From d823b79536d0d3857fcfbbe13b26cf9f204a45fb Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 21 Feb 2023 17:56:30 +0100 Subject: [PATCH 001/436] WIP refactor influence tests --- notebooks/influence_synthetic.ipynb | 34 ++- notebooks/notebook_support.py | 101 ++++++++- src/pydvl/influence/linear.py | 167 -------------- .../model_wrappers/torch_wrappers.py | 214 ------------------ src/pydvl/utils/numeric.py | 67 ------ tests/influence/conftest.py | 184 ++++++++++++++- tests/influence/test_influences.py | 144 +++++------- 7 files changed, 360 insertions(+), 551 deletions(-) delete mode 100644 src/pydvl/influence/linear.py diff --git a/notebooks/influence_synthetic.ipynb b/notebooks/influence_synthetic.ipynb index 739226324..ec0f54ae4 100644 --- a/notebooks/influence_synthetic.ipynb +++ b/notebooks/influence_synthetic.ipynb @@ -74,6 +74,7 @@ "\n", "import numpy as np\n", "import torch\n", + "from torch import nn\n", "import torch.nn.functional as F\n", "import matplotlib.pyplot as plt\n", "from pydvl.influence.general import compute_influences\n", @@ -252,6 +253,37 @@ "We will now train a logistic regression model on the training data. This can be done with the following" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "33f9cd97", + "metadata": {}, + "outputs": [], + "source": [ + "class TorchLogisticRegression(nn.Module):\n", + " \"\"\"\n", + " A simple binary logistic regression model.\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " n_input: int,\n", + " ):\n", + " \"\"\"\n", + " :param n_input: Number of feature in input.\n", + " \"\"\"\n", + " super().__init__()\n", + " self.fc1 = nn.Linear(n_input, 1, bias=True)\n", + "\n", + " def forward(self, x):\n", + " \"\"\"\n", + " :param x: Tensor [NxD] representing the features x_i.\n", + " :returns: A tensor [N] representing the probabilities for p(y_i).\n", + " \"\"\"\n", + " x = torch.as_tensor(x)\n", + " return torch.sigmoid(self.fc1(x))" + ] + }, { "cell_type": "code", "execution_count": 10, @@ -267,7 +299,7 @@ } ], "source": [ - "model = TorchBinaryLogisticRegression(num_features)\n", + "model = TorchLogisticRegression(num_features)\n", "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", "model.to(device)\n", "\n", diff --git a/notebooks/notebook_support.py b/notebooks/notebook_support.py index 0958c7c59..2dcf05ca6 100644 --- a/notebooks/notebook_support.py +++ b/notebooks/notebook_support.py @@ -1,8 +1,20 @@ +import logging import os import pickle as pkl from copy import deepcopy from pathlib import Path -from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional, Sequence, Tuple +from typing import ( + TYPE_CHECKING, + Any, + Callable, + Dict, + Iterable, + List, + Optional, + Sequence, + Tuple, + Union, +) import matplotlib.patches as mpatches import matplotlib.pyplot as plt @@ -13,11 +25,14 @@ from torch.optim import Adam from torchvision.models import ResNet18_Weights, resnet18 -from pydvl.influence.model_wrappers import TorchModel -from pydvl.utils import Dataset +from pydvl.utils import Dataset, maybe_progress try: import torch + import torch.nn as nn + from torch.optim import Optimizer + from torch.optim.lr_scheduler import _LRScheduler + from torch.utils.data import DataLoader, TensorDataset _TORCH_INSTALLED = True except ImportError: @@ -28,8 +43,73 @@ MODEL_PATH = Path().resolve().parent / "data" / "models" +logger = logging.getLogger(__name__) + + +def fit_torch_model( + model: nn.Module, + x_train: Union["NDArray[np.float_]", torch.tensor], + y_train: Union["NDArray[np.float_]", torch.tensor], + x_val: Union["NDArray[np.float_]", torch.tensor], + y_val: Union["NDArray[np.float_]", torch.tensor], + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + optimizer: Optimizer, + scheduler: Optional[_LRScheduler] = None, + num_epochs: int = 1, + batch_size: int = 64, + progress: bool = True, +) -> Tuple["NDArray[np.float_]", "NDArray[np.float_]"]: + """ + Method that fits a pytorch model to the supplied data. + It represents a simple machine learning loop, iterating over a number of + epochs, sampling data with a certain batch size, calculating gradients and updating the parameters through a + loss function. + :param x: Matrix of shape [NxD] representing the features x_i. + :param y: Matrix of shape [NxK] representing the prediction targets y_i. + :param optimizer: Select either ADAM or ADAM_W. + :param scheduler: A pytorch scheduler. If None, no scheduler is used. + :param num_epochs: Number of epochs to repeat training. + :param batch_size: Batch size to use in training. + :param progress: True, iff progress shall be printed. + :param tensor_type: accuracy of tensors. Typically 'float' or 'long' + """ + x_train = torch.as_tensor(x_train).clone() + y_train = torch.as_tensor(y_train).clone() + x_val = torch.as_tensor(x_val).clone() + y_val = torch.as_tensor(y_val).clone() + + dataset = TensorDataset(x_train, y_train) + dataloader = DataLoader(dataset, batch_size=batch_size) + train_loss = [] + val_loss = [] + + for epoch in maybe_progress(range(num_epochs), progress, desc="Model fitting"): + batch_loss = [] + for train_batch in dataloader: + batch_x, batch_y = train_batch + pred_y = model(batch_x) + loss_value = loss(torch.squeeze(pred_y), torch.squeeze(batch_y)) + batch_loss.append(loss_value.item()) + + logger.debug(f"Epoch: {epoch} ---> Training loss: {loss_value.item()}") + loss_value.backward() + optimizer.step() + optimizer.zero_grad() + + if scheduler: + scheduler.step() + pred_val = model(x_val) + epoch_val_loss = loss(torch.squeeze(pred_val), torch.squeeze(y_val)).item() + mean_epoch_train_loss = np.mean(batch_loss) + val_loss.append(epoch_val_loss) + train_loss.append(mean_epoch_train_loss) + logger.info( + f"Epoch: {epoch} ---> Training loss: {mean_epoch_train_loss}, Validation loss: {epoch_val_loss}" + ) + return np.array(train_loss), np.array(val_loss) -def new_resnet_model(output_size: int) -> TorchModel: + +def new_resnet_model(output_size: int) -> nn.Module: model = resnet18(weights=ResNet18_Weights.IMAGENET1K_V1) for param in model.parameters(): @@ -42,7 +122,7 @@ def new_resnet_model(output_size: int) -> TorchModel: device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") model.to(device) - return TorchModel(model) + return model class TrainingManager: @@ -53,7 +133,7 @@ class TrainingManager: def __init__( self, name: str, - model: TorchModel, + model: nn.Module, loss: torch.nn.modules.loss._Loss, train_x: "NDArray[np.float_]", train_y: "NDArray[np.float_]", @@ -62,17 +142,13 @@ def __init__( data_dir: Path, ): self.name = name - self.model_wrapper = model + self.model = model self.loss = loss self.train_x, self.train_y = train_x, train_y self.val_x, self.val_y = val_x, val_y self.data_dir = data_dir os.makedirs(self.data_dir, exist_ok=True) - @property - def model(self) -> nn.Module: - return self.model_wrapper.model - def train( self, n_epochs: int, @@ -93,7 +169,8 @@ def train( optimizer = Adam(self.model.parameters(), lr=lr) - training_loss, validation_loss = self.model_wrapper.fit( + training_loss, validation_loss = fit_torch_model( + model=self.model, x_train=self.train_x, y_train=self.train_y, x_val=self.val_x, diff --git a/src/pydvl/influence/linear.py b/src/pydvl/influence/linear.py deleted file mode 100644 index 5725c17f9..000000000 --- a/src/pydvl/influence/linear.py +++ /dev/null @@ -1,167 +0,0 @@ -""" -This module contains all functions for the closed form computation of influences -for standard linear regression. -""" -from typing import TYPE_CHECKING, Tuple - -import numpy as np -from sklearn.linear_model import LinearRegression - -from ..utils.numeric import ( - linear_regression_analytical_derivative_d2_theta, - linear_regression_analytical_derivative_d_theta, - linear_regression_analytical_derivative_d_x_d_theta, -) -from .general import InfluenceType - -if TYPE_CHECKING: - from numpy.typing import NDArray - -__all__ = ["compute_linear_influences"] - - -def compute_linear_influences( - x: "NDArray", - y: "NDArray", - x_test: "NDArray", - y_test: "NDArray", - influence_type: InfluenceType = InfluenceType.Up, -): - """Calculate the influence each training sample on the loss computed over a - validation set for an ordinary least squares model ($y = A x + b$ with - quadratic loss). - - :param x: An array of shape (M, K) containing the features of training data. - :param y: An array of shape (M, L) containing the targets of training data. - :param x_test: An array of shape (N, K) containing the features of the - test set. - :param y_test: An array of shape (N, L) containing the targets of the test - set. - :param influence_type: Which algorithm to use to calculate influences. - Currently supported options: 'up' or 'perturbation'. - :returns: An array of shape (B, C) with the influences of the training - points on the test data. - """ - - lr = LinearRegression() - lr.fit(x, y) - A = lr.coef_ - b = lr.intercept_ - - if influence_type not in list(InfluenceType): - raise NotImplementedError( - f"Only up-weighting and perturbation influences are supported, but got {influence_type=}" - ) - - if influence_type == InfluenceType.Up: - return influences_up_linear_regression_analytical( - (A, b), - x, - y, - x_test, - y_test, - ) - elif influence_type == InfluenceType.Perturbation: - return influences_perturbation_linear_regression_analytical( - (A, b), - x, - y, - x_test, - y_test, - ) - - -def influences_up_linear_regression_analytical( - linear_model: Tuple["NDArray", "NDArray"], - x: "NDArray", - y: "NDArray", - x_test: "NDArray", - y_test: "NDArray", -): - """Calculate the influence each training sample on the loss computed over a - validation set for an ordinary least squares model (Ax+b=y with quadratic - loss). - - This method uses the - - :param linear_model: A tuple of arrays of shapes (N, M) and N representing A - and b respectively. - :param x: An array of shape (M, K) containing the features of the - training set. - :param y: An array of shape (M, L) containing the targets of the - training set. - :param x_test: An array of shape (N, K) containing the features of the test - set. - :param y_test: An array of shape (N, L) containing the targets of the test - set. - :returns: An array of shape (B, C) with the influences of the training points - on the test points. - """ - - test_grads_analytical = linear_regression_analytical_derivative_d_theta( - linear_model, - x_test, - y_test, - ) - train_grads_analytical = linear_regression_analytical_derivative_d_theta( - linear_model, - x, - y, - ) - hessian_analytical = linear_regression_analytical_derivative_d2_theta( - linear_model, - x, - y, - ) - s_test_analytical = np.linalg.solve(hessian_analytical, test_grads_analytical.T).T - result: "NDArray" = np.einsum( - "ia,ja->ij", s_test_analytical, train_grads_analytical - ) - return result - - -def influences_perturbation_linear_regression_analytical( - linear_model: Tuple["NDArray", "NDArray"], - x: "NDArray", - y: "NDArray", - x_test: "NDArray", - y_test: "NDArray", -): - """Calculate the influences of each training sample onto the - validation set for a linear model Ax+b=y. - - :param linear_model: A tuple of np.ndarray' of shape (N, M) and (N) - representing A and b respectively. - :param x: An array of shape (M, K) containing the features of the - input data. - :param y: An array of shape (M, L) containing the targets of the input - data. - :param x_test: An array of shape (N, K) containing the features of the test - set. - :param y_test: An array of shape (N, L) containing the targets of the test - set. - :returns: An array of shape (B, C, M) with the influences of the training - points on the test points for each feature. - """ - - test_grads_analytical = linear_regression_analytical_derivative_d_theta( - linear_model, - x_test, - y_test, - ) - train_second_deriv_analytical = linear_regression_analytical_derivative_d_x_d_theta( - linear_model, - x, - y, - ) - - hessian_analytical = linear_regression_analytical_derivative_d2_theta( - linear_model, - x, - y, - ) - s_test_analytical = np.linalg.solve(hessian_analytical, test_grads_analytical.T).T - result: "NDArray" = np.einsum( - "ia,jab->ijb", s_test_analytical, train_second_deriv_analytical - ) - return result diff --git a/src/pydvl/influence/model_wrappers/torch_wrappers.py b/src/pydvl/influence/model_wrappers/torch_wrappers.py index 6aba15b16..6ba32579b 100644 --- a/src/pydvl/influence/model_wrappers/torch_wrappers.py +++ b/src/pydvl/influence/model_wrappers/torch_wrappers.py @@ -4,15 +4,10 @@ import numpy as np -from ...utils import maybe_progress - try: import torch import torch.nn as nn from torch.nn import Softmax, Tanh - from torch.optim import Optimizer - from torch.optim.lr_scheduler import _LRScheduler - from torch.utils.data import DataLoader, TensorDataset _TORCH_INSTALLED = True except ImportError: @@ -28,113 +23,6 @@ "TorchModel", ] -logger = logging.getLogger(__name__) - - -class TorchModelBase(ABC): - def __init__(self): - if not _TORCH_INSTALLED: - raise RuntimeWarning("This function requires PyTorch.") - - @abstractmethod - def forward(self, x: torch.Tensor) -> torch.Tensor: - pass - - def fit( - self, - x_train: Union["NDArray[np.float_]", torch.tensor], - y_train: Union["NDArray[np.float_]", torch.tensor], - x_val: Union["NDArray[np.float_]", torch.tensor], - y_val: Union["NDArray[np.float_]", torch.tensor], - loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], - optimizer: Optimizer, - scheduler: Optional[_LRScheduler] = None, - num_epochs: int = 1, - batch_size: int = 64, - progress: bool = True, - ) -> Tuple["NDArray[np.float_]", "NDArray[np.float_]"]: - """ - Wrapper of pytorch fit method. It fits the model to the supplied data. - It represents a simple machine learning loop, iterating over a number of - epochs, sampling data with a certain batch size, calculating gradients and updating the parameters through a - loss function. - :param x: Matrix of shape [NxD] representing the features x_i. - :param y: Matrix of shape [NxK] representing the prediction targets y_i. - :param optimizer: Select either ADAM or ADAM_W. - :param scheduler: A pytorch scheduler. If None, no scheduler is used. - :param num_epochs: Number of epochs to repeat training. - :param batch_size: Batch size to use in training. - :param progress: True, iff progress shall be printed. - :param tensor_type: accuracy of tensors. Typically 'float' or 'long' - """ - x_train = torch.as_tensor(x_train).clone() - y_train = torch.as_tensor(y_train).clone() - x_val = torch.as_tensor(x_val).clone() - y_val = torch.as_tensor(y_val).clone() - - dataset = TensorDataset(x_train, y_train) - dataloader = DataLoader(dataset, batch_size=batch_size) - train_loss = [] - val_loss = [] - - for epoch in maybe_progress(range(num_epochs), progress, desc="Model fitting"): - batch_loss = [] - for train_batch in dataloader: - batch_x, batch_y = train_batch - pred_y = self.forward(batch_x) - loss_value = loss(torch.squeeze(pred_y), torch.squeeze(batch_y)) - batch_loss.append(loss_value.item()) - - logger.debug(f"Epoch: {epoch} ---> Training loss: {loss_value.item()}") - loss_value.backward() - optimizer.step() - optimizer.zero_grad() - - if scheduler: - scheduler.step() - pred_val = self.forward(x_val) - epoch_val_loss = loss(torch.squeeze(pred_val), torch.squeeze(y_val)).item() - mean_epoch_train_loss = np.mean(batch_loss) - val_loss.append(epoch_val_loss) - train_loss.append(mean_epoch_train_loss) - logger.info( - f"Epoch: {epoch} ---> Training loss: {mean_epoch_train_loss}, Validation loss: {epoch_val_loss}" - ) - return np.array(train_loss), np.array(val_loss) - - def predict(self, x: torch.Tensor) -> "NDArray[np.float_]": - """ - Use internal model to deliver prediction in numpy. - :param x: A np.ndarray [NxD] representing the features x_i. - :returns: A np.ndarray [NxK] representing the predicted values. - """ - return self.forward(x).detach().numpy() # type: ignore - - def score( - self, - x: torch.Tensor, - y: torch.Tensor, - score: Callable[[torch.Tensor, torch.Tensor, Any], torch.Tensor], - ) -> float: - """ - Use internal model to measure how good is prediction through a loss function. - :param x: A np.ndarray [NxD] representing the features x_i. - :param y: A np.ndarray [NxK] representing the predicted target values y_i. - :returns: The aggregated value over all samples N. - """ - return score(self.forward(x), y).detach().numpy() # type: ignore - - -class TorchModel(TorchModelBase): - def __init__(self, model: nn.Module): - self.model = model - - def forward(self, x: torch.Tensor) -> torch.Tensor: - return self.model(x) - - def __call__(self, *args, **kwargs): - return self.model(*args, **kwargs) - class TorchLinearRegression(nn.Module, TorchModelBase): """ @@ -176,105 +64,3 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: :returns A tensor [NxK] representing the outputs y_i. """ return x @ self.A.T + self.b - - -class TorchBinaryLogisticRegression(nn.Module, TorchModelBase): - """ - A simple binary logistic regression model p(y)=sigmoid(dot(a, x) + b). - """ - - def __init__( - self, - n_input: int, - init: Tuple["NDArray[np.float_]", "NDArray[np.float_]"] = None, - ): - """ - :param n_input: Number of feature inputs to the BinaryLogisticRegressionModel. - :param init A tuple representing the initialization for the weight matrix A and the bias b. If set to None - sample the values uniformly using the Xavier rule. - """ - super().__init__() - self.n_input = n_input - if init is None: - init_A = np.random.normal(0, 0.02, size=(1, n_input)) - init_b = np.random.normal(0, 0.02, size=(1)) - init = (init_A, init_b) - - self.A = nn.Parameter(torch.tensor(init[0]), requires_grad=True) - self.b = nn.Parameter(torch.tensor(init[1]), requires_grad=True) - - def forward(self, x: Union["NDArray[np.float_]", torch.Tensor]) -> torch.Tensor: - """ - Calculate sigmoid(dot(a, x) + b) using RAM-optimized calculation layout. - :param x: Tensor [NxD] representing the features x_i. - :returns: A tensor [N] representing the probabilities for p(y_i). - """ - x = torch.as_tensor(x) - return torch.sigmoid(x @ self.A.T + self.b) - - -class TorchMLP(nn.Module, TorchModelBase): - """ - A simple fully-connected neural network f(x) model defined by y = v_K, v_i = o(A v_(i-1) + b), v_1 = x. It contains - K layers and K - 2 hidden layers. It holds that K >= 2, because every network contains a input and output. - """ - - def __init__( - self, - n_input: int, - n_output: int, - n_neurons_per_layer: List[int], - output_probabilities: bool = True, - init: List[Tuple["NDArray[np.float_]", "NDArray[np.float_]"]] = None, - ): - """ - :param n_input: Number of feature in input. - :param n_output: Output length. - :param n_neurons_per_layer: Each integer represents the size of a hidden layer. Overall this list has K - 2 - :param output_probabilities: True, if the model should output probabilities. In the case of n_output 2 the - number of outputs reduce to 1. - :param init: A list of tuple of np.ndarray representing the internal weights. - """ - super().__init__() - self.n_input = n_input - self.n_output = 1 if output_probabilities and n_output == 2 else n_output - - self.n_hidden_layers = n_neurons_per_layer - self.output_probabilities = output_probabilities - - all_dimensions = [self.n_input] + self.n_hidden_layers + [self.n_output] - layers = [] - num_layers = len(all_dimensions) - 1 - for num_layer, (in_features, out_features) in enumerate( - zip(all_dimensions[:-1], all_dimensions[1:]) - ): - linear_layer = nn.Linear( - in_features, out_features, bias=num_layer < len(all_dimensions) - 2 - ) - - if init is None: - torch.nn.init.xavier_uniform_(linear_layer.weight) - if num_layer < len(all_dimensions) - 2: - linear_layer.bias.data.fill_(0.01) - - else: - A, b = init[num_layer] - linear_layer.weight.data = A - if num_layer < len(all_dimensions) - 2: - linear_layer.bias.data = b - - layers.append(linear_layer) - if num_layer < num_layers - 1: - layers.append(Tanh()) - elif self.output_probabilities: - layers.append(Softmax(dim=-1)) - - self.layers = nn.Sequential(*layers) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """ - Perform forward-pass through the network. - :param x: Tensor input of shape [NxD]. - :returns: Tensor output of shape[NxK]. - """ - return self.layers(x) diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index 021de4bfa..962be12ec 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -154,73 +154,6 @@ def random_matrix_with_condition_number(n: int, condition_number: float) -> "NDA return P -def linear_regression_analytical_derivative_d_theta( - linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", y: "NDArray" -) -> "NDArray": - """ - :param linear_model: A tuple of np.ndarray' of shape [NxM] and [N] representing A and b respectively. - :param x: A np.ndarray of shape [BxM]. - :param y: A np.nparray of shape [BxN]. - :returns: A np.ndarray of shape [Bx((N+1)*M)], where each row vector is [d_theta L(x, y), d_b L(x, y)] - """ - - A, b = linear_model - n, m = list(A.shape) - residuals = x @ A.T + b - y - kron_product = np.expand_dims(residuals, axis=2) * np.expand_dims(x, axis=1) - test_grads = np.reshape(kron_product, [-1, n * m]) - full_grads = np.concatenate((test_grads, residuals), axis=1) - return full_grads / n # type: ignore - - -def linear_regression_analytical_derivative_d2_theta( - linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", y: "NDArray" -) -> "NDArray": - """ - :param linear_model: A tuple of np.ndarray' of shape [NxM] and [N] representing A and b respectively. - :param x: A np.ndarray of shape [BxM], - :param y: A np.nparray of shape [BxN]. - :returns: A np.ndarray of shape [((N+1)*M)x((N+1)*M)], representing the Hessian. It gets averaged over all samples. - """ - A, b = linear_model - n, m = tuple(A.shape) - d2_theta = np.einsum("ia,ib->iab", x, x) - d2_theta = np.mean(d2_theta, axis=0) - d2_theta = np.kron(np.eye(n), d2_theta) - d2_b = np.eye(n) - mean_x = np.mean(x, axis=0, keepdims=True) - d_theta_d_b = np.kron(np.eye(n), mean_x) - top_matrix = np.concatenate((d2_theta, d_theta_d_b.T), axis=1) - bottom_matrix = np.concatenate((d_theta_d_b, d2_b), axis=1) - full_matrix = np.concatenate((top_matrix, bottom_matrix), axis=0) - return full_matrix / n # type: ignore - - -def linear_regression_analytical_derivative_d_x_d_theta( - linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", y: "NDArray" -) -> "NDArray": - """ - :param linear_model: A tuple of np.ndarray of shape [NxM] and [N] representing A and b respectively. - :param x: A np.ndarray of shape [BxM]. - :param y: A np.nparray of shape [BxN]. - :returns: A np.ndarray of shape [Bx((N+1)*M)xM], representing the derivative. - """ - - A, b = linear_model - N, M = tuple(A.shape) - residuals = x @ A.T + b - y - B = len(x) - outer_product_matrix = np.einsum("ab,ic->iacb", A, x) - outer_product_matrix = np.reshape(outer_product_matrix, [B, M * N, M]) - tiled_identity = np.tile(np.expand_dims(np.eye(M), axis=0), [B, N, 1]) - outer_product_matrix += tiled_identity * np.expand_dims( - np.repeat(residuals, M, axis=1), axis=2 - ) - b_part_derivative = np.tile(np.expand_dims(A, axis=0), [B, 1, 1]) - full_derivative = np.concatenate((outer_product_matrix, b_part_derivative), axis=1) - return full_derivative / N # type: ignore - - # FIXME: FloatOrArray doesn't really work def running_moments( previous_avg: FloatOrArray, diff --git a/tests/influence/conftest.py b/tests/influence/conftest.py index 0174cfa6a..3efb684b8 100644 --- a/tests/influence/conftest.py +++ b/tests/influence/conftest.py @@ -1,4 +1,4 @@ -from typing import TYPE_CHECKING, Tuple +from typing import TYPE_CHECKING, List, Tuple import numpy as np import pytest @@ -6,6 +6,12 @@ from pydvl.utils import Dataset, random_matrix_with_condition_number +try: + import torch + from torch import nn +except ImportError: + pass + if TYPE_CHECKING: from numpy.typing import NDArray @@ -75,6 +81,182 @@ def linear_model(problem_dimension: Tuple[int, int], condition_number: float): return A, b +class TorchSimpleNN(nn.Module): + """ + Creates a simple pytorch neural network. It needs input features, number of layers + """ + + def __init__( + self, + n_input: int, + n_hidden_layers: int, + n_neurons_per_layer: List[int], + output_layer: nn.Module, + init: List[Tuple["NDArray[np.float_]", "NDArray[np.float_]"]] = None, + ): + """ + :param n_input: Number of feature in input. + :param n_output: Output length. + :param n_neurons_per_layer: Each integer represents the size of a hidden + layer. Overall this list has K - 2 + :param output_layer: output layer of the neural network + number of outputs reduce to 1. + :param init: A list of tuple of np.ndarray representing the internal weights. + """ + super().__init__() + + layers = [nn.Linear(n_input, n_neurons_per_layer)] + for num_layer in range(n_hidden_layers): + linear_layer = nn.Linear(n_neurons_per_layer, n_neurons_per_layer) + + if init is not None: + A, b = init[num_layer] + linear_layer.weight.data = A + linear_layer.bias.data = b + + layers.append(linear_layer) + layers.append(output_layer) + + self.layers = nn.Sequential(*layers) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """ + Perform forward-pass through the network. + :param x: Tensor input of shape [NxD]. + :returns: Tensor output of shape[NxK]. + """ + return self.layers(x) + + +def linear_regression_analytical_derivative_d_theta( + linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", y: "NDArray" +) -> "NDArray": + """ + :param linear_model: A tuple of np.ndarray' of shape [NxM] and [N] representing A and b respectively. + :param x: A np.ndarray of shape [BxM]. + :param y: A np.nparray of shape [BxN]. + :returns: A np.ndarray of shape [Bx((N+1)*M)], where each row vector is [d_theta L(x, y), d_b L(x, y)] + """ + + A, b = linear_model + n, m = list(A.shape) + residuals = x @ A.T + b - y + kron_product = np.expand_dims(residuals, axis=2) * np.expand_dims(x, axis=1) + test_grads = np.reshape(kron_product, [-1, n * m]) + full_grads = np.concatenate((test_grads, residuals), axis=1) + return full_grads / n # type: ignore + + +def linear_regression_analytical_derivative_d2_theta( + linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", y: "NDArray" +) -> "NDArray": + """ + :param linear_model: A tuple of np.ndarray' of shape [NxM] and [N] representing A and b respectively. + :param x: A np.ndarray of shape [BxM], + :param y: A np.nparray of shape [BxN]. + :returns: A np.ndarray of shape [((N+1)*M)x((N+1)*M)], representing the Hessian. It gets averaged over all samples. + """ + A, b = linear_model + n, m = tuple(A.shape) + d2_theta = np.einsum("ia,ib->iab", x, x) + d2_theta = np.mean(d2_theta, axis=0) + d2_theta = np.kron(np.eye(n), d2_theta) + d2_b = np.eye(n) + mean_x = np.mean(x, axis=0, keepdims=True) + d_theta_d_b = np.kron(np.eye(n), mean_x) + top_matrix = np.concatenate((d2_theta, d_theta_d_b.T), axis=1) + bottom_matrix = np.concatenate((d_theta_d_b, d2_b), axis=1) + full_matrix = np.concatenate((top_matrix, bottom_matrix), axis=0) + return full_matrix / n # type: ignore + + +def linear_regression_analytical_derivative_d_x_d_theta( + linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", y: "NDArray" +) -> "NDArray": + """ + :param linear_model: A tuple of np.ndarray of shape [NxM] and [N] representing A and b respectively. + :param x: A np.ndarray of shape [BxM]. + :param y: A np.nparray of shape [BxN]. + :returns: A np.ndarray of shape [Bx((N+1)*M)xM], representing the derivative. + """ + + A, b = linear_model + N, M = tuple(A.shape) + residuals = x @ A.T + b - y + B = len(x) + outer_product_matrix = np.einsum("ab,ic->iacb", A, x) + outer_product_matrix = np.reshape(outer_product_matrix, [B, M * N, M]) + tiled_identity = np.tile(np.expand_dims(np.eye(M), axis=0), [B, N, 1]) + outer_product_matrix += tiled_identity * np.expand_dims( + np.repeat(residuals, M, axis=1), axis=2 + ) + b_part_derivative = np.tile(np.expand_dims(A, axis=0), [B, 1, 1]) + full_derivative = np.concatenate((outer_product_matrix, b_part_derivative), axis=1) + return full_derivative / N # type: ignore + + +def analytical_linear_influences( + linear_model: Tuple["NDArray", "NDArray"], + x: "NDArray", + y: "NDArray", + x_test: "NDArray", + y_test: "NDArray", + influence_type: InfluenceType = InfluenceType.Up, +): + """Calculates analytically the influence of each training sample on the + test samples for an ordinary least squares model (Ax+b=y with quadratic + loss). + + :param linear_model: A tuple of arrays of shapes (N, M) and N representing A + and b respectively. + :param x: An array of shape (M, K) containing the features of the + training set. + :param y: An array of shape (M, L) containing the targets of the + training set. + :param x_test: An array of shape (N, K) containing the features of the test + set. + :param y_test: An array of shape (N, L) containing the targets of the test + set. + :param influence_type: the type of the influence. + :returns: An array of shape (B, C) with the influences of the training points + on the test points if influence_type is "up", an array of shape (K, L, + M) if influence_type is "perturbation". + """ + + test_grads_analytical = linear_regression_analytical_derivative_d_theta( + linear_model, + x_test, + y_test, + ) + hessian_analytical = linear_regression_analytical_derivative_d2_theta( + linear_model, + x, + y, + ) + s_test_analytical = np.linalg.solve(hessian_analytical, test_grads_analytical.T).T + if influence_type == "up": + train_grads_analytical = linear_regression_analytical_derivative_d_theta( + linear_model, + x, + y, + ) + result: "NDArray" = np.einsum( + "ia,ja->ij", s_test_analytical, train_grads_analytical + ) + elif influence_type == "perturbation": + train_second_deriv_analytical = ( + linear_regression_analytical_derivative_d_x_d_theta( + linear_model, + x, + y, + ) + ) + result: "NDArray" = np.einsum( + "ia,jab->ijb", s_test_analytical, train_second_deriv_analytical + ) + return result + + def create_mock_dataset( linear_model: Tuple["NDArray[np.float_]", "NDArray[np.float_]"], train_set_size: int, diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 932ec8c86..5c11f6996 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -4,18 +4,18 @@ import numpy as np import pytest +from pydvl.utils.numeric import ( + linear_regression_analytical_derivative_d2_theta, + linear_regression_analytical_derivative_d_theta, + linear_regression_analytical_derivative_d_x_d_theta, +) + from .conftest import create_mock_dataset try: import torch.nn.functional as F - from torch.optim import Adam, lr_scheduler - from pydvl.influence.general import compute_influences - from pydvl.influence.linear import ( - compute_linear_influences, - influences_perturbation_linear_regression_analytical, - influences_up_linear_regression_analytical, - ) + from pydvl.influence.general import InfluenceType, compute_influences from pydvl.influence.model_wrappers import TorchLinearRegression, TorchMLP from pydvl.utils.dataset import load_wine_dataset except ImportError: @@ -61,6 +61,53 @@ def lmb_test_case_to_str(packed_i_test_case): test_case_ids = list(map(lmb_test_case_to_str, zip(range(len(test_cases)), test_cases))) +def influences_perturbation_linear_regression_analytical( + linear_model: Tuple["NDArray", "NDArray"], + x: "NDArray", + y: "NDArray", + x_test: "NDArray", + y_test: "NDArray", +): + """Calculate the influences of each training sample onto the + validation set for a linear model Ax+b=y. + + :param linear_model: A tuple of np.ndarray' of shape (N, M) and (N) + representing A and b respectively. + :param x: An array of shape (M, K) containing the features of the + input data. + :param y: An array of shape (M, L) containing the targets of the input + data. + :param x_test: An array of shape (N, K) containing the features of the test + set. + :param y_test: An array of shape (N, L) containing the targets of the test + set. + :returns: An array of shape (B, C, M) with the influences of the training + points on the test points for each feature. + """ + + test_grads_analytical = linear_regression_analytical_derivative_d_theta( + linear_model, + x_test, + y_test, + ) + train_second_deriv_analytical = linear_regression_analytical_derivative_d_x_d_theta( + linear_model, + x, + y, + ) + + hessian_analytical = linear_regression_analytical_derivative_d2_theta( + linear_model, + x, + y, + ) + s_test_analytical = np.linalg.solve(hessian_analytical, test_grads_analytical.T).T + result: "NDArray" = np.einsum( + "ia,jab->ijb", s_test_analytical, train_second_deriv_analytical + ) + return result + + @pytest.mark.torch @pytest.mark.parametrize( "train_set_size,test_set_size,problem_dimension,condition_number,n_jobs", @@ -210,17 +257,14 @@ def test_perturbation_influences_lr_analytical_cg( @pytest.mark.torch @pytest.mark.parametrize( - "train_set_size,test_set_size,problem_dimension,condition_number,n_jobs", + "train_set_size,test_set_size", test_cases, ids=test_case_ids, ) def test_perturbation_influences_lr_analytical( train_set_size: int, test_set_size: int, - problem_dimension: int, - condition_number: float, linear_model: Tuple[np.ndarray, np.ndarray], - n_jobs: int, ): train_data, test_data = create_mock_dataset( linear_model, train_set_size, test_set_size @@ -258,81 +302,3 @@ def test_perturbation_influences_lr_analytical( assert ( influences_max_abs_diff < InfluenceTestSettings.ACCEPTABLE_ABS_TOL_INFLUENCE ), "Perturbation influence values were wrong." - - -@pytest.mark.torch -@pytest.mark.parametrize( - "train_set_size,test_set_size,problem_dimension,condition_number", - itertools.product( - InfluenceTestSettings.INFLUENCE_TRAINING_SET_SIZE, - InfluenceTestSettings.INFLUENCE_TEST_SET_SIZE, - InfluenceTestSettings.INFLUENCE_DIMENSIONS, - InfluenceTestSettings.INFLUENCE_TEST_CONDITION_NUMBERS, - ), -) -def test_linear_influences_up_perturbations_analytical( - train_set_size: int, - test_set_size: int, - problem_dimension: int, - condition_number: float, - linear_model: Tuple[np.ndarray, np.ndarray], -): - train_data, test_data = create_mock_dataset( - linear_model, train_set_size, test_set_size - ) - up_influences = compute_linear_influences( - *train_data, - *test_data, - influence_type="up", - ) - assert np.logical_not(np.any(np.isnan(up_influences))) - assert up_influences.shape == (len(test_data[0]), len(train_data[0])) - - pert_influences = compute_linear_influences( - *train_data, - *test_data, - influence_type="perturbation", - ) - assert np.logical_not(np.any(np.isnan(pert_influences))) - assert pert_influences.shape == ( - len(test_data[0]), - len(train_data[0]), - train_data[0].shape[1], - ) - - -@pytest.mark.torch -def test_influences_with_neural_network_explicit_hessian(): - train_ds, val_ds, test_ds, feature_names = load_wine_dataset( - train_size=0.3, test_size=0.6 - ) - feature_dimension = train_ds[0].shape[1] - unique_classes = np.unique(np.concatenate((train_ds[1], test_ds[1]))) - num_classes = len(unique_classes) - num_epochs = 300 - network_size = [16, 16] - nn = TorchMLP(feature_dimension, num_classes, network_size) - optimizer = Adam(params=nn.parameters(), lr=0.001, weight_decay=0.001) - loss = F.cross_entropy - nn.fit( - *train_ds, - *test_ds, - num_epochs=num_epochs, - batch_size=32, - loss=loss, - optimizer=optimizer, - scheduler=lr_scheduler.CosineAnnealingLR(optimizer, T_max=num_epochs), - ) - - model = nn - loss = loss - - train_influences = compute_influences( - model, - loss, - *train_ds, - *test_ds, - inversion_method="direct", - ) - - assert np.all(np.logical_not(np.isnan(train_influences))) From b9cbf02125c6080b6246c4197e8eb91af4e5bf6f Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 22 Feb 2023 18:17:56 +0100 Subject: [PATCH 002/436] refactor test_influences --- src/pydvl/influence/conjugate_gradient.py | 229 -------------- src/pydvl/influence/general.py | 29 +- src/pydvl/influence/inversion_methods.py | 50 +++ .../influence/model_wrappers/__init__.py | 7 - .../model_wrappers/torch_wrappers.py | 66 ---- src/pydvl/utils/numeric.py | 3 - tests/influence/conftest.py | 99 +++--- tests/influence/test_conjugate_gradients.py | 110 ------- tests/influence/test_influences.py | 286 ++++-------------- 9 files changed, 150 insertions(+), 729 deletions(-) delete mode 100644 src/pydvl/influence/conjugate_gradient.py create mode 100644 src/pydvl/influence/inversion_methods.py delete mode 100644 src/pydvl/influence/model_wrappers/__init__.py delete mode 100644 src/pydvl/influence/model_wrappers/torch_wrappers.py delete mode 100644 tests/influence/test_conjugate_gradients.py diff --git a/src/pydvl/influence/conjugate_gradient.py b/src/pydvl/influence/conjugate_gradient.py deleted file mode 100644 index 20f5ddc4b..000000000 --- a/src/pydvl/influence/conjugate_gradient.py +++ /dev/null @@ -1,229 +0,0 @@ -""" -Contains - -- batched conjugate gradient. -- error bound for conjugate gradient. -""" -import logging -import warnings -from typing import TYPE_CHECKING, Callable, Optional, Tuple, Union - -import numpy as np -from scipy.sparse.linalg import cg - -from ..utils import maybe_progress -from .types import MatrixVectorProduct - -if TYPE_CHECKING: - from numpy.typing import NDArray - -__all__ = ["conjugate_gradient", "batched_preconditioned_conjugate_gradient"] - -logger = logging.getLogger(__name__) - - -def conjugate_gradient( - A: "NDArray[np.float_]", batch_y: "NDArray[np.float_]", progress: bool = False -) -> "NDArray[np.float_]": - """ - Given a matrix and a batch of vectors, it uses conjugate gradient to calculate the solution - to Ax = y for each y in batch_y. - - :param A: a real, symmetric and positive-definite matrix of shape [NxN] - :param batch_y: a matrix of shape [NxP], with P the size of the batch. - :param progress: True, iff progress shall be printed. - - :return: A NDArray of shape [NxP] representing x, the solution of Ax=b. - """ - batch_cg = [] - for y in maybe_progress(batch_y, progress, desc="Conjugate gradient"): - y_cg, _ = cg(A, y) - batch_cg.append(y_cg) - return np.asarray(batch_cg) - - -def batched_preconditioned_conjugate_gradient( - A: Union["NDArray", Callable[["NDArray"], "NDArray"]], - b: "NDArray", - x0: Optional["NDArray"] = None, - rtol: float = 1e-3, - max_iterations: int = 100, - max_step_size: Optional[float] = None, -) -> Tuple["NDArray", int]: - """ - Implementation of a batched conjugate gradient algorithm. It uses vector matrix products for efficient calculation. - On top of that, it constrains the maximum step size. - - See [1]_ for more details on the algorithm. - - See also [2]_ and [3]_. - - .. warning:: - - This function is experimental and unstable. Prefer using inversion_method='cg' - - :param A: A linear function f : R[k] -> R[k] representing a matrix vector product from dimension K to K or a matrix. \ - It has to be positive-definite v.T @ f(v) >= 0. - :param b: A NDArray of shape [K] representing the targeted result of the matrix multiplication Ax. - :param max_iterations: Maximum number of iterations to use in conjugate gradient. Default is 10 times K. - :param rtol: Relative tolerance of the residual with respect to the 2-norm of b. - :param max_step_size: Maximum step size along a gradient direction. Might be necessary for numerical stability. \ - See also max_iterations. Default is 10.0. - :param verify_assumptions: True, iff the matrix should be checked for positive-definiteness by a stochastic rule. - - :return: A NDArray of shape [K] representing the solution of Ax=b. - - .. note:: - .. [1] `Conjugate Gradient Method - Wikipedia `_. - .. [2] `SciPy's implementation of Conjugate Gradient `_. - .. [3] `Prof. Mert Pilanci., "Conjugate Gradient Method", Stanford University, 2022 `_. - """ - warnings.warn( - "This function is experimental and unstable. Prefer using inversion_method='cg'", - UserWarning, - ) - # wrap A into a function. - if not callable(A): - new_A = np.copy(A) - A = lambda v: v @ new_A.T # type: ignore - M = hvp_to_inv_diag_conditioner(A, d=b.shape[1]) - - k = A(b).shape[0] - if A(b).size == 0: - return b, 0 - - if b.ndim == 1: - b = b.reshape([1, -1]) - - if max_iterations is None: - max_iterations = 10 * k - - # start with residual - if x0 is not None: - x = np.copy(x0) - elif M is not None: - x = M(b) - else: - x = np.copy(b) - - r = b - A(x) - u = np.copy(r) - - if M is not None: - u = M(u) - - p = np.copy(b) - - if x.ndim == 1: - x = x.reshape([1, -1]) - - iteration = 0 - batch_dim = b.shape[0] - converged = np.zeros(batch_dim, dtype=bool) - atol = np.linalg.norm(b, axis=1) * rtol - - while iteration < max_iterations: - - # remaining fields - iteration += 1 - not_yet_converged_indices = np.argwhere(np.logical_not(converged))[:, 0] - mvp = A(p)[not_yet_converged_indices] - p_dot_mvp = np.einsum("ia,ia->i", p[not_yet_converged_indices], mvp) - r_dot_u = np.einsum( - "ia,ia->i", r[not_yet_converged_indices], u[not_yet_converged_indices] - ) - alpha = r_dot_u / p_dot_mvp - if max_step_size is not None: - alpha = np.minimum(max_step_size, alpha) - - # update x and r - reshaped_alpha = alpha.reshape([-1, 1]) - x[not_yet_converged_indices] += reshaped_alpha * p[not_yet_converged_indices] - r[not_yet_converged_indices] -= reshaped_alpha * mvp - - # calculate next conjugate gradient - new_u = r - if M is not None: - new_u = M(new_u) - - new_u = new_u[not_yet_converged_indices] - new_r_dot_u = np.einsum("ia,ia->i", r[not_yet_converged_indices], new_u) - - if rtol is not None: - residual = np.linalg.norm( - A(x)[not_yet_converged_indices] - b[not_yet_converged_indices], - axis=1, - ) - converged[not_yet_converged_indices] = ( - residual <= atol[not_yet_converged_indices] - ) - - if np.all(converged): - break - - beta = new_r_dot_u / r_dot_u - p[not_yet_converged_indices] = ( - beta.reshape([-1, 1]) * p[not_yet_converged_indices] + new_u - ) - u[not_yet_converged_indices] = new_u - - if not np.all(converged): - percentage_converged = int(converged.sum() / len(converged)) * 100 - msg = ( - f"Converged vectors are only {percentage_converged}%. " - "Please increase max_iterations, decrease max_step_size " - "and make sure that A is positive definite" - " (e.g. through regularization)." - ) - warnings.warn(msg, RuntimeWarning) - return x, iteration - - -def conjugate_gradient_condition_number_based_error_bound( - A: "NDArray", n: int, x0: "NDArray", xt: "NDArray" -) -> float: - """ - Error bound for conjugate gradient based on the condition number of the weight matrix A. Used for testing purposes. - See also https://math.stackexchange.com/questions/382958/error-for-conjugate-gradient-method. Explicit of the weight - matrix is required. - :param A: Weight matrix of the matrix to be inverted. - :param n: Maximum number for executed iterations X in conjugate gradient. - :param x0: Initialization solution x0 of conjugate gradient. - :param xt: Final solution xt of conjugate gradient after X iterations. - :returns: Upper bound for ||x0 - xt||_A. - """ - eigvals = np.linalg.eigvals(A) - eigvals = np.sort(eigvals) - eig_val_max = np.max(eigvals) - eig_val_min = np.min(eigvals) - kappa = np.abs(eig_val_max / eig_val_min) - norm_A = lambda v: np.sqrt(np.einsum("ia,ab,ib->i", v, A, v)) - error_init: float = norm_A(xt - x0) - - sqrt_kappa = np.sqrt(kappa) - div = (sqrt_kappa + 1) / (sqrt_kappa - 1) - div_n = div**n - return (2 * error_init) / (div_n + 1 / div_n) # type: ignore - - -def hvp_to_inv_diag_conditioner( - hvp: MatrixVectorProduct, d: int -) -> MatrixVectorProduct: - """ - This method uses the hvp function to construct a simple pre-conditioner 1/diag(H). It does so while requiring - only O(d) space in RAM for construction and later execution. - :param hvp: The callable calculating the Hessian vector product Hv. - :param d: The number of dimensions of the hvp callable. - :returns: A MatrixVectorProduct for the conditioner. - """ - diags = np.empty(d) - - for i in range(d): - inp = np.zeros(d) - inp[i] = 1 - diags[i] = hvp(np.reshape(inp, [1, -1]))[0, i] - - def _inv_diag_conditioner(v: "NDArray"): - return v / diags - - return _inv_diag_conditioner diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index c7c7786de..49f4bd54f 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -8,11 +8,8 @@ from scipy.sparse.linalg import LinearOperator from ..utils import maybe_progress -from .conjugate_gradient import ( - batched_preconditioned_conjugate_gradient, - conjugate_gradient, -) from .frameworks import TorchTwiceDifferentiable +from .inversion_methods import InversionMethod, conjugate_gradient from .types import MatrixVectorProductInversionAlgorithm, TwiceDifferentiable try: @@ -39,16 +36,6 @@ class InfluenceType(str, Enum): Perturbation = "perturbation" -class InversionMethod(str, Enum): - """ - Different inversion methods types. - """ - - Direct = "direct" - Cg = "cg" - BatchedCg = "batched_cg" - - def calculate_influence_factors( model: TwiceDifferentiable, x: "NDArray", @@ -155,7 +142,6 @@ def compute_influences( progress: bool = False, inversion_method: InversionMethod = InversionMethod.Direct, influence_type: InfluenceType = InfluenceType.Up, - inversion_method_kwargs: Optional[Dict] = None, hessian_regularization: float = 0, ) -> "NDArray": """ @@ -176,12 +162,6 @@ def compute_influences( (and explicit construction of the Hessian) or 'cg' for conjugate gradient. :param influence_type: Which algorithm to use to calculate influences. Currently supported options: 'up' or 'perturbation'. For details refer to https://arxiv.org/pdf/1703.04730.pdf - :param inversion_method_kwargs: kwargs for the inversion method selected. - If using the direct method no kwargs are needed. If inversion_method='cg', the following kwargs can be passed: - - rtol: relative tolerance to be achieved before terminating computation - - max_iterations: maximum conjugate gradient iterations - - max_step_size: step size of conjugate gradient - - verify_assumptions: True to run tests on convexity of the model. :param hessian_regularization: lambda to use in Hessian regularization, i.e. H_reg = H + lambda * 1, with 1 the identity matrix \ and H the (simple and regularized) Hessian. Typically used with more complex models to make sure the Hessian \ is positive definite. @@ -192,18 +172,11 @@ def compute_influences( if not _TORCH_INSTALLED: raise RuntimeWarning("This function requires PyTorch.") - if inversion_method_kwargs is None: - inversion_method_kwargs = dict() differentiable_model = TorchTwiceDifferentiable(model, loss) n_params = differentiable_model.num_params() dict_fact_algos: Dict[Optional[str], MatrixVectorProductInversionAlgorithm] = { "direct": lambda hvp, x: np.linalg.solve(hvp(np.eye(n_params)), x.T).T, # type: ignore "cg": lambda hvp, x: conjugate_gradient(LinearOperator((n_params, n_params), matvec=hvp), x, progress), # type: ignore - "batched_cg": lambda hvp, x: batched_preconditioned_conjugate_gradient( # type: ignore - hvp, x, **inversion_method_kwargs - )[ - 0 - ], } influence_factors = calculate_influence_factors( diff --git a/src/pydvl/influence/inversion_methods.py b/src/pydvl/influence/inversion_methods.py new file mode 100644 index 000000000..4d8229cdb --- /dev/null +++ b/src/pydvl/influence/inversion_methods.py @@ -0,0 +1,50 @@ +""" +Contains + +- batched conjugate gradient. +- error bound for conjugate gradient. +""" +import logging +from enum import Enum +from typing import TYPE_CHECKING + +import numpy as np +from scipy.sparse.linalg import cg + +from ..utils import maybe_progress + +if TYPE_CHECKING: + from numpy.typing import NDArray + +__all__ = ["conjugate_gradient", "batched_preconditioned_conjugate_gradient"] + +logger = logging.getLogger(__name__) + + +class InversionMethod(str, Enum): + """ + Different inversion methods types. + """ + + Direct = "direct" + Cg = "cg" + + +def conjugate_gradient( + A: "NDArray[np.float_]", batch_y: "NDArray[np.float_]", progress: bool = False +) -> "NDArray[np.float_]": + """ + Given a matrix and a batch of vectors, it uses conjugate gradient to calculate the solution + to Ax = y for each y in batch_y. + + :param A: a real, symmetric and positive-definite matrix of shape [NxN] + :param batch_y: a matrix of shape [NxP], with P the size of the batch. + :param progress: True, iff progress shall be printed. + + :return: A NDArray of shape [NxP] representing x, the solution of Ax=b. + """ + batch_cg = [] + for y in maybe_progress(batch_y, progress, desc="Conjugate gradient"): + y_cg, _ = cg(A, y, atol="legacy") + batch_cg.append(y_cg) + return np.asarray(batch_cg) diff --git a/src/pydvl/influence/model_wrappers/__init__.py b/src/pydvl/influence/model_wrappers/__init__.py deleted file mode 100644 index 4397c4664..000000000 --- a/src/pydvl/influence/model_wrappers/__init__.py +++ /dev/null @@ -1,7 +0,0 @@ -from .torch_wrappers import * - -__all__ = [ - "TorchLinearRegression", - "TorchBinaryLogisticRegression", - "TorchMLP", -] diff --git a/src/pydvl/influence/model_wrappers/torch_wrappers.py b/src/pydvl/influence/model_wrappers/torch_wrappers.py deleted file mode 100644 index 6ba32579b..000000000 --- a/src/pydvl/influence/model_wrappers/torch_wrappers.py +++ /dev/null @@ -1,66 +0,0 @@ -import logging -from abc import ABC, abstractmethod -from typing import TYPE_CHECKING, Any, Callable, List, Optional, Tuple, Union - -import numpy as np - -try: - import torch - import torch.nn as nn - from torch.nn import Softmax, Tanh - - _TORCH_INSTALLED = True -except ImportError: - _TORCH_INSTALLED = False - -if TYPE_CHECKING: - from numpy.typing import NDArray - -__all__ = [ - "TorchLinearRegression", - "TorchBinaryLogisticRegression", - "TorchMLP", - "TorchModel", -] - - -class TorchLinearRegression(nn.Module, TorchModelBase): - """ - A simple linear regression model (with bias) f(x)=Ax+b. - """ - - def __init__( - self, - n_input: int, - n_output: int, - init: Tuple["NDArray[np.float_]", "NDArray[np.float_]"] = None, - ): - """ - :param n_input: input to the model. - :param n_output: output of the model - :param init A tuple with two matrices, namely A of shape [K, D] and b of shape [K]. If set to None Xavier - uniform initialization is used. - """ - super().__init__() - self.n_input = n_input - self.n_output = n_output - if init is None: - r = np.sqrt(6 / (n_input + n_output)) - init_A = np.random.uniform(-r, r, size=[n_output, n_input]) - init_b = np.zeros(n_output) - init = (init_A, init_b) - - self.A = nn.Parameter( - torch.tensor(init[0], dtype=torch.float64), requires_grad=True - ) - self.b = nn.Parameter( - torch.tensor(init[1], dtype=torch.float64), requires_grad=True - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """ - Calculate A @ x + b using RAM-optimized calculation layout. - :param x: Tensor [NxD] representing the features x_i. - :returns A tensor [NxK] representing the outputs y_i. - """ - return x @ self.A.T + self.b diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index 962be12ec..8942bbddf 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -14,9 +14,6 @@ __all__ = [ "running_moments", - "linear_regression_analytical_derivative_d2_theta", - "linear_regression_analytical_derivative_d_theta", - "linear_regression_analytical_derivative_d_x_d_theta", "num_samples_permutation_hoeffding", "powerset", "random_matrix_with_condition_number", diff --git a/tests/influence/conftest.py b/tests/influence/conftest.py index 3efb684b8..6e722b277 100644 --- a/tests/influence/conftest.py +++ b/tests/influence/conftest.py @@ -4,6 +4,7 @@ import pytest from sklearn.preprocessing import MinMaxScaler +from pydvl.influence.general import InfluenceType from pydvl.utils import Dataset, random_matrix_with_condition_number try: @@ -41,36 +42,6 @@ def condition_number(request) -> float: return request.param -@pytest.fixture(scope="function") -def quadratic_linear_equation_system(quadratic_matrix: np.ndarray, batch_size: int): - A = quadratic_matrix - problem_dimension = A.shape[0] - b = np.random.random([batch_size, problem_dimension]) - return A, b - - -@pytest.fixture(scope="function") -def quadratic_matrix(problem_dimension: int, condition_number: float): - return random_matrix_with_condition_number(problem_dimension, condition_number) - - -@pytest.fixture(scope="function") -def singular_quadratic_linear_equation_system( - quadratic_matrix: np.ndarray, batch_size: int -): - A = quadratic_matrix - problem_dimension = A.shape[0] - i, j = tuple(np.random.choice(problem_dimension, replace=False, size=2)) - if j < i: - i, j = j, i - - v = (A[i] + A[j]) / 2 - A[i], A[j] = v, v - b = np.random.random([batch_size, problem_dimension]) - return A, b - - -@pytest.fixture(scope="function") def linear_model(problem_dimension: Tuple[int, int], condition_number: float): output_dimension, input_dimension = problem_dimension A = random_matrix_with_condition_number( @@ -128,7 +99,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: return self.layers(x) -def linear_regression_analytical_derivative_d_theta( +def linear_derivative_analytical( linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", y: "NDArray" ) -> "NDArray": """ @@ -144,16 +115,19 @@ def linear_regression_analytical_derivative_d_theta( kron_product = np.expand_dims(residuals, axis=2) * np.expand_dims(x, axis=1) test_grads = np.reshape(kron_product, [-1, n * m]) full_grads = np.concatenate((test_grads, residuals), axis=1) - return full_grads / n # type: ignore + return 2 * full_grads / n # type: ignore -def linear_regression_analytical_derivative_d2_theta( - linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", y: "NDArray" +def linear_hessian_analytical( + linear_model: Tuple["NDArray", "NDArray"], + x: "NDArray", + lam: float, ) -> "NDArray": """ :param linear_model: A tuple of np.ndarray' of shape [NxM] and [N] representing A and b respectively. :param x: A np.ndarray of shape [BxM], :param y: A np.nparray of shape [BxN]. + :param lam: hessian regularization parameter :returns: A np.ndarray of shape [((N+1)*M)x((N+1)*M)], representing the Hessian. It gets averaged over all samples. """ A, b = linear_model @@ -167,10 +141,10 @@ def linear_regression_analytical_derivative_d2_theta( top_matrix = np.concatenate((d2_theta, d_theta_d_b.T), axis=1) bottom_matrix = np.concatenate((d_theta_d_b, d2_b), axis=1) full_matrix = np.concatenate((top_matrix, bottom_matrix), axis=0) - return full_matrix / n # type: ignore + return 2 * full_matrix / n + lam * np.identity(len(full_matrix)) # type: ignore -def linear_regression_analytical_derivative_d_x_d_theta( +def linear_mixed_second_derivative_analytical( linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", y: "NDArray" ) -> "NDArray": """ @@ -192,7 +166,28 @@ def linear_regression_analytical_derivative_d_x_d_theta( ) b_part_derivative = np.tile(np.expand_dims(A, axis=0), [B, 1, 1]) full_derivative = np.concatenate((outer_product_matrix, b_part_derivative), axis=1) - return full_derivative / N # type: ignore + return 2 * full_derivative / N # type: ignore + + +def linear_analytical_influence_factors( + linear_model: Tuple["NDArray", "NDArray"], + x: "NDArray", + y: "NDArray", + x_test: "NDArray", + y_test: "NDArray", + hessian_regularization: float = 0, +) -> "NDArray": + test_grads_analytical = linear_derivative_analytical( + linear_model, + x_test, + y_test, + ) + hessian_analytical = linear_hessian_analytical( + linear_model, + x, + hessian_regularization, + ) + return np.linalg.solve(hessian_analytical, test_grads_analytical.T).T def analytical_linear_influences( @@ -202,6 +197,7 @@ def analytical_linear_influences( x_test: "NDArray", y_test: "NDArray", influence_type: InfluenceType = InfluenceType.Up, + hessian_regularization: float = 0, ): """Calculates analytically the influence of each training sample on the test samples for an ordinary least squares model (Ax+b=y with quadratic @@ -218,24 +214,17 @@ def analytical_linear_influences( :param y_test: An array of shape (N, L) containing the targets of the test set. :param influence_type: the type of the influence. + :param hessian_retularization: regularization value for the hessian :returns: An array of shape (B, C) with the influences of the training points on the test points if influence_type is "up", an array of shape (K, L, M) if influence_type is "perturbation". """ - test_grads_analytical = linear_regression_analytical_derivative_d_theta( - linear_model, - x_test, - y_test, + s_test_analytical = linear_analytical_influence_factors( + linear_model, x, y, x_test, y_test, hessian_regularization ) - hessian_analytical = linear_regression_analytical_derivative_d2_theta( - linear_model, - x, - y, - ) - s_test_analytical = np.linalg.solve(hessian_analytical, test_grads_analytical.T).T - if influence_type == "up": - train_grads_analytical = linear_regression_analytical_derivative_d_theta( + if influence_type == InfluenceType.Up: + train_grads_analytical = linear_derivative_analytical( linear_model, x, y, @@ -243,13 +232,11 @@ def analytical_linear_influences( result: "NDArray" = np.einsum( "ia,ja->ij", s_test_analytical, train_grads_analytical ) - elif influence_type == "perturbation": - train_second_deriv_analytical = ( - linear_regression_analytical_derivative_d_x_d_theta( - linear_model, - x, - y, - ) + elif influence_type == InfluenceType.Perturbation: + train_second_deriv_analytical = linear_mixed_second_derivative_analytical( + linear_model, + x, + y, ) result: "NDArray" = np.einsum( "ia,jab->ijb", s_test_analytical, train_second_deriv_analytical diff --git a/tests/influence/test_conjugate_gradients.py b/tests/influence/test_conjugate_gradients.py deleted file mode 100644 index 98eee58d8..000000000 --- a/tests/influence/test_conjugate_gradients.py +++ /dev/null @@ -1,110 +0,0 @@ -import itertools -from typing import List - -import numpy as np -import pytest - -from pydvl.influence.conjugate_gradient import ( - batched_preconditioned_conjugate_gradient, - conjugate_gradient_condition_number_based_error_bound, -) - - -class AlgorithmTestSettings: - A_NORM_TOL: float = 1e-4 - ACCEPTABLE_FAILED_PERC_A_NORM: float = 1e-2 - ACCEPTABLE_FAILED_PERC_BOUND: float = 1e-2 - BOUND_TOL: float = 1e-4 - CG_DAMPING: float = 1e-10 - - CG_TEST_CONDITION_NUMBERS: List[int] = [10] - CG_TEST_BATCH_SIZES: List[int] = [16, 32] - CG_TEST_DIMENSIONS: List[int] = [2, 20, 60, 100] - - -test_cases = list( - itertools.product( - AlgorithmTestSettings.CG_TEST_DIMENSIONS, - AlgorithmTestSettings.CG_TEST_BATCH_SIZES, - AlgorithmTestSettings.CG_TEST_CONDITION_NUMBERS, - ) -) - - -def lmb_test_case_to_str(packed_i_test_case): - i, test_case = packed_i_test_case - return f"Problem #{i} of dimension {test_case[0]} with batch size {test_case[1]} and condition number" - - -test_case_ids = list(map(lmb_test_case_to_str, zip(range(len(test_cases)), test_cases))) - - -@pytest.mark.parametrize( - "problem_dimension,batch_size,condition_number", - test_cases, - ids=test_case_ids, - indirect=True, -) -def test_conjugate_gradients_mvp(quadratic_linear_equation_system): - A, b = quadratic_linear_equation_system - x0 = np.zeros_like(b) - xn, n = batched_preconditioned_conjugate_gradient(A, b, x0=x0, rtol=10e-7) - check_solution(A, b, n, x0, xn) - - -@pytest.mark.parametrize( - "problem_dimension,batch_size,condition_number", - test_cases, - ids=test_case_ids, - indirect=True, -) -def test_conjugate_gradients_fn(quadratic_linear_equation_system): - A, b = quadratic_linear_equation_system - new_A = np.copy(A) - A = lambda v: v @ new_A.T - x0 = np.zeros_like(b) - xn, n = batched_preconditioned_conjugate_gradient(A, b, x0=x0, rtol=10e-7) - check_solution(new_A, b, n, x0, xn) - - -@pytest.mark.parametrize( - "problem_dimension,batch_size,condition_number", - test_cases, - ids=test_case_ids, - indirect=True, -) -def test_conjugate_gradients_mvp_preconditioned(quadratic_linear_equation_system): - A, b = quadratic_linear_equation_system - x0 = np.zeros_like(b) - xn, n = batched_preconditioned_conjugate_gradient(A, b, x0=x0, rtol=10e-7) - check_solution(A, b, n, x0, xn) - - -def check_solution(A, b, n, x0, xn): - """ - Uses standard inversion techniques to verify the solution of the problem. It checks: - - - That the solution is not nan at all positions. - - The solution fulfills an error bound, which depends on A and the number of iterations. - - Only a certain percentage of the batch is allowed to be false. - """ - assert np.all(np.logical_not(np.isnan(xn))) - inv_A = np.linalg.pinv(A) - - xt = b @ inv_A.T - bound = conjugate_gradient_condition_number_based_error_bound(A, n, x0, xt) - norm_A = lambda v: np.sqrt(np.einsum("ia,ab,ib->i", v, A, v)) - assert np.all(np.logical_not(np.isnan(xn))) - - error = norm_A(xt - xn) - failed = error > bound + AlgorithmTestSettings.BOUND_TOL - realized_failed_percentage = np.sum(failed) / len(failed) - assert ( - realized_failed_percentage < AlgorithmTestSettings.ACCEPTABLE_FAILED_PERC_BOUND - ) - - failed = error > AlgorithmTestSettings.A_NORM_TOL - realized_failed_percentage = np.sum(failed) / len(failed) - assert ( - realized_failed_percentage < AlgorithmTestSettings.ACCEPTABLE_FAILED_PERC_A_NORM - ) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 5c11f6996..a0bf83ab5 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -4,48 +4,50 @@ import numpy as np import pytest -from pydvl.utils.numeric import ( - linear_regression_analytical_derivative_d2_theta, - linear_regression_analytical_derivative_d_theta, - linear_regression_analytical_derivative_d_x_d_theta, +from .conftest import ( + analytical_linear_influences, + create_mock_dataset, + linear_analytical_influence_factors, + linear_model, ) -from .conftest import create_mock_dataset - try: + import torch import torch.nn.functional as F + from torch import nn - from pydvl.influence.general import InfluenceType, compute_influences - from pydvl.influence.model_wrappers import TorchLinearRegression, TorchMLP - from pydvl.utils.dataset import load_wine_dataset + from pydvl.influence.frameworks import TorchTwiceDifferentiable + from pydvl.influence.general import ( + InfluenceType, + calculate_influence_factors, + compute_influences, + ) except ImportError: pass class InfluenceTestSettings: - DATA_OUTPUT_NOISE: float = 0.01 - ACCEPTABLE_ABS_TOL_INFLUENCE: float = 5e-4 - ACCEPTABLE_ABS_TOL_INFLUENCE_CG: float = 1e-3 - - INFLUENCE_TEST_CONDITION_NUMBERS: List[int] = [5] - INFLUENCE_TRAINING_SET_SIZE: List[int] = [500] + ACCEPTABLE_RTOL_INFLUENCE: float = 1e-7 + ACCEPTABLE_RTOL_INFLUENCE_CG: float = 1e-1 + INFLUENCE_TYPE: List[InfluenceType] = [InfluenceType.Up, InfluenceType.Perturbation] + INFLUENCE_TEST_CONDITION_NUMBERS: List[int] = [3] + INFLUENCE_TRAINING_SET_SIZE: List[int] = [50, 30] INFLUENCE_TEST_SET_SIZE: List[int] = [20] - INFLUENCE_N_JOBS: List[int] = [1] INFLUENCE_DIMENSIONS: List[Tuple[int, int]] = [ (10, 10), - (20, 10), (3, 20), - (20, 20), ] + HESSIAN_REGULARIZATION: List[float] = [0, 1] test_cases = list( itertools.product( InfluenceTestSettings.INFLUENCE_TRAINING_SET_SIZE, InfluenceTestSettings.INFLUENCE_TEST_SET_SIZE, + InfluenceTestSettings.INFLUENCE_TYPE, InfluenceTestSettings.INFLUENCE_DIMENSIONS, InfluenceTestSettings.INFLUENCE_TEST_CONDITION_NUMBERS, - InfluenceTestSettings.INFLUENCE_N_JOBS, + InfluenceTestSettings.HESSIAN_REGULARIZATION, ) ) @@ -53,252 +55,76 @@ class InfluenceTestSettings: def lmb_test_case_to_str(packed_i_test_case): i, test_case = packed_i_test_case return ( - f"Problem #{i} of dimension {test_case[2]} with train size {test_case[0]}, " - f"test size {test_case[1]}, condition number {test_case[3]} and {test_case[4]} jobs." + f"Problem #{i} of dimension {test_case[3]} with train size {test_case[0]}, " + f"test size {test_case[1]}, if_type {test_case[2]}, condition number {test_case[4]} and lam {test_case[5]}." ) test_case_ids = list(map(lmb_test_case_to_str, zip(range(len(test_cases)), test_cases))) -def influences_perturbation_linear_regression_analytical( - linear_model: Tuple["NDArray", "NDArray"], - x: "NDArray", - y: "NDArray", - x_test: "NDArray", - y_test: "NDArray", -): - """Calculate the influences of each training sample onto the - validation set for a linear model Ax+b=y. - - :param linear_model: A tuple of np.ndarray' of shape (N, M) and (N) - representing A and b respectively. - :param x: An array of shape (M, K) containing the features of the - input data. - :param y: An array of shape (M, L) containing the targets of the input - data. - :param x_test: An array of shape (N, K) containing the features of the test - set. - :param y_test: An array of shape (N, L) containing the targets of the test - set. - :returns: An array of shape (B, C, M) with the influences of the training - points on the test points for each feature. - """ - - test_grads_analytical = linear_regression_analytical_derivative_d_theta( - linear_model, - x_test, - y_test, - ) - train_second_deriv_analytical = linear_regression_analytical_derivative_d_x_d_theta( - linear_model, - x, - y, - ) - - hessian_analytical = linear_regression_analytical_derivative_d2_theta( - linear_model, - x, - y, - ) - s_test_analytical = np.linalg.solve(hessian_analytical, test_grads_analytical.T).T - result: "NDArray" = np.einsum( - "ia,jab->ijb", s_test_analytical, train_second_deriv_analytical - ) - return result - - @pytest.mark.torch @pytest.mark.parametrize( - "train_set_size,test_set_size,problem_dimension,condition_number,n_jobs", + "train_set_size,test_set_size,influence_type,problem_dimension,condition_number, hessian_reg", test_cases, ids=test_case_ids, ) -def test_upweighting_influences_lr_analytical_cg( +def test_linear_influence( train_set_size: int, test_set_size: int, + influence_type: InfluenceType, + problem_dimension: Tuple[int, int], condition_number: float, - linear_model: Tuple[np.ndarray, np.ndarray], - n_jobs: int, + hessian_reg: float, ): - A, _ = linear_model - train_data, test_data = create_mock_dataset( - linear_model, train_set_size, test_set_size - ) + A, b = linear_model(problem_dimension, condition_number) + train_data, test_data = create_mock_dataset((A, b), train_set_size, test_set_size) - model = TorchLinearRegression(A.shape[0], A.shape[1], init=linear_model) + linear_layer = nn.Linear(A.shape[0], A.shape[1]) + linear_layer.weight.data = torch.as_tensor(A) + linear_layer.bias.data = torch.as_tensor(b) loss = F.mse_loss - influence_values_analytical = 2 * influences_up_linear_regression_analytical( - linear_model, + analytical_influences = analytical_linear_influences( + (A, b), *train_data, *test_data, + influence_type=influence_type, + hessian_regularization=hessian_reg, ) - influence_values = compute_influences( - model, + direct_influences = compute_influences( + linear_layer, loss, *train_data, *test_data, progress=True, - influence_type="up", - inversion_method="cg", - inversion_method_kwargs={"rtol": 10e-7}, - ) - assert np.logical_not(np.any(np.isnan(influence_values))) - assert influence_values.shape == (len(test_data[0]), len(train_data[0])) - influences_max_abs_diff = np.max( - np.abs(influence_values - influence_values_analytical) + influence_type=influence_type, + inversion_method="direct", + hessian_regularization=hessian_reg, ) - assert ( - influences_max_abs_diff < InfluenceTestSettings.ACCEPTABLE_ABS_TOL_INFLUENCE_CG - ), "Upweighting influence values were wrong." - -@pytest.mark.torch -@pytest.mark.parametrize( - "train_set_size,test_set_size,problem_dimension,condition_number,n_jobs", - test_cases, - ids=test_case_ids, -) -def test_upweighting_influences_lr_analytical( - train_set_size: int, - test_set_size: int, - condition_number: float, - linear_model: Tuple[np.ndarray, np.ndarray], - n_jobs: int, -): - - A, _ = tuple(linear_model) - train_data, test_data = create_mock_dataset( - linear_model, train_set_size, test_set_size - ) - - model = TorchLinearRegression(A.shape[0], A.shape[1], init=linear_model) - loss = F.mse_loss - - influence_values_analytical = 2 * influences_up_linear_regression_analytical( - linear_model, - *train_data, - *test_data, - ) - - influence_values = compute_influences( - model, + cg_influences = compute_influences( + linear_layer, loss, *train_data, *test_data, progress=True, - influence_type="up", - ) - assert np.logical_not(np.any(np.isnan(influence_values))) - assert influence_values.shape == (len(test_data[0]), len(train_data[0])) - influences_max_abs_diff = np.max( - np.abs(influence_values - influence_values_analytical) - ) - assert ( - influences_max_abs_diff < InfluenceTestSettings.ACCEPTABLE_ABS_TOL_INFLUENCE - ), "Upweighting influence values were wrong." - - -@pytest.mark.torch -@pytest.mark.parametrize( - "train_set_size,test_set_size,problem_dimension,condition_number,n_jobs", - test_cases, - ids=test_case_ids, -) -def test_perturbation_influences_lr_analytical_cg( - train_set_size: int, - test_set_size: int, - problem_dimension: int, - condition_number: float, - linear_model: Tuple[np.ndarray, np.ndarray], - n_jobs: int, -): - train_data, test_data = create_mock_dataset( - linear_model, train_set_size, test_set_size - ) - A, _ = linear_model - - model = TorchLinearRegression(A.shape[0], A.shape[1], init=linear_model) - loss = F.mse_loss - - influence_values_analytical = ( - 2 - * influences_perturbation_linear_regression_analytical( - linear_model, - *train_data, - *test_data, - ) - ) - influence_values = compute_influences( - model, - loss, - *train_data, - *test_data, - progress=True, - influence_type="perturbation", + influence_type=influence_type, inversion_method="cg", - inversion_method_kwargs={"rtol": 10e-7}, + hessian_regularization=hessian_reg, ) - assert np.logical_not(np.any(np.isnan(influence_values))) - assert influence_values.shape == ( - len(test_data[0]), - len(train_data[0]), - A.shape[1], - ) - influences_max_abs_diff = np.max( - np.abs(influence_values - influence_values_analytical) + assert np.logical_not(np.any(np.isnan(direct_influences))) + assert np.logical_not(np.any(np.isnan(cg_influences))) + direct_if_max_abs_diff = np.max( + np.abs((direct_influences - analytical_influences) / analytical_influences) ) assert ( - influences_max_abs_diff < InfluenceTestSettings.ACCEPTABLE_ABS_TOL_INFLUENCE - ), "Perturbation influence values were wrong." - - -@pytest.mark.torch -@pytest.mark.parametrize( - "train_set_size,test_set_size", - test_cases, - ids=test_case_ids, -) -def test_perturbation_influences_lr_analytical( - train_set_size: int, - test_set_size: int, - linear_model: Tuple[np.ndarray, np.ndarray], -): - train_data, test_data = create_mock_dataset( - linear_model, train_set_size, test_set_size - ) - A, _ = linear_model - - model = TorchLinearRegression(A.shape[0], A.shape[1], init=linear_model) - loss = F.mse_loss - - influence_values_analytical = ( - 2 - * influences_perturbation_linear_regression_analytical( - linear_model, - *train_data, - *test_data, - ) - ) - influence_values = compute_influences( - model, - loss, - *train_data, - *test_data, - progress=True, - influence_type="perturbation", - ) - assert np.logical_not(np.any(np.isnan(influence_values))) - assert influence_values.shape == ( - len(test_data[0]), - len(train_data[0]), - A.shape[1], - ) - influences_max_abs_diff = np.max( - np.abs(influence_values - influence_values_analytical) + direct_if_max_abs_diff < InfluenceTestSettings.ACCEPTABLE_RTOL_INFLUENCE + ), f"Influence values of type {influence_type} for direct inversion are wrong: max relative diff {direct_if_max_abs_diff}" + cg_if_max_abs_diff = np.max( + np.abs((cg_influences - analytical_influences) / analytical_influences) ) assert ( - influences_max_abs_diff < InfluenceTestSettings.ACCEPTABLE_ABS_TOL_INFLUENCE - ), "Perturbation influence values were wrong." + cg_if_max_abs_diff < InfluenceTestSettings.ACCEPTABLE_RTOL_INFLUENCE_CG + ), f"Influence values of type {influence_type} for cg inversion are wrong: max relative diff {cg_if_max_abs_diff}" From 516640a25bb6833b1e67d9bad829e39c265eeae6 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 23 Feb 2023 16:41:05 +0100 Subject: [PATCH 003/436] fix test_models --- tests/influence/conftest.py | 51 +------ tests/influence/test_influences.py | 139 +++++++++++++++--- ...models.py => test_torch_differentiable.py} | 73 ++++----- 3 files changed, 150 insertions(+), 113 deletions(-) rename tests/influence/{test_models.py => test_torch_differentiable.py} (70%) diff --git a/tests/influence/conftest.py b/tests/influence/conftest.py index 6e722b277..2ad89dfd0 100644 --- a/tests/influence/conftest.py +++ b/tests/influence/conftest.py @@ -52,53 +52,6 @@ def linear_model(problem_dimension: Tuple[int, int], condition_number: float): return A, b -class TorchSimpleNN(nn.Module): - """ - Creates a simple pytorch neural network. It needs input features, number of layers - """ - - def __init__( - self, - n_input: int, - n_hidden_layers: int, - n_neurons_per_layer: List[int], - output_layer: nn.Module, - init: List[Tuple["NDArray[np.float_]", "NDArray[np.float_]"]] = None, - ): - """ - :param n_input: Number of feature in input. - :param n_output: Output length. - :param n_neurons_per_layer: Each integer represents the size of a hidden - layer. Overall this list has K - 2 - :param output_layer: output layer of the neural network - number of outputs reduce to 1. - :param init: A list of tuple of np.ndarray representing the internal weights. - """ - super().__init__() - - layers = [nn.Linear(n_input, n_neurons_per_layer)] - for num_layer in range(n_hidden_layers): - linear_layer = nn.Linear(n_neurons_per_layer, n_neurons_per_layer) - - if init is not None: - A, b = init[num_layer] - linear_layer.weight.data = A - linear_layer.bias.data = b - - layers.append(linear_layer) - layers.append(output_layer) - - self.layers = nn.Sequential(*layers) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """ - Perform forward-pass through the network. - :param x: Tensor input of shape [NxD]. - :returns: Tensor output of shape[NxK]. - """ - return self.layers(x) - - def linear_derivative_analytical( linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", y: "NDArray" ) -> "NDArray": @@ -121,7 +74,7 @@ def linear_derivative_analytical( def linear_hessian_analytical( linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", - lam: float, + lam: float = 0, ) -> "NDArray": """ :param linear_model: A tuple of np.ndarray' of shape [NxM] and [N] representing A and b respectively. @@ -244,7 +197,7 @@ def analytical_linear_influences( return result -def create_mock_dataset( +def add_noise_to_linear_model( linear_model: Tuple["NDArray[np.float_]", "NDArray[np.float_]"], train_set_size: int, test_set_size: int, diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index a0bf83ab5..901fb30a9 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -1,13 +1,12 @@ import itertools -from typing import List, Tuple +from typing import Dict, List, Tuple import numpy as np import pytest from .conftest import ( + add_noise_to_linear_model, analytical_linear_influences, - create_mock_dataset, - linear_analytical_influence_factors, linear_model, ) @@ -16,10 +15,9 @@ import torch.nn.functional as F from torch import nn - from pydvl.influence.frameworks import TorchTwiceDifferentiable from pydvl.influence.general import ( InfluenceType, - calculate_influence_factors, + InversionMethod, compute_influences, ) except ImportError: @@ -27,9 +25,6 @@ class InfluenceTestSettings: - ACCEPTABLE_RTOL_INFLUENCE: float = 1e-7 - ACCEPTABLE_RTOL_INFLUENCE_CG: float = 1e-1 - INFLUENCE_TYPE: List[InfluenceType] = [InfluenceType.Up, InfluenceType.Perturbation] INFLUENCE_TEST_CONDITION_NUMBERS: List[int] = [3] INFLUENCE_TRAINING_SET_SIZE: List[int] = [50, 30] INFLUENCE_TEST_SET_SIZE: List[int] = [20] @@ -44,7 +39,7 @@ class InfluenceTestSettings: itertools.product( InfluenceTestSettings.INFLUENCE_TRAINING_SET_SIZE, InfluenceTestSettings.INFLUENCE_TEST_SET_SIZE, - InfluenceTestSettings.INFLUENCE_TYPE, + InfluenceType, InfluenceTestSettings.INFLUENCE_DIMENSIONS, InfluenceTestSettings.INFLUENCE_TEST_CONDITION_NUMBERS, InfluenceTestSettings.HESSIAN_REGULARIZATION, @@ -69,7 +64,7 @@ def lmb_test_case_to_str(packed_i_test_case): test_cases, ids=test_case_ids, ) -def test_linear_influence( +def test_influence_linear_model( train_set_size: int, test_set_size: int, influence_type: InfluenceType, @@ -78,7 +73,9 @@ def test_linear_influence( hessian_reg: float, ): A, b = linear_model(problem_dimension, condition_number) - train_data, test_data = create_mock_dataset((A, b), train_set_size, test_set_size) + train_data, test_data = add_noise_to_linear_model( + (A, b), train_set_size, test_set_size + ) linear_layer = nn.Linear(A.shape[0], A.shape[1]) linear_layer.weight.data = torch.as_tensor(A) @@ -116,15 +113,111 @@ def test_linear_influence( ) assert np.logical_not(np.any(np.isnan(direct_influences))) assert np.logical_not(np.any(np.isnan(cg_influences))) - direct_if_max_abs_diff = np.max( - np.abs((direct_influences - analytical_influences) / analytical_influences) - ) - assert ( - direct_if_max_abs_diff < InfluenceTestSettings.ACCEPTABLE_RTOL_INFLUENCE - ), f"Influence values of type {influence_type} for direct inversion are wrong: max relative diff {direct_if_max_abs_diff}" - cg_if_max_abs_diff = np.max( - np.abs((cg_influences - analytical_influences) / analytical_influences) - ) - assert ( - cg_if_max_abs_diff < InfluenceTestSettings.ACCEPTABLE_RTOL_INFLUENCE_CG - ), f"Influence values of type {influence_type} for cg inversion are wrong: max relative diff {cg_if_max_abs_diff}" + assert np.allclose(direct_influences, analytical_influences, rtol=1e-7) + assert np.allclose(cg_influences, analytical_influences, rtol=1e-1) + + +conv3d_nn = nn.Sequential( + nn.Conv3d(in_channels=5, out_channels=3, kernel_size=2), + nn.Flatten(), + nn.Linear(24, 3), +) +conv2d_nn = nn.Sequential( + nn.Conv2d(in_channels=5, out_channels=3, kernel_size=3), + nn.Flatten(), + nn.Linear(27, 3), +) +conv1d_nn = nn.Sequential( + nn.Conv1d(in_channels=5, out_channels=3, kernel_size=2), + nn.Flatten(), + nn.Linear(6, 3), +) +simple_nn_regr = nn.Sequential(nn.Linear(10, 10), nn.Linear(10, 3), nn.Linear(3, 1)) + +test_cases = { + "conv3d_nn_up": [conv3d_nn, 10, (5, 3, 3, 3), 3, nn.MSELoss(), InfluenceType.Up], + "conv3d_nn_pert": [ + conv3d_nn, + 10, + (5, 3, 3, 3), + 3, + nn.SmoothL1Loss(), + InfluenceType.Perturbation, + ], + "conv_2d_nn_up": [conv2d_nn, 10, (5, 5, 5), 3, nn.MSELoss(), InfluenceType.Up], + "conv_2d_nn_pert": [ + conv2d_nn, + 10, + (5, 5, 5), + 3, + nn.MSELoss(), + InfluenceType.Perturbation, + ], + "conv_1d_nn_up": [conv1d_nn, 10, (5, 3), 3, nn.MSELoss(), InfluenceType.Up], + "conv_1d_pert": [ + conv1d_nn, + 10, + (5, 3), + 3, + nn.SmoothL1Loss(), + InfluenceType.Perturbation, + ], + "simple_nn_up": [simple_nn_regr, 10, (10,), 1, nn.MSELoss(), InfluenceType.Up], + "simple_nn_pert": [ + simple_nn_regr, + 10, + (10,), + 1, + nn.MSELoss(), + InfluenceType.Perturbation, + ], +} + + +@pytest.mark.torch +@pytest.mark.parametrize( + "nn_architecture, batch_size, input_dim, output_dim, loss, influence_type", + test_cases.values(), + ids=test_cases.keys(), +) +def test_influences_nn( + nn_architecture: nn.Module, + batch_size: int, + input_dim: Tuple[int], + output_dim: int, + loss: nn.modules.loss._Loss, + influence_type: InfluenceType, + hessian_reg: float = 100, + test_data_len: int = 10, +): + x_train = torch.rand((batch_size, *input_dim)) + y_train = torch.rand((batch_size, output_dim)) + x_test = torch.rand((test_data_len, *input_dim)) + y_test = torch.rand((test_data_len, output_dim)) + + multiple_influences = [] + for inversion_method in InversionMethod: + influences = compute_influences( + nn_architecture, + loss, + x_train, + y_train, + x_test, + y_test, + progress=True, + influence_type=influence_type, + inversion_method=inversion_method, + hessian_regularization=hessian_reg, + ) + assert not np.any(np.isnan(influences)) + multiple_influences.append(influences) + if influence_type == InfluenceType.Up: + assert np.allclose(*multiple_influences, rtol=1e-3) + assert influences.shape == (test_data_len, batch_size) + elif influence_type == InfluenceType.Perturbation: + assert np.allclose(*multiple_influences, rtol=1e-1) + assert influences.shape == (test_data_len, batch_size, *input_dim) + else: + raise ValueError(f"Unknown influence type: {influence_type}") + # check that influences are not all equal + assert not np.all(influences == influences.item(0)) diff --git a/tests/influence/test_models.py b/tests/influence/test_torch_differentiable.py similarity index 70% rename from tests/influence/test_models.py rename to tests/influence/test_torch_differentiable.py index d4d855c07..56afbe6b7 100644 --- a/tests/influence/test_models.py +++ b/tests/influence/test_torch_differentiable.py @@ -10,31 +10,29 @@ import numpy as np import pytest -from pydvl.utils import ( - linear_regression_analytical_derivative_d2_theta, - linear_regression_analytical_derivative_d_theta, - linear_regression_analytical_derivative_d_x_d_theta, +from .conftest import ( + linear_derivative_analytical, + linear_hessian_analytical, + linear_mixed_second_derivative_analytical, + linear_model, ) try: + import torch import torch.nn.functional as F + from torch import nn from pydvl.influence.frameworks import TorchTwiceDifferentiable - from pydvl.influence.model_wrappers import TorchLinearRegression except ImportError: pass class ModelTestSettings: DATA_OUTPUT_NOISE: float = 0.01 - ACCEPTABLE_ABS_TOL_MODEL: float = ( - 0.04 # TODO: Reduce bound if tests are running with fixed seeds. - ) - ACCEPTABLE_ABS_TOL_DERIVATIVE: float = 1e-5 TEST_CONDITION_NUMBERS: List[int] = [5] TEST_SET_SIZE: List[int] = [20] - TRAINING_SET_SIZE: List[int] = [500] + TRAINING_SET_SIZE: List[int] = [50] PROBLEM_DIMENSIONS: List[Tuple[int, int]] = [ (2, 2), (5, 10), @@ -106,13 +104,13 @@ def lmb_correctness_test_case_to_str(packed_i_test_case): test_cases_linear_regression_derivatives, ids=correctness_test_case_ids, ) -def test_linear_regression_model_grad( +def test_linear_grad( train_set_size: int, + problem_dimension: Tuple[int, int], condition_number: float, - linear_model: Tuple[np.ndarray, np.ndarray], ): # some settings - A, b = linear_model + A, b = linear_model(problem_dimension, condition_number) output_dimension, input_dimension = tuple(A.shape) # generate datasets @@ -122,18 +120,15 @@ def test_linear_regression_model_grad( train_x = np.random.uniform(size=[train_set_size, input_dimension]) train_y = data_model(train_x) - model = TorchLinearRegression(input_dimension, output_dimension, init=linear_model) + model = nn.Linear(input_dimension, output_dimension) + model.weight.data = torch.as_tensor(A) + model.bias.data = torch.as_tensor(b) loss = F.mse_loss mvp_model = TorchTwiceDifferentiable(model=model, loss=loss) - train_grads_analytical = 2 * linear_regression_analytical_derivative_d_theta( - (A, b), train_x, train_y - ) + train_grads_analytical = linear_derivative_analytical((A, b), train_x, train_y) train_grads_autograd = mvp_model.split_grad(train_x, train_y) - train_grads_max_diff = np.max(np.abs(train_grads_analytical - train_grads_autograd)) - assert ( - train_grads_max_diff < ModelTestSettings.ACCEPTABLE_ABS_TOL_DERIVATIVE - ), "training set produces wrong gradients." + assert np.allclose(train_grads_analytical, train_grads_autograd, rtol=1e-5) @pytest.mark.torch @@ -142,13 +137,13 @@ def test_linear_regression_model_grad( test_cases_linear_regression_derivatives, ids=correctness_test_case_ids, ) -def test_linear_regression_model_hessian( +def test_linear_hessian( train_set_size: int, + problem_dimension: Tuple[int, int], condition_number: float, - linear_model: Tuple[np.ndarray, np.ndarray], ): # some settings - A, b = linear_model + A, b = linear_model(problem_dimension, condition_number) output_dimension, input_dimension = tuple(A.shape) # generate datasets @@ -157,21 +152,18 @@ def test_linear_regression_model_hessian( ) train_x = np.random.uniform(size=[train_set_size, input_dimension]) train_y = data_model(train_x) - model = TorchLinearRegression(input_dimension, output_dimension, init=linear_model) + model = nn.Linear(input_dimension, output_dimension) + model.weight.data = torch.as_tensor(A) + model.bias.data = torch.as_tensor(b) loss = F.mse_loss mvp_model = TorchTwiceDifferentiable(model=model, loss=loss) - test_hessian_analytical = 2 * linear_regression_analytical_derivative_d2_theta( - (A, b), train_x, train_y - ) + test_hessian_analytical = linear_hessian_analytical((A, b), train_x) grad_xy, _ = mvp_model.grad(train_x, train_y) estimated_hessian = mvp_model.mvp( grad_xy, np.eye((input_dimension + 1) * output_dimension) ) - test_hessian_max_diff = np.max(np.abs(test_hessian_analytical - estimated_hessian)) - assert ( - test_hessian_max_diff < ModelTestSettings.ACCEPTABLE_ABS_TOL_DERIVATIVE - ), "Hessian was wrong." + assert np.allclose(test_hessian_analytical, estimated_hessian, rtol=1e-5) @pytest.mark.torch @@ -180,13 +172,13 @@ def test_linear_regression_model_hessian( test_cases_linear_regression_derivatives, ids=correctness_test_case_ids, ) -def test_linear_regression_model_d_x_d_theta( +def test_linear_mixed_derivative( train_set_size: int, + problem_dimension: Tuple[int, int], condition_number: float, - linear_model: Tuple[np.ndarray, np.ndarray], ): # some settings - A, b = linear_model + A, b = linear_model(problem_dimension, condition_number) output_dimension, input_dimension = tuple(A.shape) # generate datasets @@ -195,11 +187,13 @@ def test_linear_regression_model_d_x_d_theta( ) train_x = np.random.uniform(size=[train_set_size, input_dimension]) train_y = data_model(train_x) - model = TorchLinearRegression(input_dimension, output_dimension, init=(A, b)) + model = nn.Linear(input_dimension, output_dimension) + model.weight.data = torch.as_tensor(A) + model.bias.data = torch.as_tensor(b) loss = F.mse_loss mvp_model = TorchTwiceDifferentiable(model=model, loss=loss) - test_derivative = 2 * linear_regression_analytical_derivative_d_x_d_theta( + test_derivative = linear_mixed_second_derivative_analytical( (A, b), train_x, train_y, @@ -215,7 +209,4 @@ def test_linear_regression_model_d_x_d_theta( ) ) estimated_derivative = np.stack(model_mvp, axis=0) - test_hessian_max_diff = np.max(np.abs(test_derivative - estimated_derivative)) - assert ( - test_hessian_max_diff < ModelTestSettings.ACCEPTABLE_ABS_TOL_DERIVATIVE - ), "Hessian was wrong." + assert np.allclose(test_derivative, estimated_derivative, rtol=1e-7) From f6b31f1ec2ec1174d81a745854249cc18a77288a Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 23 Feb 2023 17:23:52 +0100 Subject: [PATCH 004/436] minor changes to synthetic notebook --- notebooks/influence_synthetic.ipynb | 67 +++++++----------------- notebooks/notebook_support.py | 24 +++++++++ src/pydvl/influence/inversion_methods.py | 4 +- 3 files changed, 46 insertions(+), 49 deletions(-) diff --git a/notebooks/influence_synthetic.ipynb b/notebooks/influence_synthetic.ipynb index ec0f54ae4..e3741b929 100644 --- a/notebooks/influence_synthetic.ipynb +++ b/notebooks/influence_synthetic.ipynb @@ -78,12 +78,16 @@ "import torch.nn.functional as F\n", "import matplotlib.pyplot as plt\n", "from pydvl.influence.general import compute_influences\n", - "from pydvl.influence.model_wrappers import TorchBinaryLogisticRegression\n", "from pydvl.utils.dataset import (\n", " synthetic_classification_dataset,\n", " decision_boundary_fixed_variance_2d,\n", ")\n", - "from notebook_support import plot_dataset, plot_influences\n", + "from notebook_support import (\n", + " plot_dataset,\n", + " plot_influences,\n", + " fit_torch_model,\n", + " TorchLogisticRegression,\n", + ")\n", "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n", "from torch.optim import AdamW, lr_scheduler" ] @@ -211,7 +215,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABagAAALYCAYAAACZoRUeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzddVhWyd8G8Hvo7hYQOzBQEezutbt17VjX7m7XtXbt7rVz7e7EViwURSUkpJF65v0Dfr66ipIe0PtzXVwrz5mZc5/H2PN8mTMjpJQgIiIiIiIiIiIiIvre1JQOQEREREREREREREQ/JxaoiYiIiIiIiIiIiEgRLFATERERERERERERkSJYoCYiIiIiIiIiIiIiRbBATURERERERERERESKYIGaiIiIiIiIiIiIiBTBAjURERERpZkQQgohOip4/uJCiGtCiPdCiBff6ZxOyddd6Xuc73v70a+PiIiIiLInFqiJiIiI6BNCiHXJhUophEgQQrwUQiwTQphnYMxKyeM5ZVLM2QDCARQGUDaFc47L5OL1KwC2AK5mdCAhxAkhxLoMJ/p83FVCiDOZPe5XzpfZ7zERERER/WRYoCYiIiKiLzmPpGKsE4DfAbQAsEHJQP9RAMBZKeULKWVgRgYSQmilpp2UMlFK6S+ljM/I+YiIiIiI6P+xQE1EREREXxKXXIx9LaXcB2ABgHpCCN0vNRZC2AohtgohQoUQMUKIM0II1+RjTkgqeAOAd/JM6jMpnfhbYwkhJIB8AKYkjzXpC2N0BTAVQO6PZoNPSj72QggxTQixRAgR/L9sQoiBQojbQohIIYR/cgbbj8b8ZAmMj75vLYQ4IISIFkI8Tz53ipJnTtcE0OWjbNWSj1knz2APFEJECCEuCiGqfNRXUwgxTwjxWggRK4TwE0JsTT42CUB3AFU/GjfFLMm5vZKXSbkEoMR/jgshxEohxLPk34fnQogZQgjtVLzH7YUQV4UQYUKIICHEQSFEwa+9L0RERET0c9JQOgARERER5QgxSJrc8Nn9oxBCANgLQBtAQwBhAMYBOC6EKICkpTGaANgHwC35+7gvnSSVY9kCuA5gM5IK55FfGGobkpb/6ID/XwLk43a/A5gHoPx/rmkYgGcAbADMBbAVQNUvZf3ILACjAAwC0A3AKiHEJSnlkxTaDwSQF4Bf8q8BICS5+H8awEMA9QGEAmiTfO0uUsqHAAYAaA2gI4DnAKwBVEweYw6SZpbnAdA8+bWwLwUQQpQCsAVJS6WsA+AM4K//NgPwFkB7AAFIKmAvBxAPYCK+/h5rA5gGwBOAEYDJAA4KIZyllF/8vSciIiKinxML1ERERET0VUKIogD6A7gqpYz4QpMaSCo8O0spPZP7dAbwAkA/KeUUIURIcttAKaX/V073zbEA+AshEgFEpjSWlDJGCBEJIDGFNtellJP+0+fjAq23EKI/gJtCiFxSyjdfybxISrk9Oet4JBWRqwP4YoFaShkmhIgDEPNxtuQZyUYA2kgpE5Jfni6EqAmgN5IK4LmTxz0rpZQAfJBUrIeUMlIIEYPk2e9fyQsAQwFckVKOTv7+sRDCDsDCj3KqAIz9qM8LIUQ+AP0ATPzaeyylXPvx98nXFoykQvbFb2QjIiIiop8Il/ggIiIioi+plrzURQyA+0iards+hbbOAIL/V1AGACllLJI2E3RO43kzc6yvufbfF4QQ1YQQR4UQr4QQEQAuJB/K/Y2xbv/vF1LKRCTNOrZOHnNM8vv4v6/KXxmnLJJmbod+3AdAZSTNjAaAtQCKA/ASSRtXthCpXEP7P4oCuPSf1y78t5EQomfyUh0ByVlm4tvvB4QQLkKIPUII7+T30if50Df7EhEREdHPhTOoiYiIiOhLrgLoAiABgO8PuCxD1MffCCEcARwCsBHAFABBAOwBnADwrQLwf98bif+fCLIMwPaPjn1tJrYakpb3aPaFY9EAIKW8LYTIA6A2kmZp/wVgqhCinJQy/Bs500QI0QrAYiQtX3IWQDiAVgCmf6OfHoBjSCp4/4qk5UEA4AG+/V4SERER0U+GBWoiIiIi+pIYKaVXKts+AGAuhCj60bIc2gDcASxJbvO/Iq56JoyVWnGpON//lAWgC2CQlDIm+bxl0ni+z0gpQwCEfOHQl7J5AOgMIFxK+fYrY0YC2ANgjxBiBpLWsq4K4N8Uxv0STwAV/vNaxf98XwXALSnlvP+9IJI2vPzWdRQBYAlgbPK62RBCVEDSmtZERERERJ/gEh9ERERElFGnkLRkxj9CiIpCiGIANgDQAbA0uc1LACoADYQQVkII4wyMlVreAGyEEOWFEBbJM3tT8hRJM5+HCiHyCCGaApiQxvOlNVsZIUS+5GyaSNr00RtJmwnWEUI4CSHchRCjk/NACDFcCNFBCOGcPJO6G4BE/P96194ACicft0gu7n/JfADlhRDThRAFhRDNkLQu9cceAyguhGiSnHMg/n/zxY+v47/v8UsAsQAGJPeriaSZ3jLd7xYRERER/bBYoCYiIiKiDEnerK8pgEcADiJp0z4bALWllEHJbQIAjEbSchF+APald6w02AtgR/I4gQBGfOUa7iJpc8PeSJpdPAxJmxJmlblIWkbkTnK2ilLK90iaCe2BpLWmnwDYjaRNI18m9wsHMATAZQD3kLQcSAsp5ePk46uR9J5dSh633ZdOLqW8gaQ1xdsmjzMKwOD/NFuOpCVP1gK4haRZ7JP+02Yv/vMeJ/8+dUTSMiQPAMxB0vup+vbbQkREREQ/G5H0GYCIiIiIiIiIiIiI6PviDGoiIiIiIiIiIiIiUgQL1ERERERERERERESkCBaoiYiIiIiIiIiIiEgRLFATERERERERERERkSJYoCYiIiIiIiIiIiIiRbBATURERERERERERESKYIGaiIiIiIiIiIiIiBTBAjURERERERERERERKYIFaiKin4AQoqsQIkHpHEREREREREREH2OBmogomxJCnBBCrMuk4bYByJVJYxERERER/dAy+V78f2OuEkKcycwxiYh+BBpKByAiovQTQmhJKeO+1U5KGQMg5jtEIiIiIiIiIiJKNc6gJiLKhpJna9QE0EUIIZO/uib/t4MQ4pAQIgrAVJFkpRDimRAiRgjxXAgxQwih/dF4nyzx8b/vhRAVhRA3hRDRQogbQoiy3/9qiYiIiIiyjxTuxasJIayFEOuEEIFCiAghxEUhRJWP+mkKIeYJIV4LIWKFEH5CiK3JxyYB6A6g6sf39wpcHhFRtsMZ1ERE2dNAAHkB+CX/GgCMkv/7B4CRAPonfy8AvAXQHkAAgBIAlgOIBzDxK+dQAzAzefxAAPMBbBdCFJBScr1qIiIiIvpZfelePAbAZQAPAdQHEAqgDYDjQggXKeVDAAMAtAbQEcBzANYAKib3nwOgAIA8AJonvxaW1RdCRJQTsEBNRJQNSSnDhBBxAGKklP4AIITQST68XEq5+T9dxn706xdCiHwA+uHrBWoBYJCU8mby+JMAXAGQD8DjjF8FEREREVHOk8K9eFckTRhp89FkjulCiJoAegMYBCA3gCcAzkopJQAfANeTx4wUQsQAiPvfmERElIQFaiKinOfaf18QQvQE0AOAEwB9JP37/q1lnCSAOx9975v8X2uwQE1ERERE9LGyAGwAhAohPn5dG/+/18taAMcBeAkhjif/+t/U7BlDRPQzY4GaiCjnifr4GyFEKwCLAYwCcBZAOIBWAKZ/YxyVlDLxo+9l8n+5PwERERER0afUkLS8R7MvHIsGACnlbSFEHgC1AVQH8BeS9owpJ6UM/25JiYhyGBaoiYiyrzgA6qloVwXALSnlvP+9IIRwyqpQREREREQ/gf/ei3sA6AwgXEr5NqVOUspIAHsA7BFCzEDSOtZVAfz7hTGJiAicJUdElJ15AygjhMgnhLAAoJlCu8cAigshmiS3HYj/33iFiIiIiIjS7r/34tuTXzsohKgjhHASQrgLIUYLIZoCgBBiuBCigxDCOXkmdTcAiUhal/p/YxZOPm4hhND+/pdFRJT9sEBNRJR9zQUQhKR1ogPx/zuA/9dyABuRtObdLQDuACZ9h3xERERERD+q/96Ll0HSTGgPJN13PwGwG4AbgJfJfcIBDAFwGcA9JC0H0kJK+b/9XVYjadPES8ljtvseF0JElN2JpI1liYiIiIiIiIiIiIi+L86gJiIiIiIiIiIiIiJFsEBNRERERERERERERIpggZqIiIiIiIiIiIiIFMECNREREREREREREREpggVqIiIiIiIiIiIiIlKEhtIB0svCwkI6OTkpHYOIiIiIcqAbN24ESSktlc6Rk/D+m4iIiIjS62v33zm2QO3k5AQPDw+lYxARERFRDiSEeKl0hpyG999ERERElF5fu//mEh9EREREREREREREpAgWqImIiIiIiIiIiIhIESxQExEREREREREREZEiWKAmIiIiIiIiIiIiIkWwQE1EREREREREREREimCBmoiIiIiIiIiIiIgUwQI1ERERERERERERESmCBWoiIiIiIiIiIiIiUgQL1ERERERERERERESkCBaoiYiIiIiIiIiIiEgRLFATERERERERERERkSJYoCYiIiIiIiIiIiIiRbBATURERERERERERESKYIGaiIiIiIiIiIiIiBTBAjURERERERERERERKSLbFKiFEDpCiGtCiDtCiAdCiMlKZyIiIiIiIiIiIiKirKOhdICPxAKoIaWMFEJoArgghDgspbyidDAiIiIiIiIiIiIiynzZpkAtpZQAIpO/1Uz+ksolIiIiIiIiIiIiIqKslG2W+AAAIYS6EOI2gLcAjkspryociYiIiIiIiIiIiIiySLYqUEspE6WULgDsAbgJIYp9fFwI0UsI4SGE8AgMDFQkIxERERERERERERFljmxVoP4fKWUogNMA6v3n9RVSSlcppaulpaUi2YiIiIiIiIiIiIgoc2SbArUQwlIIYZL8a10AtQE8UjQUEREREREREREREWWZbFOgBmAL4LQQ4i6A60hag/qAwpmIiIh+eMHBwdixYwdu3rypdBQiygRCCAchxGkhhKcQ4oEQYuAX2lQTQoQJIW4nf01QIisREdH3FhgYiB07duDOnTtKRyGiZBpKB/gfKeVdAKWUzkFERPQzCQ4ORnGX0hAm9oj09cLC+XPQuXMnpWMRUcYkABgqpbwphDAEcEMIcVxK6fmfduellA0VyEdERKQIf39/lCzlCg2L3Ih48wSrly9Bq1atlI5F9NPLTjOoiYiI6Ds7fvw4hIkDHJpPgG3d3/D3kuVKRyKiDJJS+kkpbyb/OgLAQwC5lE1FRESkvEOHDkHTphAcmk+Adc3eWLh0pdKRiAgsUBMREf3U8ubNi0g/L4Q+u4GIJxdRqGB+pSMRUSYSQjgh6SnFq184XF4IcUcIcVgI4fx9kxEREX1/+fLlQ+SbRwh7fhNRXpdRmPe+RNkCC9REREQ/MTc3N8ydNR06j/ajSmErLP57gdKRiCiTCCEMAOwCMEhKGf6fwzcB5JZSlgSwEMDeFMboJYTwEEJ4BAYGZmleIiKirFa1alVMmzgG2g/3oWbJ3Jj75x9KRyIiAEJKqXSGdHF1dZUeHh5KxyAiIiKiHEgIcUNK6ap0jqwihNAEcADAUSnlvFS0fwHAVUoZlFIb3n8TERERUXp97f6bM6iJiIiIiH4gQggBYDWAhykVp4UQNsntIIRwQ9LnguDvl5KIiIiIKImG0gGIiIiIiChTVQTQCcA9IcTt5NfGAHAEACnlMgAtAfQVQiQAiAHQVubURyuJiChNQkND8fr1axQsWBBaWlpKxyEiYoGaiIiIiOhHIqW8AEB8o80iAIu+TyIiIsourly5grr1f4G6jj5sLM1w5cI5GBkZKR2LiH5yXOKDiIiIiIiIiOgnMGnqDJhX6oQCPVfgnUofu3btUjoSEREL1EREREREREREPwNTUxPEv3uD+MgQJEQEw9jYWOlIREQsUBMRERERERER/Qzmzp4F6wRfPF3dH03rVUfTpk2VjkRExDWoiYiIiIiIiIh+BnZ2dvC4clHpGEREn+AMaiIiIiIiIiIiIiJSBAvURERERERERERERKQIFqiJiIiIiIiIiIiISBEsUBMRERERERERERGRIligJiIiIiIiIiIiIiJFsEBNRERERERERERERIpggZqIiIiIiIiIiIiIFMECNREREREREREREREpggVqIiIiIiIiIiIiIlIEC9REREREREREREREpAgWqImIiIiIiIiIiIhIESxQExEREREREREREZEiWKAmIiIiIiIiIiIiIkWwQE1EREREREREREREimCBmoiIiIiIiIiIiIgUwQI1ERERERERERERESmCBWoiIiIiIiIiIiIiUgQL1ERERERERERERESkCBaoiYiIiIiIiIiIiEgRLFATERERERERERERkSJYoCYiIiIiIiIiIiIiRbBATURERERERERERESKYIGaiIiIiIiIiIiIiBTBAjURERERERERERERKYIFaiIiIiIiIiIiIiJSBAvURERERERERERERKQIFqiJiIiIiIiIiIiISBEsUBMRERERERERERGRIligJiIiIiIiIiIiIiJFsEBNRERERERERERERIpggZqIiIiIiIiIiIiIFMECNREREREREREREREpggVqIiIiIiIiIiIiIlIEC9REREREREREREREpAgWqImIiIiIiIiIiIhIESxQExEREREREREREZEiWKAmIiIiIiIiIiIiIkWwQE1EREREREREREREimCBmoiIiIiIiIiIiIgUwQI1ERERERERERERESmCBWoiIiIiIiIiIiIiUgQL1ERERERERERERESkCBaoiYiIiIiIiIgoVS5duoT169fD399f6ShE9INggZqIiIgyzdGjRzF23DicOnVK6ShERERElMlWrVqN+k1aYOz8tShRqgwCAgKUjkREPwAWqImIiChT/Pvvv2jdoQvWn3+Bpi3b4sSJE0pHIiIiIqJMtHz1OtjW7g/7JqOhZZUPJ0+eVDoSEf0AWKAmIiKiTHHw8FGYlG4M+2qdYFyyPo4cPaZ0JCIiIiLKRM5FCyPM8xRCHl9G+OvHKFiwoNKRiOgHwAI1ERERZYqqlSsi/N5R+F/bj4gHJ1ClciWlIxERERFRJlq4YB5+cSsIC99zWPLXPLi6uiodiYh+ABpKByAiIqLvy8fHB+fPn4eLiwucnZ0zbdx27dpBpVLhxKkzqP/rfDRu3DjTxiYiIiIi5RkaGmLVimVKxyCiHwwL1ERERD+RJ0+ewK18RRg6Fkeo9x3s3rEVtWvXzrTxO3TogA4dOmTaeERERERERPRj4xIfREREP5E9e/bAoGAl5Go8EhaVOmDF6nVKRyIiIiIiIsp0jx8/xtatW+Hj46N0FPoGFqiJiIh+IgUKFEC0zx2EPbuJaK8rKFqYG9sQEREREdGP5fz583B1L4/hs5ahuEtpPHz4UOlI9BUsUBMREf1EmjVrhpED+0Lf6yBa16uEsWNGKx2JiIiIiIgoU61csw5m7q2Rq8loGBSphu3btysdib6Ca1ATERH9RIQQGDliOEaOGK50FCIiIiIioixRpFBBHL20A2HWeRH76h4KFGiudCT6Cs6gJiKin9rr169RqVoN2Dvlw5y585WOQ0RERERElCVCQkKwYsUK7Nq1CyqVSuk4WWrY0CFo06AqdB7uwYAeHdGuXTulI9FXcAY1ERGlma+vL4aPGoPwiEhMmTAWpUqVUjpSunXv1Rc+KmuY1mmBqbOmoWqVSihbtqzSsYiIiIiIiDJNTEwMyriVQ5xBLsS988OpM+eweOFfSsfKMpqamvh7/lylY1AqcQY1ERGlWYPGTXHuWRTuv7dCjdp1ERkZqXSkdPP184OeQzHo2eSDrqkNAgIClI5ERERERESUqe7du4fIeMChySjkajwS27gmc6Y4e/YsOnXthhkzZyE+Pl7pODkWC9RERJRmjzwfwLpiG1iVbQwpNODr66t0pHQbP3oE3hycC+8Ng2ChC9SoUUPpSEREGSKEcBBCnBZCeAohHgghBn6hjRBC/C2E8BJC3BVClFYiKxEREX0fTk5OiA0PxtsbhxB4bTeKFS+hdKQc79GjR2jUtDnO+2tjwdodGDGKG9CnFwvUREQ5xMmTJ2FpYwdDYxMsX7FC0SzNW7SEz85JeLVnGuztrJE3b15F82RE69atceemB3ZtXAmPq5ehp6endCQiooxKADBUSlkUQDkA/YUQRf/Tpj6AAslfvQAs/b4RiYgop5FSYuXKVejUtRt27dqldBxKIysrKxw5+C+KqPmgTnFb7Ny6WelIOd6tW7dg7FQCNu5NYe7eCmfPX1I6Uo7FNaiJiHKINu07wqLWb9A2tsLgIUPRonlzWFhYKJJl47o12LFjByIjI9GmTRtoaOTs/53kzZs3RxfZiYg+JqX0A+CX/OsIIcRDALkAeH7UrAmADVJKCeCKEMJECGGb3JdyKA8PD1hZWcHR0VHpKET0A1q5chVGT/kDRiXqYX/v32BgYIC6desqHYvSoEKFCji4f4/SMX4YFSpUQPjLAVCdWInYV3cxsHdXpSPlWDm7okBE9BOJiY6GtqkNNA1MIdTU8f79e8WyqKuro23btoqdn4iIUkcI4QSgFICr/zmUC8Crj75/nfzaJwVqIUQvJM2wZtEzm0tMTESHDh0QGhqKvXv3onz58kpHIqIfzNkLl2BUsgGsXX9BfEQQLl++zAI1/dRy586NKxfPY/v27ShYsAU/I2cAl/ggIsoh/vxjFp6uG4xHS3ugc6eOsLe3VzoSUbbn4+ODBo2aoGz5yjhy5IjScYi+KyGEAYBdAAZJKcPTM4aUcoWU0lVK6WppaZm5ASlTqaurY+/evTA0NES1atWwadMmpSMR0Q+mScP6CLm2E29Or0fY/ROoU6eO0pFyHB8fHxQrWRo6evro2q0HVCqV0pFyJD8/P5SvXBXmVjYYMmw4kh4IU0aRIkUwceJEtGvXDkIIxXLkdCxQExHlEP369YX3s6fwvHcbSxcvVDoOUY7QrFVb3A83QJhDNbRq2x4BAQFKRyL6LoQQmkgqTm+WUu7+QpM3ABw++t4++TXKhl69eoXz588jOjr6q+2KFCmCq1evokKFCujUqRNGjx7N4gf9lG7duoVcjk7Q0tbB8JHctCyztG7dGls3rEa36gVw5MA+VKhQQelIOc7gYSMRblIYzv3X4eCpi9i3b5/SkXKk3wcNxWtpBYc2M7F+624cPXpU6UiUQSxQExHlINbW1nzEmigNvJ8/g1mJWjAtXBFaesbw9fVVOhJRlhNJ03dWA3gopZyXQrP9ADqLJOUAhHH96ezp6NGjKFqsJFp26Y3iLqURFhb21fbm5uY4evQoevbsiVmzZqFFixaIjIz8TmmJsofuvfpC26UZig9Yj5Vr18PDw0PpSD+M+vXrY/LkyahYsaLSUXKkiIgIaBhZQUPXEBp6Rvz3OZ3eBgVB2zIPtE1toWVshaCgIKUjUQaxQE1EREQ/rN69esFn5yT4bBsLexsLFCtWTOlIRN9DRQCdANQQQtxO/moghOgjhOiT3OYQgOcAvACsBNBPoaz0DdP/mAObWr2Rp9N8xGiZ499///1mHy0tLSxfvhwLFizA/v37UalSJfj4+HyHtETZQ3RMDLQMzKCuow91LV3ExMQoHYkUpFKpEBoaqugyEP8zbfIEhFzchEdLf4W1nkTz5s2VjpQjTRo3GgGnV+HZmv4wEVFo0qSJ0pEog7hJIhEREf2wZkybgrq1ayIkJAT16tWDpqam0pGIspyU8gKAry6CKJM+pff/PokoI+xsbfD8+UNEWznhfcgbWFtbp6qfEAIDBw5EoUKF0KZNG7i5uWHPnj3cPJF+Cgvm/IGWrdsCauqoXq0ql6L4iT1//hyVq9VAUGAgSpUug1PHj0BPT0+xPG5ubnj10hv+/v7IkycPNDRYlkuP6tWrw+vxQ7x69QrFixeHtra20pEog0R2+AlSeri6uko+pkNERDndhQsXcPDgIbi7u6Fp06ZKxyH6aQghbkgpXZXOkZPw/lsZb9++RduOnfHo0WP06NYVkydOSPMmTJ6enmjUqBHevHmDVatWoWPHjlmUlij7CA8PR2hoKBwcHLhx2U+sQ+euOP8qEbaV2+PlrqmY/HsX9O7dW+lYRD+lr91/c4kPIiIihVy9ehX1GzbBxss++LXPAKxfv0HpSERElM1YWVnh1LEj8PXxxpRJE9NVaCtatCiuXbuGcuXKoVOnThg7diw3T6QfnpGRERwdHVmc/skJIQBVIiAloFJl+Z+Hp0+fonK1mijmUiZVSzIRURIWqImIiBRy6tQpmDjXgH3VTjB1a4V/D3P3aSIiyhrm5uY4duwYevbsiRkzZqBly5bcnIuIfnjTJk+E2uvruPlHUxS0MUCnTp2y9HxNW7bBK808SCjaFO06dsbbt2+/2Sc2Nhadf+0Op/yF0Lf/ACQkJGRpRqLsiAVqIiIihVSoUAFhj87B/+pehN36FzWqVlI6EhER/cD+t3ni/PnzsW/fPlSuXBmvXr1SOhYRUZZxcnKCt9cThL57h3OnT0BXVzdLz/f6lQ9MilSCcX5XaOoaICAg4Jt95sydh6NXHsCw5iDsOnoeq1evztKMP7pDhw6hU9duWLhoMZ8WykFYoCYiIlJI1apVsWXDGtR0UGH2pNHo26eP0pGIiOgHJ4TAoEGDcODAATx//hxly5bF1atXlY5FRPRN//77L/788088efIkTf2EENDX18+iVJ8aNPB3vNg6Ft6bhqFIgXwoWrToN/v4vHoNbbsi0LfJC03rAnj1+vV3SPpjunjxItp27ILzAbqY/OcizJk7X+lIlErcJJGIiIiIfjrcJDHteP/94/l488Q1a9agffv2Skci+iEtXrIEq9dtRPFizlj89wIYGBgoHSnH+fvvRZg080/oOZVCxOMLOHf6JB49egQHBwdUqFBB6XifuHr1KkJDQ1G9enVoaWl9s/3t27dRtUYt6FvlRkzQK1y7fBEFChT4Dkl/PPPnz8e87WeRq05fBN07jUKJT3Bw326lY1EybpJIRET0E4qPj4eHhwfevHmjdBQiIsqGihYtiqtXr6JcuXLo0KEDxo0bx8ehiTLZ2bNnMXbSdMQUbIxjN55j6IiRSkfKkbbs2AXLat1hX6cvDByLo1bd+hg8ZQEaNG2JBQv+VjreJ9zd3VG3bt1UFacBwMXFBY8e3MO6v2fiycMHLE5nQPXq1RH68Bxen1qL4Mtb0LRRA6UjUSqxQE1ElAVUKhUePHiA13w8ixTy/v17lKtYBXWbtEKhosWwb98+pSMREVE2ZGFhgWPHjqFHjx6YPn06WrVqhaioKKVjEf0wvLy8YJCrEIzzlYZBwQp4+Pip0pFypArlyiL05r94e/Mw3j27AWFgCceWk5Cr4XAsXr7ii31UKhWePn2KkJCQ75w27WxtbVGnTh1YWloqHSVHc3FxwanjR9G9RiGsW/Y3evbooXQkSiUWqImIMplKpULTFq1QsVptFCpaDKu4yQUp4NSpU3gdEoX83ZfC/pchGD95mtKRiIgom9LS0sKKFSswf/587N27l5snEmWiBg0aIM7vMV7vmYaAk8sxoE9PpSPlSLNmTEff9o3gouOP+XP+REzwG7x7fAWhD06jUMGCn7VPSEhArboN4FquEhyd8uLw4cMKpCYllC1bFpMnT0aTJk2UjkJpwAI1EVEmu3fvHs5fuoqCvVcgb9tpGDt+otKRfmgxMTH466+/MGPGDAQGBmZ4vKtXr8LF1R3FS7ni3LlzmZBQGebm5ogND8L74NeI9nsKC3Pzr7b39PREtx69MGz4SISFhX2nlERElF18vHmil5cX3NzcuHkiUSawtbXF/bu3MHfsbzh36jhatWqldKQcSVNTE5MmTsDuHVvRu3dvrFmxFEYvT6BCHkOsW/35DOozZ87g3pMXKNxvLXL9MgTDR49TIDURpRYL1EREmczY2Bjx76PxPvgNogO8YWxiqnSkH1qT5q0wc/lWLNp1Du4VKiE+Pj7dY0kp0aBhY0Q6VsP7/PXQsHFTxMXFZWLazJGYmIgXL14gJiYmxTbu7u4YOvA3vNk5HhZRT7F6xdIU24aHh6NS1eo48TwW/5y8hWYtW2dFbCIiygHq16+Py5cvQ1dXF1WrVsWWLVuUjkSU41lZWaFNmzZwcXFROsoPo1WrVrh++Tx2bN0MCwuLz44bGhoi4X0k4iPfIS7UD4bcmJIoW2OBmogokzk5OWHW9Kl4s3Mi8PAQtm5ar3SkLBcZGYneffujcvXa2Lp163c995lTx+HQZCQcGw5GSGg4fHx80j1WfHw8wkLfwbRgOZgWcENcXGya1uG8ePEiBgwchNWrV0NKme4cXxMZGYkybuVRorQbcjk64c6dOym2HT92DIIC/HDz2mXkyZMnxXbe3t5Q09aHXeX2sKn+KzyuX8+K6BkSGhqKlStXYseOHdzAi4goizk7O+PatWtwd3dH+/btMX78eP7bS/QTiIyMRJPmrWCTyxE9evVBYmKi0pHSzd3dHb26dcGjFX2g9uzMVydrEJHyRFZ9gM5qrq6u0sPDQ+kYREQ/jAMHDmDRspUoUqgAZkybCl1d3VT3/bVHLxy5/hSGhSrB/+RynD52GGXKlMnCtP+vXMUq8InVh7q+KeKfnseL50+ho6OT7vF69u6LXfsPQaipo1bVCtj2z6ZU9bt79y4qVq0Ok9KNEfP0Eob1745RI0ekO0dKVq9ejXHzVsOxxQQEXNuHknpB2Ld7R4bGjI6ORsEizlBZFUFi+FtUcSmIHdv+yaTEGRcbG4viLqURqWmO+PAgNK1bFSuX80MGZYwQ4oaU0lXpHDkJ779/PnFxcejXrx9Wr16NFi1aYP369dDX11c6FhFlkZGjx2DDocuwqtwRfof/wqyxg9CtWzelYxHRD+Jr99+cQU1ERLh37x7adeqKp5oFseXYVfw+aEja+t/3hHGxWjArUglG9oXx5MmTLEr6uUP/7kX76sXRoKgpLl04m6HiNACsWLYEB3Ztwd6t67Fl04ZU97t06RJMC5ZDrkptYVa+LY4cP5WhHCnR1dVF4vtIqOJikBj9Dnp6qf9BQkr09PTgcfUyfm9RBZMH98DmjesyHjQTPXr0CMHh0XBoOgb2zcZg+/btSkciIvopaGlpYeXKlZg3bx727NmDypUr4/Xr10rHIqIs4uvnDy3r/NA1t4emRW4EBAR8l/OeOXMGs2bNwrVr177L+TLbjRs30LVbD4wbPwHR0dFKx8kyK1auhIGRMcytbHDs2DGl49APhgVqIiLCgwcPYOxYFJYlasHUpQFu3Ep52Ygv6dmtM/yPL8br/bMRG+CFGjVqwMvLC+07dUHnX7tnaNmNbzEzM8OcP2dj+dLFyJs3b4bHE0KgQoUKqFy5MtTUUv+/yYoVK+Ld48t4c34LQi5vRf06NTOc5Utat26NKq7OuDW3DQzfPcLsmdMzZdyNmzbjz3kLsHDpCjx//jxTxswsjo6OSIgOx9sbhxB4dReKOjsrHYmI6KchhMDgwYPx77//wsvLC2XLls2xRSQi+rohAwcg1GMPXmwaipjn16ClpQU/P78sPee///6LJi3bYPGBG6hZpz4uXbqUpefLbL6+vqheqw5OvxJYtecUuvfqo3SkLBEcHIyBg4cgX6e5sKo3GG3bd1Q6Ev1gWKAmIiJUrVoV0b6P8frQAgScWIZO7dqkqX/vXr3w765tmPp7R9y9dQPm5uaoUq0GLryWOP0sCtVr182i5NlH8eLFcfTQAbQoaYY5U0ZjxPBhWXIeDQ0N7Ny2BRs3bICfny9Ku7rj4MGDH46HhISgW49eqNugEU6dSt0s7vv372PqjD9g33IqomzKolPX7lmSPb1MTU1x7MghFFV/hRqFzLB3V8aWNCEiorRr0KDBJ5snfu89J4goc4SHh2P37t24/oU9R0qVKoWnjzzRsXl9JEqB+ZsPoWRp1yydSb1zzz6Ylm2JXDV7wLhEHRw+fDjLzpUVPD09YWCVG7YVWsKqUkdcvHRZ6UhZIi4uDkKoQdPADNrGVoiJic6yPXfo56ShdAAiIlKera0tbt+4jv379yN//oGoV69emseoXLkyKleuDAAIDAzEu9BQlKjcDpASHjMaIy4uDlpaWpkdPVupUKECKlSokOXniY6ORrcePZGv/Qyo4mPRpl0HhIeGQE1NDR27/Io7/vHQyVUUTZq3gue923BwcPjqeCEhIdDSN4aOeS7ER4ch2Ptcll9DWrm7u+Pg/j1KxyAi+qn9b/PE5s2bo127dvD09MSkSZPS9MQRESknMjISLmXK4r2mMaLe+mDGlAno36/fJ22srKxw+twl2NYdAJP8rni9dzpOnTqFdu3aZUmmCu5uODDtT6hpaiPy8QW4DW+fJef5mpCQECxduhRqamro168fjI2NU923VKlSiAv1w6ujSxH39hla/9IgC5NmnEqlQnh4OIyNjSGESHU/W1tbdO/eHWuWdoNUqfDnH3+kqT/Rt7BATUREAJKWUfjtt98yZSwLCws4OxeDz+5pkInxqFqj1g9RnH7+/Dk6/dodAQFvMWncGHTs2EGRHHFxcZBSBR1TW6gS4hAXG4PExESoqanh7r37MK83HHrWeRB1/yiePXv2zQJ1hQoVUDR/btxb2Qfx0RFYsWzJd7oSIiLKaSwsLHDixAn07dsXU6dOhaenJzdPJMohzp8/jxihh9ytpiLC5z7+WrzsswI1AJQoVhRHPE5CFf8e4a8foVChQlmWqVevnohPiMfpcxfQ5M8ZaNSoUZad60uklKhcrSbeaVhAqhKxc89+3LiW+lnQ5ubm8Lh6GRs3bkSuXI3RpUuXLEybJDAwEGMnTER4WATGjRmJYsWKparfq1evULlaDfj5+qJY8RI4c/IYDA0NU33ehQvmYeSwIdDS0oKVlVV64xN9kcipU/K5izgRUfYWFRWFjRs3Ql1dHZ06dcrQ5oU7duzAgMFDoa2ljQ1rV6Fq1aqZmDT1XMtVQKB+QejbO8Nn30zcu3UDefLkUSTLsBEjsWz5SkipwphRozB2zCgAwKgx47BywxboWOSGWugLeN67k6obz8TERNy7dw+WlpbIlStXVscnUtzXdhGnL+P9N31MSon58+dj2LBhKFWqFPbt2wd7e3ulYxF9F+/evcPY8RPxNjAII4cNRtmyZZWOlCqenp5wr1gFuRoMRuRzD5S0xBefUIuMjMSQYSPg+egJfuvTA23btlUg7fcREhICO3tHlBy2E4DEjZlNEBEeBl3djG9EnlXKlq8EP2kGdUMrRNz+Fz7ez2BgYPDNfr369MXh+8Gwq/ErfPbOwshuzTBo0KCsD5wDvHr1CuMnTkZ8QgImTxiH/PnzKx3ph/S1+2/OoCYioiyhr6+PPn0yvklIREQEunbrDqdWk5EQHYZmLVohODBAkUfKfN/4wrxBR+hZ54WOgSkCAgIUK1DPmf0HBvTvB3V19U8KAjOnT0XF8u7w8/ND8+bNUz0rQl1dHS4uLlmUNmVLly3DlGkzYWFpgW2bN6Jo0aLfPUNmuHnzJub/vQi2NtaYMG5sqj4kEBHlZEIIDBkyBIUKFUK7du3g5uaGvXv3ws3NTeloRFmudbuOeBCUCC2LPKhVtz6ePXkECwsLpWN9U9GiRbFs0d+YPf8vFM6dGyuWLvpiOwMDg5/miToTExPksrfHm+PLIVUJKFC4SIYm1jx9+hTr12+Ao6MDunfvDnV19UxMm+T+ndso2n8tNHQNEX73CF6/fo3ChQt/s58QakDyJFWpUnGJjmRSSlSvXRexliUgNLRQpVpN+Lx4Bg0Nlky/J86gJiKibC0gIAB58hWE84D1SIyNxv3Fv+J9TIwi613+9ddCjJ88FTrG5shtY4ZL585AU1Pzu+f4UXh5ecHF1R15Wk9BxKv7MH57A3duXFM6Vpq9ffsWBQoXhYlrM8T5P4Vbfkvs282NHLM7zqBOO95/U0ru37+PRo0awd/fH+vWrUObNmnbbJkop7GwtoV9m5nQMbXF8/UDcWD7Bv5wJgfz8/PD7Dlzoa6mhpEjhsPS0jJd47x9+xaFihaDXqGqiPN/jFb1q2HJor8zOS3Qqk17nLv5EOr6ptB/748Hd2+najnFN2/eoEr1mvB54Y3Srm44eewwJ1UgaflEXV09uI7ZDwiBe/Pa4qW3V7r/HFDKvnb/zd0siChHiImJwebNm7Fr1y4kJiYqHYe+4s6dO6hQpTrKlq+EixcvZng8a2trtGvXFk9W9sHTNb9j3PgJim3GNHDgAFw8exJbVy/GxbOnM6U4/eDBAxQo7AwjEzNMnT4jE1LmHMHBwdDWN4KedR4Y5CqCoMBApSOly+PHj6Fragvb8i1hVaUTrl3LeUV2IqKMKFasGK5duwZXV1e0bdsWEydOhEqlUjoWUZZp1rQp3hyYg1cH5kIbcXB2dlY6EmWAra0t5s+dgw7t2+HEiRPw9/dP1zi3bt2CnmVuONTqAZuavXH46LFMTprkn03r8cfYgRjdvRmuXb74WXHa09MT+QoWgZ6+IUaOHvvhdQ0NDdSoXg3NW7TE+jUrWZxOpqWlhao1auHlzsnw2T0dRYoWzRFPRPxoOIOaiLI9lUqF8pWq4mVIDFSxMahevhS2/bNJ6Vj0BVJK2OZyhF7pZlDT0kPg6ZV46+8LbW3tDI/78OFDaGlpZZv1wOLi4rB+/XpERkaic+fOMDc3T9c4ZdzKI8SiNIzzl4X35pE4e/JompfakFJCpVJlySOEWSkhIQG16jbA3YdPEBcVjvlzZ6Nnjx5Kx0qzsLAwFCzsDA3HUogPeokmtSpi5fKlSseib+AM6rTj/Td9S2xsLPr27Yu1a9eiVatWWLduHfT09JSORZTpEhMTsW3bNgQFBaFt27bcMO4HsHPnTnTr1RdGDkXw3v8p7t66ATs7uzSN4evriyLFSsC4VCPE+nqiXvniWL9mVRYlTln5SlXhZ1gUZoUrwfufkTi8byfKlSsHlzJuCNLKBXU9Y8R4HoeP97MMLWfyI3n//j02bNiAhIQEdO7cmcX7LMI1qIkoR/P19cUDT084/74JqvhY7PqzFeTmjVwzKxtKTExE0Ft/lCpeA0JdA2+OLUFYWFiGb9qFEN9cmzggIAAHDhxAnjx5UKNGjQydLzXatu+Ei/e8oK5vhsXLVsDz3p1UPVr3X2Hh4dAp5ABtYyto6hkiPDw8Tf1v3LiB+g0bIyTwLXr16YvFC//KMX83NDQ0cPLYYdy8eRPm5ubImzev0pHSxdjYGDeuX8GmTZtgZdXsu+zeTkSUHWlra2P16tUoWrQoRowYgefPn2Pfvn3cfJd+OOrq6mjfvr3SMSgTLVq+CtY1esHcuQpe/zsHBw8eRM+ePdM0hp2dHc6cPI5lK1Yhd82mGDp0SBal/bqIyEhoO9hC08AUGjoGiIyMhJQS9+/cQqnhY6GmqY2Htw/D398fTk5O/98vIgJv376Fk5NTjpv4klE6Ojro1auX0jF+apxBTUTZ3vv372Fn7whj99ZIjAmH1hsPeD32VDoWfeTIkSMYMWY8DA0MYG1libNXbkBNXRPuLkXw797dWV4wDQ4OhnNxF2hYF0CU71NMGDUMgwcPzNJz6ujpo9hv66GuY4Any3vgyrmTKFSoUJrH2bVrFzr/2h2a2nooU6okjh76N00bcpQuWx5hdhVgWrginm0YhEO7t6F8+fJpzkH0s+EM6rTj/TelxYEDB9CuXTsYGhpi//79cHXlXzciyr76/fY79py7A+MSdRFwfAn2bNuEatWqKR0rXQ4fPoxWbdpBXVMbZUqXwrHDB6ChoYFfGjfDjSevoaZjAJPEENy9dePD547Lly+jXoOGkGoaKFywAM6dPpFtZld7e3vj3r17cHNzg42NjdJxKAO4BjUR5Wg6Ojo4efwoCsqXKG36HsePHFQ60k8hISEBqfkh5rt379CydVvEFvwFvnqFcOfuPezYsBKbVvyFfbt3fpfZvOfOnYO6qT3sG4+Ebb3fsWrdhiw/Z0mX0vA7sw7+F7dBTSbA3t4+XeO0aNEC3l5PcPncSRw/cjBNxWk/Pz94PnoIdR19qGloQqhpID4+Pl05viUqKgpPnjzJsvGJiOjH0rBhQ1y6dAna2tqoXLkytm3bpnQkIqIU/fnHTNR3Lwz9pwcxbeKYHFucBoD69evj1UtveFy5gBNHD334fLFn5zZMHdoLo7o1w6XzZz/53DFq3ERYVOmKIv3XwSc4Gvv371cq/icuXbqEkqVc0W/MTBQpVgLPnj1TOhJlES7xQUQ5QqlSpXD00L9Kx/gmKSWioqKgr6+fY5ZZ+C+VSoWOXX7Ftn82w9beAcePHEJ4eDhWrFqDAvnzYcjgQZ8sZREUFAQ1TW2YFHBDfFQoHp3f/F2W2PhYwYIFEe77FMEPziLq2TVULVEsy895cP8eTJg0BeERERiz8BT09fXTPZaVlVW6lkH5c85cGDgUw/N/F0AmxqNwoUKoVKlSunOkxNPTE5Wr1YBKqMPC1BhXL12AmZlZpp+HiIh+LMWLF8fVq1fRvHlztG3bFg8fPsTEiRNz7D0SEf249PX1sWblcqVjZBpTU1OYmpp+8pqWllaKy5YYGhggPiIICTGRSHgfmaHPNplpyfKVMCvXGjbuTfHq2DJs3boVY8eO/XZHynE4g5qIKJMEBASgsHNxmJlboJSrO0JDQ5WOlC5HjhzB8XNXUHrkLmgUroMeffqjdt0GOP4iEfPXbMfAwUM/aZ8vXz6UdimJ5xuHwHvzSPw2YMB3z+zs7IxN61YjV+hN/OJWAMsXL0zXOFJKjBg1BnkKFEbrth0QGRmZYlsLCwssWfQ3Nq1f+831sbOKuro6tPSNUWrgBpjnL40ObVtDTS3z/9c+beYfMCjRAAV7r0aUri02btyY6ecgIqIfk5WVFU6ePImuXbti8uTJaNu2LaKjo5WORUQET09PlHJ1R+58BbFp02al4yjq7/lzoBdwC/cXdkaTutVRv359pSMBAPLlccJ7n9uIeP0Qsb6PkDt3bqUjURZhgZqIKJPM/nMOIo3yotTIvQhQGWHJkiVKR0qX+Ph4CA0tqKlrQk1bH6HvQmHkUBh2FVrBomIHnD1/8ZP2ampqOH7kIDav+BsH92zDHzOnK5K7SZMmOHPiCFYuXwojI6M091epVBgyZAiWb9gGg+q/4fxDX0ycNCULkmaekSOGwzzeHzdnt0RuQ+C3337LkvMYGhogISIIie8jkRgVmu5dradOmw5Tcys4lyyNJ0+eZHJKIiLKrrS1tbFmzRrMnj0bO3bsQNWqVfHmzRulY30XUkocOHAAa9aswbt375SOQ99ReHg4WrRuhwJFimHq9BmpWjqPvq8WbdrjnWVpGFTpgz79fsPr16+VjqSYvHnz4tGDu4h9H4PVK5dnyaSX9Bg9aiQaVCyBhKtr0b19c25O+gPLHn/iiIh+AEk3neI/3+c8DRo0QPF89ri3oB3eXdyI2TOnItL3CV6dWI23p1ehYYN6n/XR1NREnTp1UKFChRz72G7/AQOxcv0/0LLKC33bAtCxL4YXPq+UjvVVFhYWuHf7BmJionH9ysV0FeY/plKpsGrVKgwdOgw3btz48Pq0yZNgpxaC+ws7o2KJ/OjcuXOax75x4wbm/rUYudv/gSjrMvi1R+8MZSUiopxFCIHhw4dj3759ePToEdzc3PAzbLo5fOQodOk7COMXrEMZt3KcPf4TGTZiFC57BUO7Qk/MX7wCR48eVToS/cfbAH8Y5SkFA/vC0NQzRHBwcJrHCAgIQN/+A9CtRy88f/48C1L+3HR0dLBm5XI8vn8Hf8ycnm0K55T5+DtLRIoICAj44WaRjBg+DHqhT3F7dnNYyHfo37+/0pHSRVNTEyeOHsLzp4/h7/sav/zyCy5fOIduNQtj9oRhmDVjGi5evIgKVaqjVr0GP8xM2O07dsCx6UiEe9/G/VUD8Pb8Rgz+PWO/h5s2bYZbhSro1LUbwsLCPry+b98+1P2lMQYNGZopH1Q/XhM8IyZNmYpR0+Zh240AVK9ZB0+fPgUAWFpa4vrlC3gfE43dO7dBU1MzzWO/e/cOWvrG0Da1gY5VHoT8YH//iYgodRo1aoRLly5BU1MTVapUwfbt25WOlKU2bNwM+8aj4NBsLCLjBe7cuaN0JPpOvF/6QC+3CwzsC0PPJj98fHyUjkT/MXb0aLzYOhbP1g6AS/EiKFYs7fvY1KrbAP/efIXjT6NQqUq1DG0o/uTJE8yZMweHDh1KVXspJTZs2IBBg4fgwoUL6T4vUXbAAjURfXdDhg2HU74CsHNwxIqVK5WOk2lsbGzw5OEDvA3ww91bHjAxMVE6UroJIWBjYwNtbW0AQJEiRTB1yhT8+uuviImJQYOGjRFg7govVS7UbdBI4bSZo0TJkgi7fwrWbs2gCvPD+TOnUr3h4Pnz52GfOw/MLK2xdu06AMDt27fRb+BghOWuhZP33qBP/6S1ue/cuYNOXbvjmXYRbD1+DYOGDMuqS0qzw0dPwLJSJ9hX7QjjvC64evVqpo1dpUoVFHC0wZMVvfH63z8xY8rETBubiIhyluLFi+PatWsoVaoU2rRpg8mTJ+fYJ8++xbmYM4Jv7EfgnROICX0LJycnpSPRdzJ04G8IOLMaPtvHIjHgCZo0aaJ0pGzvwYMHaNW2A7p26wFfX98sP9+QwQNx9eI57N++EccPH4S6unqa+qtUKjy4dxt2NXvArmonhEdG4e3bt+nK4u3tjbLlKmDBznPo0K0PFi1e/M0+8+b/hcFjp2LXnXeo36gJbt++na5zE2UHLFAT0Xfl5+eHZctWwLnfGhTsMh+DBg1ROlKmEkLA2Ng4xy5zkRpBQUFQQcCiWHVYuNTFa58XP8SHyp1b/0GDUg5wMQjByePHULp06VT3bdmmHfTKdUau5pPQf8DvCAwMhJeXFwxt88O0oDuMi1SD58PHAJKWujByLAqL4jVgUrI+btzK3JlUHh4ecMyTDwZGxpj5x+w09a1TszqCLm3Gm/NbEfr8Ftzc3DItl5aWFs6dPoGzxw7A6/FDNGvWLNPGJiKinMfKygqnTp1C586dMWnSJLRr1w4xMTFKx8p02//ZhGqFzJHnvSf279kFW1tbpSPRd1KvXj3cun4Vq+ZOgef9O7C2tlY6Uprcu3cPq1evxuPHj7/L+WJiYlC1Ri1cC9bFySdh320STJEiRVChQgVoaGikua+amhqq1agNnz3T4bN/NhwdHWBjY5OuHKdPn4ZRnlKwr9sfVtW6Y8v23d/sc/jYCZiVa4NcldvCpGAFXLz4/3sFvX37FkePHv0uhX6izJD2v4FZQAjhAGADAGsAEsAKKeVfyqYioqygqakJKVVIiIlAfFQotHV0lI6UrUkpsWbNWly5dg3NmzbJFrspOzg4wKVkSTzZMgqJsdHo0vXXH6Igb25ujpXLl37yWkJCAm7cuAELCwvky5cvxb6RERGwtXKCpqEZ1DQ0ER0djerVq0MOGoJXe6Yh0s8Ls6dNxq/de2Lzpk1IlBIq9bmI8X2IyWNGZup1dOzaDZolm6NA7mKYMWsomjdtgkKFCqWq75TJE2Fna4OHjx+j08zDKFiwYKZmU1dXR4kSJTJ1TCIiyrm0tbWxbt06FC1aFKNHj8azZ8+wb98+2NnZKR0t01haWmLT+rVKxyCF5M+fH/nz51c6RpqdPXsWDZs2h0k+V4QNHYEzp46nafJGegQEBCAuQYV85VtCFR+LW3NaQUqZ7T9nHNy/B6tXr0ZcXBy6deuW5lnY/1OyZEmEeY+E5q2jiHp8Hr80rIYrV67A2toaefLk+WKferVrYuaCpXgf8gahjy+hQoWkDd6fPHkC9wqVoGeZG5EB3jh3+iRKliyZ7muk7CshIQEHDhwAADRs2DBdP2jJLkR2mPUmhLAFYCulvCmEMARwA0BTKaVnSn1cXV3lz7CpBtGPaPHiJRg6fDi0tXWw9Z9N2aLoml0tWboU46fPhYFzLby7vhsH9+1C5cqVlY6FuLg4HDp0CLq6uqhTp062v3FMj/j4eFSrWQePn/sgNjIUC+b+ie7du32x7YK/FmLs+PFQ19BC0yaNsH7NKgghEBQUhGPHjiFPnjxQU1NDvSYtkf/XRQi6fwbRHtuxcf1a1KlTJ1Nz2zvlg3H1/tC3K4Cnq/vjxME9KFOmTKaeg+hHIIS4IaV0VTpHTsL7b8pK+/fvR/v27WFsbIz9+/fz/11ECurRqw+Ov1DBtnwLvD69Dp0r5cWMGdM/HPfz88P0GbOQqFJh7OiRsLe3T9d51q/fgIFDhkJbWxsb163BkBGjEJyoD9X7SJQrnh/7du/IrEvKEQ4cOIBVazegeNHCOHriFJ6/8sP7yHdYuvBvdOrU8bP2UkqsW7cON2/fQeuWLT58Thw7dhzWnX0Ch5rd4Xt+CxoUNsCyJYu+9+XQd/BLo6a4/sALkBLlSxXBvt07lY70VV+7/84WS3xIKf2klDeTfx0B4CGAXMqmotSKiIhQOgLlMP3790NMVCRCQ4JYnP6GE6fOwqRME9iWawbjIlVw6dIlRfNIKXHp0qWkWRUNG6Ju3bo/ZHEaAK5du4bH3q+Qr9si5G4xAZOnz0ix7aCBA/DY8z48rlz4UJwGAAsLC7Rv3x7ly5dP2nFaSkCqoKlrAHMLy0wvTgPAnFkz8GLnZDxa2h3VKpVDqVKl0jzG7D/nwNY+N8pVqsINfYiI6Lto3LgxLl26BA0NDVSuXBk7dvxchSnKWaSUSEhI+GqbJ0+eYNasWdi1a1eOWw6veDFnRHtdxrsnVxHj7QFn56IfjkkpUbVGbez18MGB2/6oVLU6VCpVms/x7t079O3fHw4tp8C0Rj+0bd8Rl86dwYR+7fHH2IHYue2fVI91584dtG7XEb369kNQUFCas2QXDRs2xN5d21GjRnV4+wUhX7dFcGw6BpOmfflziBACv/76Kxb+teCTSUwODvaI93+CKP9niPV7CCdHh+91CfQdhYWF4cTxY3BqPwtO7Wfh0IF/ERUVpXSsdMsWBeqPCSGcAJQCkHk7M1GWCQgIQNGiRTFx4sR0/U+Jfl5CiB+2sJmZGjWoh5CrO/D67CaEPjiNatWqpXssKSXOnj2LI0eOpHt36aHDR+CX5m3QoefvqNugUY672U4LS0tLxEaGItrvGSJf3YeVldVX29vb26NgwYIp/rl2dXVF6xZNcHteGwScWIIVS1M3i+HPOXNha58bbhUq4cWLF99s37ZtG7z0foZb1y9j945tSYXxNLh+/Tqmz54Ly4aj8EbDAd169UlTfyIiovQqUaLEh80TW7dujSlTpvzQ9xr0qfj4eDx9+hTR0dFKR/mqR48ewcEpL7S1ddCmfUckJiZ+1sbHxwdu5Sti4b6r6DVwBGalcV8Qpf3Wvx/6dm4JS79zGDGgF9q3b//hWExMDLyfPUGu2r1gV7M7/P38EBYW9kn/d+/effJ5Iy4uDjdu3ICfn9+H196/fw9ADdqm1tA1t0d0VCQMDQ3Rt29fdOjQIdVLFYSHh6Nazdq4GqyHgzdfoVGzlmm61qCgIDx79ixT/63x8/PD48eP0z2mpaUlYsNDEB3gjajXnrD+xueQ/+rRowda1K2MiJN/oX6FEhg8eFC6clD2ZmBgAENjYwTeOoLAm4dhZm4JXV1dpWOln5Qy23wBMEDS8h7NUzjeC4AHAA9HR0dJyouOjpZdu3aVAGT9+vVlcHCw0pGIfji7du2SI0eOkufPn8/QOH37D5CmtrmlZe7CskbtelKlUqV5DG0dXVl6yBbpNu6gNDS1lM+ePctQpuxuydKl0s7BSbq4usnHjx9nypjR0dEyISEhVW09PDykkbm1LN57qXSo1klWq1UnUzJ8zYEDB6R1/hLSbfxhWaj9NOlcskyWn5NICQA8ZDa4/81JX2XK8N8D+j5iYmJkp06dJADZtm1bGR0drXQkymIhISGyQOGi0tjCVppZWktPT0+lI6Wodv2GMnftnrLs6H3SIndhuW/fvs/abN68WdqXrCrdJxyRhTvOkKXdKiiQNOuULVdR2hSvIm1KVJclSrl++FyRkJAgGzVtLrV19aSJmYW8evWqjI6OlvkLFZGaekZSQ0dfTp069cM4ffr9JvWNzaSegbGcO2++jIuLk42aNpdqaurSMU8++fTp029muXfvnjSzdZTuE47I0kO2SH0j41Rfx+bN/0g9AyNpYGohm7dqk67PR/+1du06qWdoLI3MrDI05oIFf0ubXI6ytFt56eXlleFcGfX+/XvWe7Kh27dvyxq168katevJu3fvKh3nm752/50t1qAGACGEJoADAI5KKed9qz3XwMs+pJRYvnw5fv/9d9jb22P37t1wcXFROhYRfURKCS1tHZQctBnq2np4sLATHty5idy5c6dpHKf8BSEK1IKmsRV8Dy3Am1cvYWxsnEWp6ciRI+jSfzicOvyJ8Oe3IO5uh+fdW1l6zpiYGJSrWAW+QaF4Hx6MtatWoGXLtM1EIcoJuAZ12vH+m74nKSVmz56N0aNHw9XVFXv37v2hNk+kT/3111/4Y+0+ODQeAf+L21Apl8TmDeuUjvVF1WrVhY9OYViWqosXW0ZjyR8T0KJFi0/aPHjwAOUqVoFFxfaIfnYVretVwrjRI/H3wkXQ0tTEoEED8eTJE7Tr2AXh4WGYNX0aunX79avn3bt3L/YdOIQqFSuga9cuij6NGhERgZUrV0KlUqFnz54fPg8cPnwYnfsORp4OfyL4/hlYBntg5NBBaNW2A5wa/g4NbQN47ZyG8NAQ6OnpAQC8vb2hra0NOzs7bN26Fb+PmwmnNtMQcGUXSplEY++u7V/NEhsbi6LFSyJGPxcSIoJQs1xJbNm0IVXXYefgBNPaA6Fvmx9PV/XF6aMHMlzLsLazh9Uvo6BrlRtPVvbG+ZNHUbx48Q/Hr169igmTpyEuLhYPPT0RH5+AeXNmo0uXzmk+1507dzDrz7kwNzPD1MkTYWpqmqHsKTl9+jQaN2uO+Lg4NG/REps3rOPT0JQu2X4NapH0J3s1gIepKU5T9iKEQJ8+fXDu3DnExcWhfPny2Lhxo9KxiOgjQgjY2Tsg+N5JhDy6CCFVUFdXx++DhqBdh864efMmgKQPgyNHj4WZhTXKuFf4sP7wsWPHULl6LRQuVAjmIbeh8+Qgdu/cnqOK01euXEGDRk3RqWs3BAQEpLqfSqXC9evX8ejRoyxM92XVqlVDLjN9PF3dDy/2zsSAvr0y/RzTZ8yCrr4BbO0dcfXqVejq6uL6lYvYt3U97t+5xeI0EREpQgiBkSNHYs+ePfD09ISbmxtu3LihdCzKIvr6+kiMCUNibDQSo4JhaGCgdKQUzf1jBkKvbMG9+e1QNI8NGjVq9FkbZ2dn7N21HWWN3qFvu4aYPXM6KlSuinXHb2PZnnOoXe8XtGrbASjaENaNxmDAoMGfLH/xX0ePHkWXHn1x+o0Gho6bgrVr12XhFX6boaEhhgwZgmHDhn3yeUBdXR1SlQgpVZCqBGioq8PExASJ8bEwyecKI6cSgBCIjIz80CdPnjwffviUkJAANXVNCDV1qGnqID7h28sSamtr4/qVSxjdrSnmTBiKjevWpPo6DAwNERvqj7iIECTEvoe+vn4a3oUvMzQ0QkyQD2JDA5AQ+x4GBgbYtm0bChYtDveKlVG7bn08Vc+HR1GGCE/QgF2z8ejb/zeEhISkavyoqCg0aNQUxqbmcKtQGRf91LHn0mM0a9U2w9lT0u/3wbCt+ztKDNqCIyfP4vLly1l2LvqJpTS1+nt+AagEQAK4C+B28leDr/XhI4bZk7+/v6xWrZoEIPv37y9jY2OVjkREyR48eCArVa0hS5UtJ0+fPi0rVK4mrV1qydx1ekkjU3MZFBQkT506JU1tcsuSv62RDlXayQaNm8pXr15JAyNTmb/FaJmrfDNZtWbWLzOR2YKDg6WhiZnM88vvMle5prJcxcqp6qdSqWSjps2lqY2jNDS1kDNm/ZHFST938uRJqatvKK0LuUpjM4tMWWokKChIHjx4UJ44cUIamJhLl4EbZL7mI2X+ws6ZkJgoZwCX+OASH5Rj3L59Wzo6OkpdXV25Y8cOpeNQFoiNjZVNmrWUWto6soxbeRkQEKB0pK96//699Pf3T/XyDb6+vlLfyFS6Tzgi3cYdlEJNTRqbWcgSfVfIsmP2S0MzK/no0aMU+0+YMEHmqtxWuk84Ip3q95cdu/yaWZeSqRITE2XbDp2kuoamtLC2lbdu3ZIqlUq6V6gkNfWMpbaxpWzUtHmK/WNiYmTFKtWlrr6RtLC2lffu3cvSvNeuXZP2ufNIfUMjOfOP2Zk2pmOe/NLI1FwuWPC3fPnypdQ3MpGFO82StuWaSS1DM+k2/rAsPWSLVNPSla6j9kg9Q2P5+vXrVI0/afIUaVO8iiw1eLM0yuMiHWv3lKUGbZJGpuaZkv9LipUsLfM3HyXLjNwlTazs5ZUrV7LsXF/y4sUL2bhZS1mtVl158eLF73puylxfu/9O3arzWUxKeQEAnw/4AVhbW+P48eMYOXIk5s2bh1u3bmHHjh18HI8oGyhatCjOnzkJIGnpiCtXr6BEn2XQNrFB5MNTePbsGUJCQqBlZA5tU1toW+VBsO8FvHz5Erqm1jB3ropoy9x4/O+Xd5HOznx8fKCpZwTL0vURFxEEz/WDUtXPy8sLZ85dQOG+qxEXHowZMwZi9MgR6coQFhaGkydPwsHBAWXLlk11v7UbNsGqUgfYuDfFq2PLsX37dowbNy5dGQDg9evXKF3WHRomdgh9/Rjq2nrQ1DeBtrE1QnPwrs9ERPTjKlmyJK5du4ZmzZqhVatWmDJlCsaNG8dHzH8gWlpa2Lt7h9IxUk1bWxvW1tapbm9paQlLSwu8OrIYMj4GpV3d0aVjB4weNwLqWrqoXbM6ChYsmGL/WrVqYd7fiwGhjkjPU2i0eEGqzx0WFoY/Zv+JyKgoDB08KM1L/KWFmpoatmzagHWrV0JLS+vD39HLF87h1q1biIuLg7u7e4r9dXR0cP7MSQQGBsLU1BSamppZlhUAypYti1cvnmf6mC+fP/3wvYeHB7QNTGDkVAIaOoYIunMMPrsmIzo0EOrqani0vCfatW2LXLlypWr84JAQqJvYQcvQHLqWjgi5dxIxz699cSZ/Zlm5bDEaNGwM7/1z0bNXb7i5uWXJeaSUX/y9/6VxM4SZFoGWsTPq/9IIr156w8jIKEsykHKyRYGafiwaGhqYO3cu3Nzc0L17d5QuXRrbt29HlSpVlI5GRMkWLFoKg1xF4LV7NrRNbaCKDoezszOKFSsG6+mz4LWqL2KjQrF4xzaULl0axjoCPrsm432IL/r16PrJWIGBgfDx8YGzszN0dHQyNWd8fDx69e2PI0ePoUqlSli3ZuVXdyaOjIzE9BkzsHDhIujo6eOfjetRp04dFClSBBbG+ni1dzriw4PQpnXrVJ3/f48kRr15jPchvoBQx82bN1G6dOk0XUdERARcypRFrJYpot6+xMypE9Gvb99U9S2YPx+OXdmHcJt8iH3zAHnzZmzJjR07dkDTviQcGgyElscBJHoegufirlAlxGPt6lUp9jtz5gxWr9uAYkWLYOiQwaneWZ2IiCgzWFtb49SpU+jVqxcmTJgAT09PrFmz5qv3BUTZhYaGBi5fOIf5C/6ClpYWhg4ZDBMTEzRq9AsiIiJQrFixr/7ApXLlyji4bzeOHjuGCiNW4pdffsGZM2cwdOQY6OnqYsXSRShSpMgX+/7SuBmeh6tDTd8UOytWhvezp9DW1s6qSwWAz8YXQqT6/lkIASsrq6yI9VWxsbGYN28+Xr/xRZ/ePT9ZNzojSpYsify57eG9cQhiw0MwYexYONjbwcjICKVLl0ZcXBzy58+f6vF+/60/tlSsgmcvPCDiozGoRzfkzZsXnTp1ypS8X1KuXDkEBwYgPj4eWlpaWXKOmJgYVK9VF3du34aOthZWrlj2YanBZ15PULTvSGjoGSP40hb4+/uzQP0jSmlqdXb/4iOGOcP9+/dlgQIFpLq6ulywYEGm7IpLRBnXf8BAaV28mrSr1E7qGprKTZs2fTgWFxcnb9y4If39/T+8FhoaKjdt2iSPHTv2yd/jc+fOSUMTM2lun08WKFxUhoaGZmrOJUuWSMv8pWSJfiultXMFOWnylE+Oq1SqD0sJ+fv7S9tcjlLb1FZq6BpJp/q/SVNzy0+uYeXKlXLnzp0yMTHxs3MFBQXJy5cvy7CwsE9e37Jlq9QzNJVahubSplwzaWRqLt++fZum6zhw4IC0KVhauk84Iot0+VMWKlYy1X1jY2Nln36/yWIurnL8xEkZ/nd0x44d0tw+v3Tu/pe0KVFVDho8VL548eKru3Lfv39fGpiYydx1+0jL/KXkkGHDM5ThR+Hv7y+HjxgpR44aLQMDA5WOQ2kELvHB+2/KkVQqlZw5c6YUQsiyZctKX19fpSNRDhEdHS1Pnz4tvby8lI6SYeHh4dLAyETmbzlGOtXtI3PnK5BiW00tLek6ao90n3BEmljayadPn2ZqlpCQENmjVx9Z95fG8tSpUxka6+bNm3LgoMFy0aJFMiEhIZMSpk7HLr9Kq8Ju0r5aJ2lkav7JZ6GMio2NlSdOnJC3bt3KlPHCwsLkzZs3ZURERKaMlx2sWbNGWhcqK43ylpa6lrmltqGpHD9xkpRSyh69+kgLx4LSprCrLOXq/t3/bFDm+dr9N6c/UZZydnbG9evX0aVLFwwaNAjXrl3DihUrMmXzASJKv1kzpuFd399w8/Yd9B89Au3bt/9wTFNT87MZDsbGxujQoQPi4+Px/Plz2NnZQVdXF1Nm/AHLKl1hUbI2Xu2ZhlWrVmHths148ugBmrVohX82roe6unq6c/r5+0PTMg90LRygZZUfvn7+H449f/4cNWrXxasX3qjb4BdUr1IJsC4Ml4ZD4Hd5N8Je3EZMTDSklBBCwNjYGD169Pjiee7evYsq1WtC29gS4n0EPK5dhr29PQCgbds2+H3wUNi1nAodMzt4BzzC06dPYWlp+cWxYmNjcf/+fTg4OODNmzdYunwFtLW0EPn2JUK9PBD57BpK5cuX6vdAS0sLSxcv/GqbxMREhISEwNzcHGpqX9//uEWLFrh1+y627VyOaq5lMHXKJBh8YyOiW7duwSSPC2zcmyLUwgHnLhxOdf4flUqlQuVqNRBllBcyMREHDtXB/Ts3lY5FRPTDE0Jg1KhRKFy4MDp27IiyZcti//79aX66iX4uUVFRcHUvj5CoBES/C8CalcvQqlUrpWOlW3BwMKCmDrPCFZHwPhL3Tq9NsW2VajVx/9+5UNc3gaG+DhwdHTM1S8cu3XDLNwa6uZzRpFlLPLh3Gw4ODmke58WLF6haoxaMSzZA7P4T8H7pgzmz/8jUrF9z5uxZWNcbAT0rJyT63sf9+/fTtIzL12hpaaFmzZqZMhYAGBkZoVSpUpk2XnagoaGB+JgIvA8LgcuAtYgLD8SCBYMxZdJELF+6GE0OHUJERASaNGmSoc+XlH19/VMsUSYwNjbG7t27MX36dGzZsgXly5eHl5eX0rGIsqUHDx6gU9duGDBwcKp3ck4PAwMDbN64Dg/v3cKY0aNStYZjSEgInEu4oEy5SnDMkw+PHz+GpYU5YgO9ERsagLiwt9j37wGEGxVEiUFbcPrqHWzfvj1NuQ4dOoROXbvh74WLoFKp8GvXroh9dgkv/xmO8DuH8Fu/Ph/ajhw9DirH8igzei9uPPKBl5cXEkL98P6dPyJ9HyPi+U38+ccfqbq2+X8thFGpRsjTaT7UHUph/fr1nxxv0rgRfA/Nx6tDf0EtNjLFR/7+t5RH3SatkbdAIVSqUg1Hnr7H9uNX4VKiOHQe/4uy9jpYs3JZmt6Xr3n58iWc8hWAY558cCnjhrCwsK+2F0Jg+rQp8Hr0AFs2bfhmcRoAKlasiDDv23h1YhUCz65F08a/ZFb8HCs0NBQ+L1/Cvm5/ODQYgEee9xETE6N0LCKin0bTpk1x8eJFqKmpoVKlSti1a5fSkSgbO3HiBELjNeHUaR5yNRiMaX/M+Wr76Oho3L59G+Hh4d8pYdrkzp0bZV1d4b1pGLw3j0DPXr1TbLtv9w4M6dwIPeqXwbXLFzN9iYa79+7CwrUpLF3qQM8iV7o/61+/fh3Gjs7IVbUjLCp3wdHjpxAXF4fXr19j8+bNuHv3bqbm/q+6tWvD/+RyvDq5Gu9D3qBkyZKZMu7Lly/RvWdv9OrTF2/evMmUMT8WFxeHY8eOwcPDI9PHTq+3b9/i1atXXzx27NgxDBg4CNu2bUPShNokbdq0QckCjoiPCkXY81t49+gS7HIlTRhSU1NDw4YN0a5dO+jp6X2Xa6DvjwVq+i7U1NQwZswYHD58GG/evIGrqysOHDigdCyiDAsPD8e06dMxYcJEBAYGZmisiIgIVKleE+deSey6+AhNmmd8VoeUEk+fPk2aZZFB69evR6SOLQr1XQs95zqYNvMPzJ8zG7k1Q+GzZQTaNfsFxqbmUDMwhbq2HtR1DREdHZ3q8S9fvoy2nbri/FtdTJ27BH/OnYc8efLg6SNPbFu9CE8feX5SGI5PiIfQ0IIQahAamnB3d0ejGuXxetsoFLPShOe92/jtt/6pOre1lSXiA1/g/Tt/xIe8+mzdu2VLFmH2+CEY1Lo6bly/AkNDwy+Os3fvXoTBAPm6LYZ19R6QGjqwq9QWVpU74bWvH257XMGendtSnH2dHtNnzgIcyqLEkO0IVBli9erVmTb2/+TJkweXL5xDrzrFsPjPqRgzamSmnyOnMTExQZ58+fDq4AK8OjAPxUq4cB1UIqLv7H+bJ5YsWRItW7bEtGnTPil4EP2PjY0NYkL8EO3nhSifu7C3s0uxra+vLwoUKoJaDVsgT/6CePTo0XdMmjpCCBw99C/WL5mLPVvWY9HfC1Jsq6+vjxEjRmDypEmwsbHJlPM/e/YMe/fuRUBAADq0a4c3B+bg1f7ZUI8LR5kyZVLsFxISgvaduqBcpWrYuXMnEhMT0X/AQDjmyY8Nm7cg9OV9vDm3GW/PrIa/ny90dHWRt2ARjPhjGSpWrYFDhw5lSv4vWbp4IcYP+BVW718gPj4ejZq1QEBAQIbGTExMRKWq1XHscRgO3wtCtZq1M/XfqISEBFSpXgsdew9CrfqNMXW68pvZL1u+HE5586Owcwn06ffbJ8fOnDmDlm07Yt+DCPQZNALr12/4cExLSwunThzFzm1bIO7ugG30I+zdlbbJTpSzsUBN31XdunVx48YN5M2bF40aNcLEiROhUqmUjkWUbnUbNMLi7Sew6tB1lK9UBYmJieke6+XLl4CGDmwrtYVtta64dTNjPwVPTExE/V8ao0y5SsidJx/279+fofH09fWRGB2GxLhoJESGwNDAANbW1rh49hRCAgOw8K/5mDpxHMKv78KjxV1gpRWHNm3apHr8a9euwbhgediUbQzjMo1x9vxFAICpqSmqVKnyWVF3xtTJeH//CO7Ob4u8Fnpo164dVq9cjqAAP5w9dRwFChRI1XmllBgzehTKOJngzfbRqFepNH799ddP2qirq6Nr164YPnw47FL4QDP7zzkYPGwkgl8+RMQrT8QGPocqLgavTqyC34llqFqpYob+fKREXV0DMjEekCrIxPgse+TN2dkZEydORNu2bVM1K/1Hp6amhgtnTqFnw3Lo3bQyTp84qnQkIqKfko2NDU6fPo0OHTpg/Pjx6NixI59ooc+4u7tj3KjhCDu5APl0wrBy2eIU265evRqwK4H83ZdA37kO5i346zsmTT1NTU3Ur18fVatW/a73ZmfPnoVLmbL4bfxsFClWAr16dMOaxXPRvVFFGBgaIn/holiydOkX+/7aozfOPg5CiH01/NqzD2bNmoXtB0/CpO5QXPcKRJvWrdDCxQIl8tlBK3cZlB3zL/TtnaFhUwRWVbpg2co1WXZdmpqasLOzw+ugCOTv+jdeJZhh2MjRGRozNDQUQYGBsKvWBXY1foX3My/ExsZmUmLg/v37ePL8JfJ0movcbaZifjb4szp8xEgU6DIPRfutwabN/8DHx+fDsXPnzsHIuQbsKraGaZmmOHri1Gf9mzdvjof3buPy+bMoXLjw94xOCmOBmr47JycnXLx4EV27dsWUKVPQsGFDvHv3TulYRGmWmJiIq5cvwLHxcDg0+B3+AW8z9FP2AgUKwFBXEz4H5uH1/tmoX/8XeHp6omfvPhg9ZiwiIiLSNN7Fixfhce8hCvddA4fGIzF05Jh0ZwOALl26wK2II+7ObwdbBGHyxPGftXFxccFrnxe4df0ybl6/mqrlI/6nevXqCH14Hq9PrUXwpS1o2qjBV9sXLVoUr3284eP9DBfPnU7X7NVr167B2s4eZuYWKFQwPwL9fbFh7WpoaKRti4br169jxux5sG06HpYudfFs+2Q4qAXh5LHDaOFqBxkZiB2796Bo8ZKZMpv9YxPGjYFBmBc8ZjRGPjPNFNfZzi7CwsLQoFFT2Nrnxu+Dh+boH1Kam5tj8uRJmDhhAkxNTT85JqXEs2fP4Ofnp1A6IqKfh46ODjZu3Ijp06fjn3/+QfXq1eHv7//tjvRTGTZ0MHyee+HMiaMpTjgAkiZHJIT6Iy4iGPHv3sDczOw7psz+Fi9bCfMK7WDffCL08rlj586daNKkCfb8exBxuavAutFYjBg97otLfTx8/BgmzjVhVqg8DKyd8PjxY2hZ5YeedV5o2xVBXHwCFsyfhyJFikJNUwcQalDT1EJ0oA+ivC7BuWjWFizfvXsHTSMLaBlZQMvcEcHB315yUUqJLVu2YPz48bh169Ynx8zMzFC4SFH47JmJl7unw718Rejo6HxzTJVKhfj4+G+2s7a2Rlx0OMKe3UTo40uwd8jc9cXTQ0dXL2n5x8gQqBITPrneqlWrIvzBSfhe2IZ3HntQr3bmrctNOR8L1KQIXV1drFmzBkuXLsWJEydQpkwZ3L59W+lYRGmirq6OUmXc8OrQ33h9fDnMzUw/WxoiLbS1tXH9yiUMaVcb04b3weKFC1CxSjUcfRqDdQcvo3W7jmkaz9DQEPHvoxAf+Q6xoX4wSmFZirTk+3fvLsTFxsLj6qUUl6nQ09ND3rx50zyTt0SJEjh94hi61yiEtUv/Qq+ePT85Hh8fj6dPn36ybIimpiYsLS0hhEBoaCiOHj0Kb2/vVJ+ze6++MCrXASUHbcbq9Ztw82b6NrkLCAiAjokV9KzzwMCxOAoWLIDL58+iYsWKkBDQLVAZxQb+gwjdXFj60YyS8PBwzJ07F3Pnzk3zDyD+x9bWFo8e3EVMTDQunjud7TehHTNuAm6/iYZVk/HYsucQdu7cqXSkTCelRJduPeBSthzyFyyS4iwiIiLKPEIIjBkzBrt378a9e/dQtmzZz4pFRKnRs2dPVHbJj2drB6CYjQ5GZ/LSZvHx8bhx40aO/SG2poYaQh9fRsQrT4R530Xu3LkBACHBIdC3KwQ9q9zQ1jP64iS0fj174M3BuXi1eyo03odg2LBhiPW+Cp+to/Hu+i783r8vAGDUyOEQb27g3vw20Ap7CXuNMDSvXhaTJnw+QSYztWrVCgbxIfBa3RdBFzdhwthRX23v4+OD3n36ov+wcVh7xgtVq9f6ZEkYIQTOnT6BUT1aYFzfdjh+5OA3Mxw+fBhGJmbQ0zfApMlTv9rW1tYWG9auhtq9nXCMf4Hd27ek7kKz0NbNGxF8YjGebRiCuXNmf/L5uGrVqti17R80K26MFQvnokuXzgompewmbVPEiDKREAJ9+vSBi4sLWrZsifLly2PFihXo1KmT0tGIUu3E0UOY/eccxMXFYeiQxWmeeftflpaWGDZsGADAw8MDmvqmsKvcHrFhgbi6aUiaxipVqhQG9u+DOXP6wdrGFuv2ZM9CoJTyw2OJZcqUSZpJ/p9i+rt37+BeoRLeBodCHYm4cPY0ihQp8uH427dv4VK6LKS+OSIDXmD3jm2oXbv2N88dGxsLDV0jqGvpQF1D68Mjd97e3oiKioKzszN27NiBsROnwNzcDBvWrELBggU/G6dmzZqw0p+I5+t/x/uwIKxdteLDMW0tLci4aECqoIqL+bAxjZQSVWvUwpv3OgAktmzfhetXLqb7Ec3M3vAmq7zx84O2bSHoWjhAy9zxh5zh5u3tjT1796Fw39WICwvEqNEj0K9vX6VjERH9FJo1a4YLFy6gcePGqFSpEjZu3IjmzZsrHYsykZ+fHzw9PeHi4gJzc/MvtgkPD8fJkyfh6Oj41TWRv0RbWxs7t2VNoS8mJgblK1fFK79AxEWGYes/G/HLLzlr8+lLV64B6sZ4cXgJVNGhKFSoEABg8sRxGDRkGLT0DFGquDNKly79Wd9Bg36Hq2tp+Pj4oF69ejAzM8Njz/u4ffs2ihQp8mFmu4ODA7y9niA4OBgWFhZQU/s+cyuNjY2xdfNGXL58GY0bN4aDg8NnbRISEhAbG4tbt26hQcMmiIc6HOv1g3F+V6jCfHH27KdLU2hpaUEIgeDgYLx79+6bm/x17d4Tjs3GQNcyN+bM64tfu3b+8EOAL2nevHmm/RsXFhYGfX39DH2mrVmzJgIDfFM8Xrt27VR9TqOfkJQyR36VKVNG0o/D399fVq1aVQKQ/fv3l7GxsUpHIlJcRESEtLFzkHZujaRlgdKybYdOSkeSiYmJ8o/Zc2T9Rk3lqlWrMzTWqVOnpJmFldTS1pEz/5gto6KiZIXK1aSWtq7M5egknz179qHtggULpK1LDek2/rB0rPmrbN+pyydjLVu2TOYqVVO6Tzgi8zYZJmvXb5iqDEeOHJH6hkZS18BItmjdViYmJsq58xZIfSNTaWxhKxs0aiL1DU1k4U5/yNy1e8hiLqVTHOv9+/fywoUL0tvb+5PXAwMDZcnSZaVQU5MVq1SXERERUkopQ0JCpJqGpnQbf0i6jT8k1dQ1ZUREhNyxY4csXqqsrPtLI/nq1atvXoNKpZJbtmyRM2fOlM+fP0+xXUREhOzT7zdZrVY9uWfPnlS9P1nh0qVL0tDETFrndZZ29o7S399fsSxZxc/PT+oaGMnifZbJAq3HS5tcDkpHoi8A4CGzwT1tTvri/TflJH5+ftLd3V0CkNOmTZMqlUrpSJQJPDw8pJGpubQtWEqaW9l8dt8lpZTh4eEyT/6C0qawqzQys5JLly37/kFTsHfvXmmdv6R0G39YFmgzUZZyK690pDQ5dOiQNLWwlE6/DJBlRu6Sxha28tatWx+Oe3t7yxs3bsiEhIQszREUFCT79PtNtmnXUd6+fTvTxl2zZq00NLWQ1vlLyIJFnGVkZOQnx0+ePCkNjIykuoamdMiTV+au31/aV+ssdS1zSw09Y6muYyAd8+SXQUFBH/o0a9FaWhV2k3bujaVtLkcZFRX14VhCQoIcNmKUdHEtJ8eMHS8TExOluZWNLNptviwzfIc0MDb75DNRVomPj5eNmjaXWtq60szCSt64cSPLz0k/p6/df3OJD8oWrK2tceLECQwZMgSLFy9G9erV4eub8k/diH4GBgYGuH71Evo0LItJg7pjw9rVSkfCosVL8Ofi1XiiUQjDxk7K0MaLHbt0g0Wt/ijaZyWmTp+Bv//+G8+CYuAyfCfU8lbCuImTP7RN2qAxFImxUUiMDILhf9a2tre3R0zAc0T5PkWMzx045f58tsOX1K1bFwF+vnj25BF2bP0HampqmDhpEvJ3nouCvZbjzJmz0NAzgJFTcRjnd4PfV/5d0tbWRsWKFeHk5PTJ6xYWFrh94xri4+Jw4eypD+tyv3v3DkJdEy+PrcTLYysANXUEBATg1x69EFe4MR6E66Fdpy5fzR8QEIAhw4bjt5ETsXDvZZRxK5fiOuj9BgzE3gsP8Nq4FDp364F79+6l6j3KbOXLl8djz/vYsW4pHnneh7W1tSI5spKNjQ3mz/0TPtvGIuryBmzfslnpSEREPx0bGxucOXMG7du3x7hx49CpUye8f/9e6ViUQQsXL4VxmaZwbDsT2nncsWnTps/anDt3DjFqBsjdehpyNRqOBYuyz1Jb5ubmiA0PxvuQN3jv7wUriy/PAM+Olq9YgfZde0E3b3n4HFuBO/Paol3rFihZsuSHNk5OTihdunSWbdr9P01atML+a89x0Q9wr1AZbTt0wuPHjzM87ux5C2DfaDic2s9GWIImzpw5g4iICBw6dAj3799Ht169EZuoBr1cRfDmtS/e3T0O4/xlkRAVAqtSdVFm+A7Em+TBypUrP4x54sRx5Ko/EA51+yEOGnj69OmHY4sWL8b6XYfwvkgzLN+0E2vXrsXyJYvgvXU87i3sgl49uyNv3rwZvq5vOXLkCK7cfoiSw7bDuFw7DBo6IsvPSfRfLFBTtqGhoYG5c+di27ZtuHPnDsqUKYPz588rHYtIUfb29hg/fjz69esHTU3NLD/fiRMnsGrVqhSLnNeu34BB0RqwKF4d+gUqpHrN5mXLl8Pc0gZ5CxSGh4cHACD2/XtoGphCQ9cA6uqaSEhIAGRSeyk/3Tivc+fOqFAsH+791RE2CMbUyRM/Od6gQQP81qsros4uhlseE/w5a+aHY48ePcKUKVNw5MiRL2bT19eHra3th6U1TExNEen7GNFvX0CqElEwT248Xz8IL7aNw/Chny+z8s8/W+BesSo6de2G0NBQAEkbaHbt1gN6BkYoXbYcvL29sXbtWixatAjh4eEAACsrK+hqa+F9kA+i/bxgb58Lvr6+0DWxgnF+V5gUrgxv7xcfzvP8+XPYO+WDroEx2rRrj7HjJ8IpXwEsWrIc1jX7wKFuP+hZ58XVq1c/yxgUFIQr167DpGRdmDtXhWGuQplyE+/r64uDBw+m+QeK9+/fx+Tps/D7oCEICfn25jM5Ue9evRAaEoQ3Pi9QuXJlpeMQEf2UdHR0sGnTJkyfPh2bN29GtWrVfsilpZSSmJgIT0/PTN8A+msc7HMhzu8Rot++QFzg8y9udujo6IioQB+EPruB8McXkP87FPhSq1KlShjQtwfe7BgHy5jnWL5k0Wdtnj17hoULF+LEiRMKJEzZlh27YVm1Kxzq9YOdS3XMnTMHSxcvTPfydBlx59YtWFfugLBnt2BUqCIu+amhUtXqiImJydC4uR0dEPHsOsJf3kd00BuYmJigZGlXdB88DhWqVEdIUDCM85VB0S6zkbtub+jIGESeXogSzs6QsZGQifFQxUZ+snl7ufIV4HdyJd6c2QDER39ScH78+Cm0c5eGcZ6S0HF0weMnT9GiRQsEB73FW39fzP1zdoauJ7WEEEmfv6SEVCUq8ntKpPijgun94iOGP7b79+/LAgUKSA0NDfnXX3/xkTyiNAoICJCbN2+W169fT3Wf2X/OlSbWDjKXS3VpbWv/yaNp//Pvv/9KQ1NL6VCuiTQwNv3m+H//vUgamphJdS1dma/ZSJm36TCZJ38hKaWUmzZtlrr6BlLXwEj26NVHRkVFyUpVa0gNTS2pZ2QqrXM5yEFDhsrExMQP48XHx8v4+PgUzxcYGCgHDh4ie/XpJ58/fy4PHDgg1TW1pbaJjdTQMZDjJ0765vtw5coVmbdAYWllm0uuW7dexsXFyVOnTn32+KBKpZJ79+6VBibmsmCbSdK2dB3Zpn1HKaWU27dvlxZORWTpoVulfcWW0s4xj7Qq6CptileWxUqW/vDY48WLF2WFKtVl7Xq/yCdPnsiYmBhZtLiLtC7gIo0tbOUfs+d8OF+eAoWlbfmWsnifZVLTwFRqaGnJ0sO2SfPiNaRR3lIyd71+0sDY9LPHAM+dOycNjU2lnomF1DI0k3YuNaSljZ0MCAj45ntx4cIFuWrVKvn69evPjt29e1camZpLu6Lu0sjUXN69e/eb40kp5YsXL6SBsanM13S4tHOtLxs0apqqfkSZDVzig/ff9FPZvXu31NPTkw4ODp8sSUDp8/79e+lWvpI0trSTBkYm8tixY9/lvNHR0bJN+47SwSmf7Nt/QIpLSaxfv0EWL1VWNmneSr59+/a7ZMsM3t7e0tjMQtq7/SJNrHLJ5StWKB3pg9FjxkmrAqVlnkaDpaGZpbxy5YpiWdp36iIt85WQQk1duo7cLd3GH5bGFjbSy8srQ+P6+vrKug0ayoJFi8vlK1bIPXv2SNvCZaX7hCOyUIfp0srGTuqY2spiPRZKi6KV5W+/D5Lbtm2TU6dOlcVLlpZqauqyRu16Mjo6+sOY4eHhcszYcbJvv9/k48ePPznflStXpKGxmbR3qSoNjc3kP//8I318fDJ0DemRkJAgm7dqIzU0NaWFtW2mLptC9LGv3X8rfqOb3i/eIP/4QkNDZZMmTSQA2b59+8/WfyKiLwsICJBWNrlkrhKVpZG5lVy/fkOq+hUu5iKdGg6SdpXaSmO7vCmuU3zx4kU5f/78b964eHt7Sz0jE1mi7wqZr9kIqWvpKIv3XirNLKw/tHn37p309fX9pF/vvv2lrUtNWbzPMmnuWEhu27ZNSinl4sVLpJa2jtTW1ftwTWfOnJG9+vSTS5YslYmJidLOwUmqaWhJDT1jaWZhJZ1Llpb5mo2QbuMPS6O8paWFtW2q3otvUalUsm2HTlJH30gaOhaT7hOOyMIdZ8ripcpKKaVcvXq1tHWuIN3GH5ZODQZIoaktDeyLSG0TG6mlZ/DJjWdERIS8c+fOh/XooqKi5L59++TVq1ellElF+fXr10tdIzNZoM1E6Tb+sDSwLyLVNbRk8b7LZZEuc6Smtq5s076jPH/+/GdZq9WqK/M2GSrdxh+WprmLyG7dun32nn/J2rXrpJGFjbQvVUuaWVp/VqQeNHiItK/SQbpPOCJzVekgBw4anKr37uTJk9I6fwnpPuGILNZrsXTIkz9V/YgyGwvUvP+mn8/Nmzelvb291NPTk7t371Y6To62f/9+aZWvuHQbf0gWaDVOlk5hLeV9+/bJvv1+kzt37vzOCXOmlStXSvsydaT7hCOyQOsJslK1WkpH+iAuLk5OnjJVNm3RWu7du1fRLPHx8XLdunXSuUQpaVXQVdq61JQFCheVcXFxmXoeDw8PaWRmJYt0+VPmKtdENmraQo4aM1Y65S8kW7ZuJ3/7fZA0dywo7crUk9a29jIkJCTN53jy5IncuHGjLF3WXZra5pb6RiZy8+Z/MvU6UisqKuqTyUFEme1r999c4oOyLWNjY+zevRvTpk3Dli1bUL58eXh5eSkdi35ykZGRaNqiNWztc6N3v/5ITExUOtJnjh07Bk2rvLBvOhY2tftj8fJVqeqXJ7cDXh1bDgiB2Pfvcf7ipS+2q1ChAgYNGvTJenNfEhkZCTUNLWib2kDXwhGxYW/xYM1gTJ/2/2tLm5iYwNbW9pN+AYGB0LYrAj0rJ2hbOsHPzw9RUVEYMnQYivRaikJdF6BXnz7w8PBAwybNcdgrFuNn/YWhw0fAPyAAJfqthFP9fgiPjIKZqSmifJ8iNtQfse/8kOc/60On1+PHj3Ho8FEU6bkEsaH+eLRxNPyO/I2+vboBAFq1agVTtWg8Wd4D7y7/A21tXZgWKo8CrcYhMVHi3bt3AAAvLy/kyV8QNeo3Rf6CRfDmzRvo6emhcePGcHNzAwC079QFw6bMg9DUwbPds3B3SQ+8D3qJKZMn4dnG4Xi9bzq2bdmMrZs3olKlSp9ltTAzQ1yQD+LCA6GWGI9mzZp99p5/ycq1G2BdszdyNRoGXXtnHDt27JPjTrkdEevriSjfp4jz9UQep5R3F/9Y2bJloRkfgVf7ZsL3wBx06dQhVf2IiIgyqlSpUrh+/TqKFy+O5s2bY8aMGUj6vExpZWRkhPioMMSFByM2+DVMTIw/a3Pw4EF06tYbB5/Gonvfgdi5c6cCSXOW4sWLI+z5LQTdPYmwu0dQtoyLIjmklDh37hz279//Ye12TU1NTBg/Dnt2bkOTJk0UyfU/Ghoa6NKlC25cu4wpQ3qgafmCaNOyOW7fvp2p5ylTpgz+mDEFKo+NcLFSw6rlSzBz+jR4P32EHdv+wd79+2FXfzAcfhkEoW+GW7dupfkcBQoUgL29PXwC3qFAj6VwbDoaE6ZM+2qfqKgoLFy4EH/99RciIiLSe3mf0dPTg5oay4SkDP7Jo2xNTU0NY8eOxeHDh/HmzRu4urriwIEDSsein9iUadNx1SsQVk3GY/eRc9i4caPSkT6TP39+RLx5gtCn1xHx6ByKFi744dj79+8x+88/MXz4CDx79uyTfg3q1YF5IXc4VO8Cxzq9cfV66taXTomzszMqlXfHrfkd8HDDSBg4OKNQ4YLo07v3J+0OHz4MSxs7mFpYYcuWrRg+eCCCL/2Dl5uHQ+XniTZt2kClUkGqVAi8cwIRrx9CqlS4evUqTAuVg12FVjAr1woXLl6BprYuNPVNoG1sDQFg0/o1MI58Bs+VvyFvLiscOpD+TR0/ZmBggIT4WCTGRiNXlY5Qj3iDw/t3oW+fPgAAQ0ND3L5xDZfOHIfPi+cwNzeDoWMx6NnkhbGF9Yd1qBf8tRA6Bashf4+lEPYuWL5ixWfn2r93Dxybj0OxfquhraOLdo3r4N6tGxgzZjQiw0MRFhKMZs2apZj1r/lzYJPoi+cbBqNd84Z4+zYQdX9pjEmTpySt+52CksWdEf7gJEIeXkCEzwMUKVLkk+P9+vVDizoVEXN+KVrUqYj+/fun6r0zNDTELY9rmDKgEzauXIQpkyZ+uxMREVEmsbGxwenTp9G+fXuMHTuWmyemU5UqVdC9Uzt4rR0Ag8DbWPGFtZRPnzkLoxJ1YVu+BYxdGuDEqTPfP2gO4+7ujjUrlqBAwhN0a1Ybs2ZMVyTHqDHj0KR1R/QcMh6Vq9f86j3j97Z9+3ZUrl4bPXv3RVxcHKysrLB5+26sO/UINWrX++J+LClJTEyEr68v4uPjU2zTp3dvPLp/Bwf27YaVldUnxwrkL4A35zYjwOMAgl49haOjY5quJTw8HJWr1UStWrURFuiHyDePEe33FBbm5oiJicH4CRPR+dfuuH79+if9atVtgOnLt2HW6t2oWqM2f9BGP4aUplZn9y8+Yvjzef78uSxVqpQEICdMmMBHTyhLvX37Vk6cNElOnz5dhoWFfXi9Q+eu0rF2T+k+4Yi0K/uLnDVrloIpZYrrs69evUa6lqskO//aXYaHh394vXmrNtK6SDlp7fqL1DMwlJs2bfowxt27d6WBiZl0rNVDWjgVlRMnT/nm+ecv+FsaGJnIXI5O8vLly1/MN3v2n9Ixb37pXqGyfPLkySfHExMTpYGRsSzS+Q9ZrMdCqaNnICMjI+WbN2/kmTNnZGhoqJRSypcvX0pdfSNpUbK21DQ0l63atJX37t2TBsamMleVDtLMPr+c/edc2bJNO6mtbyQ1dXTlilSs2Xft2jW5bt26L66x/C2LFi2WxqbmMlfuPPLSpUtfbbtmzVqpb2QqzezyyAqVq314/HDsuPHSpkR1WXrIFmlV2F3Omzfvs76ly5aTuco1lbnr9JSmFlbpXu4oPDxc1q5bX2rqm0irMg2kZb6Sctr0GSm2j4qKkv0HDJSVq9eWGzZsTNc5ibIzcIkP3n/TT02lUslp06ZJALJcuXLSz89P6Ug/nMOHD0tDMytpX6OrNLKwSXH5uJ/VP/9skQWLFpeVq9eUz58/l7dv35YzZ86UR48eVTqaNDI1ly6/r5Nu4w9JI3Mb2bZ9Bzlh4iQZERGhaK7bt29LQ1MLWaDVOGnrUkN26tpNtuvYRTo1GJC07FylNnLSpEmpGis4OFgWKlpc6huZylyOTvLly5dpzlOrbgNplLeUNHeuJk0dCsrNmzenuq9KpZIVKlWWpoUrSNfRe6VF0cpSz8BQFi/lKh8/fizbd+wirZ0rSsfaPaWhidmHzytRUVFSQ1NTuo07KN3GH5LauvoyODhY3rt3Ty5btozrR1O29rX7b8VvdNP7xRvkn1N0dLTs2rWrBCDr168vg4ODlY5EP6CEhARZoHBRaVumnrQpUU26V6j84ZiHh4c0MjWX1vmKSyubXPLVq1eKZPTy8pJ5CxaW6uoaskPnrqn+gY2ZpbV07vG31DQwkxYlakpj69xy6kdFyrNnz8qevfvIhYsWfXPMFy9eSH0jE1mi/yqZv8Vo6ZSvYJqvIz4+XmpqaclSgzfLMsN3SG09/U/+XgcGBsrmrdpKB6e80qZYlaQNStpNlW4VqkgpkzYWGT5i5IdCu0qlkt7e3nLs+AmyjHtFOXDwEBkbG/vFc2/dulUamllK8yLlpYa2rhw6bFiWbsj67NkzefXq1U82eXz37p10KeMmdfQM5C+Nm8mYmJjP+vn7+8tfu/eULVq3k3fu3En3+X/t0UtaFq8qC7WfJrWMLKVtxTayacvW6R7ve1OpVJ9sOEOUUT9ygRrAGgBvAdxP4Xg1AGEAbid/TUjNuLz/ph/Rzp07uXliFjp8+LAcPGSI3L9/v9JRshVvb2+pb2QiC3eaJR2qd5ZFi5dMmnhRobk0trT96uQAlUolBw0ZKvUMDGWhosXlkydP5Jy582XegkVkvV8aZcqmkMVcykiH6l1k3mYjpJqmtrSv0k7aFK8q6zZomOGxM2Lbtm0yV7GKSZ8J2k+TZlZ2UltXX2rpm0jHOr2lsaWdPHjwYKrGmjFjhrQtVUu6jT8s7Su1ln37/ZbmPI2atpCONbrKsmP2S8u8xT7snZMaV69elTr6RtK6bGPpPuGItHZtKEeOGv3heO58BWWxXkuk+4Qj0rZQ6Q8/uFCpVDJ/oSLSvmJLaV+5jXRwyisvXbokDYxNpUPZ+tLA2EyePXs2zdeSE6xZu1YaGJtIUwurVP8+f2++vr5y9+7dGd6w80f1tftvLvFBOYquri7WrFmDpUuX4sSJE3B1dc30daYo5zp79izyF3ZG3oJFcPz48XSPExgYiDdvfOHQYCAcGw/HtSsXPzzWVqZMGTx5+ADb1yzCk0cPYG9vn1nx02TA4KFIsC8Hl2HbcPTMZRw8eDBV/apWrYaXB/+CrqUj8jUdDrt6A/DP1h0AAH9/f9y6dQs1qlX9P/bOOrqqo2vjO8l1d4+7uweCOwR3d3eX4MWhuLVIcXcIFCgUd3d3JwnE5T7fH2nzvWmEBAKB9v7Wumu1nJk9e849SfbM2fNs6tqlyyf1xxISEsiCxSG2WEUcmZ4SEoquf8ZgMGjkyNF065eudHNhR+rcqTNNm/4zlS5XiWbPmUvtOnahk48SydylCr25c5beXNxHcRd2UlCgPxFlHYOcPGkiNWvWjMzMzMjMzIzOnDlD85esokSH6rRm1580afKUPMde+OtyUpftQA4NRpLYMYTmL15a6Pv4OdjZ2VFQUBAxGIzsf2vWohVdvX6DUlNT6fLly8RisXL1U6vVtOSXRbRx3Wry8vL67PFv3LxNUrcyJHEIIJ7almIv7qbmjRt+tr1vyZ07d8jSxo5EYjFVqlqD0tLSStolEya+d5YRUZVPtDkCwOevz5hv4JMJE98l9erVoyNHjpDRaKTw8HDaunVrSbv0r6JKlSo0fdo0qlmzZkm7QkREaWlp9Pbt279f1pUYL1++JI5QRiIbb5I4hdCTR49I4hZJhgodSR7ejDZs3ppv38OHD9PyNRvJucMCStYFUuPmrWjsxCnEjehEV96aUdcevb/Yv22b1pMz+w0xb8eQSK4hfZlWpK3QkU4cz12jJjY2lho0akqevoF5ytUVBgC0ceNGmjNnDr169SrfdmXLlqX0tw/p6fZJ9HjHVDKyheTWZTHJXMPJ/P4hqlaxHP08Zz7NnDn7k98xm80mY1oKwZhJxtREYrFzx+GfYvqUiUQPjtC5iXUo1NuZ6tatW+i+iYmJxBHJKe7uWTo/vSnFXjtEPbpnSeYZjUbSqFT0YPtUehQzl1LfPyM/Pz8iIjIzM6NDB36nqp5KquIqoaOH/6DNW7aS2Kc66ar2ImlgHVq9dn2R5/K9Ex8fT127dSfbJhNJU30gNW7arMR/jv/JvXv3yM3Tm3pETyUf/0A6cuRISbv0Q2HaoDbxw2FmZkadO3emP//8k9LS0igsLIxWrlxZ0m6ZKCHevXtHFSpXI6VGT5WqViNznwbECmhGdes3+OxNLIVCQUqlgp7+vpCe7JlF3r4BOTYV1Wo1lS5dmsTi3MVgCkNycjKNHTeeunbrQdeuXfssG0lJyWTBE5MFk0MWbB4lJycXqt+q35YSJb6lxOe36fX5PfTi+DqytjLQxYsXycbemfoPGUHtu/WhPv0GfNKWm5sbValYnq7PbUM3lvWjxISP1K179yLPZdjQwXTr+lW6euk8qVRKWrxuO71UhdHI8ZPpwsWLJHYpRZqgWiRSaEn+5jS1qVOBfDw9SCASk1gqz7WQvHPnDnGsvEhs70dc+yC6fvN2nuN6urvSu8u/U+ztU/TxyTXiqe3o0aNHRfb/U9y6dYuOHj2aS9suMzOT9u77nbQRjcmn5zJ6+TaWtm8vHo3svOjWqT29+H0+Pdo0hjLf3KV1q1dSvXr1Cuxz48YNWr9+PT179uyr+VUYBg0dQRYOZch34Ba6dO8ZbdiwoUT9MWHiewfAn0T0vqT9MGHiR8HPz4/OnDlDHh4eVKdOHZo4ceJ3t/Fh4ss5e/YsqbV60uotSaWz/KqJCZ/C39+frHUqerCyHz3aMIqaNWtGH26foNcXYujDpT0UFhqcb9+EhARi8kTEFEiJJdFSXFwc8ZRWJDC4EN/Glx4+evzF/tnZ2dHve3bRuVPHiWNupCf7FtCzPbOoXLnyudp27dGLjt+PowzP+jRwaHSRNKD/pv/AQdS57zCasHQb+QUEZddr+SdKpZIuXThL43q1pE7tWhNXpiUmX0psuSVxORzae+QUPeB70ZgpM2n16tUFjtmpUydyUrLp7IRapMh4RcOGDC6y3w4ODvTo/l1KSUmmbZs35lgz/s3OnTtp3LhxdP58zvo+pUuXpmBfd2IglRhIp43rVpNeryciol9++YXuPHtDQhsfir99kvr17kkKhSK7r16vp0Xz59HihQvIysqKvL08KfneSXp/8zgl3TlGPl6etHPnTgoKK0216zWkly9fFnpOiYmJVK1mbRJJ5VSzdr1CrzO/NllrKTNiCeXElqgoNSXlu/s9vX79euI5hpGhbjTJQxvTvIW/lLRLPxb5pVZ/7x/TEUMTQNbR98jISBARunfvnu9RfhP/HoxGI44dO4YjR47AaDSiTbsO0AVWh0fn+TAzt4D/wI0IGLwFLDY3W7/4c3j27Bn69O2HgYMG4+3bt8U4A6Bh42ZQu4XBUKYFxDLFZx3DO3XqFCQyBfhiGUIjIpGSklLovhFlykHhEQmRjQ9YXD6uXbsGTx9/GMq0hGen+WAKZFBqdACA+Ph4zJ8/H8uXL8etW7dyyeoYjUZ4+vjCnMWFOrg2GHwJxv+Uv67x//LgwQNMnDgRq1atypbWaNC42f9ryIXWRVRUbQikSohtsvThrl+/joSEBHB4Anh2XgD3tj+DxxfmkCO5ceMGRFI5DD5lIZDIcODAgTzHT0pKQs2oOmDyRBDr7KDU6PDs2bNC38fCsGDhQggkcigsHREcVipbe/pvOAIJHBuOQNDwXeAqrbBt27ZiHf+fnD17FqtXr8arV68+2Xb//v0QSGQweJWCRK4s0WNqUXXrw7piewQN3wW1sz9+++237GuPHj3CggULinSUMSMjAzdu3EBsbOxX8NbEjwL9iyU+sqZHNlSwxMc7IrpERHuIyL0wNk3xt4l/O0lJSWjSpAmICC1atMhTesvEj0tEZDnY1uyNwGE7wdPYg8sXlGh8k5KSgn379mVLy2zYsAH1GjXBlCnTCpTaS0lJQWhEJEQKDQQiCbZt2wYbe0eoHb0hEMuwcePGYvXz8ePHGD58BKZPn57nz4R/cDicm4zJqtHjHoa1a9cWeQydlS08Oy/Ikrqw98Qff/zxyT7v37+Hg7MreDINzJlsMDh8WJZvl7WOiGyBfv36F2rsjIyMPP89Li4O4aXLwoLBROmyFT5Lf/vXX5dAojZAH94AArE0l1yf0WjE/fv3c61be/XuA0OZFgiOjoGhbCv07NU73zHi4+MRExODQYOHILJ8ZYwd/xPu378PgVgKx4YjoA+rh9LlKhba57Fjx0HtEQHPLosgs/XC2LFj82yXnp6ORk2bg8PlIyAkvFDriy+lb/8B4AnF4ApEmDZ9xlcfr6isXr0acksnuLWZDrVrCEZEjyxpl747Coq/Szx4/tyPKUA28TdpaWno27cviAhhYWHFvsFk4vuibfuOkGqsINVao2nzlqhaIwq2NXohODoGArUNeGIFxEod2nXoVNKu5klycjJ4Iim8ui7+KwDz+GyNsMTERDx69KjIBUOfPn2KytVrwtM3EOvXrwcA2Dq6wqXFRASN2AOu0hrBoRFIT0+Hq6c3NB4R4IgVYPFE4AlEuTZRlWot1IE1ERwdA7uo/giJiMw1Zmpqag4/X716BZlSDV1wTcitnDFw8FAAwO7duyGUyGEIqAyhRIYTJ06ALxRD5VcNupA68PYPRGxsLFgcHvz6r4NPrxVgstg5dJ2BLH3slStX4tq1a5+8H7dv38b27dvx5s2bPK/HxcVh0OAh6NK1e5EXMXprO7i3m4mgEbsht3TAsWPHclz/9ddfwWBzweKL4RsQnGsDu7g4e/YsfAOC4ebli/379xeqT92GTf7/ZUFwLUyePPmr+FYYbty4AbXWABaHh1Jlyme/kHn8+DEkciUM/pUgVmjxyy+/ftJWUlIS/AJDIFHqIBRL/7UafSY+zX98g1pERIK//rsaEd0pwE5HIjpLRGetrKy+8K6bMPH9YzQaMXbsWBARQkND8fLly5J2yUQxUaZ8JVhX6YLAIdvA09hDqrNDTExMSbv1WWRkZODmzZt4//49gKxi2DExMbh169Y39+W331ZAKFNC6xoEvZXNZ9WJql6rDrS+FWFbvSeEYlmhC5jHxsbCgsGAT6/lcGoyGuYsDiyDa0IgluaKu4vKiOiR0HiXQ8CQrVB7lsa48eOLbKNarTqwrzMwa6M5JAozZswoVL9Tp05laUr7VYBALMXJkyfzbPfu3TsYrG2hcfSBQCzL1nr/448/IDU4IGjEHnh2mgc2X4TffvutUElNffr2g8qnIph8KThyA4QSGZ4/f56r3fLly6G094Jf//XQh0R9s/X3kydPvtvfy0ajEcOGR8PFwwftOnQyveTMA9MGtYn/BGvXrgWfz4dGo8Gff/5Z0u6Y+AokJyeDwWQiYPAWBAzZChabm1UdXCKD0toZljZ2OHToEM6fP19sxe5+//13RJQpj7oNGuf5h7moTJgwETy5DkJrL2iC64AvkuDIkSO5grDk5GQsWbIES5cuLVJ29OeyZs0acAUi8GRaaPRWePPmDe7cuQORQgPXVlPAUVghcNhOuDT7CQ7Objn6Dh48BAyuELY1e4OvtstRdBEA+vTrDwaTCZFUhkOHDgEAdu7cCZmlE5S+laEJqQf7/7F59uxZLFq0CLdv38b169chUeoQNGIP/PqtBZcvBAAMGTYCXIEIXL4QU6ZO+6r3JiKyHLS+FWAo1RgqjR5JSUnYunUrunbrgY0bN+LcuXNwcvOESmvAr78uydE3IDgMVuXbwr3tzxBI5Lh9+3Yu+7Gxsbh9+3aRXzQUFqPRCJVGD7tafeHUaCT4IjESExM/2W/Y8BFQuQTDpcUkyPT22LRpU57tNm3ahODwSDRu1gJv377FkydPcOHChXyzUT6XjIwMxMbG5vjZ/vXXX2HwLY/g6Bg4NhqJ8Mjyn7Szfv16qJ18ETRiD+zrDER4ZLli9dPEj8N/eYM6j7YPiUjxqXam+NvEf4mNGzeCy+XCysoKFy9eLGl3TBQDV65cgVAiA5mZg6cwQKu3NJ2mKiYuXryIzZs3Z2+YF5W4uDh06dYDNWvXK9JaPj09HUKxBE6NR8O56Thw+QLMmDGjWAqe9us/APrQOlmZ4cG1MGTosCLbGDR4MGTWLrCp1gNCqRJHjx4tdN8bN25g2bJluHHjRr5tfvvtN+g8SyE4OgYO9YchPLI8jEYjypSvBCZXCIGlG1hCBeRe5WHB5oPBYmPBwoUFjnvv3j1wBWIYyrXJKtDoXxWTJk3K1W7OnDnQekUiaMQeWFfqgPqNmhZ6bib+u5g2qE38Z7hy5QocHR3BYDDw888/F9smpYnvg8zMTEhkCtjXHQSH+sMglEiRlpaGFy9e4Pjx44XadCsKL168gEAshX3dQTCE10doqcgvttmtR0/oSzWFddWuEBhcYbC2gUSlB18owYoVKwFkbShGRJaD2jkQaid/lClf6bPGev/+PU6ePIn4+PhCtX/06BFOnz6dncWbkJAAqUIFbUhdMPgS+PReAdsaveDjH5Sr788//4zS5Srip4kTc2y0Xr58GSK5Gv4DNsCx0UjYObkCADZv3gwLNh/WVbuCp7aDj38gAGDO3LlwcvdC9Vp18Pr1a6SlpcHT2w8atxAorF3Qul2HbNvPnz//JkfJ2Fwe/AduRHB0DKRqA+bPnw+RQgurCu0hVuqhVGvB1zvDnMmGOYOdIxPnzp07CAwNh5WdAxYtXvzVfc2LzMxMWDCY8B+wAYFDt4MrEOHFixef7JeSkoJOXbrByy8IY8f/lOfv05s3b0IgkcOxYTR0gdXhGxAEvlACidoSkeUq5spsLw6OHz+OHTt2IDk5GSdPnoRIroJD/aFQu4Whe8/en+wfExMDucEevn1WwbJMC1StGVXsPpr4Mfgvb1ATkYaIzP767yAievz3/xf0McXfJv5rnDt3Dnq9Hnw+H1u3bi1pd0wUA5mZmdi+fTsWL178WTJ7n2LHjh0YNGgwDh48WOy2S5LPTaTYtWsXLG3sYePgXCjZjs9h//79sHV0gbW9E/bt21dsdp88eQK9lQ3ECg0sbezyPamdmZmJ1atXY9q0aTnaDBk2AjyhBCwuH25evl9Fyu/AgQOQqC3h3m4mNH5V0LR5qyx5D6kC/gM2gCPTwapCBwRHx0DiGASxQyAs2NxPniDs0bM31N7l4dNrBZQOPlicxzomNjYWTq7ukKj0kMqVueRLfjTi4uJQoXI1iKRyNGra/KudbP2vY9qgNvGfIi4uDrVq1QIRoWnTpkhISChpl0wUIydOnICnbwDcvf2+eqb8qVOnIDfYI2jEHnh3+xVyleaLbV69ehVimQIaR28IxVJINFYIGr4Lbm2mw2BjDyDrGWaxuQgavgtBw3eBwWQV6TlOS0vDTz/9BJ5QDKW1MyRyJUaNGoXz588X2d/Lly+jboPG8PL1B4fHh5WtfZGyiC5cuACxUouAwVvg3Gw8rO2dAAAzZ86ELrB61tv+ekNQoUp1nDp1Kitju+UkiCzdYGnjgN9//x0fP37EsmXLsHnz5q+WZQxkZWC8ffs210Zsleq1oHYNgTagOvgiKfgiCQxlW8On1wpwVTYwZ7DBU9shcNgO2NboBf/gsK/m4+fSvVcfSFQGyPV2iKpbv9he3u3evRsaJ18ER8fArc10sPgiuLaaiqDhuyA32OPIkSPFMs7fjBozFmKlDmoHL/gFZkmirFmzBmUrVEHvvv0KdYzOaDSiW49e4AmEcPf2w4MHD4rVRxM/Dv/mDWoiWkNEL4gonYieElE7IupMRJ3/ut6diK79pUF9kojCCmPXFH+b+C/y/PlzBAYGwszMDBMnTjQlwJjIl/Xr10Os0EIf2RxCqeKrbch+S16/fg0v3wCQmRncPb2LpMOcnJwMvlAEl+YT4NR4NEQS6VeN5b8GqampuHfvXoG1rnr37QeFtQt0AVWh0ugRGxuLpKQkMFls+PVfB7/+68BksYs9mQrI2hy3tLYDky8BR6xAzag6iI+Ph0AkgWPDaMjdy4DJF0NsHwALjgBCG29YVeoIgVhaYAwcFxeHilWqQyJTolnL1vkmnaSmpuLGjRufpc/9vdGv/0BofcrDt/dKKB19sWDBgpJ26V9JQfF37hKjJkz84IjFYtqyZQtNmDCBRowYQVeuXKHNmzeTg4NDSbtmohgICQmhy+fPfJOxvL29SSnm0ZONoyg1/jW1a9Pmi226u7vTnZvX6erVq8Tlcqli1RqU8u4ZJb26RzKplIiIhEIhKZRKenFsPWWmp5ERoA4dOtDs2bNJLpd/coxmLVvTrr0HSeJTnST2fnRrzUhasP0kTZ0xi/bs3EYRERGF9tfT05M2rV/z2fM1MzMjN2dHOjujKbFYTFq0YD41a9GaHj16RHE3L5AZi0+J905Sv1FD6fHjx8QUayj+3nmCuQVZuFamOvUb0fEjh6hVq1ZElPVSdc7cubRn3wGqVL4s9ezRnczMzD7bv7+5cuUKlatYmT5++EChYeG0d/cOYrFYRES0ecNaWrhwIW3btp2uahxI4BBCTw8tp3dXD5HEKZiYPBG9Pr+HCCBjRjrx+fwv9qcwAKCBg4bQ4l9/JVs7O9q2aQNZWVnl2XbWjGnUrHFDSktLo4iIiE/es82bN9OpU6dJLpeRvb091ahRg9hsdq524eHhxEyLpyebx1LS64ekUiop6eVdYvCElJb4gaR/PdPFxew5c8m6wVjKSEmg6xvG0LBhw2jChAnUuHHjQtswMzOjObN+pjmzfi5W30yY+J4A0OQT1+cQ0Zxv5I4JEz80Wq2WDh8+TG3btqXBgwfT9evXaeHChcThcEraNRPfGTv37CVJQB3SBNWipzDSgQMHqEyZMiXtVqGJjY2lefPmERFR165dSSqV0tjxP9GtB09JaO1JD15/oFJlytGFs6cLZS8lJYXS0zNIoHcmGDPpfmICZWRkZMfYeXH48GE6duwYlSlThsLCwoplXl8Ci8UiOzu7Atts3LyVtFX6E09tS/dX9qfz589TqVKliMFkUcrbJ0RkRgwmi5hMZrH79/z5c3ofF0e+fVeTMSONdk2qRwKBgLZs2kD9Bg0lJymPugyaTb//vp9Wrb9OVuXbkkDvTJnPLtOVK1dIIpHQwoULycLCgjp27EgikYiIsvZU9u3Z+cnxWSwWubi4FPu8SoJ3798TQ2ZJLJGCGGItxcbGlrRL/z3y27n+3j+mDA4ThSEmJgYymQxisRg7duwoaXdM/IB8+PABq1atwt69e79Kxsy06T9DplDByc0TV65cAZCVAX3w4EFw+CKwxCoIrTwgcysFazuHQulRc7h8aMMbQeocCoVPZRjKtf6rAnRr9Ordp9jnkB8nT56EQCyFzq8SmGwuWrdpA9/AEOjD6sKmeg/whWJ069YNEydORFJSEubNmwcGhw+mUA7npuOyfPYrj8mTJ+Pt27d49eoVHF3cYc5gQ2TnB4FcC2t7J5QqWz5fbbbXr1/j8OHDn9TDq1K9FqyrdEbQ8F1QOfhgzZo1udq069ARluWztNhkzqHgiWRwbTkZgcN2giOSw9yCAaVah0uXLiE+Ph63bt0qssTFx48fcfHixQIz5m/cuIGg0AgYrO3Alyjg03MZ9BEN4R8UgrNnzxZpvLxYsmQpJGpL8HVO4Mj0kNt6ICKyXL7P//v377Fq1Sr8+eefuH79Olw9fSBTqjFl6vQv9uWf+AaGQBMUBQuOAIZyrSG39cCgIUXXAzRhAvh3Z1B/rY8p/jbxX8ZoNGLMmDGm4okm8mXZsuWQaq1hXbkzRHJ1sRdgfPLkCTp16YZOXbrlqF8zc+ZsePkFoUXrtp+dyWo0GuHp4w+NT3lofSrA08cfRqMRzZq3gAWbj6DhuxAwZCvMzM2LVGekQ6cuECk0EMpU6D9wUIFtd+/eDaFUCUN4Awgk8h8mA712vQaQu0bAumpXmDPZ6NKtBwBg69atUKi1UKi12LJlyxePs/iXX6CzsoWXb0B2Ifjk5GTIFCrYVOkCyzLNYe/smm//Pv36Q27tAl1IHUjkSjx//hxevgHQeJeFxjMS/kGhBY6fmJiIzl27I6x0OSxZsvSL5/O9cfXqVUgVKigsHaCztP5k/anExERcvnz5X5E9/i0pKP4u8UD3cz+mANlEYbl//z58fHxARIiOjv7hjhWZ+G/x6tUr2Dk6QyhTZWkaMznw678ewdExEKv0uH79+idtBIZGQBtQFXydE8wsmOArLeFQfxj4SkswmCz4BgTj4MGDqFilOipWqY6rV6/mayszMxNz585D+46diqylN3DgIOgimoCjsITStzLkziFgcvjw7bMKQSP2QKTUgysQQWHpCEcXN3Tq3AW6Us2g9KsKtlQHTXBtMDk88ERS8AQilKtYCeqA6vDtswp8vTPMLJhwbDAcSt8qkClUuHv3bo7xL1++DLFMAbW9B+QqDe7fv5+vrzWi6sK6QjsEDt0OpZ0H1q9fn6vNhQsXIJLKoXH0hlylwZQpUyCQyKGycYWnjx/evXsHo9GIEydOQCSVQ6zQwsc/KM/jfLNmzYFAJIZaZ8iWqrl79y4Uai3kejuotQY8evQoT19dPLxhXakjXJpPgDmLA69uv4IplIMtVkEo//KN4dr1G8K2Zh+YmVsgYNBmBA3fBb5YhsePH3+R3eLgwYMHcPf0gtQpGMHRMXBp/hP8g8OLZCMjIwNz5sxFtx49cerUqa/kqYkfAdMGtSn+NmHic9iwYYOpeKKJPDEajVixYgXad+xU7JrlRqMRtg5OMITVhz6sHuwcnWE0GnHw4EFIVAa4NJ8AjVdZdOrSrch2jUYjPnz4ACabg6ARexA0Yg9YbC7i4+Nx48YNWDA5sK7aFYYyLWBla5+vrXPnzmH8+PHYs2dPDvuXLl3K3lDNi9Wr1yCqbgMEh4XDqmKWXrKhTAv0HzCwSHO5du0aWrRui569+uDdu3dF6vslnDt3Dmy+CHKPsnBsOAI8gbDYx7h//z74Iinc282EoVwrqLQ6TJ8+HYmJibh48SKq1ohCnfqNCpTtyMzMxG+//YaxY8fizp07iI2NBZvL++s73/1JWcmu3XtC41EKTo1GQqTQFKng449CXFwczp8//0k5lqdPn0JnsIJcZwuFWos7d+58Iw9/fAqKv81LMnvbhIlvga2tLR0/fpxatWpFY8aMoZo1a5qOa3yCt2/f0sGDB+n169cl7cp/jkWLFlGyyJbcuv9GmsBaZGZuTo9/X0zPj64jC2SQpaXlJ23s2raZavhbU/XSgXTx/FkaPbgvce/uJYKRPHuuoNdMPVWPqkO3yZLuwJLKVaxMRqMxT1sTJk6iYeOnUsydFIqq24DOnz9f6Ln4+vpQwu0jlJH8kexq9iG7ukMoIy2ZHm8aQ0+2jKPMtCTSlu9Idq1nUYKFmBRyGX24sodYFuZklvqBgtRG4gkk5N7jN7KqM4xOnzlHHIU1MQUyYgmkRGbmlPrhDX18dIUsDD7kHxRCT548yR5/9tz5JPKuTjbNphLbPpSWLluWr69TJ/1E6bf20/nJ9SjEy4nq1KmTq42Pjw/dun6VVi+cQbdvXKP+/fvT5J/GEo9hJKFIRO/evSMzMzMaNnIMySNakHOXJfQyEbRlyxYiynoh/O7dO5o9ezYNHDKE7FtMJ1FEG2rSPEu+ZNacucR2LE0O7eaRhU0gLVy4KE9fX754ThLHYBLZeBGTzaPrv/YkBldEbLmBMlkimvbzzEJ/R3lRvkxpir+wgxh8Kb08s53eXNpPDHOzQsnLfG1sbGxo6+ZNlPH6Dj09tILeHFlBVStXKJKNESNH06hp82jb1XiqUKkq3b59+yt5a8KECRMm/o3Ur1+fjhw5QpmZmRQeHk7btm0raZdMfCeYmZlR8+bNafHCBRQVFVWstj98+EDPnjwhXfm2pC/fjp48ekiJiYl079494uudSWznSwLHULp5+26hbf722woSCMUkFEto9+7dZGtnT0/3zqOne+eRta0dCYVCcnFxoRPH/iTr1DvkI06kg7/vzdPWxYsXKbJcBZq36wI1btmOVqxYSURZ98TLy4vc3Nyy2166dIl8/IPI3smVRo8eTV169qUrmVZ07fZDen9xD72+EEMJNw5RSHBQoefy8eNHKlWmHB1+bKSNR29Q7XoNC9133rz5JBRLSK0z0OHDh3Ndv3DhAtVv1JQ6du5Cb9++zXXdxsYmK1b2KEPp8a9Jp//0eu1TxMfH08KFC2n16tWUmZlJ7969IxZfRDy1Lb25+DtlKlxo3IK1VL5SVfL29qbdO7bS5g1rycbGJl+b5ubm1KJFCxo+fDg5ODiQSCQind5Azw4spme/LyJbewfi8Xj59r989ToJ3cqQ1DmUhJbudPPmzS+e55fy98ZmcSEWi8nX17fA+0BEtGjxYiK9Dzm0n08cpzI04+dZnzXew4cPadKkSbR69epincePikmD2sR/Ai6XS0uXLqXg4GDq1asXBQQE0ObNm8nb27ukXfvuuHPnDgWHRRBHpqOkt0/p6OE/yMPDo6Td+tdz//797D/yxpSPZExPJaR+oGaNG1JGZiaZmYGGzj5IAoGgQDvbtm2jKTNmk52tNS2YN5ukUil5eXmRUMCjUbNXEJMnIoZIRWlp6aTyr05ERBf/WEpJSUm5bKemptLUGTMpMTmVEk5uIZmNGx07doxWrl5DR46dpLpRNWjwoIFkZmZGDx48oHYdu9Dbd+9o7MjhFBUVRY0aNaLnz1/SsOiR9HjfIqLUjxQYEkYD+/amuLg42rVnH51+fp9S3jlTauxLioiIoNq1a9OpU6coPHwcWVhYUHiZCpSeEEepcS9Io1LSm1PrKO78dkpN+kBCgYBeHt9AtjX7ksQhgJ5tn0SHDx+m5s2bExGRTquhtKP7KPntE0p/85B02kr53jdnZ2d6+ugBpaamZmtK3r9/nzIyMsjJySm7nUajIY1GQ0REL1++pAGDh5Khej96+uYB1a7fiK5dOk8ioZAy3rymjKR4ykj6QAKBgK5evUrlK1WhN69eEFukoPQMIzFFcuJkpNKbxAQiIpJJpZQRf47SEt5TRtwLkkrz1t3r368vTZ42lFg8EQX6+dDRP/8gn7YzyJzJonNTG5HWw7XAZ+RTdOvalThsDu39fT89eHiL+CSgNXt2fTJQ+1Y4ODjQ4YP7adXqNeTasiy1KaI2/L79B0kR3ozEdn5EcU/o9OnTOb5jEyZMmDBh4lP4+/vT6dOnqXbt2lSnTh2aMGECDRw4sFjqYpgwkRcikYg8vLzp8daJRAB5+/oTn8+n6tWr09ARI+nxplH07v41up+WTB7efrR39w7S6/X52ktOTqZOnbuQY6tphMwMat22Hd27c5umTZ9BREQDByzOfp4DAwPp8IF9Bfq3f/9+krhFkr5Ce3qjtKGNW7ZRixbN82wbVbcBmbtVI7ZUSz9NHENyjzKk9K5IMBpJ9OwIOfHfUPVJ46hevXqFvj+PHj0iYnBIG9GY0hPj6PyijoXq9/LlS+o/aDA5tpxGKe+eUeNmLejF08fZ1+Pi4qhshUokCaxP6Q+f0rV6DenY4YM5bMhkMtqwbg0NGDKcFCIR/bJlY6H9zov09HQKCS9F8eYSykiMpZ179tKKZUvI292ZLvzSlTKS4sm+9gBCZjqdnFCb0tLSCtT1zg9zc3M6cuggTZg4mcwtzGno4PkF/g7r1K41devdl5LuHKPkp9eoSpUqXzLNz+LWrVv09OlTCg0NpYWLfqEhQwYTl8en9WtXU8WKFbPbpaWlUfeevenw0WNUs1oVmjxxApmbF19+rlQiocwPryk9MY4y4l+QRGJfZBtv3rwh/6AQ4toFUcqL23Tx8lWaPPGnYvPxhyS/1Orv/WM6Ymjiczl+/Dh0Oh24XC5WrFhR0u58dwwePAS6sAbZR6u6/qWhZaLwPHv2DAEh4RDLFOjeq88ntasPHDgAgVgKrYs/lCotwkuXgYUFA4Eh4UU6nnbz5k0IxDI41B8GnX8V1K7XMPtafHw8XD28IFbqIJErERZRGip7T6jsPFCtRlSe9jZv3gyplQuChu+CfZ2BYHKF6NmrN5SOfnBuNh4yvX22FIZvYAgsy7aEc5Ox4IukOXTxHj9+jJ69+2DwkKGIjY3N/vcXL14gokw5KDV6tGzdBnKVBhYWDHTq0i37no0cPQZcvhCWNnYICAqFmbkFOHwRtP5VYVujF5hsHhROAbCt2QdCqSLHUdvExETUb9gEGoM1WrfrUCQ96OiRo8EXyyCUKtG1e88821y6dAlStSWCRuyGd/clEMsUAIBHjx7Bw9sPHC4fbdp1QGZmJsqUrwSbKl0ROGQbeBp7CKw8YMHmgcsXYvEvvwAAEhISUKV6TQjFUtSsXQ/Xr1/PIfNx8+ZNDBkyFPPnz8eZM2dw8OBBpKWlwcHZDYbSTWFdpQtYHB5u3bpV6Hl+j9y5cwf9+w/AlClTkJycXOz2h48YCYWNG/SRzSEUy0xH8v7DkEniwxR/mzDxhSQlJaFRo0YgIrRs2bJQtUJMmPhcPnz4gOnTp2P69On48OFD9r+/fv0a3bt3h8LOEwGDNsMQ3gDNWrYu0NbHjx/B4nDh23c1fHqvAJPFRmpq6mf79scff0AkU8G2Ri/IrV0xecq0fNvyBEL49PoNgcN2gi9RgCcQwRBaGyK5Bl26dIVIIoNCpS2ShndycjKs7Ryg9asElZMf6jVsXKh+9+7dA18sQ8DgLfDsshAiiSzH9UuXLkGms0FwdAx8+6yCUCwttE+fy40bNyBR6RE0Yg/8+q8Dm8PDyZMnkZKSgkOHDsGcwYY2rAGUPpXB4PDx7Nmzr+7T35w4cQJLly7Nsdb7VqxcuSpLXtHOHfZOLuDwhfDpuQwuzX+CUq3L0Xb8TxOgcg6Ee9ufobBxw5IlS4rVl+TkZNSsXQ98kRjlK1XN8fNYWHbu3AmdayCCo2Pg3m4mHFzci9XH75WC4m9TBrWJ/xyhoaF0/vx5atSoEbVo0YJOnz5NU6dO/ay3jv9GdDotpb+JoaTXDyn91R0yVCre42n/BXr16U8vLXRk27wjrdo4mspFlspTMuJvps+cQ8rSrUjlW4We7JpBjRvUoCOHDhY5C+fu3bsk1NiS3K0UsYRyunZqaXZmdkhICF06f5a2b99OFy9epICAAMrIyCAiyvcIIp/PJ7PMNHp75Q96d/UP0mpU9PLNW+I5hJDE3p8S7p/Llkd48vgR6eq1I47cQG8EYnrx4gUZjUa6ePEi+fv708wZ03PZ12g0dOSPA0RE5BcUSuLQZmTjEkbrlvWmls2bUlhYGI2KHkEjhg2l5s1b0PbfD5Fzs5/o7qafSBlcl7gKS0q4soeqhnlSXPwTarNkMQmFQkpNTaX09HTicrm0Yd3qIt1Doqy32ePHjyPvXivIjMGkX2e3pLGjR5JMJsvRzs3NjVwcbOnmst6UGPuGrA1aevr0KVlZWdGVi+ey2wGge/cfEMPdlcjcgoiIWDwh2bu70749O0mlUmXf7z07txMRUc8+/SgwNIIAIw0eOIA6tm9HIeGliOdShtJe7KSG1crQ3NlZUh6/x+yivgMGU0rKc9p64lh2NnBcXBzt2bOH9Ho9lS5dusj3oSSIi4ujkPBSxHYsRRnv/qQz5y/SutUri3WM0aOiycpSTzdu3qJm0/aRg4NDsdo3YcKECRP/HbhcLq1Zs4bc3Nxo5MiRdO/ePdq8eXP23/Z/O/Hx8ZSQkEA6nc6UPZ4P9+7do1OnTlFQUNAXxRxHjhyhixcvUrVq1cjZ2Zn27dtH4ydNJb1OS7NmTCMvLy/a+McFMmdxyYIvoaSkDwXaEwgENGzYMJowISvT+Keffvqi9XCZMmVo6eL5tG7jFgrp3Yl69eyRb9sBAwbQjJn9icHhU+mIMJowbgzt27ePnJ3bUOOmzcih+WRKT/pIDRs3obj37wr1bHE4HDpz8jgtX76cRCJRoU/Y2draUqMG9Wnd/HZkzMygGdOm5Lju5OREHAsj3f6tP5kjk2oXsKYjysrcff/+PanV6s/+mdDr9UQZqfTqzDaKv3OGMsmMqtVtQm6OtvTH/r0UHBJCl24cJzMLJtnb2maf7vwWhISEUEhIyDcb73+ZMGU6Gar3I5GdLz1cM5hgNJIFR0hMvpRSU1NytL13/wGxLb1IYHChWJ0bPXz4sFh94XA4tP0LM+Xd3d3p4/N79PL0Nkp5cpkqFkHS5l9LfjvX3/vHlMFh4ktJS0tD3759QUQIDw//ZJXW/wppaWlo274jDDZ2aNqilSkT5DMoU6Ey7KL6I2jEHgitPSESS3MV8PtfuvfsDY13Wbi3mwmZ3v6zqzzHxsZCZ2kNnVcpSFQGdOjYKTszW6XRY+/evRCIpdCHN4BYpcfy5b8VaM9oNCIoNBwskRKqgBowZ3IQWa4CBGIZDL5lIZLKs4s2jhk3HmKlFip7T/gFhuDUqVMQSmTQu4dALFMUWBgFADx8/OHYYDgCh26HTG+HQ4cOZV8bMXIUxAZnWFXsAAZPDL7WEXylJXRekbCxd0RiYiJevHgBK1t7iORq8IQSMJhsyJRqjB8/HuPGjftklmxqaioOHz6MmJgYyJRqmDPZcG46Dm5tpoPLF+ZbKOPOnTtg8/iwrNAehlKNEFoqMlebOXPmgCuUgMETw5zJBpsvRu16DfPNdnj37h3YXB78B26Cb9/VYLJY2LFjR/Ybdo8Os2Hr6AIAmPHzTCg0Bhhs7LF///5sGx8+fMjKInEPhVilx6TJUwuc/9fk8OHD8PQNgG9gCM6cOVNg2+PHj0Nl64bg6Bh491gKhUZXYPu8WLNmDRxdPRBWuowpO9pEgZApg9oUf5swUYysX78eXC4X1tbWuHz5ckm789XZuHEjeAIheEIxmjZv+ckTg/9Fzp49C6FYBoNPWQjFMpw+ffqz7Kxbtw4imQqGoOoQSmTYv38/BGIp7OsOgj64JipUroYPHz7A09sPQpkKMqUaly9fxsmTJ7F582Z8/PgxX9tv3rzB27dvP3eKn82lS5dw7NgxZGRkZP/b69evweby4T9wI3x6rQCLzUFmZuZX98VoNOLBgwd49epVrmvzFywAX6KA0ModDDavwHXa1atXoVBrwROKERQagQMHDsDBxR2WNkVf350/fx5RdeuDL5bBvd1MBA3fBbneDidOnEBSUhLmzp2LGTNmIC4uroiz/XGpUr0mDOEN4N72Z4jkatRv2BhcvghcvgBLli7N0fb/16KhEMsU3+0J06NHj6JRk+YYMnQYkpKSStqdb0JB8XeJB7qf+zEFyCaKi7Vr14LP50Oj0eDIkSMl7Y6JfwGHDx8GmycAW6wCT+sAXUQDtO/YKd/2Hz58QMPGzWDv7IYRI0d9UYD/5s0bLFu2DAcPHkT1WnVgW7MPgqNjoPevjKioKOhDasOn5zLYVOuBqLoNPmnPwycAzk3HITg6BjK30uDxhTh8+DB8A4Lh5OaFZcuWZ7c9efIkdu3aheTkZHTp2h2WZVtljR3RCIMGDS5wnD/++AMCkQQcvhB1GzTKDkZv3LgBnkgKCzYf+sgWkLqEQySWYsGCBVi8eHG2BMrw4SOgC6oJ5yZjwFVaI3DodthW7wm2UAZ9SB1IZIp8N4TT0tIQFBoBhZUjWBwedKH14dL8JzC4IjC5Aji7e2P37t0AgNu3b8PT1x9ylQYTJ03G8ePHobB0RNCIPfDsvAAavVUOu1G1a4PJ4YGjsAJP5wSbaj0RFFa6wHuRkJAADk8A93Yz4dJ8AgQiMZ48eQKRVA7Lsq2gcg5Em/YdcerUKbD4Yjg3Gw+FV3mweMLs+7F3716oHbyyj4zZOrogLi6uSDInxUFycjKEYikc6g+DXVR/yFWaAp/v9+/fQ6ZUQx/RCCrXENRv2KRI4z169Ah8kQQuLSbBqnxb+AYGf+kUTPyLMW1Qm+JvEyaKm7Nnz0Kn00EgEGD79u0l7c5XRW9lC7fWUxE4ZBvESm0OmTUTWfTu2xf6yBZ/SSe2RPeevXK1SUpKwpMnTwqMj6pH1YVdVP8sO8G10K1bN6js3BEcHQPPTvOhs7IFAGRkZODBgwdISkrCtOk/Q6zQQuPsD0cXt3yTLb4Fr169+qQMxeXLl2GwtoW5hQWYXAE4fCGmTM1bJuT69ev4448/vkkilaunD1xbTkJwdAyE1p7g8vj5xtNRdevDumIHBI3YDbVLEPhCERzqD4Vry8ngCYSfJQPhExAE60od4NF+NvhiGW7fvv2lU/phef78OcpWrAwbB2fMmjUHQJZk5Pv37/Ns//DhQ2zbtu2bSqCY+DQFxd/FpxJuwsQPSqNGjejUqVMkFAqpbNmyNGvWrKy3Nya+Wy5dukTHjh2jzMzMknYlT0qXLk0jhw8lvkxNLs0nEFISiM/n59teKBTSujUr6e7NazRm1MhCHQdLTEykEydO0KtXr3L8u0KhoFatWlHZsmXJ1saakh9fpIRntyj51V3y9/en15cO0NXFPenx74tIJZflY/3/KRUeQs+PrKFX53ZR/P1z5OLmRpOmzqDXDC2Z+zWmHn360dWrV4mIKDg4mKpVq0YcDodsbawp5dlVSnh2i1KfXydbW5sCxylTpgy9efWCHj+4R5vWr80uYtGmQydShDQgz05z6fW5XZTy5DIdP3aEOnXqRO3bt8+W3eDzeZSZHE+ZGWlElPXzCwIxxWoyVOpEfJ0TnTp1Ks+xz5w5Q/eevCC7VjNJ5lOVPj67SWyJhixYbFJ6V6JM1xrUsHEzevr0KbVs257i5T6krzeGfpo0lSwsLEgt5dOjNUPo8aYx1K1r52y77Tt1oQNnb5HMuxJlpiZSRkIcPdo7nzQqeYH3gs/n07Ilv9LL7RMo9uBc2rRhPRkMBjp8cD9VcxFQ3zb1acHc2XT//n3iKG1IYu9PcvdIInNG9vE1Ozs7SnzzlN7fPEaxV/dTUlIyqdRaUmv1dP78+U997Z8FANqwYQONHDmSLl68SERECQkJlJ6eTlKnYJK5hFHc+3fZ0jJ5IZVK6eSxI9QgUE99WtWmFcuXFMmHV69eEVsgIZGNJ4kdg+jZ02dfMqVPkpCQQO07dqbg8EhaunTZVx3LhAkTJkx8//j7+9OZM2fIxcWFoqKiaMqUKf/adQWHw8kq7JySQJnpadlFpkuShw8f0urVq+nGjRsl7QoREbk4OVHqo3MU/+AipTw6T67OOYsynzlzhnQGK3Jx96JSZcpTampqnnaC/H3p47X99O7qIfp4/wxVqVKFeGZp9GTLOHq6YxK1bd2SiIgsLCzIxsaGuFwuzZo7jwxRg8m60XiKTzOjEydOFMrnuLg4OnHiBMXGxn7Z5P9i+oyfycbOgRycXWng4CH5tuvYpTsx3KuTT581xBNKaM3K36h/v7652s1fsIACQyOoYesuFFYqMt97VlzY29nR28sHKO7uWUp594zS09LyHZPJZJExLYmQmUHISKWUpEQSWXkSX+9EIDNKSEiguLg4Kl22AnF5AqoRVZdSUlLytPU3a1YsJ8m7i/R+7zSaOukncnR0/BrT/CHQarV0cF8MPbhzk3r06EZEWZKRUqk0z/bW1tZUq1Yt0ul039JNE19CfjvX3/vHlMFhoriJi4tDVFQUiAhNmzZFQkJCSbtkIg9Gjh6TdXRNZ4uqNWp9t8cJExMTEVm+IhhMJgJDwov16Nzr169hsLaFysYFQokMffr0QY9evXHu3Lkc7f6ZmX3w4EGINTYIHLYTTo1Hw9XTJ5ft5ORkdOjUBe7e/hg9ZixSU1PRoVNn6G3sUaVadbx9+xbO7l5waTEJTo1HQ6Kzxbx58/DixYscdlJTU9GpSzfoLK0REBiMffv2fdZcXT194NxkLIKG74JIkzVWXnz8+BFlyleCuQUDcrUeDBYbHL4QMhsPWFfuDEE+Mitnz57FtGnTwBdJ4dZmOizLtoJcrYNKawBXIIZnl4UIGrEHIo0Ndu/eDUdXD7g0n4CgEbuhtHbBzp07ERJeCubmFrC0scfEiZPAF4qgUGkhVarh1e0XBEfHgKd1hDmLC5cWk2DBYOY4zvi5vH37FnyhBCJrLzC4IihUmhxHw7Zs2YLg8EgEBoeBxZeAr3eGKqAmIiLL5bDz4cOHYvFnxoyZkOpsoQtvAKFYhps3bwIA6jVsDJneDlKNFTp06vLF4xTE39nwShsXiGQqTJk6/auO175jZ2i8ysCp8WiI5GocP378q45nonghUwa1Kf42YeIrkZiYiIYNG4KI0Lp163+lZN6xY8egVOvAZLExaszYknYH165dg1CSJachEEtx+PDhknYJmZmZGDJ0OHwDQzFoyLBc8VaZCpVhW6MXgobvgtrRJ7v4+D9JT09H9MhRqFy9Vvbpxffv32P58uXYu3dvnuuhcpWqQB9WD85NxkJQyMzbO3fuQK7SQGXrBplSjbNnz+LatWtIS0v7jNlnzZ/F5sCn12/wH7ABbB4fL1++RJPmLcEXihASXgqvX7+G0WiEs5snbGv1QeCwnVBYOeVaO+zbtw9RdevBzIIJMmdA4VUBCiunHLKAX4O3b9/C3tkNTJ4YXIEEnbt2z7ftgwcPYOfoDDNzc1SvVQdDhg6HUKqEWKlDsxatAAADBg6C1rci/AdsgMolGDNnzvyq/hcne/bsQc3a9dB/4OD/jByFieKnoPi7xAPdz/2YAmQTX4PMzEyMHz8eZmZm8PT0NOmXfodw+f9f9VkoVX6X31F8fDy8fP3BE0qg0VkWu49z5syBzrc8gqNjYFOtOzgSFQxlWkAokeHBgwf59jt58iQkKj38+q6BbbUeCAgOy9Vm2PARULuGwLXVVMgMDnkGyvMXLACLJwJXYQmuygZMrgBcgQi//PprjnabN2+GSK6BvnQzCKUKHDhw4JNzS09Px6JFizB+/Hg8ffoUO3bsAF8kgVipRemyFQodIH/8+BGJiYkYOWo0GjVtjhkzZuTSwV6zZg2EUiX0XqUhEEmg0VtBo7dEx06d8f79ewyPHgmOWAmhtSeYAikcnF2zJIGEEkg1VgiNiMT06dOhdg9H0PBd0ARUA4PNhVfXxXBuNh4cvhgqtzAYyrSAOYMNVWAt2EX1h1KjK9KLFaPRiFu3buHhw4e5rr1+/Rq9evXC4MGDs+U9/omdkwv0kS3g3GQMLNg8BIeVApB1DDSqbn1YMBhgc7kICiuF7j17f/bLuVJlK8Kx0cis46cBVbBo0SIAWb9XDx06hKNHj36TF0qpqanYv3//NzlqHFqqbPac9T5lsGzZsq8+poniw7RBbYq/TZj4mhiNRowaNQpEhIiICLx+/bqkXfoqfC/JIiNHjoQurD6Co2NgXbkzWrRum2/bLVu2QKO3gsHaDr///vs39DInVWrUglWFtggYvAUKa+dilYV58eIFakTVhZd/ENatW1eoPv37D4AuvAGCo2Og9KkINk8AidoAN0+fz5KnMBqNEIjEcGs9DZ6dF4DD42PBggVQ2nvBr+8a6IJqol2HjqhWIwo8sRzmDBYYLA4qV62RQ0bj+PHjEEjksKrYAVylNawqdgRHYQUOX5SdEPE1MRqNuHDhAi5cuFCo5/1/fb9+/TrOnz+f3a9j564wlG6K4OgYaAOqYezYkn+5UxiuXr0KgVgG25p9oHYP/+pJJyb+vRQUf5skPkyY+B/Mzc1p6NChtGfPHnr27BkFBATQzp07S9qtfyXx8fF0/fp1Sk9PL1I/pUpN8XfP0sdHVygzPTXfIz0lyfLly+l1Bp88eq8hplMZGj3up2K1r1QqKe39M0p5/5wSn90kns6Z9KWbkdjSjc6dO5dvv4CAAFIrZXTh5+b05MCvNKBvLyIiyszMpG3bttHmzZvp1u27xLUNIJG1B3H1bvTgwYNcdtq1bUsZqYnk0WEOeXSYQ0YjyLrOUBo0ZFiOdrv27CVpQG0ylGlBIq8qtG/f75+cW7uOnWnY5Lk0d9sJ8g8ModKlS9ODu7fp+KH99Mf+vcRkMun58+f07t27Au0IBALi8Xg0eNBAun79Ok2Y9QsFh5emxb/8kt1m3qIlpKnQifRRQ4ivd6WkpERi2IbSjtP3qFrN2lS7Vk1KiX9L6YlxZFO9F714+YrCw8Pp1o2rdGD3Vvrzj/1ERGRmwSAyMycytyAzc3NiCmXElqjJjIzUpWFlquYipIXz55A85TGJnv5Ju3dsK1JV785du5N/cDg5unoQTyimCpWrUVxcHBFlPQs///wzTZgwIVvu5J/Evn9Pco9IEjsEkAWbR316Zh2J27t3L+374zAxhCrKMJrRW2UwbfzjAnXq2p2ePn1aoBRHXpQpHU5xZzbTy9PbKO7uGQoICCCirN+rkZGRFB4enmveN27cIE9ff9LorWjuvHlFGi8/WCwWlS9fnry9vYvFXkF0bt+GXu2fT0+3TaDUF7eocuXKX31MEyZMmDDxY2BmZkYjR46kdevW0blz5ygoKChbFu3fRFFimuIiJSWFOnftTt7+wTRh4iQCQE5OTpTy5BLF379ASfdPkZuLc559k5KSqGnzliSt0JP44W2pbv0GlLVn8u2ZNX0qmT84Sucn16fKpUOoevXqxWZbo9HQjq2b6NLZU9SwYcNC9VGrVZTx7jGlxL6kj4+ukLZsG3LquJhijTzatGlTkX0wMzOj1StX0PPtE+j+qoE0Z/YsSk5OJoZATkyBlJgSDd27/4COn71A7t2Xk3Oz8UTmDKpSuSIxGIxsOydOnCCJaynShtYjXUQj+vj0OlFmOnXr3IGcnXN/zxkZGTQ8eiRVqFKdfvnl1yL7ndc8fHx8yMfHp1DPO4PBIADUp19/CggKpqYtWtO9e/eIiGhAvz6UevsQ3V7YgRhvb1KHDh1y9L1//z6dO3fuu5OyvHr1Komt3UnlW5mkfjXp9NnckoGvXr2ieg2bUHB4JG3fvr0EvDTxw5PfzvX3/jFlcJj42jx48AC+vr4gIowcOfKbVBD+r3Dy5EmIJDJIVHq4e/sWWFn6n1y8eBHefoGwd3ItcjXkb8WCBQugdglC4LAd0IfVLbBA4ueQmZmJrt17QqHRwdreCTJrt6wsZYkMjx49yrdfTEwMRCoDWGIVzFlc2Do445dffoGHpxfklk5Q2nkgIDA4q+KxZzgkciXu3bsHAJg3fz6EYimEEhnKlKsIuVIN68qdYVuzNxg8MezrDIS1nWOO8VauXAmJxgrWlTtDpNBi586dMBqNOHz4MHbt2oXU1FQ8fvwYdRs0RrlKVXH8+HHIVRo41B8Gv/7robJxzSWZ0K1HL3AFInD4Aiz8K0O3ILZv3w6OSAGmQAaO0hpsvhjNW7VGcnIyOnXpBrVnaYhsvGHGZIPBFSI4OgYBg7fAgsEEhycAT20LqwrtYc7iQiJToGPnrvD0DcSo0WNgNBr/ypYPAIcvhMHaFs1btQFPKAGXL8S8+fNz+BIbG4sHDx4UKdPoxYsX4PAEsK7SBUIrD/j0WgGtb0X06t230DZGjxkLsVIHpa07AoJDs7M6du3aBQsOH9aVu0DiEIjg6Bi4tpoCtkACgUQOO0fnImV7ZWRkYOq06WjRum2hJV28/QNhXbkzPDrOhUAi/yELv5w6dQorVqzIJXNj4vuHTBnUpvjbhIlvxJkzZ7KLJ+7YsaOk3fmheP78OarXqgMv/yCsXbsWADBk2HCo3ULg0mISpDpbbN68GUajEWPGjYdfUBh69+2X76m79+/fg83lwX/QJnh1+wUWLC4YLBYqVK5WYrIF38s6MyUlBQ2bNINCrYWlrSP04fXh13cNFNau2LhxY5FsGY1GzJk7F42btcTGjRuxatVqsLk8WDCYUKh1kGosIZErsXHjRnCFUnj3WAbbGr3AUVghJKJMDltnz56FQCyDPrI5WCIlLBhMNGzSLN/7NmbsOCgdfOBQfygkKgNiYmI++558Ln/88QekWmv49lkFq/JtUK5SlexriYmJuHHjBlJSUpCZmZm9Npi/YAH4IimkGiuUr1Q1lySM0WjE2bNncenSpW86FyDr51CqUEEfWB1SrQ0mTZ6Sq025SlWgD6kNx4YjIBBLcf/+/RzXr169WugsdBP/XgqKv0s80P3cjylANvEtSEpKQqtWrUBEqFatWr4VYk0UjUpVa2TprY3YA41byL/uWHxycjLKV6oKMzNzqHWWX1UbLSMjA/PmzUOfvv0+KWmwe/duMDh8ODaMhnf3JbBg8aCw84LcowwYAikYPDHMLBgYMmQoNm7ciOfPnwPICkh4AjG8ui6Gff1hMGfxwGRxEBASDgcXd/D4QuitbXHixIkc4xmNRqxYsQJt2nXIDmr79OsPqcYKSls3hISXhpObBwwRjWBbszcEIgk4fCE4cktYcPgQiCQ5tLufPHkCnlAC/4Gb4NVlEfhC0SfvT7sOHSB1DoVPz+UQGFygDq4DobUn/AKC8PHjR4SXKgUmTwiv7r+CJVZB6VMRavdwePsFgCtVw7HhCARHx0DuUQYWTBZkDn5wbTkZcktHLFq0CMuWLcOhQ4fw5s2b7CDy8ePHuTZ2t2zZAp5ABL5YhsrVamDmzJlYvHgxNmzYgKtXr+bpe0JCAnwCgmDOYMGczYPCK0vWxap8OzT9S8ful19+hbWdI4JCSxUoJXPixAns2rUrhwZmRkYGJAo1eBoHWHCEkLmVAk+mgcjGC0Ej9kAbUBWjRo/+5D3+EnRWtnBvNxNBw3dBprPFyZMnv+p4eXH58mX4BgTD3skVmzZt+ubjmyg5TBvUpvjbhIlvydOnT+Hv7w8zMzNMmTLFtElTSMpWrAxDeH04Nx0HgViGO3fuoG6DRrCt3hPB0THQBdXE5MmTsXHjRgwbNgynT5/+pM0u3XpAKFOBxeVD5V0BAYO3QO0WhunTv27tim/N7du34eLuBb5IjAGDhhTpmXv27Bl8AoLBEwjRul2HIm+iz5o9B3JLJ9hU7wGRXA1zJhtmDBYYPDGYbDaOHz+O+Ph4AED3Hj1hzmCBJVJCau2GPv3657J39OhRDBo0GGvXrv2k3EhU3Qawq9U3S4ItJApTpuTeTP3abNu2DSp7TwSN2A2H+sMQEBKeq83EyVPAZLEhksiwd+9eqHQGeHSYg6DhuyDVWGL06NGwd3ZDeOmyuH//Plq0bguJSg+RXI2+/Qd88zk9ePAAP//8M3bs2JHns2RpYw+PDnMQHB0DjsIS3br1yL42cPBQCGUqiJU6tGrTrlDjZWRk4N27d6bflf8yTBvUJkx8AUajEfPmzQOTyYSdnd030TX9t9OwcTMYIhpmvZG3cv5XbgotW7YcIoUG+uBaEEpkuHHjRkm7hIyMDLC4fHh0nIeAwVthzmTDt/dKBI3YAzMGC26tp8Kr62JweHy8efMGT58+RXp6Ou7evQuBRI6AwVshtPaC0NoTUucQWNnaFzlY5fIE8O2zCi4tJmbpzHEEEFp5IGDodnD4Qmj9qyI4OgaW5duheq3aALKy5rv16IkRI6LB5Qvh3X0JXJpPgFyl+eR4bdp1gGXZVllaer5VYSjbGjZVu4HJFWDsuHFg8cUQ2weAwRNDX6YVVBodpkyZgtu3b4PDE4IjN0BfuhkYPBFEtr6wrtI1azEUUhsCoRh670iIlTrMnDm7QD9sHZ3h0mIiAoftAEukgNwxEFyFJQRKAwQSObZt2wYAuHnzJk6ePImMjAzMnz8fGvcwBI3YDU1IXViwOJBobSCWKXDx4kXcuXMHArEMbm1nwKp82zw1xQvi+PHj4Iul0ATUAIPDR+3atVG/QUNo/SojcNgOqD1Lo1PnzujYsSM8ff0RGhFZ7BvIv/66JCtTRGuNyHIVc2j2fSvsHF1gU607XFpMBE8o/tdqhJrIjWmD2hR/mzDxrUlMTET9+vVBRGjTps2/snhiYTAajUhOTi5UW2t7p6yX2SP2QGXrjgMHDmDfvn0QSGQweJWCRK7EmDFjINVaQ1+qMQRi6SfXa0ajETdu3EDT5i1hKNUoSw/Yv8pX0QN+8eIF5s+fj127duW50ZaSkoJNmzYhJiam2DfiIstVhHWFdvDptQIStQFHjhwpVvsF0aBxM9jW6JUVN4fWgwVHgMCh22EX1R8MDj9X7ZRdu3ahdv2GiB45CqmpqYUaIykpKc/YcdOmTRDKVDAEVoNQIsP169dzXN+2bRtCSpVBo6bN8ebNm8+fZAGkpKQgOKwUxAotBCIJ9u/fn+P6kydPwBOI4dN7BVyaT4BKq4ebly9sqnWDR4fZ4ApE4ImkcG01FZZlW8I/OAxsLh8Bg7fCf8AGWDCYJRI3F8S4nyaAKZBCZOcHjtwANpeP169fIz09HQwmC3791yNg8FZweIJPxtu3bt2CRmcJNpeP0IhIU1HGfxEFxd8mDWoTJj6BmZkZdenShQ4fPkwpKSkUGhpKK1euLGm3fmimT51EipRHdHNRR6pVKZJq16792bb27dtHfkGhVLZCZbpz507xOfmFrF6/kVSlW5OhclcSO4XR/v37v7kPp06donXr1tH79++JiMjCwoLmzZlFd1cNohvz25Jao6UXh5fT82PriIyZxBTKicmXEEDkGxBILu5e5OTqTnw+n+rVqU2XZ7Wgj4+ukEvzCeTYcCS9efOWXr16VSSf9JZW9P7qH/R43yKyq9WX/Pqvo8zUJLr7Wz9SyGWUEfecUmJfUvq7h+Ti5ETPnz+n0mXL07YrsbRw3W7y9vamW0t60LPtk6hPz+6Umppa4Hh9e/ekj5d306XZbejd1YP04eFlerz/V6LMDJo5dwHZ1OhDLs3GEV/rQK+Or6e6dWpT7969ydHRkU6dOErBno708sRGsqrUifhaB3pyYAndWTOcYq8eJK7KhgxRQ0hXtRctWrKsQD94XB6lxb+mjKQPZExPI125tuTYMJrS09NJU64D/Tx7Pk2b/jMFhIRTtTqNqFqNKDIzMyNkphMBxGSyqEGDBrR03gzSaLRUukw5Gj12PLGFUhLonUlo60MvXr4s0nfx65IlJPGuRtbVupOudHOSK9W0cMF80jE+0NkJUaRmJNGK1evo199W0/3XiXTyxHEKKxVJp0+fLtI4BdG2bRu6euk87du+kQ7s25NDb/Bvjh8/TqtXr/6k7vjn8vrVS5I4BJDI2pMYLE72z4sJEyZMmDBR3PB4PFq3bh1FR0fT0qVLqUKFCvTmzZuSduub8vr1a3L38iW+QEiBIeH04cOHAtv36taVnmybQI/XDyMp14xCQkKoYsWKdPr4UZo2rDtdvXSBjp06S/KwpmQo25okrqXo8OHDBdo0MzMjFxcXGjdmFKXfPUY357Umdtw96tixY57tP3z4QPv376eHDx8Waa7v378nH79AGrd4EzVv343G/TQhx3Wj0UhlK1SmroPGULP23ahzt+752lq2bDlFlKlAPXr3pZSUlEKNH//hA7FkemKJ5MTiiyk+Pr5I/n8JdWrVoPen1tPTg0so9sp+4vD4ZDRm0scn14jHYdOjR49ytK9WrRpt2bCORo8aSSwW65P2Bw4eQmKJlCQyOcXExOS4VrduXdq7cysNaV2dzp46Qa6urnT58mVav349nT59mpq1bE3vNBF05G48tWjdtljn/TdsNpuO/fkHnTr6Bz1+eJ/Kly+f43p6ejqZWViQBYtHDK6Q0tLSaN2q34j/7AS93T2FunfpRDyJgoRW7iSyD6CXL18Sg2FBH59cow8PL5FQJCYLC4tC+3P69GnauXMnJScnF/dUsxk2ZDCZZ6SQxM6PnJuOJXMLC8rMzCQLCwsSCEX08dFlSnh6g8zNzYjP5xdsK3o0sVzKk3e/9fTgXQqtXr36q/lt4jsiv53r7/1jyuAwURK8fPkSpUuXBhGhR48ehX67a+Lr8PbtWwhEEjg2HAGrCm3h4u5V0i5lEz1yFJQOPrCL6g+RTIU///wzz3bx8fG4cuXKF2XQGI1GrFu3Dh06dMDatWthNBqxYOFCiORq6DzCoLO0ziFP8/r1azx48ADv37+Hq4cXBAY36Eo1hjmTDXMGGz7+gdAFR/11bLIGhgwdBqPRiHoNGoEpkEEdXBu6Uk0gkSvz1ff7m3379qFNuw6YO3ceMjMzcevWLZQuWwEiuQpW5dvBr99aiFSWGDx4MK5cuQIreyew+WIEh4YjPj4ee/bsgc41AMHRMfDoMAe2ji4YPHQ4JCoDVHbuCA0vnUuf7Z+8f/8es2bNAocnAJmZgcnmYt78+VBo9JC5loJTo1Gw4AqhDW8EpYMvhgwdnqP/wkWLIFNqwODwIPMoB3MWB2YWTDC5AtjXHQyNTwU0bNIsz7GvX7+OpUuXYuPGjdBb2YDN4YLNE8CmWg/IPcpCaO0FrU85dOzSFRK5El5dFyNo+C6wBFK0bNUGZSpUgrkFA3ZOLnj06BHKVKgEq/Jt4NNzWVZVdQ8vKCwdIZDIc2le58fx48ehs7KDBYsDlkgJ+zoDIbN0xIIFCwFkZSzcuXMHY8aMgS6sHsjMHDy1HQKHbodtzd4ICo0o1DjFwZy5cyFWaKHzjMj1HBcXY8aOg0imglxvh0pVqn83OpAmvj5kyqA2xd8mTJQga9asAYfDgY2NDa5cuVLS7nwz+vTtB11QzawTYl5lMWHChE/2OXXqFLZs2ZJv3ZqJkyZDbu0C68qdIZDIi3TiKzk5GXfv3s13Xff69WvoLK2hcfCCQCwtdJ0NANi5cye0LllxrFvbGXB09chx/e7duxDKVAgavgt+/deBxebkaefPP/+ESKGBXVR/KBz90bN3n1xt4uPj0aJ1WwSERGDp0mUAsurPCEQSiJVahEZEfvO16549ezBmzBicOHECjZu1gDmDBY5UB11EI1iwOFi8ePFn2b116xYEEjn8B2yAS/MJ0FpaF9h+06ZNEErk0HtGQCxTQGnjiuDoGLi3nwVre6fP8qEofPz4EdeuXct1/7v16AUOXwguX4AVK1bmuJaamgq/wBDILJ3A5otQt3597Ny5E7aOznB09ShSNvyEiZMgVmihtveCl2/AV30Ofl2yBBweHxweH4P/Z0115MgR2Du7wcrOETt37vyknUZNm8OyTHMEDd8FtZM/lixZ8tV8NvFtKSj+LvFA93M/pgDZREmRlpaGPn36gIgQHh6erdP7I/L27VusXLnymx73Kk6uX78OsVKLoBG74dN7RaE0ib8V6enpGD1mLGrWrod169bl2ebixYuQyJWQaa1g7+SS66hbYRg4eCgYTBYs2DwIDG5gcPjo0r0HPH0D4dJ8QtYms1tIDhmVO3fuYP/+/UhISMCo0WMgsfOFe7uZ4CqtoVRrMXTYcKi9yyNw2E4oPUojeuRIbNy4CSyeEPrI5lAF1ARPYUCFChUwbNhwPHv2LE/fTp48Cb5YBqtKnSC3csGkyVOzr92+fRsOzm5gc3no2r0njEYjvHwDYFm6Cexq9YVIIkNcXBxevnwJsUwBfUQjKO290bFzV/AEIvj0XIagEbshlGsKvagzGo05Nh/nzJkLNl8MlkAGgd4ZwdExcGwYjdLlKuXol56ejpiYGMgN9pC5lYZlhXZZ2nA2HlmbvHwRwkuXQVpaGp49e5ZdqPLEiRMQiKWw9K8IgViarYl47Ngx1KpbH6ERpeHi4Y2mzVvhw4cPcHRxh0217nBrMx0WHD4kls6oXacO6tRvhA0bNgAAfAKC4dhoJAKGbIVEa4t58+bhzz//zFNCJiMjA3v37kXbdu1RuXotLF/+G9LS0iCWymFfZyBsa/aBBVsAJk+EESOiYTQa0bV7TwikCvDFMjRv2QoiuRochSU4Mn32BnVoqTLZYzx79gw7duzAkydPCvUdFBU3Lz+4tpyUdfTWNeirFUa9ePEi/vzzz0++7DDx78K0QW2Kv02YKGlOnToFrVYLgUBQqE2bfwM9e/eBPrROVr0LnwoYP378F9vMzMzEnDlz0bpt+2IviLdo0SLovMsiODoGdrX7o0KV6oXue+fOHQgkMtjV7g+tT3nUb9Q0x/X4+HgIxVLY1x4Aq/Jt4ejinq8PMltPWLD5sOAIoDFY55IDadG6LbQ+5eHUeDREchVOnToFIGu9d/369e8ixnH39oNT49EIjo6B1DUCFiwu5sydW2Q7t27dgkCqgP+ADXBtOQlag3WB7ctWqAKHekOy1kW+5SFTKKF1D4NEbcCEiZM+czaF48qVK5AqVJCqLWHn6Jyjvg6Q9QLkby3uf3Lz5k1w+UKoA2tB6eCDHkUokv6/qHQGeHaaj6ARe6CwdMhVhL64+fDhw2eta/+X+/fvw8rWHhYMJspVrPKflUP6J8nJyYiq2wAiqRzVatZGYmJiSbtUZEwb1CZMfAXWrFkDHo8HjUbzQ27wvn//HrZaLarI5bAUCDFn1qySdqnIZGRkIDQiEio7D0jUlug/cHBJu1RoUlNTYevoApZYBU1IXWi9y2L27IJ1jP/JqVOnIFbq4NtnFayrdoPQyhNclS34IjHqN2oKnX8VODcZA6FMma3Ft3HjRnD5IvCkKsiVajx9+hTNW7aGUmtAROlIvHnzBgcOHACDm5VtzBLK0KNnb3B5AthFDcgqbMKXgi+SQuESAl1QLRisbbODhoSEBKxfvx779++Hh5c3FN4VERwdA4d6Q1CpWk2cPn0as2bNylF9+unTp6hUtQbMGSz49V2DoBF7IFbqsvXibty4gW7de0CjtwKRGcxZPOgim8Op0UiYM1iYN28e9uzZkytQT01NRau27WFl64B2HTrlme198uRJTJs2DQKxFPrQ2pCoLTF33rzs648fP4bB2jareCNfBK5MC0PZVggcthNCvTPUwXUQNHwXlNYuaNO2PXgCMXhCCfoNGIiOnbvAUK51VoGWyBbo3bfgoPLSpUtQag1gCmSwrzMIYodACHUOsK3RCyKZCocPH8bu3bvBE4rB4AjAV1pBIJbl+QLEaDSiRlQdCNXWYImUEDsEQqzUYtOmTWBxeAgcuh0Bg7fCzJwBLl+I2NhYvHv3LruqvV+/tWCwWJg6dSpc3T3BFUpgZm4BM3MGKlSoiD/++ANXr16FSCqH3i0YIqn8q+jz12/UFFr/ynBqNBJCqQKXL18u9jFM/HcxbVCb4m8TJr4Hnjx5Aj8/P5iZmWHq1Kn/+oJgz549g62DEzg8Adw8fb77IvQ7d+6EVGcLjw5zoPOvgrbtOxapf0xMDCpWrYFOXbrluRH5559/Iqx0WVSsWiPfgtePHj2CBYsL93YzETBkK3hieS5d5YCQCDg3GZMVd3qVwqpVq4rkZ15kZGTg1atXxXa6rF6DhuBp7GFVsQMYPDHsovrDzsn1s2z16dcfTDYHPIHoky93OnftDo1XGbg0/wkSlQHbtm3DqlWrcOjQIVy9ehUVqlRDhSrVijXOfPv2LU6ePIkGjZvCqnzbrGQL3wqYMWNGgf3i4uIwe/Zs/PLLL1i7di30nuFZGfitp8HNy6/IfiQnJ0MgkUMX0RjOTceBwxdmJ9N87xiNRpP29D+YPHkyVK4h8O2zCmqPCIwdO66kXSoypg1qEya+EleuXIGjoyMYDAZmzpz5QwWU27ZtQ2m5HE91BmyQK+Hn7PzZtl68eAH/oFBweQI0a9n6m76hT0lJwc6dO/Hnn3/+UPd/woSJkNr5wKPDbAgMbhAo9Vi+fHmRbBw8eBBygwMCh+2Ec5MxYMt0sGDx4O0fhPfv36NxsxbwDw7Hb7+tyO7j7u0HC44AluXaQGDphirVauSyu2jRIhj8KyNo+C44NoyGb1AoLBhM+PZZBe/uS8BgskBm5ggYtBnB0TEQyFS4c+cOUlJS4ObpDY1LAIRyDThCKRg8EXQRTcAWq9C9Rw8IJXIYgmtAIJZmZ3ZElq8EQ0QjSJ3DwJHpoHLyh7d/YHbhj4yMDISXKg2lXxUEDtsJsZ0fmAIZ+HoXmDPZUNp5Qm7I2oT+XyZPmQKVcyA8O82H0tEXM2fOzL725s0bXLt2LftZPXPmDGrVqoX27dvnqAzeqUs3GMIbZBXm8SiNqlWrQq7UwNyCARZPBKlrOHx6r4RYbQCDyYRv75XwH7ABbC4Pnt6+4MgtYV25Czhyy0JVED9//jyEEhkMPmXB4olgX3sAgqNjYAiJwrRp0wAAK1asgNLeC0Ej9sC56Th4+AZk98/IyMCcOXPRqk1bsHkCBA7bAf+Bm0Bm5tD9VcW8boNGkOpswZFqIJAosHnzZgBZhZu4fCHc2kyHc7Px4AuEEEpkUHpVAEukgE21HmCJlNBHtoBAIkfjxk2gL9U4y78yLdC9Zy8AWQs5d28/BIVGICKyLGwdXTB5yrRPzj0vYmNj0bR5K2gMNlDrDOjYuesnZWVKkrS0NBw7dizfBaaJ7wvTBrUp/jZh4nshISEhR/HEf7uMYGZmJt6+fVvislrp6emYPGUqWrRum6uI3d8YjUYMjx4JKztH1Iiqm++GekpKCgYPHYZadepj9+7dSElJQaOmzaHQ6FCvYeMv3mjTW9nCscFw+PRcDr5IigcPHuS4vmTJUojkKui9SkGtNXxx0efHjx/D0sYOXIEIrp7eePXqFUZEj0T1WnWyT/b9zYcPHxAbG/tJm/Hx8ZArVTBncWFVsT10oXWLlJH+TxISEgoVF378+BGt2raHt38wZs76/4SgzMxMqLR62FTuDJuqXaFQa4tlHXvx4sUsKRFrZ/BFUmgDqsGv/zqoHH3xyy+/5NsvPT0drp7e0HpFQuXohwqVq2Ylg5RqAoWtB/r2H1BkX2JiYiC3coTEKQRclQ30n5BDMfF9M2jwEOhC62a9iIpohF55yP1875g2qE2Y+IrExcWhVq1aICI0bdoUCQkJJe1Sobh69SpUfD5+lcrRWCxBkzp1PttWi9ZtoQ+tC79+a6G0dcfq1auL0dNvz8WLF2Fl5wAuT4Bhw6OL1Dc+Ph6nT5/G06dPUb9hE9g6umDosBG5Ns87du4Ky7JZ2bXa0Hpw8/D6ZCXmhw8fokZUXUSUKY+1a9eiVp36UOoswRGIYcHiwJzFhTmTjcrVauQbXAWFhEFk55v9Jt7WMXfWwt27dyEQS8HX2IMlkIDF4UJs6wtzJhtMNheNGzcFWyiDzL0MNCF1weTwMGjwYHTo0BFSnQ3c2v0MXammMGdyoAmtB4ZABq5AhCbNmsOqUqesP6ilmmDIkKEAACs7R7i3m4nA4bshVlti2LBhOX6OunbvCbZYCW1Y1kaxzD0S5kw22BI1mDwhgobvgv+ADWCyWDnm0aNXbxgim2X/Ae8/YCCALD08vkgMsVKH4LBSSElJQUh4aajdw6HxLA0f/6Ds76t7j17QBdfK0j9zj8D06dMxbfoMyK1d4dhgONhiFZgsNvr06w++UATXVlPg0WEOODwBxHIlLDh8MIVyWHAEkCk1qFC5Ko4fP17gy5S7d+9i1apV6NChA9hCGTTBtcEXSXDgwAEYjUacPn0aIoUGHu1nwxDRCJWr18zuW6NmFPgaO+gim8OMwYRD/WGwqd4T5kwOuHwhrl69iszMTOzfvx8HDx7M5cemTZug0uqhs7TGoEGDYPAtB48Os8EUKiD3LAeb6j2y72f16tWhtPeGe7uZUDr6Ydr06Xj9+jX4QjGcGo+GVYX2YAnlcG83ExKVPl8d9k8xe/bsrHHaz8oe53skNTUVgSHhkBvsIRDLsvUfTXy/mDaoTfG3CRPfE5mZmRgxYgSICKVKlfriDUYTn2bI0OFQ2nvDukoXCMSyLzoN1qVbD0it3aH0rQK+SIr+/ftD5RwE7x5LoXYLw/jxP32Rr0ePHoVKqweHx8fkKVPzbHPq1CmsWrUq+9k5f/48lixZgnv37hV5vK7dekAfXh9BI/ZA41MekWXKQuXoB7uo/hDKVNkyEQsWLgSbyweby8OoMWM/aTc5ORnR0dFwdvdC1ZpRJSqXmZCQAAaThcBhOxA4bCdYbC7i4uKyrx87dgzr1q3L8W9/k5qaimYtW0OlNaBBo6ZITk7OvtasZWtYVWiH4OgYqL0rwNreEVy+EPUbNilwQ/3+/fsQyVQIGrEHAYO3gMFk4fLly+jXfwAGDhyImJiYT64X/8m5c+cgkqng0XEuLMs0R2T5Sp/uVATb48ePx549e4rN5j958+YNDh48aPp9+BcPHz6ESqOHwtIBCrX2h0yKMW1QmzDxlcnMzMS4ceNgZmYGT0/PH+YXxbp161A2MAhtmzb9ouN1terUh02VLllacp6lsHDhwmL08tvjGxAM2+o94Nt7JUQKDc6fP1+ofvfu3YNCrYXS2hlcgRgar7LwaD8bMoNDdpbq3/ydKatzDYRYpsCtW7c+ad/RxQ1CKw+I7QNgzmTDULoZbKp2g1gqh19QKOxq9UXg0O1QWDnlGygsXrwY5gw2tGENwVPbonff/jn8nzFjBnbv3o3AkHBoAqrBtkYvWLC48Ou3Fi5Nx8Pa3hHHjh3LKrQRWAsCS3dwBWLogmpA410eFmwemHwpRLY+YLB5MGdyYF2lCzgyHfhiOYRKA5S+lWHO5EClNeDMmTOYOXM2RDIV1I4+cPXwys4wSUxMxIIFCyBXqeFQfzjYUi0s2DxYsLhgsNjo3r07RBIZ7KL6w6p8W9j/44jglStXIJYpoHX2g0SuxI0bN/D06VNwRVI4NoxG0IjdUNq6Y9OmTbBgMBE0fBcCh+0Ai8PL1k17+fIlXNy9YGZmDk9vX3z8+BHNW7WBdZWuWRu14Q0xcuRIAMCuXbugUGkhkSmwatVqcPhCeHVZhMBhO8HgieHUaBSkTiFgC8Ro3qpNnt/Phg0bYGPvDDdPH3AFWYUb+Wo7WDBY4ApEqF6rNjIyMjB12gxY2tqjVNnyePr0KYAsKRQmTwTnpuOyMtsNbmBJ1BBae0FscML0Im7s3rhxI0tDu3w78GRamJlZgC1WwapSJwhlKuzduxddu/eEo6sHOnXphrS0NFy7di1LF374Lvj0XA4LNj9L7889FGvWrCnS+H/Tv/+APDO1vzcOHToEhZUTgkbsyXr54/D5p1JMfBtMG9Sm+NuEie+R1atXg81m/+eKJ5YEYaXLZWsia7zLYd7/yLwVFStbezCFckhdwsDgCFCpcmXowupnxS+lm6JHr97F6Pmn2b17NwQSOQx+FSGSyvOsV/K/pKSkoEOnLnDx8MGgIcPQo1fvrGKWw3dB7VEK9o7OcGwwPGs+gVUwf/58ZGZmgs3lwbvbr/DruwYcHj+X9vDdu3fhHxwKnaUNZs+eg/fv3+Pnn3/GwoULvwtd4RpRdaC0dYfSzgNV/ifpY/r0nyFWaqF1C4aNvWOOE5YA8PPPP0PlFADvbr9C7Rqa4wVEv/4DofEuB+8ey6C098avv/5aKF+SkpIgV2lgVb4t9KF14PXXKcl+AwZCojJAYeWECpWrFvnU8NRpM6C1tEFweKlcmfefy4ULF7IkEsPqQ6zU5SryWBzcvHkTErkSGkdviGUKXLt2rdjH+BH5+PEjzp8/n+uZ/FEwbVCbMPGN2LNnD6RSKcRiMXbs2FHS7nwzzp07B4lMAYlKDxd3zzzfMv9IOLp6wLnZeAQO2wm53q7AzM/U1FSMGj0GjZu2QMOGjaAPb4Dg6Bjw1HawrdEra3POvzJm5aHx/fTpU+zevRsvXrz4pE/v3r2DOZMNgZUnGHwJOHI9hNZeCBy2A3yxDH5BIbCt0QuBQ7ZBprfDwoULc7zJ/5vwyHKwLNcG2vBGEKmtsHbtWgBZ2nZimQL6oOqQqC3BF4nh3X0JgqNjwJZqofKrCqWTPzp06gIAGDFyFKRyFdy8vMETShAcHYOg4btAZAbnpmMRHB0Dub0PJFpb8HWOMJRtBceG0WBx+bBg8+DVZRHsovqDweZh7tx5OHv2LHbs2JFd6MFoNGZlNbuFQmrvC7ZQDn1kC1gwWFnFGiMaQShTYfLkyQiPLIdK1Wrg9u3bueb78uVL7Nu3D69evQKQJdnBVVhCG9EYCu+KYPLFWLx4MRycXSFzCoY5gwUzcwtMmvz/chztO3aGRG2AVGOFhk2awdPHH2YMJnhKKwhE0uwXGLGxsZg1axaWLFmCtLQ02Du5wrZmb7i3mwlzFhe+fVbBskJ7KLwrgssX5freX716BZ5QDOem46AOjoIFm4egEXvA1zrCof5Q+PT6DXK9PX7//fc8n5GDBw+CL1ODr3WEPrI5zJlZunwqG1c4ubrj/fv3ePLkSZEkMo4ePYr2HTuhV+8+mDRpEkaOHIkOnTpn/35LT0/HgEFDEBJRBlOmTkd6ejoiIstBae0CgUwNNk8AtYMXbOwdC3X0My/+1rrWfUWt6+Lg2rVrEEoV8Gg/G1blWiM0IrKkXTLxCUwb1Kb424SJ75VTp05Bo9FAKBRi165dJe3Ov5YpU6eDrzBAG1oPFiwuHF1cP1tKTG9jD5dmPyE4OgYiGy+MHj0acpUGKls3SBUq3Lx5s5i9L5ja9RqCr3WAmQUTbIkG0dEFnwodM3YcVC5BcGszHQprV8yZMwdunj4wN7dAaEQk5syZC4lKD0NwDQglMty5cwdGoxE8gQgeHebAu8cysLn8XOvAkIjSsCrfJkvWUKqAjb0DtN5loXIKQLWatXP5cfToUVjZZmWHLl/+G2JjY1GtZm3orGzRf+DgT27Orl+/Ht169MTWrVsxa9YsRI8cicePH+fbPj09HZs2bcKmTZtyfPf2zm5wazsjKwvawTtX8c3Bg4f8/wuIyGbo1qNn9rX4+HhUqV4LcpUGrdq2L1LW8/Xr19G4WQu0bd8xe63A5nDh23c1gobvgkCiyM6I3759O+o3boaJk6dkn55NSUnB1atX8fHjx0KPCWStQ0IiIiGSytGhU5dPyu9MnjwZhtA6WcVDo/ohqm6DIo1XGPoPGAh9RKO/XvI0Q6fOXfDo0aMfStbTRG5MG9QmTHxD7t+/Dx8fHxARRo4cWeLaat+KDx8+4MaNG9+1PuzffPjwAYsXL8bq1avzDBh27NgBnkAEoVSJKtVrFqhF1rV7T6hcgmBdtSvYPCE4EjXkHmUh0tmDzRNA4+QHnkCMGlF1cenSJSQkJKBZy9ZwdPNE9KjRhf4DO2fOHHCV1mDwJfDuvgRBI3aDKZBBZuOGoNAInD17FnKVBhYMJtg8AWRaK1jbOeDVq1c4ffo0Tp8+jWXLloPNF0FXqgl8+6yC3GCfnWm9bNkyGHzLITg6Bs5NxkBrZQe5pRO0XqWht7JBx85dMGXq1Fzfb0ZGBmwdnKANrAGNT3nIlBoovSvCuek4WHD4EIilMGdx4NNzOYJG7IZIoYVAqkTg0O3w6DAHTKEcPIEYz549y2E3NjYWLA4PQSN2I2j4LpgzmGjbviNatW4NfWQLBEfHwKpSJ3To1LlQ9+9vOnTqDI1/NTD4Eii8KsC6cmcIxVL07dsXDBYbHh1mw6fXbzBjMPHzzJl49uwZzC0s4NllIQIGb4UFkw2tX0X49VsLmZ03OnTogMePHyMtLQ1Oru7QepeBysEH9Ro2xoULF+Di4Q2VzgChWAqeyhoWHAFsqvcATyDMFTjevHkTQpkKPI09+DonWLB5EGttweSJILTygAWHD3MGCxMmTMjRLzk5GYOHDkP1WnVg6+AEgUILFpePwUOG4OHDh/jzzz/x+PFjOLq4ZRVJsbQuUnGUQ4cOQSCRwzIkCgKxDIcOHcq+9tPESVA6+MC5yRhItDZo2qw5qtSIwsCBA3Hy5Encvn0b+/btK3KQ/E+eP3+OnTt3ZmeLf6/MnjMHOitbBISE4e7du4Xqk5ycjAaNmkKlNaBJ85b/et3R7wnTBrUp/jZh4nvmyZMn8PX1hbm5OaZPn27alPkKGI1GcHkCaILrwKPjPEg1VjkKeReFps1bQe1dDk6NRkIgUeD8+fOIjY3F8ePHv3ohyEePHiEkojS0BmtMnDQZAFClajWI7fwQMHgrFF7lUat2wXKOLVq3hVWljlnJNaF1MXr0aADIEZfs27cPM2bMyLHZvm7denB5ArDYHMyZMzeXXVsHZ7i1noagEbshMziCJ5RkS1hYMJi52qt1Bjg2GA6P9rPB5QvRsnUbaP0qwb3DbAjkGgwbNizf9fWqVasgVhlgWaEd2AIJxHpH6IKjoNYacsSie/bswcSJEws8oVC1Ri3og2vBqdEoCCTy7DlnZmbi5cuXuHnzJuQqDdT2HpDIlbmKVhYn1naOsKnaFU6NRoEvFCMuLg7Hjx+HUKqEbY1eUNp5YvSYsXj9+jWs7Rwg1VhCplQXyafmrdpAH1IbPr1WQGHtgo0bNxbY/uDBgxDJ1bCt0Qtya1dM+aveTEZGBtasWYOFCxd+cdLajBkzoHTyh2eXhRAbnMHi8MDmCeHu5fufKp747t07XL58+YfYZykMpg1qEya+MUlJSWjVqhWICNWqVfvuq1P/l0hPT4entx807mFQ2nmgUdPmebZ7//497t69+8nFgE9ACFxaTERwdAykDgEQWXvCUKYF2FwBzp49C2dXd2j8KsOqYgdI5Ep079ELGs/ScGs7AzK9fS7pj/woX6kKLDgCsMQqWJZvm1WFmSfE3Llzs/9AZ2ZmommLVrAs95e2tV8lBAWHQKIyQKzUgcnhw6nxKHDkBpgzmOjSrQeuXLmCqLr1UbFyVQgkctjV6gu1SzB69OqDzZs3Y9GiRZ98frdu3QouXwhzCwbq1m8ItkACC44AZMYAkRk0egOECh0Utu5w9fBC9Vq1weCJsjdrBVJFLlmczMxM6K1sYIhsCsvSTWBlaw+j0YitW7dCrNLDtnpPSHW2OQpLZmZm4vbt23j79i2MRiPev3+fK4B99OgRLG3sYM5gwaf3CgRHx4AlUkJs4w0zCya8uiyCX981MGdxwWSxodLqwdfYw4IjgKFMC7C4AliWaYng6BgovSuAKxCDL5Jg0qTJkKh0CBqxJ7tI4v8SGxuL2bNnw9reCQZrOyxbtgzp6em4du0a9uzZg48fPyIzMxP+QcHgqe0QNGIPXFtOhs7KFkOHDgVTIEXAkK1waTERVnaOOWx36dYDatcQ2NbsA75YhkWLFuUKuMeNGwetX2UEjdgDQ0RDdO3Wo1DPHQB06NgJluXaZGUvlGuNnv9zRLVJ81awrto1O1tIbHCGfe0BECt1OTJNPnz4gO49e6N6rTr5FiH6r/LTTxOgdg2Fd/clUDkHFlmKxcTnY9qgNsXfJkx87yQkJKBevXogIrRr1870EvMr4BcYAkOpRrCr3R8CsRRv3779LDvx8fFo2aYdgsMjsfy33/Ds2bNvlqhUoUp1WJZuCs9O8yBWaHHq1CmMGzcOKu8Kf9UOaYwOnbsUaOPYsWMQimXQe4RCIlfmeTIxPzIzM3Mk9Ny5cwe+gcHQGqzRrEVLCMQyyPV2CAgOzZKwKNcKuuBa8A0IzmWLyxfCu8dSBAzZCr5YhrIVKsOmek+IbLwh0DlDpLFG2/Yd8/Sjddv22TJ8ulJNoQ6KyorZrRxx5swZAFnFJMUqPfShdSAUy/KVjXj9+jXqN2wC/+BwrF+/HkDW+tDN0xs8oRh6KxtcvnwZR44c+exn5vbt24WSebx69SqCw0rB3dsvO76ePXs2DEE1EBwdA4d6Q1Gxag1MnjwZOv/KCI6OgWXZVmjZum2hfalaIwo21XtkS3YuWrTok302bNiABo2bYfqMn7Of9eat2kBp6w6tZyk4u3kU+DsrMzMT7969y3e9nZqailZt20NvbQeJUgOnRqMQOGwnODIdIkqXKfTcfmQOHz4MoVgKqcYSXr7+P0y9s4IoKP42JxMmTBQ7XC6Xli5dSvPmzaPff/+dAgIC6NKlSyXtVoFcvHiR3Lx8yGBtR6tWrS5pd74aDx8+pEdPn5FV3RFkVW8kbdm0Mc92UqmU7O3tyczMrEB7dWvXpNd//EJP9i2g+EdXyKpyF9KXbkY8kZR4PB49fvyYdGXbkCakLpkxOHT95i3iWvuS0OBKHK0TPXr0KNtWfHw8nT17lj58+JBrHEuDgWSOAcTXOtKL4xso8fhSWrdmJXXt2pW4XC4REZmbm5NCJqOM+JeUnhhHGR/f0rmzZ8mh7WxybDuHMtJSiK93IeemY4nN5tDP06dS2QqV6OJHKd1MlpKAzyVXs4dU1s+B3rx5S7du36E2bdqQVCot8B70HTiEDNV7k0/vlbRv/0HKTE8jcyabLDhcYsu09Pb9B2pcpzolvHpI75Iy6Nq1a9SvZ1dimhO9Pbaa6kTVInt7+xw2zc3N6cihgxRpzaJIWw7N/nk6nT59mmrVqkVzpk2iYEkcTR49jFq0aEFERJmZmVSlei0KCIkgS2tbkijUJFcoiSMQ0aFDh7LtJicnU7/ePcnM3ILubvyJ7m6eSBnJHyj5w1sicwu6sqgrXZzdhlR+1SgjI50yZPbk0XEuWZVvSx8u76XFC+ZS4rW9dHNBe4q9eZxc2s8l67ojaPb8hWRmzKCXJzbSiz9XkIeXD6Wnp9PSpUtpzpw5RETUvXt3mjJhHCUmJlGHTl1IodJQUFgpat1jMPn4B1JiYiItXjCfzFLiKeHpDfr44By5urpQkyZNiMNikjEthTKSPxCbzaY3b95Q67btqUbtunTwj0Mk9atFKt/KJLXxJD6fTx4eHjnuJ5vNJmNqIsGYQRnJH+ja9WtUqmwFGj5iJGVkZOT73c74eSYtW7aUXp/fQ2+v/kFJt45QgL9f9vW2rZrTy0PL6dKcNpTw9BaBJSCBwZWEjiF08eLF7HbtOnSmTX9epuuwptr1GtD9+/cLfKb+S7x49YqYSlviyHTEVNjQy1evS9olEyZMmDDxncDn82n9+vU0fPhw+vXXX6lixYr09u3bknbrX8W2zRsoQAUyfLhEO7dtIblc/ll2RCIRLV/yC61a/isNGjyMnNw8ycsvgOLj44vZ49y8evWKeAY34qpsiSNR0evXr6ljx44kSHpCN+a2oox7R2nwgP4F2ggLC6OL58/QnLED6drli+To6Fjo8c3NzcnCwiL7/5u3akvvxO4krzaQtu/cTRvWrqIdG1bS8SOH6difh6iUwYxq+BkoZtf2XLbGjhlNd5b3oVsLO1LtqFo0cvgQevPnckp6dZ/c2s0gxxZTacVvy/P0o3LF8hR3bhs9O7qW3p7fRWlvHtCzwyspIyk+ez5rN24mZUQLMlTsRGKXMDpw4ECetpRKJW1Yt5rOnjxKDRo0ICKiX375hWItFOTRey2ZWQXTnHkLKCIi4rOemYGDh5JfUCj5h4RT3/4DCmzr7u5OJ4/9SVcvnqPKlSsTEVH58uUp/tZxevr7Inp79DeqX6cWiUQiyvj4ltKT4ik9/iVJxOJC+xM9bDC9P76a7i3pSoL0d9lzzo/Lly/TL8t+o8SkRKpWtQqZm2dtLW7etJEs6wwny9pD6fW7eLp7926e/Z8/f04Ozq6kM1iRp48/xcbG5mrDYrFo2a+L6enDe6TX6Sgt4R1lpiQQjJl09uzpQs/te2Tt2rXUuFkLmjd/PmXt2ebNiNHjSFm2HTl2WESvk81p+/bcPzP/KvLbuf7eP6YMDhM/CsePH4dOpwOXy8XKlcVfPKC4sHVwhm3N3nBrMx08obhQusg/IgkJCZDIlbCu0hmG8Abw9Cnc75L09HRMnTYdbdt3zKFJbTQasX79evz000+oUKkqVE7+0PpWhI29I1JSUtCoaXMo7b2h9S4LeycXxMTEQCCWQucWBLlKk62JdufOHchVGiitnKDU6HD//v0c47958waR5StBrtKge8/eud40p6en4969e9i6dSvYPCHMLJjw9PGHQCyBY8NoODQYDgsmCxy+CDyhGFOnTcezZ8/+Oma3G4FDt8Pc3OKvghcyWFfpCqWDL/oPHJzvPVmydCmkChWYHD5cW05CwOCtECu1cPPwghmTA89O8xAwZCssuEJY2tpDaOUBvs4ZYr0DfvvtN7x8+RL37t37ZJZ6l249IFHpIdFYomnzVnm22bNnD7hCKTgKK5CZOSSOQQgasRua4DpQa/U4ePAgzp49m1WY0rcCzJkcSB2DIbb1gTmLh4ChOyC294c5kw0LNg8MFhsMDg9clS08Os6FzC0CPXr1AZCVDbxt2zbwxTJ4dl4A68qd4RsYjCtXrqBRk+aIql0H9k6u4IllkNl6QesVCWc3Dxw/fhwcgQQ21XpAYOkGBk8M52bj4dF+NlgCCVRaAzZt2oT5CxbAzskVZStWxtOnT/H+/Xs0adocFgwm5CoNjh07hrDSZaELrgmbat3B4QshUukhtvYAm8fH3r17c92fhIQElC5bAWbm5rCxc4BUawOnRqOgtPfOtxJ8WloamCw2vHsuh2W5NmBwBJg8eUqO7ysmJgZChRZ8gwukzqHQhNUHgyOAQCTNcUTW3tkN7u1mZmX2u/iXuJ5mfHw8KlapDpFUjoZNmpVoRtqNGzcgVaigtnOHXKUptDSIiS+HTBnUpvjbhIkfiFWrVoHNZsPOzs5ULKwAsgpwz8S5c+ey/y0zMxO9+/aDla0DGjRq+lWzEFu1aQdDZLOsTFSvMpgxY8ZXG+tvNm7cCIFYCoWlI7x8/XHgwAFMnjwZx44dw71793LVpUlNTcXSpUuxYMGCL5Zhy4ssWY+pCBqxGworpxzycMePH4e3fxC8/YNw/PjxPPs/fPgQ169fz445b968Cb5QDLuofrAq1xqOLu75jr1p0yb06t0HW7ZswbDhI9CpS7ccBSJHjxkLpb0XbGv2hlCmwtGjRws9rxkzZkDtHo6g4bugC66F7j16Fbrv/5KUlAQGkwX/ARvgP2ADmGzOZz2Tly5dQtu2bSFXaqC3ssXGjRshV+lgzmCCyRVi8pQpnzbyP7x79w4XLlz4ZPHK9PR0yFUa2FTpAuuK7aGztM7+rvyDw6APrQPrKl0hlinylfno2bsP9KF1EDRiDzQ+5fHTTz/l2e5vjh07BgabBzMLBgQae5QuW6FIc/ue2LVrF8RKHWxr9ILM4IAFCxbm2zaqbgNYlmoMn94rIDPY51pDpaWl4dWrVz+UBFRB8XeJB7qf+zEFyCZ+JF6+fInIyEgQEXr06PFdHs8TSeXw6vYLAofthEih+WSl52+F0WjEmHHj4RMQgu69+hTLvbtw4QJq1K6HJs1bFlrTduDgoVDae8OqYgcIxNI8FwapqalYuHAhpk6dijdv3gDI+gO+bNkyzJo1K7uq9d27d7Fjxw68fv06u2+v3n2yi0Dow+ph4KD8N4b/Zv369fAPDkdU3fpwcnWHSKYCg82DQ/1h8O6+BHyRBGvXroWzmyekSjXEakvIrV0RFBqBzMxMZGZmIiA4DBrXYKgcvFGzdt0sLWq/8n9pUY9FcHhknmO/efMGXL4QHh3nQhvRGOYMJjh8ITx8/MDmCWDGYEHqGgG+1hFsqRYWHD6UvlXh0mISGFxhoaukp6SkgMFkwn/gJgQM2QozCwY8vHxzyY54+QZA4hQMuWc5MPgSiB2yNqhFtj5gcARQWrtAqdFDE1w36x5HNgdHIEa1GrXAkyhgKNsKAoMLfHuvhMKzHKQKNfgSBbThDcGWasAXy/HhwwfExMQgvFQkatWui2HDo6FQa+Hm5ZtD402tM8C+7iCYWWT5HTRiD8QKDUaPHg2NbyUER8fAscFwMPlSaIOjwBIpYRfVH64tJ4MnEOH9+/d4/PgxunXviXbtO0KmVEHj4AWRVJ59PFEklcOnV5ZEiVxvi7LlKkBi6Qp96WYQSmR4+PBhnvczMzMTo0aNgi4sq5indZWuaNaidZ5tMzIywOHx4dFxLry6LgaHy88uYvk3U6ZMgT60Niw4Avj1W4vg6BgIFXps2rQpR7sRI0dBpreHzr8yVBp9rgrv35oBgwZD41Mevr1XQuXkn+/zmJaWhkmTJqNVm3Y4fPjwV/Pn3bt3OHr0qEkO6htj2qA2xd8mTPxonDx5EhqNBiKRCLt37y5pd747/vjjDwgkchhCakEglmVvPq5cuRIKG1d4dpoHjWdpDCggAeNvDhw4gN59+2LdunVF2vzp0LkL9CG1EThsB9SuwZg7N7cu89fg4cOHOHbsGHbs2AGhVAFDWF0IxDIcOXIkV9tqNWtD5egHjXs4fPyDil2KZMrUqeAKxJDpbBEcVip7/ZaRkQGJTAH7uoNgX3cQJDJFgbV+/pdjx44hokx5VK5e84te5mdkZOCniZNQt0HjXPHqp0hISEBEZDmYmZvDzdMHL1++RHp6Ot68eVOkZyQ9PR08gQguLSbCteUk8AQipKWl4cOHD5gzZw4WLFiQZ7H7vOzwhSI4NxsPlxYTweHxIdPbIWjEbni0nw2dlW2R5ldY3r59CzaXj6DhuxA4dDssGMzsTe0XL16gReu2qFG7Hs6ePZuvjd59+0EfXDMrocirLCZOnPjJcW/cuIF2HTqi/4CBn118/XsgOjoa+ojGCI6OgU3VbmjQuClOnDiR58uix48fwzcwBEKxNFeS2tWrV6FQa8HlixAaEVmoZ+Z7wLRBbcLEd0BaWhr69u0LIkJ4eDieP39e0i7lYMrUaRBI5JBqrFC9Vu3v5i3c2rVrITM4wLnZeAhUlggODcPp06e/uR+BoaXg3HRclg6vb7kc2sefQ2pqKubNm4cJEybg5cuXGDduPNTu4fDptQIq1xBMyeeNt9FoxPPnz3Hx4kUIJHI4NRoFTUB1cKQa2NToBQs2Hx4d5iBwyDYIZSp06NQZ9Rs1BZPFgV+/tQgavgtCqTK7+nNiYiJmz56N8hUro2rN2li1alVWlnFYPcj0dtmFVv7Jo0ePwBdJETB4K7x7LAWHJ8DNmzfBZHNgV2cgPDsvBJmZgy1RI2jEbnBVttmVzWV23vkGhAkJCRg1egy69+yF27dvIzMzE1y+EP/H3lmHWVV9f3jP7e6+d7p7hikYcuju7g6RlJAYUFBCUVQkFAUUERWRkBKxAxQFFQxApSRE6Y657++Pq/NznCHF/N73eeZ5lLPrnHvuzNprr/VZMS1HE9fmnoDjOzqDu0eNKjZoL1++TIhEQu7Y1eQWrkWm1iNRaQmRypAo1KT0mkFu4VqUJidyvS1Q7MSbgNZs591332XCxPvQ6PRYU6oFNNtq9MAQmYFcpUGjN6HRGXjllVd49913kSk1OPOa4q7YBpvTU2aRTYVSReaQReh8iTiyGhBWswcWu5MtW7agM5pxlW+GXG/FYLLg8gYivtMHPUvO6JXoTFZ27tyJLzwSb8WWOLPqoTDYA0Uha/Wk0y9acj1798USGofJF4/T7SUhJYOkrg8FnO+pFa9pcH/xxRfoTRZ82XXQmaysX78eCDivFyxYwKhRo4ujn1944UU0OgMqjZY5TzzBu+++W2JT8NVXX6E3WdDYQzFEZuLObYLLE1rKkf2rfviMGTNKFcT8qykqKqJ8xcr4qgWKbXpyGnDfffeV2XbosOHYYzIJq90HndH8jzm4C3J7CDqog/Z3kCD/Rvbt2xcsnngV+t1xJ6E1egTs9WqdGTr0LgCmTp2KJ6dB4HC+Tl/atCu7Bs2vvPvuuwFHd0FXTK4w5s2bz4kTJ3j88cd5+umnrxkwc+jQIZJSMwiRSKheq+5f7jTq3fcOwmr1+iUgoxPDho8ocb2oqIgQiYSc0SvJLVyL1mi5rUWof43mNnki0BtNDBs+vNiZePr0aeQKJdmjlpM9ajlyhfK6Edzbt29nyZIl/Pjjj7dtjX+UX4vV7dq1C7c3FJVWT3Zefqko6CtXrrB06VIWLVpU6j1Yu3Yt7tBw3L4wVq1aRVFRERlZubhSKuFMyKVajdrXXcf58+f/PxJ7xFLkCiVag5mkrg8RVqMb2eXzb99N/wa/309BzTo4YtKxR6XQqGnzmx7j8OHDxCelIpXJycqtwMmTJ/+Elf4z+eCDD9AZLXgrtkJntqPW6nBEJODxhd1UFnvjEIhcnAABAABJREFUZi0Jr9WL3LGrcSbk/GH/xF9F0EEdJMg/iBdeeAGNRoPL5SrzRPvv5JtvvmHz5s1/WUGPsvD7/QwcMhSDyUJmTnmGDRuGp0Jz3BVbo/Um4Cvoit5ouaWT8ytXrnDgwIEynYrXY+L9k7CGxuGt1Aa96drznz59mi+++KKUk+63NG/VBkdcNu6sevjCIzl69CiNmrbAbLXTrGWbMo3Zy5cvU7NufTR6IxqtDltkCnnj1pHU7WGkKi3GqCxU9nAkciVao4WYhCQcieWJqD8AqVJDWK1exLQYhd5oLmEENG7WEndmLSIbDkJntPD6668zYcIEXnrppRKbni+//JJadRtQo3Y9PvvsM7p274nebEejN/LQw4/wxJNPIlVq0IenoTQ5Uaq1KNQ6kro+hDmxMlKVFmtkGmGR0cXpXnv27KFKQU1iE1N45plnadC4Gc6Uyvgqt8PqcHHixAkqVqmG0uJB44rGFFcBnSceiVSO0Wzlzjvv5LHHHiM1Mwt3Vj2cuU2QKjVY7S7eeOMNMrPz8BV0IbHLNKQqLZ7K7VE7IlA7o9AazMUFYDZu3IhUoUZhsCPTmkju+SgqjY7PPvuseK39+t+JCPl/R7hcqSkRBQ+BVDuL3YVEpkCpNRIVm0Crth3Yvn178fX77ruPdu3aIVVoCK3RHaXJhUKjx+wKo2mLVhw8eLC4wnnu2NUIEUJK75m4UiozesxYIBBZbnd5MESmo7aFojWYsUal4avW6ZoR1L+yY8cO5s6dy9atW4v/bdw992INS8BbqS1KjY64xFR69enHuXPnOHv2LPFJKcg1BkIkUipVKSg+IPjmm2+YMmUKjRo1pk/fvsWyNf9UHnpoOkZ3JFK1HqXRidXhKj4wPHXqFB27dCMuMZUBAwcGiqB2DBys+DIKWLRo0d+8+iC3k6CDOmh/Bwnyb+XMmTM0b94cIQQ9e/b8R2Zn/h08/fTTWHyxxLQYhdkbVSyvuG/fPmxON+64TPQmCxs3brzmOPfddx/eioFss8iGg2jZtj2Jqem4UqvgiCt3XYfc74sG/pUEnkEMUU2GYXKFFRf4+y3xSan4KrUmrGZ37C7PbX1/MnMqENuqEJUtFEe5+jjSCsitUKn4eofOXbF4IrB4ImjUtDlffPHFVQ9ZVq4MBG94UvKxOdy31ZF+O2jXsTOh1ToFooCTKjBnzhx+/vnn4kzBth06YY9IwhmfRV5+pWvusX/88UfUOkOx/S+RSIsd4dfiruEj0Jlt6C0OBgweyrx584mIiad8pSo3tF9evnw5ZpsDo9nKokXP3/C9X7x4kRdeeIElS5bc0t4aAvv+c+fO3VLffzsbN25k4sSJVKtek/DagQMlT3Zdpk0rW3qxLJq3aktoQWdyxryKIyb9X7NPCTqogwT5h7Ft2zZiY2ORyWQ8+uijwciH37B27Vos3igyBj2Lr3IbatSuh8FsRWW0k9j5gYCjKL0KL7744g2Nd/z4cWrXa4jF7sJgsaMxmImIjr3pCHa/38/ChQsZPWZMCW3d37Nr1y5sTjdWTyRuX9hVDSmt3lAsiWDxRLBt27brrmHVqlXYIxLJGbOKyIaDkCrUGMLTkGmMv4kgXoNcqeazzz4jKa0ciV2mkTduHbbIFIxWJzqTnbvuuquElEBYZAyJ3R7GV9AVrcXF4sWLOXPmDHv37i1+N/1+P063j4g6fYmodwdWh4vLly+zc+fOYodkWrlc4jvcT964deh8iYwcOZLqNWsh11nQhaVg8MbRq1evEs7xCpWqElqtI4mdH0BntGAwWckYvLC44vYnn3zCww8/jFJrxJpSDYlMgVSpIbXvHGRqQyBK22Alr0JF7ho2nH533Mnrr79eHMGwcOFCFDoTSpMLmdZMZMNBqEwO7E438+bNB2D37t2MHz8ehUqNPiIThcmFyuKmSfOWJZ7/vHnzUOhMGKOzMcXmERYZw5YtW3jkkUeoVlATmVyB1mghsv4AMgYuQGuylXAA/xaNVl9cWTyq6TCc3jA++uijYumVhORU3Jk1caZUxh0ajjc8ipat2xXf1+zZs5EoVCR2nUbmkEWEyBTojSYGDBrMW2+9xebNm695QFIW5XLzSeg4mbxx6zDFZOOp1A5nYnnGjC1kzZo1qEx2PJXakjV8CRpHBC+//DIQcOpGxyXgjElHb7Ly3HO3zzj66aef2Lx58201Xpu2bE1U46FkjViKI606EydOLL7Wq08/DKEJyDRGVFYvdpcXszcGT34rDGYru3fvvm3rCPL3E3RQB+3vIEH+zRQVFTFmzBiEEFStWrVYXu5/Gb/fz0MPTadOg8Y8+tiMEnuso0eP8vrrr9+Qk/Odd95Bb7YRWrMHZncEU6ZMRW9xkFu4luy7lyGTK8rsV1RURKeu3ZFKZYRGRJWQgPuVK1euXFfj94/g9/uZ8fjjNGneiiefnFvmPnP//v107NKNlm3al7nGsti6dSsp6eUIi4q95j6sUdMWuLLqI9MYyRu3jpwxqwiRSIod9n6/n3feeYcOnTqjM9kwWF1079m7zLFq1WtIdLMRgWjwcrWYPXv2Da31r6Jjl274KrcpjmBt0qw5Ko0OlUbLtIceRiqVkX33MnIL16A1Wq4ZxHH58mXc3jBCq3XEV7ElsQlJN7yOr7/++oY/x99y5coVNFo9Sd0eJqXX46g0upvePwT5YwwaPBR3Zi3SB8zHHpXKggULbrjvd999R3hUDBKJlPqNmt7QgcY/gaCDOkiQfyAnTpygcePGCCFo37598I/BLyxevBhXQg6Zd72A2hGBRCqjVp36NGrSFEtYIt4q7dGbLDfsKLpz4ODAL/0756FxRRPddDievMal0t3+COfPn2fr1q2079QFk9VRrCXtyWtM4bhxZfapWr0W7sxahBZ0wWJ3curUqevO8/rrr2PxRpE98hUi6vZDrjEQ3XwUMW3GI1WoCa3SntBqnfCEhnPlyhXunTARiy8Gb14jFBo93grNiW83AYlCjUKlZs4TgYIMw0eOQqbSIlGoUBgdmK129CYLWqOFqtVrcenSJc6dO4dUJidn9EpyxqxCoVLzzjvv0K5jZ4bcNYyTJ0/StEVrvHmNSOw8FYPFwSeffMLhw4dxuH2IEAkyhYpnnnmG8ffcw/Tp0zl//jy+iGiSez5GbuFabGFxVK1eE0dCHp4KzXC4vOzcuROD2Yo9sw46exj5lapg8UbhqdQWQ2Qm2aOWY8+oQ4hURlFREZ999hlvv/128Un+5s2bMdjcpA98BmtKATaXj6efnldsrB86dAizzYE3tyEGZzhqnQGn28tjjz1WKvLF7/czafIU4hOTadykKYsXL0ZrNOPOqodUqSG+3UQUehsJnaaQM2YVVm/UVbMkNAYTMrUeX0FXFEYHIVI5kTHxxVptR48eZdKkSUybNq1E6qPf72fRokVoDGZceU2RqQ2YkyojUWiQSKVUKaiJUqPD6o3C6fEVS7ncCMOGj8QenU5ozR5IlRrS7phLRP0BtGjTni1btqDQGIioPyCgqR2RVpxG9sorr+CKzw7olre/j7Ryudec59VXXyUyNp7ElHQ++uijq7bbtGkTepMFW2gMEdGx/Pzzz5w5c4bRY8bSpVsPtmzZcsP39lsWLnwOo90TSKszmkuMU7l6LRQGO8k9Hg3cpyuCwsJCxo0bVxwFH+S/Q9BBHbS/gwT5L/C/Vjzx559/ZtOmTX9Kcb/f8tprr3FH/wEsWrSIs2fPYnO4CavRHW+FZqRlZpfZZ+3atVhDY8ge+QrhtXtTvVbdEtfXrFmDVm9AJlcwemzZe4R/KuFRsUQ2HERil2lo9MZSWYQ//fQTZ8+e5dChQ1StUQu5Soszuz6u9BolIqgh4IyVyRWUu+sFsu9ehkqjK/OApf+AQbjSqpLQaSoKvZX4pBT27t37p97nzbB3716iYuORSGVUrlYDhVJN5tDnyRi0ELlCSVRsAqEFnYioPwCz1X7dgItvv/2Wjl260a1Hr78kWvzSpUvIFAoyhyyi3LAXUao0/ympjQ8//JBx48axatWqv3spV+XEiRPUqd8Qm9NN9569bzrzwu/3/2sc078SdFAHCfIPpaioiPvuu4+QkBDS0tL+UMGH/wpnzpwhNaMcKr0Ze0btQJRjXDazZ8/mySefZNjwEXz22Wcl+nz33XckJKehVGvo1adfiUiBlm3aE16nb6CYXEoBYbV6Yk/KJzWjHJ26dmfLli1/KK3thx9+wBMajkpvxhidhT2zLuaEfMrd9QKOxPI8/PDDZfY7fvw4Q4cNp1uPXmWeeB8+fJh33nmnROVjv99Ptx69kEpl2BwuZEoNcp0FlcVDQnIqHTp3pV3HzsXvkd/vZ/r06dSsWROzzU5S9+nkjVuH1htPZOO7UGt0xdrACqODjEHP4qnUFplKR3TT4eSOXY09KoXly5cDYLQ60Tij0Lhi0BjM6E0Wwmr1wp1Rg7oNGvHTTz/RqGkLElIyip3f33zzDTqzjXLDXiK29XhkSg2e3EY4EsvToHEzZjz+OHqzHUdkMulZOZw8eZKHHnqI0aPHsGfPHtauXYsnMeD8TOn1OJGxCbRp3xGJRIo1pSBQIb1ia6wON/dPnoLB4sAWGkvVgprFf+DHjB2HVm8gOi6xlJPx6aefxhiZHpBK6TqNxNSM637mR48eJSElDYVah0xrImPQs4TW6I4zt0mgSKNSjd7ioE69hlc1MpxuHyEyBUIiI0QqI6HzA7jzWyGRq8oskPnDDz+wfv16cvLykau0/6+vWL0rErkKld6MTKnBVb45hsgMHFn1saZUQ6nWMGHChGIpk2tx+fJlpj30MG3atUdnMOFNrYTOaKZa9ZqkZ+VRq3YdpHIVCq2R5LTM4mjujz/+GIPVSVLXh/BWaEajpi2uOsd7772HUqUhru0EopsOx+n2XrVto2Ytiah/Z+CwJ6OAWbNm0bxVW1ypVQir2QOD2crhw4eve1+/58cff6RcTnlMNif97xxY4tqSJUuQq/X4qnUiqetDJWRggvz3CDqog/Z3kCD/FTZt2oTT6fzPF0/csmULNoOBVLOFCJfrL63p89VXX9G2Qye69+x9VZ3Y5cuXY49KIXfsaqKa3EV+lYIS113eUBI7T6XcsBcDcm4VKmEwW+nSrcdNO6Z++uknvvnmm6vKRnz66afUqtuAxs1aXjdg4aWXXqJGnfoMHnrXVZ2oOoOJ9AHzyRmzCr3FwY4dO4DAfqNr956oNDo0On2xM/DQoUPcPWo048ffU2I/82sfo9lKXJvxvxQJ1JcZrHXmzBnqN2qCXGPEnd+K0CrtqVWvYal2GzZswB0ajtXh4vnnF1/zXiGwB3/ttdd49dVXb1me4rf3cuHCBc6ePYtKrSWt35Ok9J6JSqNlx44dNG7Wklp1G/Dpp5/+oXn+LO6fNAW1zoBGb+Tu0WP/7uXcNjZu3BjQea7UFqPdc1PyJUH+XIIO6iBB/uGsW7cOi8WCyWT6R5/w/VVcunSJhk2aEVrQJeCAzKjBQw89dNX29Ro1IbSgM+XuegFraAxr1qzh8uXLrF27llmzZqE3WbCHx6PU6BBCoNToCK3aAXd+S6QKFXaj8ZYLL44ePQZP+SbY0msRXvcOske+gtrqRanW0KhpixsqjHLlypUSTvLNmzdjMFtxRqfgdPuKT9C/++47Vq1axYEDBzBb7cg0RkJr9cJXvStOj69UCt++fftQaXS4KrRAYw9HoTGg9cajsoXiq94NlVoTKMgXFoHOl0hu4Vqim41AptYTXrsXWSOWYvVF89prr3HhwgVCQiTEtBpLTMsxKJRq7OHx5I1bR/qd87A53WXe25dffonB4iBr5FKiGg9BobeSN25dwDDX6YGALvP69es5f/48ly9fZsWKFTz55JN8//33HDp0CKPFhrdyW+wxmfTuewd79uxh3bp1hEVGo9SZ0BpMbN68GZPVTnr/p8kduxqTw8sXX3xx1We+fv167ug/gPTMLKRKDRENBmCMzqJGrTrX/bymTJmCK6MGuYVrcZVvgSk2F5XVi1SlRapQM2rUqBIbhoMHD7Jt2zaKiorYuHEjy5cvJ7dCJXzVOmFNr4PC5MRbrTO+6l0xRmcjlStKRNS/9dZbKNU61LYwJHIVQiJFaXIR2WgIBoePdu3a0bdvX6RKLfrQZKQqHUqrF5UtFKlKhyOtOnqThS+//JJPPvmEsMgYdAYTD04r/Z367rvvePjhh3nmmWdYsmQJ9Rs1xp1Vh/gO92OwOHj77bf59ttvuXLlCpcvX+bBaQ/RrUcvBg0eTExCMnUaNCrTafzSSy9hsjqQawyobaHoQ5PJHPwccoXiqhJH3Xv2xpPTgIyBC7CFJ/LCCy/gDo0g7Y655I1bhysmjbfffvu6n9fvadm6Hd7yTUjpOQOTw8c777xT4vrq1auJT0olLCq2WAYmyH+ToIM6aH8HCfJfYt++fWRkZCCRSJg+ffp/UkKwW7t2jDUY+cHjo73RxAMPlF3M++/i4sWLFNSsg0Zvwmi2ltK6dri9JHV9iKzhS1Codbiz6pExeCH2qFQWLlx4w/O88soraPVG9BYHtes2KOXcPnfuHGarnYj6Awgr6Ex0XOJVx/r444/Rm+3ENL8bZ1I+d/zu8P5X7p88Bb3ZjsUdQf1GTfH7/cWBLnqrk+y7l5PQcTJhUbHXXPvatWupVrMOdeo1IDQyBl94FCtWrLhq+5UrV+KMSSe3cC1xbe8lLSuX/fv3U6dBI9KyclmyZAlGs5X49veR3ONR1FodJ0+eZO/evaxevbpMu7RT1+5YfTHYI5KoXbfBbfuuDB06FJlMjlKt4YUXbkyO8q9k586dDB4ylEmTJpc4iDh48CD79+//G1d2fb7//ntWrFhxw0UEf68j3/o6hVGD/HUEHdRBgvwL+P7778nIyEAIwfjx4//WQoX/BL7++musDhdGu4fouAR+/vnnq7atVK0GUU2GkVu4BmdcJi+++CJ16jfEHp6AxRtF+46d2bhxI6dPn+bIkSMo1VpyC9eQO3Y10hAJk40malWseNXxFy1aRLcevcosMjJlyhScyZWIbzcRqUKNNSodi915wxIkq1evLk71G3/PBADad+xSXH3bk9OAqVOn8sYbb6AzmvEk5mB1uFAo1UjkKnLHriZnzKuESKRkZOWW0LIeMWIEhoj/jw6WqrSYbQ6kcgUKvRV3Zk0MJjPW0Di0nniUJhcSuZLp06cTHh2LVCane8/exUZbZnYe7oyauLPrEROfgMsbiie7HvaoVJq1aElUbAJqrb7E6bvf76dz127IlWrUWh1Giw1f5Xa40qtTULNkdWq/30+deg3Ru6NRWbzI1TomTZnKl19+ybDhI3jssceoU68BIkRCiERGVGws27Zt48KFC5w+fRqHy4M5oSJxbe9Fqzdx8OBB5jzxBDEJydSsU58NGzZQoVJV4pJSUesMhNbsgdrsxhBVDmtKAWqbj+HDh/PQQw9x//3306BxU5q2aF0qwv3hhx/GEpcbiDDPrIdEqUHjSSDtznm406uXiJp//vnFaPUmDDY3dqcblcGKLSqVuMRkMnPyUOmM6EOTsWfWQSJXEtt6HFK5okSkSUZ2HpENBwX0ypOrIdOaEFIZLl8Ec+c+hd/vZ8yYMdgz65A3bh1htXsjkauQaQyobGGk9J6Jt0IzJk+eTFxSKlFNhpF+5zx0JmuJ6OB9+/Zhstrx5jbE7Apj+vRHycguT2jNniT3eBR3UoUSmoPDR47CHpNOWK1e6Izmq2rf/fzzz2h0BuQ6C6l955A5ZBEKnQWNwczIUWOu+t344YcfSE7PRGc007Z9Jy5evEivPv2wR6XiyWuMzekuoaV+o+TmVyG2dWHg+5VcgcWLrx9pE+S/SdBBHbS/gwT5r3HmzBmaNWuGEIJevXrdcpag3+9n5cqVPP744xw4cOA2r/LWGT54MM2NJj5wuMg1Gpk3b97fso4lS5aQkJJOparVS2XA+v1+Dhw4UGYk8rJly1Br9ShUauKSUgiv0ydgj2TW5NFHHy1zrj179tCoaQuqVK/F+++/D0B0fBIJHSeTO3Z1mZJy+/btQ2u0kFu4huy7lyGVyq7qhF2wYAG+zOrkjVtHXNt7qVC5oMx2EAg82bRpU3ERyLoNGqE12ZDIFEQ1GUZs63HY3aWDZn5l9+7d6IxmopuPxJNdn/qNml51rl85d+4caZlZWH3RaA0mli1bRn6VAkIrtyW+3QR0RjMyuYLMwc+RNXIpKq2edevWoTdZ8CTmYLLa2bVrV/F4V65cKdaGzhmzCrXOcMNOz2vx8ssvY7C68FZui85kLRUA8Xdz/PhxLHYn3kptcCZWoEXrtn/3km6YDz/8EL3Rgje5fKnP82q8/vrrGKxOIur1x+KLYeasWX/BSoPcCEEHdZAg/xLOnTtHly5dEEJQv379W3K+/Bc4evQos2bNYsGCBXz99dfX1VV6//33MZgsGKxOcspX5Pvvv0ejN5IzZhVZI5cilcpKFObIzsvHnlAeY3gaORo99xrN1K9atcyxFy9ejMkZSnjdfhjtnlIn/GfPnqV2vYao1FrKV6zEiy++yI8//njD9+pwe0ns/ADl7noBjcHEnj17uGvYCFxpBaTdMRd7ZAoLFiygUdMWxU5Kb1Zd4hMSUeot6LzxaFzR6MNSiKh/J1GxCcVjjxs3DolcRVjNnuhCk7GkFOCu0AKjzUVCp6nkjVuHI7YccrWO+A6TsGXUJiu3QnH/3xuXx48f55577mXs2EKOHDnCwYMHeeCBB5g/fz45FSoRUe8OMgYvxGj38PHHH+P3++nYpRsavRG1Vs+TTz7J888/T9fuPRk1ekwpjbMjR46g0ujIGbOK7FHLERIpcoWSY8eO0aFzV1IyspEq1Mi0JpRmDyESGVKZAofLg8MTij0pH3NsDmq9iRdffJHZs2cjVWpJ7DINT4UWqHQGIur3J6blGKQKNdl3Lyeq8VCkSi0qixeJXIlSb0Hjikai1OCu2JrQ6t2QKtQlMhvOnDmDyeZChISg9cRhiMwkRKZEZXISFhldQpMvPCqWxC7TCKvdG6lSS0zL0SR1n47JE8UHH3yAXKUhc8gi8satQ2GwI2RyouOTeeONN4rHyC2fjzWlgNS+c1A7IlGa3YgQSYkI8WeeeQZreCKpfedgT6qIVK4kts14IhsOQq6zYHKFsXLlSty+cGLbjMcYk4NcbWD8+PHFYyxcuBBfRkGxlnRWXkWy8yqgMDqQ6wKa5Js2bSquTJ5dvlJxUUxfZvWrRv5899136ExWdL5EzImVkCo1SJVaqhTUvOoGpqioiIpVCrCExiFVqFDqTCSlpnPs2DGeeuopJk6ceMsahCtWrEBnNOOMTiEyJo4TJ05w8eJFjh8/fkvjBfn3EnRQB+3vIEH+ixQVFTF69GiEEFSrVu2aQR5XY+L48cQbDLQyW/DZ7Tc9xunTp6lbtSpKmYwa+fm3Tdf25MmTNKldG4/FQp+uXW9aFuN2sH//frQGEwkdJxFWoxvpWTk31f/ChQucOnWKTz/9FKPFhs0XTXhUzFWLXCanZRJatQNRTe7CYLJw4sQJMrPziKh/JxkDn8FgdZaSPywqKiIvvzLO+CzsEUm0aX/16NH9+/djtjnwZdXBaPcUy/Rdj/fffx+LJ5KcMatI6DgZiUKNVKVD7/Axe/acMvts2LABZ0xasXSf2e66oYKRFy9eZOPGjcVFBj1hkaT0nlVcw6ZX775oDCZ0Zht977iTLt16EFazJ3nj1uHObULDhg154IEHOHLkCH6/H09oOBF1+xHVZBgGk4VqNWojlcnJrVCp2M69WTp360F43TsCe7Uq7Rk79p8ll7Fp0yYcEQnkjVtHxsAFWB2u2zr+Tz/9xKeffvqnFADt2KUbYbV/Ocwp36xEgfNrsXTpUjp07sqcOU/8JzNK/q0EHdRBgvyL8Pv9zJo1C7lcTlRUVCmD47/O+fPniYqNx51eDXtk8lWrOv+ekydPsnPnTq5cucK5c+cwmCxENx9JRP3+eELDS7Q9c+YMjz/+OOWzspCGhBDucl21AFqffv2Lo5l9BV24a9hwIJCeNnjoUJYtW3bD93bx4sVSGmxWh4uk7tPJGr4ErdHC999/z6lTp2jcrCU2pwedyYpKo6NCpSq40qqR3ONRLN5oXnrpJV566SW6d++OUqsne9QKMgY+g1qrLx77hx9+QKMzIFFqUJhcZI9+lfj292FxuHGmVCa66XDUehMqvRm1IwKVLZSMrNxb+gOemJpBfLsJ5I5djS00ljfeeIMvvvgCg9VFxuCFJHSagkypwRmdisFsLfO9vnjxIkazlajGQwmr84tkhcFEzTr1sKUUENfmHqRKDca4PORaM1kjXiap6zTkeitadywR9fuTW7gGuULJqVOnsNgcaL0J5BauJaHTVESIhKwRL5MzZhVShRpXhVaoTE5sGXVw5jYjRKZAH5aCI6sBcoOdxC4Pkjt29S9a0dISkbZvvPEGWoMJjc2HRKEiRCLFaLGVimDJyMolot4dGKOzkettAee6yYVMqWX37t2o9SYsyVXxVu2ERK7CEJpIVJNh6IyW4lS7OXPmIFNqkCjUSBQarGk1scZkldB6Lioqov+AQXjDo6jfqAlqnZGcMa+SNXwJIRIJj8+cCcBzzy1Crg7IviR2eRCdyVpcUOmzzz5Db7YR1XgozsTydO3eE7XWQM7olcXj6K1OdAYT69evZ8J992MNjcNbqQ16k+Wq+oZ+v5+mLVphsLmRyFWk9JpBzuiVGKxX/97t2bMHncmKNbU6oTV6BKR+Uqsw6zZFP3z33Xe88cYbnDlz5pfsBBMKlYZOXbsHDdj/IYIO6qD9HSTIf5nnnnsOpVJJdHT0VbOcrkZadDQrbHZ+8PioYrPdtAThpPvvp4HRxA6Xh2ZGI+MLC2+q/z+ZTz75BIs7gtzCNaT1e/KqMnfX48CBAySlpCORymjSvMVVA3LUGh3lhi4OFG+2ufnmm2/44osviIpNQGswMv7eCWX2O3/+PIsWLWLp0qXXdORfvHiRF154gcLCQt58880bXv9nn32GwRKoYRPZYCBKk4vcwrVE1OtPxy7dyuxz6tQpvGERmKKzUZpcaO1htOvY+Ybn/JUpUx/AaHfjjM0gOS2D8+fPs2fPHnbu3Inf72f8Pfdij8/BllYTmVqPKSIVT1YdwqNiuHDhAtu3b6dKQU3yKlZh4MCBOJPyyRz6PAZfPNVr1Cius3IzPP30PMyeSCLq9cdgc7N69epSbc6dO8fKlSv54IMPbnr8P8qJEyewOlx4K7bCkZBHqzbt2b17N7369mPAwME3FWD1K889t4ja9RvRqUtX9CYLVm8ksQlJJfa727dvp22HTvTo1eeqhzDXY/w99+JMLE9S9+lYwxJuSA7ntddew2AyI1couH/SlBue69y5c8yZM4fZs2eXqYse5I8TdFAHCfIv5MMPP8Tj8aBWq29Kk+zfzpYtW7B6IwOnu4MWYjBbb2mc9957j+zyFalYpaBEpKnf7+fdd98tjvC9dOnSNaM4V65cicHqxFu1A3qznfXr17N+/Xr0FkdAM9juKVP64/e8/vrr6AxGFEo1XXv0Kp5zyZIlv6T6aRgwcBBPPfUUjz76KAcPHiQhJZ2oJneR0mcWCpWGxOQUouISKBx/T3H/oqIiouMSURidyNQGpAp1iQruP/30E3373YHWYMboiUZntFBYWIhCo0NtdqFQqXHElSO3cC2eSm2RKjUMGjK0xNqXL19OUlomlapVL06pKioq4v333+ejjz7C7/f/IlUS0MKrXqsuly9fZseOHSjUOiQKVcC5KlPgyG6Ir3pXunbvWWKOCffdj9FiIyI6DqPFjlxnwZnbBKVah0ylI6HTFPLGrUMXmoRUbUCmNlDurhdI6DQFpcmFO78l+tAkfBVbEhkTh9/vx+HxobL60PkSkSo1qHQGTK4wrGFxpKaXY8CgQYwcORKN3ohUoUaq1BLbaizWlGpIFGrUjkh0YcnofEkk95qJWqsv8a4cPHiQZ555Bp3ZQbmhiwOfVXq5Eve1bds24pJSUWn1CImEckMXkzN6JQqNjv3799P3jjtRm+yo7eGEyBXIdGZ8BV1wRCXzzjvv8NiMxzE5fLjSCgiRyZHrLL9oeL9U4jDit/j9fqrVqI3S7EKht6HQ6IpTQgEiYuJJ6voQuYVrcUSlsH79+uJrq1atolHTFtw9egzHjh1DazAS1+YeopoMQ6pUkzNmFVFNhuHwhNK1e0+mTJnC2LFjr6n3/ev7snnzZrxhkcS0GEV6/6dR6wxXlcI5c+ZMICsiMhNnbhOyRi7FEZPBggULrjnPrRCXmEJYrd4YIjJQaI1/yhz/BdavX098chqpmdm3rNn/TyPooA7a30GC/NfZuHFjcfHEdevW3XC/zq1b08Ro4iGTGatWe0Mp9b9l7OjRdPlFK7q3wciwIUNudun/OO6fPAWz1UFiSjqpGeWwRyRisDqZPGXqLY3XsUs3fPktyR75CvbodJ599tky2/Xq0w9raAyu+CzK5eT94aJ+v+XSpUvk5VfG5ApHqdUzceL9N9X/ngkT0ej0uH1hqHUGvBVbYrA4eOWVV67aZ/Xq1RjsHuLb30da/6dxuH23tPZNmzaxYsWKMp2I58+fJzI2AXN8BSQKFeXueiEglecOKxUcMXHiRFzl6gQy/eLKY4nNIb9ytZtej9/v56mnnqZjl25l7g0vXbpERlYuzph0TA4v91zlYOHP5Ntvv2X4iJE8+OCDnD59Go8vDF/lNnhyG5GacXN/39955x0MNhfRzUeiMjmJbDQ4sJ9MrcTTTz8NBDIp9EYzUpWWEKkcq9NzS1kP58+fp1vP3sQlpzF85KgbkkJ1uL0kdJxM5pBFaPTG4uj761GpanWciXm4kiqQl185GLjyJxB0UAcJ8i/l8OHDVKlSBSEEAwYMuGUduX8Tx44dw2C2El7vDjy5jahY9eo6aDeL3+8nKTUj4IxU6ahbv0GZ7Xbv3k10fCISiZRmLVuzatUqRo0ezYYNGwC4++5ReKt2JG/cOsLr9C0zyruoqIjTp08Xz+vwhBLX9l6y716OyeFj8+bNQOA0+4cffmDRokXIlQEnrtYZgcPlxRsWSVTzUSgMNswJ+diT8ilfsUqpuUx2N77qXUnu9ThaTxydO3dm3759JQyAAwcOULtuPfIqVqZm7TrFUeGunEYBXWqlBqlKh8YVg0SmYNq0aaxatYoWrduiUGmIbT2esJrdSckIOGCbt2iN3u5FbbLT8hcNs6NHj7Jz585io+HLL79EpTeTPfIVErs8iFxvRedLwOCLo2ev3sydO5ft27fz1ltvYbA6Sb9zHuF1+qLWm0ns8iB549ZhjCpHiEyBQm/DFFcBqUJN6zZtsTo9SKQyQqRyLKGxGM1WWrZuQ8/efYojj5cvX06IVI4IkaFxx+JMLE+HDh1Qa3TorS50Jiu+8CimTJlKaERksV53QqepqPRmYmLjEBIp6QMWkHbHXJRqTSmD6MMPP8TsDie552OY4vIwWR0lChz+9t0zWe1ENx1OQsdJaHQGTp48SVFREbVq1UYiV5Ix6FkyBi5AIlcSFhnN6dOnSc/KI6HjJPLGrcMQlYlMY8RTuR325MpUqlr9qu96YWEh1qTKJHV7mNBavenUtXvxtSeefBK92YYzOpWk1PQSGom7d++mXsPGlK9UlQ0bNvD666+TkJJOTHwSequTzMHPoXZEYEupRmhBFyx2J6dOneLJuXOpVrMuffrdwaRJk3jllVfKNOjmz5+PVKFGolCh1OivuVn+4IMPyM7Lx2CxI5XJadq81XXlfm6FhOQ0ZGoDkQ0HEdlwEEaz9X++BsDvOXv2bOCwou29RDUdht3l+U8Y7EEHddD+DhLkf4G9e/eSnp6ORCLhkUceuaHf36dOnWJI//40r1u3xEH2jXLw4EFifD58ej0RLvcNO4duhUOHDjFmzFgmTJh426REfs/WrVsxWByk9X+K8Nq9yClfkfXr1/Ppp5/e8pjNW7UlvFavQNHtlIrMmVO2LIbf72fVqlUsXry4TF3rm+WDDz7gvvvu480332TTpk3ozA7kWjOmmFykCjUHDx68Zv9z586xY8eOUlIOH330Effff38JmbqyOHr0aEBSpEp7nIkVaNWm/R++p7KIikskuedjGKLKYUurQWhBZyx2Z/H+7FeOHDlCWGQ0EpmC3MK1gRpFMvkfftbHjx+nR68+VK9dj7Vr17J582YsnkhyC9eSdsfcG4q8/+6773j77bdvy+f+e55++mlkKi25hWvJGbOKEImklPP49OnTV/198fjjj+PLqR/Yo0Rm4MxpRMbAZ7CGxhUfUHz11VcotEaiGg8lZ/RKlGY3r7322m2/l7Iw2xwk93yMrBFL0Rqvnun5W86cOYNMriB37GpyC9egUGlKZT8H+eMEHdRBgvyLuXTpEkOGDEEIQcWKFa9rNPwX+Pjjj2nSvCXde/Yuoef7R9m0aRMhEinlhi4ma+RSJDJFmZp6LVq3I7RqB7JHLccelcrixYvx+/089PAjVKhcQMtWbdBbnYTV7InR4S1VZG3btm347HZUMhnN6tVjzpwnkKn1OHMaE9NqLGqjjY8++oiZM2eh0mhRabQYLHYSOz9A9t3LUBjs2MITGDVqFCEyZaAY4i8Gk0QqK2UQRscl4qncjrQ75iLTGNEZzGiNFlLTyxUb6g0aN8ORWo2wWr1RanTYojNI7vEotogkWrVqFXCK1uyJ0upDpjXhTK2GRK7EW6UDxuhsbOm1iG46HKXWSF5+ZUSIFIlMibegK0KE0L17d7Zs2VJiXYsWLUKm0lLurheIbzcBldWLLa0GEZGBSG5fVp2AprRcgcriIXfsahI6TkKm1qN1RuGp1AapSkdorV6ESBXI1Vrik1LxhUdRu15DDhw4wP79+1m7dm2ZFbpPnDiBSqPHVb4ZxqgslHoLKRlZRDUdRm7hWvShyfgKuqAxWlCoVEjkSkwxOWjNDiZNnkxRUREDBw9BoVSjVGuY+9RTpeYoKiqiTv2GSGQKfNW7YkmsSO16/3/w4ff7GTbibjQ6PaHhUcTEJxEZG8/KlSuL2yhUgQOThI6TCK/bD5vTU/xeduneE1daVWJajEKq1CBESOAwQabAZLEVH3T8lnPnzhEWEYXKFkpil2lYYzK57/5Jpd7R1157rZTBm5aZTWi1jsS0GI3OaC5OxfP7/QwdNhyNTo9UrqTc0MXkjVuH1RPJ7NmzMTl8xLYai86bgFxnQWdxMvWBB0utrbCwEG+lNoHDnbr96NytR6k2fzWvvfYaIRIZOaNXkjN6JXKFstTm5a/g66+/ZuHChaWKLf0TOHz4cAm5F6lM/rfoft5ugg7qoP0dJMj/CqdPn6Zp06YIIejdu/efcuD7ey5evMi3335bbLf+GX83Ll++TGRMHJ7chrjSC8oM5LgdvPXWW9hCYwO2aqcpxCQk/+Ext23bhsXuRG9xkJperswAh9vNO++8g85kxVuxFXqLg6eeegq5xkBMi9GBCOPEfObOnXvV/t9++y0OlxeTw0tYZHSZ9veN8PXXXzNg0GAmTZrM+fPnb/V2rsnoMYVYfTG4M2qg1htp067DVaVuzp8/j8cXjq9SG7z5LYiJT7yhg5xDhw6RX6UAm8vDsBF3l+jTtEVr3OVqE91sBDqThffffx+dwUxcm3vwVe2ALzyKl1566arzPPvssyjUWtRGOxFRMbfVNv3qq6/QGi0ozW4syVUwx2RTtXqt4usXLlygoGYd5AolntDwMjModu3ahcFsxZdTH53FTmxiMiaLnX79BxQHely4cAGNwUxkoyHkjFqB1ua7pQOvW+H55xej0uhQqrXcOXDwDfXx+/2ERUbjq9yW0Kod8IZFBINW/gSCDuogQf4DLF68GI1Gg8vlKqVz+2/D7/dz6tSpvzwCb/v27UhkCuLb30dSt4eRyBRlaow1aNKM8Lp9yS1cgyshlwULFrB06VLM7gji2t6LPSaTTp07c0f/AWWmcDWqWZN7jWa+d3vJMpmpWLkqMo0RY1Q55HobUqWGzOw85Aol6QPmU+6uF5AqNcS1GU+5u15ApjGi0Rn54IMP0BqtqCxeXBVa4shqQHxSaqn5vvnmGxyeUOQqLS5fOGHVuwbkG5LyUWt1aPUG1HojMrUemdaE1uKmdt36xCamULWgOhqDBWNUFnnj1qFxxxLfbiJ549ZhiskhutkIUnrPRKbSIZEpiWo8FHtGHfQRaWQMWhiIbjY68VRsg95o4fPPP+f777/n/PnzmK12zElVECFSQqRyjA4fbl8YHTt3JbRmj0Chi8rtcVVoicriQa41IVVqiW45GoXWhEyuRG1x4SvoilZvYsqUKZicoSR0morS6ESuUNGoSZOrGg4fffQRtrC4X4qBPINcpUFrtOCt3J7MIYtQ28KIazcBjT0cb9XOJHWfjkprQKc3olRrqVq9FhcuXODkyZPX1KLr268fKquvuOiI1mAqvvb+++9jcvrIHPwc4bV6UaFSVV566SXWr19f/P67fWE4c5ugsvqQqbQldOnOnDlDv/4D0FscOHMaEdNiFCqrj5zRK4lsNIQKZaQgvvLKKzhi0vFW7YjaHo7DE3rV7IsDBw7w1VdfFa9FbzSTMehZcgvXotBZ8IVH8tFHH5Xo06J1W+xxWbiz6uELj2Ty5Mn4yjchb9w6ohoPRReWgkxtICkts9R8L7/8MmZ3ODEtR2OLSOLRx2Zc9bn+lTRt0QpbWBy2sHiat2rzl8///vvvozOa8WVWR2+ysHXrVvbt28e77777j9C/8/v9tGjdFosnAqPdU0oG6N9K0EEdtL+DBPlfoqioiFGjRv2h4om3wrlz56heqy4hEgmJKem3Ndhm//796ExW8satI2fMq4RIJH+KQ+nSpUtUrlYdk9OHVm+6IXm/G+HcuXN8//33f9mh78iRdxdngYbV7kPP3n2oXrM2loR8EjpOxmBzX1OHuu8dd+Kr3C5QfDC7PhMmlJap2LFjB9169GLg4CEl3rGioiJ27tzJsWPHSrS/cOECw0bcTa16DXnxxRdv2736/X5efvllHnnkEX744YdS144dO1ZCLmXv3r306NWHXn37ceDAgRuao2Wb9njzm5PW/yks3sjizMArV64QHh1Hco9HA88qvhxr165l5cqVJKWVQ6HR48isjcUXw4T7Ssqq/Pr+Gq1OLElV8BV0QapQX1UC5mo899xz9Ozdp0y5lRUrVuBOzCFr+BIc2Q1wuLwl7M0FCxbgjM8id+xqwqp3ocUv2bK/Z9euXcyYMYO33377quvYsGEDWr0RqUxO67bt//D3c8+ePcycOZPXX3/9um1PnTp107rXe/bsoWOXbnTo3JXvv//+VpcZ5BoEHdRBgvxH2LZtG7GxschkMh577LHrOnjPnz/Ptm3b/pIT+Rvl9OnTZOflI1coiYyJK5Zj+DP44IMPiI5PwhsWydKlSwHo2LkLUoUKmVLD5MmTy+z3+eefY7E70RotZJfP5+zZs9x///14KzQnb9w6Iurfec1q2AEHtYnv3V6yTWbatm2LxhFRXLFaZQ3FGZuBQhkoGJd+5zzkChUGswWJVEpcUgpvv/02p0+fRqHWYU6oiNLsRmMwc+jQoWvec7cevfDmtyBn9Ep0vkTc+a1I6/ckIVI5qXfMJbrZCEIkkuLCHfHJ6cS0GI1MbcCd3wqZ1owpNpeYlqORqrSY4/IwuSORyBWof7mHtDvmBjSa7WFIFGpiWxcGikhm18VstaEz2dDojYRIZUhkCmRqA3KFktWrV3P69Gkef3wm1ogk4trcg8oaSlSTYbiy6mF3efCUb0pUsxFI5ErM8RWQqnQkp6bx0UcfsXDhQjwplbCmFiBRaHDmNUVpdNCkabNiY+dXh26V6rV5+umnsdid+Cq3wxqfh8rkIKbVOORaIzKFCoVGjy0sDrXehNLsQaY1IVFqCK/dm9yxq3HGZrJo0aLrvmeDhwxFptZjL1cPnS+RpNSM4mvr1q3DHpFI7tjVxLQai0ZvxhWfhcUTyZC7hgGwefNmElPSMRjNaPRG9AYzVavXJK9iVUaOvJvuPXvj9IYT12Y8cW3Go7J4yRm1gsgGA8ipUIl58+axadOm4jnfeustjA4f6XfOI7RqB+o0aFRivZcuXWL8PfeSlpmFUqPDYHXSuFkLioqKGHLXMHQ2L1p3LBpnFFFNhuMLjyzR/+LFi8yePZvJkydz+PBhvv76awxmK9aUasi1ZmJbF6IPT6Xe7+aFwIagd58+mGwuFGodUqUWtzf0D6XI3g6uXLnCmjVrWL16NYXj7sEbHkXNOvVvawbHtejVp2/xoY23cltat26DzmjGEZlIVGz8PyK98Ffd+V/1+/8LBB3UQfs7SJD/RRYuXIhCobil4om3wsyZM3Em5pEzZhXeCs3o1bffbRv78uXLhEVG4ynfBHdGTXIrVLptY/+eK1eu8Pnnn1/XwX7y5Em6du9J+UrVeP755/+09dwIx48fL1H8btmyZZicPiIbDsLsjWLevPmcPn2azt16kJ6Vx2MzHr/meCNG3o07sxZZI17GmVie6dOnl7h+9uxZ7E4PodU64c6uR15+ZSBge1atXgu9xYHOYCoh8zB46F04E/KIbj4SvcVRwqb9lcuXL1/XsXmjjs+LFy9SrWZtlGoNNqf7qgW7f+Wjjz6iV59+PPDAg6UyDyoX1CS62chAMe+k8ixcuJDJU6agNVqRKpQoDHY86QW4fWEcP34cgBdeeAFvWpViWcH0rLzie2zWsjUSiZTYhGTkKi0Zg54lb9w6lGY38+bNu6H7g4Bz2uQMI6x2HwxWV6mCjTt27EClMyHXmVEbzDw47eES1wMO6uxfHNRdad6qbAf1jVJUVPSHAi5mzppFYlomdRs0wmix4c2ug8nhY+ZtKp4e5K8l6KAOEuQ/xIkTJ2jcuDFCCDp06HDVX/Y//vgjMT4f0UYjLrP5LzFAb4Tp06fjTKlMbuEafPkt6d33jj9tLrvTQ0zLMSR2mYZGp78pXboLFy7www8/lNBT1pss+MrVQmeyXlM7d9u2bXhtNtRyOU3r1GHXrl2odUaim4/EllEbqVKLRKagabPmaLR6lCo1c554Ar/fXyKCYtu2bZgcPnwFXfFW7YRGFyiK5/f7rxrRe+DAAZJSM5BIpMiUGlLveIqs4UsCBQrL1UdpduMq3xyd0cz27dtp2bod7nK1Ca3VEyGR4qvRHWdeU2QaI2np6SjVOvQ2DxK5CqXZgzm+AkqzG2deU3zVOqPWmzGHJRBepy9KrQFbYsCZ7shuGNBVHvgMiZ2novpNQb+ioiLunTCRCpWr4Q2LIEQiJSk1g88++4yadeuj1hkwJ1QsLtxodTg5fPgwx48fJyI6FrlajyWpMnnj1hHX9l5kagOpGeXYtGkTPXv3xZVahZiWY9Cb7SxdupQBgwZTsVJlLIkVkSq1hMgUyNU68itXZcWKFbRv3x5jdDa5hWvRuKLxFXQhZ8yrmEITGDhw4HWdcc888wxKIdCEhKCSyoqLVP7888/s2bOHytVqYLC5UGl0qIx2cgvXkjHwGQwmS/EYY8aOQ+uMwle9K1KlBq0vkfh2E5BrzVjTamD0RCNXqlFp9fgiopHK5FjsDvQmM77MGugtDhYvXszGjRuxOdxIpDLUOgPlciuwZ8+eEusdUzgOR2w55FozyT0fC9yrw8vWrVu5cuUKMrkciVJD1vAlpN85D63eyLfffktexcpExMQzf/6CUs9g165dNGveHI3Jji25KlqDqVS0CsCnn36KzmRFqtAQ324CMS3HIFXpiE1MueYzLotz585x//2TGDBoMN98881N9y+L9evXY3aHk9pnFu6cRuRXrvqn6P79noenP4I9KpWEDpOwhsUTl5RKTItRgaib5Pz/qUK5fyVBB3XQ/g4S5H+JM2fOFNuPH374IQ6H46aLJ94KjzzyCK60quQWriW0age6XEPe6+LFixw9evSmxj9w4ADDho9gbOG4Yifg30mHzl1xZ9Ykts149BZ7KQm8v4onnnwyICWo1TNsxMjif3/mmWdp3a4jc+Y8cdMHzsePH6dilQKUKjV1GzQuJc+xc+dOjHYPeePWkTViKQqlCvglYCM8gdyxq4ltM560cjnFfSpVq0Fsm/GBYJdyNYsL7P3K1AenIVco0egMJSTyfuXChQvUqd+IEImEhOS060Y/L168GGdsJrljVxNRpw/1GjYpvvb75/H999+jM5ixplZHZw+lW4+SRd43bNiAzmjGFhpDXGIyzz77LBpLoHCgxh2LxhZKrVq1qFazDpWq1eDDDz/k66+/RmeyEF7vDhzxOdxx50AAnn/+eezRaWSPWk5olfb4IqIxhCZhz6yDwWzl9OnTFBUV3ZAjvlmLVrjympFbuAZv1Y7cffeoEtdbtWmPJ68xyT0fQ291884775S4fv78eaoU1EShVOP2hrFjx45rznf06NESByG3k02bNmGwuUjsPBVXubpobYGs1fh2E8jN/3MkfYL8uVzL/paIIEGC/KswGo1i2bJlYuLEieL5558XFSpUEN99912pdgsWLBDZp8+Id7R60dmPeGTq1L9htWUT8pv/QHBLY5w4cUK888474scffyzzOiBOHD8q9KFJQuuJESJEIk6fPn3D4yuVSuH1eoVEEvg1mZSUJLZ+8rGYcGc78d5bG0SdOnWu2jclJUXs+/FH8ePRo2LZunUiJiZGLHv5RWE68J449uW7IrZVoUju8ahYt+418fNPP4pzZ8+IPr17i5CQECGVSovHCQsLEyFFF4VEKhWcPSoyymWL3bt3i/CoGGEyW0TV6rXEhQsXSszt8XjEl19sFZcvXxLTHpgqvn1miPhqdg/RvHkzcWrXRhFavZsIr91bmOIrirfeeks89eRsUScjTERc2SPMVrvwXzgrdJ444b90Xvx8/JSIan2PSOz3lNCYHUJy5Zw4u/czIZVKRFitXkJpcor09DQxbmg/Uc17ReRmZYhL58+KogtnhTu/tZDIlEKq0gqZ2iAuX7okvvjiCyGEEBKJRIwrHCs+fPct8daG9WLJSy+Kd9/aINLT08UzT88Vep1WnN67TXy/8mHx87a3RIg9TqRnZgu/3y+2fbZFDOrfR5z89hPx4yerxaGNS4W9XF2x47t9okbt+mL9G28JY0otYU2qLAxhSeL8+fPisUemi7lPPiFOfr9VxLYaK7KGvShCZCqx4yhi4aIXhNFoFEUXzwmuXBIaR6Q49MFLYvOkJuLihfNi4curxNQHHhRCCLFnzx4xZcoUMX/+fLF582Zx7NgxIYQQs6dNE7PMVvGNyyOS9HqxZ88ecc+99wqn2yti4hNFWKhPfPj2BqHTasTlC2fFsS/fET9+ukaYrVZx/vx5IYQQ6994S/hq9hDeSm2FISJdaJ1RwhiTI6Qagzj+9Qfi9M8HhVqtEbu++Urs+36XOHP6lLh/wr3CGJ0jvI2GC2dBT/HkvGdF1569halSF5Ex+DkhV6jEgqeeEOHh4aKoqEgE7AEhPtq8RRjS6gi5zizOH9kjLh47JC5fOCcMBkPgHZTJhSE8TWx7sr/Y9mR/cffIEaJth87ikDJaaCr1FgMGDy31OycmJkbMnzdPxEWFi7O7PxW1a9USTqez1Hdj+/btwuBLFAgh9BFpwhiVKfyXL4iTJ05c9ftUVFQkfvjhB3H58uUS/96xSzfx2KJVYtnWI6JCpSri+PHjVx3jRjl8+LBQW31C44wS2rAUseWLr0SlqtVFUVHRHx77WgwccKfo1rqR0H23RrRqUF0UFV0RZ/ZvF+eO7BEXjh0QLpfrT50/SJAgQYL8t3ns4YeF02IRTotFzJoxQ1SoUEFs3rxZREREiPr164vHHnus2E643XTt2lVYQ06JLx9tL658+64oHDOqzHYffvihsDvdwuMLFc1atr7hv70ej0c8+MBUMXHCvcJkMt3Gld8aX371jTAmVReW+ApC74kVu3bt+svXAIjBg4eKuK6PiOQ75omZs2aLw4cPCyGE6Ny5k3jx+YWiT5/A3uNmMJlM4v133hQXzp8TL7/4vJg/f76YM2eOOHfunBBCiPDwcGE16cW+Vx8S+1dMETVr1xVCCKHX68XlC2fE5bMnxLmDO8WJYz+LhQsXCr/fL7p2bC+OvDlX/LDmUXF6z2eiRo0axfP9+OOP4p57J4jkO54SES3Hiy7depRa03PPPSc+++6QyL57uThjihNjCsdf8x4kEonAXyTALyi6IqRSqTh16pSoWKVAyORykV+5mjh16pQQQoitW7cKodKL8z/tFQp7pFj0/AvizJkzxWPVqFFD7Pz6S7FqyXPi8y2fiG927BCmpAJhSykQ9rQaQgjEp599Ib4XXnHQkC7qNWgkwsLCxMpXXhZ5plOiX7uGYvpDgX3GhQsXhFShFhKZQkjUepGWliamjh4gBresIr7e/oVYu3ad0BtMQqPVidmz51z1/ibeP0m89vob4thX74ntT94pTn6+TtSsWaNEm30/HBDa8HSh88QJnTNcHDhwoMR1lUol3n5jvfjpyGHxw77dIi4u7qrzzZo1W3hDw0R4VIwYOWrMNZ/9rbB3716hc0YKQ0S6MMRVEJfOnRI/b3tLnPh8ncjKTL/t8wX5m7ma5/qf/hOM4AhyOzl16tQ/IoX6Zlm7di1msxmTyVQqdWf27NlUNpr4zOmmldHE8MGD//L1nTt3jpdeeol169YVn0ifOnWKrNwKKJRqIqJjb0niY9++fdhdHlzRqRjM1qvKA4y/dwI6sw2j3UOHTl1uao7XXnuNygU1ad22w205Ef7iiy8wmq2ESKRkDn6Ocne9gEKlvm7Bi7feeous3PLUrlOPvXv30qpte0KrdghIUCTkXrOQCQQi6X+NJJhw3/3YIpOJqNcfvdnGxo0bS7TdvXs3NpcXmdqA2mjB7vYRXqsXqX1mozfbefnll3nrrbfIqVARvdmOWmdg2rRpxaf5SrUGXVgKErkKS2Jl1FYvITIFEoUaW1ot4n4XJbtu3Tp0JguexBzsLg8HDhygT7/+eCs0I7LhIGRqPUndpweqQ3ui6datW/FnPXr0aCRyFYaoLFJ6z0Kq1BDbqhCT1Y7R7sabWQOzzcG9997L3LlzuXjxIhaHm7g248kavgS53kp43X5kl6/EZ599hlJrQISEIFPriU9MxhKeTErPGcS3v4/c/CocOXIEi92JJ68xansYGpO9+N2rU6kSDVRqaiqVmBQKVqxYQYhUTtodc8kasRSJXBWIFJcqkBscKIxO5FoztqhUcspXpKioiHvunYDRG4O3SodfnpkKhd6CRKEhtc+sQES6TME99/6/1t/bb7+N3uoitEYPrDGZDBoylIiYeBI6TiJn1ApMzlA2b97MXcNH/BJx7eTDDz9kwYJnMNrd2JMqIVVqMJgstGzVmjv6D+DDDz/kmWeeRaEKFK8cNXoMAJ6wSFJ6ziC3cC1WX3QJnexfGXLXMNyZtcgYtBB7THqZ7+b+/fsxWe1oHRHIdRZkGiNytZYFC54p8/396aefiIlPDGiHh0Wwb9++4ms2p5v0AQvIG7cOZ2QSH3744TW/CzfCr1H6KlsoMrWBuHYTMFid7Ny58w+PfSMcOHAAg9mKp1IblEY7WoOFwvH3/GckNf5piGAEddD+DhLkf4Bz586hUSj4yOFio8OFWi4vLlx4+vRpmjRp8qcXTywqKuLgwYPXHL9cbgWim40kZ/RKrKGxN6Qx+09k9pw5GG1uPGlVcLp9N62Bezvw+/0YzVaSuj5E+oD5qDS626o57vf7ycuvjCMxD50jUO/k1xpJP/30E1OnTmXmzJnF75nf72fY8JGo1BpkCjWevCbYIhIZOmw4AG+++SaPP/54Kc3fH374IZAROOwlUvvMQm80lVrLzJkzcaVWJrdwLWHVu9C2Q6drrv3SpUvUb9QUqUyOxxfGN998w733TsCVXkDO6JW40qszfvw9QGDPKVVqSOv3ZGA/4o66Zi2ojz76CK3BhKNcXaRKDSEyOSJEQtaIpeSOXY3WaGHv3r1l9j179ixZuRXQGi1Y7E6++OKL4mtFRUVotPpiaUiFSsOQu4bRtmPnUvs5jU5PxsBnyBnzKkqdqVi7eseOHbzzzjtcvHiR5cuXozNacEanEhkTd8t+EL/fj1KtIf3OeWQNX4JKo7vt8njHjh3DFx6JOyEHvdnG4MGDqVWvIUPvGv6nZjmeO3eOL7/88i/JpPxf41r2999u6N7qT9BADnK7mDVjBjqlEp1CwdT7779+h38Y33//PRkZGYSEhHDPPfcUp/1cvHiRds2aY9JoqF2p0l+e8nb58mXK5ZTHGVcOizeqRPVcv9/PyZMnb9npMmnSJDy5jQIFPmr1pGOXbldt+/XXX7Ns2TK69+zF0GHDr/scTp48yRdffIHOYCam+d14yzelao3at7TOXzl+/DjR8UmoHRHY0mshkauQqzSMv6d0YZGjR4+SX7kaao2ORk2bY7bZf9FG1iKRq5AqtejD08gZ8yrOhLzrOqh/5dixYzRr2QanL5ysnPKlDjQgkCInk8vJGrGU7LuXI5crSU7LxO72Mn36ozzx5JMoFCpkciWhEVFYw+OxhsbQsUs3ioqKUGm0pPadQ0qfOUhlcgYMGIDe6qLcsJdI6T0Trd7IM888U/yHvm7DJkQ1uSugu5tVm8cff5xeffriKd8Ua0q1gAZ2YiWcuU2QqnR48pqgM5pZu3YtTo8PrSsaiVxJiFSBxh1HaJV2ZOflM23aNPr3749MqcGckI8pIoVmLVrz3HPPIZEpECES5HorKp2BBx98EK3BiCk0AbnWRHSLUci1RjTOKORaMzp7KMOGj2T16tV4EnPIG7eO5J6PoXFGEl6nLy1at6Nz1+5oHJE4shoE5DkMJiQyJQkdJ5N+5zyEVI5cbyVEKkOmMSJECNl3LyO3cA06k5W9e/dSVFTE008/Tb169VEbraT2e4LQgi5IlBpkWhOOcvVRGJ3EJ6Uw96mnsNic+MKjCIuMRmV2odDoeWzG47z66qto9AbUOgNt2ndk69atGGyBzyCmxSgSktPw+/00a9EKiVSKwWylS9fu2CKTCa3eDZ3RzNdff83FixdLpG0+PnMmerMNozOU8MjoYhmT39KxSzdCa3QPyFJk1WXq1KlAQJaodr2GmG0OOnbpxq5du3jssceYMWMGL7/88jVTMSdOnIi7XB1yC9fizW/JgEH//3ukTfuOOOJz8OS3xOpwXdW4Pnz4MNnlK6LW6mnXsfN1CxGdOXOGsMho3OWbEtV4KAaz9abkgf4Ia9euxZOYXaxXHxET/5fM+79K0EEdtL+DBPlf4Pz582gVCt5zuHjH4USrVJYonlxUVMTdd9+NEIKCgoK/rHji78mpUInIRkPIvns5Fk8kb7311t+yDgjYLtcKItm9ezcpGVloDUYGDh5aak/zwQcf8Oyzz/5psgc3wquvvoreaEKpUvP44zNv69jHjx9HodLgzG2CPiKDsNp90BrMZepH/5bf29PR8UnXnWvE3aNRqjWoNDqeffb/Jc/Onz/PkiVLWLp0KakZ5dAaLThc3uvKUfzKuXPnimUT0zOzUZndRDQYgKd8E4aPGMnrr7/OmDFjSE5Lx5FRi8gGA9EbLdfVIN+6dSvTp08nPimV6GYjsGfWRWXxYAlPomKVgmvuf4uKiti/f38p6ZR3330XqUxO+p3zKHfXC8hUGpzJlQiv0xe9yVIi4Cs0MprIRkNI7PIgGp2Bn3/+maefnodab0LvDCcqNoELFy7w7bff8vrrr183WAoCe/c9e/aUKnDp9/vRG00kdXuY9P5Po9JoS7W5HRw/fpzly5eXcNr/mezduxeXJxSLOwyXJ/SqhwpBbo2ggzpIkKtw+fJl1HI5HzpcfOJ0o1Uo/lEFBW+Uc+fO0aVLF4QQNGjQ4Kb/MFy4cKHUH8stW7ZQWFjISy+9dEuO5C+//BKj3UNu4VoyhyxCqzfc9Bi/Zc+ePcyZM4d3332XefPmYYtKJe2OubhSq3D3qNFX7Xf69GmsDlegWEe52lQpqHnVtnOfegqVRotcqcLgiiRv3DpS+87B5Q0rbnPmzBlWrlzJJ598csNrb96qLY70GsS0HINMY8ToiWHatGllth04aAie7HqUG/YSRm8MEpkCpcmJXGfBEFUuUGTRFopULie/crViZ+/JkyeLT6yfePJJsstXomuPXsVGR7uOnfFk1yOxy4MY7W7ef//9EvM+8shjeMOjkClUxLYaS1zbe9EZjMUbmKKiIqQKNUqLB4XJSYhMSfqA+UQ3u5uQkBC++OILnn12IUq1BrlCybSHHqaoqIjadRtgdoUhV+swhSXijM8hMSWdZcuW0a//AFxpBSR1exiV3ozR6iAuKRWN3og1pRrxHSYh0xiQG+xENBgQcGRXbEWDBg3wlKtN3rh1RDYchNoZhVxrIj4pBZ3RjDs+C4lciVSlI7dwLVnDlxRr4O3YsYMHHniAadOm8e6776I3WdC4Y5AqtZhi80jsPBW1I5LcwrUk93wMk83JwYMHKZdbAYlcSXidvhijs7EkV8WdXY++d9xJeHQcKb1nkTduHfrwtIAzWiZHqtIiUagJkSnQh6eSO3Y1noptkKt1hFbtSET9/pit9uLPMBC5rEFlCyW3cA0JHSahUGsxRKQXF1LxRcag1hlI7TMLX/WuKI12cseuJqXnDNy+8OJ3/lfj+eOPP0ZrsuLOb0VozR5ExSXy6aefYrS5yRrxMjEtRqMxWohvfx9549YRmlWTBQsWlPluDho0CKlKizW5KiqtvpSu/eeff47JascWGoM3LKK4oOfQYcNxZ9QgY+Az2GPSeeqpp274u/PAAw/gTKlMzphX8WTXY9jwEcXXLly4wEMPPcSIkXfz3XffXXWMbj164S3flHJ3vYA9KvWG9Jx3795No6YtqFazzm2JzL5RfvzxR0xWO578Vtij04p1CYP8OQQd1EH7O0iQ/xXmPvEEGoUCjULB/N9p/P7Ks88+W1w88euvv/6LVxioU2F1uJDK5HTu1uNvyx4qHHcPSpUGlVrLvPnzy2xTr2FjQqt1InPwc1g8kaxfv56tW7fywAMP8Oabb/61C74Gfr//T3mOly9fRmswB4I+dBZS+87BEJmBXKGidbsOV9VJ3rNnD3qjhbDafXAm5V8zyOi3HDt2rIQj9cqVK+SUr4gzNhOLL5re/e7gwIEDJQ5ersXp06d5++232bdvH33vuBNXahXi29+HXGvC7nSzcOFC9BYH3iod0Jvt1K3fgAaNm10zevr35OVXJrLRYKJbjCFEIkOuVNGiVZub/jx27NiBzmjGklQ5UHxeocJsd5HSe2YgKCS+XImik1u2bCE5LZOwqFiWLFkCgDs0gqSuD5FbuBaV1ceoa+ydf4/f76d1uw6otAYUSnUpO3rFihWBgxC1htlz5lxzrG3btrFu3bpSNbSKioo4duzYPyZjcPiIkXgrNA/sPfNblNh/BPnjXMv+lv1t2iJBgvwDCAkJEVKJRJwD8avK2a+aw/8m1Gq1mD9/vsjLyxODBg0S2dnZYtmyZSItLe2a/S5cuCCa1a0rNrz3nogJCxPr3n5bhIeHi6+++kpULagpDKm1xLmnnxOHDv0oBg68UwghxLZt28S4e+8TGo1aTJ10n/D5fCXGPHr0qPjmm2+E2+0W/kvnxdHtb4tLxw+IyOjYW76/ffv2idz0dFFVKhX3Xb4sJjzyiGhep7J49dX7RYW8PDF2zOir9t27d69AqhSeKh3E5XMnxSdzepbZDhADBw4WcV0fERK5Umyb3UfsfflecfHEIdGvWxchhBDnzp0TWbnlxckrcnHu6EFx3z2FYsCd/a+7/s+/+ELYKnQX+rAUcXjjyyI91isGDRpUZtsTJ08KmcEh5BqDuHj+nIhoMEDY0mqKr58dKeQ6s9C6Y4TelyT69usq7r33XhESEiKef36x6Nm7t0CEiLp1aou33v1QuGrdIdZtflMMuWu4kMlkYtmKV0VY/YHCEJ4qTjqjxd69e0VkZKRo1LSF+OrL7QIhETHtJorLn7wqDr0+W7icTrH8laVCoVAIIYRYu3at8PuLRFqf2cJfdEV8+mAr8fnMniJEIhVKa6gon19JfLblE3HqxHEBCKVSKYQQYs2qFeKTTz4RFfLzRWzHqSJEKhOfTm0heg66WyREuEXV1FDx7uuPiEsXzouIpneLM/u/FP59+4TK6hPGqEyhD0sRIRKZOPzRciGRKcSx7W+JH+OixLnDP4uzh78TJ3dvFWpbqDh96kfx3bffCld+a+Gt0l7w+lzx46drxMEPXhIXjx8SEVExonO3HuLKlStiwvhCERMTIyZPniyUoRkiutkIcXjzSrH/jQUCf5G4eOKwOPX9VnFm3+ciNTVF3D2mUBwOsYvopiPE/vWzhdNqEicO7hFx5cqJ+yfeK06eOiXWvTVf6CMyxLnD3wkRIhG2lOri4r4twl90RVSskCc27TgsREiICJHKRI3qBUKtvizOnd8nJr/+mlCr1eLUqVOi9x0DxKUL54SUEPHZo53FlQtnRYhEIs4e2iWOfLpGnPl2k6iZX0G8umatUFm8QuuOFYfOnxFnD38nTu/5QpjNJnH27Flx5swZoVarxcWLF8V3330nivxChEjl4uC7z4sp908Q27ZtE+cvXhQhUpmQyJVCrVKJn99/Tpz54Wtx6tstokKFmWW+m3MXLBRhtXoLR2YdsXvVo2LRokXivvvuK76elpYmdn+7U3z33XciMTFRaDQaIYQQR376Wcis4UJpcgqZySOOHj163e/Mr/Tr10+sXL1OfDC5icjMyhV3jxxRfE2pVIqhQ4ded4wTJ08JmdElZBqjkOksN6RFHxERIVYue/mG13m7cDgc4qMP3xfPLlwowkJrih49SmstBgkSJEiQIDdLz969Rdfu3YUQQshkZbsAOnXqJKKjo0WzZs1E+fLlxUsvvSRq1679l62xXLly4qfDB8Xly5eL7c+/miNHjohpDz0kkvvPE5fPnRR33jlQdO3SpZRW84mTp4TcGifkeouQ68xi69atYuKkKcKUVE2cmvqQmPfETNGiRYu/5R5+y81qTF+P9957Tyx9ZZmQSSVCabSJpP4LxJGt68SuJfeJS6ePCp03Uax97XWxadMmkZ+fX6p/eHi4WL9utXh89hMiMq+mGD3q7hua12w2l/j/7777Tuz49juR0G+euHLulHh2dg/xxKyy7dffc/ToUZGZnSsuSTTi7M8HRHRsrNDF1xSmmGxhi80U4/u2ER9t/kSYMhsKT8XW4qBcKeJiDeLRR6bf0Pi/MmvGI6JO/Ybi+PETIr79BKEPSxFvzOsvPvnkE5GTk3PD43z22WfCFJEqvE1Gi+M7NwnZVytF7ZoF4rlXHhcKZ4y4dPygyMrKKm6fmZkptn++pcQYcplMnNy9VYRIZeLK+VNi+9df3/D8n3/+uVi5arXwSxRCYfeJHn36iZYtWwqVSiWEEKJx48bi5PFAXZ5rvW9PPz1PDBk+UmgsbmFWCfHpx5uERqMRu3fvFlWqVRc//XREpKVnirc2vCa0Wu0Nr+/PwGgwiCunfxKXz50SV04dEUZD5t+6nv8prua5/qf/BCM4gtwunl+0CJ1KhUah4MnrnPr9G/jwww/xeDyo1Wqee+65a7adO3cuVU0m9ri9DDCa6NGhAxDQrw7NrU/euHXEti6kWs26QCBS22J3El67F75KrUlKzSgx3ldffYXDaKScxYrbYmHRokXkVymgfqOm7N69+5bvae7cubSwWPnB42Ou2UqdihVvuO/58+cJjYjCnVUPR3w2TZu3KrOd3+9HbzKT1H06GQMXoFBpmDFjBq+99lrxae6GDRtwRCWTW7iWpO7Tbyj9/plnnkWh0SLXWTDH5uD2hV0zwv2rr77CYndidoaiM1lxV2hBxqCFKM1uQiQytO5YdEZziVQji81JSs8ZZI1cilKtxZNW9ZfPbhyxiSnYo1IJrdkTiVKD2uzCZLbyxRdf4PSGodBbCa3ZE7U9jJiWY0joNIWElPRS61qwYAESmYK4NvcQ3XwkErmS7LuXE910OEqzG6lSw/jx4696X1Gx8YRW60RY7d7ItWYsydWQaww8+thj9OjRA6XZTW7hWlL7zEKqDDwvjcUdkENRasjIzEapNSLTmAmRKZCqdMjVeqRqPRKVnhCJDFdeU4zRWQE5EU8cnsrtMMXmolDrCI+MJrRyW0ILOuP2hnL58mWaN2+O2h5Oat85mBMqEiJT4CrfHGduU2QqHQU167B//34aNG5GRP1ABLc7rQpPPPFEiXs7e/YsQ+4ahic0AplSiy2zDnqzvVg78ezZs5SvWAWlWoPHF8a3337LZ599RkZWDqHhkcyZM4cJEydiSahIzphVWFKqItUaURjdyHVWXPmtCJGrGD2mkHPnztGuY2cMFgcavZG27drj9ISi1OhRanRI5ErkKi0SmQKt3kD1WnWK1+6p2IYWLVpSpXot9GEpSBRqJDIlWVk5GEwWomLiuGvYcGxON9FxiaWyBNQ6A/rwVGJbjUWus/Dkk08CgaiHyVOmUqteQx6b8Xip6IfPP/8co8WGPSwOjy/suqmRZXEjFcuvxtatWzFZ7ZidocQlJv/lckdB/rmIYAR10P4OEqQMLl26xKpVq3jjjTf+MRF9fyV79uwhLS0NiUTCY4899j/1DH766SdUGh0ZgxaS3PMx9EZTqfs/duwYcUkpCBGCXK0nLTObe+65B2/FlsXZfa3advib7uDP49NPP0VntOAr6IrO4sLkjSVnzCoiGw1GptJiis8nqskwJHIVK1as+FPXcuLECfRGM9FNhxNa0IWE5LQb7vvUU08V75Wimg4jJT0TvdmGN60yNoebAwcOsGTJEowOH+H17sDo8PLyyy+XOda1vhsnT55k1qxZeMIiiW42knJ3vYDe4uDzzz+/qXvdu3dvoD5JfkusoXEUjg9Iei5cuJDJkyezZ8+e647x3HPPIVfrkeutqPVmFi1adMPzf/PNN8hUWpJ7PkZu4Vo0ttBbkt+JTUwhscuD5BauxRmdyrp16wDo1LU7virtyS1cgys5n5kzb68cza1w5swZatVtgFqrp1bdBpw5c+aqbd944w3mz5//t2jN/1u5lv39txu6t/oTNJCD3E6Kioquq0v6b+LQoUNUqVIFIQQDBgy4arrTnDlzqGUys8/tZZjRRNe2bQH45JNP0JtthNfpiy0ymXsnTAQCae96s53cwrVk370MqUxe4g/z4P79Gaw38IPHRx+DkVEjR96W+/nwww9x63TMMVuoaTQxbODNpb0fPnyYyZMnM3PmzGumfi1fvhylWkOIRIrW7KBilQIuX75cfP2bb75BZ7KS0GESvootqV474LhfuXIldw0bzvr160uNGRkTT1LXaSR0moLO4mT58uVlzr1z505iE5JRqtT06NWbL7/8kq+//prQiGhkShVpmVl8/fXXvPrqq6W0Ae0uD/Ed7idz8HOotXqsdifetCrozXYaN26MO7cxWSOXIlMbcGTUwRaVit5kCRgp9nAkSg1aTzx6qwud0cJzz5U2Wn7++eeA/InehsriRarUkNjtIaKaDEMfloIttTojRlw9/en777+neau2aI2BOe2ZdYlvNwGdycqMGTOQqXUB6RKVjrDavckY9CxypYpHHnmEDRs2MHLkSGQKFVKlhqTu08kduxql0YE5IR9daDIShZqU3jOxplZHqtTiDYtAb3Wi1hlYtGgREomUnDGvklu4BrlSzd69e5k4cSJKiw+VxYvaEYEIkWCISMeWVguVRl/sSF2+fDlqrR6zO5zouIQyDxjOnDlDRlYOEpkcqUJN124lUxb9fj/Hjh3jypUr+P1+rHZnQC4jpQCpSkvTZs1xZtULFPzLbYw+Ih2JTIGrQgtUVh+e0HAgoFE+depUmjVrxkMPPcSlS5fo0as3WncsCpMLZ15TFEY72SNfIb7D/VgdLrQ2L+F1+yFT65HIlfgiogmr1ZvMQQtRWX3o7V7S7piLPakicpWWlN4ziWoyjPCoWLZv315c0OiJJ59ErtQg1xjIrVCx+Ls/c+YsrGEJxLQcjdkTyYsvvljq+Rw7doyPP/74mgbehQsXeOutt/jmm2+u2uZWOXnyJF9++eUNp37+E7hy5Qrz5s1j6tSpt+TUD3J9gg7qoP0dJMjv8fv91K1alXImM3FGIwN69/67l/S3cPr0aRo3bowQgj59+vxpxRP/iTz08HTkCiUarZ6lS5eWuj5u3HhcmTUDBcvTa1A4bhxr167FaPcQ1eQubOGJPDz9kb9h5WVz6dIlXnzxRRYvXlxctPBWePTRR/GVb0zeuHVENxuJ3e1DpdFhttqx2J3FcndGXxwbNmy4LWs/fvw4W7ZsKSUJAQFd5opVq1OvYeOrSr35/X7WrFnD888/X2yDrlq1Cos3itQ+s/HkNKBztx48/vjjdOnShY8//piNGzcyf/58Hn/8cTp368Hzzz9fYry1a9fywAMPkJiSjlQqo36jpqXsy8uXL5OUmoE7tTImbwwqrR6ZXMHIUWPKXOepU6d44YUXrnoo9tVXXzF+/HgWLlx4ywdG69atY+CgwcWyHzdDZEw8rgotSOgwCY3exK5du256jBp16uGr2IrELtPQm23FetJduvXAV7lN4PuUWJ7Zs2ff9Nh/F1MfeBCT04c3vSoeX1gwCOYGCTqogwT5H+TSpUsMGTIEIQQVK1Ys08Fx5swZKmdno1cqCXe5SvyxWb9+PZ279WD6I48WO++vXLlCWmY2ruR8HDHpNGvZusR490+cSC2jkfccLqoYjUyfPv266ywqKmL86NFUysig8O67r3pQsOi556hftSojBg8uVTjiduJw+0juNYPcwjVYPBF8/PHHJa4/99wiktLLUa9hYw4ePMiSJUsw2Nz4CrqUiJr9ldwKlQmr2YOU3oEic9u3by9z3hp16hFWszvl7noBizeKl19+GfcvEc5StR6jO5Jp0x4u1W/Lli2otXqkChUhEikDBg3m8OHDzJ07l5iEJBRqDTKlBpMrApXVV1x8LUQqJ6HDJKIaD0Wq1GB3uFi7di3ffPMN90+aTONmLUs5GkePGYMpKgOZ2oA1pVpAX1kqx12hJWq9iY8++uiaz/bZZxcSHh2HXK0nuvmoX3TTsli2bBm+8EhC5CqEVEZs63H4qndFYbAj1xiQawwlihCG1+1Hat85yFVaFCot+vBUohrfhUSmRCKTc/+kKRQVFfHZZ5+xYcMGtm/fjs5kRYgQFHobcp2Fps1bcerUKeQqLSFSGSFyJSEyOSprKCqrD5lKy7Zt23jqqaeQyJWorD6kchX33BsobPnBBx9QUKsuzVq2Yd++fcycORNTdBa5hWvwVGqHXK0rs5Dg5cuXmT9/PkKEYE2rGYjeaDKMygU18YVHIlVqkGuMyJVq7EmVyBu3jvgO95ORXZ4LFy4QER2LVKVDaXKhtvlo1LQ5NqcHZ25jPJXaIv0lOiJr+BLi2t5LREw8FpsTtTOK2DbjsWfWRaZQIdfbCJFIURpsaJ1RqGxhKM1u5BoDOWNeJbXvHCRyFSanj+S0jGJt/iNHjrB79+4SxnH3nr0Jq907EKVduR35FStRLjefEXePvuGDv/Pnz5OWmY09PAGdycq8efPLbLdv3z5mzZpV4nu2fft2GjZtQbOWbfj2229vaL5/Az169cEWlYo7ux4uT+i/sj7CP52ggzpofwcJ8nv27t2LXaNhj9vLNpcHhUz2p0cQ//zzz6xfv75EobN/AkVFRYwcORIhBNWrV+fo0aN/95L+Mi5fvnzV7K27R43Gk9uI3MK1eHIbMmp0wOn47LMLadK8FQ8++NANZ35duXKFo0eP/mnv2Pbt27G7Q1EarJhD46havdYtz/XJJ5+gM1oIrd4Niy+Ghx6azk8//cTFixcZM3YcFk8knowCvGERpYpLnz179qaz4Yprm/ii8YVHcvjw4Zte852DhmD1ReNKyCU1vRyXLl3C7/czavRYPGGR1K7XkMlTpmByhuLNrodGZ0BvtuPNrI7F7iz1nbxv0mTM7nDsyZWRqfVkDF6IMz67VNH6Xbt2YbS5ArVwRixFrlBe9f7Pnz9PQnIqlrAENCYrQ+8aftP3+Wezf/9+atdrSFJ6uRIO+5vhwIED1Kxbn9jEFJ78zfPau3cvEdGxyORyKlYpKPMw4p9KbFIqSd0eLt7Trlq16u9e0r+CoIM6SJD/YZ5//nk0Gg0ul6tUYTwInAT/9NNPJSKFr8Xp06d58sknWbhwYXGfd955h1C7Hb1KRW5aOmF2O93atbuhaMU5c+aQaTDygtVGttH4t6f1pJXLIbxWL5K6PYzWYOb777+/ZvvuPXsTXqcveePWYUmqglKtRWcwFkch79y5k4zsXJyeUB59dMZVx8mrWIXo5iPJHbsaR3QaLVu2ROMIJ6xWL3wFXdGHp9GsZZtS/QYNHoK3SgfS+j+Nu2IbBg8ZCsCDDz6IK62A3MK1ePNbUKdeA/QmC2G1euJIykeq0JAzeiWZQ58nRCLl3XffBWDCffdjj0olqvFQDFYnb7/9dvFcp06dIjQ8EnfF1uSNW0dY7T7klM+nXccurF69+prP6dtvv0VntJDY+QF8VTsi1+hxJ5UnNCKKNWvWoLP7yBmzCl9BV6QqPUqTk7A6/dCFJqOyhpLaJxCVoXHHIteZkchV3DVsOO+88w5RsQmotAasDhebN28GAoZwWmYWZnc4CrUWZ3YDcsa8ijE6G3fF1thdXt577z30VhdqRyQhMhUyjZHEzlOxpddCqjbg8kWgN5gxRGYQXqcvzrzmyNU61qxZg95oJqrxUNz5LTHZnMyYMQNjZDq5Y1fjrtgGpd7MlClT2LRpE88++yw7d+4EoH2nLtij07Ak5CNRqIlpMRpjRBpjxo7j8uXLvPvuuzz22GM899xz6EwWwuv0xR6TyV3DR7Bt2zbUehMqaygR9e9Erg843UMkEnLHria3cC0SuYoQqYIQiRS90cybb75Jw0aNsSRVIWfMKswJFZGq9dizGhDXZjxqnRGJXElil2mE1emL1mjBaHcjU2qwplYnt3AtpqhMYhOSSrwLv+Xpp58OHHJk1EGiUKPUW0joOBlbVCozZlz9nf8tGzZswBGZRG7hWhK7TCMqLrFUm4MHD2KxO/Fl1cHk9PHYjMe5dOkSNqeb8Nq9CC3oQnhUzN+ainz27FmmTp3K2LGF/PDDD39oLJvLQ/qd88gbtw5HROJfWqzxf4WggzpofwcJ8ntOnz6NRadjptnCeKOJ+LCw63f6A+zduxeP1Uq+1YZVp2Pjxo1/6ny3wjPPPINCoSAmJuZvKZ74T+PQoUNExcaj0ZuIjku4KcfpiRMn6NytB/lVqjNz5ky8YREo1VqyciuUKAJ4O/D7/bh94YTV7k1U46HItCYUKk2pTMyb4e2336b/gIHMnz+/hL3l9/tZtWoVTz75ZAmpg6KiIjp06oJMrsBstV83mOW3tO/UhbCaPQIBEFl1ePDBB296vQaThYxBz5JbuBazK6xMeY3s8pWKi4WrLW5iWxcGiuNl1uDp3xUUjU1MKXZI6kKTiWt7L+60qkyfPp3ly5ezcuVKrly5wtmzZzHbHITX7oU3vznp5XKuusYPP/wQrcWJ0uzCFJuLTKn5nwtK8Pv9/yrH9K80bdEad1YdYlqORme0/ClZoL/y+eefs27dOs6dO/enzfFXcS37+99XDS5IkCA3Rbt27cSmTZuETqcT1apVEzNmzBCB3wsBQkJChM1mu2rBlN+j0+lEr169RMeOHYv7dG/XTtxzxS/WGkxi166d4v1PPxXznn/+hgqcfPrxx2Lfxcui47Fj4tylK2LHl1/e2o3eJl56fqGwndouzrwzWzz+6HQRGRl5zfY1CqqKk5+tFgc/WCKO7/hQxHSYLCLaThY9e/UWFy5cELGxsWLr5o/E4QP7igtNlsUDkyaKI288Kb6e1U1EOPRi3etvCGN0tjj5/Vbx87Y3xcWf94pWzZuW6uf1uMWRT14VXz87UhzZvFLotIHCdBKJRAiKhBAI4S8SBoNedGzXRkT594hO9SuJ1JQkseXh9uLzGd1FxYqVROXKlYUQQmz8aLMwpNcT9ozawhCbJ7Zu3Vo8l16vFw9OnSwu7N4sjn3zgTjx5ZviyE8/iazMDFGvXr3idvv37xdDht4lxowtFCdOnBBCCHH48GGh0JkEILS+BGHQ60WTKhniydkzhcvlEiFFl8Tls8eFTK0TIQIhLbooLvy8T1w+fVRoXFFi/5sLxKGNS8XF4wdFiL9IhIgiMXvOHDHtoYdFpUoVxbrVK8XD0x4Q/QfdJTp17S6WLFkijpwTIrbnHKH2JAqJUicunT4uzv34nTi0cak4e/acePvtt4XG4hapfWYJfViy0DgjhSEiXVgS8oVUrhKnLoWIsxcuCAHi1L5t4uj2t4TS6BCffPKJuCKkwpZeS7jymolTJ46LkJAQ4VBeEZsnNRY/frxCXLl4QTw093lRsXI1MfKBJ0RWTnmxZcsWsXzZKyK0ySgR06pQqLQGEfLlCtG1WS0xrnCMkMlkonLlymLAgAGiQ4cO4tVlS0UV9yVxV692Ysqk+0VYWJjw+/3CU6m1cGY3FJbESsLmcIiqBTXF3qUTxb7lk0VKSrK4eP6MOH/urDhx7GdRUFAgFj77jLCL4+KTSY3Eqe+3iIQOk4X/4lmxe9Ujon/fXkJvsgp9aKIwRWcJhUwm3n9zvahdq5ZQG6zi8plj4uKZY+KUMU40atJMHDt2rNQ7KJPJhDUiWWhc0SK0Zk8RotAIY1SmUEVkia+/2Vnm+w6IU6dOCb/fL4QQwuVyifMnjoizB3aIM3u2Cq/XU6rP22+/LdTueOFtMEQ4a/YTCxY+L44fPy7OnjkrnLlNhSu/pdi/Z7e4cuXKVb9nfzbNW7URDz+7Usx7/QuRW6GiuHDhwi2PlZuTK468v0gc2rhUXDh5RMTG3nqh2SBBggQJcmPodDqxbPVq8VJUpPgoLVUsW7fuT51v8eLFouaVIvGSUiUGSKRizvSbK8T2V9C5c2fx1ltviZMnT4ry5cuL9evX/91LumkAsWrVKjFr1ixx6NChWxpj2kPThdFiE/mVq4kXn39OfLfza7Hjq+3C6XTe8Bi9+twhXv98v/jJmS+GDL9bFNmTRPqwJeLAOalYsGBBibZ+v19MmHifqFK9tnhw2sMl9m83QlFRkThy6IBwlKsvrKnVhf/yRaHT6YTRaLypcX5L1apVxeOPPSq6du1aoiBeSEiIaNCggejVq5eQy+Vi165doqioSLzzzjti7ZvviYxhLwlzpS6izx0DxMaNG8WhQ4fEkSNHrmkn2SwWcfnYfnHp1M/i8skfhcViuen1xsTGiZ+3rBZHt70pLp8/Lbxeb6k2OVmZ4uinK8VPn28QV86fFie3vyGO7dgoTu//UsTHxxe3A0RKcrI4vnW1+PmLN8T5H78XB9Y8IkycEGvXbxC9Bo8WPQaOFC3btBMajUa88+YGkWU8LarHmcTaVSuuusawsDBx8dxZEdN8lIhvN0GorR6xcePGm77XfxsnTpwQ8+fPFytXrhRCiOLi6v8m5j/1hKiV5hPuox+LRc/OL/G+3E5mzZ4tKlWrKTrfMUzkVah0S/uL3bt3i+zy+cLlDRMPTnv4T1jlbeJqnut/+k8wgiPIvwG/38/69et55ZVX/lRZihvh+PHjNGrUCCEEHTt2vK2nlC6zmdfsDna6PLi0Wnbs2HHDfWvUrosnvzVZI5aisYczadKkP7QWv9/PvHnzaduhM8888+wfGutGWbx4MT1790Uqk2PPrItcZ0Gq1NxQ0YrfcvLkSb799ls++OADHBGJ5I1bR/qABciUmlLFOTZs2MDYsWOJT0zEHFee3MK1hFbvRpt2HYFAtHNO+YpIZXLCo2LQ6I14K7bCYHNToVIVQqRyJHIVBm8c7Tt2Yffu3WzZsoUFC57BaHfjrdAUvdFSSpLE7/czffqjRMUlobP7iG0zHrM7gmXLlgFw8eJFPKHhePNb4M6oSfmKVQD47rvvkKs0aByRSORKlBot3szqGGwu5s2bz9jC8ag1OpyeUNavX8+bb75Jxy7dqFilGhqdHrvLg83lQSJXIpEpyRi0kMTOU5HIlXjyW2IwWdAZLcS1uQd3udpUq14TiyeC9AELsJerh1SlQ6rS4arQgqwRL6Nxx6BSa0lKTUdncSAkMiRyFTpfIlKlBolSS3LPGQgRQs6YVYHoZIUapVpLp85dUGoN6EKTUZo9KA12Hn44IL+yZcsWyleqSmSjweSNW4c1pRrh9e7AW6U9latUQ6bSYi9Xl7BavdHqjShVGhQqNfdPmnJD78jE++5DabDizm+FXKVl1apVnDt3jpkzZ/LII49w8uRJXn75Zbp27crixYtL9L1y5Qr1GjbBmZCHO6sOEdGxnDt3joKadbB6o9Cb7Tzw4DQAfvjhB8rllCdEJseWXpOcsasxOX1lStTs3LkTvdGCt0oHzL44lBodvowCdEYLmzZtKtX+7NmzVKhUFblShS88sriA6qzZswmPiqVcbgVefPHFUhkYn332GTqTlehmI3GlVKZn7774/X7Sy2Wj8yWicUVjdXpuSmf6yJEj10xZPnToEHPnzi0l3XM1VGotWcOXkDduHWZn6B+KNDt58iRDhw2nfacufPrpp7c8TpCrI4IR1EH7O0iQv5mFCxeSYTTymt1BfaOJMbepfsufwZ49e0hNTUUqlTJjxox/VfHEeydMxOKJxJtVG4fLe9NRxDt27EBntJLW/ykiGw0hMTX9ltaRmJZJYpcHA3ZCZBrWhPyA9m5ShVJZpDMefxxbRBKxbcZj8cXcVGG7X+nQqQsWbzQ6dxQ2l7dY9/d63Opn+/bbb6M3mjFYneTlV2bdunVYvVHkjFpBRIOBqLQG7OHxyH+xf/VGM++99x6nT59m6LDhtGrboThj7Pjx4xTUrI3BbKV9py5lZvseP36cOvUbYnd56dd/QCkZjf3799O0RWsqF9S8aiZgm/YdkWvNyA02JHIllasWkF+lOvPnLyhus2vXroAUn0xGaGQM1WvXY8WKFezZs4ejR4+iUKrJGfMqOaNXIpMrbnqfnVM+H3tGbWJbjUWh1rFt27ab6v9P4cKFCzcU/X3+/Hmi4xJwp1bCGhrLwMFDy2x35MgR2rTvSKVqNVi7du0NreHHH39kx44d/ynd/PDouEANpsK12CMSefPNN296jCoFNQkt6Exqn9kYrM6/dW9xLfv7bzd0b/UnaCAH+TcwpH9/4o1GypvNVMnJ+dsLMRYVFTFx4kRCQkJIS0u7bXqtC+bPx6hSYdNo6NW58w0bNT///DMObxgR9fqTW7gWY0QakydP/kNref755zG5wohsMBCTM5SXXnqJXbt2/aF0thulbbv2qGyhpA+Yj7NcXXr06gP8f9r/mDFjb0hf8Pjx41jsTryV2uBMrECL1m1LXF+5ciUGiwNPxdaEyJToQpPJGrEUd24jevXpW9zu6NGjNG7WAoPVicrsIv3OeXirdkKhM5N99zISOk1BaXJhstrRGsyYnKHUrtuA1157jQcffPCqxtHZs2fxhEcRUX9AIO2ufFNq167NtGnT2L59Owarg7xx68gZtQKpNKDdOGHCBOwZtYulQRTGQJu4NvdQvlK14nHLSm88duwYs2bNQmu0kNTtYSQKNVkjXial9ywkCjWeim3Q2UMxhQWc+gkdJ5GamcOw4SMxWmzIVFpUrhhkGhPhdfsF3rWYHLQmKx9//DEOt4+krtPIHLwImcaIkMrReuIxhSYgVWpw5jbBU6kdMqUae2I+3kptCJEpiKh/JxENByOEhKeeeorTp0+zZ88erA43lsSKpPScgdLsxlOlA5bQOEJkcrShyaidUYEDAqmM1H5PkDlkESqNliFDh6HSaAmNiGL58uXEJaag1ugYMHhoie/Uq6++yvjx43nqqadYtmxZicKDDzz4IEqDHVtaTSRyFUPvGlbiWZ4/f54ZM2YwadIkjhw5AgR0Ft9///0yNbPvHDgYizcKV3wWGVm5V5UC+vTTTxk2fATz5s1j165dLFq06KoHVXPmzMGZVIHcsasJrdKejl3+v6Dkk3PnojNZsYXFkZVbgYsXL/LRRx9Rq24Dmrdqy9y5c6lZtwEDBw8tNv4rF9TEllGb6KbDsUen3XDxl9Fjx6HS6FBpdMyY8Xip6z///DNOtw9vRnVMzlAeePCh645ZrUZtXGnV8FZshdPt+0+k4f2XCTqog/Z3kCB/BufPn6d/z57kJCYyYdy4a9rFRUVFDB80iMTQMDq3av2PT3M/depUcfHEvn37/mucQLGJKSR1nx7Qik3Ivmmt2M2bN2NyhZIz5lWSuk/HGxZ5S+t45JHHMDm8eNKq4HB7CY+KQSorW3u3Z+8+hNXqFZCbqNyOu+8eddPzFRUVsWbNGlasWHFDn9XRo0fJrVAJqVRGtRq1r1ncuiyKJQsL1+CMSWfp0qW0btcBuVKFWqPFGp8XqL/SeCimuPLEtBhFZk55mrVsgyutgPC6/dCbLDcsk9av/wDc5WqT3v9pbBGJpYIzbgSpTE7WiJcDhdS1ZkIjo0u1adqiNWHVu5AzZhWOmAyee+654muXL1/GancS2WAAEfXuwO7y3JDedol6Lt27I9Oa0HoTMPriGTO28Kbv4+9mxYoVqLV6FCo1Q363//g9H3/8MVZfdCAY6855WOzOMtvVqF0PT15jYlqMQmc0Xzf466mnn0au0hAikSKVK5j3m0OGfzOVC2oQWqUdiZ0fQGey3lIATEJKOgkdJ5FbuBZHZDKvvfban7DSGyPooA4S5G9Cr1Kxxelmn9uLT6//U3WJboY1a9ZgNpsxmUzX1Q6+UX766Sf27t17U33ad+qCLbEiMrUBqUqPwmAnNCKK+OQ0UjOzSxUovBHu6D+A0F/0ynwFXYmIikFvcaDRGYqjfP8sZs2ahTutGnnj1hFRfwCNmrYAoHa9hjiTK+LOaYTZYuXZZ5+9rpG4c+dOBg8ZyuTJU0pF33fr0QtHdiPi2ozHld8aqdpAiESKJzSCH3/8sbhdo6bNsaXXJK7N+OIIYqMrHJXeTLlhLxHXZnygAKHeREqvx8kcuhi5xoBUoSQxJZ0TJ06wYcMG3nvvvRJG1P33T8IUnoxMY8Qcn49EpsAcm4szpTIVKlUlPCoGd04DnKlVqFJQk2PHjpGYmIjaEUFqvycwxVdASBVENByIKTaXPv36U6tOPUKkMiQyORMm3lc815EjR3B6fKjNDqRKLY6sBqjtEcUFGhVGJxp3DBKFColchTk6C6PNzew5c4CAlqTeaMYUXwGlyYVUpUWq0iHXGklITuHixYtExycFDOTBzyFVatB6E1CqtZTLycNb0AVDVDlkagMiRErWyKXkjVuHTGMkpuVYNK4YZBojRk80iSnpVK5WA09+S8yJlZBrDISGR5KQko43NAJnXjMsSVVQWX2481sjkSmIbzeBjEELUag06C0OMocsIrLhIAwWB2E1u5M59HnM7nAWL15M/UZNiYyJo0PHjvTu0xedxYkjNoOk1PTidyQhJYP4DvcHInPi8zGardd9b0+cOME999zL8BEjOXDg/9g77ygpqrQPV+fu6pzj5JzzDMww5JxzzjknyTCjKGICJYiCShRRVBQRGEwIrlkxw64oCggGck4D/Xx/NPa3s8yQxLBrP+fM8Ujde+tWd3X3e9967++3v8KxX93KV69efc1F84kTJ2jcrAVmm4NuPXtXeY8vXLgQZ1I18qauxxiZidXlZeTosVy4cIGI6LhghYAtPJ4NGzZgMFuJaj6KsJpdSMu88re/UbMWRNTvR+6ktdgiEnnppZeuec2HDh1CJWrJHreajBHLUKrUVywm1q5diyc5sJBK6jWLpLSsq465adMmqhfXJiUtgwGDBgcrw0P8dQklqEPxd4gQvwd3TJtGPaOJNVY7KUbjFabT/+1cvHiRCRMmIAgC9erV+68wT+zYuRvuzLpEtxyL3mSpYAx/PVy6dIlmLVtjsDoR9UaefHLltTtVwdatW1m+fDkHDhzg3LlzV8Rev/Lmm28GTAlzG6Mzmvn444/ZuXMnnbp0p1vP3pUm6/bs2cOEiZO4e+bMm3rYMX7CRNzZjcib/BLOlCIKi2sSFZdIj959q9wN/OWXX5KWlYM3IprUjBzC6/Uhe+zTWLzRwR1ox48fp6i4Jmqrl/RhT2DPaoQhKguF3opSo8Vic5I26FEKSjfhisvg9ddfv675tmnfkYgmQwMFM9kNmDt37jX7HDp0qEKVb0RMHN6a3YhqMRqZSqRW3fpX9GnZpj3h9fsFqt0TclixouIu3U8//ZRadRtQp36ja1ap//jjj6RmZCOVymjavBVvvPEGSo0We1bjy2vI4bTv1PW6rv9m+Omnn9i2bdstf7jk9PhI6vUAOeOfQ2eyBv13KuOXX35Bd9nPx1utNUW16lTazhsRHfQhckSnVFkF/ytmqwOpQkXGiGWkD30cpVpz3T5bf2X27t1LnfqNiE9OY9my5Tc1xurVq9EaTFi90eTkV+fcuXO3eJbXTyhBHSLEn0RmfDwTjCYeNlmw6HQcPXr0z55SkF27dpGZmYlEIuGOO+64YWflW0FRrXrEtp9C7qS16KOy8NTshlSuJL7zdKJbj8Pu8tzwFrOysrKA+3KNTogGC3qri7yp60nsfg8xlRivAZw5c4YPPviAn376iXXr1rFq1aqbCuoOHTpERHQstvA49CZL0OhGI+rIGf8cpvgCtO5YbFGpNGrS/IbH/5V6DRqhNDrQeuKRqUTcNTrjyG1OzToVAyqr00tSr1kUlG5C601AptRQUno74yZMQiZXoBK1jB49mpj4JKKajsCaWgdben2yxz6N1hOP1e7EFhaH2R3B4KHDg+OOvW0czuwmuAs7IsiVSJUi+SVl5E/bgEQioWPHTnTr3p177rmHY8eOkZSajtriQaJQBRLlKi3CZYkRqVJDQkoaEqmMjOFLyBz9JFK5IhisL1u2DNHqxZpSC1NcPjKlSFSL0WSPW405oToyhRJDVDae4i4oDTbkSjUvv/xycK47d+7EYHNhjMsnrmMpuZPW4kipQc+ePXn00YWkZeWRkZUTMBeUylGZXEjkStQ6E127dcfoCEOmEjEn1kCus2CMycad1wyL3YVGq0fjiCS61W0ojQ5UeityjZ6oFqNJH7YYmVqHUm9Ba7Si1urJHLkMfUQaid1mBhLIiYUIEikSuYLqRUWY3RFENR+FXDQgU2rw1upOfslGHDFpxMQloA9PQeuJx5nfCqlSQ9qgR8gvKcPqi+Uf//gHAF2798IQnUV0q3HI1XqycvOveT9Vr1ELV0ZdPNVaERYZzfvvv8/06dMrvI7Xw/iJk3Bl1CWp1wOoTQ4ysvMqlQQ5ffo0hcW1kcnkaGxhJPW8D3tcNvfcex/VatQkrE4vkvs+hM5kZePGjRhtbvJLysi+7RnUGu0V43399ddERMcilcro3K3HdX2XHTt2DLWoJX3YE6T0m4uoM1zxXbNjx46ApEjbibgz69G5W48qx9uzZw86o5nYtpPwFrSkfqOm1/GK/f6cPHmSF154IWSwWAWhBHUo/g4R4vegR4cOzDCa2Ofx0cdg/M27A/+qLFu2DKVSSVxc3F+mCKcqTpw4wbARo2jcvBWvvvrqTY1x6dIlduzYwY8//nhL5rR582YsOh06pZLenTtXuub57LPPWLRoETt27KC8vByXJ4zwur3wFXcmOi6hQp/Tp08Hdn4VtsOZUoPGzVre8JyGjxyFt6gDBaWbcGY1QjQ7SR3wMM6kahUKSP6dhJR0IpsOI6XvHDQ6PTHxSahFLUOHj6wwP6c3HHt2Y5RGBwqdGYlMQXyn20npPw+FSoPFF48ntwkOl5eDBw8y+8GH6Naz91WlHd5//330JguOyCQ8YRFs3ryZBQsW8Mknn1TafvTY21CJWtSiLmhov2vXLjJzC9Cb7RQUFlX6wGDHjh04XF5UGi01atW9IenOCxcu8PbbbwcTtn37D8RbvS15k1/CEZ9Dbl4eEpkCiUyO2h6JXCXelITD9VBWVobOaMbijiQjO6/CTj+/389HH33Etm3bbkrixe0LJ7HHvWSPW43OaLnmTu233nqL+o2b0a1n7woFVv9O6R3TMbsi8KQWERUbf82Kfk9YZFAKMmP4EhQq9f9EgvpWsXv3bt5///0/fedLKEEdIsSfxK5du2jZoAF18vN58803/+zpXMHp06fp2bMngiDQtGlTjhw5csvGfuutt2hZvz59u3at8kfn5ZdfRme0oPfEIldrEQ0WFGqRvCnryBn/HDK54qZkUd58802mT5/O4sWLMVidZI5aQVTzkWTmXJmsO3LkCNFxCdjCYlGKOszeGFyJuWTnFdzUuU+fPs2HH34YlE8AqFO/EfakQiQyOXlT15M3dT0Kpeqqbt2HDx+mZ59+1GnQmE2bNlU4ptZoyR77NPklG5FrDGQMW0xK3zlExSVWaBcdl4hCb8MUV4Bco8dqd/Dzzz8zeuxt9Os/gG+++YZnn30Wjd6IUmtCphKD1eeWlNpIFSrypr5MzoTnkcnkwcTfwoULkSk1qK1eJHIlUoUKV0Eb7JkNkapEfLV7oNQaeO211/jxxx9RqrVIVRq03gTUtrDAA4Me9yFTa0npOwdbRkMkUjnpQx4jY8QyJDIFWbkFnD17lvzCGkikMrTeBHLGP4doC0OjM+CKz8Lh8iJXKIOvqUSmwGxzVNAgLi8vJzouEa09ArUtDF+d3siUaqZMmYLebMeZ1xKZSkR0RpM97llc1doiVWqIbD4Kk9NHw4aNkCrU+Or2Rh+Rjlqrp3uPHhhMAZ3x6JZjA0F8XkskUhmxHUsCGtZKDZ7iLkS1GINco0cl6rB4o9HafGjdcYTX749MpUUiV+At6ogzqRoOTxhSuZK0QY8Q17EEmVKNweaieo1aGM1WVGY3qQPmU1C6CYXOgruwA/Gdp6MSdezevZvTp0+TlpmDSmdCptKSmJR8zUWU3+9HKpORN2Vd4EGGyYaoN+At6ojR4WXJkqXXeedD7779CavTC7XVizOvFfqINESdocrvlUmTJuEpDCyCwhsMoHff/nz33XdUq1GT8Og4Fj32GOXl5aRn5eJKyscWkUjvvv2rPP+BAwcYNmIUXbr3rNSl/T9Z9NhjqEUteqOpyt0V69ato079xgwYNITjx49XOdbWrVtxRCVTULqJtEGP4LnJrb+3kjNnzpCYkoYrIRuj3c29993/Z0/pL0coQR2Kv0OE+D3YsmULVq2WBjYbDqPxlknq/RV5++23sdvtmEymm078/i/zzjvv0LlVK8YMH35FHJGdkMATZivfuDzEGAy88847Vx3rwIEDqLV68ks2kjd1PVKprELM++WXX2LxRFJQuons255Bqzfc8Hx3796N2xeO3uLAbHPizG1KQekmwur1pd+AgZX2sTpcpA1eSP5lv5LPPvus0nY9evfFEZ+Dp7ADFrsTpUpD5qgV5E5ai6g3Mn36dNq3b8+aNWu4864Z2KJSiWgyFP1lSb6LFy/y7LPPsmTJkgoV0D///DPvvvsur7/+OjqjmbD8ZuiMFrZu3XrFtWkN5oBM4ICHMVlsN/TalJeXc/jw4RtK3h47dgyr04Pa7Eap0fHYY4/TpXtPwuv2Jr+kDFdaTWRyOZmjVgTWQFIZM2f+fg+0cqsVEdexhPySMpxxWbzwwgvBY337D8Tk8GK0exgybMQNj11WVoZWb0CuUDJpyrRbMl+/389rr73Gk08+eV2Ffm+//TYGsxWJVI5cqWLhokW3ZB4hbi2hBHWIECGqxO/3s2DBAhQKBdHR0deV2PlPtm/fTnJ6FnaXhzlz5vHLL79g1emYZTLT12iiQVFRlX2//fZbNmzYwMaNG/nss89o17EzFk8kRruHUWMqN0y4EUrvmI6o0xMRHVdpwPT4449ji83Gm14PiUxB9rjV5JdsxGBz3ZDZ469UVr155MgRoj0eFAoVYfX7E16/Hy6P76qVns1atsGT24SYNhPRGc0V5ALik1IJr9eX2HaTkSlUOOKyMNhc9OzZm6S0TGrVa8h3333HE08sRmuyYYxIRS3q+OSTTygoLMad0xhfza44XF4yc6sR33l6ICkdloBUoUJpdCBXiSjVInEdphHVfCQub1jw/AVFtYjrWIopLp/wRoNJH/YEcq0JiVyJNbVuQCuvVg8GDBzIqVOnkMoUxLWfhlSpQS4aLz8wGIVCZ6agdBOxHaYhUaiRSGVI5Soimw5DrlBy//3340yqRs7ENVjT6iI6orA73Xz22We88sorHD16lAaNm2GPTsfgS8Tm8l5x/65btw5Rb0IfloIgkWCMzcNTozMyhRK9Iwy1LRx3YQfMCdXJLykjvNFgVCZX4BoKWtK9e3eMkekUlG4iuc+DuHyRWB1uolvehsYZg1xjwJHTDJlSjUKpJqnXA8hFI1K5MngvKbQm4pKS2bhxI0mpGeickWisXtRaPVpHOAWlm8gcuQyT1YZoMJM7eS0ZwxajUGn44IMPuHjxIgnJacg0OgyRGZcr1xXow1NR6i0MGzYMgDVr1uCMzya/pIzY9lPJKyy+6r26fft2EpNTkSvVGMJTcWY1RKU1oLGFkdz3IWJaj6dZq7ZXHePkyZOsX7+eRx99lNGjRyNX65Ao1Mi1Jjw1umCKr0bteg2rPL/BbMWXXhOd0czbb79dabtTp06xYsUKXnjhhat+ZmrVbYA7pzHh9fthstqvK5D1+/23xOTp1KlTRMXG40kNVMKX3H7Hbx7zt7J161bskUnkl5SROuBhvBHRf/aU/nKEEtSh+DtEiN+LnTt38vzzz1cp3/C/xPfffx80T3z44Ss9Hf6u7N+/H6tOx91GE+2MJjo0r7h7Mi85mQVmC/90eYjU6ys1lv53/H4/uQWFuJKr40zIpV7DJhWOnzp16nIFdXucqcU0vMndmufPn+f7779nx44dmG0OPIm56E0WPv7440rbz507H53JisUdQf1GTaos8Dl//jxz585l4qTJvPXWW7Tv0BGNzoDe4qBD566YrHa8OQ0w2FykZGQT12FaIDme34wFCxbQs08/bJFJuFIKSUnPvKIKdOzY2/DV7hFMqLu84Tww68FgnLdv3z5EnZGs0StJ6nkfNqf7pl6fG6Fvv36orT7yS8pI7vMgVqeHf/3rX9hdHnRmG0mp6SjVGjKGLyF96OMoVOrftbq1UbMW+Gp1JWP4Esyu8KBkxvHjx1GqNOROepGciWuQKxQ3VCX+KxcvXvxTpSN+5dSpU3+anr/f7//TK5T/6oQS1CFChLgm7777Lh6PB41GU8H44XrIyMkjsvEQ0gYvRGey8uyzz5JkCmxtfMfhwm02X/dYly5d4u233+bDDz/8Q9zBlyxZgloqZYrBiE6pxpxYhD2nKXqj+aoVk/+J3++n34BBSOVK5CqR7Pxq/PTTTwB88cUXRBkMvGFzUF1nRK5UU6tuvateX3h0XLBa1hWbHtRwg4CTdL1GTcirXoMhQ4cFjEe0elQaLYndZhJWpyepmdl06NSVmrXrUVpaynfffQeAQqkkd+ILFJRuwmB1kZiciuiMIqxeXxRaExKpDLlCybRp03jzzTdJTEknOS0jGJReunSJDp264s5thi4smagWo8mbuh7RHY8zvzVy0Uh4w0HIRQMrV67k1KlTKJQqsm97hsTu9yCVKwOu3SYLKo0OrSsa6eWKY4lchSO3Jc68FjjcPmbMmIE7p3HQHCY8MprU9Aw6de4SvJ7z58+zatUqVq1aVaGKBAIPP9RaPQqtGbnWhCANVArHtJ2ETK3FntEAqVLEnFILldmNXDRerghXY4sPBONbtmzBYLLgKeqIJSKJUWNuQ6pQobZ48dXuiat6OyQyOQMHDuTZZ58lLCoWiVSGLaM+ojMarTcRndHCv/71Ly5cuIBEKiVr7NNENh0R2M6n1OCu3h5rfB5tO3SifccuQRkUQ0QK7rAoatdrgFytxZ7dBF1YClKlBqWox2h1MGrM2GDSdvPmzZjdEWSMWIq3RmeMVmeVhoHffvstCpUGmVqHp7grctGIqDfhqdaWqGYjkam0mH1x3Hf/LPx+P+vWrWPevHns3bsXgFdffZXbb78dX0Q0ek9cQNtbY8AUXw13UUeUBjsFpZvIGvMUBpOlyvt8z549PPPMMzf1MOg/0ZssZI15ioLSTVi9UXz66ae/ecwb4ejRo6xYsYJXX331D/nuuhbfffcdOqOZ+M7T8dUIONiHqEgoQR2Kv0OE+F/ngw8+oFvP3kyeMvV3Tdjs3buXMI8HQRCoW6fO/0SC5ptvvmHyxInMmTPnihjzeli9ejVmUU+OzsQDRhMx7ooJ0eeeew6tQoFMIqFts2bXFTucOnWKRYsWsXjx4koTgd9//z23jRvPjBl337DBYWX88ssvlJWVXdO08Ouvv+b999+/rt2n3333HUaLDV92fXRGKw899BCLFi3Cl9OAgtJNxHWYRmxCMmZ3BJ6iDuiNFrZv345G1JF92zPkl5RhsnuuMIpbsWIFFm8McR2mobGF4cxvjcUTxZo1a4Jt7rnvfhRKFTqD8arSIbeKTp27ItfoSek3F1/tXvguFwucO3eOPXv2cPHiRRYuWoRSpUal1vDE4sW/63x2795Ndn51zDYHU6aWBO+58+fPozMYie90B3EdSzGYLH+K/OfN8t133/HGG29cdXfyH8Fnn32Gw+1FJpPTs0+/v8R64K9IKEEdIkSI6+Knn36iZs2aCILAiBEjrju4DIuKIbnPg+RP24DVG82bb75JcnQ0jc0WUoxGbhtx49uE/ii2bt1Ksiiyz+MjX9SjsUeg9yaQnVdQ4Uflww8/ZPbs2VVWN2zevBm9xYna6iN96OO48lvS4bLBxS+//IJZFFlisTLeYMRqD0dvtl/VoOWO6XcGArP0Wvgiojh+/DgnT55kWkkp/foPZOHChXz00UeoRS0Zw5eQ3OdBpHIledM2kjboUaRKDb7aPQir0wuPLzwYZDRq2gJnUjXcOY2w2J2YfXFENh2OTK1DkEhJ6H4Pyb1nYbY5WLHiSdSiFpXejN3tY/KUqSiUKvQmMzKFGpnaENSSlkjlgf/KlSg1WoYP///3fPLUEtSiDo1OT+nt04P/fuLECVq1CkhB5JdsxF3YHqXJHdDLVmmYM3cuCrUWpc6MTKlGqlBhiMzAWdAatVbP9OnTGT9+Ag888MAVT/nPnz+PNywce2bDgGN7YUekCnUwER3VfBSRTUcgyBRIZAqkChUylRZTfDWiWoxBqlAxe/ZstmzZwpNPPsmECRNp07YdUpkciVSOIJGSPW414Y0GIVWoeeyxx4Lnnnb7HYgGC6LBQkH1Qn755Rdmz57NPffcE5Bd0ZowJxSitnixZTbCEJNDRlYuZ8+eZevWrVh8MWSOfpL0IY+h0Jrw1uyGXGvCltUYQSoja8xT5Excg1rUcfDgweB5jxw5Qk5+NWRKNSqTi+iWtyFTaXjuuee4cOEC99//AAMGDeb9999nzpw5yEUjnuKuFJRuIqLxECRyJVljniK/pAyNycHEiZO4dOkSd99zLxZPFN7cxlgdLh59dCEGmxtrYiFaTzwFpZtI7D4TrSc+INUyfElA9iWvBY7EfNq063g9H8XfTNcevbDHZODKrIvebCW/sGbQLPPvyvPPP09mbjWatWzzt6jiu1H+1xPUgiAsEQThgCAIX1VxXCIIwjxBEL4VBOELQRCyrzVmKP4OEeK/h3379qE3WQhvMABnSg06de3+u52rd+fOtDcYaarWIAgCeXl5t1Q68I/m8OHDuMxmBusNFBuNDOhRtQ9FVWRk5+Eu7EBs20nIFCqG9q8oU5aSkY2vdg9i2kxAZzBx6NAh3n33XdasWVNBwuJ/if3799OzZ0/sSdUpKN1ETNuJNGjSnK1bt6K3OIhtPxVncnVGjRnLCy+8wB133BHUk87MycdX1IHIpsMxmq1XFBL5/X5mzX4IV1gU5sQi8kvK8FZvy913312h3cWLF284cXj06FEeeOABHnrooSsS/99++y2NmjanenHtK0z8vvzySzRaPQqNHqWor1Jb+sKFCzf0UOfgwYMcO3asQv9vv/32pqqef+WNN94gNjGF+KS0K+RRnnvuOVq17cCMu2f+5TSd169fj85oxhmTSkR07J/6vVO9uDZRzUaQO2ktVm/0dZt9/t0IJahDhAhx3Vy4cIExY8YgCAI1atS4LiOQ5ctXoDWYMLvCqF2/IeXl5Rw9epTFixezdu3a6w4C3nrrLWrWbUDLNu3Zs2fPb72Ua3LgwAHad+qCXqmkq06PIJGQN2Ud+dM2oNbqgzrSb731FjqjBV/11uhM1kp/bMrKytBb3Rhj88gvKSOm7cQKFYsbNmzArFJhtYUR02Yios7AoUOHqpyb3+9n06ZNLF68ONiuYZPmONNq4SnqFNBN1htRabTkjH+OjGGLkUhlqO0RyEUDEpmC/GkbyJ+2AaVKEwzizp49y7x585g5cyaNm7ciquVYcsY/hz2nOVpvInKNAV/d3qg0It7wSGRqHdGtxmFNrY1MpSFr9EoSus5AptQgVWqIbjUOpdFB7qQXie90O1KliFqrZ8WKJ4FAoriwuDb6y67nZWVlrF69mqlTp/Lxxx+zdOlS7HFZ5E1dj7uoE7aMBqT0n4dMJaLQ6HEVdUTrS0IQJEgVajJHraCgdBNqWxgSuQq5aMAWn0vrth04e/Ys77//Ph999BGesAgEQUBt9RLeaDDmpGIKaxQzduxYqlUvRHTFIL0sRZE64GFyJ76ATKUlrmMpBaWbEF0xqM3OQFLc5qGgsBiVRotCZ8ZbqwcytQ651oTWm4C3Vnf0JkuFe3b79u18/PHH+P1+imrWwZlajDO9Lg6XF70jgoLSTQFpFNGE2RPFE08EKiZOnjxJWGQ0nozaqEwu3IUdyZ+2AalCTdrQx5HIFCR0nUFK3zkoVGrqNWrKypUree+996hWVIw7uxEKnYXUgQsCiWZHJAajmWEjRuGIyyasXj/0RgtLly5FpTUgF41ENB6C0mBHH5aK2urDGJ2FUqMLusMnp2eT1OuBQCV7aiEFhUVEtRhDav/5yEUjSb1m4cxvhdYTj1Qpore6GDBoMCWlpcyZM+cP2+pXXl7OkiVLqF23Ho6kgHSNyeG9ZnB48eLFP73iIsSfw98gQV1TEITsqySomwqCUHY5UV1NEIQPrjVmKP4OEeK/h1dffRV3fBYFpZtIHfgI4dFxv9u5ijIyWGmxsc/jI1mrRSaTER8ff0t2SP0ZbNmyhTyrlX0eH1sdTqKczhsew2ixkTlyGfklZejtXrZt21bhuNZgJHPUk+SXbMTk8DJu/ESMdjeuxFziEpNvecX7xYsXGT9xMqmZuYwaM/YPTzT+8MMPWOxOXKk1kKl1uKq3x5FYQGJSKhKpDKPFRk5BIaPH3lZpovXuu2ci12hRaPS0ade+yvO8+uqr6E1WwrLrozdZ2LFjx3XP8fXXX8ftC8dicwZNFC9dukRKehaujDo4U4ooqlmnQp/ElHTC6/Yips1E9EZzhcQxBNabW7du5fDhw9c1hxMnTjB23Hg6deleaWHUhElTUIs61KKWx594ggMHDhAdl4DR5sbu9LBy5UreeuutW1a9+9Zbb2GwOIhuORZ7THqVZpl/FoW16hLbfgoFpZvwpBbx5JNP/mlzya1WREybCeRNfRlbeMIVPlIhAoQS1CFC/E05f/48Y4YNo3paGnfdfvsN/VA9/fTTiKKIy+WqUhv239m7dy+ffPLJTRkLQqD6U280E91qHGE1u5KelXtT49wItes3xFvQkvCGA1Eo1ZisdiLq9yOy6TAsdmfwSXZA06znZU2zfgwZOvyKscrLy6lbvyEypQaV2Y1GZwiaxZSVlWGy2FCpNXjDo4iIia9SeuHf8fv9vPHGG6xdu5Zz584h6gwY4/IxJxSiMrvw1OxObEIyalGHTKHCmlYPXVgK3to9MMbkog9PxRKdSXHt/5cTefXVV4lNSCYxJZ2RI0cGDP0UKqRKDUk970N0x6HQmrDH5aAS9ahtPgpKN5HQ7W5kKm1ggdNoMEqNFolURlynO1AaHeRMXENcx1LUtnCSej2A0+3jzJkzbNiwAXtUMvnTNhDX6XYcnnDUBhtyjQGpQsXdM++hXsPGCJJAAlptC0Om1qEyOYlpMwG51oTK7CFr7CrkogljTA7uok4o9FYcuS1Q28IIbzAAndGERmdEZXYhU6oxx+UjVYo4cpohuuOQq7VBs86VK1ciWtxIFSoUeisJXe4ic+RypAo1Mo0BlcWDVKkhZ8LzRDYdjiWlFnqrG7lKE9S2C284CJlKS3KfBwMBUUp1XnzxRcrLy4PV6t999x3/+te/kEilgYcFJWVI5CqkChVRzUfhzG6EyxdBjVp16NmnXzAhfOjQIRYtWkRKWgaWmCwMEekoDXZsMRkU16qDJywCUW/C4I4huuVtyDU6TO5IJHIlprh87JkNkYtGdGHJiM5oZHL55STzLApKN+FLq8Fzzz3HgkceISIqFplSgzWtLmENByNViUQ0GYZCa0YikVK9qCadunbHnlxEdMux6IwWxt52G9aIRKJajEajM2GyOZFr9Gh9iVgzGpKakX3LguI333yTfgMGMm/+fI4cOUKnrt1Jzcxl/lU0Lhs0aU5Mm4mBhHpu46vqYX700UeYrXYUShXtO3X5r9rOGOK387+eoA5cohB5lQT1IkEQuvzb/38tCIL7auOF4u8QIf57OHToEFaHC09BS2yRKQwfNeZ3O9fSJUtw63TUt1qJdLlYv349NpsNk8n0X1lFePDgQRxGI2P0BuoZjfTq1OmGxxg7bjwWTxSuhFzSs3Ku1EweNx6zOwJnbAa51QoJj44jpf88Cko34YhKqbTa9uLFi+zfv/+mksuPPfYYtqgUknrNwh6byYMPPXTV9r/88st1+XncyPm92fUD/jPtp2B2eIhPSkEikyNVarBnNb6qHJmoM5A+7AlyJ76AqDcFZecq4/PPP2fp0qXs2rXruufn9/sxmq0kdJ1Bav/5aLQ6jh8/zi+//IJGZyC/pCxQNCKVVXgvNaIuaF5/sx5Gx44d45lnnuEf//gHrdp2wJVeh4hGg9GbLBWKxX766Sc0OgPZ454lfejjiFo9M2fOxJ3dKGB27o5Da/Vg8UTSq0+/G55HZcydOxdfQfNgxXvj5q1uqP+GDRto1rINt42bwJkzZ27JnP6dzt164C1oQeqAhzG7wnnjjTdu+Tmul3feeQeDyYJa1NGsZeubzov8rxNKUIcI8Tfl7jvvpKbRxLNWGykGI6tWrbqh/l988QWxsbHI5XLmzZv3u+oobd++HZPDS35JGVljnrop5+kbxeEOyHEUlG7CHpHA008/TZMWrWjQuFkFQ8VVq1Zh9kQR02YCFl8sS5YsqXS8U6dO0a1HL9Kz85g7dy4Q2PalN5pJ6nkfGcMWoxZ1V62c/pVPPvmEho2bYnJF4IhJo1phMWqtIWCy2GgwUoUKR0oRo8aM5cCBAwwbPhJnSlGwuteVXhu1qOWee+4JViGcPXsWUW8gptU4YtsHnr678luRX1KGJakGpoRqyFRaZGot5oTq2CISkavUKM1uZEoNRpMZiVyJ6IrBbHMwavRoFKqA9IZEKkOqUKN1x6M02FHqzNhdHp566il0VheZo54krF5flFo9ctFI7uS1JHS7G4VSxSuvvIJC1BPTbgoJXe5CrjMT3XIsBaWbMMUVoDK5iGg8BGN0Dqb46sg1Bjw1OqPQmVEaHRjDkzBZbBiiMgMGgW0nodCa0TgCTubpQx/H7vaxb98+BgwaTJt27ZEqVHhqdg3KkkhkcmQKFbaM+oTV64tUoSZ1wMNYU+tgSamFVm+iZq3ayFRaRGcMMo0eqVKD6IrFU9wFUW+kb/8BSGVyZGotcrUOuVKDaDAj6k3Ysxrjqt4eucaA2hGJITIDhUaLy+PDV9wZX3FnwqNiKnzG2nfsjEQmD8xNJWK2O5FIpRQW16a4TgNi208hsftMNI4IUgc9GnjfC9qgNNiQKVRIlVpkah2+yBjGTZiENSIJb1FHDGZrhaB+8+bNxCUmY3f5sCUUYIjMRKE1Y0mpjUwlYrM70FpcKLUmEpNSkCuUqDQiNevWp7S0lM6dOyNTqpGpdSiNdmrUrnvdn8GXX36Z7PxCmrRoxQ8//FDh2KefforOGNiabI1IJDYhEXtyDRJ73IfR7uGtt96qdMznnnsOvcWOL6suJqu9gsHof1JQVJPolmPJm7IOa1hc8KFSiL8HoQS1sF4QhBr/9v9vCIKQe7XxQvF3iBD/XezevZuZM2eyfPnyKh/CHjx48Lp2TF6Ljz76iGeeeSYY53733XekpKQgk8l45JFHfvP4v5VXX32V1Mwc8qvXuC5T+O3btzN62DDumTnzpqQT/H4/r776KqtXr660Gtrv97N582ZefPFFzp49S92GjfEWtiW+83R0RssVUoA///wz0XEJaI0WImPigl43Fy5cYN++fddMho2fMBFvcZdAsUKd3pUW3PzKiNFjUWv1aLQ6li5ddsPXXhlbtmzBaHcT33k65ogUImPjUai1ZI9bTUq/ucg0eqoX166yv9XhIqHrDNKHPo7m33a63iouXbqEQqkic/STASk9rZ6ff/6Z8vJyfBFR+Gp0wlutFUmpGcE+fr+fbj17YXZH4ozNIL96jRtOSp48eZLImDjcydUw2j0YzDbSBi8M+hC9+eabwbYHDx5ELerIHLmM5D4PYjBZmDt3Ls6kamSOfhKJTEHe5JfInbQWuUJxSxLCO3bsQG+y4K3WGqPdw7Jly6+775dffonOZCW65VicKUX0Hzj4N8/nPzl48CCNmjYnPCr2uqq7P/30Uxo1a0GL1u3YuXPnLZ/PuXPnOHDgQEh/+iqEEtQhQvxN6du1K9MNRvZ5fAwwGLnrrrtueIyjR4/SvHlzBEGge/fuwQDrwIED/Pzzz7dsruXl5WRk5+FKzMXqi2XwVYKmm2X37t2MHjOWaSWlHD9+nHETJmHxxeBJq0FUbHyVW+n8fj8LHnmEZq3aMnfe/Cp/cIYMG4ErtZi4jiUYrE66tm+PXRQRJRK8eS3JmfA8Gp3hqouA/fv3k5VXgEKjRyKVkTV2FfklG9FbHMjkCvKmvkze1PVIZHKqFdYI6qCdOXOG/gMHk56dz/DhI3jssceCRoK/snDRIiRyBTKNHntmIwSZHHt2U/JLNmJOKEQik2OKySZ77NOYEwtRqgMyH/asRpgTC5FrzUhVWrLGPIU3sw6PPfYYa9euxRmTRu7ktaT0fxipXIE1tXYg+K3VnRat2qASDUiVIkq9FZvTg1ShJqHrXcjUOmzp9TDaPSSnpmPPbEhy79koRQNakw1fQctAtURWDhKZHF1YMrlTXkYfkR4wVZTJiYqNZ/r0O0lNz0Jl9pA+9HGc+a1QaHTIVCK+un0wxeWTkJxKVGw8vsL2ODIbojTYyC8pI334EgS5HEEmR+uORa4xkNj9HpRaI2abA5PNSVhkNE8+uZKmLVrjzG5ETNuJSBUqwhr0x1e3D1KFmrz8akgUgSRtRJNhxLSZiFSuwhQf+He5xoAjuwnuwg6XdfE2YnZFIFeqglIsCpU6qDn4448/olCLZIxcTniDAQhSOfasRuRP24AjpZDCwiLkGj1SeUA721WtHfasgKFkbNtJiEYrkU1HkDpwARZfNJ27dKV2nXoMGjSY7du3B++J8+fPk5GThyMmDa3JhsFkQa7RE995euABQXwBCo2O/JIyUgcuQKbSkjNxDfGdp+Py+tBbHLgLWiFTiST3eRBbej2GDbvys3vnjLvxRcZQv1HT4ILihx9+QGswE9fpdnzFnahWo2aFPosWLSIsrzF5k19CbQtHbXYjU+uIbTcZT3pNli+vOkD+6KOPWLZs2RVJ7/8kmKCe/FIoQf03JJSgvr4EtSAIAwVB+FgQhI/Dw8N/46seIkSIvxILFyzAoFJhVKsZP2rULR//+PHjNGvWDEEQGDZs2J+mX3vixAl0BhNxnW4nqtkIfBFRNzzG+fPnadC4CVKZnPSs3Fu6DoJAdWyL1u3IzK1W6U7LqVOn4c5rFti5V9CS8RMmsmvXLtzeMHRGC0mp6VeteP7ss89QqEUMUZlIFSpKSkoqbbdnzx5EvYmcCc+TNuhR9MbrN7u/Fosee4yUjGxUoh5f3d5IlRqyb3sm4KWjUBEWFcPCRYsq7fv6669jd3rQGYy/m8fIPffdj6g3ojNZK6xF9+zZw8DBQxk2fGTwfff7/XTv1QetyYpKIzJw0KCbepDx6quv4opNp6B0Eyn95mK0OrBFJuPJa4rD5b3iPZ0zdz5KlRqdwchLL73E2bNnadikOTK5HLlSTWzbScS0Ho/Zar/mzsATJ07w5JNPsn79+qsmVL/66iseeOCBG46Tn3nmGbxpNQJ+NT3uJSOn4Ib632rOnz+Pxe4ksslQwuv1ISI69k+dz9+VUII6RIi/KVu3bsWq1dLUZsem1/PPf/6T8vJyBvbsidNoolndete1devSpUvceeedSCQS0tPTmTxhAga1GoNKxR1TpwKBH65OLVvSrV27KxKj18vp06dZtWpVpT+Sfr+fX3755aZdwc+ePYvLE4a3sD2ujLrUrFMfv9/P+vXrWbJkyS0xVCiqVY+4TrcHpAUy66CSydju8vCJ041MEFCLekaNGXvVMWrXb4i7ejsSu81EqhRxFrQhtt0U9EYzDZs0Q3REIbpikGtNSOTKG9JVszndpPSfR+6kF5Fr9DRt1hyZSkQilSO6Y1FpRDzVWl82FexA/QYN0ehMFJRuIm/qegRBgtLsJqx+f8zuSMrKyjhy5AgOlxdvXhOs4QnUrVcPa1wOORPWYEuvj9Fsw52UT/rwxUQ2G0ViaiZmmwOJVI4luThg0NdoMDFxCWgNZhQ6M1qbl9r16vPQQw/x0UcfYbTYCKvXF40tDEEQkCo1pA54mIQud6I1BILmV155BYVai0wlojNZadC4Ke5qbdFHZiBVqDG6o5EoVKQNfpTkfnOD1c8ytQ6ZRo9Mo8dbsxtRLUaj0FuRypUVKhYAImLiSR0wP6BR7YwirH5/8qasQ6mzIJXJkIlGBImU3IkvkDd1fcCU0eIhbfBCrGl1kYsGpHIVcpWIzuIkPTOHgsJinMnVcSZXp1pRzeB9f/jwYaRyJWqLF2NsHkq9DX14CjkT1qDQmpGLRqRKDQnd7sYclYEglSFT64hsNgKNMwqdwYzK6sMUXw2FRoczvQ5htXtgsTsrmKi88847WMNiLyegH0GuNSHXGDDF5RPXYRpyjQ6VqCWh6wx8xZ1RiIZAgrrTHejNNiKaDA3cL0Wd8BR3wZVRhxkzKlYvbN68GZMzjNSBC/BWa0XHzt0AeO+997BdPnfakEU43L4K/bZv347OaMaaUgvRGUV+SRmJ3Wei0ltwecJuqnLm4MGDFR5Evf7662gNJmQKJR06dQ1JfPzNCCWoQxIfIUL8nfH7/ejVat5yONnu8mBUq29JJfV/cvHiRW677TYEQaBBgwZ/ionZnj170Bot5E1dT/a41SiUyhuucBw6dBhSZcBwW21206df/2t3uoVMn34nrsx65E/bgDurPtNKSunbfyC+Wl3JLynDnVmX2bNnV9n/008/xWB1EdN2EvGdbsfpCau03a8yEpkjl5PY415sDvctvY4lS5bguyz1YU2vd3kXoxJLfDWSes1Cb3FU2Mn6R7Nnz54rqtdPnDhxhafKN998g85sI3fyWtKGLMJott7U+Xbu3InOaCGu0+14ClrSsElzVq5cyQMPPMC+ffsq7XPp0qXg/bthwwZEnQGZXE7LNm3IyMknM7egUv3qf+fcuXMkpabjTq6G1RfLyNFXX6PeDD/++CNmmwNvbhPM7gjuf6Dq+/Nq+P1+jhw58pvj9J9//jkg1zJtA3lT1iGVyv5ypo9/B0IJ6hAh/sb861//4plnnglu6V+6dCn5RhPvO1x0MJoYO/z6K5U3btyI2WxGEAQeMpn53OlGq1Ry4MABPFYrJUYTY4wmkiIjb+k1nDlzhoLCYjRaA3aXh88++4yPPvrohioXdu7cicnhoaB0EzkT16BUqX/zvC5evMisWQ/SsUt3XnrpJZYtW47B6sSbVReLzYFOpWKdzc5qqw2TKLJv3z7OnDnDypUref755yvdAhYRE09Kv7kBgzt7BFKlmvjkNDZv3syJEyeQSGWY4qsHTAUL2zNixEi++eYb2nXsQpv2na6qe+aLiCa+0x1kjnoSpUZLp86dSU7LQK5QoRF1LFjwCC5PGFZvFHaXh+3bt2M023DkNseWXi+gD60UkSo1yJXqoBHivn37mD17Nk8//TRnzpzBYHUgkSvRR6Rj8saiUIlBk8O4xCTUWj1JvWeh0Fvx1u4R0EBOqYlUoUaQyZGLBhRKJe+//z6pmbkoRD2JvR/AGJ0dGEclEtViDLaMBkgVKsrKytDqDag0Wpq3bM25c+f44osvMNscyNU6kvs8SHSr8YFqY7UOucaAs1o7JJflPXInvkD2uNVIZHI0rhjkohFjdBZmm6PCImr6nXdhcoZjjMlFrjEgyBTINXp0YclIlRosqXWQKtQojQ7UVh9SpQZTfMClPKr5KMKj47j99tsR9SY8mXXRGc384x//4JFHHuGRRx65ooLf4fKitgY0wNMGPYpMqUEiV2KIyiK/pIzIJsOwJNXAndMYiUyOLbMRWk88EpkSQa5CF5YSfJCRNXYVBaWb0JhdqDRaDCYL77zzDt9//z06o5nEbjPxFHfFEJlBXIdp6M028gqLWbFiBatXryYlI4f6jZvSvUcvFEoVeqOJpOQ0NLYwolvdhkJnRpBIyatWdIWr+lNPPYU7pfplzcGpVC8OmMucO3eOlPRMXPHZmBw+pt955Q6Pjz76iD59+iIaraQOeBhfza6kZeZcVSZn//79bNmypcI8/H4/ffoNQC3qEHV61q1bFzSkdKcVY3ZFMK30djZt2kT3Xn148KE5wc+n3+8PfnZD/G8RSlALzf7DJPHDa40Xir9DhPjfwe/3Yzcaec5q5y2HE4NKfV0ydDfL4sWLUSgUxMfH/y5b66+G3++ncbMW2MLiMDl91ywYqQyXL4KEbneTX7IRjSOS2nXr/Q4zrZpjx46RX70GEqmU3IJCjhw5wpBhI/AUtCRv6ss4k6sxf/78Kvvv2rULrcFM2uCFRLUYQ3xyWpVtZz/40OV4z3zLjd527dqFwWzFW70NZncks2bNJjE1g8Qe9wVkLeIyefnll2/pOX8LY24bh1KtQS3qmDt3Lt9++y0QSL6KOiNpQxYR12Ea3vCbX/8+//zz5FUvpn3HLjdUgHH69GlUWiOx7aeQM3ENGqOdDz744Lr6fvLJJ1g8keSXlJE5chkmi/1mp39Vdu/ezdy5c1m/fv0VxxY88ghJaVm0btexShPJY8eOkZ6Vi0ojEhkTV2XS/noImtfHZWGPSqFthxvXlg/x2wklqEOECBFk9uzZdDSa2OfxUWIw0qtjxxvqv3PnTqQSCRJBoKeoRatUsmvXLsxqDXvdXna5vcik0lv6NHLJkiU4E/PJL9lIeP1+mMxWEk0mLFptpQYilXHu3Dl84ZF4ClriTCmiXsMmv3leM+6eiS0qhahmI9FbHLz99tu8/fbbLF68mB9++IHnnn0Wj8VCuMPBpk2buHTpEsW5uRSbzWSZTPTo0OGKMefMmYfe4kB0xaI02DFHZ9K1e6/g8YJq1TFEZZIxYinmmCzuu+8+vOGRhNXpRXi9Pri9YVU+Xd6yZQtqrT5QqaDWodBZkKlE1KKOhx9+mFbtOjB1Wgkff/wxS5YsweH2otYakMiVaGy+gGyGQkHmqBWkDV6IWtQGz+X3+/n222/58ccfcYdFojTYsWbUR6YSkWsMKHRmfLV7ItfoMJotAeNCrRmpQoW3ZregAaUjpxmx7aag0hoQtXq03kSUBjuCIKB1x5E3ZR3uwo5IVWJAh1o04PZFkNB1BrmT12Jy+Ni8eTNr167lgw8+IK9aEWG1uqLQWUjpP4+8KeuQi0Y0zmikah0SmYKknvcT33k6ErkSmVoXDJB1viSGDB0KBIxiHn74YaZNm8bo0aNJSAokf9NHLCWl/3yMFjs2hwuzzUHt2rWpW7cuc+bMwe0NxxGdgt5oYevWrQwZOpywen0DVfY1uzFu/IQK79HBgwd54oknePnllxkyZAgSqZzIpsNx5DRDphIJq9cXrSee7NuewZnfGrnGQHhUDK1at0Wu1iJRqJCLRlQmJ1KFirQhizDF5aMPT8WV2xS5SiR7wvMBh+nqNQBYvXo1Zocb2eXXVOuKRWswk5yeyXvvvXfFfXT69GnKy8vJzK2GObkmOl8iOkdYUFbm22+/ZcuWLcGE7rFjx4iKjccZnYrOaK4QoJ46dYo1a9ZUqSd94MABmrZojd0dhtFip1qNmuzZs6eqjyRvv/02epMFZ3QqHl948CHW559/jtHmJnfSWpJ63ocvIprNmzfjjEmloHQTqQMfwe7yojNZiWg8FIM3juEjRnH+/HmKa9dDazBjstiuGfSfO3eO1atX88ILL4SMUf4L+F9PUAuC8LQgCD8JglAuCMI+QRD6CYIwWBCEwZePSwRBWCAIwi5BEL68lv40ofg7RIj/OTZu3IjdaESvVrPwD9CJ3rp1K1arFbPZfEvMzFaseJLuvfrw5JMrrzh26dIlBg4Zislip6hWHX766SfeeOMN3n333Uqrpy9evMiHH37Iv/71r0rPVVBYTFi9vmQMW4xcNPDss8/+5vnfDP8eX/z888+kZmQjSCQ4POFk5VfnmWeeqbLv/PkPY7E5iYlPYv369TRv1ZbiOvV56aWXeOyxx3jttdcAeGLxYtSiFlGr5+mnqx6vKpYuWUKdvDyG9O3LyZMnrzj++eef0759ewYNGsSxY8dYsmQperMNZ2wGcYnJQQnDP5tvvvkGrdFCzvjnArsSRQNao4UZd98DwCOPPorBZMETFsE//vGPW3LO8vJyPvzww6B5OgTu5W3btgWT47/y3nvvodAaiet0O7mT16LUWyvE7mfPnq1yp8CBAwfQGc1EtxqHr6g9+YXFt2T+18v777+PweYiqed9eHKb0qlL90rb3X///bjSa5PQdQZy0YBGZ6xUAud6OXv2LKtWreK5554LVU//SYQS1CFC/AXZu3cvn3322R+exHj33XfR642YRR0WnY5PPvnkhsdYtWoVSrkcQRDIzMjg8OHD1MzLo7bJTDWTiXZNm97SOa9YsQJHXCZ5U1/GV7MrTlHPD24vc01mGhdf/4/p/v37mTathHvvvbdKvekboXHzVsS0nRjQWy5oyZw5c6ps++OPPzJnzhxMajV73V6+dnmQS6WVBg2LFi3C5I4kd9JaUgcuQKM3oVJrqFGrLj/++CP1GjbBZHPQvlNXDh06hFyhDOoYK9UiR44cYcbMe6hdvzEPzHoQv99PeXk5q1atQqPVE9FkWNBQMKbtRFQGKxqDmagWY7DHZtGocVPUOhPW1Nrkl5ThLepI7br1WL16NVK5gqwxT5E+9HFUGpFLly5x8eJFGjZuhs5kQyZToDS5iG49HoXOgikun/ySMsLq9cMQnYVcrUUl6gIJeLMLmVqP2uIlvvN0NI5IwhsNJrbdFKQKNVKlhpjW4zHG5KCPSL88542E1e+P6I4LJLXr98NsdxHXYRo545/DYHXicHlwJ+ahFHVYHB4sTg8KjZbYdpPJGL4EmUpEkMpJ6TcXd1FHpEo1Cr0VvS8RldaANa0u8Z2nIxeNyBVKvvjiC9y+cOyJ1VAbbKRnZqNQaZBpTSiNDqQKNbHxCVy4cIGwiCiUBhsSpQa12YOoM7BgwYLg0/6HH16ALTKZhC53Yg2LZ+nSpcH3/fjx43jCIjDHFyDT6FEZHTgz6qFQi7Ro1YYRo0ZjsLlQaE1IZHLUOiPLly8PBp+tW7dGbfXhKvh/mRaJXIXGEYXFaqdX796YXeHkTnqRyKbDKapZh6+//ppadRuQmVtARmYWOqMFmUJFbPsSYttOwmJzVBnYDhg4EIlCiT2zEVKFCrVWj1qrR64WsUcmkZiSFlyUnDp1is2bN1/VsLAy2rTviDuvBcm9Z2OwuSpNmP87Ldu2J7LpiMD1Z9Vn3rx5wGWDF7Od7NueIa7T7UTGJrB79250RjMxbSYEqvHlSuzp9Sgo3URch2kotUYWL16MIzaD/GkbiGox5qru8n6/n+La9XDEZWKPTKZ9py43dK0h/nj+1xPUv8dfKP4OESLEb+XfzRMfffTRmx5n9erVmJxhRDYdjtHhuyJp9eyzz2KLSCJz5HK8BS3o3bdqSY5Lly7RuFkLzO4IdCYrsx+8MqZ/7LHHMNmcqLV6ppWUVjrOuXPn+O677ypNfO3du5eWbdpTo3a96y6wuV6atmyNJ79FwGDRZL0uCcDktEzCancnovFQZAo1nsy6mJxh3H33Pag1WtKHPk7qwEdQi9obWq++++67eHQ6llmstDCaGNb/yte9TbuOOGIzcacVk5yWSXl5OV9++SXr1q1jx44d7Nu3jw0bNlRalLB7924GDx3O6LG3sWPHDj7//PObloC8Frt27UJrtJA66BFkah25k9eSOfpJVGrNDUnEHDt2jIZNmmO2OejRu2+VidELFy5QvagmFk8kWoOJlSuf4tKlSzRp3hKTMwyt0cK8eQ8H2//8889otPqAZKNciTssIrjua9mmHTK5Ao8vnH/+85+Vnm/Lli3Urt+I9h27sH///uu6lt9q/nfixAnGjRtHXEIiOkc4uZPXEt95Otn5hZW2nzVrFo7UYmQaPYnd7yG570NotPpbspYP8ecQSlCHCPEXYP/+/TSrW5f0mBj69e6NWaMhUm+gSe3af1iS+vz58zjdXsLq9MRTrQ0JV9nadS38fj8LFixAoVAQHR3NBx98wNKlS1m5cuUtDxLOnz9Pk+YtkUpluLxhRIhalpit9DcY6dau3S09143wxBOLMTp8eAvbozOa+fLLL69oc+bMGUaOGo1aq8eVWgOZUoNBJWJQiYS7XJWOe+jQoYBeV41O6Ow+zLE55Ex4HndWAyZOmgwEXv8Jk6YQHh2HwxOOPTYTZ0IuxbXr8cgjj2CNSCSuYwkWXyxPPvkkvTt3JtdkwqLRYYzORmXxkDlyOZ6iTgF5ipRawcSc2eHFntkIU3w18qa+jCunCaPGjKVH777oPIlI5EokMgU9evYE4M0338Tqi8VXtzdqixd3USfkohGtLxGtJ56cCWtw5DRHqlAFFiRqPWprGHLRiESpQabUoLZ4kF/WcJbIldgyGmCMzqagdBMJ3e5GobehtnqRKjVIL5sORjYdjkJnRalUozeakckVNG3eEk9qIUk970NpdJLafz6u3GaYbE7kam2g/+W/3MlryRy1AolMHpDRGLwwYNyY0QCNMwqV2Y1MqUZjMCNXa5GLRmwZDZBpDEikMiRSOSprGNb0usgUKjp37Y5MJWJNr4dUKaLQW5GpRDKzc2jQuBkdOnVl7969lN4xnfyimrRu044nn3wyGKS++uqrmMISAlIcjkiSe88KGOEkV2Pt2rVAQPJiy5YtlX5n7NixA6lMjjE6m6wxT2GKK8Bd1BFbWl3atG3HxYsXScvMQaYSEQ0mPvjgA+ISUwiv34+4DtPQGUx8++23qEUdeZNfImfC88jkiuD8jhw5QvtOXUnLyqNJsxYoRT1yjR53YQfUFi9xHUvR+QLJ9/ySMlwJ2bzwwgs39dl64403SM/OQ6UzkdDlTgpKN2GISGXVqlVV9tm/fz8JyWlYU2phiMpCECR4w6OCAfekKdOQK5SYLDa2bt0KBBavco0ea1odoluPQypX4S7siNoWhsHh4+6778YaFk/uxBeIqN+Phk2bV3n+XzUb86dtIG/ySyFdu/8CQgnqUPwdIsR/C5988gm18/OpkZXNO++882dP5zdz/PhxmjZtiiAIDB8+vMLv5b59+1i6dOk1NXSHjRhJWL1+gYKFun0YNXpMheMLFy7Ekx6IbyObjqBaUTFtO3Zm/IRJVyS3vvrqK4x2N3lT15M+9HFM1opyBx9//DF6k5XIZiOwx2YwZeqVBoO7du3C6fZhsDiIiU/k4MGDFY5n5VXDV9yZmDYT0RnNVxz/LcQlpZLce3ZAIiM+iw0bNgSP/fTTT+zYseOKHZYaUUf22KeJ7TANfVgKBaWbSOr1AAkpGajUIlljV5E5agUKparC2s7v93PnXTOIjE2gZZv2V/gZLVu2jBZWK/s8PhabrdQruNIYT64ISOzll5RhsDj49ttvGTJsBAq1FqVoQKbU4IzNRG+yVLgPLly4gMcXjq9GR1w5TZCrtZhdYWTnVatUiu3s2bN88sknVcpHXA+Tp5YglcmRyBTofMlYU+vcsC732HHjcWfWI3PkcmzRacycObPSdm+++Sa28HjySzaS1OsB5GodTZu3xGgL3JtpgxdisTsr9HnnnXdo0rwV3Xr0Ckr0PP/889ijUsmbso6IBv1p3LzlVefn9/uvuX7//vvviU9KRSaT06lr95vOX+QWVA/s2izuijEmF43Jid5s46mnnqq0/YkTJ8gtKESQSMke+zQ5E9ag0oi3RMv+xx9/JC0zB7lCSZv2HX+3Bx0hKhJKUIcI8Regeb16DDaaWGO1Y5RKmWsys8ftJd5ovGZV4K3ihx9+QGu0kF9SRt6UdUik0t9sNvDOO+/gdrvRaDSsXHnl9rpbyYULF3jrrbdQabSoDHa0euNVNZf/CNavX8+MGTP49NNPgUCA+/HHH+P3+/nnP/9JSlo6apMDS3Ix+SVlyMWATlhSz/vQaHWcOHGi0nG//vprxo0bT3FxMbakGuSXbMRX3Jmhw0YA8Nxzz2ENiyN14AJcGXVp2LgJS5cu5ezZswwcPJSw+v2CMhLjJ0xEVCr50uXhC6cLrUpDZEwcKo0Ws82B0R2DXDTgyGmO2mjHExaB1h2P6IxGECTEJ6Vy4MABqhXVQKE1YYqvhlSp4d577wUCSVOj3Y3K5CKhy10UlG7CnFiIIJWhMNiQSGWIzmicea2wOVwodBbyp20gbdAjAd1pqZwuXbsxZsxYRL0RqVIkrvN0pAo19syGqMxuJFIFglyFIJMjUajx1emFPasRctGELiyF8OhY3nzzTVavXo3e7EB0x2GIzAgm3eWiCblGj0ytI7zREGyZjZCLRpQaHSqNiCWhGubwJNQGKznjnyO8QX+kSg2u7CYUlG7CmdcCqVJErrMgkcnJHPUkGcOXIJHKkcjVKFQiEVGx6HxJyNR69BFp5JeUEdt2EnK1jqgWo/EVdSA6LpEPP/yQ9KwcXCmF2GPSaduhE+Xl5Tz44IPIlSqimo9CY4/AlFCd6Fa3oTNaqtxu+p9s27aN+MQUFCoNKouH3Elr8dbqgVShRqZQIdrCSOk/D3tyEeMnTEKj1ZM15inyp23AYHXy9ddf07lbD8yucIx2NyP+zTClc7ceeHIak9h9JjKNnoSuM8iZ8DxSuQqlzkRE4yGY4qvhqtaG1AHzMdrdN/XdduLECXQGE3EdpmHLbIhMKaIPT0WuEnn33Xer7JeelYs7vyVKowOdL5m8KevwFravUDFVXl5eofLj0KFDqEUdmaOfJHXgAuQKJaLFhTmhOiarnQMHDtCtZ2+kUhkR0bFX/b45d+4cFpuDyKbDCa/fl/ComBu+9hB/LKEEdSj+/jty5syZoFFuiP8O/H4/XpuN+41m5pssWPV6zp8//2dP6zdz8eJFxo4diyAINGzYkKNHj7J3795AkUZWXQxWB089VfWD6bKyMvQWB97iLujNdjZu3MjMO++ka5s2vPzyyxw5coTouASs3mi0eiOi3khk0xG4Uovp1rN3hbH279+PVm8iuc+DRDUbSWxCcoXjixYtwpfbOBBXdiylZt2GV8xnwOAh+Gp2CRgWZjfknnvuqXDcYLKQOWoF+SVlmF3hfP7557/h1avI3LnzMdrcuJOrER4VE/TheOqpVYh6IwariybNW1ZIKg4cPBRrWCy2yGTkai0xbSfizqxHl+49uXPG3ahFLWpRy4MPzalwrrKyMszuCFL6z8OT04i+/QdWOP7TTz/hsVppbrXi1GqJT0pFI+po2aZ98L5Ny8zBW9iW8Pr90egMjBkzBo3BiiOvBQWlm3DkNsdT1InwBgPo3qtPcOy9e/eiM1mDa1lBIiVv2kacsRm8+OKLFeZx5MgRYuITsXqj0JsszJs3j9WrV1cqH3L8+HE+/vjjKtdlixcvxuCOIr7zdERnNKPHjKm0XVV079WH8MtrM1t6fRRqDWNuG3dFuy+//BK92U7aoEcJq9cHXVgylsgUVKKOlP7ziGo+itjElGueb/Xq1cEdgJFNhtKgcbMq23733XdExcYjlcpo3Kxlld8tbdp3IqxWN3InvoAtMvmmZDYuXLiAIJEEd8JmjFiG3mSttMjrP5k6rRStwYzOZK2wPvkt9OrTD29hO3InvoAjLpNly5Zdtf2BAwf46quvQjJ+v5Grxd9SIUSIEH8I+/bsEerJFUK+Uin4FAph24ULwrcXLwrHLl4UTCbTHzIHt9stREVGCj+8dK+w94W7hAaNmgpS6W/7GigsLBQ++eQTITc3V+jevbswcuRIoby8/DfP9ccffxSOHj1a4d8UCoUw/e57BW+DQULGqBWCITxFeO+996oc49KlS8L8hx8WBgwaLGzdulUQBEE4d+6cMGH0aKFZ7drC7FmzhHfffVe4ePHiTc+zWbNmwtSpU4XMzEyh9PbpQvWadYX6TVsLrdq0F/KrFwmHdXECUrlwcu924dg3HwiXzp0SDOFpgtabIAgSqXDq1KlKx42PjxfCPG5hx8cfC9Kd7wv/vL+tcH7nW8JtY0cLBw4cEObNf1iQWcIFrStGEESzsPnNt4R+AwcLxbXqCI0a1BN+eXuV8PWyscKxzzYI7dq2EdITE4X5Z88Ia8+dE0SVQnA6nQJ+vyARJIJMqRASe9wnXDjxixDmsgrnBZVgjMsTJDKZkJNfIHy940vBbrcLZ85eEKJajBESOt8hGMNTBK1WKwwbMUqYed8DQoPaNYULp44K+/+xSvjpvTXC8V3bBLlGL/jPHheUBptw7siPwoFPNwogCJfOnxZO//StcGLPl4JcNAoqg1V4bs0LQtlrbwjFNYoFiUQQdr14vwB+4czBPYJUphTkol6QCAhel1NQ6syCRCoT7JmNBP/Fc4LWmyDs27dfaNO1r9B3wGBB4KKg9yUKZw7uEb5cOFjYtXaW4KrWRnDkNBcEQSIc/OwV4dAXrwv+i+eF8gvnBb9ELpz5eZdgUV0SGtevI3z6YBfhp3+sEoRLF4ST+/8pXLpYLgjlZwXBf1FwZDUSBEEi4L8k4L8kCIIgqAwWoUnTJkLN4iLh1I87BQRBuHD8oHDh+AHh9C/fC1KZTLhw4rBw+JuPhN179gh1GjYRdn79jeBtPk4wZbUUXnpxjdC5Ww/hrrlPCDpfirDn1ceEc0d/EU5+/5nww2uPC1IJwfviyJEjQu16DQWT1S707NPvins3OztbeOO1TYJaoxH8588Inz/cV/jxndVCdKvbBIlSFLS+ZEHniRe0EZnCjq+/FgYNGijsfnqysHvVBCEtJVmIjY0VVj25XHjh6eVCSmK8sHzFk0L1omLh1KlTws5vdgn6+CLBGJ0taB1RwskftgtnD+wWJBJBGNyvjyDsfF04vftTQfHLl8KxVx8Spk4YJ1SrVq3S+/ujjz4SwqNiBb3RLMya/WCFY0ePHhX8giDIRKOg9SQIly6cFUR3nKBWq4TExMQqP4v/3P6F4KndS3AXdhBkalGQyBSCTK0Vzl+4EGwjl8sFiUQS/H+r1Srceed0Yfsj/YVvV04Qli9fJtx7xxRhYJvawofvvSPY7XZh5fKlQnn5BWH3rm+E+Pj4Ks+vUqmE11/dJMRe+k5I0RwWXtu0scq2IUKECPFn8NADDwhWo1GwGU3C0sWL/+zphLhOysvLhQNHjwqtNBqhqUYjXDh/Xjh58uSfPa3fjEwmE2bPni088cQTwptvvilUq1ZNWL58uSCGZwi+FhMER50BwmNLllfZv3HjxsKLz64S+taOFV5as1p47623hPWzZwuZm7cI3du0ER599FFh+xefCa+ue054bOEjgiksQXDmNhOs+e2EDz/6uMJYHo9HWPjIw8LxzQ8L4r63hTXPPl3heJ06dYTj334o7HvtMeHQW8uEDm1bXjEfrSgKl84cE/wXzwv+sycEURQrHO/Tp7ew97nbhb3PlQhhbruQlJR0zdfohx9+ENauXSvs3bv3qu1GjhwulK1bI8y5fYzw+ScfCwaDQRAEQZg4tUSIbFcqJAx+Qnh/2+fCtm3bgn0WPvKwsGLhXOHhe0uFp59cJuj3bhGM5QeF/JxsYdqUycK+vXuEH/f9IIwZParCufbt2ydonNGCzhMvaMIzhN17f6hw3OVyCdu++kro+NBDQp1WrYWTok9IGrpEeH/HbmHx5e+dVza+LGTbEX5+d7WgTygWFi1eLkg1euHSmROCv/y8UH7qqHDx3Cnh/P6vhOjIiODYHo9HcLucwg8bHhK+fe4uQWV0CNsfHy4c3vet8P7771eYx7PPPiucUTuF2H6PClJbjDDxjnuEUaX3C9WLagoX/i023LVrlxAdlyA0adtFiIlPFL7//vsrXt+dO78R9HGFgjm+QLCm1RHOnD1f4fjJkyeFqdNKhGHDRwrffPNN8N8XL14itGrbQXDZ7cLxbWuFz+b1Fk7s+UJI6jNXWPDwAuHEiRMVxklNTRXuKJkqfLtqsnDgk01CTMvbBLU9UmjRtLFwuGyWoNq9RXj+maeqvhEu07p1ayE10iV8PrujcHLbC8Ks+2ZW2XbSlBLhojdPyJm8Vvhk517hmWeeqbTdmbNnBJnWJEiVakGm1gpnz5695jz+E4VCISSlpAvnj/4k7H5lofDdS7OEpk2bCKmpqdfsO+Ou6cJXn38ifPrR+8K8h2bf8Lkr49TpM4JcaxakSo0gU+uFM2fOVNl2/fr1QlRsvFBUp6FQs079CvfQXwVAOH369J89jd9GVZnrv/pfqIIjxH8bSxYvxqnVkmexkBgRQWZ8PB6LhXkPPfSHzuPYsWPMmzePRYsWce7cuSrbvffee8yYMYPXX3/9usa9cOECo0ePRhAEatSowY8//nhT8/P7/fQbMAiNzoBGq7vC9KRT1+54C9uSOXI5Vl8s69atq3Ks0jumY4tKIbzBAHRGC59//jljhw+ngdFEZ60OmUrE5I6kRq26170V3+/38+CDc6jToAkzZt5TwSRQoVSSNXYVeVPWodLqcSfmXd4uNwuZxohMrcPtC0dntmG0e+jWo1eFsY8ePcprr70W1FtzGI1ssTv53u3Fo9Wybds2zp49S2R0LNbE6sg1erTuWKQKNXEdppE6YD5ShQqlRos9vS7WuFyqFdUEAluYWjRqhMXmxOH2Yo/PI3/aBsJq98ATFolUJkOtN5GckobG5MQQlYnK6iM8Mjp4n/TuNwBXRh3iO92BweKgsLg27uyGhNXti1KjQ64WsSTXwhCTg0ytwxKTSa1atZDI5KQNXkjmqBVI5Qq0zkikSg0ylRapQkNMm0nI1Dpi20/Bk98ST1gkglSGRCkikcrRehPIm/oy4Q0HYXN60OiMqC1eZGotgkSGVKFCdEaTX1JGfJc7kcjk5JdsJGfiGqQyOUqDnfySMlL6zUWht6IyuUjqPQuF1kzmqBVENh2O1h2HXKNHZzQTm5hCVNMRZI97FpXRhiCRkJqZTavWrVHpzBiicy5LfMiQKtQ43R569O6L0e5GodFjjM3DGJODRK7EFxGN2xeG2uIhpe8cTAnVsSQXoxANKA02tJ545GodUpmcnIlrAlX2GgP6qEyMcfnkTllHeN3edL18rwwZNgJPbhMyRz+J0RONwxNGVFwir776avA+evrpp/Gm1yRvyjqimo9GqtKSM3ENctGIQmvGEJWJVKFmwYIF+P1+HnvsMXLyCmjfqUtQK3v4iFEYY3JJ7T8fjT2CnLwCSm+/HZ3ZhisxD4vdidPjxeH28uKLL3L69OlrbrU7fPgwO3fu5NKlS8QlpRLdehwZw5egNVp47733yKteA63BSKs27VCoRZQGGzKVFoXOQmRsPK+88spVKxbad+yCPSYdR1I1NHoTWqMFh8t7Xbsszp8//5vlOC5dusT777/PV1999ZvGCfHHIYQqqEPx99+I48ePo1Op+NDp4i2HE61KFaoC+y9iQI8eJBiNpJhMdGjR4s+ezi3nV/NEvV6P1mAhvtPtOFNrMGLU9VeqNi4u5glzQFqihVaPStQH5SEOHDiA1eHCk9cMa1gcU6dVriF9Nb788ktmzpwZlF37d06fPk37Tl3QGMxI5UrqNWxyheSE3+/nlVde4Zlnnrku/dzPP/8cg9mKN7UQvckS3K15I6RkZBPVfBQZwxajM1mr1CJ+99130ZtthDcchDUsngcva3CvWbOGli1bcf/99wfbHjhwAI8vHFd8FjqjmbKysirP36ffAMLq9Ax4g2Q34r777gsee+ihh/BVaxWUYFFr9aj0FgSJBJvLS1RsAj379Kuw4+Pnn3+mfqOmOLzhNG/eHLXeRESTYaT0m4vWYGLv3r3BtqtXr8YWmUTmqBXIVFoyRiwLSIrYfWzbti3YbvSYsXiKOhDVYjT6sGQGDBx0xXV89NFH6IwWwnIboTNZglJxv1K/UVNc6bXx1uiM1mDivffe44UXXsDkCsdV2B6ZUo1CFfiL73wXyX0eRKPVV7mb5csvv8RktWMPj8PjC7/muvrdd98lIjoOq93JE4sXA4H77dChQ9eMb9u070R4/X7kl2zEmZjP4sv9/5Nt27ZhttrRmazkFhTetAb0gQMH6NuvP7l5Bdxxxx2/+26QH3/8kUcffZQNGzZcoZ/95ZdfYnW4MFgcpKRnBnceVEZKRjbxnaeTX7IRe2QSmzZt+l3nfaP88MMPxMQnIlcoKSgs/ssYjVbG1eLvPz3Qvdm/UIAc4r+Rr776ik2bNv3lRf3fffddbFotgw1G3FrdFVumrsaqVasQRRGXy8Xbb799w+f++uuv0Zvt5E56kdT+87HaK+o0//TTTxQUFWOy2Bk+cvRVjRpq1K5PfKc7AiaGuY14/PHHaVBYyBNmKw61SOrABeRP24DFE8mHH354XfN76qmnsHhjiOswDdERQXRsPLt27QJAJeqJaTuRpJ73IVOo0BrMhDcYEJAn0JqQKkVUopbly5fzySefVJj7Tz/9hMsThisuE73RwpYtW0iOiuIBo5mXbQ7MGg27du0iPSsHtcWLQmsmotEQZAoVEpmCjBFLyZ28NpD0VYqBrW+TX0Imk+P3+3nnnXdQarREtxqHPbsp+vBU8qdtwFerKw0aNUFrshHTZgL6iDSkSjXuwo6Y4gtQGp1ojRaefHIlJ06coE//gRQU1WLZsuW4vOGkD30cQ2Qm9qzGhDcciEyhQqHRoVCqkas0eArbI5HJSR/6OFmjVyKRKcge/yw5k9YiSOVIlRoSus1E64mnoHQTqQMfQarUIDoikCjUyDR6NI4o0oc9gTWlFjpPPHXrN2TylCmsXr0ahUpFXMfbkSpF1LYIZBojUqUGY0wuxpgc5Gotot6E3hmFTKVFIlMg15pJ6D4TtdVH/rQNJHafiUJvwxCVhSu7MXK1jriOpeRNXY/ZG4PWYAwk3xMLMUVnYrLaSU5NJ7zhIPJLyrDGZCGVK/DV6R2QcGk3JSALEp/Nxo0bue+++3BmNaCgdFNAvsMWRk5uPsawJApKN5HYfSZKUY+rWhvCGwxALhpwVWuLVKFGIpWj88TT/3Kw3LFzNyIaDiR/2gakSjXxne7AV7sXMqUGvcnK7NmzqVGzNhKZAo0zGqXRgUwlBv6UGlRaU0DDW63Daneybds2TBYbkU2G4avRkfSsXADq1G9ERKPBgW2WOU2RyOTYIxJQijpkCiWiVs+GDRu4cOECL7zwAiqNFrlKJDo+qcLiZ9u2bbz11lu89NJLaPVGDBYHNWrVQaU1onFEEt16PCaHl6YtWuKt3oasMU+hMdoJq9snsA0yowGuam1R6wwoVGpsTjdffPFFpZ/N8vJyVqxYwcKFCzl69Cj79+//w7ZA+/1+WrRui9kdgd5s5867Zvwh5w3x2wglqEPx99+JXxPU7ztcvGkPJaj/2/D7/WzevJlXX331f/Z927VrF8nJychkMqJj4xkybESlusJV8cjDD+NRKOip0yMqNThTCnniiSeCx/fs2cOsWbN49tlnf7PR238yYdJknCk1SOk3F2t4PE8//fRvHnP02LF4a3YLrGNqdWfkqNE3PMZnn31GdFwiBrOV+x+YVWW7Bx98EF+1VuSXlOGr24cateqyZs0aFKIBX+2eyEUD3S97z0Cg4OmVV14JroGq4p///CdWhwuzM4yI6FgOHDgQPPbee++hM1kJbzgQS1gcd999D5s3b67UGPGbb76h/8BBRMUl4q3ehqSe96E32zHbHKQNXkj+tA2YnD4+++yzYJ9Lly7Rf+BgjBYbOpMVd2F7YttOQqpQUVJ6e7DdjBl3o7WHo/Um4sxvhUar56mnnuLZZ5/l1KlTTCu9nZp1GzJ58lQef/zxSuNQrcFI9tinKSjdhMrkQtQZGDRoEN7iLij0VhK7zyRj+BKUahGjxYbV4WLNmjVXfe2OHj3Kxx9/fF2JRm94JLHtppA6cAEanYGff/75mn1+ZceOHThcXjRaAwWFxVfNU5w5c4bdu3f/ZonQP4pDhw7hcHnxZjfA7I7krruv1P4+c+YMu3btumYiv0atuoTX70fGiGUY7Z5rauT/0QwYPARfYfvAg4aUIubOnftnT6lKQgnqECFC3BAlJSWM1BvY5/Fxt9FEv27dbqj/F198QUxMDHK5nHnz5t1QELh7925Eg4nMUSuI7zwdb3jkVdv//PPPPPvss/Ts0gWbxYZCqSKnoDo///wz9953PxZfbECbzmjhn//8J0uXLMGn02PW6Air35/kvg+hNZj57rvvrjm3Dz74AJPNgUytJ6rFmEDyOSyZ3IJCjh07hlSuQqbWBZLEMjmvv/467Tp0Qq3RoraFkz9tA7FtJ5FXvcYVY8+fPx9vTsNgErN5q7Z8+umnZCUk4DVbyEpKIjkhMZBULSkjufdsFDozCp0Zc3KtYNJRolAj11nw1OiCLbMh0XGJ/Pzzzyg1AYPAuA7TAuZ3Sg1yhZKwyGhmzJiBM6NuUK9ZdMdhTatDfOfp6MNTkam1aPWmYHXtrwwbORqLLxapQhUMyizucD799FOmT5+Or3prCko3Yc8OJDjlClXAADGtHo6cpkTGxJOUmoFCb0Wq1KCPSENpdOKp0Qm1xYtcoyc9PYPI6FjkGj2WpBrEtB6PJyI6mHgsuf0OZHJlIJmt1qM0OpBrTYQ1GIAlpRY6XxLugtbIVBrs2U3Ivu0ZRHcsCqUahUaHxmAJJNVFPe6iTkjkCiwptZBp9AHzSIeb8EaDESRS8qdtIL+kDJlKQ2ZmDu7q7cgauwqV1YdUoUZ0xQSTwTpPPDanm0OHDvHDDz9gc7oxRqQgVahRaA3k5OVjsDhI6jULb/U2FBXXQqbWojK50NgjUBodxLadRM6ENSh1FjZu3AgETJKMFhtWbxQSqYzs8c8hU+tI6HY3Sb1mIZHJ0UdmIVWoiW0/FUtqbWQqLQVFNVmyZAnt27cPmkxq7JG0bN0Oo81NfklZoGJcIwKBqhapXIXOl4RUocKW0YC0IYuQi0ZyJqwhsfs9yFQicoUCrcGMyuTCU7MbYXX7YLU7KS8vZ+q0UgxWF1ZvNHqLPWCeOG0DGqsXS0otErvNRKbU0KBxE5q2bE1k0+Hkl5ShMnuwpdcla8xT6MNTA6aeegt5U18msvEQ6jduel3fJX8ku3btQme2kTf15UCljkJFTkHhVauKQvz5hBLUofj778a8hx5Co1CgValYvnTpnz2dP5SLFy+ydevWCpWT/8uUl5fz8ssvs3Hjxv+aZBIEHqQ0adIEQRAYMWLEDe9uGjFiJGqtHmdqTYwWG99///3vM9H/oEPnbkQ0GRowt85vUaFS+GaZP38+9pgMkvs8iD02g3nz5gGBYp7p06ezcuXKW5Zo37ZtGzqTBV14KnLRgGiyER0TR1i9vgETynr90BrNwfY//vgjjZo2Jyk9i+XLV1x17FOnTrFjx45Kd+6+8sor9BswkIULF1V5LWfOnMHu8uCr1Q2lwU5Sz/sCZpBxmQwePBSt0YLZHUF8Uir9Bgys1P/koYceQrR6MURn46vbh/zCmsFjp0+fRmeykTrgYQpKN6G1uDG6IrHHZBAeFYstKpW4Trdjdkfy/PPPVzrHlm3aY4rOwpHbPBATZzdi/Pjx6IxmpAo16UMfJ2fCGqRKNc64TIwWW5XV7NfD6dOnKb39DgYOHspXX32F3mgmfejj5E1+CZ3ZxjfffHND4124cIFffvnlpu4nv9/PZ5999pfcQbhu3To8SYEdzcl9HiQ+Jf2mx/r6669JSs1AbzTf1A6M35v+Awfhq9GJ/JKNuFKLmTNnzp89pSoJJahDhAhxQ6xfv55wnY77jWaSDQYWLVx4RZvdu3fz1VdfVflDdvToUZo3b44gCHTv3v2Gqsbvvf8BVGoNVoeLN998s8p2e/bswWU2U1NvQCUIGF0xZI9bjTu/JX36DcDv97Ny5UomTZpcYUGydetW7rjjDlIzc/BFxrBkydLrmld4VCwxbSYEq3xlaj2RzUeh0Zv48ssvkalE8qasu1wpLA8uCDZu3IjJFUHO+OeIaDiQWnUbXDH2mjVrLpsePoI7sx7DRozi+PHjZOcVoBYk3GkwIpMpkGsDBi6eGl3Q6E0YY/OxeRMpUqkYptWhEgTMScUBiQmFClFvJiE5FZ0viahmI5GqRGRqHXK1lk2bNuH3+9m1axei3ogtvT5Kgx2V2YPGHoFCZ0HrScAUl4/J4a1g5nL69Gkys3NRqDUoNToskSl4MusSE5/IuXPnuOeee1CIeizJtdA4Y9C5ozHbXMhUWrTeBKRyFWPGjOHcuXPk5OYh11tQ6Kx4a3ULJDEdUUhVIga7m7Vr12J3eRCdUcjUeoyeWO6acTcHDx4MmHooNchFE0m9ZpFfUoba6iWuQwmu6u0wJxcT0XgIUqWGsPr9yS8pwxRfjUmTJnHq1Cl27tzJgQMHuO/+B1CLejT2cJRGBwqjA6lSTWRMPBH1+6H1xGNLr48jL2DCpzVakMiUyFRalEYnctEUqA6/7Rlyxj+HXKFky5YtwYXVwYMHkcpkxHedgTO/FUpRT6/evYmKS6RRsxZs3LiRrl27IpPJkSqUyNVa4jrdTu7ktSj0VlzesGBS/siRI2zbto0hw4aj1JoCrta3PUPOhDVIZHJs2U3RXjYfMcbmYUmuSWzbSeiMFnyRMcS0mRh8jZs2a05aRjau5OoYvXFk5+Zz+PBhnn76aaxRadjS66P1JmGITCex+0zkGj05458joesMlAYH2eOevSy1IiVv6nryp21AJeo4cOAAmsvmg3lT16PQ6IlsPJTM0U8iF41EtxpH3rSNmDzRvPnmm3z44YdIFSpUJhcqsxe5WotGq8fq9JJbUIglLP5ygnrwdSWoDx8+zBdffHFL3bj379/PCy+8wNRpJegMJrzhkUHTxkOHDiHqDCT1vJ/olmNR6CzEdSxBazBVWsXy+eefs3nz5v8Jk6v/ZkIJ6lD8/Xfk3Llzf7vvHr/fT4v69UkyGvHqdNwxdeqfPaXfFb/fT9PmrbBHJmELj6djlxsrNLmV81i3bh2PP/44hw8fvu5+Fy9eZMyYMRXME2+EN954g/nz51+zuvdW8tZbb6E3WvAk5WOxO9m9e/d19Ttx4gR3zZjBtGkl/PTTTxWOlZeXM3L0WBJTMxk+agzl5eXs27cPo8WGp3pbrOEJV02U/Ro/O9zeq0oi/sqbb74ZkJyb8Dy5E19AJpej0JoIbzgQpd5GclpGsG3dho3xFbUnsfs96ExWduzYcV3XezN88803GO0eYttNQR+RjlSuwhWfRWxCEidPnmTnzp106tIVa3QGvrp90RstVyRov/jiC/QmK5FNhmGPy2bsuPEVjvfo3RdnUjXC6vULFICMW01+yUbkGj2ey1Xs3qIO3HnnnZXO8ezZszRq3BjR7MRXtzc6k5UPP/yQjz/+mHbtO6DSaFGotegj0smbsg5nbnMmT5ly069Jm/adcKYWE1a7ByarnXvuvfeyGaaTTl2737IHF88//zxWuwub081LL71UaZve/QZgtLvRWxyMnzj5usY9fvw4deo3RCPqaNK81Q3tlLgRvv76a3QmC9Gtx+HOrEunrt1/l/P8FdizZw/hUTGoNCLZedWqNPz8KxBKUIcIEeKGeWrlSnp06MCjl3Vq/515Dz2ERaPBq9PRo0OHKn8EL126xJ133olEIiE9PZ1vv/32us9/PT+sc+bMoYvJzD6Pj7YaEUtcPvklZYQ3GEjbDp2r7PfNN9/w+uuv37A2k9FiI23IIvKmrEOu0aPQ21DozOi9cfTtNwCFUk1EoyHEtJmA3eWpcC0DhwxFrlASER3Hjh07OHXqFGVlZUHXYr/fz4RJUwiPiqVV2w4cP36cmTNnYonJIkrU86HThVqpJqLxENRWH3K1FrWow13YHp1Mxiabg9uMZgxqLS6XB5laS2y7KeROfAG5Rh+UOrGm1EbjiESusyBXqsktKOTLL7/km2++oV379iQkpxIVm4DdHYbD5UKp0WJ2RVC3QeNgwv3SpUskpqQhFw0BremUWmTl5DF//nwOHz7MP/7xD/RmO5FNh6OxR2BOLCKi8VDkSg2eok6B6pKaXbHYnQDMmjULU1w+Cd3uRqpQB3SH9VbSBj2KN7cRCxYsYOrUqZjjC0gfvgR7dlNUWiMSmQytJx7pZVkTX+2epA6Yj0ylRZDKkKnEgMSFQok1rR5yrQmFNlDJYDRXDKbnz5+PTCXiLuyATK3Dnt2E1IELUBns2J1uBEGCVKFGkEixZzVB54lDqlTjKe5CROMhSGQKpAo1iT3uI7n3bKRyJRqdAbc3jJ07d9KxS7egZrUxrgBTfDWkChUanZGimrXQGG1oHJEojc5ANbkvEYlMgUSuxJxQiDYsmf4DBgTnW1ZWhtXuQqZUo7aFBaqZNQaUBjtSdaD62xCdhUytJ7n37ID2X2IeKelZRDQaRM7ENWjMge2FJ0+eJD4xGaMvAWdabeKTUvjll19we8PxpBaiM9spKCzG6nDh9kUglckDkib1+pE76UW0ZjtylYjWE48pKo2CwmL8fj/h0bFENRtBQre70Yg6ImPiA/Ig7jgUOjMytQ5BIqW4dj3Onj2LWqMlvsudZI17BlFvDFbsl5eX07RFaxRKFXaX55pO32+//TZ6kwWzK4yUjCxOnjx5Q5/zyti5cydGiw13cuB9i2kzidh2U4iIjgu2ef7554mIjkOh0RHX6XbyS8owu8Kv0Iyc/eAc9BYHtogECgqLf7P2dYibJ5SgDsXfIf4e7Ny5E7dWx263lw+dLgwazZ89pd+VQ4cOodJoyZv6ckDuTa64qu/M78WUceNIMhhpbrYQFxZ2w7/HTzzxBHK5nISEhBuuCP2jOXr0KMuXL2fx4sUVZCyuRVHNOrjSa+PJb05kTNw1H6w///zzeNOKAhWhvWeRklH5d/L58+fRaPUk955FUq9ZiDrDNce+ePEieqOJ+E53ENlsFAqVmvr16+Nw+8grqF4hgR4dn0RynwcDknYxaRW8UG4158+fx+ZwodDbiGg0GLnWRGZWdoX7yRsehVSuRKbWYY1IYvXq1VeM89prr9G5aw9m3D3zitfi7NmzTL/zLvr0G4BcrcVbuyfRrcYhlSsR9SZ8uY3RmywVinX+k4sXL/LAA7Pp0r1XcOfjrxw8eJBJkyZjDk9GLhqRqUSi4xKr1KC+FnaXl4zhSwKvf3Qyb7/9Nnv27GHHjh23LDl97tw5NKKO5L4Pkdw7cA/9p7zQr981uZPWkj3uWeQKxXXFtVOmTsOVUZec8c/hTKrOrFlVy8/8VsrKymjYtAVDh4/8SydtbwWXLl3iyJEjt1zC6FYTSlCHCBHilmLR6XjL4eRbtxeXVnvNoHHjxo2YzWZMJhMbNmy4ZfN46aWXiDcYWGO1U0OpQqVUo9CaMFzFSOT5559HZ7TgjEklNiGJEydO8Pnnn/Piiy9WavK2fft21qxZw4EDB1jwyCNodAZ0Zjsp6ZlY4vJJHfgIvrp90egMOFNqoNCZcbi9fPDBB1eM9euPxalTp0hITsUZm45GZ6Bater07Nnzii1pt99xB66sBphMLorVIqJChVwlotHq6d6jB77cRgGN4Lh87AolBk88Ma3HY7A60eoNJHS5i5S+c1CoNIhmF868FperV29DoTOTPW41prgClGoNL7/8MgDVi2vjK2p/ueLWzKuvvkpaRhaCRIIvPJL9+/fzwQcfoNCZyZv6Mil95yDXmmjboRMAv/zyC23btsUan0d+SRkxbSYgWlyo1CIaswutN5HUgQswRGYiUygBOHnyJFFxiQgSCXKNHm9YBDqTDV9mHcw2B++++y6esEgkMgVKnRmJIiClovMlIZErcRd1wpnXCqXJhcrsxppWF7nGgD2rMaLZQefOnbFFpWLLaIBCZ0YXloI9uwlJ/1YJMmToMHy1e1BQugmNI5LY9gEdaUNkBosWLSInvzpRzUeRM+F5FHorksva3ykD5pPQdQZqnZFqhUVoDWb0RgumiGTyS8oIq92Deg0aYfXFkjf5JaJbjkXrS0IiU5A1dhXZ41YjkcpJGfAw+SUbUVs8mOKrI3oSAnItWhOJ3WfirdmNrJy84H1kMFlI7HEfaYMeDbwuJifpQx8nfejjgWrxiEgGDx5Ml67dMLvC8WbWweUJ45133sEXEYVMJqffgEH4/X4uXbqEIJFgSQkYWkoVal577TUOHTrE6tWr+fjjj4HAzgO92U54gwEYXFEo1BpUGpGateugt7pRGZ0IEilWh4vt27fz+eefk51Xjbik1GDlTnZeAUqDHbXVh7uwA/nTNmCPz6VDhw5MmjwZjc6A1mhh8NDhV3x+Tp48ecU25cOHD7N9+/YKwXDdhk2IbjmW/JIyXMnVWLHi6ltPr4cZM2bgqdaGgtJNRDQajC2jPqkDHsbqcPHJJ58wfOQoHnzoIcrLy5k0ZRomZxjO2AyycguuWAQ53D7SBj1KfsnGG9K/D3HrCSWoQ/F3iL8Hhw8fxiSKPGWxMdNoJiky8s+e0u/KhQsXMFvtRLUYQ2TTYTjc3j8lYRHldPKG3ck+j48si4W33nrrhsfYsmULVqsVs9nM5s2bf4dZ/nZ+/vnngI/MZdPAN954o8LxPXv2VJq09vv9SKUy8qaso6B0E3qzvVL95X/nm2++QWc0E95wEI6EPAYNGVZpu9OnT6NQqsge9yzZ41ajUKquq0p18+bNhEXFIlOq8RR1xBadzrARo4CA1Eazlm0Ca4zkNPRmO664TBKSU2/aX+n06dNkZOeh0Ohxh0VUWXnerHlLwuv3D+hx1+mNqDMGjx09ehS5Uk3GiKWk9JuLRKa4IWmXc+fO8eijjzJ79mwOHz6MxxeBLiwZfUQaalHH+vXrWbRoEf/617+ue0y/339Fovb8+fOER8cR0XhIQCc4IYeVK1de95j/To/efbHHZeOp1gab082xY8euOP/YcePRiDpiE5JvaO6/cvLkSRQqdeAeuu0Z5ArlFQ+6Tp8+jVZvILH7PXhr90Qjaq9p6AgwbMRIfMWdgpI4pbfffsPzC/HfSyhBHSJEiFtKjMfDArOFTXYHJo3muowYdu3aRWZmJhKJhNtvv/2aeniXLl1iztx5dOvRm/Xr11c4Vl5eztmzZ/H7/dw7Ywa5SUl0aduWZcuW8frrr1/16WhWXnXiO08PVpSOHjUKp1ZLbauVKLe7whbERYsWodbqcSfm43B52LlzJ4mp6QGtM5sDs9WOOz4LtajDmRjQt0rscR+RcYmVXt+WLVvo1rM3PXv1xhGTRlLP+5GqROSiAWdBazQ6YwVX6AMHDhCbkIRGZ0Cp0WGNzsASkUjDJs349NNP0ZmsRDQajDUqFYvDQ0zr8YHAraAFQ4cOxRsehd3l4YknFpOSmoZEpsCcVAOlyYnS6AxUVKfWRRuWTLUatQCwOd2kD3uC/JIyNBYPSrUGqUKNPbspSoONoho1+eijj5AqNWQMW0x0y7FIlRq2b9/O8ePH8YRF4M6og9rsQR+WgtHhZcTIUUyZMgVHWjEKvRW51oTSaKdh42YVXp9PP/2ULVu2cP78eT7++GOWLVvGyy+/TIuWrfFeNn2wJhWi1FkwJxQiF43Ys5thS69HXIcSFDoLsW0nIbpjUdvCA0FPTmMeeOABRo+9DblaJLzBAGLbTUGq1CBVagiPjuO28RN4/vnn0du9RDUfFTC0VKgDFc0aLYcPHyYtK5e4jiXkTX0ZldmNXDSg9SUFDB1dMahEPYcOHQJg4cKFOBPzyZu6Hl9hexo1boo1LI68KesCDwdEIxKZnOQ+D5Lafz4SmQJvcVcSutyFVK5CotAgkSlI6DqDhK4zkMiVCDIFw4YNC342ZHIFmSOXkzPheaRyJYJEhjEuH2NsLqLehMXmoFnLNhw7doyysjI6dOhA165dg/pw/3l/RkbHorFHkDdlHRGNh5CSkX3FYvbee+/FW9iOgtJNRLccS8u27dm/fz9FtergyG2B1hO4xoiGA6uU4cgpKMJT3BWtNxFvzW7kl2zEEJWJ3hOHSi2ycOHC694Wu3nzZnRGMyaHl5z86sGFV/uOXfDV6EjW6JVYw+Kua1vr1Xj88SfwhEWgdUSQ3Hs2puhMlKIOjc7ArFmz0Zss+Gr3wBKVRv9Bg/H7/WzdupUXX3yx0sVgRk4e4fX7ktTzfrQGU/B6y8vLr+oefi0OHz5805U4f1dCCepQ/B3i78O6devIiI2lKDOzSrPdW4Hf72f16tXcddddbN++/Xc7z7X46KOPKKpVl1p1G1y16vNqfP/99zzzzDM3Xb3cvF59uhlNPGgyY9XprvAyuV5+NU+Uy+UsrER28M/mkUcewZNVPxgfNW7eCgjcC+06dkKp0aFQaXioEk3YgsJi3Jn18VRrjS8i6rqkyd5++2269+rDXTPuvqpcz4RJU9AaLWiNFiZNmXbd17NhwwY8SfkB8/L+84lJSAZgxIgRmMKSyBy9EldaLQYMHMT69etveEfqv9Ord1+MsXmkDnwE0RVTQUbk31mxYkWgiKVWj8AOPEFC5249uHTpEgcPHkQt6si+7Rkyhi1Gqdbc0AOZpi1a40jIw51Zj7jEZLZs2YLLG4aoMzD7wSvfs2vx4YcfYnW4kMnkDBk2osJcWrVtT1idnuROXos9KpVnn332hseHwEOoBQsWUFJaWmky/h//+AcmZxhZY54iosEAimvXu6nzTJg0Ba3BjGgwUVJ6R6VtNmzYgNnmQKm34EqvjcPl5eDBg1cdd9euXThcXizucDxhEezfv/+m5hfiv5NQgjpEiL85Fy9e5Mcff7xlW8nfe+89EsMj8FqtLF2y5Lr7nT59mp49eyIIAs2aNau0YvlX7r3vfqwRSUQ2GYbeYuedd94BAgsMUWdAoVRV+UN5NVq17YC3eltS+s/DaHeTk5DIMouVfR4fDa1WnnrqKebNf5iMnAKkSjWiOx611Ys7rRbdunXDlVIUkBGp348Wrdsxa9YswiOjUSjUhNXvhzWlJmqDlTbtOlR4mv2vf/0LvckSqL6MzUYpGi7r+yYQ3nBgQNusVg9GjR7NAw88wN13381XX31FeXk5n3/+ORqtgfxpG8ibsg6JVMpPP/3Ea6+9Ro/efZkwYSIqUYdCZ8Ge1QilRhuUr9i3bx8OlxdrZDJShQpdWApSZSABKlPrkIsG1BYvbl8Ely5dCgQiVk/AHFGjxxiTiyW5OGCg2LEUV1gkTz/9NEqDFZlGj1w0Eh4ZDQS065wxqRSUbiJt8EKMFnswOXjo0CHsThcSmRxBIkXrjEBnMAerxv1+P9u2batgsDF23HiMdg9amxeNPZy8aRswx+UjlckDZoQaA95aPVDbIxCkMpQmF4bobHTeBJRqDY7IJDy+8OCWxEAVwGryp21AptKiC0shdeACrOHxPPPMMyxbtpyMrDw0FhfhDQejMliDhjSbN29GZzAhVapRGuy4qrVDptYR12FawKgluTorV67k448/plHTFji9EQgSCfFJqezdu5f2nbqgUKlRqkWkCjWOnKbIRSNSuRKl0YVCZ0FtCye2/TRUFg8SqYycCWvImfA8glSKISqL4SNHcfHiRd555x1c3nCkyoCsh+iMxlPcJSBpotYEdMRNblRmN0OHj6Rl6zZIFSrUFi9ShYo5c+Zw7tw5nnvuOdavX8+lS5dYvnw5encMkU2Ho9Bbkal1DB4ytMJn58MPPwxUOHsTUOtNzJ79IFGx8eisHqRyBaI7lryp64lqNoI69RsF+128eJHVq1fzxBNPsHTpUnQmK7bIZBRqEZlChdLkRCYasaXXQyXq+Oijj67rs1xQoxax7SYHqlDisoJu6Pv27SM7vzo6g4nBQ4f/pqqxTz/9FL3ZTkL3ezGEJWOwOhkwaAjbt2/nl19+Ye3atTgTA4u45L4PoRQN7N2796pjfvPNN1SvUQuXN4y0rDyGDh/J66+/jtFsRaFS06lr9xsytPL7/XTv1QeVRkRrMP6u22z/1wglqEPxd4gQt5r7Z84kyWBgoMGITa+/LhPuW8X777/P8EGDmDtnzhVb8W+Uzz//HKtORzObHatWV6nx3LU4dOgQA3v1omX9+r+5+vnYsWNB88SRI0f+peSxXnrpJSzeGFIHzMedVT+4C+zzzz9HphLJnfQiaUMWoVCqr+h79OhRppWUctu48TedwL8au3btuuF78IcffsBgtuKr0xNHQi79Bw7mzrtmoDFY0dgjMERm4inqwIhRo3/z/GrWqRdcBzlymuF0e4FAbDNv/sO0bt+RpUuXATBv3jxEvRFHbnNyJ6/FGhYXlNKYMq0UtahFrdHSrXsPnn766ev+DCiUSnInvkB+SRlGm+uGJCkrIyMnn+jW48iZsAaT01fhs7Njx47AekgioU27Dr/5c1oVGzduxOyLIW3IIuI6lpKRk3/TY+3evTtY2b9v3z6GDR/JiFGjKxSopWbmBs0rPSnVgjH51Th9+jTbt28PFVf8DQklqEOE+Jtw5swZOjRvjlWvp13Tppw+fZojR/6PvfMMk6JY23BNzjnPbM45B3LOOeecc86woCgIImJCQQRURBFBQCQdQQyIigFFVFBREZAMSt5ld+7vx+B87iEthqOes/d18YPtqurqnu6Z6rff93nOkB4Xj02jIdLjKXN24p+F3+9n/vz5yOVyoqKibpjVsWnTJvQWO9Gtxgcygis0CzrR2l0eErs/QNboFWgMJh555BEWLVpU5szDY8eOUbt+Q8Kj47h/zlx6dOhAB5OZF212fHo9M2bMwOKJILbtFHTeOMIbDMQUk4vWaGXs2LE4YzLImbiWkMpt6dCpCwqVhrA6fXBl1EOu1GBPr0dk0xEB2QW1JmjCsWLFCkLSqwezrMOi4vCFRSBX6VDbQohqNgq9zUNkdCzWqAykSjVytY6o2HgWL16MzekmrF4/fNW7oNAa8YaGB01jVqxYgTOxAgldZ+PKaUJcYmrweB944AG8OQ0D0gQNBhITn0SDBg1Qm5xIZHIyhi8jb8oGDFYnX331FX6/H5PFhiEqC40rEnHNCDCq+RgMock0btqMBx54AGtMFpFNRxBap3dQ7/vQoUMYTFYimwzHm12fRk1bBOfRb8AgdM5wzLF5KPRWcie9Qmid3vTu2w+Azl27Y3b6MFidTJoyFb/fj1yhJGvMi+ROXo9MqUFIpKjtYTjS62A0m5GptDgy6iNVqLEkVUWht2BLrYnBbOXtt99m586dpfTpBg0ZhtEZgtYZjkJjILzBNbf1nIbMnTuXoqIiPCHhyNQGZGo9SoMDd0goiclpGCx2qteui9nuJG3QU+RP3Rx8IZDc+2EUegsrV67EbLUT0XAwIVXbk5yWWerau//++3HE56K2h5HQdRa5k19Fb/ch1wS06CIaDSZ73GpUJhehEVEorml8y1R6FDoTs2fPpmGTZli9kcjVeiQKDfrQgJZd2pDFyDUGpAo14fUHoA9NQkjlNGraAo3RQnj9AeRP3Yw9rQ5SmZwKlavijEnHFhpLj159uHr1KilpmUiVGpL7PEJo7Z5oDJbgPQsBx3ad0Uxo7V44EiqSmZWDJ6P2NXf3XmiMFhQqDVaHi48//jh43B06dcEWnog7uRJJqRl88sknvPrqq5w5c4aZ981CZbQHH068VTsycWLZTGPqN25KaM2uZIxYhtUbyWuvvQYEKg8KCqZy9/Tpd2ys9O+sW7cOd3zWtft2FklpWaW2Hzp0CIVai7dqRwyhyei9McydO/e243755ZfoTVaiW4zFnV4Tm8tHdMtx5E5ch80XdUcP8rt27cLsCiVn4lriO04nOj7xjo/zf5XyAHX5+ruccsrKjh07SImKItbnY+3atTdtVz07m+esdg57Q2hus/8hMlNl4auvvsKm0zHBYCTfZGLimDG/a7yJ48cz1GDksDeEiQYjg3/lgwGB4NI999zL0OEjfpN8wG/h1+aJ9evXv07WAAK/idHxSbi8ITzzzJ2f+6KiIvbv339Hetl+v5/JU6YSERNPi9btgs8k//rXv5DJlaQNfoq4Dncju0GA+q/i2WeXkZyeTeNmLW9YCbt7924GDhrC/ffP4cqVK5isNtIGPUVewUYUBisWm+N3B3IBWrdti1SuQuuOQSpXBU0IFy58EmtIDFHNRmF2hbBmzRoAKlWrSWTTkeROfhVHRFIwEaa4uJjPP/+cmPhEPKlVsUcm07VHrzLNITuvIraEChjDUzFarHdk2Pfuu+8yd+7cUskVSWmZxLSbSkTjoagNVgqmBows/X4/1WvVxRWXjTM2k9r1GpZ5P3fK2PETUGj0gecZjf4PSV4oKSkhPCoGX8VWePObEZ/0/8+bnbp0x5NRO2BkabGXSjj6p7Jt2zb69h/AE08s+NtrOv/TKA9Ql1PO/wiz7ruPeiYzH7k8NDCZmHHvvcyePZtWJhOHPD4GGU0M6dfvr54mAO+88w4ejweNRlNKf+sXLSt3fktUZlfABNBkCQaybU43ST0fJGvMSvQKJVlGE/UtVjITEspUFvcL27dvZ+nSpezfv59OrVqRk5jIE/PnU1BQgK9K+2BA15JQGZXRxoABgygqKqJpy9ZIZXLCo2NZuXIlCr2V/KmbyRr1AhKpHK1MjkEqw5ffkuyxL6EzWfn22285ePAgRosNb8VWWHwxTJwcKLVbvXo1FStXJadCZeY//gRKlQZjZAZRLcaQN2UDOk8MBoeP7j16ojfb0TjCCanRDWdMelDP+55770WqVOPMaYLK4iEmPoG+AwZy7Ngxli9fjj08kdT+T+BOq8moMWPp168fcp0ZtS2U8AaDiO90LzqDKShRUbdBY8wRKaisXrJGr8ASXwmFwYYlsQp6o5leffoGtJJjcpCpNKW09t58800aN2tJv4GDSgUHTVY7GcOfJa9gE0qTk8imI9G7IoiMTaBv/wGotQZyJ64jc9QLSKQy2rVsicVmJ7LpCOI63I1UqcYcXxm51oTWHY1Sow9q0fmqd8WSWBVXdiNCIyL59NNPKZg6ja49epXS9/X7/Wzfvp0NGzawfft2DCYrrph0dEYzs2bNYv369VhCYsmbsgFXXnOkChVSlRaV2UVK38ewp9YiMjYBZ2IFQqp2RCJXYghPQ2GwodAaeeCBBzDaXOQVbCJ77EsolCq6du9JckY2Q0eMYvLkyTgz6hHbrgCpUoNcY8TicNOiVRsUGu21ILyEkIhozpw5w9atW1GoNSR0nU14vX5ExSVgtDrJnfwqGcOeRqpUI6TygFa1xohMqcGSEDDOietwNzK1nu3btxMdl4g1qRrpgxej88YjJFKUGj06TyyOrIbI5IpgSbLK7CavYCPJvR5Ca7TgDQ1HrlAyYtRotm7diicuI5ghb7E7cESnkTlyOd7cxvQfOJhTp04F78Pjx49zzz33IJHJyRq9IpCZ4vDy5ZdfBj+TkpISmrVoidYRRmidPuhtHnr16sX+/ftvew9/++23pKRnoTOaGD5yVFBPOy4xGU9OQ9wZtcnOq1jm74Qbce7cOSJj4nDHZWGwOFi8+PqKkW7de6JzhOGp1A5rSOwNjXn+nTVr1uBNqhA0OdIaAw7jORPXYvVG8sYbb5R5jh9//DEmu4fscauIaTOZ+OTU23cqB7j1Arn83//2+nvp4sW4zGaiPJ7fpJtbzn8Xfr8fj9XKAouVlTY7Jo3mpnJy40eOpLLJxHSjGbtO9x8L1Dz//PM0sTs47A3hRZudyunpv2u8xYsXk2E08aLNTgWTiXkPPlhqe/NWbXElVyakWicsductqyL/aBYtWoRcLicxMfG6IGloRDTRLcaS3CeQbVsWGcJf+Pnnn0lMScNk92CxOfjkk09+1zwvXryIzWxGIVOgVKipV6PG7xrvj+D06dOMGzcOtd5EQueZ+Cq2pH6jJjdtf/HiRSpWCXiUKPRWopqPRqM3cuDAgT9kPklpWUS3nkRYvf44YtJZtWoVAN179saSUBlzbB7GyAwmTgokL+zatQuz1Y5aq6dB46ZcvXqVQ4cOER4Vg1KjQ6bSkTX2JbJGvYBWbyi1r/PnzzN12l0MHjqMr776Kvj3NWvWoNIZ8VXthN7qLFP2L8DWrVsxmG2EVGyB3mRl48aNFBYWsnXrVpQqDSqzi8jGwzA5fKxbt46zZ8+iVGkCFbGTX0WuUF6n3X3u3DnqNmiMwWShZet2Qc3nkpKSMhv8Xbly5VqSz0qyx61GoVL/Lgm5Xzh16hRqrZ68gk3kFWxEJldw+fJlTp06Rd/+A4lNTCavUtXgy4R/Mh988AF6s42wun2xhcUz+/4/z8Txf5HyAHU55fyPMH7MGPobTRz2hjDQaGLMyJHMmzeP+iYz33l8dDWZGDnkevOx34vf7+fChQv4/X7OnDlDm/adSM3MZcHChbfsd/ToUapWrRos1ysqKuLEiRMo1VpyJq4lusU4JBIp7733XrDP6tWr0egMKFRq1DI5n7k9HPL4CDMYypzB8dBDj2B2+vClV8ftDQ0GZgE++ugj9CYLvtyGKDR6nB4fM++bxZUrV3juueeYO3cuRosNT1wmRosNjc6ALaEyRncMWpmcNjoDq20O7Eo1ce3vQmsIlNyXlJSwd+9eYuMTUGl0aPVGNm3adN15jIqNR2MPJbR2b7LHrULjjCC8wSAiYxNw+cLQhyZhislFrv5/GY/mrdoSWrs3obV7YYrKxhiVha9Cc9KzcikpKdeYlYEAAQAASURBVGH4yFGERkTTsk17zp8/z9q1a1HoTCT3figQ7NUagyaJEFi81qxdB1N4CnkFm4hqNgpTdDa5k15BrdVjcwZ0qvOnbsYWGhssXTtw4ADVa9clJTOH5LR0VGoNDRo349KlS1SqVhNPXlMiGg9FIg+YHEqVGqJajMEck4NCrSO61QQMvkS8MhmTjSYMEgkqrR6pSktU8zEodBZUFg+eyu2QKVTonGFEtRiDTG1AIleQmZPHgQMH6NC5CxqLG6lCjUKjv+l1sWfPHgwmM5aEClhC42jcpBlWb0QguGy0k9RjLhGNhmKOyw/oCrYYQ+Vqtbhv1iyGjxhJnfoNURptmOLy8VXrgtnqIDktE3dSBUy+2IChpTOCxO4P4IjNJDevAjJ1QIpFrrMQUqsnETFxRMclIJXKqF2vYamsjU8//RSzM4S8KRtIG7QIk8WO1mAioetsIhsPQ6rUYIzMJHPU80Q1H4NcrUNrMOGp1BaNzcugwYF7/ccff8Tm8iJVqpEqNaiMdtS2EJJ6PogxMgO9yYLf76eoqIjktAy0Nh9KrYHQiCgimwwPmGk6Q9iyZQs2pxtvhRY4olJp1aYtvvAoFCoNORUqlbqP3nnnHQxmK7JrGt3uCq2IaDgYqVzJ4KHDWbhwIQ8//DAff/wxY8eORa5UozLakam0+LLrYzBbg9f3zTh69Cjbtm3j5ZdfJiElnbSsXLZs2RKQw7m2eJZKZbfUZywL586d45VXXrnpg+qFCxfo0LkrUXGJjJswqUxZFidPnsTh9uLLqovFE86gwUOw2BzIFUo6d+txR5kafr+foSNGIVcoMFvt7Nixo8x9/9cpD1CXr79vxIkTJzCp1fzL4eQpi41Qh+OvnlI5fzElJSWo5HI+cXn42u3FrFYH5cP+naKiImbNmEHPjh2vM8v7Mzlw4AA2vZ7hBiMZJhN3TZ78u8YrKSlh6sSJVExNZdyIEddJaticbjKGPR2QZohIKLVW/0+wfft2rFYrVquV7du3B/9uMFlIH7yY3EmvYLA6y/TC+xeeeOIJPKlVySvYRHi9frRs0/6mbV9//XVSM3PIrVjlloHsH3/8kfvuu48FCxbcUSLNn0FRURGxCUlYo9LRuqOvvSSfS0xC8k37PP7447iSKpI3ZQPeSm0x211/aABy1Jix2KNS8VXrhMFsDUpJjB07FpXZTWy7ArTOCEaOHBnsU1hYyMmTJ4NrpUGDh17zqtkUCGrHV8SV24zw6LhS+6rfqAmu1GqEVO2IzekOBnwnTJiIr1rnoBF2z96lqwVuRv+Bg//fuLFGV2QKJTqjEU9IGBKpDI0zktxJr+Cr3pkJEyZSXFyM2xtKWJ1ehNXuiTc0/Lr13qTJU3Cn1SRz5HKcCXk8/PDD7N+/H48vDIVSRWZOHh999NEt51VcXIzeGHgBkdjtfrR6w3Xmhr8Fv99PQnIa5ogUbDGZ5FaoDECFytXw5jQirFYPbE7379IkP3bsGK3bdaRi1ZrXPSf/J3n00UcJzW9K/tTNxLSZRN2GN3+JU86d848IUAshlgghTggh9pal/f/CArmccu6U7777jhCHg0SLBZ/dzoEDB7hw4QJ1q1RBKpGQm5LC8ePH/9B9nj17lvy0NFRyORnx8bRo0w5vdgMSutyH0ea67YK1qKiIESNGIISgSpUq7NmzB5VKg15vRaM1YjVbr+tz5coVzp8/T8X0dPqZzNxjMuMwmW77Zvm1114jLTMbjcGCr1qXgKRAUgVefvnlUu327t3L/Pnzg9m3fr+fqjVq44rLwhSagMYZEViMVOtMj169adGiBVqtDrvVy0KzlcYGMzKZIiDTodJicnipWac+27ZtwxYSTe7k9cR1uJv45LTr5njkyBE6de6KwWxDSKToQ5Mx6czo5HKERELupFfIK9iIXKUlJSOHDRs2sPDJJ7F4wgmp0TUod2FNqoZUKrthoMvv99OpS3cUKjVaveGGC4CLFy+SmZOHye5BqdFhsLmwhcTQonVbqteuhy+/GVHNRmEwWzl69Cjnz59HY7Ag1xgwRmUikStJH7oUV2IF5s2bx/Hjx+nWszc6k42IxsOIbjkeU3R2QDqh80xcvnBkSjVms4v7TRYOe0Popzciv2YiqTQ68FbpQHznGQHdbIMFmVKDwmDDFJOLK7cZFpuDixcvYrE5MMXkkDV6BdaEynTs1PmG18PWrVtR6kzIdeZACZxKQ/uOnRASKTK1nohGg0nqNQ+pQo3WFY1UoWLdunVcunSJhQsXMnny5EBZoisSpdGByenj/fffD+gsG83YsxriqdTumgRGb0LCo4hoMhydNx6ZxoBMpcVodeLKaUTu5Fdxxefw1FNPBedXXFxM1Rq1sYUEXiIYrQ5q1q5LREw86Vm5rFu3DqPZiqdCK0yeSBo2aozJYsVgMjNt2rRSn/2ePXuw2J14q3YkpEY3XHnNyJ+6mbB6/VHqTDz11GIgcD++8847fP311ySlZRLX/i5yJ6/HFhLDM888Q99+/ahfvwFNmzZDpdUT0WAgodU7E/tvDzeNmrYgsvEwlCYn0a0mYk2ugUytJ7rFWJRaI47YLGyxWYHPPCYHmVpPcp9H0YckEttuKr785reUyvj4448xWmy4olORypXEtZ9GdIux2J1uImPi8OY1xZNdn/Ss3JuO8Vdz5MgRnnjiieD9V1JSckdlpf9OUVFReQniHVIeoC4PUN+I77//HrtWy9duL2873Zg0mr96SuX8DZg2aRJunY4wg4FenTr91dO5IZ988gnjx45l8eLFd+Rl8Fto17Ezzvg8vBVbYXd5bii38WfzzTffkJiYiFwu58knnwTgwXkPozNZMTm8tGrb/o5+F5ctW4YjOo3ssS/hq9Sa7j1737DdhQsX0BvNxLadQmSTYXhCwv6Q4/mj8fv9pTSOv/rqK0wOL9nj16C2h6HzxGK0Opn/+OM3HSMYoC7YSGi1jmWWzSgrxcXFPP7444wePaaU7OPESZPwVelwba3aj159bl4BPHjocDx5zcgr2Ig5Lh+NKwqdO4ox/yZzYzRbyRy5PCB5FxLN7t27gYDJn9HuCVTOesJvKA3z9ttvM2z4CJYuXRq8ppYsWYLVF010y3GozC6imo/GGJmJt3L7gHxiWArmmBz0ZluwMm7fvn00b9WGFq3blcri9vv9rFq1iqrVahBSrVPgGTW/GdPuuosWrdsRVrsXeVM2oA9JQK018PDDj97yvG7ZsgVfWCSekPBgEtLVq1dZvnw5S5YsuS5zuyycPHkSlzcEe2w2aoOZJxctAkCl0ZI99iXyp27G7PT9Lsmf6rXq4qvYipg2k9AbLbf1dfmz+OSTTwIJa9U6Y/VF3fZ8l3Nn/FMC1NWEEFnlAepyyvntbNu2jcY1a9KmefPrvtD/LBOGe6ZPD0qIdDaa8Lq9xHecHvhhTanECy+8UKr9vn37mDFjBitXriy1aHz++efRarU4HA6sKjVrbQ6ettiw6HRAQF/7ww8/LJWl+eOPP9KzY0faNm5827fJe/fuRanRY4zKJKzBQKRyJebYfPRmK5999tkt+548eRKlWovTG4fZYEUqJCT3fRRnQh73z5kDwPLlz6NUqVEJgdGXQNboFdhTamJNrkHelA3YQqJZuHAhJoeX5D6PoDS7kEildOzS7aafzY4dO4iLjqGxRssHLg9alQZv5baE1OqBXGMgpvVk9EYLq1evJis9ncz0DFQ6I46M+oQ3HIRCrS11vn7hpZdewu0LIzQ8KqjbC4GH8pkzZ9KoaTNi4pOQSKTYXV5q16tP79592LJlC8XFxZw4cYIu3XtSp0Hj4IJrwsRJWOIrkjHsaXS+BCRyJfFdZ+HJacToMWOCgbe6DRrjq9iS6BbjkMpV2FJroTDYaNiwMb7kikQ1G4VbJmO8wYheIkWhMVChUhVkSg2p/R8nr2ATaosHty8UtT0MqUJN1ugVgUWRK5Q9e/aQkZmFIyugu+2p1I5ev8qEOHfuHK3adiAiJp4OnTojkavRemJwV2iNRKEmJT0DldlJXMfpARNCrRGNKxKpQo1Ko2PmrNlUrlYTV2I+WpsvmHHhzGmC2WoLZigkpKTjrdw+ELCPCMiI3H///RgsdpyxWciUGpJ6zSO0di/UVi95BRtxJ1diwYIFPPjgQ4RHx1Gzbn1++OEHevTshSOxImmDFuGIyeTxXz1IfPnll9x9990sWLAAjc5ASt/HiG03Fec1kxkIGKXojBaMkQGN6ZBaPZHKVRjC05BrTXgqt6N1++sftv/1r3+hM5jQGS3Uqd8Qs82Br0p7TOEpgWxnjYG8go3kTFh73cuQHr364M1rSlTz0UgVKiRSGY7MBuRMXIeQSMiZuBZXfktCanS7JtPSBUdmAxQGG77qXTA5fWzZsuWG98XRo0cJj44jtHYvskavQKpQkzvpFbLHrUImV3D48GHGjB3HxEmTr7v+9+/fT1ZuBUIioln0q5cB5fxvUh6gLg9Q3wi/30+frl1x63RYNBoemTfvr55SOX8TvvjiC3bv3v1f8TLwypUrzJ41i+GDB992HXyz/g8++CATJ076jxpB/js//fQTDRo0QAjBiGuZ3gcOHOCTTz6548/p6tWrtOvYGZVaQ2ZOPj/++OMN2x0+fBitwUzu5PVkj30pKJX2d+K1117DaLYgVyiZdldA1/nixYsBT5taPXBnNyQ6LoEPP/zwluNcuHCB/EpVUajUhEZE3dbLqKSk5A/J1v3www/RmyyE5jbEYLbdsBrB7/ezc+dOGjZuglytCySYqLQ4IhJwun388MMPnDt3Lqgn3rxVW5wJ+XgrtMDtDS2V6btq1Sp69OrDs88+e91nuXv3bvRmK5bEqqgMVipUrhasHH7o4UeoVK0mWpON7PEvY4xIw1etM3kFG3HE59G0adMyVbaNHjsOW2gczqRKyJRqbL5IPL4wDh8+fC1A3TMQ9I5IJ6RGN7xhkXd8Tlu2bocjOg13Yj5ZuRXu+CXW888/jze1SlBKMKdCFQBatGqLMy4bT2YdomLjf1flotsXRuqABeRP3YwjPIG33377N4/1e3n33XcZP34CL7zwwt/u/v6n848IUAfmKSLKA9TllANnzpzh/vvv58EHH7yuTOaTTz5h+/bt15WJHTx4EJtOxzyzhfYmM60aNPiPzHX63XfT5lqAurvJRNOGDTFYHXiS8vGGhnP69OlSc7QbDPQxmkg0mph1772lxtqzZw/R0dFIJBIcajUurZZZ997LqVOnCI+KwR4SjdFiK6UrfCMemz8fT0gEoeFRdOrUmeEjRjJt2jQ0Fg8xbaZgMjlop9VRRaWmYkbGbY/x6tWrmJQqRhqMbLI7MUmlOD0+uvboFVyEHT9+HJPFhs4Tiy21ViDDumZ3DGEppA1+CoPVyZ49exg9dlxAxqBqJ7LHr8YRkXRLrTOP3cGYayY1TdRqZEo1UqWWuE73BDR93WFI5UrkGiNytQGZTEFIzR4B+Y2Q6OsWnj///DNavYGkng8S134aVrsTv9/PRx99hEarvxZMDOjM5UxcF9BiVmqQKrWYbC6i4hJZvvx5AJYufRqbw0VIeBSNmzYPBhud2Y2RqXRoDGbUOiMavQm11kDVGrWJiU9ArtYhU+uRyJQYwlLQ2rx0694TvclCSM3uSBVqvHnN8VbrhFSuRKlSU7lqdRRaIxpnBAaLLaANZrIg1xgxx+XjqdQGp9vHhQsXqFG7LnKtCZXFi0yp5oUXXuDq1as8+uijZGRlY4vLI6Xvo+gsLhR6K5FNR6Cxh6HQW5FI5RgtdpQmJ1KFJrjYjWg0mPQhS9Bb7MjlCvKmbMBXrTPm2Hwyhj2DJSqd++67L3ie9+7dS0Z2Ht6wCIYOHRbUSNyzZw/33HMPVm8keQUbSenzKHK1Do3OSFZuBd544w2MdjfJvR/GU6EluRUq03fAQEJqBs6tt2IrCqZO5fTp06WyH77//ntUOiM5E9aSPnQpGt3/6+41ad6KqGajAhkj6XVQGGxIlOqAFrXFi9kVxqJFNw7Wnj9/ni1btjB58mTcsf+vPy1TaVGaXBjCUrGEJtCmfcdS/U6cOEH1WnWxOd0MHDyUAQMHotDoUaq1mG1OfBWaY4nLR+eOJqHrLDTOwEsAiVwVyOaZf/Nsnmq16mIIS8Icl0/qgAWoTA4MDh9mZwhDho24aT+AjJw8wuv2IbnXQ+hN1j/E4Kecfy7lAeryAPXN8Pv97N+/n0OHDv3VU/mf48iRI+zYseM3ZfiVU3b6dOlCDZOJUUYTDqPxjrSa/25cvXqV4cOHI4SgQYMGf3o2t9/vp1GT5thCY7G4wxg0ZNifur/fgjc0gvhO95I16gV0JmtQM/qLL76gc7ceDBg0hBMnTpTqU1hYeEOtYr/fz88//3zLIN2SJUtxeUOQqzTI5AoGDBryu4N6n3/+OQsWLChlvP1rOnftjsUdhkJnxpnThKyxK1GqNWzevJmffvqJ2XMeQKXWolJrmT//cS5fvszcuXOZMqXgjjJzH3vsMRyJlVAaHYFnp/gKDBj0/5KZfr+fXn36IZMrMFms2F0eVBodeRWrlPl7zBceRWr/JwLPUVHJLFq0KNh3//79OD0+JFI5+pAkQqp3IbdilTLPHwIvDqRSGTkT15JXsBGdyXrHv2/vvfceRpuLhM4z8WTVo3O3HkDgunnyySeZO3cuJ0+eLNNYn332GRnZeYRHxfL884FktnPnzlG5anVUegv2qFS8IWGsWrXqOnmh/xbOnTvHoCHDaNCkeamEsf8F/msC1EKIfkKID4UQH4aF/T1Lacr5z/H+++8zoGcvZs2c+bs1Rv8u+P1+1q9fT4TXSxOjkQYmM7UrVQpun3PffXh0OpLNZupUrlwq83bbtm3k2mwc9obwL4eTOJ/vRru46X5/6yLi9OnTZCUmolMoSI6O5tixY+zevZvVq1dfZ5iyfPlymtgDzuYv2OxUuUFw+OzZszRu3BghBE2aNOHixYs89thjeNJrkthtNs7cZjRv1eam8/noo4/Qme0k9XwQfUgSWmcEvupd0RnNKNRaFDoLdrmCw94QPnd70SqVZTrOxNBQXrI5OOTxkWY0XfdDsnnzZjzx2WSNXoFca0aqUCNVqLC73JhtDmbNvj/Ytm6DxkQ0GhrImo3PKWUS+e+YLDa0Ki1hGgMaqYyQOn3wVGmPQm/FGJKAUq1FabCT3OcRHBn1ArIiWiP2uBwiomOvkww4evQoKo0efUgiCr0VmUJJSUkJQ4YNR2V2E9NmMjkT16I02kns8QAhNXugsrhRGh2E1u5NYvc56IxmPv74YxRqbSBjt+0UrHYXUoUKjTMCpcmJNS6Ptm3b4oxOx3pNciSsXn+kCjUytQ57el0M4WnkT91MSt9HiYpLZNu2bTRs2jxgDNhlJgqDjbj2d5ExfBlytRZndmNi2kxCa3bQt29f3n//fRYsWMDAQYMZMXJUcPHtC48muvUkUvo/gT0yhZdffpkhw0fiiE7HFJ2LVKlB541Haw/FV71rsHxQqlBjTaoaOA57OJ5K7dB6Y5Gr9SR2n0PelA1oLG5sdhch1Tvhq9IejcGCxe6kfacu130PXb58mb79B5Kamcu9M+8L3mNFRUVUrFIdW2gMWqOFqNh4ImLimTR5CitXrsQWlUZY3b5IZAokciVVqlXHaLHhjknD6nDRoVNnlGptoArAamPevHncPX06KoMVudaERKEiLTMbq8NF5eo1GTRkGO7kyiR0uQ+l0Y5ErsSSUJns8auxJVamTZu2wbmdOXOGK1eucOLECY4dO8bKlSsxWOy4E3KRKVS4K7ZBbQ/DEJ6GRKFBpdHy6KOPcvnyZUpKSnjiiScYPmJkKTfzZcuWYXKHE9V8DBqrh+nTp9N3wEA6dulGn34DSM/OwxcWidrqJabNZNyp1bnn315e/RpPSDjJvR/GklQVmUqHyepk6tSpvP/++7f9HvOGRpDS51HyCjZi9UYG9dP/SM6dO8cbb7xRHtj6B1AeoC4PUJfz92Lbtm1YdTrSLBYSIiL+o8Z7t+KDDz5g+/btf1o14l9BnM/HVoeLw94QKtrtbN269a+e0u9m4cKFNzVP/KMpLi5m27Zt7Nix42+TXXnp0qXgXJweH0k9HyR7/GoMFsdtZRe2bt2K3mhCqdLQu2//Ozqmb7/9Fp3RgsYRTkzrSWSPX43e6qJeg8YsXPhkmcc6ceJEmfWLT58+jUoT8CzKHrcaiVRGTJsp6E1mCgsLOX/+PCq1lswRz5E+dClKlfo3a4Dv3r0blUaHJaES+VM3E9tuKpWq1bqu3ZUrV4KyKqdPn8bv9/P222+TmJpBdFwiL7300k330aR5KzyZdYlsPAzDDYLHJSUlLFz4JNHxSVSuVvM3VS3EJiQTWq0j4fX7Y3W4uHz58h2PsfDJJ0nPzqdD566cPXv2jvv/QlxiChENB5HY/QF0BjM//vgjDRo3w51Wg5AaXVGotZg9ETgikqjXoPHf5h77I2nTriOejNpENRuF3mT5w4xH/wn81wSof/2vfIH8v813332HTa9nksFENZOZof1urkv1T2LUkCEkGI1kK5SkKxR84/YilUiCP6gei4U3HC4OenxEGo1B7SwIZMZGejw0t1hJMJoomDChTPtc+vTTqLU6NFo9y5bdPFB6K/x+P2fPnr3tj8cXX3yBXafjXpOZaiYzo4cOvWG7kpISpk+fjkQiIS0tjXnz5qExO1DbQlBbvUTFJdx0H+vXr8cSlkhewSa07hgSuswMZDNn1qR79+7IlCo0MhmD9QZa6Q3UrlixTMe4dMkS9FIZYTI5OqmMdevWldpeMHUqUrkKX83uSBUqErrcR0rfx1Br9ddlI3z44YeYbQ70Fju5FSrfVHf2+PHjtGjZCp3ZhsETiVSpQeOKJrLZGCQyJbbUWphj8zBF55A/dTPRrcYj15qwR6fTt29fjh8/zurVq3nuuedK7cMbFoWvWmfSBi1Ca3awc+dO5j30EEq9hZjWE8mZsAaF3opUqUGht6Iw2JBrTaQOWEBewUb0VidOtxeZKrAwTB+yBJlCgdYa+JvWHYtCreWZZ57BHhaPyuImbeCTRDYehsYRTmz7aWgc4UgUKsLq9MERl0t0XCLZ+ZVZuvRp1q1bR3RcIgq1juTeD5MzYQ1yjR5TTA6G8DQ0rijcmfXw+MKu0x3//PPP0eiMSNV65FozMpWWCpWrER4dR3TL8Sj0VlL6zSekZneUGgM6kxVPxdbIVDps6fVI7b8AiUKNOb4icp0FiVyJLaUGUqUGudaE1h2Nw+2lU5duxCYmYzBbya9crVQZ6JkzZ+jeoxcR0TFYw5NJ7DYbqy+KlStXMnv2/fTp15+NGzfy0ksvoTOaCW8wEE+ldih0ZhJS0pGptEgVKjJGLCOh62ykChXHjx/njTfeCJgPWp3kjH+ZxO5zkCq1gc9JrcMcVyFgphidhcEVTvrQpfgqtKB9py70GzCIjJwKJKdloHOG4cptFszIHjN2HH6/n87deqDSaFFpdCjVWtQ6A2FRscS0mRwotYvPQabUYIrKRuuOQabU8Mwzz+DyhCCTyUnPysEekURIja4YTNagtl6PXgEDz/ypmwmp1QOLrbTh2KuvvkpsYgrG0GRyJ6/Hm9eUwUOG3lCeBuCuu6djdoWiNjlw5bcgvtO9yFVa/vWvf13X9ueff2b8hIn06defL774gsefeAK92YbNF0WlqjXKnJWxbds2GjRpzoBBQ27phH7y5ElCwiJwRaWgN1lKGTfdCZs3byYzryK16zf8n1qw/qcpD1CXB6jL+XvRqHoNHjIHfCgaWK0sXbr0L5vLmTNn6NKmDREOBx61miSTmaZ16vzXBEoG9upFZZOJwQYjTpPpumza34rf7+eNN95g7dq1vykA9nt5/fXXg+aJv8jQ/VMoKipiw4YNvPHGG3d0nV26dIlqNesgkyuIiI7l+++/Z9WqVWh0BlQaHQMHD73teNHxiQHZhvEvY3J4byv98Wvef/99rN4ItO4YYttPCyS6GGy4K7XF4ou6aZXeL/j9fnr37Y9Kq0OmUKHW6Ojdt/8tJSguXbqEQqUhrv00YlpPRCpX4vSGBqVALly4gEqtJX3IElIHLkSl0d5yzbdy5UpCIqKJT069rlL3m2++oVadeijUWuzxeRitTp59dtltz0txcTEGkwVjVCZyXSB56YG5D96w7U8//cSgIcNo0rwVb7311m3Hvhl79+7l7bffvuGxHjx4kHYdOtOsZRv27Nnzm/fxR2C2OUgbtIi8KRswObx89tlnmK0OMoYvI3/qZpRmF4k9HiB38qtodP/sCo+bERWXSHLvhwOSlAnZbNy48a+e0n+M8gB1Of91rFmzhjp2B4e9IayzO8iKi7t9p38ANoOBXS43hzw+vDIZzfR6shITg9uzExOZajLzos2ORavl8OHDpfqfOHGChQsX8sorr5RpYXPlyhVUGi1pA58kdcAC1Brdn+4w/frrr9OjfXtmTJ9+28z3jRs3YrFYMJvNSKRSciasJXfSKyjVmpu+tb1w4QKhEdFoHeHIFWq0zkhCanTDYLIyaNAgfNU64a3aEYXOjNnq4LvvvivTvLt2647SYCOh22zi2k0lIiY+uO2nn35CJpcjVenRh6UgkcrIHPEc2eNWo9bqb7jov3jxIt9//z0bN27k7rvvZufOnaW2nzhxglCnk0Y2G26NBqVSRWL3B3Dntwxk1kpl5E5eT+ao55EqVGhdUUgVauRGO2qdkZMnT9Khc1ccEUm443PIrVA5uNBLy8wlrsPd5BVswhmdyvr167l69Spt23VAplQjkcrIq1iZGrXrYXV6kKs0aIx2FBoDFl8UcqUaS1I1NK4oFAYbMpWO0LBw9CGJpA9ZgiO7MVKlltOnT9OxSzekchUqswu5xkho7d5BzWG5Sk1ehUqkZebgyahDfMfpGG1Odu3ahd/vp137jgH5EqUGrcGELbk6Ok8slsSq11zjE0udtx9//JENGzZg8YQT1mAASpOL1AELcGTUR6nRo7aHobaHEtV8DI6sRhgsdmrWrIVEpkDvS0CqVAfOrUxBVKvxaF1RmOMqYk2sgsJoxxRbgezxq5FKZdx9992ozK6AEWReC/IqVg7OIzk1EGTWeWKRKtWkD3sWX15TKlWpit4ZhsYZiUSmQKHSoNAayCvYRPa4VUhkCmRKNbHt70aq1JA9bhUp/eYjV6qDY+/fvx+dyUrW6BXEtpuKkMrIGr2C7LEvIZHJkevMCCGwxOaSP3UzUc1GERYVF8z6unDhAsOGjwhoUts9eEPC+OGHH3jvvfcwu0PJujaPjBHLyBq9AplCiTOlKgldZqK3ONBZXeQVbCJz5HJUWh0VqlQnsskwciasQam3lHoh9EtlQFpmNjK1PigXI5FKg99PH330EQazjcimIzCEpaDSGdGbrGj0JjQ6ww2NagC2b9+OxeEOLuy07mjSMrN46qmnmDNnTtAMtm6DxrjTaxFasxsWu5OffvqJ/fv3884775Q5OP3dd9+hN1mIajYKT2YdWrRud9O2CxcuxJtRk/ypm4lsOpL6jZuVaR+/5sSJE+iMZmLbFRBaszspGeXrnT+L8gB1eYC6nL8XPTt2pLvJzHaHiwSTiQ0bNvxlc+napi0dTWa0EgkfuDx87/Hh1un+a6ShioqKeOSRR5gwbtzvMjX7d6aMH0+U0UgFq5VKmZl/SXn+119/TUJCAnK5nEXXjNz+zly5coWjR49SvVZdHJFJWDzhDBk+ssz9n3zySVwJeeRN2UBI1Q506d4TCKz5bvay/9+JTUgmtv00ssetxmj33FRW40ZcvXqVytVqYrR7kMqVyBRKdN448go2Ed5wEN1uYDZ59erV4Av/zz77DKPdTc6ENSR2ux+V2Y09/NYZx/v370ejN6F1RaFxRiJTarGGxLB48eJgmycWLEClDlT73SqgfOrUKbR6I4ndHyCqxRh8YRHBbYWFhbg8IYRU74I3vzmhkdHs3LmTyVOm4nD7MNldWO1OxoybcN2z94ULF5ArlMh15mBCj1Zv+Pfd/2E8MHceeosdW0g01WvW+VtXfMy+fw4GiwObL4ra9RpSUlJC+05dcMRl481rilylIaxOH6Kaj8Zksf0huuZ/N6bedTdWXxS+rLq4PCGlZFH/2ykPUJfzX8eRI0dwGI0MMBjJNJqY+G8uvf9UKmVkMMRk5iGzBb1CQf/evUu9Mdy3bx/Vc3JIjYrixRdf/N37u3TpEkqVmsyRy8kYvgylSv23+wE4cOAAGRkZgaBbfEWiWo7DZLFRVFRESUkJn3/+OUeOHCnV5+LFi8ycOZNWzZvToGFD+g8cxK5du3jjjTfQ6I0oDHaSejyAK6Numd2oU9KzUBrtZI1eQWTTEYRHxQKBhUt+WhrxcgUWqZTwmt0Jrd0rEDQ2WujavWfQnKO4uJiDBw8GM0pWrlyJ0e7BV6U9epO1lNzAiy++SD1bQA5ludWORakmr2ATYfX6o/fGYomviD4kCb03DqlCjdLsJqRmD+I63oPBFcnGjRuRyeTkjH85kPVstnHw4EEAXnnlFdRqLUa5AptGi8lqx2y1s3z585SUlFyX0X3gwAF27NjBnDlz6NmzJ3qLk7RBi5BpTGg9MWj0RuRKFVKlGplaj1xnRqXRBsdZu3YtMpUWiVyJVKnBmlwdmVKDp1I79CYrqZm5xHe8JxC4Tq3C888/z7p167B4I4nrOB1zeDJ6u4/8qZvJHPEcMqWG8Hr9MFpsweB/y5atUWgNKNQ6YhOSkCvVmGKuZZa3GItUqSG0dm/kWhMaRxiOrAbIVFpUZhfO7MaBLHCVjuyxL5HUYy4SuQqJTE5ewSbyCjYikcqQq/Uo9RbiE5Nxe0MwRmWSV7CJ6BZjkal0rFixAgCF1kBs2ynkT92MISIdoyscg8mCUqNH641HIleSPngxWWNeRCJXBqRo3DGoTXZ84VH4KrRAFxIwmpTKldSsVauUwcr4CZMQEikShRqJXEli9zkk9ZqHVK4ktGYPMoYvQ6oKZHzL1AZ0Vg8LFy4s9ZleuXKF/fv3B6/FDz74AJPDS9aYlUgVapJ7PxzQd9Zo6dS1Oxk5FZh9//0YLTYiGg8lpHIbsvMrkp1fiehW48mdvB6txYklNOG6DOrw6Diimo4itE5vVBYvNWvXCc5jyZIlhGTVCRquJKdnYbA4yJm4lpQ+j2J3eW56T/bp0xeF1oQxIh2VxYPV6cERk4E3uz4h4ZFcvHgRo8VG5ojnAvrboTF39MD1C5s3b8YTlxmQo+nzaKmXU//O2rVrsYbEkDpgAd6chvTu2/+O97dnzx4srlDyCjaSMexpjGbrHY9RTtkoD1CXB6jL+Xtx4sQJGtWoQbjTyaSxY//SbOWKqWkst9qJkcuZYTSxzGrHrNX+bWRH/o6UlJTgMBrZ6Qwk20QajXz66ad/yVzOnj1L/fr1g+aJ/6lgXXFxMdOnT6dn7z5lyoT94IMPsNgcqDR6FFojeVM2kDV6BUqV+rZ9f2HBggW4kiqSV7CR0Bpd6dS1+x3Pe+vWrej0BmRyBYOGDLuje+/MmTNs2bKFtWvX8umnn7JxY+C5w1elPUabi5dffrlU+/fffx+LzYFSpaFlm3Z8/vnn6C2BZ6y49nehtofiSalyy5cLhw4dQmswkT54MbHtClBZvYTW6c3AX2lDQyAQfrvP/ttvv0VvtpE76RUyhj+LRqsPbvvhhx/Qm23kFWwid9IrSKUytmzZgsUTTurAhbhym2GJr4TVG8nmzZuvG7tDx85I5aqgJKLbF1qWU1oKv9/P6LHjsNgc5FSofF2CGgRiBGq9EXt6XbJGr8DiDv1Na97/JHv37i2VMFJYWMj8+fOZPn06r732GtVr1aVi1Rp/ihzf3wG/38+6deuYP3/+TQ1Z/1v5RwSohRAvCCGOCiGuCiEOCyF636p9+QK5nC+//JIpkyezePHiO3ah/bty6NAhOjRvTv0qVf9jZWn3zb4ftTZQ0l+/bj0KJk/+w8r8/iguXrwY1KU2msxs2rSJkpISGjRuitZsR6XVs3jJ0lJ9Nm/ejE2no6LNRqTHw/vvv8/PP//MxIkTscfnBzTE2k4hJSO7TA8b98yYicbsRCKTI1NqWLNmDRBw+E00mznk8fGaw4VOKsMSGke1GrVJSErFaHNhtFipWLkqWpMNlc6Azelmy5Yt1Kxdl4jGQwOB2SrtmT59enB/H3/8MW6dnsUWG011esxaHRZvJFqDGblSjSurMRqjHblMTotWrVHozPiqdyGp54PINHpmz55NTHwSoTW6EtFoCDKlGl9YJBs2bGDu3LkYZDJW2RwM1xuwOcJJ7vMoCoWSho0aX7eQBBg+chS20Di86TVQ64w4IpMx2N3ExsXj8njQeWJx5bdEolChUGtZtWpVsG/X7j2RKjVYEiqjtvqQqrRYU2oESprisxg1ajRGmxNfahVcnhBOnDjBvHnz8OU2Jn/qZtyV2wWlJdwZdQiNjKFD567B8sPt27cjU+uJbVeAJSHgfv3oo49ekxuJQabSYnd5cESno9CZSOn7WCB4HJ6KXGtCqlAFZTyyRq8goetsFAY7UoUaV15zXLnNUFk8SBRqQuv0vmYaqUGuM6M0OgLmfjIFZpuD48ePExYVizOrIcl9HkGhtxAfH39NkzyQTS3XGEju9RDpQ5cikSkQQhASGobD7cPlDaVK9Ro0atqC4SNGYHKG4KveBa3RTMXKVWnaojVff/01+/bto0mzFmRkZQcMaVRaZEo1Uc1GkTdlAwqdGXd+S6Jbjkem1DJs2PBS99OyZcuYNGkSDz30EM1atqF7rz706NUHmVyBVm9AZzCi1Ruvy2B+//33adC4GR27dOPHH3/k7bffxmi2otYZaNysBfPnz2fY8BF88MEHnDt3jlmzZlG7Tl2MDi+OhHwsdidbtmzh8OHDFBYW8t1332G02PDlN8Ngc+Nw+5ApNYTW6RPIII6Ivuk9WVhYSEp6JlqDBZ3BhM5g+v9gdEg09913H3qzDaXeiiOlGt6QsDJrG/6as2fP4vaG4s2sg9UXxeSCqTdt6/f7GTNuAt6wSBo0bvqbAhlXr14lp0IlnNFpmF2hjJsw6Y7HKKdslAeoywPU5fwzefvtt1m8ePF1CQp/JEuXLMGj15NrMmFVKkmLjubVV1/93eMePHjwjgza/gn4/X5GDByIQibDqFDQVW9gkcWGRasNVjT9FVy9epVhw4YhhKBhw4ZlMk/0+/3s3r2b/fv3/6b9xUXFoLGF4K3cHrVCSc+uXW/5XFWtVl0imwwne+xLSBUqYtpMJrxePyJjb/4y/NesWbMGq92JQqNHodLgDQ2/4yz/wsJC8itVxeIOQ2cwBZ9xysLBgwexuzy4Y9MxXjMxB9ixYwd33333DeXX8itVJar5aHInvYItNJbNmzczacpUZHIFUrkSvdVJfFLKLSXVAO5/4AHkysD62hSahN5sC0p8/Bq/38/y5csZMmz4dR5CvxjF16pbD7MrBI3eRH6lyjz11FNBPenElDTc6TVxJeRRt0FjnnvuOTxJFcifupmY1hMxRWfjSapwQ08hv9/P5ClTMFnshEZE8/bbb5f53P7Cli1bsHojSR+6lJAq7Wneqm2p7RcvXsTu8uCr1hl7el103jh0RnOZvmfeffddHnjgAd5///07ntc/lbNnz7Jr167rZCLL+c/xjwhQ3+m/8gVyOf/N/Drg/s033zBq2DCm33XXbwqulIXTp0+Tk5xMG5OJziYTqTExdxz0/8UYoqw8MGsWmbGxdGrVqswLxvnz5yOXy4mOjua5555DZbCRO3k9yb0fRme0lGrfuEYNHjFbOewNoa5Gi1GpxKrXs3btWryh4ThjM5EpNcTq9XhtNr7//vvb7v/ZZ59l/PgJpd5If//991i1Wp6z2hlpMpMaHc3LL7/MU089hTupQqC8rcEgVBYvxqhspCotOm8cMqUmIF+hNRPRaChGWyBo/WsWLlyIWaHEZA9DptYhV2mJS0zBZjBQQ6VCJVMglSno2bMXDqcLmVqPRK5AqlCTV6EyBw4coFnLNig0BsIbDCKhy8yAqaLeTIRcwSGPj1ftTkxaE/b0esg1RtwV2yBVali5cmWpuTjcPtIGPxXQIg5PYPz48Wj0xmvSIip8NQJmg87sxtStW69U30mTJqGyesmfupm0wU8hVWrQW914sxvgdPs4ffo0u3bt4vnnn2fGjJl4QsJJycjCZLFidIUjVagIqdENS2weMfFJnDlzho8//piHH36YDz74gEWLFmGOzQtk4bafhlxjoKioiHtnzMQXFkGdeg356KOPsDndyFQ6zDG5hNcfgFShIqxeP9IGLUKu0hIbn4CQSJEqNXgqtw9khStU2NPrkjFiGSqzm5R+j6Myu7EmV0NI5Whd0WjdMdjT6uDIrE9MfCKffvoperMNmUqLISwFqUqH0uRE54vHllIDW2qtazItchxZDckavQKJXIUlqRr6kEQkEhkffPABzVu1Jar5GPKnbsaV0xRzfAXCavUgLDI6eK+9/PLLuONzrhk99keuVKMzWlCodaQPWUJewSZUJmfwhcHFixeJiU9C64pEqtIhlSsJbzAQb34zKlSuSmFhIYcPH2bCxElMn35PmRZvly9f5vjx49fd/5Wq1sCVWg1PdgN8YRFUqVoNo90TeIjS6HG4vXz55Zfs37+fOXPm4A2NILLJcJL7PBJ4aeB033YhX1xczJdffsnp06epVbc+nqx6hNXpjcliQ6M3kth9DhGNBmNzeX5XIOPYsWM8/vjjrFu3LmgqO2XqNEIjomnQuOkfXpZ3+fJlXnnlFd56663/Gr3TvyPlAery9Xc5/zyeWrSIEL2BFlYbHqv1T808++ijj1i1atUfljU9deJErBoNFo2G6QUF7Nu3jzlz5vylUiZ/BDt27CDKaGSv28ssswWf0UiVzMwbZpT+Edzp7+KCBQvKZJ7o9/tp17EzJocXvdnGPTNm3nbsvXv3Mn/+/KCRpkFrJKbNJEwmJ910ejrqDeQkJ9+0f+36DQmv14+ciWsxOkOISUimao3afPnll7fdd1FREWqtHnNcBeR6GzJlQALxqcWL0eqNmCw2XnnllduOM2DgINT2QOVWfKd7SUrLvG2fX5g5cybevKaBdWjdvnTu1uO6NidOnKCgYCp33z2ds2fPBuThmo4gd+I6bCExwSB2cXExZ86cYc+ePRQWFrJixQqsNgcuh5MXXnjhunG79eyNO7UaUc1Ho9YZg5WMJSUlpbyRnnxyERZPBKG1e6E320pVJfbo1QeTw4vB6qRRk6bojGZCa/XEGhrL7PvnAIGA5oMPPsj8+fO5fPkyP//8MzHxiVh80UgVKowOLzHxiUyePJmZM2feNrB+p7zwwgu4E3IDVZutxlO5emmDxn379mF2BipNf5H8K4uv1LZt29CbbYRUbIneZOXNN9/8Q+f9W9i+fTthkTG4fWGsXr261Da/38+4CZMCWtU5+bd9dr8RX3zxBRa7E0dYHC5PSLC6uJz/LOUB6nLK+Ydw5MgR4hNTEBIJdRs05tSpU/jsdgYbTTQ2mWlRvz4QKKVq0bodcclpzH3wod+93ytXriCXSvnB4+OQx4dRpeLkyZNl7tuoZk3kUinx4eFl+rF47bXXiDQYWWt30MZkZkDPnmWe6zvvvIPH40GlUiGRKwPme01HIlfpSrXr36MH7U1mNtidhMhkPGOx8ZjZSo3cXL755huq5OfTX6vjsDeEHkYTM2bMKPMc/p2VK1eSnZBAhfR0nJ4QXN4QRo8ejSMymeyxL+Gp1AaZSkdEoyHoQ5KQKlRkj1tNxrCnkcgUSFVa7rrrrlJjlpSUsHPnTpyRSTizG+Gt2om8gk24U6sRGx2NRConpd98UgcsQCKT467UFqlSQ2L3B8iZsBaDzc2nn37K5cuXkSuUZI99iexxqwPayCGJmC1u4rRGjDI5cqkchd6KPbU2Cp0Fa3INatWuHZzL1atXqVS1Ot7cxkQ2GY7BbGXUqFG481sE9IZrdkeq0qJ1RyNT6wiLjObTTz+luLiYXn36oTOakSnURDYdgSOjHiarg6eeeoqHHnqoVNDws88+w2BxkNL3MUJrdUdrtGAMTULjCCN/6mbSBy9GqdXzxhtvoDWYcWbWD0h3hEehN5oDC3SNkYGDBgfH9Pv9vPTSS+RXrIy3YmuyJ6xB6wi7lnGsJaXvo+ROegW91YXWaMaV1xKZxoBaZ0AqV2KKzUNptKO2hSDXGDHF5CLXmcmduA5fja7I1AaEVEZewUbyCjah1hnIr1QFY3gq1sSqZIxYhkylw5XbFLU9DKXJiVSpwe70IFVqSeg6i4Ru9yOkMpRGB5FNhqM02NFqdTz8yKNYfdGE1u2LVKnFHJsfuGYkUqbfcy/tOnbh4YcfxmhzkdTzQXwVW9KoaQsOHTpEuw4d0dm82KIziU1IDkr3bNq0CWt4IrlTNqD1xKAw2IKa0lq9kdOnT+N0e3Fm1MMen0elqjV+0z1RXFyMRCIhd/Kr5BVsQme0IFeqCK8/EHNsfkCupnYv2rTvFOxjtbtIHbiQ3MmvYnJ4+Oyzz0qN+eCD82jQqAlLlz59w32ePXuW4SNG0alrd15++WVMdg95UzaQPmQJRovtlvN988036dqjF/fNml0mHf5NmzZh8USQ0m8+3pxGZZYKKivHjh1j3rx5LFu27G+tIfhPpzxAXb7+LuefR42cHJ6x2jjsDaGxzcayZbc3K/s7cOHCBTQKBXtcHj5xeVDKZNgNBnqYzEQaDDwxf/5fPcXfzNatW0k2mfnW4+NJi40KKSl/yn6+++47YuKTkMpktGnf8Y5+H19//XUsFgs2m+2mVaoHDx5EZ7Jek3pYhlqru2G7X/jwww/RmyyE5DVCb7Yxf/58TGo1RrMbjVTGIY+PHzw+ZFLpTX13vvjiC7yh4UilMtp36nJHCUKXL19GKpNjisoiffBiDOFpTJ48BbVWR9rAJ0nq+SB6o+mWAf0TJ06gUmtRGh2kDX6KkJrdqVqz9k3b/ztLly7FHplM6oAFuFOrMWFi6aqvkpIS4hKT8WQ3wJNRh6zcCnz44YfYHC7kCsVNj/nEiRNolSqS1VpGGoxopFK+/fZbAM6fP0/B1GlYnR6iW4wLVKKmVGL16tUcOHAAX1gESnXAJP3ixYu0ateBqGajAs8sldswc+ZM9u3bx5gxY1CoNORMWBvIYJdKCcltFKyyrVm34U2P+9KlS+zYsYOPPvqId999N3CMWfVxp9UgJ79Smc9fWTh//jzJaRlYvRHoTRa2bt1aanthYSER0bF4supji8kiIzu3TMlfgwYPDXoDhdTszshRo//Qed8pfr8fk8VGXIe7SerxAFq9ISiTCdfuYU/ABD6keicaNLlzn5f+AwcTei2pypvfnKnTpv2BR1BOWbnV+lsqyimnnD8dQHz00Udi9+7dInBP3phmDRuJb/d9IVQyhXjnwz1i8ODBQl9cLCbqDeIetUa89c47Qgghho0cLXZ9f07Ic7uJe2bNEW+++ebvmp9KpRJZyclizKULYuLFCyIsJERYrVYhhBBfffWVqJqVJeJDQ8XTS5de1/f5558XF3Z/Ir5xeUSDn34Wd02YcNv9/fDDDyJFoRA5SpWoJZWK77/5psxzrVSpkvj4449FVlaWoLhIfPbkYHFo+zMiKjqyVLtZ8+YJf9UqYqhUIorlcpGuUIgj+MWly5dFWkaW+PDz/WIdQnxZVCT2SoTweDxlnsOvuXz5sjCbzWLWo4+Kz779TlhrDRK2eiPF/CcWCqMC8fHcjuLkx5uFxhEmXDlNhLdyW4HfL4rOnRRXzhwVUoVSyJUaERsbK4QQ4uzZsyK3QmUhVyjEqLETRPGF0+Lij1+LkisXBP4SQXGhOH7mrEAgLh37VkhVWiFAnNqzTUgkElF8+WdRUnRJUHJVqFQqoVarxdBhw8RXiweLr54aKMLCwoRM+MVlIRUnw9PEVbVGWFweEdVslIhuOVZo3dHi7L53RG5OjhBCiDfeeENo9Caxc8cOceKzN8QP/3pSlBQXCUAUHvtaXDrxvTh/6HMh8RcLmUIt4jtMF6cuISpVqSaWL18uXtm6Q8T2elRYYrLEyR3PiQsHPxVSk0cMHTVWfPzpHqHVaoUQQpw/f14cP35cqIxWoXVHCaXZK4quFouYDneL4isXxfebHhffbnhE+JGIwUOHCmt2UxHZdKTwVe0kzlyViarVqokHJ/QTb27dJB6f/1jw85nzwFzRf8R48fkPp8TVKxeETK4UQqYUOm+cCG84UHz57ATxyUNdRGSYT5gTqgq1xSVkSq3wy9VCZQsRl45+LZz5LYWMYjGgdzeR7tUKUXJVHNu1Tpz+dKtQW71CptSIb16eLQ5tfESEhoaJL7/8UngqtxfnfvhMHH5jmdB540REw8EistEQgb9YqNQasXPHm+KBWfeKgy/PEAdemi6M4anCldtMOLMaCmduE3G5sEjcPf0eceH0j+Lw60uFoET8/O3H4tP5fYXRYhOPPrNa7PrZIiZPmy4G9Okhit5dLFIsV0XXTu1F+05dxKqX1wpUenHm+72iQf06QqVSCSGE8Pl8ovDnE+LUntdF0bnTQq7Wi69fulfsWz5ZSKQykZSSJn6+4henvnhbnDv6rXjvvXfFwYMHb3jtv/766+Lee+8VO3fuFEIIcfLkSdGle09Rp0Fj8fbbb4uM7DxxePNj4si2p4TFYhZqtVpcPnNElBReFJRcFf7Ci0KlUgbHu2tqgfj2+Yni66cGisr5eSIpKSm4bejQYWLMhIli+84PRb/Bw8Tzzz9/3XzMZrN4aN5csfzZp0Xz5s1Ffk6W+GbJEPHt8vFi0oTxN72H9+3bJ5o0byneOqoU8xa/KMZNmHjb+/7o0aNC4wgXOne00ISmiMNHfrxtn7Jy4cIFkZWbL+Ys2yRGTp0lBg4e+oeNXU455ZTzTycpPV28VFIiNl6+LD4uLBTx8fF/9ZTKhEKhEHKZTHxfUiy+LykWUqlU1FAqxb06vZgiV4o1N/hd+6dQo0YNEVeposj56YwYX3RFzHzkkT9lP7369hcnL0lEWINB4o3394jVq1eXuW/NmjXFrl27hMPhEHXq1BGLFy++ro3BYBD+4qvi4o9fiwuHPhdmi/WWY65du1aYUusJX4NhwpbfVuz6aLcYPW6cKL50RsgkQow4f04MuXRBVMzMFErl/693Zt17rwh3OkX13Fyh0+nEwW+/EefPnxMrli8TUmnZwzNqtVrk51cQWneUOH/kS1Fy5aLYtn278IOQ68xCabCKosLCWz57FhcXC6lcLhwZdcUXT48Rx95dJZY8uaBUm4sXL4rPPvtMXLp06br+Xbt2Fe0a1xZnNt0vqiT6xJTJk0ptP336tDj0wyER2mi4CG06Snzy0QciJSVFnDj2o/j5p59uesxnz54VCr9f3K3TidEGo8hWKMQHH3wghBCidbuOYtHaN4Umrrr4fuMj4odX5ogrJ74VlStXFlPvmi6kkZVFxpiXxHdnr4ply5aJhnXriDMfrBZHdqwQP32+XSQlJYn8SlXE8rcPiJKSEnHh0Bfi3ME9Qqc3ip++elccefsFcfrdFSIvO0P4/f4bnjeNRiOEEOLbb78VRqNRfPfd9+LSudNCG5UrPv7gfVFUVHTrD+8O0Ov14uMP3hevrV8tDny1T9SuXbvUdqVSKXa9+46I1FwUV04dEscuy0VuhUriypUrtxw3LzdbXNz3hji1Z5u4uP8tkZuTXWp7YWHhbcf4I/H7/eLSxfNC740TWne08PsRly9fDm4/e/asUOqtQmV2C7UjUpw+feaO92G3WcXV0wdF4c8nRPHZI8Jht/+Rh1DOH8HNItd/93/lGRz/nWzfvp0lS5aUMgb8b6B/jx6EGwyE6PWMHjLkhm2+++47DHI5n7k9rLM70MrkaORyfDY7fYwm6ppMtG3SBICKVWsGTdi8aVV59tlnbzjmnXD69GkKJk9m0vjxpfTiKqanM8VkZp3dgU2r5cCBA8FtJSUlNGnYkMpqNT94fIwzmenapi3FxcW8++67fP755zfc1/Hjxwl3ualqs+HQ6XjllVfw+/3s27evzOU6RUVFtGvXDiEENrsjqEf87/j9fob1749OpSI1JgaXJ4Skng+SO+kVNCYHoXY7wwcMoLCwkC+++KLMpfqFhYUcO3aM1PQsdFZ3QIdYriSkVg+yx61GoVSh1BrQeWKJ73QPUoUad24TrL5oWrRshVKtRapQIVfpcHtDWLhwIQ899BBDhg7Dk1Wf3MnrcaVWY9y4cQwbNhy3LwyJREp8UgrukHCUJicaRzhSpRql1YfCYCOh6yzkWhMSqYypd91dar6ff/45n332GT/99BNDho0gJ78CEVHRKDVapEoN5tg8olqMQabSkpWdEzSsiIiJxxiZgSu3GTpvHKaYPOI7TicsMoY+/QdidXqITUimVp16hNXtG9CMrtgahUrDjBkzcCZXJX/qZkLr9EGm0mEIS0Wq0hLdchzuzLo0a9ma+o2aolCpcbg8pKRlYguJRqEJyE+E1u6NPb0uMrUeT8U2SJXagOGgyYk9ox5yvRWZSkdKWvoNP6e8StWI73QvWaNXoDJYkUikKI0O5BojITW6ofdE07VbD2rXa4BEoULnS8BbuT1SlT74mUoVambPeSCYgfL666/Tr/9ApDIZ2ePXkNT7USQyBXKVBl9YBJ26dMMenogpLDkg5aJQE95gEIawVGQaIyabIzjW+fPnadW2PdaESoFjrNQWudaEkMqJ63QvUoWK1AELSOn7GBKZAlNMLjK1nshfMkGy6wYdy9977z30ZhvhDQaidUcTVrcvloTK6AzGUufkyUWLMFrsSBUq4jvPwJZSE4XBhlQmC8hxVO2EMzug/+3Kb4HT7eWuu+4qZZ75yiuvYLQ68VVph95s480336R67Xr48psS1Xw0epOFvXv3MnbceIaNGMmhQ4d48MEH8YSEozfbkEikxCYkX6eP98033/D0008zffr0UrqFJpuTpB4PkFewEbUthFat29z2Hi0uLuadd95h7969t2y3fPlyQjICmugJXe4jK+/2mS+nT58mNCIKV3QqepPlOnme38O7776LIzw+UDUwZMktjSIh8FncfffdQd3HcsqOKM+gLl9/l/OP48KFCwzr3596lSqx/Aaar39nVq1ahdtiwW2xMGfOHFw6HQ+YLVQ1mZk0duxfPb3fhd/v5/Dhw3+aHOE333yDTi5nqN5ArEaH2e7jmWeeueNxzp49S7169RBCMHLkyOuysF988UW8oRHEJCTf1pxt5cqVWDwRxLadgj0iiYcefiS47dSpU0yfPv06yYedO3cSZjCwzeFiuMlMVmpqwAtIpebBeQ/f8fF89dVXaPVGFHorUc3HYA2Np1bdemj0RtRaPfMeeuS2Y4wZNx61Vo9aq+Opa2vKXzhw4AAOtxebNxK3N/SO9dNLSkqIjkvAm98UT3Z9UjOyaduhE2arg/qNmpTKkP01fr+fuKgYUhRKxhiMGJWqYAa1wWQhc9Tz5E/djMkVyvjx4zl06BAAXbr3JLRaR/KmbMCVmM/ChQvx+/2sWLGC4SNGsm3bNtatW4cvueI1WZJ+qHRGouOTeOutt3jnnXdo3aYtKrUWg9VJpao1bpj9Pmv2/ZgcXjyJeQFpPYMNjSMcmUpH1C3MtP9MLDYn6UOXklewCVtI9E2fjX/B7/fz6GOP0bRFax5/4olSmfYLn3wSpVqDUq3h4Uce+7OnHmTqtLvRm6wYrE769BtQatulS5dIz87F6gn/zWvvCxcu0LhZSyx2J+07dblpZUM5fy63Wn//5Qvd3/qvfIH838djjzxCmN5AM6uNEIejzBITf3fOnj2LTqnkK7eXz91elDJZsNz+13z//fdY1Go+dXlYbXOgk0iINhpZv349kyZMYM6cOcEA0erVq9GbbXgScvCGhnPq1KnfNccLFy4EF09vv/02/bp3Z86sWYwcPQaDTM4mu5MfPD7iTCbee++9YL+lS5eSZjSSKlegkUiw6/Xs27eP5vXrE2sy4dLpmHPffTfc55kzZ1i/fj379u0DAhpgBqsTrdHM/XMeKNO8T5w4weOPP45Wq8Xj8fDOO+/csN2lS5comDqNnr37EhEdR1TzMaQPfRq92ca+ffu4cuUK+ZWqYnJ40BvN1xlo/DuvvfYaFp0OtVyOUWdCqtSSPfalgPyCVIbWZEWh1hDX4e6A/IjOjFZvoGPHjixZsgS/309hYSEDBg0mt2IVqteshT0yGW9WPQxmK66shoTXH4ApPIUpBQUAFEy7C4s3Em9mHSQyOVmjXiBvygbkGgPO3KbIVDoyhj1DVLNRyNU3L0k8f/48P/zwA2+++SYmZwjuCi2R663ofAnow1JQaXSlFp8mmwNDWGpAxkOhRggpKqsXuUpD/UZNgiVk7777Lgq1FmNEOjKlhsSUNDZv3oxMpUVl8SJVarEmVSW65XikSg1pg58iuffDyNU6dFYPuZNfJaJ+f+o1bMK6detQ64xEt56ITKVDbQ9FqtYh15rQmm3EJiQh1xoxxeQgVahw5TZDrjEG5RCOHDkSDLCPGTseZ2wW4Q0HoTdZuf/++7F4IwmvPwCt1U29+g0YP348MpUWhc6C0uQipd98pAo1GcOeJr7TvZisDiCwyB4+YhRxSan06z+ARk2bI1frERIpcq0JtT0UvSeWocOG88ILL/D444/TvEXLQJBaqcWWXoeEzjORyhSlXoQ8+OA8NAYzEpkcpVqLLywCuVJFxojnkCpUZI56nrSBTyKRK4lsMjzwAkBrxFexFQazNain+PDDDxOS3zRo2qIPS0am1uMLC7/uOliyZAkGZxhyjQGZxoBSbyYzKxuNyYE5oTKmmFxyxr+MNbEKKqsPY0Qa6Vk5hEZEY7TYqFC5KuH1BwTKKqt3ZsKEiQGd8kGLrumUx7Nz587g/u6bNRuTMwRvWjV8YRE3fRG0c+dO9CYrvirtMNrdQe3suKRUQuv0IbX/E8hUOhYuXHjLe/TXfPPNN7c0O/r+++/RG804sxthDY1l+j33lmncc+fO8frrr/8mDbxf8Pv9fPPNN6X0TU+cOIHRYiO8/gA8WfWo17DJTfsvWbIUsysEX+V26E0Wdu/e/Zvn8r9IeYC6fP1dTjl/Ja+88godmjXjnmnTyiQv9b/MsmXLaGIJeMsst9px6fWlXpzfCbt376ZJkyYIIWjUqNFv1gz2+/088uhj1K7fiOn3ziiTPMcrr7xCBauVQx4fT1usyOQKUvo9TsbwZ1Frdb9J73zixIl4K7Uhf+pmIhoPpUPngJH1V199FdRzvh0nT54MnoejR4/ywQcfcOXKFUaMHIWvSrtAUlSFltdJeJSFDz/8kJCwCMxWO40bN8YZn0PGiGW402oycdLkm/YrLCxkzOjRdO/UORhsPXbsGAaLHWNEOq6cJjg9vlIvRb777jvCIqORK5RUqV7rhtfId999h8FsJbROb5zxufTtP7DU9pwKlYlpM4m8KRtwRqXcUMc7LDKGlD6PklewEalcRXSLscS0nohUoWbevHl3fI4ADh06RFZeRUxWOyNHjwkGjC9dulSma6ti1Rr4KrQgqtkoDGbrLc05b0VRUREqtYb0IUvIGPY0SrXmd794unr1KpMLplK7fmOWLFl6y7ZfffUVe/fuvaE0TVFREbt37/5LzVfL+f2UB6jL+UeQn5zMizY7h70h1LbZg4GJfzpXrlzBotPxjNXGIosNu9F40x+ZuyZPRimVohSCWJ2OCunpN12wfvHFF6xfv56zZ8/+rvktXbwYvUqFTqlk+JAh2HQ6phpN5Ov1GA0WQiq3xyCTE6lWU6tixWDgD2DK5MkMMhg55PExUm+gf4+efPHFF/j0er7z+Hjb6cb+b9mbN+LQoUNoDWZyJqwlY9gzqDTa2/aZ++A81Fo9Gr2R3n37ER0djVwup3fv3qxYsaLUYqxD5664kisTWrsXOoMJb2g4OoORmbNmA7Bu3Tqc0ankFWwkps1ksm+jHZYaFcUzVhv73V7sUhkSuZLUgQtJ7D4HvdHMm2++idZgJnfSK2SNWYlEKkOjN+KOy8Tp9nHkyBHGjp+IMz6H6BZjkWsMxLSeRP7UzdhDY5GpNFjiK6EPSaBxsxYARMYmkNT7IaxJVZEqtYTW7kVMm0nIVFqyx61G541DqlCjMNhQ6wN6c19//TWHDx8Oznvbtm3ojeaAvl5+pUBWd4VWmOMrIlPpiIlPYt26daWONSwqluReD5E/dTP60CRs6XVQ28NI6v0Qnsw69O3Xn5kzZ/LEE0+wd+9e2rVrR7169Vi3bh1Tp07FEplGfOcZqCxekno+GBjHF4/eF4/K7MZTqS0Kg5WE7vcTUb8/9Rs3Zf/+/cjVOmQqLfqQJFRqDa3btsUVEoFcqcZkcxHdchwhNXvgym9J/tTNRDYZTvXadYmKjUdnshIeFcORI0coKipixn2z6NC5G1u3bmXXrl1k5uTjDY0gJS0TpVqDTKnGW7l9ILCaWR+dLx6ZUkv2uFW4cpuh1BqZUjCVSZOnoHVGENNqAkqDDblai6di64CxTUQ63iodMISlUrNWQLtv586dGGwuUvo+iiuvBTpfApFNRyJTahg3bjw1atcjKS0DrcFMUo+5+Kp1RqkzkZaZzaAhw9CbbSg1euQqNXKFCoXOHNCLHvU8Ko2OGTNmlKpS+PTTT9GbLHgqtw9m2Bsj0mnVuvV113BRURGt2rZHqdYQm5BE9Vp10Nh8aBxhyDVGVFojQqZAptJhS6lJ9vjVSKQyIpuOJG3QIpRqLWZPwNTQ5PCxbt06xowdj9UXjSelKpHRcVy8eBEIfFcpNXokUhnOnCa4YjPYuHHjDe+tzp274K0ceBCKaDSEzl17AAEDmKi4BPQmC4MG37gK5UZMKZiGzmRFb7EzdMSoG7YZOHgoWqMVpUZPh46d/mOmhMXFxdRv2ASDxYHOYOLVV18Nbtu1axdt2ndiyLARt/yOb9qiNdEtxgay6Su24IEHyvZyr5wA5QHq8vV3OeX83fjFO6OgoICPPvror57O34Yvv/wSm07HJIOJXKPxN2ecP/fccvRmG+74bKx2BzKZjKSkpFIVon8mly5dIjclhUSzGYtGg1KlIW3QIjJHPY9aq/tNSUdBLeyKLTBYnaxZs4adO3diNFuxuENJTE0vk+k1BPTE9SYLNl8USanpTJo0GVdqNbJGr8CVVInZs2ff8fwiY+LxVG5HZJPhSOUqjGHJAfPzuHx69+1/R2ONHDUaT25jwur1Q+eKZPz48de18fv9tw2ovv/++/Ts3ZcZM++7LoBfs059wuv0JnPU81g84Wzfvv26/rXqNcBXsRUxbSYjJFJyJqwhd+I6JDI5X3zxxR0d0y80a9mG0KodyBj2NFZvJFu2bKFbz97IFQosNgfvv//+LfsfO3aMjl26Uad+I956663fNAcoe4B6/fr1NGjSnFGjx972ZdHd0+/BEZNJTOtJmBzeUlWS5fzvUR6gLucfQc+OHWlpMrPAYsWl17Nnz54/dPwjR45QMGUK999/fzBw8p/iX//6FymRUaTFxNz2B+Py5cu89dZbrF+/nsuXL/+p8/L7/RjUarY7XOx2edDI5TS2BYxnVtjsWLXGaxmSXalctfp1wfI1a9ZglssJUyoxabW8++67HD16FLNGw2qbg1kmM8mRkbedx+nTp9HoDKT0eZTY9tNwuLy3bF9cXIxCqSJj+LNkjXkRlUbL999/j8vtQQiBymChSvVawUBTSEQ0qQMWkD91M57YjOvMJbZv347FE07GiGWE1e5JrXoNSm0/fvw4jz76KCtXrqSkpIT0mBiestj4wu3FpVKhuiZHYbLa2bhxI36/n2YtW2P1RWF2+oiKSySyyfDAucyuzyOPPEKNOg2CMi2O1JoYQ5MIbzAQvcmC0e4mr2AT2WNfQqXRcvToUWrUroc1NgeV2U3KgCfQhyah1BnRWRx4K7VBqlAhpHJkSg2tW7elUdPm6C12tHoTj1wrzUrLyiW27RRyJ7+K1uZFobcEHZ+lChV6o/m6zI3hI0dhj0rBU6kdMrUetSsKmcaATK3HmlgFrcGMN7cxztgsatetfy37tT1aoxW1zogxMhOZSodKZ0Jv9+LLrI3N4UKh1uKr1pncKRvQu6OQyeU4PT4+//xzJk2egj25GlljXsQYmUH37t1ZtmwZjqhUMkevQGMPxRiWjLdKB+RaE1HNRqFxhFGzdh28OY2Dxhejx4wpdSxHjx7FYLYSVrcvzpSqKHUmcsa/jC2lJtakqmSPfQljZAbZOTm069ARhUqNxh5GfMfpaBxhOFwuIhoNCVxHFdsgVetR20KDGdS+mt3wVutEv/4DeP/992nStBlGdwS5UzYS1+Fu5FoTxsgM3PktMNmchNftQ0iNbqgtHjKGP4spNh+pSofa5GDUqNF8/fXX7N69m27dutG6dRtiE5JwJ+ZjD4u/6YJ+165dxCckoPPEkTniOUwR6Tz44IO3vJ+KioqQymTkTFxL7uT1AQNJuQKdI4zk3g9jiauAPjQRuVpLcp9HyJ30Ckabm6nTptG+U5egU/iVK1dITc9EJleiNRipU78RCxYupHqtuoTV60f2uNWobSGotQa++uqr4P4vXbrE22+/zTPPPINGb0JhsBHZeBhGdwQLFtw6U7qkpISDBw/ecOFcVFSEXKEka/QKssetRqnWXhfsPXHiBGqtnuzxq8kc8RwKpeqODIp+D2+88Qa2kGhyJ79KfKd7iUtKveMx7p8zF3t4AhGNhmCwOH7XA8n/IuUB6vL1dznl/JH4/X5mz5hBnQoVuLug4DeZ3D72yCPEGo0MMRix6XQ3lcv7X+Sdd95hUJ8+PPzQQ7/ZQDgjpwLxHe8JrOUS8wLJFBYLVquVfv36MXv27DIHc38rhYWFvPfee/zwww88tXgxao0OlVrLPTNm3rLf5cuX+f7772947Lt372bOnDm8+eabANRr2ITIJsMDButJFVm6dGmZ5la5ei2iW40nr2AThrBkLDYHOXkV0BlNNGra4o6z1letWoVUriBr9AryCjah0FuRyBU4sxuj88bRqm37Oxpv+MhRePObB44ro/bvMrm/GV999RWxCclotHqGjRgVfJ48c+YMHTp3JTu/Mo899hjNW7UlO78yterUw+QMxeAIoVnL65NCykqlajWD596dkMO0adOweiPImbCWqBZjSM/O+81VA5cvX+bRRx9l1qxZZapSD0p8qNQ88uj1Eh979uxBb7YR1Xw0ruTK18lx/DtNW7QmqvmYwLNwfjPmzp37m46jnP8ObrX+lv81ytfllHM9Dy9cKCaMHCnW7N8vHhs+XKSmpv5hY1+5ckVUyckR1S9eEj9KhHhn61axdsuWP2z821G3bl3x2bcHytRWrVaLqlWr/skz+n+kEon4tKhIaCUSIZFIxHuFhWJG0VXxthACmUQcfH6cuHjysLhv/Vpx7Ngx8fXXX4vs7Gxx9epV0aNDBzFSqxMlQiKWKOUiPz9fSCQS8cTixWLS+PHCZHKJ55cvL7W/w4cPi5UrV4rQ0FDRpk0bIZFIhNVqFU8ueEKMGD1GaDRasWrlC7ecs0QiEQqlSlw9f0ZIVRohERJhMBjEiRMnhK9aJ3HkrRfEO2+/IT788EORm5srGjdsIF7eMl8onNGi8KejIiMjQ/z4449i0aJFwmQyif79+4sendqKJ58cLMIiokTHYYPF1KlTRf369UV6erqomJkpMi9fEV/7S8T7b70lHlm8WLRu0lScO/eTUMrkwp7fWhQe/Fj07tBcNGzYUAghxJpVK8WOHTuEWq0Wzz73vFj91mfioidGXDl+QPh8PtG1YzsxasIUcfngbnH+2w9FpM8r3FcPiGdfWStatmknju18SRSfPykiIqNEbEKSUBntovDcSeG/6hdypVY4MuoLsW+TeOiB2WLPnj0idVwXsX//frFqzTqx7Z1d4vzZkyJz5PPi6vnTYuz4YWLIkEFCo1aLcxd/Ev6iy6K4qFDg94vvNjwqrl44K4yRmeLqiQPiww8/FEVFRaJixYrCarWKuXPuF0kJ8eKtt94Waz6ViCs/nxDZI5eLSycPii+WjhYmh1eENhwqis6dEjsW9hP27KYipFZP8fP3e4Qrva5wZjcSBzc+IrRnvxIXLl0WiQ6Z+LHYJX66cFn8uPMlcfyjDULqLxEanUEMHthfSCQScfLUKaE02sXFo98ItdEmdn3wkVj23HNCrjEK6dsrhB8higsviTOfbhHJcVHiwr7NYnifLkKtVokvX35D4C8RVy78JB5+5FFh0BtEYVGhyMnOFnK5XEh1NuGp2FpcOnlQnP56lPCXFAtzbL74cesC8dmj3US16jXFK2tWicLCQnH40CHxgzJamGPzxMWj34hjO1eKM9uWilN73xQXj+wTQgihMFhF2sAF4uC/Fomzn/5LyLkqGo9eImrXayDMmU1EcYlffPlEL+G/ekXIRYnQ6ozi9Kf/Ev7iYhGVUlPI1Dpx7L3VYu+Tg4XaHi60znDhzGwgFix+WjRs2EC07dBZXFWZReFPx4RMlIjZM2eI8PBw0axZsxveG7m5ueLDDz4QTZq3Eh8tGSLq1qsvBg0adMv7SS6XC7vDJU5+8i8hU2qEEBJhsVqFMjxV6H3xwhSTI/z7toih90wX06YXCJlCJerVqSXumjZNFBYWipUrV4pJkyaJS5cuiWPni0VEs1Hi8OtPi29VCWLi3bOEzagVisRMIVOqhVyhFCMHjQiagl64cEHkVqgkTl8oEudOHBG6qBxhTagoju1aJ9JjwkS/fn1vOu/CwkJRp34j8cmnnwqpQGze+KqoWLFicLtMJhNqjUZcOv6tkMpVwu/3C7n8/5c9O3bsEFu2bBF+f4m4cvqIKL58XiiUKiGRSG55vv4odDqduHrlkii+9LMo+vm4sOr1dzzG6FEjhEqlFLs++Ei0e/qp/+hvRznllFNOOaV57rnnxLOzZ4txcoV49MsvhdXhEEOG3pnR7aaXXxZjZHLRWKMVZ65cFm+++WYp0+C/mh07dojhffoIv98vHly4UNSsWfM/st/Lly+LnJwcUalSpVJ/37Jli+jRu68oLi4WTzz2iGjTps0tx4mKjBDvHdglpEqNuHjyB9G4cWPRqVMnkZaeLp5ctEgYvbFi9dr14v2db/9px6JUKkV+fr4QQojevXqJjh06iJKSEmEwGG7aZ//+/aJqjVriSuFVERLiFe++/aYwmUzB7RkZGSIjIyP4f4vFLK4ePCKuXjgjrl44XartrXDY7eLg8e9EoTdeXL34szCmNhR7P1gj9HqDOHnqlDh16pQIDQ0t01g7d+4UXXv2ETK1QexZMECoLB5BcaEwuyNEZOOh4vLpw+KdNXeXaaxfmDBurNhQo5b45P5WIiEp6ZZr3A0bNoivv/5atGjRQkRERJR5H7GxseKrL/de9/f+A4eId745Iwxx9cXEqXeLt7b9S2RkZAhA7NixQ/j9/lLrsMOHD4v2HTuJ7w/+IDp17Chm3zfjliaY90ybIpq3aiNOv/O8MGgUwu12CyGRColEIi4c3ie+/2S3MFusYsaMGWLM6FFlPh4hhGjZpr3YfeC4kGpN4snFS8W+zz8TCoVCfPjhh+Ldd98VVatWLXX99OvbV3Tv1k0IIYJG67/m888/F6awJOFIryuUBpv48ONXgts++eQT8c0334iaNWsKm80mhBCiW+cOoveAwaLo6Bfi3FfviUaNZt/R/Mv5H+Jmkeu/+7/yDI5y7oQvv/ySSKORw94Q9rq96FWq3zTOxYsX6dWpE6mRkUwaM6bMpeBXrlz5zW/6/2ya1quPXSrFI5ORn5bGZ599RkFBAcuWLeOnn37i9ddf59ChQ7z55pvY9HrybDbC3W4a1aqFSkj4zuPjW48PpUx227e6p06dwmuz0clsJtloomDChN887zVr1mA0W9HqjSxZuhS/348vLILwOr1x5jRGIpFgNpvZsGEDxcXFLFq0iLvuuotvv/2Wy5cv4wuLwJvXBFdiBRo1bREc94UXXiBMb2CYwYhdq+OJJ54g0xrQvHvD4SLc4QRg7oMPIVeqkKl0JHSdfUtztXPnztG6XQciYuKZOGlK8LrZunUr9evUIVmvZ7zBiFWrZcCAgYwaNYp2HTrTf+BgatatT2TTEYGs4PTqRMXGI5UrURisaPSGUtq6R44cQWswkTFiGVKlltT+TxDXfhoylZY5DzzInj17AvrGCiU5+RWQqrQBczylDo0zCrvLg85oxhOfg9ZgIjUjh8fmz6e4uJhGTZqj1hmRyBVENBqG2upDrjUFNKBzmuBKr4VWb0KuNRHReChqkx1bXC4JXWehs/swhyWR0m8+SqMdmVqPzhuPyuJBSOVEtxyHOa4CUoUKmUp7zZhQhdYdjVShRm/3kTNhDe6KbZCpdCT1moc5rgJCIiUuKSVYDrl+/XqMVidCSNC6ogmp0xuJXIErtzlGhxdPSBgytR5HVkNUFk8g61wiRSJTYHd7mXHfLIqKivj5558Ji4zGGpGMVKHCmlQNmcaAVm8kKTUdqVxJ2sAnceY0wRSTS17BJkKqdaJu/Yb8+OOPLF68mJCceuRP3Uxch7tx+8IwmCy4Q8JQavSE1u6N1uZFZ/PgjEqhYpXqyOQBA8SYNgGpF1N4MgqVBplSS2L3OSR2m41Sby2lg+f3+/n2229/t6nsxx9/TER0HAqNHo3eRH6lKrz00ktYbA48CTnoTRbWrVtH9dr1sDpcdOvek5KSEk6dOkVsYjJamxeVyYnBF49SZ8KV35yQmt2vmWP2pkXL1hjNVnRGCzXr1C9VibFq1Src8TnkFWwitv00FFojoXV6Y3L6WLFixS3nvXr1apzRaeRN2UBU89FUrl7rujZ9+/VDrtajMNgwOMNo3rIVGTkVaNa8JXqzDV/ltih1xsA9pbOg0ZvYsWPH7zqfd8KESVNQa3WER8Xy6aef/sf2W04AUZ5BXb7+LqecP5CJEyYw3BB43phiNDGoT587HmPm9OlkmUxMN5px6HR/KwPc4uJi7EYjCyxWFltsWPX6/4h29vR7Z6BQqlBrdbz44srg30tKStAbTSR0nUVSr3lodIbbVsmePHmSpi1aE5+czmPz5wf/ptLqMUZlIoRASCR/mtnjb6VT1+6E1epOXsEmPGnVefjhWxsqHjlyhOz8iuiNZvr2H1jm6rDDhw+TnVcxIANYsTUxbQtQ6CykDVpEaLVO1G/ctMxznjNnDjKlhqhmowKSfho9Dz/8MCarndDaPXGnVqNF63ZlHu8X/H4/P/300y2fwx+YOw+LOwxfbmPMNkcpycPfSmpmLgld7gs8kyVVYOXKlWzZsoXXX3/9urmcPXsWg9mGKSoLpdGBzubmuTKYur7++uto9UZCMmqhN1upWbsOCqUaiVRO2sAnyRixDJVGF/QAKgunT59GIpORM/5lUvo9jlyjxxMSzsRJk9CbbYTmN0VvspTyjrkdP/74Ixa7E19OQyzucB6YOw+A5cufx2B14E2uiMcXWipbe8eOHcyfP/+WvjDl/G9wq/X3zV/hlFPOfxFhYWGiWK0WMy+cF5MuXhCRoaFiz549dzzOzOnTxY8bNopZ5y+KVxctEitWrLhtn7smTxYmvV7YjUaxefPm3zL9P42SkhKxedtW8abTLd52usWX+/cLp9Mppk+fLrp06SJMJpOoWbOmCAkJEY/Nvl+Mk8nFyyqNyC0sFHs//VRkKBWi3emToumpEyI/K0toNJpb7m/Xrl0iSkjE/Vq9uF+pEmtffPE3z71Fixbi57OnxcXzP4uePXoIiUQitv1rs0jSnBLpdiHWr18vwsPDRZMmTcSMGTNEr169xLRp00RkZKT49ttvxaWiEhHaYIjwNR4ltm/bGhx305o1YpBMJsYZjKKdXC6+++478UNRkVh28YJ4vKhQZGRkiCNHjoiCqdNEcv8FIqbVBPHN6pni1I5lokHd2sFxdu/eLTZv3iwuX74sDAaDWPXiC+LB++8TcplEfPjhh0IIIWrXri1+OnpUTFaqxVCDUWT6EStee18s3/yeuHDxoljw+GMiNCREFB7/Rlw+fVgUnvlRIKQiruM9Imvk88IWnSV2794tioqKxNGjR4XRaBRSiURc/PEroXGEiS+WjhYH//WkcFdoJTZs3iIKCwvF/i/2iqLCK+KD994VHdu0FMWXzwm1xSWKfjoqrhQVC3NmExHW/l6hDksXx+UeMeXumWLevHli16dfiNQRz4uoZqPFwS0LhNJoF1mjV4iwOn2E9PhecXb/e6KwBOGp2Eac3L1FeJ1W0aZ2nlB9sUZEh7iEMbGa0LmjBX6/CKnRVRjCU4QQQkhkclF04aw4991uYUupKSRypaD4qjDF5IrUfvNFRKPBoujqVSFVqIXSYBVyuVwc3vKEoOSqyBn/sjivCRX3zJgpjh07Jjp26SYc1boLZ04TIaRScfTtF4TelyBO731dXDx/Xhw/flwkdL1PqM1uUXzpnIhqPkZkjlgmpHKFUMZUE7Mff1bUb9BYvPXWW6JIYRKx3eaKyMbDxNmv3hMKUSLUarU4dlUnEBKhMNqEM6uhOP/DXvHhrBbi+K61osTvFyqVSuTn54ufvv5AHNmxQhx/82nx08/nRFSXB4Q6tamQqLTCW7mtcFftIpLjosTih+8Tb2z7l2jdtp3w//yjOLh5gfhmzf3i/I/fiKQ+j4nolmPFN2tmizNfviOuFl0We/bsEd98840ARM/efUVqZo6IjIkTTy5a9JvvpXYduwhJUiMR3+U+IZEI0bRxQ9Gjd19RIpGJEJNcfPLRB2LVmnXi0+9OiJ/O/iSWPbdMDBg4SKRlZosDBw6IwkvnRWKPuSKx10NCKpOLE7vWi6M7XxKHty4SZz9cKxo1rC/2fPKx2Pf5HrHtX5uEQqEI7tvlconLZ4+Kyye+E5cPfyEy09NEs0SdWPz4w6J9+/bivffeE2mZOSI5PUu88cYbpeat0WhESdElUVJ0RZRc/Elotdrrjk2hUAl3xVYia+RyobCGim07dokrCc3F1h3vC3NmUxFSu7dwVWwrDBHpImv0C8KWUl188MEH140DiJdfflkUFBSIXbt2/eZz/e/cN+MecfniBfH9ga9EWlraHzZuOeWUU84/heLiYrFv3z7x888//9VTKRN+v18Enq+vp03btuI5/GJE4RXxREmxaN+16x2PP37yZNH9rrvEoeZNxXMvvyxycnJ+75T/MK5evSrOXbwoqqvUoqpKJa4UForLly//qfs8duyYmHnfLJEyZKmI6TRL9OnfP7itqKhIXL50SWgd4UJjDxV+f4koLCy85Xh2u128smaV2Lf3EzH4WvatxWIRer1BqG0hQm0PFwJEq1atxLlz5/7UY7sTdFqNKLn0s/AXF4qSKxdv+8zl9XrFh+/tFOd/PiueXPD4LTN3f43P5xMfvr9T9OrZQ1zc/7b4Yf1coTI7AufGEytOnDxV5jknJSUJqUIt7Ol1hTu/hZAKxLBhw8Sbr28VdSLkolezauK5Z5aUaaw9e/aIVatWiVOnTgmJRCJMJtN1FW8XL14Uly5dEkIIsXzFSuGqPUCENBwqdCFJ4q233irzvG/GkIF9xY+bHhKHXp4uxPmj4qklT4vOfYeKNl16iz79BpRq+9ZbbwmZySMSuswU0S3HieJivzh8+PBt97Ht9deFJaOh8DUbJ6y5rUVERKQ4fuxHoVQpAw1u/NVzS+Y8MFcodFbx/abHxf4XCkRo7d7CUne4eODBh4Qptb7w1h8sTBmNxZq168o8psfjEZ989IEY362hWL7kCTF61AghhBCPPL5QeOoOEqGtpwmpLUJs+VXFeuXKlcWgQYNEXFzcDcf85JNPxKxZs0r1Ked/kJtFrv/u/8ozOMq5U7799lvatGiBXqGgvcWCTae7rdnAv9OtbTvuMZk57A2hm8nMrFmzbtn+wIED2LVaPnV5eNFmx2O10aF5c3p06MAPP/zwew7nD8Hv9+O12XjYbGGJ1YZFpyuVBV1SUkL/Hj0wajSE2Ww0Mhh5zeEi2WSia6dORBoMZOn1OM3mMulZfffdd9h0Ou4zmWlqMtOt3Z2/Nf+FM2fO8PLLL/PJJ5/ctM3Fixfp2rUrQgiaNGkS1J+9ePEiDreXkKodcaZWJzktI2hEs3DBAhKNRu41mfHq9bz22mu88847tGvShKH9+nH27FkOHDiAzmQlZ/zLpPZ/HLVWz4IFC4LZCQ899AhGqxNndCppmdlcuXKFBQsXYnaH4avSHr3JwieffILf78diNBKvVDPKYEQtkZA6cCFZY15EqzcAgayOGnXq4XD7GDFqNFOn3YUtLA5vpTYYLTY2b96M1eFCazBRoXI1Nm3aREpGNkkp6WiNZkJqdMPsjUKl1aG1+1Bq9Sxfvjx4jt58801UWh0xbSYT2XgYco2e5F4Pobb5CKnZHb07kmbNmmGwuVGZ3UjkSlQWDxpHOFljXsRdoRUOdwh6iwOdJ5assS9hTa6O1mihTv0GzH/8cXbs2IHBZMUanoxUoUamNhBSswdKgx2r3YlMrsRzzRgvvP4ApEoNaquXlL6P4kyrhVSpRa4zI1WqUao0VKxUGXtqrWDmcoNGTcirWAWd3UdewSbShyxBSOW4K7YOZPHW7oXS6EDjjETnjcOaXB2ZSkNi9wfImbgWhc5CSr/HSeg8E6XewiOPPILebCOuw914choTGRPPk08+iVShwhiRjkytR6LUIFPrUZrdyBRqknrMxZvTkC7dewLwzDPPYDBbkcnk6O0+8qZsILH7HORqHb68Jhjtbp57LvA5bN26Fa3eiEQqJS0tnZEjR6I1WsmZsJbU/k8gVahQmj3IVDrUVi8avYn758xBb7EH2gxYgMliu+l98IvG88GDB2+43epwkTpgAbmTX8Xk8GKy2kjt/zi5k9ejt7rQ6PTI1AGd9bTBT5E+eDFyhRJHZDIKgx2VxYO3aidiWk9EpdFx5MgRduzYwfTp00nNyMLk8KA1mKhYpRresEgGDBpSqqLknhkz8YRGULVmbY4cORL8e0lJCRabg+hW44ltV4DBZCllZFNSUkLP3n2RyRVExsbfMCPj448/xmC24kuugEqjxZvf7JoZZgM0ZheRTUdgcISgNVrxVW6L3mQplcl87tw5Jk6aTJVqNTA5Q/FV7RC8f8v55yPKM6jL19/l/KVcuHCB9KxczA4vRrP1jjL4/gqeeOwxtNd8V1avXn3DNvv27WPx4sV89tln/+HZ/Xn4/X5eeOEF7rnnHrq2a0e4wUCk0UiDmjUZ0LMnzzz99J9mMHz06FE0eiNZo14gpe+jGEyW4LYRAwcSqtGhVGqQqbT0ukPDvV8TFZ+ENaka7gqt0ds8SKVSkpOT/2Pmibfj6NGjpGXmIJPJadS0BVeuXPlT9+f3+4PZvCqLB5XFg0KtLWXofDuKioqIS0zBFp2B2RtFv4GDftNcXnzxRQwWO96USrg8ITesHLz/gbko1RpUGi0LFi6k/8DBuJIqEtVsFAaL/Q/ztnrvvfdYsWIF+/btQ6Mzkjt5PTnjX0Ymk3P16tVgu71796I1WohtPw17Wh1UOiPffffdbcd/7rnnsIbEEN/pXhzRacx9cB4AS59+GpVGi1Kl5oG5t/aWgcD69euvv6a4uJhRo8dgispEZfUhU2lJG/xUwI/IbMfkDiem9SQs3kief/7533pagnTp3hNPVj0SuszEZPeU+Tt9z5496E0WfP/H3llHW1Wmf/yePmf36brd3UF356W7pFG6UynBAmwUQRBQUVCGHtQxRxzHDsRWwC5CBeHe8/n9cfDM3KEuCOr85n7Wuou1OPuNvU/sZz/v836/dTqjugPcd9/a3zyXGv68nCv+/sMD3Yv9qwmQa7gYRgwaxNWKysFANGNlhRnTp19Q++eeew6nJNHA5cIhy/Tq1ImF8+ad5v77K++//z4eQeBtX4AHHS4EvZ7ZqsZVqkZeauqlOKXfzIsvvkhZdjaFaWmnmQdu2rSJfE3jNa+fEapGit9PSiDA9FPyJo899hirVq2qVnL6V55++ml6lZczZfz4i94+99133xGIiSOQWYakOVmwYOFpAeTJkyeZM306rerXp2ePHhiNRpKSkiLJpw8++IChw0bgt9upY3fglySmTp7M0qVLuW7xYob268cjjzxyxvFDoRBDh49EkFVsoszKVauqvB6MSyR7yK2Uzt6JKzaVZ555hlbtOpLUeSplc3YRXasDy5Yt4/4HHiBKb0BnMKIG0tAZTfhKO+LLbUTDJs345z//edoWrlAoxLp167j66qt55ZVXaNS0ObEthlM6aztKbGYVd+3nnnuO8RMmUqdefYKNB1I2Zxeu/BaYrTa++uorILxFyyaFA6z0ftch6HRogojRYkVvFpDjcjCJKgaLQHzbMWiptfCWlWNS3OjNNmyeBOKTUklKScOiuDDaFBxZDYlpegUGq4QWSOCee1ayf/9+HnzwQWRFxVvSgbjWo7Cn16VN+47cddddyO5okrvOxOaJJ0qnx2QVMVhEjBYBOS6f9H6LiW4yiNSMbL755huSUtNRnF5cHh+CpBLffhxGQUWOzcaiuIiNi0PwJZF5xVLkuFz0ZhtROj1xrUcR02wwUXojeqMZvcmK3mzFW1aOzROPHJfD0KFDefDBB0lKy0RvEZDj88J9B9Mpm7OL9H6LMStu0novwCQo2GMzKJuzi+SuM6jXsCkA+UWlJLQdQ/7YtZgEGdkZXkRYsmQJy5Ytq+II7o+JI63XfIomP4zBKrF582YGDh6KqDowWwVEuweDTUHwJlI6eycZA24kNjEFQVLJHbWClO5zCMTEnfGzeuTIEVIzsnDHpSMq9jM+WEyZOhWTxYZNsdO6XUeSUjNIaD+e7GG3ozdZSelxNQkdJqDTG8gfs4b8sfdhslgRFY2Y5kMwa36MgopZcdGzZ09efvllPv74Y6LjEoiK0qGmlJLcdSZmxUXOyLtwJ2RXy6zn+PHjGE0miqc+Qsn0v2CxCaeZeP76nTgX+/fvZ8uWLTz77LOoDhfReQ2RVAeTJk2iW88+rFhxD1u2bGHevHmRhapfadysJb7cRgi+pCrf36VLl553/jX8+alJUNfE3zX8saxbtw5felgqK6H9eJq0aP1HT+ms/PDDD8gWC895fGx3edAE4bIlZf9sXDtvHpmKylBFxSlJbNmyhZtvvhm/KHKNopIiK9z7H7HwpWTu/AWYLVasgsgDD/xL/isvOZmtLg97PD5q2e2sW7eOPv0HUr9Jc7Zv335BY7Ru14Fg7c6k91uMbHdx9913Y7fbcblcl8yA+Ntvv+WGG27gtttu49ixYxfVx+/1mQuFQgweMhQlOo2SmVtJLJ9CMO78xvf/yY8//si6devYsmXLRc+9bsOmEWP5YF5DVq9eXeX1I0eOYLEK5I9bS95Vq7BYbRw9epQpU6fTtmPnan0WDh48yMyZs7juuuv46aefOH78OOvXr+eBBx6oImPz8ccf8+KLL3L06FEUzUFy52kktB2N1x992vlt2LCBgpJaNG7Wooo5+LkIhUIsXLSYsroNmTp9ZpWCjl9++aVan5sXXngBxe5EcXopLCnjgw8+wBeIxmARceW3wGCVsNm9tGrbnsXX3UCLNu255dbbzvv+fPbZZ1x51RiuvGoMn3/++RmPOXToED379CO3sJQ7ly+v1jkD3HjjjUTXLqdszi4SyyfRvvzizSZr+PNTk6CuoYZT3HH77eSrKsvtDlIVhQ0bNlxwHx9//DH33HMPDkHgakWloaoxetiwsx4/eexYBJMJyWLBYbGw3x/kfX8Qg15/1hvBjz/+yBdffPGHB7733nsvzewODviDLFY1OjZvfsnHCIVCHDlypNraaBDWiQ5k1wkngIPpuI1GnILArcuWRY65dt48aqsqd9udJMgy11xzDS6XC5vNFqkg3rVrF6Wn9KV72ET0ZisWzYfJKvHKK6+cdx4HDhyI6B//O7XrNySmYe+w/rJq54MPPuC662/EGZdOXKtRyHYXzz//PHaXh6zBN1M46SEMZht5hUXkFRYTiE1AVDQc0UkIksLcuXNP0zB/+eWXsTvdGEw2jKKGv043BF8yMfGnB4/jJ07CkVGf/LH3IcdmIyiOSAVoKBSicdPmGKwilqgo5ioaw2UFxWzGrPlQEgtI73stFs1HoG4PUnpcjc5kwyiEE6aS5mL58ru48qoxqA43RqtI9vA7KZuzC5snHl+tLlwxJPz9qKys5J577sFkk5Djc3HnNcfu8vDSSy/hj47DZJMpqVWHzZs344xJpnj6ZoRAKibZicEqYrIKPPHEE0C4KuOjjz7i4YcfJpBZRtmcXcS3GY3BaMFotiLbnVgVZ7ja2xVNg0ZNMFlF4ttcSXKX6RisMs6kArp07crw4cMxmq2IwfRw0l0O6xDnF5Ui+JJIaDoYq9GMwSqS3m8x/pL2mGwyBpuCWXZhMNtwxWUgqQ7+8pe/0H/QYAwWgbTeCyiZuQ1HIIHVq1fzxRdfnPFzJNudpPddRNHUTRhFjeYtWvL888/zySef8NVXX3HXXXdjMJowiXayhtyCM6cpkuqge4+eiLKCNxB91oenDRs24M8opWzOLlK6zaK0ToMqr+/duxdR0QjU64nF7ic6LoG///3vpKRn4fT40BtMuAtakT3sdoxmKyaLFYvVxtJlt7B9+3Zq1WuE0xtAp9OTmJqOqDrQPNHEJiQTrNeDkhlbEP0pGKwSVmd0WLevtD3XXnst18ydj8kmYTBZKKlV94x6esNGjELzRmP3x9G7b/8znuOvnDx5kkceeYSHH374jIuG33//PR06dSY+KZVrr110zr5CoRC9+vZHbzRTMG4dsc2HYnPHEtdyBLLdxZ49e87Zvob/DmoS1DXxdw1/LOH7fSqFEx4gpkEvOnXt8bvP4dtvv61W0ufbb79Ftlh43evnWY8P0WK5oNj1v5m6eXk86HRxMBBNW5eL+++/n9mzZzPmlN72QlVjSN++l3UOP//882n39vGjRlFLVRknK7hkmcbNWhIoaUtyl+lIqv2Cqp+//PJL2rQvJyO3gFWr7gXgvffeIzU1FZPJxKrfmIA/efIkKemZ+Aua4U0vo0Xrdr+pv8vNPffcgz2QhFHQcOU1Rw0mM3HSlHO2uVx+S4OGDMOf35T0votQ3YHTYt6jR49isQrkjV5N7si7sdiEC5rLsWPHwoVPZR3xZtWlZZt2NGzSHG9KAZ6kPNq06wjAmjX3hZ/P/HHUbdCYpUuXYrJJGK0iLVq1+c2/B3evWEF6dj5t2pdHColCoRDPPfcczz33XLXzAk1atCah3VhKZ+/Em1bMmDFjuPnmm7nuuuuoXb8x5V268be//e2CrlEoFCIxJY1g7U4EapWTlJp+SfMUTz31FIrDQ0L7cbgSslh03fWXrO8a/nzUJKhr+J+gsrKSI0eOnPeY66+9lg5Nm3LbLbdc9A/rpk2baOFyczAQzaNON8Xp6ec8/vDhw/z888/Uzs+nmd1OLU2jW/szm0w89thj2EURzWqlZ3l5tW52P//8MytWrGDFihXnNSq8EI4ePUpRZiaxsoxLUS5YEmXz5s3069aNpTfddMbz+Pnnn2lWty42k4nEQKDageQLL7yA4vKR0GECdoORj/xBnnR7cStK5JieHTtyg2rnYCCa9qKEYrGQpqpYzWaioqIYM2YMr732Gh5RpL2oYLAIZF6xlNLZO7A6o+nUpesFneu/8+mnn9K4WUvSs/MiMg6VlZXccutt9B0wiHvvvZfjx4/jdPvIHHgjhRMewCLIXDFkKJ60EmRBQRcVhcMVjae4PTbNw5RpM6qM0aJ1O3y1OmNWXCR1mooUnYnFFYPT4zttPocOHSI+KWyuaFVd5BeVsuzmm+neqy8PPvgg5V264S3pgNNi44A/yFu+AMaoKMyqh/jWV1I2Zxfekg5E6Q0YbQpm1YPL4+Wee+7h9ddfZ+LEiYjuGHJH3o07rxkW1Y0rpwlGQUXSXGzbto3KykratOuI6g6gM5gonPggZXN2YVZc6PQGBG8i+ePW4YxJZsiQIQiqg+jGgzAKCiUzt5E7agWyaicUCjF33nwaNGrC3Xev4JtvvkFUNIw2GYNVIrb5UEpn78DmjMFgEVCTijDbRPbu3cuePXtweXyYFTcZA24kUK8Hdeo1YPacq3H5gshxuVgdQcyKi0GDBtGrd1/0JiuK0cwzHi9dbAIWm4w3EEuU3ohJduLIaoi/bndUu5PXX3+dJ554AkcwkeSuMzGYBUw2mdbtOkSCwJMnTzJ9xiwaNm3J8rvuAmDIkCHham6jBaNNRvEnoHmCTJsxK/Iezpp9dVgexSZjsAjENB2Mxe6noKiEr7/++qyfxaeeegrNG0NylxmIvkQSktPo3K0HLl+ATl26c/vtt+POaRQ2dOxxNVbNy12n5lVQXIY3vzne0o7oTVamzZjF0aNHOXr06GnjhEIhBEkhf8xqSmZswSzIxDYbTOnsHagppUjBdExmK77kXNy+AI899ljYkCg+j4Lx63FmNTzjg08oFGLPnj3VCsw7de2OOyETT1IuTZq3Ou34rj16EyhqRVqv+ch29zkXofbs2YPdF4sjox5ybDauglYYzVa69+rDzp07zzmPX/niiy/429/+xnfffVet42v4/alJUNfE3zX8sVRWVjJ46HBsokxuQfFZpagu19h9u3ZFNptxSBJ/+9vfztvmmpkzkS0WZIuFu+6883eY5aUjFAqxf//+iNzdhTDxqqtooGrMVVScosg777zD008/jUcUmSArxEryeY2NLzXfffcdjzzyCDNnzmTiuHG8/vrrxCWlkj3k1nDcmpzLY4899pvH+f7772nWrBlRUVFMnDjxopOwH330EYrDQ+nsnRRP34zBaPrNCb6PP/6YqdOmc8MNN5x1kaWiooLPP/+8ivxEdRh0xRA8xe3JGbkCNbGQNm3aRsy5a9drSGxiSiSOraiooGuPXuj1BmLiEy+5Cd7hw4fp3W8AuYWl3HrbbWc85rbbbsdssWKxCdz7HxXW52Pv3r3YfTGUzdlF0eSHsQoiFptI6aztlMzcisFo4tixY8QnpZI58EZKZ+/AGZNMfHIaKd1nUzL9LzgC8Tz77LMXdX6vv/463Xr0xCzIpPVZSLB2Oe06dgZg4BVDsPvjsPvjIjKC56Nj527ENOwdlozU3GiBJAKFzQhEx3L48OGLmuPhw4cxW2yUzt5J6ewdmMyW8+ZdLpSHH36YLj16c8MNZ84b1PD/h5oEdQ0XzWuvvcaIQYOYM2PGn87N+N956623iHa7sZlMlLdsedkdpQ8ePIhbURimqOSpKnOqKRXy448/smLFCtauXXvWORampXGvw8mH/iCpqlqtm12zunVppNlprNlpUrv2JV3RPHHiBO+8884F39CeffZZ/JLEYlWjUFW5ftEiQqEQq1auZGi/fmzatIkVK1bQSLPzqT/IBFVjQI+qlTM//fQTY4YPp0WdOqz/D+fjO5cvJy0rF9FgYIfLw1LNTkZcXOT1v/zlL3hFkR5OJ6rRyDwlrB3eWdVo0KABUVFR1K9fn2XLlqHT65GiM4lpOpjsIbdisIg0bVb9avHvv/+eadNnMH7CxHNqi3///fekZ+Ug2914fEHuuusurDYRUacjYLeTkZOPK6859W0Cn/iDDJAUJM2Lu6A1uYWlVfoq79IdLaUUV36LsLxElxmYRZXrb7gRCCf/B/fpQ3Z8PFMnTKBDpy5Idg9WUaZrt+44Y1JJaDcWxeUnIyePmGZDcLjjqGuxkWERsLvDEhl6sxUtuRiD2YboTcBolWjYpBnffPMNlZWVrFixAouoYM+oR9mcXSS0H4dFcSGrGpMnT+app54C4NVXX0VxByiZuQ0pNgtHZgOCDftitMnhAMqXREr3q3El5WOTVLyFrdGZrJGFg4R2Y3F6/HTt2g29yYLNE4/BIpCSmoZZcpAzYjmCN5FA/V6UzNiCVXKQ1GkKZXN24cltQt++ffH4gzjj0sNa1rITg1XGpnlQYzNw57dAZzST1mchKd1mISkahw8fpqCoBL/BwMf+II843ShWiWC9HphkJ3qTlaIpGymbswu7N5p9+/axZcsWrKoLqzMaJbGIrNwCQqEQP/30E5s2baK0rDaOhFxSus1CdPgoLq3NkqXLGDx0ONFxCVhlB6WztpM/di2irHDo0CHWrl3L7t27MVlFAnW74y0J6ygndZqCzR1H3YaNI5+LzZs3U6teI3r07hup7p82fQYGk4XYZkPwFLTAorjIHLwMyZ9MTGwcJqtIbPOhiME0JHcMK1eupKKiAp1eT8nMbZTO3omg2M/qgP7r700wNp6k8slkDlqC1SZikxQMVhEpOgNPRm2uvvpqnnzySb7//nuef/55bLIdd0GrcFV1/d6071h+Qa7k/86xY8fQGc3hCnhXLCaL7bTdDWH39Wsj7usbN248a3///Oc/Ud0B/HW6YfMmEqjXE3d6LebNm1+t+bzyyisodie+5FycHl+1dAdr+P2pSVDXxN81/O/y7LPPkqKofOAPssLupDgjo1rtvv3224u+V/1RhEIhBvTogdNmQ7XZeOihhy6o/YkTJ7h2/nwG9eoViesAnnzySaZPm8bWrVsv6VwPHDjATz/9dNZjvvzyS2K9Xho6XbhEMTL+vAULsftiCeTUJyY+8ZIl0E6ePMmVV14Z8bS5mCTf8ePH8fiCRDfsQ6CkLYUltX7TnI4cOYLHFyRQuzPejFp06nK6r88333xDTnIyTpuN5OhoDhw4UK2+X375ZeyCQLzRiGiyIsgqf//73wGo06ARMY37k3XFMiTNyd69e3nkkUdwx2dSMv0vxDa7gtbtO/6mc7tYTpw4ccGJeAg/M3n9QQJ1uuHJbkijps1x+wLEtRhGbNMrCMbGEwqFKC6rQ1zzoeQMvwPZ7iI1M4ekTlMomroJzRtT7d11oVCICZMm4/YFqdugMeIpzyAlIR93YWvi245Bsrup27AJBqOR4mmbKZ62GZPFWq3P9CeffEJmTj4Wqw1RcZAz8q7wok1SdpXv74UQCoXILyrFl9sIX05DCorL/vCd3keOHOGJJ56oibH/C6lJUNdwUXz99de4FYVpikobVaNnefkfPaWz0qF5c65RNT7yBymx23n44Ycv+5jvvvsuc+fOZe3atZf0B7pWTg5jJJkykxnNYDirCcuvHD16FKvRyKf+IJ/6gwgm058icF6yZAkD7WH5jJGiRFZqKnNmzyZNUZivagQlibFjx54zQX3V0KG0UTXutjvxS9IZK7jvXbWKWLebnKQkXnrppSqv/eMf/2D58uUM6NWLHqrG3z0+4mwiJrMVg9GE2WxGVVWMZiuxLUcgeBPDCS5fMqJS/a2BJbXq4i9oTrBOF4Kx8WdcfNixYwfNmjXHkZRP6eydxDTqx4BBg0mJjibLJiEIarhC1myhhU3ggD/ISFHCZhHQgkl07tItEpS8/fbbTJs2LWysZzTjyW+OZPcwf8GCyHhzZsyghaqxw+UhTZIQNTclM7eSM/xOjBaBuFajwlpu9brTpk0b9CYLOpMNvdlGoH4vrM7osHRFdkMsNpGO5Z0YP2FiJEl58uRJGjdriUWQ8Ba3x+IIRK5fxoAbcEUnVdHz/eijjzBZRXJGLCeu1Uj0ZhuS5iTYoDclM7dic8ciKHY0l5f4NqPDEiHeRARf8qmqYRGDyYTOYCLQoC9lc3ahpZSiM5gwKS6Kpmwioe0YTBYbOp0Ov0VATSwirfcCzLIDq+JEismKVAqbRDvZQ29Diskivu1okrvORGc0Uzxtc1gL2mji5MmTVFRUUKewELfJjFWnI6nTFAonP4zOYMJgU7B5E/EWtiQmPpHjx48zc9Zs7CklZA1ehtUZzYQJE6jXsDE6vR690YzNm0hC+/HhxHlhG5zZjXAEk1i7di3ffvstoqyS2nMucS2GkZSWQVJqOr7M2ggOHyargEHQ0JltRDfqj80VS3TjgSh2Jz/99BPvvfcekuogpdssAiVtadM+/Jv96quv4gwmUjZnFwXj1qE3WTHJTpSEAvRmAb3BhN5kJUqno6C4LGK8U6d+I7w5DfAXtSI5LaNK1VAoFGLz5s2kpGeh1xto2KQ5Tz/9NKmZOQRjE7j//gc4cOAA/mAMepOF5NR0svMLiU9K46GHHqKiooJGTZthMNswSU4MZiv2QAJ2l+eijKWef/55zJKDgvHriW05ArOgnPY9vOvuu1GcXgJZdQjExJ1Rz/rfz++qsePRGYx4S9qHvyu1OjFl6rRqzWfQ4KHENL0inAyvVc7cuXMv+Jz+rDz99NPcf//957x+/y3UJKhr4u8a/nt46qmn2LBhwyVLOu7Zs4cEWeEdX4CbNTu1cnIuSb9/Rl577TViJJn3/UEedbpJ9Pn/6CmdkV9++YUW9evjEgRcinLWhN/dd99NucPJwUA0t2kO2jZqFHntscceY/Xq1Zdl99Idd9yBwWAgOzv7opJi77//PoMGD2X0mHEX5N9zJl566SXcsSmR2E51uE47Zv78+fRQNQ74gwxVVSaMGVOtvgd0786cU4U93WWZ8ePHR16LT04jc9ASSmfvxB2XzpNPPsmGDRvwpORTOms7CW1H06xlmyr9nS9p/M477zB//vxIEvyPoHXb9lgVBxZBIT0rm6nTptGqXQfal3eJVITv27eP3MISPP5oli27hRdeeAGH24vBaGL4yCurnQ/YsmULjuhkcketwFvcFpPkpGzOLnKG34FJUNCbLMS3uYqEtqPRmywkdZ5KcpcZKJrjghPwbdqX4y9sQXzb0ciao4oZ+bkIhULccOMS6jRowtTpMzl58iSHDx/mhhtu4IYbbrjoSuzfSigU4sUXX2T37t1ExyXgTc5FUu3s2rXrD5lPDRdHTYK6hovimWeeoejUzf8Zj5d4j+ePntJZ+T0S1O+99x7//Oc/L5u+1q88+eSTmKKiEHU6BJ0Ov6Kc84YXCoVICgYZp2pMUDUSA4E/xbaYN954A6co0tRmw6XXM0xWkI1GrpIkDgaiGaMoTJ8+naZ16lSR+PjVfHH9+vXULyxk9anPYHunkzVr1lzUXL7//nvaNmmC327HYDSRe+U95I9Zg9FkRqc3EKXThZPDFoG4liMonbUduy+2SsL7448/ZvTw4UweP75KUBkKhdDrDZTM2ELZnF3IdvdpW1Q3btyI4vITrN8Lg1Uirdd8/CXtGDHqKqwmE6JNpmTGFnJH3o0gKQg6HVJUFH6dHqNOj1VS8aUWEJ+UwtKly5DMFtwGA3a9HtWbhCDJ7Nixo8qYg3r14ppThqDdJBmTVSBn+B0kdpyIUVAxCTLuvGaIip2nn36aqKgocq9aibesE0arhC8YQ0zTwWFTuEb9GTdhQpX+n3rqKVwxKWQOugmDTcZbWo7RJqHGZhPXcgSK3Xnaw0FiSjoGq4hZ9WASFbS4LAwWAZ3BiNEiYBEVcvMLcSZkk1Q+GZ3JitEm48prFk6qihqe4vYYzAIp3a/G4ggQ32Y09vS6GAUNiyBx7733Ur+oCEmnx6p5MUt2DCYLMU0GYRI1sobcEunDaJPRGc0Yo6IQDEb0JhuC5kZ2eJg4eQrffvstOfkF6C0C/rrdsTmDyL4ELKeSu4kdJmAwC+TlF0QcxfsNvIJAvV5YtLCUiFWQ0ZssuAtbY3EEMGs+jIKCM7sRerONnOHLiW4ykDFjxwGwfft2svIKqVO/EevWrcMdl06gfi8EbyJRurChZpTegM5oRvQlYXPHYhZkVLuTm2++GV9KPmVzdpE1+GYSUsLSQz///DOxCUkECprjSsjBaLbizGkSNiLpMAGDTaZwykaSu82OtIHw4tfixYu5Zu7c0x6kxo6fgFW248xpQsmMLXiz63H99VX14q5dtBhXfCbxbUdjtEl4a3XGnd8Sg1Wkeas2fPvtt7z22msMGzYMf1G4kjq26SD6Dbzi/F/q/+Cxxx7DEZ1C6aztpPa4huT0rDMe9+KLL7Jhw4ZqP7h+9NFHBGLi0DwBAjFx1a4+mjV7Dt6semFTyKRcVqxYUe1z+TNz/Q03oXmCBLLrEJuQdMm3d/7e1CSoa+Lv/1VCoRCvvPIKr7zyyh9eBXcuduzYQf/u3WndrBnxkkQjh4Oc5JRLImcXCoUYM3w4JoMBn8NxwTJ2Z+OXX35hzowZdG7V6ncpmKkO7777Lh5B5EWvjzvtDrITE//oKZ2RRx99lBJ7uHBliWanWZ06Zzxu9+7dJCoKjzrddFE1rhwy5Heb42OPPYamabhcrouWdLgUHD58GKfHR7BeD7xZ9SKSEP/O4sWLaa9qfOIP0ktVmTppUrX6njR2LJ1Vjec8PkpUjdWrV0d+J+65ZyWS5sQVm0phSS2OHz/O8ePHqd+oKTZJwe7y8Morr/Dcc8/RrWdvfMEYonQ6SmvXO2NS829/+xsGkwWbOxa9yRqRmasuoVCIl19+mT179lz0b9m3336LxSaSO2oFRptCdKN+uJJyGTdhYrXGP5PvyblYuXIlgdwGVeJwX+2uiIFU6tRviNFkpmTGFkpmbMFotpCZk092ftFFfd4OHTrEiFFX0b68ywW1f+ihh3AEE0ntORd3ch7XXX/DBY99qaioqODgwYOcPHky7E3jCWKT7TjTap3aUTqVxs1b/WHzq+HCqUlQ13BR/PDDDwRdLgYqCrVUlRGDqqd7dLn56aefTrsB/SrxYTUaL4vEx63LluEWBBIVhQ4tWlxUAvjxxx8nwecj6HTy4AMPnPW4999/H0mv52Gnm3d9Aex6Pa+//vo5+/7oo48Y0KMHA3r04IMPPrjguV0uXnnlFYoyMliihbWgBysKqtnMWFnBLYo8++yzhEIhDh8+HLmms+Zcjd0Xhz+zFl5/NEFJotzhxO9wnNUxuLqcPHkSi9VG3pUrwwlqswVvURu0lDKioqJwutwIsormjaFZqzaRxYhffvmFeJ+fK1WN3qpG7fz8Kv3Wa9gEb3YDAsVtSUhOPW11e+AVQyIVy4H6vYmK0qPTG5g952p6dO6MwWQhe9jtJHWaQkxcAgaTFZPJimCyYDBZSeu9gLI5u/BnlOLw+LAYjLzvC/CWL4A+SodZVCLJ9L1797Jw4UIWLFiAQxRp4HLhs9vp1LkzRquEzRNPbPNhGAUF0e6lQeOm/Pjjj9hkDcGXhFnzYbLYSMvMQvUnkNRpKvZAQsRYEmDr1q3ExCdhtMk4c5qgM1rQ6Q306NWLYSNH0axla1LTM0lISa8iozB//nwMZhtSTGbYfG78elJ6XINJcZF31Sp8tTpjtXtp3aYtuQXFmGwyieWTKJuzC3dBKxzZYa1kT1EbdAYjgjcpXI3ebDAWQebxxx+noqKCaTNmkZKeRWFhEevWraOwpBau7AYYRQ2rMxqLMxqz4qJk5lbS+y0mYJNYotmRJQcmq4hOpycjOxd3IAaz7PiXpEb5ZBS7G5tsj0hFaCllZObkRYLuf/7zn5itAp7idpTN2YWvdhfMmpec4XeGE+0WISxdYpXQGYzhhL1NZN68eezfv5977llJ05ZtmTXnatavX4/RKmGU7CSWT0VnMJE99DbyRq9GZzDRsWNHZE8cJbO2kdBuLHXqNwonorPronmiue76GyPX/uuvv2bp0qWsXr2atWvXYlbdZAy4AS2lFL1FoGjqJtJ6zauSoP53fvjhhyoBuCDJuAtb46vdNXyeha1OqxJu3b6cpE5TT71/LXFkNcDqjCF76K34C1tGzDPvvvtu3Mn5FIxfj7+gOeMnTop87/bv31+tRcFfK/plhwdRVqvoRP/4448cOHDgoh9cjh8/znvvvRepLK8OP/30E9179iEYl8iwEaMu+8Lm70ViagZZVywLv+cp+f/1FSs1Ceqa+Pt/ldHDhhEjy8TIMmOGD/+jp3NGXnzxRTyiyCJVI9dkZqAgcsAfJNduP6sx8MVw4sSJS5Kk/+WXX5g0ZgxJfj91RJFlmh2/JP1pTHWvnTcPwWwmxu3m+eefB8KJn2VLlnBFr16nFTr8EezYsYMsVeUdX4BZqkbbJk3OeuwNixZRmJpKv67dfvdqznfffTdinnjvvff+rmP/O++//z5jx41n/vwFZ5REOXLkCI1r1UKv01GWmxuRPluz5j7yisro0r3XGc3eDx8+THmLFgQdDoYPGsTgocMxGE3EJSazd+9e9u3bx1NPPVUlLgyFQnzxxRccP348/Cyr2oltMRwlPg9PcXt8uY1YuHDhaWPVb9iYYMO+Eb+b+KTkC7oG4ydOQnX7sfti6d6rzwW1/ZXjx48jq3Z8tbqgJhdTNmcXmQNvIjO3EAhrRDdt0ZqmLVtf1C6//+T7778nPikFd1waBpMFb0lH3IVt0OsNlJeX06R5K9xx6bjjM+jQqct5+7vjzjuxOz3EJaZc1EJbZWUlf/3rX9m5c2ckXp03bx6BOuEYP67VSPr0G3jB/V4Kvv76a5LTMrDJGlZRRm+2EdNsMCndZ2NW3GQPvY1ASRv6Dxr8h8yvhoujJkFdw0XzySefMHfuXO66666L0nS6lBw7doxWDRtiMRpJjo4+TX6hOiaJF4vfbucJt5dP/EFiZZk33nijWu3uX7+eJqVlDBswAIcss9bhYpvLg2I9u4ZURUUFDouFVQ4nr3n92E0m3nnnnUt5Ohw9epTu7dsT63YzYtCgy/reLrnhBvJVletUjYAkce211zJr1qyzPlz4grHkjFgeTmrFpXH77bezcuVKPvjgAyoqKvjss8/YsWPHRSer716xArPVhtliZdLkKUiqnWBZe8w2EZ1OR0ZGBlu2bKGiooKKigr27dvHm2++iVcMPxi95vWj1+mqPMwcPXqURYsWMWfO1RHX5X9n1ap7sfvjiWs1CqOgEtdqFLlXrsRgsaH5YjGabYiKRkJKGhMnTkQKplE6azuxLYdjFWSCZR3IGHAjistHVm4BFoORtQ4Xy+0OLHojSkIBdRs25qOPPsIlywxRVNIVhVnTprF9+3a+/vprPvnkE1SHi2BJG0ySHXdha+JajUJUHTz66KM4AgkokoOWNoFiixWHNxGLIFGnQWNGjroyYih3+PBhBEkhrc9CEjtOQm+yUDDhfgrGr8dssXLs2DESU9JJaDua9H7XIcgqX331FZ9++imeQCzJXWecSuyWYE8pwZFWGzkum9LZO0nqNBWbO5Zhw0dgsYl4itsjxWSR1HkqRkHFYveT0H48BptMVnY2NklB8sZjMFuRNDeiojFs2DAkd3Tk+OS0TD799FN69xuA5vScqkA2YhRUCsatI7HDBFIFmUecbswWgUC9npTM2BLW3zbZsHmTMFhEAvV6YpJdiP4U5LhczIoLV15zdEYzFlFGsTsjiwT9+/dHTSqmcNJD2NPrhuVArCKuvOZYVA9RegNiMJ2SmVtPyZ0IBLLrYBVErLIdT1FbtJg0LIJEcpfpRDcagNUdh05vJO/KlRROeACdwcSCBQuwumIomrKJYMO++GPi+f7771m/fv1pGnNHjx7luuuuY/78+Xz11VdYBRmz5sPmTcRgtmKyWJEU9TRDoS+//JJmLVtjttpQNEek+iI9K5dAnW6YZAcGq0R8UsppZo0rV65C80YTrNMViyBhstrQUsoiyf4mLVoDsGHDBkxWEb3RjC86LL3x/vvv4/VHI2lOMrJzq2XqVFlZyXvvvVdFeuKpp55CVu2Iip1mrdr84fex/3batC8nUNqOlO6zkVTHJTdC+r2pSVDXxN//i/z4449YjUbe8QV4xxfAajSeU+/3j+DHH3+kbevWdJZkDgaiWWF3kmIycbfdiVMUf1czxeoyZ8YMGqkahafmeTAQTXeH84IrQn9Prp03jyJVZaGq4RVFXnjhhfO2OXDgANdeey333HPPee+pH330EStXrqwi+XYuKisrGdq/P0a9ntTYWPbt21etdn8E/26eOHny5IteiP7ll18YNGQYsYkpXDFk2GXxUfr3ub322mtImpO03gsIlLSl/Aza1f/O448/jiOYSNGUjcS1GEbDJuf36Nm4cSPBnLqnEr03YrDKONPKuPqaa047tm+//mjJJeRdtQo5Jot6DRpe0HkZjCaKJj9MyYwt2EQlsqPxfBw8eJC+AwbRuVtP3nzzzYhMndFsJdigD67EHCZMCr+vLq+f+NajiG81Erfv0uxU/umnn3j++efZvHkzgZg4jOaw/J49tRZGi41Vq1axdevW836u9u/fjyCr5IxYTlKnKcQnpV7wXHr07osjmIQWTKJV2/ZAeCe0rDmILmqOrDkvieHoxTB33jw8+c0pnb0Tb2lHbN4EzIqbQMN+WGwSMQnJtGlfXmNI/l9GTYK6hv8XrFq1igaanU9O6RX3737uG+qlJDc5mcWqxlaXB7vNdtZt3t988w2LFy/m5ptv5qGHHkK1WLhW0eikagh6PS95/ezzBVAsltOSOf/OY489hl0QMOn11TZg/JUffviBdevW8cQTT5z1mJlTp9Je1XjG46WWqlbZfv7EE0+QFAgQ43ZfsInKmaisrGTQgAGkBYP06937vDfaBk2aE6zdieQuM5AUO/v372f0sGFYjEZUQUCx2WjgcuGUZYYPGcLEsWOrve3+V44dOxbZHvrGG2+wdOlSnnvuOXbs2IGmadjtdjZv3kzD0lKCkoRDFInz+8kwmzFHRWHV69m+fTsAX331Fffeey9PP/30Gcd69tln2bRpE3fdfTf9Bw3GbLaSM/IuEssnI3gSKJ29k7Re88gpKAZg0qRJSN4ESmZsIaZhXxRZo1nL1qRl5XLb7bfz0UcfkZGdi2IyYdXrsRnNBKwiot4Q1uRzuTgYiGadw0XD//id/PDDDxk2bFhY1kSvRwykojdZ2LJlC7LmwG40ccAf5F1fAIPeQCCnHsGYWLzJucgOD7ffcQf79+9HVOyUzNgSTpTqDWQNuZXMQTdhNlt55plnkBSNvNGrKZ21HcXlY8eOHciqHYvmw5HZgIz+12OWHDRv2YqSsto43D4sqgeD2YogKezYsQO92UrRlE34anXGYBGJitIT23wockIeUTo90bHxBGp1wlvSAZ3Rgiu3KZ6itjg8fkySnewht1I6eweSO5o9e/ZQWVkZrp6/ahWFEx4Ia24bzZgsNsSoKCw6HUabQmzzIeF2sdlYndHozTb0JgtReiM6g4mC8espmbEFvUXEaFOIMpgQvIkYBY3GzVuyc+dO5s2bh0m0Y7AIYeNBRcPmjsUku06ZK1oQvEmUzNhCbIvhWN3xODLqhauqjWbk2GwMVgmzqFI6ewcF49ejM5rDJoAmCzqDCb3Zxty5cxHsXnQGE1ZnNDHxSXz44Yc8++yzPP/88xw7dozKykref/99yurUP6Un3ZKU9Ewef/xxouMS8fiDPPTQQxw9erTKg+abb77Jddddh0UQMUkO8sfeR3KXGeQWlnDs2DEGDBqMwxskLjGZ+++//6wPqVu3bmX+/Pm88sorPPPMM3h8QXwpeUiqnb/+9a8ARMcnkTHgBkqm/wXNE+SVV15hwKDBxDTqR+nsnfhyG7N06dIL+o7/SkFJLZK7zqBk5jbccelVKqsvhA8//JAmLVqRV1wW+e7/L/Ltt9/So3dfyuo25NFHH/2jp/ObqUlQ18Tf/4ucOHECuyiy2uFktcOJQ5L+dIt3Xdq0oaEkI+t0DBYlEiWJkpxcGhWXsG3btj96emekW9u2LNHs3KTZ8eoN9JQVXLJcbT+TP4IOTZuy/JRfTF+Hg1tvvfWcxx86dIgYj4d+ikqZqjLyirNLcu3btw+XLNPZ6cIjiud937744gueeeYZjhw58qeQKqwOJ06cYNSoURHzxIsplLrxppvwpBaRM/wO3CmFLFu27DLM9F/cfPPNSMF0yubsIr3fYlIyzq29vnXrVtwJmZTO2k5S56mU1K533jEOHjyIpNrxlnZE8CXjyGyAVdLOqLv9448/kptfjMkmkZSacVZ/izMl7kOhEE6Pj6ROU0nrNR9RVqq92JaVW0B03a7ENR+K0+OLPBe+9tprTJw4iTvuuIOKigoOHz6MyWKlZObWsOSGycyPP/5YrTEuBLOokDnwJsrm7EKKzmDRokXVavf222+juHyUzNhCzvA7cbi85zz+yJEjtGjdDs3hpmeffhw+fBiD0UTJ9L9QMmMLOoOJF198EQhX6K9cuZLXXnut2udRWVnJBx98cMn8sObOnYuWUkbJzG248lugM5hQEguxCBJPPvnkJRmjht+fmgR1Df8vuOeee2h8ylBvsqrRrF49enbsyOzp0y9o6/XF8Prrr1OcmUmiz8fqs2zlOnHiBJmJiXRTNUpFCVFvoInFikOvZ4GikeLz4RQEvKLI6GHDzjtmKBS64NX4H3/8kfT4eJo7nCQqCgvOsFINMLR/f2ac0iceoKiRLVehUAiXonCfw8lfXG4Uq5WjR4+ec8yTJ0/yxBNPRG5m/8nTTz+NX5K4UbNToqos/jcjvzPx5Zdf0rV7L+o0bMLOnTt5+eWXiZFl3vEFWGl3EtAbOBiIJt5goLMoMUxVSQwEqlVx8PDDD9O/e3duvfnms27n/PDDD8nLy0On0xG0WvnEF+B2u4PijAzcFgvv+AI86HThkWRWrFhBjMdDe6eTWFnmtltuqdLXwrlziZNl6jgcFGVmcvz4ce5dvRqrTURvMGISVHJHrSC6YV+atAhrZ7333ntYrAI6nQ6r2YpkE5EU+2lJsWPHjmE3hyvtD/iDZJrMREVFYTQLBK0S2VYrfreXqdNnVgn0nW4fmQNvpGDC/RhtMt7CVixYsICXXnoJ1WJlkqzQRxBRbOGqYHsgibTeC0jpNpv45DQqKytJSE7DJDsx2mTKatdFUlSMFgFHfCaqO0DT5mGpBUcwkRat2jJ//ny8xe1QNS+KRcBoETFZbGRk5+LLqosntZicvEIeeOABPv/8c44ePYrBbMNgk9GbrJhVL0ZBQQqmY7QpBBv0wWCVSO46k9LZOzFYRYKN+mNzx6E32zBYBKIbDySxfDI6k4XefftTWVmJIMqnJDLuRW8006Z9OZ9//jltO3REsHuw2P0YrOHtYxbNR/H0zXjLyjGdMmm0OILIcblYNB+iPxXBm4jgS6J09g6EQCpGq4gWnYpNtmO0yVjsPvQmG1F6A1E6PUWTH6Z46iPojSYExU6U3oDeaEFwRWN1BMOSI30XYfPEo6WW4fUF8CbnYffH06ZdB5LTMogymEjsNJWYZkOIT04lEBOHP7cBdl8cTZq1xCapGKwSNtVFcloGZXXqIzs86Awm0vpcS+nsnYjquU1SNm7ciGx3osXnhq+/4sZoUwjU70Vqeiay5kRJyCel+xxUt79KgLhnzx4CMXEIksKi664/re/Dhw/z2GOP8dFHH0X+LyUjm+TO0ygYvx7J7uKdd95h+MgrCdbqSMmMLXjSS7njjjvO/sU+B3XqNyK+9SiKJj+M3R930cFsbmEJMY0HkNrjakRFq3aFTg1/bmoS1DXx9/8qTzzxBNmJiWQnJp6zoOGPwqdp/MPj4zG3F4/Vyg03/HH6p9Vly5YteCWJTk4XqiAwc+ZM3nvvvT96Wudk+R13kCQrjJQVnKLIW2+9dc7jn3vuOQocjog/kUsQKMnIoF+PHixevDiy8Axw/fXXM0gNG+1dr9rpVV5+1n6ff/55nJJEocNJvM/PF198ccnO8ffgtttuO6t54uuvv07dBo0prVP/jHIvY8eNJ9igd9jzpX4vxldD9/i3UKdefUyiHTWpCKOo0ap1m3Mef+LECRo1a4GoOpDV6svrPPjgg1gllYT240nqMoPM3IKLmu+RI0eoVbcBOr2e7LzC0wq8XnjhBbJyC0hJz6ry+TsXoVAIg8FI8bRHKZ29E9nuPqfpZet2HXAnZuNOyKR9+ela3xfLu+++y0033cSOHTvwR8fjzG5EcpfpGMy2sxY+/SehUIgu3XuiOL0Issry8+zYmDJ1Gr68JuSPW4snpZDbb78dqyiT0G4siR0moDcLNG7ShHHjJ1R7B8O6detp27Ez8+YvoE79RsgOD5KiXZIE8rfffovRKhKl02HzJBB1qkhn8pSpv7nvGv44ahLUNfy/4Oeff6ZJ7dqIJhPRLhcOm43rVTtNVY2xI0ZcsnEu1jjmo48+IiBJHPAHuUIQmSwrHAxEM1FWUE0m7l6+nI8//viyBqtPPvkkRacCx7+6PaQEAgB8/vnnDOzZk/IWLdizZw+vvvoqstWKz2TCIQgR3eqKigrMBgMvn6r0ls9T6V1ZWUnbJk3I0jRiZZlZU0+/WSxdupQB9rAG9S2agySP56zJ7DPx8ssvEyvL7PMFuNfhxGkwsMPpRhcVxYf+IAcD0fiqsd3z8ccfJyBJLFY1chWVW/6jQqGyspJt27bx6KOPcujQIRo3bkxUVBT1zRbGKgpNa9fGJ4q86Qtwn8OJYhURVBf15fD20w1OF2VZVY3ZYt1u/ub2csAfJEPTWLNmDcuXL+fJJ59EMJkYpWioZhsGi433338/0u7WW29FtlgxGowktJ9ASvc5FJaebhTTol59xisqz3i8uI1G9GYb6f0WE9d6FEarSHq/63DGZ3LPPfdE2mhON1lDbqFw0kMYrBKqO8Bf/vIXAKZNm44iyEh2H3qjifLycnRGC1JM2MywoLiU119/HdnhJb3vIuLbXEVsYgovvvgizmAipbN3kjvybty+AG+88QbPPfccFRUVPPjggwiamzIhfK3usTvRLDb0Rguls3dQOms7eoOxykLT2PET0BlNxDYfSkq3WegMJuITEoluMpCyObuIaTYYk+TAmVKMWXFTOms7iR0mIHgTSOkxF71FwCiEk7WC5mbXrl089NDD2EQJs8XK7bf/K+H5+eef4w7EkNpzLiUzt6Ill2C2+8m6Yhk2Tzz+ut3JGnIrequIM7tJeN6ztlMyYwtROh1iMCMsl+GJp3T2TrKG3IJRUEjpPgeDRcDqikVvtGDRfMS3vgqz1caxY8f47LPPOHz4ML369MMkKOSPW0tC+/HY3LGImounnnqKRx99lMcff5yDBw+SlVeA0SZTOms7BePXYxMkvvnmG1auXMnOnTsxmc0UTniAoqmb0JttOJMKUNzRlM7aTnLXGVg0H9F1uhIdl1ClWu7jjz+mUbMWZOUVsnHjRuo3aU5y15lhKZbUMhI7TCCh3VhMgowvGIsUnUFyl+lhTfWillWSx0mpGSR3nkb+mNWIqqPK5/ps7NmzB48/iNli5eq584DwQlVuQTF6vYHmrdpy7Nix09odOXLkvMY0b775JjHxiRiMJkaMuuqidUY1h5u8q1ZROnsHdl/MBVWT1PDnpSZBXRN/1/DnpF+3bjRUNa5QVKLd7ksu4ff4449Tr6CANo0bV+s+VV1efvllVq9ezSeffHLJ+rzcPProo8ydOzci5XYuvv76a9yKwgxFpa0k4zWZuFWzI+h09JNl4mSZlad2ZW7dupVEWeZeh5MGqsa8OXPO2m+vTp1YeCqZ3V2zX/Yq4svB7t270TQNt9vNc889B4SfKVXNgZpURKB+T1S787SiqrfffhvV4cKfVojqcLF3797LNsf3338fk01Eic8jtsUwBE88t91223nbhUIh9u/ff0GVw6FQiIFXDMFktlSRiLtQrrvuOrw5DSidtZ1ASVvGT5jIp59+yvPPP/+bCtTKO3fDk5yPL7seOXmF5ywKO3nyJI888giPPPLIJdltsmHDBho3a3lKxrE9mjeaBQsXkp6Vg8sfw7XXXntB/YVCId555x0OHjx43mMHDR5KTOMB4Ri+pC0LFixg9OgxWBQXYiANi+zAmVxEdP1eaE73GTXK/53HH38cxeUnsXwS9rgMJGcg/NzRZXq1qu2rw+bNm3H7AqgOF1k5ucybv+D/jbfL/yo1Ceoa/t8QCoUiEhZtT0kZPOB0UTcvLyLwv3v37t+0NeyqoUOJkWSiJYlxI0dWGftcHD9+nBiPh7GqRonVRrbZwgani1xRZPLkyWc8l927d7NmzZqzbme6UD7++GOcoshyu4OB/2Yu0qC4mKGndKBdsswjjzxCjCRxt91JA0VlzowZAPz1r39FEmQkowlVb6Bh7dpnHOef//wnnVq2onObNrhtNj7xB/mn149stTLhqqvo2bFjJDh78803cUoSA0UJr95AV5uAS5arfc6hUIgrhwzBZjJhFyU6tmlDdnw8ST4f7VSVPopKenx8JGA4cuQIjZu1wGITaNqidSSYWrRoEcPUcNX4jZqd3p06VRmnR+++uGLTcCdm07BJMxIDAVSjkaioKExGI9u2bWPS2LEYdXosBiOxzYdisAhE6fS0EmS6qBoDe/as0mej0lJGqxqrHE40qxVB1oguaY2oaIhmM4+7vWxxuVFstiqfWYfLQ1qv+WQPux2DRSBQpyst27Srck2uGjMOUVZwCSKa1Yrijo0kavNG34vBIlA2ZxfBej2ZNi0sE/Pkk0/i8UdjsAjoDUZiE1O47fbbI/3WqteQuDZXYRLt+Gp1Qg6kIPqTwgYZrUdRv1FT3nrrLRSHh6LJD5Pacy7+mHiWLl2KqGik9pxLTMM+FNeqw5NPPok/Oha7y8OEiRMxGQy49Hp2uDz0E0QEvQGDVSLYoA/R9XqQmJpe5TtWUVGB3mCgaMqmsKSGyYKouTBJduJajcRi9yM6fHTr1g2rKKEll2CR7NhTiskZeRcGi0DJjC3kjV6N3miOyNVUVlby9ttvR7RzT5w4QUJyKnJ0OjZ3HNGN+odlNEwWzKoHLaUMvcmK3iKgN1rC/5qsxLUaSXSTgZhVD3JcLlJsNkZBJb3fYoL1euL0BtDp9FgcfvRmG7kj7yah/bhwhbbByMmTJzlx4kTE2Gf21ddgtYnImpP8olLuu29tlc9Sm/bleMs6IcflYHXFYNPcDBtR9fdJ0Ryk9V5A5qAl6M02FE80ksND4YQHiG02mNjEFEaPHXeaJE5RaW1iGvUjrfcCREWje8/eeHIbk9H/OkySnaROU/EWt6XfgEE4XF5iml6BSXJgT6+DVZSZNWsWb7/9Nm07dMIqa8S3HU3JjC2obv8FJXLP9Bv75JNPUrdhE+rUb8iiRYvYv38/oVCIocNHYrbYkBSV3bt3X1Tf1aGyspJ77rmH2nXqItk9eJJyKC6r/afbDl/DxVGToK6Jv2v4c/LLL79wyy23MGf27EuuN/39999jPxUrT1M1CtLSLmn//9959dVXGdKvHw3r1mOQrLBQ1ehqEzgYiGa53UG7xo0jx952yy00q1WLaRMnnnOn47hRo+iiajzp9pKnqjxwDjP5PwOfffYZq1evPq0iet++faSkpGA2m1m9ejV33XU3JtlJsGFfjIKKyWIjKS0Th8vDDTcuibT78ssv2b1792XfnfWPf/wDuy8Od34LLJoXUXWc8X1Zv/5+4pPSKCyp9ZsT5j/++ONvSiYuXLgQf0EzSmfvJFinC23atkNUNFwxKWTnFVRb0mPPnj2sXLkyEgOfOHEiUjh0uTyszsSzzz6L4vDgym+BI7M+ZXN2kdLjauo3Pr+296Xg7bffRnO6ccem4A/G8tlnn/HLL78wbMQoUrNykTQnuaNWhM2wk3POWcn91FNPkZ6Zja8kbAyf2HEiVsVB4cQHiWs+hMbNWv4u51TDfx81Ceoa/t9x4MAB3IpCf00jVVG4cfFi+nTpQpaqkaVq9OvW7aL6PXLkCDaTiX2+AHt9ASxGI0eOHKFP5y6YDAYK0tPZv3//Wdu/9tprdGrfnhFDhzJh9Gjq5uUxe9q0MybM5199NUmKQiuHk5SYmAu+OS676SYaFBYyftSoKivI27dvp1nt2vTv1j1S/WwXRf7p9XPAHyRRUZkyZQp9T2nO3azZ6dwqLC9x7bXXEqzThbzR9xJs1J/O3XudNu7hw4dxKQrXqhrDVRVZr2eNw8l8VcMjCHRWNa5VNZySFJEReP311xHMZm7WwpXUKarGq6++ysmTJ1l03fV079X3vLqu/6mR+6sx4dVz5lQxJpw7dx6+3EYUTdmIN7s+C0+tQr/00ks4RZGRikqMJHH/+vWRNidOnECvN1A8fTMlM7dhMFnIOhVsj5ZkLGYzBoMBm06HajSiM1owyU5Sul9N4aQNmGwSaanpFJTUZv6ChezZs4evvvqKLVu2EBsTR7Q/QJOmzYhtPjScNK7fiw7t2iFbrcg2G6tXr+bNN99kyZIlPPXUU1isNvLHrAnLQZisZOcXRapx1q5di2YyIet0uFPKCNbrTpt2HYlPSsFkk7BqXkTViUWQiM6tj2J38uabb1JZWYmi2UntOZf0vosQRLlKVerJkydJycjCJDmQYrMpm7OL7CG3YrSFZTHsaXWwCjJHjhxhwqTJGIxGjGYLJkFGpzdgMFtJzcyhWau2fPLJJzg9PlJ7ziVr6K0YzDYUbyKq3Y+k0+MOpJ4yiRRISkljwKDBZ/xejRh1FZo3BovqxZ5el+Lpf0FvNGFVXdjTaqPYnaxfvx5BsePJaYhNlElOy0CvN4Tfw8E3k9xlOmabFNGWa9K8JWZBwSqpTJoyjY8++ghBcVA6ewdxba4kSm+kb7/+WAWRwokPnpIQCZsVlszYgtUVi9FsRXG40ZsFogwm7On1MFpF7PHZGG0SxWV1GDRoENExsZhVDxbNR8nMbWQNvjlstCirPP300yiaA7PFRp9+A05Lzt9zzz3MnTs3IoURiE0ksXwSxTO2YvPEI3oTsbs8VR5mHn/8cXzBWMyChKLZmTJtOoOHjcBkthATl8h9993Hhg0bTpPtsUlhc5XS2TuR3EE6lpdjlOxYHEH0JiuK5qReoyZ8/fXX3HHnnRjMNnRGC1E6A1IgGW9WPUTVQUyjfmHjTKMZQdHo1rP3aYnhL774gnfeeadaCePvvvsOSbWT1GkKgXo9sCgu7C4PO3fuRHX7KZ76CGm95pOQkn7evi6WWbOvxhmXQbBBbwRZZdmyZbQv70JqVi5Lliy7bOPW8PtQk6Cuib9r+N9j3759REsy+08VV6g22x89pT8VX3/9dbUqZfft24dbUShTNVS9niWanTqqxtWnil4uhEOHDtG5VSsSvF4mXHVVleemUCjEzClTCDocNC4rO69J+rFjx/jiiy8uemH6fHz22WdoTjdadCqCrLFk6VL+/ve/c/z4cd58802uueYaCgoKiIqKIiU1jYQO4ymbswtvSQesgkhcq5HkjlqBZHfx9ttvX5Y5no2KigoaN2uJ3ReLqNhZ8W87LH/lwIEDiLJGxoAbiWs5goyc/Ms2nxdffJH4pFQcLi93Ll9+xmO+++47MrJzsUkKsQlJZOYWktpzbtg0L6WAzZs3n3ecdevWozg9RBc0xe7yVHvRq7KykhdeeIFXX331Qk7rnNxyyy1El7Yla/DNGAWVxA4T8KQWM2nKtEs2xvn44YcfeOmll874Pe/dbwCetBKC9Xpgd3nOWkG9f/9+ZNURll002/AWtUFx+mjeshUWm0ByWuZ/vZF2DZePmgR1Df8v+eCDD7jhhhvYvHkzhw8fxmYy8YE/yPv+IBaj8aIMDH41jlnjcLLK4cQhy6xdu5YSTeNdX4ArVY0BPXqcse3+/fuJdrspcDhxKwqvv/76OcdKi45ml9vDwUA0RQ7HBWkAbt26lSRZYZ3DRRNVY/Z5jBSvHDKEXFWjpd1BXmoqb7/9Ni5ZprvDiV+SItWlL7/8MpJqJ1i7M4rLx4YNG8KO2v36IVkslGRl8cQTTxAryxzwB3nN60c0mylMS6NhcTFxbjdPuL0cDERT7HBW0Z4aMWgQBapGe7udzMREjh07xqw5V+NOyiO+zWgkzRmR/giFQnzzzTcXtXVrwsRJBOt0pWzOLjx5zehYXh7Z8vTiiy8yf/7804zSQqEQgehY4loMI6H9OASTBa9ez3xFpa+qUZCdjaLXExUVhVevR43SYYiKQtO8ZA+/A4sg40ouIK3PQqx2H4rLj6TaESSZ2BbD8GbXp6i0Fs64DFK6z8YRTOLqq69GVh0EMkrQHG5EWSW6rAOKw0O/fgMQZBVJczJsxKjIPH/++Wckg5GuNoG/uNw4dDrsdj95hcWcPHmSjz/+mCeffJLXX3+daZMmkezz0bFlSw4dOsSJEycwmkwRHWSLTeD777/n8OHDlNWpj06vx+72ocRmozfbiGl6Bc6UYgxmG1ZnNGbNS1RUFAnJqezatQtFc2JRvVg0H0VTNhLTZBDZ+QU899xz/Pzzz1gFkZxRK5DjcojS6Sme+gils3eiN1lJ77eYgvHrMZhtyKqdxs1bYne66dG7bxXJhlAoFK40sDtIaD+OpM7TiNLpidLpqFW7Lm+//TY9+/Qjvs1V4cR/nS4sWLCAUCjEunXr8fjDxoG/VvOvX78end5I0ZSNFE1+GIPRxHvvvYfeZMFfuyvO3CYYrBJ6oxmTTcEoaIjBdIy2sDZb8dRHMKtuRo68EpsokT30NvLHrEFnMGFSPQiSzJ49e0jPzMKsuHDlNUeKzcGeXjdijqi3CLRv357s/CKSu86gePpm7P64KlsfR145GldiDv6ycgRJ4YYbbiArNw+DRcCsuLG6Yiie9ijBrNps2rSJ/fv3k5mTj8lspkfvvpFKlW+++QZ/MIZAVi2skoqgOvGll5CelcOxY8f45Zdf6NG7LwaLgNGmIATS0JusGKwSSeWTw9+horYMGzaMhx9+mGeffZZbbrkFk6hRMv0vZA5agsXuo3TWdnR646mE/g5kp5fHH3/8tIfD++5biyCrKE4v7cs7V3kArays5NpFi2nZtkNEP+/NN99E80ZTOnsn+ePWYrDJBAuaMHfuXBSnj6Ipm0jtcQ1JaRl89913PPPMM+fdinihFJTUJr3f4rA2ZH4j6tZvQKC4NZkDb0LzBKutEVjDn5OaBHVN/F3DpeOdd97hmWeeOa/00h9NRUUFjcrKKLHbSVIUpowb90dP6U9BKBRiaL9+yBYLitXKli1bztvmwIEDbNy4kdtvu412TZowYezYS77DaPfu3aQoCs94vAxXVXqWlxMKhZg0ZRpuX5D6jZtFFuv/8Y9/4FZV7FYrrRs1qpY/zYWydOlSDBYBV25TzIobvUXAFZtKUlo6kmonunY5istPkyZNwrswrQLRTQaGiyn8QTIH3kjprO04gomR+PT3pKKigpdeeumsmsuvvvoqmjeG0lnbyR15Nw73uU33fgvxSakkdZpCzvA7EWT1rKb3lZWVfPXVV+zatQuzIOOv042cEctR3QH+/ve/n3echk1bRqTrgoXNufvuu8/b5ldtZ7svFsXpZcq0C194ORP79u1D1hxEl3VAUBwUlNRiztXXVPuzGgqFIkU3F8KBAwd4++23z7tw88svv3DTTTcxceKkcyaYn3jiCbzJueEK8G6z0OxO/va3v511znfccSd9BwyKyErW8L9NTYK6hv96fvnll3NWGFdUVODRNJZodm7U7Hjt9ouW+Xj88cfJTggbx/ztb3/jnnvuoZndzgF/kGtUje7t2p2x3bx58xh4ynhwmqIyfODAc47TsXkL+qkat9sdOEXxnOYM/8lNN91Ev1PVyDdqdnqcZU6/UllZyaZNm1i5cmVEUuDDDz/krrvuOm172iuvvMLixYt5/PHHAdi0aRP5msYbXj9XqRq9OnWiMCOD5nY7+arGkH79Im0njx1LrqrSRlZwKEqVoKGiooIHHniAO++8MyLv0bBpS1K6zw5rCpe0Yvny5Zw8eZJOrVsjWyy4FOWMhiLn4tNPP8UXiEGyuxD1elqcWjA4n8bg22+/TXRMPPE2me0uD6NlBU0QaNe0KSOGDGG0JDNYlIiKisKl1/Oyx0e5zYYxKgqj2Upc61HhConSjkQ3HkB8m9HYNG+4EnnYHfhj4pk5ew51Gzala9dulNauS1yrkeEtVMVtUE5VLSe0H0/nbj04cOAAH3zwAaFQiGeeeYZx48bRqXMXZJ2OmzQ73WwCLa1WFqkaqtXKunXrIosyjz32GImKwl9cbrqpGiMGDQJg0pSpyA4PitPHkGEj2Lt3L23atMGemEfprO34Clvij45BUjSycgvo338ABcWlCHYvUnQG+WPvI1i7M0mp6Qi+JAw2BbPqCbet0xWj2YYjOgWbpBKXmILRbEXwJiL6U/DX6Upsi2HoTVZ0RhM6g5GYpoORffHYk4vwlXVC8sSSV1DEwmsXVXnAeemll8gvKkVnsGCwCNg88ejNVvbt28fCRYtxJ+eT2nMu9kACmzZtOut7PH36dPQmCxn9ryO977XojWZsooTBIuAt6YCnqB1RBiMGq0hKt1k4MuphdcchBtMxmK3o9Hpq1a3PyZMnsdgEcketoHDCA+jNNvRmG56ETK677jp0eiPRTQaeSmh7sSgudAYjNl8SRkHFJilk5OST1HkqxdMexe6L5e9//zufffYZX3zxBTEJyeQMv5OyObsQ/SnozTZcyQXoTRaMVgE1uYiE9uOQNAf79u2jR6++xNTvSdGUTbgTsnjggQe44447aNm6DfbY9LAGtsmCWfVSOnsnrthU/v73v7NkyRLcqUXkDL8TOS4XJaEAiyBiFDXMqhd/3R7ozTbcHi/+9BI0T5Cu3bphsAjkj11LcpcZ4a2rZe1xePw4o5PxphZSVFr7jNs5AzHxZF6xNKzz7Y3mpZdeiry2dNnNuOKzSO4yHc0Xy+bNmzl58iT5RaWosVmYVS86owWLGP5NuGrseIwmM7JmZ+3atdhdHrxJOdhdnnOaurz//vs88sgj563A+pXJU6fjTswhpskgJNVBfnFZ5DcrkFOftWvXnr+TGv601CSoa+LvGi4Ny++4A48okqVpNCgpuSyJwUvBSy+9RLzPh8VopFunTjz55JOXrdL2v41XX32VGElmpqxgjorCotNVK0kNMGXcODyCgFsQmD3tX5Wgb7zxRsRk/t5Vq6q02bBhA4P79GHVypXnfA/uv/9+GjscHPAHud3uoFnt2mzfHk7w5l55D8Fa5fTsE34WaV63Ljdqdj7xBynW7Dz66KMXfiHOw5w5c1CTiiibs4u03gswK56w0Z47SKCkLWVzdpHUaQqt25dz6623otfrcTgcrF69mvXr70eUNTRPkCbNWl7SZP6XX37JsmXLWL9+/W+SuqyoqKBhk+Y4o5OQ7e4qUiSXGofLS87wOymZsQXF5TtvRbk/OpbE8snIp7xxJlXTKG/02PF4s+qS0uNqVJc/YvRYUVHBlUOGEO/x0L19+yo7DNeuXYvRKiL4kkntNQ+D0cTWrVt/k+71r+zdu5clS5bw2GOPXVC7gwcPkpSajsFoona9hqcV47300kts2rSJQ4cOVfn/u+6++1SBiI/yLt0uyW/eoUOHCETHEihohjM6mclTz14sd/Mtt+KMSSWu9Shkh+eSmCfW8N9NTYK6hv9qtm/fjiYICCYTE6688qzHvfjiizQqKaFRaWmVxMfF8OGHHzJqyBAmjhnDxx9/TFluLj5RxKtpZ9VUXb58ObVVlec8PtpVo6r522+/ZVCvXrSsV48dO3Zc8PzcikJ7lwuPKLJ9+3YqKioY0q8fqs1G/aKiaumY/fTTT+etNF+zZg2N7eHAcLGq0aFZM44cOcLKlSt5+OGHqaiooLKyklAoRGVlJTfeeCOKxUJHhxOXKEYS3Wfitttvx+6LJVinC/KpZNuOHTvI1TQ+8gdZptlpVFJyQdcGwpXG5S1bRgxXBikqixcv5ujRo1zRuzeFaWlct3DhaTfobdu24RNFBmt2nIIYSY6/9dZbuGWFHKsVQ1QUhqgoPHo9Dc0WRogSN6oaepMVb1Y99CYrab0X4MlviVVU8Je2R/DEI6guHG4veWlptNTsRNtE7CmlZA25BS2YjE3WSOo0BVdCNouvv6HKnETViTO3GXqLiM0qYtPpsOvCes4HA9Hkmsxo/ngSU9I4fPgwK1eupL3DycFANLfbHTSvU4f+gwbTtGUbVq5cyWuvvcYDDzyAIKn4ilpjEjWSOk0lUKucCRMnAbBkyTLsvjj8Ra0wmG0YRQ2DVcKRVhvF4cZT3I6U7rPRm21EGUwYrCLJnadRNmcXamIh7rzmWAUJwekne9jtiME0jIJK9rA7UJNLEf3JxDQdjNEqYLCI+Gt3weaJx+qKxZWYS/sOHdm0aVMk0fnkk0+GNZ77XBtJ3K5cuZKTJ09SUlYbg1XEKkgsWbLkjLsXvvvuO5q3aoPRJqE32zCYbUiuaPLHrUP0JmIWNYwWGzqDCTkuXBGQ3vdazJIdQdZISEoJGx7KGo2btSAYHUuU3oDeZMGZ0xSdwYgkqwwZOgydyYLRpuCv0w29WWDixImIskJsyxFkDb0Vk6AQm5iCKCsYTeGq5wmTpmCTFGyiTF5hCY6UEmKaXoHeZCWpfEo4IZpVhxtvvJEJkyaTlZuP2Sqg2h0UFJcS33oUpbN34susRZt2HXDGZxHdqB96k4VAg94UjF+PSbIT02QQgqTy0EMPMfLKKwnW7xXuu15PVIebqVOnonhiwtXeZhsOtxd3fDolM7fhr9MNWbWTV1iMTm/AaLHRtHlzRo8dx5dffsn27dvZsGHDWSs70rJySewwgbwrVyKpDkaMHEVMQhJtO3Sia49exLe+MlzdUrc711xzDRDeaizIGhZHgOgmg7DJdt555x0gvI23oqKCSZMmE6zXI1zlXL8X48ZPOOP4Tz31VHiHSHYdVIeLJ5544rxa+BUVFdx8yy2MHHUVL7zwAhs3bkTSnPjTigjGxl/yiu0afl9qEtT/HfH3J598wosvvnhZtd9ffPFF1q1bV0UyrIbqkxwIsN3lYf8pU+g/ojK0OpRlZ7NEs/Oa109Qknj55Zcv21jbtm1jyZIlfPjhh5H/27t3Lx2aN6dt48aXVDagOnz55ZcsXryYO+6444xV7m+99RYeQUDW6XjR6+NRpxuPqp233yNHjiCYTLzlC/CG14/F+C/T6/zUVK5V7WxzeXAIQkTObevWrcRIEteqYanG1ffee87+81LTyNA0HKLI7t27Wb16Nf7sOmHd2/JJNDqlddu2SROuVjXe8wXI1rTzygdeDK+88go2WSO58zS0lBKkQCo5w+9EVJ2ImovEDhNwJ+Ywb8FCIOzvo6pqxDzxs88+44033qiykP9bdx0cPXqUYGw8gcIWuBKyGDZyVJXXP/roIxqWlJASCHLnv3nPnI2TJ0/y7LPP8tZbb13wXL7//nuGjhhJ246dIongs3Hn8uXhxKnLR+duPc6bOHW6fWQNuYWiqZuQNGe1DU5//vlnrhozjroNm7Jy5b8WSlatWkWJqvG0x0t7VWP6Kc+on376CUFSSOu9gOQu0zHaFPQma9iHpFadS3YvOnbsGDfeeCNTp02PSPqdi6EjRhJdp2u4MCirLrfcckvktbvuvhvF6cGfUUpcYnKVJLXL6yd72B1hfxiXnzfffPOSzP/LL7/ktttu45FHHjnne9epaw8SO0wIx+l1urB48eJLMn4N/73UJKhr+K8mKRBgg9PFXl8Avyhedr2u48ePE+v1MkZR6aOq1CkooKKigo8//viMiZdQKMSPP/7IyZMnGdqvHzEuF93atbsoiZELYf/+/axbty6SjLv//vspVDVe9foZ/B+VzWfizttuQzSbEcxmlt1441mP+/HHHynNySFalnEpCv/4xz+qvH7P3XcjWizIVisP3H8/8+fPZ9ipSvIFqkZWXDz1CwrOGnxu3ryZhQsXRm6Wu3fvJkNVec8XYJFmp+lZjBrPxzWzZtFY1XjI6SJDCSfkxl95Je1VjUecbpIV5YyB6zPPPMP1119/2iLHV199xRNPPMHbb79NSlwcuqgooqKiGCVKbHa6sEVFYTMYw8lPq4TVGaReg8Y0atQYLamQ0tk78JV2RDOZOOAP8pYvgN5kITE1g8lTp7N69RradOjEwmsXVQlaO3ftjlHUwlWtigtndmOi4xLo1K4d2YpCV1FEtAgUTnoILZiM0+MnKS0Tn8NBPWd4kaCgqARvYUsSOk7EZjBi1OkQ9HrsGXUjlR4mm4zLG+Dhhx/mu+++I7ugmPQ+15I97HbMspOSmVvDemkWAV90HNlDb6Nszi6srliUpCJMooq/tAM5I+/C6owmpec16PQGEpJT0RmMGK0SOoMJb0kHBIOBJKMJ4VRViRwfTghnDLgRwZcUNh6MycIVn0Gvvv0BePfddzFaJXxlncgctASjTeaFF17gtddeQ3H5KJr8MCndZ2MSFGS7m5tvvrXK+9epaw8CJW1I7TkXi6gyYMAA/DkNKJ29k7hWo2jYpBkLFixASyrArLjRUmthkjTGjBnLmDFj0JusZA68ifg2ozGr3rC2tCNIlNGM3mjBnlKCqDqYNm0aRot4qqraitPt4cSJE8y++hpEuye8yOCKJVCvFzZRoWv3nlhFmSidAXdhG6TYbKL0RoxmKwZLuHLDkVGP1J5zUZwetm7dSp36jTBaw4l2e1odDCYrsmpHcXjIKyohr6gsIkuhJhXhqx0OZkV3DLHxidgkBW9SDm5fAFlzVHGOr6ysZNKUaaRm5tCrTz/27t2LpNpREwuRY7PxFrfH4wtGdmKEQiFmzJyNxx9NvUZN+OKLL6pc988++4wevfvSsk171qxZQ3xSKormYNAVg3EEE8O7C4pa0rJVa2S7i+iy9kiqPZI0GDHqKuxptUjrsxCz6kXUXLzyyitVxrjxxhvxpJWQd+VKPOllLL7uujP+JnTv1Ze41qMonbUdqzOIVbYjyuoFLxDu3buXrVu38sMPP5zx9crKyt9UvVTD70dNgvrPH3+vX7cOhyCQoqo0Kiu7LJW5a++7D78k0cbpIuhyXXajsv+P1C8qYpqq8ReXG5cgVDtx9HuTm5TEOoeLD/1BUlT1siXSl910E0myQh/NjkdVIwa/cT4fc1SNhaqGz35mg7rLwbFjx0iOjqanqtFA1ehZ3umMx40eMQKbTsebvgCPu704JOm8fR8/fhzFZmOT080GpwtNECJxbNDp5HG3l0/8QeJlJVLkM2P6dMZLMgcD0cxTtPPuOj127Bj/+Mc/IrufDh06RHJaBq7YVGT1XzKJe/fuJSkYxKDXM6hXrwu6F1dWVrJ///5qySds3LiRpi3bcMWQYZTWqYcvGMvCaxfx0EMP0bFLNxYuWlwlln/nnXdITk7GbDazZs2ayP9//vnnpGXmoNcbqN+o6TkN/yoqKvjqq68i5/TWW29x33338eGHH/L888/jiU+nbM4u8q5ahdsXrNK2NDcX0WRFr9MhWIVLlqA8E63atsdf1JKEdmORNUfEj+hsnE964rPPPovsMl6//n5sooRVlOk3cBDffPPNb/oOLV68mL6nnllnKypX9O4NhJ/5rKJMyfS/UDT5YaJ0epK7zqB09g7svthLtrjUpXtPPOllBOt0weX1R2LrszFk2HCi6/cIP1Nm12fZsmU89NBDtG5fjtsXJK33Qsrm7MKfXlxFSiMpNYP4duOIazUKqyBdcuPZ87FmzX2o7iDB+j2RVAf//Oc/f9fxa/jzcdkS1FFRUf1/S/vf8leToP7fISUYZL3DxZu+AD5RjFTPXS4++eQT/KLEgVN61ka9/qw3zY8++ojk6GgsRiMt6tevYjp3Nvbv309ZTg6qzcZVQ4deskTG8uXLaX1KimT+OaRIIKy1bTOZ+JvbSwerDVmvZ9LYsWedy8mTJ3n33XdPk1n58ccfkSwWnvF42e32IFmsbNiwgXRFYa3DRYnNRq7VyppTWtfVuSFVVlZyRZ8+GHQ6NKuV26ux0n8mjh8/zpjhw6mVnc3CuXMJhUKUt2jBslPSKN3sjip9v/jii4waMoTrFi06ayXD7t27ccgyZoOBbp06ER8XR9SpiupMgxFRpyNQrydyXC6ugpakZeUyd+5crJoXqysG2ZeIXRCYpmp0lSREgwGTwcDgPn3Oeu3rN2yMv043SmfvxJFRH4ukMXrcBEKhEBs2bCAuPhElOoOkTtPQG81kDryRpE5T8AVj2bZtG++++y6eQAw5w+8krdd84owm3vYFmCqrSEYzSZ2mIAZSiTIYsahu9CYLJosNg9mKmlhETLPBGMw2cketILHDBOwuLzNnzUZ1B5FjszHYZIqnbya56yxMNhmLIGOSHFjdcZgkB7pTVcZGQcVX1hm90Ui+2cwBf5A5ior+VCI2tvlQpJhMDFYZg02mdPYOiqZswmgyR67F0mXLMNokDFYJweGjU9duvPzyy6juAMXTNpPWewFWVyzuwtZYRSlSuXHo0CFi4hJJPKWrLAbSECWZhORUHP44FHtY/3z16tW4k/PJG7MaNakIg0VEbzBiNJkwSfawHt+V92AUNWKbDcFb2hGz5sWV0zhSxVNauz4Gsw1PcXvMsouevXpH5h8dl4gzpzEJ7cdjFBRsdh+CYqdg4oPoLQKOrEa4C1uhM5iJbzsavcmKFJuDwSYTm5jKmjX3UbteQ6Ib9Ca97yIMVom80ffiK+vEzJkz+fDDD6moqGDKtOkI3gSCDfthOLUwIGkumjRviS86PqLZ7S9szoIFC3jsscf46quvOHbsGE1btEan15OVWxBJNj/66KOYrCL5Y1aHdanj03nhhRf45ptvaN68OUarSHSTKwjW7kTX/zBWLSypRXTdriS0HYNid0YqOpYvX04gv0n4unWYQIs27Xn++ee5+eabeeONNyLtw7qBMyibswt7Wm1Kymqd9nt8/PhxevcbgDcQQ88+/c66/XLGzFm400qIbTEcqyNA6aztpPWad0kNgNasuQ+rIGITJO67r0b+48/OnzFB/UfG1tX5+73j76z4eDY63ez3B8nWNJ566qlLPkbjklJWndp11Nbh5L777rvkY/wnx44dY/GiRYwfPZq9e/de9vEuN++//z4NS0pIj4lh1cqVf/R0zsqvuzKdNhvd2re/bIuJDQoLWedwcTAQTTuni7Vr13L8+HGMej0f+oN87A8im82/2y6cN998kyQ1nIh7zetHE4SzHjtt4kRkiwXZYmHN6tXV6n/z5s3EejzEe71VFn1vv+UWXIJAkqLSrlmzyPV+6qmn8IgiYxSFgCRVy+juV0KhUESHd8+ePWeU7DqTzNiZePXVVxl15WgWXruIklp1EVUHmtP9m3finonvvvsuoks9depUKisrGT7ySoK1O1E6azvezNrceuutZ2x78OBB4hKTsUkK6Vk5bN68GYcg0FBVsYsiTz/9NLLmIK7VSAJFLWnRuuozoCirJLQfT9HUTVhkJ8uWLTvrPL/55hvqNmyMYncy8Ioh1b6Wv+KLjiNn5F1h2cPErPNWUZ+Lm5YsRZBURNXBqKvGAOGYvrxLV6xC2DPGYDQycfKUi+r/wIEDRLvdFDmcuGSZNWvWMGvWLB555BF69umH5otBcfpw+4LENhlAao9rEBXtki1i2l0e8sfeR9mcXTiCSUydOvWcldSffvopMfGJWGwiBcVlPPbYY8gOD4nlk1DjcpCDaaT1WYjscFfZ8b1nz56wF403EdHhZcas2axevZqlS5fyzTffXJJzgXC+4GzV5Vu2bGHOnDkXJN35448/MmLUVdRr1Iz16++/VNOs4U/Ab05QR0VFZZ7hLysqKurv1Wl/Of5qEtT/O+zevRu7KGIxGpk24cxbtyGcWH711Vd/c7B58uRJspKS6KqqNFNV2jZpctZjB/TowThV4xN/kEaanRUrVpy3/57l5VypqLzi9ZNssZxRw/Snn35i0pgxdGrZstrb0w4dOkRuSioJioJbUc4ZXJ04cQLBbKa/INLSYmWHy0OuorJ+/fpqjfUrv27rW+dw8ZTbi9Vk4sSJE9y4eDGNS0pI8HhYZXdwMBBNniTTuFZt7rrzzvNu4Vp2001kywrXyAqqxUJadDQNiotZvGgRjUtKGTFo0Dk1yc/Gjh07cIkiTZwuAk5nxDzxk08+wSlJTJcVGqgqo4cNO2P7BJ+P9Q4Xr3r9iHo9ZpuI4VQlddBgoIdNwO1PIanzVMyiyp3Ll9Ole0+8RW3IGnwzFsXJXXfdRb+u3Uhwubnu1DbEdFVl165dZ7wuo8eOx1fclpKZW7EnF9GlS5fIzX/R4uvQfLG4shpiMNswCxIlM7aQP/Y+bEJ4QaBBURFelxuL5kUMppNlMvOpP8hSzY5ddqK3CPhqd8Vb1gm9yUrRlE3kjLwLvdlGoF5PBFcM6ZlZ6E0WDIKKzmDCaLbQo2cvLGI4mZzQfhxqUhFSMI0WrdshSDIm2YUjpylFUzYix2Yj+lOJbjIQ2RuPy2Bkl9tDXYsVR2Z9MgctQU0uwXBKesMoasS3GU2gfi9SM7Mj12L//v2IqoOiqZtQ4vOJitKRX1RCzz79MFsFdAYTNnc8BouI1RWL0SJyxYABGM1WpEAqerMVwZ+MSXZiFDW8Xh/jx4+PJAdOnDhBWZ36ROn0WBxBDFaRwokPktR1FgZz2KDQYBGR4/Mw2mT8tbtiFWRUT5C03gtwpZXiD8bgym36L9MQT4BffvmFTz/9FLvbF9GWtnnikZSwfEj+2LWYJAe+Wp2xeeLx1+0RNmu0iMQ0vQKrK4bElDR++uknArEJZA+9jdLZO7E6gsS2GI7ii+f++/8VuFVUVBCXkIToiceVVY+Y+ET27dvH+vXrEew+nDlNyBmxHNEbx4YNGyLt7rjjDrzppZTM3EqwVjlDR4yMvNauY2e8OQ2IadQPzenm4MGDuH0BtNQybJ748AJErU7Ua9i0yudXkGQKJzxA6eydaN7oyA6Yr7/+mkBMHL7kXARJoV6jJnTt0fu0wPzhhx9GtrsI5NTD4faetxLnbPz888/UqtcAg8mMySpglR0UjF8flkapXe+cbf/+97+zdOnS8xrfHj9+HItNIGfkXeSMWI7FJvzpzcL+1/kjE9R/xti6On+/d/zdqKSEGarGY24vPlG8LJV/IwYNoqOqscbhJHjK7PZyM6B7d5qoKmMVFY+qXtIkQQ3n5vDhw5GK5n/nzTffZN26db+5uvDo0aO0bNSIhpLETZodjyhGkkU9OnakUNMotdtp26TJZde//uCDD+jVqRNd2rTBo6pMVlS6qRot6p37vvfdd99dVJx9Jt577z1efPHF0xKdzzzzDHPmzOGvf/1rtfu6b80aZKsVxWbj/lPPLCdOnGDjxo088sgjFyS9cPDgQRS7k+jG/XEk5SM4/ZTO3kF8m9E0a9mm2v1Uh1AoxIEDB/j6668ZMWIEUVFRdOzYkX4DBhFdv2dYoi23IUuXLq3S7lf5tCsGDw0nsmfvxF/Ygsy0NGwmCy5HAJvJwtixY/nHP/5Bl+69uHL02NN2eMUmpJDSbRYlM7Zgc/jZtWvXWec6dPgIAqXtyB+3FndC1gU/G46fOAlnTCqBgqYEY+Mv+nMUCoWwWG3kj1lD0ZRN2ESFL774gtdeew3V7cfmjiOlx9UUTX4YxeG56HvDoUOHeOaZZ3jiiSfCMnD1eqL5Ylm+/C7+8Y9/8Morr/Dhhx/SuFlLcgtL2LZt20WNcyY6dOqKN6suwXo9wpJ8+U1RHa4qskD/SWVlJd999x2hUIg777yT6OJWkWcOTzCO3MJSVq9eU6XNK6+8giMQT+nsneRdtQqLIONOzCFQ0Iy4xOTTdg1UVlby3nvvnXWn4JlYc999WGwCZouVO+6484Kuw9kYOnwkvpwGpHSbhezw8OKLL16Sfmv447kUCeojUVFRq6Kiou79j7+D1Wl/Of5qEtT/W1RUVJyzOnnFXXfhsAnEywodWrT4zUnqb7/9lsWLF3PzzTefc6vXgO7dmahqfOoP0riaCerGZWXcpIUrnWubLRTn5Jx2zLD+/WmjaizT7LgvQNbkqaeeon/v3ixbtoxXX32VVvXr06xOnTNWLt+7ciWSXs88JazT3F/VmD9/Ph1btECx2WjTuDFD+/enNDOTa+fNO2MQ/fzzz6NYLAQNBgSdnusXLao6xqpV+CWJQlnBZTCwWNXIUBRW/Id78jfffEOzOnVwyjL9unenZYMGLDslVyLqdDzgdHGNqqHo9axyOOmoagwfMOC0+Zw4cYL5V19Nn86dz7ptf9++fTz66KN8/fXXkf/btGkTDU7pVf/F5aYwNfWMbaNdLv7icrPXF0A1W/HV6YpgtODUG1F1OmSdDovegGh3M2/+fADK6jb8l6laVu1IIrFBURFjJIn5iorHZMag1xNwOnn55Zd54IEHaFBYSP/u3Vm/fj0eSUbQ6SgsLuOBBx6IBGHp2flkDrwp3HdmGbXq1EPzRCNpTuYtWIjP4WCJZucW1Y5Fr8em2JGMRuxmM4LBSFxiMiaLlbTe8zEKKnqzQN7oe0nvtxiDRSB76G04Y1JJz8hADKahM5opGL+evNH3YjRbcMVnkNp7Pkp8HmbFTWKnqRSU1MLp9iJ6EzFYRDKvWIo9ox5iMA05mIqsOZAlGUlvwKrToTOa8RS1wyQ5uOqq0Xh8QXwlYd1uye7i7bff5pq58xg9dhxvvvkmDrcXLbUWWmqtsC5ycWsmTprM999/z8iRozBYRLIG30zp7J1Y7H50BiPaKTOb5K4zEPzJxLcbi85owSjZ8eQ0wheI4a677qJZi1ZMnjw5XJVhtmGwCBRNfpjMQUuQVDvdevTA5fGRmp5Jm7btad66Hdu3b+eWW2/DE4zDZvdgTyoMB5n1e2PRfMTExuP1RyPZXdgkFbPmw5HZAKNNJjM3n2sXX4fFasMmq5glO6k9rglXC6fXJSpKh1FQSO1xNe7MurRt3xGzTcBolZADyciak8SUDOYtOF1P/dChQ1xzzVymz5gZqfS47777cCfn48ioh0l2kpiSXuW3cunSpTjT61A6eyeB+r3Izs0nLTuPNu3L+eijj5g1ew7DRozi7bff5vnnn0f2xoW3k165EoNFwGC0nPagOWjwUFxx6fiz6pCVm19lK+ahQ4dYsmQJihbWxo5p1I+4xOTTzuWVV17hgQce+E0VK/fccw/e9FJKZ20npvEA0rPzsAkS8UmpPProo7zwwgtnvG9s27YN2eEmulYHJNV+zoW/n3/+GbPFSsG4deSPW4vZYq3Wrpoa/jj+4AT1ny62rs7f7x1/v/fee9TKzSXG5WLZTTddljGOHDnC8IEDaVBY+LtV/yZ4vTzt8XIwEE2J08nTTz/9u4xbw5nZvXs3LlGkvcuFS1Z49913L6qfyspKauXl0VjTiLVYSPb5qiS0KioqePTRR9m4ceNll/cIhUIkBYNMUjWmqxo+h4Oh/fszefz4C0o8/Vk4fvw4ksXCE24vj7m9iBYLv/zyC81btcWTlIM7IYsOnbpUu7/t27cTyCgNm5kPuRWToFI89RFiG/enfXn1+zkXO3fu5KabbqJz27Y4bDZUm40HH3ggYp6Ynp6Oxx/EJink5BdVkXh499130ZxuAhklmG0i/qLWYe3hnIbExsVHPES8JR3o1KkzEE665xeVYrGJNGrSlA8++AAIPx+KiorFJtK+vPM5n5M7de0RMXEP5Dfhtttuu6BzDoVCbNq0idtvv73Ks1Z12q1du5ZhI0axdetWQqEQqt1Jet9ryRl+BzZR4ocffuDdd99F0sKFJnqzDYvmQ9Sc55Xd2LBhA0lpmZTUrnvG3dhLly4lplbHU9KHU2ndvvyCzvti+Omnn1iwYCExCUnEthgR1mgubsUdd9xRrfYffPABit1JsLQdqjtQRV/73/n8888RFY3UHlcT06gfJptEwbh1lM3ZhTOYWEU675dffqFewybIDg+Sop3TS+pXfjWPzxl5F3mj78ViFS6J1GlpnQak9pwb9qfJa3TBu5uOHTvGzTffzLhx41i1alWNfNefiEuRoP5HVFSU8wz/v7067S/HX02C+r+Tzz77LFK1eimJdbvZ6fLwiT9IgqLwzDPP8O6771JRUUEoFDqv4+7PP//Mvn37LjiZ8MEHH5Dg9yOazDSpXbtaumVLly5F0OmINRhIN5rIiIk57ZjSzEwecoa3BjZ3udi4ceN5+7377ruRDEamygq5ioJDFFmoatyo2fFoWiQQPnnyZCQB9NRTT+EUReo5XfgdDqZMnkwrVeVNn59WokiKxcpGp5sUSaJ927bceeedVYKaTi1bsfhUYreN3c7d/5F4hrB0RudOnRgjKxFd6qH/oY89avAQ+qka16oaNp0Oh9GIw2ikj03ApdfzqT/Icx4fok7HwUA0axxOGhQWnjbWtAkTqK9qLFY1PKJYLY2wY8eO4VRUbFE6hosSOVYrU8ePP+OxDz/0EKLJhEWnw5/VAFd6LQxmG5rdR65NxniqmnrgwIGR6/Too48iqQ58ybnEJ6VEHgpmz5yJXa+nltmMX29gny/AjZqdwowMPKLIaoeT3qqKajSyTLMzXFYwWwUCmbWQNScPP/wwzVu1wZVZn8TySUiqg7179/Lyyy9HPstmg4G9Xj+vef2YdTpmzJzJBx98wND+/dEEgZKsLK6ZOw+jyYTgSSCu9ZXojRb0RjNGi4CkqGguLwaLiFFyojOayLtqFTkjlmMwmalVtwGaJ4jBbEV2+pAUO0OGDCFQ3JqyObuIazkCg1XCYBHwBmKYO3cu77//Pvfddx/26FRKZm4j2KgfeqOZwYOHAuEFhK49etO73wA2btyIyx+NzeHHU9wOzenib3/7G6kZmbhzm1I6eyfBul25avRYnn32WRSHB7PiJrphPzIHLUFvtuEtLccsu8gctARXThP0Jit6kxU5LhdvWSfMigur6sAkasQ2H4pJsqNoDhLLJxGo1xOdwYjOaMZoNqN4oskafDP+opY0aNSEyVOmRlbzZdWOp6gN0U2uQG8W0BktWJxBDGYb0Q37nJJoqYvOaMZb0gFvWTmpGeHq8F+3q3bv0Qs1Oo3YFsMwWEWc2Y3QUmuFKyO6z0FQnaT1XkDGoJswWiWcCblo3mgWX3f9eT/nv37W69RvhFWUcfsCEfObUCjEQw89RPfu3TFaRQwWIXzONpmMATcQrFVOh05dq/R10003oTdZSGg3Fnd+S8RAKjZJZd++fVWOq6ysZOPGjaxateq0Kpqhw0eieWOwqF6cWY0ombkNvcF4QVXHu3bt4o477jjvfWXVqlV404rDCepG/ejRuy8A8xYsRLa7sfvjaNex02nJ8T79Bv7LvLFeD66++upzjnPdDTdiFUSsgsj1N16eZFoNl44/OEH9p4utq/NXE39fGgb36UMDVWWUouDVtBrD1T+YPl26sOhUPHuFql20idenn36KRxDCMoG+wDllAi83P//8MyaDgXd8AR51uhFMpvMaA/+Z+emnn7CZTLzs9fOi14fVZOLzzz/HYhMombmNkhlbMBhN1X6W+/zzz1EdLoL1euBOyiM1IxuDwUhSasY5K1irQ2VlJXfefjvxsky/U882T7i9bHa5SfD5gH+ZJ3o8HrZt23Za0njW7NkE6nQJJ4rr98bp8aPXGyirU5+p06bjTKtF/pg12BPzI5XX3Xv2wVPQAsFspa7Vhma1RoqUjh07Vi0T2JdeegnF7sQZTCAhOZVPP/2UkVeOplmrtpe0evg/uffe1Wj+OGJbDENxeHj88cfZvXs3bl8A1e6sUhU8bvwEDGYbeaNXk9RpCmZBqWIK+J989tlniLJGRv/riGsxlMzcgtOOef7555HtLuJajcQZm871N/x+MdykKdPwpJeS3HUGist3QQuW7777LsuWLeOxxx4753Hbt28nv7iMpi1bU1qrLoHi1sS1GIrqcFX5Xdi2bRuexCxKZ20npdssCkrP7wV18uRJzBYreaPvpWDcOixW4ZLswFix4h5Ul59gQROcHt8Z5XzORet2HVFj0jBYRJS4XJxu7++uv13DmbnoBHVUVJTx1L9KVFSU4VzH/t5/NQHyfxeHDh2ieaNGSEYjmtXKnOnTL2n/+ampLFY1drs92K1WNFEkKEnkZ2SQGAgHiF3atDljtcInn3xCnNdHvKKQ4PdXO4H+1ltvMWvmTFatWsX3339f7QD06NGjJMfEUEtViZUkbrr+9OTSDYsWkSDLdNXs+B2O8674vf/++4hmM52sNg4GornX4UTR6XnfH+SjUzp33333HdMmTMBsMOBWFEpzc2lSqxaPPvooO3bs4JtvvmH61KkMOWUWMUySaWS2cDAQTQ9BpIHFQqGiMnvatMi4Q/r1Y6CqscfjI1dVz5pIf+6553AJIqMUlYAk8cgjj1R5vWd5OfMUjWSjkU1ONx/7gwRNJgb070/tggKyNA2/KOIQBNqe2oK7auVKXnjhBTLj44lxubhvzRqalJayxuHkNa+fbEFg4MCB561QmTlzJtYoHR2sNjSdDl1UFBUVFbz77rvUrteQ1MycKud1+PBhrhg8lNjEFLp074kkytic0cgxWQiSQvfu3YmKiqJdu3aRZPT777/P7t27OXr0aKSf5nXqcI/dyQaniwSjkQ/9QWbICn6Xi3qOsCzKRqcbu8HAAX+QuYqKllwc2cZlFlVMNgkpOhOzpDF16tTTzq15w0YYjCZ0eiM21YvFJrJlyxZSFYU9Hh/DZIVOLVvyww8/kJ6VgyM2Hb1FJKHDRNL6LMRoldFSykjrNQ+T5MCseojS6dEbLfiCMVRUVPDGG2+wf/9+XnjhBT777DPuvfdeHNGp5IxYji+3MQMGDeaTTz6psrVz+/btuGJTKZ6+mfhWI6lTv9Fpc//hhx8QRPlUMrcTFp0eo9GM1Wxh8+bNuL0+zDaRYEwc+/fv59ZbbyW6tC25V63EovkwWASs7nCFr7ugFQarRFZuPs888wwWQSJ/7NpTJo8xROkNRDceSNmcXcQ2H4rebMOZ3YisIbdg1rzozLawcWJKSbiyovNULLKTYIM+SKqdLVu2YLQIeIraoTdZsXniEXxJ+Gt3Cbt+F7ahZMYW5LgcpOh0DBYBvclSRZYDwpVV/uhYrM5o1OQSzJoXg8mCkpAfXiSw2EjuOpOiyQ9jFFRyht9B1uCbSUhJP+36VVZWMuqqMdhdHuo1ahKpYgmFQnz99ddVvhdLl96MPZBAoE53dCYrgQZ9CDbogxhMo2zOrrBZZkFx5PgvvvgCiyCR2GEiUmwWRptM4aSH8KcXs3Xr1nN+337lxIkTGAxGiqZuomTGFvQmC67EHFq2Prt2/n9y401LsftiCRa1wOnxnfPB69ixYzRq2gKjyURMfGLk4VOQZPLHrKFk5lZkuztSbfQry26+BWdcBkmdp6J5Y6qYzpyN77///r86CfB78sQTTxATn4T//9g77ygpqu1tV+dQ1V3VOU7OOc+Qc845g+QgOWcQERUxoAKiyFVBDGBAkWAOKJgAc0SCIHgFJEiQMP18f8zYP+cywJDUe7951uq1YLrOqdPV1d27du39vsEonn/++b98/39HgvqfHFtX5FEZf18bTp8+zT333MOkCRP47rvv/u7l/H/PrOnTqS0rPGF3kmS1nhenVpRTp07htdmYISsMkxWyk5Ku8UovjyZ16mDTaIjRahE1Gl555ZW/dT1Xy+yZMzFoNBg0GmZMncrZs2dxuL1EN72RqEYD8fojLuuGwFdffcWEiZN44IEHwkVNf7B82TJq5uTQu0uXy6o4X7VyJRajEVmtZqmtRNu+mdHEFIuVxTY7qdHR4W3/bJ74n9WhS5YswRmbQXr/+3EnF3LLnFvDsdvx48dp2aY9NqebTl27h2/sN27WEltsLiOlkqKgCRYrI4cOrfDa/+DXX39l69atnDp1im49bsCbVZe4thOwKI7rppnfo1efsEdKsGZXZsyYccFtt27dimT3UDDlxRLjdLOV0WPGXXD7Tz75BMUTUeIlc+MS7E53udutW7eOXn36sWDBwgp1Yy9f/jiNm7di2oyZV9UR8fvvvzNuwiTqNmzKY49dfw+EQ4cOMWTocDp16X6e8fjbb7+NzRdFzpgniGrYn9r1GpZ5/kKfr0WLHsBgNGMwmpk7785rttaNGzeydOnSK5L4MxhN2JKrE9NydMmNnrwmF9Vfr+Sv42oS1K8KgiBdbJu/61EZIP93UaugAK0gsNXj4zOPD7NOd820zQA+/fRTshMTCTqcZCYkcGephEZQr2eiVWaHL0ChYuOpp546b+y40aMZVJqU7WuVmVqB5Pm2bdswazQMFiWS9QYmj7vwj+IfbNy4keXLl3PgwAEOHz7Mk08+Wa5xxJkzZ2jZoAEmrRa7KFYomHzppZfIlRXsajXjLFYSdDry09NJlxWyFYW2TZvyySef4JckPvf6WWyzE6HRcI9iw2m1hivMf/zxR6I8XuJkGa+iYDOZqCsrSGo1m9xennY4qZ6VFd7vL7/8Qr0qVZANBtKjoy9693bTpk3Mnj37vG3OnDnDsGHD0KvVyCoVd8g23nN7sahUbN26lbNnz/Lmm2+ydetWfv75Z5YtWxbWh4z1+Vmg2FnrdCObTNwyaxaxFgtOtZrWJhNVrFZ6deoElFS7t2jdjvqNmpaRPOnRowfNSxP7D9sc2DQadu7cicPhRIlMI67tBMySzG233cbDDz9cphr/iSeeoIHNzgLFTkeTmWpZ2YRCIe6//360Wi1xcXEX1K0dM2wYjWSFRYoNRavFqNFgUampKyuIag31bXaCkkRcMEgNm50oUcQkO0nuORd7Wu2SBGi1jhTN2EB08+F06d4zHDRs3LgRly+IWm/CEpWJI60OepsXnc7AY489Rp6s4DeYMehNiJLMwYMHOXnyJAsWLECU7XirdSgxCNSbURKroCqtOE7oOB21zojKINK2fYfzXtNrr72GaJFRqTWotHrUehNLljx83nbFxcV07tYDtUaL2aKg1eqIiU8qU33bq3df9LILS2Q6BsWLWmdEJ9rQmmW0RhFvWnVcCXlhncBvv/0Wi2InWNQSye5Gozei1htR4gvQSTZ0RlM4SduidTs8aTXwVy/RfNNKdjRGC8G6N6AVFURvAo70OmhNVtR6E/Edp5E77unSquV0tEYz/prdKJqxgYj8xvTs2ZNgfmMi6vfDU9AKsyeWtP73UTRjA1JkOhqDGUFQYXRGUjDlRaKaDKFx0+YAPPfcc7Rv34EOHTvx7LPPolKrKZy2lsLp61HrjHj9Eaj1JozOCLQmC6JFRqPVoTdJJHSchr+gBc1btT3vGD/77LM4IhPJGv4o/qJW9Ozdt9zzEKBWvUYkdJ5J0YwNaAxmMm9cEpbtUOsM6M2WMm2Dvfv0RWMQyZ+8msyhD6PW6glk18Xrj+CNN95g48aNlzTVCYVCONxeYluPJb7DVEyihTvvvJMWrdtRtWadS1aCAGTkFJDcc25J0JlejVWrVl1yzPHjx8sE1xExccS0HE1KrzswS9bzqhiLi4u5/Y55NG3ZhocqIOFUScUpLi7GqthI6jqblBvmYZYsnDhx4i9dw9+UoP7HxtYVeVTG35X8L3L69GnGDhtGzZwc5t1221VVPX/22Wd0adWKGzp35scff7yiOYqLi69J5fWjjz5KLcnCXn+QBYqd+lXONxq+Vpw5c4Z///vfF53/888/58MPP7xiKcYW9evT2Cpzg1Umxufns88+48MPP6RBk2Y0ataiwpKIl2Lr1q14RYnH7A46Kwq9Onaq0LhQKIRiNrPO6aa3WSRfr+cexYZDb8Cg1RJ0uXjvvffKjDl06BB169ZFEAQmTZoUPjbnzp1jxKgxxCWl0rvfgEt2AwN88MEHGM0iqTo9zzlcVLHKV52QS8nIIeWGO0vMtVMKmTVrVoU6VC+XJ554AtkVIFinF5JycdmjUChEZk4eWpMFjVHCmdmAjl26X3D7c+fOUbNOPZyRCVjs7gp3Hl6MN998E6vTS1y7ibgTcpk4aQp33HEHt9566391kUIoFGLk6DEYzSIJyWl88803hEIhdu7cSVJqBhqNlnYdO5er9378+PFrmt+5WqrVrIPki0dJrELKDXdi80VXqNCkkuvP1SSo5wmC8KkgCP4//a2WIAgbLzbur3hUBsh/PwcPHqyQvlBxcTEqQcCiUvGC08U6pxtRr79u2pydWrZkpKzwqceHW6djZqmJYXWbjccff/y87WfNnEkrWeFLr5+mckki8lK0aNaMOgZDuMo1obRd60IsvP9+IiQLTe0Oor1eDh06dMFtV61aRaHNxk5fgJtlhZYNGpS73ZkzZ8LtTIcOHSLoclHXYsWp19O2dWvOnTvHunXrWLNmDWfPnuXjjz8m2mLle6+fFXYnCVotO30BrAZDGY2wkydP8uWXX3LixAm++eYb7rvvPmxmM+MsVvL+o4IaYEDPnjQpldVwimKFK4G++OILlixZQrMGDcjUG6hjEjEbJUSVCkmlwiGKhEIhfvjhB15//fVyzzWbKLLR7WW7L4DLZCIuEECrVhPQ6djrD7LV48MmigDEJiYTUfcGYpqPQLE7w4mQd955B7k0WZ+v11O1oACTWo1NpSZBq0U0y+hMFtwpVfAk5dOwSfPw/t9++22iLBZedLroJSv07NAx/Ny7776Lz+fDZDKVazBy6tQpxo0YQdNatVjx+OM0qFKFxaWGks0VGwMGDGDTpk2cPHmSp556irVr15ZUc3oCmL3xxLYag1ZUiGoyBIs7EoNOj00UeeCBBzCaJQw2PxqDSKBWD4J1b0CtN9K5SzdOnjyJz+PFU9iawunr8WQ3ZHapXjbAnXfehUZnIH3gIuLaTUKtM+DOa46SWAVbUlWMjiD+Wt2xOV3nXYRExiYgx+djckVhdEQgBpIxiZYLXqysX78emy+a3HEriWo4gPzCKtx+++288cYbiBaZ7JHLKZy+Do1ZRlCryRu/isxhS1HrjBROX0/B1DUIKhVVa9bhnXfeYfz4CdSsXYeHHnqIw4cPU69hY4xmiUBEJGmxsRSkpvLOO+9w4sQJbr55Nl5/EL3ioXD6epzZjUrkWhwunCnVSyqptXpUelOJyWX/+5CdfubOnUv/AQPQW+zorU4MZpFnnnkGSbHjzGqETrIjxxdgicwgWPcGNEYRlUZHoHYvjHY/8e0mYXRGUFS1Go8tW4aoONBJJRrMkt1DdFwCvrzG+ItaEROXiMMbJL7dJAqnr8cSmc748eN55513WLp0KVVr1qVbjxvKbQ1fsmQJvoxaFM3YQEyLkTRp3uqCn8XpM2/CGZtBVJMhGMwWRMWB0erAndOYnDFP4IhO47HH/q+10myxYk+vg06yo9YZ6NqtO0uWLGH4yFHITh/2QCzNW7W54Pt++vRpBgwaQkRMHJ5AJBk5+bz11lsUVK1BsGZn4ttPRpJtl+wc6dWnH96MWsS1nYCkOMKSJZfDli1bSMnIJio2oUIJ7kquHWfPnkWr05M79inyJz6HwSxe9LfxevA3Jaj/sbF1RR6V8Xcl/79w+vRp5s+fz5RJk87rrrmeTBozBp1Gg9/h4P3337+quUaNHIlfo+Etl4feooioUhEXCFy1hMV/8uWXXxJwOpGNRuoUFZUreXjT1Kn4JIkYq5Vu7dpdUaLcrNfzldfPXn8Qp0aD1eHBF4i84I2AM2fOsG7dOjZu3HhZ+3vmmWeo5yipfn7S4aRKevqlB1GS3LMYjbzl8vCR24uo0dC6YcNLdgidOXOGQYMGhc0T/9xxebkcOnSIgX36UJCSwviRIy/LOLI8bp97BzZvFP6ceujNFpxRSVjtbu64RJXs/v37adqiNamZOTzyyKMV2tfzzz/PuPETeP311y+57d69e3G6fbiikrEodj744IOLbn/mzBneeuutSxpeV5T58+cTLGoR1qy2uf14M2rhy25ASkbWVfth/RM4d+4ca9euxarYUGt1yHF55E9ajSs247wu0H8iv/76KyNGjiIxNZ2ElHRmz7n1b5NcqqQsV6VBLQjCYEEQdgqC0KW06uNnQRDGXmrc9X5UBsh/H88++yw5ySkYNVqsRiPPPvvsJcfUKSqiyGzGolJhUquv65farl27yEtJQTQY6NS2LX6HA4vBQMMaNcq9+3zs2DGa1K6NaDDQon79CiXde3btikWlYppVJl+vp3aVKkBJZfX4sWN56KGH+O233xg2YCD1i4qI9XrDmtJ1HM6LBirPPPMMeYrCDl+AmbJC60aNzttm48aNOCwWzDodvTp1ori4mH379rFw4cKwscR/EgqF6NutGxaDAbNWS6RZJEex0aphw0t+WX/00UeMHj6cRYsWnVcZmZuUxPMOF3v9Qeo7XaxevfqSx2/z5s04RJFODicmlYon7U72+AIoOiNmtRaX0cjYUaN44YUXcJhF8ux2UmJiypiHAMy/6y4cZjNBSSLa7aavKDLDYsUoCIyRLAS1WpwWC6+99hoajZb8ic9ROG0tomxn9erV9O7bn5tn38LKlStp27gJM6dOJSkigmccLnb4AsRqtFhUajQGE4XT15Vo5Ko1Zdq47rrjDtKio2nXpAkHDhwos779+/dTs2ZNBEFg5MiRZcb99NNPDB02gqHDRvDTTz8xYtAgWsoKj9ud+EWRMWPGlKki3bZtGy+99BJjx49HrdWj1hkwmCXatOuAQavlDaebtU43Jr0e2RuNkliESqMtqcadthaNzhC+oz9m3Dhc6bXIGv4I7rTqZRLUP/zwA5LiIH/yahK7zUYn2iiasYG88atQaXSo9SYyhz+CRqs7TytYZ5IQ1GryJz1fcqz0ZswXSFC/9dZbpGXlYpJdZI94jGCdkiS6r6gNFrubyNgEIur0JL79FASNDpVGR2Lnm0jqOhu1zkCwTi+8pRrSsa3HljhSJ+YRrN0Do1lCq9Pj8QXYvHkzLllmoc3OYpsdu8USfh++/vprDGaJxM43EazRmSo1alOtZm0Mkg2VVo+/Rlf8tXugMYr4glHEJaYgqNRoDGYcGfVI7TcfyeZm4KDBZOQWEBkTi0qrL5HmMFlR680YRQs6vYHMG5cQ0aA/ar0ZkysKndlKfFIKclwewXql8iIN+tOv/0AmT5nKuPET2LdvH02at8JbpS2ZQx/GZPNitiiYZCdmSb6gESiUBGVxick4g3FYFDvvvvvuBbc9d+4cc+feQURMPEazSHZePjn5hUQ1HFBSMZNdj/vuuy+8fVpWLsE6PYlsNAizRQ4nFQ1GEzljnqBg6hokxcHOnTvL3d/tt8/FnZhPWr97ccakh81lbU43WcP+ReH09TgCMRc1JISSSo1hI0dTtUYt2rVvz4MPPnjJyu0/8/PPP5OYmo5Wpycnv+ii+oWVXB+mTJuBpDiw2t0MGnL5bchXy9+lQf1Pja0r8qiMvyu51mzatIl6RUU0rV37uskHXAl/6IQPssp4bba/pCpy27ZtBCULn3t93K/YyUs+X8Lrcoh0uehmMhPQaFBUKpbbHYz5j4KKa0HnVq2YXmoaX8dm49FHz09ImnQ6tnp8bPcFcJhMV1Rd3qhmTdrIMoMkC2adkYLJLxCo2o6x48YDJUU2DzzwAPfff3+JvGSNGuTYbMRYrEwYNarC+zl06BDRPh8NHQ78ksSSBx+s8Nh/PfwwksGAqNdz8/TpFR4XCoW47777UKvVZGVl/aO0cjds2MCkSZNQvJEUTl9HxuDFuLyBi45p3KwFgWrtSO55OxabM2zwXh5nzpzh3nvvZfyEieUaGF6Io0eP8vbbb7N///4Kj7lWfP311xhFC+7sRphlB4KgCndAmkTrRQ0iDx8+fE1MBK8FCxctwu0PkpaVW6YDYeHCRegNRtQ6A8k955I9cjkag5nsUcvxphSx9C8yFK7kf5OrTVBnlVZ6FJe6jZsuNeaveFQGyH8Pa9aswW82M9MqE6nRME6yEuUuX8fpzxw5coRZN93ElIkTL1vg/mo5e/YsBw4cuKZ3zHbt2oXP4cCq1eJ3ONi/fz87duzAIUmMsljJlWWqZmfTXFH4l92BQ6ejnijxsM2BWxR59913eeedd8qtfDx79iztmzdHr9EQ6fGU265WJSODRTY73/sCJMoyb731VoXXfuDAAY4fP86GDRvC1dVXwy033USKVaa7YsNru3TVI8Do4cOZYPk/fbRMnY5pVhlRpaK9WeRFp4sYi5WsxCQeLtVvq2t3nCfR8uGHHzJz5kyeeeYZ0uLjMRrM+BMK0eoM2PR6CvV6JlmsmNVqmrdqg8XpR3T4SEnPQJJtRDYcgCe5iL4DBoXnzE9NZZ5sY7Pbi02txiXLuL0BIuvdQLBGZ+KTUit8bF5++WUeeOABBgwYgCAI1KxZk/3795c4qycmE6jalkDVtsQlJvPbb78xuE8fsuIT0OpNOFJrYnH6mD//Ph584AF8kkQVux2zWk3G4MXkjV+FwSzxzjvvoDOYSBOtFOj06AQBi06HxmRFa5YRA8nYYrOoVrNO+DMwdMAALBoNerUGlUaL3mjigQcWs3nzZuo1aorscKM1SuiMIibJirdKe2xJ1dBJdlR6Mxanl4FDbgy/zlAoxO7du9Hp9Kh1RqKa3khcm/GotHqWLy/btfDhhx8Sn5yGRmcgrs14fKVyIoJag69qhxLJkmbDadmmHY2btUBUnLgLW+Ov3QO1wYzGKBLdfDjW2Dw0RpGYVqMpnLYWrVEkfeBCimZsQPQnEt9uEnFtJ5CUmoFeo+Fbr5/vvX7MOl2ZGx2rV68mO78KTVu25oknnsAVlUzhtLUkdr4JMZBEYpdZ6ESZMWPGIPkTcOc2Q4pIRaUzIgVTsUWlYnEFSOwyC4PiRSsqFE5fT+64lajUWubMmcPDS5diMJpRqdXoJDueojak9r4Lg6RgtNrRSXYiGvRDsnvO073cvn07ouwoMS7UGQjW7Y07vyUmdzRF1Wpd9Pz75ptvuOuuu86rLP7999+57777mHnTTezZsweAO++8E3dKFSLq9y3R77ba0RnN2H1RxMQnlqls3bFjB42btaCoeq0yVS7BqBhiWowkqdstiBb5gpqNAwYNIaJenxJpjuodmTJ1KlBiEmP3R+NNzictK6dCZok//vhjiYN5zS44Y9IZU3qRWhFGjRmLv6glhdPX4c2sU6HumUquPd9++y1ffvnl31LV8jcmqP+RsXVFHpXxdyXXkpMnT+K0Wpmv2LhJVogPBv/uJYWJdrt5x+1hrz9IvsNRrizfteb9998n1mpluy/AcruT9JiYq5ovJykp7NEjqVRsdHmYICt0b9/+Gq24hG7t2jFGLimuqaqU37Ea5fFwr2LjaYcTxWS6opvCR48eZea0adSsWhWrOwp/bA6KL46bbpoFQONatainKDRVFHKSk/GaRXb7Amzx+LAYjZe1r4MHD/LUU09dsjK3PH777Tf27NlTYe3qM2fO8OOPP3LmzBk2bNgQNk/ctGnTZe/7erF7925Eq0Jyz9uJrN+XrLyCi26fkJIelgaxBhKx2ux07dGr3Niu/8DBuBJyCNTojOJwXdBT5OWXX6Zv/4E88MDiv70S9pFHHkH2ROLMbIDk9BEIRuIvbEGgWnsiY+IuWDAxbsJEDCYzRrPEihXXrmDvnnvuxR8RTWHVmhcsEPlPvvvuO0TZTvrAhUQ3GUJmqd/M0aNHMZhEsoY/gtZkIX3gIvImPINGb8JsVcjJL7omCfaXXnqJzt16MG/eXZdVYFLJfz9XI/HxvCAIhwVBmCEIQmtBEH4SBKH5xcb8VY/KAPnvYfzYseHE4gyrTGODkfjAxe+g/q+yb98+2jZtSvWsLJ588kmWLVtGnMFIglZLc6MRnyiGzTFa2e3UrFKFeoVF3Dt/Pl6bjXyHA49EIAb7AAEAAElEQVSiXPBO8YkTJ8I/vmfOnGH37t3hys+qWVncp9j51usn3mrljTfeYOLo0VTNyGDG5MnXrK3oo48+YlDv3tw8c+YFJVlCoRDPPfccd911V4Xv9i9ZsoQsq8yjdgeZFis1q1ShfrXqZMTG8kCpzEUzu4Oi3Fz6yQrrnW6iLZYyemSvvvoqblGkp82OQxTJyM4jtvW4ElO8rAZYVCrWON0lFxZ6PW3atsXqjcJXpR1avRGraCVr6FLS+t1LQmpGeN41a9YgGwwYVCrys7LYu3cv3377LV2696Rn774VrviYO2cOcVYrre0OojxeHnroIUwmEz6fj1dffRWdwUjh9HUUTl+HzmDkk08+YcWKFRhMItborBJzuh63kZqZS0ZsbLhKPVmnI7LRIDKHPozRLJKenYfoT8TojCBPp+dzr49OkoTTYqFmzZrMnTuXpUuXcvLkSbZu3crNN9+MqNOxxeNFp9GSPeIxsob9C53egEWxE9NyFN5qHTDaA8juIA8++CDJqekYJQVHdAqZOXm899574XOzuLiYlm3aIcolCU29yYJelHF4AuVezPmCkQTr9EKv+Mgdv4qs4Y+g1uqxp9fBoHiIbTUGkzOC+xcs4MyZMxRWq0GwTi9yRq/ArNVjNZjRiTbUeiNqrR5bIAZXbDo2hxuD7EIKpiBodEQ1uZHIxoOJjk9icJ8+REoSkaJEx1atuH3OHJrVrs3cOXPCn5WzZ8+yefNmFHeQ7JHLiWw4AI1RQq0zkF9YxJAhQ9AYLUQ2GojRGYHZn4Q1JhuzZMFfu3tJsrVGF1RaPREN++POa47ebAlrt2XlFuBOLUnyJ3WfQ9GMDXiT8hgxYgSNGjehRavWZTorQqEQe/fuZfXq1bjjMsi4cQl6q5PC6evD1eyt2124Auq9997DItvxpxZhc7rLtPO279QFd1IB/qJWeP0RHD9+nGnTpuMvao3O4iRj0AMUTH0J2enjmWeeqZDuIZRUfmXnFZKQkn5Bp/dQKES3Hr3QGMyYFDcWxR7+DiwuLmb27Nn069evwu3Hzz33HIH06hTN2EBqn7tJyTjfmf1CjBg1mkCVNhROX483qz633nprhcdW8r/B3yTx8Y+NrSvyqIy/K7mW7N27F7vJxC5fgG+8Jabm16M1/uTJk5ctLdizQ0cayjKjLFbcsnxel9wfrF27luGDB1+T7tDi4mJ6dOiAYjSWaBlfpFMKSmLhekVFdGjePHzD+c98+umn5CQlEXQ6SY2NRdTpiPJ6r7kx5w8//EBSZBQatZp2TZuWaxj34YcfkpuUTEpk5FXrwC5dupQovZ4Fip1YvZ4HHniA06dPo1Gr2eUL8KMvgGwwYDWZWGJzMENWSI+Lu6p9Qok831NPPcULL7xw0fN0yYMPIhkMSHo9sy9i9gcl15ORMXFINieRMXHs27ePr7/+mri4OPR6PcuXL7+qNb/11lsMuXEYS5Ysueqk7lNPPUVCSjrVatbh+++/v+B2+/btw+Z0oTVKiL54dGaZ9MGLcSfmce+99563fWRMPBmDHijp2kvKLdeH5P3330dSHEQ2GoQjIpF5d959Va/lahk6fAQR9fuWmDrWvYGBgwYzcvQYhg4bwd69e8sdM/uWOWiNInJcHkndbkG2Oa7JWrZt24bV7iZ9wAIi6vSkZt36FRr3/vvvY/dHUzhtLWn97sUfWXJD7PDhwxhMIjmjVxDZcAAqjQ6DSaRr957s3LnzmnxHb968GYvNSXSz4ThjM5h18+xLD6rkf4arSVDPFQTB/qf/Z5S2JA692Li/4lEZIP89vPzyy/hEkfEWKza1GovRyGuvvfZ3L+tvoUPz5twgKzxmL6mK7n3DDVTVG3jF5SZLpyczLQ2fJNHK4cBnt4fdZyeOG8eN1pIk/0irzJgRI8Jzbtq0iaL0dApSU+narh1eRaFGbi4xfj9eUSTK42HEiBHceuutuGQZvUbDwBtu4J677qKKLLPS4SRblsMJyT8bTj2xYgWt6tdn6oQJFapM3LNnDw5JYqpVpoEs079Hj0tu/+qrr1aoBbK4uJjbZs+mYdWq3DZ7dviHbt68eSgaDV6dDpeicPPNN1O3alWSgkHmzplTZo7Bffows9TccqTFSkFhEfaEfJK63YLiicCnKGTqdAwRJUxqNRk5Jc8VzdiAO7GIZkYjosGEIyqFceMnAiVSB05RpK8o0tVsRlKrmTt3brl3iY8fP84nn3xyQZ24zLg4XnCWJJVrOBy89NJLfPrpp8TFxaHT6QhGRuHJqI03sw6JyWk4JIlEUcLsS0BrshDXbiJKQiEag5naBQUMkmWedjhxGI2IFhmTWeLBhx5CZ5LwFLXBGptLq1Kzx3GSFZNGi6TTkx4Xx6lTp3j//fdxiCI9ZAW9oOJZhwudRktq3/mYvfEIKjV6USZ/yhpyxzyJSqNDJ9kZOHAgoVCIl19+meeff/68c+fdd9/F7o+hYOoakrrdQlRMPFu2bLlgEKw3mvBWaY9Zo0WvUmHWaFHrDMjx+bhymqAV7RRVqcovv/yCPyKypHJYo0OjNxLl9dHfLDLJYsWjVhOfkMj69eu54447sNhdJHSchj2xEEmro0BvwK5WM6BvX+6Ydyd6k4jWIKI1mNFodYyRrGTLMjfffDOSUtKapzg9DBs+ErNkIT45jRUrVvDCCy+wY8cObr75Ztx5zYluNhyTKwq1QUSJSGbixImIVgWzI4Baqw8bK5q98QRrdSMyJo4DBw5gNEsUTl9HbJvxqPUmPPFZxCUml2smcu7cOVq0blsi5yFKmGU7Kb3uQGdxoCRWQfQn4vD4L+po3a3HDUQ1HlySOC9qzZw5cwiFQoweOw6VWoPB5iNj8GKcEfFs3bqVPXv24AtEoDNZiG4+nPT+92MwS9x2221lzCuvlueeew5HRAKZQx7Cm9uErt17hp+bOetm7P4YArkN8fiCFfou2blzZ4k5Zt0bcMXnMGzEqAqvZd++fcQmJKE3msnIyq1wpVMl/zv8TQnqvyy2FgShiSAI3wqCsF0QhEnlPN9bEIQDgiB8Uvrof6k5K+PvSq4loVCIpnXqkGezkSrLDOjV65rv4+477sCk0yEaDDxyGW3pp06dYs7s2YwcOvSC5nuvvvoqPlFkmlUm1mJh2Z/8Gq6G/fv3X7JC8d///jd2UWSRzc4wWaHmJT6boVCIw4cPX9dKxfIS09eDcaNHM760YGqKRWbEkCEApMfFMUiWGSUrRHt9rF+/nqqZmTSqUeOypCPKo7i4mKJqNfEk5OCMTCrXfHrHjh18/fXXiAYD77g9bPP4sBgM5XbM/sHESZPxF7UqjddaMWnyFKCkgrtOnToIgsDkKyw+2rJlC5JsJ6J+P+zBBObecXHd6D9e543DRuANRtGidbvz5BUrwuQpU/EXtSJ94EKMNh++6iWm7v6q7ZgyZep529/Qtz/upAKCtbsj253lduPec889RFRpXaL53G4iTVq0vux1XUvefPNNJMVBsEorJNl+yQ6LrVu3YrG5SO1zN96q7bFEZWJ3ea7JWl555RVcMakUTl9Pcs+5JP6p8OpinDt3jjoNGmHzRiJabTz88P99P86ecysGoxmDSaRb956YRAtWp5dmLVpfkwT1ggULCBY2p2jGBuI7TKF+4+aXHlTJ/wxXJfFx3gBBCAiC8MnljrvWj8oA+e9jw4YNTBg3jhdeeOFvb6/5q3nxxRfp0ro1s2fOJCsujudKq1qr2R00b9yYCaUJ00GShSmTJrF582YeffTRMomkqVOmUMti5R23h3pWmWp5eZj1enKSk7FbLCy02RkiSkRptGxye+ktSqSUmv51N4sU6vUkWK0suv/+cDXIsIEDmVQaqI2wWGnWuDFmnQ6jVstN06axceNG/JLEQpud2orClPElbfD//ve/Lxg0rV+/nprOEt3sDS43aVFRFzwu7733Hg5JoqrDSdDluuCd44vx+++/47RauUexMVtWMKtUtLPZcVosbNiwgTpFRaTHxLCitG1wwvjxePV6ephF4iUJXzAS0RONQXaRmpHFzz//TIO6dcnLzGTDhg2MGz8RV3wOUU2GIOpNrHO6UatULFmyJPxDu2PHDkwqFXt8AXb7AqgFgTxRpE5RUZlzfdeuXUS43SQpCgGns9xqz65t29FBVuhkltCbJFq0bsvRo0c5fPgwzZs3RxAEcnNzmTVrFm1atOBGUaK3RSZQqztas4w1OgtPQasSd2qzGa8kkej389ijjxIKhQiFQhQXFyOoVBRMeZGcsU9hUqlxqtWIRpG0/vdj0ptIMppYt24dU6dOZWTpOdLRZMKqN2CzWlHrjbjzWpA38VkswWQs7igM9gC25Or4qnVEbzDSsnVbmrZsTXpWDjq9gcbNWobPvS1btiA7feSOfYrYVmPIzMnnkUceYfLEiXzyySfnHZfcgiL0iocGJjM/+gIMslhJTUhArTMgRaSi0Rno0q0HzZu3QC/ZiW0zjqzhj6IxmElISkZSq1EJAla9CbPsYO3atSxbtoxAdh2KZmwgULsn6QYje/1BXnC6SIuORqvTE9l4MFrRhr9GF2LbTiRZtDLVKmNTbIj+JDKGPIgtsQrNm7cIr/X2O+ZhNEvoDGaiYuNQafXoLA6Se9yKLakabl+AvXv3MmDgIFxpNckZ9ThydCZqtZqcMU+SP2k1KrWatWvXEoiMxplZD5M7ClG2sXLlSn777Te+/vprJkycxMKFC8NyO2+88QZWV5CkHrcS32Ea/ogonN4ABqsLf40uyJEpjJ8w8aKfp2nTZ+BJrUpav3txRCXz+OOPs2nTJhRPkNyxTxHVdChGRxC7yxO++Dhx4gSrVq0iEBWLxmBGYxAxe+MQrbarNhD84yZHz5498WfVDZs3Nv3TBUZsYgpp/e4traDJY/369RWa++OPP2bIjcO46+67L/viuLi4mMOHD1/Wb9mmTZvYsGHDX3YhXsn14++S+PjPx/WIrQVB0AiC8IMgCLGCIOhLJUVS/2Ob3oIgLLiceSvj70quNWfOnOHFF1/k5ZdfvubXFUeOHEHSG/jQ4+VttwfRYLgmCdrly5ZRKzeXrLS0cGx1q6zQr3v3a7DqirF161biZZk9vgDvub14ZOWK5vnqq6/o3aULQ/r2q5BM3z+BjRs34hRFetvsuESRN954AyipyB/cpw/9e/a85kaQO3fuRLI5KZy+jrwJz6LWaNm1a1f4+ZtvmYNotSEpTkxaLRtcbja5vUgGw0VvgN900yy8WfUomLoGb1a9sFwJlHw2Bg4ciCAItG3b9rLNExcsWIAvuwGiPxFBrcbli7hkkdLjjz+OMzqVzBuX4M2qd0X+ELNvuQVvRm0KJr+AM7kKJsmKOyYVp8fHjh07ztv+9OnT3DFvHsNGjLygVvW2bduQZBuBWt1RfFEseuCBy17Xteajjz5i/vz5l/RMgZIOXW9CdkkSucdtaE0Sa9asqdB+zpw5w4IFC5gyZWq5hq2///47uQVFOCLiEWUbjz++osKv4dy5c3z88cflyoIcOXKE3377jUBULKl97qZg6kvYvJF89NFHFZ7/Qnz55ZdYZDuBau1RPBE8sHjxVc9ZyX8P1zRBXTKfYLmScdfyURkgX3/OnTvH+++/f9V3nP9g586drFq1qtwfpgtRXFzM0qVLmTRhQrnJrivh4MGDfPLJJ+Ef6BdeeAGf3Y5HUVi1cuUFx3344Yd4RJE7FRs1ZIWm9esTtFio63CQGBnJe++9h9NiobrTiVuWy22fm3fbbdhNJhStDrvRSN0aNciQZT73+hgpK4hqNd96/dxuVaiu17PHF+BuxUaURsMPvgDNjSbGW6wsstlp3aBBeN6S6liJ5k4XdlHEoNGQqdMRq9FiUqno27cvne0lciOLbXZa1K3L9IkTsRoMWA0GFpYaoG3atIkOzZoxqHdvvv76azyKwgCrTL4sM3bYsAsem27t2jFHVtjrD9JVUbjrrrsu+3355ZdfsOj17PQF+M7rRyMI7PQF6GEW8TqdTJYVnnG4cJjNvPbaazhKK/mTDQYa1KmD1e6mcPp68ietRqPVnTf/mTNnuPW22/H5AqSJEvmKQseWLcPPh0IhauTlYVWpaG000dhgxKpS8anHi0GjKTHJS0pl06ZNTJk0iQGlNyNutMqMHTnyvP0dOXKE1s2aYZBsJPe4DV9OA3r3GwCUnNezZs1CpVJh0Ovx6/WIKhX9zCJanQGNUSKh0wyyRy1HozfR1WTmcbsTh9l8XsCdX1QVS1QGtuRqGJ2RqHV64ttPJn3AAgxaPQ6djsjYeKpWr0msZOE+xU6mVeaBRYsA6NC5G5H1+5bIHGTUomPHjmj1RiIbDcZoD5RqRJvxVe+MxmAma+QyPClVyrToTZg0BZ3egD8iiiEDBpBllRlusSJqtcyYeROHDx/m9ddfZ+/evcQmpuCt0o56opUffQH6iRJGrZ7opkPJHlGSiI6o1wdbTAYag1gSEE15EZ3FiUqjpadZ5COXB5tBRK94cHv92BwuDGaJQHY9JMWFzWDgEbuD3qUmoyqtHq3ZirdaB+xptTF74nCYLEgGIzpRwZXTFK3ZipJYhfr164ffI41Gh1ZUkIIpqHVGVBodSmJR6d3+qWiMEoJKhUVx4KvanqIZG/DkNiNZp8diMCF5ojFa7Dgi4nF7A6h1BmJbjcGd3ZAmzVvy888/I9udBGp0xhWXxeAbSz5jHTt3RSfZMbkiEQNJ5BVWZeZNN2FPLESOL8DsjaPfgIFlzrX/NIk5deoUN/TtT0JKOhMmTaG4uLjkcxORQMHUl0joPBOTxcbDDz/Mhg0bylywt+nQCVduM+T4AopmbCCx80zyq9S45Ge4uLiYadNLtp06bUaZCovZc27F5o3Ck1YNrcGMKzoFi1K24qRdxy74susT23oskmy7rIvL4uLivyRhPHHyVBR3EFd0CjVq16twFcnZs2f56quvKqu0/2H8UxLUXIfYWhCEqoIgvPyn/08WBGHyf2xTmaCu5H+ao0ePIhkMfOD28qbr2iSot23bhleUeMzuoK4oomi1TLRYibZYrqsJ/H9y+vRp8tPSqGW3k2CVmTR27GXPcfLkSXx2O5OsMn1lmSqZmddhpdeHjz/+mHvuuYf333+fGZMnE+ly0bB69TKx0OPLl9OjQwcWLVhwWTc/3n77bWbPnl3G4+f48ePINgcxLUcRqN0Di9GMy2pl+/btFBcXo9PryRm9gvyJz6E3GLEYjZh0uvA11oU4cuQIVarXQqVWU6V6rfO0uUOhEPfeey9qtZrs7OzLMpf85JNP0JskPIWtyZ+8GntMZtjc7tSpU8ybN4/xEyaWibfuuusu/PlNKJqxgajGg9EbTHRr1+6yqmaPHTtGzTr10Wh1VK9Vl507d7Jp06arNqPevHkzkyZNZuXKlVd1M+vXX3/l2LFjbN++/aLdiJciFAqViT2//fZb2nboTNsOnfn222/LbHv8+HGSUtPxxKYjKXYeW7aswvvp3W8AzvhsfFXaYnd5yi0uO336NO+9995l5VkqSmpmNjEtR5E59GEkxXHea7tSPv30U2655RZefPHFcp//97//zYhRoxl847AyN4Mq+e/nmieo/wmPygD5+lJcXEzrxo2Jt8q4zSJ33n77Vc33ySef4JAkmjhdOCSJLVu2VGjczClTyJZlRlqsOCTpqr90/6j0jZdlshKTOHToELLZzPMOF2ucbixG4wX1Vh966CE6OkqSvEttDhpXr87mzZtZuXJl+Ad33759vPLKK+c59+7evZtXX30Vs17PB24v33n92E0mZs6cSb5V5kevn3myjXivlzirlWhRRFKpSdBqMatUWFUqVIKARa1mksVKllVm3n8Yen3//fc8+eSTfP/99xi0WnJ1Ovb4Ajxmd5AVH4/TYqGLzU5QsrDg/vuxGAx87vWxye3FrNfz888/45AkbpcVesgKTWrVYvv27dx0000sXbqUs2fPsnLlSqZPn87WrVuBksB2wYIFNKhdm1ayzCsuN5myzJNPPnnZ700oFCI5KooUrZYYjZaAWsO/7A4Cag0aQaCzycwrTjeJskzPnj1pLors9QdZZndQOz8fm8OF3RWF7IxEZzDz5ptvlruf33//nRUrVvD000+XMYhcv349klpNP7NITb0erSDQySwyVFbQq1Q4bV6c/kScbi933HEHDawyWz0+mlisDC1tLfxPHnvsMQJZtSmasYGETtOpVqtemXVE+XyoBAGVINDCaMRjMjF62DCmTJmCWqtHpdagaHSkanV87/WTYbPxzDPPlJGF2L17N1q9AdGfiMkVhd5oRnG40epLgmOjwYQ1JhtrRAo1a9SkfdOm3D1vXjjQ/PLLL1EcLnRmGb1J4p758+nVpx96SSG+w9QSTe+cpkQ1uRG91Ulcmwn48pow5z8kV/bt28eqVasoSEnhKUdJ5X090YLZ5sYq2/HGZ2JR7LRt3xFnbAayxYFGEDBrdAhqLXJsLsG6vcP626m978IoWkuTyzKO9DooiVVoaTTS0qLgTKtNYueZaIwSSV1vxhGXQ8eOHdm4cSOrVq2iZk4O3dq145dffsHrD6ITbRTN2FCq36ylatWq5BVVQ0muhiunCXJ8ARqdnq+++ip8PupMFpJ73EbRjA2YvXHIEckYzBKW6Ew0BjNiIJnC6etw5zbDaLZgkN249CY+cHvRqFSoVGryJj5H1vBHUGl0iIFkimZsIGPwYgKRMaxfvx5PQg5FMzaUGJTEJZUkxrU68savomDqGjR6I6+88gpbtmxBozcS124i7rzmVK1RG4CffvoJrz8C2ROBRm/E7Qvy1ltvcezYMV555RW2b99OKBTixRdfZP78+QSj49AaJTRGEbMzAlFx4oxMomWbduFg/7a5d6D4Y9FbnaT2vQdfQQs6dO52yc/w4sWLcUSnktz9VhzRqTzwp+qWP1dHu+MzmTdv3nmGuUePHqVFq9aYLDKKw33Jqu3i4mL27NnDSy+9hGiR0Wh1TJl2ca3Hq0W0WMkeuZzCaWuRnb4K3cA9fvw4mTn5yC4/VsXOe++9d13X+Ae//PILn3322VUb4f4v809KUF/rhyAIHQRBePhP/+/5n8no0gT1fkEQPhME4RlBECIuMNdAQRA+FgTh48jIyKs/8JVU8hcy/847wxIfyx599Krne+aZZ6hXej3wpMNJSnQ040aP5tlnn70Gq708jh8/ztNPP82rr75aJmH3zDPPkBYbS156Op999tkFx//www/4JIk9pRrgeq32mq2tuLj4iuQhLpdXXnmFeKuVN10eBsgy3dq1A0q6XqMkC/NkG6lWKw89+GCF5nvttdew2JwEanTCYnOxYcOG8HMffPABHm+ANLPEu24vPWw27r77bkKhELLNQVLX2aT1nY9JlDhy5Mhl3Qy5VAJ4/fr1WK1WPB4PmzdvrvC8DRo3JaJeHwqnr8eXUYsFCxYAJX4knpQqBKp3xOnxha9l/4grRXcURp2BZx0ukmX5gtdVP/30E81btSU7v8p5n4F/Yqf1pCnT0BtNmLU6HAYDisnEgnJ0sS/FO++8g2xzoNXpGDt+AsXFxfiDkUTW70Nk/T74g5Hh9/TgwYOcOHGCEydO8Oqrr1528Z/N6UatN6HS6pGcgQu+F9eLbdu2EZuQjNXm+Eu1v9OzcvEXtiRYoxOByOjKePZ/iMoEdSWXzVdffUVAktjpC/CO24PTar2q+caNHs3o0ha4cRYro4cPr9C4apmZPF2a7GrhdF11ZULL+vWZJ9vY4wvQ0GbnoYcewqjTsc3j43OvD7NOV64mLMD27dtxWiz0URRiLBYeWLiwQvt88803cYgiVRwORLWau2QbLzndSFotdqMJRaPBrtPhtFrZvHkz7777Lq+99hrJ0dFkmkW8ajV7fAHedrlxSRYG9e7NwgULLhrITJs6FYdazVsuD2OsMs3q1mX79u0sXLiQt956iyNHjmAp1Ud7welCMYu8//77pNls7PUHec/txW+3l5nzvnvuIclqZZjFikOU+Oqrr2hSuzYNZIWmVhmf1UpiMMjE0aOvOCBZsmQJUSYzRTodKWoNdQwG/Go1aTo9wyULJpWKnNRUrMaS6uYJFispBgNTJ07EIUmMlyz4NRrUgoCs1XLo0KEK7feHH37AZjRxi6xQx2AgQ6sj6HIx4IYbaNawIRaVmhV2J90kK6JGw8mTJ2nXrBkGtRqDRoeoOJg4+XxNtZ9//hm3L4A/rSoWm5OnnnqKDRs24PT60Wh1JBuNbHR5iNRoEASB5Lg4jh49SmpGNlaVihU2B3t8AZK1WhLMZtwWK2aLgmiRWbhwIV6HA5VKhc5gwl+zKzEtx+CISODDDz8EoHfvPugVD94q7TDYvKSkl69JlpyehRRIRk4owihZ+e677xg2fAT2qBSimtyIxigiRaSiNVlR6YxojSKZufm899575BYUIloU9CYJX2oRosFIttHEFIuMqDfir9EF0R1N4fR1WKOz0ZtE4pOSGTZsOBHRsRjsfnLHPY01JgeD2YrRLBGo0RlndCrjxk/ErtiQPLFENR2KRm/CoNGiM4jhxLElOouEjtMIVO94QdmLDz74AI3ehDu3KdbYXAw2H7bIVEwWBXtKDSLq90WtM/Dss8/yyy+/UKV6TUSrjN3jx1PYhtTed6ExWTBJVgYNHoxOdqHSGrGn1qJw+no8ha2pUasO8RERdLJYaWuViQ8GUevNqHVGRH8SglqD3urCEp2N1mSlT7/+LF26tERGw5eAGEgiOa2kcsnrjyCm5SgSOs9EtMocP36cjRs34or+vwS33e0t0ZmOiUMr2VDrjKT1u5fELrOwOd1ExsThic9Ekm1079ETmz+GQF5jDKIVf/VO5E18FmdmAwJ1elEwdQ1GsxQ2gDp37hw33zKH5LRMPIFImrVsc0FzqD8IhUIMGz6CYJ2eJYYxdXoyYuSo8POt23XEl9eYuHYTkRR7uS2KoVAIq2InqdstpPa5G5MonafB+fvvvzNp8lSatWxDUmo6ZqsNtc5AVJMbyR37FEap/O6Va0ViSjpRDQeQ2PkmRKtyUV3JP3j88cfxJhdQOH09sa3GULdhk+u2vj94+eWXEa0KNk8E+VWqXbY52P8vVCaoBYcgCIbSfw8SBOGNS81bGX9X8lfwyy+/sHjxYp5//vlrkuT6/fffK+S/UhEOHTpEtNdHI4cTvySxpIKJz7+K3bt3I+n1ONRqivR6ZL3+gvHw2bNnyUpMoqWiUENR6ND82ujAfvHFFwRdLkw6Ha0aNryuHU4rVqygnr0kXl5ks9OgalUApk2bFpZfmS0rDOjZ8xIzlTBq9BiCdXtTNGMDEQ36MXTYiDLPT580ibqywmyrjE2jIdbr5dlnn+X1118nEBmDy+vnqaeevuavE0quz+Pi4jAYDDxeKnlYkTFOj69E/zgjO3zTwO7ykD3isZLCgagkPvjgg/CYo0ePkh4fzyyrzDdeP3FWKxs3bix3/pp16xOs3pHELrOQZFu5UhGXori4mI8//jhcJHK92LdvHybJStqA+7Fo9Xzn9fOO24NiNl/2XHFJqSR0mkHe+FVY7W42b96MzmCkcNpaCqetRWcwcvToUfoNGITBJGKWLBWW9PhPDGaJ1L73kDv2KdQ6Y7hQ7H+Zs2fPolKrS47n9PWYLUqZ7ohff/2VtWvXlns9Uck/n8oEdSWXzf79+1FMJp53uLhdVkiNibmq+RYtWkSBLPOsw0WRLHP//fdXaNykMWOoIstMKk2KXm3ioVenTgyUFT70eEmXZVavXs0tN92EzWTCbjIxbcKEi47/5ptvmDdvHmvXrr3odl9++WX4R7ZdkybMk0sSv60kC25FIeBwoNdoeM/t5R2XB0mnC7dXnT59mo8++oivvvqKefPmYTUY+JfdwWhZISkykjvvvPO8Cu0333yTnj17ctttt4WNEWfPmIHfZqNadna5wcIDixYhaTRY1Goa1qzJvffcg1Wno7HZTIbVyuC+fcPJl59++okkn58ltpKKkS52B4sWLUKtUrHTF2CPL4DDZDqvIvJyCYVCzJ0zh1r5+cg6XUmiWa3m+VKt7yxJItrlwqvTschmo73JhEeWWb9+PREGI+MtVtoaTfzoC9DOZGbqpEmX3Oe+fftoUKMGfq2W1U4XLzhdONVqhpdKmrzwwgvklpoPrnQ4cYsiAKNuvJForZZ2koxolNBotRw4cIAOnbqSlVfEzJkz8dntaNVq6teuzbZt29i+fTsGk0RE/b4kdZ+DTa3hTZeHkaKERhAQBIGEhARcCTkoJgsjJAsvu9woajX9+vULmxHGt5tcknDNqI/DE4tJb8IqKWhVKoxqNRMnTuTHH3+kUaMmaIwSclweWpOFxo3LT4wZLQrOzAZENByAWmfk5Zdfpri4mHvm30v3Xr1p2bIlsj+O9AEL0JospPW7l8gG/dCZLEgRqZg8saj0JmyptfBW7UBsXDxmvQFXRm3MVhsWV4CI+n0xe2LIHvEovvymDBxyI7feeisGxUvBlBeJazuB7PwivvjiCyZNmhzWBj9w4ADNmrfAbLURrHsDBVNexGAPoDPLeNOqodEbkT0RWBQbX375JaFQiJMnTwIlwU2f/gNx+4I0atKMgsJCDJJCweQXyB7xGGqdkazhj5ZUSDuDvPnmm/TtP5BAUUtyxjyByRmJWm9GY5RQabR07tyFth06EqzbG09ha9Q6IxqDGYPNh95g5KeffmLG9OlMnjQJrdGMO7cZWcMfwWAP0LVrV2wONxqDGW9OI0SrDYNJJLbVGDyFrTHY/ETFJQIlupIxcQnYXV5uK+2UOHHiBN5ABLb4XCSnH71ZIqrJEKRgCrbUWqh1RvInPU/2qOVodXp86dXDxiOi4gxLpZhtHrQGEzZ/LBqDiYgG/YhrOwHZ5uCrr76ieq26JKSks2JFxW8Gbtu2rUTCRKNBb5IIZNfFItvDN0qgxBG8d78B1G3Q5ILfn+fOnUOn15M75knyJj6LwSSelwAeNmIUnpQquHKaIAVTKJy+jqgmQ7BGZ5E38Vm0Jku5FzjHjh1j9+7dV53o+Oabb6heqy7p2XmsW7euQmNefPFFHJGJ5Ix5gohaXWnbofNVraEi5BVVI6HjNAqnr8MTn8ULL7xw3ff538j/eIL6khIf/7G9RhCEo5eatzL+ruR6c+zYMWL9flrb7KTKMpPHjfu7l3QeBw8e5Mknn+T999+/6HahUIgXXniBBx988JI3eq8VmzdvxqnV8kiptF81g/GiBT6HDx/mvvvu4+GHH77iJP4777xD64YNGdCzJwcOHKB1w0bcJCvs9AUotJX4blwv/kimptts2EWRl19+GSjpmnWKIoNkGZ8ohn8H/5CPnD59erkm0CtXrkTxRhLTYiSKN/K8Y/f7778zdvhw7AYDt8oKTzucyCbTeddm14s/mydOmTKlQtIbp06dYteuXWXl3Np1xJNajUCNzthdnvMkyD766CN8djs6jYYb+/W7YPwUiIolfeBCCqevxxWVfEmzwP8kFArRrmNnFE8Eks3JzbfMufSgK+Tf//43JtFC2sAFGDU6XnV5+JfdQYTLddlzRcUlktz9VvInrUZ2+XnzzTcRJStmVzQmVxR5hVX57LPPsDq85E96nuSec4mIjruiddscLtL6zi8pxBCtlyXz8t9Mjdr18KTVwJtdn5T0zPC5vn//frz+CHzJeUiyLfyZr+S/h8oEdSVXxBMrVpAYDFKQlnbV+s/nzp1j0pgxFKamMmHUqAq3PJ09e5b599zDsIEDLxgE/vDDDwzo1Ysb+/W/ZIJ037591MrPx2GxMGLQoPAX3Y8//sju3bsv70VdgLHDhuETRXyiyPiRI6mSnU0rk4mXXW6iNFr69+/PmTNnkM1mFJUKWaXCrFLxxBNP8O2331KUmUmiLGMXRdasWcOaNWuomplJrMdDjsVCR1khISIiXBG3fNkyFI2GugYjFrWaWoWFFVrn/PnzqW61strhIl8UcegNPGJzUMNoJNrvR9LrsRgM3DxjBulxcRQaDGTodMyyyrhEkS1bthC02+llFhkmWfDZ7ZeskDh79iw7d+68oIzKnykuLmbXrl2MHjqUqrLMMFHCqFLxqN3BFIsVj0ZDtFnEYjAg6XSYVSoSNBo6mMzs8QXoKVmYWIGLmsKMDCJMEkGTBaMgkKDR4DUYWL58OaFQiKNHj2JWa8gzSdh0BgyGkkR8SmQk65xuXnV5EFUqdIIKl8WK1iwjBpLRGkXGSha+9fiIs1p58803efDBB3GaLcS3n0zhtLWYRAVZpcKv02OSHBjtfgRBQKXWEN1sOFa9EatGw9hRo3j//fdR3AFyxz2Nr1pHTM4IimZsIGvoUnQaHXF6AzdYFWLMVswGEZvTTU5BFWJajqJoxgYc6XUZWY5WNoDZIpM9cllJotbhL/NZe+211xg/fjyi7CCiQX8MipfC6etI638fKq0BszeOyEaDUOtNGGx+dJKdwqrV+fDDD5k7dy6vv/46FsWGSqNDikwv0bRrciNtO3Tm3LlzNG/ZGp3eiGxzXLRlsf/AwbhTquIpaIlWb+DWW2/l8ccfZ/yEiZisdqy+WBKTU0lKTUej1VFQpTr33XcfrvgssoYuxZtRi6HDhqMzmolo0B9Hel10FgeiLwFXThO0Rolhw0fStkNnohoPpnD6euT4ArSigiOjHqIvAZM7BpNkwWSW0Ik2BJWGtP4LyBz6MAajKXz+//TTT2hNEtFNh2FPq42g1iBaFVq1bktko4ElZo41u2KUFAqnry/R3tab6DdgEFBiLmOUXUTU64OkOHn99ddZu3YtFrsbR2Z9DKIVd1oNimZsIKn7HKzRWZg8MWiMEmq9kfikZBRPBGn978Nf0ILo+CS8mXWQ4wuwRmUS2XgIZovMo48+SpUatcmvUp1NmzaRW1iVyHq9Se4596JVMFu3biW3sCqpmTm8+uqrVKtZh5gWI8iftBqbL4aJEyeW0af75ptvqN+4KVVr1ilX3uLQoUMMGTqcTl26M/jGoYiyHYvNFdbk/jMFVWuS1O0W4ttPQfTGkT95Nf6a3VAbzKh1Bqx2V/giKhQK8dxzzzF69GhEi4xotVFQVK1MBUZFeeedd7jnnnv48ssvL3tscXExAwYNwSxZyMzJ/0suLOo3bkpE3V5kj3gMmzeSt99++7rv87+R//EEtVYQhB2CIMT8ySQx7T+28f3p320FQXj/UvNWxt+VXG/eeust8ux29vqDvO7yEOfz/d1LumKmjBtHiizT2mYnLhC4YJfm1bBv3z6efPLJsJTHA4sWIalUtDeZWelw4jEY2LRp0zXf7x/s378fuygyT7bRU1ZoWrs2rRs1YqassMMXoKCcBHUoFGLJQw8xbOBAXn/99atew8mTJ3nvvffOM2l///33mTNnTthEEWDs+Ak4o1PxV+uAbHeWq0H86KOP0blbD/71r0cumJi1iSKb3V52+gL4RLHcZPf14vTp0wwYMCBsnvif3WYV4eTJk9x6622MGj2G77//niNHjtC5VStSo6K4ecaMsCH7pW5a3Hb7XGSXH29SHslpGeEikYqyc+dORNlOwZQXyR65HKNZvOzXcjnMu/MudHoDRoMRm9lMjNfLoAED6N6+PS+99FKF51m3bh2ixYrBJNK73wDuu+8+YswSZrOMUbITHRXDV199hcXmInfc0yR2vono+KQrWvOzzz5bcu1hMJaRsjt9+jR9+g8kOj6JAYOG/M9JYBw/fpy7776buXPn8uuvv4b/vmjRIgI5DSiasYHY1mNp3LzV37jKSq6EygR1Jf+znDlzhiivl5GyQl+LleykK/viv1YcP34co1bLl14/X3j9GLVaGlSrRpFeT4JWS6pWi1tvICU6GpfJxHzFxpsuD2aVihqygmI0EmkyMdsqc5dio1pWVnhumyiy1eNjrz9Igqzw6aefAlA7L4+lpZXNLYwmVCrVJYOJs2fPkhgdjVutxqpS4VKryTCZ+d7rp6fZjFoQWO90s81TInuiUakYKUoMEyUktZrnnnuOhQsX4tDr6W4WqW8wEOf3s3LlSm6//Xa2b9/Ob7/9xrx587jllls4cOAABw8eJC0uDp8oEunxVNgA7ezZs9xz991079yZoCiy2xdgs9uL1WAgzutlllXGqlLxiM1BE4MRUaXCqFKREh1doUSU3igSrN6ZxM4zUWt1SBYZXzAStVqDxxdk69atWBVbadXzLZgkK/v376dnh440t1jI1Oq42Sqz0xcgRacjokE/vFXao7c66WUSSTRJqDVaglGxrFu3DpvRiFGrR2eUcHl8BEQRyWAiY/BiCqevx2JxoBdUCIJAdGx8ONgOhUKMHjsOrU6Pxx/EKFrwVe+ELbk6kmTFZRJxxWSR0HkmOtGGNSodlUaLklBIap+7Mdq8PPzww+UGjr369MMRk443pyHBqJhwFf4DixcjuwMEC5phtsjoDGb0ejNGRwCtqKBXPMS3m1SSYDVKFEx9idyxT6E3GMNzz5p1M3rZRbDuDaj1ZnSSHavNwWOPPYbD5UGj1dG5Ww/OnDnDli1byC2sSmJqOj179eLOO+8Mr/fkyZPUrdcAk82LL78pisPFRx99hEmSS4/dOjRGCW9BSwqnr8ObUYvGjRvjL2pV0qZZvy9Zufk44vOwp9bCoHgxuKKRgilE1O9LRIN+tGrXga1btyLbnUgOH1qjhMkVRdGMDSWVyaJCRGFzbE430c2H4y5ohaBSo9GbkO0unnnmmfDrrlWnDoJKjdHup2DKi0Q2GohBtGILJpDQcRqKLxrZZkOJTEFyR1Kjdh1Onz7Nd999h94sEd10KEUzNuCv0YXp06czZepUArW6l/ytVg/0JhF/1fYYbD6s3mi0RolAnZ5kDH4QRyCWfv0HEB2fRLOWbdi9ezfDR47G5vaT1O2WEgmOnLosX768zHngDUSSMWgRhdPX4wjEXvCmoDcQQUyLkSSWSpDkFlYlrs14CqauwRmZxPr168tsHxWXQFTD/sS2GYdVsZ93IVWzTn18+U2JajQA2e5k27ZtfPvtt+VeFM6ffx+KNxJ/QVP0ZgtqtQanx4fVZic6PqmMk/qwkaNxRCRisDpJ6DyTgqkvYXQEkKzKZXXjrFpV0r4ZLGqJRbZfVM/zn8KOHTvIyMnHqtgZP3HyP1IH8p/A/3KCuuTlCc0EQfhOEIQfBEGYWvq3mwVBaFX679sEQfiyNHn9piAIyZeaszL+ruR6s3fv3nDCs4us0KZRo797SVdMnM/Hay4Pe/1B8uz2MqZ714Jdu3bhURSaOpy4RJGXXnoJv93Osw4nrY0mbGoN06eeL0F3Ldm0aRMZtpIbCu+4PUQ4nXz55ZdEuN0YtVraNG58XgHLPXfeSbpVZlpp0cufO66uN4lpmaT1nV9SLJBW9Yo7jG656SZ8kkSyrNCyQYPLMhG8FoRCIebPn39F5onlMbR/fzrKCuucbpKs8mUla9977z2ee+45fvvtN3777TcmjxtH786dy8iGXIhDhw5hlqyk3HAncW3G44+IuopXUTHOnTtHcXExP/zwAx5/BFqtnlpmEbfZXKE1/8HJkyfD8jmPPvpoiffMhGfIn7ward7IgQMHmDh5KlqdHqvt6j7/p0+fPi9+nnfnnbgT80gfuBBXfA73XcKQ868iFArx+OOPc9NNN1223nZFWLNmDTZ/DGn97sWX04BBQ4Ze831Ucn25WPytFiqp5L+YQ4cOCUePHBHePHlCePS3Y8K3334nTB4/Xjh79ux12+eJEyeELVu2CEeOHDnvOb1eLxj1euGzs2eET8+cEYx6vdC9f3/hJ4NBSNfphZ+LQ0JvvV4I7f1JiDxXLBwOhYTnTp0UuppF4SlREobqDcLx338Xtp09I9xy7KhgkeXw3AU5OcIdv58SFp04LhxTCUJUVJQgCIKAWi2sPHlCeP33U8IHZ04LMX6/oNfrBUEQhOPHjwsLFy4UFi5cKJw8eTI810svvSQc2bdPaGQ0Cl96/UINg0HYr9MK1Q/+Iuw8Vyy0MpmEIb8eFF75/aRQXFwsRGm0wilBEB45eUJISEoSfjt2TLhl/HhBc+6cMN0qC31Ei3DixAlhZv8Bwre33S4U5eQIVbOzhddvni18Nm+eULdqVeGhhx4SUg4eFD60KkKbU78Ld912W5lj99lnnwkjb7xRmHvbbcLp06fDf9dqtcKo0aOFx1asEJKysoTWp04KXU6dEDp37Sr8evCgsL/4nKATBOGW308LbxeHhN9VGmHxI48IX/zwg+D1ei/5fmq1WsGe1UAQg6mCoFIL9iodhTNytGCJzRXM+R2EAUOGCY8sfVg4uHmlsGPVbGHK5EmC1+sVFj3yLyGlb1/hN5sihFQqISQIQkhQCQbFJ1ijMgRV6KywqviccDAmV8ifskY440gS5t15t/DwihVC47q1hSF9ewl7du8UHnz6acHqcgu/bFkr/Pr1RuHEqeNCP9EsaNVqYdeO7cK8efOEM2fOCI8++qigCRULG995W5gze5YgCILw66evCLbig8LOnT8IZ4xmwZrdRLAnVRXkuFzh+L7tglpvFgSVSti17n7hzG+/CoOHDhe8/qCwefPmMsdg6UOLhbtmjhMm9GwqbPnw/ZLzCoRlK54WPHUHCIGmIwR7fJ7A2d+FCQadoDt7WvAWtBLOnfpN+PG1pcLPH7wohM6dFo5u/1g49NVGwe31h+f+cOs2IVinlxCo2VVwZTcUrEat8MN33wgLFi8RtDFVBK3VLTz7/AvCwoULhWYtWguHnPnCzj37hQ2f/yLcsfQZoX2nroIgCMKxY8eE77ZvF2zp9YSIpiMEQYkUqtWoKZwtRti/+Rnh88WDBYrPCYJaIwiCShDUWiE3N1c4t3uLsOvxscKxbS8KoskoCAZRiGs7QVDi8wWXCUF94heheP8XwpGPnxdGDh0i5OTkCLt3bBeef2qZoMgW4fSRfwv73lsp7HntX4JOtAmHv3tfOHniuCAgCKcP7xdUGq0Q336yEGg1Seh5Q2/hxIkTwhNPPCls++wrwZ1SVTjz26/Cmd9+FdQanaAyiELNvDTBd+gDQThzXDAF0oRzJ44IbZrUFapVrSb4ghFCSlqGUFyMsP+D54V9760S/v3xGqF27dqC2+USDn60Wti1fqFw/MvXhDtumyMMapIp3H3LNGH5g/cKaampgtHmE4x2nxACQSAkzJk1Q1iz+lkhMjJSmDp5oqBVI+xcM1/YueYe4diuz4RatWqVOQ/Gjx0j7Fp1k7Bz2WghJsIr5ObmCrt27RIG9+kjDBs4UNi3b58QCoWEA//+WbCn1BAs0ZnC2TNnhJpVC4UDby0VPr+nq1AlJ1Vo2LBheE5A2Lt7l+DMaSI40+sKxQjCwYMHhfnz7xNatGkvPPjQQ8Knn2wTvDV7CN4q7QWtySIIgiAkJiYKKpXqvM/ryJHDhccfXiSM69pQ+PrzT4QlS5YIp06dEtQ6sxAXGytkZ2eHt33yySeFYOtJgt7mF87+dlAoPn1CIBQSjFHZwmPLll3yu+EPVjy9SnDW6CEEGg8VrKm1hfXr11d47N9FTEyM8NnWj4Sjhw8Jd9x+a7nHspL/fYB1QCIQB8wp/dsM4MXSf08G0oAsoC7wzd+74koqEYRAICA8t3atsKlKoWDv0F7411NPVXjsqpUrhQiXS4jz+4XXXnvtOq6yYmRkZAhLz5wWVp48Iew6c0aIi4u7pvO/+OKLQl2VWnhIbxBu1GiFe+bMEWSLRdhTXCyMsFgFlcEg9B848Jru8z/JysoSTlskYfCpk8KQ078Lnbt1E1JTU4Vd+/cLBw4fFp7fsEHQ6XRlxrzzyivCEI1GGCxZhGZ6g7Bp06brusY/U7tGdeHAeyuEfe+tEo799K2QlZV1RfNMnTlTWP/uu8KSl9YIz2/YIKjV1yatcvr06Qpdx6pUKmHkyJHC2rVrhR07dggFBQXCBx98cMX73bNzp1BdpRIy9XohVaMRfvrppwqPrVatmtC2bVtBkiRhQM+ewhdLHhai128QmtWvL+zfv/+iY+12u/DYI0uF395+QNB+v0FY/eyqK34NFUWj0QhqtVoYNHS4oEuoI6QPfVj4TGsS0jRaYevWrRWex2QyCXa7XRAEQejevbugN5qEoz9sFY7t/FQwGPSCKIrC7bfeIpw6eUI4cuigULt27Stes15fMt+f2f3jHkHvSxFEb5yg9yUJP+7Ze8XzX0tuunm2MHLyzcJDr3wuFFWrIezZs+eazt+8eXNh1OC+wun3HhKqJ7iEO26/9ZrOX8nfzIUy1//0R2UFRyVQ0jodKJWZ2OELUF1vINZoYsaUKddlf/v27SPa6yPVZsMty3z++efnbbN+/XriAwESgsGwJtJbb72F1+FgtGShpdHEKMnCGy4PLrUalSCQZjDwktNNNYOBXmaRvf4guUYjjzzySHjeX3/9ldHDhtGna9dwBd+JEycw6XQ0MxqJ0GgwqFTs2LEDKLl7WTM/n8aKQiPFRu3CwrD+2LPPPkvAYKSLycyPvgAtTGZGjxqFWhD43uvnR68fi0pFrEaLT6OlZakGcyOrlaVLl9K5RQvukRX6iBIGQUDU64nz+bjVqvCR24ukUqESBHaU6lO7zGZmzZpFA1nme1+A7rJC53bteOuttwiFQuzbtw+nxcI4i5U6shw2Mjl79ixzZs2iY/PmrFy5ktOnT7NhwwY2b97MM888Q6GiEK/RoNWbCNbrTfao5ZgVN7lpaTStVYsvvvjiku/pzFk3I9k9WH2xmBz+kmrZEY+ik+wkdJxGenZeeC3lSZN88cUXRLjdGDQanJIFe0QiRskavnPsTK9TosuW2xSDaC231b5XrxvQyx7MvgRsqbWQTGaeeOIJRo4cWVJJHRVFsiQxzmLFIYrYXR7SB9xPwZQXkV0+PvvsM6LjEtGKJaZ/ap0BsysKjclCxuDF5I1fhVpnJLr5CGJbj6NKjdrlHoujR4+SW1AFrU5HYmo6/QcOwpNShbi2E7DYXbRu2hSn0YRKrUVjlHDlNSO+wzQEQUVEg36I/kS0JksZx/OFixYhe6OIKNWs/qPKOCuvELXeRHLPuSR0mo5kVdBotKT2vQeDreR9yBu/CpNZ4ujRo/iDkbgy6mB0RiDHF6IxSlijs/BUaY9Kqyex800E6/VGazRjNEtkZOVy+PBhjhw5wrvvvkvzVq2xRyZhdkejF2WMohWTZEW0yMydO7dck41jx46xfPly2rTviD8YhS8imtmzZ9O7Tz80Rom4dpMQ1BpyxzxJ/sTnwkaDNes1JKHjNIpmbMCeXA1BrUEn2jDZfaxcuZKXX34Zb0I2RTM2kNbvXrzBKCzOABqDiE60oZfdmL2xGGUndes34F//egTZ5cOX2wijaOHRRx8Nf8bfeecd1q5dy9tvv41sc6A3mjGYJfyFLbAFE2jWohUHDhxg5Ogx+ItakdhlFhZ/HOMuIH/zySef8Nprr3H69GnOnTtHrN/PcFlhoKyQER8PwIhRY5BdAfSijBydgTshl/qNmrB+/Xqy8grJzC3g3XffDc/Zt/9AHME43LHp1K7bgMWLH8QeTCCuzXgUbyS16tbHFZuBP6cBUbHxl9UeGoiKJa3vfAqnrcXuiypT9V27XkMCRS0J1O6OWm9EpdbgzGqIMzaDBy/D1OrW2+fiis0gru1EZJe/Uuvufwjhf7yC+no8KuPvSv6p/Pbbb1iNRl5wunjc7sRhsVywe2Tfvn20bNCA7Ph4Hl6y5Lqt6dChQwzu04fWDRuWkZn4g82bN9O7SxemT5582dIIUCIzEG02U0tvwKJSYRAERo4YQUpUFB5FqbCh+9Vy6NAhHnrooQqbWi68/36SrFbGWqw4RfEvNX07ffo0c269jb79B15WtexfwS1zbkOnN2AySzz9dMV1u7/66itiY2MxGAysWLECKJFeWbFiBVu2bKnQHK+88goOUaSqw0GU18u///3vK3oN8X4/r5d2DRQ4HOWe9ytWrKBPvwFh6ZctW7ZQp6CAmrm55UrBXS/yq1QP+3XI3lgsRmMZibrL5b333iMlPYuE5DReeeWVa7jS8vnss8+w2hz4k/OR7c7rbjJZUTJzC0npdUdJx2ZWLZ5++vqYhlby38vF4u+/PdC90kdlgFwJlCRoOrRsyQiLlT2+AC2NJtqbzLSqX/+q5j137hxPPPEECxYsKON8feutt9LdKrPXH2SiVWbgDTdcdJ49e/ZQPScHh8VC765dqZGTQ2IwiGI00tLhxKxWUyRJuPR6Iu124rxeGhmM3KXYENXqsIzHhTh58iSiXs+7bi9vuz2Y9fpwG92RI0cQdXp+9AXY7QugFQRcZjMJUVH06tSJ1Ph4zCoVakEgJzmZL774AotaTWeTmZ4mM5JKxS5fgM+9PjSCwEyLFYtOx+eff87d8+aRLcvcLit4RJFB/fpj0+kIajQENRrqGYzk6/R0NpkZIErE+v0cPXqUFvXro1Wr8dvt2LxR2P0x9LihD6+88grVnU72+oO84nKTHBEBwKzp06kqK9yj2PBJUhnjjSNHjpAUFUVVmx29USSh03QKp6/D7I6ivyhxs6wQ7fVeNFA+efIka9asYfHixTz11FP4g1H485pgCSSiM4pIVoU333zzEmdLSbB725w5tG7WjHbt2oXbBX/99VdE2YFKo8PsicWTUsSyZcvKjP31119xShItTGaijGYk2U2B0UiU18vJkydZsmQJarUaRaVitdNFJ4cTty9ITOuxpA9YgGgt0Qq+cdgIbFGpODLqY5JkUtKzUGl0qDQ61HoTKq2B7JHLiG48iDr1y2+Xvf322/Fm1qFw+jr8Ra0YOnwE4yZMonHzVqxatYqffvoJo9lC5pCHcOY0weyOIqblaDQGEX/1zkQ2Hoxid5a5yAqFQjz22GMMuXFYmWBt7dq1qLV68ietJnfsU2h1Opq3bI1WtKHWGfFV64g3qx616zfizTffxBNXol+dMXgxGqNIsF4ftCYLwYYD0BjMYXkRra7Erf7P7/upU6dKdKmnvEjB1JfQ6vQ4IpMpmPoScW0nUlC1xnnHYs6tt6M3mDCaLRjMFgz2AEZnJBqDiCAI2BIKS7S9M+ujNYpY7G4GDBoCwI3DRuBNr0lil1nozDIak4xWcmC0Oli1ahXff/89kmInvv0U/PlNyczJQ2uyEt9+CukDFqAxmNGbzNxxxx2cO3euJOHdaXpJoJfXiCWlF9Njxo1H8UTgikmleq26nDp1ipUrV+JLyqNoxgbSByxAJynIdicuXwRGewB/ja7Y4nK49dZbL3le//LLL1gNBvaUfodoVCp+//13QqEQL7/8MjqDicJpa0uPqQ7Z5iCu7UTi201CtjnCWnihUIgNGzbw/PPPc/r0afr2H0hko0El7bW1ujNhwkQeffRR5s+ff9kmUhk5eUQ3G0rG4MVIiqPMhcUvv/xCrz79aNK8Fa+99ho9buhDVFwig28cVmEfBCj5Pbj5ljk0bdmGRx997LLWV8k/m8oEdWX8XUlZiouL/2slgQ4cOIDFYOBrr5+tHh8GrfaC3/UtGzRgkCyzyuHCI4plpJtCoRAHDx4sV8/14YceolH16kwYNapCfioXY/fu3TgkiZusMo1lhb7dul3RPHmZmXjUarb7AjztcOK1WK5qXX8FoVCIJ554gvFjx/6lCcl/IgcPHuSjjz5i586dmEQLOaNXkD7gfiyyct62P/74I++//365Uo4HDx6kdu3aCILAiBEj8NpsNLU7sBmNDB8+nCNHjlxyLT/88AMzpk8nOSKCwvR0tm3bdtmvZ9SQIeTKMj1khYDTWUY7GODJJ59E8USUGFw7faxevRqf3cGdio37FTtOqzX8+nbs2MG2bduum3zKK6+8gmRVsDi8BKNjy8jE/VM5evQos2bdzMRJk/npp5/Yt28fGzZsuCJ/levFsBGjcCfmEdloEJJsu6Kk/6+//squXbv+a3+PKrk4lQnqSv5nOHz4ME1q1cJmFunUug2tGzfGYTRiUqmQVCq8Gi1+UWLZY2WTCGfPnmXfvn0VTkoM7tOHHFmmlc1GcnR0OOG2ePFiqskyH3q8tJVlJv1HFeK+ffvKBABd2rThRlnhA7eXFFnm7rvvplWDBrRu3Jgbb7yRTEVhrz/IOqeblMhI6lepSj2DgeZGI1kWC48//jhQ4hjdq1Mn/HY7nVq2DGsEAzz4wAOY9XrMej2PLF0a/ntxcTHxwSDDZYXBkgWPWsMquwNFrWa2rJBhlbltzpwyelbDBw3CqFKRpdUiq1Q8aLNzs1XGrFIhqlQE9HqWLFlCcXEx982fzw2dOvHcc8/hsFjYWGoUIms0eIxGFio2Eg0GclJSyxhQHj58GL3BRMHkF8iftBqtTseuXbtwWCyk6nT4dTq6tG8PQOsGDVhYqmvXw27n/vvvL3O8P//8cyJcLrRqNRqdAa1ZRqMzcKtV5juvH41afUHDiNOnT1OUmUmhzU6kxcKtN9/M999/zy233MLSpUvZs2dPmUTrp59+SmpmDv6IaB555NEyc00dP55UUcSgN+LKboxotYUT2ytXrkRS7HiT8vEHI89LwC1evJgMvZ69/iBrnW4cajU7fAE8ZjNZWTmYdTpMGg0aQUBdWq0+d+5ctHoTKrWG9Kxczp49y+nTp5l50yw6dunOq6++yg8//IBGqyVj0ANkDvsXGr0BlUpNsNS0ozxuvfVWvFn1KZy+Hl9hS7p068bRo0fDz//www+Isp3opsPwVmmH3mSmoEp1tDo9WqOZuMTU84LZw4cPs2LFCm6//XYWLVrE3r17+e2331i8eDE5eQXoRRmd2coNffpikW1ENR1GRMMBaAxGxowdx9GjR/npp5+wyHaimw/HnlYbtd6M1mRFb3Wi0RvxBiJxBONQ3EFGjx3H9u3b+fnnn8NrCIVCeP0RRDceTEzz4VhkBXsglvyJzxHd9EZq1K5XZs3bt29HlO1k3LgEJbEKaoMZneQgucetONLrIQaS0RglnGm1kF0+Zt9yC1999VU4iDpx4gTdevZCZ7ZiS66OJSoTd34L9FY3BrOVO+6Yx5o1a6hRpwHZeQWkZ+eh1urJGrqUgskvoDGIjBs/ASi5idKlW3eccTlENx2Kxe4Kmx2ZJQs5ox6ncNpaDJJCZEw8s26+GYtsJ6rJEGxJVXFmNcAanYUjvS4agxlvlfbozNZwhc3FCIVCFGVmUt9qxWI0I6hUNGneit9//51z587h9UcQWb8vEXV7EYiMRqPVkT9pNfmTV6PR6enUpTtPPfXUefNu2LABi81JsGobJNl+VeZNn3/+OcnpWTg9Pu699/5LD7hCTp8+zX333cf0GTPYtWvXddtPJX8tlQnqyvi7kv9j/p13YtLpsEsSa9eu/buXc0WMGDwYjyjiMJmYc9NNF9wuJyGBVQ4Xe/1Biux21q1bB5Tc0K5frRoWvZ6gy1UmXnrttdeItFh42OagjqwwbeLEi66luLiYUUOG4FEU6letel5F6rp166hZWpyxzukmPTr6il7ztGnTUNRqtnp83K/YifF4rmieSv56Pv74Y5wWC6k2G7F+PwazSO6YJ0kfuBDJKpfZ9vnnn8duNpOiKBSkp5dbcX/69Gn69++PIAj4dHpGSRYiNRqqm0ykxsaWuX4sj4MHD6KYTDztcHKHbCMpMvKyX1NxcTGPPfYYt99+O3v27Dnv+UFDhhLZcEBJ0UWdXowaPQadRsN3Xj8/+AJI+pJCk0UPPIBotaG4gzRt0eq6JakPHDjA559//l9jMFi9Vl28WXXxV2lNMCrmkr5Tfwd/dCn07N23THFZRVm5ciVmyYoo2+nQuWtlkvp/kMoEdSX/M0wcO5YOsswnHh9ZokiM2cxOX4DldgexPh/z588/r+J13759JEVF4TCZSI2JqVDLkstq5UOPl73+IMmKEm6POnPmDL27dMEty7Rs0CCcvAuFQnRq0waTRoNRq2VFaWK5Sc2azFds7PEFqGGxIhmN3C4r3CgrZCcm4RBFFtnsdJcV2jVpQte2bRlolXnK7iTRag0HzAMGDKBIr2ez20t9k5mbZ84ss94zZ86U+8O6a9cuBt5wA2mxsfS0WJlosXJDqYTIfMVGblIS1bKyqFelSliuJDU+nny9nrmyglOtxqJS8ZzDyXqnG0ml4uabbwZK2snGjBzJvDvuIDk6mttlhWcdLhSTiXvuvpvaeXkM7tOH33777by1/lFpGdt6HHanO5xMH2WxMtMq47Pb2b17N1Wzs7FrNNQyiyhmM5MmTSrTPtina1dGygqfeXzoBYFnHE7ecLnRCQKpVutFq1FWrVpFgsXCHl+AN1wenKKIqNcj6vXcd889/PDDD9x1113Mnj2bLVu2EIyMIbLJYNL63YvZIpcJumrn5dHYJBKs27vEkK9eH4YOHxF+ftu2bbzwwgvnVREANGnWEpNKzZ2KjeZmCbNaQ32jEZ3ZillnZJ3TzddePza9nqDfXxJ0+gNENhxAwdQ12CISmTdvXni+4uJi6tRviM4ootEZMJjMiLKd4aPGsGPHDp5//vkyaz9z5gxffvkl+/fv57nnniMhKRW90YjOaMbuj8Hu8oSdyUOhEHGJKYi+BBzpdbE5PZw4cYJjx44xdfoMUjJy6NWnXzgAPnToEB5ZpprBiFujwe6Px+n2kpaZgzetOlqTRLBOL5SEIgyijFZvIGvYv0qkPSRrmSTzxo0bqdOgMQZJwV+jC7bk6hTN2EBUkxvRGEx07NyZ9957j87deiDZnJgkK0uX/gsoqTbo3rMX3mAUeUXV2LJlC337D0Sj0eKPiOKjjz6iT/+BJKdnM+OmWXz++edYnV6cWQ2xpdTEEpWJJTqLohkbSOwyK2ysmJiSekHDkxdffJFAWpWwjIdKZ8ToiCC29TjMNg/PPfccy5YtwxGZSFL3OZjtXtQ6I1qTheS0zHAFV3RcAoo3CrXOiFpvClfMh0IhElPSiWrYn4RO01HrTSR1nY3V4WHp0qVExyUh+eKI7zAVrdmKK7sJ/hpdw8esV59+F/xs/Jk5t96OWqtDY5RI6j4Hd2I+Dz30EADffPMNbTt0pkOnrmzfvp2evfti80VhcQUxWGxENxuG7PKzZs2a8+bdtGkTd911V4WrVQ4dOsTGjRvL/Qz9FXTp3hN3Yj7+Km1xef1lbtxcjOLiYhYuXMSwESMvaDpZyd9HZYK6Mv6upISff/4Z2WjkA7eXZx0uPIrydy/pigiFQnz77bdhubsLsfThh/GIIkV2BxnxCeFijccee4xaNhu7fQGmygqdW7UKj7nvvvvoVlo0cZ9iv6R543PPPUeGLLPZ7aVvORXSv/zyC16bjd5WmWxZZuLo0Vf0mouLi6lXvTpalQqHKLJ58+YrmuefzNq1a4lwuQg4HDz77LNXNdepU6e47777uOWWW8rEmdeDEydOsHjxYhYtWlRucrh7+/bcVNqZ20Gx0aRpM3QGI0aTyIoVT5TZtkpGBo/ZHezxBahit/Piiy+Wu89QKMTQoUMRBAGtILDCXnITJNtmL1dm8M98//33eEWRnb4AH7i9yCbTlb/4cvjyyy/p0qULZtlBoHYPLDYXr7zyCv179iRJlkmTFTq3bg2A0+MjY9AiCqa+hOIOXLKr+K/i3LlzrFq1imXLlpX7nn744Yd4/RHoDUamTZ95TfcdCoXQaLQUTH6BohkbsDrc7Ny585ru459AIDKG1N53UjDlRRR34C+VAKrkr6EyQV3J/wyD+/RlXOkPeVNRwmUw8KHHy1xZoUpGZrljJo0fT5/SMd2tcoXcrBtWr04PWWG2rOC0WMrIfJTHm2++iUmlYpgokavTYS/9QX/ttdcwqdX4NRoUtQa3TsceX4BPPD4sRiNr166lcY0a9OvenUOHDrFjxw7cooRNrUbS6Xj11VcJhUIY1Gr6iSWJ5ZGShXo1a15wLWfOnKFvt264ZZkW9Rtw5MgR9uzZQ25yChqVClGtZqgoEdBoEAUVIyULt8gKUV4vjzzyCIIg0NMskqjVImk0WPV6tnh8rHa6MKhUVK9Vl+q16mKTJEaWaka3a96cwvR0kiIieOrJJ89b06FDh1i0aBFPPvkk586dY9OmTWTnF5FbWJX333+fsSNGYFapqG0wsM3txW4y0aR2bfrJCivsTmx6PXZJoptiI9lqZda0aTz88MPUyC9glCzzuceHQRB43+3lVZcHg0bD2rVry9xt379/P4sXL2bdunWMGDoUUafDKAg8ZncwWlawqNV86PGy0u5ErTWgNYoo8fl4chqj0ZswOoIYHQFyx608L1C6bfZsAkYjos1LfPvJWJwBWrRowcSJE0mNiUGjVlOQns7BgwfDY3bv3s2yZcto1rIVaoMZb2Q6wfwWmGxesjIzCVTrgFWy8bjdyYeekmOyc+dOZs2ahSAI6C1OMocuweKORjYYWL16NQCvvvoqBtlNwdQ1JHW7BaOk8MMPP7BlyxYsip1AejVMohWDScRsUXB5AyieIFq9kSSLBY8o0rRxY/yFLUuqG2p3p1Xrtpw7d46ff/4Zq+Ige9TyEnkLfwwrVqzgySefxOaPIeWGO/Gm16RNuw6sWrWK9h06kaQ3sNcfZIPLjc3qxJdaBYNZomDqSwgqNZ7CVsjx+cS0HI1BtKI3mjBJVsaMGw/A008/TVpWHg2aNGPnzp3UrtsAi92L2R1N9qjluHKb4sioh6g4WLJkCVaHh4LJL5A+cCEOtxeAFq3b4cuuT1STG7Eo9nAbXHFxMb/88gs9b+iNJ7Uqqb3vwhGM5+mnn6bHDX1KpEtqdiOxy82o9SakiDQ0BhGV1oBJtFzUdf6nn35CtjsJVO+EHExCJypENR5M0YwN+Gt2xSrb6Ny5C4EanSmasYHIBv0xuWMRg8noTBY2bdrEokWL8GfXxVvUFm+VdhROX489rTYqtYb8omps3bqV2vUaYpYdBOv1oWjGBnzJ+Tz//PPs3LkTq82JXrKh0uiw+qLRiQq+qh0wWWyMGTP2vDWHQiFGjh6DbHeSV1SVDz/8ELNFJnvEoyR2mYVB8eLLrF2uS3goFGL8xMm4PH7cvmD4Zk2gdncmT746T4BvvvkGm9ONJy4du8vDd999d1XzXQl2l4fsEY9SNGMD7qikCiebp02fiTM6lWDdG5BkW/hmTyX/DCoT1JXx938j27ZtIzsxkSi3m3/9qXPuati7dy82k4kvvH5ec3mwieI1mfefzGeffca6devKdBIuX76cqoqNnb4A42WFLm3ahJ/74YcfcFmtdHA48ElSWD/3Qjz88MM0LU1o3yHbaN2w4Xnb7Ny5k9tuu43ly5dfdYVoeVWGC+69F8VsJsLluqJKxqvl6NGjfP/995clq/WfnDt3DtlsZpXDxQtOF1aTiVOnTl3RXPv27aMoJ4dMs5nmkoWEiIjzpFp+/vlnFi5cWCE97Z9++olZs2Yxf/78ctdUv1o16isKDUu9gA4cOMC3334bfq9HDB5MF1nhfbeXfEVh2bJlHD9+vFz5mJYNGjBSVnjB4UIyiWTkFIR9Xcpj2NChqAQBo0rFhFIPmz93tJZHKBSibdOmJMgyPlHklot0IVwuu3btwmmxMNhiJcpsplaNmrz22mvh/b7xxhu8+uqr4XMlISWNmBYjSR+wAINZumT32uOPryA7vwptO3Tml19+uaq13jz7FmS7k5SM7PPitq49euGMTsGbXEBuQZXzzu2U9Czi2ownZ/QKLHZ3uX5VV8N/QwX11ZKQkk5cu4lkj1yOpDgqY+f/QSoT1JWcx2effcbzzz//t1WjXSlff/01XpuNeFkhLhBg3KhRWIxGEoLBsLRAKBTis88+CxvkTZ86lQ6yzC5fgDayzM2zZl1yPwcOHODGfv3p0qrVRZNQf7B48WKKShNxLzhd2LRaurRuTa28PDwmE6843TxlcyCq1dQQRVLMZvr36HHePC+++CL5Nhs/+gIsttmpkZPDuXPn0KtUKCoVGTodVpWKXqUmguXx0EMPUVVW+NDjpZ0sM2HMmPBzoVAIRa+nvsHAUpuDlkYTGVotXUxmDIJAS4cDm0ZDQ5OZyaXaYXNmzcKg1SLq9ch2J1FNBhPTbDg6nYFdvgBvujzE+XwXXM+pU6dIiYmhpWIj22KhR8eOZZ5/7rnn8BuNNDEaqaE3EKU3UKuggIzYWJ4vbb/Ms1rJslrZ6w+y2unCJ4rUVBRqWaxYdTqMGg1mQcAgCJhUKkS9vsw+Dh06RITbTTubnRiziFkQaGI0YlOpsapU1KtSFZNOx0a3l/qilUDtHqg0WvInraZoxgZ0kp2s4Y9giUxHlB00btqizIVEKBRi+fLlNGrShPiERKxqNTk6PWaVigi1mm5mM0VGI53atyc5MpJIpxOzZCGYXRdRtmNVbOhEG9aIFNIys3nvvfeQZBuOtJoYVWoMWi3zbrstvL+FCxciCCoEQSDTaOZOWaFDs2YArF69Gq1ZJnfsU6X60GYAbhw6nGCdXiUJ0uqdceU0wZ3XHGtMDoXT1xPddCjVJJlVDicBRcGdVEjO6BXYkqtjtNhw+yMwSVb0RjP2xELc+S3Q6I04gnFIsg1Pei2KZmwgpuVoZLOFqjYbTosVUatjsc1Od7OEwxWFpDiwOV1ENuiLXnahFW0kdbuFohkbcKVU5YEHHggnkHfs2IEk20jqPoeIWl2pWrM2p06dYsGCBTRs3BSN3ojJHYNWtGFyRWK2yJgkmcyhDxPffgpRsQkAeINRZA55iKIZG/DEpocrSLZs2YLV5sCkuIhuNqzk2BS2ZO7cuRw9ehTZ7sISlYlOsmM0SxjMEql97ya51x2YROmC5/wffPLJJ9SpW4+ateqQkpqOxijizmuB1mQhqskQjCYzFtlGMKceap0ejVEkvt0knFkNqVG7HrfffjuSNxZXbjNc2Y1LqkgSqxDRoD+e9JrMnz+fo0eP0rBxE3QmC86YNOISkzl27BiLFy/Gn1m7JPndeAhOjxedSURVqu9tsbvDLdzbt28nJT0Lg9GE6AySPeIxgjU6U7dBY3RmC/mTnid94ELUOgNpmdnlVg+vXr0aezCejEEP4MluiEG0EqjZBUlxXLDKvKKMHDWaYM2S6u9A9U5h+ZO/kpZt2uNJr0mwdg9sTneFfzvTs/KIaNCPgikvEpFbn8ceq9Sw/idRmaCujL//G8mIi+MO2cY6pxubyVRuG/2VMHH0aExaLUaVCtlk4ulyJJr+yZw5c4aPP/6YvXv3XvEcp0+fpnWjRmjVauKDwfMMlHfu3MmSJUsqdJPy8OHDpMXFkawoOCSpjHnwX8HevXtRTCbecXtYaivpNL0a9u/fz9iRIxk7cmSFKo83btyIXZJwGE1EOp1MnzLlihLLv//+Owatlk88Pr7w+jHrdBw7duyy5/nuu+9wyzIRGg2ySoVTrcap15dJfh05coQor5d2NhsJZpG6NWpc8Kb4yZMnifH56GWVqScrdGzRgmPHjvHYY4+xevVqjh07hkGrZbcvwI++AAaNFsVkwidKtGzQgHPnzvHrr7/SrE4dvIrC4D59LprI3717N7ULChBFK+6sBiR0nIbF5rioIfzbb7+NJIqoVSrGjx9foeP0RyHRn3XZv/32Wxo2bUHNug0YP2ECXbr3KlfC7WI88cQTNC+VtHna4aR6VtZFt588eQo6sxWdZEe0ecKyl+XxxRdfICkOkrrOJlDUiuat2l7W2g4cOMCDDz7I888/z4cffojs9JE17F9ENRxA1Rq1y2yr1enJm/AshdPXYbG5zuvWiIpLJLnn3JLqX2/ENTfi/EODesLESfz000/XdO5/Cu+//z6+YCRGs8jsOZf2zKkooVCI2+feQWpmLj179y1zc7KSv5bKBHUlZXjyySdxiyJ1HE5ifL4yVZ3/DRw7dozPPvvsgm7XwwcOJCBJ+ESRiaNH8+uvv1ItJwe1SkWt/IIKmURcLrt27cKqNzBCspCh0+GVZYaVmvsZVSrq6A1YhBJ37UYGI6lmMwPKSTK/+eabxFutfOzxMVlWaFa3LgDDhgzBKAikaXVIOh1vvPEGwwYOZNjAgWUC8S+//JIOHTrQtTSZO9mq0P8/9uO2WvGpNdxgFjEJKm6XFRoZjURptOz1B3nY5iDW6aRbu3Zh7b0zZ85w4sSJMkZzao2O/pKFWrIcfi1fffUVc+fO5aWXXgJKtL/Hjh6NS6/nWYeLDz1ejCoVT/6pyrpLx44ka3XMk2241GoSIiM5efIkixYswC9J1LA7SIiIwGE2c4dso5msYFKp2O4LsMcXwGkyUTUrC6MgEKlWE6fWEOUuq7+3Zs0aapUGRS84XURrNOz1B+lkMmPU6Th8+DBLHnwQs16PVmfAk9sMKTIdR0Y9fNU6ojVZSO13L0bFRf2GjcpU1G/dupWcpCRivV6WL1tGWlRUuJ0uRavFXqr5HanRoBME7pAVnne4MKg15E18lpgWI2nToRNvvfUWI0eOwixZEC1Wxo4dS1HVajRr0TLcvhUKhcKJ8f79+6MVBFSCQLTBwLRJk8LH3Onxo1Jr0RpF6jYoqdi56+67ccXnkNrnbszeOKKaDCGifl9MrihyxzyJp7A1Bp0RrUaHWqMlIioOlVaPklBIVNNhiP5ECqetJbLxYLRGEbXOgLeoTWnCuxMGs0QgrSpqnZGHbHZ2+wI4DAaMogW7KCNqdRRVr8VLL73Exo0bqdegEWkZWZicERhsPlw5TdCbRJYsWcK9997L3r172bhxI87IBAqnryd94EJ8EdHUqF0Puz8GSbZTv2FDNEax5DWMW0lE3V5Uq1ELi2wjEBkd1jYeNmIUzugU/PlN8AUiwgnWHjf0IbJhf1J6zUVjMONMyMXmdLNjxw7WrVuHNzGHohkbSO1zN/7IGHQmCZM7usR0Uq3hxmEjLlpd06f/QNxJBQTr9sJqKzFIVKvVJPe8nfyJz6E3mtmyZQvLli1j5MiRmNzRYXPDYFQcepOIWmdEpdWj1psQBBUGm5+8ic9iSyhk7ty5tO3QGV92fQK1e2L8f+ydZ5RUVdaGK1fdfCunzjnQdNMN3eScM5KzRJEgiOQMIgaCqCCIiKCgYsKAgmFUVGQUFXNARQVkREYFyame70e1NbbdJMM4800/a7Fcy7r33FO3qm/ts8/e7yvKsb/ZBx98EE9iNgVXrUH0J6OlFhHXqD9me1TfMKHZEK64cgQATVu2JqHx5SS2GoESn0vx9E2kdppAQkoGojcRs0PGZLFz2WWdY4unH3/8ke69+lC1sJjld9zBsmXLCBU0jm1S1KhVlxkzZvwhFVs33HAj/uya5I+4C19mMQsXLvzdY14qR44cYcbMWVw5fORFu6Qvv+MO7JKKwx2H3RlEVn+bUUwlfx6VCerK+Pu/kaDTyfNeP18GwyQoyh9WoXfq1Clku4MnPT6e9viQ7fbfbQT4Z3HmzBlGDxtGajBIjw4d+Oc//0ndoiLSNQ2nKP4hMhCXqnt67Ngx5s6Zw6grroh9JsePH+fNN9/83RWdv4WdO3fiFyV2BkI86/Xh07Ryx6xfv57RI0bEJAXPRSQSITc1lQGqRn9NIy8t7YL3p0nNmsxWNVwmE1NVjSay8puNIGdPm4ZbEPGIIpN+UXjzS/72t78xc+bMc26Kz507l36KisNo5KNAiA8CIcwGQ5l18HPPPUeJ283eUBzPeH34TWZ8mlZhIvD9998nVYt26L7rD6I6HOTk5RPMqYknIZOhw4aTkZDAKE1ntKajW6zc7/bwZTBMtqb/5vgoq0oB2f3nR7vmsmvEOijPxb59+0hKTMRgMNCtW7ffVKmflJpOYtNBpLQfi8lqjxkcbtq06aLH+OSTT3BLEjNVjTqaxvjRo897/NBhw0loOjhmqD1+wrk13zdu3BiL2bP7LyAjN9pVPe+GGwklJFOvUZNzJnMPHz5MWlwcHZwucjSN7l264EnMpHjaU2T2vo6sKvlljs/KrUp8g14ktR6JrGi0bt+RoVcOjxUubNiwIaqfrDq5rGv3P007+9/BqVOnuGn+Aq64cgTbt2//q6fzu9m4cSPOYCLZ/ecTyKvPVWMqfpZU8udTmaCupAwNq1fnblf0x7eF231RZln/bs6ePcuWLVvYtm3bJQWIBw8eRLLZ+KQ08LCZzezatYszZ878rvayi2Hm9OkIZjOSxYJitbLdH2RPMEyCJGE2GFimu6hZaob3nNdPZlxcuTEikQjjR49GEwTy09PL7Npv3bqV5cuXs3v3bjISEih2OCiy20mLiyMSibB161bckkRrlwvRZCJdltHsdubMmcPRo0cZ0rcvecnJdOnQAWtpYrOq1RYzZ9GMRu52uWkpK4waOrTc3O5auRJBkBE98TjjM6nXsDHjrr6aRYsWcfLkST777LOohETNjuj+eJbefjtTxo2jRNWYoWqoRiPtHQIFViv5qWmxcbu2acsC3cneUBwDJImQ18upU6cA2L59Oxs2bOCnn37i+eefp3vbtkwcO5aq6elcoWlMLJVgqVmtGpLRyENuLxMUlcz4+DJz37lzJx5JYrHupL0kk2i1cp/LQ9BsZtLEiWzYsIFW7ToycNBg3F4/ZpuA0WIjZBfwCSJpmdlYHBJaWg2CBU1p2qJ1bOzspCTma04e90T1t5vUrk0vUeJBtwfBYGC0rLA3FMe1mk6a2cIoWWFnIIRgNJHaaSL+rGKmTZ/BsWPHsNrsOMwWFKMR0WBAUNwEi9sTn5jCypUrCTid2CwWBvXrR1CW6S4IiMZoJXWbNm348ccfgWjy8Pbbb+eee+6JaZOfOnWK4SOvIjUzB5NNwGQTMVjsmKwOzHYJOT4Ho8VOdv/5FE14GLNDwiFKpHaagKegOYIviRpTniCuYb+YBrOaXI1qV69DT6uBVZDpf/kA0uLimKjpLNSdeFSVv/3tb6xYsYIvv/ySI0eOMHz4cBSbjWxNJyM+npT0TOyChO50MWDgYFzhVIKFzTHbHNglBbfXjz+1KqonwIiRV+EOp1A8/WlyB92C2SGR1fcGvNVaomfWwp9bl5mzyndInD17lnXr1rFo0SL27dvHTz/9RP1GTTGZzNg1H1WGLMEVn8HIkSNj1dsff/wxsu4mo/tMQsVtkTQXcY36Y1O9ZPaaS9GER1A9gTIVJj+ft2PHDiKRCCkZ2VQZcls0iZ9dgw6dLsNiFzA7ZETdw5Arroyd99NPPxGXmEIwrx7OQCI9e/XGbBfJH7mKlA7XYBE1bIKMVXZhstixK25uvvlmElLSqTJkSXShklGNZ599ln/+859s2LCBbj164nR7sUsq3mqt8FZrgd0VIlDSCcUbx7333gtAjVp1Ses8haKJj2IVNWRPCKtDJDk1jbiGfak2Zi2BwhbMnj2bQ4cOsXv3bnr26UeoqAVZfeaheQJs2rSJUHwi/tQ8FM1Vzgvg93D8+HG69+qDPxRPzz79/mMTJr8mISWd3IGLKZ6+CcWfxPLly//qKVXyKyoT1JXx938jS2+9FY8okqyqdGrV6g9LgJw4cQKHxcrb/iDv+oMIVmuswmzfvn1MnjCBmdOnx2KNv5I1a9ZQqGm84PXTTtPp3rkzhc6o58tal4eirKzznn/gwAHefPPNc1b0vv/++9QvKqJaRkaFPgoV0bdLV5prOuNUDa+q/iVJ6V8SiUQY0q8fHlFEcwjcdeedZV5fe++9JCsKU9WonMNzzz13zrEOHjyIWCpTuCcYxmGxsG/fvnKV1E888QQjhgxh3bp1tG/WjK6iRK3Stc8z3qgh/G/lyy+/5IsvvqjwtaeffpqgJDFKUfGf472sXbuWKoqKbDRyv9vDWpcHTRA5ffo0L730EmvXruW9997DLUks0J1cJgi0dwg09XjZsGFDufEOHz5MyO1mtKrRSdOoW706zkA8xdM3Ue3qdciqzldffcXgvn0Z2Ls31bNzmKc5ed0XICTL5UzFf2b//v0sX76cJ554osI18OLFt6J5Q4Sq1iMUl3DBjq6pEyZQW9UottowGAw0atSIxYsW0bx2baaMHx9bc52Ln3WPq098lOJpT2F2KBSMvpdw3e7M/JUn0oV4+eWXGdS7N9fPnXvB67700kvImov4Gq2QNScbNmyIxei/5qeffiIpNZ1gdjGqJ8BtS5awdetWNG+IKkNvJ65O13NWVb/88stUc0WleF7w+hGNRkw2B6LTh6Tq5T77r776isu69qBhk2ZIikZS61GEilrSvFXb2DEHDx5k9+7dv8vcLxKJsHPnTnbv3v2bx/i9DB95Fd70QuIaX46iu36T3vXx48d54YUX/iNkOpYsWUK4qAUlMzaT0uEaWrbt8FdP6X+WygR1JWUY0LMnPTSdB90e4mSZrVu3/tVTKkMkEqFHh45kahpJisLYESMu+twTJ06giyL3uz2scbmxG424BYG8tLQ/vVLcKUm84PXzYSCEZDKTrig0dLqoUaUKbkXhVt2Jy2hipKxQV9UYNmDARY17+PBhPvzww5jG1KFDh5BNJlo5HPQRRUSjke+//56RV1zBFCW6kz9CVnBYLAyRFfJVjSb16tFU03jK46OaprFy5Ureeecdwh4PXWWFNIuFlnYHORYrOUlJvPjiiyQHg2iCwE3z5vHZZ5+hWq3kmqNyIA6jkdyUFIb07RszQVyxYgVx1aMP/fRuM6jXqBnVs7Ji1cRN7A6qWa0MlxUal9SMvb/7778ft8nMEEnGZTKRJMuxytctW7bQpGZNOjZvXiYo3bt3L13bt0ezWqmjadgNBuLNZnYHwzzr9ZHo85W7j5s2baJ9kyZcOWgQQ/v3p05+PotLTdpk3U1yh2sQXCHiGvWnePom3KlFXC0rpKgqy5cvxxOfRsmMzRSMuRfN5YmN61FVtviilUzh0hbOkqpVcVttaIKAYjIxWlYImswk2mwoNhthWaZO9RpUr1mXoVeO4Pjx4/z0008oJhNrXO5oVZTZTLHNhiLpmCw2FIuFpU4X7/qD+BwOGpRWbdztdJGekIDFYiEhIYFwfCImk5leffufc9E6a861mMwWbA6BxJR0AlnF+NKrYRMVsvrMo3DceiyCSjgxBYsgY3ZImKwCBqMRk00gUKsL1a6+D4vkjFZZZ5SQO+hWvMEwn332GZ1atKBlvXps27aN1XffTYOiIob260f9Rk1xyk5u0qIbEm2cTpYvX86+ffs4ffo0aVm55A5cTMmMzSiJecQ3HYzRYqNbt2iF+c6dO5E0F1UG30ZisyHYVTclMzaT2fs6bJJG5249LuhQDnDt3LkE8hpQffJjuHPqISkag4cO4+mnn6ZLly5k5ValXYdOpGRkYZc00jKzMRgMJDQfil33k9nzWoomPIJDdZXRIp85ew6y04PmDdGjd19atWmL5A7hL2qNpOhY7QK5Q24jrctUFFUvF7h+//33rF69mmeffZZXX30Vq+yixtQnyRl4MxZBpaCwOuG63Sgc9yCu1AIaN2nKZV264o5LI1TUAn8wjk8//RR/MI5Qdg1kzcXGjRtJSsvEmVmLhGZDMFpsGK0CNofAypUrefXVV3n22WeRVR3NE6SgqAairBJu2A9PVk1sgoQnPo1AOJ57770XSdGQNBdOX4iMHrOjyfcqdZg4cSJxSSn4Q/GsX7/+gp/B/wI169YnvlE/cgYsqtTQ+w+lMkFdGX//t/Kzt8QfXZ03b/ZsNIcD3eFg9rRpQLQzKyMhgQGqxmWaRv0aNf7Qa/4WbrzxRvpoOntDccxSNdo2b06crPCi188ETaflebxaXnvtNdyyTJauk5OSUmGCLzspibmazr0uD7ooVuhFc+rUKaaMH0+zWrW4bfFiUgIBXvL62RuKo4b798tbnT179qIMeRfNn0/17GwG9OxZzpg8Eonw5ZdfVmgQP6RvX+aW3sPRisq00s+7IiKRCMV5eXTSNDpqGtlJSagOB6rdzpB+/YhEImzevJmQLDND1UhRFBYsWEBucjIOo5EBskJ1TWPsyJGXfiMuglHDhjGt1G9ooqIyrgLDyUgkwozJk0mLi8MrSaSFwzz77LMsvOkmEhWFFi43aXFxPPnkk2THx5NkszFRUXFL8jkT4zt37mTUsGFMnTiRr776CkV3kdxuDHF1ulJUXKvMse+99x7ZSUnoosicGTMqHO/QoUMkB4N0dLrIUjVmTJ5c4XFbtmzhnnvu4cCBAxe8Ny3q1OEuZ9RcMV8UMRqN2EwmFmg69TSday+QZD548CApGVmInviop4qgEKrTDVlzxdZrF8uqlSsRbTZEm63chklFvPPOOyxbtowu7drhFUU0h4MV59jsP3jwIA899FBMfufRRx8lkFlE8fRNZPSYTbUatSo875tvvsFVuinRRZTwBNMpGLMWh6Sct2r41VdfxZeUTcmMzVQdsRJfsHzh2e9h0JArkJ0eREVjwcJFf+jYF0tWlQJyBiyKVrFXqc2GDRvYuXMnb7zxxkUV/h0/fpyq1YrwJmUh627uvnv1v2HW52bPnj24fQFCubVQdPcFO0cq+fOoTFBXUoYffviBXpddRvXsbG5fsuSvnk45fnYS/yIY5sNACIvJdEnVz08//TQZcXH4FYV2ksSeYJgumsZ11113SfOIRCJs27aN11577aJ2QP26zkNuL6/5AghGI9mpqaxbt44jR47wwgsvEPZ4cNntVMnMZOHChRfcOYZoBYdf1/E6HPgEgWuuuooTJ05gMhj4LBhmbygOl9nCF198wZIlSyjSNO5xucmRJKpKMo+4vSzSdeKdTmaUBm5NBJHcpCRGDR3Kp59+ylVXXYVqtzNJVkhXVHp17YpgMhE0mbnL6cYritx///34rVEt4b2hOC4TBAZKEu00ndFXRqtA33jjDRSnh+S2o/GlFzJx8lTcskyGxcJwScZhMCJbrBgNBnRJilWenjlzhrT4eBrYHSzQdDyiyBdffMHWrVsRzWZu1V2MUzWqZWaWuTfTpk5luKLykNtLrtlCTZuNXIsV3WRi8TkkAI4dO8aOHTv46KOPGDduHEOHDiUrORm7yYTdYkPyJhGs2YkaU55ATchFE0WmT5oUrZKITyRYvRXetAJ69e3P1q1bSfT7Ea1WFIuFJEXhstaty31XNm3aRG5GBgGnk1FDh/Lxxx/z/vvv8+OPP1JStSqi1UpOSgr79u0jNRhknqrztj9IyGRmo8dHus2OyeZAMpm53+3hs2CYoM2GU5K4zOUiXlFYuWIFW7duxW63YzRZSG53NZ7ETFatWkWPDh1oXqdOuYrWn+d57Ngxbr31VuqWlOB3uTGarRjNVsRgGmaHRFKbUcQ1HoCvsDXF054irlF/TDYHBqMJLa0GBpMZT0EL3Dn1qFpYvcw1Xn/9dYKyzGqXm06ajtFkJlSlEb1llVd9AVIsVrp17hxbYPfo3ZdA1YYktx2NRVTJG7Yck9VBoSSRk5LCkSNHWLZ8OaH4JKoUFOEPhXGn5GMRZJJS0vjwww/P+bd03XXXYZdURNVJx06XESppHw24anXimnHjeeCBB5BdfgIlnTA7ZCySi3CDvuQOvAWTTcCZXQc1KR+jxYbZJmI0WzDbxZgGXyQSwWqzU+3qddSY/Dg2QUL3JxAoaoVNkHBIKq7c+lgElZT2Y/H4y2tBXn/DjSSnZ9GqbQd27dpF0xatsAhKdBPA7WPcuHGkpGdiNJmwigpxjfqjeoKMHz+eW2+9lX379rFixQrC1ZpQMmMzqZ0m0qRFa3SPP6bBLQbTEYNpqMnVsIka7nAKjZu15MCBA3z88cds2bIFX3I04M4fcRcef4g333yTw4cPk1Uln4wes6kx9Ulkpw9JcxHKqUkwnIAoy2T1nkdGj9mouvO/rqVx586d1GvUhNz8Qh5//PE/ZMxdu3ZRq14DElMzuPPOlX/ImJX8sVQmqCvj70rKs2/fvjLt8Hv27MEnRo26dwXDmIzGv/wZv2fPHuK8Xmq43bhlmTfeeIMb5s4l7HJTKz//nAlFgMtatuKG0sRsG6eLO+64o9wxmiDwhj/AV8EwQUmuUId43pw51NF07na5SVVUWjVuTIkkM0iSka3W3yW98tFHHxHv8yFYrbRp3DhWpPKzz85nn30GwLPPPkuyovCQ20sHTeeqK6646Gvcd999JMkKkxSVgCTx2GOPsXHjxnNqLv/444/MmzePefPmkeQP8LDby85AiDhZ5t1332XypEmM+UXX4IBSOY8vvviC2bNnc9ddd/1p3azr1q0jVVG4XtNJVpRLknjJS07mcU/U86a2O5q0OnHiBHNnz2Zw376XVMi1detWmrZsQ7cevS9KH/iOZcuoW1DA0H79OHz4MM8//zzFv5AYqajb9lJZtnQpyYrCgFIt9K5du2I1GPCZTIySFHp06HDe83v16U+goCmh+r1xyCqLFy9mzpw5bNu27ZLmcfLkSSS7nS0+Py/7/Eg2+zk7GH65lvr888/xiSI7AyH+5vXjUdWLut6RI0fIrlIVb2JmrAL7XLz00kt0bN4cVRDI7DOPogkPI2uu2HPkrbfeYvHixWX0pA8fPkxcYjKhak3xJGYx8qox5cY9fvw4K1euZOXKleeUJq2IvXv3Iioa1SdtoOCq1TjEv8a0duy48XiSqxCu2x3V6WbOtXOjXkLBRJq2bH3B34FnnnkGX0pUOjC7302kZ1f5N8383Ozfv59HH32Ujz/++K+eyv80lQnqSv6rOHr0KE5JYpXLzc26kziv9ze1yIwbM4bems6XwTAtNY0FCxac89hPPvmELq1b06FZ81ji9MqBA0lWVVJUlSH9+l3weg8++CB2gxHBaGSOqmE1m1m8eDFffvklO3bswCtJ3KDp1NV0Jl1zzUW9h/7dutFVlEgxW1jlclMsScybM4e6hUV0lGWGKCqJfj8nT57kzJkzzJo2jcbFxYwZORLZZCLdYkE1mshKS0OzWIgXBGSjiWVOF+01PWbU+NxzzzFm5EhuvvlmdIeDpU4n16samRYLCYrCG2+8QWo4TJzZzGhZQTYaec7rZ4nuom2pTjZEtZ47denOnGujrVt2iwXZaKSaxYKl1MCwlyiRZbGQGR/P6dOnaVG/AXGyjGo2k+jxsGb1aiKRCEG3G5/JxO5gmB3+IIrDUeberFmzhqqqxjLdiWg0MlfVaCBJNKlTp8J7uX//ftLi4khTNcRSuZF8qxXRYOBxj5cXvX5sRiO+UBxGk4kWrdvFpAQikQhvvvkms2fPZsWKFZw+fZqshESW6E7q2uxYDAaCTmeFFZIffPABy5cvL9fKd8MNN9BeVdkTDNNflCjIymLHjh2E3W4sBgM5Fgs3aDqK1YZVkPEWtsZhtSOYzIRMZvy6zi233BIz/AOoVa8hdlcIg8GAqHvISU5muKYzX3PiFMVztpt2a9eOIoeDNIuFEpsDs01ATcrHldsILa0G8U0HY5VdpHebgScui8tlFbvRSEZ2FTyyTFdRoqrdTs/LLouN+frrrxOOT6CBQ2BvKI41Ljea7sZXpQFO1YvNYMBstmA0mWnWoiUQDfbatGuPRVAwmCzRal+jiT6KTnWnk2effTY2/uOPP45DkDCaLSS3HU1SyyvJyMmr8P3t3r0bo9lKzuULyOx5LQaTBYekoLr9hOOT2LNnD1169Ca57eioVEatzpgdMtn9F1Aw+h7MdpHi6ZuoMeUJDEYj1Sc/RsHoezCarUyePCV2HV8gRFrnKWT3n49ViFajl8zYjCujGG9hS0pmbMZX1Aabw1FGt+/IkSM8+eST6P44Mntdh01xYzJbyCso4umnn0bWnMQ16IMvszoDBg9lzJiriWvUP2qA+AstaYgGg3oggZzLFxIsaELrtu2xiipSKANvtRaYrA6UhCqYHTJ6egnF055C8wZjC+mffvqJYDieUPWWeJJzGXrl8NjYBUXFhOr3In/kKjRviLVr1/Lwww+za9cubA6R6hMfpWj8Q1is1v86V/Hc/EISmg4ks+e1SKp+UQZQlfz3U5mgroy/K7kwP1dQ91Oj1bMNiov/6ikB0YTpiy++yL59+y7pvCH9+nG5pvN3X4CqmsZDDz1U7pgZkycTryjk6jptGjeuMBHT+7LLYonuQZrO6NGjkW02OgsCfRSFlvXrx449e/Yszz77LM8+++xFJfe7tG7N9NI1TC3dyX333UckEqF/9+7EyTIeUeSmefO444476FQqT7BEd9GmYcNLuhePPPIIY0ePZv369ST4/dR1u/FIUsxE+VzkJCWx0unmHX8Q3WIhJymJVq1aoZtMjFdU/CYzHdu2Pe8YfySRSITVd9/NwF69WFsqX3axdGnTht6azgpn9L3/0V4RZ8+eZePGjaxfv75MQnbLli3EywprXR7aazojhwzlrbfewiWK3Kw76a7rdGnT5g+Zw1NPPcVNN93Exx9/zCeffIImCEgmEwaDgWtK16Rbt24lFJ+Iojm59dZ/FbAVVK8ZMzMPVan9m7vkTpw4gWC18ndfgNd9AQSrtcKk7aKbb8EuiDg9Pp5//nn27duHLgi85I2afSYHAhd9zePHj/PKK69ctDTF+vUPIkgKdkFk9NVRfeKtW7ci6y7iarZH1t387W9/ix3/3XffsWTJEh588MHY3/Xp06e58ab59OrTn7yCIvxZNfBn1aBug8YXnc/4/vvvESSZKkOWkNFjNh7f7zM4/a2cOXOGFStWMGnSZD744AM8/iB5VyyjeNpT6L443nnnnfOe/+6776I4veQOXEx8/V40bNr83zTzSv7TqUxQV/KX88orr1A7P58G1avz1ltvXfD4559/nsKsLGpWrcqbb775m6554MABSqpWxWQ00qxu3XM6tUYiEcJuN5NVjdmaTsjt5tChQ9gtFj4NhKJ6wRfhGH327FlSw2FGqhqNBRGX2Uw3lxuvqjJ//nw6uT2xRF3jiwzuRw4dSjW7g0GllSs3aDoNatZEdTiwm0zULKhWoTbVq6++SqaisCcYZqHmRDWZuF7TSXE4qC/L7A3F8YDbQ80qZXcyH3jgARwGA/lWK26TCcFgoHfnzkQiER566CEyBJEBkoRmNFLHIeCTpNiOdCQS4YcffihTHVG3Rg2mqhq36E4CJlNMg/spjw+vQ+DVV18lS9P5IhBiie4kPRzmm2++YfTw4VgNBqpZrZTYbMSZzXTv1Il169bxxRdfsHv3bm644Qbq165NfnoGPbt2pXOrVowaOvSc2ojz58+nq6rxrNdHQqlJ4tv+IHaDgb/7ArznDyJaLEycMIEZ06fHJGHOnDlDl7ZtcTkc6KLI5s2bAYj3eBgrq9Sy2fgyGGaiqpWrQti+fTuy5iS+RkvkX+ny3njjjbQSRHYHwwwQJfw2e8xc8p///CdXDhpE19ZtePnll2nYuAl6anWy+t2E4gyy1OmiitNZrvXsjTfeQHO6sdjsGAwGLGYz7RwCDoMRh9HIihUryhx/7dzrUHQ3qslMNauVe0vlWOrZ7LjyGpHUagQmq4OMnDy8/iAWu0hfReNelxuHwUDrFi1ItkTNNV/zBQi7XLHvn6a7iG8+FMkhUc9uJyTLLF2yhImTJlNUvRjR5iC7340UjnsQm6jEqoEWLFhAqEZbLJIe1UWe8Ah2SUd3OMosGlIzskluexU2zU/xtKfIH3FXGemVX/Lyyy9jsthKTSnHYLIJKAm5tGjZJpZIXXzLrWih1Gj1tqBiMFsx2yXsrjAmq51Q3R74ClvHjBLtzgA2QS5TTfHaa6+RlpVLOCGZ5i1b48+uSXK7qzHbBAR/MundpiO7g2zcuJFTp04x59q51KxdD5tDxGJzoPiTCNXtgbegBcXTNxGo1pQ+ffsSyqoelTLpcz2y7qFa9WJEzU18k0Fo3lC5SqEbbryJzNx8uvXoTV7VfNx5jUnpcA2u3AYoiXkUT9+EXffjK2pNdr+bkBS9jK7fvn37WLBgAbfffjtbtmzh+++/59tvv8UfisOueTFZbPQfMJAvv/ySJi1aUbWomOYtWqJ5gqguH2PHXZxT/G/h1KlTf0rlnu7ykj9yFcXTn0b3x5eRbqnk/y+VCerK+LuSi+Mf//gHUydPZvasWX+K2fhv5dSpUyxbtoxZs2bx9ddfX9Q53333HU1r18av6YwaOvScvynbt2/nhRdeiHl5/Jqnn34anyTRxe3BLcvcddddFDpd7AmGedzjJScxMXZs786dydV0cjWd3p07X3COXVq3ZmppgrpmaYL6q6++wiOKfBYM83dfANluZ9++fYQ9Hpq4PXgliSeeeKLcWDt27GDLli0Vvo+33nqLVatWcf3119Oh1J/oNt1F6wYNzju/l19+GZ+uYzYaqWV3sN7tQbJaaSxKDJcVuggig0qLYP7T+ec//8nlPXrQuKSkXJXt7t27efrpp3+XnviwAQPI1XRqO53Uq149tk6666676FhaLX2H00VhZiairCLIGkk+P1cOHPin6b1//vnnLFq0iGrVqmEwGJg2bRrhhGTSukyl6vA7ERUtpqHct19/7LKOL6uEYDj+d0lm3rZ4MZLNhmSzccuiRZw9e5b9+/fH7sk333yDKGsUXLWazF5z8fiDPPfccyy86SZcskyi3/+HmG+fj6NHj5aR/Rk56irCDfpGi0KaDi5TFFIRU6ZOx5uaH5UpNFkonvYUxdOewmp3XJRkz8+sWXMPLo+fUHziH+rr8nvIzK1KUuuR5A66BUnVL0ofe+ntt5OYmkHdho3ZvXs3X331FUOuGMbwEaPOqSleyf9/KhPUlfylnDhxAreisNTpYr7mJOzx/C7TAIgmQ5fceiu9L7vsgjvlFQWeO3fuZOPGjfzwww/ctXIlJoOBL4JhvgqGUWw29u/fj0dVWe50cYfThUtRzhmg/pKvvvqKof37kx4IcEepHEYXl5vrrrsOj6IwSNVIV9VzSlD88MMPbNu2LfYDtnnzZgJq1HG6nSTjkySCus7Dbi8fBELRlqdftOIdPXqUWdOn0/OyzugOB4+5PTR3CHSWognumzQd1Wqlk8tNkqJw2+LFsfs5duRIzEYjutHIRo+PKyUZh9kc+6zee+89/JLEGpebzopK7erVY1WXR48epUFxMbLNRnIwGGuJWrNmDemyTBO7ncGlGtPXajqN7HYalNSMBriiSKrZjGY0IhsMBHWdQapGb1FCMRjwm0x4NA2XKNLO40G12xHMZhSjkRpWG25Z5vPPP7/gZ3PnnXdSYLPxktePYjQyWVHpIog4jUbspdXdPlWls6bRTdOolpVFJBJhy5YtJAsCu4Jh1rjceASBI0eOsG7tWgSrlWo2G18Fw0zWdLq3b1/mmhMnTiJcvxclMzbjTqsRlZ1p2pTvvvuOQ4cO4ZNkbAYDWRYLBbLMfffdV27en332WdTwrmdvVKeHZEGipyhhFxUycvJYs2YN46++mmtGj+b999/n9ddf5/PPP2ft2rWYzWZMBgP3uTyscrlx2my4bTYSAwEWLlyI5PSTO+gW9FAGmtFIkdXGFFXFbLWjpRRhlZ04xGjrZr+ePRGNJqxGEw6TGYc3Ca/JhGo00sHuICDIZKVnMHPqVJIUhRyLFVXSUUUV2WRmzZo1sff05ptvYrY5ooaM4x9CUHR27tzJQw89xLRp01B1FyabQEb3mVSf/BhW2cXUqVPL3Jeq1aqT1HY0cnwuds2PxSFTp2atCp8t77zzDoIoYzTbMDlkUtqPRQplkpSaETtm69atOCQVNSkf0Z+CRXJGzQxD6RgtNhKSU2nWshVfffUVCxcuZOTIkRVWDixdejs2uwO7INK2fUdq1KyDM5xOuH5v5Lgc4hJTABgz9hq8GUWY7SJVhi6lcNyDmG0OBN2Lt6A5xdM3ESxswbhx49FcHsL1emBTXASKO5DUZhRGsxWrQ7igQY3VZsMianjym2ERFJzpxaR0moBdkEhISiYxJb3CapidO3fi8vrxp+SiOd34/AE8eY0pmbGZ+MaX03/AIIpKahHXoDeu3AZYHDKNmjTjjTfeOO98zsXFJJ1nzbkWi82GpGh/uG7czNlz0LxBvMk51KpT/6Ke95X891OZoK6Mvyv572ZI377U1jQGqBphj+ffnjx/6623WLlyJZ9//jnHjh2jWlYWNVwugrLMsqVLgWh3mMNi4fNgmM9LDQZ/rRX9az7++GMS/QEcFgvtmjbl5MmTfP/992gOB094vCxzukgo9Vv57rvvePTRRyuUOZs7axYhWSZbK18J/uSTT+KTJDq5PaiCQIos87jHS2dN58qBAy/43iORCFnx8Tzh8bInGCZX0wk6nVR1ufCq6gWrK3/Jhg0bCLvdhN1uHnvssYs+72L44IMPuHzgYMaNn8Bzzz3HzJkzy3SxnYvXX38dtyxTz+PBr+vnlY05H4LVyvuBILuDYYK/WLPs27ePkNtNS7eHgCzjdHvJuXwhNaY+iTMQf1794z+KkydPMnDgQAwGA1abndyBN1Nj8uMoLh+ffPIJd965Emc4hWDtbgiKztq1a3/3NQ8fPszhw4c5cOAAGdm5CLJKcloG+/btY9euXUiai6KJj5B3xe0YzVb0YBIeb+CiOiU++eQTmtWuQ80qVXjmmWd+91x37NiBKCvY9QBpl03CGZd2Qcm2ug2bktF9FsXTn8YiqsQ16EN8w76E4hP/cmmk38t7771Hbn4hofgkVq26+5LPP3PmDHGJycTV7Ua4ZkeycqtWeNw///lPLuvag/yikr9ct7qSP4fKBHUlfykHDhxAsdv5Ihjmk1JN6YvRX/6ZFcuXk5ecQuuGDdm7dy8Aty9ZQhVVY4HuJEFWLtiK9kuefvppPJJEXbeHBL+fprVrU8Nmo8hqo5rVRtX0dCKRCK+++irVs7MpysoqI6NwMUwYM4Ymms4yp4tQqXHeRx99xLx589iwYUMsibZlyxZWrFjBnj17+Oijj/BpGlVdLsIeD2+++SZuWeY6TaeNrFA1K4s333yTJL+f9W4P7weCeEUxVnkKUQfxlprOCFlBNpkwGQz4FRWXKHJFqWnJjddfz5133skLL7wQO+/1118nSVH5MBBise4kz2Kljs1Owq/aqNatXUutvDy6tmtfxjBm+fLlNNWd7A6GGavpXN6jB2fPnuX06dPcvmQJTerWRbPbaaaoaGYLuiCQqihIFgthtxuX0cRURWWdy43NYGBPMMzuYBirwUBPh4BsNMYMIEfKCh6jkepWG6LBQAuXm7Vr17JlyxZmz55dpvXql3z//fdIJhNSaSJcNBjQrFYybTYGixJuQcBqNsccyiWrlR9//JFnnnkGt8nEe/4g8zUnktHIyCFDgOhOf4PiYkSrlQS/v5zEx7p163CFU4lr1B+v2cJTHh8DNJ1epVIYW7duRbbZUIxGFJuD/MIaZSrQf/6u1nF7SAoE+frrr5l33XW4vQESmw8lo+e1SGYzfVSNAYqKaDJhETXMNgfTZ87ivvvuw2w0YjUY6C1IxJlM3O1yoxiN2AwGtOSCqKll12k4bQ5yMjJoWKsWzsRcSmZsJmfAIuyan6yUVFrJCrfoTmSrneR2V2OVXVgsNhyyE5PNQWLL4XjTC5FFiZd9fh52e/CZTDzn9TNUVsq1KS5duhSbQ8Rqs3PN+AlMmz4Td1wa4RqtcXp8CJKM2S5istqxi0pMbuVn3n77beKTUpDMZjoJIve7PORoWrlnwddff41HURiuqGTb7SjuePw12uOu2oSSOv9qv125cmVMuzmhxTBMDgVPfnNKZmwmseVwOnfrUeH36pf89NNP2B0i+aPuJm/YcuyCyLZt21DdfrL7LyBc0p7WbTvw9ttvU1hcm7Ru07GIGjkDFlFtzFoESWH58uUkp2Vgc4ikpGVyxx13sGXLFsaNn4BdlKh29TqKp2/C4QoT32Qg9Ro1Ped8du7cidsfwlO1Ca6sOkiKSsfOXYlLSkX1hvGnF1BYo2aFydhrrhlHuG73qORJ7W5YRA05nEW1sffhy2/C1deMw+MPEt9sMGIgjSpDbsOXW5fxEyZd8D79+p7Vqd8Io8lEUXGtc7rRf/3114iqTrWx95Hd70Z8wfAlXedieP3119m8efN/nTxJJb+dygR1Zfz9v0QkEuHqESPwazqNa9b8r5AyOnPmzHnXDAleL6/4AuwNxVHN5eLVV1/9N86uPEePHmXTpk1lkrNnzpzB73SyUI/+8zudF6XFfPbs2XKJ7Pvvu49En4+cpKSLMqhzShLbfFEt7bAsl9Fd7d62LQv1qGl1X02nXevWVE1NpWenThed6F96220EZZl8TcPtcKAJAt06drwo876fOXnyJKogsMHtZYPbiyoIl7ROPB8HDx7E6fER3/hy/PlNsDtERioq8bIc8xA5F4P79mV6qX/PQFXj2muvBWD8NdeQk5bGyCuv5PTp05w+fZpt27adU7u7ano64zSdRboTt6KU6cj99ttvuf/++3n77bfJqpJPSvux5I9a/W81Vo5EIixcuBCj0YjRZEJUdXr37U8kEuHygYNJbHll1LOlfq9yxSK/h5mzZhEsaknx9E2ESjow9ppxRCIRhg0fiSCrmKw2BLOFGrKOYLYwZsyYC45ZJTWVGZrOXU43Tkk6Z0x5sXTp3ouEZoNJaj0SwR2mY6fLLlhkt2jRYlyhZEK1uyApGq3bdaR7rz4XVUz1/539+/cjSCrF0zdRPO0pTCZzhTF3py7dCdVoS2bv61Cc3nIymZX891OZoK7kLyUSidCtfXtyNZ10VWPYgAEXfe57771HQJLZ4PYyvHT3H6BJ3broRhM+k4mWDoFZs2Zd9JhtGzXiVj1a3dzR5aJls2bUVzUGSzJOu71M4vZi3tu2bdt46623yvxgnThxgoljx9KmYcNzVnivXLGCeEXhMpeLgNPJgD59uKY0EBqkagwcMIA8ZzRwfMUXIM7tBqJJS10UsVssTJswocyYIV3nBa+fHqLIUElmZyBETV1n7ty5zJ0795zmX6+88grpqsbnwTCrShOYPpMJwWot00p16623YjJbMZotZKZnxQLsFStW0FDX+SoYZpSq0bh2bRSHA4fFgmCx4LBamTh+PEuXLqVfv354LRZCpdW3yWYzktHIJo+PrwMhVJOJDopKC4eDJLOZeLOZHoJIvtXK/W4PaRYLV0gyc1QNyWhEczhYvXo1PklipKoRPId2XiQSIcHrpZ1D4HmvnzSbjVWrVtGyUSOCqkZJzdrkpaXTS9Xoo2rkpaURiUTIz8jEZTRiMRiiCWCjmWa1a5cZ9+DBgxXuikciEeYvWER2larULTWOWel006DoX2aCsqqT1W8+NaY+iVUqq5XepmEjbiv9rrbUda666ir27NmDojlJ7z4LKZyNyWBgd2lS3W4yUzhuPVI4C7sgsWvXLob074/JaMRgMFDTZuOjQBCPyYTZYMBoNCP6krHYHDjlqEv5J598gkNSSesyBU9+MyR/CnFOJw+WStTUEiSsihuzXYjpILurNCSh2RDSukzF6fIxVtMZLssUWm3sCYZZ6XSTk5jI0aNHuXbWLAb17UftwkKckkSvzp05ffo0aVm55A66Japxl12DW265hRo165BfVBxbhO3YsYOGxcXUqVYttghtUbcei3Une4Jh6judtG/fgcFDr+CDDz4AotrwybKKzyGRJyqYLDa0lCLseoCCwhp88cUX1KrXgITkNCRFQwplYnZIODzxWASF7MsX4s+tw+Qp0aD8m2++YdLkKcyZc22ZRcbevXt57bXXsDtEql29jvxRd2OzOzhz5gxLb7+dzNyq1KpbH1lz4g4no7m8GM1WTFY7RrMFq83O9TfexPHjx1m8eDFdunRB1lyEq9bH5fXz9ddfM2jIFTjj0tFSChE8CYRKOtCle68K/6ZPnDiBPxgmVKsLUiAVpzcQ63hQdRcFV62hePomdH98THf/l8yfPx9fVjH5I1ehphQS12QgDnc8Jqud5PRMfvzxR2bPmYvFLuIt+Fciv0u3npeU4L3++usJ5DWgxtQnCRY2Z+Kkih3rY1U14x8id9AtuL0Xr0H4n8Y777zDyy+/XFml/R9AZYK6Mv7+X+Kxxx6jiqazzRdgkKYzoGfPv3pK5+Wpp56KxbtzzxHnd2/fntaazgRVw6uql5QY/Xeyfft2GhYX07C4uMLK2O+//56OzZuTGgwydcKE391p+jO5ySlcp+nc7/ag/8qLZObUqTTQdVa73KSo6iUV+/ySHTt20LBmTUapGm/5g+RoGk8++eRFn3/06FEcFgvv+YO85w/isFguyVDufLz99tt44lIpmbGZamPWYrfa2RuK40ZNp1+3buc9d9b06TTXdDZ5fOQpCvPmzWPSxIloJhNdBRHRaGTs6NE0q1uXDE3DK0ksv/32cuPs2rWLzq1a0bJevfNuKrz55pvEJ6UiKSrzbrjxd7/3S2Xjxo3IsozX6+Xvf/87EH1mKC4f4brdkHU3r7zySrnz3nnnHVo3bEjbJk1isTdEN2bOVzE8d+5cAvmNKZ72FMGilkyY+K8Ch2+++Yai6jUYIEVlKaerGs1+oel+LlRB4E1/kK+DYUKy/Lv1xIcMu5JQcVuqjb0Pb2rVMt2gEP1s23fqQvNWbWMSpj/LYs6ZM4fXX3/9v75q+o/k7NmzVMkvJFC1Ef7cOtSp36jC46oUVCer7w3RIpnsGtx33328++6755Rr/a2cPn26XAFUJf8eKhPUlfxbOH369DkTE2fOnOH555/npZdeuqSga/PmzdRwRfXcHnZ7KUhL4/Tp00g2G497vDzp8WE1GC5Jj2rE4MF01nQe93hJU1WeeOIJpk6YQLvGjVl3Ca1LZ86coXfnzqSoKvGKwvjRoys87tSpU6xbt45Vq1Zx9OjR2P9vVKOY1S43XwXD5AgCyV4f+YLIa74A9UtNHVPDYS5zOinQtDLO3KdPn44ZbXzwwQd0bNGCWoWFuKxWCq02Ms0WpipRA776msbAgQMrTEL9zCuvvILTbsdhjGoVe40msi1WWtkdxLndsUS0Q1TI7r+AogmPYHXILFu2DIBjx45Ro0oVzAYDktGIYDDwsNvDK74AotHIix4fss3O4kWL8NrtFFltpJgtLNWdCAYDwVIzxSSrlZKqVZk7dy5DhgzBKcv0EiW+CoZpbncQkmVUk4ldgRCv+QLYDAZcNhs1i4oYr6ixIGbk0KHl3uNrr71G9dxcri81tOmq68yaNQtZdZLWeQrhWp2oXa8hUyZOZNL48ezfv5+zZ88iGY284PWzJxgm2WxBslgqlOLYsGEDLevV48qBA2MSLQcPHqRxzZpYTCacDgc1XC48pbrdb7/9NjfffDMeX5CEpoPJ7HktdqudeoX/erZdOXAgXTWdO5wuRKORWqUO3IMGD8ZkteOq0hDFIdFKUmgvSEhWO/mjVmN3BhFkNVZdf/jwYerUrBlt4TMYkI0mPMkF2CWdnj178tBDD5WplnnwwQdx+kKYrHYSU9OZMWUKybJMK7sDu9GIzSFQVKMYT35TCq95ACmchRKfi+4Lc+ONN9G2SROKc3OJ93hItFgQzVZkV3STpYHDwXhFLTXa9FFT07nrrrvo2acfgbz6JLe5CllzlmulPHPmDD5dZ46qsUR34VaiVdWvvPIKLlkmSVXxqSq+KvWJb9QP3e3lxx9/5I477sDhDJB35R1485tiETVKZmwmf8Rd2ASZvIJCfIUtyexzA6KioXuisifF0zeh+BMJJyTRp/8Ajh07xsmTJ6OO3SUdCFRtSL2GTQC45557kRQdzRsiPSsXu0PELkjcfvuy2PyPHTtGWlYuyW1HRxPDqUX4SzpRY8oTaL742DOsXcfO+LJKEDzxpHYcH61aqd6CJUuWcPbsWR588EFat26Dxx+iXqOm56yA++qrr1Cc3qi54+THMZstvPvuu/TudzneQJj4hn1J6zIVWXNWqK144sQJevTui6g6EdxhMvtcj031ojndMc25r7/+GrtDwiJqKIl5mKx2rDY7NruDRTffUuG8fs3MWbMIVm8dfZ+1LmNMqSlNRVx9zThsDhFBUli//sGLGv+XnD17lu3bt/+lzt1z5l6H6vLhjkulaYtWf9rC5dixY3zxxReVSfALUJmgroy//5dYtWoVLUpj6gW6k/ZNz92B859AnMfDQ24vO/xBXIJQocb0kSNHmDltGlcOHHTeOPc/nSsuv5xems7zXj/ZqlahlvTF8vHHH/P8889z7Ngx3n//feoUFJCXksKjjz5a5riTJ08yYcwYGpeUUKeoCF0UaVhc8puS/K3q1+fm0mKBhk4X69atu6TzZ0yahFsQcAsCMyZXvFH9Wzh69Cih+ESC1VvjTslHdEhcr+nkqGpMguVcHD9+nEG9exPv8SBbLIRlmYAsx6rO+4kS2WlppGsaXwfDbPL4SPb7/7C5/xn8+OOPMW3pivjggw9ITk7G4XBw//33A1FfqDlz5lSYXD99+jRBl4vrNJ1Zmk68z0ckEmH5HXdgdwgIosx9991f4bUOHjxI9ZLamExmqlarXk7betmyZWTbHTzp8VFPlLj2HJtUr776Km0bN6ZP5y6MHDqUZFWlQHfSrG7d3x1jHThwgNr1GiKrOr369i8XU6VmZBPfsC9JrUfidHtjGytnz56lR+++WKxWXB7fv0Wu5Y/g/fffZ/369Wzfvv0P2yT7NQcPHmTBggUsXrz4nAnnFXfeier2EcwpIRSXiNsXwB1OJhCKv2ivgQuxYcMGBEnBYrUxa861f8iYP3PmzBmWLFnKqNFjfrOX2v93KhPUlfzpPPzQQ9GKWauVG6+77g8b9+jRo1TLyqLI6cInSay66y6OHz+Ow2LlnV/stF/KjtqhQ4foddllVE1N5fprr/1ND+Cnn34a0WpFMhqJM5t50O3BajZX2LLXrX17SnSdRk4ndQoLYz+Wo4YOpZWm08khUNVq5XanC4/Fgmi307xhQ06ePMl3333HbbfdxgMPPFDhj+yZM2cIezzM0nRSSnWZE81m8i1WVJsNtyAgms20c3vQHQ7aNGnCzKlT+eSTT5g+bRq33norJ0+eJDsxkeVOF095vIhGI0GTmT6iiNdkQrfb2bt3L8eOHcPmEEhudzWF49ZjsYvc/otKAa8kcZUkszsQorXDwShZ4W1/EMFoZJ6qo5lMBCQpVolbxWJBMRppYncgGI0sWrSIV155pUxb3yeffIJblmkvSagmEwGnE81oJMNiwWU0YTMYcBgMOIxGwg4HY2SFoNnMrF/p8j766KMEZZlmioLDYCBHEHBLEmvWrMGTkEmVobeTffkCgnGJZc576623EC0Wmtod3KI7cRiMyHY7b7/9dpnjPvzwQ7ySxDKni86/qMqYOX06nTSNzwIhWqkaAy6/nM8++4zXXnsNtyRxudOFy27HZnMQLyjUESWG9O0bG/fHH3+kR4cO+HSdQaUV2FNVjfYtW2IwmYhvOgg9vYS4RpejxOdGJTNK9bS7di9bGRWJRGjatCkGgwGT1YGaVIDFLrJjxw4OHz5M/27dyEtJYfb06UQiEc6ePcvHH3/MoUOHiEQieN1uDCYzBrMZuztMQWF1TDYRk9WBTXbSpGkznn32WQ4fPkz3Xn1Iz65Cw4aN8OQ1pGD0PbhyGyAZTbzo9bM3FEee1cqDbg9dNZ0FCxZw5MgRxo4bT4fOXXnxxRfZu3cvK1as4KWXXuLkyZPUrFMfs11Estp5wO1BtlpjidUffviBDz74AN3loWD0PZTM2Iw3IYPt27dz5513EsirR8mMzaS0H4vZLpHS4Rp8RW3QPX5Ek4kkh4TLl4Q7nEJeQRHxDfuS3X8+suZi586dRCIRbl+yhEYlJQiqi5IZm6k++THMFisAcUmp5AxYRPG0p3AFE/nb3/7GTz/9xFdffRWrsu7d73JEdxh/jfYUjL4HwROVGim85gFUTyDWviZICoXj1hOs1QUttTpZveeh++MvWUvvzJkzZOXmESxojD+rmEZNW6C7vSQ0GYi3Sn3c/jA1atXl2WefPe84R44coe/lA8mqUkCnzl3wBkLYHQJz5l7HgQMHECSFrH43EqrfG6PFRt6w5RSMvge7IF1Ui/D+/ftJSc9E1t3EJSazZ8+ecsd8+OGH9OrbnytHjOLzzz8vs9F3sUQiEdp36oweiEd2epg77/pLHqOiMX/88cdLWgApmpP8UXdTPO0pNE+Qjz766HfP49d88MEHuH2BqLRMXv5/lKHZfxqVCerK+Pt/iYMHD1IlLY3M0s3uiqoh/5MIulw84Yl6rnhEkV27dv3VU/rTaN+0KYtKE5/tna5yptY/88MPP3D1yJEM6NmzQjPfNatX45UkqjmdFGZnX1Ql8po1ayjWdHb4g/TTdEYMHnLJ83/11VdxyzKJikJxXt5vqnT88ssv+fLLLy/5vAuxb98+5s2bx/Lly3nggQcY0LMny5ctu+j1X2owyOMeL18Gw3hsNgqsNpY7XfhMJsaMGYNbFHnS42OmplOSl1fu/J9j6r+ahx9+GE0QcAkCfbt2jb3/X8/tu+++o169ehgMBqZPn37euf/www9IVitfBsN8EQxjM5v57rvvsAsS+SNXkXfF7ThE6bySNhUVt/3www+0ad8Jt+YkweXmissvr7DS9fvvv8ctyyzQnQzTdGoXFPDqq6+yadOmP0wm5lxEIhHMZgvVJ22gePrTSJorVsDx/PPP445Lpfrkx0hpP5bi2vV+17VuW7KEmnUbMmbsNX+aDN1VV4/FLjuxCCp2WWfg4PLFXv9Otm/fzsMPP8ywYVfGJAdDtToxefKUSx7r5MmT9BswiHBiCn36D+DkyZO4vH5yBiyicOz9iIpW4frjtzJ+4mQ8KXnENeyHorkq5V0qoDJBXcmfjltR2Ojx8ZY/iOpw/KG6dkePHuXZZ58t0zZ07YwZOAUB5y922o8fP864q66idYMGl1QJfS6++uortm/fXmEFWpzHg2I08qjby0LdScBkIuBylQt2zp49i8lo5LNSTWW3IPDNN98AcPfddxOvO9FMUf3lN/1BJIOBZIsFt8XChHHjKpzXyZMneffddxnYuzfVs7NxmM086vYSMpnZ6gswWVFxms089NBDTJkyhf6aznZ/ENVoZJqq0VzTcNntDFI16msal/foQYLXyxMeL58Fw7jMZu4vTSI3tjvwOZ38+OOP5GdkkifLSKVyEYogUlKlCqtWreLUqVMIBgO9RImPAyFqWG1YTSYcZjMOoxHBaOQGTcdvMtHY7mCdy4NoMDCptOp5tKwgWizMmT693Ptt26w5dQSB23QXfpOJLLOZEZKMZjTylMfH+4EgQmlSNmwyoxqN+HS9zBg9O3ZkvuZklqphNxiwGQwU2R1kJSVhl1RsqheT1U7/y/8lP7N9+3bcksRgVcNpMqEZjcxVdYZqOuPGjWPdunWx1rENGzbQqPSePez2UpSZCcCEa65hcKlsS39VY9qU6I/qpAkTuLo04TxT1ahZWEh+Whp9u3StMJl0eb9+5NpsbPL4aKJpDB08GLusY9O8mAUFk9WO2S7gstt5wx9gse6kKCsrJjvx8wKlfqOmCN7EaKLZYCAxKYn9+/fTrGFD2igqT3i8ZCoKo0aNoqi4JorTi6I5ufHGGxFNJrIFCY9dwGYTsVqszFQ1mksqDqs1logdedUYAlUbkTtwMaoniCBrhOr1xGgyE8ypTzVBZqAk4TAaSVVV0uLiYonmSCTCiy++yD333IPT4yNc2BTNG2T48OE44zMpnvYUqZ0mIjhk4n3+cn9vPXr3xZteSKi4HYFQPIcPH+af//wn8Ukp+JJzUDQXHTt2QnZ6SUhJJzclhftcHvYEw2TbbKRlZvPpp59Sr1ETUjNzYsYcGzZsIE1VWao7sdscBEs6EMhvRN0GUcmhvGpFJLUeSdUrVyDrbj744AMaN2uJrLuRVZ0XXniBxNQMsvpcj5pcgNkmUK9BI/yhOKw2OxMn/0vTr0HjZgQLmhKuEzWkKahek8WLb63wWXAhfvjhBxYuXMjtt98eNfsJJ0fbXK9eh6I5L3m81Mwc0jpPodqYtci6m08//ZS7716N0+MjFJ+E1Wan6vA7o220gnTR7vOnT59mz549FS4mjhw5gsvrJ6Hx5YSK21Jcq+4lzxuiZqOK00uNqU9ScNVqJEX9TeP8zI8//kjVakXYHCLJaRmx5/qFSMvMIan1CLL6Riv29+/f/7vmURHdevQmoemgqNFmXn2WXqBK7H+ZygR1Zfz9v8bx48d58803K+yc+U/jwfXrUR0OJJuNiVdf/VdP50/lhRdewC1JFLlcpIbD56xiblGvHj00namqhk/TysWM1dLTedAdjWuqO108/fTTPP744yxZsuScJnO33XYb7UuT4zM1nd6dO8de++mnn85bcftLfvjhBz788MO/pHPnz0wAF2ZlMV9z8rLPj1cU6dOjB4UZGUwtXX+uXLGCtFCIWlXzy3VoPffcc3jUaJy84IYbLvnaDzzwAMMGDODBB8t2jX3zzTc0q1OHZL+f62bPvqix0kIhHnZH13qJisIrr7xC41q1MBmN1CksLKPX/EvzxM6dO59zwyESidC+WTOq604KdSfd2rfn4MGDUbm7sfeRP2p1TO7uUhgwaAihopZUGXIbzmDSOY2x33vvPZLVaMfwdn8QpyRd0nV+L9179cGbnIM/s4jiWv+q2H7uuedwx6dTY8oTpHQcR/WadX7zNZ566in0QAIZPWbjy6zBtOkz/qjpxzh27BgWq42iCQ9TNPERTBYbVpuD7777jpUrV7Js2bILGrv+WcyaPQd/Xn0Kx96PL7sWN91000WdF4lEGDtuPHZBxO0P4krMIe/KO/BlFnPT/Pnobi+5g26hcNx6RFWPbS78ERRUr0lW3xspmbGZuIIGsW6ESv5FZYL6/zHHjx//01owLgWXLPOM18c7/iCaw3FRTru/lz179pR5mFwzahTNNZ3lzqh79rZt237z2OvWrsUliqRpGo1r1eLQoUNcd+21jB4xgg8//JCA04nXZGJXMMxrvgB2o5HVq1dXOFZmQgKjVI0Zmk7Q5eLEiRPs2rULtyjygNvDGFlBMxqpZbWhG41MUlRu0HQks5njx4/z/vvvM2XyZAYPHkxaIIhuteK2WpGNRhLMZgSjEb/VSobFyu5gmDWuqN4vRLXD0lWViYpKvtXG3lAcz3p9OM1m9obieM0XIOxycd+6dWgOB25BoEpKCg1Ld6M1q5XnnnuOJ598klqlbaH3uNyIJhO5ViuLdSd+q5W1a9eiWCwU22zYDQYEgwHN4SBL1Yj3+0kURNwmEz1K/+sqNemrYrNxv9tDVas1mjy2WMrtkDepWZPlzqgOcy2Hg1y7HdVgxGEw8JjHy9v+IBaDga6CyN5QHNfICqLRSGogQHZCIvULi+jbuzc1VBW7wcAsVWOoJEerry0W/FnFFE/fREqHa2jYtAVffPEF3Tt3JikU4orSBPoNmo7bbGahpuMXBHRBoJ3Hi1uS+Pvf/84///lPEvx+2rncJCkKo0eNIiM+nqDTiU/TCMkyaXFxsb+L9evXk66oLNFdpNsd0cpnu0ByKMTUCRPKBNpvvvkmAUmig0PAbzIjmy34QwkUFFbHYDJhtNhRA0nkVMknIAh0FkT6iRJhjwdZdeKJTyc9K4effvqJnLwCktqMomjSo1gkPVpNbTIjW+3cpEUXJx0cAlZJxyJq+Kq3JaXDOMx2gWCpgeSLXj+CMWrA+bY/yIeBELLNxvfff8+6devIyq1KSvuxUcmGohZcffXVTJo8GUFWyeg+k1Cd7hiNJtavX88777zDsWPHOHXqFCdPniQ5ITEaFElObIqbGlOeILPnHDJz8tD8iRSNf4j4poOxa94Kd/ZPnTrF0qVLmTNnTpmd8MOHD/Pyyy/HTFZ/pnWjRozWdJ7x+ggIAo899hh33nknW7duLXPcnDlzGFa60TBBUamSncOsWbNjUi7vvfceGdlVcHl8XDfvBiZNmoQzLp3iaU+R3nUaBdVLGDn6ajzJVQjV7ITL648tPn/9/D548CATJk5i6LDh5zTc+fm825YsoV3Hziy9/fZz/g5s27aNW2+9tVTbMIVQUQu8aQX06N23wuPPRyg+KeowP/lxNG+ojAkUwF2rVmEXRGwOgRtumn/J46+6+25kVcPp9rJx40Yg2kWhe0MUT99E0fiHsAviJY8L0YogUVbJuXwBKe3HEp+c+pvG+Zkbbrghqp04fRPhWp0YOWr0RZ33wQcfUFijJqkZ2Tz88MO/aw7n4vKBgwnXuozqEx/Fl1bA3Xff/adc5/8DlQnqyvi7kv9sjh07dsEukI8//pjBffty9ciR5WQC/pvYvXs3L730UmzD/9577qEoK4v2zZrFNkFdssxb/iB7Q3Fk6Hq53+HWjRoxslTGMCBJjBg2jCxVo6vTRZzXW8bg/Ge+//57clJSSNWiSe+fx9y0aRNOUcQjilzWuvUlJRkjkQg7duzg7bff/lPXqX//+98JezzYLBamjh//p1xjx44d5CQn41FUFs2/tNgmwedjncvDG/4ATkEos2799NNPeeONN855Xx9++GGSZIXZqkaCLLNhw4bYa93ateMKTeM5r59kRWXLli0XnEteaipLnS7e9AfxSxJjx4yhgSzzqNtLV1VjysSJZY6PRCIsWLAAo9FIYWEhs6ZPp0lJCVMnTCizCXHq1CkeeeQRNmzYEPv/1143D7sgYRckliypeJN8586d1KhVh6TUjFhByM80adE6JnMXym/InXfeWeEYp06dojA7myZOF1U0jVG/kHjcuXMntes3JKtKPo888sgF789v4cyZMzz88MOsW7euTLfC2bNn6dytBza7gO7yxDS9fwsLFy4kXNIu1gnavlOXP2LqZThz5gyyqpHZ81oye1+HySYgKSpNW7TCn1mdQG5tCmvU/MM2gg4cOMA777xzUdXgR44coUXrtsiqTtsOl120Pv2rr76K7o+j2tj7SGx+BQ53XHRtWq8nw4aPYP36BxFEGZtDYNKUab/3LZVhwqQpeJKrENegD4ruKidbWcn54++/PND9rf/+1wPks2fP0q9bN6xmM2GPp8I2r38n961bh+JwIFqtFVbB/jtoXrs2K51u9obiuMzlZuXKleWO2bVrF2NGjGDqpEnnDXirJCfzsNvL7mCYXF2nWf0GNNd0rlZUfJrGmjVrUMxmfCYTitFIgSDik6QyO7yRSITpU6bgNJvxm8y4zGamT4s+ALdu3UqurrMnGI4mx0wmmtjsGA0GPguE+DoYRrFYeOONN/AoCj1ECcloZJ3LwxWSTCO7g4DJxELdyXNeP7LZTE5yMkmKilMUufvuu3nppZc4ePAgC2+6iZp5eag2G/1lmaqiiG63M1bVaKVpdGvXDogGqLt27aJWQQGJDgd+q5V2LVsCUamLoCzzuMdLN1nBZTLFEpoDJZmMpCR8gkAdUaSBLBNSVRZqOs96fYgGA6LRSHuHwN5QHMudLprZHUySVUSDAc1opLco8qDLgyoIsUDt66+/pnv79tTMy0O0WlFMJkSTidYtWjBm1CjMRiNyaaLbZjRSw2bjHX+Qdg6BeLOZv3n91LLZ6SaIeCSJkVdeicNopIrVymBJwmEwEPJ4cIZTKRh9D4Gal5GaloFS2r4nG424S+9xrsVKotVGtaws2rVuzejSxPUkRWXUsGFAVKrgrrvuilbL+v30EyVSzWYcBgMJXm+ZDZNIJMLy22+nRb16iKJM0cQNVBmyBMXmoEDVWLVqVezYRx55hIbu6Pd6gCgjeRPJ7DkHxZ/E8uXLeffdd3nxxRd55ZVX0C0Wrtd0qlit+IJxpHWeEtVSTqhCz969WbduHSaLDbNDxuyQSExKwmA0YrKJ2A1GqpVKhDg8CeRcvgAtrQZqSiFiMAPBZOIel5urZQW/2UxaIIDT4cAjiowfPZopU6fjTsjAnVULk9VBILMIbyAUW1S98MILeANhZM3JLbfeFnt/y5Yvx+4QsNjsWO0iGT1mUzz9aQRvIsE63QlUqcfgocO4fOBgjCYzFrtI3fqNylXnHjp0iAULFrBgwYJY4vhCfP311zQqqUlqMMiMKVNwenzEVWuK6vZz773/6sJ45513cMsyPV1ufJLEpk2beO+991i7dm2ZxcaxY8dIz8rBlZiFTfVQOG49SS2HUad+I86cOcNdd93F7Nmzf1egcurUKVauXEmvXr1xhpJJ7TgeZyi5Qr3HjRs3ojg9xJW0RdZcPP/88yxYsICVK1f+ptbHBx98EEFWkFQnPXr3rXDRefz48d8kwXHo0CEcokTesOVk91+AoulEIhFOnjxJWmY2wYIm+DIK6dT5/KZG52P9+vXEJaWSnZf/uzXhbrzxRgJVG1I8/WnCNTtw1Zj/nOq+ffv2UbVadaw2Gx0v6/qnt7n+N1OZoK6Mvyv57+bIkSMEXS4maDq9NJ2GxcV/9ZT+ED7++GO8ksQDbg/DNJ3WDRsCcHmPHtTUdLrpOunx8eWSNXv27KFl/frkJCaybOlS8pKTedLjY28ojrou9zm1rU+cOMEHH3xQJn4qzMxkjcvNrmCYLE0rkwTduXMnjzzyCBOvuYY6+fmMu+qqMr81V11xBX67HZ/VSouGFRuh/REUZmayRHfxrj9ISJYrXA8fP368jKn1vxO/HjVZ/DgQwiuKsfjv1ptvxiuKpKoq7Zs1qzDxN3rECKaWFkdMUlTG/sLrqH5RESud7qjXkMtVrsK6IrZt20a814tgtXLtzJlUr1GMXVDQVQ/JgsQ15/BSevLJJ3E4HJiNRmaoKrU1nRsuQs7zxx9/PG88Xq1GCYlNB5Fz+UIk1VlGwueZZ55B1pwE0vMJJySdVxf9p59+Ys2aNTz22GNl7mOVgkISmw4iq/c8JFWvsNNt9+7dbNmy5TfFrRfDoUOHfndHwc6dO1GdbuIKm6A4Pb9Ln/5nIpEIX3zxRZkNq+eff55AXCI2USEYF5UWNJpM1Ji6keLpTyMqGv/4xz9+97VfeuklZM2JK5hIlfxqf1pl9jPPPIM3MStaLNR9Jma7hBTKwGwXqd8o6iF04sSJP+X6Z86cYdmyZYwZOzZmnllJWSoT1P8P2bRpE7mazmfBMNfrTprVrv1XT4njx49f1B/5888/z0033VRu1//38Nprr1GzsBCfzUZnpwufppVr1Th+/DgJfj/DVY3LNI1mdc/dKl4tM5OpqsbzXj8BSSLodPGyL6qdW+SOuhgfO3aMIUOG0KXUYfgGTadPly6cOHGCzq1bY7NYiLNYuNvlpsRmo6sg0qJOtMXn5MmT1MzPp8jpxGu3owkCWQmJFFetSqbdTpEo0qhmTR566CGauT1kmC1kWCzsCYbZ6PGRYragGY084/WxKxgmQZZ56623eO+999i4cSNuWaa6y01SIMA//vEPdu3ahS6K1LbZSRQEhgwYwKhhw5g9Y0aZH+VPP/2UsCyzOxjmHX8Q0RrV2P3HP/7BkEGD8IoiitGI1WDAYzLRV5QQjEaukGVu1V0oNht5aWkIJhOa0UQju50Jisp6lweXycStuotim402DgepFgvFNjsrnG5cRhOS0UhJQUFsLsVVqnCVprNQ03EYjax1eXjG60O22/nxxx+5evhw4mWZZEWhce3aaEYTdoMB2WhkSOlncpWscIUkU90VTc6lBQI85vGyNxRHbVHkrrvuwi0rKEYTHnPUqHFWaTDYTRCxGwxkW6zMVjXmqBodW7emKC8Pv8VKN0EgbLNxzdjypm6SzUbYbGaVy00Du50WdgeFmVnljvv666+RVJ38UXeT3m0GQYfEcEVl6pR/6WsdPHiQ9Ph4SmQFh9lCfOMB0R3g+r25Zty/qkWWLVtGD1c0kb3C6SYYiOodV71yBQ5XGKvNQYPGTfHm1MZbrQVOt5drxo1Hjs/BaLJgNFsI1OqC3RnCV9SGkhmbSWo1ArNdJLP3dYQa9EEzGsm3WAk7RExmM6rzX0FxVpUCcgYsomTGZvzpBUyZMuWClUzHjh3DLojkj1xF1eF3YrYJJDTqT/7IVVglnWrVSxh51RiOHDlCUXEtAlXq4c+tQ8mvtNwikQjVqpcQyGtAIK8BhTVqXnLFzooVKwgXNqNkxmbSu06jfuPmZV7/6KOPuP3223njjTfYtGkTiu4mrqAhmssT0xZ7+eWX8SVlU3XkKpyZtTGazCSmpPHhhx8SiUQ4cODABd2id+zYQaOmLWjasnUZWaOfuaxrd3zp1ZB8icQ3GRhtH2t0OVeNHsOHH35YZuOtR+9+JLUeGf2+1OnKtdf+fhOQCxns/FYOHDiAQ5QpGv8QBaPvwWZ3sH37du655x7ee+89br75Zu68884/TXvvUjl06BBFxbWwWG2kZ+X+IUH7pbB///6LllCp5NxUJqgr4+9K/rv55JNPSFSjRQMfBEJIdvufdq133nmHm266ib/97W9/2jV+5rnnnqOotHPxcY+X3KQkICqJddddd7Fw4cKLkmnp07kLHTWdhboTwWgk6HbHDLQvRJ2CAm7SnLzrD5KgKLzxxhtANMHkliRyZZkUi4X1bg91NZ2bro96Oxw9ehSrycTHgRCfBEJYDQaefPLJS74HP/30E/fffz/PP//8OWOO3KQk7nN5+DwYJllVef3118u8/sgjj6AKAqLVyqQK4vU/m7X33ovqcKDa7YwuLWgBCDidvOD181Wp3EZFBp8bN24kKElco6gEf1UE9eSTT+ISRfKcTvIzMi85yfbss89iNJmpdvU6akx5ArNdLHfvfsmoUaNQjEbsBgPdBZH+3S69WCASiTB/wSLqN27OnLnXEQgnUGXIEoqnP407nFKuynjXrl0899xzF1108mucHh9VR6ykePrTOAPxMa+Xn9m8eTOy6sSXnENyWsZfGlPdeNN8wokp1GnQqFy3J0T12e++++4/JNl55swZWrfriOz0IMoqjz322DmPTcvMIa5udxIa98cfjPtDCh4aNGlOSsdxFE/fRCC7+JINVS+WU6dO0bBpcxSXD0FW0HxxZPW9kZwBiwiEE/6Ua1Zy8VQmqP8f8tRTT5Gv6+wKhlmoO2lcs+ZfPaVzEolE2LhxI9dffz23LF5MWJYZpDtxS9IfkqTet28fbllmrqbTQJKpVqUKX331VbnjPv3001gQ+3EghFCafP01b7zxBk5BIMlsRjGZ6NS2LYN696aepnGFqhJwOmM6XY899hipispdTje1NJ3r585l6dKlNNB0RslKLFF6naaTYLMx+Re60sePH2fz5s1lDPfOnDnDhg0buO6661i4cCFPPfUUmiAQZzJRxWKlhs2G02jCYjCgWK1oNhtxskznNm1iu8Y9OnRgnqZH5RokiY4dOnDffffRpjQx+5DbS80qUROPrVu3MmrYMJYsWcKZM2c4ePAgis3GYt3JWFlBMZmYMGECAaeTYl3HazLxWSDEAk1HNhpJKtUy3uqLBlmy1UqxpvFVMMxsVUczm2kmiLzs85PuECjMzKRVkya0qFuX4VdcgdvhYJKikmK2MFqKSnMIFgsBVcVsMNBXlPi6VMLjdV8g+rkZjdwwbx6RSITt27ezbds2tmzZgmw0sszp4l6XG4fBQJ5DQDAaybfZCLlcHD58mJFDhtBQ05iharglmYULF5JptbHZ66OJ3Y5mMNLU7mCz14fXZKK+zY5qNNLKETUVUWw2xsgqTe0OgiYTU1UNtyyX+b4dO3aMdm3acFmp5MgtupM6Njvp4XCF37eFixbjECTMVgfFmoZHUfjwww/LHHPo0CHuvPNOVFHEYnXgyqqNIGuxxQJEq23csswVqkaqojLvuuuwOCRsiodASSdsDhG7IFI0/iFKZmzG6Y/nrbfeolbd+pisDkxWBwaDAYPRhNFsxZmYh9nqoHv3HjhECYco0659B0ry8hA0D0UTHyGt8xRy8goAGDTkCvzZNUlsMQxZc5arEn799ddZuHBhmTkfPXoUm0OgYPQ95I9ajcFowmETMFlsNG/ZKnbcjz/+iM0hUjz9aYqnP43Faovp4X3//ffMnz8fi9UWe91qd5yzWubAgQNMmDiJceMnlEkqvvLKK6ieAOndphPIrcPoq8+9kOnYpRvJbUdTMmMzweptuPHGG4Gobr1NkLEICmaHTHxyGhD9u+7YuSsOUUbRnLz88ss899xzLF26tIwb9alTp3B5/SS1HklSi2EEQvHlFmU/f4ZZfa7HbBcJ1+yIrLlISE5B98ehOd2xe7xw0c14knNJ6zwZPZDA448/fs739Fs5evQon3/+OQcPHmTt2rU88cQTvzl5fc34CYiKhiApDBg4CMXpIVzQCN3trfCZ/p/AkSNH/u0yW2PHjcchKQiSzIpztL1WcnFUJqgr4+9K/rs5efIkWUlJdNF06mt6rCvwj+add97BLUkM0nXCsswDDzzwp1znZ44ePUp+RiY1XVHZwtuXLLnoc99//31GjxjBjTfcwIEDB2jWoAEJVivrXG7GaTr9u3e/qHF27NhBSiiE3WKhddOmhN1uqqSk0KpJE67TdMYqKleUrnNmqhpD+vUDokl0sbRAZ43LjWg0xuKki+X48eNUTc+gkctFqqoya+pUTpw4Qde2bVEFgeZ16/Ljjz+yceNGdFFEdzjKGP/9TNjt5nGPl/dLjTb/ilb7Q4cOlfObqJqWxvW6kyc8XpyCcE6Dts2bNzNp4sQKDa2//vprXnnlFY4fP37e63/xxRe8+OKLZQqSenbsiGpzkNJhHFl9rsfmEM/bWfzhhx/ilCTcFgsGg4E+ffpw5swZps2YSXp2FXr26XdBY8y1a9fiiksjvftMPEk5dO3WHVl344lPp1ad+pdcaXzy5Ek++eSTc1Y/X3vdPFRPAHd8BvFJKdx7771lvh/1GjUl7bJJURmRKnW45557Lun6fxR///vf0bxBqgxdSly97rRo8+c8w37m1VdfxRVKpsbUjWT1mUdqRvY5j929ezd9Lx9Ij959Y75Lv5dOXboTV7c7BaPvwRWXylNPPfWHjFsRZ8+e5fPPP2f37t0EwwmEilrgScrmyhGj/rRrVnJxVCao/x9y+vRpOrdpg2yz4dP1Mkmf/zRunDePOKuV9kI0YTi7tEJ1kO685IDllxw7doy3336bjRs3UlRaOfqi10+y31/h8SdOnCAtLo6+pUaB7Zo2BaIVqtu2bYvtnN5yyy30L9U8vt3pomOzZpw8eZLFixczZdKkMk6skUiEJbfcQos6dZg+aRKnT5/mpptuoqum87zXj2Q00srhQDIaqVqlCm+//TZvvfUWDzzwQKxd6euvv45VWEJ0V9snSfRzuXBLEosWLUK2WFjudNHeIeA3mfCaTGgmE8MGDuT9998v09I0ZvhwLlNUXvD6ybZYSBQEpk+diluWmaCoFGsak8eN46OPPsItSUxWVIo0jfatWkWrDMxmEkxmWjsEOgkiVodId1nhOa8ft8nEe/4gy51Rw8J4s5mGdjuyyUS+plGQk0M1ReWLYJjpmk5IVYmz2VCMRiSjEdnhKBNkPfXUU8gWK23sDuJMJmrbbFhKJUEKLBacRiP5skzQ5UI0GvGYTHRwCGTFx3Pq1CluuuEGRgwZwvbt29Ed0cTyZ8EwuslEYkoqVsWNFMrAZHNw1VVX8d133zF39mwG9+3L1q1buf766+mrqDzn9XO5KJFkNJJnsZBmtqAYjfzN6+dln59ESWLKlCkkWa3sDcXxui+A22SKGkl6vLHE38MPP4zqcCBYrShWK61FCdVoQrTZeOA8BglHjx6NuRWfz6ThH//4B4sXL+a6664rZ8QC8O677zJ37tzYbvjdq1dHNYHtDm6cv4CmLVrjzalDsKQj3kAo1hp6/PhxElPTsQoyhtLq+PmqTr6s8Pjjj/PDDz/EKnW2bduG7o+n+uTHyOg+k8ycvNgYM2bOolef/rzyyitl5vXiiy8i627ianVE1t289NJLsdcW3bwYu0PE7hBZuGgRL7zwQjkX97Nnz5KQnEpc3e7E1elKcloGZ86cYfDQYZhtAnbNh8Uh4y9uT7CkIykZWWWC0JMnTzJr9hx69OpLUkoaweqtCJW0IzUji7Nnz/Ltt9/ywAMPMHv2HOo1asao0VfHAv7du3fz5ptvlgmcp0ydjp5Sjaze87BrfmqURDcIT5w4gdlipXDceorGP4TV5uDw4cOlbt5p1JjyBGmdJxOXmIzuiyNcvQVOjy9WLfH9999jF0RqTN0YrWixWMstPKrXrEOouB0JTQYiKipJqWmkZ2YRyKlN8fRNJLUeSev2HYFoYvza6+bRvHU7lt9xxzm/V7++15OmTCOUmILbH6Jzl+7nrCp59913cXp8KE4vgqITyCrGHZ/OsOEjL+paFbF3716+/fZbmrduR2qnCdHq7+otue222y588v8A33zzDYKsUjT+IaoOvxNR/n1mj//rVCaoK+PvSv77OXDgAPPnz2f58uV/SJfN22+/zcyZM8to/t54440MLi3+WKg76dGhw+++zoU4cuQIGzdujBWyHDlyhAceeIBnnnnmnBuj3377LW5FoYsokSuKXN6zJ3feeSeFssItupMBisqgPn0uaR5ff/01TkHgWa+Pm3UnIV2nmaZzi+ZENBppoem4JYmXX345ds706dNRTSb8ZjOqw1FhR9j5eO2118h1OtkTDPOC10+C18ttt91GI03n/UCQzprOpNKin8OHD7Nv3z4ikQjPPPMMy5cvj8k5xHu9POT28o4/iFsQysWX5+L06dPceeedXH/99RdtgnwpvPfee1TPySE1GGTNOTyMLsTZs2cvqMe7YcMGZM2JLyk75kcDMH3yZAodAvGCjM0uMmnSpAte7/PPP+eOO+6gQ4cOGAwGatWqhTOUQu7AxQTy6jN23Pk1wCdOnES4fm9KZmwmoelghlwxjA8//JAtW7aUq8x94403yKtWnczcqhUm5w8cOEBKeia6L4zbF6hwTfTz+xckhVCtzrji0rj+hn/lHXr07ku4ZgfyrliGM5hY4XX+HTz++OMEMqpRPH0TmT2vpWrRnytTtGPHDlS3n4Ix95LcdjT5hTX+1Ov9mj179lBUUgtVdzFq9NX/tiKPf/zjHyxatIi1a9f+qaaqlVwclQnq/8f88MMP//H6kllx8TzkLpVVsNmJt1hYpDuJk2Wee+653zTmd999R3p8PJm6jldVCbo9dNOdFGgaY0eeOzmyb98+Zs6Ywfz582OVf0GXi3yXi4DTyaeffsrbb7+Np7SlKktVWXLrrZc0twMHDpCVlERQkhBLTQ/HywpeswXFbscrCDR0utAkiTZt2qA7HIRlmV6XXUYkEuGKyy+PyUyMLpV72LhxIyW5ubjsdiwGAx8EQnwQCGEzm1m4cGGZhN/BgwfJz8jEazIxTJKZp2r07dqV7du3M2bkSG677TbOnDnD6tWr6eTxRHWhdRd2k4ktPj8b3F7sRiPDRQmHxYo7rzHxZgsLNSeywYjFYEAyGtGMRh50R8+vp2l07tyZ4oICVJMJs8GAZDaj2mx8HQgxXdFQjUZyLVbcDkeZqtGhQ4eim0xIBgNxZjMfBULMVTVyLVYCZjOdOnXi6aefxulwsFR3MVpRyUtNZeSQIdTTNCYpKm5ZZsFNN6E5HHgFgT5du2IXFfJHrqJkxmYc7jiCZjPZycnce++9TJ8+nbfffpuvvvoqWnlhMpFoNuMymfGYTFgNBnSjkVSzhfaCSKI/wN69e1FtdvpLMsV2B16TiStkBbeisG/fPvbv349f19ng9vBhIITb4WDevHk8/PDD523D3LRpE5ogoJjNBGSZubNmEYlE+Mc//nFBY6CL4cSJE7EA9uqrr8ZiE7DbRSS7nU8++YSffvqJsWPHonjjKJ7+NHGN+mMwGDAbDAhGY5kKf4huyvTudzk2h4is6RfV6jryqtExaZK4xlE5il9y5MiRC1ZerF+/nuKatenctTt79uzhwQcfxBWfQcFVq/EVtcGZUw+T1YFDcTJr1pwy544YNRpfRnUSWw3HaLGR2Go4RRMexiHKvP/++3j8QcJ5dVGcnjI6fg888ACSquMMJlKrTv3Ywnf//v1YbAJKQhXimw7CbLFw9OhRzpw5gyirZPe7kZzLFyBICi+//DIurw+b6qH6xEdJbnc1istHZq+5pe7ODVm7dm3s3jZv2QZfShUkVwCz1UZCcmqZTpPvvvuOK64cQeduPRBllZQO1+DOroPkS6Jw7P2Ea3emV9/+QHShumjRIu69996LNjdas2YNzvgMci5fgJKUjxLOpHe/yys8tmPnriQ2H0qVK5ZhU9wUT99EtTFrkVTtoq51Pq4ZNwF/Tm0ye16L7ov7yxYO/2l89913OESZ/FF3k91/AbrL81dP6b+aygR1ZfxdSSW/5P3338ctSQxXVVIUhTuWLQOikhtxsswi3UmhprHgdxTY/BZOnTpFjSpVqOd0kalpjD+HXvDzzz9PoiCQarFQ3WrDabOxcuVKdLOZejY7osl0ySbyH3zwAXGyzK5gmOe8fgK6zvBBg6ielcXYq65i3bp1fPLJJ+XOe+mll1i8eHG5rsAL8cQTT9CmcWMEsxm/yYTfZKZGXh5z586ld+n6aIyqMWLIkDLn3bxgAcmKQmeXi5Dbzf79+6OdqKKI3WJh9rSLN0Ib2q8fNTWNPqpGgt9fYVdeJBJh//79f+g6/NNPP+XGG2/k8ccfP2/ibtu2bXg1DZvZzLABA855bGFxbTK6z6RkxmYCWdV56KGHALjvvvtQRAW35kPRPNx++7KLnmMkEmH+/PkYjUasokq1MWtJbnMVHTp3LXfc66+/zuuvvx7repU1J/E1WiJrrjJr11+f5/EHSek4jowes5FUrVyV9Pz58wlWi8ryxTfqT/8Bgyoca/Xq1cQXNqVkxuZo3F2nQey17777jsbNWxKMT2LajJn/9m64nzly5Ag5efl4EzORNWfsM/ozmT5jFoIok5CcWk76pJL/Db766iuKa9UjEE7gxt9gbP97qUxQV/KX0rJRI5raHSzSdBSDAafVSlZ8PKvvvvs3j3nzzTfTRY+a9M1Qoy19ixcv5v7777+kXbGJ48YxrDTYGaVqMYOIrVu3MmHcOO67775yP1g/VzA8++yzFf6YnThxgqkTJ1IjP5+g3c4XpfpxiWYzWRYLK50ucixWOgoCDe0Oiq02Pg+GCckyM2fMIKhquM1mZqoa8aLE2LFjYxWM33zzDbLNxv1uD4t1Jw6jkZ5OF2FZ5t5ftCa9+eabpa2IToKSXOGP3aeffopTFEkwm9GNRhwGIxvdXm7QdOxmM4LRSK5dwGex4VE1UsNhGkgyXwfDPOByEzCZ6OQQWOF0o1kssaTuendUC65aaTV0vNmM12Rik8fHnmCYRLMZXRT5+OOPo9rYdju36E7q2+ykmC18GQyzzBnVqh4hK6QmJSFarQgWC6rJRLLFQp6iENajLuV7Q3E09Xh57LHH+Pbbb/nss8+IRCLk5lfDW9Cc5LajMVlsbPB4yJYk4kSRkYqKW5L48MMPCTmd/M3rZ3cwTIIgMm7cOPJSU7lGijpn6zZbTDvvnXfeoWrVfFLSMtBlmaDDgS4ITJo4EV0QcJnMFFttPO32IttsvPzyy5w5c4YPPvjgnAYfuUnJNLc76CIIPOnxkSyKJASCOIxG7EYTt91yS5njI5EIhw4dKvPd+/bbb+nZpx9NWrQ+p5P30aNHMVttBOt0J7HlcKwWG4sWLaJmfj4NFAWLzUHOgEXENxmIao2acJoMBrp37x67ViQSYeWKFfRo144FN910wbbCn7nnnntwhVNJ7TQRZzjaZncuHnzwIXSXB93tjblur7zzTlw2G6LRiM1oZOmSJSxbtoxg1QZRrezWo3B44lGTq5HRYzYldeozesxYuvfsw5tvvklB9Zpk9b2BtE4TkE1mqtrsSDYH6Vk53HHHHYQLGlMyYzNpXaaU0Z5Oy8olq++NUf26uLRYG9qZM2dw+wIktRpOUoth+INxsXv01FNP4Q/F4Q2EohJAGdmkXjYJT9UmGIzGqDSDrOFMq05qpwk4ZL2M7t+pU6eYP38+ku6NVTcUVFBN8cEHH6D74yievomC0fdiFWREWaGwuBb79u3jyJEjhBOSCBU2x5Ocy+Chw8qNUREzZswgWKtztMKl2RC0tBrUqFWvwmN797ucuDpdyB+9BpPVQUr7scTV605B9RIgWt1zy623MWDQEF544YWLuv7PHD9+nCtHjKK4dn2WLK3YAf5/ldtuW4JdEFF155/aGvm/QGWCujL+rqSSX3LrrbfSt7SLcpnTRYfSbkuIGsL3aNeO+TfccN61xhNPPEFGXBxVUlJ49dVX/5B5vfPOO6SoGnuCYf7uC+BRFCBaFNOiXj1CLhdjR45k//79OIxGXvcF2B0ME7TZKMrMZFVpp2kTu4PG9etf0rUjkQhd27UjXlFwCQLLb7/9D3lPFfH222/jl2WuVTUcRiNPeLws0V3Ee718++23pIbDpGoaIbe7nORAcU5OrHCmqdvDww8/DERjtgv5f/yasMvFVl+AvaE4qrpc5ZL6R48epUbNOgiSii8QPmcF76Xw5Zdf4lEUBmg6aarKLYsWnfPYmnl5LNFdfBoIkaKqbN26tcLj2nW8jHCty6gyZAk22YnJbKZdh05MmjSZcP1eUam6Ot2IS0qlYdMWl2Qgfffdd2M0GjFZrAiSUi7OGzh4KLo/Ht0fz6AhVwBRqZDly5efNyl65swZzBYrReMfosaUJxAklW+//bbMMcuXL8eXUZ2iCQ8Tqt6aUVeNqXCs999/H1l3kdD8Cryp+UyYNKXC4/5qjh8/zssvv1zGKLKSSv5MGjZtTnzDPuRdcTuqJ8D27dv/rdevTFBX8rs4fvz4Je0qfv/990ydNIkJ11zDvn37OHToEHlpadgNBjKtVp72+Giu6cy6hJ3sX7N69WpKNJ3t/iA9NZ3RV175m8aZP38+jTWN13wBmmka18+bd97jjx07RrWsLOq7XGSoGhMrMNwYc+WVVBUlHAYDksGIYjBgNxgYIsok2Gw0F0WcRhN7gmG+DIYxGQxs8njR7HYcBgOPuL1MU1Q0mw2f3UEjt5v0+PiYScSmTZtIDQaRHQ46iVIsiG7XuHGZebz99tvMmzePBsXFmIxGqqanl9M4a9msGSU2Gw+6PQRNJgSjkRo2G5rDQVgU2RMM86ovgE+NBgdBl4suuhO/2UyeIOC0WKmakoJgseAwGKhvs9NHlLjP5cFpMvGMx0dnUUKzWLhaVljpdKEbjPSWZCaXaqoVlOrXbXR70Y1GZJMJh9FIK0lGsVhIMJvpKoiEzWYsBgN7gmGe9/rxyzLVNY0RiopHUcqYSnz55Zfcd999OAQJwSZQ32ZjmdOFZDJxfWmA39PtZvTo0cTpOtNUjYfcXlyiyO7du6lZpQqrXW52B8MUOZ1s3LixzH1bu3YtzUqD/TucLtx2Bw+6PXwVDBMym7EaDMRZLKhGI4k+H4mKglOSeOaZZ8p9X7KTkgiaTBRZrTzr9dFAFNFMJj4NhHjC40U0GpEUncTUDHp3745mtWIzGgm7XFx//fWcOnWKOg0aEa7ZkZT2Y7E6RHKSkhjcpw9Hjhzh1KlTdGnbFlPpJkRdWUW1OTAYTTz44IOodjt7gmHm607MNiFqqChqdHaI2M1RjfF+/fpx7Ngx1q9fT5qqslh3kq2q3P2LTabHHnuMBK+PJL+/jJELRBc3ty1ZQuv2nbhtyZJzPk9OnjyJQ5DwVW+LklgVq03g5MmT1MrPx2My8UnpPfHIMt9//z3JaRk4Q8lY7AIWu0h808H40gtJSc8kWNCUhOZXoOouhg67EldcKi5J457Sz62OrLBq1SpefPFFNG+IrN7zCOY34oorR8TmU71mHRKaDCRv2HIsgkooPjG2WfTuu+/SpHkrmrVsU6519bvvvuP666/n1ltvxR+OJ2fgzdSY8gSi7kULJJLZ9wZMNgHBm4QaSqX/wMFlzn/llVdwhVOi+nC955GWmRN77amnnkJzunGIEnEJyaWyGmnlZDW2bduGLzGTkhmbyR91Nx5/sMJ7/ms+/vhjFN2FmpSP2SYgKto5DUz27t1LXkERVpuNho2b0rBpCy7r2iP2nJk951o8STkkNBuCrLkqqzT+QCKRyF9W7fP/icoEdWX8XUklv+Tvf/87fklirqZTqGncMHfuBc/ZuXMnb775JmfPnuXIkSNogsB6t4c7nC78Tucf8qw+cOAALkniNt3FKE2ndqmp+JC+femn6bziC1BF03j00Uepmp7OWFVjudOFS5JoUq8ebRwC95QWl2QlXLpB2NmzZ3nvvff49NNPGTlkCFXT0hg9YkQsUR+JRJgzYwa18vIYd9VVF1VVfPToUV5//fUyBRxr1qyhnqrS0SEgGYx8GAjxmi+A3Whk//79HD9+nA8//JAPP/yQCRMnMWrUKB5//HFOnDjB4D59aKfp3Kq78EpSudjs0KFDrFq1ig0bNlywmOmyli3poGlMUTW8qlrO9HvlypX4s0sonv40CU0H0rlbz4u9ledk9erVdCpNsK9xuWlU49zSC8W5uSx3uvgsECJd08pJ60FU+iQ/IwNBkKLxXCCFYElHLIJK3z59kDUn4ZJ2UYPyZkNIbjsap9t7Scn8LVu24Pf7sdvtrF+/vsy1rTY71SdtoPqkDVht9gt2Sv6Sq64ei+YN4Qol0blbj3Kvnzx5knadOmN3CJTUrndeU/aXXnqJ/gMGMX/BwkvWua6kkv+v5FStRmbv6yievglfal65tfufTWWCupLfxE8//USD4mIsJhP5GRnldi/PRa2CArppGgNUjczExFhr+ezZsxlQWq08U9UY1Lv3b57b6dOnGdS7Nx5FoUW9enz//ffnPf7777/niSeeKLfbfvz4cfp07kLY5aJnp8vOq+W1c+dOgm43AZOZPcEwr/kC+DSt3HH1qlUjx2IhbDbzkNNNA5sd2WjEYTLRvlUr+nfvjmq1MkxR6aWqOG02gk4n+dnZxJnNfB0M8zevH81kjkmj1HW7yzhg37xwIemShM9kYqnTRV1ZYeqECeXmsmrVKurqTr4Ihhmu6Qzs1avM63np6cxRo5p62RZLzFyxr6YhWK3c5XQzVlFJ8no5cuQIe/bsYdmyZaxZs4aVK1fyxhtv8MMPP6CU6ky/4Q/Q3O5ANRqpJYjsDoZp5xCwmkw4bTbspfIgWaLIsmXLOHToEPFeL00cDuLNZmSzmWuuuYb0+Hi8moZkNvOyz8/eUBw5Fis2g4FpqkYrTaNPly7ceeedTJk8uUz74Kuvvopblqmj62h2O9lpaegWC0GLBY/FirNUgkQxmVBNJlxGE7rJRFjTuK80Effkk0/iFEWSVZV61auXC9ZeeOEFkhWFgaKEozSpPlJW2OoL4LbZyLBY6C6ItHUIZFss7A6GuUN3UZCZyY4dO2LJpUgkQkooxBg5Wq0tGgxRHXCDge3+IKtLzWWy+88nrfNkzCYzXYToxkEPUSTBbmdQ7964vH7yR66iePomHJqPGzWd1qrG1SNGMGbMGIpkhWtVnXYOgb2hOJY6XSS4PZw5c4bkYJDRms5QRUURFIqnbyKx1XBSUtLYsGEDs2fPxmg0UlBQwJDBgxmnRI1Gp6saI4cO5dixY9x6663YrVbudbpZ7/agi+JFS0r8kqNHj2KyWJHCmaR3nYZN87Fu3ToG9u2LYjTypj/IPS438Z6orMGxY8fYvn07Bw4cYNOmTXTr2Ye5183D7Q/+Qt4ljE2UsdhFJLOF3rLCw24vYVmOVS4vWbqUajVq0X/g4JgT+tdff43u8mBxyFgknYRmQwjl1WX1BbQCT548SVJqOsGiFviyiikorI4oq0iai2rViwkWNie7341IoQyqDFmC6E/BKiixanEoddhu2wFZjzps/2w8GIlEcIgKRrMVi6hitTtYsWIFGzduLLcAPnDgAKrTTWKLYQQLm9O8VduL/hz27NnD3XffzdKlSys0sv3pp59o2aY9To+Pnn36nXMhWr9xc9JLW0vjqrfkjovUwf7/SiQS4Y47VtC9Vx/uvXftXz2dSjh/gFz5rzL+ruTCvPfee1zeowdjRoy4YCz+38LTTz/NwF69WLxo0QUTmbfefDPe0nixY8uW/OMf/0C127lddzJQlLCYzb8pHqqIF154gaa1atG1bduYX0nH5s2Zr0U7Sts6XaxYsYJdu3bRvlkzGlavznPPPcfOnTvRbDaSLBbCDoHZ06f/5jlcN2cO2YKIZDQiGo20bNQIiHbKVVU11rs91NE0brrhhvOO89133xGXmIw3IQPV6Y5V77366qsIRiPTVY2aNhu60YjbZKJAELi9tHL78OHD+AJhXAm5uMwWUmw2qqSn8+233zL6yitp17gxTzzxRJnrnThxgqrpGbRwusjTNEYNHXre+f30009MHj+ewX37VhgHrV69Gl9GITWmPkl8/V706N039trZs2eZMGYMKf4AxVWrlityORc7duzAK0ncWGr4OWHMmHMe+/LLL+NWFESrlQE9e1a4CbJ69WqaOF3sCYa5QdNRTCZGyCo5VhuJPh87duxgwYIFGE0mqk9+jOJpT1VYrXwh9u/fT506dTAYDMycGZXKOP1/7J11nFRl+4fn1MTp6Zmd7V1qqQU26O5GQEJKOkRECUFABBVREQwUEANRFEXCAoMXCwMDERtBBBUVA15EUWCv3x8zzutK2+/v3evz4R9OPefM2Zn7uZ/v/b0PH8awvZTrPoVy3adg2t4z+jsoKSlh06ZNPP/882V+wWWU8Sdw//33o1teAmm55NcqOu2q6D+KsgR1Gb+Ja6+9lnaWza5ojHMtmwtGjTrlMYcPH0YUBD6OxtgdjeHzeNizZw8Q7yIctm0aBgLxhn3jx9OtbVtumDfvT1WCff7556SFQjTyBwho2jGBwueff84111zD4sWLj7uyeujQIY4ePUrfbt0ZrhtogsB8r48RukGd6vnH7H/dNdcQSCSoz9N1cmWZHdEYS30B8suVA+LJr/NHjGDcBRcklQMXjh5NqixTQZaxRZFysRh9LZu7fH7CmsbWrVuT1+jbvTtTDJMbLC8VFIWmDRoctzHMggULaGnHm4xcbNmc07VrctsPP/yAmrBNaOiMq7eb6QarA0HyLItRo0ZhSxJVZYU6qkbNatV47LHHeOihh7jqqqt47rnnWLJkCc8//zzLly/H63TiF0X0hFo7v0IFJIeD8pKEJTkJSzLbojGW+PykWFbyWe/du5crrriC8jk5eGUZTRCYaVqs9AfRBYGObg+XmRYeh4DgcNC4bj2mTpp0wq7NnVu3ZmYi0X6OqmEqCn6Xi+cDIdq53TRzudkWjdHBo5IlSTwXilDP6aJCZmbyHM8//zy5sRhRr/eEXZ3Hjh6NKYqsC4Ro5HRhiiKaLGMqTixRZLxuoDscREWJl0MRihQnAVkmVddpUqcOqtOJT9eRBIFt0RivhyKogkCeaeIWBCSHA58gIkoKhZPWUGPsPYiCQNdEgrqXqtFP1Yj5fAwcPBQtmIo3Kx/D6ebDaIxrLZuMQIAsVaXQ6eQen58UUeJef4DWmsaQ/v0B2LFjB0P69aNj69Zotp+0ZgOxQjGWLVuWvNdHH30U27YxDAPT5WKI7SWcUIQ3ad6KUMVi7NxCKnh03ghFcMnyGZdT/kz1moVktBoe76pdrwdTp07lhx9+oHGdOsiCgO3xnNL3evDQ4QSzqxCs3gxF86LoPir0vpxK/a5Bk2SqZmVx3oiRTJx48Ql98OfMmUOssB3B/JaEarWj6oiF+GJZp1xh/uCDD7BDKRRPW0etCQ/idLn5+uuv+eijj/jss8+IxtIJZlZEVFwoupfM9hcQrdMNxa1y7733Mmv21bTt2IXbbrudDz/8kK+//ppJl0xFcTrxB0OIipsaF9xNhV4zkZyek04kXnnlFbr3PIfzzr8gqfx+9913Wbp0aalmryfj7bffZubMmSxfvjz5PT3x4klEqjchf8xdBMvVYMGCBcc99pprr8MXyyHWoCe65eOdd945rWv+f+W2227HG8smq/0YrGAs2Vy1jL+PsgR1Wfxdxm9n3759hCyLSyybXpZNi3r1/u4hleKGuXNpUKMGY4YP/1Mm3/v27SNommwIhvkoGiPkdNK+RQtqVa1KSJS4yIiLUI6nbv2jeO655/DrOpW9XipmZvLNN98cd78PP/yQWbNmcd999x0z51qzZg19unVjztVXnzKJOKRfP0xB4MlgmHcjKdiKwkcffcTUqVMZkRAwTDMthiZizBMxY8YMQtWaUDxtHRmthicVyGvWrKGxL26x8lAgSEiSuN3no5JlJRuAv/766wTScjFUk7G6QVAUyZQkbKeThQsWcPDgQTZs2FDKLmHz5s3kWvEKypd/YZHyW/nxxx9p1bYDoiiRXa4CO3fuTG677777qGKYPBEM0cajonk0brvt9tM672OPPUavzp2ZMW3aKRt+/vTTTyftVbNixQryLZs3wlGG6QYpiebuawJBMvz+5H5n9zqHQEZFQjnVaNy85W+akx86dIj+/fvjcDg4++yz+f7773nmmWeoWLkaFStXO6H94KyZM8lNSaF1w4bJfEEZ/z188sknzJgxg5tuuukPaVBbxl/Lzp07eeGFF/6Wz64sQV3Gb+Lqq6+ms2WzOxpjmGVx/mnaaDQoKKCzZdHbtKick5MMdl555RWWLFnCihUruOmmmyhvmtxg+8gzTRbfeuufdh8LFy6kS8JP7gbbR/vEaj/EFZg5sRg9bJs6ls2Anv8pIyopKeGi887DKUn4DYM2TZrQyO0mX1Gok1AijBk9+pjrlZSUsHjxYjLCYTyCiE8UeT0c5WrLS93q1Y87xm+++YbPP/+cTi1bErQsenbtyhdffEHvs86ibrXqLF26lDfffJPt27fz7bffUiE9HU9CVWB7PLz22mvHjGHVqlVcffXVVMzMxFIUIrZdyiPt66+/Rnc6edAXYJimIzocDOnbl5rlK3DZ1Kk8/vjj1PUHeCkUwSeI9FA10tweQi435xgmqiDQxhtvdrng5pspqlyZKYbJU8EwFS2LNWvWoEkSmiCgOAT8spO3Iinc7PVRq2LFUuN988038bvd6A4HHoeDuk4nsy2boKKgJhoyuhwOOnk8pMgK0yZP5sCBA4wcNIjmtWsnk6n/+te/4ol2l5tHAiHKyTLVFAV34ryqw0HvhC3KIE2nQFH4JCWVIZpOfpUqyeaEXrebhV4fDwdCqIrCxIkTk2qVn3nllVfIMk1qO530VTWmJp7JE4EQA3UDXRDwCgIxUcRONJd8N5LCu5EUZIeDcZqOIit4JJlKikKaJNE+oXCeYdpETRNdkjBcHpyqiSbJWJKEnkheBwWRApcLU5Kw3W6qVKhAebcbnyBQ7HRhOp14ZJn3IikUKXH1ukcQCEkSlZ1OMiORY5LIa9eu5fwxFyR9+9atW0f13FyKKldm1qxZiIKAw+HAZ1msX7+en376CUEUKZryKEVT1yIpbnweD9MmTeKDDz5g4OChnD9m7DH+219//TVDhg2nQ+euvPDCC0B8ceumm26ia9duqIZNrKANuuUr9W4fPXr0tALnI0eOMGbMGMJ+P95yRYhOD9VH30HBxJWIihtBcuLUbWKN+mJ4g8c04Dty5AgLFy7EF8uhfK+ZuO0wuuVj4sWTmXbpdIrqNuSSKdOOq+r4/vvvCUZSSG10DtFarahdv1Gp7fv37+eZZ57h6aefRna6SW0yAE8ok/SWQ3HpFlYkk5wuE7BCqTzyyCO8+eabGL4QNS+8l7SWQ5DdOgUTV1J50PWounXKZ/FLnn/+eXTLS2qNJng0nfadujB//s0nfKY7duzA9PpJqXMWvlhOsvv5uYOGkNakf3wRoag9Y8eOZdasWTz11FOlji8pKWHZsmVMnnzJGfka/n/l3EFDkosvsUbncPGkSX/3kP7nKUtQl8XfZfx2tmzZQrmEIOD1cBSvpv3dQ0ry2GOPkW2Y3O0L0MKymTx+/B96/umXXILmdOISBHp6VB4OhNAEgXG6iSXLXJV4LqNMixkzZpz6hL+DL774gpdffvmEwg2IxzV79+495vf++eefJ6rrXGXZ1LIsZs2cedJrbdy4EVUQudsX4IVQBMvl4rPPPuOtt94iYBi0CwTxa9pJvbe/++47graNEcoi//w7CVZvTv8BA2lSXEzU68VyuRhiWuSbJlVycqiQmsqUiROTY//3v/9NMJyCpXsJiSKPBkLsisbIlWUsl4vctDRqeH34NS25EPzVV1/h13WusbwMsSwancQ+42duv+028nNzade0aSkbwV9yvAqy6667ju6JZP0Vlk0wVoFGzVqV2udnlf71c+eelkL43//+90k/3+Nx9OhRhvbvj+n2ULNSJQynk4mGSbGqMnrYsOR+R44cYc2aNaxYseJ3JapKSkq4+uqrEQSBgoICPv3005Pu/9BDD+F1OjlHVelrGPTs1Ok3X7uMv57vvvuOaCyNlKIOhMoXcHav314ZX8afz/bt26lYuRouj8rQESP/dpvAsgR1Gb+Jb7/9loLKlTFcLsqnpx/jX3wi9u3bx8wZM5g2dSpffvklADfOm0eKrlPX54t7o40Zw0WJH+8ppkXvbt2olluOoGly9Sl8oM+UdevWkWOarA4EOcuyOW/If8q6Xn/9dSrY8SDylXC01Ir65s2biek6b0dSuM3rp0J6On7DoE8iwXm+aTFm5MhTXv+S8ePxKAo5KbFjPFhLSko4b8gQdKcTy+M5bhlYSUkJfbt3J1XX8XtUOrRrR6eECmCYYdK7W7djjpkxbRqVTItuhoHb4aCLbuBT1WOSREP79yfDMIjpeqmO4N999x07duzAb5pkKAoNna5Egt9LqiQxStep63TySUoq9/oD1KlalXr5+cy1vbwbSSFDVamRl4dTENgSjvJyKIxbEBAdArrTmUxK/syWLVtwOhw0cDpp7HLR2e1BcTiQHQ6aNGlCXl4e9X5xvaim0bRePTqYJrd6/fjcHto2aULM5yMiCPRUVbIlGdXhYICqEhJFGjpdXKgb5MgyAVHESCS986S4V7TocJAViVIhIwOXw8FLoQjXWjZuh4BPFNEEoVSzyaNHj1K/sBCnw8GWcJTd0RgRSWJ9IMQ820u5lBSCmkaKJPFuOIouCNzp87PE58eZuDdfNJfKA+ehGH58gkANRWFjKMJZqsaYESP44YcfuPPOO6mVl8c5pslyf4CQ200gFMVlBpGcKmMMmzfDUTyKQr+zz6ZSRgZdO3Vi69atRH0+Lrds8hWFpi4343QTf0L17ZMVivIqs2bNGkYNHkxRXh5XXHZZ8gfrwIED2KrKEp+febYXp+JGM4M4FTcOh4OCgoL4YkleVWJ1u5LW6BwC4SibNm3i+++/JxSJkdqoDykFbSmsXVpV1axlG1IK2pDZdjSG7eOLL77gvDFjCeZUJ9agF5phceWVV55x5/efWbNmDam6zhTTIiBJiLKCqLiQ3Aay7sOX14j0lkPj1hON+zFu/H/sce66aymyS40rnN0q6dm59Ol/LgcPHmTx4sX4MypSofflBDLzmD//+I2Ctm3bxuChwxh70bhkyfPhw4fZs2dPqYnI9BkzcWoW2R0vjHdYL+6Et2LdeAKzbjdmzpzJyy+/jB1OpXDyQ1ToMwvDF8StGbhVnWXL7i113aeeeooWLVoRsm0K8vKO8V8cPHQYac0HkTfgWmTVJKP1SPxp5bnuunlAfKL15ptvJr38li5dSmqNeAPJCudcQdX8Au69917Wrl2L7Q8STC+PPxBCceu4rBCSS+X8MRf8ps/sv529e/eyYsWKUpUuv+ahhx7C9IVIrX82uu3n2Wef/QtHWMbxKEtQl8XfZfx2fvjhB8qnp9Pd9lLbsunfo8ffPaQk8+bNo3eimfpc20vXNm3+sHN//vnnmC4XW8JR1gfDOAUBQxSZkJjX5Gg6OZrGdNMiqmnHLN7+1Xz00Udkp6RguFzUyc/n3//+d3Lb9ddfn2wKOd/ro3OLFqc836JFi/CqKqrTyQ1z5yb/f+fOndx3333H2Cn+mldeeYU826anaWM5Pbg9Op1bt2aEZfNMKEyapjGgf39uvvlmHnjgAV577TWOHDnCJRMmUD8/n0snT2bbtm2cO3AQfpeLCUZ8jucXRXJVlfzE57DY66dRrYLkdTdu3EjH5s0Z0LPnKdW6b731FmFN4wF/kJGWTdtfiJtOxaeffkrE66WS4kSVndjplRg3fmJy+4svvpj0Oa9hWcy+4oqTnu/Kyy5DVRR0l4slv+j9cqa8+uqrnDd0KNdeffVpeYQfj08++eSUz27NmjXouk5KSsoJxQklJSWUT0vjLI9KT1UlU5JpWPPEvy1vvvkmdRs0pmZRnbLY6R/Cq6++SiAtl+Jp68i/YCm2L3jMPhs3bmT16tVnvLhSxh9Pmw6dSGvSj5oX3Yc/NZe1a9f+reMpS1CX8ZspKSnhq6+++t3+T3kZGTwUCLI7GqOWz8fcuXMJaBoDvT5CmkblnBxmWDbPhsJENY0333zzN13ns88+48477zwmAXr1lVdSo1w5+nTrxsxLL6VxQQGTxo1j7969hBJNMM62bFrUr8+9997LunXreOGFF0g3DN6PpHCXz0/lzCx2795NejhMOcsmxe9n27ZtfPHFFwzq04fGRcVcd911p/2j/9hjj1G/Rg28sswgTafY6SRie4/Zb8eOHYRUlQ+jMTaGIrgVhZa6zsfRGANOkCRPDYXIk2W6ulVqyjJ3+vwMM0y6devGiIGDkoqCkpISXn311VL+akvuuAPd5cIjSaS6XJytG7gFgQmGiSmItHC5yZAkVIdAtiRT6FEZ2Ls3r7zyCil+P7IgoAkCzoRqeX0gxCOBEIpDQJJdWLLM4sWLk9c7ePAgednZ1Ha5iIoSbRMe1st8AWxBpLeqYQpxBfIFukEDpwsjoR5f6gvwWjgatwWxbNq7PRiCwCBNJ1uS6JdYTLjO9lJVVgiLEpcaFrYgYDocSA4HgzSNBk4XO6MxztONuPedYeJL2JU8FAjGSzdFEUVxJr2A169fT1TTKXQ6qaootNUNdEkiLMsYgoBXlDhf09EkCcHhwO1wYAgiHocDJfF8vOWLKZ62Dn/VppSTJPqoGj5RJN3nT1oyANStVo2lvnjjlKouF4rmpWjKo1QdvgDT6ebhQAjD7ebQoUNJ37ZnnnmG119/nXZNmmA7nUkv74qyQkgUOV83WOT1o8syzUyLFf4glUwrqZ7+7LPPsN1xu5BXwhEcQtyjruDi1QiCiCRJ5Obmsn79egYPHUaDxk1xulVcHpXBQ4dhBSIUTV1LwcSVKE5nqfczEElJekQHMyrwwgsvUC6vKpUHXR9Pzlau85vsD44cOcI333zDBeedx6TEBOUS00J1uginpKKlVMRbsT65XSfhtEJktBqOFYgmvQqPHDmC4nShpVSgaMqjZHW4gHoNm7B3714WLlxI+/YdMHMKSG06gGi9nowafT4//vgjs2fNYsSgQWzatOm449qxYwcpqemohkXV6jVLlWTOmDkTMxgj1qgPHt1CNb2k1u6EbnmZftlleFQdxaPhUo2kH/Xnn3+ebJr6M8899xya5SOt6bkYVpAuHpWav6pUmHPdXII51QjWaEOoVnuKp60ju/M4OnbpxsGDB6lesxBvOA3d8rJhwwbeeustNMtLWvMh2GkVcHk0UvMbYVg+/vWvf7Fp0yZ69uqNovsomvIo1UbeiqS4/+cC0T179hCKxEipXAfDG2DVqlUn3Hf9+vXMnDmTjRs3/nUDLOOElCWoy+LvMo6lpKSEDz744LRK7r/88kvmzJnDbbfd9o9qQPbRRx8Rsiza+wOENK1UH5ffy5dffonudLIpHOHhQCje2Lt5c/IT1aOaJFEhK4teXbuetv/wn8nQ/v05P2HZ2Na2ueGGG5Lb3nrrLfyazjDTItMwuO0X8fnxePLJJ/GqGn6Phy5t2iSrZHfu3MmUSy5h7ty5p7R4++abbwhZFpNMi7Msiw7Nm9O4sJAFCb/khj4fd9xxBzmxGE38fqK6zjm9e1NoWdznD1DDsrg1UXm7bds28jIzMUWRDFWlck4OAaeT2k4n9d0eenbu/Jue2eOPP06BLz6elf4gVbOyz+j4b7/9lqlTp9KwSXMmXjy51DO5/vrr6ZdYFLj5FIsCe/fuxXS5eD0c5V/BMIbb/bcpHyePG4fX48Fyu7n2FB7jW7ZsIRQKIUkSfXr3Pua74bvvvsMlxXs67Y7GcDqEEzbkBkhJyyCz7Shyu07CsLx/SJz50Ucfcc8995SqLi7j9Nm3bx/eQIi0xn2JVG9Cq7ale93MuPwK7FCMcLl8qubX/M3Wj2X8MdRv3IzszuMomvoY4XI1Sonu/g7KEtT/Q3z//feMGjyYetWrl1rV/rtp26QJwyybe3wBgprG+++/z6uvvsqcOXN46aWXqJyZyQP+IDujMSrZ9m/ya9uzZw8pfj8d/X5SdJ07j7PKfN9991HJNFnqC1DHsrh61iy2bNnCub16MWbkSKqWL0+2x4MtCLgdDmxZRhEEbE1L2gAcPHiQLVu2JJupNa9bl366wWzLRhUEiqpXZ968ebz88svs27eP2bNnkx2JEjUMmjZqRJPCQkYOHoxf07jZ66OHRyUqitzi9RGQJPJycqhXs1ZS/bh37964ujoQYr7XR0DTsEQR0eFA/5WqF+KNSpwOB7UUBb8goDgcjNJ0LEkiS1WZblqk6DqPP/74cZ+jpaqsD4YpUJzck0iKtrJtMmIxIorCfK+PR/1BoqLE/f4AlqwkbRhKSkrIjaYw1bDYGomSJknIDgceRcErSbRxu7nKstFlmW3btgEwbdo0Knri1hZPBEPogoBHEBim6QzXdD5JSWWWZVPX6cJMfC4jNZ2eHhWfGLe5KJew6tgQDJMmSfRRVRSHA68gcq3tpYIs4xIE+vXpQ/tWraiRn0++y8Vo3cAQBOo6XeyKxrhQN/BpGjFJIiORoL7G8vJMKIydUFkXVq6MLIpULl+eYabFzkTDQsvjoYmq4nY4uNKyGaBppEoSVRSFaDBIOaeLd8JR3A6BDcEwjwZCKA4HarQ8oqSQqiiIDge5qam89957pT/TJUvwu1zUdDoxHQ5MUSScU0Ba88FITjdB0+SB++/nww8/pFmDBqR4PFS0LLq2a0dJSQlD+valrmUx0LTiqhdZplBxUuR04pNlZiVKUftbNrNnz05+lr3POotc0yRV13GrOtmdxpHTZSIut8qGDRuIRqOoatw72fYFyBt4HdVGLcatm2Rk5xKt0YJg+QKyy1Xk7rvvTgbVo0aPIZBRkZT8pqRlZvPdd98xYtRogrk1SG3cF8P2nXbFxs/s2LGD7JQUdKeTauXKEXQ6udgw8bs8hGq2pV6DhiiKG1lxY4ezESSZ1u3al2pOePjwYWRZQQ1nUzBpNekthlC/cVNi6Zmk5DfBqduYGdUIVGuG5PTw7LPPMnroUBpaNpMME7+uJ30I33//fe6+++64ymfQEFIb9qZo6loi1Roxd+5cSkpKuPSyGdQqrkf9ho3wh1NIzy7HvHnzuO6663jppZdwezSqDl9A5cE34HJ7Si1a3Hbb7dSu35haVasRsW1y0tNJqduV4mnryOowloa6Rao/UOoZHT58mPETJ1Gpaj4uVSdWvydWKJUJEyeyePFiIhVqUTR1LTldJlCruB6rVq3C5VERZYVYeiaxRn0T9hR9k0rpyy+/HFFxk3fudWS2G43s1kv5l58p77zzDlXyaxKMxrjhhpt+83n+ShYvXkwsP640z+06iUbNW536oDL+EZQlqMvi7zJKU1JSQseWLQm63RhOJ1f9wVWNfyW7d+/m7rvvPm6Tu99Lh7ZtURwODEFggKrRu3NnFi9ejMfpZJZlM8OyKZeW9pvP/+OPP7J69Woef/zxEyYkS0pKuHz6dOpWq8aF552XtGdYvXo1zevUYWDv3nz99deMGDiIYZbFx9EYLWybm24q/dv6xhtvcMUVVyST6fcuW0bIskjx+Y5JsBdWqsRtXj87ojHyLJt//etf7N+/n1ggwGDTorFl0bdb91Pe35YtWxjUpw/jLoj3yFi3bh0+TSPP9lKjYjxmbOL380lKKst8AVJ9PiYmhAdjDZPxF11U6nxvv/0269ev5/LLLqNA1bjV6ydFUZJ9ZPbs2cNzzz1XSj1+Mg4ePEh+hYoU+nxENJ1FJ+i18Vt488038WsaowyTbMNg4S23nHDfr7/+GsPlYlM4wuPBEIbHw/Lly9myZUtyn0OHDvHggw/y2GOP/WkNBb/55ht0p5OtkRQ2heO9Zk62IPXaa6/hV1XSJQmHw0HjBg1KvcclJSXUysujh2nRyzCplJV1wvf86NGjSJJMrQkPUnjJI6iGfUr7kFOxdetWDNtHan5jdMv7p/rE/39l79691CysjdOjUTW/Zqk5CkAomkrVEQspmroWf2oOL7300t8z0DKAuJDJtH2Y/jCFtev95U0Rf01Zgvp/iAljx9LKslnmC5BlGKxbt+7vHhIQV2Oe1bo1RZUrc8/ddx+zffny5dgeD+mGQZvGjY/50Xv11VdpXrcurRs0OKG6esmSJXTwxxOqd/j8NC0qOmaf6dOnM8y0kj6/A3v3Tm575ZVXMCWJzm4PMVGirdvNLMvGIwic+4v9fk3YtnkxFOGTlFTKJ9SzHQwTy+Ui7PfjlyTGGyar/EFUh4NrLJs8TaN6Ivm6NhAiJkl8kpJKD49Kc5eL8YnjP/roI0pKSlh6112kB4PkRKO4BAFTEKgiywzTdKrm5HD48GEunTyZVvXqUT47G1UQOEdVyZVkDIeDVFFEkyQyJYkeHpWRmk6H9u2P2wzFZxg8HAjRU1Wp73Qx1/ZiiCIeWeZ83SBHkslP2H7sjsbI93r517/+BcTLHq1Esn1nNEauJJHq95OnxVXQPyeci1WVhx56iAceeIDUhEJ6gddHX1VDFwQqSzKyw0FQFLnB9lFdUeji8VBZlnE6HLwYirA7GsMriNQtLiYtGKSLqlFOlmnjdnORbqCLItMvvZTMYJBUn4+pkybxwAMPYPrDpNQ5C0lxU1HT0AQBSxTjz9XlJujxcKvXTzu3B93hwBIEbEEgJIqYhskgy2ZbJIVKsoImiowyTNJ1HVEQuNK0iIoiu6MxXgtHcTkchESRLFXFkCQ8kpK0BHk5FEFyOLjvvvuYP38+ixYtStpBHI+zu3ShkdNFhiSx3B+ghduNpri4/vrrgXjZXdA0kRPn3xGNEVBVdu3axU8//cQtt9zCpZdeykcffURA07jStJnv9aE4HFhOJ00tm5BlsX37dkpKSvj00085ePAgGzdu5NVXX2XTpk3UKq5LZlYO6YEgtSpV4oknnqB+/fo4HA6cLhdu2YlbUtBkhc2bN3PhhRfidHtIqd8TXyyHa669DogHm/fffz/z589P+lMfPnyYuXPnct75Y46ZTB49epT169fz9NNPnzCAHdi7N2MSCqGWtpcWLVqgGzbpLYcRqdqQMRdcSCwQYLRh0lzVqJWXd9zz3HDDjcguFYcgYHoD3H777YRzqlI8bR2CpFBr4oMUT1uH6Y+wbds2apQrx5pAkE9SUmkWCLJ69WqefvppFI+OonkRFBe67UeUnQSqNSdUqZibbrqJO++8E396BSr2uRItWo5A9ZaU73EpblXnxx9/ZP/+/TjdHmpeeC/5FyxFcbqS1RnPPvssViBKSv0eZCpOXghFaKfpOFWDtGYDcVkhdKeb+b9QSf2al156iZEjR6IZJpHcauimhRlKI3/MUlLq9cCpGngDIfIGzKHmuPtxaSbe1PJU7DubQFYV5s+fD8RV56FIDMmt4bRCmKG036VUq1FYTGarYVQddjO67T9mseafyPr167FDqVTsO5toflOGjji19VMZ/wzKEtRl8XcZpRl7/vl4RZEPozHWBUOognDK5sD/7ZSUlLBy5UquvPLK01ZTPv3000Q0jWmGSSXT5Jb589m5cydBVWVnNMbWSBSXLP8mtevRo0dpXq8ehV4vlSyLkYMGHXe/ZcuWUdm0WO4P0NCyuXLmTN5//30CmsZCr4/elk2d/Hx6nXUWmeEwsijSvF69k6pPv/vuOwy3m8cCIR70B7FVtVTSs0HNmsy2bLZGomQaBi+88AKbNm2iSkIR/HIoQsS2T3mPy+65h3LRKIYo4tN1HnvsMT799FNeeuklDh06xOuvv05U17nHF+Acy6Zl48b4NY0OgSB+Xef1118H4nYSDWrWpHu7dnz22Wec07Vr0v97sGkxa9YsNm7ciF/XqeHzkRWN8sUXX5z02f8cax08eJC1a9f+5qpegI8//pjxF17IjOnTSyXHX3vtNS699NKTVlz9zNxrrsGtKKhOF0HDoKU/QFjTeeCBBzh69ChN69ShttdLZctm+Lnn/uax/kxJSQlXzZpFVjBETiTCXUuWcODAAQy3myeCIVb6g1i/ei9+zaJFizjb72d7NEZdpwuHw0HPnj35/vvvk/t89dVXTL3kEi6ZNClpCXoihgwbgS8lk0BGBVq1af+7VeRTp04lVu9siqetI73FEM4dNOS0jnvkkUfod+4gbr75lhOO4fDhw7z//vunvRjyR7Jp0ya6dDubIcNHnHRO+UcwZNhwUgrbUeOCuwlmV+HuX+V3iuo2ILVBT8r3mI5metm1axcvvfQSjZq1pE37jkmh2v8iR48e5ZlnnuHFF1/8Sysi9u/fzwcffHDKZrh/BWUJ6v8hOrdsybyE51oPr5cbb7zx7x7SafPZZ5+xdevWY37wfvrpJ0K2zTWWlyssm9Rg8Lh/zC+99BJRXec2r58Ots2owYOP2eett97Cr+t0CQQIaBrr169Pbtu0aRPeRHIxW5J5IhiKWyooCgHTpKSkhF27drFo4UJifj+5sRhPP/00Y4YPJ0dRaOFykyZJqA4HdZxOKskyQVHEFASuMW0yEqvI1RSFcYZJQNNo7fOToarYTiedLBuXw8H6YIiPojEkhwOvy0VGLMaUKVPYs2cPLevVZ67tZVc0RnGi2YXf5eKaq66itmVxm9dPQJapkVAUPxIIYQoCGaKILYoUKE6qyAqaIFBR00s9o5+f+4oVK9DkuC+zxyGQKYpcoOuYgsDzoQiLvH6CLjeWJJFvGNSoWDHZPGT79u3YLhdeQSQginhEkUoJv+zHEmOpIivobjd33303XqcTjyBQU1EwHA7auT08EQwhOxxoDgcdE6ppyeHAdDhY7vOjOBykiyK1FCeGKDGgVy+2bt1K5YoVcTocpAgChiAw+rzzWLBgARG3mwt1gyLTpGZhMZltR1M8bR3ROt1wOhzMnj2b+++/n/vuu49ly5bRIhBIel1nh0IENQ1TFAkaJt07duRC0+IRf5BmLjcNXS4ClsUjjzxC0zp1aKbraIJAU5eLCrJMQBB5JhimvKoiO91UGTIfpyM+PkMQ8Igiq1atKhWwHY+ld91F2LZxCQIdEo0Ub/pVw88ZM2bQzLTIkCSutrws8fnxquoxAdKRI0eQRZF3w1E66jai4kKQFVy6SYMGjbjnnnto2aABPo+HoGWVsq3Ys2cPtsfD6kCQqy0veVlZ/PTTTwwaNAiHw0GuLPNSKEI5VeWJJ57gnN69CVhBMpsNJLf7FBo3b33S+zwRZ3XvgT81F19KJgMGHvt3DTC4b1/Os2w+jsZoatvccsstTLh4MtnlK9HznL589913vPfee/To0oXB/fqdNBjev39/spnQrl270C0f2R0vxGmFsHMLiRR2IBSJ8dhjj2H7Q7hdKu08KkHT5NNPP6VGrSLs8sVUHnwD7kAaZlYNGVbkqAABAABJREFUao5bjhrOpmJeFb7//nsmTZpMrH5PiqetI635III1W8ftUySZ/JoFiKJEOJaOW9VwqzrXXDsnOb5FixaRWqtFXCmt6uyOxrjW9lK7Rg1GjT6fGTNmnNIDEmD0mAuINewdb3ZYtzveQATJpaGnViJYtTGS00Ol/tdSc9xy3LrFsOEjyS+ozYSLJ5cKbnbu3EmV6jXxqDpDho34XcFWenYueedeR9GUR/HHsv9rrDDmzr2eKvkFnNNvwN8yKSnjt1GWoC6Lv8sojVeLx3vPhMLc7PUREyXaNW78dw/rT2XenDmUM00GmxYBw2D79u2nddwjjzzC8HPPZfGttybt39o1bUp120uOaXLBaTaX/zUfffQRYU3j42iMtyIpOGX5uPvNmDGDoQnRzWWmxcDevXnssceo64srj9cEgnhFiSssm5imnVYy9Ntvv00qZV8LR49Rym7evJmsaBSnLDPu/PMpKSnh22+/JeL1Msa0aGNZdG/f/iRXgPfee4+AqnKPL8BQTadQcRI+TlL7jttvp3aVqvTqchZff/01H3zwAffccw8ffvgh+/fvp13TpmgJ68EhpknL+vV55JFHCGsaPfx+/LrOW2+9Rc+OHbkykbTu6vWWsjj5JU888QQ+Xccly1w6efIpn9Wp+P7778kIRxhmWnSwLNo0+u1/Rz/99BMLFy6kc+KzXeD10aZhw/i7ov7nXXGd4F05E+688078sswoTWe5P4DP7Y5XBS5dik/XCdt20hrvRLz//vv4dZ1hpkmuYdCxfXsEQaCwsPA3qZ9LSkrYsGED69at+0OshJYuXYo/rTwV+8wimJvP1ddce8pjnnvuOQxvkIzWI0r1b/mZw4cPM2LUaFTTh1u3sbz+v6RB+LPPPktmTnmCkRRUPd5fJqWgDY2bt/xTr3tW955ktI43/k7Jb3pMZcauXbto1a4D1QuKWbNmDQcPHsTy+snqMJb0pgPIKV/pTx3fP5WSkhI6d+2OP5aNHU7lvPMv+LuH9LdQlqD+L+Htt9/m9ttv/11eSA899BAhTaNdIEDYtpPl5v/NfP311+hOJzuiMbZFYyiiyOeff37cfe9asoRmxcWMGjyY77777rj7bN++nSVLlhzTzOr7778nZJpcaJhUlRWyJZnOHg+WINKifn369+iB1+3G5RB4NBDidp+fkGlx9OhRrr/+eipmZ1M+FiPkchERRd4NR7jT64tbXDgE+qgaYVGkUHGiKworV65kyZIlPPnkk3Ro3Ro10bQvU5KopihUTKix8xUFXRBI8QdoUlzMOMNkaySFTEnCEASCms6AHj24IhF89fCoeBwCM0ybFi43uiCQGYvhEQR2RmPsSCS/nwiGyAqH2b59O3lZWUiiSN/u3bnpppuoaVks9QUol0iytnO7yU14OlfxeMhxuRmu6aiShOZ04pZlKqWmMXXSJAb06kVIVdGdTi6dOhWvy80Kf5CLdAOvINDa7aGLaeESBJq53GyNpNDG7UZOjOnJYBi3w0HA4cDlcGCJIimSRGVFwRAEurvcZIsiliBwu9dPQ5eb8mlpdLEsppgWuqJw22238fXXX+PTNNq5PeTIMi1dbuoWFeP2p5Ld8UIMzcYQBLJTU5PvwN69e0kLhWjv85NmGNwyfz4lJSUcOHAg6e2sSxIxScIjCFxlWQRNE4h32J41axadOnZEEQS0xPgVhwNdklANm4KLVxMpV0SqKBJ0xJXwtiCS4vef0Ovx888/x/Z4eDgQYoiq4RFFmnm9hDSN1atX8+WXX1IxIwOHw4EmCJyv64QlmVTbZuXKlYwYOJAWdeuyfPny5DlHDBxIqtuDU7MpnLSGin1nI7k0/JUbYsdyiKg6O6MxrrG8VIjFqF2lCpdMmMBbb71FTNf5KBrj2VCYgGGyf/9+0sNh/KKIklCMp6oa06dPJ0vTmO/1Ud7lRveGmHnFmZcKf/3117g8KgUXryK9+SCcosiLL754zH47d+6kQkYGTkmieb16x036Dx95HprlQ9Ut5s47sbr416xfv57mrdsRiqaiBVJwenQGDRqMW9Uo3/MyKpxzBYrLzRVXXMGmTZuoUVhMRpuRcY/t/FbY5YopmrqWaLVG3HxzvLHili1b4uWFNZogOT3Iqo3LG8VlhfDl1KBw8kPEanei34CBSZX5999/zx133MG8efOw/UFSqjVEkyRyNA2/rp9xieJVV80mVLGYaiNvJVS+Fi1btyFUvoDyPaajWj6s1PJILhVBUsjIKX9G5/4t7Ny5k/SsXETZidvw0rBxs3+Up2kZ//8oS1CXxd9llKZKdg51FCduh4OYJNFM0/4QVeY/maZFRSxJJP66+APc8Tsa0R0+fJh169bxzDPP/ObF2gMHDuDTda63vVxi2VTKzEzGoBs3bkye99133yVgGLQLBPFrGk8//TT79u0jOyWF1j4/UaeTNm43n6SkMsYwmTJlymld/+ILL8Tv8WC73Sds4Pfre3vvvfcYM3IkM6ZPP6U/8JNPPknNhJjqoUCQbEnGUtXTGtvPjL/gAjoaJs+GwtRSnIwzDLIjESAuOFqwYEFyof784cPpbtk8HQxTzbJKxcO/JDsaZZkvwJZwlKCq/m6F53vvvUemGbcleTuSguZy/a7zbdiwgQzD4F5/gI6WzeihQzlw4AB+w2Ce7eViy6Zy9ul7ZR84cIDWjRrhkmVa1K+f7G0ycvBgUkQp2TuqkqomK2XPhDfffJOZM2eycuVKSkpKWL16NZqmEYvFktaQfxclJSVcNmMmNYvqcuG48acVa15zzTWk1ulcqn/LL5k7bx7ejMrkDbgWPbUS/sqNaNuh8591C0n8oQjlzp5GVvsLcNmReNPC8+/EGwj9qdd97bXXsHwB/LEssnLLn1KxvXPnTnTbT9GUR6k14UEkWfnb/NT/Tvbs2YNHNymc/BC1JqxAkpV/hKL5r6YsQf1fwMaNG/FrGl39AXyqyvTp07nzzjt/kz/Mli1bWLZs2e/2Z/qnUFJSQpc2bahmmmTLMn5JImAYSY/m38OhQ4d47733ksHUe++9F1diDh3KmDFjyM/LY0Dvc3j22WdJMwyeC0WwBIEPIim8HIogOxxs3ry51FivvuoqXAmvZCmRoByasLa4yrKppCgMPndg8pi9e/fiFgS2/uKcXlWljtPFyMRxFxkmYZcLr6YRE6W4LYMgEHAIGIrC/PnzCagqHVQVO2H/kfTRTiRI3YLANNNiomHiFUTamSb5FSuSE4lwoWnxQSSFGrZN+9atuTjh83ahYTI0oaYxFIVBfftStXx5enlU/KJIVJTiSnFBYJ7tpb5ucNH559OoqAhJEMjLymLalClYokiaJCE6HOxKNMSQHQ4GJpoYDtF0NEXB9HhwiSIeQcByOKiYsPR4NRxlVzSGXxRJcQh4HA6qygrvRVKYa3uxJYnnEzYr1Xw+XnjhBR5++GHqeb1JFYklSlx33XU4BZFCzWSW5SUgilTIyCz1TnzxxRfceeedx+0Sfccdd9Ay0cRlTuK6AwcMYO3atUn1TJ2aNfE4BGKSRHoiqd/C76dJ85both/F5UEQJVwOB4u8fmZZNl5R5KoTNBx5//33iWga2xNJYVtVeeCBB5ILLBedfz69tXjSuEBRiEkSLZs25dChQww65xw6WzaLvH7Cmpa0zigpKaFybi5Ot0bNC+8lt+tkJI9B8bR1VB2xEKdL5YNICpeYFlFZ4QF/kFqWxYIFC+jSpg3ZpklI05gzezbPPfccNXw+1gVD+AQBh8OBKIq0atWK0bqRVPY0Ki4+Y2+8I0eOcPDgQUzbRyi3gHJOF7bsxCGI1G3QiLfffpu6DRuTmVuBRQkF089/y1u3buXcQUOYMPFi9u/fz7Zt21DcGmZOLaJ1u6O4XGc0no0bN+KPZVM09TEqD7oexaUiihK1xj9A1ZG3IiouUqo3wvCFuOSSKcguD1pKeUTFhex0Y4diVMirUsqjbfv27dx9993cdNNNqIZFsGIxTreHQOUGFE1dS6zhOfTu2z/5mdVt0JhwhUJC5WrQsEkz8msWIkoy/mCY559//oyeLcS//3r16Uc0NYO+AwZy4MABxo2fSN2GTRk2fDi+WDbVRiwipagjPc/pe8bnP1PadzqLtEa9493AIxk8+uijf+r17rxzCTkV8qjXsAk7duz4U69Vxj+TsgR1WfxdRmnefPNNaletRtS2yQ6F6NGx4zHeov/fmDRuHPUtm1mWTfAXsdLfyXPPPUeToiLaNW3K+++/z9iRI8kwDHJMk35nn53c7+OPP+bee+8tJW766quvuOuuu7jsssuI6TpjjHjM9uu49ujRo4wcNIiQZdGyfv3kYjjEq1I7NG9Ok6KiZA+eH374gauvvpqLx48v9Zv5+eef06VVK/Jzc1l4yy3s2LGD66+//oS9bg4ePEjV3HLUUjVsUUSVZRYvWnRGz2dAz55cmlCPn+1R0QSBomrVjjtv/vbbb+ncsiUZoRAXnnfeCWO/9IR9xTuRFMKa9rstxn744QcyI1EGmRZtLYt2TZv9rvMBzL/xRupUrcqQvn2TvZA2btxI87p16diixRkl1a+4/HLaWxbvR1LoZFlMnzYNgEcffRTb6cQnilSUFSplZv5hfrVvvPEG6enpeDyev71J25ny2muvoVteYg16YofTuO2220ttHzX6fFKb9I8rihv0wkit+KfHziUlJShOFzXG3kONi5YjOd1E85sSyMxj8NDhf+q1Ie5Nvnnz5tN6P44ePUqd+o0Il6tBIL0CfQf8JxdSUlLClKmXUrFKPucOHvq3+yP/mRw8eBDdtCnX41KyO15IOBr7n0zUlyWo/ws4f8SIZFKwgixTqGo09HppXq/ef91Lu3v3bkYPG8boYcNOK0m+a9cu6tWoQdA0mTh27HHv9/DhwwS9Xhq64s3sxukmg/ue+Et/x44dzJ07lzvuuIMZM2awYMGCpKfYz+zZs4fc1FQyTZPUQJBXXnnlhM/62WefxZYkKssK5WUZSxDwCiK1PCqzZ8/m4YcfLhWspXq93Gj7eC+Sgl8UCcsK1yea9bkFgcb167N582b+/e9/x71mBYH1wTAr/UFcDoHVq1cT9vnIVxTWBUPUcTpRnU5S9Xg5/9ZICk6Hgwf8QSrqOqogIDscuCSJGprGeCPuRZwtSeyKxnjQH0QVBHRBIGKadGzdGp+moTsEqsoKl5sWu6IxGnh9cV9aSaJlQn0907RwOwQ0UeSVV15hwvjx6KLI2kCIj6MxUiWJRk4nHd0eRIcDVZapr8UVuCNNiyH9+nH55ZdjCwIZksQ5qsoA3cDr9qAJAuGEGloUhKQPcRfLpr+qYQsClWWF8brJLV4fbiGenO6rarR0uUkRJXyJhHahZdHbsokFAkyePJlp06bhV1Wut7100g2a1KlDw6IifFI8OSw5HHgcDi6++OKkRcmpWLNmDZUtixdCEQaaFmleL0VeL3mWxYiBA3n55ZeJejwYgsD2aIx3IimIDgeW281nn33Gtm3bcHlUKvaZhSZKfJQoyZMcjqSy9teUlJTQo1MnMgyDgKoy99rSZWijhw1juG6wOxqjs8eD1+lMJvbqVK3KvQlf9hb+APfff3/yuD5du5Gv6kiiiKi4kJwuMtuOJlqjBWnpcUV9UNcZrGlJ9c2EceM4evQomzZtSgbuX3zxBQHDYLpp0ckw8Wk6jkSi2iVJnGPH1d5r1649rWf8MyseeADD7catKIw57zx8ifexu6oTcnkwozmkZ2aT1rgveedeh277kxO0b7/9FtsfJK3pAMLVmpBfsxY1C4qwy9eOJ+NdKrJq0af/6avCPvjgA3TbT5XBN5LefDBpHp3BpheXx0DxaATy6lM8bR3luk+hfuPmfPTRR8ybN4/777+fr776infeeSfZwOh4bNq0iVtvvZXbb78d2a0hqxaSW6d7j15AfMLpVnWKpjxK4SWPIEoygcw8Ci95mIwWQ2jdvuNJx//iiy9SNb8WedVqsGHDhlPeb0lJCePGTyQQjlK/cdMTVq38kdRr1JScLhPjzSQr1DqhyumPYNu2beiWj0r9ryWtST+K6zX4065Vxj+XsgR1Wfz9T6ekpIQ1a9awcOHCUgnEMv44fvrpJ66cMYM+3br9rt49zz77LLmxGFGvlyV33nnC/T788EMuGDWK6VOnJpOM+/btY/Xq1aVELz9z+PBhFEni7UgK26IxDJfrtN+FRYsW0bVrV5YuXcptt93GypUrkwnae++9l3zL4qVQhD6WzYiB/0kYNahVi1GWzS1eHz5NY8+ePfTs1InmlsUw0yIWCCQVt93atWOQZbPCHySkqvh1nd62l6xEJeLxOHDgAKtXr2bt2rV88803p3Uvv+TVV18lYBjkJaz1LjVNmlk2V8ycecbn+pkVK1ZgyDKmKFIrL48Zl13GxHHjflc18u7du5k0YQJXXnHFCSt7/y4mX3wx5yaS/ENMiwm/aDy5YcMGRo0axZw5c05pQ/hLdu7cyYMPPnjSZ/b5559Tp04dHA4HM2bM+K/Kc7z00ktMnTr1uHY5r776Koblw5dbC1F2Ub5i5dOeX/4eZl5xJbrlxwxE6N6zNzfeeCPLli370xpm/h4OHTrE/fffz8MPP1xqfPfddx++tHLknXsd4bw6XDJl6t84yj+fp556irxqNahRUPyX2MD8EylLUP8XcPP8+dSwLBZ5fUgOBx9FY3wcjaE7nf9VyoWjR49SISODYZbFYNOicnb2KX94urVrx2jL5oVQhPKWxZNPPnnMPiUlJYiCQF2nk03hCO3cHs4+6yzeeOONY87/ySefELIszrFsUiSJqChSXTcY3KdPqf1mzJjBOYkf5lG6gSpJtKhfn0OHDh1z/Zb16zPKMONN/BI2BjmShOV2EzBMGgcC+LX/lNjnROJezduiMdIkCUUQsASBWorCY/4gIVGM+yw7ndx0ww1kRCK4HA48goApSqxevZrDhw8zdMAAUkyTvMxMHnvsMdIjEWokbDa8skJjnx9dFGnpcpMuSaRJEmmBAKOGDsWn6wREkSeCISYaJuVkmR3RGNVtL5dccgkxl5suHg/rgiFsQcCUJBoVFVEtN5fzdIMObjdqQqk9UtMJyjIeWSbftrEVhctMi0cDoWRyvLqi8GE0RmOXi4YuF7d64wn22jVr0aNHD85RNTaHozRzudBFkfnz51OtYkVyVZXqpkmvLl2AuC+YV5LRHQ7cDgeLvT5qKAp+UeRcVcMrxhtK3mh70RNJb9nhoEO7drRs3hyPINBT1air6zSvX5+mtWvTullzoj4fky2bCwwTXRBwiiK2JNNS0wmaJjt37mT58uW0b9GCpk2asGzZsmPerZKSEi487zwitk29GjUIqCof/7xgIMts3LiR7MT5b/X6uc72YggCIaeTm266iSNHjuBye6g26jaC6VXIkCTCokTl7OyTJi+PHj3K5s2b+fDDD4/Z9vHHH5OdkoKlKARUlet+kcC++aabSDcMOvr8pAaDfPnll7z22mvUrteQajUKSE9JQVc1Rg4dSqMmTeON/Txx65AjR46wadMm/LpO20RTmjfeeINvv/2W6dOmMWXy5GSjmVdeeYX+Z59NYc2aRGq1pnDKI+jhTBwOB7FYjPvuu492HbugGSZNW7Q+qUfvgQMH2LRpE5aq8lggxMuhCIbLRbPGjWmX8N++1evHb/oxvf64X/HUtQQzKiYTr5s2bULzBlEjOajR8jitEC47QsU+syietg67XDHZncfhdKulvl+/+OILPvzwwxN+Z92yYAEpaZnE0jOpruvcZPsIezyMHz8eKxClfM/LiFRtyPCR553w/k7Grl27KF+pCrJqEmvUl9yul1C3YVMgPkENR1PJaD6ItCZ9CYRTCOZUo/CSR8hsPYKWbU/s+Xj06FG8/iA5Z02k3NlTMSzvSd+3v4sNGzagW17scCr5tYqOWyb8xhtvkFshD9sf5Lq51//maz333HME0spRNHUtVQbfSCzj9Mtiy/j/Q1mCuiz+/qdzyYQJVDItOnl9ZKeklHnc/4NJCwZZ7PWzLhjCcrv56quvjtnnwIEDpPj9jDYtOlg2HZo3Z9++fZRLS6Oh309E07jj9tLKzJKSEsIJ4csdPj9eTTstheFTTz1FQItX8emSRAvbpqplMXroUADmz59Px0Sl4RWWTY8OHZLHRmyb5xINyctbNq+++iphy2ZTOF6tWMXr5ZVXXgGgMC8vKYYop2m0T1gOLjlBw/rT5fLp0/EbBtVyy/HOO+8cs/2LL76gf79+nGvEq/UmmhYjE711Dh06xFtvvXVGfy833ngjtU2LhwJBarrc5LndDDUt0sPhU9qW/N3s3LmTzZs3n5FVwKeffkpOLEaaYZAZjbJr167fNYY33ngDv67T8leNLI/HDz/8QN++fY/bPPHvYPv27TRr1Yb8gtq/qynsjh07WLFixV9msXr48GFmXH4FTVq05pprrvmvSvb/kquuuoqU4o4UT1tHRpuRnN2rz6kPKuO/mrIE9X8BR48eZca0aTQtKiJkmoy3bCZZNunh8J/iS/Pjjz+ydetW9u3b94ee99tvv0VTFHZHY+yKxnDJ8ilXjJsWFzM/YZtQz+vlmmuuOW5Q165pUzKcTgxBwJZl0nSdVN1g3OjRpfZbtmwZ7X7R6C5XkgmIIik+X6n95s6dS3PL4u1ICp09HkZpOvW9XpYuXXrMtcvHYjwaCBESRZ4JhdkZjRFxuigoKKBvIjCaYdr0T5TdPfHEE2iyjNMRVy0/6Q9SS3Fyh8/P7miM6orCNZaXF0IRZEFAdDjIlmSW+fw0sL0sW7as1PV/+ukniqpWpbKm4XIIeASRourVufbaa/Ekjt8aSWFHNIYmy6SHQsiiiC6KeBwOfE4nF+gGLwfDRJwuquXkxP2dBYHRukFMFBk5fDhHjx4lYBg8HQxjCwJ3+vzc7vPjdDgwBIEcKd48sZymkZeZSUYwiOl2U8njocjpZFc0xkTdxE54K19u2ZRXNQb064dHEOitqvHmiQ4HIVGidn4+S5YsYcWKFUk7h3atWuERBG60fTRyudAEAVMUmW5atDUtAppGL01DFQSW+wNcYVoYgkDlzEx0p5NysswnKam8Go5ieTz4NY0GPj9uQeDjhAe3LIoE3W7mJ7qOd/CoDB8+nLDbjSkIDFA10mWZGZdeesL39pe+b5Msm7ysLI4ePcpZ7drhcjioIsd9xMOCQAOnC11RePbZZ1mwcCEut4rT5WHgoME899xzlJSUsG7dOrIiEdKDIVatWsXrr79OWmY2HlVn8pRp3H///UkrkV9z+PBhPvvss+N+Vzz66KPMnj2bPXv2cPToUfyhCFntx6CnVcbMqkGsfg9Mrx87kk7h5Ico3/MyyudVTR6/fft2li9fzkcffQRA3Ro1OMu0OMe0qJyTw7///e/kBKBvv/54yxVS/fwlRPKb0b9/f2zbxuPxYKVVpOZF9xGp3oQpU6fx7bffsnbtWp599tlksnTXrl2Eo6kE0+PWGBN1kwt0A01RePTRR/G7XMyzvRQ6XXgNk6tmz0a3/QQzKlKjoJgDBw7w/fffs2TJEtz+GHkD52LlFOCv1oLMNqNwGn68FeoiqxbZncahW3by2nfccSeqbqJ7A/To3YfNmzdz7bXX8swzzxz3eV8+fTpdWrXiriVLAFi8+DaK6jZkyLARJ/zOe//991m5cuUJ1cjNWrUhtUFPqgy+EVk10Uwv99xzDxCfoL777rt06daDbj16895779G8VRtcHpVAOMrrr7/OPffcw+LFi5OKrJ85dOgQsqJQMHElhZPW4PKov0mx9Ffw9ddfs3Xr1uP6AW7atIlAJEZWu/OpNvJWdNt/Ws0gj8ePP/5IzcLaBDMrYniD3Pir5i5l/G9QlqAui7//yezbt4+IYfJkMMwnKanU8vlPqwLmv4kPPviAnp0707NTp9/8ff5PwfR42BiKsC2Sgt/j4eOPP05uW7duHRmhMAFdx5Rlxhsmr4QieDWNlStX0sgf98Be5gtQXLnKMed+4YUXqJKdTV5GJk899dRpjadX585cZdk8HgyRJknsjsbYFI6giiKXT5/O3r17qZCRQSXbJmAYvPzyy7z99tv06NiR6uXLk2MYNPT5qJWXx48//kj39u1pZVmcZ1pEfb7kHHLJnXcS1jRq+3xkxWKENI15tpdmts15Q4fy3HPPnbQx9fF47bXXiOk6G0MRpls2jQoKjrvftm3bCNs2dQMBAobB5s2b2bt3LxUzM8k2TcK2fUzPoRMxbuxYLkhUM4/VDfombAhzrdM/x9/B7bfdhk9VyTJN2jdrdkZ5gx9//JFt27YdV5x1plx0wQWMTTy/iwyTsb+an/+akpISZs2alWye+Nlnn/3uMfxWqtUoIK1Jf8r1uBTNtP+SqsE/gstmzCSYU53sTuMwAxGefvrpv3tIv4nt27fjDYSIVamDbnmPO/cq4/8XZQnq/zI+/PBDenXpQs9OnX63/9Xx+Pbbb6mam0u2aRI0zT+0tKCkpITa1avTwbJpZ9nUP43P6amnnsKnaWSbJn63m8yETcDI4cMJWRZVc3J58803+f7777nxxhuZPn06mtPJB5EU3o6k4JSkUmrAN998k6CmMcf20szlZqCqERRFWjVqVOq633//PV1at8YpipSTZd4IR6l9nOQwwA1z55Ki6/ikeDfsVf4guiyT7vZQXpZ5OBCivq5TOTOTxoWFbNiwgUOHDrF3714Mt5u1gRCXmxYeQSBbllEdAk8EQzwVDON0OOjq9pAmSRiKQp38/GNW6rds2UKqqpIrySz3B9gWSSEgirgTqmufIHC15eU2rx9LkrjEtNgRjZGnKFSvVIlrrrkGZ0LpnC3LLPL68Yoig1WNkZqOz+mkab16+DweUvx+bEFAcTh4L5LCuwmbigGJQG2CYaKLYnJl/F//+hdpwSC6KGLKCroskyaKjEj4Z8+2bGpWyqPPOecgCQLlJInbvH52RWPUtCwefvjh5H2OGDiQym4PGYlA+plQGFUQOPuss8gOBEj3+5l88cUMPvdcAorCzmiMjQlfcM3pxHS5sAWB2oqTWoqT7HCYmZbN7miMdFmmrqZT1/bSoUULnA4HLVxulvj8BESR7t2709zlpn1CpbvMFyAvPZ0dO3ZQWLkyfsNg0rhxyQTx559/Tq9u3cgKh2lWrx4ffPABEJ9shVSV9yIp3OsLoAkCqiDgE0QKatbkuuuu46uvvkqWRkJC4app3OsPsNIfxPR4qFytBlkdxpI/ZimKalDdNKlkWZw/bBh3LVlCis9Hbix2wh/xw4cP07ZtW1yJBH9mJMKqVauQZIWCSauRVStpV6HaQTQ7QK3xDxAu6kQoHDmuB/dPP/2E4HDwccJHXJflZLK9Xv2GuFQdO6cmouwit0IlvvnmGz788ENC4TAOh4PUxv2I1e9Bn34DcKs6bl8MUXYSy8iMd2Rv355wQXuKp60j1rA3ktNDqFY7XKrOa6+9xooVK+jSqhXnDRuWTIq/++67bNiwgRUrVmB6PLhlmeZNm5JSFD9PZtvz8PhjZLUfE7cykZ0obo2schVZv3598t4C4ShVhtxI4eSH0Gw/Xo+HgbaXaGLyeLqcqKTuqaeewrB9xCrXwRcMH6OuKCkpwRuKUrHPlRRNXYudWoF58+bx3nvvkZFTDklWGDh4aPL9O3r0KLOumk3rdh1Zctdd9D7rLIpsm+ZeL8XVqh0zQRk6fCSGL4zL8FK1Wo1/vBro17zzzjvolhdF85I3cC6FlzyCN5LOpk2bfvM5Dx06xPr16//RE88y/lzKEtRl8fc/mYaFhWQqCt08KtfZXvya9rtVjv8kjh49SmYkysWWzcWWTUYkwocffsiTTz55jPL1yJEjfPTRR//o3655c+bg9XiIahqD+/Yt9Xvt1TSW+wOsDsQt94oVJzlOJ93ateOVV17Brygs9wfopWq0b9a81HlLSkrofdZZZJkmUU1j+iWXsGfPHm688cZkA7rjMeXii2lh2dzu9eNJzBPO1TSqKwqVTIsHH3yQ77//nldffZWvvvqKn376iVggwBTLZqxpkRoKsXz58uSi+/fff88Vl1/ORRdccIzX8datW3n00Uc5cOAAq1atSsZqKX4/tfx+gqZ5Rt7eGzZsoLJt83E0xjJfgPzc3BPuu3fvXp588slkgvO6666ja0LFPcm0GdCz52ld880338Sv6zQLBNFkmfq6wTDTIi0U+tPfu7179/7ma2RHIjwSCLEzGiPHNH9XXPRLFi9aRNA0yYocf07wa2666SaKLYtV/iC1LYsbb7zxtK6zatWqv715ou0LUn30HRRNfQxvJO0f4UN/OrTp0JmcLhMonraO1OKOzJs37+8e0m9mz549rFq16rjVwmX8/6MsQV1GKRYsWEA7r5fd0Rgzf1XS9Uewf/9+5syZw5w5c45bWrVt2zaGDRjA+cOHJy0CvvzyS2bPnk2DhJL6RtuHV5J4JhTmSstLcZX/KDoPHTqE5nRyl88fL/U3jGOCs6VLl5Jm26QqCk1VlVS//4SKwQ8++ICcWAxFkujSuvUxXtU/8+qrr3LTTTdRWLkyFdLS8GoaZ7k91Fac+CSJoKZxsWUz3+vDp+tJZcEN11+PR1HwKAqzrriCQQMGUJSfj+xwICdUzBfpBqN1g5BpcvjwYQ4cOMAFI0fSoWlT1qxZQ9f27fEIAumSxAKvjy3hKJYgsMof5LVwFKfDQSVJIuByEdZ0ppkWO6MxCp1O8hWFoKZxnz/AO5EUgqLIv4JhOlk2HqcTw+mkRrVqaIlx1FKcZMsybdxuogmPZ6fDQYHi5PlQhJYuNx6Hg7Bl0b5ZcypmZOATRarKMlGPh8q5uRQrTnRB4DzdICCKxESJsKbRrnlzwgnlyAuhCJmGkbRFAahXvTp32D4sQaCO00m6JOFxOEgLhWhu2dztC5CpG0yaNIna+fnEJImgKNLC7SYvK4uCqlWxEgnqoCzTqX17Wlg2awJB8gyTYcOGcdddd/Hjjz/SulEjMl0uUmWZ7FiM9evX4xFFTEHgCsum0OmkU5u2tG/WjHGWzUuhCNmmmVQvVStXjv6GyRDTolxaWjIhWFJSwqjBg7HcbhRRpJPbw+5ojEGaTnXFSWPLovdZZ5V6t3788UdcssyWcDTe6dvpJCOnPBX7zqbwkodxmQFW+QO8Ho5iuN1osszaQIjbvH40SSoVOH7yySeMGjKEShkZ+AWR231+dkZjZEoyHsNL3QYNsSMZyLIT2a3jr9IEPVYRfzCCIIiEJImxukFQ03jhhRdKjXPnzp3okkwnzaCXZuARBKoOX0iNC5chKm7SWw6NNwep241Lf6E+37ZtGx5VxeFw4HS5adu2HZHaXagx9p54klpx07BxUxS3BzMrn/wxS/GWr41dvnY86KrbLen5djx/RoCY389KfzD+t+FyYfuDpOQVo1teevbsTaXK1fB4I5Q7+1LSmvQ/pnFJRnY5crtOovqo21BcboYl7H+usuxSDYlOxDfffENBcV0EUaRug8bHfPe1aN2OrHbnUzxtHdFabZgzZ06p7S+//DKq6UdWLTyhTDy6xffff0/TFq3JaDGEWhMexJ+am/THvOaaOQQy85KqCVkUeT+Swu5ojLCqsmDBguSiCcRLYXXLS1qT/oQr16Pb2b1OeU9/Ns8//zwzZsw4re7wixcvJq2gFTldJiC5VJy6l9btOvwjPfbK+O+hLEFdFn//Uzly5AiiILAlHKWfqmFL0n9dU7FTceDAAdyyzM5ojJ3RGG5JwquqFPn85MRiyWrK7777jro1ahDRNEKWfVLrgC+//JLRw4bRqLiYzHCYRoWFvyvh8c033/Duu++etir1448/5r333kvOSw4cOMATTzyBS4oLYd6OpKAKArd5fVRISeGHH37gkUceIdXjobqiUFWWyc/LS1r9Qby6zO/x8GE0xuvhKK5EpWR3r49KpsXUiy8+7lh++OEHRg0eTHHlygwfMoTsUIhip5PXw1HOsb3HxCFffPEFltudrDaURPGEc6LTYcaMGUmP44tNi2EDBpz2sYcPH6ZVw0akGQa2Rz0jocDixYupa9tsCUc5x7IZM2LEaR336quv8uCDD7Jq1Sree+89rrj8ciZcdNGfatdQUlLC0P79MVwuLI+nlGjndCnIy+MKy+aJYIiAqp5Ro8QT8fnnn2O53TwZDLPY6yc9FDrlMUeOHGH8mDEUVKzIuPPPP24l3Il44403SEtLw+PxsGLFit8z9N/E5EumYodTCeVUpVZRnTMa+9/J0qV3YwWipNbuhGH7ePvtt//yMfz00090PbsnitNJtRoFf6sSvoz/HsoS1GWUYtmyZdSybV4PRxlo2Qzt3/8vu/ahQ4dID4e5wLQYYFkUV/1P4nndunVUtCw2hSOcb1pJhewqf5AKqWnJ/davX0/Yo5IlyYQkiQ6tW5e6xu7du4l4vbT1+bGcLgYPHnxcK5NDhw7x9ttvc+DAAUpKSk7o57Z3717efvvtUirt/fv3YyhOxuoGbVxuTElCc7nYHI6yKxoj4PFwVtu2DB80CL+u08frJU3Xk75y4y+8kHMNg3X+IM6EInVnNIbkcFAtJ4cOrVrRwbK50fYRVFVkUeRef4AaioLbISA5HKgOB2sD8Y7TTkHATvyoy6KIVxBxOwSaudxMMUz8Hg/3+AK8FUnBEkWa6gaGojB6+HA+++wzOrRvT22nk09SUnkkEMISRSbrBl457gXdN9HQ0BAEKsgyFWWZF0MRWug6lijyVDDMJYZJUJapkJnJFMNEcjgYpGpcpJu4HA7auz1Ur1gRv8uFKYroinJMUH3jvHlkGSY+QaCXqnKpYREURVRB4BxV5algCEMQqOT2kGUYNG/ShLysLGpVqsTgwYOp4vFwnz9ALcVJJ7eH/j16MGzAALIiEbLS0hh93nlJhcIPP/zAokWLGDduHNVzy2HJMpVkGTvRTLI4P58ffviBBjVrstDrY1c0RrHXx+rVq/nyyy8RHQ52/awkVpRjGtbs2bOH6dOn00qPN4w82xNXwD8ZDBG27GPes0snTyaoqoQ1jXGjR7Ny5Uo8moFL1ZEVJ3NMiwstm+xYDE0Q+CCSwouhCKogEPZ6+eqrryiqUx9BEEn1aEgOB7WdTmaYFq+HowRFkXCdrnQ9uycTJkwgV1VRdR/F09ZRc9xyJEkhLz2Dq624H+Fwy+byyy/n1VdfJZaWiUszqVSlOi6PRrSoE77cIhyiRJWhN5M/5i4E2YmZWZ1K/a7Gl1b+GKucgwcPMnHiRGRZxrIstEgudoU6RIq7UHXEQnS3iiZKWFYQyWPi9Bi4dB/uQBoewyYUiRGtVIjpC3H77Xcc8/xSfD5WB4JsjUTxezy88sorPPTQQ2zfvp3PPvsMzbQJVG+B25+GlVWd/ucOKnX8iy++SCw9E920GDJ0GBkJ+5Z8y2Leddcd97vhl1w8aTLRmi0pvORhItUac8UVVwDxgH3koEFIihu7XBF5A67FZUeS1h0/8/LLL2OHUqky7GZSm/SjfKV4iW+dBo3J7jyOoimPEsquwurVqwE46+yeZHW4IK42r9uV9FCIUZbNpZaNWxRJySvCsH3JUuBnnnmGcE4Viqeto9rIW4mkZpzynv5MNmzYgGH7idXvgeEL8cgjj5x0/61bt8YT7M0G4k0tx8hR55Ulp8v43ZQlqMvi738ydWvUoJtlca5pUT49/b8maXImtG3ShHq2l/q2l5hlc5Mdt15r6/NxeyJmvvPOO2ni9bIrIazp0qr1Cc9XNz+fvqbFRbpBUBQZZ1o0LixMbv/hhx/4+uuvT2tsGzZswKtppOoGDQsLT8v3+Zd88803lEtLo5bPh6koeF0uDEEk3+mkkmlx1eWXA/Dggw9S7PXycTRGvqJQyeWipu2le0JAtG/fPmyPh+X+ANfbXkK2TZ2EJcjaQIhK6elA3CKrb7fu1M/PZ+ldd5Uay5EjR6hfWIgqCARlmaBllbIggXiytGFhIVkuFxFZpnqFCr/L03bhwoXUtiyeDYVpa9lMnTSJXbt2MaRfP87t1euUCwdHjx7l7bffToqZTsTOnTvZsmVLMib46aef6NO1G5bHQ9PatY9rG/lrJo8bR5phUN6y6Na+/Z/i5fv222+zZs2aUu/fG2+8QZph8EEkheX+AOVTU8/4vFu3bqVGhQqk+gPc/AfZle3YsYOgqvJBJIVnQmG8mvaHnPdk7Nmzh9q1a+NwOJg5c+af8hl89dVX3H777Tz++OPHnP+5557joYceOuO/87+b9evXM2fOnL8lOQ1w1113EcypTq0JDxKrexZ9Bww89UFl/M9TlqAuoxRHjhxhcN++eDWNhgUFx/VZOlnC9vfw8ccfE9Y0dkdjfBiNIQoCnVq2pHFhIU888QRjRozAq2kUV61KjSpVCMgKhixz66JFyXPccccdtPfFA7MFXh8t69UrdY2FCxfS1RcPcG/x+mj7K2uPhx9+mOZ16hDSdTIMg4jXe8Iv9bnXXotHFHELApbLlSybev3116lg2yzx+TES1hnF1atT3jTJtyw0SWK6adFGNyjndLHKH6Sly031ihUpKSlh6uTJnGWYfBhJISKK1HY6qZnwK66rOHGKIvcm7rG530/U62WqZTPL9sYVJrKMIYqokoTlctG0UaNkw8gKGRmkCXH7j3RRRHI4KC4uxnS7ccky7Vq0wEh4UhfoBheMGkXAsvA4HIzWDaorClmRCLogEBBEZiXK5EZoOk6HA48o0i3hMdZP1clOeE8/4A8ScLtZsWIFHocDZ0IdXi2RVC8ny3gEgddDEbaE4orPMWPGHLPS+uSTT1IuI4NqctzvurnLxUzTQnE48DgEuntUUkSJqaYZb1bYsAnBjIqoHo0LE+OaYMR9sDu3a8fSpUuxRJEeqorqcFC/sLCUEiYtGORy08YUBHZFY2yPxhAdDg4fPszq1atpULMmhqKQbhjUr1WLH374gfvuuw9DEGiZsAQxRPG4ybJ///vf1KhYEcHhoJIs09HtIV1R6NauHRBXiLRs0oSwqlKvoIDNmzcnPRiPHj1K3Ro1qGOYVNY0MgMBOjRrRvu2bbEkCcPhwCuIjNNNnLLMRePGE6nZiloXrySUU4tUSaKHx0M00ZDT8KdiRbPQPSqpuo4uySiKi9TG/YhWa0aeahB0u4m4XGRJErYk0al1a/wuN06nh1jj/qQ1G4Rm2kiyjFsQKFQ1BFFGECWs7JoY6ZVx6zZTpl1aKvD78ccf6dq2LaIgkJOWRjAYRBAEBMVF7lkXk9luNNWcLp4NhWnm9uBxeUjLyiW1cT8q9JqB4nQTqVhI8bR1VDznSqrVPLbpzqpVqzA9HjyKwpQJE0ptW758ObGq9ePH952NavpO2Vl7yZ130r1dO66dPfuEidDDhw8n7/PCi8YRq9MlrpAuaMu0aZcC8cCtlmkhOgQC1VuipZTHqRpJT++fKSkpYdCQYShOF4b9H/+1jRs3Yto+NMtHoybNkwtl999/P6Y/TGqdzuiWl8cff5z+PXpQULkyocrxe81qdz6dunYH4hPlQChKSp0uBHNrMGDQkJPe/5/NhAkTiTXqS/G0daS3HMqQYcNPecxzzz3HiJHnMX/+zWXJ6TL+EMoS1GXx9z+Zb775hqmTJzNx3Lj/t6q0Q4cOcdddd7FkyRLO7d2bcyybtYEQuabJ448/DsR/w2vZNu9FUjjfso+pQvslTllOVhNFRYmFXh8V0+IilyeffBKvpqE7nZzbq9cpE2CNCwuZnxAo1Pb6zkjFC7BkyRJaJ2L5+V4fDQoKeOKJJ5g1axYrVqxIXv/HH3+keb16eN1uFIeDHYlY9Jd9fFatWkXF9HRqVKjA6tWr8WsaV1tezrJsenbuDECvLl3obdnc5fMT0fRSNgXTpk0jT1F4LhShvdtD/aLi44558vjxNNJ1lvkClDNMVq5cydzrruP8ESPO2Dri8OHDDD/3XDKCIXp26sSBAwfIy8pipGVzoWWTGYkcd9Fl165dnN2pE+VjMc4fNuyk6vUFN9+Mz+MhTdfxejx4FYXCKlXO2PParSi8EY6yIxqLN0D/VfL+97Jy5UqCmkYjv5+McIQvvviCkpIS3n77baKaxpvhKIu9fipnZf2h1/2ZzZs307FFC7q1bVuquu5ElJSUMLhvX8Kqhu3xMP+GG/6Ucf2aH374gT59+uBwOOjVq9cf2jxx//79pGZkkVKtEd5IBjNmXv6HnfufwMcff8xVV13FkiVL/tIY+ZZbbiFatQFFU9eS0XIIZ3U/PUudP5tDhw7x/PPPHzPfOhn79u1j7ty5zJ8//29v3Pn/nbIEdRlnxMcff0ylzExkUaRVw4Z/aKL6yJEjVC9fns6WTVPbJqLrjLVsFnh92B4PdiJwrFapEl5V5RrLSxfTSgZfEC/fy4hEaOD3E9S0pKLwZzZs2EC6YbDE56eNZXPheeclE+7vvvsuAU1jvtdHJ4+Hrh6ViabF4L59fz1Ujhw5gkuWeSkUYUs4ikcQaFRUxJEjR7hi5kxstxuvKPKAP8jWSAqmKCI4HBTWqEFxQtnwVDCMIYrYgsAEwyRLUcjLzGTeddeRkxL3dtYdDtyJf7YgkCFJaA4HUY9KV5+PFL+f559/no4tWlC/Vi1CCZXwAMsmxTQ5x7IYalnkpqZy+PBhzu7ShZZuD9daNp5EEtUQBLxOF5MnT2b06NHUVFUsQSAkikQNA00QOE/Taeh0oggCfpcbryDQwOkkIsaT1DFJIiMc5tNPPyU7JYUq3rgfotflIiJK6JKUVM3279ePoCAyWo83kDxP0xmh61RTnAzTdMrJMo1dLjq6PRiyzLvvvlvq2X/77bdkx2KkSBKTEypqxeGgq8eTDPQrKgrVKlRAtYMUTXmUcj2m4xEEmrjdaILAIE0jrKo0LCjgWtvL4wn1tS2KFFapklTOu2SZF4JhTEFgqmFxgW5gKQpvvPEGIU3jBttHK8uid9euyUD64Ycfxu1wcIluMMkwERwO1q5dS1owSMA0ue6aa6hTvTq2phELBmnkdPFJSio32D68ssywcwfSukEDmjZsSGVFYY7txS+KnPULu52dO3diKwq7ojHejaQgCQI1K1XibNPiLI+KLghJD/J2rVrRtWt3VMWFJIhYgXSyXC5SvV7aNm7M1KlT6dWnP9lp6aRLEnWdTlSHA1uSUGQnlVxu8mSZsCxjiiL3+wNUlhXqeTw84A+SIUnkdJlI0ZRHUWSFVK+XHFnhlXCUK02Lzq1a0XfAQM7pN4AdO3Yc87d05513Ute2+TAaY6Rl07NLF+rXr4/D4UB2unDrNn01LVkG2rNLF3zBMNVGLaZo6mOYgSiaHaBin1mkFLY7YfDz448/HrdB4dtvv41u+cjqcAHhynUZPPTUydDjsXbtWubMmcPcuXOpVViEKEn4AiE2btzIJ598QlpmNrrtJ7tchaTiZ86cOfSwbc42bAxvFDNWnnoNm5wweNy8eTPVahQQjMa4ds5cdu7cSdMWrcmrWuOY0s8NGzZw7bXXsmXLluT/rVy5El8sh7wBcwhXrs+48ROT23bs2MHUadO45ZZb/hIl3i+rTn7NypUrsULxhofelCzuvPPOP308ZZTxa8oS1GXxdxn/HL7++mvOat2aimlpXD59ejKBe+TIEfqdfTaKJJFfocJJk4dntWlDQ8umnUfFkiQCqsrihMilem4ud/j8bIukkG2avPjiiycdT4fmzZlg2bwWjlLesk67OeHPPPHEE+SYJuuCIfpaNuf2iltrvfnmm1TOysKn68xOVFuVlJSwc+dOoj4fl1s2Myyb1GDwhLHChg0b6NqmLReMHJnsaVKYl8d9/niT+MZ+f6mEeqdOnejmUfkkJZVphkVOOHzc8/bs1ClZSdfPtmlUvz61LYuJholf19m+ffsZPYNf8uOPPyKJIjujMXZFY3hkmbBtEzBN7rn7bgCuveoqPJKEWxAYpukUWRaLFy9OnmP//v28+OKLSRVyzO/niWCIFf4AflFkTSBIH1WjY8uWZzS2zEiErh6V3qqK6fGU6hPzR9Cibl3m2l6GajoZioJbUTDcbhYvWsQl48fjlCSClnVaXs9nyo8//kjE6+XyhNd7ubS0Ux9E/J3ctm0bn376KRAX3fTu05/K1Wsxd+71f/g4f3ndK6+8EofDQVFR0R+2OPfkk08SKVed4mnrqDL4RjJyyv8h5/0n8PXXXxMIR0kpak8gM4/zxoz9y669f/9+8qrmY/rDeAMh3nzzzb/s2ifi4MGDVKleg0B6eXTLe1r2WEeOHCGvaj6Rao0JV6pNk+at/oKR/u9SlqAu44wY3LcvoyybndEYTWwvl112GXPmzEkqGX4v33zzDXPmzOGmm27Cr+u8FIrEfVNlmY5uNxFRpK7ThSGKbI1ES5WvQbyT9ehRo7jwwgt55513jnuNhbfcQuOCAs4bMpTXXnuNjHAERZJoUFBAw4SaYZU/SGVZobdlM/a880odX1JSwr59+9BdLh4JhNgQDOMWBFrUq8fVs2ZRy7KYYlhogsD9/gBbI3FP6MVeHzmmSdiyOMeyybcsquflcXaiYeACr48CxUmmYTB+/HgMQeDRQIguHg+TDJPd0Rit3W6qu1yMGTOGBQsWJAMDgDVr1tAgkfxe7g9gCAI7EzYTfo+HJ554AlOSmWHaDNF0LkgkiCcZJqmiRDm3m+qGiS4IPOoPsj0aI+JyIScUGzuiMWSHAy2hVh6m6ckEt+p0JhNk3333HZs2baJTq1aMMS3u8weoYBisWbMmuT09HKbY6eRfwTD5ikKmJGGKIkGvF8Hh4KPEuC1BoHe3bsd8hn27d08GyUM1nVRJIkWUuNH2UVNxEtR1Ij4/iuyiQq8ZpDcfhOyMJ6evt718GI2RZZoMGzSIqoqTIqeTy0yL3dEYTQyTuoWF3LpoEVMmTsRyOqkmyzR0ugiKIn369GHZsmW0C8QD/Xt8Aern5wPxJF+TZs1xCCIu2UkTl5saFSsStm3u8QV4IhjCLYr01w28gkg3twePIFBLceJLLGK00w1u8fqwRJHr7fg99lZVsn4RNO7duxeXIHBVolmNKgi4Es0jd0djOAWBqCgy3jDRBIHscJgbbR9bI1F8osSIESNK+SDv2rULXZa51x9gvGHiF0UyJIlUUaS1281cy0tVWSYgCHySkkqB4uTyxMSsiizjUtyowQxsWWaVP8gwTaeW4qSuZTNr5syT/s0vXLiQlgnf+8kJ9dNPP/3E+eefj8PhIC8vj4jXSy2/n4ARb6Rz2YyZWMEUQjlVKSiuy8KFi6iSX0Dnrmcft1zz448/Zvbs2dxzzz3HndCtW7eOjl26MWHipN+0Kj7/5puxw6lEarVFVFyEizsjqxZpzQZSsXI1IK4W2r17d6nk7+eff05mNEpVrxfT4+Hqq68+abf0ojoNyGgxmKrDF2B4g1SqUp20RudQvsel6Ka31PfBz2zatImHH36YgwcPUlJSwoyZl1Opag36Dxx83KY7R48e5fXXX//TGpHs37+fwtr1EEWJqvm1jrG/+ZmlS++mR+8+3Hrr4j+llLOMMk5FWYK6LP4u47+H0/mdOHToEAsWLODqq6/m0UcfTValAdSqWJGbvT7eiaSQbhi88sorJz3X9u3bqVGhAqbHkxS7nOl4Z156KeVjMTq1aJn8LSyuWpUrLS/PhyJENK1Uo94tW7bQtnFj2jVpwoYNG7jrrrtOmUj/mUULFpCi6zTz+YnYNt3ateP2226jpKSEJ598EjVh0+cRBCaOH3/cc6xdu5agptEuECBomlTLzeVBf5BPUlJpHQj+bh/01o0a0cT20jJhR/agPxgXkLjdfPXVV3iUuPjh1XAUtyDQzzC57LLLgHiclxoMUlHTUUWRRsXF5GVmcq3t5RLTpFCJWxXe6fNTs/yZJR+b16tHsctNG4+HnFjsD1/EH9q/P9mKQie3hyuteNXmCn8Aw+Vi3759pSry/mg+//xz7IS3+IcJb/HDhw/zwAMPMKRv3+Q7csp7GDGSaH5TKvWbjR1KLdVo/M9g5cqVqKpKamrqSX3nT5cdO3agW15yzppISkEb2nXs8geM8p/BU089RbRcPsXT1lF12C2kZeb8pdc/fPgwH3744T+mie1DDz1EuFw+RVPXUqH35VSpUXDKYz799FM000vR1LUUXvIIgiiedu+BMs6csgR1GWfEwN69udCy2RWNUd8wsdxu+tleMgwjqUL4o5g4diy5pkldr4+gplFOlrnbF08K1na5KNY0KpkW0yZNAuJeXX5NY5xhUsk0mferBh/Ho1PLlky1bLZHY9S0bAKWRUefjxSnE1WWaVq7dik/sG+++YbCKlVwyzIZkQiqLKM4HARNi7feeovu7doxL5FUbK7pqIqC7HCQKUn4RZFMTeOuu+7i6quv5u677+bVV18loGlcbJhUkGWmmxbn2F7mzp1Lms/PtbaXDm4PAzWdDyIp1FCcqKLI3Llzj7mX/fv3UyEjgwZ+P1Fdp1J2Nu0sm+6mRbVy5bjsssuoozixBAGPw0F5WWapL0CeJCM6HGyLpPBRNIbb4WCmafF0MIylOCmuXp2KikIVRaGpy0VAkggmEpVvhqPoLlcyKXjo0CEuuOAC3AmbiQZOF1vCEaroOlUyM+nQvDnDBw6kvmmRnXgmXkFkgmHGk+qyjOVw0NOjMlLT8YoiIwcPBv6zWv/FF19wx+23k20YXGyYGKLIUFVjrG5gCgLNXC7SRRGPIOAXRSIuD4pL5ULdYHGiW7kpy0S8PmoV1aFvr16ENY1husHbkRTyFIVeHpWKpsntt91G906duCTRyGWYYTJt2jQ+++wzIl4vZ3t9ZBkGN15/Pa+99hqWqqK4NWpedB/lelyK5PTw7rvvorlcvBiK8G6iAU6hohAWBFIliTxJRncIlJckTEHgctPivUgKLoeDiCgyQNXiY3Y6kyWZhw8fRlJcBMPZBGMVEAQJQxTpoeucY1mYkszchP3KAE0jpGks9QXYFo0dVxm0adMmck2TXdEY64NhYpLE+mAYzeHALQh4hbjXt+JwUEmKv/OGw4FPFOmnagw1TEKGQYEdTzQ/4A8S8niYMnHiKQP5AwcOULt6dQKqSiwQKLWwdPfdd+PxeIhGo9xyyy2lyjLXrl3L+PHjSzXSPB5fffVV3L6iqD2BjEpcOO74E6+TcfToUWbMvJy6DZsy4/Irjkly123YlPI9plM8bR2+yg3J6jCWUEEHgjXakFOh0inv/8UXXzytktPs8pWo1P8aiqY+RiC9HKbtSyjJ1+JLyeTVV18ttf/V18zB9EcI51anavWap6x4OXr0KO06dsYOp6FZPubN++PLNq+88koi1RpTNPUxogVtGDd+wnH3Kykp4Ysvvjhpwr6MMv5MyhLUZfF3Gf87bNy4kZBto0gSY0eO/NsWRiulp/OAP8jOaIzylsXGjRuP2eeLL74gNRikrd9Pyi962EA80fbII48cN6Z4+eWXGTlyJLmGwRzbS45hsHz5ciDuVdu3b18WLVp0zL1/8803rFy5kjfffJOtW7dyzz33sGvXLiaPG0dN02JMQkH9WxoGPvTQQ0yZMoWNGzfyww8/sHDhQm644QbciUq8rZEUNEWJN+J2uXgyGOapYBinIBDxepOVedOnT+fchJXfRbpBVaeTZvXrUy03F5+qoQkClRUFQ5JYtmzZcceyd+9eenbpQsXUVHp07Zqc2yiSxAc/W8Po+nGrAU/GwYMHTxp/7du3j4DHw5PBMJ+kpFJLcbLY68NwuU64iP9HUVJSQov69anr9VLTtunZqTOPPfYYqbrO5ZZNedMs9X6diEbNW5HbdXK890l+U2699daT7v/FF1/Qo2NH6larzn333febxr5582bS0tJQFIXi/HzuPcHnero89thjNGrWkn7nDjptL/r/Bj755BMM20d6y2FEqjakW4/ef/eQ/lZefvllrECUKkPnk9qgJ63atj/lMT/99BPRWBppjc4hVrszeVXz/4KR/u9SlqAu44z48MMPyYxEMVwuctLTOTvh57zwOH7Ov5eSkhLWr1/Pgw8+yEsvvYTf7aazx8NdPj9hTWPChAmsWrUqGUjddNNN9PmF/3SHpk1PeY0OzZszw7L5KBqj2Ovl1ltvZfHixTz55JPH3X/GZZfR1YorbfuYFhMuvIj777+fG2+8ke3bt9OzRw9sp5Peholf05g0aRIdEsnN620vmX7/MQm7Z555hg6tW2M6XXT1+QkYBtu2beP111+nclYWAdMkOxJFEgQiksy1lk2KrrNhw4Zjxrd//35Wr17N66+/zoEDB5g9ezaXX345X331FfPmzcMjCFximORJMs1cLuo7XVSTFTRJ4jLTYo7txeMQSBFEdEGgc4cOHD58mDo1a9LI5cIUBNIkCVUQ6OlRaWGYdG71nzKXNo0bU+B0UsfpIkeS6e72xBXWositXj8XWTYhVeVWr48rTBu3Q8BMNFLcFY0Rk2UyRZGIKOJ0ONBEkS+++II9e/aQl5mJT1EwXS6W3nUXy5cv58IxY1i0aBFVsrPRBYEGThfbEkngxwIhHvQHcQsCuijS0e3hX8EwlQwDl9tDSqM++KwQttPJo48+SkFeZRRRpJqi8HE0xqWGybABA9i0aRN+XadpIEjQNJOKmzfeeIP+/fvTu3dvHnjgAcaefz79VA1DtSi4eDUV+8xCUtycc/bZNG/UCNvtxpAksmSZfEVBEwSeCIbYHY1RTpYZrxtUlGQCokgzpwtbELjb52esbuB0ODjb52fhwoW88MILXHbZZQQTiWhZdrEsoc72yDKTJ06kXcuWZMoyU0wLQxC46KKLsFUVy+2mb/fulJSU8NFHHzG4b1+G9u/P22+/TX6lSuQZBl5R5GyPylBdJ2qaOB0CpsPBa6EI9/gCqIKAJoo8Hggi/7IZpNNJldxy1LS9BFSVBbfcwsMPP8zzzz+ffD8OHDjA0P79qZ+fz+JfBK9Hjx7lk08+KWX7sHPnTh555BH+9a9/kZ2djaIozJ8/n5KSEr766iuisTRSqtbH9Ie59db/lHj+mnXr1hGtUCtetjfkJlIzc2jfrBl1q1c/rY7ohw4dokuXszCi2ZTveRn+9IrcdtttpfYZe9E4QhUKye54IZJbI1zUGdHpQXZ5KKxTnyeeeOKU1zkd7r77HjTTxhfNpG6DxkyeMhU7lEo4N5/qtQqPsc1ISc+iytD5FE1dSyC9/CmT+W+99RZWIErhJY9QbcQivP5Td2Y/U2bMmEG0ZiuKpq4lpXZnLhh7Yantr732Gq3adiCcmoHLo2P7AmfsbVlGGX8EZQnqsvi7jH8Ohw8f5s477+Smm27i22+//VOuUVJSclL7qb+C5cuXY3s8xHSdDs2bH1eld/fdd9M2UTG5xOenYc2aADz77LP4NY1GgQBRn++YhPGePXuoXr4CUxLzkgmGybixJy/337t3L5mRKE38AUKaViqZePToUW699VYmjh//m0r3l951Fxm6zhjDJKBpvPTSS8lt18yaheVyoQkCQZeLcmlp3DJ/PqbHg+F2M2nixFIVc/Pnz6eOrvNCKEJbt4ez3B5qV6ma3L5p0yauvvrqk46zZYMG9FQ1rrG88Ybo1aoDULtaNQZYFuNNi1ggcEb2lnNmz8ajKGhOF7cvPnGsOuGCC6hmWXQ1DDyCgOF0MXXixBPu/0dy6NAh7r33XlasWMGRI0eYMmUKYxLJ/pmWzdB+/U55jlWrVmF4A6RUrkMoEmPPnj0n3b9Ti5YMtCyW+OKWnL+2czxdxo0diy5JOBwODKeTp59++jed5/87L7/8Mr369GPCxZOOa3f4v8bsq68hmpZJnQaN2L1792kds337dgYMHMywEaNO+X6X8fsoS1CXccYcOXKEr7/+mhdeeIGorjPX9lLfspjyJ/+Qfvvttwzo0ZP6+fnceccdx2x/7bXXCGgakw2LqqbFtbNnn/KcW7ZsIerzoTudNK9fn2uuuYalS5ee0NdtxmWX0S2RoO5rWTQoLqaSadHN68PrdNLatOhrmIRMkw6tWlG/sJAsTWOVP0gny+L8YcOAuOfXpZdcQo/27ZPWFy+//DK33nrrMSvzJSUlcasJSUpaPvT3eo+roj4Za9euxRRFdkdjPOgP4HYI1PL7Cds2FbKyqCwrNHK5aOpyI4sidfLz2b9/P/v372fcuHGYgsjMhCq3ndtDRVkmFgjw2GOPJX285V/4x+mCwFPBMB5ZJsuMW5S8EIpgu934ZJkqikIFWUZNeD9XNk1sRWFRokt7B5cbVZYZO3o0KaEQEVFiezTGw4EQGaEQV11+OT5dJy8ri+eeew7D6cQQBFo5XSgOB1sjKbwWjiI5HNRUFGopCpYg0KC4GKdbxe10U11RyJVkfIZBSUkJI4YORXU4yJYkBIeDvMxM9u7dy86dO1m1ahW9unTBcLupUaEClseDKggM0XTKGwbdu3ShwDRpopkIoozT4UByOKisKPS0bIqqVsWRUB0P0nRMQWCkbnCXz48qCOQYBn63m06qSieXG9UhUKA4yZHiCW2/prFkyRL8Hg+pCa/oS0wLl8PBWN1gqmlROSsbiE8a+vbpQ8zno3JGBrffdhsbNmygWas29D93EHv27CEnFmOMZTPKsrEUhQqWheX2MHr0aBrWqkX3du3YvXs3giBiCgLvRlJYEwhiCCKmJOETRSxBoLlHpWPi/j755BPSMrJR3CpuVaeaZZFlmskqh8F9+9La42GJz49Pkli9ejUlJSXs3r27lKffCy+8gF/XaRwIELZtXn/9ddq2bYvD4aBfv37cfffdpFSuS/G0dVQ45wryC2qf8L3ftWsXhu0jo9VwIlUaEAyGGWvZ3O7z49O0U/rX9e7bH9UfI7XJAIqnrSO1cT/GXFB6Qvfjjz9yydRptO/clREjRjJk2HCKatfDzqpKatMB6Jb3D7PM+Pjjj3nllVeSC13PP/88q1evPq41Sd2GTUht0JMKvS9Ht7ynVP188sknaIZN5UHXk9XhAnLKn1z9/Vv46quvqJBXBY9ukpGdW8qW5LvvvsP2BchsM4po3e6okVyyOoylfuNmf/g4yijjVJQlqMvi7zL+OfTt3p3atk0H20vV3Fx++umnv3tIJ+Xpp5+mS6tWDD/33DNWY37++ee88847J5yLbNq0iaiuc4fPT2fLZtiAAQCc07UrVyTi9N6mxcyZM0slo2pXq0YrVcMnigzWdAKqelyxC8TneosWLaJD+/a08sbnHrd5/dTLr8HBgwfZt28fy5cvL7Xw/dNPP5325/Lhhx/SoLiYqT9XKFoWV155Zal9+px9NkMTdoQ9LZurrroqOd9YsGAB1113Hd98803y2n26d0eXJKJOJwFVPaFS+kSkeL08G4qrmPNkBVmSgLja97yhQxnUpw/vvffeaZ9v37596E4Xm8IRngmFccsyIwYNYt26dcfsW1JSwvLly5k3bx5vvfUWn3/++RmN/bfw2WefsXHjxlLWCytXrqRf37543W4GaDphVWXFihXHHPvJJ59w4UXjuGTK1OSC0datW3nwwQdPS/VdJTOTNYG4PUyRz/ebrUI7NW/OXMtLF4+Kw+GgoKDgD+2PVUYZZfz1lCWoy/hdrFixgu7t2nHZ1Kn/iGDx6aefZvTw4dx6662nXZ53+PBhNm/ejNcZ9wFOdbk4b8iQ4+779ddfUz4tLV5aZllkBIPc6Y2rGGSHg/ciKXySkkpQljlb17nctDBdLvJzc+l/9tlJ39+JY8fS0LKZY3sJa9oxpfkQD1auueoqGtaqRdDlYrphEhZF+mg6/8feeYdHUb1tePruTt/ekhBC770X6R0EBCkSkA7SFQEREFTsBQtFbKBioaioKGJDVFTsCoiioIAVBVGRIuz9/bFrPpGuWH+5ryuXkp05c2Yzm5x553mfJ2iarF279oTOb9++fYw65xxcjwdfxlYiKsuUyMlh4MCBxA2DNmb6iX11109WOMwHH3xAKpUilUpRu1IlGpgmflGkp0/n5UiMuCRRXFGwJZkiHg+uqtGwenWKJZMMt2zOM20cUaSsotC1QwfqVqlC7YwdxnmjRuFVFDZnksg1QWCwYVKvWnW6nHEGCVmmv2HiEwQ8gsD5lk1RWcYRRZ4MRRhjWuRGo8QNg5ciMS5zXAxRxDEMalSujKEoVNM0DFHEzKi9i8gyflEkV5YpnZdH67YdMEWR88x0YKZPFJl60UUEfTptPF4aeTxsiic5y3Ho17s3TWrXpmQySTHD4J1onL6mRbYkUUfTeDESY14gSPkiRWjfsiU5fj+WLDM/EGRtLIEripxjmKiyTFYsRv+M5/hEyyEvEqF2+fLMmTOHl19+mQ8//JCu7dpRs0IFyloWNzoudTUNR5JoUrs2A/v3JyylC8aWKDLIMDFEkWxFIazrvPnmm3z//fesWLGC3t2709ZxuTMQJGEYaF4f4aptSNRsR8069TE1jS3xJJ9mvMU/jMW5zvXTtnHjQ66fdqd3wlI9eAURXRTRZZmuls2KcIRiPh+9e/fm6quv5rvvvqNdu3b4S9Wl5uQniNXuRL7l8FIkRti2AShXpAi3Zz4vLbxemjVqRMczumLYfnTL5rHHHgPSVkJTMzct/WyHSy+9lIMHDzJ16lQEQaBUqVKYTpCcFoNxcyvSucuZx/wMrF69mm49ejFuwgXEXJdVkWhaue44h3z2br/9dqJZRQjFklw/Ix3yksgpSrFO41F0h0CZ+uimc4jK50h8/fXXqF4dq0gFZK+JFckuOLcT4ZNPPmH8hAu44oor/lBS9JYtW2jeuh3lq1Rn4cKFJ7TPvHnziSVzKFWu4inx9TsSBw8e5KuvvjpMGfbRRx9hByLUnPwE1cYtRlQ0clsOoUnzVn/KPAop5FgUFqgL19+F/HMwPR7ei8XZGk9SxLZPqlD4V/PZZ58RNE2ucf30dFw6NGt+ysZ+5513mD17NpdecgmNa9RgSN++BfcWF4wdS2vHZYJlF4gkvJLERRMnAuBTVdbFEiwOhrA1rcDe40iMHzOG6o7DGT6doCTxQCBICU1Dl2VcXSc7GqVxIEgRy+KaK6/kzttvx/B48Kkql06bxrJly46YCQJpO5WgYdDIttFFkZGmRdwwePbZZw/Z7vwxYzjTcXk3Gqeh4zBr1iwAzmjThoaOS0fHpfxvHlb8+OOPrFix4nddH2OGDSNPVWnu8eKXZNqcQCfusdi1axemx8OrkRjPhqOogsBkyyZqGId0F55K9u7de9QHG79m5cqVBAyDCn4/pYoUYceOHdx6yy3kWRYjLBtTUdJiE9Nm8pSph+y7f/9+sooUJVmnE/EqzahZp/5Rj7NhwwYuuugi5s2bd8i8brz+erIsi9MCQcoULcoPP/zwu8737rvuIss06eX68WkagiBQq1atQoVrIYX8iyksUBdSCHB6y5Z013WeCUeJSxKOqjHvzjsPK3KvW7eOkK5zjevS3jAwRRFdEAhKEl5RpKLHwyDDxCsIdPB4+TSWINe2Wbdu3SHjNKtdmzsDQbbGk1Tw6RSLRunXs+chSoe5t9xCBdtmjj9ArqJwg+vnPNOiSDx+wsXpd999l5jfj08UqamqhCSJvoZBR5+PgCjhEQQmZtq4utkOgwYNKlAjQNp3ztQ03orEsAWBSqqKnvFGvtrxU0xWuNpxUQSBAbZN/Zo1cRSFUoqCoyh0Ov10fv75Z7Zs2UJuIoEmy1QpXZqY388ljstFtkNCkhlpO7Rp2gzDdglWaIJquJiyQkuPtyCI0BFFfJlis+3xUMQ02ZzxOw6KIgFRxFUUwprG46EIdwWCuD4fpihyVyDIeMvGFkXK5ORw4MABLEXl+Uyhsqgs45EkQh4PpijSyetjazzJENPC1TQm2ek2NJ8gMM8fYJhh4ssonG1RJE9WqOzxUtrrpaTmISZJLAiEeD+WICZJ+CWJdk2b0rpZM0KSxPWunzKKSpfOnbly+nR0TSMeCNDl9NMZfPbZvPzyyzi6jibKeAWR2/xBRjkuefE4EUliUzzJkmAYWxS5OxBiazxJDX+A+++/nxLZ2dQMBLBkmWFGWnnSUjeIyDJldItIkQrYbpAG1avT0nVpbFkEFYXVkRgDHJcGNWpwxRVXFLQ87du3j5tvvpl61WtwWrVq1KlUiWsySv6Ofn/BDcPPP/+MKkmEi9eg5qRlRKq2oalucr7jUrN8eQDO6tkTvyTRyuPFlSTat25NIF6EGhMfodRZ0wsUu1MnTaK54/JYKEJlx+Guu+4quCYfe+wxXNfF4/Ege3QCxasRiSdP2Kdv2uTJ5FoWtfwBaleqVHBjs3r1ajTdJlKtLWXPvhafHeSVV16hd9/+REpWI1KlJbppHdEP8rfcfvvthMvWJV7vTFQzgKI75PfpW/D6qlWraNSsJV3O7HFYsOHnn3+Oz7SJ1jydYKlatGzTnnXr1v1PeDEfOHCAytVqEitTCyteDEn1EM/KOez3ZyGF/BUUFqgL19+F/Lns27fvhIOz6letSl/HZbLtEHXd313Q+itYtWoVVTIWiM+GoxSNRk/JuC+++CIhw6BHMEjIMA5bj+zevZu+PXrglSQeD0VYE41hiiKO18uWLVvo2bkztV2Xtq6fSiVLHVNYVLVUqQKFa1nDpEg4TFLT2BhPFnTBbUtksSwUoXR2Nrqm8XwkykuRGKogUDcQJBkKsW3btsPGHpifz0UZEcJA06JaxYoF3aS/ZseOHTStWxdTlrFVlS5t2/Ljjz/iURQ2ZDyhk6b1hzvUNm3aRP9evRiQn891111H586dufzyy0+JEveG667Dp6pokkQvXWdbIosBrp+rrrrqD4/9a1KpFKOHDkWTZUK2zapVq465ffumTbkus5Zv6w9w2223cUbr1tyU6WLtoetkNe5D1fPuR1G1gjXorl27GDduHJrPoOrYB6gx8REkST6iKGzbtm04gRCJul0IFinNuAkTD3n9lVdeYcmSJYd0UP4ennnmGWbMmMH777/Pgw8+iM/nI5FI8NZbb/2hcQsppJC/h8ICdSH/am6/7Taa1a7NucOH/6GFRMv69Znh+rk7ECIoSVxsu5Sw7MOsRB588EGaBNNBjfcHQmRJMsVkhUtthxciMVxJopqqsjIcoYiiUN20KJ6dTYmsLIpEIgUJ17NnzqSoZdHIMMiWZR4OhWltWYwdObLgWMMHDy4I5zvPsnFUFcvrZf78+YfN/9cJz9u2bWPC+ecz7aKL6NCsGVMdl0/jSaqqKlYm3HBTPIkoCNRR0rYXtVSNmK7z9NNPHzLuwYMHKZGdzRDHpbWu41dUvILAuExRe5LtcJrmISpJDNANvJKEIYp003WmWjYls7O5ZNo0xowcSU8rbfPR2TA5o3Nn2jZuTF4kgiKKxG2bli1bEilXn1pTllOk9TBcScYSRTr6fFSxbfyWRTdfenE3wbKJWhZuxmaigeaho8/HfcEQIUlCFwRqGAalihUjIklsiSdZFYniE0TGjB7Njh07uPSiiwhKElVVjWqqRlAU8Yhp/+0sWS4IBvQIAi9HYjwcDOMV0sVonyDQyetjWyKL6Y5LSFH4JJ5kRThClixzleOiCQJeQaS0ohI1DHp16UKPM86gpU/ndK+P8l4vF1xwASFdZ000xiw3QFCUGGk7uKpGFVXDKwhkyTJbM/OP2jaWKPJKJMb1rh9LFBljOzwdjpJlWlx88cW0yPiwz/UHcSWJZrqOVxBZHYmxOZ5EE0V69+3Hjz/+yM0338xNN93EyCFDiLkuRSNRKlsWvRyX7EiE77777rBr7dlnnyWg61Q0TKKOU1Bg3bNnT9rDW7eQRAlJ9ZAVCNCmcWM+/vhjAL7//nsqlCyJmlHwP/nkk9ihGFXPu5+808+jfKWqBWMN6t2bCnl5XDB27GFqkI8++gifriMIIlmNehMvX48FCxac8Of9hRdeYOnSpQXq5M2bN1OtZh0U3Sa3zXBqTVmOk1uBhQsXsnLlSkaOHMn548bz4YcfntD4Tz31FG40G1FWqHb+IqpPeAjNq7Nz5062b9+O5fjJO/08sup1pXrteofs26FjZzxujFpTllOmz9VIqgd/LJvcYiVOKEgR0jYgPTp1on3z5if8MOufwo8//sj8+fNZtGgRe/bs+duCqgoppLBAXbj+LuTPY9HChVheLz5V5ZIpU467/ZdffsnQfv0464wzeOedd/6CGf5+fvjhB4olk5zuD1DWcRh/7rnH3+kEGD18OBMy6+9xls25o0Ydtk0qlcLRdZ4OR3k7GsfKFKi3bt3K/v37mT9/PjNnzjzi+u6QYw0dSj3HYXwmAPH+++8n7vOxNpZgpj+ALcnc7g/Sz3Fp17QpPlXlxUiMVyMxNEHgTn+AtpbNjBkzDht7+sUXc5rj8mAwTEX7/0UIL774IlVKlqRCXl5BFtC4cePQRZGYJBGTFSaMHUu9KlXo7bicbzskgsFDOs1eeuklikSjOD4f1x2hCLx+/XpOq16dysWL8+CDD3LgwAGKxuMFlnelc3NP+bpj7969zJk9m2KWxXkZv+1XX32VgwcPsnr16oIA9FQqxaybbya/a9eTDg584403yLYs1scSzPUHqVS8xDG3H5CfT2/H5flIlDKOw9KlS7n2qquo5DhcbLtYokRumxGU6X0VumkXdLzVqtuAWMVGhCo0QTUDRMs3pF7Dxkc8xoMPPkiyfD1qTVlO2b7XUaZClZM6p9/D+aNG4Xq9SKKIqqo8+OCDf/oxN2/ezIUXTmLGjBl/u4d9IYX8FygsUBfyr+W5554j27S43R+kmeP+oQXgzJkz8Yoi/kyr2bZEFpc6Lp3atDlku+3bt5MVDtMxEMQRRaqoKkFJKkjczlFVRpoWm+JJyhgmI0aMIOKm/W4fDoVxfD6+++47Xn31VebMmUOrVq3olCm6Xu34CXu9BQW/5557jpBh0CsQTBcES5Qgz7JwNI0B/Qfw/vvvU6tCBRxNQxFFon4/zz//PMWSSfrZDqfbDjmBAOMclwWBEBExbdHQzafT1ptWFvsEgT66wTmGSUDXDwtwhLRNwLCBAxkxeDD1a9UiLklYgkAPn46VCTIMZryk23m9eAQBn5Au7J5jWuSoKpIg4IgSDwZCdPL6MFSV119/nYsmTaKm45CvG9iiiEf1kGjQE11WuNJxuTcQQpdlrrvuOhKhEDVUjVciMdp4vZTXPOiiSHVNIyFJzMsUZlt6vTT3eGl82mnMmTOHgCxTRlEISxK+jE2FrSj0PussooEApihSXJaJShJRQcQriLTxeAmKIpVkhbZeHyFJIiz9vwd3J5+PsCSxNBSmuW1jqSqXOC5tTQtXUWgbDOHoOuXz8rA1jQscl1GOS8nsbHJjMQI+H9XLlePll18mYZrM8wexRBFNEIiLEoogcI5hco5hUiVTQI/KCkMGDMAriJiiSEKS8coyDatXJycc5qrLLmPlypXkWhaPhSL00A3KK+liuikI1FA1xpgWQdNk3759rF27lrxEAkWSGDZgAKlUiiLhCCvCEZ4LR8nx+dA1jaxQmBdeeIFXXnmFNo0a0alVK2x/kGDpugSLlqffgEEF18qUCy7AEEUsQaC6quJIMi3q1+fTTz8t2CaVSvH999/z888/M3roUBKOg0+SCEZiBWF4H3zwAV3atOH0Fi0KAm3WrVvHlClTuOuuu0ilUnQ/Kx+vP4YgCCiqdtjDlZMhr2Rpshr2ILtpPyTVgx4rRiiaoHe3bhSzbYrbNv179TqpMadfdjmy6qFkt4sofdZlGJbNnj17eP7559HtAEU7nEul4Xdg+4OH7FerXkMUwyVetysef4Ksxn2oNWU58aotuPrqq4973DvvnIeieTE1H919Oqaq/qOVZn+En3/+udBrsJA/jcICdeH6u5A/j5BtsywU4a1oHPdXa99/Ovv37z+mhcIvD1a3b9/OnDlzDglz/6PcdtttVLAdbvUHKW873HmEPB6Au+bPR1dVVEHAJ0lcPHnySR9r//79XHPVVQwfNIjnn3+ekjk55GgeJEHAJ4q0ad2ahtWq0aNTJ7766ivmzJyJoWlooogtilRV01Z7F2QySH7Nvn37GDl4MDXKlGHKBRcUWAqGHYc5/gDzA0H8hsGePXsom5vLta6fLfEkNTWNpg0b8vXXXzNyyJAjekKXyslhjj/AS5EYQV0/LHujUokSTM3cX7g+nQ0bNmD9yvJOleXjWqulUikmT5hAqawsurRte0KhnalUioULFzJu7FhWrVpFKpXizA4dKG7bhHw+KhYrRsOaNSllWlzpuGSbJk888cTxf1AZXnvtNXItmw9jCeYFglTIyzvm9tu3b6dNo0bkhMOMHzOGVCrFwYMHmTVzJgPz85kwYQL+UIRwLMGyZcuA9DUhShI1Jy2j5uQn0HwmEyZMKLCY+S0ff/wxlhMgp/lAIiWrM3josBM+n9/Dzp07MTSNdbEET4UiiIKAIAgMHz78TxM77Nq1i3AsQaJOJyIlq9P9rPw/5TiFFPK/RGGB+hSxZcsWOjRvTu3y5VmyZMlffvz/Jb7++mtmz57N4MGDOTPTQjfTH6D9H/AKG9y3Ly08XpppnrQq1bSISRIlsrMP2/aLL75gzpw5SKLIx/Eks9wAXlEk7vNRo3x5gpaFpWmc0bYt+/fvx6MovBGN80EsgeP10rZpU4rZNjHD4PR27TBFidM8HvyiRESS6NOtW8Gx3njjDW6++WZuu+02yrkuW+JJFgfDBGWZLNflLNMkIcm8F0swyx+gQl4x4mba43hjPIksiuTG4/hEkUsdl0q6jq4oqIJAO82LKAh8Ek+yNZ7EJ4qUzs5m2IABR2y3uu7qqykWjeHJWHwEJAlfxte5daYw7RUEXorEuCcQwhBFZvoDVFM1NsWTjDVtTFFEEARsUUQRRQxZZoRhMdgwmWDZ3O0PUl7V0ASB16JxNseTRHSdjz76iInnn49fljFEkaKyzHmmTRlZJltRqOPxYIsitTQPYUki2zR55JFH+PHHH6lerhy6qqIJAiFJ4qVIjGm2Q0iSyDdMVEEgqGkUlWRGmxanaR62JbK4JxAiLErUUFRsWcZSFDr7dFZFopRXVGxRJG5ZDOrdm2effZazzjiDcWPGsGrVKhYsWMAXX3zBCy+8gK2mF76b4kkkQWDPnj188cUXHDx4kOuuvpqAJ33NzQsE+TCWIEuW8QgCjb3pEMeFwRBFZYW+ffpw1113oWcCC1dHYqiiyM6dO7nnnntYsWIFmzZtomHt2riKQnFFIekz0TQf7b1ezjMtTEXhoYceolnduoS9Xi5xXNbHEpR0HJ555hnaNGmCR/Wgm35kxcOjwTC3+oMUTyYJ2TZXO37G2A6W5qHWlOVUPOdWYsmcQ64Tw+PhVjdAQJK4LxhipGXTuFatw66nW2+9lZqOw5PhCPU8HrxeH4OHDiOVSpGXSHCB4zLNcUkEg3z88cfY/iCJul0JZpdk8kVT2bVrFz3z+5CVk4ssy5QoUYL33nvvqJ/x/fv389RTTxUUwX/hwIEDiJJEjYmPUHPy46g+g/Hjx/PFF1/gURQ+jCXYGEvgVZSTLvQ+99xz5JUsQ5FiJXniiSfYt28feSVKEShdDzNZCo8dYPjI0QXbp1Ip7rvvPgzbjxnOQvMZxKu1ourYB4iUrMott9xyzONt374dn2FRftBMSpw5mbDHh0+SDrFIOVU8++yz9O7bn2uuve4wL+m/gocffhjdsFA1D5MmX/SXH7+Q/z6FBep/x/q7kH8nIdvmsX9ZgfrySy7Boyi4ul5QtPuFn3/+mTM7dECVZXKiUW699VYq5OVRuUQJVq1axZxZs+jevj23zJ79u4tlqVSKqy+/nDanncY1V155zHF++uknduzYcUoe4j755JPUDARo6PFwvmnxVChC3DQPs1DYvXs3V199NQ196Q7DOf4AzWrXOeq4u3fvZuzIkXRs3pwHH3wQVZZZF0vwYSyBqWl8++231KtalZGmxbvROEVlhQEDBhxzrlmhEMtCETbGkySPkNcTsixeisT4NJ4k27J47733qF+tGi1dP01cl+b1j+6n/AtLly6ljOOwIhzhTMdl2IAj5xYdbd/8rl2ZPHEiQZ+PN6NxApLEZY5LH9OkpKKwLZHFMNth2rRpJzxuKpViUJ8+GJqG3zD+kGhj7dq1xAMBQrpO3SpVDrGfrFS1BvFqrUnW6USRvOLHXf+9/PLLnN1vANMvu/xPVxfv3r0b2+vlkVCYB4IhPIJAKUVBEARcf4AzzujCZZdddkIPFE6Ul19+mUjRMtSaspxKI+YRjMRO2diFFPK/SmGB+hTRqFYtRjou8wNBgobBJ5988pfP4X+B77//nrxEgtP9AYpbFo7HQ8dAgLDXy6RJkwq2e/XVV2lSuzYt69fn3Xff5fPPP6dr27bUr1KFG2+8kWXLlhUUYVOpFGVzc6msahSTZYKSxDmmxUjTolrp0kedS8xxGGlaTLJsvIJAXiYR+9a5c3njjTeoWKIEXlWlVqVKhHWdhGnS84wziBkGm+JJXo7EsLxeHE2jv2HQQNWop3no2KJlwTEef/xxiieTFIlGCXm9PB2OcqFlU1vTsCWJ8ZZNriyzMZ7krkCQ8kWLUjwri762QwfHoVndujz44IM0C6VtSR4KhrFEkbii8Fw4iiWKNPF4aeP1YogiNzh+Tjct8rt0BdJhbatXr+ahhx6imGVzTyCIIQgMM0y2xpN09Pro6tMpp6h4xbSy9/1YgmfCUTyiSCOvj6qqxqfxJBfZDuUUhSaah7KKysfxJFNtB0sUqZMp0lqZ4rNfFHFFiSxFRRdFyuTm0r55c6qbFhU9HgxRpJ9h4Igii4Jpj7zarkvjRo3o1LJlgTXLgQMHyO/Zkzyfj24+HzmyzKfxJPcF0/YskYw/dNC26W9aPBGKEJAk5vgDtPB4sUURryBQzqfjEwRCoogjipiCQLnixY+polm8eDFBXScoydTRPFTxGViatyAs75133iFumDwdjpKUZG7xB1gfSxCUJIp7vTStX5/KpUpRJjub0UPP4eeff+arr77CnynG66JIs4YNKVesGM0CAYrbNkHDYIhpUVZRkBSVMr2vpGj70SS8OlvjSaKGQe1KlTjPdigiy8z0B9gcT1LJdXn88ccZNHgokWrtyOtwLkaiBK29Xh4JhvEKAn5JZks8yXuxOIogkN3kbKLlG9CpS7dDznv0sGEERImiGWuS5eEIebHDF2xTpkxhUKZVdbzlkKjYBJ9h88knn6BIEh/Hk3wST2J5PMydO5esig3Tthe9r6RStUML3i+88AKxWAxd14/YFnngwAGa1atHRddPtmkx7TdqorYdOhEpXplYmVpUr12XgwcPcuDAAUK2zUx/gNn+ACHbPmKHwcmwbt06/NFsak5+gqpjH8Dj0wtuMJcvX47luKiaxrARo1i8eDEbN26kboNG+AyLzl27HXdx/8knn2A4Aapf8DCVht+BLKtYqsYLL7zwh+b9W9555x1MJ0CRlkMI51Vg4oUnr876o4QiMcqefS1Vz7sf3XYPUekXUsipoLBA/e9Yfxfy72TxokVYXi9eReHSqVP/7ukck1QqxYSxY7EliaYeL3f6gySCh3Y/PfTQQ1RxXT6OJ5liO9hSOiz7Fn8Ax+ejpGUxw/VTwrK59957//Jz2LdvHxPOO4+W9etz+223ndS+H3zwASHDIE9WeCAYYks8SWW/v8CG4xd27NhBIhQiLsssC0U4y7I5u3t31q9fzxVXXMHDDz98SFF9SN++tHZcrnNcQrpOnx49yLYsiv6qa61u5crkyjI+USQhSQQ9Hi677DKeeOKJQwqnv3D3XXfheL2EdZ2zu3c/rIg/fdo0kqZJOdelZcOGHDx4kB9//JGZM2cye/bsY6qn75o/nxZ169KkYUM6+tP+zde5fjo0bUoqlWL//v0sXryYxYsXH+bvvWvXLvJ79iSgqlzhuFSz00GEVzguOZn18uvROF5RZKjtEDIMXn755aPOZd26ddx555188MEHh3x/586df7gQ3L1jRyY7aVFUU9fPbb+6Xr755hvOHzeeUWPOPaGHSvv27eOK6dMZ1KcPq1ev/kPzOhEWLVpEIhDAlGWucFw6mQ6+cC6CICB7TUJl6lKhcjV++OEH3nnnnSNeQyfDjh078IciZJ3Wi2i5+pzeueshr+/du5e33377lBbFCynkv05hgfoUUTQa5alwOnCtnOueUJBWISfPypUrqZ6xcng6HCU7FCLsutSxbYpaFldOn86+ffsIOw7Xun6mZ7x0WzRowGDH4c5AEF0Uqeq4lMjOZseOHXz55Ze4Xi+fxpN8GEvgE0Usj4eAYfDMM88cdS5FIhFaeLw00Dxkywpb40keDIYpl5tLlzZtOM9xWRtLUMF1mTNnDmvXruXrr7/G8flYHAxzjeunZHY2ixYtIm6ahDSNoGlx0ZQpnNW5MzffeCOurnN/MMQ9gRCmpmHKMjmyzNmmRTwYxPXpBFUVryTh6jrLly/ns88+44Jx47h42jS+//57Pv/8cyKOQ75pUVxRONe0qK95KKooGIKAlikMl8gEnjwcCpMXibB48WICuk5Z1yUnHqeH6/JeLEFxWaax5uGjeJLGHg9TbYdRGcV5A01DF0W8osgZHTvStHFjrEy4YViSqKAodPH6qKCqbIonme64lFYUDFWlYrFiBeEcdTWNcoqCX5S4zHYYYjtIgsDGeJIhhsnYTGGzlqrR2OPlSsclqOu8//77h/yMup/ekWKaRklFoaPHS+gX5bckEZRlptgOW+NJ6lk2rs9HM9ePJgiEJYmQKBEWBMopKmFRoqqqMtV20EWRhqpK0DSPubBpVL06t/uDbIwlKKZ5cIpVRxVFvLLMmGHDeO655yjvuqyLxunk9eLLWHycpnkIatohYZW/ZvPmzZx//vncfPPNrFq1ioqZRfLT4SiWKLEtkcXyYBjZa1LjwkepPOouZFmlveNSuVQpiicSXGDZxCUZO/NQIejz8dNPP9F/wAB8kkw9jxefJKM5ETRZpa+uF7RslnccurRvT9/+Axk95lxuueWWQwqg+/fvx6eqFJFlKqsqriRxzRVXHHYeGzduJOq6VNQ0fKqHYp3G4TNMdu7cSdd27ajuutT1+2nZsCEbNmzAdPzktBhEuERVRow+3M7n888/p379+giCwJgxYw65OVi7di3ZlsWnmQdDAdM8ZN/9+/dz9913c8cddxwS2PTSSy9Rq3x5apYrd0oS17///nv8oQg5zQeQqNmeWnUbFLwWiScpnX8FVcYsQLec31VwTaVS9OrTF9MNIWteNK+PcRMOb6/9o9x+++1kVWtOrSnLKdl9GnUb/rGk+99DMByjbN/rqDr2AQzb/7sfCu/fv5/Lr7iSXn360rJNW8pXrs41115/aidbyL+SwgL1v2P9Xci/l/379x/XTuGfwFNPPUVR0+TxUIReuk4rj5eI4xyyzeLFi6lkGGyOJ7nUdjBFkQ9jCdbFEsiiyHjzlwfy/+8d/eWXX7Jw4cLjZkWkUikefPBBrrvuOrZs2fK7zmHS+PE0clxu9QfJsayTVtguWrSI0rm5mIpCcdumYY0a7Nu3j4MHD/LZZ5+xfv167rrrLipbFqHM2tKWJO6//35ClkV/x6W4bXPj9dcXjFmnQgWucFyikoQqCNSvVo01a9bw6quvFhSWO7Vsybm2wxvROKUUhcaaB1dRqBkIUKF4iSOuw7dv386mTZuOqDDfs2cPl112GVOnTi0I/vvoo49oWb8+1UqXPqpn8erVq0mYJrf6gzSxbIK6Ts1AEFNRUCSJIrEYdatWpbzHQ3mPl+YNGhyyf+vTTqOi10ePTFDiTH+AepUr41fTHZktPF5KKwrFs7O59NJLeeWVV476s3jxxRcJGgadgiGCpskbb7xx3J/fLxSo1lu0KBDM/JY+Z57JCMdlYzxJbdfl7rvvPuHxf8uoIUNo6DhMth2ChvmHAy1PlGEDBlDLcQj7LEqcOQUhk42j2WEUzUMiGKSkm64R/FFR4fvvv885w0YwddrFh9xDfPvtt+muyUQuTiB0Uj+nP8r0y6/A4/URjiZOyf1LIYX8lRQWqE8RV06fTrZlUTsQoHq5cgV/9Ao5tWzdupWgaXKN66e749KgenVqB9MF60dDEcoVKcL27dsxtbStxMZY2mO3WDzOk+EIW+NJyioqi4NhmgaC3Hfffezbt4+oP13MnuC4FM/K4uuvvz5uW9yZ7dvT2XEZbVpYosSjoQhjHZdmdevS5rTTuNpJe6bV8/u5/fbbadukKTHXpUWjRpTMyqJ6mTK8+eabQHqRvm7dOhYsWECuZXG146ekZeGVZdbHEqyNJfAoCuvXr+fs7t05u3t3Pv74Y77++mvefvttPvvss8MW+Z9//nmBSvzjjz+mVrVqNPB46ez1kSvLNNc8xHSdmTNnYmZUyR28PrJlGUdRyPL7udUfZGs8SZbHg0cQcESRuppGSJJRBAFblmlvO+iSxCQrHejYStfp2qULqVSKC8aPZ6BhcpZuEMwsWAOCgCmKaWsNSSJXlhEFgV5dutDfcdP+x7LCPYEQdwSCnObxMMZxCRsGQw2Tzl4fcUnmetdPUUmmlqrhyDKLFy8uOPfPPvuMZnXromVsWDbGk+iCQDVFpbaqkRMOU7daNQZZNutjCWq6Lv369WPkyJHcdNNNuIZByOfD7/PRzuujrKJwXyYcs7En7cFnCALX/2qh/Vt6dz2TfMdlaShMUJIxMsqT9bEEccPg7bffJi+WTjvXBIGEovBONM4Y06J80aIn/HkIGAaz/AH6Oy6uotBD12nh8WCpXvRADCsQpkPHTtxwww3s3LmTmTfdhKGqDDJMNsYSnG/ZhFWVl19+mTEjRxZ4sE+wbGLlG2NrXpaFIkREEa+sMGrUKA4ePMjXX39NVjhMu2CQbMtizqxZBfN68MEHiTgOrmFw5RGK07/w9ddfk5+fj6RoyIqHrGiU7777jmeffZaePXty8cUXF/wuffHFFzm73wAuv+LKoybP79+/n5EjRyIIAg0bNuTLL78E4KuvvsLVde4KBJniuFQuWfKE3t8/g3fffZduPXoxaOg5vP766zzyyCN8+eWXBEJRyvW/gWrjFmM4gYJgyWOxdetW+vYfSJ++/dm8eTOQvpHdsGHD776JPRE+/PBDLDdAst6ZBJLFuPKqa/60Yx2NJUuW4DMsVI+X8Rdc+LvHGTZiFOGS1chpPhBZ81Gs4/m40WyefPLJUzjbQv6NFBao/x3r70IK+bOZP38+rTLimFn+AI4sc/9995FKpXj11Vd57bXX2LdvH7nhMD5RJCpJFFMUEl4vWaZJ144diRgGAzJr2eeee46tW7cSDwRoEQoRNgweffTRox7/0qlTKWM79HT9xAMBvvrqq5M+h47Nm3NjRgTS0x/gxhtv/F3vxaeffsqaNWvYv38/r7/+OoGMMMWSJJKhtK1CXJJYE41xie1QpkgRzsisn+cFgjSrXbtgrOuvuYagojDdTivPKzrOYe/Dpk2bKFOkCJogUlKWCUgyCzPj1Q4EDrNaORZbt26lZE4ONUyTKq7LWWecAUDtihUZ77jcHQjh1/UjKoNvv/12OmWugdv8QRrXrMmFF15IJdthUzzJGMtGEQQ2ZSz9FEE4xC4xLU4KEZAk+hsmEUmmbvXqNGvQgHqaRjefjimK1K1y/CDBYQMHMjFzzzXKshl//vkn/B6kVesOM1w/YcM4ojXep59+SoXixZEliZannUZusZL4dJPzx5+84KFGmTI8mOl0bREKHXKv9mfy888/M3fuXDp06IDPclFUL6HS9ZBUL4Ig0CITdD/Qdhg/duyf4lF98803k6jUmFpTllOk5RA6d+1+yo9xJDZu3IjhBKg86m5KdJ1EbrG/756nkEJ+D4UF6lPIK6+8wtKlSw95evZPZcWKFZw3evS/xi97+fLlTLzgAp566ilWrlxJp5YtOad/f15//XVChsEcf4CzHJeWp51GyexsJEEgpmmUtR3O7t49/QDBMKiiatiiSHOPh6DHW/BU8a233qJ906ac0bo1H3744THn8tVXX7F792527drFmGHD6N6hA2PHjKFkMotGtWqxadMmXnnlFUK2TdwwaFC9OiPPOYcujsPLkRg1HfeowSYTL7iAIabF5Y5LF5+PyqVKETdMYobB+DFjTui9SqVSDMjPx/V60wuizGJg7dq1GKLIKNNigmUTkiQcr5ft27ezcuVKAl4vnX3p8MRb/AFa+XSqaBpPhaN4BZFxpkUVVWNbIoslwTCOJNGpXTsUSUJXVUIeD808XgxZ5rnnngP+XyVbIxjE8nqpoqi8Gokx1/VjZcL7QrJM2yZNGDpgADmui98wcFWVGY5LPa8XU5bJjcXp3KEDZRWVgJAOYHFkGUtVcRSFAf36HfIedGzRgsG2Q0CSuM71c6XtImYU2FvjSWxJ4tVXX6VGufJ4FIWSWVlUdhwa+v3Ur1aNJUuWYHu9OLLMZY7LmT6dPFlhsGGiiyKnaRojTQufKLJ+/fojKoC++eYbzmjdmgpFizJx/HiygkEWBEK8F0vgKgrXXHMNEV1nXSzB4mAYXRRRBIGSioImy+zdu5dt27bRsHp1Yq7LxKMsoJYvX07zunXpdUYXnnjiCSyfj2xdJ2Ca3HXXXQWLz507dxYUe5csWYIuSZzu9RGQJGyPh48++ohbb72VKrbN4mCYyl4dK1kaVfPiFdLKb9MNFhTuHnjgAVpkbhLuDYSoW7FiwZxeeuklRg4dyuxZs45pg/LNN99gyQoTTYtnQhHqah4GDhxIzDAZlLmRW7Vq1Qld97/mnnvuwefzkUgkCloKH3nkEaqVLk2T2rULQnW2bNnCww8//KcWc4/GSy+9hOUESJSthT8UYcaMGXh1E49PZ+SY4we+plIp8kqUIqv+mWQ37EFWkaLHfK9PNW+//TaTJ0/m/vvvP6GF/TfffHPKwxr37t37h8csX7k6ZfpcTa0py3GK16B4lwtJVm3GnDlzTtEsC/m3Ulig/vesvwsp5M/k22+/pXhWFjUDQYK6XnDvNDA/n6K2TRHLYuTgwTzwwAMEvV4a6jquz8e9997Lm2++SSqVYvXq1Vx11VUFtg0333wzZ/rTBeMZrp+OzZsf9fhVS5bk4VC6yNckFGLp0qUnfQ4LFy4kbpp0DQQJWfbvVrLu3LmTaVOnMmniRErn5JCvG6yKRCkqy8QVhZiqUkZR+CSe5O5AiLI5RYgYBuebFtmaRpUyZahaujR+w+C84cOpWa4clznpAnUZXadlkyaHKT5XrVqF3+PlLNPClmQG2TZLgmFihsE777xzQvP+8ccfSYbTNoefZgRMsiRx4MABEoEAK8NRtsSTFHecIypdt23bRszvp1MgSMI0mT9vHvfeey91XD+fxJOMNS28osg022Ga7eAVxUOETl3btaOx7dDS68UVRWa6ARRJYtmyZfhVjZqqRiXdYNzo0cc9l5tuvJHqjsPdgRAVbId58+ad0HsAULt8eR7IrN1bBIO0adYMw+OhUsmShwgjUqkU8+bNIysrh3j9M6kyZgFuJHlM25EjMXnCBCo7DoNth5Bls3Xr1pPa/1Rw+eWXU9006W85nObT0TK+1MMNk2KqiiKKJIJB1qxZw7fffkuDRk0xbZduPXsdVRBzItx9992E88pTZcwCEjXbMXDwkFN4Vkfnvffeww7GqH7Bw5Ttdz3RxOF5WoUU8k+msED9P8izzz5L1DDS/sWmxYIFC/7U482ZNYuaZcuR36XrSXkwpVIpVq5cyfTp00mYZjq40DAOU7Y9+uijtKhXj/5nnUWbRo240HH5IJagrGkydepUDh48yK5du3ANg6qqSlKSme64xL1eHnnkkROez8GDB8nv2hXb48FvGKxYsaLgtdWrV9O0Th1aNWhQUBD84Ycf+Pjjjzl48CBnd+/OFNtlWyKLbq7LNdccWXH4zDPPYEgSLb1eSisqrZs0Ye3ataxcuZKpU6dy/fXXH1fZ/e6775JlWmyMJXgwGKZoLMbDDz9M3cqVkQSBzZmkaq8gEA+FGDl4MJWKF6dNs2YUicVolGk/uycQwu/xYGWCCbtkitd3BIL01A3KKQqOorA2lmCQYWKJIlVUFVMUcT2egmLoN998w8qVK7n77rtxZJkKmW1sj4eLLrqIrl270rZZM1o6LrP8AYIeD506dqRj8+ZMHDeObdu2ceDAAS4cP56yHi/dfOn5DTEMIpLEEN0k4PEcEiBXrXRpRhgWwwyTsKxQLrcohihytm4w1rSxVJW9e/dy04wZ+FQVRRC4JuO3FtUNyuTmcpntkK/raJmisUcQ8GbSyddEY2yJJ/GLIqaq4jeMw7z4Pv/8c7777ruCf69YsQKfnFaeN/N4cHWdsE/n3Wic+4Ih4pKMIQgsCATxyjL79u2ja7t2nOO4vBCJUdy2DzsGpP2V33zzzYIWte3bt/P8888XKGxSqRQDe/cuCE558skn2bJlC8uWLaN4Tg454UiBH+HBgwe5cNw4yhYpgqt5EAWByiVLEQlHME2LsePGFRQj33zzTaKGwa3+IJ0cl/5nnQWkH4QEDYMJlk1lx6FX9+6UzsmhaqnShwUUrly5Ep8kk/QaWIaDrGjk5uRwkZ1Whpxr2UwYN65g+23btnHTTTfx6KOPHrco+vbbb5OXl4eqqsycOfOw7d9++21ClkWzUJiQZR33Jmft2rXMmjWL11577ZjbnSg9e/WhSMsh1JqynETt05k+fTo//vgj33777Qntv3v3bhRVzaSpP47Hpx/VFubvZtiIUXh0A59h8sADC//u6RzChZOmEMwpTaJOFyTVQ7RkNULR+L8isKuQP5fCAnXh+ruQQn7h+++/56mnnioo4n333XcYmsbaaJyXIzE0Webqq65CF0USsoyjqscsxj3xxBPkWTYPBEO0dV3OGzHiqNv2P+ss2jhu2s7OMI4rpDkaL7/8MnPnzmXTpk2/a3+A+lWr0dlx6GU72IrCNY5b0F0YUhSKxmLEM/Zupqry6KOP8tBDD2EpCqNMi3zDIFuWWRONUUzXadSwIRHHQZMkEqrKJCudp/Jrb+XzRo/m/Iy130jDolR2NpWKFePW4wRH/5o33niD0q5LRJKYbjuMtWxKFykCpMMvs0yLqn4/DapXP2reyNatW7n99tsLbDz37dtH60aNMFSVRDBI9fLliasqUVWlVZNDrc/27NnD6NGj8WRsEutoGn7TZM+ePdx5xx20rFeP80aMOKFQywMHDnDRxIk0rlGDyy6++KTUv9ddfTXFbJtu/gB+06SUbfNONM75jkunlv+fgTRt8mQq2g6DDROf6qHSiDsJ5ZQ64n3IsTh48CDz58/noosuOsyG8a9i165dlM7NpW4gSMQwmDVzJslYDEEQ8Igib0Tj3OD6qVmuHMNHjiZerRVVzr2XcPHKh/hvnywHDhwg/+x+WI6fug0bs3379lN4VkcnlUpxVu+z0S0Xn2Fx332HZ/MUUsg/mcIC9f8gkydPZlTmD/10x2VAJojiz2D16tVkWRYPBEN0c1369ex5wvv279WLko5DWNOYlClYjbdsxh5BSfzzzz+TSqVo1aABVzt+Po0nqeX3F6iH33vvPYo5Dn10g6mZsc6zbCaMH39S51LMttkYTzI/EKRS8eLs2bOH1o0b4xEErnX9XOK4FInGDlssvPnmm4Qsi9KOQ24sVmA98Fvefvtt8jIWC69F47i6zqxZswg5DmdZNk0ch67t2hVsP3vmTBpUqcLQfv348ccf+eijj2hcqxauLDPLDXCrP0heLEbcNLnCcQlJEtVVjTqaRlCU8AoCtXSdR0MRKnt9TJo0iUQwSMdAkCzDxNA07g+GuDcQQhUEpEzrXjuvj3qahi8TilhWUbknkH4if1rGAuPXBb+DBw9y5ZVXYisqY02LrqZJ4zp1CNs2fR2XsKIwP9M619TjIc/rpUenzgX7v/fee0yaNInsRILqalqF7RdF2mR8pUsrKkmfj/wePYi4LrokUUJRaOLx4moaa9aswdY0mno8lFZUGtasya5duzA9Hl6JxHg6oxKfbjuEHYfyxYtjZwraAUmif79+zJkzh4jHgyGI1NI0Wnu8xKR0QOW8QJCi0SivvfYae/bsYVCfPgUK9vvvuw9IL1Rcj4eSikJvn05x26Z39+7IGeuU2/wBVEHAEQSydZ1nnnmGJrVqMcsfYGs8ScNAgAceeOCQ6+XAgQM0ad4Kfywb3XJIhsOIgkDIMGhavz7r169nzZo15Fo2G6JxztJ1TFkm5PNRNB7ngw8+OKQF8RfGjh7NWY7LJ/EkTbxeqnm8dHNcav1KJQ1w33330bRWbYb07cv3338PpNsgu2TUGfMDQWxJRlc0OukmRaLRQ/bfvn07qpb2hKs5aRllz74GfzhGGdvmWtdPUcsqUCp9/fXXhKJxktVb4o/nculllx/5g/orduzYQZs2bRAEgd69ex+idD931CjGZH4PjrFszsuoVn788UeatWyDx6fTqGkLvv/+e9544w1MJ0B2zTZY/uAftn/YtGkTbdq2xZ9bnnL9byBYpDT33HPPUbf/8ccfGTx0GPUbNeOee/7/gWK9ho2Jlq1DrHx9qtWs86e0KP5RNm7ciOkGqTZuCeX6zSAUjf/dUzqEX26epkyZwtKlS1m8ePHvap8u5L9HYYG6cP1dyN/Dd999xxtvvPGP7kjdt28fts+HkwmtdlSVuGVxfyZEsJSi0Ldv32OOcf0111C7fHkG9+lzzHPdvXs34889l27t2/PUU09xw/XX07d792PagpwMq1evZsmSJQXruKOxf/9+pIwCeWs8iaNpeEWRIrKMLop0aNGCnTt3smjRIhYsWFDwwP2C8eOxRZGt8SQfx5NIgsCnsQRVNY0OXh8Bw6ByiRLc6Q8wwrTIywQhXjh+PGd368bUqVMpZdnc7AYoa9vccccdR5zf1q1bOaN1axpWq8bjjz9+yGs7d+4k6rr0NkyKKCq5oTAbN24seH3NmjUsX76cvXv38u233x5xbXwkUqkUO3fu5MCBA+zbt49Fixbx4IMPcuDAgUO2e//99wkaBv0NE58ocr5l08iyGZiff0LHOZU8/vjj3HzzzcyePZs6/rQd5QzXT7O6dQu2qVOhQoGVSgOPB69h06RZyz8cFv538f3337Ns2bICEVkqlWLgwIEIgkBlVeVG10/lEiXomd+HnGb9qTVlOfGqLY4qKPs3sHXr1sJwxkL+lRQWqP8Heeqpp4gbBpNshzzL4q758/+0Yy1YsIBWGY/oOwNBTjvBn81PP/2ER1H4MJbgBtdPRJK42HbJMU0eeuihgu1+USfLkkRuLM59991H2HEI+nw0r1+/IMl47969lClalFpGuuA40rSIGgbPPvvsCZ/L66+/To5lsTaW4CY3QI2yZZk9ezZ1bRtbFNn8q5ax/fv3M+vmmymeSNCgWjU2bNhA68aNsTUN1+ejdZMmTL/00sP+0O/YsYOQZXOJ49LZsrBkmVKKQk1NI0eWeSoUxtV1AJ577jlyLIu7A2n1xehzzqFKqVJMcFxu8QfwiCJR12XEiBH0yQTpXe+kQwA1QaCSotLc42VspiA+wrSIBwIsXryYG264geXLl+OVZdZlPLAVUUTJ+EibokhlVcUSRbwZy41uPp0HgiHCkoQmCHzzzTfs3r2bH3/8kYsmTqRkJgHcEEVaNmrETTfdRAPHYZxl08rjJSwrNPV40AUBVxAxJYlvv/2WDz74gKBpMsh2KG5ZlCteHEUQyJJlVoQj5MgyW+JJXozE0EWRW/0BvILA+ZbNxliCPMti4sSJlFHVAq/yEokEZXNz0QSB16NxVkWiaJJEuyZNeP311+nTpw89M0ryGa6frm3bcumll9LfsnknEqOiqhINBskyDNbFEtzsBojIMoYkIYsirqywLhpnrj+Aa5o888wzzJ07l0qZgMyQJGGJIgHDoFXTpriiSFyS6ezTyZVlopLE2fn5rFixgoBhUNJxqFqmzCFhMKlUimFDhuB10sXdcv1vwPTo1NE0mmgezjMtgqbJ888/T7ZlMdgwiUoSXXw6W+NJBls2uiyjqyqTx4/nySefJL9rV6ZffDHDBw9miOOyNZ6kg9fHeMtmSzyJLElHTAffv38/999/P/fccw9vvfUWQcPgPMumuKoSLlOfiufcik/z4VGUw/a9//77UX0mFYfdRm6b4VSsUp3ZM2fSo2NHLrxgIuWKFiUvHuf8888nUbY2taYsp+zZ11CmwvF9+n75HTF16lREUaRKlSoFyqEbbriB2o7D0lCY2o5T4Md4+eWXEy1fn2rjFhOr2IgpF01lypQpJOt3S/vItRpK/tn9jnXIY/Lxxx/jBEJkVWuJx3SJJbM5f/wFx7TnGDBoCLEKDSnRdRJWIFKgRN+9ezczZ87kpptuOuX2GaeKzZs3Y9h+qpx7L6V7XUY8K+fvnlIhhZwQ//UCtSAIrQRB+EAQhI8EQZhwhNc9giA8kHn9VUEQco83ZuH6u5A/ytq1a4m6LmVcP0XjcT7//PPfNc6LL77IpZdeWmA5d7Ls37+fpUuXsmLFiqM+/K1aqhQzXD+b4knKWhaJQIBxls3T4SgBSWLcrzrAThVXXXYZVRyHyxyXmGEWqHl/zcsvv8yQQYOoV6kSQ/r2PWqg94EDB7h46lSyLYsGgSDlixc/7kOBulWq0MVx6OM4lMktypYtW7juuut4/PHHefTRR2ndsCFD+vYt6CA8ePAgefE4ObLM6T4f9bV05k1UUSilKGyMJWgXCtO2RUuCkkQHr4/RpoUhy7SwHabaDkHTZPoll9C5VStuuO66o/48GtWsyTDHZa4/SMAwDuuEWrduHUP69mPiuHFHLcZPvfBCLI8Hy+NhbsbqK5VKMW70aKKuy2k1ahyzw+rAgQPMnDmTcWPHHhJ+OWvWLNrrBgsCIWpqabvEFeEIpbP/PvuFPXv20LBGDRKmScA0Dwk8P2/ECOo7LlNsh6Ce7hr+K23k/goOHjxIg9q1EQQBURSZPXs27777Lv5QhGCiKDlFi/H111//3dMspJD/OQoL1KeABx98kJjfT8zv/9d4Oi9btoyRQ4dy//1/btvHN998Q24sTpNgiKhhcO+9957QfgcPHiTq9zPD9XOzG8Dy+RjYu/dhCtJly5ZR3nHZGEsw1XFp2bAh7777Lh9//PFhC5hvvvmGG264gbFjx3LhhReycuXKox7/5Zdf5r777juk3T6VSjF25EhUWSYeCPDKK69www030MZxaOHxUlZRyVM1coJBzj7rLCKGweOhCOMdl6qlSlPZddmc8SnTRRFHkiiZnX3YYvC1116jW/v2VChWHFkQeD+WyNhJSAQlidanNQJg7ty5dA6k/etm+wO0Oe00HJ+vwH4i7vPxyCOP8O677xI0DPpZNraiEPZ4sEWRqbbNk+FIOpRD8+CKIpogUCMQxDEMpk6dSsQ0CUkSYUkiqGp4FIWwJLEqEuUS2yFuWXSzHa6yXYyM/YVPUbC9XlRJwpRkPLKMRxCQBYHsTChilVKluPfee9FFkcFG+hg1q1bFI4qEJAlFEMiRZSZOnMgtt9zCmYEg78cSjDNtqpUuTa6mEZIkRhkmhihyZyDIONtBEwSKKwrtvD4aeDyUV1Q8gkjJ7GxikkQjj4eIJJOXSDDMtDjXtFAFAVUQuPbqq9m9ezc///wzts+HX5SY4fopr6iUzcvjySefxCuKNPN4sUWRoK7TolEjZFHEEkUaeDyMs2w2xZOUV1XOt2z8okQnXSfHsmjXujVDLZtrXD8NPB62xpNMsmyqlCpFIhiiqWmRK8l4BYFeukHA62XTpk18+eWXvP7664cVhh999FFydB2v5qPC4FkUaTUUR0mr2t3Mly6KTL3oIsaccw62KHG2btDK62VTPMkZPp0zfTrvxeKYmoYpSZyl6xT3eBjcty95iQR+rxdTkjhdN+hsO9SpXPmIn5cu7dpR0/VTz++nWb16vPLKK4wdMwbLcSnX/0ZqTHwE1XAYMmDAEfe/8qqrcQIhipcqy7vvvlvw/WQoxBx/gAeDYUyPB9Pxk9fhXGIVT6NN+9O57rrrDrs5u/ySS/AbaZuWX6v4H3vsMVzXxe/3s3z5cn7++WfOHT6cqiVLcu7w4QUPiyZOvJBErdOpNWU5yXpdGHPueSxevBh/PJcSXScRyi3L9TNuOOrvjuMxc+ZMsmq0ptaU5RTvPIFmrdodd5+adRtSsvu09JwqnXbURPUff/yRlStX/uFE8lPNtEsuRdU0LMc9xBqpkEL+yfyXC9SCIMiCIHwsCEKeIAiaIAjvCIJQ9jfbnCMIwpzM/3cXBOGB4437byxQL1y4kPqVK9O9Y8fC7ol/AIP69CHfMHggGKKHbXP55cfvlvotK1euTAdr2w4xwzhMTXs8UqkULRs2pJrfT2nH4Zz+/Y+4XZPatbkicw9SxnGYNWsWUcPAEEUqlS59QnYNv2XBPfdQtVQp2jVtekSLkE4tW3JzJuywjz/AjBkzDnn92quuIuzzEZZk7gmEaOe4jBw8+LBxNm/eTF4igSVJLAtF2JbIooSi0Ll9+4L7p4MHDx5WlNyxYwdTJk3ignHj+OKLLxiQn09Jx6GUZeMoCje7Abo6Lt07dgTghuuvx68o2IJAMrO+79ShA4P796eKbTPGsgmaJtOmTcMnirwVjbMtkUVclrkl49FdNxg6obVDVjDI85EoW+NJyrgur7766gm/75Du6rM9Ht7JCFcMj4dUKsXjjz9OacfhpUiMwY5Dj06djjrGecOHU8txGGnZhCyLbdu2AXDVVVdhiiJjMveAgw2T2o7DiEGDTmqOp5oDBw7w4YcfHqYY379/P1ddcQWD+vQ5zBP8v8aKFStIJBIYhsFDDz3Erl27eOedd37X57eQQgr54xQWqP8g+/fvx/b5WBoKszQUxqeofPHFF3/Z8f8NfPvttyxZsoS33377pPZ79dVXqVq6NHmxGJdccskRn5jPnj2b8rrB5niSa1w/AU0jx7IpnpV1wqqLHTt2cPPNNzN//nx+/vln5syaRdI0aR4MkpdIsHPnTp5++mkaVa9O+2bN+PDDDwvmsmvXLqqXK0fA68U1DIIeD3f6A1Q2DEpmlKoPBcPkRaOUcRw+iCWopKhcYju8FokRlWTCpsnkCRMOO78hffsSk2WGmxaX2g5hSUIRxYLra9u2bcQDAdpkiv+33norrsdDUpYpq6g4ooiraoweNYq6lSqlvbMliXsCIbr6dBxR5HSfjlcUKefzEVdVJlg2Z/h0qqgarXQDW1EYY1g8HAwR8vno0rkzPlnGK4pkB4O88MILnN29O01r1eaGG24g4jjkygrXun42xpOUzCxWPYKAVxC40Q1wZiapuk7NmgzKWCxc5fhpWKMGhigy2rTYHE9STdWQRZFhgwYR9PkISRKlVBVL06hVuTLBTFG1SoUKJP1+4rLM6Zni8dZ4ko3xJKIg0MurYwgCPkHgHMOklGlSs1w5rnL8bI0nqadquKqK5fXiVRRGDh2KVxQZb9m09nrxCQINDJNhQ4dSzLaZ6fq5OxAkKElk6TqmopCUJGprGpMtm0/jSWrqOpIo0tDjYVUkyu3+AHUrVyZs2xT3eCmvqGyMJRhmmOSGQgzs04eArmNJMl28Pu4Phgjp+jF9AocNG4aZeajglRV000EWBF6LxlkfS2CIIguDIWyPl6+++ophAwZQz3YoqSiIgoAly9wVCPJmNI5XFIl5fISiRfHHiuE6Ab7//nsirstI06Kax0MyFOKTTz5h+vTpXHLJJQUPb/bt24ciSXyc8Ta3PZ4CxcGdd85DtxwMN0TDRk1PqjUwlUrhU1WmOy7NPV4sRWHevHm0anc63XqcRUDXOdsfIPqrm893332XuGGwOhLjCtdPrfIVDhnzo48+omLFioiiSK9evXjggQcKvNJ/Ydu2bSSyi+CPZhFLZPPJJ5+QSqW48aabady8NRdfculhrZsnw8qVK3FCcUp0nUS0dM0TSkW/9dbbcEJxklWaEIzE+Pzzz9m/fz+fffZZwVx27txJqSJFqBoIEDQMnnjiid89xz+DAwcO/CMtSAop5Gj8xwvUdQRBePJX/75AEIQLfrPNk4Ig1Mn8vyIIwjeCIIjHGvffVqDesGEDYcNgXiBIX8elY4sWf/eU/uepX7MmEUmitKIQVxRmz5590mOMGzuWsZn15UW2wzlHeTh+ND799FPCus6n8STrYglUWT7i36+33nqLZCiEIkl079TppBSmL7zwAlVKlqRisWI8/fTTAHzwwQeEdJ37gyGGOS4tGzQ4bL/bbr2VopbF0IxX868f6gOUyspipGnR0etjWyKLOf4ArY4wzuCzz2aE49LM46WfYTA/ECQgSeSaJk8//TT3LliA5fVieDzcfuutRzyHvXv3osoyH8YSfBRP4hFF1sYSLA2FqZCXB8BZnTszwbTRRZGeuk55VeXsnj05ePAgc+fOZeyYMbz55pu88MIL+BWFepqHbrqOrWlUsm16Oy6JYPCE8jmmTppEUcumfiBA1TJlDlvfHY8dO3ZgeTysjsR4LBTB1XVSqRT33HMPjQNpu70b3QAt69c/6hiVihfn0UzBv2k4XBBo+dBDD1HcNOml69TXPJQqWpTZs2cfc128ePFiRgwZwsMPP3xS5/F3sH79espVqkoknsXNM2eesnE3bNhAq4YNaVC16u/uhjgRPv/8c2rUqIEoilx++eWnZL36zDPP0K1nL6ZOu/gQkdGBAwcYOmwE2UWL0/2s/EPsBwsppJB/SYH6eG2Iv/36KxfIP/30E15F4Z1onHeicTRBoHRu7h9KfS0kzYYNGwiaJsMsm9K2zfW/8YH6/PPPCds2eYqCTxTRZZkzDINtiSzybYeLpkw57jH27dtH+eLFae/6qeW49OnWjRplyvBAMMSyUARXljFUDUvTmO0PcL7jUr1s2UPGuPuuu2hapw5N6tenRyYsZJJlE9J1SlkWIV3nzttvZ0B+PnLGHmO4adHO66O/YfJ8JEox6/AAvK1bt1IiOxtTFCkqKzQ2TGpVrHjIH83PP/+cBQsW8MYbb/Dkk09SNxBgUTDMVNuhuCwzyx8gIMuMMi2Sskxjj4dtiSzuDoTIk2USoRCvv/46N998Mx3btaOx14suirwXi7MiFMGXma8uiPgyHtSWph0SXvILjz/+OA1DIepoHma4fj6KJymuKNzguGiCQDlFKWhps0SRM306AUniKsdPKa+PmMdLUpIZnyny1tI0Jlo2hqaRn59PV8NkWyKLqbZDfpcurF+/nnXr1lE6Nxe/JKfnmilEjzAtumeK8DU1Db8o0dLjxZYkzu7enZdeegnb4yEgSQRkBVdVuTcQ5L1YgoiuYykKDwRDvBGNY4gi9T0eIoZByDSp5dPJybynTTxeuhoGlzsuJRUFQ5bxSRJO5r+/qJkjssy5w4ezZMkSDFUlKcuImaJ9uTJlqGDZvBSJ0U3XccM5SKqHfr/xpdu7dy8bNmwoUNxnBUMsCIRYE01bmziahk+WuTcQ4vFQBEMUeSMcJeDxsGnTJvbt28eAvn1xFYVGXi+GouBRFHyShCvLCKJEjYmPUOPCx5BVD2+//TZR3WBrPMmHsQSKJFGjQgUaGyZtLItqZcuSSqVIpVLkJRL0MEzGWDaJYPCQ338bNmxIe3p7PBRLJvn000+P+7n8hUH9+uFKEjP9Aer4fEw8/3wAJk2axIjMzefFtlvg4ffSSy9R0nHYHE+yMBiibCYA59fs3r2b3KJ5CIKAZtjUqtvgsIXonj172LBhw5+2aLzzznmc1rQlY88ff8I3UC+++CJ33HEHn3/+OZs3byY3Hiek61QqWYodO3Ywf/58WmZ83Gf6A7SoV+9PmXshhfyv8B8vUHcRBOG2X/07XxCEm3+zzVpBELJ+9e+PBUEIHWvcf1uB+sknn6RmphNtaShM+dzcv3tKp5T9+/fz3nvv/WMDdI+E4fHwejTOJ/EkfkX5XcFqS5YsoahlpdeXts3831gZplKpYxaTf/zxRwKmyY1ugCmOS6mco1tTXXLRRTgeD36fj6kXXnhC8zt48CAh22aOP8C8QBC/YbB3716effZZKvvT4olHQ0e3f1i6dCnTpk3jjTfeOOy1Vg0b0suyCUoSDTweQl4vt99++2HbndN/AIMcl9ciMbJkmaxMdk2NTDew6fGwIhxJK4k17YjWH6lUilggwHWZblevKFLe56OoZXHl9OkAPPDAA4R8PsopaZu9leEoRX+TR/IL8+fNo2Lp0jRu2JBNmzZx1113cfnll5/wujGVSrFy5UoWL158VFuT4zHrppvQNQ1H1wu6on/44QcqlypNSccl8Bt7yL1799KnWzeyQyF6du7MOf37U89xOD+jDN+yZQuQLkr26tIFOdM9e6T7qF+zZMkSipgWk22HpGGwdOnSf7TFRqVqNSjScgjlB83CdIPHPb8j8fbbb9O5a3f6DRhU0M1StmhRJjsus/0B/IZxwt7gv4effvqJ7t27IwgC+fn5f0hBvX79ekw3QG7rYURK1WDYiFEFr91+++2E8ipQYfBsouXqMXnKRX988oUU8h/iH1+gPpE2xN9+/dUL5KkXXlhQiDrPtMi2rN+dsPxv5eeff+bDDz88pT6oc+fO5cyMf/UdgSAtf1Nweeihh2gaCrE1E1qYEwjQ2XF4P5agpeNw1VVXHfcY69ato6htszWe5J1oHF1V6dS6NT0clzxZYYbr595AiJAksSWeZE00ht8wCvY/b8wYXFmmlqbR0LRwVJVWgQA+UaSN7RDx+bhk2rRD3qfFixfjKAqWKBYE4DWw7SPan6RSKT7//HOmTZ3KJRdffFjYwfr16xl6znCmTruYjz76CEOWOc8wyZVlkpJEaVkhT1V5LhzFEgSMTMHWEUUCpsmrr75asODZvXs3pizjiiL5ukFFRWWK7bAlUywuoyiUUBTKKAqlihQ5bKG0bt06bK+XFh4P3ozPdUiS0AQRryDgiiItMkXoplq6UF7VsmlUqxZ+w+Aa22VxMIwhingy+y4NhtFEkeuvv54qjsPKcJTTLZvT27Th+++/55JLLqG7nS5UnmOYtPJ4MQWBfN2gkqKQK8lsjSd5LBQhS5YpGolw0ZQpfP3117z33ntULV2aYrEYYcfhgWCItbEEUcNg1qxZmJqGLAjYsowlilzl+KmsqmRFo7heL/1cP6aiFLTqxWWZrmecQdww+CiWwCsIvByJ8UFGzRxyHDq0bMlU22FjLEFAlMg3TPIUheYeL9sSWVzhuCRL1CRZryuXXHJJwXv79ddfU6pIEYrY6QLwBx98QMRxeDIc4f1YgpAkcbHtEJZkHFHEJ4rIgoBPFGnRqFFBAXbUOefQw2cQkiS6+nQMWaa018vSYAhN9RCp3h7XcLEVhaVLl1K9XDla+f3UcV1Ob9kSXRQpLiv4RQmvorBjx46MjU+M0l4vpqIclnh99dVXc7rjsDWe5BzHZdjAgRw8eJCvvvrquIrq2bNnc6brL1ABtWvUGEjbKuVZFje5ASo5DrMyao0DBw7QoUULEqaJ69NZtGjRYWMePHgQSZLJbtYfUZIRJemkU8n/boYNHMjwjEd4Z8flqquuYsWKFRSzbVaEI/RxXM7u3v3vnuYJsX379r8s2byQQk6GwgL1iRWoBUEYJAjC64IgvJ5zjELeP5EffviB0rm5NA4EybYsZlx77d89pVPGDz/8QPVy5Shqpwtlf2eb/po1a2hYrRr1q1Th5ZdfPua2pXJymO64zA8EcXX9d4d8zZ83j/yuXZl7yy2HPIReunQpfsPA8HiYddNNR93/hRdeoFHNmrRp1OioRfI9e/bgVVTeyoiUfKp6QoXRffv2ocky62MJPowlMDSNnTt38tNPP1G1TBlq+gPETZObbjh5O7HPP/+cLm3bUrFECWyfj5K2Tdi2C8LhfuGzzz6jQvHiafFB+fL4DYO4YdK4dm1++OEHfKrKK5EYb2TujR577DGGDxp02Pv52muvUb9qVSI+H7UNg4ameVig9sKFC7E9Hi60Hdo6Lt1PP/2kz+sXdu/efUK+wAcPHuTCCy+kYrFi1CxfHtPrJRkMHdPe8df7/la4sHfvXiaMG0ciEKBq6dIF7+d1113HaY7Di5EYzR2HSy++mOuuvZZRw4bx5ptvHjLG008/zS233HLcTutUKkW3M86gh89HBUVFEgQMScKrqMe8Zo/HAw88wKhzzmHZsmWHfP/FF1/kggkT/pBNabJIHuX6zaDmpGUEEkWP+zn/Lbt27cINhinSYhDJ2qdTs05apa5rGu9E43waTxIzDD7++GMAbr7hBkokk+RFouiaRuWSJQte+yOkUikuvvhiBEGgTp06fPnll79rnPvuu49kpdOoNWU5pfOvoHL12gWvTZs2jUTtjtSaspycZv05u9/JdXgUUsh/nX9Dgfq4bYi//fo7FBw1K1Sko2Uz1nZIBIP/U+0aP/74IzUrVCBpmoQdh9dee+2UjPvWW28RNgym2g41HIdpkycf8vrHH39MMPN6U8dlQH4+zerWxaeqtGva9ITSv7///nsijsNk2+Es3SCpKCSDIbp36oSrajwUDPNBLIEry9RwHIrbNuePGgWk1Zoxr5clwTA9dYP6mgdHFKlYsSLFvV4utR1muwHqH8G3t2fnzjTTDRxRJEdRKJGdfUhgx3fffXfcJ7fffvstjj9IrFZH7EgOxRJJBEGgpJwuJN8XDFFe1TC9XmplvJqjksRw0yJHlvGpKjG/H01RmDxhAgBTLriAmK4TVjXszLYbYwnKKyqqIPBuZpHgVxRaNGxIv169+Pbbb/nyyy/JjcWo5rp4ZZk2hsn7sQTzA0Ga1KyJT1Xp5tMpoyh4BIGiksQoy8bVdRrVqYNPFKmkqtiZ4vRjwTBtPV48gkBFXWf27NmMGjKEiGkSVFQa+P1UKF6Cyy+/nBaZMMSuPr1AJT0/EKRv5pzvDYQYbJhYokQ9w6Cn7VA2L4+6lStzrmXzYDCMq6XfJ5+qcs7AgVx4wQVMmzqVTz/9lGgoRIdMq+St/iB+ReHll1/mmmuuoU3Tpgw3Tc63bJr5dM4//3z8Xi9NPR58Qtob+4lQBF0Uae7xoMsyFVWV6bZLQpYL1CS6KFJEVvBKEm7RKvgkiWLxeIEtzhVXXMGZGXX+ubbDkL59mTplClqmCN3B6+P0jDXLtY5LZVXlk3iSC22HM9q0KbhmFixYQFjVuMh22JZIt4HWVNNhLb19PryZhyYLAiFcXeeLL75g9uzZzJs3j0WLFlFRS3tn3+YPEs5489166620y/gEXu/66dCs2SHX6fXXX09Lx+HTeJJ+TrrVtnK1mvhMm3gyh48++ohUKsUTTzzBvHnzDlF6ffzxx7i6TglNI6CqXH/99QWv3XrLLZzRujXXXnXVIQ9LUqkUGzZsOOYNTG6xEuQ060e8bldEUUTTNHr16vWvUZmNGT6c3k7a076l4zJjxoz0onrKFIonErRr2vRfEexy2eVX4tVNvLrJ9Muu+LunU0ghh/AfL1AXWnxk2LVrF4sWLWL16tV/91ROKXfffTeNMyKI61w/bRo1+lvm8UumzPWunxvdAGHHOebD6ffee4+G1apRtVSpwwppf5RUKkXAslgaCvNiJIbl8ZyQdcTR2L9/P5bXyyOhMI+FIlhe7xGDpI/E6KFDybEsito2A37VMbd7926WLVt2WHHzZJk2bRp9M2u9cbbDkL5HDnf+pYtr165dbNy4sWA9ddOMGensD01j5DnnEDYMLrQdKtgO1/5GAPTll1/ier1sjSf5JJ5EEsXDOonffPNNBuTnM2nChMOK+D/99BOzZs3ixhtvPGp4IaQ7NV1dx/J46Nez5zFtGLp16oQhisz1B+mduUebFwhS5Cjq7b1797Ju3bqjPmDYuHEjIV3n0VCYhpqHuGFw9113MWHcOIZk3udRlk33Ll2OuP+Ma6+lqGXRMRAkKxw+5oP50UOHkvD5cESRfobBpniSelo658byeH7XWvWeu++mqGVxoe0QN80CYcarr75KyDAYY1oUtSzuOILa/kS44447MRw//ngRTmvS/KQs/SAtcvJHs6k5+Qmqnnc/PsMC0u9FCduhmt9P8/r1OXjwIO+88w5x02RZKMIo06K+5mHcKbZoWrRoET6fj5ycnJO2KAXYsmULTiBEonZHAsliXDL9soLXNm3aRDASI16yCpYb4PXXXz9l8y6kkP8C/4YC9XFVHr/9+jsWyNu3b2f0sGEM7N2bDRs2/OXH/zu58847aZJpSbvMcenYsuVx99m7dy9vvPHGcZVzTz/9NAPz87n+2muP6Pv64osv0rdHD6ZNmXJIq/y6desYkJ/PucOHH3fx+fbbbxMzTdp6vbwdjdMgGOKxxx7j/vvuw/H5iOoGXdu3Z/HixTzzzDMFC6L77ruPZv60uvPOjHdbHTUd3hcRRYpKMn5RpF+vXocdc/v27ZzRujWlc3IYM3JkQTF6x44d1K1ZE1WSsL3eY/qOXXXVVXhECV2Sqax5uNJxcWSZIqrKKNNiWyKLCZZNzzPPxFBVlobCzPUHiUtpxbcpSczyB3gnGidumgVqgJtvvpkSiQRxWUYXBERBoIqqoosiF1h2gaf0RbZDF59OViAd0nJGpkg5wjDRMx7OpVWVRCCA4/Fwpm4ww/XjFyXqeL1ULF2a8nl5VFI1zvSlC8CTbIccWeahYJiePp2zdJ0qrssDDzzAtm3bCHq9PBVOB6BU9Pt56qmnaNO4MbIopgvwblpNWiQWw8wELjqZYq8gCHwST/JRNJ4OcpRkHg1F2BpPkqso9OvXj1WrVlGqSBF62w4dHYcS2dkU83qxRJHeukFUkshNJIB06ObprVvjKgoNbIeQZXHTjTcStiyae72MyBTIrYxNyg2OH48g0N8wqJCxpRlmWrTxesnOBBqWLVsOU5J4JhzlKsdP1dKlgXSwXiPHZW0sQXfHZeyoUcyePZtOrp9zTYs8WSGi64QdhyKGQUVVY3M8yUTHpWvbtgXXTCqV4qyePSnj8XCLP0COrGCKIg01TzrIUpR4LxZnYzyJpWqHKAdWrVpFrmmxKhJllGXTsmFDAB555BHK2A5Ph6Oc5bgM6tPnkOv0xx9/pEmdOsiSROVSpbjsssuIla9PzclPkN2oF7369OWiiRMpaTu0DAQoVaRIwQ3CVZdfnvbHliQ6GybVyhxqr3My7Ny5k86tWpEXi9EvP5/mrdvRsElzalaqhCPLCIJAyHUZf+65uLpOpRIl/rG/y7/66itqlC+PJIq0aNDghB7G/dPYs2cPmsdLlTELqDJmAZrH+z/1YLeQfz7/8QK1IgjCJkEQiv6qO7Hcb7YZ9puQxIXHG/ffWKD+r7J06VLKOQ6vR+MMc9xjBrv9mezevRuPorAxlmBjPImuqn9qm/6xSKVSmB4vqyJR3ovFCzI6/ghLliwh4jiEHYeFvwlyP95cXn/9dV599VXef/99WjVoQP0qp85nd/bs2dTNKHvbOi5TJk486TG+++47duzYwU033UR+xkJsjj9Ah6ZND9nu559/JjcWY7TjMshxqViixEkdp0WDBjR1XVo7LrUrVTpq4blcbi4LAiE2xhLkWtYxBVGqJFFJTduKPBmOUFSWeSocJWTbh2371VdfUTInhzzbIR4IHFExv2bNGorZNgMMk+YeL7dkVO4LFy4k5vdTUvOk7fZUlfNHjz5s/+plyrAwGEp7UwdDPPjgg0ec9969ewvU9V18OmNMi63xJK29XsZbNrbH87u6zgbm53NpRugyyrKZNGkSAFdeeSUDM9+/zvX/IXX75s2bef31139XTsu+ffsoUbos8YqnES5WkR69egPpz8mzzz7Lo48+WvDwZ8WKFVTN1B0WBcOUU1RudAM0rV37WIc4aV5//XWSySSGYfwuH/APPviA4cOHM3ToUD766KNDXvvmm294+umnTzgvq5BC/pf4zxSo/80thv92Fi5cSGXH5b1YehGc36XrMbfftWsXFUuUoKTrEjRNXnjhhVM6n++//56Y389426G749K0Tp2jbvvDDz/w4Ycf0qtLFzo6Lte7fkKGwcaNG4F0IfkXheev2bdvH2vXrqVYMkk9148piuT7dFRBYE0kRiU1rTi2RJElS5awfPlyhvTty5zZswvG2r59O/WrVkVTFDo0b86HH36IrWkUkWXMjGWMIctceumlR3x6WyKZpLamYYoiEUniPNOivU/H7ziYqkr7YJCgYTBnzhx0UWRjLMGaaAxFEIjKMrYsc38wxMZ4klzL5rXXXuPdd98lbBhc4bjU1DSaaR6yJQmvIKALAnVUjQqKik8Q2JbI4sVIuhDcoFYtyjkOK8IRKnu9VNU0+hsGjT0edEGgQqbA7RUEzvbpTLcdOrdqhSXLRDNezRdaDnUzC7w8WcErinhVldJZWQzp25dqZcpQTFHpbxjM9QcJ6vohvnS/hLDt3r0bQ9W4LxjiNn8QWxRxZZk8WaGGqqFl7EdKKQq2KFJWUTFFke62g6kouJn3ZXM8iZVRXzwbjlJeUYkEg3z22WcA1K9WjWpeL/0NE9fnY+nSpQR1nUYeDxdm/JHbmiZFc3II+3wEvV4cVWVdLMGT4QjeX/yyDZMyikJlVcXNqNw3Z2xJcsJhIL1g7dK2LYbHQ+NatXj77be55ppr8EkSZ+sGMUkiLMt0bt2a559/nlaNGuFVFIrEYmzYsIFUKsWV06fTpGZNmp92GraqElQUDEliqmlTRdPwx0sSyi5HQJJIyjKuohzWEnzRxInE/X7qVanCJ598AqQXjxeOG0exeJwOzZqzdetWnnjiCd56663DPjMAc+bMIVq6JiV7TCMYTFKtSlWKRqM8FY6yLZFFlUCA559/Ph0W5POxKhLlWtdPOUU9alDRsfjuu+94++23Gdq/P10dlzGWgyTJqJqHOXNuQZYk1scS9NUNBEFAznitl1QUGtc6tYvdU80fCWs8Gvv372fZsmU899xzf2qo4b59+/DqBhUGz6LC4Fl4fcYJK88KKeSv4L9coE6fntBGEIQPM9YdF2a+d7EgCB0y/+8VBGFRJv9ljSAIeccbs7BA/c8hlUoxYtAg/IZB3cqV2bp1618+h82bN1O7YkUsVSXq8VDatul1FIXpX8XcOXOwPB5sj4dJ48YdcZsffviBc/r3p0nNWtx9111/+pzKFi3KpFPss7t//34G9OpFVjDIme3bn5Qn84YNGxh1zjlcPHUqu3fv5q233iJoGJyXyQS68frrSaVSzJ41i4H5+Tz22GM8+uijxG2bgNfHtVdffcLH2rt3L7Ik8Uk8ydZ4EsfrPWoHWOUSJZjjD/BeLEHCNI+pbC2Xl0dMkqmveYhIEpai4Hi93PEbGzpIdyl2yxRpx9oOg88++7BtDhw4QJvGjfHLMq08XkabFm1dP7fffjsvvvgijqJQWlZo5/VhSNJh7/fZ3bvT0XGZ5Q8Q1nXmzJnD3Xffza5du9izZw8ffvghe/fuTfuTWzZz/UGucNy0haimYUgSpqYd5nO+ceNGnn766eP+fO+9915yLYsJlk3MMAqCOVetWkXMMJlqO5SxbWbedBNffPEFa9asKRB+vfDCC9x4442nXLTx4YcfUr5yVQLhKNMvv4IdO3Ywc+ZM7rrrrmMqsPfs2UOtihUp77pYsozf4yFgmjz//POndH6QtsL5JTzxiiuuOKl18bJly7D8QbKqNsP2B3+Xn34hhfwv8m8oUP8rLD7+lzlw4AD9evZE1zSqly1bEAhxNO68805aZNoOr3H9tP/Nk/g/ytq1aynmpNut3onGcXy+gtcOHjzImjVrWL9+Pa+99hoh2yZhmlQvV45zBgygY4sWPPnkk4eNOX3aNEyPh6LxOAsXLiQRDBL0+ahRoQILFy5k2tSpmJ60CjVPlmnj9bE1nqS3blAsJwdT0zjHMKlgOwVhj+eOGMFZjssHsQRNHJeWLVrQW0+HPI4xLTRBwBZFuukGQcPglVdeOWROCb+f1l4vL0ZiVFM1IpKERxAwBAHL62XmzJl88MEH9O3RgyqqRkJKeylbsoyuaVxwwQW4uo7r9VK5ZMm05UcwWGDXcE8glPZcluWC4rIsCHglCUUQqK9plFIUAqKI6/UybswYwqaJT5So5/HwaTzJoIwf9rZEFrf4A0QkCb8gYno8jB49mqSi8Ek8yZJgGEsUCckyp2fsNK5wXFxF4SrHT08nvQh5OhSho9dHUD482f26q68m5roUS6aTxD+MJXgvFkcWBKrpBi+Eo2iCwDPhKE9nbDWyJBlXlplk2fTWDRp5PFzhuOiiSHlVJS+ZpIxtM8a0CBoGzz//POPHjuXs3r3xiSK9dIO4JJNlGMycOZNqgQBPhCL4RYlSqkZWOMyWLVtYu3YtGzZsYOyIEdgeD6bmKfAhb6BpFFMUtsaTLA+FMUWRsCShiyLjxo4taHfcu3cv3Tt2wtF1VI+PRMWGyKqXnj6dmRlV+6/90X/44YeCVs0FCxZQ1ra5KxDEI4qsjsT4KJ4k4PHQtE4dunXqhGm7+L0+LrBsHgtFyHf9zJgx44Q/d19//TU33XQTxXNyqOq6xA2Dm361/yuvvMKQvn25dNo0qtaohSGKXOm4NLQdSmdn08dxuckNEDQMtmzZwuuvv06uZbMpnuSRUBhHkuh2ksqOd999FzcYJpgsSkDXudR20GSFSsPvoNLwO9C8PmqUK0cfx2W07eBT015/UUmilqaRHYkA6d8b11x5JT06dmThwoUnNYd/E6lUikbNWhDOLYs/XoShw0b8qcdbsOBedNNGN20WLDjcg/+/RCqV4s033+SVV175Uwv/hZw6/usF6j/jq3D9XcgvHDx4kPZNm3Ku4/JSJEYRw+D666//RwS97dy585g2WEP69qWD43JHIEjcNFmzZs2fOp+j+ez+HezYsYOo6zLKdmjlOJzZvj0Aq1evZtzYsSxYsIBUKsWMa6+lgu1wse0SM0yKJZNc5fjTa2Cvl8qlSlE0GmXOrFnHPF4qlaJ8sWIMdhxGOS5F4/GjFidfeuklon4/qiwz4dxzjznupk2b6NiyJZXLlGH27Nl8+umnR1Uez5o1i4YZoVW3TJfikfjpp58IWxb9DZMOPh+OorB161a++uorDFFkVSQttMhTtcM8mL///nuGDxxI64YNObNjR0o5Ds0CAUoWKUJONEqOZVMsmWT9+vVMmjSJYokkFfLyeOKJJ9i2bRtff/01Q/r2pWKxYowcPJj9+/ezaNEiQoZBtUCAMkWLHvfBxpIlSzh31KjD7nMff/xxhvbrx2233srTTz9NwDAo7bpUKlmK+fPnEzdNevkDBE2TdevWHfMYJ0Od+qeR06w/Fc+5FTsYPSlbm71797Jq1So2bNjABx98wHfffXfK5vVbfvrpJ7p164YgCPTu3fuEw81btz+dou1GUWvKcpK1O3LllVf+aXMspJD/Ev+GAvVx2xB/+1W4QP5n8/DDD1PecXklEmOg49KnW7dTOv6ePXsomZNDV8elvuPSo1NnIL0I6tq+PXm2TdQwKF+8OJdngsYa+wOHpXz/wrp164gZBmuiMWa4fmKWxUTHZUs8SXO/n7lz5xaM36t7d/KU9BP0LfEkTT0eTFGki08nIEmMN23OaN0agKH9+jPKTofHdXEcOnToQG2PhzXRGNXVtEr5F6/g0ZbNBRmf6F84vVUrLsgodXvpBlVVlf66SU/dIKBpdGrTliFDhlC+eHEG6QYrQhEqqSqlFIWQJFE8nuDWW2+lSunSBFWVVyMxzrVsDFmml26QkGUMQeB8y+axULqArGfCDmtoGpYoUlJWqK6oWIpCm6ZNaWhZTLEd7ExIny6KxCWJuf5A2iZEEPAKAkpGPewXJVZFokx3XHKCIQxRIk9WeD4S5QzdIKZpBT7NAa+Xyq5LU3+AqmXK8O677xb4sK1fv56oYbAyHCUvE1qZkGQcUaJEbi4eQSAmSqiCwGvROK9F42iCgF/X6dO7NxVsm+KywpJgmG2JLBp7PKiCQPcuXShbvDh+XWfo4MFUKV2a7rZNESWtxn4/luA6109E19m+fTtl8/JoHAiSNAyGDh7Mzp07+eSTT3j//fcPUc4PGziQzpbNo6EwbsZH+nZ/kAGGSZYkERBFbF0naFr4VJW+PXpwww03UNuyaeP1EqvViVpTllOk5RACmpcqqkpAkmjb5MgPeyZdeCHDM9dKKGPt8mgoguPz8c033xTMa+pFF5FrWQy2HYKGydq1a4F0GEl2KET1smULFqcHDhxg27Zt7N+/n127dlE0HqeD41BEURhtWiwLRSiZTAIZvzXT5ELboaHj0LxxY07PtDreFQhSt1IlenXpwmk1arB8+XIgfXN7Rtu2JAwDS9MYPGjQYZ6Gx+LmG25AlSQ0WaFE18kES9XC0jQkSabSiHlUHjkPzevjkUceoXjJ0pQtW46eZ55JR5+PhCQjCgIVypcnlUpx9RVXUM1xuMb1kzDNU9aCezQ++ugjapQrR9i2ueh3tOX+XjZv3ozpBqk5aRlVxy5E1bQ//ZipVOp/omA75ryxOKE4biyb7mflH3+HQv52CgvUhQXqQn4fs266CZ+q4kgyt/qDbI0nqe0P8PDDD//hzp+DBw9yzz33cM011xR0tJ1qTqtWjfkZS4u2wRD33HPPn3KcX/i1z26zevX+1iL+K6+8QsVAWqjyciRGIhA44nZd27ZlRibEur/rx/b5eCocZXM8SVhRGGJaPBGKENJ1Pvjgg2Mec9u2bQzp25cB+fls2rTpmNumUqlT3j22d+9eunXogO310axu3aN6PG/atImEabItkcXGWAJVlgteq12pEmfq6Q7UgG4cM1wvKxhkVSRtVxjxeBiUCXs/y7KJOg7NA0GKWjaX/yos/aabbqK24/BYKEI9x+H666+nXuXKzPUHOM3jQREEskKhgu7G30uLevW4yU2LyJoEgtSrUoXrMz/ns10/157CINmSZStQutfl1Jz8OOEipQtU3X8Xb731Fq+88soRP3+pVIpp06YhCAJ169Y9rjXQ/Hnz8GkerKwylOw+DTeWw9KlS/+sqRdSyH+Kf3yBOj3Hw9sQj/X1v7ZAXrFiBUVjMbLDYRYvXvx3T+e4pFIpRg8dSsRxaFSz5nHTjH8PX3/9NePHj6dUdjYxxyE7FKJ8sWKEfT42xZO8HInhk2VGOC7vxRIU1XXyolEa1ahx2ELqtddeo6ht83E8yeJgmLCuM9xx+SiepK7rMm/evIJtu3fowFTboZqqoWYU0Jdk2saGGiauonJLRvm7ceNGssJhEqZJ2bw8PvvsMzq1bo2pKDiiSE9dp4KiMssfIE/XeeBX3nbbt2+nU9u26LJMXkaJ6xUELrEdwhlLjiqKgl8QaaqmbUDkjOVIm4z/nl+SsEURRxSxBYF8n85t/iAVihWjUqVKSJlicklFoYKqEhJFFEGgmcfLmmiM8yyLpCQx2/VjiCK2KLLoVwXeHFkmIIpogoBXEDnd68MSRZp4vHT0+jjLpxMWJUxRxJ+Zf1FJpr9hEpIkQj4fuijS0uulqKIyfNAglixZwty5c6lTuTLZlkXANFm5ciWrV6+mpOOwLBTGFUUmm+mielFZwSdJVFdVimSU0kZmTg1r1WLdunWkUimuu+oqEq5LdqY4b2e2SQQC1NY8lM7YgaiCQD1No77moYnHS56sUEXXmZwpIu7atYsHHniAFStWMGPGDDq0a4fr9RLTdc5o377gWu/RqVOBF1wb20GXZWprGm28XiRBwJRloqaJVxCprKoUNS0aN26MKYqUkhW8/gSl86/AzCpDW91IK/Xj8aOGy7zzzjsETZPOoRCO10uRcARX08gOhZl3552HbPvYY48xffr0gtbJDRs2EDEMngpHmea41KlYiR07dlCpZEnCuk6RWIy7776bmsH0zdyKcIQcWWaU49Ksbl0AHnzwQZqH0tfGw6Ew5fPyCFkWfR2X4rbNyGHDCJgmUd2gad26BeqEVCrF+++/f9K/I7799lssj4fVkRiPhiJ4VQ/h4lW48sorGTV6DJrHh+b1cfkVV2L7gxRpNZRE9dbUaXAaiVAISdFQDBdBEGjfvj2dW7UquBHr5/q5JtMF8WfRplEjxmdUZ7mWxUsvvfSnHu8Xvv/+e0zbpXiXieS2HExusZJ/yXH/6xw4cABZUal2/iJqXLAUr2H9Yd/TQv58CgvUhQXq/0VSqRSTJ0ygWDxOu6bNCh5inyg7d+7E8nh4KRLjEtvBK4rk2TbVy5enXF4ekijSqVWr323pdO7w4VR2HHq4LtmRyBGVk7t27WLw2WfTtFZt7rvvvpM+xh23307StGgXDJIMhY5ZbDwVHMln98/khuuuo1xuLqc3b3HY36Jdu3aRDIUYaDuc5rjkdz2ybeMdt99OUctipGUTNAwuGD+eoK6Ta9kEvV6WBsN8Gk9S0nH+UADpwYMHefbZZ3n++edJpVLs3LmTgfn5tKhX73f5Ap8se/fu5cz27XF1nZYNGlAsmSTfdmjrOLRs0KBgu2+//Zah/fpxRus2h9nj/ZZmdesyINM1aKgqp9sOG2IJahoGFYx0J+0ToQilsrIK9hk7ZgyjMkKTcy2bMSNG0K1DB+r5fDTU0l2rI2yb/kfIPToZenTqzGDH5YVIjFKOQ9/8fGo7DrP8AXIsixUrVvyh8X/NokWLMCwXfyyHOvVPO+K1n0qlGH3ueWgeL0WKlTilCu5fc/74C7BDMfyxHLp063FU4cTChQsLwhPfeeedo45XPJFgSTDEINvF0G3GnHfenzLvQgr5L/KvKFCf7Nf/0gI5lUoRME3uDYR4OBTG9nr/lYFZfwbN69VjvOPyTDhKRJIYZZh4RZEHg2Guc/3EHZe4YeKRJExFYWEwxIWOS83y5Q8Z5+DBg3Tv2JGIruP6fMyZPZsKxYsjSxKdW7fmvffeo0a5ciSDQYYOHkzIMGjopIuO8WCQ8qrKXH+QbFmmaGax8Uu79wsvvMBHH310mDK0XpUqNNc8afsMUeKsHof+saxfvTrZikJCklBFkbjHQynNQ0BVKZKdTTlFxc4E71miSEVFoaXHg1cUOd+w0gV6UeQG1083Xae4oqCLIn7DoHyJEjR3/URlhTsCaeVLRVXFKwjYGQW1I6YLp6YoMtcfICxKxDJe0rVVDUNWCPp8rAhHmGY7tPZ6ucrxkyPLDDbMggJwdsb+461oHE+mGL4pY/0S8XqZ4wa43HEpZxgF1gqLFi2irj/AlniSm9wAucEgcb+fsGVhSxIhSSIoigVWDcVlBVUQcESRm10/+aZJncqVD3m/H3roIUpbNuUVBSXjUe1kCtKlFIWloTD1NQ8VFQVREJjrD9DW68UQRcaOHs2BAwd47bXXyIlE8CgKxRMJWjkuLb1eyikqjTWNoCTh+nzcd++9vPjiiwQMg8qBADmxGIascJ5p0V83MESRQYMGUUbTeC8WZ4hh4pckLFlmgmXzYTROTNHwql58okg5ReXOQJC46+fc4cOpU6ECl06detjiasK4cZTJyaF18+ZUKFaM0bbDpbaLqWnHVASvXr2aUo7Dp/EkS0NhSiSTXH311XRy0ur/EbZD7+7dCRoG17p+ulgWMcOgTaNGBR7h27ZtI2zbDLFsKtsOE8eO5YMPPuDKK69k6dKlNKlVixtcP5/Gk9T0+3nooYdO6rP+W77++mtsj4d3onFWRaKogkjX7j0LPmc//fQTP/30E2vWrCGUU4JaU5ZTeeQ8/KEI/QcOJrtpf2pOfhwrpxyCIFCkSBHiusEAxyVoGMdclJ4KaleowB2BIFviSar7Azz22GN/6vF+zXPPPUfVmnVo0Kgp69ev/8uO+18mlUoRCEcp3nkCpXpcgmE7hX+n/wUUFqgL19//iyxbtoxSmeDjfMel/1lnndT+33zzDZbHw9vROC9EYuiaxptvvkmfbt0Y7rh8fARxx8lQLB7n2UxmRY1g8Ijrl749etDZcbnNHySi6yxZsqQgjPxEWb16NfPnz/9TRDR/Nvfddx8D8/O55+67D3tt9erVZJkmS0Nh+jnuEUPxNm/ezKQLL2TGjBnHLJg//PDDTJ48ucCCcNOmTbz55pvcOncuQV2nhOPQvH79Y/oJ/5aff/75EKuKs844g9KOQwnbYVCfPnTv2JFursscf4CwYZyQr+/+/ftZs2bNcS0oj8QNN9xAY8flnWiczo7DyHPOYfKkSVx22WX88MMPR91v586dvPzyy+zcufOw17744gvyu3SlZf36LF26lOb16+NVVRrVqk1Q17nFH6CP49K+WbOCfd577z1ClkXjUJiQZfHOO+/w5ZdfUqZ4cepqHrbEk4wyLZrWr88bb7xB5ZIlyY1Gueso3cFH4/PPP6dxrVrE/X4mnHce+/fv5+IpUzi9WbPDBC3H48CBAzz99NOsWrXqqAXfbdu28eabbx71GnnhhRdwo9lUPe9+irQaQt0GjU5qDifCwYMHUVSNSiPuxC1ZC0n1cEbXbked0+uvv04ikcA0zaOqomuWL8+ljsvT4ShhXf/Hhq7/k3nzzTdZvXr1P8IWqpC/lsIC9b+cn3/+GU1WeDsaZ30sgalpfPvtt3/3tP4RVClRgvuCIbbEk1RS1f9j78zjrZreP76nM+15n3m4U7d7u3Wb53meNIhGFEpRURQlCYWKQplTSiGEzJkThSKFSH0j0kQZoigNuuf9++Oc7k8qFdF3OO/Xyx86a6+9znTPs571PJ8PMxw/iiRREI9TlJ1NTFWZ4vippOvkpCU5Xg9FSAQCh8yVTCZZu3btQa/tgRazxjVrMtqyeSUYJuDz8fDDD/P000+zdetWXnvtNQJuN7Vcbip6fTSr34BBF1xAr+7dydJ18gyD8885tN170aJFuESR81SN6wyL4rw8kslk6R9pS1YYbVg8EQjhE0U6eL1sjmdRUdPI8npxCQLtvF42xRIM1g1UQeAcVaOS14vpchHz+SivKGyOZ/FyKExAkmjbqhVffPEFhicV6Jzi9XKhpvN6KEJIkqnudhNMG41cm5Ye6ZmWAjFFkVtsh0XhCLookq2qFOfl0cCn0tnrwxRFarrc3JPWt+7mU1HSEiAjDJPTvD4auj1kSTJuQcAjy/gkiR4+lQf9ASxJYuzYsWzbto1XXnmFItPi/UiMS3UDWxS5w0pVcc8JBLnSMAmkq8gf8qf+P57WzfZJEoooUpyXd1AS9K677uJUy8YSReKSzLPBEDOcAF5B4Ly0Lvi1pkUtxYUmiqiCiCYI5EkSvbp356zOnUlYNrfZDisiMWxR4qVgmE2xBJookivJpVrb5bKyqFZURMDnI2zbLF++HJcgoIli6j9JolmzFrRMy7+MNS0CkswI3aCJ20Mbj4d6Ljd+SeL1UIRxppUyV7Qsmlg2jwWCVDRNhgwZwosvvkgymeSuu+4iIstMc/xUTR8sXKabxKSUXnpA1w9pC1yxYgVXX301s2fPpk3jxkRVFVuWaVavHuPHj6e1ZbMuluBcy2booEEsWLCA09u04aJ+5x82IP/Xv/7FNddcw6xZsw4JNjq0aMGodDdDBcs6rA788TJm1CgMjwfD42FGWobn9+zatYucMmWJVWtJsExFzu8/kEmTbyVUtgrlz76BQE4RQ4cOxbIsdF2nb9++f2jKc6J44YUXcFSVMqZJ41q1jlnvLsO/L++88w7FlatRUFR8Qj7fGf5+MgnqTPz9v8jMmTNpl5Z4uN126NCs+XHPMXb0aHS3G93j4d6pUwHo2aXLYeXxjpcep57KaVZK+zig63z99deHjKlfuTJzAkGWhKMYkkSOplEmFmPz5s1/6p7/STz11FPkGQbjLJsyhnFQ9yWkijyapeVLHkhLrJ1IyYwvvviCu+++m0ceeYSlS5ceV3L6vffeI2zbqC4XZ3XuzHfffYfmcnOfE6CsrKCLIgWJBE+nuzUbBQLMmzfvD+fcs2cPjWrWpJxl4VfV4/YRuf766zn7gNyiaTHogguOes3atWuJ+f1U9fuJ+f2sXbv2mO83b948Wtarx7k9ehyik75582bmzZt3kOHp/fffTzS9N4lKEnUqVaJCXh6TbId5wTC2z3fY78jfTTKZpFvHjlRMd0oOOv/8PzXPK6+8QjC3iDpXv0Bhj2uoWrPOCV5pinA0gV2uHv5Kzag25EFCBdX+8G/UV199Ra1atRBFkYkTJx6SgP/kk0+oXlRE3O8/yI8nw7Fx+RVXYgaiOLFcunQ/439CCjDD/5NJUP8XcP011xBUVSKaxqUXXXSyl/Nvw2OPPYZfVcnxeLBlmVzd4OL+/QGYOHEi/dISCxNMm2y/n0ppY7dJvzMx2LdvH906dEASRSrm5x+SyKuYl8fD/iA1XG4isozt8zF//vzSx++dOpXmtWtTq2JF6psmVxomXlHklWCYz45wqFC1XDkauz108fkoVBRsnw9LVVHdbqbefTeO18vroQgbYglyZRldEBiqG/hEkZssh7gk0cTjYX0swXmahi2KlJEVcmQZw+PBVhR8gkBzt4e4JKNLEj/99BP79+8nNxpluGWTL6dkLQ5UYmcrCrYkEZNlWni8vBIKU8HjIT87G0OWeS4YYl0sQbYs08bjQZckaqsq2W43jevVo1J+PhXdHm6wbEKSRHWvlyrlyxNSNcooCuNNi6ggoCkKuW43jihiCwIBMVURnet2kx+P88MPPzCwb1/cgkihojBCN8iTZRKyzMZYgkXhCJbHQ0iS2BhL8GoojJbWeR5nWqyNxikjKwQ8Xh577DG6d+xIYTyOX1XR0xXTd9p+TvF4GaDphCSJhm4PPiElk1LN5WZJOMqpXh+GIKBLEkMMk6gs84g/yBexBDFF4VRNZ6BpoaUT+Ae0tgvicU5La59falqc17MnLlFkRSTGikgMRRAIlKtN1LbJNoxUolLXWRqOkiPLWKLISMOkIG0w+WwwVFrtPSbd/tdP08n2eim2LAadfz4N6talTzrRfpPlkCvL2KLEtPSBQVe//6BA7LPPPiOg6wwyTCqYJldefjmOL2Wg2FHXadO4Mac0bYokitSuVOkvyRXs37+fFStWUFymDB5FYdD55x93IJJMJtm1a9ch123btu0Q05hkMsns2bMZ3L8/L774It999x133HEHjzzyCPv372f//v2MGDmKmnUbcu1115ceTlWuXBlRFBk7duw/cpq/detWPvroo+Pa3GXIkOHEkUlQZ+Lv/0W2bdtGuZwcqvtTpsW/jWePhx9++OGg39/Vq1eTCAYJ+HzUr1aNnTt3/ql5f/rpJy4fOpSzu3U7xIjuAPfcfTfZhkFButBiczyLPqbF6GuuOez41atXU6dSJcpEIqUJ9f9ULujbl5HpWPBq0+KSCy886PE5c+bgS3c86i4XEctCkSQu6tfvqLHX0eKRL7/8kpBpcobjJ0s3jrvitlmdOkyyHT6PJaho2cybNw+/rqOLIg/7g8xwApheL3m6QXt/gLxo7Ih60Qd45ZVXqO44bIolmBMIUqPc8UmXff311+TH4xRYNjG//w/1tLdu3cqZp51GTjjMhen3YJBpcflRDB3/Cm+//TbZus5D/gBnmxbn9uhB0DRZFI6wLpYgruvHVGV+otm6dSuW18u6WIJ/ReMokvSnDkJ+/fVXWrQ+Bd0Jopv2n/57dDSWLl2KE4qQ1eI86o5+mXit9kyYMOEPr9m1axc9evRAEAR69+6dKSY5QSSTSRSXmxrDHqX2qOdQDet/4nAxw/+TSVD/l/DFF18c1YTif5GNGzeydOlS3nrrLZYuXVoafM2aNQuXJJHtcmG6XNx666288cYbh23dnz17NvXsVFviEMvm3B49Dnr8kYcfRne7qepysymWYKrjp1mtWofMU7OoqPTUv57bwwBN50F/AEfTDmo9vHjQIDyCwETLZmM0jiGK+BSF5wMhnguG0FwuRo8ahSVJlFMUGrs9ZEsSjdweZFGkgmnSV9Uw0jIXalpOY04gyMP+IG5B4CbLpp3Xiy2KKTfskSNLW87Xrl1LqyZNcCSpVFO6msvFMN2knddLjiRRL22SWNPt5nLDxJPWkHZECUMUae32kCXLbIolWBKOokoSsiiSE4lQ7HJxvxOgs2Vxww038N5776GKqWSzKor4JYk+WspoxCsInKmqrI3G8YoiDRyHZ599lo8//hhbkuijaqWV2JosU8m0iOs6N1x/PfnRGGXT2tHNPB66+FQSsszqaJwiRaGHT6V8Xh7dLZtXQmGKTJOKhYVYUspMURQEQpLEMN3AL0qERBFdUTgrnegdaZjookhYSj1nnyDgEQRsj4c6VatSvbiY09q1Y8OGDQweOBBNUbBdLvIiESr4fHweS3CubtCoTl00t5vngiGeD4ZxKy6Kz7uVMoXl+fTTT9mxYwdnde2GLkl4RZGmbg8RUSSeljPxiSJVFBeG24NPEGjh8eIVRF4Phfk4EkN1uxly8cVookgPn4olijR2u9EVhea6zjTHX2r899vvR5dgsLTCpkaFCmR5vUQlmSxZJujzAfzlRO0777yDTzMQJBmfqrNgwYLjnuP777+nZnExblmmVsWKR+0guW/GDAoNk2tMi6imHbPh4c6dO+nZsyeCINCpU6e/1TH8n+Cbb77h+eefL5VhyZAhw8FkEtSZ+Pt/lZ9//plFixb9KUmEP2Lv3r189dVX/8gh71tvvcXpnTpxmmmxMhqntWVx8803H3ZsnUqVuNayeTFt6vf555//7ev7I77//ns++eST4z6g3rFjBwHTxC9JDNENAi4XL7zwQunjJSUlWKrKM8EQr4bCeESJ6y2bNdE4haZ1xHjom2++oVbFikiiSIv69Y8obTFt2jR6pKuzpzl+2jdpclzrb163LjdbDmtjCQp0g+K8PIK6jkcQ+Cwa55NoHLcs8+qrrzJr1iy+++67o875/vvvE9d1FoQijLBs2jRqdFxrgpQs3MqVK/9Q0gNS3YD9LJsePpWGaR+UVpbFxKMkOv8qt0+eTJWyZenWoQPff/89t0+eTDCtB96tY8eTUn36yy+/4Nd1pjp+brIcHJ+Pa0aNOqJXzh+RTCZZt27dIQUnJ5qPP/4YOxAilFNIPCvnmCrPk8kk1157LYIg0LBhw4y/yAkiEkuQf/pwinqNRzXMP/W5yfCfSyZBneFv5cUXX6RcVhYVcnN5/fXXT/ZygFTQ6hYE/KJIGVnmfE1Hd7no1a3bQW1TB7jvvvto4ThsjCW45gh6bXPmzCFf13knHGWoZXN627Y89thjTJs2rVTu4Mrhw6lhWQwyTCyvl5CqEvJ4uOSSS0q1cRcuXIijKIwxLcrICs3cHoK6jldRqOlyY6UTwZrHQ+/evdHTshv5ikJH06R1o0bMnj2byy+7jHfeeYe9e/cS8/txCwKr08GdIgisjaVa5GxJIiLLVHGl2sNGjRrFU089xa233kq+2825qsZD/iCOKOEXRRKSxPmaxoZYAlEQWBdLsDGWwBBFKisKD/uDtHZ7aOb24IgSUxw/F2k6BYrCv6JxErKMoxtoLhe1K1Xixx9/5Nprr6VVWqLkVtvBJ4gsDUfZHM8iW5ax0xXDtijiuN1UyM2lQc1amOmq6VXRONeZFtXLFTFu3DiWLl0KpAKNsWPHIosia2MJNsezsNJGj0WKQkAUCXm9TE6b33V2/Fx77bX4NY0zbYeYqqJ6PBSkTSirKS68oojl8ZAny3gFkSxFYUMswWOBIAWKwnWmhU8QcCSZIbqB4/Uya9Ys/LrObbZDL59KQJSwJRlBEFK61JJEQNf/P8GdWwU1mM3wESPZunUrs2fPpkphIWPTpnlBSeJS3UB3uWjZvDmSIOASBFxuL61UjUmWgy4I3GY7jLBsqhQWsmfPHrp27EjQNCkTi9Gibl0efPBB2jRrRo1y5Ti9Y0fcskLQMFmwYAFLly7FkFOfwyoeL5defDGyIPBRJMbaWAJNlkt1Gfft28eCBQv44IMPDvt9SyaTLFmyhGXLlpFMJtm7dy9DL7yQuhUrEo5lUbbzFdQa+QyGGSQRDB739/maq67ijLQcSnfT4qorr+Tbb789YkB+bo8eTEx3T1xkWoz9jUv60Ugmk9x+++0oikJhYSErV6486jWfffYZDZs0p0Llav+Ioc+x8Pnnn+MEw8Qr1MGw/aX6kf/ubNq0iZtuuonZs2dnNOky/O1kEtSZ+DvDfzY7duygXdOmGF4vp7dtyy+//HLYcWUiEV4MhtkQS1BoWaVx5D/Jr7/+ymuvvcadd96JrarkGgYNqlc/4poPx3vvvUdlx89jgSB9VQ1H0w65h9flYlkkxspoDI8ocktarq2SbR8iP/Xss8/StlEjahYXc4Zpsj6WoL1lM2nSJADWr1/P9ddfz/Tp09m/fz+LFy8mpuvc7fhpbtmMPEZjuJ07d/LDDz/w/vvvE/X78SgKucEgvTWNrj4fuiQT8fmIaTpXXHrpMb8eB7j5xhvJCgRoUK0aX3zxxXFff4A1a9bw/PPPH7Fqu3x2Ni8Ew3weSxBzuwmbJj27dDlu/fMTweeff84HH3xwUmOlRYsWUbdSJWyXi7M0nVMti44tWx39wpPIDz/8wLJly467w+OAeWJubi4ff/zx37S6/x3ee+89KlapTtlyFQ46ZMvwv0EmQZ3hb2P37t3YqsqcQJD7/QH8hsG+ffu46cYb6dWly0lL1jSoV4+IJBGXUlIVRYpCNcXFqZpG5YKCQ8bv2rWLRjVr4vf5iAcCh3UQTiaTjBw2jIBhUK9KFXp17041y6a946dSQQF79uyhpKSEGTNmMOrKK2lYvToXmhaz/AFUUaRcbi5PPPEE9WrX5gLdYHM8i1tsB0uSePLJJ+l9zjnUcrlTSXLDpJHbQ1F2Nhs3buTVV1/liuHDGXv99aUnjLt27eLdd99ly5YtnN6hA2ra9C8gSRiCQGefjyxZxicIvBmOsCmWICctFVLLtMgJBvEKAn5RIl9WuN12GGGY+HWdqMtFX9PCVBQamhZNPV6iksQ5PpXN8SxGGCZBSSI3XeHriBLjLIsvYwmKlZRhYac2bRg35lpMn4+gaZIty7wWitDdp6IJAgWKQguPl3w5lRyOWRYVy5TB8HiYYjtUdbtxCQIV0jIXUxw/QUWhuu3QqXVrHnjgAUKaRk2/n4DXR1dVY4Cm45ckPIJAFcWFLUqlus/FLje5kQjjxo2jV1r24k7bT8DtoSAnh2F6qlWvo6ZT4PXS1aeiezxENY2FoQhXGyb13G5eCIbJlmVapV+TYpcLw+Ui4PMxPxjGESXOUTXCkoStKBQqCvNDEaq5XMhpHWrL5eKMbt34+uuvSQSDdAgEcWSZwbrO+liCXJeb3HCYzp274jMDeANZKB4VRRDRZIVRhkmuqlKpTBk6t2172EqgvXv3UrmggFNth6qGgaWkdOwf9AcozMpi/Lhx1NE0uvtUKnp9DLn4YryiyFTHz6OBIB5R5Oeff2b//v20qF+fyrZDXNeZOH78IYnh3mecQVnTJMcwGDZ4MOOvv54mls3cQAjVp1HQ9UpqXfkMphUmZFnH/X2+auRIeqUNG0/RdGyfD9PjoXWjRodtt3vwgQfIMwwuN0zCmsZbb7113Pd86623iEajqKrKo48++odji6tUJ7dVP4p6jkMz7X8Lw6WxY8eSqNeZuqNfJqf1BZzd+7yTvaSj8sMPPxCKxonX7kAwrwKXDP37WmYzZIA/DpAz/2Xi7wz/mSSTyUNig+nTphFMm/q1bdLkH5fWSiaTdGzVioq2TURRSj1kamk606ZNO6Y51qxZQ8cWLXBcLtp7fZT1eKheseIhz+WWCRMwvV5sr5fePXvi13Usr5cu7dsfJMGwevVqQprGPY6fzppOscvFpliCLpbFjTfeyLZt24gHApxnWtSxLAZf0J+SkhKGDxtGzUqVuHzo0GOSPHjk4YcxvF50t5srhw2jpKSEXbt2UZSdjSqKDNENcmWZdm3a/C2Jvy1btnBW5860ql+fV155hZKSksMWODz33HMENY1GgQB50egh+tAAt0ycSI5h0MwfoGLZshkzZFLFQoXpopAVkdghhyb/TSxbtqzUPPG555472cvJkOE/lkyCOsPfxo8//ojmdrMmGmdlui3rumuuoY5lMdGyiWoaixcv/sfXVb9qVSKSxGtpF/CidIXsGT4VlyActqWnpKSEr7/++iA36+nTplE5P5/2zZvz1VdfHTTer+ssj8TYFEtQ1rJYvHjxQSfo+dEor4ZSJnqVFBdVPF5sl4s+qpYysDNM4m43Qy65BEhJLlTUND6OxLhMN1ISG5JE5YKC0ha3n3/+mY8++oj169dTmJ1NRcdB93ioZhi8GY5Qw+cjNxgkYdv43W4MRUEXBAbrBvc6AXRR5GyfyoZYAlMUOcvr43Svj7AkMca0SGga7Vq1olmdugwaNIgPPviAGTNm4Nf1lMazIFCoKAQliXGmhSOKRCTp/yuDRZFWnpSBo5L+7zSvj7ssGy2dDLdFkVxRJCedSJbS1147ZgxPP/001W2HbFmmj6pRKf2+6aKIRxB42B/gy1gCy+ulStmyPBYIsjISI8en0qhePRrUrk3f3r0564wzCMgyzwfDnK/ptPB4qGyYPProo7z++utEvV6mOH4auT008HjIDoep5FO5O31gcF3aLKVhMEj/vv2IOQ4RXSeYNh+cbNnUcblp5PawOZ7FVMePIyt4BIGeqspLwTCdvD7cokgLj4eFoQgBSeLDSIypjp+oaZJMJnnggQfoGEi1Ss70B7BlmSxdp33z5vz666/Y/hBVB8+kztUvoOkOLwbDFHq9nNquHTNnziwNsJPJJDt27Dgo4F69ejV5psmmWIJnAkEsUWJNNM5TgRB5kQjnnn02RYqLM3wqZ+sG3bt1wysI5MsKEUlCUxQAPvzwQ8qYZqn2t+P14lEUskMhli5dynfffYfh8bA2lmBVNI5Llulz5pmlr+Gpqobi9iJKMm6P76jJ3sPx7bffUqWwEN3tJqJpjLVsNsQSNHAc5syZc9hrnnzySS4fNuwvdXV8/fXXNGzYEEEQuPTSS0u7IH6P5Q+m3qdrXsSOZB9WRuif5v777yeYV0zF8+8gUqEeo8dce7KXdFRee+01YoXVqDv6ZSoPuIfsvLIne0kZ/svJJKgz8XeG/y62bNlC1XLlkCWJZnXrHiTZ8Pnnnx/V1O+rr75i0PkXMKBPH7788stDHt++fTtXDBvGgD59WL169TGva926dURUjfWxBB9GYrgFgfciKd+RgGkeVboMoCAri6ssOyWPJ4r0UTWKVZVe3bsfMnbr1q189dVXLF++nK7t29OrWze2bNnCqlWr6NuzJ5cMHMhDDz1E00BK6u2pQAi/y4Xj9VKtqIht27bx+uuvUycdo74eilAQj9Pv7LOpZNnUdRxaNWx4TNISIcvi5VCYldE4fp+vVHasQYMGnO71sTmexX1OgLiuUykvj+4dOx5Vd/p4aN2wIRdYFlMcP4bbjVuWCVnWIfHhKY0bMyVdwNJa0xg9evRh51u8eDFz5849bkmCZDLJdddcQ8XcXM48/fS/Xc7i72D79u18+umnBx107Nq1i7xolPNMi5aWRfeOHY94/e7du0+oYefJYPPmzdSsWRNRFLnpppsoKSnhiy++OKGf2f8Fli1bxrx58zKHPP+jZBLUGf5WBp1/PgldJ6ZpjLzsMjq1bMk96R/4s/1+7rzzTu6dOpWWdetx6aBB/0gb1LR77sGRZHqrGlMcPz5RRBMELtB0emo6tSpWPOocH3/8MVFN46lAiP66TkE0yjPPPFPa8t+0dm0qu90EJAldSOkTG14vTz31FAATxo0j6vZQy+2mWHGRkCTO01LaxoN1neKCQp588snUeqdNQ5UkIpKMN52w9aaTtwFJommDBqxZs4Z4IEA528YxDDrZqdPqdl4vbbw+arrchCWJ6sXFZOkG62MJ3g5H8QoChiiWSocM1lJSFF5B5EF/IFVZ7fPRsU1bCrKz6Wma3GilnNMPJOU7tGhBBZeL/HRSeahuUEVVyUqbFt5iOxiiiD+tm5yQJPprOp9F45SVFSZYdulzGqDp1HK5aeHxsDGWoL3Hi1cQaK/r1KlcmXK5ecRlmc3xLD6KxNAFgbN9Kh4hpa882bIJmiZVypXDL0lYokhNl4sCXWfMqFFMu+ceqpYtS67Hw2fROA/4AxQpCiFNY82aNQBc0K8fCcVFN6+PuCTRWFWp5PPh9/lQ0q9TTZeboGFw0003MW/ePPbv389rr71GbiSCpSj4RBFbkngsEKSXqpEjyxTIculr3UfT8CsKbkEgT5bxSxJro3HmBkLoksSVV1zBQw89RFzXecAfoJNl0+ess1i1alVpu16FSlXJbXMB5XvdgMeV0rrLUxRaNm5cWrXy448/UqdyZVSXi4ply5ZW7/78888ETZPBukFvwyQ3FMJwe7B8PmbPno0/rQHeV9OxXS7mzJlDkc/HpliCF4JhcgIBILVZc1SVRwNBLtAN/LLMikiMO2w/NcuX55dffsHRNO73B7jL9hNxHBYuXEhA02gXDBEyTVatWsXnn3/+l/TFkskkP/zwA13atWOkZfN5LEFN22Hu3Ll/es4/Yv369TSrU4cykQiNGzVCEASaNGnC1q1bDxl73fVjsYIxQnkVqN+46b9F8F1SUsJlwy+noHxFzj2v30lpPz1evvrqKwzbT27bgUSrNKVrjzNP9pIy/JeTSVBn4u8M/10MHTSIvpbFhliCdpbF5MmTj+v6ygUF9LdsLjEtysRih/yen9K0KV0tm+GmRdRxjjmu2b59O5bPxyx/gLGmhS6K+ESRC3Wduv4Ar7322kHjd+/ezYYNG0rvv3//fuR0HLk+lkATRXJlmZouN7okMXfuXObOnctNN93EunXrSu8ZNAw6eH3U9HipXbkyUcdhpGnRy7JpWKMGuZEop/oDlDEMbpk4kS1btpTGoFu3biVoGIwyLU6xbHp16YoipYodNsQSBFX1sLKJvyfm9/NkIMTySAzb6y3dW1x22WXoosjVpkVFxYUpSTwfDHOmZXPBOecc0+t6LOSEQrwRSnWS5soKs5wAD/gDlI3HDxo3oE8fuqgazwRDZMkyps932Jjvz/Lcc89RZJq8EAzT1bK5ZMCAw477+eefeeGFF45YTf74448zuH9/nn322RO2tmNh4cKF+HWdhK5Tt0oVxowZUyrHtmnTJkZfcw2TJk06bLyZTCYZeuGFeBQFv2EcszfMvyu7du2ie/fuCIJAVnYOmh1A1c1//D35T+WWSZMx/BEiBVWpWKXaf8QeJcOJJZOgzvC3kkwm+eijj/jkk08AmHHvveQZBuebFgFdZ+bMmeQYBrP8AVpbNiOGDv1H1jR9+nSqly9P/cqVmTlzJlba4HB9LIEkikeshjzASy+9RHUjVYE6NxAiJElke71ENI37ZszgrrvuooLLzdvhKF19KjFJYoRukvUbjd158+ZRvkwZZEGgOF15PNwwyfOpTL/3XiAViLgkibPTxnwX6wbZkQg1XW6iksRttkN5l5vsQIDabg+fRuM09fko7/XxcjBMZ93AEEWuNkxeCoaxXC4Mj4fHA0HGWw6GJNHAsvAIAhFBIJE24gu5XJiiSJ6iUKtiRaoUFmJIEovT2tB5LheCIFCtuJjKBQW09Xq53rRxiyLnnnkmAwcMIF/VKFZcRNOmg3paksMnCFxrWtzr+AmKqcckQaC8y8XmeBZz/EEMUSRLlkuv09OGjyFdx6/rXKQbtPV6aez24IgivXwq+W43hYkEDzzwALbHw0vBMONMi6ouF6+FIsT8frI0jQf9AVp5vMTdbkzFRbXy5UtbsZYsWUJeJIpXFMmWZBxRYlMsUardfaZPJSHJaKJI0DCo5fWR4/VxXdoZ/rHHHqOSbnCNYVLL7cF2e7BEkRXhKG+Ho4iCwMC0hMuNlk01xcVcf5DKigs1nfzOVhQuNkyChsGkW26hac2aDDzvvEPMWdasWUO9hk3ILVsOze1GEQTaeb00N01umjgRgBtuuIHOafmL80yLYUOGAPDMM8+kWjwVhaLsbLZs2cL333/Phg0buOSSS4imWznfj8SwVZXdu3dTs7iY2rZDTNO449ZbS9cxd+5cqhYUUKNiRcroOp+nndKLc/MAmD9/PlULCqhVoQKLFy/mqhEjqFq2LKe2bVu6UTpRfPbZZ5RNJJAliTNOO+2Y2nRXrVrFgAsHMeba6475pL5d06Zcatm8GgoT13XGjh2Lz+cjHo+zZMmSQ8a/9957vPLKKwd1YGQ4ft555x3OOOtshl9+xVHNijJk+KtkEtSZ+DvDfxeD+/dnoGWzKZbgNMvipptuOuZr9+7diyxJbIgl2BRLYHo8h8g8OJrGh5EYm+NZFFr2MXdMrV27lg4dOmBJErVcbu6wHMKyzLXpvdLmzZtLx65atYp4IEBYValdqVJpEvzcHj2oatvUsWx0SaKhy11afVwQi1FsWZxr2URsm4k33Eit8uWxJInmHg+9VBVVFMkxUvHpymgMPf38Zs6ceUQD6w8++ID+vXsz5uqrU7IcOTlcadncYjsETfOY9LPnzZuHrap4XS4mjh9f+u+DBwwgJMt4BAGfKNJE09kcz+Jux88pjRsf0+t6LIy+8koKTJNmtoMuSayIxHg2GCI7FDpo3I8//kjA46FIUbjGtKjpD/Dmm2/+qXt+/fXXDOjTh3N79CittJ8yZQpd0gVck22H09u04ddff+WqESNoVqsWE8aNY8eOHRTn51PfHyCiacyaOfOgeR999FHydIPRpkVC1/9Qu3fNmjVULSzEr+ule5i/QvM6dbjT9rMxlqCSy00Ln0pVy2LU8OFHvfbDDz8kS9dZHY0z0x+gcn7+X17PyaakpIS+ffsiCAJ6djEF3UZRtlyFk72sf3v279+PajpUOv9O6lzzEk5WAYsWLTrZy8rwD5NJUGf4W3jsscfo16sXM++775AWrxdeeIEbb7yRjz/+mClTptDDn/pBvsv2c2qLFv/4WktKSqhWVEQXy6KdZdGifv0/HL9v3z56dOqEKopUVFyEJYnuPh+dfSpzAyGqFRRw6623clo6qXydaZGQpFSrns/H7t27eeaZZ7jtttvYsGEDA/r0obNlc6VhYrpc9OjenaBhYCgKpqqiCALNPR4+isRo7/WSFYtRICv0UlOBsCWKjDYt2nm9tPV4qaaq+GQZtygStywcSWJeMMzGWIIcl4vevXsTNE3KlynD/PnzmTp1KpY3pZlcqCg086nkRaMMHz6cp556igULFlDFceinalRSXLTxeglKEtUVF5VcLnRBYLxp81wwRLHLxfjx49mxYwemLDNcN3nEH8QnigRFkfouN+XLlMEnilRzufAJItmSREySMEWRS3WDkCRxiW4w0x/AJ4j08Pmo63azLpZgmG5Qs7iYlk2bpgwLBRE1rSPdX0u1/1mqSlSWWR9L8FIwTESS6KlqJIIh2qbbBac6fkxR4rHHHjvoc+D4fJiiSEVF4f1wFF0U6adqlJFlQpLEm+EIVdJ60aoo0trjxRZFgmpKU+26664jR5ap63bT0evDlzZlLJs2VVQEgbjXy622Q3mvl4CYOmTIlxV0RSHk8/FMMMTmeBZtgqHSKvqjMfzSSxlgpHSyB5sWw4YOZUCfPmgeDx18KptiCfpY/5+grpiXx5xAkHWxBAWmyZIlS9i7dy9FubkkZJmAJNHC46VQUTjj9NP5/vvvOfO006iSn8/4ceMOuveGDRv4+uuvKSkpoVfXrvh9Pmyfyrx589iyZQvbtm3jp59+YvHixdx2221UNy2eCoRoZFncfBybw2MlmUwe9YDpANu2bcMOhMhqejaRSo05rcuhrbCHIz8ep4bLRc90AP7SSy+xYsUK8vPzcblc3H333SfFNT1DhgwnjkyCOhN/Z/jvYuPGjRRkZWF6PNSqWLHUxPxYadWwIa1tmw62Td0qVQ75nT+rcxeaWDY9LZuyicQxJWi/+OILgobBWZZNQJJQBRFLlmlcrx59zjjjEBPjs7t140ozlWRvazvcc889QCqx8+yzzzJ37lxmzJhB1O3muWCI3pZNwjB5OpCKLWtaFnGfj4f8Ka+Zj9MJ9YTbQ34iQVfboaFlc+bpnQ+73mQyycKFC3nmmWcOqWz89NNPad2wIXHDIDccZuZ99x3T61pSUnJIQcFZnTszzrL5MpbgNNMiYlnUDwQIahrPP//8Mc17LCSTSebPn8+VV15Jpfx8NEXB9HqZ+/jjh4wdfEF/alk2vSyb7HCY7du3/6l71iquyAWWxUjLJh4IsHv3brZu3UpOJELDQJCApjF//nwm3Xwz9SyL2f4gxabJsGHDaOBPyao8FghSs3z5g+a96PzzuTYtoTfcMLni8suPuIbmdesx2rJ5Jxwl2zB47733/tRzOUCn1q0ZYdl8GImRoyg84g8yLxim6mG8nX7P+++/T45hsCbd2VqxTJm/tJZ/F1asWIFPtxBlF4rPoLB88cle0r89r7/+Om7dIdagB0W9xqN4fIf1Usrw300mQZ3hhDNv3jyydZ3xlk2hYXL/rFlHHLt+/XrClsXpgSAxXT8oYXg0kskk98+axYA+fY5quPjLL7+wZcuWIyaNtm3bxo033sikSZOOWpl3//33U8+2eTYQQhUEqnu9qOkk8flaSu5j69atZIdC5CkK3rSEyAzHTxPDoHWTJhSZJj1th6jj8Pnnn9P/3HNpUqMGU+6+G8Pr5cVgmMcCQSxRxBBEzLTOsi6K1DQMInJK7qOlx0M5RWFzPItF4Qi6JBFSVR70B/g0Gidb09AUBStdkRwPBIhpGsMMk7iuM2/ePB5//HFOCQaxRalUNzvftHj++ef59ttv+fLLLwloGvc5flqrKn5dp5OqUSArfBaJEZIkKigKYUnCJ4gsWLCAKVOmYIgiC9Jtc3FJorUnVU3coG5deqariMdbNgExpXG9IBShjsuNKoqlxo0xSaKVx0sjt4cNsQRXGSYF8ThhTaOLYeITRe73B3grFMEriKiCQK4oUtflJiJJqGLqtavvcmNrGoog0MztISJJdPX5OLNLF0pKSpgwbhxFZcpQqCi8HopwqtfHmT6VwvTrfKft50rDJC6lEs1RSaJfuppjjGlhyjIADWrWwiMIfJAO+PNlhdn+AIogMN3284ATIGSanNmpExPGjycRDBFOV7UvXLiQSy+6iAamyUjDRJUkZsyYcdBnb8eOHaVBfElJCRf07kN+NEr75s0J2zaVTRO/pnH99ddT27ZZEAwTk2XckkSlgoJSiY86FSsyyXZYFokR03Q++ugj1qxZg5N+H2c5fm6xHaoZBnPmzKHHqadyjmXzYLpq44CUzfCLL8bv82F5vUyaOJFnnnmG+++/nx9++IHLhwzB8nrRPR7Cpkk1vx/T46F7+uBmlGFx0fnnH/2L/jeyZMkSwmWKqTv6ZapePItgNH7Ua9asWYPj8TDV8dPFpxI3zdJN2g8//ED79u0RBIHevXsf0+b0n+Dnn3/mjTfeKNV2zJAhw9HJJKgz8XeGk8vu3buZNm0ad9555wnT5N2/fz/fffddqVTF8bBr1y7uuusubrvttsOuZ+/evUyZMoUbb7yRFStWcO+99x4iz3GAnTt3csVll1GnenW62g6b41nc6wRo4fHQzjC5/fbbD3vd+eecwwDLYm00TgPbZtbv9lgbNmxg3bp1TL75Zirm5dG5bVt6n3kmbS2bGywbze3mNCd1v/KKQiWXi9N9KvFAgA0bNjB58mSmT59+xIP+qy6/nHzTpK7j0KB6jUMSy41r1mSkZfNsMERQVVm7du0hc/z6669cP3o0ndu25aHZsw97nyVLlhDQdWr6A+RGo3z66ae8/PLLh53v98ydO5dTW7Tg8iFDjikO+/DDDwlpGteaFlUNg6uuuOKw4/bv38+sWbOYOHHiQVXtx0MymURJy7FsiiWIaFppbPbDDz/w8ssv88UXX/DVV1/RvVMnxqQTzhcZJhdccAExXWduIEQ/y6Zru3YHzf3kk0+SretcYZjENI1XXnnliOuoUVTEg/4AG2IJqtgO8+fP/1PP58BzGti3L4qYLhpSFBq4XIRkmSoFhUftHkwmkww6/3xUlwsnnZz/PTt27Pi3MBk/Xq6+ZgxujxdJllFVlWHDhtOpczdunHjTv4Xk378bS5YswQxGsQpq4w0kyC8od7KXlOEkkElQZzjhjLrySi5NJyCvMy0G9Onzh+M3btzIrFmzjvv0duZ991HONLnOtIjrOq+++uphx7355pv4dR3b66Vzu3Z/+Qfhrrvu4lTbYVMswVDDpHG9eoRMkwJFoaXbg6UoOJpGvSpVmDp1Ki1atKBZuop1ku0Q13WeSlcytAoGS3WpIZUoNzweVkXjLI/E8AgClU2T1s2aUbdyZcqmX9dXQ2HiloXtdhOSJHqpKsUuN4MuuICwpjHdCbAqGifq9TFt2jS6d+rExRddxJBBgxiZrrS9yrQYMmgQGzduJGikXLI7eb109vlQZYWwqmL5fDz80EM8/fTT1K1cmeKCAnwuF1paC7tIlonLMptiCRaGImiSxNQpUzBkGZ8gEE4nr01RpJnHw0P+IDk+lSy3m+eDYdp5feRKMqYoMkw3sCUJb/q6Gi43cUnCSFcre4WUJl+T+vUZlzbC09MVylr6EKC52035tLZzJUVhQShCL5+KKYp086mlkiATLJtabjcX9OvHbZMnU8nro4Hbzem+VIX1OMvGFEXquNxYosiGWIKV0RiyIHCOTyXgdlOgKDwdCFHX7aa4bKpCoFH1GpRXFM7yqVxtmAQkiXmBEIogUEVOybhELIv58+fz+eefs2fPHt5//32+/fZbfvrpJybdcguaLFPH5eZa08JRVb755hu++uorYqaJSxAwXG7eeecdGtWtS76iMD8U4XTdoHblymSrKk1tm+xgkM5p1+wxpkWPTp0OOpx5//33KRtPoHk8nNWtG4888ggbN25EFgQGajr5kkwXnw/T66Vpw4bkOA5z05/ZRoEAzz33HN9++23pZ3VpOIpLkgjmVSCYW552HU/F9npZFY0zUNPp5lPZHM/iGtPGUBTqGCaOz8fSpUuB1In5BQMvZOrUaUfdNK5bt44HHnigNEn+V9i+fTuhaJx4vc6EytWk5zm9j3rNCy+8QMO0MdAzwRBVfteKWFJSwpgxYxAEgerVq59wGZPj5YcffiA3v4BIfiV0y+Hll18+qevJkOE/hUyCOhN/Zzi5dGzZkma2TXvbpnalSn8qqXwi2Lt3L6Muv5xW9euXSvAdYM2aNaxYseKgGOvbb78lEQzS2R8gzzC49pprDkn49uzShVMtm/6ajiVJ3G471Hd7uFDTaWrbTJs27bBr2bx5MzXKV0CWJLq2b3/QvDdcdx1+n4+gqnJ5umMOUkU6V48cSa+uXXniiSeIBwI0dxx8oshpmkbc7WHMNdewZ88evv766z/sAAsaBu+Eo2yMJShjmodoIRfE47yQ7tqsYNssXrz4kDmuHz2aBpbNnbafLP3ImsNff/01b7755nEdTixbtoyornO346etZTNk4MDDjtu4cSMvv/wy33//Pffeey9npA0hZ/oDtG3Y8JjvdziO9jnt2r49jWyb9rZDzeLiQ/alj86Zg6OqRHw+DFmmcyBIQE8Vk0yfNo3qhYV0btv2sBrYzz33HMMvvfSosd5zzz2Ho6rkGAatGzU65s7Dw/Huu++SaxisiMSYYDvkRyJU8/p4KRimqWUxccKEY5pnx44dh01mT5w4EcXtxeVVObv3ef+RHYqbN2+msLAQQRDwV2xKIK+YCTfd/LfcK5lM8uijjzJhwoSTvgc5XpLJJIOHXIqsuIhl5fDhhx+e7CVlOAlkEtQZTgjJZJI5c+Zw+bBh3HHHHYQ1jUvSVbpHq27+Ldu2baNz27aUz85m7Jgxh/wILVq0iLlz5/Lzzz/Tt2dPbkgn4S42zCM6KjeoWo27HT/rYgkq2fYfnigfidWrVzNjxgxWrlzJjz/+SJXCQrINg4hts3LlSorz8mjt8aYSqqKII0rUc3uwPB462zbZskIFrxdDktAVhTa6wc2WQ/A35nwHGH7xxTgeDz5RJOTx0KR2bfbs2VNayXyvE6CfZdO8bl1CqsoTgSAdvT6yIxHuuusuChUFWxRTMhSSxBtvvEG9ypUpzs1lxIgR5Og615oWeYbBww8/zPbt21m9ejXdu3dHl2U6qRo+UeSZYIhng6G0ZIMPTZSo6/VSw+WmnddLLbcHQxAwRZEiRaFDWtPY8ngIixL13W6qKgq6KGKlpSw2x7Po6fhp2qgRtiyX6ktnyTKmJJEIBunuU7lEN/AIAoogpEwmIhHOOOMMbrrpJmyvlwqyQjefj3xZ4fNYgvGmRaGsUCutzR2SJDp6U6Z+56kajiixOZ7Fp9E4siAQkWUihsFHH31E8wYNOE/VmO0P4EvLtqiiSBuPlzttB0cUqaC4KKtqdOnYkeGXXsqcOXPo06sXfsWFVxDJj8X4/PPPefPNN9HdbvySVJo8VwSBqCThlyRauj2pZLWmE1C10u/GE088gZF+zw1B4BEnwNponFzDYOXKlbRq1oxyisIXsQQ3WQ4VcnIw3W66pRPqEyybgNvDonTlebFlkxUKUcG2CZkm77//PpA6mW5YvTpNa9Vi+fLl9D7jDKrZNo0cPxULCvCKIgFJoows4xYEbEmij6pR2+XGL8s0DwQozM5mx44dbN++HcPjYX4owmOBIG5RpNao56g96jnkdIvk4nCUQZpBscvFm+FUwKpLEgFJwpRlJowbx7Jly9DtADmtLyCQU3RIwPbbDdPq1asxnQBZ1Vtg2IG/VPFxgC+//JIrrxzFyJEjD9GTPBw//vgjZWIx2vsDlDFMbknrff+eefPmYVkWfr//pCaF77//fuKVG1N39MuU7XIFTVu2OWlrORIfffQRt91222H1uzNkOFlkEtSZ+DvDyWP//v1Iosi6tOZzwOcrNdD7pxk1YgRVPR4qKyl/lnPPPhuA8ddeS1jVyNYN+px5Zume5YknnqBVOuH5eCCII8vkx+MHmQaWz87mlVCYzfEsyukG9atUJSsQQBQETm3VqtTs+kj8fn/066+/4lEUPojEWBWNo7vd/PDDD4e9duvWrQwePJhT0prHD/uD1Cpfnoht43i9tGrY8Ij3r1OpEsMsm3udAI6qHRI3TZ0yhbCmUdG2aVK79mETn53btuUOO3XvcxyH22677bD3Wrp0KWViMUyf7yB96j/igQceoFO6iOABf4DmtWsfMubtt98moOs0DASJBwK8/vrrBHSdwYZJedPk1ltuOaZ7/Z7vv/+eBtWrI4kirRo2PGJH7t69e7nvvvu46667Dpt8L87NZW4gxIZYgnzdYNSoUX+LzME333zDJ5988pcLt9544w2K03Is9/sD5AQCXJQuhhphWlx8hEOCY+Hrr79GcfsoPm8ytUY+g0e3S32t/tMYN24cPn88rUtdkU5duv4t97nq6tEEssuRqHsqTjB8Qs08/yn+Ew8hMpw4MgnqDCeEqVOmUGiYDDdMgprGtGnTGD169HEng/v16kUvy+blUJgC0zzo+nHXXksZ06Sx30+1ovI8+OCD5OgGlxomYU07ollFszp1mGA7/Csap9C0Djqp/+mnn0qDp19++eWQP21q3PoAAQAASURBVIgfffQR06dPx6+qdE/rgr399tvs27ePzz77jJ07dwKplrZ2Xh9eQWB1NM6HkVS1bTWPl83xLF4IhrFkmasMk6cCIXRF4bTWrUurvjdt2sQzzzxT2ub15Zdfsnz5cj788EPeeecdWjVoQNtGjbjjjjtoXqcOZ3XuzNatW5l8880EDIOinByWL1/O1VddxfmazsZYgqGajqW4KJtIMMGyeTwQxPapzJgxgwv79uOSwYPRPR40t5urR4ygfatWjE63kl2sG/RWNW63HXRRZLLlYIkiG2MJvoglkAWBqrqOIYoM1HQe8gdRRZGrDANVFBlv2bT1eAmKqcRsTd3AkCQ6+FMSF83r18eWZVRBYEEowvpYgoAkYbndvJoO2HNlGZ8oUtvjJUuWOd0w8IkiWWKqyloVhNKk7UTLprbLjSmK6ILAWNMkIklYaePBoCQxWNPp7POhiSKWz8e4ceOwfT5UUUxpaadlVDySRO2qVXFJErrbTW40Spl4nJZNmvDaa6+VGtKMGTOGal4f62IJLrdsalWsyBNPPMGqVau48MILKaPr3GhatHB72BzP4mbLISpJFKUlWaY7AZrVSgXOZaJRng6E+CwaxxElbFFEF0Ua1KjBpRddhCKKlEkn428wbcrn5JTqhldzufCJIrqi0M80udP249c0Pv/8c5YvX862bduAVEAcTD8+yXaI+v3Iosin0TgbYwlMSeKxQJAvYwmy3W48sowlimyKJdgQSyAKArbPh6NppS2ZD9x/PwHDIOb3o1s2ZTpcTF67iwjHEtx1xx1oHg8Bw+C0U04hOxjEJ8u8GY7wRSxBSJIwvF7uvPNOsuueSt3RL5Pd+nyKK1dlyZIlfPHFF3zwwQcEDQPT5aJe1aqMGTOGRP0u1B39MnntBnFmz7/u5L5t2zaK8/Mpa1kHJfN/y6+//srYcePpekZPnn/+eb777jvuv/9+Xn/99dIxGzZsYMKECaWu5ZAyPqpcuTKiKDJu3LiTUv318ssv48TzqDxgCvE6Hel1bp9/fA1/xLJly9Ath6y6nTCc4B+a+mTI8E+SSVBn4u8MKbZv314a7/6TVCsqor9lM8yyyYlE/lKV51+hXuUqVFJcDNUNng2GMGWZlStX4nO5WBaJsTaWwHK76dSqFXfefjsrV64kpGnc7fjp4PVxpqrS/zdG1QBXXHopVS2LXpZNIhgsjdX+bJxQUlKCo2k8FgjyfDCM4fX+ofHzhx9+SETXudP2c4plUxCPc4PlsCGWoIHj8Oijjx72unXr1nFqq1Y0rlHjiIfv//rXv1i0aNER369HHn6YhK5ztuMQ0HX+9a9/HXZc5bJlucP28244SljT+PTTT4/yKqQqVSO2TQ/HT45uMC2t0f1bzu7WjbHpAqdets3NN9/MBx98wNVXX82jjz7K999/zzVXXcWoK67gm2++Oeo9D3DF8OGcZVm8EgyTUBTKhMN/KqZpWK0a11k2i8IRor+R1fu72LNnD8uWLfvTicz9+/dzetu2hFQVR1WZPn06IdOkSTBV+f1XqmBfe+01vF6VwjPGUP3Sh1E8h5eN+U/go48+QjMdjKwiBEGgfPnyx1QYc7yUq1iF4vMmU3f0y8SL6/Hss8+e8HtkyPB3kklQZzghdGvfvvQ0vK/jZ9KkSYcdl0wmWbRoEW+88QYlJSX8+OOPPPHEEyxfvhyAUxo35q70PO39gYO01XLDYV5LaxpXdBwWL17MvHnzGHXllSxcuPCw97v5xhvJCYUw3W4USeKifv1IJpMkk0ku6tcPX1rvqlJhIS5Zpmq5cqU/0OOuvZaYppPj8VAkyywJRbhMN7jkwgsPuU/McXgjFMEQRZ4NhpgTCOISBGyvl8m2Q1fLxpQV3g5HWRtLEFZVvvjiCwBWrlxJ0DBoFQwR0HU++OCD0nn37dtH2La52XK4wXLICoWOeKo4b948alWsiCbLVFBSScs2TZtiqypLwlG+jCVKK9qvu+46DEkiLElckZZbUN1ucmWZawyLnLT2siaKWKLIXH+QqCRxlWEyRDcwZJnze/fGEEVeCobZFEtQRpYpL8tUcblKZUhMSWKGk6pkqGfZDBgwgNxgkPM0jZn+AJooMsIwmBcM4xNFChSFhCzTLq3r3UfTqKi4mOH4ucfxU0lx0did0t2+xbJp7/XhSkuA6IKAJknkRCIookhcFDnfpyIKAi8GQ7T1eLFEkWXhKHfZfsKqSlefj15pTeSxlk3Q5yvVC9yzZw/r1q0joGncZfs5U9UIuVwkgkFeeuklVJeLOi4XG2IJrjZMClxuCnQDv6rS0u9HF0XaebzkywpvhaP0VFXikkRYlHgxGOY8y6Znly4AFGXnMNMf4INIDDutwX2ubnB+377ENI2VkRhN3B5kQUCTZd58802mTplC0DTxiiLXmRZ3234sl4u2jRqVPoffbnR++OEHdLebz2MJPovGccky5fPyGG7ZTLBsLFlmomWzNBwlpmnEAwHiskwXn0objxdP2mzz1VAY3eM5ZOPzwQcf0KRFa5q3alva8nngu3aA/FiMO2w/LwTD6KJIXjRK7zPPwlIUjEg+qiTRQdfxiiJ+r5cs22GsabEhlqCay03Pnj3xJ/Ip6jmOcGENxt9w42G/C8fDAcmezfEsrrVszjz99EPGXHHlVYQKqlOm4xAMJ1j69+oA27ZtIxiJEa/TkWBuBYZcelnpYzt37qRnz54IgkCnTp3+tKnOnyWZTHLNmGtJ5ObTpl1Hvvvuu0PW3qlzNwqLKzN58m3/6NoARo8eTaLRGdQd/TK5p1zE2b3PO+jxvXv3ZnT6MpwUMgnqTPydAcaOHo3mdqN7PMw6RtO7E8VXX33FwPPOo2/Pnic1KTV0yBBMUeSpQIhNsQRFHg+vvfYaWaEQUx0/TwdCeESRGyybiqbFvdOm8cwzz1A5P59Ct5uPIjG6WzajfqNtXFJSwpw5c7jlllsOqqz+I0pKSliwYAELFiw4bCL7pZdeIjsUIub4eewICebf8vTTT9OpZUuGX3IJp7dpw0jLZm00TnXbPkh+8O9g4cKF3HbbbYckp7///ns6tmxFmUiEoKbzdCDIF7EEuYZx0P7oACUlJXz77bcHxQkbNmxgypQpLFiwgLvvvJOysRiNa9Ys3XeNHD6cDuliqKqWxSOPPHLQnHUqV6aHZXG2aVGpbNljPjQYOmgQAyyLIkVhjGnxgD+Araqlhw/HyqpVq6hWrhwR2+bmG/96nPtH/PTTT1QtV0R528avaSxYsOBPzZNMJlm/fn1pRfiWLVt48cUX/7RW9wG+//57/LqO1+VBlGTq1an7l+Y72Xz00UfcfPPNXHXVVXg8HvLy8k74AUTvvucTKW5AbruL0C2n9HOfIcN/CpkEdYYTwp23306xaXK1aRHWNN55553Djrvg3HMpNC2KLIsep51G2USCFoEAMU1n5n338dJLLxHQNGr7AxRkZR30o96yfn0GWjYznAB+VWXjxo1/uKa3336bHMPg5VCYAZZNtw4dSh9bvnw5OYbBp9E4s/wBQrLM+mic3qZJ88aNObdHDwyPh3fDUdZE4xhp6QOfKHLFYcwzBvTpQ03DpLY7ZfKnixLdu3Rh/vz5dG7blksGDGDC+PEpuQy3m4r5ZVmxYgUAI4YP55J0K9TlhnlQAnzbtm3objfrYgnWxhK4ZPmwbXcbN27Er6rMcAKcZ5hUKFuWl156iZKSEm64/npimkaRZdG4Vi0CqkqW4uIaI2VMGJQkNFdK1qJBWp7CIwjEPB56qRqN3R58aQNCUxQpVhTaNG7M2rVrsdxuYpJMJcVFXJIpklLa0118KgWygi+d5J5o2cR0nQv798cvybycrpIuKyuogoAmCAzSdTbFEhTKMmXT1dUxSaKKy4UmirT0ePGJIuXllJxIfXfKqC7scqMrCi8Ew7wZjhDQdW644QY8abMOy+XCkmW0tJTI2micux0/EU2jmU+lkuLilVCY9obJyOHDD3pd33jjDWr6/aUJ93xZobrbgy8t3aGJIj5BwCeKvB6KMEjXaZuW3bjH8RNwuVKV4Wnpjohp4bg9hHwq7Zs359tvv2X79u1Mnz6dsGXhkiSK3W5WR+O0t2wuvfTSVPVENM7D/iC54XCpPtvPP//MlClT8CkKrwfDLAlH8LncJJNJtm3bVtpm2LxevdKq77M6d6aibVNkWZx/zjl88cUXdO/YkY4tWvDII49QlJOD5fMxdswYvvjiC3p1706tatW4/PLL8SoKyyMxPorE0NxuduzYwb59+w6pkHnzzTepXq4c1cuVO0RXcOnSpeSFw+iyTJlolMEXXkhjy+LRQJCQLJe6j1+k6QzWDQxZ4XLDYm0sQXm3l7POOouJN91MnQZNuGz45Sekmuqhhx6ilm3zfiTGuZbNhX37HjKmUbNWlDtjDHVHv0xWrbZMnz79oMfnz59PrFx16o5+mcoDppBT5v9dy+c+/jiOpuFzu5FlmcLCwr+9GuZ4OOvsc4nVakdxn0nY4cQRO1H+Lp5++mnsaA4FXUYSyK3A7XfcWfrYVdeMQXG50QyLl1566R9dV4YMmQR1Jv7+X+fbb7/F9HhYEYmxMBTB8HpPeOv10qVLObtbN4YPGXLCjBBPNPv27aMoPx9NFCnrclG1qIjdu3ezePFiKpYpQ1jXae/1HeK98/PPP9O6USNkSaJxrVpHlNz45ZdfuOuuu5g0adIRxwCc26MH5S2L8pZF7zPOOKHP8bPPPqNcTg6yJNGra9eTdjB8wTnn0MuyeT0UocCn4nO58Hu9nHn66Yd89n788UdqVKiA5fVSkJV1yL7wk08+IaJpvBgMM8KyaV63HpAqHDi3Rw+Kc3MZOWzYQQno3bt3o0gSG9PSMqbHc8jB/pHYsGED+fE4bkHkvUiUDenCoGOp/D4aX3/9Nd06dKBB1ao88cQTJJNJNm3a9Iefl2Ph4Ycfprnfz6ZYgjttP23+ov7238G6deu49tprmT59+kGfyz179vDkk0/y0ksv8eWXX7J06dKT1mXxZ1i6dCnRaBTDMHj++edP2Ly//PILo666mu5n9mLRokUnbN4MGf4pMgnqDCeEZDLJfffdx8UDBx5RF3b37t24ZZnPonHeDkdxyzLN0sm/R/xB6lWqDKR+iH4rpXCAr776iu4dOtCkZk3mzZt31DU98cQTNPYH2BRLMMsfoGG1aqWPffDBB2TrBv+KxrnPCaCLIi5BQBcEij0eJlg2hiQxwbIZohtUc7nYmNb/bde06SH32r9/Pw888AAXXngh55xxBnfcfvthg7tuHTvS0jQZYVoEDYOtW7dyzz33UMeyeDYYoqFlMXnSJJLJJFu2bGHXrl10adeOarZNJcumef36lInFqJifz9tvv1067+LFi6nopIwbF4Qi5IbDB933448/ZvHixQzs25erTYtcWebJtL5ZjizToG5d6qeT5I8FguQ4Drfeeium202uJDHT8fNBJEYrj5ceqkan1q1JJpNc2LcvXlmmUFFYG43zbDCEJghUdrmY4vgZY5hUVFzkRaI8/NBD9O/dO63VLVPb5SYgSWiKC0MQqOVyMc608YliqbxHyOMhaJoM0PW0yZ6Flj4oiHo8RHw+bkhLdTwXDHGr7eATBGKWxT22w7pYgmLLYtasWbRs0IDKbjfudHK5cePGNK5dm7Cuk7BszunW/ZAW1mXLlhHUNJr5fGTJMp28PixRxBRTwecD/gCGKKJKEv00jZiiEEpLZXTw+jAkibgkM9ayOVfVqO5ysygcoY1lM/a661LBs21T3rbJi0ZZs2YNbRs3RnW7ad+8BTt37uTKYcPwpI03D0jC7N27lxoVKlDftlHThwc+QShtHx11xRX0SOvBnWpZtG3VigpZWbRt3pznnnuO119//Zg3mfv27WPE0KEUxONoioLl9XLtVVcxbcoUfC4XqtvNfemE7f79+/EbBvc6gdRBkq4f4vD+W/r27Mn1ZqrNsr7HSw1V5QF/gEJFYbRp4nW50RQ3kiBieNRj+t4fKw/Nnk2V/LK0rF+fHqefjqNpNK9b97DtdnfedRdONIdE/c4Ytv+QSq7Nmzdj2H5y2w4kWrkJ3c/oCaSkQQyvlxeCYV4JhfG5XESjUVRVZc6cOSfsufwV6jZsSmGP0alWwEqNeOihh/7xNUydNo1TOp7GjRNvKt0orlu3Ds3yU2PYo5Q/ZyLRRPY/vq4M/9tkEtSZ+Pt/ne+//x7D42FpOMqLwTC2qp7QBPWWLVsI6DrXmRadf1dIciS+++47urZvT7WCAu6+886jjj8R/PDDD5x5+umUz8vjksGDDykUWbJkCUFN43zLJqyqdO7QgbO7dWPZsmXA0fVUO7ZsSQvL5nTLpmq5cofdP/z88894FYW1sQRro3G8inJE2ZXvvvuOF198kfXr1x/3cz2WxPSOHTt4/fXXj7ny+wC//vorzz33HM8///wR73Nqi5bcmu5qq+1yo7tcZOk6VQoLD+lAmzhxIp0ti02xBAOsQ7WO33jjDSqnTe2fCoSomJd3TOusW6UK3SyLXpZF5YKC0rhk69atTJ06lRdffPGI7+m+ffsYctFF5BgGlW2bU5o2PSHybqc0acIAK1WVHVBVunXqhN/nw/L6jqla/ki8/PLLFFkWb4ejDLAszurc+Q/HL1y4kDvvvPOky2yUlJTQvF496joOWT4fhqJQZNk0rlXrsEaL/65s2rSJ6tWrI4oik9L7/wwZ/tfJJKgz/Gn27dvHli1bjvmHt6SkhIjjcKrXh5HWBg643TzsD9LrN3IHx8rmzZu55MILGXLRRXz11Ve8++67PP744/z4449AylAxPxajqu0QULWD2tWSySSXDBiAR1HwiCLjLIsl4SheQeCGdMKsk2FSEIthKAoFisLqaJzLDPOYAugjURCPsyAUYXM8iwJdp33z5syYPp1hF19MjXLlGDJwIL/88guntW2L7fUSMAwWLlzIvHnzmDlzZkqT2e3GEkUsTSOZTLJ///5UlbSuU6hplDFMxl177WHvf9edd1LdtChWFIy0rnG+onD++ecT0TRm+4OcoarokoTl9qC7XERNk7jXS7u0eWLEcQ6qAH377bfxSRIjDZO6bjdBUaSyy8Vb4SidfT4K3W7GXX89JSUlvPfeewR0nYTXi6W4sQtqk92iD6rLg1sQ8IoiZ/hUNsezuMIwCXi9GB4PBYrC3ECIhqbJTRMmsGXLFt555x1++eUXIJVsNCSJbEkmJsl4BIF8WWF5OEqBabJo0SJWrFhB2exsDFmhmstNM48XQ5aZP38+7Zs1R3O7KRMM0r1TJ9avX8/OnTuJOg5DDJM6Xh9BTUdzu2nl8RKRJNZEU07lmihSvqgIVZLo61ORBYFKiouzfCpeQcAlCCyPxLhEN+irpeRELjctBvfvT//evbkiXTXcy7K48QitfLt37z4omH///fcptCwGazpBSeICTeccVSPL7wdg+NChnG+mgvZGPpWwJPOAP0BDt4fccOSYAqCff/6Ze+65h66dO9PIsnjEH6RQ15kwYQK7du1Cc7t5OxzlzXAEjyxTq0IFzjvrLNyyzJponE+jcXwuFz///DPJZPKwVQ0LFy4koGl0SOvUXXTBBdStWJGQYeCoGldfeSXde/SgcbOWzJw566hrPlbWrVtHQFWZGwgxwrJpfAy/Gc899xwTJkxg1apVh3383Xff5cyzz2XEyCtLN4179uzB63KxPBJjRSSG6nKxdu1aGjZsiCAIXHrppSe92uOJJ55AtwPEimqSlVvmuFtR/y7Wrl2LbgeoeflcivtMQrf8nHV2b1588cWTvbQM/yNkEtSZ+DsD3D55Ml6XC8PrZe7jj5/QuRctWkRNf0oGbmEoQplI5KjXnNW5M70tm6cCIRK6zrvvvntC13Q4+px5JmdZNnMDIUI+H+2bN2fk8OEHJYiXLVvGxIkTaVSzJj0sm2vThShHq75NJpPIksTn6YrdiKaV+tH8lv379xOyLG6zHW6zHcK2fdgk7/r164n5/TROx1W/LWY5EXzzzTeUicWo5Q8Q0PUjSiz+nmQySedTTqG67VDFtunV9fAGcQ8++CA+UaSqy0VAlBhtpGLZDo7DlClTDho7adIk2ls2G2IJ+lgWlw4efNDje/fupVHNmhTbNkFV5YH77z+mtf7www+MueYarh41qrRoYdu2beREInR2/BSYJjeOHfuHc7z77rvMnz+/tEjjyy+/5IUXXjjmauzfUy6RKJVUrGJZhHy+0sKgvGP43hxgy5YtLFq0qDTZn0wmGTlsGDHHoXndunz99ddHvPbBBx4gSzfo6fcTNIy/xbjxWFm3bh1RTWNDLEEFReGxQJBNsQRVHadU5vA/hZ07d9K1a1cEQaBv377/UQn2DBn+DjIJ6gx/irVr15ITieB4vdStUuWQaucj8fbbb6OIIh9EYnwcieGRZepWrEivrl2POTHyySef0OfMMwkbBv1Ni36WTcy2CSsK2bKMJklUyMvDkWUq6jpRv/+wumUAu3btwqcoLApHWBmNo4siAVFkoGkR0DQ++ugjdu7cSfP6DXBJEpXKlj1mLadvv/2W9evXH5QMvLBvX+pZFq19KhFZZoJlk+vx0KNbN3bv3g3Aiy++SBU7Vf16p+2nSY3U53n8+PF0SSdvJ1g2mijx+eefkxUIIAkCRbJC3ONh3LhxR1zT7t27ObVDB0K2TaHHwxjTopxh8Pjjj/PA/fcTdLup7nJxmtfHUN1gYyxBG9thyJAh3HvvvaxevfqggPitt97irM6d6XLaaVQvLsbweKjtdqOl5S90UaRR7doUJBIoksQ5PXrw8MMPc+GFF6J4fFQdPJO6o18mFMxCFwS8gkBVl4t3w1Haeb2c5vVRU3Ghp40OTZeLTZs2ce+99zJr1qzSH/FkMklI02jl9jBYS0mFtPB4kUSRwRdcwN69eynMyaGbbiAKAmvTGwFHlKhSrhxtDQNbFLnFdjjDp2IrLp588knyzFRV+cpoHN3jYe3atfhVjSJFwZc2VXQJAl10o9SUsXPaeLG6oqBLEl06diTm9VJW0zFcLmoFUkaRK1eu5Iphw+hq2SyLxKjhduN1uUqrkX/Pd999V6qP/s033+BXNVqnZU82xRJsjCVQRJHdu3ezefNmCrKyUoYlpknX9OfmNjtldnm0VrKSkhLqVa1KW9sh2+0uNZPpp+l4FYWzu3XD53KxNBxlcTiKIgg84g/Q0bKpWVxMrmFQxjQZ0KcPn3zyCbnRKIok0fuMMw450Fq9ejWPPPLIIZU+H3zwAQFdp1MwROAPZIMOt/YVK1YcdoN3gHfeeYfyls2mWIJXQuFj2hT/WSaOH4/p9WJ5vYwdPRpIbZouvvhiBEGgSZMm/4jD9quvvsqQQYOYM2fOIQcU//rXv3j++ef/cX3sozH0smG4PT5cHi9GOIe8doPQ7QBLly492UvL8D9AJkGdib8zpPj111//FsmHHTt2kBOJcKZtU92yGHoYj5ff07BqVR5IJ7Wb+wM8foKT5oejac2azPQHWBqOooki4yybjpbNud17HDI25jgsCUfZHM+iouMc0+9V3cqV6W3ZDDUtsn8j5fZ73n33XRrXqEHjGjWOOO/EiRM5Jx2zjbVsLMXFqa1a/eE+be7cuVw+bNhRk83Lli1j4MCBdHacUvPvLqe0O+rzg4MlCz9PSxYe2Pf8li1btmB6vdxs2TR0uzlX01gZjVHHtpmdNug+wM8//0zzevWQJYnq5csfNpbat28fixcv/svJ1Oeff57GgSCb41k8GwxRpWxZILWP/G1M9c4771A2Hsev69x1++1A6iAmoGk0DgSJBwJHlag8HLdMnEi2YdDIH6BCXh5Bn4/3IlGmOX4q5OYe0xwHioRq+QNkh8PHrQ/dsXlz7nFSnc9n+gOHHBj8k/z8888EDIPbbIdCReFyw+TVUJhYeu9+NPbs2cP777//t5gU/hlKSkq4+uqrS/cFf/YgI0OG/wYyCeoMf4q+PXsyLJ3gaWfb3HXXXX84fvHixTz11FPs2LED0+fj2WCIF9Mu0weqYI+Fn3/+mYhtM9RImcMdSMzJgsA7aSNAUxS5QNN5yB8kIEnUt20ee+yxI87Z5fTT8QgCHkEgKIpkhUJcf/31pUnt3xu9/Z4PPviAji1acGrLltx88828+uqrzJg+HcvrJaiq9Dv7bCbceCNXDB/OZ599xo033kjItrk8LalxjWlRxu2meaNGdG3XjmrFxeS43ayJxhlv2bSsXx+Axx9/nEKPlxeDYdp6vdSpXJnzzzmHCw2TS3QDPZ0QbvYH+mHn9uhBY8viHNMiqOu0rFeP29ItRU899RQRl4urDJMzfSoDNZ31sQTNbYdp06aVzvHdd9+xZMkSVq9ejen10tLjIa4oOG431cuXx/J6eToQZH0sQTnLonHNmlxj2ayJxsmRZVyCQH23B4/bixYrJFyjHbLixhFF/OnnoIkiIUmirsuFJgjookhMkjFEkSqFhTQzDOqbJqe1acPixYsJ+nylmtC91NSJenNdZ8SIEZSJxUqTybqYksM4X9O50jAxRJHiggK6qRrlFYXN8SwWhVO63F3btaN8Xh7dLJvGtk29qlVpVK0aPU47jUQoxBW6wZ22Qx23h83xLE7xeLkmXQ09VDdwCwID+/blutGjaVyrFiMuv5xvvvmGRYsWlQZE27dvp33z5nhFkUZuNw84fnS3+5BE4W233ILp8WB6vIwZNQqAG2+8kbAsY4oi7b1e2ni9NKhevfSaX3/9lc2bN/POO+/gFUXaeVMmkWFFYerUqUf8jEBKTifg87EplmC2P4gqirTweLHTppjZmsbll12G6nbjlWVqqakE+B22n47Nm7N06VKWLl1KMpmkfdOmXGc5rI3GqWTZx+xoPmL4cIakvyMjDfOQ1s3DsX//fk5t1Yo8w8SvqsyaOfOw4/bt20ejmjWp6jjENJ07br31mNb0Z9m6dStbtmw55N9nz56Nz+cjHo8fcwL+z7Bo0SIimsYow6LAMJn5Dxtd/RV27NhBs1ZtKeh2VUoDvE577r777pO9rAz/A2QS1Jn4O8Pfz1dffcWkSZN46KGHjqkj85FHHiGsaTTwByjKzf1HDlYfffRRwppGJcOgitvN5ngWL4fCFB8mMXhh377UtGy62w758fgRZTh+yzfffMMlF17IgD59jphI3bdv3zF1vz3yyCNUsSxeDIZp6fHST9M5zbK5euTIw46fNXMm+YbB5YZJSNNYsmTJYcfdesstJHSdcrpOGZeL+aEIPSybwf37H3VNB9YfcRwmWjbjLPsPTd9nzZxJVjBIYVYW1YqK0D0ezunRg3umTKHvWWcdcihxLBWn+/btO6bP19q1a2lWty6VypTh4d9Inn322WcENY3b08b3Pbt0ofMpp+CWZXLTEn0ARTk5THH8LApH8Pt8bNiwgbNOP50b04cGvWyHSZMmHXUdv2fjxo3UqVSJmG1z/ejRTBg3DtXtJisUOuYq+d49epR6vfSybG6++ebjWsNVI0bQxLK52/ET1/UT6lmyceNGZsyYweLFi4/5mrfffpuW9erRsmFDahUXkxsOc+sttxz1uh07dlC5oJAi28avndjn8Vd5+OGH8Xg8lClThk8++eRkLydDhpNCJkGd4U8xoE8fBlgWX8YSNLPtgxKYv2fi+PHkGAYN/X6qly/P448/TsS2CZomjx6nDuvq1avJM81UG4/LRVuvl46WjeVyMcGySzWBX0i3QVVUUuYay5cvP+Kc33zzDfmJBGFVJWCapUEGpLS5gqaJ6nZz++TJKWmQiy+mfpUqjL3uOnbv3k3EcbjBcrjStLAkibKGgenxMD8U4bNoHFtRaGWaDDBMTLebLL+fjj4VRxQZqOmEJImhuoEhSUyyHRq6PeTIMpIg4Ph8pRUDyWSSUZdfTkEsRoeWLfnpp58476yzuNgw8QoiH6cN7DyyzE8//cR7773Hl19+edBzDVsW70VSlR3FjnPQ6zJ16lQaGAY5sowiCBiyjCJJtG3SpLTK4YMPPiBoGFT1+7E1jYAkUSQr9FY1Xg6FiUsy8bRW84JQhLCm0ahadW61HdbHElRxuajjSgX3t1oOliAQEEVEQWBlNM6/IjFEQeCzaJz1sQSqKGIKAk8EQmyMJciVU/IdG2MJ1sUSSIJA2LLo6lPZFEvQxaeiKgqyKNKkTh3qVKzIlaaFLYqsjMZ5NRTGIwjkyTIBUcRRFGbOnEksEECTJFp6vJRXFGp6PNStWhVH00j4/fTu3ZuEpvGQP8hplk2VggLaWTbDdQNVFJmUPsEvVBTudQIUKQpC+jWsktbjDsky5/bqVRqQl5SUMPWeexjUvz8uScJMJ+V1Sebbb7/lq6++YunSpezatQtvulr5o0gM3e3mxx9/5IsvviCgadxgWlTyeKlaXMxPP/1ESUkJ27dvPyjwHz9+PF5JIurxkBOO8M033wCwcuVKLjr/fK695hp27dpVOn7v3r1khUKMtGwutGxiwSA+WWGsafFBJIajKKxatYqdO3eydu1aYn4/DRwHxe1FlCQ6d+tR2tbYumFDbrEdvowlqOk4PPvss8f0Xb/vvvuoZlrMCQSpbVnceccdR71m2bJl5Jsm62MJng+GyQ4Gjzh2z549vPbaa8dUafF3smLFCvLz83G5XEyZMuVv0Z8bN24cF6Y3JTdZDud0737C7/F3cveUKTjRHOINumNY/iPKrGTIcCLJJKgz8XeGfx++//57nn76aVatWsWqVat44YUXjlgV/NZbbzF+/HjeeuutE3b/lStXMnv2bGJ+P71smyqWxchhww4Zt3//fmbPns2tt95aGmv9FX799VfOPO10ZEmiICuLzz777A/HJ5NJrhw+nCzHoYLLzdponKFpWbnfckA6rmfnzkxKaz4PsCxuuOGGw85bLpHgxWCYjdE4ca+XnGCQru3bl8oqHgvLly+ndcOGtGvShI8//viYrwOYfu+9VDBNbrRssnT9uIyTx44Zg0dRsFX1qEUS9atW5cq0nItfVQ/q7nvppZc4tUULBl/Qn1mzZlEn7XVzlWXTrX17AOJ+P6+EwnyeNkhcvXo1V1x2GR0tm+eDYSpa1p+q+j+9TRsutmzmhyLkGEZpUcO3337LPffcw9NPP33U+HHEpZdymmXzRihCDcviwQcfPK41bN++nepFRdhuNy0aNjxhUhQbN24kYtt09geI6zqzj3Ndx8v9999PGydlDDnZdujYosXfer/j5d133y01TzzWop4MGf6byCSoM/wpNm/eTJXCQiRRpEOLFodt0zpAfjTKq6FUwriy4/ylgHHPnj3kxmIUeTyU8XqpVqkSt9xyC2+//Tb54TCGKGH5fMRUlRo+Fb/Xy7SpU/nll1/48ssvD3H/HTduHCNGjODrr79mzZo1ByXpAOKBAI8FgrwbjmJ5vbRt2RJLFMmWZQKSxMWDBmF5vaxPt6xJgsCZPhWfKFJBUbjbdtBFkbgkc61pUVZW0lIWIka6UriBx0uRz0cbLWUEONsfpIHbQyVFoZLiwnC7D0qibd68mdtvv52nnnqKtWvXkhuJ4BYEngmGeDoQQnW5aFSzJgWWReB3mmudWrfmNMtiuGnh1zRmzJjB7t27Wb9+PdmhML50JbkkCNSrXv2Q16Nvz55cnU50Fbhc3GH7aeD2MMNJtVs29Xho7/Hi+HxEHYfbJ0/mnXfewVZVdFGkmstFIm0i2NrrJSCKaIKALYqUV5TSKudRusEttoOZfvxqw2RBKIIpivhEkZGGyWBNx3K58CoKZ6YT1N19Khf060eLhg1TyW1RZJLllJoaPhUIYbjd+DUNn+Kic/v2jB8/nueff55FixZRt0YN3IpC3LYxRJG3w1EmWDaFiQSd0i2l050ALevWZeSwYbRv3pwuXbrg93g43eOhjCQTEiVsUSQoSuRKMpPTgX8Pn4otSQS9XmpWrMjwoUOpalqMMizUdGXy57EEYbebqVOn4tc0Ktg21cuXx/D5mBcM83oogu7xsG7dOt5//32ee+45Tm3Zku6nnc7IkSO55557KBNLaR23atiQ3bt38+2331K7UiVEQaBy+fIsX76cZDLJd999R0DXGW6YtPD6aN248UHv9Zo1azinW3f6nX02U6ZMwckqRFctFFGiXH7Zg8Z+88031KrbgJwWfag96jlCZSoxd+5cINVSGLIsTI+HU1u1OmbN5ZKSEq675hoaV6/OVSNGHFN78dq1a3E8Hl4LRRhv2RiywurVq9m3bx+tmzTB8XioVVzxsNXMJ5MffviB9u3bIwgCvXv3Pq6ukmPhzTffJKJpjDRM8g3jiJXl/848/fTTXH/99Xz44YcneykZ/kfIJKgz8XeGfw+2bt1KdjhM80CQkKbxzDPPHHHsa6+9RljTGGjZRDTtiMbtf5aNGzdy8803H1Yu6+/giSeeoIZt83kswUjLpmu7/5fUWL58OS+//PIhpo2Q2ivkRqMU2TZRxzmo+GbE0KGl5ttDhwyhyDS5xrSIaNoRq0nbNGrEIMvmYX+QoKb94/rD/Xr25IZ0FfLFhsnotGTa0Vi/fj1+n48PIzHmBkJkBYN88cUX9O/dm0EXXHCI5nJOKMRLwRDd054y5XNzD5GM2759OxMmTKCuZbM+luBay6bLKacAMHPGDCyvl6imcU737pSUlHDl8OFYbg8Bj4dLLrroT31u6lWuzAP+AJtiCer7/TzzzDP89NNP5MfjnO74KbYsRg0f/odz/PTTT/Q49VTKRCIMGTiQPXv2cNOECfTv3fuY9uZjr7uONpbNW+EojS2LO/+kSem3337L008/XfqZnD59Ol3Se6x7nQBt/6AT+ETw3HPPUZz2njrfsund41CpnpPNxo0bqVatGpIkMTldIJchw/8KmQR1hr/EgSrJP6JVgwZcZNnc7w8Q0LQ/5Sp9gBUrVhBQVUYaJsWqyo2/01s+8Af8vffe49lnn2Xnzp18+OGHRGybqKZRv1q10na76uXLU9vtpo3XS9gwDvtcAobB/FCE1dE4fp8Pj8uFIYo8GQhxtWESNQzaNG5MXcumUHFRXlHIkxWWhKMM0HRMUWKEYTI/FMEvSdjpBPBb4SjPBUO4BZHKBQVUyMvDr2mcpRvEZZmKioIqivRRNWxR4sK0Lt/3339PIhjkDMehgmkxfMgQHn/8cfpfcAFqWh6jvteHIUl8Go3zTDBEQTzOokWL2LZtGz/99BOjRoygKCeHYl0n4XYjiyIRw6BAVkoTxYM0HZ8oHtL+dcVll3G6ZfN2OErc7Sbf7aGHT0UVRQoUBb8kYQgitU2TCmXKlFa3/PTTT3Rs3Ro5/fxDHi9dOnSgQtkC3IJAM7eHnqrK6micGi43HjGVwO+k6RhpGQtNFMkOh7F9Phq6PZR3u2nduDFtW7VClyQ8okhQVZkyZQp5Xh/tPV40QUgdBAgCsiCgezxcNWoUps+H4XKjiSItPR5CssLkdFvYyMsuo4LbTa4s82UswROBEHHbJhEMckogSFTTmTNnDu+//z4BTad7IIAuy3TVdB7xB9FEkVGGWVrNbwgCZ6oqVvr9nBsI4ZckHJerNLEflGWmOH7eTLcE1qtShWnp0/0GpsX5/frhNwxMn4+RV1yBX9Mol3Z7X7x4MQFNY5BhEnC5GG5abIglqOvxUly2gL7nnsvZpsVD/gA+UcR0uejaoQMLFy6k0OViczyLN8MRNFE8rG7zvVOn0qllS8qWKYtXM3ACoUM03b/55huisSxyT7mQOle/QKSwOo888kjp43v27OGbb775RwKsypWqoLl9+AMJIpWbMXnyZHr26EGWLLMoHOE8TaNDy5Z/+zqOl5KSEsaMGYMgCFSvXp1169ad0Pnnz5/PpRdfzGOPPZYJdDNkOAYyCepM/J3h34MZM2ZwWjqBNcXxc8rvDtR/y6UXX8zItDzYlYbJ0N8Z5/2nMWfOHBo4DhtiCcZZNqe2agXATTfcQELXqek4NKxR47CH/wf2QDt27Cj9t1WrVhHTND6JxnnQH6AoO5sHHniAwf378/LLLx9xHZs2baJT69bULi7m0UcfPfFP9CjMnTuXhK4z2DAJqqlE+rDBg6mUl0e3Tp3ofeaZXDxwII8//jgLFy4sjXPWrVtHUFX5JBrnuWCImOOQG40yxLI537SoVlR00H1umzQJ2+OhvMvF6micS6yDDR0/+OADQqZJgWXh93pRFYVEMHiQHMOWLVv47LPPSCaTvPHGG+SbJm+GI1z8uwOG4+Hpp5/Gr6pUtFNeL7t27WLhwoXU9Kc0oV8LRSgbix3XnMMvuYSGlsXotO/Sp59++ofjLx44kMvSRUr9TYurr7rquJ/HV199RSIYpEUgddDx4osv8vbbb5PQdaY7AdpaNpf9zd/ZZDLJZYMHE7Fsmtet+29XtHKAnTt30qVLFwRBoF+/fhnzxAz/M2QS1Bn+djZv3kzXdu1oULUqTz/99F+a65577uGswP9XsrZv2vSo13Rr357r03rZLRyHmTNnkkwmU2Z50TibYgksSeL1118/5Nr7Z87E9HoxPR4uGzyY8vn5RCWJjbEE80MRwobB3r17eeyxxxg9ejQVCwqol67mvdP2E/L6eCwQZGMsQVnFhSNJeASBjyMx3kqbyw0wLSbbDraqMnbsWE455RS8osigdEX19aZNlw4d+PTTT7nhhhtonH7+84JhLEmmnm3jFgQsUWR5JMbmeBZxWeYex2GgbqDJMpUsC9vlokZRES+99BKKJHGr7VDb5ebTaJwBmo6armR+LG0C0szjobCggFtvvbW0Qv6nn36iyymnELYsdJeLtoaJrigMHTKEO+64g6hh8mj6+kaBwEFyDslkkt5nnEFc1wn4VG6ZMAGAmydORJNSifxNsQRtPV4Ml4smderSpk0bJk6cyOOPP86DDz7IL7/8wjPPPEPzOnU4p3sPGtasSVPbpo5uUL9aNfbt28cjjzxCGZ9KsaJgCiLXGCbPB0J4BAFVlikbjzM3EGJtNE5Ikng1FGZOIEi247B27Vqa1qzJbCdADZcLR5TwCgLNmjThm2++KU1MA1x5xRWlGslXmxb50SiVypTBJ8u8G46yIZYgIEko6Yp05zevbT23G1kQKDZNLjNMTK+X3HAYf1oPuXuHDlxkWiwKR4jJMqbXy0svvZTSdG7SlNtsh02xBC39fnr27EmftGlJfbeHy4yUxEVDt4cOPh9ZjsNAy6aqy8VMf4B1sQQVLJt58+bhFUX6qRoN3G4MUSQeDB5kzPHMM8+QbxhMcfxUtyzGXn/9YQOkbh06cJpuYLg8SC4P1WvVZc+ePezcuZNLBw2iY/Pmf/m7f6xcd/1YQgVVKdt5BFYwxoIFC6hUUEATt4dNsQR3O36qFhT8Lffetm0bIy67jIsHDDgowZxMJikpKWHHjh3cd999PPnkk0fUQpw3bx6WZeH3+/9ws5ghQ4a/l0yCOhN/Z/j3YMGCBZQxTJ4IhOhi2VzUr98Rxz766KMUGCa32A6FpnnQYfl/Inv27KF1o0apqlzHYcWKFQBkB4MsCEXYlPZ7ee+99w66btmyZTSuUYN6VaocVB27cuVK4rrOv6Jx5gSCFCYSf3j/jz76iHO6dWdw//4n1bjtp59+onK5coiCQPn8fCZPnkwty+IJfxBNEBiqG+QqLsq5PRSY5kGGmyMvuwzN7cbwepk+fTq218v8YJgvonEkUTykQGns2LE0NS02xRKMtWwSpknvHj348ccf6dmlC9emK7lP8XoxfD7eeOONI677iSeeoGG64GSa46dprVp/+jXYsGEDixcvLq2Y37x5MwFd5xbb4UzLpnPbtsc1X4MqVUr3JR2CIeYcRXZz1apVhC2LGoEAMb//TxVS3H333XRP71lusx1Oa90agAfuv582DRty2eDBJ7yL8D+ZkpISrrrqqox5Yob/KTIJ6gz/UXz00UcENI3LDZOKpsktEyfy3Xff0b93b05v0+awrWlnd+3GANPiX5EYtWy79OTfcbvpo2pcrpv4RJG3336bZnXrUpSVxT2/MeH68ccfS52hN27cSNy2yXO5CHg83D558kH32rlzJzUqVKDQSklonNGjB7bXS57PR5bfj1eSGKTp6KKIO11NvDQcZVMsQVnLYsWKFezfv5/2bdoQlWXusP1U1HTO692boKpSbJpoksRNlkMHXSciSUQkCZ8gEJIkOvt8jDRMbJ+P7GCQLH+AYaZFgaJwvWlxrxPA0TRifj8BKZV8jUoSIUmiuuLCTstwXGVa+ESRjppGK8vi1HQAcYARw4cz9HcGdq0bNSLudnOOqvF4IEhM1w+qtN2wYQOO18tw3WCEYaK53axevZpKZctSV9UwRAm/JFFWVlgeiWFJEmfoOkFNO8gAJJlMcsvEidSpUgWPIDDSMDnDpyIKAnv37mXv3r00rVsXryBwqW5Q2eUiIkkUpyVETFnmXifAikgMUxS5zrRo5/VSzu0moOv0OvNMQoqCVxC4zXJ4LBBE83hKA8KSkhIuvegiIrZNWY+HWf4ANX+jkTxm1CgSqkpZRcFKy7s093jwCSKmKFHF5caWZBrVqcP111/PiOHDeffddw96fTdv3kxxmTJYksRlusENpknCsvAoCnmhEH3NVGtaBdOkXevW+GWZVh4v5TWNoK6jCAJNPR5eD0UI6DplEwlMSeYmy2FlNEaeYfLOO+9wzhlnYEsSMUmiudvDKX4/D/3GFGbUqFH01DTWxRKMt2z69ux52O9l1YIChuoG84IhajtOafvtwPPOo71lcYVhElBVVqxYwWeffcbFAwZw1RVXHFTV82fYvn07HVu2Iu73c2Hfvuzfv59ff/2Va6+7nlM6nsbs2annMmH8eExJJl9R8Ikis2bN+kv3PRJNatWio2FQz+MhYJr88ssvLFiwANsfRHG5CUUTxCo1JJhTxAUDLjziPGvXrqVy5cqIosi4ceOOydgnQ4YMJ5ZMgjoTf2c4eWzcuJHLLrmEUSNGsG3bNm695RZqlS9P7x49/jB2SCaT3DdjBr26dGHG9On/FR1DyWSSrVu3HlQg0KBaNS63bB7xB/GrKh9++CED+vShR8eOvPvuu8T8fibbDlMcP4F0Mc2BuYYMHIjqcmGr6h9qOe/YsYOwZXGNaXH2b0zbTwY33ngjp1qpDsFelkWDevUYYJpMsOxSo3tLFFkfS7AyGsOjKECqYnfevHmsWrWKX375hQdmzUJN73sSLhdtmzQ55F47d+6kXtWqhH0+fKLIWNOmh2Vz3llnMeiCCzjbtFgeiVHT5aafqlOUk3PEde/atYtaFSumDfm049LOXr9+PWvXrv3DMQsXLqRz27Zc1K8fP/zwwzHPDXD96NFUNi0GGiZBwzimDufvv/+et99++7i0x3/LCy+8QIFp8lQgxKmWzaWDBv2pef7XOGCemJ+fn/FhyfBfTyZBneEg1q1bx8KFC/+tTy+XLFnCsKFDeeCBB1IVpc2acY5lc7PlEND1g1p1vv/+eyoXFOASRVRRpGvHjqVati+99BIR0yTg9TJxwgRaNWjAMMtmXjBMRNOO6J67b98+Fi1adMTH9+7dy+LFiykuU4b6fj+2ohBXFE7xePCIIg/5g0y2HFRZpnPHjuRqGk1th+rlyx8UfM649166tmvH5Jtvpmb58jziD7IplqDYMGhaqzYtmzRBTRsKnuLxcprXR8N0JWy3zp3ZvXs3466/ntaWhVcQ+CgSY30sQUTVyA2HudlyUEWRCZbNJbqBLoo0cLlKdaAdWWZzPItV0TiKINCifn127drF999/T83KlSnvcvNYIEgdy2LcuHHYXi/vh6O09XoxRJGrrrySGTNm8Nlnn7FkyRIGXXghqijSw6dS3+3GdLnwaxqiIPBlLMFn0Rg+UeRu22F+MIwqCLwTjjLEMLlq1CggZepy4w03UKTp6IKAKQjUcbkZbVr4BJEFCxYA8Pjjj3NKuirgyUAIQxRRBQFfWvLDIwgokoRf07AEkcZuD2uicc4wTEyPh+tMi/ZeL609Xj6MxPC5XOzcuZP9+/czbtw4KhkG84NhKnq9lAmFuOiC/gclEd955x3ClkWRovB0IMTmeBbVXG7OO+88OnfuTKXCQiraNnFdZ/x11wGpjcC2bdtK57j55ptR02uNyTKnaRqfRuO0NS3ys7KIWDZtW7akmmXxkD9IsdtNu1NOYe/evdStWpWY203A5eKiAQP49ddfmT9/PnnRKG5FYfgll5BMJkkmk7Rr2ZKGqsaDToCErpc6uK9Zs4aIZRGQJIKyTOgI5jLffvstYdOkvtuDLUkkgsFSaZcGVapQPy2XYkoSPXv0IB4IMMS06GxZtGva7Cjf9j/m0sGD6W7ZLAlHqWXZRzR8SSaTzJkzh/79+x+2UwLg/fffZ9GiRcekdX0kFEnCcnmJ1+qAL5jNgAsHEc/Oo+issRT1Go/bCFDnmpeoNnQ2pu3/w7l27txJz549EQSB0047je3bt//pdWXIkOH4ySSoM/F3hmNj9+7d3HHHHUxMF438Vfbt20d+PE5/06KHZdGoRuZz9Xu++OIL2jZuTI2iIubOnUurBg0417IZb9kEdB2XLPNpNM7nsQS6231QfAmpiuSjSQZ8/PHHlLVSkg4fRmI4mlb62N69e7nissto27AhM6ZP/1ue428ZO3Ys3dNVzeebFuedey5hy8KRZR7yB1kWjuIRBKY6fq6zHMplZ/PJJ58QNAyaBoJY6YS83+3mYX+AL2MJcny+I2pu79+/nzvuuINmaR+ZB/0BGlatynfffUf9atXwiiLdfCpPBYLkhEIATLrpJsolErRt3JivvvrqoNdq2bJlh+hd/xE3jh2L3+cjrKoHVYOfSJLJJLNnz2b06NH/WNIzmUwycfx4ahYVcd5ZZ/Hzzz//I/f9T+ejjz4iEksgCAJuj4cXX3zxZC8pQ4a/jUyC+n+M7du3M3XqVB566KFDWpqefvppAqpGNcdP5YLC/5gfjexgkDfDETbHs6jsOKUJNoDRV1/NGemApqdpcdXIkaWPbdiwgW4dOtCqQQMWLlxIpTJleCoQYlMsQVXHKU12/hleeeUVaqV1wQbpOn5Roq3Xi1cQyfL7qVy2LDfccAMBTaOiYZAbDnN6+/bUqViRqVOmlM7z5Zdf8sILL9C+WXMuTCfP47rO8uXL+e6771AVhReDYcorCrdZDn5J4lrTooVucME55/DLL79wTrfuBFWVhNtDFdumffPmRGyb2f4AtiiyMZZgZToJnRuN8uqrr/LCCy+QFQox2DA5zeejsdtDK9Oif//+9OjUiV6mxVmqSkCWOfess/jll1+I2KnAeIRhorlcBFWV7oEgts+HpiiUVxSiklwa6HoUhXMcP5VdLvqoGhcbBpqilCaSNVEkLElkaRrPPvts6sfZtrFdLqKSRC2XmzxZ5sl0Aripx0OjunVLX7eArjPMMKmuqmRHIhiiyCQ7peMXlSSyPB5yDYOYbVPD7Wa6EyDq81HFTFWGLwxF0NOmjBddcAG//vorpzRtSszrRRNF7nH8jDEtwm43CV3n+t8ZtpzXsycxWaaz18c9jh9NUQipKg1tB12SUjIvoQgB3WDGvfdieDwYHg9j0sn44rw8pjl+3o/E0CSJgemK9bNNizHpew2/9FKGpf/9CsNEd7lYsWIFNStUoL9pcpWVMsf57YHT76uJtm/fTu8ePahXqTLT7rmn9N/79+7N8LTWXBfdYNARqhxmz55N+7TszCx/gKa/2Uhec9VVOJLEuliCN8MRbFUt3ex8FIlh+Xx/5uvF3XfeScOqVSnOzWNU+vn3sB0m/66j4Vi57uqrSeg6FSyLU1u1+tMVV7WrVMHOqkDd0S9Tse9tFFaoRDASo2K/26l2yQNILg9lOg4h0aArtes3Oup8yWSS22+/HUVRKCwsPOKhWIYMGU48mQR1Jv7OcGyc1qYNLSybbpZFcX7+MZshH4mNGzcS0TQ2x7NYF0sgiWKmk+gohEyT9yJRNsezKLJtup16KoX/x955hklNfn14kqnpZfrMArtL77136b0JCIIUFUQEFFBRFBBRUUQEUUHFQlFALAgqUhQRxA6KhaJS7RRp0pa53w877uv+6UhT574uvpDkyZNMdubkPOf8foZBUcOgU5s2ZzXmwYMHKZKeThvToopp0q1jx5xtd9x6K3UMk6csP3k1jcWLF5+rSzku27dvp3ShQliSRKG8efn++++5tls3bJeLSm43Myw/pttN2UKFqF+1Gl999RW3DB5Mf01nnGlR1u3mk3CU9rJCRbebim4PhijmdD8ejy+++AJZFKnhzS7A6NS+PZAdm1171VVYkoQhScyaOZOVK1eSpqq8GQjR2zDOWmsaspPjnqRc4NeRGJrXe8YLP1999RUlMvNjynLOe0WKfy7lKlUlo1k/il8zAdHlQhRFxo0b96/oEEmR4n9JJaj/Qxw+fJgyhYvQxLSoZJpc9T+utTXKluWZpENwLdvPiy++eJFmemYM7t+f4oZBc8umUN68OSaIcPIEdaUSJRhgmEwwbSxFoU7VqlhOF3mTZorHc8X+k5kzZ3Jl27aMHzfuuEHz119/TUhRmOkPkNfp5IVkNW9ljwfV6+W7776jdvnyPGVl3++KXh8ehwNZEAj4fCxbtozly5fjV1VqBQKEzGwjh6J58/LIww/nnGfa1KnEbJuIaaF7PFTweNkWS2N+IETJzEwgW5Lit99+49133+Wtt97iyJEjTHrsMRSnE1UQqOjxUMjlQnEIOZWvAN9++y2lCxWmktfLmnCUOl4fBRUF2+ViStLcr75l5ej7TZ48GdvppJjTRUAQaOjzsSEa51pFpbTLRXOvD6/DwQBVI8PtxiuKWC4Xd2g6MaeTvOEwPkEg3enEEAQ+DIW5VtVofNllQLaW+F2GyZZonApuD5ogEhJECrhcXJs0dWz+FymSzz77jD69emFpGvUtG0MQaOr1MdowcToc3KnpxEQnsiDQyOMl7nbTvl07IqZJW0mmpNtNR0kmrih88sknvPfeexRJthfO8QexnE58Dgdz/UE+CEVQvV4K5slDeiTC7Nmzefzxx8nw+SjrdpPH6cRyuaji8TA/EKKCx8OVkowtitnmjU4n7wRDfBGOonu9/Prrr2REIryc1MqOyDJxv580TSMtEGDAgAGsXLmSjz/+GNXloplPwhZF2sgyw4cPz6mc2RqNE1EUNm7ceNK/oaNHj7Jr165cgc7Afv3obJh8GY5SWdMZN27ccY99//33iavZBpGXGybXdu2as+2nn35C93qZGwgy1rQonDcvmbEYXXWDywyT9s2bn3ReiUSC2bNnc+vNN+doKL799tvk0zSetwM01XV0t5sSlk1GNJojxXOmGJLEh6EIm6JxoorK+vXrz2qcb775Bp+ika/RdYSKVqFbz2t4/vkXkBQVSdFp1aYtjZq1pHPXbseYsuzfv5/333//uGYt7733HpFIBEVRmDVr1lnNLUWKFGdGKkGdir9TnB4elysn5oirGt99993fGu/IkSMUzcigs27QzDCpX736OZrppcGRI0fofsUVGJJErQoV+PXXX//2mH169qSsadLSsnJMym+++WauvfbaXNW8Z8r27dsZP348zz77bK7CpjaNGjHBzC7EudKymXCSRO+ZsH///hPGckePHuXnn3/O7ma86y5q6wYv+oPkd7qQHQJNkwaSfzJx4kSqGAbXKiotJCnHM8ZwOrlF03nBny2PsnXr1uOe7/nnn6eBbfO4ZXOPYVKjTJlc23/44Yec7rZXXnmF6na21vRztp8qJUue9T1Yv349SvL9oKYnu3jlTIvG6lSsyF2GyYehCHlUjWXLlrFr165LYqHnjz/+YNWqVWctE3Im/P7777Ss34CImf1+8tdn+IcffqBpnToUT0/n0UceOe9z+TsULl6Kwp3upuLQ+dixDGrWrInD4eDaa69NmSem+NeRSlD/h1i7di15NI2tyYpZxevNtb198+b0MkwWBEPk1bRcur+XMolEgldeeYXJkycf08K2fft2yhUtiux2U6Zw4Vwr0Jai8HE4ytZoHL/bTRvd4FHLxpYkPvnkkxP+iL/11lukqSpjDIvShsGEvySM/8rU556jfJEi5I9EaCXJPGP7CYoiDXSDSZMm0bFlS3oZJguDIYKiyLO2n7eD4RyN3Kvad2Cknm3EcZVhcv/995/0PixZsgRbUeihG5QxDG4bPJjt27dTpnBhNK+XYpmZbN26let69CBPIEDQ5+NFO8D1qkpAFFE8Hm4ZOChXYLhx40byx+P4RJFMZ/YLSC2fhCIIlHF7kEWRKqVKUatcebp27YqUTLLfoGrU8nip7vESE0UKOF2Uc2drXNuaRgNZ4YtwlPqSjCGKtPZJ2G43fVWNbbE0uskKA1SNzrpOv2RrW5d2l9PfMFkfiVFe1+nQoQOhWB4CZRoSq9kJrxlm7Nixue7JCy+8QKPk4sBzth9DEIiLTtpLEh6Hg7mBIM8mP5fuqkbdGjXQRZF8TidehwOnw0HdGjV48MEHWbZsGRFF4d1QmJG6iSaIuB0OrlNUhuo6iiAQFsWcezlmzBgaJ80M050urlZU7jVMTEEg6PNhe73cbZhsiMbJcLkYrhusDEVQ3R5+++03enTtikcQUASBFo0bc+DAAe695x4yVJUBmo5fUXj//fdp3bo1EY+HkZpBQV1nzpw5dGzViiqmSWPLokLx4seVrfj+++9Zvnw569evp2CePChuN0UyMigQi1G6YEHeeustalWogCKKqE4npiyzcOHC4z57T0yaRLVSpejRqdMx2pDTpk0jMxKhbOHCfPrpp/zwww/cddddPPzwwznmmyfiqSeeoEDSSDKgKHz44Yf06tWLlsmq6ccsmwbVqvHBBx/kWpg6U4qmp3OPYTLDDmDKMmvWrKFB9epkRiKMHjXqjMZasWIFnbt04447h+Vc3+7du0+aPN+5cycZBQoRzFcI1bBYunTpMfv8+OOPVK9eHYfDwcCBA4/pgEmRIsW5JZWgTsXfKU6PGuXKcaVhcqNukBYMnvK3/XT45ZdfGDF8OKNHjz6vHZ27d+/m9ltuoe+117J27drzdp6/MnXqVCqZJqvDUbobJn169vzbYx49epSZM2fy2GOPsWPHDnp27kwVw6STYZARjbJv3z6+/PJL3nnnnTNOaO3du5eNGzfmei+aPXs2UVXlcr+foK7z7bff/u1rWLRoEZaiYPh8dG7b9qTJ1J6dO+e8I12jqLT2STT4H43sI0eOcFPfvhRLTyeoqhQyTYKGQVDXeScYZks0TgHDyDE//1/WrFlDUFEYY1jUN0z69+59wvns27eP0oUKU9wwMFwuyhcpwltvvXVW9+GKVq242TD5PhqnhNtD/379zniMcoULM9X2szkap4iq4nO78QgCkihe1IrqX3/9lYJ58lDYNAklvZfOJzffeCNtjez3q8qGwZQpU3K2tWzQgOsMk7mB4DG+SeebrVu3cvuQIdx3772n9f7y+uuvo2gGqhWgcbMWHD58OMc8sXbt2mzfvv0CzDpFigtDKkH9H2Lv3r2EDJMRhsk1hknV0qVzbf/xxx9pXKsWBWMxHrj33oszyfNAIpFg9+7dx7TB3NS3L0UMg5q2TdDn4+WkVEQBWcaTTMj9qfE0c+ZMqpcuzRWtWnHbbbfROylT8IBh0aF5c5YsWcIvv/xy3PP//vvvVChWjJjLxVWyQjSp8/vn/c4Ih5FFkQ9C2RWzkiDw888/M/TWW2lsmLweCFHKMHjiiSdO2Tb53Xffcc899zBt2jSOHj3KXSNG0MHIriDvrhs0adCAyobBe6EI6W43nRSVSZaNLAhU9nrprGpYkoTl81E0f37Wr19PncqVMV1uJIeDpj4fIaeTMi43U20/liBwt2HyqGVjOl3crOmUdLvZFkvj/VAEWRBIj8XIcLnYGo2zIBhC93i4WlHZFkvjakWllsfLlmiciOikgdfHp+Eo1T1eHA4HuihiJROxmzdvpnShQrhEkc5t23LkyBFCkTjpTfpS8fbXUPxx+v1PEDdx4kRsl4tpdoDWkkRczK5mXxWOIgsC6yIxPglHcTkcmKpKEVXlBX+A6h4v7ZOJ+HSfj7a6QeF8+Rg9ahRBXUcWBJr7fHSVFdwOB+mxGA28PrZG4wzRdBSHg48++ohKJUvilyQ8gsDq5GJIQBSpUKYM1cuUYYxh8X00TklVwy2KuBwO4pJEq8aNCcgyy0MRJpo2xdLTAWjfrBnjk3p4nXSdkKIQc7uJeDwUiEZ55OGHSSQSHDp0iGaNG+N1uSiSns4333yT677MnDkTvyxT3LSIWxbX6wZfhLM1wOf4g0w0bfKFw7z77rsUNgy+i8Z5xvZTrkiRM/rbmzt3LramoXp9OfIhhw4donf37hROS+O6Hj2OeaYPHDjAW2+9xapVq+jYvDk9ZYW404ktipQsVRorlons8lDD6yOkKMyZM+eM5nQ81qxZQ42yZSldoABz586lXZMm9EkuHuXTNFasWPG3z3EypkyZQqxkTSoPW0Bmy4HUb9zsuPsdOnSIfv365QSkfya9N2zYwPjx41m0aNF5nWeKFP8lUgnqVPz9b+H3338/poDjXLJ9+3YG9e9Pn55Xn9LU7VKjad3LaG0Y3KQbRCwrVyfh+WLixIm0SBYwDDfMs5bgOBkhw8iR/ChuWdw8aBBhRaGEaVK7UqXTlmFZsWIFfk0jJMvUq1YtV3fpypUreeKJJ/j+++/Pao4bNmygYvHihE2TUSNGULZQIZ6x/XwbjVPQME5aKPXuu+9iSRLVvV5MQaC2pp00gXzgwAFWr17Nrl27eODee4mpKmUsi1oVK550wX/ixImEVZWgojDlFFrbf/zxB1VKl6ankSx4UpQTVmefjMubNmW4YbI5GqemZTFt2jT++OMPhg8dSo9OnU4rJp0/fz6mLBNXVQy3m1f8Ab6MxLBFkYAkXTTJuLFjx9LeMHOq2f8qG3Mitm7dyt13383kyZPPuDijZ+fO3JGUK+xkmDzwwAM528oXKcJMf7a/UxXbZv78+Wd8PWfDgQMHSI9G6akbNDEMmterd1rH7dq1i++//z5XPmP69Okp88QU/zpSCer/GKtXr+aKVq24tmvX47aS/5dIJBK8+eabzJo1i/vuHkWGptHAMFAEgc/CUWb7A6QFAnzzzTcEFYXnbD89DJM6VargVxR6GQYxWUaXZaoEAgR1/aTGicNuv502jRoxe/bsY7ZPGDcOj+jE43Cgut0MuuEG9u/fT8/OnSmRnk6J/PlRPR5CpsmHH354zPEffPAB3Tt2ZOitt7Jv3z4WL15MlRIliRkGl0kyW5Ku13Vr1aJL8of6JlWjWL585LVsdEGgrNtNYZcLy+GgjSTRVVawfD5KaxpPWDYNvT6Ku92MNy2Cosgdqo7ocPB1JMbGaBzD6aSbohAURXopKrW8XlSnk/feew/F5aKFT6KRT0L7U1va6cwxAawoy+RxOqnvzTZYDAoicYeDWzWdUYZJ0zp1cn1uf9K6aVMktxenKGLLKjNmzCCRSHDkyBE2b96MrSh0krLHDooiV8ky1Txe7jdMFIcDWxBRBIG61atnLzwk9advVDUkQeAO3aCWx0sPRSWfqnJZ1apc2a4dkiBwnaLSyiehiCIjR46krNvD15EYjZJSJl6ni6u7dGHNmjVkhsMUdLmo482uKFccDgKShOp2400aeEoOB+vDUTZE47idTvKoKt9G48wPhHIMWB4eO5aSusFdyRbFtpLMRNPGEkRkjyfnvqxYsYIMXeeTcJThx3Fe/6vpZtzrpbem834oW6f722icj8NRZI+HDz/8kHyaxppIjLGmdcyi1qn+vmxV5dVAkGWhMJrXy86dOxn74IPUMgwWBcPUNIxc0iEHDx6kcqlSlLcsoqpK25Yt8QoCrwaCzPIH8AgCxa8eT7mBL2BGM3j00UdPez5nQvUyZXLkjqrbNi+//PJ5Oc+fzJ07F3+eApTq+xTxyi3p0q3HSfefNm0akiQRi8V46aWXCGgaV5oW+TSNJydPPq9zTZHiv0IqQZ2Kv/8NPDphAmrS4+KeESMu9nTOKyOGDsVSFIpnZp52As5SFD4LR9kWS6OQafL555+fdP9ffvmFd955528l/Hfu3Enx/PnJ0HVChsGqVauO2Wf79u0sX778rA2Sm9erTzvD5DbdIGQY5A0GeSsYYks0TmHD5IMPPjjmmJdffpni6elULlEiZ071qlTh4aR/SyXLOqfxUINq1RlimLwXipBH0yiemcl40+LLSIx8msZHH3100uPXrVvH9X36UL1MGfr16sX+/ftP+9yffvopixYtOmU1ebGMDB40LeYHQpiSdEq5lPRQiCXBbF+kUpZ1Vt3Ia9asIeb3o3u91KtWjQMHDnBt1640NExG6AZ+VT2ldB9kP0Nr164lLRDgRX8w2+hSEIkrygmrxs83Tz/9NFUMk4/DUa4wTG48gb/Nn+zevZs8oRDddIOqhsE1f5ERPB1WrVpFUNcpYVlkRKO5ch/Tpk4lqCiUt2xKFyr8tzoxz4S1a9eSnnzf/Oo4He1nysqVKwmHw+i6zptvvnmOZpkixcUjlaBO8a9lz549Z2QqsXDhwmzjQkniy0iMeYEQEctiwYIFVLazNZfnBoKUzMjgk08+4d5776VD+/bckJQbuFHTueks2rA+++wzapUvjy6KTDAsvo7EMH2+HLfnN954g1KmyXfROA+ZFnWTRoB/sm3bNvyqygjdoKlhUqtyZXSvl0mWza2aji4IOB0C5YoW5YsvviBPKEQZ2yag6dStWhVJEPggFGFLsrrX4XCwMRpnWywNOZk8vczrRRYEhiavtZuqkTccplq5chTSDUqbJvVr1KBGuXLITieSIGC53VQuX57hw4djer3crOmku91kShIbIjHu0Q0quN0M0HRKlShBWcNgUzTOg4aJLAh0kmSa+SQyXC4qlC7NlClTjtEF//HHH6laujSq10uPTp14++23Ceg6HqeTKzt2pHzyc1sYDGG4XGgeD26Hg+puD35BICaKSA4HEVnm2WefJaBptAgEUDweaiWDh7mBIPmS1zRSN2mjavid2WaPayMxnIJAsZJliGgabocDQxCYaNqsj8QooOu0bNKEDrrOHbpBUMjWlPs0HGV9JIYmCNytG3wdjhJxOumragzXstsDA5KE5fZgSBLTpk4FspO+kx5/nN7du5MRCjE/EGJbLI2ybg+Z8XjOfVmwYAGlky8UT9t+Khcvnuu+Na1ThwGGyVvBEIbHgywIOB0O7KRxZFhRGDViBIlEgsH9++N2OskbCp1RQJtIJFC8XpaHIqyJxHK0tQfdeCMDks9Rf01n8E035RyzbNkyipsmW6Nx3giESA+HkVwuvorE+DwcxSUIhEvWJL3pDWiGzaZNm057PmfCq6++il9RKGlZlClc5LwHrYlEgpsGDSYYiVO7XsPT0qNcvXo1GRkZOJ1OysoKW6NxnrL8NLoAWp1Hjx5lyZIlvPvuuymDlhT/WlIJ6lT8/U/nyJEjSG43K0MRVoWjqB7PWSc8L3U+/vhj0lSVD0MRRhomtStUOO5+fxYx/MkVrdtQ2zDpqmdLYZwsyfn5558T1HUq+v1EbftvaW0fOnSIL7/88hhZNMhOUIYMg7K2TTwQOK1k5P/y+++/c/NNN3F1ly58/vnnVC9ThtsMk5f9QfyyfEzV8/bt2zEliVn+AA8YFoXy5AGgeb163G6YfBmJUcwwzmkCrHyRIky1/WyJxilrWYwfP56Y34/b6WTQDTdcEvFFyDB4Jxjm+2icNFU7pkp1165dzJo1i/yxGLai0OSyyyig69S3bYplZp5R0vyvHD58mF9//TXnHpTKn595yZi/TiDAvHnzTnus119/Hc3rzfa8cblo07RpLvP0C8mRI0fo2bkzfk2jUc2a7Ny585h9Vq9ezY0DBzJx4kTee+89StvZWucrQhHS/H42bdpEjXLliNv+Ywzqj8eOHTv46KOPjhvLf/PNNyxatOisP6ez4Y8//iBvOExvw6CFYdCkdu2/PebmzZspXbo0oijycLKbNkWKfyqpBHUKDhw4wIwZM3jxxRf/Nbqmz8+Yge7zoXu9DDzF6uz/csuNN6J4PGg+H7NnzWLv3r0USU+nju0nTdWY8JeKz3HjxlHTMFgSDFPbMHjgFDrR/0sikSAtGGSMYTHJspEcApVcbhSPJ6c6Y8GCBRQ3TDZEYoxOJqjbN2+OLkk0rFGDl19+mYrJquiFwRCaIOAXRbZE43wSjqIJAj6XK+ec4x96iIhhUDRfPrwuFyXdbm7TdKZYfmSnE8XhoJlP4gpJxvZ4uS/ZitVJVlBdLrrqBrYs88UXX5BIJFiyZAlvvPFGzrNz4MABhg8fTlBRqOrzken10iEp6THJypZTqSDJ6ILAnZpODUnmvnvvpUmdOtiShKUoWC4Xy0LhbHMQQaCUJFHTNGnxFwOURCLBCy+8wIC+fZk4cSKtGzYiKCtMsfysiUQxRZGAotDctimsG9wxZAj9+vTB43AgOhx0lmW2xdK4RdMp5PXy5JNPsnHjRmbMmMHSpUsJ6jq9NZ1iXh9hwyDky5bweNzMlkTpKMvUVTTC6aVxOARef/116tSsSVhReMyy2ZBMUFcvX55xSVmOBr5suY8nTZtHTQtNEJhk2XwXjVNI0yiSmYnf4yHT5eZR0yRdVXnhhReO++zcO3Ik6YpCfUnG9Hpz6bgdPnyYRrVqEVVUTFlmwYIFuY7dvHkzdSpXJjMSQfF4aOeTuFpWsH0+XnvtNb7++utc+x89epQ9e/acsW7h4xMnonm96F4vQ2++Gch2Fg/qOtWTXQd/Pde3335LQFaY5Q9wk2FStUwZ2rZoQUCSCMgyd9x6K4MG30Lb9h1ZtmzZGc3lTNm0aRPvvffeOdHSPF/s3LmTqlWr4nA4qOj2UMMwGDJo0Hk/b9v2HfGn5ceOpdP96mtPuN++fftOKH2UIsWlTipBnYq//+kcPXoUzefjrWCIZaEw6lmYrf1TePvttylummyKxplmByhXqNAx+6xbt4788ThOUeTKtu3Iysri4MGDPPLII4wcOfKU1bHXX3MNtyTj7Wt1g2F33nnOr2Pv3r00bdCAQcmF/KtPcJ4FCxbQq1s3Hp048bSM7zZs2ECdSpUonp7O1OeeO+72iKKwMRrno3AEXZKA7HtWLCMDj8tFn549z2nia+7cuViyTIauU7tSJQ4dOsQPP/xAj27dqFi8OANvuOGkhvUXggnjxhFIzrFt06a57vWyZcuwVZWg00lBp4vFwTB+SeLZZ59l2rRpZ7UYdPTo0ePe49sHD6a0YdBDNwib5hnHVkePHmXlypUEDYM0nw9ZEMgfj19yshCbNm1CM23ita8kmFmSPn1vIKjrDNENWhgmlzdrRssGDbjRMHk3FCb9H+SZ9Vc2bdrE4Jtu4q7hw8+ZrNDevXtp3bo1DoeDXr16nbaMT4oUlxqpBPV/nEQiQd0qVahhWZQzTCqWLMnwYcP+luPzyThw4ACvvPIKS5YsOa+re2HT5I1AiK8jMQKyfMZVDrt27cq1mrp7927mzJnDypUrc+13+PBhenfvTsFYjGu6dDnjQCorKwuXKPJNJMZ30TiKIGAKArLbzbZt23js0Ufp1a0b9WvXxu10Eg8EuPXWW6ljmHwRjtLOMOjXpw+SINBFVijkcnG1rFDV46Goy02a00khj4cmtesA2aaHtiSxMBhijGGhO130VzWKutxYbjfz589n4sSJFC9alLatW3Njv340TFZcFFIUPE4nBX0+DEniiy++4PXXX+euu+7igw8+4NChQzz11FNEg0EUhwOvw8HmaJz5gSCyIHCbplPA4yVimrgdAnU8XqKiiFcQePLJJ0kkEvzwww/s2LEDWRAxksc8a/sxBYFPwhFEQeCzzz4jkUjw7DPPkF/TGKob6KJIT0UhJIrM9AdYF4kREUWKKAodO3Tg9ddfZ86cObiT1cuDNZ0ybjfvhyI08kkYPh9PP/00ZYsUoX7Vqnz11VesXbuW/v36oXi9XK9q5He7yePxoAkiDSUZp9OFFEwnkFGWPF6ZgCRxhWHQQFGQRBGfy0XPzp1ZvHgxfkWhvG2TPx7npZdewvJ4sUUnmseDJknoXi8dW7WiQFoat2kG9xkmIVGkoWXx9NNPH/PcHDx4kFWrVjFnzhyefvpp1q1bd8yzd/ToUdavX89PP/3E119/fdzKgQMHDiCLIn0VlXaShCaKx0j/JBIJbrj2WmS3G0tRTmiUeCJ27NhxjEHgzz//zMKFC48bYM+YPp2yBQtSuXRpbFmmZiBA2DR57733jjt+IpGg7zXXIHs8lCpY8JwY9fyTOHr0KO3bt8fhcBAJh8+7ydOOHTvwSjIVb3+NCkNewelyH3fhItvQRcenaFzZtVuqmiPFP45UgjoVf/8bmDVzJrokIXs8/2oJqCNHjtCkTh1iavbC/GuvvZZr+yuvvILiciELAmMMi7KmySuvvHJG5xg5fDgNDZN3gmGqGgaPJ701zhV//PEHpQoWIl2SuMzr471QhOqGwaOPPkpWVhY//PADhw8f5oMPPiCkKIzQDUrrBg8epzjm4MGDPPXUUzz++OOntSiRSCRo3bgxGbJMwOPhhuuuO6fXdiJ++uknVq9ezZEjR/j+++/xqyrVvV4Mh4M8Hg+N6tdn3bp1zJ8/ny1btlyQOf3Jzz//zIDrr+fKDh2YN2/eMQsBDapVY3xSS7yKx8ME0yKvpuXIxPzxxx9nFPvcOWQIHpeLyHGkQY4ePcq0adO45557zlrzu1e3bgxOLrB0kGTq+3w0qFbtrMY6X7z00kuEClei8rAFFOs+lqIly/LFF1/Qq1s3ht56K3v37qVa6dI8nZThq2LZvPrqqxd72pcMR48e5bbbbsPhcFCnTp2UeWKKfySpBPV/nB9//BFbktgcjbMhGkd0OOiq6WREo+e8/efIkSPUrFCBypZFQd1gcP/+53T8v5InGGSmP8DH4SiWJJ1VUJNIJHhw9GjqVqzIkEGDzulK5F8Dlmu6diXu8ZDpzNZpvksziHo89Ln2WkobBiN0g5CisGzZMhKJBKNGjeLKpEnjTbrBdT17onq9XCsrWILAHarOKN1AlySu6NCBUXffnROcrl69mnyaxsZonIXBEFHTpEW9erSsX/+4en0HDhygW8eOhGQZNSkDYQoCtb0+Lr/8cvKqGn11g4CiUK96dcr5fFT3eFEcAj6Hg0GqRn9VQxJFDK+Xcm4PNd0egqJIO5+EJYh0lmUytf+vTH/4oYco4c2unP4gFGFzNE5EFKng8aKKImmqSpfLL+eqDh0Ynazuvl5RGahqTDZtPA4HkiBwlawwTNPp1a0bAPWrVcPnEFgeivBmIISSlC+pXKo0kyZNwicIREWRAi4XBdLSAHjuuedorGpsi6Uxww4QlmXu/7OiXFFRXC6G6QZPWjYuh4Ot0Thbo3FklyuXMcqWLVtYunQpe/bsYc6cOVTUdbZE4zxi2lxWqTK//PILR44cwSmKbIjG2RSNIzkcBBQVxeulRP78rFu3Dshu2yxRoAAFDAO/qtGwTh00jwdbVXn33XdzfX6//fYbhfPlI0PXidr2MZXRGzZsIJasJP8mEsPjdObavnnzZu655x5issLaSIxpdoCi+fKd9Nk+evQoO3bsyBXIr1u3jpdffvmMdO87t23LPcl7faVp8uCDDx53vzfffJNiRrbJ4y2GScsGDU77HP8m5s2bh2EY2LZ9TMX8ueTQoUPopk2BdreR2XIg/lDkuC9gGQULU/jKe6hw26uYobRTakmmSHGpkUpQp+LvfwuJROK0qmz/6Rw5coRnn32WV199Ndfv0tGjRzFkmdcCQRYHwyiCQEXTPK4nzMn4448/6Nq+PfmjUfr07HnWXae//PILdStXJqBp9L3mmpzPZtmyZZSyLNZHotRL+rhc06UL3377LXHLQne5iAcCDBs2jKusbNmDRy2b1g0bHnOOFvXrU8s0aWRaVC1T5rQ+/yEDB1JYUegsK/hV9bzJqJ2IBx98kI6ywrZYGuXcbiq4PTSUZDSnk1p+P35V5ZNPPjnn5/38889p1aAhlzdrxvr163P+v3yxYnQ3DG4wTNIjEZ544gleeumlnHvZrkkTbjJMPg1HyeN0Ynm9dGrTJru7rUwZ3E4n5YsVOy25yS+//JKoovB5OMoky6ZUgQLn/DoHDxhAe03n83CUGh4vnWSZamfgLXMhmDFjBk63l3jtLmjRAlSqVOWYfebNm4clyxTQdQrmy8c777xz4Sd6iTN16lQ8Hg/58+c/5t3vv8KyZcsIReMoms7D4x+52NNJcQakEtT/cQ4ePEjYshhlmAxUNfI7XWyLpZHfMM55289XX31FXk1jS9KEzVIUABYvXkyJzExK5c+f60cmKyuLDz/8MFewcLq89dZb2JqGz+3mgXvvPav5vvjiixTRdabafqobJveNGnVW4/xJVlYWYx98kOIZGTgFgZIFCvDhhx8SDwQorih4HQ76yNkmgy6HA7/Hw6PJAPQqy+bhhx8GsqsN8sfj5FMUTJ+Py1u2pFqlSijJBLIhCIRFkVggkLNy+qeD+9GjR2nTpAn5NA1bkuncoQOS240hy8c1PtmyZQuW14vX4aCTJLMuEqOGx4siiNStUoUHk9IVvfRsw8Rvo3G2ROPYosgk00J1CFwuSXhEkZDHw7ZYGl9HYngdDiSXiwY+H9tiaTxn+6lVrhyQvcI/Qje4SdWIiCKFvV7y+gPILhfLQxG+jcYJyTLxYJCI6GRIUme7qMtNhtdLUJaRRZHWlk1AUVi6dCmQ7eRcTZJwJyU+3IKQU01UuUQJJlk2W6JxKrg9uEQRyA6WFUHgTt2grNtDnlCIch4PUyw/MaeTsGmSqeuYPomCaWlcrml01HRKFyp0wqqJhx56iDxOJ5+FowxUNSqVLJmz7cp27ShrWlQyTIpmZlJA11kVjnKHYeZolD355JM0trIrNkYbJkG3m2+jcSZZNpVLlMh1rjFjxnB5cjHjZt2gUDxOywYNcuRADh06RME8ebhSN2hgGLkkVNatW0dQ16llmliiyFeRGM/afopnZJzwGd++fTtlChdG83gonj8/a9eu5emnnyagKNQPBIhY1mm98Bw+fJibb7qJpobJ64EQJQ2DmTNnHnffOXPmUNWy2BKN87BpUa/KscHsf4UNGzZQsmRJBEFg1KhR5y0h8d5771G6fCXKV652wpfFwsVLUuDy2yk3eDa6P5xLgiZFin8CqQR1Kv5OcWYcPHiQIYMG0bR27ePKSJxvrmzXjqKGQSHD4OouXXL+PysrC5/bzUfhCF+Eo3gcDupWqXLGsmU7d+7ktdde45tvvvlb87yma1d6GiYfhSOUMUxefPFFILvL0S8rPG376W0YNKxRA4DSxYrRUpLYGo3TW1Fp1bQpfkWhv6ZTQNOZ9NhjucY/cuQIoiCwMRmTWz7pmE6241GpWDFe8gfZFkujoe0/Ydx1vrjnnnvI43Qy2x/A6XCwLhJjazSOXxR5PxThNk2nz9VXn/D4H3/8kV7dunFlu3anbZJ5+PBhorbNSMNkiGFSIC0tR6dcFAQ2JQtPFFGkjmFSyjDpe801QPbnVaFYMQxJolf37qxfv55EIsHdI0fS1jDYEo3TWTcYMnjwKefx2WefkU/T2BCJMcsfoHBSA/xM2Lt3LyPuvJObbrjhuN2EO3fupH716khOJ4bThSnLLFmy5IzPc75IJBL069ePMj6JrqrO5ZJCy3r1jrvvt99+S8E8eahp2+TRNMY+8MAFnu3JSSQSvP7660yYMIHNmzdflDm8//77hEIhdF0/r4UrlyrxvOkU7DCM0n2nIKsG27Ztu9hTSnGapBLUKVi1ahWtGjQkn99PA1Wjn24QDwTOuTHYjh07sBSFxy2bmw2T8kWLcvjwYWxV5Vnbz9O2H1vTyMrKIisriyZ16lDQMAjKCo8+cuYrXyerGNm+fTt33H47Q4cMOcaQbPq0aVQoWpRiBQrQK9kKNcowsT1e2jVtetb6fbcNGkQBSaKU2836SIwBhkmF0qVpn0xCP2RahCSJQl4v30XjtJYk4i4XAzQdS5KoVLIkxfLm5c4776Rbp04EPR4ynU6aeH0Ucrm43zCxBJFBarZuXWO/n+nTp/PoI4+guN3ILhc333gjWVlZjBs3jqFDh6J6PKwMRZgXCGGr6jFJ1et69KCXolLN7UFNaluXd7nJF4sx8MYbCbnclHW7CUoSltdLH0XlNk0nJIq8YAeQBIEmuk61smUJGQYDVI3LJRlNFOnduzem280DhkVljxdbkvjpp59YsmQJAUWhgz+ALkk8+uijHDp0iMxojEctm9cDIVS3h9qGwSTTppbHS1GXC7/Xi+J287TtZ4CqEfH7WbNmTc61/Pbbb5QsVIiQ00lLVSViWfz444/89ttvFIjFKO12M832ExGdlChalB07djB+/HjqqCpdZYWmPh/VK1QgU5Ko6/Vxg6JRPD2dzz77jE2bNpE/FkMVBFRR5Jpk1fbxGDVqFGU9XlRBIJ/TSesmTXK2ZWVl8eCDD9K0cWN69uxJuaTR4STLpkbZsuzdu5dp06ZR2jD4KByhh24QcLtZG4nxsGlRtkgR+lx9Nbffcgu///47o0aNooZusCYS43JZpqrHy92GScSyczoCfv75Z0aOHMlDDz2U0zWxfv16WrVqRVMl23yvtseLWxCwVZW33377hNc2YvhwOuoGW6Nxumo6ituN3+XKqXTvYlrHrYTes2cPjWvXRnK7KVukCLLHg8/lolrZspRIT2foLbecMOF/8OBBaleqRFRR8WvaCaVA/ivs27ePzp0743A4aNWq1UUzxFqxYgV2MIzT5WbwLUMuyhxSpPg7pBLUqfg7xZkxZNAg6homkyyb+HG6us4nu3btQnF7+DYaZ32yI+yvnaDjxoxB9/kwfD4G9et3xrJTv/zyC/nCEWr5/QQVhblz5571XNs2bsJ9RrYhdFPL5oknnsjZ9uqrr1KjbFlqVKxI3YoV6dahA35No4HXxwehCJU8HurUqMGHH37I0KFDmTNnDvv376d39+5UKFKE++6+m0QiQYn8+bneMLnFMMkTCp1WF+jNAwZQSdO4VdORBIG80egFTa6tXLmSgMdDSbcbSxDopqjcqhsogsjL/iB1DJP77rnnhMdXKlGCa3SDoYZJxLJOqxP4l19+wfD52ByN8200jksUc+5Vw5o1aWSYtNJ1DKeTzZEYH4Uj+DUt5/ht27bxzjvv5DK7vGvECDoY2bFwN8Ng4IABp6y2TyQS9OzcGcPnw5TlMzJB/JMW9evTwjC5QTeI+f0nfF9NJBJs3LjxnGkfnyvuHDKETFWjrMdDyOUiLCs5izf/y9tvv0255Pvz64EQRc4ioX8+efD++ymg61xh2UQs64w6SM8lmzZtolSpUoiiyPjx4/9TcnumP0jJ3o9R4bZX0azgWRU8prg4pBLUKXLYvXs3d95+OwOuv/686bguWbKEOhUq0KJ+fb777jv27NmDlEywrQpHUUSRgrEYTevXJyQ62ZyUosgTCJxy7KNHj7J69epTul0nEgnKFytGR02no6IQNU127doFZLv5BhWFF/wBOqgqitNFc8NAFQTGmxYtDJM7hpxesmXTpk1c16Mnfa+9lm3btlGtVCmuV1Vqe71sica5yzCpWq4chXWd1wJBWhsmrZs2pbDXx3fROPdqBrIo0qd3bwKGQSGXizJuN16HA5/DQVOfj/GmRWtJ4qFkJXN3WaGEy80cf5A8qsrSpUvxOJ28n3Rw9wgCvXv2pJCi0ETVkAWBlcEwS4NhVJ+PgwcP8tFHH7FmzRqysrLo1a0bvZP7vRUMMTcQxONwsHjxYgKazoOmxY2aTlCWiTmdBAQBXRBwOxzIgkCdOnW46667uLxZMyoXL0GNKlVoXK8+V7RrRwGvl/JuN7Yg0F/VaKKqPPnkk0C2FMmTTz6ZS0/3gw8+oFh6OnkCAa7v04e410sdr5c6Xh9RTaNP795objfXKioPGhaK18vMF14gYlnkCQZZsGABhWMxnrcDzPEHKebx8tRTT1GvalW66AbDdAOfw4HlcFDb48GvKHz33XekR6KUs7NbC+fOnUtA0xik6dQyDK5PVnJMnDiRvE4XL/uDNPD6kP4ilZFIJDh06BB79uxhxLBhXNG+PQFJYphuUFjXeWLyZL7++msK582L1+VCd7kYpGrkdzrRRBFTFNE8Hnp264bs8SC73VQrVx7N66VYejpXXXEFLlHEVJTsFy/doLVhUjAex/RmJ8LdDgeKIPBpOMqmaBzd6z1mYeZP1q1bR0DT6KDpWKJIP0WjrKISUBQUj4d7R47kxx9/ZNSoUTmLB38y8q67cqpG2ssKjb0++qkadb0+XvYHKaobvPTSS8ec8+6RI2lhGHwTidHQ56OnrPBhKILq9Z40wfrll19Su2JFiuTNy8CBA3O9IPyXSSQSPPzww7hcLgoWLJhroeZCzyMrK+uinDtFir9LKkGdir9THJ/ly5dz1113sWjRolz/36xOHR5PJo062PY512j+K/9bhHL48GECus4jps040yJi2ccUqfzyyy/8+OOPZ3W+KVOm0ML2sy2WxmOWTeOaNc967h988AEBTaOgYVA8f/6cd5A/2bx5M/6k4XZ3w6RwWhp+pxOfw0FDn480RclVNT1k0CAaGyYv+YMU1nVeffVVtmzZwjVdu3JVhw689957p5WsPXLkCGWKFqWoy4UpCFT0eAgbxhnp2N47ciQBTad0wYJnLC2QSCS4qW9fXKJI2LKoWKoUxdMzaFyvHiUzMriuR4+Tev14XC7WJquuY6p6Wv5DiUSCBjVqUM2yqGBadGjZMmfb/v37GT9+PCNHjsRSVO43TK4xTGpXrAhkSwj4VZUKtp/0SDSnSv2v3YRR08TncqFL0mlpnv/888/s3buX33//nWu6dKFOhQrMmD79lMcBWIrC6nCUbbE0Cplmjhb2qdixYwfD77yTYXfckfNZb9u2jQ4tWnBZ5cpn7D1ztsRsm2WhMFujcfIrCs8888wJ9/3222/xyzLP2n56GSZN69S5IHM8XSoXL84sfyC7GyEQOKWc0Jo1a2jZ5nIu79j5lHmMM2Xv3r20atXqP2ee+NSUKUiKhmLYXNX93Bq8pji/pBLUKS46fa+5hryahuXxUE9WWBwMU9LjxedwMC8QYqRunFRWALKT05c3b05eTcOWJB5/9NET7rt//348TmeOXrBPEGiWbCFatGgR5W2brdE4cwNBCsbjtGnThhaKyrZYGrfqBtf16HHKa8rKyqJAWhp9DZNehkmJ/PkZdvvtlNJ08jmdqIJAUNdZtWoVo0aMoFT+/HS9vD0//fQT/qSkRlgUKaUbzJ49G69D4HHL5lZNRxMEvA4HrSWJvE4njbw+/KLINYqKIQhkOJ0Yosigm25i5cqVeJLJ5fdCEbyCQECSWBwMsy2WRkGXC6fDgVcQKJAnD6UKFiLucuETBOLBIH379iWo67gdDtZEonwSjuJ2OLiuVy+iisqWaJw1kRhuQSCWXFBYFgojiyK3Dx7M0aNHaVqnDtcYJlMsP345O+kbkGWWJOdQxOXK1tkWxdNuNRs+dCiVJInHLZuA00nYtnEnDSaHaDpBUaRZo0ZoPh/zAyFm+QNYioLmclHU5SIqOqnk9mC4PXiSxonbYmlERJEpyZerDKeLRYsWsWfPHpYuXcqyZcvYsWMHn3/+OTf27cuDY8bkJGfvvvvuHN280YZJRFGB7EWKIunpOEWRNMuiqa5znW4QMU169+jBc889lx0cV6vOCMNkTSRK3OnkRX+QqOjkUdPiSStbV9vtcPBROMLyUASXw0EXVaOyrnNdjx6Mvuce8ioK+ZISPZ+Go/gEgZJuN/cZJm8Hw2iCQDGXizJuD8UyMo75od62bRsfffQRo0ePpkPyWiaYNhFZJm6aPGLafBSOEJJl8gRDXKkb1DIMrmzbDsgO8qdMmUKeSASXKBJSVfpoOstDEUIeD0Xz5GHUiBHHDRCG3HwzVye7Fdr6JBp4vawIRVA9nhMmqBOJBPFAgLt0gwcMC0kQGDVixGk9P/9GJk2eTMOmLbj7nntzksLPPfccPq8Xl9N5XhMFKVL8G0klqFPxd4pjWbZsGUFFoa9uEFPVXAZl06dNI6aqdLD9BHU9x8ztwdGjSQ+FqV2x4jnRNX777bcJGgZel4t7/vK7//7771OtdBlqlivHxx9//LfP81cWL15Mhqbxsj/I5YZ5Wu8CJ2PHjh2sWrXquAnXpUuXUs7OjkUXBkPkj0a54YYbqK9nd0hOswPULFs2Z/+OzZvzgGElPTssxiU9XY4cOUKL+vWxfD78mnaM8R5kFw49/PDDOT4n3a+4gvwuF09Z2cn4errBtGnTTuuaVq1aRUxVWR6KMMIwqXWW3wdZWVk8OHo0pXSD4bpBUFH46KOP+P777xk0YAAjR4w4bnVw68aNKS/JNFAUShQowJYtW3ItUvz222/s3LnzmOMOHjzI888/z+zZs09Y6fz+++/TqkEDenTqlFMN275Zs5wOwXaWzcSJE3P2TyQSfPHFF1iSxOpwlFcDQSKWddr3oHvHjlxumDxj+4moKqtWrTrlMe2aNqWertNDN8gXjrB///5THvNn0VYHw6CjblC2SBESiQS1KlTgesPkccvGVpQLUgFcu2JF+iY7MGxFOeVi0osvvkj10qVp37z5RatQPhHX9ehBE8NknGkRVJSTyqYePHgQfyhCvobXkqf2lWQWKnLO53P06FGGDBmCw+Ggbt26/xnzxF9//ZWNGzemktP/MFIJ6hTnhX379tHrqquoWrJkjvndiUgkEnz66adc3rIltyeTVN0UlfJuD+lOJ5bTybPPPnvSMdasWUOaqvJ9NM7iYJjoSYKARCJBsYwMWksyV8gyhVyunArt/fv3U6pgIarZNlFV5dFHHmHr1q3kCYUoZdsEDYMvvvjilNe/fft2NK+XrdE4m6NxnA4Hl1Wuwt13380tgwezYMEC/vjjDyZPmsQ1Xbowd+7c7ICgUiXy+nwERZE6kkz+eJxPPvmEoNvNlmicT5PaeZVLlqRJ7dqULFSIHt2706dPH4JOJ28GQrwWCKIKAlHbprCRXYXtcTjwOBzoHg9xw6CDJDPWtFAFgT6KytfhKIbXS9WkpMNE0ybD6STN5aKiLONXFJRkdXRpn4/+N9xA4Xz5qKoblDAMGl92GZIgMMsfYLhu5DL3yIxkmxJui6VR1rR4/vnnCSsKrSWJ+w0TJZlUt5Oa5P97Hz/44INcgejPP/9MjXLlmGBmB+/tJZk8opOiLhcDtezg/S7doFvnzmheL19FYnwajuIWBMKWhSkIOfMp5spuIyzndtPY50NOam2PMy18gsC6des4dOgQdatUIU3VsBQlp5Jg69atOXpzGzduxK+qVPNJqH95Xnt06kR/w2RTNE55t4eRenYgm2kYuSpLqpcpwyTLZlM0TgGni4be7AWa5aEIG6JxtGTV/IpQhKXBMC6HA6fDQabTRcy2KZg3L0M1nbxOJ51lheqKiuZ0kuZ08logyKZonDSnk1tVnTKSxP3/4/g+b948bFmhsGGSJxwmIIo8ZtlU8XjIFwxSIBbjJX+Qb6NxorJCgeR9/jQczWl1vOvOOymm63QzTMKmyYcffkj5okUxJImBN9xwTHCwZMkSxo8fz4YNG9i6dSsZ0SgBnw9FEEh3ulBEkdEn0X0/dOgQTkFgQzTOxmgcRRCoWqrUKf82/428+uqrmJG8FGh3G4GM4ox9aBwHDhwgatv013TCTicOh4OBAweetalTitPjp59+YtGiRadlipTi0iaVoE7F3ymOZejttzMgGQOM1M0cI+o/Wb58OZMmTcpJTn/88cfEVZWFwRA3GiZN69b923MoEI/znO3ns3CUgCyft67P/2XsAw9QtmBBOrdte87ks/5MZP5V13rfvn0USU+nke2ngK4zctgwPv30UyKqyiTLpoWZO0G+cOHC43p9vPHGG5Q2TTYmTblr/8/f57PPPEMeVaOLZeFXVdavX8+2bduImyZtJIkXk92Ypyud9s4771DcNNkcjfOCP0Cp/PlP+z4cPHiQ8ePHM2LECLZt20ar+vV57E8fHttmzJgxpAWD9NENGikq+fx+Hnn44ZzYMpFIUCwzk5qSRBmPF1kUsXw+qpcrx759+xh5553oXi+a18vE8eMBmDlzJuUKFaJxrVpnVbXav3dv2hsmS4JhShgGc+bMybV98+bN2JLEF+Eor51hgrpKiRK8kKzAref3n1Dq4k/27NlDheLFUd1udEk67YKfvXv34nO5coq2FHd2YUjUsnKqmQub5jlf8DkeW7du5fJmzahTseI/XjN5//793HLTTbRt3JjXX3/9pPv+8MMPyJpJpTvfoOLtryGKzvPWffhX88S/q6WfIsX5IpWgTnFeuPH662lumMz0B8jQ9GPaAI/Hp59+il9VqeIPENA0NJ+PkCzTunHjU35Rb9myBUuSWBAMMda0TllxvWnTJixVpbjXRylNo1+vXjnb9u3bx2uvvcann36a83979uzhgw8+YMeOHccd7+WXX8bWNAxZ5rlnniGRSFCldGmaGia1vD6KuVwM1Q3Cuk7H5s1ZsGABj02cSDFd527DJKqqNGvYEEkQ0ASB3oqKKAj8/PPPZGVlUbtSJcqqKmluN8UyM3nggQdyBQv79++naEYG5SUZv8tFlYoV6aUbFHa5uEnVGKkbqC4X8+bN47abbybN46G0240kCHRWVUYbJoYsk+GTeCcYposkYzkEirpcZDqdyIKALIj4HA5KFy6Mraq0tWxMr5fByUrpJ554goKxGNXKlMlJvs6ZMwfN7SbkdFLB4yUgy9kmhi4XmiiiJqvBI5rGPffcw9y5c3M+688++4ygrlPSsgmZFhVKlaJW0vXcdrmwRZH2kozPIfCiP8B0O4ApCNyuGcS8Xp5//nlK5s+PKgjIgkCBZGW5LYpcJSs8afmxBBHDITDayG7Bq1+3bk4iPmLbvPLKK8yfP5/ySRO+Jy0/1UqXZsK4cViSRERRuPaqq0gkEvz000+89NJLOVUoAF0vb88thsmWaJwakkRxSaKHbpAejXLgwIGc/RYtWoRPELAEkUyXC9nhQE7en5jopKTLTSHRiUsQ8LlcFHK52ByN001WUJ1O6ikqAVGkic+H7HYzdOhQnnriCTSfD0kQiEsyIUVBFATqVqlyTOVJtdKledr2szUap5JhoLrdVPd4qeL10rxePV588UVMSSIoy3Ro2ZKIZTFYN2hrmDStexkAGYEAryTNdWob5glbGfft20e/fv0IyzJdLJuApvHtt99y8OBBiuTJwxx/kK3ROKVNk8WLF5/077hVo0ZkulyUcLuJuFzccuONJ93/38rIkSOJV29P5WELSG/Sl05durFp0ybCyQWnL8NRBIcDh8NB7dq1T8ssKcWZs3r1anTLT7RwOaxAiA0bNlzsKaX4G6QS1Kn4O8WxzJs3j7zJuLGIrjPlqadOuv/rr79OBSu7M3GGHaBC0aJ/ew55g0HmBoKsjcSIKsoZS0lcSvTp2ZO4qmJ5vUQsiwY1arB582Z27drF1KlTWbhwYU4SdtasWTSuWZP+vXsf4xO0du1aXnrppVy/70uWLKGwYbA2EmOUYdKgWrVcxzSvW5dJySRwJ9vPo8nu0127dtG5bVvKFynCxAkTTvtajhw5QqNatbK7YmX5uJJuJ6Jjq1bUNUy66QbpkSjjxo6lkK5zo6rhV7K1iAua2UUen4ejKA4HIa+X5k2a8P3337Nnzx58LhdbonHaShK3ajpbonHqWxYPP/wwqsfD6nCUlaEIktudIxHxgj/AQMOkVoUKx8xp3bp1lCxQAF2SuPWmm0gkEuzbt4933nmHjRs38vvvv9OuaVPyR6M52/+XYbfdhuR2o/l8OffjwIEDx7zXPvfss3Rq3ZpHH3mERCLB5McfJ03TaGL7yRsOn7LiddKkSTQysw3UbzdMrmzX7rTueyKRoGyRInQyDCr5fOguF5VKlKD31VdTQNepZduUK1r0jA1FU5w+R48epWKV6kSKVCKUvxQt2pzeZ3e2rFixglAohGEYvPXWW+f1XClSnA2pBHWKE5JIJJg9ezaDbrzxjF1+m9ety8RkhWs722bSpEmnddyPP/7I4sWL2b59O7t27eL7778/7baMp554grRAgJL58+dKLh+PJUuWcP1119G9e3emT59+QjPF0+Ho0aMYssy8QIglwTCaz8e+ffvYs2cPd955J5rbw9fhKJ0lmRoeLw8Y2e0+zerXZ0yyJa+3bqC43XwTibEwGEIXBPLH4znXfvDgQV599VUmT56MrSh0sv2EFIU333wzZx579+7l1Vdf5eOPP2bYsGGUlmVEh4MNkRhbonH8ksTWrVvJyspi7JgxNK5dm3gwiO12EzcMpk+fTvcuXZAEASOZ1F0VjtBP1WgryWyNxrlGN6hXuzadkwHtI6ZN6wYNTnhvqpYqxXO2n5f8AfJKEhmywvfJyoqMUIjhw4fzwQcf0Lh2bSpZFqVNk67t2wPQtlkzCrtcFHA6UQSBy7xeFEGgiyST6XTxsGlxj2FiCQKtJYnbNR2Pw0GRzExeeOEFfvrpJ0yfj3eCYRYFw7gdDnrKCtfLCiFRJCyKhDweVJcLvyRRvnhx6lasSJXSpWmjG0yybIKKwtSpU8nUdT4KR7jdMGlSqxaGJPNeKML6SAy/JPH2228ft5Vu/fr15A2H0b1eapQvz8iRIxl6221s3bo1134///wzhtfLimCY7yMxnILAwIEDqaZpLAyE6CkrWD4fS5cuZfz48TTSs3Wem/gkqiflOF7wB0jTcwcbhw4dYtSoUfTv148ffvjhhAFmywYNGGCYLA2GSdd0+l53HfmjUepVrZoz1507d7Jp0yYSiQRff/011/XoQcumTel73XW88soraE4n9b0+7jFMJEE4bnLuwIEDlClchDI+HxFRZIRu0OEv3w8FYzFuVDXmB0L4PZ5TaidnZWVx7733Ur9WLe69++7/jK7a//LZZ5+hGhZplZujWQHmz59PVlYWFUuUoJFpUdU0ad+8OVOnTsXn8xGPx1m5cuXFnva/jl7XXU+eut2oPGwBsWrtGHrHHRd7Sin+BqkEdSr+TnF8XnjhBXpccQVPPvHEKWP0AwcOULlUKYqZJn5ZOaUW6+nw4osvovt86F4vfa+55h/bvv3bb7+heb0sDoQIiCKXeb2YgkjBvHnPyfiJRILrevTAJYpkRKPHxFR3DhlCDcNkvGkRVdXjSoCcKVlZWXz55ZdnvBBuKQqf/UU/efXq1cyaNYvbhgzhgw8+YP/+/eQNh+mpalzm9ZEnKXF4naoRDwTYu3cvVcuUoYVhkN/j4XpV4/tonOqmyeOPP47q9bIsFOaNQAhdkli+fDlFzWyjyoXBEOnh8DFzalSzJkMNk0/CUTJ1nddff53C+fJRzrLxK8opK2P/ZN++fRw6dIhEIsHAG27A63LlMh1/9dVXydA0xpoWxZLeNJCdSJw+fXouz5j9+/cfVxbmmWeeoZppsiEa5zrD5OouXU773v/2229cd+21WG4PC4MhRhgmVUuXZvHixcyaNeuYxZAU5579+/fzzDPPMGPGjAvyLvNX88QJEyb8Y79DU/w7SSWoU5yQZ55+mvxJN+eQopx2ixfAK6+8QkhRaBQIEPP72bZt23mb5549e5gxYwZvvfXWaX3BLlu2jJCicLOmk6FpTJs69W+d/8iRI3icTqp7PNT3Zlew/ml4kkgkaFSrNiVVDVsUmZls12oaCHJD377k0zT6azp+WUb1elkZimRXAnu8uSpx/+Suu+6iT7K1cpRh0rNz52P2Wb58OX5VpYQkIQkChTxeapoWtSpWzEnE//bbbxiSRFQUuV3LruKOWBa9e/RggJ7tPN3SJ9Fakmjg9dHQ62NTNM4VhkHnjh3Jo2pMtmxqGSZ3/sU08uDBg0yaNImxY8eyY8cO2jVpQm/D4M1AiLAsE5FkPglHedC0qFyiBJCdnDV92eNviMRwiiJHjhwhahjcoelUdHsYbZgsC4Vp55OIJSuni7jcNJBkdEHEFgT8ooguikxNfp779u3DkhWes/08bFpYgoDscDBU07lKNyhXogQLFy5k27ZtdOvUiWamybO2H8vpzKkErpo0+bmxb18MSaJ0wYKsX7+ePMEgT1l+ZvsDyIJIHlUl5vcf9zM7cuQIv/3223GfzUQikWP0U6F4cWp7fVTxeNGdTubNm0ejWrUQBYGIYXD1VVfxww8/5AThqtOJIoqYLhdTLD+XGybdr7gi1/hXtG6TrRNtGOQ7SQXG5s2bqVm+PGl+P8OGDj0tM50J48ZRVNe5VdOxJQnN7aaXotLA60OTpGP2f/aZZyhbqDBhj4cNkRhvBkLERCdRVeX9999n586dyG43VTzZ0j4eUeTgwYN89tln50SzctWqVZTIzCRqWTx6BhVB54qsrCymT5/OY489dowh0rlgzZo1TJgwIVfiec+ePTz++OM8++yzOQHvqlWryMzMxO1289hjj6WC0nPI3aPuIVy0CiV7P06wQOmU7vc/nFSCOhV/pzg+H330EW0aNaL7FVfwww8/nHL/Q4cO8f7775+T3/I/2bNnD7/88ss5G+9isH//fgxJoruscIUksy2WxjjTwnS5zul5TlSEc/jwYUbccQdtGzdm1qxZ5/Scp0sikeDpKVPIDIYoI0n013Sits2ePXuO2Xfz5s1c2akTituNLAg5hoAFTZMvvviC3bt3c//99zNkyBCKpqcjCgKtGzXi0KFDPPXEE6heH6YsM+fFFzl06BBVy5ShvGURU1UeGjMm5zxHjhzhlhtvJOTz8aTlZ3M0TnnLYtCgQdROehJNsmwqFi12Rtf6+eefE1dVvo7EeMb253T7nko250/uHjYspxp71syZubYdOnSIy5s1wymKlC1S5Izfu1esWEFhw2Bz0oOpUFraGR2f4p/H3r17admyJQ6Hg969e/9ni3xSXHqkEtSXGPeOHElGOEyD6tVPK+g7n3Rt3z7HdKOPbjDqJHqwx+Pzzz9n1qxZ57Wd/MCBA5QqWIi6tk1BXWfoLbec8piRI0fSN6l1Pdow6d6x49+aw759+9C9XsaaFoM1nZiZW2Ns0aJFWD4f1Twe0pxOOmk6IcPghx9+YN68edx5550sX76ch8aMQfF6CZsm8+fPZ+itt9KjUyc++OCDnLFmzZpFXkVhomlTwTB46MEHj5nPFa1acW/StKODadG9e3emTZuWK+n4zTffEFMUnA4H30bjbIrGkUWR3ldfzZWGwYZIjJqShCGKlHa5MZ1OREGgSunSbN++nWeefpqmtWtz2+DBuapyyxQuTEWPl+aSTKG8edm8eTONa9WiUDzOg/ffz/Dbb0fxeskfj/PZZ5+RSCT48ccfCRoGow2TOw2T/PE4AIrXy2fhKG18ErIgEBZFdEHAkmWUpCazKgiUcbuRHA6m2n4mWTa618vGjRtZvnw55YoVx+/xoosiaR4vpqJQNE8eapSvkCt4a1CtGk8mDWGKOl0ERZHKsoIkioR8PlRRRPd6uf7qq0kkEowePRpFEHAlzSq3xdIYeIamOZMefRTF68VWVZ566iluvPFGyiZ1uUcbJnWrVmVA377EbJveusE1ukHxzEwSiQTPPfccZXWdJcEw5SSZQtEo13bteowmoqUorEoG8DGnk4Cus3jx4hMGrpMefRTZ40H2eE6ZxG3doEGOPmA3y6Z5o0bIycD5heefz7Xvu+++i+Vy4RdFJEGgjMvNdZpOXsvKeSnat28fms/HG4EQs/0BTFmm6WWXkaHr2LLMM08/fdr39niUKVSIBwyLxcEwflk+LXf3c8nVV15JecOkuWlRokCBi9ouuXPnTpo0aYLD4aBbt26ntSCR4tQcOHCAK6/qTt6MAvS67vqU3vc/nFSC+r8Vf6c4PX7//XcCus59hklvw6BamTIXe0qXNEePHmXWrFmMHTs2VyXsn8ydO5eobRMWnUy1/dTweqlyju/pRx99RKE8eQjoeo7+8v9y4MAB3nvvvbPSYv47zJo1i/yaxoOmRT6fj4Z16+Yq9kgkEqxbty7X4sYnn3xC+WLFqKNqVPP5sHX9uAv/f/0NfvHFF+nUujUP3n9/TsL+wIEDLFiw4Jiu2wkTJlBCVSnpcuMTBIJuDzXKV2Dy5MlEnE7eCoa4SlYISvIZXeuqVatIU1XWRmJMtf0UzZcPyE4OBxSFXknJx3nz5h1z7I8//ojh87E6HOWNQCjH/+V/2bZtG/WqViVfKMTdw4ef9tyOHDlCgxo1yK9nF009+8wzZ3RtKf6ZHD16lFtvvRWHw8Fll112QinTFCkuJKkE9SXEsmXLSNc0FgZD9DYM2jdrdlHn89STT1JA07K1kxWFd99996LO53h8+OGHFEtqbi0LhYnb/lMe8/bbbxNRFO7UDQpqOk9PmXLCfbOysnjgvvu4olWrE1YXbNy4kbCssDka56tIDM//VD488MADXJ2c49WKQplixXLMYwBeeP55NJ8P2eNh0mOPAdCtQweaGAYjdAO/qrJ161a2b99OscxMIj4fqstFjSpVjluxe9MNN9DWMFkcDFPKMJg1axavv/46rRs2ZFC/fuzbt4+srCwa1qyJIYqUdLup7PEQdLmZOnUq1cuWxe100qRuXdo2b07hvHlJs21kj4ebrr/+hBWXH330ES6Hg28iMbZG4wRcrpNqsO7bt48a5cujeTykBQLUqVSJlg0a5Jg23DxgAJm6Ttjl5iEzWwO6oiRjKAq3aDpFXS4WBcO0kSSUpJTJl5EYToeDqG1jqyoPmxYDdYNCaWk8/fTTlC9WjIaWRRXTpH2LFkyePJm7776b8ePHE1VV6nqzDSoHKSpuh4PGXh/fhKNU93gZY5hEFIW1a9dSJG9e0p1Oqnu8VPZ4+CoSo50sc9MNN+Rc3/z584naNgFdZ8b06bmufceOHeg+H++FIgxQNbwOB1ZSI/tJy6KepqG53dygangdAlujcbZE43hdLvbt28cDDzzAlclFiBG6QbcOHY57j5vUrk1rVWOgqhESRap5PKhOJ6bPx313351r30OHDiF7PKwIRVgZiiB7PMdNXO7bt48DBw7w8NixFNN1hmg6AUXhk08+Yd++fcdtPRw+fDh+UWRDNM5bwRCyINCmUaNjEuUvPP88YdMkLRDg4YcfJr+usykaZ14gRGYkcsJn6XTIFwrxRiDExmicDF3ns88++1vjnSmmLLMqHGVrNE6mrp9SvuR8c/ToUYYNG4bD4aBs2bK5vpNSpEhx8gA59e/fFX+nOH2++uor0nWdrdE4q8JRjON0TKX4f67r2RPb6cIrCGguF+vXrz/ufmMfeIBSmZm0bdbsnC8aF0tPZ7xpsTQYxpakY5LQe/fupXShwpSyLPyyckIPkfPBoBtv5NZk9fBQ3aB/nz65tl9/9dVEFAVbknhw9Oic/9+zZw95QyEaKipVdYMOLVqc8BxLly4lqqiMMSzKGwYP3HffSed0Q58+6ILACN3gSllGEwTspOSf6XaT4XRS0e0h4wzj0kQiwQ3XXovsducyXYfs99nRo0ezdOnS4x77448/ong8lHG7KelyYxzHWB7g8mbN6JM0bszQtDN6d8/KyuLjjz++4IsUKS4+zz33HB6PhwIFCqTME1NcdFIJ6kuIOXPmUNPONhKZYvmpWa7cRZ1PIpHg+eefp3+fPpesiP6PP/6IrSg8atn0Ngwuq1LltI574403uKFXL6ZNm3bSFvfRo0ZR0TAYa1oEPB7aNG9+TOXl0aNHqVO5MlUti+KGwbVXXZVr+2effYZfUeijG+TTNKY+91zOtqysLFSfj4XBEMtDEVSvl71791IkTx4WBkN8Ho4SdruxFYVqlSrT1sjWSxuoahT3eAgZBuvWrWPy5Mk888wzfP7553z99de0b96cArEYNw8YwJo1awgqCg+bFs0Mk0Z162KrKpLbTWY0SidZZrxpUdIwclbtjxw5QutGjYgoCrrTyVDd4PNwlIK6kaOZ9r/MmDED2+mkiywzWNWQRfGkLuePPvoojcxsA8EBx9FLSyQSLFu2jNqVKnGTYfJ5OEpxw0DzerlaVmmXrFwebZhYopOgKBITnfRRVYoYBpbbzZZonNXhKB5B4Pbbb8fwetkSibE+EkMSBKoaBl01Hc3lomKJErhEkVf8AdKSGtV60rQy0+nkQcPCL8t8//33lC5YkLjoJL/TSTWPB0kQCLhcOS7biUQCU1aY4w/yVjCE5vOxd+9efvnlF65o3ZpqpUohuVysiUSJJY0bZ9gBrlFUAl4fdWvUoIE/wNZonKIuF40kiWaGSY3kd9tHH32E4nRS2OVCcTqZMmUKbRs3pkOLFrkWBX7//XeaNWpEmsdDE68Pj8PBmkiUT8NRvC5XrnauPxPUy0JhVpwgQX3vXXchud2oXi/Tpk7lmWeeYUDfvicMqP9kxYoVyILAslCYxy2bPP7cC0lHjx7lpr59yRMI0KJ+fXbu3Mn69esJyDILgyHuMUwqJSVhzpanp0zBkiTyaBptmjT5W7rzZ0OtChXoYZjcZZgEdf2kfxsXknnz5mEYBrZt/+Nd01OkOJekEtT/nfg7xelz+PBhyhYpQkPLooxxYjmCFNnokkQzn5Tt46KodGjT5oLPIS0Q4M1AiO+icfJoGl988UWu7S+//DI1kkbZz9p+ql/AqvglS5YQUhSuM0zCisJbb73F119/zdSpU1mxYgWmz8e6SIwPQxEktyfnne37778nmjSCXnuc4qC/ctttt9FU1fguGudh0zplAdhLL72EXxTZGo2zJhJFFgTuNUw6tW7N4P798blcmLJ81jHTnj17zlhO4fDhw2heL49ZNuNNC1tRjhvH1ipfniet7M+ypm3nvJf8m/njjz8YeMMNNKpePdc7doozY8WKFQSDwZR5YoqLTipBfQnx5wp2ScvCryjMnTv3Yk/pH8GiRYtoUK0andq04ccffzynY1/etCnjzWyZkytlhRpeH3nD4WOqRA8cOMDVPXrgcTpRvV5m/0+19SeffMLdd999jKFGVlYWktvNilCET8NRFI+H33//ncH9+5MuSYRFkc6ywgehCHGfj6qywgTTorrHQ09ZoaHfT+G8eWlomMQ8HvwuN5YkMfkv2qdz5syhflL7erY/gOx0MscfZGUogubxErFtPE4nV7RuneMqvXz5cgoZBhujcUq63Dxu2TkabK+99tox92nmzJlYkoRfFFEdDjSHgwI+H/f+pUp35cqVVClZkiolS7J8+XImTJhALUVlczROX92gWYMGx3Vi37hxI+WKFEVJSmxoPh9yUuKjiMuN7vEwatQo6larRjVVpb9uELVtDJeLyh5PdhJXEKgrK/hFkeoeL30ME83pYkUowrZYGsVcbroqKhnhMF6nE9nh4DKvj63ROLdoOroo4nW5uP+eewB4//33sVQVVRDor2osCIaIqioff/wxU6ZM4f7778fncvFxOMqXkRiqx8PKlStpUqcObVSNCYaF7najJpPbJdxutkbjvBYIUjAWY/PmzfhVlRs1nXK6Tt1atRg7dmyOJl/fa6+lu67zgh2gjqajyzIjDJMhhkmBtLScAP7FF1+kRpkyhGSZsi43HoeDNwIhXg0E0SXpmOD2ycmTcyQ+JiXd3P/k119/RU/KriwKhjFk+Yz0i0cOH47u9ZEWCPD+++8f8/yUNgyWhcJcYZj069ULgEcnTCDNH6BckSLnpOJ469atrFmz5oInpwF++eUXenfvzhUtW57SxPVCs2HDBkqWLIkgCIwaNeqi3J8UKS41Ugnq/078/U9h3759l4RvwJ49e5gyZQovvvhi6vfiFBTJn58GXh9bonG6KwrXXISE/tNTpmBKElFFpVObNsc8QytWrCBvsoP3OsOkXZMmF3R+y5cv55577mHZsmWsWLECv6LQOhDArygoHg9vBEI8Z/sJW/8vofjHH38QtW1u002uOUkRw+zZs7EkiXSXi5jTSZqqntJ76PDhwxTLzKSBolLc7aaR10cLw+SWm24CsrXDL7SE165du1A8HjZE46yPxPA4nRw4cOCY/ebPn48tyxS3LMoWKcLevXsv6DwvBgNvuIFGhskTlp/YOTL7/K+yadMmSpYsidPp5JFHHrkkfm9S/PdIJagvMf7UADuXRiIpzp5pU6eSR1W5SlawBZFFgexE5P+2P+3atQvV6+X9UIQFwWyH6NP5Ut+9ezfD77gDxeNB9XgYndT5njNnDmmSRBm3m/uSUg51PV5UQaCQy0UJl5vCLheGz0dAkng7ECIqOvkuGmdxMEzYNHPO8csvvxC1bTpYNvl1Hcnp5O1gmC8jMUyvl7Vr1x5jNLN69WqiisKHoQjXKtlazBFFoX716sfVzi2WLx8v+oNsisbJ63QSEUUKOF10aN0ayE7EBw2DR0ybR61s2YvObdsSdblwOhzIgkAhVUN1u2nXpg27d+8+5hz79u2jYc2aCA4HmU4nE00T1ePl448/zrmXdWvWJDMS4fZbb6VG+fJc5pOo6/GSRxDJ43TS2OdDFgQ6tW1L83r1aK7r3KLpBESRNwMhbFUlqOs08fmomAwEr1FU2jZtluvzTCQSrFq1ijlz5lC9bFkiuk7NypVp0aABVQyTK5JVsqbPh+HxoLtchGUZVRRJdzrxiyKFNY2pU6eyZMkSTI+Hkm4PIa+XR5L6gKtXr2bwTTfx2GOP5Swc/EmfnldzvZFdfd7UMPA6nWyOxvkuGscpihw+fDi7AllReMb2c5WiEhZFWvokbCFbB7p506bHfSYPHTp0XJmO3377Dd3r5eNwlLeCIcwzTFCfjEceeYS2VvZC0L2GedJWzRTnh3379tGpUyccDgetWrW6ZCq8U6S4WKQS1P+t+PtSZvfu3VQvVw6vy0XJAgX46aefLvaUUvyF119/nRaXXUa/Xr2OMffbtGkT+QIB3IJA/nj8gvgLLVmyhPHjx+fqqPvxxx9Zu3YtiUSC1157jQbVqnH1lVeyfft2Hnn4YUrky0dQVal/jjyQFixYwJ133nnG8pDXX3MNQ5M+Qf01nVbNmxO1bDKjUd55551c+3711Vdc1b4Dvbt3P2GBUsVixZhuZ3ckllVU7rrrrtOax++//85jjz1Gy6ZNKZo3L1e2a3fRk71d27ensGFQQNdP2rmwZcsWVqxYcdwE9r+RRtWr80TSR6it7efJJ5+82FP6R7Nnz54c88TrrrsuZZ6Y4oKTSlCnSHEKFi5cSJH8+amqanQwDIplZh6zcr59+3Y0r5dV4SjLQmEUrzenqmTOnDlUL1OGDi1a5DKM/OSTTwjqOnk1jTKFC7Nly5acbX9qso03LWRBIObMlpNw/cXUUBJFyhUujOX1cp2qoQoCi4JhHjFtiuTNl2t+W7dupU+fPtSrXRvJ6UQRBGRBwC9JKB4PiseTyzjl8OHDZESj2Zp5osj1vXvz7bffnrBSplrpMtxtmCwLhdEFgYmmzc2aTlCS2LZtG/v378frcrE+EmNDJIbkdpMvGOTdUJh+ikpQEIiJIt1lhSaSRIPq1Y85x6hRo8j0eKjl9VLN4yWQrII4fPgwa9as4a7hw6limDxr+yms6/Tv3x/F6STsdGEIArOSVeTV5GwduSvbtSNPIEBIVSmqaaRrGn2uvZZM3eD7aJwqHg+Cw0HQ6cSUpFxmlQNvuIG4qpJH06hapgxldZ0ybje6IHCTqmVXZVsWN998Mz6nk86SwkBVo6bXy9ZonNGGiS4IqB4PTz/1FPv27eO1117jk08+Oa1ncvPmzRRIS0PzeKhapgx1KlemumVR0bS4vHnznOe2kp1tYvhaIIguCDxvB9gSjVPUlb0Q8CfjH3oIzefDr6oMGDDghEH4mPvuw5eU+Jj5wgunNdfT4ddffyVvKERm0pCmcpkyx02SXyi2b9/O9OnTWbFixUWbw8UgkUjw8MMP43K5KFSoEF9++eXFnlKKFBeNVII6FX9fKowZM4YWyUXpnoaRy+/iQvPrr7+yYcOGs1qgPnToEFd16EDENGnXtCn79u0743NPnjyZefPmXTKVfWvXriWgKEwwbdoYJledwBPkQlW/Pz1lCnk1jSsti4CmHSNL+GfxwiTLprNhUq18eQrqOk/bfqoY5in1mU/E4cOHGTJwIHUqVKBnt25EFYUBmk5IUY5JLJ+M8ePGUckwmGEHKKUbPPfcc6xfv54xY8Yc08GZSCS4e/hwCsXjtG7YkO3btx8zXvN69ehnmLwVDBFPdjoeOnSIBQsWHNPNd6lz9OhRli5dyrJlyy7Is5RIJLhzyBDyBALUq1r1nHcpnyumPvccMVWlre0nbJq53qdTnB1ZWVnccsstKfPEFBeFVII6xT+SRCLBd999x86dOy/I+f744w/GjRvHPffcw2+//Xbcfe4eNgzV40H1enly8mQgu3U+oCg8a/u5xjBpdtllOfu3adSIhl4fjbw+SsgyTz31VM62hQsX4vf50ASBDlK2QcdNySrYoZrO3YaJJAiM1g3KShLpkQg1K1UibBgUyZePDz/8MNfcFi9eTDRpDBlzOhmlmzxj+XE5HHwUzjbFk9zunOroDz/8kMJJveslwTB5AoGcsRKJBK+88grjxo1j8+bNAHz55ZeULlgQv6IS8XjYEo0zNxAkLIqkGQYTxo3jmq5dKaDrFNB0OrRqRc/OnSkkScScTrrLCpIjW6N4QySG2+lkwYIFTJ48OSepX7ZYMWp7vUwwLUxB5MqOHdm3bx8VS5QgQ9cx3G5GJavNe+sGmWlpPGpla7pH3G5aSjJPWH6CikK75s1pZ5i84A8QV1XGjBnD+PHj6dG5MzHLop1hEnU6uVFR2RZLY4im5xi3HDhwAK/LxdeRGGsjMdyCQGW3m46yzCv+IGHRSRdZQXW7MZ1Ookkta5/DQf6k7EcPRUETBIq73Che72k9g6tWraJ39+6MuPNO/vjjD44ePcqOHTtIJBIcPHiQGTNmMGvWLL799ls+/PBDdu7cSZH0dKoln5vLPF6U5GKH7nLlSGZs27YN0yexIhThOduPKYpULlXqhIsRBw8ePC+r6a0aNKCnovJxKEI102LGjBnn/Bynw86dO0mPRmns95Omqjw2ceJFmcfFZNmyZYTDYRRFOaE5bIoU/3ZSCepU/H2pMHr0aFoZRraOsW4w4PrrL8o8Xnj+eQxJIqIodGzV6ozlPSZMmEAtw+DDUITmhsnwO+447WN3795NRjRKa8umiG4w/Pbbz3T654W5c+dSJ1kA8Yo/SLlChc7Z2H9WO0+cOPG0k4NNatVispVdnNDB9jNp0qRc2998802q+f05xQthy6JXsmL53pMk2E/FfaNGUcMwmWYHSPd66SDJbIulMVDTuW3IkNMeJysriztuvZXa5cszasQINm7cSFDX6WaYFNB1Hh47FoBHH3mEkunpBN1uXvEH6GKYXH3llceMt2XLFupVrUr+aJSxDzxAVlYW9atXp4xlkU/TuPMM5vZfY9GiRRTQdZYGw/Q2TK5IdsVeiqxYsYKnnnrqpMnpnTt38tprr/HVV19dwJn9s3n22WfxeDwULFiQtWvXXuzppPiPkEpQp/jHkZWVRetGjQjLCqYk5Rj7XUj27dvHkEGDuLJdu1xaV7t27crV3rdkyRLKJ6tYXw+EKJo3b862iqVKUcbt5jHLJiQ6ue2223Kd49prr6WHll2NO9a00AQBvyAQcbnIY9tU1HQiopP6Xh+G08kLJ6loHTZsGP2TLtn3GiZ+txvF7cYjiCwLhVkaDCN7PBw+fJh9+/YxcuRIZLebp0yb6zWdqqVL54x178iRFNENrjQtTEmiQCxGg+rV2bp1K4cOHaJ4/vykO134RZErJYVybjcZmsaCBQu47dZbUTwebJ+Pa7p0oUR6ek5bViufRBWPl5a6QWYsRh6vl+aaTp5gMNtkz+mkgMtFXqeT0h4PkydPZsaMGdRJGov2UVR0p5PL/QH8qkrD2rW53jBZHoqQqWm0aNiQBtWqMXv2bOpWrMjTdvZ5m9h+Ro0aRVBRGKEblNY0alSrhuRyUcrtZoYdoKjbzaPJROVXX32F7HLxjO1nqu3H43CgOxw5LwR1FYWaVapgqyox0cmL/gB36jqGw4HXISAJAqpD4DHTZrRhoojiKZ+3n3/+mYCmMUQ3aGQYdL28/XH3e37GDGxZppBhUKtiRX799Veu7NyZCkm5lhqqxuVt2+WSdPn2228JyTLrIjEWBkMERRHL5+Ott966IK2of9K+WTOGGCbfR+NUNq2TPs/nkgMHDnBFq1aEDZOOLVsyc+ZM6iRf3mb5A1QoWvSCzONS44cffqBatWo4HA4GDhx4wfUWU6S42KQS1Kn4+1Lh999/p1LJkqgeD0XS0y/ob/NfyR+N8mogyHfROBm6fsZ+CsOHDaNHMhk6UDe4Iek3cTosXryYSsnf5reCIQqnpZ3p9M8L27dvJ08oRJukjN4D9957zsYeNWIEhXWd9pZNWjB43Arh/+X2m2+mlmEywbSJquoxVcK7d+8mfzxOE9tPhqYzsH9//KpKB3+AkKKctfFf944duSdZJHK1puP3eLnHMMmjqn/rPe25556jVXIBYKrtp06FCixdupS8msZMf4BmPolussJE06ZxzZqnHO/rr78mTVWZHwgy3x/EUpSzntuF4o033qBj8+bcMWTIOZXtWLVqFQXiaahe73EXfJ5//nnqJt+xHrNs6lWpcs7OfaH57bffSI9GqeXPLlSaM2fOxZ7SP4bly5cTDAYxTZOFCxde7Omk+A+QSlCn+MexbNkyiiQN/KbbAUoXKHDez7l06VIefPDBHOfrrpe3p7lhMsow8atqjt7X6NGjcyWs9+/fT/H8+alt+8mjaox94IGcba0bNeLBpAHjVYpCv379cq1OLlq0iDRVZZxpUVrXuaJ9ezq1bs3woUPZvHkzms9HQ6+PbbE0nrD8VC5ePOfYlStX5prL0qVLCSsKt2g66arG5e3aEfD6MAUBr8OB2+HgumuvJZFIULNCBWpqGrUUBd3pRBJF/H8JcssXLszL/iALgiFsUWR+IES/v1SH79y5E0kUUZNjT7Zs2hsmEydOJGQYLAyGWB+JEZQkNLebMm4P9xsmmiBQomBBbh40CMPp5NVAkG2xNCrLCo3r1WNwMsHeSZYxFIXt27fz+OOPU0hR+TgcpZ9h0qhOHUaMGMELL7zA+vXryWNZSIJA8YyMXLIVz8+YQURVqe8PkDcc5sEHH6RDMmE9xfJzWZUqGJJEO0mikMtFzLLIysri4MGDxAMBOsoKYacTVRAYa5pMNC0UQaCKYZARjbJ9+3YqlCyF5BBIczqp5PGgCAIhw6CvohIQRTZG43wcjiK73ad8/t5+++2cF7O3g2Eimkaa30+NcuVy6dUXzZuP2zWdj0IRSpkWS5YsyU7Atm5NxDS5olUr/vjjj1xjJxIJrr/6ahRRRBYEGvskDLebTF3HkmVeffXVU/+BnIREInFayc1169aRGcuunm/bpMkF0zy7f/RoGhgGH4UjNDAMBvTvT0hReNr209Ew6dy27QWZx6XIoUOH6Nu3Lw6Hg9q1a+eSKEqR4t9OKkGdir8vJRKJBLt27bqopoSlCxbkYdPi/VCEkKKwbt26Mzp+y5Yt5AmFKGFZhE3zuMbYJ2LTpk34FYVxpkVH0+TyZs3OdPrnjZ9++olJkybx5ptvntNxS2Zm8loyFq7pDxxjtH48Dh06xLDbbqNNo0Yn7IDavn07zz33HEuWLAGyZT+eeOKJv2XgvGjRIgKKQptAgICmcc+oUVzTpcsZdWH9/PPPNKxRg7zBIENvuYVEIsHq1asJKgoPGBZ1DJPB/fvz9NNP0yLpWzLZsom43fgV5bTu/9atW1FFJ+lOJ5ogkB6NnvU1XwjWrFlDUFEYY1jUM0wGXHfdORu7SsmSPGBYfBKOElNVVq1alWv7nj17KFWwEMVNC1tReOutt87ZuS80U6dOpUnyPe8Jy0/9f3Cy/WKwcePGHPPEif/BztIUF5ZUgjrFP45PP/2UNFXjk3CU0aZFtb9U954P5syZQ1RV6Wla+BWF1atXUzRvXhYEQ2yLpVE9EOCBBx4gpCj0MkxCisKiRYtyjt+zZw9z5sw5porh5ZdfJqqqXGlZ6C4XaYpCWFEYNWJEzj7Pz5hBw5o1MXw+8mga5YsVy6nQbt6kCUFRZJodoInPR4Wkg/XSpUsJ/mUuf652Ll68mME33cTLL79Mo+rVaeLzMVjT2RSNc6emc/0117Bz504UUSQsimiCQFgU+T4aZ4JpU75IEQB6XXUVjQ2THrJKMbebrdE4M/0ByhUunDPvsKpSy+OloyRjCAIBTWPLli1kRCJMsfwsD0VQnS76KyqZTifl3W4eMS3y6zqdrrgCSxTJcDq5R8+uMO519dW0MQw+CUepqqiMHj2aW265BUkQkBwOvIJAhWLFGDJ4MFFFobBhULxgQeoaBh+HozQzTEbceSdZWVm8++67fPrpp6xatYrZs2ezfft2vvnmG/yqSl9Np3CyhXDevHmUKlCQUoUL5wTxmzZtIqwobI3G2RCN4xMEptkBlgbDKB4P06dPZ+fOnSxevJignH3tS4JhtkbjFJBlArrOkkCIxl4faU4nAZeb4UOHnvIZ3LFjB1HbpqduUFHTsN1ulgRCDNB0imdk8OOPP/LNN9+gOF1U8niwBJGAz8fnn39+2s/5Rx99RNcOHahfqxZlDIMt0ThTbf9ZVxB/99131KxYEUkUcTocpFk2K1euPOkxiUTigpu63Dp4MNclK7qu13UG33RTdhV1hQr07NyZXbt2XdD5XIpMnToVn89HPB4/5WeYIsW/hVSCOhV/Xyh+++037r33XsaNG8f+/fsv9nROyMcff0yBeBxTlhlzllrFe/bs4aOPPjqr39bFixfTsn59+vTsec5/m3fu3MmHH354jMnh6ZKVlcXu3bvP6QJC18vb08oweci0CCgK33777Tkb+1yzevVq8obDeF0u+iUl8c6Urpe352rDZGkwTCFdz0k4v/7661zRqhX9r7+e+tWqUbpgQRSnk5peL5YgosnyaS+WzJ8/n7K6ztZonGdtP5og0KZx4+MawF8KzJgxg2bJCvLn7QA1y5Y9Z2OXzMzkeTvA99E4hQyD995775h9Dhw4wMqVKy9a18a54t133yWfpvGyP0hHw+SaLl0u9pT+cezZs4cWLVrgcDi4/vrrU+aJKc4bqQR1in8kw267DdXrpWBaGqtXrz6v5+rcpg1jjOyV+msNg9GjRzNk0CBKGQZXmiYxv5/re/fm1mSF7+2awYC+fU857q5du2jfsiWlCxZEdbvZEI3zSTiK5HbnMr9o06gx9yb1oBtYFk8//TQA06ZNI+L1UcTlIuj25Pz/4Jtu4ubkXIbqBv2Os9p+6003UUZRsEWRAapGWJJ47bXXWLhwIZkuN5uicZ6x/ViCwPpIjNGGielykUgk2L9/P0MGDaJdkyYUyZeP0pZFQJaZMX16zviS281XkRjbYmkERZF80SgHDx7k7bffJi0QQJckGtatS0vDpJTbzSTLZlM0TqYkYbo9vOAP0F1RsESRpg0asHv3bppdVo+AptG1fXv6XnMNeZISHJU8Hqq6PXTp0gW/prE8FGFTNI7h9tAzeR8G6Ab9+/ShVaNGFDEM0lTtmHa2VatWMWzYMGbNmkUikWDbtm2kBYNUS0qGLFu2jKysLMoWKUIL06S2aVK9QgXi/gCmLDNx/HhGjRiB5HZjShK3awbVPV6uU1SmWH5sWWbY0KHogkhhp5OSLjem18vGjRtP+pzs2bOHL774gq+//prBgwdjaxpeh4MMp5Oxhkkep4uwYZIRjXJ90qBxkKpRp1q1XOPMnj2bInnzUql48WOqJP7Khx9+SB5NY1kozBDDpNFptEwej7KFCxMVnUyx/KyJRAmIIgFdv2SMjf7ku+++I+b3U8KyiNr2Jf0CeDFZtWoVGRkZuN1uHnvssUvuc0yR4lyTSlCn4u8LwZEjRyiePz/tDZOGhknTunUv9pT+tTw5eTIFYjGqlSmTK6H55ZdfEjIMSlo2eUIhtm7detpj/vDDD5QuVAhJEPAIAumRCOvXrz8n892zZw83Xn89bRo1uuRb66uWLs1ow+STcJQ0Vcupxl66dCllCxUiIxymU8eOfPPNNycco1GNGjxiZktKNLBtpk6dmrMtkUiQHolQyu2mqyTjcDh4xLRZGAgRkGW2bdt2wnH/+OMP7h01ioH9+zNz5kzyaRrvhsIMVDXqen3UNE2efPLJc3czziHbtm0jZBh0MS0K6joPjRlzzsZ+7bXXMCWJsKzQtmlTsrKyztnYlyIPjx1LuUKF6NSmTar45Cz5q3livXr1LpgXWIr/FqkEdYrzyuOPPkpmJELV0qVPubr9zjvvUCAeJy0QYOYF0p89HcY+8ADlDIOHTYu8araWciKR4IUXXmDMmDFs2bKFmTNnUkDTeMi0KKTpTJ8+nanPPUetcuXo2bkzv//++zHjtmvalA6GyRgjW4biCdPm8aTO3F/p1qED1xkmn4ejlDVNXnzxRSA7WJv8+ONc0aoVT0yaxK+//sr06dMZOXIkBTSdcaZFEV3n2WefPebcBw8eZOgtt1C9fHnatW2b07Y1YcIEgqLIp+EoI3SDmCjicjjwOQScgpCrwiCRSLB582beeustli9fzmOPPcb8+fNJJBLUKFeOFj6JG5RsHeZ8qspDY8ei+Xz43G5GDhvG3r176dCiBWHTRHG50ESRgNNJCbebbbE0XvIH0UWR2bNnHzN/2ePh83CULdE4YVGkvsdL8+bNKZaewb2GxYv+ILrXSzwQoJhlEbEsFi1aRERRcqQ1NJ/vpJ/7uHHjuCIpwXKfkS2PAdlakOPHj2fy5MkcPHiQAwcO0KROHVyiiC6KfBKO0l1WyOtyMVw3CLhcFM+XzoABAxg0aBA+h8BNqsYr/iC6z8f27dv57rvveOONN9ixYwdHjhyhT8+eZITDtKhfn7BpUsAwyYzHiQaDNPD52BqN01tRUR0CN2saAVGki6xQ1u1hQTBELcPgig4d6Hr55TwxeTK//PILpiTzoj/IA4ZFkXz5Tnrto0aMIGKaVC5Z8qwTtprPRz6nk5n+AOsiMeJOJy6n85IMgHfv3s3HH3/M7t27L/ZULml27NhBkyZNcDgcdO/e/Ri5mBQp/k2kEtSp+PtCsGnTJiLJzqxvo3FcophaADwPbNiwgYAsMz8Q4g7DpFqZMjnb+vS8mluSnVTddYORI0ee9ri9u3enriRR3eNlUzTOLbpBpzZtznh+v/3220mTrJc6pQsUYLodYGM0ThHDYNmyZRw+fBhbVXnS8vO4ZaMJAkFdP6GW9qJFi7AVheKWRfH8+XO9O40bN46Y6ORh0yLT6UIRRWrpOs1MiwrFi5+0cv2K1q1pYBj013UilsXQW27B8HhId7p4PximmWnxyCOPnPN7cq747rvvGDt2LK+99to5/27YuXMn33//feo7J8UZ8cwzz+B2u1PmiSnOC6kEdYrzwh9//ME333xDSFF4MxDiTsOkxknakhKJBCHT5Fnbz7xACN3nOyfJoiNHjjBjxgyefPLJXBrEZ8LRo0d54L77aN+sGdP+spr/VxKJBE8+8QTtmjZl7JgxzJ07l4DXy3O2n8sNkx6dOh1zTIFYjEXBMNtiaZTRdWK2nxKZmcdIgWzbto0qpUqh+Xxc3aVLToLv6NGjLFiwgLlz5/LTTz+RLxymie0nTdW46souXNGqFZNOs9Lx6NGj9OrWDdHhwBAEZEFAEQSetGzeC4bxOBz0vPJKPv/8c7Zt28aRI0do1agRhs+H6vGgiiJxl4t0VeXekSO5acAAbEGghMvFAFVD83iwVZX5gRAfh6N4HQJXtm+fM7cFCxZQ3DBYF46S7nRSyu0mLIr0VTUCun7MfEsWKMCtusEE08bncOBzOCio65QrWozKJUpSLF8+Zs+ezd69e/nggw8YP3489957L6YkMd0OcJ9h4pck3n333RPek9mzZ1PCMJgbCNJENxg8YMBx93vqqacoKsu09PkICgIbonFesgOEDIOOLVvSvWtXShQoQDXDIOJycYumkeF0oQoiNw8axOLFi/ErCjX8AdKCQR544AGqGAZLg2HqyzI1vF62xdKop6iE3B7qeLyM0A1qeb1kulzU8PloJclsisap5/USlCSa1qtHuqpmJ6N1ndGjRxNVVDZG47wfilwQU5j+vXuTJst4HQ68DgeW282QgQPP+3lTnF+OHj3KsGHDcDgclCtX7pQdAClS/FNJJahT8feF4ODBg+QLR7jBMOlsmFQ7hy3855ply5bR77rrmPT44xdVC/tsWLlyJYWT8mWvB0Lk/4v28B1DhtDCMFkZilDdMHjsscdOe9zuV1xBU0n+WwnqJydPxvD5sHzSOdUYPpfs3LmT5cuXnzC5PG/ePExZJiwrtG7cmKysLH7//Xdkt5sNkRhrIzE8DgflbZulS5ee8Dw//PAD77///jEL4EUyMnK8aO7QDUK6zmOPPcYjjzxyyvfFmG2zMhRhWyyN0raflStXsnbtWuKBAGFFoWzRoqxdu/aSK6D44YcfGD5sGGPHjr3g8ncpUpyK9957j0AggGmauaRNU6T4u6QS1CnOKTt37qRyqVK4nU4Kp6dTJBkMzg0EKXQSx+1EIoHP7ebjcJR1kRiGz8dPP/30t+fTpd3lVDItGlgWFUuUOK/Bx/333IPu9aJ5vShuNzWTicXpdoDqx9HJvv3mmylmGLSxLNKj0ZMGWAcOHKBVw4a4nU6qly3Lb7/9Rq9u3ShmGJS3LMoUK0a9pIneC/4AVUqUPKO5v/HGGxQ3DL6JxLhd0ynhchP2+ZDcbrwuFzf260eTOnXIp2lYkszNN99MKV3n9UCQoCiyMBjiZk2nvNtD6QIFeOihh6iq6bSRJPK53fS9/npMWWZRMMzqcBRNEEhTFD755BN2797N/PnzsRSFh0yLlqqGRxCYaQd4KxjCSuru/VXrasOGDbSoX59KxYujiCIz7ABbo3HKWRbz5s1j0A03cFmlSkx67DEub96cmqZJS9MiPRojJMvEnE5uVLUcg8vjkUgkaN2sGR5BwCOKDBk0KGfb01OmUK9yZfr16kWD+vWRBIGybjeSw4EiihiSxJw5cxhw3XVU0A0Eh4Pvo3FqeLy09UnYokhep4syhQvTumHDHLPM9pZNs2bNclzuh2g6hT0eVoWjVNA0NJcbTRBo4vNR2OWifIkSXNOjB0FNp43fT1RVmT17NoMHDmRQMpAfrhv0ufpq2jRpQgFdJ6Io3Hf33Wf0fJwNiUSCBQsWMH36dObNm5cjK5JIJFKVGv8C5s2bh2EY2Lb9jzbOSZHiRKQS1Kn4+0Lx/fffc0OvXgy+8cYTJgAvNp9//jkBReE2TaeMYVyQOOJccuTIES6rWpUihklAlnli0qScbXv37qVd06b/x95Zh0dxfX38zPru7I6sSwgECQR3gktxd3co8sOdIi0ULbRAcShuhQKF4u7u7hYIFIdAiGe/7x9J8zaNkISEIPN5njzAzr3nnpndsGfOnPs9cIgi2jVrlixt1X8SnZxcDiXDIKPNlmyJD5Flsddiw1W7EyatFn5+fkmaFxISkqZb7CMjIzF1yhQ0qlULol6PgiYTrDyfoEzHq1evcPv2bbjdbjx//hwvXrxAh5Yt4VKpYJfLUVCpgk0QUvQZL1O0KHiGQTsdCz3DwKDRYOH8+QCi4sqAgIAEY8tWjRqhPM+jC8fDaTLFVGaHhITg0KFDyGi3w6zTIX/27J+MZEFQUBC8HA605nh8w/NoUL16eruULAIDAzGwb19kMJtRpnDhBO+1JD5v7t69i9y5c0Mul2PGjBnp7Y7EF4KUoJZIVUaOGIEGPI8HDheacByyuqIaL5h0OiyIDiQSYvzo0TBpdXCwLLq2b58q/qgUCly1O/HA4YKDZXHnzp1Yx48ePYoJEybEqVpOLkFBQdAqlThtc+CUzQEFEVxyOb5RayDK5Zg/b16cOW63G+vWrcOMGTPw5MmTRO1Pnz4dFXgBN+xOtOQF9O7WDQqZDFftzii9ZbUaVp0OC40m1NXpkC9bNoSEhODMmTNYuXLle+2vW7cORUQR9xwuTBZEZLZasWTxYoSFhSEsLAyHDh2CN8djMi+ip94AK88jg1yBBaIRORVRjRJXmczgGQaZzWb07dEDrRs3RgazGS3qN8Djx48xZ/ZsKImgJEIrHQuXXo9NmzZF6/8aYTFwqFCiBDq1aYNBfftCp1RCp1LBwnFw6Q3w8fLCs2fPYvndqEYN5FAo0V9vwG6LDTaNBu1atUIFPqoaP5PBAIVMht+NZlRSa6CXyaBkGBgYBrNFI4qZTNi1a1eC18VkMGCbxYoLNgcEjQb+/v5Ys2YNnCyLhUYTqvECzBoNxvAC/J0eaKLVoUKFCjHBbzanE7ssNmRXKNBex8JLroCSCGVUatyyO5GL55E9c2b4qNVYaTQjB8fjt99+g9NkQhGTCWaDAcULFIDIsmherz5GjRoFr2gJlCNWOxyiiC1btqBWpUqoXbMm5syZA5teDz3DQCeT4VsDB4dej82bNyMiIgJHjx7FpUuXEv0sJJXg4OBkP/DZunUrzBwHVq3G9F9/TXDc69evMXXq1BgZFYlPk5s3byJPnjxgGAajR4/+7CrqJCQSQ0pQS/G3xP8zZ84cNIkuhJgvmlA1hf0p0gq3240LFy7g/PnzCSYqw8PDceTIkVTTiP6H0NBQ+Pv7p7hJotNkwnKjGQesNvAazXtjdgDYvXs3jHo9WKUSZXx9E61KTg7Pnj3DjRs34Ha78cuECcjP8xjLCzDKZPjTZEFvjkfv9/TZGT96NAzRBTuTJ07Evn370KNHD/Tv0yfFcgAXL16EmeOgJMJAgwE7LFbwWi2uX7+OIrlzQ6tUIk/WrHj8+HGcuSEhIfj5558xeMAA3L59O9ax/3XsiO7RfX7q8TwmTJiQIv9Sm0uXLiELH1WscsHmAKfVprdLSWb79u0wqDWwyGTYa7GhJy+gbuXK6e2WRBoREBCAGjVqgIjQrVs3hIeHp7dLEp85UoJaIlX54fvv0YSLSlC34nkM7NcPx44dixMQJMSdO3dw9erVmOAyMjISR44ciWm2kVwK+eREV17ACF6ATRBidUffu3cvLCyLjoIIK8ti9+7dKVoDiAp+9Go1dlps2GGxQkmEAXoD8mp1qF21apzxYWFhKJo3L3QMAyvL4tixY4nanzhxIhpEB1C9OR6d27ZFtgwZ8AMvYIogwmQwoEuXLuAZBhoieCiVqFuzJmwsiyrR0hF///03BvfrhywOB+pXrRqrQURoaCgqly4Ns04HM8fFSdhfvHgRvFwOX5UKRVQqCCoV8qpUYKLlNQSZDGqGgUWhxDzRhPIcj2wuF7J7eKBR3bpgVSrolErolUqUUWugYRi0bt4cgwcMQOfoauHuHI9+vXvHrPnmzRt0atsWvaKPN+IFjB8/PpZfzevXR3uDAYWUKhhkMrRo0gT1qlTBr9EVyc1FIzwdDugZBmM4ARoi7LXYsNVshZphkMFqjVcf/B+s0RIfp20O8BoNfhwxAqxSiSoaLfydHpgrmmBlWVRWa7DVbEUWhQKj/lVV1KpRI1TheXRj9dAyDEqrNWis1SGzXIHOOhacTIbGrB51dCzMGg1GDh8Ot9uNly9fYv/+/Xjy5Alev36NcsWKQS6ToXThwjDq9fiRE9CMF1CmSBFYWBYTeBHleAEmjQbd9QZMEUToGAZVqlTB3r17E/1sJRe3241+3btDrVDAqNcn6/fGLopYZTLjiNUOLoGbsIiICBT08UHN6EaUdaSg9pMmMDAQzZo1AxGhTp06if4+SUh8TnypCWoiMhLRTiK6Gf2nmMC4SCI6F/2zISm2pfj7y+XSpUswsSz6GTjk4jhMHDfuvXMiIiKwe/du7N+/P813TvXt1g1OvR4uvR69u3ZN07VSm507d8IuiuC0WsxMohZyAW9vTONFeMrlKKNWw0Onw+Sff07Wuq9evcKmTZtiKqJXrVoFXquFnWXRoEYNNKxWDVMFI/ydHmipY9FNb0AlnsfY0aPj2Nq/fz8y2e0wGwzQyOU4bXPghM0OjVIZq3/NhxAeHg5Bp8MBqw037VE7Ivv17Yv60YVRrTkeA/r0SZbN3t26oTUv4K7DhSq8gClTpqSKrx9KYGAgXGYzenI86vICqpUtm94uJZkC3t7ooTfAV6XCA4cLC4wmlPyX5rvEl0dERAT69+8PIkLFihU/mZ0IEp8nUoJaIlV59uwZ8mfPDoNKhdxZsyapCiAh3G43mtWrh6wcBw+9Ht/9S2Ihqfj7+6Nt06ZoXLMmzp07F+tYnx49MDhaBuE7A4fe3bun2FcAGDVqFDQKBbQqFb4fNgwtGzbEsMGD420k1qVLF2gZBquMZnxv4OFltSZq+8WLF/DOmBGCWg2bKOLmzZu4cuUKqpctiwq+vjhy5AgqliuHulotLtgcKKlSw67TYa4YVe1Sy2RCt27dkIvnsctiQ2NeQPdvO8VaIzg4GGvWrMGFCxfirB8QEACNXI57DhfuOVxQyWTw1OtRQaVGDoUSTfV68DodmopRgex0wQhPuQJrjGYoiHDMao/WnibcsDvRz8Chb69emDhxIr7heRy32lGZFzB2zBiEhYXh4cOHiIyMRP9evdCcF3Dd7kQFXsDUqVNjfHr79i16dO8Oq8EAOcOgUc2aCAsLw7p162BjWdQ1mWHhOKxYsQJOtRpXbA7oGAZno4NmlVz+3i1n69atA6fVQq1QYPzo0RB0OvxpssAqk+EbtQZ2lsXsWbOQN2tWWDQa1KtRI9ZN2JQpU8DLZOAYBtpofe8RHI880cl6Ua3GAAMHIVr3+/Lly3F8GNCvH+roDbjtcKE2z6NL585oVq8eenTqhFmzZqG2yRwjJaNmGJyyOfDA4YJNJsfgwYMTPb+UcOHCBTj1ely2O7HYaIJPAg0X3W43rl+/juPHj+OHH37A7NmzwWu12GOx4bLdCVGrxYMHD+LMu3//Pqw6XUzDKDnDwCYI8DCbsXXr1lQ/H4kPx+12Y8qUKZDL5fD29k61Kn0JifTkC05QTyCiwdF/H0xEPyUwLjC5tqX4+8vm2LFjGNC3LxYvXpykhHOTOnXgw/PIynGptjMyPt69eweNQoErdieu2J3QKBQIDAxMs/XSm5CQEGQwmeCjUMBboYC/0wPrTBbky5o1yTaePXsGL4cDpUwmWFgW69atQ/YMGbDWZMEdhwtZOA7fDxsGD60WnfX6qIIagwEt6jeI977G02rFAqMJuyw2aBgGf5os2GGxQq9Wp2pF5bQpUyBGJ9HbNWuG0aNGxU5QJ7PXyZMnT1A4Vy7IGAaVS5eOVciU3ty8eRM9u3bFsO+++6yaePvmyYMJvIA8SiU85HIIGg02btyY3m5JfAQWLFgApVIJb29vXL9+Pb3dkfhMkRLUEqmO2+3GixcvPni798OHDyFqNLjtcOGCzQGVQhEnIA4LC8OsWbMwevRoPHz4MFn2ly9fDm8DhymCiOwch2XLlqXY12vXrsGk16OXgUNujsf4eKoL/uGvv/6CoFSitEoNq0yGuYIRglKZoFxCZGQkDh8+DAvHoarRCAvLYsuWLXHGtWzUCL31Bvg7PdBQq0OubNlQlxew3GhGBoMBffv2Rb3oBPIEXkSDav+vZxYcHAzffPmQW4jS5luyeHEcHzLa7PiOFzCYF5DJbkerli3BKxTYHd3oMZ8gQNTpUE2rhcAwyCiXw04MFETYY7HhgNUGJRGWGU0oHN2EJjg4GM3q1YddENC0Th1cvHgRnjYbzDodCuXMiTt37qBM4cJQKxSoU7lyrCYhFUuWglkuh1Emg4Zh8G2HDjFVIKdOncLChQvh5+eHsLAwFPTxwTeiES61Bjq5HAa1GlOSWGny6tWrmKrQjDYb5ohGLDOaoFUqE02Y3rt3D5xSiUVGE7qwemSRK1AzuvJ6gdGEcoULw9Nuh0Umw1GrParx4X/+7woMDIRJb0BbHRtVEa7ToUHdujHH/fz8YOE4tBFEZOU4FC9YEBkVChRSqmDSauM8wfbz88OMGTM+qJnF3r174WRZXLU7scxoRg5PzzhjIiMj0aROHdh0LLQMg/YGA3x5HhVLlQKn0YDXaNC/R4947YeEhMDDYkF/jkcHXoBeJsMmsxWrTGaILCvpV3/CHDhwADabDSzLYtWqVentjoTEB/EFJ6ivE5Ej+u8OIrqewDgpQf2VcvToUcydOzeOLF5yePbsGQxqNW47XLhmd0IplydL2zk5hIeHQ2RZLDaasNQYFSukRlI0MDDwk4k53G43Dh8+jJ07d6J/z54oE33/wjEMhhh4NNKx4JVKjBg2LEn2Fi9ejGrGqCKWOaIRFYsXRyEfH/wsiDhqtcPGstizZw9YlQrNdTp00xuQL1u2BO2JLIsDVhtu2J0QVSroVCpwWi1+X7EitS5BDPfv38e1a9didhy+T+IjKaRVj6JLly6hWpkyqODri6NHj6bJGp8aJ0+eRAarFQqZDC2bNIm3GEXiy+XAgQMxzRMTk9GUkEgIKUEt8Unx9OlTtG3aFFVKlcK6desg6HRYajRjiiAig8USZ3ybJk1QihfQkuOR0W5PVsWE2+3G7Jkz0bRWLcyaMeODgtAFCxagQXQl62KjCd8UK5bg2DoVK8ZIUNTSaKEkgkWlwv/+9784X+LBwcEoV6wYRJUKBobBFrMVvwgiGsbTLOPatWuwCQIyaHUwsyx69eyJ1o2boGS+fJg9cyaePHkCL4cDhY0mmPR67N+/P2buzp07kZvnUUCphIoItn8F91evXsWMGTOwcuVKNKldG01q10bn9u1RmOeRW6FEZY0GIzgeZoMBubJmg5YYrDdZcNPuhCxac1pDBA0x0DIMfHPlwpD+/eMNBju2aoU+0RIxtYTEt9qpFQrU02rxwOFCT70B+ZRRetWPHj2KM/bNmzdYvHgx1q9fj8ePHyfaoCU0NDRmO+LwQYOgUyph0Giw8vffo7S4M2SA02jEooULE7QBAIcOHUJ2lsUDhws7LFbYoyupu7F65OA4dO3UCd27d0dmjRZ+DheWGc3I/5/g/9ChQ8jBcfCSK2CRyaBnGJj0+lgPf27evImJEydiw4YNcLvd2LBhA2bNmoW3b9/GsrV9+3YICgU8FArYtVrMSOI20n+IjIxEg8ZNoWENUGm0UMnlEFk23gZ5586dQ0aDAcuNZhSI1szea7Ehi8OBly9fvvcG4saNG2jfvDnat2wJnVKJy3YnTtscUCsUkrbZJ87Dhw9RvHhxEBH69u0rvV8Sny1fcIL69b/+zvz73/8ZF0FEp4joGBHVTYptKf7+/Fm1ahUcej0aGk2wcFySJfr+S0hICIx6PWaJRvwiiHCaTGma7N21axd8MmZEDk9P7Nix44NshYSEoEaFClArFPByOHDz5s1U8jLlDOrTB14ch9yCAE9BwILo5HI1jRasTIYCKhW2mK3IaDAkqa/O3r17kclgwDqTBU15AR1btsSZM2eQ3dMTgk6H8aNH48KFC8hoMOCew4U9FhvsopigvRlTp0LQamHV6dCpTRtERkZ+lOR+cHAwXr9+nWiTxPTC7XbDy+HASF7EZEGEmeNiFdp86Uh9Sb5e7ty5g1y5ckEul2PmzJnp7Y7EZ4aUoJb4pKhRoQLa8AKmC0aYWBaLFi1C3ixZUCRnTpw4cQLh4eGxvtytPI8TNjv8nR7IJYo4depUuvh98eJFmFkWQzkehTg+0QqG/j17ohovYIXRDKdMjpZaHQSZDNU5HjZBwL1792LGrlixAiVFEfcdLozjBRRTqVBOp0PP//0vXtsBAQHImiEDmho41DQYkDNLllhJ7zdv3mDfvn0YNWIEcmbMiBoVKuDvv//GhQsXICgU6MiyuGJ3Ir9ag8WLF+PixYsw6fVobjTBzuqxYcMGAECxXLmwxmTBdbsT3lotKhQvgePHj0OtUMAqk+F7Q5Tucha5AiIjA0MEvUwGg0YDpVyO/j16xBtI/q9jR3TgBdxxuFBeEGK+1EJCQjB04EDUqVgxpjIzT44cKKlS46bdiRY6HTqxepQzW7Bp06ZE36tnz57h2bNniIyMxMOHD2M14Zs7ezZ00ZUfP40bBzFaMmWL2QpOrY43+Z0QwcHBKJDDBwW1OphlMhgUCmTLkAEd2rdHs8aN4WUwoJrRCEGthpPVQ9Dp8Ndff8Wy8ejRI4g6HcZyPGqo1bAzURXpnjZbjBxIWFgYvuvfHxWKFsWkiRPjXFe3240bN27ApNdjAi9ihmgEzzAolUw9uAMHDsDo9EKRIRuQrfH3yJE7X4LVULdu3YJZp8NfZgt4hsFAA4cqPI+WDRoma00AGNCzJ8w6HUStFuP+pe/9sTl37hy8M2QAp9Xix+HD082Pz4HQ0FB069YNRISyZcumuKJJQiI9+ZwT1ES0i4guxfNT578JaSJ6lYANV/SfmYnoHhFlSWBcp+hE9inPeHbUSHxe1KlUCdOidYebiUZMS+bD7H9z4MAB+ObNi9IFC6ZbfJ4SlixZgpKCiLsOFwbyApr+a+daeqFVKnHW5ohqjK5SIYNOh0ZaHURGBpdMjkVGE+47XCgkiti8eXOSbE6aOBH5smZF0zp1YvWl+YfIyEjU/OYbZON5WFkWv06alKi9R48e4datWx8tUdyrRw9wMhkMMhk6tm6d4LiwsDCcPXsWf//9NyIjI3Hnzh28efMmzf2LiIiAXCbDdbsTdx0uCBqNFA9JfDVIzRMlUoqUoJb4pMjicGBntGREAaMxVpXvpk2bwOt0UCsUGD5oEACgdsVKqMsLGMjxsPJ8vAFWauPv74+OrVqhef36sZKEbVu1greHB9q2aYNLly5h3bp1ePbsWZz57969Q8lChWBSKsHKZDArFJgefTPQWDTGetK4du1aFBCiNJj76g0wyWTIq1LBN2/eWDafP3+OnTt34vz58+A1Ghyz2mCXyZBToYRJr4+1rez48eNw6fXYYLagEy+gYY0aAADffPkwlOPwwOFCVV7ArFmzMG7cOHSMblL4Ey+gRf36AIDB/fqhGM+jv4GDSa/H4sWLMaBfPxTNnx++ej0yKhRgGQYeMjkGGjjcdLiQQ6lCZzZKu9hDr4+38eWjR49Q0McHMoZBjQoVYh5GDOzdG+V5AdMEIxzR5/PixQvkzZYNciJY5XL01Btg0usT1ZWeMHYsOLUaBpUKWV0umLRaOIxGXLx4ESEhIdCpVDhoteOgNaqxi6DR4IzNgb/MFnAMA29Pz2R9wQYGBmLdunU4fPhwrNdzZcyITWYr/J0e8DWZMG/ePDx9+jReGwcPHkT+rNmgYhj4KJS443Dhe15A3SpVAADjRo9GSZ7HYqMJmXU6DBkyJObmwO12o3XjxrBqdZAR4ZrdiTsOF7QMg46tWiX5PICoLb+CzQOFBq5F5jr9kb9Q0UTHT/nlF5gMBmS02dCodm2MGD48xdp+d+7cgZ+fX4rmppTTp0+jX+/emDVrFiIiIuCbNy/G8wJO2Oxw6vVxNO0l4rJkyRJoNBq4XK6vZmurxJfD55ygTuwnqRIf/5mziIgavm+cFH9//gwdOBDleAFzRRMyJLMR8pfC4sWLUVoQcc/hwmADh6K5c6e3S/DOkAGj+KjKaVGnw6hRo+DQanHQYsMPHA8tI4MXx6FMkSKxCi8+lIiICBw7dgzXrl1LNZuJcf36dSxduhStmjSB2WBA+WLF4u1ndPPmTehlMvxpsmCggQMvl8ereRsUFIRiefMiC8+D12iQxeWCVauF8T87Sd/HiRMnMHz4cPz555/JOp8OLVogFy+goCCi5jfffHJV3hISaUlERAT69esHIkKlSpWk5okSSUJKUEt8UowYOhRZOQ5VjCZkz5gxlmRHRqsVf5jMuGBzwKzT4datWwgICMB3Awagc9u2H60xV0EfH3TmeQzlBTiMRgQHB2P44MEozQuYKhhh1WrBqdUoxPMw83wc2Y49e/bAi+OwzWJFW45Hdk9PfGPgsNhoQkaDIdbNQEREBFo3bgxFdIXAwegGczqVKmbMvXv34DSZUNxkhkmvh5fTiYJqDZpH6xaP4HhULVcOZQsXRu1KlTB79myUit4auNRohm/uPACimt/ZRRFOvR4FcuRAQEAANm3aBC+DAbNFI3x5Hj+NHRvj17Rp09CnRw9Mnz4dDpbFQAOHDHo92rdvjwEDBkClUMApk2EMx8PP4UI+lQrNtDrctDvhxXE4fvx4gtf4v/IfVUqWxG/RDR8bGE347bffYo6FhITgp3Hj0O3bb+NNev9DcHAwNEolTtkc+IHjUUylwv3oZG+T2rURHBwMnUqFI1Y7jljt0KlUGDFsGOREMDAM5otGmLTaZFVRJ0TDGjXQnBcwUzTCzLK4detWvOPevn2L69evIywsDMuWLUPR6IqeEbyA2pUqAQBaN26MsbwAf6cH2rMsrGp1TAPMy5cvw6XX46bDhVoaLZxyObKo1MidOXOyk8Vutxtdu/WAXKGE2ebAyZMnP+wifMLcunULJr0e/QwcCvE8hg0ahNxeXvjdZMZdhwvZeR6HDh1Kbzc/C86ePQsvLy8olUrMnDlTujmT+Gz4ghPUE//TJHFCPGNEIlJH/91MRDeJKOf7bEvx9+dPSEgIBvXpg6qlS2PB/Pnp7U6SefDgAWp+8w0K5ciBFcuXf5Ct4OBgeHt4QE0MrDIZMrBskquS04qLFy+iXNGiKJozJ7Zv346QkBAUzZMHhcSowo1xY8bg/Pnzn3WV4tGjR2FiWVQTBOgYBsuMJrTnhXgLKg4dOgRPhQIPHC5sMVthkMnixNJ3796Fp8UKGRG+UavRVaeHj0IBP4cL0wUjyhUunKAvwcHBMUUy586dg4ll0cPAIYvBgDmzZiX5nCIjI7F161Zs2LDhs35vJCQ+hPnz50OpVCJ79uy4ceNGersj8YkjJaglPincbje2b9+OxYsXx6mGzmCxYK3Jgot2Jyw6XbpowrndbihkMty0O/HA4YKNZXHv3j3ULF8es6MbENZnWeRQKOAlV8BTrkDxAgUARAX99+7dw5IlS1DxX41JRLkcRkYGQSZDh3bt4l03NDQUebN5o5YgorggoGmdujHHxo4dizbRVc7fczya16+PWjVqIJdWix0WK6rzPAxKJWaLRvQxcHAYDPDOmBEFeAFGjQaLFi2KsfXu3TvcunUrVhA1d/Zs1CxfHiOHD483uBo0YAD6G7iYZHi1ChWQ3TMjami0KKBQQs8w0DFM1DY8YqCXy9GhRYtkJarmz5sHT4MBzUQjLByHu3fvJnnuP4SFhUGvVmOHxYrBBg55lErccrjQixfQqmEjAFEaev9IfMyM3tZaulBh1OE4tOB4+Hh5pUojlZcvX6Jjy5aoUqpUgpIkFy5ciNIUNxiQN5s3nj59iloVK0KnVMJlNuPMmTOYOGECGtStC6NGgyoaLYwyGdaYzOC0WgBRDy+MWi0OWG2YKYjIYLVh586dH3QO4eHhX3ySccWKFahptsDf6YFVJjNK5M0bo4nvYFnUrVo1zRrqfIm8ePEC1apVAxGhbdu2CAoKSm+XJCTeyxecoDYR0e7opPMuIjJGv16YiOZF/70EEV0kovPRf3ZIim0p/pZILyqXKoXuvIDfTWaYdewH3yM0qFYNY3gBfg4XWghioj1R0ovg4GBs374d58+fT29XUoXunTvju+j7iZ56A7qxeoznBdSrUjXO2Kj7omzwUihgYBjUqFw5zpi2TZuiJ8fjrsOFkio1CiqU8JTLcdHuwBCOR/Vy5RAREYEHDx7E9J4BgFnTp8fcC8yeMQNTpkxBm+h7vBmiEfWidzB+bI4ePQpPqxWsWp2ukncSEilh//79MJlMEEXxq9yZI5F0pAS1RKpw//59/Prrr9i4cWOaJa/Wr18PTquFVqnEd/36pckaSaFRzZooLgioIogokjs3IiIisGjhQmTQG9BKNEKvVEJOhKt2J245XGCVypiOxnaWRU4vL3h7eqKQ0QhDdLD0wOHCEqMJXvE0gvyHV69eYdq0aViwYEEs7d9FixahIM9HJ6MFDBs8GJGRkejfsydyZMiA2pUqw1OvxwOHC8etdugZBlmdTggaDfLyAnJlyRKnoV5y2LRpE1ysHt9zPGxyOTJqtTBHVzWsMZlBRGCIMNLAY5fFBo1CkeT1IiIiMKhPHxTOkQON6tbFlClTYhr2vH37Fm2bNkVBb2+MGzUqSZ+731esAKfVQqdSoYBPTsgYBrmzZIml+x0UFBQrgfb69WuM+vFHDB86NN5thm/fvk2Tz3zz+vUxPLphZE1BxIzoRp6vX79GREQEOrZqhbK8gN4GDpxWCxXDYKiBQy9eQOGcOWPsTJ08GUZWj8wOpySzkET+qaDub+BQmOcxdOBAAFFSOjdv3vziE/RpQWRkJL7//nsQEQoWLJiih0wSEh+TLzVBnZY/Uvz9dfDy5UtMmjQJs2bNSpGcxLFjxzBowACsWLEi1b5Ps3t4YLPZigcOF/KJIvbt2/dB9jZv3gwLy6KG2Qwrzyf7O+vXSZNQIm8+/K9DB+mhbAJM/vlneJhMKJo7N65fv45fp0xBMZ7HSpMZ2ZVK2LRamPSGBGPX0NBQ7Nq1C2fPno33eKuGjTCQF3Df4UJxtRoahkFZlQpKItg4DidOnEBBHx9YdDpksFpx8+bNmN2Uh612HI7eTblv3z7YWBY/cgLy8zwmjh+fhlclYfJkyYIZohEnbHZYdLoUy65cv34dFy9e/KixbGRkJLp17AijXo8yhQvj77///mhrS3w63L59Gzlz5oRCocDs2bPT2x2JTxQpQS3xwTx+/Bh2UUQzUUQ2jsNPY8ak2VqhoaEflExNCZcuXcLmzZtj1g0LC8OiRYswa9asWE02du/ejV9//RWnT58Gp1JhiiBijmgEp9GgY+vW6BWdbKzPCxgzZgzWr18Pl8kEJRHKqdX4H6tHdg+POOsHBwejZYOG8LRY0LZpU4SGhiI8PByTfv4ZXTt0wKFDh9C3e3dk9/BAq0aN4kg3hIeHo2DOnMijVCKzXIH2OhZqhsHvJjP8nR4oaTLFac6XVEJCQjDll1+gksuhJkIDrRY37E5oGQZtdCz0DIMurB52mQz5FUqIjAwGtTpWpUJiTJ8+HUU4HutMFhTneUyZPDnmWJ9u3VCbF7DOZEE2jntvc0Qg6vNTsmBBZNXrwclksOj1WLRwYYrOPSgoCBVLloRKLkdmpzNWkjs16Ny2LdrzAi7anfAVBCxevDjm2Lt372DRarErWq89l1KFyhoNciiUMGk0UvIvFTh58iT69OiBGTNmSNXSqciGDRvA8zyMRiO2b9+e3u5ISCSIlKCW4m+JuISHhyOftzfq8ALKCv/fDyOpnD9/HiaWRR+9ATk4DlP/FdcFBQVh6MCBaFa3brIr7KZOngynXo9iRiMK+vjEaqieUi5cuIAVK1bA398/WfO2bdsGL4MBv5vMqMoLGNCr1wf78qVx4cIFOFg9dllsGMYLKJA9BxYsWIDe//sfSuXPj+GDB+P06dO4c+cORo4Yge+HDcPTp08REhKCffv2JSk5e/36dXjabDCo1ShTpAhmzpiBcoULo1vHjggMDMTkyZNRixfwwOFCbwOHVo0bx5ugDgkJwdatW9GxZUvMmDYNkZGRH+EKxSWzw4F1JgtuOVzwNBgSTMwnxshhw2DV6eDU69G1fXtcvHgRHTt1xtBhw2PJaqY2a9euRV5ewEmbA9/yPNo2bZrkuQEBAXj48GGa+SbxcQkICIjZVdmjRw9J+kYiDlKCWuKDWbNmDSqZo5Kdq00WFPHxSW+XEuXly5f4ftgwDBk06L3dlJcsXgwry6K40QQfL68kd33euHEjeLkcLrkCLp0O5UuUQCuex02HC98IAqZNm4b+vXqhMcfjot2JoioVtDJZvBUfY8eMQSWex0GrHWV5HpMmTcKgPn3gy/MYyvEwsWy8jUH+zdu3b5EtY0bkZfXIzXHw9vBAR17AWpMFjgQaFr6P5cuWgVWroSBCF1aPA1Yb1ET4lRehJYKGYdBIp4O/0wOzRCOqajSopdXhf//7H9xuN6b88gtqf/MNJk2cGO9T/FUrV0Ijl6OX3gB/pwcGGDiULFIETWrWxJo1a1CnUiW01rGYK5rQUBAxffr0BH2NjIzEr5Mno2qZMvDQ6eCtUGCyIGKz2QpBq01S4LNq1SoUzZUL1cuXx8WLFzF79mzk1rEwMAy0DIN83t5wu90fVJEQFBSEuXPnYu7cubh79y5KFigAVq1GywYNY32BDxs8GFlUKpRQqdGN1UPDMDhtteOuwwWVXJ6sap1Hjx7F0UmPj4iICCxYsAA//fRTsm/WJNKH+/fvY8OGDZ/c+3Xz5k3kzp0bDMNgzJgx6XazJyGRGFKCWoq/JeJy9+5dOFgWDxwu3LQ7oZDJkhX3TJ8+HS2jZe5mi0bUqlAh5ljntm1RhRcwnheSFNv+l9OnT2PTpk0pbsicWkyfPh2NoyUhpggi6kT3DJH4f3777TdkUatx3+HCapMFgkyO6kYTvByOWBKPJQoUQH2eRzOOR67MmVEsb17kFUVYWBYLFyx47zrh4eF49uxZvJ/RmTNnoqRWi9sOF9rqWFj0eoSEhGD2jBmxJD4+FVatWgVeo4VZp0OrRo2Sfb8REREBtUKBczYHrtud0KtU4EQTMpRvA3ueMqhdr2Gi858/f44pU6bE2cmbFObPn48qohEPHC6M54Uk/078+eef4LVaiBot2jZtKu1g/EKIiIhAnz59QESoXLlyHFlXia8bKUEt8cFcuXIFZpbFL4KIaryATq1bp7dLiVKiQAE04Hm05HjkfI+mcNFcubDCGJV8L2U0Yd26dbGOL12yBD6enihdqFCsQHrhwoWoGq0Lvdxohm+ePPDNlw8KmQw1v/kGwcHB6NKuHfpFj2nMcRg5cmS8PvTp0QO9osd14XgMHjgQJfPlw6roCugaZjNWrFiR6Dm73W60atwYGoUCrEqFpUuXok6lysibJQtmz5yZ9Iv3L3uCTocdFivO2BwwMAw2mi1QMgwyyuQoolSinEoNo0yG0byAnEolGml1yGAwYN++fVi8eDFychxmi0bk4jgs+E+Q6Xa7wWm1mCUaYWRk8FWpYVCpkEevxyRBhJ1lkStLFuRWKpFDqYSoVieaZJ4yaRLycTwm8iKMMhl4hsE+iw13HC449XpcuXIl0fO9desWTDodlhnN6MxGVV/XqVkTekaGzWYrrtid4ORy8CwLnUqFaSnQKnS73fimRAmUF0QU0BuQyeHAggUL4g3GOrRogSEGDiM4HnlVamR0OlFCEOEriDHNE5PChLFjwWs0ELXa98rm/K9DBxThBbTgBXjabAgICEj2OUp8PM6ePQuTXo8KZgvMBgMuXryY3i7FIjAwEM2aNQMRoU6dOnj9+nV6uyQhEQspQS3F3xJxCQ4OhofFgn68gLY8D9+8eZM1/9SpU7CwLIZxPPJyPCaOGxdzrHCOHPjTFNX/oaLZgrVr16a2+x8FPz8/2EUR1UxmWFkWGzZsSG+XUp2XL1/i4MGDeP78eazX37x5g61bt+Lq1asJzg0ODoaV5+GtUCCDXA4dw6CfIaoYpZTJFLMjMjQ0FHKZDPcdLhy12GCQyaBnZOinN2CtyYI8Xpk/6ByCg4Ohl8kgI0I+pRIZ9PoYv0NCQhASEoKgoCBMnjwZI0eO/CRkKV6+fAk/P78UJWrdbjcsPI+FRhPWmixgVSpYM/mg2PfbkK/7ApjtzgTnhoSEwMfLC/UEEb6CgFaNGiVr7YCAAOTzzo7MHA+zIWHZlv+SzRX1AOPmB1SNS3y6zJs3DwqFAtmzZ0+X3mISnyZSgloiVdi6dSsaVKuGgX36fPTKhV27duHnn3/GpUuX3js2LCwMMoaBn8OFBw4XRI020SrqRjVrokN0pbEok6Nw7twxGsjXr18HJ5dDQwyyKhQo9K/K8fo1asDAMJjAi/BVqdGt47cAECuguHbtGpwmEzJxHLw9PfH06dN4fbh69SpsgoCCJhMcRiNu3bqFkcOHIx/Ho7uBg0mvx507dxI971OnTiGTgcNNuxPLjWbkzJjpvdcqKCgI06dPxy+//BLnyabb7YbIsthmseKUzQE1MdAqlWjTqhU0DAMNEUqq1FgomuBUqVEoTx5U9PWN6Qjft1cvDIxuhDLYwKF39+6x7D979gxKhsF+qw2bzVaoZDKUKVz4/xtRCiL0SiXuOVy45XBBzjCYNGkSgoODERgYiIY1asAhijGSKC3q18dEXoS/0wPfGjjwWi30cjky6PVoVKtWzPsSFBSEiRMnYviwYbGqivft24d8ohjTLTyTXA6dUglOqcRKkxmnbA7oGAazBCOOWO3gNJp49aoTIyAgAFqlElvMFphkMgwycMjFcejQpg2svACjXo/ly5YBiJKfMOn18OE4GORyeFos6NevH1asWBFvVcPly5exYMGCWA9RwsPDoVYocMrmwMXoSoonT57g5wkT0LNr1zhBoKfFggPWKEmRAkYjDh06hOvXr2PokCGYNWuWtEXrE6N39+7oF/071svAYUDfvuntUhzcbjemTJkCuVwOb2/vJP0fLiHxsZAS1FL8LRE/169fR8dWrdCjc+dkxzoAsGfPHnT79lvMmT071g6a0SNGwIfn0VIQYROETyIhmFIePXqE33//PdEGhqdPn8ayZcvw22+/4ffff0+y/F16c/v2bTiMRhQymWDl+Zgij9evXyN7xozwNZpgYVmsWrUq3vn379+HRafDHbsTf5rM0BChCS9gtmiEUavFgAEDsHTpUkRGRqJonjxowgvIolCgp96AA1YbPORyNGb1qFyq1AefS8USJdCQ49GH4+E0meLcw9arWhUVo4uasrhcKdJcTw5pvaNs7969yJ7BE152O5YuXQqr3QVnsTqwZCuAVm3bJzjv0qVLyMxFxZTnbA7w0c3Yk0NoaCguXLiAly9fxjm2efNm5MyYCQW8vWMlr/NkyYLZohFnbA7YWPa9BUUSnx/79u2LaZ64Z8+e9HZH4hNASlBLpCpPnz6N94snrVi2dCk89Hq0FUSY9Hpcvnz5vXNiVVBnzpxoBfWTJ09QpXQZ8DIZ/qfXYwAvoFyxYgCAAQMGwFelxhW7E020Ohj/9WWdyWrFRF5AQaUSJrkcdatVi1fbKzAwEFevXn1vwPPixQscOnQo5tpGRkZi7ty56NihA44cORJrbHh4OG7cuBFLq/v8+fNw6vW4aHdgtmhEvmzZYo6FhYWhbdOmsPI8alWsGFMZW718eXwjCKjDC8ifPXuc67Rq5UrolEooGAZZXS6cPHkSFUuUwARewHW7EzkUSviyeng5HHGqbQ8ePAgzy6KV0QQzy+LAgQNwu934/fffMXr0aPz222/wZvVgo+UznDyPObNnw6bVIr9aA41cDg3DYDTP4zsDBz3DQEeEfD4++H7IENTkBRy12lGK55E7e3awajXMSiW+5XiwMhkMGg3at2qFM2fOxAoG61erhko8j3Ycj4x2O969e4fw8HCMGD4cNoMBuZVK2GUy9NAboFersX79eogsC7VCAYNSiT0WGy7ZnRC1WqxZswalChZEzUqV8OjRo0Tf33/e0ywuFypotGisjZJGmSMaIcgVWG+2YLvFCoNGExM8+/v7g9dqscRowh8mM3itNl7Nxd9//x1sdIUIp1DgxIkTMesJOh3+NP2/7c5t26I0z6N/9IOPfyfpG1Svjjo8j+HR1Q+XL1+GlefRxcDBl+fRs3Pn956jxMdj8qRJKMnz2Gi2wpfnE5XASW/2798Pm80GNpEb2o+F2+3G1q1bMXfu3BQlXiS+HKQEtRR/S3xc3G431q5di59//vmL76WxfNky2Fk9Sut00MtkKMzzqFauHNxuN27cuIGff/4ZmzdvTm8342XI4MHoHL2zs4+BQ69u3QAAf/zxB8pHy7csNppQKn/+eOdHRkaiVKFCKCeKKCQIaFSrFjq2aoVyRYvCyvFowQsowPPo2707Xrx4gaGDByOL1Yr5ogkPHC7kUamQN3v2OL1f3r17h0ePHiWruvjVq1cY2LcvunboEK+kDKtW45LdCX+nBzJxXKKV4R/CpUuX4PLMBLlcgY6duqRYyiIkJARN69QBr9WicqlS75VO8PPzw4gRIzBz5sxEZTvevHkDa7S0ZEteQPnoe+HUIDAwEIJOh+VGM2aKRjiMxpjzP3z4MJwmE9QKBUYOG5Zqa0p8Wvy7eeKcOXPS2x2JdEZKUEukGsMHDQKnVsOgVn80za76VatiqhBVVdtaFDElCdIKL1++xA/Dh2Pod9+9V4MaiEqe5BKimmhsMFtiGhmOGzcO9aI1lnvrDShTtGjMnJYNGqIIy8Iik2GR0YQaPI8enTolus6tW7dQPF8+eJhM+Pk9HaKfPn0Kb09PZOUF2AQBFy5cwMjhw1HExwceRiPsOh14pQoVS5SIeRL9Xb9+UMnlsIkiDh8+HGNr9uzZKMkLOGGzox7PY3D//oiMjISMYXD7n0pzlSqOTvGbN28g6HSYJRgxlheR1eWBfDlyQMswUBHBrlKha9euCSZ5zpw5g2nTpsXoX48eMQK5eB7N9AbwCgU4mQw1NRpU5Xg0r18fhXLmhFmhgK9KjbY6FkZGhqxyORzR19gpk0NOhHzZs6N/dODcVm9AdrUa52wOFGBZ2MxmNNfrcdLmQHaOx7Zt22L5JOh0OG9zwN/pgay8gIsXL6JP9+4oqNZgHC9AL5dDrVCAVauxYN48AFE3VBEREZj/22/gNBpwajW6deoEVi7HRF5EW5ZFVocj0ffzH27fvo1aVaqAUyhiKqjVMll0lbMDepUqJtgMDQ2FSi7HRbsDV6MroOMLRH0yZMAgA4ebDhdyKZSoV6dOzLENGzbALoowGQxYvmwZ8mTOjM1mK/ydHihvsWDjxo3w9/fHzZs3ERAQgEH9+qFds2Y4ffo0tm3bhtLR2vM7LFb4eHom6RwlPg5hYWHo2aUL8mXNir7du3/yFe4PHz5E8eLFQUTo27dvuvn746jREJ2Z4MpfHg6Xp6SL9xUjJail+Fvi8yciIgK9unRBTs+M+LZVqzSvgE0q5YsUxXwxKplbTaPBJF6EXqXC2bNnYTYY0FoQ4GUwYMa0acmyGxkZCT8/v1RpEpkQU6ZMQZno3jiVeQFjRo0CABw5cgQeej3Wmy1oywtoVq9egjbevXuHxYsXY+XKlTHf97t370YxU9Q12WWxIZvz/yUnNm3aBCPLIhvPwzdfvji9Vvbv3w+jXg9Ro0GdKlVSLYaoVLIk6vM8enI8PCyWNNslXKpsBWSq2hWFBq6F0emV7Cah/zBjxgyU4QWctznQkOcxoE+fVPPxwoULaN24Mbp36oRnz56lmt3Hjx+D12hw0+HCRbsDSrk8TiW5pD395fP69euY5ok9e/b85O9bJNIOKUEtkSo8ffoUnFqNi3YHDlntYNXqj/JlMmbkSBTjeUwRRLj0+nibDH4ooaGhKFmwIPIIIqwsizmzZgGIkqHInjEjXCwLmyDEevIeHByMBvXro2p0g795ogkVfX0TXadSiZIYxAvYbbHBqdfjzJkz8Y7bu3cvGjVqhJrR2/e/4wSULVECeTgea0wW+KrUyCpXoLWOxXhegNlgwIsXLwBEVVf/+33ZuXMnsjkcyKRQYL/FinpaHXwLF4afnx8sOhYtdSx66A3QMQx27doVy4+oMTrcdbhwweaASi4HK5NhlcmM8zYHDHI5bty4keTr7Js7N/4wmVFFo0EnVo+/zBaYlEq0bdkSK1asQAmjERaZDCdsdvg7PZBDocBwAw+7TIbCShVGcDwu2BzIwLIw6fXIYzRC1GrRJvo9aMfxyOxyYZoQ1aSjgFqN3r17x/KhcK5cqKrVoZuBg8tkQmBgIDyFqG2HdxwuZJYrwKnVqFO5cqwK9X949eoVnjx5gvXr18Mpl+OBw4VjVju0DINt27Yhh6cncmbKFO8WpsePH2PLli148OABDh48iD49emDBggWxdKKHDRwIIGo7VP2qVVEsXz5YdDo4WH2CFcwFvL0xhuNxw+6ESyZH/ty5Y+kRX7t2DaULFoSPpyeqV6wIX55HDwMHs4HD6B9/hKDVwsay6NSmTazPzsOHD2E2GDCQ41H+M9Cel/j0CQ0NRbdu3UBEKFu2bJIeIKY2mb19kKvDryj2/TY4shfE1q1bY46dP38e+/btk4LmrwQpQS3F3xKfP3PmzEExnsd2ixUVeAFjR49Ob5cAAJ1at0Z9XsAyoxlWmQztWT1cZjPmzp2L+tE9ZhYaTahUvHiSbQYGBsI3Xz5YdTrYRREXLlxIE99DQ0PRvnlzeFosaNmgYaxk8dTJk5Hbywv5fXzQuUMHnDp1Ksl2Hz58CJNej5Ecj1q8gKZ168Y6/ujRI5w6dSreSt+S+QtgpmjEXYcLeQQhTgFKSnn9+jWGDByIHl264NatW6liMz4K+5ZElvqDUGToJlgy+WDLli0psjNu3Dg046OKdPpxPDq3bZvKnqYNbZo0gRfHwanXY0j//untjkQ68e/miVWqVJGKRL5SpAS1RKrw6tUrGNRqHLTa8ZfZApFlP0qCOjw8HGN//BFlChdG1YoV8eeff6bJOqGhodi7d28c7avQ0FBcv3493ifqjx49gsNoRE2TCQ69HsuWLo05tnXrVhTMnh0l8+eP0fotkC0bVprMuO9woYAoYseOHXFszpw+HRkNBtTkOOgZGXaZrWjGCyhRrBg6Gjj01BsgMDJoicEJmx0PHC54C0K8TSWePn0Kg1KJjHI5iipV0DMMPBUKNOV4mDkOrEyGBlodSqhUMMlk+O233/Du3bsYqRK3241q5csjB8/Dy8ChbKlSEGUy/Gmy4LLdCUGhSFaCunfXrigrCPCSy7HSZMYDhwu+RiM2bdqEAwcOIJPBgLIqNSqrNeipN0DLMLBqdSiSJw94mQxzRCPuOVzIJ4hYvXo1jh07hnPnzsFpMiGbICCj3Y4//vgDrFwOu0yOHAoFzDodrl27hsePH6N4wYLgGRlqarTwUqnRsU0bAIBTFOGSy1FMqUIRpQonbHbU5gUMHzIkwXN5/PgxWJkM36g18FYoYNLpoJXLscxoxiKjCUaDIVZ1wF9//QWDVosiYpRUzcmTJ2PZ+/vvv+Hv7w8gSrvPxOoxgRfRkOdRtWxZXLp0KcHft5MnT4LXaKBnGJRUa9CX42HhuJjK9mJ58mA4L2CdyQJRq8WoUaMwaMAAXL58GYJOhwNWG27YnTDrdHG23J49exbdO3XCuDFjPpmqJInPnyVLlkCj0cDlciW5kU5qUbdBYzgKVkaWugOg58WYG9Kx438CZ7TCnCEbypSvmKg0lMSXgZSgluJvic+fYUOHxshRDOZ4/K9jx/R2CUBU35EOLVqgcI4cKJw7N+pXrYpLly7h1KlTsLEsfhZElOEFDEpGBey8efNQMbpfyg+8gCa1a6fhGSTMd/37oyjPY0C0XNw/vXuSwrFjx9C6UWMM6tcv3kKQhKjg64uxvIgrdieycTz27t2bAs/fz5MnT1C+WDGYDAZ0bd8+1TSjDxw4AAMvguVEVKxaPcUPwh8/foysHh7IwvNwGI1pJkmS2rjdbpw4cSJRzXaJr4fffvsNCoUCOXLkkJonfoVICWqJVGPOrFlg1WqILIv169d/tHU3bNgAD70ewzgennpDkpLUGzduROvGjTFp4sRUTTREREQgIiIChw4dgrdHBtgEAd9++y2OHz8eMyYgIACiTofFRhMm8CIyR29hW7VqFYw6HbLxPEoXLhxvs5SS+fJhuTGqsqKsjoVWqYRJrYaHxQK9Wo0McjkOWu3Ir1Qiq0KBaoKAXFmyxNrq53a7ERISgh9++AF5lSpsNVtRWqWGggjrorunFxYE2BUK3HW4sNlsBcswGPbdd2BVKmiVSnRo1w7tWrcGq1RCp1Sib69e+OOPP+Ch1YGNlvgoVbhwsq5daGgoxvz4I8r6+sKo0aCQ0Yh83tljEuKjfvgBLpMJXk4nOrRqjU2bNsU0Vdu9ezdEloVVp0P1ChViBXZv377F+fPn8e7dO1y6dAkZTCZME0Tcc7hQ1GjE9u3b0bROHZTSalFXq4W/0wO/iSZUjW6+MnvmTIhqNTiFAi11LPydHujL8ej27beJns/atWvh5XAgV7ZssIsi1ES4Znfist0JlVwek9DdvHkzRJUK1TVamGQydGH1iVY87N69G0Wit0DusFjh7XK999qGhITAy2bDHktUk8NiJnNMFbenxYIdFivuO1zIyvExGtUAkMFiwQKjCTstNvAaraTJK/HROHv2LLy8vKBUKjFr1qyPtr3z9evX6PBtZ3xTpXqs6mnRZEXe//2GosM2Q7B5SDdRXwFSglqKvyU+f27cuAErz6OU2QxT9O7EyMhIrFu3DgsWLMDr16/T28U4bNiwAU1q1sSIYcOS1Thx2bJlKCYIuGF3ohsvoE2TJmnoZcIUz5MHf0RXgdcwW7By5co0X/P8+fPIZLdDIZOhW8eOsWKGFy9eoHunTmhWrx5OnjyJV69eYfjQoRjYrx8ePnyYrHW+bdUK7XgBJ20O5OeFVO2b8e7dO/j7+39QvHPx4kUsX74c+/fvT1aCX0LiU2Pv3r0wGo0wGo1p9sBJ4tNESlBLpCput/ujJRK2bduGqqVLI2/27BgcLXcxjOPRs2vXROcdOXIEdlaPcbyAQjyPcdHaaR/KwvnzwarVYNVqWDgOc0Qjtlms4LVaPH36NGacn58fzFod7jhcOGdzQKNUxhy7f/8+Tp48mWCjis5t26IWL2CWaISNZcFFJ7pXmszQKJUoYeDwwOHCdEFE7qxZMXfu3FjbY+7fvw+fTF5QyGTI7OGBrtHyF/31BjhEEdV4AT/xAkw6HYxqNRwyOQwMAy+WhUouxyGrHZXVGmRVKJBVoUBltSZKwkKpREhICEb98AMKeHujfYsWH6R/d/XqVezYsSNZWm9v3rzB3bt3E/z87d69G2aWRT4dC6NMhtKCAB8vL7x9+xZlChXCBF6AWSZDHa0Odq0WCxcsiJl74cIFLF++HJ5WK3KKUd3lk9pJ+u3bt9AoFGijY+GSyyHIZOj1r89o83r18BMvRGlm61hk0WgweuTIBO0FBAQgk92B+qKInDyPIQMGJMmPLu3aoSTPo6uBg00QYvTjpk6eDBvLIqcg4JsSJWIl9/fv3w8vux0WjsP8335L0joSEqnFixcvULVqVRAR2rZtG0dz8mPikzsfMlbuhBytfgJrEJLU+FTi80ZKUEvxt8SXwZMnT7Bt27aYZGSvLl2Qm+dRRTQiT9ZsX8wOsLCwMDStUxcKmQz5s2fH/fv308WPoQMHojDPo290BfWdO3c+2trxVTRXK1sWzXkBP3JRsofF8+dHA55HB45HVg+PBKuVz507B988eZArUyasXbsWANCwenWM5aP6EtUQjSlq6OZ2u9GjUyeILAvfvHlT7X3666+/YGFZVDKb4TSZkp18l5D41Lh16xZ8fHygUCgwd+7c9HZH4iMhJaglPkvu3bsHE8timmBEOR0Lk0KBwQYOHno9/vrrr0TnTp06Fa3EqMaKM0UjvO0OdGzVCn5+fin2JyQkBKxajX0WG/ZabFASYY/Fhpt2Z5RO87+kEdxuN+pXr44cPA9PgwGD+/ZN8jrPnz9HxTJlkC9LFsyfPz+6SZ4T1+xO6JRK5MueHdkFAUaWxc6dO+PM/7Z1a7QxcMivVEJOBJ1cjhK8AEGnw5EjRzC4Xz80rV0bu3btQtf27ZFfr0dbVg8Lx0GnUmGL2QJ19LmtMJqhIsImswWsWp1gUt3tdmPr1q1YvHhxkrSkwsPDsXDhQvzyyy+pWrHbtkkTjI5OBNfRsWjWrBkCAgIAAOvWrYNJp0NunofdbE6wc/rbt29x6tSpeCtuAgICUL1CBVh0LHwLFIj1UKJO5coowgvIbTCg7H+0yEf98ANK8wIWG01wKRSoXL58ojdLbrcbzRs0gEImA6/T4dixY0k6/4cPH6LyN9+gRNGiOHLkSKxjly9fxsGDBxPt4C0hkR5ERERg+PDhICIULFgwjszMx+Lq1aso4lsSmb19UrViSuLTRUpQS/G3xJeJheNwzPr/MngJ9Xz5XEmoUMPtdn+UqtqIiAjMmjUL/fv0SZVrGxISggbVq4NVq1HB1xcvX75M1nwbL+CYNap/jY8gQMYwuONwwd/pAauOjdME/h9yZMyI8byAVSYzBJ0Oz549w/Hjx2E2GJCV55ErS5YUaeRu3LgROXkep2wOdI9Hazul1CxfHtOFqPvb+kYjJkyYID1Ml/jsef36dUyxSu/evaU+MF8BUoJa4rNkz549KGQ0xsgcOI1G9O3VCxs2bHjv3EuXLsHEsujM8bDL5ais1aI7LyBHpkwprv4OCgqCVqnECZsdx612qOVyiBoNHKwe7Zo1i2M3IiIC+/fvj5FTuHfvHn7++WesXr06Xh/8/PzQrF49ZDKZUECvR01BQEEfH9StUQNGhQKiUomu7dsjNDQUp06dwuPHj/Hu3Ts8ePAglr32zZsjv1KFjiyLK3Yn8mp16NevX4y+8b8JCwvDr7/+ioH9++Pq1atYvHAhdCoVlETgGQY+CgV0DAOdShVLX/u/DBs0CN4ch8pGI3y8vN5bFd2xVSsU5QU0FgRkcblSrWP2uNGjUYoXsNxohg/H4Y8//sDDhw9x4sQJhIaG4tatW9i9e3eMpEhy6dG5M3iZDD30BjTR6eCTKVPMsbCwMKxcuRIrV66MlQQ+efIk5s2bhyJ584JXKpE3a9b3dsbev38/vPmopodTBBEl8ud/r29utxsFfXzQgufRmosKqlNLN09C4mOwceNG8DwPY7Qsj4REWiMlqKX4W+LLpHyxYujAC5jIR/X9eF/c9SVw48YNeDkc0CgUqFau3GdVNT59+nSU4wVctjvRhBcwIBm63ADQtX17FOQF1BdEZMuQAWWLFkVtnkcrjkf2jBkTTHgJOh2OWe2463DBwepj+uq8fPkS586dS/E1XLZsGcqJUQ3bJwkiqpctmyI7/6VXly6oFZ1Qt6hUMKhU4DUajBw2LGbM69evMeL77/HdwIFS8lrisyE8PBy9e/cGEaFq1aqfpDSTROohJaglPkvevn2LbBkyoJrRiGwch5HDhydr/tmzZzFkyBBoFQrcd7hwz+GCUi7/oC3kkyZMgF6thl6txpSff4afnx+uXr363qT3kydPYBdFtBSiJBtG/CuQ+IdCPj7owQsYzwswyWS4ZnNAUKth1enwqyCiHMehf69eMeMPHz4Mk8EAs06HqmXLxiRFb926BZNGg+HRUiDVBAGzZs0CELUt7n1Jy/DwcOTLkgVLjVFNDIvxQhzN79WrV6Njy5aYP28e3G43Mlmt2ButfZxXFHHo0CEAUZIc169fjxMYWnkex6MrHXKKYrI6gCdGWFgYBvXpg7KFCmHC2LHYvHkzjCyLHIKAQjlzpjgx/Q8FcuYEzzB44HDhlsMFGcPEee+9OlgRAACCH0lEQVT//PNPdG3fAcuXL8cff/wBO6tHUYMBngoF9llsaM0L6NiqVaLr7N27F9l5HjcdLkwXjCieL1+i491uNyb/8gsUDIP7DhceOFzQq1TJrkCRkEhvbt68idy5c4NhGIwZM0Z6yCKRpkgJain+lvgyefz4Mdo2bYraFSvGxKSfOkFBQR8kodisXj0M5AXcc7hQShCxaNGiVPQubRk3bhyaRO+A7MPx6Nq+Q7LmR0REYNmyZZg6dSqePXuGgIAAjB41CsOGDMHjx48TnDd6xAg49Hp48zzqVq0a5/pfvXoVkyZNwq5du5LlT2BgIIrkzo1MXJQEysGDB5M1PyHevn2Lb1u1QhEfH6hkcpyxOXDO5oBOqYy5xylbpCjq8zzacDy8PT2lalSJz4q5c+dCoVDAx8cnpom5xJeHlKCW+Gx58eIFFi5ciG3btqUoaHO73ShVqBAqCyLKCwIqly6d4Ni///4bDapXR9FcuRKtFn79+nWMbERS+euvv1DeHNVM5C+zBQWyZYszRqdS4aLdgQcOF8wyGTroDeBZFrWitbcXGE2oVLx4zPgKxYphSnQjwEKiGEv25OzZs7DyPJx6PQr6+CAgIACzZ8yATqUCp9Xij/dsX69XpQq68gK2mK3w0BtiNYDcsmULPPR6jOEFZOc4zJ83D1XLlEF7XsA0wQgjy8Lf3x/Hjh2DmePgYTCgWN68sZLD1cqWRWNewPecAAvH4cWLF8m6nkmlTKFCmCua8MDhQknRGKMv9z4eP36Me/fuxXrN398fnEoFL7kcdbValFKpUbFkyVhjVq5cCQ+9HiM4HpkNBhTw8cFM0YiJvIhv1Br4Oz0wWRBR65tv4l03JCQEjWrWhF6thqfJBI1CATPHxZHr+C8L5s9HDoMBWeQK1NRo0VBvQP7s2T+aVryERGoSGBiIZs2agYhQp04dqYpCIs2QEtRS/C0hkVTevXuHTq1bo3COHPhpzJhUi7GePHmCMr6+UMpk8LTZcPny5RTZaVavHgZHJ6iLsSzGjRuXKv59DJ4+fQpvT09k4jg4TaaYSuaPwfnz53Ho0CFERETEev3atWsw6fVoLYjIoNdjcTIT/mFhYbh06VKaFIuEh4fDoNFgo9mKrWYrDBoNQkJCEBkZCRnD4G4S5E0kJD5V/t08cd++fentjkQakFj8LSMJiU8Yo9FIbdu2pSpVqtDmzZspV6ZMVDB7Djp+/HiS5jMMQ9v276e6Y8dQk/Hjaf327XHGvH79mkJCQqhTq1YkHj5Cvf5+Qn27dKGrV6/Ga5PneeI4LlnnkStXLroQHExL3wXSrPBwKlSsWJwxzZs0oVYhwdQyOIg0gkghVauQWqmkvYFvqderlzQk8C01atMmZrxGq6WXAAUDFOx2k1qtjjmWP39+uvvoER04d47+3LqVNm/eTH379KEdgpFW6w3UsW1bcrvdCfo7fcECupM3D/VWK6nfiB+oaNGiMceOHj1KDRgZtWH11JqR0dF9+2jx6tUUWbUKbc6Ti1atX08ul4tGDxlCAxgZHdVzpHvgT+vWrYuxsXzdOnK1akl+VSvT9n37yGg0UkBAANWtUoVcJhN1adeOIiMj4/Xt0aNHtGPHDnr69Ol7r7vZYqEL7ki6ExlBjyIiyGw2xxkTGhpKs2bNogkTJtC9e/cof44clNHhoDxZslDXDh1ixr18+ZIEtZrWma1klcnpnIyhDTt3ElHUg76u7dtTm+bNqQkjo456A7VmZCRjGPrL7SaWIToeHkZVAt/Q6PAw4q1WalG/Pu3ZsyeWL/Pnz6enBw/RMdFEJSIiqdO339LfL15Q8eLFEz3P08eOUSNGRhssVnrldtPjPLlp95EjxDBMnLFhYWE0efJkGtivH127du2911BC4mPDsiwtX76cJk+eTJs2baKiRYvS5cuX09stCQkJCYmvmBFDh5L/hg00+NkLmvfTT7R58+Zk23C73bR8+XIaN24c3bt3j+7fv0+5smalV6fPkIGIKge+o+96906Zf+PH028R4eT990N6FhpKv4wdS48ePXrvvJcvX9Lp06cpKCgoReumBhaLhS7cuEHbTpygm/fvU7Zs2T7a2nnz5qWSJUuSXC6P9frOnTupqlJFY3UsfadU0dqlS5NlV6lUUq5cuUgUxdR0l4iIFAoFLVy6lNqFhVCLkCD6beFCUqvVJJPJqHThItT3XSANDXxLgtlEdrs91deXkEhLypUrR8ePHyer1UoVK1akefPmpbdLEh+ThDLXn/qPVMHxdfHmzRsIWh1+N5kxXTDCw2L5YJv/dFhmVSrwWi2y2h1YZzLjhM2OQqKIbdu2pYLn/8/u3btRskgR1KhaNVZzvX+IjIzE2rVrsWTJEgQGBuLQoUMoYDTisNWOXnoDLBwXa/zVq1fhabNBzzDIarPj7NmzcWxevnwZZoMBFUxmaBgGy41mHLLaoVOpUrx1/sCBA7CwLHoaOLj0eqxevTrecc3q1UMPXsB5mwN5eQHr1q2Ld5y/vz/qVakCL7MZxXQ69NUbIMpkyOftHeep/9mzZ2E2GFDKbIaV599bYfHgwQOULVIELqMpXlmVjRs3wtvlQjaNFo04Hhaeh4ZhcMBqwzW7E5xSGeNDZGQkalasiKwcByvLYsovv8TYOXPmDDIYDFgommCWydAv+tr8/vvv6Nm5M8oXKYJpv/6Kw4cPo3XTpqgULeViZllcu3Ytxs5PP/2ExtFbHPtxPDq3bZvo+f3Djh07YGVZdBREmFkWBw4c+P/XBQF6tQbTf/0VANCpdWuU4Xn0MHCw8ny8n0UJiU+F/fv3w2azgWVZ/PHHH+ntjsQXBkkV1FL8LSGRRBpUq4ZfBDGqQR3LIm+OHLh69WqybAzu1w/5eR5tOR52UcSwYcPQMnqn5AiOR1GVCjUT2GWXFPJnzYrfjVE7B78xW7B+/fpEx58+fRpmjoOPICCrh4cUEyKq8vnFixfYv38/nHp9VC8YXoj3PiI+3G43bt++jb///jvJa/r5+WFA374Y8f33yd6l+19ev36NkT/8gCGDBiXLBwmJT41Xr16hSpUqMc0T/7vLQeLzJbH4O90D3ZT+SAHy18XDhw8hajS45XDhnM0BtULxwVvrLl68CKdej6t2J1aZzLByHASFAgZGBo1MFksyIzXo0KIF8vMCKogiiubJ815NsKdPn8JsMGAox6M2L6BhjRqxjkdERMBhNGK8IGIsL8JpMsVJOn83aBC6Rwe+gwwcdHI59Go1Zs+YkWS/z5w5g0mTJuHo0aMxrx08eBDff/89tm7dmuA8Pz8/FPLxgV6tRqc2bRJMiPvmz496rB4LRSMMDAMLI8NmsxXdDFxMkB4ZGYm9e/eiQe3aGGDgMILjkUOhRNVKlRL9HGzatAk//vgjTp48GefYoUOHYGf1GMsLyKdUYhjHw6hSgWcYLDOasddig06hiNVYJyIiAseOHYuVVAaACxcuwKnX45LdiX56Dhaex+bNm+P1qYiPD9aYLPB3eqCy2YI1a9bEHHv69CmyZ8wYs8Xxv+skxuHDhzFhwoSYppwA4DSZ8LvJjMNWO3iNBo8fP0Y2pxO7o/XCfU1m7N69O8lrSEikB/7+/ihevDiICP369ZP0FCVSDSlBLcXfEhJJZdu2bTCzLHzVaoiMDD0NHDxttmTdj+Tx8sJmsxX+Tg+UMZvRt29fFOB57LBYUUGtgaDV4vz58yn2sVvHjijLCxjK8TDp9bh7926i41s0aIAR0YURDQQRU6ZMSfHaXwKnT5+GTRRhUKlQu1IlLF++HA2rV8eoH35IUuzhdrvxbatWsOh04DUazJ09+71zgoODkcluRyeORx2eT1SO8mMREhKCZvXqw8YLaFC9+gf38JGQSCnh4eHo2bMniAjVqlWTZP++EKQEtcRnj9vtRqtGjeDFcXCwegwfPPiDbV65cgV2lsVFuxOLjSZ4Wq3wNhhwx+HCIqMJBbPnSLbNy5cv48iRIwgNDY1zLEpj2okHDhdcen2S9NXOnDmDDi1a4LsBA/DmzZtYx968eQOtUonbDhduO1xQKxRxAog5c+agCM/jL7MFpXgeo0aOTNaT+aNHj8LEsmgrGmFj2SRVlT948ACzZ89GoZw5IWMYlCpYCK9evYp37IihQyHK5MgcrZ2cSS6Hl1yOBw4XfjeZUShH1HvQqHZtWNRqGORyeCmU8FEoMFM0IotWh+XLl8dre/GiRchoMKArx8PEsjhz5kys45MnT0YbMaoSZppgRG6FEhaeh4njoGMYqImgV6tjJXwTY2Dv3lDJ5TAbOOzfvz/BcWNGjoQPx6O1IMAmCHE6bIeEhODq1aupEgwa9Xrssdhwxe6EUauFn58fvm3VCmV4Hr0MHCwchydPnnzwOhISaU1oaCi6desGIkK5cuWkz61EqiAlqKX4WyLphIaGfnB15+fOiRMnoJLLccJqx53o2Pvdu3dJnt++eXNU4QWMiE4g37lzB/26d0d2Dw80qVMnTqyfXEJDQzFuzBh0btsWx44de+/4nl26oCkv4LjVjiKCgCVLlnzQ+p87VUuXxnhewN3o/j4J7f5MiFu3bsGq0+GGPaoYxPyf3a/xcePGDXhGFxNdtTuhUSpT6H3qMWnSJJTneZyw2VGdF/DjiBHp7ZLEV87s2bOl5olfEFKCWuKLwO1248SJE7hw4UKq2fyuXz+o5HIYDQbMmDEDGQ0GXLA58BMvoFSBAkm2Ex4ejpKFCkFFBB3DIHe2bAgKCoo1pnDOnOjGCxjLC7DwPN6+ffvB/jeqVQv5BQH5BAFN6tSJczwiIgIDe/dGQW9v9OzcGWFhYcmyP+S779DrX1sP3yc5cffuXVh5Hjm0OtTQaHHP4UItrQ5KhkGrRo1iqg/CwsIw6ocfoJLJcMrmwB2HC7xMBm9PT2TPmBF5BRFmHYtlS5di79690BKhhU6H5lodtEQYyvHwd3qgv4HDgL594/WlSc2amBK9FbODIGLixImxjp8/fx4mlkVXAweXWo2yJUrg6tWrmDt3LopyHG7YnRjPC6hdsWKseUePHkXxfPngmzcvDh8+HOtYaGjoe6VT3G431qxZg4kTJ+LOnTuJjv1Q5s2dC06jgaDRoHfXrjE+/jhyJNq1bo2LFy+m6foSEqnNkiVLoNFo4OHhkaSbbwmJxJAS1FL8LZE0tm3bBkGng1apRM/OndOsCXNoaCgePXr0yTZ5drvdqFGhAnwFEUUFEXWrVEnW/KCgIHw/ZAjaNW0aJ4b82Pz999/YsWMHKpcqBSvPo1ObNl/EFvpz586herlyqF6+fLLvGauXK4eRvIhbDhfyCQI2bNiQrPmPHj2CoNVin8WG+aIJXnb7e+eEhIQgs9OJdhyP6jyPamXLJWvNtGDYkCHoGH2v1Yvj0aVDh2TfQ0pIpDZ79uyBKIowmUxS88TPHClBLSGRCP8kFd1uNwb27g21QoHMTidOnTqFTm3aQNDpUKpgwUR1vDZs2IDsKhXuOFwYzwuwK5Vxgpr79++jVcNGqFu5SrySEykhIiICGzZswMaNG2MFladPn0apAgVQxCfnB0k4rFmzBlkMBkwTjMjD8Zg9a1ai46dOnYpmooheegNa6Fj4Oz3QUsfiW1aPwoKAFStWAAC+698fJQwG2GQy/CyI+N1kBhut9xwcHIx9+/bh+vXrqFetGjIZDGAZBqM5Hg8cLsiIYNaxaCMaYWZZHDp0KF5fJk2ciPw8j3G8AKtWiylTpsRJHp8+fRo//vhjrPfqt99+Q16Ow0W7Az14Ac3r1485FhERAasgYKpgxHTBCDPHpbvcwMuXL7Fv374EK0qfP38Of39/jP3xR5TKnx9NGzSAoNPBpdejQvHiePToEZYuXRqjWy0h8alz9uxZeHl5QaVSYfbs2Z9sIkPi00dKUEvxt0TSyJ4hA5Ybzbhqd8Kl13+QDEVCnD9/HnZRhKjRoFyxYggODk71NVKD0NBQrFy5EqtWrfpsk3b79u2DkWWRSxCRM3PmBHc6fm78I384hhfwIy/Aw2JJVs+dS5cuwdNmg1IuR/P69VOUsJ81fTqMej0y2mxJjq39/f0x9LvvMHbs2E9CTuPevXvwsFiQSxRhUKqgUyph5rgPKgx49+4d+vfsibqVK2PTpk2p6K3E18SNGzeQPXt2KBQKzJs3L73dkUghUoJaQiIZ/JPsWLVqFQoIAs7aHOjI8WjXrFmCczZu3IhsKjVuOVwYzfEwKhQ4cuTIx3I5Fm63GxmsVvwsiJgnmiCybLK2H/7X1tzZs1G/alVM/vnn9yaCtm/fDi+DAdMFI0SZHAaZDHaZHKetdlQWxZgvkoq+vlhoNGGbxQqHTA6zTIY6tWrFsnXx4kVkMBhw1+HCbosNBoZBPZ0OOb28cOLECfz6669Yt24dqpQqhRL58mHnzp2x5kdGRmLar78ip6cnHFotshoMaN24caL+L1q4ELxGA1GphEomQ6GcOXH//v2Y4+/evYNaocANuxM3HS5olcoP3o75Idy9excOoxFFTCaYDQacO3cu1vFpU6Ygg9mMzC4XfAyGKNkUtRoNtFr4OVwoJAiwGY2oajTB02DAr5MmpdOZfFpERkbC398/XqkeiU+DFy9eoGrVqiAitG3bNs6OFQmJpCAlqKX4WyJp+GTMiMVGEy7bnXCw+jTZgVW3ShWM5AX4OVwoLYpYunRpqq8hEUXNChUwKXqXYVWjEQsWLEhvl1KFgIAAaJVK3ElE/vB9uN1uhISEpJGH6c+FCxeiKszLlUv0QdObN28wbdo0+PA8bjtcmCKIKFu4cIrX7dKuHarxPKYIIiwsK+3ilEgxr169QuXKlUFE6NOnzxex8+NrI7H4W0YSEl85AQEB1LZJEyqWKzfNmjGDGIYhIqI3b96QlZGRWSYjL4ahN69fExFRWFgYjfnxR2rbpAnt2bOHiIiqVatGOcuXoxyPH9HYwLfUvGNHKl68eLqcDwD6+/lzqqbRUnmNhhAZSW/evEmRLYZh6NvOnWnt1q3Uu1+/mGuTEJUrV6Z+Y8bQ6ixe1LJjB1rx11/kNuipZlAgvXK5qEmTJkREVLd5cxoRHETL372jYLjJwrJUq04dOnLkCC1dupSePn1KgiBQYEQEXQkPp9NhYcQJAuUbMIAOnjpFRYoUoZ49e9L3AwZQkYuXqO19f2pcty69jn6PiIhkMhm1bd+ebj98SHkBehwYSH+sXk0HDhxI0P/vBw6kFXqOTput5GBZmr9iBWXIkCHmuE6no5ZNm1KNoHdUIyiQGtevTwaDIUXXNjVYvHgxVYuIpHVqLXVkZDT7119jjl27do1GfvcdLWDklOH5cyrjBpVWa6iWWkN+EZH03O2mF2HhZI2IoHkaLU1RaWj0kCHUqXXrFH9evgQCAwOpVKFClC9bNvJyOunq1avp7ZJEPBiNRtq0aRMNHz6cFi1aRKVKlaJ79+6lt1sSEhISXyTT5s+nPmGhVPD5U2rZsQPlzp071ddQq9X0lojCiCgYIJVKleprSERhsdnoIkB3IsLJLzKSzGZzmqzj5+dHVUqXpjyZM9OC+fPTZI1/w3EcVa1YkRoGB1Gj4CCqXa0asSybLBsMw5BarU4jD9MXt9tN1SpUoBJnz1GJs+eoWoUK5Ha74x1rMBgoR44cUfMACgORTC5P8drnTp6ktgolNdSxVFCrleJriRQjCAJt3ryZevToQZMnT6batWt/1feuXxwJZa4/9R+pguPjcOXKFTSqUQNNatfG9evX09udNKFTmzZoyAtYZTIjg94Qsx0rICAA+byzw4vjYOa4mGZ5fbt3RxlewBhegJllceXKlRhbQUFBCVYZ79y5E+PHj4/TrC8t6N21K7w4Dj48j0a1aqXbFvjIyEjcuXMH169fj/N0c/369aj0zTcoljs3Rv3wA36bMwcuvR7VTSZksFrx9OlTLFywABmtVuT39sbZs2fj2Oe0Wpy2OeDncMGp18f5jEZERIDT6eCjiKqm+EUQUaFYsQT9zZMlCyYLIvZZbDDpdLh9+3acMW63G/v378e+ffuStW0wIe7fv48DBw6kaEvfnDlz4Mvz2GuxoQrPY8Tw4THH9u/fjwwKBfwcLkwTRGgYBrXMFhi1WmT28ACn1aJ9q1Yw63T4TTShgVaHkio16vMCvm3V6oPP63Nl7ty5qCSKuO9wYch/JF4kPk02bNgAnudhNBqxffv29HZH4jOCpApqKf6WSDIRERFpKrtx69Yt5MiYEXKZDE3r1E13CbUvmSdPnqByqVJwGY0Y0KtXmt0nVCxRAr15AetMFlhZFlevXk2Tdf7N8+fP0axpUzRs0CDWLsjUZs2aNbAJAswGAwrkyIFWDRvh8ePHabZeavD27VtoFArccbhwJwk7QSMjI9Gkbl0oZDI4jMYPuoedNHEisnAcmohG2EUxUelMCYmk8k/zxJw5c8Z73y7xaZJY/J3ugW5Kf6QAOe2JiIiAh8WCYbyAwbwAL4fji9T6rOjri99EE/ydHqhuNGHx4sUxx0JDQ3H+/Hm8fv065rWS+fJhpckMf6cHapjNMbrKibFq1Sq49Hp8y/MwsSxOnz6dJufyD263G0eOHMHevXtTJYmaEl6/fo3CuXJB1Gjh5XDg7t27AKIaHDSpWRP9e/WK1SiyVP78WGaMuq5VTGb8/vvvsey9ePEC27dvjxVsDuzdG5k5DgVFERVLloz3XKdMmYLMShVuOlwYw4uoXLIkAODBgwc4depUrBugU6dOIUfGjLBwHKZOnpyKVyN+duzYASPLIr9oRPaMGdGgRg04jUa0qN8g0e2Fz58/x4ULFxAUFIT/deiALA4HWjZoiA0bNqBjq1b4dfJk+Pv7Qy+TIbNcAZGRQUaERYsWxXqgAgCrV69GvqxZ4aVW45LdicVGE8oULJjWp/7JsmjRIpQQBNxyuNCNFxKV9pH4dLhx4wZy584NhmEwZsyYdPt/T+LzQkpQS/G3xKeHtF37y8HH0xN/mS144HAhnyhiz549ab5muWLFUJfn0Ybj4e3pmSYPOkJDQ2HQaLDBbMFfZgvURCir1aJMkSKpvlZq07BmTRQURBQURDSoUSPRsTOnTQOv0cCi06FLu3bvtf327Vv8r0MHVChaFEuXLIlzfMuWLZg+fXqaPjiQ+PrYvXt3TPPE/fv3p7c7EklASlBLpIiXL19Cr1LhnsOFuw4XVHL5F6nzuWrVKthYPb4xmeFps+Hp06cAovR9c3p5QcYwaFSzZkwjlPGjR8OH49CB42E2GODn5/feNZrXq4eJfJTWWyeex7hx49L0nJLD0aNHUTRXLhTMnj2moeLsmTOR1elE6UKFcPPmTRw7dgylCxZE2cKFcfTo0QRtnTx5EjNmzMDFixcxadIk1OIFPHC40IMX0KVde9y+fRsmlsVPvIBavBBLE7pjy5aozwtYYDTBodfHSuLfv38fLrMZJc1mmPT6mM7nbrcbBw4cwObNmxPUC46MjESbJk2glMvhYbHg/PnzWLVqFUStDll5HuWKFUtzrWG3241JEyeiWpkyGD96dEzyrGrp0pgmGOHv9EAFvQG5tFoctdpRgecxceLEeG3t3bsXRlYPL45D0Tx5YvTFT548CQvLYiTHoyDPY+zIH1GyYEEU0xtQlOOQzelE4Rw58MOQIXEeND19+hQZrFaUEwSIavUn9fn82ISGhqJ+tWqQMQzyZM0qBdGfEYGBgWjWrBmICHXq1In1YFFCIj6kBLUUf39NPH36FM+fP4/z+qVLl7B48WLcunUrHbyS+JKZO3s2bCyL/KKIYnnzprm2c2RkJGQMgzsOF/ydHrCxbJrEcYGBgdAqlbhgc2ACL8DAMKio1kAnk+HRo0epvl5qEh4ejvXr12P9+vXvTd4LOh0OWG24bnfCpNW+9563S7t2qP2ve7njx4+npusSKeDMmTPo06MHpk6d+kXvSvmneaJSqZSaJ34GSAlqiRThdrtRpUwZlBRFFBdE1K5UKb1dSjMuXLiAtWvXxgrcWzRogN58VCVlMUHA8uXLAURdlz/++ANjxozBtWvXkmR/yqRJyM/z+FkQ4aHXY8eOHWlyHv8QHh6O58+fv7fi3e12wyaKmC4YMV80wcjqce7cOVhZFpvNVnTSG2BUq6FhGPzMC8inVIIhQk4vrzhByo4dO2BlWbQwmmBiWfTv3x+VBQH3HC504AV079QJmzdvRuno6vNNZivyeHnFzA8ICEDntm1RvkhRLPtPY5yJEyeihSDA3+mBUbyAlg0bJvuahISExFyPfFmyYpXJjPsOF/IKInbt2pVse8lhyZIlyMlx+IUXYVer0ahhQwQFBaFt06ZoywvYZbEho0aDWjod/J0e6MrxGNS/f7y2KhYvjmmCEQ8cLpQ2GrFy5UoAwIwZM9DcGLUTYI5oRM1y5REYGIjZs2ejTq1aKM1x+NNkQR6Oj/ks/5uDBw9C0GpRRRRhYlkcOnQoTa/Jp45UwfV54na7MWXKFMjlcnh7e+Py5cvp7ZLEJ4yUoJbi76+FUd9/D06tBqdWY8rPP8e8vm/fPphZFnWjCwASa5omIZESLl26hF27dsWRh1m7di1aN26MXydPTvKupwcPHmDq1Kn466+/ErzHKVukKOrzPNpxPLJlyJBmSbkfhgyBUasFz8gwR4wqNqmmN2D+/Plpsl564GE2Y5HRhN0WG3iNJqaIKyHKFS6MxdH3ItVNJqnRaTpz7949mPR69DNw8OV59O/ZM71dSlNevXqFSpUqgYjQt29f6V7uEyax+FtqkiiRIAzD0F87dlCXqVOp+4zptGbz5vR2KdmcPHmSfPPkoYLZs9POnTsTHJcnTx6qX78+mUymmNfCQ0OJIyIVEekYhsLCwogo6ro0atSIhgwZQtmzZ0+SHz169aK2339PZ8qXo4lz51KlSpUSHf/06VPav39/rKZ/R44coaK5clFhHx/at29fgnOvXr1KXk4neTmdVLl0aQoJCUlwbEREBL1884YqaDRURqOh8PAwevDgAVmUSsqjVNKZ0FBqq1ITQ0QRRMQyMrrjcFHFFy/ph0GDYtlas3w5/U+uoJ80Wmouk5NcLifkzk2ZHz+i03YbDR05kooVK0Z3GKL+Qe9oQFgo1W/WLGY+x3E0e+FC2nPiOLVo2TKWbZfLRZcAuhweRseJyCNTpkSvX3z80/Dk7du3ZDSb6FxEBN2KiKBnEeGx3vd/ExISQuPGjKHe3brRlStXkr3mP1w8f54quUHT3r4hHxD5bdpEzerWpQlTp9LTggWok5yhWm3a0gmViqqHBNF6hZy+7dIlXluiyUS34Ka/3ZH0LDKSBEEgIqJy5crR9tAQGv/2Df0cGUFV69cjlmWpc+fOZDIY6BtiqKhaTcWI6O7du3Hs7ty5k5oqlDRfy1I3uYKWzpuXrHN8/PgxfTdwIA0fMoRevnyZ3Ev0ySH/gEYwEukHwzDUq1cv2rNnDwUEBFDRokVp9erV6e2WhISERLrx5s0bGj9+PB0QjLRLEGnwd99ReHg4ERGtWLiQuskVNF2loSaMjNasWZPO3kp8aeTKlYu++eYb0mg0Ma/t27ePerRpQzm376CFI0bQ1MmT32vn2bNnVCx/fjr0ww80oFUr+mnMmHjH/bVzB+Xp2ZNsnTvRvmPHSKFQpNq5/JsRY8bQuevXqWaD+rQxIpz2hYTQZYYoa9asabJeerBszRr6QamgxiFB9MvUqWSxWBId37prVxoSFkZdQoPpHBFVrFjxo/gpET+nT5+mQhot9TFwNEihon07dqS3S2mKIAi0ZcsW6t69O02aNElqnvi5klDm+lP/kSo4JN6H2+2Gy2zGFEHEIqMJIsvGyCEkhYsXL8JhNMKo1aJ04cIfTd7k7NmzMBsMKGIywWky4d69e4iMjISF5zFTNOI30QSjXp+gLEXjmjUxlBfg53ChtChiSTwaYP+mV5cuyGTgkJXj0LpxY4SFhaFs0aLwEQQIcjnmiibU1WhhkslQQqXGfYcLgzkeRfPmjdXsZNqvv6IAz2OOaIQ3x+GPP/4AgBhplH/w9/fHlClT8OeffyZY/fDw4UNUKlkSme12jBs1CpGRkRjUpw98PD3RqmGjFDUUfP78OQrkyAGtUomcWbKgkE9OuEwm/Dx+fIJzWjdujIo8jz4GDhaex7Nnz5K01oJ58+AQRWTz8MDhw4dx7Ngx8BoNDAyDfEoljDIZlHJ5nHmvXr3CsWPHEpUm8PPzg2/evDDq9ejXo0esa3j69Gl8//33WL16dazXDx48CBPLopLZDAvH4caNG3HsLlmyBHk5Hn+YzCjFC5iQyHX5LxEREfDx8kIbjkcTXkCxvHmTPFdCIq3w9/dH8eLFQUTo16/fF721USJlkFRBLcXfXwHv3r2DXq3GXosNW81W6DWamMqyXyZOhC/PY5nRjFwJ7LCS+LqJiIhI0q7M5PDTTz+hIx+1M3KyIKJprVrvnbNu3TpUMEftwlxnsqBg9uyp5s+H8PbtW3Rq3Rql8ufH7Jkz09uddOfIkSNYvHix1ATxE+CfCuo+Bg7FeB4DevVKb5c+GrNmzYJcLkeuXLmk5omfIInF3+ke6Kb052sIkN1ut9To6QOIjIyEUi7HJbsTtxwu8BpNsr8sQ0ND8ejRo2S/D35+flixYkWchnT/JSwsDK0bN4bIsvimeHE8f/4cndu2xXccD3+nB9pyHH788UeEhIRAJZfjmt2Jm3YnWJUKr169itdm07p1MZAXcNfhQnFBxLJly+B2uzFm5EgUy5ULPTp1iqUB53a7cezYMTRr1AhapRI5MmbE+fPncfjwYSxatAgiy8LBssibIwfyZssGg1IJViZDfQMHk16P69evA4i63uNGjULN8uUxferUDwpka1eqhM4GDjssVmQ0GLBjxw4cP348yQni+Bg+dCia8jweOFxoyvMYPnToe+d42WzYb7XB3+kBb4UCmez293bofvz4MXiNBjssVswWjcjscAAAJk2ahFxKJR44XFhhNMOm06X4XFLCzZs3sXbtWjx8+DDe4263GyOHD0fxPHnQr3v3OA8WEuPJkycQNBo8cLhw3+GCXCZLc11vCYmkEBoaim7duoGIUK5cOTx58iS9XZL4hJAS1FL8/bWwaMECGDQaCDod/li1Kub18PBwDB04EOUKF8b40aO/yGboEinn/v37yJYhAwxqNYrkzp1qvR3OnDkDE8uiC8fDU2+It6Hef7l+/TrMLItfBBE1eQEdWrRIFV8kJL5kzp07h369e2PGjBlfneTFrl27IIoizGYzDhw4kN7uSPwLKUH9GbJp0yYY9XpolUpMnTw5vd35bOnfsycyGgzIxvNoXr/+Rwm8r127BrPBgBpmM8wsm2jH6vnz58OXF3DW5kALXkCvrl3x/ZAhqM4L2GexoRjPY+7cuQCA7t9+Cy+OQxaOQ7tmzRK0efPmTWRxuaCUy1GncmWEhYVh9erV8OF4rDZZUIEXMGLYsFhzDhw4gMwch7M2B0bwAiqVKBFz7OXLl7h+/ToiIyPhdrtRqWRJzBCiGj42N5owY8aMD7xisQkODoZZrcYCowkPHC4U0epgMxqRSxRhNhhw4sSJFNkdPnQomkUnqJu9J0EdERGB0SNGwNvhQBaVCp1YPUwyGepotPDNnz/RdW7dugVeocBNhwsHrDbolSoAwKlTp+DQRWl7dzVwqF6+fIrO41MkMjISubNmRXOOR32eR4kCBdLbJQmJWCxevBgajQYeHh44duxYersj8YkgJail+Ptrwu12SwloCbx58ybJO4p6dO6MztGxcx1eSLCBd0o4efIkRo0ahS1btiR5zvbt29GgWjX079kzRbspJSQkvi5u3LgBb29vKJXKL0of/nMnsfhb0qD+RGnfsiX9ptbSXtFEw777jp4+fZreLn2WTJgyhVbv3k0LN2+mpatXE8Mwab7m2rVrqS4jozkqDfVSKGnJnDkJjg0ICCAXw5BFLqdMRBTw8iUNGjqU+AoVqL2coUING1K7du2IiGjqnDn0+44dtGTrVpq/fHmCNrNmzUo3HzygN4GBtH77dlIqlXT79m3yZRgqrlZTRSK6de1arDnv3r0jTiYnUSYjp0xOgYGBMcdEUSRvb2+SyWTEMAyVKFeOlsFNfwS9o71hoZQ/f/4PuFpxuXr1KqkUCur/+hVVefaUroSGkK/bTdu1LPVk5DR53LgU2e3Zuzddtdsp+/OndNVup569eyc4dtLEibRh8mTqExJKgW43rQsKor/MVqqj09HThw/fuxZDRKWf/E21nz2lSLiJiKhQoUL03ZjR1Fejojv589HcpUtTdB6fIjKZjPYcOUJZe/ag/H370uY9e9LbJQmJWLRu3ZqOHj1KSqWSypQpQ3PmzIl6Si8hISHxlcAwzEeJgyU+TQBQhxYtyGYykd1opMOHD793jkwup3AiAhGFU1S8Fx9rVq8mmyCQw2ik9evXJ8mfwoUL07Bhw6hatWpJPofKlSvTmi1baOKvvxLLskmeJyEh8XWSLVs2OnbsGJUtW5Y6dOhA/fv3p8jIyPR2SyIxEspcf+o/X3oFh8iy2GOx4ZLdCUGjgb+/f3q7JJFEVq1aBR+OxyqTGWV4AaNHjkxw7LNnz5A9Y0Zk4XlYeR4XLlyIObZjxw745s6NisVLvFcq5H3cunULFp5H1QSqusPCwlClTFnYWRYiy2LXrl0J2goPD8foESPQpGZNrFmz5oP8io8XL17AbODQV8+hCqtHzixZUJAXcNhqR1NeQM8uXVJs2+12IyAg4L0VRC3q18dP0dp4HTkeSoZBQZUKeobB+HHjEp376tUr8FotxvMCBnE8vDNkSLG/Eh+G2+3GgF69oFOp4JMp0wf/Hkl8/rx48QJVq1YFEaFdu3YfrbeAxKcJSRXUUvwtIfGVcPDgQWTlONy0OzFLNKJY7tzvnfP3338jb7ZsUMrlKFu0KN6+fRtnTEhICAwaDTaarfjLbAGn1Uo9HyQkJD4pwsPD0b17dxARatSogYCAgPR26asmsfibiTr++VG4cGGcOnUqvd1IMxYtWEA9//c/Yojof9260bhffklvlySSCAD6acwY2rh6NfmWKUPjfvmFVCpVguNDQkLo5s2blDFjRuI4joiIXr9+TZk9PGiiSkP+7kj6wyjS5Tt3Psivhw8f0pEjRyhv3ryUPXv2OMfdbjfdu3ePTCYT8Tz/QWsllwMHDtCsX34hV8aM9MOYMXTjxg36edQoMprN9P2YMTRq2DBa9+eflD9fPlq2di2Jopim/mzYsIE6N29BFdUq2hoWRvOWLqWTJ09SuXLlqFKlSu+dv3nzZhrWpw+xLEszFy+mvHnzJnntd+/e0Y4dO8hqtVLJkiU/5DS+eg4dOkSta9SgP7Us/RUSTAd8ctDuo0fT2y2JdCYyMpJGjhxJo0aNooIFC9LatWspU6ZM6e2WRDrAMMxpAIXT24/PiS89/paQ+FI5fPgwtalenbbq9LQzNISWuJx07OLF984DQKGhoaTRaOI9/u7dO7KIIh03mimSiIq/eE6v3r5JcLyEhIREejFr1izq0aMH+fj40MaNG6X4P51ILP6WEtSfMAEBARQWFkYWiyW9XZH4yNy6dYvK5M9PxziBXrjdVPr1SwoMCUlvt5JEQEAAbdmyhRwOB5UrV+694/38/KhQrtw0QKGgo0Skq1CeVvz5Z5r7+T6OHj1Kp0+fpm+++YZ8fHw+ypohISFUsmBB0jx5Qg/Dw6nLwIE0eNgwOnjwIF24cIGqVKlCWbNm/Si+fAls376dBjVtRn9pdbQrJITmuRx0NAk3YxJfBxs3bqRWrVqRXC6nlStXJunhk8SXhZSgTj5fQ/wtIfElAoC6tGtHi5cvJ4NORxu2baPixYuniu0RQ4fStMmTCUTUd8AAGjZyZLzjrl+/TqdPnyZfX1/KnDnzB6/r5+dH8+fNI5PZTF26dCG1Wv3eOW63m0JDQ0mr1X7w+h+DTZs20ZxJk8grWzYa+8svpNfr09slCYnPml27dlGjRo1IoVDQunXrqFSpUunt0leHlKCWkPjMcLvdVL18BXp84QK9cUdSo/bt6afJk9Pbrffy7t07KpInDzlevaZrQe/I4e1Nv//5J2XLli3BOTt27KCRzVvQH2oNXQoPoz5aDV3x8/uIXn86HDlyhDrVqEnbtDq6FhFBnWREYyZNov6dO1NZpYp2RoTTkdOnE72eEv9PeHg41a5Uic6dOkWhRPTH+vVUsWLF9HZL4hPi5s2bVL9+fbpy5QqNHj2aBg8eLGm0fkVICerkI8XfEhKfN0FBQaRWq0kul6eq3QcPHhDDMOTh4RHv8SNHjlDtypWpuFZLR0NCaM/hw8naYfhf3r59SzmzZKEqoWF0myHyqFiJlq5Zneico0ePUp1q1SggMJDat25NM+fP/6S/869evUplixSh75Vq2gU3GatXowUrVsQaExgYSONHj6YXT59R9359KVeuXOnkrYTE58ONGzeoVq1adPfuXZo7dy61bds2vV36qkgs/paaJEpIfILIZDLauGsn/bTydxo7Zw5t+usvUiuV1LV9e/qUHyqdPHmStK8DaImOpQW8QP5XrlLF0qUpIiIiwTlFihShB3IZ9Qt6R/3CQql+06aJrrF3716aMmUKXftPo8cvAQ8PD/o7LJR2hYbQ+rBQypw5M/2xaBENUahoolZHVRRK2rZtW3q7+dmgVCppy969dPjCBbr78KGUnJaIwz/NUxo3bkxDhgyh+vXr05s3b9LbLQkJCQkJiVQBAP355580ZswYunLlCul0ulRPThMRZciQIcHkNBHR8oULqYtcQbNVGmrOyGjVypUftN7169dJiIigkXoD/aTW0s5du947p/e339IImZwuWmy0fe1aOnbs2Af5kFT2799P3hkyUEarlVavTjyJ/m+uXbtGebVaqqfTUSuFki6ePRtnTOtGjeji7DnErV1LFUqWpFevXqWm6+mO2+2mQX36UO5Mmahds2YUFBSU3i5JfAF4e3vHNE9s164dDRw4UGqe+IkgJaglJD4xzpw5Q7t27SIAVKVKFVoxfz7VffmKzpqtdODPP2n79u3p7WKCZMqUifxCQ2hzcBCteveO8iiV9Pr160SDJVEU6djZs1R8xA80cv58GjV+fIJjly9bRq1r16azP/5IpYoUeW+S+ufx48nMcZTTy4vOnTuX0tP6aHh6etKCFStonmcG+ru4Ly1evZryFilCq+CmDcFBtD88jPLkyZOqa4aHh9Off/5J69evT/RBwucKwzCUOXPmj66rLvH5wLIsrVixgiZPnkwbN26kokWL0pUrV9LbLQkJCQkJiQ9m6uTJ9F27dnR/wkQqU6wY3b59O138yObjQ7sZokOhIXRAxpB3PP1wkmUvWzZ6TkQTA9/SyNAQKlWyRMyxGzduUI0KFahCsWJ06NChmNcBkJyiEiAyikp+pibnzp2joUOG0NKlS2MKigBQ47p1aUhQME0DUcfWrZP8ILx06dJ0nWGoR0gQDQwPpWbt28cZc/TYMRqi1lBPvYFsMjndunUrVc8pvVmxYgXtWLiQfn4XTI+3bqPxo0ent0sSXwiiKNKWLVuoW7duNHHiRKpbty69ffs2vd366lGktwMSEhL/z8Rx42jK2LFkVSqJy5qVdh85QsFBQWRlGNIzDOllMgoODk5vNxMkU6ZMtGjVKurasiUxEeHkpdFSPu9sZDabE53ndDqpV69e77W/dulSGqRQUT2tjkBBtH37dsqRI0e8Y69evUo/jx5N61kDHXn1mjq1bEknLl1K0Xl9TOrUqUN16tSJ+fewESMIbjdtO3mSxrZunSRd76QCgBrWqEGPTp4iN4FWlC5Nf2zYkGr2JSQ+FxiGod69e1PBggWpcePGVLRoUVq4cCE1atQovV2TkJCQkPjCOXfuHF26dInKlSuXaBVyStj4xx80VKGkbzRaehEaQvv376csWbKk6hpJoXvPnvTk0SOavns31a9Vi1q1avVB9niep31Hj9LMX3+lohYL9R84MOZYvapVqd7LV2RjZFS3enW69+gR6fV6+mX2bKpbowaFBL6lpo0aUYkSJRJZIXncvHmTKpYuTS0YGU1gGHro50eDhw0jAPTm3TvKazSTnmGIIaLg4GDiOO69Ns1mM504f542btxIXTJlosqVK8cZU61aNeq3ZQtlCSEK0Go+Wt+cj4W/vz/lA1EelYp8w0LJ79699HZJ4gtCqVTS9OnTKWfOnNSzZ08qUaKE1DwxnZE0qCUkPiE8TGZaKldQVoWCKgQF0srduyk0NJRqV61K8shIypM/P23esydJTUDSk9DQUFq2bBlFRkZSy5YtSafTJXkuAHrw4AFxHEeCIMQ6NuqHH2jrr1OpKcPQhIhwWr5pE5UtWzZeOydOnKDmlSrRLtZAZ8PCaLBWTdcfPPiQ00p3tmzZQrN/+YW8smWj0RMnksFg+CB7r1+/Jg+rlS6ZreQmIp+nj+n127efTeMYCYm04OHDh9SoUSM6evQo9e/fn8aNG0cKhfQ8/0tE0qBOPlL8LSGRumzYsIG+bd6cimm0dDwinI6fO5eqyZFhgwbR3jlzqQYRTYkIp52HD1O+fPlSzf6niEappFNmK3EMQ0UDXtOxy5dirml4eHiSE8TJYfHixfRXv/40Ta2hvSEhtCCLF+05cYKIiMb9+CNN+uknUjIyqtO4Ec1asCDV1g0PD6f58+fT8+fPqW3btqn+gCO98fPzo+IFC1JWmYyuhITQpp07ydfXN73dkvgC+ad5olKppD///FNqnpiGSE0SJSQ+E4rny0fl/O5TPoWCugUH0fnr18nDw4MCAwPp+fPn5OnpSTLZl6vM43a7qUX9BrRr5w6KAGjhihVUt27dmOMRERE0fvRoOnv8ODVs1YqaNW+eqK0GNWrQiUOHKCgykmbNn09NmzX7CGcRPyEhIbQiurFJ8+bNSaPRJGv+mjVrqH3TpjTawNFut5uM1arSwg/U74uIiCBPm426Rbopgojmq1Xk9/jxJ90wRkLiYxAWFkZ9+vShmTNnUvny5WnlypVktVrT2y2JVEZKUCcfKf6WkEhd6letSmWPn6CGOpYGBL+j4iNHUo8ePVLNfkREBP0yYQJdPX+emnfoEG8V7pdG92+/pd2rV5NBJiM+Z07afuBAmt8/Xb58mcoWK0Zd5QrazhBV7dqVfhw3Lub47du3KTQ0lHx8fKQ4O5k8f/6cTp06Rbly5aIMGTKktzsSXzA3btygmjVrkp+fH82dO5fatGmT3i59kUgJagmJz4Tbt29T19Zt6PmzpzRk7Fhq2LBheruUprx7947kcnlMsvbEiRPUrFIl2ska6FRYKI1gdXTFzy/F9t1uN924cYNEUSSbzZbo2F27dtGSuXPJO1cuGvjdd6RSqVK8bnxUKVOGQi9eIoaIFLly0o6DB98boJ4/f56G9OlDBND+Y8conxv0h9lCJ0JDabTZSKdToVHkhQsX6LtevUgml9P4X3/9pLt/P3z4kObOmUO8IND//ve/ZCf5JSSSy5IlS6hz585kNptpzZo1VKxYsfR2SSIVkRLUyUeKvyVSi8jISPp+8GDau307VahWjUaOHZsmzfs+dYYMGECnfptHreUK+j48lGatXk1VqlRJb7feS0REBP3y00904fRpatK2LdWuXTu9XYoBAO3atYuCgoKoWrVq743pHz9+TIN69aLnT57SgBE/pFhO79ChQ7Ri4SLKkSc3devR46v8PEtIfO68evWKGjVqRLt376YBAwbQuHHjpN/lVCbR+BvAZ/lTqFAhSEikNe/evcPoH39Ev169cOvWrfR254tizIgR0CqV0KvVWLZ0KYKDg7Fu3TrYWRanbQ5MEUQUypHjo/hy6dIlmNn/a+++o6Oq9jaOP3tm0hNCQkdKEEW89K4QUJEiTaVbKBYsryIqioAVxYpXBRVQvGAviCIiUhRFUQFRpBcpUqSXJIT0TGa/f4AuFAgpk5yU72etWZKZPfs8s9fxzJ7fnNknzD4dWda2iyxr7xs69JQ2mZmZ9pFRo2zXSy6xb7z+erb9bdu2zd4xZIi9/5577OHDh+2xY8dssMdjd1Q5x+6sco4NDQiwR48ezbYPr9drq0RH26ciy9rHI8vaEMlWdbltz+AQW9nlts8/80y+XnNxk5KSYmMqV7E3lIm0l0dG2j7dujkdCaXEb7/9ZmNiYmxgYKB97bXXrM/nczoS/ETSr7YIzGmL0435N/xl4sSJtnlkpP24XHnbPDLSTpo0yelI+ZaZmWmTk5Nz9ZzU1FQ77PbbbbumTe0r48fna/uvjB9vo8LCbM1KlewPP/xw2jaffPKJvapDBzty+HCbmpqa5209/sgj9qLISPt8ZJStHBZuly5dmue+nHb5xRfbIZFl7fiyUTY6LMzu37/f6UgAHJSRkWHvuOMOK8n26NHDJiYmOh2pRMlu/l1y1wpAqfH111/r2Wef1cqVK/3e96C+ffXjCy8o7c231LZlyxxfdbkkOnz4sG4dPFg9O3f+xxWxzyYuLk7jx4/XG2+8oYyMDEnSoUOH9Nwzz+in6PL6rExZ3XHrrbqwVi3df8MNyrBWbeIOa3xwkF57992Cejn/sGrVKl0UHKJBYeG63e3R8p9+OqXNc089pW8mT9ZVa9bqqfvv1/z580/bV3p6ui69+GIFzPhEe998Sz07X6GwsDBVrVhRr6Qk65WUZFUqX17h4eHZZkpKStLRY8d0bWiYBoSGKdMYVQ8P1y9GanRJO90/apRfXntxsW3bNnlSU/VkeIReCA7VwkWLnI6EUqJJkyZasWKF2rdvr9tvv10333yz0tLSnI4FAMXa1k2bdInPqnVQsC7xWW39/XenI+XLggULVCEyUuUiIzXy3ntz/Lzg4GBNmDxZ369YoaFnuWC4tVYvPv+8rurQQa+MH6/jn/OP+/PPP/Xo6NH6PCxcD2V4deM115zy/BUrVujOwYPV4dff9NvUaRo9fHjOX+C//PLjj7rB5da1YWFqHxSk3377Lc99OW3j779rcFCweoeEqlJAgHbt2uV0JAAOCggI0MSJE/Xqq69q7ty5atOmjXZwgc5C4XiB2hjT1xiz3hjjM8bwM0vkyocffKCbevXS9mefVce2bf1epF78448aGxyq0eERirJWW7du9Wv/xcnA3r2V/vlstf75F13dpYsOHjx41udkZGSoXcuWWvz4E3pnxAMa1K+fJP29tEWWpCxZeb1eXZqcou/DInStJ0D/d/vt2r5vn5o3L5xDQtu2bbUsI12PJR3TE94M9ejb95Q2a3/9Vb2NS91CQnWpy63169eftq89e/YoKyVFI8LCNSYkVD+vXiVjjL5avFgHO3XUgY4d9VUO1sIrU6aMOrVvr76pKeqbmqwrr7hCQye+qgnvvae5Cxf65XUXJzExMUrxuDUu6ZgeTUtRa5ZaQCGKjo7WnDlz9Mgjj+jNN99UbGysduZj+SEAKO2uHzxYb1mfbstI11vWp+sHDXI6Ur4MvflmTQoO1a/lK+qdN97Qxo0b/b6N/73xht568kl1/W2lJjz4oCJCQlSjYkV99913SklJUbDLpSout2I8biWlpJzy/PXr16tVcLB6hoZqgNut1flYrueqa67Rc95MPZacpAUZ6Wrfvn1+XpqjBgwapFvSUnVTWqrc5curQYMGTkcCUATceeedmj9/vv7880+1bNlSP53mJDb4V1G4LP06Sb0kve50EBQ/X8yYoXs9AeofGiZfcpK++uorNWnSxG/9t7/0Uo3+/nuda6WjgQE6//zzT9vu8OHDGjP6QcUdOaz7H35YTZs29VuGomLNunWaHhSsWh6P3k5N1o4dO8560bAdO3Yo8eBBvRxeRonWqsW8eZKk8uXL65ExY9T20UflcbnUq18/7ZkzRwvTUvVu0jFlTp6sGjVq6J777/dL9oSEBD371FNKTkzUPQ88oNq1a//j8Ro1auinX3/VzJkz1bVOHfXs2fOUPvrfdJPuWPSdlqenamGWVyO7dTvttqpXr67IChU0PC5ecZI6n1jHrnbt2nrn449znNkYoxlz5mj27NlyuVzq3r27PJ6icMj+p/j4eC1dulQXXHDBKePqT+Hh4fp+2TK9+tJLahwVpftHjiywbQGn43a79cQTT6hFixYaOHCgmjVrpg8//FAdO3Z0OhoAFDvNmjXT8tWr9csvv+jlFi107rnnOh0p34yRjI7fCsKaFSt0pYy6h4Rqs9erfV6vOmf5NLh/f+3Yv19de/ZU65kzleHz6aVXXz3l+e3bt9cIr1f3+VL0szdTo268Mc9Zhtx6q6pWq6a1a9fq++7dVbdu3fy8NEc9++KLatehg44cOaKrrrrqH9c4sdZqxowZWrVypa66+mquRQGUMh06dNCyZcvUo0cPtW/fnosnFrQzrf1R2DdJ30lqntP2rIEHa6198fnnbeMT65+dEx5uFy5c6Nf+U1NT7bhx4+zokSPt9u3bz9iuQ+vWdsCJtYIrlClj4+Li/n7svXfftfVr1bKXtmplt2zZku9My5cvt327dbO3DBpkDxw4kKPn7N27127dujVfa6cOHzrU1o+MtN2jom3dmJgcrbGXlJRkK0dF2VFlIu3AyLK27b/+v01LS7OZmZk2JSXFXt25sw1zuezUqHJ2ScXKNjokxO7cuTPPeU/W/qKLbJ/ISDusTKStVqGCTUlJyVM/S5cutZMnT7abN2/Ott2hQ4fs008/bSdMmJCrbW3bts0++sgj9rXXXrOZmZl5yliY9u3bZ6tXrGhjy5W35cLC7IIFC/za//79++3tN95oB/bpa9etW+fXvoH82Lx5s61fv751uVz2mWeeYV3qYkqsQc0a1ICfzJs3z5YNDbXBHo+9/667CmQb3377ra0QFmYHREXZUGPsR9Hl7aIKlWx0eLi11lqfz2f/+OOPbD8fbN++3b766qv266+/tgkJCbbXFVfYmIoV7T133GGzsrIKJHdxNunVV22dMmXsPRFlbLmwMLty5UqnIwFwwJEjR+zll19uJdkHHnjAer1epyMVW9nNv83xx51njPlO0v3W2hz91oiriEOSfD6fXhk/Xst//FFXXXON+p1YQqKwlS9TRvNDw1XF7Vb7lCRNX7RIjRs31o4dO9S8Xj29HhKmFd5MfV8rRj/lYxmS+Ph41akZo3tdLm2TtL3uBfp22bJsn/PaxIkaPWKEAo3R1X376rU33/x7iY3csNZq1qxZOnz4sHr37q3o6OgcPW/jxo3675NPKiwiQo+MHasKFSqcsW3V6GhNcweotsejS44d1aIVK3TBBRfkOuu/hQUF6dfo8irjcqlNUqK++uUX1alTJ9/9+tORI0dU//zz1SPLp7VGata3r1594w2nY2Xrtdde09cPPqSXQ0L1SUqyFrVorllffXVKO5/Pp6G33KKPZ8xQw//8Rx/Nnn3Ws+8lqXXjxvrPjp2qLGmqy2jb7t0KDQ0tgFcC5F5ycrKGDBmijz76SDfddJOmTp3qdCTkUrZXEcdpMf8GziwzM1MZGRkKCwsrsG2sWLFCS5Ys0eKFC/XdwoXK9Pk07qWXdOvtt+e6r+FDh2rXe+/rrsAg3ZORpgcmT9a1115bAKmLr56dOqnTryt0ZUioHkxNUbMxj2nYsGFOxwLggMzMTN19992aPHmyrrzySr333nuKiIhwOlaxk938u1B+L26MWSip8mkeesha+3ku+rlV0q3S8Z/kAy6XS3cPHy7l4yIf/tDr6qv1f198oWrGyERG/v0zt4MHD6pcQIBaBgaqjMvog71787WdXbt2qazLaFBomPb7fLpi/YazPuehkaM0K7yMqrrdajNjhkY99phq1aqV620bY0679MXZXHjhhZr6/vs5avvc+PG65rbb5DFGvfr29VsRudNll2nYsmWqaKXAyEjVrFnTL/360+rVq1XT5dJjIWH6PTNTt82d63Sks6pevbrWZXn1W0a6Flurmmf4ee4nn3yipZ/O1LzQME3e9LseHjFCU95++6z9r9ywQVPLVVCEMXrrWKL27dtXoMuIALkRFhamDz74QK1atSpyX3gBAApfQECAAgICCnQbzZo1U7NmzTR06FDt3LlTISEhqlSpUp762r93r5pIOi8gQHUyM3TgwAH/hi0BYjt00Gs/L9eBpGOal+XVnRdd5HSkHNu4caPu+7//U2pqqsa+8IJiY2OdjgQUawEBAZo0aZLq1aunu+++W7GxsZo9e3aRrC0UV4VSoLbWdvBTP1MkTZGOn8Hhjz4Bf5j85pv66KOPFB8fr/9de+3fa5c1adJEVS64QN02b9GhzAyNHjs2X9upW7eugitU0O1HjmivterTp/dZnxMRHqZtGV5lScrw+c56BuqxY8d09OhRnXPOOXk60zo/Bg4apK7duiklJUXVq1f3W78ffPaZpkyZomPHjunFW25RUFCQ3/r2l3r16mlbRoZeyfRqpTFq076z05HOqmvXrlp933166O231aBxY40dN+607eLj43WOy6iKy63zJa08ciRH/V/dtZtu/v47lZNR+apVefNHkWOM0T333ON0DABAKWOMUUxMTI7bW2tPmdcPe+ABdf/6a32alqL44GBNuOYaP6cs/u69/36Flymj1b/8qg+uvUYtW7Z0OlKOXd25s65NPKZyxqWru3bVzn37CvTsfqC0uPPOO1WnTh317dtXLVu21KxZs3TxxRc7HatEYIkP5FpSUpKeffJJHdq/X3fce68aNWrkdKQiLSMjQ0uWLFH58uVVv379fPeXkJCg6dOnKyoqSn369JHL5cq2/eLFi3VD//46lpKip8eN0y233XbGtvPmzdN1ffrIZa06dOyoDz/77Kz9lwRPjhmjVydMUM1q1fTBrFmOnaW7evVqvf7KK6pavbrue+ABhYSEFNi2fvvtN3322Wdq0KCB+vbtW6BfRiQkJCi2eXNlHD6ieF+Wvly4MEcT/MzMTL3//vtKTk7WgAEDFBkZWWAZAZQ+LPGRe8y/geIlPT1d/a+8UnMWLlSz//xHsxcu/McZ1/v379fWrVvVqFEjfqpeglhrFRQQoNUVKinUGDVPiNdvv2/y6wlAQGm3adMm9ejRQ7t27dL//vc/DRw40OlIxUJ282/HC9TGmJ6SXpFUQVKCpFXW2rOeOsgE2Tl9u3dX+o8/qb61ekNWG7dtU/ny5Z2OBT9odN55uj8+QW2CgnVFSpLe/PJLtWnTxm/9e71erV69WhUrViywCVJ8fLymTZumoKAg3XzzzWct8v7888/q17Gj3g8J05fpaVrZsIHmL158SrvU1FS9/fbb8nq9Gjx4cI4m8W9OnaoR996rkKAgvfnhh+rQwS8/Jsm3DRs2qF3LlrrO5dZXRrrz8cd1VwGfBZqenq5Nm45PjHO6fjkAFCQK1LnH/BvFxenOGC5OVq9erW+++UYtWrRQ27Zt89zP66+/rg9HjdL/QsL0dEqy0jt11HWDBys2NpYv/ouIv+ox/t5f77j5Zi369FOFuVwq36Ch5n23qFj/PwEURXFxcerbt6++/fZbjRo1Sk899VSpOMEvP7Kbfzs+ctbaz6y11ay1QdbaSjkpTsNZP//8s0YGBevO8AhV83i0efNmpyMVqszMTN0/bJhiGzfW0088Iae/5PGnkJAQHfb5lOTzKTUry69n8GZkZKhDmza65vLL1bhuXU2fPt1vff8lKytL7S++WD+OfVKzHn5Efbp1kySlpaUpPT39tM+Jj49XeY9HNd1uXeh2K/4My0/07tpVH48erbmPPKKOsbHy+XzZZomLi9M9Q4dqenConvNJA/r2zd+Ly0Zu98HFixerU3CwRkaU0X3uAM2fNeuUNr///rtimzRR3eo19E4O1os+m6CgIDVq1IjiNAAAKDAZGRnq26OHAj0etahfX/v27XM6Uq799ttvurxNG60b+6T6d+mqzz/P8SWbTpGamqpIScGSDmdm6MvPZumZwYPVrF49xcXF+S0z8ubVCRMUERKiimXLasGCBX7te+L//qeXZ8zQY2+/rS8Wfk1xGigA0dHRmj9/vm6//XY9++yz6tWrl5KSkpyOVWw5XqBG8dOlWzfdn56mB5OO6YjH45dlK4qTF8aN0/J33tWw3Xv0wQsvFkih1SkT33pLE4IC1fLIIQ28/XY1bdrUb33/+OOPit+8Rd+GhmtySKieeehhv/X9l3379mnPn3/qldAwTQkN04Lvv9fEl19WuchIRZcpozdef/2U51x22WUKP+88XZJ8TPekpeqhZ545pU1mZqYWfP+93gwJ05SQMP2+ebMOHTqUbZb09HS5JJ3jdquWx6Pk1NRsC8mpqam6ddAgNT7/fD324IM5Kjpv3bpV9c49V0EBAbp10KCzFs3/0qJFCy1MS9P/ko7pNZ9Xbdq3P6XNoD59dPn2HRqXlqbhd9yhHTt25KhvAAAAp7z//vva9+OP2lixsprs3q0xo0c7HSnX5s6dq75uj8aGhuluj0ezPvwwz33dcMMN2lmxklokJuinzEy9EFFG04NCVDs1TfPmzfNjauTWgQMH9PCoUfo6MkoTAwJ143XX+bV/Y4w6duyoHj16FPjFO4HS7K+LJ77yyiv64osvFBsbq127djkdq1iiQI1cm/i//+mm58epzgMjtGTFCpUpU8bpSIVqy4YN6mCt2gQFq42kLVu2OB3Jb5o1a6Yd+/crNSNDTz//vF/7jo6O1iFvprZ4vVrl9So6m2VhfD6fFi1apG+++SbHRVdJqlixokIiIvTflGSNTUlS47p19cCIEVpYNlpflY3WPcOGnXImdVBQkL5ZskSfLV6sDdu26corrzyl34CAANWrXVvPpCTpxeQkRUaWVbly5bLNUqVKFQ2+4Qa1TUxQl8QEPfPcc6c9cyEzM1PjnnlG7Vq21OqZn+mJhKOaOWmSZsyYcdbXe/+dd+rKuHitqVBJS2d/keMPGs2aNdMHs2Zpb8+rdeMTT2jUw6d+WbD/wAHFBgaqcUCgogICdPjw4Rz1DQAA4JTjZwwbBRuj8tYoNTnF6Ui51qRJE823Pn2akqyPZNXkoovy3FfZsmX16/p1WrZ+vbpdfbUW+bL0S3q6NmVmqEaNGn5MjdzKyMiQ2xiVdblU3uVW2hl+7Qmg6DPGaOjQoZo3b5527NihFi1aaOnSpU7HKnYoUCPXPB6PbrnlFj300EOqVq2a03EK3aBbb9XLWV7dlpGmmdanPn36OB3J7wriJ2CNGzfW/Y88osE+r76tUV2vv/uOpOPLU0yeOFGD+/f/uyg7ZMAA/V/Pnrqrd28N7t8/x9sIDAzUoiVLlN6rlyKvv14z/1WwzczM1Nq1a095nsfjUaNGjVS5cuUz9j3vu+9kevVS4pU99M1PP8rj8Zw1z/jJk/Xrhg3atH27ht5992nbjB4+XF8895y67fpTm1KSFeVyqalMjs5YTktJUQVjFGqMwl1GqampZ33OXzp06KDX33pLQ4cNO+06WQ88/LAGpCTritRkxdSvr8aNG+e4bwAAACcMGDBAB6pWUYvEBL0d4NboJx53OlKudevWTWNeflk/tL5YAx58UEOHDcu2fWZmpgb26auyoaG6/OKLdeRfy9Xt2bNHCQkJenHSJHkvaafHoyI1fMyYfK1tjfyrXr26brz5Zl2cEKeex47qhQkTnI4EIJ86deqkZcuWKSIiQpdeeqnee+89pyMVK45fJDGvuEgLnLRp0yatXLlSbdq04eyDfJo8caImPvigBhqXXsnyatL776tf795aV76iZIwaHj6o/YcP5/lM/Scee0xPPvGE3DLqFhKs7TVrasXGjX5+FXnXumFD3bt3n1oHBeu6I4d1ODBAcR6Plv72m2JiYrJ97s8//6zunTrJeL1q0KiR5i5apKCgIL9l27Rpk44cOaJWrVrlqCAPAMUJF0nMPebfxd93332nuXPmqOVFF5XIkyyk49ck2b17typVqqTg4GCn4xS4qVOnatr992tyUIjGpaWq/HXXavykSZKkN15/XaPuHa4yHo8atb5YM+fO5QJeBWjWrFl67YUXFHPeeXpu/PgcXYhy//79CgoKUlRUVCEkBFAYjhw5or59+2rRokUaPXq0nnzySY69J2Q3/6biAORB3bp1VbduXadjlAjLFi/WQOPSgLBw7Uw6plWrVqlsRITmpKXKJSk8NFShoaF57r9rjx6a9tJLWhAWoS1er4bFJ/gtuz906dlTY8dPUOuMDK33eDRu/Hh1795dFStWPOtzW7VqpZ379unw4cOqVq2a39/02McBACg5lixZov7du2uwy62RU6Yo6dgx3XDjjU7H8ju3262aNWs6HaPQJCYmqoqVyrndqmGl/QkJfz829uGH9UF4uC7wBKj90qVavXq1mjRp4lzYEmzjxo26dcAAjQ0M0sK163TnsWN675NPzvq87H7BCaB4KleunBYsWKChQ4fqmWee0caNG/Xuu+8qPDzc6WhFGiV8AH9bvHixZs6cqZSUwluvr1vv3no1y6unko5pRpZXnTt31hcLFuiz2udqRq0YzZ4/P19n7zZt2lSNW7dWp+RjGpR8TGOeezbfmZOSkpSVlZXvfiTp4TFjNHLSRFUefq9++GW5brrpphwVp/8SGhqqGjVq8I0sAADI1nfffadengDdHVFGd7g9WjhnjtORSgVrbY7njdZaTXjxRXVq3VqPPfigvF7vWZ8zcOBArSsbqUuSj2maSxr+4IN/P1YuOlqrMjK0xZupRK+Xs3QL0JYtW/Sf4GB1DwnVtZ4AbVy3zulIABwUEBCg1157TRMmTNDs2bPVtm1b/fnnn07HKtI4gxqAJOmJRx/VW+MnqEqAR89UqaKffvtNgYGBBb7dfv36qWzZslq+fLm+7NRJLVu2lCR976efELtcLs2cO1cbNmxQVFSUzjnnnDz35fP5NGTAAH04Y4YiwsI0e/58XZSPC9dIx9f7vv766/PVBwAAwNnExsaq39NPq3zSMX1sre7v1Cnb9vtO/EqrXr16fBGeR1999ZWu7d1byWlpGvPYY6e9MPXJPv30U01+/HGN8gTo9Q0bVCYqSveNGJHtc8qXL6/Vv/+urVu3qkaNGoqIiPj7sbc+/liD+/bVq3HxevqFF866fBzyLjY2VsM8Abo9LVXrMjN09y23OB0JgMOMMRo2bJjq1Kmj/v37q0WLFpo1a1a+awglFTMNoATJzMzUnDlz9PXXXyu368tPmThJbwaHaHpQiJL27NHq1atz9fy33nxTzS64QFd36qx9+/bl6rmdOnXSww8//HdxOq8++vBD1alWTU3r1tWKFSv+vt/lcql+/fr5Kk5L0g8//KCf5s7V2vIV9Yhxa/jtt+erPwAAUPps3rxZndu21cUNGmj+/PmFtt127drp7U8/VcI1/fXQq69oyK23nrHt9OnTVe+889S9TRt1v/zyHJ3Ji1PdMnCgJgUFa0m5Cnr+6ae1a9eubNuvX79el1mpY3CIuslow6pVOdpOUFCQ6tWr94/itCQ1atRIqzZv1p+HD+lW5q0FKjo6Wr+sXaNe/31e0z7/XDcOGaLt27fn+jMZgJLniiuu0LJlyxQeHq5LL71U77//vtORiiQK1EAJYa3VVZ066bGBgzSsb1/dOWRIrp5f+9xa+jQjXQvS0nQwMzNXxdz169dr1F13aeSROFVe/rNuGzQot/Hz7eDBg7r95ps1Li1DAw8c1HU9exZ6BgAAnGaM6WuMWW+M8RljzngRSGPMFcaY340xW40xowozY2nXr3t3tVy7Trfu3afr+vTRkSNHCm3bnTt31iuvv65BgwbJGHPGdk+MHKkpIWFaHF5G21eu1LJlywotY0mSmelVuHEpxBi5jTlrob9ChQp6NyVZdyQmaEJmhq4tgWuEl2QVKlTQjTfeqIyMDMVUraqL6zfQVZ068QUPAF144YX6+eefdfHFF2vAgAF66KGH5PP5nI5VpFCgBkqIPXv2aPnPP2tmSKhmhoTpf2+/natv7N+bOVN7Lr5Ib9eqqXemT1fVqlVz/Nzdu3erZlCQ2gQFq7MnUDu3b8/LS8iXo0ePKtTlUqPAQLUKDNKhuDi/b6Nt27Zq07WrGhw+qLE2Sy++9prftwEAQD6tk9RL0uIzNTDGuCVNlNRF0n8kXWuM+U/hxMOuvXt1ZXCwLg8KVrjLpYMHDzod6RRly0ZpkzdTu7K8SvB6VbZsWacjFUsvTZqo65IS1Sr+iAbedJPOPffcM7bdsWOHHn3gAY0IC9fhrCxdWL++OnToUIhpi5+VK1eqcZ06qlmxoqb9739Ox/nbQ/fcq5eCQ7Qssqz++PVXLV58xsMxgFLkr4sn3nLLLXr66afVp08fJSUlOR2ryGANaqCEiI6OljwezU5NVZz1KaZq1WzPjPm36tWr69N58/K07djYWKWVK6c+R45oZ0aGHh8xNk/95Md5552n2Pbtdfn33yvZm6XRDz/k9224XC5N++ADvTxlikJCQuR2u/2+DQAA8sNau1HS2eYALSVttdb+caLtR5KukrShwANCd9x5p/pNnqwoj0d1GjRQnTp1nI50iinvv6fre/bUKwcPasTDD6t+/fpORyqW+l9zjbp176709HSVK1cu27Y7duxQzcAgDQkJVevMDN25e3chpSy+Bvftq0GH41Q/IEDXDRumjp07q3r16k7HUnh4mPbuy1KCz6ekrCyFhYU5HQlAEREYGKjXX39d9erV0/DhwxUbG6vZs2erRo0aTkdzHAVqoIQIDQ3VrLlz9cjw4QoODtbnr79eaNsOCwvTkpUr9f333+ucc85Ro0aNCmQ71lrt2rVL0dHRp6yxZ4zRR7Nm6bffflN4eLjq1q1bIBkkKTw8vMD6BgCgEJwj6eRLye+W1Op0DY0xt0q6VRIfnvzkyeeeU9errlJiYqLat29fJL/wrlevnlZt3ux0jBIhPDw8R3PHFi1aKCWyjG5MPKZt3kzddOfwHPUfHx8vj8dzyty4NDgSH68mgYGq7fEowuNRQkJCkShQvzJtmvp066anDhzQsLvuyvd1dgCULMYY3X333brgggvUv39/vfzyy/rvf//rdCzHmeK6aH/z5s3tr7/+6nQMoNRITU1VcHBwrs7K9iev16urO3fW8mXL5DVGn8yerfbt2zuSpaBt2bJFaWlpql+/vmPjXdi2bdumbdu2qVWrVoqMjHQ6DoBSwBizwlp7xjWaizJjzEJJlU/z0EPW2s9PtPlO0v3W2lMmzMaYPpKusNYOOfH3QEmtrLVDs9su82/Af+Li4jR9+nRFRUWpX79+crlcSkhI0Jw5c1SlShVdfvnlZ+3j8Ycf1n+ff14yRuNfeUU333JLISQvOiZPnKhHHnhAEW6PmraN1YwvvpDLxSqmAIqPrVu3qkaNGgoMDHQ6SqHIbv5NgRpAtjIyMtSnWzfNX7RINSpX1oLvv1ft2rULPcdXX32lEf37a3ZImL5KS9O0alW1dM2aQs9R0J4ZO1YvPfusglxudbrqSk197z2nIxW4efPmaWDfvqoTHKwDQUH6efVqlS9f3ulYAEq44lygzomzFKgvljTGWtv5xN+jJcla+0x2fTL/BvwjLS1NTf/zH52fkKA/rdVFvXpp0tSpuerj8OHDql2tmn4oG60E61O3o0eVmJpSak5u+Mv27dt19OhRNWzYkOI0ABRx2c2/OYIDJcyqVav06quvasWKFdm227lzp+bOnatDhw5l2+7jjz/WkV9XaHPFyuqVlKxHRozwZ9wcCwkJUUJ6hhJ9Ph3wZSkkNNSRHAXJWquxY8dqbkSkFoVH6LNPP9WePXucjlXgXnn2WT0eEKQZQSH6T1q6Zs+e7XQkACjpfpF0vjGmljEmUNI1kjj4AoVk48aN8sXHa1JImF4PCtYnn3yS6z7cbrespBRrdcxn5XGXzo/2tWrVUuPGjSlOA0Axx1EcKEGWLl2qDrGxWv7YGHW55BItWrTojO2a1a+v5wYPVsMLLtCOHTvO2GdWVpY8On6wCJBkfb6CiH5WycnJSvZmqtmBffrvsUQ1b9Mm1334fD69++67GjdunHb74cIzmzZt0vLly5WVlZXvvqTja1FFR0bqt4x0rfdmymdMqVjvunpMjH60Pq3OyNBGb6aqVavmdCQAKLaMMT2NMbslXSzpS2PMghP3VzXGzJUka61X0lBJCyRtlPSxtXa9U5mB0qZmzZo6kpWlt5OT9Gpamhrl4SKUUVFRembcOLWPP6Lrko9p6jvvlLqzp0uTL7/8Ur27dNGo++5Tamqq03EAwO8oUAMlyGeffqobXG49ExyiW90effbxx6dtN2XCBA1zufVBYLCu8Pn00UcfnbHP/v37K7Def1TvyCG9GxSox559tqDiZ2vVqlXqFRqq7VWr6eGISO3Npqh+JiPuvlsv3XWX1jz9jC5q0kQJCQl5zvPS88/rkmbNdX3HTurVtat8fircT581S+PLROget0tvvP12qViP+dnx45XVNlYPhIXo5vvvV8eOHZ2OBADFlrX2M2ttNWttkLW20l/LeFhr91pru57Ubq61to61tra19innEgOlT3R0tL5cuFCr28YqtFdPfTBrVp76uXPYMB1LTVV8UpJ69e7t35AoMtauXasb+/dXu2U/a9XUaRoxbJjTkQDA7zxOBwDgP42aNNGTRjo/NUWzJQ1r2vS07aqfe66WGKMWGRlaKalDNle7Dg4O1lc//KCEhASVKVPGsSvNd+nSRZc/+aS8KclakJWpCddem+s+Zs+cqdcDg3VBQIB6padq5cqVuuyyy/KU59mnntKM8HDVcHvUbulSbdy4UfXq1ctTXydr06aNNuSh+F6cRUVF6eMvvnA6BgAAQKFp2bKlpvth/uPU3Ly4Sk5O1vLlyxUTE6NatWo5HSdH1q9frxYhIeoTGKxK6Wl69ZdfnI4EAH5HgRooQa677jrFHTqkuXPm6IbOnXXzkCGnbTf6kUc0dOdOPbBkiXr0GaRrz1LsNcYoKiqqICLnWKNGjbRo6VJ9/fXXGtysmS655JJc99G8ZUuNX/SdmqWnaZsvSxdccEGe81QsV05Lj8QpPsCnY16v4+MDAAAA4MwSEhJ0cZMmCktM1I70dL09fbq6devmdKyzateune7xenV/VoqWe70aNmiQ05EAwO+MtdbpDHnCVcSB4mnLli06cuSImjdvLo+ncL8jS0pK0lOPP659u3bp/4YPV6tWrfLc15o1a3TLddcpPiFBY557Ttddf70fkxZN33//vRYtWqR27dqpffv2TscBgHzJ7iriOD3m3wCKs/fff19vD7tbbwaHaE5qimZcUEcLly51OlaO7Ny5U7Nnz9Z5552nLl26OB0HAPIku/k3Z1ADKDRvvP66Hhw+XNEBAapRv77mffddoRapw8PD9czzz/ulr4YNG+rndev80ldxsHDhQg24+mr1c7k14L//1dQZM5gcAwAAoNioUqWKtnkztS7TrWU+n86pXsPpSDlWs2ZN3XXXXU7HAIACw0USARSaZ8eM0duh4fo6NFy71q1TaTwLy1qrtLQ0p2Pk2vwvv9QNLrdGRpTRzW6P5rNmNAAAAIqR9u3b6+b77tOwwAAdbt5c/534qtORAAAnUKAGUGgqVayk5ZkZWpeZqbjMTFWoUMHpSIVq9+7dql+7tsqEh6tDmzZKSUlxOlKOtW7bVh/L6t3kJH1ofbq4XTunIwEAAKCYOXjwoG4dPFj9unfXLw5c7O/BRx/V77t364uFX5e6zyIAUJRRoAZQaKZN/0hfxdTUsAC3nn7xRdWuXdvpSIXqqUcfVbu4eG2tWFmuDRv05ptvOh0px3r16qWxkyZpS7eueuTll9W/f3+nIwEAAKCY6d+jh7I+n63GP/6krpdfrvj4eKcjAQCKANagBvLI5/Npzpw5SkxMVM+ePRUWFiZJ2rNnj+Li4lSvXj25XHwHdLK6detqyapVTsdwjM/nU7C1MpI89vjfxcn1Awbo+gEDnI4BAABQqqxdu1YDe/fWoSNH9OBjj+nOYcOcjpRnazZs0PNhEarscmlaSpL+/PNPRUVFOR0LAOAwqmdAHg277TY9NGiwpg27W5dddJEyMzP17jvvqMH556t7mzbqecUVysrKcjrmP8yePVvVK1TQOeXK6bPPPnM6Tq6tWrVKY8eO1eeff+50lDwZPWaM5oSHqd6RQzp6bi3deOONTkcCAABAEXfTNdfomoOH9I47QGNGj9bWrVudjpRnffv00a3pqbo9LUXB5cvrggsucDoSAKAI4AxqII/e/+ADfRsRqQoul2J37tSWLVv0+KhReissXA0DAtXh55+1YsUKtWzZ0umokiSv16tB11yraaFhcrvcGnT99eqWkKDAwECno+XIhg0b1CG2rfq63XrL+nRg3DjdevvtTsfKlZiYGG3etUsJCQmKjo6WMcbpSAUuOTlZP//8s2JiYnTuuec6HQcAAKDYiYuLU/2AQJ3n8aiMx1Osl8WYNHWqPunSRfHx8erfv7+CgoKcjgQAKAIoUAN5dEHt2pq260/VMkZJVqpataqioqK0cc9elTEuJXq9Klu2rNMx/+b1epWemaHzPJFyGSnT61VmZmaxKVB/++236hIUqIeDQ9UoNUVffvJJsStQS5Lb7Va5cuWcjlEoEhMTdXGTJgpJSNCOtHRN/eB9XXXVVU7HAgAAKFYeefppDR46VBFutxq2aqWmTZs6HSnPXC6X+vXr53QMAEARwxIfQB59MneuDl92qb5p3EizF8xX2bJlNfXDD/VBhfK6NjNdDz/5pOrUqeN0zL8FBwdr5AMPqH1igi49mqDh99zz97rZ//bB+++rbdOmGtS3n+Li4go56em1aNFCX6en653kJE31ZemiSy5xOhLOYt68eaqUcFSfB4fquaBgvTT2SacjAQAAFDs33HijVm3apM9/+EGzFiyQ2+12OhIAAH5lrLVOZ8iT5s2b219//dXpGECxs2PHDllrVatWrdM+vnbtWnW8+GKNCwrWV1lZyrr0En04a1bhhjyDuXPn6pN331XDFi101913Mzkv4n744QcN7NZNk4NC9GlmhlLaX6YPZs50OhYASJKMMSustc2dzlGcMP8GAABAXmU3/2aJD6CUiYmJyfbx7du3q05wsC4PClFIepqe3bSpcILlQNeuXdW1a1enYyCH2rZtqztHj9a9kybpvIb1NXXyZKcjAQAAAACAIoYlPgD8wyWXXKK9wcEanJ6qe9PTdMuwYU5HQjE2YvRobfrzT8355htVqlTJ6TgAAABAiTV9+nQNGTBAb735porrr+UBlE6cQQ3gHyIjI/XL2rX66quvFBMTo1atWjkdCQAAAACQjS+++EIPDBmi29wePT37C7ncbg0aNMjpWACQI5xBDeAUUVFR6t+/P8VpAAAAACgGlvz4o/oYlwaHhet6Y7Ts+8VORwKAHKNADTjM5/Pp008/1dSpU5WYmOh0HAAAAABAMdO5Sxe958vSuGOJmuLL0hVXXel0JADIMZb4ABw29JZbtOTTmarsMnpl3PNavnaNAgMDnY4FAAAAACgmLr30Us2YO1fffPON3oqNVceOHZ2OBAA5RoEacNhH06fr6/AyquRy6ZL9+/X777+rQYMGTscCAAAAABQj7dq1U7t27ZyOAQC5RoEacFj9unX1+tatqi2jROtT9erVnY4EAAAAAAAAFArWoAYc9vGcOfJ27aplrVppztdfq2zZsk5HAgAAAAAAAAoFZ1CjVFq+fLm++eYbtWrVSu3bt3c0S+XKlTXtgw8czQAAAAAAAAA4gTOoUeosW7ZM3dq3187nntOAK6/SZ5995nQkAAAAAMAJL/33v6pWvrxa1q+vzZs3Ox0HAFDAKFCj1Jk/f76ucbn1SFiEhno8mvPJJ05HAgAAAABIWrt2rZ4f87jecXnUefce3Xr99U5HAgAUMArUKHVatmyp2dbqw+RkfWB9ahEb63QkAAAAAICkuLg4RQd4dL7Ho0aeAB05csTpSACAAsYa1Ch1unbtqmdem6y5M2fqjssu02233+50JAAAAACApNatW6vShRfqsg0bFJ+ZqVdfHu90JABAAaNAjVLpuuuv13X8VAwAAABAIUlJSdFzTz2l/Xv26P/uuUeNGzd2OlKRFBAQoAWLF2vNmjWqUKGCqlev7nQkAEABo0ANAAAAAEABGzJgoI5++60aWauOM2dq3ZYtqlSpktOxiiSPx6OmTZs6HQMAUEhYgxoAAAAAgAL289IleiAwSHeGR6hWYKA2bdrkdCQAAIoECtQAAAAAABSwLt27a2RGmh5OStQeSQ0bNnQ6EgAARQJLfAAAAAAAUMAmvPaa3mzVSvv27dOSQYMUFRXldCQAAIoECtQAAAAAABQwt9utIUOGOB0DAIAihyU+AAAAAAAAAACOoEANAAAAAAAAAHAEBWoAAAAAAAD41R9//KHeXbqoc2ysfvrpJ6fjACjCWIMaAAAAAAAAftW7Sxd1OHBQ1YzRVV266I/du1WmTBmnYwEogjiDGgAAAAAAAH61eccODQoOUa+QUAVZq4MHDzodCUARRYEaAAAAAAAAfnXjoEG6Ni1V16SlqnbduqpVq5bTkQAUUSzxAQAAAAAAAL96ZcoUzevZU8nJyerRo4fcbrfTkQAUURSoAQAAAAAA4FfGGHXt2tXpGACKAZb4AAAAAAAAAAA4ggI1UERZa7Vx40bt3bvX6SgAAAAAAABAgaBADRRBPp9P/a+6Sh1btlS9887T22+95XQkAAAAAAAAwO8oUANF0Jo1a7T8u+/0Q0Sk3g+L0GMjRzodCQAAAAAAAPA7CtRAERQREaGkrCzt9Hr1uzdTkWXKOB0JKDSpqam6vndvxVSspFsGDVJmZqbTkQAAAFBCWWv12IMPqlalSupyySU6ePCg05EAoNShQA0UQbVr19ZjTz2l/hlpeqNspKZ99JHTkYBC88Lzz+vwN9/qXWO0afZsTZkyxelIAAAAKKG+/vprfThxoqZZo6qr12jEXXc5HQkASh0K1EARddc99+hAQoI2bN+uZs2aOR0HKDQH9+5VA2t1ridAF1pp/759TkcCAABACXXw4EHFeDyqExCgpsal/Xv2OB0JAEodCtQAgCLltrvu0juyuio9VXM8bt10881ORwIAAEAJ1aNHD+0pW1ZdU5P1aGa67nv0UacjAUCp43E6AAAAJ6tXr542bNumjRs3qn79+oqKinI6EgAAAEqoyMhI/bJ2rX777TfFxMSoWrVqTkcCgFKHAjUAoMgpX7682rZt63QMAAAAlAKhoaGKjY11OgYAlFos8QEAAAAAAAAAcAQFagAAAAAAAACAIyhQAwAAAAAAAAAcQYEaAAAAAAAAAOAICtQAAAAAAAAAAEdQoAYAAAAAAAAAOIICNQAAAAAAAADAERSoAQAAAAAAAACOoEANAAAAlBDGmL7GmPXGGJ8xpnk27XYYY9YaY1YZY34tzIwAAADAyTxOBwAAAADgN+sk9ZL0eg7aXmatPVzAeQAAAIBsUaAGAAAASghr7UZJMsY4HQUAAADIEZb4AAAAAEofK+krY8wKY8ytTocBAABA6cUZ1AAAAEAxYoxZKKnyaR56yFr7eQ67ibXW7jHGVJT0tTFmk7V28Wm2daukWyWpRo0aec4MAAAAnAkFagAAAKAYsdZ28EMfe07896Ax5jNJLSWdUqC21k6RNEWSmjdvbvO7XQAAAODfWOIDAAAAKEWMMWHGmIi//i2pk45fXBEAAAAodBSoAQAAgBLCGNPTGLNb0sWSvjTGLDhxf1VjzNwTzSpJ+tEYs1rScklfWmvnO5MYAAAApR1LfAAAAAAlhLX2M0mfneb+vZK6nvj3H5IaFXI0AAAA4LQ4gxoAAAAAAAAA4AgK1AAAAAAAAAAAR1CgBgAAAAAAAAA4ggI1AAAAAAAAAMARFKgBAAAAAAAAAI6gQA0AAAAAAAAAcISx1jqdIU+MMYck7SzgzZSXdLiAt1FSMFY5x1jlDOOUc4xVzjFWOcdY5RxjlXNFaaxqWmsrOB2iOCmE+XdR2j+KM8bRPxhH/2Es/YNx9A/G0T8YR/8pTWN5xvl3sS1QFwZjzK/W2uZO5ygOGKucY6xyhnHKOcYq5xirnGOsco6xyjnGCtlh//APxtE/GEf/YSz9g3H0D8bRPxhH/2Esj2OJDwAAAAAAAACAIyhQAwAAAAAAAAAcQYE6e1OcDlCMMFY5x1jlDOOUc4xVzjFWOcdY5RxjlXOMFbLD/uEfjKN/MI7+w1j6B+PoH4yjfzCO/sNYijWoAQAAAAAAAAAO4QxqAAAAAAAAAIAjKFADAAAAAAAAABxBgfokxpihxphfjTHpxpi3ztL2BmNMljEm6aTbpYUStAjIzVidaH+vMWa/MSbRGDPNGBNUCDEdZ4yJNsZ8ZoxJNsbsNMZcl03bMcaYzH/tU+cWZt7CltPxMcc9Z4w5cuL2nDHGFHZeJ+VirErdfnSyXB7HS+Vx6S85HSve70yQMWbqif/vjhljVhljumTTvtTuV7kZq9K+X4F5tz8xL/cP5u15x5zeP5jv+wefB/yDzwr+wWeJnKNA/U97JT0paVoO2y+11oafdPuu4KIVOTkeK2NMZ0mjJF0uqaakcyU9XqDpio6JkjIkVZJ0vaTJxph62bSf/q996o9CSemcnI7PrZKultRIUkNJPSTdVkgZi4rc7EulbT86WY6OTaX8uPSX3Lznleb3O4+kPyVdIilS0sOSPjbGxPy7IftVzsfqhNK8X4F5tz8xL/cP5u15x5zeP5jv+wefB/yDzwr+wWeJHKJAfRJr7Uxr7SxJR5zOUtTlcqwGS5pqrV1vrY2XNFbSDQUYr0gwxoRJ6i3pEWttkrX2R0mzJQ10NlnRkMvxGSzpBWvtbmvtHkkvqBTsQ39hX8q5XBybSuVx6WS85+WMtTbZWjvGWrvDWuuz1s6RtF1Ss9M0L9X7VS7HCqUcxyD/YV6ef8y18o45vX+wD/oPnwf8g/dp/+CzRM5RoM6fJsaYw8aYzcaYR4wxHqcDFVH1JK0+6e/VkioZY8o5lKew1JHktdZuPum+1To+HmfSwxgTZ4xZb4z5v4KN57jcjM/p9qHsxrGkye2+VJr2o7wqrcelvOL97gRjTCUd/39y/WkeZr86yVnGSmK/Qu6wv/gHx6nTY96ed8zp/YP5fuHjeOg/vEfnEJ8lzoydJu8WS6ovaaeO70TTJXklPeNkqCIqXNLRk/7+698RKtnfxoVLSvzXfUd1/HWfzseSpkg6IKmVpE+NMQnW2g8LLqKjcjM+p9uHwo0xxlprCyhfUZKbsSpt+1FeldbjUl7wfneCMSZA0vuS3rbWbjpNE/arE3IwVuxXyA32F//hOHV6zNvzjjm9fzDfL3wcD/2D9+gc4rNE9krNGdTGmO+MMfYMtx9z25+19g9r7fYTp+ivlfSEpD7+T174/D1WkpIklTnp77/+fSz/aZ2Tg3H69+vWib9P+7qttRustXuttVnW2iWSJqiE7FNnkJvxOd0+lFSKJrI5HqtSuB/lVYk8LhWEkvx+lxvGGJekd3V8bcihZ2jGfqWcjRX7VcnGvNt/mJf7B/P2AsWc3j+Y7xe+Unk89LfS/B6dG3yWOLtSU6C21l5qrTVnuMX6YxOSSsQViAtgrNbr+IUw/tJI0gFrbbH+BigH47RZkscYc/5JT2ukM//U+ZRNqITsU2eQm/E53T6U03EsCfKzL5X0/SivSuRxqZCUun3KGGMkTdXxixb1ttZmnqFpqd+vcjFW/1bq9quSjHm3/zAv9w/m7QWKOb1/MN8vfKXyeFgI2B//hc8SOVNqCtQ5YYzxGGOCJbkluY0xwWdaO8cY0+XE2jEyxtSV9IikzwsvrbNyM1aS3pF0szHmP8aYsjp+1dK3Ciepc6y1yZJmSnrCGBNmjGkj6Sod/9bsFMaYq4wxUea4lpKGqQTvU7kcn3ckDTfGnGOMqSrpPpWCfegvuRmr0rYf/Vsujk2l8rh0spyOVWl/vzthsqQLJfWw1qZm067U71fK4VixX4F5t/8wL88/5u15x5zeP5jv+w+fB/yDzwp+xWeJnLDWcjtxkzRGx7/tOfk25sRjNXT8dPsaJ/7+r46v+ZQs6Q8d/xlDgNOvoSiO1Yn7hp8Yr0RJb0oKcvo1FNI4RUuadWI/2SXpupMea6vjP2n76+8PdXxdoSRJmyQNczq/U+NzmrExksZJijtxGyfJOJ2/iI5VqduP/jVOpz02cVzK+1jxfqeaJ8Ym7cS4/HW7nv0q72NV2vcrbsy7nRrLE/eV2uPUWcaRebufx+4041bq5/R+Gkf2v+zH8bTHRI6HBTOOvEefdRz5LJHDmzkxAAAAAAAAAAAAFCqW+AAAAAAAAAAAOIICNQAAAAAAAADAERSoAQAAAAAAAACOoEANAAAAAAAAAHAEBWoAAAAAAAAAgCMoUAMAAAAAAAAAHEGBGgAAAAAAAADgCArUAFDMGWPGGWNmnfT388aYb4wxgQ7GAgAAAEos5uAA4D/GWut0BgBAPhhjykn6Q9KlklpJulNSrLX2qJO5AAAAgJKKOTgA+A8FagAoAYwxYyT1khSp4xPjP0/c/5yk1pJ2SLrJWpvpVEYAAACgJGEODgD+wRIfAFAyrJTUQNLokybGjSSdY61tK2mTpD4O5gMAAABKGubgAOAHFKgBoJgzxjSQNFnS25JuOumh1pK+OvHv+ZLaFHI0AAAAoERiDg4A/kOBGgCKMWPMOZK+kHS7pDskNTDGXHri4ShJiSf+fVRSdGHnAwAAAEoa5uAA4F8UqAGgmDLGlJE0V9KL1trZ1toUSc9LeupEkwRJZU78O1JSXKGHBAAAAEoQ5uAA4H9cJBEASihjTGNJw621g4wxD0rabq390OFYAAAAQInFHBwAco8zqAGghLLWrpJ0wBjzg6R6kj51NhEAAABQsjEHB4Dc4wxqAAAAAAAAAIAjOIMaAAAAAAAAAOAICtQAAAAAAAAAAEdQoAYAAAAAAAAAOIICNQAAAAAAAADAERSoAQAAAAAAAACOoEANAAAAAAAAAHAEBWoAAAAAAAAAgCMoUAMAAAAAAAAAHOFxOgAAAACQEytWrAj0eDxvSIqV5HY6D/LEZ4zZ7/V6H2/atOkCp8MAAADAecZa63QGAAAA4KxWrlx5d9myZe+qWbPmUZfLxSS2GPL5fCY1NTV4x44dgenp6UMpUgMAAIAlPgAAAFAsuN3uG6tWrZpMcbr4crlcNiwsLDUmJibD4/E85nQeAAAAOI8CNQAAAIoFa21kYGBgptM5kH8hISFp1trKTucAAACA8yhQAwAAoLgwxhinM8APTpwFz2cRAAAAMCkEAAAAAAAAADiDAjUAAAAAAAAAwBEUqAEAAACHVK5cueFPP/0UkpN2P/zwQ2hBbgMAAABwAgVqAAAAwAGHDh1yHz582NO0adO07NodPnzYfejQoYDGjRtn2y4/2wAAAACcQoEaAAAAcMCvv/4aEhMTkx4SEmLP1q5y5coZERERvoLaBgAAAOAUCtQAAADAGRw9etTldrub7dy5M+Cv+3755ZfgChUqNIyPj8/XXHrlypUhdevWTZWkPXv2eNq3b39euXLlGoWFhTVp3779eXFxcS5JWrVqVUjNmjXTr7/++hqRkZGNa9asWX/BggXhJ/f1wgsvlK9du3a9iIiIxu3atTt/z549nn9vQ5I2bNgQeOmll54XFRXVKDw8vEnr1q3Pz89rAAAAAPKLAjUAAABwBpGRkb5atWqlLV269O/1nx944IFq99xzz/6oqKhcn9F8snXr1oXWr18/RZLi4+Pdd91118Hdu3ev+eOPP9bExcV5XnrppQqStHbt2pC1a9eGdu/e/WhcXNyqPn36HPm///u/mn/1M2rUqMrTpk2r8Pnnn289dOjQ6ipVqmTcf//95/x7G5I0cODAWp07dz566NCh1QcPHlw1ZsyYvfl5DQAAAEB+UaAGAAAAstGoUaPkFStWhErSvHnzwrds2RJy3333Hcpvvxs2bAhp2LBhqiTVr18/vWfPnokhISG2UqVKWZdeemlifHy8R5I2btwYettttx249tprj7rdbg0dOvTwjh07gjMzM7Vnzx7PhAkTqnz44Yd/1K9fPz04ONjecssth1etWhX2721I0q5du4KysrKM1+s1oaGhtlOnTsn5fR0AAABAflCgBgAAALLRvHnz5FWrVoVK0qhRo6o99NBDe4KDg/+xpnPLli0vMMY0O92tWbNmF/y7T5/Ppy1btoQ0b948VZKmTZsW1bRp07rR0dGNIiIiGk+cOLFynTp10iRpy5Ytwddee238X8/dv3+/JyIiIisgIEBz5swpk5mZ6WrTps2FERERjSMiIhr37Nnz/IiIiKx/b0OSpk6duv3LL78sW6VKlYb9+vWreeDAAXdBjRsAAACQEx6nAwAAAABF2UUXXZT8yiuvVH7rrbfKpqenu2677ba4f7dZvnz577npc9OmTYEul8vWqVMnY/bs2RGPPvpotffff39b69atUySpWrVqDZs3b56yefPmwKSkJHeVKlW8fz13xowZUZdddtlRSYqLi3N37Ngxft68eX/8exsbNmz4ext/3XfllVceu/LKK4/t2bPH07lz5/MnT55cfsyYMQdykx0AAADwJ86gBgAAALJx0UUXpR4+fDjgoYceqv7EE0/sdrnyP4VesWJFaJ06dVKl4xcyrFKlSkarVq1SDx065OnXr19MXFycp2nTpmkrVqwIcbvddurUqdFZWVn66KOPIt95550KY8eO3StJLVq0SFm2bFnEjz/+GCpJcXFxrvfee6+sz+f7xzYk6e233y67du3aIJ/Pp4SEBPfRo0fdTZs2TTl9QgAAAKBwcAY1AAAAkI2QkBBbp06d1NDQUF+/fv0S/dHnmjVrQi688MJUSRoyZEjcrFmzoqOjoxufd955qZ07dz5au3bttODgYLtmzZqQXr16HVm6dGl42bJlq8bExKR//PHHWxs0aJAuSR06dEi+77779vXv3792fHy8JyIiIqtDhw4JAwYMSDh5G5L0ww8/hI8YMaJGUlKSu2LFipn33HPP/iuvvPKYP14PAAAAkFfGWnv2VgAAAIDDVq9evaNRo0aHC3u7aWlpplatWvXfe++9Py6//HIuKugnq1evLt+oUaMYp3MAAADAWSzxAQAAAGRjxIgRVZs3b55EcRoAAADwPwrUAAAAwGn8+OOPoREREY2XLFkSPmXKlD+dzgMAAACURKxBDQAAAJxGbGxsyrFjx1Y5nQMAAAAoyTiDGgAAAAAAAADgCArUAAAAAAAAAABHUKAGAAAAAAAAADiCAjUAAAAAAAAAwBEUqAEAAAAAAAAAjqBADQAAAAAAAABwBAVqAAAAAAAAAIAjKFADAAAAAAAAABxBgRoAAADwgwMHDrg7duxYOyQkpEnVqlUbvPbaa9FOZypMTz/9dIX69etfGBgY2LR3794xTucBAABA8eBxOgAAAACQF/vqN2zki48vsPmsKyrKW2XdmtU5bT9kyJAagYGBdv/+/auXLVsW2qdPn/OaN2+e0rx587SCyihJnZ/9ttHR1MwCG4fIkADvglHtzzoO55xzTubIkSP3zZ8/v0xaWhonwgAAACBHKFADAACgWCrI4nRu+09MTHTNnz8/asWKFesjIyN9nTt3Trr88suPTps2rVzz5s33FGTOgixO56b/wYMHJ0jSL7/8Erpnz57AgswEAACAkoMzGwAAAIB8Wrt2bZDH47ENGzZM/+u+hg0bpmzatCnEyVwAAABAUUeBGgAAAMinY8eOucPCwnwn3xcZGZmVlJTkdioTAAAAUBxQoAYAAADyKSIiIis5Ofkfc+vExER3eHh4llOZAAAAgOKAAjUAAACQTw0aNEj3er1m7dq1QX/dt2bNmpC6deumOpkLAAAAKOooUAMAAAD5VKZMGV/nzp0THnzwwaqJiYmur776KmzhwoVlb7rppiNOZyssmZmZSklJMVlZWSYrK8ukpKSYzMxMp2MBAACgiKNADQAAAPjB1KlTd6amproqVarUaPDgwec+//zzu5o3b57mdK7CMnLkyKphYWFNJ02aVPnzzz+PDgsLazpy5MiqTucCAABA0eZxOgAAAACQF66oKK8vPr7A5rOuqChvbtpXqlQpa+HChdsKKs+ZRIYEeI+mZhbYOESGBORoHF588cW9L7744t6CygEAAICSiQI1AAAAiqUq69asdjpDUbBgVHvGAQAAAMUWS3wAAAAAAAAAABxBgRoAAAAAAAAA4AgK1AAAAAAAAAAAR1CgBgAAQHFhrbVOZ4Af+Hw+I8nndA4AAAA4jwI1AAAAigVjzNGMjIwAp3Mg/1JTU4ONMfudzgEAAADnUaAGAABAsZCVlfXm3r17w06cfYtiyOfzmeTk5JAdO3YEer3ex53OAwAAAOcZfiYJAACA4mDFihWBHo/nDUmxktxO50Ge+Iwx+71e7+NNmzZd4HQYAAAAOI8CNQAAAAAAAADAESzxAQAAAAAAAABwBAVqAAAAAAAAAIAjKFADAAAAAAAAABxBgRoAAAAAAAAA4AgK1AAAAAAAAAAAR/w/5sKB6dWiC5wAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -253,37 +257,6 @@ "We will now train a logistic regression model on the training data. This can be done with the following" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "33f9cd97", - "metadata": {}, - "outputs": [], - "source": [ - "class TorchLogisticRegression(nn.Module):\n", - " \"\"\"\n", - " A simple binary logistic regression model.\n", - " \"\"\"\n", - "\n", - " def __init__(\n", - " self,\n", - " n_input: int,\n", - " ):\n", - " \"\"\"\n", - " :param n_input: Number of feature in input.\n", - " \"\"\"\n", - " super().__init__()\n", - " self.fc1 = nn.Linear(n_input, 1, bias=True)\n", - "\n", - " def forward(self, x):\n", - " \"\"\"\n", - " :param x: Tensor [NxD] representing the features x_i.\n", - " :returns: A tensor [N] representing the probabilities for p(y_i).\n", - " \"\"\"\n", - " x = torch.as_tensor(x)\n", - " return torch.sigmoid(self.fc1(x))" - ] - }, { "cell_type": "code", "execution_count": 10, @@ -294,7 +267,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Model fitting: 100%|██████████| 50/50 [00:03<00:00, 14.92it/s]\n" + "Model fitting: 100%|██████████| 50/50 [00:03<00:00, 16.59it/s]\n" ] } ], @@ -310,7 +283,8 @@ "\n", "optimizer = AdamW(params=model.parameters(), lr=lr, weight_decay=weight_decay)\n", "scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=num_epochs)\n", - "train_loss, val_loss = model.fit(\n", + "train_loss, val_loss = fit_torch_model(\n", + " model=model,\n", " x_train=train_data[0],\n", " y_train=train_data[1].astype(float),\n", " x_val=val_data[0],\n", @@ -339,7 +313,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -375,7 +349,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 12, @@ -384,7 +358,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -524,7 +498,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -598,8 +572,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average mislabelled data influence: -1.046369442947661\n", - "Average correct data influence: 0.01503900857368328\n" + "Average mislabelled data influence: -0.7335035023958383\n", + "Average correct data influence: 0.00799189782482135\n" ] } ], @@ -626,7 +600,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -687,8 +661,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average mislabelled data influence: -1.0463689425714193\n", - "Average correct data influence: 0.015039001098187444\n" + "Average mislabelled data influence: -0.7335032648603442\n", + "Average correct data influence: 0.007991897833854632\n" ] } ], @@ -702,7 +676,6 @@ " y_test=test_data[1].astype(float),\n", " influence_type=\"up\",\n", " inversion_method=\"cg\",\n", - " inversion_method_kwargs={\"n_iterations\": 10, \"max_step_size\": 1},\n", ")\n", "mean_train_influences = np.mean(influence_values, axis=0)\n", "\n", @@ -726,7 +699,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/notebooks/notebook_support.py b/notebooks/notebook_support.py index 2dcf05ca6..2e24d82d8 100644 --- a/notebooks/notebook_support.py +++ b/notebooks/notebook_support.py @@ -46,6 +46,30 @@ logger = logging.getLogger(__name__) +class TorchLogisticRegression(nn.Module): + """ + A simple binary logistic regression model. + """ + + def __init__( + self, + n_input: int, + ): + """ + :param n_input: Number of feature in input. + """ + super().__init__() + self.fc1 = nn.Linear(n_input, 1, bias=True, dtype=float) + + def forward(self, x): + """ + :param x: Tensor [NxD] representing the features x_i. + :returns: A tensor [N] representing the probabilities for p(y_i). + """ + x = torch.as_tensor(x) + return torch.sigmoid(self.fc1(x)) + + def fit_torch_model( model: nn.Module, x_train: Union["NDArray[np.float_]", torch.tensor], diff --git a/src/pydvl/influence/inversion_methods.py b/src/pydvl/influence/inversion_methods.py index 4d8229cdb..dad14d755 100644 --- a/src/pydvl/influence/inversion_methods.py +++ b/src/pydvl/influence/inversion_methods.py @@ -38,10 +38,10 @@ def conjugate_gradient( to Ax = y for each y in batch_y. :param A: a real, symmetric and positive-definite matrix of shape [NxN] - :param batch_y: a matrix of shape [NxP], with P the size of the batch. + :param batch_y: a matrix of shape [PxN], with P the size of the batch. :param progress: True, iff progress shall be printed. - :return: A NDArray of shape [NxP] representing x, the solution of Ax=b. + :return: A NDArray of shape [PxN] with each line being a solution of Ax=b. """ batch_cg = [] for y in maybe_progress(batch_y, progress, desc="Conjugate gradient"): From 27c6b0d2c9776bd9072122963535739c260e09de Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 24 Feb 2023 10:29:19 +0100 Subject: [PATCH 005/436] refactor inversion methods --- .../frameworks/torch_differentiable.py | 9 ++++- src/pydvl/influence/general.py | 34 ++++++++--------- src/pydvl/influence/inversion_methods.py | 38 +++++++++++++++++-- src/pydvl/influence/types.py | 11 +----- tests/influence/test_influences.py | 2 + tests/influence/test_torch_differentiable.py | 3 ++ 6 files changed, 65 insertions(+), 32 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 8e3a370c3..1d333db96 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -1,6 +1,7 @@ """ Contains all parts of pyTorch based machine learning model. """ +import logging from typing import TYPE_CHECKING, Callable, Optional, Tuple, Union import numpy as np @@ -24,6 +25,7 @@ __all__ = [ "TorchTwiceDifferentiable", ] +logger = logging.getLogger(__name__) def flatten_gradient(grad): @@ -49,7 +51,12 @@ def __init__( """ if not _TORCH_INSTALLED: raise RuntimeWarning("This function requires PyTorch.") - + if model.training: + logger.warning( + "Passed model not in eval mode. This can create several issues in influence " + "computation, e.g. due batch normalization. Please call model.eval() before computing" + "influences." + ) self.model = model self.loss = loss diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 49f4bd54f..c9b4058d4 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -5,12 +5,11 @@ from typing import TYPE_CHECKING, Callable, Dict, Optional import numpy as np -from scipy.sparse.linalg import LinearOperator from ..utils import maybe_progress from .frameworks import TorchTwiceDifferentiable -from .inversion_methods import InversionMethod, conjugate_gradient -from .types import MatrixVectorProductInversionAlgorithm, TwiceDifferentiable +from .inversion_methods import InversionMethod, matrix_inversion_algorithm +from .types import TwiceDifferentiable try: import torch @@ -24,7 +23,7 @@ from numpy.typing import NDArray -__all__ = ["compute_influences", "InfluenceType", "InversionMethod"] +__all__ = ["compute_influences", "InfluenceType", "calculate_influence_factors"] class InfluenceType(str, Enum): @@ -42,7 +41,7 @@ def calculate_influence_factors( y: "NDArray", x_test: "NDArray", y_test: "NDArray", - inversion_func: MatrixVectorProductInversionAlgorithm, + inversion_method: InversionMethod, lam: float = 0, progress: bool = False, ) -> "NDArray": @@ -64,8 +63,12 @@ def calculate_influence_factors( raise RuntimeWarning("This function requires PyTorch.") grad_xy, _ = model.grad(x, y) hvp = lambda v: model.mvp(grad_xy, v) + lam * v + n_params = model.num_params() + invert_hvp = matrix_inversion_algorithm( + inversion_method, hvp, (n_params, n_params), progress + ) test_grads = model.split_grad(x_test, y_test, progress) - return inversion_func(hvp, test_grads) + return invert_hvp(test_grads) def _calculate_influences_up( @@ -126,9 +129,9 @@ def _calculate_influences_pert( return np.stack(all_pert_influences, axis=1) -influence_type_function_dict = { - "up": _calculate_influences_up, - "perturbation": _calculate_influences_pert, +influence_type_registry = { + InfluenceType.Up: _calculate_influences_up, + InfluenceType.Perturbation: _calculate_influences_pert, } @@ -173,25 +176,20 @@ def compute_influences( raise RuntimeWarning("This function requires PyTorch.") differentiable_model = TorchTwiceDifferentiable(model, loss) - n_params = differentiable_model.num_params() - dict_fact_algos: Dict[Optional[str], MatrixVectorProductInversionAlgorithm] = { - "direct": lambda hvp, x: np.linalg.solve(hvp(np.eye(n_params)), x.T).T, # type: ignore - "cg": lambda hvp, x: conjugate_gradient(LinearOperator((n_params, n_params), matvec=hvp), x, progress), # type: ignore - } - influence_factors = calculate_influence_factors( + influence_factors: "NDArray" = calculate_influence_factors( differentiable_model, x, y, x_test, y_test, - dict_fact_algos[inversion_method], + inversion_method, lam=hessian_regularization, progress=progress, ) - influence_function = influence_type_function_dict[influence_type] + compute_influence_type = influence_type_registry[influence_type] - return influence_function( + return compute_influence_type( differentiable_model, x, y, diff --git a/src/pydvl/influence/inversion_methods.py b/src/pydvl/influence/inversion_methods.py index dad14d755..00cfe8263 100644 --- a/src/pydvl/influence/inversion_methods.py +++ b/src/pydvl/influence/inversion_methods.py @@ -6,17 +6,17 @@ """ import logging from enum import Enum -from typing import TYPE_CHECKING +from typing import TYPE_CHECKING, Callable, Tuple import numpy as np -from scipy.sparse.linalg import cg +from scipy.sparse.linalg import LinearOperator, cg from ..utils import maybe_progress if TYPE_CHECKING: from numpy.typing import NDArray -__all__ = ["conjugate_gradient", "batched_preconditioned_conjugate_gradient"] +__all__ = ["matrix_inversion_algorithm", "conjugate_gradient"] logger = logging.getLogger(__name__) @@ -30,6 +30,38 @@ class InversionMethod(str, Enum): Cg = "cg" +MatrixVectorProduct = Callable[["NDArray"], "NDArray"] + + +def matrix_inversion_algorithm( + inversion_method: InversionMethod, + mvp: MatrixVectorProduct, + mvp_dimensions: Tuple[int, int], + progress: bool = False, +) -> Callable[["NDArray"], "NDArray"]: + """ + It returns a callable that solves the problem of finding x such + that Ax = b, where A is a matrix (of size mvp_dimensions), and b a vector. + More precisely, given mvp, a (callable) matrix vector product that + returns the product Ax for any vector x, it returns another callable that takes + any vector b and solves the inverse problem. + + :param inversion_method: + :param mvp: matrix vector product, a callable that, given any array x, + returns the result of Ax. + :param mvp_dimensions: dimensions of matrix A + :param progress: If True, display progress bars. + + :return: A callable that, given any array b, solves the inverse problem, + i.e. it finds x such that Ax = b + """ + inversion_algorithm_registry = { + InversionMethod.Direct: lambda x: np.linalg.solve(mvp(np.eye(mvp_dimensions[0])), x.T).T, # type: ignore + InversionMethod.Cg: lambda x: conjugate_gradient(LinearOperator(mvp_dimensions, matvec=mvp), x, progress), # type: ignore + } + return inversion_algorithm_registry[inversion_method] + + def conjugate_gradient( A: "NDArray[np.float_]", batch_y: "NDArray[np.float_]", progress: bool = False ) -> "NDArray[np.float_]": diff --git a/src/pydvl/influence/types.py b/src/pydvl/influence/types.py index 866214044..65ebc9c45 100644 --- a/src/pydvl/influence/types.py +++ b/src/pydvl/influence/types.py @@ -1,12 +1,10 @@ from abc import ABC -from typing import Callable, Iterable, Optional, Tuple +from typing import Iterable, Optional, Tuple from numpy import ndarray __all__ = [ "TwiceDifferentiable", - "MatrixVectorProduct", - "MatrixVectorProductInversionAlgorithm", ] @@ -39,10 +37,3 @@ def mvp( Calculate the hessian vector product over the loss with all input parameters x and y with the vector v. """ pass - - -MatrixVectorProduct = Callable[[ndarray], ndarray] - -MatrixVectorProductInversionAlgorithm = Callable[ - [MatrixVectorProduct, ndarray], ndarray -] diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 901fb30a9..2efdd5347 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -78,6 +78,7 @@ def test_influence_linear_model( ) linear_layer = nn.Linear(A.shape[0], A.shape[1]) + linear_layer.eval() linear_layer.weight.data = torch.as_tensor(A) linear_layer.bias.data = torch.as_tensor(b) loss = F.mse_loss @@ -194,6 +195,7 @@ def test_influences_nn( y_train = torch.rand((batch_size, output_dim)) x_test = torch.rand((test_data_len, *input_dim)) y_test = torch.rand((test_data_len, output_dim)) + nn_architecture.eval() multiple_influences = [] for inversion_method in InversionMethod: diff --git a/tests/influence/test_torch_differentiable.py b/tests/influence/test_torch_differentiable.py index 56afbe6b7..2e05669be 100644 --- a/tests/influence/test_torch_differentiable.py +++ b/tests/influence/test_torch_differentiable.py @@ -121,6 +121,7 @@ def test_linear_grad( train_y = data_model(train_x) model = nn.Linear(input_dimension, output_dimension) + model.eval() model.weight.data = torch.as_tensor(A) model.bias.data = torch.as_tensor(b) loss = F.mse_loss @@ -153,6 +154,7 @@ def test_linear_hessian( train_x = np.random.uniform(size=[train_set_size, input_dimension]) train_y = data_model(train_x) model = nn.Linear(input_dimension, output_dimension) + model.eval() model.weight.data = torch.as_tensor(A) model.bias.data = torch.as_tensor(b) loss = F.mse_loss @@ -188,6 +190,7 @@ def test_linear_mixed_derivative( train_x = np.random.uniform(size=[train_set_size, input_dimension]) train_y = data_model(train_x) model = nn.Linear(input_dimension, output_dimension) + model.eval() model.weight.data = torch.as_tensor(A) model.bias.data = torch.as_tensor(b) loss = F.mse_loss From fcc5c95b75ae0215564d17bd7c3602eaf97c4b31 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 24 Feb 2023 10:40:50 +0100 Subject: [PATCH 006/436] further simplify inversion method calling --- src/pydvl/influence/general.py | 13 ++++---- src/pydvl/influence/inversion_methods.py | 38 +++++++++++++----------- 2 files changed, 28 insertions(+), 23 deletions(-) diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index c9b4058d4..5e0dc0381 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -8,7 +8,7 @@ from ..utils import maybe_progress from .frameworks import TorchTwiceDifferentiable -from .inversion_methods import InversionMethod, matrix_inversion_algorithm +from .inversion_methods import InversionMethod, invert_matrix from .types import TwiceDifferentiable try: @@ -64,11 +64,14 @@ def calculate_influence_factors( grad_xy, _ = model.grad(x, y) hvp = lambda v: model.mvp(grad_xy, v) + lam * v n_params = model.num_params() - invert_hvp = matrix_inversion_algorithm( - inversion_method, hvp, (n_params, n_params), progress - ) test_grads = model.split_grad(x_test, y_test, progress) - return invert_hvp(test_grads) + return invert_matrix( + inversion_method, + hvp, + (n_params, n_params), + test_grads, + progress, + ) def _calculate_influences_up( diff --git a/src/pydvl/influence/inversion_methods.py b/src/pydvl/influence/inversion_methods.py index 00cfe8263..75fdc1ac2 100644 --- a/src/pydvl/influence/inversion_methods.py +++ b/src/pydvl/influence/inversion_methods.py @@ -30,36 +30,38 @@ class InversionMethod(str, Enum): Cg = "cg" -MatrixVectorProduct = Callable[["NDArray"], "NDArray"] - - -def matrix_inversion_algorithm( +def invert_matrix( inversion_method: InversionMethod, - mvp: MatrixVectorProduct, + mvp: Callable[["NDArray"], "NDArray"], mvp_dimensions: Tuple[int, int], + b: "NDArray", progress: bool = False, -) -> Callable[["NDArray"], "NDArray"]: +) -> "NDArray": """ - It returns a callable that solves the problem of finding x such - that Ax = b, where A is a matrix (of size mvp_dimensions), and b a vector. - More precisely, given mvp, a (callable) matrix vector product that - returns the product Ax for any vector x, it returns another callable that takes - any vector b and solves the inverse problem. + It solves the problem of finding x such that Ax = b, where A is a matrix (of + size mvp_dimensions), and b a vector. + Instead of passing the matrix A directly, the method takes its mvp, i.e. a + (callable) matrix vector product that returns the product Ax for any vector + x. This is done to avoid storing a (potentially very large) matrix in memory. :param inversion_method: :param mvp: matrix vector product, a callable that, given any array x, returns the result of Ax. :param mvp_dimensions: dimensions of matrix A + :param b: :param progress: If True, display progress bars. - :return: A callable that, given any array b, solves the inverse problem, - i.e. it finds x such that Ax = b + :return: An array that solves the inverse problem, + i.e. it returns x such that Ax = b """ - inversion_algorithm_registry = { - InversionMethod.Direct: lambda x: np.linalg.solve(mvp(np.eye(mvp_dimensions[0])), x.T).T, # type: ignore - InversionMethod.Cg: lambda x: conjugate_gradient(LinearOperator(mvp_dimensions, matvec=mvp), x, progress), # type: ignore - } - return inversion_algorithm_registry[inversion_method] + if inversion_method == InversionMethod.Direct: + return np.linalg.solve(mvp(np.eye(mvp_dimensions[1])), b.T).T + elif inversion_method == InversionMethod.Cg: + return conjugate_gradient( + LinearOperator(mvp_dimensions, matvec=mvp), b, progress + ) + else: + raise ValueError(f"Unknown inversion method: {inversion_method}") def conjugate_gradient( From 89c114adea5f220e4d683c05f560102fb467a361 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 24 Feb 2023 10:45:44 +0100 Subject: [PATCH 007/436] minor changes to compute_influences --- src/pydvl/influence/general.py | 37 +++++++++++++++++----------------- 1 file changed, 19 insertions(+), 18 deletions(-) diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 5e0dc0381..45fe6f3fb 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -132,12 +132,6 @@ def _calculate_influences_pert( return np.stack(all_pert_influences, axis=1) -influence_type_registry = { - InfluenceType.Up: _calculate_influences_up, - InfluenceType.Perturbation: _calculate_influences_pert, -} - - def compute_influences( model: "nn.Module", loss: Callable[["torch.Tensor", "torch.Tensor"], "torch.Tensor"], @@ -178,10 +172,10 @@ def compute_influences( if not _TORCH_INSTALLED: raise RuntimeWarning("This function requires PyTorch.") - differentiable_model = TorchTwiceDifferentiable(model, loss) + diffable_model = TorchTwiceDifferentiable(model, loss) - influence_factors: "NDArray" = calculate_influence_factors( - differentiable_model, + infl_factors: "NDArray" = calculate_influence_factors( + diffable_model, x, y, x_test, @@ -190,12 +184,19 @@ def compute_influences( lam=hessian_regularization, progress=progress, ) - compute_influence_type = influence_type_registry[influence_type] - - return compute_influence_type( - differentiable_model, - x, - y, - influence_factors, - progress, - ) + if influence_type == InfluenceType.Up: + return _calculate_influences_up( + diffable_model, + x, + y, + infl_factors, + progress, + ) + elif influence_type == InfluenceType.Perturbation: + return _calculate_influences_pert( + diffable_model, + x, + y, + infl_factors, + progress, + ) From 0a2e176851458e78c7cd68672396ca77619e14a7 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 24 Feb 2023 14:13:17 +0100 Subject: [PATCH 008/436] update notebooks --- notebooks/influence_imagenet.ipynb | 120 ++++++++++++++-------------- notebooks/influence_synthetic.ipynb | 21 ++--- notebooks/influence_wine.ipynb | 57 ++++++------- notebooks/notebook_support.py | 87 +++++++++++++++++--- src/pydvl/influence/general.py | 37 +++++---- 5 files changed, 190 insertions(+), 132 deletions(-) diff --git a/notebooks/influence_imagenet.ipynb b/notebooks/influence_imagenet.ipynb index d7494436a..fcd135e26 100644 --- a/notebooks/influence_imagenet.ipynb +++ b/notebooks/influence_imagenet.ipynb @@ -60,8 +60,6 @@ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import os\n", - "import pandas as pd\n", - "import torch\n", "from torch import nn\n", "from notebook_support import (\n", " plot_sample_images,\n", @@ -69,6 +67,7 @@ " plot_losses,\n", " corrupt_imagenet,\n", " load_preprocess_imagenet,\n", + " process_imgnet_io,\n", " plot_corrupted_influences_distribution,\n", " compute_mean_corrupted_influences,\n", " TrainingManager,\n", @@ -82,10 +81,9 @@ "plt.rcParams[\"font.size\"] = 12\n", "plt.rcParams[\"xtick.labelsize\"] = 12\n", "plt.rcParams[\"ytick.labelsize\"] = 10\n", - "hessian_reg = 1e4 if os.environ.get(\"CI\") else 1e-3\n", + "hessian_reg = 1e4 if os.environ.get(\"CI\") else 1e-1\n", "random_state = 42\n", - "np.random.seed(random_state)\n", - "DEVICE = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")" + "np.random.seed(random_state)" ] }, { @@ -163,7 +161,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -191,26 +189,13 @@ "metadata": {}, "outputs": [], "source": [ - "from typing import Tuple\n", - "\n", - "\n", - "def process_io(df: pd.DataFrame, labels: dict) -> Tuple[torch.Tensor, torch.Tensor]:\n", - " x = df[\"normalized_images\"]\n", - " y = df[\"labels\"]\n", - " ds_label_to_model_label = {\n", - " ds_label: idx for idx, ds_label in enumerate(labels.values())\n", - " }\n", - " x_nn = torch.stack(x.tolist()).to(DEVICE)\n", - " y_nn = torch.tensor([ds_label_to_model_label[yi] for yi in y], device=DEVICE)\n", - " return x_nn, y_nn\n", - "\n", - "\n", - "train_x, train_y = process_io(train_ds, label_names)\n", - "val_x, val_y = process_io(val_ds, label_names)\n", - "test_x, test_y = process_io(test_ds, label_names)" + "train_x, train_y = process_imgnet_io(train_ds, label_names)\n", + "val_x, val_y = process_imgnet_io(val_ds, label_names)\n", + "test_x, test_y = process_imgnet_io(test_ds, label_names)" ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -259,7 +244,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -290,12 +275,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "f1_score of model: 0.8468272032336833\n" + "f1_score of model: 0.8853543321365104\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbcAAAGNCAYAAACSdj8gAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAAsTAAALEwEAmpwYAAAjPElEQVR4nO3de7xcZX3v8c83ISQEolGCyCWIimjFCtRI9XjHC+qxRa21WqpwjkesR7RW6qXW4+WoLW2t1JbWGoSKFm9EW5TSUrwgwkEUEAHBC6UgYLiEO8g1+3f+WCtxs9mZtZNMZvbM/rxfr/XKzJo1z3pmvyb7t3+/9aznSVUhSdI4mTfsDkiS1G8GN0nS2DG4SZLGjsFNkjR2DG6SpLGz1bA7IEma3Q54zrZ1w41r+9LWuRfcfUpVvbAvjfVgcJMk9XTDjWv57im79aWt+Tv9dFlfGupgcJMk9VTABBPD7sZGMbhJkjoUa2u0gpsDSiRJY8fMTZLUU1OWHK2pGg1ukqROo3bNzbKkJGnsmLlJknoqirUjtoKMwU2S1GnUrrlZlpQkjR0zN0lSTwWsHbHMzeAmSepkWVKSpCEzc5Mk9VTgaElJ0vgZrVu4LUtKksaQwU2S1FNRrO3TNhNJ5if5fpKT2uePTHJ2kkuTfCHJ1l1tGNwkSb0VrO3TNkN/AFwy6fmfA0dW1R7ATcDruhowuEmSZo0kuwL/Hfhk+zzA/sCq9pDjgJd2teOAEklST82SN32zLMk5k56vrKqVk57/NfAOYEn7fHvg5qq6r31+FbBL10kMbpKkDmEt6Vdja6pqxbRnSV4CXFdV5yZ59uacxOAmSZotngb8ZpIXA4uABwEfA5Ym2arN3nYFru5qyGtukqSeCpio/mw9z1P1x1W1a1XtDrwK+EZVHQR8E3hFe9jBwIldfTa4SZI6rW1Lk5u7baJ3Am9LcinNNbhjut5gWVKSNOtU1WnAae3jy4D9Nub9BjdJUk/Nkjd9G1AyEAY3SVKniRqt4OY1N0nS2DFzkyT1ZFlSkjR2irB2xAp9o9VbSZJmwMxNktRp1AaUGNwkST15zW2ELHvo/Np9+YJhd0NzxE8uWDzsLmgOuYs7uKfu7mM0CmtrtK5izdngtvvyBXz3lOXD7obmiAN23mfYXdAccnZ9fdhdGLo5G9wkSTPTrOdm5iZJGjOjds1ttEKxJEkzYOYmSeqpygElkqQxNGFZUpKk4TJzkyT11NzEPVq5kMFNktRh9K65jVZvJUmaATM3SVJP3sQtSRpLa0dsVYDRCsWSJM2AmZskqadRXInb4CZJ6jThaElJkobLzE2S1JM3cUuSxk4RR0tKkjRsZm6SpE7exC1JGitVOLekJEnDZuYmSeqQkVus1OAmSeqpsCwpSdLQmblJkjp5E7ckaawUYcKbuCVJGi4zN0lSJ8uSkqSxUrjkjSRJQ2fmJknqENZ6E7ckaZwMqiyZZBFwOrCQJj6tqqr3JfkU8CzglvbQQ6rq/F5tGdwkSbPF3cD+VXV7kgXAGUn+rX3t7VW1aqYNGdwkSZ0GUZasqgJub58uaLfalLYcUCJJ6qkqTNS8vmzAsiTnTNoOnXyuJPOTnA9cB5xaVWe3L304yQVJjkyysKvPZm6SpEFaU1UrNvRiVa0F9kmyFPjnJE8A/hi4BtgaWAm8E/i/vU5i5iZJ6rS25vVlm6mquhn4JvDCqlpdjbuBfwT263q/wU2S1FMBE+2abpu79ZJkhzZjI8k2wPOBHyXZqd0X4KXARV19tiwpSZotdgKOSzKfJvn6YlWdlOQbSXYAApwP/H5XQwY3SVKHDGSx0qq6ANh3mv37b2xbBjdJUk/NTdyjNUOJ19wkSWPHzE2S1MklbyRJY8WVuCVJmgXM3CRJnSZGLBcyuEmSeqqCtZYlJUkaLjM3SVKnURtQYnCTJPXUjJYcrULfaPVWkqQZMHOTJHUaxErc/WRwkyT1NIpzSxrcJEkdvOYmSdLQmblJkjp1raI92xjcJEk9OUOJJEmzgJmbJKnTqA0oMbhJknpyPTdJkmYBMzdJUidHS0qSxsoozlBiWVKSNHbM3CRJnRwtKUkaL+VoSUmShs7MTZLUU+FoSUnSGLIsKUnSkJm5SZJ6GsX73AxukqROoxbcLEuqp6sv25qXPPKJ/PlhuwFw9tcexNsO3IOXP+5XedXee3Hk4cv5xe1+jbRl7PzIu/nqZRfwjr+9Ythd0YjZ4r+VkixN8r87jtk9yUUbeO20JCu2TO/U5ah378qee/9i/fM7bp3Hq996LZ897yKO/taPWHPNAo7+4M5D7KHG2WF/ehU/+cHiYXdjzlu3KkA/tkEZxJ/cS4GewU2z02n/spRtH7yWfZ9++/p9+7/8Zp78nNtYtLhYsnQtLzroBi7+3rZD7KXG1bMOvIk7bpnP98/YbthdEc2tAP3YBmUQwe0I4NFJzk9yZJKvJzkvyYVJDpx03FZJjk9ySZJVSR7w51qSFyQ5q33/CUm2a/cfkeTiJBck+cgAPtPYu+O2eXz6Iw/nDe/7ec/jLvzOdjxiz7sG1CvNFYu3W8tr/+gaPvEBqwLaNIMYUPIu4AlVtU+SrYDFVXVrkmXAd5J8pT3uscDrqurMJMfSZHvrA1V7/HuA51XVHUneCbwtyd8BLwMeV1WVZOmGOpLkUOBQgN12cSxNL5/+i5044FU3ssPO927wmHO/tR1fO+EhfOyknw6wZ5oLXvuOazjl89uzZvXWw+6KAMoBJV0C/GmSC4CvAbsAO7avXVlVZ7aP/wl4+pT3PgV4PHBmkvOBg4FHALcAdwHHJHk58As2oKpWVtWKqlqxw/bz+/SRxs9/XrQN5317O15+6PUbPOaScxfz52/anfesvJxdH333AHuncfeove7k155xG19euWzYXVFr3a0Ao3TNbdDpy0HADsCTqureJJcDi9rXasqxU58HOLWqXj210ST7Ac8FXgEcBuzfz07PNT84azuuvXJrXvPkxwNw5x3zmJgIP3vBIv7uP37CpRduw/sOeSRv++jP2PcZt3e0Jm2cvZ96Ozsuv5fPfO8SALbZdoJ584rd9vwJhx2w55B7p1ExiOB2G7Ckffxg4Lo2sD2HJvNaZ7ckT62qs4DfBc6Y0s53gL9LskdVXZpkW5rM7+c0pc6Tk5wJXLZFP80c8OKD1vDsA29a/3zVxx/GtVdtzZuPuJLLf7SIPznoUfzvD13NU15w6xB7qXF18vHbc9qJS9c/f8Ubr2fHXe/hb9+16/A6pZErS27x4FZVNyQ5sx3q/z3gcUkuBM4BfjTp0B8Db2qvt10MfHxKO9cnOQT4XJKF7e730ATPE5Msosnu3rZFP9AcsGhxsWjxfeufb7PtBFsvnGDp9mv55Ad35pYbtuLIw5dz5OHLAXjYrvdw9Gk/HlZ3NWbuvnMed9/5yysmd94xj3vuDrfc6HXyYVl3K8AoSdXU6t/csGLvRfXdU5YPuxuaIw7YeZ9hd0FzyNn1dW6tG/sWjZY89uG14uMH9aWt05770XOratp7l9sk5XRgIU3ytaqq3pfkkcDnge2Bc4HXVNU9vc7j1BKSpE5V6cvW4W5g/6raG9gHeGGSpwB/DhxZVXsANwGv62rI4CZJ6jSIm7irsW6U2oJ2K5pBgqva/ccBL+3qr8FNkjRIy5KcM2k7dPKLSea3t3tdB5wK/Cdwc1WtGwhwFc1gwp68QitJ6qn6exP3mg1dc2vOVWuBfdoJOf4ZeNymnMTgJknqNIPrZX0+X92c5JvAU4GlSbZqs7ddgau73m9ZUpI0KyTZYd0Uikm2AZ4PXAJ8k2aSDmhmpzqxqy0zN0lSh4Hd57YTcFyS+TTJ1xer6qQkFwOfT/Ih4PvAMV0NGdwkSZ0GUZasqguAfafZfxmw38a0ZVlSkjR2zNwkST2tWxVglBjcJEm9VXM7wCixLClJGjtmbpKkTl1TZ802BjdJUk/F4G/i3lyWJSVJY8fMTZLUYfQWKzW4SZI6OVpSkqQhM3OTJHUatQElBjdJUk9VoxfcLEtKksaOmZskqZOjJSVJY8fRkpIkDZmZmySp06gNKDG4SZJ6KmJwkySNnxG75OY1N0nS+DFzkyT1NoI3cRvcJEndRqwuaVlSkjR2zNwkSZ0sS0qSxo4zlEiSNGRmbpKkngrLkpKkcVPAiAU3y5KSpLFj5iZJ6jRqA0oMbpKkbiMW3CxLSpLGjpmbJKmDS95IksaRZUlJkobLzE2S1JtL3kiSxpJlSUmShmuDmVuSzzCDWF1Vr+1rjyRJs9D4lCUvHVgvJEmz24iVJTcY3KrqA4PsiCRJ/TLja25Jnp/kmCRfbZ+vSLL/luuaJGnWqD5tPSRZnuSbSS5O8sMkf9Duf3+Sq5Oc324v7urujEZLJnkz8AfAJ4FXtLvvBP4G+G8zaUOSNKIGt+TNfcDhVXVekiXAuUlObV87sqo+MtOGZpq5vRV4XlUdAUy0+34EPHamJ5IkqZeqWl1V57WPbwMuAXbZlLZmGtyWAFeuO3/77wLgnk05qSRptFT1Z5upJLsD+wJnt7sOS3JBkmOTPKTr/TMNbqcD75qy7y3AN2faUUnSCOvfNbdlSc6ZtB069VRJtgO+BLy1qm4FPg48GtgHWA38VVd3ZzpDyZuBryZ5PbAkyY+B24CXzPD9kiQBrKmqFRt6MckCmsB2fFV9GaCqrp30+tHASV0nmVFwq6rVSZ4MPBl4BE2J8rtVNdH7nZKksTCAASVJAhwDXFJVH520f6eqWt0+fRlwUVdbGzO35Dya62wA8xm129UlSZssg7mJ+2nAa4ALk5zf7ns38Ook+9AUNi8H3tDV0ExvBXgi8C/AQuBqYFfgriQvq6ofbFzfJUl6oKo6g+kTp5M3tq2ZDig5Fvg7YNeq2o9maOZR7X5J0jjr12CSAU7hNdPgtifw11XNQM72348Bj9lSHZMkzRZprrn1YxuQmQa3k4HfnLLvN4B/7W93JEnafDNd8mY+8Pkk59KMlFwOPAk4cYv3UJI0fOOyKgAPXPJm8tDLi4FT+t8dSdKsNC7BzSVvJEmjasb3uSXZmmai5GVMGqpZVd/YAv2SJM0m45K5TZbk6cAJNPe5PQi4lV9OpvyoLdY7SdLwDW7Jm76Z6WjJI4G/qKqHAre1/34Q+Pst1jNJkjbRxtzn9rEp+44A/rC/3ZEkzUap/myDMtPgdgtNORJgdZLHAw8BttsivZIkzS5jOkPJl4EXt4+PpVnH7Vxg1ZbolCRJm2OmS968ddLjjyQ5myZr8143SdKsszFL3qxXVd/ud0ckSbPXIK+X9UOv6be+zQwqpFX1zL72aEB+ctn2PP93/sewu6E5YtVVDizW4Oz/otuH3YWh65W5fXJgvZAkzW4jdp9br+m3jhtkRyRJs9SARzr2w0xHS0qSNDI2aUCJJGmOGbHMzeAmSeo0aqMlLUtKksbOjIJbkoVJPpzksiS3tPtekOSwLds9SdKsMKbTbx0JPAE4iF9274fAG7dEpyRJs8yIBbeZXnN7GbBHVd2RZAKgqq5OssuW65okaTYY9Iz+/TDTzO0epgTCJDsAN/S9R5IkbaaZBrcTgOOSPBIgyU7AUcDnt1THJEmzSKU/24DMNLi9G/gv4EJgKfBT4OfAB7ZMtyRJs8o4XnOrqntoVt3+w7YcuaaqRqwCK0maK2YU3JI8asquJUmTXlbVZf3ulCRpdhm1ASUzHS15KU1COblguu6jzu9rjyRJs884Brequt+1uSQPB94HuGipJGnW2dSVuK9J8lbgJ8Bn+9ojSdLsMoL3uW3OxMmPBRb3qyOSpFlsHINbkm9z/4+2GNgL+L9bolOSJG2OmWZun5zy/A7gB1X10z73R5I0G41b5pZkPrA/cGhV3b3luyRJmm1G7Zpb5wwlVbUWeAEwseW7I0nS5tuYJW8+kGTBluyMJEn90DO4JXl1+/DNwNuB25JcmeRn67Yt3kNJ0vCN2dySnwA+B/zeAPoiSVJfdAW3AFTVtwbQF0nSbDSGN3HPT/Ic7j+n5P1U1Tf62yVJ0qwzZsFtIXAMGw5uBUxdMUCSpI2WZDnwaWBHmviysqo+luShwBeA3YHLgVdW1U292uoKbndUlcFLkua6wWRu9wGHV9V5SZYA5yY5FTgE+HpVHZHkXcC7gHf2amimtwJIkuao0Fxz68fWS1Wtrqrz2se3AZcAuwAHAse1hx0HvLSrzzMaUCJJUp8sS3LOpOcrq2rl1IOS7A7sC5wN7FhVq9uXrqEpW/bUM7hV1ZIZd1eSNL76V5ZcU1Ureh2QZDvgS8Bbq+rW5Jd5VlVV0j12c3OWvJEkzQUDvBWgnQnrS8DxVfXldve1SXaqqtVJdgKu62rHa26SpFkhTYp2DHBJVX100ktfAQ5uHx8MnNjVlpmbJKnbYDK3pwGvAS5Mcn67793AEcAXk7wOuAJ4ZVdDBjdJUrcBBLeqOoMND2R87sa0ZVlSkjR2zNwkSZ3GbW5JSZJGbm5Jy5KSpLFj5iZJ6m3AC432g8FNktRp1K65WZaUJI0dMzdJUrcRy9wMbpKkTpYlJUkaMjM3SVK3EcvcDG6SpN5G8FYAy5KSpLFj5iZJ6ilseKr+2crgJknqZllSkqThMnOTJHUatfvcDG6SpG4jFtwsS0qSxo6ZmySp24hlbgY3SVJvNXrX3CxLSpLGjpmbJKnbiGVuBjdJUifLkpIkDZmZmySp24hlbgY3SVKnUStLGtwkSb25npskScNn5iZJ6jZimZvBTZLUUxi9a26WJSVJY8fMTZLUbcQyN4ObJKlTarSim2VJSdLYMXOTJPU2gve5GdwkSZ1GbbSkwU3TOvCAS3jBsy5l991u4rQzH8lffvwZAGw1fy1//JbT2fNRa3j4w+7g8A8cwAUX7zTk3mpcrL5sEX/0/L359RffwFv+9lJuunYBK9/1KC67YDtuunZrjjrrPB62/O5hd1MjwGtumtYNNy3m+C8/kVO++ZgHvHbRjx/GEUc9kxtu2mYIPdM4O+Y9j+TRe9++/nnmwT7PvpnDV/54iL0S8MvS5OZuAzLwzC3J7sBJVfWEzWznEOA/qurn/eiX7u+M7z4CgD0ffQM7PPS+9fvvWzuffz55LwAmJjKUvmk8nXni9ix+0H3s+aQ7uebyRQAs3eFeDjj4Wtbe1/FmbXGjVpYc5cztEGDnYXdC0ub7xW3z+eJHlnPwe68Ydlc0JoYV3LZKcnySS5KsSrI4yXOTfD/JhUmOTbIQIMl7k3wvyUVJVqbxCmAFcHyS85Nsk+SIJBcnuSDJR4b0uSRtgi/85XKe86rr2H7ne4bdFW3IgMqS7e//65JcNGnf+5Nc3f6+Pz/Ji7vaGVZweyzw91X1K8CtwNuATwG/U1W/SlMufWN77FFV9eS2jLkN8JKqWgWcAxxUVfsAi4GXAXtV1ROBD0130iSHJjknyTn33HvHlvt0kmbs8h8u5sIzHsxLXr962F3RhlRTluzHNgOfAl44zf4jq2qfdju5q5FhBbcrq+rM9vE/Ac8F/quqftLuOw54Zvv4OUnOTnIhsD+w1zTt3QLcBRyT5OXAL6Y7aVWtrKoVVbVi6wXb9uuzSNoMPzzrQVx/5ULe+Ou/xuv3fRJf/cTOnH3y9rzzhb867K5pCKrqdODGzW1nWLcCTI3fNwPbTz0oySLg74EVVXVlkvcDix7QWNV9SfajCZKvAA6jCYTaRPPmTTB//gTz5hXz5hULFtzH2rXzmJiYx4Kt1q7/E2zBVhMsWHAf9947n2bucGnjPO+g63jab96w/vlXPrEz11+5kNf/2WUA3HNX1g9euu+ecM9dYetFIza6YRz070e+LMk5k56vrKqVM3jfYUleS1O1O7yqbup18LCC225JnlpVZwG/S9PZNyTZo6ouBV4DfItfBrI1SbajCVyr2n23AUsA2tcWV9XJSc4ELhvgZxlLB738B7z2t3+w/vnznnkZnz5hbz6zal+OPfLLPPxhTVn3iD85FYDfO+y3uPb6JUPpq0bbwm0mWLjNxPrnixavZcHCCR60fTNE8vf2eMr61976rH0B+OJVZw22k3Ncn5e8WVNVKzbyPR8HPkgTYj8I/BXwP3u9YVjB7cfAm5IcC1wMvAX4DnBCkq2A7wH/UFV3JzkauAi4pt2/zqeAf0hyJ/Ai4MQ20wvNNTxths+s2pfPrNp32tde8+bfHnBvNJe88vCr7vfcQKaqunbd4zYmnNT1noEHt6q6HHjcNC99HXjAb9Oqeg/wnmn2fwn40qRd+/Wpi5KkqYa4KkCSnapq3Yijl9EkPD05/ZYkqdOgbuJO8jng2TTX5q4C3gc8O8k+NGXJy4E3dLVjcJMkzRpV9eppdh+zse0Y3CRJvbnkjSRpHGWi+5jZZJTnlpQkaVpmbpKkbpYlJUnjxiVvJEkaMjM3SVJvxVBv4t4UBjdJUifLkpIkDZmZmySp24hlbgY3SVJPfV7yZiAsS0qSxo6ZmySptypHS0qSxo9lSUmShszMTZLUbcQyN4ObJKmTZUlJkobMzE2S1FsBE6OVuhncJEndRiu2WZaUJI0fMzdJUqdRG1BicJMkdRuxGUosS0qSxo6ZmySpk2VJSdJ4KRwtKUnSsJm5SZJ6ahYrHa3UzeAmSeo2MewObByDmySp06hlbl5zkySNHTM3SVJvIzha0uAmSepQzlAiSdKwmblJkjo5Q4kkafxYlpQkabjM3CRJvRXEm7glSWPHsqQkScNl5iZJ6jZaiZuZmySpW6r6snWeJzk2yXVJLpq076FJTk3y0/bfh3S1Y3CTJM0mnwJeOGXfu4CvV9VjgK+3z3syuEmSulX1Z+s8TZ0O3Dhl94HAce3j44CXdrXjNTdJUm9FP9dzW5bknEnPV1bVyo737FhVq9vH1wA7dp3E4CZJGqQ1VbViU99cVZV0TwZmcJMk9RRmNhhkC7o2yU5VtTrJTsB1XW/wmpskqduArrltwFeAg9vHBwMndr3B4CZJmjWSfA44C3hskquSvA44Anh+kp8Cz2uf92RZUpLUbUBlyap69QZeeu7GtGNwkyT11t/RkgNhWVKSNHbM3CRJnYY8WnKjGdwkSd1GLLhZlpQkjR0zN0lSh826R20oDG6SpN6KkQtuliUlSWPHzE2S1G3E7nMzuEmSOo3arQCWJSVJY8fMTZLUbcQyN4ObJKm3AiZGK7hZlpQkjR0zN0lSB2/iliSNoxELbpYlJUljx8xNktRtxDI3g5skqTdHS0qSNHxzNnO77fafr/nG6X9yxbD7MYKWAWuG3YlR89Bdht2DkeX3bdM8or/NFdRoTS45Z4NbVe0w7D6MoiTnVNWKYfdDc4Pft1lkxK65WZaUJI2dOZu5SZJmaAQHlBjctLFWDrsDmlP8vs0WliU1zqrKXzYaGL9v2lRmbpKkbiOWuRncJEkdRm/iZMuSmlaSTyX5UI/XK8keg+yTRk+Sy5M8b9j90NxjcJtD/EWjcZDk/Un+adj9mFMKmJjozzYgliUlSd0sS2o2SvIZYDfgq0luT/KOJCckuSbJLUlOT7LXlLctS3JqktuSfCvJtFP6JFmY5CNJfpbk2iT/kGSb9rVlSU5KcnOSG5N8O4nfu7nlyUkuTnJTkn9MsgggyeuTXNp+L76SZOd1b0jysSRXJrk1yblJntHufyHwbuB32u/xD9r9hyS5rP2u/leSg4bxQTV7+Etmjqiq1wA/A36jqrarqr8A/g14DPAw4Dzg+ClvOwj4IM38fudP8/o6RwB7AvsAewC7AO9tXzscuArYAdiR5hfTaP0JqM11EHAA8Gia78l7kuwP/BnwSmAn4Arg85Pe8z2a79NDgc8CJyRZVFX/Dvwp8IX2e7x3km2BvwFeVFVLgP9G831VP1X1ZxsQg9scVlXHVtVtVXU38H5g7yQPnnTIv1bV6e3rfwI8NcnyyW0kCXAo8IdVdWNV3Ubzy+dV7SH30vzyekRV3VtV364asfqGNtdRVXVlVd0IfBh4NU3AO7aqzmu/X39M8/3aHaCq/qmqbqiq+6rqr4CFwGN7nGMCeEKSbapqdVX9cIt+ojmnmhlK+rENiMFtjkoyP8kRSf4zya3A5e1LyyYdduW6B1V1O3AjsDP3twOwGDi3LT3eDPx7ux/gL4FLgf9oy0bv6vuH0Wx35aTHV9B8h3ZuHwPrv1830GT9JPmjJJe0JfObgQdz/+8mk957B/A7wO8Dq5P8a5LHbYkPMmcVVE30ZRsUg9vcMvnPpt8FDgSeR/OLY/d2fyYdsz5LS7IdTYno51PaXAPcCexVVUvb7cFVtR1AmxkeXlWPAn4TeFuS5/bxM2n2m5zt70bzHfo5k5ZlaUuL2wNXt9fX3kFTsnxIVS0FbuGX380H/PlfVadU1fNpqgQ/Ao7u/8fQKDG4zS3XAo9qHy8B7qb5a3kxTSlxqhcneXqSrWmuvX2nqib/FU41f4odDRyZ5GEASXZJckD7+CVJ9mjLl7cAa2lKSJo73pRk1yQPpSlvfwH4HPA/kuyTZCHN9+/sqrqc5rt5H3A9sFWS9wIPmtTetcDu6wYmJdkxyYFtgLwbuB2/Y/1nWVKz2J/RXMy/mSYLuwK4GrgY+M40x38WeB9NOfJJwO9toN130pQev9OWOL/GL6+PPKZ9fjtwFvD3VfXNfnwYjYzPAv8BXAb8J/Chqvoa8H+ALwGraQabrLtOewpNafsnNN/Ru7h/afOE9t8bkpxH83vsbTTZ4I3As4A3bsHPMzeN2ICSeG1fktTLg7faoZ665MC+tHXKzcecO4gFaL2JW5LUW9VAZxfpB4ObJKnbiFX5DG6SpFklyeXAbTQD0O7blDKmwU2S1KkGX5Z8TlWt2dQ3G9wkSR1cz02SpF6WJTln0nboNMcUzaxG527g9U4GN2mKyQu1JnlGkh8P6LwbXAA2yWlJ/tcM29nkdftc80/TKvp5E/eaqloxaVs5zRmfXlW/BryIZhKAZ25slw1uGkntL+E722VPrm0D0nb9Pk870XOvCXvX9eeQJGf0+/zSrFET/dlmcqqqq9t/rwP+GdhvY7trcNMo+412DstfA1YA75l6QBKvK0sjJMm2SZasewy8ALhoY9sxuGnktX/l/RvwBFhf3ntTkp8CP233vSTJ+e3KBf8vyRPXvT/JvknOaxe6/AKwaNJrz05y1aTny5N8Ocn1SW5IclSSXwH+gWbJltvb6c16LuLavv72JKuT/DzJ/5zp503y6CTfaM+/JsnxSZZOOWzaBUK7fhbSdAqoierLNgM7AmekWYj2uzRLb/37xvbZ4KaR164x92Lg+5N2vxT4deDxSfYFjgXeQDPz/CeAr7TBZ2vgX4DP0My3eQLwWxs4z3zgJJr5DnenWZ7l81V1Cc1yK2e1C2gubd+ywUVc06wo/UfA82nm39yY61yhmSd0Z+BXaGbdf/+UYx6wQGh73g3+LDbi/JprqgZWlqyqy6pq73bbq6o+vCldNrhplP1LmyWdAXyL+69s8Gft4ql30iym+omqOruq1lbVcTSzxz+l3RYAf90uprqKZhXo6exHE1DeXlV3VNVdVTXtdbZ2FYRei7i+EvjHqrqoXY/s/TP90FV1aVWdWlV3V9X1wEdpJguebLoFQun4WUhjw+sRGmUvbWeXn87kWeQfARyc5M2T9m1NE6gKuHrK6uBXML3lwBVVdd8M+jZ5Edd1+wLMbx/vDJw7g3M+QJIdgY8Bz6BZHmYecNOUw6ZbIBR6/yykDZphSXHWMHPTuJr8P/FK4MOTFlNdWlWLq+pzNMut7JJJEYhmQc3pXAnstoFBKlP/5/dcxLU979RFPGfqT9vz/WpVPYhmKaJMOWa6BULXfYYN/SykDRvgaMl+MLhpLjga+P0kv57Gtkn+ezsi6yyahTHfkmRBkpez4WHH36UJSke0bSxK8rT2tWuBXdtreJ2LuAJfBA5J8vgki2nWzZupJTTr492SZBfg7dMcM90CoV0/C2lsWJbU2Kuqc5K8HjiKZvDGnTTX6U6vqnvagHY08CHgZODLG2hnbZLfAP4G+BlN9vRZ4EzgG8APgWuSTFTVMppFXN9Ls4jrMpqFYT8OnFJV/5bkr9v3TdAM+Dhohh/pA8CnaVY2v5RmMMwfTjlm3QKhOwMntp+t589ihufWHHQbN53ytVq1rE/NbfJ8kRvDxUolSWPHsqQkaewY3CRJY8fgJkkaOwY3SdLYMbhJksaOwU2SNHYMbpKksWNwkySNnf8PXevbFzpUXFkAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -339,12 +324,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "eb973044c7634b2eb8ca3a1bc0b1a79f", + "model_id": "f5082dc0c07b48f39da89a8946deb716", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Split Gradient: 0%| | 0/98 [00:00" ] @@ -457,7 +442,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -491,7 +476,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -512,10 +497,14 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "Looking at the images, it is difficult to explain why those on the right are more influential than those on the left. At first sight, the choice seems to be random (or at the very least noisy). Let's dig in a bit more by looking at average influences:" + "Looking at the images, it is not immediate to explain why those on the right are\n", + "more influential than those on the left. A lot seems to depend on the tonality\n", + "of he buildings, water and the color of the boat. Let's dig\n", + "in a bit more by looking at average influences:" ] }, { @@ -550,7 +539,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -576,12 +565,12 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -601,10 +590,17 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "Once again, it is not easy to explain why the images on the left have a lower influence than the ones on the right. One could argue that in order to predict that there is a dining table in the image it is beneficial to clearly see both the chairs and the table itself, a feature missing in some samples on the left. Also, color seems to be a discriminant: houses with a blue painting could get confused with the water around a boat. Of course, this is debatable and different people could come up with other explanations *a posteriori*." + "Once again, it is not easy to explain why the images on the left have a lower\n", + "influence than the ones on the right. One could argue that in order to predict\n", + "that there is a dining table in the image it is beneficial to clearly see both\n", + "the chairs and the table itself, a feature missing in some samples on the left.\n", + "Also, color seems to be a discriminant: black tables get confused Venetian boats\n", + "more easily. Of course, this is debatable and different people could come up\n", + "with other explanations *a posteriori*." ] }, { @@ -639,7 +635,7 @@ " avg_influences=avg_influences,\n", ")\n", "\n", - "corrupted_train_x, corrupted_train_y = process_io(corrupted_dataset, label_names)\n", + "corrupted_train_x, corrupted_train_y = process_imgnet_io(corrupted_dataset, label_names)\n", "\n", "mgr = TrainingManager(\n", " \"corrupted_model\",\n", @@ -661,7 +657,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -685,7 +681,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "F1 score of model with corrupted data: 0.8164795918367347\n" + "F1 score of model with corrupted data: 0.7784210235437161\n" ] } ], @@ -710,12 +706,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "06237dca13474cc1afcc66220191cf33", + "model_id": "e01293d753ba4849a81952872211faca", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Split Gradient: 0%| | 0/98 [00:00" ] @@ -821,7 +817,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -873,17 +869,17 @@ " \n", " \n", " 0\n", - " boats\n", - " 0.945390\n", - " -0.890972\n", - " 1.836362\n", + " tables\n", + " -0.103410\n", + " -3.208211\n", + " 3.104801\n", " \n", " \n", " 1\n", - " tables\n", - " -1.092637\n", - " -2.757206\n", - " 1.664569\n", + " boats\n", + " 0.009908\n", + " -3.637032\n", + " 3.646940\n", " \n", " \n", "\n", @@ -891,8 +887,8 @@ ], "text/plain": [ " label avg_non_corrupted_infl avg_corrupted_infl score_diff\n", - "0 boats 0.945390 -0.890972 1.836362\n", - "1 tables -1.092637 -2.757206 1.664569" + "0 tables -0.103410 -3.208211 3.104801\n", + "1 boats 0.009908 -3.637032 3.646940" ] }, "execution_count": 24, @@ -1011,7 +1007,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.4" + "version": "3.8.13" }, "vscode": { "interpreter": { diff --git a/notebooks/influence_synthetic.ipynb b/notebooks/influence_synthetic.ipynb index e3741b929..7e7325bf2 100644 --- a/notebooks/influence_synthetic.ipynb +++ b/notebooks/influence_synthetic.ipynb @@ -267,7 +267,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Model fitting: 100%|██████████| 50/50 [00:03<00:00, 16.59it/s]\n" + "Model fitting: 100%|██████████| 50/50 [00:03<00:00, 14.51it/s]\n" ] } ], @@ -313,7 +313,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -349,7 +349,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 12, @@ -370,6 +370,7 @@ } ], "source": [ + "model.eval()\n", "pred_probabilities = model(test_data[0]).detach()\n", "pred_y_test = [1 if prob > 0.5 else 0 for prob in pred_probabilities]\n", "\n", @@ -498,7 +499,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3sAAAIfCAYAAADJ38UbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAACog0lEQVR4nOzdd3hURd/G8e9sSyHU0HsRFUInAqIIIoqKiqLYC8WCvfuo2LGg2FAUFRXLa0MUAbsiAqI8CFJDR6TX0AIp2+b9I4EHSBAWkpzN5v54ncvN2bNz7t2EZH87c2aMtRYRERERERGJLS6nA4iIiIiIiEjhU7EnIiIiIiISg1TsiYiIiIiIxCAVeyIiIiIiIjFIxZ6IiIiIiEgMUrEnIiIiIiISg1TsiYhIkTPG9DbGLDfGhIwx7xljuhhjrDGmttPZokne6zLfGBMwxvx6kGMeM8YsK+ZojjDG1M/7OTnZ6SwiIiWRij0RETlseYXazxE+xg28C4wC6gK3F0W2GDEc+AtoCPQ6yDHPAx2KLdE+jDEn5xVf9YvplKuBGsB/I3mQMSZojOlTJIlEREoQj9MBREQk5tUAkoBvrbVrAYwxziaKXo2Bp621qw92gLV2F7Cr+CI5x1obAjY4nUNEpKRSz56IiByxPT19xpjrjTErjTE7jTHjjDHV8u7vQ27vDMDkvF6hLgW0U+CwzgN7aIwx1fLOudkYk2GMmWqMOaWAdk43xkw2xmQaYxYYY846oN2qxpiRxpiNxphsY8xiY0y/fe4/xhjzhTFmuzFmmzHmR2NM833uL5f3+A3GmBxjzGpjzIuHeK2OM8Z8Y4zZlbeNN8Ycs29uwA18kPcc+hyknf2Gce752hjT0xizyBiz2xjzqzGm8T7H9Ml7LbsZY9LynvN/jTGtDjzmgHPV3vM9y+vNm5J314q8/b/+y/O1xpjb817H3caYtcaY2w84poYx5tO81zkrL3fqPvfvN4xzn68vNsZ8nff9/fuAn5F/8l7HkXnH2rz9EX/PRERKOhV7IiJytE4ATgV6AN2B5uQONQT4DGiXd7snub18vx/JSYwxCcBEoCxwFtAa+Bb4yRjT5IDDnweeBlqSOwTwM2NMxX3amZR33xVAU+BWIDPv/mrAb8AmoBO5QyYXA78aY6rktf8k0CbvOTUGLgEWHiL7j0A80DlvSwK+N8b48l6TGnmH35J3+7MIXp4awI15z6cjua/Ruwcc4wKeA24i93uyGfgmL9vhWE3u8yXv8TU4+FDTPR4FfiX3e/Uc8IIxpieAye3e/Qo4Hjgnr82N5H4/Kx+i3cHAB0AL4FPgbWPMsXn3nQCEgDvyMu55XSP6nomIxAIN4xQRkaOVA/Sx1uYAGGPeIPeNNtbaLGPM5rzjtlprN+QdcyTnuQQoB1xird3TA/WUMeY04IY958zzuLX2+7xz3Q/0IbeY+AG4HGgAHGOtXZN3/N/7PPZG4B9r7Y17dhhjbgPOJreYehmoB8yy1u65lmwV/17EXg5UAdpaa7fktXkp8A9wqbX2A2BD3uuyY8/rFIE44Cpr7ea8tp8DPjHGxFtrs/c8DeBea+2kvGOuIreAuxx451AnsNaGjDFb877cfJgZv7HWvpp3e4kxpj1wDzAW6Eru9yTFWrsgL9PV5L4mNwFP/Eu7w6y1o/Ie8zC5xfqpwBJr7eaDvI6Rfs9EREo8FXsiInK0Fu0p9PKsA6oVwXlOAKoD2w8oFuOArAOOnb3nhrV2ozEmtE+mtsCCfQq9gs7T1hhz4HVxCeT2CAG8DnyRN+RwAvA98IO1NnyQNlPyzrnlgFyL8+47Wuv2FHp7via3uKtKblGzxx/7nH+bMWZhIZ3/YP444OupwKC82ylA+p5CLy9TjjHmv4eRafY+jwkZYzZx6J+5SL9nIiIlnoo9ERE5Wv4DvrbkFhqR2POGe+/jTO4snvtebuAid9jdBQU8PvMQmfY8/nC4yC0Gbingvh0A1tofjDF1yR222gX4P2CeMea0vElFiltB3wOI7HKNgooe75HFKXIFPd9/fa5R+D0TESlyumZPRESiwaa8/9fcZ18r9i8aZ5C7JMFOa+2yA7Z1EZxrJtDUHHyNvxnk9iytKeA8e3vPrLVbrbWfWGtvIPd6xc7kXv9XkLS8c+69Fi3v2sDjgPkRZD9ae5dsMMZUAJoAe3rWNgHuvFx7tDng8XuKLHek58vTcZ/zpQHJxpi9r5kxJg5oz9G/Jv6CMkb4PRMRKfFU7ImISDRYBqwEHjPGHJ83++JL/K+HCuAjYAW5k4qckTczY3tjzAPGmPMjONcneecalzc7ZQNjzGnGmEvy7h9GbqEw1hjTKe88JxtjnjLGdATIu93L5M6w2Zjca/l2sf+QyX19TO6EKJ8ZY9oYY9qSO7HIWiKbiOVoWOA5Y8wpJndm0Q+AjLxsANPzvh5sjGlsjDkTeOSANlaS2wN4tsmd0bT8Ic55jjHmlrz2biX3ussX8u77Je+cHxtjTjLGNMvLFE/ueoNHYwVwqjGm5p4C+wi+ZyIiJZ6KPRERcVzehCuXkHuN2SzgNWAg+wwtzJtopDO5PW8jgSXAl+RO8rEygnNl5rUzn9yCa2He+RLy7t8InAhsyWt/MbmFZj1gfV4z2eROIDIzL08L4Cxr7Y6DnDMLOIPcyWwmkzsb6G7gTGttQUNOi0IYeBB4k9zM1YEeea8H1tqtwGXk9sbNBR4G7tu3gbzX5gHgfnJfi7GHOOcTQDdgTt6577PWjslrywLnA4uAb4A/8zKdvu+1jUfobnKvzfyH3CIbIvyeiYjEApP7u1ZERERiVd46dG9ba4vtWv289e2ustb+X3GdU0RE9qeePRERERERkRikYk9ERERERCQGaRiniIiIiIhIDFLPnoiIiIiISAxSsSciIiIiIhKDVOyJiIiIiIjEIBV7IiIiIiIiMUjFnoiIiIiISAxSsSciIiIiIhKDVOyJiIiIiIjEIBV7IiIiIiIiMUjFnoiIiIiISAxSsSciIiIiIhKDVOyJiIiIiIjEIBV7IiIiIiIiMUjFnoiIiIiISAxSsSciIiIiIhKDVOyJiIiIiIjEIBV7IiIiIiIiMUjFnoiIiIiISAxSsSciIiIiIhKDVOyJiIiIiIjEIBV7IiIiIiIiMUjFnoiIiIiISAxSsSciIiIiIhKDVOyJiIiIiIjEIBV7IiIiIiIiMUjFnoiIiIiISAxSsSciIiIiIhKDVOyJiIiIiIjEIBV7IiIiIiIiMUjFnoiIiIiISAxSsSciIiIiIhKDVOyJiIiIiIjEIBV7IiIiIiIiMUjFnoiIiIiISAxSsSciIiIiIhKDVOyJiIiIiIjEIBV7IiIiIiIiMUjFnoiIiIiISAxSsSciIiIiIhKDVOyJiIiIiIjEIBV7IiIiIiIiMUjFnoiIiIiISAxSsSciIiIiIhKDPE4HKGqVK1e29evXdzqGiIiIiEhUmTlz5hZrbRWncxyu7qeWselbQ4Xe7sy5OT9Ya88s9IajQMwXe/Xr12fGjBlOxxARERERiSrGmJVOZ4hE+tYQ03+oW+jtumssrVzojUaJmC/2RERERESk5LNAmLDTMUoUFXsiIiIiIlICWEJWxV4kNEGLiIiIiIhIDFLPnoiIiIiIRL3cYZzW6Rglinr2REREREREYpB69kREREREpETQBC2RUbEnIiIiIiJRz2IJWQ3jjISGcYqIiIiIiMQg9eyJiIiIiEiJoAlaIqOePRERERERkRiknj0REREREYl6FgipZy8iKvZERERERKRE0DDOyGgYp4iIiIiISAxSz56IiIiIiEQ9C1p6IULq2RMREREREfkXxpgzjTGLjTHLjDH3F3D/KcaYv4wxQWPMRU5kLEhUFHvGmDrGmInGmAXGmDRjzO0FHGOMMa/kvcBzjTFtnMgqIiIiIiLOCBfBdijGGDfwGnAW0BS4zBjT9IDDVgF9gI+P+MkVgago9oAgcLe1tinQAbi5gBfwLKBx3nY9MLx4I0Zu6dKlbN682ekYIiIiIiJy5NoBy6y1f1tr/cCnQM99D7DW/mOtncvh1Y/FJiqKPWvtemvtX3m3M4CFQK0DDusJfGBzTQMqGGNqFHPUw2at5corryQlJYXRo0c7HUdEREREpESzWEJFsAGVjTEz9tmuP+DUtYDV+3y9hvy1SlSKimJvX8aY+kBr4L8H3HXYL7Ix5vo93yynetaMMbzzzjvUrVuX3r17c/HFF7Np0yZHsoiIiIiIlHgWQkWwAVustan7bG85/EwLTVQVe8aYJOAL4A5r7c4jbcda+9aeb1aVKlUKL2CEmjVrxrRp03jmmWcYO3YsKSkpfPbZZ1jNIiQiIiIiUlKsBers83XtvH1RL2qKPWOMl9xC7yNr7ZcFHFIiX2SPx8P999/PrFmzaNiwIZdeeikXXXQRGzdudDqaiIiIiEiJYXFmghbgT6CxMaaBMcYHXAqMK5xnVbSiotgzxhjgHWChtfbFgxw2Drg6b1bODsAOa+36Ygt5lJo2bcrUqVN59tln+eabb2jatCkff/yxevlERERERKKYtTYI3AL8QO7cIqOstWnGmCeMMecBGGNOMMasAXoDbxpj0pxL/D8mGooNY8zJwBRgHv8rsB8E6gJYa9/IKwiHAWcCmUBfa+2MQ7WdmppqZ8w45GHFatGiRfTt25dp06bRs2dPhg8fTo0aUTvXjIiIHKadgQympc9kd2g3zcs1oVFSA3L/fImIRB9jzExrbarTOQ5X8xY+++W3lQu93WPrrC9Rr0MkPE4HALDW/gb8619Dm1uV3lw8iYrW8ccfz2+//cbLL7/MQw89REpKCkOHDuXKK6/UmwIRkRJq/o6FPL/4NSwQDAcY6/qONhVbcssx/XGZqBhIIyJSolkg7Hw/VYmivz4Ocbvd3H333cyePZsmTZpw9dVXc95557F2bdRfhigiIgcIhoO8tORNcsJ+/GE/YSw5YT9/bZvD9K1/OR1PRERKKRV7DjvuuOOYPHkyL730EhMmTKBZs2a89957upZPRKQEWZKxHFvAZf45YT+TNv3uQCIRkdgUwhT6FstU7EUBt9vNHXfcwZw5c2jWrBl9+/alR48erFmzxuloIiJyOP7lvYKG54uIiFNU7EWRxo0bM2nSJIYOHcqkSZNISUnhnXfeUS+fiIjDrLVsyt7Cdn/BS8Aem9QIU8Cf1DhXHJ2rdCzqeCIipYJFPXuRUrEXZVwuF7fddhtz586ldevWXHvttZx55pmsWrXK6WgiIqXSgh2LuWXW/dw79zFunXU/j6U9x1b/9v2O8bg83HnsDcS5fPhcPlwY4lw+2lZsyQmVWjuSW0QkFoWtKfQtlqnYi1KNGjXil19+4bXXXmPq1Kk0a9aMESNGqJdPRKQYbcrewnOLX2Wrfxv+sJ+gDbI042+eXPBCvt/Hzco34dXWg7my7kX0rtOTh5vew62Nr9VMnCIi4hj9BYpiLpeLm266iXnz5pGamsr111/PGWecwcqVK52OJiJSKvy8aRIhG9pvX5gw2/zbWZyxLN/xZb1JnF69C+fXOptGSfWLKaWISOmgYZyRU7FXAjRo0ICff/6Z4cOHM23aNJo1a8bw4cMJh/PP/CYiIoVnU/YWggcUe3ts9W8r5jQiIiKRUbFXQrhcLgYMGMD8+fPp0KEDN910E926dWPFihVORxMRiVlNyx1HnMuXb3/IhtVzl2dLTjrj1/3AF6vHs2K3Rp6ISNGxGEK4Cn2LZbH97GJQvXr1+PHHHxkxYgQzZsygefPmvPbaa+rlExEpAqdU6UA5b1k8xr13X5zLR4fktlSLr+pgsugwZfM07pr9CKNWj+WLtV/zWNoQRq74RNeXi0iR0QQtkVGxVwIZY7j22muZP38+J598Mrfccgtdu3Zl+fLlTkcTEYkp8e54nmo2kDOqdaWKL5naCTW5sm5vBjTq43Q0x+0K7mbE3x8SsAGCNojF4g/7mbR5KosyljodT0REULFXotWtW5fvvvuOd999l9mzZ9O8eXOGDh2qXj4RkUJU1pvEVfV780qbZxjS8jG6Ve+sGTaBOdvTcBfwOuSE/UzdMt2BRCIS6zRBS+T016qEM8bQt29f5s+fz6mnnsodd9xB586dWbpUn6qKiEjRcR3kDZLBHPQ+EREpXir2YkTt2rX5+uuvef/995k/fz4tWrTgpZdeIhQqeBY5ERGRo9GyQgph8l+b53V5OblKBwcSiUjsM4Ssq9C3WBbbz66UMcZw9dVXk5aWRrdu3bjrrrvo1KkTixcvdjqaiIjEmERPIjc16ovP5cXn8uExHrzGy5nVu3Js2UZOxxMREcDjdAApfDVr1mTcuHF89NFH3HbbbbRq1YpBgwZx55134na7D92AiIjIYWif3JbjyzVmevpf+G2A1hWaUzOhutOxRCRGWSCsvqqI6NWKUcYYrrzyStLS0jjjjDO49957Ofnkk1m4cKHT0UREJIaU95bj9Opd6FHjdBV6IlLkNEFLZFTsxbgaNWrw1Vdf8dFHH7FkyRJat27Ns88+SzAYdDqaiIiIiIgUIRV7pYAxhssvv5y0tDR69OjB/fffT8eOHUlLS3M6moiIiIjIYbFWE7REKrafneynevXqjB49ms8++4wVK1bQpk0bnnnmGfXyiYiIiIjEIBV7pYwxhosvvpi0tDR69uzJgw8+SIcOHZg3b57T0URERERE/lUYU+hbLFOxV0pVrVqVUaNG8fnnn7Nq1Sratm3Lk08+SSAQcDqaiIiIiEg+FgjhKvQtlsX2s5NDuuiii1iwYAEXXnghDz/8MO3bt2fOnDlOxxIRERERkaOkYk+oXLkyn3zyCV9++SXr1q0jNTWVxx9/HL/f73Q0EREREZE8mqAlUrH97CQiF1xwAWlpaVxyySU89thjnHDCCcyaNcvpWCIiIiIicgRU7Ml+kpOT+b//+z/Gjh3Lpk2baNeuHY888oh6+URERETEURYI4yr0LZbF9rOTI3beeeeRlpbG5ZdfzqBBg2jbti0zZsxwOpaIiIiIlGIhawp9i2Uq9uSgKlWqxPvvv8/XX3/N1q1b6dChAwMHDiQnJ8fpaCIiIiIicggq9uSQevToQVpaGldffTVPP/00bdq0Yfr06U7HEhEREZFSxGK09EKEYvvZSaGpUKEC7777Lt999x07d+7kxBNP5P777yc7O9vpaCIiIiIiUgAVexKRM888k/nz59OvXz+effZZWrduzbRp05yOJSIiIiKlQNi6Cn2LZbH97KRIlC9fnhEjRvDDDz+we/duTjrpJO69916ysrKcjiYiIiIiInlU7MkRO+OMM5g/fz7XXnstzz//PK1ateL33393OpaIiIiIxCALumYvQrH97KTIlStXjjfffJOffvqJnJwcTj75ZO666y4yMzOdjiYiIiIiMcRS+MsuaOkFkcPQrVs35s2bx4ABA3jppZdo2bIlU6ZMcTqWiIiIiEippWJPCk3ZsmV5/fXX+eWXXwiFQnTu3Jnbb7+d3bt3Ox1NRERERGJAGFehb7Estp+dOOLUU09l7ty53Hzzzbzyyiu0aNGCSZMmOR1LRERERKRUUbEnRSIpKYlXX32VX3/9FYAuXbpw6623smvXLmeDiYiIiEiJZC2ErKvQt1gW289OHNe5c2fmzp3L7bffzmuvvUaLFi2YOHGi07FEREREpMQxhItgi2Uq9qTIlSlThpdffplJkybhdrvp2rUrN910ExkZGU5HExERERGJWSr2pNh06tSJOXPmcNddd/HGG2/QvHlzfv75Z6djiYiIiEgJYNEwzkjF9rOTqJOYmMgLL7zAb7/9RlxcHKeffjo33HADO3fudDqaiIiIiEhMUbEnjujYsSOzZ8/m3nvv5e2336ZZs2b8+OOPTscSERERkSgWwlXoWyyL7WcnUS0hIYHnnnuO33//naSkJLp37861117Ljh07nI4mIiIiIlHGYgjbwt9imYo9cVz79u3566+/uP/++xk5ciQpKSl8++23TscSERERESnRVOxJVIiPj+eZZ55h2rRpVKhQgR49etC3b1+2bdvmdDQRERERiRIaxhmZ2H52UuKccMIJzJw5k4EDB/Lhhx/SrFkzvv76a6djiYiIiIiUOCr2JOrExcXx5JNP8t///pfk5GTOPfdcrrrqKrZu3ep0NBERERFxiAXC1lXoWyyL7WcnJVrbtm2ZMWMGjzzyCJ9++ikpKSmMHTvW6VgiEZm/Yy6PpT3EjTOvY+C8+5mxdbrTkURERKSUULEnUc3n8/H4448zffp0qlWrxvnnn88VV1xBenq609FEDmn+jrm8vnwYa7LWELABNuZs4N1/3ub3LVOdjiYiIlICGUJFsMUyFXtSIrRu3Zrp06fz2GOPMWrUKFJSUhgzZozTsUT+1eg1o/CH/fvt84f9fLH2c6y1DqUSEREpmTSMM3Kx/ewkpvh8Ph599FFmzJhBjRo16NWrF5deeilbtmxxOppIgTZmbyxw/87ADoI2UMxpREREpLRRsSclTsuWLZk+fTqDBg3iyy+/pGnTpowePdrpWCL5VPRVKnB/ojsRj/EWc5qSISOQwWervuDBuY/x7MIXmbc9zelIIiISRTSMMzIq9qRE8nq9PPTQQ8ycOZM6derQu3dvLr74YjZt2uR0NJG9zq/ZC5/Lt98+n8vHOTXOw5jY/uNyJDICGTw473G+3/ATq7PWMH/nAoYufY3v1//kdDQREZESScWelGjNmzdn2rRpPPXUU4wdO5aUlBQ+++wzXQ8lUaFdcnuuqHsV5TzlMbgo4y7DBTUvpFu1M5yOFpW+3/Azu4K7CNrg3n05YT+frxlDdijbwWQiIhINrDW6Zi9CHqcD7GGMeRc4B9hkrW1WwP1dgLHAirxdX1prnyi2gBK1vF4vDz74ID179qRv375ceumljBo1itdff51q1ao5HU9KuZMqd6Jj8skEbACv8apH71/M3T5/v0JvD7dxsypzDceWPcaBVCIiEk1CMV6cFbZoerXeA848xDFTrLWt8jYVerKflJQUfv/9dwYPHsw333xD06ZN+eSTT9TLJ44zxuBz+VToHUJFX4UC94dskPLessUbRkREJAZETbFnrZ0MbHU6h5RsHo+H//znP8yaNYvGjRtz+eWXc8EFF7B+/Xqno4nIIZxV4/R81zi6cVM3sQ7V4tVLLyJS2lkgjCn0LZZFTbF3mE40xswxxnxnjEk52EHGmOuNMTOMMTM2b95cnPkkSjRp0oSpU6cyZMgQfvjhB1JSUvjwww/Vy1eKBcNBfts8iSGLnubFxc8yfes0wjbsdCzZR5Nyx3NF3UuIc8WR4IrHa7w0TKrPHcfe4nQ0ERGREslE05tfY0x94OuDXLNXDghba3cZY84GhlprGx+qzdTUVDtjxozCDyslxuLFi+nXrx+///4755xzDm+++SY1a9Z0OpYUo7AN88rSF1i2a8neRc59rjjaVkylb4PrHU4nB/KH/azJXEtZb1mqxFV2Oo6ISMwyxsy01qY6neNw1UypaPt/2qXQ232yxVcl6nWIRInp2bPW7rTW7sq7/S3gNcboXYAc0nHHHcfkyZN58cUXmTBhAikpKbz//vvq5StFFu5MY/mupXsLPQB/OIeZ2/5kTeYqB5NJQXwuHw2TGqjQExGR/VggbE2hb7GsxBR7xpjqJm92A2NMO3KzpzubSkoKt9vNnXfeyZw5c2jevDl9+vShR48erFmzxuloUgwW7lxATjgn3/6wDbM4Y5EDiURERESKXtQUe8aYT4A/gOOMMWuMMf2NMQOMMQPyDrkImG+MmQO8Alxq1TUjEWrcuDG//vorr7zyCpMmTSIlJYV33nlHvXwxrqynLB7jzbffbTwkeZIcSCQiIiJHIoSr0LdYFjXPzlp7mbW2hrXWa62tba19x1r7hrX2jbz7h1lrU6y1La21Hay1vzudWUoml8vFrbfeyty5c2ndujXXXnstZ555JqtWaThfrGqf3BFXAcseuIyhVYW2DiQSERERKXpRU+yJFLdGjRrxyy+/MGzYMKZOnUqzZs0YMWKEevliUAVfBW5qdDuJ7kTiXfHEueIp5ynPHY3vJc4d53Q8EREROQyWwr9eL9av2fM4HUDESS6Xi5tvvpmzzz6b/v37c/311zNq1ChGjBhB/fr1nY4nhahp+WY83/JVVmb+g9u4qJtYH5eJns+7rLX8unkCP2z4lt3BXTQo04jedS6lTmI9p6NJMfpz6198s/5HdgR20rx8U86v1YNKvopOxxIRkRIqet7piDioQYMG/PzzzwwfPpxp06bRvHlzhg8fTjisddhiicfloVHSMdQv0zCqCj2AMWs/54s1n7HVn05OOIdFGQt4btFTrM9a53Q0KSbj1n3H8OXvsHTXcjblbObXTb/x4Lwn2O7f4XQ0EZGoEcZV6Fssi+1nJxIBl8vFgAEDmD9/Ph06dOCmm26iW7durFixwuloEuOyQllM2PjjfktDAATCAb5dP96hVFKcskLZjFk7npx9fgZChMgKZfHt+h8dTCYiEj2shZA1hb7FMhV7IgeoV68eP/74I2+++SYzZsygefPmvPbaa+rlkyKzJWcTbpN/VH2YMP/s/tuBRFLc1matw23c+fYHbYh5Oxc6kEhERGKBij2RAhhjuP7665k/fz4nnXQSt9xyC127dmX58uVOR5MYVNGXTNAGC7yvenyNYk4jTijvLU8wHCrwvsq+SsWcRkQkemmClsio2BP5F3Xr1uX777/nnXfeYdasWbRo0YJXX31VvXxSqJI8SaRWaofX+Pbb73P56FHzPIdSSXGqEpfMsWUb4Tmgh9fn8nFOze4OpRIRkZJOxZ7IIRhj6NevH2lpaXTu3JnbbruNLl26sGzZMqejSQy5ul4/OlXpjNf4cOGisq8KAxrdSv0yDZ2OJsXk9sY3klLueDzGQ5wrjkR3Av3qX8lxZRs7HU1EJCrkLr3gKvQtlplYX1MsNTXVzpgxw+kYEiOstbz//vvccccd+P1+nn76aW699Vbc7vzX2ogciZANEQgHiHPFYQpYCF5i347ATnYFd1Mtrgoel1ZIEpGiY4yZaa1NdTrH4araNNle9H9nFXq7w9t+VKJeh0jEdikrUsiMMfTp04e0tDROO+007rzzTk455RQWL17sdDSJEW7jJt4dr0KvFCvvLUethBoq9ERE5Kip2BM5ArVq1WLcuHF8+OGHLFy4kFatWvHCCy8QChU8wYKIlAzrszbwy8ZJTE+fgT8ccDqOiIjsw6IJWiKljw1FjpAxhiuvvJLTTjuNAQMGcM899zB69GhGjhzJ8ccf73Q8EYmAtZb3/vk/pmz+HYPBZVy4jIsHmtxN/TL1nI4nIiJyRNSzJ3KUatSowVdffcVHH33EkiVLaNWqFc8++yzBYMFT6YtI9Jmx7S+mbplGwAbwWz/Z4WwyQ5m8sPgVwlaz74qIRAdN0BKp2H52IsXEGMPll1/OggUL6NGjB/fffz8dO3YkLS3N6WgichgmbppMTjgn3/7sUDYrdv9T/IFERKRAYUyhb7FMxZ5IIapWrRqjR4/ms88+Y8WKFbRp04ann35avXwiUS5wkOvzjDEEw9H579daS04oRz2PIiJyUCr2RAqZMYaLL76YtLQ0evbsycCBA+nQoQPz5s1zOpqIHMRJlTvgc/kKuMfQKCn61jqctW0ud85+gGtn3Ma1M27jk1WjCVlNECVSUmQGM9mYvVn/biNkLYSsKfQtlqnYEykiVatWZdSoUXz++eesWrWKtm3bMmjQIAIBzfAncjDb/dtZnLGYbf5txXrekyt3pFGZBsS54gDwGDc+l48bG10bdUsgLM5YxivL3mSzP50wYXLCOfy4cSLv//OJ09FE5BByQjm8uvRtBsy8h//MfZwbZtzNr5umOh1LYlh0/QUTiUEXXXQRXbp04dZbb+WRRx5hzJgxjBw5kpYtWzodTSRqBMNB3v3nXWZsnYHH5SEQDpBaMZX+DfoXS7HlcXm4v8ndzNk+j7k75lPOU5ZOVU6iclxykZ87UmPWjscf9u+3zx/2M3nz71xa50ISPQkOJRORQ3nj7/eZuXUOARsECzn4GfnPJ1TyVaBFhRSn45UIsT6hSmHTqyVSDCpXrswnn3zCl19+ybp160hNTeWxxx7D7/cf+sEipcBXa79i5taZBGyArFAWQRtk5raZjFk7ptgyuIyL1hVbck39K7ig9nlRWegBrM/aWOB+t3GxPbC9eMOIyGHLCOxixtbZBOz+I3z8YT9frf3OoVQS61TsiRSjCy64gLS0NC699FIef/xx2rVrx6xZs5yOJSVMIBxg8qYJvLD4KV5b9gLzdsx2OtJRm7h5In67/4cfARvgl02/OJQoetUvUxdTwOxxYSzJvkoOJBKRw7EzmIHHuAu8b4t/azGnKZkshb+geqwvqq5iT6SYJScn8+GHHzJ27Fg2btxIu3bteOSRR9TLJ4clZIO8uPgpRq/5mKW7FjFvx2xG/D2MMWs+czraUckOZRe4Pyecg7W2mNNEtwtrn4fX5d1vX5zLxzk1uhPnjnMolYgcStW4ygXud2FoUrZxMacpuZxaesEYc6YxZrExZpkx5v4C7o8zxnyWd/9/jTH1C/u5HwkVeyIOOe+880hLS+Pyyy9n0KBBpKamMnPmTKdjSZT7a9ufrMtes18vmD+cw4RNP7CtBH8y3KBMgwL31y9TH2Ni+1PXSNVNrM1DTe7h+LKNiXP5qOxL5vK6velV61yno4nIv/C6vFxS53zi9pn512CIc8fRq3YPB5PJoRhj3MBrwFlAU+AyY0zTAw7rD2yz1h4DvAQ8W7wpC6ZiT8RBlSpV4v3332f8+PGkp6fTvn17Bg4cSE5O/sWdRQDm7phV4OLfbuNm6a5FDiQqHFfWu5I4VxyuvD9LLlzEueK4su6VDieLTo2SGvBw0/t494TXGNp6MN2qdVFRLFICnFnjNG455loalalPJV8FTkw+gaebP0S1+KpORysRLDg1jLMdsMxa+7e11g98CvQ84JiewPt5t0cDp5ko+MWs2ThFosA555zD/Pnzueuuu3j66acZO3YsI0eO5IQTTnA6mkSZcp5yuHARZv+FtA1Qxp3kTKhCUL9MfR5PeZzvNnzHyt0rqZtYl7NqnEX1+OpORxMRKVSplVqRWqmV0zFkf5WNMTP2+fota+1b+3xdC1i9z9drgPYHtLH3GGtt0BizA0gGthRB3sOmYk8kSlSsWJGRI0dy8cUXc91119GhQwfuu+8+Hn30UeLj452OJ1Hi5MqnMnnzRMIHTGbidfk4vlzJnra7Wnw1+tTv43QMERGJYkW09MIWa21qUTTsNA3jFIkyZ511FmlpafTt25fBgwfTpk0b/vvf/zodS6JEjYRaXF3vWuJcccS7EohzxVPRW4k7jr0f90FmeRMREYkJRTCE8zCHca4F6uzzde28fQUeY4zxAOWB9EJ41kdFPXsiUah8+fK8/fbb9O7dm2uvvZaOHTty99138/jjj5OQoAWTS7sTkk+kZcW2rNi9nDhXHPUSG+h6LRERkaLzJ9DYGNOA3KLuUuDyA44ZB1wD/AFcBPxio2A6afXsiUSx7t27k5aWxrXXXsuQIUNo3bo1v//+u9OxJAr4XD6OK9uE+mUaqtArQHpOOt9v+J5x68axKnOV03FERKQQWJxZesFaGwRuAX4AFgKjrLVpxpgnjDHn5R32DpBsjFkG3AXkW57BCerZE4ly5cqV480339zby3fyySdz5513MmjQIBITE52OJw5Iz9nCZ6vfZ2HGXNzGTWrFE7mw9hUkuPXzAPBH+h+MXDESiyVkQ3yz/hs6Ve7EFXWvUGEskmf+joV8vOoL1mZtoLKvIhfXOZ/2yW2djiUStay13wLfHrDvkX1uZwO9izvXoahnT6SE6NatG/PmzWPAgAG8+OKLtGrVit9++83pWFLMskKZPLv4EdJ2ziZkQ/jDfqZvncrQpc9o8XFgd3A3I1eMJGADBG0Qi8Uf9jNlyxSW7FridLwSb03mWp5Z+CJ9pt/EjTPvYszarwnZkNOxJELzdyxkyOJhrNi9Cn/Yz7rsjby+fCSTNmnkiEQ/h67ZK7FU7ImUIGXLluX1119nwoQJBINBTjnlFO644w52797tdDQpJtPTp+IPZWP5X2EXtEE2Zq9j+W4VM/N3zC9wohp/2M+09GkOJDp8K3b/w4SNvzBr22yC4aDTcfLZnJPOo2mDmb9zIQEbYGcwg3HrvmPE3x84HU0i9PGqL/CHA/vt84f9fLL6S31oJFHNwXX2SiwVeyIlUNeuXZk7dy4333wzQ4cOpUWLFkyaNMnpWFIM1mStxH/AsgsAYWvZkH3gxGCyh8n7LxoFw0FeXPwyTy98lk9Xj+KN5SO4Z85/2Jyz2elo+/l2/Y8ECigQpqVPZ5t/uzOh5Iisy9pQ4P6MwC5ywjnFnEZEipKKPZESKikpiVdffZVff/0VgC5dunDrrbeya9cuZ4NJkaqZUBefKy7ffpdxUS2upgOJokvz8s3zLTgP4HV5OTH5RAcSHdpPG39m4c7F+MN+/OEA2eFstgd28PqyN52Otp+/d/9DiPxDNr0u70GLB4lOyb5KBe6Pd8fhc/mKOY1IZNSzFxkVeyIlXOfOnZk7dy633347r732Gi1atGDixIlOx5Ii0iH5ZLzGu18vldu4qRJXjWOSjnMwWXRI9CRyXYPr8BovXuPFbdx4jZeuVbvSuGxjp+MVaOLmyfl6ay2WVZmr2e7f4VCq/Gon1MJVwNuGQDhItfgqDiSSI3VxnZ75iro4l4+eNc/CZfTWUCSW6F+0SAwoU6YML7/8MpMnT8bj8dC1a1duvPFGMjIynI4mhSzBnch/jn+CJuWa48KFx3hJrXgidzR+UDNN5kmtlMqQlkO4pM4lXFjrQh5LeYxL6lzidKyDCh3k+jyDiarJT3rUOAOva/9JvL3GS4sKKVSOS3YolRyJ9slt6Vf/csp7y+HCRaI7gV61zuHcmt2djibyryyOLapeYplYvxA3NTXVzpgxw+kYIsUmMzOThx9+mJdeeom6devy9ttv061bN6djSRHY8/tbRV7J9vnqL/h+w48E7f5FX/W4agxu8VRUfX+XZCzj3RUfsSZrLR7joUuVk7i83sX4XF6no8kRsNaSE87B5/KpR6+UMsbMtNamOp3jcJU/vpo9+a3C//Du286vlqjXIRJaZ08kxiQmJvLCCy9w4YUX0rdvX04//XSuv/56hgwZQrly5ZyOJ4UomoqAA2WHsnEbF15d/3NI59Q8m7+2zSbdn05OOGfv8NMbGl0XNd9jay3GGI4tewyDWzxKMBzEZVwqEEo4Ywzx7ninY4hE5HAWQZf/UbEnEqM6duzI7NmzeeSRR3jxxRf57rvvGDFiBN27a5iOFJ3Vmf/w4coRrMtajTGG5uVac0W9aynjSXI6WtRKcCcwqNmjzNg2kyUZS6kSV5mTKp9EOW9Zp6Mxb3sa/7fyU9ZlryfJU4aza5xJjxrd8bj09kFEHGCJ+WGXhU0fyYnEsISEBIYMGcLUqVMpU6YMZ555Jv3792f79u1ORys0gXCAj1d+S5//PsyV0x7g9aWfsSOgGUmdsCOwjZeWPMmarJWECROyIebtmKUF3w+Dx+WhQ3J7rq5/JWfVODMqCr0lGUt5eekw1mWvB2BXcDdfrR3P6DVfORtMREQOm4o9kVKgQ4cOzJo1i/vuu4/33nuPZs2a8d133zkdq1A8kfYmX6z5mXT/dnYEdvHTxj+4e9bz5ITyr0UnReu3zRPzXXcWIsSmnA38k7ncoVTRb3XmGl5a8gq3/HUHD89/jD+3Rsd15l+uGVfgwts/bPgZf1j/vkSk+GlR9cip2BMpJeLj43n22Wf5448/KF++PGeffTb9+vUr0b18SzNWsXDniv3ekAZtiB2BXUzZ8peDyUqn9dlr8xV7kDur5IasdUzd8itDlzzNG8tfJG3HHAcSRp81mWsZtOBpZm+fQ0Ywg1WZq3nr73f4acMEp6OxNmtdgfsNFNmSEP/sXsWXa8Yzft33bM7ZcsTtWGvJCmUTtvnXXBQRKU006F6klGnXrh0zZ87kiSee4LnnnuOHH37grbfeokePHk5Hi9jyXavJ/Zxvf9nhHBbtXEG3ah2KP1Qp1rBMY+bvnJWv1ydsw0zc/AObcjbgD+cAsCgjjc5VTueCWpc6ETVqfLn2q3yvlz/s54u1X3Jq1c6OXhtXO6EW2wMFF3UVfBUK/Xwf/vMpv2yeQjAcwGXcfLFmHP0aXMkpVTpG1M6Uzb/zyeov2BXchc/lo0eN7vSsebYmkxGJEbHeE1fY9JtPpBSKj4/n6aefZtq0aVSqVIlzzjmHa665hm3btjkdLSJV4ysV+AbO5/JSM6GqA4lKtxMrn0K8K2G/hbe9xkv1+Br7FXoA/nAOEzf9wFZ/uhNRo8bfu/7GFvCBRdha0v1bHUj0PxfW7plvSQWfy8dZ1bsX+lILizOWMXHzFPxhP2EsQRskYAO8u+L/yIjgGtw/t/7Fu/98xI7ATkI2TFYom3HrvmPsum8LNa+IOEPr7EVOxZ5IKZaamsqMGTN46KGH+Oijj0hJSWHcuHFOxzpsLSscR3lv2f2KCwCPcXNatfYOpSq99iz43rZiBxLciZTzlKdbtR5Uj6+1X6G3h9u4WZqx0IGk0SP5IIuRh2240CZp2ZC9kXdXvM9jaYMYueIDNmZvPKzHHVO2EXcdext1E2rjwkV5bzkuqn0+vWqfVyi59jUtfXq+6wMB3MbF7O3zDrud0WvGFthT+vW6HzSkU0RKJQ3jFCnl4uLiGDRoEBdccAF9+/alZ8+eXHHFFQwdOpTk5ILfiEYLt3ExuMUdvLTkA9J25E4AUjuhGncedxXlvZrq3wkVfcn0bXDTfvu+WPMxLtyECe2332BI9JQpznhR57ya5zJs2ev7FShe46Vj5Q4kuBOOuv2/d61g8KIhBMIBwoRZuXsVf6RP44Em99GgTP1DPj6lfBOeavHYUec4FPMvnz27IlhrcEtOwb2hARsgK5RNGU9ixNlEJLrYGO+JK2zq2RMRANq0acOff/7JY489xmeffUZKSgpjxoxxOtYhJceV58nmt/JRh8F80P4pXm37AA2TajsdS/ZxUuUuuI073363cdOkbHMHEkWPlhWac029K0nylMFrvHiNl5Mrd+TqelcWSvsfrvyInHAOYXJ7tcKEyQnn8NHKTwql/cJyUuX2eAsYGhqyYVpVOPyfkdoJNQvcn+hOIEGLh4tIKaRiT0T28vl8PProo8yYMYMaNWrQq1cvLrvsMrZsOfJZ8YpLoieest7S3UsUrarH1+TKetfic8UR70ogzhVPeW9Fbm/8gBbnBk6uchKvtn6Z51o+w2tthtKnwdWF8rpYa1mx+58C71u+6++jbr8wNUpqwFnVT8drvHiMB19e4TugUV/KRND7e2ndXgVeZ3hJnV6aoEUkRoQxhb7FMv2VFdmHtRaCCyG0EbzNMO4qTkdyRMuWLZk+fTqDBw9m0KBBTJgwgddff52LLrrI6WhSQp1QqSMtK6SyYvdSfK446iU21JvvfbiMi0q+ioXapjGGOFcc2eHsfPfFR2Ev18V1zqdT5Q7M2j4Xr8vLCRXbUMFXPqI2mpQ7jnuPu51PVo1mbdZ6kn0Vuah2T9onpxZRahEpTtZqNs5IqdgTyWND6dht/SD0D+AG68cmXoYp+yAmgmtGYoXX6+Xhhx/m/PPPp2/fvvTu3ZvevXszbNgwqlbVTJcSOZ/Lx3FlU5yOUap0rdqFnzdN2G/yE5/x0bVqF+dC/YsaCdWpkVD9qNpoWu44BjUbWEiJRERKNn2sKpLHbr8dgkvBZoHdBfghcxRkj3U6mqOaN2/OtGnTePrppxk7diwpKSl89tlnub2gIhLVLqx9AW0qtMFrPCS4E/AaD6mV2nBBrZ5ORxMROSLWmkLfYpl69kQAG9oMgdlA8IB7srC738MknF/8oaKIx+PhgQce4LzzzqNv375ceumljBo1itdff51q1ao5HU9EDsLj8nDjMdezzb+NjdmbqB5frUgWRBcRkeiknj0RALsbyD9bYO59GcUaJZqlpKTw+++/8+yzz/LNN9/QtGlTPvnkE/XyiUS5ir6KHF/uOBV6IlLCaVH1SKnYEwFw1wFXQesveSHutGKPE808Hg/33Xcfs2fP5thjj+Xyyy/nggsuYP369U5HExEREZF9qNgTAYxxY8o9DcTzvx6+eHBVwiQNcDBZ9Dr++OP57bffeP755/nhhx9ISUnhww8/VC+fiIiIFBldsxcZFXsieUz8qZjkLyDhIvB1hKRbMJW/wbgqOR0tarndbu6++25mz55NkyZNuPrqqznvvPNYt26d09FEREQkxljQMM4IqdgT2YfxNsZVfhCuSu/hSroe4yrndKQS4bjjjmPy5Mm8+OKLTJgwgZSUFN5//3318omIiIg4KGqKPWPMu8aYTcaY+Qe53xhjXjHGLDPGzDXGtCnujCJycG63mzvvvJM5c+bQrFkz+vTpQ48ePVizZo3T0URERCQW2NyF1Qt7i2VRU+wB7wFn/sv9ZwGN87brgeHFkElEItS4cWMmTZrE0KFDmTRpEikpKbz77rvq5SskOaFs/tm9jPSczU5HKRYr5q3k7Qc+4o2732fBH4udjiMiIlKiRM06e9baycaY+v9ySE/gA5v7jnGaMaaCMaaGtVZTAIpEGZfLxW233UaPHj3o168f/fv3Z9SoUYwYMYI6deo4Ha/EmrjxO75ePwoXbkI2SN0yjbiu4R2U8ZR1OlqR+PyFcbz/yGcE/EFs2PL1mz/RvU8Xbh12rdPRRETEIWFi+xq7whZNPXuHUgtYvc/Xa/L25WOMud4YM8MYM2Pz5tLx6bdINGrUqBETJ07k1VdfZcqUKaSkpDBixAj18h2BtB2z+XrdKPxhP9nhLAI2wD+7lvLO30OdjlYkNq3ewnsPf0pOlp9wKIy1lpzMHH5471cWTFvidDwREXGARbNxRqokFXuHzVr7lrU21VqbWqVKFafjiJRqLpeLW265hXnz5pGamsr1119P9+7dWblypdPRSpRfNn6L3/r32xcixIrdy9jmT3coVdGZ/u0sjCv/nyh/lp+pY/7rQKLotN2/nWW7lpIRyHA6ioiIRKGoGcZ5GNYC+47/qp23T0RKgIYNG/Lzzz/z1ltvce+999KsWTOGDBnCDTfcgDGx/alaYdgZ3F7gfrdxsyuYQUVfcvEGKmIen4eCfixcboM3zlv8gaJMIBzg3RUjmLV9Fl6Xh0A4wEmVO3FF3atwmZj8HFdEBIj9pRIKW0n6izAOuDpvVs4OwA5drydSsrhcLgYMGMC8efNo3749N954I926dWPFihVOR4t6Tcq2wG0K/nyuenzNo25/ccY8nl/0H+6dcxVPLriNP9MnH3WbR6PjeanYcP7hvm6vh1MvO9mBRNFl9JrPmL19FkEbICuURdAG+WPLVL7f8J3T0UREJIpETbFnjPkE+AM4zhizxhjT3xgzwBgzIO+Qb4G/gWXACOAmh6KKyFGqX78+P/30E2+99RZ//vknzZs357XXXiMcDjsdLWp1q34uie7E/Qo+n/FxQe0r8Lp8R9X2sow03vl7CGuzVxK0AdL9m/h8zdv8tuWHo419xMoll+U/H95GXIKP+KR44hLj8MV7uXbwFdRrUtuxXNEgbMNM2TyZgA3st99v/fy88UeHUomIFA8tvRCZqBnGaa297BD3W+DmYoojIkXMGMN1111H9+7due6667jlllv4/PPPeeedd2jUqJHT8aJOOW95HmgymF82fcvCnXOp4K3EadV60Lhs06Nu++v1nxA44HrAgPXz3frP6Zh8umPDAjv1ak/LLm8wbfxMgoEQ7c5uTeWalRzJEk1CNpSv0NsjK5RZzGlERIpXrE+oUtiiptgTkdKpbt26fP/994wcOZI777yTFi1a8Mwzz3DLLbfgKmCCjtKsrLc8PWtdRs9a//rZWMQ2Zhd8+XNOOJusUCZlPEmFer5IlKtUljOu6eLY+aOR1+WlRnxN1hXwfWuUdIwDiUREJFrpnZSIOM4YQ79+/UhLS6Nz587cfvvtdOnShWXLljkdrVSo5Kta4H6v8RLvTijmNHI4rqx3NT6XD5O33pQLF3GuOC6pU7gfBIiIRJPcYZdaeiESKvZEJGrUrl2bb775hvfee4+5c+fSokULXnrpJUKhkNPRYtrZNS7Ga/a/7s/niuPUqufhNm6HUsm/ObbscQxs8gjtK51InYS6nFy5E482HUSdxLpORxMRkSiiYk9EoooxhmuuuYa0tDROO+007rrrLk455RQWL17sdLSYlVK+LZfVHUAFbzIGQ4K7DN2rXcjp1c53Opr8i1oJtbm24fU8mvIEV9fvS9X4gntoRURiSdiaQt9ima7ZE5GoVKtWLcaNG8dHH33EbbfdRqtWrRg0aBB33nknbrd6mwpb64odaV2xI8FwELdxa+1DERGRGKCePRGJWsYYrrzyStLS0ujevTv33nsvJ598MgsXLnQ6WszyuDwq9I6QP+zHH/Yf+kARETliWnohMir2RCTq1ahRgzFjxvDxxx+zZMkSWrduzbPPPkswGHQ6mgjpOVt4eclT3DX7Ou6afR0vLXmKLTmbnI4lIhKTNEFLZFTsiUiJYIzhsssuY8GCBfTo0YP777+fjh07kpaW5nQ0KcUCYT9DFj/G0l2LCBMiTIhluxbx/OLHS3UvX9qONF5c/CKPzH+EL9Z8QUYgw+lIIiKlkoo9ESlRqlWrxujRo/nss89YsWIFbdq04emnn1YvnzhizvaZ5ISzsfxvHJDFkhPOYfb2PyNqKxgOsju4C1vCxxT9tOEnXln2CvN2zmN11mq+3/A9j6Q9wq7gLqejiUgJZyn8Xj317ImIRBljDBdffDFpaWmcd955DBw4kA4dOjBv3jyno0kpszlnE/5wTr79OeHswx7KGQwH+XTVB9w5+wbum3sr98+7jZlbpxd21GKRE8ph9NrR+/VqBm2QXcFd/LjhRweTiYiUTir2RKTEqlq1Kp9//jmjRo1i1apVtG3blieffJJAIOB0NCklaifWxeeKy7c/zhVPrYTDW/Pu09XvM3XLJALWT8gG2RHYzvsr32RxRsmbiGh11mrc5J8tN2iDzN0x14FEIhJrbBFssUzFnoiUeL179yYtLY0LL7yQhx9+mPbt2zN3rt5YStFLKdeSZF9lPOZ/Kxm5jYdKvmSalW91yMdnhTKZlj6VgPWz71sPfziHb9ePLarYRaaspyxBW/CQ6greCsUbRkRij9UELZFSsSciMaFKlSp88sknfPHFF6xdu5bU1FSeeOIJ9fJJkXIZF3cf9wgnVT6VMu4kEt1JnJTchbuPfQS3OfR6kDsCO/KOsxjYb9uQvaZowxeBavHVqJtYF9cBby98Lh/dq3d3KJWISOmlYk9EYkqvXr1YsGABF110EY8++ignnHACs2fPdjqWxLAEdyKX1LmGIS3f4PmWb3Bp3T4kesoc1mMr+ZIJ23BugWf233YHM8gOZR/0sbuCGUzc9BNj1nzGvB2zCdtwIT2jo3Nb49toUKYBXuMlwZVAnCuOS+pcQpNyTZyOJiKxQOM4I+I59CEiIiVLcnIyH3/8MZdccgkDBgzghBNO4MEHH2TgwIH4fD6n44ns5XP5aFouhXk7/8p3n9u4mbV9Oicmn5LvvhW7l/HykmcJ2zAB6+fXzT9RK6EOdx77AF6Xsz/j5bzleKjpQ2zK3kRGMIPaCbWJc+e/rlFERIqeevZEJGb17NmTtLQ0LrvsMp544glSU1P566/8b6pFnFT7IBO5hGyQnYHt+fZba3lr+TBywtl51/pBTjiH1ZmrmLjpp6KMGpGq8VVplNRIhZ6IFKrScs2eMeZUY0yDvNs1jDHvG2NGGmOqR9KOij0RiWmVKlXigw8+YPz48aSnp9OuXTsGDhxITk7+6fJFnNC47PHEFTCjp8fl5Zik4/Pt35izgd2h/IuUB6yfaem/FUlGEZFoYW3hb1HqdSCUd/sFwAuEgbciaUTFnoiUCueccw7z58/nqquu4umnn6Zt27b8+Wdki16LFIXjyqZQL7EhXvO/4Zc+l49jyhxHwzKN8x3vwnXQNyeuw5gURkRESoRa1tpVxhgP0B24HrgR6BhJIyr2RGJMMLiK7dvuYePGTqRvuYKcnGlOR4oaFStWZOTIkXz77bds376dDh068MADD5CdffBJMESKmjGGW475D+fXuoTaCfWok1CPC2pexo3H3IUx+YcXVYmrSkVfpXz7fS4fJ1fuXByRRUQcYSk9wziBncaYakBnYIG1dlfefm8kjWiCFpEYEgz+zeZNZ2FtJhAiFFyO3z+N8hVeJDGxp9PxosZZZ51FWload999N4MHD2bs2LGMHDmS9u3bOx1NSimPy8OpVbtzatVDL09gjOGGRrfx4uKnCNoQwXAAt8vDsWWPp1OVrsWQVkREisGrwJ+AD7gjb99JwKJIGlGxJ1LCBUOb2ZX1A5YQwexfsHY3uUO6c1mbxc4dA0lIOAejIV57lS9fnrfffpvevXtz3XXX0bFjR+666y6eeOIJEhISnI4n8q9qJdThmRavMGf7THYEttOwTGMalGlUYE+gyJHKDGaxO5RJsq8iLqPBYBIFLBC9PXGFylr7rDFmDBCy1i7P270WuDaSdlTsiZRgO3aPZuPWeyHvj7C1WcQBvgP+JlubRSi0Ho+ndvGHjHLdu3dn/vz53HvvvTz//POMGzeOkSNH0rFjREPiRYqdz+XjhEonOh1DYlB2KIe3/n6Pmdtm4zIu4lxx9Kl/GR2ST3A6mkg0T6hSFFYAHYwxqdbaz8gt9iKij2lESqhgaCMbt96HJQdrs7A2C4AcIHzAL0JrQ7hcFYo9Y0lRrlw53nzzTX766SdycnI4+eSTufvuu8nMzHQ6mohIsRu2bAR/bZtN0Abxh/1kBDN48+/3WJyxzOloIqWGMaY5sAQYAbyTt7sz8G4k7ajYEymhMjK/g4OMZAjsV+zFkZDQA5crqThilWjdunVj3rx5DBgwgBdffJGWLVsyZcoUp2OJiBSbbf7tzN+RRsAG99vvD/sZv+47h1KJ7MMWwRadhgOPWGuPBwJ5+yYBJ0fSiIo9kRIreJCxDAaMB2OSgDji40+jfIUhxR2uxCpbtiyvv/46EyZMIBgM0rlzZ+644w52797tdDQRkSK3zb8dj6vgq3w25Wwu5jQipVoK8H95ty2AzZ2YIaKJBVTsiZRQZRLOKHC/MXFUrzKGypW/pFr16VRKfhuXK7GY05V8Xbt2Zd68edx0000MHTqUli1bMnnyZKdjiYgUqZoJ1QnZUL79blw0KXusA4lE9lX4yy5E8dIL/wBt991hjGkHRDSeWsWeSAnl89Qlufy9GBMPuAEXxiRQMek6EuLa4vU1w+2u4nTMEi0pKYlhw4YxceJErLV07tyZW2+9lV27dh36wSIiJVC8O57zap5NnMu3d5/BEOeO49yaZzmYTKTUeRj4xhjzOOAzxjwAfA48FEkjmo1TpARLLncTSQndyMgch7UhyiaeTbyvudOxYk6XLl2YO3cuDz74IK+88grffPMN7777Ll26dHE6mhymlf9sZvzYv9i8KYP2Jx7DaaenEBcX0bq0IqXG+TV7UD2+KuPXfc+OwE5Syh3PRbV7Ujku2eloItF8jV2hstZ+bYw5E7iO3Gv16gG9rLUzI2nH2BifvzQ1NdXOmDHD6RgiEiOmTJlCv379WLZsGTfddBPPPvssSUma/CaaTZm8iMFPjiMQCBEOW+LjvVStVo5hb/QhMTHO6XgiIo4xxsy01qY6neNwxTWobWs8cUuht7vy6gdK1OsQCfXsiYhEoFOnTsyZM4eBAwcydOhQvv32W95++21OO+00p6NJAQKBEM8P/oacnP/NLJidHWDD+u2M/XIml12p9RTFOcsylvN/Kz9jZeYqkjxJ9KjRne7Vu2FM1F5DJCLFxBjzxMHus9Y+crjt6Jo9EZEIJSYm8tJLLzFlyhS8Xi/dunVjwIAB7Ny50+locoC/l28iXMAIFr8/xKRfFzqQSCTXyt2reWbRCyzf/TdBG2R7YDufrxnDqNVfOh1NJLqVnqUX6hywnQDcAzSKpBEVeyIiR+ikk05izpw53HPPPYwYMYLmzZvz448/Oh1L9pGY6CMcLvgveZkyGsIpzvlq7XgC4cB++/xhPz9s+JnsULZDqUQkWlhr+x6wnQX0AoKHeuy+VOyJiByFhIQEhgwZwtSpU0lMTKR79+5cd9117Nixw+loAtSpm0yN6uXzDYuLj/fSs1dMXp4hJcTKzFXYAroU3MZNes5WBxKJlBSmCLYS40fg/EgeoGJPRKQQdOjQgVmzZnHffffx7rvv0qxZM77//nunYwnwxDO9qVqtHAmJPhITffh8bs45rzWdTjnO6WhSitWMr1Hg/pANUclXsZjTiJQgpWQYpzGm4QFbM+BJYHUk7WiCFhGRQhIfH8+zzz7LhRdeSN++fTnrrLPo27cvL774IhUqVHA6XqlVs2ZFPvzkJubPW822rbtJaVabylXKOh1LSrnza5/LwozF+MP+vft8Lh+nVDmJBE+Cg8lEJEosI7cU3dP1mAnMAq6JpBH17ImIFLJ27drx119/8eCDD/LBBx+QkpLCN99843SsUs3lMrRoWZfOpzZRoVfM1matZtza0YxbO5q1WRF9IB3TjklqyB3H3kyN+GoYDPGueM6sfjpX1bvM6Wgi0a2U9OxZa13WWnfe/13W2iRrbSets3cArbMnIk6aOXMmffr0Yf78+Vx99dW8/PLLVKyoIVpSOnyz/iu+Xz+eoA1iALfxcGb1c+hR8wKno0WVYDiI27i15IIUuxK5zt6jtxZ6uyv73l+iXodIqGdPRKQItW3blhkzZvDwww/z8ccfk5KSwrhx45yOJVLkNmSv5/v14whYP5YwYcIErJ/vN4xnQ/Z6p+NFFY/Lo0JP5HBYwJrC36KEMWa1MWbVobZI2tQ1eyIiRSwuLo4nnniCCy64gL59+9KzZ0+uuOIKhg4dSnJystPxRIrEnO0zCdtwvv1hG2bO9plUr36OA6lEpKSL8UGJVxZ2gyr2RESKSevWrZk+fTrPPPMMTz75JD///DPDhw/nggs0pE1iz95hiQe8MTPG4DZuZ0KJiEQxa+2kwm5TwzhFRIqRz+fj0UcfZcaMGdSoUYNevXpx2WWXsWXLFqejiRSq1hVOwBSwfpXB0LrCCQ4kEpGYUEomaAEwxrQyxtxqjHncGPPEni2SNlTsiYg4oGXLlkyfPp1BgwbxxRdf0LRpU0aPHu10LJFCkxxXmYvrXInXePEaH17jw2O8XFznSpLjKjsdT0QkqhljrgemAl2B/wDNgbuBYyJpR8M4RUQc4vV6eeihh+jZsyd9+/ald+/e9O7dm2HDhlG1alWn4zkiM7iLuTumsjOwjQZlmtAoqTkuo88lS6pOVbrSvHxr5u74C4AW5dtQQQuGi8jRiKIJVYrYfcCZ1topxpht1toLjDFnAZdG0oiKPRERhzVv3pxp06YxZMgQHnvsMSZOnMiwYcO4+OKLS9UMfasyl/DO308QtpaAzcHniqdWQkP6N3gYj8vrdDw5QhV8FTmlymlOxxARKWmqWmun5N0OG2Nc1trvjDEfRdKIPi4VEYkCHo+HBx54gL/++osGDRpw6aWXctFFF7Fx40anoxULay0frXyBnHA2AZsDgD+czZrM5UxL/9HhdCIiEi2MLfwtSq0xxtTPu70E6GmM6QT4I2lExZ6ISBRJSUnh999/59lnn+Wbb76hadOmfPLJJ9gYn2t6U84asoK78u0P2Bz+2vZr8QcSEZHoUxSTs0Tvn9fngCZ5t58A/g/4BXg8kkZU7ImIRBmPx8N9993HrFmzaNy4MZdffjm9evViw4YNTkcrMgZz0L+3pWkoq4iICIC19j1r7Xd5t78DKgIVrbXDI2lHxZ6ISJRq0qQJU6dOZciQIXz33Xc0bdqU//u//4vJXr4qcbVI8pTPt99r4jihoq73EhERAJM7QUthb1HIGPOyMWbvOjXWWr+1Nv8QmENQsSdygG3+jczZNpElGTMI2aDTcaSUc7vd3HPPPcyePZvjjz+eq666ip49e7Ju3TqnoxUqYwxX1r+HeFcZfK54XLjxueJomJTCCcnd9h63JWcd49a+xbt/P8ovG0axO7jTwdQiIlLaGWMqGWN+MsYszft/gVMOG2O+N8ZsN8Z8fbhNA2Pz2n3cGHPcEeWLxU+I95WammpnzJjhdAwpAay1fL/hHWZu/R5j3BgMXuPjmgZPUjW+rtPxRAiFQgwdOpSBAwcSHx/Pyy+/zNVXXx1TwxxzQlnM3/lfdgW2U7/M8dRNPG7v8/t71zw+WPE0IRsgTBiP8RLnSuDmxs9T3qd120REImWMmWmtTXU6x+GKq1fH1njg9kJvd+WN9x7x62CMeQ7Yaq0dbIy5n9yhlv8p4LjTgETgBmvtOYfZtgs4DbgMuAD4G/jIWvvi4eZTz55InkUZ/+WvrT8StAEC4Wz84Sx2h3bw8cpBMTlsTkoet9vNXXfdxdy5c2nWrBl9+vThnHPOYe3atU5HKzRx7gTaVuxC56rnU6/M8XsLPWstX6weRsDmECYMQNAGyAzt4ueNnzqYWEREilX0TdDSE3g/7/b7wPkFxrZ2ApARScPW2rC19idrbT+gGZAODImkDRV7Inn+TP9u75Tv+8oM7WRD9goHEh2eUNiPtWGnY0gxaty4MZMmTWLo0KFMnDiRlJQU3n333Zj+UGJXcDsZwe359lvCLMmYWfyBREQkllQ2xszYZ7s+gsdWs9auz7u9AahWWKGMMWWMMVcaY74hd/mFIHBNJG1oUXWRPIFwdoH7DabAItBpq3b/l6kbXyYjsAGPiSOl4gWcULk/LqN/1qWBy+Xitttu4+yzz6Z///7079+fUaNGMWLECOrUqeN0vELnc8VzsI9f41yJxRumEFlr2bUji7gEL744LRwvInJIRfO55pZ/G8ZpjPkZqF7AXQP3/cJaa40pnJX7jDGfA2cBfwGfANdYa7dE2o569kTyNCvfCa+JK+AeQ834Y4o9z7/ZkDWfn9Y+zM7AOixhAjaL+du+YOqmV52OJsXsmGOOYeLEiQwbNozffvuNlJQURowYEXO9fHHuBI4t2xr3AZ9Rek0cJ1Y+26FUR2fW1KX06/IMl7d/nItaPsSzd35E1u7o+2BJRKS0s9Z2s9Y2K2AbC2w0xtQAyPv/pkI67Z9AU2vtKdba4UdS6IGKPZG92lQ6gyrxdfGaeABcuPEYH+fXvh2PK7o+cf9ry/sED+htDNocFu/4Fn9ot0OpxCkul4ubb76ZuXPnkpqayvXXX0/37t1ZuXKl09EK1YW1b6VmYkO8Jo44VyIe46VlhU60Tz7L6WgR+2fxeh6/7l02rN5KMBAi4A8x9bt5PHXzB05HExGJXpZoXHphHP8bWnkNMPZoGwSw1j5nrV11tO1EzXgvY8yZwFDADbxtrR18wP19yL0gcc9MBMOstW8Xa0iJaV6Xj/4NB7Nw5x8szZhJkqcibSqeTnJcTaej5bPdX/C/fRcedgc343OXKeZEEg0aNmzIzz//zFtvvcW9995Ls2bNGDJkCDfccENMzNiZ4EliwDGD2Zi9km3+zdSIr19iZ+H84u1JBAL7L+0S8AeZ99/lbFidTvU6yQ4lExGJboUzSLJQDQZGGWP6AyuBiwGMManAAGvttXlfTwGOB5KMMWuA/tbaH4o6XFQUe8YYN/AacDqwBvjTGDPOWrvggEM/s9beUuwBpchlBHaQE84h2VfF0TelbuOhWflONCvfybEMhyM5vjEZuzZy4MD1MCGSvIV2XbCUQC6XiwEDBnDmmWdy3XXXceONN/L555/z9ttv06BBA6fjFYpq8fWoFl/P6RhHZc3fmwiH8r9j8fo8bFyzTcWeiEgJYa1NJ3d5hAP3zwCu3edrR95cRsswznbAMmvt39ZaP/ApudOYSozbEdjGi4sHMXD+7QxacD8D59/Gop3znY4V9VKT++A54PpCj4mnZcWL8boSHEol0aR+/fr8+OOPvPXWW/z55580b96c1157jXBYM7dGg5S2DfB43fn2+/1B6jXWBzYiIgcVfUsvRLWjKvaMMVcXUo5awOp9vl6Tt+9AFxpj5hpjRhtjDjrdnDHm+j1Tp27evLmQIkphs9YydOkz/L17KUEbJGD9bA9s442/X2Rzzkan40W15PhjOKfOS1SLb4bb+CjjqUL7KjeQWrm/09EkihhjuO6665g/fz4nnXQSt9xyC127dmX58uVORyv1zu93CnEJPlyu/41kiEvw0r13OypULrvfsWEbIhgOFHdEERFxmDEm2RhzlTHmvryvaxpjakfSxmEVe8aYpgVsKcANR5D7SI0H6ltrWwA/8b/FC/Ox1r5lrU211qZWqVKl2AJKZP7evZRt/vS9CyTvEQqHmLJ5gkOpSo5qCU05v95rXHvsT1zZaDTNKvaKieuypPDVrVuX77//nnfeeYdZs2bRokULXnnlFfXyOahy9fK8MvZ2OnZvTlL5BKrXqUTf+3pw42Pn7z3GH85m/JpXeWbBxTyzoDdvLbuDtZlLnQstIiLFxhjTGVgMXAE8nLe7MTA8knYO95q9acBo4MB3koV10cRaYN+eutr8byIWYO942D3eBp4rpHOLQ3YEtmEK+LwhRIjNOYU1a62IQG4vX79+/TjjjDO4/vrruf322xk9ejTvvvsuxxwTXUuLlBY161Vm4GsHHyAzauXTrMxMI2Rze/U2ZP/NB/8MZMAxr1DRV9ByTyIiEkNeBi6x1k4wxmzL2/dfci9/O2yHO4xzIXCvtbbvvhswJ5KT/Ys/gcbGmAbGGB9wKbnTmO61Z/2KPOflZZISrG5iA4I2mG+/z/g4tmxTBxKJxL7atWvzzTffMHLkSObOnUuLFi14+eWXCYVCTkeTfaTnrGVV5oK9hd4eoXCQ/24Z71AqERHnGVv4W5Sqb63dM9RtT0o/EU6w+a/FnjFmT2OnA9sPvN9a2yOSkx2MtTYI3AL8QG4RN8pam2aMecIYc17eYbcZY9KMMXOA24A+hXFucU7luKqcUOlEfK7/TTTiNh6SvGU5MTm6Z8MUKcmMMfTp04e0tDS6du3KnXfeySmnnMLixYsP6/HBcIiVuzexNSejiJOWXlv963Gb/H/PwwTZlBNb6yeKiEQk+tbZKyoLjDHdD9jXDZgXSSOHqgy/M8ZcYK3dGVG0I2Ct/Rb49oB9j+xz+wHggaLOIcXrirrXUj+xEb9u/omccDatyqdyZo2exLs1o6RIUatVqxbjx4/n//7v/7jtttto1aoVTz75JHfccQdud/6ZIgF+3TiHFxZ9QdAGCYbDtKjQgEeaX0l5r9Z2LExV4urk69UDcBsvtRIaO5BIRESK2d3A18aYb4AEY8ybwLlEuGLBoYZxzgamGmP2riptjDklb1FAkaPmMi46VTmNh5sO5slmL3NRnStJ8pQ99ANFpFAYY7jqqqtYsGABZ5xxBvfccw8nn3wyixYtynfsop2reGbBp2QEM8kK+QnYIHO2/82Ds991IHlsq+CrxrFl2+Mxvn32GjzGS7vkcxzLJSLiqKJYdiFKh3Faa6cBLYA04F1gBdDOWvtnJO38a7Fnrb2X3BlfphpjLjXG/ASMAr46ktAiIhKdatSowVdffcVHH33EkiVLaNWqFUOGDNnvWr5RqybjD+9/nW3Qhli2ax2rM7XMTWG7oM5ddKzci0R3eTzGR+Oktlzb6AXKerXguohIrDPGxAGbrbXPWWtvttYOBjbm7T9shzNByx/ATuAjctfCa2CtfSHixCIiEtWMMVx++eWkpaVx1llncd9999GxY0cWLFgAwIasrdgCPgL1uNxsydlR3HFjntt46FLtcu5p8iEPpozmsvqPkBxX0BK0IiKlSCnp2SN3qbm2B+xrS+4cJ4ftUBO0jAF+Bb4AegHdga6RnEBESoalO3/l0xXXM3LZxfy47il2+Nc5HUkcUr16db788ks++eQTli9fTuvWrRk8eDCtyjXEa/JfyxcIBzkmqWYBLYmIiBSuUjQbZ3Nyl1rY13SgZSSNHKpnbwnQyFr7hLV2LHAmMMwYc3MkJxGR6DZzyydMWP8cW3KWsTu4hSU7J/LZPzewM7DB6Wgxw1qLP7iWYGir01EOizGGSy+9lAULFnDuuefywAMP8MYVjxJenYFnn4Iv3uXj0rpdKOtNdDCtiIhIzNkBVDtgXzVgdySNHOqavf9Ya7fu8/U84GTgukhOIiLRKxDO4s/0Dwja7H32hgmEs5mZ/sl+x27OXsLCHd+yNnM21kbvR2HRJiP7d+avO5G09acyb207lmy8lEBok9OxDkvVqlUZPXo0o0aNYs2q1Uy57m3ixq+hurcCTcrV5T9NL6ZvwwNnhhYRESkipWcY5xfAx8aYZsaYRGNMc+ADcudPOWwRLcoHYK1da4zRImgiMWKbfzUu4873y84SYl3mHACCYT/frn2QDVlpABgMSd4q9KzzMomeisUduUTJCa5k+ea+hG3W3n27cqazdOPlNKnxE8ZE7fo+++nduzddunTh1ltv5bOXP6b1pNa89957tKjWwuloIiIisWgg8AK5QzfjgGxgJPBgJI0czgQt+VhrtZKuSIwo46lc4HpeAOW81QGYkf4B67PmEbTZBG02AZvFdv9aJm4YUpxRS6TNGR8QtsED9gbxh9aQ6Z/tRKQjVqVKFT799FO++OIL1q5dS2pqKo8//jh+v9/paCIiUlqUkp49a222tfZmoAxQHUiy1t5i7X5DsQ7piIo9EYkdZTyVqFumHe791vMCj4mjbfLlACza8R0hu/8bekuI1bv/JBjOKbasJVFO4B+goGLahT9UMifB6dWrFwsWLKB379489thjtGvXjtmzZzsdS0REYlxRTM4SxRO0YIwpD5xA7mQtpxpjuhpjIposU8WeiHBGzQdpkNQRt/HiMXHEu8vRtfo91EzMHaJ3sJ4/iyVMqMD7JFdSfEcMCfn2Wxsg0Vdyh0AmJyfz0Ucf8dVXX7Fx40ZOOOEEHn30UfXyiYiIFAJjTB9gHTAeeGef7e1I2on4mj0RiT1eVwJn1nqEnNAuckK7SPJWyb2OL0/9pJNYsvMnbF5hZ23uqAeP8TJ21b2kVDiH48ufsd9jJFflpIvZlPEWgVCQPT18LpNAhcQexHnqOBsuQoFwFgu3f8GKjIl4XWVoWqEX5513Hp06deKOO+7giSeeYMyYMYwcOZK2bQ9cGkhERKQQ2JJxrXsheAq4yFr73dE0op49Edkrzp1EOV/1fEXbiVWuI9FTEY+JJ3cSThdgCNocNmYvZPLGV/lh7SAnIkc9t6ssx1f/lipJV+B11yDe05haFQZSr9LzTkeLSDCcw9erbmBW+ruk5yxmQ9ZfTN7wJNM3D6NSpUp88MEHjB8/nvT0dNq3b8/AgQPJydEQXyeEbYitOWvYFSgZy3yIiEiBPMCPR9uIij0ROaRETyUub/ABJ1W5idqJbTHsXwwGbTYrd/+XTdlLHEoY3bzuZOpUeoLmtf5L05oTqFL2aowpWb9+/874mYzAuv2u3QzabBbtGMPuQO4yEueccw7z58/nqquu4umnn6Zt27b8+eefTkUulZZnTOf1JVfw/t+38uayPny04h52BVX0iUgMKSUTtADPAg+Zo3zDULLebYiIY7yuBFIqnkvl+MaEOXB2SQjbMOsy5zqQTIrDmt1/HLAWYy4XHjZmz9v7dcWKFRk5ciTffvst27dvp0OHDjzwwANkZ0c0eZgcgS05Kxm75mkyQzsI2GxCNsC6rEV8vnKg1sUUESl57gQeAjKMMav23SJpRNfsiUhEyriTcRtfvtk53S6P1tyLYYmeKhjce6/b3FeCO//3/ayzziItLY27776bwYMHM3bsWEaOHEn79u2LI26p9NfWcfkmU7KE2O7fwMbsZVRPaOxQMhGRwhPNs2cWsisLoxH17IlIRI4tfxqmgF8dLjw0SDrJgURSHI4v3xOXOfDzQYPPnUT1hFYFPqZ8+fK8/fbbfP/992RkZNCxY0fuu+8+srKyCjxejs4O/0Ys4Xz7jXGREUx3IJGISBEoJcM4rbWTDrZF0o6KPRGJSKKnIufWeYZEd0W8JgGPiaespxrn130Bryve6XhSRCrE1adz9UfwuZLwmkQ8Jp7y3rqcVfuVQ15/2L17d9LS0rj22msZMmQIrVu35o8//iim5KVHvTKt8Zi4fPtDNkD1ePXqiYiUJMaYOGPMU8aYv40xO/L2nWGMuSWSdjSMU0QiViuxJX2P+Zz0nBUY46KSrz7GlJqpkEut+mU7UyepI1tzluE1CZT31Tvs73u5cuV48803ueiii7j22ms56aSTuPPOOxk0aBCJiYlFnLx0aFnxTGZu/YrdwdDe62q9Jo7mFbpT1pvscDoRkUIQ5YugF7KXgFrAFcCe5RfS8vYPO9xG1LMnIkfEGBeV4xuRHNdAhV4p4jZeqsQ3oULckRX4p59+OvPnz+eGG27gxRdfpFWrVkydOrUIkpY+ce4yXNNwGG0qnUcFbw2qxTfi9Bq3cFr1AU5HExGRyF0AXG6t/QNyx+hba9eSWwAeNhV7IiJSrMqWLcvw4cOZMGECgUCATp06ceedd5KZmel0tBIv0VOertWv4/rG73JNw2E0q9BNH8aISGwpJdfsAX4OGIVpjKkCRHQRtoo9ERFxRNeuXZk3bx433XQTL7/8Mi1atGDy5MlOxxIRkWhWeoq9z4H3jTENAIwxNcgdvvlpJI2o2BMREcckJSUxbNgwJk6ciLWWzp07c9ttt7F7926no4mIiDjpQWAFMA+oACwF1gGPR9KIij0REXFcly5dmDt3LrfddhuvvvoqzZs3Z+LEiU7HEhGRKGNs4W/RyFrrt9beaa1NAqoBZfO+9h/qsftSsSciIlGhTJkyDB06lMmTJ+N2u+natSs333wzu3btcjqaiIhIsTLGNNyzAWWBBvt8fdhU7ImISFTp1KkTc+bM4c4772T48OE0b96cCRMmOB1LRESkOC0jd+jmsn22pXnbYVOxJyIiUScxMZEXX3yRKVOm4PP56NatGwMGDGDnzp1ORxMRESeVkglarLUua6077/8uoCbwFnBVJO2o2BMRkah10kknMXv2bO655x5GjBhBs2bN+PHHH52OJSIiUqystRuAO4BnInmcij2RUi47lMnETV/w6tL7eOfvQSzaOdPpSCL7SUhIYMiQIUydOpUyZcrQvXt3rrvuOnbs2OF0NBERKU5FMDlLtE7QchDHAYmRPMBz6ENEJFb5w9kMW3o/2wNbCOZN7vTP7kV0rtqTbtUuPujj0nPWkR3KpFp8PTwub3HFdVTYBlm8fRTLd35FyAaol9SNlErX4HUlOR2t1OjQoQOzZs3iscceY8iQIXz//fe89dZbnHXWWU5HExERKVTGmCnsP8g0EUgBnoikHRV7IqXYn+m/sGOfQg8gYHP4ddMYTkw+kzKecvsdv92/mY9WPk16zjpcxg3AuTUH0LLiKcWa2wlT1t/Phqw/CdlsABbt+JQ1uydzVt3/w21KR8EbDeLj4xk8eDC9evWib9++nH322fTt25cXX3yRChUqOB1PRESKWsnqiTsabx/w9W5gjrVWE7SIyOFZlDGTQAHLtXiMh9WZ+/8usdby/orH2Ji9ioD1kxPOIiecxdi1r7M+a0VxRXbE1pzF+xV6AGHrJzO4kdW7fnEwWenVrl07/vrrLx588EE++OADUlJS+Oabb5yOJSIiUiiste8fsI2OtNAD9eyJlGrlvJUwGOwBH5OFsfl69dZmLWNncCuW8H77gzbAtPRvuKD2LUWe1ynp2WkU9FFi0GaxKWs29ct2L/5QQlxcHE899RS9evWiT58+nHPOOVx99dW8/PLLVKxY0el4IiJSFGK4Z88Yc1hDNK21jxxum+rZEynFOiafheeAIYgGF+U8FamdcMx++3cHt2MK+JVhCbMzkF6kOZ2W6KmKwZ1vv9v4SPLWdCCR7Ktt27bMmDGDhx56iI8++oiUlBTGjRvndCwRESlkhpifoKXOYWy1I2lQxZ5IKVYrsSEX1LoBnyueOFcCXuOjalxt+jd8BGPMfsfWTjyWkA3ka8NrfDQu2/awzmetZU3mEhbt/C8Zga2F8hyKQ43EDnhdZfIVuwYPDcqe7VAq2VdcXByDBg1i+vTpVKlShZ49e3LllVeSnh7bH0SIiEhMmWmt7Wut7Qs8tef2AVu/SBrUME6RUq5Npc40r3Ai67P+Id6dSNX4gj8wKuMpz0mVz+f3LeMI2BwAPMZLWW8ybSuedsjz7Ayk88GKh9kZSMcYF0Eb4IRKZ9G9er98hWW0cRkPp9d+i982PMh2/3IMhgR3ZTpWf4IET7LT8WQfbdq04c8//+Tpp5/mqaee4ueff+aNN97g/PPPdzqaiIgUhujqiStsTwHD8m7/BZT7l2MPi4o9kWIQtmGmbP6VXzdPwB/207ZiO86s3oNET0RLpRQZr8tH3TLHHvK4btUvp1ZiI/7Y8g1ZoV00LdeeEyufQ5w74ZCP/WzVM6T71+de85f3i3rm1h+oldCY5hWifzbPJG9NzqzzHlnBdMI2QKKnWtQXqaWVz+fjscce4/zzz6dv375ccMEFXHbZZbzyyitUrlzZ6XgiIiIH87cx5gUgDfAaYwrsxbPWvnu4DarYEykG7654k9nb/8Ifzp358ueN3zNr2wweThmEz+VzOF1kmpRrT5Ny7SN6zHb/ZjZmr8w3uUvA5vDf9PElotjbQz15JUerVq2YPn06zzzzDE8++SQTJkzg9ddf58ILL3Q6moiIHInou8ausF0C3AdcBniBqwo4xgKHXezpmj2RIrYhez2zts3cW+gBBG2QbYFt/Ll1moPJik9OOBOXKfjXTXYos5jTSGni9Xp55JFHmDFjBrVr1+aiiy7ikksuYfPmzU5HExGRI2GLYIsS1tol1tprrbWnA5OstacWsHWNpE0VexJ1dgV3MWvbHJZkLCNsw4d+QJRbsWt5gYWOP5zDop0LHUhU/CrH1S5w4XG38dKk3IkOJJLSpkWLFkybNo2nnnqKMWPG0LRpU0aNGuV0LBERkQJZa/dOiGCMce27RdKOij2JKl+v+47b/rqX4cvfZsiil7h79gNsyN7odKyjUsFXEUP+a7s8xkPluCoOJCp+buOmZ61b8Zq4vTNaekwcZT0V6VjlfGfDSanh9Xp58MEHmTVrFvXr1+eSSy7hoosuYuPGkv07RkSkVInhnr19GWPaGGP+MMbsBgJ5WzDv/4dNxZ5EjbQdCxmzdjwBGyArlEV2OId0/1aGLHoZa6P0X+JhOK5sE8p4knAd8M/NZdx0qtLZoVTF7/hy7bmu0fO0rXQGjZPaclq1K7nxmKEkuJOcjlbkAuFMFm8fw5QNTzB36/tkBUvOshOxKCUlhT/++IPBgwczfvx4UlJS+OSTT0r07xkREYk57wMTgVSgYd7WIO//h00TtEjU+HnjxP2uawOwWHYEdvJP5koalKnvTLCj5DIu7jnuQd5c/iprstbgMoYy7iT6NbyBSr7SNdlH1fi6nFPzRqdjFKus4Fa+Xt0Pf2gnQZuN2/iYv/VDutd+jeT445yOV2p5PB7+85//cO6559KvXz8uv/xyRo0axfDhw6levbrT8URE5CBifIKWfdUDBtqj/CRSxZ5EjV3B3QXudxlDZjCrmNMUruS4ZB5s+hjb/dvwh/1UiauqaftLib/S3yArmI4lBEDI+gnhZ+rGpzmv3vsOp5OmTZsydepUXnrpJR566CGaNm3KK6+8whVXXKF/oyIi0aj0FHtjgDOAH46mEQ3jlKiRWql1gcsQhGyYRkkNHEhU+Cr4KlI1vujWZ8sKZTJ+3WieSLuPZxc9wrT0yRqa5rDVu6bsLfT2td2/An8ow4FEciC3280999zDnDlzOP7447nqqqvo2bMn69atczqaiIiUXvHAGGPMj8aYD/bdImlExZ5EjS5VOlEtrsregs9g8Ll8XFHvEuLd8Q6ni37+sJ9nFz3CTxu/ZkPOOlZm/s2nq9/nk1WHvRSLFAFXAbOQAhjAGA2uiCbHHXccU6ZM4cUXX+Snn34iJSWF999/Xx+YlHDBsJ+FO37h5w2vMTN9DFmhnU5HEpEjVRSTs0Tvr/gFwLPAVGD5Adth0zsNiRpx7jgeazaQ3zb/wcxtsyjnLceJye3ICeewcOcijit77EHXahOYnj6V7YFtBG1w7z5/OIdpW3/jjOrnUjmuqoPpSq9jy5/H/G0fEbI5e/cZPNRIPAGvK8HBZFIQt9vNnXfeyTnnnEO/fv3o06cPo0aN4q233qJWrVpOx5MIZYcy+GjF7ewKphOw2XhMHL9v+ZBL6z1PlfiI5jgQESlW1trHC6MdFXsSVXwuH12rdaZrtc58tXY8Ly0Zhiev9yPBncADTe6mRkLJmTxhxtY/+XHj92QEM2hWrjk9apxLBV+FIjnXwox5+MM5+fa7jZsVu5ep2HNI84pXszk7jY1Zs/cuO1HGU42Tqg10OJn8m8aNGzNp0iSGDRvG/fffT9OmTXnppZfo27evruUrQX7f/CE7AxsJkfshWNDmELQ5fLvuOa5p+IbD6UTkSMTyBC3GmFOstZPzbh908XRr7S+H26aKPYlK83ak8fW67wja4N6equxwNkMWv8wLLZ8pEW+2xq8dy3cbv91bgE3e/Csztv3J4ylPUs5brtDPl+yrjBs3oQKuDyvvrVDo55PD43b5OL3WS2zNWcrWnCUkeWpSLaFVifgZLu1cLhe33XYbZ599Nv3796d///6MGjWKESNGUKdOnSI/fyCcw9KMP9gVTKdWQlNqJhyvn5sILd45ZW+ht6/0nNVkBXeS4Cn838UiIkfhdaBZ3u13DnKMJYLlFzQmTqLShI2/knPAMgwAGYEMVuxe6UCiyGQGM/l2w9f79bSFCJEVyuTnjT8WyTk7VTkNt8u93z6DIclTlmOSji+Sc8rhqxTXmGPK9aB6Ymu9YS9hjjnmGCZOnMirr77KlClTSElJ4e233y7Sa/m25KzkjaVX88O6V5i88T1GrXyQ0aseJmTzFy5ycC7jPuh9RpcFiJRMMXzNnrW22T63Gxxki2gMun7TSVTafZBlGAyGrFD0L8OwJmv13uGn+wraIAt2phXJOavEVeP6hneQ5ClHnCsOr/FSO6EedzQeqGsdRY6Sy+XilltuYd68eaSmpnLdddfRvXt3Vq1aVSTnG7v6KbJCGQRsFmGCBGw2qzPnM2vr10VyvljVrEJ33Gb/WZ4NLmomNCHeneRQKhE5GsYW/hbLNIxTolK7Sqn8vfuffIush7EckxT9F9WX91YgaPMPpwRIjqtcZOdtWq4Fg5sPY2P2enyuuCI9l0hp1LBhQ37++Wfeeust7r33XlJSUnj++ee5/vrrC63Hdrt/AzsCGznw4+agzWHu9h9ITT6/UM5TGrRPvoQ1mXPZkLWEMGHcxk2cK4mza93ndDQRkWKhj/slKnWuejI14qsTl7cMgwsXPpePq+tfTpw7zuF0h1Ytvhr1ytTDfcAQIp/LR/dqZxbpuV3GRY2EWir0RIqIy+ViwIABzJs3j/bt2zNgwABOP/10/vnnn0Jp3xImd3GO/MIH+RBJCuZx+bi47nP0rjeYzlWvpUfN+7numPcp59WEVSIlVgwP4ywKKvYkKvlcPh5JeYCr619Omwqt6FzlZB5uej+nVDnJ6WiH7ZZjbufYpOPxGA9xrjgS3WW4pl4/GiY1cjqaiBSC+vXr89NPP/Hmm28yffp0mjVrxvDhwwmHw0fVbgVvDcp4Kubb7zE+UsqfdlRtl0bGGGomNKFNpZ40KtvhX6/jExGJNSbWF4tNTU21M2bMcDqGlGI7AjvIDO6many1fD19IhIbVq1axXXXXcePP/5Ily5deOedd2jY8MiHnK/PWsxnKx8kbEMEbQ5eE0/luHpcWv9ZvK7oH90gIiWDMWamtTbV6RyHK6FaHXvMFXcVervzX7qrRL0OkVDPnkgRK+8tT42Emir0RGJY3bp1+f7773n77bf566+/aN68OcOGDTviXr4aCcdxQ+P36FKtP+2TL+a82g9wRYMXVOiJSKlmimiLZVFT7BljzjTGLDbGLDPG3F/A/XHGmM/y7v+vMaa+AzFFREQKZIyhf//+zJ8/n1NOOYVbb72VU089lWXLlh1RewnusrSpdC6dq/WlUdl2Gn4oIiIRi4pizxjjBl4DzgKaApcZY5oecFh/YJu19hjgJeDZ4k0pRWFzTjpzt6exOSfd6SgiIoWiTp06fPvtt4wcOZI5c+bQokULhg4detTX8omICJqgJUJRUewB7YBl1tq/rbV+4FOg5wHH9ATez7s9GjjNaGXiEisQDvDykuHcO+dhXln2JvfOeZiXlwwnEA44HU1E5KgZY+jTpw9paWl07dqVO+64g1NOOYUlS5Y4HU1EREqRaCn2agGr9/l6Td6+Ao+x1gaBHUByQY0ZY643xswwxszYvHlzEcSVo/X56q+YvX0eARsgK5RFwAaYvX0eo1aPcTpazPKH/fy88QeeWfgELy1+jlnbZlIUEzSFbbhI2hUpiWrVqsX48eP54IMPSEtLo2XLlrzwwguEQlpCQUTkSGhR9chES7FXqKy1b1lrU621qVWqVHE6jhTgl02TCdj9e/ECNsDETVMcShTbAuEAzy58kjFrRrNi93IWZqTxzoo3+XzNp4V2jo3Z6xm65GlunXUNt8/uy/v/vEFWKLPQ2pfi5w/tIiu41ekYJZ4xhquuuooFCxZwxhlncM8993DyySezaNEip6OJiJQ8GsYZkWgp9tYCdfb5unbevgKPMcZ4gPKALvQqoXLCOQXuzz7Ifjk6M7dNZ1POBgLWv3efP5zDpE0T2OpPZ1P2Rn7a8D0/bfieLTmR94bvDu5iyOLHWLJrIRZL0AaZuW0aQ5c+o16+EigrmM6Pa27ns797MHrFBXz1z2VsyV7gdKwSr0aNGnz11Vd89NFHLFmyhFatWjFkyBD18omISJGJlmLvT6CxMaaBMcYHXAqMO+CYccA1ebcvAn6xehdZYh1zkIXFG2vB8SIxb/vcAgtsl3Hz5ZrPeTxtIGPWfs6YtZ/z6PwHmLjx54ja/z19EoFwALvPx2NBG2RD9jr+yVx+1Pml+Fgb5vs1N7Mh6y/CBAgTYEdgJT+suZXMoIbFHy1jDJdffjlpaWmcffbZ3HfffXTs2JEFC1RMi4gcFvXsRSQqir28a/BuAX4AFgKjrLVpxpgnjDHn5R32DpBsjFkG3AXkW55BSo4+9S8n3hWPm9ypxN24iXfFcU39yxxOVvRyQjn8uXUGv26azOYj6EU7EuW9FXAV8M/d2jB/bfuTgA0QtEGCNkjABhi95lPSI5ghdW3Wqv16Dfe1IXvdEeeW4rcxaw6ZwS1Y9u9tCtsQS3aMdyhV7KlevTpffPEFn376KcuXL6d169Y888wzBINBp6OJiEgM8TgdYA9r7bfAtwfse2Sf29lA7+LOJUWjXpk6DG7xGN+t/4l/MldRP7EuZ9XoRpW4yk5HK1LLd/3NkMUvYq0lTO5EJqdXO42L61xEUU4u26lKZyZt/oXwAQWZMS5suOAhZLO3z+S0amccVvt1Euozy/xZYMFXI/7AuZYkmu0KrqegjznD+NnpX1X8gWKYMYZLLrmEU089lZtvvpkHH3yQL7/8kpEjR9KsWTOn44mIRJ9SMKFKYYuKnj0pnarEJXN1/Ut5pOl9XF3/0pgv9EI2xItLhpIVyiI7nI0/7CdgA0zYNJG0nUU7hKtGQk36NbieeFcC8a4EfK44qsRV5eTKnQs8PndUw+H/Nj0x+RTi3HEY/leweoyH2gn1qJfY8GjjSzFKjjseS/714DwmnmoJLR1IFPuqVq3K559/zqhRo1i5ciVt2rThySefJBDQUjQiInJ0oqZnTyTWLclYSjCcf4hWTjiHXzdNpln5lCI9f9tKJ9CyQmtWZv5DnMtHrYQ6bMzZwOTNvxCy+/fuGaBVhTaH3XZ2OJtL6lzD71smsXTXQtzGQ/tKJ3N+rUuLtMdSCl/FuIbUTGzHuszphGzudZ4uPMS5y9OwXHeH08W23r1706VLF2699VYefvhhvvzyS9577z1atGjhdDQRkeihnr2IqNgTKSaBcICDlT3+YpqF1OPy0CjpmL1fV4+vwTk1e/L1urGEbRgMuHDRq/bFVI479LIl/nAOb//9Ggt3zsdjPARskFOqdKN37StU5JVgXWo8Rdq2T1iy4yuCNoe6ZTrTOvlavK5Ep6PFvCpVqvDpp59y8cUXc+ONN9K2bVseeughHnjgAXw+n9PxREQcp2GckVGxJ1JMjit7LOECPo6Kc8VxYuUTHUiU66wa59Km4gnM2jYTgDYVU6kaX+2wHvvxyvdYsHM+QRvYu27ib1smUjWuGl2qnl5kmaVouYyH5pWuonmlq5yOUmr16tWLU045hdtvv53HHnuMMWPG8N5779GqVSuno4mISAmia/ZEikmcO47+Dfrgc/n2zkIa54rj2LLH0K5SarHn2Xflkmrx1TmzRg/OrNHjsAu9QDjAjG3TCNr9ryvyh/38vPG7Qs0qUhpVrlyZjz76iK+++oqNGzdywgkn8Oijj+L3FzzzrYhIqaClFyKinj2RYtQ+uR31y9Rjyuap7A7tplWFljQv3wyXKb7PXaal/86Xa0ez1b+VCt6KnF+rFydX7hRxO/5wzkEncckM7T7amCKSp2fPnnTq1Ik77riDJ554Ym8vX5s2h39drYiIlE7q2RMpZtXiq3FRnV5cU/8qWlZoUayF3vT0aXyw8j22+rcCsD2wjY9XfchvmydH3FaiuwwVvBXz7TcYGic1OeqsIvI/lSpV4oMPPmD8+PFs2bKFdu3a8dBDD5GTUzzX+4qIRAtjC3+LZSr2REoway2/bf6N++fez01/3cTzi59nVebB10L7cu0X+MP7DwHzh/18te7LiM9tjOGKev3wuXx7l1xw4ybeHU+v2pdE3J6IHNo555xDWloaV111FU899RRt27ZlxowZTscSESkeRTGEU8WeiESrr9d/zYerPmRjzkayQlmk7Uzj6YVPszZrbYHHb/WnF7h/e2B77mycEWparjn3HfcIqZU6UDexPp2qdOXhpk9TLb5GxG2JyOGpWLEiI0eO5JtvvmH79u106NCBBx54gOzsbKejiYhIlNE1eyIllD/s55v13xTYUzd27VhuOuamfI+pHFeZTTmb8u2v6K14xMNJayfWo3+D/OcSKQxZwW38lT6Slbt/w2sSSKlwIU0qnI8pxuHP0erss89m/vz53H333QwePJixY8cycuRI2rdv73Q0EZGiE+M9cYVNfy1FSqj0nPS9wyf3ZbGs2L2iwMf0qtUbn2v/tbp8Lh8X1LqoSDKKHA1/aBdjVvZn8Y7xZAY3syOwiulbhjN542Cno0WNChUq8M477/Ddd9+RkZFBx44d+c9//qNePhERAVTsiZRY5b3lCdpggfdVO8jyCamVTqBf/WupGlcVg6GyrzJX1+tLx8onFWVUkSOyeMfX5IR3EuZ/P+dBm83fGRPICKx3MFn0OfPMM5k/fz79+/fnueeeo3Xr1vzxxx9OxxIRKVQGTdASKRV7IiVUoieRjskdC+ypO7fmuQd9XGqldjzd/DlGpI5kcIvn6ZDs3ILuIv9mfdZsQjb/bJMuPGzJXuxAouhWvnx53nrrLX788UcyMzM56aSTuOeee8jKynI6mohI4dEELRFRsSdSgl1V7ypOqXxK7kLtxk1Fb0Wua3Adx5U9zuloQu5sqTmhLEI25HSUQrXNv4Zpm99nysY3WZs5F2uL5i9lOW8tTAGXllssZTxVi+ScseD0009n/vz53HDDDbzwwgu0bNmS3377zelYIiLiAE3QIlKCeVwerqh3BZfUuYSccA6J7kSMyX8dnxS/pRlz+XLNCLb5N+EyblIrncp5NfvgcXmdjnZU0rZ/z68bXyFsQ4QJM2/7eBqWPYnuNe4v9J+9phV6sWjHuP2GKxvclPXWoEq81nL8N2XLlmX48OH07t2b/v37c8opp3D77bfz1FNPkZiY6HQ8EZEjZoroA8YjZYypBHwG1Af+AS621m474JhWwHCgHBACnrLWflYc+dSzJ1JCBcNB/ps+nTeWvcVnqz9nm397TBR61tpC7yna6t/Cb5t/Zlr6JHYHdxVq2wVZm7mC91Y8S7p/A2HCBG2AGVsn8tnqYUV+7qKUHcpg4sZXCFo/YUKAJWCz+TtjKqt2F/5ab+V8tTij1rOU8VTDbXy48FIjoRVn1X4pJn7Wi0PXrl2ZN28eN910Ey+//DItWrRg8uTJTscSEYkl9wMTrLWNgQl5Xx8oE7jaWpsCnAm8bIypUBzh1LMnUgIFw0GeWfQcqzPXkBPOwYWLXzdNok+Dazipcsm8Bm991jo+Wvk+S3ctxmM8dEjuSO86lxPvjj+qdn/aMI5v13+JwWCMYdSq9+jT4GZaVEgtpOT5Tdw0hqAN7LcvaAOk7fiTjMA2ynorFtm5i9Kq3TNxGQ8hu/9yHwGbzaKdv1Av6YRCP2fNxDZc2uBzdgc34XElEO8uV+jniHVJSUkMGzaMiy66iH79+tG5c2duueUWnnnmGZKSkpyOJyJy+KLzGrueQJe82+8DvwL/2fcAa+2SfW6vM8ZsAqoA24s6nHr2REqg37ZMZVXmanLCuZNXhAnjtwHe/+dDckL5J7SIdjsDOxm8aBBLdi3CYgnYAH+k/86rS188qnbXZP7Dd+tzC6+A9eMP5xCwft5b8RpZocxCSp/fppy12AL+GnmMl22BLUV23oLkhDL5M/1bvln7OjPTf8AfOvLJOlzmYJ8PGjzGd5D7jp4xhiRvNRV6R6lLly7MmzePW2+9lWHDhtGiRQsmTpzodCwRkYgU0WyclY0xM/bZro8gUjVr7Z4pojcABU+Jvie/Me0AH7D8SJ5/pFTsiZRA09Kn51tMHcBlXCzbVSy/OwrV5M0TCYbz94StzFzB6syVR9zu9K1T8/WwQe7rNH/HrCNu91DqJjbGFPDrNWgDVPbVKLLzHmhrznpeXXI9P28Yycxt3/PjhncYtnQAO4+w4KxXJhUKGGLrMT6alD/jaONKMShTpgyvvPIKkyZNwu1207VrV26++WZ27Sr64c0iIlFsi7U2dZ/trX3vNMb8bIyZX8DWc9/jbO51KAftezTG1AA+BPpaa8NF8kwOoGJPpARKcCcUuN9aS5w7rpjTHL3VmSsJFFSU4WJ99pGvpxaywQJ72CyW0EHWKCwMp1Y9P9+SGF4TR4fkM0j0FN+wuW/XvU5WKINA3vIFAZvN7uAOflj/9hG153XF06P2o3hMHF6TgMfE4TY+2lTqTc3ElMKMLkXslFNOYc6cOdx5550MHz6c5s2bM2HCBKdjyf+3d+fxUVV33Mc/v0kmE/YtAWQRRFRMQliMqCC44AJaEQVxqQsipYpL3apgUbG4IYK1izxoFXHHUlB5irWCYK2ikCKBBBERkFXKvoZsc54/En1AAmZgJndy832/XufFzJ2buV/mzJ3kN+fec0Xk53lw6QXn3HnOuYxy2rvAxrIi7odi7n/lPYeZ1QX+AfzOOff5kf3nI6diT6QKOrfx2QcVEwA1EpJpU+s4DxIdnVY1WxO0g2epDBOmWXKzI37eTg1OIylwcPEbdmHS6nY84uf9OY1CTRna9lFOrN2BpEAy9YMp9D7man7R7PqYbfOnnAuzcs/ig4pdR5hvds0/4udtVSuLwW0nc07T2+ne+Ndcd9yLnJE68CjTihdq1qzJuHHj+OSTTwgGg5x33nncfPPN7Ny50+toIiJVyXvADWW3bwDe/ekKZpYETANecc5NqcRsKvZEqqL29TPo1eQCghYkORAiOZBMncQ63H3SnQSs6u3W3VPPJhgIYvz/GRYTLchxtY6nRc1jj/h5j691Eqc26PZjwRcggaAlcVmLX1I3WO+ocx/OMTVaMfj4ETza/lUeSBvPmakXV3LfGHaI7R363LuKCSXU5uR6F5DZoA/1KvGwVImNbt26kZOTw7333ssLL7xA+/bt+fDDD72OJSJSrhids3c0ngTON7NvgPPK7mNmWWb2w6E0A4AewEAzW1jWOh71livAYnUx3HiRlZXlsrOjPyW4SDzYWriNr3d+Tc3EWqTXPZnEQHxMsLt893LmbZmHmXF6o9M5rgKjjRv3fc9bq19j6a4lJFqQrilncnnzAUd9WKpzjlV7lrNw+3ySAkmc0rArTY9itLAq+fvqMXy1cy5h/v8hqwmWSMf6Pbm4+a0eJpN49fnnn3PjjTeydOlSfvWrXzFmzBjq1YvtFyMi4h0z+69zLnbTU0dZrZSWLv0Xd0X9eedPuqdKvQ6RULEncgjf7l7JW6v/zqq9q2mQVJ/Lml/CGY2iP7W837y5+k3mbJpDUdmEK8FAkF5NenFZi8s8Tlb97C3eyaSVD7Cj6H+EXZiABWiU1Jzrj3uMUIIurC3l27dvHyNHjmTMmDE0a9aMF154gV69enkdS0RioEoWexfHoNh7xb/FXnwMA4jEmZV7vuPRr57+ccbLvfn5PL/iZXYW7eTCpj0P+7OF4UJmbpzDp5u/ICmQRM8mZ9G1UZcqeXhlpFbvXc2cTXMOmCm0MFzI+9+/zxkpZ9A0uamH6aqfmol1ubntH1m1ZzFbCtaRmnwsx9ZM1wXJ5bCSk5N58sknufzyyxk4cCC9e/dm0KBBjB07lvr163sdT0Sqs+gcdlmt+P+vT5Ej8PaaaQdd2qAwXMiUte9SHD70LI7F4WJGLXmKv619h1V7V7Ns93JeWvkqz6+YFOvIceHLbV/+OKK3P4cjZ3uOB4nELMBxtTuQ1egiWtXKUKEnFdalSxcWLFjA8OHDefnll8nIyGDGjBlexxIRkQio2BMpx6o9q8tdXuxK2Fm865A/999tOazL/57C/QqegnAhX2ydz/r8I7+EQFWRGEgsdwQzQIBg4ODZNqsS5xxzN8/hia+G8VDub3h7zcvsKtrhdSyRmEpOTubxxx/niy++oEGDBlx88cUMHDiQbdu2eR1NRKorDy69UJWp2BMpR0qo0SEfq51Y65CP5e5YQkG44OAHnLF01zfRiBbXujTsQqCcjxWH45QGp3iQKHqmrHmFKWtfYX3+GrYVbuazTR8xeunv2Fu8x+toIjGXlZVFdnY2I0aM4LXXXiM9PZ3p06d7HUtERH6Gij2RcvRr0eeg69glBZLo2bhHude3+0GDpPokljOtfcAC1AvWjXrOeJMaSuXaVtcStCChQIhQIETQgtx03E3Ui/GlDmJpR+E2Ptsym8L9CvkSSthbvIdPN+tC1FI9hEIhRo0axbx580hNTaVPnz5cd911bN261etoIlJNGHF56YW4pmJPpBwd67fnptbXUS9Yl0RLJBRI4oIm53D1sf0P+3NnpXYr9zDGpECQDvUyYhU3rvRI7cHTHZ7m2lbXcl2r6xjXcRynNTrN61hHZU3+ynKL+CJXyNe78mK+/Z1F25m75UM+3fwB2wu3xHx7IofTuXNn5s+fz8MPP8xbb71FWloa77zzjtexRKS6cC76zcc0G6fIIZyZejpdU7qwp3gvNRKSK3QNu0ahhtx94q38ZfkLFIWLcDjqB+tz94m3xs018CpD3WBdzkw50+sYUVM/2JAw4YOWBwiQEmoS023P3/oxf1/7wo8XnJ++/lUuPuaXdE/tHdPtihxOUlISI0eOpG/fvtx4441cdtllXH311fzxj38kJSXF63giIlKm+vz1KXIEAhagTrB2RD/Tvl4az3Uey+q9awkGgjRLbqoZEKu45jVa0Th0DOvz1xCm5MflCZbI2akXxmy7O4q28ve1L1DsDpzh9B8bXqdd3Y6kho6J2bZFKqJjx47MmzePJ598klGjRjFr1iyee+45+vXr53U0EfEpvx92GW06jFMkBgIWoHWtY2le4xgVej5gZgxtex9ta7cj0RJJCiRRN7E+N7X5DU1rNI/ZdnN3zP9xRG9/zoVZtP3zmG1XJBLBYJAHH3yQ7OxsWrRoQf/+/bnyyivZtGmT19FERKo9jeyJiFRAnWA9bj/xAXYV7aQgvI+GSSnlnp8ZTWEXxpUzJ3QYR4krKecnRLyTmZnJ559/zpgxYxg5ciQfffQRzz33HFdccYXX0UTEL6rBpRKiTSN7IiIRqBOsS0qoccwLPYD0euVfriLREmlfr0vMty8SqWAwyAMPPMCCBQto3bo1AwYMoH///mzcuNHraCLiExaOfvMzFXviS4XhIhZtzyVney6F4UKv44gckYZJjbmw6QCClkSAAEaAoCXRPfUijqlxrNfxRA4pIyODuXPn8sQTTzB9+nTS09N56623cD6f9U5EJN7oME7xnUXbc/nj8gk/3nfOcVvbIXRqkOlhKpEjc07jPpxctzM52+cSdmEy659G8xqtvY4l8rMSExMZNmwYffr0YdCgQVx99dVMnjyZ8ePH07RpU6/jiUhVpe+MIqKRPfGVXUW7eOab8eSX7Pux7QsX8MflE9hRtNPreCJHpGlyCy5segW9j7lShZ5UOWlpaXz66aeMGTOG999/n/T0dF5//XWN8omIVAIVe+IrX2z9b7nLnXPM3TI/6tsrDBcyec1Uhi64h19n38kLKyaxs2hX1LcjIlKVJSQkcO+997Jw4UJOOukkrr32Wi699FLWr1/vdTQRqWLMRb/5mYo98ZX8kn2UhA+epbDYFZNfkh/VbTnnGL30D7y/YSY7inayu2QPn2yay4O5j+k8QRGRcrRr145PPvmEsWPH8uGHH5Kens4rr7yiUT4RkRhRsSe+0r5eGgmBhIOWBwNBMuulR3Vby3evYOWe1RTtd8HrEkrYVbybz7dkR3VbIiJ+kZCQwN13301OTg4ZGRnccMMN/OIXv2DdunVeRxOReOcA56LffEzFnvhK61rH0rVRF0KB0I/LQoEQXRp0pk2t1lHd1nd71+A4eL7egnAB3+5eGdVtiYj4zYknnsjHH3/Ms88+y+zZs0lPT2fixIka5RORw9JhnJFRsSe+M/i467m97RC6NDiFUxt05ta2g7n5+EGYWVS30ziUQoCDRxGTAkk0TW4S1W2JiPhRIBDgjjvuYNGiRXTo0IFBgwZx0UUXsWbNGq+jiYj4gi69IL5jZnRqkBnzSy1k1EujbrAOhQWFhPcb4Uu0RHqknhHTbYuI+Enbtm2ZPXs2zz33HPfffz8ZGRmMGzeOQYOi/0WdiFRxPh+JizaN7IkcoYAFeCjtPjLqnUyCJZBgCbSp1ZqH0+6jVmItr+OJiFQpgUCA2267jcWLF9O5c2cGDx5Mr169WL16tdfRRESqLI3siRyFBkn1ub/dnRSUFBDGUSMh2etIIiJVWps2bZg1axYTJkzgt7/9LRkZGYwZM4YhQ4ZolE+kmjP8f45dtGlkTyQKQgkhFXoiIlESCAS45ZZbyM3N5dRTT+Xmm2/m/PPPZ9WqVV5HExEvxWImTp9PCqViT0REROJS69atmTlzJhMmTOCLL74gIyOD8ePHEw4fPBOyiIgcTMWeVBtF4SKKw8VexxARkQiYGUOGDCE3N5euXbsydOhQevbsyYoVK7yOJiIe0KUXIqNiT3xvff73jMx7ioHzbmfg/NsZ9/V4dhbt8jqWiIhEoFWrVnzwwQf89a9/ZcGCBbRv354//elPGuUTETkMFXvia7uL9/BQ7miW7fqWMGFKXAkLti3i90ueJuz0B4KISFViZtx0003k5ubSo0cP7rjjDs455xyWL1/udTQRqSwuBs3HVOyJr/1701yKXBFuvz25hBK2FGxlyc5lHiYTEZEj1bJlS2bMmMHEiRPJyckhMzOTZ599VqN8ItWADuOMjIo98bW1+espDBcetDzsHN/v2+hBIhERiQYzY+DAgeTl5XHuuedy55130qNHD5Yt0xd5IiI/ULEnvnZ8rdaEAkkHLTeDY2u28CCRiIhEU/PmzZk+fTqTJk0iLy+PDh06MHbsWEpKSryOJiLR5oCwi37zMRV74mvdUk6jZkINAvu91YOWSKuaLTmhdhsPk4mISLSYGddffz15eXlccMEF3HvvvZx55pksXbrU62giIp5SsSe+lpwQ4tH2v+P0RlkkB0LUSqjJeU3OYvjJd2JmXscTEZEoatasGe+88w6vv/46y5Yto2PHjowZM0ajfCJ+oglaIpLodQAzawhMBloDq4ABzrlt5axXAiwuu7vaOdensjJK1dYwqT63nzDY6xhxbUfRTtbsXUdqqBFNkht7HUdE5IiZGddccw3nnnsut9xyC/fddx9Tpkxh4sSJpKWleR1PRKRSxcPI3jBglnPuBGBW2f3y5DvnOpY1FXoiURB2YV5e+Tq/+fJ+nv1mPMMWjeSJr8aRX7LP62giIkeladOmTJ06lTfffJNvv/2WTp068eSTT1JcXOx1NBE5CpqNMzLxUOxdCkwquz0J6OtdFJHq5cONs/l482cUuWL2luRT6IpYuusbXlzxitfRRESOmplx1VVXkZeXxyWXXMLw4cM544wzyM3N9TqaiBwp56LffCweir0mzrkNZbe/B5ocYr1kM8s2s8/NrO/hntDMhpStm71p06ZoZhXxlX9+P+ugS1MUu2Lmb/uSgpICj1KJiERXkyZNmDJlCm+//TarVq3ilFNO4bHHHqOoqMjraCIiMVUpxZ6ZzTSz3HLapfuv55w73GmSrZxzWcA1wB/M7PhDbc8597xzLss5l5Wamhq9/4iIz+wt2XvIx8q7PqFEX3G4mP9uy+bdddP4fMtnFOl1F4mZK664giVLltC3b19GjBjB6aefzqJFi7yOJSIR0GGckamUCVqcc+cd6jEz22hmxzjnNpjZMcD/DvEc68r+XWFmc4BOwLexyCtSXaTXbce8rQtwP/mOpUGwPrUTa3uUqnJ9suk/vLt+OtsLd9C8RjOuOnYAJ9dtVynb3l28mye+GsWOoh3sC+8jFAjxt7WTeaDdgzQKpVRKBpHqJjU1lcmTJzNgwACGDh1KVlYWDz74IMOGDSMYDHodT0QkquLhMM73gBvKbt8AvPvTFcysgZmFym6nAN2AJZWWUMSnrmrZj5oJNUi00u99AgRICiQxuM111eLSFP/6fiavfPc6mwo2U+SKWLX3O8Yte5avdy2rlO1PWTuZzYWb2RcunRCnIFzArqJdvLzqpUrZvkh11q9fP/Ly8ujfvz8PPfQQXbp0YeHChV7HEpHDicVlF3w+shcPxd6TwPlm9g1wXtl9zCzLzP5ats7JQLaZ5QCzgSedcyr2RI5S4+RURmc+Qq+mPTmh9vF0TzmDUekPkFHP/9OTl7gSpq1796DDVQvDhUxZM7VSMvx3WzYl7sDrf4UJ8/WupRSHNWOgSKylpKTwxhtvMG3aNDZs2MCpp57KyJEjKSzU4dQi8cgAcy7qzc88v86ec24L0LOc5dnA4LLbnwHtKzmaSLXQIKk+Vx/b3+sYlW5P8R6KwuVPzrA2f10lpxERL/Xt25cePXrwm9/8hkceeYRp06YxceJEOnfu7HU0EZGjEg8jeyIila5mQk0SrPyPwMahypnY6dQGXUiwhAOWGUZa3XQSA55/FydSrTRs2JBXX32V9957j02bNtGlSxcefPBBCgo0M7FIXAnHoPmYij0RqZYSA4n0bnohSYGkA5YnBZK4vEXfSsnQv8UAmoSaEAokYxihQDL1gw24vvWNlbJ9ETnYJZdcQl5eHtdeey2PPvoop5xyCtnZ2V7HEhE5IvrqWESqrUub9yEhkMiMDe+TX7Kv9JDWllfSoX5mpWy/ZmItRqY/Su6ORazNX0vjUGM61u+sUT0RjzVo0ICXX36ZK664giFDhnD66afz29/+locffpjk5GSv44lUa34/xy7azPn8BcvKynL6Rk5EDsc5R7ErJtESq8UspCJScdu3b+eee+7hpZde4uSTT2bixImcdtppXscSiQoz+2/ZdayrhLp1WrhTs26N+vN+NOeBKvU6REKHcYpItWdmBANBFXoicpD69evz4osv8v7777Nr1y66du3K/fffz759+7yOJiLys1TsiYiIiPyMXr16kZuby0033cRTTz1Fp06dmDt3rtexRKoZBy4GzcdU7ImIiIhUQL169Xj++ef54IMP2Lt3L926dePee+8lPz/f62giIuVSsSciIiISgQsuuIDFixfz61//mrFjx9KxY0c+/fRTr2OJVAvmot/8TMWeiEiMFYeLWZ+/nl1Fu7yOIiJRUrduXcaPH8/MmTMpLCyke/fu3HXXXezdu9fraCIiP9L83iIiMTRr42zeXjMFcBS7EjrUz2RIm5tITtD07SJ+0LNnTxYvXsywYcP4wx/+wPTp03nppZfo0aOH19FE/Mnn59hFm0b2RERiJGf7Yt5a8zb7wvvYFy6g2BWzaPtinl/xotfRRCSKateuzZ///Gdmz55NOBzmrLPO4o477mDPnj1eRxPxFwcWjn7zMxV7IiIx8o8NMygMFx6wrMgVkbN9kQ7pFPGhs88+m8WLF3PHHXfwpz/9iczMTObMmeN1LBGpxlTsiYjEyNbCbeUuT7QEdhWr2BPxo1q1avHss8/y73//m0AgwDnnnMOtt97K7t27vY4m4g+69EJEVOyJxIG9xXv5x/oPeWbZ/+Fva949ZJEgVUu7OicSKPdj1kgNpVZ6HhGpPN27dycnJ4e77rqL8ePH0759ez766COvY4lINaNiT8RjWwu3cXfOQ7y99h3mbV3Ae+s/4J6FD/Ht7lVeR5OjdGnzPiQnhA4o+JICSQxo2Y9gIOhhMhGpDDVr1mTcuHF88sknBINBevbsyS233MKuXRrZFzliLgbNx1TsiXjszdXT2FW0m8JwEQDFrph94QKeX/GKx8nkaKWGUvh9xkjOTOlKaiiFk+qcyG1th9KzybleR4u6wnAhX+/8ipW7vyXsfH62u0iEunXrRk5ODvfccw8TJkwgIyODmTNneh1LpEoy56Le/EyXXhDx2JfbFhHm4D+O1+WvZ2/xXmom1vQglURLaiiFm9rc6HWMmJq3ZS6vfjcRI4DDUTOhJrefcDctarb0OppI3KhRowZPP/00/fr148Ybb+T888/nV7/6FWPGjKFevXpexxMRn9LInojHkgJJh3jESAzo+xiJbxvy1zNp1UsUhAvYF86nILyPbUVbeWbZaIrDxV7HE4k7Z5xxBl9++SX33XcfL774IhkZGfzzn//0OpZI1aEJWiKiYk/EYz2bdCfJDjx/K8ES6FS//WEKQZH48MmmjylxBxd1ReEilu5a4kEikfhXo0YNRo8ezWeffUadOnXo3bs3gwYNYvv27V5HExGfUbEn4rFLm/Wmff00kgJBkgMhQoEQLWs0Y0ib672OJvKzdhbvKPcwZAfsKdZU8yKHc9ppp7FgwQKGDx/OK6+8QkZGBjNmzPA6lkj8ckA4Bs3HdIyYiMcSA4nce9KtrMvfwHd71tA4lMLxtY/DzLyOJvKzMut3JGf7AgrCBQcsL3ElnFinnUepRKqO5ORkHn/8cS6//HJuvPFGLr74Ym644QaeeeYZGjRo4HU8kbhi+H9ClWjTyJ5InGhe4xi6pnShbZ02KvSkyuhcP4vmNVoccMhxUiBEzyYX0CCpoYfJRKqWrKwssrOzGTFiBK+99hrp6elMnz7d61giUsWp2BMRkSOWGEjknpOGc0WLazixdjsy63Xi121upV+LAV5HE6lyQqEQo0aNYt68eaSmptKnTx+uu+46tm7d6nU0kfihCVoiosM4RUTkqAQDQc5qfA5nNT7H6ygivtC5c2fmz5/P448/zmOPPcbMmTMZP348ffv29TqaiFQxGtkTERERiTNJSUmMHDmS+fPn06RJEy677DKuueYaNm/e7HU0EW9pZC8iKvZERERE4lTHjh2ZP38+jzzyCFOmTCE9PZ2pU6d6HUtEqggVeyIiIiJxLBgM8tBDD5GdnU2LFi3o168fV155JZs2bfI6mkjl0qUXIqZiT0RERKQKyMzM5PPPP+fRRx9l2rRppKWl8be//c3rWCKVypyLevMzFXsiIiIiVUQwGOR3v/sdCxYsoHXr1gwYMID+/fuzceNGr6OJSBxSsSciIiJSxWRkZDB37lyeeOIJpk+fTnp6Om+++SbO56MUIpqgJTIq9iQiJa6E7K0LeXvNu8z536fsKynwOpKIiEi1lJiYyLBhw/jyyy85/vjjueaaa7j88sv5/vvvvY4mInFCxZ5U2N7ifIYvGsVflr/ItHX/4OVVb3HHl8NZn69fKiIiIl5JS0vj008/ZfTo0bz//vukpaXx+uuva5RPfCgGo3o+309U7EmF/X3tdDbs+x/7wqWjeQXhAnYX72H88okeJxMREaneEhMTue+++1i4cCEnnXQS1157LX379mXDhg1eRxOJHoeKvQip2JMK+3TLPIpd8QHLHI6Ve1ezp3ivR6lERETkB+3ateM///kPY8eO5V//+hdpaWm8+uqrGuUTqaZU7EmFGXaYx0RERCQeJCQkcPfdd5OTk0N6ejrXX389l1xyCevWrfM6msjR03X2IqJiTyqse8rpBC3xgGWGcXyt1tRMrOlRKhERESnPiSeeyMcff8wzzzzDRx99RHp6OhMnTtQon0g1omJPKuzyFr+gZc3mJAdCBAiQHAhRN1iHoW0HeR1NREREypGQkMCdd97JokWLyMzMZNCgQVx00UWsWbPG62giR0QXVY9M4s+vIlIqOSHEqIzh5O5Yyqo9q0kNNSKrYUeCgaDX0UREROQw2rZty5w5c3juuee4//77ycjIYNy4cQwaNAgznYwhVYjPi7No08ieRCRgATLrp9GneS/OSDlVhZ6IiEgVEQgEuO2221i8eDGdO3dm8ODBXHjhhaxevdrraCISIyr2RERERKqRNm3aMGvWLP7yl7/w2WefkZ6ezoQJE3Qun8Q/B4Rd9JuPqdgTERERqWYCgQBDhw5l8eLFdOnShZtvvpnzzz+fVatWeR1NRKJIxZ6IiIhINXXccccxc+ZMJkyYwBdffEFGRgbjx48nHPb5fPRSRcXgguo+H9FWsSciIiJSjZkZQ4YMITc3l65duzJ06FB69uzJihUrvI4mEvfMrKGZfWhm35T926CcdVqZ2QIzW2hmeWZ2c2XlU7EnIiIiIrRq1YoPPviAF154gQULFtC+fXv+/Oc/a5RP4kv8jewNA2Y5504AZpXd/6kNwBnOuY7AacAwM2t2tBuuCBV7IiIiIgKUjvINHjyY3NxcevTowe23384555zD8uXLvY4mUir+ir1LgUlltycBfQ+O7AqdcwVld0NUYg2mYk9EREREDtCyZUtmzJjBxIkTycnJITMzk2effVajfOJXKWaWvV8bEsHPNnHObSi7/T3QpLyVzKylmS0C1gCjnXPrjzJzhajYExEREZGDmBkDBw4kLy+Pc889lzvvvJMePXqwbNkyr6NJdRW7Sy9sds5l7dee33+zZjbTzHLLaZceEK/0+iXlDhU659Y45zKBtsANZlZuURhtKvZERERE5JCaN2/O9OnTmTRpEnl5eXTo0IFx48ZRUlLidTSRSuGcO885l1FOexfYaGbHAJT9+7+fea71QC7QPfbJVeyJiIiIyM8wM66//nry8vI4//zzueeee+jevTtff/2119GkWnHgwtFvR+c94Iay2zcA7/50BTNrYWY1ym43AM4EKmXnUbEnIiIiIhXSrFkz3n33XV577TWWLl1Khw4dGDNmjEb5pPLE3wQtTwLnm9k3wHll9zGzLDP7a9k6JwNfmFkO8DHwtHNu8dFuuCJU7ImIiIhIhZkZv/zlL1myZAm9e/fmvvvuo1u3bnz11VdeRxOpdM65Lc65ns65E8oO99xatjzbOTe47PaHzrlM51yHsn+fP/yzRo+KPRERERGJWNOmTZk6dSpvvPEGy5cvp1OnTowePZri4mKvo4lfxW6CFt9SsSciIiIiR8TMuPrqq8nLy+Piiy9m2LBhdO3aldzcXK+jiQgq9kRERETkKDVp0oQpU6YwefJkVq5cySmnnMJjjz1GUVGR19HEb+LvnL24pmJPRERERI6amTFgwACWLFlC3759GTFiBKeffjqLFi3yOpr4iYq9iHhe7JnZFWaWZ2ZhM8s6zHq9zOxrM1tuZsMqM6OIiIiIVExqaiqTJ09mypQprF27lqysLEaNGqVRPhEPeF7sUXpRwcuBfx9qBTNLAP4C9AbSgKvNLK1y4omIiIhIpPr160deXh79+/fnoYceokuXLixcuNDrWFKlxWBUTyN7seWc+8o593MXFewCLHfOrXDOFQJvAZfGPp2IiIiIHKmUlBTeeOMNpk6dyoYNGzj11FMZOXIkhYWFXkcTqRY8L/YqqDmwZr/7a8uWlcvMhphZtpllb9q0KebhREREROTQLrvsMvLy8rjqqqt45JFHmD17tteRpCpyQDgc/eZjlVLsmdlMM8stp8VkdM4597xzLss5l5WamhqLTYiIiIhIBBo1asSrr77K/PnzufDCC72OI1ItJFbGRpxz5x3lU6wDWu53v0XZMhERERGpQrKyDjkfn8jP8/k5dtFWKcVeFMwHTjCz4ygt8q4CrvE2koiIiIiIVCoVexHx/Jw9M7vMzNYCZwD/MLMPypY3M7MZAM65YuA24APgK+Bt51yeV5lFRERERETinecje865acC0cpavBy7a7/4MYEYlRpMo2VdSwNwt81m1ZzUtazSnW+pp1EhI9jqWiIiIiFQpDsIa2YuE58We+NuWgm2MyH2c/JJ8CsKFhAJJ/G3te4zKGE7j5BSv44mIiIiI+Jbnh3GKv0367i12Fu2kIFx6PZ2CcCG7infz4srXPE4mIiIiIlWKA+fCUW9+ppE9iamF23IJc+Bwu8ORu+Mrwi5MwPR9g4iIiIhUkA7jjIj+0paYOlQxZxbAsEpOIyIiIiJSfajYk5jqmnIqiZZwwLIES6BLw86YqdgTERERkQg4F/3mYyr2JKauPbY/LWo0IzkQImhBkgMhmiY35sbWV3sdTURERETE13TOnsRUzcSaPN5+BF/tXMba/PUcU6MJ6XXb6Vw9EREREYmMcxD294Qq0aZiT2LOzEirdxJp9U7yOoqIiIiIVGU+P+wy2jS8IiIiIiIi4kMa2RMRERERkSrB6TDOiGhkT0RERERExIc0siciIiIiIlWA/y+VEG0a2RMREREREfEhjeyJiIiIiEj8c0BYI3uRULEnIiIiIiJVg9MELZHQYZwiIiIiIiI+pJE9ERERERGJew5wOowzIhrZExERERER8SGN7ImIiIiISPxzTufsRUjFnoiIiIiIVAk6jDMyOoxTRERERETEhzSyJyIiIiIiVYMO44yIRvZERERERER8yJzz93GvZrYJ+M7DCCnAZg+3L+qDeKF+8J76wHvqA++pD7ynPogPKUAt51yq10Eqysz+SWnuaNvsnOsVg+f1nO+LPa+ZWbZzLsvrHNWZ+iA+qB+8pz7wnvrAe+oD76kP4oP6oXrQYZwiIiIiIiI+pGJPRERERETEh1Tsxd7zXgcQ9UGcUD94T33gPfWB99QH3lMfxAf1QzWgc/ZERERERER8SCN7IiIiIiIiPqRiT0RERERExIdU7ImIiIiIiPiQir0oM7PbzCzbzArM7OUKrH+XmX1vZjvN7CUzC1VCTF8zs4ZmNs3M9pjZd2Z2zWHWHWlmRWa2e7/WpjLz+kVFX3crNdrMtpS10WZmlZ3XjyLoA73vYySS3wH6/I+NivaBmQ00s5Kf7AdnV1pQHzOzkJm9WPY5tMvMFppZ78Osr30hyiLpA+0L/qZiL/rWA48CL/3cimZ2ITAM6Am0AtoAj8Q0XfXwF6AQaAL8EhhvZumHWX+yc672fm1FpaT0n4q+7kOAvkAHIBO4BPh1JWX0u0je+3rfx0aFfgfo8z+mKvx7GJj7k/1gTmyjVRuJwBrgLKAeMAJ428xa/3RF7QsxU+E+KKN9wadU7EWZc26qc+4dYEsFVr8BeNE5l+ec2waMAgbGMJ7vmVktoB/woHNut3PuP8B7wHXeJvO3CF/3G4Cxzrm1zrl1wFj0vj9qeu/Hhwh+B+jzP0Yi/D0sMeCc2+OcG+mcW+WcCzvn/i+wEjilnNW1L8RAhH0gPqZiz1vpQM5+93OAJmbWyKM8fnAiUOycW7bfshxKX+tDucTMtppZnpndEtt4vhXJ617e+/5w/SMVE+l7X+97b+nzPz50MrPNZrbMzB40s0SvA/mRmTWh9DMqr5yHtS9Ugp/pA9C+4FvqSG/VBnbsd/+H23XQN5JHqjaw8yfLdlD6mpbnbUovKroROA34u5ltd869GbuIvhTJ617e+762mZnThT+PRiR9oPe99/T5771/AxnAd5QWHJOBYuAJL0P5jZkFgdeBSc65peWson0hxirQB9oXfEwjexEwszlm5g7R/nMET7kbqLvf/R9u7zr6tP5UgT746WtK2f1yX1Pn3BLn3HrnXIlz7jPgWaB/bP8XvhTJ617e+363Cr2jVuE+0Ps+Lujz32POuRXOuZVlh7gtBn6P9oOoMrMA8Cql5xLfdojVtC/EUEX6QPuCv6nYi4Bz7mznnB2inXkET5lH6SQVP+gAbHTO6ZusQ6hAHywDEs3shP1+rAOHPmzhoE0AmhkycpG87uW97yvaP3JoR/Pe1/u+8unzP/5oP4iislmWX6R0wqh+zrmiQ6yqfSFGIuiDn9K+4CMq9qLMzBLNLBlIABLMLPkwxz2/AtxkZmlmVp/SmZJerpyk/uSc2wNMBX5vZrXMrBtwKaXfah3EzC41swZWqgtwB/Bu5SX2hwhf91eAu82suZk1A+5B7/ujFkkf6H0fOxH8DtDnf4xUtA/MrHfZeUyYWTvgQbQfRNN44GTgEudc/mHW074QOxXqA+0LPuecU4tiA0ZS+o3I/m1k2WPHUnq4wrH7rX83pefN7AQmAiGv/w9VvQENgXeAPcBq4Jr9HutO6SGDP9x/k9JzAnYDS4E7vM5fVduhXvdyXnMDngK2lrWnAPM6vx9aBH2g933s+qDc3wH6/I+/PgCeLnv99wArKD10Leh1fj80Si+h4IB9Za/5D+2X2hfirw+0L/i7WVkni4iIiIiIiI/oME4REREREREfUrEnIiIiIiLiQyr2REREREREfEjFnoiIiIiIiA+p2BMREREREfEhFXsiIiIiIiI+pGJPRERERETEh1TsiYhITJjZU2b2zn73x5jZLDNL8jCWiIhItaGLqouISEyYWSNgBXA2cBpwK3Cmc26Hl7lERESqCxV7IiISM2Y2ErgcqEdpobembPlooCuwChjknCvyKqOIiIhf6TBOERGJpS+B9sDw/Qq9DkBz51x3YCnQ38N8IiIivqViT0REYsLM2gPjgUnAoP0e6gr8q+z2P4FulRxNRESkWlCxJyIiUWdmzYHpwM3AUKC9mZ1d9nADYGfZ7R1Aw8rOJyIiUh2o2BMRkagys7rADGCcc+4959xeYAzwWNkq24G6ZbfrAVsrPaSIiEg1oAlaRESkUplZR+Bu59z1ZvYAsNI596bHsURERHxHI3siIlKpnHMLgY1m9gmQDvzd20QiIiL+pJE9ERERERERH9LInoiIiIiIiA+p2BMREREREfEhFXsiIiIiIiI+pGJPRERERETEh1TsiYiIiIiI+JCKPRERERERER9SsSciIiIiIuJDKvZERERERER86P8Bj/qqBH4B+csAAAAASUVORK5CYII=", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3sAAAIfCAYAAADJ38UbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAACoqklEQVR4nOzdd3hURd/G8e9sSyHU0DsIKoReBBEUEUVFRXnAgqKAyoO9V+xYQGwoVlREHxuiCArYEEFRpEgNSFF67zXJtnn/yMoLJAgLSc5mc3+u68jm7Nk5925isr+dOTPGWouIiIiIiIjEF5fTAURERERERCTvqdgTERERERGJQyr2RERERERE4pCKPRERERERkTikYk9ERERERCQOqdgTERERERGJQyr2REQk3xljuhtj/jLGhIwx7xlj2htjrDGmqtPZYknkdVlgjAkYY346zDGPGWOWFXA0RxhjakZ+Tto6nUVEpDBSsSciIkctUqj9EOVj3MC7wEigOnBbfmSLE68DfwC1ga6HOeY5oHWBJTqAMaZtpPiqWUCnXA1UAn6P5kHGmKAxple+JBIRKUQ8TgcQEZG4VwlIAcZba9cCGGOcTRS76gJPW2tXH+4Aa+0eYE/BRXKOtTYEbHA6h4hIYaWePREROWb/9PQZY/oaY1YaY3YZY8YaYypE7u9Fdu8MwJRIr1D7XNrJdVjnoT00xpgKkXNuNsbsNsZMNcacnks7Zxtjphhj9hljFhpjzjuk3fLGmOHGmI3GmExjzGJjTJ8D7q9jjPncGLPDGLPdGPOdMabhAfeXiDx+gzEmyxiz2hjzwhFeq5OMMeOMMXsi21fGmDoH5gbcwPuR59DrMO0cNIzzn6+NMV2MMX8aY/YaY34yxtQ94JhekdeyozEmPfKcfzfGNDn0mEPOVfWf71mkN+/nyF3LI/t/+pfna40xt0Vex73GmLXGmNsOOaaSMeaTyOucEcnd4oD7DxrGecDXlxpjvo58f/8+5GdkReR1HB451kb2R/09ExEp7FTsiYjI8WoJnAl0BjoBDckeagjwKXBK5HYXsnv5fj2WkxhjkoBJQHHgPKApMB743hhT75DDnwOeBhqTPQTwU2NM6QPamRy570qgPnALsC9yfwXgF2AT0I7sIZOLgZ+MMeUi7T8JNIs8p7rAZcCiI2T/DkgEzohsKcA3xhhf5DWpFDn85sjtT6N4eSoBN0SeTxuyX6N3DznGBTwL3Ej292QzMC6S7WisJvv5Enl8JQ4/1PQfjwI/kf29ehZ43hjTBcBkd+9+CZwMXBBpcyPZ38+yR2h3IPA+0Aj4BHjbGHNi5L6WQAi4PZLxn9c1qu+ZiEg80DBOERE5XllAL2ttFoAx5g2y32hjrc0wxmyOHLfNWrshcsyxnOcyoARwmbX2nx6op4wxZwH//eecEY9ba7+JnOt+oBfZxcS3QA+gFlDHWrsmcvzfBzz2BmCFtfaGf3YYY24Fzie7mHoJqAHMttb+cy3ZKv69iO0BlAOaW2u3RNq8HFgBXG6tfR/YEHlddv7zOkUhAehprd0caftZ4GNjTKK1NvOfpwHcY62dHDmmJ9kFXA/gnSOdwFobMsZsi3y5+SgzjrPWvhK5vcQY0wq4GxgDdCD7e5JmrV0YyXQ12a/JjcAT/9LuUGvtyMhjHia7WD8TWGKt3XyY1zHa75mISKGnYk9ERI7Xn/8UehHrgAr5cJ6WQEVgxyHFYgKQccixc/65Ya3daIwJHZCpObDwgEIvt/M0N8Ycel1cEtk9QgCvAZ9HhhxOBL4BvrXWhg/TZlrknFsOybU4ct/xWvdPoffP12QXd+XJLmr+8dsB599ujFmUR+c/nN8O+XoqMCByOw3Y+k+hF8mUZYz5/SgyzTngMSFjzCaO/DMX7fdMRKTQU7EnIiLHy3/I15bsQiMa/7zh3v84kz2L54GXG7jIHnZ3SS6P33eETP88/mi4yC4Gbs7lvp0A1tpvjTHVyR622h74HzDfGHNWZFKRgpbb9wCiu1wjt6LHe2xx8l1uz/dfn2sMfs9ERPKdrtkTEZFYsCnyb+UD9jXh4KJxJtlLEuyy1i47ZFsXxblmAfXN4df4m0l2z9KaXM6zv/fMWrvNWvuxtfa/ZF+veAbZ1//lJj1yzv3XokWuDTwJWBBF9uO1f8kGY0wpoB7wT8/aJsAdyfWPZoc8/p8iyx3t+SLaHHC+dCDVGLP/NTPGJACtOP7XxJ9bxii/ZyIihZ6KPRERiQXLgJXAY8aYkyOzL77I//dQAXwILCd7UpFzIjMztjLGPGCMuTiKc30cOdfYyOyUtYwxZxljLovcP5TsQmGMMaZd5DxtjTFPGWPaAERudzXZM2zWJftavj0cPGTyQB+RPSHKp8aYZsaY5mRPLLKW6CZiOR4WeNYYc7rJnln0fWB3JBvA9MjXA40xdY0x5wKPHNLGSrJ7AM832TOaljzCOS8wxtwcae8Wsq+7fD5y34+Rc35kjDnNGNMgkimR7PUGj8dy4ExjTOV/Cuxj+J6JiBR6KvZERMRxkQlXLiP7GrPZwKtAfw4YWhiZaOQMsnvehgNLgC/InuRjZRTn2hdpZwHZBdeiyPmSIvdvBE4FtkTaX0x2oVkDWB9pJpPsCURmRfI0As6z1u48zDkzgHPInsxmCtmzge4FzrXW5jbkND+EgQeBN8nOXBHoHHk9sNZuA64guzduHvAwcO+BDURemweA+8l+LcYc4ZxPAB2BuZFz32utHR1pywIXA38C44AZkUxnH3ht4zG6i+xrM1eQXWRDlN8zEZF4YLJ/14qIiEi8iqxD97a1tsCu1Y+sb9fTWvu/gjqniIgcTD17IiIiIiIicUjFnoiIiIiISBzSME4REREREZE4pJ49ERERERGROKRiT0REREREJA6p2BMREREREYlDKvZERERERETikIo9ERERERGROKRiT0REREREJA6p2BMREREREYlDKvZERERERETikIo9ERERERGROKRiT0REREREJA6p2BMREREREYlDKvZERERERETikIo9ERERERGROKRiT0REREREJA6p2BMREREREYlDKvZERERERETikIo9ERERERGROKRiT0REREREJA6p2BMREREREYlDKvZERERERETikIo9ERERERGROKRiT0REREREJA6p2BMREREREYlDKvZERERERETikIo9ERERERGROKRiT0REREREJA6p2BMREREREYlDKvZERERERETikIo9ERERERGROKRiT0REREREJA6p2BMREREREYlDKvZERERERETikIo9ERERERGROKRiT0REREREJA6p2BMREREREYlDKvZERERERETikIo9ERERERGROKRiT0REREREJA6p2BMREREREYlDKvZERERERETikIo9ERERERGROKRiT0REREREJA55nA6Q38qWLWtr1qzpdAwRERERkZgya9asLdback7nOFqdzixmt24L5Xm7s+ZlfWutPTfPG44BcV/s1axZk5kzZzodQ0REREQkphhjVjqdIRpbt4WY/m31PG/XXWlp2TxvNEbEfbEnIiIiIiKFnwXChJ2OUaio2BMRERERkULAErIq9qKhCVpERERERETikHr2REREREQk5mUP47ROxyhU1LMnIiIiIiISh9SzJyIiIiIihYImaImOij0REREREYl5FkvIahhnNDSMU0REREREJA6pZ09ERERERAoFTdASHfXsiYiIiIiIxCH17ImIiIiISMyzQEg9e1FRsSciIiIiIoWChnFGR8M4RURERERE4pB69kREREREJOZZ0NILUVLPnoiIiIiISByKiWLPGFPNGDPJGLPQGJNujLktl2OMMeZlY8wyY8w8Y0wzJ7KKiIiIiIgzwvmwxbOYKPaAIHCXtbY+0Bq4yRhT/5BjzgPqRra+wOsFGzF6S5cuZfPmzU7HEBERERGR42CMOdcYszjS8XR/Lvefboz5wxgTNMZ0cyJjbmKi2LPWrrfW/hG5vRtYBFQ55LAuwPs22zSglDGmUgFHPWrWWq666irS0tIYNWqU03FERERERAo1iyWUD9uRGGPcwKtkdz7VB67IpWNqFdAL+CiPn/ZxiYli70DGmJpAU+D3Q+6qAqw+4Os15CwI/2mjrzFmpjFmplM9a8YY3nnnHapXr0737t259NJL2bRpkyNZREREREQKPQuhfNiOwinAMmvt39ZaP/AJ2R1R/x/N2hXW2nnE2MjQmCr2jDEpwOfA7dbaXcfajrX2LWttC2tti3LlyuVdwCg1aNCAadOm8cwzzzBmzBjS0tL49NNPsZpFSEREREQkVpT9p6MosvU95P6j7nSKNTFT7BljvGQXeh9aa7/I5ZC1QLUDvq4a2RfTPB4P999/P7Nnz6Z27dpcfvnldOvWjY0bNzodTURERESk0LDk2wQtW/7pKIpsbxXYk8pnMVHsGWMM8A6wyFr7wmEOGwtcHZmVszWw01q7vsBCHqf69eszdepUBg0axLhx46hfvz4fffSRevlERERERGJboex0ghgp9oDTgJ5AB2PMnMh2vjGmnzGmX+SY8cDfwDJgGHCjQ1mPmcfj4d5772XOnDmceOKJXHnllVxyySWsX19oalYREfkXuwO7+X7jJL5cO45le/7WB3oiInnKEMqH7SjMAOoaY2oZY3zA5WR3RMU8j9MBAKy1v8C/v9I2+y/mTQWTKH+dfPLJ/PLLL7z00ks89NBDpKWlMWTIEK666iqyOzlFRKSwWbBzES8sGYoFguEAY9eNp1npxtx4wnW4TKx8tioiUnhZIOzAZ2jW2qAx5mbgW8ANvGutTTfGPAHMtNaONca0BEYDpYELjTGPW2vTCj7twfTXxyFut5u77rqLOXPmUK9ePa6++mouuugi1q4tFD3CIiJygGA4yJClb5AV9uMP+wljyQr7+WP7PGZs+8PpeCIicpysteOttSdaa0+w1j4V2feItXZs5PYMa21Va20xa21qLBR6oGLPcSeddBJTpkzhxRdfZOLEiTRo0ID33ntPQ39ERAqRJXv+wtqcs21nhbOYvHmqA4lEROKTQ8M4Cy0VezHA7XZz++23M3fuXBo0aEDv3r3p3Lkza9ascTqaiIgchX97q6Dh+SIi4hQVezGkbt26TJ48mSFDhjB58mTS0tJ455131MsnIuIway2bMjezM5D7ErB1U07A5HJdXoIrgdPLnpbf8UREigSLevaipWIvxrhcLm699VbmzZtH06ZNue666zj33HNZtWqV09FERIqkhbsWc+uc+7hv/mPcOvs+Hk8fxHb/joOO8bg83Fa3HwkuHz6XDxeGBJePZqUb07JMU2eCi4jEobA1eb7FMxV7MeqEE07gxx9/5NVXX2Xq1Kk0aNCAYcOGqZdPRKQAbcrczHOLX2abfzv+sJ+gDbJsz988uei5HL+PG5Ssx5Amg7iyene6Ve1C/3p3c3Od6zUTp4iIOEZ/gWKYy+XixhtvZP78+bRo0YK+fftyzjnnsHLlSqejiYgUCRM3TSEYDh20L0yYHf4dLN69NMfxxb0pdKzQni5VOnNCSq2CiikiUiRoGGf0VOwVArVq1eKHH37g9ddfZ9q0aTRo0IDXX3+dcDjnzG8iIpJ3NmVtJkQo1/u2B3YUbBgREZEoqdgrJFwuF/369WPBggW0bt2aG2+8kY4dO7J8+XKno4mIxK36xU8iweXLsT9kw9QuVrPgA8WgLVlb+Wrdt3y++iuW79XIExHJPxZDCFeeb/Esvp9dHKpRowbfffcdw4YNY+bMmTRs2JBXX31VvXwiIvmgXblTKeEtgce49+/zuXy0Sm1BhcTyDiaLDT9vnsadcx5h5OoxfL72ax5LH8zw5R/r+nIRyTeaoCU6KvYKIWMM1113HQsWLKBt27bcfPPNdOjQgb/++svpaCIicSXRnciAtP6cU6EDZX2pVE2qzJXVu/Pf2r2cjua4PcG9DPv7AwI2QNAGsVj8YT+TN0/lz1yuZxQRkYKnYq8Qq169OhMmTODdd99lzpw5NGzYkCFDhqiXT0QkDxX3pnBljUsZ0nQggxo9TscK7TXDJjB3RzruXF6HrLCfqVumO5BIROKdJmiJnv5aFXLGGHr37s2CBQs488wzuf322znjjDNYulSfqoqISP5xHeYNksEc9j4RESlYKvbiRNWqVfn6668ZMWIECxYsoFGjRrz44ouEQrnPIiciInI8GpdKI0zOa/O8Li9ty7V2IJGIxD9DyLryfItn8f3sihhjDFdffTXp6el07NiRO++8k3bt2rF48WKno4mISJxJ9iRz4wm98bm8+Fw+PMaD13g5t2IHTix+gtPxREQE8DgdQPJe5cqVGTt2LB9++CG33norTZo0YcCAAdxxxx243e4jNyAiInIUWqU25+QSdZm+9Q/8NkDTUg2pnFTR6VgiEqcsEFZfVVT0asUpYwxXXXUV6enpnHPOOdxzzz20bduWRYsWOR1NRETiSElvCc6u2J7Olc5WoSci+U4TtERHxV6cq1SpEl9++SUffvghS5YsoWnTpgwaNIhgMOh0NBERERERyUcq9ooAYww9evQgPT2dzp07c//999OmTRvS09OdjiYiIiIiclSs1QQt0YrvZycHqVixIqNGjeLTTz9l+fLlNGvWjGeeeUa9fCIiIiIicUjFXhFjjOHSSy8lPT2dLl268OCDD9K6dWvmz5/vdDQRERERkX8VxuT5Fs9U7BVR5cuXZ+TIkXz22WesWrWK5s2b8+STTxIIBJyOJiIiIiKSgwVCuPJ8i2fx/ezkiLp168bChQv5z3/+w8MPP0yrVq2YO3eu07FEREREROQ4qdgTypYty8cff8wXX3zBunXraNGiBY8//jh+v9/paCIiIiIiEZqgJVrx/ewkKpdccgnp6elcdtllPPbYY7Rs2ZLZs2c7HUtERERERI6Bij05SGpqKv/73/8YM2YMmzZt4pRTTuGRRx5RL5+IiIiIOMoCYVx5vsWz+H52cswuuugi0tPT6dGjBwMGDKB58+bMnDnT6VgiIiIiUoSFrMnzLZ6p2JPDKlOmDCNGjODrr79m27ZttG7dmv79+5OVleV0NBEREREROQIVe3JEnTt3Jj09nauvvpqnn36aZs2aMX36dKdjiYiIiEgRYjFaeiFK8f3sJM+UKlWKd999lwkTJrBr1y5OPfVU7r//fjIzM52OJiIiIiIiuVCxJ1E599xzWbBgAX369GHQoEE0bdqUadOmOR1LRERERIqAsHXl+RbP4vvZSb4oWbIkw4YN49tvv2Xv3r2cdtpp3HPPPWRkZDgdTUREREREIlTsyTE755xzWLBgAddddx3PPfccTZo04ddff3U6loiIiIjEIQu6Zi9K8f3sJN+VKFGCN998k++//56srCzatm3LnXfeyb59+5yOJiIiIiJxxJL3yy5o6QWRo9CxY0fmz59Pv379ePHFF2ncuDE///yz07FERERERIosFXuSZ4oXL85rr73Gjz/+SCgU4owzzuC2225j7969TkcTERERkTgQxpXnWzyL72cnjjjzzDOZN28eN910Ey+//DKNGjVi8uTJTscSERERESlSVOxJvkhJSeGVV17hp59+AqB9+/bccsst7Nmzx9lgIiIiIlIoWQsh68rzLZ7F97MTx51xxhnMmzeP2267jVdffZVGjRoxadIkp2OJiIiISKFjCOfDFs9U7Em+K1asGC+99BKTJ0/G7XbToUMHbrzxRnbv3u10NBERERGRuKViTwpMu3btmDt3LnfeeSdvvPEGDRs25IcffnA6loiIiIgUAhYN44xWfD87iTnJyck8//zz/PLLLyQkJHD22Wfz3//+l127djkdTUREREQkrqjYE0e0adOGOXPmcM899/D222/ToEEDvvvuO6djiYiIiEgMC+HK8y2exfezk5iWlJTEs88+y6+//kpKSgqdOnXiuuuuY+fOnU5HExEREZEYYzGEbd5v8UzFnjiuVatW/PHHH9x///0MHz6ctLQ0xo8f73QsEREREZFCTcWexITExESeeeYZpk2bRqlSpejcuTO9e/dm+/btTkcTERERkRihYZzRie9nJ4VOy5YtmTVrFv379+eDDz6gQYMGfP31107HEhEREREpdFTsScxJSEjgySef5Pfffyc1NZULL7yQnj17sm3bNqejiYiIiIhDLBC2rjzf4ll8Pzsp1Jo3b87MmTN55JFH+OSTT0hLS2PMmDFOxxKJyoKd83gs/SFumHU9/effz8xt052OJCIiIkWEij2JaT6fj8cff5zp06dToUIFLr74Yq688kq2bt3qdDSRI1qwcx6v/TWUNRlrCNgAG7M28O6Kt/l1y1Sno4mIiBRChlA+bPFMxZ4UCk2bNmX69Ok89thjjBw5krS0NEaPHu10LJF/NWrNSPxh/0H7/GE/n6/9DGutQ6lEREQKJw3jjF58PzuJKz6fj0cffZSZM2dSqVIlunbtyuWXX86WLVucjiaSq42ZG3Pdvyuwk6ANFHAaERERKWpU7Emh07hxY6ZPn86AAQP44osvqF+/PqNGjXI6lkgOpX1lct2f7E7GY7wFnKZw2B3YzcjVo+g//1EG//kC83cucDqSiIjEEA3jjI6KPSmUvF4vDz30ELNmzaJatWp0796dSy+9lE2bNjkdTWS/iyt3xefyHbTP5/JxQaWLMCa+/7gci92B3Ty04DG+3fA9azLWsGBXOi8vfZVvN3zvdDQREZFCScWeFGoNGzZk2rRpPPXUU4wZM4a0tDQ+/fRTXQ8lMeGU1FZcWb0nJTwlMbgo5i7GJZX/Q8cK5zgdLSZ9u+F79gT3ELTB/fv8YT+j1nxBZijTwWQiIhILrDW6Zi9KHqcD/MMY8y5wAbDJWtsgl/vbA2OA5ZFdX1hrnyiwgBKzvF4vDz74IF26dKF3795cfvnljBw5ktdee40KFSo4HU+KuNPKtqNNalsCNoDXeNWj9y/m71xwUKH3D7dxs3rfGuoWr+NAKhERiSWhOC/O8losvVrvAece4ZifrbVNIpsKPTlIWloav/76KwMHDmTcuHHUr1+fjz/+WL184jhjDD6XT4XeEZTylcp1f8gGKeEtXrBhRERE4kDMFHvW2inANqdzSOHm8Xi47777mD17NnXr1qVHjx5ccsklrF+/3uloInIE51Y8J8c1jm7cVEuqRoVE9dKLiBR1Fghj8nyLZzFT7B2lU40xc40xE4wxaYc7yBjT1xgz0xgzc/PmzQWZT2JEvXr1mDp1KoMHD+bbb78lLS2NDz74QL18RVgwHOSXzZMZ/OfTvLB4ENO3TSNsw07HkgPUK3EyPapfRoIrgURXIl7jpXZKLW4/8Rano4mIiBRKJpbe/BpjagJfH+aavRJA2Fq7xxhzPjDEWlv3SG22aNHCzpw5M+/DSqGxePFi+vTpw6+//soFF1zAm2++SeXKlZ2OJQUobMO8vPR5lu1Zsn+Rc58rgealW9C7Vl+H08mh/GE/a/atpbi3OOUSyjodR0QkbhljZllrWzid42hVTittr/2kfZ63+2SjLwvV6xCNQtOzZ63dZa3dE7k9HvAaY/QuQI7opJNOYsqUKbzwwgtMnDiRtLQ0RowYoV6+ImTRrnT+2rN0f6EH4A9nMWv7DNbsW+VgMsmNz+WjdkotFXoiInIQC4StyfMtnhWaYs8YU9FEZjcwxpxCdvatzqaSwsLtdnPHHXcwd+5cGjZsSK9evejcuTNr1qxxOpoUgEW7FpIVzsqxP2zDLN79pwOJRERERPJfzBR7xpiPgd+Ak4wxa4wx1xpj+hlj+kUO6QYsMMbMBV4GLrfqmpEo1a1bl59++omXX36ZyZMnk5aWxjvvvKNevjhX3FMcj/Hm2O82HlI8KQ4kEhERkWMRwpXnWzyLmWdnrb3CWlvJWuu11la11r5jrX3DWvtG5P6h1to0a21ja21ra+2vTmeWwsnlcnHLLbcwb948mjZtynXXXce5557LqlUazhevWqW2wZXLsgcuY2hSqrkDiURERETyX8wUeyIF7YQTTuDHH39k6NChTJ06lQYNGjBs2DD18sWhUr5S3HjCbSS7k0l0JZLgSqSEpyS3172HBHeC0/FERETkKFjy/nq9eL9mz+N0ABEnuVwubrrpJs4//3yuvfZa+vbty8iRIxk2bBg1a9Z0Op7kofolG/Bc41dYuW8FbuOienJNXCZ2Pu+y1vLT5ol8u2E8e4N7qFXsBLpXu5xqyTWcjiYFaOa2Pxi//lt2BnbRoGR9ulS5gDK+0k7HEhGRQip23umIOKhWrVr88MMPvP7660ybNo2GDRvy+uuvEw5rHbZ44nF5OCGlDjWL1Y6pQg9g9NrP+HzNp2zzbyUrnMWfuxfy7J9PsT5jndPRpIB8tW4Cr//1Nkv3/MWmrM1M3vQL/ec/zg7/TqejiYjEjDCuPN/iWXw/O5EouFwu+vXrx4IFC2jdujU33ngjHTt2ZPny5U5HkziXEcpg4sbvDloaAiAQDjB+/VcOpZKClBHK5Mu1Yw/6GQgRIjOUwYT13zqYTEQkdlgLIWvyfItnKvZEDlGjRg2+++473nzzTWbOnEnDhg159dVX1csn+WZL1ibcJueo+jBhVuz924FEUtDWZqzDbdw59gdtiAW7FjmQSERE4oGKPZFcGGPo27cvCxYs4LTTTuPmm2+mQ4cO/PXXX05HkzhU2pdK0AZzva9iYqUCTiNOKOUtSTAcyvW+sr7UAk4jIhK7NEFLdFTsifyL6tWr88033/DOO+8we/ZsGjVqxCuvvKJePslTKZ4UWpQ5Ba/xHbTf5/LRufJFDqWSglQ2IZW6xU/Ac0gPr8/l4/zKnRxKJSIihZ2KPZEjMMbQp08f0tPTOeOMM7j11ltp3749y5YtczqaxJGra/ShXbkz8BofLlyU9ZWj3wm3ULNYbaejSQG5te6N1C9xMh7jIcGVQLI7id41e3JS8bpORxMRiQnZSy+48nyLZybe1xRr0aKFnTlzptMxJE5YaxkxYgS33347fr+fp59+mltuuQW3O+e1NiLHImRDBMIBElwJmFwWgpf4tzOwiz3BPVRIKI/HpRWSRCT/GGNmWWtbOJ3jaJWvn2q7/e+8PG/39eYfFqrXIRrxXcqK5DFjDL169SI9PZ2zzjqLO+64g9NPP53Fixc7HU3ihNu4SXQnqtArwkp6S1AlqbIKPREROW4q9kSOQZUqVRg7diwffPABixYtokmTJjz//POEQrlPsCAihcOGjA1M2vQTM7bNxB8OOB1HREQOYNEELdHSx4Yix8gYw1VXXcVZZ51Fv379uPvuuxk1ahTDhw/n5JNPdjqeiETBWsuIFR/wy5ZfMRhcxoXLuLjv5LupWayG0/FERESOiXr2RI5TpUqV+PLLL/nwww9ZsmQJTZo0YdCgQQSDuU+lLyKxZ9b2P/h16zQCNoDf+skMZ7IvtI8Xl7xM2Gr2XRGR2KAJWqIV389OpIAYY+jRowcLFy6kc+fO3H///bRp04b09HSno4nIUfhp0xSywlk59meGMli+d0XBBxIRkVyFMXm+xTMVeyJ5qEKFCowaNYpPP/2U5cuX06xZM55++mn18onEOL/157rfGHPYBe+dZq0lK5SlnkcRETksFXsiecwYw6WXXkp6ejpdunShf//+tG7dmvnz5zsdTUQOo03qqfhcvlzuMZwQg2sdztk+jzvnPEDfmbfQd+YtfLJqFCGrCaJECot9wX1szNys/2+jZC2ErMnzLZ6p2BPJJ+XLl2fkyJF89tlnrFq1iubNmzNgwAACAc3wJ3I4O/w7WLJ7MTv82wv0vG3LtqF2sVokuBIA8Bg3PpePfrWvj7klEJbsXsory95gi38LYcJkhbP4fuOPfLDiI6ejicgRZIWyeGXp2/SbdTf3zXuc/868i582TXU6lsSx2PoLJhKHunXrRvv27bnlllt45JFHGD16NMOHD6dx48ZORxOJGcFwkPdWvMvM7TPwujwEwkGalW5On5rXFUix5XF5uO/ku5m3Yz7zds6nhKcEbcu1oWxC2Xw/d7RGr/0af/jgYaf+sJ8pm3/lsmrdSPIkOZRMRI7kjb9HMGvbXAI2CBay8DN8xceU8ZWiUak0p+MVCvE+oUpe06slUgDKli3Lxx9/zBdffMG6deto0aIFjz32GH5/7tcJiRQ1Y9d9yR/bZxK0ATJCGQRtgNnbZ/Hl2i8KLIPLuGhSujFX17yKi6teFJOFHmSvBZgbt3GxPbCjYMOIyFHbHdjDzG1zCNiDR/j4w36+XDvBoVQS71TsiRSgSy65hPT0dC6//HIef/xxTjnlFGbPnu10LClkAuEAUzZP5MUlT/L6sudZsHOO05GO20+bf8wxSUrABvhp848OJYpdNYvVwOQye1wYS6qvjAOJRORo7AruxmPcud63xb+tgNMUTpa8X1D9aBdVN8aca4xZbIxZZoy5P5f7E4wxn0bu/90YUzOvn/+xULEnUsBSU1P54IMPGDNmDBs3buSUU07hkUceUS+fHJWQDfLikif5Ys2HLN3zJ/N3zebt5a/w5dpPnY52XDJDmbnuzwpnYa0t4DSx7ZKqF+J1eQ/a53P5OL9SJxLcCQ6lEpEjKX+Y0QIuDPWK1y3gNIWXE0svGGPcwKvAeUB94ApjTP1DDrsW2G6trQO8CAzK46d+TFTsiTjkoosuIj09nR49ejBgwABatGjBrFmznI4lMe6P7dNZn7nmoF4wfziLHzd9w3b/VgeTHZ9ah5nxsmaxWhgT3zOlRat6cjX617uHk4rXxefyUdaXSo/ql9K1ykVORxORf+F1ebms2sUkHDDzr8GQ4E6ga9XODiaTo3AKsMxa+7e11g98AnQ55JguwIjI7VHAWSYG/oCp2BNxUJkyZRgxYgRfffUVW7dupVWrVvTv35+srJyLO4sALNg5O9fFv93GzbI9ix1IlDeuqH4VCa4EXJE/Sy5cJLgS6FH9KoeTxabaKbV4qP59vNPyNV5sOoizKrRXUSxSCJxb6SxurnMdJxSrSRlfKU5NbcnTDR+iQmJ5p6MVChbyaxhnWWPMzAO2voecugqw+oCv10T25XqMtTYI7ARS8+WFiIJm4xSJARdccAELFizgzjvv5Omnn2bMmDEMHz6cli1bOh1NYkxxT0lcuAhz8ELaBkh2F3MmVB6oWawmj9R/gm83jGfVvlVUS67GuRXPp0JiRaejiYjkqRZlmtCiTBOnY8jBtlhrWzgdIj+oZ08kRpQuXZrhw4czfvx4duzYQevWrXnggQfIzMz9WiYpmk4reyZuk/NzOq/Lx8klGjiQKO9USKzA1TV781D9R7mmZh8VeiIikkPYuvJ8OwprgWoHfF01si/XY4wxHqAk4Pj1FSr2RGLMeeedR3p6Or1792bgwIE0a9aM33//3elYEiMqJVWhZ43rSXAlkOhKIsGVSGlvKrfVfQD3YWZ5ExERiQv5MITzKGfjnAHUNcbUMsb4gMuBsYccMxa4JnK7G/CjjYEZxjSMUyQGlSxZkrfffpvu3btz3XXX0aZNG+666y4ef/xxkpK0YHJR16LMqTQq1ZwVe5fhcyVQI7m2rtcSERHJJ9baoDHmZuBbwA28a61NN8Y8Acy01o4F3gE+MMYsA7aRXRA6TsWeSAzr1KkT6enp3HPPPQwePJixY8fy7rvv0qZNG6ejicN8Lh8nFj901mf5xzb/VmZsm04gHKBRqcZUT67hdCQRETlOFo5qqYR8Obe144Hxh+x75IDbmUD3gs51JCr2RGJciRIlePPNN/f38rVt25Y77riDAQMGkJyc7HQ8ccC2rM18tnoEi3bPw23cNC/dhkuqXkmSWz8PANO2/saIFe9isYRsiPEbvqZtajuuqH6VekBFIhbsXMTHq0axLnMDqb4ydK96Ma1SmzsdS0TymK7ZEykkOnbsyPz58+nXrx8vvPACTZo04ZdffnE6lhSwjNA+Bi9+hPRdcwjZEP6wn+nbfmHo0qe1+DiwN7iXESveJWADBG0Qi8Uf9vPL1p9ZumeJ0/EKvTX71jJw0fP0mX4DN826ky/Xfk3IhpyOJVFasHMRzy95hRX7VuEP+1mfuYE3/n6XKZunOh1N5Igcumav0FKxJ1KIFC9enNdee42JEycSDAY5/fTTuf3229m7d6/T0aSAzNg6FX8oE8v/F3YhG2Rj5jr+3qtiJn3X/FwnqvGH/fy+9TcHEh295XtXMHHjj8zePodgOOh0nBy2ZG3l8fRnSN+1iIANsCu4i6/Wjeedv0cc+cESUz5Z9Tn+cOCgff6wn49XfaEPjSSm5eM6e3FLxZ5IIdShQwfmzZvHTTfdxJAhQ2jUqBGTJ092OpYUgDUZK/Bbf479YWvZkHnoLNBFUe5/tA3msPc5LRgO8sLil3h60SA+WT2SN/4axt1z72Nz1manox1k/PpvCeRSIEzbOp0d/h3OhJJjsi5zfa779wT3kBXOKuA0IpKfVOyJFFIpKSm88sor/PTTTwC0b9+eW265hT179jgbTPJVlaTq+FwJOfa7jIsKCZUcSBRbGpRomGPBeQCvy0vr1Nic2Oj7jT+waNdi/GE//nCAzHAmOwI7eW3Zm05HO8jfe1cQIueQTY/Ly7qMDQ4kkmOV6iuT6/5EdwI+l6+A04hERz170VGxJ1LInXHGGcybN4/bbruNV199lUaNGjFp0iSnY0k+OSW1HV7ji/RUZXMbN+USKnBCyskOJosNyZ5krq15PV7jxWu8uI0br/FyZrkO1C1e1+l4uZq0eUqO3lqLZdW+1ezw73QoVU7VkqrgyuVtQzAcpHxiOQcSybHqVvXiHEWdz+Xjosrn4zJ6aygST/R/tEgcKFasGC+99BJTpkzB4/HQoUMHbrjhBnbv3u10NMljSe5k7j75CU4u0RAXLjzGS/PSbbilbn/NNBnRvExLBjZ6ju7VLqNrlW48XP9xuleLieWOchU6zPV5BhNTk5+cX6kTXtfBk3h7jZdGpdIom5DqUCo5Fq1Sm9O75pWU9JbAhYtkdxJdq1zIBZU6OR1N5F9ZHFtUvdDS0gsicaRt27bMmTOHhx9+mBdffJEJEybw9ttv07FjR6ejSR4qm1CeG+vct38iBRV5OZX0lqRD+cLxc986tRXfbPiOoD246Ev1laGMr7RDqXKqlFSRe0++k/eW/481GWvxGA9nlGvLFTUudTqaHIPTy7WhXdlTyQpn4XP51KMnEqdU7InEmeTkZJ5//nn+85//0Lt3b84++2z69u3L4MGDKVGihNPxJA/FcpGXGcrEbVx4df3PEV1Q+Xz+2D6Hrf6tZIWz9g8//e8J18fM99haizGGE4vX4elGjxEMB3EZlwqEQs4YQ6I70ekYIlFxalH1wkrFnkicatOmDXPmzOGRRx7hhRdeYMKECQwbNoxOnTRMR/LP6n0r+GDlMNZlrMYYQ8MSTbmyxnUU86Q4HS1mJbmTGNDgUWZun8WS3Uspl1CW08qeRglvcaejMX9HOv9b+QnrMteT4inG+ZXOpXOlTnhcevsgIg6wxP2wy7ymj+RE4lhSUhKDBw9m6tSpFCtWjHPPPZdrr72WHTt2OB0tzwTCAT5aOZ5evz/MVdMe4LWln7IzoBlJnbAzsJ0XlzzJmoyVhAkTsiHm75zNkKXPaO2uI/C4PLRObcXVNa/ivErnxkSht2T3Ul5aOnT/NP17gnv5cu1XjFrzpbPBRETkqKnYEykCWrduzezZs7n33nt57733aNCgARMmTHA6Vp54Iv1NPl/zA1v9O9gZ2MP3G3/jrtnPkRXKuRad5K9fNk/Kcd1ZiBCbsjawYt9fDqWKfav3rWbIkiHcOvtWHk1/lJnbZjodCYAv1ozNdeHtbzf8gD+s/79EpOBpUfXoqdgTKSISExMZNGgQv/32GyVLluT888+nT58+hbqXb+nuVSzatfygN6RBG2JnYA8/b/nDwWRF0/rMtTmKPcieVXJDxjqmbvmJIUue5o2/XiB951wHEsaetRlreWrRU8zZOYfdwd2s2reKYcuH8cPGH5yOxtqMdbnuN5BvS0Ks3LuK0Wu+4ut1E9icteWY27HWkhHKJGxzrrkoIlKUaNC9SBFzyimnMGvWLJ544gmeffZZvv32W9566y06d+7sdLSo/bVnNdmf8x0sM5zFn7uW07FC64IPVYTVLlaXBbtm5+j1CdswkzZ/y6asDfjDWQD8uTudM8qdzSVVYndJhIIweu3oHK+XP+znizVf0L5ce0evjauaVIUdgdyLulK+Unl+vv+t+IRJm6cQDAdwGTdfrBlL71pX0a7caVG18/PmX/l49efsCe7B5/LRuVInumj9OJG4Ee89cXlNv/lEiqDExESefvpppk2bRpkyZbjgggu45ppr2L59u9PRolI+sUyub+B8Li+Vk8o7kKhoO7Xs6SS6kg5aeNtrvFRMrHRQoQfgD2cxadO3bPNvdSJqzPhrz1/YXD6wCBNmm3+bA4n+33+qdsHn8h60z+fycV7FTjn2H68lu5dmLy4f9hPGErRBAjbA8OX/Y3cU1+DO2PYH7674kJ2BXYRsmIxQJmPXTWDMuvF5mldEnKF19qKnYk+kCGvRogUzZ87koYce4sMPPyQtLY2xY8c6HeuoNS51EiW9xQ8qLgA8xs1ZFVo5lKroSnInc9/JT9C8dGuS3MmU8JSkY4XOVEysclCh9w+3cbN09yIHksaOsgllc90ftmGK59EkLRsyN/Lu8hE8lj6A4cvfZ2PmxqN6XJ3iJ3DnibdSPakqLlyU9JagW9WL6Vr1ojzJdaBpW2cQOOT6QACXcTF3x/yjbmfUmjG59pR+ve5bDekUkSJJwzhFiriEhAQGDBjAJZdcQu/evenSpQtXXnklQ4YMITU11el4/8ptXAxsdDsvLnmf9J3ZE4BUTarAHSf1pKRXU/07obQvld61bjxo3+drPsKFmzChg/YbDMmeYgUZL+ZcWOlCXv3r1YMKFK/xcmrqqSS5k467/b/3LGfgn4MJhAOECbNy7yp+2zqNB+rdS61iNY/4+LSS9Xiq0WPHneNIzGHWzTJEt57klqzce0MDNkBGKJNinuRjiSciMcTGeU9cXlPPnogA0KxZM2bMmMFjjz3Gp59+SlpaGqNHj3Y61hGlJpTkyYa38GHrgbzf6ileaf4AtVOqOh1LDnBa2fa4jTvHfrdxU694QwcSxY5GpRrRs0ZPUtwpeI0Xr/FyWtnT6FmjZ560/8HKD8kKZxEmu1crTJiscBYfrvw4T9rPK23KtsKby9DQkA3TpNTR/4xUTaqc6/5kdxJJWjxcRIogFXsisp/P5+PRRx9l5syZVKpUia5du3LFFVewZcuxz4pXUJI9iRT3Fu1eolhVMbEyV9W4Dp8rgURXEgmuREp6S3Nb3Qe0ODfQtmxbhjQdwqBGg3il6StcU/OaPHldrLUs37si1/v+2vP3cbefl05Iqc25Fc/Ga7x4jAef8eE1Xv57Qh+KRdH7e3n1rrleZ3hZta6aoEUkToQxeb7FM/2VFTmAtRaCiyC0EbwNMO5yTkdyROPGjZk+fToDBw5kwIABTJw4kddee41u3bo5HU0KqZZl2tC4VAuW712Kz5VAjeTaevN9AJdxUdpXOk/bNMaQ4EogM5yZ477EGOzl6l7tEtqWPZU5O+bhdXlpUboZpXwlo2qjXomTuOek2/h41SjWZqwn1VeablW70Cq1RT6lFpGCZK1m44yWij2RCBvait3eB0IrADdYPzb5CkzxB6O6ZiReeL1eHn74YS6++GJ69+5N9+7d6d69O0OHDqV8ec10KdHzuXycVDzN6RhFSofy7flh08SD1qL0GR8dyrd3LtS/qJRUkUpJFY+rjfolTmJAg/55lEhEpHDTx6oiEXbHbRBcCjYD7B7AD/tGQuYYp6M5qmHDhkybNo2nn36aMWPGkJaWxqeffprdCyoiMe0/VS+hWalmeI2HJHcSXuOhRZlmXFKli9PRRESOibUmz7d4pp49EcCGNkNgDhA85J4M7N73MEkXF3yoGOLxeHjggQe46KKL6N27N5dffjkjR47ktddeo0KFCk7HE5HD8Lg83FCnL9v929mYuYmKiRXyZUF0ERGJTerZEwGwe4GcswVm37e7QKPEsrS0NH799VcGDRrEuHHjqF+/Ph9//LF6+URiXGlfaU4ucZIKPREp5LSoerRU7IkAuKuBK7f1l7yQcFaBx4llHo+He++9lzlz5nDiiSfSo0cPLrnkEtavX+90NBERERE5gIo9EcAYN6bE00Ai/9/DlwiuMpiUfg4mi10nn3wyv/zyC8899xzffvstaWlpfPDBB+rlExERkXyja/aio2JPJMIknolJ/RySuoGvDaTcjCk7DuMq43S0mOV2u7nrrruYM2cO9erV4+qrr+aiiy5i3bp1TkcTERGROGNBwzijpGJP5ADGWxdXyQG4yryHK6UvxlXC6UiFwkknncSUKVN44YUXmDhxImlpaYwYMUK9fCIiIiIOiplizxjzrjFmkzFmwWHuN8aYl40xy4wx84wxzQo6o4gcntvt5o477mDu3Lk0aNCAXr160blzZ9asWeN0NBEREYkHNnth9bze4lnMFHvAe8C5/3L/eUDdyNYXeL0AMolIlOrWrcvkyZMZMmQIkydPJi0tjXfffVe9fHkkK5TJir3L2Jq12ekoBWL5/JW8/cCHvHHXCBb+ttjpOCIiIoVKzKyzZ62dYoyp+S+HdAHet9nvGKcZY0oZYypZazUFoEiMcblc3HrrrXTu3Jk+ffpw7bXXMnLkSIYNG0a1atWcjldoTdo4ga/Xj8SFm5ANUr3YCVxf+3aKeYo7HS1ffPb8WEY88ikBfxAbtnz95vd06tWeW4Ze53Q0ERFxSJj4vsYur8VSz96RVAFWH/D1msi+HIwxfY0xM40xMzdvLhqffovEohNOOIFJkybxyiuv8PPPP5OWlsawYcPUy3cM0nfO4et1I/GH/WSGMwjYACv2LOWdv4c4HS1fbFq9hfce/oSsDD/hUBhrLVn7svj2vZ9YOG2J0/FERMQBFs3GGa3CVOwdNWvtW9baFtbaFuXKlXM6jkiR5nK5uPnmm5k/fz4tWrSgb9++dOrUiZUrVzodrVD5ceN4/NZ/0L4QIZbvXcZ2/1aHUuWf6eNnY1w5/0T5M/xMHf27A4li0w7/DpbtWcruwG6no4iISAyKmWGcR2EtcOD4r6qRfSJSCNSuXZsffviBt956i3vuuYcGDRowePBg/vvf/2JMfH+qlhd2BXfkut9t3OwJ7qa0L7VgA+Uzj89Dbj8WLrfBm+At+EAxJhAO8O7yYczeMRuvy0MgHOC0su24snpPXCYuP8cVEQHif6mEvFaY/iKMBa6OzMrZGtip6/VECheXy0W/fv2YP38+rVq14oYbbqBjx44sX77c6Wgxr17xRrhN7p/PVUysfNztL9k9jxcW38v9867i6UW3MHPb5ONu83i0uagFNpxzuK/b6+HMK9o6kCi2jFrzKXN2zCZoA2SEMgjaIL9tmco3GyY4HU1ERGJIzBR7xpiPgd+Ak4wxa4wx1xpj+hlj+kUOGQ/8DSwDhgE3OhRVRI5TzZo1+f7773nrrbeYMWMGDRs25NVXXyUcDjsdLWZ1rHghye7kgwo+n/FxSdUr8bp8x9X2sj3pDF8+mHWZKwnaANv8m/h8zdtM3fLt8cY+ZiVSi3PfB7eSkOQjMSWRhOQEfIlerht4JTXqVXUsVywI2zA/b55CwAYO2u+3fn7Y+J1DqURECoaWXohOzAzjtNZecYT7LXBTAcURkXxmjOH666+nU6dOXH/99dx888189tlnvPPOO5xwwglOx4s5JbwleaDeQH7cNJ5Fu+ZRyluGsyp0pm7x+sfd9vj1HxE45HrAgPXz7YaRnJp6tmPDAtt1bUXj9m8w7atZBAMhTjm/KWUrl3EkSywJ2VCOQu8fGaF9BZxGRKRgxfuEKnktZoo9ESmaqlevzjfffMPw4cO54447aNSoEc888ww333wzrlwm6CjKintL0qXKFXSp8q+fjUVtU2bulz9nhTPJDO0j2ZOSp+eLRokyxTnnmvaOnT8WeV1eKiVWZl0u37cTUuo4kEhERGKV3kmJiOOMMfTp04f09HTOOOMMbrvtNtq3b8+yZcucjlYklPGVz3W/x3hJcCcVcBo5GlfVuBqfy4eJrDflwkWCK4HLquXtBwEiIrEke9illl6Ihoo9EYkZVatWZdy4cbz33nvMmzePRo0a8eKLLxIKhZyOFtfOrXQZXnPwdX8+VwJnlr8It3E7lEr+zYnFT6J/vUdoVeZUqiVVp23ZdjxafwDVkqs7HU1ERGKIij0RiSnGGK655hrS09M566yzuPPOOzn99NNZvHix09HiVv0Szbms2g2U8qZiMCS5i3F2hW6cVf4Sp6PJv6iSVJXravfl0bQnuLpmb8on5t5DKyIST8LW5PkWz3TNnojEpCpVqjB27Fg+/PBDbr31Vpo0acKAAQO44447cLvV25TXmpRuQ5PSbQiGg7iNW2sfioiIxAH17IlIzDLGcNVVV5Genk6nTp245557aNu2LYsWLXI6WtzyuDwq9I6RP+zHH/Yf+UARETlmWnohOir2RCTmVapUidGjR/PRRx+xZMkSmjZtyqBBgwgGg05HE2Fb1mZeXvIU98y5jnvmXMeQJU+yJWuT07FEROKSJmiJjoo9ESkUjDFcccUVLFy4kM6dO3P//ffTpk0b0tPTnY4mRVgg7Of5xY+xbM8iwoQIE+KvPX/ywuLHinQvX/rOdF5Y/AKPLHiEz9d8zu7AbqcjiYgUSSr2RKRQqVChAqNGjeLTTz9l+fLlNGvWjKefflq9fOKIeTtmkRXOxPL/44AsFn84i7k7ZkTVVjAcZG9wD7aQjyn6fsP3vLzsZebvms/qjNV8s+EbHkl/hD3BPU5HE5FCzpL3vXrq2RMRiTHGGC699FLS09O56KKL6N+/P61bt2b+/PlOR5MiZkvWRvzhrBz7s8KZbD3KoZzBcJBPV43grrl9uX/+zTy44Bb+2D49r6MWiKxQFqPWjjqoVzNog+wJ7uG7Dd85mExEpGhSsScihVb58uX57LPPGDlyJKtWraJ58+Y8+eSTBAIBp6NJEVEluTo+V0KO/QmuRConVTuqNj5d/R6/bp1MwPoJ2SA7Azt4f8UbLNm9MK/j5rvVGatxk3O23KANMm/nPAcSiUi8sfmwxTMVeyJS6HXv3p309HT+85//8PDDD9OqVSvmzdMbS8l/9Us0oYyvLG7z/ysZuY2H0r5U0ko2PeLjM0L7+H3bVAL24Ov7/NbPhA1j8jxvfivuKU7Q5j6kupS3VMGGEZH4YzVBS7RU7IlIXChXrhwff/wxn3/+OWvXrqVFixY88cQT6uWTfOUyLu446VHalD2TYu4Ukt0ptEltzx0nPorbHHk9yF2BHYc9bn3G2ryOm+8qJFagenJ1XIe8vfC5fHSq2MmhVCIiRZeKPRGJK127dmXhwoV069aNRx99lJYtWzJnzhynY0kcS3Inc2m1Xgxs/CaDGr/JpdV7k+wpdlSPLe0rS9iGc71vb3A3maHMwz52T3A3kzZ9z+g1nzJ/55zDtlPQbq17K7WK1cJrvCS5kkhwJXBZtcuoV6Ke09FEJB5oHGdUPEc+RESkcElNTeWjjz7isssuo1+/frRs2ZIHH3yQ/v374/P5nI4nsp/P5aNeiQbM2/lHjvtcxs3sHdM5NfX0HPct37uMl5YMImzDBKyfnzZ/T5Wkatxx4gN4Xc7+jJfwluCh+g+xKXMTu4O7qZpUlQR3zusaRUQk/6lnT0TiVpcuXUhPT+eKK67giSeeoEWLFvzxR8431SJOqpJYPdf9IRtkV2BHjv3WWt76ayhZ4cz91/plhbNYvW8VkzZ9n59Ro1I+sTwnpJygQk9E8lRRuWbPGHOmMaZW5HYlY8wIY8xwY0zFaNpRsScica1MmTK8//77fPXVV2zdupVTTjmF/v37k5WVc7p8ESfULX4yCbnM6OlxeamTcnKO/RuzNrA3lHOR8oD1M23rL/mSUUQkVlib91uMeg0IRW4/D3iBMPBWNI2o2BORIuGCCy5gwYIF9OzZk6effprmzZszY0Z0i16L5IeTiqdRI7k2XvP/wy99Lh91ip1E7WJ1cxzvwnXYNyeuo5gURkRECoUq1tpVxhgP0AnoC9wAtImmERV7InEmGFzFtu13sX5jWzZv6UFm1m9OR4oZpUuXZvjw4YwfP54dO3bQunVrHnjgATIzDz8Jhkh+M8Zwc537uLjKZVRNqkG1pBpcUvkKbqhzJ8bkHF5ULqE8pX1lcuz3uXy0LXtGQUQWEXGEpegM4wR2GWMqAGcAC621eyL7vdE0oglaROJIIPg3Gzedi7X7gBDB4F9k+adRutQLFEu+2Ol4MeO8884jPT2du+66i4EDBzJmzBiGDx9Oq1atnI4mRZTH5eHM8p04s/yRlycwxvDfE27lhcVPEbQhguEAbpeHE4ufTLtyHQogrYiIFIBXgBmAD7g9su804M9oGlGxJ1LIBUOb2ZvxLZYQ/syJWLuX7CHd2azNYMfOh0hOuhCjIV77lSxZkrfffpvu3btz/fXX06ZNG+68806eeOIJkpKSnI4n8q+qJFXjmUYvM3fHLHYGdlC7WF1qFTsh155AkWO1L5jB3tA+Un2lcRkNBpMYYIHY7YnLU9baQcaY0UDIWvtXZPda4Lpo2lGxJ1KI7do7ik3b74HIH2FrM/Bg8Rzye9DafYRC6/F4qjqQMrZ16tSJBQsWcM899/Dcc88xduxYhg8fTps2UQ2JFylwPpePlmVOdTqGxKHMUBZv/f0es7bPwWVcJLgS6FXzClqntnQ6mkgsT6iSH5YDrY0xLay1n5Jd7EVFH9OIFFLB0EY2bb8XSxbWZmBtRvZ+IHzIL0JrQ7hcpQo8Y2FRokQJ3nzzTb7//nuysrJo27Ytd911F/v27XM6mohIgRu6bBh/bJ9D0Abxh/3sDu7mzb/fY/HuZU5HEykyjDENgSXAMOCdyO4zgHejaUfFnkghtSdjwmHuMfvn6c2WQHLSBbhcKfkfqpDr2LEj8+fPp1+/frzwwgs0btyYn3/+2elYIiIFZrt/Bwt2phOwwYP2+8N+vlp3uL87IgXI5sMWm14HHrHWngwEIvsmA22jaUTFnkhhZYPk/hvKYPBgTAqQQFJiR0qXGlzA4Qqv4sWL89prrzFx4kSCwSBnnHEGt99+O3v37nU6mohIvtvu34HHlftVPpuyNhdwGpEiLQ34X+S2BbDZEzNENbGAij2RQqpY0jm57jcmgYrlvqR82dFUrjiDsqlv43IlF3C6wq9Dhw7Mnz+fG2+8kSFDhtC4cWOmTJnidCwRkXxVOakiIRvKsd+Ni3rFT3QgkciB8n7ZhRheemEF0PzAHcaYU4CoxlOr2BMppLye6pQpeQ/GJAJuwIUxSZQqdj1JCc3x+RrgdpdzOmahlpKSwtChQ5k0aRLWWs444wxuueUW9uzZc+QHi4gUQonuRC6qfD4JLt/+fQZDgjuBCyuf52AykSLnYWCcMeZxwGeMeQD4DHgomkY0G6dIIVam+I0US+zInn1jsYRISTqfRF9Dp2PFnfbt2zNv3jwefPBBXn75ZcaNG8e7775L+/btnY4mR2nlis189eUfbN60i1Zt6nDW2Q1ISIhqXVqRIuPiyp2pmFier9Z9w87ALtJKnEy3ql0om5DqdDSRWL7GLk9Za782xpwLXE/2tXo1gK7W2lnRtGNsnM9f2qJFCztz5kynY4hInPj555/p06cPy5Yt48Ybb2TQoEGkpGjym1j28+Q/GfjkGAKBEOGwJTHRS/kKJRn6Zi+SkxOcjici4hhjzCxrbQuncxythFpVbaUnbs7zdlde/UCheh2ioZ49EZEotGvXjrlz59K/f3+GDBnC+PHjefvttznrrLOcjia5CARCPDfwa7Ky/n9mwczMABvWb2fMFzO54qrTHEwnRd2y3X/xv5WfsnLfKlI8KXSu1IlOFTtiTMxeQyQiBcQY88Th7rPWPnK07eiaPRGRKCUnJ/Piiy/y888/4/V66dixI/369WPXrl1OR5ND/P3XRsK5jGDx+0NMnrTIgUQi2VbuXc0zfz7PX3v/JmiD7Ajs4LM1oxm5+guno4nEtqKz9EK1Q7aWwN3ACdE0omJPROQYnXbaacydO5e7776bYcOG0bBhQ7777junY8kBkpMTCIdz/0terJiGcIpzvlz7FYFw4KB9/rCfbzf8QGYo06FUIhIrrLW9D9nOA7oCwSM99kAq9kREjkNSUhKDBw9m6tSpJCcn06lTJ66//np27tzpdDQBqlVPpVKlkjmGxSUmeunStaVDqURg5b5V2Fy6FNzGzdasbQ4kEiksTD5shcZ3wMXRPEDFnohIHmjdujWzZ8/m3nvv5d1336VBgwZ88803TscS4IlnLqV8hRIkJftITvbh87m5oEsz2p1xktPRpAirnFgp1/0hG6KMr3QBpxEpRIrIME5jTO1DtgbAk8DqaNrRBC0iInkkMTGRQYMG8Z///IfevXtz3nnn0bt3b1544QVKlSrldLwiq3Ll0nzwyU0smLea7dv3ktagCmXLlXA6lhRxF1e9kEW7F+MP+/fv87l8nF7uNJI8SQ4mE5EYsYzsUvSfrsd9wGzgmmgaUc+eiEgeO+WUU/jjjz948MEHef/990lLS2PcuHFOxyrSXC5DoybVOePMeir0CtjajNWMXTuKsWtHsTYjqg+k41qdlNrcfuJNVEqsgMGQ6Erk3Ipn07PGFU5HE4ltRaRnz1rrsta6I/+6rLUp1tp2WmfvEFpnT0ScNGvWLHr16sWCBQu4+uqreemllyhdWkO0pGgYt/5Lvln/FUEbxABu4+HcihfQufIlTkeLKcFwELdxa8kFKXCFcp29R2/J83ZX9r6/UL0O0VDPnohIPmrevDkzZ87k4Ycf5qOPPiItLY2xY8c6HUsk323IXM8368cSsH4sYcKECVg/32z4ig2Z652OF1M8Lo8KPZGjYQFr8n6LEcaY1caYVUfaomlT1+yJiOSzhIQEnnjiCS655BJ69+5Nly5duPLKKxkyZAipqalOxxPJF3N3zCJswzn2h22YuTtmUbHiBQ6kEpHCLs4HJV6V1w2q2BMRKSBNmzZl+vTpPPPMMzz55JP88MMPvP7661xyiYa0SfzZPyzxkDdmxhjcxu1MKBGRGGatnZzXbWoYp4hIAfL5fDz66KPMnDmTSpUq0bVrV6644gq2bNnidDSRPNW0VEtMLutXGQxNS2mNQxE5RkVkghYAY0wTY8wtxpjHjTFP/LNF04aKPRERBzRu3Jjp06czYMAAPv/8c+rXr8+oUaOcjiWSZ1ITynJptavwGi9e48NrfHiMl0urXUVqQlmn44mIxDRjTF9gKtABuA9oCNwF1ImmHQ3jFBFxiNfr5aGHHqJLly707t2b7t270717d4YOHUr58uWdjueIjOAe5u38hd2B7dQsVo/aKY1wGX0uWVi1K9eBhiWbMm/nHwA0KtmMUlowXESORwxNqJLP7gXOtdb+bIzZbq29xBhzHnB5NI2o2BMRcVjDhg2ZNm0agwcP5rHHHmPSpEkMHTqUSy+9tEjN0Ld63xLe/fsxrLUEbBY+VyJVkk6gV61H8Li8TseTY1TKV5rTy53ldAwRkcKmvLX258jtsDHGZa2dYIz5MJpG9HGpiEgM8Hg8PPDAA/zxxx/UqlWLyy+/nG7durFx40anoxUIay0frRyMP5xJwGYB4A9nsmbfMqZv/dbhdCIiEiuMzfstRq0xxtSM3F4CdDHGtAP80TSiYk9EJIakpaXx66+/MmjQIMaNG0f9+vX5+OOPsXE+1/SmrNVkBvfk2B+wWfyxfZIDiUREJObkx+Qssfvn9VmgXuT2E8D/gB+Bx6NpRMWeiEiM8Xg83HvvvcyePZu6devSo0cPunbtyoYNG5yOlm8MrsP+vTW6Zk9ERGKUMaaMMeZ7Y8zSyL+5XphsjPnGGLPDGPP10bRrrX3PWjshcnsCUBooba19PZp8+gsqIhKj6tWrx9SpUxk8eDATJkygfv36/O9//4vLXr5yCVVI8ZTMsd9rEmhRWtd7iYgIgMmeoCWvt+NzPzDRWlsXmBj5OjeDgZ5H/UyNeckYs3+dGmut31qbcwjMEajYEznEdv9G5m6fxJLdMwnZoNNxpIhzu93cfffdzJkzh5NPPpmePXvSpUsX1q1b53S0PGWMoUfNe0l0FcPnSsSFG68rgVopabRIPXv/cVuy1vLV2jcZ/vejTNr4KXuDuxxMLSIiQhdgROT2CODi3A6y1k4EdkfRrgHGRHoMHzfGnHQs4TQbp0iEtZZvNrzDrG3fYIwbg8FrfFxT60nKJ1Z3Op4UcSeffDI///wzQ4YMoX///qSlpfHSSy9x9dVXx82MnZWTanNvvbdYuGsauwM7qFGsHtWTT9r//P7eM5//rXiKkA0QJsyqfYv4fet4bqj7PCW9WrdNRKRIyJ/BLWWNMTMP+Pota+1bR/nYCtba9ZHbG4AKeRHIWnubMeYO4CzgCmCaMeZv4ENr7QtH24569kQi/tz9O39s+46gDRAIZ+IPZ7A3tJOPVg6Iy2FzUvi43W7uvPNO5s2bR4MGDejVqxcXXHABa9eudTpanklwJ9G09JmcXv4SahQ7eX+hZ61l9JqhBGwWYcIABG2AfaE9TNzwsZORRUSkIOXPBC1brLUtDtgOKvSMMT8YYxbksnU5KFr2G8Y8e9NorQ1ba7+31vYBGgBbyR4OetRU7IlEzNg6Yf+U7wfaF9rFhszlDiQ6OqGwH2vDTseQAlS3bl0mT57MkCFDmDRpEmlpabz77rtx/aHEnuAOdge359hvCbNkzywHEomISFFhre1orW2QyzYG2GiMqQQQ+XdTXp3XGFPMGHOVMWYc2csvBIFromlDxZ5IRCCcmet+g8m1CHTa6r2/8+nyy3lv2dmMWHYuMza/QVjXGBYZLpeLW2+9lXnz5tG4cWOuvfZazjvvPFavXu10tHzhcyVyuA9LE13JBRsmD1lr2b1jH/6sgNNRREQKh9hbemEs/1+AXQOMOe4WAWPMZ8BGoC/wNVDDWnu+tfZ/0bSjYk8kokHJdnhNQi73GCon1inwPP9mY8YCJq7rz+7AWixhgjaDBTtG8duml52OJgWsTp06TJo0iaFDh/LLL7+QlpbGsGHD4q6XL8GdRN2UZrgPudTcaxJoldrZoVTHZ/bUpfRp/ww9Wj1Ot8YPMeiOD8nYG3sfLImIyL8aCJxtjFkKdIx8jTGmhTHm7X8OMsb8DHwGnGWMWWOM6XSEdmcA9a21p1trX7fWbjmWcCr2RCKalTmHconV8ZpEAFy48RgfF1e9DY/L63C6g83e+h7BQ3obQzaLJbvG4Q/tdSiVOMXlcnHTTTcxb948WrRoQd++fenUqRMrV650Olqe6lrtFion1cZrEkhwJeMxXhqVaker1POcjha1FYvX8/j177Jh9TaCgRABf4ipE+bz1E3vOx1NRCR2WWJu6QVr7VZr7VnW2rqR4Z7bIvtnWmuvO+C4dtbactbaJGttVWvtt0do91lr7arjCkcMzcZpjDkXGAK4gbettQMPub8X2Rck/jMTwVBr7duI5BGvy8e1tQeyaNdvLN09ixRPaZqVPpvUhMpOR8thhz/3//ddeNgb3IzPXayAE0ksqF27Nj/88ANvvfUW99xzDw0aNGDw4MH897//jYsZO5PcKfStM4iNmSvZ4d9ExaRahXYWzs/fnkwgcPCw64A/yPzf/2LD6q1UrJbqUDIRkdhm4mvgSr6LiZ49Y4wbeBU4D6gPXGGMqZ/LoZ9aa5tENhV6cWR3YCdbsjY5PvTMbTw0KNmOS6reztkVr4nJQg8gNaEu2cuvHCxMiBRvnsz4K4WUy+WiX79+zJ8/n9atW3PDDTfQsWNHli+P3UmGolUhsQYnlWhZaAs9gDV/byIcyvn7zuvzsHFNzoloREREjkVMFHvAKcAya+3f1lo/8AnZCxRKnNsZ2M4LiwfQf8FtDFh4P/0X3MqfuxY4HSvmNSvbG88h1xd6TCINS1+G15XkUCqJJTVr1uS7777jrbfeYsaMGTRs2JBXX32VcFgzt8aCtOa18HjdOfb7/UFq1NUHNiIihxV7E7TEtOMq9owxV+dRjirAgVPIrYnsO9R/jDHzjDGjjDHV/iVXX2PMTGPMzM2bN+dRRMlr1lqGLH2Gv/cuJWiDBKyfHYHtvPH3C2zO2uh0vJiWmlCH86u+RPnEhriNj2Ke8rQsewPNU6878oOlyDDGcP3117NgwQJOO+00br75Zjp06MBff/3ldLQi7+I+p5OQ5MPl+v8e+oQkL526n0KpssUPOjZsQwTDmq1TRKSoMcakGmN6GmPujXxd2RhTNZo2jqrYM8bUz2VLA/57DLmP1VdATWttI+B7YMThDrTWvvXPoojlypUrsIASnb/3LmW7f+v+BZL/EQqH+HnzRIdSFR7lk9K4qPpr9K47kStqf05a6a5xcV2W5L3q1avzzTff8M477zB79mwaNWrEyy+/rF4+B5WtWJKXx9xGm04NSSmZRMVqZeh9b2dueOzi/cf4w5mMW/syzy7qxrOL/sPbf93KuowlzoUWEZECY4w5A1gMXAk8HNldF3g9mnaOdoKWacAocl4kVCOak/2LtcCBPXVV+f+JWIDsmW4O+PJt4Nk8Orc4ZGdgOyaXzxtChNiclWfrUYoI2b18ffr04ZxzzqFv377cdtttjBo1infffZc6dWJraZGionKNsvR/9fADZEateopV+xYQstm9ehsz/+Z/yx+kb52hlPJVLKiYIiLijJeAy6y1E40x/1zM/TvZl78dtaMdxrkIuMda2/vADZgbzcn+xQygrjGmljHGB1xO9gKF+/2zMn3ERZFMUohVT65FMJdFwH3Gx4nFc5ufR0SOV9WqVRk3bhzDhw9n3rx5NGrUiJdeeolQKOR0NDnA1qy1rN6Xvr/Q+0fIBpm+dexhHiUiEv+MzfstRtW01v4z1O2flH6iXE3hX4s9Y8w/jZ0N7Dj0fmttnqxka60NAjcD35JdxI201qYbY54wxlwUOexWY0y6MWYucCvQKy/OLc4pm1CelmVOxef6/4lG3MZDirc4p6a2czCZSHwzxtCrVy/S09Pp0KEDd9xxB6effjqLFy8+qseHwiFW7d3INv/ufE5adG33r8Ntcv49DxNkU9aKgg8kIhIrYmydvXy0MJeF1zsC86Np5EiV4QRjzCXW2l1RRTsG1trxwPhD9j1ywO0HgAfyO4cUrCurX0fN5BP4afP3ZIUzaVKyBedW6kKiWzNKiuS3KlWq8NVXX/G///2PW2+9lSZNmvDkk09y++2343bnnCkS4KeNc3hh8ecEbJBQOEyjUrV4uEFPSnq1tmNeKptQPUevHoDbeKmcdKIDiUREpIDdBXxtjBkHJBlj3gQuJMoVC440jHMOMNUYs3+xMWPM6caYn6MMK5Irl3HRrtxZPFx/IE82eIlu1a4ixVP8yA8UkTxhjKFnz54sXLiQc845h7vvvpu2bdvy559/5jj2z12rGLjoE3YH95EZ8hOwQebu+Jv+c99xIHl8K+WrQN3irfEY3wF7DR7jpWWZCx3LJSLiqPxYdiFGh3Faa6cBjYB04F1gOXCKtXZGNO38a7Fnrb2H7BlfphpjLjfGfA+MBL48ltAiIhKbKlWqxJdffsmHH37IkiVLaNKkCYMHDz7oWr6RqybjDx98nW3Qhli2Zx2r92mZm7zWpepdnFr2PyS7S+IxPuqktKB37Rcp7k11OpqIiOQzY0wCsNla+6y19iZr7UBgY2T/UTuaCVp+A3YBH5K9Fl4ta+3zUScWEZGYZoyhR48epKenc95553HvvffSpk0bFi5cCMCGzG3YXD4C9Rg3W7N2FnTcuOc2Hk4vfyV3nPwh99X/gstqPEpqQm5L0IqIFCFFpGeP7KXmmh+yrznZc5wctSNN0DIa+An4HOgKdAI6RHMCESkclu76iU+W92X4skv5bt1T7PSvczqSOKRixYp88cUXfPzxx/z11180bdqUgQMH0rT4CXhNzmv5AjbICSmVc2lJREQkbxWh2Tgbkr3UwoGmA42jaeRIPXtLgBOstU9Ya8cA5wJDjTE3RXMSEYlts7Z8zMT1z7Ilaxl7g1tYsmsSn674L7sCG5yOFjestWQF1xIIbXM6ylExxnD55ZezcOFCLrzwQh544AFev/JRwqv34Dmg4Et0+bisenuKe5MdTCsiIhJ3dgIVDtlXAdgbTSNHumbvPmvttgO+ng+0Ba6P5iQiErsC4QxmbH2foM08YG+YQDiTWVs/PujYzZlLWLRzPGv3zcHa2P0oLNbsyvyVeetOY/76s5i7tjV/bryCQGiT07GOSvny5Rk1ahQjR45kzarVTLnubRLGrqGipxQnF6/OvfUuo3etc52OKSIiRUXRGcb5OfCRMaaBMSbZGNMQeJ/s+VOOWlSL8gFYa9caY7QImkic2O5fjcu4c/yys4RYt28uAMGwn/FrH2RDRjoABkOKtxxdqr1Esqd0QUcuVDKDq1i6+VrCNmP/vt1ZM/hz41U0qPQtxsTs+j4H6d69O+3bt+eWW27h05c+punkprz33ns0qtDI6WgiIiLxqD/wPNlDNxOATGA48GA0jRzNBC05WGu1kq5InCjmKZvrel4AJbwVAZi59X3WZ8wnaDMJ2kwCNoMd/rVM2jC4IKMWSpt2v0/YBg/ZG8QfWsNe/xwnIh2zcuXK8cknn/D555+zdu1aWrRoweOPP47f73c6moiIFBVFpGfPWptprb0JKAZUBFKstTdbe9BQrCM6pmJPROJHMU8Zqhc7BfdB63mBxyTQPLUHAH/unEDIHvyG3hJi9d4ZBMNZBZa1MMoKrARyK6Zd+EPrCzpOnujatSsLFy6ke/fuPPbYY5xyyinMmTPH6VgiIhLn8mNylhieoAVjTEmgJdmTtZxpjOlgjIlqskwVeyLCOZUfpFZKG9zGi8ckkOguQYeKd1M5OXuI3uF6/iyWMKFc75NsxRNPxZCYY7+1AYr5GjqQKG+kpqby4Ycf8uWXX7Jx40ZatmzJo48+ql4+ERGRPGCM6QWsA74C3jlgezuadqK+Zk9E4o/XlcS5VR4hK7SHrNAeUrzlsq/ji6iZchpLdn2PjRR21maPevAYL2NW3UNaqQs4ueQ5Bz1GspVL6c7G3cMIhLZgIz18LpNE6eTzSfBUczhddALhDBbu+ILluyfhdSVTv1RXLrroItq1a8ftt9/OE088wejRoxk+fDjNmx+6NJCIiEgesIXjWvc88BTQzVo74XgaUc+eiOyX4E6hhK9ijqLt1HLXk+wpjcckkj0JpwswBG0WGzMXMWXjK3y7doATkWOe21Wc+hW/plxKD3zuSiR66lC11IPUKlO4rncMhrMYu6off2x9ly1Zi1mfMZvJG57i982vUqZMGd5//32++uortm7dSqtWrejfvz9ZWRri64SwDbEtaw17AludjiIiIsfOA3x3vI2o2BORI0r2lKFHrfc5rdyNVE1ujuHgYjBoM1m593c2ZS5xKGFs87pTqVHmcRpX+Y2GlX+gQvGeGFO4fv3+vfsHdgfWHXTtZtBmsmjnaPYGspeRuOCCC1iwYAE9e/bk6aefpnnz5syYMcOpyEXSX7t/5/WlV/DB8psY9tc1fLziTvYGC8fajiIiR6WITNACDAIeMsf5hqFwvdsQEcd4XUmklb6Qsol1CXPo7JIQtmHW7ZvnQDIpCKv2TjtkLcZsLjxsyJy//+vSpUszfPhwxo8fz44dO2jdujUPPPAAmZlRTR4mx2BL1kq+WvsUGaGdBGwmIRtgXcaffLbqQa2LKSJS+NwBPATsNsasOnCLphFdsyciUSnmTsVtfDlm53S7PFpzL44V85TD4N5/3eaBktw5v+/nnXce6enp3HXXXQwcOJAxY8YwfPhwWrVqVRBxi6TZ28bkmEzJEmKnfz0bM5dRMamuQ8lERPJOLM+emceuyotG1LMnIlE5seRZmFx+dbjwUCvlNAcSSUE4ueRFuMyhnw8afO4UKiU1yfUxJUuW5O233+abb75h9+7dtGnThnvvvZeMjIxcj5fjszOwAUs4x35jXOwJbnEgkYhIPigiwzittZMPt0XTjoo9EYlKsqc0F1Z7hmR3abwmCY9JpLinAhdXfx6vK+cSAxIfSifUpH3Fh/G5UvCaZDwmkZLe6pxfdcgRrz/s1KkT6enpXHfddQwePJimTZvy22+/FVDyoqNGsWZ4TEKO/SEboGLiiQ4kEhGRY2WMSTDGPGWM+dsYszOy7xxjzM3RtKNhnCIStSrJjeld5zO2Zi3HGBdlfDUxpshMhVxk1Sp+BtVT2rAtaxkek0QpX42j/r6XKFGCN998k27dunHddddx2mmncccddzBgwACSk5PzOXnR0KjUefyx7Uv2Brfvv67WaxJoUOpcUrypDqcTEckDMb4Ieh57EagCXAn8s/xCemT/0KNtRD17InJMjHFRNvEEUhNqqdArQtzGS7nEepROOLYC/+yzz2bBggX897//5YUXXqBJkyZMnTo1H5IWPQnuYvSs9SpNy3ShlLcS5RPr0LHiLXSocIPT0UREJHqXAD2stb9B9hh9a+1asgvAo6ZiT0REClTx4sV5/fXXmThxIoFAgHbt2nHHHXewb98+p6MVesmekpxZoS/X1XmPq2u9Slqps/VhjIjElyJyzR7g55BRmMaYckBUi6iq2BMREUd06NCB+fPnc+ONN/LSSy/RqFEjpkyZ4nQsERGJZUWn2PsMGGGMqQVgjKlE9vDNT6JpRMWeiIg4JiUlhaFDhzJp0iSstZxxxhnceuut7N271+loIiIiTnoQWA7MB0oBS4F1wOPRNKJiT0REHNe+fXvmzZvHrbfeyiuvvELDhg2ZNGmS07FERCTGGJv3Wyyy1vqttXdYa1OACkDxyNf+Iz32QCr2REQkJhQrVowhQ4YwZcoU3G43HTp04KabbmLPnj1ORxMRESlQxpja/2xAcaDWAV8fNRV7IiISU9q1a8fcuXO54447eP3112nYsCETJ050OpaIiEhBWkb20M1lB2xLI9tRU7EnIiIxJzk5mRdeeIGff/4Zn89Hx44d6devH7t27XI6moiIOKmITNBirXVZa92Rf11AZeAtoGc07ajYExGRmHXaaacxZ84c7r77boYNG0aDBg347rvvnI4lIiJSoKy1G4DbgWeieZyKPZEiLjO0j0mbPueVpffyzt8D+HPXLKcjiRwkKSmJwYMHM3XqVIoVK0anTp24/vrr2blzp9PRRESkIOXD5CyxOkHLYZwEJEfzAM+RDxGReOUPZzJ06f3sCGwhGJncacXePzmjfBc6Vrj0sI/bmrWOzNA+KiTWwOPyFlRcR4VtkCU7PuXvXaMJ2wDVUs6mfpleeF0pTkcrMlq3bs3s2bN57LHHGDx4MN988w1vvfUW5513ntPRRERE8pQx5mcOHmSaDKQBT0TTjoo9kSJsxtYf2XlAoQcQsFn8tGk0p6aeSzFPiYOO3+HfzIcrn2Zr1jpcxg3AhZX70bj06QWa2wlT19/LxowZhGwmAEt2fsy6vVM4p/qHuE3RKHhjQWJiIgMHDqRr16707t2b888/n969e/PCCy9QqlQpp+OJiEh+K1w9ccfj7UO+3gvMtdZqghYROTp/7p5FIJflWjzGw+p9B/8usdYyYvljbMxcRcD6yQpnkBXOYMza11ifsbygIjtie9bigwo9gLD1sy+4gTV7fnQwWdF1yimn8Mcff/Dggw/y/vvvk5aWxrhx45yOJSIikiestSMO2UZFW+iBevZEirQS3jIYDPaQj8nC2By9emszlrEruA1L+KD9QRtg2tZxXFL15nzP65Stmenk9lFi0GawOeMPahTvVPChhISEBJ566im6du1Kr169uOCCC7j66qt56aWXKF26tNPxREQkP8Rxz54x5qiGaFprHznaNtWzJ1KEtUk9D88hQxANLkp4SlM1qc5B+/cGd2By+ZVhCbMrsDVfczot2VMOk8tnYy6TQDFvFQcSyYGaN2/OzJkzeeihh/jwww9JS0tj7NixTscSEZE8Zoj7CVqqHcVWNZoGVeyJFGFVkmtzSZX/4nMlkuBKwmt8lE+oyrW1H8EYc9CxVZNPJGQDOdrwGh91izc/qvNZa1m7bwmLd01jd2BbnjyHglAx+VS8ruQcxa4LN7WKd3YolRwoISGBAQMGMH36dMqVK0eXLl246qqr2Lo1vj+IEBGRuDLLWtvbWtsbeOqf24dsfaJpUMM4RYq4ZmXOoGGpU1mfsYJEdzLlE3P/wKiYpySnlb2YX7eMJWCzAPAYL8W9qTQvfdYRz7MrsJUPlj/MrsAWXMZF0AZoWeZ8zq7YJ0dhGWtcxkOHqsP4dcOD7PQvw2BIdJfj1IoDSPSkOh1PDtCsWTNmzJjB008/zVNPPcUPP/zAG2+8wcUXX+x0NBERyQux1ROX154ChkZu/wGU+Jdjj4qKPZECELZhftk8iZ82/4Df+mleuhXnVryAJHdUS6XkG6/LR/ViJx7xuI4Ve1Al+QR+2zKOjNAe6pdoxallLyDBnXTEx45c9TTb/Ouyr/mL/KKete0bKifVpUGp2J/NM8VbhXOqjSAjuIWwDZLsqRDzRWpR5fP5eOyxx7j44ovp3bs3l1xyCVdccQUvv/wyZcuWdTqeiIjI4fxtjHkeSAe8xphce/Gste8ebYMq9kQKwPDlbzB35yz84eyZLydunMDs7TN4qP5T+Fw+h9NFp16JVtQr0Sqqx+z0b2ZT5sock7sEbBa/b/2qUBR7/0jyqFgoLJo0acL06dN55plnePLJJ5k4cSKvvfYa//nPf5yOJiIixyL2rrHLa5cB9wJXAF6gZy7HWOCoiz1dsyeSzzZkrmfOjpn7Cz2AoA2yI7CdmdumOZis4GSF9+Eyuf+6yQztLeA0UpR4vV4eeeQRZs6cSdWqVenWrRuXXXYZmzdvdjqaiIgcC5sPW4yw1i6x1l5nrT0bmGytPTOXrUM0barYk5izJ7iHOdvnsnT3MsI2fOQHxLgVe//KtdDxh7P4c/dCBxIVvLIJVXNdeNxtvNQrcaoDiaSoadSoEdOmTeOpp55i9OjR1K9fn5EjRzodS0REJFfW2v0TIhhjXAdu0bSjYk9iyrh1E7h99t288fcwnlv8IvfMvZ8NmRudjnVcSnlLkz1Z8ME8xkNZX7mCD+QAl3FzUZVb8ZiE/TNaekwCxT2lObXcJQ6nk6LC6/Xy4IMPMnv2bGrWrMlll11Gt27d2LixcP+OEREpUuK4Z+9AxphmxpjfjDF7gUBkC0b+PWoq9iRmLNy1iC/XjSVgA2SEMsgMZ7LVv43nFr+ItTH6f+JROLF4PVI8KbgOnbbfuGlbrr0zoRxwUolWXHfC8zQr04k6Kc05q0JP/lvnZZLcKU5Hy3eB8D4W7xjNzxueYN62EWQEC8+yE/EoLS2N3377jYEDB/LVV1+RlpbGxx9/XKh/z4iISNwZAUwCWgC1I1utyL9HTRO0SMz4YeOPB13XBmCx7ArsYsW+ldQqVtOZYMfJZVzcdVJ/3vzrFdZmrMZlDMXcKfSu1Y8yvqI1bX/5xOp0rnyD0zEKVEZwG1+v7oM/tIugzcRtfCzY9gGdqr5KauJJTscrsjweD/fddx8XXnghffr0oUePHowcOZLXX3+dihUrOh1PREQOI84naDlQDaC/Pc5PIlXsSczYG8x9og6XcZERyijgNHmrjK8sD9R7nB3+7fjDfsollNe0/UXEH1vfICO4FUsIgJD1E8LP1I1Pc1GNEQ6nk/r16zN16lRefPFFHnroIerXr8/LL7/MlVdeqf9HRURiUdEp9kYD5wDfHk8jGsYpMaN56Wa5LkMQsiFqF6vlQKK8V8pXmvKJ+bc+W0ZoH1+tG8UT6fcy6M9HmLZ1ioamOWz1np/3F3oH2uFfjj+024FEcii3283dd9/N3LlzOfnkk+nZsyddunRh3bp1TkcTEZGiKxEYbYz5zhjz/oFbNI2o2JOYcUa5dpRPKLe/4DMYfC4fPapfTqI70eF0sc8f9jPoz0f4fuPXbMhax8p9f/PJ6hF8vOqol2KRfODKZRZSyJ6yxxgNroglJ510Ej///DMvvPAC33//PWlpaYwYMUIfmBRywbCfP3f+yI8bhvLH1i/IDO1yOpKIHKv8mJwldn/FLwQGAVOBvw7ZjpreaUjMSHAn8GjaQ0zd/Ct/7JhDCW9xWpdpRVY4i0W7/uSk4icedq02gelbp7IjsJ2gDe7f5w9nMW3bL5xT8ULKJpR3MF3RdWLJi1iw/UNCNmv/PoOHSskt8bqSHEwmuXG73dxxxx1ccMEF9OnTh169ejFy5EjeeustqlSp4nQ8iVJmaDcfL7+VvcGtBGwmHpPAb1s+4NIaz1MuMao5DkRECpS19vG8aEfFnsQUn8vHmRXac2aF9oxZ+xUvLX0FT6T3I8mdxH0n302lpMIzecLMbTP4buM37A7upkGJhnSudCGlfKXy5VyLds/HH87Ksd9t3Czfu0zFnkMalr6azZnpbMyYs3/ZiWKeCpxWob/DyeTf1K1bl8mTJzN06FDuv/9+6tevz4svvkjv3r11LV8h8tvmD9gV2EQ4MlN50GaBzeKbdYPoWftNh9OJyLGI5wlajDGnW2unRG4fdvF0a+2PR9umij2JSQt2pvP1+vEEbXB/T1VmOJPnl7zI4EYDC8Wbra/WjmHCxvH7C7Apm39i5vYZPJ72JCW8JfL8fKm+srhxE8rl+rCS3lJ5fj45Om6Xj7OrvMi2rKVsy1pCiqcyFZKaFIqf4aLO5XJx6623cv7553Pttddy7bXXMnLkSIYNG0a1atXy/fzBcBbLdv/K3uBWKiXVp1JSPf3cRGnJrin7C70DbctaTUZwF0mevP9dLCJyHF4DGkRuv3OYYyxRLL+gMXESkyZunJRjGQaAXYHdrNi70oFE0dkX3Mf4DV8f1NMWIkRGaB8/bPwuX87ZrtxZuF3ug/YZDCme4tRJOTlfzilHr0xCXeqU6EzF5KZ6w17I1KlTh0mTJvHKK6/w888/k5aWxttvv52v1/JtzVrJsGVX8sP6l/hl07t8sep+Rq/uT+iAYdpyZG7jPux9RpcFiBROcXzNnrW2wQG3ax1mi2oMun7TSUzaGzrMMgwYMsKxvwzDmozV+4efHihogyzclZ4v5yyXUIG+tW8nxVOCBFcCXuOlalINbq/bX9c6ihwnl8vFzTffzPz582nRogXXX389nTp1YtWqVflyvq/XDCAztJuAzSBMkIDNZO2++czdNjZfzhev0kp1wm0OnuXZ4KJSUj0S3SkOpRKR42Fs3m/xTMM4JSadUqYly/euyNG7F8ZyQrHYv6i+pLcUQZtzOCVAakLZfDtv/RKNGNhwKBsz1+NzJeTruUSKotq1a/PDDz/w1ltvcc8995CWlsZzzz1H375986zHdqd/PbsCGzj04+agzWLBzm9olto1T85TFLRMvZw1++azMWMxYcK4jJtEV3HOq3Kf09FERAqEPu6XmHR6ubZUSqxIQmQZBhcufC4fPWv0IMGd4HC6I6uQWIEaxWrkGELkc/noVOHcfD23y7iolFRFhZ5IPnG5XPTr14/58+fTqlUr+vXrx9lnn82KFSvypH2LJXtxjlzuO8yHSJI7j8tHt+rP8p8agzi9/PWcX/kB+tQZQXGvJqwSKbTieBhnflCxJzHJ5/LxUP0HuarGlTQr1YTTy7XloXr3065cW6ejHbWb69zGiSkn4zEeElwJJLuLcU2NPtROOcHpaCKSB2rWrMn333/Pm2++yfTp02nQoAGvv/464XD4uNot6a1Esqd0jv0e46NeyY7H1XZRZIyhUlI9mpTpQu3irXH9y3V8IiLxxsT7YrEtWrSwM2fOdDqGFGE7AzvZF9xL+cQK/zpZgIgUXqtWreL666/nu+++o3379rzzzjvUrn3sQ843ZCzm81X3EbYhgjYLr0kiNaE63Ws8h8cV+6MbRKRwMMbMsta2cDrH0UqqUM3WufLOPG93wYt3FqrXIRrq2RPJZyW9JamUVFmFnkgcq169Ot988w1vv/02f/zxBw0bNmTo0KHH3MtXMekkrq3zPu3KX0/L1Ms4v8qDXFbzJRV6IlKkmXza4lnMFHvGmHONMYuNMcuMMffncn+CMebTyP2/G2NqOhBTREQkV8YYrr32WhYsWMDpp5/OLbfcwplnnsmyZcuOqb1EdwmalLmItuWvpXbxVhp+KCIiUYuJYs8Y4wZeBc4D6gNXGGPqH3LYtcB2a20d4EVgUMGmlPywJWsr83eksyVrq9NRRETyRLVq1Rg/fjzDhw9n7ty5NGrUiCFDhhz3tXwiIoImaIlSTBR7wCnAMmvt39ZaP/AJ0OWQY7oAIyK3RwFnGa1MXGgFwgFeXvIa9859iFeWvcG9cx9iyJLXCIQDTkcTETluxhh69epFeno6HTp04Pbbb+f0009nyZIlTkcTEZEiJFaKvSrA6gO+XhPZl+sx1togsBNIza0xY0xfY8xMY8zMzZs350NcOV6jVo9mzo75BGyAjFAGARtg7o75fLZ6tNPR4pY/7OeHjd/yzKIneHHxs8zePov8mKApbMP50q5IYVSlShW++uor3n//fdLT02ncuDHPP/88oZCWUBARORZaVD06sVLs5Slr7VvW2hbW2hblypVzOo7k4sdNUwjYg3vxAjbApE1THEoU3wLhAIMWPcnoNaNYvvcvFu1O553lb/LZmk/y7BybMtfzypKnuH321dw5pxcfrHiDjNC+PGtfCp4/tIeM4HanYxR6xhh69uzJwoULOeecc7j77rtp27Ytf/75p9PRREQKHw3jjEqsFHtrgWoHfF01si/XY4wxHqAkoAu9Cil/OCvX/VmH2S/HZ9b26WzK2kDA+vfv84ezmLxpItv8W9mctZEfNk7gh40T2JIVfW/43uAenl/8KEv3LMJiCdogs7b/xtClT6uXrxDaF9zKN2vu4KO/LuTT5V35fPmVbM5c5HSsQq9SpUp8+eWXfPjhhyxZsoQmTZowePBg9fKJiEi+iZVibwZQ1xhTyxjjAy4Hxh5yzFjgmsjtbsCPVu8iC606h1lYvK4WHM8X83fMy7WQdhk3o9eM5In0B/hy7Ui+XDuSx9Pv46dN30fV/rStkwmEA9gDPh4L2SAbMtexYt+xzUQozrA2zITVt7B+3x+ECRC2AXYGVjJh9a3sC25xOl6hZ4yhR48epKenc/7553PvvffSpk0bFi5c6HQ0EZHCQT17UYmJYi9yDd7NwLfAImCktTbdGPOEMeaiyGHvAKnGmGXAnUCO5Rmk8Li65pUkuhJxkz2VuBs3ia4Erq7Zw+Fk+S8rlMWMbTOYvHkym4+hF+1YlPSWwpXb/+42zOwd0wnYAEEbJGiDBGyAz9d8zDb/0b+xX5Ox8qBewwNtzFx3rLHFARsy5rI3uBnLwb1NYRti8c6vHEoVfypWrMjnn3/OJ598wl9//UXTpk155plnCAaDTkcTEZE44nE6wD+steOB8Yfse+SA25lA94LOJfmjRrFqPNPocSas/56V+1ZSI7kG51bqSLmEsk5Hy1d/7fmL55c8j7WWMNkTmXSs0JHuVbuTn5PLtit3BpM3/0j4kILMuAzhcO4fac3ePouzKnQ6qvarJdVirpmRa8FXKbFq9IHFMXsCG3LdH8bPTv+qAk4T34wxXHbZZZx55pncdNNNPPjgg3zxxRcMHz6cBg0aOB1PRCT2FIEJVfJaTPTsSdFUNiGVnjUv56H699Gz5uVxX+iFbIiXlr5ERiiDzHAm/rCfgA3w46YfWbgrf4dwVUqqTJ9afUl0JZHoSsLnSqBcQnnalj0j1+PtAf89Gq1TTyfBnYDh/wtWj/FQNakG1ZNrH194KVBlE0/CknM9OI9JpEJSYwcSxb/y5cvz2WefMXLkSFauXEmzZs148sknCQS0FI2IiByfmOnZE4l3S3cvJRjOOUQrK5zF5M2TSSuZlq/nb16mJY1LNWXlvhUkuHxUSarGxqwN/Lx5IiF78JA9AzQu1fyo284MZ9KtWi+mbZnMsj0LcRsPp5RpS5cqV+Rrj6XkvdIJtamS3JK1+2YQstnXebrwkOAuSZ0S5zicLr51796d9u3bc8stt/Dwww/zxRdf8N5779GoUSOno4mIxA717EVFxZ5IAQnYwEE9XwcqqFlIPS4PJ6TU2f91xcRKdK50MePWf0nYZvfmuIyLi6tcRtmEIy9b4g9n8fbfr7Jo1wI8xkPABjm93Nl0r3qlirxCrEPlJ1mw/RP+3DGGoM2kZsoZNE29Fq8r2eloca9cuXJ88sknXHrppdxwww00b96chx56iAceeACfz+d0PBERx2kYZ3RU7IkUkBNTTiScy/C4BFcCp6ae6kCibOdWuoimpVsyZ8csAJqVbkm5hApH9diPVr7Hwl0LCNrA/nUTf9kyifIJFWhf/ux8yyz5y2U8NCpzFY3KXOV0lCKra9eunH766dx222089thjjB49mvfee48mTZo4HU1ERAoRXbMnUkAS3An0rtkbn/Htn4U0wZVA3ZS6tCzTssDzHLhySYXESnSqeAGdKl5w1IVeIBxg5vZpBO3B1xX5w35+2DghT7OKFEVly5blww8/5Msvv2Tjxo20bNmSRx99FL8/95lvRUSKBC29EBX17IkUoFaprahZrCa/bPmFvcG9NC7VmIYlG+IyBfe5y7Stv/LF2lFs82+jlLc0F1fpStuy7aJuxx/OOmhdvQPtC+093pgiEtGlSxfatWvH7bffzhNPPLG/l69Zs2ZORxMRkRinnj2RAlYhsQL/qfofrq55NY1LNS7QQm/61mm8v/I9tvm3AbAjsJ2PVn3AL5unRN1WsrsYpbylc+w3GOqm1DvurCLy/8qUKcP777/PV199xZYtWzjllFN46KGHyMoqmOt9RURihbF5v8UzFXsihZi1ll82/8L98+7nxj9u5LnFz7Fq3+HXQvti7ef4wwcPAfOH/Xy57ouoz22M4coaffC5fPsnnnHjJtGdSNeql0Xdnogc2QUXXEB6ejo9e/bkqaeeonnz5sycOdPpWCIiBSM/hnCq2BORWPX1+q/5YNUHbMzaSEYog/Rd6Ty96GnWZqzN9fht/q257t8R2LF/Ns5o1C/RkHtPeoQWZVpTPbkm7cp14OH6T1MhsVLUbYnI0SldujTDhw9n3Lhx7Nixg9atW/PAAw+QmZnpdDQREYkxKvZECil/2M+49eNy7akbs3ZMro8pe5iF60t7Sx/zcNKqyTW4ttaNPFhvAJdXv5oyvtzPIXIsMoLbmbrxBT76uyufLb+Shdu/wB7DBxPx6Pzzz2fBggVcc801DBw4kGbNmvH77787HUtEJH/FWM+eMaaMMeZ7Y8zSyL85rnExxjQxxvxmjEk3xswzxhTYECgVeyKF1Nasrbmu22exLN+7PNfHdK3SHZ/r4LW6fC4fl1Tpli8ZRY6HP7SH0SuvZfHOr9gX3MzOwCqmb3mdKRsHOh0tZpQqVYp33nmHCRMmsHv3btq0acN9992nXj4RkYJzPzDRWlsXmBj5+lD7gKuttWnAucBLxphSBRFOxZ5IIVXSW5KgDeZ6X4XE3JdPaFGmJX1qXkf5hPIYDGV9Zbm6Rm/alD0tP6OKHJPFO78mK7yLMP//cx60mfy9eyK7A+sdTBZ7zj33XBYsWMC1117Ls88+S9OmTfntt9+cjiUikqcMMTlBSxdgROT2CODiQw+w1i6x1i6N3F4HbALKHfeZj4KKPZFCKtmTTJvUNrn21F1Y+cLDPq5FmVN4uuGzDGsxnIGNnqO1gwu6i/yb9RlzCNmcs0268LAlc7EDiWJbyZIleeutt/juu+/Yt28fp512GnfffTcZGRlORxMRyTv5M4yzrDFm5gFb3ygSVbDW/vMJ5AbgXxcsNsacAviAv6I4xzHTOnsihVjPGj3xuXxM2TKFkA1RwlOCHtV7cFLxk5yOJmTPluoPZ+Jx+XAbt9Nx8sx2/xoW75xIIJxJ7eKnUjmpIcbkHFJ8vEp4q2DwYDm4B9tiKeYpn+fnixdnn302CxYs4N577+X5559n7NixvPvuu7Rt29bpaCIisWqLtbbF4e40xvwAVMzlrv4HfmGttcYcvq/QGFMJ+AC4xhbQBegq9kQKMY/Lw5U1ruSyapeRFc4i2Z2cL2+6JXpLd8/jy7Vvsd2/GZdx07z0mVxYuRcel9fpaMclfcc3/LTxZcI2RJgw83d8Re3ip9Gp0v15/rNXv1RX/tw59qDhygY3xb2VKJeotRz/TfHixXn99dfp3r071157Laeffjq33XYbTz31FMnJyU7HExE5ZsYW/FoJ1tqOh7vPGLPRGFPJWrs+UsxtOsxxJYBxQH9r7bR8ipqDhnGKFFLBcJDft07njWVv8enqz9ju3xEXhZ61FpvHv8i3+bfwy+YfmLZ1MnuDe/K07dyszfib91cMZKt/A2FCBK2fWdsnMXL10Hw/d37KDO1m0saXCVo/YUKAJWAz+Xv3VFbtzfu13kr4qnBOlUEU81TAbXy48FIpqQnnVX0xLn7WC0KHDh2YP38+N954Iy+99BKNGjViypQpTscSEYknY4FrIrevAXJMiW6M8QGjgfettaMKMJt69kQKo2A4yDN/PsvqfWvICmfhwsVPmybTq9Y1nFa2cF6Dtz5jLR+vGsHSPX/iMR5apZ5Gt6pXkuhOPK52v98wlvHrv8BgMMYwctV79Kp1E41KHXa0xnGbvOlLgjZw0L6g9bNw13R2B7ZT3JtjVuZCYdXeWbiMh5A9eLmPgM3kz10/UiOlZZ6fs3JyMy6v9Rl7g5vwuJJIdJfI83PEu5SUFIYOHUq3bt3o06cPZ5xxBjfffDPPPPMMKSkpTscTETl6sbkI+kBgpDHmWmAlcCmAMaYF0M9ae11k3+lAqjGmV+Rxvay1c/I7nHr2RAqhX7ZMZdW+1WSFsyevCBPGbwOMWPEBWaGcE1rEul2BnTy7+AmW7FmExRKwAaZtncrQZc8dV7tr9q1gwvrRBG2AgPXjD2cRsH7eW/4qGaF9eZQ+p41Za7C5/DXyGC87Alvy7by5yQrtY+bWcUxY9yp/bPsGf+jYJ+twmcN9PmjwGN9h7jt+xhhSvBVU6B2n9u3bM3/+fG655RaGDh1Ko0aNmDRpktOxRESiEmuzcVprt1prz7LW1rXWdrTWbovsnxkp9LDW/s9a67XWNjlgm3PcL8ZRULEnUghN2zo9x2LqAC7jYtmeApncKU/9vHkSwfChPWEBVu1bzup9K4+53enbpuboYYPs12nBztnH3O6RVE+qi8nl12vQBkj1Vcq38x5qu389ry69jh83vssf2yfww4a3eW1ZX3YdY8FZo1gLyGWIrcf4qFfynOONKwWgWLFivPzyy0yePBm3202HDh246aab2LMn/4c3i4hIwVOxJ1IIJbmTct1vrSXBnVDAaY7f6v9r787Doyrv//+/3pNMEgICgQSQTUSqmIRFDCAgVEFUtCoKouKOSBWpdauiFcUPLtAULK2VCzfEHaWg8ivUFkRrFZUUCSQuiICsWnYCZJ/7+wfRH0qADMzkTE6ej+u6L2bOnMx5MWfOJO+5z7nvwm9VWllRpoC+K9p4xM9b7soq7WFzcio/yByFkXBGk4sPmBIjaIk6rfHZSo6vvtPm5m38q4rKC1RaMX1BqSvS3rKd+uemp47o+YKBJJ3f8kHFW6KCVkfxlqg4S1CXRpeqeXJGJKMjyvr06aPc3FzdfvvtmjJlijp06KAFCxZ4HQsADi86Uy/4FsUeUAP1bXLGAcWEJNWJS1Lbusd7kOjoHJfcRkE7cJTKkEI6NqnFET/vKSndlRA4sPgNuZDS63c+4uc9nMaJzXTzCY/oF/U6KSGQpIbBVJ3bbKjOO/baw/9whDgX0po9yw4odp1C+mb3kQ+mclzdLA1vN0NnNvuNejf5ta4+/ln1SLvuKNPCC8nJyZo0aZI++OADBYNBnXXWWbrpppu0a9cur6MBACKEAVqAGqhDw0yd2/RszfvuHcVZQJIpGAjqjpNuU8Bq3nc4p6eeqX99P09l5f9/T1y8BdUm+QS1TG59xM97Qt2T1DWllxZv/1AloWIFFKc4i9PAlkNVP9ggUvEr1azOcbqh7ZiobuPQTKaAnA6cxidwlHP+JcbV47RNH+nVq5dyc3P1wAMPaNKkSZo3b56eeeYZ9e/f3+toAHCAo73Grrah2ANqqEGtLtaZTc/QV7u+UnJ8XWXUP1nxgdg4pL/ZvVKfbvtEAZm6N+6hNofpbTwmWF/3tH9QM9a9qK8KPle8BdWjcW9d0vKyo8phZrqs9TB1b9xHS3csVkIgQac26qlmSc2P6nlrAjNT+/o99eWujxTab1LyOAsqo8EvPUyGWFSnTh1lZ2dr0KBBuv7663X22WfrxhtvVHZ2tho0iO4XIwCA6LFIz2cVa7KyslxOTuTnf4L/rdq9Wq+tnalv965VSkKKBrb4lU5r3M3rWDFvxrpX9f7mhSqtGHAlGAjqnKYDdFGLiz1OVvvsLdulF9eM1q7S/ynkQjIF1Dixpa5q86gS45hYG5UrKirS2LFjlZ2drebNm+vpp5/Wueee63UsAFFgZv91zkVvLqIIq5vaymWcf3vEn3fxC3fWqNchHLHRDQDEmNV71uiRL7J/HPFyb2Ghnl71vHaVFujsZv0O+bMloRIt+P49fbTlYwUDCerX9Jfq0bh7jTy9Mlxr936r9zcv/MlIoSWhEv3ju7k6rXEPNU1q5mG62ic5vr5GnPCEvt2zXFtLNigtsbVaJWcwITkOKSkpSePHj9cll1yi6667TgMGDNCwYcM0ceJENWzY0Ot4AGqzCEyVUNv4/69P4Ai8sW72AVMblIRK9Lf1b6osdPBRHMtCZXr48z9o5vrZWrN3rb7evVLTVr+kp1c9H+XEsWHp9s9+7NHbn5NT7o5cDxLBLKA29Trp1EbnqXXdTAo9VFm3bt20ZMkS3XvvvXr++eeVmZmpuXPneh0LABAGij2gEt/uWVvp8jJXrl1lBQf9uSXbl2pj4SaV7FfwFIeK9em2xdpYuCniOWNNMBCstAczoICCMXI94ZFyzmnRlvf02Bej9UDeb/X6uudVULrT61hAVCUlJenRRx/VJ598opSUFJ1//vm67rrrtH37dq+jAaitmHohLBR7QCVSExsf9LF68XUP+ljezs9VHCo+8AFn+qrg60hEi2lZjbopUMnHipNTl5SafSr8zHUvaOb6F7SxcJ22l2zRR5vf1YQvf6+9ZXu8jgZEXVZWlnJycnT//ffrpZdeUkZGhubMmeN1LADAYVDsAZW4uOWFB8xjlxBIUN8mfSqd3+4HKQkNFW8H9mAFLKAGwfoRzxlr0hLTdGXrqxVvQSUGEpUYSFTQgrr++OFqEOWpDqJpZ8l2fbR1oUr2K+TLVa69ZXv04RYmokbtkJiYqHHjxunTTz9VWlqaLrzwQl199dXatm2b19EA1BKmfdfsRbr5GcUeUInODTtqWJurVT9YX/EWr4RAgvo37avLW196yJ/rk3Z6pacxJgSC6tggM1pxY8rpaX2U3XGihra+Sle2vkbZnR5Xt0bdvY51VNYVrq60iC91JfqqID/q299VukOLtv5LH255RztKtkZ9e8ChdOnSRYsXL9aDDz6o1157Tenp6XrzzTe9jgWgtnAu8s3HavZFNEAU9UrroR6p3bWnbK/qxCVVaQ67xomNdNuJt2jKyqdVGipVSE4pwYa6/cRRMTMHXnU4JlhfvVJ7ex0jYhoGGylU2eTkCig1sWlUt7142/v62/qnZdo3sMqcjS/q/GOvVO+0AVHdLnAoCQkJGjt2rAYOHKjrr79eF198sa644gr9+c9/VmpqqtfxAAAVas9fn8ARCFhAxwTrhfUzHRpk6Ikuk7R273oFA/FqnnQsIyDWcC3qHKcmicdqY+E6hVT+4/I4i9cZaedEbbs7S7fpb+ufVpn76Qinf9/0strX76y0xGOjtm2gKjp37qxPP/1U48eP17hx47RgwQI9+eSTGjRokNfRAPiU30+7jDRO4wSiIGABtanbWi3qNKfQ8wEz08h2d6tdvfY/ntZbP76hbmj7WzWr0yJq283bufjHHr39ORfSsh0fR227QDiCwaDGjBmjnJwctWzZUoMHD9Zll12mzZs3ex0NAGo9evYAoAqOCTbQb068TwWlu1QcKlKjhNRKr8+MpJALyVUyJnRITuWuvJKfALzTsWNHffzxx8rOztbYsWP17rvv6sknn9Sllx76WmcAqLJaMFVCpNGzBwBhOCZYX6mJTaJe6ElSRoNTK10eb/Hq0KBb1LcPhCsYDOq+++7TkiVL1KZNGw0ZMkSDBw/W999/73U0AD5hocg3P6PYgy+VhEq1bEeecnfkqSRU4nUc4Ig0Smiic5oNUdASFFBApoCClqDeaefp2DqtvY4HHFRmZqYWLVqkxx57THPmzFFGRoZee+01OZ+PegcAsYbTOOE7y3bk6c8rp/543zmnUe1G6JSUjh6mAo7MmU0u1Mn1uyh3xyKFXEgdG3ZXizptvI4FHFZ8fLxGjx6tCy+8UMOGDdMVV1yhGTNmaMqUKWrWrJnX8QDUVHxnFBZ69uArBaUFevzrKSosL/qxFYWK9eeVU7WzdJfX8YAj0iyppc5pdqkGHHsZhR5qnPT0dH344YfKzs7WvHnzlJGRoZdffplePgCoBhR78JVPtv230uXOOS3aujji2ysJlWjGulkaueRO/TrnNj29arp2lRZEfDsAUJPFxcXprrvu0tKlS3XSSSfpqquu0kUXXaSNGzd6HQ1ADWMu8s3PKPbgK4XlRSoPHThKYZkrU2F5YUS35ZzThC//pHmb5mtn6S7tLt+jDzYv0pi8R7hOEAAq0b59e33wwQeaOHGi/vWvfykjI0MvvPACvXwAECUUe/CVDg3SFReIO2B5MBBUxwYZEd3Wyt2rtHrPWpXuN+F1ucpVULZbH2/Niei2AMAv4uLidMcddyg3N1eZmZm69tpr9atf/UobNmzwOhqAWOckORf55mMUe/CVNnVbq2fjbkoMJP64LDGQqG4pXdS2bpuIbuvbvevkdOB4vcWhYn2ze3VEtwUAfnPiiSfq/fff1+TJk7Vw4UJlZGRo2rRp9PIBOCRO4wwPxR58Z/jx1+g37UaoW8qp6prSRbe0G66bThgmM4vodpokpiqgA3sREwIJapbUNKLbAgA/CgQCuvXWW7Vs2TJ16tRJw4YN03nnnad169Z5HQ0AfIGpF+A7ZqZTUjpGfaqFzAbpqh88RiXFJQrt18MXb/Hqk9YjqtsGAD9p166dFi5cqCeffFL33HOPMjMzNWnSJA0bFvkv6gDUcD7viYs0evaAIxSwgB5Iv1uZDU5WnMUpzuLUtm4bPZh+t+rG1/U6HgDUKIFAQKNGjdLy5cvVpUsXDR8+XOeee67Wrl3rdTQAqLHo2QOOQkpCQ93T/jYVlxcrJKc6cUleRwKAGq1t27ZasGCBpk6dqt/97nfKzMxUdna2RowYQS8fUMuZ/H+NXaTRswdEQGJcIoUeAERIIBDQzTffrLy8PHXt2lU33XST+vfvrzVr1ngdDYCXojESp88HhaLYAwAAMalNmzaaP3++pk6dqk8++USZmZmaMmWKQqEDR0IGAByIYg+1RmmoVGWhMq9jAADCYGYaMWKE8vLy1LNnT40cOVL9+vXTqlWrvI4GwANMvRAeij343sbC7/RQ/gQNWzxKw3JG6fEVT6qgtMDrWACAMBx33HF655139Mwzz2jJkiXq0KGD/vKXv9DLBwCHQLEHX9tTtkdj88fr693fKKSQyl25Ptu+TOO+yFbI8QcCANQkZqYbbrhBeXl56tOnj2699VadeeaZWrlypdfRAFQXF4XmYxR78LV/b16kUlcqt9+RXK5ybS3epi92feVhMgDAkWrVqpXmzp2radOmKTc3Vx07dtTkyZPp5QNqAU7jDA/FHnxtQ+FGlYRKDlgeck7fFf3Pg0QAgEgwM1133XXKz89X3759ddttt6lPnz5asWKF19EAIGZQ7MHX2tZto8RAwgHLzaTWyS09SAQAiKQWLVpozpw5mj59uvLz89WpUydNnDhR5eXlXkcDEGlOUshFvvkYxR58rWdqdyXHJSuw31s9aPFqndxK7eq19TAZACBSzEzXXHON8vPzdfbZZ+uuu+7S6aefri+//NLraADgKYo9+FpSXKLGZf5e3RtnKSmQqLpxddWv6Rka3f52mZnX8QAAEdS8eXO9+eabevnll7VixQp17txZ2dnZ9PIBfsIALWGJ9zqAmTWSNENSG0lrJA1xzm2vZL1yScsr7q51zl1YXRlRs6UkNNSodjd6HSOm7SzdqfV7Nyo1sbGaJjXxOg4AHDEz09ChQ9W3b1/dfPPNuvvuuzVz5kxNmzZN6enpXscDgGoVCz17oyUtcM79QtKCivuVKXTOda5oFHpABIRcSNNXv6TbP7tHk79+Uvcue1Djv5iowvIir6MBwFFp1qyZZs2apVdffVXffPONTjnlFI0fP15lZWVeRwNwFBiNMzyxUOxdJGl6xe3pkgZ6FwWoXeZ/v1D/3vKRSl2ZCssLVepK9VXB13pu1QteRwOAo2Zmuvzyy5Wfn68LLrhA9957r3r06KG8vDyvowE4Us5FvvlYLBR7TZ1zmypufyep6UHWSzKzHDP72MwGHuoJzWxExbo5mzdvjmRWwFfe+W7+AVNTlLky5WxfouLyYo9SAUBkNW3aVDNnztTrr7+uNWvW6NRTT9Ujjzyi0tJSr6MBQFRVS7FnZvPNLK+SdtH+6znnDnWZ5HHOuSxJQyX9ycxOONj2nHNPOeeynHNZaWlpkfuPAD6zt3zvQR+rbH5CRF5ZqEz/3Z6jtzbM1sdbP1IprzsQNZdeeqk+//xzDRw4UPfff79OO+00LVu2zOtYAMLAaZzhqZYBWpxzZx3sMTP73syOdc5tMrNjJVU607VzbkPFv6vM7D1Jp0j6Jhp5gdoivf7JWrztv3I/+44lJdhQ9eLreZSqen2w+T96a+Mc7SjZqRZ1muvy1kN0cv321bLt3WW79dgX47SzdKeKQkVKDCTqjfUzdF/7MWqcmFotGYDaJi0tTTNmzNCQIUM0cuRIZWVlacyYMRo9erSCwaDX8QAgomLhNM63JV1bcftaSW/9fAUzSzGzxIrbqZJ6Sfq82hICPnVZq0FKjqujeNv3vU9AASUEEjSs7TW1YmqKf343Xy98+7I2F29RqSvVmr3fatKKyfqqYEW1bH/m+hnaUrJFRaF9A+IUh4pVUFqg59c8Vy3bB2qzQYMGKT8/X4MHD9YDDzygbt26aenSpV7HAnAo0Zh2wec9e7FQ7I2X1N/MvpZ0VsV9mVmWmT1Tsc7JknLMLFfSQknjnXMUe8BRapKUpvEd/0/nNDtLv6h3gk5P7aGHMn6vzAb+H5683JVr9oa3DjhdtSRUopnrZlVLhv9uz1G5++n8XyGF9FXBlyoLMWIgEG2pqal65ZVXNHv2bG3atEldu3bV2LFjVVLC6dRALDJJ5lzEm595Ps+ec26rpH6VLM+RNLzi9keSOlRzNKBWaJjQUJe3Hux1jGq3p2yPSkOVD86wvnBDNacB4KWBAweqT58++u1vf6uHHnpIs2fP1rRp09SlSxevowHAUYmFnj0AqHbJccmKs8o/ApskVs/ATl1TuinO4n6yzGRKr5+h+IDn38UBtUqjRo304osv6u2339bmzZvVrVs3jRkzRsXFjEwMxJRQFJqPUewBqJXiA/Ea0OwcJQQSfrI8IZCgS1oOrJYMg1sOUdPEpkoMJMlkSgwkqWEwRde0ub5atg/gQBdccIHy8/N11VVX6eGHH9app56qnJwcr2MBwBHhq2MAtdZFLS5UXCBeczfNU2F5kVISGuqKVpepU8OO1bL95Pi6GpvxsPJ2LtP6wvVqkthEnRt2oVcP8FhKSoqef/55XXrppRoxYoROO+00/e53v9ODDz6opKQkr+MBtZrfr7GLNHM+f8GysrIc38gBOBTnnMpcmeItvlaMQgqg6nbs2KE777xTzz33nE4++WRNmzZN3bt39zoWEBFm9t+KeaxrhPrHtHRds26J+PO++959Nep1CAencQKo9cxMwUCQQg/AARo2bKhnn31W8+bNU0FBgXr27Kl77rlHRUVFXkcDgMOi2AMAADiMc889V3l5ebrhhhv0hz/8QaeccooWLVrkdSyglnGSi0LzMYo9AACAKmjQoIGeeuopvfPOO9q7d6969eqlu+66S4WFhV5HA4BKUewBAACE4eyzz9by5cv161//WhMnTlTnzp314Ycfeh0LqBXMRb75GcUeAERZWahMGws3qqC0wOsoACKkfv36mjJliubPn6+SkhL17t1bt99+u/bu3et1NAD4EeN7A0AUvfv9u3pj/RuSpDJXpk4NO2n48cOVFMfw7YAf9OvXT8uXL9fo0aP1pz/9SXPmzNFzzz2nPn36eB0N8CefX2MXafTsAUCULNuxTDPWz1BRqEhFoSKVuTIt27FMT6962utoACKoXr16euKJJ7Rw4UKFQiH98pe/1K233qo9e/Z4HQ3wFydZKPLNzyj2ACBK/r7p7yoJlfxkWakr1bKdyzilE/ChM844Q8uXL9ett96qv/zlL+rYsaPee+89r2MBqMUo9gAgSraXbq90ebzFq6CMYg/wo7p162ry5Mn697//rUAgoDPPPFO33HKLdu/e7XU0wB+YeiEsFHtADNhbtldzN/1Tk1dM0cx1b2lbSeVFAmqWk445SYGDfMymJaZVcxoA1al3797Kzc3V7bffrilTpqhDhw569913vY4FoJah2AM8tq1ku+5aNkZvrH9Ln25fojmb/qHf5Y7Rqt1rvI6Go3RR84uUFJf0k4IvIZCgS1teqmAg6GEyANUhOTlZkyZN0gcffKBgMKh+/frp5ptvVkEBPfvAEXNRaD5GsQd4bMbaWSoo3f3jtV1lrkxFoWI9tWq6x8lwtFITU/VQxkPqldpLaYlpOrHeibrlhFvUt2lfr6NFXEmoRF8VfKHVe75RyPn8ancgTL169VJubq7uvPNOTZ06VZmZmZo/f77XsYAayZyLePMzpl4APPbZjmUK6cA/jjcWbdTesr1Kjk/2IBUiJTUxVcOOH+Z1jKj6dOsivbz2WZkCcnJKjkvWqF/cpRZ1WnkdDYgZderU0R//+EcNGjRI119/vfr3768bb7xR2dnZatCggdfxAPgUPXuAxxICCQd5xBQf4PsYxLZNhRv04rfPqDhUrKJQoYpDRdpeuk1/WjFe5a7M63hAzOnRo4c+++wz3X333Xr22WeVmZmpf/zjH17HAmoOBmgJC8Ue4LG+TfoowX56/Vac4tS5YYdDFIJAbPjPlvcqLepKQyX6ctfnHiQCYl+dOnU0YcIEffTRRzrmmGM0YMAADRs2TDt27PA6GgCfodgDPHZh8wHq0CBDCYGgkgJJSgwkqmVyc914/LVeRwMOq6BsV6WnITtJu5leAjik7t27a8mSJbr33nv1wgsvKDMzU3PnzvU6FhC7nKRQFJqPcY4Y4LH4QLzuOOkWbSjcpLV71yktMVUn1D1eZuZ1NOCwOjTorKU7/quSUPFPlpe7cp14zMkepQJqjqSkJD366KO65JJLdP311+v888/Xtddeq8cff1wpKSlexwNiisn/A6pEGj17QIxoUedY9WjcTe3qtaXQQ43RJaWrWtRp9ZNTjhMCierb5BylJDTyMBlQs2RlZSknJ0f333+/XnrpJWVkZGjOnDlexwJQw1HsAQCOWJzF644T79PgllfqxHonq2ODU3Rj21G6pOVlXkcDapzExESNGzdOn376qdLS0nThhRfq6quv1rZt27yOBsQOBmgJC6dxAgCOSjAQVJ+0vuqT5r/5AwEvdOnSRYsXL9ajjz6qRx55RPPnz9eUKVM0cOBAr6MBqGHo2QMAAIgxCQkJGjt2rBYvXqymTZvq4osv1tChQ7VlyxavowHeomcvLBR7AAAAMapz585avHixHnroIc2cOVMZGRmaNWuW17EA1BAUewAAADEsGAzqgQceUE5Ojlq2bKlBgwbpsssu0+bNm72OBlQvpl4IG8UeAABADdCxY0d9/PHHevjhhzV79mylp6frjTfe8DoWUK3MuYg3P6PYAwAAqCGCwaB+//vfa8mSJWrTpo2GDBmiwYMH6/vvv/c6GoAYRLEHAABQw2RmZmrRokV67LHHNGfOHGVkZOjVV1+V83kvBcAALeGh2ENYyl25crYt1evr3tJ7//tQReXFXkcCAKBWio+P1+jRo/XZZ5/phBNO0NChQ3XJJZfou+++8zoagBhBsYcq21tWqHuXjdNfVz6r2Rv+rufXvKZbP7tXGwv5pQIAgFfS09P14YcfasKECZo3b57S09P18ssv08sHH4pCr57PjxOKPVTZ39bP0aai/6kotK83rzhUrN1lezRl5TSPkwEAULvFx8fr7rvv1tKlS3XSSSfpqquu0sCBA7Vp0yavowGR40SxFyaKPVTZh1s/VZkr+8kyJ6fVe9dqT9lej1IBAIAftG/fXv/5z380ceJE/fOf/1R6erpefPFFevmAWopiD1VmskM8BgAAYkFcXJzuuOMO5ebmKiMjQ9dcc40uuOACbdiwwetowNFjnr2wUOyhynqnnqagxf9kmcl0Qt02So5P9igVAACozIknnqj3339fjz/+uN59911lZGRo2rRp9PIBtQjFHqrskpa/UqvkFkoKJCqggJICiaofPEYj2w3zOhoAAKhEXFycbrvtNi1btkwdO3bUsGHDdN5552ndunVeRwOOSKxNqm5mjczsX2b2dcW/KZWsc5yZLTGzpWaWb2Y3HdVGwxB/+FWAfZLiEjUu817l7fxSa/asVVpiY2U16qxgIOh1NAAAcAjt2rXTe++9pyeffFL33HOPMjMzNWnSJA0bNkxmXIyBGiT2eqZHS1rgnBtvZqMr7t/zs3U2SerhnCs2s3qS8szsbefcxmiHo2cPYQlYQB0bpuvCFueqR2pXCj0AAGqIQCCgUaNGafny5erSpYuGDx+uc845R2vXrvU6GlCTXSRpesXt6ZIG/nwF51yJc+6HyakTVY01GMUeAABALdK2bVstWLBAf/3rX/XRRx8pIyNDU6dO5Vo+xD4nKeQi36RUM8vZr40II1VT59wPc5x8J6lpZSuZWSszWyZpnaQJ1dGrJ1HsAQAA1DqBQEAjR47U8uXL1a1bN910003q37+/1qxZ43U0wAtbnHNZ+7Wn9n/QzOabWV4l7aL913P7vjGp9FsT59w651xHSe0kXWtmlRaFkUaxBwAAUEsdf/zxmj9/vqZOnapPPvlEmZmZmjJlikIhn49HjxoqChOqV6FH2zl3lnMus5L2lqTvzexYSar493+Hea6NkvIk9Y7AC3JYFHsAAAC1mJlpxIgRysvLU8+ePTVy5Ej169dPq1at8joaUBO8LenaitvXSnrr5yuYWUszq1NxO0XS6ZK+qo5wFHsAAADQcccdp3feeUdPP/20lixZog4dOuiJJ56glw+xxYOevcMYL6m/mX0t6ayK+zKzLDN7pmKdkyV9Yma5kt6X9Efn3PKj3XBVUOwBAABA0r5evuHDhysvL099+vTRb37zG5155plauXKl19GAfWKs2HPObXXO9XPO/aLidM9tFctznHPDK27/yznX0TnXqeLfpw79rJFDsQcAAICfaNWqlebOnatp06YpNzdXHTt21OTJk+nlA2oYij0AAAAcwMx03XXXKT8/X3379tVtt92mPn36aMWKFV5HQ20VvakXfItiDwAAAAfVokULzZkzR9OnT1d+fr46deqkSZMmqby83OtoAA6DYg8AAACHZGa65pprlJ+fr/79++vOO+9U79699dVX1TKgIFDBSS4U+eZjFHsAAACokubNm+utt97SSy+9pC+//FKdOnVSdnY2vXyoPjE2QEuso9gDAABAlZmZrrzySn3++ecaMGCA7r77bvXq1UtffPGF19EA/AzFHgAAAMLWrFkzzZo1S6+88opWrlypU045RRMmTFBZWZnX0eBXDNASNoo9AAAAHBEz0xVXXKH8/Hydf/75Gj16tHr27Km8vDyvowEQxR4AAACOUtOmTTVz5kzNmDFDq1ev1qmnnqpHHnlEpaWlXkeD33DNXlgo9gAAAHDUzExDhgzR559/roEDB+r+++/XaaedpmXLlnkdDX5CsRcWz4s9M7vUzPLNLGRmWYdY71wz+8rMVprZ6OrMCAAAgKpJS0vTjBkzNHPmTK1fv15ZWVkaN24cvXyABzwv9iTlSbpE0r8PtoKZxUn6q6QBktIlXWFm6dUTDwAAAOEaNGiQ8vPzNXjwYD3wwAPq1q2bli5d6nUs1GhR6NWjZy+6nHNfOOcONyNnN0krnXOrnHMlkl6TdFH00wEAAOBIpaam6pVXXtGsWbO0adMmde3aVWPHjlVJSYnX0YBawfNir4paSFq33/31FcsqZWYjzCzHzHI2b94c9XAAAAA4uIsvvlj5+fm6/PLL9dBDD2nhwoVeR0JN5CSFQpFvPlYtxZ6ZzTezvEpaVHrnnHNPOeeynHNZaWlp0dgEAAAAwtC4cWO9+OKLWrx4sc455xyv4wC1Qnx1bMQ5d9ZRPsUGSa32u9+yYhkAAABqkKysg47HBxyez6+xi7RqKfYiYLGkX5jZ8dpX5F0uaai3kQAAAABUK4q9sHh+zZ6ZXWxm6yX1kPR3M3unYnlzM5srSc65MkmjJL0j6QtJrzvn8r3KDAAAAACxzvOePefcbEmzK1m+UdJ5+92fK2luNUZDhBSVF2vR1sVas2etWtVpoV5p3VUnLsnrWAAAAKhRnBSiZy8cnhd78Letxdt1f96jKiwvVHGoRImBBL2x/m2Ny7xXTZJSvY4HAAAA+Jbnp3HC36Z/+5p2le5ScWjffDrFoRIVlO3Ws6tf8jgZAAAAahQnOReKePMzevYQVUu35ymkn3a3Oznl7fxCIRdSwPi+AQAAAFXEaZxh4S9tRNXBijmzgExWzWkAAACA2oNiD1HVM7Wr4i3uJ8viLE7dGnWRGcUeAAAAwuBc5JuPUewhqq5qPVgt6zRXUiBRQQsqKZCoZklNdH2bK7yOBgAAAPga1+whqpLjk/Voh/v1xa4VWl+4UcfWaaqM+u25Vg8AAADhcU4K+XtAlUij2EPUmZnSG5yk9AYneR0FAAAANZnPT7uMNLpXAAAAAMCH6NkDAAAAUCM4TuMMCz17AAAAAOBD9OwBAAAAqAH8P1VCpNGzBwAAAAA+RM8eAAAAgNjnJIXo2QsHxR4AAACAmsExQEs4OI0TAAAAAHyInj0AAAAAMc9JcpzGGRZ69gAAAADAh+jZAwAAABD7nOOavTBR7AEAAACoETiNMzycxgkAAAAAPkTPHgAAAICagdM4w0LPHgAAAAD4kDnn7/NezWyzpG89jJAqaYuH2wf7IFawH7zHPvAe+8B77APvsQ9iQ6qkus65NK+DVJWZ/UP7ckfaFufcuVF4Xs/5vtjzmpnlOOeyvM5Rm7EPYgP7wXvsA++xD7zHPvAe+yA2sB9qB07jBAAAAAAfotgDAAAAAB+i2Iu+p7wOAPZBjGA/eI994D32gffYB95jH8QG9kMtwDV7AAAAAOBD9OwBAAAAgA9R7AEAAACAD1HsAQAAAIAPUexFmJmNMrMcMys2s+ersP7tZvadme0ys+fMLLEaYvqamTUys9lmtsfMvjWzoYdYd6yZlZrZ7v1a2+rM6xdVfd1tnwlmtrWiTTAzq+68fhTGPuB9HyXh/A7g8z86qroPzOw6Myv/2XFwRrUF9TEzSzSzZys+hwrMbKmZDTjE+hwLERbOPuBY8DeKvcjbKOlhSc8dbkUzO0fSaEn9JB0nqa2kh6Karnb4q6QSSU0lXSlpipllHGL9Gc65evu1VdWS0n+q+rqPkDRQUidJHSVdIOnX1ZTR78J57/O+j44q/Q7g8z+qqvx7WNKinx0H70U3Wq0RL2mdpF9KaiDpfkmvm1mbn6/IsRA1Vd4HFTgWfIpiL8Kcc7Occ29K2lqF1a+V9KxzLt85t13SOEnXRTGe75lZXUmDJI1xzu12zv1H0tuSrvY2mb+F+bpfK2mic269c26DpInifX/UeO/HhjB+B/D5HyVh/h5GFDjn9jjnxjrn1jjnQs65/0/SakmnVrI6x0IUhLkP4GMUe97KkJS73/1cSU3NrLFHefzgREllzrkV+y3L1b7X+mAuMLNtZpZvZjdHN55vhfO6V/a+P9T+QdWE+97nfe8tPv9jwylmtsXMVpjZGDOL9zqQH5lZU+37jMqv5GGOhWpwmH0gcSz4FjvSW/Uk7dzv/g+3jxHfSB6pepJ2/WzZTu17TSvzuvZNKvq9pO6S/mZmO5xzr0Yvoi+F87pX9r6vZ2bmmPjzaISzD3jfe4/Pf+/9W1KmpG+1r+CYIalM0mNehvIbMwtKelnSdOfcl5WswrEQZVXYBxwLPkbPXhjM7D0zcwdp/zmCp9wtqf5+93+4XXD0af2pCvvg56+pKu5X+po65z53zm10zpU75z6SNFnS4Oj+L3wpnNe9svf9bgq9o1blfcD7Pibw+e8x59wq59zqilPclkv6P3EcRJSZBSS9qH3XEo86yGocC1FUlX3AseBvFHthcM6d4Zyzg7TTj+Ap87VvkIofdJL0vXOOb7IOogr7YIWkeDP7xX4/1kkHP23hgE1IYmTI8IXzulf2vq/q/sHBHc17n/d99ePzP/ZwHERQxSjLz2rfgFGDnHOlB1mVYyFKwtgHP8ex4CMUexFmZvFmliQpTlKcmSUd4rznFyTdYGbpZtZQ+0ZKer56kvqTc26PpFmS/s/M6ppZL0kXad+3Wgcws4vMLMX26SbpVklvVV9ifwjzdX9B0h1m1sLMmku6U7zvj1o4+4D3ffSE8TuAz/8oqeo+MLMBFdcxyczaSxojjoNImiLpZEkXOOcKD7Eex0L0VGkfcCz4nHOOFsEmaaz2fSOyfxtb8Vhr7TtdofV+69+hfdfN7JI0TVKi1/+Hmt4kNZL0pqQ9ktZKGrrfY72175TBH+6/qn3XBOyW9KWkW73OX1PbwV73Sl5zk/QHSdsq2h8kmdf5/dDC2Ae876O3Dyr9HcDnf+ztA0l/rHj990hapX2nrgW9zu+Hpn1TKDhJRRWv+Q/tSo6F2NsHHAv+blaxkwEAAAAAPsJpnAAAAADgQxR7AAAAAOBDFHsAAAAA4EMUewAAAADgQxR7AAAAAOBDFHsAAAAA4EMUewAAAADgQxR7AICoMLM/mNmb+93PNrMFZpbgYSwAAGoNJlUHAESFmTWWtErSGZK6S7pF0unOuZ1e5gIAoLag2AMARI2ZjZV0iaQG2lforatYPkFST0lrJA1zzpV6lREAAL/iNE4AQDR9JqmDpHv3K/Q6SWrhnOst6UtJgz3MBwCAb1HsAQCiwsw6SJoiabqkYfs91FPSPytu/0NSr2qOBgBArUCxBwCIODNrIWmOpJskjZTUwczOqHg4RdKuits7JTWq7nwAANQGFHsAgIgys/qS5kqa5Jx72zm3V1K2pEcqVtkhqX7F7QaStlV7SAAAagEGaAEAVCsz6yzpDufcNWZ2n6TVzrlXPY4FAIDv0LMHAKhWzrmlkr43sw8kZUj6m7eJAADwJ3r2AAAAAMCH6NkDAAAAAB+i2AMAAAAAH6LYAwAAAAAfotgDAAAAAB+i2AMAAAAAH6LYAwAAAAAfotgDAAAAAB+i2AMAAAAAH/p/hiUNWnGIQEoAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -572,8 +573,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average mislabelled data influence: -0.7335035023958383\n", - "Average correct data influence: 0.00799189782482135\n" + "Average mislabelled data influence: -0.7414471365061857\n", + "Average correct data influence: 0.00813213261992543\n" ] } ], @@ -600,7 +601,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -661,8 +662,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average mislabelled data influence: -0.7335032648603442\n", - "Average correct data influence: 0.007991897833854632\n" + "Average mislabelled data influence: -0.7414468874499299\n", + "Average correct data influence: 0.00813213256671605\n" ] } ], @@ -699,7 +700,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index 1ffbe67fe..cc257a35f 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -55,8 +55,7 @@ "import numpy as np\n", "import torch\n", "import torch.nn.functional as F\n", - "from notebook_support import plot_train_val_loss\n", - "from pydvl.influence.model_wrappers import TorchMLP\n", + "from notebook_support import plot_losses, TorchMLP, fit_torch_model\n", "from pydvl.influence.general import compute_influences\n", "from pydvl.utils.dataset import load_wine_dataset\n", "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, f1_score\n", @@ -169,7 +168,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9001287c81bb4cc08a9e27c420f2e260", + "model_id": "ce404d963a144702b0cdd559dce44fa2", "version_major": 2, "version_minor": 0 }, @@ -198,7 +197,8 @@ "optimizer = Adam(params=nn_model.parameters(), lr=lr, weight_decay=weight_decay)\n", "scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=num_epochs)\n", "\n", - "train_loss, val_loss = nn_model.fit(\n", + "train_loss, val_loss = fit_torch_model(\n", + " model=nn_model,\n", " x_train=train_data[0],\n", " y_train=train_data[1],\n", " x_val=val_data[0],\n", @@ -227,7 +227,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7MAAAHmCAYAAAChwtkCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAABNmklEQVR4nO3dd5xcZ33v8e9vyvbetNKutLsqliV3W+4GbHDAJsYU5xJjE0wzIYmTQMKLy00Bm5tyyYUklxAgBoxtIBAgYGoIGDAYd7lbkot6tbRarbbXmef+cc7szs4W7a525kz5vF+veZ0zp81vraOxvvs853nMOScAAAAAAHJJKOgCAAAAAABYKMIsAAAAACDnEGYBAAAAADmHMAsAAAAAyDmEWQAAAABAziHMAgAAAAByTiToAk5GQ0ODa29vD7oMAAAAAEAaPP7440edc40z7cvpMNve3q7NmzcHXQYAAAAAIA3MbM9s++hmDAAAAADIOYRZAAAAAEDOIcwCAAAAAHIOYRYAAAAAkHNyegAoAAAAAMgFY2Nj2r9/v4aHh4MuJeuUlJSotbVV0Wh0QecRZgEAAAAgzfbv36/Kykq1t7fLzIIuJ2s459TV1aX9+/ero6NjQefSzRgAAAAA0mx4eFj19fUE2RRmpvr6+kW1WBNmAQAAACADCLIzW+x/F8IsAAAAACDnEGYBAAAAACft6quv1l133ZWxz2MAKAAAAAAoUBUVFRPrg4ODKi4uVjgcliT927/9m2688cZ5X+u//uu/lry+uRBmAQAAAKBA9ff3T6y3t7fri1/8oq688sppx42PjysSya74SDdjAAAAAMAU9913n1pbW/WJT3xCzc3Nete73qXu7m5dc801amxsVG1tra655hrt379/4pzLL79cX/ziFyVJd955py677DJ96EMfUm1trTo6Opa85ZYwCwAAAACY5uWXX9axY8e0Z88e3X777YrH43rXu96lPXv2aO/evSotLdUtt9wy6/mPPPKI1q9fr6NHj+rDH/6w3vOe98g5t2T1ZVc7MQAAAADkudt+sEVbD/am9TM2rqjSx95w2kldIxQK6bbbblNxcbEkqbS0VNddd93E/r/8y7/UFVdcMev5bW1tuvnmmyVJN910k/7wD/9Qhw8fVnNz80nVlUCYBQAAAABM09jYqJKSkon3g4OD+uAHP6if/OQn6u7uliT19fUpFotNDBqVLDm0lpWVSZr6jO7JIsym0+igFBuVSmuCrgQAAABAljjZFtNMMbMp7z/1qU/phRde0COPPKLm5mY99dRTOuecc5a06/BC8MxsuoyPSv9nlfTQvwZdCQAAAACctL6+PpWWlqqmpkbHjh3TbbfdFmg9hNl0iRRJdR3Ska1BVwIAAAAAJ+0DH/iAhoaG1NDQoIsuukhXXXVVoPVYUE3CS2HTpk1u8+bNQZcxu2++Qzr0jPSnTwVdCQAAAIAAbdu2TRs2bAi6jKw1238fM3vcObdppnNomU2nptOk7t3S6EDQlQAAAABAXiHMplPTBklO6nw+6EoAAAAAIK8QZtNpmT9K2WGemwUAAACApUSYTafadilSKh3ZFnQlAAAAAJBXCLPpFApLjeulI1uCrgQAAAAA8gphNt2WnUY3YwAAAABYYoTZdGvaIA0ckQaOBl0JAAAAAOQNwmwaHR8cVU/VOu/NEVpnAQAAAGCpEGbTZGg0pvP/9l59bVeFt4GuxgAAAADyiJlp+/btgX0+YTZNSovCOm1FtX6+z6TSWlpmAQAAAGSdq666Sh/96Eenbf/e976n5uZmjY+PB1DV/BBm0+ii1fV6en+PYo0bCbMAAAAAss5NN92kr371q3LOTdn+la98RTfeeKMikUhAlZ0YYTaNLl5Tr/G40+GS1d5cs/F40CUBAAAAwIQ3velN6urq0v333z+xrbu7Wz/84Q917bXX6uKLL1ZNTY2WL1+uW265RaOjowFWOxVhNo02tdUqHDI9N75CGu2XevYFXRIAAAAATCgtLdVb3/pW3X333RPbvvnNb+rUU09VRUWF/umf/klHjx7VQw89pJ///Of67Gc/G2C1U2Vvm3EeKC+O6MzWav2ye5leK0kvPyvVtgVdFgAAAIAg/ddHvGyQTs1nSFf/n3kdetNNN+maa67RZz7zGZWUlOjuu+/WTTfdpPPOO2/imPb2dv3+7/++fvWrX+kDH/hAmopeGFpm0+yi1fX6/uF6OQtLB58IuhwAAAAAmOKyyy5TQ0OD7rnnHu3YsUOPPvqobrjhBr344ou65ppr1NzcrKqqKv3FX/yFjh49GnS5E2iZTbOLVtfrc/dFNVBziioOPB50OQAAAACCNs8W00x6xzveobvvvlsvvPCCXve612nZsmW64YYbdM455+jrX/+6Kisr9c///M/69re/HXSpE2iZTbPEc7M7oqdIB5+UUkYJAwAAAICgveMd79C9996rL3zhC7rpppskSX19faqqqlJFRYWef/55fe5znwu4yqkyEmbN7A4zO2Jmz82y/1Qze8jMRszsQ5moKVMSz80+ONQmDfdIx3YGXRIAAAAATNHe3q5LLrlEAwMDuvbaayVJn/zkJ/Xv//7vqqys1M0336zf/d3fDbjKqTLVzfhOSZ+RdPcs+49J+hNJb8pQPRl10ep6/fj+5fqDqKQDT0j1a4IuCQAAAACmuO+++6a8f+UrX6nnn39+yraPf/zjE+upc9NmWkZaZp1zv5YXWGfbf8Q595iksUzUk2kXr67XtliLYuFiBoECAAAAgCWQc8/Mmtn7zGyzmW3u7OwMupx5uWh1vSrKSrU3utZrmQUAAAAAnJScC7POududc5ucc5saGxuDLmdeiiIh/fYZy3X/4Cq5Q09LsfGgSwIAAACAnJZzYTZXvfHsFj0+3iEbH5I6twVdDgAAAADkNMJshmxqq9Xhio3eG7oaAwAAAAUn6AGTstVi/7tkamqer0t6SNJ6M9tvZu8xs/eb2fv9/c1mtl/Sn0n6K/+YqkzUlimhkOnss89TryvT0J7Hgi4HAAAAQAaFw2GNjeXleLcnbWxsTJHIwifaycjUPM65t51g/8uSWjNRS5DedG6rnnmoQxt2PabSoIsBAAAAkDE1NTU6fPiwWlpaFArRQTYhHo/r8OHDqq6uXvC5mZpnFpJOba7SN8o26qK+70ijg1JRWdAlAQAAAMiAhoYG7d+/Xy+88ELQpWSd8vJyNTQ0LPg8wmyGVZ1ymSLPfksHtvxGLee8NuhyAAAAAGRAKBTSqlWrgi4jr9C+nWEXvOIqSdJLj/0s4EoAAAAAIHcRZjOsoalZB4vaFT34qIbHYkGXAwAAAAA5iTAbAFt1kc5wL+i/nzsQdCkAAAAAkJMIswFYdvrlqrIhPfDg/UGXAgAAAAA5iTAbgNCqiyRJRQcf087O/oCrAQAAAIDcQ5gNQm27YuVNOj/0or7x2L6gqwEAAACAnEOYDYKZwm0X67Li7fr24/s1Ms5AUAAAAACwEITZoKy8SPXjh1U0cEg/3XI46GoAAAAAIKcQZoPiPzf72srd+vqjewMuBgAAAAByC2E2KM1nSNEy/U7jPj24o0u7jg4EXREAAAAA5AzCbFDCUal1kzaMbVU4ZPrGY7TOAgAAAMB8EWaDtOoSRTu36JpTyvTtzfs1Oh4PuiIAAAAAyAmE2SC1XSzJ6d1tR9U1MKqfbWUgKAAAAACYD8JskFrPlyysM2JbtayqWN95Yn/QFQEAAABATiDMBqmoXFp+lkJ7H9KbzmnRr17s1NH+kaCrAgAAAICsR5gNWtsl0oHHdd2ZjRqPO/3g6YNBVwQAAAAAWY8wG7RVF0uxEZ0y/pJOW1Gl7z55IOiKAAAAACDrEWaDtupib7n3Qb3l3FY9s79H24/0BVsTAAAAAGQ5wmzQyuulhvXSnod07VkrFA6ZvvMErbMAAAAAMBfCbDZou1ja94gayyN65boGfffJA4rHXdBVAQAAAEDWIsxmg1WXSCO90pGtetM5LTrUM6wn93UHXRUAAAAAZC3CbDZo85+b3fOQLl/fpEjI9NOth4OtCQAAAACyGGE2G1SvlKpapL0Pqro0qotW1+tnhFkAAAAAmBVhNhuYeaMa73lIck6/tXGZdnYOaEdnf9CVAQAAAEBWIsxmi7aLpf6Xpe5dunLjMkmidRYAAAAAZkGYzRarLvGWex5SS02pTltRRZgFAAAAgFkQZrNF46lSSY2090FJ0m9tXKYn9nars28k2LoAAAAAIAsRZrNFKDT53Ky8MOuc9MvnjwRcGAAAAABkH8JsNmm7WDq2Q+o7rI3Lq9RSU8oUPQAAAAAwA8JsNkk8N7vvYZmZLl/fqId2HNV4LB5sXQAAAACQZQiz2WT5WVKkdKKr8UWr6zUwGtOWg70BFwYAAAAA2YUwm00iRVLrpolBoC5cXSdJenhnV5BVAQAAAEDWIcxmm1UXSy8/Kw33qqmyRGsaywmzAAAAAJCCMJttVl4gubh06GlJ0oWr67V5dzfPzQIAAABAEsJstllxrrc8+IQk77nZvpFxbT3Ec7MAAAAAkECYzTbl9VLNKumAH2Y7vOdmH9l5LMiqAAAAACCrEGaz0YpzpYNPSpKaqkq0uoHnZgEAAAAgGWE2G604Rzq+RxrwAuyFq+v16K5jisVdwIUBAAAAQHYgzGajlsRzs17r7EWr69Q3Mq5tPDcLAAAAAJIIs9lp+dmSbGIQqAs76iUx3ywAAAAAJBBms1FJldSwbqJltrm6RC01pXpy3/Fg6wIAAACALEGYzVYrzpkY0ViSzmip1nMHegIsCAAAAACyB2E2W604V+p/Weo9KEk6o7Vae7oG1TM0FnBhAAAAABA8wmy2ShkE6vSWaknSloO0zgIAAAAAYTZbNZ8hWXiiq/EZfpilqzEAAAAAEGazV7RUato4MaJxXXmRWmpK9ewBpucBAAAAAMJsNlt+lvTycxNvT2+pomUWAAAAAESYzW5NG6SBI9KAN7/sGS3V2nV0QL3DDAIFAAAAoLARZrNZ0wZv2blNUtIgUHQ1BgAAAFDgCLPZLBFmj6SEWUY0BgAAAFDgCLPZrHK5VFI9EWYbKoq1vLpEz/LcLAAAAIACR5jNZmbeiMZ+mJW81lnCLAAAAIBCR5jNdo2nSke2Ss5JmhwEqn9kPODCAAAAACA4hNls17RRGj4u9R+W5IVZ56StBxkECgAAAEDhIsxmu4lBoLZKktY3V0qSXjrSF1RFAAAAABA4wmy2SxnReHl1icqLwnrpcH+ARQEAAABAsAiz2a68QSpvnAizZqa1yyq1/QhhFgAAAEDhIszmgsZTp4xovK6pgm7GAAAAAAoaYTYXNG2UOp+fGNF4XVOFDveOqGdoLODCAAAAACAYhNlc0LRBGu2XevZJktYtq5Akbad1FgAAAECBIszmgpRBoNY1+SMaMwgUAAAAgAJFmM0Fjad6S396npaaUpVEQ3qJQaAAAAAAFCjCbC4orZEqlkld2yVJoZBpbVMFYRYAAABAwSLM5oq61dKx3RNv1zVVavthnpkFAAAAUJgIs7mitkM6tnPi7dqmCh3sGVbfMCMaAwAAACg8hNlcUbda6jsojQ1Jkk5Z5g0CtaNzIMiqAAAAACAQhNlcUdfhLbt3S/LmmpWkl+hqDAAAAKAAEWZzRSLM+l2NV9aVqSgS0nYGgQIAAABQgAizuaJutbf0w2w4ZFrTyIjGAAAAAAoTYTZXlNZKJTXSsV0Tm9Y1VeilI3QzBgAAAFB4CLO5pG71lBGN1zRWaH/3kIbHYgEWBQAAAACZR5jNJSlhtr2hTM5Je48NBlgUAAAAAGQeYTaX1HVIPfuk8VFJUkdDuSRp11Gm5wEAAABQWAizuaRuteTiXqCV1FbvhdndhFkAAAAABYYwm0smRjT2BoGqLo2qrrxIu7voZgwAAACgsBBmc0nt1LlmJam9voyWWQAAAAAFhzCbSyqapGh5yiBQ5drdRZgFAAAAUFgyEmbN7A4zO2Jmz82y38zs02a23cyeMbNzM1FXzjHzBoHqnpxrtr2+XId6hjU0yvQ8AAAAAApHplpm75R01Rz7r5a0zn+9T9LnMlBTbqrrmNYyKzE9DwAAAIDCkpEw65z7taRjcxzyRkl3O8/DkmrMbHkmass5daul7t1S3GuJ7ahneh4AAAAAhSdbnpltkbQv6f1+f9s0ZvY+M9tsZps7OzszUlxWqe2QYqNS70FJUntDmSTx3CwAAACAgpItYXbenHO3O+c2Oec2NTY2Bl1O5tVNHdG4siSqhooiRjQGAAAAUFCyJcwekLQy6X2rvw2palZ5y579E5va6svpZgwAAACgoGRLmP2+pHf4oxpfJKnHOXco6KKyUpXf+7pnsld2e3259nQxABQAAACAwhHJxIeY2dclXS6pwcz2S/qYpKgkOec+L+nHkl4vabukQUnvykRdOSlSLFU0TwmzHQ1l+s8nvOl5SovCARYHAAAAAJmRkTDrnHvbCfY7SX+UiVryQs1K6XhSy6w/Pc/urgFtWF4VVFUAAAAAkDHZ0s0YC1HdOq2bsSQGgQIAAABQMAizuah6pdRzQIrHJU22zO5ieh4AAAAABYIwm4tqVkmxEWnAm2e3ojiihopi7TnKIFAAAAAACgNhNhdVt3rLlEGgaJkFAAAAUCgIs7mo2p+SNynMttWX88wsAAAAgIJBmM1FNX6YPZ7cMluuI30jGhgZD6goAAAAAMgcwmwuKqmWiqtmHtGYrsYAAAAACgBhNldVr5R69k+8bW8okyTt6WIQKAAAAAD5jzCbq2pWTulmnGiZ3cVzswAAAAAKAGE2V1W3Sj17J96WF0fUWFnMIFAAAAAACgJhNldVr5SGe6Th3olNHfXlPDMLAAAAoCAQZnNVYkTjlOdmd/PMLAAAAIACQJjNVdUzhdlydfaNqJ/peQAAAADkOcJsrpoIs5PPzU5Mz8NzswAAAADyHGE2V1Usk0LRGUc05rlZAAAAAPmOMJurQiGpumXGuWZpmQUAAACQ7wizuax6pdQz2TJbVhTRsqpiBoECAAAAkPcIs7msZtWUbsaS19WYllkAAAAA+Y4wm8uqW6W+Q1JsbGJTO3PNAgAAACgAhNlcVt0qyXmB1tfeUK6j/aPqGx6b/TwAAAAAyHGE2VxW3eotkwaB6pgYBIrnZgEAAADkL8JsLquaHmbbG5ieBwAAAED+I8zmsuoWb5kUZtvq/DDLIFAAAAAA8hhhNpcVlUuldVPCbGlRWM1VJdpFyywAAACAPEaYzXXVLVPCrCS1N5TRMgsAAAAgrxFmc131ymlhtqOhXLu7GAAKAAAAQP4izOa66lapd2qYbasv17GBUfUMMT0PAAAAgPxEmM11VS3ScI803Duxqb3eGwRqD8/NAgAAAMhThNlcl5hrtvfAxKYOf3qeXTw3CwAAACBPEWZzXfVKb9kzGWbb6sskSbuP8twsAAAAgPxEmM11E3PN7pvYVBINa0V1iXbTzRgAAABAniLM5rqKZsnC00Y0bqsvJ8wCAAAAyFuE2VwXjkhVK6Y8MytJ7Q3lzDULAAAAIG8RZvNBVcsMc82WqXtwTD2DTM8DAAAAIP8QZvNBdeuUZ2alyel5dtHVGAAAAEAeIszmg+pWqfegFI9PbGpvYK5ZAAAAAPmLMJsPqlul2Kg00DmxaVVdmcyYaxYAAABAfiLM5oPqVm+Z9NysNz1PKYNAAQAAAMhLhNl8kAizvVMHgWpvKNOursEACgIAAACA9CLM5oOqFm+ZMqJxez3T8wAAAADIT4TZfFBaK0XLZwyzPUNj6h4YDagwAAAAAEgPwmw+MPOn55kaZtc2VUiSdnT2B1EVAAAAAKQNYTZfVLfMGmZfOkKYBQAAAJBfCLP5YoaW2ZaaUpVGw3rpMGEWAAAAQH4hzOaL6pXSwBFpfGRiUyhkWttUoZeO9AVYGAAAAAAsPcJsvpiYnufAlM3rmiq0nW7GAAAAAPIMYTZfzDI9z5qmCh3qGVbf8FgARQEAAABAehBm80WiZTYlzK7zB4GidRYAAABAPiHM5ouJltmUbsbLKiUxojEAAACA/EKYzRfREqm8UerZN2XzytpSFUVCtMwCAAAAyCuE2Xwyw/Q8kXBIqxvK9dJhRjQGAAAAkD8Is/mkunXaaMaS19WYbsYAAAAA8glhNp9U+S2zzk3ZvK6pQgeOD2lwdDygwgAAAABgaRFm80l1qzTaLw0fn7J5XVOFnJN2dg4EUxcAAAAALDHCbD6ZmJ4ndURjb3qel47w3CwAAACA/ECYzSezzDXbVl+uSMj00mGemwUAAACQHwiz+WQizE6dnicaDqmjoZxBoAAAAADkDcJsPilvkkLRGUc0PmVZpV54mW7GAAAAAPIDYTafhEJS1Ypp3YwlaeOKKu09Nqje4bEACgMAAACApUWYzTfVK2cOs8urJEnPH6J1FgAAAEDuI8zmm+rWaaMZS9JpK7wwu+VgT6YrAgAAAIAlR5jNN9Ut3jOz8diUzY2VxWqoKNLWg70BFQYAAAAAS4cwm2+qWyUXk/penrLZzLRxRbW2EGYBAAAA5AHCbL6pXuktZxjReOPyKr10pE+j4/EMFwUAAAAAS4swm2+qWrzl8b3Tdp22okpjMaeXjjAIFAAAAIDcRpjNNzV+y2zPvmm7NvqDQPHcLAAAAIBcR5jNN8WVUlm91L172q72+nKVFYV5bhYAAABAziPM5qOaNql7z7TN4ZDp1OZKbT1EmAUAAACQ2wiz+ai2TTo+PcxK0mkrqrXtYK/icZfhogAAAABg6RBm81FNm3R837S5ZiXvudm+kXHt7x4KoDAAAAAAWBqE2XxU2y7Fx6S+Q9N2neYPArXlYE+GiwIAAACApUOYzUe1bd5yhkGgTllWqXDIGAQKAAAAQE6bd5g1syvMrMNfX25md5nZl82sOX3lYVFqEmF2+nOzJdGw1i+r1NP7j2e2JgAAAABYQgtpmf2spMRDmJ+SFJUUl3T7UheFk1S9UrLQrINAnbWyRk/vO84gUAAAAABy1kLCbItzbq+ZRSS9TtL7JP2BpEvSUhkWL1IkVbXM2DIrSeesrFHv8Lh2dQ1kuDAAAAAAWBoLCbO9ZrZM0qskbXXO9fvbo0tfFk5aTduMz8xKXsusJD2973jGygEAAACApbSQMPsvkh6T9DVJ/+pvu1TS80tdFJbAHHPNrm2qUHlRWE8RZgEAAADkqMh8D3TOfcLMvisp5pzb4W8+IOm9aakMJ6e23ZuaZ2xYipZM2RUOmc5oraZlFgAAAEDOWtDUPM65FxNB1syukLTcOfdsWirDyUmMaNyzb8bdZ6+s1dZDvRoei824HwAAAACy2UKm5vmVmV3qr/9PSd+Q9O9m9hfzPP8qM3vBzLab2Udm2N9mZj83s2fM7D4za51vbZjBHHPNStLZK6s1FnPadoj5ZgEAAADknoW0zJ4u6WF//WZJV0i6SNL7T3SimYXlPWd7taSNkt5mZhtTDvukpLudc2dK+rikv19AbUhVc6IwWytJPDcLAAAAICctJMyGJDkzWyPJnHNbnXP7JNXO49wLJG13zu10zo3Ka9V9Y8oxGyX9wl//5Qz7sRAVy6RIyayDQDVXl2hZVTFhFgAAAEBOWkiY/Y2kz8hrQf2uJPnB9ug8zm2RlPzw5n5/W7KnJb3FX3+zpEozq19AfUgWCkk1q2ada1aSzl5ZwyBQAAAAAHLSQsLsOyUdl/SMpFv9badK+n9LVMuHJL3KzJ6UN5ftAUnTRicys/eZ2WYz29zZ2blEH52n5phrVvLmm93dNajugdHM1QQAAAAAS2AhU/N0SfqLlG0/mufpByStTHrf6m9LvtZB+S2zZlYh6Trn3PEZ6rhd0u2StGnTJjfPzy9MtW3S/kdn3X32yhpJ3nOzV5zalKGiAAAAAODkLWQ046iZ3WZmO81s2F/eZmZF8zj9MUnrzKzDP/56Sd9PuX6DmSXq+V+S7phvbZhFbbs03CMNdc+4++yVNQqHTJv3HMtsXQAAAABwkhbSzfgfJF0pb/Tis/zlqyV94kQnOufGJd0i6b8lbZP0TefcFjP7uJld6x92uaQXzOxFScsk/e0CasNMaju85bFdM+4uK4po4/Iqbd49c9gFAAAAgGw1727Gkv6HpLP87saSFzyfkDdw0wdPdLJz7seSfpyy7aNJ69+W9O0F1IMTqVvtLY/tlFrOnfGQ89pq9Y3H9mosFlc0vJDfbQAAAABAcBaSXmyB2xG0ukTL7M5ZD9nUXqvhsbi2HOzNUFEAAAAAcPIWEma/JekHZvY6M9tgZldJukfSN9NSGU5etFSqapW6dsx6yKa2OknS5t08NwsAAAAgdywkzH5Y0r2S/lXS45L+RdIvJTGvSzar65izZba5ukQtNaV6fA/PzQIAAADIHfMOs865UefcR51za51zZc65dfIGafrz9JWHk1a/Rjo2e8us5HU13rynW84x0xEAAACA3HCyI/448cxsdqtbLQ12SUPHZz1kU1utOvtGtO/YUObqAgAAAICTsBTD19Kcl83q1njLOQeB8p+bZb5ZAAAAADnihFPzmNmr59hdtIS1IB3qk8LsLNPznLKsUpXFEW3e0623nNuaweIAAAAAYHHmM8/sl06wf+9SFII0qW33lnOMaBwOmc5pq9XjuxkECgAAAEBuOGGYdc51ZKIQpEliep45uhlL0vlttfrUz17U8cFR1ZTR4A4AAAAguy3FM7PIdnUdJxzR+IIO77nZR3fx3CwAAACA7EeYLQT1a+bsZixJZ62sUVEkpEcIswAAAAByAGG2ENStkYaOSUOzPxNbEg3rnJU1tMwCAAAAyAmE2UJQt9pbnuC52QtX12vLwR71Do9loCgAAAAAWDzCbCGYmJ5n15yHXdRRp7gToxoDAAAAyHqE2UJQ2yHJTvjc7DmrahUNmx7e1ZWZugAAAABgkQizhSBaIlW1nHBE49KisM5qrdEjO3luFgAAAEB2I8wWivrVJ2yZlbwpep490KOBkfEMFAUAAAAAi0OYLRR1a6Su7ZJzcx524ep6xeJOT+zluVkAAAAA2YswWyga1knDx6XBubsQn9dWq3DI6GoMAAAAIKsRZgtF/Tpv2fXSnIdVFEd0Rku1HtrJIFAAAAAAshdhtlA0rPWWR+cOs5J0yZp6Pb3vuPp5bhYAAABAliLMForqVVIoesKWWUm6dG2DxuNOjzJFDwAAAIAsRZgtFOGIVDe/EY3Pa6tVUSSkB7YTZgEAAABkJ8JsIWlYN69uxiXRsM5vr9UD249moCgAAAAAWDjCbCGpXysd2ynFTvws7CVrGvT8y3062j+SgcIAAAAAYGEIs4WkYZ0UH5OO7znhoZeubZAkPbiDrsYAAAAAsg9htpDU+yMaz+O52TNaqlVZEtGDdDUGAAAAkIUIs4VknnPNSlI4ZLpodb0e2EGYBQAAAJB9CLOFpLxeKq2d1yBQknTpmnrtOzakfccG01wYAAAAACwMYbbQ1K+TurbP69DEc7O/oasxAAAAgCxDmC009WvnHWbXNlWouapEv36xM81FAQAAAMDCEGYLTcNaqe+QNNJ3wkPNTK86pVG/2X5U47F4BooDAAAAgPkhzBaaiUGg5tc6+6r1jeobHtdT+46nryYAAAAAWCDCbKFp8MPs0fk/NxsOmX5FV2MAAAAAWYQwW2hqOyTZvFtmq0ujOntlDWEWAAAAQFYhzBaaaIlUs2pec80mvOqURj17oEdd/SNpLAwAAAAA5o8wW4ga1s17rlnJC7POMUUPAAAAgOxBmC1E9eukrh2Sc/M6/IyWatWVF+lXL9DVGAAAAEB2IMwWovo10tiAN0XPPIRCpsvWNujXL3UqHp9fAAYAAACAdCLMFqKJEY3n39X48vWNOto/qucO9qSpKAAAAACYP8JsIZqYa3YhYbZJIZPu3XYkTUUBAAAAwPwRZgtR1QopWjbvuWYlqa68SOe11ererYfTWBgAAAAAzA9hthCZec/NznOu2YTXbFimrYd6dfD4UJoKAwAAAID5IcwWqvp1C+pmLElXblgmSfr583Q1BgAAABAswmyhalgnHd8rjY/M+5Q1jeVqry+jqzEAAACAwBFmC1X9OsnFpWM7532Kmek1G5bpoR1dGhgZT2NxAAAAADA3wmyhql/jLRf43OyVG5ZpNBbX/S8dTUNRAAAAADA/hNlCVb/WWy5grllJ2tReq6qSiO7dRldjAAAAAMEhzBaqkiqponnBLbPRcEhXnNqkn287rLFYPE3FAQAAAMDcCLOFrGHdgltmJen1ZyxX9+CYHt7ZlYaiAAAAAODECLOFbBFzzUrSq05pVHlRWD9+9lAaigIAAACAEyPMFrL6ddLQMWnw2IJOK4mG9ZoNy/ST516mqzEAAACAQBBmC1nDOm+5iK7Gv30mXY0BAAAABIcwW8gSIxp3LTzM0tUYAAAAQJAIs4Wspk0KRRf13CxdjQEAAAAEiTBbyMIRqa5jUd2MJboaAwAAAAgOYbbQ1a9bVMus5HU1riiO6PtPHVziogAAAABgboTZQtewVjq2U4rHFnxqSTSs15/RrB8/e0iDo+NpKA4AAAAAZkaYLXT166TYqHR876JOv+7cVg2MxvTfW15e4sIAAAAAYHaE2UI3MaLx4roan99ep1V1Zfr24/uXsCgAAAAAmBthttCdxFyzkhQKmd5ybose3NGlA8eHlrAwAAAAAJgdYbbQldVLJTWLmms24bpzW+Wc9N0naJ0FAAAAkBmE2UJn5rXOLrKbsSStrCvThR11+s8nDsg5t4TFAQAAAMDMCLPwnps9uvgwK0m/c16rdh0d0OY93UtUFAAAAADMjjALL8z2HZRG+hd9id8+c7kqSyL6ykN7lrAwAAAAAJgZYRaTg0CdRFfjsqKIfue8Vv3Xc4fU2TeyRIUBAAAAwMwIs/DmmpVOKsxK0tsvatNYzOk/HlvcnLUAAAAAMF+EWUh1HZLspMPsmsYKXba2QV97ZK/GY/GlqQ0AAAAAZkCYhRQtlWpWLnqu2WS/d3GbDvUM695tR5agMAAAAACYGWEWnvp1JzXXbMJrTm3SiuoSfeXh3SdfEwAAAADMgjALT8M6qWuHdJLzxEbCId14UZse2N6lrQd7l6g4AAAAAJiKMAtPwynSaL/Ue+CkL/X2C9tUXhTWv/16xxIUBgAAAADTEWbhaTzVW3Y+f9KXqi6L6oYLV+mHzxzSvmODJ309AAAAAEhFmIWnaYO3PHLyYVaS3nPZaoVM+sL9O5fkegAAAACQjDALT1mdVN64JC2zktRcXaI3n9Oib27ep67+kSW5JgAAAAAkEGYxqfFUqfOFJbvc+165RiPjcd354O4luyYAAAAASIRZJGtc74XZkxzROGFtU4WuPr1ZX35gt44NjC7JNQEAAABAIswiWeOp0kiP1Pfykl3yg1eeosHRcX3uvu1Ldk0AAAAAIMxiUuN6b9m5bckuuW5Zpd58TqvuemiPDvUMLdl1AQAAABS2jIVZM7vKzF4ws+1m9pEZ9q8ys1+a2ZNm9oyZvT5TtcHX6I9ovITPzUrSB65cJ+ecPv1zWmcBAAAALI2MhFkzC0v6V0lXS9oo6W1mtjHlsL+S9E3n3DmSrpf02UzUhiTlDVJp3ZKNaJywsq5MN1ywSt/cvE+7jg4s6bUBAAAAFKZMtcxeIGm7c26nc25U0jckvTHlGCepyl+vlnQwQ7UhwWzJRzRO+KNXr1VxJKS//dHSdWEGAAAAULgyFWZbJO1Ler/f35bsVklvN7P9kn4s6Y8zUxqmaFwvHdm2ZCMaJzRVluhPXrNO9247rF8+f2RJrw0AAACg8GTTAFBvk3Snc65V0uslfcXMptVnZu8zs81mtrmzszPjRea9xlOl4eNS/9IHzndf2qHVjeW67QdbNDIeW/LrAwAAACgcmQqzByStTHrf6m9L9h5J35Qk59xDkkokNaReyDl3u3Nuk3NuU2NjY5rKLWBNp3rLJX5uVpKKIiHd+obTtLtrUF+8f9eSXx8AAABA4chUmH1M0joz6zCzInkDPH0/5Zi9kl4jSWa2QV6Ypek10xoTYXbpn5uVpFee0qirTmvWZ36xXXu7BtPyGQAAAADyX0bCrHNuXNItkv5b0jZ5oxZvMbOPm9m1/mF/LulmM3ta0tclvdO5JX5wEydWsUwqqV7SuWZTffQNGxUJmT70racVj/NHDAAAAGDhIpn6IOfcj+UN7JS87aNJ61slXZqpejALM6lpo3R4a9o+YkVNqT527Wn60Lee1h0P7NJ7X7E6bZ8FAAAAID9l0wBQyBbNZ0iHn5Pi8bR9xHXntujKDcv0D//9grYf6Uvb5wAAAADIT4RZTNd8pjTaL3Wnb5AmM9PfveV0lRWF9cH/eFrDY4xuDAAAAGD+CLOYrvkMb/nyM2n9mKbKEv3DdWfq2QM9uu0H6evWDAAAACD/EGYxXdMGKRSRDqU3zErSa09r1h9cvkZff3Svvrl5X9o/DwAAAEB+IMxiukixN0XPy89m5OP+/LdO0aVr6/VX9zyn5w70ZOQzAQAAAOQ2wixm1nxm2rsZJ0TCIX36+nPUUF6kd9/5mPZ3M/8sAAAAgLkRZjGz5jOk/sNS3+GMfFx9RbHufPcFGh6L6aY7HtXxwdGMfC4AAACA3ESYxcyWn+ktM9TVWJJOWVapL7xjk/YdG9J77tqsoVFGOAYAAAAwM8IsZrbsdG/58tMZ/dgLV9frn68/W0/s7dZ77npMg6PjGf18AAAAALmBMIuZldZINW0ZbZlNeP0Zy/WPbz1LD+/s0rvvJNACAAAAmI4wi9k1n5GR6Xlm8uZzWvWPbz1bj+46pnfe8Zh6hsYCqQMAAABAdiLMYnbLz5KO7ZRG+gL5+Ded06L/d/05enJft/7H5x/UweNDgdQBAAAAIPsQZjG75jMkOenwlsBKeMNZK3TXuy7QoePDevNnH9CWg8xDCwAAAIAwi7ksP8tbHnwy0DIuWdugb/3BxQqZ6brPPajvPXUg0HoAAAAABI8wi9lVrZCqWqV9jwZdiU5trtL3brlUZ7bU6E+/8ZRu/f4WjY7Hgy4LAAAAQEAIs5jbygukfY8EXYUkqamyRF+7+UK9+9IO3fngbr3lcw9o+5FgnucFAAAAECzCLOa26iKp94B0fF/QlUiSouGQPvqGjfr828/TwePD+u1P/0ZffmCX4nEXdGkAAAAAMogwi7mtvNBbZknrbMJVpzfrJx94hS5ZU6/bfrBV133+QW071Bt0WQAAAAAyhDCLuS07XYqWS3sfDrqSaZoqS3THO8/XP771LO3pGtQ1//Ib/c0Pt6pnkDlpAQAAgHxHmMXcwhGp9bysa5lNMDO95dxW/eLPX6W3bmrVlx7YpVd98pe64ze7GCAKAAAAyGOEWZzYyoukw89JI9k72FJNWZH+/i1n6od/fJlOW1Glj/9wq6745H36+qN7CbUAAABAHiLM4sRWXSi5uLR/c9CVnNBpK6r11fdcqDvfdb4aKov1v77zrK745H364v071TNE92MAAAAgXxBmcWKt50uyrO1qnMrMdPn6Jt3zh5foy+86XytqSvQ3P9qmi/7u5/rL7z6rlw5nbwszAAAAgPmJBF0AckBJtdS0MSsHgZqLmemK9U26Yn2TnjvQo7se3K1vPb5fX3tkry5dW68bLmjTazY0qSQaDrpUAAAAAAtkzuXu/JybNm1ymzdnf9fXvPDDD0rPfEv6yB4plLvhr6t/RN94bJ+++vAeHeoZVkVxRK/duEzXnr1Cl65tUDRMZwUAAAAgW5jZ4865TTPto2UW87PqEmnzHdLBp7zRjXNUfUWx/uiKtXr/q9bo4Z1d+v5TB/Xj5w7pO08eUF15ka4+vVmvPrVJF6+pV1kRfz0AAACAbMW/1jE/a66QZNKOn+d0mE0Ih0yXrm3QpWsb9PE3naZfvdCp7z99UN954oC+9sheFUVCurCjTq86pVGXr2/SmsZymVnQZQMAAADw0c0Y83f75VIoKr33Z0FXkjbDYzE9tvuY7nuhU/e9cEQ7OgckScuqirWpvU6b2mp1fnudTm2uVIQuyQAAAEBa0c0YS2Ptb0n3f1IaPCaV1QVdTVqURMN6xbpGvWJdo/76mo3ad2xQv3qxU4/tPqbNu7v1o2cOSZLKi8I6e1WNTl9RrY0rqnR6S7U66ssVCtF6CwAAAGQCLbOYv72PSHe8VvqdL0unvyXoagJx4PiQNvvB9sl93Xrx5X6NxuKSpLKisDYsr9Ipyyq1prFca5sqtKaxQi01pYRcAAAAYBFomcXSaDlPKqmRtv+8YMNsS02pWs5u0RvPbpEkjY7Htf1Iv7Yc7NGWg73aerBXP3nukLoHxybOKYmG1F5frtbaUrXWlqmlpnRyvbZUtWVRnscFAAAAFogwi/kLR7yBoLbfKzknEcBUFAlp44oqbVxRpf+RtP3YwKi2H+nXjs5+bT/Srz1dg9rfPaiHdx5T/8j4lGuUFYW1oqZUDRVFaqwsUUNFkRoqitVYWaxGf1lfUaTq0qhKo2GCLwAAACDCLBZq7ZXSlu9Kh5+Tms8IupqsVVdepAs66nRBx9Rni51z6h0a1/7jg9rfPaT93UM60D2kg8eHdLR/RM/uP66j/aPTAm9CNGyqLo2qqjSq6pRXWVFEZUVhlRWFVZpYRiMqL55cT+wrCocUjYQUCZmKwiG6QQMAACDnEGaxMGuv9Jbb7yXMLoKZqbosquqyap22onrW44ZGYzraP6IjfSM62j+irv5R9QyNTbx6/WVX/6h2dg6od3hMg6MxjY7HF1VXOGSKhk3RkBdyo2FTNBzyX956OGQyM4VMMkkhM4XMZOY10k997x0XMpP5P7f55yWO9d57GyeO8fcnv5d/XMg0cU7iM6Wp17Up722GbZPbi/yfrygyuSwK2+T7iW2Tx5REJ39ZUF4UUUk0REs5AABAQAizWJjKZmnZGdJLP5Mu+2DQ1eSt0qKwVtaVaWVd2YLOG4/FNTgW09BoTIOjMQ2Ojiet++/HYhqPOY3F4hqNxTU27q2PxZPW/X0Tx43HFXNOzklxf+nkFI977+NxKaa44v7+uJPkL+NJ58nb7J3rvJZqJ0lO8k5x/tI7xjlvXf6+ePJ2JfYlv086f7Z1/7PHYnGd7Ph3ZlJZNKzSpFbxsqKwyosjqiiOqKokqqrSxHLqenVpdGI/3ccBAAAWjjCLhVt/tTdFT/8RqaIp6GqQJBIOqSocUlVJNOhScsJ4LK6xmNPouBfevXDvr49PfT8Wi2t4LD7xS4HB0ZgGR/zlWNL6aEz9I+M63Dus3qHxiVbzuRRFQqorK1JdeZHqK7xlXXmR6suLVOsv68qLJ7ZVl0bpGg4AAAoeYRYLd9qbpF//g7Tt+9L57w26GmDRIuGQImGvJTydRsfj6hseU+/wuHqHxtQ7PDYRdHuGxtQ9MKpj/qtrYFR7ugZ1bGD2Z6dD5j2X3VBRrKaqEjVWFKupqjhlWaLGymJVFPM1DwAA8hP/ysHCNW2UGk6RttxDmAXmoSgSUn1Fseorihd03sh4TN0DY+oaGJkIu4nX0f5RdfaNqLNvWNsP96mzf0Rjsen9psuKwmqsLFZTZbG/9EJu48R7f8Ts8mKFae0FAAA5hDCLhTOTNr6JrsZAmhVHwmquDqu5uuSEx8bjTj1DYzrSN6IjfcPq7PMGEEssj/QO6/mX+3T/i0fVN0OLb8ik+orJcJvcytvoB+DEvnJaewEAQBbgXyRYHLoaA1klFDLV+s/Yrm+unPPYodGY16rbP6wjvZOh19vmheFth3p1tH9UsfjMrb1NU1p3SybnRU50c670nvGNhEPp+pEBAECBI8xicehqDOSs0qKwVtWXaVX93KNlx+NOxwZHJ4LutNCbaO196aj6hqe39ppJ1aVRb0CrssmBrVJf9eXFqi2Pqr68OO3PLwMAgPxBmMXi0NUYyHuhkKmholgNFcXasHzuY5PnRu70uzl39o9OGdxqT9egnth7XN2DM7f4SlJpNDwRcmv9kZur/SmNqhNTGiVNbZTYVlES4ZlfAAAKDGEWi5foarz1e9IFNwddDYAALWRuZOeceofGdWxwVMcGRtTVP6ruQW8k52P9o/52LwjvOzaoniFv1OfZArDk/X6tojgyLeR6c/56c/8m5v9N3laRtK28OKLyojBdowEAyBGEWSxe00ap8VTp2W8RZgHMm5mpuiyq6rKoOhrK53WOc06Do7GJYNubWA6PT9mWmPqoZ2hMO4/2a2DEm/e3f2R8zjCcrCQamgi4ZUURlUZDKi0KqzQaVknUW05576+XRsMqSVovLQpNOb44ElZRJKTiSEiRkMmMlmQAAE4GYRaLZyaddb10761S1w6pfk3QFQHIU2Y20Xq6oqZ0wec75zQyHlf/yLgG/HA7MBJLWk/aNuqt9w+Pa2gspuGxmIZGYzo+OOa9H41paCzm74sv8ueRisJesC2KhFUcSayHJgJvUSTkHxOevj3ibS9OHBP1lpFwSNGwKRLyltFwSBH/fVHEW0b87dGwF6qjiXNSziVsAwCyHWEWJ+eMt0r33iY9803piv8VdDUAMCMzU4nfktqwwPl+5xKPeyE5EW6HRv3w668nwvDgaEwjYzGNxuIaGYtrNBbX6HhcI/7LW49pdDw+cczwWFy9Q+OT25OP9c9Pp0jIvOAbCikamQy+iTCc/D4SMoVDXhAOhZLfe8vwlPchhUNSJBSa85hIyKZda+r7UMo5cx8TMu858JCZwmYyk7/dFAppYnvi/cQ+884N05oOAFmHMIuTU90idbxSeuYb0uUf8ZobAKBAhELmdTMOYBRm59xEKE4E3fGY01jcX8biGovFNR5PrDuNJ5bxeNI27/3ouHds4pjkcyev5x07HvM+e9w/JhZ3Go87DY3F/PdxxeJSLD65P5Z0XMz/nLiTxuPxie1ufj3BAzURjP2g64XcqeE3HJrcHwopKSRPPzcRspOD9OR1TSbvf62hpPVp200y2ZR9ocR60r5Q6nEm/9jJ9eRzvGvM4zqz1DgfMx3mXeXEx3nHLv01g7DQe99p4X9ZFv4ZC5eNP8diuJP4kMS9P/Xv1eTfmcQxk9un/n2U/wu0ib9jSecr+fjE9pRrT/tOUOJeT/l7nnT+BR31qsjROeRzs2pkl7PeJt3zfmnfI9Kqi4KuBgAKgpn5XY3zZzqjeNwp5pJCb8x7PxF4Y34oThwz5X184v14YpsfvuNOisWd4s5/xaWYc3LOKRbXxHbvGK+OuHP+MUnn+vtjLuV90rVjcfnX9a+VdG2XWse0c71tXtB3ijlJzvvnvvOv5Zz894l17xyXdJzzr+3kH5O0f+ZrJG1P2T/tOv56POnzAOS2n37wlTpl2dxz1GcrwixO3oY3SD/6M+nprxNmAQCLFgqZQjJF8yefF4SZQvG0Y2ZogZtvEJ7tuPlec6bTZ2p5m/m4xbXgLqbRd6Hd2Bf3GQs8fhGfkokW78X9mSzwv+8iPiP5Fz7SDL888o9R8i+JUvY5b+fUXyRp8u9Z6udMu/bEL7hm/kXUTOevmsdMBNmKMIuTV1zhBdrnvitd9QkpWhJ0RQAAIEMSXSQlKbyoiAUAi8NkelgaZ10vjfRIL/wo6EoAAAAAFADCLJZGx+VS9Srpia8EXQkAAACAAkCYxdIIhaRzbpR23id17wm6GgAAAAB5jjCLpXP2jd7yqa8FWwcAAACAvEeYxdKpWSmtebX05NekeCzoagAAAADkMcIslta575B690s7fhl0JQAAAADyGGEWS2v966WyeunJu4OuBAAAAEAeI8xiaUWKpLPeJj3/I6n3UNDVAAAAAMhThFksvfPf4z0zu/lLQVcCAAAAIE8RZrH06lZL66+WNn9ZGhsOuhoAAAAAeYgwi/S48P3S4FHpuW8HXQkAAACAPESYRXp0vFJq2ig9/HnJuaCrAQAAAJBnCLNIDzOvdfbws9Lu3wRdDQAAAIA8Q5hF+pz5Vqm0Tnrw00FXAgAAACDPEGaRPtFS6ZI/ll76qbTnwaCrAQAAAJBHCLNIrwvfL1Uul372MZ6dBQAAALBkCLNIr6Iy6fKPSPsflV74cdDVAAAAAMgThFmk39lvl+rXSffeJsXGg64GAAAAQB4gzCL9whHpNR+Vjr4gPfbFoKsBAAAAkAcIs8iMDW+Q1r1W+tlHpZefC7oaAAAAADmOMIvMMJPe+FmptEb6z/dIo4NBVwQAAAAghxFmkTkVjdKbPy91Pi/9918EXQ0AAACAHEaYRWatebV0yZ9Ij39ZeuD/BV0NAAAAgBwVCboAFKDXfEzqPeA9P2th6ZJbgq4IAAAAQI4hzCLzwhHpzbdLLi799C+95SV/7D1XCwAAAADzQJhFMMIR6S1f8NZ/9tfSsR3S1f9XihQFWxcAAACAnECYRXDCUem6O6TaDuk3/ygd3S699S6pvCHoygAAAABkOQaAQrBCIenKj3mttPsfkz7/Cmn3A0FXBQAAACDLEWaRHc58q/Ten0nREumua6Rf/V8pHgu6KgAAAABZKmNh1syuMrMXzGy7mX1khv3/ZGZP+a8Xzex4pmpDllh+lvT7v5ZOe4v0y7+RvvJmqe9w0FUBAAAAyEIZCbNmFpb0r5KulrRR0tvMbGPyMc65DzrnznbOnS3pXyR9JxO1IcsUV0rXfVG69l+kfY9Kn79M2vGLoKsCAAAAkGUy1TJ7gaTtzrmdzrlRSd+Q9MY5jn+bpK9npDJkHzPp3HdIN/9CKqvzWmjv+SNpoCvoygAAAABkiUyF2RZJ+5Le7/e3TWNmbZI6JNEcV+iWbZRu/qV02QelZ74hfeY86dEvSOMjQVcGAAAAIGDZOADU9ZK+7ZybcfQfM3ufmW02s82dnZ0ZLg0ZV1QmXXmr9Pv3S40bpB9/SPr0OV6oHR0MujoAAAAAAclUmD0gaWXS+1Z/20yu1xxdjJ1ztzvnNjnnNjU2Ni5hichqyzZK7/qx9HvflapXeqH2U+ulH/6ZdPBJybmgKwQAAACQQZEMfc5jktaZWYe8EHu9pBtSDzKzUyXVSnooQ3Uhl5hJa14trb5C2vuQ9Phd0lNfkzZ/SapbI532Jum0N0vLTveOBQAAAJC3zGWoRcvMXi/pnyWFJd3hnPtbM/u4pM3Oue/7x9wqqcQ5N23qnpls2rTJbd68OU0VIycMdUtb7pG23iPtul9ysclge+o10vKzpVA29qYHAAAAcCJm9rhzbtOM+zIVZtOBMIspBo5K237gB9tfSy4uVSyT1r1WOuUqafXlUnFF0FUCAAAAmCfCLArPQJe0/WfSiz+Rtv9CGumRwkXSqou918rzpdbzpZLqoCsFAAAAMIu5wmymnpkFMqu8Xjrreu8VG5P2PuwF252/kn79D16rrUxq2uCF2uYzpKaN3vuyuqCrBwAAAHAChFnkv3BU6niF95KkkT7pwOPSvkelfY943ZKfuGvy+IplXqhtWC/Vtkt1Hd6yps2bKggAAABA4AizKDzFld7zs6sv9947J/UekI48Lx3ZKh3Z5i2f+po02j/13IrmyYBbvVKqXOaF3/ImqaLJWyfwAgAAAGlHmAXMpOpW77XuysntzkmDXVL3bu91bNfk+q5fS70HJc3wzHlRpVTR6AXc0hrvudxprxqppEqKlnvhN1omFZV7y2gZIzADAAAAJ0CYBWZjJpU3eK/WGZ45j41Lg0el/sNS/xH/dXhyOdDpBd4j26ThHu81U/idSaQkKeCWeq9wsTeIVTiaspxjPRSWLOS9ktct7P1807YlH2tTt1nI3xaSZP5cvv5yYj00z3UlnRua57pm+fwTfabmOGauz2SuYgAAgGxGmAUWKxyRKpu913zE49Jo32SwHe6RRgelsQFpbEgaHZDGBmdZH5Jio95gVqMDUqzbW4+NTm6fshz15tzFSfIDbrhIihTN8AuD4pl/uZB6bKRUivq/oIiUTP6CYsr6bMeUevcaAAAApuBfSECmhEKT3YwzIR7zXi7uBVsXT3rvJrdN2R6fZVvSeXL++cnr8Xmsz3K8XMq1Z/ucuY5J/UwtoK7Eumb5nPj0XxTExqTxkZRto94vIJKPHR+VYiPesWNDUnxscX+WoUhSyE0JvBPL4slAPG2ZdGziGnMdGymhZRoAAGQ9wiyQr0Jh74XsERuXxoeksWEv+I4PeyF3bGiO7f62sWH/mOTtQ94gZQNHJ88fH5oMzyfTOh8p8VueI1Io6rUwhyKTLdCJ9VB06jET2/zjZ+yuntqdPXVf8vGWcvxs10k6L/W4aftDcxyf2gU/6ZhQ2P/Zk/97+K3v/F0DACDjCLMAkCnhiBSu9EbUzoTY2NTgO7EcmRp+Z1vGxrxXfMwL4vGxlG1jUnzca4GOD8ywb4YW/xO94jHN+9nyrGKzBP3o1NA/WxierYv6jOsn2h/1WupP9Dw9AAA5jjALAPkqEaRUFXQlC+OSuoCndnVPhN34DNsn3rs5utindqNP3u9mv2Y87gX32GhKuB+dI+inbks5f3x48vzYyMzPv4+PKC3h3sIzhNwTBeKZgnHxLNv9ZWS2/fO5RhEjuwMA5kSYBQBkl4nRpAkykrxQPZ4admdanyUQp4bjE14jZdtI3wzPgqeeP5Ken93C8wvEoUhSl/Hw1PWQ3108uet4KPWY5H3Jx6R0RZ9yfHjqyOhSyvsTLGcaGX6h19Bsz7bP8QsQN9cvR2bZt5hz5jxvsfUlmfJcv82wfaZtSdtPeP58jl3A+RN/3jM8QpF8T8y4L3n7fK6Vcuys1wrzCyPkPMIsAADZLBT25qNWWdCVzC7RGp48INqsgXk0JRTPFq5PdI2xyZAfj/ld3keSWtOTW9hj01vaJ7YljkvZllgC+S4U8X8hFPbX/V/YTGwPJW2PJP1SJzL9+FmvkfI+eRyG1LEX5hyLIfXYlMc6Zn3MI5ryiwbkC8IsAAA4OWb+M8ERZXXoXoyJbuupQTdlVPXFLk/2GrO1zs75D/c59s163mLOmeO8xdYnaUrL7pSWXDf7tinbT3D+lNWT/SwljZqfmE0gnrRthu1Tjk/sc7NsTz1+hsc0ZjzHpdzT45OzIMTHvZdLfp+8PT65njgnMUZD6nWmXdsfayH58YxM/dLIwvMLxLOG45nO8beFkq4d8r8L57UvMnndiWuGU95Hpq8nvy/wkE6YBQAAmE0iqPNPJiA9EmMSJA8sOOO4A6n7ks+Za6DC1GNnuUZsdPq+8eHZz5nYNj65HkRvjomQnhp6k4N0JOWVaEn3W92v+Septi3ztS8BvpkBAAAABCMUkkJFkoqCruTkOTc13M60nhyME63aiTA/8T65BXtc01q0T7hvLKUlPPnzE63m8cnHNHJyFgEPYRYAAAAATpbZZFflaGnQ1RQEhjADAAAAAOQcwiwAAAAAIOcQZgEAAAAAOYcwCwAAAADIOYRZAAAAAEDOIcwCAAAAAHIOYRYAAAAAkHMIswAAAACAnEOYBQAAAADkHMIsAAAAACDnEGYBAAAAADmHMAsAAAAAyDmEWQAAAABAziHMAgAAAAByDmEWAAAAAJBzCLMAAAAAgJxDmAUAAAAA5BzCLAAAAAAg55hzLugaFs3MOiXtCbqOE2iQdDToIpC1uD8wG+4NzIX7A3Ph/sBsuDcwl2y9P9qcc40z7cjpMJsLzGyzc25T0HUgO3F/YDbcG5gL9wfmwv2B2XBvYC65eH/QzRgAAAAAkHMIswAAAACAnEOYTb/bgy4AWY37A7Ph3sBcuD8wF+4PzIZ7A3PJufuDZ2YBAAAAADmHllkAAAAAQM4hzAIAAAAAcg5hNk3MrM7MvmtmA2a2x8xuCLomBMfM7jOzYTPr918vJO27wb9HBszsHjOrC7JWpJeZ3WJmm81sxMzuTNn3GjN73swGzeyXZtaWtK/YzO4ws14ze9nM/izjxSPtZrs/zKzdzFzSd0i/mf110n7ujzzn/xl/yf//RZ+ZPWVmVyft5/ujgM11f/D9AUkys6+a2SH/z/lFM3tv0r6c/f4gzKbPv0oalbRM0o2SPmdmpwVbEgJ2i3Ouwn+tlyT/nvg3Sb8n714ZlPTZAGtE+h2U9DeS7kjeaGYNkr4j6a8l1UnaLOk/kg65VdI6SW2SrpD0YTO7KgP1IrNmvD+S1CR9j/zvpO23ivsj30Uk7ZP0KknVkv5K0jf9oML3B2a9P5KO4fujsP29pHbnXJWkayX9jZmdl+vfHwwAlQZmVi6pW9LpzrkX/W1fkXTAOfeRQItDIMzsPklfdc59MWX738n7YrnBf79G0jZJ9c65vowXiowxs7+R1Oqce6f//n2S3umcu8R/Xy7pqKRznHPPm9lBf/9P/f3/W9I659z1gfwASKsZ7o92SbskRZ1z4zMcz/1RgMzsGUm3SaoX3x9IkXR/PC6+P5DEzNZLuk/Sn0qqUQ5/f9Aymx6nSBpPBFnf05JomS1sf29mR83sATO73N92mrx7Q5LknNshr0X/lMyXh4Cl3gsDknZIOs3MaiUtT94vvlMK1R4z229mX/Z/my7uj8JkZsvk/b9ii/j+QIqU+yOB748CZ2afNbNBSc9LOiTpx8rx7w/CbHpUSOpN2dYjqTKAWpAd/qek1ZJa5M3h9QO/FbZC3r2RjHulMM11L1QkvU/dh8JwVNL58rp5nSfvz/5r/j7ujwJjZlF5f/53OeeeF98fSDLD/cH3ByRJzrk/lPdn+wp5XYtHlOPfH5GgC8hT/ZKqUrZVSaLbaIFyzj2S9PYuM3ubpNeLewWT5roX+pPeD6fsQwFwzvXLe45Jkg6b2S2SDplZpbg/CoqZhSR9RV4vnlv8zXx/QNLM9wffH0jmnItJ+o2ZvV3SHyjHvz9omU2PFyVFzGxd0razNLWrBwqbk2Ty7omzEhvNbLWkYnn3EApL6r1QLmmNpC3OuW553YHOSjqe75TClhjwIsT9UTjMzCR9Sd6Agdc558b8XXx/YK77IxXfH5C8Rs01yvHvD8JsGvh9zb8j6eNmVm5ml0p6o7zflKHAmFmNmb3OzErMLGJmN0p6paSfyOvm8wYze4X/5fFxSd9h8Kf85d8DJZLCksKJ+0LSdyWdbmbX+fs/KukZv4uYJN0t6a/MrNbMTpV0s6Q7A/gRkEaz3R9mdqGZrTezkJnVS/q0pPucc4muX9wfheFzkjZIeoNzbihpO98fkGa5P/j+gJk1mdn1ZlZhZmEze52kt0n6uXL9+8M5xysNL3lDW98jaUDSXkk3BF0Tr8DuhUZJj8nrknFc0sOSfitp/w3+PTIg6XuS6oKumVda74db5f1WPPl1q7/vSnmDMgzJG2WwPem8YnnTtfRKOizpz4L+WXhl7v6Q94+OXf73xCF5/7ho5v4onJe85x2dvK5+/UmvG/39fH8U8Guu+4PvD17+v0V/5f87tFfSs5JuTtqfs98fTM0DAAAAAMg5dDMGAAAAAOQcwiwAAAAAIOcQZgEAAAAAOYcwCwAAAADIOYRZAAAAAEDOIcwCAAAAAHIOYRYAgAwys/8ys5uCrmM+zKzdzJyZRYKuBQCAVPzPCQCAEzCz/qS3ZZJGJMX897/vnPvafK/lnLt6KWsDAKBQEWYBADgB51xFYt3Mdkt6r3Pu3tTjzCzinBvPZG0AABQquhkDALBIZna5me03s/9pZi9L+rKZ1ZrZD82s08y6/fXWpHPuM7P3+uvvNLPfmNkn/WN3mdmsLbdmtsLM/tO/9i4z+5Okfbea2bfN7D/MrM/MnjCzs5L2b/A/+7iZbTGza5P2lZrZp8xsj5n1+DWVJn30jWa218yOmtlfLtV/PwAATgZhFgCAk9MsqU5Sm6T3yft/65f996skDUn6zBznXyjpBUkNkv5B0pfMzFIPMrOQpB9IelpSi6TXSPqAmb0u6bA3SvqWX8+/S7rHzKJmFvXP/amkJkl/LOlrZrbeP++Tks6TdIl/7oclxZOue5mk9f5nftTMNpzwvwoAAGlGmAUA4OTEJX3MOTfinBtyznU55/7TOTfonOuT9LeSXjXH+Xucc19wzsUk3SVpuaRlMxx3vqRG59zHnXOjzrmdkr4g6fqkYx53zn3bOTcm6R8llUi6yH9VSPo//rm/kPRDSW/zQ/K7Jf2pc+6Acy7mnHvQOTeSdN3b/J/taXlh+iwBABAwnpkFAODkdDrnhhNvzKxM0j9JukpSrb+50szCfmBN9XJixTk36DfKVsxwXJukFWZ2PGlbWNL9Se/3JV0rbmb7Ja1I7HPOJbe27pHXwtsgL/TumONnfDlpfXCW+gAAyCjCLAAAJ8elvP9zeV1yL3TOvWxmZ0t6UtK0rsMLtE/SLufcujmOWZlY8VtcWyUdTOwzs1BSoF0l6UVJRyUNS1ojr9UVAICcQDdjAACWVqW852SPm1mdpI8t0XUfldTnDzZVamZhMzvdzM5POuY8M3uLPy/sB+RNIfSwpEfktah+2H+G9nJJb5D0DT/c3iHpH/0BpsJmdrGZFS9R3QAApAVhFgCApfXPkkrltXg+LOknS3FRv4vyNZLOlrTLv/4XJVUnHfY9Sb8rqVvS70l6i3NuzDk3Ki+8Xu2f91lJ73DOPe+f9yFJz0p6TNIxSZ8Q/0YAAGQ5cy61dxQAAMg1ZnarpLXOubcHXQsAAJnAb10BAAAAADmHMAsAAAAAyDl0MwYAAAAA5BxaZgEAAAAAOYcwCwAAAADIOYRZAAAAAEDOIcwCAAAAAHIOYRYAAAAAkHMIswAAAACAnPP/AcNZRwcJIJVxAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -239,7 +239,7 @@ } ], "source": [ - "plot_train_val_loss(train_loss, val_loss)" + "plot_losses(train_loss, val_loss)" ] }, { @@ -258,7 +258,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -270,6 +270,7 @@ } ], "source": [ + "nn_model.eval()\n", "pred_y_test = np.argmax(nn_model(test_data[0]).detach(), axis=1)\n", "\n", "cm = confusion_matrix(test_data[1], pred_y_test)\n", @@ -327,14 +328,14 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 12, "id": "218d0983", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4b5f7a72f877486b8007e1a0969e1b27", + "model_id": "7749b4cf1e7c4b0185bceb1bc894a6d5", "version_major": 2, "version_minor": 0 }, @@ -348,7 +349,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "15553c7a94c6433b9994a28cf19aa666", + "model_id": "245f27435cd942b2b659f6c0008593ae", "version_major": 2, "version_minor": 0 }, @@ -368,7 +369,7 @@ " *test_data,\n", " influence_type=\"up\",\n", " inversion_method=\"direct\",\n", - " hessian_regularization=1,\n", + " hessian_regularization=0.1,\n", " progress=True,\n", ")" ] @@ -391,7 +392,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 13, "id": "9169c2dc", "metadata": {}, "outputs": [], @@ -409,13 +410,13 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 14, "id": "233a57da", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -428,8 +429,8 @@ ], "source": [ "_, ax = plt.subplots()\n", - "ax.hist(mean_train_influences[num_corrupted_idxs:], log=True, label=\"normal\")\n", - "ax.hist(mean_train_influences[:num_corrupted_idxs], log=True, label=\"corrupted\")\n", + "ax.hist(mean_train_influences[num_corrupted_idxs:], label=\"normal\")\n", + "ax.hist(mean_train_influences[:num_corrupted_idxs], label=\"corrupted\", bins=5)\n", "ax.set_title(\"Influece scores distribution\")\n", "ax.set_xlabel(\"influece score\")\n", "ax.set_ylabel(\"number of points\")\n", @@ -447,7 +448,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 15, "id": "8bc72789", "metadata": {}, "outputs": [ @@ -455,8 +456,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average influence of corrupted points: -0.008919590861305823\n", - "Average influence of other points: 0.005525699381638608\n" + "Average influence of corrupted points: -0.03891054072273765\n", + "Average influence of other points: 0.031147227974786414\n" ] } ], @@ -489,14 +490,14 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 16, "id": "462d545e", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a4f6b7fdbc6d41d1886ab969bcf4ff03", + "model_id": "13ae88de7f79441e8ab05d9947a9e8f6", "version_major": 2, "version_minor": 0 }, @@ -510,7 +511,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e73769256e964c4aacf3be5a6a96211d", + "model_id": "92dd0ef4917245df8efef33b48817db5", "version_major": 2, "version_minor": 0 }, @@ -537,13 +538,13 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 17, "id": "1e096222", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -584,7 +585,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 18, "id": "efdb4050", "metadata": {}, "outputs": [], @@ -596,7 +597,7 @@ " *test_data,\n", " influence_type=\"up\",\n", " inversion_method=\"cg\",\n", - " hessian_regularization=1,\n", + " hessian_regularization=0.1,\n", ")\n", "mean_cg_train_influences = np.mean(cg_train_influences, axis=0)" ] @@ -611,7 +612,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 19, "id": "599bab0a", "metadata": {}, "outputs": [ @@ -619,7 +620,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Percentage error of cg over direct method:0.0015781619965701342 %\n" + "Percentage error of cg over direct method:0.0009528368049549545 %\n" ] } ], diff --git a/notebooks/notebook_support.py b/notebooks/notebook_support.py index 2e24d82d8..fbdee5798 100644 --- a/notebooks/notebook_support.py +++ b/notebooks/notebook_support.py @@ -70,6 +70,52 @@ def forward(self, x): return torch.sigmoid(self.fc1(x)) +class TorchMLP(nn.Module): + """ + A simple fully-connected neural network f(x) + """ + + def __init__( + self, + n_input: int, + n_output: int, + n_neurons_per_layer: List[int], + ): + """ + :param n_input: Number of feature in input. + :param n_output: Output length. + :param n_neurons_per_layer: Each integer represents the size of a hidden layer. Overall this list has K - 2 + :param init: A list of tuple of np.ndarray representing the internal weights. + """ + super().__init__() + self.n_input = n_input + + self.n_hidden_layers = n_neurons_per_layer + + if n_neurons_per_layer == []: + layers = [nn.Linear(n_input, n_output)] + else: + layers = [nn.Linear(n_input, n_neurons_per_layer[0]), nn.Tanh()] + for idx, n_neurons in enumerate(n_neurons_per_layer): + if idx == 0: + continue + layers.append(nn.Linear(n_neurons_per_layer[idx - 1], n_neurons)) + layers.append(nn.Tanh()) + layers.append(nn.Linear(n_neurons_per_layer[-1], n_output)) + + layers.append(nn.Softmax(dim=-1)) + + self.layers = nn.Sequential(*layers) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """ + Perform forward-pass through the network. + :param x: Tensor input of shape [NxD]. + :returns: Tensor output of shape[NxK]. + """ + return self.layers(x) + + def fit_torch_model( model: nn.Module, x_train: Union["NDArray[np.float_]", torch.tensor], @@ -206,7 +252,7 @@ def train( ) if use_cache: self.save(training_loss, validation_loss) - + self.model.eval() return training_loss, validation_loss def save( @@ -228,10 +274,25 @@ def load(self) -> Tuple["NDArray[np.float_]", "NDArray[np.float_]"]: self.model.load_state_dict( torch.load(self.data_dir / f"{self.name}_weights.pth") ) + self.model.eval() with open(self.data_dir / f"{self.name}_train_val_loss.pkl", "rb") as file: return pkl.load(file) +def process_imgnet_io( + df: pd.DataFrame, labels: dict +) -> Tuple[torch.Tensor, torch.Tensor]: + x = df["normalized_images"] + y = df["labels"] + ds_label_to_model_label = { + ds_label: idx for idx, ds_label in enumerate(labels.values()) + } + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + x_nn = torch.stack(x.tolist()).to(device) + y_nn = torch.tensor([ds_label_to_model_label[yi] for yi in y], device=device) + return x_nn, y_nn + + def plot_dataset( train_ds: Tuple["NDArray[np.float_]", "NDArray[np.int_]"], test_ds: Tuple["NDArray[np.float_]", "NDArray[np.int_]"], @@ -535,6 +596,14 @@ def _process_dataset(ds): processed_ds["labels"].append(item["label"]) return pd.DataFrame.from_dict(processed_ds) + def split_ds_by_size(dataset, split_size): + split_ds = dataset.train_test_split( + train_size=split_size, + seed=random_state, + stratify_by_column="label", + ) + return split_ds + if os.environ.get("CI"): tiny_imagenet = load_dataset("Maysee/tiny-imagenet", split="valid") if keep_labels is not None: @@ -561,14 +630,10 @@ def _process_dataset(ds): lambda item: item["label"] in keep_labels.keys() ) - split_ds = tiny_imagenet.train_test_split( - train_size=1 - test_size, seed=random_state - ) + split_ds = split_ds_by_size(tiny_imagenet, 1 - test_size) test_ds = _process_dataset(split_ds["test"]) - split_ds = split_ds["train"].train_test_split( - train_size=train_size, seed=random_state - ) + split_ds = split_ds_by_size(split_ds["train"], train_size) train_ds = _process_dataset(split_ds["train"]) val_ds = _process_dataset(split_ds["test"]) @@ -754,12 +819,8 @@ def plot_corrupted_influences_distribution( non_corrupted_infl = class_influences[ ~class_influences.index.isin(corrupted_indices[label]) ] - axes[idx].hist( - non_corrupted_infl, label="Non corrupted", density=True, alpha=0.7 - ) - axes[idx].hist( - corrupted_infl, label="Corrupted", density=True, alpha=0.7, color="green" - ) + axes[idx].hist(non_corrupted_infl, label="Non corrupted", alpha=0.7) + axes[idx].hist(corrupted_infl, label="Corrupted", alpha=0.7, color="green") axes[idx].set_xlabel("Influence values") axes[idx].set_ylabel("Distribution") axes[idx].set_title(f"Influences for {label=}") diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 45fe6f3fb..9e7d5b5fd 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -132,6 +132,12 @@ def _calculate_influences_pert( return np.stack(all_pert_influences, axis=1) +influence_type_registry = { + InfluenceType.Up: _calculate_influences_up, + InfluenceType.Perturbation: _calculate_influences_pert, +} + + def compute_influences( model: "nn.Module", loss: Callable[["torch.Tensor", "torch.Tensor"], "torch.Tensor"], @@ -172,10 +178,10 @@ def compute_influences( if not _TORCH_INSTALLED: raise RuntimeWarning("This function requires PyTorch.") - diffable_model = TorchTwiceDifferentiable(model, loss) + differentiable_model = TorchTwiceDifferentiable(model, loss) - infl_factors: "NDArray" = calculate_influence_factors( - diffable_model, + influence_factors = calculate_influence_factors( + differentiable_model, x, y, x_test, @@ -184,19 +190,12 @@ def compute_influences( lam=hessian_regularization, progress=progress, ) - if influence_type == InfluenceType.Up: - return _calculate_influences_up( - diffable_model, - x, - y, - infl_factors, - progress, - ) - elif influence_type == InfluenceType.Perturbation: - return _calculate_influences_pert( - diffable_model, - x, - y, - infl_factors, - progress, - ) + compute_influence_type = influence_type_registry[influence_type] + + return compute_influence_type( + differentiable_model, + x, + y, + influence_factors, + progress, + ) From 77c958ae570394e40204ff0e3389881ae3b3d42b Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 24 Feb 2023 14:46:59 +0100 Subject: [PATCH 009/436] update changelog --- CHANGELOG.md | 4 ++++ tests/influence/test_influences.py | 1 + 2 files changed, 5 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7b78b8ce0..477557217 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,9 @@ # Changelog +## 0.6.0 - Refactorings + +- Refactoring of influence functions and removal of torch wrappers + ## 0.5.0 - 💥 Fixes, nicer interfaces and... more breaking changes 😒 - Fixed parallel and antithetic Owen sampling for Shapley values. Simplified diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 2efdd5347..2072706a7 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -24,6 +24,7 @@ pass +@pytest.mark.torch class InfluenceTestSettings: INFLUENCE_TEST_CONDITION_NUMBERS: List[int] = [3] INFLUENCE_TRAINING_SET_SIZE: List[int] = [50, 30] From e5e78e0aa6557f03acc9e2a2fd2651a4792ac77d Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 24 Feb 2023 14:48:53 +0100 Subject: [PATCH 010/436] further update changelog --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 477557217..a26e3e438 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,7 @@ ## 0.6.0 - Refactorings - Refactoring of influence functions and removal of torch wrappers + [PR #278](https://github.com/appliedAI-Initiative/pyDVL/pull/278) ## 0.5.0 - 💥 Fixes, nicer interfaces and... more breaking changes 😒 From 4fa87537c0bc64870fcb2e6b4a32d53752df4797 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 24 Feb 2023 15:13:19 +0100 Subject: [PATCH 011/436] fix tests --- src/pydvl/influence/general.py | 2 +- tests/influence/test_influences.py | 9 ++------- 2 files changed, 3 insertions(+), 8 deletions(-) diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 9e7d5b5fd..e59b2a834 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -2,7 +2,7 @@ Contains parallelized influence calculation functions for general models. """ from enum import Enum -from typing import TYPE_CHECKING, Callable, Dict, Optional +from typing import TYPE_CHECKING, Callable import numpy as np diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 2072706a7..d5c567d85 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -4,6 +4,8 @@ import numpy as np import pytest +from pydvl.influence.general import InfluenceType, InversionMethod, compute_influences + from .conftest import ( add_noise_to_linear_model, analytical_linear_influences, @@ -14,17 +16,10 @@ import torch import torch.nn.functional as F from torch import nn - - from pydvl.influence.general import ( - InfluenceType, - InversionMethod, - compute_influences, - ) except ImportError: pass -@pytest.mark.torch class InfluenceTestSettings: INFLUENCE_TEST_CONDITION_NUMBERS: List[int] = [3] INFLUENCE_TRAINING_SET_SIZE: List[int] = [50, 30] From 6c5da2822da4bd6e234fc0f598b38a3ba61b9aa8 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 24 Feb 2023 15:25:23 +0100 Subject: [PATCH 012/436] still trying to fix tests --- src/pydvl/influence/general.py | 29 ++++--- tests/influence/test_influences.py | 123 ++++++++++++++++------------- 2 files changed, 82 insertions(+), 70 deletions(-) diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index e59b2a834..2e873ce8a 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -2,7 +2,7 @@ Contains parallelized influence calculation functions for general models. """ from enum import Enum -from typing import TYPE_CHECKING, Callable +from typing import TYPE_CHECKING, Callable, Union import numpy as np @@ -35,12 +35,15 @@ class InfluenceType(str, Enum): Perturbation = "perturbation" +TensorType = Union["NDArray", torch.TensorType] + + def calculate_influence_factors( model: TwiceDifferentiable, - x: "NDArray", - y: "NDArray", - x_test: "NDArray", - y_test: "NDArray", + x: TensorType, + y: TensorType, + x_test: TensorType, + y_test: TensorType, inversion_method: InversionMethod, lam: float = 0, progress: bool = False, @@ -76,8 +79,8 @@ def calculate_influence_factors( def _calculate_influences_up( model: TwiceDifferentiable, - x: "NDArray", - y: "NDArray", + x: TensorType, + y: TensorType, influence_factors: "NDArray", progress: bool = False, ) -> "NDArray": @@ -98,8 +101,8 @@ def _calculate_influences_up( def _calculate_influences_pert( model: TwiceDifferentiable, - x: "NDArray", - y: "NDArray", + x: TensorType, + y: TensorType, influence_factors: "NDArray", progress: bool = False, ) -> "NDArray": @@ -141,10 +144,10 @@ def _calculate_influences_pert( def compute_influences( model: "nn.Module", loss: Callable[["torch.Tensor", "torch.Tensor"], "torch.Tensor"], - x: "NDArray", - y: "NDArray", - x_test: "NDArray", - y_test: "NDArray", + x: TensorType, + y: TensorType, + x_test: TensorType, + y_test: TensorType, progress: bool = False, inversion_method: InversionMethod = InversionMethod.Direct, influence_type: InfluenceType = InfluenceType.Up, diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index d5c567d85..9644238cb 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -114,68 +114,77 @@ def test_influence_linear_model( assert np.allclose(cg_influences, analytical_influences, rtol=1e-1) -conv3d_nn = nn.Sequential( - nn.Conv3d(in_channels=5, out_channels=3, kernel_size=2), - nn.Flatten(), - nn.Linear(24, 3), -) -conv2d_nn = nn.Sequential( - nn.Conv2d(in_channels=5, out_channels=3, kernel_size=3), - nn.Flatten(), - nn.Linear(27, 3), -) -conv1d_nn = nn.Sequential( - nn.Conv1d(in_channels=5, out_channels=3, kernel_size=2), - nn.Flatten(), - nn.Linear(6, 3), -) -simple_nn_regr = nn.Sequential(nn.Linear(10, 10), nn.Linear(10, 3), nn.Linear(3, 1)) - -test_cases = { - "conv3d_nn_up": [conv3d_nn, 10, (5, 3, 3, 3), 3, nn.MSELoss(), InfluenceType.Up], - "conv3d_nn_pert": [ - conv3d_nn, - 10, - (5, 3, 3, 3), - 3, - nn.SmoothL1Loss(), - InfluenceType.Perturbation, - ], - "conv_2d_nn_up": [conv2d_nn, 10, (5, 5, 5), 3, nn.MSELoss(), InfluenceType.Up], - "conv_2d_nn_pert": [ - conv2d_nn, - 10, - (5, 5, 5), - 3, - nn.MSELoss(), - InfluenceType.Perturbation, - ], - "conv_1d_nn_up": [conv1d_nn, 10, (5, 3), 3, nn.MSELoss(), InfluenceType.Up], - "conv_1d_pert": [ - conv1d_nn, - 10, - (5, 3), - 3, - nn.SmoothL1Loss(), - InfluenceType.Perturbation, - ], - "simple_nn_up": [simple_nn_regr, 10, (10,), 1, nn.MSELoss(), InfluenceType.Up], - "simple_nn_pert": [ - simple_nn_regr, - 10, - (10,), - 1, - nn.MSELoss(), - InfluenceType.Perturbation, - ], -} +@pytest.mark.torch +class NNArchitectures: + conv3d_nn = nn.Sequential( + nn.Conv3d(in_channels=5, out_channels=3, kernel_size=2), + nn.Flatten(), + nn.Linear(24, 3), + ) + conv2d_nn = nn.Sequential( + nn.Conv2d(in_channels=5, out_channels=3, kernel_size=3), + nn.Flatten(), + nn.Linear(27, 3), + ) + conv1d_nn = nn.Sequential( + nn.Conv1d(in_channels=5, out_channels=3, kernel_size=2), + nn.Flatten(), + nn.Linear(6, 3), + ) + simple_nn_regr = nn.Sequential(nn.Linear(10, 10), nn.Linear(10, 3), nn.Linear(3, 1)) + + test_cases = { + "conv3d_nn_up": [ + conv3d_nn, + 10, + (5, 3, 3, 3), + 3, + nn.MSELoss(), + InfluenceType.Up, + ], + "conv3d_nn_pert": [ + conv3d_nn, + 10, + (5, 3, 3, 3), + 3, + nn.SmoothL1Loss(), + InfluenceType.Perturbation, + ], + "conv_2d_nn_up": [conv2d_nn, 10, (5, 5, 5), 3, nn.MSELoss(), InfluenceType.Up], + "conv_2d_nn_pert": [ + conv2d_nn, + 10, + (5, 5, 5), + 3, + nn.MSELoss(), + InfluenceType.Perturbation, + ], + "conv_1d_nn_up": [conv1d_nn, 10, (5, 3), 3, nn.MSELoss(), InfluenceType.Up], + "conv_1d_pert": [ + conv1d_nn, + 10, + (5, 3), + 3, + nn.SmoothL1Loss(), + InfluenceType.Perturbation, + ], + "simple_nn_up": [simple_nn_regr, 10, (10,), 1, nn.MSELoss(), InfluenceType.Up], + "simple_nn_pert": [ + simple_nn_regr, + 10, + (10,), + 1, + nn.MSELoss(), + InfluenceType.Perturbation, + ], + } @pytest.mark.torch @pytest.mark.parametrize( "nn_architecture, batch_size, input_dim, output_dim, loss, influence_type", - test_cases.values(), - ids=test_cases.keys(), + NNArchitectures.test_cases.values(), + ids=NNArchitectures.test_cases.keys(), ) def test_influences_nn( nn_architecture: nn.Module, From 8dcb5bf91ec6cc657e0fe7f53137063b880824d0 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 24 Feb 2023 15:37:23 +0100 Subject: [PATCH 013/436] fixing typing --- .../frameworks/torch_differentiable.py | 14 ++++---- src/pydvl/influence/general.py | 5 +-- src/pydvl/influence/types.py | 34 +++++++++++++------ 3 files changed, 32 insertions(+), 21 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 1d333db96..5104de7d8 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -7,7 +7,7 @@ import numpy as np from ...utils import maybe_progress -from ..types import TwiceDifferentiable +from ..types import TensorType, TwiceDifferentiable try: import torch @@ -70,8 +70,8 @@ def num_params(self) -> int: def split_grad( self, - x: Union["NDArray", "torch.Tensor"], - y: Union["NDArray", "torch.Tensor"], + x: TensorType, + y: TensorType, progress: bool = False, ) -> "NDArray": """ @@ -112,8 +112,8 @@ def split_grad( def grad( self, - x: Union["NDArray", "torch.Tensor"], - y: Union["NDArray", "torch.Tensor"], + x: TensorType, + y: TensorType, ) -> Tuple["NDArray", "torch.Tensor"]: """ Calculates gradient of model parameters wrt x and y. @@ -138,8 +138,8 @@ def grad( def mvp( self, - grad_xy: Union["NDArray", "torch.Tensor"], - v: Union["NDArray", "torch.Tensor"], + grad_xy: TensorType, + v: TensorType, progress: bool = False, backprop_on: Optional["torch.Tensor"] = None, ) -> "NDArray": diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 2e873ce8a..2c9552ade 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -9,7 +9,7 @@ from ..utils import maybe_progress from .frameworks import TorchTwiceDifferentiable from .inversion_methods import InversionMethod, invert_matrix -from .types import TwiceDifferentiable +from .types import TensorType, TwiceDifferentiable try: import torch @@ -35,9 +35,6 @@ class InfluenceType(str, Enum): Perturbation = "perturbation" -TensorType = Union["NDArray", torch.TensorType] - - def calculate_influence_factors( model: TwiceDifferentiable, x: TensorType, diff --git a/src/pydvl/influence/types.py b/src/pydvl/influence/types.py index 65ebc9c45..f8bab2407 100644 --- a/src/pydvl/influence/types.py +++ b/src/pydvl/influence/types.py @@ -1,18 +1,32 @@ from abc import ABC -from typing import Iterable, Optional, Tuple +from typing import TYPE_CHECKING, Iterable, Optional, Tuple, Union from numpy import ndarray -__all__ = [ - "TwiceDifferentiable", -] +try: + import torch + import torch.nn as nn + + _TORCH_INSTALLED = True +except ImportError: + _TORCH_INSTALLED = False + +if TYPE_CHECKING: + from numpy.typing import NDArray + + +__all__ = ["TwiceDifferentiable", "TensorType"] + +TensorType = Union["NDArray", "torch.TensorType"] class TwiceDifferentiable(ABC): def num_params(self) -> int: pass - def split_grad(self, x: ndarray, y: ndarray, progress: bool = False) -> ndarray: + def split_grad( + self, x: TensorType, y: TensorType, progress: bool = False + ) -> "NDArray": """ Calculate the gradient of the model wrt each input x and labels y. The output is therefore of size [Nxp], with N the amout of points (the length of x and y) and @@ -20,7 +34,7 @@ def split_grad(self, x: ndarray, y: ndarray, progress: bool = False) -> ndarray: """ pass - def grad(self, x: ndarray, y: ndarray) -> Tuple[ndarray, ndarray]: + def grad(self, x: TensorType, y: TensorType) -> Tuple["NDArray", TensorType]: """ It calculates the gradient of model parameters with respect to input x and labels y. """ @@ -28,11 +42,11 @@ def grad(self, x: ndarray, y: ndarray) -> Tuple[ndarray, ndarray]: def mvp( self, - grad_xy: ndarray, - v: ndarray, + grad_xy: TensorType, + v: TensorType, progress: bool = False, - backprop_on: Optional[Iterable] = None, - ) -> ndarray: + backprop_on: Optional[TensorType] = None, + ) -> "NDArray": """ Calculate the hessian vector product over the loss with all input parameters x and y with the vector v. """ From 61bc3bc7e57a5927549d18d966ea80ac1c1d96f6 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 24 Feb 2023 15:52:01 +0100 Subject: [PATCH 014/436] trying to fix torch imports --- tests/influence/conftest.py | 6 ------ tests/influence/test_influences.py | 8 ++++---- 2 files changed, 4 insertions(+), 10 deletions(-) diff --git a/tests/influence/conftest.py b/tests/influence/conftest.py index 2ad89dfd0..75053430d 100644 --- a/tests/influence/conftest.py +++ b/tests/influence/conftest.py @@ -7,12 +7,6 @@ from pydvl.influence.general import InfluenceType from pydvl.utils import Dataset, random_matrix_with_condition_number -try: - import torch - from torch import nn -except ImportError: - pass - if TYPE_CHECKING: from numpy.typing import NDArray diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 9644238cb..8444da2cf 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -1,4 +1,5 @@ import itertools +import sys from typing import Dict, List, Tuple import numpy as np @@ -114,8 +115,7 @@ def test_influence_linear_model( assert np.allclose(cg_influences, analytical_influences, rtol=1e-1) -@pytest.mark.torch -class NNArchitectures: +if "torch" in sys.modules: conv3d_nn = nn.Sequential( nn.Conv3d(in_channels=5, out_channels=3, kernel_size=2), nn.Flatten(), @@ -183,8 +183,8 @@ class NNArchitectures: @pytest.mark.torch @pytest.mark.parametrize( "nn_architecture, batch_size, input_dim, output_dim, loss, influence_type", - NNArchitectures.test_cases.values(), - ids=NNArchitectures.test_cases.keys(), + test_cases.values(), + ids=test_cases.keys(), ) def test_influences_nn( nn_architecture: nn.Module, From 9b50f345e7039b8f17138462de7f14846be0957e Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 24 Feb 2023 16:03:23 +0100 Subject: [PATCH 015/436] fix tests --- src/pydvl/influence/types.py | 9 ++------- tests/influence/test_influences.py | 6 ++++-- 2 files changed, 6 insertions(+), 9 deletions(-) diff --git a/src/pydvl/influence/types.py b/src/pydvl/influence/types.py index f8bab2407..4693af0e4 100644 --- a/src/pydvl/influence/types.py +++ b/src/pydvl/influence/types.py @@ -1,19 +1,14 @@ from abc import ABC -from typing import TYPE_CHECKING, Iterable, Optional, Tuple, Union - -from numpy import ndarray +from typing import TYPE_CHECKING, Optional, Tuple, Union try: import torch - import torch.nn as nn _TORCH_INSTALLED = True except ImportError: _TORCH_INSTALLED = False -if TYPE_CHECKING: - from numpy.typing import NDArray - +from numpy.typing import NDArray __all__ = ["TwiceDifferentiable", "TensorType"] diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 8444da2cf..7b7dce904 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -178,6 +178,8 @@ def test_influence_linear_model( InfluenceType.Perturbation, ], } +else: + test_cases = {} @pytest.mark.torch @@ -187,11 +189,11 @@ def test_influence_linear_model( ids=test_cases.keys(), ) def test_influences_nn( - nn_architecture: nn.Module, + nn_architecture: "nn.Module", batch_size: int, input_dim: Tuple[int], output_dim: int, - loss: nn.modules.loss._Loss, + loss: "nn.modules.loss._Loss", influence_type: InfluenceType, hessian_reg: float = 100, test_data_len: int = 10, From 63ee2753d03af1b64d14b00c80fc35f1af4aa782 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 28 Feb 2023 10:22:58 +0100 Subject: [PATCH 016/436] addressing PR comments --- CHANGELOG.md | 2 +- notebooks/influence_imagenet.ipynb | 103 ++++-- notebooks/influence_synthetic.ipynb | 37 +- notebooks/influence_wine.ipynb | 33 +- notebooks/notebook_support.py | 324 ++---------------- notebooks/notebook_support_torch.py | 265 ++++++++++++++ .../frameworks/torch_differentiable.py | 17 +- src/pydvl/influence/general.py | 18 +- src/pydvl/influence/inversion_methods.py | 16 +- src/pydvl/influence/types.py | 10 +- src/pydvl/reporting/plots.py | 10 +- src/pydvl/utils/numeric.py | 2 +- tests/influence/conftest.py | 104 +++--- tests/influence/test_influences.py | 141 ++++---- tests/influence/test_torch_differentiable.py | 14 +- tests/utils/test_caching.py | 15 +- 16 files changed, 570 insertions(+), 541 deletions(-) create mode 100644 notebooks/notebook_support_torch.py diff --git a/CHANGELOG.md b/CHANGELOG.md index a26e3e438..dea593e48 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,6 @@ # Changelog -## 0.6.0 - Refactorings +## Unreleased - Refactoring of influence functions and removal of torch wrappers [PR #278](https://github.com/appliedAI-Initiative/pyDVL/pull/278) diff --git a/notebooks/influence_imagenet.ipynb b/notebooks/influence_imagenet.ipynb index fcd135e26..63e44d7d3 100644 --- a/notebooks/influence_imagenet.ipynb +++ b/notebooks/influence_imagenet.ipynb @@ -67,15 +67,16 @@ " plot_losses,\n", " corrupt_imagenet,\n", " load_preprocess_imagenet,\n", - " process_imgnet_io,\n", " plot_corrupted_influences_distribution,\n", " compute_mean_corrupted_influences,\n", + ")\n", + "from notebook_support_torch import (\n", " TrainingManager,\n", - " MODEL_PATH,\n", " new_resnet_model,\n", + " process_imgnet_io,\n", + " MODEL_PATH,\n", ")\n", "\n", - "\n", "default_figsize = (7, 7)\n", "plt.rcParams[\"figure.figsize\"] = default_figsize\n", "plt.rcParams[\"font.size\"] = 12\n", @@ -217,8 +218,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "Cached model found, loading...\n" + "No pretrained model found. Training for 50 epochs:\n" ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "842cf8d419684bfd925ec9598846fd96", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Model fitting: 0%| | 0/50 [00:00" ] @@ -256,7 +271,7 @@ } ], "source": [ - "plot_losses(train_loss, val_loss)" + "plot_losses(losses)" ] }, { @@ -275,12 +290,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "f1_score of model: 0.8853543321365104\n" + "f1_score of model: 0.8750542770299609\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -324,7 +339,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f5082dc0c07b48f39da89a8946deb716", + "model_id": "5ee7e435828248fd88ce0bcdc574ca1c", "version_major": 2, "version_minor": 0 }, @@ -338,7 +353,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d3ba08b6304743419d5c7f48570da7e9", + "model_id": "5fa2291b2b2d4501b6674d208534cff9", "version_major": 2, "version_minor": 0 }, @@ -352,7 +367,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c5dfbd6417db4e359833919611e6373b", + "model_id": "4c6a042331654c09b2c7a22abf174bc3", "version_major": 2, "version_minor": 0 }, @@ -442,7 +457,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -476,7 +491,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -503,8 +518,8 @@ "source": [ "Looking at the images, it is not immediate to explain why those on the right are\n", "more influential than those on the left. A lot seems to depend on the tonality\n", - "of he buildings, water and the color of the boat. Let's dig\n", - "in a bit more by looking at average influences:" + "of the buildings, water and the color of the boat. Let's dig\n", + "in a bit more by looking at average influences." ] }, { @@ -539,7 +554,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -565,12 +580,12 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZYAAAG9CAYAAAA2k1BjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9eZxlyVXfi35XROy9z5RjzT2pW62WhGZaSDIICSEMBoMNHrDBYBtfjEdGj/ddg+FjPxu4vma4vs82GBuuGYxtwAYbAQYkMLOEGIzQgKZWj9VdXZWVmWfYU0S8P1bsc05mZVVXtUrdWa3zq96d5+x57xMRK9Zav7WWxBhZYYUVVlhhhZsF82zfwAorrLDCCs8trATLCiussMIKNxUrwbLCCiussMJNxUqwrLDCCiuscFOxEiwrrLDCCivcVKwEyworrLDCCjcVK8FyDCEid4jIRRG5I32/W0SiiHzqDZ7n5SLydhEpReSBa+z3XSLyzz/K2/6oICJfJiLtU+zzgIh8/VPs830i8nM3eO1vEpEP3MgxH2uIiBGR3xaRP30d+0YR+dIbPP9TvsurHLcmIudF5JXXse8viMj3PI1rfJWIPCwiIf02T9k2VjheuCUFy9MZPJ5NJEERReRN13nINwM/EGN8+KO89P8J7AEvBl4jIl8qIkcFLv0j4K+JyPM/yusdB3wN8IXP9k0cBRH5gIh803Xu/pcAAX70OvY9B/zI072vq0FEfk5Evm95XYxxH/g24HomIn8S+Fs3eM3bgO9A+8DtwP91I8evcDxwSwqW5zJE5BzwZ4Hvugmnuw/4xRjjAzHGC1fbKcb4CPDzwN+4Cdd8VhFj3I0x7jzb93ET8HXAd8drRDCLSA4QYzwfYyyfsTuD7wM+TURedq2dYoyXYox7N3ju56Pj0k/EGB+LMY6f5j2u8CziOSlYRORFIvKTIjJOy38TkRcsbX9IRL5i6fv/mzSK5X0eFpG/uvT9i0Tkdzqzkoh8m4gMl7Z/qoj8iojsp+V3ReSPpM0Ppb9vS9d54Bq3/2eBB2KM736KZzyTNLcL6Xq/IiJvTNvuTprJvcA/Stf8BeD70/aYlu9bOuV/Ab7kKa55j4j8mIg8KiJTEfk9Efnzh/b5BRH5HhH5hmQyuSQi/15ERkv7GBH5xyLyRPp9/iOwda1rLyEXke9M531cRL5dRNzSuQ9os+la/zS9p7GI/LCIfO1RphUR+XwRea+ITNJz3Hdo+6tF5H+k81xI7+J5S9vvEJEfFZEnUzv5kIj83e69oL/HNy69/7uv8p5fBbwU+K+H1kcR+WoR+SER2eXg7/mlS/vdk+6zTG39b8rRZqmrvsvUNj4D+ItL9/smgBjjE8CvAtc0vx2+5lO1DVFt7pfS7g9e7R3JEaYxOcIqICIvSL/HZRHZSe/k5YfPIyKvF5HfSm36nSLymkPnvldEfiTd71RE/peIfN7S9qfdLp6reM4JFhHpA/8D6AGflpYR8NOSZnjA24A3Lx326cCFbp2IvAhVw9+avn8Z8K9Q9f8lwF8A/jDwr9N2B/wE8BvA/Wn5JmCazn9/+vunULPFgYZ7CJ8GvP06nvFtwBrwOcAnAm8BflZEPgEVZOeAh4FvTZ//OPCV6RTn0vI1S6f9DeBsOv5qGKHv5HOAlwPfDXyviHz6of3+NLANvAn4IuDzgL+/tP2rUBPJ30XfzTuBb7zWMx869jHgdenzVwJ/8Rr7fy3w1el6n4i+2394xH7ngL+OCtdPQd/tv+s2ishLgF8Efg34JLStePSd99Ju/xLYQNvGi4EvR38DULPQA2gb6t5/N+E4jE8DHokxPnrEtm9EB/X7gSt8JCIi6CRhA3gj8MeAz03PfhjXepdfgw7y/2npfn916djfQPvNjeJabeP/QvsI6PNd6x1dEyJyBvhl4AngDcAfAt4H/IKInFra1aBmt69J13wC+E9LAvYs+tybaB96OfANQEjbP9p28dxEjPGWW1BV/Oeusu3L0QH95NK6M8AM+Avp+5cBj6fP96X9vwH44bTurwMPLh3/APDXDl3njUBEZ9pb6fObrnJPd1xr+6F9fwf41kPr7k7Hf+rS/T8MuEP7vRX4jkP3/fVL379Uf/Ijr7uervG5N/hb/Djwb5a+/wLwu4f2+VfAry19fxj4J4f2+RGgfYprPYCaSJbX/RTwH67WNoBHgH986JgfXr4WOglogVNL6/4sOnj0ls77w4fOU6S28wXp++8C33SN+//AtbYv7fcdwG8csT4C//Yq6780ff7M9P0FS9u3031+zw2+y58Dvu8q9/jVwIWneI5fOHTN62kbb0r3f8fSui879Hsd+J7WHehj6Tf99UP7CPBB4GuXzhOB+5f2eV1a96L0/R8D54HhVZ7xo24Xz8XlOaexoCaEd8cYn+xWxBgfR2crL02r3gacFrURvxmd2fw0ixnYm9M+pNnN84Bvk4VpbYx2QtAOvAN8D/AzIvJTIvK/J63n6aAPPJW9/DXAWeDyoXt6Ayoonw66a/avtoOIDETkW0Tk95NZYAz8UfT9LON3D31/FBXuiMg6qg3+6qF9fvk67/N3rnbuI+53A7gN+PVDm37tiN0fjQf9UI+iA9Hp9P01wJ849L4voppx986/A/g/ROQ3RORbJZkmnwau1Qauqc2iGvWTMcY5yy3GeAlt/4fxO4e+X/VdHoGSa7SVa+CqbeMm4zXAqw/9XvvoJG25j8RD99Rpid09vRr41Rjj5BrXeabaxS0D99S7PPcQY/yIiHwItSF/CjrT/y2gSDbYNwF/J+3eCd+vIQmbQ3g4nfMrROQ7gc9CZ43/WES+MsZ4o074C+gM81owwHuAP3HEtukR664H3TWv6uQH/hnw+ahZ6X3ABDXtbBzarz70PXLzzK5P59zXk8L7qPOydG6D+jS+5YhjLwLEGL9XRH4a+Gx0kvJTIvJfYow3RAVGf4NPucq2qw1wy7jelOUfze+0zbXbysfimh3CEeuyQ98NSkj5yiP23V0+V4zRH7qf7vjrwTPZLm4ZPBc1lt8HXiIiJ7sVyd76IuBdS/u9DRUsbwJ+PjWuX0Rt8idJ/pWk7TyEqsYfOGKZzyxjjO+KMX5bjPFzgH8L/JW0qetM9jru/7dYaFZXw2+i7Jm9I+7nKLt8hxpARI66j5ejtuHfvsbxbwR+MMb4n2KMvwt8CHjhU9zrAURlCT3ClQPn62/kPNd5rV10BvrJhzb9oadxut8EXgF88Ih3PmehRWUyfW+M8S+gZtkvSVoa6Pu/3jbwAhE5PFheD94NnBKRe7sVIrLFDf5OCde635ej7+TZwBOATf26w/2H9vlNtB89fMTvdSMC8Z3Ap8gSUeeI63y07eI5h1tZsIxE5FWHlhcDP4TOpP6jiNwvIq9GbeqPAP9x6fjOCV2gHblb9xeAD8QYl52G/wD4ahH5ByLyMlHW2ReIyHfBnH3yraLMsOeJyCejZqmO2fUkMAY+S0TOpo5+NbwFeG1y0F8NPwh8GPhJEfksURbY60Tk/yMiX3CN4z6c/v5xETklS0wtVMD+crw2PfR9wOeLyGuT0/K7UVPTjeKfA18jIn9eRO4Tkb+NOjY/FvjnwNeKyJeka30tqlXeaCGifwp8AvAD6fnvEZFPF2VVPR9ARP4fEfmjoiyil6IO+4dQEwzo+3+9iNwlIidF5Gr9r9OMn44A/DnUtPP9IvIa0UDG70d9SDf6zB9GzUn3pvvNYE4QeCPwk0/j/m4G3o6+029Jv+lncyUh4/9BheKPi8gbUh/5VBH5JyJyNW3wKPxLdJz8cVH22D0i8nki8jlp+81oF8853MqC5XXo7Hp5+a8xxhk6cFTA/0S1kAnw2THGZTX8bagp8BeXVOG3pnVvXb5QjPH7gT+DMljeDrwDdQ4+knaZoPbUHwb+AA1q+1WSGh5jDMDfTOd4mGtrBf8DeJyjzVzd/ZQoc+g3ge9N1/wx4LXAR65x3DuA70RjZJ5AO183UPw5njp25uvS+d+Gmhke4ekF5n0n8H8D347a+T8ZDdL8WOA70Of8TvS9/yFU2NxQ3EeM8T2oljUCfgadNPwb1M9wOe0m6XrvQtveEPicGGM3oH8jyi56Hzr5uesq19pB29KfP2r7U9xnRNvOBGV1/XfUH/g+bvCZ0ff0JCqoLrDQKt+Evof/dKP3dzOQfEZfjP6W/wsl3vy9Q/s8jrarJ9G+8T50QvY8lAl3vdd6DPhUVAi8BbWI/BP0t75Z7eI5B3kOP9stC9HYkK8DXv1MND4R+TNo53zVIXvzcxIi8u+AV8YYX/1s38vVIBpT9Q7gpU9h3ryec62hE5qvjzH+i5twb29BJ2Tf+tGea4XnJj4unfe3AH4AZX3dxkIr+liiAP7Sc1GoiKYI+ROoluXRuI6/wNFO3WODGOMHRAN072HBVLouiMgfR01f70FZbd+ImsE+ag0jCalfQ7XNFVY4EiuNZYXnNJKD9z+iDtYeGkvyL2KM/+ZZvbGPIUTki1Cfw92oSeydwN+JMb7rWsetsMLNwkqwrLDCCiuscFNxKzvvV1hhhRVWOIZYCZYVVlhhhRVuKlaCZYUVVlhhhZuKlWBZYYUVVljhpmIlWFZYYYUVVripWAmWFVZYYYUVbipWgmWFFVZYYYWbipVgWWGFFVZY4aZiJVhWWGGFFVa4qVgJlhVWWGGFFW4qVoJlhRVWWGGFm4qVYFlhhRVWWOGmYiVYVlhhhRVWuKlYCZYVVlhhhRVuKlaCZYUVVlhhhZuKlWBZYYUVVljhpmIlWFZYYYUVVripWAmWFVZYYYUVbipWgmWFFVZYYYWbiqcULCLyfSLyc8/EzVzl+g+IyNc/jeO+WUQeF5EoIl8mIt8kIh/4WNzjCis8Xaz61wrPScQYr7kAG8DWU+33sVqAU8DwBo95HRCBzwfOAn3gm4APPFvPcVyW9B4i8D3Xse+bgV8CdoFLwM8Cn3TEfl8A/AYwS/v+T2C0tP0HgA+m7RfTeT75iPO8HPgJ4DIwBf4X8Nql7X8H+D1gDxgDvw38xUPneCPw48BH0nN+/bP9zp/iHa/61y2ypOf878CDQAk8DvxX4CVPcdz/BrwNeBLYB94JfMmhfc4BPwj8PtACP3eVc50D/lPqA3vADwOnD+3zD1K/3Uu/0x1XOddH3d+utjylxhJj3I0x7jzVfh8rxBgvxBgnN3jYfUCIMf54jPF8jHH2sbi3Ww0i8mbgL6IN6Kn2vQvtRL8DvAYdsHeBnxGR4dJ+Xw78e7RT3A+8FvgXgF863a8DXwZ8AvDpwMPAz4rI7UvneSXwK8CHgM8AXoo27OW29wDw94BPAl4FfD/wb0Xk85f2GQHvTvudf6rnfLax6l+3FCI6KfozwIuAzwUc8PMi0rvGcW9GJzufg7bbHwL+vYj82aV9CnTy9m3AkRqsiBi0T94DfCbwWcALgf8qInLoXD8B/JOr3dBN7G9H4zqk9PexJD2778BXoQPEGPgeIAP+GjpT3AG+G8gPSfvvRgenHeBfAt/MU8xy0sN9/aHv/wj4TvSHeBz4dsAt3V9cXtL6b1q+1uHvad2npmPuXlr3auB/pOe8APwY8LzD50Fnb+8FJsAvAPcdOvergZ9mIf3fDrxuaftnoj/0DHgE+F7gxE2cbZ1Jv9enpvu7psaCaiERWDs0w4nAK9P39fQ8f/UG72Ujnefzl9b9IvAfnsZz/Tbw7dfTdo7jsupft3b/Al653Cdu4LifAH70etrE0vrPStd60dK6l6Z1bzpi/zdxFY3lY9Hflpen67x/LSrFPhP4YuBL04v6FOCz0/c/D3z50jHfmhrHnwf+ENoB/sbTvP5XAY+hKvlXAV+JzsQBvgb4WnTGfC4tTwsi8hL0B/g19HnfnM77s4dmKOeAvw58CfoO1oB/t3Sel6LmoZ10jk9EO6tJ27sZzQ8Dr0AH9buBH+tmIiLypmTPftPTeA6DahTfFWP85es87J1oJ/wrIpKJSB/9PT+IdnDQhr4GzETkN5PN/RdE5A3XuJce+ruPgXekdSdRjehdIvIWEbkgIu8Ukb9yrWcSkc9GZ45vu85nulWw6l+3QP8SkTXgL6OC6v038OgAm6iQvBG8HvhwjPF93YoY4++zmDBeF56R/vY0Z1RPcHC29JOo/bBYWvfjwI+kz0OgAr780Ll/nac3o/qJQ/v8FEvSFzW7tIf2+SZucEaVnvWHD+1ToPbIL1g6TwucWtrnzwIB6KXv3w/8LmCu8oy/AHzLoXV3pXt5Vfr+WnRAf+1R53iKd/iNqTGYpetdj4/ldegMuU3P817g+Uvb/366x4eBL0JNYf8CqDlkd2YhTALwEAdtuZ3NfprO+aq0fwl8xaHzvDydp0UF3/92vW3nOC6s+tct179QIT5Ox78beMEN/uZfmvrI/dfTJpbWfzfwq0esfwfw/zti/Zs4QmP5WPW35eXpaizviTHWS9/PA++LMVaH1p1On18A5GhDX8avPc3r/86h74+ipp6bjdcAf0JExt2COp97qJ15fv0Y44VD9yMsnv/VwM/HGMM1rvO1h67z7rTtPoAY49tjjC+OMb79ajcrIj916ByIyBvRRvOl17j+Uec6jZoL/hvaEF8PvAd4S5qpwYJV+M0xxh+OMf5WjPGrgPehZptl/CDagD8V+HngR5IfZ/k8Pxlj/NYY4+/EGP8lagL6qkPneV86z2vQQec7RORzrve5bhGs+tcx7F9L+GeoVvTpqI/ivyz1iWsi+Sf+DToJ+K3rOeZjgI95f3NP88aaQ9/jVdYdFlzxaV7vMOpD34+61lMhoI1zGdmh7wadDX3LEcdffIr76Y6/Hhh0FvT9R2y7EQf0X0Zt7ct4M8r8+ciSf88CbxSRL0Pt2Y8cca6vBCTG+JXdChH5ItTc8GfRRvhY2vT7h459N/C85RUxxl3UPPMB4FdF5L2owPvfr3Ge30dNO8vnqdM5AH5bRJ6PamQ/dcQz3KpY9a/j2b/04jE+iWqQ7xeRX0Xv9UuAf32t41L/+T5UKzjqXp4KjwF/+Ij1Z1j0oes9D3wM+9vTFSw3ig+gjeOTWcwUQG3BzxaeAE6LiI0xdgym+w/t85uoTfaDMemFTxPvBD5DRMxVZlW/Cbw0xvhRxQFcRUD8S+BHDq37XpQy+Y2oc/YoDNHBYRmBgwPGL6W/L0bNDR1ehNrOrwWDzkxBzW0PpfMs40WoaeZ6z/PxilX/egb61zUgPEUbFJGvQM3EfzHG+B+f5nV+BfiHInJfjPH96bwvAe4Ertd3Cs9Af3tGIu+j0hm/C/j/isjnicgLReSfoPTTmzXLulG8DRgA/0hE7hWRLwT+5qF9/il6jz8gIq8VkXtE5NNF5DuT5L5e/J+oyv2DIvJJ3fVE5JPT9n8IfL6IfJuIvCpt/2wR+bfJaU66/ntF5LU38pAxxidijO9aXlCn4U763qbzf7OI/PzSoT8BfIKIfIuIvEhEXs6CEfSz6dwfRDn13yginysi94nIN6MN9l+l875MRP6uiLxaRO4SkdeIyL9DKZM/mM4TUQbTnxaRv5me/y8AfwX4ju6G0vt5g4jcLSIvFZG/i9r7/9+lfUbpHb4KNQ+dTd9fcCPv7VbCqn89M/1L1MH/10Xklaktvx6dtAWUzdbt9/OpH3Tfvw7tD18D/KKInE3L9qHzd+12G1huxx1+Dvitpff1OpTq/+ssTeTSvb0KNZECvCSdaxtubn+7Gp7JlC5/H7XX/xBKBdxCB6ryGbyHOaIyK74CZd28Cw1i+j8O7fMelIUyAn4GnQ3+G9TcdPkGrvV7qCPtFNoAfgf426RYjxjj21CT1StQLeB/oayWfRYmkAE6oxjc0INeP84B9y7d8y8CX5ju6x3pvs8BnxNjfGDpuL8E/CiqBf0W6kP5jBhjxxwrUZ78W9CZ9X9FO84bYozvWLrevwK+Dvhb6O/x94CvjjF+79K1bkODLd+X7ucL0Bngty/t80koJfK30/3+zfT5e274jdxaWPWvj33/mqFm4LeiLLAfQunNfyjG+ODSfvdykC33Naj5+V+jZqhu+TEOomu3fwz1a3bfu+cMwOeh1oafRyd4H0Rp+8sTiH+Ujvs36fvPpO9/fOlcN6u/HQn56DTQjw4i8lZ05vynnrWbWGGF5yhW/WuFZwvPlI+FZEq5H2Wq5KiT6NPRaNQVVljho8Cqf61wnPCMCRbU1vvXgf8bNcG9F/gTMcaffgbvYYUVnqtY9a8Vjg2eVVPYCiussMIKzz2s6rGssMIKK6xwU/FMmsI+WjwDqlU8dJnD35/i6BjxYZHUtwtIDEGp9c66+bq4dF65Io7smYDlyvi1jymejYdc4Rr49PtfGvM8Z2Njg9vOnePsmTOUZUkIgUFviLUW5xxt09A2La94xSvYPnECEKzL6A/6eO/x3rOzu0tZaxxjXvTYOrFN0euR5zlt22qaD6t9QkSw1mKtxRiji83mfUPkYFNxRbFYJwZNfceR+897rECWZfjgKasZzlgyYzFGkBhpqpLYekLT8sM/9EP86H/+T/z5L/1SXvqSl/DSl7yUCOzt7zEYDBkORuRbm5gso7y8CzGCNbiswLmc/fGYuqmp6xoxBps5YghEH+YpTqqq4t3vfjff9V3fxRvf8Km88Y1v4MyZMxRFQVnO5mMEh1KjhNASQpgvS6lWeOWnvPHY9qlbSbDcElhu5IKg/wkRFTrd5w7GmCs60gorPBNwzmGtBTg42IvBObcY9I3FOW2rRoSI/hURjDFJaBics8Qoc4EhB/YJOqjLwWV5v27p7id9OLD+8PfDfUdYCJYYI0aEIs+RJHG6gVkQxBjEWrIsoxOwm9vbuKIAoNf2yTIVeOV0CsZgI0ymMx45/ygnTpxie/skDz74INPZlDvvvJMscxjnCN4Tkbkw6PV6bG5ucu+993LmzBlGo9HSuzeYZDuKMSJzwRKIcekdp79zIXSMsRIsV6BrqE9PQTJyhHVRIIZI0zQs+7REhCIvVHl4xiCslIcVAEajESaNaM45iqQZxBjp9/qI6MBoxECMC0EkFpsET4eiKBCjWnCW5wc0EoU9oLEshFansdgrBMxcgKRtoIOwai1yhVA5DB8jzlnW19eoZiXlbIb3HkLAGdV8jHUMh0M2Nzd5wX338QkveQkUPYiRwWBA8AHfei489hhN03DbHXfy+Pnz/Icf/CFe89rX8epPei0/9VNv4dKlS3zt130dw+GIQCR4T2j9XAiMRiOyLOMLv/ALOX3qJKdPn6KqKrz3ZJlbaCJzTSUQo0FkYfGYJ3hMAuY4YyVYDuAooXJjg/CyGjs/gxisMYgzV5jAYgTvw0pzWeEZR57nB9pqp7XEEGl9q7N6kaRpWMQIEXDWanuWhXZSFAXWOWIUXOYOaC3dzNykCdRhbeawBnN4HcbAEYKlu+cjIWCtxXvPk08+Se4yijyHGIghEio1+dVtOxeaJi8I1rLz6GNApJfnZFmOtY73v//97O7uceLUGQbDAS9+8YvZ2NikLEvue8ELKOsaY4ya/dRQgXEW36jGUpYlIsLZs2cpipy6qWm9mrnskoCOScPphHqMC21m2RS2Eiy3NG58oD/qx+/UaWOuVE3aVhuXMc+4z2OFj3M45wghzDXpTggECbRtixGDtRZJ2geigsXagxoGQJ4XuM50Y80B/wkkTWUhH440gR3WYkRED0jXBdR8dcjHchTECHmeM51NuXTpElsbmwz7fSw6eJdVhQ+Bpq6JMZI5h2QZXgwXH3sMEWFja5PR+gYuL/jQhz7EY4+d51Pf8EaGgyEvfvGLcVlBVVXcd999uCybCxYEbKfdta1erywxxnD69GmqqqSskvZEGh/SfcckUDrEKMS4EDzdtuM+CV0JlqvisPYihz4ftU2w1iWBstjWtQHvOyecT2aFDGsdB5PH3sj1ns62FVZYQERwTkkl3UAXQuDCExfIsoxTp07NBY4KAB3czbLPwxhya5LjPAmJJfPVQkgsD5jxir/LmtPyslzjmhgPav1XGWCDD4z3x4gId955FxICTVXTxAAh0nqPtZatzS2KPKdtGvYvXGB84QJbW1tYY8iLHLynnEx42Uteyj1338NwbY2yLPHes77eZ3vrBFXbEGUxgWyCn7+zoijw3jMdjwkhICJUdUVd14xGI5xzRO8Xz3/Af7R4V7eClrKMlWA5EjcyIB/e1jUMnb0tEInJeei9xxhLmgQeeY7rv96NbFsJlhUW0IGMualKNWe134/HY3o9TWJ70J8hiZSyMEWJEWzSIkJSS65wsMuNzbKvx4fSPcPVhYuKpEjAADbCdDLBty2FNdgsIy8KndxFCG1LW1aMx2PyLGcwHLI/nrA/mbCxvs7G5ibT6ZSyqsiybG7Cqptap4adAF1ihhqj/ilJfiq1aOjzZVlGlmU0VbXwoyQNTX1dt25/XcWxPCXk0OfD3w9uU59JpK5bqqpiOi3xXjUS5xzOZTiXz81iTeOpquaa57y521ZYQeFjQIyhPxxgM0cbAj5GGu85//jjXNrZwViLSaYwbb9WR42FnJnPznW7m2s3HSJxvt/VfCNHzcivJVyeSuiICOvr6zzxxBN82z/7Z/zGr/4aVgy/9iu/wk+/5S2Us9mcGFD0eqyvr7N55iyx1+Pr/8HX86/+9b8mGw752be+lb/9t/4W++Mxp06d4t9+93fzMz/1U7zohS9iMp3yS7/0S/z0T/00P/dzP4f3HpdpyZm6rplMJmpmBDWrbaxjMsdwNGR7e5ter6cmuCP8qzcW6HD8sNJYromnNyCLdMwNMCZeoZV0M0PdV5aYMysBsMIzh24g1/YnB8xSbdvStu2BAe/wQH8Fe0uWIrIOaTnLJuHu2MXfK+nGy5B0Ppb+Hr6Pqz2fEaHf6+Fbz97uLsPhEEHIez1EhNlkwnh/n8uXL/PAhz7IbDpV2vHGOjEEekXO1uYmvV6Poig4ffo02ydOkOUZvaKg3++ztb2NS8yukMxgiziUMH/H3fu11uKsISRBLke9yyPe43H3qyxjJVhuMkQ6YeFwR7xd7yNV1SBicE4dqCus8GxgHtORBqw5zTWxwpaD9padxp1iISIYMYg5ZPhIAkaMJBbXYv/u7+HPV9VmRNSfMxcsKgSvx1RWzUqGgwGv/+RPwSB88AMf5FWveCWbGxvYPGM2mfDEQw/zwAc+wLt/7138yA/8IHfecQd/8gu+gLNnz9JOp7zkhS9i+IV9zp45y3Aw4M998ReruQo4deoU/f6Q/miIyzNCCFRVhV3yWTVNg4jMzYo6qcwoioLLly/TNA29ojhA3e5+E0nPHtLk81Zx3MNKsNxkRLwPiBycBdZ1TVVVfOQjDzKbTdnb2+fcubOcO3eO0WhEnufP9G0+8zj+feHjDl0QpDrt41JMiWFjfYPhcLjYeT74mwPMrm4JXQzGXKgYFSydZt6dgyu1jcNCYnm235mrun1Z0nDgGoNsjEQf6BU97r73Xtqypq0qppMpbdNw6vRpMufY3Nri5MlTnD1zhuFgQOYyvb6Ay3PdLy9497vfjQ+e17zuD1E3DR/6yANsbW6ztXWC3miIcZa6aTBWnf4xqgmwruq5X7V7noiaIaO+DL1dFp8PPEa3XlRQc4v4XVaC5SajbT3GLKJlY4SyrNjf3+fd7343u7u77Ozs8Amf8AnkeUFR9BKbBFaj7wrPJA6zwTrfiLWWjY0N+v2+7tgN4klYdAP7gZiTGLWOdcdsSn1AlkxATyVUDguX+X5HHHd4/+V99QRKKy6KHlunTlKOx5T7Yy48/jh7+y3bJ7bJnGNja4uTp05x9tw51kZrFHmO954YIi7POXHqFFvbJ/jZt/48jz32GC97+SsYT6e8613v4uUvewV33HEX+XCAWEsz3sdYS5bn8+fqhMpBwRLxIczfU3fTMcYr53xza+JhQtHxxkqw3GTk+eKVhhDwPjAY9MnzjPvvv5/pdMru7i633XYbt912LgWpHTlZWWGFjykGg8E8jsXaReR9lmXcdvttZE5ZS865OYPJuSz5Dg3GWSTFtPhOy0B9+9bauVNaTThp0DxkeusgctAncSC+ZYmG/FR04zj/n97Dhz74AX70x36UN77+9bzhU15PcffdOoC3LW2MuLzghS9+MZ/7uZ9LaFUAfPjDH6ZpW17yspcSEXwIvOY1r+Gxxx7j27/zO9na3ubTPv1NnDl3Fpdn+KYlti1FURCBsiznWleXJ03SO8vznBD9PGDSZdkBOvHBJRBCl9plRTc+dni6P8j10R2BQw394HFxzqbp0jiMRiO2t7cYDPqJgrx8rsP3cNQzyIFt14vFKeKBic8B5+gVx1z93XUzsqttW+F4o6MZg5pZrLUaAImwNlpbaCNLmokxQgik2fYSm2npz9yRv7TMQ7uu0Sw638Ly37QBltbDtdvXYpIvzGYzHvjQh3jVy15Oludk6Rmb8R4xBIiRza1N7rnnHibjMdPJlPPnz7O7e5ndy5fJe31cnjMYDOj1+3zkwQfxMXLixAklAhhDiEohtjYFnLZ+KS1LIkSkezLWEtowT80CwJwWzSHBsnzkrYWPC8ECHIhmhYUA6GZsHU1yOUjrerEsHJb9mNYarF2sWF9fI8YR29vbS6ywK8f0hXP04LoQOqfeR6fhxAjR+/mgcT0HdJ3kQET0fHOabXqv2V3tM5r8bIWnifFsihHB5hlRoPGtxn6IsL65QURps+JbGkhMMY9YC+ZKhpgRwbp8vr7rcxqFL8QjMn8b08W9HErjsoQQgqZIWRJ0R2k98/tIsSO+bbn77rv56q/+as7dcQf0ejTjMbFtyfKCGDzV/j79LNdMw3fdRVWWfOShB3niwgV+6Id+iNe94Q28+pM/hbf8zM/wwQ98gC/+kj/HbbffxtnbbsO6jDZ4sqJAjNEks0njW76vmJhfXZ9xzuKcmWtyHlQrab3mGUN9PFFI/VMHGE2kGY987uOG57RguZb6eIB5cRSP/MCxV2oIh/c/eqAXrtRmzHLqo3St+aelz0edcBFkmfrOdbFjjrqrhSoUCHExW4JuVqiz0+UY0QPp/YWDzzZ/viu3Xf15Vng20U0QNGvxYsIgIlhnl9rXQc1k0URlrkmkBrJoj2n9wil9hD+k0z6ucY9XhCjLlQINDvbnrn1bY+n3B5w7d45Bv09dVUi3HzAej/nQH7yf9fU11jfWyZ2a/TY2NqibhocefpiN974XkxeIEU6fPcNdd9/N9skTWGcxzmKMVX9JCAfezbLGdUX/TCa9uSaXhonOxHdgzErbFmZAjj7nMcNzWrAAB3jkh9cB8xnG8nfQ2dkCCzaMyPUKlRvDsnA50imZrt1F7qr28jTpygJiu0jgFt+qL8iHFogYcVhrcJlNgZxdzqcI81e3PJjoSTU9zdK2+We49vCxwrOBjhVmrcU6u0jbgqZkIWqaEitGE0+m/F9HMpiOkB0xDbTd7Bsj84Z+3ROi65yZL4TKwlRWFAVFkTMa9plOpuw9+SQb62tkRQ5NzUMfeZDv/b7v47M/94/y2Z/3uVCWZM5xzz33UNU1b33bW3nvH/wB9kd/jC/+0i/hE/7IZ/HiT3wV1hjq6RSbZbi8x/7eHm3b0B8OrqpJHXwkNcEd9qnAQrjc6njOC5blQMQO3WyiEx7Lppvl1NRpDSwFd+nEYeFcW+5NOvinAfgAlgfXo43NV/Yx3W/ZgieCahEI3Qi/aJSHr9F9Pur63fvoEg8qe8fGtA6bYhC6GWVcOE1l6fwxpvQeB9X+TgvSx9QPxhWHH3CFZxmSVOfup5ozWbsZ9Nwmq9t8DJqOyLkDQX2Kxb4Lf4scMVAe0HuvS7gc2CPGA9rJ0Tun9dYSvadtW2yWMVhfZ+fyDm1dMyxyptMpIQSmkwk7Fy4wyHOiwNrGOnfceQef8qmfyvrGBuubW7z0ZS/j1JnThLZVM2BivGEEm1mQOH9/8/fZ9bVDz9xZHZbT5B94xE7zEZlrK10escUVjjee84LlWg23aZoDWVaXHW6L2JJOeCwLBQ4JFh3o1YFn0iRreVuHOP+r+xwUArJkQtKspl2jW/hVjOlyCKkAC2HRjA/f40HBcnDbQgMT7RxqxV66r+4ZOjaPT0d2FYkCsdP954LF6HrfLvmdVoLluGJ5dj1vGd3geGAWrYsPgTZ4crJDdmHmTU4OSpZDQ2q36fCk6imEy7I/j4XZ9ahjOzOXIGAMIWiQYtbr0ysKHnrgw4x3L3Nya4vpdEKMkTIJFnvyJM45Rmtr3GYNxaDP7XfexR133UWe/ChV0+BFMJn6mTAyD4gECCl9zZI75OCjd89xWFM59K7j/BUukRlYMp8dczznBUvTaB6uRXbWRYxJx+Nf1li6bW2rZVaROO8snalYWBqU5x2p01Q6FSMk4QDzATqadL64dJw2RCNdluPlVhNYJLM8OENrvQZeuXlJ16OFyXzGGKOeZy4EjvqrS1PV1E3DZDJmOp0xm82YTie0jab58CHQNo3SqZNjFUHrXMSIb5uFLyhJxD/2BX/6Bn61FZ4JHDDbdANbatOBK8kubdvSNA153jvgS1kWIDGtmpvBDp5l3uqfto9gaUA+yteSvqggbBuC92rWCx5fV5w7d5a9fo+f+5mf4fLlHU6eOsWpM6c5feYMxhqapuHR84/x+PnHedfvv4s3fuZn8vyXvYzQ1BAD+XBIFAihpaxK6slUI+czNycZXHFvgGHpXV/xSEf4VpbfmRzc91pszOOC57xgmQclHaE+H+W07xzQmjhyWRMwnUth8fdIxCs+x6VBmxiJEpfkQNDVaClTWTo+8UNSR5LkY1Fh1dQ1Pnga6XxBB7WndPJ0tnCFBiFxIdQOz6TqqqSuavb29hiPx/OlrmvatqFtPXVdzwO/lgeoEEIyMapWtipgdnxxeIBamD4XU5/l9V3d9bmDHDopcaDZL3wwSyuX2tmyH2R5+1Ohy8Z8eMp+NbNYCF7NtdbMj+v1+lS9kvNPPM5sMqHf69Hr9ej1e1qfpW3x3jOrSi5eusSsrBBriU2aKNk0qcQQYkPd1ISo2cp7qaTx8nhz4AEPvevDzLG56WyJKHH45RwluI4jnvOCpSiKq7LDDvtWNI+PDuBZ1m077A+5UquILFErl4p5dRO6hTazbFLrzqkaUlnNEpHA0TFxfMrX1LaeGAI+eOq6oa5qJtMxZVny0EMPpyCsTkDBIqBqYbI7/L2ZzVIDVbOYMV3NDZPMbQsh0S3doNJRtLv6MkfZfLvO7pbMBCscL3T0+rZt5078btAyKceXcaQSD3ae+6oTHJ3GHjlkmhI52CI6p7rIXGE+vP9hjXwZB/puCGCuwbhaQvCavbnoUtNEmEzGzGYz1tfXMWg+saZtab0nW19ntLHBy1/5SrZOnODy/h4ba0Nme7tKkjHCZH8PmzkGoxFZhMxH/ucv/RJ7e3t83ud+LoPBgAXj6wjhEtIEcKnIjI9pAnnglXWMsQXd+OC2lcbyrGF5Ju1TYZ/uc4xxLliWG/nBdrrsgkPLhhLnJp8QfJrFxbkQmE5myfcSiQuDdXdHLARTZ1fTRtO0Pg3EWklSZFFd0vuARuEG6rqmrhtmsylVpalivF9oCLqEJBj0WiH4hcaStvm64qB/pytBuwhoi0vPqPewUNn1nEcVIOre4aJe90qwHF/Mf8P0/fDs/3AfmrMll81gc5PwAtrSF//v1i2bza6HbpwufkCPP8rh3Z3vgAbWVbBMSnznALfOceb0GXLnOP/YeYxzmDzjsUcfpW4aTq2vs7GxwW2338ba+jpGBHFKaLGooI3pb5bnjNbXVAibZPC6ioWku34nZA//DunpDrybhUl7yci90liOB7oBOc9zjDFMp1PatmU4HCrV8kCZ1U6YdAPpwozUtg0haQ1t21KWM5qmTUtFWZb8/u+/h6ap6QZ6EGLspicHG0vX/YwRiqI/v34nrLrBe3FcJ8TC/BqDwSgxxRaCZTHokwSSXzjl071kLhVmmqeMCDRNSELkYOTw8tKZvjpNpLvn5RnkcqLCGLtrr3DcMA9sDYG4NAG4ckas+1VVtShcRedPOWi2kSRsrhwgdaenMxwevhfm1oVrB/fmRaH7h0D0ntB6MudYW1vj/k96NY88/DBPXrxINhyQra/ztv/8n3n80Uf5y3/5L3Pi9Enuf/Wr2djapuj3kCIHY3BpkA8xqOaSF7z6kz6J1mtKl/mTHjHwz4X00ru6Vqxd2gs46FdZaSzHDF0neuCBB9jZ2ZmvX0690LY1MQasM4hEkIDQZSr2aXCNiW1S472aqnxo8W3LZDLWgZyQWpCkz5HOTwOLc+o1hKZRrUM1BNU2uhrh1qQklZKERWCu6VRVmQbxJY2Fjie/0C70/vXaxEidHI0dCaGz3aobprtfJRqIAMlXMhoOcFlGv9fTAlDGJLOYp06102PUKHyfTGZdJb8Vjhc6n8nyBKKLBYnEuRgIaYLVtC2uPWgKmw+g8aAA0f+WNI1DvrynEjELqvNC648xKg1+yW961Oy9O9Z7jxjVJHxoaJtGi2/VNUWvx/aJE7z4Ez6Bcjrl7b/yK1x44gn29/d5+9vfzubWFqfPnlFqsbXUtVaJLHp9QJNI+uBpfSTLMvIsO+QhnT/2Fc/A3CR9kBV2WFgsJroH6cYxxnnq/uOKjxvBsuyAfOCBB3jwwQfnmktVVfMftqpmhODp9QuNkDcBI8n3YGGuaUTVakKIaBltncmvjda00XfO9Kh6uDaPIwSLAUjnCIHWN/NzusxirSFzIWWLZX7OVJaCuq5S91VB1gmPzk9/gBbdbYuRpqoQIHN2bl9fYCFUOlNHt8/GxjpFUbC2tp5SUzhmsxlN08zfZ9M01HVDbGrapj4UbLrCcUI32QrLPovDbkBUuLS+pUm/5eFh7frGuUPi5Go+lfne85tcyK004Tk8KJujnOHRIxiM00SSdV0zGY9pmobNjXW2tre57777+PCHP8R73vV77Fy8SFmWvOMd7+D2O+/g5JnTmqPJGupSY17yoqessBiom4aqblkfrZM5R1vXB+5Lkq9JDgmMq1GNl59eRNKzLmjGnUnweOsqio8LwWKM4Jzm7RIx7O/vcenSk5RlnWZrnjwvyPOC1tfg1RwUYsTESJCoDTQxs5QaDAha91pkbkmuys53sTB3xTlLS22wYnSbLE/josyFgWaSzRmNhuTpsw9B2Vp1o+ysqiXEoGYnPUHXJJk3veXpYjcBjHrdIi8w0qWz0T4+H2SWojK7HGpdlts8VxbNcDRKZZYd3oMPQlXvUpYV4/H+nEl26dJFqrq6qb/nCjcHxjhAMMZjrcM4reNuJKV4IbXgqIOjjYIN4NC4p0z1WUJnFyMSTVx2BiSzWddGr1YptZvRM2+q82h9OTiQChGTFiKYoGO/ieAlEfRF+4IRC8nPZ62j6PfYuXyZyXjMxsYaFy48wX//bz/BoN9nNBzyaW/6NLI84zfe/hu4Xs7Z592JzTKa4OkNBkSgahq9KTEUeZ9ebqibmrqqyazjQP/jwGMt+bOWfJUxHNyxextLp5gbwpNwMXOhc3xxywiWp3qNSy6yxaelgxaBkOoUr+pK1dsY54MqoDMfYxaObMJinA5BVVAJC2d3Iu5LEgze+7k2o4O+ISQTmkm2LQlxLlQWpoeUo8lYMpdRZDmD/oAiL8iyjNa3ygxrg+4flERgbHr4jj68PGtbfmtRv3esHB08JLHYulngIpp/+Z0ZY1KGZhUk1mn6dGMdIpam9VRVzSTFvOzt7bM/HjMZj9nb318JlmOKLMtoW4MxLQFovQoYMYui9kIqcR8FG3UAN5H559D5odOAmXTl+eAnnTk1SYhImsToIXOlRbrPInOhEgSiLJl9IpikrdgQMSaoWQw7TxcTCOk4mWtfIV3UWKtaV10Tg/opL1/eod/rsbaxzqnTpyh66owfjIb0RsNkRfBkTqs8NlUzF5aZdVjrqKsa3/okWJZwoPvFK0xhyW692Ddq/4wic3N0RwoLcSmR5fKLO6a4ZQTLjWHxawUfQCIuOatjjGS5pSgy6qpWH4Yz1G1FVVdkmSXPczY3NxGJ+LambUOK3SgTAyvgrCVzhWo2ycdCjGRZTgjQNi1Fr0eR99jb36VtGgZ9pT3GEOYdcNAfYK2lbT1ZVrCxsaGEAmPZXtum1+/RK3pqrmsimWT0sh5VWWl6jS6g07eEpGn5zukfuga9eDM+mRJaH3DOkPUzjU3xDc5ajEATPFo62RKJ1E1NlheIsfT6I7K8oA2GclpSliW/97/exYUnL3Dh4hPUVc2snOGcHm/zgmFvFXV/HHHmzDnKquTJixfZm0ypHn6Yu573PEbFkHo6w0bo2QwThTwK1kMWA3njyTKP9Z3DX2h8QxMCMTRYa+n3ejoQ+ohNGlDbJmq+EWVVEpEYMVEojOalM9YSLHgLZfQa3ZUnrTpEYu2JdUMfQ4bB+gaXF2RbGzRNyaytsYMeYg1V7bEi9FPxLu89J06cYNQf0FY1Z0+e5q9++VewdmKL4fYGv/S2t7Jz6RJ/+HP/COubm9ShovaB2nsGWYbDkRV9oo/4xqtJOkLf9Qim00QOJbFZ2KS1T/owT9cfY9TPQf+GpsU6S+YM5awm+ECvV+Cjpy4rssyRZe46HP7PPm4ZwXKkU+y69lyiOybNxFqTihc5EMgypw7zGOn1Coo8Y2NjHWJU5lfd0BgVHN5ouhKlFmqq8Dif+ZPWpep8UTWYIsvJnCNLOZYidm4vtcboUmQUeU6/6M39QXmW0csLekWBAP2ip500GRc6c10MASNCS7vgmqXZW+zs0+l66aO+mQC+9TR1Q91UhEzZcSEErNO4lhD1vZDWX7x4SZ33gxFVXVOVNXv7Y8bjKWVZ432rVQMRQoi4fJVG/7gic5mSRiJ4H6jqZBpe3ikmbSKoOUxCxAT9G7wniFETjTAvRTyn3caobCxaEDUlI4KJCy+eRDUQuwCGgLQ+md5ACIhEYmjpDGrGGGwmmDb5LkTU31GVtInxGEJX30TbblmW2BjmVggjQp7lmFwYFjm94ZAiy8F7QtswHAzp9XqJKdfFu3WmajVfta3HYLAYCOl+U6LWgx6Tzr63lNtviTTREScE0oQylXtOmhukMSWNN13cUTxUBuS44ZYULDeiBF7JSFQWRxc4aYxRmmAazNdGI3q9gnNnztL6lss7lylLnZn3er2koah/IwYPYpA0Ozci1FWDGKHfK6iqitlkzOnTpymKgmpWLjVU6Oi7IKyvbVAUBcPhUNOmeM+g12M0GNDv9+nlOdF7ZjM1N3XHT6fT+WzMOzc/drnRHv6rQkeIMTCbVUynE6azCUXhsM7g8gxjDVmWzQWLEaGua9793ncjYtna2lYjR4zsXN5lVpYQDXneYzDsU1Uzqrqc+2hWOH6wxmHEKsux9QSzYEgaI5ioFBMTUGHiI2ICNqo5t61q2mjwWMRZnBVtOySXc9tC3eBDQ8TQ6w10EiWi2kmahKkACoQ24GODNRAs5A5aA1WrfQrrGOR9hv2CZlJC67GZBm5OLl7ADnqYfo+qbog0FEVBWzdcvrzL5nDAxnBAaFp807KxdQJHpBnvYpqWsLtPgTDIcpwYDOCDx2YFmc2QNFS2bYNvPFVZg4sYJ4TWA5Hc5aicuZKlFlnQ+DUeqEklkHVvawxZket7F/BZhhGjk0aEftEjBI9vWmaJJHOcccsIlqeNA7bI5FRPM4SOLtn5EcQIea6aQxdMaZPT31lDDAaTbL9KN/Y4ZxEMRZFydiXzp8ssQsQaIXMWZw0h05iZoiiwRhlfOosy5EWOcxn9fg/vUyRwbrAu0h/mZI1QVhkh1vhgaJqWGDx5YQhBi9C1raacaNtACELbJmGCJ3j96zvhEpI71Qp5kYH06fcLrDW0QQMzx+Mx09mM6WxG8Eqznkwm5HkvBZyqjVmFh6baz7OM0XCoZkTfsra2Nk91scLxgpo+hejD3FGOT2V0dS5ORz32QefeHqijmnNCFBAHzoFVraVpWnX0+0AehdwVOAw2gmvbuYYic71bEX2TtCGPsYbcWnw/J1hD69t58grbVgRqYutpvOf83gV8jHiJ5FVBPinmiSDrokfwgbas2C1LphcvMdm5jG8a/P4+3nv2L17gwYce5MGHH6Jsa1yRMdnZoSlLWmfoDUcUg1HKj2Zp65YYIk40WFJCwKaM403TgCSyz4HgyINayuHYMGCRCmkeU9ak3GOSsmKodcUYnfA9VQzPs43noGBZsDL0d13QEOdmyY6tkhyPIsxTmmRZRpYCKXWdwVrBWYFoNVeXNbSt0LY11licdRRpthF8mAsWZw155sgzp4Ip00F4MOhT5Dl5llMUOdYaAposrygKFSytJ8sF62AwyGkaoV9m+OBovaX1FUQVPjEK3oOxQXMZGaOz0Kg2BR88iFcBMw+eVIacNY48z8gyS7/fw1jDeDrWTre/z6WdHXYuX2Y6meF9ZLi2gTFa/c45wVmnyxJ7bDgc4H1DXZWsj9YYjobPRkNY4SngjMUialZpU5aRgJqs0Fk7Kct2iEHNTkQVLDEQo/YRkzk1WUWUxh4CvvH0sh6DrCA3VuvWj/fBq0+BmNQSk0gCodL13qsZ2WWQ9YjiwLe6O5GmrmialmANjW/5yBOP0BLJh316s4y+yXTAF4NLZmUTYTad0kymVPv72BhpdvfwTcPlJy7yu+/4LX7113+Vl73q5Zy9/RyTncvMJlPK4Fnb2mZtKyJDTfjaVq067iXDRvX7GGsSY0yp/9Esk4USZ3PZ/HWUYJkzMrWKp0+xX3r/RhNpJoJPx9A8zjjed/e0cSXlr3OWLdKwhIOsDHR2ZpMqWqZ4FmO0lGhwbh5o2Ov1iDHSH+QYMVgxTKYTYjTc/+pXkud5Cmy0WCN8+MMfZjwes7G5hrOOvFDG13Aw4MyZ0/T7PRpfYZyh6Pcpp1Nm0ynrW1sUhdKgY4wMNwZcfPICl56MWKezmqZpiIlyKUYw1mCsajHOOXwIZA14b9Kipo/ZtNHgTCDGQNvW7O1VtG3LI+cfnZvUNC6lTVRjizNqL67rMglhB3iIgbXRkP6gz/r6uqrtvmUwHGj+pBWOHUxHeQ8RCJigmoVFSzNI8gfENBgaazWmQ7lXiERcandtDPgYCG2L+IBtAk4iuYF46TLV/pgHfvudNPv7+N0xcVYRpk1KkwTkFpfnDNfWOXHyFCdOnoK77oTREGxECBgCeS8nK3JKgWDAZELuMra2NshbyFtwUXnHe/v7OJcxWlsnFn0ilknZ4KuKxx94kN5oxO0vejH3nj/P5cceYyPrkTWRftS69HvjMbXNqI2DJmCswzcBKw7Je9TNFF8HfFRfZ2s0jxnWzOO+5szKFHKg486iZDPWUmQZMYSU2cDOwwC6fUIIzGYzrJG5D2aV0uUZwkI+HBX/OifUHpgpCF2dE026Z42Z16nXKPswt3nqX0GsMBoN1ckdva5DqCr1e5w+fZJer6+kAOfIjOGxRx9hMoFeL08mI2Wl9fsF6xtrDId96rZUE0CvwJqI4BmO+uRFQVS+JFnRZzLOyTJDnltEAjG2mhMsUTW7lCoxCsbEuWaxECwQfGcKMziX07YafFnXNSEGZtMpdYqm795pllms6zQTQ4xqAsgyN9fuBoM+/UE/CcM8qez22HeCj1d01i+6vgBzI9WczBQOBfwZk/Jwd+73qGbPVEKBOR1ZMCFi2sDs0i6zixfZ+/CD1Lu7hIs7hPGMOKmIPuWxK3Jcr4ff3KS/O2U0rhGTwdoaZAalojS4E5u47U39HlucM5jMkjtHHiI56gOKMULjEbE40biTKEYp0j7QVBVFr89gOGJtOGJzMKJvM/IouGQBiE1DrHXxtiZYj28i0QScWJqy0cW3qnFkQjSaV8x0Y4lJOcbSOKPvPc4t9CaRCTwqdIx0JACd9y4nCiWZLhe/3vHFLSNYbtZr7PwpxmgkvXMZo2Gf3Glaho3RSM1aTgjeU1bg65rgG/Lc0e/3eO1rXs1gOCTv9zUPUdvyy7/8y+zt7nLyxBbD4QhT5NB6YtuSZ47MGjbWh4gxtE1Dr+cYDApcbjAOchFibKnLkmq2T1lOWAsDYoiMdy9jjGHQ7+ObfZpmTJ4rhVpZXEKMlhgNMR79ky4EqlEzBAXWZOR5b67B7e/vsT8eU85KxpMxe+PxfFDJiow8yzl16nTKE2bZ3Fzj5IltLl28gHPC7bffTp7n5IWjqUuqcsZkPGE2md2kX2+Fmw2BOR3YiiETg0VoY9RMvD5lbRBRX0rmCNbRiFD7Ftc02MqoCRhYL3rkAYYWillLe3mP3//5X2Lnww9waucSg6oi29vHtBHjIy5YTIR2d4r3+5TNo+zkH+BikZOtb2iOLpdRmsiTxnPvZ3wKz//0T+bxySX2Q8PJk1uqrl8e46KlCIa2rIkhsjkcqJZVN5T7+5R7++w+dh6alle84AUU/R48+jhcvAyTkhOnT7MxWierW4yBYbT0o6GIQqwaorT4JhJMi3iopiXVtKSNWr0mZoZoBGxnClvEw1lZaDG2o+In1uXly5fnOfp6vR79fo/pNGUA6RUL34y1RDHUbZsmm8cXz3HBsmQSk4UuoynmO5pf7ArBJTpysh8HdZoN+j0MkcxZQgwUeU6W6axdUPaMZI48V/py29S0vqFvcsqmohxPQCJZ5tTRL4JvIZEhmU3HeF+R54JvGybTfUIIZJmlKqe0raZFgUhdz/C+od9XZ7gGNHYOwS5Z5pLutqQpzP1MQanAMRSIpAScXu+HFEDaUSSdTdqINRS9gizPky9J7b155ugVuc4aU2oa7xumk1q1Hx+o/Co48thiSRNZ9gd0WsyBYFsRQqLWh5TDbllzCTFgYkTEYaLgIhgfkSYwvXiZyRNPcnvbUNQ1RdUoScBHshiQAHntab2HqqFpAk3dQhCic0x8S2mF6cDRTGfg1ZoQBZwYEDOPiYkpG4UxyccYAqFtkBBwQGga2mnJhcfOawaJ4ZB6f4K0ntneGIMw3rmMZE59ryGqlhOi1lFK1oOQHO0igrOWINCm7tb5S0S0tLgAIQkWzWrh5paS5YSSXUJcY7os7Epr7hJudotPefiOM24ZwXLj6AZVpZNIKpoFEL3Ht1pZMqSkdiT6cFOXED1ihX6/z6lTJ9TcJcLe3h4hBKq6pG4qvG8o8pwiy8kzS6+XcfHikzRtTa+wXLxwnscefZQYW4ajHnmuwU1NoxXo6rrk0UcvY0zk3G2nKcspDz/8EU6fOcOZ02d54onzVHXFxvomZVly/vHznDx5krNnTxOiOvj298b44AkhlQMOEFHzwnJusm4bqP9lNov4NlBVJXVdU1XVvLDXdDKlqWty5+gPBvQGfUajEVmWzanDgUi/nzMc9sidINEzHe/Ses/eeEJbq/+nbupj3wk+XtFFf+uAZVPmYohefSsaDT9nt6TBM9IKiOl8CmqG9UF9K8FbiIJrDbaNmCYye+Iik0fOMxoNGLYt+azEt57WB2wwmCBktTr/BwEaERpj8C3UvuWh849S9TL8HSe1nePJ+gWFWbCvjLPQBNoQKHo5IsJ+UxPbiAUyIr1+nyeahv2dHX7pd3+PUa/PvXffzd5j5zFVw8Pv/xA4gw+eweYGa2dOIY3HpAzgkuJu8GqWE6AoMrJ+AcawV07xMSApfqaj/Xe+3M7xHoInJMuCNQbrnNKNk1PeOa1G2TYNZam/VbfeOaeTtmPep56TguVgHZRuWYiazikdgkcImjzOe7y1CAFrDT4G9qzh8uWLyrEPStm1zlLkGcYIVVUyHAwY9Ac0dZUGd89kvM8H3r/LbDol+JZekQE5KX6KPNPrNE3JbLpP6xtm5d5cY9ne3sYYYTabsre3y4XHLxCC1wSVW5tkzlLVDURPr8gJMeC9OvmCj/jQBWJ1kfdx/io6zQbU6araRkGeq9Dosg6UpSbmzItcyw2IOnnb0CwCz2ZTZtN9vG+IwTObTmi9p65KDELunFIwj3cf+LjFvESbCF06Fh88bcqw3QXtdZqMjx5Cm+i0EU/ASso4LF3sSkPw4Guw3oLN6LuMoXXEuib4Vh3ZVn0JEgQJosG6PtKmVCu1b5nEljp3DO45R39rDXffXdiz2+yEmjgssFa4XE4x1jEYjqi9B1qC1Zxngk1CRTB1C74hS87yQb9PvyjIxCh1uaw4ub1N3u9RTqa4PKeX5WRWadc+jSPWGEKMNE2d+pQgrSaqNMIi/Uzye3bvNcaAwSShYg74en0iR4QYqeo6MVZFY+3Qz1muDv6yqpNPdUU3vik4HI1yPegiZWEx8xKReSW84BtMojD6pGYG3yAGqkajyOumoqlr2rpJ9s8+WxsbiBEmk33q9Q38WkPTVBohHDyT8YyHH36YQb+n1OIiT1G1ejt57ojoPcxmWglyb38HEej1MnzbYI1QzqbsXr7Mo4+ex1rL9vYmwWvsTFXprLIocmIMeG9oW08rXmeOIWj6lhjnwgUgRGX8QCIkWIMxDmNsSsSZs7G5QTEr53E6zllsSkrYts28M9TllOkkCZboKcsZrfe0dUORF+RZzmymtOgVjh/SuJgGQDXhdOngQwyaiNIukpy20aspVQJRUg48olaDkGQbaFtiE/FlINIDm9OzGUPjCPWUGFSwSIrfIjG4QqupWps20PhAXUf2fEUdC0b33EN+22mGL38h8ewWl0KN7Y2wmWP38g42y8jW12gk0uIRGymsJou1QIHRySERZy155hj1+/TznMxY6ATL1jajjTUeeOI8Wa+ngsW4pJSpoDAp0r/1bSeVwSfKg0lpZlO2C5UxcR6bEoip/9mFaRrN0TYv21HXtE3DxsYGWZ5TVRUgOJdRVRVlWc39N8cZt4xguTlItmTT0efVv+LsIkFljB6JwmjQT9Ksi8FI1GQRHjv/KLu7l3nve9/DnXfcyV133slwOKA/6PHkxQs89NCD/PRb3sJrX/daXvfa1zAr1Qk+6Pd04F4bps7rWR/dxmw25fff9dtsbm3yiZ/4JjY2NgghcPfdz2c0WuO//Jcf57bbbuMzP/Mr5tRd5bHLUgXLmIp2qV13YR5PMQlGtRi16Qrk6Mwp1XaJUaOBm6ahbVpEhPX1dU6c2GZ7e4vtE1sUeUHr1bw13t+nP+jR7xcMhwPKqkpsNAge6rqlrlve994/4PLl3WfwN17hehFSsK/vgoZ9pG5b6laDHI0B62waGCE0NZhI5gxRIm1Z4TJLcIY8QmYN67mjINCflljfQBNo9nYpdy/jXcAT8KHBI3iEuvGqqVQacOmx+Mzic0vbd4SNAcOX3Etxxxn6L3k+uxLYDQ158jvmgwEihlndYKzFjUZM6oZp3TCylrJu2Lm8x9BlDIzj/e9/P08++hjP2z7FqNen3+8zWltjY2ODixcvcnF3h/2mIh8NUh0XT13XeGfBWfrDHm2IBGtSJdmk+fkwT5rpl+JTOhwgDXVOfGspy5Kf+ImfYDKZaEC2MWTW8qY3vYlz584BzOPDuozhWykM4TjjlhcsN8KNEJhnPTU6UZqr+8v7CB2NVoVQx0f3qTb2eH+fS5cu8uCDD1LkORvrawwGPawxVFXJ7uXLPPDhD/HCF95LjB6faqz4YIlRNQCTCDe9nla5m01nrK+tsb29TZZlmtJlMGA0WmN3d5cT2yc4efIURE042TkofeuvaMQqXJJdF0EO1QhXKrK+PN/NxmIq/JSS5HVCqN/vs729zcmTJzQhnm+p64pe7nCJsBBDpGlarM0AFSyzWc10WpJn2RJFcoXjhPF0zHg6ZTqbafsQaNoGHwOafjRl6WaJ2BK8ZhgGxHtoPfgWJ5ZcDLkIGeBiREJQf03TqBlM1CykM/cU8Ni2NG2g9ZoKxYvRJJXOUucG38twp7Zwp7ZgY4SvS+q6hBAwQYMWowjeB8RliHU0sSYGjzdC8C3Tckbeg5g7ptMJ+/v71Gsb1E1DWVVz5/hkqj6SNjfz9Csxmajm2Yi7iakzai4MkdCmejZmMR7NE0xyJYlmNpsxHo+x1jIej3nPe97L/v4eMUYy5yjynBfcd988wax1jn6/T11V+BDmQuo445YXLHC0cJlz9Lu8091eaVZgraWaNUiRszYc4NsW39bqa3CWvMjVRBADRVFQFMXcyf3kbMZkf8z+3i6+rSlyS9uWVFUgzzN6hWU4yImhYby/S6/Xw2aO6Bt8I1TldM5jr2utWrm9fYLt7ZOsDdeYTWfs7e3hMkdTNrzipa/g3G23IWLV/lzVSg/FUjbq3ctdjk//qmlF0zTkKTVNnuea76wqcVmR0tf4lGm1RcQpm6djx2EpZzMuXrjE9tYmw/6A/d099i4HIupjicGnqZpQVWPqumE02sS3gf39GYLVxH4BQrtyshxH/Lef/ElmZcmTF5+cl2U4ceYko801xBia0LI/rhgUBf08p44B8RHT1Bgca87hYsBVFWtFn55E7HiMqTxSNhAyxDsG1lI5R11NyAyEPEuJFi2T0uNDxBc5VYjstg3eWXxPeCTz+CJw152nCac2eTxUtJlF8jU8ltBGcsmSj8gQW2h8QIwmc8QKklnyQYHLc0yWce55d+Ks5eGHHuHBBx/kt9/5znm9mSp4ohW2bz9LNJb96YS1YY9ev8fENzS+YX/nImItLu9pklcita9TEbACawxOhLJpqKqKLDnmI4sS6T//1rfy1l/4BR599DGm0+k8cLttW6zV4nm/9Tu/M++3oOl3vvALv5A/+af+FG0IjGfHm8L/nBAsV8PCiqmRxR06Cq2mY7HkeYY3ynhZOLE1AWOXLK6qqsTy0MVaw8bGOoN+D+cs3rc0jTo1jQhb21sMBn2MgaapqOtAVZbqHylnSVj1cN7h25aTJ06ytrbObDpLGWclRdRbnn/PvWxtb1GVVWLrdGwv5g76tvXJ6WfI82JOWdTvOd5rLRcVluqYNV3QVjrXPLNR1Fov3nsNpoyoiaxt8KGERLOu6hkQGe/vKS3SQwxCU6fo5NS8nl6l8xU+1phMJ8zKksl0qoIlhjQjBjp9JXiddImQW4PLHKbxGCDzAdt6HDqxyQVMXSOtpn+RGIhtgyXihK6a9tyqTCQlbozUPtJKpLaG2hmazDC64zT27Aliv0frLE3sLA7JNxPRjGYxVX1JKWcgJbfs4m+MpDpKcOLUSTKEoo3U0ymzy3s6DhhL6VvEWW6/6y5G21vYPCeIULetZhYgleyLEUI7twyETsR0gddzq8jC/NVpReqIz+n3+1RVxf7+3oHfpDu2aZo5tbjLD/aBD36Qd77zndx7772sr68/gy3lxvGcFSxzHUUDVwBNLY+knGAuI/QK+v0eo0Ef3zraVnN+WWfJ+z0a7xmPW2azGVWl9mTtfJ7hsM9LXvwizp49Q15k1HVJWQZy6zAGXvziF3Hu3Fl6vYInnjjPeDzm8cfOA1D0Ms6ePcfZM+fI8xznHC99yUsRMTz88KOMhiNGgxFRIv3+gM/6w38EHzyXL+3QK3r0utlSDBCUjFD6SnOPZQVbmwMikYtPXMSKYzAY4UxObgvG03EypUmqrCnEIHP6oghzmqQxjhihrhtmsxl1PWM82UVMpCgcl3cucfnyDlmWIWJo6kiW9dhY28ZKjsEhQTXEFY4fAqQU8DVtjEQE4ww2M8QmpR6JgbYqqaqSU2mylM1KTG0wRGxjsM4wMBk9scTJGBMtFGvQ1FBW5KGhEK27IslR3zm110YbBGPZuXCBKkJd5OwXjknf8po3v4ET993D5dGQ2hgCBokGCWaeyNIFmWfQCGgVSfWyg3Hgjeb2C0a33fcJL8a9KFK+aJdyf5+Lj52fV8ycNhUmy3jpa+4nOsNONaGMgZ39PSgyxFkkz4lEyraalxAHwHDAfNZlTe9MVl28iojwwvvuI8tzmqbhwx/+MA8//CgiwtqaZjZv25ayLOd+zjzPGQ6H/M//+T9561vfyjd8wzdw//33Pytt5npxCwmWziNytaQtiuX12sY6o1iamafZuqSAKmKiEoeW4FvalFdrb7yvWVODbhdB66KIcs/7vT6ba2usrY/IrFPTkI1sbWyopiKRzY0NzYRqHf1ej9tvO5d8HYG14ZA8c0wnE0II9PuaUXhalvSLPv2ijzid8YwGI2JUlbuXq2BpfKM5ipqUEp9AbnMyl+FbLfbljEOiMJvO1BwV0RTgIjRB0247Z2jbSPQpVXqy63aajjUWIrSNlkQuyynWCM7mKbJ+n42NDVxm8USsSFL/HZYMZ1UrXOH4YTjokzmtDVS1DU1oefTRh/FtTTOeIj5oRuKqxtQNG4MBWxvrfMEf/2MpC7fSd51xFG2AtubR972XMK2xNRR1pKgivabGjoasWYvzAdO0OJNhnSN6IQQY9IZ4iZjccOa+59G773n0bztDO+hjosG1hkJkzmIziYWWe/1rYB6p5k0k4JlWJRGPcZaqbQhVw+jUOZxx7H7kEabjffZmU5x1WJtRjIb0RiPs6VMECdhLHmmVIu3yHOMsXgw+BJrWz7Uv6RLiOO3bMcQUOKnUZFKwY1e6Yn19nbvvugsrQlWWyc+aSigbiy0cWZbiZoylaVouXrw0F1jOZZo26hjjFhIskGhZS3+fAmn2ssiCpOp9V6FeWCSm9F59LEbUWffkxYsgQt7rzfOH9Xs9ZXQYQ5bnnDl1UiPwDcSgeXy2NjeJMTAa6g8fQyBz6sA+fWKbEAJlOWM4GJA5y3QyppxV1AOlH1+6vEtmMzKX4XKHyxzbm9uqFkdPkRcUWUFZlxqh75K92hmGvSFWlGnStA02mcPKSTmflTnrNGlgo4LFWKH1kRB9KtKkpYo7Hr21OvD4tqWpaqrZDOuEoqf50aaTfTbWRliRlCRPkjBxOKM+npXz/nhi0O9RFDlFr2BWzZjVJY8+9ggXn3yC8aXLSOsp2oAfj/HjCQMxnD15ki/67M9ho29oWk+RZeRikbalmkw5/74/oLp0GS7us0HGRnT06prRcMTQZFDV+GpKbjNy16P0Ojr3egMaK9gczrzgXm5/w2vZW+tR5w4TLC55xoMRzR6cBEum8zls7KwUkdZG2hjYqcYYJwyGPa1sOq24rd/D5j12JvtM9nfZn07Js4w8D6wNTjDc2sSc2IbQYCd7QNCcgFmGyRxtovK3rSak1fLjUUsMpLiVGMKc8BN9IMSDhb3W19bYWF/HLAmWEDSpbJblZC5fOPxFQx92dnYoioLBYIDLcoqVYLnZuFKoyNKWw3smRfSQnT8V3gkt3jeairsqqcsZtTW03vP4448jxrK+ucH6+jqj0Yh+v5/y/uhspD9IxXe8pz/oY41hf38/mZjc3CeTFw5QJ/p4vM9DDz00t7fOZqXGnzQQo87eypkWFnOZ/jx7u3tkWcbm1qZGLLctZVUSY2R9TW2tTdNoJuH+gJ1knvrCP/2FDAaDZD+PePE0vk6R+s1ckGiW44A1B9PfF0WPXq/AOYdJvPmmrpROXELblHhfU1UzjBHyfIg1wnS8T78v2CKnTESHFY4fLl14Uks1DApGoyEb+TqzyYRqNtXKij3DurGQ5ZD3yOuGk64gu3SZ6ZOXeP+734WGIwtb6yMyEfq7e6zFyPrWBnkVyOtAf1Dgihw7GOKnJb5soOhDb4hvapoY2HeR7Oxp7n/9J8HzTlNtDtjxFbO6pp+vJesCi2qWJk0M0TxdXdVJA0hsQXyK07LYPCPDIC7HVzMm0xk7e3uax64sKSL0jGVnMmEqkYu//qvUwbM73sUUBbZXMDQGlzvKOgVGChR5j6IotNBXsoTEVFel0y46YdJpLMvmssl0xngyxbpFChfQUhaT6RQfAqPREOccp06d4jM+4zN485vfzPOf//wU33J8cesIlitsXAc/Hm0a60xnVzecdbnBtAZCS4hC4z113SDGU1d1yjqqQUnzDBei6fSbRk1MXdbftlanW+YcUTwhObq7btA0DXt7e8kxrhUoiTCbtWijyphMJkwmE7IsI8bAY+fPk2Vam76qlJlW18rjn01n87TavZ4SAp588kn6/V7ykwjiJT1rohSHuRtSeyOdXVjmhcf0GTKsWaT+7vz8QpcfpktfoTE5zloEwbdaxtmYxPU/5uknPl5RlxUuc+SFw1llPs6SabboOXrG0hdLzBwYR99EhmKIe2PaqmT/4UchaBso1tconCUvKwoxbBQ9TNtgxZMb0VT8xiJ5hukVBKeJLNtkXoqDDHtig82772CyNWCcGaoQqUIgk5TPrwv0TUQAUiuOKX7ERlLZ49Q2xczLJbvckLucqixpZzWT2ZRJOaOsarDKbivbBl+WcOkSdfTsVTMKgV6R04ZA9IG6adTM5TSPnrOO1ieW5NwCEuYax6KwV0hsZZkLGESZcTEkavdSSICa27QuU54b+oMBz3ve83j1J32SZkM+5n3q1hEsHwU6dlgXryEkrcNYMqtLcAZv1aYpYjh98iRNq+appqwopzP2rQqWmKrpzWtPxzifMdmUJdaKINZiBPbHmntrv23Y2dnhyQsXqKqSpqm5/bY7GQyGZJngvQqe7RObnD5zkn6/jzGGe+65Gx+8Vuc7ZFUSMTRNzf7+OCW6dDRtRZ4X9PoFeZHhU3EvZY3pjcaU4lwdtJ7kygUiJv0Tuqy3gpGIs4aTJ7axNtLrO8rZhOlkn0E/p1dkFLkeQ3D0i4JRf8DG2gbl9HjPrj5eMcxzfPSML19OsVYt2xvrFJlj3WVIVeOf3GH65CVmF3Z40WidDdfw5O++mzzCmalna32NrfURk70d2moMZUluLQMfMU2LeI+vGtom0NRg84LBC5/Pk48+wcXzj1Lcdhq7vcmZ17yMsLXOw3nDLM6YlS2+18M6y9gCydyUx0AWIpoTRpi5RDoBsjaS+aTFiPorxBp8jGyvb3BiuM7bf+nXeOzBh3nwQx+mnlU0VcO5s2cZbG4waRsyb7n79nuI1rDWlLhBn6zfx2QuRclrf89sholCbDzT/TG+bekPeqi9zieW2MK3GIOyu3r9HrOyoiwbnn/3XVTllEcee2zO/nIux2UZNtN0SJd2LtPv99ncPgliqaqGLM+x9nibl29NwbKkgMSn8X4XFADmdbdlvkY1EmcdIUSqEBf2Ua8zEWt1wO2i3oH5bENTt0jiCkia1VjItOywMSapsiV1XXHb7XfSH4wIweJbT1VWZJkjy3J6PaUNd0yR2Ww21yjmzyJC27aq4aQaKFvbW0nTQH1HvquPHZO2lTQY1P47T845n1kpjbK7bgjqkIwdkcHAUqjbXNPxbZtMhV3p5mYhwFY4dsiMQXyg9p6mqogG1gY91baDR4LHCrgQyFrPZtHjRH+AmcwwEQZNYOAj/Sj4xtPWWnrYhYhpW4xXwRJ8k2KmjLbVckYjAQYFZWGxhWV0Yp24MaTpWWoTqX2LJHpzk+5XSSra54MopdmbBX9ZzIKQ4wmUdYkEi2SGutGMApqXC2yWMbAZo1NDTp06xfbJk5A7XJEzXF+nJTIZtxpjU1WY4DVeJsZUQyUx02JMxIFOi9Jwhm4GuKyhzEugJ0rxbbfdpslln3hivt0Hj6/C3GTW6/Uw1jKZTPBRY2W0PsvxTpN0awqWQ3g645ZGE+sMXomLSeBEzepqrEFaUYaVD3MhYq0hy3TAr6t2kW4/ZfQr8gIxid5sBLBz38wdt99GURQaRVtXVFXJxslTZEUfJMM3LeX+ZF4lTmm82kCbpmE6neq9y4IeXKSG1jQNveGQYjBgsrtLU1XMZjMmkwlNUt+NMYgF6wz4lADPN4SgYtWHQJvKojZNTdt6ylKzH7dJQE0m+1gHxvY0y3NdqrCyhsl4jLUFw35PKdplpCxLLVK0wrFDz1rqGChDZLq/T723w+ntTXJrKPf3ydqWdacltgcCLzx9hru3T9IfV+Te46YN/bzGZhWjSU2sG1yRaUdqG2h0kaZG2ggUlLMJT154knxzg8FdZ3gih7YP22c2iOtD2p4mWJ3WNRuZxfYKZlVFiF3iS0mpaEKXpksnRrJUETZ6Wt9y8fIljLNsxA1sC+20JssLNre3qccl2xub3P/KV1H0+uR5gbeiaVu219mfTTm/v8t4b59JOSPvFbjM0SsKcutwJmnyEXKb4bpSziIY6zr7CMC8f3boMhm/9rWv5XnPex6/8Y53UNc1zjmqqqas6rm57fRZFT4PPvQgTdNw8uRJnnjiiXng5HHFc0KwwHUKlxTToplEw9z+vyhX3GpyvRCpqoq21frbWUpXvcxLj6kwj9jlUqFC0zapnPFCB2obHZQff/zx+XmapqauK3Z293FZjrVaKTI07TyFRJHnGGOoU7BUkefzR+mqOza1Bm7OypJiOiEvCq1B4T3j/T1ltmVZSsPdEhqvSQRTKFnrWyIWEUvwAd+mMqutp6krqqqez54Q0XQ0aoWgV2g6m36voMgzKCzW5um+MwyOfq/PoF/f3B97hZsC8VptsZflxFY10vHuLrGuiOMJAwSX9VgbjhiczTiztsHJ/pB1ycmaFmNassrD3gRTNsS2TYGDntBUhLYhtA02Wky0mMZgo9Av+tTOMDOewR23YbbX2a2mUBncaJORzcj70NYtdTshMyZlDQ7K2jSJjJMYvjH5/IRIMMnPIcL65gbGWvq9AW3r2S33OHX6DGdOnqZHxmi0xsbp0+xe3uWJxx5ldzqBzPKqT3kdeb/PYDikBZoYcZmSWroaRcEH9a1oSP1BOtH8nphrLsA80LpNlo+1tTXKsiRP/Xo6nSFi5nnAjDHMZjPOnDnD533e5/Hyl72c3d1dALIseyaayNPGc0awPDU6mjIp51ESLnPzjxYP0joKkbqqCFEO1EjI00CvEcQB37ZYk81VW9B4D2MFa93c5Nam9A6TyXiuiahG0GBtyiyc9VNyumxey77zsUynU3q9HmfOnJkzSrrBXp36LePxWGvQZxmDgSbQG4/3cc7R722llBENra+0XnnRaSktMXaVKJXAoNmSPbNZSV1Vc41DRDTy2uh77BUFG2tr9IqCLHNIT7AmJ88zDBlCRr/Xox40V/waKzz7iEHNOD2XE9DMDJO9PerxPrauMa7AbRRsD4ecGW5yZm2d7d6Q9eiwNGBqqD1UNdJq6QSaBtoaP9unbWt821AUaxiTI6XB2Yz+cMDMGfbEc/vtpynOnOCxeoYpLev2JHmWM8oynri8S9205IMhGKNOequJM42ktP4aCq/xaBIJ0iWDhPX+BkYsmXFML+8z3pvw/JfczcZwBGWg6PUZbW/z+JMXeeSxx3j4ifNI5njF6z+ZrNdjMBxSh0CVSDA2OesNWt4YHwk+JNPY4r2GedG9VHagWx9CCnw0iLEMh0NN+5LngDJE+/0+vWSFAJjNZpw6dYov//Ivx3s/px3bYx4b9nEiWBasjY7JJEScGJwxWh0yc/g20z0crG+sgxjllWcZbeM1668RJpMZ1hoGwxFEi+ASVTimkqFRK+Al5lRX/92niHfnHGa4hrGGkGp+a0NR9bk/KDQWJMsQIwyHPQ1qbFOjxBCS7S1EjzEwSHEzQmQynUBEc5RZS9O2KeV2STHIcDbDS5uyImsKD6VGaqZZLQYWKauKxgd15xubAh+H+FBTVZN5kkotrRoZ9U+AwGS6y/paxmjYIx8OKfzKyXIsISZFdnkGgxGjbIOdSxeomopTgyHGBy6fv8C50TYnhwPMzj7NXknMe1oOeNiDcgZlBa3WO6GaAJBlQ2x0BF/hvdBGmOWWJsuYDDLc7Sc5dcdJ4slNqlGP4ahPYy07+7uaTDLLEWPUx5DStgRJ2VTmPtElpljn8ZOIl9TLqwaDx5uAdRnr6+uaA817ZnXFkzuXeM/73jv3JW6fPInNM37vf/0eNnMEI3giRZYnNqjM+6tvPCbFz7g8x1iTgpYDTfJpxojGnVhHr+hpHaimwdoMK4bJ/pi93T3wgSLLOLG1OScPTUsNJ9ja3ubRRx7hG77+H6r/xQc2NjQa/z/8x//wrDWdp8ItI1i67KuQ8lvNDZhpXbfjQjFZOrhb1zn69K90zuxUl9oYrVciAnmegWh1NzEpPX3UMqVd1K3MY34Trba7fDIlSWJaddTE7t6dy3AuI3OOptXMx12CgIiWQc6cw2YuPWtyqMeAxDjn76ufUm3N0hV7SVHyIUC/35s7971XExditMBS1PJFIURsiu6KUesTdfbhTqML8xes5wrRq7NUNE6gqWvqxlPkHkFNd4MQEWuxWU52zFN8f7wimq66aqLLZ+op8EGLtLk2Euoa1wYG0WCrBpEAYiFzkGd0JRcIAUIgNurkFpdjokOipwmGBpjlhrZw+I0hbnsDe3Kbtp8TnIFeTkSo2mZOonFZL1kCYjcnXKDjr8R5Wb/Uh7ry4+DTJA9JqeetJqwMIeJjYFaWPH7+MVyekxU5o9GALM/ZuXQJmzmK0RCb6XuZv7O4ILJI6iski4W+gpgmZ+q77TQPp4MLbaDjROPbluA9Gxsb+NYznU3xIZW/8DreOOsYjye8852/pfFnPrC5tTk3nx1X3DKCRdOqKCe9Q+er63CAitu1qQPR9+gP1jb4pqYNLT4ozdKHmqataFpPQLD5kMZ79vam5Jly/G2WUqZ4neFb108NKlKWLRAZDTX2pKpKnDNkTu2kIdlhM5fRy/tED5UP8ySSTZgh1lD0c2bVmL1xQ54YIaHxWGsp+gMt+Vs3iHGpk6hwqJuWIs/Jsxwf0UJctQqtqtVUMKPROm1oaeqAyTR1S1ujrcDprLINySFqLVm/T7SG2jdUTcN0Oub3fvedrK/1edUrX0JVzijLScqMLExnNWIF6/o0YphFwQ5HFOZ424M/XuH7A9W885z9/V32L+xwauskgyJn3RqGbeBMv+VMm7G+33B6NGAjL7CDHhCg2oW2glgRglZhjdESWwizSuOnQo9pL2NqLB/qCf3bt3j+m1/PNDNMHOy7SB1qYl0iWY5bG2kbjDBtKohCnhWAEH1IQb0pc7EIUSJiDTZX7d5aqKsaHwPO5uQuZ20wSg07gDF4AdcrGG6sceauO9jf32c8HtNbH2FTOhgC1FWJixkWpQILMifpiEorEIPv1mNSoLCdhyD42uPFQ9B0R3M/afD0i4Jzp8/wVX/tb/De976XH/jBH8T7Gt+0OGOJwGQ8TfsDKSpgsjdlZlbO+5uDK9KCxPkf9ZHJ0upUljem3747PnZZTqVTLZIC02UmTcGSEZpyRpt8KTElfPReZ+SJ0Tin5UJHN9bBXItmtYjYeYGtSNTo9aSaaLBinGsiPniMqO/EB48PLa1vsV3AVdKqtCxwwKZn7pSxxbJIWIOkan9haXsiL3TlYGOaIUlQe7EP6tRHRKPyl+iRIjb5U3JijCk761jjeVA2jLGaAwpjVYOzDpMd72Cuj1c0wRMEbIoMVzq9Zv1WWrrBiSHHkEchC+ACEDwRP3fUqzFNaesilmhINYB0qaKhFEN2+iRycpPdTGgKS5NZzetlhGAtUaBuaozNMC4jxlbbqGiteZnHiJkUsJwMYEEtBNEKCyUlZS9PZBlcgDZgu/pANpUTttrGMYLNHC7LtDoki/EghrBQlnx3/jRdNaJkG5YMI0garrrqrclIwlJAd1SNxlnD1uYmw+FQa9n7Lhg7JNdR0D49v4bMKdPHGbeMYDmqsE3nIOtUX5OyyWv97JAESzpOTCKaWw1cTBInompxF6sS0cH9wqUdjMsYbWxhjA7o0+kUI5bglX1S1zXWCtbotSGwu7uPSMRaIURDiBokaYyQZTnWasZgrU2vJU5D1DoqEluiJHozGoOikbsgKdiqswi4lDBSw0Q0NxFi5h1AjA70SMBaNd0plThFrXhV2X0XUBZbmqZdOOqNUdJCqnRnU+K75997L9ZE6rrh4sVLPProI6ytb9LrDRkMhhjbA9vHOEcbQZwGkq1w/DApZ1gxtE1LUzcYhNB6mrrFO22jtIEswBCHbSPQwLQBE8BoIlSP1yo9EslcjokWm2W0TaRtIjuhYmYd515zP5NRxrvHFxkV24zW1whpUDe9glnTcGHnElub22yO1vBSJy3FYhCsFTJjyYy2yQhUvqINnnI6IxiIRjBZpumJsoyiKBiORpgIJkT6w6Ga7KzgBZqoAsnmSiroDwY04/2O5qNCpfVE8anfdAGZlmgi0WoZYmWGMpcci3F/IXLm5Yhj91mXPM+AyOXLl+n1+vT7A1ofNNqfRcaMTriEhVfg2OKWESyHq7DNwxxlbv6nM8d2fpNrIaKzm/mCELRqNyEEHn/iPFnRozccas13kycBoY5y57R6YpdnS2drkbzIE93Y6GDt25SgTmf86uBP5YGj4FOAonUZJKqktU4ja5NmpPREj28DTe2pqhqiwZgwF6BdSWKN3tdcRXke5o1Zk9y1SQNTR6cPIfHuzdwPJMnXEmOg9Q1NV664Vcq0wDwIjeTv6fd6DFKuNBH1zYS2pTUVQjj2UcIfr2hmJV6EUCk1OPqWcjoj1jXGgfjIuAyUAo1JTMZoscESJRJSLjwfo9YqiWjW7KCVJptgaIwwdZaqnxEHPRjkSBR85qiBmfdahBIIIozWN2hC5MlLl+hlPayxGocVVZY1JIe5U/MrTn2QJoJEbbvOOJ1UAW3wzKqS6LWwnaTAZU8Ea8iKgjx4PAHrLMYKRZ5pzXpn1ZlubOrh2sc6jUSSZqZ/dZJKErDLTuBOiHQVObssGJ0FwUevlSujJs8MMdIETxs84jPVUhLdX1LwdZyf/3jilhEswHyQZMkpBumHZf4V0uxmftzyj7Dk4OuESlwSLlE0BcSFJy/QGww5e/ttEAucMZiUs2gw6KVKb1Y5+xF1YgJ5oekWssxQVYG6qlSNR01LmgMoYMSpWY0IBpxTR2gITRIslqbxGi/TBowE2laFQ101CDYJlkWW1RBa2sbPY1xiWBQe6jSyecMPKlwkaT7WWow1SSDHFKfT0raaLt+3DcG3+qJMV4dCjW79XsFw0MfYZJoLAe8bYlMBZpXd+JjCVzU+RtroU/VQoZzN8AYdvT2Mq8CsyGjzPm1T0waLjYW2n1QYLCTzsY+Ryrf4AHULrXE04pj2HH6Q4QcFsV8gCCHLqIiUraeJkar1ZEXO+tYWu5d32bu8x6kTp+jljqatwUekBbyH4MmdFuQrBgVIxMZuQiTkxmKso4mR1num1YzQtPi6UYpyGqjFCHmvoI0tHo9xWgAwy1OQp1MrgIihDamfm5SxQwRjF4tOqJLpK9kN5hktOoGTMiUvhI3ecxt9WqIK6Rhog6cJfh7xHwARi1hJZrWVYLm5iF0NagCz0FieEsnpEpQt4kNMMwTwGIJYotiU7qHgRS9+EUWvx+nTJ7V2hDiapiaEip2di8pPl0iWZ2SZmw/I++N9rBUGg4K6aWiDJ3M6g8qKHkShbbWSuCDKvPIRP201DUpb0h8M6Pf7+Cakyo8RY/SZRTTWRRdHlqXZk2jQVue36ZLhASm7qgaBYhLrrdCMxWqHLhb16tNss6uUGVPgWeYsEgyP71yiKBwb66cYDodsbm4y6A/Isoy9/X2QDFusITYHAm1dJ3bOCscNA6d096ZpyawjswbfVFShJUpAAowbKO2QOtcIfSeBPPZ0pp2IIzGqs72JsNdU1D4y9gG7vo5dGzC84yxxa50nphOksJy5804u7l7msccvMtraIi96xKCTLd94MpMxGowITaD2FQUGJ1ad4t4TvU+Z7ASbfDAxdubvQM0MbE1jVK2YzaY0ZUVd1oz393BiGO+PlWzQTbhEaNoW0zS4xATFJOacmBTYH/Em+VZES0QYC+JSIHTdLgRLTP7O5O2PnSkrtHP/L3T+10B/0OPue+5gNktByelfS/LrpoktkEKbj3efuvUEC6gaGUlmqEQ9Phz62uEI+nHnwO60lc7hHTFElHmytb1Fnmuwn0SrRrLkwC/LUpM9No2mR0mvMdJFshvaNJOLMS4RBvQ6YeFeJ6DkfN+GlF9La2AQk6kuNeiYqIywlG+Izqne+VsWWVSBA1mFO7KAJlrWBDbLLLvu2TTwcqGud0v3htSvpDblzDqyLFMTGNDUNWIirljs731D2xzvvEYfr8hTgkZPxBkht5aySfWJ8PgAPhg8AS+RlkgbZaH5JoYUUWfrPkaaEKhipDQ6eZG1Pr2Tm7C5wX6M2BDp24wQhKZu1ckuWrPHIOpgx5DbDEm0XqXzajbxOc04KOuKRLdPDZwYPb5uiDbQ2DTrbA1VWVLNKggt1hhNiRK0x7fJl9m1/+Xgw8QlXfB95jnAOg9+ZwoXQuwyVKSJbxT07S7IQYSw1K0WHv28yDl95hQXLlxU091c20mjhUQNDFW9Z8liczxxSwoWSTl65vXal4RK6CqqxgAStTF2TpjkO1CNBdVQxBKMI4jFo9RBjGFra4sQAnuXL5G5gizrMeirv6X1jRb+6vdxeVcAqIYY6A+GOouxgkSLRJe46S1tmGpjC4K1OdZqJLKIYHyNF4NpI8b0sKbACARpE8ssMp2Wc2d+XbVAOxcenWAJYVFzezotU8ZUl5YMl1st9NU2WtulaWnbkrYVLl68zN7eRE0P0pJngpVIDA1NVdJUJZlzGuMgAiHg64bZZEJT1dRlRVYIg0KzsxpnuDTdZzKdPQutZIWnwnqR411LFnP6gx69fp+Zi7SNQ0JDP0LRGqTIaB14o/1jVpU6W3dCClHEh0jjPa3T+i29rXXyc2fIbztL7+47YW3E0DrGTct7fvvd9NfXOLd1BiMFNELmU18OARfAxVTcK0Rme3t46+ivrZM7S+Y0JZL3gXoyS0kpmZfrbpoGb4TWKfNLMkebsjfvTUpC6xnv7hO9aucaOS+4zBKihiAYI8l/oj6WlP5y4YBPVoK2lbk/t/btXCAQO5NV8mkG9UvGsPCJRgDRfH+nbzvNH/4jn8mv/8Y7ePIdv6lmOYGoBWbQV9HSBI36DzFwnHFLCZYFbZiFs16u3CfK0r5HnWVJe1ANYjkeX53qZVmldPR7DAcjBgPDaLieklBmFL0ea+vrBLoKcTojMU7ph6FR34d12dxR51MEuohdXMtYFSySI0Gd+5qPyM3ZXEb8PF7GGoex5oD/RM8pibTAXKOZm7/QTqDVL9VsZ7LkEEyRxCFE8iyj3yvY2tqgrnrUZcVwNCDPM+pSc6kpizLOg7uIXZCpwTktQaD+RU3H39QVdbkSLMcRElokeEzU1C7WoDV1okNixAX1RwQipW9poqMVaJsITtObEDUzQ0dVF2MxeU4xGiGjAe0gZx9PaGtqDD5EJJVlsFjaqiUAjfdY5yjyQlMPNQ0uK7BISvpotWYSEYlhHvTbhDbVt9d+RMogEXzQQRmI0hKaRn1ETa3VUOtataFUO8WIUFXlnKxvjVHfiQmI0UmqGhc6wZKc6YhWtSQFFHcvN3bmruS0D50VYIlsk/bzvsU6y6nTpxgM+ouM45K0HIFOgC/IAccbt5RgmWMpN9cVmwxJm5mH5jL3r8wHcgtpcA+IBhR2znuM0o0fP89sOuHipYucOX2W06cNZ07fRq/XZ31tnfWNTZ53z93sXN7h0qWLC9aUsYToqeqKwaDPYDDQVBMhMJtWiGgBLcQRxWpwobUUzkLwOOsoih7O5sRMMNIS/MIc1hv0GQ5HVFW5lA4fujr1oCljYozs7OzQpe2eay5WBVNeDIlE6tbTNJGmCViTU2941tc3aJqGcjrjxNYmGxvrTPcv0jY1ggqY2WyGb1rN7uqU1knMMS5HiETfEnzFbLLPeLz/sW4RKzwNtKUG7hJaJOaYGChyS3A6ucoDuAZq77k8m7DllKUlJfRyxyBXhpeEiK9T7FZ/RD4ckp85xXhrxHjoeGK8QzXZYzQ6gXUFm+vbiLX4MjCZTanbhiYGBsMhJza22K2mjC/vkm9ukRcFm+sbWpmxrlNhPSWHhBjwRKyz9HKLdRpKUM6mBO/V0R2C+mqmU8rpTAt9tW0qRkcyceuyt3uZMsuQuDmn2YvpYl0SI4u5G57OVU+KT1Prl8wnv2qhW5itOv9L52MJSQOaThuMtdx11x2srQ1pmmYuXHQyZ1O4hdr1Rcmrxxq3jGAJfmGn7yo5HtiekkKGNBswRgfUutLZsrWS6lDLXAUNJNtw0FQuAU0OZ4H1tQ0y56irmqLoY02WItmFWVkxHAWGgzV2di4znZYoOcuCuMQA85w4cYrbbr8NzckkNI1PmkOualXQGWLwnkc+8iBtWxODJ8YalRkqDJ3NVSYaYW1zmxOnTtHMpoTgMXmuGlHbqmBJs6+2aRiPJ0lrifOlrjUhZNM2dJTr1kfaNqa0Lz4xxZRZZwwYAlpeINJUNRItbUrFr9H+mWZQ9pEoRrcpzYimqaiqlcZyHBFTyWqJgeBb2qZecj4nF7GxlHXDftlQDzJaa3UgDpHYphITIZKLwxsh2AyPYVbXXJrs84SpeKgqKTHc7h2nz97OfZ94Px/5wAd54IMfYLS+Rp4VZAacWKb7EyQKa6MRMQTqqqaXZQQis2qGdaoZ570+GJhWJUGgxGNFE0W2ooW+si79StNAWRPKiljVSIz0XLagHntP26rg6sgBiAZTd1Z0kiUjvTlYMo3FVCEWo/n+OitKJ05k4aln7thPgqfT/mOIeNNA1Bg477vg6c6PHOYB1hIXvp7jiltGsCyX7TyKxR2Cp66r5PDWHyfGyP7+Xsr9lVMUOVnuiKJBTTE58EMSLDHRdq0T1tc3yLOMalbSy/sY46irlqaOzKqaNkT6gxFgmE5KstxinVFtCMFYz/aJUzz/3hci1qnQUaIiYAmtpqg3KMXzQ3/wQaqyxBoIHpo6kuda7tjaLl2FsLaxyYlztxGmymqxo5G20qqam/gISnN++OFHCaHC+4AxKhzatlH1ukIbqXXqpPXxkOksUSkNGKPpKESEpkmCpW4wqH04zzIy6/Au4mMqHWCVt9M0FXV1vNNPfNwi+EXuOd/SNhVm7pNMEd8GKt+wV7VU/TWNe0na80KwQCGOaA3eZlQizOqKi+OSh9vIh8b7lFHIs022bruL57/sFTz08KM8/PAj3PuCF9DvDzBJyx7vjen1Cob9AdPJhDY0hNGANihtuJACWzjyUQ/jLLO9ljYG6tjiEJwxeKNMLxsj0Xt8VUNVE6ua2GjZ7KLXm5uM67oh+pq2rgmp/3RkgM7aLss+3WSOi0lCaHYAVHu7gqa6YHB15ZQhaUroxDa0HpFAKwZiwFlDk66jssgTg0kF9bpYseOtstwygmXZl9CpK2oe0nrvdV2xv7+vsw+vDrkYoxamspa1tSEhDkH6qXBX1OhW72m8ZvqNqNqrPgJPXsDW1kn6/RH9/ghjMuXJZ336g3XWT5zCPvAgVdWmmio5G5tbNE3NpZ2LeG9ovYAP+NBy8eIO1mZsbpygbT1t4+kVPWLUOibOBs1VFCK+Vc1CMwd0qSGCBkeSBEHTUl68pGyyulbtoSiwXfXLqqKuG5zLEKya4KJqdwipQl9G02oionZWUtcN5ayEqNfe3t7ieXfeztnT24z3LrN36TwEj0mzM+91MLCuIpKDcUhW4DKLyzNiaGiblWA5jlgb9ZPGrv6ISNCS1CKExDS0xhFcS2UiMiywvT5MKnyIlOMpmXFkxjIqhvStxWQZ3kd2LlzifNHyUOG5aCLTKFz+vd/lvR95iPd88MM88IEP8sAHP8jvve+99Ho9Bv1CWZXJpBx8m0pWGHpFkeJFDPfedy/33ncvp9fO0Bv02J3tUU9LLl2+zGA0YDAcUKQ4MDetMSEwNI5+r8easUxLjdS3KeVQ6wMmhORjUvq9xWAjaC2xqBr73CffRaUsKHGSLAsm851XHzjs/l1iaCaBEVGfaNbXMWlWlmTWsrW+Nhd4VdPqvm1LdKgmdQtUZb3lBMsBpHgN7z113TCdTha+DjFJsEzIMkdROLI6UzU6z9RJFlr6/T5ZnmupUWspci0tbEND6xyx9WR5D2scHdfRuZwsK8jyHmJcmuBoHco810y+Ma2LGB3MPVRVS+ZMEhxqfoq5gFh6RT+VSV7QHqfTaSpZ2tGBW07tj6nLkqos8XVNVc3S89cURY+iqHEuo65r9vf3aepWU8kYR78/ANo5u+Ew90ED3tSxaa2l3+9R9LREshVP9DVZlhG8DjoxQNt4SiqM9dhMtRyXMadAx2RmWeH4wTlLJGKCRqIH4rwiakfxRdAcXE6IVogpf1EMHt96nBHECplYrM0oxOHwhMbTWk/tWrxz+Cjsj/fYn8zY359w6cknuXjxIvuzCXmWMRz0IETqpqauKuqq0mzDmWrtzln6wz7rmyO2T21zYryHjy37+3vsj8fs7FyiaSratmaU98gxtHsTbIA8agJL4z2m1fx7DsBaiqJHk7fkrf//s/fncbel110f+H2mPZzpHe9QtyZJpaqSVBoslUYjy5YdCGDAuAMGAhjCEDeEtAn50OkhdDtAbAgkDTR0N4TuhMk4NGGMmWx5IniQR2yVqiRVqeY7vfedzrj3fqb8sfY5963r0ogs3bLfVZ/zqXvO2eN59/OsZ631W78fs9mU1DsZhRJIs+ojjTUyWPdldCWcXTnHHg8ktSbJWvWNx33dZQ1w2fyb29FKzsLSsWZMHpQVezs7NG1HCKGXPV5HLpms+yjq7s6EvXYcCxgEO5/XbRib9NhoNCL4jsODm5tskNKanBKL+YyidAwHltlpy2JueNtjb+atb3mT1AF657ROn26NRzhraKannJ6c8Owzz9CsPG0byAhJ33CwRVUMSauIyYaiqAkB2iaiKMgp0DaBjKUoh5AVroQH7h+BMhhbolRDii3WlBS25M1vfgvBd/iuwfQd8H/xL/0FPv7xJxiPR71I0JIPfs0HWc2ntG1LDF6K6DFId3yUhsqu62iahieeeBLvA1oZ3v3ux3nnO9/FctnQ+Y6ytPKwqxUhZHyUPhrIzBczdne2efObHib6juef/zTPffppZqcnFK7CllL3WS6PuHlDGAqcK6jHGucy2AIdPGgjDNKc97HcjRYRinpjFUYb0GYDnY1RiElXbcvEWYqdimn22GZOrRzOGKxWmKxQXYbcoWyiHDgmVcX9O2O6bQs7hsnAMSNzsHVCs2y4dTyjqxR2b4QtSozRBGRRs+qWkBLGgNEZoxI5Rnzs8N2Cn/roj/OzP/uTshg0WhBSfYrIOisOKBtcgmq6wiaoMGRrwVkGu9vUoxEPvukRLt1/P+/46q8GI9HL3//uv8vVl17kdffci87QdS3GOYxzPbxXUZZFD0XWTOdTlvMFri6FgFVJJBNjoChKisIJAwVgjSWnLBRPPUPzfC4ErtF2KG0YFRXvevs7ePD++/nu7/l7zI6fQQURElNrIs6YGA2H2HMFyS+Npb6bMefbP/S66Uj3uhJSI5AO9tzrp3RdIzorMYpID1ka+rTeRKcp5U19wnvhOtLaoLXpGxP75kKkhuK9rNYUSlbsq5bBsO4fLtFniTHTrBpOT04lcsmZ6FPvWAq6xtO1ntB1AihIt6Ovdbfu9vY2ly9fZjgcSEdx1zKoa3zX4bvudtqgh0yuo7qiKKQYGCLLxZLlcsV0OhMW4iystesmsLVgGEgqIBktTWa9mmTbNbTLBSH4XoUygNF93cZSlLWg2HqCTd1LtyqtUT09RlHe3doRv3Itr5H7AKxV2m9HsnmDvPIqs4qBpYKoHGm9bM59gVs4XTBBYMoOQ2EshXUUhaPUitHWCOsEuBIGFakN1M7htMZlkeXuqgoVIyol6rLAaNXrC0VC9EQfiG1Lp5agFLbonzdreoEvIGR8zLDwFGicLYhGE600YiYfuPHSy4QYGe/toZwDbTg6vMX0dMrh4SHWWoL3Akyxls53ApaxghYrq0JoXlKiKkrKumY42aVrO45uHeCbltB2OCfbW6UJRELXYbQhG43VBm17fSci6EhhLNuTbZwxEjHRQ/mLajOuRMX27s6FvWYcS1gTKOaEpce1Z3EgmtQrRCZWqyXLxZzVShBRdV1LB3gIdL6l61pZ7UdZWRhjKat6MzHf9AGt4OLONstlw3IhGi0xJqwr0MowPZ0x316itGOxaLh54xave/0DVGUtBHhoQkgc3DjA6qfwfSSxWnVobSiLAWuRsBi6/nxb5BRYLqfSvBgDH/jAB3j/+9+3YWhWai0IljeoraoSMSTn3AY2ubO9h/eeT3ziaabTOc8//wKPPnqLxWIpgkfOMqiFlqMLHVkFsgpYpYUhWmW6tuHGzeuk0BF9J82gWvHpGzcxKIzSlNWAS5cryrrGmJ7NuKeucWWJrUrGWxPCGQaAc7vbrG/663WBdJ/uVT0mNipYxshJzhyGTFaW+6oBpdZStU89ICVJrsd1EWc0tovYaKWgbgxFYdm/dFHoiy4HdMyYmKmUxilFnZXUOrogapQholMgp8jidIbvOhbLOW3T0DWrvicEbLRSCwlpI+nNfIkKERcNtSvYGhoWuWOZAk1ILI9O+OSnPoUqHN//fd+HrSpMWTKdz6WZOQQRPtMy+VulOTk9omka5sslRVmwt7/LlXvv4Z4r97C/s8vuhQvc88hjHN+6xcmPHHB6csLp9JR7773CaDSk0JbUBZanUvM1xrC9s4OxhqvXb9J2HU3TUQ+HjKoa0zeHGqUoioLtnZ1ewkKzWC0J/u5OL79mHIuxBrKQNmqRPBQKeh177ivHzs62pKFWc1JcN0F5rIGUOozOlIXt6xyJxXyxQXk4K/Qk2d3mzBKalUzbdCxXDaulFMIfuO9+9nb2uHb1KsPBgLc+9lY637JarmhWDc1K/h9DxGiND9JIWJVS6yjLkvl8yWK+ZHtrQlUWeN8BazoJcSAnp0d9qkuQXClHylJoZiSCSJtoxVq7gRTPZguCl9rK7u4eDz30RpwruXbtBuPRiLIqGdQ1WilpmFRSnOyCp+3E+eYcOTw86NNzLZUxqJzZ2tqBnEV2YI3Lz6I66GPfZpoyKkkKo+k8qx5wcG53l6V1ijLKYoKYUSZv+jDWcNeOyConZjFiiXiDULsYTc69imruezdCQvmI6iLKJ3RI2AwuCyKRrKiMxgCWhAsJmxKDCA5FhcYoJ6vylAk+srp+iPUd21k0Y3ISVGKMEd8t+qgqYFOmjonCg0ngUodtI76LdDnQEimNxtQDLm3vEIximRJd0xC6jqw1xlkWq5Wkq5Tq5csNKSusKxkMFNZZlNIslw0HB4fMFytcUTD8tx9nOV/w8rPP9sCZjunJCYUTUssUI23XSarbmE0EUg9HpAxt5xmORmxvbbG3u8ve7i6LpsHaAmsMriiwrsA6J8zkd7G9ZhyLtbf5ewQhhQhRCQ8ErijY2d6iWc6ZatXj8lt8FykKQ4pSkHaFIEZSyrSrpk8FZJwzVFUp67WUCa3H+yDol7ZjPl+wWh7jXMGb3/Q2BoMB169do65r3vKWt/DEx59gNpuyWi1ZrVY0qxUpCvpE05FVpiiE7LEsS2FwPT3hwt4ug7qmWZ7Kddi+M14rptMZJydHffQVCNEzmYwZj4c94V7eOBat9abG4rtACJGiKNjd2WUy3sbZguvXbpIvZUYpw9ZEUGFa46VgRfAdXdfS9UXQ4+NDGSBty/ZwSOUKJtvb5JjoVs2GPj8lET/zQVpO9VqmNkaarmPVtl+hp+bcPpttaEF69JNCHMla+yhnJA1GZpUzs5ixJLyBeNaxZC3OiQw+oUxEdwHtIzpmbM7YDCl4NJqBKXE647JGhQ7tI2WQ6GXbljgUTilyDHRd4uUbt1A+MioLrBGNoLbp8F3g9OQUnwItHQ5NgWKoaqwyog5Lh18u8UQ6FSmrAdY6drZ3aUg0s2OarmMZI/XWBO0Mi9XtviurNE4b6qraTOrCAm5YrRo6Hzg6epqmaQidLPZCCBvG8GsvSxp8tVqgtWYwGAgUv6+xoBRveevbMM7RhchlYDIes7uzw97ODvn4BKUNVptNyq0q63O48S+FrREU634kAGctu9sTpie3sFahCKjsUWRWiymffOpJ1tQqly5epOpTZFppDInkOzzQti3LxZKf+LEfJ6fM9niLtm1JKbG1PUErww//8A9SDwbcd/99LJZLQaPFjpwT048dkEnCuK0SOQW2JyMp9k3n+NbTNQ11Ybnvyj2k2DGbdqTQ4qyhrmqslYf39PSYq1ev4pwmpkDbNlSVQ+sxi8Uc7wPWmtv1oL6HRylB0Vy8OCaGxGrV8PLLV/n5n/8YbdswGNT8jt/2W9janlDV5aYu1XUtwXeMhgOctWzvTFgtV6yWGleUKG1omo7gA8vFqucZk45p6xzKFmA0PoHOmqwsJ9M5N24dfgWflnP7TJZCH7FkECktacTL6TaKKWXwCpSFZVYUSjHXiYLMxIoD2LSCRwT+GEB1HrwlB4vxDqfAxYTNmbpryKuWvGxY3LhFmC84OpxiY2IQFUWGIoFJHSZnHtKyUi8wmKTRSYGuwJWk7Wqjf7Fm+zd9z1iLJyporaItDV1pmVmNdxbtA/PFlE89/QlOQ+I0ZZS10MtmKAQuJEhNqIsCqxUxSdZgd3eXS5cvcfHSJZn4XYHuWTvypu4ExklfUFXWWGsYDAYbNdgYpAm1857UdhxPp8QMB7eOOTo6JiUYj7ekt85ZQoh0s4UAdc4jli+NrRtQ5d9n5HrlE7RWlFWBs0bggPl23aVrA22zlIGjFOPhQFZXyoJCmgZjlJV419E2Kw4Pb6GVZlgPaNuG5XLZQ44Vzz3/HIPBAGs1J9NTTqenvUaLYtUssFYxHNb4riHGDhC+sNVyTk5gbUnhKgZVSdOs6IIndA2psFSV2wgHdV1H2zagbM983PWiWx7vu54JwKK1wVrXcxMplLZoDCKjLMJgi/mS05MpR0e3qKqS1WrFYFBTlo61nuu6hlW4vuBaFqIuaIV2RikRL5OUm3Ts+7BmXzXSCKqlmz8rjTIWHyRqObe70NZNx2dffe1ijZLMCFV8UApvwCtFQ6Il4ZWWhkmjUFH6PqS1I4luSoxSiI8JkxIuZWzKVCGTWk9atbTzBXE6Jxwek7tA65NEUFmBitJLtXcJpyw29ZXJDCaLfLJ1FpUUNqnbsGAl190oRzDQOEMcloRBwfXYslCZVfB0q4bp6ZSTmDlNmaQ0WUHoudNsP7uonKmtoL5C9NRVjVKGyc4OaFl0aWPJVgBCxvrN72gL4TBzxgr1TF8TBYiDNcN6JiRpMZjNZviQRNFTaQpnRBYAkQUISXrv0rlj+dJYzIIn1z1OXDpr1yxzAUXCFCKWFWJH6FZ07ZLQtYJwCp7t7W22t3dQOdAsZty4eUjbdSyXS3Z2d9ne2WNra0Jdl3zt134Ni8WCGzcOeO6FT/PEx54ghjUVg9Rjnn76E9JZHlpi6Ho6FImknNN4/zXs7gx4/rkZy+WSTz/9LPv7F/hVX/0hnNUYQ9/Nv+STn3gKYzX7+7t934qsGnd2tlksp6QkOtxHx4fM5lPKskApzeHRIUZrBoMhSgkP2qWLV1BK87/+6x/jxo2bPPPMszz8xkd57LG3c+vghhT+lelJ+ITI0vRoE2MMg2HVR0ICe1ZKYawRHjNbkZNiMoHlsmG1aqhHY6xzJC1yAcuuYVwNmOzsUo3HlMPhV/TZObdXtzWrr9EGkzUmm40EbowixRuNUJtEp2isZqEUB35JwlGnCgCrNaVRGJBoBdFJMSmjY6QIHqMz252iDJmRz9igsLokj/bIekgKFbrz2FXLAE2NZmQLnFKkroUYRAEyK3SSc2okTWVQuL7YrWLCZ6H57ypDwNA6hxqMUdtjXG45ih0/f3CD6XyK1prKIv05gwFZG5Zti0JRmIIcokR2SVjRl176wII2VKMxu5cuUZcV1lhc375Auo1cXTMut6tG+s2C35BlWmfJwOHJKXVZsX/xMifTGSfTKWVdM9nZZrpY4r1n0TSyuDOW7d09nLu7kZavGccC9CsRBLee+2YWdXvVJURwuRfwEaU5rSDmSNusIG9RFk50G3MS1TxZb/cRjvAlkTPOWYpexCsEz3w+ZXf3AlU5oHBVHyUYMiWZSEpSYFc64qxhOKqYjIfyefKQI1XlsFbRtQtC14Iy+K4lRd/Tt5i+VhLw3mOtwBo7LxLI64ii65oexgggndNN0/SwZkVRHJOT4uTkhNlsLoqTWmj+QYqIqu9+i1GovAFpDNV9zhyJmLzvpOiKwJS1toJOsYZe7RVjHdo4oeVIER0DKC0SqyHQ3uUIll+pZowkwKyxvWPRfVYpybO0FpbSiqwVAYUHFrGjyplVNjRK0ymDVWaDrFTQj62exKjPqZUxU8VM7RNFzBRZY22BLhW56gADTaBIUKZErSIORQxRaqqIZovSWiiGAJMSOmfMRp5YtktKFk8eJfRJnSc2LcZlTM7MZzOaZrUR7FuLZ2UNMrCEtRgjDc5KG8gJEx1oTesDR6dTXrp6Da0MRmt2RkPqsmRrMsYVBUVRsGqWhJApyorU77/RQdIyRsqyxFhHPRhw8+iIW4dHzBYLlquVSACkJGAZpW+nzs5rLF8a0/r2v40RnYWeRnLdKgwg6ofBS89KTlSVIy89i+kUdeECo7rqRb4SW6MBoSqpqpK6rimMolku5ThKkXJgNB6gdGK5nPP1X/8NPPjg63tq78h8PqesHFVVYJ1AdXNqGQwH3HffPSKYFAPDQcGgMmyPH0ahODy4iu9E1KseDrHWce999wg+viyZzaZ431LVJcZCzjK5t52haVY0zYqUKozRlGWJ957pdErXBbyPXL16A99Fbt48oOsCW1vbjIZjiqJiOp3hu6aPbrTwq/X/WWNQZNqQCDEwXc57lFvLeDCWiAaLVhZrSsCidEHWBrSmHIwwMdCRiSgWTcfxbMHR6fTL/bic2+dhpRX0ldUOmzUmK+HmypGskowBDckootU0SLrpYLUkZcuYjNUiGGYVfZFZgVYYtZZwUJichVolQh0S49YzyJo6GybVEOcyqs0ElixOl+RmRW4kashKUfcULc45bK+cmpPUgnzTkmOWaEYbrLZU1gp7sjGsiDTLFcvQsZjPSBcmKJ24cf06pzlSTAZk39J4Twqd8A8YmRZD3zNnnDSEGkBZSZCdLhb8wsef5GNPfYLD4xNSSrztDa/j3iv38J53P87e3h6juubg6IimWTGZTHC2YOCEMVlpxXwpAJ/tnV2MtRT1gOPTKR978knmyxUhRmxVYZ2jGo6EBipEDo+PCPHubjp+zTiWrIAsuX0jzy49zSoCeY2Q+lpJThitsEaTo0QrR4e3uP++eymcpWlbkTftK2zRt0RrpIHKOrQxGGehTfjQUJSWnb0dyqpAG+h8i1aKra0RIXS0zZKLF68wGNY0yylF6XBW0bYe7xuCF937yWSHlLJ0H9+6yY0bBzzy6JvZ2t4mxEDMiaaPSpyzhGgpCsOjb3oY4wyRTAgBH7wMVkBru2EtTjETQuLHfuyjvPzSNWmITImqKolRHGHhhDQyJ+EaiyGgjAIjqZFsNKUpsMlITXadfdeymtXW4GxBVQ3Z3t2nLGraEMlKMdnbJSlY+RafEz4Frtx7H104j1juRhOoufQkGRQ6y7+VBkcmaUVyCm+R/6eEiZmGyArFisiSwIrAIGt0Pkuu2OsSpT4ijpmwaAhtJC46QhZhPWUrLJrSOXJdUU7GJGdJzqFj3NC2ZqCJLTl2CFmsut0gqRQGLdIXWUgzVQyUucQqxcgV6KrA1gVNFJBKlzNtSrRdh0+RqBAZYmNIvfZJShlntMiS50zoBQIVkJSk3UhZGoBz5tbxMSEGjFYMh0MGgwGnpyegFY8//m5q0/f7JImPYt/Era3UUVrvyUpRVCUuRQiR2HdohxQlfVZoSqWw5zWWL52lDClmUWdUiFNJ0ktBiuTghQo8RYwRxxJDoOtajo4O6boW56ys+GPsJXUToWsJxhCMobIWaxRFYYmxw/tGemR2t3CVAy3U8UXhGE/GTE+lRrO9NWZ3b5vpqUKrjNG98mK33HTXD4cVMUSa5Zyjoxs888yneODB+9lRWxJpZfBBCo/WGVw0FEXBux5/F4PRkFzepnFoTk5I3lMPRhsdFoUmJXjmmee5+nLvWLKiKHrHMpuJ3LIVgSaRGfAYp+W3UNJ9b60hJSOUGZkNKCDmLLIC1lLVAy5cuMz+3kXmyxURuHDvZZQxBJU5mU05mp5yzz1X8OeO5a40o7SgIpU4Fd0vIHQGjCNpiVSCy2STCSS69ErH0qhIowItsqIvWIte9Yqmfc0hA3G5Iq48YdYR0QRloAJjHLVzcv5JEm4xa4m+E3binCSl2nZ0MdLFKAqlxjAaTiSVZwtSiEQf8EsPMeGSw1jDyBWYusYNK260p/imocuZLifarsVrSGulM2NIKFISqLU1QnXjO/+KmiSs2TKSFOTJHJ+cMptOOT0+wvQNliF6BsMhj739bbiqIEU2DjemRFaSkkwZvO/ICoqqpEiR7ANdKz1lPkmK3fRsBufSxF8iW69c0hlCuNzLfSptQGWU1lRlzWS8JSE5idc9cD/PPvtpPv6xJ4gxslgsWK2kc3d//wK1Lwmh60NsKJzGGkW7XBB9x3hQYTVE37KaT1nVIlFsrKHtGqpBST28QBdaTqcnQnlCokuiVGeMoRwOUQoOD2+iAGcV9993mdGwYlRbQjcnBZFBLfoO+oTitFmyWs75+BMfQxvDqm17DL0mR2lqNNYJU7OP1NWAsiiZTWeiCGkdISTaZoVVMB7WHN68TkfCOk1RygOqrBAJrpYdPnp00eeYMywWK46Pjzg6fJa2CRgc1hYM6glX7rmfy5fv5Yknn+RkOmWwvUVRVQy3JyybFYtmwRNPfpzj45OvzENzbp/dUiL39YWcBW4spUuNVQaMJhcWZRJarTW/wVtLkw0zrag1VApKkFW/Ag80gI+Z5BO5E3TXznBEbTrqNmK7gG47ckgkY8luINdUFcImrEE1mehhsWqIKqEHjlI5StXPBgqS8vgcCX1RXBeKwpWYrFFJS4tNr8+SdOKTN1/m6dkRXQwkBZ5MUdVsDSumKdPFgDJO0HBRQAAb6pqscWUlEZJRrNqWpm0xvXJqORxK1O8sAfAZOh+FBaAeYMoK33nhRVYaWxUiKY5mPpvx6Wef5aWr1zidzgSshNyL0hqVe02qlGl9OEeFfalM5TUia9Ms3yMweqiYEo1ppXTfhFhjjWJ3d49bt271oW3aoF5yzsIqmi2F69NfWmOUNHql4Mkp9uiTTE5h0+9hrazmU0q4QihSptMp84ViUJdSaPcRRZJCoxFoZLNaoZWiKsqeudXgnCansOFccqYgpCwyrN7Tec/BwQEATdMQk1Dol0UlBb0+ivM+MhwMGdRDuq6T3gStMYWhrgZMxiO2JiO2tkbknBgMBwyGFSmpPhWmaH3To1gkaspZaMzbtuPo6ITFYkVhRfTM2iUhaVZd5JNPP83h8THlaEQ1qNne32PVNazahlu3jlgsFl+x5+bcPoulCGtZXdjAWlWfHlPKYJQlIb0ZMWl0TkRtCGgarWgULMmstIBgCqPwWknRPANRoYP0hJTWUpgo5JI5oUNAZYOKWWABSovCq7VQJnSyZJWIrZDUK6s3aKs+T0uKIvmQVa+gqhVGOwwG1SmSgqgygUiXPNN2yWmzIGQ5ZswIp51z0HXkdIbNeP3DqB5KDX2qsL+Ofk6S8aIwrhCtFK02c43PGZ8S81WDMm7DhIyWtgAhy820bcfNW7eYzeZ4H9dMukIOKgIswr6henXWc8fyJbI+f6tl5hesfRC2Y2ON0NIvO+bzhtPpgqoqyErz1Kc+zdPPPMetw1N8yAyGY4wxxBiYTk+FWM5kBgNHXQ9oVw2dj9L5myLL5QoVPE7B1qBmdzKkrFxfgDO0Xct8seBH/vUPM5tO+cbf8OuoBxWkwHg0ZDwcsGxaFJnRYCi8Zb6jKgx1UfeklYkcAoVWbI1Kjk9OWZyc0DUrOh946fkXKcqK0WSH555/nudfeIGH3/gI4/GE+XwBKJwrmM1aCjenazxGaZzTPHj/A/yWb/7fUVcVZVly+bf+JobjIcNLW5AjYTnFFMLgeno6Zblc8uLLL7NcNUxnc7QyFG5AyqC05W3vfBcpZW7cPOTGyS0+9cKLtK1HFQWD0RhXFqJKGUSszOqKslCf/W97bl8RS+0SZSx6ULMisMyJNkSIsGuGVBHGucCgqcik6Mhoos2stOLIiGb9rPMEa5gYixnXRKVZoUiUFKHEBYMFYmjpuobULBn5TJVhnIUnTB2dygTqHIwHsLeFbiz4FlcI2WpMidh2pNYzKCqcMYIMs4ayHuBjIERJ70YVyOMhMSsWKXGzOeVg0WKdZmc8oZ1OWZJpEqQukFYCaHFocpQGX6csNijwAdv31uSQQCWCzjgsk2okv2WCYjAk9XB7AdJ4ytKxiIm/+T/9Pe699z4+/OEPMxoMGdS1EFt2Qvh6dDrlqac+tVFlnS9WpJQZTyaQRVsJJVo5pZYesbvZ7u6rO2NZtH/7pkiBFQsMK9O1nUCLbcHpbM4LL77MW9/yJnZ2tgk5MNk+ZDic4IpSohptJK0WPSiFMaLdIrDa1MMlRY2usJYrly6TYuahh97A3v4Fci81jNLMFgvyfAZK42Nk2bRoY3DWEFPGx9gXSdeNnXGjs2AUEi1sOp4D0YsyY1E4iqLAh8izn34O6wp2L1zi6svXuHbtJmU5ZDSaslo1GGMZDIZC+eAcq1VL6HnKnLPUdUVVlpRFQV2XVKWja5ZAJOeISpI20Fo4xwaDITkr5osGaxzOFYzHE4oySJSkoR4MCEmRsqGoJcrR1pJyFqqLtiOGhLMFax2bc7u7TOWEIgnVu8p4Ej5LdBJSIpL6lKtAegWlpUkqEfpGyUKBU5kFEZMjS5VIKDolNbkcMzorVFa064wBmYAAcZTpazupR3f2NRmSRCFZg6tLTDJE3zfnxiREl1qjyEKbpDTWaFCGqOU6W61oYuTYN9xql1zvViwJBJNxlcWu71+v6x6RxDrDIPUnrUD3jZmwzpbkDRhVelWE0SPERMqJLibQBltqIonoI3Gx4ujklBdeepkrl++hqgcih9yju2LMPZOGxRm7OY/Ka5LQHjXQC33d3RWW15BjiV2QtFJx+5K1cySlmB4cYJ1le3+H51+6xkd+4If5wAc+wNu/6p2oqqSebPPjP/rjTLZ28SFJiG80xihSjugg3fdNs2JQ1jgrjKnGFpiR4fUf/CA7e/tcuudeiqri8OhEVk8obhwccP3mAffedz+uKFgsGrS27O/vEVNmsWy5sL9D6Rzz00Oi7wi+2TiWshTYcIoRnzOz6Sm2KNnf3ycrS+cj/+JffISYElfuv4/T2YLT2YIXX7wuAl7GUVUV+/v71GVFXZQcHR7TNA3OOhQwnZ7CaITTcHx8wOlMM19N0VYznAiFjLWOkCT9tb+3T1kumc4aqirjo+bB11eEkFgsV2gtTVp7F+X8s/mSpmm5fuOAZdNwOp2xBhMM6uGGe+rc7i4zfRt7ypGgMl4lvJJUq08JmyI+trgkVCnaZbKBRilJyeTQL0Y0J6nDZ3ChAm3xtqBJidAFilyC0kyjx+bAwCpMJ534KYscOIk+pa0heFgFYm7JKjPcGZNTIjYNyjmU7VNdqD6XJfsb6zBVQaoKgtYctC3Hq5ZPrQ54Yb7gpfmCZlLQlYatvQEqRRZNSzKaoDJd64kJJpOqZ64Qh6IyIuLVT+dSNz87tUsaftVIM3YTPOPRiPFoyM2bN2jbjt3dIUcnM/7V9/8gH3j/+9nZu8CqFRaNoihIWfX9MBajrTjNlASQlIXUVStx7sLOfg43/pKYtmbDSCxOQWOtRWnFYDgiRs/RzQMefOABftM3fROX7rlCVoqjgwNmp1PKqiIjBTepaYiYkLWW4XBC2zWotoWeyVSAZgkfIto4BsMxh8cndF3gpatXCTGBMSybhvliyY0bNzk5OeW9H/hV7O5sU5eOw1s3OTq8ScqKmLI0g/U8XlZLRCSmKCuRPfYh0sUVadXSec9gNOT3/6FvQ2vhEXvxpau8+NI1hqOxKEW2Hmst49FIdFraDn1qNo1UMWXKukYZTRcCcb4ADV1qyV1m2a1ER0VLhJUyoAxt19H5242V4nQio1GJUrrPF0ukVxQF2lguXhTI5Hiyhe9CT+IZ7/pmrl+ppp0mayWljSx1EKMyWSlYoxRz3pQbrNaCyDRSfAgxkDFgFF30mJiYqQXaOJKBJiZWPoCqsM6QzIBYWHTOVHi60NFkKFLCxST09zGSvZc4yvX5byXPXuo6TBcwQeopqqfrzzmTu47WKFoLTc60VvFiWHIYlzwdFsTdmu37dnlxfsoiefS4xvgAvqMLkfkqQj+vhOBRRFTU0ul/prYrjdi3oxWlhEssKWReUfQCX6FXrxWdohg8Ya1227bSpKylJ0/3dV1hfxaQhMoZrXpockqkEDBWCDiTMZi7XELyNeNYjLOEphXFNmdxvcCPsYbBaMhiNuPw5gEP3v8Ab3rkYSZbYxJwePOA2ckJRVkJVrzrNdj7XpGBtgyGQhKZUgZ0j2DOhJhpu4DShrKqufr8ixwdn/D0M88SUkIXFmNlUr558xaL1ZL3vO8DXLp4gdStePLJJ5hOT/vCp6yorLFAQWE1zhi6rhMQgHOEmOhWLU3nabpAVobBaMRv/g+/laIoaeZLnnjiKT7+5CcZjydoY5n2zYeFdRzeusXh4S2RGEBouGNKlFWFAroQCE1HIqJKRUyBpmuFvltpwdWnnkswQwgZrS1VVbBqPCkrhsMRoEVjphdBK4qCQmnqwZAQE03bsVysWC5XzOdz0cg4t7vOlBNSOtVLq5gkzkWq0r1QXhJqF5RCa4exGmlCT8IerKTF3icPMTDLGpMLdGFoYmDlDVZtgVXEYkjyBVopWr+iWynaTtGEhAkZrRMqBBKBkIM0Ktq+ETpFYtdhfEaHHrDTk+/nEIirhpWBmYGZhYWD59OCm2HJp9OSi3t7XHzgPp57umW5iLhhhek8ea7pVoHFIjCY1Fhj+gleGCh0ltS7yesYfO1M1JkivDgGYd6Q9HPoocJ1XWOMoWuWhCBKr76Txa1SUjM2WpL7MXgBVCQhXdNa9SwiiRwDyhhZjFp7Djf+Uppzlu2dLamzaIXvWro2URSWmzdv8i//5ffxrse/iscffyemLGmahp//2Me4dXAT4wqKoqIoB2xtbUtdJYl42K2jU7quxbctg3ogkZDTpLjiZLbgmU+/wM3DKYtVQ+s9yhbEruX46ISHH36ENzz0Rj7+iU9xcnqKQVQndVFhXIV1FbYQJbxl06BJFFazagOLKFTbOWcKlzHWMhhvYX2k8IGYBZb4Iz/4w4QQmc0WPT9Xx2NveweXLl3CFJXkYX3guWc/zbPPPsvx8THL5YrZYsmyaTHGce3aVa6+/BIHBzdxpeP3/KHfTzWoWM6nsAn6pSlstlgJ/X6MHB4dc3R8wtbOHkpp2kakBNYStgp6mhdpLs05U1UVg6qmG3uara27Pmz/FWtOaEK0thQqkZTGOQMGCqXREWGPUAplZPGSrUKbJHWFFFCuQDuLbxoiSZosc8LqglmEeQc27ZGopH6hLEmXDEsFA8uiWZDbQInBxQTLlmgj3gaMzugkwByFoqrHaGdgYGAZIGTBNmdDKgZQOnRl8SPFXHX8wtXnUJOKR7/h/RSDAUVV88bxW7m4bPiFTz5D5yP7W1ukNKdrAwMjchXLLpJyBCXNkkppkla90J5IoQkQNbGW7UCBLuymVrsW3/OhI0RFXVWEIJRRzhnh+iORk6auKqqiEPH14PGhoyorjNbkFGWe8h22LKgKI07xLk8vv2Yci5AyKlzhNjFp12ZiipANy+WSpz/9aR56+A1CYa0tMWVefvkq09MTEdaxFtMrHFpjiKHFe0/rGxH1yutuGYH4xazofGA6X9D4hCtLtHGMJhNYLDk6Oe0bBS9x5cp91IOhwAOzEv1wY2XSVUZw8Yle9UITU1/s6xlhY8qorCSqwZCVIYeID5GXX3qZtu2YzZeU1YC6HrK9s8P+xUsMRhNImdg2zGYzjo6OKHqK+9Cn8kJMLJZLDo+OefnqNcq6Yry9y3hr3Dd39Th9Jd3StlwQYsT7wOl0LpQuk12qqmZhRUIg9AzHOYE2tqf2FmK8lDMhJkKI+E7Sced291nWItKltAhvObJIUQDWaFGRVJmsM0kpskGCBNXjcLNMqMqovlck0hIwypBUpOsbKkOOmJyIyQgwAEM2Bbo0BFZ0CVAi+0AMgu1VGRXyRnpCGYOxpUCRtQWdyUg0lZQiupLgLN5aFnhmKXHkWypTMbi4I/VSW1D3jdCxJ5Yc1gMq21AomQx1zuieKy2RWROQJQ0ocS5JreEoeU0kJeg0ZfouCKnjaq2kpktG6RJjJJox/aJMK+kb0n06zShFyFn49sgYBTGnHmQh7501VIXbZCXuVnvNOJauawHpuDdWmgSr4aBHTiSmizkf/Zmf4i1vewuxfx6aVcMP/OCPoMm8733vxriKbByzRSNspd6jtaYoR9iBxVkrE2GI+LalbRMxGxIWpR1f9c53c+HSJdxgyMsvX+UHPvIRdncvMd7a5V3vfi+r1YpqvIVywvqqdYm1FfP5UmSQs0EZgQpWVhqtct+LI93pmWUrZHxZW4EdLxumi5WkyXzkkTe9gXe846u4dO8DDIZDiTRUQhkndDS2wIdE10VcUREiPPfSVU5mIqW8bDu6nElYbDFkvFuRQyD5iHYOpQ3DHUUMgWbV8ORTT/PEE5/gNz/yVt7w0BvZ3tnr1SPP4mTkFWLqW4uSaMQosyEJPbe7zzpk5e2MwioreXvJBguKUUcCEVQm6kQ0UheI0ZOjh+xJKhB1xFtBfAUb0TZgbWCZI02O+OyxMRCiCIKl1lIWIyZFSb7VEbTCjEpsDLCYUSiLI0GXwWeyb4QYcqBv0zgFkU7uCoe3lmVZcL1bcX0x4xeuXeUgLmi2NV4HPv7cszx4/4M8sH+RJ578Sa5fv0EZMkNXMhqMafWKWQfMVmStqcqSqDXeiCRANOK8slK9AnMipbiRR9ZJ6kM2iOJkYdeE+6C1dNlPT0+oqoorV67grOXk1i2R2tCaxfSYrlkwrAt8lwk+YUgCGIhC3zQqC0ZVybgsRSjsK/fYfF72mnEs9GymSitBZKXYF9IUVgttyd7+PoPhqGcCVVjnePjhR5hNT7l2/SarpuHk5IQ3v/nNbG9vk7xnenrKp55+ekNT/5Y3v4XJaIuf/amfous8WhuGrmA4mjAcbzEcb+HqIZOtFXv7F6nqITHB/v4lcR7aSsSi2NRoUAZjBHIpDWlGoJhrupTMhrlUaYlmUsz4mMlKc9+Dr6NpWq5du0FdDzaFe6V0v6907RvjsE76SGJKGOvoQuCll18mx4gyRiKmrPrzKpQWtlZtA0qJ0JExRupKWZGyYrlsODo6ZnvniEuXr1AUJaA3jZRs0mjrvtW8gWveLv2e291mIWWMFt0RvRb6Urln84WMJhkhosz9qj0qgfvSq0/mnIk5ETVkI7otykLSSZ5x+omYJBWK3Ee0WuO1YZUTKnqOg6ZIEafzJtWdkpBhsp7MuxYIkIXqSGGZ9txl09BwlDxTEnYyplYlWR3gU2LVNBwfn+CUY3ZySrtYoQNoldA+UqEYF442RaFZiXEzHwgkTDr4E0rYBTb/CXOBjIA+gtcIQ3kQqQ5rtGRHUqKuSu69cg/DQS1S5KkAMoe3Djg5PoIU++gEoaZSStBgWlE6R+UshTPEEM5rLF8qW1OZaK1ZLhcslwuMEdjweDxi98I+H/76b+ChRx7BVjXkxGRrmz/6x/4YH/3oT/Cn/tSfJHiPRvFX/tpf5f1f80HoPD/6o/+Gv/Onv5Pj42MWizl/82/9Hd7wprfwZ//sn0cpzfvf9wHuGW5z3/2vY7S9hxuOQTtGWzu8+S1voyhLlsuW17/h4Q1nUIpCLNc0HccnMy7u71GWBW2zAGTAxeCJ3vfSwvSyxZKmC6uGVbPCx0xRD/mN3/wfcHjriO/9p/+UejjGFTUKvc5EAAptLUVVMxxNSEAXIq6qmC9X/Jsf/3EeuO8+7rtyBWUKSTt4yFEcizIWpZzoiYfco8QUZV2RsSxXHT/zMz/Htes3ecMbH6Uoevr9lHrFyrWmi2OzlFovLEMk5YSt7+7Q/VeirWLCorFZU6BxqDWWFnr+rKwcXkWSVgSTpQs/BhHv0ppEpkuBKE1ZRKPJRoFLdOSeITmSiDjjUFkRCCyU5ljDjW6JX01ZNpqBUWz3OkXGZNogQBNXl4QUWaymsihCc/HeB3BVzYuHJ0ybFdeOZ3SFoysK7nvrW7l3aHn6p79faqKLFZ86+ARPLH6e7KUB1EQHHnyaMQYe2BpzMJux9J7cdqAVMRlSz6SejNRZohaGAhBnJ/10Eukln8ha+mtW7ZLZbM7F/T0hgTWGSxcv8v73vYfoPb5boXJN8pEnfv7fcnJ8jO8kk6JzJHWeTEajKG3JzmTEYFBTl455sxTHdBfba8qxpJTo2lYgxoMBWgs08ImPP0Hbtnzgqz/AvffeJ8XiLGmZydYOw9EE0ISQiCGSYu5hiprJZIfH3/0+PvGJp3j22WcxrkRpR8yKna1t3vXu93Dpnnu4cPEyZT2QCTMmrC24ePkeTk5OObh1xPbuHsYUsBb2aTyj8RYPvv4hXnj+OULX8q53vYODmzf4vn/1L3jX44/z+OPv6hs/swAG+lX+008/w8GL13jo0Texf/EiZVlTlCW7+xcpq5rOhw31xsaUYjQZc/HyZcqqBq0JfW+AccJC4GMSdUnnhE4CIzhJgacIfWCWUFzEvRz1YMj2zh4vvPgyxyenNMuGQTXc1FW0lt03HiX3OWZ6Uksja+Fzu/vMJ9EFyRhU1tgsbBPkDKYnNS1snwZK0viihDTR9M3DxliS0uAUGUWylqwNwUDSoi+UlaRHY4rkBE3qOPSREFqu0bDSLdd9y9gWXNndIRFIOTJbNXTRE7o5nY+czDpBaGnFu7dfz97+BL8/JLct5mTKYjrlcDpjeXAVZprKFRAyzdGc0jiG1ZBFuyCGyKgsUcqAD9TaUJSC7mxC4MZ8RkdG54xN4iBVFhADWpEV4jz7517gwgpnZQytVksUmeGgEgXYnHnszY9y5fJlRoOaHAtSKNEq03QNBzdvMDudErqmhxkLtNtoQ+kKaWwuLIUWYIQzoNLdPaZeM45FmnITTdtQlRXVYIAClsvEU089xfb2Nh/+8IeFWj/K5A6iGT0cjlHaEiJ0XSAFcSwpwWSyzXve8z6apuP6jVtoV5K1I2EYTXZ457vfw3CyRTUcSTdwz9jqrGP/4iWOT2fcOjzi9SGhjYUej962HaPxFg+87g387M/+HMdHR/z6b/wNHB2f8gM/+K95+E1v5dHH3iHFypxAS09I8oFnn3+Jg8Nj/r03PsJDDz8CgCtK9i5cpKwG+BA3nf+bFSaK4WgsRJZ1DdpIqgNNUdbSW5DFybiyRGsHykrUoyWproxG5YxfraSgazV1PWJ3b59PfPJTXL12nXbVkGLsQQma275tzbPTk4NqweFbc3ejV34lm0fgtLmX0DJZiZhcYqNNYZ0WpgmdpGCuZBFkUVRa2ggzCowFpUjOEZWiBTAabS1oWd3HFIgJmuyJqWOeMi+rlrnp6FanbKkhy91LtCHR+MhhaFnlFbNuyapJHC0iVgmJ69aWJVyZUNmK3Hrs4Yjlsx3XT65z66BBW0VZOnKMnB4dMdreYWd7jD9Z4UNkNC4hK5qmw1mLqQoGgwFdTCxXK5oU0UCbpKBPjASh5CBrJWixnhFc+lnAWU0KkVWzpHQFg7pkNl1AgkceeoiLF/aFS7DvqO+aFV3bcOvgJqv5gtJJf4rWCmNLCmsY1sKYUTmD02ByxGnQ9u4eV68Zx+K9BwXDwe1O7pgT1lk+8IEPCIkcMklabTYTrlAuKFaNNEKFDFlbMA6DZu/CZT7wwa/luRde5id+8mcAQXX5kEFbSX8VQksiBTvp+EdJTno2W/DiSy/z1re9Y7ONUobBYMzR8QnXr91kPNmhrkcMhmOsrehCJiYF2L79mc28rHXBwfEpTzz5FPP5ElB0nccYx7333c+gHlBUFaBIKcuKMAu7sbGO4WhMRvVRjeJ1r389f+AP/H5GgwF1VeNTxDrHeHePrC0hxA1ltHVCZeGqQe+gM48++ia2t3f54Ae/BoDd/QsYK/oTuSf0XEdOSgsrsr4dxpzbXWwBi1UOtEOn3sn0z0O2MsFpa8hGmIFBVFdrW1EozcBYCEL7ghWxt+wcMSc6H7BWUFBJiWhW1h3JahgYsjZkrRm/4V7ccpvDowOK3W123/0ODk6OWJ3c4taNxHzliGrIeLzFh97wCKXWlEoz3N7hkMTHf/LHiF2g1Jbjk2OWqaVMFh0VadaSc2J3NIYQOb51xHg0Ro0UJyczcs6iBNt3OMboyQku72zjc2IZI02MNCGwiJ4uJVZBiCB9jKBT32DaNyR3AYXUQwpncc4wrB11VTAYlDhr6FYrgRDHCClA8oxqh04OS+/PUexNhtR1xXgwlKkheHIOxKAYFFYWhnexvWYcS8qp71q3m0kYQBvDxYuXXtEJq3rm0/U2GbXpKs/9CisjD0RZD7h8+Qo7u3sMhiMpvvcUDSiNK8oNGCD3kkPrCRQUq6bl+Phkozmy3s9YTdO0HB4eMRyOKZzF2hKlLSjpH6DXUcnrHXsuoLYTmG/ng9AmJTDGMplsb5yqFMnV5lpzlqKhtQLbjEnSWePJFm9929upigJnLLauJLLqHVLuG7vowQSS3hK0WoqR7e0dBoMhe3t7xCjQ5bbrek0XuRLZTy5KrfmMbv/854mwu9RiUvKKkNNa7ruHzPaweCFbZSP6phRY7XDaiCwDgZC8kCIaTTLCXBHXekc9O29WEHTPnO2MAAG0Qg9KnIFaBeq9Xcq9PQyJGFvyagsKh7Uw2tvn3offgEsJGxNp2bGcLbh+8ybJB8bVgGWzIGSP67nJUggowGpDjIku+s0Y91l4xwQJFyXVleQeB6Uj5IwJkSJESiWRRBcjuu+gN0HqTiJfLIixLkgztTUaoyVFNh4NGA2HlIXDaEFbimMJKCRlXzhDdBarwPYchXVVMOhfKUa60G0AE8447Dnc+EtjZVH+os+0tLyyAd+/iq0RSkVZ0/lITB2rpmW5XDEYDtDWUVQ1j77pLfyaX/Nr2d+/AGipQxhDjBGlTd+nsb4GEfkJMXLjxgFPPfVJFnOhhtfGbJAyz3z6OX7oh/8Nv+t3/g4efvhhXOnQpmBnZ5+qkg52+oJpaPv0U1FQlgMmWzvEkFktW+rBkLIcMBhscXh4yNHhIcPBFrqyhBQlv1uUct4QCCESY8ZVFfVwKA2hVii66cWK0LrvC7LEEOQ+++sRBgKFsQWVcRRlzY/9+Ee5evUqk9GYCxcu8I53vIO6rimrCtYNkGebtlKCnvaml+o8t7vMlq0QuIZ5wFQjtqoRdWXRwIKWSN6oMiak4c9qLaAP46jqMTM/Z9W2lIUDbVkETwCCdjhTikJkXWPLkqYnpgyhxTeJdhlZHJ6ik+I9b3sX9XCI844i1wzsNo+//fUUZYFWUFrDthtw9PyLXHv+RY5fegm/WHAhanLUtLNDtG+wocU6sNZR1QOapuPmrRPGW2NGO9sc+4aYM8XlHTrvOT6ZUigoVKZwwkFmYsRlcMD+cERVVrRBBMZuTU9Ztg1H8znLnISSptaS6MiyuK2cSCenLvGhr/967r//PrZGotVC9hgyygAp4zSM64raaEZVxfZkxNZ4zHI5J8WAM4msEsrJMk0rRWkzd7lfee04FnVnauXzmKsyuUctaaqq4vLly+zvX2B/bx+lNb4L0BepL166zJvf/BijvtCPWudQewSIhCKbU69htcIGPJCGypQ2EUXqNRbm8znWFQwGQ0LoqKqKB1/3era2tjeErvTRE30fQYiJtvVk1IZpVSmFtYoYE6tVSzyrx6Bu/08pcQy39RqUNGoakT+lh4AKtLSHcCstGjL9+/W9SjZRIsA1Zr+ua6qqwlr7iuiJnDfw7/XvlXNCowV+fW53nXVRxEayEgg6WZH66BWV+34WYRBOKcriI2fA9dsqSSW5ElfUUFhMkCZbA9iiwBYFKWd8DGQnnekpB7TRFIXFO4fJmrKsKFzREzE6rCmoigFlVZGiJ3Qd1w+vM7t+i9nhKWnl0T5hs4w1kzKl1lBYVI6k0EtsZGE/ToiIl++ZnLPKeA3BKoxTJKvxKfY9WBYVMykEMBZtLbWxlNqQhyMGrpCUVwgsQpCaZWEYD/exZUE9GRODULHs7e4wHg17yjNpdMxZIM0qC7x4PBQOtbooqMoCZzWFNSSVcUZJO0BpSTGSgqTQ0l3eH/aacSxfrMUoD8rW1g7f8i2/jW/5lm9hNBqhteb48AhrLVvb2zz22Nt44xsfYTAYcHh0BMpK7tkVssgPUSgclEB7hck6sbu3xxsffhjnCtrWU1VCzR9Dous8TdNsIoAYE7t7+/zaX/frecNDbySEtCHSNEUtdY2UmM+XHBweo7Shqoec9aJt13I6m/VKla90uEpJfSOmjA+CNoupjxr69GBWr1L0U4IOWqflQhCnZEzeOJXhcMz+hcjb3/52xuMxo/F4s3vuc3Fn3cdaflVlgSOfJ8TuPlt1EYzFVJXk7JOibTuRyS4zykq6q02JGCO+h+uPa5EtbjuPtiWjrQGDrQk4y7KZY0kEMoOyYlhUzFcrQrPCbI+Efih01OWY3cmYIQ4VhXsLNMaWOFdRFh6tC3LWLOcdh9ev88RHP0rVBSofuXc0oh5WNKe3ICVqa6kLSy5qbs1Oadolzg7IyjCZjGgIHM2nqEEJVjMPDSEnfKWxpSEXluV0ATFSFGNSDKyWM/Atqm3Y3t6jrGr2d3boUuTCasnJYs7pcgGjAW444KF3vJ16Mma0u03oPMF7EfQzhtC1QMYYhfdCH2VVRqXAfZcvCg1MEjmNHDpqp1HOUTqDUhYzKFjM5yy7htCFDaXS3Wq/TB3L7cjC9OmskxORDR4MBhgjceRgOOgLzWCdTPCZjA+eEGO/6pf4JCOFPq0lzyx04YYr99yDf/vb2dnZxjl7u9YArJYrDg+PCCH00Y/e1Dwu7O/3zYpI46RSmy711Pd/rEPrdXoqxkjwgeA9XdfSdR3OSU0oxYjqO/m11pgeoab0uuaSN9/JOWRVuj7+Wc0U0ytTKtY1K9jf32dQ10y2JlRVBUqaONM6tfaKI4ht1lTnhfy70gbDMUWvVBhSpguRUmusVmQnhCnNckGbO3zuGE8mFEUBHrrOE5cepQSmm2yBrUq2t3YohwN2L15gWNYMipKnP/00J6enzOcrtNHslTWV0qSuY39/j9KVVOMhtigxg5Kdao9qfxtdFKIJrzTtckE5qHHOY33EO1GdXOQOcsDqKD0lEQorMGfVM2aYskallpw9b3jLo4z3dtCjmpAji9US37b4puXlZ56jmS0IJmO1ZbK/TW0kHdxlj28SGqmt6NKgo0Ulyyq0NMvEjZs32Aodg8mI0lkGVYHKSdRoYxDaFmNlbvEd9WiAKixV6QgqC/W/lGzYnuxQlQXDusJohdGag5s3OLhxE+/bDer1brXXjGP5/Kem9UQpE5sxQrd/enpKCEEGRr9dPRiynv60MeiebTgEUaKLvWPJff+40qqnM5GjW2u4557LTCYTtre3KJz8nBGZsFcrcSzeB5mgtWE8nvDYYzus5ZE3QIL1daueWbinR7ldoM+EEKV+EiJd29G1LUWPhlun4W47FrlO3TuW9fnEMQr9ivSZ9E54M/krTL+PfE7vWPboJhNG4/Hm2ClJX9DZ/dcdwevifV4f4NzuOhuOxuiYyD4Qs6SKamtwQhxGmzqa5YIOT1CB4eASw8EQfzgn+MBy0YkMsLHkoqHUhkuTXfYuXeDRx97CoNcHms/nRB+YvXyEKQr2tvaIrbAV79y7zXi0RchWoqe6YKuu2akqGi8LPGsMzXJOPR5gO08RAjF1NDGypEMRKbV05OYkrOUORfQO4wrKwZAUDSl1PPrmN3PvGx5kcGkPnwKniymHNw84PDjg8OgWTWhJGYxxbJcjSmUpMJwcT2m7FlRAFw5XjyBoCJpmtcKHFnNwnUjinvuu4ErHcFCznM/xoZO2Aq0xOaNSJAdPXRY4a6jLAq/EKRoFzmguX9jfyImbXtTMqkS7nDOfx16U8O6114xj+WIspcR0OqUsS77hG76BBx98Hd4HjDGbUDIlSVlZa1+BtFjXEMIG7fXKnGbOGe+9MC5vb/WRg5jWSmCWKfWpMEmhrZ3aOrKAvEGwdV0HiJolPaPqOt2me3CCUor9/X2KomBvb4+qqja1FGvlfLGPtNbXu/7MWrtxsnL9cNZdp56xeN3reMbPAAgFThJyvhjPQIzVug50+1i5d6z6TI3q3O4+EzCHRMI+Z1oSlBrrDK4yqJgooqaoh+zUBY+/4+1cvHiJwhuST7RLjzMl1hZ4FFlrit0JripoVy3tYsVxjBwd3GI5nXFpe4+UEsc3bgkbtrY8+amnyFkxW3VMtrd55M1v5fD5Yw6PT3jgwQcZj8cMtebK7oQPfuDdDMuCYem4efUFZifHvPB0JHQNKXW03YquWzGua5x2xJnQKnWnMxZ4GhVZLhqW8yV5WBBJtG1DPay5Ul5hUn+Q2Hbs2AGVcYxdzcCW1LZkNhMxu2tHR5zMZzx/4wYhrmi7zPblPbRzZCT62B4OhT3de3ROmH6uUEaBgbooqN0Wj77xIXa2Jjz2xtezWi44vnWTxXzGajFjNKxwFlTy5AxdikTfoAhY09dI72J77TiWL6ZWlRElRed49NFH2dvbk0KfuX3A9eR91nForRkMBlRVtenTWM+PmxV5lgnbOScQaPLGgYCgN4wxfUe92hx3beJcbk/gUsg/W4u4DSNeb6+U2ug7lGWJtZYYA9zxkG1vb3Px4sXNv3/Rz9IX59W6eXhzItU7BX7R710UEhmFcKZ3ZQ3v1koQeusfHfp0oaQZs7rzCs/tbjDdN8QqrYSsmL5or25ziDmjMYXDDmr2dna4eGGfmorUJZazBqMLtHIsu67vVTFEHzk5OiYGT/Ke5WJB6DxbkwHee+bNDFMUmEIzm03pvGfRerKBrl1yenjA9ZdeZm88pMwR5Sw6R7ZHA7a2RmxtjfBpCaViMN3Bdw0ptviZJs4DwRoUmqSkmbnzHVEnlIVmuWI+m5MGUhxvfSP9OkYxmYzQCXaLIbUr2a7HjKoBo7JmPl+xbFrioECdVNxYzakIlAS29naxrmAxb6nKkkFdk0Ighk4E1JTC57RWA8MYhdUFo8GAyWTM1qhmOZ8R2xU5ekK7IoaONnmsEu6wFAMhtIDsr9TdDQt77TiWL2JqWkcVly5d4lu/9VsZDAaU5Ssbi7RWlGWxmfSLomAymfChD32IS5cuYozqayvrnyr1UUAi50jOUo/oOqGTd7YQEj2luf++K7z//e9lMhkLrr+HIocQ+mPedjRFD6fWfb9ACEkgzv0+62tzzjGoB5t9RdY40TZLrHWUpeM/+8++fRMBFUVJWZZ47+m6jqIoekf4il8KSOSe3mXNbRkF2N9HH7edqziN3nG8agew6iHgZzznud11VpYFpswM6oJxiNQh4kPLskuoTqjpt4YOPSgwlSN2K1azU5bdlPl0yYvPXmU+X7KYNUznS7oYsYOKLniOZyeUpaOsSrbGE6qyZNV0IqFgK8ygphjVKJWxyfLYlYeoXEFsj2iPXmL54tPcDAvmVcnJyTExJ5KD+x95A/c/8gbsXsn+pXsZPHIB1WcIXnj2OZ5/9jlefvLTrE6m7KUBKmVC21JNhmxvDXnhk8/w8osvMLq4hXYGVSi6rqFrG2anp0QfmFQDLuzt847H3s6F/YtQGY7TklX22L0xF/bGbD/yALO2Zd62VPWAHDMvfPJ5tidbvOHBB7h5/To3rs8oC4fTmo45OgsTO73Ozc0b15hPD5keHzGbnvDS88+xmE9ZzmY0qzmQuHRxH9dnWIKXtN94NOgzG3ev/bJ2LEopqqpCa81wONxMqOt00DpVs05NpZR6zQTHQw+9ge3t7U20craGsJ5oRVZ0s+yHdbNhkkL83t4ejz7yCHVd98e+ndKS68h9jUO9Yv69M40U+8K8MbdXKRs4sRL6Gmlkk+0nk0m/1e2Hb03gub7PzydN9Wpfn43e1r9b7hslz/6J1tBjQcQlrLm7V1i/Es1Yje7BF8JAHElI34SIVyXIkehbQpOYnhxJwyElq2VD51tC8MQYSL3yoVHCNu60CGLlvlHSGIMPUrN0RYUPieXpjOVqhTKKyWSISomTgxvo1LI3qSmUR/tIkTt8CjRtYHZ8wLWXDXoyQFcF5c6EwpVU4zHj3V12FytowM9W7HQlq+mcq8++0Nf6tHANJs+wHZBCwK88bbuibRtMTFilsUoRO8/R4S3atuX45JjT+VKYO7QhKU20hjYl2pQYDke4wjEejRgNhhTWopEGTazpI/rbmiu5Z1E+OLiB1YputWC5mLNYzAhd14+vNdJS5pTgI6nnQFSsQUV3r72GHMsXbtpoLly4IDrTvQRwjILHzzlTlusoQeO9x3tPWRbUdcmHP/x1m7rEnbae5NdOAZJ0J2dIOWz6Nh5++CHuuecS2zu7mzqH9KNYYpRr0dq8YrIGARwURbHpgG+aBmOMOKgYNwXz3EcaWuvNvcDZepA8gLevV8AJMcZXbH/Wka2DKCnsi1zz2fLSuth/1mJKGwTb5hh9ncZ3UvM5Zze++8xaDSHSdktcDNgYKXudO2MzKUdCt2LVeFbH0nsymkzY2bkMSaMs1IOKqqgZDIYkYLK7Q0aYiZu2oe0aBmPpdp9OO5wtmezs8NzV53nu6vOYQjGeDNjfmzA/PuJnPv4zPLB/gcff+gZWp8fEruPCeMyqa7lxcsytl5/h6ReeJJQFdjjgLe99D9u7+0wmu+zvX2Y42GHvq76aSjnc1PPsJ5/m+RdfotPgciK0AZM0I+MIyTO/dUTbX+frXvcgk8kYay2d93zqqY8zW6yYL1e0MZGUohxNiCiaEDBlha0q3vOe97O/u8+FnR1G9RCrRFI4dB3RGSwap3uHaw1d4+maFR/71FM0qwW7WyNSijTLBXVZMB5u0dYWcmJ7e0JOkeViLtQ5ORF8i47njuXLbGfJRCCGQOrRUOtXjLKN990GQSWhpd2gpuq6BoXUMNS6obA/aJIUj9aqr08kaYDSwgibkdxuPahxzlKW5auGrredSSZGoaAPIbC1tc0jjzzCcDgEwOg+MqJnGzDrwgtIof/MQ3aGu2uDjstpAxJYQ4lByCJz339yO9WlzuzZM4Kvi/m3C009vVjeUMGcrVHltVdZF5Hucsz9r1Q7OT0E70nzOdoaamcoBwNGpWVYG2Ly5FVHiokUE0ZlUgzcvHENsBhV4XSJUwUherousHhxDlqhC0NIkZgi2hZYm3G2RmtLu4roZBi5AYOBZTwYoLoWHToGtSHlFaerW+S8JKtA20pad3enwqzArjLzzpPigvmnXqQtb3Hw8ReJUZGSwj36ZszWDtoYhhf2ePsH38/uzja7O1t87N/+HCfHRxzdPECRcbGH+aJpj06YLlbUgwFoxdAWFGPH1nBMl8Sx2HJI6wPH0ynNomF5uuDaJ58hXJjxpkceky79pkUBdSWy4SkGzHpIpIi1GlOVWCvs4NIqkCmKgqJwAgRKhaTakzSsWmvIUSie1kKHd7P98nQs63ksZ0IM0n1rbvegKCWppBBi71h073Ru/xxlWZJyIoRusxLfTMgxSXir7br6L3OnEthwRibtuirRw8Ga4mcz+d5Or92+6thL+bZNx/bWDo8++ijD4RBFX+Ppz6+0wqg7SB7P3O/6+K/4RXqo8QbBdcbh5CRptLWG9lm48PrYt/3fGSjxGWfyi/7f09QAwpqc7+5B8CvVTk4OIQTSfMFgVJPcgGpQMBxWDEsIQRGzJflI8hGrIcfAzYNbaOUYDnYZVgpXFsQQaJsVBwcHKKMZToZCsGoU2hakQlGX24CmbSI6WYZ2wM6wZjKoUG2Dji3DypByw3SxxJmI0olVM6MqSi7uXsKajEsRVi3tsmPxzMu0PnHrZIm2FcYNuGd4iYGqUVsj6t0d3vqB93LvpYvcc2GfGzeuMZuecnzzFs5otkcDTFakrGmOTmmVIm9tUdYlo60tbFliihJPPyZMyXLZEBcNfrWkOTnlpnmePG/40Pu+Bmsdt46OUUBVlnjfkIL0sOiewcBpja0qnJWFbMoRo6TWWxRW+uEohFMsr2U1DDFodOylKM4dy1fW1n0eku9P0j18ps8DztQruD05SoRxe6I22qx7JUWfflNoQCbPDSpKpm3bF9V912GsFTXFvBbHSptrWB/HWSGvK5zl8Xe/k4cfeYjLly/Ld/09pBhZU2iuJ35lhKRo7ezQ+hUOYH39cl4+r9pKTreL9jnnM/GfIMBeiVTre2XIPdFnJnpJm5jeab8il3Zud4354KmsYf/yPg/s7fL6/V0u1I7aKLSfY4zD2DFVrBnEAFajrOKhhx5itfJcv3ZI8pnYRibjMVvjschckzClw6eAT2EjCJezxmhHXVoOb97g6OYt3vjgY1y4sMXNl6/SNFNUDsTc0WWPNkJjtL07RGdFszxBh8zQKAY7++SkWbWGVUooZzDFAFMMufH8NY4Pp7BTElVi5VesuhUZUVEdjcfCsZcidIHsPdl3lIXDGkOpFSZl/LIh+oByHdnYHpCSiKsGWs/FyTb37l3ka772w1y4dJlbV69xeHLKJ595huFwyHg4IJMkGnEFMXimp1Pq0lGVBYWzDMoKRUQrRVWUWBFxpSgsZC0aLVpROEfXtoQQNi0Jd7P9snYsSimZeHtb93is6w3Appi9/vftlM7tlNq6BiGf5tswXW4Xqe8MQRTq9vnW2/THXzuWzaqjj0RA2Ff29/fZ39/fHEsbI6R2Kb3iuja2DiHOFPRebSr/fOVMX5nWOuPE1Lph8/b7dT9QzohsaxbnIsjpNRfZeSrsbjRJkVrqumI4HjHZmlBbKIikKHx5xhTkpMnJ4vsHfzIeo9QKHzxWdXjV08TbgrIsiCmK0FxG0sbr56lnczDaCpJx1VI6x7CquHlwjbZdInXBSMpB2MSVkUk2ZtKqg6RxyvQoSkfuIklFKu0wpsDYgtVsybLriLkk6kSbWqZzAQqghUxTOVGQzD5K7SLKOLVKiyZKhhTCGai8Qq0zDyFCTNRVwWQ84XX33c+Fy/fw8k//LCfHx1y/fp2LFy4wqEo2PLlaEwHfdTijSM6glTBkrFkzJOUtFEha675+L2NpnW1Zc/Dlu5x/T93t2snndm7ndm7n9tqyuzueOrdzO7dzO7fXnJ07lnM7t3M7t3P7ktq5Yzm3czu3czu3L6mdO5ZzO7dzO7dz+5LauWM5t3M7t3M7ty+pfU7HopT6H5VS3//luJjPcP7nlFL/5Rex33cppW4opbJS6vcqpb5DKfX0L8U1ntu5fbF2Pr7O7ZelbQSnPsML2AJ2Ptd2v1Qv4AIw/AL3eR/SyvFNwGWgBr4DePordR9fyRfw54GngDlwCvwo8I2fY5+vAf5n4CVgBXyq/w3LV9nuh4AT4Aj4m8Deme+/jjO6X3e8/viZ7X7oVb5/6bNc3+/tt/n+z7LN1wPxbv67n4+v186rv8//BXgBaIAbwD8C3vI59vt9wA8Ct4AZ8NPA77xjm28C/hlwHVgCTwDfTt8Scse2fxD4t/01HAH/9Au9RsAB/w1wrR/f/yvw+Kuc60Hg7/TX3gCfAH7j5/qtPmfEknM+zTkff67tfqks53yQc158gbs9DKSc8z/OOV/POa9+Ka7tNWRPAP8J8A5kUvgR4B8rpR7/LPv8KuAZ4D8E3gL8F8AfBv7CegOl1FuB7wM+CrwX+HXIb/+P1O2uyB8F7rnj9ceQTri/d8c5v/uO7d75ahemlHoL8J39fbyqKaUuA38D+Fef5R6/4nY+vl5TlpHn/VuAR4FvRJrMP6KUqj7Lfl8P/GNkfHwV8pz/TaXUbzuzzdcBPwZ8M/BW4M8B3wX8H88eSCn1p4A/Dfx3wNuADyIT/xd6jX8O+P3AtwHvAT4NfH8/btbnuhf4caTH8zcAbwL+Y2Sx+dnt8/DS/yNnVoXr98B/2p9gDvx1xAP+74HngWPgrwHFHZ70ryEr5mPg/9X/cJ91lQM8B/yXd7z/k8BfRLz1DeD/Adgz1/eKlW//+XecPded7/vPPtjv87oznz2OTE5z4AD4B8CDdx4HWXE8BSyQ1ffDdxz7ceBfANP+WB8F3nfm+18N/Btk9fAy8D9wZuX/S7D6Oga+/Qvc548Bh2fe/2ngqTu2eWf/G374sxzn3wDfe8dnPwT89c/jGgbAx4DffuezeWYb3T+j/6dX+zvfTa/z8fXaHl/IYi0D7/gC9/snwP/8Obb5S8BPn3n/EBKB//v/LtcITJDo4z8+s41BoqXvOPPZ3wB+7Iv5Xb7Y4v17gXf3f6zfAfyu/of6auDX9u9/N+IR1/Zn+4fjdwPvRwbAH/4iz/+fIiHc+/p//xHg9/TffTvwR5E/wHrl+0VZvzL+YWQl8W5up1a+7w7vfw/wh4DfifwGY+D/d+Y4jyGr6+P+GO9EBqvuv1+vaL4HeDvwm4HXAf9gvfJXSn1dn8/+ui/2fvrjWKXU7wZGwL/+AnffRgb22irkAT1r69Xrhz7D+d+G/EZ/9VW+/mal1IFS6pN97eGBV9nmrwA/kXP+ns9ynX8CGUh/9rNsczfb+fh6DYwvpdQY+AOIo/rUF3Dr8IvH0uezzTcDHthXSj2hlLqqlPrePnPwhVzj40CJOGIAsrBdfh/i/FFCfvibgR9TSv1dpdRNpdQvKKX+z0qpz00F9kWuqG7yytXS9yI5uPLMZ/8Y+Pv9v4dAC/z+O47943xxK6p/csc2/xz4u2fe/14g3LHNd/AFrqj6e/2eO7YpkRzobz5znABcOLPNb0NSPVX//m8hOVH9Ge7xh4A/c8dnD/TX8lX9+/ciK7b3fpErq9+ArOQishL9rDWWV9n/zchq8I+c+ewb+mv8NmRFvQf8w/6zv/oZjvOXkZW4uePzbwN+PZIG+EbgJ/rn7PKZbb4VeJK+JnDns9l/9mFkUrz8mf7Od9PrznvgfHzd9eMLceLzfv+PA2/8Av/mvwvogHd9lm2+DnEiv/HMZ//vfr+n+zHyHiSdfARc/HyvEUlv57PPWP/5nwOe6P99qd+mAf5bxFn/zv5c//XnuscvNmJ5MufcnXl/HfhEzrm947OL/b/fCBTIg37WfuyLPP/P3fH+KvJDfKntPcgqer5+AYfISv3hs+fPOR/ccT2K2/f/OPCRnHPi1e09wB+94zwf7797GCDn/NGc85tyzh/9TBerlPrndxzjrP0gkt99P5Ja+VtKqXd99tvfHPdhJF3xPTnnv7z+POf8EWRF+13cTjF8Akmf/KJ7VUoNkEH117OskDaWc/6rOed/lnP+WM75e5GVeYEUPlFKPYqsQn97/gw1AaXUPvC3gf8o53z987m3u9TOx9ddOL7O2J9DJtoPI7WJf9hHBp/TlFLfBPz3yCLgZz7DNu9HCu7fkXP+p2e+0sgC7ttzzt+bc/5JZLGVkHH1JbnGM+cC+IWc83+ec/7ZnPPfQWqbf+Rz7fzFshv7O97nz/DZnY4rf5Hnu9O6O96/2rk+l72avqe7471GVkN/5lX2P/wc17Pe//Mxjaww/tarfPeFTJB/AMm1/yLrJ+M1HPQnlVLvQAqDv/2zHfBMgf4fI+mIO4/7l5VSfwVBB02R3/SPI4X/O+13ICm4v/65biTnfKyUehJJWQB8ANgFfvoMW/I61RGAr0X+fleA/+WObVS/zbfmnL/7c537LrDz8XV3ji85ec63kAjyU0qpH0Wu9XcC/5/Ptp9Sal0X/IM551e7FvpU3D8Fvivn/J13fH2t//8TZ66lUUo9g6C3Pt9rXB/nMoIeW9ulM9/dQp65J3ilPQFMlFI7+bOATr5ctPlPIw/HB7i9UgBZPX+l7CZwUSllzqye71zB/xSSk30m9/HhF2k/DXyDUkp/hlXVTwGP5Zz/nfoAcs4vfwGba2Rl+BlNKfUeJA/7t4E/+pl+g/7za/0+f6D/+B+9yqbfhhTtPyeqRCk1Ah5BIJjr4/3UHZv9aWQw/EFkVaYQpMxZ+8NIGvDXAy9+rvO+Ru18fH0ZxtdnMcXnHkt/EPh/Ar8n5/w/fYZtvhH4/wN/Iuf8377KJuua6JuQlCVKqQJ4PVI/+nyv8aeR1Om/j0RP65rKv4cAQMg5e6XUT/TnOmuPAp8Tyfhl6bzvV8t/FfjTSqnfoJR6RCn1XyN5+y/VKusLtR9EEEZ/Uin1kFLqtyKQ3LP2ncg1/m2l1HuVUq9XSn1YKfUXlVJv+ALO9d8gIfffUUq9e30+pdQH+u//b8A3KaX+O6XUV/Xf/1ql1P9XKVUD9Od/Sin13i/kJpVSl5RS/5VS6n1KqQeVUu9QSv0ZpD7yN85s911KqY+cef8h4CNIpPJdwCWl1GV1Bo7Yb/fH+2O+SSn17cjg+c47B7FS6p1ISuIXFe37+/2v+nt8sD/3P0EGw/8AkHM+6dNkmxfSO7Po3y9zzotX2eYm0PXvT7+Q3+61Yufj68szvpQU+P9Q/7w/oJT6VcDfR6Kzf3Bmu48opb7rzPv/DKmPfDvww+txpJTaPbPNb0Xqk3++v4/1NhfOXMIPIOnOv6CU+pBS6k2II9DI4u/zusac8xSJXL6zf14eQ8AQNa8cn98FvLcfmw8rpX4T8H9FEIOf1b6clC7/BRLifTcCBdxBwsI7UUVfFss5fwJZ6f4OBL76+4D/yx3bPImgUEbAv0RWg/898gc4+QLO9QtIMe4CgoL5OeA/Rwrp5Jx/EEGzvB1Zlfw8Uk+YcTsFMkBWC4Mv6EZlJfsO5KH9VH8fjwO/Puf8D89sdw8CZ1zb70PQN/8REo2cfZ21X40UR/8tglL6P+Sc/8SrXMe3IWH3v3iV7zoERfa9/TX+rf487/18optzA87H19fxSz++Vghw4AeQ5/S7kfTv+3POZ1NKD/FKtNy3I3DedRpq/foHZ7b5T5BU4Z+4Y5ufPHOfGfhN/Wf/BKmhXQa+9kwN6vO9xj+OLNr+OhLBPAz86pzzZnznnP8Z8vf7LcAvIE7vzwN/6rP8RsBXWOhLKfUDwHHO+T/4il3EuZ3bL1M7H1/n9pWyL5s0sZL+hXchXrZA8PYfRrpRz+3czu3fwc7H17ndTfbl1LzPCKroLyEpuKeAb845v1pq5NzO7dy+MDsfX+d219i55v25ndu5ndu5fUntXI/l3M7t3M7t3L6kdu5Yzu3czu3czu1Lal/OGsu/k/3ff89vyVpryrLc8NF0IZBzxrkCbTTKGJS2KGNxVYk2Fq0NGYg5obVBa009GqK05uRkitKaqq7JZDJwcjwlRXjdvY9grYGcuHr1Wa5de46HH72fre0BIS1IORBix3A4YTicsFglYlQYvUVWjpRrhuMdhqMdJjt7DEZDHnz4EtZZsoJEJOWEVqCUQqHJKeGjR6PRGZ74+V/g8NYtFrMVwXuaVUOIiRgzo8kWw/GIN7/tbRRViXYWazXGauqywBqNSpmu65iezqnLkkFZYjUoBYrAyfExTz31cbrO0/lIiImUMt5nUBplHQ88+DoeePB1WKdQShExKK3QVtG0kbaTa845UzrAKLKR31lrTde2pJR40+72nV3Y5/YVtsk9e9lZx2g05vKFy1zav8itG9cJXcPFvSFlqRkNNBf2x1zYH9M0C7zvWC47crYoNWK1VKxWGuXGLFvPP/vnHwGtuOeBK2ibUTbx4nOfolktuHjpEiEFjmcnWGdxzlKWJdZaBsOatus4PLzF3u4uu7s7NE1D13bcuHEdpaCua3KMpJhompYUE4UxGK2x1pBCIodElxIxQ4eSTiiVGW5vM9zaopmeEnxHkyLGGKqqpK4q6roihEAMgePDIwDKqiL6SAyR3d1dyqKkWbU0qxUnt46o6gHlYMBysSD4jtT2BAFa9S/Q1qKNoRoMGAyHXLxwAd95fNfJmCkL3vXOd3FwcMBHvu/7uXLvFa5cuZdPPvUUs9mMvb09ckw08xXVoKIa1Nxz5QqD4YAf/Cfff9eOqdeMY1lPVGfNGnEazjmZLbVCaYPWBmst2lhAobSmsKbfS2GtRfXHijGyWq1o2oZV0/DELzxJ13ouf+P9bG1tMRwMmM6HDBdDutBxOvOczm5QVQX3XLmE1pYQPdY5bOGoqxHWDSirHfb272F3/x5sNcA4i7XyoCegi54utdS2xCoDRLRSlLZAI6FkWTiKwrHSKxQZcib4jrbraEPHdH6KsoqtnR3ue90DLBby3aWLF6iqkth5Tk9OePqTn+TyxUvcc+kSToMi0bVLTk9PmM/nOFcwqEtiUqSUmS9aQkz4tuP46ASlX8ZahzZG7sVYbOFYLJcslktOpqd0XYcyGussw/EQVxS4wnHj5k2WqxVv+tD7vmzPyrl9frae1LUxGGMxxgGKlDNZKzIQYibGRAgB7z0+BKy1SMuFxTqNDRpTOEJSOGvAaJxzaJf7l6U0Q77213wDxyfH/MAPfEQWSMlTVhXaGLoukGKirCpuHR7y8ksvQ5RFVzUuscZAhpgyMQQUYI1mNB7jjKVwjrZpaVctzXKFD1EGmtUwLPEpslou2Lt0CWMML730AkZrRsMBs9mMmzeuU1e1LIZWK6xzOOdIMZFSYmtri7quefGFl4gpYeuSNnasThpoA6S+Vm0VlBayjFdXFFjnKIuCwloU0LUN89mcyWRCVVZsb2+zWizJjadQlvFwiImKuOy4lQ4Yjcc8+PDruXn1Bi99+gVGwxFmM5/dnfaacSzOOZRSaK03EYtSsoo2xoBSJDJriiitNMZoxLEYrHN4HwghsJgv8DHwwgvPo5RmvLWF0hpjDEVZkLNi2S4pWkc9sIwnQ67oy6zaE2ZzcUIxB24dHTIYjBkMRlT1EGNLYoz4ZsVsGQhZ0fgok3HhmLQ1rrQUg5Lp4pTZ8hRnDFopDAoyqIxELChmiynet2iVQSV8aGmaBfPlkghoY4gqcuv4gKPpoTicrmN7a0JVFpSuwLctp6dHNMsZ1156HpUjikzhLKvVkmvXrrG9vc329o5EewqUkt9Ra0XwHavFgqKsMNaSUGSlSAuJGH0IlGWBc5aYEsZqNGC0kqhJIU7x3O46s9ZtxhPrsUUmpYzSBmU06ExWiowi5kzKIOwfsjCT5+T2wk/JkENrhTGgdUZpCD7w3PPPsVgsiDH222qUsWjrcM6SmkwzW2EKy2Rnh3bVknKiKGustZRFQfQSVXRtS06ZjCKIB8SHhE+JlDMoMGUBzqCcwxqL0YYUIwooigJypmtbYuuhTVAktNHs7u6ScqJZLQlNIDaBg5dvUJQlRmmctbQoyqrGuYL5ySned+h+oZtDpKwrqrrCWln0dm1DDJ4YPFopqrKgKgsKZ1ku5qyWC8gybpy1KEllyO8SAjev3WAxn5F1RlsZW3ezvaYcC8gDnFISx9I/nNZaSWWl2zRB8qCLV9dGtgkhEGOkbRqWzYoXXngRay33AMPRkHow6FNtilWzoKwsKQ8YjYeMJpann7nFbD4lpBYfOyKehMJVFZPK4lzJbBZZtR2ns5bGRxarFlPV2KKgiTvUw5ptM+F0esLB0Q2UTigFNotjIWaMMmg088WUzrcoLY4lhI5Vs2Q+P6UNkQQsmgXGOdy1F2m7jq7rqOuS0jl2trYxRmOA5WzOajYn+A6lYHdnh+g9J6enKKUYjcY4Z1C9Z15PGCF4los5GbDJkcjElFk2LRgNWlHV/Uqv62RS2bwUmnzuWO5S09ai+ggFJQuVlLOkaLWRqF4nUPIXTFleRhtAkzOgQGkl6VGtZGHXf6Y1GCMpoZgCLzz/PJ33pLhOSxtJV1uLKyu61tMuGib1DuPtbTAzQggURYVzjqqqiC4SQwA0MUYSmpwgpUQXIyGlnlZbYaoCZU2fJrZYY0gxQc4UzhFjoGs7YhugSxATplDs7EkabnrtGqlJ5CZza3UTYw2X778XjEUrxaCuGY8ntM0KnwK6dOSYiE2gKkq2trYAyYrMZ1NijCzmc7a3ttiaTKgKR+Esi/mM1XIJWRbE1oqDVhqctaQYuXn1OmhQRsmYPncsXxpbO5Z1pJJSwlgr0Yi1pJwIvWNZr8CUAu8jOoNxCeccxlhqwK0KvPdYa9nd3aUoJWS9eOkibdsxm5+SiVQDi3MZYyNd8kSVcHVBSoH5Yoa2DozBFAMGQxjvXEIvOg5OpsyWpzQx4JPULA5nY4bjIZe6i1w/uMr1g6sopM5SWVmNzaczNAqdFXvbewyqmuFoxHymuHVwg7ZdMJudSLQQIy+8PKesKy5dvkRRlZRlwXx+wrHvePH5Z7DGMBoOWE7nLGczdrd3KIuC66ul1HS8J/gLGK3QCjKZGDqJ7JWla1Z0bQMkXFGSW4sPgdlsTu5XVQnIfTo7xMBytWIwGjAYDDk+OaZt28/wVz23r6TFPr2afSKkTFKqf2mMLXDOUJYJW5Ro5zDWiXNJiZwjMXhCtIQIOidylpQZRpGSJ2cFZEiJ0jk++DUf5PT0lB/64R8hek/XrGhWJVlBPRhQ1BXDC7tUoxFFWRFPp7Stx7cBZy2DYZTrTZm2C6QYccb10bHBFZVcdylRS9SA1hhjccZitWF6ekKMkUFdYrQmOoMeVRSlpR5IVL5aSk2zKis63+GVx1UWbTWHRwfknAkhsZgvCF0g+CD1x6bFWMNoe0xROsiZ0XCItZadyRbee5bLJcvFkqsvvIy/2LG9vcVDr3sDdVFBhq5tWUxnGK0oCkszayjLgvsfuJdVs2LVrMgh4pu7e0y9ZhzLur6ScyaldCb07kP4OzhNVV8UF7u9j7UGjCGkuHFSdV2jjVS1q6pEKc2qWWKsJqaIzhlywhaOIpYo3ZFCIMRA5zuatqELHUUMWGfQVhFTgNiSOsOy7Yg50+WGlV/iBobjkyNOTo4xBoxSdNYR2o7T42NUUigUW6MxWteUhaV1mhg93re0/fm6EJjPZ8QU6LoJysgqp2mXtE3L4nQq95sCy/mc1WLOoCohJ5KXPLXSGlJC945YUsOJnCXqiClIvcW3oCB6SX91Xbv+kVl2UqB3hcP7jpPpFO87vPfMZzO8v5P1/NzuBks5y987ZUlzKTapTqV1X3uRyEKpPnWlNIkskU2S+kNG9+CXTMoRlTVCMizhi8qSWh0OBsQYGY1GffrH473HdBatNcZZykGNLRxKiUMw1pJ93ERLJMipf05Rm3S4gHQUkqJLqJyISdJeRmtMv53vOkLwDMoCbRTGOXEw1khdSGvZJsZ+TMgcoq1GW03bT+haW2KMdH0RXiEOV2WDdXI/pERRFFRlSfRBasIxSvZgsaJrWnznsUZLDQlIMRGDB2RuisFD4SirAqUyxmhyn3W5m+0141gA7mzmXNdcJDfcO58+htRaCpKjUUmMiabrNumxQVVR5aqvqZTs7OxwcnrKycnxpkj50otXuXz5Eo+/5+1kOlJueevbHyOljp/9uR8nh0wxqIgkZss5+yTQcDo/YT5vWHULBoWlrBTtfMFi1fDywQxXOq7eepFVs6BpF+zvbaMKx9HxMaHtWM4WEDMqK1AP4kqDNpmYWqazI06nh5yc3qLpWjJw8cI+ZV1RFJabN69x6/CIyWREURZsbY9wxlIXDqeHDEvHdHrMkfcUxlIWJdvbO1hrKJ0AGmISJ6qVoiw0q8YTfUezWtD5luWqwxjDcDSUNIYxHD53wHK14vKlS+iciF2Lby3ealbz2XnEcpdaSOJUchTHElFkrcna9P82uNKh+tqa0gZtEjHJwiPESMpnai0qk3OArNFEjDJYKX+ynC/4e9/zd7lw6SJf86EP8olPfpJPfOKTNPMZsW0oHnwAVxS0bUfKmabruHzlCs46QhdRSlJwXdvSNS3NqiDFRFUUMg+gehDOkma+IHpPVlAOKkbjoSxCEcAPKeG7lmI44J4rl1ktVyyXS1KU+s1yMSeEIICCLkvtQxmsMehK5hBJmYuTi8FD0pI7JtE1K6yCbA07kwllWfATP/rj5JzZ2t5CkxgMHIXTWK1QKaFSgiyAhNI5oo90TYc1EH3D9Rdf5KGHHuL1r389Tz75JAfX7uSCvbvsNeNYUnplSHI7Grn9/hWORUnOVxAskdxJURISKUVZXSh15iXHKYoCQMLOtiHltJaKwjlH7FdOMWVCSoTkUTEznc/JyrGzMyLlRBc8tn/56InRk3MipkDbrgjRS9opRYLPzKanRB8gJkigs5L1l4IYQ18fkmNI8CYrxBA9qlPM+zxt1zY0jSGlgAoRazSxcyTviV2gWUmYn43FKH17Ncd6fZk36kxaKxSZnCJd20LXsVyuMMaCVmipzkqOeLWi296i857VYt4DADIxeHJ6hVjkud0tphRK9xEAql+4rdFgkZgSSmtSBh8TMQskXykNmh6gr16xwFuDP7QCbaTGovoU62I2pyxLjo8PMVpx8eI+RzdvkvrnSxtDWRR03strtSKoluhlrGprCZ0neE8MsY+Y5FxZ9QvP3Gc1elQWOWO0xlmHsYbFXEAI6+9IeRPVRC8RWFlK1qJrPVoBVvWOUzHa2sYaAQPl3jGnGNBaUVcjjNU4ZymKkrIoaJuGrmlIUa63Wa6IIWK0piwKqqIghQg5UVcFCgEUXLp4kcl4zGJ6iveeplnhnGM0HG3qzHezvWYcSwjhtvPoLXO75iKrEQtaelnWD3pRlCjtUY0MnBgjTdPSdm2PWFofW1NVFcPhkK7rmC/nTOenzFcLilJjncanTEyJLmYaH2nbdhOi+/g8w9EJj+9eIWvFfLUgKiPIsG6Fz55qWKKtIhEFMWMsIXR0beClF17EaM3e9g5GqixonVAk2qahbcQhaA1VWeBjwAfP8cnRZiCl/L+x92e/luXZfSf2+U17OsOdY8jIiJwrs+YixXkWJVGS291tthoQoIYf2oYbhl/sJwN+sGH/AUY/+NWA3C82YFjdVkuyrG4NTYqiyKIosljFyqyqrMzIjPlOZ9zjb/LDb58TWVQ3yQfCFYnKBVxkROS9J07cu/dev7W+UwQi9WZNTeSiH8bJwxCdBxeQCadlQKKEpMgMWgnEGPgnxsWGECOri4j3lnbVJmylbhBSkq+XeCIeePrkMdZaZtOSfuh59uwx03rKdDodQeAXlm7/I11SyTGtJWGSYcQmQdD2PcYIophgXaDpLNGnU7VQJq2HZUAohRJJk+JCRCqBVAKtBcZIsjythpGAheuLK37jv/sXvP325/iJH/8qv/s7X+fq+prr60vKquLw4IjNdkvXdTy+/5ihaRPtWGnEpNwfhmIICAQiJDBbK4l3AaJA6MRujH5ASIERimlVMp1O2K6usW1ARkG0gWaTYuG1ENT9gPees5NT2ralrWtklnQyUqU11Juvv5EOmN4DiZ6/u0fffPN18ixPgHsIeO/58MMP2Ww25FmGHSyLi2uyzJDnGYfTOYezOa7vETFwdpammcXlFT//sz/L4eEhv/97/4bLy0s++ugjyixnUpaUWU6u/2QY54tVn5rGAjynFv+J2q3IdhS93Z95v3v4R/I836/CTFFQ+ILXXnudoizJsgylFdWkIsR0SvvyV77CZFrhvEe4QBSCunGE6Lj90st0Xcum3oxajpbrxYptMyCUIgrBZrul6QbkekvdNoQQOTw9BB/p6w4fHCE4unaLtQNd01Bm+bjv9kBECTlOXIm8kGUZZVHiXUBIRTcMdKslzntc8Mzmc2bzGVdXF7Rthxssk6rk1s2buN7i+4Gh64neo1FMqorjoyOmkwlGm0TdJDWz1LUDITi8G1iv1/RDAvWl1ignKauKoqq4ffMGJjOcnt5gvV4DjKQAS+faF/509aNaWpuR6JIoxc4nYaGP0LQdxghciGBd0mrJRDRRUowTwidSxPa33u5Pwn5yEQK0lpycHWIyjSlzMi24PH9K8AOZkcynFTHC00cPUVpTGMN8fsCQF2yWa5RWlGWJUQqtdBIYhoiIgeDTYS/4dPI3WqX3qJOuKniPkooiz8mzHJsNaCkJ3rNerciyjCwzZCYj6kie5WTGkBmTZAtSMamSNiszGqUUVVky9JZhsBwfHeOchRCptxs26zVVVVFVFcE7lBTcvXsPYqTeNpRFQVHkOJ+0NXps8Ktlzc2bJUeHB9y7+zIvvfQSd27dous6NpsNZ2dnnJ6e8vprr1LX9Q/lmvnz1qemsfyAZmUsP+pZ4o4uKRLwmE5fiT4YQjfuRDO0ydBak5UFIUZee+01pFJko4hJacVyvQIp+dKXv4yQYJ0b6ZaC3lmEjNy6dYfBDSyWCy6vruht4Hp5iRA1YsR7tvUW58FHQTdYpJRMD6b46FisFzhvcW7g/Nlj+r7jZHaIHk9iCZwMeyo1gNYaYwxlUYynRoXues6vrpNwLTjKsuDGjRtcX18xDAPBOoyac/vWbYa2o29a1ssVdhjQSKpqwvHRcbpptCbEXZNOK0NBIAaHcwObzZK27SiqCZqAd5I8O+Dk6JA3P/cWB4eHFHnJxeUl2+2ay8srrq6uaOsa6/5kXPtn9SKU0iath0VI668Qxgk8UncdJlP4kA4Xgh5hRm3LOOrvhh1Is64gdZt0PwakiDtGOlpLbt46oppUzGZzFosVF8+e4N1AZhSzaUW9rXn2+CHHJ2ecnJ6iD+bYwVLXNUprplVJpg1Ga7pG4qzDWU/wHh8ccdxTGylBSaJQKJ2mCyUlRV5Q5AV2GJLY2DmaZstsNsXoJLIUQlDkOcYYbpzdQEmFEpKTkxO01jx5co6U6VAmYouzjuPjY4iBoW3p6obHjx5y48YN8szsG93rr72KUoq2bqiqirIseffdd2nbZsR9YL1quHVDcnhwwMt37vDGG29w68YNjDGJ+TrKLJxzL/xh7VPTWNTIUPkk7Th6/7yxQGoAMe5pjzJCUZQorTFZhveephnGBiG5ceNsD+zrcSJ49vQZ26bmK1/9MUL0XFxdYDJFliuKMvHXL6/WDEPPut7y6PEFDx4+ou0GynLCZttSN11ilagMozOikOyAi2GwLK6W5EViekyqObkpmJQTMpWlNV3bYztLs+2wvUOhcIOjXjdstzV13dANA9Y7ptUUbQyzwwMmswlFVlCVU6KHl196iddfeZW/8df+KloqRIT/zz/8h3x8/z7tpk43W1Hsm1faNQvKPENpzWw+Q47YUtM0KCkIBIIf6BrL1WWgaTbkhWG1nNN3SaCZGcXR4Ywi1yxWRWKQfVYvXkmZpgqAmFbCPviEr9QdRabwgfGw4zA66aucj7hRjR9jsj3yYfzwLh3wgicGlw5JfrRa6ba887nX+F/8Z/8Z//Af/CP+wT/4hwRr6QfHR99/HyklN06PiHiWl+cM1uGcR8QAwdPVW9qQ6MZD0+OtJ46YoJAQRiLCrtlFASYzaCFp1jUbk/PSzduEsxu8//73kMBsMkULhe0HTk5PqKqKw4MDQOCcx+ikgVmt1ngffkCYffPWTaaTGdNJRV5k3Dw5QUpBjJ4iL8jznCdPn9K1bdLghJDsYJZLVssl8+mMTBuausbalsODHCmT1uXy4oIyz3l4/yNmsxmvvfYam82G9WaTNixS8sZbP/ZDu3T+rPrUNJYdZrJXCpMehM95YuPMHZ+vwXZ0xN3XuRHwi84hlWIySauutu9HQWASXXnnyLIM531iffjAYCEvMmKEtk00Se/B2kDXWUKAGAV13VLXLV3Xk+UKpUXaCYsklHLW0fd9uuCVwZhsfKArQDAMDjukETv4QPTppiGAGxxKKqqyIgqJsJbMR/Ki4PDwmCxPCub57IA8yzk9PuPmzVu89urrFFmyxfjD3/99NssV7aZOp7NPNBYp02SmVNpjSwFZZqiqkixLe/Skvo845/FuoKkTC8YWOW3bECJMqjKB/jFQdCa9+c/qxSsR92NHZDf9pxWXd368X9KDPIYkjJXB40LEu3SP7VwadvTj3X5MinR37qjrMYCzPVrCrbMT5tMSLdOEEWxgaBuyPGMyn9O1PW3XE6NExJiIOKODg7UW2w/YNmE+iUwASguCj8SRJyLGzYWIcRRGevq2Yz5Pmq3MGKLWzEbGmJSSs9MzZtMp09mUEAJt06G1RqnUWGL05Hkxii01RVEwm804mM+oyoKX7tyhKksO5tM9FXs2m9G2iXU2DJZaG4aup9E1xpjRnyz5nyWsM1nW2GGg7/rEVguB1WrNer1ivVozmU72B+wXtT41jWVXux/Y7gMxMr9E2vt665N1y9AjteLg4AAhRPKyEiIxPnRSFYeR574DmYdh4POf/wJRiNHuQnPz5kts6jXbeo3RifveNg5tMm7fPEOIgrI64smTZ1jr+OM/fo+r6wV/9Ed/zMnpDU7PblBNKpTWXF2mFZVEUuUlh7MjhqajtYF626PEwKAshck5nE4p8wmZKcikwagcITQ//ZM/yVd/7Mf46MFDnl1c8E/+6X+LUJKymJAXOXlZ8Nd/7ctkxvDuN/+YTBVMyhm5yTBa86t/+df43Jvv8H/5z/9znPW8cu/e3jct7dwDq7Wk61uuPr5mOpsxnU6J0SMl/OVf+RUikafPnrFYLlmtN7zyyl1eeukOeV6klYpz/NE3v8mzbz5mvVzSfTaxvJDlhp4QIt6Fvc2KVgqtFX0P3gX6vkfJgJJqtGNxNNsOokLJgtm0ZDap8MHS9y2IgDEZ02kFamAYWogJ+6hXK77+2/+K/+X//H9KZnJeuX2D6/Oe3gfefOUOUgqapscGRxw63nzrHcqy4t1330Nrzc0bNzh/esmzyw1ZJpFa4Wy6hzUJG/IBykmGNpqsKDg4POSNN9/k6uqK68U1s9mEqqp4/dXXOTw64stf+sJoaXSQjCbzfI/NLpYLgk+EnYuLK/qupyxLnPNsN1s2my3ff//7VGWJMYaHHz/g+PiId97+HA8fPODBgwecHJ/sX3O73fLgwQMO5nPu3LrDg/sPaOsWc3oTgWa56Dk6lFTFhIPZIacnZ8xenbFer/nt3/7XI4ssZ1JOMPlnjeUvpBKVUfw7H58USYUfEEWmw9Pzz3tOjdx9AHuPpE/SjdODNlEM8yynHzK0ynAJNEFKjZIaKQxFPmE+HegOLW3Xc3lxxWZbM6mmFHmBViqJqsRAnucj/VEz9AOr5QoCZKZI7sGRxNoSihCS47GSOtE7o8ANjq4baOoWokArk/6/lGMjVBAE3gWiguOjY6aTKU3TsR42DH3PwwcPOX92weHhIfODeXqg7NlAaf7z3qFU2isPw8DV9RV26AnRs14viUDbNolK2Xdcnp9DjOR5sbf/2IzGlMF7eMH3wT/SFdMJeaddMlrhlWYYNU1102CUR0uHkH4kdKSvaYYtSpYYPaGs5hRlvr+XkjNGEhbeuXPKrZtH3H3pkK6p+ej+R7zxxuu89updvv/+BW3d4oYBpeUek5ECYnAJ/BYCoxRFljGtKobDOfODKUWeMa2m6V6OnhgS73g2n2Iyg0eQFwXHx8cIxDjtTyiLgsPDIw4O5kync6qqIstyttstdV1TltU4kaeJLYSYtgcRMpMhhU9GrNpgtBm900hr7L7HuXS4tYOj67qRIRbG/+fSRKdG+6RxwxJHEWl6Dom9EDz4ML6exVtH13TkeU7TND/Uy+bPqk9NY1GjFbtSz/2sEsyc9CoIMcpNxtUXiU4phNzTkf9kU0qQ4zi27/58D0KOoqjMMCmnEAWL9TXWDkxmU5RSOAt5NuHkOGM6O6Gua/7Zv/gNlNZ88QtfSu9VSu7fv0/Xddx79RWUVJQmZ3F5zf31fV699woH8yNODg8Joyq3b3u6bgAUSqZVmfeRet3w/ne/z3pVU83myfRRGLQ2lFlFiBE7eD66/5Aiz/jKF7/MrKp48vgZH37/A+5/8AHf/tY3aestf+nHv8Lx8THXiwVFkfbBUitijLRty9HxMT/50z/Fv/yt3+IPfvf3EaTv++/87m+zU7wMw8BgLb/5m7+R/q1IlNaUkypZ8Q+WGAJKvNi+Rj+qJSFZIQ0WQkBLQZkXyBgZuiQSPH92gVYeozwHBxXGaIzO6LuWR4+e0dSetol86Uu3mc8PMSZNvV3XMMkMZVnwq3/5LW7dPOHnf/qn+NY3v8P/6f/wf+aVl1/hr//VX+G7791ns77i4ulT8jLn6PiITAkyJVhfX1PrDVoICmOo8ozi9hm3bpzy2muvcnZyyl/6sR9HSkld14nJlWWcnt3EZBlPL65YrVZ8/OABL916Cessfd8hleKtz72FUhrvLV030HVXfOtb36Kua770pS8hhGCz2SBGsfX11QLvA5NqOh5YJZPJlKqajs0gENzOYSKS5TnT2ZzBWrqhxw4OZ23SyUmJC2HvKj0MycOwLCVKCXyIdF1PXdfjWrCjKAouL664urrm6cU5Wiv+1t/5n/3wLp4/oz41jeWTE8uudjqWEFK3j5+QS4g/MZ2kxvLJVxT7PWz67Sc/N/HTlRJkOsMbT8g8jc4RQSBFoiGCJtMKrXKqSjKbHvCzP/OzLBZLPn74YKQcTnj5zh0QMNiB4AJGSeaTGWVekOksibSERAkwytD5lr7riT6S5haJiJIQ4PLimuVyy+27L6OzDCJkWc7x0TFidHl+9vQJm3XN9eWCpVjQ1TVXFxdcXVySmxwzUywWK/K8YDqdJet0KWmaFu8dk8mUtm34p//0n7LZbnn5zstcX18zWMtkOhkt1jVdly76pm2ByNe++mOEGDm/vGQYLP0oetthOJ/Vi1W50QnDIBCcw/Y99XZL33WIcXopigIlLFJYuq5P+ToOhsFTllXCCIVgsA4xrtS0kUwmE+7du8m9V2/y+mu3OZxPaJst82nOf/y3fo2vfu1L3H35Jf7qX/kF3nnnTYRUo2BTJfzGQTWdA5IHHz9iGCzOeapqwmQy4fbN2xweHjKdzhj6nuViyfHxMQfzku1mixCS+WxO8BGiQAqNVgInk9/YarEiL3KqqkyalS4Jf8uywvuQslryak9KEDIxt7bbGuc86/V6RxsgeIcQMJuUDIPl2bNz1pttwmjH51PfDXRdx3K1YrNpUPqSxXJFPwxJsS8k1ges8/SD5Rt/9E3uf/QRN85uEmOkbra0TUeIEedffMHxp+aO/2RT2U8se7Ax7kH8+CfWOp9sLDtq1k5p/z/YWMYvF6TGEownek+uCwgChR4f98mYTipFXpYopbhx4xbvf//7/Jvf/32Oj48wWvP6m69TFAXvvvtuMs7Lc+bT6UghjBAYLVwUShmCj3RtlxpmlEgUAkWMgqurBevNFpllTGczIoLM5BwcHGGyDKkVjx8+ZrPacnVxRd+1PPjoo+RL1PccHcwwWrFYLJlOp0wm0/33bblaM9iB+XzK02fP+I1/+Zu88eYbvP7GGzRtgwue6XRCluUURUldN2RNy7auQQi++KUv0vU92yax15LTcomSn00sL2JlWoH3yenLO2zX02xruq6lKDRGa8qyhCghQN/XeOcILq1rJ5MpeZ6jlMYOicDinMdkiqqacO/uXb721Xe4+/IZuZHcf/9dJpXh1/8nf4XT0xscn5zxq7/682y3DRFNPzhWq5rMlGRZSVFN8T7yzW/+MRcXV3z/+x9wenLCzZu3ODo4YjqZUlUT7OBYXC+ZTWZkOufi8grnA2+9cxM7eIhyJOcIpNSE4FktV1STiulkQt8NLBfrtNoyGd4HpNTkeclgB/yQLPFFiGy2DcMwsFyuxm2IxA49UsK0GhvL+UVaXzk/rgWTRU3TtiyXK4bBYq1jvVqTPMGSg4XzkcF5Buv4o29+CyUF77zzBbLMjPIDhRQS73c+bC9ufWoay465sdOxKKX2OhbYE8LSKkwAUqH0cwV+CP5PTCyfwGM+uQoTybra5Omhv1mtEEqQZxmvvfIKznu+/Z33Um7D2WkKtDKG9XaD845yUnAwn/Krv/zLDLbHOsv1xfk+p0UktViyg+kHZrM0MTx59BglJZOy2vPUgw9JjyPU6Oqawrfabc3Tx08oyiWL9ZrNesN6u02sM+85vzjHDQPX5xcIwPYdtu+x/cDVxVOIESE81WRCVuT0XU/btVwvFzRtw2K14Hpxncw1rU2WMsHRDz0fffQRr7zyCr/2a3+dR48f8/DRIy6vLtlstvzu7/4uh4eHfOHz76CV3jeXF51z/6Na9XpFjJEqzziaz7l14wa279luFcGnidn2jvmsZD474OT4kLIsmFQzJpM5t2/epW0DbeO4uLjm/Pwy6VtixNqBosg5OTnhwYOP2a6XfPT9d/HOooA333ybN978HJPJjOl0zuX1CuvS5P7g0SPOz6+YTOZjOmzGdDrj7OwWWhs264a3P/cFjo+OefzoKXVdU5QV603N+x98yGKxxDrPYt0wnc34yZ/8ab73/vd4//3v8/obrzKbTen7DmsHLi8uabp0iDs+PkVrzfXVNVmec3Z2hvRJ5nB0dEwMkfV6izYwnR9iRk1NCB4pU+Ce947rxQo1MsdiTPjM4Dy9cwzOsdnWbDdbyiqtoH0MuJHhVhQl84MDHjx8RL1tmMwOUyaL96NAM6Mo871p5Ytan7rGsqMbh9GRN8B+fRXHAWSXBZE+/wcxlX+nxPOV2O51dszl9NkhTSZCUlUVcU9/lAnIG9+Pd4mCbLIktLp39w6r9YrVesnV5RVt2+KtRSqZOP7P0ZxRkbtJFEaTj55mY8VIFHH8O5JJXsp32NL3A+2YfFl3HdYlj6V2tMRXJDtxLQXeWtxgsX1LDA5tUn6K3FGhQ6AbeuqmIcbAtt4mU0rv6boO51LTaup0YptMKooyx4xOriEEnj17SoyRu3fv7jGx3c/qs3rxaj6dkDqB5PjokJPjI+rtFqMVbbNBK7m/zquy4saNm8wPZhzMjpjPDrn78uusVx3LZcNm06b7bhRQeu+JEZSSbLc1i+WCzWaDswN4z3K1ZLVeo3SO0oau62malvV6w2q1ZrlaUdcDJsu5efMltMmYTGcj69OjlEGbjKbt6QeL0gbrPMOmph0B9KurBUIoqqrauwxMpzMODw/3hrNN02K9I8ZkCaWVTmu9MdJ8hyemr39uMSZGk1tjsv2hVUiFHyyb7ZYsy8lG7Zz3jrppaNqOYbDpfm1aiipp7PyYUgmgtEpmnIOjHrcBmTGEGDDWMRiHj+GzxvIXVdnoYrrz6VGjAWIIcZ8uGaVABdABohRInSy//51RZaxdQ9lx4dOfRQjpwp9Oprz1+usslisWiyWb5QohJZ//3NspcdJoHj15zOOnTzg8OqDMM4a2QRvFy3duMp8WzCc5m8UVm6Ghb7ZIoZDeM6kS7bFZrRisZbm4psgLZtUkqXWVQqlETIjB03UN5+fPsM6TFxnX11cJvM9MipEd4wPkmL8iBNTbNUoIyiJHI8i1QokcokmRssbQjzdRUU5wzrHdbjk/f4oxhjfeeIOua/nGN74xGhBGtFE8ffaUv/tf/N3EDvIp0yXLM9brDev1hu9973vJSzPCZMyj+KxevPrf/+/+tzRNy5PH55wc3+Tk+AaXF9c0dc3Fsye0bc1qfUleCLJMcvPmLU5PTshMiZSaq6sFTeNoWpvwiaJkUs1QKmlcrq6ueP/97yNE5ODwEPXqqyl7KMtQKuPJ+QW//fXfZ7PZ4pzierHmvfc+4Mtf+TG+/OWv8d6732NxsWAyPyPPC26//Aqr5ZrVcs17znonTAABAABJREFU73/I5Mk5Z8dnyKykGVxifgnJneMbKKVYrTasN1v+0T/8x1STinv3XmU6mSNQPHmSJp3tdp22DnnGw4ePEkA/naJ1Rt+lw6K1jvWmwTrPZlPT9z3rTU1VllRlSd1sCcFzvVrStQ2PH32cEiuV4er6grZtqbcJh9RK0jYtbduRFTkRQZ63dH1qjghFiIKyKnBuwFqP1obZbEbTdCxXa3wMZNlndOO/sPokxpJWXsncTgix9wkT+6nludsqI57ySQGY+Hde9xMYDiS/IQHD0BODR+tx+pHJZVVIAaND6aSq0FohBBijUrpbDCgFeaaZTkucm6ZddkiBEjEkt2KiH0VgAEm5TAzjSm7nuhzHU0+9jwOIMbk0G5mDFAQRf+Bzkxp5JCJ4R5AKJcR40pFE0ikpnf4UJsvxPgnQpExJgts67du7rkOZ52tF5yyXl5ckWiSAHBt/mlycTY5jETGK6F7sffCPap2dnrBabbi6WBCco9luko+cVBwdHTGbVsxnOT50hNjjXdJ3SGFwbmC7WTAMgmFg/DnvXHfTgePy8ooPvv8B9165QZ5rVutkxnhyfEJE4aNgs625Xqw4ODhDapOktCLlwegsJysiUhlMVjCdHdC2FmRNbx20PUXT4pylt54YkjjT5CU6JpZ7GNMlnUvZKYvFAqUkbdvRdV3CCb0nj3EvoG7bjr4fqOskTvQhsNluGZxDCs1gk82MlGma67oe7x1FWdAPA22XbKSUTBKErk/JrhDxSjI4hx81eDtpQyRhMYkskBwF4o5xlAAiGLcvIcZ9qOGLWp+axvID1i1j7UD5ZJf/iRXW+NCXYzDRros8//L/gdcSAkRESsHxwZwYAk8efUyWFylxThsQkt75ferQ6ckJRydHXF6d0w898/l0TJdcE70jzyT3Xr7NjdMjlsvleBq8wNuW1g9keUWeKYpco6TA2i55M8ndSk8QnWcYOq6uLpjN5hzMD9EKEIKyysfJLeExPnrquiaEwOnhUfJE6jukSkaDmUnOr3Xf0VtH23bM54nLb52n6y0Hh0dsthvefe898jyjKAuKmKOMIR8dCTaLa6xNAOWdOy9TVZPx+ysQE8l2NOes6/qzxvKCVpXn1GxYL665eHKB7T1FPiHPC+69cofJpODwYMqz8wc8ffaA1XJJXW85Ob7BZlPznfc+QKsJWk+oqikxCtqmQ8jIMFjee/c9vv3uH/B3/pNf59atU/7wm9/i9OSYdz7/BaRKp/N2cGyaji98+VUOti3LzUBeTdk0PbOjEyYHgnJ6wGQy4+zmS9StRyw22CDwvWXz8cNRLO0ZeosdLE03JNuTMeL7+PiEzXbL06fPePDgATFG8tzQdi3nl1fkeZ5U9AdTlM549uyCbV1zcXWJMQZjDM+eXWCd44033iKEwHK5QkpFWVbUTZvcvQ+mWO9p+iGxOcXoZKENOvc452iHYXQFgSwvKMoKlRmQYk/R762ltw7rPDLTCKOxISKVTlOOGM1BX+D61DQWP1L3lFJ7M7YfYIKxox+PE8k4nfzJ2jeovSjpBx96YrS4EJ8wYiR4CJ7gBYhkFJl0M3Kf/jaZlGgtqDcrfEwuyEWRUeQVXbulax3bzRJnHfP5ZLwJHEIEpEzkAKUU2igIkaQKSZNNHBU7KZTOM9gOrRUySppmu1/LCSlHO5bUS7WRRB/ovcUGT/SOGM24Mkuf1PfphLXbiwshmEwmhDjmUkiRUv5GdwOvNbvUzaIUgBztJjYcH58SYqRp2pRAKVMu+mcYy4tZH92/z2azJYRxSibS9x3OOa6vrgh+xsnRPFknhUDfpRC8cBBQQjGbzQneEONzLC1hFQmPrNt2pKT3DIPj4OCQLC+5uLqmaXvquqUoK27feRmd5egc5ofHIDSrTU2M6Zpbrja0ncN6SW89k/nh/hkgtcL2PYvlMokWleH8akkMnlybMYtFYe0w4hsN1g5s6y3WWbq+4/p6gXWWm7duUJYl3qeJq2lajHFk2ejmMYocd+mWIaQGGkK6Q/2o0t9NIBGYzecIkXQ2TdOwresUP0B6liSadaIbR8BkGVU1IcsL+n4YozU823qRPNt8oO270bb/xa1PTWMJPj2c9k3lE83hB0woIf35/kcLzxdfca99+URX+kEMZlyTCZFGeklAxPGhzNhy4rhqEzLlT5iU96AkXFw8IsZAXmrKYsLRwYyLc0kMlu16gZKKk5MzNqsttuuRBKSQFHmWLP2NRobU0lLIlhv/CWMsaXQMQ4cpSpQUbNYJ9ylEinRVyiRsRgi0lnhSuFiMEKJIKzqtMUWOQCQBV9eBYM9u2TWWoij2EcO72NYdvlUUBcbkaJPxve+9T9O0TOeHeO9ZLJcURUlRVMl99gU/Xf2o1kf37ycjyXF9JQT0fQcRri4FUsQ9uSSGwDA+VKMPKKWZzw/oukjfxU+QNCJKaapqQtMv0mqo7eiHNAlrrbhaLHn27IJn55fcvfc6Z/NDlMkxGRwcHuGDZFO3FEVS1W/rLUp2bFtHUZRMZgfUdZOMZo3AdT3XqzWz6ZzppODy6ilt01DlGVoriizpzoQQNHVD0zV8/OABkUhZ5iwWC5bLJc45Dg4PODg4Ivi0EkvAetKOpEaSHvZKG0KEfrD4sbE475Nf2UjKiQims/nePT1CIgawW+PL5x/jykubjLJKlH5t0jPBWsv19YKdpPvy+uqFT2X91DQWGUFFUONpQCJBpJzu/SpMyjF9mzHsKyUdptlj9/GcjxV24sOk2U8Ky5Eu2fUpi3o6m6dTfdtSVBVCKvq2RRlDUWRYO9C3lqLMyaeS5aTCOYsQAde2rIPlyYOPOD9/hmu3HJ2e8ZNf+yLfee+7fGdxQRwEUWfkusBkGdPpHJ87gvcImaYIQmLbTOczurZjvd0wGx2b5/M5IQas99h+wNlkUS+lZLPZIIUYRW4CLQTepwfAME4ht2+/tG8q0+kc7wM3bt0mPpOs11sOD+fcvHmTtuvwwY+AvaVtW7Ks2Issi6Jku90SIxiTpw9t0mRmP7PNfxHr8eOnSKnIshKjcwpjMDo5Ci+XS2IMPHr0hKurJdt1z+HREZPJhFs375LlJZ97u+Lhw3MePXzGZttgncNkOVIput4hZcGkOuLjj8+pm4Eim/HSS7f5hV/4RX7nd36Xi4vf4+jojMPDEzabDi0N915+hTsv3+P2S/e4ulyyXK75V//qdwFJVU64vjhPp/+2xVpHP2Ili+Vi7ygcQmqWXbOmLAuqmzfo+56+69GZolAFMpP0fc/VqqGoSu6dHCUfwKFnriWqyJjO56P2RXF244wING2DMRmz+Zx+aGnb7YiFRq7On+CdJZNhNLONdPUGN2i2mzVNvcE7S5EXlGVBCKMXm5DYwSacMwbqtsXkyffv0ZNHCQt1djzYRryMYF5sbdinprFoRBIR+l0UaaL8itEPLApB2HmDqecU4t3cEuPz5iL3A8tzmvFOtr/7uuBdYlopTcSOOd+jxfgOFQSi93hrUVWedq4mYyBiXUe73bJdW7p6Sxh6pkXB8cGMO7du8OzhQ4wISDwyOpACLSVGa2SEsKNQ7948IoH2jLGxPqBiTCuqEIgj8IiPe8JCMhCU5Fqzm9a8d2mCiIGhH+gHix16+r4bV1wV0+mM5WqZGkIUGJPRdj0789oQAsNgAYUQEmNMsqawFpCjI6xKY/5n9cJW2/ZonWF0OpQl+qxM1u21GM0WG9p2wLmIlBnGFAhh0DpnOpmTZ2ukTFZAfnSQAIHzEdBoXbKte5SuuXl6iFYFs+khs9kR89kRZTElMzluqBFCMqlKTo9PuHfnZfACP3j6rk0iw2bCZrVgsVjQ26TEb5sGO1j6rsHZga5LU78QAtu3CBVxIcWDD35AyyJtGowCJ3C9R2eayWzKYHsC4IInENFZeh0pZVoLI5LLMQGtJc4N9EOXwr8EODcQg0NGl8g1MeCGluAVzg4pptsnanLS46VJ0DtH8Cl/KUbwwaN00uFt6s0YPphA+0AkKtj5k72o9alpLPO8wllHvdqSlyV5WaDweCIBhXWebdeSVyVZWWBDIIr0gA4xMvg0q0QhkgYmCkwu93x0Zx3WObJJhVaaIDQ+BhbrFgBpCqRIo+nh/CCJwOoWCGRCEPueKOFkOmezWfHw6WP++I+/yXvvfZuf/Zmf4Ce+8AU+99YbHB8d8sq9u2yePuD8owlDkHgkFokIgb5ucNYTfVqRaW3oBkdvPau6Sbz82QHWg20GpArpFBPi3vHZB0uMAe+GkYGWmGh8Yo3oXGS12bBpWxZXVyyur/j1/+jXeeutNzk9PmWzWiOjZHG1ZL3aoLROKZvVjgmhsEP6O4qyTDTKvkZrxWw2G2neEpNnCc/5rF64qspTQDAMAmc9veg4OjqmLAvu3nsN7xyr9RprNUodsl5F6m3N0yd/nJiEecFqvWW93pIXJaAYeocPim6QREqkMsQwx/YFTx5tWS0+4Nnjv8dbb73Ff/K3/1M++OBDFlcLVs8WqUHNPJfFIzInePjwEefnFzz+/ndo25b7QjJYi3WWg4MDTJaRq0BeCeazKXW9ZbtdsdkMRCJ5keG6muHxdqT3T+hiiw+eyVFFPsuY2ClCSjoGZsdzlFI8vTrHeYfHMSkqqrIcGZZwYmYoKcnyuBdk+35LjJFbJwcMXcvTx9dopci0pls3BGA6nROMJA4er3uckhghKXQ24rogosRoQ5UX5EVGbw2611jvGLzDkcg5aqJQ8jO68V9IqZhWV2KXiRoC3oW02jLqOYoSd/nvAUIS/o2uKeMac1x78Rzo/6STaPBJkLj7vJ0g8nm+Q1ozBdLxXY6vqca9aqZTsJDvB4yUzKqKg+mUg9mM48MDJmWJ7VqKzHB2cowwJUhD0Ie0vefiepOmok+KC/dTQo/SGZk24/pvZL2Rkvp2FGwhUg5GihgOY2Rr0rrspp88N8QQ+fCDDxj6LqVKak1RlDg3BiyJpBMKQ9K6yADOej7B4QbY+7J5l3LArbUIkUSgKbfmxQYaf1RL7ZXh6X4JMeCcxTk90ucFJsvGrJWUS2Sd3Z+uzeDo2gT2ZzGQIo7ZbwFilMQg6TqHiD1KWLKsYDY7pCqmGJ3jBk/XDjjrkSLStwNusKOFUoooxqcYDO/DeD+HpOBXEjVGYEgl0FphjMJHSYgBbdJhSIhkSKu1ZvBuf7jahQIGHyAk/FGSPPvSoiDhqyI4RACISG8RQRB6B/0AQ0/sWyIB20hs1+K6Fqk10muG3hKAsqgQMVLkGqMUO7m2ICKlQo6oTAzpfk2pmClyHCmoympsLAGhf9Az8UWsT01jIURkhNyYFHo1rnE8kUJrBCmXJUYYrGXw6QfS22FkXZB+gEoRE1l+zzTbWYd757D9ACGS51n6yY9AuByV+JE4gtFhtPhOTKxMK6QUGCKNVPRtx8u3XuLurVu8evcOR0dzpmVF9J4HH31EYTRf/PzbnN58mWIyp5je4uMHT/kH//ifoZVCGUMMHmsHRJR459hua4oyorShLKv07w1/gka9Q5JihOiAsAdV4xi4pZTi9OiM5WLJN77xDW7fvs2dO3c4OjxiOp2yXCzZbDaj++vIxhupm12X1Ppp/bWz608j/ND1wDCu2tJtY50l/PfR8z6rH3qpHU0dv592N9sVg+0oy5Isyzg5OWY7WpCsNluGkS4rpcTHiPMJT0R4EAGhQWqByTTDEPA+cn25QilBVWpu3XqZX/nlv0bXtlxdrlleb9gsa9zgIXq8rQk2UJiM2zduUBhDbjQNKZJXihSc5+wAAubFPK2JgCLP0VqRDz0+BorRv88YQ1VWFHlBaBt8BNdbhmHYg+BCCGyWofKceZHjLNR9g+pa8DYxQ2Mg2h5Pyrdw/UAYBgg2pc0uUyZTs20RSiG0oh0sQUhyU0CA4+MpMaSmK2IgxoBWEiUFBI8bLF3b0bYNbVvTdA3VpOLO3Tt4GXAErH/xbZI+NY3lD/7wDxIIH2P6oSmJDQGhFKcv3cLkOboqktpep/HROc9mvU4iJKlSPorWRAkgEDGtxFRaeiJGqqQU4KzdCw53Z4vx2koXWIyk8CtJjAIICBHp+waE4OW7d3n44CMePX7CyekR5WRC0/b44Nm2PZPZAWe3b6NMmSKMjcZogRSeGD3BBWbTiqPDOZt1g4gB27fkeYZWguAGXPBjXsvONmA3i43CUVKOC0oSYyAJI9OE0dQ1w9BTFgVHR4fcvnWLPNs5LYvxBlajJUWaOKR6PhmmCSpFESfxF3Rdl06GPmXD7Fhun7WVF7M2q3NCjPtGoZSiazvsoFmY575V/bClH2p8aIkkk0khA0JahLQgBtKjZCBGmyYdnWKCg0oakxjB2oh1Hh8FUmVkOQhpiEJhshIpFUVRgtTU7UCeZ0nsaHKUzhEWhEpU+YhKMKdQBKC3dtxMKEJQxCDRokQLjYkGHQtUyJB2QAweOQjUINBW7PNfKi/IXSTYHtG2iOUKZTQ600zLjEwrJtMKrSVlnpyhRUzuF9oYZienoDRBapTJUMZgY3Jsnh+d4gPUbceH9z/mo48eotSoi2tb+q7FO8dkUnL7pZuIHDbNltnyCp1pZvMJQUS8iKMY/Id77fxZ9alpLN/4oz9KDzytkNoglCJKickMZJrZwZyTWYVSKVkuthFnHW3XIZQiKwqM0oj8uXZFxKRXUTulvgalBEqSJgWRvI52nPOwB+zdc+2MDCOP3wMpGElKwcsv3+XRo4c8fvqU1954jflgqdvEP9+2Pae3bnHvlbtsti3OBaRRaCVQIhnSheCZViWH8zld3SKix/Y9IniMEjg34KNAFQUpWWNcSX3CgUCSAMJxETg2F0EM0DQ1dvT8Ojk+5vbtW3sX1Z0XmpISInt9y459t1vRWWuxzu2NQftuZMsFv3c9+MzO5cWt9fI8/SyJ5HlOnucMfVpnijgkk9Jc0PU13bDFBwcCtMnH68yCtEQGEKmxgEUIRaYh+pRO2XtLDBHrUjy4DwKhDFmuEMogpMHkYkyenKXG0nTkRYU2JVrnKJ0hVNiD2j4EQpAg0jpvcH3aTCAJPpEJNAUGg4kaHXKUN0inkYNF9ALpBMYJlAAtofSCwguGtifUDWK1QmUak2ccZHOmmeTGtKIsDPNpSW4UmVYU80PyyYRbn/s82WRGfnCIyQt0ViBNhlSGyfyAEKDpLb/xm7/Fb/7Lf8XV9ZKmadluNvuV4mRScfv2TfJpTtO3TK9nBAIqlwQRCRKyotjfcy9qfWru+qIqR+ZJGGmvgabvkoHiB5LD4yOiUSAVQcC33n2X9XbDrTt3KMuSyWyOP05pdLuwMBfBKI0WSdhFAG9j8hwbP88YnYwclSKOk4p1aXKKMexzYqRMi7K8KFFKUlQ5P/6TP8Nb73ye+/e/z/sffowj6QQePPiIcjbntTc+R+8ahsExUUmgpkXE+p5+cDx5/BFKRmJQKAlHB1PmsynTqmK5XuOdJ4Ys3U8i5YOLsGOF7ciJu9zxkCwvRoVMVeS89so9fuonf4qjoyMODw+pJhXBp4Q7Zy31tkYbzXw2QwqBd24fYyylREkFCvToW1QUBVKlkLXgHME5nNrhQJ/Vi1b3338vxfAOPUVRUJQlg7PEGMnykoODQ9rureTM7R2TyQypFOvNVdocSEHfDfS9TU1CjI4UIUCwiGAR0VIYjRDJNqiqphwfn/HxRx/z0f37mKzk7iuv8bm33ma5WPD1r/8ew+Cp657pwTE6KzH5hKwYiGR7EklgZ/sywYeAdozPhpgEnwGETxN7eiAnfCL0ESwYEpMLI9EiHS5zoTFIYlTpHm8S9uOsQ0wrlMnJhaRAUQpNITW51syqCTovefrwCdl0w3GUZIUjLzyTuUFriRKKrMiYHR5T5AVD19E2NX3XM51W9GN8d9u2LBbXXK+u6N3A8dGcIAK974lCECVkufmssfxFVVK6JofdEMHHwGAHXAisVkuk0UkVjMMTOX/2jOvlgsl8Sgg+uZ8OydMn2eonoZcnEoNhD6UFTxhdgSUxNRiRTjU7EsBOmb+XXwoxWsfEhDkoiZCa2fyAajLlg/sfsmlalqstgx1oB8dgAzbA4AL94NCqxzuL0RI/0iXd0NM1NXk+RQr2u9j9JByTgE3u38f460+MyWIkJySuQUQkWwIEMJ/N+PKXv0SR55gso+vSRBWDIHjPYIeUHW4ynHfE4JEygaVqnEj2nm3jRCOFJIa4b8JKaPa0l8/qhartOokC27alL0v6rmCwlhADUmd4b7mxuZHQuRjJixyFpq43hBiRSjH0A8PgiHGMpdjz+9NKlxDQWYZSGjnG+RZlhfOB1XrD4fyA6XTK2dlNYtwp0BNmEmK6uoXUSGXQJum5pFb7SG4hNEKElGM0/p1CqPSeXcRLDwSskMgocNbhbYoYFyERb8ToOhB8JIiw17ZFD1FGvI/72OOUpKr2/00BYgYpNX03EPWQYox9IgXsMCFBwrSKvEBJmWKPvU9+fyrhlVIKQkyeZsPQ47xFm9REexfYua9rJdH6xT6sfWoaS4hgfaDueoRSe3vuKGCz2TCZzRLN1SRRpHU96/UKb21aXTmLipFciaRuFxLrBxSMJpBJaUz04CFED15gfY8dGWI71b8NI8tJqr2XkNY6NRSl8MGz2rR88MH3+fDDD5gdTJkf3eT9B084PT3l1/69X6eoCj56esXyapF2rNuPaeqas+NDTs/OOD27wdHxGXlRYfIKowWLqyvsMGD7jqKcUpRlwkXEaFAHiV2y90YbzeyCIkg/Ti3pgr46P+fOzZvcOD5Gjaaa0TuGGBmcxduBoWsoigylBFfXS/qhpywnaGPIi+I5a23sZs5Zdk+X3boxL5Lq+LN68UrZFGAnnUcMligkwduUD2IdQ1cS/EDX97R9z3K9wofA9dUCISRFUYyvJFDyXoqRIJ3AwuBxrWVoe6bVnCwvsUGgdUael1STGdPZISYv8VHyrW9/BwF85Ss/xsnJKcdHJ1xdXXN5cUk/BJyXIHNciMQ+UlZpeknwniTPZsQ44NxAnimiTwfOND15jErBZU3T4uxA37d789cYPDEENtuG3GhunBxBPiWUc7xW+Mxgs0N6M2GrZlhhcDEnc5pcGIZekyvDwckNJrMZZ8cpGlmbjNlkhs5y7ODxYcDKFtf1ROso8wwpBcvViratmUwzysqQF5rSZsghsl5e0w8dy/UCOeI9d16+Q1FkP7Tr5s9Tn57GQkwTw0gJRIgE5BGxMWk5tNboLOEvRhu0VqjxgRtDOs0kCuG4Joohgdujm/B+ZbNjicWQXjvuJvwxFyWOzqRaE0IBIy0TkfALKTXlJMNHWG22lLMpUiii0FgfuV5t8IsVPjiMTNNQkWeJZaXSqW1b10xmB2iTo0fGTowBIZ4LEJXSnxCC7gD8HZExpoYzWjmLnSRUJEaL0TtKKaPWRewZckZr8jyjGvUp3nu0UoSxgSqlkELgdu8rRIRkv2JU6jnoP/RDojt/Vi9cGaGQEqLJ0cqghUrzfogM3hGsh5iYj1ppfAQRkxJ9lwWfqOZy9LCQZEajpSK6mBwjoiTXBVVRIfKC2XSWBIrj1yulkULRNA1GaabTKcGHfbxwUVbcvn2Hg4OWQKI8OxeYTCdooxmsTysxY+j6IflrkQTAoWuI3oP36dmgNF3XJjq9HZKfnpJ4nzKOcq0xWnFyeEDXNqASNdhoxeHxIVVZkE0naC2JRuGEJApJEzTRKyY6R+oUFx58xIv0vRQRlEhzUPQBOf69crRtCiFNLj5EnLVY23Pjxhk60wQCg+1Zb4+SMYgS3H7pNpOq+iFfPX96fYoaC3ginlEdL9PDXHjP0Hfp98aQFyUmz5jNZsynMzKTjaOnxdkBZ5O+REpJ8AMeRQwaITVKJHOXSGTbbHEu5VRb68ZUx3HKlyJluecFk8mUSQhkRYEkNY5yUnL75Tt874MPqXtHaz0YwWR+RN0P/LPf+G022w11W/OTX/sqd27f4s3Pv0lVFhRZxu/+ztf5+td/j5/4qZ/hxk1JQGNH3v5kUnF0dDKuCXYfQExuBGG/BxNAWgns+wxir/A/PT5kPp3g7ZBEpGOiZQiB+XzO8dERL92+Rdf39F2XpsFRTb+bRrz3WGtTs5Gaqqr2IH9d17Rtstx/0Tn3P6o10SUAIUu44njGAm+pmw7XOWSQFKaiyCU+BFwICNLq2Jh0ahZCoDGIIJhXFQKB7yPSKzJRcjg55PDoiLOX7/Dq3VfGw1y6LLMsQ0nF8npBnhccHR7z5PEzLi8u+dqP/zgvv3yXX/3LfzXpoYj0vWXoHZPpFKUVddsjpaQsy1E86ch1cgo3Mh0ig3OpsWj9A4mmO9p8ylyx4yFUIIm0TcOzJ09HnQlkRqdgQe/SCt0NOOvonSV4Te80J7oiioy27kfGnKQspmhhyKsyOVGESKY0VVFQN1uicwiRJv+mHlhvtiyWV/zir/48r772CllmCMHT9i1d39L1HfODKVn22cTyF1K9tSnrWciUR+DTmkcIgUoe8sl5VCW3sIP5jKE/ITcaSWQYerq2oa7TD1NKSdd2CUsJgcyYsQmN6ijS2sgOKfVtsBbEGBomFTJGorTJXiWEvUGlC5HeerZ1SzGZcufeK2zqLeum4+jkGC8C225g21uazjE7OuXkxm02TYsQkuPjY7KiRJuMoppQTCbJxiVEehvwUSCUJtgk/EzvdzexiJH6PGIa42S205TEKJPppVScnR1zdHQIwSefMeuo6xRvnGUZWWZ4++23kzByZNVJKVMw2DiVdH1P1/dUVQrzkjIhT94Hlsslq9Vy1Nh8hrG8iKVihg+eoeuwwWODQ2cZmSzItSdTJZksmM4PmMxnVJP0MO8Gyy6HJ5VgNknpjl/6/NeSXuPoBCUUWiruvXKP2cGc8nDK0fwQmdSWROfIlEJrw9D32GHgHEnfD2TGsFlt8NbvV9UhRCQpzCuJfuPeTWLokoAyeI8LEKTAi7AnrhgSSG9Dwm6kSIC6lAYvBV5J4ijsVEJCocgOXBJdao1SCSdxzo2q6oB3Hu8cRQa5lgSZMdgUX2xHy5m67siL9D0USoHSrBerhH365IqRZxnZuC5WMq3qizwjzwxNUzMMHevtmsxoSqPZLldJAvCVH8518+epT01jGUYvLDE2luBHhtL4kIPkjSWkIBKYz6bE4Ml0oiP2Q0/XtTT1FrxDCknXtPvGEooCivAclCYQo8fann5II7bSJgGGKkuNxLlPNBZBFDJ5JFnHtmnJywkv3b3Hv/3GH7Jer5mfnOFRaYoZPJ2LzI9POb5xi/XTlDpXjHY1Js8pqoqirGhai/OR3sZE1ZQqTW+jEDFNBEmkuKcV7EDUXX1iwjFSc3bjjKPDQ6J3SZTVdbTNFueSsExrzVtvvcVkOmM6m2HyHCFSMBNCkGVZ+r4MlslkMqZ4sjfWu7y85Orq6gfdpz+rF6oUBu8ifeNoh55u6Dm5UZGZnMJAaSoyWXI0P+HG7VvcvHWbsirxAXyIWOv2DhVDO9A2HV9652sEH8hMTpWXlHnJnZdfoppWeBM4mB2QXiCtqLKRcWn7PuE6bU+el+R5Sb3Z0LfdPsALn5qMEoJgXRLL+0SiGazfe9lZFUDA6KxFFBGDxIyr6BS/IdBIhFA4AU4kqn5KojWETGMOJHmWk2f5zmQCORqqKqVGpw5PLj1GeLxo6O1At61pmjSxX10vMSbj8Pgo+fopzXq1SpuRcfVcZIZspOXLkYmaZwajFc12S91sWSwvOTk+Zj454vLZU7bb7Q/jkvlz16emsWhj0sUiREo17NvkixUDvbNEIXj33XeROgmolsslEXjjjTcQQrBar5nPZkyKIqUdIrCyG5Mb91QWxJjEONikym3bln4M4DGAUgYpQxJLxh7ZtAihyaqaIoApCrQxBBTruuXJsyuiNMis5L3vfYA2msn8iNfe+jw3bt6kmh2xbjpkVlD3jm98+7tMD0/5a3/zf8z51YLr9z/k7PQWLgqCFPQ+TTzaFGRZYsswmlUmG4rE4Nmf5oC9Ep+UUaO04dbNW5wenyAllEVGkec471lvNvyr3/qXICQHR0fcvXePoiz5Z//8X/DoyZO0+jKG6WzOMGZc7NI53ahpqaqSsiypqorXX3+d2Wz2w7loPqs/tU7nZzRtTbvpMGXGwfSAX/rFX+Hm7dvY6DF5zvzkOAkA0dimJ7qAdQHvkxFpkZfkRcHi4pp62zDJS7zz2N4hNCgU7TaJ/2Lmabdrzp8+ZL1e0a7XPPzQYrThpbNT5NikhEji2i9+6fNUkwm/93t/sG88SibbFueTZVOe5/gQkqGmSBRkH8ekWGWIYnQ+VzlCZxAGYkhTDV6ivRqlAxERFTGyFzJ7B0FBDALrBnzwdE2bMFWt942ljz0qWFq3wohAZQRCaMpimijQg6dZ12PSq6DMMl65e4/DkyO2bcO3vvttBptExnlumM4mPHr8kLrZpFTP4JHRc3p4wOuvvMK/+Cf/hPfee4//1X/6f/xhXj5/an1qGgs7D6Jx1eW9Z3Bu73HUdx3n5xcUVU5e5IQQ0Pr53t9aS57le+AZdtG/YtR6PA/+SjtPPyqGR/+ekHIZhHiOYuxWcv2QcrG1c5iiJCBouz7tg53HZAV5FKwvLsgQHOYlx6c3eOXVN5DS0w2OSmpccCzXW06OTzk+PuXhsysWqzVVdYTzgWo6xRQlQhtMXqK0Qam0a3U+7rUqQo5eaD65A7hRmxDHZoNUTCdTyrIcv60iudvKFGL2+NEj5GgrU9cNTZPyKz788D4u+KQynh+M2JPd24H0fY8xhsPDQ05Ojjk5OcFozXQy+f//9fJZ/Zl1OD8kNxlDPyC1QucZ916+x52X7+BlcmwQRiXrlhgTtjAkoNu5wND1GKmJOsMPFj9YtFQICQGPEjIB+d7jLQgV09q167Fdl0xXmxpvDCdHh2PsddpKCKE4PJgxnc5Q7LQxaY1rlCSOKYxaJv2WjCn5VUkg7CL6dJqolEEITYyKiCKOoHmMkuBHkkF60+lg5hJLTISA8PG5e7i3hHFiSVsTT3AeQk8Ilmg7ggRNwniUVHvCj+0tUSZLMikk02qCMBKdjc7jyWcq+Q6qhFEKIsFZJBGt0r+1zDKCcwxt+0O7bv489alpLOt6u28udhiw3rFtGiJw997L9IPl3Xe/yy/84s/x87/4sywWi5Q5ohRSSk5OTvZsL2ftHjgUI3BtnUUMyZwxiSFTWuXBwQFt26G7nqa3WD8wraZpLaY0EUHT9bgQCVHQ9APrbc0HH32EyQtu332Fs5huqLPr6/3qLK/mFNM568UVwfXkBwVZVlJOFH2QPLlcs+kimy7ye994l23d8tf+vV+nKCvKsiKiQUiKvMJ5T1M3eybWyekJRZ7jraeutzx6/CDx952lXl9hPRweHjKfz5EIttstm7phu63ZrFY8fvyY6WzOO1+c8/TpM+7ff0DbdFTVhH7o8SGyXK73gGiWGyCmDPAsoyxL7GC5vrzEDsMnzcw+qxeofv7nfgZjDNODGSZLtPlmaHHBU+QGhCAIUJlBGo0PidiSGU0fBtquxcaIdJ6z+QFH5ZT79++jhOTG8SFlMaEsKorSYDJJPlMcnhzy1ttv8uH9+9y//2HShwAqOrq64/zigulkzmx2wOrygqFp0HgKLdAi6Te0lsgo8T4gbIeKkWm2w3sieZYThKKJGULnFJMZbdux3bSJki8lk7IkOEu92DCfTphNplxfXGCHnvmkJBJpu5YiWjLfYrwlBs8kDEghMCHFhduhB5JWRmlFCJ71ZpuaqkiheUqpfZieNoZgfXqGOYtzLomwtQYBg+2p6w3O9ggKDuczvLVslgsuHj0l85G//R/+On/n1//WD+mq+fPVp6axnJyeAIwAWwpda9oehODO3TusVisuLq9HN1OxN9HbZdlrnQSWYaQeCkSK+ozJxXQYEqMkeXZpBuuSvb5SyeEVgYsCH+JI802YRsqn7rheLGl7i8hy2q7HukA1zzk4PMLGtI9ebWts17JtWgbriEi0yUBJinJKpiVmPLVZ5wlC4ZFJUOkhryaYrESZYi8eiyKt/qrJLDWW4DGmQCpN8CmvpawmKbeGiJEBo6Cua566gacP7pMXBVle0NQNfT9w+/ZtsqLEWjdOJX7vLItQRJKIKxklC7RJGp5sNAKFlCkx2HEt9xkr7IWsjx/cJy9yTvoTZvOEpbVtnWzlTYqbaPsOMeqzEoEmuV/0w8BquR4TSzUxJOv9x48ek5scfYtR4LvF+R5tJJ/70htkWlLmhtwojBRYn7DTvnPYwaKFwCiJUZK2qZPbAwEpAiJ4ohf4GBOb0Sf/OxhZ9aOA0EeBR+HHAKZeGfzQE70bsRUxzi0RGQN4R7QDKnoMAR2Seas0EimSzkfF0dxVJDGl8oEQdt5opJAnkdiiqiyx/UDbDzRNS/Cerk3fx7zI6b2l8wPRpEkpxaxHlGLPEPPO45xn6HvwHqM1q8WCbr3ma1/5CidHxz+8C+fPUZ+axvKXfuInRg1J5Oj4kKOjw+TvJSXT2Yz7H3/ExfUVSkuur69TXoMxbOotQgjyPE/8deGYT2copbi6utobLLZtnajFw0CWZQx9h1KSsioSiF5JZNbhfEBnOT5EusFxvVyzWK25uF6hTIYuJ5iiYHZ0xNHJDW7fuUM3WJq25f7DR6y3LR8/fMStO3exHmYHx+SZ4vToAC0FBEfbDcSuB10QRMYQFUOQDF6CF0nA6VNDbPuWPM85PjrZ27cMfU/d9LRNAviOT86YTiqmk5LN9Smub/jwww+5ePqY3/vt3+Bnf+4X+Omf+TkWqzU+Rv76r/0N6rblO+9/n6woKSYVg3M0bU+WF4QYxubpMc5TFCWZydHlBBhvDB+xjBae8sVWCf+o1n/x//i7lEXBjdMzXn31Ve698gpFmZEXOXfzu3RDz8NHj3AhkVS2dU3fD2w2W5xzdJ2lHyx9P7Bebeh7i7We4+MTvvLlr+JcYht+eP99lJL8b976X6Pw2K4mDB04S7fdJKW5dShjOJzPmExKJlXG6jqZZEocWgR62+H6hJ90/UDwEaMTmyrG0X5ealrbYIOgixkBhV8t0UpitCJXOZnUZFgClig9YqgZXEMpHWQgbI3RislBTtc09G1LrtMKPQqbVuPOYoJH4lNjlYKBlD90cHjI08dPuLy45rvvfpvlYoEbLCYzzI8OyKqCrMo5u3MTYzTWOkJwZDnsnFrckCa4drmkzDJunpzw3re+xffefZd7Z7e5eXjyQ7xy/uz61DSWs5tneJ9OSkWRRIl5kTCTYcxll2q3ikmWES70e4v73al7J3YUMY2lYsxxN6OCvZxOybMsmVuS3FS7rqdte56cX9C0HUiTOOnK0I4nE2FyjAronfBLG7recn29BJWCyKrplMkwkBUlJsvRxmCDw7WODzaP0i5VgPNpYlnXHe3giVIjDZgCsixNF6mxJGqvUJrBuVHolWKNY0giTimeTxFpArF0bctH979NvbpO/8aRWVeWJSFG1tstdZOiX+t2yeA8UmpmsznWRzSCajJNbgWju7P3EZOpcbcs9kwwIeVnZOMXtJSKWG85Xy5RTx/gYsNsNmE6nfLSy8eI6FCyR0nIdSS6iBERGSSDFajoia7HxhYRG0QcCN7St4KLi48T07DtWCwuKcsSiUMEx9DU5FpxdnJEmWcpInixTBgqAS0FmUmaqRTH0CGiR4qAVImoUhhJUGC02hulGqPRJkPIAeeTy0Yg4qMlMwZjJEYNSGGRNiC8I6MjjCF/SiX3iadPHiGA6aRitVyyXi6ZVBWZSfkwO9fzGMYcG5mYqpshRUaEGLk8P+fi2QW2bfE2PXtwjrbtuPnSbe6+/gofP3nAYrMctV8KZ0FKQ1VN+OIXvsitmzfYXl+Ra83Z0RGLJ+fc530KlVGq/Id78fwZ9alpLKdnpzjnqJtmz0IyWYbWmvV6nQROSpFlOUVR0nZt0rqMbChr3fhKacQXMaY1lHD4kH6tTUY1mVIUGUNvEkHAWppuYLFc8fHDR6zWG0IUaJNRTuZEObosV36chiVSapQydN2Au15STCYImR7G7WDJ84Isz1Ha0HcDQ99x+fQphECuR8BRCDZNT2t3jUVigsTkJVlWjKBg4tULBNal9ZS1Q3JrZvTxGgOOYoyjEGygaWq+8+57eNsyLfTeMr2qKnwIrNdr6rbDOs9iuWKxWjM7OGQym7Pe1mgpmYwhUYmFlsgDUimUVnuK985D7bM8lheztAbrHZebNVF09N0lR0cHHB4e4t3byRRV2tGjLnlnZUpgpGIYPMIHbD/QxQZFi2SA0NP3nsvLj1OOy3ZL21ngCKIl+oGu3mKk4OjggGL0qNtut+nhG9LqSwkS8ypGordEbwGPYPTeUqNIWqdngY2QaUmRG0KwOBkQWVoxOe/Jc0GeCWIYiCHguh6ix+Doh5ah68iMwTnLg4++QwyBaTXh4uKC84tzDg8OKYuCw4PDJFH4xBQ+jBjq1WZL27ZcXy9ZXi9YXi+4c+MWk7JIbOkQGYaBo6Nj3nn787z7/nd49OjRvrFYC0qmrKUvfOELvPHaa5w/eICRkpP5nA/++DsUOqfQOaX6TCD5F1Jd3ycdi5TjycSwuL7Gh8SWOr1xxs/+7M+yWq34na//Lu+88w4HBwdAOs10gx1tXjTLdU2Mkdlsho+B6+WGskwUWRdgtW35zd/87xj6IYFtMSXobZuOgCQvJ5gsgYI+gosQhcZHQW8tynukSjhNO1jK2Yy8KDg4OKLtBqxNrJoYIwiF1BlHR6d7+4w4GkfmRcvgBIPr8T7la1vX0rYWO1iIUE1KjB79ypQk5AYtU6ZMcD1aKSZVRdvWtG3D4vqCzfJqFEdOyFUCGLXWKTvcOh48eIh1nigV1WRGVs1Zr7c0bUMUApROJ8cwxh6PzVWoBPhav7PeT9nnzr7YoUQ/qjU/Lml6z+pqoLOWTe0pK421huibdO1kyUNP4vHCosRAjD3Bd4hhi3INJnTMS0mVZWjpCdGxXp3TtZ6h99y6dczBwZx//s//W7QyDIMdNVADq82Gvu9p2n7MdIeqrCiraoyPCPt7JUK6h5VJbK4RVwk+4AZLUZYURYF1AxDJp8Vek5bw1SR6JkKeZeR5ztHRYbIl8n40Wo1khUDIDAwc3jhicjTDZDlKafK8IIRAOwz7Vd+6rmm7nmeXV3RdT73ZcvelO/zY136cV16+y8nhEZ//3Ft0XcsH99/n5OYZMUaKoqQsJ6yW5ylwTIxssxH7lUJS5iVaaXQx4523v4jpIzfmJzC82Ie1T01j8TulvRSjq6nYh3lNROKz37hxg+Vqyfn5OW+++WY6qZNWX973aA1CKgbr8CEwHZXyddMm5bpUqLphsAOPnjyl73ryPK2slDYJUEeMQWMqOSQHIO58zNKpJMaYxvjx/SmlyfKcCsjz4vmaaDypaC1Q5XOhfPDPV1xS6pR7ESUhMhIOErD3/DUSQUFIgRQquQ0IcNGiVFovODvQNFvq7YaubVIzEZFcC8qyQmlN6NPNssNPhNJIU5BlOSFucT6FGiWKNqOYTGGy5FqbFwUiRuzQP4+oRXwG3r+gJY1EulHpFFIIV3LcdTjXI9Go6Nn5Oig8KnpksAhvwY/W+MGhR2tto5JZ7GC7xCKLUJU5ZWl48vgRzgXWq+3YWHqulwu6YUBKnSbfEMjznCzPaNsO7wNam5GCnGxkjDb7VTDjISxYN2bKFIBHSJjMcqQCJZLzxo5wIoWgqqp0kHT1HvTv+j4dOA+OUnqqiBRVxSwvETs3Zalx3qf72zqidPje4pUHpUE5UIr54SF3Xr7LnTsvc3pywld/7MfZrFfU7YZ8kqx0dhO9H6UMclw1hBBHh3DQ2qClgig4OjjitXuvUGYl+M8ay19MydHySkDvBtq+4/j0FKMN23q79/uxg2PoHU3dsd02KJNWWs5HdEwPQqGSOWNrLavtlo8fPx5DqzyD7QnBI3VONjFY5wgeJMnmPsbItumRvWc7hFGAJSErQWlyIZHakOd5oq5JyenZGUfHR7R9z2AtxhiKPKcqStR0ChHqzTaxQAaH95bBOfoh0A0e7yMgyExBkecUedqvCpFyVbz3tPU2ncaCZ3p8iNGSy+s1bduwXi24uDjn6vIC32/JlOAnvvgOB7MJp8cHnN28RVEWnF9d0zQNR0fHXC9WvPvd71FM51TTA5CSrCzJijKFlTXN/r3cvXuX+XzG4cGcbb3l/gcfJE2aEJSTKbP5/Id66XxW//11ft3g3Bi9INNzUZs07V6dn5MphR9aZBwtToNHeE+3XGKtxQSLsB2+27JpYXDgYkRqwXxmyAZPPwS0CYyh8RhtODw8xrpkk9T2A0Jozm7fTnhnSPbwUcDTp09xXYcyybIp+EjXd7RdS3DpVL9zFi8nBXjoupaqMmSZpDQOYwRFIWlqTx17iqJEaY3WAh8bHj/5PiYvMFnBetPSDQOr97+HVIZqfshP/fTP8ZWf+ElQGUFIWhtwPhF3hNIIpbBdTwyeQkTa7YZnHz9gWpRMixIbPM3QY46PcF3Lxx895NbLt6lmM5arFRdXlwQEWZFxdDTBZJp+8GzrjrruKLISYT3dxRVFVNw8vkUus5Sp9gLXp6ax7MwUpZRJuEgKxelljx1FS1VVEYGmacYLNCl5Y0whQNu6ZlM3bDYbrHWY1ZrNdst6s2UYAbyUBAnGaEIMSfg4cuiRycUVmWi+MY6ncSHHwK8EVDvvabuOpm1p2o56uyXPc6x3ib8+WJx1BP88Y0EpQ4wCJSNS+PT37EwmRywjhsBzIScQGXUiKTdbaoFCI/C4YeD82RPq7YbV6iql1DUb5lXOfFrxyr27TCclRaZH08gmkRtgTPkLSK33wUrdYPERolCEmKjHUinyoqSqJlSTKeUkKY1Nlu2dYxO285m78YtYnrhLrh7D4iDRd1NeSEQkPy0RUTEiVDI5LXSGQiAj9FlPl+X0w8iWCsnvKoXjRbyOe6uUJDCOxJh+7X1InnhCUo16jyggy1I+UFqHeQ4PD1FSIZB7+UDKRknkkd08/PTxU549eUrbdUSR8bU33mEyyakqw9APY6BZhZCS9bZmuVzyve9/iOwtSvfU7cBgPdZ5JIrBeYQ2FNMZLkpcTKxNREQKk6YYpcmkIYaAdB1ZUXJ0cszhdM7RbE63SdiRt+neb7uOpmmpmzq5MmtDGIY9vdi7MQo8AqMkIq1CUm8WEVbXS2IInH3ph3Th/DnqU9NYwqiXVVKOlDzBw4cP6fueGzduUE0qbt98iT/8oz/i2bNnhAgmT3kRiWXlePrsnKfPztlsa4bBUtcJa0mZ8Glsnx/M0EazrTc45xiGIe1upSYfA4uEylOolTIgFUJpjMkxOiPEpLp/dv6Mq+sFi8WS6XzG2WqFzgyX5+eslku2mw1t04wUSUmWFUipiUGmMV+DVqP5XQRCwFnLIMQY8JXe8KbvKTLDyckhVZFT5hmrxQXLxRW///V/zWa9pG03TKqSSVny2tuvce/lO/zKL/8SEHj6+BHXixXnFw+RJkdJxWq1ph8GTk7PKCZTimrK+x/eZ7OtKarJyHpTKJ0znR0ynR8wnc2pJinNbzKdIceHS9clvcNn9eKVNMlXNQJS7azlJERF9AJpNJOiQI96dUVaxSoHzieNUy4zcpmh5JK679l0FqEFRhm8TvdtArsVzjliDDgn0qGraykmKd/n4PAQM7Ixz27c4PTsBpPphHK0BdpZBJV5SZEXlGWFVJKh7WjqmqdPn/L3/9//Nf/gv/4HPL28Zjab8B/9rf+Yl166yXw+2Yt5TZ4xWMe/+f1/yx9+44/47a//AYNNW4Eg0r18dHYLbXKkLjD5lLw6oG96eueoe4+PAsZ7NYYEuEcs5xdXZBJOzs54+/U3+dyrr/H13/pt6vWabrGkWS7Z1Fvk1SV9tOR5ycnJKRcfLanrjtWipdn22MEhhUIrg623SB/JpcY6GBrL++++x3q55G/+lb/+Q71+/rT61DQWYH9akTK5+M7n8z1VOEZYLddMJzM+97m32Ww2fPDBBzRtix/pu9fLJcvVOmEVo8pSSkmW58ly27rkQSQCJi+R2hOFQpkcqQwuBFxw+GG0lsgiUhlkSLz6KCSzssJoQ5blycp7sMiR0tzXA3XTjBNWxBhNluXppht24GJEklhaeZZRZDkhT2yYwQwYrTBKpb13TKl+ZZFzMJ0wdA2LzYLvf+89ri7PsV3NjZMjvva1X6AqCsoip8jSw2K1WuytbbQxFEXB9WpD0/cjlqUQMiViZlnO2dkNprOewQeU0lSTipOTE46PTxK7juRgYIzh7OyMosgpi4LZ/ACTv9jUyB/VipgkdrQeLSWgUaokyyYcHdygygyGAM6Cs7iuT84VbQKtu77HdQGCosgqEIam3+Ac6QEZUkJrZkrKcoq1yaTVBY/QiqKq+Imf/ilu3rrJ/OAApRVSa6rJhLKaokdF+mzUpGXjetkGj3QWFSUBkCZjfniEVIq6bQgxoEzG0a3XmR6f0PUtWmi01Dirsc6h82N0dgRiQowWHxxKp1waRY4SBZksWV1v+OA7H1B3A9YFmsEhpCYvJ0nDYx1FYZAi0my3tNHTbZbgPevFgsdPn+D6nvfee4/r60u6buDNsxt84Stf5INHH9MPiSBkMoPOBOWkSI4YUuGso15vkc5jvUAMDiM12/WW64urH/LV86fXp6qxwCeai5LPWV8hTSTbxZKqmvDGm2+xWC54dn7B1fU1IMiLkrptqdsunbpVOp0opcjLkgBY5/eNJa8KVAgEkcZVoTTWenyw9EN6uOZRoA3oOAJ/QnIgE703zwvKMllnS6kIIVDXNc2+saR1W1kWSKFYtRu8S8Z6QqTTfjZiMSlwKdIbk5LwxvFfiEgmNZOqYD6pON8sub485/3vvMv5syfYruHGa3f59//m36AscrJM8/GHH9DWNavF9Wh1L1OwV1GwffyE1WYLOh/jlZMeJ8syzk5vMDjP1WqF1prDoyOOjk84PDpCmyxFyYaAVprT01Pmsxmz2fSFz+b+Ua5Ihg+O3npyrYgYpCoxZsrh/Iwy08SuwccO7wRd3zJ0DtckPVTbdGnNGRSFqZDSI2NLcI6mHYgyZRdlWTkaMloIHh8dUmu0Uvzsz/0cn//85zF5NppFylETnw4qYWSDSSlSPLlPlkxRiHE9lsg0s4MDUJK6aQijlODw5iuUszmLBw/QQaODRgwC70HqA5Q5QKgpUXT4MJDJCUZlyJijychlwfpqwwff/YB+cOmAGgUmy5nPj5INUlMzm03QRmFtjXMDtt+yWa54/NEDfNujgfe++x3qbWLAnZ3d4Gtf/TH+0T/9J/T9kFJoM4PKBGVVcDA/SIdR69lutjA4ehuphKZAUq+3LK4WP+zL50+tT01jEVLhgme73pBnKTslkJrKar3m4uKSb3zjmyMGAXVT7zUoUioKn/jsQgjatv0BRXjXtPgQ0o53dOnt1+tRTBkRQqHNeKH7sNdoFEWO1il6Vwjw3tE2DQgoujJZSMgEhqSv9RAiZkxYrJua9XqbaMPFLJnwxZD0M8NA17Y0TcqQ6fuOrtlCnqHI97hPkWVE3/Psycc8fvgxTx4+YLW4oGvW4AdcV9Nslmim5Kri1o0TvDvA98m9eblYMbjA4DxKCsoip/eQaU1elHgCm/WSphvwPlDkyUK8Xi2S2K3doqQavzYb9+sCcfMWVWYQ+rnp52f1YlWeVcQ4EOhR2pDnFQTw1iGjJ/SO7fUVI7qBloaoI90ekEkUc4kaEUGXdmp4Ri/IhAP2A33bYV0kkh6ew9DjXIfA4V3PN7/9bZQ2nN16iclsQjWdpMPKSFlXCKRRyXI/+r0I2IW0Hi+yDB9TEFhhJBme848/5vvbmr/3X/39pC1ZrYlAlhneefttVoslk+qAIpsQXMoZiiGwuHjGdDrnxskZoWu4evKYrKhQSmOkJo+BiYrY0NP3NUcnE4pSs+0kTiucyri+POfDy2t812Okwg0J4Pch0HUdm80GrTRVWXFVr5ONUx9ZLzc8e/aU6BxFZjieH/Ddb32b//v/9f/GyXTG6fwAhUBkL/aj+8V+d58sIQnR76nCw5Cig70PLJYrLq+uefTkMVqn0Jxu6HEjG0xEEOOUACRH3ghZno2NxBJJKzZIzC/rRkGlEHvX4D1wznOqYHJUTbmTKfzH4faJkx5Ir2+tTYBoHBtYCEk30ltiFBT5BEZwMsS49/0K3uG8TYr68fchSERM67Chb4jeYYeG5fUly6tLbN9B8Ogx6liOgjOtJNEYvCCBrT5d5IP1DC5NRVpJVJYjlEZnBYP39C7pCXyIlNNJaop1g+tbOjGeJoUk2qSlyTKNG3rwDkjphJ/Vi1fJ5yuMdHX5PMo6elzfJndd2yNkor0nAk0kkvJOhEpu2DZEnJAkF610PWSZZvDp/0UfRqfwdB2kA50nBksMFu8HmqZB6Zy2GzBlQRFHa8fImIoq9qmpYnTOgERPjuOkkwTxASMERgRcu2V5ecG73/omj5+c8/T8kggUZYGWGu8cRNBSITOJiIl8sHWJSm0E+GEkB0UwWU5Z6tF9wGJwFMpTSE8uPD0WQUqEHLqaxeISnMcow7bZIqNIzy5rabsOgUCPQuMQIsFHnPXYfkjOIDKtw7u25Rvf+ENuHh9z6/SMe3defuEdwz81jaUP6Rwkspz3vvNd3v/ed9nWDdbt0uxAZjkuJK8soRRSaUqV6MZt36eceClJAcdQ5DqJndo2jaPGEEWi9uZas3e7jIkHT0hJdrmW6aHeNuBzRIjoLEuHuGCJrmdokx5msJYnDx6gtEHnOX3XUxRJOb/Z1JRVhdKGbdNhdM50NqOzlqbrkkVNbjBNRBiQE5NWCUON1Dm2G/hX//q3Cc4yLXMuz59xdf6MIjecHEy5c+smb3/uLV5/9VWmVUVZFPz+v/k9rq+uOD48JDhPmRm2mw1X1wtcjORlxS/90i+TFQXWB8pqQlFNiaNtRb1tuLy64pvf+uYIMAoyo1FSoqVEa0WeGeZGMpWRoWs+y7x/QUsrRWEMh5MKGT3b9Qp5XKHoef+Pv87xfMrr915i8ILBeTbrFW1bM9gNQkpmJxUXjy/54OIKTJ6kAGGgmuTceekWHz645v7DaxCQ5wIHDNayWS8g9ihhWV8/pNkc8Cu/9Ev0Dp5erhAyT15f1uMBVUyRCMLgyQMUKCZ5hVAqadCkIihFZSQ3cpgaz5lxvHQQsasWNg8I7RpvtxijicPAv/03v7Wn6R9OKw6nJYfzKbkx3Dy4gVAaV5/TukhnAwuVkRclP/7jP47Ac/3k+5wcTHj13hFtc8VQd9jNChsDFmBYkWeOk9s3KIuKqCP9YGmGjuV6w8X5NXbwiChxoxGn0jCtSs4Oj5nkOZkU6dBre7puSx9mWANdBi+48P7T01je/+DDdEqSgvPLS64WS3prx/zqRDtUWuNDSlbUcswZGY0rfYhIGUGKUbj3vHbxpTGG8VTE89PVSBeL49+zE4vJfUaET9kQwUMY1eje461NuQ7e0/Ud0lpykSxYkr9WHEWfo1eXTkFmdV1jXQL8rbP0fZ8uruDRKk0zITrOn13R1ls2qwXeWYZa0mzXBDdw59WXOTk+4u6dl3j5pZeSqthaehhpzn7/35SlkrJnpExpfpOyIC9Leucoipwiz4hSJI+1ELH9hJPDw8Sy0Zp8bCw77zCjFNMyJ1OSwTv8J6bFz+rFKTH+vLRSBBfonBuFhCrpW0TJpCoInaN1A8IolM+QgxqFLxJVFOTTWTqrB49Qgigi1g1oLZhOc0Jw9F2L84YQQ8LvAsmxWITRvTjlkBiTyCw+RIQ2KCHJ8goRI8JaxBAIdqBrOoIQrOqEqWw3KyBw+8YJot9QGjDCk8nApJDMKk095CiV/AFDcClAS4JWYLRAEZCkdFkpJEYLtm3LZt0QpSFrG54+eQTBs7q+pBAvcfOgoPcd2BbXbfdkAqMgL0waAkUYc6PSKqyuay4uLujbFKfsR2EqkMTWu+eHdSitKYqcw8NDpvMJeVUQZGQI7k/70f7Q61PTWP6f/+V/RZ6nb/B2u2W73VJVFVqPWEtkBNfHsVKk8J9gh/TwhGQ7IhMoDewDqnYPeSGSLf6OdimEHEH+tCXYEQcEMbH9YwofCsERnMCPwTxOSYa+xYUxkKzvkldQTN5KeuR2pnVZGvTn8zl13fDRRx8lRlVZ0Gy3LK4vsX2LloJJoVPuS7B8/V//Fs+ePOZwOiV6x8V2lcz7tOJXfvkX+OIXvsDLt28RvGe9WLLZhZo5T6YNXduO763Hjyr+PE9MNqMUWgiiSu4BfVcnixcgz0sOZ1Peeu1VJtMp08kEM+IoYrR4Cc6SjTne60XP0L3YoUQ/qrVrLMYYNoOl7pJbt4kD+uwGVZVxcnpEf7Wir1vy2QwzmSBUIrm4KJidnnHv+CUuFouUz94tsd7x7OIZeVHy1ptHdLbm4rJFFAcorZlMJnjrCK4jzxRGKxaLJUKXTCZzLA7rPOV8ji4Kiukh+Eho2uT623RcXy1preWDTU3TtWyXlzjv+Kmf+iqPv/vHlEYiXUuhPHdvHJLnObNZzyAMLgrqusN7Tyg082nJbFIgg8MNAzE4ymrK0cEZ55eXPH30MUFokIrzp48IztJs1sif/XHunhRgtwjb0q2vEFpTHh0zqTK8FvRDj20suSr26+2nT5+ihGJxvWTo0uFxR+ixQ0+72dCuN/TbhqqqODm7wZe++HmKSUU5m2IJbN2LfU99ahqL0hlRSLrBMrgwhg7JUbCXzOYCSbGLFKOVS8TtgrBl2iHH3UeMuABx9zpI/GjLshMgfhJz3jcVkTIU9kIteC5eHNlpSIkchnG2EdjBjoLCZAehtSIGT9+1ZHme3kNcMPQWKQXODmztgBSQZwbXNaN2Bc6fPeXRxx+zXC4Yhp66jlRFzr27d3nrjdd58/XXeev1N5lPplRlibOWVmnqejvqdlKy5nK5xLuAC4EQU1xxWU2oqgk+xPTg8KlJhCHZpkNi+Citmc3ne7sba9NEJcJummMvgEM8b+Sf1YtVh0fHaKWoipy+7+j7npM8MNWRzgU6F4m6IJ8KDigZXEjREy7FOmy2DV4qhMnRxQQdQZic6AUBT4gCH6BtB4YAKhYoEwhCgA+ICP/2D/+Ijx5eUB28ThAZnVNEDWhB1JqoFDqfpJNjP2D6BjO0bLY1rbU86D2bZsvls8dMuyXTYcWbb3+BmyeHrFcbnHW8/c7nmZwvMZdrLtcNvYscndwag+9W4Dq2dcPxbEJmNN4NZHmyMvq5n/s5fu1/9B/QDCnO4rvfeY+23lKvFpweH6OUQghJluV87Ws/Rl5NmJyc4o3BGUPbOUKASk9ZXC351h9+C9sPPPj4YwSR2SStqHs3YMacKOdH6UEc75/xw1pHqGvQiviCJ1F8ehqLSaFd/eBS5nYUhLEhBJJi3O+U6mLHSIl7iwgpP6GYF3JUj0MIIjWnUXEcoh/9hHaCsU/qZ+ReKb9vKuwcfiMipBtvh81IpVMzsSlETKrkXabHpLmh7+i7LllVdHb0C5LYvsf2XbIrzwx1DGPzCZw/e8Yff+ub9M0G7y2Ns0yKnFfu3eWXfvEX+cu//Musrq/w1lJkORaB1oqubbm8OOfg4GB0hE6KYKkNPiRPomI0//M+gg0M3uNCas7We6SUzOYpPGwyTVRipRRt2+KGBDgqIVImeQgIv1tTftZYXsQ6PDyiKktu375JcAPeDtAswba07TNaGwjSkFU502w81NmBoW+xcUO7qHGZApWh8hIdIkJnaaUcIj4KhIemt/Q2oBjQPpE5FB6F4A++8U2U+i7z06e4oFhuB3RhULmmHoYE/ss84ZvWcqAFBxrW6y2tdTwVmtVmw8OP7/PKTPPaPOOv/sLP8LnXXmGzWuO85+2330FPzwnZBV14ihwcL997BWcHLp89ZXX5jPVywenR4Zh+KpNfmTH8zM/8DL/4l/8ai03D9WLJf/n3/l+srq+ol5ecnp6MUecSkxd85atfY3Z4xMGNW2TzGWY+o26GFLc8KB7cf8DTB084f3rB0/MnHN88YTKpKPKCfOjItEaQnC92VGtGrz0pFNY6em/ReYbUL/Y99alpLNu2H1W7jp3VSZSaKA0ipmnBhzROit2kQkRJM6rkVWpCQeCDIAbBsDNyU2b09dpZqDAG0z2fSBKWw76piB0tZXRf2E1Iahj267WsKNFG73em1g4orSjznOg9m/UmGc2ZDCEN/TCwXK6YlgVVWRKDw7uBrtnS1Bvev77k6aMHECyZliA1KnheufMSf+dv/21unJ4QrCUzGhsDH37/A5wdGPqei/NnPHv6lCIrKKuK+cERzntsjIS2w/rIarVhU7csNg0IiQ0xrQ6VIsuLZKApNUVRUBQ5ygek8PTDgLPJiDAIiZCCEBxWpFMrnzWWF7KElAzO8uz8nMePH/Pk8WMybykUfP7OhG54zNO/9/dZdZF1F7j98l0ODg544+Ub9Nue3//me3SqpFcVi80G5waOi4CMjmhbIj1RCKIwIDVZUaVYizLH9QE7dMyqCp2VNE0HMqcqp7Suo15vEUajpMKGQKYNR/MDXjqY8tLBlPnhMVk1Jd66S+cs19cXfO93f5P3v/4v+Re/9Xt8+9vf4ad/8qtM5zOmB8d88fgl3v5awbNlzbYduF5tWSyu2dYtdujTCjtA3Q1E7xl8Td1/zNfWa6RMhJSjwwP+w//g30/U4aHl6YMPePrgQ3SW/MrWm4Z8esDRzZv0MdI2Pf/ff/zf8PHHD6GP2M6yXWzo6i126Pno/kcMwbLta7zzFEWBNul51Q+WrumYYjARjg4PaW1H5wbQ6oUPz/vUNJbeWoIPWGtHewYzUhHT2sX5kOzaGUH70V03mSCNazBE8ruKYv9rIUa6sNz5fu3aBLu+8jx3JDz39pLI8WQmEMLv92Y+ePACuQP0xzVZ0rG4H8xHGXr6LhtXRo6+76m3azQBowRd19K1DV1Ts12vOX+avL8ISSktlaDUOSfHR7z26qsokeJgEyjvaZsGO/TYsbmkNYYbPZoMUUisd/s1oXWe6AN1f73HrdToF1ZOplgf2NbJhy0+//b8/9j773hb0+yuD/w+6Q07nXRj5e7qpCwUWi2SkUEfwJg0MphgebAxGMYmfPAwHjx4BjBGxGEYhxkzeIxJA59hEK3BBgOSkAgSSBrUrW6pu6urK1fddOIOb3jS/LGeve+tS3Wk1X0LndXaqrvP2eHd+7zPu5611i/QrTfEELBKfDtCsDLIRxAvOT3aSqw/U8MYLd7uXcfZ2Tl37t6jITNxhvHGlLgZeOPOMatRsfKKXM/w2fDudz5NUo57Z0tCDbl2JAxox+A7sRAOEaVEwUGWn0JrW9qieqcEXtUNTTulCxVKN1TtgtwpfA7UTYu2jjFrGlexN1+wv7fgYH/B9ceeoF3soR5/Bz4nrq6uc+eTH6MP8NJrt1ien/Ge974TjMW2I1U9ZzZfkKo5szHQxzfohpFmOiOOHYQRpSKxtJyDDyw3Paenp5ycHBOR68fVq1fRJGyOdBcnvPFyLl4rkePjE6hqrp0v2Ywjy77nuU88x/PPv4AJCqcsrWvxfizrc00fRrIVyLdzFWQYhpHT01Pu3r2HnvasLy5Eey0L1Dk+sOl9VONtk1jOLtYyR0mJtjWYyrAeRtTo6TYbQgyMg7hLipTIHGst3aYnIv4gxfgNpZWIJG3hxMVQKJaWE5kiuCdPSFFUXaX9pQqaRZVKyKJSwhRRRhcqqZiUIhQBRz8OIhZpBOPvjIbSCpPXEXvSmBKWxPHdW7z20prXX3mZ9cUFw2bFZrXk9huvoZIYik3amtmk5Vu/6Rt59h3vwPcdy82GzWZFv15DTly7cpWu63j55ZeYTadMnn6afhjZdPcYo/iNr8cBpTSmaqhchTJSqaA0yloRojQWV4tb5+u37uxag/1mQ7/p2HRrYvRYZBA7aRvquqapavb35lTVI46N/Bkai8UcP46cn58zm8954sknsTlQW8Vk7wrj0HN2b8X+9Sd5/MaT9GPgzGuCW5DqPaKb8Z6v/kbe+3XfzDe9/5tQKvP7ftdv5/x8ycTA9ZtXuXb9Gp96+TVW3YAbE73vOT47x6qBykSeePIZbtx8knb+NMo0oFuWmwtW3QV7Vw6pmga02DHoGLF9hx161uuO897z4x/9FH2SZvgnP/UqZ13i9O4ptyvNz7pzwht3jnnl+36AnopeVVx78lna2R6unaGU5Z3v/kpCd0HsLrj3+qv0myXJDyyXS2698jof/OD38M9+7EN84/s/wJWr18QczBgWbc3F8TF1XfP663c5Oz3jJ/7W3yOgqOYLojVEY8RxNsGTR48RVOJi1eEHj0qR+XTKVE9pbMTnwHrsuViu+PCHf4J7r77Oop3w2GyBzhnfd0z35ywWC1bdBv+IQ/jfNonFuoqUE4RYVIRV8VfIjN5LuykKMz6l+xWHtM5kElOmIxhtd5DfouUoSLLtoH/7ZHK5m+8PXKBUNW+xYyhikVlpcooCLR5HYgikEEjB7hjDKYZCphxRKrDedJDBGMX56Ql379zi3q1b9Js1BM/Qd+QYUDmhcuZgb48rhwc889RTXLt6hehHUgrbKRM5Z/q+x48jxhistWVGdSHfE5qQMsMYsFZsW0UGXAt1pyTdmDIxR4awEZh2AS4YYxj7gXEYSYgyAlmVGatYEHSbfmcZexmPXqTgSYXEOp1OqJuGaWVoa8uTj1/l7PSU519+naAMytbMpntM2hZsRTOd8453vYf9o6ugLSiLsYrDK0dYnalVoKpqAYBkAKEDZAA/Yo2lqnRZi4bpZIY2NZEKZTJVa3FVjTaGqq5JITKMA4qMMVoIuySMrUR6KUWydiTt0KZCGcXoxVtmudqwySM9FQcx0xpL1U5F0BZFUHJhr5pGgDObNTnDfLFgvdnw/Asv8vjTz5CB5cU5pEitoVuesVmeszw7Fq+jTceYMnkMUFdQOYxxOCvqxyknYlGBNkpsk3OBF+ci1hljJKXMar0hDR7XDdTWMq3rnaJz8AILf5TjbbPi9/YPhNDUdcJcR7FerQiF8wH3L6ixXLxzTHSdKBg7tzUL0kydwxgjaCaEvR+2plzFs10wAEWbviSVnVw99xFiUuLfR4lJeyxCgJw7xnFk7HtpORmFMVr0hLzFjgay2Ccf3z1Ga81iPuWlF57jJz7048QiiT+tKjQZqwVNo0m8913v5Nl3PMMHvvmbqKuKYbPBGM180uKAcRx443Xx7p40DdaKLtpyuQZGsjaELOX+ZGowjQVjUdZiUMScGWOgH0aGYeT8YokPnslkWjTOWkzhvRwc7FE5Rw4ySxq6DcvlivVqxS1jdkCHy3i0oltdCF+EzI3r1zm8cpUnbl5nf2/O+568wcc+9jG+/4d+hHpMtAG+5qu/iqtHR2gbuHLzSX7lr/n1vPjGPV6+dYcPf/SnaGvH137t1zJulvjNBccnJ9y9d1zMuiom7XTXQp21ivlU5Pm79YbqZoW2NWNU7C0WHNX7vHHnNuv1mv1Dx9j33L31OlcmE2aTCb4Mtp9+x7MMKXO2XvHG/hGmnjKvNItKM4QomzqlyMqSdc3i8CpXbz7O4vAaOSX69YpNCoxDTzWZ4UPg5IVPiezL+97HT37yRT728U/w1DPP0G02/MRP/ATL8zPO7t5mHAPjGHj8aMKkrbD1TMQjtcG0Da6tmUxmOG1Jgyf6iO8lqTprGYaOMXqWsQercW2NqWq0c1TWodGsVxty3bA/W6DQBB9Znl+w6TZf5rPnM8fbJrGslhekJDOWqqpEbqLMMGbTqVjxRpFM8WPPaimEK6kIFIFcJFiM8E6ikvYUEHQQyHJKNHVTCGOjSPWrLWhYYMaw5bRIW0uLcR6KvAMXaC3GCTGJp0UuLnykJPIrwyD6WTnRFwmX5AdWmw3Pf+InuXfnNmanW5ExKmMUGK25ev0mVw8PeeKxGxzt79E2FVZrNp3MVdBqZ7/qjOHiYsknPv4Jbty8wfUbN3aifj6IXfPFag3GYetEUgEVM7aoyDpjsdWE6UJTtVNJ4kUC3Tm7+16McWhtCTmC0hhbYV2Fc6Irdukg+WjGO595ivV6zSuvvc500nD16hUWe3tMpxNMVTPfO+A9X/E1TK88zuzK46w2Pf14G+eXGKNwdc3gPa5peOmllzAK3vnUU6Sx4/TOawzjwOn5Gc5YEpoUhPC3mM1QaVNmc0LWffGFF3D1lMniCNYRdOCFF55nvdlw5eoNUgiszs4w0wlmMuGNkwv6rNn7uhm6aWnaiSiQZ8UQEt4pDo+ustmsWH7yk3irSXXDZLZgtjhgjKDQVJM5k7rCHB3wSvJoMtdu3BBdrxhxRrOYthzs7XGwt4czhspZptMJpA1+8EXbz3O2viBpTXYVTUzUwGYzQEr4iw06ZVwUBKYzlou+Y4ieMzzJKHRd4UxRsJjOQFvCpkNlsf5wBUBkCqn1UY63T2JZLR+w9JWLeo7S+plNJ2ithLi02TD0HesUirlQKgx8YfdmLcz4rLVY6OYsniql4rDWUjlLN24Kjly8pxUKjPi4bzEB2wSjdiVN2l18lVE7PkjORe0oJ3KIjH0vQ/0YCSkKVDlHLs6O+ec/9iPUzlJZC1qINUZnnFbUxvLkYzd437vfw/Wrh+wv5jTOFoCADB4TkiBVzlhj6buOn/rJn0QpxdGVKzvvcO8jfT+yXG9wzYRJTAQ8KmbaqsEYi3WWuplQ1Q3tZEoIQSovKF7jgrfXRtoZKQt1VBJLjaviTj7nMh69ePaZp7h77x6vvvYqk7bh8PCA2WxO09QoUzFd7PPer/hqzOwIM7/CG7dusVmtSKt7VJVl72CPaBrqpuVTzz9P8iM/75t+KTp5LCMnZ2e7NmzKihQDzlrm0xmbZUe3FrmfGAKvv/giTbvg5lOOkHp86HjpU89zdnHBarkSSZd+wMwmqMmETzz3IuuQed/T72N6oJnPZgKdRzOGhI+G/cMroBXLdQdtjamgmc6ZzPe5d7FGK81s0nLQHrBXG1and4l+5Nq16/R9x3p5IYll0nC4v+Bgf4+6cviqQs+mQtZcd6SUGX3k7tmapDSmrplmmGpNt1njh4H18Tkuw8LWuOINs+x7hhi40IloFLnIITVVxdRUaJeJmw1WKWHnF71CrfUjrxr+tkkss8kEVcyjqspROcfx0OP9yNCtUED0nnEQ6GtbWaxRhOLprUi72UYKA5HI0K0Kd8TiXEVVVcwmLVXtOL13mxACSlPUew2utNBMkZABIVgmlR9AkAmSylm7k3qx1qFNGfQDY98R/EhvDJtuQ4wiJ352dorOQRRct/7iKlNpuHZ0yNd/zVdxuL/PYUkoKiUuzs6kkkqxzJciq9VqJ5y3t7fHz/35P48QAi+9+CLZVviY+MTzL3C2XHP79JxmuseNZoqta5GQaCckZHalfAQV2PQjIUZms1kRyoyk0mrQxokgIVr0zRpbpGo0w9iTYvpynDKX8Vni67/2K/jEc5/kB37wH/DqKy/SjR5nK5q65iuefYZx9JiqYtl1rJZv8PobtxmHjicPBQr/2iuvMj+6zuxowlNPPkEYO37kh3+Yq4cLvu4r381rr7zK6b17oGWjMalqtFKszk5QaaStK/bnCw73D1HasukDn/zEx1EmgQm8+spLnJ2f4YeeHALrkzNeyIk2Z/ZuPM7+0XUmTY1WcH56RtO0PPP0O7jz/EdYdz23bt+h79e0kymDrfFJs+xGppuegCXHzHi+olslzlRiDOLjMobIMIgwplawmE2YtDV7ixnf9A1fz/L8nNu3XuVo75jlfiPzngxPTq+wHgK3z86Jq461H/Gd2AiolLDaYIxiDCObsduhUpu2ISoYlSiwrzYb7iVFow163VEZx3w+xzUVxhhOTk44PbuUzf+ihLUaow1VVWGtxhnNbDohxoq6ctKK0jLjiDFK60iJ9WouTJOdtW8M8vMYZCaTsxgdJVuUjLcMYy8IMgNkqKpqZ9p1n9cioABdZgk5Z6mMct691lZfTBVYWvCe7D1ZZfq+I4aAH3v6zRpNQmdQWaosoxR78xlXjg556oknaCpH4xy1czhjZDivdWkNiu6QH0VNWczIKm7cuMndu3e4e+8ebmIIMXN+seR8uWa52jAW8qZ1DmPlpsTPmZTBxyKVkynViUZnLaKg6N1n38K8t7whXVjJecv5uYxHKq5eOeDu3QVN7SAnum7DKq5xxnBnPtmhJofNyPm6o+t7uUhqTU6Zoe9xXYdZr6mswWTLG6+8ho4DVr8XUsQPA7bSYJzQxFJi7DsqG6mc2C1IGzsxDD3H9+5hXMa4zOrinNXFOW1dk3xgfXbKahiw48j86rXd88mJYZRqaLG34K7WhCGyWos/irUOrw1ZGSH8xkzKYrGdohiZxTTSjyIlI75MRRhSa6rKYa0gHo8O9qmMolufo3yPCRs2Y8BHmJk5yYzo5UZoEGELXNgqdgi1IYnch6BPkfWStcJq8N4TfCQ68YKqXIVzlejyOYd1djdHfpTjbZNYGAeUs9SmIgw9mxD4xd/+i7h58zr37txBa8ViNuXlV17mlZdf5vbtW3RdJ7pcShJAFyLjmAhNj8mOxbTFh8B63eFzJPmBT33iYicJrkA4GBmUVVy9eoW6rvnkx58jhIC1Ir0dQ+Tateu0k1ZmLkqSVwpexB/7DqUVi70Dcsps+o71ZsOm27B/sIfWildfeYEwDtRGURmN1YpxDLSTCf/2d3wHVw4PWEwnECPEyGI6pXJVcf6TEjn4ka7rAQScECJWKdq6pplOmQ4jq96z2oz4CN0YOT49Z9UN+AwqSCvNJo2tHIeLfZarFcuV7PqstSgtVYmrGoxSGDQxenKM2MoRQ2C5XjMOA+M40BdU3GU8enFlb8573vk03/GrfjnZtlC1vPDiy5ydnvFjP/Yj1E3LjafeyfHJKS/dOuPJJ59iOmnxF7cwJG5ePeJjz3+KT3z/D/D0U48zaSvOX3+Os1svMZ7d5uVXX6O2SvQqc6Rbnoqa+GaFWzQ0k4Y7t97gzp1jfuhHPsUQwFQTSSw2c3ZyQrdZcycEamOYVY7ghTOiUkBnT+hXMtuMmsoa9uZzOfdj4Ox8Sc6RpA26aqiaKc10QTWdc7Ec0MYymc6gXxI2kedfepmzO2/g/AqrMgf7Cy6WK/IqoaInjB2ri1OGrmNSOwar0Qpm0zlRW2JomdWKp2YHhOyJOdBahYqBs5dexqHYm86oynD+5dt3WPYdfd9j25aDwyucn50x9Bc8/Y538NjVa7zn2uMYEuNmyf50ypXrR/gwslwtv9ynz2eMt01isdaUqkIqAKOhcoamcsxmE4xWTCcNh3sL/NUrGBL90OOs2w2P7x2fc3xyDjEQQiYmUeytK1eQS1q4LBTyWM7S21RJnPYGmcmEGHbseq012mnatqGpa05PTwFF7b0M5Uu9pLNmHAR+22029F1XCJBijpX8CCniym4wxMjjN29y9cohe/MZk6bGGSmdcs40dU3lKsa+Q2tNU9eM/SDHhbTkNl2Hqyqa2bTAhnNxhbRYVxUW9AStDT4EqrpFG5FjIUaBcWbIqCLeWSS+c5ZqRMvCEi+JVJSXRUYn5/sih/kR7wf/TA2jIYSR47t3yNUEVU25d+8upydn3Ds5pmknNIsDVqsVfd/TdxsMCdVvqIymaqbszafcuHbEtSuHtJVFLWdUBtlMZTGGi1mhiicQORH9yDhkuk3k/OyMrCzL5ZIxKlyjqBqNQ9HUDUYrETTVmsYakTvSCH0gl9fUikpbqsrRNBUoWaPDOMj7xUJQTpkohTghCYUtFaQoxqCNVOuVqjEqYtWW/5bpuw3deiWKyCpTWcN8OsHEA3QzJ5mKKk0ZMQzKlsQyUqtEHgf0xRIHXJktaJuGpqpZe4/rGuZ7U3Rd4+azAhIy1E2DKS10lUFrs0O17u3v007aL/PZ85njbZNYZpOJSEqHEWM0dVXRrS9Ynje0tRPhw+C5erjPlYMF/l1PQ840TQNKkRJ86EMf5sM/8RFCHBh8Ztklmqbm+rVDka+OqeiJKbJWjCHQDUO5WBZV0uJFrbVGa82knTCdTLh+/TrGGD7ykY/gvadtW5q2oWlb6kmLUobz01NGP7JcXeCjKMTmMAhHk4QyGmcN69VI33l+46/51/iK970LHSNx7MEoVBI9rtlkQu0qXjs5pmlqjm5cZxxGTs8vSCnjY+DOvbvUTUMzm9ENI5thoGoXTKqW2WJBMo5oW5p2ymbTM987xNUN3TAyxMAQRebbOIcYrcF606G1IqaI1UYQP0WEcvQi/51kwIIxpnjPXM5YHs2I3Ln9On/rb30QN9mnnh3w8mtvsF6vUcHTtFPWQ+Ji1HRe89qrr1BbzYHuWcwaqv2Wr/uq9/KBD3yA2bRF5cgre5q+WzF0SxazCTEEzi/WxJSZNRXDkDjtN1yMgdV55GK5JquKfvD4pBnihpluqJuG69dvYK2mshadImro6KOnH9bYHNEx0DiLaWoq22AWM/RmTkaImKvVCqVgHEc8I0GNdL1nMwSGKOrnxicqDM41HBxepdYKO5ySfE/YnKNJ5Og5uXcHUqCpa2prsE3N4ewm1VOPU80OwLVcuCOSqUi2JalAIhC7C8b1kk9lcMDNg0PmkwnTdkKzmHPR9xy+512MZO6sLtisNmzWGyrj6AfP7XvHtM6yN6mFuzd4bt64SVW7L/fJ8xnjbZNYxlG0wmLw1HWFMxV+HBmGnsaJm2IIHmekFzptFuIIWXr/xlje+553sb+/Rz+MhJjoPAzDwPn5KZtNxzD0jFFmCaa2ZeddRPS1xodAVJEthT/GIFLhw4BzFmcd8/lMhv4oQX8Yw6RusM4y6FF2P4WsaFQijCNkuUhrlTFkHr9xxGK2R20Vw3rF0WK/VDWeMMptODjAIBDrbtPx2muvMfogGmNK4UOgaSdk4N7JKd0wgDbcOzmh95F2OgXbEHRDTJl7xyfsHRzhqpqttHNGZirGyGffiW1mQdtlVeZN5ebHkRiF9LnzqSlyOJfx6IVqGnRdY50lxIDfrFFa46paBBCVIoTAOGb6TjZBgwaVVmzOFOd373B07QYH126glVQir37iE+QwULtAKN2AqnIEH+lWS7z3GK12CPR+GMka0a7LFp8sdWuxlaOdVlTOMmkb8CN+maFt0H0rr0HCOY2tLLaqMPMZtT9kPp2yqSqZkSp28k2xCKqGlJGVpndadlpZ9g4OaGxm+foZMQT6biNdBj9weu8uyY9cv7blvyzRk5ratIQQyASCziStZJ5kDNZYRi/E4tGPInOkoHKOSdvgnMUGXZKEog4tztUs9vaps1RtbVLURmGdaAmenp2iTKb2j7aaxdsnsQx9GVp5rFFQWbwf8cOAmrWonIl+pNI1zjgW8xnWWoZhQGtd/Bie5V3vepb1psP7SEBx9+49fvTH/n90XScy9H0QDaNY7fQoty2dGII42hUI2IN+Joos7zGbEWOk73tcQYe1dS2yJkkABM4a2fXrxKpbEYOnnU8wClQOPHH9Cs++8x0yJFytaK5cwwBDt2HoOvquY+w7XLGGHcaRs/MzpjPRQ8padL+ayYSu7zk+PZWZkTHcPTlhtRk4fOwd2EYRTc16s+He8QmPPTnQpvhAYhHrVKMtw2aFD14ACtwX5lQKQorEGGTwGO4nFkqlcplYHs3IdYWqK2xVMY6JbrNBaZGA92VzFKOAQfo+EEeprPFnpHFgs9zw2FMX3Ow2DL3A/F977gWciVw7qmjnC5rZgroaIEO3XpMKN0RUxsWmN2vN/v4hEcd6hKpVuEbTTlvq2rE3mxKHnrXvUU2DbRuMRmyIrcZVBmpHM5+RlEilXNQ1IXjhdSmRZ4op42OWxKKMbIyS+A4p7dg7OCBUitUbzxNjoO86/NAT/cjZyTFh6DncW5BTZL08pzYLVFsR/EjMBm8i2YDWFmMz1lm8FukoPw5FCRkhGDcNzhoxN7MOtKIOItVfVTUugo6ZatNhyVirGceO1abD1oY2Nl/u0+czxtsmsaQsfJS6ru8js2Iipoj3AaMVzjlG78WaWGXqpmE+W+z4LKvVitV6jasbmREkxXQ64z3veQ+nZ+ecXyyp2gkhJT70kY8QQqAuhlWVc/SdzEiMNrs2z9D3jHnEOlE49V4QWVvzns1GsPrOOfpxZBwHlhdl8KagMgZXV7zjycc42F/wzJNPsJjNmE+nVHbbahpRSmO1YTGbsTed7hJa27a4qoKNYTKZMplOef3WHZbrNUGwz9haoa1BGcPrt+9wfHrBlSffLb3rAP04yu40RkJI1JN2V7EYK1BsPRh0SjhnC45e4NapoNG2PeyUxK0yhSDQ7geqvst4tOLvfM/f4qWXXmYYI5shsR4z3RhIMVNrGPuee2cvYSb7zCZ7XD3cZ9ZWPDFNdBdnvPCJn+Lpx49457ueoa4dMXg+5gLOKB67eYWoDAHNOCZy6phMJiwWc5555mlsrTAVvHb3nCEannrvz0fZCX3UREYSA1oHtEpYMsN6yYnVxLoithV2OsVWTmZ+fU/XjdTB41IQAnQSVJdWIvpqtMFvLTOUQbtGrgsIGCApmLYTlM1cu3aNYVKz3yg2qwWb9QqrDU1dc3SwEEDOeknlLNZofDnnexuJypM2HU2jabIm5i0mVfZrxiqqytK0tfgZjQPrbk0wlqyECJlHMRprjKVxNZZErRJVtMQkz7vksXyRYlc5GAMoYkr44BlHTwgRZQ3OavE+GQaGsS4scdG3SikVhuwo3i7aiPmW1sznizIXMMz29wgxoretoEJGstbuRDCVsbsqZmvJu+WWxxh3t5RE16zv+52y8DiOO4iwNobpVDDy164ccfXKIc88/RROG2HXKjBK7yCetkioOC1yNDFEptMpSimcdUVV4D7qDKVFa3PrqRI8F6sVF6sVucxArBWYsauqXTWiyy4rFDIkSjxVtE5l11VsC3KGnO63u9T9P9a2ookhCrzyMh65eO7jn+DuvROSUtiqorUWbCClzF5b0216Ts9vsbew7B8ccOXKIXuTmicPLBet5c4rjsWs5XB/znQ6JQXP6/MWZxSLxZwxKUF6GUETOmeZz+Y89dRTVK3BNopRvcFmVDz+5NOYasaAZQwdPm6IsSMnjwoepzWbyZQ09qQwkJwAbnLKhBDofSqqw6Ii+2ALVhf18qyKBl5R4AAlkGPYAVIsjqZtscnj4qyoXgiZubKG2loBDRSYtCoQ6oxwWUJRYNfGFGjx1pF2G6moPt8nWG+NCpXWZAVxeyzOUWWFI9PohI+KENnB+x/leNskFvFMUaAsQ/CkIfDqG7dYbTY455i2LXuLOQmPT4nBB9Ajp2fnVFXFZDZjttjDNTPWXcem95xfrPEh0PtANwbGmFmtewbvGUIQccucRS15Pufk5Iy+G9ibzTFaM46jQB8VDEMvpMeuE5E5wBpBYImMuOiMGa2wRtG2LZNJy/u/+Ru4eeMaT1w/onKGymgIwn+5dniEtZbXXnkVZw3XDg/FFKiquHvvmHEYd6TN+XzOyfk5L7z6CicXF4SUOLx2Ex8jq7NTfvJjH+enPvEJjk8v0LZi8IHaSPvuxnSOtY7F/h5V3WC0I8TAZt1LD1pp6qamqitiEBG9sNVjSxFVWl7OWrGxiRHPVg0gwKVs/iMZ3/8P/wlaW2Z7R3zt+76Gd7znq0ml/fnMYzd4/pPP8+f/x7/A13zDB/i6b/wWLIFKJZ5oA2+8/Cle+fhPcDCfsT+fAZk+DJydnpBjYBx7TD3D1FN8FGO+ddcRcuLoyhVca9CVxn/qNsthpMdQ2RrcFBUdKjjyaMR7qBE0l2kmUG/I1YaEKiZ0kRQCfT9SGUXWiBaXc2/a8GSUnMtoUAbtatn8eDET62OgzdK+NUaja0vDhBx6Yqfox5GQPJv1BdF7ou9JoyONo2jsaVWY/4ZlL3D+0Weq4AkhiS15iKzXa5bNBbVzrNZLhrHn+tER0VpOhoGUFClL2xotsP/WOa4uZlysTrhYxWJq+GivqbdNYgkpCx1PpeLDoth0PcYYIe+hSuZXKCXQPFCltPTE5QqUkKT6wdMPAzGJ/W7XD4Qk9rzKSMtnNpvR9z0xJSaTCXt7+9T1HWKIHBwcoLVi7AfB9WbZyeetTEupTHLWO7KlUkqSDLns+DM5ic7Zwf4+i/kMUmLYrKito6pr/DgSxgJIKFUSW9Mx8VAuxES9K7e3Ss0xZaxzRCXf3brrOD07I2a5cMjGTWGUtPSaViyHgZ09QEaIaztXTCXvJ3pkhQCaizw0uQhyijDndkO1ddi8jEcvhiA22cY4XN3SzubUdYuzjqpuQGu6YcBYw3yxQPkeR6CpBpzR4i9Exhkt1W3OOOvwKdH3A42dYLXZrccYy/milcxYUPiUGUKiHyPRBhKRUOYgKWvAoEkENEkbktLErAg5Y6JA6ymdDG0URoOxBmvNmyXq8paTqN70X5RiewqnlAQFqcUywqmavqrorcVrtZNlUgqc0RgjgrWmbCBdXRNwmBG0jaAT2ppyPBbN/WoqJfFg0VqzXC0ZUNxdb0QOydZUGKJ11MbSOsd0NmMzLKUVb0E94t7Eb5vEMviEUolodPljWk7PlwyDJysD2jCGKFpVrsbYGmMdobSGTs9uMVssmM0X3Ds5Y9P3TGdzfEocn53TthPa2RxtDbaOPPXMM6zXa05PT7h24wbPPPMM945FI+m9X/E+NIqz4xPqWpj/m82GcRw5Pz1lvVpz586d++2gwpKdTqdFMluTfKBPGybthIO9A2ZtS7decXLnHo/duMGVg0NefOFF+q7jqccfw1kLKeNHASykENAoKluTlWIIAWMds/mC09UacsA1DX5QjDGy7nvOlitmewfUk4mgvazFaDlpF/MFnR92bSulFMpo2RH2vbQitWLaNmKUVlQLUpIWhC6JhaIO7dm2w/Il3PgRDdvO0MYRjWNE08fMweKAytW8+toLvPjyq7zy6ut8zXojxnBpFMfUFIWMu7ogh5HaStJQKnN4sM+6zDLruaZqJ9iqxgxFSillfEykIAKtmyGy7gP3lh3GO6JVJEYyHudEp2/0njFkgrL4rERyJSaMcSTkWtBMHK1WNEooBlV9v7VLLgocWd3fgO0SS5GQzeB9gCRGgs42zLQmDT2hW5O8cGKcUVitmU0apm0lqgWuxtiGuNjDUDEOCWsCTnuarMgqMp1NsTEUJXSATNs2dCnyieee46zreeXkjIPDqxweXeWiOqe1Dr3YZ1rXXLl2lfPlMX3fo02NUo/2pfvRProHQxlxX6zcTto+BQ/K0g8ercV7JHi5VU2Dq2sm0xkxrzhfrlhuevTdE2IpifshELNmvtgnpsymH8rQOov3tff0fc/5+Rm3b9/m4mJJtxkYhoHppOXGzetMJ8JjGYcBP3pWFxfcvXuXk2ORwdcKkuj5I1bJirqpiqicQHJTDGzWa4zWvPOd78QqxWa9kuGgFsy7Kag0rTRaaYwdyUHIlkkpxhRJpSr6xCc/xa27d3nt+BhbVWRjMc6xd3jAGDL9MIjgpjHYukErhfd+52OjlDD327bdJY/Re0jc701rXYRARYQ5k8lRkqi4VMYyuJfbZTx64ZPCGo2zDUNInK82XEd26ydnF2z6gb2DQ5Q2LJcrlN/gciBbqbq37aaxbHb8MMpGIkvFHGNxdg0JHzNNVWOrqrR5DBiNrRtsrQhZk7MmZk1SlqwyCo1RCWsV1SRxdO0GfY700XO2XJG0ZfAB4wJJG8YY6VJg04v8TJwZMd1DBvTRRLyXuewQOyHx5khOAR0jQxjJccQhXDGj9A4iHIvro9p5qISipi6D+zF7Rh8IxXpCa9A6kzxiyxE8BM84WnzwxBRxVcVUKZ49PGI5BpqTU6bTPaazBTaBQ+Eqh6scdV1T1bXMQrV+xBthb6PEkpUYUdmqLoOzYmmlDX3vyRk6lRiHHj8OHBweMZlq6nbCuhs4X67ph4F+GLl+43HadkI/BpQ2zBb7XCyXbDYr4WkoaNu2sON7zs7O0UpzcbEijIFh6JnPJty4cZ29xYLFfCF91xDZrNfUdc1HPvIRlMqiulykgcjiMmltxZB7htGTClR3swnszWe885lnOL57l5N7d6mdxTa1mCsBQ0pobTDaYo0lxcSm6wTZosBUFcY5nvvkp/jYc5/ktbt3OLhyxDPvehfWWfYO9rl994R+HHZKzk0j6BgfvByjlh2cMZpJNdlBiPuhLwNOjcqKqCXBpZ36puxk0wPghVh4LJfxaEZI0lIxrmEMmYvVhqg0aMvJ+ZJu8OyXxLJarTChp9KRPKvKMN6RyQyDGL75US6YDyowxJgZQ8THxKxpdxdGjAUtzqWmUtLqyoqEIReNP63E3hgrs8dpbVhHz3rsWY2BEcXoA8Z7soUxevADXdfT9QMx1iiKPpiOBLaJZaTLhqyKG2z2mBQx4whxYFYUzfU2sQDBe0kOOaO25lxJ5ow+B/w2sZDQlSuJJZFGSa4hBHLwjONACJ6UAq5yTOuaw2efZZMyzckZ1tZYWxO6ARUiTmlsVeEqmXFWdYXWmYchAY9avH0SSzH2cbai6zZ0mzWajNGaD334J3DO0tSOruvphwFbtZyvNvzAP/whlssld+4d8/jjT/D4409gXI1PACLIuLlYo43j8OAK3dARY8SasjvPsF6uiKPHakUzbYjB46zlqSef2vmsxJzQCq4cHnB6fI9x2FDXNbUTW9WYIkO/wVrLxE6prBAPF/M5B3v7TC1YrTg7OUblxOH+HrWTcn61XqKVonY1wzCyHtfiJVHVOK0JOTOEyKofWJ2dY6xmNp9SNeInvn9whZdev8Xx8RnXr99ksdgX7klOgt7xAe8DTdPsZkUaqJxArVPOootW/OulvXdfKkMl8cFJUcT7tq0/Y7SU7JfJ5ZGMxXyfyWzOzSeeZnF0nfnhVbpuxPtEOz/g8FrgmXe9j8Mr1zGupq00FYHVeoUPkYOjQ6aTCZVR1IsZTe1IZY7StBOUsYwhlm6DuEwKMdEQkyIG6IbIuveo83PsRNHsz+SCrsEX87089sxry+HBFSbjhmnYcLZakcYgFUuIaNvgVRQBWOdQztGHDDHQRdionl47Vqs11fKCi7EDpamMJmpPUp6x29DkgZtHU2rl0T5CyiQfWJ6fyaa17wARi8zK4OopJjUo3ZAwaFsxm+3h9IhTI8O4EpvyJIKXY4wEMskYqnZCVorjk3OCsUzaGaNPbLqRadVSt4YJiO9NGKnqiitHB5yfn+AvHSS/OLHtS6Yk+l0+BIyShLPedDhrSSmyKbuV0/MlISaef+FFNpuOrh+4dv0x2naCTxS5fBlCex9ojKWua2KKBB0wOqOUkd+PnhwlcThrUFlgwE1di9BkLgrGCppKZi7bdt1OvZViRKY1BsBoNJraOeqqonEKlSN+HGRYX9fUVQVk1sulwJOblpQT4zjQ1BMZthsHMdKHRAiRvpdqxDmLtZXcXEVK0A8Dk3bKYrF3n1m/HbSrjDUaYywh3DcUQglMcwcdToJYI0ulct/eWXapWySOUkh1ox793dXP1KhcRVO37C0WTCZT6qouA/ZI3U6ZzEf2Dq7QtBNAKlyrFGEUXThbVbJ5AJzV5LhV9S5W1WVAD1s3Vs3WFg/EZiEk8DExhkCOEafuz/i2aJQYI1SGuqpQTYNqhVyovBj0qQRKGZIyRKXIWpO0Ziyt3TEkok5klfF+FIHUIMZ/Khm8Dowqkn1E5YAPBqsy1U6BWJGLb0yKsaiYA9vpYgEFxQw5KfT2s2a5vkiy5X6LMGdCzkQFscgkJVuRW8MwRvoh0NgazH2IdCZTVY7ZdMrq4oTxUt34ixPTpibEwL17b9DUNQeLBTEGnHN8w9f/LOq6QmtF13V0Xccrr7zMcrmk66SXiq7AVGAr+uWaEBPzeYPRGqcF0eLHkUnTyhA6Jy7OLxi6kWQtWEQjCMN8OkNneOXFF9ibz9ibzTBWdvoqeaa15V1PPyVik/1AGmXY7qyjKkx8H4Q8WFmFMxBDj9WKWVsVpI5hvVoLKswZrHVUTcWm6/AhsNivaZoWtGW56Ti7c4+QM65qyRhSNkxne9iq4ex8xWYzErzCmJq6mjCbTTEa7tx5A1fVIuORilyNEnHOcRxlwG8sta2JKnJ2doZSUFfiQ56SJCBdnDJTjmAUrqqxRrNeLYnBf7lPn8t4qwiJWhuu7h8StGVcd8xnB9R1y80n3kkzOeX4fIN2DV3XsahbKmewuiUZx8VKZJBIPcNqTd/3O9HH9TCwPz2gbSekmBkHj2k1VlmsqtHVhNw0ZOUISdHOW+ykAh1kJkmmtRaLxvY9VcqooacmUdUGE0fyOGB1hXFTdL0gjSv6MLJMcBEzbQRyphsz1aJhb2+fEEa6zYrZ3k2UMpAQuLIPxDEzjoEfeek5DlrLVzx5BXDMpnNuXr+JH3qM0tI+n+7ho+bu2Zq+mTA4y9lqZFids7m3ZmIDrfGwuktYn5O1JhvNJgXOxxHbbXjj5JzNGMnzK2xC5NbZCmUqtKk4mbZMKse1SY2z0M5aKnPE/sSyPn6DsBq/vOfOZ4m3TWIRRy1pt4C0WVIqJEUrviN15XCuomlaTk/PCCHRD16kRXQhRSmzdUfZkYyMEeKhMUa4GFoToscax6Sd7vZas+mM+WxKU9VUzhXehjgpiuqygHSds+ztLWQov1mjVbn4ao1RipSEgKmLx4JzFhMjBoHwplR2eWXXH3yUXX+BVbqqout7kW2ZznaaZpuu52Kz2WmhCeJFkxJY42iaCZuu4/zi4gF8f3HJNBofPDpF2nZGCJJEFos92vmE9XqN9x5rLForrHFY67DWi40yGXIgZ3GeNAW9Z529T5y8jEcqUoyFIDwnqIqAwzkh2saoyNpgqxpdtO1iCHgooFm1s1CwxhAeHGxn4TlREFu2OCbCFtYLOUIOGWMqqrqhbhtMXZGtFlg7W+vvAudVClJCZ9ELV9ubEk+gjMxglato53Ome/tMpwIu0EPEzWZUk6mobReL8GJ5BElav0pbUIblckOVK1AaVwnLfzKZMGqF0WaLgWQMiZQCm9wzeEufPYOCgYSJAWs8ygsx2vsAIdBn6L2n857eS0JLw8AQMiEkbLHsiFFcKccgHjExybdut52QS4LkFydiGEkxyhf7wJeakgywrXPi1z1zxVa34fz8nA996EOM41hY+w4Q3D7EHXu+rutygZcbiAlYWzc88diTbNYr+s2GJ598kqPDA5FVmc25cfUawQ8MQy+ntlIobWnbmscfv8nQb7hze8BYjXUGox1KQ9931HVD27RMJhNm0yk2W6IfGYrPglKKtm5QleLk5LRUEYm6qVFa88KLL9H1A088/U5CzChjuXXnLs+98AJ3j0+kUkoghbxhOl1w9cp1bt26w917J7z7fe+jbhtx46xEjubiYkUGrl27wdnZBc899xzvfe9X8PhjT3Lr1m3W6zU3b9wochIZrcAaXa4SET+KvYEmC7uYzGQ6lUroMh65GMeA0ZabNx9HuRZsw8YnhpBYrXp6n3D1lKoyOGfZbFaMOVBPIGaFq1qapmXSNoxKHFy38HpfOCbOWqbTGWRpgcWQGYdAygPRJ9p2yoGq2T/YR9UtgxJQSk4Ro8EqqKzDGoSImwQSrHISMm42hS8G2lXUzYzHn3mGtnUc1gZiputGqOfkeiGAgySmZiiDQlOrjFUGV01QOXF2saJSLdpWTKo9mnlLv17SrZdiGhYzY0wMo6dPkePzE3rdMVy9QrIN0Up3JeiADonoE6v1huR7xlrjNhvsZkMfAkNKbFZrIpa6mlA1E6p6giaREGj2EDzrvsOFARNlBGD1JY/lixLbJGCt7Ji36sIpRe7cuSNmOdZSVRXOVsQUQL2ZRzKOkgQgl9e4HymJFEMsPVTnKqbTKVevXuUYROyyYN77YaTrB7phEMKU1symU5yz5ByZTGc89fQzHB+fgHp5J+qoyswiJZFvsNbt/LJ9GKis5ur168VFzjOfzjHaiH+ED1xcLAkhEkJkNl/QTBPjGPApkZUooDZNy97ePqaqScUtLyvFwdERtm640XUorZlMJlRVRdM00rZyFYvFAqAIdyqeevIpZtMpwzBQ1zUgPhehoFtSDGLylYKw7ENfNJoKYiYLCWy7W72MRyuMdQw+8NIrrzEmzZAU2dRkZRiTZr1Zc7FcEpxmdIYqbah1Ik+mUilo0Zfrh0GklELYSS9ZazFFekSQj56IqCiP3ssFs+/FDtw1tG1LshU+skMWhpxRJKqctg0LLFLBVJWj8lLVpCyETKwHLXJJdVVjy0hnohy6naPbBdV0hq6nBFNTKNdUGiqVcTmicFy5do39iSv+Q4kueDLSYTCuIuqENl42hq5lMb/OaKe8kuZEU6OaCa3ytGrADBFvEtZVRBLWaYy1aC2eK0QI0TEmzRiTfIdqoK2KDbrReB+49cZtjF+jxzWbTScWH49wvG1WvColMRTtn5JYYkzcvXuHcRyZzWaC964qYgw8yHJNKTGOI33flT/Ym5m5W95FKvphTbPHZDLlypUrDF3HxfnZjsMxDCN9P9D1kgyc0UymM5qmZrVa0k6mPPnU03zq+RfYDipLXwugDLeFrRtTlsHlMFK5CVeuXaPbbOg2HXt7B1hj8SGyXC45PjkrSKzMbLGHMY7jsyVjiCQy2jqadsJibw9dVTIsjImM4uDwkKvXb4jZl1JvSizG1Vhb0TQypO36AaUMTz/1FFrbXWIxxhCDL+Kaq9JHyKToC9RYrA3Iws3JKdI0NdY+2oJ5P1NDG8cwBl5+5TWWvWfZeZr5PrZqqNopfd+zXC0JVjNaRctAtIrMDLSYToUQ6XrZZPgQobSnrNWFDLhNLIG0VUsOgU0c2cSEc45ZJd5FQTm6we8M9oJOO8vtpCDGLPp51oplb0XRAcx0XY+yHvSAUZrKOrQSEcrKOdxshp0uMLMpyk0YqNmCCSqVpWpJIwbHlavXWFSA0viY8OMo0GRjMbbCqIS2nno6pZnvM3vsHcRmwdmtEa8cbrZHkwfqXGHrxKiFs6KIkliMQ2lDVTtU1gyjVHLRB5L3xKz+xcRy+zZqWKGGFb7rS2vs0Y23TWLZquRuK5BtBQOKcZRKY9vSMsbISY3i5s2brFYrTk9PiVG0eg4ODqjrBufE0+BBvsV2MazXa4wxXLlyjbZtufnYYxwe7NFUNc5At9nwAz/4jxi6NWO/QWtF2zZ84Fu+hf39PY6Ojkgoxlg8V4C2FSG+djKhbsQHQ5BUisMr13BGc/fkvJCvEoKWjHz8uefpNh2j9ywWe+wf7DH4wDh6lHFcnF3wzz/8YbrB042B49MzNv1AMjWundI2rSS1DHuLPZF6SQIe6LqOibbYxuJ93KG/qtqxWCzoh5F+GNlWeakk9a2vhtUiCJpSJIWEiOzJ3yt4z2TSXlYsj2icbwbcJNNMZriZZU9ZcC3KOIEXTwNVVVEbqA3kzRmWgHUVrmpopnNc1RQ4MbKjtxW2girJfMJYvZMIMpX4rNjKQT/gg6eez1HttHQDdgpJ9/XocmTVb8BBZyyMARUim75nve7xFxeM1nPsYaU6qtxxfHxMvzwjFkn6ttHYLPOeylZo5wBHznJcdtfKHYnBM9/fY2IzWRvh5MQoni2uRtcVjEHWddexSYqVvUOsO/quJTtwRRiT0JPiyOA9m64nDD05aYxbkbQm2YasLabaw6qM7qXDMIYB39QietlM0cayWm9QY4caekwq86BHOB7to3sgBOIng8FUNKqUFvKS2PHmMjQ2JeFAdpnFYg7AxcWF2AJ3Hfv7+yI0p7UMApOSwiKXakiBH8V7pKprtFY0TUNbC9LJaVitlrz++husV+dsVku8H2jblve+5724quLwkJ0WUSqwyVzMk4yVHct2BAmKqm5QZMahK6tLnpdT4vx8KdwcY3YleehHRh/RxuJD4I1bt8A4lHHCLB592dVIiywVS1ZbAANxjDt9pG3CFuBAGY4W9r0qumbb710rtftbiI2q2vqe7dQFUOI7k8rA8TIezUhosjYY57CuAVuTTAXKomyF1oY8mVIZqHQmhA6dtsAXXQb7TtZRvq+KXaCF8n/brkBBG6KlJZwQ+21bNogpRiKiTbeVvI+l6tUhEjXEbNiC17ctNcaRIRnGETIDMffSaguBiMXoAl9GFX5MIT6idnIuOiVU0dhTORd9r+3xiqMsZUMlPjIitx9CIOWe9fk5wUV60QqgCoHsR6IfIXlC4YmFEHDBMvrAMHrAgtmy6Itye85Fny/uABAZ8DGiY5JjRaG5nLF8UWKxvxAtrotzEolIRBtdPoGmqitmi9mOR5FSwhrLE08/yfG9Y9648wYX6wuGMLA4WFA1VYE1SmwroGbSoJXmZDyDIrMfgrDPN5s1kDncW7DpB85XS4IPoB3GKbSpODtf4qqavf19lDEs9vcZxrGI21mUdWSlGXwgZnGXM86y6Ucqa2imc2H3pkwfUrFVVWAd9WzGZgxsbt2h68VD5frNJ1DGcPv4mL39Q/YOFlhXYWNmMp0X8685666n2/RcrDZYO2Ksoq4r5vMZow/cu3ePyWRWeuOalAQVZqxl0tScn50yDgNXr17FWs0wdthSsWQCKmR8FJWBGMKO4TwM4yX7/hGNm08+w3yxRzKOXNCD2mi5mGYRLx1GT1RZ2lIxYXLi9GLJMPTUkynNdE4zWwifK8Fm8CzXHd0YaGZ7TBdCKNRaNL+GcaQfBrq+Z91t0G6F8hmfbhO0pcumyCMNmDBiybSNparFSbIyA1bV+Bjpxx7lPVnXNHWDywGbA9PJFEdmr65w1lE3E1xdS6Lczly1bJ6stZissFmRQgVD4OzsAlrL4wdXUCahKi1GgL5jPXjGGEnOshkC63XPyy/eYRUN+sZX4qZ7zHqPDiu0XzEzgdSv6bf0ggw+wRgyxgoq8+z0DGUrJrN9nI9CktxsGLsN+40mTxsOJgtc3VDXhmF9IUn1EY63T2LZW9B1Hav16n5FspUsFbupN7XKtsKHlWvQRu9mLNvfKb2F9N7PLlsl3qxyMbQSfTIVyw59uxtTGm0sTdvSA2NMUEx97t47JsSIcZbjk1O6fiwVVjnOENDjWCCdmZQVShucq9FGqpQUIjFEGq2J4g8srF0vM6UUM9ZVaGtZrlcs1xtxxIxCvsrlM20XcNf14jGj9S7xGmNFFblc8x/0lNlWJWpbyOVSV5VKJRfFA70dHakHKpftd1heS/rrj/bu6mdq3Hz8Saq6Bm2EpDgO1FrgxkqrUhlEUDI5r43B4IpIpN6dg0pblM5ShRciYEr3ybLbs0EUiM2uahFli61vTyAZjdJ253NkjMUUOPwWam+txSa7W4tq55fk0NGg4n1iZYgRhZLk4z15HLHOozFkU0Mhd4qvimwss5Y5UIjCljcZtDJgDNkIATOiRE29GIdFxJ2SFEsbO6BSlA1iqUTayYQcHW1bMZnOmM5mmGZKUob1OqBsRdu2WJewPjEgihYp5R3xWduMM1sxzUu48RclnnrqKc7Pz7m4uHhT+2abQLY75FB2yzt010J8F4Zh2KHDgDJfeTNseWcEZgzT6Ux4Lc5JIvIjTTvBGNHuaaczbj72BMf37nIc7gECQfzwRz9KU9d84vlPcev2HW7fvsts2uJcWQxKsep6nHU0VUPMoK1jsX9ISpHV8ozNekO32XD16lW0MihbEcfI6flqhwp717vfTdO0/PhHP8rLr74q8McQ6UdPzImQIrfv3mFMiYMr15jNF0xms51J0NaJcxw9RlvaWloaQpdROGNoJ428nw87GPY4CuzbaI2iSLqURERhS2//JsaYonobvmTnyWV87vH+n/1z2XQdt+7eY7Vecb5cc6grGm2pnbSEez9iSTglhOLWghqXaFfRTGeYupG5m7Eo48haBCaVyUWSPpOy8LCaSUvdNmgnEvNtVIzGEhS7jVuzlSkyBkfE5ATjBrJUF5WuaGyLcRXaOKqqJtcNuIbc92QvGzM/ei66Dq0Nzo1UI1QeGhy2TpjGYXMuXioCnacw9kMSJYB111OpgM2QXYXKiWSsoDQRwqNpHJO5haDxxmCU8PGtNgKOqUFXmps3H4ccmEwq5nNRWdfNjIgm3jlF2Zrp/hExQoiZ5VlxjkXW6L3jE/Zah5o4SZzq0d6svW0SS9s2YvNbLlpaK3KWXYZAWs3uv7JhdyglFrrGaOq6IhSp97ZtmJSLJgW+uHV4hPvQ461K7+hHQopYLKAY/LirSjIit51ywlnLs88+uwMRhJQZfdipAsQQCTGIaZCP+DHw/KdeIAOvvPSyyJ9Ez/n5OcuLC77hZ30D+/v7HF27zsX5Ba+99ionp6ecnp5RtVOmszn9INDNrLSgc87OkdZgTR/l4j6ZTGgnLW3blp2iOE567zk7P+Pa1escHR3xxu07DOPIlaOraGNEObnsPimCmsHLIN9aswWFCcFTg8oVMWjUkKmsBdIDc5rLeNTi1t1jUgZbNcz3HNVkQd2KpUKIkZiycLtUwhXofohQOwexpqpbkd1Ho1QSxeviTWKzxtgtkEZmL8M4stpsuHd8j84nNj7S6UDQDh9bcBEd9U6hvDEKQ2IcNlQ4ur7CKo/NUdSKUxE6DQGfR0LX4Vcr2ZitOxg6sSZ2PU1UNFhwM1zS6OQwVta4JWFVgn4JYyfEaiInZ+fUOlLrKGTRuqVqWzw93TDS+0gXEv2QGbOFArsnBUBkv2OZGWlryUmQbSFlQgYdhSYwny/IWjokuaipTadTSDWtVag40vUbWqcJ0QlJ+dKa+IsTcrEWPTBdoI6SXCjMXlOMc0xJJmaH8DJWUzcVJkhLrGlrmram74Q4WVUV3otPwlZYUUh9qlQ/QQbhZWc+jiMhBvGoQDEGgTZXteHZd7+Huq5E8dV7ur7ftaD6vicMmXH0RYNo5PlPvch601FbkbFvasfJ8TGnJ6c8/sTTNJMZB0dXSEozvPQS907PeOWVV2nne+zt7dOPgZBET6gbBrrB49pWpND7EWMs0+mUtp3QNI20FLRIng/DwMnJCdeuXefw8JAXX36Fi+WSmzceQynFZrORkrsM8JWGUEANzokKbYoiUIlVKMQvhyLIKcrOl573j2rcvntCVdcsDg6YtY65scQoqsTrbiClTFVVu4olpQGfE2biUFWNaySxpFzM5pRCGSuw3JxFDqgoWSglG7L1Zs3x8QkjmjEr1snjtSOpGcolTDb4ccD7kewMTkPuOmoV6IeG2oxUBEIx5dp1GpJn6DqG1Ypu09NtOvx6iUJhXYXHEnSFbToSBpXlQj6aAYvMjtS4hDBAjKgUODnraC00NjNrK1xd4ZoJ2ktnYD2MrAdP7w0jGZti4XQFUAKCCTFCjGhjdooEodgJqBBQRjGdzYgYfNalbZhxkwmaTKsjoU8sz0fG2hEzO6O+RzneNoklFzG6YRhwzlFV1ZsG9dvhulK6XPiEgT+Z1NS1o2mk4vHes16vubi44OL8Ausce4t9gPsukDmJ7hEZrYsv/WQfrQQZogZBhISYCFncK1XhqVRtKxdt7+lHz/nFipikUrJWKpzJZFo+FLz08svcvnObtqoIwbNer0QeRileeOlV1v3ID/zAD+yO/ebNx3j/t/5sUgaf8k4qH22kJ20rrt98DFfVvPz6GzTthLqd0PcDFxcrDo8OadoGaxyL+YJ3PfsuJm3L2dkZV44O2VssGMa+iHN6lNbi/5CF+DiO4ihYN1vIcsDI1yJIsOL5LYne/AstyMt4dKKezkk5ce/0TGZ7WdG0U3E6LZuomBIkkXlHRxKB1984I/uB1K/IqRUichhZLVe8dusOy+VaHCGVRduK9WbDGDz7+4e00ylJK4xxNMYRksXoCjObo1yLamYM2mDQTCc1ziiUhWljcU2LVRmTvSQtJ77wxlUEXWPaKXWaU12/TtibE8dO2kbaUk/3qCcL2vkcUzX4pMp1oyOTSCRM8BA9KXhy9qzCSE/AElmtNVVlObiiGWOmnc/JtUcNgfV5zxgSQ7eS1q82eBWpdGQT1sSx5+TeMePQM/RrposF0/kCTEXWluQasrJkJe35jMIU+ZaDWY1JYu9hXIWpajbdihQe7fby2yaxbFtg1lr0doi8hfBC8TTZULkK61xh6ZsdbHbStmLIMw47A69+6KlKItniAB5U5xU4btwxiQFyTrt5whZMm5S4yok0uN4Nz2NK4kXhRzKZtkAdd6+FwCaHQdRTh2Hg9OR0x1a/c+8YnxIf/cmfYvSe2WzG9ZuPsX94yNn5hfBYtNkx+pUWr+zpbEbbTpieL2natuyWRsbR33dzLJ9pPpuhlGaz2eCsxVkr+kVpqzJbRicFihyCqEVtE00qA9ItrHi7ATBG7/5ul4nl0QxtDDFk+mEU1d2U0bbCcb+lvAVvCEkxQdl0ZT/A6KlHy1BZ4jjSj754r0gbLcSA9+PO2MpYK2vTWvFjMRabHUoXK2RXk60jO9Hec66isgpDK8KTzqGSEfMhil6Z2gptS1tcaTmHtXNEoigMa0vlHJVz2EIzCMXaO6cowB8Ebq+2m9WiRJxzJGa5iIcUaYcRn5JYmJuMsQptRnTM4rYaPdGPRC0EzzgMxLGn7wf6vme1XhEQS2btGjCWaEaysqArWc9KY7XCaY2vRTutsm7XUtz6uzzK8bZJLEO/oakcX/NVX8GtW7e4ffs2zjmsMdTOMPYdz338p3jqqad58qmneeLxx6nqmldfeYXaWb76q76SV199lddfew3fd6wvzmVAXTmmbcPFxZLl8gJtLNY6bt68TgiR8/MLNpsNy+WStm0xxsgMJiSMrVDaktHMFgsWsxnny6V4l4welKFuJ4QYSSlgqwZyZuwHlBYhzW/5wLdy8/p1Tk5PGfqB9WrJG2+8wa3bt/jH//SfopXi5OIC5yrm1nG2XPLiK6+W5GlQORHJoAXFEr1ntlhwdOUK84NDrKsIIdA2LbPpHG2klbdFeSmVC8a+LHxrOTi6QgbG0Rf5fcvdu3fpu414w2jF6HsouH8K76VxcjptB/rOOZyxqHTZCnsUY7npJGGIf4LAzLPIr2glf9u2rsgBuZjHvkCSnWyIxojeDNLujIEQMs++5z3knKnrBmsdxlpev31XEIrjwNQort24TjdGujEwczOoWpqDA6KyrMdMPZthFnNUDhgENDCrNZOZhfWaTTewGXo2fUfT94SgORs36P4c3a94/YWXWF2cstks0drQTmYs9q+wdzAwDwrXTMimlgu40VitcVqjvClESIdVmraupToiQPCknLh9fEwIYvXd+0TvI87VzCrHaBowDqMiViNeL8bitQWtiDnR9SMhr+jGwNHV61S1AyPXEGlzicjsfDKhdpZZa6mNZuY0Tif60RNS5lHfqr1tEsukbXHWknMSfsUOZii77u1FcTad0jaNSEeMI0Yb6qqmaTRHhwdE73eWqq7ojo2jDKTl50Deeo7IrCALZGSnfxRCKKABITelJNIUrq5l11e0uyiPUVqjstkpq+5MF7P0sJvJhOkoxyUe3wFVlJZjitw7OQGlhPS1sw8uLaqCZtHWkkuvu6pr2naCdQ1ai3KzKl7bqtQX24v/VstOlRLtPlkSvB8LR0yXyjDv0G0CANsi8wLCZsk7EIR8f1mgo4/4oPFnakixr3btY0qrV0zbAmxVgFMsc4ci2KVU4bkkfIwMXskGJ2Uh+hbJIFXIfaqcZLLLtxjr0BF40+Ux3ycRU8iWMQo4JnhGrejHiBoG6HvGEAgpMowjPlrGEaoQMSiqqqZtWnKKKKN3Mk/GWrQp/kOkcnT314RSeaf0rQsnUuUEKRavlYxPQeYkocx4ctEdLChJiqRRLhf/EGRGu4VLV7Xo8llrxWcli1tlVgaFiH1uRWFNIUyKsrkcKap8j5czli9OPH7zMYZx5PTslPOzc46be1jnqOqKJ598ktl0xt7BPrPpnOlkyunZKT4E5rO5SOI7STpPPP4ExycneO+ZTiYAnJ2dMGknHB0cslwt8SGwXl1Ie1ZBVVc4VzGZzTDGslwuCxdELpghBKq6pZ3MJNHA/RaVFqY85QKbtmzeoh4QYiCmSDuZ4qoapS2HV65Q17XwZPqeu8fHbDYbVpsNWSna2WzH5fExo7WlblrZeSrNbD5jb3+PKCQYlDaM3jMGT20FZiyaaAqtLVUlGmhbZQA/DPgQOF8uaZqGpmlISdpb+/t7CKY4Mg4DQ/D4sRfm9ChJt+86amtJVYWzVgzDLuORC6VNuV5t27ugcyYX3a8UI8kPEAOkgM4BneNOFWIIkawgZtHwImWUrQWE0kzLOZ4wVpBiVd3g6rqoToh2WIiRPHrMOBLJRI9YUajSlkqR04szOpsxXqNWx7A6oRsGxhC4WK4IJrLxGmMjE2t57LGb5HBE33fSIraWup1RtTNc06CNwRczOwqTvTSvUSqJZ71KMoBPihAR6fooySzGKI6QW/WPwukieEksKhNzIubA2K8IfgAFddNw6Bza2NLW0vgYqRuDNg7txGOprhucEUPA0Q8QFQMOU0lF5Zq26PQ9uvG2SSzLi3NQivl8xmM3bwjju+ym59MpVeXKiRyhQH+1VtTO7rgbSWuctTx28wYg/hKxQJAVEIMX6RYFVV2Lh/2mI8XImDpZIMbuLrLz+YzpbMp0NuXw6IjDw8OdVIvSmpQpekdvFsMEirQEGG3QypBU3O0CayXKx8Kgj2QUMeXSqy5EtG1f2cBsMedd73536Tlr9vf3ca5iGFYyCDRORABDxKtR/OoLCU2jZAekd2WULJwQiN4TrSXGcB/SXcYpMWe2fW3hv+Rd1ZOKzpP3j3Yf+Gd6jMHv5HhUIQmS5Ac5elIMBD+gc0SnhNb3iY7GOqqmpakcTe1wGiioJ62UVO9BlLBl9iebrAT4FOWijOzWKWsAZXBWYY0V5BOgssJOZ1Q6AMN2ksfRlSu42QHTd7yDaCasR4UZl9jhAr/2hRuTZJ2UjaWxBqOVtKF1IUUasSeujEbHDNmgdMIQcSoSx0iKCh8TwQehGoRCGUgJHzOmSmTtGHOFsRV1XWO1wSgDoYcUBFhjMk3TyLquKpFg0hbbTlHGoLR4M1mjMEo8YqwxOKOpKocss8xQRD8f5XjbJJaL8zPatuVo7yrm5nX2F3PGIHpYditgt5VrT1H+QNlQV67odWVMKVmvXb9BVVfcuXWbYRgKQzeTYqCdTrDOUde1aG71MuwfvS/MX1eqFc1sNmU2mzKZTjk8OuTo6IhhGMpC1aTC/n2zHlfetZJEr6zg/EWhi1Cw7dIysChrS4IqigJZdpqJ+y2D2WzOfG+/tDQ0e3t7WGvxO9kHMSNLMcrgscw/MAZxa7nPqgcBQqQYiMEToyVGW0yXJIGk8lnk/e8nFrgPgIglsVy2wR7d8CEU7W1VWp5qB3dN40BKklhM+VneVjX6gcTS1EwaEWYli+y7yqLbl0FaaFtkoZLXDyWxoBRGaVBm58zoSsvZGltMjDWuUpg8kOO4ayMfXTlioSr2nn6GaCesRo0/u8V4mtj4NT5HskoCsClAHjGfK2AUQwHlGGprJLFY0DmibELniImeHERSKYTI6ANdPxBCoBt6GaLHhAkZtCWogG6gsprKGiqrCYMlJ7Oz+6ibhqppqJuWrMpMp25KG9KU1rGgwjTglME5IWrrLLPafujx46WD5BcltglD58y0aZnUza53G33AB89ms8GgSTFRFax3v+nQxtCUP6aeGIZNR79ek2PCGcvBfE9+X9ecnJyyuVixyheA7Gza+ZSqEqe7jOL49ITgI8OQ6cuJNpvNODw8FO5HmS3UTQ0Ux72cGb2XBJZjSSjiwKeNoLmsq5hOZ2QUy82GZbFZdnXDdCa4+HbSYp3DVY4MnJ8LWGAxn++Gpf3QkzbrgmCTxeTaBjOz5TuTudIWpp3V/YSglNqh6lwlFUoq3io5Z0KRxRnHAZUzagszLg6a239vFRC238VlPHoxKeenbISKbE9OqJwITjzsLab4M4KzIvrq+44EZeddY+tG5hDB0w+izND1ogqcQihtsAplNEmpcs4pjDUoY8GYAlcXJFYaxZohp1EG+MrjGGlVD30PQ0/MmUjm+PSUaAd8qshdT/YCVGmcJXYXAmxRCucszom6uNIaFQXTqQmibRcV2feQI5Xw6kXKpnC+prM5bWrZU/uAiEhtRWSrdoLSjo2Humk5PLqKswZjNSfHe3SbDadnxyQoJoRSsUQ0OSt8aWHLZtKUpJrRGeEQlW7COI6EsePk5JSh777Up8vnFW+bxKIfvBU/FYHtKrwdMYNmHEZ0aceYQsoKORQv1PuDOjEIkwH9lixYVyJkZ8ruO4wjSstF1llDXVUi77Kdo5Vdec735UucE77M9mJqrduxzrdDflWGo+zUSYXVLjav4Kp6d3H2wdMPgwzgi6SKcQ5t79/fCcmqrVWswXcd3oedkiuIs2NV+rsZtYMAhxDku8m8ici4a40gfe70pnae9Jvl76F23+U2gUK5SMR4WbE8wrE911O5RMp5EMW6d1f9yyVUgBpFadf78rssTPKYSCEQ/Sh2DdGXTUdRzC4blqzYkQQTMrC+j2eHLeZ/p9kXRc4eFcRRUWdI+f4x5UzX90SjSQqU96gkciqojDJaZkZKoXTRvtPF8ri0/FR5T5HHl1lS0qnAmIvWV1l/GYOzRUlClxdTmrqdoLSlGjOubpjP2p2XythP0AoG3xUFC1Ek0NZCEu6QTjKrMdbsXGx1LkrL0cuxpERM4mXjvX+gG/FoxtsmsSwWi+IOaXcX6xTjTgTROcNs2qK1xRT2vdKaphJP+GHoWS3XrNdr3vOe9zCdTnnppZcAsU/tNiu6zVq8VA4PWK2WjH5k3W3o+06ImXUtJ0ZBWbla07YT6rreeb5cu3Zth+iYzaTSuS8Bnor8fEQDAXFrHPoBW02wtqJuWrb1/vn5mXAGsph7oaVFVjU1rqrQSnFwuM84jtw7vivzGmMZB4/WmqeeeoaUMufn59KzdrnwEzS+VCVb5QHnHL2XKiamsCN1bmVthAYKVeUIAQqQjpzTjhtkSsLazpLSTuL7EYew/AyNzXpZqsuRFKIgwKKX6sNLKyz6viSaJG0kpEOQUiSMA84YrNEM/YZx7Dm5dxtSorIGZwXOe3Z+ToiRehiwfcfpxTnG1BhToasKhRPRRmOpq0oEYhWobFAq4UzAKc8EQ0gX+LFGhYGYMqvVimQS2in04NFDIKWenGQWEpHKJhsFUWGylQu2lgrNKIXKCGx+iwor9udWQzKJSEJnA/m+ZUTysaxlEYmU2aph8AN3irZZJuNHkX/SRcEiA8M44LuOfgzkDO18Tu0aFrMZ08mEyWRCCtKOXp2dkKLYYOQYUcowmc6oq/rLfPZ85njbJJYtfLVs0AHw4yCQvygqoCkllFHkMgsgJYbS8okx4qxhNp0SvCCXKifs/RQDVVVTVTWmVDy6JCxToMYoVaDCmRB8UXFVOGuYz+dM2pa6rncXVGvNbocPFOil9KqB+73s4j1RlRNlGLdQZrVLoN6H3YxnOx9R5SStKjErs7bHFL0hrzyiGiCLIIZYnB+NVFzqftUGsLN8Dp4Eu2N6qwpmO1MxpRoySu24PaZUR6J6oO+3xh51/YmfoZFz3kHrcxZTLZJUCduWmNqds7lcWOXvm6JA51UB0VCqZVfVqJyojMZogbNrraWtU9QwUqlmSJEweogDfr0BE8k2l2oAFB6lEpWNeEZiWuGXS8LqguXG0yfLJndgNY4aNY7oYSCNa1Ic6BiIWfBnoQBSUkoYY8WUWImM0rYTIhVLFOViLYDkbaUO7DoD97/AQqhOcfv1CIBhTA9+yXINKaZ+MUOKoo7s7BYrUboAYSQE0fAjhh34IQVPDpLw81b09RFvL79tEsvQ9cWh+j44cHl+Qdd19EWPq20FqlfXcqLknLl9+/YOV390dIXDgyNeefUVju8OPP7444QQODk54WDvgBs3bvLGG6+z2ayJcZQFstU7MuKw6EOg26xFpC9mmrriqSce54knnmBvf5+Tk5PC/2iLH8mAIqGVCEdsTbSUNLTLyR5ZLBZ4Hzi/uEtdVxhT7XZHF8s1w9hT19Xus3SdkNuaptkpDztbYa3j+Ph497oheJFoyYlY5FZSFtl9EaQULae6rkV+JQfiGIg5UoDTUNoBD6oZ1HWNs5bKOpm5DCNGScVibSFFZnYVz2U8eiFi1gprNKlAiI3V5SJpICmS2apRyMZBay076iTuo4XNxDS2pBiZT6coElZluVD6kW4Y8DGyWOxRt1MBn2SIPtL5FT51hAvI2pFMW3gbGaUCSmcqG1FpQA3HhLPXCOevsR4ynorhyhG68UymBrW6gOU5q/PbjL4jVpBIjDlgrcO5irZpccZSFd5bU9c7gmTyIyolsdnQCqyWVlyO91vpygjfBfledFboDIqETwVSE1SZnRqck9lS1oqYM2OI2KyoEky1WG2sVhv80LNMkaHv2NQNOgtnqF8vRbcwRjTSHkvx0dffe9skFlMEqbpOFI5TjKxXK4bCItdKi8NiSoxDjx+H3ePEoS4x9AOr1YqmqsUz27kdTHYchuJrLwZYYTOSksixxBTRRspd6ywHBweklAXrn2VxphRZr1eipWUMKdXEKP1QZ3QhZalCvNK4QoDc9lTrurqPqEoJHwNohXGO+WKO7awMWLUqpCwhLS5XS5RS1G1N7aTqWq/XDMPAZrWWasjZAmM0+FHaHp4RpQzGiP3xduAefEBZSd1CSL1PhBQNNflOQwg4Y3cVjDYC5bZJ2oBx9EQf3uSNcxmPVgx9J1V1CKgcUVlmhrpUKlllIQmiQMn58yAQQxVXRdnqFduFut5VPDGGHYLQe8+tO3fE0niywpgKox0+N0QcqmmkVds0GCvnkyl8EqM9OiWsblF5gXID1SYwZMd6NkPXU9rpjPnUMbu6j0o3iHHg1ZNbDHGkjyNWy3lZu0rms1oLedpZbKm8U5bZ0jZZppiIRTsshoGcEp3S5BTxobTaYkBr8TZSxu5mL7q0y3MhUQ9BhDP70ZckrgSVqXUBBWXW65XAkrWhMgajFDkI4EflQr5MibEXCsSjHG+bxGILC7UrYozeezabdZErmWC0xhpbZO79ruxNUfr8OSWGvkehaNtWUF7OSeJRimHoubg4p6rl4rzplqQcGf2AjgZtInXTYp1lttgjZxhGjzYWpQ0xRjYlsTjnChdELsBGO+nlqm0ClItwVZLKVlQzxAL3TWIIhlJYZ5nP5xhjGMdeYMwpFTZ/Yrm6oKoqZnNRHGhqgYDK8axlhlI0wKw1dLm033xCqVSkvMOOuxJCKOqpIq0v8uRpB1TYDupjjNRVdT+xaPEXB9FzG1HkUiFdViyPZgx9Xwb2UlEbgfiV3XlCkXbKC1prGSprs+PmiVmebEK0SFSgqjL0L2zzlMpGyXsu7t5FW0fVrKirlto1ZDMD02DzHJcNrqF4qFhcpWQWkoW4WeeWxi6o2oRtPH00qPkMVc1oJ1OuTfa4PrEsJpqUPeGnYD10bEIvZnQo4bcpMfbVSu0u4BpFTJEUgeSlws+J4Ef8MDAOHTEGVMrEGBiGviQXj1IGrTSuEVsKZQ2q0AjGJGTK1aZjDJF+HHeJRVuLqSpu3rxByjIvyglIMG1qnLmfYKxWYiKWIkPfEy+1wr54kZII4G1FIff39wExrdq2x7Y772p30ZOSdzKZCBZ9HHevMZ/Pd7vp7fMoraq6rlFaSeVQEPXee3yI5CiOcd04sLd3wHy2R9d14uFdkoTMXRoqJ0NMrRQpCynSWoOrhCvT1DXWWu7dvYePkapyO0LZtmX29NNPc3JywksvvcDp6Qkvvvgih4eHJTlWO5mZ9XrNZt0Jy7d2XGxWu/nJOIwM3cAwSCXXTGaFayNWAdK26xnHEVvNMFZIWf3QE4JntVqJlE1pz4VQYJrDyMnJCeM4Mp9OcVY+v/DStvj9R7sf/DM1tgrGWmmsBqsyGpmtZO/LBjmhUZhy3mqt8aPIumwVHFKB0qfoCf0GlRNW3/cCunrtGj5EaCco4zBVS+3k5mlIVCR3gHatkAXLjEUEIjN1XUFM+N5jY8RlUQp3xlE3DT4rzs/PSWcDyzyQwwofel45foM+jnRxxGqDM4amEmUAa2ROWBmLAQzgh54UIlowaxiSVCveE+MIOVNbJ9yXuiroThHL1MbQtlNQSgADMuIlZGmPXbkm6htoQ0xy/RiDqA9Mp1NiipK4URg0k0mLMwYjbQxU8mUmlsnzmcx7H+F4WyWW7TDcPAA31lpTV82u3N4+ZntBda4uraaalHpSSgzDsNPpevj1Y4wP+LrILSfR9IlJVFBDKWu3kD9nLYMx6EKc3FYh1ppi4VusftkuZnYaWtuBfD/0xCS7NVlYagdhnk6ndJ3wY4ZhYLlcslgs5EQsaq2C5ko7FvXWjnkbKUWCLzIdedta1OR0H0Yco5gnSXJVu4Sw/W6995jSggsh4I1l1Ia+F8JW7SppipSZz4OvcRmPXtw/JwsSSgtfhZxJYTtAp7Sat21c9abny8O354+sDeG9CLLKWCtzwJwx0wXKOpStaaqW2raMqSbi8LpGWbE6zg/9T9q+Dyqay3ub0s4KCUbv2Ywb0rhi7E7xvmO5WTEmT588zhiCsZAkKVVWnotJ2CJL48eRFAMG0BTN4xBIRftOIVXadk2XZYqrRfurbSagFAERqQ0xYwuxVNcN2lpsVRfl58RmGIkFuBOiaJAZpUUAs21wxqASMrSXZSnotWwfeZyletSHQJdxGZdxGZfx9orL7eRlXMZlXMZlfFHjMrFcxmVcxmVcxhc1LhPLZVzGZVzGZXxR4zKxXMZlXMZlXMYXNS4Ty2VcxmVcxmV8UeOzJhal1J9XSv39L8XBfJr3f1Ep9fu/gOd9l1LqtlIqK6V+k1LqDyilPvnTcYyXcRlfaFyur8v4VzLuY8Pf+gbsAQef7XE/XTfgKjD9PJ/zLYhy3q8EbgAt8AeAT365PseX8wb8SeBjwAo4B/4J8Ms+y3N+HvD/AV4FOuC58h3Wb/G4fwCcASfAXwCO3uL1fj7wfeUYVsCPAO944Pe/Ffhe4Lj87X7uQ8+3wB8B/jmwBO4B/wvwLQ897juBHwNOy3H/FPB7KND6R+12ub7ePrfyOf8W8DLQA7eBvwl85Wd53i8Gfqicsz3wPPCHgeqhx72nnNOb8tj/+8N/m89lvQEO+OPAG2UN/CPgGz/D8f2m8vf8+2/xuyvA/w14HRiAF4Df8tm+q89aseScz3POp5/tcT9dkXO+m3Nef55PezeQcs4fzDnfyjk/2q44P/3xUeA/Ar4OuSj8IPBBpdQ3fobn/BxkAfwG4CuB/xT43wD/l+0DlFJfDfw94J8B7wd+KfLd/031gAysUuqXAH8bWRA/G/h64A8hC2gbEyTx/O8+zfHUwLcCfwr4APALgFvA31dKPfvA4+4A/0V5n68C/mi5/zs/w2f9ssXl+npbRUbO918LvBf4ZciG53uVUs1neN4F8GeQc/a9wH+CbKT+2PYBSqkZsrEKyLn7a4FfAvz3Dzzmc1pvwJ8AfjPwHwLfDHwKWSc3Hj4wpdRXIhu2H3yL383Kz98F/Ppy7L8B2ax95vgcsvSf54FMtr0P/A5kN7sC/hySJX8b8BKyW/yzPJCRkWz/Z5Ed8ynw3wLfxWfZ5QAvAr//oft/CPlDnSC7hj8N2AeOLz94Kz//Aw++18P3y89+bnnOMw/87BuBv1s+513gbwBPP/w6yO7tY8AauYC++6HX/kbg7yAn2Qo5Ob7lgd9/O/CPkR3Ga8D/wFvs/L+Iu69T4Hd9ns/5PcDxA/f/MPCxhx7zs8p3+G3lvkZO7O/6HN/jGd6iYvk0jzXlc/yOz/K47wa++6fru/yX/Dtcrq+38fpCNmsZ+LrP83l/GvjnD9z/reXY9h742S8rr/2O/LmvtwVSFf3Wh9bJLeAPPPTcCfAR4Nc9fB6W3//Bcj7Un89ny/lzqFg+Tbwf+Kbyx/r1wL8DfA+SaX9Juf+dSNbcxh9DTo7vRHac58gO+AuJ34GUed9S/v0fA//r8rvfBfxuIAI3y+0LipLNfwApY78J+NfL6/69h3YoN4HfDvxG5DuYA//PB17nq5DMf1pe42chJ5Yuv//XgQ8CfxX4WuBXIRfYv7HdiSilfkHpZ/+CL/TzlNexSqnvBGbAP/w8n76PLOxtNMhJ/GBsd68/v/z3G4B3AK8qpX5QKXVHKfXDSqlf/Xm+91tFC1QPHdMulMT7kerr+78I7/elisv19TZYX0qpOfAfIInquc/jee9Dqo0Hz8mfA/xQzvn8gZ/9XcS74ueU+5/LevtGpLr/O9sH5JwjUun83Iee+98A/zTn/Fc/zaF+B9JG+9NKqTeUUh9TSv0JpdTks3zEL7hiucObd0v/E9ITrB/42QeBv17+PUX6c7/5odf+Yb6wHdX3PPSYvw38vx64/5uA8NBj/gCf546qfNa/+tBjaqSF86seeJ0AXH3gMf82ckI05f5fBD4E6E/zGf8B8Ecf+tlT5Vi+vtx/P7Jje/8XuLP6N5GdXER2op9xxvIWz/8KZDf4Hz/ws19YjvE/RHbUR0h1kIH/7oHvIiOL/rcibbDfX76fb3+L93mGz71i+XPlfJg99PO98lnH8rf5z7+Q7+xLcbtcX2+/9YUk8VV5/k8C7/oc/9avlr9TRuYW+oHf/V3gr7zFc+4Cv/fzWG+/odx/eH7zJ4CPPnD/30VaWtO3Og/Lzzokkf0lJPH/CmS+9Jc/22f9QiuWn8o5jw/cvwV8POc8PPSza+Xf70J2lj/80Ov80Bf4/j/+0P3Xgetf4Gt9pvhm4FcrpVbbGzJcbpDe5u79c853Hzoexf3P/43A9+acE28d3wz87ofe5yfL794NkHP+Zznn9+Wc/9mnO1il1N9+6DUejO9HLuofQC7If1Ep9Q2f+ePvXvfdyIn/V3PO//X25znn70V2tN/F/RbDx5H2yfazbs+xP5dz/rM55x/POf9h4H8uz/2CQin1R5Gd56/IOT/8WZfIZ/0mZLf9e5RSv5m3T1yur0dwfT0QfwKpir4NafN+d6lePlv8PKSC/07kIv1/+hyes4vPcb191lBKvRep6H5d/szzNY1sQv+9nPOP5py/B2mH/wal1OFneo8vVN3YP3Q/f5qfPZy48hf4fg/H+ND9t3qvzxZbe8QHwz10XyO7oT/6Fs8//izHs33+5xIa2QX9xbf43a3P8TVAyvL2rX5RTqAtHPRHlFJfhwzKf91nesEHBoYfRNoRD7/uf62U+m8QdNAF8p3+XmTwD9JSAQEQPBgfRdo6n1eU1sWfQVpEvzDn/OG3OKbE/c/6YaXUAfBf8sAg9BGPy/X1aK4vefOc7yEV5HNKqX+CHOtvRFBcn+l5L5R/flQpFYG/pJT642VtvgE8+eDjlVIOOOT+Gvp81tsNpLrYxvUHfvet5XV/7IGZ/7ZtGIB/Lef8j8vjX8w5P3jubdfx00jSecv4UsnmfxI5Ob6V+zsFkN3zlyvuANeUUiZLDxJkN/Fg/CjSk30+l9rwC4wfA36hUkp/ml3VjwJflXP+l+IB5Jxf+zwerpGd4acNpdQ3I73avwT87k/3HZSfv1Ge8x+UH//N8t8fRXZX73voae9F2i6fcyilDFJt/RLgF+ScH05Wny4+62d9m8fl+voSrK/PEIrP//zS5badEf5j4M8opRY554vymG8vj/nHDz7xs6y3H0Pabb8Y+H+Ux2jgFyHgju1jf/Sh4/nDSPL5LUgVBjKD/TallM05b53F3lv+++Jn+3A/7VEy8n8H/GGl1L+plHqPUuq/RPr2X6xd1ucb34+gIv6QUupZpdSvQSC5D8YfQY7xLyml3q+UeodS6tuUUn9GKfXOz+O9/jhScv9lpdQ3bd9PKfWt5ff/R+BXKqX+z0qpry+//yVKqf9eKdUClPf/WBlGf86hlLqulPqDSqlvUUo9rZT6utJG+oXA//jA475LKfW9D9z/+Qj88YNI6X1dKXXjYciiUur3ltd8n1LqdwH/FfBHtou4tKn+K+A/Ukr9BqXUu5RSvxv45UjlsX2dG0qpr0egzQDvKt/FjfJ7iwxffwUCxTzeHo8SWOT2df6gUuoXKaXeqZR6r1LqtyBQ6d1n/VctLtfXl2Z9KRnw//Zyvj+llPo5wF9HqrO/8cDjvlcp9V0P3P9PlFK/TCn17nL+/7pyzN+T70PN/wpSBf2V8vrfhgzX/9oDlc7nst4ukMrpj5Rz4asQoEOLnCPknM9yzh958IbwYtbl/pYG8CcRntN/W97v28rP/kL+LBD5L6Wky38K/H+RL/CfAQfIwOhhlMOXJHLOH0ey869HIHf/PvCfPfSYn0JQKDOEuPSTyC6gRf4Qn+t7/QSCYb+KoGB+HMGyx/L770fQLF+L7BI+jPRAl9xvgUyQ3cJnR2S8OUYEEvndCHLlf0F60v9Gzvm7H3jcTeBBPsi/j6Bv/j1kd/Tg7cH4dmQ4+iEEpfQ7c87/+UOP+c/K5/nj5XH/DvCrc87f98BjfhtCfvyfyv3/odz/beX+E8C/hZTwP/jQ8fxvH3idBbKwPorMHH4b8PuQ3vC/ynG5vn7611eHAAe+D1lLfwVpR30g5/xg2+lZ3oyW2xIWfxw5p38/kjR+/QOfYYVUFRUyG/vryFzz4dng57Lefi+yfv4cUsG8GwHKPLx2P2PknD8E/BvIPOnHy2t+N2/REn84vqxGX0qp7wNOc87f8WU7iMu4jH9F43J9XcaXK75k1sRKqa9Beqw/hGTl70RQFb/0S3UMl3EZ/6rG5fq6jEcpvpSe9xkpof6vSAvuY0g75O98xmddxmVcxucSl+vrMh6ZuPS8v4zLuIzLuIwvalz6sVzGZVzGZVzGFzUuE8tlXMZlXMZlfFHjSzlj+ZeKP/Wn/lR+/fXX+cEf/EGuX73GYzdu8O2/6Bfx2M3H6FZLJm3LE489jtEKrSRjKqWotMFaQ11XjOPAMPb0fU+MkaapAEgp4b0nxoirFcZmtNuwWi958ZVXuVh6zi8CP/wjP05Iij/yx/4kGPjIcx/mfHWX89Vder+i6zc897GP8+QTT/Nv/a9+HQfTqyyaI4JP5JRpqgYh3A78v//yn+O7/9qf5zf+pn+X937V1/DEs99EyJbT1cAH//r38D9/8G/z+37v7+SpJ67xf/jf/2YO9qf82u/4FTz5+Lt5/LFnMbMraNcCRogKCobYMaYB5xYoVTFmC8j3IQTbjAIUmYaEIiMQ/ETOmc1qxdj3nB2foLWmbVvOTs84PztjPp/TTiY8/swzWGMgJVKI5CStVKU0qmnYrDfceuUVDq5e5eDKFYgRckZV7cMs7Mv4Mse7rrVZKYUxBlUY2CmlrU4UWmu01iilyDkTYyTnTF3XhBBYr9fUdU1d1zzYUh8Gz/n5hrZ1tG2Fc46c4O6dc7RWzGYWlAalsc5hneXo8CqbbsNLr7xCCJmYoK4dWisuVkK8txayEl7h9evXsdbxysuvEEJEKUXTNFRVxXK9JsTIfN6QcmLwA845qkqOBWC13OyO2RqD0ZphGEhJBAOssTRNwziO+HHEOYdSmqEf0NrQti0xRlJKzOZTjNEcH9/DGMNiMWMYBsZxpGkalNKcni5FQ0tDWYS7aJqGEBJdNzKZtrSThvPzFd57bHV/758S5JRJKZMz5Jwf2TX1tkks0+kU5xyb9ZphMRCCEEG1VnLya00mA2q3SNTu//2LIYtle8Hl/nOU/Nu6iqpumM5muNoy27O8dzkQoyy41WbFa6+9xhCW+NRxcHjA0cEhyQeuXpGTfhw95+M5TtdobYgxoEkoFYkh4IMnpESIkXsnJ6w6z6deucO9k1OMq/jkp15gtTzh8cefYDJxnJyeceWqR7lKFmbmgQ+QUer+ZwfepNZ1f9lnFFn+lxMpBbRW8jJFQC6m++RlYw1VXWOdwxgDKZN1+eKMARI5JVJKhE3HZrXi/PycajJhOp9jtUarR/b8v4zPIR6ew77VXHabfLaJqVz4SOXcAIW1StarMXL+onbJK+VESpmUIGW5iMaYSOn+OpVzW3ZJcgz5TezP7XEp5PHbw5RjuX88oB4UWnzz58lvfi15jtyUSqQM6gGxRfl8ER7ioW7XotzuL1O9XYvlM6jdZ7n/vtvPtj323RIvz9tuEh/leNsklieeeILj42PeeP0NJk3L1aMjFGCtwVUV1hhyiigjJ+rurFKZrMqJwHZ3vb3QbU9aOQGM0XISaMVkOqdqGrJ1zPcfY753g2/+wC8ghIR2jtdeuMXf//vfx+Kg4eDKlJ/9/g/w9FNPsuwvQGkqM+H4zgWnd17jsWtPMGunmJQxKmGUp+86LlZr+sGz7gY+8ZGf4IWXb/F3/u4/olI1zWyPv/bX/wZtpfitv/mX44c1H/7xH+Hg+rO8bzaHpGUFGl3OuIzSGoMpJ14ibUUYTDk5NUAkk8gKcgoMmw2urnCV2y0UP44kY8g50zQN1lqcczjryCGQUai6QhlQFsZNhx9Gzs7OOD454RPPP88YI5Vz7B8eUlXVl+w8uYzPPz4XAM9bXfy21QzcX1MhhN2mL8ZECEGSh1L/f/b+LMiy7bzzw35r2MMZc6zKGu6EOwAEiJEAWpzZTYUokmKr2245rJCjW3ZYilBIsvUghy3bEX7wgyNsh/Um+0VvHWENEbZlSWzJbkktsjmCAAgCxEzgzjVXDmfaw5r88K29M+sS7KZkiKgK1orIW3Uzs06ec3Kv/a3v//0H6tqgjaYoS+lwlcZYgzIGHwK9D/S9dCsxQWzFCSYm0OONWaG0nOJTTE8UguFDKTAf2PPDtR1CfsxcAK8WxCuvduzQQoiEkFDKoxTjocs5Nz5e3/Voo/P7wPh+DO+P1lq6rXyvQSk53j3xvj/5PC+L4RXLNaVR5OL0dNeVZ6ewXJyf0fcdB4f78nGwDyT6vgcSQ0s//GKqosBoDUna5OEsowQkuzwp5FOQ0gaFGm/SXefwMQAGhUEpi7UJpROmrLhx4xa/9Eu/zGRmmc0th/vH9F3gd37391HKcOvGS8yqPY6vn3Dnzl2iT3zmEx/H2AIVA5/+ic9jKs35esdv/+4XuN+UnK07VDVF6xqjK4IucUT6oFkeXufnf/Gf5qUXXyW6CCmiiCgVURnrUshpRucMJpu7aJXkgKjVZRcupzpFYQuMNoAiBjmZGVuglKLrHd57nHNyUWuLMgXKGFLInUqQk6YyhsXBAVjLi7uGa9euM5svIIF3nsJWf7EXzPP133oNReKDJ/rhz6s35eH/B4hp+JoxQ9eQv09p2l6u2RDb8bCijMakRIgCKykFRaEQeyvpEEKfnnhuSiliDAznpuGrlwUiP98YiCRUQrrxII+XgJRv3nLwzC1FugQ41Pg9UpqkYxm+nkjEsRvzwaOTlv2jEjF4YvTEGIgxMNiXydt3iSxc7XqGggiX/w9576orvxMuO5eneT07heXiHNd3HB4ecHhwkAsL9H2PVRqVITHyScNOJhTW4npxGr9smi9b1MtfknQqchqCRKTtWiKRlDSSLmDQBtBQ2IobJzf5p37pl7E2UpgEBM4vTvmd3/0Cxlg+9fHAR17/OC/eus5Xv/wN1ucXfOqTn0QXJfQ9n/qJz/OJz32Kf/vf/rf5ylf/mEd+TrITytkxRtcYVZJMRVCeLmoW+9f4zKc+TuwVvvNoZVA6Yow8RymaCp0U+TwkhSW/bE3CjN+l5AtKyebWmpQUISZiSNiiJMZI77xgzM5hbIGxCWwhR6bgiU4gvQgorVksl5T1hBhhb2+P2WxO3/d4H/6Ure3z9aNf6s9xc/pBcNEwa9FD53Cle5HvixgjlwmQv0/TdQK/hhioqnwYtJakU4a9IlqDsQprtcBiMdE5qQZXZz/xSmG4+lyvdh4xBekS5H+IBFL++jAbzP+QFNMHbtgpF4XL138JyQ3/H4kp4X1Aq0gMiaSjFJYQiCkQoh9h9+HjcuaZn2cuJPJ+fbB7Im9VdeV//rG/th/5emYKy3w6pSoKfNdxdnrK+2XFX/nsZzk63Mf3jqos86xAo4G2bemUoioMSukPDCTNkwilAoxGpZSPCIaynIFWVCjKYgoYytISkyIkhcIyKRYo5VA4urjDKTg5uc18tuQTH/807719ny//wf+Dz37ys9z47Al1XWc/0xpiAz7xt/77/zw//4trfuc797n78IKvf/c9+qAIXnH99oc43Jvyyc/8NL7b8u//h/8v6mLKtJzx2c/9FMfXruNcQGmwRpOibFCTu5PiSmFRKqGIeN+Qokcj78twcyAlmt2OtmmYz+eEENhstvS9Z7drWC73qaqJXOBao1SBUQZtSkyKedxjUNpiihKlLeROD/2U9+1/idfV7uQHFZofNF/54I1POhQzXktKKcqyyPtRYa1Fa81iIXCrNoqqrqmrClMUoBQheLwP9B5MFPjJBykswwlwuDEDGakY5hT5eRAJ0edOAmKIl/fgFElREYYbfJDHVPoSRvtgp4Z8i5CBxtcy7Bv52TrmDmN4Dh+A0Pre5Q4rXRYWI+gKkOE0eT9thhiGwi3vpR7nyFfnQk/7emYKS/ABrRTz+QyjFV3XoZWisJbo/IBojRdSiPmiKuQljr8QNbTTctcdIbI88Ut54q20RWk5+ysMKcmfWmtCHpobpaWVTpGIAmWYz/fYX+5zdHSdd966z8OHD1ku97h58xZGCXSFMaSkUUlx+4WX2bsW+O6FZeMsUd0fw8Tr+Yz53hJUwa51vH/3PiZZSl3xYx//DEdKE1NAy9FNLtyMBFwODAccWk6SrmsIwVGXM4HQPvAee++xVthkIBsihCB4eN4MA2lA4EOBHOQ9ln+jjUUc7jVog/oz85eerx/l+mBRubyZXX7+B93Irh7Srj7W8BiX88pLdEBrTV0XpDwLrKqSsqpQ4w3WPXEST0mKSohPfi63LjIrGZ/v+B2kdDmfIEG62h3EJFBYZOxkxjn41ce6MrdRpHEvaQXW2vH90UrLfuaym7n6vslriAM+cImZDO9Jhgh97mq01rmAyncPP/fqe/vB38HTup6ZwvKlL/4By+WCf/Hv/G0ePnzEo0eP6PqWx48e4ZxjNp2yt1wSYiSFyGRSURiL1lc2CUhByADwMMgbLjGlFDElUkj4oAl9ZLtrmC0mzGOHLmohBxRywcqtWhExlHrOrFBcP77N3mKPvdkhn/nUZ3n1lY+wv39I03XMqipflBFMhdLw/e+/w52HZ3z5q9/l/tmWTa+pdMGkKlD1lFUX+N/9H/5P3L5xxK/+U7/Ab/3Xv8Xv/OZv8qnP/BTXjm9SFOU4OBxe5xMrQXQpd1Y9b33vT2iaHR//1Gex1lxe8Vda9a5zI9RgjKWspmhTgDL0rUebhDYGrTQaTUxJ3jcXiUFRFDWmsGCgMM/MJfaXev1ZHcvwtX/U9/6jILXhBK+N5ujasdw8taIoS8qyHGGitu0w1rDZXqC1QWvDbtvhfCDk7iI/IHJA6okx5UH2JVMqxiDXIpewkzFK2Iy5UwnxMgxFPjJ8l+FxH+OAn6GBQl8Wx0kmooQQhDgTBUImJYyVnzUUDYP8vMTlwD1GMEZTFZagFSFE2s5jjKYsq9y5eYxKaMMIMf7jiv3Ttp6ZXX/z5gmLxYLr16+z2WwI3lMWJfWkJoYgc4OUdRpaCd9bhRHofeI0poVdkXJhubotYhQmiXeRhMLaCmMKoUiiRmw2JbkAk0okJacXq0v2FocEH/jSl7/C8dF1jg6v0bU9rnUUhwdYo+TiQ5HQxKRwIXF6vuZi3eIDWBI+JrrekUxiOl+gTcHdew+YTBf8+Mc/yXJvT27uxghzk8uOQV6TumxWcuVIKXJxfs56vR6HnClEUAKIC5xhcM6NRaUoSxKKmMC5wHQm+PauadltG5pdw/nqgq7viUGGsH3fU1UldV2NP+enfvpHmTn1fP2gdXWAfLXbuLp+0I3sBxWVD0JkV/+dD4HUQ6STWahRlLk7Hm6a3scRAho/8gWc5+rjz9NK4TIENZBQLqGyAYO4JKiYDCNFFT/wNcaBvMpw27BvSMjgfyT6PFlQr1KCL+Fm/tTXxu5paPbH733yfR5gtmGuc7Vz+tO/jz/9+adtPTOF5dd+7deIMdJ1HW+/+RYXZ2cc7O/zwq3b3L1zR+jGIVIUFmu0DI1dopxfslXGFtRo6Th8vlhSGrUWPkRCjPgEZVWxd3BMVc8o65qukxOHjhBSpOl6tM0nFW2wpuKl2x/ij776R/wf/2//F/7Ov/B3+B/983+br7/9dTabDZX9CNNpxXRaZrqwpq4WVGXP3bunnG17op2hQgCfeNRtWc5K/sYv/yrnj+7x//5P/lP+5l//m/xr/+q/waQshfXG5SARNFoVqDymH5Y2QIykGHj/3fd4/PgxP/VznhQiruswZYUxlqquiTGy2WwxxjKbzimKCl9HehcIseXwWkHTtLz73h2+/e3v8J3vfJdvfvObnJ6estlsxo39ZJGK/NZv/4O/yMvl+fpzrg8Wl39UYRm+NrAvh89prcfuX+YJcaQcg+yVmOD04hwFlCWUpaYsDdZajDFU9YS2dbRtwJiI1h7vs26Ey5u2MTLYb1uF91AUMNaCJDqYkbCiwCpFZQp88vgYR6sRo4bZyWWh0SrTXq5AZcOgXTRfeoTjhjnKqKcZO/5ICIoQ5Ln4jNiZKx3LoGu8+t4KVFh/YL5yWSgHPc3VOdPTvJ6ZwlKVBTFGjFZUVYE1mhAcveuk/VVK8NUYSVpdYqHy22GgFiutUEn/mV42MeOwopI3bDYNiRJjEkYrTH5IqxR1YQcBccZLYT5f8MZrH+bv/Av/Ip/4+CeIMbK/v89kMmUyqbHG4J3PF6zhwYNT3n33DqePH9NFw+HN6+gQUN5jFPi+5w9+/wsc7s357/3Nv8UbH3qNvu0xKFEMG0tiUEVzOdvIqsjhJIY2JCybzZYHDx7wxd/7fY6Ojrh98xbTBZiiJHhPcDJjsbagrCpOz845O79g13R0fc8//K3fpmkazs4vOH18yuPTM87OL2jbTi54paXIJ/LmEpjs+Xr61p8Ht/9gYbmK9w8dyiVLK41DZjfMPVEEL8N0rWUIXlYaa7VAuHnfFLYgFonCDsf++IRAXZAIUclXZcFW9ZevY2jNc3djzeVMRGslxJakSXFgTA7PJetjUu6M8mNdJWBJF3NV8OlJMeG9kASGf5ufci6E8U+9l/ry4cb70aCD0YA1irKwNFqPBUReW5YTpNySxaszpad3PTOFpSwsKSWs0ZSFxRiN946+l8KStMr4qlxERVEIPgmCuaZLOuHYPud1dfPILzVRFhUhJlabFmum1GWiqBTKZswUhS7sOO2LJNAwny5YvrbHxz/yyfHC2d/fJ6VEPakhRVzvsFZhlOHRo1Pef/8eZ6dn6HrGYjbFNw3eO6zWJN/z5S9+mc9+5hP8zf/Zv0q/bWg2W8GDiwKl5fQYho5Mi6o5Dcc4GHdlwrDebHlw/yFf/P3f54UXXuBguaSoKuppJGRxm8kag7IqadqWe/cfsFptOL+44Nd//e+xa5pMgtAo5LSaEDjQGIMtiiyOC6Qnbg/P19O+Pkgj/kFrKB5XUYCrFORBqT44OgQfZa5hwFpFWZlLcWUuPoUtSDFRWJ2px/ypwmIUFFZTFsU4O72Eny6fnzVXBJVKZhopKqJWqExPNvlAaIaOLVcmhVggDWDWoIAb6odoVBLB+yd+pkIKC0ogtKvD+uF5jFLHK0UlxoBSYLQQkbQSmvW44jAbjpcEA57+4vLMFBat4f79B/ze7/0+X/2jr/LNb3yTX/zFX+TmDUkAlVOSG1vrUXh0ZXgPl6euP2vFGAkpobBC2TWBwpg8wJOLp217OXnVl+qMru8JMTIpK2JMNLtthsc080mdsV4FaFRVQRRO/ed+4ic4ufUi/9E/+AP6qLCx5/Gjuzy88z7/83/lf8zHP/oGNuxYzqfErqMuLdPDvcyK8ZDsOCAd4Ccyi63vO3kN1gjlV2nW6w337t3jrbfe5FOf/CS/+k//ElVZAInddsN2veHayU3E3+iML33pS/xX/+A32O4a2q7nwaOHuYgZlNZoZcabitHDppfLyhgjm/p5w/LMrquHrqtw2XDNDQe4wTdLGIW5Y9BClPFBbtwxCAKsrhQmgKgTA6Mzz8yJPt+o801WGYHBisJSV1W2CpKOfBjUD11HYY3M1V3Aoihye5K0xuZb/giFKUVUcvjUclrCGiHxxDzkH3VfJHwIxChU6AEm+2Bxu8oiGwqkzE9kTjnMfYa7kDFCNR7ey6tw1wCH6WeMsv8MFRZN23a89dab3L13l7OzM9q2fQLLvVo8xgFgvoifrCWXG+Vq+z5uomFQh1wARqnxBJRSyvx4lS+MfDoRNRcGDQRiCDLp0ApbCMD6+PEjrDEs95agFCkqrh0dk3TBCzeu07jI8d6M9rxiVxe8+vJtPv7RN5gXCULAtQ3GGMqyoGsawjgkvLzoBmcBea5RLCYHSAxw3tO2Hffv3ePshRewRl4fKYmoK4aMNSe8czx69Ijvfe97NG0vuHKMoDTKJIRjL5uNlBjAiyoPZYff23C6fL6ervXBrv2Df/+zhvYfnMlcpR0P32eMfqIr+eAsOqY0KtvJ+yxcudlevbTHATvSYRijR7PZyyedf/bwHMb9yQgJq2FuwpUB/pWPAdVQinHPK5WFxypeec758xlKe0L3cuU5DcUlMTxOeuLnDWvQyIxeaFdf1kBeeAKSfN6x/NDWZLYgKcV7d+6xaxrKqqLtOjbbDaUtsEVBXddorfC+zyd6MFQyHKyEyhf6joAICdt2hzaGWT2j67qsjdEYbWibHVobSmOzI6k0skrBtGLoacdT0rSsSCSSdxgS86rKoKtHRTg7P+N/+2/9r3nxxRf5N//N/wVFUWFsiQuwN1/wf/7f/1tEBUVhabY93a7jxZuHzIpEaDtUDFQpYJKHpCh0xCLeY1GR2/wrW0ZBNakJwdN0O8pSTCTrespkOhPM13u63RZjDcZq9hYzSqPZbTcYW7BYzEgpsFpdkFIebCqBE/TVzi9DcS4EOu9oupbCWKwxozju+Xr6ljFmhGRCEJZWVVXjzASeLCaXDC45OFRVRV3Xo9Ovc270Btvb26PrOtq2xWigABNBKZlTeB/xLh9FCsP+cknbNjx+oCBDWV0LgVGKhu8SySdMilQWYgHuEiGSlaBtAgqoDPjk2Vys8+A8zyiAwTdSOgHZx10nkO6klM5oMpnm167Q2604oPuA0Zq9RTWWgLbtpVurBAZ07nLIXlVysOpaf0WTM+ht5OcWlbh6tF1DDE7mv/nB45O1Pf9OnheWH95SCgaRnhI31LZraZoGMzMjTvqk3ykjW+XqzU0rRcr2CSlGKTje453DGJsH/NnIRYEmZtgpm1SqPEGLjkFyO5zIxg2prxyRENLBi7dvcnL9WJgo6vJlWW24drAPSqE19GVPP6mYWIWJHpEJx+z1lZ9L9JliYnJnlR9z5Cmq4S1Dm0uzQGM0RWFZLhbM5zNsNVCpU56xOJSGGOUGQkoYo5jOlhhT0PaiH/AxEZNohhKCp2s1XE5COx52/POO5elcznlSklkYMMJYlx2LGEkOsNZV25arg/wftAYx7VU2k9ayL9KV60IrTWGlCyclFvN5Vs4n+lpu6mLgmAgB9pYLloslXddTlgUuCNkmXNn2KYJKiUIlmbGMdGFwIaMURqO1QFDSiSRaJz+3MEnMbUdxtcx4lRp0KIa6qq68vjyEzzOc4TUPc6bhvZPXL+SDsiykIBFH2/6U4nj/unp/uPr3Yf157Hh+lOuZKSwhJoyx7O/v8/jxYzrnOD8/59HpY4ps6d45J0wTrTBIsen7fiwqWmtp0TNLxOaBf9c0kp/QdVhbYG2k0rndJmGSg9AIGJrU5SDNk+NMhi5BZbaZFCysQVkDMbCc1fyb/8a/jrI2z2YEfrI5oEHlk5QBVGxJfoNxBSaabBKJ/Bs8uI7kusyAiyhtKUw17NzM/4+gxN5lMuTOhEhhDbNJzfKVF3np5ReYHR/kuYxiu12xuVix3D8ihsRmsyYRmc4mvPHh15nNFty7/5DNdsvDR6d0bUvXd0ynUwpbUJU1KUX6viM4iQUQW/7nHcvTuIQeLn+v64q6rui6bpydOBfYbnsmE7kRDjMA59z4GMOs5SqsfDn8F2ag83LytvkSTTFitLAHS1swqWsm9YRpVaNffHGEsT7IQgshsFjusVgsWSxnkqs0DNWvti1ZsBidl/lGnrmmJL5eMg+UA6SxdoS4ml7iOJqmlcNaJgzFGJlNJ7nIytyouFJYrNX44HHek1KiKMgdYBgFk5OJdO91XYsbe1HSNEI8qorqiSJ2WYSzIbkaLF3iSD542tczVFgitiy5fuMG9x8+xFjLZrfjYrXm+vF1sa/ue6yRE9Aw0btkHIsTr8q05BgD3jkZRAeZFJaFobAWow2u2+JHT6CG6C3ltMJYI5QSVKYAikElGPEaC4FEkgtAiWQ49hIgVNRilRLbHTFoUanXU/re8Tu/+7t0XYNWgcIkSgsf+9hHONjfB1XKY3sHhSZZhS4GGwnpDJKXASea0QAvpR6lFUVpiT7gO0dphCa9Xj+i265QzQZlCxIaq4SVozX44Nm1Lbvtmma3pW0byrJiPp+htGbXNIjDqyfFgM+aoBQjzvVoJUK4elKNJ+Hn6+laVVUCQ9eR6LpupOlL8UjMZjUQafOMTesr1j4wwmhwqRIfvscYIzfdGNEJqsKCEmdgGNBkYSOuLs7RQNc2BC+PaY0RdCFe5gQF52mbhrOzx7RdJ87EKK5GXqWUICZC764UFgChCaeYxI5IazHBjDI/aTsh4JBy3+DUpYOxH1ybDSEawUaSUOm7vntCx6ONJsWYh/cyjzXWjJC8MTZn0ECIIo0w2ozUswT5APxkVzKwygaX8qd5PTM7PkRx3b12coP5W2+jjWW7bbi4WAudMYh4sizspSJXeMFyMccAA0sjyoZwfU9MUfjx1grN1lo0CtfuIHPao1ekXmGYossCqkqOExjGt1DlKV2QDYlW4GWgH9odMSXKyT4k8Nsd3oF3CqMt7a7hd3/jv2J1cQrJcbQ/5ehwxss39zmYV2AQhXzXgrZQFCib6dNRZi7JR0gKZTTB9cQYcH6DsYainBJ9j29bSqupK8ujZku/XZOaDamoQBmsjhSFQqtECp7ddkOz3dLudrTNjslkwmy2QGvNejMVS/2+z9bhET9mVHjKoqAoRX3/PI/l6VxlzkUxRtO2kqxaVXIQaNsWrTXTaUXTdOx2Ld47jNFMp9MntCyXoXuDe4Me0QFjLdo7YoKytKQU6fqA1mnsXqJ3UliUIvpA13W4rhOGodKSVJqE0t+1LcVmw/nFGb3rZR+qnNFyhZ2VYsJ10nlctRUSwa7cGLSWPJiYX0fXS8dRVZVs5ShklRDiCLAXRYEOmhQDIYmYenjMgQVptCaKQIaYMbph1jjY2KhM3okx33uyiezQQg5Feei0xnsal8XlaV7PTGF5/+49ttsNy/196ukUbSyb7Zbz1QVJSffbtB1VWREn4v+TAKuzb48ZRFwxhxE5YhCMWaFRMaK1ZrM6I4bAtKgy1z3hm57QOJKvKEppg1NSeJdQVChVopRFIaeSnJ5K73Z0rkEbYcM/fPA+Wlvqek5dL5lOl2grCuSPf+Q1Cv0qr7x8A9eu6Ls1Yf2I+9/fUNmFMFNSIupA1F5EU0Zj6yneJ1Zbhy3m2GKezSUjnb+gKAw6zHGtp28cL54cMjUf5p/4xOtcOz6i2a7ofaBznvPH57S9Y73ZYsuK46MDDg6WLBcznGtZXZxxdnEh7gTBYQvDbD6l6zq8lw4QwGqd8ejAbrel65of4ZXzfP1ZS0R+ib4PWKupqkpgIKU5Pj4GxEV4sZizXC5omt2lMBA5nQ8n+qFbkQhfuXGWZZm1LpqQIlopfATnQBcKYzVF7mxc12O1xihNcp5u15KKgMnhVkorOdU7jw+R5D2EiLKyv7XOuagyXsyAgkYrTWmuUKAZtGqIDkub0XkjGHktktuS1fU51ZI8wxyEoCGIJ1nkMphLqAbiBjCkYQ52hD54tNNjwZbCIsVCoMQ4zmoAirKgLCze+ye6wuF9fz5j+SGt07NznOtzGynS2q53tG03TrW8D1kNm0chPElxlCXdizjyiv+DKGXF8qTZrnF9D9UEa2RwGENDjA0xlNjCUFc1MULfBbSq0apCUaCUoahFs4KOdG5H53bYQtjz69WFmDkuEoWdYI3ocbWC4/0lk8rw8u0brC40q/MO327YtVucaq+Qm3uicllcr7CzBb1LnK0abLmkKBYC16lI604pC0Nyc3wXcW2k0JHltOZgOWU6nXJx9pi2czR9z8VqS+c8URdM50uWB0cUVk5OpIj3jl3bS7pfhhbkhKpGQoJs3ss4Yu8dV/bE8/UULbF2j3kWIN1GCGLBM8CXg9u1MQbnRO1+tbBcna1ctc4fvi4n7yAzRK1QUWUm5VAQ9OXgOkmBIImHXdKBlGcKKuW4ixiJIUgHn/40fTdlSi+ILkW2SZ7VAFFLgNhom3/5bIUa/EEKdrr8HjXQ8ocuYlDk56/LsP5Pe6uldDnkd86JhkUbIRZoKTARxvnPAN9Za7Kz+JNRys8Lyw9xfekPv0JRWGbTGZumpw+J9a5hvd1l8ZOicz0hRchdiiLhXU/SOs9O5BdJFl7VpRW1fox419I1gT/5zrc4e/yY2DaUhWZ/WRPCjhAbprOSsrBM6gkxJJpdj9FTjJqiKNC6YDZfypwjOapZQTWx9EGw2857tC7YnV2gX9Asp3vQ9+i+Y1EaXL/ju1//CrvtI5rtKYf7S6y2PLyzomt7drsGWyZsBU2/w0ePp6BzkYtVR1kuKcoFPnpCdGy2dzA6MZtV6FSgYoHv5cYhwsWcb5/V+tvO4UPCU3By8xbT6Yz1xSnb9TknN24ymU559PgxzgVxdU4p55PLKa7OGRyD6R/kwe4P4kw+Xz/ytdn0lKXl4GAx7oODg3201jx48ABrLXt7e/R9z3a7HUkykoUCVwf1Q1G5HJL7y7lD1oIVZYHWnqLoKAoR0xbWYrWhLEqsNlS2wBcdviyl01DQ7nYyMLd2TDRNwaFI6Ji1L3muMUb5xkT0XqbgJmTdiRYsPHdZJIVKIadKXgo2bSEiRWGw5fhyI3T7mGnC3l/OiWxmXbogHOarJpTWSiGwRg5nzW5LUZTYomA+LwnR0nbNSD+OIWCNzKPKsqDvXe6Qng3zyWE9M4Xl4mJNVZVoY0WQp3TOa5BWm7GqX+lSnvhFDHz1zJgaBuwARFSS7AXXtTTbNevHj6hLQ6H2SLSk1GJ1BcFS5LS40HuJVh0w3AQq+Sx5Ceik5dSUvLCrqkIgM52IrqfdbrDGkrynKsTE0tYlPqzotoHdZoVK0De98OeV6GJC7+mbDX2Q7iJ4UDFA6MF3uG5H71ra7TlaR3AWo0qMqoTBlsAjJ6+QIkkZktKs1jt6H8BOWO7t4b3Mi6y1HBzsMV/scef+A5SWqGKtDcrIXEppjclMtxj9kyes/+4vj+frv8USpleeC+TohQHaAulomqYTOn4I2WpEOhOhIF81Qb0UVQ5EmnE+kCnpRmX1u9F5KB+JPhB0QhWV6KGcJ4YIIRLVMCuVU3xhrRSrPBDX+WPoRobdrEDmLgzziKv580qKhbpMkB0Y+urKg0j3naUE4/dmttkAj+WVFKDTE9f5UAQuqcY6s+QC2gRMEtskmxL9djMezoaOZaBiM3RFV57Xs7CemcLy6PEZdS18xd4FtBEmU0wSLKW1iL1iLhoxgU5J2m9Fhr4EBoshEIMfi0zKanNjNDF0tM2ad9/+E+aTksXkBaz1WOvR0WNSgVWGZBQUUBeaqiwkTtgUzOciMENHTAm6TJTWgDbsH10jRsNuF4ndjsd33mOx2Mdow3xSUcyXXHv9Nne/o7jbnfLu29+n2e5YVtepy5rl4RFtt6JpL9iFHu17ylpDXTCrJxR2irVTHj5aQ2ypaCB46BLGTCisR1GQULR9D1pTlRU+RnwMnJ89Ytt0TPeOaNstwfdUhWV/b8lHPvwGh8fXuPfwIU3X59c6ZzabcXh4KHh6HrxeXFyMqurZbPKcFfaUrsPD+Qir1HVNVVXcv3+ftm2p6xrvIw8enFIUmqIwbLcNKSlu3z4cC9GA/w9QzwD3bLfbPyWotMs5WinqsiKFiO8dLoooeVaKs2/fObpdg+96ovMZeVCUVq7xFAI9YK8M7cWzbgjkVjLjSwJ7DbTmsbtKiaAiLokYcoTM1ZDhMuK8QiYg39QzM83nAjsYfgyMUz1weVBXisRgayRU46Hg6jzLGUgQZxersbtLaShqwkiNMV2BHofC8vR3L8/MjjfWgtJ0vSOmKHOEUWguJ4rL5lSTklzsNmOZMc9VUgzjZnB9j3c9bdtQVSVVWVCVBZO6xKiANYn5tJITllEUJqKVg9ihksYkKG1iWhsKU2JMxWI6QRuFNuBSiwst1iRha/UdShdM65rVqpFcFJ9GtbNJibi6wPieqrTcvnVDnJD7KSRF9A7fd7iulY7F9xRlkU84BkugIDAtwCTDtJ4RfUvfbiltoDSZHqw01WIinYq29F78va2Rln05n1GXBbvNivVmxWp9zh9//WsslnuCs8dA5wMheLbbDefnZ2it6dsOHzx91zGbzZjP5kwnh0yn0x/dhfN8/ZlroA8XRUHf92OXIfMUidRdLmeQZ5BFIT2AtWZU5w+F5CoN+YMDfRCoyfVuFACmFAle3DG0UXKTjYmdj8IGmyRhdSYRPRfWUpcVbdvIDZbcKcRLy0eBk7LlUO6ehzXQoJXOEeQ/YPo6dDrWGhKiYYtjhyIW/gY9ENHGnzv8Y7GxyXMiVEbdUmbADdZSl5qcMY8mz4WGzkQ+5D2MWQox+pLprNl5yuHlZ6ewFAVJqcw1lwTDoUVNeegmv2Y1XlSySSwqCQU2RU8c2/qA73u6rmWzXqGZUxXmSmGJFAYW00oUtTphjEcRIPWoKOmJpYFpZSmLksJWzKdiIaMtbNoe13hsYdAaguuwhWIyLXn08JSH908pTMlsPmcyUegQiBcXaOeoqoL95Q2M0uzOIm3TcXF6RnA9vm9x3Q7ne1RciCEfgULJx6TQlNpSTWa4XnHuV5QmUtlE7wNJwWQ+ISpDGwAdiGRVvtUsFjOqqmC7XbPdrNhsVnzzG1+nqiccXr9JAvquZ7e7tAIJ3rPb7fIgV3Hj5AZ1VTKd1OzvLX+k187z9YPXVe1F3/d0XTcO3Nu2pSgK9vZmY9EpS5lVDFqX4QY5mL/+oJTDS9sf6F0//r9EXscsCTDMplNSSPRNiy5LCq1JeT4XY6S0BVVZSvcBmfWVxC8vMM4oEhFl7AiFceV5POkWMEDj5DZgHNGPCbOJRIiJIX6YmKR4JMAwJqfG7NUy+KMJ3MZYWK76EQ7khOF9GxzYR4Qr14uhmA2HYZ2LClqR/JNQ3NO4npnCopQihsim2dDuGmmjnRPthA8kLRkrNg/KxJBF8llE0+Fyc2MwhWSx9/GCddtz99Ep296zdIGLbcum7emcI0TPYL8VE+JtpMiKdoMtaurFHvvH16lnxxhT4tqOPkWSi9hyyt6kwkdHIpKUpSin1Mt9Do4UwVnm0xqjEo/u32c6KVhMrzHoY7xXJKWppzPqes5isUfiFokeZYKcnGxBCEkCknSN1jXedygVmM89FxeP+MbXv4oKBhUt6ESICu88Pnk6HzBFxXI2YzaZCo269/RtT987PvpjH+Pg6Aa6rIgJ7j06BTTVZEpdVVn3UKC0/H6Ggl4WBWUh3Zl9Hk/81K6BIlxVFcvlks1mM7pVpJTYbDbZ+LTMs5VLJbwM0j1t6yiKcnwsYw1FYbKLRZGNGqPIiJXCVhU90MWIRlEVBXuLBa53nD+SriOS6PqeFCOzyZSqqqimE4pdhbYFQ7qk0LtguDUrZPan1UAkQHRecvq8bAnIf6TEGFqUBrPaoRtIY+fggswNUSaLIE0Oz4uELP+fF/VYXLxN9HiGYb4xFqWkO5SiGmiaZuyk4DIqPcZBua/Gob0o8UWn5lx4Xlh+mCtFSTwM2Tph8PeKIUCycnLXeciWDyUDi2M8oySBjZKCxnmazrPrPLrpSaalcQEX5CQUUhK6oxDpSUHEVCFm/rutsNWUcjqnnM1QuqB3nizexRaWotTgOmIKhKRQukBbyfueTioUieAdfddR2Nw6K4O1VcaXNbYoUWjqicbYiLGJamIxRuETeBfY7nqUKtAUcmpTkcUiYqxl//Ae3c7RNwGdIkRh3MckvPmiVJRlcaWFH1xnNXt7+5T1HF1WuJjYdo4Yoa4nVHVNXVUslsu8YS6FqTpjxMH5P0W/fL6ejjX8WgaI5mo4njaiBB8gMQl/s09oV4T5Fccb5TB3GXQnw+DaGA1Rhu82+2zplCDkwlIKASR6P5o8lkVB17aEGMXXyxiMFbV8AoG7FNkkbBjDp8tGRA3EY4HGSdmE8kp643AIEt7xJU15eHPiEBw4kBBSwhppHYafOl7ZStiQWhkyEJdDxPI9J/uzKKVRKqHJHm0pyetScgC+dAq51McMr254eleH+U/renYKi0uZDdWiYqK2BduLFedK4Zodi6rIWhBLjN3o2dV1HbawLA8OWa03rNYbiqqmd4nvvH2PrneYyQEPdo7u7Iy2VbSqxhlLr2DTdUwmNdVkOZrZ+QiqrDHLI/TeCXp5jU5ZUlKE2VJOblZUxo5AWYnJ42azIXhDd94Q2h5S4MGD9/Dec+vGdcqqZLftqOsDlvPDDDEFttsW0JiywBaSvrdzHdFFUfIWmvmByZGqWQVGok0t0+NDfvpXPsk3v/rHfOtrX8dONVYpTOpQ3tHHHUVRUJQVq4sNj89W7B+9QFXO2FsecvH+Pe7cvc/tl15hNply49oJj09P+fa3v8njx485Ozvjc5/7PEeHhzx++BBrCw73D7l18yY3T26yi7snog2er6dnRaDpetbb3ciCKgqJvK6qmhCjQGQZHRD3cM12u6XvPZtNg1YRq6Fr2ixyzIF7zhHIcqskzMIXT06Y1DWL2ZTtZstmu4EkEFJwPdvNlkePz/jYxz7Cxz76EX7v93+PRw8f4RUEDRhD5wPrbctiOacoLDHPhSAHijlP69t8AzcYW1LXE7quZbfbUdcl1pSk2GaiDzLgt5Y++CyqBhcim02LLYzEXgTR3kzmU3oXeHy6HQO9JpWhsMJS9b6n7zqClxjk4MTgUpOTNfvAZDJhMpnw8OEZvXMcHS0IUbzFrBX2v3NONCxGoyI4H1ExAQKL6af8zv2UP73LpYbZCZIvXxYlKmb3XS30xRiF7RW8B51PDZlj7kPIhnWab3/3e1ys1jR9IERomh7nEy4oXNL4pMVXUku3EFA0nccWIoIMSVPaCYuDa1TTJRQlISgiiaCEpWK0FJYUNUkNtExDSjpvJkNZWspSbPmrSozolNKkiBj3BUVMGm1LFIqoNCHpnJZUiBI4iYGkSvkklzFipSD6BNqgzYRIQR8UAcGMjUpZVSznIa30CF10nSPGxGy2oCzPIGm6tidhmEymzOc9i8WC8/Nz+r7HuY7edaKJcY7NZsPp6Rk66VGh/Hw9fUv2i3QeRos5a11VlFUpDhY57XTQhxRXfMS00njnybwpIJ/KB4RACcLgnZchOOD7Dq8VsS7xvsf1HYv5nLIsGQwWJ5OSqiowVmOtwZaWyXRCPakpCrFFSQNENVjPwyi0jJmFJQSebHZZFKNx5sC2EpaWH4O7nBcXWKUgePmcGEgOlioQIvRO1PhVXcj+yUSAGC/hNefEZaAsDD6mzIxz0t0F+VpRWIpscjnAjgMcJ93VYKv/7OTcX13PTGExymC1zQ6hE6IPuG5LYSyTusZYw26zwmpFmX12JH+kJqTE+XojXXNh+bv//n/Ad//k+/wLf/tfRGnLu+/fo57MqSYz+mToo0BMyhYs9g84v1hz/vic2XKPoqxRtmA5PeDl138cY0qSLvAILNDFICLMpFFJoCyfZMOFoNBojC6o66yuNZoYA7P5dGTV7HY7drvdSJGczmYMTs0uJvCB6XQmQ9a+ywpqf/n9VYmxlpCE4nhx1rLeeHYdONeQkmdWQ4qCkQ8Mnv39A2KynJ6t2D9y3Di5xePzLVX9mNOzC7TZcPulF5nO50xmU7TW4/NMKbKYzwUnPz/n8cNTvukj+3t7z73CntIVB3uWmLCFoapKrl07ZrlYcHx8PN7w+q7D9T3O9YQgJA3nHIv5BOd6XJ7JXJpXRqzReBdw3mO0dBwP7t1hOqmJ7pDz8wsuLlZc//jHONjfZ7PZUZWal146YTIp2G43GKuZzaac3LguPnWLGVVdYIxYpERy4TJGPLwGyK4Qc82m6SSnaVITgsM5UbOL39kE5xybzZauC/gQmM4LjFHsmhalNZOpFWeCEOi6RO+h8xvqScn163s4L6/v4nyH7wLLWhNSou0i82nFfFrSZ6Pb3WYjj5Up1HVZsFxOcU6KehzpxtLhDIr7GMIzV1TgGSosIcoJ22dDOK2NDA77XnLeUbS9YxqjhFFl0V7biwXJQElGCeUwxMQ7777HdDZnNp/jQmK9WdGsLui26+ywGnFOYJyiKAg+YSy8+tIr7O0fEFwgBgcqZjYa2ZE1Uy+zyncgEPTOkWLAuVIohFpTVuWI43rvifkkZqymruucDwMpyCnNFhZbFHjvcK6X15RplnJqSmJXnyIZG0ORWMxmnFy/ztnZQ5xrmU6tUK07MRjs/Rnb7Y7eeRaLfepJzXbXcLFac3Z2hq1qbFlyenbGxeqCb3zzG6zXK4HvdjtijPRNj2TDGLquo9k2WGOpqudQ2NO4PvTKy4QQ2O0aBrW47zvWq4jru8z6EsFiihGlxRlcbpJyU/U53GsylcF19BLDO61mozlsVRYU1rA3rSmsZVJXrJTB9UJB7ruW7WYFKOazKXVVYo3m+OiIxWLB/p7M8IrCSmHQipQCwcu+AtGpDSf84XPBO7xRONfhfY8PDucUIWpCkMH6dFrjXMD5gEpi9TKpS/EACxJG1rvEdFoyUYredWglFOveObreCwJgyFHgisO9OSEENrsOo0XsOJtJEXF+Tdc1XJzDetcRY2Jvb56zXPIsJZEp0fnvPBmD/Cx0MM9cYQlRbBaU1vKL7fJATyk65/BRKBTaSGHZbbfCTR9OzUqhtXh3vfPuuxweXePV1z9Mv1qzXq/YrVb0uzUhStva9xLmVRQlLiZSVLz80ktU9ZTgg7C90BgrMJkQCKQdTwx0Q3ks1/ekrBEwebhZFgIDCGQUxe4e0elMpiIulIyMSCJiraGuK1arFc456QaS/AwZvGcbm2gylVEKy3w+48bJdbp+S7OLTCcVndGwWrFrW9ymZbPb0bnI8XJJVU/YbHesVivOz8+Z7x9Sonh8dsadO+/zhS/8AQcH+xweHrDdNTRNS7NpKIuSw4MD+r5js9lQVbX8Tp6vp2596JWX6fue1WpF0zS0bYvrO7pmx+njR1nQ10k8d7Z811qxWa1GCMrnA9h0UmG15NdbY5lOp+OQfzadUJUFB4uFJJeGgFGW4MD3jq7t2G42lGXJ/t4yC44Vx0eHxJiY1tO8x8U+5dJQVtyDRQPiSdlVIuXoihAcwYPr29xtOZwHFaRAGqOZTCqsdZheqPgxwmwm86Vt2+F9ou8Th8sCWxrOL3pQaZw9db3LERHg+o66LDnYW3J6sWG1aZhPLWVRsJjP6fqezW6N61su+o5dJwSZg735GLUcx+IyiCdkDUF+Somx5dOuwH9mCkvnHT546QyMRRclfUgYF1G2RNmSpC1RaXxSrLfiqKvEWY7gAj4knBcrbNc7vv3tb3N0dEpZT/Eh4ryn63uIiQ+98jqLWvPwwWOqekpdT/nMZz/P8bUTZpMZShtKVWCKElOUtK3DhyiskDzzCQnJhQgiJpQbvqbv7WivPTBvvvu97zKZTHj1tVdxWTdwfn6OMYbZbIbNPkkhxlFjYK0dYaziCtzUuR7nHFVRorWmLkqODw6ZVTV37rzLRdtxTocxmmsnJ6zXLRfrlogmEilKiQW4WK0JEerJDJSm6Xre/O53uVhdUE+m+XMdTdNitOHo4JAUEw8fPcLqkoOjY2xZ/gAp2vP1NKxvfeOPCSEHs4UwpkWmlOcMKeJDzuhJAV1adBps7EVtbkhiNZcCRCX/nwLkiF1JcExYDfNpDSTaZsfh4RRrjphMLMYm9vcWWGspCg0EvOvwTg5U3eC3ouTnTKqCQZ4YghSIqioZkicH9/k6R/4K/OvQRhAHpRS7nQMHPsdcyHxH8pJ22xa0oioLwKN0QCvpZvpWhutlBYWVvJiuk4yX5WKKVoq22eBzJtGv/TO/yu3bJ/zBF77ArmmYz2v63tF3jl3XEWKS/CifKIwRRmUKqEztNio+4RCg1OBv9nTvqmemsPgcxjNAWdoYUlJyEamcnKgUITMourYlxsB0Ns3mcykXj9w6k9isN9hCTv9Kyy8y+CCss3pCYRNt22NsDWiOjq5xcuMmbba2ULk70YO1LzzRzo50xvxnSpdDxyExEiTGd7vdjP5LKoctiJBTXnfKDz76CWX+u9iSK4rcIQF0vZjZkTNbNIqyKFDTKUQ5bYXgKKuSoq7GsKSqrlEFVPUkF5YVbdcBejTRfPz4lKZtBNM2AkE67wkqgtbEIAl804mlrgvJs3jaSfd/SdfZ47NsDy9QpQIR8yqh7euk8xBaUxaaqpTheZ3hW6WzHFlBXRaiWM+deGEvNS+VNZTWUBZCaPHWMJ/VWIOwtKzFzKQrKsoCY4SSK55+4kKukLyVsrTMZ5ORfysHK+mmRkPZmEgRyiq7UlgjdGItkDYwQn+yf2TfGi3uHil5VJLuyBuFGQSYQZ5SVCKW1EqhrMF1cuAtCgsx0fUtWkFVWm7cuMYLt2/yx5OKlAJ1XbLbNXLwjEFC0BT5Q4sfoFZyD8iRAWn45eR7jFZPv134M1NYEghLq6rR1qJDga0qdGHpfER5iUC9WO9oO8/du+/RO8frr7/GdDplPl/Qu4b1ZoexJdPZAlsFrLXcuXOHejKlnkzwvQPX89ab9zlcTPixV18kRU3b9Jw9eEylK6bTBQno+p5utaXrPdVkms0oE1EpyXTIDDWtBGct86Ypy3JsdxMyOH3t9dcx1tB5UTEvltUoRDs7OxORldYs9vaYLxasMiPLGnOlXZYBamkLgjZjJGvbNKPS9+z0lPv37tO5NYlE1FBWC6p6wef/yk+xd3hMYMKj03N+47d/m23Ts+scZT3Bx8j5ekNKkel8wWIxZ7GYc3F2Tt+2vPf++5LOlxQ+rNk1Lc2uHTPVn6+na21WTs4/EcpSPvYXc6bTCceHByJyzfCXViLOUyC+WVn4V1yxd0+ZVpyiQMiD9sWarGnJioyqXFBfP6YuK/o8V6zLCqUkVlxlgciFkcPV0eEh1haYwnKwv+Tll25jCzuKIGVPVZcHtwjisaLxIdC2LdvtdiTFtG1LDNKlDUiAc+LjhdIcHkxByWG2bRV9C9ChtKIq5cn1GTUoyxJKIzPTJE4UfdtzfLjH4eEe3/nGV3jn+9/CEJlWJT4GWiK+b9isNjgfKA8NKkWsktcSs60+SsLAxsKSgW3pGJ/uPfXMFJbRdkErok8jfdjHxMVmQ+8cu1Yyq7vecXaxpus6Hp+e431iOlsIjKY1N27eoml73n73HRLg+l66GhK+aUj9Dr9ZM7GKqqqZzxfM5gsKU8hcZbBdCPm0VBoZ3cc0+ggNFExhLQtV2mQW2GCGB2m0lJ9OJmL/n4VYxDgK0obAJJCNJt1YvKLaldyMgZmjkCKjtSaGOHY+CqjrWuwzGodPIZ88DUobNtsdmDXTRU3XOx48eISyJboocT7Qe6EhoxTGWJbLJddPrjOfzemalgcP7lNXNbdvvsDQv/vejVTM5+vpWjdOjsY5hS0S1sL+/oK6rljMZxTWjnMVrS+jcgeHhRjj6LDQu56UYs4qEri2LEtR4mvxwyINljCGqqqpyoomIwuFLXKio5U5SS5eIQTqSlT/pihgNsFanfdGjgDOJJhBsSjIhhB4BC4LbDYbNpsNXduKPU0htjWbzYa27UgpcvPWC0xnM7SG3jku1mvadkuKDhJolahKoRB3vWRvJELebwqVInuLOW+8+prMd0KP61tSDKMwUpHGTBmtJYgwDfswQ36iwcxiZfWnC4tRWfT5FK9np7BYnXNUIr3z7HYNrfO4EHnrnfeY1BXNZo3RBqM17999RNs2uJA4OTnh8NoJSRnKasLP/OzP8cZHfoy/+3f/Lrumwbse7yWK161Pid2WdH6faWE42DvklVc+xEsvv5IvoewDlDv1+XzObL7g9PRchvLFYHeNYMJGUVihHtdVIbkUxmQNgWwelGI2nxNTovfCNokxUtc1RVFw/eQE7z2b9Zq2abg4P2c2m8mcxRh57lfoyWX2VLLa4IKIxrTWWGO5dfMmtjA8On9A7z2d96BKUAVf+dofE5Lm8z/1V3l0ds7333ybmy+8xK3jEx6dnbHbtSSlcuRswa3bL/LJT34ChSQN/tEf/iEv3n6Rf+5v/Q9om45m1zCpauyVjPTn6+lZf/XnPj12ssMwfMhVKW2R9R5mDPoaoKXdZjMO5uu6oq5r+i5TzhcL6ZLbkrquqetaXFPynMVay2QyGWGy3U4EtN5FiqJguVyOqvOjdDAWKRDtV1VMWcyn44Eq+oDSCpvpxrmEScNSVhRVxWJvyWq1Yr1eY7V0+N57Hj58yJe//GXOz8/R68A/+2u/zIdefZV33n2PR49P+c53v0vXvs+DB1uRMViNrSY0XeB81aBaj1Ke/T2JH4DAa6++yL/+r/0r/OZv/kN+8zf/ofgTxoRMn5CCHBzBOaa1FWpNdNLpk/L7IpoiEN3Z5RhfPqyWWczTvJ6ZwjKc5F3w9N7ROYexgus+OjujLktc22CNwWhD2zt67zk7X1FNpjRtT1FYqrqmzLne2+2WzWaLm3jquqasamFnGEM5nXF4cMSHXnmVvYMDQCAmtKFtGpQWL6Su7fKJJzNW8uBepqDhkuVBpkEqJRTOLOYcRF6brWPb7Lh77y7z+Zz5fE5Vy2lx1+7kRGMkLGnoimIKKGVGMdpoM5Ep18E7UhClbmEMtrDcunWL6WxCn3qarkX1PaiCRJFnUZq9/UM2jcMUBU3X8eDRY9bbLU3b0bY9N26e8Fd/8a9htObu/fvMpzOUUhwfXaOqat55513qqqYqazlVqqf7dPWXdZWFhcIyndTjocRkQfFw41KKsbBUVYnWUJpB0DdE6Jb4ieSpTOoagGk+FBVZ/CjduUBPVVWOZpRaz3LQXsjCZ5sZmXkOYjRlMRc2pxrmmpIPn1IiOCksprAMGS0hyQDTVhWJxOriFIDFfCqn/QTb7ZZbt2/wodf+Fl3b0DYt9WTC40cP0CqxmE945aUXOT/fcv/B/awjizjfE1JiMb0MNVMpUNqSX/jZn+Rgf8nv/97vcue9dzFaMZ9OqOqK+Wwp5ISq4pvf+A4P7j6kqGQvyxg2SaeisjuyyrAXQ7OictejobBE83TvqWemsIhHV8SFQO+luNhSEuhOzy6oSkvonUTpGkvnHM4Fzi5WTGZzus5hi4KyqsckvKE9DsFjjWYyqYXXV1iWdsnx0TGvvPIhMrkLa0uU1qxWa3RRMK8nbDZSnPb29yirSjZmfs5Jqwx1ZUw6RqISJsqYC5MHiJu24fHpY77z3e9w8+ZNbt++zQEHKKPYrbcAeaNarNVjTjaZTiyaFYbKAlGNEJhRMkytypJbN2+y3Ftw7/Q+ameJpiVRkJRFaYtKiuVyn4tNiylKKSaPHkl36D1t1zFf7vELf/Wv8Y1vfINvfvPrXDs6YlJNODw8whrLW2+9zY2Tm9w4mUqUwVPOYPnLuoqxYFTjvMAYOQkF50ah3pAnUteZZZgZiFqrMW9EDPJ4wuV4sNJP2Xa/73uBwepq3CNVJY8VfA7v0lo6mAFKVorJZDI+52FuMyjZvRN4zVibz/MKn3UsxaSk7VpOz85ZLBYsFgtxsAiBrttx/cYJP/+LvyihYs7z63/vP+O9995nPl8wn0yYvTjj7t27LOeai02g7xIx9RijmE/MZdAgkbKw/NzP/DTbzYr/4u//f/A+UBjNYjZhNp9z/doJdT1hvlxy7/37+N5RVuJv6H1EkzDq0l8t72phlnIZGCb3F0NMzwvLD2V1rhedBwlbFUyZcXR0RF1XVHUNKdG6hqbrBS7rGpm3tC2HR9c4vnaNrm85Pz9ntbpgu10zn9VMJyUvvvQSXdvQNS0n1w45XMz41Z/7PDePj1BK4734+JSVeCYXmUK722yoypL5yTV6J3RiqxitZyR5z0NSeaDZZfYJjCb/SmELw/HsiKIouFituHnzJjdu3KAsS3FBbRuMFnXxYFFvjUEpnQ05YTqdZpM/m2GKQNO0TyTTeedovXRYq9WG1jmKqmbXepq2ISbYtR3/3n/wH9L0nno6o+k87a4jaohKMVsuWS73WCz3UEqxXov77bTuOD44YrPd8f3vv8V8vuTw6Jj1xYqu7X6Ul87z9Wes69eOgGyXlBMLbbZNKa7AVcOHzPBAZc+worCjLXxVyYwkOIc2hkktWpCBDi9uJSKyNNZm3YYeHX2nk6mINbe7nGhpRtffwRI/hCgux2VJiNlSPySU0lfC5BIuOGJKKKvZ21/wwgu38sFObGxIiZPr17DW8ua3v8n777/Pnffv0HY9RaG5e+c9lDZMpjPOz7ZcnAWJBK+hacVpuDCaoCUa+ebJMQf7e3z/e98lBs+1o0P29/fZPzhgubePtQWbzSYLi7/Oo0f32Nub5LkuGHWZxilSBT0GjOkMlQuULa9Ta/2cbvzDWoMiPY09OlSTmslkMgoRfYgELzfzmIVbfe/oe0fXi7ZjyMwOwUtLDswmNdF1tMFR2gWL+YzXX3+Dg/kUmSRetquQTfNCwnk/XuiD02uK0oZLnkLI4kikO4khZzVkXyJSHooaqrpm6j17e3tMp1NhjikpSCkmIpcFImU/IZXfl4EYYDITzOXT4zi0V0oKUIyEHHS2Xm9ovaNMsN11bLZZ8NX1vPfu91CmYLZ3JJ2MjRSTGhQ8evwYbcyYp+F9oMuWHt6HPP/aXQruvHvOCntK13QyGSHmQSMxdPOFNfmUbLIqXF3CX/maLbOjdQhh7GZ6I9fgdDrN4kl/xZVYrkWMltO50njnQCmm8xnBe8l8L4qxmwLGGZD8HJnpDG4VwQuBRvzGxJHYZ+eJlKHj5WJO1zv6rs+OFBIi5pzn0YMH3H3/Pd5+622WewdoY9htt6OUoCwqjo+uoW1HTB7ndoBAhDoBWrGcz9lbLFivVlij2d/fk4+9BdWkBhQhOJrdlnv37tI0GwqrSWmYB4nPoFZqpD4PHd0Aqw/xylop0hhW9vSuZ+L7gikAAISWSURBVKawKI1kyRNZrS84PT2Vlj07ACsUKrfuMYgfD9pS11Pu33/Av/vv/rt8/nM/wU/8xGdYr8+Z1BU3r1/j7PQx3/rjr2CU2F6f0mNDy+rsnJKImUhw12RSitjReYzSKJPtU7qWtespqlLCvozQF7e7NWUp9vjtdoPPantjNWUpAi9SoqrrcQPVVcULt26z2+14+823ODk5oa5r5jmBMXqP1ZqirKRIRk9hLAkRWfapGy9IEHuZpPOpMCZi8CgtHk5f/sOv8PjinDZEei+ml8pOicqy2gZm8z329vZ5+dXXeflDr/GRj32UECP/q//N/5L7D+7z5a/8IQ8ePRy7xb7ruX//PtPJhI997GO89dZbfPlLf8gv/NzPc/Pmzb/gq+X5+vOsalILC0kLZbgwMlgfgr4GM8npdMJ0MqHrxOZlPp/LLNMajJKbXd/32UpFZYjMEqLMEofHbDrx4KrqSmYkIeK8I6Uk882JYX/v4IqgVgwYh647hMC0rgWyRg56u+2Woqw4OD6SLKROnndSjCw2lMBMRimWyznO9fyn//GvZ6FxifeO+WzCxdljXC/CTpWgbbb8c3/rV/j0pz/LH3zpS7z51lv83/+9/yfb7ZbU9+Pc42B/yfXjQ6xRHB7s8dEfe4NvfvOb/N7v/g6b7Q4fIrPplLbrWF+cs921eaYzFZGzHg5pvRwiVUTnsLKyMHmYb6SrBEIKTz28/MwUFp/dc7uuo+tb+r6j2e2kfTcyuEsxMYShBMRvJ/mA9z3Nbs12u8NoUcsW1vChV15mPqlpNxd45wi+4+bJy7x484SiMJeaJPXkiW2g9GolKXNDez2o6L13I6Uwej9Siwc9AGT2jTHYspCLqCyxvaXqe5qmka4qdxnA5aAwDy+vUo2H5yWQweXzG7Buee6XIkVbFLz62qvMT0+59/iMza4j7RyTxQJ0SRe2mAxzbLdbHj1+zPTdd0kKbt68RVWV3L17l/PzC0kdpCSZBD6N2pnNZsOjhw955913aduWv8rP/oVcJ8/Xf4OVnX5NYSlMkenFdc4HERdhhfhczaZT0YqQmM9mko+ST9CKDA/HmEWzsoaOvZ7I4cnkLrzI9PkYIkWUeOIhnrswerRBGq7fEIKIeI3NYktLDLI3JvOFdNA5xVE8BB1d3/HOe28TY8AWhoODQw4ODunalu1uO0Yq73Y7ykwyMFqJRb93FEXFfDaDGFivzymMZlJPxHMlKcrSCnEmw351VaIQYfbdu3d58OBBPvzKwL3ve7q2p9n1uN7n3CUlhrUxW7moQaqQUy6VuCsPHYzs6SFb6nlh+aGs7eZC3Eh3O7brLa5rOT19TNPsqMsKgKZpKYyl0EZu7iGQspXKbnMhaXhao6OIlf6Zf/qXeP+9d/C7C+7fu8ujRyt+8ed/hk9//MeZ6khh1BheNOhIQFIqNUgc8nByyLDTdrsdoS7fR4LrBZO1mhSlIMQYqadTJrMpWAPWwt4+qmkJnXgzpRAI3uP6/krwFmBEGDYoiEUs9Y+/yC7Vu7CYz/mX/uV/mXuPHvHbX/gD3n3/Pu/fecS1my9hbM3Xv/0mPsKuafjjr3+dzRe/ROcdk+mUv/E3/gZt1/LVr34F73qC9ywXc8kpTzIYfVyUnJ+dcX5+xj/8zd/AGMv/5F/62z+kK+H5+mGtmECjKQpJAS2KgmoiMOxsfjlXmc+mzGfT8Tory3I83AzsxoE5NtgMicuxHIZsUaDz3AQG1YBAWwMbrahkoJ8yHBZ8oMiFyPU9qqqwx8fQNtC1tBcXxBDYv3aC6zou7t0bn8N6s+bBg/v8X/+df4euazk8PuTX/vpf51d+5Vf5oz/8Qx4+eMDe3oIYPe+/9y7Xjq+xmC+IsxnWGFYXK6qq4pUXX+Tdd97iD774BU5u3Mb5RNsmSDYbY5YURcnBcsFsOqVr19y7f5ff+Z3fzHBwy4c//GGJmLhY0fee08dblATYCp07u5vrJIfdrFG4EroHsntzoVWip3nK68qzU1i0TuJNpBVaDUwoYVZ534/Gjzqfcsgzkb7vSTFQlSVf+6OvcPbwHhoPKRK6Hednj3n37e/z4ddf45d+8ee4fesaWoVMHZazQYxeHJIH4VUeqA3q45REwS4BXxIwZAuT/ZfksRTgkFlL4xy2sFRlQeh70FogtKZhs17R7LbS0uesa210bohElBW8u2Ijk0BJ1vdV07rLvwxaGcHSUxJxlUYw5vOLFevNll1W52uT8N7R9AG3dXTe0zqPynqG69evs9msR8aPQm4SPngqXdD1Hffu3eP07JTtdovvHVo/17E8jesLX/xSHsIXMndAcf3aNeaLBbdv32Y2nXJweEhCo4zNl5TEZWcOFz54vAtoW2KUAWVISuGjk0OcFSt57yMWuY59nvMNynetIj7K3mh3zTgnreoarRTr1QV9iDR/8j10DOgY2a5WtE3Dnfv3UcC8qri4uODi4gLnOppWvAKPr13j05/+JEZpvv61r/HW99/k/Px8RBZOrglF3rue3XZLSvDzv/BXmc/n7C33OTo64oUXXuDuvfucr845WBa0fcR1LXuLBdeuXcNoTd+1XJxfcHF+wfpiS1EWHBwckiLsdg1np+fsdi2TidjW2CJb4FyxZzKZkDO4tYuDVWZ7Zp7YkEql1Z/xS31K1jNTWIyGaMj2ENISCvQjAi9ryTc6NVZzSWzr0QrqouSPv/pV/sHf/8957ZUXmU4q7rzzJt61RNfyS3/t5/gf/nN/k2azInmHNVVOjIz5dHUlVGjAyNQAUUnutdb6Sg5MKbBdFCpzfkaE4GmahqoqCXUthQ+w2lwpLDv6rstqXHldQ9hQijEn36URKrjCMxb4QunxQDMUleF5pszjDzHR9Y7zixWr9YbtrsE5jzbyfrZNx3rnCUBAMSkkkOnw8HAMT9NZbBZTJHigtPRdz/npOevVWgpLITeY5+vpW1/88lcYNovrRbT34osvcnR0xGdj4vj4mNliiY+JyCUE67O/ltbQ+yBU/rJGG8kbCjHSu0BRWkpt8vwlEZMmpkifSTQhBIpCWGOqk+784uJCqMTeMZ2KCv7R/ftsNhvu37+fLWIM6/Wa1WrFb/3Gb1JVFR/+8Bu8+eabvPXWWxJ1XBRcu37AjZMbfPYnPsvp41O+8bU/5u7du+x2u5HGfHL9On3f0/eOdrejLCt+/ud/nrqesL5YEZOQgv6z//w/Z7M6Y3+vYLvz7HYts0nNzZPrKAV923Fxfs7q/ILNese168ccHhwRY2K3bTg/O8f7wHQqWrqqntB1fWbNZeGjVWNhGUTYOvjRgHIwy9TqqW9Ynp3CUhgJ+zLTmt16hevzzTk4Hty/y6Secnx8nbZpadsWg0KlRHCOSKILiuvXr/HKCzf42Z/8HNePD1mdPaAuLdev7XNyfEi3u4DQo4cbpRbvIh+CZKVktlXCjxTMQU2rVEGMir4Tau3GGJyTC1YpOdVfXFzQ5xnK2dkZs9mMvu9RSnHt+omEBp2e0XXdOLPhyonGZsv9IbYURNtyyRRL40xmeH7DGr4nZLba7qKTaFhEhdy2Ld/7/vdBW87O1viosLZiPpszmc+ZLRZUdcV//B//R7Rdx9nj0zyk1cwmNcoo2qZhvVrx1ltv4TtHcIFbN28xnc7+Ii+V5+vPuVwAYyxVXeJji3OR9+8/5OHpOacXayGOzOfs7e2xXC7ZWy6w1oiJoha7o2a3pdntWMwlKhjESr9tG2bzOfPZjNVmLW4SadBz5e45kgWZ0q30fc/qYjWyOueLGVobzk9PaduG1cWFOAEY+TnOed5+7xyF4u6DDcE3OB8J0XE4mfM//Zf/FW68cItrL9ziG1/+Q955+12KomQ+FyuY/f19Xn/9dRaLBbPZnC9/8UvsmgZjNLYqWNw44Xvf+hbf+9a3+dY3v8nde/eYTSccHx1x7foN6npClQ05YwhcnJ3RNg2LxYyDgwOuX7/O3bv32O0aiXy2Ca0tMSWapmE+X2TobjfC3Uob+Z4o+jYXcueiRMMi3b+8d0/zemYKy9A2aq3FxlsNN9JA0/Xj8N55R9e2FMagExIARMKnSDmds7ecc+vmDV64eYI/2Wc2qbh985i+3dLtthRGBuwpBiJRxEhRTN/kTzDhcrgG+TQRxTQueNlA3knKnffZoTgEuq4bW/CBdeOcQynFYrcbCxgpYTJ8lHKxUEqjs2Ps8PkP/nnVSXlYI0U5/13cjVL+OaJ/qasaa60kA4ZE1zlQBUUhDLa6rpnNpmhjpGgEoX9aK7RUlQVvru/puo62aUg+QoTpdMbe3t5f1GXyfP03WL1PFAoqbUhKE5Jiu2vZ0tL2XuyRrGU+n7OYzzk83KMoCrabLdpoZtMJu+2O3XbLbJYZTmPiYsfe3pLlcsn5xTld39P77KKcB9QDgwwlCnrX96zXa0lNDJHFco7WmvPTc5zr6bqGIYK4LApSUnS9oAnb5lSMNAuwxlJWNS+/8iGOb5xgZhOqyVSEoPk+koCD/X0ODw85PDxkf2+f9955h4uVIAYhQSgKVqsVZ6enrC4u2G42LJYHY7aRz3R7cQrwdK0YW1ZVNdrZxJgkJdIYDAptrLwXzmGMpihKtBbLmpQSetTvDOiIko5lFE8qYnrKcTCeocJyfLQkJUQ/0jd41+Fcwoeeru1yDsKWrmnoupaoNQZQ0UsEb99yf3vO6f3ER199gRLPK7evYYi8/+b3aHdrumbLa6++wmw+o206YlCoogREGSu3ZQn7GmYY0rrK3McYxWxaE7Kj6rQWRbPLA8lJXY5agSG0bIAXCi0xwjorg0OUv7uup9lssTksSMWEQT1ReIZB6FBEdCIj4OLf5FPWr8SAJxEVTGYzXnh5wi9fu863vv19vvWd7/PdN9/l9GzF6VmLMoMg07HZrJgvFmgtEIQPPudmFGglyX6ltTy+L4rimyc3RFujDD//8z/LC7df+FFdNs/XP2I9PNtQlQVeKbrW0bmEd6Kb2jRbfISuVxh9jtGa+UxjDXifKMuCg4M5bSMhb4Mf3G4nYVkxJY6PlhwdLXl8ekrbdmx3AW0U9VS6DmuKQUMgdPgYcK5DIxqXzkdQmvfeuaAsNSc3FjTblvWmZVJHqtLyoddu0bYy14tA5+HDH3mNWzdv8LWvfI39vbc5Ot7n2nzJr/zSrwiryhjs0TE6Rex2Byng246PfvgjrDcb/ou/9+s8Pj3j/bv3efmVV3jppZfF5t55pnXFpChIwdNud2xyYZWQNIlJXi72qOsJWhu8DzjnqSezfChUNF3HdrtjsegANd4DBnhZG4vWgRAVNggsJp83Mm918Qky0dO4npnCMp/NiCniXGC5mNN3PaenFxmnleAs7xykiNUGfQWFVEksT1KU00VVFkwnlSjgU0SlQFVYSj0h+p6uVeJcrMylbUqm/YHMdy5XRJxGxdVHqWHgH4Aip92JIdAgPqvrmt55nBd/pKveTGVRkIwhpoTJRkLe+5FN9kEG2EgeuKKwB1HwDqLKwTAwxkhA5iwxeECJR1pZYqylrmomtcPYtdhJhEDoQYVAVZVMplO00egsC44h4BXsdjt6o9luN6SQKGxB9BEXA3vLJScn1/47uCKer/9/V5mpxTFpyTEKkoaKThhtMRHMQN+PgW3jBN9PYilftQXOeYFXkydG2DaO4Z7XdI6mFeFt2zm2TUAbSNpgbcQamf9BdqKISTzC8kgu5C8ba/JczxCTwvlEESImiPzA+Uv7f4CqnjKZTgWCsobZpGI+XzI/PEIZ6QBa7+mahubBgyzMdJydnbFer7l39x7r9YZut+Ps8WOsNvSZrTmd1GJDkyRHZVDDl2XJ3t4+Wismk2mmPQ9O6AOcJZ2HuGjY8UA4wtaDCDIr63UWUENW5JucRaUH8vHTu56ZwnLj+hE+BHZNS11VHB0e8tWvfYOu61ksFxhl6NoGowzTuiI6RwpRbBOSzEpMUhRKcfvGCS+/eJvQrlApMqtLlvMli2nNvbt3eHxxynyxhy0KYtJoMs0vX/ADVX8IC5KPK3b6MeBcT1kW48U0sG+sldhW1XakJHkqWinJtFcaU12eXoaf4foeslBs+Bi+Hj9QOK6q8wftTYgCT/gQ8CkQSHSuB20wpRAI2qZlMZ+jTcG9Rxf0Lm/aEAgpcXh0wPG1a3zv+99l10CMOe+867i725JC4PzRKYW1HO7ts91s2W0b9vYWvPji847laVzHJyfS0XqPTz2dj+NwfLGYC7zpZdDuvWez6XEuUgj5i7aPGGUpa7lJEqLkq8SE0VKoOh8ISRHRtD6gI+g+YmPA2kudldgcgVISKa6Mgfz3g+MZWili0vigcF7mQ7EPbO7cH8WCIUCMiqqeMZ0t6dqOxlqapiOVNcW161AVuK7j7f/6Nzh98IC3335T9GYh8NWv/hHn52csFntMJhOuXzvizvvv8aUvfpGkNJO64vrRMWUlhptVKfu5rsS+5tq1kxGtSMB200BSGG3HWAtrFWVVslDiAt11HcZmU87R6SBHiqtL7zVjxL1AaSUH1ad8fP/MFJbgXc4USZSFRU8nKFIWSgV8EufjwpaSm+IcMQRUcKgU0MMJG892s2Z9cYEOOwg90W2JfYnbWfp2RwqeEFymlGeh5ED5U6AYhIk53TGlS3sWbSVrIduxeCexpWTlcEpJTvjZ1DF4yXpQ8RLWKgqLtcL9j5FRhJaiWNb0zmHzvCUiqt0hPU+yKCBlmG2wuYhJvifEID2WtTjvOV8/5uzslNXFOattT9t5yqIADS7mgoyiaVpWqxUXFyuc75hkRwJttWDiKTGbTVBJVNhVWTKtJ6iU6DL18/l6utZ6u5XOM0dRCAMqEGPi7EKotyFGtEoSzYvkDaEhpEjTOeqqpC5LCq0IIVJUHT5nFrkg808fJfzOGLkdOi9MK+0c1soJXNkckpdTXrXy4gFm7Hh48t7TdJ7GQRGEhj9fLEUfcrblox/9MB/9sTd46dZ1cTI2kke03Wx581vf4f133xd3dNfx6HvfZ31xzt17d5jUtbgy59nmpK6Zz+bs7+9TVTUn12+grUVlSYMINrNdlHM0TUtCcfPmC7IXU2Kz3bHdCsvMGEvneslS6oQFWhQlVSmiUJeJOJdKyDSKJQe3aVvkwqIUzqksG3h61zNTWHxmlZCSxJxayYYIweUbW6DP2dOqUHjXSzyv69AqUeoEMRCTFJbV6oKJ6omhx7UXuEbRFmK7rbUWB2KlUN6NhUWbbDCpbB6Sy1B+tJHRmsKW+cQ2FBb3hII4DAyzTCfsnZeYUxiLj6KWNEijR58mpXJhCT4/JnJ6yQSFmCOAEzI0lzCxXKxSGGcsIYqRp1EFrQ+cnZ5ycXbOZrXmfNXQuUBRlAIZuCiYrtI0TQMKVqsLIDKdipOz1ZqQIjEpptOpFL6mY2+xx8FyD4Wk7T1fT9/abLfj3713eYYpcOl648ZrtC4VdaXHwpIUhJRoul4U64UEesUYKaoL0BHn5KDX5Fz3hEJbJcNsP2iyoCyTBHcZaTycl9ArkniAFUXCaoGBXd+z6wKNg2mACsVssYRtz67d8qFX3+BX/5lfYbc6x3cdqd8QQ2K73nLn3TsygN+ucd4RXU/bNjw+fcTx0TH68BCSwpqCST1hPpuxv7/PyYnEP5iiwPnId777XXrnSUqJ+0fTsNnsUNqwWCwykaDBX6xZrzcsFgvR6jSSXLlebyhKEVbWtVjdhN02ox8qw+0ZetdiSyOdjhlNK8Vv8Hlh+aGstu2EcmctMtNQlEVJVVS4ToZgVluIHt83Ii5MctpSKYLv+dxPfJLPffrjHCwqotsy25+io8KbGqJDJxFlGWvl4hs6gGxEKRbhWUGcIETRfPR97joAY7pRgSzUYM9kMpFuBikuvfOUVcWkqmiT4Kwmm0b2fZNnOPKhlBIVPmLG53qhG5dlKUFeuTClkAO584ZNJJLK0Fj0pORIKb8mEvRQGc1Lt24xrRe89OKH+E/+3t/n4cM72HpJQNOHxGL/kOXeIffu3af3HlMIvNf1Aa8CRkGhhX+/26zFCcB5fvKv/QS/8ku/zP7ensS3Pl9P3TI518R7P0KndV0jGfKBwaCyLCxFYVittrjeo5R0Hc5HqjpJpERRoRRU1YSUOvquo+/EmFXnDPf5XIwpd7tWBvwRrC2oqmKcobZtIwfFGKnqmsJafN8DQnqpi0iwSOiW0YS+w+A5OSpQccej+3dx7Q6dIreOD1idn/HHf/RHEgzYNsxnU4w1IzR1uH9As9vx/fNzjDEsl0um0ynT2Yz9vQOJRDaGN99+h9V6MzK86umE27dvs1wu2eQh/he/9GXqyYTXXn+D3gfarqP3jjbPgbQxXDs5EYPNohD5wW57KXa+WisG26gsnLRFMdo0ye/t+fD+h7K8jxijMAxW2gprDIW1BOdRSDKjUTqf9hXESGh6rIZJWXHz5BoffuNVtucPSKHDaAnX0SbbVPsgAkyj6FzIN2x9KbgkkTCjW68ozuVDWgdISQZ1xpg890g56dFmQWfMg/2U1bOZWEDKlGZPiD5Hm4rP0EA59t6LJ1Ic8uTkNWYazlhY0kAgGAWcfvwg+4nF5DC2ZD6dwIGlLKfMphNKayiqkoAm+sRiMefg6JB33n+f9WYrCmw1xG9EIlG8pTLUGL2H4Ll2eMjHfuzD7DZbvPM/ikvm+frHrewmkXKWzyDGtdZgtBohKGsNxohduxo+n0W2oovi0vvOWIweyCaJ6GSWYhBvMQxYmyHakNB5vxpjUTFbvKAygUDg3iHUSymRAhQasVvSGpUidWmYHC+praLdbVDB5RRM+fr64lzctruOurQYXQlMriSqu21bdrsdBwcH1JOJZNMUpRwyc/Z8k2OMjbEUZZHD+GbM53OUNsQIj08fM5nOeClDW6Yo8CGAQqICsou5zcmvq9VqjBVQKkcXDMP7XOwHm5oiE3pSEo+x0WHkKV3PTGGBkhgV3oHOxm5VNWM+61nMZQBulWFvsWBvMccocR7+6pe+wMHhAf/kL/wMt08O6XdnxG5NCj3NqqcwiVJFVGghdOhU5HlMJKBJIYm1MgoTIkoH+j7kOcvAzijFfRkoyooUI9ttJ7CVDzRbEV3VtWCqVWlIvmO3bgV7zX5LCaAAT0dyggUrBjsXTbvdYbSmLgqUj0TvCIMVePSQxPQv+I6kIqhcyFIkRI+PnhhSNmsqidpL8fKRMgU+9+lP8Nqrr1LvX6MLiUfrHUcntzg8ucn5//fvc962KFsLXGgUrm3xncOrHkOiMpYUE327I+w2tOePSV2His9t85/G1W23aK0ojBJKekgk35OUpbRyU9y0ch0HL0mTk7ri8ekGSEwr0CnQNS2TkxvUdcWjopCOYxqlu+6CPK7yJLehLEtuHh2y3uxYb3ZoAsnDZn1BDJG+bUWQubdHs9vQNQ19syP4SN8ljE7UFhbTgtm0Yn825daNG/zkT35euqTNY25eP2ZSVWzOH+DbNbdvHPHgwQP63QpCT/Lg+xZbFsymM7Q+YDKZsFgsKMuK6WzGdD5nOpvhQ8Q5z3Q6p3eBs7Mzlvv7fPazn+NLX/oy/9V/+RtEwMeEsZbVZs1/+uu/Lnkse3scX78+RozHFOn6fiTxRFJOsd1IgFpdZ5jMcvfePZxzvPDCbTmUQo5XXkkhzv6IT+t6ZgqLNkUeJibQMtAuCrGl77qs6k2evivoCkPyPa5vqQrDdFKymE0oC0OKHpDUtxi9KFO0/D0ET9/36JjwQRGSJmqFQvj0MSaUigSVRCWSC5xSA3NMjYL5mEOIJEtFYKroLZiEVkLflEjWjpBnIPJCFTpqIgFFQKUcuKo0UQWSsWOHMogSYxZvBkIOQ/Ni46LC2AnJz/BC54yggrDcku6JPpJ8ZDmbklA83m7Y9Z7NtiHZgp0PbHY70eOkxGw65YXbtwh9R+w7KgUmRVKzJbme2C6ZTypp81N46rMj/tKunG6KGeZxDBcvwyfGmGvCqMMoC+m+tRaBYNP2bLc7MVNUCmssVRlJIRJUuGJPIpBt9B6jFZNJSZmpxEabDMtJl0+Koo2Jlp2XvWQtlNZQFYbCSCZJ33Z456gKg0oGFU0WUEcePrhHu9vhXE9dlRwdHmCMwEg686bbtmVwVy5LETYeHBwyW8xBa3zvRkjLey/FdrPhzbfe4s6du5yenjKZzdHWistySmy2G3F5VgplDHVO6EwkeufGxM62bfHej7ECQwGy1jKdTLG2p7QlSiu8c/LeWjsKoZ/m9cwUFltJwlzXtCQLVsuwuO96Th+9h+s7gndsLs44qwpWZ6ek4HjhxrEohkuF0QlSQKsIOqEGVX70uL7D9S0uRpS29KYmKUPUWZ+C0GGkHTfSwpsit/JmbGGHsK8sfxEX5JQkiMz3qKAIPqdLxkCfC0tU6RJjTRqVNCoLHUXqqNEqh3npyxCkrusyzTggY9cgFDMlVLOkElEFKT45dIyowDm09uikCC7iXGR/PgWl+C/+4X/J2bZh7SNtUHQBoi6IKPrec3x8jX/yn/olChImBuaFRsXAo3ffBO+oUuTFGydszh4wq2usfW5C+VSuYZQXY+5iydeuekITJdcXo/PF3t5Ekk2bhl3Tc7HqULzHdFJSlxW2qqhLi06R6Hucy9CpFhuW1eqc6WzGcrk3MiXLsqbZ9TzutrRtT9c2zGcTUl3x4P4FVsHRgZU8lrpCRUfyPQ8enVEaw/nZQ+bTKYf7c+pC4/qWr/7hl3GuZzabcfPGDd54/TXefOtt1usNdVnSO8eDBw9Y7u2zt7fPZDplNpvz4R/7MbQ1NG3HbtdydnbO+cWFaFuc48233+Z3fv/3RcPjI68fHTObz9m5R6DEAurR48c8ePiIojDjnGSQHEwmEyaTCU0jTgIf+chHxmJzVWrgvReBtXN0bYfVhuV8wWazwXn3I7ts/jzrmSksu6bFaMN0Psf1jrbraTsRX6nsWUXUeO/YhR6jFWU54YUXbnNyfEhVlqAUzoswMQXPVoHVUOhESoaoS+HRK4stKpI2JJWtrJMa/1S5wEDOWBkvHBnADfYLZD9ScoZCiB4FknSZY4tdTrsbfhPjYTGSuxXQ4nyGUYagNUGZMVkuxWE+kxlhyPwGuDIMHIqTzAiF1RNRyEzJBDAqUVcFs5S4eXKdm2XNzVdf56337/PW+/d58PiMputQhaXZrPnyH3yBgkRBxO82lAo+9eHXmM+nzAvD9eMDjg6WSHr38/VUrgHJ1UoOIEhnkS9Bhtx1YbDn7jtGvO8Y4oKNTqgCZtMJ06nApCkG/DDkrkqRCpDkWrOSZeJ9YHWxYzarsMZwdi4ZKQcHU26cHHNy/Zi7d+6x2+7YW1YZYXCstx3rdWA5FzjsZ3/uJ9lbzvHOkVLMDsEiQjw4OsJl6Klpe+7cvUeIiTrf2Avn6HyQG7rWQuN3PfPFgrbteOedd1mt1qzW65zyOuE7f/IOru8x1lJVE6wteHx2xsPTM1wOAiysRIinKAGEw+HTDDNh79msNzRNCyju3rlLUdhxnioC6zgWcuccm82GsqyoqpL1ai1+gk/xemYKS9O00qbO5qz8irbdSGHJyYwYA8ETncO5nvmkZD6b8cLt2xzsLTMzKYl+xIkgihixBupCOgKly9FdtCxKyB5KpEuIKyWVB51qpPwKUyxDY8iNW2lkkyUpQClfLHBZVLx3+BjyQG7IfcnBRpkMoJDBp0YRlfwMnxkjCjVmfUc5esqHkp94uYS1BdmnSUHAib2/QUgMOlEVhqhqbp5cY//6TX72l36ZL3z5a2C+yrZpcK6nMJp2u+bLX/h9SgWFSpzdu8OksPyVj32Yg70lh7Oa48N9DveXMm8Jz4f3T+MaNClklwbxkZNmdzBpH3110+AmDj4zwyRTZEAPamazGb7r8T7nsBiLqmp2uwjJY6yiKAxVVbLd9my3LbNphdGGs4stVWm4fXOPGzeOuX3rNm+/9R5n5ytu39yDFGi3HdttYLPtKa3lYG/Cz/zsP4FWiffeflsK3SCWQXF4eCTu4Smxvljx6OEjlvv7VNMps/mconc0naMoK7TRErGdBcxt1/Peu++z3m7YNQ3Xrl+nrGref/8hELn1whGz+YLZdM63v/snrDcb9g8OCDG7Z8REIMg8ROsxarksStq2zYSBjhjhnrmH1mqMEg8hMp1ORldz5xzb7ZbFYsFisWCzXguE9xSvZ6awHF0/wTvP3XsPePzoEaenj5nVYnvdTKdsVxe8/87bVIVltpzzcz/9k9y6ccKsNFit6JzHpYBOnuAkfa5XHmsULkJhLaU1eKUksKqPeeMN9vQ6w5oRFXPliDJLCSqgtMAHu2aXqYCZ+pvyDV9dwa7J4VxK8mWSUpIJnoZzIlwqa+XnK3RW/gs0FzMFOjk/IhpkLzOy1iApKS9xMOwcwO5EVkk3PGp6VFljyprNds3FruXB/bvcffiI9+495HvvvM/33nkflzRWaSaTCcE5Nus1fQoYAsvZlL3ZhPPTB+xNDDc+dAsVHA8fvE/oW2II3PiLulCerz/3spVAL8YaTHC4fABI5PELogRPWRw82JJUVTlm8Ai0mnh8es5uu0WnxHQ64aUXbou3ldJ85Wvf4fx8xWRSS6yENVmfAcYoqrrgkx97hXoy4drxAY8fP+ILX/h9+m7DYiZU5+Oja3z8Y7/AN77+bb71je8wqQVaenz6mP3lgjfeeG3MZvqN3/1tTh+fsrdccnx8xI//+I/z9ltv8/bbb7NY7lFlG6ODw2M+/ZnPsW12bLZbvvjlL3P25lusNw3WFqA12lhsUfKHX/k66/WW5V6dn7/hwYMzNuu7VBPL4dFRdvFWTKazS/v/DPVZK1b+dV0zxCzPZjp3JXLv8N7T9+JyAGQ2nrBLhz/73IE97euZKSxlVRNCw3YnH7tdw2I2oypLfNfl6h6pqpLlcsHtWzd54dZN2s2KFBzRu0y1FesUtBG2FAqPQStL1HaEiogJlRX1g0BRlhr/e9XQBeRU57MTQJbKSzzyAC7kgpMIH4CHLruL0QssfeDrKo2+SmkYrEIWn+X+ZDAcy9lAQ2EJI196bLtG5lvbd5TGUOoa53u6thXjyXbHg9M1dx6ecn56Sj3fk8yNrG1I3udMc0exnFGWBZv1BW2zZFIXdNuWtt1C8KO25vl6upbOwVJCIxb67XhNp+HgL/YiSewc5B8OMOw48BcBc6+Evp9SxWRSi1W8MUynNU3bStes1BNeeyHPb46P95nNZhweHtDstpwpOD7ax1rDbFpxcv0ab7zxhhg/XpyxnFUs5tMxzmI2m9G1DU1wnF9c8PDRQyaTCSjNfL5gOptRTybMl8s8GC/YO9jnpVde4f6DB/Qh0PWO1XrDm2++xWw+5+TmzUytTpydX3B+seL6tQOBzoyh6x0Xqw23l9eZzSbCCAVMAbvddrRUumq3dNVwckinHaCv0c8vxFxcLm2Zhnhx59w4r3ma1zNTWDa7jrbpaDtHVU+4dv0EkCjg73//+0TvWC6X/NiHX+fH3niNSVWxXW+oSwtG40mUtpJWvLTSesY+P7pktWttiMFlhbuo262SDASjBwaY4MQqf95qwU9VToksJ7VABjGzzjLeHEPA9z0xeUJ0DElwSomStppMgKHnkIIwAhGj1UPuSNJQNLLZ5fBAeZZy2esMf0+XM6I82Nd5sI+P6AyF+b4j+p4Xb9/i8fmab7/5PpOy5Na163QenI88vHMXaw17izmu2eCaluR72m3kG1/7CtrtSD/9GaBHK8f1kwMm9dNNjfzLumxZjT52ygkrMURIAUxMOZxrcJsQL6sYI82uR6mENVBVGqsN+/sLmae4HmM05xfnIqy0BT/+4Zfp3W1+90tfh+Q52Lf0ztP1cPfeBYt5z6c//Qn295bs7S342Z/5KV577VVKa4gh8N67b1MWBbdOrvGTn/+sxGGEHte1fPtbX8c7x/3795lOhTL8kz/1k6w3G04fnhJi4tvf+S4JuPXCi/zE5z7P9esn1PM5pigoqpr3Hj3izTffwhYlR9euc3B4gNKa9W7Ldrtjs9kyX8yYTCdMZ9MsaIS9g4gtDC+9/CKz+Yzz1SoXykSxLtAG+j5lb78GVKTtStqukQgAI5KFPs9axLoFlNY473Deo3TKwnBF13fsmi03b95kOp3+KC+df+x6ZgpL1zm63o8+REprXNfnhEgRF4GcuozW4sfVNjQaUgy4vqW00lZXdYnWCh+GXO7sHqoNKUhnQ+jRiJ2EnOguE/QMg82K4KdaDdYrQBY/SgHIupLgSSmIOj7DYgP2OjiWDhkL2XUMxkhSgcqSUkSpMgwTlAQSZykS3ZH6rPLjXE2SHHU3SvzW8C0pMFKdQwhUdcUcw0EqaXvxORN2dh5AqiSFVAkRoDAWU4rTqyJx6+YNjo8PSSnI3SlTun14uk9Xf1lXdhG5BF/VAIOJcekwrB+EiTJnka9brZlOKxnRZCFu8GHgAqAV9F1Hu9tx/fp1ymrK9eMD2q6h73fZ9XrBteMj9veXfOQjH2ZSVxitODo84GB/n6qwgjJET/SOru843NvjYG/Jo/v3aHcBYywxeGFOdR2kSMhD/IPDQ8qyYv/gQDLo24bJ3j7za9epqpK+dzw+PWW9WtN2PdpYqkq0aCiIeLq+Z7VeM53NJUul6+idw3mxZrLWUNUVk8mE7oqDgaRmBpyLxAh1LTEU8/lcjD4zUzLGxNnZCkiU5eU9JgSfiRIBpaK4t3t5PGMsVfV0H9aemcKyWm/FhbcPKCIqRTarLa5vOdzfo+92XDx+yG6z5uL8DN81BO9od1uCd7iuE8zSGsoqm7/FkNXFktyG1ll3ESlxKCI6XToJi+toPsHlNYjnyZGh01oGgTLQF9dWwUo1dWnFDbWuqGtLUZaXz6XPcxdMZpalsRG5LCoD20sJvJZAlQJnoKXjuszMzq7OSjLKpeBotE4kAt3aEemFtth3BFNweHyNI1szWXlcNHRNQ+skfbOczKnLErNYyh0pJCZlRTWt6TanlEbz1//ZX+P64R7RO1LyKB1Zrc/QG8XyL/Baeb7+fCvEfEzR4j6clNjnk5IIcGPEhTBGSw9OEjHJzffk5Dq+73G5gLQpsZhO0GXJtK55cP8+Dx8+5PDogKP9BT/9k5/g3r1H/M7v/SGf/OTr/MzP/BX+2l/7eW7dvIXWit12y5333mUymdDutqi6oigsH3r5ZU4fP+TLX/oDyjfe4NaN63zv+3/Cvbt3WC7m2KKg7zvOLs7puzYLDg2f+uRn2N8/4MaNW3z961/nm9/6Fvr4GtVLL8F2y/l77/OF3/ld7t65S9vLEL8oK3EvVgptE7vmDu/fucfn/8pfYbm35I/+6I9Yr7ecna1ZLufsLRcShDefU9S1CKCrimvXrtE0zZj0Wtf1CIGt12vW6zXOOZqm486dFRApS51towzOxUzpdmgNRaFpmkTXJbQunxeWH9Zq2g4FzBcLXNvQtw3n5+e4ruWTH32DvmsIXYNSiu1uS7tdk4KnLiWMKnMmiUnR+YBSiZiZL1EpUAalDEZZNJLxrVLMNihyS9cpY6P6smO5VJYJq6YNERUjyiM+ZYihHAqxj8mGcoU12MJQWNHCxDhAY3o89Y0I2BCGRLyii8rD+BAEBzcGrQxKy+uQo6gWkoEyo8hSa6Ek+/ZctC8pkhoPF1v8vXN8Mmx6w/1HZ1T1FCzoqOj6QOz8yFQJwaFCIvnE/t4+J8f7HB8fsZhPCN0GlMJYS1maK1jy8/U0LecD2mQDSNToMEHudIfuhatZPylR1wVKJR49Oif5QIqB+bTAWk3XtSiVWGethbWGT3/yk7z+xusYa1hvtnz6M5/h+vUjrp8cs1wuqKoC3zus0Sz3FtnKRejJ1ihIgcmk4tVXP8RiMaNpdkDCGE3fdaM1y5DeevPWLSaTGYvlPrPlHvPDI155/Q2m8wWn77/P6b37nN6/Jx6DSmjG680GU0gukdKGECK7psV5D0qxXovo8ZVXPsRms8UWdzg6OuTo8BClxaTVWjvGoRMjRilCft8Gby9xi1ZM6pqqKKjKitdfewGtFctFnedbibbpcF5SKSGJzVQnrh+zSUlhn+5b99P97K6srpN8k+ViziYE2t2O84sLfNdy8+ZNXNdw/ug+SsngbLteyQV/7RhlJSd68PWKXgwalSlAyWlN3gqDMjJcjFGjUoCosk4k5QmG8Cx1zkhIg+gk+4B10efBeoQoUFjMbW3M0JsM5WS2opUWKE8NYksrBUipvM8TJGmxI3Ec2gOQEqF3croyFqUkL1thcquTVSTKSreiDFoHlAqosMZaw3Q+oXc7Opc4W3e0LuKY0nSBqp6iA9io2O3O6TrHdDrNtjEeIVQG9m9f4+bNmxwdHVKXhvN2JTRsZSnrEmufF5ancTkfMICOeaanhutFjXTjODLCpMAopZjWFu8jjx5doAEDLBc1VVVwsV2TUqDZ1WIkWZV86lOf4POf/zxlXYmtieu4uFixWq1ZzOdYa3Bti9GK5XJB8J7gvbhnG02KgUld8dqrH8L1HbtmB4DRhq7rKQrDYj6j61pQihu3bnNwcMi0njNbLJnsH/BSPeH2zVv8w9/6Ld59712+973vsVgs+NiPf5zOOTa7HdO5QcuQQ4LNstuE0lJYjLF89KMfZbvb0TnH9esnXL9+nfV6TdN1LK24nocxXlxLUY6RFIRC473HKMXkSsdRvypq+9lshvc+x5d7QghcXFyMaZFiauuYTirs8+H9D2d96lOfYbW64Pvf+w7b1YrdesV8Pmd2fMgnPvHjPH74gK988ffoC42vLPP5DFLi/sOHwsiIknrnYyRqA9rw/2vvz4IsTdP7Puz3bt96zsm1svbq6n2dnhkMMAMQO0EOYYRMiKQohSKEoC1RiDClG/tCl77RlcM30oXo8I154QtDhEQbVijEBQAXgJjBAJh9prunu6e7a+lacj3rt72LL973nKweQg6HY2xWB/KJyO6qzKqszJPf9z3v8/w3nVcEJDZIBh+wLoLaIjhCs4j+W77fbKCM0SitqKvourr2/lJSxvWcCGglzxUA65FDGkQI6DS5yGRJI2UUP4KIkbAIUPp8SR299PHesjav3Jwc19OMLmPDkwohNVKs12ApECgkzEbIOIVJh5AOlYELlpPFCoQBkaGKiiJXVGaCWLSEkwZrHd3gqcqKPI/K6eAFUmqMlBiluXRwwKWDA45PTsmzmORZFZqyKJnOThj6jr1/S9fNRf3Pl7V2I6KNK9RzgkrM8kksxjSpr62KFos4JeQGRlVBXZZ4O7Ccd3jrefm1l/kv/ov/HT7lDb386quMJxOkijR5bTVlXXNw9SqlicLiTI8Tk1Hg+h4/dGQmZhIJrTb6qwfv/oCP3n2X4+Mjuq6lKkvKMuIoN198kfH+XlxLaY3qPGenU/7V7/0ep0dHnJyccO/uXfph4LXXXmO1avgX/+oP6PsehELpmP3y9js/iED5qqHrevKsjG7iWtP2HUJJbty4wWQyic+guooHv2GNi9hPqOidc+R5vvnY2lhyvWJfh3lJKWPmTNOc2+2nBqKfmFDatmUYLpT3P5Ya1XEEXi2XNM2KrmvZ2d5mb2eLvd1d+na5UQMTQszTJtD1MXjI+6h4H7yPfltSoTEEJIMX9NbT2+jPhXf4JlFlfb8hGGdZvCAG78mMpneezBi0MQQ/IIGqKlJOidqEb2ml0wRyztdaK52lMkTFoiMC9QovYnyqTDTnKD0JeCmTlb9PH4vrOB+gdx4jJFqZJABN9i2IjXIaPFp7lPAoHUkFbdsgVUBpiVAVWmZIk6O0wwW/GeWV1sggGHq74aQKERPxqqreiMpCkJG1IyRBSnobaZwX9XSWIE7eTtqkxXqC8v5kPfG+6DQec1ryTFOVGctFhx16gg8URcGtW7fQQiAITCYTjNaEtBomRWErrdPhzcP6wSklXiv8oNLKGchMPNt5R9d2nJ6c0LUt3ju00WRFwWgyZv/yZS7duEHbRf+wblgym0354L33OD4+iYF2s1lkc2qDdUs+/vgBRVFQFGXcXoTAyekpXdfjXAwbM5nZ6EyGYcBkGbu7u8mpWG8wqJ52g6msm4oxJq2/dfp8YvP7J2OHz/9OfBnWupcsyz7xeaQUDMPw1IuOPzWN5Zvf+DqLxZyToyNwFkngb/y7f52XXniOLHHwx+OauirJ85zBdnjnGE8mtF3HyemUpovZ20FlIDWyj2BlMzg8MmIuSXeRC4kgptqpxAhrPATneTw9RoiA0ZK93V12d3Z49OhjvLO8+eZnKEc1W5Oaw8NDDg8PuX7tKmVZ0vctXd8xm86wQ4+1PdtbO2RZgdI5IoAN0K4a2rZlMhmhjca5hNHojHZo6TpLXdfxYrWB6XTKe++9x8HBFQ4OrvDeez9kNl0g0cTGEpP0vA9MxgVaBdruECUDVaERKkPInOdfeoNxPWLVBZZ9z3S5RJuSrKppVl084SqJ946ubTGjgiwvqMdjqvEEGySZ1OR1zqpdcDo/IzcZxeTpBhr/otZkVJHlOVs728xmM5wboiu3DZRVFg9oUm2aijbxAWhxGCU3KaIxwC66SeDh29/6Nv/J/+p/zTM3b3Dr1k3+5r/3N7n97G16Z1FZRrWzvVkfU5ZxhO97sBa6BpHnqHENzSo2nbIg9B1uOsV1zYZ5FTUyFXuXDnjxc59DeU+YnvFHv/8v+Oiju9y5c4/ZbMHDR4fs7u6yu7vL3v4Bgx347/7R/52+j4FdOsujxb2NE8XR0SkAW9tj8jxe4w8PH+MfeerJmOvXr/OFL3yB45NjDo+OaJr4NY3KKmXPxKmibVrK6vzaH4aAyRTGxLeiiDlNXdtGpZCQaKOoR3VkufXN5jDqQ9wU+CCo6oKifLrvqU9NY2lWS7pmhe07RPAIKairksl4jOsWm5EzyzK2d7aYnp3Q++jGK6SkKAsGD2JwTLZ3kCbj+GwRs6yrmsFFDMYLmfCSPvIvRcAljDzLTVxhDZE+PHhH0w8smpbe+iQXUXghU1AWdNYzeMgQBKmJtsKa3nWsmh6hGozxyKCShtJvkibdvNkw2XyIhpV2iMrc3smkxg3Mlx3NEGh6HxP2ek8zOOQaFRIC52KEsVh1KBXT+JSKtGidaXTGuXAUh/PRSiKgCcIkgVfcsYv1STKERKm0DCnadk1zFlLHLG+VQowu6qkrZx1O2Q2m4ayLsQohoJJuhaBSJrxnTSHZ6HB9isR2Mq6JpaCzHV3b8ejhA5SI0eHf++53mU7PUFnGaHvCrcwkHDFKA4SU+AR4S63TNbP+Kj1Yy9A0nB4espjNGPpuQ9k1xtB3He+/9x79Ykk7n/O9736fBw8ecXR8Qt9H9btIzsDWWvrBMp8v8SEwGo8xxmCMYW9vL2pQjMF5FzcRRGxjb28PY2LoV9/3HB4e4ryjrmsW3uOtI8tM0rh4hiFm1yi59hWM90zf643AMfoMirTWjh+PUcQ6ZTade5+tvQfPGap/zlT5FNWnprEMzYq+WdE3S5QgAvLBIoUnK3K0kszmc569fZPnX3yeH7w9cGoH2tUKpTSXDq4gTs7o3Rmvvv46VT3mf/rdf442mpu3nmGxapgtVkkw71nNT6OCXprofDz0jLZ3KYocnZcMtqNpliy7gfboBCEEeV7ipab3glkzsOwszeBZ9haMiwmXWmBKTztbcTxtOJn1iCCwQ8ytsNYxHteM6prF4Sneey5dPqBpGu7du0uWZWk8PgPi+Oy9x+uKpZXIeUdPRjAVzguU1GR5CYPF9QPzfknwA5nSSDy+89SZIS9GBGVwQuJlwIZA0zbIwaMHFxlmyZtMCoXPNAFP13WcTc+YjEusu4VPmE5RxjyLrlni3MUq7GmsxXxB1hkksFw2NMsO75JgN4tJoVYK+i5ge4cdoo4lF3Fy77sOhUeLwGQyRgnJg9XjlO3e8fH9+xwfPubjB/cZjUdce+YWzz3/HL/27/w7lEVOWeTUw4CSkm61QuYZ+aW9uIIe+rgmsxZsz+zRY779zW9xdnrCYj7j8uXL1HVcwT56+JD//rd/mwcPH/Lo4UNWK4/zMNmqqKqa/b1LjMYjiqrk4cOHzGYzrPcYY57ASWo+//nPUxQF3/jmt2jahqIoWC5XNM2cX/u1X+PKlSu8++67nJyc8E//6T/lM2++yWfe/AwPPr5P17aMxjUAw9CfB3QZHVfjOmMY+tQwIia6tmjaWDmlBiKEIssM3svNBlIkDVvEuewG0H9a61PTWB49uEdwjsJonr39DM89e5u9nR2Cs3RDS9e2OGs5OT7hww8+Yrla4QPkRYFzgdl8wXK5ous6sixjNB6zv7+PdYGubWKOPOcGkFU9ipkvWrFaLWlWS9p+YEjJc0Ia8rJCS4FOp488zyiqEVkW8R2pDUrnDDbQdANaxhlCZyVCGZw/36kGaZACjBaorEJmFXmIPk1eZHjhEbrGCUnnEs2ZlNwnM7LKYNHMVgOdE9igcc6hQ6RJOyRBKlAZUknyQkOwDEODRyGkwXqwLgASqRRZXiRmkEXJGI3a903U69Q5t2/d4PatG1y7vM/2pEYqhfOetutxdsDZHq3OT1kX9XRVkUfBcGYkRgu0TM5BghhnDZvV8JpLEr3CIiXeWY/X0ZxytVhuqPEiQYZORU+sNd38ow8/jCs379majJmMxzzzzC22t7e59sxtdJ7BMKS3HrSCTEHf0jQrPvrwwxh0V5RUVY2Uiq985ascHR1x7959hBBcvnyFx4enDIPj0qUDlNK0XY8xObu7e9y9e4/FYkmWZTEjJQS6rmOxWHD//n0mkwm//Mu/xOPHj/nOd76DIJBnJl3PA5cvR3HldHrGfD7l4/v3IASyzLBKMcN5pmNjcMVGaiDSSr0o8jSdyETG8WmqWU8rcTLRep2cuf5p+RQWG2Jwmny676lPTWM5fPgxeZaxu73Nyy88zy/8/M9SlxnBOfq2YegimHd2dsYdIZLJnSDLC7quZ352xnK1ou06TJYxGo3Y39tn2TQ0bYNzUeA4JNO40XhEZhLzS8cEt6ZZJV+iMqlfNUbJGImsJHmekZdVEjh1CGlQOqO3Ht/2KBlts6uqQkiDC3Jt7IKU0bpbS4XJK3ReI00ZwVSpCDKgspgLPoS41oKAEZpM52TVmK7rWK46ehf9z6xzeECHRKmWGmkypNAUtcLajlXf4UVklDkPQ0rMVEqTlwXDEN0OVNRt0rUd0mhG9YgXX3yeL/3UTxJshyRGrHrvaTtP28RmvLU1IvsUmOb9RawiiyfqTCuMEpgIKQIhuURE6mzwsbEo1o1FEVxcvQYfCN7RdH0K0IqiL+eIQXc6oHVkft394A737t/n3r177O3usLe3y0/8xOe5cfMmV156GZFnhL4hdC30PWIyAaMIfUuzarh75w6XLl3i8uXLFEWJtZY//uOvcXp6StM0XL9+nStXrrJqe9q249L+Ada5mIuSZWxv79D3A8vlasPy8j5O3dZa7t+/T9d1/MIv/AIffPAB3/j612PEcZFjh56h77h0aR+lJB9++AGL+ZyP79/nypUrFHnO9OwEYzRVuRUnPsDaaOcfG4tI9kZxRd12K6xNTFIh0CZpzYTCh4htxajzGInhnMc7zyB8ck1/eutT01j2JxWXL1/mZ376Z7h0aY9mOedg9xpVWTANlno0Ynd3ly//lV/hV37lL/Pf/re/xQcffECd5QjpsCEgTZwy1syM559/lpPTKe9/8BFlnqNNxnK1ihxy2zPgMUaTZxliMklYxUBRFCgtMUYmtlVgsVgwm81om1U6scVQsq7t0o0VUybruub69Ws0qx5rPUVRRV+iRYOUmrLKEKYgr0bkRWxg3gvKriOokq7r6LqeVdPgvaccxR2xzgpcMPhg0FmVBKEeJaJl99qWY3d7RFEYRoVktZxz994HGJNjvaDte6TuqOsxly9f4uDgILHQApPxhNxkGB3ZbkPXMq5rTo8eMZueQPBU+QsUhSEzislkm4P9A6ZnJywXzb/ty+ei/pyy3YAMIEpLrgQ+N/TC4kLADz3ew9CHZI0PWRGnT5uYgZkBgSM4+Pmf+xl2d3Z49523OTmZcuejx9y4dsCzt69wNj3j9PQUrTV5WbK9vU0/DNy7dx8tFR+8/0P+1b/8A8ajmmdvXWdUFtRlwetf+ALVqObP/vBfMzs75eWXX97gIV/72tc4Pj5mMV+idcbV63tkRcF82ZDnBVJqjo6PGI0nvPnmmzx8+Ihvf/u3mc9neO84ODjY4BfOOfq+p+97VqsV3/jGN1BK8e//+3+bvu/pup4f/OAd3nvvB4BksjXhtddfZT6LZKJnbt1kZ3uCwKappIANQ0wRgsToeLjywac1mKQos7Q27IEnDSrXVO84oURbqIi7WutAhItV2I+rMi2Z1BW3n7lBZmI6nVEqqVcz6rJkd3ePW888w2uvvUZdj5NDq4j5KnmO9eDCOrzIU5UlbdtHy/w8I8sLBIHBWtqu29D/pFJkWUZVlTgXFcZKRTNL5yzeRfCz7zv6ttkIKr1zBJsiXYVIoGfEUyJImnatSmFdtI/xQaC0oSiqOP1oQ/ACpMFkLT4ofNDQRoGikBkIjQ8yTkgGRIheHespQybqshSCejSiqnKKtKYwJkcIhQshOiWHqGguiyrmS6Q41q3xhKLI2R6PsNYym56l5EFP3zXJsnzAO4VIjgJlUTITMn6vF/XUlbceryK9XopApiSYmILqE+04xFRulIgW90KAG9JqRyVKPLC/v8fVy5d5cO8OzbJFK02W55RVxen0DGttOo3H5jT0A03TMJ/PsX3Pw48/Zjyq8c2S8ahiNB5xcO0ak60JD+/fww4Dk/Fkc+8ePj7kwYMHeB8wWUZdjUAInPNobeI17eMUvbu7y50797h37z55bsgys6Hveu9SJPnaNzBwcnLMzs4Or7zyMqtltNR/9913WCxiOFcgYIzGpxRNoxVVVTL0NUKwOUjG9Vb0BDNZbCzOufRxhdZq43q8Zrqt30I4t9FZ/3r99Xn/dIsj4VPUWLr5FGk7Lu9MqOuKqioxAmzfsbezhXrxRX791/86V65e4869j0EpytGYVddRlCWf/dznuP/xQz5+8Ii+65ienfHo8RHOeW5duxx9gkxOlhf4EHjw6BHW2YgZtCvaYeDVV14kzzO+973vYLTgyqU9Tk9POTtdxH21htnZND6cpSQ3hqwqNxePHRyZMVRVRVmWFFlJpjNI4+86jGtnZ49nn32e2XzJ4DxVNcGfTjk7uxszLnRF005p257BLlAq2sOMRxWjekKzWuBsdGf23kaac9cwdB12WFLmGYvpKX3XsFzMqKqKuq4pspzxqKYucybjihvX9nn88CGPHh0yO76P0ZrPvPE6CoGRA1evXeHK5QPeeUuzmM9ReCSOIqvoVg3NdIFWmsn4winsaayhA4lj6FdIIcmzeKAAYtLq4FCij2tlJVLsg6AexdA87+L1nBvD8dERXdvGh71zvPTSFVbLGV/72kNu3LjO7u4+87v3OD2dcnxyRlUWMbfl1jMcXNpnf3eXrmt4/PgRdz5a0bYN3/32txlVFdevXcMYg3c+kkeUom07un5ge28vOpMrhVYGpXQ8LEnJ9na04ldKcHCwyyuvvEDfd8m+HthsG+acnp7y2c9+hv39XebzBcZo9vd3mWpN8J5f/IWfZ7Va8f57P+To+Ij/8f/5O9TViPFozLiuuHL5gJ3tLfq+Z7lc0HUdzsU8e5Pu+XWcs1IqTm9Jfb/ecDzZZNa0uHVWy0alnf78n6s1eorqU9NYXn/lJW7evEmRGXKjMVohRbRTWXsSXblyBWMMs9mMwdoYiSUExmRsbe+wXEWK79bWhMlkTNcN6YRuUu4CZEYRgLLI6LrAqukwWmHqKjqn2uhpJCUMfYdMkb5tG1cIeRJTAfHPJTDOk/JdQlLlBxDrqQafnI4jfVIrhVI6quk9UceCIM8K8rIkK0qsJWaOL5dAYn+ZgrKsGfousU/WYi3i1+4sbdcQvKXve5z1MTI1xabKRCEO3hGCS5TQ6ETghhbhFcF2CK0pc43CYfuGMjfgSjIdfQTcMCCC/MTJ7aKevrq8v4U2gnosN5l00WeO6OCrLMGHDcXcJrV3ZlJqqRTs7uywt7tDVVVopWKQlfdUVYFPKak++BQdHPAu0PZ98srKaZtmE7W7XDQ8fnRMkesEcq9XQecP0VXT0HcdfTfgfYh0YunSvRswmeDq1auUVRlXXIPjvffvsVrOkTIKDb33NGmVbK1jlNboOzvblGXBcrlgGHqOjo4QCEajOsaKCzi4fAmTGdquYVSPGNUjZvM59+7d3QRwrZMsi6LYUJTXtYkpEGLzfT358R9dca1ZnzH+PJnUctFYfmz1937z78ZozyyLiXcEpAiE4Dg7PUNnGc8++yyPDw958Oghs8WCbujJsjyG9ly+gjY5o/GEl156ia2tba5fWyThoOf4+ISTk1PW6Y7jqkB4y8nxLIogd3c5PHxM266oC4PzlpPDR1RlwaXdbe7fX+KHnt2dLUhME3w0nwveI3zAW4u3ljA4QsrEbpcrAoLcaHSWU1UVKvHthYhZ98tFgx0C+/sH7Ozts7O7z/CCo2lavvpHX8F7y2hUsb0db/KhbwnBbWzMc6Nxg2LQsFot6KUgVwad55RZTllG6qcg4G1P1wb6TOH7BukHMuWx9EgPrl9QmJqd3RFdu+Deh0dUZcV4b0JucoL3NPMlW1tbbG1t0a7auBe+qKeufuaLLyU/hkDTtLRtFzPvfaDrBobBkmURHwshsFqt8D4mRAoEbhh49ZWX+dxn36RpVrQJQLeJVluVBXt725xNZ8zni6hzClEomJmS7ck2dz66w92PPsJZy9npgh+8dY8v/tRrfPaNl6mqMtnLh436/OOPP+bOnTvMF/HePTk+S1T/nKKsqOqaX//ST3Pjxg2+8pV/zfff+iH//T/6l9y6uc0zt3Y2CY4RqO/pe8tf/asRl3VuoO97zs5OmU7P+OpXv8prr77Kyy+/zHK1AOCll15Ea80v/uLPb9iO//Jf/gu+8pVDnnnmGba3t7l58yZlWVLXdVLJR/r1Ouhr/dZ1XXTmSBjoutbNZf2+J/+/Vu1fNJYfU/XtijzPyUdV9A9a+xklQ0c7DJycnPDDH/6Qd997l+VyiUoupdPZnO+/9X1OT844PZ0ync6oqwol4sf7ros5C32fPrdEZTlaCp65cT3+u5nm1o2rWGe5e+cjsqzkygvPs1zMWS7m1FWOUfEhHhuJxttoi6KNJgRQIVDnOVWeszUa4/oh4hpCUkzGKJORlzWZ1qyWKwYb7TMOD0/xQaB1jrOBdhUfALZ3SKKgSkuDHRzL5TLaUBiDG1ZIAXmWoVRFXsgYA+ADth02+RqCgswYMq3JM8PezhbjUUVmBFVp2BpXuGEB3mNUQISBdjmjXTU0TUOdG4zU0RFBSOqyQIRAs4wrlvUJ96Kerrp54wbOO9quYzFfMFdL+n7AOosdBryKE/w6q0hJcM6jZMTrMl2wtTVhf3+fb37zGxwfHW3sj9q2ZTpdMZutsLbDeYsLPjIVPcxncx4KePMzr7G1NebhgwesVgO9D5ycnvHRRx/x7LO3mYzH5JlB63iohGhIm+dR9b9sOkCQ5wV1XTMeb7Gzs8toPObO3bs8evSAIvf0/Yrj48DBwT5lWfL666/hkwjY2oGvfe2POTi4RFWW7O/vs1wuuXfvLsfHxzx+9IjtyYStyYTFYoGWkt2dHT6+f5979+8zPTuja1vOzs42Vi15npNlGcvlcrPeWk8y61VY3/cbH7En/cKenFqeTJB8Monyaa9PzR3fNyu0FORGbWy9pYzuqxJBN/RM53M++OADvv3tb2OyHCkV1npmszkPHz1iejZlejbjww8/QGvNztYO3kUOvjE6vUXvr539S4wnY67fuMEw9Fg7cPnyJYQUHD64x2Rc8/prr/DRhx/w0XJOXRbkJk4YwTmkVww+IIRPBnICIwRVkVMXBW40QvjA4H3cB18+QGqDUFEYtVouESJLLrLHKJWxf+kKznq6picQfbukiAaTRmU461guF5FmnWV0y+iWkec6WuCT4foeN1hmqw7v/DpNAKMNRmtyY9jd2aIuczINVWkIrmS1iK+lUSCCpVutWM0XLJdLLu/uoGWJsxatM+qyYBiiA3Vd1+gnRv2Lenrq+vVrDMPAfD5HCUlwnhWBbogYhJJRV2VMhtEGrUTy3fObh+d4PGJnJ+bU37l7hxtXryFEtDQ5Op7y4MGUPIveqqaIThHex3ylrlnxl3/5F7h58zqr5ZKz6QqH4HQ65c4dx7Url5GTCWVRxAdyOqD1XU9ZV2RZTp4vWDeWqhoxmWyxtb1FVdfcv3+fo8NHFDnYoeXkpGVnZ4utrQmvvvpKUuIP/PD9H/Knf/I1PvvZz3L58mWef/55lBQsFwtOT455XNe88sor1HXNu+++i5KS7cmEd995h/d+8AMWszl2GJjNIl65fm2qqto0j816XOuNeHIdW5xl2ebja1djOPcbWzeai8by/4N67rnnEDKysbq+pxsGMl8g0tSilKKuqnSqOR8rXYgP7roaU1djrl0NDDaKIAWRqTUeTZIRXU7XtTjvsd6xWK24//DBhlXVtCsCgSzP8SHwwYcfcnR4yKptyPOY8x2cj0ysiUhGkJ48KxBCMp/O0qpLoDQoFVIEqePB/TtY61m2PXlWkOUlUuYgFNvjnCwr2BplVGVBWZYcHZ/g+obnnr2GVopRXdK0S5p2wZUr18iM5O5HFu96lPQgIvDa+4EgFPu3b2L7nunpGWWhUSrQd0vaJpCb60jpWczPsLZHCEffNfR9h7U9EPfUR8fHfHz3PlcOrjIaTSIzLAy0bZtG9ijkXFMnL+rpqjsfvB8nlr5ntVzG1NVuwFqHa1fxgWij0WNhcjKdJ0HhQJZl7Ozs8PjRQ37/93+Xs7MzpJTMFov481aKotJs7WhWjaMfAvPBobWkLA1952hWIfrLFQVvfOYNbly/wf7OFqMqY1wXTLa3kVqhs5zjk1O+/o1v8vjxYw4PD6PmSyl29/bx3rNarbh16yYvvvAs9+/dYT475T/7z/8e77z9A/7B/+UfJBxT8PmfiM3j4/sfgxDUVcVP/tRP8qu/+qt8/et/xnvvvcv3v/89dnd3+dKXvsjZySk/+MEPuHrtysaypR967t27w/bOFj/38z97/oJKRZ7nbG1v4ZxnvpijtKIa1VSjmuA9g7UxgVVKdnZ3gUBmMpx3SK1wybKJtTN6SvGMjDcLdg3jP93N5VPTWOrRKIJtzm6ovN45ROQUx/WPkhun0U2lHBWlNUpFf6GuG+KpSyiUkOgU9ZnneaTd9h3t0NN7hyUKmLSSKWI4muf5PnB4dMRisWSwjjyPgqsgIxCfaYOzMes+ywqkEDhbkmcZIUQuulSAcIm5Zen6geWiwVd1tN6XA0IaympCbgRGeYzyaOUIvgPfMa5jyl6ZG4KXuAHqwlDkmlGZxWhUN2ysIkLy7tqe1PSdoWtW5LkmM5IQLM4NKBUQePq+Bdarj0gxPSeoCLq2YzqbRZ+wlJEu8DjvQEQld9zgX6D3T2OtlosoELQ9fdcmY9SIA4rgkASMij9HLQJSaxBEen6WUVcFfdfwaLVMNNpoK++9p+8dnoDUgiAFzoFNtkBBSmzwdDawWDWsVg17O1tURY6RbuNQvj4k9tYxX6y4c/c+09mM+TxqxYzR7O7tb8BwraK543x2hgiOn/7Zv4QALl/ep+0arLXs7+9zaX+fOx99FK9Rozk4OOClF1/g7bffwrkosi6LnLquODk6YjqdMp/PqOuKLDMJM2kpy4Kd7S1MlsUU2GQWG1lrLW7wm9XYWoxJ2yaKtkBnyVofAU6gdcRE12yXkFzQEQLpHSEogopaGJ7ye+pT01hmyxVSRuxAmZxMREt219sYRrTmf3uPG2zytIo/tAgYDpxNZ6xWLSbPKauaL33xi2htaJqWIQmkzh4ecXo643R5BhLyMk/NKdA1Dd671Bw81g5sTUZsTUYwWEyA7dE4ZrXkGavlkna5YDE7QQBXLl+GEDiZPkYIQTkydHaJCo7duiBQsL9TU9djqnpM28XAn8XqFBsWdKbDdprlzCBsTyY9YYCu86xmFqMkk0IyO/qQOYFKOxzQuT7iJ8bQiSKREzQ2B8mI0bhmPK4Yhg6jHYQO52DVLpiMx4zH27RdR9/1aF3F6GPlCCLHeU3beZrOxtc6NZRATKdUUiGeftr9X8gajyr6YcDOu4S9OfrVFGct23W0JirLKokHO+piRFFW3Lh1C+cDp7NZDAQL0em4aTve/+AOZ/OGjx8tAI8UHp0bTGnYmmzRDwOHx8dIF9dt/+z3f5/vfGeH3/gP/hY3b1znF3/uL/Gtb32Lb33rW+RlRfDw9nfe5vHhIYdnS06nPWfTwP5ujkDxwzt32d3e4vWXn2e5OOUrf/j7/ORPfoHS3GA1O+Vgb4v/5D/+O3znO9/h+9//PkVmUFIwHkWfsUjkmdA1DV/8yZ/gzTdew3nP48eP+Gf/5B+jZKQxf+sb3+Du7i5f/vJfQ2vNfD49X1Wt7ZWyuKJ3BApVkhdFMjJIQWohUCq1SeR0SXzsk4GrUBolJEp6erf2A/PR9TjLkcqhraNPMoinuT41jcUnqu5mAFyLiaQg2HiM9j6aJWilCT5gg0v7TTbpbX3fI5TG+4DSBpPlCKmZ+zlD0yGVwRQlI52s6o1KjQWEVHhnkULEVEg7MFhP2w0M1pIZw+W9A0zyxhBKorRGe4OUgqLIGYaBtmvQCdMoioI8z8hMPJ35ECjKKoWIwTBIfAgopSlylQRm8aJSPu5drR/omgVmVFHkVWKDBUZVnSKOJykWOTraQhSVNasVZy7l04sYWRxCwAeHSE7L1sUMijwvMCqLSZWsxV8GkxUEIfEelI4JhIO1yaZC4sO5K+5FPV0VVeUdq8Ui0c+jt5sSikzLOHH6ASU8mZbs721T1TX4aPOSaYn10RW8aVYslg3L1Zpdto7/jjZBTnhEHxMQrQ/kSpAZyWLZcGoU/dDTNCuOjo8Y+p6qjLlG1nkePT7k8OiERdMThKIaVQglQEjquqSsyqiiDx5vLW1KkD05PkSbjOvXr3FycszZ2SkQ6LqW3d2dGL4VPKvlEtv3DMOAUlH/4p1ld3eHEMOQ6IeexWLO8fERdV1HweMmXsknzFclZUz0SwsiRTuHc8q0EPHwFbzfNB1UQIRkJu19tG8SILwnCLfJU/JC4oVMH7tYhf2YKmYROBewPuA8aG1QIdAPcbUVnENJSV2WLNoYKzqsVd9CYQebrBECzsZdsTE5o60tZosVs8WKajyhHE8otysCgd72KBEjhIe+w9mB1XJO17XRwnvoOZ0uGboVRZ7z+Td/Ai0lZ2fHKGUoqppRil8dTSbM5zNm8zlFXlAWBfv7exvuP8nOIVo+RB8n5xyj8QidmlAgXqxt225sHhaLlvn8iMnoClvjXewQTTFvXr/GZDLm6uVLrFZLVssFhYnMmpOzEx48/Jh33jlBK0dZSKzrEULh/RBvABxNs2LoB8ajLTKTI8kIPvoeFcWI8WQPqTI8EqMMPjiWTUORm2RsOYC/AO+fxjo9PWG1WvLw4/txjaQVk+SRJ0U8iK1xwXFd8carLzDZ2uIP/+iP8UGwtbvLsunou5a7dz7k6HTK0dlAEDAeS6yLTWXRWAZnsbMWKaOvZFEYJpVhcdZyNrM0bcO9+3f51jf+lP3dPa5dvcKqHVjNZrz9zg84OZ1zNrdcOtjl2sEOs7MzIPDCSy9TGMkwDGil2Kpr5menBDsgtOLqtWt84YtfQkiYbI15+PAhJ6fHvPrqq1hrefDgAUPXM/R9wklLbty4zmhUUdfVBtOZTqfMlwu+8pU/4sqVK/zkT/1UfBFDxBA9ceKI74ukmOBBrptKtAzYgO/e+9g4QgBtNj1qDdBLqz4B1se/Ez0CZXrePc31qWos6x9I2GSDxNyGaMvgsN6BINqzOIuQklxqnA/0gyXLMpwPSCXxwfLo8UOOTwwhQNv1WDfQNCusdzgRP5dL4i47DMymZ/Rdh7M9AFIEpFAUmWZS11RlgdHZ5jQvpUR7Q982ODvQdQPOQVFW4KFtew4Pj5FKpuyXaD8TkihMSAVSxknJh4RlxPFZJuPL8XiEMoatnT2E0syXK4yOkcHdYJnNFwx2iPiTUiyblhA8eVFgTBa59CHE05aNYsyhtxtKd9f1NK6lrsdIpRIHIIo+TZZR1zVCyI0pZvCerm1RImC0wDkJFzPLU1njUY2SsJpMNgQVbaKyXeDROhJiyrKkLAq6tmUhYhie94F2teT05IyjkzOmZyvalafKFV5EZG1w4AfY2aoRSnK2WIKAwii8C8xnPXWhGdWC937wDuO6pMpzmmbF9Exy/dZttnd2k00rjOqcrut58OAEJQaq0jAej8m1YGjmrFZzVvMpWzsTpI4i42GwPHzwiCwvee6lV5Aq5rdcvXUbaweUjJoQARuKsDYZJhNcu36DejTeEAR8yl3Z2t2l2t/HtR22baLQGYh7goAIMm1JwmZiATa04SftW9aY5Rox8cJHJ/MQf+2EizlPBLzzSETEeP0FxvJjqfUPwzmXwKuQiBMC7x3WDSkHOlpYG2sQTmLyMrJc/CpGjCJwITajw8NHWOuZzxaMxmPq8ZhVu4rjempMSEGzjJHIjx49pG1WiU5o2J5Morgwz9neGlPXFVJqCB6lNCIoUIHVYokdBtq2xzlPXlS0TUPbtJxNZzGAa505LnXi1luqukYnTKnrek5OTuNe1nvG43G84asaZTK2UoTAYtUwqkuUJrLnuo6j4yN2d3bY2dlm2URfr/293RiS1PdxLZhOW957hsGiQzTo6/ueZtVwcBDFXYR08whBlkWrijUlUoSY09G1bWwqXuGcfMLr6KKephrVFUoKVuMxa+m90cm6PcQ4apPniTFZ0DZNDH9zA855muWS0+NjHnz8iPlZoLcw2c3wBFbdAC7geti+WpGVht61EAJ5pmkXA83Scul6xbiS/PD999jd3uLlF16ga1r84Pj8Fw7QJo/3hoBRnXE665geLdjfzagrw2hUY5RgPjRRcjCb4kOI943S9IPjwYOHXH/mGW7eukXfdjTLJQc3buKtxQSxiQEuyxIhBLPZDK01lw622Nndo23beJ0Djx89IhuNqPf26aZTwjCgRPQf7P25XiWECLyLJyaLcz1KSPZNiVb8icYi8On198nfb71GcyRwP8T48qe5PjWN5RMjpBQIFbOfN4mL1jH0A97FlMOrV64A8P6HH0ZjOmUY1jvMEJlely9ditYvzjEMHUePGwZncc6zWqyieNIO1FXNpJ6Q38iww8ByMUdrxXhUs7e3y97ODm+/9T3en57xw3ffS4aPoKRAScHJ8THWDhxc2mM0HnHl8mW61mJtw/HJlH6wHBxcIS9KRpMt2ralaRsQCheiiePgPH1imeSFZu/SAVVV0VlPt1xxenJMVZbUVcHx6RQpY2PJMkNZ5CzblnB2Rp5laKW5e+8uDx48jHtlKSPnfojkhH6IqzCTmU2w19D1dKYlU0U8QaVTXvQy8sk+Y0g24QHnXVxP6Is12NNawzDgrEUJgU0mou2qjxOtNpRlzmR7K9oNCfjwgx9G4aSQLJcd9x/cx2MZVRk3blxF6pyPHz+gaTuGPlCYmOFycnhGEBJjfMxGOu0YFZKdS4ah62mk5Ff+0ufY2ZqwvTXBJ/xgcnAJXZTs7m7jrMMGqAsFSJ5/7jb7e9s0TcPS9kxPT/ns57/Am6+/kpiJnpPpnLBqyIsyYos+UBYltu/51le/FsXDRpNlOVkW/cW00XT9QD8MUdysNCbL0WWBVIodd4kALA4f07cdw2ApyiLiukmv8ue9rStOPmGjuA8hEOy5zuV8kgmf+PX6Y/KJjz3N9alpLOumYp1FC4VEMSQx0Xo1FoH6OM1MxnF1E7zHO4c2GVrFZDaXfqhaqQiM65hdEryLILoReLeKeRLOJ5VxZJM4Y8A5pIwkgaooGY/H9F3P9GzKYjaLQVrGbBrL2dkZ1g4R9Pdw9co1CPHkEnO2PUFIpDaUVY1HMLi0+kqU6sHGFRhSorQhL0rysqJtW4bBsVisku2Fpmsb1gFCRZEjZJzquq5lPIoBZscnJ8ym07jCEmITlxrH7Ph6Smk2PmLBB7x1kf64LgFCrG+e+DqvvaXWzefTIOb6i1rnyYUkjzgf81eCxwlB8BkqxVCH4FnMZ3RdR1WPcdbStR1FqSmqkoNLW+isYLY4jdd5AKM8rXKcLSPWWSsJPuCGgCoFZa6wqwE87O/tsTUZpViG9CDVCmUMV69fxwfBw4dHTCYj9i7tcunSHpPRiKEfGPqWpu0oipLLV65ibc8w9CzbgYCg6zratqVrWkyWkRclh4+PUEpitrc+0QB8NEwjELDOobRBGYOQCiElpsijk3nb4p0HKZBKo7TGs35Ohc1ru77+Q8q5kVJGfVsitqz//Lq8jzo4/6OyCdh4DCrlLxrLj6sGu+bH90COUpLlcknXdwQRrSKcH6KNvXfcuHGD0XjMhx99xGLVYJ3n8pUrjMdbtCnT5P333sM6j5CKvb099vb2uXrtGkVRMpsu6NqO+WLB6fExpyenTE+PsdZy+eAA5xzT2RnD9oDwgslogt215LlGEJkh3jq8s1y6dAVCoG1XDINjGGKmvEdycOU6MdVCgMyo6m2GoGiHwIPDe6yWq2hSJ6LFvtAaZTKCiA4E9WiE9Y7BOabzBctmyWI+w9mBk0QaMEYz9G00zSSeIkutGPoumvgNFj9YMm1Aqci+857gPJkxqPEYrSPjZR2tCmxM/JKjZhRPCqjrEq1jiJkSEnXBN34qq8zziKUYhfcS7wXFeBQbjbUEbzk5OkQbnX6eDiUD8+kJVVXzSz//2eQWoQgiHtJeffE2CEVRVDw6POLR4REf3j1itmhZrWKcw3YFGQ7bOrbGGbvbGWWu8K7n4eEJ4/EWk/EW9955m/HODv/7/+P/ga/80Z/yn//d/y2/+Zt/h//0N3+Df/hbv8UP33uP1WpJ17Ws2ob/4X/8x/zO/+N/4Dd+4z/kldde4Wd/8Zd59PARv/97v8vZdM7jh495+Ys/xf6LL3Fw+So+hXCZLCczhsFF2u/epYMobdAKoWJDWa1WcT0uBEEAWlONSoqiiHEYISC6boOPnjcWnmgu6X3JQzA6XwSc/KQJ5Xqa+VGlfXDx8KaS3f7TXJ+axrJZeT3xtgbVhUopaz7S/NaTSZaES0Yr8rwgM3qTkZBnOdevX6NtO05Op1RlwdbWONEVV3jrYn5JWWLrEX6IOhFE4ObNmzRNVKILoO+6RHNWm4fo+tTinacoo0AyuiFHkZgUkR+vTYaQCosgy3JCaiBKG4zJMZnDJGFaun7jmO5c4rJHcDDGrMYgICGjIBQpcd7TL5eRHu0sQ9/FqcQYQmoSkW3iUkSq3LxvGIaUGSPXFsmEiCRG0eMTTq3rzBklRTQJlSkHJhnuXdTTV6NRjTGKoW9pjaJrZYrPBtd3cc+fBMFSqMgWk1EblmeaIo+YpSdS1PEBEWIUcZFr6jJjUhfs7dQYrWgfrYBApiDTgtwILu1tsbe7HaeidFqfT8+YnU0pyhJtMra3Jty+dYNf+PmfoSoL3vreO8ymUyDwzO3bEByr1RX6LlKGZ8slH3zwIQ5J3w9cvX4DJSTz2Tw6CQhJWY/wdsC5IdntKzob1+BSpbWTNvG+EwKhJJJ4wBMAyY0cKbGDjdML51HjACEIxBMT/matJRLxSLKxx1l//N9YhaVjKoBPv9MJf3ma61PTWNYeOtbazQ+ia1d0fY/JoyVCXHEpyjLHpIebd/HBfHD5gFXTsZjPEFJRljW/+td+lcOjY/7pP/tddne2Odjf463vv830bEZZVBRFxe7uHpf29ri0u8NkMqGqK1544QUePXpI1zRA4OzkNJ4khIy73OBjymISXY7GY7LM0PcdWhukUBiTU5Zg8iKCpEWFVBprPUIoirxkd2+f8WQgNxnOWZarJatmxWw2o2lXaJNWC9Yy2ZrQNku6pmEynkTTPmPo2obD2RllUVCNRkxPe2xvaW3UGUgZGV1dN1CUBmNijKz3nsWiIzNrjU2ssBnbQ1wHJt8jpRRaCrRWFGVyFwjufMV2UU9dXb92hb7vmYwrFvNophq8izjbaoWzA/3QbVJU82QC6ZyLqx/X0/cDXT8gjSEEwWo+x5iMMteURrC/PWZUlyxWHcfHP8Q6S65hVComteGNV1/iysElCNH6vipyvve9t3j77bdRxmCKAr9c8NmXn+P/+g/+K/7r/+r/zN/9O3+Pz7z5HM8+e4O/+Tf+BpPJmICj3t2m2JrwX/+X/yV/8Ad/wGg04rU33uQ3/zf/Gd//znd467vfZTiZQlFhqjrep10HxGmiH2KSpPNgsgxTxIOZCw6Tl2RCRObpE9UNltUiOg+M8jJ59/knHFc+uQpeZ9qvFXlCpEPgj2AsEJuOEnKjg/FEYD+uzy4ay4+lnE1aFe+iniRRHgWk03u8IfI8Y3t7i+n0lOlsyjB0OB+Yz+eJJTXEnaiULJcLFvMZ07MTbt26we7OTsIiGrbHE7wduH/nQ+q6ZlTXSBEQwfPRB+9zenaKViJRFA2zaQnBopVas3Hp2pau6zbW30qpRHX2FGVOWZUMziGV5ubN6wip6Hq7GaXrUUXfR9ZJP/RoIwnB0fdtOjFmBOfwbmDoG+qqYG97i65vovcQAWMUW1tjgouv26iuoCoJbQvegbdIub5I00Wf7oV1Q1iTI5xwSBVH8OBBS0VZFGgZhZt5nqUTbdzbBwQ+eMTTPbX/hS079Ag8o7qOYt8+alIgkOcGcsNIVBR5TlkUDEO/WdOoFFQ1nc5om4asLCITUkwii8tbbN/QrlZs7e6yu7PFL/5czXR6xp27HzCuDFvjmqrMyYym71rmswUffHCPa1ev8Lf/9mcYTbbo25YP33mLrf19rj77PK+++Sq//ut/lRdeeIbtnQlvvfV9tre3eO6F51hMZ6xWK1555RUmdc377/2Qw8dH/PY//IcxbbYoeO/993l0eMjrP/ETmDxHVhrX9/i+pygrsrXhpdZRSB0GrPOovIi+ZQnHjUaRcULJyjJioag00QueHF02vwzrpEiZ8EmI478//0MhIBF4orluiH5V6fPECUaKKA59mutT1FjSA9f7uAvtQ9KyiE1jCcGT5xlbWxPOzk5pmo5+iHTa+XwWacfpQS6lYDGfMZ9PmU5PEQS2tyYQoo1+ZjRt0/LxvY+4dOmA3CgknuAtH374YYoklVRlzmhUc1wVBD9Q5HkM5TGKpmlo2xafmp7SMeku4MmLkqqqmC2WCKm4ceMGCMHZ2WzjgFrWMePeD5a2a0F4uq5huRRkmSbPDcFKhr5h6Ft2tydcPjjg6OgxTdvg7YAxiu3JiMViwXLesLu7Q6Y1y5NTvB3wNqT13HkFH6eRdQBRXENarFQoEW+o4AJaKaqijIFmCPIsani8H6JnkhQE73AXOpansuzQo5RiVFcMfQS4h76FAFmWYXQMqyrznCLPaZp4Mo+pjHFKbZsmkl6UJMujSap1nlXb4fqWbjVn69Z1tnd2eP6F29y//4Djxx8xqjK2xhVVnpEZyXK+4vj4hG9/+20+88ab/K2/9bf4s298k5OTUz589x0Ouparr73Oq2++Qm3gytWr+BD4nd/5HXZ3d7j17C1WZyv6ruOVl1/l9jO3OXx8wuHhIf/ot/87Pv/5z/O5z32ODz74EKkUL77xGUxZQZHH3KSupywrRPLSQxCxI2exPlBojcwypI8ehYPvNmveTMg4yXcRs4kgzHmOynkljCWtwtaNZW3Sul4nw7q5JCLBE2uxePSLrNOnuT41jeVJEGsYBrq+j8aPRtEnFbp3jrIoqcuKP/vG16PdPLG5d12DVoYiz+n6gWa54Ot/9id4H3jh+eeZnZ3xz//579E1K8Z1zunJ42hgd7BLkWv6bsH09Iiqrnj5hecoipxyVPPRhx/y4YcfUlU5WkerBikFyiiUKslzHYE/C1IVlGX8mp997jYvvfRSspRR9EOkIe7u7saoVal4/Pghx48fMT07Q6poXzGqCuxkRK4khoAuDCKU7O1sIYLj7OQQb3uMBF0VOGdpVgOjqmRUFpFz73wCAn08LBGxEpsYQWVKvhuNR9jBMvRD3PQ6R3QfEwQf0rotQwhJCNH1OXjHcrlCKoFS0d7lKV8H/4UtYzR5nrGzs4WUMfG0Kgx2GKJtiIhEjzzPKYoMY1Q6ZAx4N8T4awJlkTF0DV2z4vHRMaPRmBdeeolb169tGFVBQNM37G5V/C++/AsYbciMAe9ZzOeURcnt2zc4ODhgvjjh7//9/4ZlE1fHX/qZv4QJDv/4IQe720x++ku0Z6d0q4af//mfo6wqJpMtjo9PWDQtl559jsujmn8vqzk+POSdd97hwYMH/JN/9nv8zf/oN3jm+ee4d+ce9eiMG88/h5IaWY2SASRsMgO0JlManRU453FNl1il0PU2YkBFSbdc4rwlN1n8HN6d27VsWJEJo/Ruc0COdjGBoY/opRTrxdk5xfjJ/6+Fop8G6/xPTWOx1m5+7bzHWkuWaUSQSdwV95oqOYmuVitmsymj8RYyCHo7xH2lj35fznumZ6dkecH21nbMjzh8nE7eUZ2rpKTKy+SxNdA0C4T05Nl16rpke2eLj+9r+r6NmI7I6Ic+Oa1KpNDR78j2CBEwQiXrbcgyTV1XlPUIISSPHh/HnWpaKwlCBFWbaMWSZYbxqCTTirLIUIS4xhISrQRlnkdwvmtRSiQHWoO1Etv3kR2mFbbrsQwYo2OTUTJpVSTeWwSRtLC2kOlFD54nvq6Iv7RtR1VUZHlyaBXxtXchUpVDUh+D5ym/B/6CV+z6WinyPMPbApuU9yHE1NNINw4poz0wm3WRWh7iyjMzJq1vHW4YIHiqIqa11vWI+XJB2/e0wVHmht1b1zeWJ6cnJwz9gDMGrQ27uzvcvXuHe3fvYfKK0WgcV7XO0U7PyHb2KPd2eLyYIwgcHBykdXSe3JcFpiwpx1vcfOY2k/EE5zzLZcOde/cZbW+zvbfPg/fex1rL9bU42Shw0UcPGTOOkAqp4krK9l2iB6cVL4IgZGqaUSAppEIkGf3G13BNnQZIyEq0gEmefz5EYXQIEehP09J6Df1kY/GBDS560Vh+THV6ehpP0aMR3ln6viMEF61NpEQoBRIG27NcLTf53FJEm2k/9EyXS/quB6nI8oI3Xn8eY7IYxzquorXLqsENlq5Tka/eLdJqSnFyuuDkFI6OHqCSweRyuWS1XLG9vYUuMsIq3ogmEwhhEFJQFOoJN9LAMHR881vf4Fvf+Rb9EHPFsxRMpnXCTbxn1UQ21+5WGeMAXEtpBHpcMbQL5t2SvMiAwCjXOAfeCvb2dymKfOM11rZtooxq5tMpQzcgEwUa7xiNKvIsp2kj3XIymVCVJWVekCmDywoykyFldBM4OT7hrbfe4tnbz/Lc7eeQkkQCsITgMJlOjX7NNPu3dtlc1P+b6rqWplny6NEDjImmqGsH8aHvsIkh2TYxifS55+KkfvfuHay1G8X67u4O+/v75HnBG68POB+z5p0dsH2LG3pwA7mRFEXBpf195osli/mSPIvxEt///vc5PV1y796Mn/zC6/zSL/0Sk52daH6qc+azKd/65je4+cYb3NjfpWmWLGZTbAggJuRlyf7+JcpqjF+sOFs0NLM5Rmt+6os/zed+6kt03vPuW9/nD//xP+Hk5JjLV67wQtOi6wpVnOOOIk3koevxqRnINI1YIEhFMRqBELRdB0qjhdrgiTLIuA1LDDDWRqxhTT9ON4QQBAlKq3PRsfAEGUlI/IjHmPeO4BXaqYvG8uOqT4i5+CQgln6xEVF6nyi36aEm0r6fELECEcA7G4EyITZxxAKBcI5BCaTIsVZCsCglN6cm5xyr1UA8lhAjjbuers8IZDgXJxbp0unDiUjFTENuNJH0DF0XTTIHSwiQmRwlFSbLEyDvcG6IF6MUuCCgt8m8LjJTggDbt+llWE9sYiN2szaCrQQPPr5ppcDEQxk+ELyI3lBincUt0irunAIpNzTI+A1E25chUSwhgpjpg+m0FY334vvl074Q/gtaVVWm9WdIE63G22grkmUGrSRKxvVutClap7fGa6aqK9aEj7VqfXd3F+scs/ky0dRJ0cISk/z95vMZdnBxVZrSWff39wHDnbvHtF3DbD7n4Oo1tra2IIhIm+8tw2rF6vSErMipd7dxg6NMqY0mz6lE1J6EANp0mDwnH09YnZ1xdnoGIaal9oNlsVxxeHjEJOwzNjmJZ7zBOQhhM2lsPFcCIMJGAe8DCGQUDicQPkjiPbhZXsmEo6zvkTVQL9I/Jzl/PqyRFOKfW088axqyEJsJ52muT01jWdNa44QqE3goETLJEb2PuQZpRM+MIc+Tcjitt4a+jz9ab/FWslouEALGk62oMBcKI8E5g600dhhYZWk3GgIu9ASi7bZP67g2Mb8QFpNluKR4dz5SoK3zn9R6ENdK1tpogqfiA3zoGrxSEZRLdGVve4L3NLaDtIONF2JkoykhaFfRotw7u/F06toVfdcw2B6Sr9cabDXSkCVzPu+iziYqf+Pn1EqmRiM2hp9AwrAC+DUjJqlaQvy7sGatyKTUjz83tWbJXdRTV9evX8day2q1itebS792jjyr0EqSZxlDF2nzyphoc5JlZJnhxs0bnJ1NmU5nNF2HzjKef/55hBCczWecnZ0xnU6pR1soFaf2s9NT3nrre+zuX2Jv7xKz6ZS2G/jLf+XLPHr0mKOTY85mR/zxn8y5/dzzbG9vk+c5drDM50v6s1MefPe7XH3jDartbZgu4jNZKooiIyslsqxASPKsQOoMtnf57tf+lH/9u7/LL//KX+aZ517gw/sPODqZ8mff+DYvvfwSLxYVqqoQWsepJZz7fAVC0uqkh3mI7NCQGF1hTU5JDSKIqBmOXScdsnxqKjKRjQMQUiSHSmwxH1IjOb9hQuo5Aon4FCWxfmoaS0hWI9bazcNufcL2YT3JhDilaM1kPIp8/L7fWJ0oJREi4F3A2ej5pZRid3cviRsVQmTROLEb8B6kWtteB4SMoyp4fHBYb/FEmxMXHMIPWOfwSqG9jHkXfYxxXTOspJSxmaRmYHSOUgov4kovMyqOyh6s0En0uT7DRHsZJQVlEcWfdmjBxdRGrSRVWWwamMBs8rfj4UlQFxUEwccnHzP0Pdb2EfMxmqI0EQMSinVAGutJhTgJrS10tFKRDukDyJDG9eTvmixhYkM+V+pf1NNVIXikEtR1xfqELmW8bn2KzPYusRpDdNvWSnFw+QplWXDt2nUmk20WiyV5EWMgtMkQQlCWFQFBlheMRqO0lrUJO+zomobVasWNWzeRUuO8Z7K1xV/9a1+OA3YIvP3OO7z33nt86UtfYryzy6Xnn+Ps8WPOjo641LYI58CkXBQh8RuVe0TB226gmy+Y3v+Yqij46Z/9Wa5cu05VVXzhSz8NUlCPRozqmmXTUlcVRirW+So8qb8KfoM1racO4X0KUREpyXY95YSEncTXWCBAPmGfT2xMiSQGrCeQ2JRC/E/8d9cr9DX+ItMUFJ7ue+rT01jWD3NrN3460exRnp8YiDkhWmnG4xE+eI6PjyPmodeNhQgy2sBiPifPophSJ22LUBGrGJzA+Tgd+2TBIIRHyLD5WlyweDzIgMfhPFg7ABrndXQGbpq0ClqPrgohTGyUzqJVGYPBVByJjVEQRMxySBejFOlCCzEmWEtJVURa82op4iQRPEYrqrLYsEYkcoNLuRC9xsbjCfhA0zQpa6UjyzRVmVPXCUtJ6vuQOPUb2mRg4wcWtSvynPkSSOFFPu2So5G49xcYy9NagThNZ0VcwyopI4FEKRaLaFDZW3euCJcSk2VcvnyFuq65eu06TRODvdZTsU5i2qKsMFnOaDRme3tClmVY17Nqllg70HUdTdNw+/mXqEdjZvMV48kWr73xZozp7jr+T3//v+He3bvcvn2bfDJh/9lnmM3OODs9ZmhXBGtB6cTmEgSbskzSiqrte85Ozvjh++/z7HPP8frPvrb5Pi7dvAlKgVIsTk+Zn51RhMiMw6UF2BPXrRAJ80jdQBBSUwngSaC92tynQqapJIIrsRGF9aTi43Tj1wGCaaoR4bzZ+PVhVmwIA4S4EYjYzf/fLpP/r+pT01jWO//oVRUieJ6wD+/OJ5b1RLA1GaOk4OjoMd6HmDORTCH7EBvDbH5GWRbo5N4KfnPyGIaefujpbb/BbpDE5DoZryHpoigwzzOKotxgC+s4UyG6+HulMMZgrY92LcoA0TwyWr/Erz3g6IfEqvIpa15KMhOVud4NMY8BQEQWSVHkaK2i63FeoKQhz6K/EUKidYyXdWmFJaSmtz3L1YpmtcIOA13bMQxxsirLKq2v4n53jbF4H0FMrTRFnrO1tUVVlTEqeo1BPaEy3mTnhHDRWJ7SquuaEEJ0tbCRRKKUoizL2AispW1WG3silRWYomCrih+P/nYKqXTcCEhF0/dRg1VVG+ulth9o+x6FY3trwpe//GUOj085Op3SDwO6HyjrMSYvWHUDmckY5yXPPvc8Qkr++Gtf44cffsjJ0SFKCCaTMR+//x4nDx/y7IuvYqoK6jF0A972fOPPvs5iueKVF1/k0tUr7F+6hFSabnBU4xHa6M2DPbieoq4xVR1NZtuOsMYOZYgP8jXmEqW/Cc5fbxIEqLimEj6ytlhPHGEtFE4rrhAnKRHWWIvf/F6EuGZOWH3CbMKmyUTY5pP319Ncn6rG8qSHzo/iFpuTRMIgssxEC4r1CQI+8eZDoO8jcChl9PSJP8c4kTgXcQ4X1sFicUxd0wFhTQqIoLfS8QS/jksW6esDsUmEjL5B5wE/URMQksPwOQMkpK9ZSr0Bv0MAXLpISReWYLNiW58YIdIelVIgFUJqAjGLGwG9dfS9TWJRvwkOiwCu3virrbEe0te8HkzWdO6iKGIoklbp9fvzf25P+w3wF7m01skRPF6D3sXpZM32WtsorQ8IJoVgqWQ8Ge2xJErpGGynJNa5lCuk1t6kuGT2iHBkWc71GzdwSJZtH/22hEAZg9QxlA8p0cZw6eAybdtydnLM8ePHfPSDd9jZ3WVnZ4f56Qld0+CfezF+M0rRdEvmZ1NOTk5pmgahFGVVUZUVTdOyatposmoMwa4lCh6ls4gftav4epzD55F5vNagAGvSjlivo9ZrakECRJIPmE8t6El2GKlRne/A4jPBp/et8ZR0yE3Zxun95z5im9X0U1yfmsZSVWV6uJ1HdWqddqB9v3H+tJCmBoE2yRwhuBhVGjxKkPLYwdk+4RwyPWTjyc05iw0Om0bq9WUgpELqaAnuPFgXyJRE6YwQBC5EsI7kPCyVQas8vRn6LmrQnQ0MvafvPfPFCm3UhowiVGSzKSXRQhCkYAjRzrxtVxvlrSnyaDIZBEhDnlW4IJktW3IX87e7PgYyDb1Fmkh+aJZLhrYDJHmWo/KcqqzI85JRPWZUjzE6rrI2zQdSQqQgLzRlWbKzs8NoNCLP88S/j6u72NwVQsTv9WJaeXpr3fRjLghx8k96JanidVyURCqyMezs7CCE4AfvvUue59y8dYtMa/K6TLghLJsFvY+2+y41pt2dHbJM0y5nICyZgFu3b3P15rN4FNbD6awlSI3OcxzQ9D0/9wu/iBsG7t/5gPt37/Cv//BfMZlM2N7e4sWXX+Pg2g0Yj2FUA/DVr36V3/8nv8ev/S//Oq++/gZ5WYHJoKpwg2XwgaA0QRva5RwBZLmhb1v62YLBRbJLWdRxbQ6w9gPf4JxRYxY1JWtD2XhXRjA/6eoU6VDrzvESnphCAnHlDeeMys1UEyPK05C0SaiUIqQp6wkM5imtT01jWb/4m6yGzWubbKrX00p8DyKtkZRaZ0e7NJqmCSABfGJz2k7MsuDS2shvHITXjWyNPUTyxnrVEy+C8ARwGEKM+A3p4ktTLs759LE0AiOx1qVMGLGhSEtBSq+UsbEkJ+embZHJhj6uJ1IanRQopTcBQsPgQHiWq5ZhsDRNS5bnmDynWbXYrsN5j0yYjpJqMwVGirb/xPezvsLFE6/ZmpBw3jgia0Y8sQ77N6jhF/VU1Xo6KYqCobf0ekgJrSHGOoQYgW2yjLIsyYsCISRVPUIpFanyPuBcIMsyhBQ4HxBKYooSaS3SWhCJYCMFEokWGl0UBJPTd47Behor0VlOvbOL63pc31PmGSIELh9cJjjLM8/c2uCW1lqGYeDh/XvUW9vs7B1QlyVXrl6Ja9q6Ruc5KoVpSaXIi0hiCc7HSYmInyIlyug4cKR1+vo5sU52JT0jEoS4mWnOp4f0dj6+sAHZIyAc+8r6tX/iv0D6pOefZ/MRKRKLeY1ziSQKv2gsP7baJEiKdWNJD33WuItKP6sISq5vGoC+7wk4pASjVEzNSzYWsTmtkyhtcnXt6YeBzrrNKcMYRRASFwLWewbvMQiQegNqBx/ZKX034CyR8eLiHqvrhghwakcIEiUNfdcT8GRlhjJxLWCUjlYYWhKEoGl62mbFyekZmTbk2rC94zFCMNiA1gKpDM5bBucYuh7nA8dHZ7Rtx2weo5dHkxHdaoXte/zgyLSKFGMdL4P1hfujr3n8WLzZnIsZ3PHvqfgzSCcx7x1SBGK8xPkB4KKezlIqeoHt7+/TdwNd13N8ekLTtjSrFRAPLEVVM9naohrFhvLCiy/Tti2np6cbHGVnZ5ssyxgcZFXB9pXr+L7HdR1ds2BoO7SITr5GSvRkBzXZoZ0uGTqLyh3ZaMzurWeZP37M4vGjKBiWglvPPMP161d59ZUX+ZM/+RP+9E//lBAC7WrJH/3j/4mDq9f42V/6K7z56qu89uobSBMbSlmPIQRsP5DnOWVZMgwDQ9+TV2XEf5qGrIi5Kut9r23b2AukjN5hT7DDAi49h55c8wogqfDXbMj0p1kTXAQEkfRkm/aSnIvFWuOyZnxJNnvEIM8Pa2liiT3uorH8WGodQzwMEROJp4nzKUYIUhhVSEQNhxSkxETJ0PfIJAIUImk70inAO4sbBuzQY93AYC39YOltxCJIJxRtUkdL43EIIuIZOiOEgRDc5jqKILxASk3wcU0WfAQ7lcooS43RBfPVHOst5ahCKgEKgpRYHxAumkf01tINlrYf8NGVn26wqMERpMQjGVwgCIXUCheI7CxpUAaKCkxeImSOzgICxWq+ICSV9VqzsnYxFvp8B7yuiLucW0kYrYn2LmFzMxEsSDbisfW1/2QmxUU9PbV/6RLaGExdM/glvusSCSSnKMpIOsniA7msEgHEe4oyCiOlmiOlwhjIsgKpJPP5CdYHts7ONoC0S3oOPRoTnKVbLMB5VIB+cAzWUpQV3gce3rmLCYHReAJuIDjHYjknuGjpdPvZZ6nHYx4+fMzH9+8jipq+72nbFlONKYsKshyhNGsX4bgNiJOHTFN9P8TPl+VFJN24GKUdnE/2KmvTx7SWIjWSBMBHhlZam6Tnyfp6jxYv64s//ifCpz860ayxGngSd3mCn7PpM4T0PbCWXT7d99SnprGsgcRhGDaMsHWFxDFfs7JC4m4IBOPRCALMptMnQP8IUiokkuicbO2A7Xusd1hnGWxsMNa5dHnFZiKESGB4fBMiApfOxnQ8kZTK1rq4tpI6UdED3ss0qWRkhUJVCus9veupRmMQMPgefMCugRxSTsTgoqV+im7oBou2FkT0Khqcj67NSuOsi15EUqO0pKwzTJYjVYbJYsiYcwGvQWuDSDRT51yMY1Xryfz8ZlHJncAPkZevld7QoKMyOzaWEARBniuJf7RBXdTTU7t7e5Fym2XItksrWU0uFaPRGGMMeRHzgqRSzGYznHNsV+NI5FB6s242WQEE5oslg3UsptNNFo/Ao3RsLLZt6U5O0enAFt0nHNWopGl7Ht+5y8H+Pjv7ewztiqFrWS6WgKPMNM/cvs2rr7/Ob/3ffosHDz5m//qtaErbdZhqQlaUkBdRJ+DitSc33l8SoTyCqG9TSlGUZSTnWEffRDPbPM/j4Qg2K/NY56r4J5ZVm1X6+W9Ewk/W663wxF2Q7hnEOWPsyVsknC/Igjj/d4Qkssc2X8PTvQr41DSWTzLAYvmwZrS41DQUzkXwvU2Ox+PxJN0Ekae/bj7eu5g/7X1Uz7cdbdsxeMfgHdF6LoLQm6YiddLOKAQyqcvjiWYtmjUmj4D50KCkxuiMKO4M8XSnM6qyoixryqLEi0DvBm69cBuH43R6Qtus6JoGLVXSRElMZuJDX4ASEpNHJksQcU+8ajqKQpKXEm89AUFelgipMHkR7TB6G51dAjGMqciZTCZoHYkOcuPrdZ58t14/ah31NEbrGFSmI6AbI1Rjgqe38e8rFb2MfPAXdi5PcR0dHqKUIisKmsWSvu+jo0N64AK0XYdyHq10BPaRtH1HkIIr167RpZhvkSjq12/eQBtDXlScnJxwenrK5Ut71HUJPmqttre3USaDfmAy2cYHgfOSvB7x7JtvkoeA9D5mopBxcPkgJjjWBXQdQ9Pw6iuvsLd/wJ1HR5xNp7z19tvcfgGemexiuy5N43ENHkIUZfbDQFGU6DxHGoN3juVisbmOAxE7jVuRJB1IzXbzsF+zNjeVHvQCfLD8G7X5i0/gK+LJKeXfaDvpfeuWkqahJxilmyTKp7g+dY3lEw0mhA3OslbFrhtNfPPkeb5Z95wv/M/HzvWftymd0iY7lfMfYgTsxZO/fwJkW9d69SOlShNKHF1j8wKReO/xhBcT+cqijLYTXjGZTLDB0vQNztq4upPRv8xkJoWY5cR5iWi7ImWk46dpw2/A9lhKpUCmosD5lq6z6TsPiXmmkw4l0SrT93VOjDh/TdefOk5hctOoz1+j8AQVcv1n115IF83laayubSMBA7Bp1RxFjgatFC543OAQTuI2h6uQplpFWZXxQWxdZE1JSZWyWqRSDNYyXyzY3d6K10+Ih5Msy+IF5yPo74VmteqRxlDv7iJWK8JqFa8fqcjKEmE0jGIwnnWOra1tPJI7j44Z+oGz6TQaQsLGKcAYNlundZQ5RYlcf30hanjWNP31U2GdJ7+JDQ6B/7nH+I9e85tfPPEXPvF309fz/9EdsV6brYH9Jz7R035Piae9813URV3URV3Up6ue7nzLi7qoi7qoi/rU1UVjuaiLuqiLuqgfa100lou6qIu6qIv6sdZFY7moi7qoi7qoH2tdNJaLuqiLuqiL+rHWRWO5qIu6qIu6qB9r/b8A4jbn3v6aOMMAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -623,8 +638,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "Cached model found, loading...\n" + "No pretrained model found. Training for 50 epochs:\n" ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a387616480d14c769f727ba946861c51", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Model fitting: 0%| | 0/50 [00:00" ] @@ -669,7 +698,7 @@ } ], "source": [ - "plot_losses(training_loss, validation_loss)" + "plot_losses(losses)" ] }, { @@ -681,7 +710,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "F1 score of model with corrupted data: 0.7784210235437161\n" + "F1 score of model with corrupted data: 0.8220443349753696\n" ] } ], @@ -706,7 +735,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e01293d753ba4849a81952872211faca", + "model_id": "902091c124ef41f9b9ff9e9b3256bf42", "version_major": 2, "version_minor": 0 }, @@ -720,7 +749,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0100362a5b4c4258909c8b5cb39727a0", + "model_id": "36b99ba5c5af4183bd07e071f9f6bdf7", "version_major": 2, "version_minor": 0 }, @@ -734,7 +763,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c40cf2550efc4fc3aa94414c39520eed", + "model_id": "f3547a44a6f9415880e68060b4b6ea78", "version_major": 2, "version_minor": 0 }, @@ -784,7 +813,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -817,7 +846,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -870,16 +899,16 @@ " \n", " 0\n", " tables\n", - " -0.103410\n", - " -3.208211\n", - " 3.104801\n", + " -0.192024\n", + " -3.603061\n", + " 3.411037\n", " \n", " \n", " 1\n", " boats\n", - " 0.009908\n", - " -3.637032\n", - " 3.646940\n", + " 0.024808\n", + " -3.628917\n", + " 3.653726\n", " \n", " \n", "\n", @@ -887,8 +916,8 @@ ], "text/plain": [ " label avg_non_corrupted_infl avg_corrupted_infl score_diff\n", - "0 tables -0.103410 -3.208211 3.104801\n", - "1 boats 0.009908 -3.637032 3.646940" + "0 tables -0.192024 -3.603061 3.411037\n", + "1 boats 0.024808 -3.628917 3.653726" ] }, "execution_count": 24, diff --git a/notebooks/influence_synthetic.ipynb b/notebooks/influence_synthetic.ipynb index 7e7325bf2..27b706934 100644 --- a/notebooks/influence_synthetic.ipynb +++ b/notebooks/influence_synthetic.ipynb @@ -83,8 +83,11 @@ " decision_boundary_fixed_variance_2d,\n", ")\n", "from notebook_support import (\n", - " plot_dataset,\n", + " plot_gaussian_blobs,\n", + " plot_losses,\n", " plot_influences,\n", + ")\n", + "from notebook_support_torch import (\n", " fit_torch_model,\n", " TorchLogisticRegression,\n", ")\n", @@ -227,7 +230,7 @@ } ], "source": [ - "plot_dataset(\n", + "plot_gaussian_blobs(\n", " train_data,\n", " test_data,\n", " xlabel=\"$x_0$\",\n", @@ -267,7 +270,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Model fitting: 100%|██████████| 50/50 [00:03<00:00, 14.51it/s]\n" + "Model fitting: 100%|██████████| 50/50 [00:02<00:00, 17.88it/s]\n" ] } ], @@ -283,7 +286,7 @@ "\n", "optimizer = AdamW(params=model.parameters(), lr=lr, weight_decay=weight_decay)\n", "scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=num_epochs)\n", - "train_loss, val_loss = fit_torch_model(\n", + "losses = fit_torch_model(\n", " model=model,\n", " x_train=train_data[0],\n", " y_train=train_data[1].astype(float),\n", @@ -313,7 +316,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6gAAAHVCAYAAAD8YtYeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABO6ElEQVR4nO3deZxkVX3///enqrqql6rpnu6q6YZZullVkH0EFTSaYAAX8Be+MQjG0RgJ6iQi2TT6xZ8Yk7gkmkRUiPpQVCSIRkeF4BIxbiyDbA4wDDMyMw2z9DJL79VVdb5/3FvVt/fq7uqq6u7X8/Gox91OdZ8e7gz9rs+555hzTgAAAAAAVFqo0h0AAAAAAEAioAIAAAAAqgQBFQAAAABQFQioAAAAAICqQEAFAAAAAFQFAioAAAAAoCpEKt2BiZLJpOvo6Kh0NwAAAAAAi+DBBx/sds6lprpWdQG1o6NDW7durXQ3AAAAAACLwMx2T3eNIb4AAAAAgKpAQAUAAAAAVAUCKgAAAACgKhBQAQAAAABVoeomSQIAAACApWB0dFSdnZ0aHh6udFeqTm1trdatW6eampo5vY+ACgAAAADz0NnZqUQioY6ODplZpbtTNZxz6unpUWdnp4477rg5vZchvgAAAAAwD8PDw2ppaSGcTmBmamlpmVdlmYAKAAAAAPNEOJ3afP9cCKgAAAAAgKpAQAUAAAAATOmSSy7Rl7/85bJ9PyZJAgAAAIBlJB6PF/YHBwcVi8UUDoclSTfddJOuuuqqor/WXXfdVfL+zYSACgAAAADLSH9/f2G/o6NDn//853XhhRdOapfJZBSJVFckZIgvAAAAAKwA99xzj9atW6ePfvSjamtr01vf+lYdOnRIr33ta5VKpbR69Wq99rWvVWdnZ+E9r3jFK/T5z39ekvSlL31JF1xwgf7qr/5Kq1ev1nHHHVfyCisBFQAAAABWiP3796u3t1e7d+/WzTffrFwup7e+9a3avXu39uzZo7q6Om3evHna999333163vOep+7ubv3N3/yN3va2t8k5V7L+VVc9FwAAAACWqA99d5sef+7oon6PU45dpQ++7tR5vz8UCulDH/qQYrGYJKmurk6XX3554fr73/9+vfKVr5z2/e3t7Xr7298uSdq0aZPe+c536sCBA2pra5t3n4IIqAAAAACwQqRSKdXW1haOBwcH9Z73vEf//d//rUOHDkmS+vr6lM1mCxMrBQWDaH19vaTxz7wuFAF1jtKZnAbTGTXVRyvdFQAAAABVZCGVzXIxs3HH//zP/6zt27frvvvuU1tbmx5++GGdddZZJR22Oxc8gzpHm754v9725a2V7gYAAAAALFhfX5/q6urU1NSk3t5efehDH6pofwioc5RMxNTdP1LpbgAAAADAgl177bUaGhpSMpnUi1/8Yl188cUV7Y9VqnQ7nY0bN7qtW6u3Qvmh727T7Q/s1bYbKvsfDgAAAEBlPfHEE3rBC15Q6W5Uren+fMzsQefcxqneQwV1jlKJmAbSWQ2mM5XuCgAAAAAsKwTUOUrGvemYu/vSFe4JAAAAACwvBNQ5SiW8gNrFc6gAAAAAUFIE1DlK+RXUrj4CKgAAAACUEgF1jgpDfKmgAgAAAEBJEVDnqCUelURABQAAAIBSI6DOUU04pNX1NQzxBQAAAIASKyqgmtnFZrbdzJ42s/dOcf0tZtZlZg/7rz8NXNtkZjv816ZSdr5SkvEYFVQAAAAAKLHIbA3MLCzpRkmvktQp6QEz2+Kce3xC0/90zm2e8N5mSR+UtFGSk/Sg/95DJel9haQSMSqoAAAAAJYdM9OOHTt04oknVuT7F1NBPVfS0865Xc65tKTbJF1W5Ne/SNIPnXO9fij9oaSL59fV6uFVUFkHFQAAAED1ufjii3X99ddPOv+d73xHbW1tymQyFehVcYoJqGsl7Q0cd/rnJrrczB41szvMbP0c37ukpBIM8QUAAABQnTZt2qSvfvWrcs6NO/+Vr3xFV111lSKRWQfSVkypJkn6rqQO59zp8qqkX57Lm83sajPbamZbu7q6StSlxZOMxzSYzmpgpHo/eQAAAACwMr3+9a9XT0+PfvaznxXOHTp0SN/73vd06aWX6iUveYmampp0zDHHaPPmzUqnq2d0aDEB9VlJ6wPH6/xzBc65HudcvqT4eUnnFPte//03O+c2Ouc2plKpYvteMUmWmgEAAABQperq6vSGN7xBt9xyS+Hc7bffruc///mKx+P65Cc/qe7ubv3qV7/Sj3/8Y33mM5+pYG/HK6a2+4Ckk8zsOHnh8gpJVwYbmNkxzrl9/uGlkp7w9++W9A9mtto//n1J71twrysslYhJ8gJqe0tDhXsDAAAAoCrc9V5p/2OL+z3aTpMu+adZm23atEmvfe1r9elPf1q1tbW65ZZbtGnTJp1zzjmFNh0dHfqzP/sz/fSnP9W11167iJ0u3qwB1TmXMbPN8sJmWNIXnXPbzOwGSVudc1sk/YWZXSopI6lX0lv89/aa2YflhVxJusE517sIP0dZJeNeQGUmXwAAAADV6IILLlAymdS3v/1tvehFL9L999+vb33rW3rqqad03XXXaevWrRocHFQmkxkXWiutqKdjnXN3SrpzwrnrA/vv0zSVUefcFyV9cQF9rDr5CmoXM/kCAAAAyCuisllOb37zm3XLLbdo+/btuuiii9Ta2qorr7xSZ511lr7+9a8rkUjoU5/6lO64445Kd7WgVJMkrSjNDVGZUUEFAAAAUL3e/OY360c/+pH+4z/+Q5s2bZIk9fX1adWqVYrH43ryySf12c9+tsK9HI+AOg814ZBW10eZJAkAAABA1ero6NBLX/pSDQwM6NJLL5UkfeITn9Ctt96qRCKht7/97fqjP/qjCvdyvOpdAKfKpeIxdVNBBQAAAFDF7rnnnnHHL3/5y/Xkk0+OO3fDDTcU9ieunVpuVFDnKZmIqosKKgAAAACUDAF1npLxGEN8AQAAAKCECKjz5A3xTVe8BA4AAAAAywUBdZ6SiZiGRrMaSGcr3RUAAAAAWBYIqPOUjHtroTJREgAAALByMaJyavP9cyGgzlMq4QVUJkoCAAAAVqZwOKzR0dFKd6MqjY6OKhKZ+6IxBNR5SsajkqigAgAAACtVU1OTDhw4oFwuV+muVJVcLqcDBw6osbFxzu9lHdR5yldQmckXAAAAWJmSyaQ6Ozu1ffv2Snel6jQ0NCiZTM75fQTUeWquj8pM6qKCCgAAAKxIoVBIGzZsqHQ3lhWG+M5TJBxSc31UXf3pSncFAAAAAJYFAuoCpBIxhvgCAAAAQIkQUBcgGY8xxBcAAAAASoSAugDJeJQKKgAAAACUCAF1AfJDfFmcFwAAAAAWjoC6AMl4TMOjOfWPZCrdFQAAAABY8gioCzC2Fioz+QIAAADAQhFQFyAZ9wIqEyUBAAAAwMIRUBcgH1CZKAkAAAAAFo6AugBjQ3wJqAAAAACwUATUBWhuiCpkDPEFAAAAgFIgoC5AOGRqbohRQQUAAACAEiCgLlAyHlVXH7P4AgAAAMBCEVAXKJWIqYsKKgAAAAAsGAF1gVLxmLp5BhUAAAAAFoyAukBJv4LqnKt0VwAAAABgSSOgLlAyHlU6k1PfSKbSXQEAAACAJY2AukCFtVAZ5gsAAAAAC0JAXaBk3AuorIUKAAAAAAtDQF2gQgW1n6VmAAAAAGAhCKgLlK+gdrPUDAAAAAAsCAF1gVbXRxUyhvgCAAAAwEIRUBcoHDK1xGNUUAEAAABggQioJZAkoAIAAADAghFQSyAZjzLEFwAAAAAWiIBaAqlEjFl8AQAAAGCBCKglkIrH1NU3IudcpbsCAAAAAEsWAbUEUomY0tmcjg5nKt0VAAAAAFiyCKglwFqoAAAAALBwBNQSyAdUJkoCAAAAgPkjoJZAKkEFFQAAAAAWioBaAsl4VJLUTQUVAAAAAOatqIBqZheb2XYze9rM3jtDu8vNzJnZRv+4w8yGzOxh//W5UnW8mqyujyocMnVRQQUAAACAeYvM1sDMwpJulPQqSZ2SHjCzLc65xye0S0h6t6T7JnyJnc65M0vT3eoUCplaGqLq7mMtVAAAAACYr2IqqOdKeto5t8s5l5Z0m6TLpmj3YUkflTRcwv4tGcl4jAoqAAAAACxAMQF1raS9geNO/1yBmZ0tab1z7vtTvP84M3vIzH5qZi+bf1erWyoRY5IkAAAAAFiAWYf4zsbMQpL+RdJbpri8T9IG51yPmZ0j6dtmdqpz7uiEr3G1pKslacOGDQvtUkUk4zHtONBX6W4AAAAAwJJVTAX1WUnrA8fr/HN5CUkvlHSPmT0j6cWStpjZRufciHOuR5Kccw9K2inp5InfwDl3s3Nuo3NuYyqVmt9PUmHJRFTd/Wk55yrdFQAAAABYkooJqA9IOsnMjjOzqKQrJG3JX3TOHXHOJZ1zHc65Dkn3SrrUObfVzFL+JEsys+MlnSRpV8l/iiqQiseUzuZ0dChT6a4AAAAAwJI0a0B1zmUkbZZ0t6QnJN3unNtmZjeY2aWzvP3lkh41s4cl3SHpGudc7wL7XJVSiZgkMVESAAAAAMxTUc+gOufulHTnhHPXT9P2FYH9b0r65gL6t2Qk435A7RvRiWviFe4NAAAAACw9xQzxRRHyFVRm8gUAAACA+SGglkiwggoAAAAAmDsCaok01dUoEjIqqAAAAAAwTwTUEgmFTC3xKAEVAAAAAOaJgFpCyXiMIb4AAAAAME8E1BJKJWLq7k9XuhsAAAAAsCQRUEsoGY8xxBcAAAAA5omAWkL5gOqcq3RXAAAAAGDJIaCWUCoR02jW6cjQaKW7AgAAAABLDgG1hJLxqCQxzBcAAAAA5oGAWkKpREySdJCZfAEAAABgzgioJZSKewGVmXwBAAAAYO4IqCWU9AMqa6ECAAAAwNwRUEuosa5GNWHjGVQAAAAAmAcCagmFQqaWhpi6qaACAAAAwJwRUEssmYiqiwoqAAAAAMwZAbXEUvEYQ3wBAAAAYB4IqCWWjMfU3ccsvgAAAAAwVwTUEkslvApqLucq3RUAAAAAWFIIqCWWjMeUyTkdGRqtdFcAAAAAYEkhoJZYMuGvhcpzqAAAAAAwJwTUEkvFvYDKUjMAAAAAMDcE1BJLJaKSqKACAAAAwFwRUEss6VdQu6igAgAAAMCcEFBLrLGuRjVhU3c/S80AAAAAwFwQUEvMzLy1UBniCwAAAABzQkBdBKlEjCG+AAAAADBHBNS5+sEHpO+9Z8YmVFABAAAAYO4IqHN16Blp9y9nbJKMR6mgAgAAAMAcEVDnKt4q9R+YsUkqEVPPQFq5nCtTpwAAAABg6SOgzlW8TRo6JGWmr5Am4zFlc06Hh0bL2DEAAAAAWNoIqHMVX+Nt+w9O24S1UAEAAABg7gioc5Vo87YzBNRUwguoTJQEAAAAAMUjoM5VoYK6f9om+QoqARUAAAAAikdAnat4q7edYaKkfAWVIb4AAAAAUDwC6lw1pCTZjEN8V9VGFA2H1EUFFQAAAACKRkCdq3CNVN8i9U0/xNfMlIxH1d2XLmPHAAAAAGBpI6DOR7x1xgqq5A3zpYIKAAAAAMUjoM5HonXGSZIkb6Kkbp5BBQAAAICiEVDno4gKajJOBRUAAAAA5oKAOh/xNd4svs5N2ySViKl3IK1cbvo2AAAAAIAxBNT5iLdJ2bQ0dGjaJsl4VNmc06FBJkoCAAAAgGIQUOcjvsbbzjDMN5WolSSG+QIAAABAkQio8xFv9bb9B6ZtkoxHJYmlZgAAAACgSEUFVDO72My2m9nTZvbeGdpdbmbOzDYGzr3Pf992M7uoFJ2uuESbt50poCZikqRuKqgAAAAAUJTIbA3MLCzpRkmvktQp6QEz2+Kce3xCu4Skd0u6L3DuFElXSDpV0rGSfmRmJzvnsqX7ESqgMMR3+oCa8gNqF0vNAAAAAEBRiqmgnivpaefcLudcWtJtki6bot2HJX1U0nDg3GWSbnPOjTjnfivpaf/rLW2xVVKkbsaAmohFFI2EqKACAAAAQJGKCahrJe0NHHf65wrM7GxJ651z35/re5ckM6+K2jd9QDUzpeIxKqgAAAAAUKQFT5JkZiFJ/yLpLxfwNa42s61mtrWrq2uhXSqPeOuMFVTJew6VWXwBAAAAoDjFBNRnJa0PHK/zz+UlJL1Q0j1m9oykF0va4k+UNNt7JUnOuZudcxudcxtTqdTcfoJKScweUFPxqLr7mcUXAAAAAIpRTEB9QNJJZnacmUXlTXq0JX/ROXfEOZd0znU45zok3SvpUufcVr/dFWYWM7PjJJ0k6f6S/xSVUEQFNZVgiC8AAAAAFGvWWXydcxkz2yzpbklhSV90zm0zsxskbXXObZnhvdvM7HZJj0vKSHrXkp/BNy/eKg0dkjIjUiQ2ZZNkPKbegRFlc07hkJW5gwAAAACwtMwaUCXJOXenpDsnnLt+mravmHD8EUkfmWf/qle81dv2H5Sa1k/ZJBmPKeekQ4NpJeNTh1gAAAAAgGfBkyStWMGAOg3WQgUAAACA4hFQ5yu+xtvO8BxqvmrKWqgAAAAAMDsC6nwl2rxt//5pm1BBBQAAAIDiEVDnqyElyWYc4puMRyVRQQUAAACAYhBQ5ytcI9W3zDjENx6LKBYJsRYqAAAAABSBgLoQ8Vapb/qAamashQoAAAAARSKgLkR8zYwVVMmbKIkhvgAAAAAwOwLqQiTaigqoVFABAAAAYHYE1IXIV1Cdm7ZJKkEFFQAAAACKQUBdiHirlE1Lw4enbZKKR9U7kFY2N32IBQAAAAAQUBcm3uptZ5goKZWIKeek3gFm8gUAAACAmRBQFyIfUGd4DjUZj0kSz6ECAAAAwCwIqAtRCKgHp22STHgBledQAQAAAGBmBNSFSOQD6v5pm6SooAIAAABAUQioCxFbJUVqZx7iSwUVAAAAAIpCQF0IM2+pmRkmSWqIhlVbEyKgAgAAAMAsCKgLFW+bsYJqZkolYgzxBQAAAIBZEFAXKr5mxkmSJG8m3+5+lpkBAAAAgJkQUBcq0TbjJEmSN1ESQ3wBAAAAYGYE1IWKt0pDh6TM9AE0yRBfAAAAAJgVAXWh4mu87UDXtE2S8Zh6B9PKZHNl6hQAAAAALD0E1IWKt3nbGWbyTSVick7qHeA5VAAAAACYDgF1ofIV1Blm8k3Fo5KkLp5DBQAAAIBpEVAXKt7qbWcIqMl4TJKYyRcAAAAAZkBAXahiKqgJL6AyURIAAAAATI+AulDhGqm+pcgKKgEVAAAAAKZDQC2FeOuMkyQ1xCKqj4bVTQUVAAAAAKZFQC2FeOuMFVTJq6IySRIAAAAATI+AWgrxVqn/4IxNkvEoQ3wBAAAAYAYE1FJItEr9+yXnpm2SSsTU3ccsvgAAAAAwHQJqKcRbpWxaGj48bROG+AIAAADAzAiopVBYC3X6Yb7JeEyHBtMazebK1CkAAAAAWFoIqKWQD6h9+6dtkkrE5JzUO8AwXwAAAACYCgG1FIqsoEpSF0vNAAAAAMCUCKilEF/jbWdYaiaV8AIqM/kCAAAAwNQIqKVQ2yhFar2ZfKeRooIKAAAAADMioJaCmVdFnWmIbyIqSeru5xlUAAAAAJgKAbVU4q0zTpJUH42oIRpmiC8AAAAATIOAWirx1hkrqJKUTMQY4gsAAAAA0yCglkq8dcZJkiRvJl8qqAAAAAAwNQJqqSTapKFeKTP9M6apOBVUAAAAAJgOAbVU8kvNDMw8URIVVAAAAACYGgG1VOKt3namtVDjtTo0OKrRbK5MnQIAAACApYOAWir5gNo3fUDNLzXTw1IzAAAAADBJUQHVzC42s+1m9rSZvXeK69eY2WNm9rCZ/dzMTvHPd5jZkH/+YTP7XKl/gKpRRAU1GY9JEsN8AQAAAGAKkdkamFlY0o2SXiWpU9IDZrbFOfd4oNmtzrnP+e0vlfQvki72r+10zp1Z0l5Xo4aUt51piG/CC6hdBFQAAAAAmKSYCuq5kp52zu1yzqUl3SbpsmAD59zRwGGDJFe6Li4RkahU3zLLM6h+QGUmXwAAAACYpJiAulbS3sBxp39uHDN7l5ntlPQxSX8RuHScmT1kZj81s5ctqLfVLt4q9c8wiy9DfAEAAABgWiWbJMk5d6Nz7gRJfyvpA/7pfZI2OOfOknSdpFvNbNXE95rZ1Wa21cy2dnV1lapL5RdfI/Xtn/ZyXTSseCxCBRUAAAAAplBMQH1W0vrA8Tr/3HRuk/R6SXLOjTjnevz9ByXtlHTyxDc45252zm10zm1MpVJFdr0KxdtmrKBKUjIeVTez+AIAAADAJMUE1AcknWRmx5lZVNIVkrYEG5jZSYHD10ja4Z9P+ZMsycyOl3SSpF2l6HhViq/xnkF10z+Cm0rE1E0FFQAAAAAmmXUWX+dcxsw2S7pbUljSF51z28zsBklbnXNbJG02swsljUo6JGmT//aXS7rBzEYl5SRd45zrXYwfpCrEW6XsiDR8WKpbPWWTZDymHQf7y9svAAAAAFgCZg2okuScu1PSnRPOXR/Yf/c07/umpG8upINLSqLN2/YfnDGg/mpXTxk7BQAAAABLQ8kmSYK8Ib7SrGuhHh4cVTqTK1OnAAAAAGBpIKCWUtyvoPZNH1DzS830DPAcKgAAAAAEEVBLqYgKajIelSR19zGTLwAAAAAEEVBLqbZRCsek/unXQk0lvApqdz8VVAAAAAAIIqCWkpmUaJ1xLdS2xlpJ0rOHh8rVKwAAAABYEgiopRZvnXGIb2uiVrFISHt6B8vYKQAAAACofgTUUou3zjhJUihkam+p1zPdA2XsFAAAAABUPwJqqc1SQZWk9pYG7e6hggoAAAAAQQTUUou3SkO9Umb6WXo7Wuq1u3dAuZwrY8cAAAAAoLoRUEstv9TMwPQTJbW3NGh4NKeDfczkCwAAAAB5BNRSS7R52xmG+Xa0NEiSnunhOVQAAAAAyCOgllq+gjrDUjPtLfWSpN0EVAAAAAAoIKCWWtyvoPbtn7bJMY21qgmbnmGiJAAAAAAoIKCWWkPK285QQY2EQ1q/ul57CKgAAAAAUEBALbVIVKprlvqnr6BK3jBfnkEFAAAAgDEE1MWQaJuxgiqNrYXqHEvNAAAAAIBEQF0c8TUzzuIreWuh9o9k1DMw/XqpAAAAALCSEFAXQ7xV6ps5oLYnvaVmmMkXAAAAADwE1MUQb/UqqDMM3y2shdrNREkAAAAAIBFQF0e8VcqOSMNHpm2ytqlOIaOCCgAAAAB5BNTFEG/1tjM8hxqNhLR2dR1roQIAAACAj4C6GBKzB1TJG+a7u5eACgAAAAASAXVx5Cuos02U1FLPEF8AAAAA8BFQF0N8jbctooJ6eHBUhwdZagYAAAAACKiLobZJCsdmDajtLfmlZhjmCwAAAAAE1MVgNrbUzAw6WuolSc8wzBcAAAAACKiLJjF7QF3fXC8zKqgAAAAAIBFQF0+8Veo/OGOT2pqw2lbVUkEFAAAAABFQF098jdS3f9Zm3ky+VFABAAAAgIC6WOJt0lCvlJl5ht6OlgaWmgEAAAAAEVAXT36pmYGuGZu1tzSouz+t/pFMGToFAAAAANWLgLpY4q3etn/mYb75mXypogIAAABY6QioiyWRD6gzT5TEWqgAAAAA4CGgLpZ8BXWWiZLaWQsVAAAAACQRUBdPg/8M6iwV1IZYRKlETLu7qaACAAAAWNkIqIslEpXqmqX+A7M2bW+up4IKAAAAYMUjoC6meGtxAbWlgWdQAQAAAKx4BNTFlCguoHa01Gv/0WENj2bL0CkAAAAAqE4E1MVUbAU16c3ku6eXKioAAACAlYuAupjia6S+A5JzMzbLr4X6TDfPoQIAAABYuQioiyneJmVHpOEjMzZrb2YtVAAAAAAgoC6m/Fqosyw101hfo9X1NczkCwAAAGBFI6Aupnh+LdT9szZlJl8AAAAAKx0BdTEl2rztLBVUyXsOlQoqAAAAgJWsqIBqZheb2XYze9rM3jvF9WvM7DEze9jMfm5mpwSuvc9/33Yzu6iUna96+Qpq3+wV1A0tDXru8JBGMiw1AwAAAGBlmjWgmllY0o2SLpF0iqQ3BgOo71bn3GnOuTMlfUzSv/jvPUXSFZJOlXSxpM/4X29lqG2SwrGi10LNOanz0NDi9wsAAAAAqlAxFdRzJT3tnNvlnEtLuk3SZcEGzrmjgcMGSfl1VS6TdJtzbsQ591tJT/tfb2Uw89dCnX2Ib3uLvxYqz6ECAAAAWKEiRbRZK2lv4LhT0nkTG5nZuyRdJykq6XcD7713wnvXzqunS1V8TVGTJBXWQuU5VAAAAAArVMkmSXLO3eicO0HS30r6wFzea2ZXm9lWM9va1dVVqi5Vh0RbURXU5oaoErEIM/kCAAAAWLGKCajPSlofOF7nn5vObZJeP5f3Oududs5tdM5tTKVSRXRpCYmvKeoZVDNTe5KZfAEAAACsXMUE1AcknWRmx5lZVN6kR1uCDczspMDhayTt8Pe3SLrCzGJmdpykkyTdv/BuLyHxVmmwR8qkZ23KWqgAAAAAVrJZn0F1zmXMbLOkuyWFJX3RObfNzG6QtNU5t0XSZjO7UNKopEOSNvnv3WZmt0t6XFJG0ruccytrHZV4q7cd6JIaZ378tqOlXnf/Zr8y2ZwiYZaoBQAAALCyFDNJkpxzd0q6c8K56wP7757hvR+R9JH5dnDJywfU/gOzBtT25gZlck7PHR7WBn/SJAAAAABYKSjTLbZgQJ1FOzP5AgAAAFjBCKiLLVF8QO1Iemuh7iagAgAAAFiBCKiLrcGflbhv9oC6JhFTbU2IiZIAAAAArEgE1MUWiUl1q4teaqajpUHPEFABAAAArEAE1HKItxUVUCXvOVSG+AIAAABYiQio5RBfU3RA7Whp0O7eQeVybpE7BQAAAADVhYBaDvHWOVRQG5TO5LT/6PAidwoAAAAAqgsBtRwSrVL/QcnNXhVlqRkAAAAAKxUBtRzirVJmWBo+MmvTfEBlJl8AAAAAKw0BtRzibd62/+CsTY9prFM0HKKCCgAAAGDFIaCWQ3yNt+3fP2vTcMi0vrlOe6igAgAAAFhhCKjlEG/1tkVUUCWxFioAAACAFYmAWg6JfEAtfibf3T0DckVMqgQAAAAAywUBtRxqm6RwVOqbfYivJHUk6zWYzqqrf2Rx+wUAAAAAVYSAWg5m/lqoxQ3xbW9pkMRMvgAAAABWFgJqucRbix/i2+yvhdrNTL4AAAAAVg4CarnMIaCuXV2ncMiooAIAAABYUQio5RJfU3RArQmHtG51HWuhAgAAAFhRCKjlkmiTBnuk7GhRzdtbGrSnlwoqAAAAgJWDgFou8TXetui1UOv1226WmgEAAACwchBQyyXe5m3nsBZq33BGhweLq7gCAAAAwFJHQC2XeKu3LTKgdrT4M/nyHCoAAACAFYKAWi6FIb7FV1Al1kIFAAAAsHIQUMtljs+grm+ukxkVVAAAAAArBwG1XCIxqW611Le/qOaxSFjHNtZRQQUAAACwYhBQyyneWvQQX0lqb6mnggoAAABgxSCgllO8teghvpL3HCoVVAAAAAArBQG1nOKtUn9xQ3wlbybf3oG0jg6z1AwAAACA5Y+AWk7xNV4F1bmimudn8t1DFRUAAADACkBALadEm5QZlkaOFtW8I8laqAAAAABWDgJqOcVbvW1fcRMlbWj2AirPoQIAAABYCQio5ZQPqEXO5Fsfjah1VUzPdFNBBQAAALD8EVDLaY4BVZLam5nJFwAAAMDKQEAtp/gab8taqAAAAAAwCQG1nOpWS+HonAJqR7JBB/tGNJjOLGLHAAAAAKDyCKjlZOYN8y1ykiTJq6BK0p5ehvkCAAAAWN4IqOUWXzO3Cqq/Fuoz3QRUAAAAAMsbAbXc4m1S/8Gim29oyS81w3OoAAAAAJY3Amq5xddI/fuLbr6qtkYtDVE9w0y+AAAAAJY5Amq5xVulwR4pO1r0W9pb6qmgAgAAAFj2CKjllsivhVr8MN/2FtZCBQAAALD8EVDLLZ4PqHObyfe5I0MaHs0uUqcAAAAAoPIIqOWWD6h9+4p+S0dLg5yTOg9RRQUAAACwfBFQyy15slTbJN33Ocm5ot7SXpjJl4AKAAAAYPkqKqCa2cVmtt3Mnjaz905x/Toze9zMHjWzH5tZe+Ba1swe9l9bStn5Jal2lfS7H5B++7/S498p6i2FtVAJqAAAAACWsVkDqpmFJd0o6RJJp0h6o5mdMqHZQ5I2OudOl3SHpI8Frg055870X5eWqN9L2zlvlVpfKP3gA1J69tDZVF+jVbURZvIFAAAAsKwVU0E9V9LTzrldzrm0pNskXRZs4Jz7iXMun7TulbSutN1cZsIR6ZKPSUf2Sr/41KzNzUwdyQYqqAAAAACWtWIC6lpJewPHnf656bxN0l2B41oz22pm95rZ6+fexWWq43zphZdLP/+UdOiZWZt7S81QQQUAAACwfJV0kiQze5OkjZI+Hjjd7pzbKOlKSZ8ysxOmeN/Vfojd2tXVVcouVbdXfVgKhaW73z9r0/bmenUeGtJoNleGjgEAAABA+RUTUJ+VtD5wvM4/N46ZXSjp/ZIudc6N5M875571t7sk3SPprInvdc7d7Jzb6JzbmEql5vQDLGmNa6WX/5X05Pekp388Y9P2lnplc07PHhoqU+cAAAAAoLyKCagPSDrJzI4zs6ikKySNm43XzM6SdJO8cHowcH61mcX8/aSk8yU9XqrOLwsv2Sw1Hy/d9bdSJj1ts45kfiZfhvkCAAAAWJ5mDajOuYykzZLulvSEpNudc9vM7AYzy8/K+3FJcUnfmLCczAskbTWzRyT9RNI/OecIqEGRmHTxP0k9O7y1UafBWqgAAAAAlrtIMY2cc3dKunPCuesD+xdO875fSjptIR1cEU6+SDrpIumnH5VOf4OUaJvUJBWPqT4aJqACAAAAWLZKOkkSFuDif5SyaelH//+Ul82MmXwBAAAALGsE1GrRcoL3POojX5f23Ddlk46Wep5BBQAAALBsEVCrycv+UkocK93111IuO+lye0uD9vYOKZtzFegcAAAAACwuAmo1icWl3/+wtO8R6de3TLrc0VKvdDanfUdYagYAAADA8kNArTYvvFxqP1/68Q3SYO+4SxuYyRcAAADAMkZArTZm0iUflYYPSz/5h3GXOlpYCxUAAADA8kVArUZtp0kb3yZt/YK0/zdjp1fVKhoJUUEFAAAAsCwRUKvVK/9Oqm2S7vobyXmTIoVCpvbmepaaAQAAALAsEVCrVX2z9HvXS7t/If3mm4XT3lqoVFABAAAALD8E1Gp29pulY86QfvB/pZF+SWNroTrHUjMAAAAAlhcCajULhaVLPi71PSf97J8lSe3JBg2P5nSwb6TCnQMAAACA0iKgVrsN50mnXyH96tNSz051+EvNPNPNc6gAAAAAlhcC6lLwqg9J4Zj03+9Te7O31AzPoQIAAABYbgioS0GiTfqdv5F23K21XT9VJGSshQoAAABg2SGgLhXnXSO1nKTwD/5Ox6+uoYIKAAAAYNkhoC4Vkah0yUel3l16e81d2t1LBRUAAADA8kJAXUpO/D3p+a/VZUdvVfdzz+iXO7sr3SMAAAAAKBkC6lJz0UdUE3L6SMPtuva2h9Xdz3IzAAAAAJYHAupSs7pD9pJ36fcy/6uWoWd03e2PKJdzle4VAAAAACwYAXUpevE7pUidPt3+M/3vU1266X93VbpHAAAAALBgBNSlqCEpnf3HOn7f93XVCyL6xA+268HdvZXuFQAAAAAsCAF1qXrJZpnL6frUPVrbVKe/+PrDOjyYrnSvAAAAAGDeCKhL1ep26YV/oNjDt+izlx+vg33D+us7HpVzPI8KAAAAYGkioC5l579bSvfr1Ge/ofde8gL98PED+tIvn6l0rwAAAABgXgioS1nbadKJF0r3fU5/cm6rLnxBq/7xzif1WOeRSvcMAAAAAOaMgLrUnX+tNNAle+Tr+vj/OV0t8ag2f/3X6hserXTPAAAAAGBOCKhLXccF0tpzpF/+u1bXhfVvbzxLnYeG9Hf/9RueRwUAAACwpBBQlzozr4p66LfS49/Rizqadd2rTtZ3H3lO//nA3kr3DgAAAACKRkBdDp7/GqnlROkXn5Kc0zt+5wS97KSkPrhlm7bv76t07wAAAACgKATU5SAUll76F9K+R6Rd9ygUMv3LG85UorZG77r11xpMZyrdQwAAAACYFQF1uTjjCine5lVRJaUSMf3rFWdqZ1e/PvidbZXtGwAAAAAUgYC6XERi0ovfIe26R3ruIUnS+ScmtfmVJ+obD3bqvx7qrGz/AAAAAGAWBNTlZONbpdgq6eefKpx69++dpHM7mvX+//qNdnX1V65vAAAAADALAupyUtsobfwT6YktUs9OSVIkHNK/vvFMxSIhvevWhzQ8mq1wJwEAAABgagTU5ebF75BCEemX/144dUxjnf75DWfoiX1H9Q93PlHBzgEAAADA9Aioy02iTTrjjdLDt0p9Bwqnf/f5rXr7y47TLb/arbse21fBDgIAAADA1Aioy9FL/0LKpqX7Pjfu9F9f9Hydsb5Jf/PNR7W3d7BCnQMAAACAqRFQl6PkidILXic98AVp+GjhdDQS0qffeJYkafPXH1I6k6tUDwEAAABgEgLqcnXBtdLIEenBL407vb65Xh+9/HQ9svcwz6MCAAAAqCoE1OVq7TlSx8ukez8jZUbGXXr1acfobRccpy/98hnd/sDeCnUQAAAAAMYjoC5nF1wr9e2THr190qX3XfJ8XXBiUh/49m/04O5D5e8bAAAAAExAQF3OTvg9qe006Rf/KuXGP28aCYf06SvPUltjra756oPaf2S4Qp0EAAAAAA8BdTkzk86/VurZIW2/c9LlpvqoPr9powZHMvqzr2zV8Gi2/H0EAAAAAB8Bdbk75fVSU7v0i09Jzk26fHJrQp/8ozP1SOcR/d23HpObog0AAAAAlENRAdXMLjaz7Wb2tJm9d4rr15nZ42b2qJn92MzaA9c2mdkO/7WplJ1HEcIR6aV/LnU+IO3+5ZRNfv/UNl33qpP1rYee1Rd+/tsydxAAAAAAPLMGVDMLS7pR0iWSTpH0RjM7ZUKzhyRtdM6dLukOSR/z39ss6YOSzpN0rqQPmtnq0nUfRTnzKqm+xauiTmPzK0/UJS9s0z/c+YR+tqOrfH0DAAAAAF8xFdRzJT3tnNvlnEtLuk3SZcEGzrmfOOcG/cN7Ja3z9y+S9EPnXK9z7pCkH0q6uDRdR9Gi9dJ510g7fiAd2DZlk1DI9Ik/PEMntya0+daH9Ez3QJk7CQAAAGClKyagrpUUXCyz0z83nbdJumsu7zWzq81sq5lt7eqiercoXvSnUk2DN6PvNBpiEf3HmzfKTHr7LVvVP5IpYwcBAAAArHQlnSTJzN4kaaOkj8/lfc65m51zG51zG1OpVCm7hLz6Zumct0iP3SEd3jNts/XN9frMlWdrV/eA3vOfDyuXY9IkAAAAAOVRTEB9VtL6wPE6/9w4ZnahpPdLutQ5NzKX96JMXvJOb+mZX904Y7OXnpjU/33NC/TDxw/oUz/eUabOAQAAAFjpigmoD0g6ycyOM7OopCskbQk2MLOzJN0kL5weDFy6W9Lvm9lqf3Kk3/fPoRIa10mnvUH69S3SYO+MTTe9tENv2LhO//bjHbrrsX1l6iAAAACAlWzWgOqcy0jaLC9YPiHpdufcNjO7wcwu9Zt9XFJc0jfM7GEz2+K/t1fSh+WF3Ack3eCfQ6Wc/25pdFC6/+YZm5mZPvz6F+rsDU267vZH9MS+o2XqIAAAAICVypyrrmcMN27c6LZu3Vrpbixvt14h7b1Pes9vpGjDjE0PHh3WpZ/+hSJh05bNF6i5IVqmTgIAAABYjszsQefcxqmulXSSJCwRF1wrDfVKt1wm/for0vD01dE1q2p10x+fo4N9I3rX136t0WyufP0EAAAAsKIQUFeiDS+WLvm49xzqls3SJ06S7nibtONHUnby0jJnrG/SP/3BafrVrh595PtPVKDDAAAAAFaCSKU7gAo572rp3LdLzz4oPfJ1b/mZ39whxduk0/9QOuONUuupheZ/cPY6PbHvqP7jZ7/VC45J6I9etKGCnQcAAACwHPEMKjyZEempu6VHbpN23C3lMlLbaV5QPe0PpfgaZbI5vfVLD+jeXT267eoX65z25kr3GgAAAMASM9MzqARUTDbQI/3mm15l9blfSxaWTrxQOuMKHdnwKl1201b1j2T13T8/X8c01lW6twAAAACWEAIq5q9ru1dVffQ/paPPSrFGHTn+Ndq87XnqaT5b/3blWTpxTaLSvQQAAACwRBBQsXC5rPTMz72w+vh3pNEBPa11uib9Hl3w4pfoPReerMb6mkr3EgAAAECVI6CitNID0uNblLv7AxpKj+qPh67TrtpTdN2rTtaV525QJMzk0AAAAACmxjqoKK1og3TmGxV6+w/V0NiiO+r/UW9q2qbrv7NNr/63n+nnO7or3UMAAAAASxABFfPXfLz0Jz9QaM0p+stDN+j7L92h4dGc3vSF+/SnX96q33YPVLqHAAAAAJYQAioWJp6S3vI92YkX6tRff1D/c/bP9bcXPU+/2tmt3//kT/UPdz6ho8Ojle4lAAAAgCWAgIqFizZIV3xdOuuPFfn5J/SOI5/UT647X//fWWv1Hz/bpd/9xD36+v17lM1V1/POAAAAAKoLARWlEY5Il/679DvvlR7+qtZ87y362OtO0JZ3XaCOlga971uP6XX//nPdu6un0j0FAAAAUKUIqCgdM+mV75Ne96/Szv+RvvQandY0om9c8xL9+xvP0pGhUV1x871659ce1N7ewUr3FgAAAECVYZkZLI7t/y194y1SolV607eklhM0PJrVzf+7S5+9Z6eyzuntLztO1/zOCUrUsn4qAAAAsFKwDioqo3OrdOsbvP0rvyGtO0eStO/IkD5615P69sPPqSEa1uvPWqurzmvXKceuqmBnAQAAAJQDARWV07NT+uofSP0HpT/8knTyRYVLj3Ue0Zd++Yy+9+hzGsnkdPaGJl11Xrtec/oxqq0JV67PAAAAABYNARWV1X9Q+tofSvsfk177SemcTeMuHx5M644HO3XrfXu0q3tATfU1+j9nr9OV523Q8al4hToNAAAAYDEQUFF5I/3SNzZJT/9IesX7pN/5W29SpQDnnH61q0dfu3eP7t62X5mc0/kntuiq89r1qlNaVRNmTi8AAABgqSOgojpkR6Xvvlt6+GvS2W+WXvNJb3maKRzsG9Y3tnpV1WcPDymViOmKF63XFedu0NqmujJ3HAAAAECpEFBRPZyTfvIR6X8/Lp10kfQHN0t1TdM2z+acfvrUQX3t3j36n+0HZZJ+9/lrdNV57Xr5ySmFQzbtewEAAABUHwIqqs8DX5Du/CvJ5aTm46W20/zX6d42ccykIcCdhwZ12/17ddsDe9XdP6J1q+v0xnM36NIzjtX65voK/SAAAAAA5oKAiurU+aC063+8yZP2Pyb17hq7Vtc8ObQmT5LCNUpncvrh4wf0tft265c7eyRJZ6xr1GtOP0avPu0YrVtNWAUAAACqFQEVS8NIn3Rgmx9YH/W2Bx6XsiPe9XBMWvP8caG1M3qCvv9Uv77/2D492nlEknTm+ia95rRj9OrTj+F5VQAAAKDKEFCxdGUzUs+OsSprPrwOepVThSLSKZdJ512jPXWn6vu/2a/vP/acfvPsUUnSWRv8sHraMTqWsAoAAABUHAEVy4tzUt9+L6zu+on00NekkSPSsWdL510jnfp67T6S0fcf26fvP7pP257zwurZG5r0mtOP1atPa9MxjYRVAAAAoBIIqFjeRvqlR2+T7rtJ6n5KalgjbXyrtPFPpESbfts9oDsf26fvPbpPT+zzwurG9tV6zenH6JIXHqO2xtoK/wAAAADAykFAxcrgnFdRve8m6am7veG/p77eq6qu8+7/XV39hbD65P4+mUnPa03oeW0JndyaKOyvbapTiCVsAAAAgJIjoGLl6dkpPfB56aGvSiNHpbXnSOe9w3teNRKVJD190AurD+05pKcO9OvZw0OFt9dHwzqpNaHntca94NrmhddUIiYzgisAAAAwXwRUrFwjfdIj/vDfnh1SvFXa+DZvCHB8zbimR4dHteNAv5460Kft+/v01AHv1d2fLrRpqq8pVFpPbkvo5DVxPa8toab6aLl/MgAAAGBJIqACuZy35up9N0k7fiCFaqQXXi6dd7VXXZ1Bd/+IF1b392m7H2Cf2t+nvpFMoc2G5nqdsb5JZ65v0pnrG3XqsY2qrQkv9k8FAAAALDkEVCCoZ6d0/83e7L/pPqlxg9RygvdqPl5q9rer26VIbMov4ZzTviPD2n6gT0/u69Mjew/rkc7D2ndkWJIUCZmef0xCZ65v0hnrmnTWhiYdn4zzXCsAAABWPAIqMJXho9Kj/yntuVfq3SX17pSGj4xdt5DUuG58aM2H2NUdU4bXA0eH9fDew3pk72E9vPewHu08on6/0pqIRXT6+kadsS5faW3SmlXMIAwAAICVhYAKFGuw1wurPTvHQmv+ePhwoKFJjeul5uOklhOltWdL686VkidJgUmUcjmnnV39Xmjt9ELrk/v6lMl5f++ObazVGeub9Lw2bwKmVDympL9NJWIMEwYAAMCyQ0AFSiEfXicG2O6npRG/8lq3Wlr3Imn9uV5gXXuOFIuP+zLDo1lte+6IHt57RA/vPayH9x7S3t6hKb6hV3VNFoJrVMn4+BCbTHhBNhmPKhYhzAIAAKD6EVCBxZTLeTME771f2nuf1PmA1PWkd81CUuup0vrzvMC6/lxvePCEpWrSmZx6BkbU3ZdWV/+wvx1RV9+Iuidsjw5nJvdBUioRU3tzvTa01Ku9uUHtLfn9ejU3RFkeBwAAAFWBgAqU29AhqfNBP7DeL3VuldL93rWGlB9YX+Rtjz1Tqqkr+kuPZLLq6U8XQmt3/4gOHh3R3kOD2t0zqD29g4XJmvLisYjWN3thdSy4eiH2mMZaRcKhEv7wAAAAwPQIqECl5bLSwSfGKqx77/OGCEvekjfJk6XGtdKqY6VV+W1gP5aY07cbHs2q0w+s+dC6u2dAu3sH1dk7pHQ2V2gbCZnWra7T2tV1aqyr0araGq2qq9Gq2oi/rdGqukjgvHdcVxOmKgsAAIA5I6AC1Wige2xYcNeT0tHnvNdg9+S2scZAaA2G2ECYrWsq6ttmc077jw5rd8+A9vQManfvoPb0DGrfkSEdHc7o6NCojg6Pang0N+PXiYRMq+pq/FDrhdnV9VH/mdixZ2OT8ZjWJGJqbohSqQUAAAABFVhSRoelvn1jgfXosxO2z0n9ByRN+Ltb2+g93zrVq3G9FK6ZUzdGMln1FQLrWHA9OpTxt+OPjwyNqncgre6+EQ2ks5O+npnUXB+dFF6Dgba5IapEbUT10YgaYmGqtAAAAMvQTAE1Uu7OAJhFTa23fE3zcdO3yY5KffsDwfVZ6dBu6dAz0oHHpe13Sdn0WPv8mq5TBtjjvNmHJwTBWCSsWDysZHzyeq+zGUxnChM+dfWlJ0301N0/ogf3DKirb2TGSq2ZVF8TVn0sooZoWA2xiBqiEdXHwt7WP1dfuBZWvHasottYNzZcOR6LEHYBAACqHAEVWIrCNVLTeu81lVzOq8IeekY69Ft/67+23yUNdI1vH2v0vlZDynvF10y935CSItFZu1cfjWhDS0QbWupnbOec00A6q+6+EXX1j6inP63BdEYD6awGRzIaGPH30xkNjHjb/pGMegfS2ts7qMF0ttAmm5t5NEjIpIT//GzhWdvA87X5MOtVcMOq8wNwXU1Ydf62PhpWbU1YsUiIsAsAALAICKjAchQKeZMuNa6VOs6ffH2kXzq8e3xwPbzXC669O6X+Likz9dqsqm2UGtb4wTXp7TekpHhKqk9K9S1jr7rVUnj6f2bMTPGYV93sSDbM+8d1zmkkk/PC6khWRwrDj6calpzxrg+Nald3f+Ha4BTDkqcTMi+E1/qhdWKIHRdoo2HV10QC++Fx+3XRcCEQ599DAAYAACsVARVYiWJxb33W1lOnvu6clB6QBg56kzn1H5yw3+W9DjwuDfxUGj48/feqbRwfWutbpPrmQIhtnhxqQ3ObTMnMVFvjVTdb4nN6a8FoNld45nYwndXQaEZD6ZwG0xkNjWY1lM765yfue9cH0975/UdHNeRfy58Lzppc3M+jcRXbsQAbUn00Mj4MB0NuzVjlt7YmpGg4rJqwKRoJqSYcUiwSKuyPOxcOKRQiEAMAgMorKqCa2cWS/lVSWNLnnXP/NOH6yyV9StLpkq5wzt0RuJaV9Jh/uMc5d2kJ+g1gMZl5ITYWl5qPn719Ju0F1sEe7zXUKw32jh3nX0eflfb/xpupODM89deykBdaG5JeRbYhH16T/rmWwDX/eI4TQE2lJhxSc0NUzQ2zD2Geq0w254VZP9zmw+uwH3QHR/P7GQ2N5jSUzkwThrM62DfsfQ3/fUPprEYycwvAUwmHTNFwyA+0YUXDptpoWLWRsYpwbaFSHPL2x53zj6Nh1UZCqvPDdThkqgmFvG3YFA6ZIqGQImFTJGSKhCdfCxOWAQBYsWYNqGYWlnSjpFdJ6pT0gJltcc49Hmi2R9JbJP3VFF9iyDl35sK7CqBqRaJjQ4qLlR6cEGDzgbbbq9QOdksDPd76sQPd0tAhTZq5OK+2cSyw1jZKNXVSTYO3jdYH9v1tTb33Gnctf67B25ZwiG0kHFIiHFKiduFBeirZnBsLv+msBkczGh7NKZ3JaTTrbdP5bf5c4PxoximdzfrXvOHS6UxOI5mshkfzgTqjnoG0RvJBu4TheCIzbxmjSMgLzPnqeK0fjGsjYcVqQopFAueCx5HwuHOhkCkckkLmheCwmXfOPw4VzmnSOS88h6b43gzDBgBgMRRTQT1X0tPOuV2SZGa3SbpMUiGgOuee8a+V/jcVAMtT1A+I0030NFEuO32IHXfc5YXf0SFpdMDbn+552ulEav1JofKVWn+/ITk2WVR9y9j5mrq5//wlFA6NPctbbrmc03Amq+HRXCG05kPt8GhWmZxTNuuUyeW8/ZzTaNYp6x9nss4/n/PPO/+8dz2dyWl41AvCw/7XHB7NqX8ko+5+LzCPu57JzTphVimYSbHIhJDs78fygTri70e8qrCZNxzd5IVlM2+rccd+G5NM5h9L4VDI/37e8OxoOKSYP4w7GjwfGWsXi4QLbaN+H4IBHQCAalTMbzNrJe0NHHdKOm8O36PWzLZKykj6J+fctyc2MLOrJV0tSRs2bJjDlwawYoTC3kRM8dTc35vLeSF1dMh7tjYYXvP7+Wvpfi8ED/SMPWvb9aT37G12ZOqvH42Phdd6v4obrpEiMSkc9fbD/n4kOsM5/xWJSbVNRU00VWmhkKk+GlF96UdGz9toNlcIsiOZrHI5Keu88Jvzt8F9b6vx151TrhCWnR9+va85PJr1gnE+PI/m/Gtj148MjepgIDznnFPOeY93O+fkJOWck3PeVv42eN477b1vMUJ3Pqx6AThQWQ6ZQuaF4/x+PtxGQmNV5cIw7QlDtsdtQ+Zfm6JN4Fz+a+aHe49dmzwEPORXw/N9NH+bP5cP/mPt8m3G2uX7X5P/Pv4+wR0AKq8cv/W0O+eeNbPjJf2PmT3mnNsZbOCcu1nSzZK0cePGxf/oG8DKEgp5Q3ejDV6QnA/nvPA60DU+vOafvc3vH+mUDm7z1qrNjHjbbHr6cFuMfFgdN8FU8xSTT/mTTtU1eYF+haoJexNAJWor3ZPScc4VhmXnh2AH90cy3hDtkWxOI6O5QNtsoW0m54XufPjO+qE5lxsfyqc/r0Jle2zrtRnOZAvV8EzWq2KP5nLjzo1Vy71rrgr/b58P4WMB3BtmPjHQ5kd3e/VwBY7HDvJRd9w1eWE5bKaaiBXu1XylO/+9xp8LqSZiY/t+O8l/6MH/IMP/nKPwwUb+z9dr48au+fsmec+bB6ry0YgVqvLB6vvECdbyfc0Pc3cu+P3Hf9Dif/vCBzDOv7/yT2zwAQGAiYoJqM9KCo7BW+efK4pz7ll/u8vM7pF0lqSdM74JAKqNmRRLeK9iJo6ayDkpl/FDa9oPriOBIBs4lxmWhg6PDWke6p0w0dRj3v50E03JvKqumQq/FpsC+1bEfsj7WfMTUeVf+WHP9S3jJ7CKzrzmLRbGzBSLhBWLhJWodGdKJDdFiPXCqzcsfDTnH+fPZ8cq3sHqcy4ffpxTLqdAtXrsWr59PnBn/GHno9nxw8kzfn9GJ1wfzeY0Ggja0tgT8c6NHY8LhYFrKhx720zO+yChbzhTeC58NOv8beD5cP9nrlZmKukHDSHzntmv8Svt+Wp6TSRQ7fY/NMhX4gvD5zV+GL13bqzCrvx1jQ2pz7cPVtcLFXgLtpumSl+o1k98tt0blj/u2ffQ1M/A519S8P5xE4797RR/2PlT+ZEQkZD/5xKefYK6/J9f/s9V0qS/XxO3wb9v3rmx90gqfJAy1QcakfDcZujHylVMQH1A0klmdpy8YHqFpCuL+eJmtlrSoHNuxMySks6X9LH5dhYAliwzf1hviSZKck4aHZwwW3JgP90f+M3RzWM/Jw0f9b5W7y5p7/3evptmvdia+slBtrbR+zq5rLd1WW+4dWE/cN45/zgbeE/W+7p1zd5Q57rVUv3qsf38+frmQCDHUhEKmWKhsCrw6PSSkg/p+RCbD7R5k0PZWBCTja/y5gObyQsV+a+XznpD0QvH/rlxFftsTqMTJlzLV2KDz00Hn6XOf99QoH+hwnmTc2PPnY/64b/woUXgQ4F8eB/3wUJurL/Bym2wShysJuc/tJDGV3SDQ+xzk8LY5A87Jge24GMDZbghlrCQadLoAC/Ijs0eL6nwIVLOucLIj3HbwH0TPJfJef9dgiMRasIhRcNjH3gEw3PhuDBSwR8ZIAvcN+O3TmMfhAVHBIx7ZEP5kRJjH1RMfFxiqgn58q+Q/yHH+L/L/uMKgXOFv/sT/+75+y85oUWnHttYqf/cCzLr/xaccxkz2yzpbnnLzHzRObfNzG6QtNU5t8XMXiTpvyStlvQ6M/uQc+5USS+QdJM/eVJI3jOoj0/zrQAAxTIbG7Zc7ERTC+Wct+btYK8/KVVwgqrAjMwD3VLP09LwEa8SGwpLFg7sh4o/P3RIOrDN26b7p+9bKDI+tOaDa2yVX+bJ+QHcje27nArBfNz+hHahyIRZnuvGz/g87bl673ligjMWwPul1Zt4C9UtH1aygcCUnTC0vnAu8Ax8JuemHi6u4D8fNuF4/LDxQmjLjg2jD45AGBuSP1aZH38tV6gU56vKwQ8bZq4q5z9wUODDlPwHGy4wSmD8rPLBD13y5yRvFveQP9w+vw2GuMI1G3uGPf8yqfCBx2jWFT5YGXecf2Wc+kYzkz4Acs55P19o7MOVYOV8bDs2kV3wWNK4xySCQbswH0Jh3wu1mWyucO/k75WJH7zM1Q2XnbpkA6pNNVygkjZu3Oi2bt1a6W4AAKpNZsQb+jzU6wXWQX87dGiKc3674SPyykg2NoTZQpP3LTTh2Mbel8v6k2sNzjCsehoW8oJquCYwEVaNFKoJTJZVM+H8FNfy50ORQNtI4Hpkwvun2K+pnbzkUqTOe0YbAFDVgs96Byu6+c9Vg8+i55wrzOZerczsQefcxqmuMbAGALA0RGJSotV7VUou6wXVwozQg/5s0PlZoQenODfkP2Oc9p5Dzu9nM+PPj/RNfT7YPudPulVKkcA6wDX1gWpwfj8fZms1NhR8lm2hIq3ANXkhOf8sd6xxbL92lb+/yn8lFl59zmX957tHpEx6bBuu8SrssQTVbQBLRn44rySFtbz/7SKgAgBQrFB4LFRVSv553dyoP7HW6Nj+pHOBgJsZCSypFAjThcA94Xiw11+GyT+XGZH/UKMK1eWJ20Ileoprkvf1RvqKm9U6VBMIrn54rakf//MUthNCaHbEC/czsXDgeebV3uzX4479V+2E87Wr/MnNhr2fJzPs7w97y1kV9ofHtwmek8aC+MSfMRY4jjYQogGsOARUAACWEjNvbdxwxKtsLkWZES+ojhz1t33epFyFc4HzwWuD3WNDpesbvLWEI9EJW/813bXMiPcsdWF4uP/qP+CteTx0RBo5sjg/t4W8irXz12Yupn0huAa3ce96dtT/sCIz+TXpWuA4OyrJTf9nlF+POb9e87hz0bE/3+BQ8+A2VOPdn6H8+UhgmHqN90FPvu24DzJCY4F8yg85pmgbqhmr8DNcHVgWCKgAAKC88iFyvusSL7Zsxnt+eWKIHT7sheVwxAuaNbXeNhIbC0mR2rHzNbWBc3VeIMsHsGxGSgeDeTCwH53+/GC3dOi3kiwQ/iJjwTAUGfteE19hPxzmg+FUledM2puQbLAnUKEendBmRGOLn1SRcGzCn72/rakf+28w8b9PODY28mBcNX5CpX66P4ts2qvG1/rV78K2aYpzwW3j2HFNrTfDeeERgWkeHyicn+K6nDdzem2j/70bvVEB445Xe98vvIBf/yc95jA01qfc6PjHBIJbnnfHHBBQAQAAgsIRb53fhpbF/R75YcNLTX5d5+BQ8sIw88z4a7nMhOvZ8W2DzyhPnFG7mGeds6NeNTo/xHqq7eiQ9+FC3/7J17IjXrAfVzHOT2gW2I/UeiGvMNlZdKzqnMsEPlQ4KvXvHDtO983+5xmq8f5M5sLCgVnD/XWoh496P+dsw9ujiSkC7KpA+JwigOYDcTHD86cTqZsQXoPPu/vnLDT23zb4Cv43D87EPu56YOb1wis89qHMuHOzHQcnqZtuErrI1JPYhSL+cmn5vw9TjXIIjGaYqo2Z9/x/cH6AaP3kc5Ho/P97VDECKgAAAIpX6nWdl7NcdkJVPLg9MlYdD8cmLGdVPz6ABoNJtMELQlM9n5xfI3vosPf1h/3tTMeHd3v7oXBgpu96adWxE8JR3fjrNRPCU6jGD/5Dmvxse+BcMPSODno/f/9BLxDnV9fNLzsWnGl90gzsU1yXvEp3Pui53NTBsLA/IRhOt9Z3tQpFpgmy9dK5V0vPf3WlezgvBFQAAABgMYTC/gRcTeX5fsE1shvXlud7LieTRgdMNwHdDPu5jBeWC89kz1a1rZl83WXHzxZfGNI9GKhsTzV7vH89P+R6iSKgAgAAAACjA6oCTysDAAAAAKoCARUAAAAAUBUIqAAAAACAqkBABQAAAABUBQIqAAAAAKAqEFABAAAAAFWBgAoAAAAAqAoEVAAAAABAVSCgAgAAAACqAgEVAAAAAFAVCKgAAAAAgKpAQAUAAAAAVAUCKgAAAACgKhBQAQAAAABVgYAKAAAAAKgKBFQAAAAAQFUgoAIAAAAAqgIBFQAAAABQFcw5V+k+jGNmXZJ2V7ofs0hK6q50J4AJuC9RbbgnUY24L1GNuC9RbRb7nmx3zqWmulB1AXUpMLOtzrmNle4HEMR9iWrDPYlqxH2JasR9iWpTyXuSIb4AAAAAgKpAQAUAAAAAVAUC6vzcXOkOAFPgvkS14Z5ENeK+RDXivkS1qdg9yTOoAAAAAICqQAUVAAAAAFAVCKgAAAAAgKpAQJ0DM2s2s/8yswEz221mV1a6T1hZzGyzmW01sxEz+9KEa79nZk+a2aCZ/cTM2ivUTawwZhYzsy/4/y72mdnDZnZJ4Dr3JsrOzL5qZvvM7KiZPWVmfxq4xj2JijKzk8xs2My+Gjh3pf/v6ICZfdvMmivZR6wcZnaPfz/2+6/tgWtlvy8JqHNzo6S0pFZJV0n6rJmdWtkuYYV5TtLfS/pi8KSZJSV9S9L/ldQsaauk/yx777BSRSTtlfQ7kholfUDS7WbWwb2JCvpHSR3OuVWSLpX092Z2DvckqsSNkh7IH/i/T94k6Y/l/Z45KOkzlekaVqjNzrm4/3qeVLn7kkmSimRmDZIOSXqhc+4p/9xXJD3rnHtvRTuHFcfM/l7SOufcW/zjqyW9xTn3Uv+4QVK3pLOcc09WrKNYsczsUUkfktQi7k1UmJk9T9I9kt4tqUnck6ggM7tC0h9IelzSic65N5nZP8j7QOVKv80Jkp6Q1OKc66tcb7ESmNk9kr7qnPv8hPMVuS+poBbvZEmZfDj1PSKJCiqqwany7kdJknNuQNJOcX+iAsysVd6/mdvEvYkKMrPPmNmgpCcl7ZN0p7gnUUFmtkrSDZKum3Bp4n25U96ovZPL1zuscP9oZt1m9gsze4V/riL3JQG1eHFJRyecOyIpUYG+ABPF5d2PQdyfKDszq5H0NUlf9qtR3JuoGOfcO+Xday+TN6x3RNyTqKwPS/qCc65zwnnuS1TS30o6XtJaeeufftevllbkviSgFq9f0qoJ51ZJYtgFqgH3JyrOzEKSviLv09XN/mnuTVSUcy7rnPu5pHWS3iHuSVSImZ0p6UJJn5ziMvclKsY5d59zrs85N+Kc+7KkX0h6tSp0X0YW84svM09JipjZSc65Hf65M+QNYQMqbZukTfkD/5mqE8T9iTIxM5P0BXmTKLzaOTfqX+LeRLWIaOze455EJbxCUoekPd4/mYpLCpvZKZL+W97vlZIkMzteUkze759AuTlJJu/fxbLfl1RQi+Q/o/ItSTeYWYOZnS/pMnnVAqAszCxiZrWSwvL+p1ZrZhFJ/yXphWZ2uX/9ekmPMuEHyuizkl4g6XXOuaHAee5NlJ2ZrTGzK8wsbmZhM7tI0hsl/Vjck6icm+V9GHKm//qcpO9LukjeoxGvM7OX+R+a3CDpW0yQhMVmZk1mdlH+d0ozu0rSy+V9aFKR+5KAOjfvlFQn6aCkr0t6h3OOT1xRTh+QNCTpvZLe5O9/wDnXJelySR+RN9v0eZKuqFQnsbL4a0j+mbxfuPYH1lG7insTFeLkDeftlHfffULStc65LdyTqBTn3KBzbn/+JW/45LBzrsv/ffIaeYHgoLxn/N5Zwe5i5aiRt4Rhl7wZzf9c0uudc09V6r5kmRkAAAAAQFWgggoAAAAAqAoEVAAAAABAVSCgAgAAAACqAgEVAAAAAFAVCKgAAAAAgKpAQAUAAAAAVAUCKgAAAACgKhBQAQAAAABVgYAKAAAAAKgK/w83+4RH0sKt7AAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -325,11 +328,7 @@ } ], "source": [ - "_, ax = plt.subplots()\n", - "ax.plot(train_loss, label=\"Train\")\n", - "ax.plot(val_loss, label=\"Val\")\n", - "ax.legend()\n", - "plt.show()" + "plot_losses(losses)" ] }, { @@ -349,7 +348,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 12, @@ -358,7 +357,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -499,7 +498,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -573,8 +572,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average mislabelled data influence: -0.7414471365061857\n", - "Average correct data influence: 0.00813213261992543\n" + "Average mislabelled data influence: -0.7081194523556167\n", + "Average correct data influence: 0.007535246334452065\n" ] } ], @@ -601,7 +600,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -662,8 +661,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average mislabelled data influence: -0.7414468874499299\n", - "Average correct data influence: 0.00813213256671605\n" + "Average mislabelled data influence: -0.7081188846494786\n", + "Average correct data influence: 0.007535246880673285\n" ] } ], @@ -700,7 +699,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index cc257a35f..2d3b78a75 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -55,7 +55,8 @@ "import numpy as np\n", "import torch\n", "import torch.nn.functional as F\n", - "from notebook_support import plot_losses, TorchMLP, fit_torch_model\n", + "from notebook_support import plot_losses\n", + "from notebook_support_torch import TorchMLP, fit_torch_model\n", "from pydvl.influence.general import compute_influences\n", "from pydvl.utils.dataset import load_wine_dataset\n", "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, f1_score\n", @@ -168,7 +169,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ce404d963a144702b0cdd559dce44fa2", + "model_id": "a8dc091ba62e4372a55305c460060480", "version_major": 2, "version_minor": 0 }, @@ -185,19 +186,19 @@ "unique_classes = np.unique(np.concatenate((train_data[1], test_data[1])))\n", "num_classes = len(unique_classes)\n", "network_size = [16, 16]\n", - "\n", + "layers_size = [feature_dimension, *network_size, num_classes]\n", "num_epochs = 300\n", "lr = 0.005\n", "weight_decay = 0.01\n", "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", "\n", - "nn_model = TorchMLP(feature_dimension, num_classes, network_size)\n", + "nn_model = TorchMLP(layers_size)\n", "nn_model.to(device)\n", "\n", "optimizer = Adam(params=nn_model.parameters(), lr=lr, weight_decay=weight_decay)\n", "scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=num_epochs)\n", "\n", - "train_loss, val_loss = fit_torch_model(\n", + "losses = fit_torch_model(\n", " model=nn_model,\n", " x_train=train_data[0],\n", " y_train=train_data[1],\n", @@ -227,7 +228,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -239,7 +240,7 @@ } ], "source": [ - "plot_losses(train_loss, val_loss)" + "plot_losses(losses)" ] }, { @@ -335,7 +336,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7749b4cf1e7c4b0185bceb1bc894a6d5", + "model_id": "e0663748704f43278c7db2e57dd4d6b6", "version_major": 2, "version_minor": 0 }, @@ -349,7 +350,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "245f27435cd942b2b659f6c0008593ae", + "model_id": "ec3eab1eae4c4439af6337fd896895fc", "version_major": 2, "version_minor": 0 }, @@ -416,7 +417,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -456,8 +457,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average influence of corrupted points: -0.03891054072273765\n", - "Average influence of other points: 0.031147227974786414\n" + "Average influence of corrupted points: -0.03815854208794334\n", + "Average influence of other points: 0.030863110017283625\n" ] } ], @@ -497,7 +498,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "13ae88de7f79441e8ab05d9947a9e8f6", + "model_id": "610cac483f224201a4f972f0a3110b13", "version_major": 2, "version_minor": 0 }, @@ -511,7 +512,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "92dd0ef4917245df8efef33b48817db5", + "model_id": "f8de99035b9d4ab4b7f7116ae77cc51d", "version_major": 2, "version_minor": 0 }, @@ -544,7 +545,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -620,7 +621,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Percentage error of cg over direct method:0.0009528368049549545 %\n" + "Percentage error of cg over direct method:0.0007001312394795379 %\n" ] } ], diff --git a/notebooks/notebook_support.py b/notebooks/notebook_support.py index fbdee5798..615d6031e 100644 --- a/notebooks/notebook_support.py +++ b/notebooks/notebook_support.py @@ -1,309 +1,33 @@ import logging import os -import pickle as pkl +from collections import namedtuple from copy import deepcopy -from pathlib import Path -from typing import ( - TYPE_CHECKING, - Any, - Callable, - Dict, - Iterable, - List, - Optional, - Sequence, - Tuple, - Union, -) +from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple import matplotlib.patches as mpatches import matplotlib.pyplot as plt import numpy as np import pandas as pd -import torch.nn as nn +from numpy.typing import NDArray from PIL.JpegImagePlugin import JpegImageFile -from torch.optim import Adam -from torchvision.models import ResNet18_Weights, resnet18 -from pydvl.utils import Dataset, maybe_progress - -try: - import torch - import torch.nn as nn - from torch.optim import Optimizer - from torch.optim.lr_scheduler import _LRScheduler - from torch.utils.data import DataLoader, TensorDataset - - _TORCH_INSTALLED = True -except ImportError: - _TORCH_INSTALLED = False - -if TYPE_CHECKING: - from numpy.typing import NDArray - -MODEL_PATH = Path().resolve().parent / "data" / "models" +from pydvl.utils import Dataset logger = logging.getLogger(__name__) +Losses = namedtuple("Losses", "training val") -class TorchLogisticRegression(nn.Module): - """ - A simple binary logistic regression model. - """ - - def __init__( - self, - n_input: int, - ): - """ - :param n_input: Number of feature in input. - """ - super().__init__() - self.fc1 = nn.Linear(n_input, 1, bias=True, dtype=float) - - def forward(self, x): - """ - :param x: Tensor [NxD] representing the features x_i. - :returns: A tensor [N] representing the probabilities for p(y_i). - """ - x = torch.as_tensor(x) - return torch.sigmoid(self.fc1(x)) - - -class TorchMLP(nn.Module): - """ - A simple fully-connected neural network f(x) - """ - - def __init__( - self, - n_input: int, - n_output: int, - n_neurons_per_layer: List[int], - ): - """ - :param n_input: Number of feature in input. - :param n_output: Output length. - :param n_neurons_per_layer: Each integer represents the size of a hidden layer. Overall this list has K - 2 - :param init: A list of tuple of np.ndarray representing the internal weights. - """ - super().__init__() - self.n_input = n_input - - self.n_hidden_layers = n_neurons_per_layer - - if n_neurons_per_layer == []: - layers = [nn.Linear(n_input, n_output)] - else: - layers = [nn.Linear(n_input, n_neurons_per_layer[0]), nn.Tanh()] - for idx, n_neurons in enumerate(n_neurons_per_layer): - if idx == 0: - continue - layers.append(nn.Linear(n_neurons_per_layer[idx - 1], n_neurons)) - layers.append(nn.Tanh()) - layers.append(nn.Linear(n_neurons_per_layer[-1], n_output)) - - layers.append(nn.Softmax(dim=-1)) - - self.layers = nn.Sequential(*layers) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """ - Perform forward-pass through the network. - :param x: Tensor input of shape [NxD]. - :returns: Tensor output of shape[NxK]. - """ - return self.layers(x) - - -def fit_torch_model( - model: nn.Module, - x_train: Union["NDArray[np.float_]", torch.tensor], - y_train: Union["NDArray[np.float_]", torch.tensor], - x_val: Union["NDArray[np.float_]", torch.tensor], - y_val: Union["NDArray[np.float_]", torch.tensor], - loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], - optimizer: Optimizer, - scheduler: Optional[_LRScheduler] = None, - num_epochs: int = 1, - batch_size: int = 64, - progress: bool = True, -) -> Tuple["NDArray[np.float_]", "NDArray[np.float_]"]: - """ - Method that fits a pytorch model to the supplied data. - It represents a simple machine learning loop, iterating over a number of - epochs, sampling data with a certain batch size, calculating gradients and updating the parameters through a - loss function. - :param x: Matrix of shape [NxD] representing the features x_i. - :param y: Matrix of shape [NxK] representing the prediction targets y_i. - :param optimizer: Select either ADAM or ADAM_W. - :param scheduler: A pytorch scheduler. If None, no scheduler is used. - :param num_epochs: Number of epochs to repeat training. - :param batch_size: Batch size to use in training. - :param progress: True, iff progress shall be printed. - :param tensor_type: accuracy of tensors. Typically 'float' or 'long' - """ - x_train = torch.as_tensor(x_train).clone() - y_train = torch.as_tensor(y_train).clone() - x_val = torch.as_tensor(x_val).clone() - y_val = torch.as_tensor(y_val).clone() - - dataset = TensorDataset(x_train, y_train) - dataloader = DataLoader(dataset, batch_size=batch_size) - train_loss = [] - val_loss = [] - - for epoch in maybe_progress(range(num_epochs), progress, desc="Model fitting"): - batch_loss = [] - for train_batch in dataloader: - batch_x, batch_y = train_batch - pred_y = model(batch_x) - loss_value = loss(torch.squeeze(pred_y), torch.squeeze(batch_y)) - batch_loss.append(loss_value.item()) - - logger.debug(f"Epoch: {epoch} ---> Training loss: {loss_value.item()}") - loss_value.backward() - optimizer.step() - optimizer.zero_grad() - - if scheduler: - scheduler.step() - pred_val = model(x_val) - epoch_val_loss = loss(torch.squeeze(pred_val), torch.squeeze(y_val)).item() - mean_epoch_train_loss = np.mean(batch_loss) - val_loss.append(epoch_val_loss) - train_loss.append(mean_epoch_train_loss) - logger.info( - f"Epoch: {epoch} ---> Training loss: {mean_epoch_train_loss}, Validation loss: {epoch_val_loss}" - ) - return np.array(train_loss), np.array(val_loss) - - -def new_resnet_model(output_size: int) -> nn.Module: - model = resnet18(weights=ResNet18_Weights.IMAGENET1K_V1) - - for param in model.parameters(): - param.requires_grad = False - - # Fine-tune final few layers - model.avgpool = nn.AdaptiveAvgPool2d(1) - n_features = model.fc.in_features - model.fc = nn.Linear(n_features, output_size) - device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") - model.to(device) - - return model - - -class TrainingManager: - """A simple class to handle persistence of the model for the notebook - `influence_imagenet.ipynb` - """ - - def __init__( - self, - name: str, - model: nn.Module, - loss: torch.nn.modules.loss._Loss, - train_x: "NDArray[np.float_]", - train_y: "NDArray[np.float_]", - val_x: "NDArray[np.float_]", - val_y: "NDArray[np.float_]", - data_dir: Path, - ): - self.name = name - self.model = model - self.loss = loss - self.train_x, self.train_y = train_x, train_y - self.val_x, self.val_y = val_x, val_y - self.data_dir = data_dir - os.makedirs(self.data_dir, exist_ok=True) - - def train( - self, - n_epochs: int, - lr: float = 0.001, - batch_size: int = 1000, - use_cache: bool = True, - ) -> Tuple["NDArray[np.float_]", "NDArray[np.float_]"]: - """ - :return: Tuple of training_loss, validation_loss - """ - if use_cache: - try: - training_loss, validation_loss = self.load() - print("Cached model found, loading...") - return training_loss, validation_loss - except: - print(f"No pretrained model found. Training for {n_epochs} epochs:") - - optimizer = Adam(self.model.parameters(), lr=lr) - - training_loss, validation_loss = fit_torch_model( - model=self.model, - x_train=self.train_x, - y_train=self.train_y, - x_val=self.val_x, - y_val=self.val_y, - loss=self.loss, - optimizer=optimizer, - num_epochs=n_epochs, - batch_size=batch_size, - ) - if use_cache: - self.save(training_loss, validation_loss) - self.model.eval() - return training_loss, validation_loss - - def save( - self, training_loss: "NDArray[np.float_]", validation_loss: "NDArray[np.float_]" - ): - """Saves the model weights and training and validation losses. - - :param training_loss: list of training losses, one per epoch - :param validation_loss: list of validation losses, also one per epoch - """ - torch.save(self.model.state_dict(), self.data_dir / f"{self.name}_weights.pth") - with open(self.data_dir / f"{self.name}_train_val_loss.pkl", "wb") as file: - pkl.dump([training_loss, validation_loss], file) - - def load(self) -> Tuple["NDArray[np.float_]", "NDArray[np.float_]"]: - """Loads model weights and training and validation losses. - :return: two arrays, one with training and one with validation losses. - """ - self.model.load_state_dict( - torch.load(self.data_dir / f"{self.name}_weights.pth") - ) - self.model.eval() - with open(self.data_dir / f"{self.name}_train_val_loss.pkl", "rb") as file: - return pkl.load(file) - - -def process_imgnet_io( - df: pd.DataFrame, labels: dict -) -> Tuple[torch.Tensor, torch.Tensor]: - x = df["normalized_images"] - y = df["labels"] - ds_label_to_model_label = { - ds_label: idx for idx, ds_label in enumerate(labels.values()) - } - device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") - x_nn = torch.stack(x.tolist()).to(device) - y_nn = torch.tensor([ds_label_to_model_label[yi] for yi in y], device=device) - return x_nn, y_nn - - -def plot_dataset( - train_ds: Tuple["NDArray[np.float_]", "NDArray[np.int_]"], - test_ds: Tuple["NDArray[np.float_]", "NDArray[np.int_]"], - x_min: Optional["NDArray[np.float_]"] = None, - x_max: Optional["NDArray[np.float_]"] = None, +def plot_gaussian_blobs( + train_ds: Tuple[NDArray[np.float_], NDArray[np.int_]], + test_ds: Tuple[NDArray[np.float_], NDArray[np.int_]], + x_min: Optional[NDArray[np.float_]] = None, + x_max: Optional[NDArray[np.float_]] = None, *, xlabel: Optional[str] = None, ylabel: Optional[str] = None, legend_title: Optional[str] = None, vline: Optional[float] = None, - line: Optional["NDArray[np.float_]"] = None, + line: Optional[NDArray[np.float_]] = None, suptitle: Optional[str] = None, s: Optional[float] = None, figsize: Tuple[int, int] = (20, 10), @@ -376,15 +100,15 @@ def plot_dataset( def plot_influences( - x: "NDArray[np.float_]", - influences: "NDArray[np.float_]", + x: NDArray[np.float_], + influences: NDArray[np.float_], corrupted_indices: Optional[List[int]] = None, *, ax: Optional[plt.Axes] = None, xlabel: Optional[str] = None, ylabel: Optional[str] = None, legend_title: Optional[str] = None, - line: Optional["NDArray[np.float_]"] = None, + line: Optional[NDArray[np.float_]] = None, suptitle: Optional[str] = None, colorbar_limits: Optional[Tuple] = None, ) -> plt.Axes: @@ -663,7 +387,7 @@ def plot_sample_images(dataset: pd.DataFrame, n_images_per_class: int = 3): def plot_lowest_highest_influence_images( - subset_influences: "NDArray[np.float_]", + subset_influences: NDArray[np.float_], subset_images: List[JpegImageFile], num_to_plot: int, ): @@ -694,17 +418,15 @@ def plot_lowest_highest_influence_images( plt.show() -def plot_losses( - training_loss: "NDArray[np.float_]", validation_loss: "NDArray[np.float_]" -): +def plot_losses(losses: Losses): """Plots the train and validation loss :param training_loss: list of training losses, one per epoch :param validation_loss: list of validation losses, one per epoch """ _, ax = plt.subplots() - ax.plot(training_loss, label="Train") - ax.plot(validation_loss, label="Val") + ax.plot(losses.training, label="Train") + ax.plot(losses.val, label="Val") ax.set_ylabel("Loss") ax.set_xlabel("Train epoch") ax.legend() @@ -714,7 +436,7 @@ def plot_losses( def corrupt_imagenet( dataset: pd.DataFrame, fraction_to_corrupt: float, - avg_influences: "NDArray[np.float_]", + avg_influences: NDArray[np.float_], ) -> Tuple[pd.DataFrame, Dict[Any, List[int]]]: """Given the preprocessed tiny imagenet dataset (or a subset of it), it takes a fraction of the images with the highest influence and (randomly) @@ -752,10 +474,10 @@ def corrupt_imagenet( def compute_mean_corrupted_influences( corrupted_dataset: pd.DataFrame, corrupted_indices: Dict[Any, List[int]], - avg_corrupted_influences: "NDArray[np.float_]", + avg_corrupted_influences: NDArray[np.float_], ) -> pd.DataFrame: - """Given a corrupted dataset, it returns a dataframe with average influence for each class - and separately for corrupted (and non) point. + """Given a corrupted dataset, it returns a dataframe with average influence for each class, + separating corrupted and original points. :param corrupted_dataset: corrupted dataset as returned by get_corrupted_imagenet :param corrupted_indices: list of corrupted indices, as returned by get_corrupted_imagenet @@ -789,7 +511,7 @@ def compute_mean_corrupted_influences( def plot_corrupted_influences_distribution( corrupted_dataset: pd.DataFrame, corrupted_indices: Dict[Any, List[int]], - avg_corrupted_influences: "NDArray[np.float_]", + avg_corrupted_influences: NDArray[np.float_], figsize: Tuple[int, int] = (16, 8), ): """Given a corrupted dataset, plots the histogram with the distribution of diff --git a/notebooks/notebook_support_torch.py b/notebooks/notebook_support_torch.py new file mode 100644 index 000000000..307f133c0 --- /dev/null +++ b/notebooks/notebook_support_torch.py @@ -0,0 +1,265 @@ +import logging +import os +import pickle as pkl +from collections import namedtuple +from pathlib import Path +from typing import Callable, List, Optional, Tuple, Union + +import numpy as np +import pandas as pd +import torch +import torch.nn as nn +from torch.optim import Adam, Optimizer +from torch.optim.lr_scheduler import _LRScheduler +from torch.utils.data import DataLoader, TensorDataset +from torchvision.models import ResNet18_Weights, resnet18 + +from pydvl.utils import maybe_progress + +logger = logging.getLogger(__name__) + +from numpy.typing import NDArray + +Losses = namedtuple("Losses", "training val") +MODEL_PATH = Path().resolve().parent / "data" / "models" + + +class TorchLogisticRegression(nn.Module): + """ + A simple binary logistic regression model. + """ + + def __init__( + self, + n_input: int, + ): + """ + :param n_input: Number of features in the input. + """ + super().__init__() + self.fc1 = nn.Linear(n_input, 1, bias=True, dtype=float) + + def forward(self, x): + """ + :param x: Tensor [NxD], with N the batch length and D the number of features. + :returns: A tensor [N] representing the probability of the positive class for each sample. + """ + x = torch.as_tensor(x) + return torch.sigmoid(self.fc1(x)) + + +class TorchMLP(nn.Module): + """ + A simple fully-connected neural network + """ + + def __init__( + self, + layers_size: List[int], + ): + """ + :param layers_size: list of integers representing the number of + neurons in each layer. + """ + super().__init__() + if len(layers_size) < 2: + raise ValueError( + "Passed layers_size has less than 2 values. " + "The network needs at least input and output sizes." + ) + layers = [] + for frm, to in zip(layers_size[:-1], layers_size[1:]): + layers.append(nn.Linear(frm, to)) + layers.append(nn.Tanh()) + layers.pop() + + layers.append(nn.Softmax(dim=-1)) + + self.layers = nn.Sequential(*layers) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """ + Perform forward pass through the network. + :param x: Tensor input of shape [NxD], with N batch size and D number of + features. + :returns: Tensor output of shape[NxK], with K the output size of the network. + """ + return self.layers(x) + + +def fit_torch_model( + model: nn.Module, + x_train: Union[NDArray[np.float_], torch.tensor], + y_train: Union[NDArray[np.float_], torch.tensor], + x_val: Union[NDArray[np.float_], torch.tensor], + y_val: Union[NDArray[np.float_], torch.tensor], + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + optimizer: Optimizer, + scheduler: Optional[_LRScheduler] = None, + num_epochs: int = 1, + batch_size: int = 64, + progress: bool = True, +) -> Losses: + """ + Method that fits a pytorch model to the supplied data. + It represents a simple machine learning loop, iterating over a number of + epochs, sampling data with a certain batch size, calculating gradients and updating the parameters through a + loss function. + :param x: Matrix of shape [NxD] representing the features x_i. + :param y: Matrix of shape [NxK] representing the prediction targets y_i. + :param optimizer: Select either ADAM or ADAM_W. + :param scheduler: A pytorch scheduler. If None, no scheduler is used. + :param num_epochs: Number of epochs to repeat training. + :param batch_size: Batch size to use in training. + :param progress: True, iff progress shall be printed. + :param tensor_type: accuracy of tensors. Typically 'float' or 'long' + """ + x_train = torch.as_tensor(x_train).clone() + y_train = torch.as_tensor(y_train).clone() + x_val = torch.as_tensor(x_val).clone() + y_val = torch.as_tensor(y_val).clone() + + dataset = TensorDataset(x_train, y_train) + dataloader = DataLoader(dataset, batch_size=batch_size) + train_loss = [] + val_loss = [] + + for epoch in maybe_progress(range(num_epochs), progress, desc="Model fitting"): + batch_loss = [] + for train_batch in dataloader: + batch_x, batch_y = train_batch + pred_y = model(batch_x) + loss_value = loss(torch.squeeze(pred_y), torch.squeeze(batch_y)) + batch_loss.append(loss_value.item()) + + logger.debug(f"Epoch: {epoch} ---> Training loss: {loss_value.item()}") + loss_value.backward() + optimizer.step() + optimizer.zero_grad() + + if scheduler: + scheduler.step() + pred_val = model(x_val) + epoch_val_loss = loss(torch.squeeze(pred_val), torch.squeeze(y_val)).item() + mean_epoch_train_loss = np.mean(batch_loss) + val_loss.append(epoch_val_loss) + train_loss.append(mean_epoch_train_loss) + logger.info( + f"Epoch: {epoch} ---> Training loss: {mean_epoch_train_loss}, Validation loss: {epoch_val_loss}" + ) + return Losses(train_loss, val_loss) + + +def new_resnet_model(output_size: int) -> nn.Module: + model = resnet18(weights=ResNet18_Weights.IMAGENET1K_V1) + + for param in model.parameters(): + param.requires_grad = False + + # Fine-tune final few layers + model.avgpool = nn.AdaptiveAvgPool2d(1) + n_features = model.fc.in_features + model.fc = nn.Linear(n_features, output_size) + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + model.to(device) + + return model + + +class TrainingManager: + """A simple class to handle persistence of the model for the notebook + `influence_imagenet.ipynb` + """ + + def __init__( + self, + name: str, + model: nn.Module, + loss: torch.nn.modules.loss._Loss, + train_x: NDArray[np.float_], + train_y: NDArray[np.float_], + val_x: NDArray[np.float_], + val_y: NDArray[np.float_], + data_dir: Path, + ): + self.name = name + self.model = model + self.loss = loss + self.train_x, self.train_y = train_x, train_y + self.val_x, self.val_y = val_x, val_y + self.data_dir = data_dir + os.makedirs(self.data_dir, exist_ok=True) + + def train( + self, + n_epochs: int, + lr: float = 0.001, + batch_size: int = 1000, + use_cache: bool = True, + ) -> Tuple[NDArray[np.float_], NDArray[np.float_]]: + """ + :return: Tuple of training_loss, validation_loss + """ + if use_cache: + try: + training_loss, validation_loss = self.load() + print("Cached model found, loading...") + return training_loss, validation_loss + except: + print(f"No pretrained model found. Training for {n_epochs} epochs:") + + optimizer = Adam(self.model.parameters(), lr=lr) + + losses = fit_torch_model( + model=self.model, + x_train=self.train_x, + y_train=self.train_y, + x_val=self.val_x, + y_val=self.val_y, + loss=self.loss, + optimizer=optimizer, + num_epochs=n_epochs, + batch_size=batch_size, + ) + if use_cache: + self.save(losses) + self.model.eval() + return losses + + def save( + self, + losses: Losses, + ): + """Saves the model weights and training and validation losses. + + :param training_loss: list of training losses, one per epoch + :param validation_loss: list of validation losses, also one per epoch + """ + torch.save(self.model.state_dict(), self.data_dir / f"{self.name}_weights.pth") + with open(self.data_dir / f"{self.name}_train_val_loss.pkl", "wb") as file: + pkl.dump(losses, file) + + def load(self) -> Losses: + """Loads model weights and training and validation losses. + :return: two arrays, one with training and one with validation losses. + """ + self.model.load_state_dict( + torch.load(self.data_dir / f"{self.name}_weights.pth") + ) + self.model.eval() + with open(self.data_dir / f"{self.name}_train_val_loss.pkl", "rb") as file: + return pkl.load(file) + + +def process_imgnet_io( + df: pd.DataFrame, labels: dict +) -> Tuple[torch.Tensor, torch.Tensor]: + x = df["normalized_images"] + y = df["labels"] + ds_label_to_model_label = { + ds_label: idx for idx, ds_label in enumerate(labels.values()) + } + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + x_nn = torch.stack(x.tolist()).to(device) + y_nn = torch.tensor([ds_label_to_model_label[yi] for yi in y], device=device) + return x_nn, y_nn diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 5104de7d8..9f71187f7 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -2,7 +2,7 @@ Contains all parts of pyTorch based machine learning model. """ import logging -from typing import TYPE_CHECKING, Callable, Optional, Tuple, Union +from typing import Callable, Optional, Tuple, Union import numpy as np @@ -19,8 +19,7 @@ except ImportError: _TORCH_INSTALLED = False -if TYPE_CHECKING: - from numpy.typing import NDArray +from numpy.typing import NDArray __all__ = [ "TorchTwiceDifferentiable", @@ -53,9 +52,9 @@ def __init__( raise RuntimeWarning("This function requires PyTorch.") if model.training: logger.warning( - "Passed model not in eval mode. This can create several issues in influence " - "computation, e.g. due batch normalization. Please call model.eval() before computing" - "influences." + "Passed model not in evaluation mode. This can create several issues in influence " + "computation, e.g. due to batch normalization. Please call model.eval() before " + "computing influences." ) self.model = model self.loss = loss @@ -73,7 +72,7 @@ def split_grad( x: TensorType, y: TensorType, progress: bool = False, - ) -> "NDArray": + ) -> NDArray: """ Calculates gradient of model parameters wrt each x[i] and y[i] and then returns a array of size [N, P] with N number of points (length of x and y) and P @@ -114,7 +113,7 @@ def grad( self, x: TensorType, y: TensorType, - ) -> Tuple["NDArray", "torch.Tensor"]: + ) -> Tuple[NDArray, "torch.Tensor"]: """ Calculates gradient of model parameters wrt x and y. :param x: A np.ndarray [NxD] representing the features x_i. @@ -142,7 +141,7 @@ def mvp( v: TensorType, progress: bool = False, backprop_on: Optional["torch.Tensor"] = None, - ) -> "NDArray": + ) -> NDArray: """ Calculates second order derivative of the model along directions v. This second order derivative can be on the model parameters or on another input parameter, diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 2c9552ade..df565895d 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -2,7 +2,7 @@ Contains parallelized influence calculation functions for general models. """ from enum import Enum -from typing import TYPE_CHECKING, Callable, Union +from typing import Callable import numpy as np @@ -19,9 +19,7 @@ except ImportError: _TORCH_INSTALLED = False -if TYPE_CHECKING: - from numpy.typing import NDArray - +from numpy.typing import NDArray __all__ = ["compute_influences", "InfluenceType", "calculate_influence_factors"] @@ -44,7 +42,7 @@ def calculate_influence_factors( inversion_method: InversionMethod, lam: float = 0, progress: bool = False, -) -> "NDArray": +) -> NDArray: """ Calculates the influence factors. For more info, see https://arxiv.org/pdf/1703.04730.pdf, paragraph 3. @@ -78,9 +76,9 @@ def _calculate_influences_up( model: TwiceDifferentiable, x: TensorType, y: TensorType, - influence_factors: "NDArray", + influence_factors: NDArray, progress: bool = False, -) -> "NDArray": +) -> NDArray: """ Calculates the influence from the influence factors and the scores of the training points. Uses the upweighting method, as described in section 2.1 of https://arxiv.org/pdf/1703.04730.pdf @@ -100,9 +98,9 @@ def _calculate_influences_pert( model: TwiceDifferentiable, x: TensorType, y: TensorType, - influence_factors: "NDArray", + influence_factors: NDArray, progress: bool = False, -) -> "NDArray": +) -> NDArray: """ Calculates the influence from the influence factors and the scores of the training points. Uses the perturbation method, as described in section 2.2 of https://arxiv.org/pdf/1703.04730.pdf @@ -149,7 +147,7 @@ def compute_influences( inversion_method: InversionMethod = InversionMethod.Direct, influence_type: InfluenceType = InfluenceType.Up, hessian_regularization: float = 0, -) -> "NDArray": +) -> NDArray: """ Calculates the influence of the training points j on the test points i. First it calculates the influence factors for all test points with respect to the training points, and then uses them to diff --git a/src/pydvl/influence/inversion_methods.py b/src/pydvl/influence/inversion_methods.py index 75fdc1ac2..32990e294 100644 --- a/src/pydvl/influence/inversion_methods.py +++ b/src/pydvl/influence/inversion_methods.py @@ -6,16 +6,14 @@ """ import logging from enum import Enum -from typing import TYPE_CHECKING, Callable, Tuple +from typing import Callable, Tuple import numpy as np +from numpy.typing import NDArray from scipy.sparse.linalg import LinearOperator, cg from ..utils import maybe_progress -if TYPE_CHECKING: - from numpy.typing import NDArray - __all__ = ["matrix_inversion_algorithm", "conjugate_gradient"] logger = logging.getLogger(__name__) @@ -32,11 +30,11 @@ class InversionMethod(str, Enum): def invert_matrix( inversion_method: InversionMethod, - mvp: Callable[["NDArray"], "NDArray"], + mvp: Callable[[NDArray], NDArray], mvp_dimensions: Tuple[int, int], - b: "NDArray", + b: NDArray, progress: bool = False, -) -> "NDArray": +) -> NDArray: """ It solves the problem of finding x such that Ax = b, where A is a matrix (of size mvp_dimensions), and b a vector. @@ -65,8 +63,8 @@ def invert_matrix( def conjugate_gradient( - A: "NDArray[np.float_]", batch_y: "NDArray[np.float_]", progress: bool = False -) -> "NDArray[np.float_]": + A: NDArray[np.float_], batch_y: NDArray[np.float_], progress: bool = False +) -> NDArray[np.float_]: """ Given a matrix and a batch of vectors, it uses conjugate gradient to calculate the solution to Ax = y for each y in batch_y. diff --git a/src/pydvl/influence/types.py b/src/pydvl/influence/types.py index 4693af0e4..104d2859b 100644 --- a/src/pydvl/influence/types.py +++ b/src/pydvl/influence/types.py @@ -1,5 +1,5 @@ from abc import ABC -from typing import TYPE_CHECKING, Optional, Tuple, Union +from typing import Optional, Tuple, Union try: import torch @@ -12,7 +12,7 @@ __all__ = ["TwiceDifferentiable", "TensorType"] -TensorType = Union["NDArray", "torch.TensorType"] +TensorType = Union[NDArray, "torch.Tensor"] class TwiceDifferentiable(ABC): @@ -21,7 +21,7 @@ def num_params(self) -> int: def split_grad( self, x: TensorType, y: TensorType, progress: bool = False - ) -> "NDArray": + ) -> NDArray: """ Calculate the gradient of the model wrt each input x and labels y. The output is therefore of size [Nxp], with N the amout of points (the length of x and y) and @@ -29,7 +29,7 @@ def split_grad( """ pass - def grad(self, x: TensorType, y: TensorType) -> Tuple["NDArray", TensorType]: + def grad(self, x: TensorType, y: TensorType) -> Tuple[NDArray, TensorType]: """ It calculates the gradient of model parameters with respect to input x and labels y. """ @@ -41,7 +41,7 @@ def mvp( v: TensorType, progress: bool = False, backprop_on: Optional[TensorType] = None, - ) -> "NDArray": + ) -> NDArray: """ Calculate the hessian vector product over the loss with all input parameters x and y with the vector v. """ diff --git a/src/pydvl/reporting/plots.py b/src/pydvl/reporting/plots.py index f449240a7..ddc029bb8 100644 --- a/src/pydvl/reporting/plots.py +++ b/src/pydvl/reporting/plots.py @@ -1,13 +1,11 @@ -from typing import TYPE_CHECKING, Any, List, Optional, OrderedDict, Sequence +from typing import Any, List, Optional, OrderedDict, Sequence import matplotlib.pyplot as plt import numpy as np import pandas as pd import scipy as sp from matplotlib.axes import Axes - -if TYPE_CHECKING: - from numpy.typing import NDArray +from numpy.typing import NDArray def shaded_mean_std( @@ -196,8 +194,8 @@ def plot_shapley( def plot_influence_distribution_by_label( - influences: "NDArray[np.float_]", - labels: "NDArray[np.float_]", + influences: NDArray[np.float_], + labels: NDArray[np.float_], title_extra: str = "", ): """Plots the histogram of the influence that all samples in the training set diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index 8942bbddf..645583650 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -116,7 +116,7 @@ def random_subset_of_size(s: NDArray[T], size: int) -> NDArray[T]: return rng.choice(s, size=size, replace=False) -def random_matrix_with_condition_number(n: int, condition_number: float) -> "NDArray": +def random_matrix_with_condition_number(n: int, condition_number: float) -> NDArray: """Constructs a square matrix with a given condition number. Taken from: diff --git a/tests/influence/conftest.py b/tests/influence/conftest.py index 75053430d..ca6de7608 100644 --- a/tests/influence/conftest.py +++ b/tests/influence/conftest.py @@ -1,15 +1,13 @@ -from typing import TYPE_CHECKING, List, Tuple +from typing import Tuple import numpy as np import pytest +from numpy.typing import NDArray from sklearn.preprocessing import MinMaxScaler from pydvl.influence.general import InfluenceType from pydvl.utils import Dataset, random_matrix_with_condition_number -if TYPE_CHECKING: - from numpy.typing import NDArray - @pytest.fixture def input_dimension(request) -> int: @@ -47,13 +45,21 @@ def linear_model(problem_dimension: Tuple[int, int], condition_number: float): def linear_derivative_analytical( - linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", y: "NDArray" -) -> "NDArray": + linear_model: Tuple[NDArray[np.float_], NDArray[np.float_]], + x: NDArray[np.float_], + y: NDArray[np.float_], +) -> NDArray[np.float_]: """ - :param linear_model: A tuple of np.ndarray' of shape [NxM] and [N] representing A and b respectively. - :param x: A np.ndarray of shape [BxM]. - :param y: A np.nparray of shape [BxN]. - :returns: A np.ndarray of shape [Bx((N+1)*M)], where each row vector is [d_theta L(x, y), d_b L(x, y)] + Given a linear model it returns the first order derivative wrt its parameters. + More precisely, given a couple of matrices $A(\theta)$ and $b(\theta')$, with + $\theta$, $\theta'$ representing their generic entry, it calculates the + derivative wrt. $\theta$ and $\theta'$ of the linear model with the + following quadratic loss: $L(x,y) = (Ax +b - y)^2$. + :param linear_model: A tuple of arrays representing the linear model. + :param x: array, input to the linear model + :param y: array, output of the linear model + :returns: An array where each row holds $[\partial_\theta L(x, y), + \partial_{\theta'} L(x, y)]$ """ A, b = linear_model @@ -66,16 +72,21 @@ def linear_derivative_analytical( def linear_hessian_analytical( - linear_model: Tuple["NDArray", "NDArray"], - x: "NDArray", + linear_model: Tuple[NDArray[np.float_], NDArray[np.float_]], + x: NDArray[np.float_], lam: float = 0, -) -> "NDArray": +) -> NDArray[np.float_]: """ - :param linear_model: A tuple of np.ndarray' of shape [NxM] and [N] representing A and b respectively. - :param x: A np.ndarray of shape [BxM], - :param y: A np.nparray of shape [BxN]. + Given a linear model it returns the hessian wrt. its parameters. + More precisely, given a couple of matrices $A(\theta)$ and $b(\theta')$, with + $\theta$, $\theta'$ representing their generic entry, it calculates the + second derivative wrt. $\theta$ and $\theta'$ of the linear model with the + following quadratic loss: $L(x,y) = (Ax +b - y)^2$. + :param linear_model: A tuple of arrays representing the linear model. + :param x: array, input to the linear model + :param y: array, output of the linear model :param lam: hessian regularization parameter - :returns: A np.ndarray of shape [((N+1)*M)x((N+1)*M)], representing the Hessian. It gets averaged over all samples. + :returns: An matrix where each entry i,j holds $\partial_{\theta_i} \ \partial_{\theta_j} L(x, y)$ """ A, b = linear_model n, m = tuple(A.shape) @@ -92,13 +103,21 @@ def linear_hessian_analytical( def linear_mixed_second_derivative_analytical( - linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", y: "NDArray" -) -> "NDArray": + linear_model: Tuple[NDArray[np.float_], NDArray[np.float_]], + x: NDArray[np.float_], + y: NDArray[np.float_], +) -> NDArray[np.float_]: """ - :param linear_model: A tuple of np.ndarray of shape [NxM] and [N] representing A and b respectively. - :param x: A np.ndarray of shape [BxM]. - :param y: A np.nparray of shape [BxN]. - :returns: A np.ndarray of shape [Bx((N+1)*M)xM], representing the derivative. + Given a linear model it returns a second order partial derivative wrt its + parameters . + More precisely, given a couple of matrices $A(\theta)$ and $b(\theta')$, with + $\theta$, $\theta'$ representing their generic entry, it calculates the + second derivative wrt. $\theta$ and $\theta'$ of the linear model with the + following quadratic loss: $L(x,y) = (Ax +b - y)^2$. + :param linear_model: A tuple of arrays representing the linear model. + :param x: array, input to the linear model + :param y: array, output of the linear model + :returns: An matrix where each entry i,j holds $\partial_{\theta_i} \ \partial_{x_j} L(x, y)$ """ A, b = linear_model @@ -117,13 +136,20 @@ def linear_mixed_second_derivative_analytical( def linear_analytical_influence_factors( - linear_model: Tuple["NDArray", "NDArray"], - x: "NDArray", - y: "NDArray", - x_test: "NDArray", - y_test: "NDArray", + linear_model: Tuple[NDArray[np.float_], NDArray[np.float_]], + x: NDArray[np.float_], + y: NDArray[np.float_], + x_test: NDArray[np.float_], + y_test: NDArray[np.float_], hessian_regularization: float = 0, -) -> "NDArray": +) -> NDArray[np.float_]: + """ + Given a linear model it calculates its influence factors. + :param linear_model: A tuple of arrays representing the linear model. + :param x: array, input to the linear model + :param y: array, output of the linear model + :returns: An array with analytical influence factors. + """ test_grads_analytical = linear_derivative_analytical( linear_model, x_test, @@ -138,11 +164,11 @@ def linear_analytical_influence_factors( def analytical_linear_influences( - linear_model: Tuple["NDArray", "NDArray"], - x: "NDArray", - y: "NDArray", - x_test: "NDArray", - y_test: "NDArray", + linear_model: Tuple[NDArray[np.float_], NDArray[np.float_]], + x: NDArray[np.float_], + y: NDArray[np.float_], + x_test: NDArray[np.float_], + y_test: NDArray[np.float_], influence_type: InfluenceType = InfluenceType.Up, hessian_regularization: float = 0, ): @@ -176,7 +202,7 @@ def analytical_linear_influences( x, y, ) - result: "NDArray" = np.einsum( + result: NDArray = np.einsum( "ia,ja->ij", s_test_analytical, train_grads_analytical ) elif influence_type == InfluenceType.Perturbation: @@ -185,20 +211,20 @@ def analytical_linear_influences( x, y, ) - result: "NDArray" = np.einsum( + result: NDArray = np.einsum( "ia,jab->ijb", s_test_analytical, train_second_deriv_analytical ) return result def add_noise_to_linear_model( - linear_model: Tuple["NDArray[np.float_]", "NDArray[np.float_]"], + linear_model: Tuple[NDArray[np.float_], NDArray[np.float_]], train_set_size: int, test_set_size: int, noise: float = 0.01, ) -> Tuple[ - Tuple["NDArray[np.float_]", "NDArray[np.float_]"], - Tuple["NDArray[np.float_]", "NDArray[np.float_]"], + Tuple[NDArray[np.float_], NDArray[np.float_]], + Tuple[NDArray[np.float_], NDArray[np.float_]], ]: A, b = linear_model o_d, i_d = tuple(A.shape) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 7b7dce904..9eabee16c 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -1,6 +1,5 @@ import itertools -import sys -from typing import Dict, List, Tuple +from typing import List, Tuple import numpy as np import pytest @@ -13,12 +12,11 @@ linear_model, ) -try: - import torch - import torch.nn.functional as F - from torch import nn -except ImportError: - pass +torch = pytest.importorskip("torch") + +import torch +import torch.nn.functional as F +from torch import nn class InfluenceTestSettings: @@ -115,71 +113,68 @@ def test_influence_linear_model( assert np.allclose(cg_influences, analytical_influences, rtol=1e-1) -if "torch" in sys.modules: - conv3d_nn = nn.Sequential( - nn.Conv3d(in_channels=5, out_channels=3, kernel_size=2), - nn.Flatten(), - nn.Linear(24, 3), - ) - conv2d_nn = nn.Sequential( - nn.Conv2d(in_channels=5, out_channels=3, kernel_size=3), - nn.Flatten(), - nn.Linear(27, 3), - ) - conv1d_nn = nn.Sequential( - nn.Conv1d(in_channels=5, out_channels=3, kernel_size=2), - nn.Flatten(), - nn.Linear(6, 3), - ) - simple_nn_regr = nn.Sequential(nn.Linear(10, 10), nn.Linear(10, 3), nn.Linear(3, 1)) - - test_cases = { - "conv3d_nn_up": [ - conv3d_nn, - 10, - (5, 3, 3, 3), - 3, - nn.MSELoss(), - InfluenceType.Up, - ], - "conv3d_nn_pert": [ - conv3d_nn, - 10, - (5, 3, 3, 3), - 3, - nn.SmoothL1Loss(), - InfluenceType.Perturbation, - ], - "conv_2d_nn_up": [conv2d_nn, 10, (5, 5, 5), 3, nn.MSELoss(), InfluenceType.Up], - "conv_2d_nn_pert": [ - conv2d_nn, - 10, - (5, 5, 5), - 3, - nn.MSELoss(), - InfluenceType.Perturbation, - ], - "conv_1d_nn_up": [conv1d_nn, 10, (5, 3), 3, nn.MSELoss(), InfluenceType.Up], - "conv_1d_pert": [ - conv1d_nn, - 10, - (5, 3), - 3, - nn.SmoothL1Loss(), - InfluenceType.Perturbation, - ], - "simple_nn_up": [simple_nn_regr, 10, (10,), 1, nn.MSELoss(), InfluenceType.Up], - "simple_nn_pert": [ - simple_nn_regr, - 10, - (10,), - 1, - nn.MSELoss(), - InfluenceType.Perturbation, - ], - } -else: - test_cases = {} +conv3d_nn = nn.Sequential( + nn.Conv3d(in_channels=5, out_channels=3, kernel_size=2), + nn.Flatten(), + nn.Linear(24, 3), +) +conv2d_nn = nn.Sequential( + nn.Conv2d(in_channels=5, out_channels=3, kernel_size=3), + nn.Flatten(), + nn.Linear(27, 3), +) +conv1d_nn = nn.Sequential( + nn.Conv1d(in_channels=5, out_channels=3, kernel_size=2), + nn.Flatten(), + nn.Linear(6, 3), +) +simple_nn_regr = nn.Sequential(nn.Linear(10, 10), nn.Linear(10, 3), nn.Linear(3, 1)) + +test_cases = { + "conv3d_nn_up": [ + conv3d_nn, + 10, + (5, 3, 3, 3), + 3, + nn.MSELoss(), + InfluenceType.Up, + ], + "conv3d_nn_pert": [ + conv3d_nn, + 10, + (5, 3, 3, 3), + 3, + nn.SmoothL1Loss(), + InfluenceType.Perturbation, + ], + "conv_2d_nn_up": [conv2d_nn, 10, (5, 5, 5), 3, nn.MSELoss(), InfluenceType.Up], + "conv_2d_nn_pert": [ + conv2d_nn, + 10, + (5, 5, 5), + 3, + nn.MSELoss(), + InfluenceType.Perturbation, + ], + "conv_1d_nn_up": [conv1d_nn, 10, (5, 3), 3, nn.MSELoss(), InfluenceType.Up], + "conv_1d_pert": [ + conv1d_nn, + 10, + (5, 3), + 3, + nn.SmoothL1Loss(), + InfluenceType.Perturbation, + ], + "simple_nn_up": [simple_nn_regr, 10, (10,), 1, nn.MSELoss(), InfluenceType.Up], + "simple_nn_pert": [ + simple_nn_regr, + 10, + (10,), + 1, + nn.MSELoss(), + InfluenceType.Perturbation, + ], +} @pytest.mark.torch diff --git a/tests/influence/test_torch_differentiable.py b/tests/influence/test_torch_differentiable.py index 2e05669be..612bdd993 100644 --- a/tests/influence/test_torch_differentiable.py +++ b/tests/influence/test_torch_differentiable.py @@ -17,14 +17,12 @@ linear_model, ) -try: - import torch - import torch.nn.functional as F - from torch import nn - - from pydvl.influence.frameworks import TorchTwiceDifferentiable -except ImportError: - pass +torch = pytest.importorskip("torch") +import torch +import torch.nn.functional as F +from torch import nn + +from pydvl.influence.frameworks import TorchTwiceDifferentiable class ModelTestSettings: diff --git a/tests/utils/test_caching.py b/tests/utils/test_caching.py index b4f350fbf..17230ca83 100644 --- a/tests/utils/test_caching.py +++ b/tests/utils/test_caching.py @@ -3,6 +3,7 @@ import numpy as np import pytest +from numpy.typing import NDArray from pydvl.utils import MapReduceJob, memcached @@ -22,7 +23,7 @@ def test_memcached_single_job(memcached_client): # TODO: maybe this should be a fixture too... @memcached(client_config=config, time_threshold=0) # Always cache results - def foo(indices: "NDArray[int]") -> float: + def foo(indices: NDArray[np.int_]) -> float: return float(np.sum(indices)) n = 1000 @@ -43,7 +44,7 @@ def test_memcached_parallel_jobs(memcached_client, parallel_config): # Note that we typically do NOT want to ignore run_id ignore_args=["job_id", "run_id"], ) - def foo(indices: "NDArray[int]", *args, **kwargs) -> float: + def foo(indices: NDArray[np.int_], *args, **kwargs) -> float: # logger.info(f"run_id: {run_id}, running...") return float(np.sum(indices)) @@ -79,7 +80,7 @@ def test_memcached_repeated_training(memcached_client): # Note that we typically do NOT want to ignore run_id ignore_args=["job_id", "run_id"], ) - def foo(indices: "NDArray[int]") -> float: + def foo(indices: NDArray[np.int_]) -> float: # from pydvl.utils.logging import logger # logger.info(f"run_id: {run_id}, running...") return float(np.sum(indices)) + np.random.normal(scale=10) @@ -104,13 +105,13 @@ def test_memcached_faster_with_repeated_training(memcached_client): # Note that we typically do NOT want to ignore run_id ignore_args=["job_id", "run_id"], ) - def foo_cache(indices: "NDArray[int]") -> float: + def foo_cache(indices: NDArray[np.int_]) -> float: # from pydvl.utils.logging import logger # logger.info(f"run_id: {run_id}, running...") sleep(0.01) return float(np.sum(indices)) + np.random.normal(scale=1) - def foo_no_cache(indices: "NDArray[int]") -> float: + def foo_no_cache(indices: NDArray[np.int_]) -> float: # from pydvl.utils.logging import logger # logger.info(f"run_id: {run_id}, running...") sleep(0.01) @@ -155,12 +156,12 @@ def test_memcached_parallel_repeated_training( # Note that we typically do NOT want to ignore run_id ignore_args=["job_id", "run_id"], ) - def map_func(indices: "NDArray[np.int_]") -> float: + def map_func(indices: NDArray[np.int_]) -> float: # from pydvl.utils.logging import logger # logger.info(f"run_id: {run_id}, running...") return np.sum(indices).item() + np.random.normal(scale=5) - def reduce_func(chunks: "NDArray[np.float_]") -> float: + def reduce_func(chunks: NDArray[np.float_]) -> float: return np.sum(chunks).item() map_reduce_job = MapReduceJob( From 6e4ae087187d1427ea9b497426fdfa41d7dc43d2 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 28 Feb 2023 16:13:35 +0100 Subject: [PATCH 017/436] addressing some PR comments --- notebooks/influence_imagenet.ipynb | 65 ++++++++++--------- notebooks/influence_synthetic.ipynb | 38 +++++------ notebooks/influence_wine.ipynb | 37 +++++------ notebooks/shapley_knn_flowers.ipynb | 22 +++---- .../common.py} | 2 +- .../torch.py} | 8 +-- notebooks/support/types.py | 3 + src/pydvl/influence/__init__.py | 3 +- src/pydvl/influence/frameworks/__init__.py | 39 ++++++++++- .../base_twice_differentiable.py} | 27 ++++---- .../frameworks/torch_differentiable.py | 45 +++++-------- src/pydvl/influence/general.py | 37 +++-------- src/pydvl/influence/inversion_methods.py | 27 ++++---- tests/influence/test_influences.py | 12 ++-- tests/influence/test_torch_differentiable.py | 2 +- 15 files changed, 183 insertions(+), 184 deletions(-) rename notebooks/{notebook_support.py => support/common.py} (99%) rename notebooks/{notebook_support_torch.py => support/torch.py} (97%) create mode 100644 notebooks/support/types.py rename src/pydvl/influence/{types.py => frameworks/base_twice_differentiable.py} (57%) diff --git a/notebooks/influence_imagenet.ipynb b/notebooks/influence_imagenet.ipynb index 63e44d7d3..2f32fc835 100644 --- a/notebooks/influence_imagenet.ipynb +++ b/notebooks/influence_imagenet.ipynb @@ -61,7 +61,8 @@ "import numpy as np\n", "import os\n", "from torch import nn\n", - "from notebook_support import (\n", + "\n", + "from support.common import (\n", " plot_sample_images,\n", " plot_lowest_highest_influence_images,\n", " plot_losses,\n", @@ -70,7 +71,7 @@ " plot_corrupted_influences_distribution,\n", " compute_mean_corrupted_influences,\n", ")\n", - "from notebook_support_torch import (\n", + "from support.torch import (\n", " TrainingManager,\n", " new_resnet_model,\n", " process_imgnet_io,\n", @@ -93,7 +94,7 @@ "metadata": {}, "outputs": [], "source": [ - "from pydvl.influence.general import compute_influences\n", + "from pydvl.influence.general import compute_influences, TwiceDifferentiable\n", "from pydvl.reporting.plots import plot_influence_distribution_by_label\n", "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, f1_score" ] @@ -224,7 +225,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "842cf8d419684bfd925ec9598846fd96", + "model_id": "2abf9960efa04a92a0036a80d3ce93f5", "version_major": 2, "version_minor": 0 }, @@ -259,7 +260,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -339,7 +340,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5ee7e435828248fd88ce0bcdc574ca1c", + "model_id": "9566b9d6e81c43d3b79d68baefd5e9d0", "version_major": 2, "version_minor": 0 }, @@ -353,7 +354,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5fa2291b2b2d4501b6674d208534cff9", + "model_id": "afb3f25bbe9148259b435432b2077c33", "version_major": 2, "version_minor": 0 }, @@ -367,7 +368,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4c6a042331654c09b2c7a22abf174bc3", + "model_id": "fc101405997f43e3817bdc0218d18932", "version_major": 2, "version_minor": 0 }, @@ -380,9 +381,9 @@ } ], "source": [ + "differentiable_model = TwiceDifferentiable(mgr.model, mgr.loss)\n", "influences = compute_influences(\n", - " model=mgr.model,\n", - " loss=mgr.loss,\n", + " differentiable_model=differentiable_model,\n", " x=train_x,\n", " y=train_y,\n", " x_test=test_x,\n", @@ -457,7 +458,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -491,7 +492,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -554,7 +555,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -585,7 +586,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZYAAAG9CAYAAAA2k1BjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9eaBt2VXXi3/GnHOttbvT3rbaVKVSSUhHSEiABELoBAQVBJ4NjfCwwYZOfb73FBT1qaCi8N77qTQKSiOiqOCj05AgoU0IBBLSQCWpVHvr9uec3axuzvn7Y8y19z7nnttVbqrOrexvZeeevdZc7Z5zjjnG+I4xJMbICiussMIKK9wqmGf7BlZYYYUVVnhuYSVYVlhhhRVWuKVYCZYVVlhhhRVuKVaCZYUVVlhhhVuKlWBZYYUVVljhlmIlWFZYYYUVVrilWAmWIwgRuVtELojI3en7fSISReRTb/I8LxeRt4lIKSIPX6Pd94jId36Et/0RQUS+WkTa67R5WES+5TptflBE3nST1/42EXnoZo75aENEjIj8toh86Q20jSLyFTd5/uu+y6sctyYiZ0Tk42+g7S+KyPc/jWt8vYg8JiIh/TbX7RsrHC3cloLl6UwezyaSoIgi8sYbPOQfAT8cY3zsI7z0PwZ2gRcDrxGRrxCRwwKX/h7wdSLy/I/wekcB3wh82bN9E4dBRB4SkW+7weZfAwjwEzfQ9g7gPz3d+7oaRORNIvKDy9tijHvAPwNuZCHyx4G/epPXvBP4LnQM3AX805s5foWjgdtSsDyXISJ3AH8C+J5bcLoHgf8ZY3w4xnjuao1ijI8DvwD8pVtwzWcVMcadGOOlZ/s+bgG+GfjeeI0IZhHJAWKMZ2KM5TN2Z/CDwKeLyMuu1SjGeDHGuHuT534+Oi/9VIzxyRjj+Gne4wrPIp6TgkVEXiQiPy0i4/T5byLygqX9j4rIn1v6/m+TRrHc5jER+QtL3/+kiLyzMyuJyD8TkeHS/k8VkV8Rkb30+R0R+dy0+9H071vSdR6+xu3/CeDhGON7rvOMp5Lmdi5d71dE5A1p331JM3kA+Hvpmr8I/FDaH9PnB5dO+V+AL7/ONe8Xkf8sIk+IyFRE3iUiX3mgzS+KyPeLyLcmk8lFEfl3IjJaamNE5O+LyNn0+/wHYOta115CLiLfnc77lIj8cxFxS+fep82ma/3D9J7GIvJjIvJNh5lWROSPicj7RGSSnuPBA/tfLSL/PZ3nXHoXz1vaf7eI/ISInE/95IMi8r917wX9Pf7O0vu/7yrv+ZXAS4H/emB7FJFvEJEfFZEd9v+eX7HU7v50n2Xq639ZDjdLXfVdpr7xWcCfWbrfNwLEGM8Cvwpc0/x28JrX6xui2txbU/NHrvaO5BDTmBxiFRCRF6Tf47KIXErv5OUHzyMirxeR30p9+h0i8poD535ARP5Tut+piPyuiHzh0v6n3S+eq3jOCRYR6QP/HegBn54+I+DnJK3wgLcAn7l02GcA57ptIvIiVA1/c/r+1cC/RNX/lwBfBXw28K/Sfgf8FPAbwKvS59uAaTr/q9K/X4KaLfZ13AP4dOBtN/CMbwHWgM8HPgH4GeB/iMjHoYLsDuAx4DvS338U+CvpFHekzzcunfY3gNPp+KthhL6TzwdeDnwv8AMi8hkH2n0psA28EfiTwBcC//vS/q9HTST/G/pu3gH8nWs984FjnwQ+Kf39V4A/c4323wR8Q7reJ6Dv9m8f0u4O4C+iwvV16Lv9N91OEXkJ8D+BXwM+Ee0rHn3nvdTsXwAbaN94MfC16G8AahZ6GO1D3fvvFhwH8enA4zHGJw7Z93fQSf1VwBU+EhERdJGwAbwB+CPAF6RnP4hrvctvRCf5H1+6319dOvY30HFzs7hW3/in6BgBfb5rvaNrQkROAb8MnAU+Dfhk4P3AL4rIiaWmBjW7fWO65lngx5cE7Gn0uTfRMfRy4FuBkPZ/pP3iuYkY4233QVXxN11l39eiE/rxpW2ngBnwVen7VwNPpb8fTO2/FfixtO0vAo8sHf8w8HUHrvMGIKIr7a309xuvck93X2v/gbbvBL7jwLb70vGfunT/jwHuQLs3A9914L6/Zen7V+hPfuh119M1vuAmf4ufBL5v6fsvAr9zoM2/BH5t6ftjwD840OY/Ae11rvUwaiJZ3vazwL+/Wt8AHgf+/oFjfmz5WugioAVOLG37E+jk0Vs6748dOE+R+s4Xpe+/A3zbNe7/oWvtX2r3XcBvHLI9Av/6Ktu/Iv39Oen7C5b2b6f7/P6bfJdvAn7wKvf4DcC56zzHLx645o30jTem+797adtXH/i99n1P2/aNsfSb/vqBNgJ8APimpfNE4FVLbT4pbXtR+v73gTPA8CrP+BH3i+fi5zmnsaAmhPfEGM93G2KMT6GrlZemTW8BToraiD8TXdn8HIsV2GemNqTVzfOAfyYL09oYHYSgA/gS8P3Az4vIz4rI/5G0nqeDPnA9e/lrgNPA5QP39GmooHw66K7Zv1oDERmIyLeLyO8ls8AY+MPo+1nG7xz4/gQq3BGRdVQb/NUDbX75Bu/znVc79yH3uwHcCfz6gV2/dkjzJ+J+P9QT6ER0Mn1/DfDFB973BVQz7t75dwF/U0R+Q0S+Q5Jp8mngWn3gmtosqlGfjzHOWW4xxoto/z+Idx74ftV3eQhKrtFXroGr9o1bjNcArz7we+2hi7TlMRIP3FOnJXb39GrgV2OMk2tc55nqF7cN3PWbPPcQY/ywiHwQtSG/Dl3p/xZQJBvsG4G/npp3wvcbScLmAB5L5/xzIvLdwB9CV41/X0T+SozxZp3w59AV5rVggPcCX3zIvukh224E3TWv6uQH/gnwx1Cz0vuBCWra2TjQrj7wPXLrzK5P59w3ksL7sPOydG6D+jS+/ZBjLwDEGH9ARH4O+Dx0kfKzIvJfYow3RQVGf4PXXWXf1Sa4ZdxoyvKP5Hfa5tp95aNxzQ7hkG3Zge8GJaT8lUPa7iyfK8boD9xPd/yN4JnsF7cNnosay+8BLxGR492GZG99EfDupXZvQQXLG4FfSJ3rf6I2+eMk/0rSdh5FVeOHDvnMV5YxxnfHGP9ZjPHzgX8N/Pm0qxtM9gbu/7dYaFZXw2+i7JndQ+7nMLt8hxpARA67j5ejtuHfvsbxbwB+JMb44zHG3wE+CLzwOve6D1FZQo9z5cT5+ps5zw1eawddgX7KgV2f/DRO95vAK4APHPLO5yy0qEymH4gxfhVqlv3ypKWBvv8b7QMvEJGDk+WN4D3ACRF5oNsgIlvc5O+UcK37fTn6Tp4NnAVsGtcdXnWgzW+i4+ixQ36vmxGI7wBeJ0tEnUOu85H2i+ccbmfBMhKRVx74vBj4UXQl9R9E5FUi8mrUpv448B+Wju+c0AU6kLttXwU8FGNcdhr+LeAbRORvicjLRFlnXyQi3wNz9sl3iDLDnicin4KapTpm13lgDPwhETmdBvrV8DPAa5OD/mr4EeBDwE+LyB8SZYF9koj8nyLyRdc47kPp3z8qIidkiamFCthfjtemh74f+GMi8trktPxe1NR0s/hO4BtF5CtF5EER+WuoY/Ojge8EvklEvjxd65tQrfJmCxH9Q+DjgB9Oz3+/iHyGKKvq+QAi8v+KyB8WZRG9FHXYP4qaYEDf/+tF5F4ROS4iVxt/nWb8dATgm1DTzg+JyGtEAxl/CPUh3ewzfwg1Jz2Q7jeDOUHgDcBPP437uxV4G/pOvz39pp/HlYSM/xcVij8pIp+Wxsinisg/EJGraYOH4V+g8+RPirLH7heRLxSRz0/7b0W/eM7hdhYsn4Surpc//zXGOEMnjgr4JVQLmQCfF2NcVsPfgpoC/+eSKvzmtO3NyxeKMf4Q8L+gDJa3AW9HnYOPpyYT1J76Y8Dvo0Ftv0pSw2OMAfjL6RyPcW2t4L8DT3G4mau7nxJlDv0m8APpmv8ZeC3w4Wsc93bgu9EYmbPo4Osmij/N9WNnvjmd/y2omeFxnl5g3ncD/zfwz1E7/6egQZofDXwX+pzfjb73T0aFzU3FfcQY34tqWSPg59FFw/ehfobLqZmk670b7XtD4PNjjN2E/ndQdtH70cXPvVe51iW0L33lYfuvc58R7TsTlNX1/6H+wPdzk8+MvqfzqKA6x0KrfCP6Hn78Zu/vViD5jP4U+lv+Lkq8+RsH2jyF9qvz6Nh4P7ogex7KhLvRaz0JfCoqBH4GtYj8A/S3vlX94jkHeQ4/220L0diQbwZe/Ux0PhH5X9DB+coD9ubnJETk3wAfH2N89bN9L1eDaEzV24GXXse8eSPnWkMXNN8SY/x/bsG9/Qy6IPuOj/RcKzw38THpvL8N8MMo6+tOFlrRRxMF8DXPRaEimiLki1Ety6NxHV/F4U7dI4MY40OiAbr3s2Aq3RBE5I+ipq/3oqy2v4OawT5iDSMJqV9Dtc0VVjgUK41lhec0koP3P6AO1h4aS/L/xBi/71m9sY8iRORPoj6H+1CT2DuAvx5jfPe1jlthhVuFlWBZYYUVVljhluJ2dt6vsMIKK6xwBLESLCussMIKK9xSrATLCiussMIKtxQrwbLCCiussMItxUqwrLDCCiuscEuxEiwrrLDCCivcUqwEyworrLDCCrcUK8GywgorrLDCLcVKsKywwgorrHBLsRIsK6ywwgor3FKsBMsKK6ywwgq3FCvBssIKK6ywwi3FSrCssMIKK6xwS7ESLCussMIKK9xSrATLCiussMIKtxQrwbLCCiussMItxUqwrLDCCiuscEuxEiwrrLDCCivcUqwEyworrLDCCrcU1xUsIvKDIvKmZ+JmrnL9h0XkW57Gcf9IRJ4SkSgiXy0i3yYiD3007nGFFZ4uVuNrheckYozX/AAbwNb12n20PsAJYHiTx3wSEIE/BpwG+sC3AQ89W8/xbH+AlwM/BVwGpsDvAq+9Rvse8APAbwP19d4dukj5hfTev+Ia7X4wtfmWA9v/fDr+Qtr/qYccOwD+OfAIMAM+APxdwB64j78NPJTaPAL83zfbh57B32U1vm6TTxpDPwQ8DJTAh4DvAjZv4NgB8O3p2Bp4HPjbB9pY4P8A3g9UwFngXy7t/7b03g/7vOZm7xF4A/BmYJw+bwfuP9DmbwAfTvfz28AfupF35bgOYow712vz0USM8dzTOOxBIMQYf7LbICK37qZuM4jIxwNvBf4NOhFfRN/RpWscZtEB8L3ApwCvu85l/jYwuc59fDXa8Z84ZPcA7eQ/Cnz/VU7xT9DJ7H8Ffh/4RFT4lcA/Sm3+GvDXga8B3gG8KLUpgL9wnWd4xrEaX7cVXoVOwH8W+CDwAuD/h/axz7/aQSJigZ8G1tE++H7gGHD8QNMfRMfa3wDeCawB9y3t/6fAvzpwzP8DvBL4zZu5RxH5POAngO8AvgldbH5c+rdr803ofPEXUKHzNcB/E5HXxBh/92rPC9yQxvKDwJsOfge+HngsPcT3Axnwdah0u4ROSPnScf20bSft/xfoZHC9lfDDLK1u0/e/B3w3OkE+ha5i3dL97ZPmS9L+oaXzfNvBawOfmo65b2nbq4H/np7zHPCfgecdPA864b0PnVx/EXjwwLlfDfwcsJvO9Tbgk5b2fw7wK+gq+3F0Mjx2i1Za/xP49x/B8Ve8qwP7PxPVDI5xFY0FeAlwBp2U9v2mB9rdx9U1lncC33lg208A/2Xp+38FfuJAm+8EfvtWvMtb/VmNr9t7fAF/HAjA+jXafE26r5PXaPMZQAu89CauvZHex/92M/eIavUfBP7RNY6R9J7+4YHtbwd+8Hr39nSd969FV4ufA/wp4CtQM8vrgM9L378S+NqlY74jdY6vBD4ZHQB/6Wle/+uBJ1GV/OuBvwL8mbTvG1EJ7IE70udpQURegk7Kv4Y+72em8/4PEektNb0D+IvAl6PvYA3VDrrzvBT4JXTAfybwCehgNWn/ZwI/CfwY8Argi9AJ9j9LWgqKyBuTPfuNN/kMx1GV990i8jMick5E3iEif/5mznON858C/h3wVTHGC1dpMwB+HB0Af/ARXO6Xgc8XkfvTeV+JTlY/faDN60XkFanN84E/fKDNUcdqfN0m4wvYRDX79hptvgQVdN8oIo+KyAdF5PtE5NiBNh8EPltEHkrtflxE7r3Geb8KcKiwv5l7fBVwP/CYiPySiJwVkV8XkS9eOuY+4E5UWC/j59Axd208zRXVWfavln4aOA8US9t+EvhP6e8haqP72gPn/nWe3orqpw60+VmWVuTAVwPtgTbfxk2uqNKz/tiBNgWqLn7R0nla4MRSmz+BrhB66fsPAb8DmKs84y8C335g273pXl6Zvr8WXbFd1S9ylXN39vAp8L+javNfQs1Hf+4Gz3HFu1pa+bwJ+HtL267QWNDV4b+72m96oO19XF1jyYD/N+1v0jv+1kNWWt+SfpMmtf1eQG7mvT1TH1bj67YdX6h/6VHgn16n3XvR8fbfUaH/WaiP861dv0zvuETNt5+BCtC3oNpa7yrnfTfXsUQcdo/p/UVUEP95dE74lvROPye1eV1q88ID5/vLwOR67+a6Ppar4L0xxnrp+xng/THG6sC2j0t/vwDI0Y6+jF8D/sjTuP47D3x/ApXAtxqvAV4gIuMD23uoSWd+/bjfVv0EOsGdRE1ErwZ+LsYYrnGdTxaRv3LIvgeBd8YY3wa8+Fo3KyI/C3xa9z3GOGLB/PvpGON3pL/fmVaLXw9837XOeR38TXQi+LvXuKcvB16PrpI+Uvwl1E78JcAfoO/1n4vIUzHG701tvjS1+xq0n7wIXb3+X8DfugX38ExgNb6O4PhahoicRAXF7wL/53Wam3S/fzLGeDEd/7+iZqVPAH4rtSlQzf/3Ups/gWqOfxg1ES5f//XAS1Ft8mbvsZsTvn9p3LxTRD4ZnRP+x3We57p4uoKlOfA9XmXbQVNbfJrXO4j6wPfDrnU9BPTHXkZ24LtBV0Pffsjxy2afw+6nO/5GYFBTxg8dsu/MDZ4D1GHXP7DtyfTv7x3Y/nuo2eQjwWejK5vqgPP234rIt8QYX4yac14AXF5qY4G/m9osmzyuimQa+cfowOsG2btE5B6UONANkO8EvjvG+ENLbfrAvxGRvx9jLJ/Wkz6zWI2vozm+ABCRu9HJ9yHgS2OMB3+bg3gS1TYvLm3rxuPzUMHyJPpc7+0axBjPisj51OYgvg54X4zxF5/GPV5rTvi8A21Oo0SZDqeW9l0VT1ew3CweQjvHpwDvWdr+yc/Q9Q/DWeCkiNgYo0/bDq6qfxO1yX4gJj3waeIdwGeJiLnKquo3UafdRxQHEGN8/JDNH0ZV4YOrsRehZo+PBF+DmmGW8S5UM/iJ9P1voWyWZfx82v89N3GtHJ2YDr4/z/4JbHiNNs9V6tJqfD0D4wtARB5Azb+/hWog1xMqoCavTxGRjbhgAb4o/fvwUps/A7wQNcmRfDDHOTBORWQb1cz/5tO8x99ESQzXmhMeRjXDz0X9Vx0+D/VjXhPPSOR9jHGCTiL/l4h8oYi8UET+AarK36pV1s3iLSjF9e+JyAMi8mWo/XAZ/xC9xx8WkdeKyP0i8hki8t3JKXyj+Meoyv0jIvKJ3fVE5FPS/r8N/DER+Wci8sq0//NE5F+n1Tbp+u8TkdfezEOmAfuPgC8Vkb+czv1VqG31u7p2KeDtF5aPFZGXJAf5aSBP9/ZKEcnTuT8UY3z38icd+lhMTvoY4+OHtGmAs53Kn651Ol3rJWnTC9K1Tqfz7KK/2T8Qkc8RkftE5EtQevGymeC/An9dRL44tflc1Az2szHG2c28u9sFq/H1zIyvZD5+K0oX/gbgWOq3p0UpxV27XxCRf7R06L9A/Ub/TkRelq7xfShx4Z2pzb9HY07+TXqGVwA/jC4afvbArXREin/7dO4xxjhGacp/WUT+tIi8QJRa/EdQNmA3b/wT4JtF5CtE5MUi8u3Ax6Om5WvimUzp8r8D/w2NU3gbsIU6754V00SM8f3An0NZN+9GYyP+5oE270VNPSN0lf0etEP00UDDG73Wu4A3osFoXWf6a+hKmhjjW1A2yyvQTvG76I+3x8IEMkBXFIObelA9/78Evhn4q+iz/g3gG2KMP7DU7A7ggQOH/gwaFPUXgHvS37+NskVuNb4unbtjb/1A+v51S23+JOqI/Tfoqu4foxPq31hq8w0oS+07U5vvQ5ksf4bnNlbj66M/vv4XdJx8LkoFf3Lpc89SuwdYYsvFGJ9M119H/Sr/Jd3jH+80tRjjFDUtn0f7+JtQ2vRnH2K+/fMoceMiV+JG7/Fvpnfwj1Hiw1cAXxxjfPPSfX8X6j/9h6nN5wF/NMb4O9d4R8CCkfCsQETeDFyKMX7Js3YTK6zwHMVqfK3wbOGZ8rEgIi9Hbay/htrLvxKl1V01YnWFFVa4MazG1wpHCc+YYEFtvX8RzdtkUDPFF8cYDwbgrLDCCjeP1fha4cjgWTWFrbDCCius8NzDqh7LCiussMIKtxTPpCnsI8UzoFrFA5c5+P06R8eID37+vQsIDEGp9c66+ba4dF55VsIrLM9wWMdzNYbktsVnvOqlMc9zNjY2uPOOOzh96hRlWRJCYNAbYq3FOUfbNLRNyyte8Qq2jx0DBOsy+oM+3nu891za2aGsNY4xL3psHdum6PXI85y2bYkxYqyOCRHBWou1FmOMfmw2HxsHgm1xRbHYJgYRs6/dcvv5iBXIsgwfPGU1wxlLZizGCBIjTVUSW09oWn7sR3+Un/iPP85XfsVX8NKXvISXvuSlRGB3b5fBYMhwMCLf2sRkGeXlHYgRrMFlBc7l7I3H1E1NXdeIMdjMEUMg+jBPcVJVFe95z3v4nu/5Ht7waZ/KG97waZw6dYqiKCjL2XyO4EBqlBBaQgjzz1JqFT7+dW84smPqdhIstwWWO7kg6P+EiAqd7u8OxpiPlZTjKxwxOOewVsMv9k32YnDOLSZ9Y3FO+6oRIaL/igjGmCQ0DM5ZYpS5wJB9bYJO6rL/s9yu+3T3k/7Yt/3g94NjR1gIlhgjRoQiz5EkcbqJWRDEGMRasiyjE7Cb29u4ogCg1/bJMhV45XQKxmAjTKYzHj/zBMeOnWB7+ziPPPII09mUe+65hyxzGOcI3hORuTDo9Xpsbm7ywAMPcOrUKUaj0dK7N5hkO4oxInPBEohx6R2nf+dC6AhjJViuQNdRn56CZOQQ66JADJGmaVj2aYkIRV6o8vCM4bkcgL7CzWA0GmHSjOaco0iaQYyRfq+PiE6MRgzEuBBEYrFJ8HQoigIxqgVneb5PI1HYfRrLQmh1Gou9QsDMBUjaBzoJq9YiVwiVg/Ax4pxlfX2NalZSzmZ47yEEnFHNx1jHcDhkc3OTFzz4IB/3kpdA0YMYGQwGBB/wrefck0/SNA133n0PT505w7//kR/lNa/9JF79ia/lZ3/2Z7h48SLf9M3fzHA4IhAJ3hNaPxcCo9GILMv4si/7Mk6eOM7JkyeoqgrvPVnmFprIXFMJxGgQWVg8ujadgDnKWAmWfThMqNzcJHwgE6ieQQzWGMSZK0xgMYL3YaW5rPCMI8/zfX2101piiLS+1VW9SNI0LGKECDhrtT/LQjspigLrHDEKLnP7tJZuZW7SAuqgNnNQgzm4DWPgEMHS3fOhELDW4r3n/Pnz5C6jyHOIgRgioVKTX922c6Fp8oJgLZee0LRdvTwny3KsdfzBH/wBOzu7HDtxisFwwItf/GI2NjYpy5IHX/ACyrrGGKNmPzVUYJzFN6qxlGWJiHD69GmKIqdualqvZi67JKBj0nA6oR7jQptZNoWtBMttjZuf6A/78Tt12pgrVZO21c5lzDPu81jhYxzOOUIIc026EwJBAm3bYsRgrUWS9oGoYLF2v4YBkOcFrjPdWLPPfwJJU1nIh0NNYAe1GBHRA9J1ATVfHfCxHAYxQp7nTGdTLl68yNbGJsN+H4tO3mVV4UOgqWtijGTOIVmGF8OFJ59ERNjY2mS0voHLCz74wQ/y5JNn+NRPewPDwZAXv/jFuKygqioefPBBXJbNBQsCttPu2lavV5YYYzh58iRVVVJWSXsizQ/pvmMSKB1iFGJcCJ5u31FfhK4Ey1VxUHuRA38ftk+w1iWBstjX9QHvOyecT2aFDGsd+5PH3sz1ns6+FVZYQERwTkkl3UQXQuDc2XNkWcaJEyfmAkcFgE7uZtnnYQy5NclxnoTEkvlqISSWJ8x4xb/LmtPyZ0GHQU1F7DcnH4bgA+O9MSLCPffci4RAU9U0MUCItN5jrWVrc4siz2mbhr1z5xifO8fW1hbWGPIiB+8pJxNe9pKXcv999zNcW6MsS7z3rK/32d46RtU2RFksIJvg5++sKAq890zHY0IIiAhVXVHXNaPRCOcc0fvF8+/zHy3e1e2gpSxjJVgOxc1MyAf3dR1DV28LRGJyHnrvMcaSFoGHnuPGr3cz+1aCZYUFdCJjbqpSzVnt9+PxmF5PKxrs92dIIqUsTFFiBJu0iJDUkisc7HJzq+wb8aF0z3B14aIiKRIwgI0wnUzwbUthDTbLyItCF3cRQtvSlhXj8Zg8yxkMh+yNJ+xNJmysr7Oxucl0OqWsKrIsm5uw6qbWpWEnQJeYocaof0qSn0otGvp8WZaRZRlNVS38KElDU1/X7TteV3Es14Uc+Pvg9/371GcSqeuWqqqYTku8V43EOYdzGc7lc7NY03iqqrnmOW/tvhVWUPgYEGPoDwfYzNGGgI+RxnvOPPUUFy9dwliLSaYw7b92UbYK5gJjsd/NtZsOkThvdzXfyGEr8msJl+sJHRFhfX2ds2fP8s/+yT/hN37117Bi+LVf+RV+7md+hnI2mxMDil6P9fV1Nk+dJvZ6fMvf+hb+5b/6V2TDIf/jzW/mr/3Vv8reeMyJEyf419/7vfz8z/4sL3rhi5hMp7z1rW/l537253jTm96E9x6XacmZuq6ZTCZqZgQ1q22sYzLHcDRke3ubXq+nJrhD/Ks3F+hw9LDSWK6Jpzchi3TMDTAmXqGVdCtDbStLzJmVAFjhmUM3kWv/k31mqbZtadt234R3cKK/gr0lSxFZB7ScZZNwd+zi3yvpxsuQdD6W/j14H1d7PiNCv9fDt57dnR2GwyGCkPd6iAizyYTx3h6XL1/m4Q9+gNl0qrTjjXViCPSKnK3NTXq9HkVRcPLkSbaPHSPLM3pFQb/fZ2t7G5eYXSGZwRZxKGH+jrv3a63FWUNIglwOe5eHvMej7ldZxkqw3GKIdMLC4Q55u95HqqpBxOCcOlBXWOHZwDymI01Yc5prYoUtB+0tO407xUJEMGIQc8DwkQSMGEksrkX77t+Df19VmxFRf85csKgQvBFTWTUrGQ4GvP5TXodB+MBDH+CVr/h4Njc2sHnGbDLh7KOP8fBDD/Ged72b//TDP8I9d9/NH/+iL+L06dO00ykveeGLGH5Zn9OnTjMcDPjTf+pPqbkKOHHiBP3+kP5oiMszQghUVYVd8lk1TYOIzM2KuqjMKIqCy5cv0zQNvaLYR93ufhNJzx7S4vN2cdzDSrDcYkS8D4jsXwXWdU1VVXz4w48wm03Z3d3jjjtOc8cddzAajcjz/Jm+zWceR38sfMyhC4JUp31ciikxbKxvMBwuFQedT/5mH7Or+4QuBmMuVIwKlk4z787BldrGQSGxvNrvzFVdW5Y0HLjGJBsj0Qd6RY/7HniAtqxpq4rpZErbNJw4eZLMOTa3tjh+/ASnT51iOBiQuUyvL+DyXNvlBe95z3vwwfOaT/pk6qbhgx9+mK3Nbba2jtEbDTHOUjcNxqrTP0Y1AdZVPferds8TUTNk1Jeht8vi732P0W0XFdTcJn6XlWC5xWhbjzGLaNkYoSwr9vb2eM973sPOzg6XLl3i4z7u48jzgqLoJTYJrGbfFZ5JHGSDdb4Ray0bGxv0+31t2E3iSVh0E/u+mJMYtR50x2xKY0CWTEDXEyoHhcu83SHHHWy/3FZPoLTiouixdeI45XhMuTfm3FNPsbvXsn1sm8w5Nra2OH7iBKfvuIO10RpFnuO9J4aIy3OOnTjB1vYx/sebf4Enn3ySl738FYynU9797nfz8pe9grvvvpd8OECspRnvYawly/P5c3VCZb9gifgQ5u+pu+kY45Vrvrk18SCh6GhjJVhuMfJ88UpDCHgfGAz65HnGq171KqbTKTs7O9x5553ceecdKUjt0MXKCit8VDEYDOZxLNYuIu+zLOPOu+4kc8pacs7NGUzOZcl3aDDOIimmxXdaBurbt9bOndJqwkmT5gHTWweR/T6JffEtSzTk69GN4/z/9B4++IGH+In//BO84fWv59Ne93qK++7TCbxtaWPE5QUvfPGL+YIv+AJCqwLgQx/6EE3b8pKXvZSI4EPgNa95DU8++ST//Lu/m63tbT79M97IqTtO4/IM37TEtqUoCiJQluVc6+rypEl6Z3meE6KfB0y6LNtHJ97/CYTQpXZZ0Y2PHJ7uD3JjdEfgQEfff1ycs2m6NA6j0Yjt7S0Gg36iIC+f6+A9HPYMsm/fjWJxirhv4bPPOXrFMVd/d92K7Gr7Vjja6GjGoGYWa60GQCKsjdYW2siSZmKMEAJptb3EZlr6Z+7IX/rMQ7uu0S0638Lyv2kHLG2Ha/evxSJfmM1mPPzBD/LKl72cLM/J0jM2411iCBAjm1ub3H///UzGY6aTKWfOnGFn5zI7ly+T9/q4PGcwGNDr9/nwI4/gY+TYsWNKBDCGEJVCbG0KOG39UlqWRIhI92SsJbRhnpoFgDktmgOCZfnI2wsfE4IF2BfNCgsB0K3YOprkcpDWjWJZOCz7Ma01WLvYsL6+Rowjtre3l1hhV87pC+fo/m0hdE69j0zDiRGi9/NJ40YO6AbJvojo+e602vRes7vaZzT52QpPE+PZFCOCzTOiQONbjf0QYX1zg4jSZsW3NJCYYh6xFsyVDDEjgnX5fHs35jQKX4iHZP42pot7OZDGZQkhBE2RsiToDtN65veRYkd823LffffxDd/wDdxx993Q69GMx8S2JcsLYvBUe3v0s1wzDd97L1VZ8uFHH+HsuXP86I/+KJ/0aZ/Gqz/ldfzMz/88H3joIf7Ul/9p7rzrTk7feSfWZbTBkxUFYowmmU0a3/J9xcT86saMcxbnzFyT86BaSes1zxjq44lCGp86wWgizXjocx81PKcFy7XUx33Mi8N45PuOvVJDONj+8IleuFKbMcupj9K15n8t/X3YCRdBlmns3BA75rC7WqhCgRAXqyXoVoW6Ol2OEd2X3l/Y/2zz57ty39WfZ4VnE90CQbMWLxYMIoJ1dql/7ddMFl1U5ppE6iCL/pi2L5zSh/hDOu3jGvd4RYiyXCnQYP947vq3NZZ+f8Add9zBoN+nriqkaweMx2M++Pt/wPr6Gusb6+ROzX4bGxvUTcOjjz3Gxvveh8kLxAgnT5/i3vvuY/v4MayzGGcxxqq/JIR972ZZ47pifCaT3lyTS9NEZ+LbN2elfQszIIef84jhOS1YgH088oPbgPkKY/k76OpsgQUbRuRGhcrNYVm4HOqUTNfuIndVe3madGUBsV0kcItv1RfkQwtEjDisNbjMpkDOLudThPmrW55M9KSanmZp3/xvuPb0scKzgY4VZq3FOrtI24KmZCFqmhIrRhNPpvxfhzKYDpEdMU203eobI/OOfsMLohtcmS+EysJUVhQFRZEzGvaZTqbsnj/PxvoaWZFDU/Pohx/hB37wB/m8L/jDfN4XfgGUJZlz3H///VR1zZvf8mbe9/u/j/2J/8yf+oov5+M+9w/x4k94JdYY6ukUm2W4vMfe7i5t29AfDq6qSe1/JDXBHfSpwEK43O54zguW5UDEDt1qohMey6ab5dTUaQssBXfpwmHhXFseTTr5pwl4H5Yn18ONzVeOMW23bMETQbUIhG6GX3TKg9fo/j7s+t376BIPKnvHxrQNm2IQuhVlXDhNZen8Mab0HvvV/k4L0sfUP4wrDj7gCs8yJKnO3U81Z7J2K+i5TVb3+Rg0HZFz+4L6FIu2C3+LHDJR7tN7b0i47GsR4z7t5PDGabu1RO9p2xabZQzW17l0+RJtXTMscqbTKSEEppMJl86dY5DnRIG1jXXuvuduXvepn8r6xgbrm1u89GUv48Spk4S2VTNgYrxhBJtZkDh/f/P32Y21A8/cWR2W0+Tve8RO8xGZaytdHrHFFY42nvOC5Vodt2mafVlWlx1ui9iSTngsCwUOCBad6NWBZ9Iia3lfhzj/V9vsFwKyZELSrKZdp1v4VYzpcgipAAth0Y0P3uN+wbJ/30IDEx0casVeuq/uGTo2j09HdhWJArHT/eeCxeh23y75nVaC5ahieXU97xnd5LhvFa0fHwJt8ORkB+zCzLuc7JcsB6bUbtfBRdV1hMuyP4+F2fWwYzszlyBgDCFokGLW69MrCh59+EOMdy5zfGuL6XRCjJEyCRZ7/DjOOUZra9xpDcWgz1333Mvd995LnvwoVdPgRTCZ+pkwMg+IBAgpfc2SO2T/o3fPcVBTOfCu4/wVLpEZWDKfHXE85wVL02gerkV21kWMScfjX9ZYun1tq2VWkTgfLJ2pWFialOcDqdNUOhUjJOEA8wk6mnS+uHScdkQjXZbj5V4TWCSz3L9Ca70GXrl5SdfDhcl8xRijnmcuBA77Vz9NVVM3DZPJmOl0xmw2Yzqd0Daa5sOHQNs0SqdOjlUErXMRI75tFr6gJBH/yBd96U38ais8E9hntukmttSnA1eSXdq2pWka8ry3z5eyLEBi2jQ3g+0/y7zXP20fwdKEfJivJX1RQdg2BO/VrBc8vq64447T7PZ7vOnnf57Lly9x/MQJTpw6yclTpzDW0DQNT5x5kqfOPMW7f+/dvOFzPofnv+xlhKaGGMiHQ6JACC1lVVJPpho5n7k5yeCKewMMS+/6ikc6xLey/M5kf9trsTGPCp7zgmUelHSI+nyY075zQGviyGVNwHQuhcW/hyJe8XdcmrSJkShxSQ4E3YyWMpWl4xM/JA0kST4WFVZNXeODp5HOF7Rfe0onT2cLV2gQEhdC7eBKqq5K6qpmd3eX8Xg8/9R1Tds2tK2nrut54NfyBBVCSCZG1cpWBcyOLg5OUAvT52Lps7y9q7s+d5BDJyX2dfuFD2Zp41I/W/aDLO+/HrpszAeX7Fczi4Xg1Vxrzfy4Xq9P1Ss5c/YpZpMJ/V6PXq9Hr9/T+ixti/eeWVVy4eJFZmWFWEts0kLJpkUlhhAb6qYmRM1W3ksljZfnm30PeOBdH2SOzU1nS0SJgy/nMMF1FPGcFyxFUVyVHXbQt6J5fHQCz7Ju30F/yJVaRWSJWrlUzKtb0C20mWWTWndO1ZDKapaIBI6OieNTvqa29cQQ8MFT1w11VTOZjinLkkcffSwFYXUCChYBVQuT3cHvzWyWOqiaxYzpam6YZG5bCInu000qHUW7qy9zmM23G+xuyUywwtFCR69v23buxO8mLZNyfBlHKvFg57mvOsHRaeyRA6Ypkf09onOqi8wV5oPtD2rky9g3dkMAcw3G1RKC1+zNRZeaJsJkMmY2m7G+vo5B84k1bUvrPdn6OqONDV7+8R/P1rFjXN7bZWNtyGx3R0kyRpjs7WIzx2A0IouQ+cgvvfWt7O7u8oVf8AUMBgMWjK9DhEtIC8ClIjM+pgXkvlfWMcYWdOP9+1Yay7OG5ZW0T4V9ur9jjHPBstzJ9/fTZRccWjaUODf5hODTKi7OhcB0Mku+l0hcGKy7O2IhmDq7mnaapvVpItZKkiKL6pLeBzQKN1DXNXXdMJtNqSpNFeP9QkPQT0iCQa8Vgl9oLGmfryv2+3e6ErSLgLa49Ix6DwuVXc95WAGi7h0u6nWvBMvRxfw3TN8Prv4PjqE5W3LZDDY3CS+gPX3x/922ZbPZjdCN08X36fGHOby78+3TwLoKlkmJ7xzg1jlOnTxF7hxnnjyDcQ6TZzz5xBPUTcOJ9XU2Nja48647WVtfx4ggTgktFhW0Mf2b5Tmj9TUVwiYZvK5iIemu3wnZg79Derp972Zh0l4ycq80lqOBbkLO8xxjDNPplLZtGQ6HSrXcV2a1EybdRLowI7VtQ0haQ9u2lOWMpmnTp6IsS37v995L09R0Ez0IMXbLk/2dpRt+xghF0Z9fvxNW3eS9OK4TYmF+jcFglJhiC8GymPRJAskvnPLpXjKXCjPNU0YEmiYkIbI/cnj505m+Ok2ku+flFeRyosIYu2uvcNQwD2wNgbi0ALhyRaztqqpaFK6i86fsN9tIEjZXTpDa6OlMhwfvhbl14drBvXlRaPsQiN4TWk/mHGtra7zqE1/N4489xvkLF8iGA7L1dd7yH/8jTz3xBH/2z/5Zjp08zqte/Wo2trYp+j2kyMEYXJrkQwyqueQFr/7ET6T1mtJl/qSHTPxzIb30rq4Va5daAfv9KiuN5YihG0QPP/wwly5dmm9fTr3QtjUxBqwziESQgNBlKvZpco2JbVLjvZqqfGjxbctkMtaJnJB6kKS/I52fBhbn1GsITaNah2oIqm10NcKtSUkqJQmLwFzTqaoyTeJLGgsdT36hXej967WJkTo5GjsSQme7VTdMd79KNBABkq9kNBzgsox+r6cFoIxJZjFPnWqnx6hR+D6ZzLpKfiscLXQ+k+UFRBcLEolzMRDSAqtpW1y73xQ2n0DjfgGi/1vSNA748q4nYhZU54XWH2NUGvyS3/Sw1Xt3rPceMapJ+NDQNo0W36pril6P7WPHePHHfRzldMrbfuVXOHf2LHt7e7ztbW9jc2uLk6dPKbXYWupaq0QWvT6gSSR98LQ+kmUZeZYd8JDOH/uKZ2Bukt7PCjsoLBYL3f104xjjPHX/UcXHjGBZdkA+/PDDPPLII3PNpaqq+Q9bVTNC8PT6hUbIm4CR5HuwMNc0omo1IUS0jLau5NdGa9rpO2d6VD1cu8chgsUApHOEQOub+TldZrHWkLmQssUyP2cqS0FdV2n4qiDrhEfnp99Hi+72xUhTVQiQOTu3ry+wECqdqaNrs7GxTlEUrK2tp9QUjtlsRtM08/fZNA113RCbmrapDwSbrnCU0C22wrLP4qAbEBUurW9p0m95cFq7sXnugDi5mk9l3np+kwu5lRY8Bydlc5gzPHoEg3GaSLKuaybjMU3TsLmxztb2Ng8++CAf+tAHee+738WlCxcoy5K3v/3t3HXP3Rw/dVJzNFlDXWrMS170lBUWA3XTUNUt66N1Mudo63rffUnyNckBgXE1qvHy04tIetYFzbgzCR5tXUXxMSFYjBGc07xdIoa9vV0uXjxPWdZptebJ84I8L2h9DV7NQSFGTIwEidpBEzNLqcGAoHWvReaW5KrsfBcLc1ecs7TUBitG98nyMi7KXBhoJtmc0WhInv72IShbq26UnVW1hBjU7KQn6Lok8663vFzsFoBRr1vkBUa6dDY6xueTzFJUZpdDrctym+fKohmORqnMssN78EGo6h3KsmI83pszyS5evEBVV7f091zh1sAYBwjGeKx1GKd13I2kFC+kHhx1crRRsAEcGveUqT5L6OxiRKKJy86AZDbr+ujVKqV2K3rmXXUerS/7J1IhYtKHCCbo3G8ieEkEfdGxYMRC8vNZ6yj6PS5dvsxkPGZjY41z587y//23n2LQ7zMaDvn0N346WZ7xG2/7DVwv5/Tz7sFmGU3w9AYDIlA1jd6UGIq8Ty831E1NXdVk1rFv/LHvsZb8WUu+yhj2N+zextIp5obwJFzMXOgcXdw2guV6r3HJRbb4a+mgRSCkOsWrulL1Nsb5pAroyseYhSObsJinQ1AVVMLC2Z2I+5IEg/d+rs3opG8IyYRmkm1LQpwLlYXpIeVoMpbMZRRZzqA/oMgLsiyj9a0yw9qg7YOSCIxND9/Rh5dXbctvLer3jpWjk4ckFlu3ClxE8y+/M2NMytCsgsQ6TZ9urEPE0rSeqqqZpJiX3d099sZjJuMxu3t7K8FyRJFlGW1rMKYlAK1XASNmUdReSCXuo2CjTuAmMv87dH7oNGEmXXk++UlnTk0SIpIWMXrIXGmR7m+RuVAJAlGWzD4RTNJWbIgYE9Qshp2niwmEdJzMta+QLmqsVa2rrolB/ZSXL1+i3+uxtrHOiZMnKHrqjB+MhvRGw2RF8GROqzw2VTMXlpl1WOuoqxrf+iRYlrBv+MUrTGHJbr1oG3V8RpG5ObojhYW4lMhy+cUdUdw2guXmsPi1gg8gEZec1TFGstxSFBl1VasPwxnqtqKqK7LMkuc5m5ubiER8W9O2IcVulImBFXDWkrlCNZvkYyFGsiwnBGiblqLXo8h77O7t0DYNg77SHmMI8wE46A+w1tK2niwr2NjYUEKBsWyvbdPr9+gVPTXXNZFMMnpZj6qsNL1GF9DpW0LStHzn9A9dh168GZ9MCa0POGfI+pnGpvgGZy1GoAkeLZ1siUTqpibLC8RYev0RWV7QBkM5LSnLknf97rs5d/4c5y6cpa5qZuUM5/R4mxcMe6uo+6OIU6fuoKxKzl+4wO5kSvXYY9z7vOcxKobU0xk2Qs9mmCjkUbAeshjIG0+WeazvHP5C4xuaEIihwVpLv9fTidBHbNKA2jZR840oq5KIxIiJQmE0L52xlmDBWyij1+iuPGnVIRJrT6wb+hgyDNY3uLwg29qgaUpmbY0d9BBrqGqPFaGfind57zl27Bij/oC2qjl9/CR/4Wv/HGvHthhub/DWt7yZSxcv8tlf8Lmsb25Sh4raB2rvGWQZDkdW9Ik+4huvJukIfdcjmE4TOZDEZmGT1jHpwzxdf4xR/w76b2harLNkzlDOaoIP9HoFPnrqsiLLHFnmbsDh/+zjthEshzrFbqjlEt0xaSbWmlS8yIFAljl1mMdIr1dQ5BkbG+sQozK/6obGqODwRtOVKLVQU4XH+cqftC1V54uqwRRZTuYcWcqxFLFze6k1Rj9FRpHn9Ive3B+UZxm9vKBXFAjQL3o6SJNxoTPXxRAwIrS0C65ZWr3Fzj6drpf+1DcTwLeepm6om4qQKTsuhIB1GtcSor4X0vYLFy6q834woqprqrJmd2/MeDylLGu8b7VqIEIIEZev0ugfVWQuU9JIBO8DVZ1Mw8uNYtImgprDJERM0H+D9wQxaqIR5qWI57TbGJWNRQuipmREMHHhxZOoBmIXwBCQ1ifTGwgBkUgMLZ1BzRiDzQTTJt+FiPo7qpI2MR5D6OqbaN8tyxIbw9wKYUTIsxyTC8MipzccUmQ5eE9oG4aDIb1eLzHluni3zlSt5qu29RgMFgMh3W9K1LrfY9LZ95Zy+y2RJjrihEBaUKZyz0lzgzSnpPmmizuKB8qAHDXcloLlZpTAKxmJyuLoAieNMUoTTJP52mhEr1dwx6nTtL7l8qXLlKWuzHu9XtJQ1L8RgwcxSFqdGxHqqkGM0O8VVFXFbDLm5MmTFEVBNSuXOip09F0Q1tc2KIqC4XCoaVO8Z9DrMRoM6Pf79PKc6D2zmZqbuuOn0+l8Neadmx+73GkP/qtCR4gxMJtVTKcTprMJReGwzuDyDGMNWZbNBYsRoa5r3vO+9yBi2draViNHjFy6vMOsLCEa8rzHYNinqmZUdTn30axw9GCNw4hVlmPrCWbBkDRGMFEpJiagwsRHxARsVHNuW9W00eCxiLM4K9p3SC7ntoW6wYeGiKHXG+giSkS1k7QIUwEUCG3AxwZrIFjIHbQGqlbHFNYxyPsM+wXNpITWYzMN3JxcOIcd9DD9HlXdEGkoioK2brh8eYfN4YCN4YDQtPimZWPrGI5IM97BNC1hZ48CYZDlODEYwAePzQoymyFpqmzbBt94qrIGFzFOCK0HIrnLUTlzJUstsqDxazxQk0oga2trDFmR63sX8FmGEaOLRoR+0SMEj29aZokkc5Rx2wiWp419tsjkVE8rhI4u2fkRxAh5rppDF0xpk9PfWUMMBpNsv0o39jhnEQxFkXJ2JfOnyyxCxBohcxZnDSHTmJmiKLBGGV+6ijLkRY5zGf1+D+9TJHBusC7SH+ZkjVBWGSHW+GBompYYPHlhCEGL0LWtppxo20AIQtsmYYIneP3Xd8IlJHeqFfIiA+nT7xdYa2iDBmaOx2OmsxnT2YzglWY9mUzI814KOFUbswoPTbWfZxmj4VDNiL5lbW1tnupihaMFNX0K0Ye5oxyfyujqWpyOeuyDrr09UEc154QoIA6cA6taS9O06uj3gTwKuStwGGwE17ZzDUXmerci+iZpQx5jDbm1+H5OsIbWt/PkFbatCNTE1tN4z5ndc/gY8RLJq4J8UswTQdZFj+ADbVmxU5ZML1xkcukyvmnwe3t479m7cI5HHn2ERx57lLKtcUXG5NIlmrKkdYbecEQxGKX8aJa2bokh4kSDJSUEbMo43jQNSCL77AuO3K+lHIwNAxapkOYxZU3KPSYpK4ZaV4zRBd/1YniebTwHBcuClaG/64KGODdLdmyV5HgUYZ7SJMsyshRIqdsM1grOCkSrubqsoW2Ftq2xxuKso0irjeDDXLA4a8gzR545FUyZTsKDQZ8iz8mznKLIsdYQ0GR5RVGoYGk9WS5YB4NBTtMI/TLDB0frLa2vIKrwiVHwHowNmsvIGF2FRrUp+OBBvAqYefCkMuSsceR5RpZZ+v0exhrG07EOur09Ll66xKXLl5lOZngfGa5tYIxWv3NOcNbpZ4k9NhwO8L6hrkrWR2sMR8NnoyOscB04Y7GImlXalGUkoCYrdNVOyrIdYlCzE1EFSwzEqGPEZE5NVhGlsYeAbzy9rMcgK8iN1br14z3w6lMgJrXEJJJAqHS792pGdhlkPaI48K02J9LUFU3TEqyh8S0fPvs4LZF82Kc3y+ibTCd8MbhkVjYRZtMpzWRKtbeHjZFmZxffNFw+e4Hfeftv8au//qu87JUv5/RddzC5dJnZZEoZPGtb26xtRWSoCV/bqlXHvWTYqH4fY01ijCn1P5plslDibC6bvw4TLHNGplbx9Cn2S+/faCLNRPDpGJpHGUf77p42rqT8dc6yRRqWsJ+Vga7ObFJFyxTPYoyWEg3OzQMNe70eMUb6gxwjBiuGyXRCjIZXvfrjyfM8BTZarBE+9KEPMR6P2dhcw1lHXijjazgYcOrUSfr9Ho2vMM5Q9PuU0ymz6ZT1rS2KQmnQMUaGGwMunD/HxfMR63RV0zQNMVEuxQjGGoxVLcY5hw+BrAHvTfqo6WM2bTQ4E4gx0LY1u7sVbdvy+Jkn5iY1jUtpE9XY4ozai+u6TELYAR5iYG00pD/os76+rmq7bxkMB5o/aYUjB9NR3kMEAiaoZmHR0gyS/AExTYbGWo3pUO4VIhGX+l0bAz4GQtsiPmCbgJNIbiBevEy1N+bh334Hzd4efmdMnFWEaZPSJAG5xeU5w7V1jh0/wbHjJ+Dee2A0BBsRAoZA3svJipxSIBgwmZC7jK2tDfIW8hZcVN7x7t4ezmWM1taJRZ+IZVI2+KriqYcfoTcacdeLXswDZ85w+ckn2ch6ZE2kH7Uu/e54TG0zauOgCRjr8E3AikPyHnUzxdcBH9XX2RrNY4Y187ivObMyhRzovLMo2Yy1FFlGDCFlNrDzMICuTQiB2WyGNTL3waxSujxDWMiHw+Jf54TafSsFoatzokn3rDHzOvUaZR/mNk/9VxArjEZDdXJHr9sQqkr9HidPHqfX6yspwDkyY3jyiceZTKDXy5PJSFlp/X7B+sYaw2Gfui3VBNArsCYieIajPnlREJUvSVb0mYxzssyQ5xaRQIyt5gRLVM0upUqMgjFxrlksBAsE35nCDM7ltK0GX9Z1TYiB2XRKnaLpu3eaZRbrOs3EEKOaALLMzbW7waBPf9BPwjBPKrs98oPgYxWd9YtuLMDcSDUnM4UDAX/GpDzcnfs9qtkzlVBgTkcWTIiYNjC7uMPswgV2P/QI9c4O4cIlwnhGnFREn/LYFTmu18NvbtLfmTIa14jJYG0NMoNSURrcsU3c9qZ+jy3OGUxmyZ0jD5Ec9QHFGKHxiFicaNxJFKMUaR9oqoqi12cwHLE2HLE5GNG3GXkUXLIAxKYh1vrxtiZYj28i0QScWJqy0Y9vVePIhGg0r5jp5hKTcoyleUbfe5xb6E0iE3hU6BjpSAC67l1OFEoyXS5+vaOL20aw3KrX2PlTjNFIeucyRsM+udO0DBujkZq1nBC8p6zA1zXBN+S5o9/v8drXvJrBcEje72seorbll3/5l9nd2eH4sS2GwxGmyKH1xLYlzxyZNWysDxFjaJuGXs8xGBS43GAc5CLE2FKXJdVsj7KcsBYGxBAZ71zGGMOg38c3ezTNmDxXCrWyuIQYLTEaYjz8J10IVKNmCAqsycjz3lyD29vbZW88ppyVjCdjdsfj+aSSFRl5lnPixMmUJ8yyubnG8WPbXLxwDueEu+66izzPyQtHU5dU5YzJeMJsMrtFv94KtxoCczqwFUMmBovQxqiZeH3K2iCivpTMEayjEaH2La5psJVREzCwXvTIAwwtFLOW9vIuv/cLb+XShx7mxKWLDKqKbHcP00aMj7hgMRHanSne71E2T3Apf4gLRU62vqE5ulxGaSLnjeeBz3odz/+MT+GpyUX2QsPx41uqrl8e46KlCIa2rIkhsjkcqJZVN5R7e5S7e+w8eQaalle84AUU/R488RRcuAyTkmMnT7IxWierW4yBYbT0o6GIQqwaorT4JhJMi3iopiXVtKSNWr0mZoZoBGxnClvEw1lZaDG2o+In1uXly5fnOfp6vR79fo/pNGUA6RUL34y1RDHUbZsWm0cXz3HBsmQSk4UuoynmO5pf7ArBJTpysh8HdZoN+j0MkcxZQgwUeU6W6apdUPaMZI48V/py29S0vqFvcsqmohxPQCJZ5tTRL4JvIZEhmU3HeF+R54JvGybTPUIIZJmlKqe0raZFgUhdz/C+od9XZ7gGNHYOwS5Z5pLutqQpzP1MQanAMRSIpAScXu+HFEDaUSSdTdqINRS9gizPky9J7b155ugVua4aU2oa7xumk1q1Hx+o/Co48shiSRNZ9gd0Wsy+YFsRQqLWh5TDbllzCTFgYkTEYaLgIhgfkSYwvXCZydnz3NU2FHVNUTVKEvCRLAYkQF57Wu+hamiaQFO3EIToHBPfUlphOnA00xl4tSZEAScGxMxjYmLKRmFM8jGGQGgbJAQcEJqGdlpy7skzmkFiOKTemyCtZ7Y7xiCML11GMqe+1xBVywlR6ygl60FIjnYRwVlLEGjTcOv8JSJaWlyAkASLZrVwc0vJckLJLiGuMV0WdqU1dwk3u49PefiOMm4bwXLz6CZVpZNIKpoFEL3Ht1pZMqSkdiT6cFOXED1ihX6/z4kTx9TcJcLu7i4hBKq6pG4qvG8o8pwiy8kzS6+XceHCeZq2pldYLpw7w5NPPEGMLcNRjzzX4Kam0Qp0dV3yxBOXMSZyx50nKcspjz32YU6eOsWpk6c5e/YMVV2xsb5JWZaceeoMx48f5/Tpk4SoDr693TE+eEJI5YADRNS8sJybrNsH6n+ZzSK+DVRVSV3XVFU1L+w1nUxp6prcOfqDAb1Bn9FoRJZlc+pwINLv5wyHPXInSPRMxzu03rM7ntDW6v+pm/rID4KPVXTR3zph2ZS5GKJX34pGw8/ZLWnyjLQCYjqfgpphfVDfSvAWouBag20jponMzl5g8vgZRqMBw7Yln5X41tP6gA0GE4SsVuf/IEAjQmMMvoXatzx65gmqXoa/+7j2czxZv6AwC/aVcRaaQBsCRS9HRNhramIbsUBGpNfvc7Zp2Lt0ibf+zrsY9fo8cN997D55BlM1PPYHHwRn8MEz2Nxg7dQJpPGYlAFcUtwNXs1yAhRFRtYvwBh2yyk+BiTFz3S0/86X2zneQ/CEZFmwxmCdU7pxcso7p9Uo26ahLPW36rY753TRdsTH1HNSsOyvg9J9FqKmc0qH4BGCJo/zHm8tQsBag4+BXWu4fPmCcuyDUnatsxR5hjFCVZUMBwMG/QFNXaXJ3TMZ7/HQH+wwm04JvqVXZEBOip8iz/Q6TVMym+7R+oZZuTvXWLa3tzFGmM2m7O7ucO6pc4TgNUHl1iaZs1R1A9HTK3JCDHivTr7gIz50gVhd5H2cv4pOswF1uqq2UZDnKjS6rANlqYk58yLXcgOiTt42NIvAs9mU2XQP7xti8MymE1rvqasSg5A7pxTMoz0GPmYxL9EmQpeOxQdPmzJsd0F7nSbjo4fQJjptxBOwkjIOSxe70hA8+Bqst2Az+i5jaB2xrgm+VUe2VV+CBEGCaLCuj7Qp1UrtWyaxpc4dg/vvoL+1hnvwXuzpbS6FmjgssFa4XE4x1jEYjqi9B1qC1Zxngk1CRTB1C74hS87yQb9PvyjIxCh1uaw4vr1N3u9RTqa4PKeX5WRWadc+zSPWGEKMNE2dxpQgrSaqNMIi/Uzye3bvNcaAwSShYvb5en0iR4QYqeo6MVZFY+3Qv7NcHfxlVSef6opufEtwMBrlRtBFysJi5SUi80p4wTeYRGH0Sc0MvkEMVI1GkddNRVPXtHWT7J99tjY2ECNMJnvU6xv4tYamqTRCOHgm4xmPPfYYg35PqcVFnqJq9Xby3BHRe5jNtBLk7t4lRKDXy/BtgzVCOZuyc/kyTzxxBmst29ubBK+xM1Wlq8qiyIkx4L2hbT2teF05hqDpW2KcCxeAEJXxA4mQYA3GOIyxKRFnzsbmBsWsnMfpOGexKSlh2zbzwVCXU6aTJFiipyxntN7T1g1FXpBnObOZ0qJXOHpI82KaANWE06WDDzFoIkq7SHLaRq+mVAlESTnwiFoNQpJtoG2JTcSXgUgPbE7PZgyNI9RTYlDBIil+i8TgCq2mam3aQOMDdR3Z9RV1LBjdfz/5nScZvvyFxNNbXAw1tjfCZo6dy5ewWUa2vkYjkRaP2EhhNVmsBQqMLg6JOGvJM8eo36ef52TGQidYtrYZbazx8NkzZL2eChbjklKmgsKkSP/Wt51UBp8oDyalmU3ZLlTGxHlsSiCm8WcXpmk0R9u8bEdd0zYNGxsbZHlOVVWA4FxGVVWUZTX33xxl3DaC5dYg2ZJNR59X/4qziwSVMXokCqNBP0mzLgYjUZNFePLME+zsXOZ973sv99x9D/fecw/D4YD+oMf5C+d49NFH+Lmf+Rle+0mv5ZNe+xpmpTrBB/2eTtxrwzR4PeujO5nNpvzeu3+bza1NPuET3sjGxgYhBO677/mMRmv8l//yk9x55518zuf8uTl1V3nsslTBMqaiXWrXXZjHU0yCUS1GbboCObpySrVdYtRo4KZpaJsWEWF9fZ1jx7bZ3t5i+9gWRV7QejVvjff26A969PsFw+GAsqoSGw2Ch7puqeuW97/v97l8eecZ/I1XuFGEFOzru6BhH6nblrrVIEdjwDqbJkYITQ0mkjlDlEhbVrjMEpwhj5BZw3ruKAj0pyXWN9AEmt0dyp3LeBfwBHxo8AgeoW68aiqVBlx6LD6z+NzS9h1hY8DwJQ9Q3H2K/kuez44EdkJDnvyO+WCAiGFWNxhrcaMRk7phWjeMrKWsGy5d3mXoMgbG8Qd/8Aecf+JJnrd9glGvT7/fZ7S2xsbGBhcuXODCziX2mop8NEh1XDx1XeOdBWfpD3u0IRKsSZVkk+bnwzxppl+KT+mwjzTUOfGtpSxLfuqnforJZKIB2caQWcsb3/hG7rjjDoB5fFiXMXwrhSEcZdz2guVmuBEC86ynRhdKc3V/uY3Q0WhVCHV8dJ9qY4/39rh48QKPPPIIRZ6zsb7GYNDDGkNVlexcvszDH/ogL3zhA8To8anGig+WGFUDMIlw0+tplbvZdMb62hrb29tkWaYpXQYDRqM1dnZ2OLZ9jOPHT0DUhJOdg9K3/opOrMIl2XUR5ECNcKUi68vz3WospsJPKUleJ4T6/T7b29scP35ME+L5lrqu6OUOlwgLMUSapsXaDFDBMpvVTKcleZYtUSRXOEoYT8eMp1Oms5n2D4GmbfAxoOlHU5ZulogtwWuGYUC8h9aDb3FiycWQi5ABLkYkBPXXNI2awUTNQrpyTwGPbUvTBlqvqVC8GE1S6Sx1bvC9DHdiC3diCzZG+LqkrksIARM0aDGK4H1AXIZYRxNrYvB4IwTfMi1n5D2IuWM6nbC3t0e9tkHdNJRVNXeOT6bqI2lzM0+/EpOJap6NuFuYOqPmwhAJbapnYxbz0TzBJFeSaGazGePxGGst4/GY9773fezt7RJjJHOOIs95wYMPzhPMWufo9/vUVYUPYS6kjjJue8EChwuXOUe/yzvdtUqrAmst1axBipy14QDftvi2Vl+Ds+RFriaCGCiKgqIo5k7u87MZk70xe7s7+LamyC1tW1JVgTzP6BWW4SAnhobx3g69Xg+bOaJv8I1QldM5j72utWrl9vYxtrePszZcYzadsbu7i8scTdnwipe+gjvuvBMRq/bnqlZ6KJayUe9e7nJ8+q+aVjRNQ55S0+R5rvnOqhKXFSl9jU+ZVltEnLJ5OnYclnI248K5i2xvbTLsD9jb2WX3ciCiPpYYfFqqCVU1pq4bRqNNfBvY25shWE3sFyC0KyfLUcR/++mfZlaWnL9wfl6W4dip44w21xBjaELL3rhiUBT085w6BsRHTFNjcKw5h4sBV1WsFX16ErHjMabySNlAyBDvGFhL5Rx1NSEzEPIsJVq0TEqPDxFf5FQhstM2eGfxPeHxzOOLwL33nCSc2OSpUNFmFsnX8FhCG8klSz4iQ2yh8QExmswRK0hmyQcFLs8xWcYdz7sHZy2PPfo4jzzyCL/9jnfM681UwROtsH3XaaKx7E0nrA179Po9Jr6h8Q17ly4g1uLyniZ5JVL7OhUBK7DG4EQom4aqqsiSYz6yKJH+C29+M2/+xV/kiSeeZDqdzgO327bFWi2e91vvfOd83IKm3/myL/sy/viXfAltCIxnR5vC/5wQLFfDwoqpkcUdOgqtpmOx5HmGN8p4WTixNQFjlyyuqqrE8tCPtYaNjXUG/R7OWbxvaRp1ahoRtra3GAz6GANNU1HXgaos1T9SzpKw6uG8w7ctx48dZ21tndl0ljLOSoqotzz//gfY2t6iKqvE1unYXswd9G3rk9PPkOfFnLKo33O811ouKizVMWu6oK10rnlmo6i1Xrz3GkwZURNZ2+BDCYlmXdUzIDLe21VapIcYhKZO0cmpez29SucrfLQxmU6YlSWT6VQFSwxpRQx0+krwuugSIbcGlzlM4zFA5gO29Th0YZMLmLpGWk3/IjEQ2wZLxAldNe25VZlIStwYqX2klUhtDbUzNJlhdPdJ7OljxH6P1lma2Fkckm8mohnNYqr6klLOQEpu2cXfGEl1lODYieNkCEUbqadTZpd3dR4wltK3iLPcde+9jLa3sHlOEKFuW80sQCrZFyOEdm4ZCJ2I6QKv51aRhfmr04rUEZ/T7/epqoq9vd19v0l3bNM0c2pxlx/soQ98gHe84x088MADrK+vP4M95ebxnBUscx1FA1cATS2PpJxgLiP0Cvr9HqNBH9862lZzfllnyfs9Gu8Zj1tmsxlVpfZkHXye4bDPS178Ik6fPkVeZNR1SVkGcuswBl784hdxxx2n6fUKzp49w3g85qknzwBQ9DJOn76D06fuIM9znHO89CUvRcTw2GNPMBqOGA1GRIn0+wP+0Gd/Lj54Ll+8RK/o0etWSzFAUDJC6SvNPZYVbG0OiEQunL2AFcdgMMKZnNwWjKfjZEqTVFlTiEHm9EUR5jRJYxwxQl03zGYz6nrGeLKDmEhROC5fusjly5fIsgwRQ1NHsqzHxto2VnIMDgmqIa5w9BAgpYCvaWMkIhhnsJkhNin1SAy0VUlVlZxIi6VsVmJqgyFiG4N1hoHJ6IklTsaYaKFYg6aGsiIPDYVo3RVJjvrOqb022iAYy6Vz56gi1EXOXuGY9C2v+cxP49iD93N5NKQ2hoBBokGCmSeydEHmGTQCWkVSvexgHHijuf2C0X0PftyLcS+KlC/aodzb48KTZ+YVM6dNhckyXvqaVxGd4VI1oYyBS3u7UGSIs0ieE4mUbTUvIQ6AYZ/5rMua3pmsungVEeGFDz5Iluc0TcOHPvQhHnvsCUSEtTXNbN62LWVZzv2ceZ4zHA75pV/6Jd785jfzrd/6rbzqVa96VvrMjeI2EiydR+RqSVsUy9u1j3VGsbQyT6t1SQFVxEQlDi3Bt7Qpr9bueE+zpgbdL4LWRRHlnvd7fTbX1lhbH5FZp6YhG9na2FBNRSKbGxuaCdU6+r0ed915R/J1BNaGQ/LMMZ1MCCHQ72tG4WlZ0i/69Is+4nTFMxqMiFFV7l6ugqXxjeYoalJKfAK5zclchm+12JczDonCbDpTc1REU4CL0ARNu+2coW0j0adU6cmu22k61liI0DZaErksp1gjOJunyPo9NjY2cJnFE7EiSf13WDKcVa1whaOH4aBP5rQ2UNU2NKHliScew7c1zXiK+KAZiasaUzdsDAZsbazzRX/0j6Qs3ErfdcZRtAHamife/z7CtMbWUNSRoor0mho7GrJmLc4HTNPiTIZ1juiFEGDQG+IlYnLDqQefR+/B59G/8xTtoI+JBtcaCpE5i80kFlru9V8D80g1byIBz7QqiXiMs1RtQ6gaRifuwBnHzocfZzreY3c2xVmHtRnFaEhvNMKePEGQgL3okVYp0i7PMc7ixeBDoGn9XPuSLiGO07EdQ0yBk0pNJgU7dqUr1tfXue/ee7EiVGWZ/KyphLKx2MKRZSluxliapuXChYtzgeVcpmmjjjBuI8ECiZa19O91kFYviyxIqt53FeqFRWJK79XHYkSddecvXAAR8l5vnj+s3+spo8MYsjzn1InjGoFvIAbN47O1uUmMgdFQf/gYAplTB/bJY9uEECjLGcPBgMxZppMx5ayiHij9+OLlHTKbkbkMlztc5tje3Fa1OHqKvKDICsq61Ah9l+zVzjDsDbGiTJOmbbDJHFZOyvmqzFmnSQMbFSzGCq2PhOhTkSYtVdzx6K3Vice3LU1VU81mWCcUPc2PNp3ssbE2woqkJHmShInDGfXxrJz3RxODfo+iyCl6BbNqxqwueeLJx7lw/izji5eR1lO0AT8e48cTBmI4ffw4f/LzPp+NvqFpPUWWkYtF2pZqMuXM+3+f6uJluLDHBhkb0dGra0bDEUOTQVXjqym5zchdj9Lr7NzrDWisYHM49YIHuOvTXsvuWo86d5hgcckzHoxo9uAkWDJdz2FjZ6WItDbSxsClaoxxwmDY08qm04o7+z1s3uPSZI/J3g570yl5lpHngbXBMYZbm5hj2xAa7GQXCJoTMMswmaNNVP621YS0Wn48aomBFLcSQ5gTfqIPhLi/sNf62hob6+uYJcESgiaVzbKczOULh79o6MOlS5coioLBYIDLcoqVYLnVuFKoyNKegy2TInrAzp8K74QW7xtNxV2V1OWM2hpa73nqqacQY1nf3GB9fZ3RaES/3095f3Q10h+k4jve0x/0scawt7eXTExu7pPJCweoE3083uPRRx+d21tns1LjTxqIUVdv5UwLi7lMf57dnV2yLGNza1MjltuWsiqJMbK+prbWpmk0k3B/wKVknvqyL/0yBoNBsp9HvHgaX6dI/WYuSDTLccCa/envi6JHr1fgnMMk3nxTV0onLqFtSryvqaoZxgh5PsQaYTreo98XbJFTJqLDCkcPF8+d11INg4LRaMhGvs5sMqGaTbWyYs+wbixkOeQ98rrhuCvILl5mev4if/Ced6PhyMLW+ohMhP7OLmsxsr61QV4F8jrQHxS4IscOhvhpiS8bKPrQG+KbmiYG9lwkO32SV73+E+F5J6k2B1zyFbO6pp+vJesCi2qWJi0M0TxdXdVJA0hsQXyK07LYPCPDIC7HVzMm0xmXdnc1j11ZUkToGculyYSpRC78+q9SB8/OeAdTFNhewdAYXO4o6xQYKVDkPYqi0EJfyRISU12VTrvohEmnsSybyybTGePJFOsWKVxAS1lMplN8CIxGQ5xznDhxgs/6rM/iMz/zM3n+85+f4luOLm4fwXKFjWv/n4ebxjrT2dUNZ11uMK2B0BKi0HhPXTeI8dRVnbKOalDSPMOFaDr9plETU5f1t63V6ZY5RxRPSI7ubhg0TcPu7m5yjGsFSiLMZi3aqTImkwmTyYQsy4gx8OSZM2SZ1qavKmWm1bXy+GfT2Tytdq+nhIDz58/T7/eSn0QQL+lZE6U4zN2QOhrp7MIyLzymz5BhzSL1d+fnF7r8MF36Co3JcdYiCL7VMs7GJK7/EU8/8bGKuqxwmSMvHM4q83GWTLNFz9Ezlr5YYubAOPomMhRD3B3TViV7jz0BQftAsb5G4Sx5WVGIYaPoYdoGK57ciKbiNxbJM0yvIDhNZNkm81IcZNhjG2zedzeTrQHjzFCFSBUCmaR8fl2gbyICkHpxTPEjNpLKHqe+KWZeLtnlhtzlVGVJO6uZzKZMyhllVYNVdlvZNviyhIsXqaNnt5pRCPSKnDYEog/UTaNmLqd59Jx1tD6xJOcWkDDXOBaFvUJiK8tcwCDKjIshUbuXQgLU3KZ1mfLc0B8MeN7znserP/ETNRvyER9Tt49g+QjQscO6eA0haR3Gkln9BGfwVm2aIoaTx4/TtGqeasqKcjpjz6pgiama3rz2dIzzFZNNWWKtCGItRmBvrLm39tqGS5cucf7cOaqqpGlq7rrzHgaDIVkmeK+CZ/vYJidPHaff72OM4f7778MHr9X5DliVRAxNU7O3N06JLh1NW5HnBb1+QV5k+FTcS1ljeqMxpThXB60nuXKBiEn/CV3WW8FIxFnD8WPbWBvp9R3lbMJ0ssegn9MrMopcjyE4+kXBqD9gY22Dcnq0V1cfqxjmOT56xpcvp1irlu2NdYrMse4ypKrx5y8xPX+R2blLvGi0zoZrOP877yGPcGrq2VpfY2t9xGT3Em01hrIkt5aBj5imRbzHVw1tE2hqsHnB4IXP5/wTZ7lw5gmKO09itzc59ZqXEbbWeSxvmMUZs7LF93pYZxlbIJmb8hjIQkRzwggzl0gnQNZGMp+0GFF/hViDj5Ht9Q2ODdd521t/jScfeYxHPvgh6llFUzXccfo0g80NJm1D5i333XU/0RrWmhI36JP1+5jMpSh5He+ZzTBRiI1nujfGty39QQ+11/nEElv4FmNQdlev32NWVpRlw/Pvu5eqnPL4k0/O2V/O5bgsw2aaDunipcv0+302t4+DWKqqIctzrD3a5uXbU7AsKSDxabzfBQWAed1tmW9RjcRZRwiRKsSFfdTrSsRanXC7qHdgvtrQ1C2SuAKSVjUWMi07bIxJqmxJXVfcedc99AcjQrD41lOVFVnmyLKcXk9pwx1TZDabzTWK+bOI0LatajipBsrW9lbSNFDfke/qY8ekbSUNBrX/zpNzzldWSqPsrhuCOiRjR2QwsBTqNtd0fNsmU2FXurlZCLAVjhwyYxAfqL2nqSqigbVBT7Xt4JHgsQIuBLLWs1n0ONYfYCYzTIRBExj4SD8KvvG0tZYediFi2hbjVbAE36SYKaN9tZzRSIBBQVlYbGEZHVsnbgxpepbaRGrfIone3KT7VZKKjvkgSmn2ZsFfFrMg5HgCZV0iwSKZoW40o4Dm5QKbZQxsxujEkBMnTrB9/DjkDlfkDNfXaYlMxq3G2FQVJniNl4kx1VBJzLQYE3Gg06I0nKFbAS5rKPMS6IlSfOedd2py2bNn5/t98PgqzE1mvV4PYy2TyQQfNVZG67Mc7TRJt6dgOYCnM29pNLGu4JW4mARO1KyuxhqkFWVY+TAXItYaskwn/LpqF+n2U0a/Ii8Qk+jNRgA7983cfdedFEWhUbR1RVWVbBw/QVb0QTJ801LuTeZV4pTGqx20aRqm06neuyzowUXqaE3T0BsOKQYDJjs7NFXFbDZjMpnQJPXdGINYsM6ATwnwfEMIKlZ9CLSpLGrT1LStpyw1+3GbBNRksod1YGxPszzXpQora5iMx1hbMOz3lKJdRsqy1CJFKxw59KyljoEyRKZ7e9S7lzi5vUluDeXeHlnbsu60xPZA4IUnT3Hf9nH644rce9y0oZ/X2KxiNKmJdYMrMh1IbQONfqSpkTYCBeVswvlz58k3Nxjce4qzObR92D61QVwf0vY0weq0rtnILLZXMKsqQuwSX0pKRRO6NF26MJKlirDR0/qWC5cvYpxlI25gW2inNVlesLm9TT0u2d7Y5FUf/0qKXp88L/BWNG3L9jp7syln9nYY7+4xKWfkvQKXOXpFQW4dziRNPkJuM1xXylkEY11nHwGYj88OXSbj1772tTzvec/jN97+duq6xjlHVdWUVT03t508rcLnkUcfoWkajh8/ztmzZ+eBk0cVzwnBAjcoXFJMi2YSDXP7/6JccavJ9UKkqiraVutvZyld9TIvPabCPGKXS4UKTdukcsYLHahtdFJ+6qmn5udpmpq6rri0s4fLcqzVSpGhaecpJIo8xxhDnYKlijyfP0pX3bGpNXBzVpYU0wl5UWgNCu8Z7+0qsy3LUhrultB4TSKYQsla3xKxiFiCD/g2lVltPU1dUVX1fPWEiKajUSsEvULT2fR7BUWeQWGxNk/3nWFw9Ht9Bv361v7YK9wSiNdqi70sJ7aqkY53doh1RRxPGCC4rMfacMTgdMaptQ2O94esS07WtBjTklUedieYsiG2bQoc9ISmIrQNoW2w0WKixTQGG4V+0ad2hpnxDO6+E7O9zk41hcrgRpuMbEbeh7ZuqdsJmTEpa3BQ1qZJZJzE8I3J5ydEgkl+DhHWNzcw1tLvDWhbz065y4mTpzh1/CQ9MkajNTZOnmTn8g5nn3yCnekEMssrX/dJ5P0+g+GQFmhixGVKaulqFAUf1LeiIfX76UTze2KuuQDzQOs2WT7W1tYoy5I8jevpdIaImecBM8Ywm804deoUX/iFX8jLX/ZydnZ2AMiy7JnoIk8bzxnBcn10NGVSzqMkXObmHy0epHUUInVVEaLsq5GQp4leI4gDvm2xJpurtqDxHsYK1rq5ya1N6R0mk/FcE1GNoMHalFk466fkdNm8ln3nY5lOp/R6PU6dOjVnlHSTvTr1W8bjsdagzzIGA02gNx7v4Zyj39tKKSMaWl9pvfKi01JaYuwqUSqBQbMle2azkrqq5hqHiGjktdH32CsKNtbW6BUFWeaQnmBNTp5nGDKEjH6vRz1orvg1Vnj2EYOacXouJ6CZGSa7u9TjPWxdY1yB2yjYHg45Ndzk1No6270h69FhacDUUHuoaqTV0gk0DbQ1frZH29b4tqEo1jAmR0qDsxn94YCZM+yK5667TlKcOsaT9QxTWtbtcfIsZ5RlnL28Q9205IMhGKNOequJM42ktP4aCq/xaBIJ0iWDhPX+BkYsmXFML+8x3p3w/Jfcx8ZwBGWg6PUZbW/z1PkLPP7kkzx29gySOV7x+k8h6/UYDIfUIVAlEoxNznqDljfGR4IPyTS2eK9hXnQvlR3otoeQAh8NYizD4VDTvuQ5oAzRfr9PL1khAGazGSdOnOBrv/Zr8d7Pacf2iMeGfYwIlgVro2MyCREnBmeMVofMHL7NtIWD9Y11EKO88iyjbbxm/TXCZDLDWsNgOIJoEVyiCsdUMjRqBbzEnOrqv/sU8e6cwwzXMNYQUs1v7SiqPvcHhcaCZBlihOGwp0GNbeqUGEKyvYXoMQYGKW5GiEymE4hojjJrado2pdwuKQYZzmZ4aVNWZE3hodRIzTSrxcAiZVXR+KDufGNT4OMQH2qqajJPUqmlVSOj/jEQmEx3WF/LGA175MMhhV85WY4kxKTILs9gMGKUbXDp4jmqpuLEYIjxgctnznHHaJvjwwHm0h7NbknMe1oOeNiDcgZlBa3WO6GaAJBlQ2x0BF/hvdBGmOWWJsuYDDLcXcc5cfdx4vFNqlGP4ahPYy2X9nY0mWSWI8aojyGlbQmSsqnMfaJLTLHO4ycRL2mUVw0GjzcB6zLW19c1B5r3zOqK85cu8t73v2/uS9w+fhybZ7zrd9+FzRzBCJ5IkeWJDSrz8eobj0nxMy7PMdakoOVAk3yaMaJxJ9bRK3paB6ppsDbDimGyN2Z3Zxd8oMgyjm1tzslD01LDCba2t3ni8cf51m/52+p/8YGNDY3G//f/4d8/a13nerhtBEuXfRVSfqu5ATNt6xouFJOlg7ttnaNP/5XOmZ3qUhuj9UpEIM8zEK3uJialp49aprSLupV5zG+i1XaXT6YkSUyrjprY3btzGc5lZM7RtJr5uEsQENEyyJlz2MylZ00O9RiQGOf8ffVTqq1ZumIvKUo+BOj3e3Pnvvdq4kKMFliKWr4ohIhN0V0xan2izj7caXRh/oL1XCF6dZaKxgk0dU3deIrcI6jpbhAiYi02y8mOeIrvj1VE01VXTXT5TD0FPmiRNtdGQl3j2sAgGmzVIBJALGQO8oyu5AIhQAjERp3c4nJMdEj0NMHQALPc0BYOvzHEbW9gj2/T9nOCM9DLiQhV28xJNC7rJUtA7NaEC3T8lTgv65fGUFd+HHxa5CEp9bzVhJUhRHwMzMqSp848ictzsiJnNBqQ5TmXLl7EZo5iNMRm+l7m7ywuiCySxgrJYqGvIKbFmfpuO83D6eRCG+g40fi2JXjPxsYGvvVMZ1N8SOUvvM43zjrG4wnveMdvafyZD2xubc7NZ0cVt41g0bQqyknv0PnqOuyj4nZ9al/0PfqDtQ2+qWlDiw9Ks/ShpmkrmtYTEGw+pPGe3d0peaYcf5ullCleV/jW9VOHipRlC0RGQ409qaoS5wyZUztpSHbYzGX08j7RQ+XDPIlkE2aINRT9nFk1ZnfckCdGSGg81lqK/kBL/tYNYlwaJCoc6qalyHPyLMdHtBBXrUKrajUVzGi0ThtamjpgMk3d0tZoL3C6qmxDcohaS9bvE62h9g1V0zCdjnnX77yD9bU+r/z4l1CVM8pykjIjC9NZjVjBuj6NGGZRsMMRhTna9uCPVfj+QDXvPGdvb4e9c5c4sXWcQZGzbg3DNnCq33KqzVjfazg5GrCRF9hBDwhQ7UBbQawIQauwxmiJLYRZpfFToce0lzE1lg/2hP5dWzz/M1/PNDNMHOy5SB1qYl0iWY5bG2kfjDBtKohCnhWAEH1IQb0pc7EIUSJiDTZX7d5aqKsaHwPO5uQuZ20wSh07gDF4AdcrGG6scereu9nb22M8HtNbH2FTOhgC1FWJixkWpQILMifpiEorEIPvtmNSoLCdhyD42uPFQ9B0R3M/afD0i4I7Tp7i67/uL/G+972PH/6RH8H7Gt+0OGOJwGQ8Te2BFBUw2Z0yMyvn/a3BFWlB4vwf9ZHJ0uZUljem3747PnZZTqVTLZIC02UmTcGSEZpyRpt8KTElfPReV+SJ0Tin5UJHN9bJXItmtYjYeYGtSNTo9aSaaLBinGsiPniMqO/EB48PLa1vsV3AVdKqtCxwwKZn7pSxxWeRsAZJ1f7C0v5EXujKwca0QpKg9mIf1KmPiEblL9EjRWzyp+TEGFN21rHG86BsGGM1BxTGqgZnHSY72sFcH6togicI2BQZrnR6zfqttHSDE0OOIY9CFsAFIHgifu6oV2Oa0tZFLNGQagDpp4qGUgzZyePI8U12MqEpLE1mNa+XEYK1RIG6qTE2w7iMGFvto6K15mUeI2ZSwHIygAW1EEQrLJSUlL08kWVwAdqA7eoD2VRO2Gofxwg2c7gs0+qQLOaDGMJCWfLd+dNy1YiSbVgyjCBpuuqqtyYjCUsB3VE1GmcNW5ubDIdDrWXvu2DskFxHQcf0/Boyp0wfZdw2guWwwjadg6xTfU3KJq/1s0MSLOk4MYlobjVwMUmciKrFXaxKRCf3cxcvYVzGaGMLY3RCn06nGLEEr+yTuq6xVrBGrw2BnZ09RCLWCiEaQtQgSWOELMuxVjMGa216LXEaotZRkdgSJdGb0RgUjdwFScFWnUXApYSRGiaiuYkQMx8AYnSiRwLWqulOqcQpasWryu67gLLY0jTtwlFvjJIWUqU7mxLfPf+BB7AmUtcNFy5c5IknHmdtfZNeb8hgMMTYHtg+xjnaCOI0kGyFo4dJOcOKoW1amrrBIITW09Qt3mkfpQ1kAYY4bBuBBqYNmABGE6F6vFbpkUjmcky02CyjbSJtE7kUKmbWccdrXsVklPGe8QVGxTaj9TVCmtRNr2DWNJy7dJGtzW02R2t4qZOWYjEI1gqZsWRG+2QEKl/RBk85nREMRCOYLNP0RFlGURQMRyNMBBMi/eFQTXZW8AJNVIFkcyUV9AcDmvFeR/NRodJ6ovg0brqATEs0kWi1DLEyQ5lLjsW8vxA583LEsftbP3meAZHLly/T6/Xp9we0Pmi0P4uMGZ1wCQuvwJHFbSNYDlZhm4c5ytz8T2eO7fwm10JEVzfzD0LQqt2EEHjq7BmyokdvONSa7yZPAkId5c5p9cQuz5au1iJ5kSe6sdHJ2rcpQZ2u+NXBn8oDR8GnAEXrMkhUSWudRtYmzUjpiR7fBpraU1U1RIMxYS5Au5LEGr2vuYryPMw7sya5a5MGpo5OH0Li3Zu5H0iSryXGQOsbmq5ccauUaYF5EBrJ39Pv9RikXGki6psJbUtrKoRw5KOEP1bRzEq8CKFSanD0LeV0RqxrjAPxkXEZKAUak5iM0WKDJUokpFx4PkatVRLRrNlBK002wdAYYeosVT8jDnowyJEo+MxRAzPvtQglEEQYrW/QhMj5ixfpZT2ssRqHFVWWNSSHuVPzK059kCaCRO27zjhdVAFt8Myqkui1sJ2kwGVPBGvIioI8eDwB6yzGCkWeac16Z9WZbmwa4TrGOo1Ekmam/+oilSRgl53AnRDpKnJ2WTA6C4KPXitXRk2eGWKkCZ42eMRnqqUkur+k4Os4P//RxG0jWID5JMmSUwzSD8v8K6TVzfy45R9hycHXCZW4JFyiaAqIc+fP0RsMOX3XnRALnDGYlLNoMOilSm9WOfsRdWICeaHpFrLMUFWBuqpUjUdNS5oDKGDEqVmNCAacU0doCE0SLJam8Rov0waMBNpWhUNdNQg2CZZFltUQWtrGz2NcYlgUHuo0snnHDypcJGk+1lqMNUkgxxSn09K2mi7ftw3Bt/qiTFeHQo1u/V7BcNDH2GSaCwHvG2JTAWaV3fiIwlc1Pkba6FP1UKGczfAGnb09jKvArMho8z5tU9MGi42F9p9UGCwk87GPkcq3+AB1C61xNOKY9hx+kOEHBbFfIAghy6iIlK2niZGq9WRFzvrWFjuXd9i9vMuJYyfo5Y6mrcFHpAW8h+DJnRbkKwYFSMTGbkEk5MZirKOJkdZ7ptWM0LT4ulGKcpqoxQh5r6CNLR6PcVoAMMtTkKdTK4CIoQ1pnJuUsUMEYxcfXVAl01eyG8wzWnQCJ2VKXggbvec2+vSJKqRjoA2eJvh5xH8ARCxiJZnVVoLl1iJ2NagBzEJjuS6S0yUoW8SHmFYI4DEEsUSxKd1DwYte/CKKXo+TJ49r7QhxNE1NCBWXLl1QfrpEsjwjy9x8Qt4b72GtMBgU1E1DGzyZ0xVUVvQgCm2rlcQFUeaVj/hpq2lQ2pL+YEC/38c3IVV+jBijzyyisS76cWRZWj2JBm11fpsuGR6QsqtqECgmsd4KzVisduhiUa8+rTa7SpkxBZ5lziLB8NSlixSFY2P9BMPhkM3NTQb9AVmWsbu3B5JhizXE5kCgrevEzlnhqGHglO7eNC2ZdWTW4JuKKrRECUiAcQOlHVLnGqHvJJDHnq60E3EkRnW2NxF2m4raR8Y+YNfXsWsDhnefJm6tc3Y6QQrLqXvu4cLOZZ586gKjrS3yokcMutjyjSczGaPBiNAEal9RYHBi1SnuPdH7lMlOsMkHE2Nn/g7UzMDWNEbVitlsSlNW1GXNeG8XJ4bx3ljJBt2CS4SmbTFNg0tMUExizolJgf0Rb5JvRbREhLEgLgVC1+1CsMTk70ze/tiZskI79/9C538N9Ac97rv/bmazFJSc/mtJft20sAVSaPPRHlO3n2ABVSMjyQyVqMcHQ187HEI/7hzYnbbSObwjhogyT7a2t8hzDfaTaNVIlhz4ZVlqssem0fQo6TVGukh2Q5tWcjHGJcKAXics3OsElJzv25Dya2kNDGIy1aUOHROVEZbyDdE51Tt/yyKLKrAvq3BHFtBEy5rAZpll1z2bBl4u1PXu070h9SupTTmzjizL1AQGNHWNmIgrFu29b2ibo53X6GMVeUrQ6Ik4I+TWUjapPhEeH8AHgyfgJdISaaMsNN/EkCLqat3HSBMCVYyURhcvstand3wTNjfYixEbIn2bEYLQ1K062UVr9hhEHewYcpshidardF7NJj6nGQdlXZHo9qmDE6PH1w3RBhqbVp2toSpLqlkFocUaoylRgo74Nvkyu/6/HHyYuKQLvs88B1jnwe9M4UKIXYaKtPCNgr7dBTmIEJaG1cKjnxc5J0+d4Ny5C2q6m2s7abaQqIGhqvcsWWyOJm5LwSIpR8+8XvuSUAldRdUYQKJ2xs4Jk3wHqrGgGopYgnEEsXiUOogxbG1tEUJg9/JFMleQZT0GffW3tL7Rwl/9Pi7vCgDVEAP9wVBXMVaQaJHoEje9pQ1T7WxBsDbHWo1EFhGMr/FiMG3EmB7WFBiBIG1imUWm03LuzK+rFmjnwqMTLCEsam5Pp2XKmOrSJ8PlVgt9tY3Wdmla2rakbYULFy6zuztR04O05JlgJRJDQ1OVNFVJ5pzGOIhACPi6YTaZ0FQ1dVmRFcKg0OysxhkuTveYTGfPQi9Z4XpYL3K8a8liTn/Qo9fvM3ORtnFIaOhHKFqDFBmtA290fMyqUlfrTkghivgQabyndVq/pbe1Tn7HKfI7T9O77x5YGzG0jnHT8t7ffg/99TXu2DqFkQIaIfNpLIeAC+BiKu4VIrPdXbx19NfWyZ0lc5oSyftAPZmlpJTMy3U3TYM3QuuU+SWZo03Zm3cnJaH1jHf2iF61c42cF1xmCVFDEIyR5D9RH0tKf7lwwCcrQdvK3J9b+3YuEIidySr5NIP6JWNY+EQjgGi+v5N3nuSzP/dz+PXfeDvn3/6bapYTiFpgBn0VLU3QqP8QA0cZt5VgWdCGWTjr5co2UZbaHnaWJe1BNYjleHx1qpdlldLR7zIcjBgMDKPhekpCmVH0eqytrxPoKsTpisQ4pR+GRn0f1mVzR51PEegidnEtY1WwSI4Ede5rPiI3Z3MZ8fN4GWscxpp9/hM9pyTSAnONZm7+QgeBVr9Us53JkkMwRRKHEMmzjH6vYGtrg7rqUZcVw9GAPM+oS82lpizKOA/uInZBpgbntASB+hc1HX9TV9TlSrAcRUhokeAxUVO7WIPW1IkOiREX1B8RiJS+pYmOVqBtIjhNb0LUzAwdVV2MxeQ5xWiEjAa0g5w9PKGtqTH4EJFUlsFiaauWADTeY52jyAtNPdQ0uKzAIinpo9WaSUQkhnnQbxPaVN9exxEpg0TwQSdlIEpLaBr1ETW1VkOta9WGUu0UI0JVlXOyvjVGfScmIEYXqWpc6ARLcqYjWtWSFFDcvdzYmbuS0z50VoAlsk1q532LdZYTJ08wGPQXGcclaTkCnQBfkAOONm4rwTLHUm6uK3YZkjYzD81l7l+ZT+QW0uQeEA0o7Jz3GKUbP3WG2XTChYsXOHXyNCdPGk6dvJNer8/62jrrG5s87/77uHT5EhcvXliwpowlRE9VVwwGfQaDgaaaCIHZtEJEC2ghjihWgwutpXAWgsdZR1H0cDYnZoKRluAX5rDeoM9wOKKqyqV0+NDVqQdNGRNj5NKlS3Rpu+eai1XBlBdDIpG69TRNpGkC1uTUG5719Q2apqGczji2tcnGxjrTvQu0TY2gAmY2m+GbVrO7OqV1EnOMyxEi0bcEXzGb7DEe7320e8QKTwNtqYG7hBaJOSYGitwSnC6u8gCugdp7Ls8mbDllaUkJvdwxyJXhJSHi6xS71R+RD4fkp04w3hoxHjrOji9RTXYZjY5hXcHm+jZiLb4MTGZT6rahiYHBcMixjS12qinjyzvkm1vkRcHm+oZWZqzrVFhPySEhBjwR6yy93GKdhhKUsynBe3V0h6C+mumUcjrTQl9tm4rRkUzc+tnduUyZZUjcnNPsxXSxLomRxdwNT+eqJ8WnqfVL5otftdAtzFad/6XzsYSkAU2nDcZa7r33btbWhjRNMxcuupizKdxC7fqi5NUjjdtGsAS/sNN3lRz37U9JIUNaDRijE2pd6WrZWkl1qGWuggaSbThoKpeAJoezwPraBplz1FVNUfSxJkuR7MKsrBiOAsPBGpcuXWY6LVFylgVxiQHmOXbsBHfedSeak0loGp80h1zVqqArxOA9j3/4Edq2JgZPjDUqM1QYOpurTDTC2uY2x06coJlNCcFj8lw1orZVwZJWX23TMB5PktYS55+61oSQTdvQUa5bH2nbmNK++MQUU2adMWAIaHmBSFPVSLS0KRW/RvtnmkHZR6IY3ac0I5qmoqpWGstRREwlqyUGgm9pm3rJ+ZxcxMZS1g17ZUM9yGit1Yk4RGKbSkyESC4Ob4RgMzyGWV1zcbLHWVPxaFVSYrjLO06evosHP+FVfPihD/DwBx5itL5GnhVkBpxYpnsTJAproxExBOqqppdlBCKzaoZ1qhnnvT4YmFYlQaDEY0UTRbaihb6yLv1K00BZE8qKWNVIjPRctqAee0/bquDqyAGIBlN3VnSSJSO9OVgyjcVUIRaj+f46K0onTmThqWfu2E+Cp9P+Y4h400DUGDjvu+Dpzo8c5gHWEhe+nqOK20awLJftPIzFHYKnrqvk8NYfJ8bI3t5uyv2VUxQ5We6IokFNMTnwQxIsMdF2rRPW1zfIs4xqVtLL+xjjqKuWpo7Mqpo2RPqDEWCYTkqy3GKdUW0IwVjP9rETPP+BFyLWqdBRoiJgCa2mqDcoxfODv/8BqrLEGggemjqS51ru2NouXYWwtrHJsTvuJEyV1WJHI+2lVTU38RGU5vzYY08QQoX3AWNUOLRto+p1hXZS69RJ6+MB01miUhowRtNRiAhNkwRL3WBQ+3CeZWTW4V3Ex1Q6wCpvp2kq6upop5/4mEXwi9xzvqVtKszcJ5kivg1UvmG3aqn6axr3krTnhWCBQhzRGrzNqESY1RUXxiWPtZEPjvcoo5Bnm2zdeS/Pf9krePSxJ3jsscd54AUvoN8fYJKWPd4d0+sVDPsDppMJbWgIowFtUNpwIQW2cOSjHsZZZrstbQzUscUhOGPwRpleNkai9/iqhqomVjWx0bLZRa83NxnXdUP0NW1dE9L46cgAnbVdln26yRwXk4TQ7ACo9nYFTXXB4OrKKUPSlNCFbWg9IoFWDMSAs4YmXUdlkScGkwrqdbFiR1tluW0Ey7IvoVNX1Dyk9d7rumJvb09XH14dcjFGLUxlLWtrQ0IcgvRT4a6o0a3e03jN9BtRtVd9BJ68gK2t4/T7I/r9EcZkypPP+vQH66wfO4F9+BGqqk01VXI2NrdompqLly7gvaH1Aj7gQ8uFC5ewNmNz4xht62kbT6/oEaPWMXE2aK6iEPGtahaaOaBLDRE0OJIkCJqW8sJFZZPVtWoPRYHtql9WFXXd4FyGYNUEF1W7Q0gV+jKaVhMRtbOSum4oZyVEvfb29hbPu+cuTp/cZrx7md2LZyB4TFqdea+TgXUVkRyMQ7ICl1lcnhFDQ9usBMtRxNqonzR29UdEgpakFiEkpqE1juBaKhORYYHt9WFS4UOkHE/JjCMzllExpG8tJsvwPnLp3EXOFC2PFp4LJjKNwuV3/Q7v+/CjvPcDH+Lhhz7Awx/4AO96//vo9XoM+oWyKpNJOfg2laww9IoixYsYHnjwAR548AFOrp2iN+ixM9ulnpZcvHyZwWjAYDigSHFgblpjQmBoHP1ejzVjmZYaqW9TyqHWB0wIycek9HuLwUbQWmJRNfa5T76LSllQ4iRZFkzmO68+cND9u8TQTAIjoj7RrK9z0qwsyaxla31tLvCqptW2bUt0qCZ1G1Rlve0Eyz6keA3vPXXdMJ1OFr4OMUmwTMgyR1E4sjpTNTrP1EkWWvr9Plmea6lRaylyLS1sQ0PrHLH1ZHkPaxwd19G5nCwryPIeYlxa4GgdyjzXTL4xbYsYncw9VFVL5kwSHGp+irmAWHpFP5VJXtAep9NpKlna0YFbTuyNqcuSqizxdU1VzdLz1xRFj6KocS6jrmv29vZo6lZTyRhHvz8A2jm74SD3QQPe1LFpraXf71H0tESyFU/0NVmWEbxOOjFA23hKKoz12Ey1HJcxp0DHZGZZ4ejBOUskYoJGogfivCJqR/FF0BxcTohWiCl/UQwe33qcEcQKmViszSjE4fCExtNaT+1avHP4KOyNd9mbzNjbm3Dx/HkuXLjA3mxC/v9n77/Dbc2vu07w8wtv3OHEmypKFVVVCrZKsiQjGeRAYxvauAFjGjDQhjahaWhmmA7DTPPQDKHd3TTMw0zDMDQNjQnDg9sNNMHZGEmWI7aqVJIqV9264dyTdnzDL8wf63332eeoqhSQpXvts+6zn3v23m/e7/tbv7XWd32/ScKgzCFEmrahqWuauha24USidmsNxaBgvDlk+8I2O7MJPjqm0wnT2YzDwwPatsa5hmGak6JxkzkmQBqFwFJ7j3bCv2cBjCHLctrUkTrPdDohdE5GoQTSrLpIo0cG666MroSzK0bf4YGk1iRZq67xuKu79ACX1d+cRCsxCktHz5hcZjk7W1tUdYNzrpM97iOXSNRdFHV7Z8LuHMcCBsHOx74NY5UeGw6HuLZhf+/mKhuktCaGwHw2Jc0SBqVlelwznxne8cRjvP3xt0kdoHNOffp0YzQksYZqcszx0REvPPcc1bKlrh0RIekblBvk6YCw9JhoSNMC56CuPIqUGBx15YhY0mwAUZFkcN+9Q1AGYzOUqgi+xpqM1GY89tjjuLahbSpM1wH/l//K/8jTTz/FaDTsRIIWfPBDH2Q5m1DXNd61UkT3TrrjvTRUNk1DVVU89dQnaVuHVob3vOdJvvqr381iUdG0DVlm5WZXS5yLtF76aCAym0/Z3trksbc9jG8bXnrpeV58/lmmx0ekSY7NpO6zWBxw84YwFCRJSjHSJEkEm6JdC9oIgzTnfSy3o3mEot5YhdEGtFlBZ70XYtJlXTNOLOlWziS22GpGoRISY7BaYaJCNRFig7KBrEwY5zn3bo1oNi1sGcZlwpTI3sYR1aLi1uGUJlfYnSE2zTBG45BJzbJZQAgYA0ZHjApE72l9Q9vM+ZmPf4yf//mflsmg0YKQ6lJENrHigKIhCZBPltgAOYZoLSSWcnuTYjjk/rc9wqV77+VdX/u1YCR6+Uff9/d47dVXeMuVu9ERmqbGJAkmSTp4ryLL0g6KrJnMJixmc5IiEwJWJZGM9440zUjTRBgoAGssMUSheOoYmmczIXD1tkFpwzDNefc738X9997L9/39f8j08DmUEyEx1RNx+sBwMMCeK0h+aSx03YwxnlzovulId7oSUiOQDvbY6ac0TSU6K96LSA9RGvq0XkWnIcRVfaJthetIa4PWpmtM7JoLkRpK28psTaFkxr6sKQdFd3OJPov3kWpZcXx0LJFLjPg2dI4lpalamrrFNY0ACsJJ9NV3625ubnL58mUGg1I6ipuasihom4a2aU7SBh1kso/q0jSVYqDzLOYLFoslk8lUWIijsNb2TWC9YBhIKiAYLU1mnZpk3VTUiznOtZ0KpQOju7qNJc0KQbF1BJu6k25VWqM6eow0u721I371WuyR+wD0Ku0nkWxcIa9aFVl6x0KBVwmhnzbHrsAtnC4YJzDlBENqLKlNSNOETCuGG0NsIsAVV+aE2lEkCYnWJFFkuZs8R3mPCoEiSzFadfpCHudbfOvwdU2jFqAUNu3uN2s6gS/ARVofYd6Soklsijcab6URM7SOG69exXnPaGcHlSSgDQf7t5gcT9jf38dai2tbAaZYS9M2ApaxghbL8lRoXkIgTzOyomAw3qapGw5u7dFWNa5uSBJZ3iqNw+OaBqMN0WisNmjb6TvhQXtSY9kcb5IYIxETHZQ/zVfPlajY3t65sDvGsbieQDEGLB2uPYoD0YROITKwXC5YzGcsl4KIKopCOsCdo2lrmqaW2b6XmYUxliwvVgPzzdahFVzc2mSxqFjMRaPF+4BNUrQyTI6nzDYXKJ0wn1fcvHGLt7z1PvKsEAI8NM4F9m7sYfUztF0ksVw2aG3I0pJeJMy7ptvfBjE4FouJNC96xwc+8AHe//73rRialeoFweIKtZXnIoaUJMkKNrm1uUPbtnzqU88ymcx46aWXefTRW8znCxE8SixlIbQcjWuIyhGVwyotDNEq0tQVN25eJ7gG3zbSDKoVz9+4iUFhlCbLSy5dzsmKAmM6NuOOuibJMmyeMdoY49YYAM7tdrOu6a/TBdJduld1mFivYOE9RzGy7yJRWe7JSzKtpWofOkBKkFxP0ngSo7GNx3orBXVjSFPL7qWLQl902aF9xPhIrjSJUhRRSa2jcaJG6Tw6OGLwzI+ntE3DfDGjriqaatn1hID1VmohLqwkvZktUM6TeEORpGwMDPPYsAiOygUWB0d8+jOfQaUJP/SDP4jNc0yWMZnNpJnZORE+0zL4W6U5Oj6gqipmiwVplrKzu81dd1/hyl1X2N3aZvvCBa488gSHt25x9BN7HB8dcTw55u6772I4HJBqS2gci2Op+Rpj2NzawljDa9dvUjcNVdVQDAYM8wLTNYcapUjTlM2trU7CQjNfLnDt7Z1evmMci7EGopA2apE8FAp67Tvuq4StrU1JQy1nBN83QbVYAyE0GB3JUtvVOQLz2XyF8kis0JPE5IQzS2hWInXVsFhWLBdSCL/vnnvZ2drh2muvMShL3v7E22namuViSbWsqJbyv3ceozWtk0bCPJNaR5ZlzGYL5rMFmxtj8iylbRugp5MQB3J0fNClugTJFaIny4RmRiKIsIpWrLUrSPF0Ose1UlvZ3t7hwQcfIkkyrl27wWg4JMszyqJAKyUNk0qKk41rqRtxvjF69vf3uvRcTW4MKkY2NrYgRpEd6HH5UVQHW9+1mYaICpLCqJqWZQc4OLfby0KfovQymcBHlImrPowe7trgWcbA1HssntYg1C5GE2Onohq73g0XUK1HNR7VBrQL2AhJFEQiUZEbjQEsgcQFbAiUHhIUORqjEpmVh4hrPcvr+9i2YTOKZkwMgkr03tM28y6qctgQKXwgbcEESEKDrT1t42mio8aTGY0pSi5tbuGMYhECTVXhmoaoNSaxzJdLSVcp1cmXG0JU2CSjLBU2sSilWSwq9vb2mc2XJGnK4N8+zWI25+oLL3TAmYbJ0RFpIqSWwXvqppFUtzGrCKQYDAkR6qZlMByyubHBzvY2O9vbzKsKa1OsMSRpik1SbJIIM/ltbHeMY7H2hL9HEFKIEJXwQJCkKVubG1SLGROtOlx+Tdt40tQQvBSkk1QQIyFE6mXVpQIiSWLI80zmayHi6pa2dYJ+qRtmsznLxSFJkvLY295BWZZcv3aNoih4/PHHeerpp5hOJyyXC5bLJdVySfCCPtE0RBVJUyF7zLJMGFyPj7iws01ZFFSLYzkO23XGa8VkMuXo6KCLvhzOt4zHI0ajQUe4F1eORWu9qrG0jcM5T5qmbG9tMx5tktiU69duEi9FhiHCxlhQYVrTSsEK1zY0TU3TFUEPD/flAalrNgcD8iRlvLlJ9IFmWa3o80MQ8bPWScup7mVqvadqGpZ1/RW6a87tzWxFC9KhnxTiSHrtoxiRNBiRZYxMfcQSaA34dccStTgnIrQBZTy6cejWo33ExoiNEFyLRlOajERHkqhRrkG3nsxJ9LJpMxIUiVJE72iawNUbt1CtZ5ilWCMaQXXV0DaO46Nj2uCoaUjQpCgGqsAqI+qwNLSLBS2eRnmyvMTahK3NbSoC1fSQqmlYeE+xMUYnhvnypO/KKk2iDUWerwZ1YQE3LJcVTes4OHiWqqpwjUz2nHMrxvBrVyUNvlzO0VpTlqVA8bsaC0rx+NvfgUkSGue5DIxHI7a3ttjZ2iIeHqG0wWqzSrnlWXEON/7lsB5B0fcjASTWsr05ZnJ0C2sVCoeKLYrIcj7h0898kp5a5dLFi+RdikwrjSEQ2oYWqOuaxXzBT330Y8QQ2RxtUNc1IQQ2NsdoZfjxH/9RirLknnvvYb5YCBrNN8QYmHxij0gQxm0ViMGxOR5KsW8yo61bmqqiSC333HWF4Bumk4bgahJrKPICa+XmPT4+5LXXXiNJND446roizxO0HjGfz2hbh7XmpB7U9fAoJSiaixdHeBdYLiuuXn2NX/zFT1DXFWVZ8Dt++29lY3NMXmSrulTT1Li2YTgoSaxlc2vMcrFkudAkaYbShqpqcK1jMV92PGPSMW2TBGVTMJo2gI6aqCxHkxk3bu1/Be+Wc3sjC66LWCKIlJY04sVwgmIKEVoFysIiKlKlmOlASmRsxQGsWsE9An90oJoWWkt0FtMmJAoSH7AxUjQVcVkTFxXzG7dwszkH+xOsD5RekUZIA5jQYGLkQS0z9RSDCRodFOgckoywma/0L3q2f9P1jNW0eAW1VdSZocksU6tpE4tuHbP5hM88+ymOXeA4RJS10MlmKAQuJEhNKNIUqxU+SNZge3ubS5cvcfHSJRn4kxTdsXbEVd0JTCJ9QXlWYK2hLMuVGqx30oTatC2hbjicTPAR9m4dcnBwSAgwGm1Ib11icc7TTOcC1DmPWL401jegyt9rcr3yCVorsjwlsUbggPGk7tLUjrpayIOjFKNBKbMrZUEhTYPey0y8aairJfv7t9BKMyhK6rpisVh0kGPFiy+9SFmWWKs5mhxzPDnuNFoUy2qOtYrBoKBtKrxvAOELWy5mxADWZqRJTplnVNWSxrW4piKkljxPVsJBTdNQ1xUo2zEfN53oVkvbNh0TgEVrg7VJx02kUNqiMYiMsgiDzWcLjo8mHBzcIs8zlsslZVmQZQm9nmtfw0qTruCapaIuaIV2RikRL5OUm3Tst65nXzXSCKqlmz8qjTKW1knUcm63ofVNx+uvrnbRoyQjQhXvlKI10CpFRaAm0CotDZNGobz0fUhrRxDdFO+lEO8DJgSSELEhkrtIqFvCsqaezfGTGW7/kNg46jZIBBUVKC+9VDuXSJTFhq4yGcFEkU+2iUUFhQ3qBBas5LgrleAMVInBDzJcmXLd18xVZOlammXF5HjCkY8ch0hQmqjAddxpthtdVIwUVlBfzrcUeYFShvHWFmiZdGljiVYAQsa2q+toU+EwS4wV6pmuJgrgy55hPeKCtBhMp1NaF0TRU2nSxIgsACIL4IL03oVzx/KlMR8FT647nLh01vYscw5FwKQiluV8g2uWNPUC19SCcHItm5ubbG5uoaKjmk+5cXOfumlYLBZsbW+zubXDxsaYosj4tb/2Q8znc27c2OPFl5/nqU88hXc9FYPUY5599lPSWe5qvGs6OhSJpJJE07YfYnur5KUXpywWC55/9gV2dy/wa77260isxhi6bv4Fn/7UMxir2d3d7vpWZNa4tbXJfDEhBNHhPjjcZzqbkGUpSmn2D/YxWlOWA5QSHrRLF+9CKc1P/uuPcuPGTZ577gUefuhRnnjindzauyGFf2U6Ej4hsjQd2sQYQznIu0hIYM9KKYw1wmNmc2JQjMewWFQslxXFcIRNEoIWuYBFUzHKS8Zb2+SjEdlg8BW9d87t9a1n9TXaYKLGRLOSwPVepHi9EWoTnygqq5krxV67IJBQhBwAqzWZURiQaAXRSTEhor0ndS1GRzYbReYiwzZincLqjDjcIeoBweXopsUua0o0BZqhTUmUIjQ1eCcKkFGhg+xTI2kqgyLpit3KB9ooNP9NbnAY6iRBlSPU5ogk1hz4hl/cu8FkNkFrTW6R/pyyJGrDoq5RKFKTEp2XyC4IK/qilT4wpw35cMT2pUsUWY41lqRrXyCcIFd7xuV6WUm/mWtXZJk2sURg/+iYIsvZvXiZo8mUo8mErCgYb20ymS9o25Z5Vcnkzlg2t3dIktsbaXnHOBagm4kguPXYNbOok1mXEMHFTsBHlOa0Ah89dbWEuEGWJqLbGIOo5sl8u4twhC+JGEkSS9qJeDnXMptN2N6+QJ6VpEneRQmGSEbEE4IU2JX2JNYwGOaMRwP5PLQQPXmeYK2iqee4pgZlaJua4NuOvsV0tRJH27ZYK7DGphUJ5D6iaJqqgzECSOd0VVUdrFmRpofEoDg6OmI6nYnipBaaf5Aiouq637wXKm9AGkN1lzNHIqa2baToisCUtbaCTrGGTu0VYxO0SYSWI3i0d6C0SKw6R32bI1h+tZoxkgCzxnaORXdZpSD3Ui8spRVRKxyKFpj7hjxGltFQKU2jDFaZFbJSQfdsdSRGXU4t85HcR4o2kPpIGjXWpuhMEfMGMFA50gBZCBTKk6DwzktNFdFsUVoLxRBgQkDHiFnJE8tyQcnkqUUJfVLT4qsak0RMjMymU6pquRLs68WzogZ5sIS1GCMNzkobiAHjE9CaunUcHE949bVraGUwWrM1HFBkGRvjEUmakqYpy2qBc5E0ywnd+isdJC3PSJZlGJtQlCU3Dw64tX/AdD5nsVyKBEAIApZR+iR1dl5j+dKY1id/GyM6Cx2NZN8qDCDqh66VnpUYyPOEuGiZTyaoCxcYFnkn8hXYGJa4PCPPM4qiIDWKarGQ7ShFiI7hqETpwGIx4+u//hu4//63dtTentlsRpYn5HmKTQSqG0NNOSi5554rIpjkHYMypcwNm6OHUSj2916jbUTUqxgMsDbh7nuuCD4+y5hOJ7RtTV5kGAsxyuBeN4aqWlJVS0LIMUaTZRlt2zKZTGgaR9t6XnvtBm3juXlzj6ZxbGxsMhyMSNOcyWRK21RddKOFX637Z41BEaldwHnHZDHrUG41o3IkEQ0WrSzWZIBF6ZSoDWhNVg4x3tEQ8SjmVcPhdM7B8eTLfbuc2+dhmRX0ldUJNmpMVMLNFT1RBXkGNASj8FZTIemmveWCEC0jIlaLYJhVdEVmBVphVC/hoDAxCrWKh8IFRnVLGTVFNIzzAUkSUXXEsWB+vCBWS2IlUUNUiqKjaEmSBNspp8YgtaC2qok+SjSjDVZbcmuFPdkYlniqxZKFa5jPpoQLY5QO3Lh+nePoScclsa2p2pbgGuEfMDIsuq5nziTSEGoAZSVBdjyf80tPf5JPPPMp9g+PCCHwjgfewt13XeG973mSnZ0dhkXB3sEBVbVkPB6T2JQyEcZkpRWzhQB8Nre2MdaSFiWHxxM+8clPMlsscd5j8xybJOSDodBAOc/+4QHO395Nx3eMY4kKiJLbN3Lv0tGsIpBXD6GrlcSA0QprNNFLtHKwf4t777mbNLFUdS3ypl2Fzbc13hppoLIJ2hhMYqEOtK4izSxbO1tkeYo20LQ1Wik2NoY411BXCy5evItyUFAtJqRZQmIVdd3SthWuFd378XiLEKJ0H9+6yY0bezzy6GNsbG7ivMPHQNVFJUlicd6SpoZH3/YwJjF4Is45WtfKwwpobVesxcFHnAt89KMf5+qr16QhMgTyPMN7cYRpIqSRMQjXmHcOZRQYSY1Eo8lMig1GarJ99l3LbFZbQ2JT8nzA5vYuWVpQO09UivHONkHBsq1pY6ANjrvuvofGnUcst6MJ1Fx6kgwKHeVvpSEhErQiJIrWIv+HgPGRCs8SxRLPAscSRxk1Oq6TK3a6RKGLiH3EzStc7fHzBhdFWE/ZHIsmSxJikZONR4TEEpIE7f2KtjUCla+JvkHIYtVJg6RSGLRIX0QhzVTekcUMqxTDJEXnKbZIqbyAVJoYqUOgbhra4PEKkSE2htBpn4QQSYwWWfIYcZ1AoAKCkrQbIUoDcIzcOjzEeYfRisFgQFmWHB8fgVY8+eR7KEzX7xMkPvJdE7e2Ukep25aoFGmekQQPzuO7Dm0XvKTPUk2mFPa8xvKlsxAh+CjqjApxKkF6KQie6FqhAg8eY8SxeOdompqDg32apiZJrMz4ve8kdQOuqXHG4IwhtxZrFGlq8b6hbSvpkdneIMkT0EIdn6YJo/GIybHUaDY3RmzvbDI5VmgVMbpTXmwWq+76wSDHO0+1mHFwcIPnnvsM991/L1tqQyKtCK2TwqNNDIk3pGnKu598N+VwQMxOaByqoyNC21KUw5UOi0ITAjz33Eu8drVzLFGRpp1jmU5FbtmKQJPIDLSYRMu1UNJ9b60hBCOUGZEVKMDHKLIC1pIXJRcuXGZ35yKzxRIPXLj7MsoYnIocTSccTI65cuUu2nPHcluaUVpQkUqciu4mEDoCJiFoiVRcEokm4gg04bRjqZSnUo4amdGn9KJXnaJpV3OIgF8s8csWN23waJwykIMxCUWSyP7HQbjFrMW3jbATxyAp1bqh8Z7Ge1EoNYbhYCypPJsSnMe3jnbRgg8kIcFYwzBJMUVBMsi5UR/TVhVNjDQxUDc1rYbQK50ZQ0ARgkCtrRGqm7ZpT9UkoWfLCFKQJ3J4dMx0MuH48ADTNVg631IOBjzxzneQ5CnBs3K4PgSikpRkiNC2DVFBmmekwRNbR1NLT1kbJMVuOjaDc2niL5H1M5ewRggXO7lPpQ2oiNKaPCsYjzYkJCfwlvvu5YUXnufpTzyF9575fM5yKZ27u7sXKNoM55ouxIY00VijqBdzfNswKnOsBt/WLGcTloVIFBtrqJuKvMwoBhdoXM3x5EgoTwg0QZTqjDFkgwFKwf7+TRSQWMW991xmOMgZFhbXzAhOZFDTroM+oDiuFiwXM55+6hNoY1jWdYeh10QvTY3GJsLU3HqKvCRLM6aTqShC2gTnAnW1xCoYDQr2b16nIWATTZrJDaqsEAkuFw2tb9Fpl2OOMJ8vOTw84GD/BerKYUiwNqUsxtx15V4uX76bpz75SY4mE8rNDdI8Z7A5ZlEtmVdznvrk0xweHn1lbppze3MLgdjVF2IUuLGULjVWGTCamFqUCWjVa35Day1VNEy1otCQK8hAZv0KWqACWh8JbSA2gu7aGgwpTENRe2zj0HVDdIFgLDEp5ZjyVNiENagq4luYLyu8CugyIVMJmepGAwVBtbTR47qiuE4VaZJhokYFLS02nT5L0IFP37zKs9MDGu8ICloiaV6wMciZhEjjHcokgobzAgJYUddETZLlEiEZxbKuqeoa0ymnZoOBRP2JxQFthKb1wgJQlJgsp21a4UVWGpunIimOZjad8vwLL/Dqa9c4nkwFrISci9IaFTtNqhCpW3eOCvtSmYo9ImvVLN8hMDqomBKNaaV014RYYI1ie3uHW7dudaFtWKFeYozCKhotadKlv7TGKGn0Cq4lBt+hTyIxuFW/h7Uymw8hkKRCkTKZTJjNFWWRSaG99SiCFBqNQCOr5RKtFHmadcythiTRxOBWnEuJSXEhigxr29K0LXt7ewBUVYUPQqGfpbkU9Loorm09g3JAWQxomkZ6E7TGpIYiLxmPhmyMh2xsDIkxUA5KykFOCKpLhSnqtupQLBI1xSg05nXdcHBwxHy+JLUiembtAhc0y8bz6WefZf/wkGw4JC8LNnd3WDYVy7ri1q0D5vP5V+y+Obc3seChl9WFFaxVdekxpQxGWQLSm+GDRseA1waHptKKSsGCyFILCCY1ilYrKZpHwCu0k56QzFpS44VcMga0c6hoUD4KLEBpUXi1FrKADpaoAr4Wknpl9Qpt1eVpCV4kH6LqFFS1wugEg0E1iqDAq4jD04SWSb3guJrjomzTR4TTLkmgaYhhjc24vzCqg1JDlyrsjqMbk+R5UZgkFa0UrVZjTRsjbQjMlhXKJCsmZLS0BQhZbqSuG27eusV0OqNtfc+kK+SgIsAi7BuqU2c9dyxfIuvyt1pGfsHaO2E7NtYILf2iYTarOJ7MyfOUqDTPfOZ5nn3uRW7tH9O6SDkYYYzBe8dkcizEciZSlglFUVIvK5rWS+dv8CwWS5RrSRRslAXb4wFZnnQFOEPd1Mzmc37iX/8408mEb/2N30xR5hAco+GA0aBkUdUoIsNyILxlbUOeGoq06EgrA9E5Uq3YGGYcHh0zPzqiqZY0rePVl14hzXKG4y1efOklXnr5ZR5+6BFGozGz2RxQJEnKdFqTJjOaqsUoTZJo7r/3Pn7rt/8HFHlOlmVc/m3/PoPRgMGlDYget5hgUmFwPT6esFgseOXqVRbLisl0hlaGNCkJEZS2vOOr300IkRs397lxdIvPvPwKdd2i0pRyOCLJUlGldCJWZnVOlqo3/23P7StioV6gjEWXBUscixionQcP22ZA7mEUUwyanEjwCRGNt5GlVhwY0ayfNi3OGsbGYkYFXmmWKAIZqctInMEC3tU0TUWoFgzbSB5hFIUnTB0cywCaJDAqYWcDXVloa5JUyFZ9CPi6IdQtZZqTGCPIMGvIipLWO5yX9K5Xjjga4KNiHgI3q2P25jU20WyNxtSTCQsiVYDQOMJSAC0JmuilwTdRFusUtA7b9dZEF0AFnI4kWMb5UK5lgLQcEDq4vQBpWrIsYe4Df/sf/EPuvvsePvzhDzMsB5RFIcSWjRC+HhxPeOaZz6xUWWfzJSFERuMxRNFWQolWTqalR+x2ttv76NYsivZv1xQpsGKBYUWauhFosU05ns54+ZWrvP3xt7G1tYmLjvHmPoPBmCTNJKrRRtJqvgWlMEa0WwRWGzq4pKjRpdZy16XLBB958MEH2Nm9QOykhlGa6XxOnE1BaVrvWVQ12hgSa/Ah0nrfFUn7xk6/0lkwCokWVh3PDt+KMmOaJqRpSus8Lzz/IjZJ2b5wideuXuPatZtk2YDhcMJyWWGMpSwHQvmQJCyXNa7jKUsSS1Hk5FlGlqYURUaeJTTVAvDE6FFB0gZaC+dYWQ6IUTGbV1iTkCQpo9GYNHMSJWkoyhIXFCEa0kKiHG0tIUahuqgbvAskNqXXsTm328tUDCiCUL2rSEugjRKduBDwhC7lKpBeQWlpggq4rlEyVZCoyByPiZ6FCgQUjZKaXPQRHRUqKuo+Y0DEIUAcZbraTujQnV1NhiBRSNSQFBkmGHzbNef6IESXWqOIQpukNNZoUAav5Thrrai857CtuFUvuN4sWeBwJpLkFtufv+7rHp5An2GQ+pNWoLvGTOizJXEFRpVeFWH0cD4QYqDxAbTBZhpPwLceP19ycHTMy69e5a7LV8iLUuSQO3SX97Fj0rAkxq72o2JPEtqhBjqhr9u7wnIHORbfOEkrpSeHrJOEoBSTvT1sYtnc3eKlV6/xwz/y43zgAx/gnV/11ag8oxhv8rGPfIzxxjatCxLiG40xihA92kn3fVUtKbOCxApjqrEpZmh46wc/yNbOLpeu3E2a5+wfHMnsCcWNvT2u39zj7nvuJUlT5vMKrS27uzv4EJkvai7sbpElCbPjfXzb4Npq5ViyTGDDwXvaGJlOjrFpxu7uLlFZmtbzL/7FD+ND4K577+F4Oud4OueVV66LgJdJyPOc3d1diiynSDMO9g+pqorEJihgMjmG4ZBEw+HhHsdTzWw5QVvNYCwUMtYmuCDpr92dXbJswWRakeeR1mvuf2uOc4H5YonW0qS1c1H2P50tqKqa6zf2WFQVx5MpPZigLAYr7qlzu73MdG3sIXqcirQq0CpJtbYhYIOn9TVJEKoUnUSigUopSclE101GNEehoY2QuBy0pbUpVQi4xpHGDJRm4ltsdJRWYRrpxA9R5MAJdCltDa6FpcPHmqgig60RMQR8VaGSBGW7VBeqy2XJ+sYmmDwl5ClOa/bqmsNlzWeWe7w8m/PqbE41Tmkyw8ZOiQqeeVUTjMapSFO3+ADjcd4xV4hDURER8eqGc6mbrw/tkoZfVtKMXbmW0XDIaDjg5s0b1HXD9vaAg6Mp/+qHfpQPvP/9bO1cYFkLi0aapoSoun4Yi9FWnGYIAkiKQuqqlTh3YWc/hxt/SUxbs2IkFqegsdaitKIcDPG+5eDmHvffdx///rd9G5eu3EVUioO9PabHE7I8JyIFN6lpiJiQtZbBYEzdVKi6ho7JVIBmgdZ5tEkoByP2D49oGserr72G8wGMYVFVzOYLbty4ydHRMV/zgV/D9tYmRZawf+smB/s3CVHhQ5RmsI7Hy2qJiMQUWS6yx63zNH5JWNY0bUs5HPDdf+h70Fp4xF559TVeefUag+FIlCLrFmsto+FQdFrqBn1sVo1UPkSyokAZTeMcfjYHDU2oiU1k0SxFR0VLhBUioAx109C0J42V4nQ8w2GGUrrLF0ukl6Yp2lguXhTI5Gi8Qdu4jsTT3/bNXL9aTSeaqJWUNqLUQYyKRKWgRynGuCo3WK0FkWmk+OC8I2LAKBrfYnxgquZokxAMVD6wbB2oHJsYginxqUXHSE5L4xqqCGkIJD4I/b33xLaVOCrp8t9K7r3QNJjGYZzUU1RH1x9jJDYNtVHUFqoYqa3iFbdg3y941s3x2wWb92zzyuyYeWjRowLTOmgbGueZLT1044pzLQqP8lo6/ddqu9KIfRKtKCVcYkEh44qiE/hynXqt6BR51+J6tdu6liZlLT15uqvrCvuzgCRUjGjVQZNDIDiHsULAGYzB3OYSkneMYzGJxVW1KLYllqQT+DHWUA4HzKdT9m/ucf+99/G2Rx5mvDEiAPs395geHZFmuWDFm06DvesVKbWlHAhJZAgR0B2COeJ8pG4cShuyvOC1l17h4PCIZ597ARcCOrUYK4PyzZu3mC8XvPd9H+DSxQuEZsknP/kUk8lxV/iUGZU1FkhJrSYxhqZpBASQJDgfaJY1VdNSNY6oDOVwyG/+D7+LNM2oZgueeuoZnv7kpxmNxmhjmXTNh6lN2L91i/39WyIxgNBw+xDI8hwFNM7hqoaAR2UKHxxVUwt9t9KCqw8dl2AE5yJaW/I8ZVm1hKgYDIaAFo2ZTgQtTVNSpSnKAc4HqrphMV+yWCyZzWaikXFut52pREjpVCetYoI4F6lKd0J5QahdUAqtE4zVSBN6EPZgJS32bWjBO6ZRY2KKTg2Vdyxbg1UbYBU+HRDaFK0UdbukWSrqRlG5gHERrQPKOQIOF500KtquETp4fNNg2oh2HWCnI9+PzuGXFUsDUwNTC/MEXgpzbroFz4cFF3d2uHjfPbz4bM1i7kkGOaZpiTNNs3TM545yXGCN6QZ4YaDQUVLvJvYxeO9M1FoRXhyDMG9I+tl1UOGiKDDG0FQLnBOl17aRya1SUjM2WpL73rUCqAhCuqa16lhEAtE7lDEyGbX2HG78pbQksWxubUidRSvapqapA2lquXnzJv/yX/4g737yq3jyya/GZBlVVfGLn/gEt/ZuYpKUNM1Js5KNjU2pqwQRD7t1cEzT1LR1TVmUEgklmuCXHE3nPPf8y9zcnzBfVtRti7Ipvqk5PDji4Ycf4YEHH+LpT32Go+NjDKI6qdMck+TYJMemooS3qCo0gdRqlrVj7oVqO8ZImkSMtZSjDWzrSVuHjwJL/Ikf/XGc80yn846fq+GJd7yLS5cuYdJc8rCt48UXnueFF17g8PCQxWLJdL5gUdUYk3Dt2mu8dvVV9vZukmQJv+cPfTd5mbOYTWAV9EtT2HS+FPp979k/OOTg8IiNrR2U0tSVSAn0ErYKOpoXaS6NMZLnOWVe0Ixaqo2N2z5s/1VridCEaG1JVSAoTZIYMJAqjfYIe4RSKCOTl2gV2gSpKwSHSlJ0YmmrCk+QJssYsDpl6mHWgA07BHKpXyhL0BmDTEFpmVdzYu3IMCQ+wKLGW09rHUZHdBBgjkKRFyN0YqA0sHDgomCboyGkJWQJOre0Q8VMNfzSay+ixjmPfsP7ScuSNC94aPR2Li4qfunTz9G0nt2NDUKY0dSO0ohcxaLxhOhBSbOkUpqgVSe0J1JoAkQN9LIdKNCpXdVqe/G91jU4ryjyHOeEMipJjHD9EYhBU+Q5eZqK+LpraV1DnuUYrYnByzjVNtgsJU+NOMXbPL18xzgWIWVUJGmyikmbOuKDh2hYLBY8+/zzPPjwA0JhrS0+RK5efY3J8ZEI61iL6RQOrTF4V9O2LXVbiahX7LtlBOLno6JpHZPZnKoNJFmGNgnD8RjmCw6OjrtGwUvcddc9FOVA4IFRiX64sTLoKiO4+ECneqHxoSv2dYywPkRUVBLVYIjKEJ2ndZ6rr16lrhumswVZXlIUAza3tti9eIlyOIYQ8XXFdDrl4OCAtKO4d10qz/nAfLFg/+CQq69dIytyRpvbjDZGXXNXh9NX0i1tsznOe9rWcTyZCaXLeJs8L5hbkRBwHcNxDKCN7ai9hRgvxIjzAec8bSPpuHO7/SxqEelSWoS3EqJIUQDWaFGRVJGoI0EpokGCBNXhcKMMqMqorlfEU+MwyhCUp+kaKl30mBjwwQgwAEM0KTozOJY0AVAi+4B3gu1VEeXiSnpCGYOxmUCRtQUdiUg0FZTCJxkusbTWMqdlGgIHbU1ucsqLW1IvtSlF1wjtO2LJQVGS24pUyWCoY0R3XGmBSE9AFjSgxLkE1cNRYk8kJeg0ZbouCKnjaq2kpktE6QxjJJox3aRMK+kb0l06zSiFi1H49ogYBT6GDmQh7xNryNNklZW4Xe2OcSxNUwPScW+sNAnmg7JDTgQm8xkf/7mf4fF3PI7v7odqWfEjP/oTaCLve997MElONAnTeSVspW2L1po0G2JLS2KtDITO09Y1dR3w0RCwKJ3wVV/9Hi5cukRSDrh69TV+5Id/mO3tS4w2tnn3e76G5XJJPtpAJcL6qnWGtTmz2UJkkKNBGYEK5lYarWLXiyPd6ZFFLWR8UVuBHS8qJvOlpMlazyNve4B3veuruHT3fZSDgUQaKqBMInQ0NqV1gabxJGmO8/Diq69xNBUp5UXd0MRIwGLTAaPtnOgcofXoJEFpw2BL4Z2jWlZ88plneeqpT/GbH3k7Dzz4EJtbO5165DpORl7Oh661KIhGjDIrktBzu/2sQWbeiVFYZSVvL9lgQTFqj8ODingd8EbqAt63RN9CbAnK4bWntYL4ctajrcNaxyJ6quhpY4v1DudFECzUliwdMk4z4q0GpxVmmGG9g/mUVFkSAjQR2khsKyGGLPUJjZMT6eQmTWitZZGlXG+WXJ9P+aVrr7Hn51SbmlY7nn7xBe6/937u273IU5/8aa5fv0HmIoMkY1iOqPWSaQNMl0StybMMrzWtEUkAb8R5RaU6BeZACH4lj6yD1IesE8XJ1PaE+6C1dNlPjo/I85y77rqLxFqObt0SqQ2tmU8Oaao5gyKlbSKuDRiCAAa80DcNs5RhnjHKMhEK+8rdNp+X3TGOhY7NVGkliKzgu0KawmqhLdnZ3aUcDDsmUIVNEh5++BGmk2OuXb/Jsqo4OjriscceY3Nzk9C2TI6P+cyzz65o6h9/7HHGww1+/md+hqZp0dowSFIGwzGD0QaD0QZJMWC8sWRn9yJ5McAH2N29JM5DW4lYFKsaDcpgjEAupSHNCBSzp0uJrJhLlZZoJvhI6yNRae65/y1UVc21azcoinJVuFdKd+tK174xCTaRPhIfAsYmNM7x6tWrRO9RxkjEFFW3X4XSwtaqrUMpEToyxkhdKSpCVCwWFQcHh2xuHXDp8l2kaQboVSMlqzRa37caV3DNk9Lvud1u5kLEaNEd0b3Ql4odmy9ENMEIEWXsZu1eCdyXTn0yxoiPAa8hGtFtURaCDnKP0w3EBKlQxC6i1ZpWG5YxoHzLodOkwZPouEp1hyBkmPSDeVMDDqJQHSksk467bOIqDkLLhIAdjyhURlR7tCGwrCoOD49IVML06Jh6vkQ70CqgW0+OYpQm1MELzYr3q/FAIGHSwR9Qwi6w+ifMBfIEdBG8RhjKnUh1WKMlOxICRZ5x911XGJSFSJGHFIjs39rj6PAAgu+iE4SaSilBg2lFliTkiSVNDN658xrLl8p6KhOtNYvFnMVijjECGx6Nhmxf2OXDX/8NPPjII9i8gBgYb2zyx//En+DjH/8p/pv/5s/g2haN4q/+9b/G+z/0QWhaPvKRf8Pf/bN/jsPDQ+bzGX/77/xdHnjb4/zFv/jfoZTm/e/7AFcGm9xz71sYbu6QDEagE4YbWzz2+DtIs4zFouatDzy84gwKXojlqqrh8GjKxd0dsiylruaAPHDetfi27aSF6WSLJU3nlhXLaknrI2kx4Dd9+29h/9YB/+yf/BOKwYgkLVDoPhMBKLS1pHnBYDgmAI3zJHnObLHk33zsY9x3zz3cc9ddKJNK2qGF6MWxKGNRKhE9cRc7lJgiK3IilsWy4ed+7he4dv0mDzz0KGna0e+H0ClW9pouCaupVD+xdJ4QA7a4vUP3X4229AGLxkZNiiZB9Vha6PizokpolSdohTNRuvC9E/EurQlEmuDw0pSFN5poFCSBhtgxJHsCnsQkqKhwOOZKc6jhRrOgXU5YVJrSKDY7nSJjIrUToElSZLjgmS8nMilCc/Hu+0jyglf2j5hUS64dTmnShCZNueftb+fugeXZn/0hqYnOl3xm71M8Nf9FYisNoMYn0EIbpoyA+zZG7E2nLNqWWDegFT4YQsekHozUWbwWhgIQZyf9dBLphTYQtfTXLOsF0+mMi7s7QgJrDJcuXuT973svvm1pmyUqFoTW89Qv/luODg9pG8mk6OgJTUskolFkNmNrPKQsC4osYVYtxDHdxnZHOZYQAk1dC8S4LNFaoIFPPf0UdV3zga/9AHfffY8Ui6OkZcYbWwyGY0DjXMA7T/CxgylqxuMtnnzP+/jUp57hhRdewCQZSif4qNja2OTd73kvl65c4cLFy2RFKQOmD1ibcvHyFY6Ojtm7dcDm9g7GpNAL+1Qtw9EG97/1QV5+6UVcU/Pud7+LvZs3+MF/9S9495NP8uST7+4aP6MABrpZ/rPPPsfeK9d48NG3sXvxIllWkGYZ27sXyfKCpnUr6o2VKcVwPOLi5ctkeQFa47reAJMIC0Hrg6hLJonQSWAEJynwFKEPjBKKi7hXQlEO2Nza4eVXrnJ4dEy1qCjzwaquorWsvvIoscsx05FaGpkLn9vtZ20QXZCIQUWNjcI2QYxgOlLT1HZpoCCNL0pIE03XPGyMJSgNiSKiCNYStcEZCFr0haKS9KgPnhigCg37rce5mmtULHXN9bZmZFPu2t4i4AjRM11WNL7FNTOa1nM0bQShpRXv2XwrO7tj2t0Bsa4xRxPmkwn7kymLvddgqsmTFFykOpiRmYRBPmBez/HOM8wylDLQOgptSDNBd1bOcWM2pSGiY8QGcZAqCogBrYgKcZ7dfS9wYUVi5RlaLhcoIoMyFwXYGHnisUe56/JlhmVB9CnBZWgVqZqKvZs3mB5PcE3VwYwF2m20IUtSaWxOLakWYERiQIXb+5m6YxyLNOUGqroiz3LyskQBi0XgmWeeYXNzkw9/+MNCre9lcAfRjB4MRihtcR6axhGcOJYQYDze5L3vfR9V1XD9xi10khF1QsAwHG/x1e95L4PxBvlgKN3AHWNrYhN2L17i8HjKrf0D3uoC2ljo8Oh13TAcbXDfWx7g53/+Fzg8OOBbvvU3cnB4zI/86L/m4be9nUefeJcUK2MALT0hoXW88NKr7O0f8o0PPcKDDz8CQJJm7Fy4SJaXtM6vOv9XM0wUg+FIiCyLArSRVAeaNCuktyCKk0myDK0TUFaiHi1JdWU0Kkba5VIKulZTFEO2d3b51Kc/w2vXrlMvK4L3HShBc+Lbep6djhxUCw7fmtsbvfKr2VoEThs7CS0TlYjJBVbaFDbRwjShgxTMlUyCLIpcSxthRIGxoBQhSfBKUQMYjbYWtMzufXD4AFVs8aFhFiJXVc3MNDTLYzbUgMX2JWoXqFrPvqtZxiXTZsGyChzMPVYJievGhsXdNSa3ObFusftDFi80XD+6zq29Cm0VWZYQvef44IDh5hZbmyPaoyWt8wxHGURFVTUk1mLylLIsaXxgsVxSBY8G6iAFfbzHCSUHUStBi3WM4NLPAonVBOdZVguyJKUsMqaTOQR45MEHuXhhV7gEu476plrS1BW39m6ynM3JEulP0VphbEZqDYNCGDPyxJBoMNGTaND29n6u7hjH0rYtKBiUJ53cPgZsYvnABz4gJHLIIGm1WQ24QrmgWFbSCOUiRG3BJBg0Oxcu84EP/lpefPkqP/XTPwcIqqt1EbSV9FcqtCRSsJOOf5TkpKfTOa+8epW3v+Ndq2WUMpTliIPDI65fu8lovEVRDCkHI6zNaVzEBwXYrv2Z1bisdcre4TFPffIZZrMFoGiaFmMS7r7nXsqiJM1zQBFClBlhFHZjYxMGwxER1UU1ire89a38/t//3QzLkiIvaIPHJgmj7R2itjjnV5TRNhEqiyQvOwcdefTRt7G5uc0HP/ghALZ3L2Cs6E/EjtCzj5yUFlZkfRLGnNttbA6LVQnoBB06J9PdD9HKAKetIRphBgZRXS1sTqo0pbHghPYFK2JvMUnwMdC0DmsFBRWUiGZF3RCshtIQtSFqzeiBu0kWm+wf7JFub7L9nnexd3TA8ugWt24EZssErwaMRht83QOPkGlNpjSDzS32CTz90x/FN45MWw6PDlmEmixYtFeEaU2Mge3hCJzn8NYBo+EINVQcHU2JMYoSbNfh6H1LDHB5a5M2BhbeU3lP5Rxz39KEwNIJEWTrPejQNZh2DcmNQyH1kDSxJIlhUCQUeUpZZiTW0CyXAiH2HoKD0DIsEnRIsHT+HMXOeEBR5IzKgQwNriVGh3eKMrUyMbyN7Y5xLCGGrmvdrgZhAG0MFy9eOtUJqzrm036ZiFp1lcduhhWRGyIrSi5fvout7R3KwVCK7x1FA0qTpNkKDBA7yaF+AAXFsqo5PDxaaY706xmrqaqa/f0DBoMRaWKxNkNpC0r6B+h0VGK/YscFVDcC821aJ7RJAYyxjMebK6cqRXK1OtYYpWhorcA2fZB01mi8wdvf8U7yNCUxFlvkEll1Dil2jV10YAJJbwlaLXjP5uYWZTlgZ2cH7wW6XDdNp+kiRyLryUGpns/o5PKfJ8JuU/NByctDDL3cdweZ7WDxQrbKSvRNKbA6IdFGZBlwuNAKKaLRBCPMFb7XO+rYeaMCpzvm7MQIEEArdJmRGCiUo9jZJtvZwRDwviYuNyBNsBaGO7vc/fADJCFgfSAsGhbTOddv3iS0jlFesqjmuNiSdNxkwTkUYLXB+0Dj29Uz3kbhHRMknJdUV5BzLLMEFyPGeVLnyZREEo336K6D3jipO4l8sSDGGifN1NZojJYU2WhYMhwMyNIEowVtKY7FoZCUfZoYfGKxCmzHUVjkKWX3Ct7TuGYFmEhMgj2HG39pLEuzz/pMS8srK/D961iPUEqzgqb1+NCwrGoWiyXloETbhDQvePRtj/Prf/1vYHf3AqClDmEM3nuUNl2fRn8MIvLjvOfGjT2eeebTzGdCDa+NWSFlnnv+RX7sx/8Nv+t3/g4efvhhkixBm5StrV3yXDrY6Qqmru7ST2lKlpWMN7bwLrJc1BTlgCwrKcsN9vf3OdjfZ1BuoHOLC17yu2km+3UO5zzeR5I8pxgMpCHUCkU3nVgRWnd9QRbvnJxndzzCQKAwNiU3CWlW8NGPfZzXXnuN8XDEhQsXeNe73kVRFGR5Dn0D5HrTVgjQ0d50Up3ndpvZohYCVzdzmHzIRj6kyC0amFPjiStVxoA0/FmtBfRhEvJixLSdsaxrsjQBbZm7Fgc4nZCYTBQiiwKbZVQdMaVzNW0VqBee+f4xOije+453UwwGJG1CGgtKu8mT73wraZaiFWTWsJmUHLz0CtdeeoXDV1+lnc+54DXRa+rpPrqtsK7GJmBtQl6UVFXDzVtHjDZGDLc2OWwrfIykl7do2pbDowmpglRF0kQ4yIz3JBESYHcwJM9yaicCY7cmxyzqioPZjEUMQklTaEl0RJnc5olIJ4cm8HVf//Xce+89bAxFq4XYYogoA4RIomFU5BRGM8xzNsdDNkYjFosZwTsSE4gqoBKZpmmlyGzkNvcrd45jUWdTK5/HWBWJHWpJk+c5ly9fZnf3Ars7uyitaRsHXZH64qXLPPbYEwy7Qj+qz6F2CBAJRVa77mG1wgZcSkNlCKuIInQaC7PZDJuklOUA5xryPOf+t7yVjY3NFaErXfRE10fgfKCuWyJqxbSqlMJahfeB5bLGr+sxqJP/lBLHcKLXoKRR04j8KR0EVKClHYRbadGQ6d735yrZRIkAe8x+URTkeY619lT0RIwr+Hd/vWIMaLTAr8/ttrPGi9hIVAJBJypCF72iYtfPIgzCIXiZfMQIJN2ySlJJSUaSFpBajJMmWwPYNMWmKSFGWu+IiXSmh+jQRpOmljZJMFGTZTlpknZEjAnWpORpSZbnBN/imobr+9eZXr/FdP+YsGzRbcBGedZMiGRaQ2pR0RNcJ7ERhf04ICJebcfkHFWk1eCswiSKYDVt8F0PlkX5SHAOjEVbS2EsmTbEwZAySSXl5Rxz56RmmRpGg11sllKMR3gnVCw721uMhoOO8kwaHWMUSLOKAi8eDYRDrUhT8iwlsZrUGoKKJEZJO0BmCd4TnKTQwm3eH3bHOJYv1ryXG2VjY4vv+I7fznd8x3cwHA7RWnO4f4C1lo3NTZ544h089NAjlGXJ/sEBKCu55ySVSb7zQuGgBNorTNaB7Z0dHnr4YZIkpa5b8lyo+b0LNE1LVVWrCMD7wPbOLr/hm7+FBx58COfCikjTpIXUNUJgNluwt3+I0oa8GLDuReum5ng67ZQqTztcpaS+4UOkdYI286GLGrr0YFSvU/RTgg7q03LOiVMyJq6cymAwYveC553vfCej0YjhaLRaPXa5uHX30cuvqihw5POE2O1ny8aDsZg8l5x9UNR1IzLZWURZSXfVIeC9p+3g+qNCZIvrpkXbjOFGSbkxhsSyqGZYAo5ImeUM0pzZcomrlpjNodAPuYYiG7E9HjEgQXnh3gKNsRlJkpOlLVqnxKhZzBr2r1/nqY9/nLxx5K3n7uGQYpBTHd+CECispUgtMS24NT2mqhcktiQqw3g8pMJxMJugygysZuYqXAy0ucZmhphaFpM5eE+ajgjesVxMoa1RdcXm5g5ZXrC7tUUTPBeWC47mM44XcxiWJIOSB9/1TorxiOH2Jq5pcW0rgn7G4JoaiBijaFuhj7IqooLjnssXhQYmiJxGdA1FolFJQpYYlLKYMmU+m7FoKlzjVpRKt6v9CnUsJ5GF6dJZR0ciG1yWJcZIHFkOyq7QDDaRAT4SaV2L876b9Ut8EpFCn9aSZxa6cMNdV67QvvOdbG1tkiT2pNYALBdL9vcPcM510Y9e1Twu7O52zYpI46RSqy710PV/9KF1n57y3uNah2tbmqamaRqSRGpCwXtU18mvtcZ0CDWl+5pLXH0n+5BZab/9dc0U0ylTKvqaFezu7lIWBeONMXmeg5ImztCn1k5tQWw1pzov5N+WVg5GpJ1SoQuRxnkyrbFaERMhTKkWc+rY0MaG0XhMmqbQQtO0+EWLUgLTDTbF5hmbG1tkg5LtixcYZAVlmvHs889ydHzMbLZEG81OVpArTWgadnd3yJKMfDTAphmmzNjKd8h3N9FpKprwSlMv5mRlQZK02NbTJqI6OY8NRIfVXnpKPKRWYM6qY8wwWYEKNTG2PPD4o4x2ttDDAhc98+WCtq5pq5qrz71INZ3jTMRqy3h3k8JIOriJLW0V0EhtRWcG7S0qWJauploEbty8wYZrKMdDssRS5ikqBlGj9U5oW4yVsaVtKIYlKrXkWYJTUaj/pWTD5niLPEsZFDlGK4zW7N28wd6Nm7RtvUK93q52xziWz39o6gdKGdiMEbr94+NjnHPyYHTLFeWAfvjTxqA7tmHnRInOd44ldv3jSquOzkS2bq3hypXLjMdjNjc3SBO5nB4ZsJdLcSxt62SA1obRaMwTT2zRyyOvgAT9cauOWbijRzkp0Eec81I/cZ6mbmjqmrRDw/VpuBPHIsepO8fS708co9CvSJ9J54RXg7/CdOvI53SOZYdmPGY4Gq22HYL0Ba2v33cE98X72G/g3G47GwxHaB+IrcNHSRUV1pAIcRh1aKgWcxpanHIMyksMygHt/gzXOhbzRmSAjSWmFZk2XBpvs3PpAo8+8Thlpw80m83wrWN69QCTpuxs7OBrYSveunuT0XADF61ET0XKRlGwledUrUzwrDFUixnFqMQ2Lalz+NBQec+CBoUn09KRG4OwlicofJtgkpSsHBC8IYSGRx97jLsfuJ/y0g5tcBzPJ+zf3GN/b4/9g1tUriZEMCZhMxuSKUuK4ehwQt3UoBw6TUiKITgNTlMtl7SuxuxdxxO4cs9dJFnCoCxYzGa0rpG2Aq0xMaKCJ7qWIktJrKHIUlolTtEoSIzm8oXdlZy46UTNrArUixmzme9ECW9fu2McyxdjIQQmkwlZlvEN3/AN3H//W2hbhzFmFUqGICkra+0ppEVfQ3ArtNfpnGaMkbZthXF5c6OLHMS0VgKzDKFLhUkKrXdqfWQBcYVga5oGEDVLOkbVPt2mO3CCUord3V3SNGVnZ4c8z1e1FGtlf76LtPrj7T+z1q6crBw/rLvr0DEW972Oa34GQChwgpDzeb8GMVZ9HehkW7FzrHqtRnVut58JmEMi4TZGagJkGpsYktygfCD1mrQYsFWkPPmud3Lx4iXS1hDaQL1oSUyGtSktiqg16faYJE+plzX1fMmh9xzs3WIxmXJpc4cQAoc3bgkbtrZ88jPPEKNiumwYb27yyGNvZ/+lQ/YPj7jv/vsZjUYMtOau7TEf/MB7GGQpgyzh5msvMz065OVnPa6pCKGhbpY0zZJRUZDoBD8VWqXmeMqclkp5FvOKxWxBHKR4AnVdUQwK7sruYlx8EF83bNmS3CSMkoLSZhQ2YzoVMbtrBwcczaa8dOMGzi+pm8jm5R10khCR6GNzMBD29LZFx4DpxgplFBgo0pQi2eDRhx5ka2PMEw+9leVizuGtm8xnU5bzKcNBTmJBhZYYoQke31YoHNZ0NdLb2O4cx/LF1KoioqSYJDz66KPs7OxIoc+cbLAfvNcdh9aasizJ83zVp9GPj6sZeZQBO0kSgUATVw4EBL1hjOk66tVqu72JczkZwKWQv16LOIER98srpVb6DlmWYa3FewdnbrLNzU0uXry4+vuzLktXnFd98/BqR6pzCnzW9U5TiYycW+td6eHdWglCr7/o0KULJc0Y1dkjPLfbwXTXEKu0ErJiuqK9OuEQS4zGpAm2LNjZ2uLihV0KckITWEwrjE7RKmHRNF2visG3nqODQ7xrCW3LYj7HNS0b45K2bZlVU0yaYlLNdDqhaVvmdUs00NQLjvf3uP7qVXZGA7LoUYlFR8/msGRjY8jGxpA2LCBTlJMt2qYi+Jp2qvEzh7MGhSYoaWZu2gavA8pCtVgym84IpRTH67aSfh2jGI+H6ADb6YAiydgsRgzzkmFWMJstWVQ1vkxRRzk3ljNyHBmOjZ1tbJIyn9XkWUZZFATn8K4RATWlaGPo1cAwRmF1yrAsGY9HbAwLFrMpvl4SfYurl3jXUIcWq4Q7LHiHczUg6yt1e8PC7hzH8kUMTX1UcenSJb7ru76LsizJstONRVorsixdDfppmjIej/m6r/s6Ll26iDGqq630lyp0UUAgRk+MUo9oGqGTT2wqJHpKc+89d/H+938N4/FIcP0dFNk5123zxNGkHZxad/0CzgWBOHfr9MeWJAllUa7WFVnjQF0tsDYhyxL+s//sj60ioDTNyLKMtm1pmoY0TTtHeOpKAYHY0bv03JZegP1d9HHiXMVpdI7jdTuAVQcBX/Oc53bbWZalmCxSFikj5ymcp3U1iyagGqGm3xgk6DLF5Am+WbKcHrNoJswmC1554TVmswXzacVktqDxHlvmNK7lcHpEliVkecbGaEyeZSyrRiQUbI4pC9JhgVIRGyxP3PUgeZLi6wPqg1dZvPIsN92cWZ5xdHSIj4GQwL2PPMC9jzyA3cnYvXQ35SMXUF2G4OUXXuSlF17k6iefZ3k0YSeUqBBxdU0+HrC5MeDlTz/H1VdeZnhxA50YVKpomoqmrpgeH+NbxzgvubCzy7ueeCcXdi9CbjgMC5axxe6MuLAzYvOR+5jWNbO6Ji9Koo+8/OmX2Bxv8MD993Hz+nVuXJ+SpQmJ1jTM0FGY2Ol0bm7euMZsss/k8IDp5IhXX3qR+WzCYjqlWs6AwKWLuyRdhsW1kvYbDcsus3H72q9ox6KUIs9ztNYMBoPVgNqng/pUTZ+aCiF0mgkJDz74AJubm6toZb2G0A+0Iiu6mvZD32wYpBC/s7PDo488QlEU3bZPUlpyHLGrcahT4+/ZNJLvCvPGnMxSVnBiJfQ10sgmy4/H426pk5uvJ/Dsz/PzSVO93tfr0Vt/3WLXKLn+E/XQY0HEBay5vWdYvxrNWI3uwBfCQOwJSN+EiFcFiB7f1rgqMDk6kIZDMpaLiqatca7Fe0folA+NErbxRIsgVuwaJY0xtE5qlkma07rA4njKYrlEGcV4PECFwNHeDXSo2RkXpKpFt540NrTBUdWO6eEe164a9LhE5ynZ1pg0ychHI0bb22zPl1BBO12y1WQsJzNee+HlrtanhWswtAzqkuAc7bKlrpfUdYXxAas0Vil803Kwf4u6rjk8OuR4thDmDm0ISuOtoQ6BOgQGgyFJmjAaDhmWA1Jr0UiDJtZ0Ef2J5krsWJT39m5gtaJZzlnMZ8znU1zTdM9Xj7SUMcW1ntBxICp6UNHta3eQY/nCTRvNhQsXRGe6kwD2XvD4MUayrI8SNG3b0rYtWZZSFBkf/vCvW9Ulzlo/yPdOAYJ0J0cI0a36Nh5++EGuXLnE5tb2qs4h/SgW7+VYtDanBmsQwEGapqsO+KqqMMaIg/J+VTCPXaShtV6dC6zXg+QGPDleASd4708tv+7I+iBKCvsi17xeXuqL/evmQ1gh2Fbb6Oo0bSM1n3N249vPrNXgPHWzIPEO6z1Zp3NnbCREj2uWLKuW5aH0ngzHY7a2LkPQKAtFmZOnBWU5IADj7S0iwkxc1RV1U1GOpNt9MmlIbMZ4a4sXX3uJF197CZMqRuOS3Z0xs8MDfu7pn+O+3Qs8+fYHWB4f4puGC6MRy6bmxtEht64+x7MvfxKXpdhByeNf8142t3cZj7fZ3b3MoNxi56u+llwlJJOWFz79LC+98iqNhiQGXO0wQTM0CS60zG4dUHfH+Za33M94PMJaS9O2fOaZp5nOl8wWS2ofCEqRDcd4FJVzmCzH5jnvfe/72d3e5cLWFsNigFUiKeyaBp8YLJpEdw7XGpqqpamWfOIzz1At52xvDAnBUy3mFFnKaLBBXViIgc3NMTF4FvOZUOfEgGtrtD93LF9mWycTAe8coUND9S/vZZm2bVYIKgkt7Qo1VRQFKKSGofqGwm6jQVI8WquuPhGkAUoLI2xEcrtFWZAklizLXjd0PXEmEe+Fgt45x8bGJo888giDwQAAo7vIiI5twPSFF5BC/9pNtsbdtULHxbACCfRQYhCyyNj1n5ykutTamh0jeF/MPyk0dfRicUUFs16jir1X6YtItznm/lerHR3vQ9sSZjO0NRSJIStLhpllUBh8aInLhuADwQeMigTvuHnjGmAxKifRGYlKcb6laRzzV2agFTo1uODxwaNtirWRxBZobamXHh0Mw6SkLC2jskQ1Ndo1lIUhxCXHy1vEuCAqR11LWnd7K8cswS4js6Yl+Dmzz7xCnd1i7+lX8F4RgiJ59DHMxhbaGAYXdnjnB9/P9tYm21sbfOLf/gJHhwcc3NxDEUl8B/NFUx8cMZkvKcoStGJgU9JRwsZgRBPEsdhsQN06DicTqnnF4njOtU8/h7sw5W2PPCFd+lWNAopcZMODd5j+kQgeazUmz7BW2MGlVSCSpilpmggQKKSSag/SsGqtIXqheOqFDm9n+5XpWPpxLEacd9J9a056UJSSVJJzvnMsunM6J5cjyzJCDDjXrGbiqwHZBwlvte2r/zJ2KoENR2TQLvIMPSh7ip/V4HuSXjs5at9J+dZVw+bGFo8++iiDwQBFV+Pp9q+0wqgzJI9r59tv/9QV6aDGKwTXmsOJQdJovYb2Oly43/aJ/1uDEq85k8/6v6OpAYQ1Od7eD8GvVjs62gfnCLM55bAgJCV5mTIY5AwycE7hoyW0ntB6rIboHTf3bqFVwqDcZpArkizFO0ddLdnb20MZzWA8EIJVo9A2JaSKItsENHXl0cEysCVbg4JxmaPqCu1rBrkhxIrJfEFiPEoHltWUPM24uH0JayJJ8LCsqRcN8+euUreBW0cLtM0xScmVwSVKVaA2hhTbW7z9A1/D3ZcucuXCLjduXGM6Oebw5i0So9kclpioCFFTHRxTK0Xc2CArMoYbG9gsw6QZLd0zYTIWiwo/r2iXC6qjY26al4iziq9734ewNuHWwSEKyLOMtq0ITnpYdMdgkGiNzXMSKxPZED1GSa03Ta30w5EKp1jsZTUM3mm076Qozh3LV9b6Pg/J9wfpHl7r84C1egUng6NEGCcDtdGm75UUffpVoQEZPFeoKBm2bVdUb5sGY62oKcZeHCusjqHfTmKFvC5NLE++56t5+JEHuXz5snzXnUPwnp5Csx/4lRGSot7ZofUpB9Afv+yXz6u2EsNJ0T7GuBb/CQLsNFKt65UhdkSfEd9K2sR0TvtULu3cbhtrXUtuDbuXd7lvZ5u37m5zoUgojEK3M4xJMHZE7gtK78BqlFU8+OCDLJct16/tE9qIrz3j0YiN0UhkrgmYLKENjja4lSBcjBqjE4rMsn/zBgc3b/HQ/U9w4cIGN6++RlVNUNHhY0MTW7QRGqPN7QE6KqrFEdpFBkZRbu0Sg2ZZG5YhoBKDSUtMOuDGS9c43J/AVoZXgWW7ZNksiYiK6nA0Eo694KFxxLYltg1ZmmCNIdMKEyLtosK3DpU0RGM7QErALyuoWy6ON7l75yIf+rUf5sKly9x67Rr7R8d8+rnnGAwGjAYlkSDRSJLiXcvkeEKRJeRZSppYyixH4dFKkacZVkRcSVMLUYtGi1akSUJT1zjnVi0Jt7P9inYsSikZeDvrezz6egOwKmb3f5+kdE5San0NQj6NJzBdTorUZ0MQhTrZX79Mt/3esaxmHV0kAsK+sru7y+7u7mpb2hghtQvh1HGtrA8h1gp6rzeUf75ypqfTWmtOTPUNmyfv+36gGBHZ1ijORZDTPRfZeSrsdjRJkVqKImcwGjLeGFNYSPEEL3x5xqTEoInB0nY3/ng0QqklrWuxqqFVHU28TcmyFB+8CM1FJG3c308dm4PRVpCMy5osSRjkOTf3rlHXC6Qu6AnRCZu4MjLI+khYNhA0iTIdijIhNp6gPLlOMCbF2JTldMGiafAxw+tAHWomMwEKoIVMUyWiIBlbL7ULL8+pVVo0USIE59ag8grVZx6cBx8o8pTxaMxb7rmXC5evcPVnf56jw0OuX7/OxQsXKPOMFU+u1nigbRoSowiJQSthyOhZMyTlLRRIWuuufi/PUp9t6Tn44m3Ov6dud+3kczu3czu3c7uz7PaOp87t3M7t3M7tjrNzx3Ju53Zu53ZuX1I7dyzndm7ndm7n9iW1c8dybud2bud2bl9SO3cs53Zu53Zu5/Yltc/pWJRSf0sp9UNfjoN5g/2/qJT6U1/Een9eKXVDKRWVUr9XKfWnlVLP/nIc47md2xdr58/Xuf2KtJXg1Bu8gA1g63Mt98v1Ai4Agy9wnfchrRzfBlwGCuBPA89+pc7jK/kC/jvgGWAGHAMfAb71C1i/BJ7qrukHz3z31cC/BA6ACfBvgG86s0wC/LfANWAJ/CTw5Jvs7/d2+/qhN1nm6wH/er8p8IeBp4FFt8//Bbj0lf4d3uA8zp+vO+TVnec/BV4GKuAG8L8Bj3+O9X6MNe27tdf8zHIG+C+ATwE1cBP4f699/5Y32M6fXVvm977BMhH4bWf293XAj3Tjwgz4aeCta9//x8APA/uv9+y/2etzRiwxxuMY4+HnWu6Xy2KMezHG+Re42sNAiDH+QIzxeoxx+ctxbHeQPQX8EeBdyKDwE8APKKWe/DzX/38Bz539UClVAv8KcVYfAt4D/ALwT5RSb1lb9HuB7wa+B3gv8DzwQ0qpy6+zzceBP9cd4+tat97/0u377He/DfjLwP8APA78NuBJ4G9/zrP8Ctj583VHWQR+EPgO4FHgW5Em8x9WSuVvst5/AFxZe90FXAX+/pnl/hbw+4H/EngM+CbgX7zO9r7tzPb+wtp3/+DMd1eAv4RM+v6PfiGl1G8A/jni9L4W+CrgzyCTsd5KxPH8X97k3F7fPg8v/bdYmzn274E/CryKeLq/gcxK/yDwEnAI/HUgPePt/zoyCB0ig9Wf53PMcoAXgT915v2fQQaPA2TW8JcAu3Z8pzx19/mfXt/X2ffdZx/s1nnL2mdPIgPYDNgD/jFw/9ntID/2M8Ac+bEePrPtJ5GbZNJt6+PA+9a+/yZktr9Ebrr/Gdj5ZZx9HQJ/7PNY7vcgzuJRzsxakJsxAu9Y+2zUffZt3fsxMrv7j8/MzK4Df/rMvkrgE8B3nr3v1pbR3f33X7zBb/g/Aj975rM/Chz+cl3Lf8ff4dR5cv583VHPFzJZi8C7voB1vqlb571rn30YcMATb7LeW/gCIwfkWXsZ+KtnnqHngT//eW7jC97vF1u8/xpkdvpNwO8AfhfwvyOe7zd07383Mkvt7S92N8fvBt6PPAB/+Ivc/x9FUhzv6/7+T5ABEOCPAX8cSZP0HvuLsm72/OPAR5Hz7dMvP3hmhnIF+EPA70SuwQj4m2vbeQKZgR922/hq5GHV3fdfD/wAMoN5J/CbkR/zH6uOD0Up9eu6fPav+2LPp9uOVUr9bmAI/OvPsexjSLTxnUhoftY+gww8v08pVSil+sHvALlmIA98xtrMKwqz3g8iA826/VXgp2KMZ2dy6/Z/Q27yv/gG3/8k8Fh3vVQX3fxW4J+9yTZvNzt/vu6A50spNUIijKvIs/D52h8Efj7G+NNrn/0WZLD/RqXUs0qpV5RS/1Apdd/rrP99SqlbSqmfUUr9ie65eyP7FuBe4K+tffZu4K3Aq0qpn1BK3VRKfUwp9e1fwDm8uX2RM6qbnJ4t/TPgFpCtffYDwD/q/h4gA9N3n9n2x/jiZlT/+5ll/jnw99be/17AnVnmT/MFzqi6c/37Z5bJkHDxN69txwEX1pb57QjpUd69/zvAvwX0G5zjjwF/4cxn93XH8lXd+69BZmxf80XOrH4jMpPzyMD/pjUWTqKH/+jNZi3AI8AvdefrgNeA96x9/x9266Vn1vte4Km1998FfJIu33/2vus++zAy4F1+o9+w+/y7u9+oJ6X9p+v35u30OnuenD9ft/3zhTjxWbf+08BDX8DvfaW7L7/nda5xBfxsd59/LfCjSLTWn+cu8Cc5SV39p8gE4u+8yf7+KfDRM5/99u7YD5E6ylcBf6q7pt/0Ott4C1+miOWTMcZm7f114FMxxvrMZxe7vx8CUuRGX7eP8sXZL5x5/xpw6Yvc1pvZe4FvV0rN+hdSyMqRPPNq/zHGvTPHozg5/yeBH46xJ9B/3f388TP7ebr77mGAGOPHY4xvizF+/I0OVin1z89sY91+FLmB3o+kVv6OUurdb3LufwX4pRjj33yjBZRSBTJz/CRys78P+CdIjeX1ZlpvtJ1HkRnmd8Y3yPcrpXaB/xX4fTHG62+yrQ8hNZo/iVz3b0EejDc8j9vQzp+v2/D5WrPvRaKiDyNRxvd30cvnY/8R4kC+78znGnGq3xVj/NEY40cQB/BW5B4mxngrxvi9McaPxBh/Icb4V5Do8Xcppe4+u6PuGfxmTkcr/b4A/kaM8a932/qzSA3mj36e5/Gm9sWyG7dn3sc3+Oys44pf5P7OWnPm/evt63PZ6+l7ng0pNTIb+gt8tu1/juPp1/98TCOzoL/zOt+94SD6Ovb7kVz7Z1k3YPdw0J9WSr0LKcp95xts6xuBe7ti+Lr9mFLqh2OM/x6Spnkn8OEYY//7f49S6huQmdCfQiIMEPTQy2vbubT23QeAbeBn15iQ+zSGA34t8tvcBfzTM8uobpnvijF+H/D/AP5xjPGvdsv8YjeQ/IRS6r+OMd4JkNjz5+v2fL5k5zHeQiLIzyilPoIc6+8E/qc3W0+JtsYfAP5ujHF65utryHl9cm0/N5VSt4D732SzH+n+vx9Jya3bH0BqTv/gdfYFAupZt6eQVOu/s325aPOfRW6OD3AyUwCZPX+l7CZwUSllouT8QXKP6/YzyMD5XOxiwi/Sfhb4BqWUfoNZ1c8gRbt/p0Evxnj2xnoz08jM8I3s1yOz4N7uQmDFv4+T2swAOn3k0+Y5GVR+FknT/HvA/wdWD9g3IsVmEMjmz5zZxp9FnM8fQGaFCnjHmWX+MJLi+xbglbVjer3jgc8e6H6l2Pnz9WV4vt7EFG/+LPX2GxAHcDaCAHmmfg+SWn4GQCm1g6S/XnyTbfbX9NVTB6SURVLCfzt+NmrvZxAQw9vOfP7o59jX521fFscSY5wrpf4a8GeVUjeATyMX8TEECfKVsB9F6gh/Rin1N5Ef6I+cWebPIeiS/1Up9ZeRY30LUvz7yzHG5z/Pff23wE8Bf1cp9d8juc13A6/GGD8K/N+Bf6WU+h8QWOwUCdF/G/CfxBiXSqmv6b77rs8zXAdAKXUJGYD/D2R2tolEGt+AFAz75f48kl/+BoAY46fPbKdPrb0QY3yx+/tfduf2/1VKfS+SC/8e4EGk2EyMcaKU+p+AP6eUuga8gKSpCroHLMZ4BByd2d8RMIwxfmLt40+cWeYm0JxZ5n8D/kul1MeRgu49CFLsF3kdyPSvBDt/vr48z1dX2H8MiRIOkaL4f45MZP7x2nI/DHw8xvhfntnE9wA/HWP8+dfZ/N8D/q/A31RK/afIROEvIpOGf95t9/cik6SfQ9JpH0LScv8oxvjyme39JqSe81lOLMY4U0r9P4E/opT6ReQ3+I3dOt+0dh6XkUzDXd1HD3XjwPU3S0fDl5fS5T9H8u/fh5zIFlK8q76Mx7CyGOOnkNnw76ArUgP/1Zll+trBEBlEn0Zm3QVnBsLPsa9fAn4d0oz240gO+/9EN5OOMf4ogmZ5JzJz+UWk5jDlJAVSIjOK8gs6UblB3wV8P4Jc+Zd0tYcY4/evLXcFcQift3XO55uRweAnkd/1a4FvjzH+1NqifxKBd/4NZHb5MFIkvMaX3v4cEu38V8jv9Q+QGeBvepMc/K8EO3++fvmfryVS9/gR5Fn6PiTV9P4zA/uDnEHLdTWQb+X1oxVijAskir+FgA1+CAEIfGOMsf8NA5K+/qnuHP7PiGP5Xa+zye8BfjLG+PTrfAfyW/wlxCn/224b3x5j/JG1Zf4g8POcICr/5+79H3yDba7sKyr0pZT6EaS/4Ld8zoXP7dzO7Quy8+fr3L5S9mWTJlZKvQMJTz+K5O5/N4Kq+OYv1zGc27n9SrXz5+vcbif7cmreR6TJ6a8gKbhnkNDr9SgLzu3czu0Ls/Pn69xuGzvXvD+3czu3czu3L6md67Gc27md27md25fUzh3LuZ3buZ3buX1J7ctZY/l3sj/4nd8clVIopUAp0ApjDEoptEnQWqO1BqVRWj4H0DahX09ri9JG1tMatDpZThmU0mhtAEUIEaU0xlhCiPggKUOtNaPhJiEEFoslymi0MTz44IOUZclr168SQsBazWKxYD6f40OLUoGizPHBsVjOyPOMNE35+Ec/xvXXrjO9dYxrHE3d8uST7+Hd734P991/P+VgwGS+ZL5YcOPWLbQ2aGOZLxd477GpJRKJ0aMArRQxOiCionzuXIPuvkNrUIq2iYBCaYP3Hu89SSLXarlcYq1lPB5TVRV1Xcu1BUIQxK5SqucRWvED9d+tcQytru/3fu9//yu1OfGOtVkMX2AevPvtV+8jioBaa/jXfWpdRfp7MChDQFOHhKhUtwFFT6AQo7y6TfaPd0erIIvHGIn9ZrtjUcST/RHRCEdV1LK/BRCUHKWOChVB968OeL46FwWxf2nkmeq2G1VEEVERTLfgyfYUQUEg0hi5QmF13CfXRfXndur69e/f+NGIZ674um2+2YpfYbtjHMvKqQBKK5TWq8/WKD5OL6cUWuvuh1Od45DXWceiWN+OQmuFtZYsL4kRwtozGGPAOUdd1wyGQwbDIW3bMp/PqeuGGD3e69WgvLk1IssSjFHUTc1iMWcxXzKdTvEhoLXm+PiYLMm499572dreIs0SLly8wHi8Qf3yK1S1DOyL5ZK6bhiOhuR5TiAQCYSgsMZgjaGuF4TgybKUEDwQIQSIgeWyIoRImuZIAzxr5xVPOYm6rmnbFuecXLO167xem1t3JGcdyrndvvaFV1cV60Ou6rcROfVeEdc2rglRdY6j/1x91ljZf63WFgtri632E+OaczmheFCIq9F0jkqdHIJarXuyrRBPH8Jqnd7Zqc6Ndg5yta3YOUsUOmpClG1F1TlHFU853n6nceU+5AqtdnRq672dvjhv+Dvdxo/YHeNY+hlzH7GoM6+TiGXN2Sgls3Sl0UqcUT9AyucGFOjVANvfopEQIi4EbAh4H3DOr47BqYj3HhSMxiMuX5FeqBACRZ7Rti1NU0OMGG1om5YQPMZoQnCkaQpEYgy0TctyWTEcDMnzguFwiNHmZFD3nizPyZoGYzQxeJq2pnUZKGhci9JgrUFrjbWW5TLinCMGT4wB71zndBLS2EdjEqEppQkqolTsojUwxnYRiVwTrc3qup11KL2JI1l7es/ttjcfPs+RaX0k70az1UdKs5pXx3hmrDs9xHL2+9hP6mI/fnerqVUEc+r/3inFyNlRVfXTRyXbjT272brnQ53conHlp04dzupF70LjqVs6RFBRobqFdBdJnXKoKq6d6+mo5SSKiScOb/1EXzem+WzXA0j24Ta1O8axrEchr+dYVq8zzkWtHIlZOZbV7FvplVOC0zexD4HoPS54WudoG7dKvcXoZVDV4liuXLnC4eEhVVWRpRnEyHIxhwjWGNq2pXURYzRaK7I0RWu5YdrGUVU1g+GAshgwGAzQWtM0DU3T4NqWNE1I01QcUwy0bYNzLahIVdcYY0gSi9YaY4xEVG1LGyMgkYo1BmsTUAYfIt6DpMI0Kohj6SM6Y4TaaT0deHKN4ppDicQISslnJ87l3O4EO+sGPvv7kz+i6lKnZwf1tZ/7ZEh8o+97B3T6Llkbi7v3kfU7aZUq651Gf0zr+1XqZN+r79Ye6Ng5w8BaWHLydf82nixOOL0ViYq67awcYe+giOjuOgWCHFN/YqeuReyuw0ke6/Qzte5YTj9Pn/1knTuWf2c7FbHoM9GH1qtBFdXVWbqX7v/XGm306RSaPkmPxW5KJINuYDqfoZQma8WpNE1LlmUYYwhBjsNaS5ZljMdjXnvtKvv7t9jfF3noJLHkRU6WpcxmE5xvKfICYxTGKJxztG2DNQajNLf290nshGpZMxqPGW+MeeGlF3nuxefZPzyiaVoWVc3m1jYPPvQQs9kM5xzbm1ukacpgNOieiECSpDjnmM+mKAV5loEyBBRKW4wCHySJIOcPoLA26RyeIoTQRVkWa0+cr3OuexDCKj0oHIN9unEt/I/nUcydbicZm27+fSZqPW1Koo/X/aYfBvt6hV4FH4p4KjUVo5JazGrgP0kn9QvJ4H8SAyi1tv7q4E8mQLqPNE4dy1oQ1G2DLgXWp8b6Zfo72XexkT4bjaEg+q7mtEbsHE8vdfLneuT/OhesXzCeuZq3cfpr3e4Yx3I6Ylmvr5w4mFVhv/tcqX6wU6eWWb04XaORmVEgxEDTNPRAgLZ1OOewVi6Xc2HlyJQSEEFd18xmM27dukWSWC5c2MUaLZFEty+tFLo7Xu9qqmVFahOKIufg5i1c61AcMV8sqJuGw+MjllXNfLHEOU/VtCRpxnhjYxUhZGlKmmXkWY5zLa5tOkdr8D5gjMZYi1K6iy5OakqnIz+JpuS8FOBo2xZjJBV2Eo28zp196sGQomyMJ8XZc7s97eyY9camTs2bP+9IR1Zdm7THNccTTwbY+Dp31amoJp5yKqBYzVm6fZw4qbVopXNaqwghrrsIWXHdb8b1Ak+XV+u3dbLmSYIr9sex9glEVAwnXuoNbFVxWYuWfiXZHeNYTjsPiUqMlvSW1ATWivLKnHIq63UYtUqDnQYA9D9wiFI/qeoKpQzGJiitSPOUNJO/q6pCa02aWqpqwfHxEXt7N7n66qt85Cf/DZcuX+Kh3/gtNG3D8cEh3rcQApOjI4wxFEXGiy+8wEsvvch9997Pfffcx49N5hwdHXH12lXaj7c8/8LzHE0maGP42l/zIebzOR/52E/JeVvLN3zjN3LPPffgnENpTVPVLJZzFos5EjElWCsptM3NLdqmoW3aLo3H6hop1YEbopeZYlQEH2lqx/HxhMSmJElKX5RUyhCJhOD6AEmiFIWg7pTqUD0yL4wy//tK3Tbn9ib2xfwq/Qz/ZOWTATTy+s5KKUFv9agtFQU7JWmnfoWTtE7sHEm/C99NoowyJ/WP9fRYPyT0G/AnkVBf61Ad/6iOfcSxtkIfqag+BbY6pbUYTJ0s25/sWee2+vNzXdnTF+mzrtn6tb1DJ2d3jGM5hQBbq7PoteikHyhZW+6UU1lb7qzT6Te7ktZUZlUcW9Vhuh85dEiuNE1RSuG9w1qDTSyL5YLJ8TF7e3sdpDhhPp9RVRWtq9FKs5hblssKhaauKhql0MaQpClplpLlOXlRkLdCvDqbzZhMJywWc4xNSGJGCH6F3ApBaihtIwiuNE3Q2pDYFGv7+kgXsdBdn/7812ZOMcjj7r2naVvmszlJ2pImjhgDSkGWiY5Y6B1U7H4O3T2CWvYhiLPu9zi329LOjpH932e/699H1Q20bxC4rq+4Hm2oLs/UBwQqrqGsur3rVUWj20gXfsRu+c4V0GPSIhCUOKCT1JZa7S/GE3ewAhXE/n2/31NHuXb8sqBSp11ERK2BFlhlqt48Njlt8cz/suLa2rEbiDi1wJm/bn+7YxzL2YhFdUglfabWovpelt5TrKfC+u9h9X2/vjCqn8BtszwH1Crl1ae9QhCocZIkbGxskKYp3ns2NzdZLuY413Bz7wYf/ehHeec738Hb3/4Ezz33HDdv3sS5hhACMXjKsuTC7kWuXn2V2WyGNobhaEReFDzwwIO89a0PMplMWCyXvPjKyxwfHdO6hvHGmJ3dC1hjaZuGWdNgrcU5hw+ugxmPsNbSVA1aK2LoXxqbSM9P06492h0YwTkp2td1zXw258aNPdI0JcuyFeR4d3d3VZPqc9+r3yDVKGWAs0783G5HW68zvNGvtD4A9kOxUqfrAp8zpdbVS9Rq/t+Xu9cWWX3bOZ7YwXhj189CRMcuNEGtRcKynlmbIIUY0DGcrNfXWOhTYwq6AvtJskydOr/eEb7Rua2WXbs+JxUcw2c7rfWQZj3KU6fBDG/6vPTr3f51yzvIsQgUVimN0idO4Q2RYbByQn3NQRuD0uak10L3hX3zWb0q1iZ471ksFqfrOxGqekmWp+RFRtvU3Nq7SbVc4JyjaRpGoxEPPSQNk0eHhzR1jXeOqqoYDga85f6H2Nvb4/q168ymc6q6ZlnVXW9MxfUbN0FpLly8yNb2NlXTYq3l6PiIcjAgz/Pu/ouMRiK13TQN3ju898xnC5LEYoz8vHXd4L1fPUChP5f+eq6ii5OH03tPXdcryLFzLVrrDil2EtnF+NkDzXqU2H3ypb4dzu1LYDqEk4F0Nc/ok/79/dFVGbqpeV9nWP9Fpdi+9l6dDH8nX6zXKfpIpJfHUav9qu47un4R3d9jWotzCDK4huDF8yATG6OksTlGCF4ibGONpGWjnIfqemBU7I9H1g+xK7nrLu1l14fFN7h3+8jsTH2ody7xzKcnDqxfV62uz6ko5mwEs76VeHL9420+YbsDHUuX4nojp7I2Sz4dlRgpQmuz1j1uVt/JgBlWv661ZuVYgvf4EE4G3hAYjYbkeUbdVCzmc+q6xnXNhHme8fDDD9HUNUeHR9SVOJa6qtje3OTRhx9hejxl78ZNfJRtV3VN0zQsFgvgBovFkotXrrC5vYWPoI3hxs2blGV5yrGMRyPatuXw8HDVzKhQJElCWZbEGGiazkH0oX08cSxar1+zk5vV+0BV1fQOp23bNfTcSY779aGSauWszu32NRXCmgeQgSueyvUg+dE+mlAQ1Rmn0sUZfV1CIo5+Nv5Ze1xNbiTv2jmTNaciK3a1kRBWYYuOGm3W7lvvpekXUNFgVSKTpgg6tIQQMIlgt/TKW4XOscjf0s0fVziuEHU3YJtTDrF/bs4ih98w0lsb9E+Qa+pMsb+PkMQLn0KGfY5gpHfMt7PdMY4FOO0w1j47NUM+NRMXeO16umx9Jt1DlgVCHE51lzvnWSyX7O3t0TQNbZdykuK7NDLWdc3LL73Myy++1DmEyLd+6zczGo1omoY8L9gYb/Dqq68SfGA2mTMrZ8zncx544AHuunI3N27d4PD4kJ/66Z8m0pLkOY33HE+nZHnB9vYuo/Emxlp+8Zd+aYUG897TthKhHB0d8bM/+7NMJhOm0ymDwYDhcMj73vc+8jwHBJ2WJAlV1RC8XzVBrrMRJEkCSA0pyzKstVhru4ZOVssYI06379A/e33P0193hpnQsqop9BZPO5a4Nnyuutm7OmbsE01KKE5ihLBWl1ilkroP+h6QdTxHn/bS+mTermKAEND9PeZ9B9Lx/bSF6Byxdyxak5B0hXdFcC0qQhItKE3fFSNH1jNRdP/3TSuI04zKoELa/a1OeZDeuZyKvPpTiaCMXv+Ek4lW9/frPRZq5R/PpAY/a7E7IAF2YneMYzntVD57lr3++UnRXmN0n+rh5PvOVt36nDiok7tFbrpVHUGdQIXTtcF1Np2yt3eTyWSCtZZ3vvOdDAYDYowYY1a9L0prrLFopfEhiHMajHBROvhDjPgY0cYQQ6R10pCZZhlpllGW5WpQFxSbDOoxBtq2ZTabMplMOD4+pm3bzvG0JF1Npb/JQwh47zndv8Nqm/116B1olgmnWX+teucKEq2s17lO1cG679d/u3O7vUxHqanJjDkQQ1j1MfUFeuGeEwfTQ9RB0l8+sgJrhJMNIbVKJFvQpU1DXBuA12fxXW1ThUjbtizmU7QGoxTWaFSE5WKBUtAkhh5u0jZSr+x70YzWKx68ug1EujqsTdDGrmKGiDwzCo/raJgEo6ZwSqOMZZgU0DUj9yCXvlB/NnKRLzhJYZ2KPnqHfOJczgYmp5xFHySq/jr1C0bC2rN5J9id41gwa0V4BVqvHgK1Cl0VfeHYGElzZXnRFaadwJP7H0YpsiwjRrmhJf0lRfC2aSmynLIouXTpEoNywKAsiF0XV5YmUodoG/IsYWtrk9lswmIx4+d/7me5cuUK733ve3CtY39/H2MM29vbPPzwwwyHQ/JiwLPPPsdzzz7H5bsuE2JgMpnRuJbxxkYXvguSyzlxHGma8fjjb19FCuII5KHc2Bjxrne9q2tqjCuwgTGGpmmIMbJcLAVK3E2PjGlXjsJ7QZhVVbVyWGVZ8v73v5+6S9FJ57859Zv0abDXiyTP7fY344RE1eQpi+mc5WzGaDwkSSx10wpSsSxxTYNvapK8QBsLWhplXV2RpDlJWkikEGHR1oQQaX0kSxMynTCrK5z3BGVIjGGQp92945nPJri2wUTP8889yz/6B9/HhZ0dLl3Y5e2Pv40yz/ipj32EajnHu2YVYB0dHtC2DcPhkOAlu1AWBUVRopOStBjw4Nvfw8b2DnfdfT9lkVHmCY1rCMGTaLh29SV+4J/8ALFzKNiMwWiDb/st30laDKhbL+CVNFsFWX10AXTErhLhqxix1hBR+BgJQT43VksqrlvfI1nAGHtKT/HVSoFVJ82ZPXxaIWnpum5JE0uW2pON3cZ25ziWUzWUHlJ8UnQ+2/B40p9yMvjpjhHZ+26mFk9QYBIJSKrHe0/saipGm1WDI0RiiCyXS0IIq8ggy1J2dnZwzrGxMaYsBZJ7cHjAzRt7HBwcEEJgY2ODshygtaEoSja3tkiSlLqVZswkydja2sZaS2IT0iyXWZ8xGGNXx9Y0zSrSeuGFF6jrmqOjoy5iOKkhHR4eEru+nB4CvF4jUUqcqUQ+Jw4ixkhRFFy8eHGV6srzXJBmnaPql/t8frdzuz3txec+jU0SitFw5Tzmk4MVQjBJU0abmxKtA0ZrdBJAG/ABvJNXaPFeZv1WKZSWiEYIISWqNV3tMhJpvSAjg/dcvfoa89mEQZ6yt7fHfDZjVBY0dcVsckS7TDi8dZPlYkbbVKtMQrUQotXYVKtJkasy6kWGzUbYxYIXn3+W4f4Bi2XDvXdfobxyieAdIThUkhKCYzo5Am1QxrJoPOVckJ0ZBYnRWK3RRJyXqEF3fV+rKlI86bjxzhMBFwJaaYxWxBBx3bN2tn61qtN3j0joIh+lhP2DGEmtwSiF0QqjuysYgkRF+vRE73ayO9OxnGE3Zu07oW4xq/RP09Qopbt6QUKSJKtZeevcavtJkpBlOcvlEqUUk+MpIcrDVM+XTIwhRI/3jsPDQ1CKPM+JMTIYDLj33nspioLxaIQxBuccTz/1NB/5yEcZjUZsbW3xa37NhxgMBoTgeeCBB3jooYd46dVXuX7jJjbJKQcD3vb4OxgMhDNsc2sbrS1Jmqyc2XIprMgPPPAAWmu+//u/n9lsRoyRPM/JsozpdIZznqIoVg9dkqSkSQbIwz6dzgCw1q6uXVEUK3aB7e1tHn/8cYbDIcPhkCRJyPOctm0/K332Zr/Zud2+9gP/v++jLEsuX77MeDxiNBrymc98huPjY5IkYTgacs+997Kzvcv29g46tJBlYKzUS1wgqEhLYFHVhKjY2NwVtgpkgG29J+v6vaQmGJgta7xraJuaH/nRH+PqKy/z4P33UFcLhoMBo0HJsMg43LuBaxsO9q6xnM9pqwXeOYJ3bG6MKdKEUE0ByLUi1nOqakZSOhbzGZ/41MvoNGfzwiW+6Ru/niuXdmibihAcg40CnWqir1FYlIpce/UVTJLT1gvMaExRDFapqrpq///s/XmQZdl93wd+zjl3f2uuVVnVVb13A2gsBECAACWRlCjKkkiKFK2hRpYcDo81MzG2NXZ4ifFM2B7LiyIcHskKh2PCEmfGY5kyg5YmpLFs0QJBEKS4E1uj0eh9qb1yf9vdzzJ/nPtuZhUaAO2g3VXj+nW8zqxcXr68ee75nd/v913QxjEexh0YAJzxbTUpfY+srGqss1ggjSPiMGJVabSxiI5o3QE1EQLCrirR+KTSWgikr1yWZY0xhnQ88AfiNGLd0G5aD04gyP7nXzS/x3hoEsu9w+F7eRK90KTsVIzXX4NA2+7EpAKPDOtVfc/mMl4c0rfJ6rqmqiqSOOkTkE9KCiECHBFBl7jC2GtyGW1Ikpg4ihiNRlhrWS6XXH38KmmWcfPmTZyDVntpGKkC7ty5y939fW7f3ScvSz7xyU8RRRFRnKBU4Ftt1s9eQulZ9GEUd4z64FzF5AmRF3Z32d7ZZmtzi6Lw0viT6cTDj/McpcKu7dWhYezZ6Wk9q/HeM5a7d+8yHA7JspQoChGCDkpdn7tuAOuW3Lf+vc7nlEf55cGMYnFKUyyp8wXDoT/MHO7v+8OVFLTVmOl4QLGcc+v6u0RpilSKsmmJ4pStnQvs7F1i+8IeaRJ3UN8WazSNdZiu3RN092WoJEYIWueQLkAFlunGBkW+pCxLnNVsb2+RJDHWaC48dpk4DKiWJ8xnMw73b+O6bkKa+NasNYqmbVgtl8jONsKaFqEUFy7sYvCSTKZtMG1DHHZ+S3WBqQqs9a8X0WBtiyLoelUGa7tZpBCEgUJ2m75wFm2s94yRvjLzLfKgb3EFyjNrwsC37pUSZzDrbo5vrZ9dtdoghCBSEqyvjNIwwClJXRbdrDZCtw26aYjCEBk+2MTjhyqxAPcklzOV4nPJZD1I7uGuHi7Zw42FZC0ht05O5wfPVVVRliWb403AkwUDJQmDM5LkaDD0izgK+hnEOvms0WKHh4dcffxxPvLRj/H5z3+e4+NjWt3SGkMSRNy5u89Xv/pVDo5PUEHAT/30TyOE4Nad2/QKxM7fnEquW2ERQRj1iUVrjTWGJI54/PGrPPHEE1y9epW68mif7e0djDUsFovO/Ez2FUeWDADPV9FdwltXN9b63nKWZf3vrHXLurF7lijOQX7uAV/698X9iKNH8UBFnS8ojOGoaUjTlDRNfUvJeKKtbSuKnc0OFLLASYVxjpPZgsl0kxc+8jHiNOXC3iXS0MN9q6qltY7GujO+RRgi6e4xHEYF4ByBtWxubFCXOScHdwglbG1tIqxfjxd2d9jcmKDLJUcHB5g690iwjvwIzkOEnaaqCo9kVD4pSWW5sHuBqjXcOTzxlY5uieMAJR11vcQ0BdY0aOu8Z4xtEcQIa6Br1SkFQigipbBdYnHO4YxGBpJQyX6JK3UGeV53uALlYdKB8FVJZTwCTklBa/3hUbeGQEriUNJqhzaGJPSAg9npkjBQDOKApqmoihXZZIM4eLC37gf71d0X78lXEWdEyV62Zb2IhfSokLXycTdvAA9RjOO4/941Z+Wdt9/m7u27NHWD0Ya2aYjjmDgOWSyXtLrtpFy67bM7jckwYDAY8Ef/6I8QRX44GYYhg8GAKIoJo5g4zQijBJRCBAEqjEBK6rblK195kVZr7uzfZTQeMRmPmEw3GA5HNNpQNY1vh3VOj+eRWmmacunSJTY3N8myDCFKjLGUVQHQo9J8ZRdiraOqi77SEKxRYAlhqPprG0ZBn9QQrmMrrK+761rMAiFsj/jpnpB7cs+jeCBjMsi8QZ1tUc5gm5pBHCJkRNs0jNOEjfGASAmSKAChaLXh+PiY48N9fvs3f439gwNu3LjB93zq02xu74LwQ+woiFj7S+ZVjXWVR0sC4E/7IpDs7OwgsKxOj2nrgsODQ9oyRzcVn/mDnyHb3uGJp55hc2OTOAq4cf06N29c74bmhpPTU4bDIZ/81Gdo2pamrtk/XlCUNeWdO2gUpjUoIbzxnfG8tDCNSIcJG5OMIEwIooSirBAqZJQmxIFiVawQMgAZIFTXzmucnw+1NUKGBISU1drNNen2mpDVasVqlTOabhDFMc55RfOqKEiTmCBJQICSkCQhUvjN2DqN1jVNa5DA9ijBWkMxP0QJmCYSaVboShCkF97X9fOd4qFJLOeRRz0EkHMo8XsG+GetsvW85b2sdQN15tGy5oXMT72gZL70/dymqokTn1hOZ3PatiGKPa/DOts/vwoDhqMReb5CiOE5jS5P7lwP31WgOoa/b+FJpXDGcHf/gFZrZvMlDg8aMMYDCIz1xmNrRJh/Tg+xVB23ZNQ5Sq7hwM45bzaGP3E55zqym4+1/L0QXjxSSYUKJMqqvjUm1qW+PKtEzlB1ZzpN30oU8/X+WXJ5VLU8iKEEWOnfesFGTxWUyG5Y7Ns8cRjg0oRO8YcoDCjKisODA8IkQ6iA51/4CL6x41kjgVQ4Ib2BsOtQYR1nxdnOVliIvi0UBApdC6qypKkqTFNjhUAGIWk2oK1r0myAUIpGm976oShr4nRANhwTNA1BGJMUBk1L3jTIIGYyHpMmCUoImrZB6xrTaMqqIAoVcRIRJSlRGGARVEVBEMZoLRAKpJIE0nr9wDV501n/wII1OKvBaiBABg6jW+qqZGTHXoq1k3LCGISzqP6Y5lDCdVbMAmENwrQ4q3EClBO0dcnpwZ0OFab88B7H3pVHieX3Ic7gxJxPMv3M5Zwm2LmKZg07Vsq3l5x1/detT/Lg5VzaVnN4eMz+nQO2JlMMgtbV6LrGtA1b06n3hQ/W5EvJarVklS/BCZSAyWTSVQ4DyrLi5s2btFoTRhGD0QgQHN7ZpyhLHILBcIKqG95+9zrD4Yhnn3++25cdUoTgVC9dr1SIsYUnOWpDECkGacZ0PGZvd5cojrFWEwQS5wR3b99BSMloOPbzHaORMuj5OK5LVkr5jzu8jMtyNadpY6qqIElSL7u/ZirIM1M00SeXNW+BnsfgW5CSM1Dlo3jQ4ujwoDt8QaBC4ihk/+AudV2zubnBSgmuv/M2k8mU0XjCtRs3Keuaj3zog5wuVnz95Vc5Pjpivsz5/h/6ozgnaZsai6W2AqEChAxJs4wUaDpCr25qokARSsGXfvu3ufbuO3zw2SeJlWBxesTm1jZb0zFKWxYHRxztH3D3zh2+8pUXKYoCFyQQKBQw2AootObzv/47XL70GJcuXeYTn/0eVJDw67/9dS7uXeJP/amfYDAIaZuGu7dvc3h4m89//r9F65rBIKYRDus0SmqasuRv/+z/m8tXnuQzf+CHmG7sMh4OuiodFAprBI0TKDROawZpAIS0jUY6CAkZRgFymDEMJQrDslihpOLCxoS1OnjQCcmWZU6oFJPhAGMKmmbFIA7BWt59/VWuX3uHX/7855BdElq3Bv7yX//593H1fOd4qBLL/bDi8x+/5/P38SrWicQ524mH+q+xa9mILtQ5+J6SConwg7Lu1H71yhVG4zHW+RODE3Dr1k3yYtURD3Uv62KdRShJGHk0iMfAWz+I6wadVV0jpSKKYtI08zdgOqBp6q7a8EnTc818deNbUwrrLFq3tLrBaA04jDW4lv4myIu8Q8SFfWLxZl6KUPo/va+AfPIS3Qly/fueJeDzSDvwlcuaCHYf5Uuc/9ea0vyoYnkQw3aESCFUdyawPXxWANZYqrIkTVI/o+g2QvDD6TRNcTJEBiHOunOKDp6saDtgiJ9tgpIC4SQiUN1A37FYzDk5PsI8eRXwlXgcxwyGQxaLJbptuXv7LsdHR+RVQ9Voau1QcYRSAdkoRipJlCRcunSZvYuXuHjpKtYK8uK3aZqWyWRCEDqE1LS6oSoLZqfHaF0DY2LriPEaY23bcPPGdeJkQJokhIFCOEfbeph9HPrhfqAUzjbUbUOS+BaYqSsaY1ks5qyWK1arFft3b+GcT6qj0ZinnnnW36fWdPeZI1QCiaEpV9y5eY2bN65xcXuTQEmuv/06+3duo6sVTvtKBr6bI877Hw9NYrk/Ydxfndz//lrN2FmL61thfjaw/jqt9T3PGXeGWUmSEHcyJgqvGxZFIT/8R36YJ554glWxQhtNoxt+7dd/nf2DfS8kWVbMZjOEkhhrGE2mTDc3CKIQs1pR1TWDbMDuhQsI9QrHx6ds7uwyzAY8OZwQJynZYEzdnFAUtXd8VL6SQHjGfxzHPoHplratWcxnpGlMWZXItkFIyWAwQAAnJyeAbxloa/xQMEkJVECswr5F52dIHcrGmg4NFnWznJA4jnrr4/M8lm9JKvfEwyRA8b/cOJPyceimJokiQqUIld9A8zwnDCNU4GH6UgiWyyWtcezs7EAQI8PEw2DrhjgbgQxwKMpWU7cGhUBJSRqGiBAcEcIZrG45OTnm7p07rPIVgfT3YDYcMppMeeuddymKnJvXb9C2rU8WtaUoWpJpRjIYMkwGXLp8mR/4wR9iMBySZgNwiqPDY9559ybrLU5FISoK0bqlrgrapqQsV1TVgvF0k9FkSlXmFHnBu9f3GY0mXLp4AWMlbVNxOpujW83W5oQoVCRxyHK+YLk4IdjaJAxC8vkJi/mC6zdvcnx0zPHxCW9du8YqL5hONnju+ed54soeprM7HwwygiAgGabUZc7pwQ1+5Rf/If/oF/4hn/r4R5lOhlx76w2kcFwcp5SloSzaXufgQY6HJrGczStkJ+MgviWpfIuEvvDDw7O5i0NK12uKuU7faO2/IgJJFIWEQUBTNyjpPVeSJCZNE7CWqig5PDikaRvqpmIxn6PbliBUJGlMNsgYDgYMRyOCwPvdryHMdV17BnsUMRqP2Lt0qeMEOFZ5QVHWVFXrLYGlR4GFYURdrWjb1m/q0L2mFLBkg0HPPxHSVzdN21BXFQcH+2itWSwXhHFE2A38rbLMFicopRgMhkgpPMTT0tkRezh2XVcdFFtgbXhPcj+PBvsfQph8FA9ONG2LNgZj14a73ewxCr3+VhQxnU7Z2NxkurnFpaeeRlvHl770ZVptUcmAy48/wWOPP8X27i5BFKG1xQqNxtIarxwcCU/ua5oWLwTpZyTCOZ5/7jniMCRLM4aDlGeefpLtrU02NzdYzk+pyoLReKObCXr4vXWgIp/sxtMtJtMNXDTAhf6hG0PtFE4GaGtZzOcMXUw2CEjiiMEgxTnbK06slgvqpqVtagSOKAwJw6Cryi3WGNI4xoURQec7ZNqGO7dv8vabr/qZkNG4xlAUJfv7B5RlRVVWzE6O0cYyuniBYRIirCYUoAKJa2vqOudw/y6zk2PeefM1Dm7fIAlgcXKArRZEQiOcpV41YFpiYShyX8k9yPHQJJa+spBes+u85/23r146Z2ohOuZ5J5vXcVa0XcuS0G2g0kN6g4CmromCkCxOyJKU4XCA0YZ8teJgf5+qrqjqkkV3kknjlDSJGQxSBsMBo9GIVnuWfFPXHSy5ptUpMTAcjdi7fImT+ZKirCjKEqMtp6dLxqMh4/Gwey0hhbboVlPXDR69GZIknqg1yDLSxCcWh7/x2rahqAoODw6o6pp4dsp4MmE8mZAkKS6w7O/vEwQBW1uGNPXIE58kbMfZgaap+8RiTKdd1lVycCbpsn7//NtH8eBHow0CQ6vbngs+HGYEUYgMvE7dxsYGm1ubbGxt8cSHPoIVki9+8R9TN5qtwYSrVx/nU5/5DCoe4GRAWbVoZ2mRWCexKE/wE1C2LViDsC1RoAiU5PnnnmNjOqFYztnY3OSTn/y451ANMorVnLosGU+2PP9KCOIkI05SThYLtHHs7O0RhDE2jDFBilUJjatprEQEIcbCYjEnUBlJkJBEIVmWInDdmjfkqyV2ucLJCCEUceQTC3iggU8skd93hMEZg9Ytd27d5KWvfZXr775NscqZDMfoVjObzXsAUdU2hFHEeJAwTCPQLSoMCANJW5fUZcGNt1/nzu1bfP2rX2Y1PyULJfnsmHYl2RgnOKOp8hWhEkRKMC+WVGX5Pq6c7x4PV2LxAwD4NhUL6lw109kWB8LPJZACZzrCYxh6HSTnh/bamD5xtdrQtoZBkqGkotWOVdFQG8fnv/ArAKyKpUdUKZgvF4RhjDaOujE9B2W5ylFBgFIh48kEY737olIBbavZ2dklSTKvjOH8zwBBGEa9CN9kNEC3FWkS0WQJw2FGUeSUZe43cCnJq5K0LCjrmkGWMUhTbCd1HsUxZV0zn80JVEiapLR1jWk1R0eHvXXxZDLpdMY8N2bNXQHPzI/j+KyPfA6Z9ige7vjez/4B6rrm+PjIk3PDqHMpDfjM932a6dYWFx67QqAUgVSEYYKx8OM/9dPcvrvPl776ElVrsUhvey0sUZQSejYIftv2vI7GQJbEWK2pyxYlA+Io4sknn2I8HvHFL3yeKPb3ShAEXgrFWCyCnUt7SBkQxTFShUgZkkxyWmPJxhOEDLzoZBBSO7BKEaUZH/3IR5gMMy+PEoSobMjpfMnh4QlhlJGmBmMb0jQjSTPq1tFqh6AlDgSmXqKcIpYCrCHPC/7RL/x3VMUKJQxH7pceowABAABJREFUh3c5PdpnEAWkkwHFcomzjmES0LSGpq0ZJDFJlhFFAfPZKV/85S/w9LNP89TTT6GkAKN55eVvcPvmDd556w22NyZcfWyPcjnH6gbTtuAMUkAYBCRRyMZ0g3YweL+Xz3eMhy6x3M9h4dz7/q381qQj5fknOvs+BEJ2w0rpqxrXkRK9+YN/aOPQVcticUjToV7iOGK6OUWqABmEaGcwlk6xVXgZBwlSiR5qHIYRSvqbxkODw85PXlK1FtG13pwxWKvRbdMN+XzpHIbKl+GmG+AJT3A03VBVyDOtszAIybIBdd1Q100P1DKtwQrbQZnP9M7WQ9nzCsfr666U6uDTaygy3ENa6QHHjxLOwxSjjS1UnjNbFcRZxiDLkFFKGIVcfuJpJltbbFy42OmCGbS2OGF54ulnsSpCf+UljPNS88aCE45YKhCyg9J6OG3bes5TECmMs3703BnsjUZjWu2H4G2rCaMYITywIC9K6qZmMvFckDQbeKCBCLxkjLFEceJhzVZ08GYfUko2NqYMkghtWr9Cg47AaAVShggR4pxGqpAoSjoAsEHKFuEszjRIEaCQ5HnB4vSUa2+9Tr5aINE0dUFTl2RxhFCSlfa+R0EQ+DlIV/2HQYDWLWVVMZvPqKoKOri1A2anM2anp+SrFZuTIUkUUbGGZXfTyjXsUvgWpVSPmPe/P9EJT/q3a/vhM3dIX3oqlOykWzpRSdkp8jbGqxuHYdShtDqypJREcdRh1PEzDyFZ5C1ZGrKxfZE8z1nlK/IatJFkWcqzH/wg/5v/7T/HL/7i5/jc5z+HKUusC2lagXUB42yCsZa2NRR5TVHUjIYjkiSmrGqM09hWo8LIzzSkxZiWpiw6joogUBorDE1VoNscRwtS+2QoQShBlMSE8Vp5WGCt6wbs8L2f+BSLxYLbt+4SBD45VEUDzvHMM891sjANTaPJ85LBYOAhzcZvC/6tRMoAeqUi31J0Paz4LKk8KmQervjSa+9S1zWnp6fsXbzI3nCLT/3hH2Bv7xJ7V6/inGO+WhEnCckgRViHcpBKRTpvCIebyGQEKiUIlJ9bdgcSBzgDWFCdfFDvYCoUVkjPmAkjgihFBjEEES7wABJtNb/yG7/G/v5dfvAHfpCNjQ22pCOKEsJAIKRB4oikRx/WrkWJAImiaktMk+NsS11rDg73GU4H7Lhdnn3+o2xu7fK5X/plZqsZs/mSwVIzyCqiKAFgNT+mLk4JqMA4TNPyG1/4HNevX0fWJyS2pikL2tWSIl8hBpmfXTYrjHW0lcTJgCAMUIFCO8vXXvoGzz73PH/8J36S4XCIkxEOjZMBBokIIgbjKUXVcO3GTap8iRSwu/sUWjeczleUbYUq265VHb9Pq+b3Fg9RYvnWiuU85Jj7TtmilxSh+xydWZA648F01YxU3ufBGec/phRKhiAVVdNS1g1lfSb9YIGybrhz5y6zxcLj8203q+kSm+9USQLhFYSVVBitMTro9+P+9XlFu06fSHcKqoreQ8IZDwUVri+46PDsa4LZupXlHyCQjEdjlAzQrSVQXoSzbmovWJkmGGsoy7JTB4h6AUpj7LmE3W0U5+Yp62vcv/p7MsqDDoR8FOtwMiDOAi4NPZDk0t4lNnYuMJhuIILIO6eicCIEFWGd8QRIGeCkP4BZ52eVa99caew9CUbQuZTisMZXu2HgbSeqDsUYhCFBZzK3WuUoJQBLWVWsVjm3bt0iL3K01YxHU0ajSX+a9zbEYLVBBgKpvMxKEkVc2rtAWeTcuXOH3Yu7rE/8zimaxmCMII4ykmRAlmU9ZcB3vlqK1Zwo9NVBkc9ZzY6xTYXTLVY3hEowTBOiwA/6kyik1Ya69RlV0JGUjcXKsPdbsg7qtqVtKvKyQgUBUnkdPxmHRHFMU5U4a6jqBq3b7hr7g50UyvvPPMDxECUW+j3r/uSypuIBnVeL6HLNuXZOd2Jf+8A7BP6Q7xOLtQ6LQ3Zij4NojDGO/cNDirKkrErvrSAljbG8/e67/I2f+RlOZ6eczhdeEsVBkiaEYUjbtiRpSpbEfpDfapbLJVp7LonAESgJwotCmsb7ROBaBEH365quU21xnDHhlbpXRcA6R922RFqjWwtOImXIZLLBaDRhY2ObLM0YpAMa3WKs58AYq2nauoMbxwghKMuStm372cqaxb+W1v+OfyLxndWOH8WDFaOtLba2tvjYRz/KhYt77O5c8BwLoNYOa8CpGIIEgoRWl2hrCISksYJaQ6UtVduy9kMKAo8ok0EnDSQ9f8UhqOsGKSTDQUpeFCzygo3xkDTNyDq5lxs3bjAeDxkMMw+wMS2/+Zu/zmg04sknn+Tq409w9fHHybIhgQpp6tzPSbUjSFOCMCBOYwZRwA/+wB/k9Vdf5ed/7r9ie3ebj3z8Y6xWFaenSxaLAqsFexevsrk5Ybox4s7tm6yWC9LID9lvXXubnb09NnZ2aKucanmKrj052bYt0+GIcecWq40mS0LKuuZ4Pkc7h7Ga+ewEg2Tn0lWQgtl8Tlp7f6X57ITFYk6aDYjihOUqZ3tzyuXHLnEbS5mvuHt41CU8EEFAGMaIIDx/Kn0g4yFKLPdXKee4Lfd87r7BfseuXzPwvUSK7UyyJNDNKIxXGQ2CgDiJaZsK3RqapkIpx2DY6YpJLyznsMxmpyAc0+kYaw1pGhHHIUEofYup9W7gVVWwyhe89tqrfkgaxX42YjyJ0v9KFmMNjW46t0rREdK8VH9dV8xmp52/herRa0EQIoTshCQ9V0UKT2oMw8jPXoT3d4FOdNJ4BNh6fmKMuUeWvyzLfli/Thb3G3rdn0AeJZWHL3a2t9na2mR7e4vxcEgcBZS1t/wNpHeIxFms0Wjd9BJCSnrk1GCQkqUJSewJv74p2iUU6BS0nTe3cq4HhkDQqWZnVFXJcjHvVAAgDODpp5/kyfRxPvzhD7J3cYcvf+lLNHXFjevXyFcr7t65w/bWDkmaEgReh280nHjJFGsR1oF1JGHIdDTksYsXUdZxeOs2URwx3thgMp6wEmC0Jl/lOOdVyqVQGGtp2payLHj3rbd48/XXOT05wRjbzzS1MZR1DUJ4QIwxtLqhtZpASj9LlRG1Ae0EURSihJeswfn70BpDFIZ85CMfIY0jvval3yFf5Rwfn/Cxj34Pk/HIVzzOz4CvvXuNa9evs7u7QZqm7+fS+a7x0CSW90wo64/f3wY791jLtqxnLtBBCN0Ze9xvtl4KO4oC0iRmUS5odYs2NXEaEydJf0gQwvu8LJdLRpMRo/GYuilJs4goDlCqU3lt/HNXdUmeL3njzYW/KeO0b1uZTr8rDAOsM9StX0iuK8u9nL3qTi0taZoyyLKewOj9VLxqcdu2aN0SBp6vEnSkNlBIIbHO0TQt2rRdS9Ani/X3roU4i6I4k7y572S0TiDnW2Tnk8r9X/8oHtzY3dlic3OLrU68NAwVde1huIESXRXi151uu6GxVEgRdNyTmDSJSaLI2/s617sjOq9Q6nXxOv6JN5zzEQUhcRByeDhnPj/l5PiYpikp8zmjYcoTVx/jhQ99kKoqee2bL3NycsLtWze9PlkYceWxqwxHY5J0yGg04rHHhNc6cw7bemmVcZwxygY8treHco6j23e48uxTjKYTxuMxRjdo3ZDneSer4qkM1ljaVlMUJQd37nD39h1mJye+0rcWazz4paoq7zhb11hj0KYBITxUOQgRQUzcGpQTxJFX8Kgrb1ZmtMZZQxyFvPDCh7G6xXWE1JMTyUc/+lGef+455vM5QkAUhXzuc5/ntdffJMuGTKfT92/h/B7ioUos76UFhrhXfuTe+csZu152Toiis+wNpCRJsk6ssUF13tjf9+lP8cHnn0cJf2msdaRZQpImtG2DMZqyLM9Ihc4nB+9VIqjrEilhNBqyHoB86IUP8PjjV2lbjW8XRF4CwzryIqftJOudsxiM70Ub439eJyGutaauS+8sGUWUZUWRFxwdnnCwf4TRvuryi95v8kr5Xra1ljiMiKIIbbo++XpOc06JIIp8hXN0dHTOIMxXOmtxy7YjZv1ezb4exYMbn/n09xKGEaNBCjjaukQJhwoVSgpPcqwLcAaBJQwU4Jgt55wcH3B8cMB8dkpZrLy1r/AndQ/lsL3wqTN+jY2ylLZtuHv3FsMsZTjImE6GDNKr/LP/zF/gnbff4r//hf8Op1um4yFtXWLrmk987GN9JR0EIWEQsrGxiRCKN958i9OywDYNURh76H/TYtqW07v73fsNgRAkYcg3vvQlTk9PkdYxzoaEkWI2O+b09ITRMPOCkyqgqWreevMt0iTlsauPM58vqBcrhPOH1DiNCdcW4FJhrQbrTfNUGLDIa2aLFUYEyCBCWEsgBIM09UAj67wOnxKcnp6yXK2I04xsOGQwGnNyuuDW7bt9K3qxzCmqGiEDti9c5OLFi+/z6vnO8XAllvvaXOuS+z0/3g3se364tV4ttTth+3aR6isHhR+2b21uMhwMyJLMD/KBOImIk5imqTFGs1qtCMOQ6XRCWZeUHfPWI7JqpBSMxyPqpqHq2PZyJGkan1ikVIg1ykqKrlrww3kn6M2MmrYrsdumm814I6OgmxMZa0mSlLpuyPOCumqoqxqtTQceWA/jDUkUE0fxuhWO6BSHnbA9nHg9Z1n/+7yaQc8VOvf3WMf9FcyjeDhid2ebNZHYt2YNvc2uaf2JvqlRUuKCAJxfV01dUVUlVVXQNhXGtL59Kx0C5deYAy9A2gGAnUNJReMMZZkTKIhC4fkxgWJ7a5PZyRFRoLxDozXkyyVlWTAeDsmSBD0aEXYQ/SwboLWhWC5oW0NZFAQq6sAq2gtOvnuNQEgm4zHFckm+WHDz3WscHx+hm6Z7TRKjDXVZksYRIQFBZ7Q3ny9J4qRDSwYelIC/P7I0I4n8Ye3o8C66bYikv1+8jpihrUpkMiSQgqD7eLCe51rTtby9TJLWpveMklJRVjWrvGA8HmGdo6yaDu7tZflVEL33H/UBiYcmscgueUhE7xK55qioe1j35/XCvLe8o5OJxy/zXsph5YXirl271v9BsywhDEKksIDvCzfHa7E5Dw1uGg/5a3XJKl+xKlZMp1OUUty+c4cs8zIrL37963z9pZcYZEOCIATkWnWb4XDEcDBCGw1CMB57YlgURQgv3UQ2GLIGbzpnsc4QqIAwCEhTP/P5F//Fv9QP1nXb0jYtcedCGQTe4TJfFT75OgHqDLVtTEtRFf38qWma3vgrjmM2Nzf9iayDbK/BAvfHe7XHHsWDHx5Y5Dd/1fGtiuXSt3n379I0LWVRsrm9QzIeYdvaS6q0Fc40YL3ciBCOUHXAkm5HWbtH+k6YxVnL7PSUtm0QrmV+csjJfoN1muVywd/9+Z9jOhnzZ37qTxGGAd948Su8+so3WS4WbG1skqUp0+kG6XDEIAppyoLZbM5v/uqvMJvNaZpOuVsGnRmYIzIC4TziMhsMSLOMui7RuqVqS28jIRxFlVNWBWHghTWHA29LbIzn4LStYziaoLXl5HjGeGOTT3z841y5cpW9vT3+yr/77/DyN17mqcu7xHFEHMfosgStyeKIdDjkwtY20+GQtq6pm5a6bbq2dUgcxh6I0LQsliusaVnlBa02bGxu0zQtq7zCIjEo3nz7Onf2T/ihP/O+LZ3vGg9NYnnviuRM30h0A+97q5d7NzkhBEpIpFp7tYT+xNIN0qW0RNGENE1Y84+iKMBhaU1DGAaEYUAcR/3PiJMYoQTD4RDAzyc6fk1VVZyenjIcjEjTlDCMu6qmJYm9P73QHSnTGA8uFr73ao1PbOuk4m9O05fei4UjCAIuXNjDOUdZFt33+KoI1pbBXZL1qZkg7nxihEEbicX2s5p1z3hdsayrlvXw/r3aX+eTyvnk8ige/NB12bVKDaKz7G7qiqauKFZL2qalqhvausLoBmtcx83ylUzT1NR1SV2W6Lb1lXinEG6cn0VY449zzlqKcoW1Gmc0tptvCOHdGPPlgjQKvAUwDqsNTVlRFwVuPPHQZ934akkqqrohXy7IVyuKfIXWtoP6B1ht/MBb+OdL45i6KFguFgSBBOGoqgIhBWHsgS1qMOwtwZumIahD6qpBqYDRaOwN9+qGw4MTpFLs7OwyGHonWdcpeHhagcRqjQDCQHltsjRlZ2ebjY0NoiDw99LacKK796WUjEYjjyIdpKTZgCCMyYuqOxQLwihhOBxRlDVNY97XtfPd4iFNLPfqhPUVSv9WdpJ6XnFVCN9yClSACoKOUBiQxKk/2URRvwlfuLDLeDwmX81RSjIYZMzmMxbLOePxmCTxpXHbtsxmM7YHW2QdD6QoSubzX8c5LxRpjGG1WnHp0mWuXLnCZDKlbQ3z+YIwiAiCiKIqaZqG05M51jUgJVVResOjpupnLGt0GADOy41HUcif/tP/JABHR15ZdblYIKUCPHpnvXCjMCIOY4bjIUEY0Ooa5wzGmX6+sm6DjcfjPlH0IIPOeXNdvbzX8P7+t4/iwY789BhjvJ6dUl5+KC9y6rpmdnxKqzV105IkEYMsoa69tXZZNaxWC5bzE05Pjzk6OvBVM52Pe79uztCEQjisaZFKEEUBWIMSliSOYJAwSGOUcMxOjpmOR4wGA2KliKQki0JCKWjLkkVVs5rNOyXxOU1RgNakgdfVUyqgwWK1Q2EZD0Y8/dRTvPnmm9y+eYPt3W2iKKRYrgjjkMlkh2yQkmYpRVVQNzVHRydkRUmaJHzgAxlPPPkURVEAkldfewshAp546hnyPOfmrTs4BNlwxMbGBsJZFosZgVKMsozpcMR0c5MPv/BhRtMNhqMR2lpaY2nqtpvZVkipePKJp9mYjtnamHL5sccZTyZcu34LgCRJmEw3uXL1Sa5du85ydfy+rp3vFg9NYrnH8571mfxeIuQ9n+urGNmRsDpGvpTYTu/KBBFGG4zWtNr01cTa810pD9tN0hjrhv0ge42gCsOQJE7Isoy2MzGK44Q4iru+taXuMOtZNiSOUgLlMelKhn2v1BhDmoygG/w1VU1T1xjrUWFGa885aSrqqqauK3Tb+t5rWYHzyrHOuc4PQ/WJdd16q+uGpmop6woElNUKpQTpIO2v71oS/3zVso7722HfDW78qHJ58EM4A1ajmxpNg0BgtEY4wyCNqWqPYqryvFfpNdahrR/0t3VFW5WezNe77/SMso4YKVGBn1VqWsBgWk2gJEEgqcuCYrUklIIsjticjgmkRDcVUaBIoogyz6m7eafqWtZNq2nKgkB4P3mswWm/Pp3WCOstkpuq5No771CXBZPRiLauaZua4XBAEAY4YynygrKq2NreZDye+I5CEhNFHkZdlhWHRyccHZ+ye+Ei080tirKirhtabYjihPFkwnPPPYtpa955+20WecWqqDsR2qZrUzeURYlxXh+wqvwM1Ss/N9y9u0/b1Dhr+MpXv0YUBsznc08j0BrboesmG5sMRuP3Z9H8HuOhSSzfAjfutk4pvpW7sm6DnUGOvYbWGm7cGo0zhij0A0ujDU3d0GrdIb8McXxm8BXHfp6xnmU0TQN4leG1QGPTLNHakMRpJw0hMMbR1JowTMiyIWGUENg1/NeX7XGceCUZFaICL7S3XoRrcq21mla3lGXOcuGrktPTU6qqpCwq/zs1Guc6ghpnBEovvwJt06IbTbvwcOPlakacROzsbqOU6kmd4BPnunoBn0T89RPUdf2eEOP74caPKpYHP7welkY3VWd9bbs2qSRLYoRzzK2hLnNmznZseoFQAbqpfWKpK3RT0RX8nsciJcjOlE6KXoIe61UdTNsSyogoCMjnOcVySSAhTSKm4xFNVVLmOWEgiaOQqsg7lWHbz/ysddRl1ScWa01fKaE1wkEQCpqq4mh/nyzLmIyGHJ0e02rN3uWLXlTVWsq6odEtV69eYTQaMZvNCaOAKPKt67KsODw84uj4hL29S0w3NiiKsh+6x0nCeDLl2WeeoSpWnBweUlb+HvaPmrZpqMsa41a9ZXNZVVjj/Y+qyit5GN0icFy7ds1/b9tS1TWz2ZzHHrvC5ctXmE43eqWCBzUemsSyjvfis8i+cvFvPd5K9Kd2KWQnI+GwzqEbf9on8zDawWBAEHo5hrN+asFstuDGjWuEUUQYhd3p35LnBcPhkCeffBLnBFXZksQDGCsGgxFhGFOVDbp1CAKSJCNNhjjrX2OWJn6oaR1S+QUiZeBVA4C21VRl3cujrU9+SZxiB65jL4+QQvZIruFwiG49ycu3zs7aEFIqTGvQraaoCpq2pm4KsjRjZ2eH4XDIcDikLMu+NSKEYDAY+BNXl0jPHCTv/Vs8SiIPZ7z89a+jAkWcJDjXkbo6ccjJZIOo46qowMsLrasFGQREYUAUeQ/2KJS+BYY/UeMMGIuxGisF2BYpBaHyQkV165NVXSw5OTpgOZ+TxhFNWfLl3/ltoiAgVIrTo2PqqiIKAt8uPj3toPiWJMtw1jHKUtIoQqmw47NJTKOx2uG0JlSKZHvbm2u1LYNOumUxn5OkCdu7u2RG0xqvap7nJXGcEAQB1gja1lLVmsOjU67fuMVbb77DM888y4df+Kj3epKKx594gulowGuvvY6u/UwkSRK2traYbmwQxgm/+qu/StlojmYLLBJQTDc3iOMYZw2npydoo337sW442D8kXy1ZFQVJnLCzu4sQitligVDedfZBjocqsbzX8L7/XP95+pTiP3b2+W6a7z/gXMe+95WHsd5AyKsQhzS1oKkbDg6OyAYZ2SCjqqoeNRWooMOYQ9t61r3qXBmF8J7z6zZUoCKiMKau13DjkKasKKvK83CEIEkzhBO0xlBX3hgsisP+Z/gKwqskm2jdTw77dpUQwr/2IOxep2U9uA/DEC09JLSsRV+BxHFElmUkSfItFct5xWN/udx7JpD3Gto/GuI/HHF8eESUxEw3N+j4jAgkUnXIqvUHu4dwZ8KjUnjbbqWkP8iJDqjcDab9W7DGCxLhBEGnJC4BbQxaNzRVSV2VKCkwuuXw4IBBmpIlCXVZ0jYNCtBtS1WWmNZ3GNaz1ij0xnxh1yUAgVEe/KLr2lcuUvZIrEiEWOdYrBb+3gwChJIoa3HW0WrdzXAVUgYY41tWZVmR5wXz0xnT6QbzxQJjvDRSGEYkScLJ8T5G196aIwhI07Bvn9+8eZP5quDO0QnGCqyTXLp0iTRLaeqKui5xeOHXpmmpqspz1TqychhG2K591jRt3315UOOhSSzqHPJr/biHNCnXonf3MvDX7PGmaXoGvkdwCcrSuzqGYegd34oSZ2xXASma1nB0dMKGhSCI+dVf+TVm8zk/+if/JFk2BKdoW4ttaqzxPyNfVYxGMRsb2ygZslqVxPGA4XCDqjr1mPmq5qtffZGvfe1Fwshv7p/57PeBcBydHHcTUMtzzz/HaDSkqrypj5ScawXYHk1S1zV3795ld2eXne0dDg4OsLYmSdKeg1KXFavVkjfffJ2iKvjQhz7AZDrupVu01v21ds7Rti3L5ZI0Tdnc3OyT6vq6nm+H3V/JPIqHIw4PDskGmbe71h0zXkrvIxQE1FXN/t27jEZjRqMxla783zsMsE3Dha0t0jCkrkqSOPWHKufh8zIIaWo/YwiiACehqGuUgDgMCITCCIXTNbop0J10SaMkyjqEsT6xtK0XcbSWQZohUk9OU0GAtZYkihFSMhyNey6OHHiliTSI/G7gHEFnr5wXOVXTMJvPaLVmuVgRxl4hHCTOQFGUjMYhOxcuUFU1b7zxFlXVEIYxw/GY49MZ//l/8bfWEgMMY0koHLKeE0rIspgoycjijHlRsqoW3Lx1B4NgOJqQl17tfLFaUdY1VblCgqcftIajwxOCIGI0mRB21VNRFAShRgUtaZb5ZP0Ax0OTWL4t1Hj9+XWdsp6tdCnGH7bcue85mx2ojrQUhiFSyr5Ha7pebppkbG/v0DQNt27dZj5fUhYVZVl3uHlPVvR+L74dsIZt+lcmEci+PeWl/X1rbl12i6KibTXO+pNeXXm0llj3izlrNxnj3eystf5nB0EvveKRba5PlOuEW9c1JycnmFZjtKZpfd+3aWp0N0tZI8e09gCENct+/fzrn+9nNvfqhT2qTB7e8LbZDcWqwHQzljNnVkVVeZM4EJ14q7e+Nk3tDzvO0TYtZZ4jOwFK4/zalDik8KN8rwsrOogtnj/iPAnYddWQXM/prO0rJKWUvy+cQwhJlmYewtytfyssSeorFSFEv26jMCZQAaM0w8/1bZ9Ylvnq7JApFU5ojLUIbajrGqREa0uRl9y8edOj5aTnrimpvGqGc8zn857eoAtLpGBnGCKlo6obpJGI1jHPG4pae+IYAtP9LkEYYh20xreow9DPV03b0LaNv8+d7Z1t/f1nEFZ56PLmxvu2bn4v8dAklveKs+H9uX9zPukIrNEIEZ6JUHZwZASkcYxwMBgMWK1ywKOrmqYljlN2di7wfZ/+DL/0hV/mi1/8x1irCcOI/f0jsmxEGCYMRyOywYCTkxllWRNFCUqGNLXGOUkQxOR5yXy+RMkIFQmcFUSh/7q8XHU+9gnWGbTxCcBLurTdZu/8AL+tO5vjljiOANdv/js7O97n/nCf3d0LxFHMbDbj6OiQL3zhl9m7cJG9ixe7G9Oxv3+Ac5bHrj7Wt73WQpQ7OztEkS/v1zOXNXnyvDXxI3jxwx113aKNw9rDvuO1jqOj025ofchWXlBVNaPRBKUUs/mc09mMuqpYzmcc7d9Fb2wSxwky9O3aKFQoIFSKUCmkgkAEnuhrvIld29QI51BCen6HMeD8Pa2kJEtSTGgoCy8ttDGdUpYlRVH4mYqDza0t2tZDdqPIkxPH4zFJHLMx2kAIL+uEkFgHL736TQ4ODhiNPAozCEK0NdRFQVF7EEKrLccnM373S19iOPRaZOPx2Hs5dSoFTVN3bbiQuwd3kc7w3Pd/AqMbbly/RtnMqFrLqnYYFNnGLq1xzFYlKozIRlmHwPQahWEkGY5HrBZzynJFW1c4ZzuFcdEBefw+8H3f92me/8Dz78+i+T3GQ5NY7pmbrD/WI8LO/fvciXqdXGR3mgF/arLWdLON7sQvZK842rbtPbBbYyxbW1t84AMfZDQaEgQBZVFS5CU44WG+FFjrTyJeA+xc1ZOmgMAaSxKHgMBoz53JsoyqrnDO+1Bo0/TVhTWGfJWTZSlhGHqHPGdo6toTps5VYdYa8mIF1iGlIF+tKFVJVVcEoeLKlccYj0YkacxoPEQFkjxfUVbDXh9s3VpbJ5nz/z6fUN6Lff/dKpdHVc2DGUdHM6+NFS47kuzZAUwFpkMH+uq6KEqM9n5FbdsiHExGY5IoRiIIA69YrILASw9JiUFjdUuDRklBHHszPW3avioJgoA4ihkMBt5TpQPaKBkgQ0kQOOIoJY5jtra2ONjfZzabUxRLjLGEkTemq1uNDAICB4tVzjIvuHP7AN22FEVB0xparbm7v09RllRd1SKCEBV4Y0DXSSE1WmOdI4oTssGQ0Wjc87w8NaGlrmqsNphAM8gyQiWYLZbgDEGUkEaKCEXiArQTzErDMi+5s3/EY1cf5/KVKzzxxOP+vgwkVVVwdLDP+LlnGA8HRGnsyZaNN2J79dVXiZOULBuwub3JeGP6fi+f7xgPUWKhN8hal76wziPn/s25jWyNEpPSozysF2i0zncoVdcC86Y57p7Est5Y21azsbHF8899gMeuXEZKwec//wXyvOhgvJqmE5cUQp4z2/KckiTpEot1BEHkX6HTfWJZLJeAI89XVHXVJxZnLat8xbgedXBnAXjky/2+88ZaiiInCkOiMGKVL72qLBAoxWNXLhNIr1M0HA5AwN27t6nKsktatk8obdvek1jW7bE0TXs1gfXP/r22wh4llgczjo9nXv9KQJZlpGlG3LmRhuFZy1VrQ1lWlEUN0A+kJ11lIIVPLHEU9jPAQAoa14mpGoORgkEyxOHQ1kI3LA+6Nu4gG/gDk7He+EpKhFRIIYjjlCzL2Nra5vR0RlU3HJ+cUDctW5ubWLxxVhBFhM5R5DlN3XDn5h3KomA2m1EUXtNvOB4RhCFN0yCVIkoz0iwlSVMPhbaWpvGoyiRNGQyGjMcTrNX9/aDblqausVpjVcDWdEgSB8zmC49+ixLCMEGGCSIe0Fo4fPsmq7Li4OiEx59+lstXrvAH/9Af4srly+xsTrlz+xa/9Iv/iOeffYYPPPcMW3sXiOKI/OiIN15/ndu3bzOZTNjY2GS6tclgPHr/Fs7vIR6axALn5yxn//Y4FnHWAlsP99eiiaqbEzjXJ4peTiE4R+jrvn/NTfHtojv88i9/kabxHJfDowPCIGC5XLK7s0uWZWhjaHTLYDBASkVVVd2MxasV286zXipfcYDAWMPW1ibPP/8cF/Yu0LYeSpmXnvWM9b3osiw7wUvVgRDonlP3hl/atDRNTVmWjEdjLuzu8uUvf4WDgwPm8zlBEDAeT5idnHpPCeewzpDnKwbDAbPZjDAM++oqjmOGw2E/h1pL6sN7w43fqxV2PyT8UTyYsci997p1FmMFjoCmNajOrjuOPAglSROSJOkPHcZoQhkyHo0JuiF/VRS+rdXNLEOhiFVAkGWEkQIsy8UpdVN5GO1qRb5acXp0SlF4tJWxxicbqQik6qv/1WpFFEVsbm5xeHTE4eERJ7NTtDbkpdcvK4qS4XjEYDj0hyGtmedL4jjmAx/+MHfu3Ob2nTs46W2Rty/ueefKKOp/Tt3W6E7aX0pFEqdUVc3+/r6fB9m1Xp9iZ2vbm+Xplp3dHbI05s6ta/5+by0ajRUVf/qnf5Qnnn6WVkW02rLKK8aTCePJlOlk7P2blGBV5HztxRfZe2yPrct7hIFEOEs6TAnjgKbKefrjH+Ozn/1+xnFEcXLEYO/C+7yCvn08NInl/NC4J0QC6+7Xebb9eQ0x+nbRmXUvgJD3wpXpBoxnMGKL1ob5fNbB+wVVVWHDgDRJSdKkg1i67mTnq6K1F7xUsgMP2H6Q7nW/PMw5zVK2t7dIs4S6aVgs5l41NcsQ6z6zOpNkAQiCM4DB+jV7MzAvu6+U9NL42psUrVYL4jhhMpmitaaqKoLIE0XXVsRrW4H1tT1viHZvu83/zPMqx99OI+z+ZPIouTyYUVZ1PxRWKuoeEimFbwdZx2A46mC1lrZdG8+1fesMOvHTukGJzkgv1EhEv9atCXAYTk9OqOqS1XLZEX2XnByfUpUl+WrVIwyVUCjhE4sxhtlshlKKvKxYLpYslivyosJaQ1l1iaUsEUGA6IzrjDFoa4iFJBlkRGnqh+PO2yaHceznkypA00HrhUQqyJLUD/2t7aDAlZ/lOjDWoITvcjgpccpzydIk9XMcPBeoNQ7tLBcuXeKZ5z9APN4EqbweoPPinEY3OGuRtkUbw3wxRxtDnCagG7DWc4ikoGkqkjhke3vT+8eslgz23u8V9O3joUkscC65cG8iWcu2nOe2nJ+3WGv98LlDmHi5Fi+yuIbQBlIRhxFpHJMlKXXT8NRTT/AX/+I/R9M2NK2XeQgCj29XSnE68yzeVmvC0LOBx5Mh4/GY7e0N4jREm5ooVqRphEP3tsCTyZDp1Etiu+73sViMM753qzVJGiGlF7Z0rmtVNY1PcB0jzQ/VLXEcUpYF+/t32d3dYTqd9C6Sw+EIZ3zrIUoihJRUVUkYhUymE1arFfP5vCdGnpycEEVRJ5zpK7j1XOe9xCgfJZWHM27fPsRai9YNWbYgTQeowP+96romDAJGw0GnI6awzh9CptMx4/GIxx670qtTKCkJo5Ai91X3KvcqEYvlkqYuva2Eaz1RsWkp8pxilZPnnpSbJSlpmrK1tYWKQ8LQEwCllGzvXKCsKu7cvYtGEKcZm4k/2E0mU4y1BHFMEIXQteKkc6T45PnbX/kKaZIw2d5mNl/StC37xyeevV/XDEcjRsMhm9vbjEZjPv2pTxGFAbppeOON13nrzTe4sHsBJQVf+8qXma9mHB3sszGZMJ2O0Y2hCQ0b2xdASlQcUzWWRjuy8ZQgSVkVJVKFJNmI1nSmfHXjzb4UhFHE5ct7jLME6grXemkXGYU0dcXB3Vu8+s2vM8xi9g/2KcuSv/jhH3gfV893jocqsaxjDRs+G+Ovk819lco5Nr5zritxPTxXBar/3nvmFd2cxVjvf7K9vU1RFhRl2cnme1vgNdfDVyTQNBWt9hauWje0bd0/rNU4TPfqvEy5h0YGXobcedkVJRSRirBdKS9l58THeiMH62w/9wDX65kFQUDbtiwWc4zxrbI1jLppml6NoKrqrtLR2NpyenpKWZZUVdX3x89XJevrpTszsvPJ+9vNWB61wh6OCMMY3c1AGm1xZUUce6h602qM9oeXtRXF2hTOWs8O97bYHhKzXC4JlaIoC9q2pSwKirKgLEq0bnDO9knLOg9u6Q8pjh6i7/3rDQ0N1vn7umkMZV2xyguk8oN2YQEhaI2//6Ik6T/nW7eOze1tVBDwVJhwcHjA0eEhTz3zDGEU8+qrr9HouhOE9Nfg6uNPsLe3x+OPP07YodT29+/69rmzeNtlvDOmMSglSRNvAJjnjkq3yCAgTRSjyZgoHZBkQ6QKsd3BrNYtzjqEVKggwFmBsQ2uI2cXRcHdO7fJosBboNeCqsyRQjCfz7h27R1OT097NYwHNR7KxAJnqK97Ziv4BXqmdCw6pV8vNSGVQqmgq1hUB7W05/grpjfxEkqQZikbGxMQlrqp/KxEglJ0w3FDEEhCFbJczVmtcuaLE6xtOTo6YDY7ZpXPqeuctq2I4wQhQSqLVA4V4JnERlMUlZfxjmKs0f7hzvSPhPBzGmsNdV3RtHWnYxYhpSBNU2anp8xnc+KuzF8PG4uiwBmHs47ZcoHWmuEwAyGwzvY2x5cvX2Y4HJJlWZ9c1gRLrTVt2xLH8T1/g+/09/luX/Mo3t/Y2rlI0zTMlwvqqmaVV6gg9tpe0vMoitKfnF3HqQA4Pj4iCALu3LmN1i26bfwMEG9S50ebsrdjSJKoQ3+lqEARRB4J1iQZUZR7jb0oJgg8+rEsanJT0LS+G3B8fIw2ButgPJkwGo9pjVf8bq2fo0w2NjwuBlgWBUIIvvfDH+GZ557jR/6JP8H//T/9T/mZv/E3+Jf+1X+dp59+hr/0l/6PLMsSGYZoaynqmh/+Y3+MT378Ezjj50xxGPL6669zfHzCIIm9vbAQhIHCBYrRcMD21qY/nNU1hdEk2YCdeMCVZ67y3AdfYHPnoh/imwZtLPkqJ01S0iRBxTHOahYnB+hO+PbWzRv8elPw/NNPMh4NqMuC2dEBw2HK/t3bHB7c/RbTvQcxHprE8p4yLu8BN773fdEPnB2uP32vWzi6bXHWEndtnyzL+o27dS1FlZMXK1rddmixsKtOaoTsdLqkr46Wy6UfIA4zBsMMqWA4zNjZ2UIq0LruIbtKCcBgjOt87R1ZlvqNHi+DYaxBCjpFAYFztuPYeE5JEscE4XpGAhsbU8ajIfrSXp8se4VjvOuSM87fkO6sCjLuTNhva2vrHsHNteDkmnC59me5P+4XoPx2bx/FgxWz2RKkIE4GXoLI0vmpqE47zIvVBZ1Vsep8jKI47MiBkijwYpLOWn+PBV5w0h/AvBvj2sbCGAMClFUIJ3posRSSIPBySM46TwVQAcMk7eYRjuFwxNPPPsfO7i7buzs9oGa+XIAURHGMdd4vZjbzQIBsOKBpW9565y0a3bJz8SL7R0c4KamahiiO2Nu73Lu/lmXF6XxGKCVR4L2aphsbPPPMM4QKbNt6ZXRrPZLUOYw2PUEZERMkCQbBaLrB5auPo6KI1lpPrBQGrPNmg87R6gbTNpzOZqxWKxBe6qaqKr7y1a9g24bVcsZysSCJvVtlHMU9iOJBjocqsbz3+3Av3Pje5COlZwtLZ73a6jn593V7xw/fvPy9Vy+uKZqi85mviJOYKI5RjZdSOT09JgxDtre3e7jmYjmnqipGowHDwQClBMNhyvb2pk9GbUVsUp/wpB+6G21otQUnGY0GWAdV3UGdtYFA0OUtTLfgqqqiaRqGowFpmtB2rN2NjSlp4tE7eZ53rOr6jEvTST8FHR6/KAoPZjgnDZFlGUopj/s/Jz55vnK5//q/14zlUWJ5OGI2X5KkCVs7O9ANlYPAD/BF45Fc68QSd60ZD3t3OGsxpiVQkjBQXcvXEgZn6MX1gUV1sOH1PNOZrv2F7BOPt3sQHUxfIZVkNBp78y0huPzYY/zRH/ljPHb1CnuXL/uDXl3z7q0bfl5hLdpoPwSfz6mbhqZtqNuWt95+i7pt2b5wgf2jQ+Yrf1iMk5Srjz9OnucURUFZlZyenJB1JnxBoJhMxjz99NOcHO6zXMyxep1YFMKB6SwmIikJohgRhBgEg/GES1euIoIIbS1BGOOkAm1wQvgWXOu10k5npyxXy87PxkP+X3rxaxwd7DM/OSJNIi5dvMhwOOzI3KseqfmgxkOTWH4vIdbwMM42ONdxVuy5wfPZINq3gYbDIUEYkWYDsixBBYoNMemsjD3iSyrV3VSwu7PjT+mCrr2m2NrYwlnHcrlCBQFJkhAnCVEY8vWvv8jrr7+G0T5B1E1D27S0bQN4Uy7rvABdVbfYTtY/TiKUEjStJ0XWVdnPV77vM59mNBqSJglRFBKFIUJKrHHEUUIUxn4A6hwCCdIhHN1cyHW/kz+RNmt57qrqy+wgCPqW2hrxBvTX7ttd/0fJ5OGJ7d1NnnjySX7yJ3+SbDQkGQyQ1tLUNd/4xkss5nMODvbRbYvW3tyrbVuUFOi2ZbVaEqWJP+A0NVhLlqXdHMJ0bWnR63U1TY2zjrJoOgZ92QumejttRRjFTKcbjDc2ePqZZ0izjDffepvBZEpe17zxzru8df0Ge5cuMRgM2LmwhzaGoiw6Hopha+eCP/1b008ov/biyxwenVDXhp2dKf/yv/qvkyQJ08mUqqp6FeU7d/c5PNjncH+fr3/tawzShEGa0FalJ1Y7Q5pEXNjd8SZl1sP9tXXIMPS8naLEOs+/yZsWow2JCnEColARSJBYkijA1pYv/+5vcXxwl+X8lI9+6Fk++33fy/7ta8xnx2xtbyGAvKxwQqI7byVrHjlI/r7EeegrnG1c5/e4+/cyd9/nzz9XLymvFFEcd20wSxh2G2mofM9WnP1cJc+10YwfKAbKD+HirhIIZOgrpEAxSDOm0w20blkuWqrSl+/rqqNtmk42X1A3voKpmzNW8toTptVNBxf2hMY1VDiOvCZSoAKvftq1wNZzpdCdaXytCxOPxfcM/TVee30t18TLdctrXaWsH99O3fj+9+9PKo/kXh7MSLOEre1NPvzhDzHZ3mK0uYmrPSfFOMPJyTHpaODtipua09MTmrpGAG3bEGUpOL/mppvbBErSNjVBoBiNBmdW4YA1moP9g+4Q01BVZw9rLcZ6pWGLJEpStnZ22djaJopjgijGCUle1ZSVd4+0QjLdmLJ36RKhCoicnyGuyc8WR1uWnmfWthRlRZ6X5EVJ3Wqef+wKUeQlncIwIo4TFqenVGVBUZSczma8887b7F3YJbqw292vNVJCGCoGaUIQSJQShMof3LS1WCxWdK1hKX1nontdCEEgBRKHcAaFBWs43L/L7PgQ0zYoJUjS2D+3lARpil3LKmmD0gbdKbE/yPHQJJb1gDAKgw6l4ttJYDzCq6tWrPXlcBh2QopKQUe4WieF9ak8jDxk0beMJOOOzbruIxujyfOVl7oIFYN0SKAC6qamaVuaxoITOC2wnVhcmngIsbWOT3zse3nhAx/xXaiuH2utodHaA9mdQyjVIdiU94rRGtmd9JbLJVprskGKNoZ8tepnQf53ANM0SCQK7xppnUW3uv89wYteWufJXUoFSMAYL43ftJ6TMBqNqOu6b1esB/9rlNhajeD3kkgexcMR6UAxGkfsXJwQpiGIBiNqROz40Mc/hLZeBiWOEqIopqormrZhdjpHSskgy/i7f+e/5u/9vb/HX/63/688+cQT/OV/+9/i8vYu//t/4Z/3vBa8TfdyseA//Y//Ovt37nB0NMdYT8oMkyEAeVkijKGl5YWPfZw//VP/JN94+WVu3b7Na9dueMh7GHF4eMzh4RH55z5PkiT8+T//59m9sMve3l5/8PudL/0u16/f4Nd+/ddZ5SvKquLk+ITZ6Zzf+K3f5aWXX+Vzv/hLNHXD7OSk0yeDj370wzxx9Sr/1F/4c8SB4p/5C3+el178Ct948au8dP0t5ifHTCYDQiUp81N2drbY2d4gHU3QTvBbL72GCyI29nZQgaKuSkzr5aGErr18jvRJ1mlDXRcU8yPKxRG2WTEdRvzWP/4iv/qLv4DRDVEYEEYxrTYUrcXICCMTWikx7tGM5fclpBTdoLyzH7XnWlSq22SNRnSLq+exnHXHvqVNdg/5757BP9ApsQZB4KsSobDG0FqHbg3OQhRE3QYvEZ2/kcepOQSWKEoIo7irnBxuLZti9BkXR/rE4oenrpfCl1ISx51tcZr4GzwM+xZb2w0SrdS8lzeDW1v63fOxM26PlMrzZ4S+Z36yvj49LFudzaXeC178qEp5eMMr8Ra8/e5bjCZTBuMJQdfyDZMQaRRWggwVIlBgFMIFiNBLC2lAI7BCQBCgoojB2G+yr7z2BpPRmPFwxPbWJkIGzOcLlssVujGgZM+P8SulxljnNbyCgMFozNbODkYIXvjoR1nlObfu3CWKYi5fucLx6QkA77x7jcPjY27eukMSx4RRxOuvv8n+wQFhGDMeB4wnAqsdVVnx1FNPsbOz4+cyrabaveAPeAKefPJJLl/aYzyZYJqa+dyTN601mLZF6xZnI6ywtK3zPBOB73IgcXg75I2NjW5eKb1mWmeDQadgLp13dkUJlBTUZUFblRAr2rpitVyQdtI6znkQxGg8ZWNzi8nGlp8hPZqx/P6EJyZKEN6Xvq4bJpNJb8y1VueNk5Q4ib3ekFrL13/3WG+DYo2Wav2GO8wG0LFAirzw/tPGY87H43Enqx2wWPj+s+jELv3T2J5fgwCnzm/E/suUCsB1lr/WdUnJP8bD4VmVhaBWAViHrhtMBzxQcj30pH+AREr6hONlYLoiyfjZUBRFKGtwuB4pt47z7a/19V1XM4/i/39CSMuduzf4uZ/7WZ555jmefuYZLl+9ymA0JspSGqs5Wcw7r3VYrnKatqUq656rcjA7JRoMuXN4RJwOeOKZ57l+7Rr/l3/r3+GFD77Ah194gU9//ONIAa+8+hqrxYLJYESaZcRJAlJ52XpZoduGvFhRVA0G+MALL/BCGPIjP/6n+K3f+i3+tX/tX+NHf/TH+LEf+zEOjw45Ojrm//N3/y7Hx8feN2ljg42NDU5OTgjDkJ/6qZ9iZ2eHCxcu8MUvfpFf+7Vf4y/+xf8d3/M938Ph4SFhELC9uYHRGq1bAgVKCqIs5bVvXuO/+q/+NsJqJB6ogDUUZU4gBVEAdV3QNpWXauoOsMPBkOeeeZYLu7skcdIrZwincdphjSYOFFGgIMqoq5Tl6TF1kTNOQkIpGQ+yPuFWtSEdDLn62FWefOZZnnjqad548y3mi8X7vHq+czw0iUUbi3IglTf5Sbs5gpewbhEIwiDqNtquiuC+xOK+/Unag8vOALo9ZLerXpxbn/QFaYe5V0qxXC5ZLla8/vobzOcztLU9umM9w/BJUfTD//XzyM5USQrv57KuoILAS49fuHCBNE3717yefbhOk0l18hVwr8Pj/ait9e9CBzhYf1wbLy649l5xzlcy3gHTE9Wc63zKjfXf/i3VkbjvLd/yGh7Fgxm+paqYzWasVkuqquL4+JhlnmOlBOFJW8Y6r1phvQlelqbYOCFLMsajCYNsQJqkRGFEURSkacof+kM/wKW9PS5d3MMJQV1XbE43iFRA2kGDq9o7qDoEWZYQtArjDEa3LOYzpmoTpGB2cMBqsWA0HDCdjNjcmJJlGbu7u8g/82co8pzlMvezxzDg7//9v89sNuPy3h57ly5xcW+P8WhE2/j5UVNXTCbjHjIchAFBFNAUK9q6YbVccHjnDndu32I8SBkPB8RRhE5TkliRRCGTUcZoNEaqgMPDI6oOLTYcDHj26afJ4oTToyPu7h+QFwWrfIUQgiQO0U3t3S2FZbWco+um4wD5TgwWlquF3/PClCg2WG05PToBJylyz0t7kOOhSSzrjU1ZP1wO4hBjjSdO2RalFEmSdIZEok8udOd/ONv63rOlc/7z0M8TTNfeWucjKSVJkvYb+2q54ubNm3zlK1/hzp075GXpB4jOS4yLjsToGfvqnhZTEAS9OVEcp/3H4jgmiiJGI69svE4aay2y83Oi9b/75MF5YIO75+E/dnYNjLFUVd29Ht0TR72iraZtvW2AlKa//ueh3ffGo8TysEWaZrRas1gsKIqiM4U7RUhJ2bbEScLW7gUvQ2Rsv+6iKPaIL6EYjyak6YAkSQjCgDzPSZOET3784x7+HnlP97Ku2djY8DNSIC88K98BQknGkwlhqGh00yWWOYPRECEFB3fvsJidMhoOGI9GTCcTwjhCScWHP/hBz9ZvNU3TUNc1X/zCFzg6OGDv4gWuXnmMvcuXGY2GmLYlXy3JVyt2L170SLWyIIg6O/KmpipylrMZh3duc7B/F7W7w7hz2bQmI40kgyxld3eLOAxRUnF0sM+yKLEmZJBmPPXEkzSN5vjgiGvvvMvJySm37txGKcXGdMxidspidoKwLbquaOuGQAnvR2McGMdyvqJuGiabIUZ7YM/J0Qmz2ZI4G6CCB3vrfrBf3blIkhRtNIvVitFo5GWuG9fJIwiCMGQwGlLXHjabrAl9SvbIlPvjfDI5/1GBIAzXJ3PXndTPNuuyKPo/7NbWFuPxlN3dXQ4ODvlbP/uzrJYrj7DCdQisdTXinw/OkGZ+tiFoW6/DFHZzlDRNe8Ot9fevK5R1xSKE6OG/5wlT64RzXlWg56B0/wuCAASMRqP+daxf05qAdf+c5X/M3ORRgnlw49133+Xy5cf48R/7CXZ2d9na3sZ2FYRBeDBJozvwiSBNUsqy5Gf/1s+yXHRrvGOM/+N//GsoIfnt3/4dlJS8/dbbjAYDRoMB+XJBXZYcHx/jjCFSCqsNAtfPH+qq8vBgY9FtQ1WXqE7x4R/8N3+fmzdvUaxy2qbBGW/MBcKjMbu2rZIe9LK9tUmRX+Ti7jbT0QBdFVzZu8Af+Oyn+eXPf45f+sV/1LfPm8oDdwIl2dnaIAoVx4eHVGXB1StX2Zh4XbRQXqGpK/LFjCCQtNoQhd5/ZjgY4mTI4qTg5vUb/O2f/dueDxRE7F26RJakvPHK61R1RRJHlPmKqlgRBwKsR8sNkoTN0YimqqirEiUDhlnM3oVLhFHsFaTrnKrWZMMhqrMueFDjoUksXu7Bk4f8pu2Zv+IcHFhIhaPpFrw7txGuWejubJhyLs72vvuJl3QGXoK1VIy1voXk8JyOIAhJEn+iSdMMIdeIqk4J9hx6w7m1PtJZ+2oN4y3LChCdBIYnOq595teJZM2Iv3+DPw+fPj9Mvz/heLKo638vEGc2xh1y7DzPp5fHkap7Htf9Dt96/dYfE+vMBX06f++0/ije7yiKAmMMo9GIMFwbZrXeWkH4zTMvSk+jF4o4bVjlOW++/ianp6fUdcPW5iabm5vekdRa2lZjpWSV5wjncMayWixoqtK3rJ1Fdm1ZJWUvwrpWoFjfD1600hOF333nHY5PTrzaRKc8XuS5R1D6YSLgk9BaSDWOI6qyYDGfdcP3huEg46W33uL45Nj7Dxkv6qqkH7JfvXKZNE04PTkiDgN2tjc6p1ZI05QoDGjrEuH876lD01X0ikB5BYGiKHnjtTcIo5go8g6zcRwzO51RFDlSCXRdoeuKrekIJaGpGiKlutY94CCJEoIoIssGICRl06JbX7k0dYM0j1Bhvy/hJa/BCUVVt7BcMhyMicLQL0TnODo+Yd2q6SQn732STkb4bJuzdGpj93FgHFXVsK4s4o6J65n5sFjmtK3m6OgIKRTe597Dg6MwJo5SpGhpTYsz7T2Vw5rx7zdovzic8xu9c7ZnzHtFY9d72Z8Xg1zbBQO9Qdf9iWWdhIG+2gmCAKtb7y1zeIJSgW9BBF7TKc9zmqZhtcoJgoDReORtBALV3cimR4idz9Dnk4pzHXrPdRfaifcqCx/FAxDbG9scHx7x1/7qX2Vra4fNrS1u3b3LKs8pO/M6qQKSbECcZixXXo1CddVBXdbcvnWHu3fu8oN/8A9x9cpj/Ogf/xNsb23yzFNPUZclVVEySBOW8xl/+f/8bzA/PcFKQRLHDAYTz/twlrJtUEKRJClJFOG0ZnZ8RFlVzE6OGQ0G/PAf/RGef/5ZrG748pd+lxs3b/Daa6+xmC/Y3z8gThKSOGZ2eoLRmv/wr/z7PnkZzcnxCccnJ0ynUyZpwnK5wgpHGIfEUUQcRRwfHeCsIUsTVBKRZSnLxYK7t2+xNR0TRyFpllGXBXfvHpClCWmSoJ3EItmYbtIamB/PyMuSvKo5PDwmjhOaqsZqR13WJFHAaLLJT/7Ej7E5nfCf/Mf/EUkUcPHCRXTjtdfG4wkqCMnLhrKqOTmdc+mxq1y6fIXFctWZCz648dAklqKsMdaSZQNvI4r0mjvGkhe5z+Rty2g0ZjQafYsplXPO73Hf0s5Zc3PPq/aCUvKe+UWPiHK+evGcmog1Ymy9uRtz5r5oO1+I++cc94dvRYkeQbJ+e9758n6I9LcjK57/3PrtedTX2pfl4OAQKSV105CmaQ8SWNsJKOVtZK21uNb1arRn1/P+n76+hv27nGWUR5nlQYymaUjTjMeuPM54MmE4GpEOhhRVhXYwm89544232Nm9yBNPP02ee3b7IBtQVTUHB4ecnJwwn824cOECV69e5erVq2xubHDhwgXqqqYuK7LEb9xJHLOSEt02aKUIAo0T3b1prRdolVAUOYcHB8yXC4qyAjyx9+TkmLfeepPZbMbbb73J4eEhx4eHrFYrlos5bVOjk8TzRJzl8GCf0XDAY5cuIZxF4JhMpkRRyHg0wlrP1cqylCxNMUajtWYxO8FZQ13X2I7XpbVG4NBtTV6UnM4WffdEBjFCRWTDAa1xNKYiaDWB8vIyUq66+8fbdyjh0EqyWuWE3T4ihWC5WPWIUGtdB1bywrlhGNE0DaenM1Z5QasfbITmQ5NY7hwcMRgMuHLlCnVdU1UVWltq0/Luu9c7iYiCD37wg1y6dMlviABdqX1Pr9+B+A7jAs8hyXp9Li9A2XbViUSFEWEYMR5Nu8TjOhE5Dxsuy5KmadBWY6w/WZwXyFzPVZw753SJvMdv3qsAnHmhnOeWrJPNeyUcKeU9yez8/MRaS57nzOZzXnrpJay1jMZjtra22Nra4sqVKwwGg/75nXPddT47HX2nOcu3c5F8FA9mHB8f8+nve4b/4K/8h107ymABhCQejvjt3/ld/o3/07/Bj/zRH+Ev/NP/dF9Z13XDYrHk2rVr/NZv/Ra/+7u/y/d9+vv40Ic+xCBLiMKIOE6JkwFsCDCaumkYj8es5jOO5zPvHd+2SOUVLlpretn7WzdvYJ3h1u27lGVJ0nmSfO4f/QJ1VdM0LdPplCjyahMCx/bmtIfG58Jv4MVyztVLF/lzf/bPcOvWbW7euNWv5clkgtaa+XzOdDphYzphOt2gbRv+65//Ocqy5PjwiCxJmI4nNHVBVRaslgvmsznvXrvB5saEzY0J2XBCkikub26hnUSEK9KBZtQ2XHv3GnlRsrm5iTGGoijQraKpS37zN3+LQZqQpQN02/Daq68zHGQMBhna+LnycLKBCCKmIuLg8JhvvPJGJxT6YN9fD01iCaMYqRRVt3EXRdknmBs3b3YaWLBcrciLovciWbe6zhUmfYj+P3o9I3/idp5V33M8ZKe86k/qvo+r0a1BStVVFiFxFBPHcY/kwggw9Mqv683eb/xniQE8n2XtBbOOeyuEMzRYGIZ9f3k9Q7mfFd//jl0bbN2Cm8/nnJycUBYlTdtSdjeqF9Ac9/Ok7nL0j7XUjX9J7r63981W7pm5PNg3wP+SQwqJxFtMCKWQUYQzXv6nrWvauvK+QEAUhB5yLEEKRVVWtE3DcrHk+OiYKI6YTCbQHXiWy2W30UfYtqata+LIt5ea0ZA4TUiSFKE8c6xuW9bae8Zo8tWSsswpq4pEpD1QII4jkiShyHPKouDyY5fZ3dnlIy+84Pksx8cU+QprDEkYEIYB//0v/EOSJCVNUgZZgpCS1XJOnufc3d9n/25AFAZcunzZAwbaFtO2FE2FaWraOqIqcqzRSCFIkoRLe5fJsoTBIEFbaLVhY2OT0XSLT2zv0hpLayynsxltqxkNR5yenvL1l17k6HCfk6ND5sslbdswGI0wuqVcLUgGA4bjMVXTUtQN86LGArWGRZ7TGsPHPvIxtra23+fV853joUkscWfk4zV/CvI853Q2I1+tuHnrNs450jRlsVyxyguGwyFhKFFreO17POdZQvH/69s4QKvbc5ySiCAI0a1vcXmROZCiJYoioijufF5i4ijqT1K0HayXtvfVXrfJzs9GAMLQ9Zv/txNzPA8zhnuTyf1fd75aWaPJzhLLKWVZUdU1rW77KuvixT3CMCRN029pJa55O03TdMnm3nYbnF085+6fWT1KLg9iSNHJAGnt5e6DAOF8C7dY5ZR54VtBjp7z4QQEysNs66pmuVhwcnxMFEaMRyPyDrmVFyuyNEU4OkhtTRT5tWVGQ9JBRppl0LWAy7ruZF4M1mjKIqeqCuq6IQy7djCQpSlpmvHu/F3apmE8+gBPP/UUP/5jP8Yrr7zCyy+/TFXm4BwXd7a5ceM6f//v/T0+9MKHeOGFF0jTMUop9u/e5vT0hFs3r9HUTWeSNyPLMnTjIc91VdLWFVWpqIoCZx3TydgnqL0BKvAme7P5Cq0Nk+kGV598kk9++rMdathL5AshCIOYGzeu44Tjpa+/yOHBAYvVCt22bF7ZwxlNqxuSbMBgOGZ5sE9eFFTtzDfHREDVep2wD3zoBZ599tn3e/l8x3hoEstnPvMHuHnrFp//pc+zWq0o8oK2abwDnraEQUiSpJyeznnllVd5/vnn2diYnhs2f+dYj/o9VcMbZ3lPkgajHVLqjqAoSZIMa9cGXKojFnq5FN828wu1bXUnze96NNZ6lvNeEipAP99Yl/Xn3RvXVcoaOXNeD+y8d/061l+7rljquub0dMbs9JQ0S4miiLbrKx8eHvKlL32JNE0ZjUZMp1OefvrpXvRy7c1y/nreX1F9Jzn9R/HgxXg8Zn9/n7/2V/8qQnm/eJyHGRd1zfHJKUmcsFquePftd9jY3CKKY9rW0tSNlxfqOFez0xmHh4cMsgFRHBGoEaojMcdpRjIceV7XGlxjLLpp/YxFgBLd/WMtRVFQ1RVlUSCl4oUPfog4SRBS8NiVKzz22GOUhW99f+Mb3+Dw4C4///M/hzUWYzSLxZy6LHj9lW/Q1DWPP34VawxvvvkGN29cRypJXfn1fHnvAtb4drawlmK5II5DsjQmy/Y4PTnm9OTYV3eh7LhdXpDWtd09GMQEccLdo0OGm1sEScRqtuBkNqOoKhaLBf/gv/2HnBwfc3x8RJGvUGGIdYKybXn7nXdZg7zLquLg8IjBaEgyGNKsCprWsCpLxtMNdqYbfOXrL/KNV1/h+/7wD7/PK+jbx0OTWOIkxVrHnf0Df5oqin6GghCEwrtFVlXFyclp31I6f3I/z+lYs+rPj5fPD75V1/ZxzpthWUvX9nIdO31NRjw3yHYel9/PSXp48RqOJu6BR9+fXN5LUfi7bc73VyznSZNriPJ58EDbep+KtQ8G8iwZzjrDofl8TlmW7OzskKapJ4d1LTdPPL2/OjqDZ7tOykap4J5r/igevBgOhxhjeO2111ivTyf8ui/bFmsdmxsbhIGiLAqGnT+KbnUnpe8175RSHB8fcfPGTabTqfdzwds0CCAIJIv5jKbxnvfreZ9uW5zyP3e9VrTWSOeQTnb2v4pLl/aI44SiKtmYTtna3ERuCYqy5JvffJmyyLn+rue3DUcjL13fthwdHiClZDKZ0DYNs9NT4jgiUBIhvUBtliY+syEw2ltWxFHUfS5lFYadKKwnXDvnMNYL4K7b2ckgIQgiL99flRwdH3N0fMLh0RHaWGaLBS+9/A3KoiTLEpI0ZTgcEAhw1rA8OUBgCQNBWdWUriQbj4iThGmU0LQGWTZs71xga2eXW3fvUhTF+7t4vks8NInlP/ubP8NsNuOdd6/5jcr44bwUgtF4hLFQlrX3NbGA9EP2pm4Iw5DhcEBZ5BT5yvuMhAFZ4gUi26ZBBSFKCC/s6By1NYD0cN9utrKe41h3RiYE+vaW19OyHXSY/nTWu1g6d6YCINYSMWefA+4xIlt/nbXeNGk4HPZmX+vZydpf5XwlsVYi3t7eRmvNyckJzjniOCZJU5Ikweiigy1rwjAmjj0hUwjB7/zO73D9+k0OD4/JsozBYMCHP/xhNjc3qOumY19HGHNmlnb22v3pbzKZMBpNOn/u+n/ClfEo/sfGR174UHdw8gP5uqrRxmKco2xadncv8JnPfj8XL11ic2PD+/nUNc7CYjbja1/5KifHJwzSjP/yb/2XeKWKFqn8+ghVQBgEVKsFuqnQ8xmxUmxMhrRtS1GWBHGI7AApVV1zfHLM7oVdtra2KKuKOI75I3/kD7O/v8/f/Jt/ky98/hepqorNzU1fcbcto+GQJ594ko2NKZPplDQKyFcpui6955E1rBYls9kpTz71BMPhkDwvaZuau6fHhKFvZ3/qk59kMp7w8ssvM18suH3rNmmS8OSTT3P37l2qqiJIItpWs1gueyDNOE4ZTyY8/czTHByf8n/4F/8Fim52+Qd/4AfY2trm2Q88z+7uLn/kj/wQ49GI0WBAU+Ys5zP+wd/7O8xnp+T5guV8wWq5JB2Nubh3iR/7yZ8iG46wMiRKUoIo5mf+n/8vXn3ttfd7+XzHeGgSy+lsTp4XIGS3kfueq5OeyCWloTWGsNvktDboVvfD9XWlsm4vSSGxxs8oAhX0HBLRYfSNOyePIkWPInMOhFuTstYkRNNL0Du7HmifJZV10rDOIfv5xL2n+PNtpTXMeJ281pXH+ST0Xm2v+5FibXeqXKO76rqmqb1pmNaaVvu5yxpw0DRNP/8BKMuy58McHHgvjSRJej+Y9c/NO7LamnOzZu6vK6FHFcuDGavl0q8VFfi2cttSNQ3WOrLhsFPX1ty+dYs7d+547TAhMMZxdHTE/t27VGVJFEVUlV8rg2HGcDjk0qU9wiAkVIq6WFLlOW+++DWatunWlfcoWaM327ZFG0McxQyHQzY3Nzk8OiIIAgaDAXHsLXmnm5uMxmMO7t5lNpv1qMmyLAhDhQBms1Py1YpVnoOzxJG3wKjr2g/mtcZq7W2GO6JmFAY9P6xpvMir4IwP5uehAN5OeTgcnUNpeltlIRVplrJ3aQ/T7QFbO9tMpxt8KM3Y3Npga2eH0WDAMMvQdUoYSMIoIghD4jhhJVe0WjMcj9jc2Wbn4gUabXn1jbewTmARTKZTnv/gB9/HlfPd46FJLLU2WCEZjacsFgvKuiHo2lVF6SuFIAiIkxShAoqiYrXM2d7e7v1EwiAgTSb9czZ1TRAEDIdDVqsVq9WKze2tznui7ectstMcUyroiZceeulP/E3TUpYlq9UKe771hjw3W8GX99Zv2n7v/tbkstYES9OUMAz79+/XAzsf60S0NhALO7mHo6MjwM9tTk5OuHnzJkeHx6zynKKoaHVLWVX9XOX69essl8s+AQshqKqKoij48pe/TBzHfOADH2AymfgTaTd/OT4+Zrlc9q2V5XKJv3SCy5cvMxgMfr+WwaP4fYyvf/3rRFHEeDzuNnqYLxYIIfn4pz5NGChe+ebLvPLKq7zy6mveyMo5mloTxTEbmxvEccIwy4jjkCiO+NSnPsWzzz7DH//j/0RnNyGRnZnVP//P/jMc3r3D/v6CNBuQZgOPNDMtp/M5cRyzc2GXK1eu8ORTT3H34KBTtwj6tfYnfvzH+bE//af59//Nf5MXv/IVBmlK2zTcuHGDMAgIA8Xh4SF5nrNczBkMMh5//CpN27JarVgsFr4N1/hWeRRFjIZDJuMxx0eHHB7ss7+/75PkYMByueTw8JC2Nb51LiRplnJlc7s/hOmuhVi3DZceu8y/9IM/yGA4Js2G3D04oNWGJ598Emst8/kMISXaaM9RCUOvdmAdSZphnWNV5Fy6cpnnPvQBJjs7fPVrX+ff+yv/ASenC/Ki4j/8j/5v/ORnPvM+r57vHA9NYsmLEuccYRSjgrCTb8ErrzY+CcRN20mpOGazOYFUTCYTlJJo3SLShECdnexxDmmM7/Vai+oqE+e6Fo8nwLDGj61huEIGPX9lffpvmpam7jxSuudfz2h8nM05znNV1jOataTFumUVBAFN40936+pgbcK1FosE+mRz/rG2E06SpP965xzLzit7XUFIqYjjhOl0g4sX97hx4yZto5mMp4RR2PmQWwSWpm5pG83NG7c4Pjrh6PCYi3sXuXDhgr8uTnDr5m3CMGRzcxPZGZ81dYtuH2yJ7/+lxmCQdZt24DkkQlE3DSoI+ODzz1E3LS9/85tc2Nlhd+cCuxcvkvbqEwveevttDo/8QPpHf/xHefyJJ5hMxmxubnTkQY1EEHaq3uPJBN00CN3iZzoSrBdr3dnZRSovmXR6MkPIa2xsbKKU4pd+6Zc4PDzkdHZKlefQua82TU3T1EynEz75yU+SpSlJHPMLv/ALzGezTi5GIKQkSTOmG5tEsReq1cL086FWa1ar1VnV31Uu89mMNM3Y3blA27R+fuq84OXp6QzdJZbKGIIo4vbt26AUV59+uutiaKI49KZfHfhFdCaFDpgtZh52PJ+zWi1R0nc1BoMB4/GE4WDI6fExgzTlz/7ZP0vVaBpt2b14kaIq38+l813joUosa+VfFUQ+sXRscG0aHI66aWm1wRrHfLZAAFeuPIZz/g8bBoo4Cvu5gBQCIwRt04CzBMrjwpzx7Rxj1zMR/+iFGuUaVkuvT1TXDU3d9MP7e4b2rKVb7lUiXg++zzPu120upVQv7TIcDvvB5hoCvU42VVX1379OVmvRyDiO+wTjnCNfrWjOJRYlFUEQMZ1scPHCHlIoD5ucTHvRSV98W/Lcy3ncunW7f35rHdPJBmt7gtu37zAajbhy5WrfcpzP5738zKN4sGKQpUilCCMPlY/CmFVREEUxzz3zDEfHx/z6r/0azz73AZ57/oN8/BOfYHt7hyAMeeudt/j5v/N3Ovj6Md///Z/ls9///ezv38U5S11Xfbs2DQOMNYzHE5w2KOdVtcuywjiNxCcWYw3zxYKTk1OWq5znPvA82SDji1/8FebzGaezGWW+wlQVumk6X6aa4XDAZz/7GaYTL+H/G7/xG7Ra9y1phCRJUybTDZIkIwwD2tpXLGsl76KTSrLGYo1HvR0fHXPlyoDdnV3q2nvQnJx6Xkqe+8SirSGvalQYcvv2baIspdUNqq2h6ySoAKqqXOMjOnFaw2x2wsHRAbPFnGK1QinvAJsNBozHYwaDAfPjEwZpyk//9E8jgwhUyN3Do0fD+9+vqBuDdYIwkqTpAKlC5qcn/iTgXaSxQGsMVdtydHxC07Q4JwjCiCgKvZub9sJ2AphOx1jn1YrTNGE8HjFbLFnlBa++8RZN064dhDvkk08wKghZCzTq1qC1v1HyzosC6Coef8JZEwmd6xwkdYuzxvtg9+ETTtM0fYXxyiuvcHx8TBiGHc5+cU52Zs1/Cfu5xnq2Mh6PybKMq1evIoRgtVqR5znOOeqqoqob//o76+a1D0dd1z3j3zlHURR9EknTtOfCSClJ05SbN2+yv7/f/9zt7W2iKOLo6IibN29y8/ZNPv6xj7O1tfU/51J5FL/HyPMlxliapibrWlNN5YmP/+C/+f964mxRMDs5Yf/ObYr8eZrRmMViTrHKGQ+HjIYDBlnK6ckxd+/cYjgaYYxmtVqSpBlpkoL2p32Aqq6ZHR315MnxeIMwDpEqoNHa+7kMMkKZ8PwHP8gTTzzOH/7hH+bVV17hZ/4ffxNj/MxjZ2eHy5cvc3J0wK1bt/jiF7/Ixz/xCT7ykY+SlwWz+YxWe2vl4EbQdSjgz/7JH+Xxx6/ym7/yj7l79w6vvfoKn/7e7+V7P/lJvvCFL3D9+nVu37zNY489xl/6S3+Jr3/9Jb7+9ZeI4wSA45NT3w5LU7KBv2YiUAilqMqC1175Jm+89SZhlBIlKT/0h3+YS489RhwnaKPJ85zXXvkmr7/6KkcHd8jzFYvZnCCQjAYDlkZTlyXbu7tcvnqVxXxF0xoO7u5jnPCP93CMfdDioUksfqbhJSWCMEIFIYvFvJ+DIET3Nf70XlaVlyZxXqU3DCWia1+tpfa9oqu5B9VU5IXH5B8cUHeJZY3yOqsmvFS3Ugpr/OtqmoaqrlFS9fMJ00GO/ev3ZmE9U95J3LnEIqXoB+/rauT4+LjfyJumYT6f95v4WppiMBj0iWWNUqmqqhugXgJgsVj0pbjvC2uCIEIgOtKjT1rnpVvgjBuzTi5CiI4g6fqEVVUVSeI5MdvbWwghqeuG5WrJ6ekpDoii+H/ClfEo/sfGeDzuzN48P6upawaDDKUCrr37jm8FA21bk69WfsCvW+q6QuvWzzTCkCgKWcznHB0edvejQxvdQXLd+vbs119Z110bVhGEIUEQ+ftWW1ptCI0/dI3HY3YvXGBnZ4fVatV/f9u2pJmfCx4eeNHM69dvcHFvj72Le16GyBi08c9X1TU4P4u8sLfH408+xTdffInTkxPyvCAbDHj88Se8PH4Y0rYepPLCCy/wzjvvcnp66of1XRdBKa9AHqiAJE4I4ggnBYsip6gqjmYzwk7S5pmnnyNQAcPxyBOUFwveeestvv7ii7RNibOGwFlkIAmVAuvvZa+anlDkFU1rKPMc7QTaCWTo958HOR6axBLHSafF1TCeTPyiOjxEG0sYBEgZIIVvzzRNA92MIs8LoihkkI1pm5q2aei4jL3KcBgqVsslJ0dHvPzKKxwdn3KyWHbIMNknrH543mmG+QQgwckePdK2mrY1nkhlTa8VBmcVi5f996J0Z/wTv3Gv5ythGHJycsJqtepbWU3TEMfxPQlxtVoBZ/BkOGvPLZdLmqbh2rVrzGaz+zguAVGcMBqNOT4+4a233ma5zBFCUZZ1L+3ik+HaRdLQdhWaMTOUkigVdgP+kvl8zmQy5dlnn+Wzn/l+/vgf/5NkadYnykfxYMW/+5f/HQgCyFK+8N//I371Fz/Pn/8L/zSbW9v8u3/530Mbw1PPPEsYBKyWc4rVgqoYd2jDBm0alBIkScxXvvpl3nrnTY5Ojrl69Qo/8RM/wenshIPDA564coVkkFHVLdYJNre2SdOMNM0oypxlkWOdo9UtjTG4vKTVxhOhOwOyqqqYL1eczuccn54QRhGjyRipQqqq4dr1G7z62qv8jf/sP8Na2N7eZb7KyQYDLly6wnK5JF+uuH3rDlEQcnB0xMHxMQeHR8wXS6q24dnnnmcyniKcB514NXNHnuf+wBd6GXuPuDRUVYNUJWa5pNEt127fpNEajWU82UCOBf/5z/xNEIIPfOiFjh7QcOvGde7cvs2f+7P/Ky5fusgXP/852rpGVzXL2Zyju/uc3L7N7PJlnAiwbUu5yomzIcNswK1bt8nzgs9+8lPv9xL6tvHQ3PGi6+m3uu3Ns0Bgnd/0lLReEqLzQgmkxFlLUeTEcchwkPRzDKE82Wnt3RCGIfPZjMNOrdWf3q2fr4izVpjtPF4cFiE6WLHzKLE1Mz4Iw1700ieW806PZ8rFzlkcZ1yVNXp4jfDqjYiapneOtP3vp/s50RqWvNYPOwMTNBwfH3dKxgfked7fpG2rSVMPmxwMhsznC4/R755rDRJQKuihzp4Y6XqyZNM0ZFlGmqadr0dLnhc4B3fu3mE8HrO1uXVPRfgoHqwYj0c4pSCOCZSk1S1FWRDnKz8TQKCk8GCWtmVtI2GtF2c9OjqiqWviOKKpK5YLuH3rFka3vPTS1/0MpG25e+smpmkpq/Jb5IyMtRhtaXSLdZYwjAij0Fe5wvu1+EOa/9xsNuONN7zC8VogVghB3TSEYUSyEXN6Ogch+Nj3fByAPM+x1rN4m0ZT1y1RnBAnCUEYcnB4yIsvvsjx4RFFnjOdTpFS8vLLL3N4eAgI77TaagaDMRbvFxN39+C6La6EIJACgTcyq4qCMs+x1nL31m2CwM8tN6cbXLl0ib0LFximGVYbQqW4dHGP1WLJ0cGBn/day1tvvcGqqJgtc1QYI8OYsvKKIw9yPESJJcDalqKqGTbat8W61lbdyaYEoVdLFUISBQHGWvb392mbhij0UMSwmysoKViuVsRRyMbGlKOjY7+4Tk6p25ZkOPbCfOI8GVJ4JFhHgjTG9XIQ65tlOByeYd+dxTpzbi7iq5RehLL7nHOuH3aupVzWLa11IgH6Db1t235ov7GxQRR5Yb7lctkPGfM85+WXXybPc27evNn7uFR1A0IynW6SZRl7exeZz+cYYxiPxz0abT1XOc/el1L2JM2DgwM2NjbY2dlhf38frTWz2YyjoyPefudtRqMRH/vYx5jNZo+G9w9olOWaJNswPzxgsZjz27/1myRxymJ+SpJkOGMw1rs2BoEiikPmixmnx0e8+NWvEYQBk9EQcNRVyd3bt7h5/RovfeMlX4G0LaZukA4ujDdw2lKsVljnD4vaWIx15GVFGAaMp+OelBvFCdYJ8rJCG8d0OuWtt97m6PAIrVuapmY+nxOGIaPRiI9/7yf5+Pd8jP/ib/0sJ6cz/uV/5V/h1q3b/LW/9tc8L0V4BJg2losX96jrmsnGBl/56tf4jV/79d76+Ad/4AdZzOf89b/+n1B3lITFYuEPsMqTqouiIIxihqOxt50QGVsbK1qj/e9TVJweHjIYjpBBwJ0b1/FyUAl/8i/8ef6pP/e/5tWXX+LG9Wvk8wUXdnf44R/6IQIhOD44YDqZolTAz//tn2OZ56SjCXlRkZc1H/2eT7K5/UiE8vclmk53az0/mS8XBEFIlmWslv8/9v473tYsvesDvyu8aceTbjj3Vo4dqnO3Wi0h08oC2UgyIAOCMSaMjcnDB49nxngEHxvJBiyEx54hCIRlY2wJtUCAEFKjTOdWd1fHireqbjpxnx3fuNaaP9Z699n31K2oVve56DzVu+/Ze6837netJ/2e3zNZxl5rpaikxNoUaw3z+Zw0TTDGkMRRgOpKhAAdOLQmAe6XL+YoLUlVckurXl8ICW2/EY+Y8u850bDrFgJI4bmRpGyLGY8bcllrVooufUMv4JZWwK3X0ibTV1Fly/sSChBbpXOywLEsy+PrCKE2IRVNYwOcufAghRV4dFXVaG3DObVQ6+NizyRJufvue9jc3GRjY50bNzy9uQvw7Pb+NI1ftIrirPL+NMpodBjqpDreU9Cag/19tI5YX99ASMnu7i5xnBBFCb/4C/+Gbq/HaDzh4OAg1HEZ6qbm/gfvpz8ceJ69Tsbd995DXuQs8hxTVlR5yfNfeoq6qOgkGQ7fNbWqfc5u0O+DYBn2Ojw8XBpbSimUVstoQFlVdDueaqgtpvzar/1a1oYDjo7GKK1xwP/xf/w4s/mcqm6oQ9Hjxz7+SZ555llMXXA0GmGd8wjGfp9OlhHHCft7+zjneOSRR7hx4yY3b95ctvCOE58vlKFt8sHBAfHMM3lsbW6SFzk3btzEGe+FOOPLH6QFhMNWFZ/99Kf5cQFaQF2VXL64Tb/XZef6DZqyYtjrMzkYMV474Ld93deRlzVGCBoDxgnOXdgmDSCh0yp3jmKpPC7eWEteFoip8LQsrWKxx4pFKxlyAr7/SEso2VKRSBE49JWiqWuOZjNm0ylFkRMlKVJrGqTH2a+ICNTwSoglDLkNkXk5bua1upgrddzvvlUKxgC2VUIgZbTcrlUsbW5iNRTWVtO3Y6uqOq6kD1Di1nvyVpZZKkkpBDqOkUpjGkNZ1iwW+UplsVvCmv2/BrH02OSy5ibNUs6fO+e5mYKHludFgCf7EBqOYFXWZx7LKZWj8YhO1mEwGBJHEZGOGB2OQAg2Ntapqpr9/X2yrEOaZvzyL/0SZVUxW+Qorch6PZowJ9fWhly6fJkLFy6wdW6L93zNu5nMZkymk5A7mPBPdg/Ipwu08DD0yWRC3VQIKVjf2qQxDUfjEdPpNBBRHhtFSkp05BVGYxrSNFsWN1+8eJH3vOc97O/tsbuz4wuZHfyfP/7jKK1Z39ikrGqqsuATn/wksdYM+llY9C1xkhBrTZYkxEqzt3/AoN/nkUceoWka9vf36HQ6QcF5YytJEuaLnOnhYfDuU+6/7y6m0ylXnn4GlCaSGtcYrDNIh2eHbho++6lP8fQXv8Db3voYm+vrXL54ASkEN69dpy5KBt0ek4NDxsM1vv59X0fjHEfTOTpK0XGKsS6gTU+v3DGKpSxzBBBFCtNULGYNGxvrSCGYjI8wpvHIJfALdghPTWdzX+FrPOqkaQz5Yo61hm63w+HoiE9+4hMcHY2oGouIQBpognfRQoaPlYdA6wghPVxXStA6IMAAaVc8FiURUqK1Wnot1hrquqJpFI1RWNsEZXS8qMMxnLilcllW+Yb8SVsk2SbyJ5PJMozWKpZVJdVymdWNb6g0HGZUZcGVZ5/l5s5NxuMx1rpA1xL7hSZKfKjOtgSagjTzjLYAu3t7PPf88+zt7zFbeBCB0pIsTZjNJly58iz9fo/BsPMVe07O5NXLuXMXEFJQlD4CcHB4yLd+67exubnJL/3Sr3ianijCGkOxyPnmb/omti9to6OYK88/zz/96Z8GQCrNXduXePihh6nqmjRLaaqaJ7/4RT79mc+wd2OH+XTG0cGIfL7g6HDk20g4T4MvteTGjR0/N5qaOErpXxggkcwmUz732c9w5coV8tmU7e1ttre3uXb1KtPphNHogKLI+dEf/VE/X43h2vUbzOcL0sRHKnZv3qDX9WEuQmH0ZDpDK0m30/FdZZ1jkS+olOLCxQt0OxlVlVNVBVVVhlyORKqCOE7oD4bExtFYWF9fp9PJltx5Uvp5bo1DaI2Sim6vg8DnXeMwT5984gmeVZKNQd+3FOikuMDx1zJYiN0dhNI4IWlc2wH2LMfyZRNT1ygliWP/oHu4o7fqpfA1LD6x7hdpz0PkjqnrncNYb4U3jcFY42Gx8wU3d3ap6wrjPBgAF/I3zlf221BxK5bV98fhISEFwoplc5fWq5FSInXreagVODE0jd+PFBInPBOs49hjsCHB31bX365iH+ErioUUOOMfuBYSbIy/Po89EEs4drtfYX34rm58f/siz5cen8D3jhDC55ec8wVdQqpALpigdbSMMx8eHpKHXJCUIqDlJI2pmM0mdLox0R2Au/+tKFHsgRhl4HSr6prhcMi5c+fp9/shvNosDaxLl7Z5+OGHl9QjBEMk63SQCFxjwVrqsuRgb5/rV6/x7NPPsHP9BsUiJ5UpVVWzWCwQUqGkCvuBfFEEaL4jTXwTsMVszv7uHs89+yw3b97ANg1xpBn0ujxXl74OxzbM5lOeeeaZUJSrKYoS5yAJJJVFHoxSrWlaHruqRsQ+l+mMwYU1xTmL0hIhoaoLGlMvQTfg80FKa1SkUbVBae09niTx5y8gThKaxtIYi5Q+YpHEMeCoazzDh3BMJlPP+IElTROccEQ6Io4iXCCfLYocqSNUnISGhY6mKWnOWhN/ecSUC6IsYa03oChy8qKmzGeUCObTI2xjvLXtMoyWK6GhNrnuE2pF1XB+awshBJ/69U9ycHhAg8YIgZOa2miEk9RBmRh7HNaKohilNUmc+gZFgLEVjbO+r4kxCCXQSi25tKIoXmL4PVmj8SzM1oRkoA8x1aEn9nK/OA9Hto46EPzV1uCkQMWRb4jUOD9eQJKloY9GsfR2CBQVTV3RWIMTeKJM51hMp1jr49yR0lw6d4HGOCwiWF4eVhzWD3pZRpqlrG9u+PNtKqaLBTv7ezjhiNOIMp+hVIyKOghlcLLg+s5zt9TrnMnpkdFkSmMa8kVOYx2D4ZAnnnyK8XjK937v9/Lcc8/xD//hj9Hp9Bj0B0gEdVmRLwrK+YKt9TUefeQNPProo/zaL/wSH/jxn0DHET5EbJlMpx4gk6RoGVE3NUprti/fTVkUlHnJwf6IpjH0+310QKAppxC146c/8FOApTElCOgkMVmsSCLYWOuhpKUqe4G2RVNVvqvr5cuX0VpjqnrZmny+WLBYLMjLIuQtPRN3Yw20KE/pcBjG433mcx/9KIopaaqQypcWFI1DxoooS9EOlINZVVHh6AxS0l6HN73tMY6OxoyPxlR1AwiyXoxpGop6gW2gaiDKPCX/0WJBxzmy4RrzuUduvrfXY/38BabzOTQ1EkhTQRJpnNMYc7qNtTtGsTjbYBvla1Fq3+GtriukEJ6mRQhcYBk2IVwkhVgmA2fzOZ2sQ6Y0RVnhrGU2Xyyp9lvvBOsQzvqKe8LL+d4SjbW4xiCkhzg6fILa16WsnGvrGYhjavzV5Lsfw3HoS7jQunjZg9H/bzn2xQSULuxkmcgXAtd6M7QfieOxHMOanXVLNtqiLEniDJ1oz++Fb2IkhQzEhLeyNbeeTx0Ud1VVvu8M4IRDaUm336XTTUmzxIcYz2jzT6U0xtI0ltoYLlzc5h3vfCeL2YKjo6Mlj9xgMEAKdQxBl5KqrMA5Yh2Bc5RFydFoxMHevk9uh7lRVRWmNuB1TSgLUERxjGkMtWpC/i882y7QJiFw1rFYzDFNhbElSRqzsbmGFL5gsyxzqjJHyih47l6xVHW9bCXRtEaW8xEPZ633TpwjSTy1i5ACiUJqRRwrpICqKomijPPnzqGkII40Relr1KrxHCFBKumbj6mYOE1QWpGXJVoLkiRiMOzT6XYoS99xdTAckOc5ebHwc9R6yLLBt+qoTezXAAFOCJ6/epW8rFjkOWmWcfHidmBTlljT3LIWnEa5YxSLNRVl0XB4UC9zCEmkiXTE5sY6RVEwGo1o6ooyh6mDMo6XeYarV69xafsS/V6f3d09FosFR2PPFmqdoG4sde2TbFJKkB6l5The1GvjF0hZFP7fFUr89n2bYC9LP7aFEK+izFq0l4d6ljhnSbLkuOvYipx8gFaVDbCszbkd8/GqIlu2KdYKh+NodOjDX8ZgMo/FT9IMpSMi7WsIPO/ZagjOUVW+8HOxKFjkBXlZ4LnQfHgu7aRcvnub7e0LbG2tc3Cww3Q2/o39+GfymyKN8eEaYxzv+7rfxu/5Pd/L3/yhH/Lhq50d6rrhkUceYefmDvt7B+gAQV/Mc4SDLE442Nv3fe/39slnc5xxSOVDRVIo4ihGOLCN8Zx8oU6laQyqNmSdLlFdYxuDUI40TnxoO/S4N6ZhNp+gVJ+N9QFSWCbjQ3ZuXmM8nnBx+y4i7VFZTVMznU0oiwKBoJrPscHQTDJPsWKNN7w2NzeX5LRxpEgizbDXQQm4ef15NjeHvP/938DhwYiD/QOuPPcCB4cjxotnEFKgtGbY6xGnXYbrQ8DymU99DCkcG+tD7r33Xu66664l40W/P2B3d5ejo9ESgDOdTqnrxrc+NzGNs8hIkyjJz/zsz5LnOVIq7rvvPr7zO7+Tpqkxpj71SgXuIMXSwnFbksW2mE9KycbGBvP5nPF4vLSWkL6PCqHCfjwes762Rt00XLt+jdHoiN3dveWP3L5irfD1KsaHgVYUy+rifbJXSpsPWe1Fsrr4t+d8cqGXUgYW1lsVRvv3arX86qv9/OS5nVQ87eft8bTWCARNpKHx3Gq+tsZzmylnl7FuayxSyCWhZRLiyE1TUxQ5TVMH+mZ//lJ41N362hobGxuc2zrHE0884S3cMzl18pGPfHgJU3/hhRfY2thkf2+PPM/5+Mc/TlEUvPDCC1hj0Vrx2c8+zvXr15hN5xyORkwmYxAeoOKcJUmTAFKxIV/hgmFmAr+cL0hUSmJMTZ4vqOsS03iG8SSOieMeWiu0EkRG4zABNSm8hyE8E7gv1vTehTEWypqyKvyzbA2dNOO3f923Mp1O+eQnP8m5c+fZOn+e6WzmCTHXBohwrhtrQzbWhpT5nLJYIKWkLEuuX7/OzRs73Lxxk9ksp8gLn8vUzneY7GT0BkOyTgfrDGvrazhrvOI0DYt8QdbJfN6nKtCR5qFHHvbrReDbq5uGD3/owzjhwQNtDRvSrz1xpIniiLSTYrHMFrOQVz4LhX1ZJI7jZXV72y9EhuR1WykrpQThfxCWEFm5VCyLPKduaq7fuMHOzg6ziW90FMfxskYmbIppLO1y3y7ObbX7KrdYi8RqFU17jq2CaT2Tk7Qmq4plScoUYm8nlcyqwlj9HFjWrLw41OZepAxXG4hFOgohriqco6e3cSG30+ZWZBQvWaWTJMGElgJlWYRmSD40hnNIKUiimLXhkM2NDTY3tpBCnCmWUyof/ehHAP9897o9up0ee/v75EXOJz/5CcrSFyBurG+wvrbBZz/7OCCoKh9uyvPc5+KMz2+mSbyEwvoQLyF06klf/SIbIaUI6KYFtvGMwlVdobWfT1r5hLexGkdzi2KR8rh9hJDCU8s0DbUhwNr985skMd/8zd/Mzs4OTzzxBBe3L3L/Aw8ync08RN/581NKcM9dl7nr0jZXX7jCaOTndVmVXLt2jReef4EXnr9KmnVx+POOnEVpTaeTMVwboCLfSGxtuEZjKoQwNLZhns8Zrg9J05SbN3dRkeahhx8iTVOyLOPuu++maRoe/+xnPX1NsaCruiRR4psLSoGONVESkWYpZVmS5zlpmt7SMfY0yh2jWNqQTyvOuSWlw2KxIM9ziqJYLtat5m9DUC1Mty0i9HHW5JamVu0Ca3FIoX0dy0q4S4WCypPn0n626hWs9rNvz+GkgoLWE3PU9tjCa5MiJ4siV8NeJ1sar/7dbtOOb5XPEn4sJXrQp659G1mPdHM0jc+XaG1BKN+ISAriWC9rcVxjqKuSyXjsJ1mkKYvK956IAyqttkRRwnC45vnbmrPk/WmUlr06iiJ2d/fIF8+TZb4+JM0ysixjfX2dqvQkpUuY+e4+SikGgwEOD31dRWFaFxBRyj9Dvn6rYW9vF6U0vV4fsPT7XV9Max2TowlSCKbTMUmsiROvVKSCbjdDR4r5fEp/0KM/6PI1730PQvgQdlU1TKYLlPZQ+bpu0FLx+Oc+w/Vr17l69XnWNta4q74bpRWduMv25W2U9o33OmmMcZYkSRgOhzz2lscwdc10OkXriAsXLvDgQ48QJSlWfYIozri4fYGNcxdZ3zxPURXMZlOuXn8BaxvWhn22t7e59957GQwGoTV6P6wParkOffKTn2Q6nXLp0jZF4XPBbdFlXZdYZyiKRfDEDEkSeyPY1LQNA0+r3DGKZbUHfCvtAl3V1TL01NZ7+N4KZpm2aCvzvZXlk19CilCPcpz/cKGQSSqOIb1LCLGndJGyDUO5ZX2Kt/KPe7a00N+T5+ucfZEX4fHNhP3cGv5qP7vd63ZycsxqiGx5Pg5k5I8bRREu0OMYG0AIQiEVSOQyUenh0L7YyzRNoJtpUK3idRat48D4bHxYLIrBeZTZmZw+6XQ6SCl9e9/ao8NEeOajyNdfJEnC2IyZz+a39ACKYx8xkC0gxGOziONoCW8X0hcZC+GCJ++9+LIsfdg1eCg4iOMIF+ayUhA5D8lVStDtdUnTOMDsvYG3dc53ep3Pc/KiwuKbeaVplzIvsMYyGh0yGh1SVmUw/PCs5JGmP+ijtQoMGH5O6igicxmdSJLP5+zc9N1UO50Oa+vrJFlGFvrOZx2PkkzSlMpUnoSjbX1R+/5QLedfksR0uz5C0DYHc876ItHphI2NDfI85+bNneWcbXn4fO1YgsOhlPSGmmt7zZxeuWMUi6erVsuQWBl6t4Nvp1rXNd1+z8MYg/aXUlJbgzANlAXXrl9nOp362os8X+Y+XKh7aVEXUinfPTHUorRekJQKIVqmY3NLbqaNKbde0DE1i17CjfO8CMWRzZK+3trVjP2L8yOtp3PclfJYYRwzI9+a9V+teXkpJVQHKpgo0l5BN5amqRBC4ZBoHGiNEA4hDPP5lKLMUUqR53MO93Z9w7FIIfAK9tzmFoPegLIoPdTTOuqiolycocJOo/yBP/AHlqFbHZ7XD37w33Dj+nVi5aGw3vsWGFMDFqU0g0EvhGIcCIeQoKRvpvX2t7+dwXDI1vlzzBcL5vMFN25cZzabcXTka57GRxPqqqEJiWslFZ1ugm0aijJHR76y3diSKIp582NvRSlBVS8w1jCdjukNuiC8ksvzItS0eLaNIi9x1jHs9kizlMt33cX5C+cZrq8xnkxoTMPo0DMkp2mMMw3W1PT6fZTsMxsdUhQlZd2gla/IPzo6whyOuHb9Gv3BGg9ISVM3Ibc7oa4rvuVbvpnDw30ef/xTvHD1eebzGe94xzs4d/4c3azHYrHg6rUXlvP/3vt9Q7wsy3juuef59OOfYWtri+1L27z7Pe9ma2sLa6w3gJXwBLy2JE5iEnW6W1HcMYpldRE9iXZy7pggUQCmMcuQU8t+CjCbz5ZQ5JOW/3Ei3pNYGmt94aI5PraUbahLYO2xwjmZYG8X/dYbkdLHQ+M4AhxxHFFVgbjShcVfuCW0eVVeyVtpj31ym5N/33K/Qhwajj0uY1u2ZRvaAojlmHYbaw04hwnKVEhQToT9SE/x0u2ipDweVzeBGfdMTpu0Rppzzhf5RVFQIoa8Ct1KlQ/rDgaDZavrKPKW+GDYRwjPD1bXDUr7XEAcRx45pSQ6UiRpgrUGrTeZzefkee4htnXwYqRBRbFXUgKiSJNlCcaKMNea0G/JhRq2BVESkSQpZdFQVDVFWeBCiwtfDuaNOx3OVWvt2zxojRP4ehbniJNomdP0zzcrEPtQEmAts/nMt+iI/DV2e1106IwppfBF0EoSJzH9fg8hYL6YUVZFgOV79Ge321kChnq93jJX7O97Q5IkrG+s0+12l00D27VMKrEce9KYPG1yxyiWZaKbY4u89Qpad35zc5P9vX1s6B1SliXz+Zy6rkmShMVsjgsMxG0Su/2BlFIIJQIcFxZFhQOUVksiyDZ30saaj3uw1GitQ0KyWCq6Fhadpmkg+/MNsaSUgbTRkRcL3xtc67Dg314pnOxtvyqrXSVfbtxyn857aL7nt8ThGzM1jUfCaeNWAAcOpVXgV7PUZUVdFRhbowx4Q9ai44jLl7bpdbukcQLWUSxyqjynzs88ltMoLat1WZakaUoSx6HWImd0cAAWtIq4eOECd12+a8msPZ/P6fV6PPDg/WxubrG+vsG169c9PFYJFuWC+Y3F0mvWWtIf9NjcvJvxeEJZ5ozEUaBL8fNFBaUilaDby9jcWsPR4JxhZ/cGSknSTsL+wR57e7tcv3HdV72nXXz7DEEc5cRxyvpwgzhLyLJseU5tr/k0S6mNYTyZkmYVnX4HJQRCa+aLhfdeKp/DUMq3LS6rktFkgjGOrfNbnLu4zfblbRZFzTyvyboZ1sUcHd7Ampr7H7iP0Wjke9nP53SmU9+cLMt46KEH/T3Oc6LIryOj0SgYu5b19TUeeOABnHNMp9OlMgeWOZa20+tpljtGsTTGgDGhl7W3MbTylBAtyWFLZWJCnLMlaWz7vkdJgtaK4dqab/9r7DLZ7q3wls7eLYseW4+i/SFbyPCqp7IKAGgVyyohJLCEG5+ELPtamJDoX7GSVuWkN7Qqt4Mjn/x+ZU/L/1dKeOZlJcPEYyV31NA0jryQpGVC1mREMkY4wWI+X1JkOGdx1qCk736npUJLiQSqomQ6ntBUDe6UT4LfqiKURCuJjiNM0zBfzEmSmH6/T7nIAcjSjKquuH7jGv1+H6UUvX6PLPPs4dOpD0MfjUdUZUVjG4SSLbcR4C13YwzG+fquJIvZ2Fqn3+9SlrUPKU3nmKamMb5LpbENOhIIoShrh1CCTidhfX2I1oFMVSqQGucEFsmyNxKGxtTkZU5Zlb5u62jEleeeYzKbUTfekEvShLqusE2NbRoi7fuppFrSVBU6ikgybxRK5duROxnTGwxXio8daZoglSBLtjFNRVnOmc6nLIoFTz/zFHv7e9x9993EcczewV7wnhRJkvlyAyxRHLG2voZQgulsSpzES48IwFiDihQIj64781i+TNKY4+6LrffSLuoyKJZl7sIaqhB+qZuayPhFP0m9FTNcWyNNUzDHgAAfq81pGoczKwl2J25BWLUwv9ZbardvPSA4Rom1SDHnfCKv7WV/srbEORly9y+uZWnfv5TiOFmvsurltMc+9mjAowRcoJI5dq2lFDglsFZgbOOZX3NLp5NR112iSOEQzOcz8iL35+os1oISwisWIVFIhIOqKJiNJz4MZl/sOZ3JV1+EEssapcnROCiWhMGgz2I6RUhJr9tjdDjiaDQiiiO63S69fjeE0Qyz2ZTJZMJk6ulhDDZ4/8dh4vliRlVXzIspAHEa0+12iZSmKryyeXb+LLWz1E1NY2oaY4gSH5ojJPGzToqOJN1eho5ihJAUlQkofUVV1ktus8Y0FEVOVZc4LKPxEZUxHBwcUDUNG1vnSJKYxWJOVRRURc6w3yVNYjYGXQ8ciDTdbpdut0un2/OFjHEXqaOVhd2RJDFJGpMlfZqmZDobcf3mdfIi55krzxDHCWknRUrJdDplbW2N4XBIlnaWLYijJGJ9cx2pJJPZhMHagIQE447D+rGNccKRdtJT35X1dJ/dirSKpGka77aHTobOOcqyxARPpvUYWg9ha3Nr2c633cfu7q5XSs57IJ3OMftummU4AXaFUbhVFHnurbgWGNDusw3Hge9Bvwou8DUf5TIst0prb63xaBopISCybpsTeZnQVuvBtP+ezL+czME453vI1HUNAqI48vQUie89DoL5Ig9hvZzpbOL7ZBQ+WXpwuEtT18SRBmuxxuewTNMwHh1SlzlZEnOYxCghqMsSyZliOY1yuKR8z5hPZ+R5zl13+0T3eDzGWW9YJEnMuXNb7O/vcTg65Py588RxxObmRkBNSrblNhbHdDajLAvGk4kPoSq9zJ00TVvP5J8LayxSeroYKwxxohgMNsk6KdbWHBwcIaTj7rsvIoRjPB75eYNhkKUoHWFKn+BfW9tESI0QGlP56MPsaMJs5hmQz1+4yBve+AZ0nCCkpKx9J1pnDcJ5GqfpeERTlxRlEeDGY2azGVmW0esNiOIEGXmllvT6pJ0+G1sbIB21qZkfTtBa+jYEIX+1vb3N2toa29uekmVtbW1ZHzQZT9Bac/fd97K1tcU3f/M3c+PGTXZ2dpd8Z2VZEkURw+FwqeR8j6Piq/rsvJLcMYoFbi0UbOlTljUbsFzMnfMw2jiO6fa6RFGMW6n9aMcJR2BEXUnELxP06sQxHca07VRN4NIyK3keFZJ4PkEvlzBl3z/CBSSZtX77lgtMKm+RhdjSy17z7b673d+vcBdD0adH81jnGZdX2QyUUp7k0lnqqiIPoS9/7wqs8eEvi/P3VWuk8N9pJYm1ogqK1DS1z6aeyamTtlOob6vgEZaD4XCZvzQhIpAkMVpp9vZ2/e/vPDglTmJvxUcROvZJcOOM9zDmchlmlUoircQZD/RomRqW4BElfDgW5a3/OCKONVXtx0daeXBL6UsEtNREsUZp7ZPzcUSnk6J0gtIJZV5SlzWL6Swwcsf0el3W19fo9AdIrT2Sq2moqgItJVpKqmIBziClwgq/jrSN9JSOMNYRC41F4IoCFSdE1jezM7ahzBdkaYyO+p71OdQCtTVBq3Osja40xvj+MknKuXPnGI2OfOkEeGYA4de6JBjTcRyH453uOXXHKJYqYOARBFqRZqlYPBbeUVYVdfjBLl26xHA45OL2Ns45JpMJWqqlhdbCLIUQlHW19BbKpkZKuSz6clgQ1iOgQp2Lc+AwlJUBWm/Cn6dSXnndCg0+TpiHZT1MLUfThA3li6HDtwuB3a7G5Xay+v3txvsue7fmgBrj2wsI6dBa0ckynDPMpmOmkyN/fEAIi6l9YtVhWRsO6XY6uKZG4Ti3sQ7OMj7Yp8wX1GcklKdS0kDB0taK9Lodtre3Q73XnLqqyNKYLBsy6PfY3r7AfD6nqkryQOkzGA5YX9+gsZ5DDrmJtetcurRNWZUUVcnh4QFVVSKkz8vVdUM369BJOxhjKYuK2XRGvlgwX0y5595LvPENj6C1pK5LPvnrH6Xby3jzm99IknqusbLxzOXnL2yDE1gLCA1C0O93ET3BcNDjvgfu5e3veHsonoyYzaY0xjLPc4yxWNsQKYVVis1zW2glGGQpOEtVluzu7rC3twtSEqcJ9953D7V17B1NefbKFQ4OR77xoBQ8dP9dDAY9ur2Uu++9h3MXzvP4Zz7D9RvXefjhR+nGMf3BgPPnz5MGYEFRFDz//FWctURxzGwxJ+1kAWwg2NzaWkKSoyRGKEmUxKHw9PTKHaNYWm/D8xKxDCet5hDaivQkSZbWQrtwytCYq7UYVgsuWwRXG2oTQlAHBtHb8YS1cvvch7rl+/BX8Ehe+vrMSiXtK0GMV/f9cp7K7bb3/7jAkyS9NyHa8avAAgIEMhRGWk/zomRoI4n1ulAI0jQhy1I851hNU1cBalwvk/tncvqk9cqttW2HIR++rUOzufBdVdcURcFg4PvRTyZT0jQhjiPiJCJOYqQRGCvJXOrnpBQUVUxcxljr61OKIsc53yoiSRPSNKGuDc46Op0sePzCL6JxxGw6ZrGYQyg27Pa6JGlCnEToqsIY60Nf1lEUXtEYY7C0nUzlce2bE6HHklt6XEpJpNSeSkZpklihtURFERIPxz48PFiydpR1hXGebFVHmjRN6Pa6xGmCVJJe39fNrDbky0OdTVkWJElCp9MhCZQu/hw0w+Al+hbkx5/1+n263e6SHaFN+q/mc0+r3DGKpUVUAeBYYsFbd7UN4aRJQpamDIdDOp0O4/F4ifyK44gkTpa0LqsEki29flvjUlTlSxYYtrmLk94FcAuHz2ryfFUBtmG81W2b4P6u7uulFMpJGPLt5KTiacN5x/UrKrwPJJjOIoP2W16fxCfeQytn4Sw2UEBJgQ8hKMXacEC/16OYTSnzBYcH+zR17T0VY0hOeaLxt6rEcbzMHUp862rfa75chsgaaxlPJkynU9762JsZDAY899wLpGnCcH1At9ch6UREVvnoQRKBBBUprPHh47W1Pot8wZUrz2CtJY5jkighijTWOXSk2NzcwFiDEM6TOTr49Gc+zcHBLnffc4m19SGDYd/XyaQxWeUjFo3Btx1uLFVeUZYNVVWDg0FgFvBIMY8cc8IzSaSZp/eXUhJpTaQUiZZI4bB1GdiL+6EgOMfJMWVds3F0RJxmdLoZ/bU17tMJOlK+XUQWYeqK6fSI3d1drl27xt7eAaYxjEZHS3oY36VVk2UdkiRjbW19uUaNxxMmkyl333033W53uXZ42LZeJu1bg/m0yh0z41cXVJ+rOA4nWRvoDpQk63QYDgZknQ5xklAWxTLsVRS+81pL/xIH+voWAOBpqlvor3tJq2DZQ37FEm/PrVV2tzv3kzUmyxc+NPVy1w4vLoZs0Wovt82L/w0tABrfZU8I4ZOXtmXiEEh5nMfSylfWW+FwVtDUvkjShfPRSpBoTaIVhTU0dcl8OqEocs+CUBbYEL8/k9MlHt0HUilMU1PVDXHiuetaCHpjai6ev8CF8+fZvnyJTpZiAwXL5uYGnW6XrNtZRhB0pJeKpaUKimJFb9ClP+guuf2CfUPPeiPxaHTEbFqwf7BHpCXdri9CdGzS6XRI04w0TUlTr1icK3132LIKPZF8HiSTMd2uBxRkwbJ3CJyQWCRCKBBtW3G/mGuliJQiUn4ulIsJkVYMej2ybgcdR0Sx98x6/R5xmiGiGCEjhIp8iDu0Q4+imK1z54mTlHPnzvPoo28CCIqix9r6elhXBIkOrb9hCQaqG+trcuLE53XCfa0b468DQWM8L9tpljtGsayGoswKyzGEBLTz3ERpgBNnnQ5aa48SW2EZFpVYLsbRivZvkRZL9NjKsW/ncbSKZbU4sVVQL6dYVq9ldVycJS9J0bJ6Hif3e5IQ8+T3J/91wTupTc1qZ0fPBA1SuuV9VUqFsJfne3ICmrry0GhHSPoLosgn7HEWU9XMm5r5fMFiPr/teZ3J6ZBFni+Zq6vKUlalr3JveamkoGlqNjbXecMbHmVtbUgUaeIkDSSUvbDoxsucpzaBNVirJWdY2kkQAobDAUVRcP36dcqioiwqkiimqWuev/I8jam5efMG/V6HzY01er0eSRLR6aZkWbpEg8aJJ5o0oRC6VSxRlBLpZJkolyHE55tnSZxQKBUjlfYLt/JNx6JgQGkpwFqmY1/fM+j16HS7RHFMHGviJKLf7xGnKVZqHAon1DK6YZ0liVI2NtbY2joHQKfTRSm9LJNoCxyrqlrexzaEH0VR6NoqiOIEpXRoo+7JPdv8bgsiOs1yxyiWlhdsdZFulUBL27LqBUwmE4QQpCvcYq32B68c2grWVWLKy5cvkyQJn/ns47elfmm3vV0o7OVyIcBtPZZ2TH10bNXfTrG8lLI5qVhuF567XfJeqlvzHh684NsjH+eV2ratoGQorJS+ux8OpMT3t68qKl2QJhHOqADhNNjmjC7/NEsdar2SJFl6q0347dfW1zk6OmJv9yZKCra2NpbP/MWL5wNdiieZJIRNrbNgwvMX9ocQSBXhnCeFBNja2sI0BtNYirxgNpuHsJQiyzrLcM/e3i5lVfKWt/521td9a4z5YsHh+CjMV+gPhgyV5pKKkTJCCu2LqK1FCXdcdCwUTkjvZQiJUGpJ+yJX5rKUkuFwiMCB9MWIm5ubVGH96Q/6pJ0uViqQEULqJcX9oJv5glN1zGDs0aKS+XyOkgqlInCeTHK11YZzoJRDBH621WjEscEpl/RQZ4rlyyS3g9auhqNaZdMmztpwl+r3vWKpfEJ5WWApBFJIX3EcLGsRmEyzLKMOCUsX6MBXk9oiNNnxP7gLlsTxObVr++pv/1LJ+Pbvon4xcuqkMrmdcllVLLfzaG73L0AUumveMj4UT3rl23KDeWUjnFvmVmzI3yspiQL1uDE1kdY4aXFWoJVEBcbXUz4HfstKm2Ns6dzbBd3hfPV96XmuWmBJm8f0iXYJIrSuxjNh4/C/uWvzckGxBDRl09RLaiNrrH9ZR1zX9Ho96qri/PlzrK2t0el0qKoAGugP6Pf7aK2pmjpwAfr5mqYpUZyQJF1kqGMp8tzTJAnfUpwQCnNC4lCAxIVwlJAyQP/Dsyp8Jb1wDmtrOp0O6+vrHI6PEEIShbCYlRqhvGLRcYTSml4nQwDWNsjGeBLbVSoqPIeZBxL5e70a0rIhNC2VehFv4NKQXSrBs+T9l0VUpI/DSbfxFFqFMhqNMKHtZ9N4Wvd2vJK+c9uq59AExdIWH9WmoSMFVVX6/IB1rKKlTsrJRds/KC8/drWY0U9CgdTqRQv9q+EDOgkCeCXl0v69CJQd7pbh4dzbAHj42yuWwC2mBdJAbR3dTsq5zTUEDXWVszFc8yEFpUi0IokkZVlx2ntH/FaV+++/d8kV1ut20Eot+cPe/NibuHb1KleefYbr167z0Y9+lHe/512+77zyBKWmaZbgeaQ31GKlQl1WMLgQbUSMJNlCSkWSpBR5Qb4o6Pd79Ht97vmue8JSaXHWIwqvXHmGa9eukqQJvV6Xza11EAKL8w3FLBgncc4zRkRRQhxnvuDZOUxdHANikDgkjXEY4yhC8r8sy1AgCQJLpCWb6xtoJcEZ3vimN3LPvffwoQ99iKPJBGMamlAU7Ky/tijqEAVWDWMtdVVjEegoQccJkY7Y2PKhrSzreG+mLH03S1PR6/V8R0gHUkdEQvpcivVtniUCqS1CaRAKS1u2cHrljlEsbdX8yYX0xclsD/Nrq95rd0ydYqXEKXVLSGy1A6O1lsXCtyZtXdmT+ZFWVnMrq/++nNxOsRxf4IstkFfa58nrf6lw2Uspl4A8XnlEwzXadrkICmbpsTikEIQoAZHWpGmKrRsf/pIewtpJU6oiocx9iMWecgTLb1VJkmRZqKdVSGJHEQDdXodOt+OT8YLg6YsV1GNb4rjqqYvQDnzFkw+jhWhDyMeISK19aEhJRRp5uHpdlQgiSBIefPBBBoMew9D+N06SpSLTDpwTNNYv8MZApD0kt+2G2gJihBQ4PDpMGrxSwjOYSymXikUKh5RQFCVaihDq1fT7fWTIhTTGkICnhApcZTrSKCl9P6Ng+Koll+BxDxYPMipDcfJxQ8BlucRK5MFahxAh3/misPut0ZDTKHeMYmmTXF5CEn9FQbQ3vmnMku6gzaMsKfFDPLMliGzhey38TwjBzs4Oh4eHTCaTZSL+ZPhqFW58ctF+JYz5S4WnzG0skFfK2dxOqbyUx9JK63lLqY+96TYM4PDeimsro+2x9+LCcHscEktTzys1PRphmwact/jW1/o4U2GqkrTWZx7LKZU4jpeKQgrvzXc6HuE16Pfo9Xq+arybkfWyZU7Ttg3hVop622Q/6jg07VwIld2SZzRUVe2VSZrS6XTRKqIpG+bzGddvXGd9bcjacMh3fdd34ZxBSItUAhUr6qbGmRotNUIqUhnjnMQalpQuPp/akKURqq3qFxpQGCTWQZQeA3qUEEgESjhs07B7/TlwjixJGA4H9Ae9pXeTlyXd/sD3ShEKK7zCcs6xmC0QgFZ62bK8ZflYLAqEAK2jZY2db/PhWz23yNVWmqatv9OAJ+OE43zMmWL5MslqDsXh46s2WNG3JNKFR42lmS+4arep63pJRdLmX+A4ztx6OPv7+0tLwhcsvTgp/1KK5ZW8m3bc7f59PU/KyeOfhCOfvH8rWyJCSVzY+vj4widQRPudCNX27X5CJFJJwBmapg7bOuqqwGUJnU7G+Eh6OpfWyzmTUydFWQCeQNX3R6lI0wQEy4Z0HpIbkSQJddNQlCVxEvmaJ+f79CwT9UFaIIAJYeEWfah0FBbF0PfEWuZzHyFIo5QoihkOh0uqeBX5RHdVL3BCooVesfJ9uKisKowB0ziSpEOcxEtmDWdLjPF+tz8955P4hIZ+rdeACMrF4iLN1rnzYH3lSxRHy9qbNE2pqyoc02AFWOE8aatznq1YeCXdeh1KaZ9wd97z0KH5n2/gJcP6JZe527auzjm/RmndrkFi+d3LIUFPi9wximW1iyJ4VJMx/gGN1K1egnWWrJMRac1isVh6KSYkEler8Y89HR8SODw8vIVY8iQ0+OWKI1ur5uV+9Nt5HD4k9cphr9fy3Usrs6ApWEWFhWtr/xJtdb1YKpWTukFKv0A0dUWLHKurAme7dDoeHdM0NfI2Ib4zOR1SlCVaaTpZRmka6qZiOByilGJ04CvOfdW3DjUWDWVVkaSJpxxxy0oyv8MXKRdvurThMqnUMoVnja/9yPM5zkG6nnrq+LW1pRHjewVBUwaEFwRklbfijXVUVU5TW+raolRMmknfIMs5ptPSKzHAE2H6XJAPy8XLedx6LFJ4Q7V37gLW1FRl7mu4Qk+lFtRTrygWg68xAUGn1w+h4mMjWIW1SavY34Owphhjka5dT9rmXRYdwnlN0/acCoAKd8yorpQ+Uyxfbmkt89VGWoZb8yTWWdbW14hlHCxvF/oZRMTRMRqqqqolprztT722tobWmhs3ri8hyCfpXG67aC9xjbxo3KsJZzknjt2C1yCrBZIvhSK75Xj4QkdrPLvxLegT4bnPRED1CHGscMRyn95bUcrfv9lsSiQlShK66UnWhgOuKUVZFighX3ReZ3I65K677vJGlFQ0dUVT+0SyCi0QyqLkwoULHB0d8bGPfYx77rmHtbU1b6HbYw/Zh1GX2ZTQPVKhhO/N4/n9PPO4koooTtBSo4SkrkeeQkasFAlWJUVZESe+LXISijY9Qs0GDyJFKkWn08U5MFYQxxlKafIix9jG0wzhPQobcjJWtOis4/vQGAvWgwaEsxhJaLctibRCa8Xb3/Y2FnmOTFOSTockS6kNYB069hT+1hjvHcGyKVqn00ErTWNqwN+vljXE07XoW1CnUiqiKCbPy+MITQAZtXLalQrcYYrlpNfQfrbqMTSNJ8M7XizDuBAyW6W4b+tY2gIlIcSSYn/1R70dT9jqOa0iNJRUt5zby+U8Vj2WV3pYbrc43y4Hczuld/z+2Dty2FuSq8twWKtM3PEEXCqV4PC0H1hrqOuGKAlNkEL+JQ5Nz4wxIJ1HvJzJqZNer7f8WyuJ0Z6gtW2M11rphwcHTMZHOOeI45i8WGWXOBEqdg5By+sHuNC90Tqa0J+oDUFFSi89WoFYzs/KtflTuVR8Fk8YaZoGYy1RZAHlIe4INBIVmnG1rMGdJMEnBx0Yx9IEE+GIy3kaareMh9dr12IQxJJfcGNzk35dU4LnElMK6SzC+ZyKkBJb1uGOsESpetTnrWjR1QaAPlx/MhpyK6PHaoh9le3jNIu4E7TfmZzJmZzJmdw5cmeovzM5kzM5kzO5Y+RMsZzJmZzJmZzJl1XOFMuZnMmZnMmZfFnlTLGcyZmcyZmcyZdVzhTLmZzJmZzJmXxZ5RUVixDiR4UQP/+VOJmXOP4VIcR/9Tq2+wEhxI4Qwgkh/rAQ4vuFEE/9ZpzjmZzJ65Wz+XUm/07KSS6s23BjDYH1Vxr3m/UCzgHd17jNe/Gg8e8CLgIZ8P3AU1+t6/hqvoC/DnwRmAFj4N8C3/katu8Anwv39LetfP4W4MeAK0ABPAv8TWDtxPYPAD8B7AJz4NeB33eb4/wXwHNAGcZ8223GbAH/X+B6GPcs8MdXvn8z8OPAk3hWzb/31b7/r3Bvz+bXHfIK1/nPgefD874D/BTwplfYTodn+0thuyeBP3lizHcB/xK4CSzCfPuzhJKQlXHfBPxKmMeHwM8B7z4x5huAXwSOwpj/Bdg8Meb/FfYzCb/lXbc579e9bryix+KcGzvnRq807jdLnHN7zrnX2orwYcA65/6pc+6mcy7/zTi3O0g+B/xJ4G34ReGXgX8qhHjXq9z+fwaevs3n78Q/dH8MeBPwnwLfCfzvJ8b9NF4h/A68MvpJ4B8JIb6uHSCE+HPAXwb+EvB2/IT5aSHEW1fG9MK5PwT8fuBR4A8AX1g5Vgc/8f8K8OlXeX1fNTmbX3eUOPxz+b34Z+878Urjg0KI9GW2+8vAXwT+S/w8+X7gvxdC/PGVMe8HPgR8D/AY8NeAH8ArJACEEPfgFdungPcA/x5+wf9ZIUQ3jHksnONHga/Bz7mHgZ8St1ZZJ8A/A/7blznv179uvAot/aPAz598D/xp4Cp+Yfl7QAT8Z3iLcwT8HSA+oe3/TrgRI/xi9QO8gpWDt4b/qxPv/wrww3htvAP8EKBXzs+tvsLn3796rJPvw2e/LWxz38pn7wL+dbjOPfyieO/J/eAtji/iLfJfBB4+se93Af8KbyHM8D/8e1e+/1bg14AcuAb8A05YGV9m62sE/NlXMe4/xj/Ij3LCY3mJ8f8h3lMYhPdrYbv/4MS4g/b4+Froa8BfPTHmY8CPrrz/y+H3T17lNf4ip99jOZtfd/D8wi+6Dnjby4y5CvyXJz77YeDKK+z7bwGfWHn/3eFY/ZXP3rJ6fOC/Ab54Yj/vCGO+8TbHeD8v4bG8xDm9qnXj9SbvvwZ4d/ixfj/wB/Ha7+uA7wjv/xDwR1e2+e/wD8cfAr4WPwH+89d5/D8N3MBr0T8N/Cn8AgjeffxzgAG2w+t1iRDiTcAv4S2Jd+PdUAP83AkLZRv4E8D34e9BH/j7K/t5M17bj8I+3oGfrDJ8/03APwX+MfBW/AN0H/CTrZUhhHh/iGe///VeT9iPFkL8IaCHd4Vfbuwb8ZbT78OHnV6NrAEV0AA4546AzwLfJ4QYCiGkEOL34T2LD4Zt7gMu4ReGVflX+MWold8N/CrwQ0KIG0KILwoh/poQovMqz+1OkbP5dQfMLyFEH++tX8OHt15KUnwIbFVy4F4hxL0vs90aXpG28omw3f9VCBEJITL8M/A0Xum+3LHAezivS17LugG8bo9ll1utpX8B7LNiSeJ/yJ8If3fxC9MfPbHvD/P6LKp/dmLMzwD/+8r7Pww0J8Z8P6/RogrX+o9PjEnwMdDvXtlPA5xbGfMf4a32NLz/MXxYRr7ENf4i8IMnPrsnnMvbw/uvwT88X/M6Lat/H2/JGbwl+rKxUvzC/1ngj4T39/EKHgs+3v4C8NdPfH4Bv4A4oMYver9z5fuvC989cmK7PwnMV97n+Enzv+IXot+FD3v9by9zX+9Ej+Vsfp3i+YVX4rOw/eeBh15h/I8Bz+C9C4FX2Lth+/e9xDbvD3PlpKf/XrzX2oR78EXggZXvvzns9z/Fe7mbwAfCZ3/7JY7zkh4Lr3HdaF+v12P5gnOuWnl/E/iSc6488dn58PdDQIx/0FflQ6/z+J868f46fvH6cst7gO8RQszaFz6Ek+LjlsvjO+f2TpyP4Pj63wV80LWNKW5/nD934jifD989DOCc+6hz7g3OuY++1MkKIX7mxD5W5RfwuYuvxYdWfkwI8c6Xufa/BTzunPv7LzNm9djn8SGNzwD/j5XPBfA/4R/M94dr/WHgH7+GHE8rEv9w/yfOuY875/4Z8H8D/oAQYuM17us0y9n8OoXza0X+Gt4r+ka8wvhA8F5eSv4s8HH8fa3x4JIfCd+96JyFEF+LBwV8v3Pup1c+P48P4f00XsF8PT6/+C/b4zvnPoj3Mn+A47Dfl/AhzVfudf5iea3rBvD62Y3rE+/dS3x2UnG513m8k1KdeH+7Y72StAzXqxKdeC/x1sYP3mb7g1c4n3b7VyMSbwX92G2+u/kq9wHeLc9u94XzCdoWDvoxIcTb8InB3/cS+/oW4G4hxO898fkvCiE+6Jz79vYDIcRd+IThU8Dvcc6tPgvfiA9hbTvn2mv5lBDi64E/jw/r3AifXwSeWNn2wsp3hL+vnNj/58K/9+KVzr8Lcja/Tuf88gd3bh/vQT4phPi3+HP9PuD/9xLjD4HvFULEeGV4HZ8vA6+YlhJCcT8N/IBz7q+e2NWfwqPE/tTK+N+HDwH+R/iFH+fc/0cI8T/h59ME/zv8RW4PwHmla32t6wbwlaPNfwr/cLyPY0sBvBb8askucF4IodyyGxAnNfHH8THZp13wC1+nfAL4ZiGEfAmr6uPAm51zv6E6AOfctdcwXOItw5eSb8Nbwa1cAn4W+E9YibEKIR7EJ5s/iYcQn1wAu+Hfk/2JfXckL1fwk+3b8bHyVr4Dn1Np5VeAbxRCaOdc26Di0ZV9/FaVs/n1FZhfLyOCl59LAAQv9CqAEOL3A7+86okJIb4T7838Jefc37jNLrq82Ouw3EaJh/t5I+z3j4WPf+pVXMsrySutG8tBv+kStN7fBv4bIcS/L4R4RAjx3wJv5MtnZb1W+QV8HuGvCCEeDJb5nzwx5q/iz/F/FUJ8jRDifiHENwohflgI8cBrONZ/j3e5/zchxLvb4wkh3he+/6+B7xJC/A9CiLeH779DCPEjIUFHOP4XhRBf81ouUghxQQjxl4UQ7xVC3CuEeJsQ4gfxsdh/uDLuB4QQbTId59wTzrnPti+OPYlnnXNXwjZvwi/2XwL+DLAphLgYXiqM/7d4tM+PCiHeKYR4SAjxX+A9og+EYzl8eOHPCyH+oBDiDeEc34ZPwrby1/F1F/9zGPON4bP/xQXIrhAiDvfw7fhE40Z4/6bXct/uJDmbX1+Z+SV8gv9PhDl0T/C6fwK/sP/kyrgPCiF+YOX9e8L5PCiEeJ8Q4ifw4aU/szLm9+Lnw18P19HOo3Mrp/DPgDcKIX5QCPGoEOItHKP0fm5lX38xnOMbhBB/Fvgf8YjLp1bG3BPmyEPhozeFe7MRvn9V68ZLyVeS0uX/jnfx/hEeCriOvyknEQxfEXHOfQn443jUzWeBPwL8P0+M+QI+sdzDW+ufB/4uPtx09BqO9Tg+v3AOn8T+FPAXCFa8c+4X8GiWt+IX6s/gF9QpxyGQDt46f60IqAq/QH8Aj1z5WXxM+nc65z6wMm4bePA17vt7w3bfjrfEbqy87gZwzh3gvR/CsT+Frz35o865n2h35Jz7m3g48V/FJ2K/A/hdzrlPr4z5NPA78fHtT+HjzR/AI4ZauYQvrvz1cJ3fE/7+l6/x2u40OZtfv/nzK8eHnP4Nfi79I3yo6Wudc8+vjHuQW9FyCfD/xt+HfxXef93qs41XuhG+jmt1Hn1s5Tp/Cfi94Vo+Fq51G/gdrbEX5FvxgIVP41Fjf8Y595dOXMtfwc+Lvxve/2x4/7vC+1e7btxWvqqNvoQQ/wYYOed+91ftJM7kTP4dlbP5dSZfLfmKtSYObts78UiVGI+3/0Z8ZeiZnMmZ/AbkbH6dyWmSr2TPe4cPWfwtfAjui8D3OOdOFsWdyZmcyWuXs/l1JqdGznren8mZnMmZnMmXVc76sZzJmZzJmZzJl1XOFMuZnMmZnMmZfFnlK5lj+Q3Jf/1/+d1OKUWSJDjnsNZS1TXWOeI4QUiJ1AqpIoTU6CT276XGOkdjDUoplNKk3Q5SKcbjKUopsm4XpRVCSpragpP0kg1w0DQl1689y40bz/GWtz3ExuYAoQqquuRoMmI4WGcwWGcyq6kbB/SxVlM3miQbknYGrG9doD/s88a33kecRCDACXA4HBZwCBTWGsqmRCGRTvDZT32Gg/19inlJXdeUZYk14JxgbXOD/nDI2979bpTWFFVJkkakWYQCpPBWgzWOpnYoAUoIlAQpHErCaHTA5z/3OItFwSIvqI3FWoezAiE1Kk548KGHefChh9ARCAFlKGuUEqoaysa/FwKyxF9Xi98UK6+tF1dhn8lXWf7MH/k9rmkayrLku37P7+U/+J7/EFfX4BwiTnAOrGn45//iZ/iZn/lZzp07x7nz5/mDf+g/ptfr4ZxDK4mSgtlsRtM0DId9yrJkf2+PNI5J4gjbGIwxzKYTbNNgmxKJRTrHk196nIP9XZ579imKIqco57zpjY/xhje8iVlZYhxsnb9Mtz9g6+IldJwho5S6sTjnUCrCWYdpGkxT46whSRKU1jgVY6ylrCuU0iilqGv/dHZ7Peq6ZjKZ0Ol0ybLOkueqLn2hv5SSpqkxTU2WZSilwFiMMdR1TdbJSLOMIl9gjAEhUVqTZCmLRU6+KEjTFKUVDrDW0jQNUsrlSwiBqRu/DmUZZZFTlgVRFCGlJEkTrDHUZUlVlTRNTa/fJ45jkNmpnVN3jGIRQrzovZAS6RxCCKQUx2MECCkQwv9wUgiUAClVGCuXY61zGGNoTIMDjkYTrIHs8hCtFVEUEcURUawx1lDVJU25wLqGKNIIKbDOIqRAKYmSEU5ERC6j2+/T7a0xGPTodDsIKZZc49YZrLNI0V6bQwBKSPx/+P0puVy4cQ7rLMY4iqJARZqj0SFxmiAjTVVZjK3JkhitJNY6qqpiMp6RJQmdJMFJv6+GhqosaZoGcGitQXjFUtc+72atpSxLZrM5OvL316AQUiC1oCgNZWWpTY1zjjwClMAptZw4VVlirWVrY+0r8JScyWuRLMtwztHpdMjSFFbyrc7YZWXlhfPneeyxxxiurdHtdrl29SpRHCOlZHNjnY31NZTWCCH88+QcaZahwzyrmwbTNERRhBFQ1oU3Dp3FWv9q56WU0ptb1ob36vYn/ypFCBEMyuPF3DlH0zTL44In47XG4pxdjvGKS6KkJ6Bw1nqlG/aJAxP2Y61Far9dXdfgQGvl1yXwawSgtfaKoq5JkwQpBLU1y/OQSqK1Xs73IvfExFL4bYUUy2NEyW3Zm06F3DGKpX0oVkUrbwlEUTCnpUBIhZQKrTVSacAroFi3D6gIP5DflzGGPM8pyoK8KPjc41+gKmsufufdDIdDup0Ok1mX7rxL1VSMpzXj6Q5pGrN96QJSahpTo6MIHUdkaQ8ddUjSdTa3ttnY2kanHVSk0VqA8GW6lampbEmmE7RQgEEKQaJjJN7bSOKIOI7IZY7AgXM0dUVZVZRNxWQ2RmjBcH2du+67h/ncf3fh/DnSNMFUNeOjI5564gkunr/A9oULRBIElqpcMB4fMZvNiKKYTpZgrMBax2xe0hhLXVaMDo8Q8hpaR0il/LUojY4j5osF88WCo8mYqqoQSqIjTbffJYpjojhiZ3eXRZ7zhn/vvV+xZ+VMXp1cvHiRKIro9Xqc29oCaxHBj26qKhgQmve+73289+u/AYDJZMrf/5G/z2KxIMsyvva9X8N7v+Y9pJlf5GaTI5RSbF24QFMU1EXOYjGnrmrOn9uiqSqK+RRrLVi/wDZ17Z8trYhsBA7quibJMlQUI8Xrj9hLJUmjdGlkumBI5nkeFIdfF4wxNJU3kHxUxFLVJVmakaUp8/mcumlQeAWYpinWGMo8p65rHKC0xpiGPM9JkoRuJwuGpMNWDUppulnGZDJlPvXGXqQV07pEOwNk3pDVmroqaeqag4MDoihic3MdHadIpVjMZjR1zTAZ/AafgN88uWMUSxRFS6umtSaEEMfWgxBYHK3TIkWw9vHKRkcRdd3QNA3z2ZzaNDz//HMIIekPhwgpUUoRJzHOCRblgriMyDqa/qDLJXmRvDxiOvNKyLiG/cMDOp0+nU6PNOuidOLd5CJnumhonKCojV+M44hBmRElmriTMJmPmS7GREp5jwoBDoQjeCyC6XxCXZdI4UBY6qakKObMFgsMIJXCCMP+aI/DyYFXOFXF2nBAmsQkUUxdlozHhxSLKTeuPodwBoEjjjR5vuDGjRusra2xtraOkN5SEsLfRykFTV2Rz+fESYrSGovACYGdO6qmoW4akiQmijTGWpQO3pYUaCX9/r5qrCJn8nJyeHhIFEWUZcnTTz2FsY44jojjmLvvuQ+pNFVTECWCKImoyhKs5V3vehfGWr+4NjUf+tCHuOfee+n3+8hAZVUsFjRViSkrqrKiqipmsxkuhKR1pFG4W+Yz+Lns8B4FxoA0uNf7/AgwxlIVx+QDURQHT8JHAqTwLrxo1w7nME3tvSljsU2DqRts0+CMQcXey7DWIKVASc+raZ3DGoOQkqyTYZqGxWJOkiRIpUjiGOsc8/kMKWAw6CPwIbxOlnlvr6oAF0KQfp4OhgOUDPPIWZzx4Ud5ypfu0312KxJF/geUUmKtj68KKRHSu44O513VIKtudOteNk2DMYayKFgUOc8//wJaa7aBbq9L1ukEa0WQF3OSVGNdh16/S2+geerpfaazCY0tqU2FocYiiNKUQaqJooTp1JCXFeNpSVEb5nmJSjN0HFOYdbJuxpoaMJ4csXe4g5AWIUD7pAsYhxIKiWQ2n1DVJUJ6xdI0FXmxYDYbUzYGC8yLOSqKiG68QFn5CZxlCUkUsT5c8648sJjOyKczmrpCCNhYX8fUNUfjMUIIer0+UaSWLrkIeZSmqVnMZzhA2wiLw1jHoigJCRvSLPNhr6oKk7V9CSTuTLGcUhmNRmitvfWOYDye0Ol16ff7XLh4mSiCvCoRKiJKoCoKrDW8+13vQkURSZLwa7/6K3zkIx9BSsnFixcZDvpIa5c5D1PXVFUVQqozlBREWpNoRaTkCcXiw9U+t9lAXcNvwFsRCKxpWCwWy2Osra2hdRKO5Y3JpjE+9yHACv/MO+fXE2MMTV1jjA95aeXPp64bP++0z5laa6mqCikkWZYxm0zI53O0ViiliOKYqqqYzud0u116nS5lWWJM40OS1itAfx98dEIKQX8w8F6k8fkjAK0kTp7a9ApwByqW1lOx1vq4bgh7WWdpgmJxznkrREBdG6QDFVmiKEIpTQZEeUxd12it2djYIE5idBRx/sJ5yrJiOhvjMKQdTRQ5lDZUtsYIS5TFWNswm0+ROgKlUHGHThf66xeQ84q9ownTxZjCNNTWgZAcTPt0+10uVOe5uXedm3vXEfg8S6pjTN0wm0yRCKQTbK5t0kkzur0es6lgf2+HspwznR55b8EYnr82I8lSLly8QJwmJEnMbHbEqK544bmn0UrR63ZYTGYsplM21tZJ4pib+QJnbQhFnENJgQyAAtNUWAcITVXkVGUBWKI4wZWaummYTmf+4RbCww98lI/GNCzynE6vQ6fTZXQ0oixfbfPJM/lKilJ+7sRxzEMPPcRb3/4Onn76KSbTKR/84AeJoohOv8cDDz3C/Q/2l3kVhM8tzOuaOIo4d+4cZVmys7PD449/mo31dd7xjnegpcRpzXBtSFWWlEWBQBIlCTj/7HkDURBHMTWOoiyxzi5DVjTNUum8VqmbCosjTVO01j48LiXGGIq8ABxKKp/DRIQwlMIav7gLKVDS52dwDmeOc0JFUeCsRTgwTYXDkXU7gKOaT4kjyfrmGsViQV3mDNY2UAI6SYywhnJx3C6pmE+RUhAnMbYxOGOQsc/rTEeHKK3o9rtUeUGZFyGfDL10/Tf+EPwmyR2jWNr8SosIW6IqZAiPnSCTFsukOLCSDNRagVI01iyVVJZlSOVd4jRNEEKSFwuUlhhrkM6Bs+g4IjYJQlbYpqExDVVdUZQFVVMRmwYdKaQWGNuAKbGVYlFWGOeoXEFeL4g6itHRIUdHI5TyaK1KRzRlxXg0QliBQDDs9ZEyI4k1ZSQxpqauS8pwvKppmM2mGNtQVQOE8gZeUS4oi5L5eOKv1zYsZjPy+YxO6ie1rRuP2JISrEUGRewcOGdxznsdxjY+31KXfkGpffirqsr2JrOofII+iiPquuJoMqGuK+q6ZjadUtcn22mcyWmQJYDFWrrdLtsXL7Kzu0NeFByOJggpyauSzXNj5rMZJiTmdayXC3+bb/Ceh2U6maKkZDwekyUJSRyhlcYob22LEO6ytcEslYb/rDHiOBohAtDl9RZwO4cN2yqliKOIOImpqnrpTfkvWQJ8JN7LJqwdUsnlvLh1126pYKwxtEz9QgqwFtfU6CRBJTHFYu7RaqZBINBa4YzF1DVKa6TwCrBxjqLIQygcUi0RUoXz9J6TMQbbNBBCzKdZ7hjFAi9+yG5FkgTlI/xLSg8t7vUSjLEUVbUMj3XSlNSlIaeSsL6+ztF4zNHRiKZpqOuaqy9c5+LFC7zrPW/FUWFdyWNvfTPWVvz6pz6MaxxxJ8VgmS5mbGFBwnh2xGxWkFdzOrEmSQXlbM48L7i2NyVKIq7vv0BezCnKOVuba4g44nA0oikrFtM5GIdwAsS9RIlCKoexJZPpIePJAUfjfYqqxAHnz22RZClxrNndvcH+wSGDQY84iRmu9YiUJosjItmlm0RMJiMO65pYaZI4YW1tHa0VSeQBDcZ6JSqFIIkleVFj6ooin1PVJYu8QilFt9dFKo1UioMreyzynIsXLiCdxVQldamptSSfTc88llMseZ6zv7/P4eEhVVXx8EMP8eBDD5H1Buzt7/Pxj32Mz3/uczz+mc+yubnJcDjkXV/ztT5nYC1xHCOE4IEHHmBra4sH7r+PZ555hh/+4R/m67/ufXz9+97H6GhEXVVsrK8HeDIspgWT4M0651GJdS2Xz0qSJMgkQUXxixChr1ZEi+CKFEr5PMpsOqGqSjppRhzH9Ho9mrqhaWpsU2N8FAohBdpJXJvHFSC1JEoitFU424T8jA3RFMfscB+lJN1uFxG8nEG3i20aqtnE51qyjAZDY2qiKEYoiasLnnnmaX7yAx/g0vY2l++6i8cee4yNzU0GG97b27n6Ar1uz+dmpDj14P07RrFYe6tLcjv48S2KJUCQtdaAwVUOax1gsdYsoYbHL7+fOLigeZGTlwXWeYWB8K6ycWAdGOtorKWxNcI4JrMZTkSsr/ewzlI1NTq8alNjTI1zFmMbyjKnMbUPO1lDUzumkzGmbsBYsCCdhylKAcY0IT9UBzgktFUwjakRlWA2m5IvFlRlQVEorG0QjUEriakibF1jqoYiz2nqGqc0SkiUlCghVmpO3PKZ9VBJh7PGJ26risUiRykNUiCVAimZz6bkeU61NqSqa/L5LAAA3LK24ExOn7Q5R+d8El1HESrSIAQ6ikjimE6ng3UC54SvRZnN2N3ZIYpjcI7RaOST8kE59AdD1jc22N7eRkrJ3t4eB3v71CFsliYxOvMJba+UfI6lCh6utcdwXhdQXK9P/Px3gGmMf6ZD3Y2IYuI4RiuFaRryfM5iviBLU7TSCI69F2stxlq+8PnPMx6P6Q0GrA2H3H///SHRb3DK5xGVFAjnqIqcG7u73NzdJVYKAVRFTrfX4+577/WAgKZBFjnWOXauXeOZp5/m+SvPUhU5ZZEjnWNza4sH3/gG6qricH+fYpGTzxf0Bn10pElfsd3WV0/uGMXSNM2x8gjSusoiLIxaaZAKIfXSk/HFkzWiOIYaFkVJWZUBsdTu27v03W7XI1gWMyazMbN8TpxIdCSprcNYS2UcRW18wWJQNLV5jm7viHdtXMJJwSyfY4TyyLAqp3Y1aTdBaoHFoBRIpWmaiqpsuPr8Cygp2VxbR/ksC1JaBJayKCgLrxCkhDSJqU1D3dSMjg5DTUDr+jvm0wlzHHtlFTyPCNcYaCzS+WuukCghSeMIrQQiNKETOJ9wFwHVhcOYmnyc+9zKfIGQkmRyhMFhgJs3rlPXNf1eRlmV7Oxcpzfv0ev1fO3QKU80/laV1juI45i006HT62FMg2kM49GIuiy5ePEiW+cusLGxxcc//nH29/f58Ic/vJyLOzdvsL+3y3g8ZnNzk06/x8OPPsql7W2e/NKX+NSnPsXR4cjnJfKcjfUh9919mTRNvScdRVhrGI/H1FUJuGW5QGmMz/W9Ht0i/HrQNN6YqsN60O90ffFhHFNXJdPxiJ2bN9nb2eXhhx9mOBh6JSEUsVYURU0xn/N3//bf4eMf/zj9fp/3ve99/NUf/AHqqvIGF95I7fc7VGXBwd4OP/Xj/yc/8RM/wblz50jTFKzl/vvv47u/+7tRyoNkiqJgPp/zy7/8y+zs7PDUU09x/YXn6PV6/PIv/AJra2v8Z//5nwAEzzz97HKte8Ob3sja+jrbw0tfvofhyyx3jGKB42Knk9JaNUK2lYQslYhf/D02vQ2FRWlKalLuv/8B0sy7xEorOt1OKHaUvOWtb6Xb69AYg2gsTgjmiwbrGrYv3UVR5Ezn01DLkXM4GjNbVIhgaU1nMxZFhZzMmOcLrHWsba2BcZTzAmMbrG0o8hl1XVEsFmRx4quInQEcSsjgcXnwQhzHZGmGaSxCKoqqohgf0RhDYw39wYD+oM/BwR55XtBUNd1OxsULF2jK2kM/ixJnDBpFt9NhY32dXrdLpCMcggavzLzWtljbYJqKyWRCWfmkvtQa1UiyToe002H7wnmiOGJr6zyTyQRgWZ9QNPmLvM0zOR2yubm5RDNZY5gcHflcI/hapZDs1lqTpCl33X03a2vrSK3Z29vnYx/7GJ0s5dKlS1y7do35fM6b3vxGIu2r3M+dP4cUMDo4DIvoDJyhm8ZsDAcM+z2iUFhZ1zXGGKIowjmfHDdSIhSvH27sHFJI0iShbmqausLahLqyXLvyLOPxmGsvPMfe7i4H+wdsX7zAxvoas+kMnENpzRe+8AXvrRyN6GQpkVbs7u7wEz/+42RpShInIYfo6HVC/UuRc3R4wKCb0U0T4jiiqUo6acKlS9vUZUlZlqxvrJMXBRKHrStMVdJEmqaKueeeexgMBvzcz/4rnIOyakiThDTLePChB1Cn3Fi7YxTLLTUrQUyAEHoUmHddXUgoW2fBWKwtkFKRJDE6ij0KJkuxznH//fcvXXIdRSitOJqMQUoee8tbEBLqpgHhA0RlUyOk4+LFy1RNxehoxP7BAWVtOTzaR4g5IuR7ZvMZjQHjBEVVI6WkN+xhXMNoMqIxNU1TsbtznbIs2OyveRSNtTjrE+gtlBp81W0URaFCGoRS6KJk9+CQuq6pbUOWpZw/f57DwwO/WNQNkRqwfXHbI0oWOZOjMXVVoZF0Ol021jfodrpEWmNdq6R9yFBgcbahaSqm0yPyvCDtdNFYTCNJ4iGb62s89MjDDNfWSJOMvf19ZrMJ+/sHHBwckM/n1G2i9ExOlWxtbVHXNdPp1CuW8Zg49XQoUZTcoljiJOHy5cuYxqDjmKYxPPPMM7zxDY9y+fJlrl27xtWrV7nr8iV6Pe8VbG1tsbWxweH+AePxmE9+4uNUZUEaKXpZ6mlStEIISVM3OGdJoxRnPbOEiGOfTH+9Yj1kV8cJpmko6gpT19TW8tQTX2Ln5k2++IXPs7+/z/joiG/55m9CS8liPlsyCPz6Jz/Bv/7X/5qyqOl1uyilONzf5wM/+U84t3Werc0timKBtYZuGqG1JIk006MRw16PXpYSRRG5beh2Mi5dvMBkPGZydMTWxQuUde0VS+NzmbaOsXXFxfPn6PV6/PS/+BdYC1vnLzAcDllfX6euqjPF8uUST8ugboEduxAfXsZhQ0zWucDJ4yBNMz9R4hhjDItFFRSE5Pz5c8vEvg4ewc7NHWaLOW992zuwzrB3sEcUK+JEkWYaKQT7Bz4BOJnPuHZ9jxeuXiMvKrKsy3SWM18UNMYgVUykY5yQy2RbVdWMDo5I0ogkjel2BiRRSjfrEqvYh+nykrqoWcwK6rJBoWiqhvlkwWw2Zz5fUFQVtWnodXroKKK/NqTb75LGKZ2shzNw16VLPHDvfXzHt34LWiqEg3/5z/85z1+5Qj6dowKip1VeAl/YmCUxSmv6gz4y5JYWiwVKCiwWayqKRc3BvmWxmJKkEeOjAWXhCzTjSLG+1idNNKNx6hFkZ3Lq5O1vfzt7e3t87GMfW3JYdbs9ojhiPi8oy4rFYsF0MiVNR8SBTaExhrvvuYc/9+f/POPRIeOjEfv7+0wnEz74wQ+ysbHOPffcw4Xz5zm3tUlV+/qqe++9l+lkzJe+9CVMXeFMQ1mUaKVY31jH2gatvfdycHDAxbvvptPrvebkvQCEdTS2WTJyXHn2GZ740pewxpDnCz7y4Y9Q1xWR1oyPjjx6schxTUU3Tdjfn/DpT3+Go4N9NoZDpnJGHWhpev0Bd919D9evXePDTz7J/ffdQ7/fo8znOK1JVIcqz5mNx2Ab4gBjno0O+ORHPsRkMmE8PmL0c2MmkwnPPPFFZvM53TRFCUdV5vzar/4KzsF0PEZFEdPJEVoK4khRlQVNfbqNtTtGsawSty1DX6yGX0MYzB2HwRziFuRY0/ikvWsapFJ0uz7UlZdlKAj0GHfTNMRxTGMMzobq3RqSNMY5yPM6uO5Q15aiqPE0QoL5PGc+zymKkjhRKC1QUuJEoI2oPelfFEdoFXlkCHg8PYKqaqirmqqqPXeRCTViFpqqQUlFJ+vghETUNbFxJGnK2toGcRIRRZpBf0gSJ2xtnOPChYvcf98DpHGCVopPfeITTI/G5NM5QohbFItPdracZxIpII4jOp2MONZEkQ7V946mMZimYjH3rn+dJuT5Auug28l80t9Z0iLyJ38mp05aj2SVxUJHGq0jnMsxxlBV1TKxHkURSnjan163y/nz53n6qSeZTSc+b6EkO7s7lGVBp9MhiWPSNKEO0PbhcIgNQJTFYuHzKk0NAu8xW4FUnkOsJYs8LjPw57zMq9Ky690qq8l+P87hnGAyHnPt2jXyxZzFfM61qy/gcKwNB5RFjmnqkMssfKGkMUwnY5oAOgBvyKIVIqAmF4sF+3u7XLywRTdL6fR8qExLDyuOI0/hkiSxrxGzDTs3rjGbzphMJ1y9epXx0ZjFbIppGpJIe3JaaxgdTqgbg9IaFaDQOIsLMGdnT3fR8R2jWFpZ4sfDCxGQX0L4xbs2nrqlKpFaMRwOEUJ4LishSJIEEZiMrfVokTbJXFUVb3zjm3BCeG4sqblw4RLT+YTZfEKkY6QS5IsGHcVsXziHEClZZ50bN3ao64bPfe6LHByO+MxnPsfm1nm2zp2n0+2gtOZg34eoJJJOkrHWX6daFOS1ZT4rUaKiUjVplLDW65ElXeIoJZYRkUoQQvPe97yHt73jHTz3wlV29vb42Z//OYSSZGmXJE1IspRv/7a3EEcRX3j8c8QqpZv1SaKYSGu+6Ru/jUceegP/4w/9EE1tuPeee5a8aX5BsYwnkqLMOXj+kF6/H5hsDVLCN77//TgcN3d2GB0dMZ5Muffeu7l06TJJkuLwYIjPPP44O49fZ3J0RHHmsZxK+ZEf+RG63S533XUXvV7P15cYgxE1UnoU2Gg0YmNji07Hs/9WVRWMKL+w9bpdLl68yGOPPYazlp/7uX/NfD7j8ccf55Mf/zhNXfGN738/l7Yv4axhfeiT9wd7u+zs7LBYLCjLiqOjI8DR7aUMBzHD4ZDFYkHVGDa3UpLM18yYpqE2+LB2qJoX+IiGabzBlyWpf6aNB+VEUUS+WHDzxnUWc1+P8/BD9zOdTHjqiSfodjus9ftcff5Zkkhy/tx5IgFveeMbyGcznnnySW5efYHJdOrDatbyoQ9/mE7mi4D393ZRwvHH/vCfwTQln/7UJxj2O7zxkYf4hm/4eobDAb/2y79EvsjZvX7VG2WmYfvcJpvDgYfkVxXGGurG0BjL+QfuJ4pi8rIiTTPOXbjg815RRBpHqNMdCbtzFEvLSHzy1XolQgjsLUWRAY++HOcLsVa3BUC0bMf+bRzHYaH1EOQkTiirGK18XBnjkFKjpEaKiDTpMuhVFGs1eVGyv3fAdDan2+mRJilaKcqiBFGRJIlPCkpNVVaMj8ZgIY5Szx7s8KgtobDWgx6V1AghwQmaqqEoKhbzHJxAq8h/L2VQhAqswDQWp2BjfYNet8diUTCpplRlydUXrrK7s8fa2hqD4cAXuQWmgtb/M6ZBKcnm5iZVVXFweEBdlVhnmEyOcECeLyiLgqos2N/dBedIkjTko2AaiCmtMXCWvD+VUpalN7RC7jKO4yUE2drj/GVrG/v3LFFNdTDW0jSl3+/jnCPrZEjpw6c7N28wPhpx88ZNnHVsbW4Qa02n0+FQCMqyXCbt4zjBWt8aojlRbe9wy6JEJzz7sZ/DEiFCsWJgGZZSUhQFFAV1oGFpak9LFGkPWMFZtBTYpmZtbUAny+h1uhyNRlx9/nlm4zHOOYqiZD6bYm1DpBVpEiO1piw9f54UAq00k7FDS8EzTz2FtTU7N677AmPg8GCfuio4PDhgsVjQ1JW/tnAv67rBWeN5wKxnQJZS4KwJCL2Gsig4Go1I0pQ07VCWvkj6NMsdo1hUoGJvH2oIbnHAqxPcxWXoC88R1rKaCniRUvLw2rbaNnwe/sOBEgodR3SzHjjBaHJIXVd0+966a2pI4i6bGzG9/ibz+ZwP/sIvobTmzW96zJ+rlFy5coWiKLjnvntRUpFFCaP9Q65MrnDfPfcyHKyzubaGNYbFdEaZlxRFBSiU9KEyYxzzyYKnnniayXhOpz/wpI8iQuuILO5gnaOuDM9duUqaxLz1zW+h3+lw4/oOzz79DFeeeYbPf/Zx8vmMd73zrWxsbHA4GpGmqUfNaeXp7/Oc9Y0N3vPer+FXfvVX+fWPfAKBv+8f/si/pa148WGSml/+5V/y14rvR5F1O1QhnOesRf0G+J7O5DdP1tbWSNN0GeYaDAbsB+BHnGTL2hQI3F14Ay/NMowxSwTgYDDwxpuzrA2HdLa3efOb38xHP/xhPnp0xEc++lHiKOJbv/VbWB8OSKIBdVUxn8/JAzvwufPnmM+nvPDCFXrdgfc8tPbGGGCtJ6YUSoI6zrla62jqhslkQhL72pudmzfJFzkWx2w65fnnrjCfzdhYX2fQ76KE4OaN6ySRZmPYD3QT8Pxzz/Ls009SLnIQAhVFzOdzbFOztbnB+voaCMVkOmMynVIVBaOywpqGnevX+B/+xt8g1gIlLZ0so9Pp8MJzz6Kl5MqVZ8E5OpkPSSupGE+mNI0hTb2nX9U1Umu00oyPRjSNoawMVd0wy3POnTvPhQsX2d/fp9/vc9dX46F5lXLHKJZVj6WVNt7qi6o8X1Ur4oR34hXL6h7DvlY8F7GiXKx1KCWIdYyJDDY2LHSCsAIpokDlrYm1QquETkfS7w1539e+j9HoiOevvkCn413luy5fBgFVXWEbS6Qkg26fLEmJdQzWIYRECYhURGFyyqLEGReKtSTCSayF/b1Djo5mbN99FzqOwUEcJ2ysbyACy/POzRtMJ3MO90cciRHFfM5BKFRLooSorxiNxiRJSq/XX8baF4scYxq63R55vuDnf/7nmc5m3HX5Ll+ZXdd0e93QNElTFCV5UbDIc8Dx9re9A+scu/v7VJW3PmXgozqT0yfGePLFlnl4NBoBhOJB7XODwVMwxiwRmU1TA4JOp8N8NqXIPcxeBc85jmOyToe77r6LIn8rj3/mM8ynM5595hkW58+x1u+ytr7Ggw8+yOOfPmQ+nzGpK6rKkzBKJUmSxBdMkiN1Tpx4SnknNU5I8rwABFHkSwV6vR7O+hzmhz70Ya5fu8bF7YtUVcXuzg7joxHjo9Gy4LfM59RVQz7P6fUy+t2MyXgcQtWhT5O15HlFUZS+sRgQpwllWfnitcDZpbVCCRgfjYiUINZiyYbcVAUCQV2W4CzTugzJfO2r92nzQJ70MlKaJOsgRElJxc7uiLysmeY16xvQ6XQY9AcMB2tfpafm1ckdM+NXlcpqcx4XkvWr7vpqWGdVsbTQrLbS/iUVS9hc4BWLjTwxXKJTsAKFDsu9Rmq5pGpQSnH+/EWeevppPv6JT7CxsU6kNQ889ABpmvKFL3wBawxRkjDo9Tx5pnVgCRQuCqUirHEUeeEVppNIFAKFc4KDgxGT6QwZx/T6fRyCOEoYDtc9SaBWXL96nel4xsHeAWWR88Jzz1EVJXVZsj7sE2nFaHREr9ej2+0t79vReEJVVwwGPW7u7PBLv/LLPPjQgzzw4IMs8gWNNfR6XeI4IU0z5vMF8SJnNp+DELz5sTdTlCWzhUeveablDCXPPJbTKC0SrKoqptMpBwcHrK2vESeJLzJWcsmH1fKCOaAJzL5Zp0OeL6hrj7JUgYsvCt9dvnwXaRzz7NPPMDocceXKFZq64pEH72c4XGNrfZ0vfPbXWSwWzCZHWNvgcMuwXNE0VMagooJO470qi8IgWcx9fdRgoNFKEXe7FPmCRVnw0Y9+lM9/7rO8853vAGA8HrO3t8v+3h7zydh3hEwiqrLmcH/C9sVNLl5YZ293l7Io6XQ6y54tZWmpKoOxIISkO+z4m+fcck2JtEIITxejJGSxBud720wmNVhLojXOGeq6oolj0hCCbAklPVe+JdLa0+jj+Q/H4ynzvGZaQmN8c7Z+b8BgMPzqPDSvUu4YxdIiu1qrSSm1rGOBJSDM/1gCkMqTvIXtrDUnPJaVfMxqKEz4Hg1R4hf96XiMUIIkjrn/3ntpjOHzX/oiUkk2zm35hlZRxGQ2pTENWTdlOOjxTb/9t1PVJXVTc7i3u+zTIryJ4+lgyop+33sMN65dR0lJN+ssu9tZY309jlA+Jmt98618Nufm9Ruk2RGjyYTpZMpkNgudMA27e7s0VcXh7h4CqMuCuiypy4qDvZuhC56h0+16C6woyYucw6MRi3zBaDzicHToyTUDZXhjG8qq5LnnnuPee+/l277t27l2/TpXr11j/2Cf6XTGRz7yEdbW1njTG9+AVnqpXM4KJE+ntC125/M5n//859nbP+Dbf8d3cPfdd+NQy7m2zFO2VnWa4pxjMh4jhWBjYwMtJXUVkvChnqzT7SDcFt/w730DOzd3+LVf/RWefvpp8tmEd7z1Lbz1sTfz6BseZW2tz5NPfMG35a0WWGs5OjqiMxySJOmyTW9VVTgZ4QTEUeTpWoylqRuqsvKLuRA89thjXDh/nu/+7t/Fzs5NfvKf/BPuunyJ++65i9nE13EpZ6irmulkgpYQScFb3/wm4tC3SQhPcVMUJXlekhclVWOYLTwDRV4UFKUnoN3auEi3kxKJLZypqPI53Y4PhUnpSWb7nQxrDXk+R0t/b9uibWMdQmnipON7VUiJlL5RYaeT+NbqrsGamulsTl4Up55/745TLHLFPZciEJGE8JULDohnPG63uTWn8iIRxyGxdj8tcjlwv3rPRMglMkYKgRSSOIqX59MiUqJYE0cR99x9mfFkzHhyxMH+AXmeY+oaqSTOBih0yPHgHPPZFK00aZQETrMgzuGEC8fwyTzfP3zmk4ih8+W8KKib2nN1BUp8hUArD380dU1T1dRljrMNOvITVbZQaGspqpL5YoFzltl85kkpjaEoCt+zwhgW8wVVVdHtdkizhCjSyx45Ozs3cc5x9913L3Ni7W91JqdPWmXRNA2Hh4cs8iLQyR979Ksh6PZ3bGH5dV2jlSSKfR7Qtm0YQnFhu3hub18iiRN+PYTOrl69yj13XaYoCtI0YzAYkCYJzhqs8zD7PM/JBoNlLqU9vsPihPU8dYS5F47b9gC6dGmbXrfL2toak/GYpmkY9HoMBj0iKUKBsKWpK7JEUZcVpqrY2tig2+0wny+QUtHtdpnNF8znC/LS5xM5FJRlFRByDdYYsixlMBgQiQZTlyxcQ5qmHsqvBFoKOlmKczbQJ3k25Vax5GWF1h6aXDYNZV0Dvq1xp9MBIRG6Joq8sWsCf9lpljtGsbQsqlEUHcd7pe/r3naXdFKgLGgLTgqk9m2KX+SqBGkVivd02s8cWMPR+Ihet8fDDzzA6GjMaHTE9GiMkJI3PvKod/0jzbUb17l+8wZr60OyJKbKF+hIcdflCwx6KYNuwnR0wLRaUC5mSKGQxtDtdOl0OizGY6q65mh0SJqk9DtdcJZIeUbWFiFSFAt2d3eoG0OSxhweHvjkfRzhpL92KX1YrtftIATMZxOUEGRpgkaQaIUSCbgIHXmLrKwbhFSkWZemaTzJ4O5NoijiwQcfpChyPv3pT3vvEIeOFDd3bvIP/uE/8A+58ZM6TmImkymTyZQnn3zSc2k66Ha7ZzmWUyqDwWBJe1RWU8bTKaPRiOl0QpJ2cS70MglFyS1fH3CLsqltCJNZS6fTIU0STFVRl77BV6/Xo5tlfN/3fR/PP3eFn/vZn+Hzn/88155/jkgZnG2YTqeemNU55os5TWPJBgN0nJCFYxljAAXSEWkdSgSaZS8VT1lh+YZv+AYODw75C3/hL3Cwv4+1hksXL4I9z+H+Hk1Tcff2BdJIoYWjiUuaKmIw6NLtdDy9vVL0en2KPKcsFqwN11AqIk5S8qLkaDyjqg1H4wkXL1zkwvlz7N98ASshizfp9Xr0ul0kFucs5WJOEkWcv3zXMrRYVZVvQVGU1LJGINk7OGTv4BAVp0Rxylve8hhKR1ihieOEJM2I4oTfSAO0r4TcUTP+5EMthQAZ3svW62i9FnkMIxbH1plrabFftN+VHA4QhYRcVZU4a9A6eD+hD7iQAqQkiWO6nQ5aK4SAKGobA1mUgiTW9HoZTdNDtl0unadKMaYGZxDO+fAdFmOa4NKz0gvCYUzDfDFftgNwzrM0RzIBKbDC3TJW4D23touelQol/ITBk0gEC9OEDncJxjhv+UmFdY7ZfE5R5BRFgYqOw4pNU7O/vw+IULgml0y1Ht7pGcccfjF4vbTnZ/KbLy3UuNvrkHW6JEm8El72NWKtN9LmMv0C7/nrmsZzwnmYviCOk9CVscE6D/81dbPs+bJ17hyPvOENmCLHVCVKgsXvz1lHYxq0jm/pv+QC9Nl7122flpaA1qM/E5Vi6grT1CSJRzlOxhOUUrzzne8E2+CaZhmJaOo6RAtWIb4+nyQFKCmJIkUU+cLgjfV1kqyDihOmszlFUaOkwtoQOo8izp87B86ghKGTZmRZimkqmrqimE2XjOptAbcQIhwnCtBj33hwMBhQVIbGNJ63TCpqKxkMh8RJ1v5wX8Gn5LXLHaNYbqFuCdIm5T1d/koIKyz6XrEc06kcb/4S+xIChENKwcZwgLOWG9eeJ05SOlmC0hEISdkYb45j2drcZH1znf2DXcqqZDDohe6SE5xpSGLJPXdtc35rnaOjIxbzOXs7e5g6JzcVcdIhiRVpolFSUNeFp7yXbUhP4BpDVRUcHOzRD4gQrQAhyDpJ8Nx8PsY44yGS1rK1tg7O0ZQFUjmcEMSR72s/LwvKuiHPCwaDAZ1Oh7oxFGXNcG2d6WzKF774RZIkJs1SUpf4drSBkWA6OqSufUHX5ct30el0w/0ViK5kFsg55/P5mWI5pdIubkmS8Oijj/LoG97I+fPnUUoj5XFtC0IsK+GFlBRFThQn9AcDJkcj5kXhQRpK0+v3SOKYPM+JtN9+/2hMWZZkacL2pcv8oT/yR7jypS/y3JNPkM9H5IsZe7s3KauCxWJBlnXpdrvLEGvd1L4tsNZYobD4Qk4fmpPLvirz6YRFWMCds/T6PR5+6CF+4Ad/kJ//Vz/Dz/3Mz5AlKY2UTKZTJA4tfNJc4CgWORgbFvyIJNL0OhnVYMAjjzzK+sYGO3sH7OzuM54uUCrG1AHMICRvf+e7SCIJrkYKgRKSyWTEfDZl98Z1qqqiKArK0lf4dzod4jhiOBxQljXjyZStrS0e2tjkS089w/7hiM88/hnmecNo2vCWx97IW96SYi2B2P/0yh2jWNq+ER67fmw9wXEV8LElAyJ4JydlqaDCvy/q6+L8nsQKESPWgDVYI0B4l9/XzUi0kmil6HYztBbMp2OM8yzIaRqTJh2KfEaRN8ymRzR1w2DQpSpr6qpBCIuUHhyglEJHCqzDV4V4z8aFih3f7NFQ1QVaK6STLBazZVhOSBnoWLwu1ZHEGUtpamprcKbBuSiEzPygsqzIiwLEsXfR7XaxzvriOekXFRXYDUxgo82yjDQTgGQ8njCZTNnY2MI6x2KR+wIxKQPY5XTHg3+rirV2qTz6/T5bW1ukaRa878AEHkXLJL4LyCWlvBeTLxYorRisrdGyW+SLheeg63QwtQ+FyWCVtxEEAYxGI55++imwJbapMI3xSEwhiHREkiRLKPQg5OuMMaAUQoKOfOFw01hM0zAZj7FNvVRG1jrWhkNGoxF/7+/8HXavX/c9g6oKrSTvfsc7WMxnfOGznwnz2/LclecwjaGuIc1SLl7cYDqbM1/kZJ0+vf6Aazd22D884sknrzAZj0kShcNSFDmf+9xnwRlsU6CVIlIaJUM/JWNQ0t+juvJFoefPn6ff75MXNbu7ezzx5NMUVU1eVuzv7zM6mjKfN1S1ITS4xSHI88IjMU+x3DGKxRq/OC2VyopyuIWEEvznrDZyaJWHO253eqyVbnUrQ5hMCAs4JBbhwqJMUDkuhNqERCqBjBS9ToaSsLd3DecsSabJ0i7rwz57uxJna2aTEUoqNjfPMR3PqIsSiQ3U3nGYyBppvUrzmPsmXIJDKYlzDVVVEKUZSgqmE5/3SUWGjiOUinxuRgi0lhh8czHnwHoiIk/KmSYIBFVd+0pl4ZWWlMeKxRfPHfNEtZNbKUWapp4BN4p58smnWCxyeoM1TwNydESaZqRph6Y2t4IRzuTUSGtYRVFEr9djY2ODJE1WipHlUrH4EKh/FltFk+c5WSej2+uxmM28YslzXyHe6bCYeF48ISVRpI9h/9ZyeHDA008/QyeVy8W3rahvafobY6iqEinVUmFIeTxGSoW1FXXdUCy8hxRpRROq+dfW1rh29Sr/4Ed+hHObm5zf8kwScbfDO9/5TvZ3d/jspz7p57YxPP/880zGU2Yz6HQSDg/XqeqGqm5wTpKkHZ67do3ReM7zVw+IY0WSemhxni949okr1FVOXS2Io4gkitnYWCOJI6yxSGTIq/jzO3fuHOfPn2c6y1ksCnZ398jLikVRsr+/z2SWky88014IlmCdIy8KZvPFV+25eTVyxygW6UA5UMGXkEgQDitWQmFS+jwGhGZfvtOh9z3a1zEey7bFh75m31dYCj/hitIjXnr9gbfq85y000FIRZnnqCgiTWPquqLMa9IsIelJjrodmqZGCEuT50xszY0XnmN3d4cmn7G+dY73vP3NfOmLT/Cl0R6uEjgdk+iUKI7p9QaYxKNNROBrwvr+271BnyIvmMym9ANj82Aw8KR9xlCX1ZL1VErJdDpFCk+5oYRAC4ExHqVVBS9ke/vSUqn0egOMsZy/uI3bkUwmM9bWBly4cIG8KDDWhIR9TZ7nxHG6LLJM0yx0EoQoSvxL+1qBNoxyJqdLNjbWlzbV1WsvYKzh4UffwPr6BsO1dZxzdLtdet0u3W7G6ND3/nHOBo9Geuu7MWilSJIMKSOMgdl4ipSK/toGezdv+tBPmqCUwZQVa8MhDz74IJIaU5dce+EKdVFRlw04PA9Y3Xjuv6rEWkeWdnAqwglFnuehiNkrrDRNMY1/Lv/pT32A3Zs7fM/3fA9FnvPFz3+e2WTMbDJBK98o7/r1mxzs72Is7O+PONg/wDQlQgvizCEjS1FWVLWhbhrGsxmZsQzX1uj0BgzXNz1BpFJcufICT9XPsLXRQytNkvXIQq3K2ppHmq2vDTy5ZVNzeHjI0WiEjhKiOCWKDP3hkAcffojaGBprSdKUoYq4fM85nJDU1qKU4PnnnyOONec2N766D88ryB2jWDTCFxEan+h2AfIrgvvshMC23GDqGELc+i3OHSsXuXRYjmHGbdl+u501jUdaKY2jxgRPSYLnvgrhHWcMpq5RnQQpFVkUU+Gom4J8NmM2qSnmM2xV0ktTNoZ9Ll88z87Vq0TCIjFI14AUaCk92sWBbSHU7ckjfNIeaIzBGItyvhkR1uICczPGLQELZVmipCTRmtZbM6bxHoSzVGVFWdXUlece8iGuDr1en6PxkVcIzlc350UZyAcJzaE8JLIl+VNKezgmvn+Hp7N5cVO2Mzk9EkUepGEa7xnMF3PGR776XioFodFcFCniKMKGdhSBdm8lEW3Rgb4I4cOfTWOIY19LZp1/Zq13m3HWkcYJw+GQpppTiva5cp7RexlGdYHNNyTvQxM9g283bKxFCLWMRxRFwWw64ZlnnmHn5k2+67t+F8PhkNlkws4NRV2VJLEmjjTT6ZT5PEcqjXG+kVaSROg4QqgGrbSPGiiJIvLUMcbX8OhYEmcdpPDI1OvXrjObzdhY7yKEp2RRUYzSEVJplI7IOl0Evm2xkArr+P+z92fPlmbpeR/2W8M37fHsM+ScVVljVzd6BLohNIhuEAQhESJICqbNwZSs/8K6ddiWfSdb9oXDFw75jhESLStEWANIgARAAI2eh+qq7hqycs4z7rOnb16DL9baO6sVssgLhJEVyBWRUZVVOZxh7+9d7/s+z++hbXuquqFuu0CMHo/ZVDVdXUdadMLe3hihNBZB0xmM6XcL/+f5fGIKyyQbYHpDudyQFQVZkaOwWDwORW8sm6YmGxSkRU7vHF6EB7Tzns6GXsVHiaT0giSTiKiyMr2hN4Z0OAgvKqGx3nG5qgGQSY4UYVy1N5nivacva8CRCoFvW7yEg9GE9XrJo+Mn/PjHP+InP3mHr/7Sl/nyZz7Dm2+8xv5sj5dfus36+CGn94d0TmKR9EiEc7Rlhekt3oYRmdYJTWdoe8uyrBBCMRhP6S30VYdUDo/HOr8jPlvX473Dmm6H2saHYrgdHRrjWa7XrOuay4sLLucX/Pb/7Ld5443XOdw/ZL1cIb3k8mLBarkOtzOtGAy2SghF34W/Iy8KtJLUbYnWivF4HGXekiRLd6mEL87zdeaXp7tdypdf+QX+yte+xu/93u/z7W9/k8l0n4PDIz7z2c/i3SSy8Sxt20dIq6Tv3c6vEZJUG9rekaPIBhO6rqNc1XiZkmQBmqp1ik5yimLIZDjm8WLOZr0mTwtsb7lsLrE2FAxrw2tb6TAK6/ue3rR0xgfZbZKGGIquZ7PZ8KMf/oC3f/TDIBxIEv7P/+l/Spal7M9m9F0gT2gVlJHOOazpObpxk8n+Aa+8/nqAXTpLuQ7hdG3TUgyGFIMBeIF1jsvVGqkURTEMseTWcfXGVfb7WShKWqITjRWC2nienl2i5ksePnkK3oXYgL7DdD1/+CffQGuNsQ7rbBhLdyHTaDgMBcVYw7AouHH7pVCklEZLwfJyztW/6BfQ/8T5xBQW5cPoSvjd9QZrXBhtJc9uLc/y3x24YPyL1JQoRY5jL54t+rcmPmcdzgZD4vbXbQ2ROxNlvE05wvVdxj9TRbNjqhO0kNi2I5GS8WDAdDRiOh6zvzdlWBT0TU2eJhwd7COSAmSC03vUreVsvg5d0cfNhbsuoUXplFQncfwXVW/4uNwT8WMNWSghYjhIKPHB67LtfrIswTvPR3fv0rVNMI1pTZ4XGGMCjlwEn5DrgtdFOjC95WMaboAdl80aC4RlvxDBBLql1744z9/JsjR+7yTr9YoH9+9xeXFBXVfceeVVhoOC5eUlpresV2sWy3WQxXZ9ZIIlaKV2xsTdsv9jvqXdTpMgT9aJhlgkqqoM8l7EbqwEIsAXm+As3+5Wtlwz7wM6xpgej8G78BpMtKZrWy7nc+oqLOnrpqZtNXhPmigSrcMuJz4fPAE0mXiHF56+60IXpBTCOdx2oiEVfdf/TNdlbHh/7PZHhOmBEGC2rX18tmgrcE7ES16YNjjvqZomfn6RvK5CXEcIiVW7SzCEXKSwPw1hg/+jyqTn6HxiCgvOIz1kSRJCr+IYx+LJtQ6mJq3xPlBCO2tBCtq+C1svQVgCKoV3QPRYbEUAW1d7HwFzWZaG+hMX4TKqWTw+vhAcSgYNu1KSVAenbIKnkoq2brh17Qa3r13jzu2bzGYTRsUAby0P798nTzQ/9+lPcXj1FvlwQj66xoOHx/zT//b3Av00SfAusIWEDzkUm01JXvjQWheD8Pm6/4GMertJ8h68gehXefb/wvL1cHbE4nLBD37wA65fv87NmzeZ7c0YjUYsLhes12uU0s/UeEIhkTRNt1P5KLXF9YfxR9e0QBdHbaH49KYPb8YX57k7164exu7V8c7bP+RP/viPGI2mHB4e8dd//dfYbCr+4F/+EZtNkI7fuHWb2Wyf69euMxpPmO4fhChta0nTBOeCA70oCvo+mB0DDy8UhuFwSJqER85iseT+/QcMMh0MlX1Kl6YBbloHzPxwOiXLsp1Mt2kaisGIQT7k+PSMpu0YDcfRZzJFClgullxeXtD3PfsHM6wxPH78kOvXrjG7do3l8pLeGIRS4RKmFBbobehGuq5D+GAGbfoe0bY4ISnLMrDVVPCc1HUd/TI5Sim8dyRpinOGuqlxxuKsZTgYxJC8LFzUIIzRZfj38F4J1gKlEkbjAVonzJdLmraLe82gKNvuw8L77vmeAnxiCsv3vv+9sIT3PtwoVFhoCaU4vHGNJMvQgzy47bWmt+HWvV6tQusuVchH0RovAURIgvMCJUSQMXrQKiQnmr7fGQ6jTgxnw0QJvx0pRcexF4BDCE/bViAEt27f5tHD+zx+8pSDwxnFcEhVt1hn2dQtw/GUo+vXUUkRIowTTaIFUli8tzjjGI/C0m+9qhDe0bc1WZailcCZDuNszGvZYgO2vVg0jhJyXFAS74PmP96NqMqSrmsp8pzZbI/r166RpVvSciimSqqQqBk7DqmedYahgwpte9d1QJhxSyXRNolKnqBye1FWns/TNQ1KKYosx40C1yrROcI7vv3NP6PvDZvVgqvXrnP12nWcDzu/D9//KXlecHB0helkssPmC9ezXlzgzQjpDcI7hHdMRgO8c3RtjeslaaLIs4wrV65g2pq+a1itV1RliYuXqaapSQYFKgkkcfUzeCYYjUKwHYT/LqXk2rVrfOELn+db3/omZ6ennBwfxz2N5fz8nKauY0y2x/VhXNw0DdaYaPQ0eOeoqxrvAmRSxj1TIBR0eN/RGcdq0zIeDZiMhxjTRShl7Ej6LmTaGMtm3Qd/WpGhpIjm6TBR2KZBdl2/U5xqHbqSTd0EV35vKKsQRT4YjBiOJlwuFkwmk7/YF8+/5nxiCssPfvjD8MDTCqkThFJ4KUnSBFLNeDrhYDxAKRlyReqQ01A3DUIp0jwnURqRPfOuCB/8Kmrr1NeglEBJQqcgwu0gPLHlri319lkQkZcO7yXeW8BTVhVSCm7dus3jx494cnzMK6+9wqTrKesmcL7qlsNr13jp5dusNzXGOGSi0EqghMPY4KofDQr2JhOaskZ4S9+2CGdJlMCYDusFKs8hmqUEP0sgkCjYaeJELC4C76CqSvrI/DrY3+f69WukaUiQ3LLQlJTgnxnptuq77YguzLzNTn7aNlEtFxEfQvAC5/Icn75tEWlKPk6QYkCepVgL3lu+/c0/Q0qF1ilXr3yOX/rFL3PvwWPm80t+/OMfo1TCanHJ7du3KVKNThO8aVldniNcj3R97Jodk1GBAFbzOb33+JiCeHR0xOLiFGta1us1TRM4dcb0NE1N3nUkOwpwmAxsJ9nD0QDnPGVZxxG34Pr1a9jPf45333mbp6bn8vISpSSDQcHFxQXnZ2fR5yUol0sCpcLuKBepDgvxuqoQRDVlBN8GT01LbyzrsuXR0wUHsxF9O4pjKhkmBN7hTR+wLc7SlC3eO7omI0kURZ7tCBZ90wSMUl0HNJKxu0iK3jms81R1i/Oex0+fcnBwxMHhFRaLBQcHB3+RL51/7fnEvOvzQbEDzoX20FG1TQAo3pXs7c/wiQKpcALefvddVps1127epCgKhuMJdt+gIsJCCIHxkCiNFkGJggPb+8Aci78uSQKWW8d213tPb0Ln5COyYou/hrBUVEqSDzJ+/iu/xBtvfZp79z7kg48eYIC2bXj48D7FeMIrr71Jayq6zjBUwf2rhae3LW1nePrkPkp6vFMoCbPpiMl4xGgwYLFaYY3FuzS+2WQolG6rCgt3oJC+5+INaWv6FAzyjFdefolf/MovMpvN2NvbYzAc4GxQ/Zi+p9yU6EQzGY+RQmCN2cUYSylRUoECnYY3ZJ7nSBVC1pwxOGMwarsHenGetzMeDHDecTm/IElSdJKg41izqhuyLOdgb8Jyfs53v/VN/uRPv0G5Kfntv/s/ZzyekKQZDx8+5Pd+90c7UYjvGhJG2Lbk8jJQssfjSaBdrzbMLy547913UMKTSOiaDX3bMBjkCOHouybKhiumkVbcm46u70K6ZV1RN11QWUlF17U4a6nLDUWR8/obr/HKq6+QZSm/8Rt/HSUli8s5P/7xj3nnnXeoq82ucFlr6dqW8XjEaDSmbUMezI3rN4LloGkwfc/y8hLvPWmaMp0OyPOSzXpDqjxd32NMixCQqvDcSFSID8iSlF4GVE2aKLxzbJbLnRLVxUnAeDSKijqBMS5w0nSgNytdUdYdp/OSg6OM2WzG4cEBR0dHf7Evnn/N+cQUFqU0ztm4QAPrXXixOcdyuUAmOgYDGSye05MT5otLhpNRmFHqhL5rsdZErH5wpVs83iVsx13eWVyE0El8KDBCoAQ7EcDWmb+zXwoR0TE+7ByUREjNeDJlMBxx995HrKs6gus66s7Q9Y7eQWccbWfQqsWankRLbDSTma6lqUqybIQUYUyn5LN9T2i/t/1KtPLAz4DQhN86pqMhLmAJEMBkPOZzn/sseZaRpGkYC1iLd+FF3/UdOtGkSYqxIUJVSrXL3tjeFLcJnDKaRgPbycXdjN7iDF6c5+xkaZCIl12DFIJEa5TaStwdUoSdZlvXnJ+ecH5yTNO2TEdDRsOCqmlp64rVcoFzNsrxBW0d8lXK9ZK6XIMLCsfVcs3Z6Sn37t1jNh2xPx0H+bsPplslQ1ft4l5BRqrF9v0mRQjgcwTC95aS4X3g0xVFTp4VXLlyhMBz584dBOGh/vDhOI6Rx1jTs1oudxcuGQ2XfR8+93DBCiO5rgs+LEHw1qRpQtJptAJP+HuVilSMaHdwSIQKo2SvIjQz0VjT00SQp4Dde2YrXFBa0/cWIQxCa5z/2CXYeoQIlIQsywJq5zk+n5jC4nxYsJVNGxZvkXHgBazXa4bjcZC5JsEU2ZuW1WqJ7fswujI9ynsyJYK7XUh626EgQiAFUnjwFiw4b8EKetvSx/576/rvXVQ5RRVMkiTBCaxkWAY6y3Jdc/fuh3z00V3G0xGT2VU+ePiUw8ND/u2/+dvkg5z7xxcsLi5p65p284CqLDna3+Pw6IjDoyvM9o/I8gFJNiDRgsuLC/quo28b8mJEXhRhLyJkSLMD5LNFC97bKKFUOGlj1xKWihenp9y8epUr+/tBzSIF3ho67+lMj+07uqYiz1OUElzMF7RdS1EM0UlCFjM5nHO7amZMH5Viz8aNWZ7u6LgvzvN18iwDPCJK07uG8P3VmtEgI000zrS0lcN2DV/76r+FThJ++J1v8vT4mH/1x3/K3/j3/g6//Q//HuBYLRf8P/4v/1c+et/w9OFd3njjdV577VXufnSP+XzB3Y8eYIxl/2CPq4f7HB3MuDw/plw7nO1p24bVaoFOFEk6YbY3ZXa4z2A8YjIZc7A/w3ronWe9qbHOM5tO8N7Tth1d27BaLfn6r/4Kl/M5/8f/w/+e+XxO2zRk8YH8t3/rtzg82Oef/Bf/OVVVBdhs3N8cHszC+Nd5zG6hGtSVeWSmrVYrlquK5dqQKEuStNy6eYXhIMe3Fc709E1NZztcF9JTdZJw5eAgjNed2+2EpnszpFQ8OTlBSMloNCLPc4bDhJPzC8qqZrFcY5xjOhLkWeh0+r5/kcfy53UcPnQM3kXXfTAvSTy9D3p3rXU0OCkSnYTI0PjA9S4sxb134dYebzpEzMkzKTLPVGLehT/bx24lGrWsD6wwoTXO5SAESXzheQdSaophivWwXG8oxiOkUHih6a1nvlxjL5dYZ0hk6IbyLA1qDxVkxJuyZDieopMMHZd8W8fz1oC4dR0HI+h2gR+lwEFqEpE1RF4BCOF32PEtkTnIIMVOIZdoTZalDKI/xdrgrHaxgKqoqDHbj8t5hGR3u1Lq2dK/a7tdy//iPF8nkLRD7ISSW3r1M+wK8b2ypWIn8Xu/6VpM36GVoFotefrwPpvNmqrccPP6VazpUcLT1CXzizPWqyVluaKuS4piwJ07d8iSyP9ygeIb9nEqMOjynDRNMaanbRrSgYkdUdg/dn34PUHR66Nnqw+mZu+YTCZIIRgMCoTYZ3ZwwHqxpFytqauSlVa0bRihZUXGwcEB+/sHbO1WznjquuJYCOq6pmlqlErwCNquI00Uw0EO3iDY7iTBuPDzLEt2uxmlFFmacO3qFQBm00C3sM6SZjnOedL5HOd8pBunIQk2jtbDuF2QZTlSBtMzscN6ns/z/dF97DjA4rFEd7wMD3NhLV3bhJ8nSTBOZQGqNxmNSZMUJSXW9MGY1Ad/iZQSZzssCu80QmqUCHAXj2dTbTAmyBz73sRUx6jLlyJkuWc5w+GIoXOkeY4kFI5iWHD91k3ev/sRZWuoewuJYDiZUbYdv/cHf8J6s6asS77yxS9w8/o1Xv/06wyKnDxN+bNvfJNvfvNbfPkXf4krVyUOTW96lJIBDzE7CNwvtj8ImnkRvD7hCECFgd22ziB2Dv/D/T0moyG274KJNCZahrjXCfuzGTeuX6NpW9qmCd1gdNNvu5Fd2JPWKKkZDAa7RWtZlvFN2TxTrb04z9WpqgohBePxeCcPD4DJEGYlCPvDLMsYDkbUVaBmS+Bgtscv/sKXmD95xD/+v//fePcn76C04v/0n/wnCAE/+tEPmc/nfPPeh7g4yun7jlu3bvE3/+a/y70P3+fuB+9RVSVltdm9tvP8JsPRkMFwyHK5oKxrRJJSFCEGeVM3bOoaleSB9tA2mD5AKLcXs8lkzHA45K/+1V9j//CQf+dv/xb/9X/xT/in/+Sf8IMffB/b95w8fUKWphzsjfn5L32Rr3/96ywX85BEieTi4oLvfe97XFxcMJ/Pd2QAIGbBhK9fVVVIHK7vY+aK5vBgb7egh5BT/5Vf+CKj0Zg0yVit1yzXK87Oz1itN6xWazZlycViSZoNKIoCHRltgdeWMjs8RArBYjGPgoTBX9jr5t/kfGIKS9v3WOuCOssHg9IWWqcCQz4A71SghU0nY7r2gCzRSDxd19LUFWW5wces76YOFFLpHGmSxCIkIu8ljI36rqHrQjIjIoaGSYX0Hi+Daco6t5MLGudpe8umrMmHI26+9DLrcsOqapgd7GOFY9N0bNqeqjGMZ4ccXLnOuqoRQrK/v0+aF+gkJR8MyYfDgHFxnrZ3WC8QSuP6YPwMH++2YxFR+hx3GrEz2z40vJcBeikVR0f7zGZ74GzgjPWGsgzxxmmakqYJn/rUp4IxMqrqpJQhGCx2JU3b0rQtg8EwQgHD5snaEC27XC6ix+bFjuV5PE3bhctYkWH7IM+X0iKkYjgckegEax1N0+4YcEpLNpsN1hrSLAtdr4SbN2+iteKHP/wh6/WKb37zG3z605/mC1/4PO998CHzy0VYstcVT5485vz8PGbEC/Iso96EwrNer8KuMtHMJhOKwSi8R3fZ8MHwO90bhht/3+MJE4c00eR5xma9oixLLs5OefjwIe/8+F36pubOnTvBgd93AQsV+VtpkpDnGUwmmL7HOTB9x2xvQppopuMJx6enrNcblssFdd2wWlc0TU/bWdpBS6YEb33qDYZFzmwyYrlasVwuOTtbUW2CRy5LE67fuM5evUdZ1aF4rpZUZc38csGmDtLnwPiTZHlOktSIGMuMkCgduqE0fb7Hy5+YwtJFFpaIhcVZs1NS7OSubRt2BTgm4xHeWVKtwwy2a2mamqrcgDVIIWmqeldYXJ5D7p4tpXF4b+n7lrbraNsOpROElAiVhkJizMcKi8ALibEeesOmqsmKITduv8R3f/B9VqsVk4MjLCp0MZ2lMZ7J/iH7V66xOn4QookjribJMvLBgLwYUNU9xnra3mNdcALbiHHBbwPKZBwNRFnBFpK2PR/rcBKpObpyxGxvD28NpguE46CYcQHRojVvvPEGw9GY0Xi8k32uNyUIQZqm4evS9QyHw5jiGfwtbRvorBcXFzu10Ivz/J2u6xFSoXWGMT7AU6VDCcloOApEY+fxbUtvDLNZjtKauqnx3pNlGSrRKCW5ffsWWmt+9KMf8OTJY/7gD/6Al156ic9+9rM8fPwYc9rhrKGuKp48fszF+RmbzTog9rMUCIVlsbxEp4p8kMfI3/Hu0hIM54EfNhwOKYZDFhcXQBjFJmkoLOenp1ycn3Nxcc4H79/lj/7gT/hrf+3r/LW/9nU26yVd27I3mVBXFWenx+hEk6UJiRziXVBl9V3LdDJhPBrjrN91FqvlgrJsWG9ajAFjgjHYFylvvfkGk/GQUZFz//596rJktajwPnRVaZpw7dpV2q6n7foAnV2MWVyuEFJxcn6BtZbVaoWUkizNSJIE5318timSxIQuRj/fHL5PTGHRSRIBxCKkGrZ1cPR6R2t6vBC8++67SB2yRhaLBR547bXXEEKwXK2YjMcM4/xWIOhlE5Mbd6hKRExi7GKWRF3XtF1P1/UkgFIJUrpglvQtsqoRQpMOSnJHgNQlCQ7Fqqx5enKBlwkyLfjJ+3fRiWY4mfHKG5/mytWrDMYzVlWDTHPK1vCDd95jtHfIb/zmb3F6ccn8g484OryG8QInBa0NHY9OctJUI1VQtG2TALZImy32JjzSoxOfkFGjdMK1q9c43D9ASijyQGI11rJar/njf/VHICTT2YzbL71EXhT83u//Cx4/fRpGX0nCaDyhi6qZj2enK6UYDAqKomAwGPDqq6+GUcuL89yd0XSfruv48KN7pElCkqRhxCQ0nXEoHVIU295gqhZH2F1KndJ1HSen53hvGQzHCEmgAK/W6CTlF3/pl5hfXvKP//E/5s+++U2WqzW/+NWvkySa73znW4wGOePRgKZc0zuLdQalBPt7UybjMaPhkKZtYL1kmuZYZ+j7liTRjMdj2qYKl74msPwmkzHHT59wfHxMuVzhneNv/63fYr1c8dV/68tIKairMiJdHHW1wRrD3nRC3zY8fvgg5KcoSZ7lmL6jaxryPFz0bN/RlCXO9AgsaQJKgtZgTEvXalIdUlrbpgqCnLomzyxJqphOxgjgo48+4vjklJPTMy7ml7RdR5YXTPb2uHPnDvcfPOLRo8cMx2OElKzXdSAsW8HNmwMm4zFVWXFxccH45b/Y18//1PnEFJZw2Ra7UZe1li7GnzrvaJuQZ5APMrI82yXObef+fd+TxdhUGWf+WwZYWAA+C/4Swu8kj88Iq4GyKsSzLcZ2JNd2PX1v0MaQ5AUOQd20tG1PZyxJmpN5wersjBTBXlawf3iFl++8hpSWpjMMpMY4w2K14WD/kP39Qx6dXHC5XDEYzDDWMRiNSPICoROSrAhtsQqyQ2O3bl4fTJKAt4EOYEz/rHNwDqRiNBxRFEX8sgqIEmLvHE8eP0ZGrExZhjnyg4cP+eijexhn0UnCeDKNu6d+B79s25YkSdjb2+PgYJ+DgwMSrRkNh///f728OP/aI6TG+o5NWTGbzRiOx4xGE5IkDR1uFIZY5+mMDYgRG8P2IjpJK4WOEcXWhtu+VAkHh4c0TcuHd+/y9PiYpg3u9L7vubg4x+/vkekpdV3R1GEfZ/ouSIptIG+vVyuatkWkOWmeh51db2lag1SKJE3ZRhd31rBYLjg+fkq5WpPqhK/8/C9wMJvhTMfFfM58Pg+jYxVe6ypNSHWOAKqyDLJ7nQSSsw3vm7YN+8eubeIILaSwJmlK0GAqlOiDnNhaTN/hTBdiw7VmPC5Io/qu6zrqdh78PfM5Z2fndL3h6OpVEMEHJkTYb+UDi9qpUaFuwo5Xq8A729IuntfziSksq3KzKy5919Fbw6aq8MDtl27Rdj3vvvsev/K1X+avfO2rXF5ehsyRGFJ0cHCwU3tt865DTrvYxZ+KLsAZgxkyvIGm0yl13aCblqrt6W3HaDAKYzGl8QiqpsU4j/OCqu1YbUru3r9PkuVcv/0yR97TW8vRfL4bnWWDCflowuryAmdasmlOmhYUQ0XrJE/PV6wbz7rxfOsH77Ipa37jb/42eTGgKAZ4NAhJng0w1lKV1U6JdXB4EPlLlrLc8PjJw5BtYXrK1QW9hb29vaCeQbDZbFiXFZtNyXq55MmTJ4zGE976uQnHxyfcu/eQumoYDIa0XYt1nsViFVR4WpNmCRAyydM0Dayormd+fk7fdc89MO8v63l6FhD5+WiPX/zq1/na17+GVgFOenz8lPOzc37843fpnKD3ktZ6DAbftkgh2D+6EugLfcdmEzxao70ZXddxOb8IIXhScHT9Bm3T8s1vfZsszdif7XH29DHlZkldrjBtQ7VZopRgMMipW0PT9hTDEF6XFGNuv3yHpnN85/s/5Ps//DH/6//oP+ILX/giNjM8fPiIf/7P/1noRpzj+NETvHNcOzoMP3/ylOFwwI3rV+maGu8cr778EkpKtBQUeYFEkOqQb+9syICpypKf/OS7vP/+e0iVIITk6HCfyWTKK6++xuHRFQ72D/jw/Z+yWl5y//59hA8xGIeHR3z5K7/ANov2gw8+CKOvyZT9g0NeevkO/+pf/QlPnj7lpz/9KcbYECjmLNeuXWUwGiGVZjiasFxtuHvvCd73tF1DmuqgSnuOzyemsBwcBoSB3+JKJFR1kN7dvH0zLMrO5ygdVEtFUewKxzZxzkUPh47QSu+ClNj7wOvpjYnMLk3Xm6CAiTcjh8D4cHsLMt+w02j7nrZvmF8uqNsekWbUTUtvHINJxnRvRu89fW9Ybkr6pg6ZC73BI9FJCkqSFyNSLUlkiFvtjcUJhUUGQ6WFbDAkSQtUkkdVmMSLMPobDMehsDhLkuRIpXE2EFeLwTDk1uBJpCNRUJYlx6bj+OE9sjwnzXKqsqJtO65fv06aF/S9iV2JjRJJB0LhsXRdF0HJAp0ED0/KMxlkwIDHsdwLVdhzeQ6vXCFNUsaTCTdvv8R0bx8Zidaz3oBMuLksMTbIfJeXF3Rti07i3rLvA81BKHSS4YUkgHolaV7gfJAJJ2mGR+DqZ3vRrgvFqN5sMH0wB1srYpBcmA5kWcZgOGR25Trj8YTz8zPatiVNUy4uLnj46CFaKZbLBc4Gs6LpQyifs4ETCMQUSvDe0Lctztmwa/UenCVRCYnWDIeDQNrQCYvLBcvFgvV6RbnZUAyGUakVhC2j0ZC96ZTDgwPm53t41zMvL8H26JhyqZQKalbrgnqs7bAeBsMx3nuqpqasqsAic56qrun6PuBivUMJwWxvSpbl9MaztzcmS5PdxOV5Pp+YwvILX/5y9JB4Zvt7zGZ7ge8lJaPxmHsP7nM2v0BpyXw+ZzqdkiQJ63Kzk0waYzDCMBmNUUpxcXGxAyzWdRmkxV1HmqZ0bYNSkmIQYlbzgUSmDcY6dJphnafpDPPFisvlirP5EpWk6GJIkueMZzNmB1e4fvMmTddT1TX3Hj1mtal58Ogx127eprcwnu6TpYrD2RQdIuaomw7ftKBznEjpvKJzks5KsCIYOG0oiHVbk2UZ+7ODnaa/a1vKqqWuNgDsHxwxGg4YDQvW80NMW/HRRx9xdvyEb/3JH/DVX/4V/q1f+mUulyus9/w7//bfoKxrfvrBh6R5QT4c0BlDVbdBieNdLJ6WxFjyvCBNMnQxBHyk2Xp6IsJTvkC6PI/nl//K19nb2+PTn/50gD0qBQG8y9HNlzi8fotXXn0DmWSIJOG//a/+K548fMh0b4+qKrn/4B5FkTMY5ExmBzhnOTl+ipSSo2vXWK6CMlAlOYXOme3lwfMRqRVt2wYki+nJsxTTWS7nNdO9AUcHA976zKe5euMGX/6lX2Gx3vCNb32X8WjCL//yL/Pee+/x/gcfcHRwiJSSK0dHnJ+dsrq8pCxLrDHM5/Pgw+o7zlcL6rqCyCJ79OAhbV1TVSWCQI8oshStNcPBCO/D6Gq9WJComFvrA3ZJyTAOK/KU0WjA3myKdx3L00d4L0mzsHCvqiq+Twxt1+E8zBeLkG6rUx49fsLJ6Slf+OKXWK9L7j94RGcsxoZxtRCKW7dukaQpn/70W9R1Rdu2SCWDB+k5Pp+YwnJ09QhrHW3XkefBlLjN5+5iLrtU21HMINyyXLtD3G9v3Vuzo/BBECBijnsSHezFaESWpgFuCQglaZqWum55enpGVTcgk5COqBLqtqNuO0SSkSiHjsFJSic0bc98vgAVgsgGoxHDriPNC5I0QycJvTOY2nB3/RiJRwswEUi3KhvqzuKlRiaQ5JCmobsIhSXc7oTSdMZgbfjhrA3hXhG3su0iQgfS09Q19++9Q7mch88x3q6KosB5z2qzoazqIEGuF3TGIqVmPJ7QW49GMBiOYgZHoDtb60nSYEgNaI5oyJTyhdj4OT3f/e73GAwG3L//gDfefJM33nwzjHykxPbhwqXSLHSrdc3rb77J9evXydKU1WqFTlPKqqSuw1LbWouXCi8Fxnva3lA1HYLgMbt+/QZd2/Dk0UOKPOf2zVtcXpzQ1CVtvSFJFNeu7XPl6iFXrhzivOPi/IIPP/wQoTS3b93CywSk5ur162id8MH7H+Cdo4iinOvXr3Pj2jVs3/P40UNwjjzRVHVFXdfs703J0zTuTW3MTXE4wPTslGtKKtIsC5fLIieErjpsb6Ka7CwgW5zj7OSE9WqBjegaqTSL5YrzizlHV66SpCkfPXgUMo6kou4sp/MF5xcXbMqKx0+OQyxA18d8l4S+N0HWvFqRRoTLNsLCmpD6+jyfT0xhOTw6xJiAkN6qkJI03DBWqxV93KekaUaeF9RNHfO5gxqq77cVPiRKCu/DGEoYrAv/rpOUwXBEnqd0bRIEAn1P1XRcLpY8ePSY5WqN8wKdpBTDSXwjSZKBRfrg3pdSo1RC03SY+YJ8OETI8DCuu54sy8OLVie0TUBRnB8fg3NkWkfumGBdtdT9trBIEidJsoI0zSMFIORGCAS9CeOpvu8CrZnI8VIy5tT43Ty8qkp++u5PsH3NKNeRHKsYDAZY51itVpR1Q28sl4sll8sV4+kew/GE1aZES8lQ6Z0gIETPhuhYpdVO4r1lqL3IY3k+z3e/9/2dwMUjePnlOySDNMiMuwYhJWlR0HcVXV3z2uuvh7FN37NYLEBKHj56SPm4pu07rO0hxgf3ztP0lip6ZRIpuXb9Oqvlgvd/+hNmkyF7RwdIb1itJG25QmcpV6/OuH37Jjdv3eaDe/c4v7hAfPgB+4dXeOPTn6WsO6qm47VXXyXLCr71zW/T9x2z6ZTZ3pS9w0Nu37iBNT3f/rM/pe86rh4ehO6hrjmc7ZGlGdvQchklzHgfiMTGsFgsSdOU/f19tJIMipy6aUOBNYamqjk/O0MQYK1np6c786hSCqk0F/NLzs/P2T+8Qp5ku/wYpRIuFiuSR485v7ik73uePHmKsZY+xjknSbiUWtewWq/J+57RaLSbroQ98Yvl/Z/Lado2+FhiYptOEi7nc6wLaqnDK0d89atfZblc8o1v/hlvvfUW0+kUCA7xpusj5kWzWJV47xmPx1jvmC/WFEWQyBoHy03NH/7hv6RruyAd9h7nYFM1OCRZMSRJM/LhGOvBePBCY72g7XuUtUgV9jR111OMx2R5znQ6o246+t5iTJQAC4XUKbPZIfiQ/+AjODLLazoj6EyLtR1t19Cbmrru6bsePAyGBYmOvDIlcVkg1IapWotWiuFgQF2X1HXF5fyM9eIimiOHZEowHAaDY9/1tH1YhvYm3D4HwzHpYMJqtaGqK7wQoDRSxR1VVJl5KREqCeIKu8VcBMe16d1f7IvnxfkfPeVmzc2bN/n1X/91rDH8f37nd1itS6RUfOmLX2I8HrO3t0c2GDDY22OzXGH6HiUVQkheff01Dq8c8fobr9M0FVVV8u3vfJuyLJlfLkAIZgcH1GUFQnLjxo3AH3Mea0O3XZYV5aamGIzI0gSB5PT0jMvFEqETRoMhr955jYOjK7x08xbnixXnl0vWqzV10vDyyy9TbjasVysuLi5ZLZZcOzoiUZKzk1Oapgbbx3ju0J0oKcjSBCUKKLK4m+nJ0lBUB4MCpcLOpWla2rZD6wTvPXkeXPFZohE4bN8xKAqyRIMrMFHI0BuL0AnrqsYi2ZsdUNcNm6rCeg8mIF2SNPjVdJJy9cYt6rqhqWsQgVgxHA4ZDAZM98ZkaUaWZqRJQveCFfbnc+zWaS9FMCkKsQvzGgrIYnDQYrng9PSU1+PtKoSDgbUtWhNQ273BOscoOuXLqg7OdalQZUXXdzx+ekzbtGRZGFkpnYSFOiIGjalASHaE204csdnIExNSBfNhzFhIs4wBkGX5szGREDHzQqCKZ0Z5Z5+NuKTUIHrwcteOBwmx/difEQOQpEAKFWgDAozvUUogcJi+o6o2lJs1TV2FYiI8mRYUxQClNa7tMMbu9idCaWSSk6YZzm8w1qHSJEq0w9/tpSJJw8Izy3OE9/RdG/2YImBkPgHLxr+Mx9lgtpvtTTk+PuHJk6ecnpzhEVw9OmI63QGRsOQAAHcVSURBVKNrGobTKcPJhPOTU9q6RmlNXuQcHOzDNIBG+76lLEuGw1FE/XQhQsEaWhmiE7IsI01Sdr4rTxhRG0ueBoRJyFgpMas1s8MjhkozHo0Zj8YMBgNGvQvqNGuxznN0dESe5bRNS9c0NFXA4WspAp24aairEiVD9MU2KXaLHtJSIbzHWxtTUVUkLQf0vVIyjorDnjDLskgjlggI4oREh0RHF+LEu74PVAwVOg9EG973CDobLsdCBpoxXpAkGVmRM5nsActghtySj2N0R5ZlDIoBw8Egdkovdix/PkdG5JWA1nTUbcP+4SGJTtiUmzjm6ek7Q9caqrJhs6lQSRhpGevRPjwIRUxxq/ue5WbDgydPYmiVpeuDakTqjHSY0BuDsyAJmHvvPZuqRbaWTefwIkAjSQtQmkxIpE7IsixsQaXk8OiI2f6Mum3p+p4kScizjEFeoEYj8FCuN0Fy2Bms7emMoe0cTWex1gOCNMnJsyxSacODfZBn2JhH4V3Y6o/290i05Hy+oq4rVstLzs5OuTg/w7YbUiX48s+9xXQ85HB/ytHVa+RFzunFnKqqmM32mV8uefe998lHEwajKcSxSJoXIaysqnYfy+3bt5lMxuxNJ2zKDffu3kUIUEJQDEeMn/O0u7+sZzIaUq9X/LP/7r9lPJ4yGo6xfctms+G/+Z3/OqCCfEwOlZLlckXbtVRVzWuvvcY/+If/AGsNvek5PDwgTzPeeustpBRMJmO+/d1v853vfodEB9z82dk5i8WSLEnDQlyE3UuSJkgZLlOr1Zo+Ei1G072dFaDrOuq65cbtl/j0lWu8/+5PqKuKX/krX6epa+7e/YAP3nufux9+yHq1oUsTjo4OWacJ1vToNHDELi7OWSwkqxj0lSWarm1pm5Y00SjhQwIk0HfhGVKWJZ6Qb6+1JiMP72+C323rPyk3K3rrKZseoVOGk4Lz+QLHgsFgxHR/zO1X3qCqa8q64fz8gt4YRpMgNIIgaAihZyHd0zsT1JxKB46htbR1Ra2eb0HMJ6awbGGKUspgXCTkTreype97gDgrDnA4G/Ev29uRdY5NWbIuK9brNX1vSJYr1psNq/WGrjf0xhCSIAl6du+C8VELtAhFQhD+6UWMJBYhXVLGW5kHjLXUTUNV11R1Q7nZkGUZvTXBg9OFGFRnXcxmCHnX3guU9Ehhw9+zhUxuQ5Sc45mRE/BEn4gLkcpaoNAILKbrOD15SrlZs1xesFmvaao1k0HGZDTg5ZduMxoW5KmO0MgqiBuIt0jnkFqH25lWNF2P9eCFwvkgPZZKkeUFg8GQwXBEMRxhXcj+DvkVMu52XtCNn8eTKBkNiQYliB4uicBTrtexs5Y7mkNZ1/R9oFA4FzLsXaQTF0WI/b5ydETbtZTlhulkwltvvcXl+TneugAmrerQxUabsVKh28V1O9Cj1glpltH3PVVVhf2okAwnE4pRiIsgmp5PT8+CAdj5QP5Wmr43CO9JkxD53dbtzuzc1HXINzEGiccpsSMnbzOEQjvOM9pz7LiFCPsNp23A68PHpg/hY7fO4XwoBGmS0tvQDbVdQELpJIGmDRMHGRb9OglTgKZtsXFPs41gdv6ZedsaQ+uDSTLPX/hY/lxOoHGJiKMGEDx69Ii2bbly5QqD4YDrV2/w/R/+kJOTE5yHJAtf/KCyMhyfnHJ8csp6U9J1fbiJeB8z4UNrPpmO0YlmU65jHGlHXhTkUpOlafCwqBgvqpIgC1SaJMlIdIrzwXV/cnrCxfySy8sFo8mYo+USnSacn56yXCzYrNfUVRWz4SVpmiOlxjsZFF86vICUkiHQyDlM39MFYFKUP3rWbUueJhwc7DHIM4osZXl5xuLygu98809ZrxbU9ZrhoGBYFLzyqVd46dZN/uqvfh1wHD95zPxyyenZI2SSoaSKN9OOg8Mj8uGIfDDig4/usd6U5INhVL0plM4YjfcYTaaMxhMGwyHWOYajMVIG1HrTdCwXq7/AV86L8//rJFIwyBIO9qbsTSdMJyOGeUpbKTYmoHryPAmjY+MospQiT0mTnDsvvcSnP/1WUErZgGRxOA6P9rl3/x7/4l/+c77yla/wW7/1N/mdf/o7PLz/IIAnV+v4twvwkizNMXlHU3Zso7P3plP29vZ4fHJKWbVUZYVMNLfefBMhNfjwgF+v1nzv2/8NidZcvXKFvu0ZDka0TUOPI88zmiphvexQMvC1Vqs28MC6FiUFVoUuQHwsg14ASiqKvMBZF301QVHaty1aaZJEhT2mtfH/iUjgsHgvSNKMwWiEV5q27Ti/uKQzjr3DK2zKisvFMkwB8sAF7Puei8tLvHW7ceIz6b7FOUPVBkjleDzi2rVrf3EvnH+D84kpLLBNagw7Be8Fk8lkJxX2HpaLFaPhmDff/BTr9Zq7d+9SfSxPer5YsFiuwq4iuiyllKRZRtcHLIuxDoQjyQqktnihUEmGVAnGOYwz2C4QgpPUI1WCdIEU64VkXAwCFiLNKIqCrutD7oS1tGVHWVWxwwqpcmmaIaXCdBZnA5JFImOOQ0qeZrjMIhB0SUei1U5XL7wnyzOKPGM6GtI1FZfrSz58/ydcnJ/SNyVXDmZ88Yu/wiDPKfKMPNUM85zl8nJntNJJQp7nzJdrqraNuyyFkPH2mGYcHV1hNG7prEMpzWA42OVY6Dg3d86RJCHLPM8zijxnPJmSxNHdi/N8nbpcge25TBNs39O3NRJPkaW0Tch9T7QKeUGJ4srVayRpytnpOW1d8f5P391FcxvXY50LYV3rFVevXMH0Pffv3SPPMq5evULiJCqaaLfEi/VqxWa9ZDzKMKZntQojqoAHSimGI4pBcMavzy+wLghClpfLUHCkYjAccuvWrbBET1O0UvRdQ5EXdMMhbT0KKBfnQ86JkHgld1BLGSW+Io4BRIxotTbsY5w1JGmAsFZlyKl31tH5jr4PeBmt9S7wzzpHnhfsHxxi3TnWwWA0BiF5+vSEum3xENNYVfh4fNgjm7gD6iIdJAh6wiXNRdN22zTBk/Mcn09UYYGPFRcln6m+XOhINpcLBoMhr73+BpeLywh6mwOCLC8o42wzHwzD3FiF4KKsKHBAvzUnCUc2yFHO4YRER3xL31us62m78HDNvEAnoH1oY72QTLdz2CynKPqIIlc4F0YB1a6whHFbUeRIoVjWa6xx4MLnqJUKOO8sw/VBb98mCYnSJFJGObEnlQHvMBkOOF0vmJ+f8sFP3+X05Cl9U3Hlldv8rd/8GxR5RppqHnx0l7osWV7OIzVWhmCvPGfz5CnL9QZ0FuOVgx8nTVOODq/QGcvFconWmr3ZjNn+AXuzGTpJcQSysVaaw8NDJuMx4/FoR55+cZ6/05RrXN+iBPRdiBlO05Q8TejqGoSgyIN4JdGal27fYjQasV6saKqS93/yLmmWkaQJvesxxrBarVBKhQ6i67j30UdkWcqVK0coI/DGPuP1ec9mHRRdhwe3gGAqDHuGDbfvvMJ0OmVQDJBCsDq/oO0tbWdZLQJuPqi3Rty8eTMUFakoN0u61lMMCqzpME0dnP3GoGR4PXplIDICVeTiqe37KpKUrbO74jIYDJFKs14HkKV1FhdFQEmMCU6SBKU11nuyomA222e1Lml7y2CoaJqGp8cn6CQJgYRCPhvXE0ZpxsRxed/vLn5CCLRUwXAci3ddlX8Br5h/8/OJKSxCKoyzbFZrsjRkpzhCUVmuVpydnfODH/woziOhrMqdB0VKRR6VJEKEVLiPO8Kbqt7NNreU3na1imbKkDWtk3DDctbtPBp5nqF1Gmek4YZTV1UAyjUF3ppwU4otrbMWnCeJCYtlVbJabYJsOB8H/4APrW/XdTR1TVWFDJm2bWiqDWQpimy398nTFG9bTp4+4MmjBzx99JDl5RlNtQLbYZqSar1AMyJTA65dOcCaKbYN9ObF5ZLOODpjUTI8SFoLqdZkeYHFsV4tqJoOax15liEElMtLhDN09QYlVfy9Ic9GK4G4eo1BmiC0+kQgKP4yniwqsWzfc/r0CY+6jqOrV0nTjNneGIEgy1OeHp9wenbO3/q7f5fX33iTn/zkp3gcm82GV46OuHPnDlKrXUDe6ekp3/v+97hz5w6vvPYq77/3HnVZ8cad1+nbwPn7/Oc/y89/4fNY2/HR3Q+ouwBZ3D84DH4SF+gOy+WKy/klaVbQVBUPHj/h4eOnpFmBlgJneqpNyaOHj/HeMxxNuHnjGsIZEt+zWS9ZL+dczgP8cVDkKCl3VAqtFePRkPFwtJMbb6N/l8sliQ4F4OaN68F7JhVaJwzygqquado+Suslm3JD13VkWUZZljx69IimaXDOMZ+fI4Tk8GAfEzuT5fIyjN+HA9I05eXbt1mtVqxWS4QP8mgtARdoGlmWMhwWbDu65/l8YgpLCPiyO6lw14XoYGsdl4sl5xdzHj99gtYpaZLQdG34BlofOFmxSwACkddDmqWxkPR4RIwDDe1xb6KcT4gdNXi3OGfbOYXlXljkBY18MC9tEyfDnNSYoFizJiwJg9rDBd9I2+O9IM+GEBP7nPc77pezBmP74KiPP3dOInwYh3VthbeGvqtYzM9ZXJzTtw04i46JehKHEnGZniRYAW3X462jaRq63tKZ0BVpJVFphlAaneZ01tKaMGO2zlOMhqEolhWmrWkE4WsgJL4Py9801ZiuBRtvhfJFYXkejxQCEbONqnLDer1mPJkEiauSBHpvEIiUmw15UTDZm6K0Ciyu9Xo3itaJ3pHCtU7YrEv63saUx566bnYSWiElg9GQ/aNDRpMJeTGgaUqEVOR5gTGh+wnvTUvXtnRtiENeLRecPH3KzVu3yYvA9gLPer1hUBQUgwGT8QQlPVeOjhjkKZki5qwYJuMhWinWOozCsiwNO53JlDSOw7quo6qqcLkbtHRdv4tLTpL0Yx0Xcb8S45HjpVNrjel7Nut1gNNaQ9s06CQJAV2dx1pCrEVEMGklGY+GdG1Dk2jSRMedU/izTeQYZmkYK2/Nks/r+cQUltaBRSLSjJ/89D0+eP89NmVFb/odPFemGSZWdxEdsIUKcuO6bXf69BBwDHmmcc5R13WQPSYJXgRJSKY1O9qlDwmUOI8UgkwH5UxXV2AzhPPoNA1CF9fjTUtXBz9M1/c8ffgwKEKyjLZpyfPgnF+vS4rBAKUTNlVDojNG4zFN31M1TUDUZAlJ5REJyGECzmK7Eqkz+qbjj//0T3CmZ1RknJ+ecHF6Qp4lHExH3Lx2lU+9+Qav3rnDaDCgyHO+8+1vMb+4YH9vD2csRZqwWa+5mF9ivCcrBnz9679Kmuf01lEMhuSDEV4GB325qTi/uOBHb/8IKRRaBW5SIMUG7X+WJkwSyUh6uqZ6kXn/nJ62CrdeIRqqTUlT1UxGIyaTPR7cf4RznsFoxHQ6ZTLd4/jBfWzTYPqe9WbD8be+xcXFnIcPH4dLkPdYF7KMpMj48IP73L37kD7err/9ve/TtjUH167y4YP7PHz6iA8fPaKyjtnhEc4ays2KLCsohKAYDCgGg4AwaWu6as3y4oyTxw/4zKfe5PqNG9y8foOmabmYXzKeTLh64wb16hLTNVy5epVES44fPyDPMm5cu8aVo0PSJOHp8WOUUuztTZlMJozHY0zXxssbrFYrFsslR0lw4J+enVGWFRcXi5002LpwaV2vVjRpynA0QieaLsqjV6sG6+LepKsRrqetVjjrkM7x2ks30UnC+dkZptkgXU9X1wjbk8gAmXXWYPqWtq4D9yxJEH5b8p/f84kpLB/c/QhEmH+enp9zcbmg7UMWCEQzUaSEWhdaSBHnuNaH/yalBymice/ZeSY1dJEaTJASAyLKxXz8e7YhwJKYbeIs3troIYludGuxfY8z4f81bYPsezIRECyBr+Wj6TOyunQIMivLkt6EhX9vQkse5JQWrUI347zh9OSCutywXl5iTU9XSqrNCmc6bt65xcH+jNs3b3Drxg28tZi+p4Uoc7a7f7rITHIu7IK0UgyLnKwoaI0hzzPyLMVLERhrztO3Qw729sLCUmuyWFi27LBEKUZFRqoknTXYj3WLL87zc7Is241+gZ34IssCl8rFkW98kYb0ERlEM13X8eTpU7oIbW37PtzABdCHTBHrwkgr7DYke9NJ2DcS3pMmdsHGOaq6QRCwQFKEvBQZX1NpmuzMjaYLRsit275uTSBc1DVlWbJerenqhr6pOHt4n76t2Z/tc3k553K95unTpwhgvVmRZSlZFkLL5pdzUh1ex0kS0lF7Y4ICU8qdQnS7H93SvV1EJXkg7QMv7dn7u9/hjMbjEVJI8A4pQCoZ5d06EJe37xPv465nl9wXnjfy2TNr2/k9z+cTU1j+8//y/02WZezt7bHZbNhsNgwGA7SOuxZPXK57nPM44ZHe4/ouPDwhYEei6xXYBVRtH/IihhqFl0JYrIUlf/BAboUDAo8EpHfgHM4ZnBFYPM70GCXp2hrjYiBZ2+AB6x1926Glgsj52sobJ5MJZVlx//79oKgqcqrNhsv5OX1bo6VgmOvQWrueb/7pv+Lk6RP2RiO8NZxtlmgpSLXir/7qr/Bzn/kMt65fw1nL6nLBehtqZiypTmjqOn5sLTa6+LMsKNkSpdBC4FWgB7RNGRAvQJYV7I1HvPHKHYajEaPhkCTuUUREvDjTk6ZhJLm6bOliyt+L83ydw8ND+r7fvZ+ccxRFwWg0gniByrKEsqxp6o7haMDVq1d447XXER6+8Y1v8OVf+DJvvPEGZVVjjMV4z+npKe+99/6OQlGWJUmi+fznP0e5WfHhh+9xeHjA4cEBd+9+SGs65k/OydOUq0eHKBlwQM6F3eTeZMJwUNC1DW3d0JQV9z+6x8X5JSfnF+gkZTo7xCNYrSvGw4y2Lvkv/4v/F7euX+V/9Y/+AX/2Z9/g3r3v8cEH71OWG65cucJ0OuWll25xfHLMyckxr9y5w950j6tXr9J1Hcv1Gi3DlKOLKbJt24YJSF2z9cg5QJswohdS7ArL9hKZpQm3b92i63rOz8+C419rUi0RwlNu1kEQM5kEBV6aUJVhZysi5inP812ntKUDPM/nE1NYlE7xQtJ0PZ1xWAceGQ17PmQYIMKNSUaVRbwVBftwcMj77Q/vMQ789s9BYiOWZWtA/PjOeVdU4qJu++/wLIfbR3UaUiK7Lr41BX3XR0OhxliL1grvLG1Tk2ZZ+Bj8JV3bI6UIvKG+Q4qwYDVNtbu5nJ4c8/jBAxaLS7qupSw9gzzjpdu3eeO1V3n91Vd549XXmQxHDIoC0/fUSlOWm+jbCcmai8UCaxzGuYCf0AnFYMhgMAy3yJjB4UyP64ITGgRpWqC0ZjyZ7HA3fR86KuG23Ry7XA3Es0L+4jxfJ8syuq7j/Pyc6d4eL9+5AwiWyyV7e3vhFp6m9J3FGs90usfh0REvVS2bMph+R6NR/LWCum4o12uyLOOzn/0sT58+5enxCdNpKAzD4QDbtwgR5PRaa/IsZ5APw4VLb8Uz4Y25vZOfnp1hnGc8nTEaj7l+4waz/QPyYsBitcE62Gw2setXNLXC9R0v3bnDqMh574MPeXpySt103H7pDlv1GUJS1S1ZPuDqtRuApKrqnSO+LKsdh8/GmG+dhp+neR7RY34XJui9R0nNYDSkrptddszW8LhNkUySZFdctmZNYJd6K2OSqzFmRzTeWRbadnchfZ7PJ6ewJCG0q+0MvXFYL3CxIDjCN91uHb0i3CLwPjrwY+sonxWW4B4H50QoTqEHwXkb6lCcAMDH/TNy55TfFRW2hF+PiC+G7W5GKh2KSR9CxKQK7DKtFc6FTqZtGpz1NE2Pcx6pJH3b0rcNSobCUnoXi4/j9OSEH7/9I9pqjbU9lekZ5hkvv3Sbr3/ta/zar/4qy/kFtu/J04wegdaKpq45PztlOp1GIvQGax1SJ1gHWichnXIwCAiZ3tFZi4mjij62+ONJCA8bjka7m1Nd15iuQ/iAcUkShXEOYbdjyheF5Xk8aZrigfl8zksvv8znv/BFjo+PQ2GZhsKCFHRpeM+NJxNmBwc4A+fnF6RpynA4ZDqdBpJ3XLSnacrnPvc5rLUcHx8z25uG4lIUtHWFUs8KS5EXFMWAtql3cQsuSnwFoWs5OT0Dqbj98h1GozHXb9xktr8fhDrpnKYNGBohNR6JEh4pPC/fuYPpWt774ENOIl34U596k8FgwLvvvov3jrrpGAwGzPb3WS8Xu7AtYyx13QTwY7xkeQRplgaCejHYTTzCWCp0L0ppRqMxFxdzmqYNZmIVisCWML4NHtwWpG1h+binZjtFsXFcLYSIDLb+RWH58zybut2pI7aoEy81XiY716x1Yf4ptp0KHiWT6JJXoQg5gXUC7wSdjaVDJZHrtUWoEK7dPOtItt/IbVERIv5eG0ehhA5Jdd1uvJbmBTpGndqIrFdaUWQZ3lrWqzXeg05ShExou47FYsmoyBkUBd4ZrOloqg1VueaD+TnHjx+C60m1BKlRzvLyzRv8L//+3+fK4QGu70kTTe8dH314F9N3dG3L2ekJJ8fH5GkelDPTWUB1e4+rG3rrWS7XrMuay3W4zfUuzJeFUqRZHkB6MuAk8jxDWYcUAVdheoMWAickQgqcM/TChp3Vi8LyXJ6+t0ihmB0chHwdpTi7OGexWLC/f4QxlsVqSV23NG3PP/vv/3ve/tGPkFLz4MEDlsslJycn3L9/n6ZpMMayN5mQFwUHBwd89atf5fOf/xybTRnjiwNa/q1PfZpBEQy7w8GQclDQNwP6rmU+vyTRmlQrlAoCmqqsuTif85OfvM/BwRV+7jOf5eTsnMv1HCEkaZqh0kDZWK02HO5PGRQZs2FGXQW1W2uhai0ffvQQrVVArXjPfLmi6TqKpgU8Fsn8fE5dNyyXlwE5o2IBzHO+8Omf4/DgkNdff522bWmahsvFgrIs+fCjj0CGorEdl22zkO7du7crFH3fB7xM04SRWOxqnuGaxM8+c+LFdvt7gRc7lj+v0/Y9zjr6vo9Z60kgChONRdYFXDtxaR/puojQiSAkHhF4V17s/l2IKBeWW+7XtkywrSu7b/j25iAQSGRY9juBEHY3N7POghXI7UI/jsmCj8X8bD5K19I2aRwZGdq2pdys0DgSJWiamqauaKqSzWrF6XFgf+FsQOMrQaEzDvZnvHLnDkoQlC02LOPrqqLv2kB5jS10aK8dOknwQtJbsxsT9sYGplM73+2tVOSFFcMRvXVsymo3FthOCuuywhqDjktXY3RMCpQhE8e9yGN5Po+I5ImcPC8YFAOaJmSA7B8cAdC2HcZanHc8jcv6g8OjwOOLD8/1eh27eXY37aZpSLRmf7aPNcFoeLG4xDvHaDgKFIgsDXEVeUGb5xEP40i0iAwxjVIaayxt07Fartnfv8JoNObx8Ql13YT3ZnwlhnjxhrrIkALaRNK0HWXdhEmH81wu10gBeZ5GFmAbjYmOJAkP901ZU9cVmxj4pWR43hRCMhqNme7tcXBwQN001HUdQLUx0gOefQ22nYUxhrIsd9DN7a/p4iU0SfSusEDkIhIfR5EZ9vFi82J5/+d4Fqsy7FGcoygUKlWUbYfoeuqqwlhD14Z0yYASGaO1pq4aLCEfZItICMgG9UxOrHWQSsaREx6EEsQGFmctIi73QSDFs2+uVBrhHCpCGROTho5JCEwEOPZdG2CRKqg7EiUhjsLCnxPAedY5NI6Ls2Me3y958vAB5WpFW22oNmtOnj5GuBAoNigyRoOCr375F3jtlVfom5p1VVFVG5qyBO+4cnhEXdc8eHCf0XDI4OWXadqOqj6ns4LeWsouzrzTnDRJESp0KgiJ0DqAKJUmyUJa55Pj090Nqqkqmqqmqkus7dEoEq0YFIH+mqcZe9MxaXQmvzjP1xmNJ0GZZT0vvXyHr339V/nnv//7HD895c03Pk2aCIbDipHUSKWYzWYcHh7ym//ub/Le+x/wzW99C601bdvyyiuvIKXkn/7T3+H84pzj49MAZIxSc+cdVblhbzrhrbc+xeuvvcqtW7dYXM4Zj8ccPx5QVxtGw4JBUTCIFG0fOVxSBh7ferXh3r37nJ/PQ8qpE5RVzZOnx7u94HfWS0zfk0qPM4am2ZAmKWmastys6LsO7/ogwokGZrwjzYLRuSkrpBSMRmPyfEAemYNtb/jxOz/mww8/5O23347FI3yMLo7ErbWcnp6GwhrJ6tZaVqsVRVFweHi4G6kvFgucc0z3glouaHpCEVZahDiKJFwgnbcgHEJ4dCJJs+f70f18f3QfOzoJNwyMjRRhESV/Mf/AhuhhZ12MIwaivJe4iYnbEZTUu2VbZDnuFCg7U0yA9Mef+mcLF4hdzf+IjjzCIr2Q+Khfl10XeEPG4IzexQZv58im7xDCUFY1eFBKsLycc3Z6zPnxMU1VgulpmxpvDcI7hPfMplMO92fceeklrhwdYvsO58yOG7tttfuu282zw45qFb5OSIzztJ1B64QkkQilEUoG604sutZ5rLe0pgoybbHNp1B0TUvXdjgCGQEfusC2CxEEddUEA13yiXmZ/aU6ddPQ9QYhJVlRMNrbI8sL0jRjOBrTtg2L5XJHr764uKDve+7fu8/FxQXjyZiy3PDhhx+wvz9jOBwFabDWOGeDgqttSNOwH+27js16zaOHDzncn2Fu3SLPC8ajMZvhMFAqvCPVCWmSYKyJC/HAq7POUdVBbTmfz1lvSjZ1T9O2LJYr6qalaTvatsZZi3LBVNx3DXmekWUZdVVj+h5nQ1ZRlqXRdGyZ7c/Ii5xuWKOkDBikJJgivfdIBIO8iPkrOmqCPI6wW8zTBBO7NeBn4oS378EkSaLRMuH09JSu6xiPxx8jGgdDtoxy623H07bNbr+yHcE9z+cT846f7s12rbdSCo+g3Gww0fMBzx6ou5uOddR1IBgHyFyQEA9joE/Qn4f222xDuWJme9AAbG8z4WPY4ep5phDbygs//qJwzoIB72u6LoQN9daACoFBxnT0vUZ3Cnx44V2cXSClZDIecv+j9/nRD76PjUj8YZoi8WgpwDokjk+9/iqvvXKHX/rKl8nSlLYKS9HxoCABuq7l6ZPHCGCQ57tl4XpdAh1eKow3rKuGwVChcg1KI7RGIbDe01kT36gdy9Wa3vQMBsPIOCt24UmzWXAtexN2SW1dsV5vKDcbjneKmBfneTtPT07pTY9OE7LhiNHsgP2jKxxdvcrNWzd5/PgxP37nXW7evMnNm7d45513aNuOe/fuUwwG3L55k8cPH/DDH/yAPMt59bXXuHXrVnhQSsnZ2RkXFxdMJpPw+pOe1XLJH/3hvyRLNDevX6fIc/TBYTAUtyOm4zGm7zFdj/ZhvLS/f4C1nvWmZL1pMNbx/gcfcjG/5MGjJyAVw8kep+dzzi8uOTqYkWcZtm+iwbCD5Tq8p50Dguosy1KSvMA4izGeN9/6DDdvXAsGa3ygH8eOQ0Ul22y6F173UlLX9U795bynGA7YbDZ89NFHKKUYj8dcXFzsisdwOKQoimA4nUx4+vQp6/Wa69evP3seef8zhWgb+hWKddjdXlxcvBiF/XmdzXoVQn/64JEQMWQH7xkNhzuEtfcuBPSsZXiI912Q9OEjgkUF34kNNygAI02QLDtHnuWBJGq6gOoXW9FwkBnD1tMSxlpSwBYjtxUXSOlAeKyzeATe22B4ci7gV9o2IiEcTUS4uL5lU1V8+N47nJ+eoITf7XuU8CgBSkqOrl7naH+fWzeucbA3pchTtJRUddirIEXc7UCiFKvVmvd++h7Xrl/j6rVrUZodgJtN17PalKASdOZwwiCsR8eQskRpdDpgOJGkxTAUcaUC2TnRu6+LUglSaoy3ICRKp+gkJUkCV4wXheW5PLP9A8pyw+VywcX5Bfc+vMvl5YLVesM77/6Etm154403SJJgIszzgvF4wl/79V+nrmu+853v0DYteM/JyVOUkmw2G5bLJQ/u38OYwMqb7U0ZjUbcvnWTJ08ece/uh5ycHPPOO+/gXXhwz8/P4s6xiSmPFqnDpeTx42OEkOgkoapbqrql7TqSNKUoBvQuoImkEAyLIt70fdinEiKzBeH9pLZADQFpmpAkadg9Wsfx8SnGWPJUo1QgO1trscYE2bFSpDqIgXA+BguGZ4hAxLBBs0uTdQFIiJQqUMyVpm5aJlNBmmZ4HyI97G7MDnFRFVBSQN3UoXPD77qYi/lF2OU+x+eTU1g2691ya/tQ9zaMfkbDAXILpKsq2qamdGaH5hbxIS6FxMvgjPdShghd70OmSuw4tA6cnrqrAqtHBIOSQIAKxq2tJmBbYMSupXG7h69QYucH8T6YIIV3eGPpmiYs9a3FRBSG8JbV4oLvfedbZIkm1RpkeHUq6UmkIFOa2zeu8dYbb3L1aJ+9yZg80VEgYLHeh1mvC+MyrTRNXfPuO+8ghODg8DAuO4MiqGk61mVFkg8YWIehR1hPkeZheZposnxAmuUUg2Egr1oTvwciiARs8OdIqXA+WEdDYclIUrvD57w4z9+ZzfZ3l4z5xQUP7n7EYrFktd7w7k9+ymg04vXX32CxWLJYLMjznL3ZjF/7tV/j0aNH/It/8S9o2xYp4PT4mC6OaBaLBQ/u32M0GjEej5lOxhwdHnL9xg2yRGON4fTklHfffRfi67UuN4EO0TQ7ie02zOrRoyfoJOHw8ArL1ZrFcsPR1ash82QwpG5bVmWFEiJeMgN+KIiqRBjx4pEiSP2lFGgdUEQ6SRCNxDrH05NTyqricH+PNNGkaRhdO2PI0pREB6c8hBG7t0GNGoqG3Dnzn43W42VWadIsR0pFXTc450nSLEamuwDHlXI3bd/SOCAUlq7vMNbsRmgX8wva7gWE8s/ljAYDRAyPStMwg71oG/q+o603CMD2PV0bpK9FqtFKYEwsRrjdbsOZFoulrTfRO6JJ4nJvNChIs4TL8xOMMQhJVIaoZ5nYPFNleAdO+I8pyIKSKtF6h3rROgn53yrc8rumxvQdjVJUdYW1PTjLYnGJ9AasAyzKW6TwpBKuHOzzxc/9HPt7e+zHgiKcY7VYhE7K2bhfsmw2IaoZD9PplF/5+tcwxnD/3j28Tumt470PP2KxLjm5XJIPp1zLh+iY550XAxxhdyV6C8JQNUEdNBqNIijT4ky4zUmVIFTwFEklSXMd3xyStmtw9vnW3P9lPefzOV3XsX94xM1bt3n1jTd4/bXX6bqOy8vLKCE2YbcZxSqbzYb/+D/+j4OcPg23/aZp+LM/+wbee8bjMUmSMBoNaeqKxfyS0XBAuVlzcnLM8dOnJInmcn5BVZU0ZWDJZWmQ6FZVvfO59Fv4qQ171eW6pCw7yrqnNY6iyEmyAVp7nCt35uY27l6TRIc4jc2GQZEzyDNG4wl5njIeDejamrOzY5wJCZWLxYLNZsP56UlUYnm6xtE1nuFQkmWKKwcHO1OjjbksSZoipKDrbRQHha9TWZaBZBGfG9aG92YgGK9o25auCxTlLAs7oG1Xsh2z980zTMy2sGwhmc/z+cQUFq0lSirSNEVrSaIko+EAa1OyNLS6XopIGbVhdCQ8Xmzlex+L9rUm/Pe4HLTeo6UEpyPJ2EVpbh8UZArwYRm3dcA+87UEUYCMuwTvfeiMIvHUO7fji4koSzN9j+97vPA0TY01hr5raKoSiUN6ED50WUoIpuMRhwf7vHTrFnmakCcJWRJa877rdmwh5xzWWPou0JRDGFnKtWvXOTs75ez8nGSgQlDSas1yXbLeVHTRvKmTBKXDD+E92ODK721E5XhidyKRXgYoKHL3uW9l3lvfUPjvMoI9X5zn7bRdF0OpcrI8KPkOj464Or/K+cVFyBpJkl2GiYjL5Pv375OmKQcHBzs6eFPXOOcY5Hngx2Vp4Hmt1/RdhzU9deVo2/ZZrG/MO3HGIvP0f2A43Mr8IcvyOBqSWNfRtj0g0EnCZDKl7XtaY2nalrbtkF7u/CAAxoU/Z5cvlOUcHh6xXi959OgBUgRMSpKmJFph2iYs/U1LW3na2mOsIM8VeZrsxl5bUY5Kn5m3t/kw22fE1qcSPp/QyTRNw2q1out6jHG7MMCt5yV8sYkGUbfDw2yfOcaanZ/leT2fmMJC1yISTaZSTNtQGcO/8xt/nevXr3J+eoqUgsloyIOHD3j44AEnJ8fBoCRV/CY5amPpOofJG5RPmAyLiG6o6b3F9S1331uFX68CP9S7sLwXWnB0dEiWZXzw0/cxxgQjVJwHX7lyNSTdCZAiFC9n+tje1wgpmExneOepmpqyqqjqir3ZFCkFjx5+hOlaMiVIlURLQdcZisGAv/93/y6H+zMmwwFYC9YyGQ5Jk7Bf2QYWmb6jroNaJNz4LFoIiiwjHw4Zth2bpmdTdfQW6s5ycblkU7f0HoQJozTtJDpN2J/ssd5sWG9KisEwKMtk6EqSNEcJgUJibY+3Fp0mITK2LAPqvGtpoiruxXkeTzCz6iTl9PScH/zwbb708z/PG2++yY/e/jFJkvL5L3yRn/zkJ8wvL9FaM5lM+If/8B+yWCz43d/9XZqmZnF5yX/4H/6HvPHmm3jnOD8/5zvf+x6L+SVNXfLWW5/irU99CiklH7z/Pj/83nf40pe+wJe+9CWUVBFeqijLDQ8fPgoFxsNsNguAy7Yjy3L2D4/4wz/6Y/74j7/Bb/67f4M7r7zKcDSlN4blesO3v/Mdvve977O/v49SikePHpMiuHZ0RJpokkTTNIEM8Nd/4zd4+vgR777zY7IsZTQs+Dt/+7e4eeM69+9+yHq95OT0mKasaaqawTAn0YosCa/xsqzouy7scGVY3OSFQAhFkqRkecH+AbtY46btSZKE6zduMp9f8OFHd7mcV2EPIyUOT9O2ccQuMM7ghAvUaOdou5Ds6nHkgwzxfO/uPzmFRWsVuwoXFRuQJuEGMRoNUFIwHOTsTyf0R4coHE3bkOhktzw+v1hyMV+CNRjjsS4Qe7N0G0sqg5cFUCoSSo2N3+Ag8/PeY6zZ3SSklMhEUhQ5eZZxeXkJCLI+kE1d7Jekl3RtmB/XVUVT19EAGcKxXN+BsyRS4l0IJbt5/TpHh/tMxyMGeUaiQuvkvSfPghSya2qklORZRte04eMi3I6quiZJU/LRMMqGfby1aXTyDE0hpaI3hjQrkCrgWLA2JGj6gCMUEeBpIvVWKhWKjIjzZOsieTlgdLx/RmH1zzkw7y/rufPKq6HD9yYiUjRFMcC6MPrSWu8e7saYXQewv79PmqbcuHGd9WrJ6ckJR0dH3L51KwRbecd4NORgf0bftSzmcz766C5SSJ48eUzXtVzOFzx69ITRcIBWirpuqeua5XIRXk8eZvv75HnBdDojSVMGwzF5nqN0UFzt7+8zme4H8oPz7O/vc+3aNYbDIQDTyYamDTG+UkrSJEHGMLskdhLDwQAhfEyJHLC3t0dz9SrD0QCt5c6rpZMQZqcISrGiKMKbzHuSNAchWW9K2rZnvSl3HcvPPCekJIsx3W3bMZ4M0TolScIU4GNjjd17R0e8ixCQFxl5kQevXlH8hbxm/k3PJ6awjAYD8B5nOpSSZGlKXa5YL3OKLAngQ9NztL/H4WxC//rL4H1YAAqBc/CDH/yQH/7obYxtaXvPunbkecbVK/tYG2THgScm8FLQGUMdpYTWBe6RkgrTm90LZVAMGA4GXL16FaUUb7/9Nn3fUxRFeBEUBdmgQAjF8vKSru9Yb1b0NsQge9MGjyYOoSSJVpSbjqbu+Uf/i1/l02+9jrQW2zWgBMIFzfxoMCBLUh7PL8jzjINrV+najsvlCuc8vTWcnp+R5Tn5aETddlRtS1pMGKQFo8kEpxKsLsiLIVXVMJ7uk2Q5ddvRWkMbk/xUkhCC1qCsaqQUWGfRUpEojYsQyq63YdkZMetKqZg982LH8jyev/Pv/fbOfQ7P0EVuA4jgbblx4wbvvPMOVVXtoJVZljEcDfmVr/0KXdfy8OFDrly5wq1bt5jP5/R9z43r1zjYm/HGq6/xp9/4E05OjsNuou8pNxv+5I//lD/6w29w+/Y1sizl7t0nCOEZj9OdkkpozUsvvcQXXn0dD1wulnHRHaLGh8MRV64csVpvePz0mFs3bzGd7rFYLGiahiLLOT8/58c//jFFmjLICyaTIZPpOFoVOq5fu8J8fs5quQi7niTlzp2Xwsd58zpNXdM2NW29jTe2Owf9eDRiPBoxne0Dknfe/SmPnzzh29/+LsvlkvV6vfOuXL16lSRJAqU4TVBK8tZbrzEej5nPzz+Gb2G3r92y+KSU5Hm6kykfHh7uhA3P6/nEFJauC6wwa/qgP1cpfdfRtg15EtIUjelJVHB/D/NJcNXG2b9Smk+9+Tp7e1OatsNYR90TI0gvqaqatm3obLgtqUzHm3eE6EtJbwxWWLYWfmsNVRXGPkmiSXTCeDwKtzsEidZopRhkOTrRtLJD4GmiWVEJh+k68OEhLYVH4bl57YDJaEqmBW254WCyF7uaoO83XU87m6EIEuu6qnn8+DFdbwJjTAh6Y8iLAR44n19Sty1Ixfl8TtNbiuEQdI6ROdZ5zi/mTGcHJGm2ZUmETktplAqf+w626ePsV8R9U/zRdx126xvY5tREXf6L8/yd/YPDAGO1/c9+n+IlQgjFaDwhy/PdQ84Ywze+8Q2uHB1x+6XbJCphsyr53f/uv+PtH/2IxWIRO485qU5Jk5TPfPotfu4zn0YpycnJMd/4kz/h85/7HD/3c5/FxFiLX/iFr8S/3wapsPNUTcOjR4/48pd/EaU0ZRVo4FmWMZvNmM1mVFVN0zRkWcpyaamqiqLISZOExcUFzhgkntFwwNUrh6xWC85OSv7VH/4Bfd/Sdy1FnpMlB7z/059ycXaCNW2kibu4l3XYvg8qUe9JtGY4GAZTsjVB0iwlbdsGkrl10VgdZMWBrRe6jMlkQnYWupbr169z/fp1mubmznQsZVjab42VxvTx/8mf+XO0fr6nAJ+cwtI2bMNztBKQavq+o29bxKhAeI/tO1KZkaiEyXi0MxhtW9Dx+DVef/21gILoLQbB2dk53/7Od6nrOmDoG4N1ntSmOx7lti21xmABFa8UH88zEfjwd4xGP8NKSrSmyLKwwHNBQJBEyaOVjk29wZqeYjxACRDecOvqIa+9+gqpEtSbDfnhFRTQ1hVtXdPUNV1Tk6iA1267jsVywXA0ZjSeBCm1seSDAXXTcHF5GXZGSnE2n7OpWvZvvILOBVZllFXF+cWcG7dbCmc/VlgEWmmU1LTVhj6+yMOobcstAhOXsFtn8LawRL3ni8LynJ7pbAZR9BG+R+H7ZKJow4uQ4phl2Q713vc93/yzb/DGG2/w+c9/DiU1m3XJ7/7u75IkiuVyQ5pqZrMJ+7MDDvYP+PrXv8aNG9dJEsW7777Dd775Z/zCz3+ev/f3/h4fvP8hZVVz++WXcM6xXK7pekPX9fzXv/M7QXCSJqRpEBikaVBv7u3tMZvNePT4CW282DlnqaqSo6MjpBBx/9kjcIyGBUdHB1ycH3M5v+CjD35KliUcHu4zHBYMB3vc/fADfvqTlrYpQ+DdoIheFw3RMqCkJEszZtMppo8XKesRSsdnSIdzfldYsshhy7JQYCaTCWkWlvnXr1/n9ddfD9HeKjyjpApx58+W9t3PwCnDOPL5nwB8YgqL88GPspXk2eihsM7S98GIlSQJXd8H56zwZHnOeDTZ+Vk2mw2bsiTJ8rAjcILhcMSbb77J5WLJcrUmLQYY5/jB229jon49TYK8uanDjkRJtRvztE1D5zt0ElAWwSQVAoH6PvhqnLUkSULTdXRdy3q1Dp+UgFQpkizllds3mO1NuHP7FpPRiPFwSKq3o6YuGMSkYjIaMR0OdwWtKAqSNIVKRfTGkCfHp6zLEhO0z+hMBLOZUjw5OeXicsXh7TfCm9RA03UgBMZajHFkg2LXsSgdpNiyVcgIzJMymE8BXHwwhR/BtGr6PiBsPraLenGevzOfzwNgtNh2JJquDXu6K1eucHEx53/zv/3fcXR4wK/+1V/j+9//Hov5nESHke/9+/c5OznhpZdv4FxPnmf8nb/1t5juTZnt7ZHnBXmeU5Ub5udnFEXGbG/KP/r3/yG3bt7i0aOHNG0d3qtZEj01hofvvcdPf/o+T54+BiGZTKYcHh1x59XXePDoET98++3I0VJcuXaVs7Mz3vvgfZx3HB4dMBgEoOV4WNCUGUUaLkanTx/T1hVawBuv3sFaw2q94Euf+wy/+ItfYTgsSFPNoMjwztG1DevVivV6ydOnT9isV5ydnNN1LY8ePYxfRRHznSS9CbuTuq5/ZicVws4qlNKs12s2m5qy7BBChbHisNhJjG1Mc+37LubaBxd+URQoJXeZNc/7+cQUll3noBQgsM7Rmz5K9ixCKxItQ/ZJ29J2WXSJB77VVg/fdV3IdpEqhG9JyXg8iXsBxWhvirEWuR0FyWfZEVsIplB618VsI3m33vItAsJGwrAQcucH2MWbRomwVIrhcMCgyLhyeMDR4T53Xn6JJKbWaQFKSJwJPCcdESqJVFHuaBkOh2Hmq5NIFXimOkPIwNrcZqqYntVmw2qzwcfWW+sgM06iZDJ8zioWmqjmiqodKV1o1+MgOLDW3LMxinj2zdp2NNYEMu6L8/wdYy1eCKx1CKmQbBEmjsFgwGKx4Pvf/wG/+vWv8drrr/P06RPwnixNMabnwYMHeGcZDguqyqK15rXXXuVgf5/JdBqLleTuhx9QlTVgUUryyit3SHTCer2i6zqkFPQmxPsaa1gu44O83JDlBVkeAsUGowmj8TiE48W9p070bgwVvDUhXth5TxJ3lqlW4B1924I1SBF2tl3fslpa9md7vP7aa4xGOWmWMBmNsKZns15xcXHOxUVKU5cIPOvlGu8sjbf0naE3ht6EEXHXC4wJhkcf/Szb4hIIyoayqkJYl3VBXZkkaB3glx4gxjkbY7Au7HIVakdFf1FY/ryPSiLaXtOaHtcaHj09ZlNVJEnCsCiYTsY4enrnaHsDsuNysSRNUwajEaPJlCQfUdY1VdOzXJX0xtD0hrozdNazKZuoizcBbul9oCWPx8znC5q6ZToax7jSkOstBLRtE0yPdY13DgVoFRRYwlm8CcoOJQVaCYqiYDAo+MWv/DzXr13h1tUD0kSRKgkmzHav7B+gtebxw0ckWnFlf588y8nSlLPzC7q225mvxuMx8+WSjx49ZL5aYZxj/8p1emvZLC555yc/5d333uPicoXUKW1vyFQY310bjtE6YbI3Jc1ylAwAwKpsQp6KkGR5RpqlWNMHn8+Wx+Zs5C9BonWIsbGWni0NwES2xYvzvJ2jq1fp+p7VaoXuOpTW1GVJWdUMh0Mmkwl1XfOZz3yG3/zN3+TX//qv0zYN77z9I+r4gPzed7/D97/3XZqqwRlL33bUZUnTVHRtG0yATYMxPZv1PIyl8xytQodftw3WOs4vL7DWUTctH3xwl+PjY6qqQicZ4/GENM1YLcKCfTAYcH5xQXbvPsZ56rpmf3/G5eIyLPizNnYcFdI7DvemHM72ODyY0WwuKTctlxenCDzDPOX61UPefO0OP/rRD7i4OKNra/q+p66rnYnRW0uqFa/ceTmotZREqcDf00lO03T8s9//IxarDXVvSfKMXA1RaYpKNLPDA6w1vP/hByxWlySZYDgeMhiPKMt16OxdSKA1pqfrW7yzJEkacp56hXEGZVTw/jznxeUTU1iMC3RRKVzMYRFUdRMcrS7EEruYzSBEMOaBCMqrrseuNyAUXiiaNhBRrQuY7bppMS7E8woVRj6j0YimabAu3N6m0z2y7BRrLLPZDCkFXeQk4d2zoJ6YwxDIy88iRoUQocjg443f413gnM329piMR+AcbbUh0wlplgWdfBcFCbFLInYC0WYc565yFza2NWFZ59FJghXha1fWNZeLBdaHvUnA0giUCCO9vAiRw7DFScR4Z/uxVEwRTWdS4F00gEbJJfgI5AzLxy36aJuw+eI8f6eLO7Et5me7QM6LnE996i3yvGA+n+8Mi2maBl7d0RFtE2S80+mUoihCt2HCCCdAGe2O5B0QKgprVXhtRFx9GKfG8WkbburWGuqmYb3ZRBijxJgeG3lZKpI3siwlSRNW88uQidJ3CAFZltI0NV3TUG029G0d4K3eYvoW4R1KBI5emurgT1GK9WoZ7ACR/2WMwbsApU2TBJWlyCgC2mY4hXRIidIZUiqKwYC67WFTMRqNw6I+Czuha9eusV6vefLkMcYYEq1DBs6gCOzCeDlzkZ1mnWEbI651+JwhmkYjd/B5Pp+YwtL2DiEcVsmgJ1eay+Watu3xQoFUdMYGVlWSoXSG0gkmjoYuF8eMJhNG4wnn8wVV0zAcjemd42KxpCgGFKMxUit0Znnpzh3KsuTycs6Va9e4c+cO5xfnpKnmU59+C4lgcTEny4Lzv6oquq5jeXlJuSk5PT19Ng6KmRTD4TB0M0LiekPjKgbFgNl0xqgoqMsN89Nzbly7xuFsn3sf3aOpa166eYNE6wC+64JgIahdBKnO8ELQGoPSCaPxhMtNCd6Q5Dl9K+ispWwaFusNo+mMbDAIai+tUTJhOBoxGU+o+3Y3thJCIJQMLLOmCQ8eKRgWOd6LHbXAuUBblrGwEOnQPdtx2LMkvBfn+ToXFxe7YvLxJMN8MOAf/fv/Ad///vd4550fU9c1x8fHWGsQAo6OjrDGsFotuHJ0yJXDIx4/DEv0qirxPohXJuMgxzVWxxylJNK/HcUgqJt604WRsQsjWJVomrbl6ckZe7MpeZ6yWi/Ji5ysGJAVKcWw4Oq1q1y7eoW7H91ltd6wWq53yZXvvv02F2cnnD59BM6RaUVXlSxNj+tbUi3Y3xuzN5ty585LSOF5+0c/wJqeVCtknuF9ih/mSBFG3dvYia0/pY27qDDu7XHOhlAzB+fzBTdv3uStt94ij4KDGzeucffuXf70T/8YrTWDwYjZbI+Dg0PG41GYZkRpsYwhfluszDN0fmCxVVW1izN+Xs8nprAg4pwxTXZoe2d6EJqm7ZGy2TlhTd+R5jlJljEYjrB+w3K9YV01yLM51gczZNMarJeMJ3tR3tjGpbUPL/q+p2kalssFJycnrFZr6iq098NBwbXrVxkOgo+li1LDzWrF2dkZ84i2lgJc4PlDRHFneRp2D1GS66yhKkuUlLz66qtoIajKTYDkyQHDYoCKqrTwQpco3eFNMFs6IeicxcWu6L0P7nJ8dsbjiwt0muKVRiUJ0/0ZnYkOXxG4azrLkSIgKrY5NtsXeVEUu+LR9T3ENz8InJQRBBogzB6Pj6TWkFJp4+I+/Hhxnr+jY86Iid+zbf7HbhepFDdv3qRtW37605+GzJVBwTAvPnbDdhEYmSKE5969j9jb2+Po8BDT96zX62A2xtPUQbSSJJqL8zParuP45JSqrgFF1xsuVxWPHz9BqWCKTpKE4WhIGj00t27d5utf/zqT6RTnfQCrIjg9PSXLs9DJJOH37U2nmLahqyv61uNtH3aCzvH0yRkCxeyLUwZFHsQ/WQJoTB8+XiH8bgywRTRtYZZZmuxe48aFX9a0EaHvPEUeilyQBuvdIn48Hu+kxH1vInopdIQfR0VtC4uUzxJsg+Q4I0n0cz8F+MQUFi9CEJVOM5QUuwUyUtE0gShai6Dk6LuW2f4Bg6EkKwaUdctyXdK0IQjo6rWbFMWApjMIqRhN9lit11TVJvg0BBRFEd3xDYvFEikkq9UG04XQnfFowLVrV5lOJkzGE2xcpldlSZZlvP322wjho3QwLuZ8SJnUOqX1DW3Xx9bXUFWG6XjEq3fucHF2xvz8jCzR6DxjEF22rXPhVidDDrezIfjIAVYQ57kJ739wl5+8/wGPz06ZHR5w5/XX0YlmOtvj5GxO0z3LeMjzHCGeLU+RYYSolGSQDnYS4qZtouNeIrzAylDg3I6+GdhP7mPihe0b6MV5Po/WSSwiIZhNiD7ewANYUgjB9evXaduW9957j0996g2E2Gcy7ndx2zZeJvI8Axz37t/nal1x7crRDpZYDHKEgNVqhZSS0WjA2fkZp2enPH7yNIInU9abhnsPz1AalN52UgnD4YgsyyirBbdu3eTGzZuUVUPX9+zv78ebfM1kMo5+Mk2aJCTTCU0pOV8vAyLFCoQE7xzHT+cMByP2phOKPENJyNI0jLjjiC5A0UMhCuM9FynpAp1onIrq1C74W5qmoWs7vPPkRcH+/j5FxPgvFpc45xmNxtR1tVOPhjiC8LUzxu4K2HakLOUz0nHgiT0L7XuezyensPiQ2pjolLquqKsSiUdJyQ9++COSRJNnCXXd0LQtOi1Ybir+4I/+lPV6zen5BTdv3uLmzVuoJKN3AAHIWK1KpErYnx1StzXWWrSKt3MP5XqD7Xq0FOTDHGt6Eq156fZLu5wV6x1SwOH+jMuLc7o2OJWzJA8eG2dpmyq0wXpIqoPxcDIeM5vuMdSgpWAxv0B4x/7elCwJSq1NuUYKQZZktG1H2ZUIJGmakUiJ8Z7WWDZNy2axRGnJaDwkzXPyYsje7JD7T465uFhw9ep1JpO94D3xjslkTNcb+t4EXEbcFUkIca5JgvN+d+vyzn/sgRIeLsKFHBxnLSYWFAhYHCH0x1I5X5zn6XTxds2Whxc717ZtmV9e8ujRY779ne+yP5txeLDPkydPQvdhPaPRkJdu3+TDj+5xfnnJcr2mbRpAsFqXPHz0JIxTESRZeK1rJen6nsWiRCcCncBqtaHrOtrO4rxgsjeMryFDVTes1oFVl6Q5SicsLi+ZX15ycTEPwEmlOTs/5/GTJ1GhFVRlm82G8uwUrImIl/DAdn778GbnoBeCuMfpCZBYs+sOtI7QVR26BCX1Dra6Wa2pqoanx6csVhukEOR5xmQ6wXvHYrFgtVpiTM8777yDc47Pfe6znJwcc3Z2CvioiiP8vcbsIjmkSqIE+VnkcSTt7BAxz/P5xBSWLRnYucDv6o1BxS9yWdUkMQ61qhvqpuVyucZYx4cf3aOqauqm5crVGzEYiIjLD0vovjfkSpNlGdZZjDQo6RFChf/f9XgbCkeiFcIHGXCeZQE0GVtkISBPw85lO65TMQzMEYPIpEQBKIlEkiUJWZqSJwLhLX3XhmV9lpGlKeAp1+uwLMwLnHd0XUueDcKyXSVgLY0JN56maeMbRqN1Gn4kKc5B07YMiiGTyfSZs367aBd+p3QxJrTjKlyX8IJn0uF4g8M/0+jv5MW7kUH4WkgV3xi8KCzP5YnCC++39G0R+XiG87MzTk9POT+/YDgYoJOU1XpD17ZczudMo9Fvtd7Q9ZbehB9101FVDSdtvXPrKx18T8PRgLbpOD1dcOXqPlcm+0xkijGWqunD+HUwoCoryqqm64L50JgggUYIuq5ns9mwWC5p6gahNIvFgvVmw2AwYDAcUNU1ddPQNA2KwNhyMfdoe6QKn2tdN7RdgNQ6v3XZB8DscDjYdQg2jh3SVOz2INaFj229WrNcrsIDX0myLMVaw3q1wvsAkDw7PSPLUw4P959J+33oiKwJY7JAdia8t/yWyO5x8dKG2HqXxXM/CfjEFJZhnmGs4fz8KXmWMZtMsNaQJAk//8UvkWWhjQ1xoTUPHz5gvV5T13X4HskUVAo6pVmXGOsYj3OUlCTSgA+L8UFehCW0d6yWK9q6w2kNGjKt0CjGwxHSw8N7HzEdj5iORqioLxeuZ5hpXn/5pQCbbFpcF5btiU5IoxO/jxjsVAsSBdY0aCkYFSlahzdkuSmDKiwJI4E0T6nqmt4YJnsZeV6A1KyrmsXpOcZ7krTAo3BeMRxN0WnOYrmhqjpML1AqI0sHjEZDlITT06ckaRaCh5zdgfCcJ8zZtUYpTaYzrLAsFougvkkznAm3KCUlMiZlOm9BCZI0QytJuVljzfON+P7LevYmE9q2YT6vkHlKlqSQOcrVmv/sP/t/xoW942tf/6v8B//BP+I73/4ODx884Pd+//fpnODkfEHnBMO9ffJNjaWk7g3OgSVF6QydZTR9h+89GI0ucm6+ccj/t7337LEtO+/8fivseFKdCjcHdjczqUSOhtJwTMuyQMqwZQIDGPAAhgEDA32wAWR7PoFlz8gAx5IpUhY1kkkJFNHNvp1uqHTizmttv3jW3lWXI70w0MDUBesBCh3qVt06p/ZaT/qH7373u/zBf/sHRDYWXTCtR0fSv/vbv+Nv//bv+JN/9yfUTY2NcpSJaduKpnVUVUtdt6w3W/7yr/4D2+2W9W5HNp2SFiUfvXjO5uKCwyxBqZ6irimrgqoqyPMMYw1HJzmN2/G//e//B21X07Y1zrUiTVQ3WCscsyiKRp96G0XMZ4vRXngw/nrx8oyzswvaXtOjmKQJF6en7DcbEeX0njiOKXcFf/nDv+D8YsVqvcO1jjiKaOogIaNlH6vocY2cGdlP9sIlC8x7p93tKOxTi96DD5kbGbN4H0iKVrwUkmA1mqYZl5cruk7kqvEiLinEP8NoNhx+OcYI8dAYI1wMrelcizUReTZBVv0wnUyZTSekcSIzXGvRiJOiqC7LQxFFlsViLkv5Yi9+D6HKMUrhvRAwdRCoiyKLcQ4ztOt+UDiVqr9rnVT9gSAaxTFlVYlsy2Q6apoVZcWmKEYtNNHW1ngP1kSkqVRz681mJDT2BJdMo2m7Fu0dWTal6ySJzOcLslnOfr+nbVussQIfNULssrYVG2V66Dv6XpwnTUDv2cheESdv44bFoIMXuk/vxzMxsMfzPGc2mzKfH/Do8ROiJOVivQbgYLnk4w8/xHlPnGa4Hu7dvUuaZczmc05fnXJ2esrTdz7LdD5jvlwE0rLms1/8MncePBaNvCDfPyzKj08uOLlzibYRXVGO8igmEIDbtsUHPa4+qGk3bct2v8deXOC9x4QuI7yyoBQci9+Q0VIEecdmu6VpKpq2uuoSnKNzAuEfEottGow2VGVNkqTBV8ZitKGsalzf0zQtzve0bU9dN8RxhXPS/bz99ltst1tevvxE3tu2E2uJusa5DhANPvWad9GVzA5AHwiXN71bgTcosbiuwTuH1QpzLVt7LwtsG0XMFwsm0yjY6qas12v++q//mqZpAms/AgzGRIAb2fODFtLwAWICliUpjx48ptjvqIqCx48fc3S4FFmV6Yx7J3fo2pq6rtCBn6K0JcsSHj68T10VvHpZY6wOstsRSkNVlSRJSpZm5HnOdDLB9hbXNtQ7Qc4opciSFBUrLi4uQxfhSdIEpTU/f/8ZZVXz6Onbo1bRi1en/OznP+f0/EI6pcGaFcNkMufk+C4vXrzi9OyCz33xiyRZKm6csZDVNpsdPXDnzj1Wqw0/+9nP+MIXvsTDB4958eIl+/2e+/fuYYJ8v1ZgjYbeQe9om2D9GhA1ip58MpFO6DZuXDSNyIYMRlSDeZSMgSZjYskyAXF88atf5StRxO9++9tS9VjLn/zxH/Mnf/zHXF5uyKdz/uX/8D/y1jvv8Ou/+Zv8z//6X/O//tEf8T/9qz/k137j1zl6+JCu61hdXDCdz8lmM9pCjO7ortQakmzC8cldmtax3u5HGkGSZPQ97PZlABtojo+O8H3PR598zPNPPuH58+cs51OWR4dsX73C0DNNYtJ8wsTMiCKZLGw2La3zou/VCglSEGWWbCqy+6KyYUBrmrbDdTWffPxiJCQ3jSh/zOYHGGspVpfsdhWvTrfM5xmzWUaepxweHvJ7v/df8sEHz/jzH/wZVdXR97Berzg/PyPNUnRY1MOwrH8dSTnohF3/uMnxxiSW0Z/A2lBhibqw945Xr15RVdWIxY9sjPMdqNd5JE0jSYBA0Loe3nuRSXGDLHbMZDLh5OSEcxCxy0C6rOqGsqopayFcKa2ZTiYBBujIJ1OePP0M5+cXoD4YRR1V2Fl434tEi43wvg8z6prYak7u3hUkVtsym8ww2uA8dG3HZrOl6xxd58RideJpmo7We3oljnriX3GAiRORkXA9vVIsj46wScq9skRpTZ7nxHEcZLwTbBQzn88BgnCn4snjJ0wnE+q6Dj4S4kXTdS1NU+NdJ8q4XshkrhPnPe/FknlAt7zmjHcbNya6rkUby/zwcJQncm0bKnrPcnnAb/7mP+Wtd94mzlJM6Obpe9qupdisKXe7sPh2aKN56+23efjoISaSzjWO4xG+7LsOhRAtvXOU+z3Ky/xAD/sdJzJF9+/fHxFVWZbJKKks5ewoxdnZmSgGhDM/XrRK0dQNLuxfPT1129DXHvqgrRdZDg8PBSePI3ExfT/h61//GsfHR3jfjt2QtWJL/uMf/5jT0zOquuP+/WO+/Z3fY7fZsV5v+enf/4zVek0URTx5esJ//jufI01jkiRiPp8xnU6Zz+fcvXuXb33rW7z77vs8e/bhqLfnXEffq7Ccv6aLxBX8H3WVXLTSN34K8Mac+IHIBQREhCQW5zynp69omobpVGCJ8jBLezl6THhP0zRU1dVS8XrSv27MI/4HC/J8wvHxMXVZslmvRg5HXTdUVU1ZSTKIjCafTEnThN1uS5ZPePzkKe+9+3MYBmky1wIIy20T2vWepuvo64Y4yjm+c4eyKCiLksViiTWWtnNst1vOL1YBidUznS8wJuJ8taXpHJ4ebSPSLGe+WKBjkYJwztOjWB4ecnL3nph9KfVaYjFRgrUxaZoDirKqUcrw9MkTtLZjYjHG4Lo2iGvuZDxJj3dtgBrXQVpcuDm9dwFZc7Mlvn9ZwzmHjWNmh8tBsoGmKEZk4MHBAf/8n3+TR0+fEqdp8CqSr+3als35OcV+FwqyDmsTnn7mKcd3716NbSNL17XUlbDaVSgOfddRNg1pFI/EwOGsTiZT8iwfUYppmhJFEZvNJihqS2K5uLjg3oP7xFE06twB1E2N7qVj9r2nbhxd09A2deCGZBws76JUT1UX46j6m9/8Ju989m222/WoJiy238KTWa3WVE3HbLHk29/5DhdnF7x6+Yp333uP9WbD0dEJTx4/5F/8iz8YX9NglLbdboGeb33rW4Di1avn1xLLFeLryuK7R10bgw2qF1prenXzeWFvTGIZVHKHDmR4k0GQIs65caQ1/FIVgsPf7XZcXl7inGO/37NcLkmSlCiSEcB1vsWgMrrf7zHGcHx8hyzLuP/gAYfLBWmcEBkoi4Lv/fs/pS73NFUhznRZym994xscHCw4OjrCo2hc8FwBskxLq53nJGkiWPi+p+8Vh8d3iIzm9GItqsDO0/XgOsdPf/YuZVHStC3z+YKD5YI6SIsrE7FZbfirv/kbyrqlbDrOL1cUVY03CVE2IUszSWo9LOYLkXoJMhJlWZJri00tbetG9FecRMznc6q6oaobhi7Ph6Tetq3sULQIgnrv8J0HRErfe0/XtuR5dtux3NBYHh5Khb/dihsoskscEks+mfC5z3+eNE3pAqkWpTBpSpznnDx6RBZGZqOKtZKdY1uWNIXwNdI0ZTqdYozAdm2a0HeOPqhFKKXxYVpQ1zVZPiHJc9IsI4oi1us1Xdfx8uVLttsNve/5+te/TlVV/OVf/YiLiwu6phHP+6bh0f27ZEnC7qzGd8LLmU5y8uMjokjuhsvLC4w1pGk0Cs3++Mc/4cWLFywWc4HKa8iznCyVsfpqtaaqPFUlhd5w5xwslywvV6xWaz7++CP+3x//NcdHJxwdHZNlKc53bHcbUD2f+cwTfvSjKWVZ8/HHH5PnKQ8fPRBpfuBq9/sP71GGe+qGT8LenMQyLK18P8ACgzYVIenQh6WxGTHefdQzn88AIWc55yjLkoODA3nIdWDYChQDekaL0LYR75E4SdBaicFOIkinSMNut+WTT56z360pdlvatibLMr7w+S8QxTGHh+HRCAirAdaJUnKYtIAIBiBBnKQoepq6DDBQ+bo+eFRUdY018jXaWrqqoWkd2ljaruP5ixdgIpSJaJqWumkFIomMyHwPzjM62rnGhSL1KmEPcht9gE5LVydvzPC+D8gUgaiqK2XnQaiMHlQ/Euj+sQNyG//pIwojqboSzT2CSnBZlvJ5a1nM50Ezzl2Nc5FzEqdiP3G9MBMisCzAhwmACrp0A8JJa0OvenoVOnn60VCr731Y39iAjtQjWXMfTPW8cywPlyIgW1WUZYli0LVrgxr3Fc+jD8TkJE3RAVrvXCfYFjWM0RTr9WaE9Fpr0OYKUDDso9JUCqWiKOgakTWaz+YcLJdstnvKquLlq5fEccJsPqeqSzrfUtcyqp9O8wAO8pxfnDM/nXL3/h2MlcSO0oFj8wsg/ev/8Y/nnRsTb0ximR/MRYtrs8bjcchMV16BJk5ipvPpyKPw3mON5dHTx5yfnfP81XM2+w11VzNfzonTGH8t6w8dUJqLPtBFs4IwG+46YZ8XxR7oOVzMKaqa9W5L13agI0yk0CZmtd4SxQmLgwOUMcwPDqibRix+tUXZiF5p6rbD9YUkmshSVA2xNaSTmUAPfU/VyfiuRYGNSKZTiqajePGKshIPlbv3H6GM4eX5OYuDQxbLOTaKsa4nn8yC+deMfVlRFhWbXYG1DcYqkiRmNpvStB1nZ2fkuZijCeJOUGHGWvI0Yb26pKlrTk5OsFZTNyLuZ7Wip0N1Pa2TObHrupFVXNfNG4Fi+WWMuqpGlv0wQv7hD3/Ie++9JzuTYOwlz4T4+SitoW3HhFRstxRFMZINCYKryWJBFHYkFxeXvHzxgjiVPY1nK5yo8GeVUsRWQDNJEmNVT99UWCVAndXFGXWeUxQ79sWO3X6D60U76/T0JUWxZ7k8IE4TkjKm2O+pi4I4EBs71wqKsm3IJzlpmvDw0UOgpyx2dGEKcnh8xMnxEav1JSqQHeu65VKt8b3iYLnkG7/1ZRbzOX//s3fxTlCqv/Jrv8oXv/Jl/v3/9afUTcN7779HkqUcHh/x/ocr+l4kXlBwdnnKanuJtj1//sM/5+/f/SlvvfMW2orjrQ47W9W/3pUoGRSgEHvy247lU4r5QiS8d/vdVUdC0PIRu6nXRmWD5k4cpWijxx3L8DmlB0jv1W9oUOLtVR8MrUSfTDk1zlylpNFoY0mzjAponIde4/qe07NzOucwkeX84pKyakKHFX7OrkM3DVobnOvxvUJpQxQlaCNdiu8crnOkWuN6QBu884JMcR7vemwUo61lu9+x3RfiiOl6XC/LehBCZFlVlGUlHjNhji26QxYVqiPgNU+ZoStRQyP3CwS6Pige6GF1pK51LsN7GL6XSNbcbJbwL2t0bRsW1CJIqqzlo48+4r333mO5XHJ4eCiXXPiAIHEyiI8GY7vdTs5kHMeCopJZKDYgLkUSqL7aHwTdK63jANNXo7K2Duez6eqAlFKcn5+z7D3L5XLcuZyenbHdbunD8t/3YhmcZRldXYuVdteheo8MxeWcDTF0REkSYQJwIY5FZSKO4wAayKHv8S4Qho3h3r275Hk++hL1WopalAo73w4Txlp9GBkP2nkDGXkyyXn48D5n5xfsduX4Z4bXq3s94H2uYkwmV+ixmxxvTGJ58uQJ6/V6XOBdX8oDY4XchWp5RHfNxRSorusRHQaE/crrsOXr4nuTyVR4LVEkiahtSLNcpCnimGwy5f6DR5yfnXLenQE9jfP8zU9+Qpok/P277/Hi5StevjxlOhEkyjCj3pUVkY1I4xTXg7YR84NDvHfstiuKfUFZFMFi1aBsjGscl+vdiAr77Oc+R5pm/Ief/IQPPvqIxnnqzlE1La73dN7x8vQVjfcsj+8wnc3Jp1NxzlRXTpxN02K0JUuigPgJUhfGkOWp/H1tN8Kwm0Zg37LUHEYdanxthPEayEF0zqPUzVZi/WUNsfSVXZqKIrzW/PAv/5K/+au/4rvf/S5f+tKXiJIEZS1ojStL/HBJRhHJfE7RNHz88cfcvXuXxcEBJs/BGHxZkkQRy+WStmvZ7/eC2Ixj2q4lSoSU66oavMfEsVhMNA3VvhBR1qC6/JOf/IQvfOEL/ME3fguUovOOP/qjP+LF8+dE1tIYy367Ic0yJrMp569eUZYVm9WGSCsWE9mnZnmGTPykQJxOpzx8+IDZdMp0krNeX1IU+yAeKR5MdVVRFuXItn/77bfJsoyyLEMxpdjsduz3e16dvkJrzdPj40DYFsRX09RcXJwTRZbl4QFPP/OY+WLKv/2332O321NVJVUVjeN5rWW/8w8jxG7hxp9qZFkqNr+D+qdW9P0gryB+D8M/5T2XpaAxOvhJx3RB6j3LUvJwaYrgohkdHuEKejxUGk3b0HmHxQKKum3GrqQH2rbD957IWt55550RRND5nqbtRlUA1zk611E1DV0rDnTvvvdzeuDDZx/IXNW1rNdrtpsNX/uNr3FwcMDRnbts1hs+/vgjLi4vubxcEWcTJtMZVS14/F5pyqrGr9bIaDChcnK553lOlmdkWSZLWi2Ok23bslqvuHNyl6OjI56/fEXdNBwfnaCNEeXkIH1PENTsWlnkW2sGUJgQPDWoPsZ1GlX3xNYC/tqe5jZuWuSTHKWgbRt61wpikJ4sT/nVX/0Vnjx9gnctrpNRrkUFCL+jqzuqpqYq9igF/9l/8Tt8+atfwdLTViW9a1keLHjnnbepq5JXL1+w3W5I0lS6aqTTrasS7xxx2LG0TUPfiwX2o0ePqKqKFy9ecHi4xFojQqgovv5Pvs7Ttz7DPzk9pWlb6rahaRvxmGkafNtSXK7RvScxiucvnvPixXPKskBpw5OnT5lNJ0xn+SjZMpvP5e7Q4lWz3e1EvihwyDrXUZQFznvKsiBNMrI0Dd5EYprnnGO73bDbbSmKvRRi3jObzUAx0iIWiwVJElEUBLRqjTHhPjP6Fzgt8Hpi+U/wsPz/jDcmschlLXpggtwKsu39VVsrrWQw3xmQYUphrCZJY0wnI7E0S0izhKoU4mQcx7SttJ+DsKKQ+tQIpXThAVNKSWfkOmwU0aNoOoE2x4nhnc99niSJxXmuldnuMIKqqoquFoauzEsb3n3vffZFSWJFxj5NIi7Oz7m8uOTho6ek+ZTl0TFeaepnzzi7XPHhhx+RzRYsFgdUTSey3UpR1jVl3RJlGZFNqasGY4TslgX4piw2ZR5e1zUXFxfcuXOXw8ND3v/gQzbbLffvPUApRVEUAi4IC1aloQughiiSBax3MkrBKhTil0MQ5BRl51vP+5sa2SSTHUtZjnYHWvVMJjlf+eqXOT4+xnUyCWjbNviuG3wvnf1ut6MqdqB6/vnvfItv/PZvU61WdLUs/w+WC95+5y0+eSGii9vths4LCMAoEV2t6nLUyur9gDYUy97Hjx/RNDU/+MEPODk5DufIo3rF1772NbQxNE0tL0Yrzs7POb+4YJqJVFNxeYnvOvqm4c/+7E/Z7/fUTS2J5clT8jzD+QYXCsjl4YIosqzXK5pOklVsI6yRhNZ2jn1R0HYdRVGgtSXPJ6NGXpIkVFXFZrMREcz9fixWDw4O6LqW1fqSJEmYz+dio2z6wK+TDseYfyyxXP27GtEyNzfemMQykKeG9j2O49cW9cNyXSk9LhKNseR5QpJEpKl0PG0rbflms2Gz3mCjiMX8ALiCWfa9p6oGImXwpc8PhJhEj6qRDsd5ul7cK1XgqcQBIlm3LVXTst7sghucXMA9kOeT8KLg2Qcf8PLVS7LgI77f72TurBQ/f/YR+6rhe9/73viz37//gH/62/8M30Pr+1EqH23EKtXG3L3/gChO+OCT56RZTpLlVFXNZrPj8OiQNBNr2Plszmff+Sx5lrFarTg+OmQxn1M31XjIh/n6IIHRNDXGGpJ0gCx3BJVxQYI5Hxa+Bq3NfzSCvI2bE6uLixG0MoyCJ5MJs9mM/X5PlmVSjCAosKGDd85xenrK97//fZ49eya8lLrGhfEQoUt99OgRi4MDvhQS1wBvj6KIRsuOwjvZsSRxMo6iIShPZKJMsdvt2O124uoIEJbmvfdUZRVQjFKYHSwWzKcTrDHMogjvHL5tSbJMJgVdSxRZ3nrrLY6ODkmSSNTSy0L+bO/Isly6sq4NjpJtkLlvRLE8JJAi2DP3fY8Kys1V+PkH19iBvFkFtGee59R1xW63IYo0k0kmrptNhTEK48yYWP6hTv8/2r3c0HhjEsswArPWjizd4QMIniYFcSRicYN3wQCbzbOMrhXG+GDgVdUVcUgkAw7gujqvwHFlVzNwMQQOKb/dAUzrlcJqWeij9Lg8d97TBLvWnp4seJiM3wvoXEddK/qQNC8vLke2+quzc1rv+cnf/h1N2zKdTrl7/wEHh4es1hvhsQQBvwEKqoxhMp2SZTmT4KqnjcH3DU3Tju8j4TXNplOU0hRFQWTFy6Jqr6xSx9VJgCJ3XQv4MdF451DX8I9DATCQv64rH9zGzYq6vvLlGS71gdMxdDCDdbFSanwmRBW45IMPPmAddMN81+EDGGDYAUwmE+HAhMLvYr0e/U28l92dQJBVUMC+dqZVP8oddcEHfrDC9t7hug6lVSjaAqpTiY1wFEVExqDSlN45+siitKZpG3rk9c4XCw4OlqSpkISTNKEsCrquJUni8Vlvqgp6cX8ty0pADgHE07mO1jnSJCGKY9Iso+06UQgI90QURSit6Lp2hFG3rQ4dTkySxKInaBTT6USAPk5k/VGD79QQ/UiivOnxxiSWuipI44hf+cqXePHiBS9fvhRxOGNIIkNTlfzsp3/HkydPefzkKY8ePiROEj768EOSyPLVr3yZjz76iE8+/pi2Ktlv1rKgjiMmWcpms2W73aCNxdqI+/fv0nWO9XpDURRst9urUYD3tJ3H2BilLT2a6XzOfDplvd3KQW1aUIYky+mcw/sOG6eCia9qVGh7v/Fbv839u3e5uLykrmr2uy3Pnz/nxcsX/NkPfoBWiovNhiiKmdmI1XbL+x9+FJKnQfUeRw9aCWyybZnO5xwdHzNbHmKjmK7ryNKM6WSGNjLKG1BeSoltQNc5jLVYa1keHdMDTdMG+X3L6ekpVVmIN4xWItrne1TgrigFaUDDDAt9OeAW5W922/7LGsOIa7vdhjl/xcXFBVVVjaz3zWZzTc3iipuy3+95/vw56/V6/FpREhfBxygUd3EcY7zHRpZlIM66fjDPqkJh2HN+JgAYfE9vDF4bvvzlL3Ln5Jh/82/+F6DHWCmAdrs9NrJoY4jTZFx4V7WjaVu5qFEQpImSKKKsSk7Pzzg5OuLOvbvkkwm9gpdnp0SRJQmvdzDeI3RBg3Hdf/ff/0uKoqDYlxRVTef70L2kwovTmt///d/n2bNn/Lv/80/QxpDlGZPpFKM1+2I3vjez+RQbPeDV2Skff/wx//f3v8+DB/f59ne+PdoPt10HSgwHdaju+sFozF5x9W5qvDGJJc8yImsZDHRMqKyGqnu4FKeTCVma4pyjDYqkSZyQppqjwyWubYmiiD7AE7VWof3uw/+Hwb502BX0WjZ6A55/sHEVgqUcliiKiJIE53t00O5iRHhoVB9kK7wfwWh9gDamec6kkZ9LKxG8U0Fp2XnH2cUFKEXbdbjRPjiMqBTy91hL3yuUksV9luXYKEVrUW5WOkAYQ38xXP6vzXKvjRb7Xpa68jL0eAEM6DYBgA3IvA5hs/RXVa4XV72hAr6NmxfX0ZPb7Zbz83Pu3LnD4eHh6LE+ICqbpgmmWFeaXsNi+vo+8/o+cYDtynPrZGTmPa6VBb3AePsrfgaEZ9MFSLIJEF1RBC+Lgq4VM66ByNu1QTU8FDVGG3mO6cefSZ51SXaHR4ccn9xBX3smB4VkApFTBYLbQGhWWjOfz0nTFK02tG0rJntRTBzHI/z4+OSEzXZLkiSSfIuCfDLBWCsWFyFZmbAPvnPnLn3f8+zZM4qyCpMMARO1rThWDq9BPuSw2tvE8unFw/sPqJuGy9Ul69Wa8/QMG0XESczjx4+ZTqYslgdMJzMm+YTL1SVt1zGbzkQSP5Kk8+jhI84vLmjblkmeA7BaXZBnOUfLQ7a7LW3Xsd9tAnIF4iQmimLy6RRjrODnw4MPMk+Nk4wsn0qigasRlRamPOGC9SHhDG195+TQZfmEKE5Q2nJ4fEySJMKTqSpOz8+lUisKeqXIptPxwWpdj9aWJM2E4a8009mUxcECJyQYlDY0bUvTtSQ2GWfqAnawxLFooA0HqQ08gPV2S5qmpGmK9zLeOjhYIJWlo6lr6q6lbSqp7BpJulVZkliLj2Mia8Uw7DZuXBRBF2w2m/HTn/6UH/3oR/zu7/7uKIPUNA3L5ZLVasVqteLhw4fkeT4mloGhn2XZuHuIooiyLDk9PWU+n2OMYbvZ0LqOo+NjvPfUbSW0gKYVkIcSd9RhwuOdH8VOt1sZtbVNy6uXL0jSjCgY4OE9u80WbQ1JlmCNFfM9JyO5OIzC6rIijhOODo/54pe+zJMnTzBaLvEkSWjbhrJsMHaQpR+Qoc04mouiiCRJWMwPGAQqB0zKMJqaTCdUdcXR0RFN0/Dhhx8yn8+ZTCZMJpORxzJ4Rv3Kr3yVz3zmM3zve39GUTRYGzGdzmQ8Vu5p24b9fg8wdoHSCd58ZNgbk1i2mzUoxWw25cH9e8L4DtX0bDIhjqNwWTsI0F9pg+3I3fBaE1nLg/v3ABXQIN1IAHSd6BplCuIkEQ/7QuCQjS8xVhbkwyU7m02ZTCdMphMOj44CoUxkV5TW+B4658aH8zrvRmsdxO8MWhm8EomVznsSJcrHwqB39CjxeejE70FpE8QAFdrAdD7js5/7nPy9SnNwcEAUxdT1jh6FMZEoQXeOVjXiVx9IYRqFCpUhAOHS6LoO17Y4a3Guu4J0h3WKkyHw2LkxEEgHMIVztO0tf+Umhzz7nqrqOTk55jd+49fpe8/5+RlJkoTPlVhrWC4PqKqSphHwTFHsuby84MGDBzx69IjJJKcsC6pKOoT5fIYxWv58HGF7S11XIg3k3ZUb67Ud3gCcIbDOo9gSx1F4NuWiT1JBhzZNJT4wSRTIibJc772w943So/xL17UUZcl2t2V5eMiDBw9QRuP7ns45ojgmsxlNU8vOs2nCSMyNI2OjNEoZtDHXEsv15AKRiVFKs93uxgRljGU2m10hVI1iENQd5F3yPMVazXa7DdbQsVgoewEPGa3D645C13cloXNT441JLJv1iizLOFqcYO7f5WA+o+lED8uqgRXsxo8ostjekMRRwKH3GMHAcufuPeIk5tWLl9R1TeecKKG6jmySY0N10jQtdSXL/qZt0UacHPvAHJ5OJ0ynE/LJhMOjQ46OjqjrOhyMqwf3dT2uYbkZoIVa0FMyWFJ0TsZo2lyxoSVBBUWBXrohzyCaaZhOZ8wWBwERp1ksFmFJODg3yqzYO0d7bf+BMcGt5YpVD3LheNfhuhbnLM5JktZKEogPr0X+/qvEAlcACBcSy+0Y7ObGYHHQdS137pzw6NFD3n33Xc7Pz0RWnp6yLMjznPl8xqtXr6jrmtlsRlkWrFaX/Pqv/xrf/OY/I88zQVaFsfB8LhJMTVMTBw+hXbEPz410y9I1BPKfG1QzWrQyaCWCrXESjyCctrviUJWl7ELS0EFVTUnTtLRth7UHmEiPShuubSmrku1ux3K55P6D+4i1cJgWxCmTSc5q1dF3LXVT/0IBKGobowoBAUzUQ++vMsuAANvtdqE4c4FsPRkBQTIlkO5jNp+gtGI6zYkiM5rpxXEcUK0aoy1RZMmzfNRCHEaQNznemMQyJAzd90zSjDxJR5kJ13biD1EUGDTeeWJjUQqqokQHGYgkzdC5oS5Kqv2e3nkiY1nOFvL5JOHi4pJis2PXbwAwGrLZhDiOiZOUHsX55QVd66jrnqqq6bqO6XTK4eGhcD/CbiFJE0BGY33f07RtkPJ2IaEEzLoRNJeNYiaTKT2KbVGwDS1zlKRMpjJTzvIMG0VEcUQPrNcCFpjPZlgbYaylqit8sQ8INo3REGUpZmrDe6bGh7PrOrHYDj+jUmpE1UWxdCg+eKv0fU8XDmvT1Ki+Rw0wYy9ufcO/DwoIw3txGzcvhrHWsDMEODw8JM9z1us13vvxmd5sNq9dkjrsHe7evcvTp0+x1lJVlRRWwGq1knFumrLd7ujDfs5YgzZR6NR1SG6eqijDXqdi8BzxvaCm/vAP/9WIpJTk5Vit1zRtS7zdYq2RfY4RiZbV6gJ6OFke4UuBRg9nVMAKO6qyIIqsjK+qhu12O3YCSZqO+8YRgaUVru/xXXtNXeJKFmrYKznnyPNcHFgv1yPsePgzbetQypAkls16R1WV/MF/811sZLhz5yTss2omYQoz8PKSRJTYe0Drm4+yfGMSi77+EfxUhmVXaxtMrWnqRqqLXrSslFJ0fSfWxKGiVqhgECYL+oEsmMQJaSLEKsIFqrRcspE1JKGK8H14nEJVLnBJRvmXNE3Hg2dtND6Yw5JfEdp9hstWoJVKa7SBKE7Gy7ntWqq6lgV8kFQxUYS2V/89bDxVWDJqY2jLkrYNAINrC784itDGymgtQIC7rpP3JrT3Q1zBGnvxWnltnCfVovw+1PheDgkUpJIT2PFtx3JTY1imwxVAY0A+in8I45K+rusgfW+uPd+WJEnCRdqNqLFhlDp0xp0T/om4i17p0MlRG/YF0rkMoBLwuE664S988Qtj0rn+8zRtC1rhvRiQGUDAYNXIhvd9P3JjrpuOORdIv4giRl0LUEVpsOGZvQ6vHjTyRhdu+QTjPxTj+7JYLFitNux3eyFc96CVpg8SSDrojDVNS9c53nr7LbRS2EhG9p3rRmCADjIvMoIPoKI3IN6YxCJMVVkGD5e1d04e0MAEn04ydPChFj8FTRqLJ3xdV+y2e/b7PZ///OeZTCY8e/YMEHnwsthRFnvxUjlcstttadqGfVlQVaUQM5MElCzhldZEiQjVJUkyer7cuXNnRI9Np9LpyGETpJTIzzs00CFcgrqqsXGOtTFJmjFUQuv1iqqqAodEIMXaWOJUcPNaKZaHBzRNw9n5qVSBxtLULVprnjz5DN73rNdrrLGoqA9jBU0bupKBxBVFEVUrXYyMCLqxmnXOITRQiOOIroMApKPv/cgNMiFhDbskHwQG9U23u/sljUEXL8/zcaE8n89ZLpccHx9TFAWffPLJSEgeOtBpAI/sdju22y2bzWYcic5mM7quY7PZ0AVOR5JnAU3Z0rQeF1BfIMlNyI0arSKMFtJkH0a3vuuEzwEjykwHwUgbWR4+fkjnPKvVJdv1lrIsmeZToiji9OwMelgcHJBNJpg4omxqdsWeg8WMput4/vIFeZ4xm8/ZFzu867CJ6Au6pqEL0k4gySGJEynsjMF5MdITGZo++DY94jv/1X/N97//5/zFX/w/oipeNWSZgGvqtsNVQhruXIc2lpOTIxRQNxUyKIQkS7GRmOzROZquE4BMSC6/IKp/4+KNSSwDfHWAJAK0TS0mU87hfah2jBKfB4F2hEWcVFGRNUK4agW5FEfC3veuI44T4jjBhI5nQKuYADVGqQAV7gNZC3yviKygavKAjBkuVGvNWOGDdEoDCQwY/30YBcSxjM3qZoAyXwnNtW037nhG0pUSf7nBr9zaCqNFkblVAskUyZse17ng/Gik41JXXRswVp+6a+XB9ld7oSGGDmY42CZ0QyYsIr33mNAdDfPhcTR20yEsv6TRtu1YWAww8WFkM0wE0jQdn8Ohyy2KgqqqXutOhk5jeBaUUoGt3gYosHQOvpfEcsWjEpdGAhx+2Nf1vUZd75Kdo6rrgNCMgorFlXrwMIIb7bZtRF3W4c5QzGYzHj58RBTFYdJwxWAfuhil1Gv+MgJpvkZIVKKirEIn9JoHTdiLplnGyckJeZ4j+yBBcg1SUQO5su8DcEfrseMxxhJFMWmaiV240SLiCmgjygd9KyKzNzyvvDmJpS4rdKh+B4H27XpDWZZUQY9LYI8pSSKDpr7vefnyJYMV79HRMYfLIz786EPOT2sePnwojOCLC5aLJffu3ef5808oij3ONajeEwdJcW3EYbHtOspiT+cczvWkScyTRw9H+YqLi4vA/8jGll3h0arHc2WiJc9XHw6lYz6f07Yd682poFpMPB7yzXZP3VQkSTy+FvH/9qNtK0BkY6yNOD8/H79v17Ui0dJ7qa7aFt+L7L4IUsoYIUkSkV/pO1zT4XpHAE4j6C/zmppBkiRE1hLbSA5m3WCUdCzWBlJkz9jx3MbNi/1+P3YZAxdlSBQgF+qjR4/YbrejpErTNJydnXF2djZ2tFVVjQvrQbIlyzK22y3b7RZlFGmWjox0ghqGHS3C1TjikURjQOlxPFeWMjE4e/WKxcEBi+UBSSpdxenLVyLTVJUcLJecnJwwySeoXvHx7mNh93vP48dPmM8XRLGRs9t5dGyDUnHBer3i6HhJEidsNpuRg/W66sZV0TVwvfp+SJA6FHxT7t9/yHy+QGvDbDZnPj/g9PSUQdbJWgHZGCP3WFGUGKNJ04Q8n5Ak6YiGszaWz2UJZVkKSTMoBNzkeGMSiwmCVAPyxDvHfrejDixyrbQ4LHpPU1e0Adnhgw+Jd566qtntdqRxQhxJ5TPAZJu6Dr72YoDVFQI5bNsG5x3aOJQ2wiBeLvFeROnk/hQC136/Ey0tY/A+wTlZYEdGh+pIBXFGTRQIkAM2PUniK0SV97SuA60wUcRsPsOWFqXENdOHh77ve7a7LUopkiwhiaTr2u/31HVNsRMUThwJssQaQ9s0AjumQSmDMWJ/PCzcu7ZDWUndQki9IkIK/NQHCGdHZOzYwWgjUG7rZQzomhbXXs3db+PmxXw+x1rLarUa9wMDqGMgtg5L/a7rmEwmY0fy8OFDvvOd7/D5z39eEE6zWejUZbTVNA1xHMtZ6T11XYdOV7SwricWHci/vZfCJ9RcryljR1HEYrHAGCPGYkYu/el0SuccGEmKq9WK7XoraMdwxmQ0bsiyjJ4wPrdi6bDZbQP60bHd7jBG0wVpmyRJMOFndEGbrGulSJL3SBCdw2uua1EyKPYlxliWB4dAGHfXNUKQjLHWhi6xuRoZD6oE4WwNTppt2468s/V6zXq9Zrfb0d4mlk8nrBFGbRnEGNsg3SByJTlGa6wJmkehPZbEInP+3nvqqkIh4nZxHBMHkTqtFHVdsdmsiRO5nItyKyqubY12Bm0cSZphI8t0vqDvoW5atLEoLQ9eERKLtL4ueKd0GB1hhoWl0mJvbO2VrlGYYXcuwH29GIKhFDayY0XZNJXAmP3gMufZ7jbEccx0JooDaZKRpkn4efYy6ggaYNYayj6M31qPUp7eEwyKrrShrJGDEtkI52WuOwAVhgWic47k2sxba00UXACttTQo+tAh3XYsNzNmsxnOOdbrNXEcj6PcrutkNKqvugax5U3HXcuDBw+4d+/e+PwOYpXNiBpsyPOcPM/Z7rdUbTUmJhNdJRUA+p626+jaVjr8AJAZfobhfBwcHFBUJWVVobTGRpajoyOcd3h69vu9cEHqFq00D+49IIlj0kRIvrPZjLopca4L3VfNdrcTEIqC3XYLCin6whRgGBP3vZjoXbdhtlZoBQOIaEgg+32BNRHL5aHcE0GmRUaFehzXFcVV4aUU185gizSN/aiM0LYtq9Wa09NTSSztbWL51MJ7P/6CrLUcHBwwsGeH8dhwMK4WfSL1MkAAB10jpdRYZV3/ukH3KkkSlFbSOSAQ3bZtaTtH78D5nrKpWSyWzKYLyrKkc07UAOI47F1S4sgQWcHC+15IkdYaoli4MmmSYK3l7PSM1jniOApiklcuck+fPuXi4oJnz37O5eUF77//PoeHhyE5xqPMzH6/p9iXoCBJIjbFbjwYTd1Ql/Lge+9J82ng2ohVgIztKpqmwcZTjJUFaVVXdF07jkIGAdCu68SCuG64uLigaRpmkwmRldevYJzT38KNb2Zc30sMI60Bdj8UZrvdjiiKODk5Gb9m+PNlWbLZbGgaUf0dRkbDbqZtW87PzzGRdD6DREznu9GldOgKEiPPjbWW3vkRGdkHVNfgHOnCfqOqa8qy5P333xcxV++I45jFYkEfCrTOddTbmpcvXjKfz2Xc3NU4xziyPT4+oa1rmrrGWICeYrenrptRWQCueCtD9yPq6uC9/Hx939M28jMnScJyueTBgwc8e/8D1qs19+7fRWvNdrsfUWYghaN2Ojjayj3Tj93aVbJpmmZUUxYW/80+U29UYhkWakN7OlxaSZwymHONtqnhQo2iZJRj8F4WjsMDPiy+r3//wUJUhwfIGEPv5ZftvFggd11HF/4+kJFRbQw6ECeHKs5aEyx8A8SSK6OecdQQ2v2qrnBeCI9KS0YZIMyirCr8mLqu2W63zOdzkXcIcERBc12xlgc75iFETTYgbfphtKivYJmhC3FevDGGRb18rb9axIYKtus6WmNptBHRvKYhiWIUaqz2rn+P27h58YsL96HLGNSOR9BLKJaGomQkxUKYHBQAI7x8eLaHHWNmM7TS4/M1jHGG8xBFEamJxu/rlcN3V+d9GNPJ95Xv3YdqXuwtAK2IQqFFhHAuG0fbSFGUZdm4MwFGknOaJuA9ruuwVo1duewnubZPkWSVxum4K1HhNQ2fb9uBtKxHGPawe7p77w5A4Hd1owK4VnrABr0Wox5ff1X0DsnehhH6TQ5106UBbuM2buM2buPNitty8jZu4zZu4zY+1bhNLLdxG7dxG7fxqcZtYrmN27iN27iNTzVuE8tt3MZt3MZtfKpxm1hu4zZu4zZu41ON28RyG7dxG7dxG59q/H+j0iDWsgsg3QAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -644,7 +645,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a387616480d14c769f727ba946861c51", + "model_id": "52b8115cf41e4fa0b1177a60e4c2ec4c", "version_major": 2, "version_minor": 0 }, @@ -686,7 +687,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -710,7 +711,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "F1 score of model with corrupted data: 0.8220443349753696\n" + "F1 score of model with corrupted data: 0.8112659060991664\n" ] } ], @@ -735,7 +736,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "902091c124ef41f9b9ff9e9b3256bf42", + "model_id": "cb4c9bf44ef84b26bf38bdfddc725e37", "version_major": 2, "version_minor": 0 }, @@ -749,7 +750,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "36b99ba5c5af4183bd07e071f9f6bdf7", + "model_id": "26ea34222a6d453dbeb9ae94aa0923de", "version_major": 2, "version_minor": 0 }, @@ -763,7 +764,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f3547a44a6f9415880e68060b4b6ea78", + "model_id": "d3941d119c1b456c8857207d8615a4d4", "version_major": 2, "version_minor": 0 }, @@ -776,9 +777,9 @@ } ], "source": [ + "differentiable_model = TwiceDifferentiable(mgr.model, mgr.loss)\n", "corrupted_influences = compute_influences(\n", - " model=mgr.model,\n", - " loss=mgr.loss,\n", + " differentiable_model=differentiable_model,\n", " x=corrupted_train_x,\n", " y=corrupted_train_y,\n", " x_test=test_x,\n", @@ -813,7 +814,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -846,7 +847,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -899,16 +900,16 @@ " \n", " 0\n", " tables\n", - " -0.192024\n", - " -3.603061\n", - " 3.411037\n", + " -0.156153\n", + " -3.846006\n", + " 3.689852\n", " \n", " \n", " 1\n", " boats\n", - " 0.024808\n", - " -3.628917\n", - " 3.653726\n", + " -0.030673\n", + " -3.689159\n", + " 3.658486\n", " \n", " \n", "\n", @@ -916,8 +917,8 @@ ], "text/plain": [ " label avg_non_corrupted_infl avg_corrupted_infl score_diff\n", - "0 tables -0.192024 -3.603061 3.411037\n", - "1 boats 0.024808 -3.628917 3.653726" + "0 tables -0.156153 -3.846006 3.689852\n", + "1 boats -0.030673 -3.689159 3.658486" ] }, "execution_count": 24, diff --git a/notebooks/influence_synthetic.ipynb b/notebooks/influence_synthetic.ipynb index 27b706934..0e28ab25f 100644 --- a/notebooks/influence_synthetic.ipynb +++ b/notebooks/influence_synthetic.ipynb @@ -74,20 +74,19 @@ "\n", "import numpy as np\n", "import torch\n", - "from torch import nn\n", "import torch.nn.functional as F\n", "import matplotlib.pyplot as plt\n", - "from pydvl.influence.general import compute_influences\n", + "from pydvl.influence import compute_influences, TwiceDifferentiable\n", "from pydvl.utils.dataset import (\n", " synthetic_classification_dataset,\n", " decision_boundary_fixed_variance_2d,\n", ")\n", - "from notebook_support import (\n", + "from support.common import (\n", " plot_gaussian_blobs,\n", " plot_losses,\n", " plot_influences,\n", ")\n", - "from notebook_support_torch import (\n", + "from support.torch import (\n", " fit_torch_model,\n", " TorchLogisticRegression,\n", ")\n", @@ -270,7 +269,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Model fitting: 100%|██████████| 50/50 [00:02<00:00, 17.88it/s]\n" + "Model fitting: 100%|██████████| 50/50 [00:03<00:00, 15.66it/s]\n" ] } ], @@ -316,7 +315,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -348,7 +347,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 12, @@ -357,7 +356,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -438,8 +437,7 @@ "outputs": [], "source": [ "influence_values = compute_influences(\n", - " model=model,\n", - " loss=F.binary_cross_entropy,\n", + " differentiable_model=TwiceDifferentiable(model, F.binary_cross_entropy),\n", " x=x,\n", " y=y.astype(float),\n", " x_test=test_data[0],\n", @@ -498,7 +496,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -549,8 +547,7 @@ "y_corrupted[:10] = [1 - yi for yi in y[:10]]\n", "\n", "influence_values = compute_influences(\n", - " model=model,\n", - " loss=F.binary_cross_entropy,\n", + " differentiable_model=TwiceDifferentiable(model, F.binary_cross_entropy),\n", " x=x,\n", " y=y_corrupted.astype(float),\n", " x_test=test_data[0],\n", @@ -572,8 +569,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average mislabelled data influence: -0.7081194523556167\n", - "Average correct data influence: 0.007535246334452065\n" + "Average mislabelled data influence: -0.7069138219997766\n", + "Average correct data influence: 0.007597316767707558\n" ] } ], @@ -600,7 +597,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -661,15 +658,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average mislabelled data influence: -0.7081188846494786\n", - "Average correct data influence: 0.007535246880673285\n" + "Average mislabelled data influence: -0.7069132495095636\n", + "Average correct data influence: 0.007597317307720237\n" ] } ], "source": [ "influence_values = compute_influences(\n", - " model=model,\n", - " loss=F.binary_cross_entropy,\n", + " differentiable_model=TwiceDifferentiable(model, F.binary_cross_entropy),\n", " x=x,\n", " y=y_corrupted.astype(float),\n", " x_test=test_data[0],\n", @@ -699,7 +695,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index 2d3b78a75..e4af2ba4d 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -55,9 +55,9 @@ "import numpy as np\n", "import torch\n", "import torch.nn.functional as F\n", - "from notebook_support import plot_losses\n", - "from notebook_support_torch import TorchMLP, fit_torch_model\n", - "from pydvl.influence.general import compute_influences\n", + "from support.common import plot_losses\n", + "from support.torch import TorchMLP, fit_torch_model\n", + "from pydvl.influence import compute_influences, TwiceDifferentiable\n", "from pydvl.utils.dataset import load_wine_dataset\n", "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, f1_score\n", "from torch.optim import Adam, lr_scheduler" @@ -169,7 +169,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a8dc091ba62e4372a55305c460060480", + "model_id": "b22f84de78d44e4e8f7b8011f7132983", "version_major": 2, "version_minor": 0 }, @@ -228,7 +228,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7MAAAHmCAYAAAChwtkCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAABSuklEQVR4nO3deXhcZ3n+8fuZRRoto12WbEu2vMWOs5HYCVnJAiFOGnYKJBQCpYFC05ZSChQoW8uP0tLSUtawhx3CHsIaEpJANockJoudeIltOd5kS7J2aWbe3x9nJI12yZ6ZM8v3c11znf2cx/bx2Lfe97zHnHMCAAAAACCfBPwuAAAAAACAhSLMAgAAAADyDmEWAAAAAJB3CLMAAAAAgLxDmAUAAAAA5B3CLAAAAAAg74T8LuBENDQ0uLa2Nr/LAAAAAABkwIMPPtjhnGucblteh9m2tjZt3rzZ7zIAAAAAABlgZrtn2kY3YwAAAABA3iHMAgAAAADyDmEWAAAAAJB3CLMAAAAAgLyT1wNAAQAAAEA+GBkZUXt7uwYHB/0uJedEIhG1tLQoHA4v6DjCLAAAAABkWHt7u6LRqNra2mRmfpeTM5xzOnLkiNrb27VixYoFHUs3YwAAAADIsMHBQdXX1xNkJzEz1dfXH1eLNWEWAAAAALKAIDu94/19IcwCAAAAAPIOYRYAAAAAcMKuvPJKffWrX83a9RgACgAAAACKVGVl5dh8f3+/SktLFQwGJUmf+9zn9OpXv3re5/r5z3+e9vpmQ5gFAAAAgCLV29s7Nt/W1qYvfOELet7znjdlv1gsplAot+Ij3YwBAAAAABPccccdamlp0Uc/+lE1Nzfr9a9/vTo7O3X11VersbFRtbW1uvrqq9Xe3j52zCWXXKIvfOELkqSvfOUruvDCC/X2t79dtbW1WrFiRdpbbrMSZs3sS2Z2yMwenWH7OjO7x8yGzOzt2agJAAAAADCzAwcO6OjRo9q9e7duvPFGJRIJvf71r9fu3bu1Z88elZWV6YYbbpjx+Pvuu09r165VR0eH3vGOd+gNb3iDnHNpqy9b7cRfkfRJSTfNsP2opL+T9OIs1QMAAAAAvvjgTx/T488cy+g11i+p0vtfcMoJnSMQCOiDH/ygSktLJUllZWV62cteNrb9Pe95jy699NIZj1++fLmuv/56SdJ1112nt7zlLTp48KCam5tPqK6x+tJyljk45+6UF1hn2n7IOfeApJFs1AMAAAAAmF1jY6MikcjYcn9/v970pjdp+fLlqqqq0nOe8xx1dXUpHo9Pe3xqaC0vL5c08RndE5VbT/AWmO7+Ecmk6rKw36UAAAAAyBEn2mKaLWY2Yfm//uu/tG3bNt13331qbm7Www8/rDPPPDOtXYcXIu8GgDKzN5rZZjPbfPjwYb/LmVH3wIgu/I/f6nO/2+F3KQAAAABwwnp6elRWVqaamhodPXpUH/zgB32tJ+/CrHPuRufcRufcxsbGRr/LmVF1WVgXrWnQ1+7ZrWOD9J4GAAAAkN/e+ta3amBgQA0NDTr33HO1adMmX+uxbDUJm1mbpFucc6fOss8HJPU65z42n3Nu3LjRbd68OT0FZsCj+7p19f/drXduWqc3X7LK73IAAAAA+OSJJ57QySef7HcZOWum3x8ze9A5t3G6Y7L1ap5vSbpH0lozazezN5jZX5vZXye3N5tZu6S3SXpvcp+qbNSWSacurdZFaxr0xbt3aXBk+oeiAQAAAAALl5UBoJxz18yx/YCklmzUkm1vvmSVrv38ffreg+16zbnL/S4HAAAAAApC3j0zm2/OW1mvZ7XW6MY7dygWT/hdDgAAAAAUBMJshpmZ3nLJKu09OqDP3bnT73IAAAAAoCAQZrPg8vVN+rPTF+u/f/2kNj991O9yAAAAACDvEWazwMz0kZeepqU1Zfq7bz2krv5hv0sCAAAAgLxGmM2SqkhYn7z2TB3uHdLbv/eIEonsvBIJAAAAAAoRYTaLTm+p0buvOlm/eeKQPvHbp/wuBwAAAADyFmE2y153fptedlaL/uc3T+kXjx7wuxwAAAAAOC5mpu3bt/t2fcJslpmZPvySU3VGa43e9t2HtfXAMb9LAgAAAFCkNm3apPe9731T1v/4xz9Wc3OzYrGYD1XND2HWB5FwUDe+ZoMqS0P66689qGODI36XBAAAAKAIXXfddfr6178u5yaO6fO1r31Nr371qxUKhXyqbG6EWZ80VUX0qVefpb2dA3rH97ZMuXkAAAAAINNe/OIX68iRI7rrrrvG1nV2duqWW27RC1/4Qp133nmqqanR4sWLdcMNN2h4OHfezEKY9dHZbXV656a1+sVjB/Sl3z/tdzkAAAAAikxZWZle8YpX6Kabbhpb993vflfr1q1TZWWlPv7xj6ujo0P33HOPbrvtNn3605/2sdqJcrfNuEhcf9FKbX66Ux+59QltWF6rZ7XW+F0SAAAAgEz6+bukA3/K7DWaT5Ou/Pd57Xrdddfp6quv1ic/+UlFIhHddNNNuu6667Rhw4axfdra2vSmN71Jv/vd7/TWt741Q0UvDC2zPjMz/eefn6FF0VL90/ce0VAs7ndJAAAAAIrIhRdeqIaGBv3oRz/Sjh07dP/99+vaa6/Vk08+qauvvlrNzc2qqqrSu9/9bnV0dPhd7hhaZnNAdVlYH37JaXr9Vx7Qp2/foX+4/CS/SwIAAACQKfNsMc2m1772tbrpppu0bds2XXHFFWpqatK1116rM888U9/61rcUjUb1P//zP7r55pv9LnUMLbM54tJ1i/SiZy3Rp+/YricP9vhdDgAAAIAi8trXvla/+c1v9PnPf17XXXedJKmnp0dVVVWqrKzU1q1b9ZnPfMbnKicizOaQ9129XpWlIb3j5i2KJxjdGAAAAEB2tLW16fzzz1dfX59e+MIXSpI+9rGP6Zvf/Kai0aiuv/56vfKVr/S5yonoZpxD6itL9S9Xr9fbvvuIbtnyjF70rKV+lwQAAACgSNxxxx0Tlp/znOdo69atE9Z96EMfGpv3+/WitMzmmBc/a6nWNUf1v795SrF4wu9yAAAAACAnEWZzTCBg+ofLT9LOjj798KF9fpcDAAAAADmJMJuDnr++Sactrdb/3vaUhmO0zgIAAADAZITZTNrxW+nozgUfZmb6x+efpPbOAX3vwb0ZKAwAAAAA8hthNlP6j0rfeY30q385rsMvPqlRG5bX6tO371CCkY0BAACAvOf3gEm56nh/XwizmVJeJ134VmnrLdKuuxZ8uJnp9Re0aV/XgO7a3pH++gAAAABkTTAY1MjIiN9l5KSRkRGFQgt/0Q5hNpPOu0GqbpV++W4pEV/w4c9f36z6ihJ96749GSgOAAAAQLbU1NTo4MGDSiQYEydVIpHQwYMHVV1dveBjec9sJoXLpOd9QPr+G6RHviWd+RcLOrwkFNDLN7Toi3fv0qFjg1pUFclMnQAAAAAyqqGhQe3t7dq2bZvfpeSciooKNTQ0LPg4wmymnfoy6d7PSLd9SFr/Iqk0uqDDX3l2qz53505978F2/c2lqzNUJAAAAIBMCgQCWrZsmd9lFBS6GWeambTp36XeQ9LP37ngw1c2VurclXX69gN7GAgKAAAAAJIIs9nQerb0nLdLD39D2vK9BR9+zTnLtPfogP6w40gGigMAAACA/EOYzZaL3yW1nivd8g/SkR0LOvSKU5pVFQnphw/ty1BxAAAAAJBfCLPZEgxJL/uCFAhKN/+lNDI470Mj4aAuXbdIt287pDhdjQEAAACAMJtVNa3Siz8j7X9Y+tnbpAW8HPh5JzfpaN+wHtrTmbn6AAAAACBPEGazbd1V0sXv9J6fvf/z8z7s4rWNCgVMv3niUAaLAwAAAID8QJj1w8Xvkk66UvrlP0tP/35eh1RFwnr2yjr95omDGS4OAAAAAHIfYdYPgYD00s9JtW3e87N9HfM67HknN2n7oV493dGX2foAAAAAIMcRZv0SqZZe/mVp4Kj0o7fM6/nZ553cJEm0zgIAAAAoeoRZPy0+Xbr8X6Wnfindf+Ocu7fWlWttU1S38dwsAAAAgCJHmPXbs98krblC+tV7pYOPzbn7c09epPufPqru/pEsFAcAAAAAuYkw6zcz6cWflkoqpVvfMWd348vWLVI84XTPzvk9ZwsAAAAAhYgwmwsqGqTL3iPtvlt64iez7npaS7VKQgFtfpr3zQIAAAAoXoTZXHHW66RFp3jdjUcGZ9ytNBTUGS3V2rybMAsAAACgeBFmc0UwJG36iNS1R7r3U7PuumF5nR57pluDI/EsFQcAAAAAuYUwm0tWXiytu1q687+kviMz7rZxea1G4k6P7O3KXm0AAAAAkEMIs7nmsvdKI33SQzfNuMtZy2slia7GAAAAAIoWYTbXLDpZartIeuCLUmL6bsR1FSVa2VihBwmzAAAAAIoUYTYXnfNGqXuv9OQvZtxl4/JaPbi7U4nE7K/yAQAAAIBCRJjNRWuvkqqWSvffOOMuG5fXqXtgRDs7erNYGAAAAADkBsJsLgqGpI1/Ke28Qzq8bdpdNrQln5vlfbMAAAAAihBhNleddZ0ULJHu//y0m1c2VKiuooRBoAAAAAAUJcJsrqpslE5+ofTozdMOBGVmOmtZLYNAAQAAAChKhNlctu7PpIFOae/9024+c1mNdnX06djgSJYLAwAAAAB/EWZz2ernSoHQjKMar2uOSpKePNCTzaoAAAAAwHeE2VwWqZaWnz9jmF2bDLNbCbMAAAAAigxhNteddKV0eKt0dNeUTUtryhQtDWnrgWM+FAYAAAAA/iHM5rq1m7zpNK2zZqa1zVFto2UWAAAAQJEhzOa6upVSw0kzPze7OKqtB3rknMtyYQAAAADgH8JsPjhpk/T076XBqd2J1zZXqWcwpme6B30oDAAAAAD8QZjNB2uvlBIj0o7bpmw6eXQQqP08NwsAAACgeBBm80HLOVJptbTzjimbTmJEYwAAAABFiDCbD4IhaemZ0r4/TtlUFQlraU0ZYRYAAABAUSHM5oulG6SDj0kjA1M2nbw4qm28ngcAAABAESHM5oulGyQXl/ZvmbJpbXNUOw73aSgW96EwAAAAAMg+wmy+WLrBm+57cMqmdc1Viiecdhzqy3JRAAAAAOAPwmy+iDZLVUtnCLOjg0DR1RgAAABAcSDM5pOlZ00bZlc0VKgkGNA2BoECAAAAUCQIs/lk6Qapc5fUf3TC6lAwoFWLKrXtIGEWAAAAQHEgzOaTsedmp76iZ2VDhZ7u4JlZAAAAAMWBMJtPFj9Lkk3b1bitoVx7Owc0Ek9kvSwAAAAAyDbCbD6JVEmNa6cPs/UViiec2junvocWAAAAAAoNYTbfLN3ghVnnJqxe0VAhSXQ1BgAAAFAUCLP5ZulZUn+H1LVnwurRMLuLMAsAAACgCBBm883iZ3nTg49OWF1XUaJoJKSnjxBmAQAAABQ+wmy+qV/tTY9sn7DazLSioYKWWQAAAABFgTCbb8pqpIpGqeOpKZva6gmzAAAAAIoDYTYf1a+Z0jIrSW0NFXqma0BDsbgPRQEAAABA9hBm81H9qmnD7IqGciWctPdovw9FAQAAAED2EGbzUcMaqe+wNNA1YXVb/eiIxoRZAAAAAIWNMJuP6td400mts7xrFgAAAECxIMzmoxlGNK4pL1FteVi7eD0PAAAAgAJHmM1HtW2SBacf0bihgpZZAAAAAAWPMJuPQiVeoD0yNcyuqCfMAgAAACh8hNl8Vb9a6pjh9Tzdgxoc4fU8AAAAAAoXYTZfNayRju6QEokJq9uSg0DtPsKIxgAAAAAKF2E2X9WvlmKD0rH2CatXjL2ep9ePqgAAAAAgKwiz+Wp0RONJg0AtbyiXJO05SsssAAAAgMJFmM1XDaPvmt0xYXVVJKzqsrD2Hh3woSgAAAAAyI6shFkz+5KZHTKzR2fYbmb2CTPbbmZbzOysbNSV1yqbpJLotCMat9aVaW8nLbMAAAAACle2Wma/ImnTLNuvlLQm+XmjpM9koab8ZiY1rJ72XbOtteXaSzdjAAAAAAUsK2HWOXenpKOz7PIiSTc5z72SasxscTZqy2v1q6d0M5ak1rpytXcOyDnnQ1EAAAAAkHm58szsUkl7U5bbk+umMLM3mtlmM9t8+PDhrBSXs+pWSt17pdjwhNWttWUaiiV0uGfIp8IAAAAAILNyJczOm3PuRufcRufcxsbGRr/L8Vd1iyQn9eyfsLqlzhvRmOdmAQAAABSqXAmz+yS1piy3JNdhNlXJxutjE3+rWmuTYZYRjQEAAAAUqFwJsz+R9NrkqMbnSup2zu2f66CiV93iTbvbJ6xuqS2TJAaBAgAAAFCwQtm4iJl9S9IlkhrMrF3S+yWFJck591lJt0q6StJ2Sf2SXp+NuvLeaMvspDAbCQe1KFpKN2MAAAAABSsrYdY5d80c252kv8lGLQWltFKK1EzpZix5IxrTzRgAAABAocqVbsY4XtUtU1pmJW9E4z10MwYAAABQoAiz+a5qqdQ9fcvs/u4BjcQTPhQFAAAAAJlFmM131S3SselaZsuVcNL+rkEfigIAAACAzCLM5rvqpdJApzTcN2F1S11yRGMGgQIAAABQgAiz+a5q9PU8M71rljALAAAAoPAQZvPd6LtmJ3U1XlwdUTBgtMwCAAAAKEiE2XxXPfqu2Ykts6FgQEtqIryeBwAAAEBBIszmu+gSSTbD63nKaZkFAAAAUJAIs/kuVCJVNs04ojEtswAAAAAKEWG2EFTP9K7ZMnX0DmlgOO5DUQAAAACQOYTZQlC1dPpuxnXeiMbtdDUGAAAAUGAIs4WgulU6tk9ybsLqltHX8xBmAQAAABQYwmwhqF4qjfRLA50TVrfWlUkSz80CAAAAKDiE2UJQNfp6noldjRsrSxUJB7T3KC2zAAAAAAoLYbYQVLd402MTB4EyM7Xweh4AAAAABYgwWwhGw+y075oto5sxAAAAgIJDmC0EFYukQHhKy6zkjWhMyywAAACAQkOYLQSBgFS1eIaW2XL1DMbU3T/iQ2EAAAAAkBmE2UIRXSL1HJiyemxEY1pnAQAAABQQwmyhiDZNG2bH3jXLiMYAAAAACghhtlBUNku9B6esbq1LhllaZgEAAAAUEMJsoYg2S0PHpOG+Caury8KqioQY0RgAAABAQSHMFoposzed9rlZRjQGAAAAUFgIs4WissmbTtfVuLacZ2YBAAAAFBTCbKGYtWW2TO2dA3LOZbkoAAAAAMgMwmyhqEyG2RkGgRqKJXS4ZyjLRQEAAABAZhBmC0V5nRQIT98yW8uIxgAAAAAKC2G2UJh5z81O2zJbJkmMaAwAAACgYBBmC0m0edqW2ZbRllkGgQIAAABQIAizhWSGMBsJB9UYLaWbMQAAAICCQZgtJJVNUu/UMCtJrbVldDMGAAAAUDAIs4Uk2iwNdEqxqaMWL6sr1x66GQMAAAAoEITZQlLZ5E2nGQRqeX2Fnuke0FAsnuWiAAAAACD9CLOFJJp812zP1DDb1lAu5xjRGAAAAEBhIMwWktEwO81zs8vrKyRJu4/0ZbMiAAAAAMgIwmwhqRxtmZ0aZtuSYfbpIzw3CwAAACD/EWYLSUWDZIFpw2xteVjRSIiWWQAAAAAFgTBbSAJBqWLRtN2MzUxt9RW0zAIAAAAoCITZQhNtmnYAKElaXl9OyywAAACAgkCYLTSVzdO2zErec7PtnQMaiSeyXBQAAAAApBdhttDM0TIbTzjt6+T1PAAAAADyG2G20EQXS32HpXhsyqa2htERjelqDAAAACC/EWYLTWWTJCf1HZqyaXl9uSRpN4NAAQAAAMhzhNlCE535XbONlaUqLwnSMgsAAAAg7xFmC01lMsz2Tn1u1sy0vL6CllkAAAAAeY8wW2iiTd50mpZZSWqrL6dlFgAAAEDeI8wWmopF3nSalllJWl5fob1H+xVPuCwWBQAAAADpRZgtNKESqbx+1pbZkbjTM128ngcAAABA/iLMFqLo4hnD7PJ67/U8PDcLAAAAIJ8RZgtRZZPUO0PLbIP3eh6emwUAAACQzwizhSjaLPVM/8xsUzSiSDignYcJswAAAADyF2G2EFU2SX2HpERiyqZAwLSqsVJPHerxoTAAAAAASA/CbCGKNkuJmNR/ZNrNJzVF9dTB3iwXBQAAAADpQ5gtRJXJd83O8NzsmqZKHTg2qO6BkSwWBQAAAADpQ5gtRNHF3nSG52bXNkUlSdvpagwAAAAgTxFmC1E02TLbs3/azSclw+yTdDUGAAAAkKcIs4WostmbztDNeGlNmcrCQW07QMssAAAAgPxEmC1E4YgUqZ6xm3EgYFrTxIjGAAAAAPIXYbZQVTbP2DIrSWsWRelmDAAAACBvEWYLVbRpxpZZSTqpqVKHe4bU1T+cxaIAAAAAID0Is4VqjpZZBoECAAAAkM8Is4Uq2uy1zDo37eY1TZWSpCcP8twsAAAAgPxDmC1U0WYpPiQNdE67eWlNmSpKgnqKMAsAAAAgDxFmC1Vl8l2zvdM/N2tmWt3EIFAAAAAA8hNhtlBFk++a7Zn5udm1vJ4HAAAAQJ4izBaqymSYnaFlVvIGgeroHdaR3qEsFQUAAAAA6UGYLVTRZDfjWVpmR0c03sZzswAAAADyDGG2UJVGpXDFrC2zpy6tliT9qb07W1UBAAAAQFoQZgtZtFnq2T/j5rqKErXUlmkLYRYAAABAniHMFrLRd83O4vSWaj3S3pWdegAAAAAgTQizhayySeqd+ZlZSTq9pUbtnQMMAgUAAAAgrxBmC9k8W2Ylacs+uhoDAAAAyB+E2UJW2SSN9ElDM49WfNrSaplJW/YSZgEAAADkD8JsIYsm3zU7S+tsNBLWyoYKbeG5WQAAAAB5hDBbyEbD7BzPzZ7RUqNH2rvlnMtCUQAAAABw4gizhaxytGV2rkGgqtXRO6T93YNZKAoAAAAAThxhtpBFm7zpXGG2tUaS6GoMAAAAIG8QZgtZpEYKls7ZzXj94iqFAqYt7QwCBQAAACA/EGYLmZnXOjvH63ki4aDWNkcJswAAAADyBmG20FU2z9kyK0mnt9TokfYuJRIMAgUAAAAg9xFmC908WmYlaePyWvUMxrTt4MzvpAUAAACAXEGYLXTRxXMOACVJz15ZJ0m6b+eRTFcEAAAAACeMMFvoKpukoW5pZGDW3Vpqy7W0pkz3P300S4UBAAAAwPEjzBa66PzeNStJz15Rp/t3HZVzPDcLAAAAILcRZgtdZTLM9s793Ow5K+rU0TusHYf7MlwUAAAAAJyYrIVZM9tkZtvMbLuZvWua7cvN7DYz22Jmd5hZS7ZqK2jRJm86r+dm6yVJ9+3iuVkAAAAAuS0rYdbMgpI+JelKSeslXWNm6yft9jFJNznnTpf0IUkfyUZtBW8BLbNt9eVqjJbq/l08NwsAAAAgt2WrZfYcSdudczudc8OSvi3pRZP2WS/pt8n526fZjuNRXi8FQvNqmTUzPXtFne7byXOzAAAAAHJbtsLsUkl7U5bbk+tSPSLppcn5l0iKmln95BOZ2RvNbLOZbT58+HBGii0ogYA3ovE8wqzkDQJ14Nig9h6dffRjAAAAAPBTLg0A9XZJF5vZQ5IulrRPUnzyTs65G51zG51zGxsbG7NdY36qbJJ65xlmk8/N3stzswAAAABy2LzDrJldamYrkvOLzeyrZvZlM2uex+H7JLWmLLck141xzj3jnHupc+5MSe9Jruuab32YRbRZ6pn7mVlJWt1YqdrysO7byXOzAAAAAHLXQlpmP63xltL/khSWlJB04zyOfUDSGjNbYWYlkl4l6SepO5hZg5mN1vPPkr60gNowmwW0zAYCpvNW1ev32zt4bhYAAABAzlpImF3qnNtjZiFJV0h6o6Q3Szp/rgOdczFJN0j6paQnJH3XOfeYmX3IzF6Y3O0SSdvM7ElJTZI+vIDaMJtos9R/RIoNz2v3i9Y06sCxQe043JvhwgAAAADg+IQWsO8xM2uSdKqkx51zvclW1vB8DnbO3Srp1knr3pcyf7OkmxdQD+arMvmu2b5DUvXcr++9cHWDJOnOJzu0elE0k5UBAAAAwHFZSMvs/8nrLvwNee+MlaQLJG1Nd1FIs+hibzrP52Zb68q1oqFCd2/vyGBRAAAAAHD85t0y65z7qJn9UFLcObcjuXqfpL/KSGVIn2iyZbZn/7wPuXB1g77/x3YNxxIqCeXSoNcAAAAAsMBX8zjnnhwNsmZ2qaTFzrk/ZaQypE9lcsDpeQ4CJUkXrWlQ/3Bcf9zTmaGiAAAAAOD4LeTVPL8zswuS8++U9G1J3zSzd2eqOKRJRaMkm3c3Y0k6d1W9ggHT3U/R1RgAAABA7llIy+ypku5Nzl8v6VJJ50r663QXhTQLhrxAu4CW2apIWGe21uiupw5nsDAAAAAAOD4LCbMBSc7MVkky59zjzrm9kmozUxrSKtq0oJZZSbpwTYO27OtWV//8XukDAAAAANmykDB7t6RPSvqYpB9KUjLY0g81H0QXL2gAKMl736xzYlRjAAAAADlnIWH2dZK6JG2R9IHkunWS/jetFSEzqpZIx/Yt6JAzWqpVXRbWHdvoagwAAAAgtyzk1TxHJL170rqfpb0iZEZ1q9R/RBruk0oq5nVIKBjQxSc16o5th5RIOAUCluEiAQAAAGB+FjKacdjMPmhmO81sMDn9oJmVZLJApEnNMm/avbDW2cvWLVJH77D+tK87A0UBAAAAwPFZSDfj/5D0PHmjF5+RnF4m6aMZqAvpVt3iTbv3LOiwi09qVMCk27YeykBRAAAAAHB8FhJm/1zSC51zv3LObXPO/UrSSyS9IjOlIa2qW71pd/uCDqutKNGZy2p1O2EWAAAAQA5ZSJid6YFJHqTMB9HFkgWlrr0LPvSydYv0p33dOnRsMAOFAQAAAMDCLSTMfk/ST83sCjM72cw2SfqRpO9mpDKkVzDkjWi8wJZZSbp07SJJYlRjAAAAADljIWH2HZJ+I+lTkh6U9H+Sbpc0nIG6kAnVLVL3wltmT14c1eLqiH5LV2MAAAAAOWLeYdY5N+yce59zbrVzrtw5t0bShyX9Y+bKQ1pVtx5XmDUzXbpuke7e3qHhWCIDhQEAAADAwiykZXY6Tjwzmz9qWqVjz0iJ+IIPvWztIvUOxfTA00czUBgAAAAALMyJhlnJC7TIB9UtUiIm9RxY8KHnr65XSShAV2MAAAAAOSE01w5mdtksm0vSWAsyrXqZN+3eK1UvXdCh5SUhnbeyXrdvPaR/uXp9BooDAAAAgPmbM8xK+uIc2/ekoxBkQXWLNz2OEY0l7xU97//JY9rV0acVDRVpLAwAAAAAFmbObsbOuRVzfbJRKNJgNMx2Hd/PHy5b572ih67GAAAAAPyWjmdmkS9KK6Wy2uNumW2tK9fqRZW6nTALAAAAwGeE2WJznK/nGXXZukW6b9cR9Q7F0lgUAAAAACwMYbbYVLced8us5IXZkbjT3U91pLEoAAAAAFgYwmyxqWmVuvZK7vjeqLRhea2ikRBdjQEAAAD4ijBbbKpbpeEeabD7uA4PBwO6+KRG3bb1kBIJXjEMAAAAwB+E2WIz9nqe439u9vL1TeroHdLD7V3pqQkAAAAAFogwW2xqWr3pCTw3e8naRQoFTL9+/GCaigIAAACAhSHMFpvqZJjtOv6W2eqysJ69sk6/euxAmooCAAAAgIUhzBabikYpFJG6dp/QaS4/uUk7Dvdp5+HeNBUGAAAAAPNHmC02ZlLtCunozhM6zeWnNEsSXY0BAAAA+IIwW4zqV0lHdpzQKZbWlOmUJVWEWQAAAAC+IMwWo/pVUucuKRE/odNcvr5JD+7pVEfvUJoKAwAAAID5IcwWo7pVUnz4hEY0lrww65x02xO0zgIAAADILsJsMapf5U2PbD+h06xfXKWlNWV0NQYAAACQdYTZYlS/2pue4CBQZqbL1zfprqc61D8cS0NhAAAAADA/hNliVNkklVSe8CBQkvT89U0aiiV011MdaSgMAAAAAOaHMFuMzKS6FdLREw+zZ6+oU1UkpF89RldjAAAAANlDmC1WdatO+JlZSQoHA7ps3SL9dutBxeKJNBQGAAAAAHMjzBar+tVS524pPnLCp7p8fbM6+0f04O7ONBQGAAAAAHMjzBar+lWSi0tde074VBevbVRJMMCoxgAAAACyhjBbrOrS83oeSaosDen81fX61eMH5Zw74fMBAAAAwFwIs8Vq7F2zJz4IlCRdvr5Je472a9vBnrScDwAAAABmQ5gtVuX1UqQ6LSMaS16YNZN+8eiBtJwPAAAAAGZDmC1WZskRjdMTZhdFIzq7rU63/ml/Ws4HAAAAALMhzBaz+vSFWUm66tRmPXmwV9sP0dUYAAAAQGYRZotZ3Sqpe680MpiW0206dbEk6dY/0dUYAAAAQGYRZotZ/SpJTup8Oi2na66OaOPyWroaAwAAAMg4wmwxa1jjTQ9vTdsprzxtsbYe6NHOw71pOycAAAAATEaYLWaN6yQLSIceT9sprzy1WZL0c0Y1BgAAAJBBhNliFi6T6ldLBx9L2ymX1JTpzGU1+tkWuhoDAAAAyBzCbLFrOkU6+GhaT/lnpy3W4/uPaQddjQEAAABkCGG22DWd4g0ANZS+1+m84IwlMpN+/PAzaTsnAAAAAKQizBa7plO96aEn0nfKqojOX1WvHz+8T865tJ0XAAAAAEYRZovdovXeNM1djV90xlLtPtKvR9q703peAAAAAJAIs6hZJpVEpYPpG9FYkjad1qySUEA/emhfWs8LAAAAABJhFmbJQaDSN6KxJFVFwrps7SLdsuUZxeKJtJ4bAAAAAAizGA+zaX6+9cVnLlFH77D+sONIWs8LAAAAAIRZeGF2qFvqbk/raS9Zu0jRSIiuxgAAAADSjjCL8RGN09zVOBIO6urTl+jWR/fr2OBIWs8NAAAAoLgRZiEtOtmbpnlEY0l61dmtGhxJ6KeP8M5ZAAAAAOlDmIUUqfJGNU5zy6wknd5SrXXNUX3ngb1pPzcAAACA4kWYhafp1IyEWTPTKza2akt7tx5/5ljazw8AAACgOBFm4Wk6VTrylDTcl/ZTv+TMpSoJBvTdzbTOAgAAAEgPwiw8SzdILiHtfyTtp66tKNHzT2nSDx/ap8GReNrPDwAAAKD4EGbhWbrBm7ZvzsjpX3l2q7oHRvTLxw5k5PwAAAAAigthFp7KRm8QqH2ZCbMXrGpQW325vvKHpzNyfgAAAADFhTCLcUs3Svv+mJFTBwKm685v00N7uvTw3q6MXAMAAABA8SDMYtzSDVL3XqnnYEZO//INLaosDekrv9+VkfMDAAAAKB6EWYxr2ehN9z2YkdNHI2H9+cYW/exP+3Xo2GBGrgEAAACgOBBmMa75dMmCGXtuVpKuO69NsYTT1+/bk7FrAAAAACh8hFmMKymXmk7JWMusJLU1VOiytYv0zft285oeAAAAAMeNMIuJlm7wBoFKJDJ2iTdctEIdvcP63oPtGbsGAAAAgMJGmMVELRuloWPSke0Zu8R5K+t11rIaffaOHRqOZS40AwAAAChchFlMtHSDN83gc7Nmpr997hrt6xrQjx7al7HrAAAAAChchFlM1HCSVBKV2jMXZiXpkpMaddrSan3qju2KxWmdBQAAALAwhFlMFAhKLRukvfdl9DJmphsuW63dR/p1y5b9Gb0WAAAAgMJDmMVUyy+QDj4mDXRm9DKXn9yktU1RfeK3T9E6CwAAAGBBCLOYavn5kpy0J7Ots4GA6R+ff5J2Hu7Ttx/Ym9FrAQAAACgshFlMtXSDFAhLu3+f8Utdvr5J57TV6X9+86R6h2IZvx4AAACAwkCYxVThMi/Q7v5Dxi9lZvrnq9apo3dYN965M+PXAwAAAFAYCLOY3vLzpf0PS0O9Gb/Umctq9WenL9bn79ypg8cGM349AAAAAPmPMIvpLb9ASsSk9geycrl3XrFOsURCH/3F1qxcDwAAAEB+I8xieq3nSBbISldjSVpWX643PmelfvDHfbpnx5GsXBMAAABA/iLMYnqRKqn59KyFWUn628vWaFldud7zwz9pKBbP2nUBAAAA5J+shVkz22Rm28xsu5m9a5rty8zsdjN7yMy2mNlV2aoNM1h+gbRvsxQbysrlIuGg/vXFp2pnR58+eweDQQEAAACYWVbCrJkFJX1K0pWS1ku6xszWT9rtvZK+65w7U9KrJH06G7VhFsvPl2KD0jMPZe2SF5/UqKtPX6xP3b5d2w9lfvApAAAAAPkpWy2z50ja7pzb6ZwblvRtSS+atI+TVJWcr5b0TJZqw0yWnedNd92V1cu+7wXrVVEa1Fu/85CGY4msXhsAAABAfshWmF0qaW/KcntyXaoPSPoLM2uXdKukv53uRGb2RjPbbGabDx8+nIlaMaqiXmo6Tdr1u6xedlE0oo+89HQ9uu+Y/ve2J7N6bQAAAAD5IZcGgLpG0leccy2SrpL0NTObUp9z7kbn3Ebn3MbGxsasF1l0Vl4s7b1PGhnI6mU3ndqsV25s1afv2KH7dx3N6rUBAAAA5L5shdl9klpTlluS61K9QdJ3Jck5d4+kiKSGrFSHma24WIoPS3vuzfql3/eC9VpWV65/+M7D6uwbzvr1AQAAAOSubIXZByStMbMVZlYib4Cnn0zaZ4+k50qSmZ0sL8zSj9hvy8+XAqGsdzWWpIrSkD7xqjN1uHdIf/fthxRPuKzXAAAAACA3ZSXMOudikm6Q9EtJT8gbtfgxM/uQmb0wuds/SrrezB6R9C1Jr3POkV78VlopLd0o7cx+mJWkM1pr9G8vOlV3PdWh//zlNl9qAAAAAJB7Qtm6kHPuVnkDO6Wue1/K/OOSLshWPViAlRdLd/6nNNAlldVk/fKvOLtVW/Z16bO/26FTl1bp6tOXZL0GAAAAALkllwaAQq5acbHkEtLTd/tWwvuuPkUbl9fqbd99RA88zYBQAAAAQLEjzGJuLWdL4XJfnpsdVRIK6POv3aiW2jL91Vc366mDPb7VAgAAAMB/hFnMLVQiLTvPt+dmR9VWlOirrz9HJaGArvvS/drfnd3XBQEAAADIHYRZzM/Ki6WObdKx/b6W0VpXrq+8/mwdG4zpmhvv1YHuQV/rAQAAAOAPwizmZ+Wl3nTnHb6WIUmnLKnWTW84Rx29w3rVjfcQaAEAAIAiRJjF/DSdKlU0Sjt+63clkqSzltVOCLR7j/b7XRIAAACALCLMYn4CAa91duftUiLhdzWSxgPt0b5hvfQzf9DjzxzzuyQAAAAAWUKYxfytukzqOywdfNTvSsactaxWN7/5fIUCpld+7h79YXuH3yUBAAAAyALCLOZvVfK52RzpajzqpKaofvCW87W4JqLXful+3XTP03LO+V0WAAAAgAwizGL+os3es7M7bvO7kikWV5fp5jefr4tPatT7fvyY3vX9P2koFve7LAAAAAAZQpjFwqy6VNpzrzTc53clU1RFwvr8azfqhktX6zub9+rln7lHT3fkXp0AAAAAThxhFguz6jIpPizt/oPflUwrEDC9/Yq1+txrNmjP0X792Sfu0g8fave7LAAAAABpRpjFwiw7TwpFcu652cmuOKVZP//7i3TKkmr9w3ce0Vu+8aAO9wz5XRYAAACANCHMYmHCZdLy86Xtuffc7GRLasr0rTeeq3duWqffPHFIz//47/Sjh/YxOBQAAABQAAizWLjVz5M6tklde/yuZE7BgOnNl6zSrX93odoaKvTW7zysaz5/r7Yd6PG7NAAAAAAngDCLhVvzfG/61K/9rWMBVi+K6ua/Pl8ffsmp2nqgR1d94i594CeP6UgvXY8BAACAfESYxcLVr5ZqludVmJW8VtpXP3u5bv/HS/Sqs1v1tXt36+L/vEOfuO0p9Q7F/C4PAAAAwAIQZrFwZl7r7K7fSbH8a9msrSjRh19ymn751ufogtX1+u9fP6nzP3Kb/utX22ipBQAAAPIEYRbHZ83l0ki/tPv3fldy3FYvqtTnXrNRP/6bC3T+qgZ98vbtuuCjv9X7f/yo9h7t97s8AAAAALMI+V0A8lTbRVKwVHrqN967Z/PYGa01+uxrNmj7oV7deOcOffP+Pfr6fXt01WmL9aqzW3XeynoFAuZ3mQAAAABSWD6/pmTjxo1u8+bNfpdRvL72Um9E478trD+D/d0D+uJdu/TdzXt1bDCm1royvWJDq16+sUWLq8v8Lg8AAAAoGmb2oHNu47TbCLM4bvd+RvrFu6S/e1iqW+F3NWk3OBLXLx87oO88sFd/2HFEAZMuWtOoq09frMvXN6mmvMTvEgEAAICCRphFZhzZIf3fWdJVH5POud7vajJqz5F+fe/BvfrBH/dpX9eAggHTeSvrtenUZj3/lCYtikb8LhEAAAAoOIRZZM4nzpJq26TX/MDvSrLCOac/7evWzx89oF88ekC7OvpkJp3eUqOLVjfogtUNOmt5jUpDQb9LBQAAAPIeYRaZ86v3Svd+VnrHTilS5Xc1WeWc01OHevWLRw/ozicP66G9XYonnCLhgM5ZUa/zV9Vrw/Janba0WpEw4RYAAABYKMIsMmf3PdKXN0kv/7J06kv9rsZXPYMjum/nUd29vUO/396hpw71SpJCAdP6JVU6s7VGZy2v1SlLqrWioUJBRkgGAAAAZkWYReYk4tLHTpJWXSq97At+V5NTOnqH9NCeLj20p1N/3NOpLe3d6h+OS5JKQwGtbY7q5OYqrVsc1drmqFY2VKqpqlRmhFwAAABAmj3M8p5ZnJhAUDppk7T1p1J8RAqG/a4oZzRUlury9U26fH2TJCkWT+jJg716fP8xPbH/mLYeOKZfP3FQ39m8d+yY8pKg2uortKKxQisbKrS0pkxLasq0pCaixdVlqijlrywAAAAgEWaRDuuukh7+urT799LKS/yuJmeFggGtX1Kl9UvGny12zulwz5C2HezR0x192tnRp10dfXp0X7d+8egBxRMTe05Ul4W1uDqiJTVlWlwdUWO0VPUVJaqrKFVtRVj1FaWqqyhRbXlYoWAg279EAAAAIGsIszhxKy+VQmXS1lsJswtkZlpUFdGiqoguWtM4YdtIPKED3YPa3z2o/d0DeqZrUM90DYzNP7SnU539IzOeu7osrJrysCpKQqqMhBQt9aaVpePLZSUhRcIBlYaCKg0FvE84ZT4UVGnYmw8HAwqYKWBSMGAKBExBM29+bCq6SQMAACArCLM4cSXl3jOz226VrvyoRJhJi3AwoNa6crXWlc+4z0g8oc7+YXX2jehI35CO9g2rs29YR/qGdbRvWMcGRtQ7FFPPYEwHjg2q93BMvYMx9QzFNBxLZKRuMylo42F3NOBacpuZyUwKTF6XnB9fb8lt06xLzgdMMtmEcwQCU9eNniMctPHgPkNoH91emRL+oxHvU1kaVmUkpIqSIKEdAADAZ4RZpMfaq7wwe2CLtPgMv6spGuFgQIuiES2KRiRFF3TsUCyugeG4hmMJDcUSGorFNTgyPj8US2hoJDk/ktBIIqGEkxIJp3jCKeG8ady55Dop4aaud05KOMnJm3fOyUnJ9ePzzrnp18mbeucY32/0fAk3fg1p6jkSyUHuEs5pJO7UNTCioZGJv+6h5K97OD6/gG8mL+SWhhSNeC3g9ZUlqi0vUX1FiWorSlSX8lkUjai+okQBRrAGAABIG8Is0mPtVZIFpcd+RJjNE14LJO+/TZVIOA3HExociatvOO61Yg+OqGco2aI9GFPv0Ih6B2M6NhhT71BMxwZG1NU/om0HetTZP6LO/mFNN0h8MGBaFC3VoqqImqKlaqqKaFFyuqSmTC21ZVpcE+HPBAAAYJ4Is0iPinpp5cXSYz+Qnvs+uhojLwUCpkggqEg4qJqZe3fPKp5w6h4Y0dG+IR3tG9GR3iEd7h3SwWODOnjMm+4+0q/7nz6qrknPPJtJi6KlaqktV0ttWfLjzY+ObB0JE3YBAAAkwizS6ZSXSj+5QXrmIWnpWX5XA/giGLCx7sVzGRyJ69CxIT3TPaD2zgG1d/aPTR/c3albtuyfMqL1kuqI2hoqtCL5GX2VU2ttuUpCjGANAACKB2EW6XPy1dIt/+C1zhJmgTlFwkEtqy/Xsvrpm4Fj8YQO9gyp/agXcvd29mv3kX7t6ujTLVv2q3tgvGU3GDC11JZ54XY06DZ47yteUlOmIM/rAgCAAkOYRfqU1XqjGj/2I+nyf6WrMXCCQsGAltZ4XYyfPc32zr5h7TrSp12H+/T0Ee89xU939Gnz00fVNxwf268kGNDy+nKtbKzQysZKrWio0KrGCq1sqFTtPFqQAQAAchFhFul1ykulp/5aan9Aaj3H72qAglabHDn5rGW1E9Y753S4Z0i7OpIh97AXdLcf6tVvtx7SSHy863JteXgs4K5MBtxVjRVaVl/OYFQAACCnEWaRXuuukoIl0qM/IMwCPjEzLaqKaFFVRM9eWT9hWyye0N7OAe3q6NXOw33acbhPOw/36s4nD+vmB9vH9guY1FJbPhZwvanXsttUVcp7dgEAgO8Is0ivSLW0+nLpsR9KV3xYCtCyA+SSUDAw9kztZesmbusZHNGujmRL7uFe7UzO37fzqAZGxrstV5QEtSIZckdbdFclW3crSvlnBQAAZAf/60D6nf7n0rafSTtvl1Y/z+9qAMxTNBLW6S01Or2lZsL6RMLpwLHBZNDt9VpzO/r0xz2d+umWZya8V7epqnSsJXdFQ4VaasvVWlem1rpyVUXC2f0FAQCAgkaYRfqtvcobDOqhbxBmgQIQCJiWJN9ze8HqhgnbBkfi2n2kf0JL7s6O3imjLUtSdVnYC7a15WqtK1drbZla6srVmnyXLu/QBQAAC0GYRfqFSqXTXiE9+BWp/6hUXud3RQAyJBIOam1zVGuboxPWO+fUPTCivUe9VwrtPdqfnA5o24Ee3fbEIQ3HExOOqS0Pq7m6TIurI2qujmhJdWTC8uLqiMpL+GcLAAB4+F8BMuPMV0v3f0569PvSOdf7XQ2ALDMz1ZSXqKa8RKe1VE/Znkg4HeoZGgu6z3QNaH/3oA50D2p/96Ae3tulo33DU46rLgtrUbRUDZWlakxOG6IlaqwsVUO0VI3J9XUVJQoHA9n4pQIAAJ8QZpEZi8+Qmk6THvo6YRbAFIGAqTnZ4np22/S9NwZH4jp4bFDPdA3qwDEv7O7vGtThniF19A5pS3uXDvcMTXinbqq6ihLVlodVUz4+rSkLq7aiRDXlYdWUpawvD6u2vERlJXR1BgAgXxBmkTlnvlr6xbukg49JTaf4XQ2APBMJB7W8vkLL6ytm3a9/OKaOnmEd7vVC7mjY7egdUmffiLoGhvVM16Aef+aYugZG1D9D+JWk0lBA1WVhRSMhVUbCqoqEVFka8pZLvfXjn/DYtmgkpPKSkCpKQiorCaokRKswAACZRphF5pz2CulX/+K1zm76iN/VAChQ5SUhLasPaVl9+bz2HxyJq3tgRF39I+rsH1ZX/7A6+73lrv5hdfWPqHcopp6hmHoGR7S/e1C9g978TK3Ak4UCprKSoCpKQiovCaqsJKjykqDKJy2Pht/ykqDKwkGVhoMqDQVUGgoqEvampeGAIslpaSigSHKfSDioUMB45y8AoGgRZpE5FfXSyVdLD39Duuy9UsnsrSsAkA2RcFCRcFBNVZEFHxtPOC/oDiYD72BMvYMxHRv0Wnz7h+PqH4qpfySugeG4+odj4+uHY+rqH9YzXePL/cNxDcUSc194BgHTnME3HAyoJBhQOBRQOGje/OgnNGk5aCoJBcbXhQIqCVrK9oBKQpOWU84TCgYUCpiCAW+fgImwDQDIGMIsMuucN0mP/VDa8l1p4+v9rgYATkgwYKouC6u6LH3vzI0nnAZGvHA7NJLQUCyhoVhcgyPedCiW0NDI6DShwVg8ud/EfQan2ad3KKaReEIjMaeReELD8YS3HHcaiXnLw/HEhHcFp1soYAoFTaFAIBlyvbAbCgQUGpufuBxO7usdZwoGAinn8ZbDqcemhOjU+WDAFDRTIGAKmvfnF5iwziasCwakwJR1NrZuwnYbv8bYvJkCAU26bnKauj25P0EfAE4MYRaZtexcqfk06f4bpQ2vk/iHGwAmCAZMlaXes7l+iSUD7njY9QLwhOV4QsPJUOzNj4ZjN7YcSzjFE966eMIplnCKxRMT5r19XHKfRHK9Gzt2dDmecBqMxb1j406xxPixo8vj50luT54nnwTMC8iWbMUeW9b4+kAgdTm5LrlfIPnvaiAwvmxSch9LmVqypXzSslLOM+m8qTV55/SuNfov+fg/6TZh2SbMT9o2af2kyYzXmHb7TNeYUp9n9Ic2btp1KWun3c/NcuzU/Sasn3BqN+HYmWqYrVZNs1/q2ulqmGu/6c83/79LY3+e0207zv/6zfXDntm2znbo7MfNfU1L3nxm48s2upycV8rfmfF9xpeVesw055jx/Ck1Tl0/8/mn218ptf3FucvVUFk66689VxFmkVlmXuvsT26Qnr5bWnGR3xUBACYJBQMKBaUy5f9ozs45JZw0Ek8o4bygm0hI8dH55DR13ptq4nbnlEikzmuadW7SeTXNuknbU9Y558WFRLJm50brH19OODf2a3IaXe/GtiWSU01adqO/F4mJx6VOE8nzOHn7jR4fTyQmbk+ul6aGscmha0KQmumYSftOzmgzbU893+Tra5ZjUvPJ5FCcasJ+k0P3hHWp+9mUdZrjetOF7cmBfGJdcxw7x3lsmh2nr2Hm681mtsg7XWCe33HHf83ZDj6xa47+fdDY36/R48a2Jde75MVSlyfsN3b/TrNtrJap5xz9+zjn+ce2p9Y4cd9UV522mDALzOi0l0u//hfvvbOEWQBABpmNdinO/2AOAJk0+oOxfO44ybsDkHnhMums10pbfyZ17fW7GgAAAKDoWfKZ/nx+fp8wi+w4+68kmXTfZ/2uBAAAAEABIMwiO2qWed2NN39J6jvidzUAAAAA8hxhFtlz4dukkX7p3k/7XQkAAACAPEeYRfYsWied/ALp/s9Lg91+VwMAAAAgjxFmkV0XvV0a6vYCLQAAAAAcJ8IssmvJs6TVl3tdjYd6/a4GAAAAQJ4izCL7Ln6n1H9E+sP/+V0JAAAAgDxFmEX2tZ4trX+x9IdPSD0H/K4GAAAAQB4izMIfz3u/FB+Rbv+w35UAAAAAyEOEWfijbqV0zvXSQ1+XDj7udzUAAAAA8gxhFv55zj9JpVHpV++RnPO7GgAAAAB5hDAL/5TXSZe+R9rxW2nLd/yuBgAAAEAeIczCX2dfL7WeK/38nVLPQb+rAQAAAJAnCLPwVyAgveiT0siA9LO30d0YAAAAwLwQZuG/hjXSpf8sbb1FevT7flcDAAAAIA8QZpEbzvtbqeVs6ad/Lx3a6nc1AAAAAHIcYRa5IRiS/vyrUrhM+va10mC33xUBAAAAyGGEWeSO6qVeoO3aLf3gTVIi4XdFAAAAAHIUYRa5pe0C6Yr/Jz35c+nn72BAKAAAAADTCvldADDFOW+UutulP3xCCkeky/9VMvO7KgAAAAA5hDCL3GMmXf4hKTYo/eH/pFCZdOm7CbQAAAAAxhBmkZvMpE0f9QLtnf8h9R+RrvpPKRD0uzIAAAAAOYAwi9wVCEhX/69UXi/d/XGpZ7/0si9KJeV+VwYAAADAZwwAhdwWCEjP+4B01cekJ38hfekK6eguv6sCAAAA4DPCLPLDOddL13xH6tojfe5iaeutflcEAAAAwEeEWeSPk54vvelOqW6F9O1rpFv/SRru97sqAAAAAD4gzCK/1C6X/vKX0rPfLN1/o/TZC6W99/tdFQAAAIAsI8wi/4Qj0pX/Ll33Uyk+In3x+dIt/yD1H/W7MgAAAABZQphF/lrxHOnNv5fOfbP04Fel/9sgbf6SF3ABAAAAFDTCLPJbpEra9BHvWdrGdV4L7afOkf50s5RI+F0dAAAAgAwhzKIwNJ8qvf5W6ZpvS6Ey6ftvkD51trT5y9LIgN/VAQAAAEizrIVZM9tkZtvMbLuZvWua7R83s4eTnyfNrCtbtaFAmElrr5T++m7p5V+SSiqkW94qffxU6dfvl47s8LtCAAAAAGlizrnMX8QsKOlJSZdLapf0gKRrnHOPz7D/30o60zn3l7Odd+PGjW7z5s3pLheFwjnp6bulez8jPfkLycWl5RdKp75UOvmFUmWj3xUCAAAAmIWZPeic2zjdtlCWajhH0nbn3M5kQd+W9CJJ04ZZSddIen+WakOhMpNWXOR9ju2XHv669Mh3pJ+9Tbr17VLbhdIpL/GCbUWD39UCAAAAWIBshdmlkvamLLdLevZ0O5rZckkrJP02C3WhWFQtlp7zT9JFb5cOPiY9/iPpsR96A0b97B+lpRuklZdKqy6Vlm6UQiV+VwwAAABgFtkKswvxKkk3O+fi0200szdKeqMkLVu2LJt1oRCYeYNFNZ8qXfqeZLD9sbTjt9JdH5Pu/A+ppFJafoHXort0o7T4DKmk3O/KAQAAAKTIVpjdJ6k1ZbkluW46r5L0NzOdyDl3o6QbJe+Z2XQViCKUGmwve4800Ok9Y7vjdmnn7dJTv0zuF5Sa1nvBdukGb75hrVRa6W/9AAAAQBHLVph9QNIaM1shL8S+StK1k3cys3WSaiXdk6W6gHFltdLJL/A+ktRzUNr34Pjn0R9ID355fP+aZVLjydKidVL9Gqm2zftULZECQT9+BQAAAEDRyEqYdc7FzOwGSb+UFJT0JefcY2b2IUmbnXM/Se76KknfdtkYYhmYS7RJWneV95GkRELq3CUdelw6vFU6tNWb7rxdig+PHxcs8YJuzXLvWd3oYinaPHFasUgK5mIvfwAAACA/ZOXVPJnCq3mQE+Ix6Vi71Pm09zm6y5t27fZad3sPeq8FmsCkikapvE4qq/NahctqpbIab1peJ0VqpNIq7325Y59KbxoulwJZe000AAAA4ItceDUPULiCofEuxtNJxKW+Dqlnv9RzYOJ0oNP7dO2W9j8s9R+VYgPzu264YmLQDZV6rcKjn1CpFAxLwVJvdOZgiTcfDI9vC4S9LtEWSH6C3rPEU9YFUtbZ+Lqx5YAk8+aVXDaNr5uyfaZjRud1HMeY9/syed1cx1hg/PcrEBo/DwAAAHIaYRbItEDQ67IcbZrf/iMD0kCXNHBUGu6ThnuT08nzk5bjw1JsSIoNSkPHpNiwty4+JMVHvG3xkeTy8JxlFCdL+WFAycw/HAiGpXCZ10IeLvdGuw6XeT9gCJeNt56PzSe3lZRLpdFki3slresAAAAngDAL5JpwmfepWpy5azjnBdvEiOQSXuuxS3jr3eh86vp4ctvkdYnx9XKSU3Kaus4lp4mU+enW6TiOcdNsn8e1XWL898HFk6F/OOUHAMMzr4slfxjQd1ga7vd++DDS583Pt1VdkmTjwbY0KkWqxpfH5qtTtqXsF6n2tkWqvGANAABQhAizQDEy81oeVeJ3JYUlkfAC7ciA11o+GnRHBrywO9wrDfV4LedDPdLgseT8MW++/4j3vPXo+tjg3NcMlXnhdjTwjoXd0VBcPcf2KkbfBgAAeYkwCwDpEgiMP8Nc0XDi54sNJ8Nv98TwO9g9ab57PBAPdktdexYWiEtSWn/nCsal0WS36tEu1SnzDEwGAACyiDALALkqVCKF6qWK+uM/R2xoYvCdEoYnrR865o3A3fHU+LpEbAE1l016Vrg8ZYCyUm86OlhZKDJpvmTSPsnBy0KR8eeWx9ZHJm1LnosBvAAAKBqEWQAoZKFSqbLR+xwP57xu0qPBd6hHGun3PmNdqUeX+8fnJ3S17veOi3UknzkeSg5Wlnz+ODa4sMA8m+CkQDw5RIdKpwbg6fYZXR59hn10AK/JLdIl5V6Ap0UaAICsI8wCAGZm5gW2knIp2py56yTi48E2lpyOjdA9OQCnzI/tN/m41OXU/YeSwXqG88WHjq/+0GjATR3heprgO/q+6HD5xHdHl5RPfI/06DytzQAAzIgwCwDwXyAoBZKtoH5KJMZfaRUbGm9ZTm11Tm1xHu6b2jKdur3vsNQ1adtCArMFUgLvpKA7UwCe/Jn8TuqSCq9lmpAMAMhzhFkAAEYFAlIgIoUjmbtGfGQ8BI+9LzplfsL6vvGRsFOP6e9IhuSU/RIjC/h1hmYOurOtn3VbJa+KAgBkFWEWAIBsCoalshrvk06x4eQ7j6cLwKPBeNJnJHW5X+o9NHHbUK/3Lub5CoRTuk9P1606ZVuobPZnm2cb6Gt0e5D/xgBAMeNfAQAACkGoxPuU1abvnM553a5nDMCzheOUT++BSet6JZc48fosODUMB8NeqA6GktPplkPeZ6Zt0623gHe9QHJqAa97/IT5wMzrx7YHJ80Hpq6XpXQDT5mfsi51/XTHzLBu2mNmWDd67IR9cnQ9XeeBokOYBQAA0zMbD4vldek7r3PeCNazDdQ174G+Ju0fH/G6XMdjyemId63h/mnWpywnYhO3LaRFGjluHqF4tm1+rp/yg5HgxPVz/WBkzvWj5w5N+mHO5B/4hJNjG8zxA6Ep5xmdT/nBUDCcHHl+0odR4XEcCLMAACC7zMb/U1vqdzEzSCS8gDsWbhPeJxFPzsdT5mdaH/fO4+Ip+4zOz7Q+GaKdSxbikvMuZb2b5/aZjtHcx0zYb2whi+s1w/pMXDdb11jgeabcV4lJ91h80j7T3EsukfzBTXyOe3bSD3MS8Yk/9MmGQCj5+EB4/B3ko5/Q6Hzq9nByuWQBx8yyffR95tOG7TAt/zmKMAsAADBZICAFSiSV+F0J4C/nUkJxSm+HRGx8fnTblFCcDMaTe0KM9qKIj75vfDg5knzKZ2xdct/RY4Z7pYGjU49JPWe63l2eKjXYpoboCcF4UgCeEpAnheXQbOec6bjUYJ5yXCBYlIGbMAsAAABgembjXZSVwZHe02nsNWvDM4TmSQF5dPvYutHjUvadErqnOy45Wn28c4ZgnnLOtLP5jxkwef3VH5dql2egpswjzAIAAAAoHNl4zdqJGB03YEKL8uTW6ZFptk/aNzY5WE9qKZ+yPGksgdiwlOjTlMcL8ghhFgAAAACyJXXcgJIKv6vJawwbBgAAAADIO4RZAAAAAEDeIcwCAAAAAPIOYRYAAAAAkHcIswAAAACAvEOYBQAAAADkHcIsAAAAACDvEGYBAAAAAHmHMAsAAAAAyDuEWQAAAABA3iHMAgAAAADyDmEWAAAAAJB3CLMAAAAAgLxDmAUAAAAA5B3CLAAAAAAg7xBmAQAAAAB5hzALAAAAAMg7hFkAAAAAQN4x55zfNRw3MzssabffdcyhQVKH30UgZ3F/YCbcG5gN9wdmw/2BmXBvYDa5en8sd841Trchr8NsPjCzzc65jX7XgdzE/YGZcG9gNtwfmA33B2bCvYHZ5OP9QTdjAAAAAEDeIcwCAAAAAPIOYTbzbvS7AOQ07g/MhHsDs+H+wGy4PzAT7g3MJu/uD56ZBQAAAADkHVpmAQAAAAB5hzALAAAAAMg7hNkMMbM6M/uhmfWZ2W4zu9bvmuAfM7vDzAbNrDf52Zay7drkPdJnZj8yszo/a0VmmdkNZrbZzIbM7CuTtj3XzLaaWb+Z3W5my1O2lZrZl8zsmJkdMLO3Zb14ZNxM94eZtZmZS/kO6TWzf0nZzv1R4JJ/xl9M/nvRY2YPm9mVKdv5/ihis90ffH9Akszs62a2P/nn/KSZ/VXKtrz9/iDMZs6nJA1LapL0akmfMbNT/C0JPrvBOVeZ/KyVpOQ98TlJr5F3r/RL+rSPNSLznpH0b5K+lLrSzBok/UDSv0iqk7RZ0ndSdvmApDWSlku6VNI7zGxTFupFdk17f6SoSfke+deU9R8Q90ehC0naK+liSdWS3ivpu8mgwvcHZrw/Uvbh+6O4fURSm3OuStILJf2bmW3I9+8PBoDKADOrkNQp6VTn3JPJdV+TtM859y5fi4MvzOwOSV93zn1h0vr/J++L5drk8ipJT0iqd871ZL1QZI2Z/ZukFufc65LLb5T0Oufc+cnlCkkdks50zm01s2eS23+V3P6vktY4517lyy8AGTXN/dEmaZeksHMuNs3+3B9FyMy2SPqgpHrx/YFJUu6PB8X3B1KY2VpJd0j6e0k1yuPvD1pmM+MkSbHRIJv0iCRaZovbR8ysw8x+b2aXJNedIu/ekCQ553bIa9E/KfvlwWeT74U+STsknWJmtZIWp24X3ynFareZtZvZl5M/TRf3R3EysyZ5/1Y8Jr4/MMmk+2MU3x9Fzsw+bWb9krZK2i/pVuX59wdhNjMqJR2btK5bUtSHWpAb3ilppaSl8t7h9dNkK2ylvHsjFfdKcZrtXqhMWZ68DcWhQ9LZ8rp5bZD3Z/+N5DbujyJjZmF5f/5fdc5tFd8fSDHN/cH3ByRJzrm3yPuzvUhe1+Ih5fn3R8jvAgpUr6SqSeuqJNFttEg55+5LWfyqmV0j6Spxr2DcbPdCb8ry4KRtKALOuV55zzFJ0kEzu0HSfjOLivujqJhZQNLX5PXiuSG5mu8PSJr+/uD7A6mcc3FJd5vZX0h6s/L8+4OW2cx4UlLIzNakrDtDE7t6oLg5SSbvnjhjdKWZrZRUKu8eQnGZfC9USFol6THnXKe87kBnpOzPd0pxGx3wIsD9UTzMzCR9Ud6AgS9zzo0kN/H9gdnuj8n4/oDkNWquUp5/fxBmMyDZ1/wHkj5kZhVmdoGkF8n7SRmKjJnVmNkVZhYxs5CZvVrScyT9Ql43nxeY2UXJL48PSfoBgz8VruQ9EJEUlBQcvS8k/VDSqWb2suT290nakuwiJkk3SXqvmdWa2TpJ10v6ig+/BGTQTPeHmT3bzNaaWcDM6iV9QtIdzrnRrl/cH8XhM5JOlvQC59xAynq+PyDNcH/w/QEzW2RmrzKzSjMLmtkVkq6RdJvy/fvDOccnAx95Q1v/SFKfpD2SrvW7Jj6+3QuNkh6Q1yWjS9K9ki5P2X5t8h7pk/RjSXV+18wno/fDB+T9VDz184HktufJG5RhQN4og20px5XKe13LMUkHJb3N718Ln+zdH/L+07Er+T2xX95/Lpq5P4rnI+95Ryevq19vyufVye18fxTxZ7b7g+8PPsn/i/4u+f/QY5L+JOn6lO15+/3Bq3kAAAAAAHmHbsYAAAAAgLxDmAUAAAAA5B3CLAAAAAAg7xBmAQAAAAB5hzALAAAAAMg7hFkAAAAAQN4hzAIAkEVm9nMzu87vOubDzNrMzJlZyO9aAACYjH+cAACYg5n1piyWSxqSFE8uv8k59435nss5d2U6awMAoFgRZgEAmINzrnJ03syelvRXzrnfTN7PzELOuVg2awMAoFjRzRgAgONkZpeYWbuZvdPMDkj6spnVmtktZnbYzDqT8y0px9xhZn+VnH+dmd1tZh9L7rvLzGZsuTWzJWb2/eS5d5nZ36Vs+4CZ3Wxm3zGzHjP7o5mdkbL95OS1u8zsMTN7Ycq2MjP7LzPbbWbdyZrKUi79ajPbY2YdZvaedP3+AQBwIgizAACcmGZJdZKWS3qjvH9bv5xcXiZpQNInZzn+2ZK2SWqQ9B+SvmhmNnknMwtI+qmkRyQtlfRcSW81sytSdnuRpO8l6/mmpB+ZWdjMwsljfyVpkaS/lfQNM1ubPO5jkjZIOj957DskJVLOe6Gktclrvs/MTp7zdwUAgAwjzAIAcGISkt7vnBtyzg045444577vnOt3zvVI+rCki2c5frdz7vPOubikr0paLKlpmv3OltTonPuQc27YObdT0uclvSplnwedczc750Yk/bekiKRzk59KSf+ePPa3km6RdE0yJP+lpL93zu1zzsWdc39wzg2lnPeDyV/bI/LC9BkCAMBnPDMLAMCJOeycGxxdMLNySR+XtElSbXJ11MyCycA62YHRGedcf7JRtnKa/ZZLWmJmXSnrgpLuSlnem3KuhJm1S1oyus05l9raulteC2+DvNC7Y5Zf44GU+f4Z6gMAIKsIswAAnBg3afkf5XXJfbZz7oCZPUvSQ5KmdB1eoL2Sdjnn1syyT+voTLLFtUXSM6PbzCyQEmiXSXpSUoekQUmr5LW6AgCQF+hmDABAekXlPSfbZWZ1kt6fpvPeL6knOdhUmZkFzexUMzs7ZZ8NZvbS5Hth3yrvFUL3SrpPXovqO5LP0F4i6QWSvp0Mt1+S9N/JAaaCZnaemZWmqW4AADKCMAsAQHr9j6QyeS2e90r6RTpOmuyifLWkZ0nalTz/FyRVp+z2Y0mvlNQp6TWSXuqcG3HODcsLr1cmj/u0pNc657Ymj3u7pD9JekDSUUkfFf9HAADkOHNucu8oAACQb8zsA5JWO+f+wu9aAADIBn7qCgAAAADIO4RZAAAAAEDeoZsxAAAAACDv0DILAAAAAMg7hFkAAAAAQN4hzAIAAAAA8g5hFgAAAACQdwizAAAAAIC8Q5gFAAAAAOSd/w8Ha4bswZNI9gAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -336,7 +336,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e0663748704f43278c7db2e57dd4d6b6", + "model_id": "3ed93a165d71427a90375cefa63a68e4", "version_major": 2, "version_minor": 0 }, @@ -350,7 +350,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ec3eab1eae4c4439af6337fd896895fc", + "model_id": "0c82a28bbb934e59827b9bf696fc32f1", "version_major": 2, "version_minor": 0 }, @@ -364,8 +364,7 @@ ], "source": [ "train_influences = compute_influences(\n", - " nn_model,\n", - " F.cross_entropy,\n", + " TwiceDifferentiable(nn_model, F.cross_entropy),\n", " *train_data,\n", " *test_data,\n", " influence_type=\"up\",\n", @@ -417,7 +416,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA68AAAH3CAYAAABU2mlaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAAAw9ElEQVR4nO3debhdZXk3/u9NEmUmAmEmCSgq4otUUxywiEPVVhRrtUALVlFxeBHU/qyAreUVC7TaUmdFRVRQihZHqEqdcEAtKFoBZQxDGCQiSBgE5Pn9sXfSw8k5yU5y9tkr8fO5rnOdvZ81PPc6Z10755tnrWdVay0AAADQZeuNugAAAABYGeEVAACAzhNeAQAA6DzhFQAAgM4TXgEAAOg84RUAAIDOE14BGIqqelFVXVFVv6uqU6pqn6pqVbXDqGsjqapvVtWHJ3s/xX0dU1WXT/Z+CP2dUlX/Naz9AzAawisAK7Q6QaCqZiQ5OckZSeYmOWIYtTGlXpDkDYOsWFU79P8jYp8B9/2OJE9YzbpWVMdBVTXRA+uPSPKiqe4PgNGaOeoCAFgnbZtk4yRnt9YWJUlVjbaijquqWa21e0fVf2vtlqneZ1Wtl6Raa0uSLJnq/U+mtXbbdPUFwPQx8grAKlk6EltVh1bV1VX1m6r6QlVt3V/+kiTX9lc/d7IRuskuI66q+/r7WPp+636fN1fV7VX13arae9w2D62qz1TVLVV1Z1X9tKr2HbP8cVX11apa0t/PmVU1byXHuV9V/bi/v1ur6odV9Qer0OefVtUFVfXbqvplVb2vqjaa4Of42qpamOS3VbXByo63qmZV1b9W1XX9fd9QVaev5FjmVdWXq+quqrq2ql47wTrjLyN+cr/v2/tfP6mqZ/UXL/39fqP/O1zY3+aYqrq8qvavqp8nuSfJwye7TLiq/rKqrqyqu6vqnKqaP2bZctv0a2pVNb9/Tn2i3976X6eM/dmO2a6q6v/r93VP9S5nf924fS+sqrdW1Tv7v9ObqurEqvIf/QAdIbwCsDr+MMlTkzwnybOS/J/0Lg1Nkn9Psmf/9X7pjcJ+b3U6qaoNknwjySZJ/iTJHyQ5O8k5VbVrf51t+vufneR5/Vr+Psn9/eWPSvKtJOclWZDkaUl+19/H+pP0u02STyf5VJLdkjwxyb8luW/APndP8oUk5yZ5TJK/TrJvkg+M62rPfj379ddbb2XHm+S1Sf4iyUFJdun3//0V/AwryWeTbJFknyTP7W/z2BVsM7Nf/w/66z02yTFJ7uyvsnTbP0/v9/uHYzbfLslr+sf8qCTXTdLNtv31/iLJHyXZNMmZ/XoH8b0kh43Z17aZ/PL01yQ5NskJ6f0+357khKp62bj1XpvkhiSP778+rH8cAHSA/00EYHX8NslLWmu/TZKq+kCS1yVJa+2uqrq5v94trbUb++usTj/7pxdq9m+t3ddv+8eqenqSV/b7/L9JWpL9Wmt39Ne5Ysw+/jbJl1pr/7C0oaoOSvLrJM9O8rkJ+t02yawkZ7TWFvbbLhmzfGV9vjHJj1prr++//3l/tPOzVfV3rbWr++33Jzm4f1nt0lHrlR3vvCSXJvlWa60luSbJf09wDEs9Pb0Q/IjW2qX9fv6yv91kNknykCRfaK1d1m+7bMzy5X6/Y6zfP6Zl+5/kd79heufQ5f11Dk7yi/TC/NdWUFuSpLV2T1Xd1n89vobxjkzy7tbaSUuPpaoekeTNST4yZr1vt9ZOGLPOS5M8Y9w6AIyI8ArA6vj50uDad32SrYfQzx8m2SbJreMC0IOT3NV//bgk3xsTIifax8Oqavw9l+unN3I5kZ8m+UqSn1XVOUm+meTM1trSy2VX1uduSb4+ru1bSSq90cil4fWSpcF1TK0rO96PJjknyeX92s5J8sXW2j2T1PKoJIuXBtckaa3dXFW/mGT9tNZ+3b+E+CtV9fV+7Z9trU26zRg3jQ2uK3Dz0uDa7/PSqlqc3s9upeF1UFW1aZId0hsFH+tbSY6oqg1ba0tHlC8ct871SXaaqloAWDPCKwCrY3xQaukFs1Vxf//7su2qN0vx2Fta1ktvxPPPJtj+zgnaJrJeevdGnjDBsl9NtEFr7XdV9SfphclnpHd57AlV9aLW2pcG7HcQ48PvSo+3tXZhVe2U5I/Tu3T7nUmOraontNZ+M1WFtdZeUVXvTPLMfl/HVtVhrbUPrmTTyQL9qro/y59Ts6Zo35OZ6Lx2ixVAR/hABmBUftn/vt2Ytj3ywMByfpKdk/ymtXb5uK/r++tckORJYydDGuf8JLsnuWKCffx6suJazw9ba8e11vZOb6TupQP2eVGSvce1PSW9MHTRZH0OeLxprS1prX22tXZ4evfx7trf/0QuTrJlVS0bZa6qLZM8YgV1LO3nZ621f22t/Ul6l84e2l+0NOTNWNk+VmBOVT10TE0PT7Jlv96kd35s1f8PjaXG36d7T3/bSevoB/rrMvHv46oxo64AdJzwCsCoXJ7e5bPHVNUjq+rJSU5ML+AtdVqSq5KcVVXP7M8y+/iqOqqqnt9f533p/Xv2+araq6p2qqp9+yOnSXJceuHu1Kras7/8qf1ZZXeeqLCqelJV/X2/r7n9e053z/8Gq5X1+fYkj+3PVvvIqnp2kncnOW0ll9Su9Hir6o1V9VdVtVt/BPaQ9CagunSSfX4tyU/GHP8e/X4mfSxPVT2sqv6perP7zquqJ6Y3qdLS41+c3qNvnllV21TVQ1ZwTJO5M8lHq2pBVS1I8rH0LttdesnwN9K7L/at1ZvZ+UXp3Ws81lX978+rqjlVtfEkfR2f5LVV9Yqq2qWqXpnk1emdGwCsJYRXAEaiPyHR/km2SvLjJO9NbwKd+8esc3d6I2Tnp3ev56VJzkxvlt6r++vckOTJSW5Pb2bei5L8Y/ojuK21S5I8Kb3nzn4lvQD2oSQbJLl1kvJuS2+G4c+nN1HRyekFvmMH7POn6c3ou3d6wfETSc5K8qqV/ExWerxJfpPkDenNnvw/6V1i/OeT3Y/an9Tp+f1jOjfJl/o1/2gFpdyR3v3Ap/dr+I+Mmd23tXZ/ekHyL9Ib1fzxio5rEjckOSnJZ5J8J70w+4J+vekfzyuSHJjkZ+mF9KPHHdt/p3fZ9AfTG6l9zyR9vT/JW/rbX5zkTUmObK2ZiAlgLVL9fyMAAACgs4y8AgAA0HnCKwAAAJ0nvAIAANB5wisAAACdJ7wCAADQeTNHXcCq2nLLLdv8+fNHXQYAAABDcMEFFyxurc0Z377Whdf58+fn/PPPH3UZAAAADEFVXT1Ru8uGAQAA6DzhFQAAgM4TXgEAAOg84RUAAIDOW+smbAIAAFgV9957b6677rrcfffdoy6FJDNmzMjs2bOz5ZZbZr31Bh9PFV4BAIB12nXXXZdNNtkk8+fPT1WNupzfa6213Hvvvbnpppty3XXXZe7cuQNv67JhAABgnXb33Xdniy22EFw7oKryoAc9KNtvv33uuOOOVdpWeAUAANZ5gmu3rMrlwsu2GUIdAAAAMKWEVwAAAJZTVbn88stHXcYyJmwCAAB+78w/8qyh7n/hCc8Z6v5/Hxl5BQAAWMvdd999oy5h6IRXAACAEZo/f37e8Y53ZPfdd89mm22W/ffff9kzaT/0oQ/lYQ97WDbffPM873nPy/XXX79su6rKe9/73uyyyy7ZZZdd8s1vfjM77LBD/vmf/zlbbbVVtt1223zuc5/L2WefnYc//OHZfPPNc9xxxy3b/oc//GGe+MQnZvbs2dl2221z2GGH5Z577pn24x+U8AoAADBiZ5xxRr785S/nqquuyk9/+tOccsop+frXv56jjjoqZ5xxRm644YbMmzcvBxxwwAO2+9znPpcf/OAHufjii5MkN954Y+6+++4sWrQob33rW/OKV7wip556ai644IJ8+9vfzrHHHpurrroqSTJjxoyceOKJWbx4cc4777x87Wtfy/ve975pP/ZBCa8AAAAjdvjhh2e77bbL5ptvnuc+97m58MILc9ppp+WQQw7JYx/72Dz4wQ/O8ccfn/POOy8LFy5ctt1RRx2VzTffPBtssEGSZNasWXnzm9+cWbNm5YADDsjixYtzxBFHZJNNNsluu+2WRz3qUfnJT36SJHnc4x6XJzzhCZk5c2bmz5+fV77ylfnWt741isMfyLSE16o6uap+WVU/m2DZ31RVq6otp6MWAACArtlmm22Wvd5www2zZMmSXH/99Zk3b96y9o033jhbbLFFFi1atKxtxx13fMB+tthii8yYMSNJlgXarbfeetnyDTbYIEuWLEmSXHrppdl3332zzTbbZNNNN83RRx+dxYsXT/3BTZHpGnk9JcmzxzdW1Y5JnpnkmmmqAwAAYK2w3Xbb5eqrr172/o477sivfvWrbL/99svaqmq19//qV786j3zkI3PZZZflN7/5TY477ri01tao5mGalvDaWjs3yS0TLDoxyd8m6e5PCAAAYAQOPPDAfPSjH82FF16Y3/72tzn66KPz+Mc/PvPnz5+S/d9+++3ZdNNNs/HGG+fnP/953v/+90/JfodlZPe8VtV+SRa11n4yqhoAAAC66hnPeEaOPfbY/Pmf/3m23XbbXHHFFTn99NOnbP/veMc78slPfjKbbLJJXvGKV2T//fefsn0PQ03XsHBVzU/ypdbao6tqwyTfSPLM1tptVbUwyYLW2oQXWFfVoUkOTZK5c+c+buzQOQCs7eYfedaoS1hnLDzhOaMuAeigSy65JLvuuuuoy2CcyX4vVXVBa23B+PZRjbw+NMlOSX7SD647JPlRVW0z0cqttZNaawtaawvmzJkzjWUCAADQBTNH0Wlr7X+SbLX0/cpGXgEAAPj9Nl2PyvlUkvOSPKKqrquql01HvwAAAKwbpmXktbV24EqWz5+OOgAAAFg7jWy2YQAAABiU8AoAAEDnCa8AAAB0nvAKAABA5wmvAAAATLl99tknH/7wh6dsfyN5zisAAMBIHbPZkPd/23D3P2QLFy7MTjvtlHvvvTczZ3YjNhp5BQAAWIvdd999A7Wt7YRXAACAEbr22mvzghe8IHPmzMkWW2yRww47LPfff3/e9ra3Zd68edlqq63y4he/OLfd1hvNXbhwYaoqH/nIRzJ37tw87WlPyymnnJK99torr3/967PFFlvkmGOOyTHHHJODDjpoWT9Lt1sabPfZZ58cddRR2XPPPbPppptmv/32yy233JIk2XvvvZMks2fPzsYbb5zzzjsvSXLyySdn1113zUMe8pA861nPytVXX71s/+ecc04e+chHZrPNNsthhx2W1tqU/pyEVwAAgBH53e9+l3333Tfz5s3LwoULs2jRohxwwAE55ZRTcsopp+Qb3/hGrrzyyixZsiSHHXbYA7b91re+lUsuuSRf+cpXkiQ/+MEPsvPOO+emm27Km9/85oH6//jHP56TTz45N9xwQ2bOnJnDDz88SXLuuecmSW699dYsWbIkT3ziE/P5z38+xx13XM4888zcfPPN+aM/+qMceOCBSZLFixfnBS94Qd72trdl8eLFeehDH5rvfve7U/VjSiK8AgAAjMwPf/jDXH/99Xn729+ejTbaKOuvv36e/OQn57TTTssb3vCG7Lzzztl4441z/PHH5/TTT3/A5cDHHHNMNtpoo2ywwQZJku222y6vfe1rM3PmzGVtK3PwwQfn0Y9+dDbaaKMce+yxOeOMM/K73/1uwnU/8IEP5Kijjsquu+6amTNn5uijj86FF16Yq6++OmeffXZ22223vPCFL8ysWbPyute9Lttss82a/4DGEF4BAABG5Nprr828efOWmxTp+uuvz7x585a9nzdvXu67777cdNNNy9p23HHHB2wz/v0gxm4zb9683HvvvVm8ePGE61599dU54ogjMnv27MyePTubb755WmtZtGhRrr/++gfsq6pWq54VEV4BAABGZMcdd8w111yz3ARL22233QPuJ73mmmsyc+bMbL311svaquoB24x/v9FGG+XOO+9c9v7GG29crv9rr732AX3MmjUrW2655XL7WlrrBz/4wdx6663Lvu6666486UlPyrbbbvuAfbXWHvB+KgivAAAAI7Lnnntm2223zZFHHpk77rgjd999d7773e/mwAMPzIknnpirrroqS5YsydFHH539999/lR5bs8cee+Tcc8/NNddck9tuuy3HH3/8cuuceuqpufjii3PnnXfmLW95S174whdmxowZmTNnTtZbb71ceeWVy9Z91ateleOPPz4XXXRRkuS2227Lpz/96STJc57znFx00UU588wzc9999+Vd73rXhGF5TQivAAAAIzJjxox88YtfzOWXX565c+dmhx12yL//+7/nkEMOycEHH5y99947O+20U9Zff/28+93vXqV9//Ef/3H233//7L777nnc4x6Xfffdd7l1Dj744LzkJS/JNttsk7vvvjvvete7kiQbbrhh3vzmN2evvfbK7Nmz8/3vfz9/9md/lje96U054IADsummm+bRj350/vM//zNJsuWWW+bTn/50jjzyyGyxxRa57LLLstdee635D2iMmurpi4dtwYIF7fzzzx91GQAwZeYfedaoS1hnLDzhOaMuAeigSy65JLvuuuuoy+icffbZJwcddFBe/vKXj6T/yX4vVXVBa23B+HYjrwAAAHSe8AoAAEDnDX63LwAAAOuMb37zm6MuYZUYeQUAAKDzhFcAAGCdt7ZNVLuuW53fh/AKAACs02bMmJF777131GUwxl133ZVZs2at0jbCKwAAsE6bPXt2brrpptx///2jLuX3Xmstd955ZxYtWpStttpqlbY1YRMAALBO23LLLXPdddflF7/4xahLIcmsWbOy9dZbZ9NNN12l7YRXAABgnbbeeutl7ty5oy6DNeSyYQAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOk94BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOk94BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOk94BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOk94BQAAoPOEVwAAADpPeAUAAKDzpiW8VtXJVfXLqvrZmLa3V9XPq+qnVfXZqpo9HbUAAACw9pmukddTkjx7XNs5SR7dWts9yaVJjpqmWgAAAFjLTEt4ba2dm+SWcW1fba3d13/7/SQ7TEctAAAArH26cs/rIUn+c9RFAAAA0E0jD69V9eYk9yU5bQXrHFpV51fV+TfffPP0FQcAAEAnjDS8VtVLkuyb5K9aa22y9VprJ7XWFrTWFsyZM2fa6gMAAKAbZo6q46p6dpK/TfKU1tqdo6oDAACA7puuR+V8Ksl5SR5RVddV1cuSvCfJJknOqaoLq+oD01ELAAAAa59pGXltrR04QfNHpqNvAAAA1n4jn7AJAAAAVkZ4BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOk94BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOk94BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOk94BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOk94BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOk94BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOk94BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOk94BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOk94BQAAoPOmJbxW1clV9cuq+tmYts2r6pyquqz//SHTUQsAAABrn+kaeT0lybPHtR2Z5GuttV2SfK3/HgAAAJYzLeG1tXZuklvGNe+X5GP91x9L8vzpqAUAAIC1zyjved26tXZD//WNSbYeYS0AAAB0WCcmbGqttSRtsuVVdWhVnV9V5998883TWBkAAABdMMrwelNVbZsk/e+/nGzF1tpJrbUFrbUFc+bMmbYCAQAA6IZRhtcvJPnr/uu/TvL5EdYCAABAh03Xo3I+leS8JI+oquuq6mVJTkjyx1V1WZJn9N8DAADAcmZORyettQMnWfT06egfAACAtVsnJmwCAACAFRFeAQAA6DzhFQAAgM4TXgEAAOg84RUAAIDOE14BAADoPOEVAACAzhNeAQAA6DzhFQAAgM4TXgEAAOg84RUAAIDOE14BAADoPOEVAACAzhNeAQAA6DzhFQAAgM4TXgEAAOg84RUAAIDOE14BAADoPOEVAACAzhNeAQAA6DzhFQAAgM4TXgEAAOg84RUAAIDOmznISlX1qCS/aq3dVFUbJ3ljkvuTvL21ducwCwQAAIBBR14/lWR2//U7kuyd5AlJPjiEmgAAAOABBhp5TTK/tfaLqqokL0jyqCR3JblqaJUBAABA36Dh9e6q2iS90HpNa21xVc1Msv7wSgMAAICeQcPrJ5N8PckmSd7Tb3tsjLwCAAAwDQYKr62111fVM5Pc21r7Rr/5/iSvH1plAAAA0DfQhE1V9a7W2lfHBNe01s5P8ryhVQYAAAB9g842/JJJ2g+eojoAAABgUiu8bLiqDlm63pjXS+2cZPFQqgIAAIAxVnbP69KR1QflgaOsLclNSf56GEUBAADAWCsMr621pyZJVb2ttfZ301MSAAAAPNCgsw3/XZJU1VZJNh637Moh1AUAAADLDBReq+pZSU5Osu24RS3JjKkuCgAAAMYadLbh9yU5NslGrbX1xnwJrgAAAAzdQCOvSR6S5IOttTbMYgAAAGAig468fiTJS4dZCAAAAExm0JHXJyQ5vKqOTHLj2AWttb2nvCoAAAAYY9Dw+uH+FwAAAEy7QR+V87FhFwIAAACTmTS8VtXBrbVP9F8fMtl6rbWTh1EYAAAALLWikdcDk3yi//rgSdZp6T3/FQAAAIZm0vDaWvvTMa+fOj3lAAAAwPIGnbApVfWQJM9Nsn2SRUm+2Fr79bAKAwAAgKUGes5rVT0xyRVJXpVk9ySvTHJFvx0AAACGatCR139L8prW2ulLG6pq/yTvSvKHQ6gLAAAAlhlo5DXJw5OcMa7tM0keNrXlAAAAwPIGDa+XJTlgXNuL0ruUGAAAAIZq0MuGX5fkS1V1eJKrk8xPskuSfde0gKp6fZKXp/fYnf9J8tLW2t1rul8AAADWHQONvLbWvpfkoUnek+SCJO9O8rB++2qrqu2THJ5kQWvt0UlmZPkRXgAAAH7PDfyonNbar6vqG0m2S3J9a+2WKaxhg6q6N8mGSa6fov0CAACwjhj0UTlzq+rbSRYmOSvJwqr6dlXNW5POW2uLkrwjyTVJbkhyW2vtq2uyTwAAANY9g07Y9LH0Lhee3VrbKslDkpzfb19tVfWQJPsl2Sm9Ed2NquqgCdY7tKrOr6rzb7755jXpEgAAgLXQoOH1cUne2Fq7I0laa0uSvKnfviaekeSq1trNrbV7k5yZ5EnjV2qtndRaW9BaWzBnzpw17BIAAIC1zaDh9ftJ9hzXtiDJeWvY/zVJnlBVG1ZVJXl6kkvWcJ8AAACsYwadsOmKJGdX1VlJrk2yY5I/TfLJqnrr0pVaa29Zlc5baz+oqs8k+VGS+5L8OMlJq7IPAAAA1n2Dhtf107ukN0m2SvLbJJ9NskF6QTbpPad1lbXW/iHJP6zOtgAAAPx+GCi8ttZeOuxCAAAAYDKD3vMKAAAAIyO8AgAA0HnCKwAAAJ03aXitqrePef206SkHAAAAlreikddDx7z+3JDrAAAAgEmtaLbhn/SfwXpxkgePfZ7rWKv6bFcAAABYVSsKry9Mb/R1XpLK/z7PdazVerYrAAAArIpJw2tr7ZdJ3pYkVTXTs14BAAAYlRWNvC7TWntpVT0kyXOTbJ9kUZIvtdZuGWZxAAAAkAz4qJyqemKSK5K8KsnuSV6Z5PJ+OwAAAAzVQCOvSf4tyWtaa6cvbaiq/ZO8K8kfDqEuAAAAWGagkdckD09yxri2zyR52NSWAwAAAMsbNLxeluSAcW0vSu9SYgAAABiqQS8bfl2SL1XV4UmuTjI/yS5J9h1OWQAAAPC/Bp1t+HtV9dAkz0myXZIvJjnbbMMAAABMh0FHXtNa+3WSU4dYCwAAAExo0HteAQAAYGSEVwAAADpvoPBaVUIuAAAAI7PSUFpVM5LcUVUPnoZ6AAAAYDkrDa+ttd8luTTJFsMvBwAAAJY36GzDp6X3nNd3JrkuSVu6oLX29WEUBgAAAEsNGl5f3f9+zLj2lmTnKasGAAAAJjBQeG2t7TTsQgAAAGAyA88iXFWzquqPqmr//vuNqmqj4ZUGAAAAPYM+Kuf/pDdp04eSfKTf/JQkJw+pLgAAAFhm0JHX9yd5S2vtkUnu7bd9K8mTh1IVAAAAjDFoeN0tyan91y1JWmt3JNlgGEUBAADAWIOG14VJHje2oar2THL5VBcEAAAA4w36qJy/T3JWVX0gyYOq6qgkr0ryiqFVBgAAAH0Djby21r6U5NlJ5qR3r+u8JC9orX11iLUBAABAksFHXtNa+3GS1wyxFgAAAJjQoI/KeVBVvbWqLquqO/rfj62q9YddIAAAAAw68vr+JI9IcniSq9O7bPjoJNsnOWQ4pQEAAEDPoOH1+Uke2lq7tf/+4qr6QXqzDQuvAAAADNWgj8q5McmG49o2SHLD1JYDAAAAy5t05LWqnjbm7SeSfLmq3p3kuiQ7Jvm/ST4+3PIAAABgxZcNf2SCtqPHvX9lkn+aunIAAABgeZOG19baTtNZCAAAAExm0HteAQAAYGQGfc7rY6rq61V1S1Xd0/+6t6ruGXaBAAAAMOijcj6V5D/Se87rXcMrBwAAAJY3aHjdJslbWmttmMUAAADARAa95/VjSf5ymIUAAADAZAYdeT0hyXlVdXSSm8YuaK09beJNAAAAYGoMGl4/k+SqJJ+Ne14BAACYZoOG1z2SbNFaM7swAAAA027Qe16/neRRwywEAAAAJjPoyOtVSb5aVZ/N8ve8vmXKqwIAAIAxBg2vGyY5K8mDkuw4vHIAAABgeQOF19baS4dVQFXNTvLhJI9O0pIc0lo7b1j9AQAAsPYZKLxW1c6TLWutXbmGNbwzyZdbay+sqgelN8oLAAAAywx62fDl6Y2K1pi21v8+Y3U7r6rNkuyd5CVJ0p/N2IzGAAAAPMCglw0/YFbiqtomyT+kNwvxmtgpyc1JPlpVj0lyQZIjWmt3jOvv0CSHJsncuXPXsEsAYF01/8izRl3CSi084TmjLgFgrTToo3IeoLV2Y5LXJTl+DfufmeSxSd7fWvuDJHckOXKC/k5qrS1orS2YM2fOGnYJAADA2ma1wmvfI7Lm96del+S61toP+u8/k16YBQAAgGUGnbDp2/nfe1yTXmjdLclb16Tz1tqNVXVtVT2itfaLJE9PcvGa7BMAAIB1z6ATNn143Ps7kvyktXbZFNTw2iSn9WcavjLJ0B7LAwAAwNpp0AmbPjasAlprFyZZMKz9AwAAsPYb9LLhB6X3OJs9kmw8dllr7cVTXhUAAACMMehlwx9L8pgkX0xy0/DKAQAAgOUNGl6fnWSn1tqtQ6wFAAAAJjToo3KuSfLgYRYCAAAAkxl05PXjST5fVe/MuMuGW2tfn/KqAAAAYIxBw+th/e/HjWtvSXaeunIAAABgeYM+KmenYRcCAAAAkxn0nlcAAAAYGeEVAACAzhNeAQAA6DzhFQAAgM4TXgEAAOg84RUAAIDOE14BAADoPOEVAACAzhNeAQAA6DzhFQAAgM4TXgEAAOg84RUAAIDOE14BAADoPOEVAACAzhNeAQAA6DzhFQAAgM4TXgEAAOi8maMuAIBpcMxmo65g7XDMbaOuAACYhJFXAAAAOk94BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOk94BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOk94BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOk94BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOq8T4bWqZlTVj6vqS6OuBQAAgO7pRHhNckSSS0ZdBAAAAN008vBaVTskeU6SD4+6FgAAALpp5OE1yb8l+dsk90+2QlUdWlXnV9X5N99887QVBgAAQDeMNLxW1b5Jftlau2BF67XWTmqtLWitLZgzZ840VQcAAEBXjHrkda8kz6uqhUlOT/K0qjp1tCUBAADQNSMNr621o1prO7TW5ic5IMnXW2sHjbImAAAAumfUI68AAACwUjNHXcBSrbVvJvnmiMsAAACgg4y8AgAA0HnCKwAAAJ0nvAIAANB5wisAAACdJ7wCAADQecIrAAAAnSe8AgAA0HnCKwAAAJ0nvAIAANB5wisAAACdJ7wCAADQecIrAAAAnSe8AgAA0HnCKwAAAJ0nvAIAANB5wisAAACdJ7wCAADQecIrAAAAnSe8AgAA0HnCKwAAAJ0nvAIAANB5wisAAACdJ7wCAADQecIrAAAAnTdz1AUArJFjNht1BQAATAMjrwAAAHSe8AoAAEDnCa8AAAB0nvAKAABA5wmvAAAAdJ7wCgAAQOcJrwAAAHSe8AoAAEDnCa8AAAB0nvAKAABA5wmvAAAAdJ7wCgAAQOcJrwAAAHSe8AoAAEDnCa8AAAB0nvAKAABA5wmvAAAAdJ7wCgAAQOcJrwAAAHSe8AoAAEDnCa8AAAB0nvAKAABA5wmvAAAAdJ7wCgAAQOcJrwAAAHTeSMNrVe1YVd+oqour6qKqOmKU9QAAANBNM0fc/31J/qa19qOq2iTJBVV1Tmvt4hHXBQAAQIeMdOS1tXZDa+1H/de3J7kkyfajrAkAAIDu6cw9r1U1P8kfJPnBiEsBAACgY0Z92XCSpKo2TvIfSV7XWvvNBMsPTXJoksydO3eaqwMAmDrzjzxr1CUwjRae8JxRlwDrjJGPvFbVrPSC62mttTMnWqe1dlJrbUFrbcGcOXOmt0AAAABGbtSzDVeSjyS5pLX2r6OsBQAAgO4a9cjrXkkOTvK0qrqw//WnI64JAACAjhnpPa+tte8kqVHWAAAAQPeNeuQVAAAAVkp4BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOk94BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOk94BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg84RXAAAAOk94BQAAoPOEVwAAADpPeAUAAKDzhFcAAAA6T3gFAACg82aOuoB10jGbjbqC7jvmtlFXsHZwLgEAQzb/yLNGXQLTaOEJzxl1CavNyCsAAACdJ7wCAADQecIrAAAAnSe8AgAA0HnCKwAAAJ0nvAIAANB5wisAAACdJ7wCAADQecIrAAAAnSe8AgAA0HnCKwAAAJ0nvAIAANB5wisAAACdJ7wCAADQecIrAAAAnSe8AgAA0HnCKwAAAJ0nvAIAANB5wisAAACdJ7wCAADQecIrAAAAnSe8AgAA0HnCKwAAAJ0nvAIAANB5wisAAACdN/LwWlXPrqpfVNXlVXXkqOsBAACge0YaXqtqRpL3JvmTJI9KcmBVPWqUNQEAANA9ox553TPJ5a21K1tr9yQ5Pcl+I64JAACAjhl1eN0+ybVj3l/XbwMAAIBlZo66gEFU1aFJDu2/XVJVvxhlPUyB/1dLX22ZZPEIK+H3k/OOif3vZ9NUc84x3ZxzHVH/NOoKpo1zbi2xlpyT8yZqHHV4XZRkxzHvd+i3PUBr7aQkJ01XUUyfqjq/tbZg1HXw+8V5x3RzzjHdnHNMN+cc02HUlw3/d5JdqmqnqnpQkgOSfGHENQEAANAxIx15ba3dV1WHJflKkhlJTm6tXTTKmgAAAOieUV82nNba2UnOHnUdjIzLwRkF5x3TzTnHdHPOMd2ccwxdtdZGXQMAAACs0KjveQUAAICVEl4BAADoPOGVoaqqzavqs1V1R1VdXVV/uYJ1n1pV36iq26pq4QTL5/eX31lVP6+qZwy1eNZaq3jeVVX9U1X9qv/1T1VVY5a3/n6W9L8+PD1HQZcNeo4NcH7tUVUX9D/XLqiqPabtIFjrTOF553ONgazCOedvOKaF8MqwvTfJPUm2TvJXSd5fVbtNsu4dSU5O8sZJln8qyY+TbJHkzUk+U1VzprZc1hGrct4dmuT5SR6TZPckz03yynHrPKa1tnH/6+XDKZm1zKDn2KTnV/8RcZ9PcmqShyT5WJLP99thImt83o3hc41BDHrO+RuOaWHCJoamqjZK8uskj26tXdpv+0SSRa21I1ew3TOSfLi1Nn9M28OT/E+SLVtrt/fbvp3ktNbaB4Z3FKxtVvW8q6rvJTmltXZS//3LkryitfaE/vuWZJfW2uXTdQx026qcYys6v6rqmUk+mmSH1v/HuKquSXJoa+3L03dErA2m6rzrv/e5xkqtzt9x/oZj2Iy8MkwPT3Lf0g+8vp8kmWwEbEV2S3Ll0g+9NdwX67ZVPe926y9f0brnVtWNVXVmVc2fskpZW63KObai82u3JD9dGlz7fjrJfmCqzrulfK6xMlP1d5y/4ZgywivDtHGS34xruy3JJqu5r9umaF+s21b1vBt/bt2WZOMx94c9Jcn8JI9Mcn2SL1XVyJ+RzUityjm2ovPL5xqrYqrOu8TnGoOZqr/jfNYxZYRXVltVfbM/6cNEX99JsiTJpuM22zTJ7cvvbaWmcl+sxYZw3o1ff9MkS5aOhrXWzm2t3dNauzXJEUl2SrLrVB4Ta51VOcdWdH75XGNVTNV553ONQU3VZ5TPOqaM8Mpqa63t01qrSb6enOTSJDOrapcxmz0myUWr0d1FSXauqrH/S7e6+2ItNoTz7qL+8kHWTZKWpFawnHXfqpxjKzq/Lkqy+9hZYNObXMfnGhOZqvNuIj7XmMhU/R3nbzimjPDK0LTW7khyZpK3VtVGVbVXkv2SfGKi9atqvapaP8ms3ttaf+msm/37LS5M8g/99j9L74+8/5iGQ2EtsqrnXZKPJ3lDVW1fVdsl+ZskpyRJVe1WvUeZzKiqjZP8S5JFSS4Z9nHQXat4jk16fiX5ZpLfJTm8qh5cVYf1278+zPpZO03VeedzjUGtyjnnbzimi/DKsL0myQZJfpneNOmvbq1dlCRV9UdVtWTMunsnuSvJ2Unm9l9/dczyA5IsSG/muxOSvLC1dvPQj4C10aqcdx9M8sX0ZkL8WZKz+m1J79EA/57ePT9XpneP2L6ttXun4RjotgnPsVU5v1pr96T3OJMXJ7k1ySFJnt9vh4ms8XkXn2usmkHPOX/DMS08KgcAAIDOM/IKAABA5wmvAAAAdJ7wCgAAQOcJrwAAAHSe8AoAAEDnCa8AAAB0nvAKwO+1qrqoqvYZcN1HVNWFVXV7VR1eVadU1duGWyEAkCQzR10AAIxSa223VVj9b5N8o7W2R5JU1SnDqAkAWJ6RVwAY3LwkF426iFGpKv/pDcDICK8A/F6rqoVV9Yz+62Oq6oyq+nj/0uCLqmpBf9nXkzw1yXuqaklVPXzcfl5SVd8Z19aq6mH91w+uqndU1TVVdVNVfaCqNhiz7n79S5J/U1VXVNWz++2bVdVHquqGqlpUVW+rqhmTHMueVXV+fx83VdW/jln25Kr6XlXdWlXXVtVLxuz/41V1c1VdXVV/V1XrjTmm71bViVX1qyTHrOw4AGBYhFcAeKDnJTk9yewkX0jyniRprT0tybeTHNZa27i1dukq7veEJA9PskeShyXZPslbkl7oTPLxJG/s97t3koX97U5Jcl9/mz9I8swkL5+kj3cmeWdrbdMkD01yRn//85L8Z5J3J5nTr+HC/jbvTrJZkp2TPCXJi5O8dMw+H5/kyiRbJ/nHFR0HAAyT8AoAD/Sd1trZrbXfJflEkses6Q6rqpIcmuT1rbVbWmu3JzkuyQH9VV6W5OTW2jmttftba4taaz+vqq2T/GmS17XW7mit/TLJiWO2G+/eJA+rqi1ba0taa9/vt/9lkv9qrX2qtXZva+1XrbUL+yO4ByQ5qrV2e2ttYZJ/SXLwmH1e31p7d2vtviR3r+Q4AGBo3LsCAA9045jXdyZZv6pm9sPb6pqTZMMkF/RybJKkkiy9/HfHJGdPsN28JLOS3DBmu/WSXDtJPy9L8tYkP6+qq5L8v9bal/r7v2KC9bfs7//qMW1XpzeautTYvlZ2HAAwNMIrAEyNO9ILdkmSqtpmzLLFSe5KsltrbdEE216b3mW+E7X/NsmWg4Tn1tplSQ7s37P6giSfqaot+vvZc4JNFqc3WjsvycX9trlJxtbYVuE4AGBoXDYMAFPjJ0l2q6o9qmr9JMcsXdBauz/Jh5KcWFVbJUlVbV9Vz+qv8pEkL62qp1fVev1lj2yt3ZDkq0n+pao27S97aFU9ZaICquqgqprT7+/WfvP9SU5L8oyq+ouqmllVW1TVHv1Lo89I8o9VtUn/3tg3JDl1ov0PcBwAMDTCKwBMgf4ETm9N8l9JLkvynXGrvCnJ5Um+X1W/6a/3iP62P0xvkqQTk9yW5FvpjYYmvQmUHpTeyOivk3wmybaTlPHsJBdV1ZL0Jm86oLV2V2vtmvTunf2bJLekN1nT0nt5X5veqPGV/Zo/meTkFRzqpMcBAMNUrbWVrwUAAAAjZOQVAACAzhNeAQAA6DzhFQAAgM4TXgEAAOg84RUAAIDOE14BAADoPOEVAACAzhNeAQAA6DzhFQAAgM77/wHMtuB2w3mu0wAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -457,8 +456,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average influence of corrupted points: -0.03815854208794334\n", - "Average influence of other points: 0.030863110017283625\n" + "Average influence of corrupted points: -0.0382529221316219\n", + "Average influence of other points: 0.030890610494236293\n" ] } ], @@ -498,7 +497,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "610cac483f224201a4f972f0a3110b13", + "model_id": "3c5bd03e730c4062bb4ed7dc219b06d0", "version_major": 2, "version_minor": 0 }, @@ -512,7 +511,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f8de99035b9d4ab4b7f7116ae77cc51d", + "model_id": "f2d0066f551e4cbab6bf6c27772bee77", "version_major": 2, "version_minor": 0 }, @@ -526,8 +525,7 @@ ], "source": [ "feature_influences = compute_influences(\n", - " nn_model,\n", - " F.cross_entropy,\n", + " TwiceDifferentiable(nn_model, F.cross_entropy),\n", " *train_data,\n", " *test_data,\n", " influence_type=\"perturbation\",\n", @@ -545,7 +543,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -592,8 +590,7 @@ "outputs": [], "source": [ "cg_train_influences = compute_influences(\n", - " nn_model,\n", - " F.cross_entropy,\n", + " TwiceDifferentiable(nn_model, F.cross_entropy),\n", " *train_data,\n", " *test_data,\n", " influence_type=\"up\",\n", @@ -621,7 +618,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Percentage error of cg over direct method:0.0007001312394795379 %\n" + "Percentage error of cg over direct method:0.0007946275658844653 %\n" ] } ], diff --git a/notebooks/shapley_knn_flowers.ipynb b/notebooks/shapley_knn_flowers.ipynb index 787edbeb0..549ce205f 100644 --- a/notebooks/shapley_knn_flowers.ipynb +++ b/notebooks/shapley_knn_flowers.ipynb @@ -68,7 +68,7 @@ "import numpy as np\n", "import sklearn as sk\n", "from copy import deepcopy\n", - "from notebook_support import plot_iris\n", + "from support.common import plot_iris\n", "\n", "plt.rcParams[\"figure.figsize\"] = (20, 8)\n", "plt.rcParams[\"font.size\"] = 12\n", @@ -142,7 +142,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "25db2986aef24b08ae9ccfccb2c0c6df", + "model_id": "56f410b858c848dc9cc41eb01b5e16c0", "version_major": 2, "version_minor": 0 }, @@ -181,7 +181,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJIAAAIfCAYAAAArE/YjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAADOYklEQVR4nOzdd5hcZfnG8e97pmwv6b3TEiAE2ASSAAlIkS4CUqSj4E+pglIFRBRBLGBHREDAgoj03juEThICgfSQutm+U8/z+2MmS7ZmyJbZcn+ua67MnPKe+8zuyZ555j3vcWaGiIiIiIiIiIjI5njZDiAiIiIiIiIiIj2DCkkiIiIiIiIiIpIRFZJERERERERERCQjKiSJiIiIiIiIiEhGVEgSEREREREREZGMqJAkIiIiIiIiIiIZUSFJREREOo1zbqxzzpxze3SHdlpo9zbn3FOtve7gbZ3inEu09roTtneVc25hZ7UvIiIifZMKSSIiItKqziysdFPnAkdnurBzLuGcOyXDxf8FjNiSUJvJsEe6yDa2yawbgN07ensiIiLStwWzHUBERESkuzCzyo5u0znngKCZ1QP1Hd1+a8ysBqjpqu2JiIhI36AeSSIiIrLFnHPHO+ded85VOufWOeceds5t08KiY51zTzvn6p1znznnjm3SzpB076e1zrlq59zLzrm9NrPtS9NtRdPrPe6cy2tj+f7OuX8552qdc6udc9cArskyTS912z7dbkV6vfnOuRPT8xYDAeBv6R5Blp5+Srqn0t7OuXeAKLBva5eyOef2dc7Ndc5F0u/llE3mNVvHOTcyvb3Z6V5IL6ZnLUpPfy69XLNL25xzJzvn5jnnYs655c65a5xzwU3mP+ecu8U59yPn3CrnXLlz7g7nXGGrPwgRERHpU1RIEhERkfbIAa4BdgH2A5LAw865cJPlrgduBaYAdwN3Oed2BkgXf54FioADgZ2BR4AnnXMTW9qoc+7rwMWkLkXbOr3tRzeT9a/ArsChwD7AWOCIzazzD2A9MAPYEfg+sCE9b2p6f88DhqUfG3nAdenltwPmtNK+R+q9+S4wDVhL6v1rtSDWxDLg8PTzaekMX29pQefcwaR+Bn8HdgAuAL4HXNlk0aOA/sBs4FjgEOCiDPOIiIhIL6dL20RERGSLmdnfNn2dHi9oPakiy8ubzPqrmd2Vfn65c24fUkWWE4FjgGLgGDPb2Pvmp865rwBnkirUNDUGWAU8ZmZxYCnwbms5nXNbAV8D9jezZ9LTTgMWbWYXxwC/MrN56defbZxhZmtTV61RaWarmm4SuMDMXmyY4BwtcMAPzOz59DInkioOHU+q8NUmM0s658rTL9e2kGNTFwP3mtm16dcfO+eGAj93zv3EzGLp6UvM7Pz084+cc/8C9gV+tLk8IiIi0vupR5KIiIhsMefcFOfcfc65Rc65alIFHUgVYDb1apPXLwPbp59PBYYCFc65mo0PYE9SvY1a8m8gBCxJX452onOuqI2ok9L/vrJxQrpw8mZb+0dqwOpb0pd8XeWc22Uzy29qc21v1PDemNkGYD5fvDcdaXvghSbTngdygQmbTHuvyTIrgSGdkEdERER6IBWSREREZIs45/KBJwADTiV1adXU9Ouml7a1xSNVPJnS5DER+HZLK5jZClKXjJ0GrCHVW2aBc27Ul92PtpjZT4BtSBWudgBeS4+ttDlJM4t0QAS/hWmhDmi3LbEmrw2dM4qIiEiaTgpERERkS00EBgGXmdlzZjYf6EeTAazTmt6Gfgaw8XKxOcB4oMrMFjZ5rGxt42YWNbPHzOyHpMYvyid1+VpLNm5rxsYJ6XGcpra5h6ntfGZmfzCzo4ArgP/bZHaM1IDb7dHw3jjnSkm9rxvzrgECzrlNewQ17RW1sfCzuRxzgaYDmM8idSe5T79EXhEREenDNEaSiIiIbE7hpncSS4sAS0jdkexs59wvSQ1e/XNSPViaOt059xGpotEJwHTg7PS8u4DzSQ0yfRnwMalLqfYB5pvZ/5o25pw7ndQXYm8AFcBXSA3WPa/psgBmttA59wDwe+fcmcBqUmMGtXo5XPpOZdcB95IaS6kU+GqTbSwC9nbOPQrEzGxda+21woDrnXMbB/H+KVBNakBy0vtXTWoco5+RugTtiiZtLCHVc+mg9HhGUTOrbGFb1wIPOucuBv5LqtfXVcAvNxkfSURERKRN6pEkIiIim7Mb8E6Tx//SRZMTSN0xbS6p8YQupOXLsS4GzgDeJzXA9glm9jZA+hKwWaSKTH8jVUj6L6lL5Za0kmkDqcvpniN1Wdz3gTPM7Ok29uM0UgNyP0RqbKAVwH1tLJ8g1cPqr+ltPE6qAHX8JstcQOpOcItJ3XHty/KBS4E/k9r/ocDBZlYHYGblwHGkei29T+oSvh9u2oCZrQYuIfUefw7c39KGzOwRUu/BycCHwK+BPwA/3oLcIiIi0kc5s5a+NBQREREREREREWlMPZJERERERERERCQjKiSJiIiIiIiIiEhGVEgSEREREREREZGMqJAkIiIiIiIiIiIZUSFJREREREREREQyokKSiIiIiIiIiIhkRIUkERERERERERHJiApJIiIiIiIiIiKSERWSREREREREREQkIyokiYiIiIiIiIhIRlRIEhERERERERGRjKiQJCIiIiIiIiIiGVEhSUREREREREREMqJCkoiIiIiIiIiIZESFJBERERERERERyYgKSSIiIiIiIiIikhEVkkREREREREREJCMqJImIiIiIiIiISEZUSBIRERERERERkYyokCQiIiIiIiIiIhlRIUlERERERERERDKiQpKIiIiIiIiIiGREhSQREREREREREcmICkkiIiIiIiIiIpIRFZJERERERERERCQjKiSJiIiIiIiIiEhGVEgSEREREREREZGMqJAkIiIiIiIiIiIZUSFJREREREREREQyokKSiIiIiIiIiIhkRIUkERERERERERHJiApJIiIiIiIiIiKSERWSREREREREREQkIyokiYiIiIiIiIhIRlRIEhERERERERGRjKiQJCIiIiIiIiIiGVEhSUREREREREREMqJCkoiIiIiIiIiIZESFJBERERERERERyYgKSSIiIiIiIiIikhEVkkREREREREREJCMqJImIiIiIiIiISEZUSBIRERERERERkYyokCQiIiIiIiIiIhlRIUlERERERERERDISzHaA9hg4cKCNHTs22zFERESkk7z11lvrzGxQtnNIYzoHExER6d3aOgfr0YWksWPHMmfOnGzHEBERkU7inFuS7QzSnM7BREREere2zsF0aZuIiIiIiIiIiGREhSQREREREREREcmICkkiIiIiIiIiIpIRFZJERERERERERCQjPXqwbRERkS0Rj8dZvnw5kUgk21EEyM3NZeTIkYRCoWxHkXbSsdW9BAIBSktLGThwIJ6n749FRKRjqJAkIiJ9zvLlyykqKmLs2LE457Idp08zM9avX8/y5csZN25ctuNIO+nY6j7MjHg8zurVq1m+fDmjR4/OdiQREekl9NWEiIj0OZFIhAEDBuiDbjfgnGPAgAHqwdJL6NjqPpxzhMNhRowYQW1tbbbjiIhIL6JCkoiI9En6oNt96GfRu+jn2b3okjYREelo+ssiIiIiIiIiIiIZUSFJREREREREREQyokKSiIjIFlqwYAFTpkyhqKiIm266iVNOOYXLL78827FEejwdWyIiIt2XCkkiIiJb6Prrr2fvvfemurqac845J9txWjR27FieeuqpbMcQ+VJ0bImIiHRfKiSJiIhsoSVLlrD99ttnOwaQutW37/vZjiHSIXRsiYiIdF8qJImIiGyBffbZh2effZazzjqLwsJCPv7442bL/OUvf2Grrbaif//+HHbYYaxcuRKAK6+8krPPPhuAeDxOQUEBP/jBDwCor68nNzeX8vJyAF577TVmzJhBaWkpO+20E88991xD+7Nnz+ayyy5j5syZ5Ofn89lnnzXa/oknnsjSpUs59NBDKSws5Prrr+fggw/mt7/9baPlJk+ezH333Qek7rh10003MX78eAYOHMgPfvCDRh+ib731ViZOnEi/fv044IADWLJkSTvfSZHGdGzp2BIRkW7OzHrsY9dddzUREZEva968eR3SzqxZs+wvf/lLw+uTTz7ZLrvsMjMze/rpp23AgAH21ltvWSQSsbPOOsv23HPPhnk77LCDmZm9/PLLNn78eJs2bVrDvMmTJ5uZ2fLly61///728MMPWzKZtCeeeML69+9va9asadj+qFGj7MMPP7R4PG6xWKxZxjFjxtiTTz7Z8Ppf//pXw7bMzN59913r37+/RaNRMzMDbPbs2bZ+/XpbsmSJbb311g37+L///c8mTJhg8+bNs3g8bj/5yU9s+vTpHfJetvYzAeZYNzjn0COzczAdW93v2DLruJ+LiIj0HW2dg6lHkoiISCe46667OO2009hll13Iycnh2muv5dVXX2Xx4sVMnz6dTz75hPXr1/PCCy9w+umns2LFCmpqanj++eeZNWsWAHfeeScHHXQQBx10EJ7nsd9++1FWVsYjjzzSsJ1TTjmF7bffnmAwSCgU2myuww47jI8//phPPvkEgL///e8cc8wxhMPhhmUuuugi+vfvz+jRoznvvPP4xz/+AcCf/vQnLrnkEiZOnEgwGOTSSy/l3XffVc8J6VI6tkRERLKrSwtJzrmAc+4d59xDLcw7xTm31jn3bvrxra7MJiIi0pFWrlzJmDFjGl4XFhYyYMAAVqxYQV5eHmVlZTz//PO88MILzJo1ixkzZvDyyy83+rC7ZMkS7rnnHkpLSxseL730Ep9//nlDu6NGjfpSuXJzcznmmGO488478X2ff/zjH5x44omNltm0zTFjxjRcNrRkyRLOPffchiz9+/fHzFixYsWXfn9EtpSOLRERkewKdvH2zgXmA8WtzP+XmZ3VhXlEREQ6xfDhwxv1JqitrWX9+vWMGDECgFmzZvHMM8/wzjvvMHXqVGbNmsXjjz/OG2+8wV577QWkPnSeeOKJ/OUvf2l1O865NnO0NP/kk0/mxBNPZI899iA/P5/p06c3mr9s2bKGgY6XLl3K8OHDG/JcdtllfPOb38zgHRDpHDq2REREsqvLeiQ550YCBwO3dNU2RUREsuW4447jb3/7G++++y7RaJRLL72U3XbbjbFjxwKpD7t33HEHkyZNIhwOM3v2bG655RbGjRvHoEGDADjhhBN48MEHefzxx0kmk0QiEZ577jmWL1+ecY4hQ4Y0Gyh4+vTpeJ7HBRdc0KzHBMAvfvELNmzYwLJly7jxxhs55phjAPjOd77Dtddey9y5cwGorKzknnvu2ZK3R2SL6dgSERHJrq68tO03wA+Btu6feqRz7n3n3H+ccy32J3bOneGcm+Ocm7N27drOyCkiItJu++67Lz/5yU848sgjGTZsGJ9++in//Oc/G+bPmDGD+vr6hh4SkyZNIjc3t+E1pHop3H///fzsZz9j0KBBjBo1il/84hdf6lbkl1xyCddccw2lpaXccMMNDdNPOukkPvjgA0444YRm6xx++OHsuuuuTJkyhYMPPpjTTz8dgCOOOIKLLrqIY489luLiYnbYYQceffTRL/3eiLSHji0REZHscqnBuDt5I84dAhxkZt91zs0GLjSzQ5osMwCoMbOoc+5M4Bgz26etdsvKymzOnDmdFVtERHqp+fPnM3HixGzHyKo77riDm2++mZdeeqnRdOccn3zyCVtttVWX5mntZ+Kce8vMyro0jGxWa+dgOra637EF+rmIiMiX19Y5WFf1SJoJHOacWwz8E9jHOXfnpguY2Xozi6Zf3gLs2kXZRERE+pS6ujr+8Ic/cMYZZ2Q7ikivomNLRET6gi4pJJnZJWY20szGAscCz5hZo/6+zrlhm7w8jNSg3CIiItKBHn/8cQYNGsSQIUM4/vjjsx1HpNfQsSUiIn1FV9+1rRHn3NXAHDN7ADjHOXcYkADKgVOymU1ERKQ3OuCAA6itrW11fldc8i7SG+nYEhGRvqLLC0lm9hzwXPr5FZtMvwS4pKvziIiIiIiIiIhIZrryrm0iIiIiIiIiItKDqZAkIiIiIiIiIiIZUSFJREREREREREQyokKSiIiIiIiIiIhkRIUkERERERERERHJiApJIn1IbVUd7z03l/mvf0Iykcx2HBHpIIsXL8Y5RyKRyHYUkV5Fx5aISMexxCIs+gqWXJntKNJOwWwHEJGu8fw9r3L7lf/EDDCjsLSAC2/9LmMmjcp2NJEe441H3+bfNzzAqkVrGDpuMN+48DCmHbhLtmOJtMo5Nwq4AxgCGHCzmd3YZJnZwP3AovSk/5rZ1V0YE9DxJSLSW5lfh1VdAfH3SPVlSWI5s3FFF+FcKNvxZAuoR5JIH7BswQpuvexuAqEgeYW55BXlUV1Ryy9O/QOJuL5lFcnEG4++ze/O/ivln1dQ1L+Q8s8r+N3Zf+WNR9/u8G1dd911jBgxgqKiIrbddluefvppfN/n5z//ORMmTGDAgAF84xvfoLy8HIC99toLgNLSUgoLC3n11VfxfZ9rrrmGMWPGMHjwYE466SQqKysBiEQinHDCCQwYMIDS0lKmTp3K6tWrAfjb3/7GxIkTKSoqYvz48fz5z3/u8P2TLpUALjCzScDuwPecc5NaWO5FM5uSfmSliNQVx5eOLRGRrme1f4D420AhuILUv9FnsLp7sh1NtpAKSSJ9wEv3vYGf9AmFv+iEmF+UR01FLR+9sTCLyUR6jn/f8ADBcIjcghycc+QW5BAMh/j3DQ906HYWLFjA7373O958802qq6t5/PHHGTt2LL/97W/53//+x/PPP8/KlSvp168f3/ve9wB44YUXAKioqKCmpobp06dz2223cdttt/Hss8/y2WefUVNTw1lnnQXA7bffTmVlJcuWLWP9+vX86U9/Ii8vD4DBgwfz0EMPUVVVxd/+9jfOP/983n6744tl0jXM7HMzezv9vBqYD4zIbqrmuuL40rElItL1zJIQeQIoAudSE50H5EHkf1lMJu2hQpJIH1BbWQeu+XTnIFIb7fpAIj3QqkVryMkPN5qWkx9m9aK1HbqdQCBANBpl3rx5xONxxo4dy4QJE/jTn/7ET3/6U0aOHElOTg5XXXUV//nPf1odu+Wuu+7i+9//PuPHj6ewsJBrr72Wf/7znyQSCUKhEOvXr2fhwoUEAgF23XVXiouLATj44IOZMGECzjlmzZrF/vvvz4svvtih+yjZ4ZwbC+wMvN7C7OnOufecc48657ZvZf0znHNznHNz1q7t2N/7rji+dGyJiGRDklTn2KalhwBYXRbySEdQIUmkD9hl38k45zCzhmmJeBIz2KZsfBaTifQcQ8cNJloXazQtWhdjyLhBHbqdrbbait/85jdcddVVDB48mGOPPZaVK1eyZMkSjjjiCEpLSyktLWXixIkEAoGGy2aaWrlyJWPGjGl4PWbMGBKJBKtXr+bEE0/kgAMO4Nhjj2X48OH88Ic/JB6PA/Doo4+y++67079/f0pLS3nkkUdYt25dh+6jdD3nXCFwL3CemVU1mf02MMbMdgJ+C/yvpTbM7GYzKzOzskGDOvb3viuOLx1bIiJdz7kwBHcAq24ypwbCM7OSSdpPhSSRPmCn2ZPYee8dqK2so2ZDLdXlNUTrohx/2dcp7l+U7XgiPcI3LjyMRCxOpDaKmRGpjZKIxfnGhYd1+LaOP/54XnrpJZYsWYJzjosuuohRo0bx6KOPUlFR0fCIRCKMGDEC55p3ORw+fDhLlixpeL106VKCwSBDhgwhFApx5ZVXMm/ePF555RUeeugh7rjjDqLRKEceeSQXXnghq1evpqKigoMOOqhREVp6HpcayfRe4C4z+2/T+WZWZWY16eePACHn3MCuzNhVx5eOLRGRrueKzgUvD6wK/OrUv64/ruC0bEeTLaRCkkgfEAgEOOeP3+ac33+b6YeVse8Je3Hlfy5k/5NmZzuaSI8x7cBdOOu3p9N/WCk15bX0H1bKWb89vcPvKrVgwQKeeeYZotEoubm55OXl4Xke3/nOd7jssssaPsCuXbuW+++/H4BBgwbheR6fffZZQzvHHXccv/71r1m0aBE1NTVceumlHHPMMQSDQZ599lk++OADkskkxcXFhEIhPM8jFosRjUYZNGgQwWCQRx99lCeeeKJD90+6lktVQv4KzDezX7WyzND0cjjnppE6P1zfdSm75vjSsSUikh0uOAHX7zbIPwVy94SC7+D6/w0XGJLtaLKFgptfRER6g0AgQNn+O1G2/07ZjiLSY007cJdOvx15NBrl4osvZv78+YRCIWbMmMHNN9/M0KFDMTP2339/Vq5cyeDBgznmmGM4/PDDyc/P57LLLmPmzJnE43Eee+wxTjvtNFauXMlee+1FJBLhgAMO4Le//S0Aq1at4jvf+Q7Lly+nsLCQY445hhNPPJFgMMhNN93EN77xDaLRKIceeiiHHdbxPa6kS80ETgQ+cM69m552KTAawMz+BBwF/J9zLgHUA8daFrrKdPbxpWNLRCR7XGAAruCEbMeQDuJ6cpfasrIymzNnTrZjiIhIDzN//nwmTpyY7RiyidZ+Js65t8ysLAuRpA2tnYPp2Oqe9HMREZEvq61zMF3aJiIiIiIiIiIiGVEhSUREREREREREMqJCkoiIiIiIiIiIZESFJBERERERERERyYgKSSIiIiIiIiIikhEVkkREREREREREJCMqJImIiIiIiIiISEZUSBIRERERERERkYyokCQiItLHFBYW8tlnn7WrjbFjx/LUU091UCKR3kPHl4iI9HbBbAcQERGRrlVTU5PtCCK9lo4vERHp7VRIEhERydBzixdx89tvsryqkpHFJZyxy1Rmjx2X7VjNJBIJgsHu+Se+O2eT7NLx1X7dOZuIiPQeurRNREQkA88tXsSVzz3N2tpaSnJyWVtby5XPPc1zixd12Dauu+46jjrqqEbTzj33XM455xwqKys5/fTTGTZsGCNGjODyyy8nmUwCcNtttzFz5kzOP/98BgwYwFVXXcXChQuZNWsWJSUlDBw4kGOOOaahTeccCxcuBKC+vp4LLriAMWPGUFJSwh577EF9fT0ADzzwANtvvz2lpaXMnj2b+fPnt5g7Go1y3nnnMXz4cIYPH855551HNBpNvW/PPcfIkSO57rrrGDp0KKeeemqHvV/Se+j40vElIiI9hwpJIiIiGbj57TcJBwLkhUI458gLhQgHAtz89psdto1jjz2WRx55hOrqagCSyST//ve/Of744znllFMIBoMsXLiQd955hyeeeIJbbrmlYd3XX3+d8ePHs3r1ai677DJ+9KMfsf/++7NhwwaWL1/O2Wef3eI2L7zwQt566y1eeeUVysvLuf766/E8j48//pjjjjuO3/zmN6xdu5aDDjqIQw89lFgs1qyNn/70p7z22mu8++67vPfee7zxxhtcc801DfNXrVpFeXk5S5Ys4eabb+6w90t6Dx1fOr5ERKTnUCFJREQkA8urKsltcslIbjDI8qrKDtvGmDFj2GWXXbjvvvsAeOaZZ8jPz2fcuHE88sgj/OY3v6GgoIDBgwdz/vnn889//rNh3eHDh3P22WcTDAbJy8sjFAqxZMkSVq5cSW5uLnvssUez7fm+z6233sqNN97IiBEjCAQCzJgxg5ycHP71r39x8MEHs99++xEKhbjwwgupr6/nlVdeadbOXXfdxRVXXMHgwYMZNGgQV155JX//+98b5nuex49//GNycnLIy8vrsPdLeg8dXzq+RESk51AhSUREJAMji0uIJBKNpkUSCUYWl3Todo4//nj+8Y9/AHD33Xdz/PHHs2TJEuLxOMOGDaO0tJTS0lLOPPNM1qxZ07DeqFGjGrVz/fXXY2ZMmzaN7bffnltvvbXZttatW0ckEmHChAnN5q1cuZIxY8Y0vPY8j1GjRrFixYrNLjtmzBhWrlzZ8HrQoEHk5uZ+iXdB+hodXzq+RESk51AhSUREJANn7DKVWDJJfTyOmVEfjxNLJjljl6kdup2jjz6a5557juXLl3Pfffdx/PHHM2rUKHJycli3bh0VFRVUVFRQVVXF3LlzG9ZzzjVqZ+jQofzlL39h5cqV/PnPf+a73/1uw7gtGw0cOJDc3Fw+/fTTZjmGDx/OkiVLGl6bGcuWLWPEiBGbXXbp0qUMHz681WwiTen40vElIiI9hwpJIiIiGZg9dhw/nv0VBhUUUBmNMKiggB/P/kqH31Vq0KBBzJ49m1NPPZVx48YxceJEhg0bxv77788FF1xAVVUVvu/z6aef8vzzz7fazj333MPy5csB6NevH845PK/xn33P8zjttNP4/ve/z8qVK0kmk7z66qtEo1G+8Y1v8PDDD/P0008Tj8f55S9/SU5ODjNmzGi2reOOO45rrrmGtWvXsm7dOq6++mpOOOGEDn1fpHfT8aXjS0REeg7dH1RERCRDs8eO65LbkR9//PGcdNJJXH/99Q3T7rjjDi6++GImTZpEdXU148eP56KLLmq1jTfffJPzzjuPyspKhgwZwo033sj48eObLXfDDTdwySWXMHXqVGpqathpp514/PHH2Xbbbbnzzjs5++yzWbFiBVOmTOHBBx8kHA43a+Pyyy+nqqqKyZMnA6leH5dffnkHvBPSl+j40vElIiI9gzOzbGfYYmVlZTZnzpxsxxARkR5m/vz5TJw4MdsxZBOt/Uycc2+ZWVkWIkkbWjsH07HVPennIiIiX1Zb52C6tE1ERERERERERDKiQpJINxOpi7JuZTnJRDLbUUREREREpIOYX475Fa3Mq8KS62jpiiHza7Hkasz8Tk7Yfqmsa3pE1q5mZlhyfau/Az2JxkgS6SYS8QT/uv5/PHXni5hv5BbkcNwlX2fW0dOzHU1ERERERLaQJRZh1T+HxKeAYaEdcEUX4wLDUsWlqusgPgdwEBgFRT/EhSZiFsFqboLIk6mGvBKs4Fy83D2zuTstMqvHqm+C6FOpCV4pVnAeXu7M7AbrJiyxMPVzTi5KvQ5NxhVdhAsMyXKyLaMeSSLdxL9/8QCP3fos4dwQ+cV5JBJJ/nrJXbzzzAfZjiYiIiIiIlvA/Bqs4nyIfwoUAcUQ/xCrOB/fj2AVP4TYnPS8IkiswCouTPVcqb4B6h8D8sEVgV8H1Vdj8XlZ3aeWWNX1EHmcL7LWQvVVWPyjbEfLOvMrsYrvQ2IxDT/n+HtYxQWY9cyrUFRIEukGYtE4T/39efKL8wgEAwCEc0J4QY8H//h4ltOJiIiIiMgWib0EVgNeMTiXfpSAvx7q/wvJJeCKwXmpeV4hEMHq/wvR59PzUp8PcLlgPlZ3T1Z3qSlLrofYiy1nre9eWbPBIs+B1YFX1OR3YA3E3852vC2iQpJIN1BbWUcy4TcUkTYK5YRYu7w8S6lERERERKQ9LLkaLNHSDEguB9KFhUbzSF8C5aUKTJtyYUiu7KS0W8g2AIGekTUb/FWpn3fzGamCYg+kQpJIN1AysIii/gVE62ONpkdrI2w7dUKWUomIiIiISHu44LbggrDpINpmqaJLeCrgQ9OBqZ2D0HTAA4s3nmdRCE/p5NRfUmAE4FrOGpqSjUTdigtNTPXUavo7ABDcKjuh2kmFJJFuwPM8jr/sSBLROLVVdcSjcarLawjn5XDEOQdlO56IiIiIiGyJ8FQIbgdWCRYBqwcqITwNlzMbcvcHqlOXPlkUrAICI3F5+0HBaanpfs0X87xiXN6RWd2lppzLg4JTgTqw2lRWvwK8km6XNSvC0yEwIfXz2/g7YJUQnolTIUlE2mPGYVP5wW1nsd3UrSgozmfG4VO5+n8/ZMRWw7IdTUS6gQMPPJDbb799i9cvLCzks88+6/BlRXoDHV8i0lmcC+BKf5EqCgUGQmAoFHwXV3wVzjlc4YVQeB4ERoLXD/KPx5X+Fudy8fKPxpX8GELbpMZYyj0Y1+9PuMDgbO9WMy7vG7jiH0Nw61TWvEPTWQdmO1rWORfClf4KCk6BwAAIDIPCs3DFl2c72hYLZjuAiHxhh5nbscPM7bIdQ0S6oUcffbRd69fU1HTKsiK9gY4vEelMzuXhCk6AghNamOfh8g6FvENbXjdnD1zOHp0dsd2cc9BDsmaD8wpwBSdDwcnZjtIhVEgSERHJkB95HupugcRyCI6E/G/h5c7KdiwSiQTBoP6kS8+m40tERKRn0KVtIiIiGfAjz0P11ZBcB6409W/11anpHeS6667jqKOOajTt3HPP5ZxzzmH27NnccsstANx2223MnDmT888/nwEDBnDVVVexfv16Dj30UIqLi5k6dSqXX345e+zxxbeCzjkWLlwIwCmnnML3vvc9Dj74YIqKithtt9349NNPW1y2vr6eCy64gDFjxlBSUsIee+xBfX09AEcffTRDhw6lpKSEvfbai7lz53bYeyF9i44vHV8iItJzqJAkIiKSibpbgDC4vNTdVFxe6nXdLR22iWOPPZZHHnmE6upqAJLJJP/+9785/vjjmy37+uuvM378eFavXs1ll13G9773PQoKCli1ahW33377Zsd7+ec//8mVV17Jhg0b2GqrrbjssstaXO7CCy/krbfe4pVXXqG8vJzrr78ez0udPhx44IF88sknrFmzhl122YVvfvOb7XwHpM/S8aXjS0REegwVkkRERDKRWA7kNpmYC4kVHbaJMWPGsMsuu3DfffcB8Mwzz5Cfn8/uu+/ebNnhw4dz9tlnEwwGCYfD3Hvvvfz4xz8mPz+fSZMmcfLJbV+Df8QRRzBt2jSCwSDf/OY3effdd5st4/s+t956KzfeeCMjRowgEAgwY8YMcnJyADjttNMoKioiJyeHq666ivfee4/Kysr2vxHS9+j40vElIiI9hgpJIiIimQiOBCJNJkYgOKJDN3P88cfzj3/8A4C77767xd4SAKNGjWp4vnbtWhKJRKNpmz5vydChQxue5+fntzgA8Lp164hEIkyYMKHZvGQyycUXX8yECRMoLi5m7NixDeuIfGk6vhrR8SUiIt2ZCkkiIiKZyP8WEAOrB7PUv8TS0zvO0UcfzXPPPcfy5cu57777Wv2g65xreD5o0CCCwSDLly9vmLZs2bJ2Zxk4cCC5ubmNxnfZ6O677+b+++/nqaeeorKyksWLFwNgZu3ervRBOr4a0fElIiLdmQpJIqS6lycTyWzHEJFuzMudBUVXQGAgWGXq36IrOvyuUoMGDWL27NmceuqpjBs3jokTJ252nUAgwNe//nWuuuoq6urq+Oijj7jjjjvancXzPE477TS+//3vs3LlSpLJJK+++irRaJTq6mpycnIYMGAAdXV1XHrppe3envRdOr50fIlI1zOLY+ZnO0aPY2aYxfp0cV+FJOnT6msj/O1H/+Rb25/Pyduczc+++RuWf7wy27FEpJvycmfh9f873uBnUv920q3Jjz/+eJ566qlWe0u05He/+x2VlZUMHTqUE088keOOO65hrJX2uOGGG9hxxx2ZOnUq/fv356KLLsL3fU466STGjBnDiBEjmDRpUovjzIh8GTq+dHyJSNew+Mf4G87G1u6PrTsYv+aPmMWyHatH8KOvYBtOwtYegK3/On7df/pkQcn15J0uKyuzOXPmZDuG9GDXnfxbPnzpI/KL8/A8j9qqOvIKc7nuiR9ROqgk2/FEpJPMnz8/o54IPdlFF13UcIepnqC1n4lz7i0zK8tCJGlDa+dgfeHYgt5zfIlI32PJz7Hy08Hi4AqBJFgN5OyNV/KjbMfr1iz2Nlb5QyAI5NFwSXbhmXj5x2Q5Xcdr6xxMPZKkz1r+8UrmvbKAwn4FBIIBnOcoLC2gvrqeF+55NdvxRES+lI8++oj3338fM+ONN97gr3/9K0cccUS2Y4n0Cjq+RKS3sPr7waLgFYFz4ILgiiH2PJZcne143ZrV3Q7mgctPv3c5qed1d2KWyHa8LhXMdgCRbFmzdB1eMNBoQE0A53ks//jzLKUSEdky1dXVHHfccaxcuZIhQ4ZwwQUXcPjhh2c7lkivoONLRHqNxKep4tGmnAcWhOQqCAzJTq6eILE0VTzalAuDVaV6dbnSrMTKBhWSpM8aNmEIfsLHfMN5XxSTzIzxk8dkMZmIyJc3depUFi5cmO0YIr2Sji8R6TVCkyD2Nmz6Xbr5QAICI7OVqmcIbg2xd8CFvphmUXBFqUcfokvbpM8aNm4Iux6wE9UbaohH4yQTSarLayjuX8geX98t2/FEpJP15DECexv9LHoX/Ty7F/08RGRTLvdQ8ApSd8i0ZKoQYlWQexAuMCDb8bo1V3By6pI2vzr93tWDRaDgdJwLZDtel1IhSfq0//vVyRx53iGEc8Mk40mmH7orV/33BxSWFmQ7moh0okAgQDwez3YMSYvH4wSD6iTdG+jY6n7q6+sJhUKbX1BE+gQXGIgr/R2EZwKxVFGp8Axc4bnZjtbtudD2uNIbILQdEE1dBlh8KV7eIdmO1uV01zYREelz1qxZQzQaZcSIEXievlPJJt/3WbFiBTk5OQwePLjZfN21rXtq7RxMx1b3YWbU19ezYsUKhgwZQnFxcbYjiYhID9LWOZi+/hMRkT5n4MCBLF++nAULFmQ7igAFBQUMHDgw2zGkA+jY6l5CoZCKSCIi0uFUSBIRkT7H8zxGjx6d7RgivY6OLRERkd5PfY5FRERERERERCQjKiSJiIiIiIiIiEhGVEgSEREREREREZGMqJAkIiIiIiIiIiIZUSFJREREREREREQy0qV3bXPOBYA5wAozO6TJvBzgDmBXYD1wjJkt7sp8IiIiIiIiIj2BRV/F6m6DxHIIjscVfAsX3mnz6yVXYjW3QPwNcEWQdyQu7+s452F+JVZ7G0SfAQKQeyCu4AScy2u7TfOxyMNQ/y9IboDwzqk8wbEdsavSzXR1j6RzgfmtzDsd2GBmWwG/Bq7rslQiIiIiIiIiPYQfeQ6r+hEkFgNBiC/AKi/EYu+2uZ4l12Mbvgux58A88Cuh5g9YzU2YxbCKc6H+fjAfLAZ1d2MVl2Bmbbdb+zeo/jUky4EARF/FKs7Ckis7aI+lO+myQpJzbiRwMHBLK4scDtyefv4f4CvOOdcV2URERERERER6AjOD2puBELgCcAHwCsEcVtvax+30upEHwa8GVwouCC4XXDFEHsYij0FyOXil4ELgwqnlEnMh8WHrbfo1UP9vcIXp9oLglYBfj9Xd25G7Lt1EV/ZI+g3wQ8BvZf4IYBmAmSWASmBAlyQTERERERER6RHikPwcyG082eVBYuFmVp2bKvQ0Ws8DAhB/HyzZZJ4DLN3zqRX+KsC10G44VYSSXqdLCknOuUOANWb2Vge0dYZzbo5zbs7atWs7IJ2IiIiIiIhITxECrx8QazI9CoERba8aHA+WaDzNfCABwa1SvZua8SAwrPU2vYFAMt1OkzzB8W3nkR6pq3okzQQOc84tBv4J7OOcu7PJMiuAUQDOuSBQQmrQ7UbM7GYzKzOzskGDBnVuahEREREREZFuxDkH+ScBEbAomIFFgDjkn9L2unmHg8tJXd5mlioqWRWEZ6bn9QOrTI+RlAS/IlWcCu3SepteKeQeAFSBxdPt1gIhXN5RHbbf0n10SSHJzC4xs5FmNhY4FnjGzE5ostgDwMnp50ell2l7RC8RERERERGRPsblHQ4FZ6UuH7PK1BhJhRfj5e7Z9nqB4bjSX0JoQmo9YpB3BK74EpzLw/W7CUJlQDVQCzmzcKW/xLm2Sweu8BzIO4ZUz6RKCIzAlVyPU4+kXim4+UU6j3PuamCOmT0A/BX4u3NuIVBOquAkIiIiIiIiIptwzuHyj8DyDgeiQC6Z3qvKhSbi+v0JsygQxG1yOZsLDMOVXodZDHA4F8owTxhXeCZW8G0ghnO5m11Heq4uLySZ2XPAc+nnV2wyPQIc3dV5RERERERERHqiVE+hvC1cN6eNeeF25FERqbfryru2iYiIiIiIiIhID6ZCkoiIiIiIiIiIZESFJBERERERERERyYgKSSIiIiIiIiIikhEVkkREREREREREJCMqJImIiIiIiIiISEaC2Q4g0pvNffkj/nThHSz7aAVF/Qs55odf45Az98t2LBERERER+ZIssRyr/wfE3oXACFz+cbjwzql5/gas7t8QexlcMS7vSMiZjXMOswhWfx9EngQ8yD0El3cwzoUw87HI4xC5H6wecvbB5R2J8wqzuq89nVkSizwGkQfT7+u+uLyv47yC9rWbWIrV3QXxDyEwCldwPC40uYNS9xwqJIl0kg9ems9F+/8EP5HE8zzWLlvH786+hTVL13DaT7+Z7XgiItIHOOdGAXcAQwADbjazG5ss44AbgYOAOuAUM3u7q7OKiHRnlliGVfwfWB2QB8k1WPxtrOgyXLgM2/BdSK4GlwusxqqvgcQiKDgZq7gI4h+Ay0k1VnMTFp8DxT/Ban4NkYeBMOBB3e1Y9AXo9wfcxuXlS7PqGyD6BBACPKi9Nf2+/h7nwlvWZmIRVnEWWATIheRqLP4WVnQFXu6eHRm/29OlbSKd5I/n34afSBIMB/GCXupfz+O/Nz5CLBbPdjwREekbEsAFZjYJ2B34nnNuUpNlDgS2Tj/OAP7YtRFFRLo/q/t7qojkSlMFIa8ICEPN77D6hyC5BrzSVCHJFQCFUP8PLPo8JOaCKwGXl36UQOw1LPoSRB4FisHlp4tQJZBcAtEXsrm7PZollkL0SaDoi/fVlUJyEURf3vJ2a28Dvz79s8wBrxgIQu3vMfM7KH3PoEKSSCdZ8fHneF7jQ8wLeiTiSZbOW56lVCIi0peY2ecbexeZWTUwHxjRZLHDgTss5TWg1Dk3rIujioh0b/H3gPzG01wuWBXEXgcCTeYFUtOir4ElwLlN5jkwH2KvAh44r8k8w2Lvdspu9AmJTwDX8vsaf3/L242/ny4SbioX/HVg1Vvebg+kQpJIJykozcc3azTN91OvB44ckI1IIiLShznnxgI7A683mTUCWLbJ6+U0LzbhnDvDOTfHOTdn7dq1nZZTRKRb8gaDxRpPswTgQWAMuGSTeQYkIDgSXAsjyrgABIYDll62icDwDgreB3mtfNZyQGDolrcbGAw0vbIkCYRSPc36EBWSRDrJkecfAgZ+ItXN0feNZCLJxN22pnRgcZbTiYhIX+KcKwTuBc4zs6otacPMbjazMjMrGzRoUMcGFBHp5lz+8ali0cZikiWBmtTA2flHAMHUoM5mqd5GVgmhHXB5X0/1YvGr0/MsNc/rD3lHQWAUUJVex8BqweXgcvfP4t72cKHJqUKcVX7xnvs1QC4uZ98tbtblfxMs3vx3IO9rWzzuUk+lQpJIJznyvEM4/HsH4DxHMp7ET/pM3G1rfvrIpdmOJiIifYhzLkSqiHSXmf23hUVWAKM2eT0yPU1ERNJcznQoPD91uZTVAPWQexiu8ExccCyu5Jr0mDk1QC3kzMQVX43zCnGlv4LgGKA69QhOxJX+Cs/LxZX8AkI7p9erAW8wrvQXuIAK9lvKOS/9vu7EF+/5UFzpDbjAll8Z4nL2gsKz0pfJ1QARyP06ruC0joreYzhrqRtdD1FWVmZz5szJdgyRNkXqInz23hKGjhtM/6H9sh1HRKRHcc69ZWZl2c7RU6XvyHY7UG5m57WyzMHAWaTu2rYbcJOZTWurXZ2DiUhfZRYHfy24kma3kjfzwV8NLh/nlTSZZ6n1CLRYzDB/A1gUvCG4TcdTknYxvzzVi8gb3GHvq1ksNS6SK8V5+ZtfoYdq6xyshYs1RaQj5ebnMmn6ttmOISIifdNM4ETgA+fcu+lplwKjAczsT8AjpIpIC4E64NSujyki0jM4F2p1/CLnPAi0fK8C51x6jJ1W2vX0hXNncF7/jm/Thfv8GFYqJImIiIj0Umb2EqnhRdtaxoDvdU0iERER6ek0RpKIiIiIiIiIiGREhSQREREREREREcmICkkiIiIiIiIiIpIRFZJERERERERERCQjKiSJiIiIiIiIiEhGdNc26XXefvp97rjqHtYsXcv4yWP41s9PYOz2o7IdK+ti0Tgv3fc6rz/8NvmFuex93B7suOfE1K1IRaTbML8aq38QYm9CYDAu72u40MSOaz/2HlZ/P1glhGfi8g7EubwOa19ERKQvMqvH6h+F2MvgSnB5h+PCOwHg+xGo/T3UPwIEIP8IyP82nqeP4wCWXI9F7ofY+xAcjcs7Ahccl+1Y0gaXuuNrz1RWVmZz5szJdgzpRh772zPc+J2/YOaDc5hvBMNBfvHUFUyavm2242VNIp7g2hNu4uM5nxIIBfCTPgBfO+tAvn7uwVlOJyIbmV+Fbfgu+J+T+q4nAXhQdDFe7lfa3b5fdy/U/hHMwAXB4hCcgOt3U7ctJjnn3jKzsmznkMZ0DiYi8gWzemzD2ZD4DFwILAHOQcH3IPdQWH8oJBcDG7/ANQjtiDfg31lM3T1YclX63KcCXBiIA0FcybW48C5ZTte3tXUOpkvbpNfwfZ+bf/B3jFTxKBgKEMoJkown+O3Zf812vKx668n3Wfj2ZxT2KyC/KI/C0gLyCnO5//ePsWFNZbbjiUia1f8vVURyJeAKUv8ShpobMYu1r22/BmpvBvLB26T95GdY5OmOiC8iItInWf2TkFz0xd9vrwTIg9o/Qf0/IbmE1BdEmzziH+JHX8xq7u7A6v4OVgFeKbj89LmPw2p+TU/u9NLbqZAkvcb6lRuoq6ojEGz8a+0FAyybvyJLqbqH95+fl+qAsMllbIFgAM9zLHxnURaTiUgjsVeAcONpLgcsCsll7Ws78XG6vU260TsHFoDYq+1rW0REpC+Lv5b6e7rpkBEuBDiIPA4YX/RGIv3cIPJMl8bslmKvA/lNJuZBcmXqMnzpllRIkl6joDQf5xxNC9fmG6HcUHZCdRMlg4pbrOibQWFpQRYSiUiLXL9Ud/hNmQFJcEXta9srBnya/SfpEuANaF/bIiIifZnXP/X3dFMNf7/7t7KSg0Br8/oQV0LqUv5N+UAAuull96JCkvQi+YV5bDttK5LxJOanPij5vmG+z74n7JXldNm155G7EQwFiNWnLo0xM2ora+k3tJRtp07IcjoR2cjlHwnOUmMXQeok1CohtDMuMLh9jQcmQGAMUPVFMcliQACXe0j72hYREenDXO6hQCD9d5X039kqCIyFovNS8xqKJZZ+HoD8b3Z51m4n7+jU+2bJ1Gvzwaohdz+cy8luNmmVCknSq1x9/0WMnjiCZNInGU/iJ312/spkzvzlSdmOllXDxg3h7N99i0AwQH11hPqqeoaNG8JFt5+F5+m/AZHuwoXLoOC7QBysDqiG8E644sva37ZzuJKfQmAroAasFjAovAgX2qbd7YuIiPRVLrQtFP4QsPTf1xoIbo0r+SleaBwUXwWESBWQkkAOlPwaz1OPJJd7AOQfD9Snz31qIGdPXOFZ2Y4mbdBd26RXWvjuIpbMW86k6dswbNyQbMfpNuKxOEvnryAnL8yIrYc1GjNJRLoP8+tSg3Z6pbjAiI5t2yw13pLVpO7Y1s2/7dNd27onnYOJiDRnFoXEp+AKITCq0bm278cg+mxq7KTwXnhesI2W+h7zq1LnJ95AXECf37qDts7B9NsrvdJWU8ax1ZRx2Y7R7YTCISbsNDbbMURkM5yXD972ndO2cxAc3Slti4iI9GXO5UBoUovzPC8MeQd0caKew3nFnXbuIx1P17SIiIiIiIiIiEhGVEgSEREREREREZGMqJAkIiIiIiIiIiIZUSFJREREREREREQyokKSiIiIiIiIiIhkRIUkERERERERERHJSDDbAUQ62oY1lbz4n1dZ+elqtt51PDMOKyOvMC8rWSJ1UV59cA4L3lzIkDGD2Ouo6QwY1i8rWUREREREpG3lNZ/w2Lw7+Kyihm37l7L/xJMpKRgLgO+XQ/XvIf42BEZCwf/hhSdttk0zg/g7WPQ5IIjL/Qou1Lm3uje/Dos+C/H3ITAKl3sALjCoU7fZdp5yLPI4JBZDcCIud1+cV5i1PNI+zsyynWGLlZWV2Zw5c7IdQ7qRJfOW8dPjfkOkNgouNW3AsH5cee+FlA4q6dIs1RtquProX7J6yVog9QckJzfMRXeczda7jO/SLCIiPZVz7i0zK8t2DmlM52Ai0hstWvMsZz/2JDXxL/pb9MuJ8fuDjmRo8VBY9zWgPj3HgACU/Bwv75BW2zQzrOZGiDwE5qc/o3iQfwJewSmdsh/mV2AbzgJ/VSomBl4uruSXuNB2nbLNNvMkFmEV54LVgqU/pAX640p/hwsM7vI8kpm2zsF0aZv0Kn+99G6i9TEK+xVQWJp6rF1Rzv9++2iXZ3nklqf5/LPVDTmK+hWSSCT5y0V30pMLuCIiIiIivdFNrz5ATTxIcTje8FgfzeEvb9wNVVcAdaQu6gkCIcCHqh/j+37rjSYWpIpIFIJXCq4UKIC6O7Hkyk7ZD6u9C5IrwRWDVwxeCfhxrPoXWfkcYjW/Ab8OXEk6TzEk12G1f+vyLNIxVEiSXqOuup5FHywlv7jxZWx5hbm8+di7XZ7njYffJrcgp1mWVYvXULG2qsvziIiIiIhIy+KJCG+tLaYwFG80vTAY5+XPCyD2Hs0/PgfAasBf1Gq7FpsDlgC3ybouABjE3u6w/I3EXgTXZGgPVwDJJWCVnbPNVpjFIP4BuKImeQoh9lKXZpGOo0KS9BrBUAAv4GF+4yq7n/TJyQ93eZ6cghz8ZONvJzZ+ARDO0fBkIiIiIiLdhXMBQgEff+OlV2m+OXKDSXCh1tYECtpoOI+WP3Z74HK3MO1muFygaS+pjZ+RWtuPzuKR6sHVNE+yebFLegwVkqTXCOeG2e2gnamtrGvosmm+EauPse8Je3V5nv1OmkU8mmjo6mpm1FbUstOs7SkoaeOPjYiIiIiIdKlgIMRBo+uoSYQavvw1g7pEkMPHG+QeRKoYsrEgY0ACAqPwgkNbbdfl7AkuCBb9YqJFgBCEd++cnck9IrU987/YEauG8Ayc17WfQ5wLQu5+QDWN3ljqIPewLs0iHUeFJOlVTv7xMWy9yzjqq+qpr6mntqqOGYdP5YBT9u7yLLOOns7ex86kvipCfXU99dX1jNl+FN++7oQuzyIiIiIiIm07c+YP2GVgFTWJELWJIDWJEHsMq+Sb0y6FossgtAOQBBKpf10/6PfnNtt0gcFQdDngpwebrgXn4Uqu6bS7lrm8QyDvq0BNanvUQGhbXNH3O2V7m81T8H8Q2mmTPNUQnoXL/0ZW8kj76a5t0uuYGYvnLmP9yg2M3GYYQ8dm904Aa5atY+n8FfQbUsL4yWNwzm1+JRERAXTXtu5K52Ai0pt9/PkjrKz8jNH9JzJ+8FcazfNj70DsdQiMgZwD8LzM+maYXwfx91K9k0KTcS5n8yu1kyVXQuJT8AZBcNusfg4xM0h+CsnPITAGFxydtSySmbbOwVRIEhERkW5LhaTuSedgIiIivVtb52C6tE1ERERERERERDKiQpKIiIiIiIiIiGREhSQREREREREREcmICkkiIiIiIiIiIpIRFZJERERERERERCQjKiSJiIiIiIiIiEhGgtkOIF3D933mvbKAT95ZROmgEqZ+dQqFpQVZy7Nk/nLef34uwVCQXfebzODRg1pd1vd9PnzpIz59bzH9h5RS9tUpFBTnd2FaERERERHpbiyxCIu+Bni4nBm44KjsZTHjgzWreXfV5xSGw8waM44B+frMIr2TM7NsZ9hiZWVlNmfOnGzH6PbisTi/PP2PzH/tExKJBMFggJyCXC6+42zGTx7T5XnuueF+HvrzkyQTPs5zBIIep15zPLOOnt5s2VgkxvWn/p5P5nxGIpEgEAyQX5jHJXedw5hJ2ftDISIiXcM595aZlWU7hzSmczARyTa/9k6ouw0smZrgglDwXbz8I7o+ixnXvPAszy5eRML38ZwjHAhw7Vf2p2z4iC7PI9IR2joH06VtfcDz/36Fua8sIL8kj5KBxRSUFhCLxPjDeX+jqwuJiz5YwkN/fpLcojyKBxZR1L+QUG6Yv13+D6rWVzdb/sm/P8+CNxY2ZC8sLaC+NsIfv397l2cXEREREZHss8SSVBGJfPD6pR7kQe0fsOTqLs/z4pLFPL3oMwrCYfrl5VGSm4tzcNVzTxNLJrs8j0hnUyGpD3jx3tcJhoM45xqm5RXmsm5FOasWr+nSLG899QHJpE8g8MWvXigcxMz48KWPmi3/8n1vEMoNNcqeX5zHyk9Xsf7zDV2SWUREREREug+LvpbqieQ2GanFBQEfYm92eZ6nFn2Kcw5vk88sucEQ9YkEH61b2+V5RDqbCkl9QCDY8o/ZzBoVdLKZxTmH81yz6V4gAC30PHKA18LyIiIiIiLSyzmP1CeCJsyRjY+4AeeAlq+W2LS4JNJbqJDUB8w+ZiaJWALzv/jPra6qnhFbDWXQqIFdmmXqAVMIBAMk4l908YxF4ngBj8l7TWy2/OxjZxCPJhpdxlZXWcfYHUbTf2i/LsksIiIiIiLdh8uZCS4AFv9iosVS03J27/I8X91qGyA1VtJGdfEYRTk5TBzY+k2FRHoqFZL6gJlHTGP3Q3alrqqe6vIa6qrqKepXyPduOq3RJWNdYeQ2wzn24q8RrYtSU1FLbWUdfjLJ9248lYKS5neRm/2NGZTtvxN1lXVUb6ihrqqOkkHF/N+vT+nS3CIiIiIi0j24wHAoPAeIgFWBXwXEoeginNe/y/PsNmIkR2y3PbWxGFWRCDXRKOFAgJ/tsx8BTx+5pffRXdv6kMVzl/HZe4spGlDETrO3J5wTylqWdSvLmfvSR3jBADvNnkRx/6JWlzUzFn2wlMUfLqVkUDGTZ00iFM5edhER6Tq6a1v3pHMwEekOLLkOYm+keiKFp+G87F6xsKSigndXf05hOMz0kaPJD+kzi/RcbZ2DqZAkIiIi3ZYKSd2TzsFERER6t7bOwdTPTkREREREREREMqJCkoiIiIiIiIiIZESFJBERERERERERyYgKSSIiIiIiIiIikhEVkkREREREREREJCMqJImIiIiIiIiISEaC2Q4gkolXH3yTd5/5kIEjB3Do/+1Pbn5uq8vGYnEevfkpViz8nInTt2XW0dPxvNZrpvW1Ed5/fh6R2igTd9+awaMGdsYuZCSZSDL3lQWUf76B0RNHMm7H0TjnspZHRERERKS7Wl9Xx5srVxBwjqkjRlCam5fRerFkkjdXLqeiPsLEQYMY369/JyeFdXV1zElnnTZiJCW5rX+e6c7Mr4HYG0AMQjvjAkOyHUmyoEsKSc65XOAFICe9zf+Y2ZVNljkF+AWwIj3pd2Z2S1fkk+4rFolx1m6XsHR++tfCwd+vvoefP3Y5k6Zv22z5xXOX8f1ZV1BXXQ9mPPCHJ7j1srv545zrKCwtbLb8gjcXcsPpfyQWiWFmOOf42lkHcsQ5B3X2rjWz/vMN/Oz437B+5Qb8pI9zjsmzJnLOH75NKBzq8jwiIiIiIt3Vw58s4FevvoxvBkDAOS7bazZ7jx3f5npLKys477FHqIjWp9d17Dd+ApfsMQuvk77Afejjj/jVay/jGzgg4Dl+tNfezBozrlO211ks9jZWeTkQB1LvnRWcjpd/bJaTSVfrqkvbosA+ZrYTMAX4qnNu9xaW+5eZTUk/VEQS/nzhHSyZv5xA0CMYDhAMBYjVx/jxUb9scfkfH3UDtVV1BEMBguEggZDHmiXr+OW3/9Rs2Xgszq/P/DPJRJKCknwKSwvILcjhf799lAVzPu3sXWvmlovvZO2ydeQX51HYr4D8kjzefXYuT9z+XJdnERERERHprlZWV/HLV14iHAhQlJNDUU4OwYDHT194jg319a2uZ2Zc9dwzbIjUUxjOoTgnl8JwmCc+XcgTCz/plKwrqqv41asvkxMIUpzOGnAeP3nhWSoirWftbszqsaorUi9cEbhiIA9qb8HinfPeSffVJYUkS6lJvwylH9YV25ae7YV7X8N5Dud98e1AIBSgcm0Viz5c2mjZqvJqPv90NcFgoGGac45AwOOtJ95r1vaCNz8lWhcltyDni7aDAcx8Xrn/zU7Ym9bVVtUx9+UFFJQUNExzzhHOC/PsP1/u0iwiIiIiIt3Zy0uXkDCfUOCL8/5wIEjSjFeXL211vZU11Syq2EBhONwwzXOOoOfx4CcLOiXri0sWN8uaEwyS9I3Xli/vlG12itg7YDFwm1yS54KAj0WfyVosyY4uG2zbORdwzr0LrAGeNLPXW1jsSOfc+865/zjnRrXSzhnOuTnOuTlr167tzMjSDVjSx9FyF9N4JNbodTKRBNL9RZu24zevWyYTSWih+6oBiXhiS+JuMT/pp540ieMcJOPJLs0iIiIiItKdxX2/xW4JhpHw/VbXS/p+i58snHPE/c45506atZzVjGQbWbufVt4fM7B410aRrOuyQpKZJc1sCjASmOac26HJIg8CY81sMvAkcHsr7dxsZmVmVjZo0KBOzSzZt+sBU/B9H7Mv/vdNJpLkF+ex1S6Nr3/uN7iU/sP6NSq8mBnJpM+kGc3HU9qmbAKBgEcs8sV/fL5veM6x20G7dMLetK6oXyHjJo+mruqL7q1mRrQ2yozDp3VpFhERERGR7mz3kaMIeF6jQkzCT30BPW3EyFbXG1lcwqCCAuriX5z/mxnxZJKvTti6c7KOGNliVi89QHiPEZoCuFSvpI3MBxfA5eyZrVSSJV1WSNrIzCqAZ4GvNpm+3syi6Ze3ALt2cTTphr5346n0G1JCMu4TjyZIxBJ4gQDf/8t3WrwT20W3n00wHCQRSxKPJkjGfQpLC7jgL99ptmxeQS5n3nASyXiC6vIaqtZXU19Vx8wjdmOHPbbrit1r5Ns/P4H8ojxqK2qpWl9NXVU9Y7YfxcFn7NvlWUREREREuqvx/fpz8k47UxePU1FfT0V9PfXxON+duhtDC4taXc9zjitn7UMo4FEVibChvp6aWIwpQ4dy8NbNv3juCBP6D+DEyVOaZf3etN0ZXND8ZkDdlfOKoPBCIAZ+BdgGoAZyD4XQ5Cynk67mNu3p0WkbcW4QEDezCudcHvAEcJ2ZPbTJMsPM7PP08yOAi8yspQG5G5SVldmcOXM6M7p0A7FYnPt/+yjvPTeXwaMGcvQPDmPYuNZvM7luZTn3/OJ+VixcxbbTtubI8w8mv7D1W4GuW7GeNx59h7rqeibvNYmtdxmP66Q7NmxObVUdbzzyDmuXr2P85LFM2Xt7gqEuubmiiEi35Jx7y8zKsp1DGtM5mIh0BwvL1/PS0iUEPMeeo8cytrRfRutVROp5ZtFnrK+rY8chQ5k6fASBFr6k7kifrF/Py8tSWfcaPY4xpaWdur3OYsmVWOR5IIIL7wbBiVn77CSdq61zsK4qJE0mdalagFQvqH+b2dXOuauBOWb2gHPuWuAwIAGUA/9nZh+11a5OYkRERHo3FZK6J52DiYiI9G5tnYN1SVcHM3sf2LmF6Vds8vwS4JKuyCMiIiIiIiIiIl9el4+RJCIiIiIiIiIiPZMKSSIiIiIiIiIikhEVkkREREREREREJCMqJImIiIiIiIiISEZUSBIRERERERERkYx0yV3bpHvYsKaSxR8upXhAEeMnj8E512Ft+77PJ299Rn1NhK12HkdhaUGHtQ1QvmoDS+Ytp3RQMWN3GN1mdjNj2YKVrFtRzshthjF41MA2204mk3zy1mdEaqNsvet4CorzOzT7upXlLJ2/gv5DSxkzaWSHvu89WTyZ5IM1q4knk+w4ZCj5oVC2I4mIiIhIJ1lcsYEV1VWMLi5lVElJh7S5pGID1730IsGAx+V7zmZwYWHDvITv8+Ga1UQSCbYfNJiinJyGeWbGR+vWsiESYZsBAxmYn/n5/+qaGhZuWM/g/EK26t+/0bm9+ZUQnwdeIQS3x7kv+m2Y1UP8Q8CD0I44F27fzotkUcaFJOfc/sAUoHDT6WZ2RQdnkg5mZtxzwwM8/Jen8AIe5hvDJwzhB3/7Hv2GlLa7/RULP+eG0/5AxZpKcA7MOO7Sr7P/SbM7JPvdP/svT9z2HF7AYb4xarsRXPDX/6N0UPM/QLVVdfzmzD/z8Vuf4QUcfsJn5hHTOP3abxIIBJotv2zBCn5x2h+oWleNc+Cc48Qrv8Hex85sd3bf9/n7j+/hmbtfwgt6WNJnzA6jueCW71Dcv6jd7fdk89eu4eKnn6AmFsMBnnNcvMde7DNuQrajiYj0Ks65W4FDgDVmtkML82cD9wOL0pP+a2ZXd1lAEen16uNxrnr+Gd5YsZyAcyTNZ4/RY/nRXnsTbuH8PFOn338vzy5Z3PD6oU8WcMS2E/nlAQfxyfr1/PCpx6iKRoHUR5Tzd5/JwVtvy9q6Wn745GMsqazAc46kbxy3w2S+vUtZm1/4+mb8+rWXeejjjwg4D9+MbQcO5OdfOYCS3Fz8unug9i+AAwy8QVByLS44Gj/6ClT9FEik5rk8KL4aF95pi/dfJJsyurTNOfc74E5gV2DUJo+RnRdNOsqcx9/loT8/SW5hLnmFueQV5bL845X8/pxb29227/vccPofKV9VQV5RHnmFuYRyQ9z1k/+w8J1Fm29gM159YA6P/e0Z8opyU+0X57F47jL+fOEdLS5/x1X/5qM3FpJfnEdeYWr5F+99nafueKHZsslEkl+c+nsq11Wlli/KIxgOctsV/2Tx3GXtzv7iva/x1J0vkFecft+L8/jsvcXccvFd7W67J4smEvzgycepjccoCIfJD4fxPI9rXnyO5VWV2Y4nItLb3AZ8dTPLvGhmU9IPFZFEpEPd/PYcXlu+jML0eV9hOIfnlyzi7++/s8VtPvnpJ42KSBvdt2A+b69cwQ+eeozKaJSCcJiCcJiQF+CGV17isw3l/Pi5Z1i0YQMFoTD5oTD5oRB3f/AeLy5d0uY2H/5kAQ8s+IiCcA756XbnrV3L9a+8iMXfh9o/A7ngCsAVQnI1VnkZfmI1VP041cjGeRbDKi/F/Jotfg9EsinTMZKOB3Y1s2PM7NRNHqd1ZjjpGE/+/QW8gEcgkPpxO+coKC3gk7cXsf7zDe1q+7P3llCxqoKCki+6gwZDQcyMF+55tV1tAzz59+cJBgN4m2QvLC1g3isLqFxX1WjZWDTOaw+9RUFJfsO3CZ7nEc4L88QdzzVr++O3PqN6fU2jS9mC4SB+0ufF/77W7uxP3P48oZwgnrfp+57Pe89+SG1VXbvb76nmfL6C+kSM/NAX3XnDgQBJ3+epzz7NYjIRkd7HzF4AyrOdQ0T6JjPjoY8/oiAcbjg/d86RHwrzv4/mb3G717/yUqvzLn76CaqjUQrDX5xrhgIBkr7xn3lzmbt2DUU5OQ15Ap6H5zn+O39um9v87/y5hAIBvE32oygnh1eWLSVa8yCYgdvkgh9XBP5qqL8XSIDL2WReHhCF2Otfet9FuoNMC0nrgIpOzCGdqL66vqEQs5FzDuc5IrWRdrUdqYuC17wLqPM8aipr29U2QF1VPV6wSZdXBzhHtC7aaHIilsBP+rgmebyAR31N8/2M1EZSbTXhnKO2ov2Fnvqalt93gFh9rN3t91T18TjWwnTfoCbWd98XEZGWOOfGOefuds7Nc84t3fTRgZuZ7px7zzn3qHNu+zaynOGcm+Ocm7N27doO3LyI9FZGqje61+SSsYBz1CfiW9xuXbz1c8b6eMvtOgcVkfqG4Swa5/E2ex5aG4sRaLJe6iI2w/erafbR2rnUElYFlmyhRQOrb3ObIt1Vq4Uk59z4jQ/gl8Bdzrnpm05Pz5NubupXpxCPxjH74uN7pC5KYb8Cho0f0q62J+yUGrQ7Hks0TDMzzPeZ+tWd29U2wNQDpzQrukTrovQfUsrAkQMaTc8vymPM9qOoq2r8H3Kkup6y/Ztff7z1Lqlf30ST7DjYtYXlv3T2r04hWts4e6QmwuDRgygd3DEDDPZEOw0ZhllqAMSNfDOCnsf0UaOymExEpFu6G/CBC4ATmzw6wtvAGDPbCfgt8L/WFjSzm82szMzKBg0a1EGbF5HezHOOqcNHUhNt/AVwTSzG9JGjt7jdg7battV5x+ywI2ZGwv+ieGNmOAcHbrUNJTm5jYpNZkY0mWD22HFtbnOvMeOaFb/q4nFGFZeQmzcb8FO9khoajgEByD0g1VPJ/E3mJQEHoSmb31mRbqitHkkLgU/S//6R1ECNL6dfL9xkvnRz+544i1HbjqC2so6ailqqy2vAN864/sSGy662VF5hHqdcfQyx+hjV5TXUVNRSW1nHxOnbUnZA+4sxB562D8MmDGlot3pDDQ7Ht68/ocXsp//0OMK5IWo2pJavrail//D+HHHuwc2WLSwt4IQrjiZaH6O6vLphGzvuOZFdvrJju7MffMZ+DB4zsKHdmg21eAGPb113Qp++c9ugggK+tcuu1MfjVEYiVEYi1MSizBo7jp2HDs92PBGR7mZ74CQze9TMnt/00RGNm1mVmdWknz8ChJxzbd/uVETkSzh7t90pCIepikSojkapikQozc3lO2XTtrjNi2bs0eIdf0tzczlr2nS+N2136uMJKiMRqqIRqmNRpo8czYxRo7lkj1mYWXpelOpYlAn9+vO17Sa1uc0TJu/E8MLiVHvp/Qh4jotm7oXL2wdCOwJV4FeBVQBRKPw+LjQFcr8K1IBfCX4FUAt5x+CCGnJYeia3aS+VnqasrMzmzJmT7Rg9QrQ+ymsPvc2HL81nwIj+zP7GDIaOHdxh7S+Zt4wX7n2NmvJadtlvMrvuN5lgKOObArYpUhfl1QfnMO+VBQwaNZDZ35jO4NGtfxNavmoDz/3rFVZ+uoqtdx3PHkfs1mgcpKYWfbiUl+59jZrKOsoOmMIuX9mRQNPL6bZQfW2EV+5/k/mvfczQsYOZ9Y0ZDGrSk6qv+nDNah7/9BMiiQR7jx3P7iNHNev2LCLinHvLzMqynSNbnHMPAVea2VvtaGMs8FArd20bCqw2M3POTQP+Q6qHUpsniDoHE5Evo7y+jkc++ZhPytez3YBBHLj11pTm5rWrzUQiwbmPP8pzSz7DOceBE7bm2n32IxhMfQaZv24tjy/8mJpYjFljxjFj1GgC6S+il1dV8vDHC1hVU8PUESPYZ9x4coPNC1NN1cZiPPnZQt5d9TmjSko4eOttGVqYuhuzWQyiL2OxV8CV4vIOxAXHp+cZxOdgkWfBBXA5+0Jocp/+clm6v7bOwTIqJDnnbjKzc1qY/hszO6/9EbeMTmJERER6t75YSHLObXrntP7AMcB9wKpNlzOzKzJo6x/AbGAgsBq4Egil1/+Tc+4s4P9I3ZO6Hvi+mb2yuXZ1DiYiItK7tXUOlmmXkVOAZoUkUtfnn7dlsURERESkBU0HjHuIVPHnSw8kZ2bHbWb+74Dffdl2RUREpO9qs5DknDtt43KbPN9oPKm7uYmIiIhIBzGzU7OdQURERKQ1m+uRtPGOIGEa3x3ESHWPPrkzQomIiIgIOOfKzax/C9PXmFnHDXYoIiIikqE2C0lmtjeAc+4aM7u8ayKJiIiISFqz0V+dcyGgY+4KISIiIvIltVpIcs5tem/1K5q8bmBmfoenEhEREenDnHMvkuoBnuuce6HJ7JHAZgfEFhEREekMbfVISpA6gdkcfSMmIiIi0rFuARwwFfjrJtM3Di/wTDZCiYiIiLRVSBq3yfODgaOAa4ElwBjgIuDezosmsuU2rKlkw6oKhowdREFxfrbjSA+wtmoR1dFVDC2ZRH64JNtxvhRLrgK/AoJjcC4v23FEpAOY2e0AzrnXzOyjbOcREcmWmliMF5cuZmBePlNHjMx4PTNjWVUlkUSCcaX9CAUa93/4YPUqllVVsfuIkfTPb/x5oby+jtW1tQwvLKIkN7dD9qO7MYtBYhF4RbjA8GzHkR6m1UKSmS3Z+Nw5932gzMwq0pM+ds7NAeYAf+zUhCJfQiwS45ZL7uL1h94mEPTwfePgM/blqO8finMu2/GkG6qOrGf+Z+czLOcjPDzWVDpW2zHstvV52Y62WeZXYVU/gfg7pP47d1jhmXh5X8tyMhFpj6Z3ynXOzWhpOTO7tWsSiYhkx69ffZmb336TpKUulOmfm8dthx/JdoMGtbneiuoqfvTMkyyuqMA5R14oxKV77MWMUWNYUVXFN//7b1ZWV7Px48HXJ27PtV/Zn3gyya9ee5nHF35CwHMkfePrE7fnu1N3w+tFnyX8yFNQ8xuwOJDEghNxxVfhAgOyHU16iM3dtW2jEiAfqNhkWn56uki38Y9r7+PVB+ZQUJqP53kkE0ke+OPjDB4ziFlHTc92POmG5n72Q0bmzqc2kYdzDo8EwwN3MXf5eLYfeVi247XJqn8GsbfAlYBzqZOBmt9hgVG48K7ZjiciW27TO+U6YCawClgGjAKGAi8BKiSJSK/11Gef8sc5b+AcBD0PM2N9fR0n/O8e3jj9O3hei0P44ptx4ROP8nlNDUXhMM45IokEVzz7NLd/7ShO+t89rKiuIuh5OOfwfePeeXOZNGgQkUSSRz5ZQFFOLp5zJH2fe+Z9yJCCAo7efscufgc6h8UXQPV1QBhcAZhBYh5W9SMo/b2+fJeMtHz0NXc78JRz7gzn3IHOuTOAx9PTRbqFeCzOc/96hfzivIY/LIFggFA4xCM3P5XldNIdVdStYkTOB9Sli0gAPkF886ir/keW07XNkusgNgdcMQ1fp7kQGFidrjoW6cnMbO+ND+AD4AdmNsrMZpjZKODC9HQRkV7r5rfewDAC6fN65xxBz6MqEuWZxYtaXe+D1atYU1tLcU5Ow/ldbjBI3Pe54/13WFb1RREJwPMcOLj1nbe5d/6H5IfCDb2PAp5HbjDIP+f2nv9yLfIA4IPLSU1wDiiGxCeQXNLWqiINMu2R9ENgIXAMMBz4HPgd8JdOyiXypcUicRLxBLmFOY2mB0MBqtZXZymVdGd10XJ83BeFmLSkeYRdZZZSZciqAA+a3lDThcBfn5VIItIpTgAGNpn2O2AdcE7XxxER6RrlkfpmvWOcc+CMNbU1ra5XGY22Om95ZeUX7WzaLlAdjZDww5Q2GRMp6HlURiNfMn03llwHFkjt9EbOgXngd/PzX+k2MuqRZGa+mf3JzL5iZhPNbJ/062RnBxTJVH5RHsPGDSZS2/iPR31NPTvuOTFLqaQ7G1y8FdFkDkEXbzQ95CWocztnKVWGAiNT3yRZk5Mli0LO7tnJJCKdYRXQ9DrbQ4E1WcgiItJlZo4cjZlh9sWNxDc+nzVmXGurMXHgIHwzkr7faD3n4JBttiWQvmRtU74ZU4YMY9KgQdTEYo3m1cZi7DpsREfsUvcQ3g1o8jHe4oCD4IRsJJIeqNVCknPuxE2en9bao2tiimyec45TfnIsADUbaojURqjZUEN+cT5Hnn9IltNJdxQMhKnL/S5BlyQvUEfYi5Ln1VGTKGLbEf+X7Xhtci4MBecA0dS3R1YHVgmBIbi8I7IdT0Q6zjnA7c65V5xz/3LOvUpqaIGzs5xLRKRTnbvbDIpzckn4fsMj6fscuvW2jCgubnW9QQUFHL/jZGrjMaqjUWpjMaqiUSYOHMxXxm/F6TuXYUAimWoznkySGwzyo1l7c+5uM9KXz0Woi8epikTIDQU5c9epXbfjnczlfhWCo1J3/LU68KuAeij4Ns4rzHY86SHcphXeRjOce8TMDko/f7aV9c3M9umscJtTVlZmc+bMydbmpZtatmAFj//tWVYsXMU2ZePZ/+S9GTCsX7ZjSTf22ZqXWb3uTsKsIRbYmYmjvkVp/tBsx8qIxedi9f+F5BoIT8PlHYbzdB8E6T2cc2+ZWVm2c2STc24gcCBfDC/wsJll9RpWnYOJSFdYV1fHdS89z8vLllIQDnPSTlM4cfLme42bGa8uX8YDC+ZTG4/xlXET+OpWW5MbDAHwwIL5/GnOm2yI1DFl6HAunrknY0pTnxeWVlZwz7wPWVi+nokDB3PUpO0ZXtR64aonMr8GizwM0ZfB64fLOxwX3iXbsaSbaescrNVCUk+gkxgREZHeTYWk7knnYCIiIr1bW+dgGQ227Zw7B3jOzN7v0GQiIiIi0ohz7jEz+2r6+YtAi9/6mdleXRpMREREhMzv2lYGXOCcKwJeBJ5PP962ntylSURERKT7uWOT57dkLYWIiIhICzIqJJnZSQDOubHArPTjivTs0s4IJiIiItIXmdndmzy/PZtZRERERJrKtEcSzrltSRWQZgMzgY9J9UoSERERkU7gnHsHeI7UOdcLZlae3UQiIiLS13mZLOScWw08DIwn1d16BzObZmY/6MxwIiIiIn3cBUAVcB6w3Dn3vnPut865o7IbS0RERPqqTHskPQDsCXwN6Af0d849b2YrOiuYiIiISF9nZs8AzwA45wYA3wfOAr4LBLIYTURERPqojHokmdm3zWw7Upe2PQXMAOY65xZ2Zri+qLaqjvJVG/B9v8Pb9n2fdSvLqa+NZLR8LBJj3cpy4rF4h2f5spLJJOtWlhOpi2Y7irShPh5ndU0NyU74/e1uzK/AkuszW9YMS67F/JpOTpUZ8yswv3Oujoklk6yuqSGaSHRK++ZvwPwNndK2SHfknDvQOXetc+4V4F1ga+ASYHJWg4lItxBNJFhdU0MsmeyybS5Yt45Xly0l2cI219XV8eGa1SRaOBesjkb4cM1qamKxZvMiiQQfrllNeV1ds3lmxtraWqqjLX8OKK+voyJS3+K8qmiEtXW16P5QIh3ry4yRtDOpQtLepHon1QJvdFKuPqe2qo5bL/sHcx5/Fwz6Dy/l9J99kx1mbtch7b/52DvcfuW/qNlQC86xxxHTOPHKo8nJy2m2rO/7/Pc3D/PoX58hmUgSzg1x1PcPYb+TZuOc65A8X8arD87hzqvvobayDuc59jp6Ot+8/CjCOaEuzyItiyWT/OHN13nw44/wzSgKhzlr2u7sP2HrbEfrcJZcjVVfB/H3AcMCE3DFF+GCE1pePvYOVn0D+KtTr8MzcUUX4ryiLkydzpJciVX9HBJzU6+DW+OKLsYFx7a/bTP+8eH73PHeO8SSSYKBAN/ccSdOnDwFrwP+37DEstT7nvgo9Tq4La7oIlxwdLvbFunmHgY+Ba4F7jCzzqnSikiP4pvx9/ff5e4P3iOeTBIOBDhxpykcv8NOnXa+/u6qzznpvv9QE08VggLOce5u0zlr2nSqIhFOfeC/fLAmdb4T8jzO2HUq5+42g4Tvc86jD/L0okUYhofjoK234Yb9vornefz8pRe44713SFiq+LTr0OH85bAjKAyHefvzlVz/8ousrq0BjD1Gj+EHM/aiOCeHxRUb+OmLz/PJ+nXgYIdBQ7hkz1mMKCqmvL6On7/0Am+sXI7DMbK4mItn7sX2g4d0ynsj0te4TKqzzrkNQCXwAqnBHp83s6z3RiorK7M5c+ZkO0aHuO6k3/Lhyx9RUJqPc45oXRTz4ScPXszIrYe1q+1P3v6Ma479NcFwkJy8MMmkT21lHXt8bRrf+eXJzZa///eP8p9fPUReUR7BUIB4LEG0JsKZvzqZmYdPa1eWL2veax9z3Yk3EcoJEU5nr6usY+9jZnLaz47v0izSul+/9jL3fTSPonAOAc8jmkgQTSa4Yb8DKRs+ItvxOoxZAis/GfxVQHF6Yg14+bj+dzYrDlliGbbh2+lXeYCBVUF4J7zSX3dldMxiWPmJ4K/ji+zV4BWlsxe0q/0HFsznl6++TH4oRCgQIJ5MUhePc9a03Tl60g7tzB7B1p8AVgFsfI+rwZXiBtyJc7ntal+6N+fcW2ZWlu0c2eKcmwnslX7sBHzIFwNvv5itXL3pHEykJ7pn3of87o3Xmv3dvWD6TA7bdmKHby+ZTDLpjzcRb6Gn0d8O/zq/euUl5q1bS9DzcM6R9H0M+PlX9ueVZUu5f8F8As7D8xy+byTN58TJUxhTUso1Lz6H5xwBz8PMSPg+ZcNHcP2+X+XUB/4LGHnBEEaqV9OUocP42T77c9y9/6I6FqUwnPpivDoWZWBeAXd9/Wi++8gDLCwvpygnBwfUxuOEPI87jziaQQXtO+cR6SvaOgfL6NI2YGczG2tmJ5nZX7tDEak3WbV4DfNe/ZjCfgV46f98cwtySSYSPH3XC+1u/+G/PIn5Rk5eGIBAwKOwNJ9XH5xDVXl1o2V93+fhm58itzCXYCg19EIoHCSYE+KBPzze7ixfOvufnwTnCG+SPb8knxfufY3aquZdX6Xr1cXjPPTxgoYiEkBOMIjDcdcH72Y3XEeLvw3+WnAl4Fzq4RWBX4NFnmu2uEUeBOLg8tPLe6l14x9iiSVdmz32BvjlTbIXp4pJsZfa3fyd779HTjBIKJD+fyMQIDcY5M73321320RfBasEV/xFdlecmhZ9tf3ti3RjZvaymV1rZgcCU4A3gR+SupObiPRRd77/LrlN/u7mBIP8vSP+7rbg1nffaSgiuU0eAFc//yzz169rKCIBDeeEf3jzdR5Z+DEB5/C81DzPc3jO8Z/5c/nL23Nw6SISgHOOoOfx1ucr+ceH75NIJskPhXEutU5xTi7vr17NvfPnUh2LUpSTi3MOl55XXl/Hv+d+wKKKDRTn5OCl5xWGw0QTCR5d+HGnvD8ifU2mYyQt7uQcfVr5qgoCQa9ZN1QvGGD14rXtbn/NknWEchpfxeh5Hp7nUbWucSEpHo1TV13fUETaKJQTZP3Krh+XZM3S5tkDAQ/nSF2mJ1lXGYlgWMMJwEbhQICV1dWtrNVDJdcBLY3/5Kd7KTVdfgVYk7FwnQO8dM+gLuSvA2th/ARLYMk17W5+bV0t4UDjfQ0HApTX1+O3d1wCfx20dDWPxbv+fRTpYs65I5xzNzrn3gUWk+qZ9DvgwGzmEpHsMTPK6+tb/Lu7roUxhjrCJ+Wpv7ctXTS3ri51Tt70s4wDyuvriSeTzT/nOEckkaAyGmn2gXTjsp9uKG8oPm06L+AcSysrWuwdlTSf5VVVOFzzS/wcrKiuantHRSQjmfZIkk40cpth+EmfZKLxhzw/kWTi7tu0u/2J07chFmk8YHY8liAQ9Bg8emCj6eHcMEPHDibaZFDr+poI2+wyvt1ZvqztdtuKaF3jAfni0Tih3DD9h5V2eR5pblBBAfmhULPBlSOJOFOGtO+yzG4nuFXq300LI2bggrjQpObLh3YCmhRvLAn4EBzXWSlbFtw61SOqWfYQLrRtu5vfbuBAapsMnlkXj7P1gAHtHyMpuDW4YIvZG34mIr3XuUAFqbu1DTCzPc3sMjN7IruxRCRbnHNsPWAAdfHG5/d18RjbDhzYylrtc0B63MuWvhracfAQPFKXrG3KN2ObAQMpzskh2eRLpaQZA/LyGVfar/k83yfoPPYYNZqk33xe0ozdRowi5AUaDaJtZnjOY7eRo0ia3+IXWTsNGfpldltEWqFCUjdQ3L+Ig8/Yl7rqeuprIsQicarLaygdUsrsY2a0u/0DT/8KBSX5VJfXEEv3OIrWRvjGDw4jnBtutKxzjhN+dBTJRGocpXg0Tk1FLcFgkKMuOLTdWb6sQ7+zP/lFeVSX16R6S1XVE62PcexFhxMKa7Dt7iDoeXy3bHeiiQQ1sSixZILKSD35oTAn7jQl2/E6VnBrCM8AKsHqwSKpy6uCEyDcfPwwl3sQBAaBXwEWBatLXUqWdyTO69/F2SdBuKyF7NtBaNd2N//dqbvjOUdVJEIsmaQqmuqp9r2pu7U/e2hy6mGV6dzp7KEd08U6kd7LzGab2ZVm9oyZtXxbIhHpc86aujuGURVN/92NRHA4vlvWAX93W/CV8RMYkh5byDZ5BJzj+n0P4IiJk0iaT8L38X2feDJJ0PO4bM9ZXDB9D4D0PCORTPUkunjmnly65ywCnkc8mcT30+ubcdJOO/O17SYxuKCAikg90USCuniMmliMoyftwD7jxjNx4CAqoxEiiQT18ThV0Shlw0ew99hxHLjVNlRHI9TF40QTCSoi9YwsLmHvsV3/xbhIb5TRYNvdVW8a6NHMePWBOTx26zNUV9Syy747csiZ+9NvcEmHtL9m2Toe/OPjfPDiR/QfVsohZ+zHLvu2fufgBW8u5IE/PM6KTz5nwpSxHPa9rzJm4sgOyfJlrV6ylgf+8BhzX/mYgSP6c8iZ+zFl7/YN3isd740Vy7nzg3dZVV3NTkOHcdLknRlV0jG/v92JWRyrfwAiDwNxyNkPl3cUzstveXm/HKv7J0RfSo1JlHskLnffrNwB0SyG1d+fzu5DzgG4/K/jXF6HtP/RurXc8f67fLJ+HRP69efEyVM67O4oZlGs/j6IPAYY5Hw1nb35nSeld+nrg213V73pHEykp5q3dg13vP8On5aXs/WAgZw4eQoTBw7qtO3Fkkm+/eB9vLZ8Gb4ZY4pLuOnAQ5iU/lt/81tvcNu771Adi7J1/wFcvtfe7DJsOAD3fzSPG19/lbV1tQwtLOLCGXs09HJ6bflSfvbi8yyq2EBJbi7f3rmMk6fsAkB5fR13f/A+Ly5dTHFOLkdN3J79J2yFc476eJz/zJ/LYws/xnOOQ7bejiMmTiIcCOCb8fAnC7hv/jzqEnH2GTueY3fYkeIc3aBDJFNtnYO1Wkhyzu2TSeNm9kw7srWLTmJERER6NxWSuiedg4mIiPRubZ2DBVuamPbXDNo2QP0DRURERERERET6gFYLSWbWxSPBioiIiIiIiIhId9ZWjyQRERER6WLOub/T8s2RGjGzk7ogjoiIiEgjGRWSnHPFwFXALGAg0DBKrJmN7pRkIiIiIn3TwmwHEBEREWlNpj2S/gCMBK4G7gROAH4A3NtJuURERET6JDP7cbYziIiIiLQm00LS/sBEM1vvnEua2f3OuTnAg8CvOy+eiIiISN/mnAsD29K8V3jW7pwrIiIifVemhSQPqEw/r3HOlQCfA1t1SirpNIl4gkAwgHNu8wt3slgkhhf0CAY1VJdIeyR8n1giQX443Cntx+LVBLxcAoFQp7QvIq1zzu0B3APkAMVAFVAELEN3zhWRTpL0fQACntdsnm+Gb0awhXltMTPivk/I8770Z5F4MknA8/A68DOMmZHwfUKBQIe1KdJXZPoJ/j1S4yM9DbxI6lK3GuDjTsolHeyjNz7h71f/hyVzl5FXlMdXT9ubr511IIFg1//HOe/VBVx/yu9ZtWg1OMe4HUdzxT0XMGzckC7PItKTRRIJzn30IZ5fupik71Oam8tFM2dx1KTtO6T9z1bdy4b1f2BoXjkxP8Dn0Unsss1vyQ2VdEj7IpKRXwPXm9mvnXMbzKy/c+4KoC7bwUSk91lbW8tNb7zCi0uWgHPMHjOWs6dNZ0B+PnXxOH+c8zqPfPIxcT/JzkOHc97uMxhX2q/NNs2MRz75mL++M4e1dXUMLSzkzF2nse/4CZvN88n69fzm9Vf4YPUqcoJBDtlmO87ctYzc4JZ/uZXwfe547x3umfchNbEY2wwYwDnTprPT0GFb3KZIX+PMNntTEJxz49PLfuqcGwxcCxQCPzazeZ2csVVlZWU2Z86cbG2+x1gyfzlXHfELDCOvMJdEPEmkJsL+J8/mxCuO7tIs5as2cPLWZxOPxgkEAxiQjCcpHlDEP5b/Sb2TRL6EY/7zT97+fCUB5+EcJM1wwM2HfI1ZY8e1q+3PN7xMZN15BLwkkWQIDyM3EGdZ/Rim7/C/Dskvkgnn3FtmVpbtHNninKsE+pmZny4k9Utf6rbIzEZkK5fOwUR6n2giwUn/+w+ramooysnBzKiJxRhZXMLtXzuSHzz5KG99/jmF4TCec9REoxSEw/z9iKPon5ffaruPfLKA6195kXAgSE4gQDSZIJpI8uPZ+zB7bOsdK1fX1HDy/fcSSSQoCodJmlEbi7Ln6LFcs89+W7yfN77+Cv+dP4/8UIig51Ebj+MBfzrkcLbqP2CL2xXpbdo6B8uoP6KZfWZmn6afrzGz083smGwWkSRzj/zlKZKJBPlFeTjnCIWD5Jfk88zdL1Jb1bVfaP7ruv8Rj8YJhoM4z+F5jmA4QHV5DU/e8UKXZhHpyVZUVfHO558T9Dw8z+GcI+h5+Gb88tWX2t3+ohV/IuQliSTDgMPHoy4ZZkTeUtZU6MOjSBeqJHVJG8DnzrlJQD9SX+iJiHSYV5YvZU1tLSW5uXjOEfA8SnJz+bymmv99NI93V62iJCcnde7hHMW5udTGYjy68JM22731nbcIB4LkBoM458gNhggFAvz1nbfaXO+BBfOpj8cpzslpOM8pzsnl5WVLWVFdtUX7WB2Ncv+C+RSGw4QCqeE+CsNh4r7PPz58f4vaFOmLMr6w1Tl3mnPuSefc3PS/p7vuMNCObNbS+SsI5TYeOyUQSF2bvGFVRZdmWTJ/BU07wW38NVr84bIuzSLSk328fi3O0WyMAc85VtZUt7v9IGtIWtP/4h2+eWyo+bDd7YtIxv4LHJR+fivwLPAW8J+sJRKRXmllVRVxP9lsetJP8vH6dXjONR/byDk+21Deapu+Gatra8lpMg5RbjDIiqq2i0Gfbign4DXe3saC0sotLCStrattKJJtKicYaHM/RKSxjApJzrnrgYtIncz8IP3vhcB1nRdNOsqEKWOJRWKNpiUTqT8SA0b079Is2+wyvtkfoI2XV243dfPXSYtIyqRBqTHFml6e7JsxtqS03e0nvOF4rumlz4bnjAHFu7a7fRHJjJmdZ2Z3p5/fABwJfBv4VlaDiUivM6a0H2Ev0OjcwswIOI/JQ4bimzU778CMiQMHtdqm5xwji4uJJBKNptfH44zr1/bnkIkDB+G3cJ6T8H1GF5dmtlNNDC0sAlLjJG0qmkgyceDgLWpTpC/KtEfSKcBXzOyPZvaImf0R2B84tdOSSYc5+Nv7kpMbpmZDLcmkT7Q+Rl1VPQefuR95BbldmuWoCw8ltyCHeDSB7xt+0kjEkgwY3o9Zx8zo0iwiPdmQwkL2GD2GhO+T9P3UnVCSPgHn8cMZe7W7/a1HnEs0GSQvEMOZT8AlyQ/GWF6/FQOLd+yAPRCRTDjnbtr0tZm9ZGaPkhqEW0Skw+w2YiSjS0qojESIJ5PEk0mqolEm9B/AQVtvyx6jx1AZjRBLJkj4PpWRCKV5eew/Yes22z1z12nEk0nq4jGSvk9tLIZvxpm7Tm1zvUO22Y6icA6VkQgJ3yeaSFAdjbL/+K0YUrhlV/fmh0Ict8NkamNRIokESd+nKhohJxjk2B10fiOSqUwLSdXpR9NpW9anULrUsPFD+NG/v88Oe2xHPBKjuH8hJ199DEecc9DmV+5gxf2LuPGVn7JN2QQww/Mcu+y7I7+fcx3el7yFqEhf9+dDvsY3Ju1ATiCIb8aI4iL+ePChTBs5st1tDyqZQm7/n7OifjjBgE/cD7I8ugfTtru9A5KLyJdwSivTT+zKECLS+4UCAW468BC+tt1EHKneREdO3J5f7X8gnnP8aK+9OXXKLuQEgiR9n33HTeDPBx9OcU5Om+3OHjuOn31lf0YXlxJNJhjfrx/X7XsA00a0fb4yID+fPx18OLPGjCWRTJIfCvGtXcr4wcw927Wfp07ZlfN3n0lpTi6xZJKyYSP4/YGHMroDenSL9BWZ3rXtbOBrwM+B5cAoUpe43Q88snE5M/usU1K2QncMERER6d366l3bnHOnpZ/+DjiryezxwNFmtm3XpvqCzsFERER6t7bOwTK91/qN6X/3bjL9K8DGLtcGBBARERGR9trY4yhM495HBqwGTu7yRCIiIiJkWEgyM11zJCIiItJFzGxvAOfcNWZ2ebbziIiIiGz0pQpEzrlRzrndOyuMiIiIiHzBzC53zg1wzp3onPsBgHNuuHOu/YOhiYiIiGyBjApJzrnRzrmXgY+Ap9LTjnLO3dKZ4URERET6MufcLGAB8E3givTkrYE/Zi2UiIiI9GmZ9kj6M/AwUATE09OeBPbrjFAiIiIiAsBvgGPM7KtAIj3tdWBa1hKJiIhIn5bpYNvTgIPNzHfOGYCZVTrnSjovmoiIiEifN9bMnk4/33ir3RiZn8OJiIiIdKhMeyStBrbadIJzbhKwtMMTiYiIiMhG85xzBzSZti/wQTbCiIiIiGT6bdYNwEPOuWuBoHPuOOBS4OeZrOycywVeAHLS2/yPmV3ZZJkc4A5gV2A9qW7cizPM1y299/xc/vOrB/n809WM2m4ER19wKJOmb9visslkkifveJ7Hbn2Wuqo6Js+axDcuPIzBowd1ceovLxaJ8atv/4lXHniTRDzJ6O1GcN6fz2S7qVttfuUMLJm3jH/f8AAfv/kp/YaUcOh3D2CPI3bDOdch7Xemj9at5ea33mTu2jUMLijgxMk7s9/4CR2SvSYW44dPPsoLS5aQNJ/tBg7iun3/v737jpOrqvs4/vnd6Vuym94TCAklhEAgVEFQehMUVOzYsJfH/tj784gNxAJYsaDoIyogiCgiVWBDDyWEJJDek+3T7u/5YyZhe2azZbZ836/XvLJ777lnfufe2cyZ35xz7unsP35Cl+U3NzfxkyV13LX6eZLRKOcfcBAXLVhIPBLpcyxhGPLIC78h2notVdGdbMnsy8RJH2TfCUd3Wd49jTdfC61/Bc9A4kSs8q1YMK7r2OtXsnztN5kUfYyMx6m3Mzl83w8Qiyb7HPtACzOPQv3nILcCiEHyZBjzdYIg3mX5Rzas58cPPcjybduYMaaGty86guNmzuq67jDkoVU/IZn5IxWRBjZn92fq5A8za/xhA9egfuIe4i03QMsfwHdA7Ais8h1YtOu2etiIN/8SWv9e2JA8Dat4MxZUDV7QIuXxUQp9sL8CKTO7CjgXOK+8YYmMTA+sXcNPHqrj+Z072Ke2lnccvpgjp42ste3XNzTwk4fquG/NC1TEYlxw0AJeffACokFAQzrNzx95iNtWLMcwzpg7j7ccuojKeNf9FhEZnczd91wKMLPzgHcBs4HVwJXu/ucSjzWg0t0bzSwG3A18yN3/06bMe4GF7v5uM7sIeKW7v7anehcvXux1dXUlxT/YHrz1Ea5430+IRAPiqTjp5gweOh//xftY8JIDO5X/xed/xz9/cxfxVJxINEJLQwtVtZV8/ZbPMHbS0J5B+P6jP8WzD68kEgQQGGEuTzQe5apHv8X0/ab2qe41z67nC+d/g2w6R6o6STaTI9ua5bWfOI9z3nVaP7VgYCzftpX3/PUGsmGeilicbD5PJp/ng0cdywXzD+5z/af+6ues2rGdiBlg5D0kGY1y+5vfxsTK9h+uG9Jp3vqX69nU3EhlLE7oTksuy4mz9+UrLzulz7Hc/+xlTI/8hmwYJRdGSUZayXuUYOwPmTV+Ubuy7o7X/zekHwCrAAy8CSJTsXE/wSzVrnx9yybWrX4NVdEmWvMJzEISQZbVrUdy7Pwf9jn2gRTmVsGWV1BYWi4KhIVHbAHB+D90Kv/w+nV85O+3YAapaIzWXI68h3zhpS/nZfvO6VT+P898hRmxG8iEUfJeOO/ZME7FhJ8xpbbrpPVQETZeBS3XAUkgCt4IQSU29sdYZEq7su55fMf7ILcMqChubYbIPGzsDzHrezJUhi4zW+Lui8sdRzmZ2TTgjbzYB/u1u68pZ0xDuQ8msrfuXf08n7n9H5gZqWiUllwOd+d/Tj6NY2bMLHd4/WJHawtv+fMf2d7aQlU8QT4MacllOWvu/nzsuBN4541/4rlt26goJo6asxkOmjCRH519HsEw+BJXRPpPT32wUqe24e5/cfez3P1gdz+j1CRS8Vh398bir7Hio2MG6zzgmuLP/wecbMNhyEk3rrv0z0TjUVLVKSLRCBVjUljE+P2lf+lUdvumnfzrd/dQWVNBIhUnGotQPa6Kpp1N/Ou3d5ch+tIte2gFyx9eRTQaIYgGBIERjUfJZfJc87nr+lz/TVf+nUxrlqqxlUSiEZIVCVJVSf58xS1kWjP90IKBc82jD5PJ5xmTSBINAlKxGKlYjJ8+XEcmn+9T3Xc+v5Lnd+4gGgQEQeG8xyIRWnM5vv/AfzqV/+fK59jS3ERtMkUsEiERjVKTSHLXC6t4fseOPsWSybUwwf5AOh8n63HcAlrCCiJBjrUbu7ipUG45ZJaA1YDFwWIQ1EK4EW+9s1Pxp9deS2WkmeZ8BSER8h6jKZdiRqKO9TuX9Sn2AddwGYUkUgwwIAJEIbuUMPNkp+I/fqgOM6iKJ4gEAZXxOLEgwpVLHqBj0r8pvYMp0b/Skk+S8zhOQEu+grhlWLn+qoFvWx942AAtfwSqwZJg0eJroBlvub7zAdmHIPccsOs1Ey/8nF8B2SWDG7zIIDGzCjP7upndAFwCXO7u73P3/y13EklkpLpqyYNEAqMqHicSBMV/jSvrHih3aP3mr88uY2e6ldpkimgQkIhGGZNIcutzy7l1+bOs2rGDmmSSeCRCPBKhJpHk2a1beXjDunKHLiJDSI+JJDM7wswWtPl9opn9xsweNbMrzazkOQVmFjGzR4BNwG3ufn+HItMpfMuGu+eAncD4UusfSvL5PBtWbCJR0X4IaLIywQtPde77rV+xkUg0IIi0vxyRaIRnH1oxoLH21dJ7nsYCsKBDzs+c5Y+s7HP9zz2yqtN5jMaj5HN5tm3Y0ef6B9LTWzaTisXabYtHIrTmc2xvaelT3Q9vWA/QxRQ54/FNGzuVf2rL5kIeo21JMyIWsGrH9j7Fsr1pLVHLke8wUzaTjzEm0sVrIL9yVwDtt7sXR5y0F2aW4h2CNzPyBGxteKpPsQ+43FN0OvEURpCRfahT8We3bSUVbf+aSUajrG9o6JR83Nr4HDh4h//GMx4lyfJ+CH4A5dcCAXQcSWQxyHZOsJFbBZ5r/5oxA88W9omMTD+gMIXtaeBCCssMiMgAWrlje6f34VQ0xood28oUUf9bumljp5FFgRmRwHhkwzqyYb5d/9KsMOp95fa+9RdFZGTZ04iky4C2cwx+AuwPXA0sAC4t9YncPe/uhwEzgKPaJqh6w8wuMbM6M6vbvHnz3lQx4IIgYOyUWrKt2XbbMy1ZJs3uvObRxBnjyWdDPGw/4iCXK6w3NJTNOWQ2HtJptAQO0+f1bVobwPR5U8h0OI/5XOENrmbimD7XP5Bm19SSzuXabcuFIVELqE32bW2feeMmFJIIHc67Gew3tvM6Q/vUjO20zd1xd6ZWV/cplpqKybgHGGG77bEgR2N+SucDIlN3BdBhh0Gk8/o4HtkHs7DDRicgpKZin70PfDBEZtF58KUXHrGDOhWfXj2GdL79ayaTzzM2leq0llVtxUwCc/AO591ytDLE13KITALynWKHLET37aL81MKopY4s9uLrSWTkOQM4zd0/AZwJnFPmeERGvCmV1Z3eh1tzOaZVDe0+Z2/MGTuOfIfPHO5OPnTmjptAPOg8XTwSBEyrHjnnQET6bk+JpIOAuwDMrJZCR+YN7v4D4HUUvinrFXffAfyLQgeprbXAzOJzRYEaCotudzz+andf7O6LJ04cmgtRmxmv+tDZZFoyu6dfpVsy5DI5Lvjw2Z3KT5wxnsNPXUjDjibyuTzuTlN9M/FknJPfcMJgh98rh550MFP2nUgukycMC4mJXCZHEAl40xde0+f6z3n3aQRBQEtj6+66m+tbOOVNJ5KqHNoLLb/p0MLaQM3ZLO5OJp+nKZPh1QcvIBHt212bz9hvLhMqKsiF4e6EUC4fEjHj/Ucd07n83HlUxuLUp1uLnYWQ+nSagydNYt64vg38S8aqWZ8/lVSklQg5cCcepAFj3Ph3dj4gejBE9wPfCV5MJvhOCKqx5Mmdis+b/iYy+TjJoAXcMQ+piLawIT2PmeMO7VPsA67qgxSms+XYnUAiB5GZBPEjOhV/26LDyeVDWnOF10w6l6M1l+PNhy7qNPpsTGoSazIvoSLaSlA87wlLExJh2qS3D0Lj9p4F4yBxClBfGGnkDmEjEMNSF3Q+IH4UBJOKr5mwzWtmIsS7XtBdZASodPf1AO6+mkK/SEQG0NsXHUE6l9/9RWA6lyObz/O2RZ3fs4erc/c/kFQsSkM6Xeg/hiE7060cNX0G5x94EOMrKtjZ2kroTuhOfWsrkyurOHLa0P5yW0QG154SSVFg10I0xwAb3H0Z7O7U1JbyJMUpcbXFn1PAqRSGard1A/CW4s8XArd7qSuBD0EnvfY43vKVi0gk4zRsa6SiOsU7L30jR5/d9RvRu7/9Zk5784lkW7M0bmti9kEz+PRvPjQs7tp22T1f46Bj5uH5kFw2T+2kGj7zu4+w/+GdFwfurbmH7ctHf/IeJk4fR8O2Rjx0zv/Ambz2k0P/ZjWHTp7C115+ChMrKtiZbsUodFDevqjva8YGQcAfX/N65k+YSL7YCZhUVcnV557P7NrOo4/GplJcceY5HDJpMvXpNC25LGfOncfXX35av9xB7uh5X2BN9pUAVEabacjWUJ/4DPMmv7RTWbMAq7m0cPcymoF6iB2G1V7e5R24JlTNIjrue2zOzKIi2kI8kuGF9EtYMHdoL7QNEMQPgZpvg42lkEwKIXYYjP9tl+VfOntfPn3CiVTHE+xMtxKPRPjg0cfyqgPnd1n+yHlfZ3X2LCLmVEab2ZEbR2vFV5g9fuh3eK36vyD1GiBbSApFZ2O1l2LRfTqXtThWexnEjwUaCo/4sVjtZZjpLjIyYkXN7GVm9nIze3nH34vbRKQfnbbfXD5+3PGkYjF2tLaQisX4+HEncOqc/codWr+ZXFXF9844hwMnTGRnupVMLsd5BxzEF098OYlolO+feS7HzphJYzpNYzrNS2bN5oozzyXWD3f5FZGRo8e7tpnZPRQWd/y9mf0CCN39bcV904H73X2PcyjMbCGFhbQjFJJXv3f3L5vZl4E6d7/BzJLAr4BFwDbgInfvcYGg4XDHkDAMybRmSaTiJX1gz+fz5LN54snh9+Eok8mSaU5TVdv/t+N2dzKtGWKJGEFQ8hrxQ4K7k87niEeiA3K3i9Zcjmw+R3WitBFa6VyOSBAQHYDzGIZ5Mvlm4pHKkq6TexbwkpMB6WwzkSBKNDL8/j7CsB5IEgR7jt3dac3lSERLe83sOu/JWN+mKZaDex7IUngLKKV84bsNJZBGj9F61zYzW0XnubFtubv3/RubvTQc+mAie2vX+3AyGu2XL9yGqnQuRzQICnde7mDX2owdp9aLyOjRUx9sT/NrPgncaGZXAnng+Db7XgvcU0oA7v4YhQRRx+2fb/NzK/DqUuobToIgIFmRKLl8JBIhMkz/w47HY8TjsT0X3AtmRiJV+nkcSsyMZHRgzgsUFmNO9mKqXF+n1fUkCCIkg9KTGWa9Oy+JWMWeCw1RQVD62gJm1mmh9p7r7t15H0rMIhS+Yyi1vBJIMjq4+z7ljkFktOrt+/Bw1VOfUAkkEelJj58o3f1uM5tFYYHtZe7e0Gb3X4HfDWRwIiIiIiIiIiIydOxxaEIxebSki+3PDEhEIiIiIiIiIiIyJA2vxWZERERERERERKRslEgSEREREREREZGSKJEkIiIiIiIiIiIlUSJJRERERERERERKMnD3AZdecXceuOVh/vaz22nc3sjhpy7krHecQs2E0m8ZLqNL6M7fli/jT08/RUsuy8n7zuHCgxZQnUh0Wb4hneYPTz7O7atWkorGuODA+Zw2dx6B2SBHDvkw5Obly/jL00+Rzuc4Zd/9uHD+AirjXd/avT7dynVPPM6/n19FZTzGBQcdzClz5nYb+6od2/n144/yxKaNzK6p5Y0LD+OQSZP7JfZcGHLTsqe54ZmnyYUhp+03lwsOOrjfbhO8Yvs2fvXYIzy1ZTNzasfyxoWHMX/ipH6pW0RERAZfOpfjL888xc3PLsMMzpy7P+cfOJ94JLLHY6955CF+8nAd9ek0B4yfwGdOOIlDp0zd43FrG+q59vFHeWj9OqZWVfOGhYdyxNTpfWpH6M7flz/L9U8/SXMuy8v22ZdXzz+EMcW+5/1rVnPtE4+xqamRI6dN5/WHHMqUquo+PaeIDE3m7uWOYa8tXrzY6+rqyh1Gv/jj5Tfxlyv+RiQaEIlGSLdkGD91LF+96b+pqq0sd3gyBH3r3ru4cdkzxCIBgQW05nLMqR3LVeecRyLaPkfcmstyyY1/YdXO7SSjMUIPyeZDXnHAgXz02OMHPfav3XUHf39uObFIhMCgNZdj/3ET+OHZr+jUqWrOZnnnjX9idf1OktEY+TAkF4ZcOP9gPnDUsZ3qfm7bVt5z8w2kc3mS0SjpfA7D+OrLTuEls2b3OfYv3PFP/rVqBfFIlMAKncP5EydxxZnnEg36Nsjz6S2b+cAtN5HJvxh7YMY3TjmdI6fN6HPsIsORmS1x98XljmO4MrOfAecAm9x9QRf7DbgcOAtoBi5294f2VO9I6oOJDKTQnY/9/Rbq1q8jUezjZPI5jpw+g2+ecgbWwxd6X7rjn/zm8UfBDCvWFQsCrrvwIg6ZPKXb49Y21PPOG/9MUzpDMhYlk8/jOJ8+/kRO22/eXrflsv/cy5+efnJ33zOdyzGrpoarzzmfvz+3nO/+5x6CwIgFEVpzWaoTSX567iuZXFW1188pIuXTUx9MU9uGgIbtjdz4w1tJVSdJVaeIp+JUj6ti24Yd/PsP95Y7PBmC1jbU89dnl1GdSFARi5OMRqlJJFi1czv/fn5lp/J3rFzJC/U7qEkkSUajVMTiVCcS3LjsadY11A9q7Kt2bOe2FcuLscdIRmPUJJI8t30b96x+vlP521YsZ219PbXJFMlolMp4nKp4nOufepLNTU2dyv/4oToyuTw1ySSJaJQxiSTRIOCKB/5DXxPnz27dyp3Pr6Imkdwd+5hEkqe3bOH+tav7VDfAVUseJBu2jz0w43v339fnukVk1PoFcEYP+88E5hUflwA/GoSYREaNRzas5+EN66lJJEjFYqRihb7DknXreGzTxm6Pa8xk+O3SxwksIBoERIKAWCRCNgz56l139Picv37sEZoyGWpShf5EdSJBIhLligf+Qy4M96odGxob+PMzT7bveyaTrN65k1ufe5Yf1d1PMhajKp4gEY1Sk0zRkE5z3dLH9+r5RGRoUyJpCFizbD1BUBiJ1FYQDVh6zzNlikqGsmVbtxCYtZvaZWa4w8Mb1ncq//DG9bvL7BKYETHj2a1bBz7gNpZt3YLROfa8hzy2sXOH6qH16zp9WxcJAgIznt3WOfbHNm2kosMUuWQ0yvrGBpqy2T7H7ni7eMyMXBiytIfOYKmWbt5IZax97KlojFU7dpDJ5/tcv4iMPu5+J7CthyLnAb/0gv8AtWa253kzIlKSZVu3kA3DLvsOz2zZ3O1xT27aROhOELTvAwVmLNu6pcfnfHjDepIdRqcnolGaMhm2NHf+Eq4Uz27bStSCzssKGNy7+gWyYdhpVHkiGuGh9ev26vlEZGhTImkIqJ04hnwu32m0RD6XZ9KsCWWKSoay8akKHO/0mjFgWnXndbWmVlXTcTCOu+MO4ysqBjDSzsZXVNDVKO7AjKldDH2eXj2GsEPwhdidCV3EPqmislPSJReGJKPRTp2qvYk9oHPwETMmVfZ92PaEVOfYs2FIVTze52lzIiLdmA60HVK5pritEzO7xMzqzKxu8+buPwCLyIvGpyqIdfEeHgsCJlR0v3zF9DFjwOnU13OgNpnq8TknV1Z16k/ki8msMYlk6cG3MSFVQdhF39MdZtfUErp36q9l8nmmVGtam8hIpE8mQ8DUOZM58Oh5NG5vIiwON21tThONRjnljS8tc3QyFC2YNJmZY2poSKcJi0mVpkyGRDTKGV3MfT9z7v4kohGaMhm8+EbfkE4zu7Z20BdyPmzyVKZUVlPf2ro7IdSYyZCKxjhlzn6dyp+9/wHEIxGasy/GXp9OM3fceOaNG9+p/JsWHkY2n9/dgcqFIc3ZLK+ev6DPyZgjpk5jQkVlu9gb0mkqYjFets+cPtW9K/ZMPk+2Tewt2SyvW7CwLIuii4i05e5Xu/tid188ceLEcocjMiwcP2s21YkEDen2fYcxySTHzZzZ7XHTx4zhoAkTyIXh7uRNvvg54ZIjjuzxOd9wyKG4O+lcbvdxjZkMZ86dR8Ve3hzkwAkT2ad2LPXp1t19z+ZshkQkwqsOOpiX7zuHhnR6d4zpXGGNytcdvHCvnk9EhjYlkoaID/7gHRxx2qG0NLTSXN9MVU0l/3X1u5ix/7RyhyZDUGDGt047k0VTp9GUSdOYyTC5qopvn3YmEys7f7tV2HcWkyoracpkaMpkOGLadL556pmDnqCIBAHfPf0sFk6eQkMx9mnV1Xzn9LMYl+o8wmh69Ri+eeoZjE9V0FiM/ajpM/jGKad3uUDly/edwweOOgaApkyGTC7Haw5ewMWHHd7n2GORCJedcRYLJk3eHfusmhouP+McapJ79w1fW2fMnce7jziSsJgYzObzvP6QQ3njwsP6XLeISDfWAm0/zc4obhORfpCKxfjeGWez39jxNGYyNGQyzB03nu+dcTbJaM9JnV+98tUsmDiZfOjkwpCIBbxj0RG8bkHPyZmjps/g4y85gVgQ0JjJ0JrLce7+B3R5k5JSmRnfPOUMjpw2g6ZMhsZMhgmpSr552plMra7m48cdz+n7zaMlmy18uRmJlHyHOREZfnTXtiGmYXsjLY2tTJg+jkBTWaQE21taSOdzTK6s6vHOH1AYHr2xqZFEJMrYVM/DogfDtpZmsvmQSZWVe4w9dGdjYyOpWHSPQ7qhMJx6c3MT45IpUnv57VtPtjQ3kw9Li7230rkcW1qaByx2keFEd23rOzPbB7ipm7u2nQ28n8Jd244GvufuR+2pzpHYBxMZaJubmsBgYg9T2rqyvqGB9Y0NzJ84qVfT9LP5PJuam6hJJKnqsH5kX+xobaE113XfsyGdpj6TZnJllabliwxzPfXB+rZgiPS76rFVVI/VXGIpXW8SQmbGlKrqAYymd7oagdSdwIyp1aXHHo9EmN7FelH9pav1mfpLIhod0NhFZPQws98CJwETzGwN8AUgBuDuVwI3U0giLQeagbeWJ1KRka+rUeOlmFpd3as+0C6xAeoL9fSFXnUiQXUi0e/PKSJDixJJIiIiIiOUu79uD/sdeN8ghSMiIiIjgMYbioiIiIiIiIhISZRIEhERERERERGRkiiRJCIiIiIiIiIiJVEiSURERERERERESqJEkoiIiIiIiIiIlER3bRMZptwdsg/iLTeBN0PiZVjyVMziXZZvSLfy7fvu4faVK0hGo7zhkEN508LDCIKhn0/e0drCt+69m38/v4qKWIw3LTyMNy48rNvynt+Ct/4ZMk9AdB8s9SosOqv78tllhfK59RBfjKXOwYKaLsuGYQjNV0PLn8BzkDgdqj9IECS7LN+SzXLL8mXc+fwqapNJzjvgIBZNndaL1vef0J27nl/FLcuXkXfn9P3m8rJ95hAZBq+Bgeb5dXjz9ZBbDrEDsNQrsciU8sQSNuAtN0LmQYhMwlLnY7GDyhKLiIiIiEhHVrjr6/C0ePFir6urK3cYImURNv4MWn4DbkAAlofoIVjtNzGLtSvbnMlwyq9+zubmJswMKCSiTt53Dleec/7gB98LjZkMp/zyZ2xtad4dO+6cOXd/Lj/znE7lPb8O3/4eCBvA4kAWiGG1l2KxhZ3Kh613QsNXgJBCbj0HwURs7A+xYFzn8lvfANmHANv1jBCZCeNvJgja5+Zbc1ned/NNLN+2lWgQkAtDAjPee+TRvHr+gj6clb1z6T13cvPyZRiGGeRD56Wz9+HLJ5384rkdhTy3HN/+QfA0WAw8C0EKq/0eFp0zuLGE9fj290K4nt2vRwKo/hRB8uRBjWWoMLMl7r643HFIe+qDiYiIjGw99cH0NbTIMOT5zdByLVAFwRgIqoAxkHsCMvd1Kv/jh+vY0tJMNAjaPW5ftZJlW7cMevy98f0H7mNrh9gjQcAtzz3L8zu2dyrvTT8Db4CgFqwCrAZwvOEyOibO3fPQeBkQK5SzysK/+U148x871R2m/wPZhyl8wG/zyK+Blt93Kn/biudYvm0rYxIJKuNxapJJUrEYV9U9QEM63feT0wvPbdvKzcufpSqeoDqRoCqeYEwiwd0vPM9jGzcMaixDjTd+HzwDQU3hNRPUQNiCN145+LG0/LmQRGr7eiQOjZfjnhn0eEREREREOlIiSWQ4yj1JYRRS5MVtZuCOZx7oVPyOlStxp92ok10/37Zi+UBH2yd3Pr8KM+sm9uc6H5B5AKjssLEC8qsKUwDbyq8HbwTrMC3NkpC5t3Pd6dt3FWhbGHBI/7tT8ftWv0DQIfZocRrZsm2Dm8B7fNMm3J2gw3nMhnke27RxUGMZStwdMo+CVbXfYdXFkWeDLHMv0GF6qiUKo6Xyqwc/HhERERGRDpRIEhmOrLqbHQ7B+E5bx6dShX1dmFjRMekytIxLpboYSVT4fVJlF7EHNRSmA7WVpzDqqMMH9KAKCMHD9ts9B11Ma+tyWw/7xldUEHYRe+jOmHjXayoNlOpEvF0SaZeoBYxJJAY1lqHEzIqvg46vmRzYmDIENLbw+mvLHcj38HcvIiIiIjJ4lEgSGY5ihxYSF95Q/JAJeCtYDEue1qn4JUcchZmRDwsJE3cnF4Yko1FeddDBgxl5r11yxJFdxl4Ri3HWvAM6H5B6DZABzxd+97Aw6ih5Vqe1oyyohfix4PVtzmMOLI+lLuhcd8XreXHdml0JojwQQOXbOhU/d/8DCczI5HO7Y29Ip5ldW8vccT0kpQbAcTNmURmL0ZjJ7E7ENWezJKJRTpy9z6DGMuSkLgCaX0woelgYvZa6cNBDsYoLwLywThMUXpe+E2KLsMikQY9HRERERKQjJZJEhiGzCFZzKUSmAY3gTYVFgsd8AYtM71T+qBkz+MgxLyEoJmTy7lTF4/z03Ffunmo1VL109r6878ijdyeT8u6MSST4+Ste1WXsljwbUq8GWopT2RohcRJW9e4u67fqT0D8CKChcB7JQOU7scRxncoGwRio/R6QpJBAygERqP4sQWxep/L7j5/Ap084Ebyw4HljJsPcceP535NPH/TFrVOxGN8+/SzGp1I0Z7M0ZTJUxWNceuoZ1CZTgxrLUGMVb4DkmUBT8TXTBKlzsYrXDH4s8cVQ+V4gW4ylAeKHYmM+M+ixiIiIiIh0RXdtExnG3B3yKwvrp0T3wzpO3eqgMZPh36tWUJ1IcPzM2QRDPInUVkO6lX8/v4qaZJKXzJi1x9g93AH5tYU7sJUwksPz6yDcDpHZWFDVY9kwzEHmzsJ5T7yMIOh5mlo6l2P5tq1UxuPMrqkt6x3SQnee27aNvIfMGzeeyDB6DQw0z2+FcANEpnZ5x75BjSVsLvxtB7VdJodHE921bWhSH0xERGRk66kPpkSSiIiIDFlKJA1N6oOJiIiMbD31wfRVtIiIiIiIiIiIlESJJBERERERERERKYkSSSIiIiIiIiIiUhIlkkREREREREREpCRKJImIiIiIiIiISEmUSBIRERERERERkZJEyx2AiOy9ZVu3cOvyZ2nOZTlh1j4cM2MmgVm/1L25YQ2/WvJjntvewOSKGK897AIOmHxUv9QN8NSWzdz23HJaczlOnL0PR06f0W+x95bnN+Ctt0J+PcQWYcmTMEuUJRYREREREZGhTIkkkWHqj08t5fsP/Ie8hxjGLcuX8dJZ+/DFk07uc0Jm5ZbH+OAt17I9nQSvBuCOtTfy6eOe45QDX9fn2K974nGuXPLA7thvXv4MJ++7H5854aRBTyZ55lF85yfBs4BB+h94y++h9nIsqBrUWERERERERIY6TW0TGYZ2tLbwwwfvJxWLUptMUZNMUh1PcOcLq3hw7Zo+1/+D+65hW2uSymiWyliOyliObBhw5ZKH+1z3luZmrlryAKlYbHfsVfEEt698jkc2rO9z/b3hHuIN/1P4JaiBYAxQDbmVeMufBzUWERERERGR4UCJJJFh6LGNGwGIBpHd28yM0OHu1c/3uf6l2xIkIvl221KRHBuaK3hh25N9qvuRDesAiAYv/vcTmJEPnftWv9Cnunst3ADhViD14jYzsASk/zW4sYiIiIiIiAwDSiSJDEPJaNezUg2ojMX7XH8iyOPefpsDZk4qNqZvdUejWBfT18yMynjfY+9lNBRa1lEIVjHIsYiIiIiIiAx9SiSJDEOHTZlKZSxGUyaze1s2nycw47T95va5/uOmRUmHEcJijsUdmvMx5o9tYGL1jD7VfeS06SSjUZqz2d3bMvk8kcB4+b5z+lR3b1lkPMQWAvXszpx5CJ7FUucPaiwiIiIiIiLDgRJJIsNQPBLhG6eesTuZ1JTJkMnn+eixL2HO2HF9rv9DJ3yGwyfU05KP0ZqP0JKPMrOyic+87B19rjsZjfGNU04nGY3ujj2Xz/Opl7yUWTW1fa6/t6z60xDZB2gEbyr8m3oVJF426LGIiIiIiIgMdeYd568MI4sXL/a6urpyhyFSNpl8nsc2bqA1l2Ph5CmMSfTvLesffuGfPLb+EabXTONlc19NpJspdXsjk8/zyIb1ZMM8CydNobqfY+8N9xByT0G4HaLzsMjkssUiIu2Z2RJ3X1zuOKQ99cFERERGtp76YP33qVBEBl08EmHxtOkDVv+iWSezaNbJA1J3PBLhqOl9mybXX8wCiB1c7jBERERERESGPE1tExERERERERGRkiiRJCIiIiIiIiIiJVEiSURERERERERESqJEkoiIiIiIiIiIlESJJBERERERERERKYkSSSIiIiIiIiIiUpJouQMQkRc1ZTLc+cIqNjQ2csD4CRw1fQbRoH/yve7O01u38ODaNaRiMV46ax8mV1V1Wz4Xhty/djXLtm5lalU1J8yaTWU83i+x9Ja7Q+4pPLMErApLHI9FJpYlFpGB5h5C9mE8uxQLxkHiBCyoKXdYIiIiIiKAEkkiQ8bzO3bwgb/dREO6lWzoxIOAuePHc9npZ1MRi/Wpbnfnsvvv5S/PPE0uDImYcWXdA3zupS/jpH327VS+KZPhw7fezPJtW8mGIbHA+FFdkivOPIdZNbV9iqX3sYd443eg9W/gObAI3nQlPuYLBInjBjUWkYHmnsF3fg6yS8BzOFFouhJqLsVi88sdnoiIiIiIpraJDBXfuOdOGtJpqhNJxqVSVMbjPL1lM7974tE+1/3whvXc8MzTVMXjjEulqEkmiQYBX7vrDpoymU7lr338UZ7Zsnl3+epEkp3pNN+4564+x9Jr2bpCEokqCMaB1QBRaPga7q2DH4/IAPLWWyHzIFBdeL0HY8CzeP1XCyOVRERERETKTIkkkSGgPt3Kk5s3UdVm6piZkYrGuPW55X2u/45VKwg9JDDbvS0RjRK688jG9Z3K/33FclKxGNamfHU8zhObNlKfTvc5nt7w1n+BO1ib/64sURidlH18UGMRGXCtfweLQZu/PaiAcAvkV5ctLBERERGRXZRIEhkCjMKHRu+w3aFd8mdvRYIA6LqeiHX+byAw6zIW66d4esUidD4zu0QGMxKRQdDda9rRW7aIiIiIDAXqlYoMAdWJBIumTqOxzWgfd6c1l+Wc/Q/sc/0n77sfZkY+fHFqTGsuSzwSYdGUqZ3Kn7P/gbTmsoVFrosa0mkWT5vebtTUYLDEqYXRSJ5/caO3gCUhtmBQYxEZcMmzgRy0ncbmjRCZUXiIiIiIiJSZEkkiQ8QnX3ICk6uqaMyk2dnaSmMmw1HTZnDhQQf3ue4FkybzloWH0ZzNUp9upSGdBoyvvvwUEtHOa+6/Zv4CFk+bTmMmU4glnWZqVTUfP+6EPsfSa7GFkHot0AS+E7weCLAxX8asPHeRExkoljwZEicDjRDuBG+AoBob8/l2U01FRERERMrF2o44GG4WL17sdXV15Q5DpN9k83keXLeWTU1NzB03joMnTurXD49rG+p5aP06kpEox8yYSXUi0W1Zd2fp5k08t30bEysqOXLadGKR8k0l89xqyD4KloL40VhQVbZYRAaa55ZD9ikIagqvd+v+b3WkM7Ml7r643HFIe+qDiYiIjGw99cE6D0UQkbKJRSIcN3PWgNU/vXoM06vHlFTWzFgwaTILJk0esHh6w6IzITqz3GGIDAqLzoXo3HKHISIiIiLSiaa2iYiIiIiIiIhISZRIEhERERERERGRkiiRJCIiIiIiIiIiJVEiSURERERERERESqJEkoiIiIiIiIiIlESJJBERERERERERKUm03AHI6OT5LZBdAkQhfhQWVPdb3fkwZMn6dWxqamTO2HEcNGEiZtZv9Q+kXBjyUDH2/caN58DxE3qMvTGT4f61q0nn8hwxdRqTq6p6rN/zGyD7CJAonvfK/m3AMOWegcwSCLdDbP/CrddFREQGQWtzmsf+/SQtDS0cePQ8Js+eWO6QREREejQoiSQzmwn8EpgMOHC1u1/eocxJwF+AlcVN17v7lwcjPhlcYfOfoOmH4A5mQBQf83mCxLF9rntLczP/detfWdtQTxg6ZsbhU6fx9ZefSiI6tPOmm5oa+dDf/srGpsbdsR81fQZfedkpxCORTuWXrF/Lp/95G9kwj3th2zsOP4I3HHJYl/WHTb+G5l8UfzMgDjVfx+KHDkRzhg3Pr8V3fBTCbUBY2BY/CRvz35h1Pu8iIiL9ZfkjK/nmW39AujlDGIYYxlnvPJnXfPy8YfMlmIiIjD6DNbUtB3zU3ecDxwDvM7P5XZS7y90PKz6URBqBPPd8IYlECoIxYNVAAPVfxsPGPtf/7fvu5oWdO6iKJxiTTFIVj/Pg2jX89onH+lz3QPvGPXexvqGhXez3rVnNH59c2qlsay7LZ2//B6E7VfEE1YkEqViMnzy0hKe2bO5U3rNPFpNIFWC7znuI138W9/SAt20o8/qvQbgFrKpwbqiCzL/w1r+VOzQRERnB8rk8l73rKjKtWSrGpKiqrSRZneTmH/+Dpfc+U+7wREREujUoiSR3X+/uDxV/bgCeAqYPxnPL0OLpf4PnwdqMDrIEkIPMg32quzWX5b7VL1CdSL5YtRmpWIy/Pju0O2QN6TRL1q2lKpHYvc3MSEYj3Pjs053KP7R+PZl8nlQstntbNAjIe8g/VzzXqby33g6EHc57CjwN2Uf7tS3Diec3QW4Z0GZqpQVADFr/Wq6wRERkFFj+yCqadjaTqnqx3xKJBITu3H39/WWMTEREpGeDvti2me0DLAK6eoc81sweNbNbzOzgbo6/xMzqzKxu8+bOIy9kqMuBeff7+iD0wrzJjgPBzYxcGPap7oEWFuemdYodI5fvHHs+DCm0trNcmO9qa3fFwft23oe3rs4VgIFnBzUSEREZXfK5PJ3f+Qv9lmxmNL83i4jIUDeoiSQzqwL+CHzY3es77H4ImO3uhwJXAH/uqg53v9rdF7v74okTtRjhcGPx44BIYVTSLp4FDOJH9KnuiliMQydPoSGTebFqd5ozGU6ds1+f6h5oNckkB0yYSGPmxWlm7k5LLstp+3Ve+PmwKVMxMzL5F89j6E7EAk6cvW+n8pZ4aWGkjbdJSnkGCCC2sF/bMqwEUyAyDbzpxW3uhZFayVPLF5eIiIx4cw/bh1giSqalTb+l+K3YsecuLmNkIiIiPRu0RJKZxSgkkX7j7td33O/u9e7eWPz5ZiBmZhMGKz4ZJNEDIHUh0FS4Q1a4A2iFqg9iwbg+V/+x446nJpGgIZ1me0sLjZkMc8aO5Y0LF/W57oH2yZecQFU8QX26dXfs88ZN4KIFnRM91YkEn3rJiWRyOXa2trC9pYWmTJpz5h3AYVOmdq48tgiSZwKN4LvOewaqP4kFPd/pbSQzM6z6MxAkwOsLr0kaIbYAS72i3OGJiMgIFk/Gec93LyafD2nY1kj9lgaaG1o4+uzDOfyUQ8odnoiISLfMvbv5Lv34JIXbTlwDbHP3D3dTZgqw0d3dzI4C/o/CCKVuA1y8eLHX1dUNRMgywDz7DJ75DxDHEsdj0Zn9VndjJsO/V61kXUM988ZP4LiZs7q869lQ1JBOc8eqlaxvbOCgCRM5ZsZMYj3Evq6hnn+vWklzLscx02cwf+Kkbu/y4u6QexLPPACksORJWGTKALVkePFwJ956B/gWLDof4kfpjm0iQ4SZLXF3Dc8YYtQH6z9b12/ngZsfoqm+mQUvOZADjpyrO7aJiEjZ9dQHG6xE0vHAXcDj7Lq/NnwamAXg7lea2fuB91BYKKcF+Ii739tTverEiIiIjGxKJA1N6oOJiIiMbD31waJdbexv7n43Xa0m2L7M94HvD0Y8IiIiIiIiIiLSe4N+1zYRERERERERERmelEgSEREREREREZGSKJEkIiIiIiIiIiIlUSJJRERERERERERKokSSiIiIiIiIiIiUZFDu2iYipQnDkNtXrWTF9q0cN3M2CyZNLndIIiIiUibuzqqlq9m+cSez589g/NSx5Q5JREREiSSRoWJN/U5e/YffsbW5GQy47x4WTprM7y68iGigwYMiIrJ3zOwM4HIgAvzE3f+3w/6LgW8Ca4ubvu/uPxnUIKWT+m0NfPvtP2LV0tUEkYAwF3LyG0/gjZ+7kED9AhERKSO9C4kMEe+44U9saW4iEhjRICBixqMbN/CVf99e7tBERGSYMrMI8APgTGA+8Dozm99F0evc/bDiQ0mkIeDHn/w1Kx57nooxKVJVSVJjktz2y39zz58eKHdoIiIyyimRJDIEbG5qZMX27USDADMDwMwIzLjx2WfKHJ2IiAxjRwHL3X2Fu2eA3wHnlTkm2YPGHU08dsdSKmsrd/cLgiAgGo9y6zV3lDc4EREZ9ZRIEhkCGjPZLrcbkM3nBzcYEREZSaYDq9v8vqa4raMLzOwxM/s/M5vZVUVmdomZ1ZlZ3ebNmwciVilKt2QAo5hD2i0SCWipbylLTCIiIrsokSQyBMyuqaEqESfv3m573p1DJk0pU1QiIjJK3Ajs4+4LgduAa7oq5O5Xu/tid188ceLEQQ1wtBk3pZYJM8bR2pRutz3dkuaosw8vU1QiIiIFSiSJDAFBEPDFE19OgJHN58mFIdl8nlQsxtdefmq5wxMRkeFrLdB2hNEMXlxUGwB33+ruuzIWPwGOGKTYpBtmxiWXvokgCGjc3kjTzmaadjQxadZEznrHyeUOT0RERjndtU1kiHjFAQcxZ+w4rrj/Xl6or+eIqdP4wFHHMrmqqtyhiYjI8PUgMM/M9qWQQLoIeH3bAmY21d3XF399BfDU4IYoXTngyLn8762f5Y7r7mXj85uYf+z+HPuKI0lVJssdmoiIjHJKJIkMIQsmTeaqc19Z7jBERGSEcPecmb0fuBWIAD9z96Vm9mWgzt1vAD5oZq8AcsA24OKyBSztTJwxnld/9NxyhyEiItKOEkkiIiIiI5i73wzc3GHb59v8/N/Afw92XCIiIjI8aY0kEREREREREREpiRJJIiIiIiIiIiJSEiWSRERERERERESkJEokiYiIiIiIiIhISZRIEhERERERERGRkiiRNIyFYcjzT61hzbJ1hGFY7nAGVHM2y1NbNrOxsbHcoQy4zc1NPLVlM42ZTLlDGVU2Njby1JbNNGez5Q5FRESGqNbmNCsee54t67b16rhcLscDf3uI+25aQi6X69WxW9dvZ8Vjz9PS2NKr4/Y2VhERkT2JljsA2TvLljzH9z/wUxq2NeKhM376OD74w3cy+6AZ5Q6t3133xOP85OE63J28O0fPmMFnT3gZVfF4uUPrVy3ZLP97953c+cIqIoHhDm9eeBhvPnQRZlbu8EashnSar955Bw+sW0MkMAzjHYsW89oFh5Q7NBERGUL+fs2/uO7SG/AwJJ8LOfj4A3jf5W+jckxFj8fd85cHufTiK0g3F74giidi/NdV7+Jlrzu+x+Namlq56qPX8PA/nyASLXz3+8oPnc057zp1j/2Cv/38dn7/zRvAnXwuzyEvnc97vnvxHmMVEREphUYkDUP12xr45sU/oGF7E6nqFKkxKbas28Y33vQ90i3pcofXr+5Z/Tw/WnI/0SCgIh6nMh7nvtWr+eY9d5U7tH73vQfu447nV1IZj1MRi5OIRvnZIw/xz5XPlTu0Ee3Se+/kP2tf2H3eo0HAj5bcz32rXyh3aCIiMkQ8dueT/PqrfyQSDUhWJamoSfH4nU9x1cd+2eNxO7bU8/XXfZd0c4ZINCAai5BJZ/nm237Ixuc39XjsLz73O5bc9hgVY1Ikq5JEEzH+8K0bqPv7oz0e9+gdS7n2a9cTjUUKsY6p4NE7lvLjT/661+0WERHpihJJw9CDtzxCuiVDqioJgJlROaaC5oYWHr3jyTJH17+uW/o4gRmxSASAwIzqRII7X1jFztbWMkfXf1qyWf7+3LNUxeMExW8Zo0FALBLwuyceL3N0I9eO1hbufuEFqhPJ3ec9FolgGL9/8okyRyciIkPF335+O2ZGNF4YzG9mVNZW8ui/nmDH5p3dHveny28mnwuJxiK7RxFFYxHCfJ7rL/trt8c11Tfzn5uWUFlTgQUvHhdEA27+8T96jvVnt2ORNrEGRmVtBQ//43Hqtzb0qt0iIiJdUSJpGKrf1kA+l++0Pcw7jdtH1hpC21paiAaRdtsCM8xsRK0h1JzNEjq7kxm7RIMI21p7tyaClK4hncGs83mPRSJsbWkuU1QiIjLU7Ni4k2isQ38kMIJIQNPO7t8vdmzaibt32u4O2zd2n4BqaWzFgCDSvqsejUXYubm+x1i3b9xBNNZ+9YogCAgi1mOsIiIipVIiaRg6YPF+ROPRdh2TMAwxg3lHzCljZP3vmOkzac21X/y4NZejOh5nSlVVmaLqf+NSKSZVVtLSYQHO5kyWo6ePvHWvhoqp1dVUxeK0djjv6VyWY2fMLFNUIiIy1Bz2sgVkWtv3RzKtGRIVCSbPntjtcUeddThmhocv9tncHQuMxacf2u1x46bUMmZCNenm9ksWpJszHHrSwT3H+vIFZFraf9mWac2QrEwyadaEHo8VEREphRJJw9CBR8/j0BPn07ijieaGFprqm2ne2cIJFxzDzAOmlzu8fnXRgoWMT1Wws7WV5myW+nQruTDPR459CZFg5Lx8zYyPHns87r67rTtbW6lNJnjLoYvKHd6IFQ0C/uvYl5DL56lPv3jex6cqec18LbYtIiIFZ7zt5YybOpbGbY20NLbSuL2JXDrHxV++qNPon7aOPfcI9l04i3wuJJfNkcvmyWfzTJ87hVPedGK3xwVBwMVfeR35XEjj9kZam1pp2N7ImAnVnPue03qM9cy3n8zYybU0bCsc17ijiWw6x8Vffi2RaKTHY0VEREphXQ23HS4WL17sdXV15Q6jLHLZHPfdUMfdf7qfSDTCia8+liPPXEQwgpIru2xvaeFPTz9J3bq1TKsewwXzD+agCd1/+zecPbt1K3948glW1+9g0ZRpvPKg+UysqCx3WCPeU5s38X9PLWV9QwNHTp/OKw+cT20yVe6wRAQwsyXuvrjccUh7o7EPVr+tgX/8+i6euOtJJkwfz2lvOYm5i/bd43G5XI5ffen/uP3au/DQeemrj+XiL7+WeHLPd59d+cQL3Przf7Hphc3MP/YATnnTS6mdWFNarL+6kyfufooJ08dz+ltfxn6H7lNKM0VERICe+2BKJImIiMiQpUTS0KQ+mIiIyMjWUx9s5A1fERERERERERGRAaFEkoiIiIiIiIiIlESJJBERERERERERKYkSSSIiIiIiIiIiUhIlkkREREREREREpCRKJImIiIiIiIiISEmUSBKRstnZvImtjWsIw7Df687m82xsbCSdy/V73SIiMjrlcjmWPbSC7Zt2dNqXz+d59N9LWfH4qn59ztbmNFvWbSOfz/drvSIiInsrWu4ARGT02dL4Aitf+BRTksvBYXV2EjUTPse+E47ul/r/9PST/PihOlpzWSIWcOH8Bbxj0RFEAuXORURk7/zyS3/gD9/6C9lM4QuKeYfP4X9u+TRVtVX85mt/5Fdf+j35XOGLkYoxKS79++c54Ki5e/182UyWa79+PXf87h48dCrGVPD6z76K48/vn/dKERGRvaVPVSIyqMIwz7o172JKcjnNuSQt+SRjY5sJt3+UHc0b+lz/7Suf4/L/3EvoTlU8QSwS4drHH+WaRx/uh+hFRGQ0+vsv/821X/8juWyeaCxCEAlYtuQ5PnHqV1hy26P84nO/251EAmiub+HDL/1cn0YRXfu16/nHr+4knopTUVNBJp3hxx//FU/c/VR/NElERGSvKZEkIoNq2cbbqY1toyWfwszAjHSYJB5keGbd7/pc/68fe4RoJCAeiQAQDQIqYjF+v/Rx8gMwhU5EREa+677xJ3AnEi10nYPAiEYjrHjseb7/oZ8BYIHtfgDkMjn++J2b9ur5WpvT3HHdPVSMSRGJFt7P4sk4BMaNV/69H1okIiKy95RIEpFB1Zxe1+V2MyefXd/n+jc0NRGPtJ+1Gw0CWnI5WrRekoiI7IUdm+qxDtOjLTAM2L5+e6fyu5JJzz+1Zq+er3F7I+7sTiLtEkvE2Lx6617VKSIi0l+USBKRQTWh+lAMx91f3OiOu1FRcVif6z9k4mSaMpl221pzOaZUVVEZi/W5fhERGX32XTCz040hwrxjgTHviDmdyntYeI97yflH7tXzjZ1cS6oqSaY12257uindp3WXRERE+oMSSSIyqGaNP4w16UVURluIWYaoZamItrA1M4n508/vc/3vOHwx8UiE+nQrmXyehnSaXBjy/iOPKUylExER6aVLvv0WotEIuUyOMBeSy+YJ83lOefOJfOxn7yOIBnjoux8AE6aN47hXHLVXzxeJRnjdf7+STEuG5vpmsuksjdsaSVUmecV7T+/PpomIiPSaEkkiMuiOPOAK1vtbqc+NpzlXxZrsucyd8yvi0VSf6543fjxXnXMeJ83elzHxOIdPncZlp5/FCbP36XvgIiIyKu1/+By+9a8vMu+I/YglYoydVMNbv/o6PnLVu5k8ayI/eOB/mXHgNIJIQDQWZfHph3LNiiv69JwvvfBYPvaz9zLv8P2orKnkuPOP4kt/+QRT953cT60SERHZO9Zueskws3jxYq+rqyt3GCIiIjJAzGyJuy8udxzSnvpgIiIiI1tPfTCNSBIRERERERERkZIokSQiIiIiIiIiIiVRIklEREREREREREqiRJKIiIiIiIiIiJREiSQRERERERERESmJEkkiIiIiIiIiIlISJZJEREREZMQJw5BcNtfr49ydbCaLu3e5f8eWHeRyXde7bcM2Ghsbu963rYFt2xq63JfL5Whtbu0xnr2Ry+a6bYeIiMjeipY7ABERERGR/pJpzfD7b93A7dfeTaY1wwGL9+PNX3wNs+fP3OOx997wIL//5g1sWbOVsVNqueDDZ3Pia47DzLj0rT/gH7+8g115mbFTavnZk9+lqraK71zyI275ye2767HA+MbfP8uily/krz++jcvedXW753n711/PRZ96JfXbGvjyhd9m6b3PEOZDxk2t5YM/eAfHnnskYRhy84//wU1X3kbjjiZm7D+VN3z2Qg454aA9tuPJ/yzj11/+Ay88tZaKMSnOfMfJvOK9pxOJRHp3MkVERLpgw/lbisWLF3tdXV25wxAREZEBYmZL3H1xueOQ9oZyH+zy915N3a2PkqpOEYkGNO1sJpGM8z+3fpYJ08Z1e9yDf3uYK97/U2KJKPFUnGxrlkxLhrf/7xtZ8ehKrv36nzodU1VTwbu++xa+/bYfdVnndeuu4rXT3tXlvp888W2+dMG3Wbt8A5FYBDPIZ/MEkQjfu+9rPPqvJ/jLD/5GoiJBNB6ltSmNhyGf+e1/Me/wOd22Y9XS1Xzpgm8CkKxKksvmaW1s5cy3n8zrP/2qnk6diIjIbj31wTS1TURERERGhE0vbOah2x6jqraSaCyCmVFVW0m6JcPt197d47H/992biMYjJCoSmBnxVJxYKs4fv3sjf/jOTV0e07izmcvf++Nu67z4gA91u+9jJ3+Jdc9tJBqPEASGmRGNRwnzeX7+md9y809uJ1mVIpaIYWakqpKEofOXH/6tx3bcdNXfyedDUtUpzIxYPErFmBS3/erftDS29HisiIhIKZRIEhEREZERYdPqrYXRPYG12x5EAl54ak2Px25ctZl4Kt5uWzwZY9v6HWRbu1+jKNfa/TpMLY1dr3sE0LClEQvArH2sGKxZto58Lk801n4qWiIVZ+2y9T20AlY/vY5YItZuWyRaqGf7xp09HisiIlIKJZJEREREZESYOmcy+WxIGIbttof5kP0O26fHY2fsP5V0U7rdtnRLhsmzJ5KsTHR7XKIy3u2+6rFV3e4bN7UWD8HDDstMOOy3aF9i8SjZTPskVbo5w5yFs3toBcxZOJtsa6bdtlw2TxAY46aO7fFYERGRUiiRJCIiIiIjwvipYzn+VUfRtKOZTGuGfC5Pw7ZGKmsqOOm1L+nx2Nd+4nzCfEhzQwthPqSlsZVcOsdrPnEeb/7ia7o8ZuyUGj7z2490W+cvV13R7b7v3P1l9l04i3wuT5gLCUMnl84RjUV561cu4vwPnklrYyvp5jT5fEjTzmaisQiveO/pPbbjnHefSiwRo3FHE/l8SLo5TUtjC+e8+zSSFd0nxEREREqlRJKIiIiIjBhv+9rrec3HzyNVlSKXyXHkGYfxhT9+jLGTano87pATDuLjP38fsw6cTqYlw7Q5k/nwVe/i6LMO59UffQWv//QriURf7DrPPngG175wJceecwRv+epF7eqKJqL8fNn3qKqq4mu3fIYg8uL0NQuM//7th5gyazLfvfPLnHDBMURiEQidmQdN59J/fJ6ZB0znrHecwjsvfSNjJ9eSLd597jO/+6893n1u+typfO73H2X+sQeQbc1QM2EMb/vq6zj//WfuxdkUERHpTHdtExERkSFLd20bmtQHExERGdl01zYREREREREREekzJZJERERERERERKQkSiSJiIiIiIiIiEhJlEgSEREREREREZGSKJEkIiIiIiIiIiIlUSJJRERERERERERKokSSiIiIiIiIiIiUJDoYT2JmM4FfApMBB65298s7lDHgcuAsoBm42N0fGoz4ZGh7dutWrn7oQR7fuIEJFZW8ceGhnL7fPAovGREREZHSuDv33VDHX37wN7au387cRfvymo+9gjkLZ/ep3hWPreLbb/8Rq5auJogEHH3W4Xzkp++hoirFtg3bufTi7/PE3U+Dw4HHzOMTP38fk2ZN7KdWiYiIDK7BGpGUAz7q7vOBY4D3mdn8DmXOBOYVH5cAPxqk2GQIW7ljO++7+QYeXLeGIAjY2NTI/9x9J7994rFyhyYiIiLDzG2/+jdXfuQXbF6zhUg04Mn7nuGrr/0Ozz+5eq/r3LxmKx86/nMsf3QVDuSzee6+/n4+dNxnyOVyvHfxJ3nk9icI807ozuN3PsV7F3+KTGum/xomIiIyiAYlkeTu63eNLnL3BuApYHqHYucBv/SC/wC1ZjZ1MOKToevaxx8lnc8zJpEkGgSkYjEqYjGuefRh0rlcucMTERGRYSKXzfF/37mJRFWSZGWSSDRCVW0luWyeP19xy17X++uv/h/Z1gyxeJQgMIJoQCQWYfXT6/jxJ37Djs31RGIRgogRBEY0HqFxZ1OfnlNERKScBn2NJDPbB1gE3N9h13Sg7ddBa+icbJJR5snNm0hG28/AjEUi5MKQzc1NZYpKREREhpudWxrINKeJxdv3KxIVcVY+/sJe17us7rlO2ywwzOCJu57EQ283Hd/M8NBZtmTFXj+niIhIOQ1qIsnMqoA/Ah929/q9rOMSM6szs7rNmzf3b4Ay5MyuHUs6337kUS4MMWBcqqI8QYmIiMiwUz2uikgsSi6bb7c905pl6n6T97remftPA9qv2+juuMO+h8zCgs5rOlpgzDpw2l4/p4iISDkNWiLJzGIUkki/cffruyiyFpjZ5vcZxW3tuPvV7r7Y3RdPnKhFCke6Nx5yKIEZzdkM7k42n6cxk+aVB82nIhYrd3giIiIyTMQTMc58+8tpaWghm8nh7rQ2tQJw3vvO2Ot63/SFVxOJBuSKdYahk8/mGTe1lvd+760kKxOF5wsdD51cJk88GeNVHz67v5omIiIyqAYlkVS8I9tPgafc/TvdFLsBeLMVHAPsdPf1gxGfDF3zJ07if08+nSmV1exMt+I4Fx96OO8+4qhyhyYiIiLDzKs+fDYXfuQcDGjY1si4KWP50I8u4cCj5u11nTMPmM6X/vQJxk6pJZ/NE+ZD5i7al+/d93Uqqiq47K6vMmPeNPK5PPlcnilzJvGtf32Jqtqq/muYiIjIIDJ3H/gnMTseuAt4HAiLmz8NzAJw9yuLyabvA2cAzcBb3b2up3oXL17sdXU9FpERwt1J53PEI1EC6zxEXERERiYzW+Lui8sdh7Q33PtgYRiSTWeJJ+Pt1i/qq6b6ZmLxKPFkvNO+5sYWACqqUv32fCIiIgOlpz5YtKuN/c3d76bj5PHOZRx432DEI8OPmZGMaiqbiIiI9F0QBCRSiX6vt3JM9+s3KoEkIiIjxaDftU1ERERERERERIYnJZJERERERERERKQkSiSJiIiIiIiIiEhJlEgSEREREREREZGSKJEkIiIiIiIiIiIlUSJJRERERERERERKokSSiIiIiIiIiIiURIkkERERkRHMzM4ws2fMbLmZfaqL/Qkzu664/34z26cMYYqIiMgwoUSSiIiIyAhlZhHgB8CZwHzgdWY2v0OxtwPb3X0u8F3gG4MbpYiIiAwnSiSJiIiIjFxHAcvdfYW7Z4DfAed1KHMecE3x5/8DTjYzG8QYRUREZBhRIklERERk5JoOrG7z+5riti7LuHsO2AmM71iRmV1iZnVmVrd58+YBCldERESGOiWSRERERGSP3P1qd1/s7osnTpxY7nBERESkTJRIEhERERm51gIz2/w+o7ityzJmFgVqgK2DEp2IiIgMO0okiYiIiIxcDwLzzGxfM4sDFwE3dChzA/CW4s8XAre7uw9ijCIiIjKMRMsdgIiIiIgMDHfPmdn7gVuBCPAzd19qZl8G6tz9BuCnwK/MbDmwjUKySURERKRLSiSJiIiIjGDufjNwc4dtn2/zcyvw6sGOS0RERIYnTW0TEREREREREZGSKJEkIiIiIiIiIiIlUSJJRERERERERERKokSSiIiIiIiIiIiURIkkEREREREREREpiRJJIiIiIiIiIiJSEiWSRERERERERESkJEokiYiIiIiIiIhISZRIEhERERERERGRkiiRJCIiIiIiIiIiJVEiSURERERERERESqJEkoiIiIiIiIiIlESJJBERERERERERKYkSSSIiIiIiIiIiUhIlkkREREREREREpCTm7uWOYa+Z2Wbg+W52TwC2DGI45aS2jjyjpZ2gto5Uo6Wto6WdUL62znb3iWV4XunBHvpgQ8lo+hvdGzo/3dO56ZnOT890frqnc9OzoXR+uu2DDetEUk/MrM7dF5c7jsGgto48o6WdoLaOVKOlraOlnTC62iojh163PdP56Z7OTc90fnqm89M9nZueDZfzo6ltIiIiIiIiIiJSEiWSRERERERERESkJCM5kXR1uQMYRGrryDNa2glq60g1Wto6WtoJo6utMnLoddsznZ/u6dz0TOenZzo/3dO56dmwOD8jdo0kERERERERERHpXyN5RJKIiIiIiIiIiPQjJZJERERERERERKQkSiSJiIiIiIiIiEhJhn0iyczmmVmrmf26m/1mZt8ws63FxzfMzAY7zv5QQlu/aGZZM2ts85gz2HH2hZndUWzjrvif6abcsL+uvWjrsL+uAGZ2kZk9ZWZNZvacmZ3QTbn/MrMNZlZvZj8zs8Rgx9oXpbTTzC42s3yHa3rS4Ee7dzrE3VhsyxU9lB+217Q3bR0B13UfM7vZzLYXr9f3zSzaTdnXm9nzxdf5n81s3GDHK9ITM3u/mdWZWdrMflHueIYSM0uY2U+Lf8MNZvaImZ1Z7riGEjP7tZmtL75vLTOzd5Q7pqFmT59LRqtS+/ejWamfCUaT3vath4Jhn0gCfgA82MP+S4DzgUOBhcC5wLsGPqwBsae2Alzn7lVtHisGI7B+9v428R/QTZmRcl1LaSsM8+tqZqcC3wDeClQDLwU6tcHMTgc+BZwMzAbmAF8avEj7ptR2Ft3X4ZreMUhh9lnbuIEpQAvwh67KDvdr2pu2Fg3b6wr8ENgETAUOA04E3tuxkJkdDFwFvAmYDDQXjxUZStYBXwV+Vu5AhqAosJrC33gN8Fng92a2TzmDGmL+B9jH3ccArwC+amZHlDmmoaaUzyWjVan9+1Gnl33lUWMv+ptlN6wTSWZ2EbAD+GcPxd4CfNvd17j7WuDbwMUDH13/KrGto8mIuK6jyJeAL7v7f9w9dPe1xevW0VuAn7r7UnffDnyF4XVdS23nSHIBheTDXd3sH+7XtK09tXW42xf4vbu3uvsG4G/AwV2UewNwo7vf6e6NwOeAV5lZ9SDGKtIjd7/e3f8MbC13LEONuze5+xfdfVXxveomYCWgRElR8T0rvevX4mO/MoY0pOhzifTBaOwr99aw6G8O20SSmY0Bvgx8ZA9FDwYebfP7o3TdMR6yetFWgHPNbJuZLTWz9wxwaAPlf8xsi5nd08O0kGF/XYtKaSsM4+tqZhFgMTDRzJab2ZrilJlUF8W7uq6TzWz8YMTaF71sJ8Ci4rVfZmaf624K0TDwFuCX7u7d7B+217QLe2orDO/rehlwkZlVmNl04EwKyaSO2l1Td38OyAD7D0aQItK/zGwyhb/fpeWOZSgxsx+aWTPwNLAeuLnMIQ0JvfxcMlqV2r8fVfairzxaldLfLLthm0ii8K32T919zR7KVQE72/y+E6gyG1br6ZTa1t8DBwETgXcCnzez1w10cP3skxSmvkwHrgZuNLOuvgEaCde11LYO9+s6GYgBFwInUJgys4jCUPqOurquUBj6OtT1pp13AguASRS+dXgd8PFBibIfmdlsClMjrumh2HC+pruV2Nbhfl3vpJAkqgfWAHXAn7so1/GaUvx9WF1TEQEziwG/Aa5x96fLHc9Q4u7vpfD/2gnA9UC65yNGjVI/l4xWpfbvR6Pe9JVHpRL7m0PCsEwkmdlhwCnAd0so3giMafP7GKBxqGf4dulNW939SXdf5+55d78XuJzCH+qw4e73u3uDu6fd/RrgHuCsLooO6+sKpbd1BFzXluK/V7j7enffAnyH0q8rQMMAxtdfSm6nu69w95XFIb2PU/hmbzhd013eBNzt7it7KDOcr2lbe2zrcL6uZhZQGH10PVAJTADGUljHoKOO15Ti78PtmoqMasW/+19RGFH4/jKHMyQV+153AzOAYTUifCD08jPYqNSLzzKjUW8+E4xWpfSth4RhmUgCTgL2AV4wsw3Ax4ALzOyhLsoupbAg8y6HMryG7p5E6W3tyIHhNEKnK921Ybhf166Uer2G1XUtrouzhkLcuzd3U7yr67rR3Yf8Ghe9bGenwxlG17SNN7Pnb0yG7TXtoJS2djScrus4YBbw/WLndyvwc7ru3LW7pla4i2QCWDYYgYpI3xVHcP+UwgiBC9w9W+aQhrooWiMJ+va5ZLQaTn2BAdXHvvJosTf9zbIYromkqyn8Z35Y8XEl8Ffg9C7K/hL4iJlNN7NpwEeBXwxKlP2j5Laa2XlmNtYKjgI+CPxl8ELtGzOrNbPTzSxpZlEzewOFlfy7WqNjWF/X3rR1uF/Xop8DHzCzSWY2Fvgv4KYuyv0SeLuZzTezWgpDXX8xaFH2XUntNLMzi2tSYGYHUliseFhdUzM7jsKw7T3dUWK4X9OS2zqcr2vxW8GVwHuK/yfVUpij/1gXxX9DYd22E8ysksLIq+vdXSOSZMgovo6TQASI7Hq/LXdcQ8iPKEybP9fdW/ZUeDQpvodfZGZVZhaxwt1HX4cWlobefQYbdXr5WWa0KvUzwajTi771kDAsE0nu3uzuG3Y9KAyzb3X3zcWObWOb4lcBNwKPA09Q+M/uqsGPeu/0sq0XAcspTC/4JfCN4pDK4SJG4Va9m4EtwAeA89192Ui7rvSurcP9ukJhPv2DFEYsPAU8DHzNzGaZWaOZzQJw978BlwL/Al4Ange+UJ6Q90pJ7QROBh4zsyYKi3deD3y9HAH3wVvoInkwAq8plNhWhv91fRVwBoX/l5YDWQodPIrtPAEKdzMC3k0hobSJwhoi7y1HwCI9+CyFaRSfAt5Y/FnrcLB7DY53UUgEbCj+fTcWP/RKYYTEeyiMnNgOfAv4sLvfUNaohoCePpeUO7Yhotv+fVmjGlq67CuXNaKho8v+5lBlw2hJGRERERERERERKaNhOSJJREREREREREQGnxJJIiIiIiIiIiJSEiWSRERERERERESkJEokiYiIiIiIiIhISZRIEhERERERERGRkiiRJCIiIiIiIiIiJVEiSUSGHDNbZWandLPvF2b21cGOqfjc3cYlIiIiMlyZ2RfN7Nfd7DvJzNYMdkzF5+42LhEpHyWSRKRbZna8md1rZjvNbJuZ3WNmR5Y7rsFQzoSViIiICOz+EqvFzBrNbGOxf1JVwnF3mNk7BiPG/lLOhJWI9I4SSSLSJTMbA9wEXAGMA6YDXwLS5YxLREREZJQ5192rgMOBxcBnyxyPiIxySiSJSHf2B3D337p73t1b3P3v7v7YrgJm9jYze8rMtpvZrWY2u80+N7MPmtkKM9tiZt80s6C4bz8zu93Mthb3/cbMavcmSDM7x8weMbMdxdFTC9vsW2VmHzOzx4qjqq4zs2Sb/Z8ws/Vmts7M3lGMea6ZXQK8AfhE8RvAG9s85WHd1SciIiIyUNx9LXALsADAzI4p9n12mNmjZnZScfvXgBOA7xf7Md8vbr/czFabWb2ZLTGzE/YmDjObZmZ/NLPNZrbSzD7YZt8Xzez3ZvZLM2sws6VmtrjN/sPN7OHivj8U+1JfNbPKYtumFWNuNLNpxcPi3dUnIuWhRJKIdGcZkDeza8zsTDMb23anmZ0HfBp4FTARuAv4bYc6Xknhm7PDgfOAt+06HPgfYBpwEDAT+GJvAzSzRcDPgHcB44GrgBvMLNGm2GuAM4B9gYXAxcVjzwA+ApwCzAVO2nWAu18N/Aa41N2r3P3cPdUnIiIiMpDMbCZwFvCwmU0H/gp8lcLI8Y8BfzSzie7+GQr9svcX+zHvL1bxIHBYsfy1wB96+4VY8UvBG4FHKYxWPxn4sJmd3qbYK4DfAbXADcCuRFYc+BPwi2IMv6XQV8Tdm4AzgXXFmKvcfV1P9YlI+SiRJCJdcvd64HjAgR8Dm83sBjObXCzybuB/3P0pd88BX6cwWmd2m2q+4e7b3P0F4DLgdcW6l7v7be6edvfNwHeAE/cizEuAq9z9/uKoqWsoTL07pk2Z77n7OnffRqHjc1hx+2uAn7v7UndvpvREVnf1iYiIiAyEP5vZDuBu4N8U+lxvBG5295vdPXT324A6CommLrn7r919q7vn3P3bQAI4oJexHAlMdPcvu3vG3VdQ6Cde1KbM3cW48sCvgEOL248BohT6Ull3vx54oITn7K4+ESkTJZJEpFvFJNHF7j6DwjDqaRQSQgCzgcuLw6l3ANsojDSa3qaK1W1+fr54PGY22cx+Z2Zrzawe+DUwYS9CnA18dFcMxThm7nqeog1tfm4Gdi1QOa1DfG1/7kl39YmIiIgMhPPdvdbdZ7v7e929hUIf6NUd+kDHA1O7q6Q43f+p4vT8HUANve9/zaYw/azt834amNymTMe+UtLMohT6Xmvd3dvsL6X/1V19IlIm+gMUkZK4+9Nm9gsK08ig8Mb/NXf/TQ+HzQSWFn+eBewaovx1CiOdDnH3bWZ2Pns3THlXDF/bi2PXAzM6xNqWIyIiIjI0rQZ+5e7v7GZ/u35McT2kT1CYirbU3UMz207hS8DePu9Kd5/X24Ap9L2mm5m1SSbNBJ7rKmYRGbo0IklEumRmB5rZR81sRvH3mRSmpv2nWORK4L/N7ODi/hoze3WHaj5uZmOLx34IuK64vRpoBHYW5/h/fC/D/DHwbjM72goqzexsM6su4djfA281s4PMrAL4XIf9G4E5exmXiIiIyED6NXCumZ1uZhEzS5rZSbv6bXTux1QDOWAzEDWzzwNj9uJ5HwAazOyTZpYqPvcCMzuyhGPvA/LA+80sWlxv86g2+zcC482sZi/iEpFBpESSiHSnATgauN/MmigkkJ4APgrg7n8CvgH8rjg97QkKiyS29RdgCfAIhQUhf1rc/iUKC3DvLG6/fm8CdPc64J0URjNtB5ZT4uLX7n4L8D3gX8XjdiXI0sV/fwrMLw7b/vPexCciIiIyENx9NYUbmXyaQnJoNYUv5nZ9vrscuNAKd9b9HnAr8DcKN1N5Hmil9Gn9bZ83D5xDYY3IlcAW4CcUpsnt6dgMhZu0vB3YQWGdp5so9r3c/WkKC3CvKPa/pnVTlYiUmbWfoioi0j/MzIF57r683LGUwswOopAMSxQXDxcRERGRAWRm9wNXuvvPyx2LiJROI5JEZNQys1eaWcLMxlIYXXWjkkgiIiIiA8PMTjSzKcWpbW8BFlIYKSUiw4gSSSIymr0L2ERhkcc88J7yhiMiIiIyoh0APEphattHgQvdfX1ZIxKRXtPUNhERERERERERKYlGJImIiIiIiIiISEmUSBIRERERERERkZIokSQiIiIiIiIiIiVRIklEREREREREREqiRJKIiIiIiIiIiJTk/wHut1hZGVIF+QAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -218,7 +218,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABJAAAAIfCAYAAAAv5iYeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAACAcElEQVR4nOzdd7ycdZX48c+ZuTWNACmUJCRAQHqLCCIIKIIVC664FrCh7rLquos/XRX7qltsq66yiKKri4oNFUWqiCISiig9QCihp7db5/z+mAncXJKbG+beeW75vHk9L2aeeeaZM3NLzj3P+X6/kZlIkiRJkiRJm1MqOgBJkiRJkiSNbBaQJEmSJEmSNCALSJIkSZIkSRqQBSRJkiRJkiQNyAKSJEmSJEmSBmQBSZIkSZIkSQOygCRJ0jgUEd+KiEvG2mvVKyKOjoiMiFlFxyJJkjSSWECSJGmMiYj2iPhERNwZEesjYllEXBsR7yo6No08EXF2RFxRdBySJGlkayo6AEmSNOT+GzgGeDfwZ2AKcBAwp8igJEmSNHrZgSRJ0tjzcuDfM/OnmXlPZv45M7+VmR/vf2BEnBYR90bEqoi4ICJm9nlsXkT8OCIejIh1EfGXiHhDv+dfERHnRMRnIuLx2nnOioi2gQKMiJMj4saI6IiIxRHxuYiYWHvs1IhYERET+j3nzFpXVWzifMdFRG//oWcR8Zpa7FNq9z8VEbfW9t0fEV+LiG0GiHOTQ9oioiciTu1zf2ZtqN5jEbE6In4fEUf1eby59h4fiIjOiHgoIs4b6DMarIj4l4i4u3bexyLiooho7/P4cbV41kfEkoj4ZkRsX3vso8BbgOfW3mdueF8RsWNEnFf7Wqyvfa0XDPY9RcTBEfGriHg0ItbUuuBOGIr3LEmSGs8CkiRJY89DwAkRsd0Wjnsm1U6lFwPHA/sB/9Hn8UnAZcALa4+dBXwzIo7pd56TgO2BI4HXUS1gfXpzL1orUPw38J/A3sAbgecDX6sd8n0ggVf3eU4JeDNwdmbmJk57KdX3/bp++08BfpqZq2r31wOn1V73VOBo4Eubi3UwasWay4HJVD+rg4ALgYsjYq/aYf8A/A3wemA+8DLgj/W8bu21Xwm8n2q32XzgOOBXfR4/FvgZcB6wP9WvzVzgx7VC3H8A3wOuBnasbd+vPfZT4BnAS4BDgUdq72naIN/TFKpfy2OAg4GLgAsiYo9637ckSWq82HQOJkmSRquIOIJqUWAWcDPVP+ovBH62ofgSEd8CXgTMzszO2r7/B7wnM3cc4Nw/Ax7NzLfV7l9BtSCxW2b21vadRrUos31mrq291qzMfH7t8cXAZzLza33OexTwW2C7zFweEV8CDs7M59QePx74ee08j24mts8AL8nMfWv3ZwJLgBdn5kWbec4rqBZX2jOzEhFHUy0Gzc7MB/rf7/O8HuCtmfmtWkHsk8DczOzpc8xlwE2Z+Z6I+CLVItzzNlMAe1oi4h+BdwL7ZGb3Jh6/AvhjZr6/z745wL3AQZl5Y0ScDeyemUf3OeZ5wCW1895S29cKLAb+OzM//nTeU0T8GfhBZn7q6bxfSZJUHDuQJEkaYzLz98BuVDuCzgVmAudT7f7oO/zrtg3Fo5oHa8cCEBETakPTbo7qRNxrqBaddun3kn/aUDyq+T3QWothIxExvfb8z9WGNa2pnXdD18zutf9/HTiiTwfP24ALNlc8qjkX2CciDq7dfx3wKNVCyIbXf2VEXBnVYXlrgO8CLcAOA5x3S55Ze/6Kfu/pSKqdOQDfpFpsWVQbNveqiGjZ3Alrw9LW9NmO3MyhPwCagXtrQ+jeEBGT+8X2nn5x3VJ7bH7/k/WxD7B0Q/EIoPa9ck3tsS2+p4iYHhFfjYjbasPg1tSe2//7R5IkjQJOoi1J0hhU64T5Q237z4h4PfAdYEOnD0BX/6cBfQtM/w6cCLwXuB1YS3XY2WbnDBqEDRev3k21s6e/B2rx3xwRVwFvq3UWvYzqUKrNysxbI2Ih1SFx19f+/799OqOeBfyQ6vC6M4DlwGFUC0+bK+ZUav9/4nOJiDIbX4QrAbcCr9jE89fVYrsxIuZRHWJ2DPBF4BMRcVif4XV9fY1qcWiDJZt5z0si4hm1cx4LfBj4bEQ8KzPvr8X2Wapf+/4e3tQ5B2sQ7+lbVCdufx9wD9Xhg+ex+c9akiSNYBaQJEkaH26t/X/GVjznKOC7mfkDeGIeoj2ozoXT1zMjotynC+nZQCdwV/8TZuYjEXE/sGdm/s8WXv/rwBeAZVQLKBcPIuZzgQ9HxLeBA6jOz7PBc4DHM/NDG3ZExElbON+GjqedgPtrtw9k40LbhqLVqoE6pDJzDfAT4CcR8a9U52x6LtWhef2PXUb1fW9RrTPo18CvI+LDVL8+Lwf+qxbbPpm5aIBTdAHlfvtuBraPiL37DWF7FvDVQb6no4D3ZeYFtedPBHYF/jqY9yVJkkYWh7BJkjTGRMRvI+IdEbEgInapzWfzVWAFm+762ZzbgRMj4tCI2JvqJNo7beK47YGvRMReEfFi4BPA1zNz7WbO+0HgXRHxwYjYNyL2jIiXR8TX+x13fu3/H2bzk2f393/AtsA3gOszs2+x4nZgekS8JSJ2jYg3An+3hfMtojpf0Ecj4hkR8Rzg81S7tTb4LtUOm19GxAsiYm5EPCsiPhARLweIiDMi4nURsU+ta+fNQC9wxyDe02bV3svbIuKAiNiF6rC9yTw5TO1Mql/Dz0XEgRGxW0ScEBHfiCdXarsHeEYttmm1QtFlwJ+A70XEERGxL/BtoI3qBOiDeU+3A6+LiP0i4kCqX5v+hSpJkjRKWECSJGns+RXVQsKFVP+I/yZwJ3BEZj6+Fef5R6rFk8uprnK2hCeLOn2dD6wGrqI6ROkXVFcG26TM/A7V1bteQrVIcS3wUfoN08rMDqpDr0rAOYMJODOXAr+k2iX07X6P/QL4FPCvwF+Ak6kOZRvofD3Aa6h2bt0AfIVqAazS55gOql03C6l+1ncAP6a6ctm9tcNWUR0KeHXttV8BvCozbx/M+xrAcuBNwBVUu8zeC5yWmZfWYruc6tC2/YHfATdRLYCtBjZMuv0Nql+DPwCPAa+tFeteDtxG9fO8luo8T8f1+R7a0nt6E9Wv3Z+oruj269p5JEnSKOQqbJIk6WmrrfK1KDPfOkzn/wHQnJmbml9IkiRJDeIcSJIkacSJiG2pdvC8AnheweFIkiSNexaQJEnSSHQD1bmV/i0zryw6GEmSpPHOIWySJEmSJEkakJNoS5IkSZIkaUAWkCRJkiRJkjQgC0iSJEmSJEkakAUkSZIkSZIkDcgCkiRJkiRJkgZkAUmSJEmSJEkDsoAkSZIkSZKkAVlAkiRJkiRJ0oAsIEmSJEmSJGlAFpAkSZIkSZI0IAtIkiRJkiRJGpAFJEmSJEmSJA3IApIkSZIkSZIGZAFJkiRJkiRJA7KAJEmSJEmSpAFZQJIkSZIkSdKALCBJkiRJkiRpQBaQJEmSJEmSNCALSJIkSZIkSRqQBSRJkiRJkiQNyAKSJEmSJEmSBmQBSZIkSZIkSQOygCRJkiRJkqQBWUCSJEmSJEnSgCwgSZIkSZIkaUAWkCRJkiRJkjQgC0iSJEmSJEkakAUkSZIkSZIkDcgCkiRJkiRJkgZkAUmSJEmSJEkDsoAkSZIkSZKkAVlAkiRJkiRJ0oAsIEmSJEmSJGlAFpAkSZIkSZI0IAtIkiRJkiRJGpAFJEmSJEmSJA3IApIkSZIkSZIGZAFJkiRJkiRJA7KAJEmSJEmSpAFZQJIkSZIkSdKALCBJkiRJkiRpQBaQJEmSJEmSNKCmogOox7Rp03Lu3LlFhyFJGiOuu+66xzNz+nC+xvHHzsyly7qG/LzX/XnFRZl5wpCfWNoEczBJ0lAyBxsdRnUBae7cuSxcuLDoMCRJY0RE3Dvcr7F0WRd/uuSYIT9vefpPpg35SaXNMAeTJA0lc7DRYVQXkCRJGm2SpEKl6DAkSZLGFXOw+llAkiSpwUxeJEmSGs8crD5Ooi1JkiRJkqQB2YEkSVKDee1LkiSp8czB6mMHkiRJkiRJkgZkB5IkSQ2UQHr9S5IkqaHMwepnAUmSpIZKejOLDkKSJGmcMQerl0PYJEmSJEmSNCA7kCRJarDEq1+SJEmNZg5WHzuQJEkaJyLihIi4PSIWRcT7N/F4a0R8v/b4NRExt7b/uIi4LiL+Uvv/sX2ec0XtnDfWthkNfEuSJEkj2ljKv+xAkiSpgRLoLeB1I6IMfAU4DngAuDYiLsjMW/oc9hZgeWbuHhEnA58FXgM8Drw0Mx+MiH2Bi4Cd+zzvdZm5sCFvRJIk6WkoIgcba/mXHUiSJI0PhwKLMvPuzOwCzgNO7HfMicC5tdvnA8+LiMjMGzLzwdr+m4H2iGhtSNSSJEmj15jKvywgSZLUYDkM/wHTImJhn+20fi+7M3B/n/sPsPFVrI2OycweYCWwfb9jXgVcn5mdffZ9s9Y+/eGIiDo/HkmSpGFRQA42pvIvh7BJktRACcO1hOzjmblgOE68QUTsQ7Wt+gV9dr8uM5dExGTgR8AbgG8PZxySJElba7TmYCMp/2poB1JElCPihoj4xSYeOzUiHuszCdRbGxmbJElj3BJgdp/7s2r7NnlMRDQB2wBLa/dnAT8B3piZd214QmYuqf1/NfA9qq3akiRJGmP5V6OHsL0buHWAx7+fmQfWtrMbFZQkSY2Uw7ANwrXA/IiYFxEtwMnABf2OuQA4pXb7JOCyzMyImAr8Enh/Zv5+w8ER0RQR02q3m4GXAH8dXDiSJEmNVUAONqbyr4YVkGqVsxcDFoYkSWqw2pj606mu4HEr8IPMvDkiPh4RL6sd9g1g+4hYBLwX2LDU7OnA7sCZ/ZaLbQUuioibgBupXkH7n4a9KUmSpBFsrOVfjZwD6QvA+4DJAxzzqog4CrgD+MfMvL//AbUJqU4DmDNnzjCEKUnS8KkuITss4++3/NqZFwIX9tt3Zp/bHcCrN/G8TwKf3MxpDxnKGCVJkoZDUTnYWMq/GtKBFBEvAR7NzOsGOOznwNzM3B+4mCeXsdtIZp6VmQsyc8H06dOHIVpJkoZRQmUYNkmSJA3AHKxujRrCdgTwsohYDJwHHBsR/9v3gMxc2mdJurPxiqYkSZIkSdKI0JACUmZ+IDNnZeZcqpNGXZaZr+97TETs2Ofuyxh4sm1JkkalBCrDsEmSJGnzzMHq18g5kJ4iIj4OLMzMC4B31SaR6gGWAacWGZskSZIkSZKqGl5AyswrgCtqt/tOHPUB4AONjkeSpEarEEWHIEmSNO6Yg9Wn0A4kSZLGo/E24aIkSdJIYA5Wn0ZNoi1JkiRJkqRRyg4kSZIaqDqBo+3TkiRJjWQOVj87kCRJkiRJkjQgO5AkSWowr35JkiQ1njlYfSwgSZLUQNX2aUmSJDWSOVj9HMImSZIkSZKkAdmBJEkqTKVSYdEtD7JuTSe77bUTk7dpLzqkhrB9WpI0mlUqyaLbHmLt2k5233MHJk8ZH/9+a/QzB6uPBSRJUiEeun8Z//nB81n++BqI6j/mf/OWozj+lYcUHJk0tkTECcAXgTJwdmZ+ZhPH/A3wUaod/n/OzL9taJCSRo2Hlizn3z/2M5YvW0MQQPKaU57D8S89sOjQJA0zC0iSpIarVCp8/swfs/TR1Uya0gZAT08v5511BbvuuQPz99m54AiHTxL0OoJcDRIRZeArwHHAA8C1EXFBZt7S55j5wAeAIzJzeUTMKCZaSSNdpZL85ycvYNnja5g4qRWo/vv9f9/8HfN2n8Eee+1UcITS5pmD1c9PT5LUcIvvfJSlj6xi4uTWJ/Y1NZXJTH77q5sKjEwacw4FFmXm3ZnZBZwHnNjvmLcBX8nM5QCZ+WiDY5Q0Siy+61GWPrqaCRNbntjX1FSmUoErLr65wMgkNYIdSJKkhuvs6IIIIjYeh14qBWtXdxQUVeNkOv5eDbMzcH+f+w8Az+p3zB4AEfF7qsPcPpqZv+5/oog4DTgNYM6cOcMSrKSRrbOjm9jkv9+wbk1nQVFJg2cOVh8LSJKkhpu3xw6Uy0F3Vw/NLdV/ijKTSgWeedSeBUc3/HqLDkDaWBMwHzgamAVcGRH7ZeaKvgdl5lnAWQALFizIBscoaQSYN38mpXLQ3d1Dc/OT/35nJs989u4FRydtmTlYfRzCJklquLb2Fk5513F0dfayeuV61qzqYO3qTvbcbxbPPHKPosOTxpIlwOw+92fV9vX1AHBBZnZn5j3AHVQLSpK0kba2Zt70zmPp6uph9er1rFndwdo1ney5z84ceoS/NqSxzg4kSVIhjnj+PszZdQZXXvQXVq9cx0GH784hz55PU3O56NCGVQKV9PqNGuZaYH5EzKNaODoZ6L/C2k+B1wLfjIhpVIe03d3IICWNHkcc/Qxmz53GlZfcwupV6zn40HkccthuNDWN7X+/NfqZg9XPApIkqTCzd53O6955bNFhSGNWZvZExOnARVTnNzonM2+OiI8DCzPzgtpjL4iIW6h295+RmUuLi1rSSDdn7jRe/9ajig5DUoNZQJIkqaGCiiPI1UCZeSFwYb99Z/a5ncB7a5skSWOUOVi9LCBJktRACVSKDkKSJGmcMQern+U3SZIkSZIkDcgOJEmSGqzXCRwlSZIazhysPn56kiRJkiRJGpAdSJIkNVSQRNFBSJIkjTPmYPWygCRJUgMl0GvyIkmS1FDmYPVzCJskSZIkSZIGZAeSJEmNlFBxAkdJkqTGMgerm5+eJEmSJEmSBmQHkiRJDZQEFa/fSJIkNZQ5WP389CRJkiRJkjQgO5AkSWqwStEBSJIkjUPmYPWxgCRJUgMl2D4tSZLUYOZg9fPTkyRJkiRJ0oDsQJIkqcFcQlaSJKnxzMHq46cnSZIkSZKkAdmBJElSQwUVouggJEmSxhlzsHpZQJIkqYES6E2TF0mSpEYyB6ufQ9gkSZIkSZI0IDuQJElqsPT6jSRJUsOZg9XHT0+SJEmSJEkDsgNJkqQGcvy9JElS45mD1c8CkiRJDRWkK4BIkiQ1mDlYvRzCJkmSJEmSpAHZgSRJUgNV26e9fiNJktRI5mD1s4AkSaNUd2Ud96y+kCVrfke51MrcSScwe9LRRPgPoyRJkqShZQFJkkah3uzm9w9/iJVd91COFpIKNyz9L5Z13saB0/6u6PC0BRXH30uSJDWcOVh9vEwtSaPQQ+v+yKrue2kpTaap1EZzaQItpUnct+ZS1nQ/WHR4kiRJksYYO5AkaRRa2nEzmRWi9ORVlIgSEcHKrruZ1LxTgdFpS7z6JUmS1HjmYPWxgCRJo9CEphmwyX8Ag9by1AZHo62RBBUbgCVJkhrKHKx+fnqSNArNmvhcytFCd2UdmUlm0tW7mglNM9i+de+iw5MkSZI0xtiBJEmjUHvT9jx75ke47vEvsr7nMSDZrm0vDp72HldhG+kSKmn7tCRJUkOZg9XNApIkjVLbte3F83f+b9b1PEI5Wmhr2q7okCRJkiSNURaQJGkUiwgmNu9QdBjaCokTOEqSJDWaOVj9LCBJktRQQSUdZihJktRY5mD18tOTJEmSJEnSgOxAkiSpgart05IkSWokc7D62YEkSZIkSZKkAdmBJElSgzn+XpIkqfHMwepjAUmSpAYzeZEkSWo8c7D6+OlJkiRJkiRpQHYgSZLUQE7gKEmS1HjmYPWzgCRpxFq3rpNr/ngXDz+0gnm7zuCQBfNobi4XHZYkSZIkjTsWkCSNSA8+uJxPfOynrFndQaVSoVwuMXOHbfjIR1/JpMltRYcn1SGoOIJckiSpwczB6uWnJ2lE+uY3fsvq1euZNKmVKVPamTixlQeXLOfHP7626NAkSZIkadyxgCRpxOno6ObWWx5k0sTWjfa3t7dw9R/uLCgqaWgkUMkY8k2SJEmbZw5WP4ewSRpxShFEBJkQfX4nZyZNTc6BpNGvwvhKNiRJkkYCc7D62IEkacRpaW3ikAXzWLu284l9mUlHRzfHHLN3gZFJkiRJ0vhkB5KkEelNbz6Khx5azkMPrSCzum+//WfzkpceVGxgUr2ScdfuLEmSVDhzsLpZQJI0Im0zdQKf/uzJ3HrLEh5/fDWzZm3HrrvNIMJf+pIkSZLUaA5hkzRilUrBPvvO4rlH78Vuu8+0eKQxIQmS0pBvgxERJ0TE7RGxKCLev4nHWyPi+7XHr4mIubX9x0XEdRHxl9r/j+3znENq+xdFxJfCH1RJkjQCFZWDjaX8ywKSJEkN1psx5NuWREQZ+ArwQmBv4LUR0X9SsbcAyzNzd+DzwGdr+x8HXpqZ+wGnAN/p85z/Bt4GzK9tJzz9T0aSJGn4NDoHG2v5lwUkSZLGh0OBRZl5d2Z2AecBJ/Y75kTg3Nrt84HnRURk5g2Z+WBt/81Ae+1q2Y7AlMz8Y2Ym8G3g5cP+TiRJkkaHMZV/WUCSJKnBMod+A6ZFxMI+22n9XnZn4P4+9x+o7dvkMZnZA6wEtu93zKuA6zOzs3b8A1s4pyRJ0ohQQA42pvIvJ9GWJGlseDwzFwznC0TEPlTbql8wnK8jSZI0igxrDjaS8i8LSJIkNVAClWIagJcAs/vcn1Xbt6ljHoiIJmAbYClARMwCfgK8MTPv6nP8rC2cU5IkqXAF5WBjKv9yCJskSQ0VVIZhG4RrgfkRMS8iWoCTgQv6HXMB1UkaAU4CLsvMjIipwC+B92fm7zccnJkPAasi4rDa6h9vBH5W18cjSZI0LArJwcZU/mUBSZKkcaA2pv504CLgVuAHmXlzRHw8Il5WO+wbwPYRsQh4L7BhqdnTgd2BMyPixto2o/bY3wFnA4uAu4BfNeYdSZIkjWxjLf9yCJskSQ2UQGULS74O22tnXghc2G/fmX1udwCv3sTzPgl8cjPnXAjsO7SRSpIkDa2icrCxlH/ZgSRJkiRJkqQBNbQDKSLKwEJgSWa+pN9jrcC3gUOoThj1msxc3Mj4JElqhCyoA0mSJGk8MwerT6M7kN5NddzfprwFWJ6ZuwOfp7pMnSRJkiRJkgrWsAJSbfm5F1Od6GlTTgTOrd0+H3hebUZxSZLGlIJWYZMkSRrXzMHq08ghbF8A3gdM3szjOwP3Q3Wm8ohYCWwPPN73oIg4DTgNYM6cOcMVqyRJwyKzuEm0JUkaq5YvX8sFv7iB669fzOTJbbzwhP159uHzsSdBG5iD1a8hHUgR8RLg0cy8rt5zZeZZmbkgMxdMnz59CKKTJEkauyLihIi4PSIWRcT7N/H4qRHxWJ8lgt9aRJyS9HStWrWeD33kR1x00V9YvbqD++9fxle/dinn/+jaokOTxpRGdSAdAbwsIl4EtAFTIuJ/M/P1fY5ZAswGHoiIJmAbqpNpS5I0hoRXv9QwtQVMvgIcBzwAXBsRF2TmLf0O/X5mnt7wACVpCFx2+S2sWLGWKVPan9jX21vhgl/cwAnH78/kyW0FRqeRwxysXg3pQMrMD2TmrMycC5wMXNaveARwAXBK7fZJtWOyEfFJkiSNUYcCizLz7szsAs6jOu+kJI0ZN9+yhHK5vNG+crlEqRQseXB5QVFJY0+jV2HbSER8PCJeVrv7DWD7iFgEvBd4Sou1JEljQRJDvkmb8cQckzUP1Pb196qIuCkizo+I2Zs6UUScFhELI2LhY489NhyxStLTssMO29DbU9loX2bS21Nh220nFBSVRiJzsPo0vICUmVdk5ktqt8/MzAtqtzsy89WZuXtmHpqZdzc6NkmShlviCiAacX4OzM3M/YGLeXJV3I04D6WkkeoFx+1HualER0c3mUmlkqxZ08F++85i5oxtig5PI4Q5WP0K7UCSJEnSsNowx+QGs2r7npCZSzOzs3b3bOCQBsUmSUNi9qztOOOfXsiUbdpZt66L9eu7OOxZu/MPpx9XdGjSmNKoSbQlSVKNEziqga4F5kfEPKqFo5OBv+17QETsmJkP1e6+DLi1sSFKUv3223c2X/jP17F8+Vra25uZMKG16JA0ApmD1ccCkiRJ0hiVmT0RcTpwEVAGzsnMmyPi48DC2lQC76rNSdkDLANOLSxgSapDqRRsv/2kosOQxiwLSJIkNVh69UsNlJkXAhf223dmn9sfAD7Q6LgkSWo0c7D6WECSJKmBkrB9WpIkqcHMwernJNqSJEmSJEkakB1IkiQ1WI6zJV8lSZJGAnOw+tiBJEnDbM3aDnp6eosOQ5IkSZKeNjuQJGmY/Pqyv/DF//stKzu7KAHP2n0WnzjjRCa0u6zsuJYuIStJktRw5mB1swNJkobBNdfdzSe/dTGrOrtoiqAUcPWiB3jXR79fdGiSJEmStNXsQJKkYXD2D66iktBS2lCnD5qiwq0PPc79S5Yxe+ftCo1PxUmgUnQQkiRJ44w5WP0sIEnSMHh4+WpK/TpkS5TopcLdix+1gDTOpe3TkiRJDWcOVh+HsEnSMNhl5nZPucJRqe15xvwdGx+QJEmSJNXBApIkDYN3vu4oyhF0ZYUKFXqyQk9WJ9KeOWObosNTwSoZQ75JkiRpYOZg9bGAJEnDYJ9n7Mzn//Hl7DJ1CpnQVi7zisP25t/+5VVFhyZJkiRJW805kCRpmCw4cB7/96W3Fh2GRpwgGV9XqyRJkopnDlYvC0iSJDVQwrhrd5YkSSqaOVj9HMImSZIkSZKkAdmBJElSg1Wy6AgkSZLGH3Ow+tiBJEmSJEmSpAHZgSRJUoM5gaMkSVLjmYPVxwKSJEkNlOkEjpIkSY1mDlY/h7BJkiRJkiRpQHYgSZLUYOnVL0mSpIYzB6uPHUiSJEmSJEkakB1Ikp62X17/By645wrWso75rfN42+EvY6ftpxcdlkaJzGRFx9U8subH9FZWMrX9SGZOegVNpclFhzbMwgkcJUmSGs4crF4WkCQ9LV++5Hwu67wKWiGyxJ/jL/zjlXfw+ee+j522277o8DQKPLj6Ozy46ltAEDSxtvsclq67mH1mfI1yaWLR4UmSJEnqwyFskrbaynVruWL9Hyj1lmnqbaZcKdPU00x3SyffvPrnRYenUaC7dyUPrvo25ZhAU2ky5VI7zaWpdPY8wONrLyo6vGGVQCWHfpMkSdLmmYPVzw4kSVvtr/fdTUZSrpQ32h+V4I7OewqKSqPJ+u67CEpE9P9nqMzKzmuZOfmVhcTVKE7gKEmS1HjmYPWxA0nSVps5dTsykkpWNtqfpWRKjPX5azQUmspTSXrJ7HfZJntpLc8sJihJkiRJm2UBSdJW232HnZm2fjqV5t4niki90QsEr3zGscUGp1GhvWkeE5v3oCdXPlFE6q10QJSZPullBUc3/LI2ieNQbpIkSRqYOVh9LCBJelo+ddzfMaNjJpXmCr3lHkoEL5/yAo7Z5+CiQ9MoEBHMn/YpprQeTG+upreylnKpjd23+xgTmnctOjxJkiRJ/TgHkqSnZfo22/K1V32Aex97hKWrVrDXrLm0t7YWHZZGkebydjxj+ufo6nmUnlxLe9PsTcyJNDY5/l6SJKnxzMHqMz4ydUnDZpfpM9llunPW6OlraZpBS9FBNFAmVExeJEmSGsocrH4OYZMkSZIkSdKA7ECSJKnRcsuHSJIkaYiZg9XFDiRJkiRJkiQNyA4kSZIarFJ0AJIkSeOQOVh9LCBJktRQ4QogkiRJDWcOVi+HsEmSJEmSJGlAdiBJktRgiVe/JEmSGs0crD52IEmSJEmSJGlAdiBJetpWrV7PH29czMrV69lrtx3Ye/6OlEpW9TeoVJK/LH6IWxY/wtRJ7Tx7n7lsM7Gt6LBUsATSJWQlSZIayhysfhaQJD0tt9/9CJ/48q/o7OqhUqnQVC5z4N6zOONtz6epqVx0eIXr7u3lX797KdcveoDu3gpNpRLnXPQnPn7K8ew1Z2bR4UmSJEnSVnEIm6StVqkkn/vGpfT2Vpg8sY1tJk9gQnsL1//1fn537aKiwxsRLr9xEQvvuJ+JbS1sO6mdyRNa6emt8NnvX06l4qWP8S4zhnyTJEnSwMzB6mMBSdJWu/+hZaxc3UF7W8sT+yKCcrnEFddYQIJqAalcLhHx5D8q7S1NrFiznvseXV5gZCpcmrxIkiQ1nDlY3SwgSdpqEQGZZL9BxJlJ2TmQACiXNv3rNRPniZIkSZI06lhAkrTVZu+4LdO3n8y69V1P7KtkUsnkeUfsWWBkI8dxh+xBb6X6mWywtqOLHbabzOzpU4sLTCNC5tBvkiRJGpg5WH0sIEnaahHBP731eUxob2Htuk5Wr+1g3bpOjn7WfA4/aNeiwxsRjtx3V449cHfWdnSxal0na9d3Mam9lfeffOxGw9okSZIkaTRwFTZJT8vcWdvztU+czPW3PMDqNR3sMW8Gc2dtX3RYI0apFPzjq47ixGfvw+33P8aUCa0cssds2lr8tavqMrKSJElqLHOw+viXjKSnrbW1mcMPmld0GCParjtuz647WljTkxLG3YSLkiRJRTMHq59D2CRJkiRJkjQgO5AkSWqo8bfkqyRJUvHMweplB5IkSZIkSZIGZAeSJEkN5gSOkiRJjWcOVh8LSJIkNZrt05IkSY1nDlYXh7BJkiRJkiRpQBaQJEmSJEmSNCALSJIkSZIkSRqQcyBpWC19dBWPPbSCGTtty3bTJxcdzojT093LPXc+Qrkc7LL7TMrloa3pZlag506gC5r2JKJlSM8v6WlIXEJWkiSp0czB6mYBScOiu6uHcz73a665/DbK5RK9vb08+7h9OPXdx9PUXC46vBHhlhvv4yv/+nM61ncDyeRtJvCuM09k1z12GJLzZ8895MoPQeUxICCayUkfoNR2xJCcX9LTk0C6BIgkSVJDmYPVzyFsGhY/+84fuPqSW5gwsZX2CS1MmNjGVb/+Kxf+4JqiQxsRVixby+c/+hO6u3qYMLGFCRNbWbNyHf/xwR/Rsb6r7vNndpMrzoDeR4GJEBOrvy1Xf5zsfbD+NyBJkiRJGlcsIGlYXPqz65kwsZVSqdoiWCoF7RNauPjH1xcc2chw7e9up6erh9a25if2tU9spWN9FzctvKf+F+i+EXIVlCZD1No0oxWyh+y4pP7zS6pL5tBvkiRJGpg5WH0sIGnIZSbr13U9ZT6fclOJdWs6CopqZFmzuoPe3qf+tslKsnb1EHxGlTWbeSChsrz+80salSLihIi4PSIWRcT7N/F4a0R8v/b4NRExt7Z/+4i4PCLWRMSX+z3nito5b6xtM7YQw94RMbN2e1JEfCwiPhIRE4bwrUqSJI0IYyn/soCkIRcR7HXgHNb2KxatXdPBvgvmFhPUCLP3AXNoai6RfUrWlUqFCHjG/rPrf4HmfYAKZO+T+zIhSkTLofWfX1J9MoZ+24KIKANfAV4I7A28NiL27nfYW4Dlmbk78Hngs7X9HcCHgX/ezOlfl5kH1rZHtxDK/wFTa7f/AzgKOAz4+hbfhCRJUj0anIONtfzLApKGxWvfeSwtbc2sXrWe9Ws7Wb1yPe0TWvmbtx1ddGgjwh777swhz57PmtUdrF3dwZrVHaxb08XzXnogO87aru7zR3kGTHg9sBYqK6GyGlgFzQeDBSRpvDoUWJSZd2dmF3AecGK/Y04Ezq3dPh94XkREZq7NzKuoJjL1mpuZt0dEAK8EXg2cBBw/BOeWJEkaScZU/uUqbBoWc3abwSf/501c/vMbWXznI8zbcweOfcmBbDdjStGhjQgRwTv+34t55pF7cPVlt1JuKvGc5+/DAYfuOnSvMeEUaN6X7PgVZAfRejS0Hk21CC6pSMM0XH5aRCzsc/+szDyrz/2dgfv73H8AeFa/czxxTGb2RMRKYHvg8S289jcjohf4EfDJzAFnBOiIiMlUr8Ldl5mPR0QT0LaF15A0RmQm9971KI88tJIdZ23LnHnTiw5pRLvxxnu54c+LmbXzdhxz9N40NZnLbc7SlWu5bfEjTJrQyj677khT2X6JzVm7poNbb3mQcrnE3vvuTGtr85afNAYUkIONqfzLApKGzbSZ2/Dqtz636DBGrHK5xKFH7smhR+45LOePCGhZQLQsGJbzS6rD8GQvj2dmET/wr8vMJbWk5EfAG4BvD3D894DLgMnAhvH8BwNDsIKANiUiTgC+CJSBszPzM5s57lVUr3w+MzMXbuoYqV7r13Xy+U9cwJ23PkhEkJnsc+Ac3vWBl9AyTv6AHazOzm7+/r3fYdHDT85f+V/nXM6XP/O3zJkzrcDIRp7M5LzfXM8PLvsztTV82GZSOx972wnMnrltscGNQFddeTvnfO0yKgkBNDeXec/7Xsze++5cdGjDb+zkYIXkX5ZkJUkaH5YAfSdZm1Xbt8ljaleltgGWDnTSzFxS+/9qqsnJgONkM/MfgQ8C78zMDQlMBfjHQb0LbZVBzr1ALQF9N3BNYyPUePP9b13F7X99gAkTW5/Y/nLdYn72/T8VHdqI819fvZg7H1pGOaC5FJRLsLKjiw98/EdFhzbi3HjnEn5w6Y1MaG1mYnsrE9tbWb56Pf/6rUuoVMbZMllb8PBDKzj7q5dRbiozYUIL7RNa6O2t8LnP/pL167uKDm8sGlP5lwUkSZIaKSlkEm3gWmB+RMyLiBbgZOCCfsdcAJxSu30ScNlA7dAR0RQR02q3m4GXAH/d4keQ+RtgUUQcVru/MDMvG8yb0FYbzNwLAJ+gOmmny6Vq2FQqFX53yc1MmNRW7ZSm2jHdNqGFy399U8HRjTyXX3MnpQhKtc+qRNBUCpYsX8Ojj60qOLqR5ZI/3QGw0SrQk9pbeGT5ahY/tKyosEakP129iN7eXpqbnxwK2drWTE93LzfdeF+BkTVAMTnYmMq/HMImSdI4UBtTfzpwEdWhTOdk5s0R8XFgYWZeAHwD+E5ELAKWUU1yAIiIxcAUoCUiXg68ALgXuKiWvJSBS4D/GSiOiJhDdSWQA6mmcpMi4iTghMx869C9Y9Vsce6FiDgYmJ2Zv4yIMzZ3oog4DTgNYM6cOcMQqsaDnu5eWttaNtpXKpXo6uwpKKKRq6dSeerOABI/r37WdXRTKm38h3zUim9d3X5WfXV29GxyFFeSdHX5WQ21sZZ/WUCSJKnRCuqmz8wLgQv77Tuzz+0OqqtybOq5czdz2kO2MoyvA78EjuTJ9uyLgf/cyvNoCERECfgccOqWjq1NCHoWwIIFCxwToq1WKpXY/5C53HTDvUye3P7E/nVrOjnsqD0KjGxk2n+3HfnT7Q9QrRpV9fbC5LZmdtppamFxjURHHjiP6++4n8x8oruts7uH5qYyu81yvqi+Djh4F37xs+upVPKJoltvT7VYuc++s4oMrTEK+NdrLOVfDmGTJKmhgsyh30aRQ4HPZGaFWhqXmSupjvfX0NvS3AuTgX2BK2pXOQ8DLogIV2DQsHjdaUczeVIba1avZ82q9axZvZ6p20/kb059TtGhjTj/9O4TmNjSTHcl6eqt0NWblALOeMdxlEr+GdfXkQfuxv6778Sa9Z2sWtvBqrUd9PRWeM9rjqLZVes2Mn/PHTjqmL1Yv66L1avWs3rVejo6unnN6w5nu+0nFR3eMBvXOdiQ5F+D7kCKiBdQbXfa6Luqb+VMkiRpCx4Bdgfu2LCjNqnzGJ94oTBPzL1AtXB0MvC3Gx6sJY9PXJ6PiCuAf3YVNg2XHXbals987RT+cMVt3L/4cebuNoPDjtqTiZO2aiXpcWGHHaZy3lmn8d3v/Z6bblvCzjOn8vqTn83cedOLDm3EaW4q85G3nMDCW+/jhtsfYJtJ7RxzyHx2nDal6NBGnIjgzW8/msOfM5/r/nQ3TU1lDnvOfObtOqPo0DS8hiT/GlQBKSK+DPwNcDmwrs9Dti9LkqSt8R/ALyLi00BTRLwW+Bdgk0vLqz6DnHtBaqhJk9t5wUsPKjqMUWHKlHbe+Y7nFx3GqNBULnHYvnM5bN+5RYcy4kUEe+87i73Hw5A1bTAk+ddgO5D+FjggM+/f4pGSJEmbkZnnRMRS4O1UJ3c+BfhwZv600MDGsC3NvdBv/9GNiEmSJDXOUOVfgy0gPQ6s2JoTSxoZKpUKlUrSNEzjv4f7/NXXyKesrKEnVSpJBE9MGqnRYHx/rTLzZ8DPio5jNKgNPfsUm55GwKXQJEnaKuM3BxuK/GuzBaSI2LXP3f8Evltrd3qkXxB3b+lFIqINuBJorb3m+Zn5kX7HnAr8O09O7PjlzDx7EO9B0iYsfWwVn3z/D7n9lofITHbYcSr//JET2efAofl7o2N9Jx8/8/v88fYH6QG2a27i3W9/Pse84MAhOX9m8oubbuN/r76RpWvWMnu7qZz23EM5fDf/Xtrg4UdX8s0fXs31f72fpqYSxxy2B69/5bOY0N6y5SerWON4AHhEvHlzj2XmOY2MZZT4HnAX8E9sPI2AJEnaWuM0Bxuq/GugDqRFVD/eviW6l/R/Larj6bekEzg2M9dERDNwVUT8KjP/2O+472fm6YM4n6QBVCoV3nXqN1i2dA3lcgkIHn5oBe//h//lnPP/nukz61/s6L3v+SY3P7SCcibNEazo6ubj//Vrtt12Egc+c/e6z//TG27hvy+/hramMlPb23h01Ro++rNL+PSrjufgXXau+/yj3Zq1nXzoPy5g1ZoOJk1sJTO5+KrbeODhFXzsvS+xG0kj2Rv63d8B2A34PWAB6an2AY6orZoiSZL0dAxJ/rXZ9R8zs5SZ5dr/N7cNasxKVq2p3W2ubeO09icNv6suu5Vly9ZQbioRpSBKQVNzmZ7uXv7vnCvrPv+S+x/jlodW0JRQiiCApggqAf/zjUvrPn+lknzn6htob26itbmJiGBCSzOlCM79/fV1n38suOraRaxe28HkSW2USkG5XGLypFbuuPsR7rr38aLD05bkMGyjRGYe02/bC3gH4Kpfm3Yl4GzDkiQNhXGagw1V/jXYVdi+lJnv2sT+L2TmewZ5jjJwHdWl476Smdds4rBXRcRRVJeW+8dNTdodEacBpwHMmeNQFmlT7rr9YWDTc+Lcs+jRus9/520PQkL/00fCksdX133+dV1drOnoYpv21o32tzU1cd+yFXWffyy478FlZL9/sKI6ERIPP7aK3ee6xK9GlW9RnW/xjILjGBFqK6RtsBj4dUT8BHi473GbmwhbkiRpEL7FVuZfm+1A6ufUzezv3wa1WZnZm5kHArOAQyNi336H/ByYm5n7AxcD527mPGdl5oLMXDB9un8gSZvyjH2rQ7yyf4UB2H2PHes//z6zAaj0O30Cc2bUPzxuQksL20xoo7OnZ6P9Hd3d7Dp9u7rPPxbMmz3tKQXCzCQz2XmH+r8GGkbDceVrlFz9AoiIUr9tEtULQysKDm0kmd1nmwj8gmr39ux+myRJGqxxnIMNVf41YAdSn4mWmjYx6dKuVKtVWyUzV0TE5cAJwF/77F/a57CzgX/b2nNLqnrWkXswY8YUHnlkFeVyEAS9vRVaWpp47VuOrPv8O+y0HQfNncb19z5OZlIi6AkoB7z97c+v+/ylUvCmIw7hCxf/nkolaW1qYn13N0lwyhGH1H3+seCIBbtx/oXXs2zFOiZOaKGSyfr1XRy49yzmztq+6PCkgfTw1HRrCfC2AmIZkTLzTUXHIEmSxpQhyb+2NIRtQ4dRCxt3GyXV1dhOGcyLRMR0oLtWPGoHjgM+2++YHTPzodrdlwG3Dubckp6qVCrxX99+G5/50I+46fr7qGQyd9fp/NNHTmS7aZOH5DX+/fNv4t8+eT5XXH8PXcCOE1p599+fwD4HzBuS879o/z1pa2ri21dfzyOr1rDb9O1561EL2H/WDkNy/tFuQnsLnzrjRL770z9xzY2LaW0u8/IXHMBJLzrYCbRHgU00B44n/X9JrM1MJ+7ajIhYlplPab2MiEczc0YRMUmSNFqN4xxsSPKvAQtImXkMQER8MjM/tLUn72NH4NzaPEgl4AeZ+YvaGP+FmXkB8K6IeBnVytgyNj9sTtIgTNlmAv/6X4MeZbrVmprK/MtHX8O/DNsrwLF778axe+82jK8wuk3bbhLvfvOxRYchbZXMvLfoGEaZ5v47aivaDmohE0mSpKHKvzZbQIqIvvMjndnvft9AtrisbGbexCZWEOk7+WNmfgD4wJbOJUmSRpeI+B2DmCUgM49qQDijQp/PrC0i+i+fOQv4Q+OjkiRJo8Vw5F8DdSBtaozcpngFTJKkrZHjbpjh2UUHMAqdDQTwTOAbffZvmEbgsiKCkiRpVBtfOdiQ518DFZD6jpF7MXAS8GngXmAX4P8BPxrqgCRJ0tiSmZtcWVWbt+Ezi4g/ZuZtRccjSZJGl+HIvzZbQOo7Ri4i3gssyMwVtV13RMRCYCHw30MdlCRJY1mM3wkcAYiImcChwDSqXTYAZOY5hQU1gvRf+TYinr2p4/y8JEnaOuM5BxuK/GtLq7BtsA0wAVjRZ9+E2n5JkrQ1xnfy8nLgf4E7gX2Am4F9gasACyJVfVdACOAI4GHgfmA2sAN+XpIkbb1xmoMNVf412ALSucAlEfEFnkxe3lXbL0mSNFifBN6UmT+MiOWZeVBEvIlqMiOeXAUXICL+C/hpZn6hz753Ay5RKUmSBmtI8q/BFpDeBywCXgPsBDwEfBn4n615MUmSxr1kvE3g2N+czPxhv33nUu2w+ecC4hnpXk+11byvLwOPU72YJ0mSBmN852BDkn8NqoCUmRXga7VNkiTp6Xo0ImZm5iPA4og4nGoxxFVdN+1h4GXAT/rseynwaDHhSJKkUWhI8q/NFpAi4g2Z+Z3a7Tdv7jgncJQkSVvhf4DnUF3J9fPA5UAF+M8igxrB3gX8KCLOoDqNwBxgb+DVhUYlSZJGkyHJvwbqQHot8J3a7Tds5pjECRy1GY90PMYVj/6eB9Y/yOwJO3PM9COY3ta/C3/kWreuk8svvZlrr7mbKVPaOe74/djvgDlFhzVomck1N9/Lr/94Gx1dPTz3oN04dsF8WpsHO3J1y269/SF+dclfWLZ8LQftP4cXHLsPkye1Ddn5V3ct5r7VP2Ft931s07oXcya/nPamGUN2/uG2ZtV6Lv3Fjfz5T3ez3bRJHHfiwey53+yiw9JIME4ncATIzM/2uf3tiLgCmJiZtxYX1ciVmRdHxK7AC6lOI/BL4JeZubTYyCRJGoXGaQ42VPnXZv+SzMwX9bl9zOaOkzbl3rUP8F+LzqK70kNTNHHfuge4dtkNvHv+acyasFPR4W1RR0c3H/vQj1iyZDnNzSV6eyvceP1iXvO6Z/Pilx5UdHiD8s1fXMMFV91MKYJSBLcufoQrb7yLT7zthTQ11T9S5NIrb+Ub5/6OzKSpqcyiux7lt1fdzqfOfOWQFJGWdfyZ6x/7CJndBC2s7LqDB9dewqEzP8fE5ll1n3+4rVm1no/+w3d4/NFVNDeXuef2h7j+D4s49V3HcdQJ+xcdnlSYiHgP8H+1Fmoy875iIxr5MvNxnryoJ0mStFWGKv8qDfLF3hUR/sWjQfvxkl/QU6kwsWkireVWJjZNpKvSzU+X/Kro0Ablqitv58Ely5kypY329hYmTWqjrb2ZH573R9au7Sw6vC16ZNlqfn7VzUxqa2FSeysT2lqYMqGV2+59hGtvu7/u83d29fDt7/2B1pYmJk9qo72tmSmT23j08dVccvktdZ8/M7lt+X9DQnNpG5pK7TSXtqGnspa7Vo6Ov6Eu/cWNPP7IKiZPaaetvYVJU9ppaWviu1+/nK7O7qLDU9FyGLbR42jgnoi4JCLeFBFTig5opImIX/e5/buIuHJTW5ExSpI0Ko3fHOxohiD/GlQBCVgA/DwilkXEzyLivRFxSESM2ynMtXmZyT1r7qW9vHEXSnu5jUVr7i4oqq1z4/WLKZU3/vZuaioTAYvvfqygqAbv9vseJUpBqfTkj3hEkBW48Y4ldZ//gSXL6a0kzc0bdzI1N5W5/qb6mwl6ch1ru++nHO0b7S/HRJZ23Fj3+Rvhz3+6m+aWfp9PcxO9PRUevG9ZQVFJxcvMl1MdinUe1SHyD0XEjyLilYUGNrJ8u8/ts4FvbGaTJEnaoqHKvwa7CtsbASJiLvDc2nZm7eGpW/OCGvsigglN7fRmL03x5LdYb/YyqWligZEN3nbTJlHp3bicnJn09iZTtmnfzLNGjm0mtrHJ6m4k07ap/2swZXIbld4KmUnfOnJPTy/bbVv/+cvRQimaSXqJPr+mMrtpHSVzIG03bTL33P4Q9Pl2yUwqvRUmTRm6eaI0GsV4XkIWgMxcQbUwcnZEzKnd/iGuxAZAZn6vz+1zi4xFkqSxY3znYEORfw22A4mI2BN4AXA88DzgDqozeUtPccyM59BR6aSSFQAqWaGz0sUxM55TcGSD87zn70OpHHR19QDVP/zXrOlkl12mMWv2dgVHt2X77rYj206ewOr1HWRWC2EdXd00l5s4+uDd6z7/9GmT2fsZO7F6becT5+/u7oUITnj+vnWfvxTNzJr0QnpzLfnE91AvFbqYO/lVdZ+/EY478SCIoLvv99DqDp5xwBymzdym4Oik4kXEcyLiK8C1wCzgIwWHNCJFxA0R8fmIeHlEjPx/gCRJ0ohVb/412DmQHqG66seuVNuq983MQzPzjK2MV+PE82c+l+dMexadlU46ezvprHRy9PRnj5oC0i5zp/POf3gB5XKJdeu6WLu2i/l77MB7/9+LGQ0jN8ulEh8/7YXMnrEtazu6WNvRRXtrMx9603FM33bSkLzGu97xPPbbe2fWrutiXUc3CZx26lHstceOQ3L+3ae+iR0nPo/eXEtvriPpZN6Uk9lp4nFDcv7htud+s3nTu44jgfXruli3ppO9D9yFd77/JUWHphEgcui30SIi/j0i7gX+F1gDHJ+Ze2fmJwsObaT6J2AV8B7ggYi4KSL+KyJOKjYsSZJGn/Gagw1V/jXY9bwvAI4EXg5sC2wXEb/NzPonU9GYVI4yfzP7RF604/NZ1rWc7Vu2Y2LThKLD2iqHHb47hyyYx5IHltE+oYWZo6xrZKdp2/DFf3wFSx5bSXdPL3N22JZyadBNh1s0ZXI7H/znl/D40tWsWt3BzjttS2vLYH+lbFk5Wth3+/cyf+qb6OxdSnvTDjSXhqb41ShHnbA/hx2zFw/et4zJ27Sz/QznCpaAicDrM/N3RQcyGmTmZcBlABGxPfBe4HTg73DInyRJGpwhyb8GOwfS2wAiYiZwFNU5kL4aEY9nZv3jYTRmTWqaOGrmPdqU5uYyc+dNLzqMpy0imDVj6rC+xrTtJzNt+8nDdv7W8ra0lrcdtvMPt5bWZubOn1l0GNKIkZl/V3QMo0lEvJAnc6/ZwNXAB4DfFhmXJEkaPYYq/xp0u0BEHEQ1eTmGajfSWuBPQxGEJEmSNumXwF3Ap4FvZ2ZPwfFIkqRxalAFpIhYDqwErqQ6nO2fMnPRcAYmSZIkjqTagfRq4JMR8Veq3UdXOgxQkiQ10mA7kA7KzMXDGYgkSeNC1jZpEDLz98DvgU9HxAzg3cD7gI/jHEiSJA2eOVjdBjWjrsUjSZKGUMbQb6NERLw7IqYVHcdoERGviIgvRsSNwGKq3UhfBl5YZFySJI1K4zQHG6r8a+iWZJIkSdqyY4HFEfGLiHhNRLQWHdAI925gBdXV17bPzCMz84OZ+Ztiw5IkSaPIkORfFpAkSWq0HIZtlMjME4FdgF8B7wEejoizI+KoQgMboTLz6Mz8SGZelpnri45HkqRRbZzmYEOVf1lAkiRJDZWZSzPzK5l5ONUVXp8JXB4RiyPigxExqeAQJUmSxpShyL82O4l2RBw7yCAuG3TEkiRp1FytGk4R8Tzg9cCJwELg34D7qA7Z+hXV1cckSZKGzjjPwerNvwZahe0bg3j9BHYdVKSSxpy1aztZeN09rF7dwR7zd2D+/JlEjI6J5KQijeefkoj4D+BkYCXwbeBDmbmkz+N/BJYXFJ4kSRrDxmsONlT512YLSJk5bwjilDRG3XX3o3z6Mz+no6Obnt4KTU1lFhwyl3/4++Molx0dK2mz2oBXZOa1m3owM7sjYkGDY5IkSRrLhiT/GqgDSZI2qVJJvvili+jq7mXSpDYAMpNrF97NH/5wJ0ceuWfBEUoj3Dhun87M0wEiYjawc2b+cRPH3NbwwEaQiPgOg/guycw3NiAcSZLGjnGagw1V/jWoAlJETAE+SnWipWn06fzKzDmDC1nSWPHAkmWsWLGO9vaWJ/ZFBOVSiSuvut0CkqTNqiUu5wEHUk3jJkXEScAJmfnWImMbQRYVHYAkSRo7hir/GmwH0leBWcDHgf+lOunSGcCPtiJmSWPEQPMcjddxxdKgjaIlX4fJWcAvqU7SuLS272LgPwuLaITJzI8VHYMkSWPO+M7BhiT/GmwB6QXAXpm5NCJ6M/NnEbEQ+Dnw+a15QUmj3847bct2201i2bI1TJjQClSHsPVWkuc+d6+Co5M0wh0KvDgzKxGRAJm5MiK2KTiuESsiWoA9eWoXuCvhSpKkwRiS/GuwM92WqM7WDbCm9iIPAbtvzYtJGhtKpeDd//ACWtuaWbuuk1Wr1rN2XSeHP2s3DnvWbkWHJ414kUO/jSKP0C9/iIi9qS4hq34i4jnAvcBvqV4pPB+4CDi7yLgkSRqNxnEONiT512A7kP5Mdf6jS4HfUR3Stga4Y2teTNLYMW/edL70+ddz/Q2LWbWqgz322IFd500fcHibpJrRk2wMh/8AfhERnwaaIuK1wL8Anyk2rBHr88C/ZebnI2J5Zm4XEWcC64oOTJKkUWf85mBDkn8NtoD0Np5smX438GlgKuDqH9I41t7ewhHP3qPoMCSNIpl5TkQsBd4O3A+cAnw4M39aaGAj1x7AF/vt+wxwD9VkUJIkaUBDlX8NqoCUmXf3uf0o8JateRFJkqQNMvNnwM+KjmOUWAlMAVYAD9XazZcCk4oMSpIkjS5DkX8NtgOJiHgz8FpgJ+BBqkvAnZOZ47cJTJIkbVEth9iizDxnuGMZhX4MvAj4HnAOcDnQTXUuJEmSpE0ajvxrUAWkiPg34ETgC1QnctwF+GeqK4K8b7AvJknSeBeMqgkXh8obBnFMUi2QqI/MfE+f2/8REX8EJgO/LiwoSZJGoXGYgw15/jXYDqRTgYMz84ENOyLiF8D1WECSJGnwknE3gWNmHlN0DKNVRHwpM9+14X5mXlXb/wXgPQWFJUnS6DPOcrDhyL9KgzxudW3rv2/V0IYjSZLGuoiYGhGvi4gzav+fWnRMI9ipm9k/mKuKkiRJwNDkX4PtQPoC8OOI+AzwADAbOAP4fETsuuGgvpNtS5KkTRtn7dMbiYhjqc7rczvVYfFzgK9ExKsy89JCgxtB+sxb0LSJOQx2BR5vcEiSJI164zUHG6r8a7AFpA3Lx/ZvgXoe8KXa7QTKg31hSZI0Ln0ZOC0zf7BhR0S8GvgK8IzCohp5NnQYtbBxt1ECj1BdfleSJGkwhiT/GlQBKTMHO9RNkiRtyTi9+lWzE/Cjfvt+AvxPAbGMWBvmLYiIT2bmh4qOR5KkMWH85mBDkn9tVWEoImZHxGFb8xw9fZnJAw8v587Fj9Ld01t0OE/Lss613Lz8IZZ3rhuW869d08Gdtz7I0kedjmtTMpO7ly/n1sceo7t3dH4PSRpzvgP8fb997wS+XUAsI15mfigito+IN0TEGQARsVNEzCo6NkmSNGoMSf41qA6kiJgD/B9wINWa3aSIOAk4ITPfujUvqMF5bNlqPnvWJdz34DJKpaC5qcw7XnskRxyy65afPAJ0V3r5ws1X8Jslt1KOEr0kL5q1N+/a+7mUo/6GtszkgvOu4YLv/4mIoLe3wv6HzOUdZ5xA+4TWIXgHo999K1bwL5dcwoOrVxERtDc18+Gjn8uzZs0uOjRJ49tBwDsi4n3AEmBnYAZwTURcueGgzDyqoPhGlIh4LtUrhguBI4B/B+YD/wy8tMDQJEnS6DEk+ddg50D6OvBL4EhgaW3fxcB/bmXQGoRKJfnEV37NQ4+uZNKEViKCru4evnju5czacSq77LRd0SFu0XfvWsivHriFKc1tlCKoZIWf3/dXZrZN5m93W1D3+a+96k5+/N0/MmFCC+WmMpnJjdfezblfuYx3nPHCIXgHo1tPpcJ7f/0rlq5bx6SW6vdQR083H7zkEr7zqpPYcfLkokOUxrfx2z4N1VZph6sN3heA12TmpRGxvLbvGuDQ4kKSJGmUGr852JDkX4MtIB0KvDgzKxHVecszc2VEbFNvAHqqu+57jEceW/VE8QigpbmJjs4eLv3D7bz5pMMLjnDLfrT4RiY0tVCqxV+KEu3lZs5ffOOQFJB+9ZPraGoqUW6qztseEUyc1MY1v7uDN/7dsUyYOL67kG546CGWr1/P5Na2J/a1NTWzsrOD3yxaxCkHHVRgdJLGs8w8t+gYRpm5fVZH2ZD2djH4HE6SJI1zQ5V/DTb5eATYHbhjw46I2Bu4byiC0MbWrOsiSvFE8WiDUilYtnJ45hIaSpnJmp5Otmlu32h/c6nMqu6OIXmNVSvXP1E82mDD57V+Xde4LyCt6uzcZHE9E5auH/nfQ5LGtoiYSfXi1DTgiX/sMvOcwoIauW6JiOMz86I++54P/KWogCRJ0ugzFPnXYAtI/wH8IiI+DTRFxGuBfwE+M/hwNVi7zdmeSiXp6a3QVK7OF5SZZCYH7zPy58yMCPbfdiduXvEwU5qf7IBZ3d3BIdOGZv6dAxbM5ZJf/JmWlie/hTs7upm63US23X7ikLzGaLbvjBlkJr2VCuXSk99DpYBn7rxzwdFJGs8i4uXA/wJ3AvsANwP7AlcBFpCe6p+o5mC/BNoj4utU5z46sdiwJEnSaDFU+degZjOuVaTOAF4N3A+cAnw4M7+7VVFrUKZMaue1L13A+o4uVq/tYN36Llav7WTe7GkccfBuRYc3KH+/11G0lMqs7FrPup4uVnavp72pmbfv+ZwhOf9LXv1Mttl2IqtXrWf9ui5Wr1pPpZKcevrzKJXqn6R7tJs5aRKv2W9/1nZ3saqzkzVdXazq7OCAHXbg8Nlzig5PUg7DNnp8EnhTZh4ErK39/zTgumLDGpky84/A/lQTvXOAe4BDM/PaQgOTJGk0Gr852JDkX4MeP5+ZPwN+tlUh6ml7xXEHsPucafz6d7eyZm0Hhx+0K0c/az6tLaNjyoM9tpnB2c/5W368+M/cufox9pwyg1fucgA7TJgyJOffbtpkPvXl13PpL//MLX++nx12nspxLz2IObtOH5LzjwVvX7CA/WfO5Be33876nm6O3XVXjt99Pk0W2KRiJcToSTaGw5zM/GG/fecCD1NdWUxAREwAPkT16uD1wKczs7PYqCRJGsXGdw42JPnXgNWIiDgE6MzMv9buT6e6Gsi+wNXAP2fmmq0IWlthvz13Zr89R+9wo50mbMPpew/fKsxTpk7gFa87nFe8buRPKl6EiODZc+bw7Dl2HEkaUR6NiJmZ+QiwOCIOBx4Hylt43njzFWAB8CvgJGB74B8KjUiSJI1WQ5J/bakV4QvADn3unw3sAZxFtYj0b1vzYpIkifHcPg3VJWQ3jGf+PHA58Gfgq4VFNDKdALwgM98HvBB4ScHxSJI0+o3fHGxI8q8tjYfaC/gdQERMpZrA7JuZd0TEBcAfgL/bmheUJEnjV2Z+ts/tb0fEFcDEzLy1uKhGpImZ+RBAZt4fEdsUHZAkSRqdhir/2lIBqQnoqt0+DHg4M++ovej9taKSJEnSVouIEvDAhtuZWSk4pJGkKSKO4clldvvfJzMvG8yJIuIE4ItU29TPzszP9Hv8HcDfA73AGuC0zLyl/rcgbdrPLrqBc35+Dcs6Opg2oZ13vOoIjn/uvoXGtGzlSj5y/td5cOr9UILtls7kwy95K3N22GHLT9aI0NnzMA+uOpcVHX+kqTSFmZNezfSJL6L6T42kDerJv7ZUQLqZ6sprPwBOBi7p86I7Ayu3OlpJksa5cTyBIxFxMNX5ffYH2jbsptoE7jxIT3qUjZfVXdrvfgK7bukkEVGm+nkfRzVZvDYiLuhXIPpeZn6tdvzLgM9RHUInDbnzfnYNX/j5HyChHPDQ2nV85DsX09Nd4cXP37+QmHp7e3nHzz5BZdY66A4SWD77Qf7x8s9w7sv/lUntEwqJS4PX3buMWx59B929KyiXJtDZ8zCLV/wnHT33M2fqO4sOTyPIeM3Bhir/2lI59v8BX4+IZcCLgc/2eew1wO8H+0KSJElUV/y4nOoE0bvWtnkMohgynmTm3MycN8A22M/rUGBRZt6dmV3AecCJ/V5rVZ+7ExlNMzpo1PnGhX8igOZSUIqguRSQ8NWfXFVYTN+/7BIq09eRHSXoLRG9JbKjREzt4uu//ElhcWnwHl1zAT2VlTSXp1KKFsqldppiEo+s+RHdvSuKDk8aCYYk/xqwAykzr4qIOVQnzr4jM1f3efiXVJMQSZK0Ncb3n+e7AB/MzPH9KTTOzsD9fe4/ADyr/0ER8ffAe4EW4NjGhKbxpqu7h1W93TQ/ORITgKaAZZ2dBUUFf31oEcwANooroASLVtxXUFTaGqu7biL6/WkbUSayREfPfTSXpxYTmEae8Zt9DEn+tcUBoZm5OjOv61c8IjNvz8wH63lxSZI07vwEeEHRQWhjmfmVzNyNavf5hzZ1TEScFhELI2LhY4891tgANSY0lUu0RolKvz9fKgkTSsWNYN1pyoxN/1GZMLNtWsPj0dZrb9qFCj0b7cuskPTSUp5eUFTSiDIk+ZczikmS1EBBdfz9UG+Deu2IEyLi9ohYFBHv38TjrRHx/drj10TE3Nr+7SPi8ohYExFf7vecQyLiL7XnfCkiYhPn/U5EfDsivk113P1PIuI3G/b1eUxDbwkwu8/9WbV9m3Me8PJNPZCZZ2XmgsxcMH26f5Bp65VKJV508J5UAnprF8F7K0kFOOnI/QqL680nvJRc20S09rJhXe5o6SU7ypx2/MsLi0uDN2PSKyjRTG9lLZlJZi+9uZqpbc+itWnHosPTCFFUDjaW8i8LSJIkNVIO07YFfSZTfiGwN/DaiNi732FvAZZn5u7A53ly7sMO4MPAP2/i1P8NvA2YX9s2NfnyIuCu2nZL7by/77Nvw6ahdy0wPyLmRUQL1UVRLuh7QETM73P3xcCdDYxP48z73n48L95/PkHQnUkpglceuhdvf91zC4tpQlsbH9rv7yk/PJForRCtFXi8ndNnncJOFktHhfbmOew5/d9pbdqR3lxFb65n2oQXsut2Hy46NI0kBeRgYy3/2tIqbNLTduXNd3PuFdfx4LJVzNp+G049dgFHPGNu0WGNGIvvfpRPfeZn3PXQciJgrznTOfPMVzFjxpSiQ5M0Nj0xmTJARGyYTLnvalwnAh+t3T4f+HJERGauBa6KiN37njAidgSmZOYfa/e/TbV75Vd9j8vMjw35u9GgZGZPRJwOXER1lZVzMvPmiPg4sDAzLwBOj4jnA93AcuCU4iLWWFcqlfjwu17C+zq7eXzZaqZPm0JLc/F/khy05558f89/56HHH6e3t5dZM2cWHZK20uTWA9h35rn0VlZTilZKpdaiQ5JgjOVfdiBpWPz25rv5zE+u4PFVa5nS3sqjK9fwqfMv4w+3LS46tBFhzZoO/u6fvsOih5ZRjqBEcPO9j/L208+hp6e36PAkjU7TNsxPU9tO6/f4piZT3nlzx2RmD7AS2H6A19y5dp6BzrmRiDgmIubVbu8QEedGxDcjYoeBnqenLzMvzMw9MnO3zPxUbd+ZteIRmfnuzNwnMw/MzGMy8+ZiI9Z40NrazM47bjciikd97ThtmsWjUSwiaCpPsXikRhsoBxtT+ZcFJA2Lb12+kOZyifaWZiKC9pZmmkolzr38uqJDGxF+eN7VdPT00lwqExHVf+xKJVau7+LXv7yx6PAkjU6Pb5ifpradVXRAm/FVYEOl/HNAM1ABRmq8kiRJAxkNOdiQ5F8jq+SvMSEzeXDZKqZOaNtof1tLEw8sXVlQVCPLorsfodJvwGwQJBXuuuuRgqKS1CiDnfR6iA1mMuUNxzwQEU3ANsDSLZxz1hbO2d/OmXlf7fzHU11WtgtwZVdJkjSsCsjBxlT+ZQeShlxEsNO2U+jo3ngpzY6uHmZtv01BUY0su+06gxIbT5SfJEGw664zCopK0hi3xcmUa/c3zH9zEnBZZm421crMh4BVEXFYbfWPNwI/20IcqyJiJvBc4JbMXFPb37x1b0eSJGnEG1P5lwUkDYtTj11Ad28v67u6yUzWd3XTU6lwyjGHFB3aiPA3rzmctqYy3ZXe2lKjSU+lwjbtLbzwJQcVHZ6k4VbAKmy1MfUbJlO+FfjBhsmUI+JltcO+AWwfEYuA9wJPLDUbEYuptjyfGhEP9FlB5O+As3lypY+NJnDchP+imkx9l+qqJABHALdt+V1IkiTVocE52FjLvxzCpmHx3H12BeDbV1zHkg2rsB2zgGe7ChsAkya389X/fAOf/PRPufvhFUTA3nOm85EPv5KmpnLR4UkabsUMYSMzLwQu7LfvzD63O4BXb+a5czezfyGw71bE8NmI+AnQm5kblo5dArx1sOeQJEl6WgrIwcZS/mUBScPmufvs+kQhSU81d9cZnP0//RdJkqSxLzPvGOi+JEmShtZQ5F8WkCRJarSCOpAkSZLGNXOwujgHkiRJkiRJkgZkAUmSJEmSJEkDcgibJEmNlBC2T0uSJDWWOVjd7ECSJEmSJEnSgOxAkiSp0bz6JUmS1HjmYHWxA0mSJEmSJEkDsgNJkqRG8+qXJElS45mD1cUCkiRJDRZFByBJkjQOmYPVxwLS01SpVFj4+0X87tJbIJMjjt2bZz5nPuXy0I0KvPmm+7nsN39l7ZoOnnnY7jzn6GfQ2tY8ZOfXwNasX81vbvkej66/hiYms/+Or+DQ3Y4uOqxBy0xuWngPv/31X+no6OKw5z6Dw495Bs3N/thLkiRJkrZOQ/6SjIg24Eqgtfaa52fmR/od0wp8GzgEWAq8JjMXNyK+rZWZfOOLF3PVpbdSKlVrmDdddy/XXb2Iv/t/LyKi/rrmL396PT/43z8AUCoHt/zlAa687BY++MlX0dJiAWC4rVm/mu9c/zaa2x+l3FaCSG5a+VeWXHc7rzjk7UWHNyjnn/t7Ljz/WoigVApuufF+rr7iNv7546+g3FQuOjxpfLN9WpIkqfHMwerSqEm0O4FjM/MA4EDghIg4rN8xbwGWZ+buwOeBzzYotq12792P8YfLb2PipLYntkmT21j4h0Usuu2hus+/auV6zv/e1bS3tzBpchsTJrQyaXIbi+9+lGt+f+cQvANtyWW3/pDm9sfo7W6j0ttKb08bvT3NPJ7ns3ztsqLD26Klj67iwh8tpH1i9XtnwsRWJk1p47a/3M+fr72n6PAkSZIkSaNMQwpIWbWmdre5tvWv/Z0InFu7fT7wvBiKVp5hcOctD9JbqTzRfQQQEfT09HLHzUvqPv/iux8lIig3PfnliQgighuvW1z3+bVlD6/7E1kJNholm9WundsfurGQmLbGotseohSx0ZDKiCAr8Ncb7i0wMklQ/c0y1JskSZIGZg5Wn0Z1IBER5Yi4EXgUuDgzr+l3yM7A/QCZ2QOsBLbfxHlOi4iFEbHwscceG+aoN23ipDbKpad+dOVyiUlT2ofg/K1kJcncuMZWqSTbbjex7vNry5piKhGVfnsTIpnStm0hMW2NiZNaN/1AwDbb+j0kSZIkSdo6DSsgZWZvZh4IzAIOjYh9n+Z5zsrMBZm5YPr06UMa42Ad9Kx5tLU3s35d5xP71q/vorWtmUMO363u88/bbSYzdtyGtas7nigidXX1UC6XeO7z9q77/NqyZ84+CSgR0Vvbk5SbO+jpmMYzdjqgyNAGZa/9ZzNl6gTW9Pke6uzopqmpzLOP2avg6CSRw7BJkiRpYOZgdWlYAWmDzFwBXA6c0O+hJcBsgIhoArahOpn2iNM+oZUzPvFKpkydwLq1naxb18nESa3888dewaTJ9XcglUrBP3/oZcyeO411aztZv66LCHj7u17A7F2mDcE70JbsN2cBOze/GSIplbsoN3XSvX4mL9vrs5Q20X020pSbypzxqVcxc8eprF/bxbq1nTQ1l/mHD76U6TtsU3R40vg2HInLOEteJEmStpo5WN0atQrbdKA7M1dERDtwHE+dJPsC4BTgauAk4LLsP4ZrBNl1jx34z3PezH33PA6ZzJ43faP5Zuo1fcYUPvEfJ/PgA8voWN/N7LnTXH2twV64/9+yrutEbnvwJia3bcNuM54xKopHG+w0ezs+/fVTeODepXR39TBn3nSaml19TZIkSZK09RpVkdgRODciylS7nn6Qmb+IiI8DCzPzAuAbwHciYhGwDDi5QbE9baVSibm7zRi280cEO89+yjRQaqAJLRM5eO7hRYfxtEUEs+fatSaNJAHEiL08IkmSNDaZg9WvIQWkzLwJOGgT+8/sc7sDeHUj4pEkSZIkSdLgOSZKkqRG8+qXJElS45mD1WX0TOgiSZIkSZKkQlhAkiRJkiRJ0oAcwiZJUqPZPi1JktR45mB1sQNJkiRJkiRJA7IDSZKkBnMJWUmSpMYzB6uPBSRJkhopsX1akiSp0czB6mYBaQRbs7aT629YzPr13ey9107MnrVd0SFJkiRJkqRxyALSCHXLrUv498/9mu7uHiqVJErB8c/flze87tlERNHhSZLq4dUvSZKkxjMHq4uTaI9A3d29fP5Lv6FSSSZObGPy5HYmtLdw0SV/5a83Lyk6PEmSJEmSNM5YQBqB7rjzYTo7u2lra35iX6lUIitw1R/uKDAySdJQiGHYJEmSNDBzsPpYQBqBMjffVzfAQ5IkSZIkScPCOZBGoD3m70BzcxOdnd20tla7kKrzIMERh88vODpJUt28GCBJktR45mB1sQNpBGppaeLdpx9HJqxZ08HKletYt76TY456BvvvN6vo8CRJdYoc+k2SJEkDMwerjx1II9T++83mS59/HdcuvIeOji722Wtn5s6d5gpskiRJkiSp4SwgjWDbTGnn+cfuXXQYkqShNs6uVkmSJI0I5mB1cQibJEmSJEmSBmQHkiRJjTQOx8tLkiQVzhysbnYgSZIkSZIkaUAWkCRJkiRJkjQgh7BJktRotk9LkiQ1njlYXexAkiRJkiRJ0oDsQJIkqdG8+iVJktR45mB1sYAkSVIDBa4AIkmS1GjmYPVzCJskSZIkSZIGZAFJkiRJkiRJA7KAJEmSJEmSpAE5B5IkSQ3m+HtJkqTGMwerjwUkSZIaKYE0e5EkSWooc7C6OYRNkiRJkiRJA7IDSZKkBrN9WpIkqfHMwepjB5IkSZIkSZIGZAeSJEmN5tUvSZKkxjMHq4sdSJIkSZIkSRqQHUiSJDWY4+8lSZIazxysPhaQJElqNJMXSZKkxjMHq4tD2CRJkiRJkjQgO5AkSWqkxKtfkiRJjWYOVjcLSJIkSRpVHlmynEU3L2HilHb2OXgXmltMaTfn8XXruOGhB2kulTl01iwmNDcXHRIdHd186b8v5s7Fj7HPHjty+tuPpamp+K/hHQ9ez60P/QdBhTnbncaB844tOiQA3nfWz1m4eAk7TJ7Il//+FWw3ZVLRIbFm/Tp+fcPVrO5cx7Pn78+es3YpOiQAHn1oBXfcvISJk9rY95BdaG4u/vtqpFq5Yh03//UByuUS+x0wmwkTWosOSaOAP1GSJDVUQnr5S40TEScAXwTKwNmZ+Zl+j78XeCvQAzwGvDkz7214oIOQmXz3K5dy2QU3EBFEBBOntPG+f3sNO8+dVnR4I86Pbr6Zr/zpGgCCoKlc4tPPP46Dd9qpsJhuvW0Jb/vg/1GJ6v2blzzGjy/7C//7+VOYM6e4r+FPr30zR+/0B2bumASQ+U5+ft1evPSQnxYW08OPr+C4z36T3qbqvxkPr1rHc/71LP7l2KN4/QsWFBbX1bf9hc/d+i0qTb0kyS9uuJQDFu7Dh172FkqlYmZIyUzOO/u3XPyT6yCCCJgwsZX3ffpvmL3r9EJiGskuu+SvfPubvyMrCRE0NZV493tfyP4Hzik6tGFmDlYv50CSJKnBYhg2aVMiogx8BXghsDfw2ojYu99hNwALMnN/4Hzg3xob5eBd/4c7ufSCG5gwqZWJk9uYMKmVNavW8+WP/ZT0j4KN3LVsGV/+0zW0NTUzqaWViS0tZCb/csnFrO/uLiyud33kB08Ujzb87uopJe98/3cLi+mWB/7I0Tv9niTpzqArgx7gqB1v5be3fKewuF7x2W/T21z9vn7id30JPnPx7wqLqaunhy/c/G0q5V7KPU009TRT6ilxY9Nf+fX1VxcW103X3sNvfnId7RNbmDiplQkTW1m3ppMvfOwnVCqVwuIaiR58cDnf+saVtLSUmTiplYkTWwD44ud+xbp1nQVHN/zMwepjAUmSJGnsOhRYlJl3Z2YXcB5wYt8DMvPyzFxXu/tHYFaDYxy03154E6VSbNTlMGFiK48+tIIlix8vMLKR57K776K3UqGpz2fV1tRMV28vCx98sJCYOjq6WdvbCzz5R1cAJCzvKq6oddcjn6MU0NvnT8EkCKCj+9zC4lpV6oXs9wdqQqU5+d1NiwqJ6fe3/pme5m7KvU8OZAlKBPCbe4orIF35m78AbPS7oX1iCyuWruG+ux4rKqwR6ZqrF1HprdDUVH5iX2trEz09vdz05/sKjEyjgQUkSZIaLYdhkzZtZ+D+PvcfqO3bnLcAv9rUAxFxWkQsjIiFjz1WzB9k3V09RGx8vXfDULbeHrsM+urs6d3sYz2VzT82HpWie5O/RwNoKvU0PJ4NMjb/y33V2mI6RXp7N/O9k9CTxX1W3Z099PvVUPtdEXR3FxfXSNTT3bvZtKGnexz8bjAHq4sFJEmSJBERrwcWAP++qccz86zMXJCZC6ZPL2ZOkcOO2YvenspGw9U61ncxcVIrs5znZCNHzt2FcgSVPp9Vd28vQXDQjjsWElNbWzMtmxnw0V7Q3DkA2058HRkQG/0lmCTQ2XNCUWHR3lOqRbKx6A1efPg+jQ8IOPwZ+xOVEpV4stCQVMiAZ+94UCExARx+zF5UKrnR74bOjm5a25qZO39mYXGNRAcdMpdyubTR0L6eWsF5n/1mFxWWRgkLSJIkNVAAkUO/SZuxBOj7F8Gs2r6NRMTzgQ8CL8vMETsJxrOfvw97H7wLa9d0smrFOlavWg/AO/7lpZTLprV97T9zB16y556s7epkRcd6Vnasp7O3h/cecQRT29oLi+t9b3s+sPHF+0j42D++uLCYnr3nSVz92FyaA1oiaY2kJeDPK7bnRQe9v7C4vvDGlxC1CaMyqhvAifPnFxbTxLY2XjvzJWQp6Wnupqelm0pzLzuu24GTDn9eYXEdetSeHPDMXTf63VCpJO98/4tdia2f3XafyXHH78e6dd2sXLmeVSvX09HRw+tPOZJtt51YdHjDyhysfv40SZLUaE72q8a5FpgfEfOoFo5OBv627wERcRDwdeCEzHy08SEOXnNLE+/915O4+brF3Prn+5gydQKHHbMX206bXHRoI05E8N5nH8ELdp/P1fffR2u5iWPmzWPO1KmFxvWi4w9gj/k78K+f+yUPL1vNztOn8OF/emmhK7ABnHDARVz05y/RUjqfUqnCms4X8OKDzyw0piP3351fzTiFt3/1Rzy8dg0Ty8186KTnccKhexUa16sOP5b9l8znZzdewequtTxr9n684KBn0VQu7k/LclOZd3/05dx8/b3ccuN9TJ7SzrOOfgbbz5hSWEwjVUTw+lOew2HPns8N1y2mubnMM5+1G7Nmb1d0aI1hDlYXC0iSJEljVGb2RMTpwEVAGTgnM2+OiI8DCzPzAqpD1iYBP6zNL3RfZr6ssKC3oFwusf+hu7L/obsWHcqIFxHsN3Mm+80cWUN4dt91Jud8+c1Fh/EUxx/wLuBdRYexkTk7bMevPv62osN4ivk7z+afd35D0WFspFQqsd+Ceey3YF7RoYx4EcH8PXZg/h47FB2KRhkLSJIkNdI4bHdWsTLzQuDCfvvO7HP7+Q0PSpKkRjMHq5uDxSVJkiRJkjQgC0iSJEmSJEkakAUkSZIkSZIkDcg5kCRJajDH30uSJDWeOVh9LCBJktRoFbMXSZKkhjMHq4tD2CRJGici4oSIuD0iFkXE+zfxeGtEfL/2+DURMbfPYx+o7b89Io7vs39xRPwlIm6MiIUNeiuSJEmjwljKv+xAkiSp0Qq4+BURZeArwHHAA8C1EXFBZt7S57C3AMszc/eIOBn4LPCaiNgbOBnYB9gJuCQi9sjM3trzjsnMxxv2ZiRJkp6OBudgYy3/sgNJkqTx4VBgUWbenZldwHnAif2OORE4t3b7fOB5ERG1/edlZmdm3gMsqp1PkiRJmzem8i8LSJIkjQ3TImJhn+20fo/vDNzf5/4DtX2bPCYze4CVwPZbeG4Cv4mI6zbxmpIkSWPdQDnYmMq/HMImSVIjJcPVPv14Zi4YljMP7DmZuSQiZgAXR8RtmXllAXFIkiRt3tjKwQrJv+xAkiRpfFgCzO5zf1Zt3yaPiYgmYBtg6UDPzcwN/38U+AkObZMkSdpgTOVfFpAkSWqwyKHfBuFaYH5EzIuIFqqTMl7Q75gLgFNqt08CLsvMrO0/ubZKyDxgPvCniJgYEZMBImIi8ALgr/V+PpIkScOhgBxsTOVfDmGTJGkcyMyeiDgduAgoA+dk5s0R8XFgYWZeAHwD+E5ELAKWUU1yqB33A+AWoAf4+8zsjYiZwE+q8zzSBHwvM3/d8DcnSZI0Ao21/MsCkiRJjdbgJWSfeNnMC4EL++07s8/tDuDVm3nup4BP9dt3N3DA0EcqSZI0DArIwcZS/mUBSZKkBossqIIkSZI0jpmD1cc5kCRJkiRJkjQgO5AkSWo0L35JkiQ1njlYXexAkiRJkiRJ0oDsQJIkqYEi0/H3kiRJDWYOVj87kCRJkiRJkjQgO5AkSWo0L35JkiQ1njlYXSwgSZLUaLZPS5IkNZ45WF0cwiZJkiRJkqQB2YEkSVKDRdEBSJIkjUPmYPWxA0mSJEmSJEkDsgNJkqRGc/y9JElS45mD1cUCkiRJjZRApeggJEmSxhlzsLo5hE2SJEmSJEkDsgNJkqRGs3takiSp8czB6tKQDqSImB0Rl0fELRFxc0S8exPHHB0RKyPixtp2ZiNikyRJkiRJ0sAa1YHUA/xTZl4fEZOB6yLi4sy8pd9xv8vMlzQoJkmSJEmSJA1CQwpImfkQ8FDt9uqIuBXYGehfQJIkacwLVwCRJElqOHOw+jR8Eu2ImAscBFyziYcPj4g/R8SvImKfzTz/tIhYGBELH3vsseEMVZIkSZIkSTR4Eu2ImAT8CHhPZq7q9/D1wC6ZuSYiXgT8FJjf/xyZeRZwFsCCBQssH0qSRh+vfkmSJDWeOVhdGtaBFBHNVItH383MH/d/PDNXZeaa2u0LgeaImNao+CRJkiRJkrRpDelAiogAvgHcmpmf28wxOwCPZGZGxKFUi1tLGxGfJEkNk0Cl6CAkSZLGGXOwujVqCNsRwBuAv0TEjbV9/wLMAcjMrwEnAe+MiB5gPXBypv1lkiRJkiRJRWvUKmxXAbGFY74MfLkR8UiSVJwk8PqIJElSY5mD1auhk2hLkiScwFGSJKkI5mB1adgk2pIkSZIkSRqd7ECSJKnRvPglSZLUeOZgdbEDSZIkSZIkSQOyA0mSpEZzCVlJkqTGMweriwUkSZIazBVAJEmSGs8crD4OYZMkSZIkSdKA7ECSJKmREpeQlSRJajRzsLrZgSRJkiRJkqQB2YEkSVKjefVLkiSp8czB6mIBSZKkhkqTF0mSpIYzB6uXQ9gkSZIkSZI0IDuQJElqNC9+SZIkNZ45WF3sQJIkSZIkSdKA7ECSJKmBAgivfkmSJDWUOVj97ECSJEmSJEnSgOxAkiSpkRJXAJEkSWo0c7C6WUCSJKnRKiYvkiRJDWcOVheHsEmSJEmSJGlAdiBJktRwXv2SJElqPHOwetiBJEmSJEmSpAHZgSRJUqM5gaMkSVLjmYPVxQKSJEmNlNg9LUmS1GjmYHVzCJskSZIkSZIGZAeSJEkNlS4hK0mS1HDmYPWygDROZSaX3bCIH/72zyxdvY69d5nJKcctYNedti86NEmSNIQi4gTgi0AZODszP9Pv8aOALwD7Aydn5vkND3KUy0yuuvQWfvHDa1m+dC177rszr37jEczZdXrRoWmQ1qxdxS9//3lWt1xNlJK2dQfxwsPey3ZTZxQa15UX/5WzvnopS1espa21iRNffginvuN5hcYkafxyCNs49aMr/8IXfvw7Hl25hnIE19+5hDPO+gX3PbK86NAkaRyoDMMmPVVElIGvAC8E9gZeGxF79zvsPuBU4HuNjW7s+MUPr+XsL1zM0sfWUC6X+MvCxXzijO/z4P3Lig5Ng1CpVDjvd+9k3ZTLodwDVOia+kd+tPDtdHatLyyuP1xxK//6qQt4bPlaAljf0cP3/u8avvCvPy8sJmn0MwerhwWkcaizu4fzrriB9tYm2luaKZdLTJnQSld3D+dfeVPR4UnS2Jc59Ju0aYcCizLz7szsAs4DTux7QGYuzsybGG9Z8BDp7Ojmgu//ifYJLbS1VfOqSVPa6ers4ZfnX1t0eBqEP9/6W0pTHqS3sxUqTWSW6e1spTxhBX+8sbhizf/896Uk0FQqEVGiXCpRDvjNxX+lq7O7sLikUc0crC4WkMahpSvX0lOp0Fwub7S/taWJ2x94rKCoJEnSMNgZuL/P/Qdq+zRElj2+mkpvhaamfnlVaxN33fZwQVFpazy89E6IBKLP3iDKFR5ZeUdRYfHY42ue8sdaqVSiN5OHHrC7TVLjWUAah7adPIEg6K1sfKGxq6eXOTOmFhOUJI0Xid3TGpUi4rSIWBgRCx97zAtOG0zdbiIJ9Pb2y6u6eth5rnNLjgbbTt4Z8ql/FmWlxHYT5xQQUdXUKe1P+fVeqVSIgOk7TC0iJGl0MwermwWkcai9tZmXHLYXa9Z30d3TS2ayrrObUgSvfu4BRYcnSZKGzhJgdp/7s2r7tlpmnpWZCzJzwfTpTg69QfuEVp73ogNYt7aTnu5qXrV+XRelUvDiVy0oOjwNwoL9XkDvum0ot3YA1SEppZYOKh3tHHbAywuL62/f+BwAeisVMitUKhV6Ew5bMI8JE1sLi0vS+GUBaZw69fhn8tpjDyKBVes6mTF1Eme+4Tj2mGVCKEnDzvH3apxrgfkRMS8iWoCTgQsKjmnMOfnNz+HEkw+lksnqVeuZvsMU3vvRl7PrHjsUHZoGoampmZcf9GVi+V6UWroot3XCinkcv+cXmDRxSmFxvegVh/DmU4+ktblMTyUhguceMZ8PffpvCotJGvXMwerSVHQAKka5VOJ1zzuY1x5zEF09vbQ2l4mILT9RkiSNGpnZExGnAxcBZeCczLw5Ij4OLMzMCyLimcBPgG2Bl0bExzJznwLDHnXKTWVe+fpn8/K/PYzurl5aWpvMq0aZ6dvvzKkv/G+6ujpJKrS2tBcdEgCvOfVIXv3GI1i1cj2TJrc9Za4tSWokC0jjXKkUtLX4bSBJjZO1TWqMzLwQuLDfvjP73L6W6tA21alUKtHaZoP/aNbSMvKGhpVKJaZuO7HoMKQxwBysXlYOJElqtHHW7ixJkjQimIPVxUskkiRJkiRJGpAdSJIkNVrFq1+SJEkNZw5WFzuQJEmSJEmSNCA7kCRJaqTE8feSJEmNZg5WNwtIkiQ1nMmLJElS45mD1cMhbJIkSZIkSRqQHUiSJDVUOoGjJElSw5mD1csOJEmSJEmSJA3IDiRJkhqoOn+jV78kSZIayRysfhaQJElqNJMXSZKkxjMHq4tD2CRJkiRJkjQgO5AkSWqkav900VFIkiSNL+ZgdbMDSZIkSZIkSQOyA0mSpIZKqFSKDkKSJGmcMQerlx1IkiSNExFxQkTcHhGLIuL9m3i8NSK+X3v8moiY2+exD9T23x4Rxw/2nJIkSePZWMq/LCBJkjQOREQZ+ArwQmBv4LURsXe/w94CLM/M3YHPA5+tPXdv4GRgH+AE4KsRUR7kOSVJksalsZZ/OYRNkqQGy2Lapw8FFmXm3QARcR5wInBLn2NOBD5au30+8OWIiNr+8zKzE7gnIhbVzscgzilJkjQiFJCDjan8yw4kSZLGhmkRsbDPdlq/x3cG7u9z/4Havk0ek5k9wEpg+wGeO5hzSpIkjWUD5WBjKv+yA0mSpEYaviVkH8/MBcNxYkmSpFHPHKxudiBJkjQ+LAFm97k/q7Zvk8dERBOwDbB0gOcO5pySJEnj1ZjKvywgSZLUaDkM25ZdC8yPiHkR0UJ1UsYL+h1zAXBK7fZJwGWZmbX9J9dWCZkHzAf+NMhzSpIkjQyNz8HGVP7lEDZJkhoqIRs/iXZm9kTE6cBFQBk4JzNvjoiPAwsz8wLgG8B3apM0LqOakFA77gdUJ2fsAf4+M3sBNnXORr83SZKkLWt8DjbW8i8LSJIkjROZeSFwYb99Z/a53QG8ejPP/RTwqcGcU5IkSVVjKf+ygCRJUoNlZVgmcJQkSdIAzMHq4xxIkiRJkiRJGpAdSJIkNdLwLSErSZKkzTEHq5sFJEmSGixNXiRJkhrOHKw+DmGTJEmSJEnSgOxAkiSpoRq/hKwkSZLMweplB5IkSZIkSZIGFKN5DGBEPAbcO4hDpwGPD3M4w8n4izfa34PxF2+0v4fxEv8umTl9OAOJiF/X4hlqj2fmCcNwXukptiIHG26j/XdTI/lZDZ6f1eD5WQ2en9XAzMFGgVFdQBqsiFiYmQuKjuPpMv7ijfb3YPzFG+3vwfgljUT+bA+en9Xg+VkNnp/V4PlZaSxwCJskSZIkSZIGZAFJkiRJkiRJAxovBaSzig6gTsZfvNH+Hoy/eKP9PRi/pJHIn+3B87MaPD+rwfOzGjw/K41642IOJEmSJEmSJD1946UDSZIkSZIkSU+TBSRJkiRJkiQNyAKSJEmSJEmSBjSmCkgRMT8iOiLifzfz+BkR8deIWB0R90TEGY2OcSBbir/PcS0RcWtEPNCo2AZrMO8hIg6OiCsjYk1EPBIR725kjAMZxPdQa0R8rRb3soj4eUTs3Og4NyUirqjFvqa23b6Z4yIiPhsRS2vbZyMiGh3vJuIabPwj8ud4sPH3OX5E/RxvTfwj9Wd4K76HRuzPsaSNRcTpEbEwIjoj4ltbOPYfI+LhiFgVEedERGuDwhwRBvtZRcQpEXFd7XN6ICL+LSKaGhhq4bbm+6rPcy6NiPSzGvDYXSPiF7Uc7fGI+LcGhTkibMXPYETEJyNiSUSsrOUv+zQwVOlpG1MFJOArwLUDPB7AG4FtgROA0yPi5EYENkhbin+DM4DHhjmWp2vA9xAR04BfA18Htgd2B37TmNAGZUtfg3cDhwP7AzsBy4H/akBcg3V6Zk6qbXtu5pjTgJcDB1B9Hy8F3t6g+LZkMPGP5J/jwcS/wUj8Od5i/KPgZ3gwX4OR/nMs6UkPAp8EzhnooPj/7d19sF1Vfcbx70MiSSEkwcDE5oWIiBZQuKUgmQp4R+kEVCpY49jBFor4OgxYgmjxpYHyMtJiBXxBMSVAUgiOvEWNlCnSIagBfElKBm1pgoYEwkveMQQTf/1jrescbu452fvknrP3vXk+M2dy79lr7/Ocfe/KXnfttdaRZgCfAd4BTANeB1zS8XT1UuhcAfsAnwQOAI4jnbMLO5qsfoqeKwAknQG8qqOJ6qtoHdwbuA+4H3gNMAVoeVN8GCr6ezUTOBs4AXg18GPgls5GMxscw6YDKf8BuQH4z2ZlIuKqiPhZRGyPiF8BdwNv7VLElorkz+UOBj4IXNmFWKUUfA8XAPdGxPyI2BYRmyPi8a4E3IWC+Q8m5V8bES8BC4ChdsfgTODqiHgqIlYDVwNnVRupuDrX46LqXI8LqG0dLmE41GOzPUJE3BERdwEv7KLomcCciFgeEeuBf2IIXdsGQ9FzFRFfj4gHI+Ll3A6YzxC7ju6uEr9XSBoH/CNwUadz1VGJc3UWsCYivhQRL0bESxGxrOMBa6TEuToYWBwRKyJiB6mj7fBO5zMbDMOiA0nSWOBS0h82RfcRqdd3eadylchSJv91wMXA1o6GKqnEe5gOrJP0I0nP5qkjB3U+YWsl8s8B3ippkqR9gDOARZ3OV8KVecjwQ5J6m5Q5Alja8P1S6vPHc5H8f1CnepwVzV/Lekyx/LWsww2KvIe612MzK2+ga9tESRMqyjOUnEh9rqN1dAXwdeCZqoPU3HTgSUmL8nX4AUlvrjpUTd0GHCLpDZJeReoA/0HFmcwKGRYdSKS7THMiosxaIrNJ7//GjiQqp1B+SacDIyLizu7EKqXoz2AK6T/J84GDgJXArR3OVkTR/P8LrAJWA5uAw0gdT3XwadKQ/cnAN4GFkg4ZoNwYYGPD9xuBMbkzpkpF8zeaTX3qcaH8Na7HRc9/XeswFH8Pda7HZtaega5tAPtVkGXIkHQ2cAzwL1VnqSNJx5BGZ3ma865NAT4AXEuaHv494O48tc1e6WlgMfAr0s3EmcDfV5rIrKAh34EkqQc4CfjXEvucS1pD5V0Rsa1D0Ypm6aFAfkn7AlcB53UhViklfwZbgTsj4pE8deQS4M/z8OBKlMz/VWAUae2XfYE7qMnIhYhYkqcTbYuIm4CHgHcOUHQLMLbh+7HAloiIbuRspkR+oF71GIrlr3M9LnH+a1eH+5R4D7Wtx2bWtoGubQCbK8gyJEg6jTSV+pSIeL7iOLUjaS/ga8D5EbG96jxDwFbStKxFEfEyqVNyAukmjb3SF4BjganAaFJb6v48Ktqs1obDpwj0Aq8FfpMHUIwBRkg6PCKO7l8432n5DHBiyRFLndJLsfyH5nIP5nJ7A+MkPQNMj4gnuxd5J70U/xksAxo7KirttMh6KZ6/B/hsRKwDkHQdcKmkA2rY+ArSgtP9LSctoP1w/v4o6jl0vVn+OtbjgQyUv871uL9m57+OdbiZZu+hh6FTj82smL5r2+35+6OAtRGxyzVu9kSSTgZuIN2E+e+q89TUWNLorAX5mj0iP/+UpJkR8WBlyeppGXvYWlq7oQdY0NCGnSvpy6R1kB6tKpRZEUN+BBJpmsIhpIrYA1xPGjI5o3/B/AkKVwB/EREruhexpaL5HyP1UveVOwdYm79e1YWcrRT+GZCmGp0uqSfP+f086W7FxgHKdkuZ/I8AfytpXM7/CdKCgZX+0SlpvKQZkkZLGpl/109k4PnUNwMXSJosaRIwC5jbxbg7KZO/jvW4RP5a1uOSvz91rMNl30Mt67GZ7SzX59GkP95H9NXxAYreDHxI0uGSxgOfo+JrW7cVPVeS3k5aOPuvIuLh/tv3BAXP1UbSVKye/Ogb0fpnwJIuRa1ciTo4D5gu6SRJI0if9Pc8MNQ+aKNtJc7VI8BMSRMl7SXpb0if8vdEN/OatSUihtWDtCbKvPz1CaSpOX3bVgK/Iw1z7ntcX3Xmovn7lesFnqo6bzvvAfg4ae2R9cBCYGrVmUv8Dk0gNbqeJX1i22LgLTXIfCDpYrQ55/oJqYNloPcg0jSqdflxFaAhlL929bhM/n771aIel81fxzpc8neolvXYDz/82PmRr8nR7zGbtAbbFuCghrIXkDrlN5E6u0dVnb+O5wr4IbC933V0UdX563iu+u3z2lxuZNX563qugPeSOkE2AQ8AR1Sdv47nijRt7auktZA2AT8DTq46vx9+FHkoos6zD8zMzMzMzMzMrGrDYQqbmZmZmZmZmZl1kDuQzMzMzMzMzMysJXcgmZmZmZmZmZlZS+5AMjMzMzMzMzOzltyBZGZmZmZmZmZmLbkDyczMzMzMzMzMWnIHktkwIelJSSc12TZX0mXdzpRfu2kuMzMzs6FK0mxJ85ps65X0VLcz5ddumsvMbHe4A8lskEk6XtKPJG2UtE7SQ5KOrTpXN1TZUWVmZmYGf7h5tVXSFklrc/tkTIH9HpB0TjcyDpYqO6rMbM/jDiSzQSRpLPBd4Drg1cBk4BJgW5W5zMzMzPYwp0bEGOBo4BjgcxXnMTMb8tyBZDa43gAQEbdGxI6I2BoR/xERy/oKSDpb0uOS1ku6V9K0hm0h6TxJKyQ9L+mfJe2Vtx0i6X5JL+Rt8yWNbyekpHdL+oWkDXm01JEN256UdKGkZXkU1QJJoxu2XyTpaUlrJJ2TM79e0keAM4CL8h2/hQ0v2dPseGZmZmadEhGrgUXAmwAkTc9tnw2Slkrqzc9fDpwAfCW3Y76Sn79G0ipJmyT9VNIJ7eSQNEnSdyQ9J2mlpPMats2WdLukmyVtlrRc0jEN24+W9PO87du5LXWZpH3ze5uUM2+RNCnvtnez45mZtcsdSGaD63+AHZJuknSKpP0bN0p6D3Ax8F7gQOBB4NZ+xziddKfsaOA9wNl9uwNXApOAw4CpwOyyASX9KfBvwEeBCcA3gHskjWoo9n7gZOBg4EjgrLzvycAFwEnA64Hevh0i4pvAfOCqiBgTEafu6nhmZmZmnSRpKvBO4OeSJgPfAy4jjRS/EPiOpAMj4rOkdtm5uR1zbj7EI0BPLv/vwLfL3gjLNwMXAktJo9PfAXxS0oyGYn8J3AaMB+4B+jqw9gbuBObmDLeS2opExIvAKcCanHlMRKxpdTwzs93hDiSzQRQRm4DjgQBuAJ6TdI+kibnIx4ArI+LxiNgOXEEanTOt4TBfjIh1EfEb4MvAX+djPxER90XEtoh4DvgS8LY2Yn4E+EZELMmjpG4iTbGb3lDm2ohYExHrSA2envz8+4EbI2J5RPyW4h1YzY5nZmZm1gl3SdoALAb+i9Tm+iDw/Yj4fkT8PiLuAx4ldTANKCLmRcQLEbE9Iq4GRgFvLJnlWODAiLg0Il6OiBWkduIHGsoszrl2ALcAR+XnpwMjSW2p30XEHcDDBV6z2fHMzNrmDiSzQZY7h86KiCmk4dKTSB1BANOAa/Kw6Q3AOtLIoskNh1jV8PWv8/5ImijpNkmrJW0C5gEHtBFxGjCrL0POMbXvdbJnGr7+LdC38OSkfvkav26l2fHMzMzMOuG0iBgfEdMi4hMRsZXUBprZrw10PPDHzQ6Sp/U/nqfhbwDGUb79NY00zazxdS8GJjaU6d9WGi1pJKnttToiomF7kfZXs+OZmbXN/4mYdVBE/FLSXNJ0MUgX/MsjYn6L3aYCy/PXBwF9Q5GvII1senNErJN0Gu0NR+7LcHkb+z4NTOmXtVFgZmZmVk+rgFsi4sNNtr+iHZPXO7qINOVseUT8XtJ60s2/sq+7MiIOLRuY1PaaLEkNnUhTgf8bKLOZWSd5BJLZIJL0J5JmSZqSv59KmoL2k1zkeuAfJB2Rt4+TNLPfYT4laf+87/nAgvz8fsAWYGOew/+pNmPeAHxM0nFK9pX0Lkn7Fdj3duDvJB0maR/g8/22rwVe12YuMzMzs06aB5wqaYakEZJGS+rta7excztmP2A78BwwUtIXgLFtvO7DwGZJn5b0R/m13yTp2AL7/hjYAZwraWReT/MtDdvXAhMkjWsjl5lZKe5AMhtcm4HjgCWSXiR1HD0GzAKIiDuBLwK35Wloj5EWP2x0N/BT4BekhR7n5OcvIS2svTE/f0c7ASPiUeDDpNFL64EnKLiodUQsAq4Ffpj36+sY25b/nQMcnodn39VOPjMzM7NOiIhVpA8ouZjUKbSKdEOu72+ia4D3KX1S7rXAvcAPSB+S8mvgJYpP32983R3Au0lrQK4Enge+RZoOt6t9XyZ9+MqHgA2kdZy+S257RcQvSQtrr8jtr0lNDmVmttv0yum0ZlYlSQEcGhFPVJ2lCEmHkTrBRuVFwc3MzMysgyQtAa6PiBurzmJmexaPQDKzUiSdLmmUpP1Jo6kWuvPIzMzMrDMkvU3Sa/IUtjOBI0kjo8zMusodSGZW1keBZ0mLN+4APl5tHDMzM7Nh7Y3AUtIUtlnA+yLi6UoTmdkeyVPYzMzMzMzMzMysJY9AMjMzMzMzMzOzltyBZGZmZmZmZmZmLbkDyczMzMzMzMzMWnIHkpmZmZmZmZmZteQOJDMzMzMzMzMza+n/AT+tTUtptx7kAAAAAElFTkSuQmCC\n", + "image/png": "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", "text/plain": [ "
" ] @@ -230,7 +230,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -242,7 +242,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJYAAAIfCAYAAAAi+FZZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAACPu0lEQVR4nOzdeZxcZZX4/8+p6jXd2TdCEgiyrwJG3BABBXHFdcBx3Gdw5ivOODrO6Iy7zk8dl1FHZ5RRx31XFBVFFBRQQHbZMeyELQvZOr3X+f1RFeh0upNOL1XV3Z/361Wvrnruc+89Vakkp899nudGZiJJkiRJkiTtrkKtA5AkSZIkSdLkZGFJkiRJkiRJo2JhSZIkSZIkSaNiYUmSJEmSJEmjYmFJkiRJkiRJo2JhSZIkSZIkSaNiYUmSpGkmIr4SEb+eaucaq4g4PiIyIpbVOpbxEhHvi4hV43Ss3f6zjIjXRkTfeJxfkiTVJwtLkiRNIRHRGhEfjIg/R0RnRKyPiCsi4u9rHZtq4uPAk8fpWP8AvHw39/kusHSczi9JkupQQ60DkCRJ4+p/gBMoFwGuA2YBRwF71TIo1UZmbgG2DLc9IgpAZGb/CI61cRTn7wQ6d3c/SZI0eThiSZKkqeVFwMcy88eZeWdmXpeZX8nMDwzuGBFnRMTdEbEpIs6JiMUDtu0TET+KiPsjYmtEXB8Rrxq0/28j4ssR8ZGIWFs5zlkR0bKzACPi9Ii4NiK6IuKuiPhkRLRVtr02IjZExIxB+7ynMgorhjjeSRHRP3gKW0ScVol9VuX1v0fEzZW2eyPi8xExeydxDjk1LiL6IuK1A14vrkwTWxMRmyPi9xFx3IDtjZX3eF9EdEfEAxHxnZ19RiNROc9ZQ7TfHBEfqjzfbirctteVz+YWoAc4ICLmR8T3I6IjIh6qjHr76sCpb4Onwm17vYvv0Q5T4SLiCRHxy0r/LRHxx4h4UmXbLr93kiSpvlhYkiRpankAOCUi5u2i3xMpj2x6HvBs4HDK06a2aQcuAJ5T2XYW8H8RccKg47wMmA88HXgl5cLWh4c7aaUg8z/AJ4BDgFcDzwI+X+nyXSAZMOWqMqrm9cAXMzOHOOxvKL/vVw5qfw3w48zcVHndCZxROe9rgeOBzwwX60hERCtwITCT8md1FHAucH5EHFzp9mbgL4C/AvYHXghcNpbzVnwVeHlENA+I5xjgIOBrO9lvT+D/Uf58DgHuA/4PeDzwfOBEYBnlP8td2dX3aDsRcShwEfBI5TxHAf/JYznpSL93kiSpTjgVTpKkqeWvgW8BayLiRsoFjHOBnwwqynQDr83MboCI+Dzwlm0bM/N64PoB/f8rIp4F/CXlQso264G/rUylujki3gV8JiLelZkdQ8T3PuCdmfn1yus7IuJM4HcR8feZ+UhEfB34G8qFE4CTKBdD/m+oN5yZpYj4BvAq4KOV97MYOJlywWNbvw8N2O2uiHgn8J2IeF1mloY69gicRnm64WmZuW1kzr9HxDOBN1L+TPcGbgN+V/kzuAe4YpTnG+h7wKcpF6q+X2l7NXBZZt62k/1agFdl5j0AEbE/8ALgWZl5YaXtDMoFv13Z6fdoCO8AVgGvHPCZ/3nbxt343kmSpDrhiCVJkqaQzPw9sC/lEURfBRYDPwDOGTSN7JZtxYCK+yt9AYiIGZUpbjdGeQHwLcBzKRdJBvrjoPV5fg80V2LYTkQsrOz/ycoUqC2V4/6i0mW/ys8vAE8bMOLnb4BzMvPhnbz1rwKHRsTRldevBB4GBk7deklEXFSZZrUF+CbQBOyxk+PuyhMr+28Y9J6eTnl0EpQLYocDqyrT714aEU3DHTAi/nXgsSLi6UP1y8wNwDmUC2pERCNwOjsfrQTw0LaiUsUhlZ+PjqLKzF7gyl0cB3bxPRrCE4DfDFfI243vnSRJqhOOWJIkaYqpjJz5Q+XxiYj4K+DrwHHA7yrdegbvBgwsPH0MOBV4K3Ar0EF5+tqwaxKNwLYLWv/A0KNP7qvEf2NEXAL8TUR8hPKInOfv7MCZeXNEXEl5xM7VlZ/f2Fb0qqzh833K0/TeTnkq1pMpF6SGK/JsK348+rlERJHtL8wVgJuBFw+x/9ZKbNdGxD6UR16dQHmU0Qcj4skDpukN9HnKo5G2WT1MfFAuIp1dKdo9jfJUsl2t3zTUSDIofwd2166+R7trIr53kiRpAllYkiRp6ru58nPRbuxzHPDNzPwePLrO0QHAQ4P6PTEiigNGLT2V8vSo2wcfMDMfioh7gQMz8393cf4vAJ+iPNVuNXD+CGL+KvDuiPga5fWC/mrAtmOBtZn5rm0NEfGyXRxv2wipPYF7K8+PZPvCybZi1qadjaiq3J3tbMpFoP+P8ppQzwB+OkTf9ZTf90icV+l7OuWi1c8y85ER7rvNTZWfT6G8XhUR0UB5dNHOptSNxlXAMyOiMMyopZF+7yRJUp1wKpwkSVNIRPwuIv42IlZGxN6VtX7+G9jA7q1RcytwakQcExGHUF5Eec8h+s0HPhcRB0fE84APAl8YZn0lgH8D/j4i/i0iDouIAyPiRRHxhUH9flD5+W6GX7R7sG8Dc4EvAVdn5g2D3s/CiHhDRDwuIl5NeQHrnVkF3A28LyIOiohjKS80PTCWbwJ3Aj+PiJMjYkVEPCki3hkRLwKIiLdHxCsj4tDKyKXXA/2MQ9GmMjrtW8DfUV5P6qs732PIY/yZcoHrcxHxjMqf9xcorx01mlFMO/MflKcIfrPyHd03Il4eEU+pbB/p906SJNUJC0uSJE0tv6C8vtC5lH9J/z/KiyM/LTPX7sZx/pFyUeVCyqNYVvNYsWegHwCbgUsoT8H6GeUFmodUWbT7LyhPbfsj5UWs38eg6V6Z2UV5+l4B+PJIAs7MdcDPKY8q+tqgbT8D/h34/ygvDn065SlxOzteH+XFuRcB1wCfo1wYKw3o00V55NGVlD/r24AfAcdQ/vwANlGe2nVp5dwvBl6ambeO5H2NwFeBg4GNPLZe1e56HXBDZf/f8tgosa5xiO9RlcW5jwcWUp6WeS3wNsqFNhj5906SJNWJGNkFQEmSpO1FxG+BVZn51xN0/O8BjZk51PpFmkCVtaRuobxo+ttqHY8kSapfrrEkSZLqSkTMpTzi58XAM2sczrQQEcfx2MismZRHDq0AvlK7qCRJ0mRgYUmSJNWbayiv3fQfmXlRrYOZJorAu4D9gF7K0+JOqExdkyRJGpZT4SRJkiRJkjQqLt4tSZIkSZKkUbGwJEmSJEmSpFGxsCRJkiRJkqRRsbAkSZIkSZKkUbGwJEmSJEmSpFGxsCRJkiRJkqRRsbAkSZIkSZKkUbGwJEmSJEmSpFGxsCRJkiRJkqRRsbAkSZIkSZKkUbGwJEmSJEmSpFGxsCRJkiRJkqRRsbAkSZIkSZKkUbGwJEmSJEmSpFGxsCRJkiRJkqRRsbAkSZIkSZKkUbGwJEmSJEmSpFGxsCRJkiRJkqRRsbAkSZIkSZKkUbGwJEmSJEmSpFGxsCRJkiRJkqRRsbAkSZIkSZKkUbGwJEmSJEmSpFGxsCRJkiRJkqRRsbAkSZIkSZKkUbGwJEmSJEmSpFGxsCRJkiRJkqRRsbAkSZIkSZKkUbGwJEmSJEmSpFGxsCRJkiRJkqRRsbAkSZIkSZKkUbGwJEmSJEmSpFGxsCRJkiRJkqRRsbAkSZIkSZKkUbGwJEmSJEmSpFGxsCRJkiRJkqRRsbAkSZIkSZKkUbGwJEmSJEmSpFGxsCRJkiRJkqRRsbAkSZIkSZKkUbGwJEmSJEmSpFGxsCRJ0jQXEadExK0RsSoi3jHE9uaI+G5l++URsaLSflJEXBUR11d+njhgn1dU2v8UEb+MiAVVfEuSJEl1b6rkYJGZE32OmliwYEGuWLGi1mFIkqaAq666am1mLpzo8zz7xMW5bn3PuB/3qus2nJeZpwy1LSKKwG3AScB9wBXAKzLzpgF9/h9wRGb+bUScDrw4M0+LiKOAhzLz/og4DDgvM5dGRANwP3BIZq6NiP8Atmbm+8b9zWlUImI58DVgMZDAWZn56SH6HQ98CmgE1mbmM3Z2XPMvSdJ4qkYOVov8C6ZWDtYwkQevpRUrVnDllVfWOgxJ0hQQEXdX4zzr1vfwx1+fMO7HLS48e2dXqo4BVmXmHQAR8R3gVOCmAX1OBd5Xef4D4LMREZl5zYA+NwKtEdEMlIAA2iJiHTALWDUe70Xjpg94W2ZeHREzgasi4vxByewc4L+BUzLznohYtKuDmn9JksZTNXKwGuVfMIVysClbWJIkabJJkhKliTj0gogY+Nv+WZl5VuX5UuDeAdvuA540aP9H+2RmX0RsBOYDawf0eSlwdWZ2A0TE3wHXAx3An4E3jdN70TjIzAeAByrPN0fEzZT/nAcms38J/Cgz76n0e7jqgUqSNMFqlH/BFMrBLCxJklRHJiixWZuZKyfiwAARcSjwUeDkyutG4O+Ao4A7gP8C3gl8aKJi0OhV1ms4Crh80KYDgMaI+C0wE/h0Zn5tiP3PAM4A2GuvvSY0VkmSJsJkzL+gfnIwF++WJGl6Ww0sH/B6WaVtyD6VufuzgXWV18uAs4FXZ+btlf5HAmTm7VlezPF7wFMnKH6NQUS0Az8E3pKZmwZtbgCeADwPeDbw7og4YPAxMvOszFyZmSsXLpzwpcgkSZoqpkwOZmFJkqQ6UpqAxy5cAewfEftERBNwOnDOoD7nAK+pPH8ZcEFmZmUNnp8D78jM3w/ovxo4JCK2VRlOAm4eyftX9VSuav4Q+GZm/miILvdRXgy0IzPXAhcBj69mjJIkVUMN8i+YQjmYhSVJkqaxzOwDzgTOo5x4fC8zb4yID0TECyvdvgTMj4hVwFuBbbfDPRPYD3hPRFxbeSzKzPuB9wMXRcSfKF89+/+q9660KxERlP9cb87MTw7T7SfAsRHREBEzKK/7YIFQkqRxMJVyMNdYkiSpTiSQEzPHf+fnzTwXOHdQ23sGPO8CXj7Efh9imDn7mfl54PPjG6nG0dOAVwHXR8S1lbZ/BfaC8p9fZt4cEb8E/kT54usXM/OGWgQrSdJEqVX+BVMnB7OwJElS3Uj6M2sdhKaBzLyE8u2Id9XvY8DHJj4iSZJqxfxrrJwKJ0mSJEmSpFFxxJIkSXUk8YqZJElSNZl/jY0jliRJkiRJkjQqjliSJKlOJNBf6yAkSZKmEfOvsXPEkiRJkiRJkkbFEUuSJNUR5/hLkiRVl/nX2FhYkiSpTiR4u1tJkqQqMv8aO6fCSZIkSZIkaVQcsSRJUh3xepkkSVJ1mX+NjSOWJEmSJEmSNCqOWJIkqU6Ub3frNTNJkqRqMf8aOwtLkiTVi4SSeY0kSVL1mH+NmVPhJEmSJEmSNCqOWJIkqU4kUKp1EJIkSdOI+dfYOWJJkiRJkiRJo+KIJUmS6kiJqHUIkiRJ04r519hYWJIkqY64eKQkSVJ1mX+NjVPhJEmSJEmSNCqOWJIkqU6UF490KLYkSVK1mH+NnSOWJEmSJEmSNCqOWJIkqY54xUySJKm6zL/GxsKSJEl1ojwUW5IkSdVi/jV2ToWTJEmSJEnSqDhiSZI0aj39/Vz/wIP0l5IjluxBS+P4/bfyQOcG7ulYx+KWWaxoXzhux613DsWWJNWDNd0Psb57DfObF7GgeVGtw5EmlPnX2FhYkiSNyjWrH+A95/2art5+IqCxUOBdzzqep6zYa0zH7Sv18+lbfsVvH7qFYhTozxKHzVnGuw5/IW0NzeMUvSRJGkpPqYfv3/sVVm2+hUIUKGU/B806gpcuexUNBX99lLQjp8JJknbb5u5u/vUXv6K3v5/25kbamhopkbz3VxewrmPrmI79k3uv5jcP3kRbQzMzGppob2jmT4/cyxduu3Ccoq9fSdBPYdwfkiSN1AUP/Zw/b76JlmIrzcUWWoozuGnTdfxuzXm1Dk2aEOZfYze93q0kaVxcete99PaXaG1sfLStpaGBvv4SF99515iO/bPV19JabKQQ5SHJEUF7YzO/fegWekt9Yzq2JEkaXmZy1SOX0lxsJQb8P9xcaOGK9b+vcXSS6pVjGSVJu62zr5dS5g7t/Vlia2/vmI69tb+HQmx/3aNA0J8l+rJE4zD7TRWZzvGXJNVGkvSUephRbNuuvRAFekrdNYpKmnjmX2PjiCVJ0m47aukSAugvPXZz1lImDYUCRy/dc0zHfsqC/dja17Nd25a+bg6YtQetxaYxHXsy6J+AhyRJI1GIAvu1H0Rn//bT2rv6t3LAzENrFJU08cy/xsbCkiRpt+01Zw5/8fjD6ejpZWNnNxu7utjS3cPzDj6QAxcuGNOx/2qfpzKvuY1NvZ1s7u1iU08nzcVG3nTgM8cpekmSNJxTlryYlmIrnX0ddPZvpbOvgxnFNk7e44W1Dk1SnXIqnCRpVM548kqetPcyfn3b7fRniRP3exwrly19dE2G0VrQMpP/OeY1/PrBG7ll44Ps3Tafk/c8jPnN7eMUef1KoJRe85Ek1c7C5sWcuf87ueaRy3mwazV7ti7nyDnH0NYw9f8f1vRk/jV2FpYkSaMSERy55xKO3HPJuB+7vbGFFy1/Aiwf90NLkqRdaG+YydMXPqvWYUiaJCwsSZJUN4KSs9QlSZKqyPxrrCwsSZJUJxIo7bKXJEmSxov519hZlpMkSZIkSdKoVGXEUkS0ABcBzZVz/iAz3zuoz38CJ1RezgAWZeacyrZ+4PrKtnsy01sSSJKmpH4Xj5QkSaoq86+xqdZUuG7gxMzcEhGNwCUR8YvMvGxbh8z8x23PI+LNwFED9u/MzCOrFKskSZIkSZJGoCqFpcxMYEvlZWPlkTvZ5RXAe3eyXZKkKShIotZBSJIkTSPmX2NVtcW7I6IIXAXsB3wuMy8fpt/ewD7ABQOaWyLiSqAP+Ehm/niYfc8AzgDYa6+9xi94SZKqIIF+ExtJkqSqMf8au6pNJMzM/sp0tmXAMRFx2DBdT6e8BlP/gLa9M3Ml8JfApyJi32HOcVZmrszMlQsXLhzP8CVJmrIi4pSIuDUiVkXEO4bY3hwR361svzwiVlTaT4qIqyLi+srPEwfs0xQRZ0XEbRFxS0S8tIpvSZIkqe5NlRysaiOWtsnMDRFxIXAKcMMQXU4H3jRon9WVn3dExG8pr790+wSHKklSdSWUqrx4ZGVE8eeAk4D7gCsi4pzMvGlAtzcAj2TmfhFxOvBR4DRgLfCCzLy/csHoPGBpZZ9/Ax7OzAMiogDMq9JbkiRJGrka5F8wtXKwqnx6EbEwIuZUnrdS/uBuGaLfQcBc4NIBbXMjornyfAHwNOCmwftKkqRROQZYlZl3ZGYP8B3g1EF9TgW+Wnn+A+CZERGZeU1m3l9pvxFo3fZ/NvB64MMAmVnKzLUT+i4kSZImlymTg1WrLLcEuDAi/gRcAZyfmT+LiA9ExAsH9Dsd+E5lse9tDgaujIjrgAspr7FkYUmSNOUkQYnCuD+ABRFx5YDHGQNOuxS4d8Dr+3jsitcOfTKzD9gIzB/U56XA1ZnZve1iEvDBiLg6Ir4fEYvH51OSJEkaPzXKv2AK5WDVuivcnyhPXxvc/p5Br983RJ8/AIdPWHCSJE19aytrFU6IiDiU8tDskytNDZTXVPxDZr41It4KfBx41UTFIEmSVGcmNP+C+snBqj+RUJIkDas0AY9dWA0sH/B6WaVtyD4R0QDMBtZVXi8DzgZenZnb1j9cB2wFflR5/X3g6F2HIkmSVH01yL9gCuVgFpYkSaoTCRM1FHtnrgD2j4h9IqKJ8rT0cwb1OQd4TeX5y4ALMjMrw61/DrwjM3//6PsoT2n/KXB8pemZuD6iJEmqQzXKv2AK5WAWliRJmsYq8/XPpHw3kZuB72XmjYPWQfwSMD8iVgFvBbbdDvdMYD/gPRFxbeWxqLLtX4D3VdZXfBXwtiq9JUmSpLo3lXKwqqyxJEmSRqYWt7vNzHOBcwe1vWfA8y7g5UPs9yHgQ8Mc827guPGNVJIkafzVIv+CqZODOWJJkiRJkiRJo+KIJUmS6kZQImodhCRJ0jRi/jVWFpYkSaoTCfSniY0kSVK1mH+NnVPhJEmSJEmSNCqOWJIkqY6k13wkSZKqyvxrbPz0JEmSJEmSNCqOWJIkqU44x1+SJKm6zL/GzsKSJEl1I0jvSiJJklRF5l9j5VQ4SZIkSZIkjYojliRJqhPlodhe89HEi4jlwNeAxZS/emdl5qeH6ftE4FLg9Mz8QfWilCRp4pl/jZ2FJUmSpOmnD3hbZl4dETOBqyLi/My8aWCniCgCHwV+VYsgJUlS/bOwJElSHSk5x19VkJkPAA9Unm+OiJuBpcBNg7q+Gfgh8MTqRihJUvWYf42N470kSZKmsYhYARwFXD6ofSnwYuB/drH/GRFxZURcuWbNmgmLU5Ik1SdHLEmSVEe8YqZqioh2yiOS3pKZmwZt/hTwL5lZihj+e5mZZwFnAaxcuTInKFRJkiaM+dfYWFiSJKlOJEHJwcSqkohopFxU+mZm/miILiuB71SKSguA50ZEX2b+uHpRSpI0scy/xs7CkiRJ0jQT5WrRl4CbM/OTQ/XJzH0G9P8K8DOLSpIkaTALS5Ik1YuEUjoUW1XxNOBVwPURcW2l7V+BvQAy8/M1ikuSpOoy/xozC0uSJEnTTGZeAiNfUCIzXztx0UiSpMnMwpIkSXUicfFISZKkajL/GjsLS5Ik1Y2glC4eKUmSVD3mX2PlpydJkiRJkqRRccSSJEl1ojwUW5IkSdVi/jV2jliSJEmSJEnSqDhiSZKkOuIcf0mSpOoy/xobC0uSJNURExtJkqTqMv8aGz89SZIkSZIkjYojliRJqhMuHilJklRd5l9j54glSZIkSZIkjYojliRJqhtByWs+kiRJVWT+NVZ+epIkSZIkSRoVRyxJklQnEihl1DoMSZKkacP8a+wsLEmSVEdKmNhIkiRVk/nX2DgVTpIkSZIkSaPiiCVJkupFOhRbkiSpqsy/xswRS5IkSZIkSRoVRyxJklQnkiC95iNJklQ15l9jZ2FJkqQ60u9QbEmSpKoy/xoby3KSJEmSJEkaFUcsSZJURzJrHYEkSdL0Yv41No5YkiRJkiRJ0qhYWJIkqU4kUKIw7o9diYhTIuLWiFgVEe8YYntzRHy3sv3yiFhRaT8pIq6KiOsrP08cYt9zIuKGcfh4JEmSxl2t8i+YOjmYU+EkSaobQYnqLh4ZEUXgc8BJwH3AFRFxTmbeNKDbG4BHMnO/iDgd+ChwGrAWeEFm3h8RhwHnAUsHHPslwJYqvRVJ4ywz6em7lZ7emykWFtDa/CQimka0b3fvHXT2Xk8xZtHW8hQK0TKi/Ur9qyn1XENEC4WmpxCFtrG8hWmvr1TiqrX38HDXZvaduYCD5+xBhIsUa3i9ff1cc9O9bNjcyQF7L2LFsvm1DqkKqp9/wdTKwSwsSZI0vR0DrMrMOwAi4jvAqcDApOZU4H2V5z8APhsRkZnXDOhzI9AaEc2Z2R0R7cBbgTOA703we5A0zjL7WLPhXWztuogkiShSLMxjj3n/TWPDsp3sV+KhTR9n49afkAlBgUKhjeXzP0NL4wE7PWdvx5fp7/gakCQFIppomv1RCk1Hju+bmyYe7tzMW/94Ng93bqaUSQBHL1jOB49+Hk1Ffw3UjlY/tIH3fubnbN7SRX8mBYKnHv043vzqZ1AsONlpAkyZHMxvhyRJdSKBUsa4P4AFEXHlgMcZA067FLh3wOv7GHDFa3CfzOwDNgKDL2G+FLg6M7srrz8IfALYOh6fjaTq2rz1J3R0/ZaImRQLsylEO339a1iz4b073W9L10Vs7PgJBWbSUJhNsTCTUqmD1evfSWZp2P1KPX+iv+NrZLRBYTZRmElSomfjv5LZM95vb1r4+PUX8MDWjbQ3NjOrqYX2xmauWHMP37/r2lqHpjqUmXziy79h4+ZO2mY0M6uthbYZTVxy1Sp+98c/1zq8CVWj/AumUA5WlcJSRLRExB8j4rqIuDEi3j9En9dGxJqIuLby+OsB214TEX+uPF5TjZglSZpC1mbmygGPs8bz4BFxKOWh2W+svD4S2Dczzx7P80iqns2dPyZo2m7aVCFm0dN7M339a4fdb2Pnz4ACEYUB+7XTV3qY7r7bh92vv/t8khLlmSFlEa2QXZR6rxvbm5mGOvp6uGrdvcxsfGwKYkTQ0tDAuffeWMPIVK8eWreZ+x7cQPuM5kfbIoKGYpHf/OHWGkY2qU1o/gX1k4NVawxkN3BiZm6JiEbgkoj4RWZeNqjfdzPzzIENETEPeC+wknIx8arKvMNHqhK5JElVlFn1Of6rgeUDXi+rtA3V576IaABmA+sAImIZcDbw6szc9lvjU4CVEXEX5VxjUUT8NjOPn6g3IWmcZT8MsRZP+Y7cfcPvljtuiwjIgCG2PbZj7zAbohyLdktmArnDqjFB0FcafuSYpq9SKYdsjwj6+qf+d6YG+RdMoRysKiOWsmzbwlGNlcfQ39wdPRs4PzPXV4pJ5wOnTECYkiRNR1cA+0fEPlFelfd04JxBfc4Bto0YfhlwQWZmRMwBfg68IzN/v61zZv5PZu6ZmSuAY4HbLCpJk0t763PI7K4UKMoyt9DUsIJiYfGw+81qfTZJ/3b7lUpbKRZm0ryTNZYKzScQFLabLpfZDVGk0PT4Mb6b6ae9sZlD5yxhc2/3o22ZSWdfLyctPaiGkaleLVk4i4Vz29na9ViRNzPp7evj+GP2r2FkU9qUycGqtsZSRBQj4lrgYcqFosuH6PbSiPhTRPwgIrZV7kYy73DbOc7YNn9xzZo14xm+JElVUarcmWQ8HztTma9/JuW7idwMfC8zb4yID0TECyvdvgTMj4hVlBeD3HY73DOB/YD3DJjKvmgiPhdJ1TWz7WW0NB5B5mb6S+vpL20iCq0smPO+nd5VbFbrSbS3HEspN9NXWk9faQNEsOecD203zW2wQtMTKbY8B3ILWVoPpQ1E9tIw813lKXHabf90+DOZ1djCpp4uHuneypbebvabtYDTH3d0rUNTHYoI/vF1J9LUWGTTli42bOqko7OHww7Yk2c+9cBahzfhqp1/wdTKwWLg1YSqnLBcWTsbeHNm3jCgfT6wpbKK+RuB0zLzxIj4J6AlMz9U6fduoDMzP76z86xcuTKvvPLKCXsfkqTpIyKuysyVE32ePQ/dM9/4vTeO+3Hfd9j7qhK/ZP41tWT209l9Od2911MsLKat9USKhVkj2K/E1p5r2NpzNcWYy6zWE2kozhvBfkn23UR/9+UQbTS0HE8Uhx8dpV3r6Ovh4gdXcf/WTRw4exHHLNybxsLwBT5p05YuLr3mDtZv3MpBj9uDxx+0lEKhJtPEgOrkYOZfY1f1+0xm5oaIuJDydLYbBrSvG9Dti8B/VJ6vBo4fsG0Z8NuJjVKSJEma3iKKzGh5KjNanrqb+xVoa34Cbc1P2M39gmg8lELjobu1n4bX1tDEKcsOqXUYmkRmtbfw7Kf7ndHuqdZd4RZWRioR5bGsJwG3DOqzZMDLF1IeCgblYWEnR8TciJgLnFxpkyRpihn/W92WarMYpSRJ0iRh/jVW1RqxtAT4apQnVhcozx38WUR8ALgyM88B/r4yj7APWA+8FiAz10fEBykvbAXwgcxcX6W4JUmSJEmSNIyqFJYy80/AUUO0v2fA83cC7xxm/y8DX56wACVJqhM73hxakiRJE8n8a2yqvsaSJEkaWsKI7iIiSZKk8WH+NXZVWWNJkiRJkiRJU48jliRJqiPTbbFHSZKkWjP/GhtHLEmSJEmSJGlUHLEkSVIdSa+YSZIkVZX519hYWJIkqU4k4VBsSZKkKjL/GjunwkmSJEmSJGlUHLEkSVIdSW93K0mSVFXmX2PjiCVJkiRJkiSNiiOWJEmqF+ntbiVJkqrK/GvMHLEkSZIkSZKkUXHEkiRJdSKBUq2DkCRJmkbMv8bOwpIkSXUkHYotSZJUVeZfY+NUOEmSJEmSJI2KI5YkSaojLh4pSZJUXeZfY+OIJUmSJEmSJI2KI5YkSaobQeIVM0mSpOox/xorC0uSJNWJxKHYkiRJ1WT+NXZOhZMkSZIkSdKoOGJJkqQ6UspaRyBJkjS9mH+NjSOWJEmSJEmSNCqOWJIkqY64eKQk1b+e/vWs7fwDpexmbssTaGtcUeuQNEWt27qV3995D919fTxx+VJWzJtb65CmJPOvsbGwJElSnch08UhVR0QsB74GLKa8bulZmfnpQX1eCfwLEMBm4O8y87pqxyrVm7VbL+XmdR8i6SOzRESR5TNfzorZryfCf8M1fn5/5928//wL6SuVKGWJYhQ47cjD+ZsnrfS7No7Mv8bOqXCSJEnTTx/wtsw8BHgy8KaIOGRQnzuBZ2Tm4cAHgbOqHKNUd/pKHdyy/t+JKNJYmEVTcQ4NMYN7N3+fzT031zo8TSEdPT188Ne/paEQzG5pZm5rK21NjXz32uu56aGHax2etB0LS5Ik1ZHMGPeHNFhmPpCZV1eebwZuBpYO6vOHzHyk8vIyYFl1o5Tqz4bu68gsUYzmR9siimSWWLP1t7ULTFPONasfoL+UNDc8NsmoWChQyuSCVXfWMLKpyfxrbCwsSZIkTWMRsQI4Crh8J93eAPximP3PiIgrI+LKNWvWTECEUv2YXr8qqpac6abJxDWWJEmqG+HikaqqiGgHfgi8JTM3DdPnBMqFpWOH2p6ZZ1GZJrdy5Upv2KwpbXbzkUQU6c/uR0ctZfYTUWDhjONrG5ymlKP23JOGQtDd1/foqKX+UolCBCfut0+No5tqzL/GyhFLkiRJ01BENFIuKn0zM380TJ8jgC8Cp2bmumrGJ9WjhsIMDpr3r0A/vaVN9PRvoC+3snzmXzCz6eBah6cpZEZTI+8+6QT6S8mmrm42dHbR0dPLK446gkMWL6p1eNJ2HLEkSVKdSKDkeA9VQZRvJ/Ql4ObM/OQwffYCfgS8KjNvq2Z8Uj1bMOMpHNP8DdZ1XkYpu5jTcjRtjXvXOixNQU9dsRff/qvTuPTue+jq7WPl8qXsPXdOrcOacsy/xs7CkiRJdWS6Lfaomnka8Crg+oi4ttL2r8BeAJn5eeA9wHzgvyu3te7LzJXVD1WqP03FuSxpf06tw9A0MG9GK887+MBahzHlmX+NjYUlSZKkaSYzL2EX6xBn5l8Df12diCRJ0mRlYUmSpDri4pGSJEnVZf41Ni7eLUmSJEmSpFFxxJIkSXXEOf6SJEnVZf41NhaWJEmqE5lQMrGRJEmqGvOvsXMqnDSF9JZ66ezfSubkuV9mKXvoLW2eVDFLkiRJksocsSRNAT2lbn7xwNlct+EKStnPouYlPH/pX7DXjH1qHdqwStnDXRu/zANbfkpmLy0Ne7DvnDczt/WJtQ5Nqq0a1Fgj4hTg00AR+GJmfmTQ9mbga8ATgHXAaZl5V0ScBHwEaAJ6gLdn5gURMQP4PrAv0A/8NDPfUbU3JEmStDtqdI17quRgjliSpoAf3Ps1rnnkMpoKzbQW21jb8zBfu/O/Wde9ptahDev2Rz7L6s0/JGikGDPp7lvLTWvfzeaeW2sdmjStREQR+BzwHOAQ4BURccigbm8AHsnM/YD/BD5aaV8LvCAzDwdeA3x9wD4fz8yDgKOAp0XEcybwbUiSJE0qUykHs7AkTXLre9by58030VpsoxAFIoKWYit92ccV6y+pdXhD6u3fxEMd59EQ7RSigYigWJhBUuK+Td+vdXhSTZUm4LELxwCrMvOOzOwBvgOcOqjPqcBXK89/ADwzIiIzr8nM+yvtNwKtEdGcmVsz80KAyjGvBpbt1gchSZJUJTXIv2AK5WAWlqRJbmPPIxQrxZmBClFgbfdDNYpq53pK6wgKlIv0jwma6Oy7p0ZRSfUgyBz/B7AgIq4c8DhjwEmXAvcOeH1fpY2h+mRmH7ARmD+oz0uBqzOze7t3FDEHeAHwmzF+OJIkSROgJvkXTKEczDWWpEluQfNiSvRTyhKFeKxWXMoSy2c8roaRDa+luAcRBUrZRyEe+2co6WZW06E1jEyastZm5sqJOnhEHEp5aPbJg9obgG8Dn8nMOybq/JIkSXVoQvMvqJ8czBFL0iQ3s3EWT5x7LF39W+kpddNX6mNr3xbaGtpZOe8ptQ5vSMVCK8tnvYpSdtBf2kope+nr30QxZrB01strHZ5UU0mM+2MXVgPLB7xeVmkbsk8lUZlNeQFJImIZcDbw6sy8fdB+ZwF/zsxPjeazkCRJqoYa5F8whXIwRyxJU8Czl7yIhS2LuXTd7+js6+CQuU/ihIWn0NYws9ahDWvZzNNoLi7kvs3fpad/HXNnHMfes19Da8OetQ5Nmm6uAPaPiH0oJy+nA385qM85lBeGvBR4GXBBZmZliPXPgXdk5u8H7hARH6Kc/Pz1xIYvSZI0KU2ZHMzCkjQFFKLAynlPY+W8p9U6lBGLCBa1PZNFbc+sdShS3Uggq3y728zsi4gzgfMo3+r2y5l5Y0R8ALgyM88BvgR8PSJWAespJz4AZwL7Ae+JiPdU2k6mfOvbfwNuAa6urAH32cz8YrXelyRJ0kjUIv+CqZWDWViSJGmay8xzgXMHtb1nwPMuYId5qpn5IeBDwxx2RGPAJUmSpqupkoNZWJIkqY5U7iIiSZKkKjH/GhsLS5Ik1Ys0sZEkSaoq868x865wkiRJkiRJGpWqjFiKiBbgIqC5cs4fZOZ7B/V5K+VVy/uANcDrM/PuyrZ+4PpK13sy84XViFuSpGqrxeKRkiRJ05n519hUaypcN3BiZm6JiEbgkoj4RWZeNqDPNcDKzNwaEX8H/AdwWmVbZ2YeWaVYJUmSJEmSNAJVmQqXZVsqLxsrjxzU58LM3Fp5eRmwrBqxSZJUT3ICHpIkSRqe+dfYVG2NpYgoRsS1wMPA+Zl5+U66vwH4xYDXLRFxZURcFhEv2sk5zqj0u3LNmjXjErckSdWSlBePHO+HJEmShmb+NXZVKyxlZn9lOtsy4JiIOGyofhHxV8BK4GMDmvfOzJXAXwKfioh9hznHWZm5MjNXLly4cHzfgCRJkiRJkrZTrTWWHpWZGyLiQuAU4IaB2yLiWcC/Ac/IzO4B+6yu/LwjIn4LHAXcXrWgJUmqiul3hUuSJKm2zL/Gqlp3hVsI9FaKSq3AScBHB/U5CvgCcEpmPjygfS6wNTO7I2IB8DTKC3tLkiRJEl29t7Kl6/cEDcxsfQZNDXtP6Pk6eh/k/q2X0p/dLG49mjlN+xOx619Mu/vXsrbjd/TlJmY3H8Xs5iOImLhJJFv7Orluww2s7VnPXjOWceisA2koVH1sgaQprlr/qiwBvhoRRcrT776XmT+LiA8AV2bmOZSnvrUD36/8o3xPZr4QOBj4QkSUKvt+JDNvqlLckiRV1XRb7FGSxurhTf/DI1u+QdIPBGu3nMXiWW9jTtuLJ+R89225iGvWfYZS9pMkt234PnvPPIkj5r1xp8WlR7qu5Ka17yGzl8wSEd9hfutTOWj+uyj/mjS+Hup6mE/fdhZb+zvpzxLFKLCkdTFv3u9vmNHQOu7nkyYz86+xqUphKTP/RHn62uD29wx4/qxh9v0DcPjERSdJUh1xKLYkjVhXzy08suUbFKL90eJMZi8Pbfok7S1Pp6G4YFzP11vawjXrPkshmmgsNFbOV+LuzeeztO1YFrQMuYwspezhlrX/DlmgoTC7sl+yrvP3rO28hIUznjGucQJ8654fsbW/kxkNMx493+rOB/jNQxfxgqXPHvfzSZOa+deYVG3xbkmSJEkaT5u7LyHp327ET0QjmSU6uv847udb23UDUKIYjQPOVyApcX/HpcPut6Xnz5Syi2KhZcB+AQRrOi4Y9zi39nVyV8c9tBYfG5kUETQXmrnykWvH/XySpjcn2ErTUGaJ7L2OUv9qCsVlROPO5/c/0nM/D3WuornYxvIZh9NQaKpitGWZyU0bHuSuLetZ3DqTo+cvpzCCtQxqbUvPKrb0/JnG4lzmtjyBwoBEVJIkjU2BRmDHfCCiQMT4/6oTNAx5Psid/h8fDD3VLXex32gVKkWroc5XnMA1nSRNTxaWpGkmS5vo2fBWsu92oAQE0XgQTbM/ThTat++bJS5Z8w1u3vhboJykNRVm8Pyl/8T85r2qFnNXfy/vuupnXLduNSXKydLSGbP55JNezLzmtqrFsTtK2cct6z7Cus5LSEoERZqK8zhi0cdobdiz1uFJkjQlzGw9nrVb/pfMXqJSoCllN0GRtuYnj/v5FrQcRiEa6St10VAZfVTKfoIiy9qOHXa/9qYDaCzOpqd/Iw2Fcu6S2U8Ai9pOHvc4W4otHDRzP27Z/GfaGradL+kp9fCU+U8c9/NJmt4sV0vTTN+W/yH7biWjHQqzyZhJ9t5EX8cXd+h7V8c13LTxQpoKM2guttNUmEF3fwe/euCzZJaqFvN37riKq9feR3tjM7ObWpjZ2My9HY/w6Rt/V7UYdteDW37J2s6LKEY7jYXZNBTa6e5byy3rPlLr0FTPEjJj3B+SNFU1NezNollvpUQXfaVN9Jc2A/0smfMhioVZ436+hkILxyx8B0HQU+qgp7SFvlInB895JXOa9xt2v4gCBy/4AA2FFvpLW+grbaY/O9hz5kuY2zIxhZ5X7PUSFjTPp7O/k46+rXT2d3HIrAM4YdHwBTBpWjL/GjNHLEnTSGbS33UeGbMevWtJRJC00d/1CxpnvmW7/rdsuoigsN00uabCDLb0rWN9z31VG7X083tvorWhcbs7rcxsbOH3D91BT38fTcX6+6fswY6fU2D7mBsKM9nccyvd/etoLs6vYXSqVwmktyWRpN0yt+0lzGw5jo7uy4lopK35yRNSVNpmYesRnLz8SzzceQ392c2CliOY0bBwl/vNbDqAJy75No90XUFfaQuzmw+ntXHZhMU5p2k2/3bwP3Lr5lVs6NnInq1L2GvG0p3euU6ajsy/xq7+fhuTNMHK09+2F5D9O/Tsz35iUN+IgAxKQ/SfKH2l0pBJUImkVKc3By3Rx9BrMARZxc9OkqTpoKG4gNkznle18zUW2li6k6lvwykWWlgw4+kTENHQClHg4FkHVO18kqYnp8JJ00hEUGh+OuSm7dtLWyg0H79D//3bn0KJfnJACb+31EVzoa2qayw9c88D6Ojt2S6Ozb3dHDV/GS3F+lwMe9GMZ9LP9jH3ZwczGpfRXNz1VU1NX5nj/5AkSdLwzL/GxsKSNM00tr+ZKCwiS5vI0iNkaRMU96Cx/W936LvfrCexV9sR9JQ66OzbSFf/ZgJ41h5/SyGGvrvJRHj1fsewd/tcNvd280j3Vjb1dDGnqZV/PPSEqsWwu5a2n8qspoPpyy309D9Cb2kThWjmoHn/4hB0aQgRcUhELK48b4+I90fEeyNiRq1jkyRJmqrGIwdzKpw0zURxEc3zv06p+2JKfXdRaNiHQvNxRDTv0LcYDZyy5B9Y3Xkz92+9hdbiTB438xjaGuZUNeZZTS2cdewr+MNDd3D7prXsOWM2xy3Zj7aGpqrGsTuKhVYev+gTPNJ1JZu6b6a5uICFM55BY3Hi1nzQFDHNFnsc4NvAXwAPAR8HDgS6gC8Ar6phXJIkaaqbvvkXjEMOZmFJmoYiWim2nMxIxhxFFFg241CWzTh0wuPamaZCkeOX7M/xS/avaRy7oxANzG99MvNbx/92x9IUtCIzb43ykL6XAIcAncCdtQ1LkiRpShtzDmZhSZKkOjLNpuQP1BURMyknM/dk5tqIaABaahyXJEma4qZx/gXjkINZWJIkqZ5M38zmW8AFwEzgs5W2o3HEkiRJmmjTN/+CccjBLCxJkqSay8x/jIiTgd7MvLDSXAL+sYZhSZIkTWnjkYNZWJIkqV4k03rxyMz8VUQsj4gnZ+ZlmXllrWOSJElT3DTPv2DsOVhhogKTJEkaqYjYKyJ+D9wC/LrS9rKI+GJtI5MkSZq6xiMHs7AkSVI9yQl4TA5fAH5OeX5/b6XtfOCkmkUkSZKmh+mbf8E45GBOhZMkqW4EOX2HYh8DPC8zSxGRAJm5MSJm1zguSZI0pU3r/AvGIQcbcWGpspjTkUD7wPbMfM9IjyFJkjSMh4D9gNu2NUTEIcA9NYtIkiRp6htzDjaiqXAR8VngG8ATgOUDHst2I1hJkqThfBz4WUS8DmiIiFcA3wU+WtuwJEmSprQx52AjHbH0l8DjM/Pe3Y9RkiRp5zLzyxGxDngjcC/wGuDdmfnjmgYmSZI0hY1HDjbSwtJaYMPuBihJknbX9J3jn5k/AX5S6zgmg4jYB/h3hl6mYK9axCRJ0uQ1ffMvGHsONmxhKSIeN+DlJ4BvRsSHKc+/GxjAHaM9uSRJGmRy3UVk3ETE64fblplfrmYsk8S3gNuBtwFbaxyLJEmT2zTNv2B8crCdjVhaRfnjHVi6e/7g8wDFkZxIkiRpJ1416PUewL7A7wELSzs6FHhaZpZqHYgkSZrUxpyDDVtYyswRLewtSZLG0TS9YpaZJwxuq1xBO7gG4UwGFwFHAVfVOhBJkia9aZp/wfjkYCNaYykiPpOZfz9E+6cy8y0jPZkkVUNf31oe3PA+tnRfQiFamdv+l8xvfxOFgvVyaZL5CuV1Ht9e4zjqQkR8YMDLu4BfRsTZwIMD+2Xme6oZlyRJmnK+wm7kYCNdvPu1wA6FJcpDpt4ywmNI0oTrK23kzw+dSH9pI+WZvBt4aOPH2dp1BXsv+lqtw5N2Lpm2V8wiYnDldwbwV3jzkIGWD3r9M6BxiHZJkjRS0zj/gvHJwXZaWBqwiFPDEAs6PY5yBUuS6sbajZ+pFJUaKER5ibhSJpu7L6Kr5zZamg6obYCShtPHjmndauBvahBLXcrM19U6BkmSNOWMOQfb1YilbYs4NbH9gk5J+e5wrxnpiSSpGjq6LwF4tKi07XkpYUvX+RaWVPdy+l4x22fQ647M9ALWMCJifWbOG6L94cxcVIuYJEmarKZx/gXjkIPtdMGRzDyhspDTR7Y9rzxOzMxXZOZluxuxJE2khsLiHdpKlf8pGop7VjscaVKIiFMi4taIWBUR7xhie3NEfLey/fKIWFFpPykiroqI6ys/TxywzxMq7asi4jMREYOPO1Bm3j3oYVFp5xoHN0REI96tV5KkSWOq5GDDjlgaNM/uPUPMu9sWhLe5lVQ3Fsw6k81rLqaU/RSiWCkq9VEszGRW6wtqHZ5UdyKiCHwOOAm4D7giIs7JzJsGdHsD8Ehm7hcRpwMfBU6jPCX+BZl5f0QcBpwHLK3s8z+Uh1BfDpwLnAL8YtC5L2YEqxpk5nFjeItTyoDPrCUiLhq0eRnwh+pHJUmSdtdUysF2NhVuqHl2Q/HKmKS60dZyDHvOeTcPbPwwpewFoLGwgL0WfpVCYaT3K5BqKHd6UWkiHAOsysw7ACLiO8CpwMCk5lTgfZXnPwA+GxGRmdcM6HMj0BoRzcA8YNa2kc0R8TXgRQxKaoAvju9bmRa+SPnOBE8EvjSgfdsyBRfUIihVx5aubi64+Q7uWLOO/RbN54SD96WtuWmX+3X19/CHtTdxx5YH2LNlPscuOoxZjTN2uV9fqYc7O67mga23MrNxPgfMehptDXNHsF+JPzx4N3986B7mtczg2XsdwNK22SN6j1I1lLLENevv4fJ1t9NWbOaEPQ5mr7b5tQ5rSPd0rOHiNTfR1d/DE+fvz2Gz96Iw9JgPjUX18y+YQjnYzn7LGjjP7nnAy4APA3cDewP/AvxwPIORpPEwb+brmdP2V2zt/gPF4lxamx5f65CkWlsQEVcOeH1WZp5Veb4UuHfAtvuAJw3a/9E+mdkXERuB+Wx/E4+XAldnZndELK0cZ+AxlzJIZn51NG9mOtv2mUXEZZl5y2iPExHLga8BiykXpc7KzE8P6hPAp4HnAluB12bm1aM9p8bm/g2beMu3fsbGzq7yYiARfOPSa/nMK1/Aolntw+63oaeD917/VdZ2b6SUSUTwo/su4b2Hv4rlMxYOu193/1Z+uvojrO++j6xca756/U953tK3s0frfsPu19Pfz9v+8DP+tPaB8qjhgG/cdg3/fsyzecqSvUf/AUjjpJQlPnLDz/nD2lWUJ98EP7znCv7h4GfzzD0OqXV42/nVA9fwpdvPp78ySei8B67h2IUHc+YBz7O4NDnsLP+CKZSDDVtYysy7tz2PiLcCKzNzQ6XptsoHdCXlYVaSVFcKhSbaW4+vdRjSbouJWTxybWaunJAjAxFxKOWh2SeP8TiLKV+9W0B5VA4AmfnlMQU4RQy+Q29EPHWofiP8vPqAt2Xm1RExE7gqIs4fNPz+OcD+lceTKOd8gxNeVcn/XHAZG7Z2Mru15dG29R1b+d/fXcG/veCEYff7wb0X8VDXhu1GKG3p7eSLt/+C9x/+6mH3u2HD+azrvofmwky2Lc/RU+rkwof+l9P3/sijbYOdd++tXLf2AWY1Nj/ap6uvlw9e9Rt+8tzX0FhwsoNq64p1d/KHtauY2fDYd7S31Md/3XI+T16wL20NzTWOsGxT71a+fMevaS400lD5e5OZXLLmZp6x6DAeP3fwessai8mYf0H95GAjnRcyG5gBbBjQNqPSLkmSxkv170qyGlg+4PWySttQfe6LiAbK//+vA4iIZcDZwKsz8/YB/Zft4pjbiYgXAd8A/gwcSnlY92HAJYCFpbKBd+gN4GnAg5SvZC4H9mCEn1dmPgA8UHm+OSJupnxFc/Dw+69lZgKXRcSciFhS2VdVVColl99xLzNbtv+Ft725id+vunuYvcouX3cLrcXt92traOG2TffR1d9DS3HoqXSrtlxOMZq3KyA1Rgtb+taypW8tMxuHHu30m/tWUYzYbr+WhkY6entYtXEdB8/1poWqrd8//Gcgt/9uFxroKXVz04bVPHHB42oX3AA3bSwPZGkYUIyNCEpZ4o/r/mxhabzV5q5wUyYHG+n4ua8Cv46IMyLiORFxBuXFoRzCLknS5HYFsH9E7BMRTcDpwDmD+pwDvKby/GXABZmZETEH+Dnwjsz8/bbOlcLDpoh4cmU61auBn+wijg8Br8vMoyjf5vYo4AzgqrG9valj4B16geuBt2fm8sx8amYuB/6p0r5bKneYOYryIp8DDTVEf4fh9JX88MqIuHLNmjW7e3qNQAQ0NRQplbb/zaeUSVNx5yOAmqKBZPt77SRJIYLiTqbSNETzDvtBecREMXa4KeGjZjQ0PXo31oH7lEiai651qNpraWgc9tbyjXW0HmfTcLEEwxaENelMmRxspIWlfwY+Q3n18U9SfsOfrbRLkqTxkJQXjxzvx85OmdkHnEn5gtHNwPcy88aI+EBEvLDS7UvA/IhYBbwV2HY73DOB/SjfPfbaymPbcIT/R3lhyFXA7ey4aORge2Xm9we1fZVyQqQd/RXwX4PaPsv2o5p2KSLaKa+Z+ZbM3DSaQDLzrMxcmZkrFy4cfs0ejV5E8OzDDmBLTw9Z+Y04M9na08tzjzhwp/s+a8nRdPVvv19HXxdPmn/wTn+JPnT2CZSyl203gM5Mekpb2KP1AGY0zBl2v+evOJiER9eEAdjc183StlnsM3PXC39LE+1ZexxKIYK+Uv+jbVv7umlraOHQOTvUzmvmsDl701JsorO/59G2vlI/RQo8feHBNYxsCqpB/gVTKwcbUUk2y/+jfL7ykCRJU0hmnkv5drQD294z4HkX8PIh9vsQ5atcQx3zSsrDqEfq4YhYnJkPAXdFxFMoL0zpgixDexB4IeUh8Nu8AHh4pAeIiEbKRaVvZuaPhugykiH6qpI3HPdE7lr7CDfe/zBBudBz1N578uqnHb3T/Z6/55O4Y8sDXLX+zxQIEti3fQmve9yzd7rfgbOO5aGuVdy66RKCgAhmN+3BiYvP2Ol+T1m8F6884Ei+9edrKVSW6Zjf3MaHn/ycYddlkqrpgFl78Ib9juPLqy6C/j4ioLXYxPuOeFFdrQHWVGjgnYe8jA/f+H229nc/2v76xz2LFe2LaxiZxtNUycGGLSxFxKsy8+uV568frp8LakqSpHHwv8CxlAsd/wlcCJSAT9QyqDr298API+LtlKer7QUcwhDJ51Aqw+O/BNycmZ8cpts5wJmV2x8/Cdjo+kq1M6OpkY+f9lz+/NA6Vj+ykeXz57Dvwnm7LNY0Fhp420Ev496ta7h36xoWNs9mv/Y9d7lfRIFnLH49R859Hmu676KtYQ57tOxP7OJOVBHBGw99Mi/a51BuXP8Qs5paOHLBnjQUvIOV6seLlj+BZyw+iBs2rKal2MiRc5fX1TS4bQ6ctZSznnQm12+4m+7+Xg6bs9d2C/FL42TMOdjO/va8Avh65flww6oTF9SUJGn81GbxyJrLzI8OeP61iPgt0JaZN9cuqvqVmedHxOMo37ltT8rrLPw8M9eN8BBPo5zfXR8R11ba/pVygYrM/DzlK6jPpTyUfivwunF7AxqViOCAPRZwwB4Ldnvf5TMWsnzG7k9VnN20mNlNuz86YvGMmSyeMXO395OqZW5TG09fdECtw9ilpkIDT5i3b63DmPqmaf4F45ODDVtYysznDng+/D1MJUmSxigi3gJ8uzIMm8y8p7YR1b/MXMtjFwF3d99LGHA74WH6JPCm0RxfkiRNDuORg41oTGpE/H1EHLG7B5ckSbspJ+AxORwP3BkRv46I10XErFoHVG8i4pcDnl8cERcN9ahljJIkTUrTN/+CccjBRjqRdCXwtoiYCVwM/K7yuDpzuJs1SpIkjUxmvqhy69yXUZ6i9dlKIWW4haWno68NeP7FmkUhSZKmjPHIwUZ6V7hXA0TECuAZlce2lcrn7FbUkiRpGCO7Pe1UlZkbKBdMvhgRe1Wefx/vDAdAZn5rwPOv1jIWSZKmjumdf8HYc7ARL30fEQdSLigdT3nBx9soj1qSJEkaFxFxLOUbiLwMWAe8t7YR1aeIuAb4LeVc7KLMXF/biCRJ0mQ2lhxsRIWliHgI2Az8gPIw7Ddm5ubdD1WSJO1MTNMJ5hHxMeAvKK9K8F3g2Zl5bU2Dqm9vo3zB7y3AtyJiFZWlCjLzB7UMTJKkyWa65l8wPjnYSEcsnQM8HXgRMBeYFxG/y8zVu3MySZKkYbQBf5WZF9c6kMkgMy8ALgCIiPnAW4Ezgf+HUwclSdLIjTkHG+kaS38DEBGLgeMoXyH774hYm5n7jfbkUj3b1NVFT6nE/NZWInY+57arp5fNHd3MnTWDhuLOb7bYXyqxfuNWZs5opqW5cTxDnjD9pX7u7bifWU0zmdc8Z1yPXSptpT830VBYRMSIblRZcz2lHrb0bWV240yKsfPf3zL76epfR2NhJg2F1ipFKE0+mfn/ah3DZBIRz+GxnGw5cCnwTlymQJIk7YbxyMF2Z42loygnLydQHr3UAfxxhPu2ABcBzZVz/iAz3zuoTzPlaXZPoDyf77TMvKuy7Z3AG4B+4O8z87yRxi3trrVbt/LRiy7iytXlAXl7zZ7NO57xDA5euHCHvn39Jb750z9y7sU3kZm0NDXyqhcew0lPPWjIY1989e188ceX0bG1GwKedcwBvOHFT6GxoX4vLv/87gv42DUXs7m3/PqJi9r4yJP/mjljLDCVSp08tOlTbOo8F4BizGbR7Lcxq/WEMUY8cfqzn3NWn8fFay8lSZoLTbxwz1N46oJjhuz/QMfvuHn9WfSWNhMRLG07mYPnnUEhJkdBUVJd+zlwO/Bh4GuZ2VfjeCRJ0jQ1ouEBEfEIcDZwNOVpccdk5tLM/MsRnqcbODEzHw8cCZwSEU8e1OcNwCOVEVD/CXy0cu5DgNOBQ4FTKI+Uqt/fwjWplTL551/+kivuu4/25mZmNjdz3+bNvPXcc1m7desO/b/1sys458IbaG5soK21mf5SiS987xKuuOHuHfpe/+f7+dQ3f0t3Tx9tldFK5116C1/80aXVeGujctWa63jvHy+mozdpKSbNxeTyhzr4+0s+P+ZjP7TxY2zceg4FZlCMmZRyKw9seDedPdePQ+QT42f3/4rfrrmExkIjrcVW+rPEd+/9CTdsvHmHvuu6ruNPaz9Bf3bRWGynGC3cu+UX3LT+CzWIXNIU9HTgy8DLgXsi4lcR8W8R8fQaxyVJkqaZkc47OSozV2TmqzPzS5m5andOkmVbKi8bK4/By2OdCmy7de4PgGdGef7RqcB3MrM7M+8EVgFDDw+QxujGhx/m7g0bmNXSQiGCiKC9qYmuvj7O+/Oft+vb29fPLy6+iRmtTRQr09+aGhsoFgr88FfX7nDsH11wHUTQ3FQeKFgsFGib0cxvrriNjs6eCX9vo/HVWy6gP6G5ofxZFCKY0ZDcuL6bOzbeNerj9vU/wqauX1GM2WyrExeiBTJZt+Wb4xT9+Oor9XHx2stoKbY8Ov2tsdBIIQqc9+CFO/S/c2N57dxioRmAiCKNhTZWbzmf3lJH9QLX5JIT9NCUk5m/z8wPZ+ZzKF+0uwL4Z8p3ipMkSSNl/jVmIyosbZuSNhYRUYyIa4GHgfMz8/JBXZYC91bO1wdsBOYPbK+4r9I21DnOiIgrI+LKNWvWjDVkTUNrO8q/8A9eUymB1Zs2bde2tbOH3v7+HdZUamws8vD6HW+a+NC6zTtMeSsWCgTB5o6ucYh+/N2/dSvFQctLlQtMyf1bHx71cftLjwCFHdZUimiit78+7wnQ2d9FX6lvhzWVGqOB9T0bdui/te/BHaa8RRQJgt7+TTv0lx6VMf6PSSAi/iEiFtQ6jskiIl4cEZ+u5FZ3UV5v6bPAc2oZlyRJk9I0zb9gfHKwqq2Um5n9mXkksAw4JiIOm4BznJWZKzNz5cIh1sORdmX/+fMpZVLKx0rMmUkAj99jj+36zmxrYU57K9092y9r0dndy8GP274vwKH7LqG7p3e7tp7ePpoai8yf0zZ+b2IcHblgEf2Dqu39mWQGh8zdf9THbWzYk6CBzO1HapWymxlNR4/6uBOprWEGMxva6SltH3N3qZt92/feof+8lsPpz+7t2vqzh0KhiZYGf3eWhnAicFdE/CwiTqusvajh/QOwgfLd4OZn5tMz898y81e1DUuSJE0yY87Bqn4LpszcAFxIeb2kgVZTvqsJEdEAzKa8iPej7RXLKm3SuFs2ezYn77cfm7u72drbS3dfHxu7ulg+ezbH77PPdn0LheC1L34yvX39bNnaTU9vH5u2dNHc2MBpz9mxOPLSZz6eGS1NbNrcSU9vHx2d3XT39PGaFxxTt4t3v/6g59PemHT0Qm8p6eqD7r7gJfsuZV7L3FEftxAtLJj1t5Syk/7SFkrZTV/pEYqFmcxrf8U4voPxU4gCL172XPpKfWzt66S31EtHXweNhUaes8ezduj/uFkvp6Ewg57+TfRnD72lDkqlbg6c8zoX79bOTdOh2Jl5KrA38AvgLcCDEfHFiDiupoHVqcw8PjPfm5kXZGZnreORJGlSm6b5F4xPDjbiu8KNRUQsBHozc0NEtAInUVmce4BzgNdQvl3uy4ALMjMj4hzgWxHxSWBPYH9GeDc6aTT++elP59DFi/nxTTfR2dfHSw89lNMPP5zmhh3/uhx79L7Mam/hR+dfxwNrNrLy0L142clHsXzJjkWXPRbM4uNvfRE//PW1XPfn+1k0t52XPPPxPOHg5Tv0rRd7ti3hG896A/91w9lcveYRZjUWeMX+R/Pyx419psW8tr+gqbiEdVu+QV//w8xsfhbz219DY3HH0V714ui5j6e9oZ3zH/wta7rXctisgzh5jxNY0rp4h74zGpfw1D0+xe2bvsf6rutoKS7icbNfzsLWlTWIXJocMnMd8DngcxFxBPB14HURcS/wv8CnB6zZKEmSpHEw1hxs2MJSRJw4wgAuGEG3JcBXK3dzKwDfy8yfRcQHgCsz8xzgS8DXI2IVsJ7yneDIzBsj4nvATUAf8KbM7B9JbNJoFAsFXnjQQbzwoING1P+IA5ZyxAFDLvu1gyULZnHm6ZPr4vveM5fz8af8/YQcu73l6bS3TK4bGB0wc18OmLnviPrOaNyTw+e/ZWID0tQzia5wTYSIeCbwV5Rv3nEl8B/APZSnfv2C8t3QJEmSxs80z79gbDnYzkYsfWkE507gcbvslPkn4Kgh2t8z4HkX5VvmDrX/vwP/PoJ4JEma1CbPUo/jKyI+Tvmi0kbga8C7MnP1gO2XAY/UKDxJkjSFTdf8C8YnBxu2sJSZ+wy3TZIkaZy1AC/OzCuG2piZvRHhXFJJkqTxNeYcrCprLEmSpBGapkOxM/NMgIhYDizNzMuG6HNL1QOrIxHxdUbwDcnMV1chHEmSpo5pmn/B+ORgIyosRcQs4H3AM4AFDBgplpl7jTxkSZKkHVWSme8AR1JO79oj4mXAKZn517WMrY6sqnUAkiRpahmPHGykI5b+G1gGfAD4BuUFnd4O/HA3Y5YkScOZZLenHWdnAT+nvDDkukrb+cAnahZRncnM99c6BkmSppzpnX/BOORgIy0snQwcnJnrIqI/M38SEVcCPwX+czcCliRJGsoxwPMysxQRCZCZGyNido3jqlsR0QQcyI6jyUdyx15JkiQYhxxspIWlAuUVwgG2VE7wALDf7kQrSZJ2LqbvFbOHKOcVt21riIhDKN/mVoNExLHA94FmYBawCZgJ3MsI7tgrSZIeM43zLxiHHKwwwn7XUV5fCeBiylPj/mfgiSVJ0jjICXhMDh8HfhYRrwMaIuIVwHeBj9Y2rLr1n8B/ZOY8YHPl5wcp52iSJGl3TN/8C8YhBxvpiKW/4bEh1v8AfBiYA3jXEUmSNGaZ+eWIWAe8kfKom9cA787MH9c0sPp1APDpQW0fAe6knCBKj+rY1Mkl517LqhtWs3SfhRz3/COZt3jXMxzWd2/mC7deyBVr72FJ60zOOPB4Hj9v7ypErMmqo6+Ti9dcy6otq1naupDjFh7J/GZnNEv1bDxysBEVljLzjgHPHwbesHuhSpIk7Vxm/gT4Sa3jmCQ2Up4CtwF4oDJkfR3QXsugVH/WP7SRD/zNl9i4voNCIbjytzfzy+9cyjs++xpWHLhk2P3u37qel/zmLDb39hIEt254hIse+Drvf8LJvGTvY6r4DjRZrOveyAdu/BIbezsIgiu4mV8+eCnvPPg1rGgb/rsmqfbGmoONdMQSEfF64BXAnsD9lG9H9+XMnFyDvCRJUl2o5Ba7lJlfnuhYJqEfAc8FvgV8GbgQ6AV+UMugVH/O/tLv2LBuC7PmtD3a1rG5k699/Fze87/DXyv+6J/OZXNPL80N21bOCHr7k49c92teuPwJNBSKExy5JpuzV/+ODT1bmNk44LvW18lX7zyX9x7muASpnox3DjaiwlJE/AdwKvAp4G5gb+CfKN+J5J9HcgxJkrRzwbRbPPJVI+iTlAsnGiAz3zLg+ccj4jLKi3f/smZBqS5dfdGtzGhr2a5tRnsLd9y0mq7OHlpam4bc74q191GM2K6tIWBrX4mbN67m8Ll7TVjMmpyuXn8rrcVB37ViC3d0rKarv4eW4tDfNanWpmH+BeOcg410xNJrgaMz875tDRHxM+BqLCxJkjQ+Jt9ij2OSmSfUOobJKiI+k5l/v+11Zl5Saf8U8JYahaU61NrWxOYNnTQ0PjbCqFRKGhqKFIvD38enudjAZvqG3Da7cca4x6nJr6XYxOa+ThoY8F0jKUaRYoz0nlFSDUyz/AvGPwcb6d/wzZXH4LZN4xmMJEmaviJiTkS8MiLeXvk5p9Yx1bHXDtM+kiuQmkae9bJj6O7qoVQq/9aUmWzd0sVTnn04jU3DX2N+yYojKJHktv1KSU8me81sZ6/2BVWJXZPLSYuPoae/h1IO+K71d/HUBYfTWBjxCiySamCsOdhI/4Z/CvhRRHwEuA9YDrwd+M+IeNy2TgMX+ZYkSbtvGg7FBiAiTqS8btCtlKfd7wV8LiJempm/qWlwdWTAmggNQ6yP8DhgbZVDUp076eXHcO/tD3PpeddTbCjQ31fi4KNX8Iq/P3mn+73pwGdx4yP3c8mD9xH9SQILW1r476e8sjqBa9I5eckx3Nv5MJeuvZ5CFChliUNmreAv99r5d02qB9M1/4LxycFGWljadjvbwcOlngl8pvI8AVfxkyRJo/FZ4IzM/N62hoh4OfA54KCaRVV/to1IamL70UkJPET5FsHSo4oNRf7mXafyotcfx/13rWX+HrNZ9rhFu9yvUCjw+ae+llWbHuSyNatY1jaP4xYdRKHglCYNrRhFztj3VF609Dju71zLgubZLJux6++apJobcw42osJSZvo/iCRJ1TB9r5jtCfxwUNvZwP/WIJa6tW1NhIj4UGa+q9bxaPJYuOdcFu45d7f322/WHuw3a48JiEhT1aKWuSxq2f3vmlRT0zf/gnHIwXarYBQRyyPiybuzjyRJ0gh8HXjToLa/A75Wg1jqXma+KyLmR8SrIuLtABGxZ0Qsq3VskiRpUhlzDjaiEUsRsRfwbeBIyrW89oh4GXBKZv71SE8mSZI0jKOAv42IfwZWA0uBRcDlEXHRtk6ZeVyN4qsrEfEMylcXrwSeBnwM2B/4J+AFNQxNkiRNLmPOwUa6xtIXgJ8DTwfWVdrOBz4xiqAlSdJwpu9Q7P/FaW+741PAaZn5m4h4pNJ2OXBM7UKSJGmSmr75F4xDDjbSwtIxwPMysxRRXi89MzdGxOyxnFySJAkgM79a6xgmmRUD7tSyLR3uYeS5nSRJ0rjkYCNNPh4C9gNu29YQEYcA94w1AEmSJICIWEz5YtYCILa1Z+aXaxZU/bopIp6dmecNaHsWcH2tApIkSZPTWHOwkS7e/XHgZxHxOqAhIl4BfBf46O6FK0mS6k1EnBIRt0bEqoh4xxDbmyPiu5Xtl0fEikr7/Ii4MCK2RMRnB+3zioi4PiL+FBG/jIgFu4jhRcDtwAcoT8F/c+Xnq8bnXU45bwO+GRFfBVoj4gvAV4C31zQqSZI0YlMlBxtRYalSpXo78HLgXuA1wLsz85sjPZEkSRqBnIDHTkREEfgc8BzgEOAVlVHJA70BeCQz9wP+k8cuLHUB76a8YPTAYzYAnwZOyMwjgD8BZ+7inX8IeF1mHgV0VH6eAVy1i/2mpcy8DDgCuBH4MnAncExmXlHTwCRJmoyqnH/B1MrBRjwPPzN/AvxkpP0lSdJuSojqLx55DLAqM+8AiIjvAKcCNw3ocyrwvsrzHwCfjYjIzA7gkojYb9Axo/Joi4h1wCxg1S7i2Cszvz+o7avAgwxKmqaziJgBvAs4DLga+HBmdtc2KkmSJrHa5F8whXKwnY5YiognRMRhA14vjIhvRsR1EfH5iGgfyUkkSVJNLYiIKwc8zhiwbSnl0cjb3FdpY6g+mdkHbATmD3eyzOwF/o7yej/3U74K96VdxPhwZX4/wF0R8RRgX6C4i/2mm88BLwBuAV5GebkCSZJUf3aWf8EUysF2NRXuU8AeA15/ETgAOIvylbL/GOmJJEnSCEzMUOy1mblywOOsiXwLEdFIOak5CtiT8jDsd+5it/8Fjq08/0/gQuA64L8nKMzJ6hTg5Mz8Z8pD559f43gkSZr8pkD+BbXLwXY1Fe5g4OJKgHMoJzCHZeZtEXEO8Afg/430ZJIkqe6sBpYPeL2s0jZUn/sqc/dnA+t2cswjATLzdoCI+B6ww4KUA2XmRwc8/1pE/BZoy8ybR/Qupo+2zHwAIDPvjYjZtQ5IkiSNypTJwXZVWGoAeirPnww8mJm3VU54b6XYJEmSJq8rgP0jYh/KycvpwF8O6nMO5Rt3XEp5+tUFmbmz1QhWA4dExMLMXAOcBIw4OYmIAuXh4EREITNLI913GmiIiBN47FbAg1+TmRfUJDJJkrQ7pkwOtqvC0o2U7wT3Pcpv8tcDTriU8vw+SZI0Tqq9eGRm9kXEmcB5lOfSfzkzb4yIDwBXZuY5lOfmfz0iVgHrKecE5Xgj7qK8MGRT5Xa1J2fmTRHxfuCiiOgF7gZeu7M4IuJoyusHHQG0bGumPJjcdZYe8zDlu8Bts27Q6wQeV9WIJEma5GqxePdUysF2VVj6F+CnEfF5oJ/H5t0BnAb8fiQnkSRJ9SszzwXOHdT2ngHPuyhfaBpq3xXDtH8e+PxuhPFV4KfA64Gtu7HftDLc5y1JkiafqZKD7bSwlJmXRMRelBfsvi0zNw/Y/HPgO6M5qSRJGkZtbndbD/YG/m0Xw7slSZLG3/TOPsacg+3qrnBk5ubMvGpQUYnMvDUz7x/tiSVJkgY4Gzi51kFIkiRNM2POwXY1FU6SJFVJUJs5/rUSEV/nsWuEzcDZEXEJ8ODAfpn56mrHJkmSpofpln/B+OdgFpYkSaoXyXQbir1q0OubahKFJEmavqZf/gXjnINZWJIkSTWRme+vdQySJEnTzXjnYLtcY0mSJGmiRcQJEbFP5fkeEfHViPi/iNij1rFJkiRNVeORgzliSXXlj3fcy/euuJ41mztYuWIppx1zBItmtdc6rJro6u7l55fcxG+v/DMNxQInP+VgTnrygTQUd6wHZyZrOi/m3s0/ore0iQWtT2GvmS+nqThnyGOv3vIbrl//P2ztW0t7w2IOn/93LGk7fmLfkMZNZnLF+ps578HL2NzXydFzD+C5S57KrMa2qsbRW+rj/Aev5TcP/olSljh+8eGcsuRomouNVY1DU8Z/A8+uPP9k5WcncBbwwppEJEmSNPWNOQezsKS6cc41N/O5Cy6lEEFjscBPr72Z3916J//zqlNZOM2KS339Jd77+V9w690P09zUQCac9cPfc/2q+/nn1zxzh/53bvo6d2/6FkGRiAbu3fQD1my9iJV7/DeNhZnb9b1r00/448MfIYECwSM9d3Pxg+/kKYvezfKZz63SO9RYnL36d/xk9cU0RIFiFPnFA5dy+bqb+NDhZ9DW0FqVGDKTT9z8Y6585HaaogjA1++8kKvWr+J9h7+CQjggdrSm2+KRAyzNzHsiooFycrM30AN4B1pJkjShpnH+BeOQg5n5qy709PXxxYuuoKWhgfbmJpobGpjd2sKmzi5+eNUNtQ6v6q6++V5W3bOGWW0ttDQ10trcyMy2Fi6//m7uWL1uu749/Ru5Z9N3aIg2GgptFKOZxuJsuvvX8MCWX+5w7OvWfZYEitFARJFiNJIJ1679ryq9O43Fpt4Ofrr6EmYUW2gtttBUaGRmQxuP9Gzidw9fU7U4btt8P1c/cgcziy20FJtoKTYxs6GVWzet5k8b7q5aHJpSNkXEYuAZwE2ZuaXS7hA4SZKkiTPmHMzCkurC/Rs201cq0dRQ3K69uaGBa+5+oEZR1c5tdz9MfymJiEfbIoLM5I771m7Xt6P3LoICEcVBRynySNe127WUSn109W+mMOivfoECW/s3jOM70ERZ3bmGQhQoxo5/hjdturNqcdy55SEyd/yO9pb6uX3L9Ps7O65yAh6Tw38BVwDfBD5XaXsacEvNIpIkSdPD9M2/YBxyMKfCqS7MmdFKqVSiVEoKhcd+Ue3p62ePOTN3sufUNH9O+3afwzaFCObOmrFdW3NxHkn/Dr/kJ/20NizZfv9CA8VoILM06MhJQ8FBAZPBnMZ2+rO0w593iRKLWuZVLY65TW0UYsfvaEOhyLym6fd3dlxNrkRk3GTmRyPibKA/M2+vNK8G/rqGYUkT4qqb7uGLP7qUB9Zu5qAVi3jTaU9n+ZK5u9zvT6sf4NMXX8Idm9ez/+wFvOXYYzlkz8UTFuemri5+euutXHX//SydOZMXH3IIj5tXvf9rJlpmidVbr+KOzb8jSfZpfzrL244hnM5NV9+D3L/lHLb0rKK96UD2bH8BLQ2Lah2WNHGmaf4F45ODWVhSXZgzo4XjDtyHC2+5g5nNTRQLBbp7+4iAl608rNbhVd3TjtyHb/78Cjq2djOjtQmAjq3dzJ/dxuP333O7vjMalzO7+XA2dP2JhkI7EJSyiwIN7Dnz+Tsce+/2E7hj8/kUMogokFmiRIl925+9Q1/VnyWtCzho1l7cvOku2oozCKC71Esxipy46AlVi+Ooefsyq3EGG3s7aCu2ALC1v5u2hmaOmX9A1eLQ1JKZt+3stcZXRHwZeD7wcGbu8J9tRMwGvgHsRTln/Hhm/l91o5x6zvnt9fzHV35DqXKB4OFrNnPp9XfxhXefxkErhi8SXXDrKt504U/oJwmC1es3c8k5d/O/J72Ep+27YtzjXN/Zyd/+5Cc83NFBQ6HA1fffz7m33cYHn/UsnrrXXuN+vlq4Yu2XWLX5AiLLF0pWb72avduewlMXvXm7izfTzZaeVVz38Nvozy6CIhu6ruOBLT/lyMWfoq1xRa3DkzQBxpqDWY5X3fjHk4/lpEP2o7O3jy3dPTQ3NvCO5x3P4cum352mZ7W18IE3PY+li2bTsbWHLVu7OWDFIj74pufR0DB4yhsctuDdLJjxFPpzK/3ZQWNxFocveB/tQ/zn/4SF72V521PJSErZR0ayV/txHLngnVV4ZxoPb97/5Rw990A6+7vYWuqivaGVtxxwGstmVO9KYlOhgQ8c8Zfs276Ejv5uOvq7WT5jAe8//C9pa2iuWhxT0vQeiq3q+gpwyk62v4nyWguPB44HPhERTVWIa8oqlUp85tsXkUBjQ5GGYoHGhiK9vf187P9+s9N933/Rr+knaaJIIwWaKNJHifddeP6ExPrd66/n4S1bmN3SQltTE7NbWigWCnzikkso5eT/h2VDzz3cvvkCmqKNpmJ7+RHt3NNxGWu7p3dN+/YNn6c/u2gszKKh0EZjcRb92ckdG/631qFJE8f8a0wcsaS60drUyD8/9xn8vxOfzKaubhbNbKehOH1rn49bOp9Pvf0lrN3QQbFQYN7sGcP2bSzM5PAF76W3fyN9uZWW4uJhh3EXCg08dckn6e7byJa+u5jZsA9NDbMm6m1oArQ1tPIPB5zG5t6tdPZ3s6B5dk3uwrakdR4fPvLVPNKzhVIm85udAidNJpl5UUSs2FkXYGaUh260A+uBvmrENlWtXrORrV09NBS2/ze7WAxuH7SG4kB9/SUeKG2hcdA14cYscE/fxgmJ9Q/33ENz4/bT5FsbG9nQ1cWDmzez56zJnTs83HlLeVr5gD+LiKBU6uPhzptZ2HJgDaOrncwSG7uvoyG2//NtiDY2dF1Vo6gk1TsLS6o77S3NtLc44gHKCc7Cue0j7t9YnE0js0fUt7lhNs0Njx9taKoDMxtnMLNx+IJjtcxtGvl3VNKk8lngHMq3G54JnJY7LtJHRJwBnAGw1xSZIjVRZrW1EAQJDJxoVUpobRw+LS8EFDMoZVIcuL5eJI3sOJJ5PMxuaeH+zZu3aytlkkBb0+QfuNZUbBvixidQiCJNxbYaRFQvgmLMIOknBhQyk34aCl5AkjS06TscRJKkepMQE/CQRunZwLXAnsCRwGcjYodhKpl5VmauzMyVCxcurG6Ek8zs9lb232sB/aUSWSr/5SyVkszkOccePOx+hUKB4+atoD/KfQEyk36SZy3ed0Jiffmhh9JfKtFXKj16vs1dXTxl+XJmt7RMyDmraemMo2iIZnpLWx9t6yt1UYgmlrc9qYaR1VZEsGf7qfSXOh692Utmif7cyp7tL65xdNIEMf8aMwtLkiRJGsrrgB9l2SrgTuCgGsc06X3yn17C0oWzy0Wb/hKlTFYevJw3n/6Mne936gs4rHURfVGijxJ9UeLxbXvwkec/d0LiPG7FCl539NF09/WxtaeHLT09HLXnnrzjuOMm5HzV1liYwYlL/pXm4kx6S1vpLW2lodDM8Xv8Cy3FyT3Nb6z2nv1XLGp7Fn3ZQV+pk/7sYHHbKSyf9Re1Dk1SnXIqnCRJ9WSaXeFSXbsHeCZwcUQsBg4E7qhtSJPfvNkz+P7HX88Nq+7nztXrOfKgpSxfPHeX+7U1N/Gj17yaWx58iJseeJgj9lzCfosXTFicEcFrjjqKlxxyCHesX8/8GTNYNntk0+0ni/kt+/GivT7H+u47SfqZ1/w4CuGvR4Vo4qD5/8I+s19PZ/8DtDYspbk4v9ZhSRPL/GtMqvIvZ0QsB74GLKb8R3ZWZn56UJ+3A68cENfBwMLMXB8RdwGbgX6gLzNXViNuSZKkqSoivk35bm8LIuI+4L1AI0Bmfh74IPCViLie8pJA/5KZw68wrd1y2H57cth+e+72fgftsZiD9lg8ARENbWZzM49fsqRq56u2iALzWyZmOuFk19ywkOYGp7dK2rVqleT7gLdl5tURMRO4KiLOz8ybtnXIzI8BHwOIiBcA/5iZ6wcc4wSTGUnSlOcVM1VJZr5iF9vvB06uUjiSJNWO+deYVKWwlJkPAA9Unm+OiJuBpcBNw+zyCuDb1YhNkqR6ErvuIkmSpHFk/jU2VV+8OyJWAEcBlw+zfQZwCvDDAc0J/Coirqrc0na4Y58REVdGxJVr1qwZx6glSZIkSZI0WFVXp4uIdsoFo7dk5qZhur0A+P2gaXDHZubqiFgEnB8Rt2TmRYN3zMyzgLMAVq5c6WA2SdLk4/9ekiRJ1WX+NSZVG7EUEY2Ui0rfzMwf7aTr6QyaBpeZqys/HwbOBo6ZqDglSZIkSZI0MlUpLEVEAF8Cbs7MT+6k32zgGcBPBrS1VRb8JiLaKC8iecPERixJUm3EBDwkSZI0PPOvsanWVLinAa8Cro+Iaytt/wrsBY/e0hbgxcCvMrNjwL6LgbPLtSkagG9l5i+rEbQkSZIkSZKGV627wl3CCIp2mfkV4CuD2u4AHj8hgUmSVG+c4y9JklRd5l9jUtXFuyVJ0k4kJjaSJEnVZP41ZlVbvFuqtb5SP1etvYPbNj1Q61AmzNrODu7ZvIH+UqnWoUiSJEmSpgFHLGla+MFdf+Qj1/2arv5ywWXJjFb+56mvZL9Ze9Q4svGxobuTD/7xAq58aDWFCNobm/iXJzyDY5euqHVoknZDAOEVM0mSpKox/xo7RyxpyvvT+nt4/9W/oru/RFMxaAx4oGMrr734q5SmyMief/vDr/jjg/fR3thEe2MTXX19vPuy81m1YV2tQ5MkSZIkTWEWljTl/e9tv6NE0lgsrx8fhaCxEGzs7uXXD95Y4+jG7u5Nj3DDuoeY3dRMoXz3RFoaGujPEj++Y/K/P2nayQl4SJIkaXjmX2NiYUlT3sOdm4lBNyWMQvn1/VsfqUVI42pdVyfFKBCx/XssRoEHO7bUKCpJkiRJ0nRgYUlT3pMWriAzydJjZeMsJQkcu+iA2gU2TvadPY8k6Rs0ra8/k2MWL6tRVJIkSZKk6cDCkqa8NxzwDOa2NNFTSnr7k57+pKeUHLvHsimxePfs5hZed8gT6OjrZXNPN519vWzo7mJJ20yes+LAWocnaXc5FFuSJKm6zL/GxLvCacqb3dTG2Sf+HR+/8Rf84aG7aCk28LJ9juJv9j++1qGNm1cddBSPmz2P7//5BjZ0d3Lc0n142X6HMbOpudahSZIkSZKmMAtLmhYWts7ioytPq3UYEyYiOHbPFRy754pahyJpjLzdrSRJUnWZf42NhSVJkurFNBw6LUmSVFPmX2PmGkuSJEmSJEkaFUcsSZJUT7xiJkmSVF3mX2PiiCVJkqa5iDglIm6NiFUR8Y4htjdHxHcr2y+PiBWV9vkRcWFEbImIzw7apykizoqI2yLiloh4aZXejiRJ0qQwVXIwRyxJklRHotrniygCnwNOAu4DroiIczLzpgHd3gA8kpn7RcTpwEeB04Au4N3AYZXHQP8GPJyZB0REAZg3wW9FkiRpVKqdf8HUysEcsSRJ0vR2DLAqM+/IzB7gO8Cpg/qcCny18vwHwDMjIjKzIzMvoZzcDPZ64MMAmVnKzLUTE74kSdKkNGVyMEcsSZJUTyZmjv+CiLhywOuzMvOsyvOlwL0Dtt0HPGnQ/o/2ycy+iNgIzAeGTFQiYk7l6Qcj4njgduDMzHxoDO9B2qnM5MpfXccF37qYro5unvyCJ3D8XzyV5tbmWocmSap31c+/YArlYBaWJEmqIzExic3azFw5IUceWgOwDPhDZr41It4KfBx4VRVj0DTz7Q+fzS+/fAFRDAqFAquuuZPLfnoV//qtf6CxqbHW4UmS6tgUyb+gRjmYU+EkSZreVgPLB7xeVmkbsk9ENACzgXU7OeY6YCvwo8rr7wNHj0ew0lDW3r+e8/7vQmbMaqVt1gxa21ton9vG7dfdxdW/vr7W4UmSNJQpk4NZWJIkqZ7kBDx27gpg/4jYJyKagNOBcwb1OQd4TeX5y4ALMnPYI1e2/RQ4vtL0TOCm4fpLY3X7tXdRKAaF4mOpbUSQmdz4+1tqGJkkaVKofv4FUygHcyqcJEnTWGW+/pnAeUAR+HJm3hgRHwCuzMxzgC8BX4+IVcB6yokPABFxFzALaIqIFwEnV+5m8i+VfT4FrAFeV713pelm5rx2hkqzg2DuHnOqHo8kSbsylXIwC0uSJNWLnLA5/js/bea5wLmD2t4z4HkX8PJh9l0xTPvdwHHjF6U0vAOfuC/zlsxh7er1tM2eQUTQtbWbhqYGjn3x4HVQJUkaoEb5F0ydHMypcJIkSZrUisUi7/jam9n74GVs3dRJ5+ZOWttbeOtZb2Thsvm1Dk+SpCnNEUuSJEma9BbttZAP/ORfePietXR39rB0/z0oFou1DkuSpCnPwpJURZkl6L2K7L2ZKCyA5uOIQnutw5JG7f6HN3LFn+6mlMkTDl3OXnvOq3VIk1+NhmJLU0FEsHjvhbUOQ5I02Zh/jYmFJalKMrvJDf8CfTdA9pEUoeMLMOcTRMN+tQ5P2m3n/u5GvvKjy+jvLwHw7Z9eyWnPO5qXPvuoGkcmSZIkqVpcY0mqkuz8MfT+CZgJhXlQmA2lreSmD7OTO0ZKdWnN+i185YeX0dLUwOyZrcye2UprSyPf+fnV3PfgI7UOb3Krze1uJUmSpi/zrzGxsCRVS9evIJoh4rG2aIf+u6H0cO3ikkbh2pvvI0kaGh5bv6RYLNBfKnHVDffWMLLJLSjflWS8H5IkSRqa+dfYWViSqqbA8KVrFxfV5FIoBOX/hrcXj26TJEmSNB1YWJKqpeX5kD2w3bS3zdBwIFFcULOwpNE4+tDlFAtBT2//o229ff0UiwWeeMTeNYxMkiRJUjVZWJKqJFqfC83HAlugtAFyMxTmETPfWevQpN02d9YMzvyrZ9DX18/mjm42d3TR3dPH3/zFU9ljwaxahydJkiSpSrwrnFQlEY0w6/3Qdyv0/bm8gHfTE4loqnVo0qgcu3JfDjtgCdfcfB+lUnLUwcuYN6et1mFNetNtTr4kSVKtmX+NjYUlqYoiAhoPKj+kKWDOrBmc8KQDah3G1JEMmi4rSZKkCWX+NWZOhZMkSZIkSdKoOGJJkqQ64lBsSZKk6jL/GhtHLEmSJEmSJGlUHLEkSVI98YqZJElSdZl/jYkjliRJkiRJkjQqjliSJKmOOMdfkiSpusy/xsbCkiRJ9cTERpIkqbrMv8bEqXCSJEmSJEkaFUcsSZJULxKvmEmSJFWT+deYOWJJkiRJkiRJo+KIJUmS6kZCeslMkiSpesy/xsrCkiRJdSRqHYAkSdI0Y/41Nk6FkyRJkiRJ0qg4YkmSpHriSGxJkqTqMv8ak6oUliJiOfA1YDHlP7KzMvPTg/ocD/wEuLPS9KPM/EBl2ynAp4Ei8MXM/Eg14h6t6353Iz/57C946O617H/0Prz4H57H3gcvq3VYU84dWx7gB/dczB0dD7BHyzxeuvxYDp+zT63DqolSqcQl517Hed+5jI5NnRx57AG88LXHMW/RrFqHJkmSJEmawqo1YqkPeFtmXh0RM4GrIuL8zLxpUL+LM/P5Axsiogh8DjgJuA+4IiLOGWLfunDJjy/nrH/6OoWGAk3NjVz96+v500U3894f/pPFpXF0++b7ef8NX6e3VKKl2MSfN6/mwzd9h3844EU8acHBtQ6v6r73ud9w3ncupbGpkWJDgd/+5Gquufg2PvT1NzJzTlutw5M0QgGEV8wkSZKqxvxr7KqyxlJmPpCZV1eebwZuBpaOcPdjgFWZeUdm9gDfAU6dmEjHplQq8e3/72yaWhqZMbOVhqYG2ue20dfTx9mf/nmtw5tSvnvP7+jLEjMbW2ksFGlraKEhinzjrt+Q02xF/43rt3D+9y9nxsxWWmY00djUwKw5bWx6pIPfnnNNrcOTtLsyx/8hSZrU1nZexRUP/RsX3/9Gbl7/eTr71tQ6JGlqMf8ak6ov3h0RK4CjgMuH2PyUiLguIn4REYdW2pYC9w7ocx8jL0pV1ZZHOtjyyBaaWpu2a29pa+bP19w5zF4ajVVb7qe1sP3n3FxoZG33Jjr7e2oUVW3cf+caCsUCxeL2f52LxQK3XXt3jaKSJNWziPhyRDwcETfspM/xEXFtRNwYEb+rZnySHnPv5nO56uH3sb77err61nL35p9y6QP/QFff2lqHJklAlQtLEdEO/BB4S2ZuGrT5amDvzHw88F/Aj0dx/DMi4sqIuHLNmupX8VtnttDY3Ehfb9927T3dvSxavqDq8UxlC5tn05Pbf8592U9rsZnmYmONoqqNeYtn099X2mGkVn9/iT328nsnTSpZHoo93g9pCF8BThluY0TMAf4beGFmHgq8vDphSRqoP3u4dcP/USy00Fhop1hopqk4m57SJu7afHatw5OmBvOvMataYSkiGikXlb6ZmT8avD0zN2Xmlsrzc4HGiFgArAaWD+i6rNK2g8w8KzNXZubKhQsXjvt72JXGpkae/boT6Nzc9Whxqaerh1JfiRed+ZyqxzOVvXTZsfSXSvSUegHoK/XT1d/DC5Y+mWJUfSBeTS1eNo/DjnkcWzZ20t9fLjB1dnTT2FTkxBc/odbhSZLqUGZeBKzfSZe/pHwjlXsq/R+uSmCSttPZ+wCl7KUQ2184LUYT6zqvq1FUkrS9qvwGHhEBfAm4OTM/OUyfPSr9iIhjKrGtA64A9o+IfSKiCTgdOKcacY/GS97yPF74plMo9ZXo2LCV5tZmzvj4q3j88YfuemeN2DELDuKv930OTYUGOvo6KVHiZcufzqnLnlLr0Gri7z7wUp56yuF0be2hY3MnC5bM5m2ffCVL9nbEkiRpVA4A5kbEbyPiqoh49XAdaz1iXJrKmopzyCyRWdquvZS9tDYsrlFUkrS9at0V7mnAq4DrI+LaStu/AnsBZObngZcBfxcRfUAncHqW5/b0RcSZwHlAEfhyZt5Ypbh3W7FY5OVvfQEvOvMUOjd30T63jUJheo2gqZYT9ziSZyw+gi19ncwoNtNYqNbXuf60tjXzN+9+Ea/6p+fS291L++wZVOq0kiSNRgPwBOCZQCtwaURclpm3De6YmWcBZwGsXLlymg3+lyZWU3E2i2c8jQe3XkxjoZ2IAv2lbiBYMevFtQ5PkoAqFZYy8xLKd/HbWZ/PAp8dZtu5wLkTENqEaWxqpHH+9FrrpxaKUWB2Y1utw6gbLa1NtAxaPF7S5DLd5uSrbt0HrMvMDqAjIi4CHg/sUFiSNLEOm//3FKLIAx0XEQTFwgwOnfdm5rUcVuvQpCnD/Gtspu8QD0mS6lHJzEZ14SfAZyOiAWgCngT8Z21DkqanhkIrRyz4Jw6e+0Z6S5tpaVhEIfw1ThpX5l9j4r9IkiRJ00xEfBs4HlgQEfcB7wUaobxEQWbeHBG/BP4ElIAvZuYNtYpXEjQWZ9JYnFnrMCRpBxaWJEmqJ14wUxVk5itG0OdjwMeqEI4kSbVl/jUmriotSZIkSZKkUbGwJEmSJEmSpFFxKpwkSfUicSi2JElSNZl/jZkjliRJmuYi4pSIuDUiVkXEO4bY3hwR361svzwiVlTa50fEhRH/f3v3HqVJXd95/P3pnpsw3ISRyN2IomgUdTTJKitZTRQ3LJpoAjEuJBrUxLhGTMya6CqauGRjVg1xlXjB24omogFFjcfLGoyiaIIRQYKAAiL3AYZxmEt/94+nJueh0z3TU093PZd+v86pw9NVv6rn+6sa+nz7V99fVTYmOWueY5+fxIc+S5IkzTIpOZgDS5IkjZDU4i87/b5kGvgr4HjgaODkJEfPavZ84I6qOpLeK+fPbNZvBl4NvGKeY/8SsLHtuZAkSepC1/kXTFYO5sCSJEnL2xOAq6rq6qraApwLnDirzYnAe5vPfws8JUmq6p6quohecnMfSdYCLwfesHShS5Ikja2JycEcWJIkaZTUEixwQJJL+pbT+r7xYOC6vp+vb9YxV5uq2gbcCey/i568HngTsGlhHZckSRqS7vMvmKAczId3S5I0QlJL8vTIW6tq/VIceC5JjgEeXFW/t+NZAJIkSaNqEvIvGF4OZsWSJEnL2w3AoX0/H9Ksm7NNkhXAPsBtOznmzwLrk1wLXAQ8NMkXFyleSZKkSTAxOZgDS5IkjZKlKcXema8DD0nyoCSrgJOA82e1OR84pfn8bODzVfPf2quq/1NVB1XVEcCTgCur6rhdRiJJkjQM3edfMEE5mFPhJElaxqpqW5KXAJ8BpoF3V9VlSc4ALqmq84F3Ae9PchVwO73EB4DmjtjewKokzwR+oaq+03E3JEmSxsok5WAOLEmSNCJStVRz/Heqqi4ELpy17jV9nzcDz5ln3yN2cexrgUcOHKQkSdISGFb+BZOTgzkVTpIkSZIkSa1YsSRJ0igZzg0zSZKk5cv8ayAOLEmSNEqGVIotSZK0bJl/DcSpcJIkSZIkSWrFiiVJkkZIhh2AJEnSMmP+NRgrliRJkiRJktSKFUuSJI0S5/hLkiR1y/xrIA4sSZI0KgqYGXYQkiRJy4j518CcCidJkiRJkqRWrFiSJGmUWIktSZLULfOvgVixJEmSJEmSpFasWJIkSZIm2JUbbuE93/0aV2y4hUP23IdTj3o8j1t3yC7327T1Oq658/1suPdfWLNiHYft9aus2+OJHUQsSRonVixJkjRCUrXoi6Tl6/I7bua3/+E8vnLT99m8fSuX3fEjTv/K+Xzxh9/b6X6btt7AJTe9lJs3fYnttZm7t3yPy257PTfcfUFHkUtSd8y/BuPAkiRJkjSh3nnFxWyr7ey9ag0rp6ZZu3I1K6emedtlX6Z28ofPD+7+MNtrEyun92YqK1kxtSdTWcP37nw3M7W1wx5IkkadU+EkSRoly+wOl6SldfkdN7HHilX3WbdmegU3bdrIPdu2sHbl6jn323Dvt5nKmvusm8oqts3cw73bbuF+Kw9aspglqXPmXwOxYkmSJEmaUD+xx15s2b7tPuu21Qx7rFzJ/aZXzrvfHisOYqa23Gdd1XYAVk7vs/iBSpLGlgNLkiSNigJmlmCRtGyd8tD1bKsZ7m0Gl7bObGfT1q2c/ODHMD01/58Ch+39qwTYPrMZgJnaxraZjRy05/GsmNqzi9AlqRvmXwNzYEmSJEmaUE8+6MGc/ugns2pqmru33MvMTHHqUev59Yc+bqf77bv6pzh6/1excnot22bupmorh+z1LI7c74UdRS5JGhc+Y0mSpJFRBOf4S1pcJxz+CJ5x6MO5c8tm1q5czarp6QXt94A9jmXd/Z7I1pk7mZ7ak+ms2vVOkjR2zL8G5cCSJEmjxIdHSloC01NT3H/NHru9XzLFqun9liAiSRoh5l8DcSqcJEmSJEmSWrFiSZKkUeINM0mSpG6Zfw3EiiVJkiRJkiS1YsWSJEmjZJm9nlaSJGnozL8G4sCSJEkjxLeSSJIkdcv8azBOhZMkSZIkSVIrVixJkjQqCl93K0mS1CXzr4FZsSRJkiRJkqRWrFiSJGmUeMdMkiSpW+ZfA3FgSZKkkVEmNpIkSZ0y/xqUU+EkSZIkSZLUihVLkiSNEm+YSZIkdcv8ayBWLEmSJEmSJKmVTiqWkhwKvA84kN5Y4NlV9ZZZbZ4LvBIIcDfw4qq6tNl2bbNuO7CtqtZ3EbckSV0KEO+YSZIkdcb8a3BdTYXbBpxeVd9MshfwjSSfrarv9LW5BnhyVd2R5HjgbOCn+7b/XFXd2lG8kiRJkiRJ2oVOBpaq6kbgxubz3UkuBw4GvtPX5h/7dvkqcEgXsUmSNDIK30oiSZLUJfOvgXX+8O4kRwCPAS7eSbPnA5/q+7mAv09SwDuq6ux5jn0acBrAYYcdtijxSpLUqRkTG0mSpE6Zfw2k04GlJGuBjwIvq6q75mnzc/QGlp7Ut/pJVXVDkgcAn01yRVV9afa+zYDT2QDr16/3X4YkSZIkSdIS6uytcElW0htU+mBVnTdPm0cB7wROrKrbdqyvqhua/94MfAx4wtJHLEnSMNQSLJIkSZqf+dcgOhlYShLgXcDlVfUX87Q5DDgPeF5VXdm3fs/mgd8k2RP4BeDbSx+1JEmSJEmSdqariqUnAs8D/lOSf26WZyR5UZIXNW1eA+wPvK3Zfkmz/kDgoiSXAl8DPllVn+4obkmSulW1+MsuJHl6ku8muSrJH86xfXWSDzfbL26el0iS/ZN8IcnGJGf1td8jySeTXJHksiT/czFPkSRJ0qIaQv4Fk5ODdfVWuIuA7KLNC4AXzLH+auDRSxSaJEmjYwiV00mmgb8Cfh64Hvh6kvOr6jt9zZ4P3FFVRyY5CTgT+FVgM/Bq4JHN0u/Pq+oLSVYBn0tyfFV9CkmSpFEypJlrk5SDdfaMJUmSNJKeAFxVVVdX1RbgXODEWW1OBN7bfP5b4ClJUlX3NDePNvc3rqpNVfWF5vMW4JvAIUvZCUmSpDEzMTmYA0uSJI2M6r3udrEXOCDJJX3LaX1fejBwXd/P1zfrmKtNVW0D7qQ3fX2XkuwLnAB8rtUpkSRJWlJDyb9ggnKwTqbCSZPs8zf8K++78hvcuOkuHrbvA3jh0T/L0fsdOOywJKnfrVW1vusvTbIC+BDw1mZqu0ZIkncDvwjcXFWzy+j72z0e+ApwUlX9bVfxSaOqagu16VzYfAHUvbD6WLLHb5LpBf2tJ2n5GEr+Bd3nYFYsSQM4/9rLeN0ln+X6ezawIlN867Yb+d2LPsbld9w87NAkja2ZJVh26gbg0L6fD2nWzdmmSVT2AW5bQGfOBv61qt68gLbq3jnA03fWoHn+w5nA33cRkDQO6q4z4J5zYGZT7wG9P/4UteF3qJl7hh2apNY6z79ggnIwB5aklrbPzPDXl3+VNStWsMeKVUxPTbHXqtVsrxnO+e7Xhh2epHHV/VtJvg48JMmDmoc8ngScP6vN+cApzednA5+v2vmBk7yBXvLzst09BepGVX0JuH0XzX4X+CjgHRMJqG3XwJavQvaBrIashKl9YeZW6t4vDDs8SW0N561wE5ODORVOaumurZvZuHULe61afZ/191uxkis23DKkqCRp91TVtiQvAT4DTAPvrqrLkpwBXFJV5wPvAt6f5Cp6AxEn7dg/ybXA3sCqJM8EfgG4C/gj4Argm0kAzqqqd3bWMQ0sycHAs4CfAx4/5HCk0bDtWmAKMuuF11Ww7Qp6s0sladcmKQdzYElqae3K1ayenmbrzHZWTk3/2/p7t2/jyL0PGGJkksZWscDK6UX+2qoLgQtnrXtN3+fNwHPm2feIeQ6bedZrfLwZeGVVzWT2H9F9moeRngZw2GGHdROZNCzTDwSaaoT+/y8SmD5iWFFJGsSQ8i+YnBzMqXBSSyunpjn5yMeyaetWtmzfTlXx421bmani1KO8sStJGnvrgXObO6LPBt7W3BG9j6o6u6rWV9X6devWdRyi1LEVR8GKh0HdCbUdagZm7oTsSdY8ddjRSdJQWLEkDeB5D30cK6em+OC/fpM7t2zmgXvsze884ok8bt0hww5N0rha2Jx8aclV1YN2fE5yDvCJqvr40AKSRkAS2OeN1Maz4N7PAdth1aPJ2peRqX2HHZ6ktsy/BuLAkjSAqYRfe8hjOenIx7Bl+zZWT69gZ9MFJEkaFUk+BBwHHJDkeuB/ACsBqurtQwxNGmmZWkv2/kOqXgHM0HvmriQtXw4sSYtgKmHNipXDDkPS2KtmkZZeVZ28G21PXcJQpLHUe/O3pPFn/jUofxtKkjRKLMWWJEnqlvnXQHx4tyRJkiRJklqxYkmSpFEy4x0zSZKkTpl/DcSKJUmSJEmSJLVixZIkSaOicI6/JElSl8y/BubAkiRJI8XERpIkqVvmX4NwKpwkSZIkSZJasWJJkqSRUT48UpIkqVPmX4OyYkmSJEmSJEmtWLEkSdKI6D070jtmkiRJXTH/GpwDS5IkjRITG0mSpG6Zfw3EqXCSJEmSJElqxYolSZJGRa8We9hRSJIkLR/mXwOzYkmSJEmSJEmtWLEkSdLIKJiZGXYQkiRJy4j516CsWJIkSZIkSVIrDixJkiRJkiSpFafCSZI0QspSbEmSpE6Zfw3GiiVJkiRJkiS1YsWSJEmjwtfdSpIkdcv8a2BWLEmSJEmSJKkVK5YkSRol3jCTJEnqlvnXQBxYkiRpZBSUD4+UJEnqjvnXoJwKJ0mSJEmSpFasWJIkaYTUjLXYkiRJXTL/GowVS5IkSZIkSWrFiiVJkkaFr7uVJEnqlvnXwBxYkiRphJSJjSRJUqfMvwbjVDhJkiRJkiS1YsWSJEkjw9fdSpIkdcv8a1BWLEmSJEmSJKmVTOpcwiS3AN8fdhy76QDg1mEHsYTs3/ib9D7av/G3VH08vKrWLcFx7yPJp+n1YbHdWlVPX4LjSvcxQvnXcvh915bnZm6el7l5XubnuZnbYp+XJc/BzL8GN7EDS+MoySVVtX7YcSwV+zf+Jr2P9m/8LYc+Sto1fxfMz3MzN8/L3Dwv8/PczM3zsjw5FU6SJEmSJEmtOLAkSZIkSZKkVhxYGi1nDzuAJWb/xt+k99H+jb/l0EdJu+bvgvl5bubmeZmb52V+npu5eV6WIZ+xJEmSJEmSpFasWJIkSZIkSVIrDixJkiRJkiSpFQeWJEmSJEmS1IoDSx1K8sUkm5NsbJbvztMuSc5McluznJkkXcfbxm708bVJtva125jkJ7uOt40kJyW5PMk9Sb6X5Nh52v1ekh8luSvJu5Os7jrWNhbSvySnJtk+6/od1320u2dWvBubPvzlTtqP1TXcnf6N8TU8IsmFSe5ors1ZSVbM0/bXkny/+bf88ST37zpeSUsryUOavOMD82wf23yjreWQb7a1HPLUtiY9v21rkvPitiY9n1Y7Dix17yVVtbZZjpqnzWnAM4FHA48CTgBe2FF8i2EhfQT4cF+7tVV1dWcRtpTk54Ezgd8A9gL+I/Dv4k7yNOAPgacAhwM/Cbyuu0jbWWj/Gl+Zdf2+2FGYrfXHC/wE8GPgb+ZqO47XcHf61xi7awi8DbgZeCBwDPBk4LdnN0ryCOAdwPOAA4FNzb6SJstfAV/fRZuxyzcWwXLIN9ua2Dy1rUnPb9ua9Ly4rUnPp9WOA0uj6RTgTVV1fVXdALwJOHW4IanxOuCMqvpqVc1U1Q3NNZrtFOBdVXVZVd0BvJ7xuIYL7d8k+GV6AxT/MM/2cb2GO+yqf+PqQcBHqmpzVf0I+DTwiDnaPRe4oKq+VFUbgVcDv5Rkrw5jlbSEkpwEbAA+N+RQxpX5pnaY9Py2reWUF7c16fm0FsiBpe69McmtSb68kxLJRwCX9v18KXP/4TSqFtJHgBOS3J7ksiQv7ii21pJMA+uBdUmuSnJ9Mw3nfnM0n+saHphk/y5ibWM3+wfwmOY6X5nk1fNNRxphpwDvq6qaZ/vYXcNZdtU/GM9r+GbgpCR7JDkYOJ7e4NJs97l+VfU9YAvw0C6ClLS0kuwNnAG8fAHNxyrfWCTLId9sayLz1LYmPb9taxnmxW1Nej6tBXJgqVuvpFf+dzBwNnBBkgfP0W4tcGffz3cCa8dk3vtC+/gR4OHAOuC3gNckObmzKNs5EFgJPBs4lt40nMcAfzxH27muIfTKaEfV7vTvS8AjgQfQu1NxMvD7nUS5CJIcTm8K1Xt30mwcryGw4P6N6zX8Er0k5S7geuAS4ONztJt9/Wh+HvnrJ2lBXk/vLvj1u2g3jvnGoJZDvtnWJOepbU16ftvWssmL25r0fFq7x4GlDlXVxVV1d1XdW1XvBb4MPGOOphuBvft+3hvYuIvKg5Gw0D5W1Xeq6odVtb2q/hF4C71f3KPsx81//7KqbqyqW4G/YOHXEODuJYxvUAvuX1VdXVXXNGXB/0LvrvGoX79+zwMuqqprdtJmHK/hDrvs3zhewyRT9KqTzgP2BA4A9qP3/IPZZl8/mp/H4fpJ2okkxwBPBf73rtqOab4xkOWQb7Y14XlqW5Oe37a1nPLitiY9n9ZucGBpuAqY667QZfQepLjDo5t142i+PrZtNzTNvODr6cX6b6vnaT7XNbypqm5bovAGtpv9+3e7M+LXb5b/ys7vrsAYXsM+C+nfbONwDe8PHAac1fxRcBvwHuZOfu9z/Zq3+awGruwiUElL6jjgCOAHSX4EvAL45STfXMC+4/C7brEth3yzrYnJU9ua9Py2rWWWF7c16fm0doMDSx1Jsm+SpyVZk2RFkufSe7PAXM8GeR/w8iQHJzkIOB04p8NwW9mdPiY5Mcl+6XkC8FLg77qOuYX3AL+b5AFJ9gN+D/jEHO3eBzw/ydFJ9qVXNntOZ1G2t6D+JTk+yYHN54fRezDyOFw/kvwHeiXwO3tbGozpNVxo/8bxGjZ3C68BXtz8jtmX3tz+b83R/IP0no9xbJI96d09PK+qvEMmjb+zgQfTm5pyDPB24JPA02Y3HON8o5XlkG+2tUzy1LYmPb9ta+Lz4rYmPZ9WC1Xl0sFCb4721+mV/W0Avgr8fLPtWHqlxzvaBvgz4PZm+TMgw+7DIvfxQ8Bt9MojrwBeOuz4F9jHlfReWb4B+BHwVmANvSqKjcBhfW1fDtxE71kw7wFWDzv+xeof8OdN3+6h99rVM4CVw45/gX18B/D+OdZPyjVcUP/G9RrS+yPyi8AdwK30noNxYLNtI3BsX9tfA37Q9PHvgPsPO34XF5fFX4DXAh9oPk9EvjHAuZj4fLOjc7Pc/t1MdH671OdlXHOqAc/NROfTLru/pLnYkiRJkiRJ0m5xKpwkSZIkSZJacWBJkiRJkiRJrTiwJEmSJEmSpFYcWJIkSZIkSVIrDixJkiRJkiSpFQeWJEmSJEmS1IoDS9IykOTaJE+dZ9s5Sd7QdUzNd88blyRJ0jhK8tokH5hn23FJru86pua7541LkgbhwJLUoSRPSvKPSe5McnuSLyd5/LDj6sIwB7AkSZKaG1o/TrIxyU1NbrJ2Aft9MckLuohxsQxzAEvS8uPAktSRJHsDnwD+Erg/cDDwOuDeYcYlSZK0jJxQVWuBxwLrgT8ecjySNPYcWJK681CAqvpQVW2vqh9X1d9X1bd2NEjym0kuT3JHks8kObxvWyV5aZKrk9ya5H8lmWq2PTjJ55Pc1mz7YJJ92wSZ5BeT/HOSDU111aP6tl2b5BVJvtVUXX04yZq+7X+Q5MYkP0zygibmI5OcBjwX+IPmLuEFfV95zHzHkyRJWgpVdQPwKeCRAEl+psl7NiS5NMlxzfo/AY4FzmpymLOa9W9Jcl2Su5J8I8mxbeJIclCSjya5Jck1SV7at+21ST6S5H1J7k5yWZL1fdsfm+Sfmm1/0+RRb0iyZ9O3g5qYNyY5qNlt1XzHk6S2HFiSunMlsD3Je5Mcn2S//o1JTgReBfwSsA74B+BDs47xLHp31x4LnAj85o7dgTcCBwEPBw4FXru7ASZ5DPBu4IXA/sA7gPOTrO5r9ivA04EHAY8CTm32fTrwcuCpwJHAcTt2qKqzgQ8Cf1ZVa6vqhF0dT5IkaakkORR4BvBPSQ4GPgm8gV5V+SuAjyZZV1V/RC8ne0mTw7ykOcTXgWOa9v8X+JvdvTnW3CC8ALiUXiX7U4CXJXlaX7P/ApwL7AucD+wY2FoFfAw4p4nhQ/TyRKrqHuB44IdNzGur6oc7O54kDcKBJakjVXUX8CSggL8GbklyfpIDmyYvAt5YVZdX1TbgT+lV8xzed5gzq+r2qvoB8Gbg5ObYV1XVZ6vq3qq6BfgL4MktwjwNeEdVXdxUVb2X3lS9n+lr89aq+mFV3U4vGTqmWf8rwHuq6rKq2sTCB7bmO54kSdJi+3iSDcBFwP+jl2/9OnBhVV1YVTNV9VngEnoDT3Oqqg9U1W1Vta2q3gSsBo7azVgeD6yrqjOqaktVXU0vRzypr81FTVzbgfcDj27W/wywgl4etbWqzgO+toDvnO94ktSaA0tSh5pBo1Or6hB6pdcH0RsgAjgceEtTgr0BuJ1eJdLBfYe4ru/z95v9SXJgknOT3JDkLuADwAEtQjwcOH1HDE0ch+74nsaP+j5vAnY89PKgWfH1f96Z+Y4nSZK02J5ZVftW1eFV9dtV9WN6+c9zZuU/TwIeON9BmkcDXN5M5d8A7MPu516H05uu1v+9rwIO7GszO09ak2QFvbzrhqqqvu0Lyb3mO54kteYvEWlIquqKJOfQm3YGvWTgT6rqgzvZ7VDgsubzYcCOsuY/pVcJ9VNVdXuSZ9KutHlHDH/SYt8bgUNmxdqvkCRJGj3XAe+vqt+aZ/t9cpjmeUp/QG/q2mVVNZPkDno3BHf3e6+pqofsbsD08q6Dk6RvcOlQ4HtzxSxJS8mKJakjSR6W5PQkhzQ/H0pvKttXmyZvB/57kkc02/dJ8pxZh/n9JPs1+/434MPN+r2AjcCdzXMCfr9lmH8NvCjJT6dnzyT/OcleC9j3I8BvJHl4kj2AV8/afhPwky3jkiRJWiofAE5I8rQk00nWJDluR87Gv89h9gK2AbcAK5K8Bti7xfd+Dbg7ySuT3K/57kcmefwC9v0KsB14SZIVzbM6n9C3/SZg/yT7tIhLknaLA0tSd+4Gfhq4OMk99AaUvg2cDlBVHwPOBM5tprN9m96DF/v9HfAN4J/pPWTyXc3619F7oPedzfrz2gRYVZcAv0Wv2ukO4CoW+DDtqvoU8FbgC81+OwbM7m3++y7g6KbU++Nt4pMkSVpsVXUdvZeivIreYNF19G7S7fhb6S3As9N7a+9bgc8An6b3YpbvA5tZ+CMA+r93O/CL9J4veQ1wK/BOetPqdrXvFnovfHk+sIHec6I+QZN3VdUV9B7ofXWTex00z6EkaWC577RcSaMqSQEPqaqrhh3LQiR5OL3BsdXNw8glSZK0RJJcDLy9qt4z7FgkLS9WLElaNEmelWR1kv3oVV9d4KCSJEnS4kvy5CQ/0UyFOwV4FL1KKknqlANLkhbTC4Gb6T04cjvw4uGGI0mSNLGOAi6lNxXudODZVXXjUCOStCw5FU6SJEmSJEmtWLEkSZIkSZKkVhxYkiRJkiRJUisOLEmSJEmSJKkVB5YkSZIkSZLUigNLkiRJkiRJauX/A1hZtlDJXvD7AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -314,8 +314,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Mean shapley value of corrupted points: -0.008934091047241414\n", - "Mean shapley value of regular points: 0.010925156715879228\n" + "Mean shapley value of corrupted points: -0.0008635032194620216\n", + "Mean shapley value of regular points: 0.01021608580386053\n" ] } ], @@ -347,7 +347,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -372,7 +372,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "dval_env", "language": "python", "name": "python3" }, @@ -390,7 +390,7 @@ }, "vscode": { "interpreter": { - "hash": "4e000971326892723e7f31ded70802f690c31c3620f59a0f99e594aaee3047ef" + "hash": "b3369ace3ad477f5e763d9fa7767e0177027059e92a8b1ded9e92b707c0b1513" } } }, diff --git a/notebooks/notebook_support.py b/notebooks/support/common.py similarity index 99% rename from notebooks/notebook_support.py rename to notebooks/support/common.py index 615d6031e..2219fc310 100644 --- a/notebooks/notebook_support.py +++ b/notebooks/support/common.py @@ -544,7 +544,7 @@ def plot_corrupted_influences_distribution( axes[idx].hist(non_corrupted_infl, label="Non corrupted", alpha=0.7) axes[idx].hist(corrupted_infl, label="Corrupted", alpha=0.7, color="green") axes[idx].set_xlabel("Influence values") - axes[idx].set_ylabel("Distribution") + axes[idx].set_ylabel("Number of samples") axes[idx].set_title(f"Influences for {label=}") axes[idx].legend() plt.show() diff --git a/notebooks/notebook_support_torch.py b/notebooks/support/torch.py similarity index 97% rename from notebooks/notebook_support_torch.py rename to notebooks/support/torch.py index 307f133c0..1c4851bec 100644 --- a/notebooks/notebook_support_torch.py +++ b/notebooks/support/torch.py @@ -1,7 +1,6 @@ import logging import os import pickle as pkl -from collections import namedtuple from pathlib import Path from typing import Callable, List, Optional, Tuple, Union @@ -16,11 +15,12 @@ from pydvl.utils import maybe_progress +from .types import Losses + logger = logging.getLogger(__name__) from numpy.typing import NDArray -Losses = namedtuple("Losses", "training val") MODEL_PATH = Path().resolve().parent / "data" / "models" @@ -202,9 +202,9 @@ def train( """ if use_cache: try: - training_loss, validation_loss = self.load() + losses = self.load() print("Cached model found, loading...") - return training_loss, validation_loss + return losses except: print(f"No pretrained model found. Training for {n_epochs} epochs:") diff --git a/notebooks/support/types.py b/notebooks/support/types.py new file mode 100644 index 000000000..d5c6123ed --- /dev/null +++ b/notebooks/support/types.py @@ -0,0 +1,3 @@ +from collections import namedtuple + +Losses = namedtuple("Losses", "training val") diff --git a/src/pydvl/influence/__init__.py b/src/pydvl/influence/__init__.py index 37f1ff9cf..fe8fa3f51 100644 --- a/src/pydvl/influence/__init__.py +++ b/src/pydvl/influence/__init__.py @@ -7,4 +7,5 @@ probably change. """ -from .general import * +from .frameworks import TwiceDifferentiable +from .general import calculate_influence_factors, compute_influences diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index b3059de2b..70b7ae04b 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -1,5 +1,40 @@ -from .torch_differentiable import * +import logging +import os + +from .base_twice_differentiable import BaseTwiceDifferentiable + +logger = logging.getLogger(__name__) + +available_frameworks = [] +try: + import torch + + available_frameworks.append("torch") +except ImportError: + pass + + +if available_frameworks == []: + raise ValueError("No supported framework is installed. Currently supported: torch.") +elif len(available_frameworks) > 1: + logger.warning( + f"There are multiple available frameworks: {available_frameworks}. " + f"Environment choice will default to {available_frameworks[0]}" + f"You can select the one you want to use by setting os.environ['FRAMEWORK']= preferred_framework" + ) + +FRAMEWORK = os.environ.get("FRAMEWORK", "Not Set") +if FRAMEWORK == "Not Set": + FRAMEWORK = available_frameworks[0] + +if FRAMEWORK == "torch": + from .torch_differentiable import TorchTwiceDifferentiable as TwiceDifferentiable + + TensorType = torch.Tensor + # etc. (or something like that) +else: + raise ValueError(f"Unknown framework: {FRAMEWORK}") __all__ = [ - "TorchTwiceDifferentiable", + "TwiceDifferentiable", ] diff --git a/src/pydvl/influence/types.py b/src/pydvl/influence/frameworks/base_twice_differentiable.py similarity index 57% rename from src/pydvl/influence/types.py rename to src/pydvl/influence/frameworks/base_twice_differentiable.py index 104d2859b..da757869c 100644 --- a/src/pydvl/influence/types.py +++ b/src/pydvl/influence/frameworks/base_twice_differentiable.py @@ -1,21 +1,12 @@ from abc import ABC -from typing import Optional, Tuple, Union - -try: - import torch - - _TORCH_INSTALLED = True -except ImportError: - _TORCH_INSTALLED = False +from typing import Generic, Optional, Tuple, TypeVar from numpy.typing import NDArray -__all__ = ["TwiceDifferentiable", "TensorType"] - -TensorType = Union[NDArray, "torch.Tensor"] +TensorType = TypeVar("TensorType") -class TwiceDifferentiable(ABC): +class BaseTwiceDifferentiable(ABC, Generic[TensorType]): def num_params(self) -> int: pass @@ -24,14 +15,15 @@ def split_grad( ) -> NDArray: """ Calculate the gradient of the model wrt each input x and labels y. - The output is therefore of size [Nxp], with N the amout of points (the length of x and y) and - P the number of parameters. + The output is therefore of size [Nxp], with N the amout of points (the + length of x and y) and P the number of parameters. """ pass def grad(self, x: TensorType, y: TensorType) -> Tuple[NDArray, TensorType]: """ - It calculates the gradient of model parameters with respect to input x and labels y. + It calculates the gradient of model parameters with respect to input x + and labels y. """ pass @@ -43,6 +35,9 @@ def mvp( backprop_on: Optional[TensorType] = None, ) -> NDArray: """ - Calculate the hessian vector product over the loss with all input parameters x and y with the vector v. + Calculates second order derivative of the model along directions v, + which can be a single vector or a matrix (thus the method must support + broadcasting). This second order derivative can be on the model parameters or on + another input parameter, selected via the backprop_on argument. """ pass diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 9f71187f7..b91ceddfb 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -2,24 +2,17 @@ Contains all parts of pyTorch based machine learning model. """ import logging -from typing import Callable, Optional, Tuple, Union +from typing import Callable, Optional, Tuple import numpy as np +import torch +import torch.nn as nn +from numpy.typing import NDArray +from torch import autograd +from torch.autograd import Variable from ...utils import maybe_progress -from ..types import TensorType, TwiceDifferentiable - -try: - import torch - import torch.nn as nn - from torch import autograd - from torch.autograd import Variable - - _TORCH_INSTALLED = True -except ImportError: - _TORCH_INSTALLED = False - -from numpy.typing import NDArray +from .base_twice_differentiable import BaseTwiceDifferentiable __all__ = [ "TorchTwiceDifferentiable", @@ -34,22 +27,20 @@ def flatten_gradient(grad): return torch.cat([el.reshape(-1) for el in grad]) -class TorchTwiceDifferentiable(TwiceDifferentiable): +class TorchTwiceDifferentiable(BaseTwiceDifferentiable[torch.Tensor]): """ Calculates second-derivative matrix vector products (Mvp) of a pytorch torch.nn.Module """ def __init__( self, - model: "nn.Module", - loss: Callable[["torch.Tensor", "torch.Tensor"], "torch.Tensor"], + model: nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], ): """ :param model: A torch.nn.Module representing a (differentiable) function f(x). :param loss: Loss function L(f(x), y) maps a prediction and a target to a single value. """ - if not _TORCH_INSTALLED: - raise RuntimeWarning("This function requires PyTorch.") if model.training: logger.warning( "Passed model not in evaluation mode. This can create several issues in influence " @@ -69,8 +60,8 @@ def num_params(self) -> int: def split_grad( self, - x: TensorType, - y: TensorType, + x: torch.Tensor, + y: torch.Tensor, progress: bool = False, ) -> NDArray: """ @@ -111,9 +102,9 @@ def split_grad( def grad( self, - x: TensorType, - y: TensorType, - ) -> Tuple[NDArray, "torch.Tensor"]: + x: torch.Tensor, + y: torch.Tensor, + ) -> Tuple[NDArray, torch.Tensor]: """ Calculates gradient of model parameters wrt x and y. :param x: A np.ndarray [NxD] representing the features x_i. @@ -137,10 +128,10 @@ def grad( def mvp( self, - grad_xy: TensorType, - v: TensorType, + grad_xy: torch.Tensor, + v: torch.Tensor, progress: bool = False, - backprop_on: Optional["torch.Tensor"] = None, + backprop_on: Optional[torch.Tensor] = None, ) -> NDArray: """ Calculates second order derivative of the model along directions v. diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index df565895d..4579a2648 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -5,21 +5,11 @@ from typing import Callable import numpy as np +from numpy.typing import NDArray from ..utils import maybe_progress -from .frameworks import TorchTwiceDifferentiable +from .frameworks import TensorType, TwiceDifferentiable from .inversion_methods import InversionMethod, invert_matrix -from .types import TensorType, TwiceDifferentiable - -try: - import torch - import torch.nn as nn - - _TORCH_INSTALLED = True -except ImportError: - _TORCH_INSTALLED = False - -from numpy.typing import NDArray __all__ = ["compute_influences", "InfluenceType", "calculate_influence_factors"] @@ -47,18 +37,16 @@ def calculate_influence_factors( Calculates the influence factors. For more info, see https://arxiv.org/pdf/1703.04730.pdf, paragraph 3. :param model: A model which has to implement the TwiceDifferentiable interface. - :param x_train: A np.ndarray of shape [MxK] containing the features of the input data points. - :param y_train: A np.ndarray of shape [MxL] containing the targets of the input data points. - :param x_test: A np.ndarray of shape [NxK] containing the features of the test set of data points. - :param y_test: A np.ndarray of shape [NxL] containing the targets of the test set of data points. + :param x_train: A matrix of shape [MxK] containing the features of the input data points. + :param y_train: A matrix of shape [MxL] containing the targets of the input data points. + :param x_test: A matrix of shape [NxK] containing the features of the test set of data points. + :param y_test: A matrix of shape [NxL] containing the targets of the test set of data points. :param inversion_func: function to use to invert the product of hvp (hessian vector product) and the gradient of the loss (s_test in the paper). :param lam: regularization of the hessian :param progress: If True, display progress bars. - :returns: A np.ndarray of size (N, D) containing the influence factors for each dimension (D) and test sample (N). + :returns: A matrix of size (N, D) containing the influence factors for each dimension (D) and test sample (N). """ - if not _TORCH_INSTALLED: - raise RuntimeWarning("This function requires PyTorch.") grad_xy, _ = model.grad(x, y) hvp = lambda v: model.mvp(grad_xy, v) + lam * v n_params = model.num_params() @@ -137,8 +125,7 @@ def _calculate_influences_pert( def compute_influences( - model: "nn.Module", - loss: Callable[["torch.Tensor", "torch.Tensor"], "torch.Tensor"], + differentiable_model: TwiceDifferentiable, x: TensorType, y: TensorType, x_test: TensorType, @@ -154,9 +141,7 @@ def compute_influences( get the influences over the complete training set. Points with low influence values are (on average) less important for model training than points with high influences. - :param model: A supervised model from a supported framework. Currently, only pytorch nn.Module is supported. - :param loss: loss of the model, a callable that, given prediction of the model and real labels, returns a - tensor with the loss value. + :param differentiable_model: A model wrapped with its loss in TwiceDifferentiable. :param x: model input for training :param y: input labels :param x_test: model input for testing @@ -173,10 +158,6 @@ def compute_influences( M number of train points. If instead influence_type is 'perturbation', output shape is [NxMxP], with P the number of input features. """ - if not _TORCH_INSTALLED: - raise RuntimeWarning("This function requires PyTorch.") - - differentiable_model = TorchTwiceDifferentiable(model, loss) influence_factors = calculate_influence_factors( differentiable_model, diff --git a/src/pydvl/influence/inversion_methods.py b/src/pydvl/influence/inversion_methods.py index 32990e294..6ce065360 100644 --- a/src/pydvl/influence/inversion_methods.py +++ b/src/pydvl/influence/inversion_methods.py @@ -13,6 +13,7 @@ from scipy.sparse.linalg import LinearOperator, cg from ..utils import maybe_progress +from .frameworks import TensorType __all__ = ["matrix_inversion_algorithm", "conjugate_gradient"] @@ -30,30 +31,30 @@ class InversionMethod(str, Enum): def invert_matrix( inversion_method: InversionMethod, - mvp: Callable[[NDArray], NDArray], + mvp: Callable[[TensorType], NDArray[np.float_]], mvp_dimensions: Tuple[int, int], - b: NDArray, + b: NDArray[np.float_], progress: bool = False, -) -> NDArray: +) -> NDArray[np.float_]: """ - It solves the problem of finding x such that Ax = b, where A is a matrix (of - size mvp_dimensions), and b a vector. + Finds $x$ such that $Ax = b$, where $A$ is a matrix of size ``mvp_dimensions``), + and $b$ a vector. Instead of passing the matrix A directly, the method takes its mvp, i.e. a (callable) matrix vector product that returns the product Ax for any vector x. This is done to avoid storing a (potentially very large) matrix in memory. :param inversion_method: - :param mvp: matrix vector product, a callable that, given any array x, - returns the result of Ax. - :param mvp_dimensions: dimensions of matrix A + :param mvp: matrix vector product, a callable that, given any array $x$, + returns the result of $Ax$. + :param mvp_dimensions: dimensions of matrix $A$ :param b: :param progress: If True, display progress bars. :return: An array that solves the inverse problem, - i.e. it returns x such that Ax = b + i.e. it returns $x$ such that $Ax = b$ """ if inversion_method == InversionMethod.Direct: - return np.linalg.solve(mvp(np.eye(mvp_dimensions[1])), b.T).T + return np.matmul(np.linalg.inv(mvp(np.eye(mvp_dimensions[1]))), b.T).T elif inversion_method == InversionMethod.Cg: return conjugate_gradient( LinearOperator(mvp_dimensions, matvec=mvp), b, progress @@ -63,17 +64,17 @@ def invert_matrix( def conjugate_gradient( - A: NDArray[np.float_], batch_y: NDArray[np.float_], progress: bool = False + A: LinearOperator, batch_y: NDArray[np.float_], progress: bool = False ) -> NDArray[np.float_]: """ Given a matrix and a batch of vectors, it uses conjugate gradient to calculate the solution - to Ax = y for each y in batch_y. + to $Ax = y$ for each $y$ in ``batch_y``. :param A: a real, symmetric and positive-definite matrix of shape [NxN] :param batch_y: a matrix of shape [PxN], with P the size of the batch. :param progress: True, iff progress shall be printed. - :return: A NDArray of shape [PxN] with each line being a solution of Ax=b. + :return: A matrix of shape [PxN] with each line being a solution of $Ax=b$. """ batch_cg = [] for y in maybe_progress(batch_y, progress, desc="Conjugate gradient"): diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 9eabee16c..4ee930560 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -4,7 +4,8 @@ import numpy as np import pytest -from pydvl.influence.general import InfluenceType, InversionMethod, compute_influences +from pydvl.influence import TwiceDifferentiable, compute_influences +from pydvl.influence.general import InfluenceType, InversionMethod from .conftest import ( add_noise_to_linear_model, @@ -87,8 +88,7 @@ def test_influence_linear_model( ) direct_influences = compute_influences( - linear_layer, - loss, + TwiceDifferentiable(linear_layer, loss), *train_data, *test_data, progress=True, @@ -98,8 +98,7 @@ def test_influence_linear_model( ) cg_influences = compute_influences( - linear_layer, - loss, + TwiceDifferentiable(linear_layer, loss), *train_data, *test_data, progress=True, @@ -202,8 +201,7 @@ def test_influences_nn( multiple_influences = [] for inversion_method in InversionMethod: influences = compute_influences( - nn_architecture, - loss, + TwiceDifferentiable(nn_architecture, loss), x_train, y_train, x_test, diff --git a/tests/influence/test_torch_differentiable.py b/tests/influence/test_torch_differentiable.py index 612bdd993..cb1a0ff2b 100644 --- a/tests/influence/test_torch_differentiable.py +++ b/tests/influence/test_torch_differentiable.py @@ -22,7 +22,7 @@ import torch.nn.functional as F from torch import nn -from pydvl.influence.frameworks import TorchTwiceDifferentiable +from pydvl.influence.frameworks.torch_differentiable import TorchTwiceDifferentiable class ModelTestSettings: From 8fc3e0a93b55bd5b93ad127f7fb4a67106c601e0 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 28 Feb 2023 16:25:10 +0100 Subject: [PATCH 018/436] fix typing --- .../frameworks/base_twice_differentiable.py | 12 ++++++++++-- .../influence/frameworks/torch_differentiable.py | 2 +- src/pydvl/influence/inversion_methods.py | 2 +- 3 files changed, 12 insertions(+), 4 deletions(-) diff --git a/src/pydvl/influence/frameworks/base_twice_differentiable.py b/src/pydvl/influence/frameworks/base_twice_differentiable.py index da757869c..af22cdce4 100644 --- a/src/pydvl/influence/frameworks/base_twice_differentiable.py +++ b/src/pydvl/influence/frameworks/base_twice_differentiable.py @@ -1,12 +1,20 @@ from abc import ABC -from typing import Generic, Optional, Tuple, TypeVar +from typing import Callable, Generic, Optional, Tuple, TypeVar from numpy.typing import NDArray TensorType = TypeVar("TensorType") +ModelType = TypeVar("ModelType") -class BaseTwiceDifferentiable(ABC, Generic[TensorType]): +class BaseTwiceDifferentiable(ABC, Generic[TensorType, ModelType]): + def __init__( + self, + model: ModelType, + loss: Callable[[TensorType, TensorType], TensorType], + ): + pass + def num_params(self) -> int: pass diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index b91ceddfb..75d863cd2 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -27,7 +27,7 @@ def flatten_gradient(grad): return torch.cat([el.reshape(-1) for el in grad]) -class TorchTwiceDifferentiable(BaseTwiceDifferentiable[torch.Tensor]): +class TorchTwiceDifferentiable(BaseTwiceDifferentiable[torch.Tensor, nn.Module]): """ Calculates second-derivative matrix vector products (Mvp) of a pytorch torch.nn.Module """ diff --git a/src/pydvl/influence/inversion_methods.py b/src/pydvl/influence/inversion_methods.py index 6ce065360..4cafe610a 100644 --- a/src/pydvl/influence/inversion_methods.py +++ b/src/pydvl/influence/inversion_methods.py @@ -54,7 +54,7 @@ def invert_matrix( i.e. it returns $x$ such that $Ax = b$ """ if inversion_method == InversionMethod.Direct: - return np.matmul(np.linalg.inv(mvp(np.eye(mvp_dimensions[1]))), b.T).T + return (np.linalg.inv(mvp(np.eye(mvp_dimensions[1]))) @ b.T).T elif inversion_method == InversionMethod.Cg: return conjugate_gradient( LinearOperator(mvp_dimensions, matvec=mvp), b, progress From 9d79a9bcb9f7323106814799bec404b0d10851e6 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 28 Feb 2023 17:05:50 +0100 Subject: [PATCH 019/436] minor changes to docstrings --- .../frameworks/torch_differentiable.py | 48 +++++++------ src/pydvl/influence/general.py | 68 +++++++++++-------- src/pydvl/influence/inversion_methods.py | 3 +- tests/influence/conftest.py | 1 + 4 files changed, 71 insertions(+), 49 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 75d863cd2..a49a9fdde 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -38,8 +38,8 @@ def __init__( loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], ): """ - :param model: A torch.nn.Module representing a (differentiable) function f(x). - :param loss: Loss function L(f(x), y) maps a prediction and a target to a single value. + :param model: A torch.nn.Module representing a (differentiable) function. + :param loss: Loss function $L(f(x), y)$ maps a prediction and a target to a single value. """ if model.training: logger.warning( @@ -65,13 +65,14 @@ def split_grad( progress: bool = False, ) -> NDArray: """ - Calculates gradient of model parameters wrt each x[i] and y[i] and then + Calculates gradient of model parameters wrt each $x[i]$ and $y[i]$ and then returns a array of size [N, P] with N number of points (length of x and y) and P number of parameters of the model. - :param x: A np.ndarray [NxD] representing the features x_i. - :param y: A np.ndarray [NxK] representing the predicted target values y_i. + :param x: A np.ndarray [NxD] representing the features $x_i$. + :param y: A np.ndarray [NxK] representing the predicted target values $y_i$. :param progress: True, iff progress shall be printed. - :returns: A np.ndarray [NxP] representing the gradients with respect to all parameters of the model. + :returns: A np.ndarray [NxP] representing the gradients with respect to + all parameters of the model. """ x = torch.as_tensor(x).unsqueeze(1) y = torch.as_tensor(y) @@ -106,12 +107,12 @@ def grad( y: torch.Tensor, ) -> Tuple[NDArray, torch.Tensor]: """ - Calculates gradient of model parameters wrt x and y. - :param x: A np.ndarray [NxD] representing the features x_i. - :param y: A np.ndarray [NxK] representing the predicted target values y_i. + Calculates gradient of model parameters wrt $x$ and $y$. + :param x: A matrix [NxD] representing the features $x_i$. + :param y: A matrix [NxK] representing the predicted target values $y_i$. :param progress: True, iff progress shall be printed. :returns: A tuple where: \ - - first element is a np.ndarray [P] with the gradients of the model. \ + - first element is an array [P] with the gradients of the model. \ - second element is the input to the model as a grad parameters. \ This can be used for further differentiation. """ @@ -135,18 +136,23 @@ def mvp( ) -> NDArray: """ Calculates second order derivative of the model along directions v. - This second order derivative can be on the model parameters or on another input parameter, - selected via the backprop_on argument. - - :param grad_xy: an array [P] holding the gradients of the model parameters wrt input x and labels y, \ - where P is the number of parameters of the model. It is typically obtained through self.grad. - :param v: A np.ndarray [DxP] or a one dimensional np.array [D] which multiplies the Hessian, \ - where D is the number of directions. + This second order derivative can be on the model parameters or on + another input parameter, selected via the backprop_on argument. + + :param grad_xy: an array [P] holding the gradients of the model + parameters wrt input $x$ and labels $y$, where P is the number of + parameters of the model. It is typically obtained through + self.grad. + :param v: A np.ndarray [DxP] or a one dimensional np.array [D] which + multiplies the Hessian, where D is the number of directions. :param progress: True, iff progress shall be printed. - :param backprop_on: tensor used in the second backpropagation (the first one is along x and y as defined \ - via grad_xy). If None, the model parameters are used. - :returns: A np.ndarray representing the implicit matrix vector product of the model along the given directions.\ - Output shape is [DxP] if backprop_on is None, otherwise [DxM], with M the number of elements of backprop_on. + :param backprop_on: tensor used in the second backpropagation (the first + one is along $x$ and $y$ as defined via grad_xy). If None, the model + parameters are used. + :returns: A matrix representing the implicit matrix vector product + of the model along the given directions. Output shape is [DxP] if + backprop_on is None, otherwise [DxM], with M the number of elements + of backprop_on. """ v = torch.as_tensor(v) if v.ndim == 1: diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 4579a2648..417f44435 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -34,18 +34,20 @@ def calculate_influence_factors( progress: bool = False, ) -> NDArray: """ - Calculates the influence factors. For more info, see https://arxiv.org/pdf/1703.04730.pdf, paragraph 3. + Calculates the influence factors. For more info, see + https://arxiv.org/pdf/1703.04730.pdf, paragraph 3. :param model: A model which has to implement the TwiceDifferentiable interface. :param x_train: A matrix of shape [MxK] containing the features of the input data points. :param y_train: A matrix of shape [MxL] containing the targets of the input data points. :param x_test: A matrix of shape [NxK] containing the features of the test set of data points. :param y_test: A matrix of shape [NxL] containing the targets of the test set of data points. - :param inversion_func: function to use to invert the product of hvp (hessian vector product) and the gradient - of the loss (s_test in the paper). + :param inversion_func: function to use to invert the product of hvp (hessian + vector product) and the gradient of the loss (s_test in the paper). :param lam: regularization of the hessian :param progress: If True, display progress bars. - :returns: A matrix of size (N, D) containing the influence factors for each dimension (D) and test sample (N). + :returns: A matrix of size (N, D) containing the influence factors for each + dimension (D) and test sample (N). """ grad_xy, _ = model.grad(x, y) hvp = lambda v: model.mvp(grad_xy, v) + lam * v @@ -68,15 +70,19 @@ def _calculate_influences_up( progress: bool = False, ) -> NDArray: """ - Calculates the influence from the influence factors and the scores of the training points. - Uses the upweighting method, as described in section 2.1 of https://arxiv.org/pdf/1703.04730.pdf + Calculates the influence from the influence factors and the scores of the + training points. Uses the upweighting method, as described in section 2.1 of + https://arxiv.org/pdf/1703.04730.pdf :param model: A model which has to implement the TwiceDifferentiable interface. - :param x_train: A np.ndarray of shape [MxK] containing the features of the input data points. - :param y_train: A np.ndarray of shape [MxL] containing the targets of the input data points. + :param x_train: A np.ndarray of shape [MxK] containing the features of the + input data points. + :param y_train: A np.ndarray of shape [MxL] containing the targets of the + input data points. :param influence_factors: np.ndarray containing influence factors :param progress: If True, display progress bars. - :returns: A np.ndarray of size [NxM], where N is number of test points and M number of train points. + :returns: A np.ndarray of size [NxM], where N is number of test points and M + number of train points. """ train_grads = model.split_grad(x, y, progress) return np.einsum("ta,va->tv", influence_factors, train_grads) # type: ignore @@ -90,16 +96,19 @@ def _calculate_influences_pert( progress: bool = False, ) -> NDArray: """ - Calculates the influence from the influence factors and the scores of the training points. - Uses the perturbation method, as described in section 2.2 of https://arxiv.org/pdf/1703.04730.pdf + Calculates the influence from the influence factors and the scores of the + training points. Uses the perturbation method, as described in section 2.2 + of https://arxiv.org/pdf/1703.04730.pdf :param model: A model which has to implement the TwiceDifferentiable interface. - :param x_train: A np.ndarray of shape [MxK] containing the features of the input data points. - :param y_train: A np.ndarray of shape [MxL] containing the targets of the input data points. + :param x_train: A np.ndarray of shape [MxK] containing the features of the + input data points. + :param y_train: A np.ndarray of shape [MxL] containing the targets of the + input data points. :param influence_factors: np.ndarray containing influence factors :param progress: If True, display progress bars. - :returns: A np.ndarray of size [NxMxP], where N is number of test points, M number of train points, - and P the number of features. + :returns: A np.ndarray of size [NxMxP], where N is number of test points, M + number of train points, and P the number of features. """ all_pert_influences = [] for i in maybe_progress( @@ -136,9 +145,10 @@ def compute_influences( hessian_regularization: float = 0, ) -> NDArray: """ - Calculates the influence of the training points j on the test points i. First it calculates - the influence factors for all test points with respect to the training points, and then uses them to - get the influences over the complete training set. Points with low influence values are (on average) + Calculates the influence of the training points j on the test points i. + First it calculates the influence factors for all test points with respect + to the training points, and then uses them to get the influences over the + complete training set. Points with low influence values are (on average) less important for model training than points with high influences. :param differentiable_model: A model wrapped with its loss in TwiceDifferentiable. @@ -147,16 +157,20 @@ def compute_influences( :param x_test: model input for testing :param y_test: test labels :param progress: whether to display progress bars. - :param inversion_method: Set the inversion method to a specific one, can be 'direct' for direct inversion - (and explicit construction of the Hessian) or 'cg' for conjugate gradient. + :param inversion_method: Set the inversion method to a specific one, can be + 'direct' for direct inversion (and explicit construction of the Hessian) + or 'cg' for conjugate gradient. :param influence_type: Which algorithm to use to calculate influences. - Currently supported options: 'up' or 'perturbation'. For details refer to https://arxiv.org/pdf/1703.04730.pdf - :param hessian_regularization: lambda to use in Hessian regularization, i.e. H_reg = H + lambda * 1, with 1 the identity matrix \ - and H the (simple and regularized) Hessian. Typically used with more complex models to make sure the Hessian \ - is positive definite. - :returns: A np.ndarray specifying the influences. Shape is [NxM] if influence_type is'up', where N is number of test points and - M number of train points. If instead influence_type is 'perturbation', output shape is [NxMxP], with P the number of input - features. + Currently supported options: 'up' or 'perturbation'. For details refer + to https://arxiv.org/pdf/1703.04730.pdf + :param hessian_regularization: lambda to use in Hessian regularization, i.e. + H_reg = H + lambda * 1, with 1 the identity matrix and H the (simple and + regularized) Hessian. Typically used with more complex models to make + sure the Hessian is positive definite. + :returns: A np.ndarray specifying the influences. Shape is [NxM] if + influence_type is'up', where N is number of test points and M number of + train points. If instead influence_type is 'perturbation', output shape + is [NxMxP], with P the number of input features. """ influence_factors = calculate_influence_factors( diff --git a/src/pydvl/influence/inversion_methods.py b/src/pydvl/influence/inversion_methods.py index 4cafe610a..fe062978b 100644 --- a/src/pydvl/influence/inversion_methods.py +++ b/src/pydvl/influence/inversion_methods.py @@ -68,7 +68,8 @@ def conjugate_gradient( ) -> NDArray[np.float_]: """ Given a matrix and a batch of vectors, it uses conjugate gradient to calculate the solution - to $Ax = y$ for each $y$ in ``batch_y``. + to $Ax = y$ for each $y$ in ``batch_y``. For more info: + https://en.wikipedia.org/wiki/Conjugate_gradient_method :param A: a real, symmetric and positive-definite matrix of shape [NxN] :param batch_y: a matrix of shape [PxN], with P the size of the batch. diff --git a/tests/influence/conftest.py b/tests/influence/conftest.py index ca6de7608..13b054743 100644 --- a/tests/influence/conftest.py +++ b/tests/influence/conftest.py @@ -5,6 +5,7 @@ from numpy.typing import NDArray from sklearn.preprocessing import MinMaxScaler +torch = pytest.importorskip("torch") from pydvl.influence.general import InfluenceType from pydvl.utils import Dataset, random_matrix_with_condition_number From b482d21c6262900e0732567a945a4722bc34610f Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 28 Feb 2023 17:30:43 +0100 Subject: [PATCH 020/436] minor changes to conftest and docstrings --- src/pydvl/influence/frameworks/torch_differentiable.py | 2 +- tests/influence/conftest.py | 9 +++++---- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index a49a9fdde..847f57882 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -72,7 +72,7 @@ def split_grad( :param y: A np.ndarray [NxK] representing the predicted target values $y_i$. :param progress: True, iff progress shall be printed. :returns: A np.ndarray [NxP] representing the gradients with respect to - all parameters of the model. + all parameters of the model. """ x = torch.as_tensor(x).unsqueeze(1) y = torch.as_tensor(y) diff --git a/tests/influence/conftest.py b/tests/influence/conftest.py index 13b054743..acb802867 100644 --- a/tests/influence/conftest.py +++ b/tests/influence/conftest.py @@ -59,8 +59,7 @@ def linear_derivative_analytical( :param linear_model: A tuple of arrays representing the linear model. :param x: array, input to the linear model :param y: array, output of the linear model - :returns: An array where each row holds $[\partial_\theta L(x, y), - \partial_{\theta'} L(x, y)]$ + :returns: An array where each row holds the derivative over $\theta$ of $L(x, y)]$ """ A, b = linear_model @@ -87,7 +86,8 @@ def linear_hessian_analytical( :param x: array, input to the linear model :param y: array, output of the linear model :param lam: hessian regularization parameter - :returns: An matrix where each entry i,j holds $\partial_{\theta_i} \ \partial_{\theta_j} L(x, y)$ + :returns: An matrix where each entry i,j holds the second derivatives over $\theta$ + of $L(x, y)$ """ A, b = linear_model n, m = tuple(A.shape) @@ -118,7 +118,8 @@ def linear_mixed_second_derivative_analytical( :param linear_model: A tuple of arrays representing the linear model. :param x: array, input to the linear model :param y: array, output of the linear model - :returns: An matrix where each entry i,j holds $\partial_{\theta_i} \ \partial_{x_j} L(x, y)$ + :returns: An matrix where each entry i,j holds the mixed second derivatives + over $\theta$ and $x$ of $L(x, y)$ """ A, b = linear_model From 3a863b3ce447e0b7ba4dba6bfab3d3e11b5ffc49 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 28 Feb 2023 20:03:17 +0100 Subject: [PATCH 021/436] fix test --- tests/influence/conftest.py | 56 ------------------------- tests/influence/test_influences.py | 66 +++++++++++++++++++++++++++--- 2 files changed, 61 insertions(+), 61 deletions(-) diff --git a/tests/influence/conftest.py b/tests/influence/conftest.py index acb802867..59790b726 100644 --- a/tests/influence/conftest.py +++ b/tests/influence/conftest.py @@ -5,8 +5,6 @@ from numpy.typing import NDArray from sklearn.preprocessing import MinMaxScaler -torch = pytest.importorskip("torch") -from pydvl.influence.general import InfluenceType from pydvl.utils import Dataset, random_matrix_with_condition_number @@ -165,60 +163,6 @@ def linear_analytical_influence_factors( return np.linalg.solve(hessian_analytical, test_grads_analytical.T).T -def analytical_linear_influences( - linear_model: Tuple[NDArray[np.float_], NDArray[np.float_]], - x: NDArray[np.float_], - y: NDArray[np.float_], - x_test: NDArray[np.float_], - y_test: NDArray[np.float_], - influence_type: InfluenceType = InfluenceType.Up, - hessian_regularization: float = 0, -): - """Calculates analytically the influence of each training sample on the - test samples for an ordinary least squares model (Ax+b=y with quadratic - loss). - - :param linear_model: A tuple of arrays of shapes (N, M) and N representing A - and b respectively. - :param x: An array of shape (M, K) containing the features of the - training set. - :param y: An array of shape (M, L) containing the targets of the - training set. - :param x_test: An array of shape (N, K) containing the features of the test - set. - :param y_test: An array of shape (N, L) containing the targets of the test - set. - :param influence_type: the type of the influence. - :param hessian_retularization: regularization value for the hessian - :returns: An array of shape (B, C) with the influences of the training points - on the test points if influence_type is "up", an array of shape (K, L, - M) if influence_type is "perturbation". - """ - - s_test_analytical = linear_analytical_influence_factors( - linear_model, x, y, x_test, y_test, hessian_regularization - ) - if influence_type == InfluenceType.Up: - train_grads_analytical = linear_derivative_analytical( - linear_model, - x, - y, - ) - result: NDArray = np.einsum( - "ia,ja->ij", s_test_analytical, train_grads_analytical - ) - elif influence_type == InfluenceType.Perturbation: - train_second_deriv_analytical = linear_mixed_second_derivative_analytical( - linear_model, - x, - y, - ) - result: NDArray = np.einsum( - "ia,jab->ijb", s_test_analytical, train_second_deriv_analytical - ) - return result - - def add_noise_to_linear_model( linear_model: Tuple[NDArray[np.float_], NDArray[np.float_]], train_set_size: int, diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 4ee930560..faf4f38b5 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -4,20 +4,76 @@ import numpy as np import pytest +torch = pytest.importorskip("torch") +import torch +import torch.nn.functional as F +from numpy.typing import NDArray +from torch import nn + from pydvl.influence import TwiceDifferentiable, compute_influences from pydvl.influence.general import InfluenceType, InversionMethod from .conftest import ( add_noise_to_linear_model, - analytical_linear_influences, + linear_analytical_influence_factors, + linear_derivative_analytical, + linear_mixed_second_derivative_analytical, linear_model, ) -torch = pytest.importorskip("torch") -import torch -import torch.nn.functional as F -from torch import nn +def analytical_linear_influences( + linear_model: Tuple[NDArray[np.float_], NDArray[np.float_]], + x: NDArray[np.float_], + y: NDArray[np.float_], + x_test: NDArray[np.float_], + y_test: NDArray[np.float_], + influence_type: InfluenceType = InfluenceType.Up, + hessian_regularization: float = 0, +): + """Calculates analytically the influence of each training sample on the + test samples for an ordinary least squares model (Ax+b=y with quadratic + loss). + + :param linear_model: A tuple of arrays of shapes (N, M) and N representing A + and b respectively. + :param x: An array of shape (M, K) containing the features of the + training set. + :param y: An array of shape (M, L) containing the targets of the + training set. + :param x_test: An array of shape (N, K) containing the features of the test + set. + :param y_test: An array of shape (N, L) containing the targets of the test + set. + :param influence_type: the type of the influence. + :param hessian_retularization: regularization value for the hessian + :returns: An array of shape (B, C) with the influences of the training points + on the test points if influence_type is "up", an array of shape (K, L, + M) if influence_type is "perturbation". + """ + + s_test_analytical = linear_analytical_influence_factors( + linear_model, x, y, x_test, y_test, hessian_regularization + ) + if influence_type == InfluenceType.Up: + train_grads_analytical = linear_derivative_analytical( + linear_model, + x, + y, + ) + result: NDArray = np.einsum( + "ia,ja->ij", s_test_analytical, train_grads_analytical + ) + elif influence_type == InfluenceType.Perturbation: + train_second_deriv_analytical = linear_mixed_second_derivative_analytical( + linear_model, + x, + y, + ) + result: NDArray = np.einsum( + "ia,jab->ijb", s_test_analytical, train_second_deriv_analytical + ) + return result class InfluenceTestSettings: From ac114a3d73256c5e2325bfd3b58e1a1236dedd42 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 1 Mar 2023 12:51:58 +0100 Subject: [PATCH 022/436] improve influence docs --- docs/pydvl.bib | 16 +++++ docs/valuation/index.rst | 11 ++++ docs/valuation/influence.rst | 14 +++++ docs/valuation/influence/frameworks.rst | 14 +++++ docs/valuation/influence/model_wrappers.rst | 14 +++++ docs/valuation/loo.rst | 14 +++++ docs/valuation/reporting.rst | 14 +++++ docs/valuation/shapley.rst | 14 +++++ docs/valuation/utils.rst | 14 +++++ docs/valuation/utils/parallel.rst | 14 +++++ src/pydvl/influence/general.py | 66 +++++++++++++-------- tests/influence/test_influences.py | 4 +- 12 files changed, 181 insertions(+), 28 deletions(-) create mode 100644 docs/valuation/index.rst create mode 100644 docs/valuation/influence.rst create mode 100644 docs/valuation/influence/frameworks.rst create mode 100644 docs/valuation/influence/model_wrappers.rst create mode 100644 docs/valuation/loo.rst create mode 100644 docs/valuation/reporting.rst create mode 100644 docs/valuation/shapley.rst create mode 100644 docs/valuation/utils.rst create mode 100644 docs/valuation/utils/parallel.rst diff --git a/docs/pydvl.bib b/docs/pydvl.bib index 2a35ee51b..f6aca21f8 100644 --- a/docs/pydvl.bib +++ b/docs/pydvl.bib @@ -50,6 +50,22 @@ @article{jia_efficient_2019a langid = {english} } +@inproceedings{koh_understanding_2017, + title = {Understanding {{Black-box Predictions}} via {{Influence Functions}}}, + booktitle = {Proceedings of the 34th {{International Conference}} on {{Machine Learning}}}, + author = {Koh, Pang Wei and Liang, Percy}, + year = {2017}, + month = jul, + eprint = {1703.04730}, + eprinttype = {arxiv}, + pages = {1885--1894}, + publisher = {{PMLR}}, + abstract = {How can we explain the predictions of a black-box model? In this paper, we use influence functions \textemdash{} a classic technique from robust statistics \textemdash{} to trace a model's prediction through the learning algorithm and back to its training data, thereby identifying training points most responsible for a given prediction. To scale up influence functions to modern machine learning settings, we develop a simple, efficient implementation that requires only oracle access to gradients and Hessian-vector products. We show that even on non-convex and non-differentiable models where the theory breaks down, approximations to influence functions can still provide valuable information. On linear models and convolutional neural networks, we demonstrate that influence functions are useful for multiple purposes: understanding model behavior, debugging models, detecting dataset errors, and even creating visually-indistinguishable training-set attacks.}, + archiveprefix = {arXiv}, + langid = {english}, + file = {/Users/fabio/Zotero/storage/HW6BK957/D9MZ9MUI.pdf;/Users/fabio/Zotero/storage/J4YQYLEN/Koh and Liang - 2017 - Understanding Black-box Predictions via Influence .pdf;/Users/fabio/Zotero/storage/MHFVLFHJ/Koh and Liang - 2017 - Understanding Black-box Predictions via Influence .pdf} +} + @inproceedings{kwon_beta_2022, title = {Beta {{Shapley}}: A {{Unified}} and {{Noise-reduced Data Valuation Framework}} for {{Machine Learning}}}, shorttitle = {Beta {{Shapley}}}, diff --git a/docs/valuation/index.rst b/docs/valuation/index.rst new file mode 100644 index 000000000..3b471ff72 --- /dev/null +++ b/docs/valuation/index.rst @@ -0,0 +1,11 @@ +API Reference +============= + +.. automodule:: valuation + :members: + :undoc-members: + +.. toctree:: + :glob: + + * diff --git a/docs/valuation/influence.rst b/docs/valuation/influence.rst new file mode 100644 index 000000000..e2b6b5ca5 --- /dev/null +++ b/docs/valuation/influence.rst @@ -0,0 +1,14 @@ +influence +========= + +.. automodule:: valuation.influence + :members: + :undoc-members: + +.. rubric:: Modules in this package + +.. toctree:: + :glob: + + influence/* + diff --git a/docs/valuation/influence/frameworks.rst b/docs/valuation/influence/frameworks.rst new file mode 100644 index 000000000..248bf9423 --- /dev/null +++ b/docs/valuation/influence/frameworks.rst @@ -0,0 +1,14 @@ +frameworks +========== + +.. automodule:: valuation.influence.frameworks + :members: + :undoc-members: + +.. rubric:: Modules in this package + +.. toctree:: + :glob: + + frameworks/* + diff --git a/docs/valuation/influence/model_wrappers.rst b/docs/valuation/influence/model_wrappers.rst new file mode 100644 index 000000000..03e779b0d --- /dev/null +++ b/docs/valuation/influence/model_wrappers.rst @@ -0,0 +1,14 @@ +model\_wrappers +=============== + +.. automodule:: valuation.influence.model_wrappers + :members: + :undoc-members: + +.. rubric:: Modules in this package + +.. toctree:: + :glob: + + model_wrappers/* + diff --git a/docs/valuation/loo.rst b/docs/valuation/loo.rst new file mode 100644 index 000000000..064c8e0b1 --- /dev/null +++ b/docs/valuation/loo.rst @@ -0,0 +1,14 @@ +loo +=== + +.. automodule:: valuation.loo + :members: + :undoc-members: + +.. rubric:: Modules in this package + +.. toctree:: + :glob: + + loo/* + diff --git a/docs/valuation/reporting.rst b/docs/valuation/reporting.rst new file mode 100644 index 000000000..adc81e949 --- /dev/null +++ b/docs/valuation/reporting.rst @@ -0,0 +1,14 @@ +reporting +========= + +.. automodule:: valuation.reporting + :members: + :undoc-members: + +.. rubric:: Modules in this package + +.. toctree:: + :glob: + + reporting/* + diff --git a/docs/valuation/shapley.rst b/docs/valuation/shapley.rst new file mode 100644 index 000000000..3929a7eb0 --- /dev/null +++ b/docs/valuation/shapley.rst @@ -0,0 +1,14 @@ +shapley +======= + +.. automodule:: valuation.shapley + :members: + :undoc-members: + +.. rubric:: Modules in this package + +.. toctree:: + :glob: + + shapley/* + diff --git a/docs/valuation/utils.rst b/docs/valuation/utils.rst new file mode 100644 index 000000000..70b958d51 --- /dev/null +++ b/docs/valuation/utils.rst @@ -0,0 +1,14 @@ +utils +===== + +.. automodule:: valuation.utils + :members: + :undoc-members: + +.. rubric:: Modules in this package + +.. toctree:: + :glob: + + utils/* + diff --git a/docs/valuation/utils/parallel.rst b/docs/valuation/utils/parallel.rst new file mode 100644 index 000000000..0c6821440 --- /dev/null +++ b/docs/valuation/utils/parallel.rst @@ -0,0 +1,14 @@ +parallel +======== + +.. automodule:: valuation.utils.parallel + :members: + :undoc-members: + +.. rubric:: Modules in this package + +.. toctree:: + :glob: + + parallel/* + diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 417f44435..bbd6cac8b 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -2,7 +2,6 @@ Contains parallelized influence calculation functions for general models. """ from enum import Enum -from typing import Callable import numpy as np from numpy.typing import NDArray @@ -34,19 +33,27 @@ def calculate_influence_factors( progress: bool = False, ) -> NDArray: """ - Calculates the influence factors. For more info, see - https://arxiv.org/pdf/1703.04730.pdf, paragraph 3. - - :param model: A model which has to implement the TwiceDifferentiable interface. - :param x_train: A matrix of shape [MxK] containing the features of the input data points. - :param y_train: A matrix of shape [MxL] containing the targets of the input data points. - :param x_test: A matrix of shape [NxK] containing the features of the test set of data points. - :param y_test: A matrix of shape [NxL] containing the targets of the test set of data points. + It calculates influence factors of a model from its training and test + points. Given a test point $z_test = (x_{test}, y_{test})$, a loss + $L(z_{test}, \theta)$ ($\theta$ being the parameters of the model) and the + Hessian of the model $H_{\theta}$, influence factors are defined as + $s_{test} = H_{\theta}^{-1} \nabla_{\theta} L(z_{test}, \theta)$. They are + used for efficient influence calculation. This method first + (implicitly) calculates the Hessian and then (explicitly) finds the + influence factors for the model using the given inversion method. The + parameter ``lam`` is used to regularize the inversion of the Hessian. For + more info, refer to :footcite:t:`koh_understanding_2017`, paragraph 3. + + :param model: A model wrapped in the TwiceDifferentiable interface. + :param x_train: An array of shape [MxK] containing the features of the input data points. + :param y_train: An array of shape [MxL] containing the targets of the input data points. + :param x_test: An array of shape [NxK] containing the features of the test set of data points. + :param y_test: An array of shape [NxL] containing the targets of the test set of data points. :param inversion_func: function to use to invert the product of hvp (hessian vector product) and the gradient of the loss (s_test in the paper). :param lam: regularization of the hessian :param progress: If True, display progress bars. - :returns: A matrix of size (N, D) containing the influence factors for each + :returns: An array of size (N, D) containing the influence factors for each dimension (D) and test sample (N). """ grad_xy, _ = model.grad(x, y) @@ -70,18 +77,21 @@ def _calculate_influences_up( progress: bool = False, ) -> NDArray: """ - Calculates the influence from the influence factors and the scores of the - training points. Uses the upweighting method, as described in section 2.1 of - https://arxiv.org/pdf/1703.04730.pdf + Given the model, the training points and the influence factors, calculates the + influences using the upweighting method. More precisely, first it calculates + the gradients of the model wrt. each training sample ($\nabla_{\theta} L$, + with $L$ the loss of a single point and $\theta$ the parameters of the + model) and then multiplies each with the influence factors. For more + details, refer to section 2.1 of :footcite:t:`koh_understanding_2017`. :param model: A model which has to implement the TwiceDifferentiable interface. - :param x_train: A np.ndarray of shape [MxK] containing the features of the + :param x_train: An array of shape [MxK] containing the features of the input data points. - :param y_train: A np.ndarray of shape [MxL] containing the targets of the + :param y_train: An array of shape [MxL] containing the targets of the input data points. - :param influence_factors: np.ndarray containing influence factors + :param influence_factors: array containing influence factors :param progress: If True, display progress bars. - :returns: A np.ndarray of size [NxM], where N is number of test points and M + :returns: An array of size [NxM], where N is number of test points and M number of train points. """ train_grads = model.split_grad(x, y, progress) @@ -96,18 +106,22 @@ def _calculate_influences_pert( progress: bool = False, ) -> NDArray: """ - Calculates the influence from the influence factors and the scores of the - training points. Uses the perturbation method, as described in section 2.2 - of https://arxiv.org/pdf/1703.04730.pdf + Calculates the influence values from the influence factors and the training + points using the perturbation method. More precisely, for each training sample it + calculates $\nabla_{\theta} L$ (with L the loss of the model over the single + point and $\theta$ the parameters of the model) and then uses the method + TwiceDifferentiable.mvp to efficiently calculate the product of the + influence factors and $\nabla_x \nabla_{\theta} L$. For more details, refer + to section 2.2 of :footcite:t:`koh_understanding_2017`. :param model: A model which has to implement the TwiceDifferentiable interface. - :param x_train: A np.ndarray of shape [MxK] containing the features of the + :param x_train: An array of shape [MxK] containing the features of the input data points. - :param y_train: A np.ndarray of shape [MxL] containing the targets of the + :param y_train: An array of shape [MxL] containing the targets of the input data points. - :param influence_factors: np.ndarray containing influence factors + :param influence_factors: array containing influence factors :param progress: If True, display progress bars. - :returns: A np.ndarray of size [NxMxP], where N is number of test points, M + :returns: An array of size [NxMxP], where N is number of test points, M number of train points, and P the number of features. """ all_pert_influences = [] @@ -162,12 +176,12 @@ def compute_influences( or 'cg' for conjugate gradient. :param influence_type: Which algorithm to use to calculate influences. Currently supported options: 'up' or 'perturbation'. For details refer - to https://arxiv.org/pdf/1703.04730.pdf + to :footcite:t:`koh_understanding_2017` :param hessian_regularization: lambda to use in Hessian regularization, i.e. H_reg = H + lambda * 1, with 1 the identity matrix and H the (simple and regularized) Hessian. Typically used with more complex models to make sure the Hessian is positive definite. - :returns: A np.ndarray specifying the influences. Shape is [NxM] if + :returns: An array specifying the influences. Shape is [NxM] if influence_type is'up', where N is number of test points and M number of train points. If instead influence_type is 'perturbation', output shape is [NxMxP], with P the number of input features. diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index faf4f38b5..66b3bc67e 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -239,11 +239,11 @@ def test_influence_linear_model( ids=test_cases.keys(), ) def test_influences_nn( - nn_architecture: "nn.Module", + nn_architecture: nn.Module, batch_size: int, input_dim: Tuple[int], output_dim: int, - loss: "nn.modules.loss._Loss", + loss: nn.modules.loss._Loss, influence_type: InfluenceType, hessian_reg: float = 100, test_data_len: int = 10, From 925185c92b0c8644423fc66c6ed65d2beac7566a Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 1 Mar 2023 12:56:34 +0100 Subject: [PATCH 023/436] remove docs from pr --- docs/valuation/index.rst | 11 ----------- docs/valuation/influence.rst | 14 -------------- docs/valuation/influence/frameworks.rst | 14 -------------- docs/valuation/influence/model_wrappers.rst | 14 -------------- docs/valuation/loo.rst | 14 -------------- docs/valuation/reporting.rst | 14 -------------- docs/valuation/shapley.rst | 14 -------------- docs/valuation/utils.rst | 14 -------------- docs/valuation/utils/parallel.rst | 14 -------------- 9 files changed, 123 deletions(-) delete mode 100644 docs/valuation/index.rst delete mode 100644 docs/valuation/influence.rst delete mode 100644 docs/valuation/influence/frameworks.rst delete mode 100644 docs/valuation/influence/model_wrappers.rst delete mode 100644 docs/valuation/loo.rst delete mode 100644 docs/valuation/reporting.rst delete mode 100644 docs/valuation/shapley.rst delete mode 100644 docs/valuation/utils.rst delete mode 100644 docs/valuation/utils/parallel.rst diff --git a/docs/valuation/index.rst b/docs/valuation/index.rst deleted file mode 100644 index 3b471ff72..000000000 --- a/docs/valuation/index.rst +++ /dev/null @@ -1,11 +0,0 @@ -API Reference -============= - -.. automodule:: valuation - :members: - :undoc-members: - -.. toctree:: - :glob: - - * diff --git a/docs/valuation/influence.rst b/docs/valuation/influence.rst deleted file mode 100644 index e2b6b5ca5..000000000 --- a/docs/valuation/influence.rst +++ /dev/null @@ -1,14 +0,0 @@ -influence -========= - -.. automodule:: valuation.influence - :members: - :undoc-members: - -.. rubric:: Modules in this package - -.. toctree:: - :glob: - - influence/* - diff --git a/docs/valuation/influence/frameworks.rst b/docs/valuation/influence/frameworks.rst deleted file mode 100644 index 248bf9423..000000000 --- a/docs/valuation/influence/frameworks.rst +++ /dev/null @@ -1,14 +0,0 @@ -frameworks -========== - -.. automodule:: valuation.influence.frameworks - :members: - :undoc-members: - -.. rubric:: Modules in this package - -.. toctree:: - :glob: - - frameworks/* - diff --git a/docs/valuation/influence/model_wrappers.rst b/docs/valuation/influence/model_wrappers.rst deleted file mode 100644 index 03e779b0d..000000000 --- a/docs/valuation/influence/model_wrappers.rst +++ /dev/null @@ -1,14 +0,0 @@ -model\_wrappers -=============== - -.. automodule:: valuation.influence.model_wrappers - :members: - :undoc-members: - -.. rubric:: Modules in this package - -.. toctree:: - :glob: - - model_wrappers/* - diff --git a/docs/valuation/loo.rst b/docs/valuation/loo.rst deleted file mode 100644 index 064c8e0b1..000000000 --- a/docs/valuation/loo.rst +++ /dev/null @@ -1,14 +0,0 @@ -loo -=== - -.. automodule:: valuation.loo - :members: - :undoc-members: - -.. rubric:: Modules in this package - -.. toctree:: - :glob: - - loo/* - diff --git a/docs/valuation/reporting.rst b/docs/valuation/reporting.rst deleted file mode 100644 index adc81e949..000000000 --- a/docs/valuation/reporting.rst +++ /dev/null @@ -1,14 +0,0 @@ -reporting -========= - -.. automodule:: valuation.reporting - :members: - :undoc-members: - -.. rubric:: Modules in this package - -.. toctree:: - :glob: - - reporting/* - diff --git a/docs/valuation/shapley.rst b/docs/valuation/shapley.rst deleted file mode 100644 index 3929a7eb0..000000000 --- a/docs/valuation/shapley.rst +++ /dev/null @@ -1,14 +0,0 @@ -shapley -======= - -.. automodule:: valuation.shapley - :members: - :undoc-members: - -.. rubric:: Modules in this package - -.. toctree:: - :glob: - - shapley/* - diff --git a/docs/valuation/utils.rst b/docs/valuation/utils.rst deleted file mode 100644 index 70b958d51..000000000 --- a/docs/valuation/utils.rst +++ /dev/null @@ -1,14 +0,0 @@ -utils -===== - -.. automodule:: valuation.utils - :members: - :undoc-members: - -.. rubric:: Modules in this package - -.. toctree:: - :glob: - - utils/* - diff --git a/docs/valuation/utils/parallel.rst b/docs/valuation/utils/parallel.rst deleted file mode 100644 index 0c6821440..000000000 --- a/docs/valuation/utils/parallel.rst +++ /dev/null @@ -1,14 +0,0 @@ -parallel -======== - -.. automodule:: valuation.utils.parallel - :members: - :undoc-members: - -.. rubric:: Modules in this package - -.. toctree:: - :glob: - - parallel/* - From 8a38b72b9653a4fd47c047c8824453c64b6a6e70 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 1 Mar 2023 13:04:04 +0100 Subject: [PATCH 024/436] small fix to docstring --- src/pydvl/influence/general.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index bbd6cac8b..9cd6543fe 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -37,7 +37,7 @@ def calculate_influence_factors( points. Given a test point $z_test = (x_{test}, y_{test})$, a loss $L(z_{test}, \theta)$ ($\theta$ being the parameters of the model) and the Hessian of the model $H_{\theta}$, influence factors are defined as - $s_{test} = H_{\theta}^{-1} \nabla_{\theta} L(z_{test}, \theta)$. They are + $s_{test} = H_{\theta}^{-1} \grad_{\theta} L(z_{test}, \theta)$. They are used for efficient influence calculation. This method first (implicitly) calculates the Hessian and then (explicitly) finds the influence factors for the model using the given inversion method. The @@ -79,7 +79,7 @@ def _calculate_influences_up( """ Given the model, the training points and the influence factors, calculates the influences using the upweighting method. More precisely, first it calculates - the gradients of the model wrt. each training sample ($\nabla_{\theta} L$, + the gradients of the model wrt. each training sample ($\grad_{\theta} L$, with $L$ the loss of a single point and $\theta$ the parameters of the model) and then multiplies each with the influence factors. For more details, refer to section 2.1 of :footcite:t:`koh_understanding_2017`. @@ -108,10 +108,10 @@ def _calculate_influences_pert( """ Calculates the influence values from the influence factors and the training points using the perturbation method. More precisely, for each training sample it - calculates $\nabla_{\theta} L$ (with L the loss of the model over the single + calculates $\grad_{\theta} L$ (with L the loss of the model over the single point and $\theta$ the parameters of the model) and then uses the method TwiceDifferentiable.mvp to efficiently calculate the product of the - influence factors and $\nabla_x \nabla_{\theta} L$. For more details, refer + influence factors and $\grad_x \grad_{\theta} L$. For more details, refer to section 2.2 of :footcite:t:`koh_understanding_2017`. :param model: A model which has to implement the TwiceDifferentiable interface. From 78c4f3534c90ebda123754f818de1c494e30e835 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 3 Mar 2023 11:31:55 +0100 Subject: [PATCH 025/436] reverting use of env variable for frameworks --- notebooks/influence_imagenet.ipynb | 6 +- notebooks/influence_synthetic.ipynb | 61 +++++++++++-------- notebooks/influence_wine.ipynb | 41 ++++++++----- src/pydvl/influence/__init__.py | 2 +- src/pydvl/influence/frameworks/__init__.py | 40 ++---------- .../frameworks/torch_differentiable.py | 17 ++++-- ...ferentiable.py => twice_differentiable.py} | 7 ++- 7 files changed, 83 insertions(+), 91 deletions(-) rename src/pydvl/influence/frameworks/{base_twice_differentiable.py => twice_differentiable.py} (90%) diff --git a/notebooks/influence_imagenet.ipynb b/notebooks/influence_imagenet.ipynb index 2f32fc835..52fa941de 100644 --- a/notebooks/influence_imagenet.ipynb +++ b/notebooks/influence_imagenet.ipynb @@ -94,7 +94,7 @@ "metadata": {}, "outputs": [], "source": [ - "from pydvl.influence.general import compute_influences, TwiceDifferentiable\n", + "from pydvl.influence import compute_influences, TorchTwiceDifferentiable\n", "from pydvl.reporting.plots import plot_influence_distribution_by_label\n", "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, f1_score" ] @@ -381,7 +381,7 @@ } ], "source": [ - "differentiable_model = TwiceDifferentiable(mgr.model, mgr.loss)\n", + "differentiable_model = TorchTwiceDifferentiable(mgr.model, mgr.loss)\n", "influences = compute_influences(\n", " differentiable_model=differentiable_model,\n", " x=train_x,\n", @@ -777,7 +777,7 @@ } ], "source": [ - "differentiable_model = TwiceDifferentiable(mgr.model, mgr.loss)\n", + "differentiable_model = TorchTwiceDifferentiable(mgr.model, mgr.loss)\n", "corrupted_influences = compute_influences(\n", " differentiable_model=differentiable_model,\n", " x=corrupted_train_x,\n", diff --git a/notebooks/influence_synthetic.ipynb b/notebooks/influence_synthetic.ipynb index 0e28ab25f..7ac280e42 100644 --- a/notebooks/influence_synthetic.ipynb +++ b/notebooks/influence_synthetic.ipynb @@ -60,8 +60,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/fabio/miniconda3/envs/data_shapley/lib/python3.10/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" + "/Users/fabio/.local/lib/python3.8/site-packages/requests/__init__.py:109: RequestsDependencyWarning: urllib3 (1.26.9) or chardet (5.1.0)/charset_normalizer (2.0.12) doesn't match a supported version!\n", + " warnings.warn(\n" ] } ], @@ -76,7 +76,7 @@ "import torch\n", "import torch.nn.functional as F\n", "import matplotlib.pyplot as plt\n", - "from pydvl.influence import compute_influences, TwiceDifferentiable\n", + "from pydvl.influence import compute_influences, TorchTwiceDifferentiable\n", "from pydvl.utils.dataset import (\n", " synthetic_classification_dataset,\n", " decision_boundary_fixed_variance_2d,\n", @@ -217,7 +217,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -266,11 +266,18 @@ "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "Model fitting: 100%|██████████| 50/50 [00:03<00:00, 15.66it/s]\n" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f4b626fcdb0a4efe80f3904c00725b57", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Model fitting: 0%| | 0/50 [00:00" ] @@ -347,7 +354,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 12, @@ -356,7 +363,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -437,7 +444,7 @@ "outputs": [], "source": [ "influence_values = compute_influences(\n", - " differentiable_model=TwiceDifferentiable(model, F.binary_cross_entropy),\n", + " differentiable_model=TorchTwiceDifferentiable(model, F.binary_cross_entropy),\n", " x=x,\n", " y=y.astype(float),\n", " x_test=test_data[0],\n", @@ -487,7 +494,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 16, @@ -496,7 +503,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -547,7 +554,7 @@ "y_corrupted[:10] = [1 - yi for yi in y[:10]]\n", "\n", "influence_values = compute_influences(\n", - " differentiable_model=TwiceDifferentiable(model, F.binary_cross_entropy),\n", + " differentiable_model=TorchTwiceDifferentiable(model, F.binary_cross_entropy),\n", " x=x,\n", " y=y_corrupted.astype(float),\n", " x_test=test_data[0],\n", @@ -569,8 +576,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average mislabelled data influence: -0.7069138219997766\n", - "Average correct data influence: 0.007597316767707558\n" + "Average mislabelled data influence: -0.7618193132719681\n", + "Average correct data influence: 0.008644202479956366\n" ] } ], @@ -588,7 +595,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 19, @@ -597,7 +604,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -658,14 +665,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average mislabelled data influence: -0.7069132495095636\n", - "Average correct data influence: 0.007597317307720237\n" + "Average mislabelled data influence: -0.7618190305526785\n", + "Average correct data influence: 0.008644202231215354\n" ] } ], "source": [ "influence_values = compute_influences(\n", - " differentiable_model=TwiceDifferentiable(model, F.binary_cross_entropy),\n", + " differentiable_model=TorchTwiceDifferentiable(model, F.binary_cross_entropy),\n", " x=x,\n", " y=y_corrupted.astype(float),\n", " x_test=test_data[0],\n", @@ -695,7 +702,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -767,7 +774,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "dval_env", "language": "python", "name": "python3" }, @@ -781,11 +788,11 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" + "version": "3.8.13" }, "vscode": { "interpreter": { - "hash": "4e000971326892723e7f31ded70802f690c31c3620f59a0f99e594aaee3047ef" + "hash": "b3369ace3ad477f5e763d9fa7767e0177027059e92a8b1ded9e92b707c0b1513" } } }, diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index e4af2ba4d..51d7fab8d 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -43,7 +43,16 @@ "execution_count": 2, "id": "be813151", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/fabio/.local/lib/python3.8/site-packages/requests/__init__.py:109: RequestsDependencyWarning: urllib3 (1.26.9) or chardet (5.1.0)/charset_normalizer (2.0.12) doesn't match a supported version!\n", + " warnings.warn(\n" + ] + } + ], "source": [ "%autoreload\n", "%matplotlib inline\n", @@ -57,7 +66,7 @@ "import torch.nn.functional as F\n", "from support.common import plot_losses\n", "from support.torch import TorchMLP, fit_torch_model\n", - "from pydvl.influence import compute_influences, TwiceDifferentiable\n", + "from pydvl.influence import compute_influences, TorchTwiceDifferentiable\n", "from pydvl.utils.dataset import load_wine_dataset\n", "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, f1_score\n", "from torch.optim import Adam, lr_scheduler" @@ -169,7 +178,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b22f84de78d44e4e8f7b8011f7132983", + "model_id": "93a2375c77b8416faafe2a0f6cc50f47", "version_major": 2, "version_minor": 0 }, @@ -228,7 +237,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -336,7 +345,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3ed93a165d71427a90375cefa63a68e4", + "model_id": "a1bbb2086dd54478b09ace458fd73e62", "version_major": 2, "version_minor": 0 }, @@ -350,7 +359,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0c82a28bbb934e59827b9bf696fc32f1", + "model_id": "99f8e4b9ba75452e84d0d6acddd519e1", "version_major": 2, "version_minor": 0 }, @@ -364,7 +373,7 @@ ], "source": [ "train_influences = compute_influences(\n", - " TwiceDifferentiable(nn_model, F.cross_entropy),\n", + " TorchTwiceDifferentiable(nn_model, F.cross_entropy),\n", " *train_data,\n", " *test_data,\n", " influence_type=\"up\",\n", @@ -416,7 +425,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -456,8 +465,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average influence of corrupted points: -0.0382529221316219\n", - "Average influence of other points: 0.030890610494236293\n" + "Average influence of corrupted points: -0.03877732371354803\n", + "Average influence of other points: 0.031097713459676678\n" ] } ], @@ -497,7 +506,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3c5bd03e730c4062bb4ed7dc219b06d0", + "model_id": "8d1b0dc5afa54ff688dc2d87551b74fc", "version_major": 2, "version_minor": 0 }, @@ -511,7 +520,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f2d0066f551e4cbab6bf6c27772bee77", + "model_id": "5524f3d894ab4a70bbb6c3c6877ecbb1", "version_major": 2, "version_minor": 0 }, @@ -525,7 +534,7 @@ ], "source": [ "feature_influences = compute_influences(\n", - " TwiceDifferentiable(nn_model, F.cross_entropy),\n", + " TorchTwiceDifferentiable(nn_model, F.cross_entropy),\n", " *train_data,\n", " *test_data,\n", " influence_type=\"perturbation\",\n", @@ -543,7 +552,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA8EAAAKRCAYAAAB0satDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAADiEUlEQVR4nOzdd3zV1f3H8dfJnveGAAHuhbBnbgQCLlDco7XWVUedrVq1bu34afeudjjrrFr3rFpttS4cKC4gjCSssBISRhjZO7nn90duMFLAAPfme8f7+XjcB7k333vvm8v45vM953yOsdYiIiIiIiIiEgvinA4gIiIiIiIi0ldUBIuIiIiIiEjMUBEsIiIiIiIiMUNFsIiIiIiIiMQMFcEiIiIiIiISM1QEi4iIiIiISMxQESwiIuIAY8wwY8xsY0yjMSbq9is0xvzKGLNqH553pDGm2BjTbox53xgzwhhjjTGHhSKniIjEHhXBIiLiKGOM1xjTaozZYIxJcDpPH/oJkANMAYYE60WNMeeHSVH9F+CQfXjefUAhMAo4PaiJREREUBEsIiLOuwT4D1ADnBzqNzNdEkP9Pr0wFvjcWltqrd3kdJhd2Z/PyVrbYK3dug9PHQu8ba1db63dvq/vLyIisjsqgkVExDHGmDi6iuBHgceAy3p873vGmFpjTMpOz/k/Y0x54LkYY8YYY140xtQYY6qNMW8ZY/J7HP8dY0yHMeYoY8xCoBU41hgz0hjzUmAEuskYU2SMuWCn90o1xjwYyFFtjLnXGPPHnaf5GmPOMcYsMsa0GGPWGWNuM8ak7+H3bYFjgIsDU30fDTyeYYy50xhTGci00Bhz+k7P/b0xZlng++uNMfcbY9yB7x0JPNH9Hju99vvGmId2eq2fGWPW9bj/qDHmHWPMNYHHWwOfwaDA97YYY+qNMXONMbN29/sLvNaXpkN33zfGnGKMWR6YBv6+MWZsd/bA5xIPPB7I/p1dvO4up0cHXvtXPe7v8bPs8TpnGWP+Ezhmzc7vGXidOwKfdWvgz/cnPb6/15+NiIg4S0WwiIg46WtAMvBfuoq3Y4wxIwLfex5IAk7Z6TkXAk9aa/3GmEHAR0AVcDhd029XAO8bYwb2eE4ccCtwIzABmA9kAO8GMuQDDwL/MMYc1eN5twbe/4LAa9cCV/YMEyia7gP+CkwK5DsWuH8Pv+8hwCfA04GvrzPGGODfwGTgbMAXeN1njTHH9HhuM10XCyYB3wGOBO4KfO9j4Ooe7zEEuG4POXblIOBoun7fk+n67N4DMun6rKYCrwNvG2Mm7uVrDwG+D5wHzAi85iM9sndPC7868PVze/n6QNdoP737LAFuAR4HDgCeBR4yxozr8Tr/Ab4JXANMpOvPd0vg+6kE77MREZG+Yq3VTTfddNNNN0duwCvAX3vcfwP4XY/7zwKv9bg/HbDA+MD9XwGf7vSaBlgNXB+4/53Acw7vZZ6/B75Op2vU+JKdjvkUWNXj/jrgip2OmRV4z357eK/3gYd63D8SaAHcOx33CPCvPbzOaYGccYH753ed3vf8foHHfgas63H/UbqmpWf0eOw7QAWQsNNz3wXu2EOuX+30Of0K6AAG9njsbMAPpPR4zALn97g/IvDYYbu63+O4VcCvevtZ9nidG3t8Px6oBy4P3D8mcMz03fwe9+mz0U033XTTzdlbLDUgERGRMGKM8QIn0TV61u0x4K/GmF9ZazsC9181xuRYa6voGoX73Fq7InD8gcA0Y0zDTi+fStfa0p7m7fT+acAv6FqHPISuUedkukb2AMYEHvt0p9f5JPAcAqPNw4HbjDF/6fnyPV5jHr1zYOD9KrsGIHdIAkp75D4duD7w2i66RmqTgMHAhl6+154ss9b2/DwPDLx2zU65kukald4bG6y1W3rep+uzygHK9yHr7vTqswxY1P2FtbbTGFMFDAo8NA2ottbO38P7BOuzERGRPqIiWEREnHIJXSNvC3cqIOLpKjJfBt4CtgLnGmPuAc6ha0SxWxwwmy+mAPdU2+PrTmtty07f/zNdU35vpGsKdSNdU5rdOx23p07L3cuKruOL4rmnij08d1evVUtXYbWzNgBjzMHAC8AfgR8B1XRN036MrgJvT/x8UZx321Xjq8Zd5FpG14jzzpq+4j131rbT/e7Pdm+WZ/kDv+7p9/KVn+VXZOptnmB+NiIi0kdUBIuISJ8zXzTE+gPwzE7f/glda15fDozMPUXXmtw1dBWoz/Y4dj6BKam7KHK/yizgKWvt8z0yjQM2B76/iq4C6VBgaY/n7dj2x1q72Riznq7p2X/fy/ff2Xwgi66pwcW7OeYwYKu19mfdDxhjvrXTMd0Fc7y1trPH41WAZ6djC3qZ60KgLjAa77TukeQdvxdjTA7g7XFMbz7L3lgA9DPGTN/NaHC4fTYiItILaowlIiJO+BowDHjAWlvc80bXutTjezTIepyuYu3XwH/sl7fN+RtdI8evGGMOD3T8PSzQQXnGV2RYAZxijDnIGDOJrsZYOwora20j8ADwO2PMN4wx44wxv6erOVLP0eGfAtcaY35qjPEZY8YbY041xjywl5/Ju8A7wEuB548yxkwLdGr+Xo/MA40xlwS+fyE7NeoC1gZ+/aYxZqAxJiNw/x26umKfabo6at9EVzOxr/JU4DVfM8YcH/iMDzbG3GyMOXUvf4/7zVrbDMwFfmyMmWyMmUbX35HWHof15rPsjXeBD4HnAl2tRxpjZhpjLg18P6w+GxER6R0VwSIi4oTLgM+stbtaB/ousB24FMBau4SudZtT6Cp2drDWbqZrpHYr8BJdReJTdK3T3fgVGW4AyuiaxjwbqAT+udMx/0dXl+Gngc+BfnQV6TtGna21TwBnAd8IHDOPrinblV/x/l9irbV0dSF+CbgdWA68Rte66dWBY/4D/J6uEfQiuqaH/2in15kH3ElXAV9F14UC6JoyfU/gNp+uixB38RUCI+xHBJ7zD2BlIONBdH1+TrgYaKCro/SzdF3A2PHn3ZvPsjcCr3MSXR2f76fr79eTwIDA98PxsxERka9guv5/FxERkd4wxrxLV7OkM5zOIiIiIntPa4JFRER2wxiTT9dU7E/oajx1AXAUXdO5RUREJAKpCBYREdk9C3yfrmnDcXRNqz3NWvuGo6lERERkn2k6tIiIiIiIiMQMNcYSERERERGRmKEiWERERERERGJGzK4JHjBggB0xYoTTMURERERERCQEFixYsNVaO3Dnx2O2CB4xYgTz5893OoaIiIiIiIiEgDFml3u2azq0iIiIiIiIxAwVwSIiIiIiIhIzVASLiIiIiIhIzFARLCIiIiIiIjFDRbCIiIiIiIjEDBXBIiIiIiIiEjNUBIuIiIiIiEjMUBEsIiIiIiIiMUNFsIiIiIiIiMQMFcEiIiIiIiISM1QEi4iIiIiISMxQESwiIiIiIiIxQ0WwiIiIiIiIxAwVwSIiIiIiIhIzVASLiIiIiIhIzFARLCIiIiIiIjFDRbCIiIiIiIj0WmNrh9MR9ouKYBEREREREem1cx78lKueLnQ6xj5TESwiIiIiIiK90tzWybKNdYzon+Z0lH2mIlhERERERER6ZUlFDR1+y7Th/ZyOss9UBIuIiIiIiEivFJbXADB1mIpgERERERERiXILyqoZNSCdfulJTkfZZyqCRURERERE5CtZa1lYXk1BBE+FBhXBIiIiIiIi0gvl25vY1thGQa6KYBEREREREYlyC8qqASgYnuVskP2kIlhERERERES+UmF5NRnJCYzNyXQ6yn5RESwiIiIiIiJfqbCshqm5WcTHGaej7BcVwSIiIiIiIrJHDa0dLN9Ux9QIXw8MKoJFRERERETkKyxZX4PfQkFultNR9puKYBEREREREdmjwvKuplgaCRYREREREZGoV1hew9icDNypiU5H2W8qgkVERERERGS3rLUUlldH/P7A3VQEi4iIiIiIyG6t2dpITVN7xO8P3E1FsIiIiIiIiOxWYVnXeuBpwzUSLCIiIiIiIlGusLwaV0oCowZkOB0lKFQEi4iIiIiIyG4VltUwNbcfcXHG6ShBoSJYREREREREdqmupZ2VVfVRMxUaVASLiIiIiIjIbiwqr8FaoqYzNKgIFhERERERkd0oLK/GGJg8zO10lKBRESwiIiIiIiK7VFhew/hBmWSmJDodJWhUBIuIiIiIiMj/8PstC8urKYii9cCgIlhERERERER2YdWWBupbOqJqPTCoCBYREREREZFdKCyrBqAgN8vZIEGmIlhERERERET+R2F5Nf3SEhk5IN3pKEGlIlhERERERET+x4Kyagpy+2GMcTpKUKkIFhERERERkS+paWpj9ZbGqGuKBSqCRUREREREZCcL19cARF1TLFARLCIiIiIiIjspLKsmPs4weZjb6ShBpyJYREREREREvqSwvJoJgzNJS0pwOkrQqQgWERERERGRHTr9lkXlNVE5FRpUBIuIiIiIiEgPKzfX09jWybQobIoFKoJFRERERESkhwVl1UB0NsUCFcEiIiIiIiLSQ2F5NQMykhiWnep0lJBQESwiIiIiIiI7LAysBzbGOB0lJFQEi4iIiIiICADbGlpZu7WRgihdDwwqgkVERERERCRgYXkNEL3rgUFFsIiIiIgIALe9tYI73yl1OoaIowrLq0mIMxww1O10lJBRESwiIiIiMW9VVQN/e28Vz3xe7nQUEUcVlleT53GRkhjvdJSQUREsIiIiIjHvztml+C1sqmthS32r03FEHNHR6Wfx+lqmRvFUaFARLCIiIiIxbsWmev6zZAMHjuj6wb94Q63DiUScsXxTPc3tnVHdFAtUBIuIiIhIjLtz9krSkxK47awpABRXqAiW2FRYXg3ANBXBIiIiIiLRaemGOl4v2sTFM0cwLDuNkQPSNRIsMWtBWTWDXMl43ClORwkpFcEiIiIiErPueGclmSkJXHLYKADyPC6KK+scTiXijMLyagpy+2GMcTpKSKkIFhEREZGYVFRRy1tLN3PpYaNwpyUC4PO6qaxpprqxzeF0In2rqr6F9dubo34qNKgIFhEREZEYdcc7K3GnJvLdw0bseCzf27U3qqZES6wpLKsBiPrO0KAiWERERERi0KL1NcxeXsVls0bhSknc8XiexwWgKdEScxaWV5MUH4fP63I6SsipCBaJMA2tHU5HEBERiXi3v72S7PQkLpox4kuPZ6UlMbRfKsWVGgmW2FJYXk2e10VyQrzTUUJORbBIhGjr8PObfy/F98s3+WzNNqfjiIiIRKwFZdv5YOUWLp81iozkhP/5fr7XrenQElPaOvwsqahlWgxMhQYVwSIRobKmmbMe+IRH5q4F4BMVwSIiIvvs9rdLGZCRxAWHDt/l931eN2Xbmqhtbu/jZCLOWLqxjtYOPwUx0BQLwqgINsacaIxZYYxZZYy5aRffTzbGPBf4/mfGmBGBx48zxiwwxhQFfj26z8OLhNC7yzdz0l0fsqqqgXvPK2BMTobWKYmIiOyjz9Zs46NVW7niiNGkJf3vKDB8sS64RKPBEiMKy6oBKNBIcN8xxsQD9wBfAyYB3zbGTNrpsEuAamvtGOB24NbA41uBk621+cBFwBN9k1oktDo6/dz6xnIufnQ+Q9yp/Puaw/h6/hB8HpdOyiIiIvvo9ndWMjAzmfMP2fUoMHSNBAOU6KKzxIjC8mq8WakMdqc4HaVPhEURDBwErLLWrrHWtgHPAqfsdMwpwGOBr/8JHGOMMdbahdbaDYHHS4BUY0xyn6QWCZHNdS2c+9Bn3Pf+ar59UC4vXzmDkQPSga4T88baFrY2tDqcUkREJLJ8vHorn67ZzlVHjiYlcffNfwZkJDPEnUKRmmNJjCgsq2ZqbpbTMfpMuBTBXmB9j/sVgcd2eYy1tgOoBfrvdMwZQKG1dpfVgTHmMmPMfGPM/C1btgQluEiwzV21lZPu+pCiilpuP3syfzw9/0sn6jxP4Or0Bl2dFhER6S1rLbe/vZLBrhTOOSj3K4/3qTmWxIhNtS1sqG2JmanQED5F8H4zxuTRNUX68t0dY6190Fo73Vo7feDAgX0XTqQXOv2WO98p5fyHPyMrLYlXr57JaVOH/s9xed7u/Qt1YhYREemtD0u3Mm9dNVcdPWaPo8DdfB43a7c2amtCiXqF5V3rgafFSFMsgF13A+h7lcCwHveHBh7b1TEVxpgEwA1sAzDGDAVeBi601q4OfVyR4Nra0MoNzy3iw9KtnDbVy+9P8+22WYcrJZER/dO0LlhERKSXrLXc9vZKvFmpnDX9fy8w74rP68JaWLqhjoNGZoc4oYhzFpRVk5wQx8QhLqej9JlwGQmeB4w1xow0xiQB5wCv7nTMq3Q1vgL4FvCutdYaY7KA14CbrLVz+yqwSLDMW7edk+76kM/WbueW0/O57azJuy2Au+V53eoQLSIi0kvvr9jCovU1XH30GJITvnoUGLr2CgbNvJLoV1hezQFD3SQlhEtpGHph8TsNrPG9GngTWAY8b60tMcb8xhjzzcBhDwP9jTGrgBuB7m2UrgbGAL8wxiwK3HL6+Lcgstf8fssDH6zmnAc/JTUxnpevnME5B+VijPnK5/o8bsq3N1HbpP0LRURE9qR7FHhYdirfmta7UWCAHFcKAzOTtS5YolprRycllXUxtR4Ywmc6NNba14HXd3rsFz2+bgHO3MXzfgf8LuQBRYKopqmNH76wmHeWVfH1/MHccsYBuFISe/18n/eL/QtnjBkQqpgiIiIR751lVRRV1vKnbx1AYvzejf/4PC6NBEtUK66so63TT0EMrQeGMBkJFokli9bXcNJdH/HByi386uRJ3HNuwV4VwPBFh2hdnRYREdk9v79rFHh4/zROn7rzxiNfLd/rZlVVA81tnSFIJ+K8wrKuplixNhKsIlikj1hreXTuWs68/2MAXrhiBt+ZObJX0593lp2ehDcrVeuCRURE9uCtpZtYtrGO644ZS8JejgJDVw8Ov4Vlm3S+lehUWF7NsOxUBmYmOx2lT4XNdGiRaFbf0s5NLxbxWtFGjpmQw1/PmkxWWtJ+vWaex6WRYBERkd3w+y23v13KqIHpfHOyZ59eo2dzrFgbKZPoZ62lsLyaQ0f1dzpKn1MRLBJiSzfUceVTC1hf3czNX5vA9w4fRVzc3o/+7szndfP2ss00tHaQkax/yiIiIj29XryRFZvrufOcKfs0CgwwxJ1CdnqS1gVLVKqsaWZzXWvMrQcGTYcWCRlrLc9+Xs6p986lub2TZy87hMuPGB2UAhi+2L9w2UZN0RIREemp02+5451SxuZk8I0D9m0UGMAYQ57HRZGWH0kUKiyvAWJvPTCoCA5L89Zt5+aXithQ0+x0FNlHTW0d/OD5xdz0UhEHjcjmtWsP58AR2UF9D5/2LxQREdml/yzZwKqqBm44bhzx+3nxOd/rpnRzPS3tao4l0aWwrJrUxHgmDM50Okqf0xzKMLRsYx3/XLCeFxdUcO7BuVx55GhyXClOx5JeKt1cz5VPFbJqSwM3HDuOq48es98n4F3JyUwhJzNZzbFERER66Oj0c+c7pUwYnMmJeYP3+/V8XjcdfsvKzfUcMDRr/wOKhInC8momD3Pv83KBSBZ7v+MIcOGhI3jvh0dyeoGXJz4tY9af3+MPry9jW0Or09HkK7y8sIJv/m0u1U1tPHnJwVx37NiQFMDdfF63RoJFRER6eGXRBtZsbeSG48YFpwdHYFvCIp1vJYq0tHeydENdTE6FBhXBYWtovzRuOeMAZt94BF/3DeGhD9cw60/v8Zc3V1Db1O50PNlJS3snN79UxA3PLSZ/qJvXrj2cmWMGhPx9fR4XpVX12r9QREQEaO/0c9e7peR5XBw/aVBQXnNYdiqulATNvJKosqSilg6/VREs4WnEgHRuO3sKb90wiyMn5PC391Zx2J/e5a7ZpdS3qBgOB+u2NnL6vR/zzOflXHnkaJ6+9GAG9dH09e79C5dr/0IRERFeLqykbFsTNx43DmOCMxPLGIPP66ZE2xJKFCksrwaIyc7QoCI4YozJyeSecwt4/drDOWRUf257eyWH/+k97v9gNU1tHU7Hi1mvF23kG3d/RGVNM498Zzo/PnFCn66r2NEca4OKYBERiW1tHX7unF3K5KFujp6QE9TX9nndLN9YT1uHP6ivK+KUBWXVjByQTnZ6ktNRHKEiOMJM8rj4+4XTeeWqmUwemsUt/13OrD+9zyMfrVXXwj7U1uHnV6+WcOVThYzJyeC1aw/j6AnBmXa1NzzuFPqlJVKidUoiIhLjXliwnsqaZm4I4ihwN5/XTVunn9Kq+qC+rogTrLUsLK9mam6W01EcoyI4Qk0elsVjFx/EP684lLE5GfzmP0s58s/v8+SnZbpKGWIV1U2c+cAnPPrxOi6eOZLnLz+Uof3SHMnSPUWrWFO0REQkhrV2dPK3d1dRkJvFEeMGBv31fR4XACVaFyxRYP32ZrY2tDEtRqdCg4rgiDd9RDbPXHYIT196MN5+qfzsX8Uc/df3eX7+ejo6VQwH2+xlmznpro9YU9XAfecV8IuTJ5GU4Ow/ozyPmxWbNEVLRERi13Pz1rOxtoUbjxsf9FFggBH908lITlCHaIkKC8q3A8RsUyxQERw1ZowZwD+vOJRHv3sg/dKS+PE/l3Dc7XN4ZVElnX7rdLyI19Hp55b/LueSx+YztF8q/7n2ML6WP8TpWADke920d3btXygiIhJrWto7uee9VRw0IpuZY/qH5D3i4gyTPC7NvJKoUFhWQ0ZyAuMGZTodxTEqgqOIMYYjx+fw6tUzefCCaSQnxHHds4v42p1zeKN4I9aqGN4Xm2pbOPfvn3H/B6s59+BcXvz+DIb3T3c61g4+b2CKlk7MIiISg57+rJzNda0hWQvck8/jZtnGOs20k4hXWF7N5GFu4oOwj3akUhEchYwxHJ83mNevPZy7vz2VTr/liicL+cbdHzF72WYVw3vhw9ItnHTXhxRvqOWOs6fwh9PySUmMdzrWl+Rmp5GZoilaIiISe5rbOrn3/dUcOqo/h44OzShwt/yhLlra/aze0hjS9xEJpcbWDpZtrGNaDE+FBhXBUS0uznDyZA9v3XAEt501mfqWDi55bD6n3fsxH5ZuUTG8B51+y+1vr+TCRz6nf0YSr149k1Onep2OtUvGGPI8LorVrENERGLMk5+WsbWhaxQ41HyewLaEuugsEWxxRQ1+C1NjuCkWqAiOCfFxhtMLhjL7B0dwy+n5VNW1cMHDn3P2g5/y2ZptTscLO1sbWrnokc+5c3Ypp0318q+rZjImJ7zXTGiKloiIxJrG1g7u/2A1h48dwEEjs0P+fqMGZpCaGK+ZVxLRFpbXAFAwLLaL4ASnA0jfSYyP45yDcjmtwMuzn6/nnvdWcfaDn3L42AHceNw4psb4tAiAz9Zs45pnFlLb3M6fzjiAM6cPDen6omDxed20dnRN0Ro/OLwLdhERkWB4/JMytjW2cf2xoR8Fhq5BhUkel3pwSEQrLKtmTE4G7rREp6M4SiPBMSg5IZ6LZoxgzo+P4mcnTaRkQx2n3fsxlzw6L2an+Pj9lvveX825D31GenIC/7pqJmcdOCwiCmD4ojlWrP75iYhIbKlvaeeBOas5cvzAPt3r1OdxUbKhDr923pAIZK2lsLyagtwsp6M4TkVwDEtJjOfSw0fx4Y+P4kcnjGfeuu184+6P+P6TC2Jqu53qxjYufXw+t76xnBN9g3n16plMHOJyOtZeGTmga4qWtm4QEZFY8NjH66hpaueGPhoF7pbnddPU1smarWqOJZFn7dZGqpvaY3p/4G6aDi2kJydw1VFjOP+Q4Tz80Voe+Wgtb5Rs4puTPVx3zFhGDcxwOmLILCyv5uqnF1JV38JvTsnjgkOGR8zob087pmipOZaIiES5upZ2HpyzhmMnDmLysKw+fe98b1dzrJINtYzJid6fjyQ6FXavB47xpligkWDpwZ2ayI3HjePDHx/FFUeM5q2SzRx3+xx+9MJi1m9vcjpeUFlr+cfctZz1wCcYA/+8YgYXHjoiIgvgbvleNyUbajVFS0REotojH62lrqWD648d2+fvPSYng6SEOC0/koi0oKyazJQExkTxAFdvqQiW/9EvPYn/O3ECc358FBcdOoJXFm/g6L++z09fLmJjbbPT8fZbXUs7Vz5VyK//vZQjxuXw2jWH9/mV5FDI87hobOtk3TZN0RIRkehU29TOwx+u5cS8wfgCo7J9KTE+jolDXOoQLRFpYXk1U3P7ERcXuYM+waIiWHZrYGYyvzh5EnN+dBRnHziM5+ev54g/v8+v/13ClvpWp+Ptk+LKWk6++yPeWrqZn359In+/cFrUdMfr/mFAJ2YREYlWf/9wDfWtHVx/XN+PAnfzBZYfaeaVRJL6lnZWbK5XU6wAFcHylQa7U/jdqfm8+4MjOW2Kl8c/KWPWn97jj/9dRnVjm9PxesVay9OflXP6fR/T2u7nucsO4XuzRkX09OeddU/RKtmgdcEiIhJ9tje28Y+5aznpgCFMGOxcA0uf1019awfrq6NrqZhEt8Xra7GWPu2mHs5UBEuvDctO49ZvHcA7Nx7BCXmDeHDOGg7/03vc9tYKapvbnY63W42tHdz4/GJ+8nIRh4zqz2vXHsb0EdlOxwq6xPg4Jg7O1DolERGJSg/OWUNTeyfXH+PcKDB80RxLM68kkiwoq8YYmBIFSwCDQUWw7LWRA9K545ypvHn9LGaNG8Bd767i8Fvf5W/vltLQ2uF0vC8p3VzPKffM5ZVFlfzguHE8+p0D6Z+R7HSskMnzuimurMVaTdESEZHosbWhlcc+Xsc3J3sYOyjT0SxjB2WQGG8o1o4MEkEKy6sZl5NJZkp0LAPcXyqCZZ+NG5TJvedN47VrD+Ogkdn85a2VzPrTezw4ZzXNbZ1Ox+Olwgq++be51DS18+QlB3PNMWOjvhGAz+OmrqWDiurIb2AmIiLS7YEPVtPa0cm1Do8CAyQnxDNukGZeSeTw+y0Ly6spGJ7ldJSwoSJY9luex81DFx3Iv66aSZ7HxR9eX86sP7/Ho3PX0trR98VwS3snN724hBufX8wBQ928fu1hzBgzoM9zOMHn7VojpROziIhEi6q6Fh7/pIxTp3oZHSZbu+R73RRv0MwriQyrtzRQ19JBQa7WA3dTESxBM2VYFk9ccjDPX34oowak86t/L+WoP7/PM5+X097p75MMa7c2cuo9c3l23nquOmo0T116MDmulD5573AwblAmCXGG4g0qgkVEJDrc98FqOvyWa492fhS4W57XTU1TO5U1mnkl4a+wvBqAAjXF2kFFsATdQSOzefayQ3jq0oMZ5E7h5peKOOavH/Diggo6Q7idwGtLNnLy3R+xqa6Ff3z3QH50wgQS4mPrr3hKYvcULa1TEhGRyLeptoWnPivnjAIvIwakOx1nB59HM68kchSW1ZCVlsioMPo35LTYqhCkzxhjmDlmAC99fwb/+M6BuFIT+MELiznu9g94dfGGoO6t19rRyS9fKeaqpwsZNyiD1689nKPG5wTt9SONz+tScywREYkK976/Cr/fck0YjQIDTBziIj5OzbEkMiwor6Ygt19UbQ26v1QES0gZYzhqQg7/vvow7j9/GolxcVz7zEK+fteHvFmyab8LtfXbmzjr/k947JMyLj1sJM9dfiierNQgpY9MPq+bbY1tbKprcTqKiIjIPqusaebZz9dz5vRhDMtOczrOl6QkxjM2J0PLjyTs1Ta1s6qqgYLcLKejhJUEpwNIbDDGcKJvMMdPGsR/ijZyx9srufyJBeR73dx4/DiOHDdwr69OvbN0Mzc+vwgL3H/+NE70DQ5N+AiT5+nav7C4so4h7ti+ICAiIpHrnvdWYbFcffQYp6Psks/r5v0VVVhrNcImYWvh+sB6YDXF+hKNBEufioszfHOyh7dumMVfzpxMTXMb3/3HPM6472M+XrW1V6/R3unnj68v49LH55PbP43XrjlcBXAPE4dkEme0TklERCLX+u1NPD9vPeccmIs3TGd4+Twutja0sbmu1ekoIrtVWF5DnIHJw7KcjhJWNBIsjkiIj+Nb04ZyyhQPL8yv4O53Szn3oc84ZFQ2Pzh+PAeOyN7l8zbVtnDNM4XMW1fN+Yfk8rOTJpGSGN/H6cNbWlICowdmUKIpWiIiEqH+9u4q4uIMVx412ukou+Xzds+8qmWwO3Z2opDIUlhWzYTBLtKTVfb1pJFgcVRifBznHpzLez88kl+dPIlVVY2cef8nXPjI5yxeX/OlY+es3MLX7/qQkg113HnOFH53ar4K4N3wed1q1iEiIhGpbFsj/yys4NyDcsN6Wc8kjwtjoEgzryRMdfoti9bXUDA8y+koYUeXBCQspCTG852ZIzn7wFye+HQd972/mlPumcuxEwdx/bFjeWvpZu5+t5RxOZncc14BY3IynI4c1vI8Ll5eWMmW+lYGZiY7HUdERKTX7pq9isT48B4FBs28kvBXWlVPQ2uH1gPvgopgCSupSfFcNms05x48nEfnruXBOWv4xt2bAThz2lB+c4qP1CSN/n6V7ilaJRtqOTKGt4sSEZHIsnpLAy8vrOCSw0aSkxn+U4x9HhefrNnmdAyRXVpQ1tUUa9pwFcE7UxEsYSkjOYGrjx7LBYeO4IlP1jG0XxqnTvU6HSti5HlcAJRsqFMRLCIiEeOu2aUkJ8Rz+RHhPQrczed1869FG6iqb4mIol1iS2FZDf3Tk8gNsy3GwoGKYAlr7tRErj56rNMxIk5mSiIjB6RTVKEpWiIiEhlKN9fz6uINXD5rNAMyImMpzxczr+rIGa8iWMLLwvJqpub20xZeu6DGWCJRKs/joljrlEREJELcMbuUtMR4Lps1yukovTYpMPOqWBedJcxsb2xjzdZGTYXeDRXBIlHK53VTUd1MTVOb01FERET2aPmmOl5bspHvzhxJdnqS03F6zRWYeaWLzhJuFpZ3rQcuyM1yNkiYUhEsEqV8ni+maImIiISzO94uJTM5gUsPH+l0lL2W53FpW0IJO4Xl1STEGQ4YmuV0lLCkIlgkSnU3xyrW/oUiIhLGiitreaNkExcfNpKstMgZBe6W73VTWdNMdaNmXkn4KCyrYeIQl3ZV2Q0VwSJRql96Et6sVIo1EiwiImHsjndKcaUkcPFhkTcKDF80x9KUaAkXHZ1+Fq2v0XrgPVARLBLFfF4XJRoJFhGRMLWkooZ3lm3me4ePwp2a6HScffLFzCtddJbwsHxTPc3tnUzVeuDdUhEsEsV8HjdrtjZS39LudBQREZH/cfvbK8lKS+Q7M0c4HWWfZaUlMSw7VcuPJGx80RRLI8G7oyJYJIr5hnZN0Vq2sd7hJCIiIl9WWF7Neyu2cNmsUWSmROYocDefx63p0BI2FpRVk5OZzNB+qU5HCVsqgkWiWHeH6CJdnRYRkTBz+9sryU5P4qJDRzgdZb/5vG7KtjVR26yZV+K8wvIaCnL7YYxxOkrYUhEsEsUGZiYzyJWsdcEiIhJW5q3bzoelW7niiFGkJyc4HWe/dTfHKtFosDhsS30r5dubKBie5XSUsKYiWCTKaYqWiIiEm9vfXsmAjGQuOGSE01GCwhdojlWi5ljisMLAemB1ht4zFcEiUS7P62ZVVQPNbZ1ORxEREeGT1dv4ePU2vn/k6KjZw7R/RjIed4qWH4njCsurSYw35AWWxMmuqQgWiXI+jwu/hWWbdHVaREScZa3l9rdXMsiVzHkH5zodJ6jyvJp5Jc5bWFZDnsdNSmJ0XGAKFRXBIlFuxzolXZ0WERGHzV21jc/Xbeeqo8ZE3Q/pPo+btVsbaWjtcDqKxKj2Tj+LK2q0NVIvqAgWiXJD3ClkpydRrHVKIiLiIGstt729giHuFM4+cJjTcYIuf6gLa2HpBp1vxRlLN9TR2uHXeuBeUBEsEuWMMeR5XJqiJSIijvpg5RYKy2u4+ugxJCdE1ygwfLEtYbFmXolDuptiqTP0V1MRLBID8r1uVm6up7VDzbFERKTvda8F9malcua06BsFBshxpTAwM1kXncUxheU1DHGnMMSd6nSUsKciWCQG+Lxu2jstKzc1OB1FRERi0LvLq1hcUcu1x4whKSF6f/zM97o1EiyOKSyrpkBToXslev8XEpEddkzR0tVpERHpY11rgVeSm53G6QVDnY4TUj6PS9sSiiM217VQWdOspli9pCJYJAYMy04lMyVBV6dFRKTPvbV0MyUb6rj2mLEkxkf3j555Xjd+C0s3qjmW9K3CssB64NwsZ4NEiOj+n0hEgK7mWD6Pm2J1rBQRkT7k93etBR45IJ1Tp3icjhNy+d3bEmrmlfSxBWXVJCXEkReY/Sd7piJYJEb4vC6WbayjvdPvdBQREYkRb5RsYvmmeq47ZiwJUT4KDD23JVQRLH2rsLyaA7zuqF5zH0z6lERihM/rpq3Dz+otao4lIiKh1xkYBR49MJ2TJ0f/KDAEZl553RRVauaV9J3Wjk6KK+vUFGsvqAgWiRF5O/Yv1IlZRERC77WijZRWNXD9seOIjzNOx+kzPo+L0s31tLSrOZb0jZINdbR1+rUeeC+oCBaJESMHpJOWFK8pWiIiEnKdfssd76xk3KAMTsof4nScPuXzuunwW1Zurnc6isSIL5piaSS4t1QEi8SI+DhDnselZh0iIhJyry6uZM2WRm44dhxxMTQKDF80xyrSRWfpI4Xl1Qztl0qOK8XpKBFDRbBIDMnzuCnZUEen3zodRUREolRHp5873yll4hAXJ+QNdjpOnxvaLxVXSoKWH0mfsNayoKxao8B7SUWwSAzxed00tXWydmuj01FERCRKvbSwknXbmrjh2LExNwoMXzTH0swr6QsbalvYXNfKNDXF2ithUwQbY040xqwwxqwyxty0i+8nG2OeC3z/M2PMiMDj/Y0x7xljGowxf+vz4CIRxOd1Adq/UEREQqO9089ds0vxeV0cN2mQ03Eck+91s3xjPW0d2pZQQkvrgfdNWBTBxph44B7ga8Ak4NvGmEk7HXYJUG2tHQPcDtwaeLwF+Dnwwz6KKxKxxgzMIDkhTs2xREQkJP65oIKK6mZuPG4cxsTeKHC3PK+btk4/pVVqjiWhVVheTUpiHBOGZDodJaKERREMHASsstausda2Ac8Cp+x0zCnAY4Gv/wkcY4wx1tpGa+1HdBXDIrIHCfFxTBji0jolEREJutaOTv727iqmDMviqPE5TsdxlM/TNfNKF50l1ArLqjlgaBaJ8eFS1kWGcPm0vMD6HvcrAo/t8hhrbQdQC/Tvk3QiUcTncVG8oRZr1RxLRESC5/n5FVTWaBQYYET/dDKS1RxLQqulvZOSDXVaD7wPwqUI7hPGmMuMMfONMfO3bNnidBwRR/i8bupbOli/vdnpKCIiEiVa2ju5591VTB/ej8PHDnA6juPi4gyTAhedRUKlqLKWDr/VeuB9EC5FcCUwrMf9oYHHdnmMMSYBcAPb9uZNrLUPWmunW2unDxw4cD/iikQun6dr/0KdmEVEJFie/bycTXUtGgXuId/rZtnGOjo61RxLQqO7KdbU3Cxng0SgcCmC5wFjjTEjjTFJwDnAqzsd8ypwUeDrbwHvWs3nFNlr4wZnkBhvKNI6JRERCYKW9k7ueX81B4/M5tDRWqnWzed10dLuZ/UWbUsoobGgrJoR/dMYkJHsdJSIExZFcGCN79XAm8Ay4HlrbYkx5jfGmG8GDnsY6G+MWQXcCOzYRskYsw64DfiOMaZiF52lRSQgOSGecYMy1axDRESC4slPy9hS38oNGgX+kh0zr3S+lRCw1lJYXqOp0PsowekA3ay1rwOv7/TYL3p83QKcuZvnjghpOJEo4/O4eXvZZqy1+oFFRET2WVNbB/d/sJqZY/pzyCiNAvc0amAGqYnxFFXWcsa0oU7HkShTUd3M1oZWpqop1j4Ji5FgEelbPq+L7Y1tbKzVzmIiIrLvnvikjK0Nbdxw7Dino4Sd+EBzrBL14JAQWBBYD1yg9cD7REWwSAzK82qKloiI7J+G1q5R4FnjBjJ9RLbTccKSz+OiZEMdfr/a2EhwFZZXk54Uz/hBmU5HiUgqgkVi0MTBLuIMFG/Q/oUiIrJvHvt4HdVN7dxw7Fino4Qtn9dNU1sna7aqOZYEV2F5NZOHZZEQr3JuX+hTE4lBqUnxjMnJoEQjwSIisg/qW9p5cM4ajp6Qw1Q15tktX2DmlaZESzA1tXWwbGO9mmLtBxXBIjHK53Frr2AREdkn/5i7jtrmdq0F/gpjcjJISoijqELnWwmexetr6fRbpqkp1j5TESwSo/K8bjbXtVJVr+ZYIiLSe7VN7fz9wzUcN2kQ+UPdTscJa4nxcUwc4tJFZwmqwvKuplhT1RRrn6kIFolR+d1TtCq1LlhERHrv4Y/WUN/SwfVaC9wrPo+Lkko1x5LgWVhezaiB6WSlJTkdJWKpCBaJUZM8LkAdokVEpPeqG9t4ZO46vuYbTJ5Ho8C9ke91U9/aQfn2JqejSBSw1lJYXsM0rQfeLyqCRWJURnICowaka4qWiIj02t8/XENjWwfXay1wr3U3x9L5VoJh3bYmtje2UaD1wPtFRbBIDMvzuinWdGgREemFbQ2tPPrxOk7KH8L4wdqbtLfGDsogMd7ofCtBUVjWtR5YnaH3T6+KYGPMUcaYkYGvhxhjHjPG/MMYMzi08UQklHweF5U1zVQ3tjkdRUREwtyDc9bQ0t6ptcB7KTkhnvGDM7X8SIJiQXk1mckJjM3JcDpKROvtSPC9QGfg678CiYAfeDAUoUSkb3yxf6GuTouIyO5tqW/lsU/WccoUL2NyNAq8t7q3JbRWzbFk/xSWVTMlN4u4OON0lIjW2yLYa60tN8YkACcAlwHfB2aELJmIhFxed3MsrVMSEZE9uP+D1bR3Wq49RqPA+yLP66amqZ3Kmmano0gEa2jtYOXmek2FDoLeFsF1xphBwBHAUmttQ+DxxNDEEpG+kJWWxNB+qZqiJSIiu7W5roUnPy3jtKleRg5IdzpOROrellDnW9kfi9fX4LeoKVYQ9LYIvhuYBzwF3BN4bCawPBShRKTv+DxuTYcWEZHduu/91XT4LdcerVHgfTVhcCbxcWqOJftnQVk1xsCUYVlOR4l4vSqCrbW3AscCM621zwYergQuDVUwEekb+UPdrN3aSF1Lu9NRRILGWsuSihr8fq2/E9kfG2ubefqzcs6cNpTc/mlOx4lYKYnxjM3JoEgjwbIfCsurGZuTgTtVk3H3195skbQW8Bhjzg7crwTWBD+SiPSl7nXBSzUaLFHkgTlr+Obf5nLeQ59RUd3kdByRiHXPe6uwWK46aozTUSKez+umuFLNsWTf+P2WheU1Wg8cJL3dIikfWAn8HXg48PARwCMhyiUifSTPo3VKEl3WbW3k9rdXku91U1RZy4l3fMhz88r1g6fIXqqobuK5ees5a/owhmVrFHh/+TwutjW2sbmu1ekoEoHWbG2gtrldRXCQ9HYk+D7gF9baCUD3nMkPgMNCkkpE+szAzGQGu1K0LliigrWWm18qIik+jocums5/rzscn9fF/71YxKWPzaeqrsXpiCIR4573VmEwGgUOkvyhXRedNSVa9kVhWQ2gpljB0tsiOA94MvC1BbDWNgKpoQglIn3L53VpJFiiwgvzK/hkzTZu/vpEBrlSGJadxtOXHsIvT57ER6u2cvwdc/jPkg1OxxQJe+XbmnhhfgXfPmgYniz9uBcME4e4MEYzr2TfFJZX405NZJQ6tAdFb4vgdcC0ng8YYw4CVgU7kIj0vTyPm9VbGmhq63A6isg+q6pv4fevL+Ogkdmcc+CwHY/HxRm+O3Mkr193OMP7p3P10wu55pmFVDe2OZhWJLzd9W4pcXGGKzUKHDRpSQmMHphByQYVwbL3FpRVMzU3i7g443SUqNDbIvjnwGvGmF8DScaYm4EXgJ+FLJmI9Bmf143fwrKN9U5HEdlnv/73UprbO/nj6fm7/CFh9MAMXrziUH54/DjeKN7I8XfM4b3lVQ4kFQlva7c28lJhBecfPJxBrhSn40SV7l4FInujtrmd0qoGpmk9cND0douk/wAnAgPpWgs8HDjdWvtWCLOJSB/xebs6ROvqtESqt5du5rUlG7n26DGMHpix2+MS4uO4+uix/OuqmWSnJfHdR+dx80tLaGjVLAiRbnfNLiUpIY4rjhzldJSok+dxsbmulap69SeQ3lu0vgbQeuBg6vUWSdbahdbaK621J1lrr7DWLghlMBHpO4NdKfRPT9I6JYlI9S3t/PxfxUwYnMlls0b36jl5HjevXjOTK44YzXPz1nPiHXP4dM22ECcVCX+rqup5ZVElFx46gpxMjQIHm8/b1RxLzShlbxSWVRNnYPKwLKejRI2E3hxkjPnN7r5nrf1F8OKIiBOMMfi8booqdVKWyPOnN1awub6F+y+YRlJCr6/tkpwQz01fm8Bxk3L4wfOL+fbfP+XimSP50QnjSUmMD2FikfB15+xVpCTGc/ksjQKHQp6na+ZVcUUtR43PcTiNRIrC8mrGD3aRkdyr0k16obc/LQzb6XYg8EOgd5fcRSTs+bwuSjfX09Le6XQUkV6bv247T3xaxndnjGTKPl4hnzY8m9evO5wLDhnOwx+t5aS7PmRxYOqZSCxZsame/yzZwEUzRtA/I9npOFEpMyWRkQPSKdbyI+klv9+yqLyGgtwsp6NEld6uCf7uTrevAacDWkQlEiV8HjcdfsvKzWqOJZGhtaOT/3txCd6sVH5w/Lj9eq20pAR+c4qPJy85mKa2Tk6/72Nue2sF7Z3+IKUVCX93zl5JWmI8lx2uUeBQ8nndFGvmlfRSaVUD9a0dFKgpVlD1ft7Y/3oLODVIOUTEYd3rlHRilkhxz3urWb2lkd+f5iM9SFPEDhs7gDeun8UpUzzc9e4qTr1nLis26cKQRL+lG+p4vWgTFx82kn7pSU7HiWo+j4vKmma2a5s26YUFZdWAmmIFW6+KYGPMqJ1uPuB3wPrQxhORvjK0XyqulARN0ZKIsGJTPfe9v4rTpno5Msjr6typidx21hQeuGAam2pbOPnuj3jgg9V0+m1Q30cknNzxzkoyUxK49DCNAofaF82xdL6Vr1ZYXk12ehIj+qc5HSWq9HYkeBVQGvh1FfApcDhwUYhyiUgf626OVaIO0RLmOv2Wm15aQmZKIj//xqSQvc8JeYN584ZZHDVhIH/873LOefATyrY1huz9RJxSVFHLW0s3c+lho3CnJTodJ+r5PF1FsPYLlt4oLK+mIDcLY4zTUaJKb9cEx1lr4wO/xllrM6y1h2ubJJHo4vO6WbapXusgJaw9+WkZC8tr+Pk3JpId4mmbAzKSuf/8adx+9mSWb6rnxDs+5IlPy7BWo8ISPe54ZyXu1ES+e9gIp6PEBHdaIsOyUynR8iP5CtWNbazZ0shUrQcOuv1ZEywiUSbP46Ktw8+qqgano4jsUmVNM396Yzmzxg3k1CnePnlPYwynTR3KWzfMYvqIfvz8X8Vc+MjnbKxt7pP3Fwml+eu2M3t5FZfNGoUrRaPAfcXncWv5kXylheu71gNP03rgoNttEWyMWW+MKf+qW1+GFZHQ+qI5lk7MEn6stfzs5SL8Fn5/qq/Pp4YNcafy+MUH8dtTfcxfV83xt8/h5YUVGhWWiFXT1MZ1zy7Cm5XKRTNGOB0npvi8bsq2NVHb3O50FAljhWU1xMcZDhjqdjpK1NlTO83z+yyFiISFkf3TSU+Kp7iyljOnD3M6jsiX/HvJRt5bsYWff2MSw7KdaRBijOGCQ4Zz+JgB/PCFxdzw3GLeLN7M70/zaV9ViSh+v+UHzy+mqr6FF66YQUaQOqxL7/RsjjVj9ACH00i4KiyvZuKQTNKS9O8z2Hb7iVprP+jLICLivLg4Q57HTfEGrVOS8FLd2MavXy1h8lA33wmDEasRA9J57vJDeejDNfz1rZWccMcc/nBaPsfnDXY6mkivPPjhGmYvr+JXJ09iyrAsp+PEHJ/HBUBJZZ2KYNmljk4/i9bX8K1pQ52OEpV6fVnBGDOFro7QA4Adc9Cstb8IfiwRcUqe18Wzn6+n02+Jj1MnQgkPv3ttGbXN7Tx56cFh8/cyPs5w+RGjOXJ8Djc+v4jLnljA6QVefnlyHu5Ura2U8PX52u38+c0VnJQ/RNOgHdI/IxmPO0UdomW3Vmyup6mtU+uBQ6S3+wRfBswFjgb+D8gHfgCMCV00EXGCz+Omub2TtVvVHEvCw4elW3ixsIIrjhjNxCEup+P8j/GDM3n5yplce/QYXlm0gRPvmMNHpVudjiWyS1sbWrnmmUKG9UvlljPyte2Kg/K8ao4lu1dYXgNAgTpDh0Rvu0P/GDjRWnsa0Bz49VuAVvOLRJkvmmNpSrQ4r6mtg5+8XMSoAelcfXT4XndNSojjxuPH8+L3Z5CWFM/5D3/GL14ppqmtw+loIjt0+i3XP7uImqZ27j1vGpnqBu2ofK+btVsbaWjV/xPyvwrLqhmQkczQfqlOR4lKvS2Cc6y1Hwa+9htj4qy1/wVODlEuEXHI6IHpJCfEqUO0hIXb317J+u3N/PH0fFIS452O85WmDMvitWsP5+KZI3n8kzK+fueHLCjb7nQsEQDuml3KR6u28ptT8pjkCb9ZFbHG53VhLSxVHw7ZhcLyaqYNz9JsjRDpbRFcYYwZEfh6JXCKMeZwoC0kqUTEMQnxcUwc4tIULXHckooaHv5oLecenMvBo/o7HafXUhLj+cXJk3jme4fQ4becef8n3PrGclo7Op2OJjFszsot3PVuKWcUDOUsdf8PCz6PtiWUXdva0ErZtiZNhQ6h3hbBfwImBr7+DfAk8C7w61CEEhFn+bwuSirr8Pu1/6k4o73Tz/+9WMSAjGRu+toEp+Psk0NH9+eN62dx1vRh3Pf+ak7521xKdHFJHLCptoXrn1vE2JwMfntqnkaWwkSOK4WczGQVwfI/CsuqAShQU6yQ6VURbK19NDD9mcCv/YB+1tr7QhlORJzh87ipb+2gfHuT01EkRj304VqWbazjN6f4cEXwusWM5ARuOeMAHvnOdLY1tnHqPXP527uldHT6nY4mMaK908/VTxfS0t7JvedN036jYcan5liyC4XlNSTGG/IDfVok+HrbHfoOY8yB3fettW3WWrWOFYlSO5pj6cQsDli7tZE73lnJiXmDOdEXHfvuHj1hEG9dP4sT8gbzl7dWcsb9n7B6i06jEnp/eXMF88uq+ePp+YzJyXA6juzE53GxqqqB5jYtl5AvFJZXM8njjoheGJGqt9OhDfCKMabUGPNrY8z4UIYSEWeNG5RJYrxRh2jpc9Zabn5pCUkJcfz6lDyn4wRVv/Qk/nZuAXd/eypl2xr5+p0f8o+5a7XsQELm7aWbeWDOGs4/JJdTpnidjiO74PO68VtYulHnW+nS3ulnSUUNBblZTkeJar2dDn0dMBS4EhgGfGqMWWCMuTGU4UTEGUkJcYwfnKn1i9Lnnp+/nk/XbOcnX5/IIFeK03FC4uTJHt66fhYzxwzg1/9eynkPfUZFtZYeSHCt397ED55fhM/r4mcnTXI6juxG98wrnW+l27KNdbS0+9UUK8R6OxKMtdZvrX3bWnsx4AO2AX8OWTIRcZTP46a4shZrNUolfaOqroXfv7aMg0dmc3aUd6/NcaXw8EXTufWMfJZU1HDiHR/y/Lz1+vcmQdHa0clVTxdigXvPnaYplWFsiDuF7PQkNceSHbqbYk1TU6yQ6nURbIxJN8acb4x5ja5tkjqAi0KWTEQcled1U93UzobaFqejSIz41b9LaOnw88fT84mLi/7utcYYzj4wlzeun0Wex8WPX1zCpY/Np6pe/+Zk//z+tWUsqajlL2dOJrd/mtNxZA+MMfi8boq0/EgCCstrGOxKwZOV6nSUqNbbxlgvAJuBy4D/AMOttV+31j4ZynAi4hyfxwVo/0LpG2+WbOL1ok1cd8xYRg2MreY9w7LTeOZ7h/Dzb0zio1VbOf72OfxnyQanY0mE+vfiDTz+SRnfO3wkJ+RFR2O5aOfzuCjdXE9Lu5pjCSwoq6ZgeJbTMaJeb0eC5wGTrLWzrLX3WWu3hjKUiDhv4hAX8XGGEhXBEmJ1Le384pViJgzO5LJZo5yO44i4OMMlh43ktWsPZ3h2Glc/vZBrnllITVOb09Ekgqze0sBNLy5h2vB+/PjEyNxfOxble910+C0rN9c7HUUcVlXXQmVNs9YD94HeNsb6k7W2PNRhRCR8pCTGM2ZgBsUbNEVLQuvW/y5nS30rt55xAInxvV6lE5XG5GTw4vdn8IPjxvHfoo0cf/sc3ltR5XQsiQDNbZ1c+WQhyYnx/O3cqTH/bymSdDfHKtJF55hXWN61HrhA64FDTv9Dishu5XldOilLSH2+djtPfVbOd2eOZPKwLKfjhIWE+DiuOWYs/7pqJv3SkvjuP+Zx80tLaGjtcDqahLGfv1LMyqp67jh7CkPcWksYSYb2S8WdmqhtCYXC8hqS4uPICyxJk9BRESwiu5XvdbOlvpWqOjXqkeBrae/k5peWMLRfKj84fpzTccKOz+vm1WtmcvkRo3h23nq+duccPluzzelYEoaen7+efy6o4JqjxjBr3ECn48he6mqO5VIPDmFBWTU+r4vkBHV0DzUVwSKyW91TtIq1f6GEwL3vrWL1lkZ+f1o+aUkJTscJS8kJ8dz8tYm8cPmhxBnDOX//lN/+Z6ka6MgOyzbW8fN/FTNjdH+uO1YXkyKVz+NmxaZ62jr8TkcRh7R1+CmqrNXWSH1kb7ZI6m+MucAY8+PAfY8xZmjooomI0yYOcWEMmqIlQbd8Ux33vr+a06d6OUIjV19p+ohsXr/2cM4/eDgPf7SWb9z9EUsqapyOJQ6rb2nnyqcKcacmcuc5U4mPga3FolWe101bp5/SKjXHilUlG2pp6/CrKVYf6e0WSUcAK4DzgJ8HHh4L3BeiXCISBjKSExg5IF1TtCSoOv2Wm14swpWayM++McnpOBEjPTmB357q4/GLD6KhpYPT7v2Y295eSXunRo5ikbWWm14qonx7E3d/eyoDM5OdjiT7Ib975pXOtzFrQZmaYvWl3o4E3wGcba09EejuzPEZcFAoQolI+PB53JSoQ7QE0eOfrGPR+hp+efIkstOTnI4TcWaNG8ib18/ilMke7ppdymn3ztXWKjHo8U/KeG3JRn54/HgOHtXf6Tiyn4Znp5GRnKCZVzFsYXkN3qxUBrlSnI4SE3pbBI+w1s4OfG0Dv7YBWsQlEuV8XheVNc1sb9R+pbL/Kqqb+PObKzhy/EC+OdnjdJyI5U5L5Lazp3D/+QVsrGnhG3d/xINzVtPpt1/9ZIl4i9fX8LvXlnLMhBwuj9G9taNNXJxhkselHhwxrLC8WqPAfai3RfBSY8wJOz12LFAU5DwiEmZ8nq4pWiU6Mct+stbys38VA/C7U30Yo/WL++tE3xDevGEWR44byB9eX845D35C2bZGp2NJCNU0tXHlU4XkZKbw17MmE6d1wFEj3+tm2cY6OrTEIeZsqGlmY20LBblZTkeJGb0tgn8APGWMeQxINcY8ADwK/ChUwUQkPOR5utcpaYqW7J9XF2/g/RVb+NEJ4xnaL83pOFFjQEYyD1wwjdvOmszyTfV87c4PefLTMqzVqHC08fstP3h+MVX1LdxzXgFZaVpOEE18Xhct7X5Wb9GFrFhTWN61HlidoftOr4pga+2nwAFACfAIsBY4yFo7L4TZRCQMuNMSGZadqmYdsl+2N7bx638vZcqwLC48dITTcaKOMYbTC4by5vWzKMjtx8/+VcxF/5jHplrt8R1NHvxwDbOXV/HTr09kyrAsp+NIkKk5VuwqLKshJTGOiUNcTkeJGb3tDp0MbLHW/slae5W19hZgc+BxEYly+V631inJfvndf5ZS19zOLWfkaxuXEPJkpfL4xQfx21PymLd2O8ff/gH/WlipUeEo8Pna7fz5zRWclD+Ei2aMcDqOhMDIARmkJsZTpCI45hSWV3OAN4vE+F7vXiv7qbef9NvAtJ0emwa8Gdw4IhKO8jxuyrY1Udvc7nQUiUAfrNzCSwsr+f6Ro5kwWFe5Qy0uznDBoSN4/brDGTsok+ufW8SVTxWyraHV6Wiyj7Y2tHLNM4XkZqdxyxn5Wk8fpeIDzbHUgyO2tLR3UrKhlqnDs5yOElN6WwTn07UlUk+fA5ODG0dEwpEvMEVrqbZKkr3U1NbBT18uYtTAdK46aozTcWLKyAHpPH/5ofzfiROYvayKk+76SD9cR6BOv+X6ZxdR09TOPecWkJmS6HQkCaF8b9e2hOr0HjuKK2tp77RMy9V64L7U2yK4Fhi002ODAK3cF4kBeZ6u0Tv9AC1767a3VlJR3cwtpx9ASmK803FiTnyc4ftHjublq2ZgDJx1/ye8t7zK6ViyF+6aXcpHq7bym1PymOTRTIpol+dx0dTWydqt+hE7VnQ3xdL2SH2rt0Xwi8DTxhifMSbNGJMPPA48H7poIhIuBmQkM8SdomYdslcWr6/hkblrOe/gXA4ame10nJiW53Hzr6tmMmJAOpc8No8nPi1zOpL0wpyVW7jr3VLOKBjKWdOHOR1H+kD3zCtddI4dC8qqyc1OY0CGWi31pd4WwT8FltE1Bboe+BRYAfwkRLlEJMzkedwUazq09FJ7p5//e3EJAzOT+b+vTXA6jgCDXCk8f/mhHDU+h5//q5jfv7YUv6Zchq1NtS1c/9wixuZk8NtT87QOOEaMzckgOSGOogoVwbHAWktheY22RnJAb7dIarHWXgWkA4OBDGvt1dZa7b0gEiN8XhertzTQ1NbhdBSJAA/OWcPyTfX89hQfLq1hDBvpyQk8eOF0Ljp0OH//cC1XPlVIc1un07FkJ+2dfq5+upCW9k7uPW8aaUkJTkeSPpIQH8eEIS7tyBAjKqqb2VLfSkFultNRYk6v+3AbY9zAgXQ1yTrKGHO0MebokCUTkbDi87ixFpZt1Giw7NmaLQ3cObuUr+cP5vi8wU7HkZ3Exxl+9c08fv6NSby5dBPn/P1TttSrc3Q4+cubK5hfVs0fT89nTE6G03Gkj/k8Lkoq6zRTIwZ0rweeqqZYfa63+wR/B9gA/Bt4uMftoZAlE5Gw0r1OSVO0ZE/8fsvNLxWRkhDHr76Z53Qc2Q1jDJccNpL7z5/Gik11nHbvXFZV1TsdS4C3l27mgTlrOP+QXE6Z4nU6jjgg3+umvrWD8u1NTkeRECssqyYtKZ4JgzOdjhJzejsS/HvgW9baQdbakT1uo0IZTkTCxyBXMgMykrUuWPboufnr+Wztdn560kRyMlOcjiNf4YS8wTx32aG0tPs5/d6P+Xj1VqcjxbT125v4wfOLyPe6+fk3JjkdRxzSfdFZU6KjX2F5DZOHZpEQ3+vJuRIkvf3EE4C3QhlERMKbMQaf16UO0bJbm+ta+MPryzhkVLY62UaQycOyePnKGQxypXDhw5/zzwUVTkeKSa0dnVz1dCEWuOfcApITtKVYrBo3KJPEeENxpS46R7Omtg6WbqyjYHiW01FiUm+L4FuBnxljdJlCJIb5PG5KqxpoaVcjHflfv3ylhNYOP388/QB1so0ww7LT+Of3Z3DIqP788IXF3Pb2SqzVesS+9Lv/LGNJRS1/PXMyuf3TnI4jDkpKiGP84ExddI5ySypq6fRbCrQe2BG9LWpvAH4G1BtjynveghXEGHOiMWaFMWaVMeamXXw/2RjzXOD7nxljRvT43s2Bx1cYY04IViYR+TKf10Wn37Jik9YOype9UbyJN0o2cf2xYxk5IN3pOLIP3KmJ/OO7B3LW9KHcNbuUG55bRGuHLnj1hVcXb+CJT8v43uEj1UxOgK6LzsUbanUxKoqpKZazettz//xQhjDGxAP3AMcBFcA8Y8yr1tqlPQ67BKi21o4xxpxD1+j02caYScA5QB7gAd4xxoyz1urMLRJkeZ4v1ilNHpblbBgJG7XN7fzilWImDnHxvcPVKiKSJcbHcesZBzC8fzp/fnMFG2pbePCCaWSlJTkdLWqt3tLAzS8uYdrwfvz4RO2pLV18XjfPzltPRXUzw7I1MyAaFZbVMGpAOtnp+v/VCb3dJ/iD3d2ClOMgYJW1do21tg14Fjhlp2NOAR4LfP1P4BjTNd/uFOBZa22rtXYtsCrweiISZEP7peJOTdQ6JfmSW99YztaGVm49I59ENfeIeMYYrjpqDHeeM4VF5TWcfu/HlG1rdDpWVGpu6+TKJwtJToznb+dO1b8f2aG7OVaJmmNFJWstheXVGgV2UG+3SEo2xvzeGLPGGFMbeOx4Y8zVQcrhBdb3uF8ReGyXx1hrO4BaoH8vnysiQdDdHEsnZen22ZptPP1ZOZccNpIDhmY5HUeC6JQpXp763sFsb2rjtHs/ZkHZdqcjRZ2fv1LMyqp67jh7CkPcqU7HkTAyYXAm8XFqjhWtyrY1sb2xjWnDVQQ7pbeXHG8HfMB5QPfihBLg+6EIFSrGmMuMMfONMfO3bNnidByRiOTzuFm+sZ72Tr/TUcRhLe2d3PxSEcOyU7nhuHFOx5EQOHBENi9fORNXSgLf/vtnvLZko9ORosbz89fzzwUVXHP0WGaNG+h0HAkzKYnxjM3JoEjNsaJS93pgdYZ2Tm+L4NOAc621nwB+AGttJcEbca0Eeu6nMTTw2C6PMcYkAG5gWy+fC4C19kFr7XRr7fSBA3XCEdkXeV43bZ1+Vm5Wc6xY97d3V7FmayN/OC2ftKTetpiQSDNyQDovXTmTA7xurnq6kPveX61mPftp2cY6fv6vYmaO6c91x4x1Oo6EKZ/XTXGlmmNFowVl1WQkJzA2J9PpKDGrt0VwGzs10TLGDKSrCA2GecBYY8xIY0wSXY2uXt3pmFeBiwJffwt413b9r/AqcE5gyvZIYCzweZByichO8rvXKWmKVkxbtrGO+z9YzRkFQzl8rC4qRrvs9CSevPRgTp7s4dY3lvOTl4s0G2Qf1be0c+VThbhTE7nj7KnEx2k7Mdk1n8fFtsY2Nte1Oh1FgqywvIYpw7L0799BvS2CXwAeCxSZGGOGAH+jq4HVfgus8b0aeBNYBjxvrS0xxvzGGPPNwGEPA/2NMauAG4GbAs8tAZ4HlgJvAFepM7RI6AzPTiMjOYFirQuOWZ1+y00vLsGdmsjPTprodBzpIymJ8dx59hSuOmo0z3y+nosfnUd9S7vTsSKKtZabXiyifHsTd397KgMzk52OJGEsf2jXRWdNiY4uDa0drNhUR4HWAzuqt0XwT4C1QBGQBZQCG4BfByuItfZ1a+04a+1oa+3vA4/9wlr7auDrFmvtmdbaMdbag6y1a3o89/eB54231v43WJlE5H/FxRkmeVwU66Qcsx79eB2LK2r5xcmT6KetHWJKXJzhRydM4E9nHMAnq7dx5v2fsKGm2elYEePxT8p4rWgjPzx+PAeP6u90HAlzE4e4iDPofBtllqyvwW+hIDfL6SgxrbdbJLVZa2+w1mYAg4DMwP220MYTkXDk87hZurGOTr/WKcWa9dub+MubKzhq/EC+OdnjdBxxyFkHDuPR7x5EZXUzp94zl6IK/ZD+VRavr+F3ry3lmAk5XD5L+2nLV0tLSmD0wAztyBBlFpR1NcWaOkwjwU7q7RZJo7pvQCYwssd9EYkxPq+LlnY/a7Y0OB1F+pC1lp/+qxhj4Hen5dO1VbvEqsPGDuDFK2eQGB/HWQ98wjtLNzsdKWzVNLVx5VOF5GSm8NezJhOndYDSSz6vW9Oho0xheTVjczJwpyU6HSWm9XY69Cq6pkCv6nErDdxEJMb4As2xtC44tryyaANzVm7hxyeMx5ulPU0Fxg3K5OWrZjB2UAaXPTGfR+eudTpS2PH7LT94fjFV9S3cc14BWWlaQiC9l+dxsbmular6FqejSBD4/ZaF62soyNUosNN6Ox06zlobH/g1DvAADwIXhDSdiISlUQPSSUmMo1gdomPGtoZWfv3vEqbmZnHBoSOcjiNhJCczhWcvO4RjJg7iV/9eyq//XaKlEj08+OEaZi+v4qdfn8iUYVlOx5EIox0ZosuarY3UNLVrf+Aw0NuR4C+x1m4Crgf+GNQ0IhIREuLjmDjEpSlaMeR3ry2jobWDW884QFs6yP9IS0rg/vOncfHMkfxj7jouf2IBTW0dTsdy3Odrt/PnN1dwUv4QLpoxwuk4EoEmeVyAmmNFi8LyrvXAGgl23j4VwQHjgbRgBRGRyOLzuFm6oQ6/Rnyi3vsrqnh5YSXfP3IM4wZlOh1HwlR8nOEXJ0/i19/M493lmzn7gU9jegrn1oZWrnmmkNzsNG45Q2voZd9kpiQyckC6lh9FiYXl1bhSuhqeibN62xjrQ2PMnB63+cBnwG2hjSci4Srf66ahtYOy7U1OR5EQamzt4KcvFzN6YDpXHTXa6TgSAS6aMYIHL5jOqqoGTrvnY1Zsqnc6Up/r9Fuue3YhNU3t3HNuAZkpaoAj+87ndWv5UZRYUFbN1Nx+ao4XBno7EvwQ8HCP2y3AAdZaTYcWiVF5Xk3RigV/fWsllTXN3HrGASQnxDsdRyLEsZMG8cIVh9Le6edb933Mh6VbnI7Up+6aXcrcVdv4zSl5O6aziuwrn8dFZU0z2xu1M2kkq2tpp7SqQVOhw0RvG2M9ttPtn9ZadYYWiWFjczJJio/TFK0otrC8mn98vJYLDhnO9BHZTseRCOPzuvnXVTPx9kvlu/+Yx3Pzyp2O1CfmrNzCXe+WckbBUM6aPszpOBIFdjTH0vk2oi0qr8FamDZcRXA4SNjdN4wxv+nNC1hrfxG8OCISKZIS4hg/OFMdK6NUW4efm18qYlBmCj8+cbzTcSRCebJSeeGKQ7nyqUL+78UiyrY18cPjx0ftVMBNtS1c/9wixuZk8NtT87QOWIIiz9NVBBdV1nL42IEOp5F9VVhejTEweZjb6SjCHopgoDeXL9URRySG+bwu/lu8CWutftiLMg/OWc3yTfX8/cLpWs8o+yUzJZFHvnMgv3ilmHvfX0359ib+cuZkUhKja3p9e6efq58upLW9k3vPm0Za0p5+xBLpPXdaIsOyU3XROcItKKtm/KBMnVPDxJ7+h15grf0bgDFmjLV2VR9lEpEIkedx88zn66msaWZoPzWLjxartzRw1+xVnJQ/hOMmDXI6jkSBxPg4/nBaPsP7p3PLf5ezqbaFBy+cTnZ6ktPRguYvb65gflk1d54zhTE56vwqwZXvdWv5UQTz+y2L1tdw8mSP01EkYE9rgn/f4+vCUAcRkcjjC6xTUtfK6OH3W25+qYiUxDh++c1JTseRKGKM4YojRnPPuQUsqazl9HvnsnZro9OxguLtpZt5YM4azj8kl1OmeJ2OI1Eoz+OmbFsTtc3tTkeRfbBqSwP1LR1qihVG9lQErzHG/NUYczGQaIy5eFe3vgoqIuFnwuBM4uOMOkRHkWfnrefztdv52UmTyMlMcTqORKGTDhjCM987hLqWDk67dy6fr93udKT9sn57Ez94fhH5Xjc//4YuHElo+NQcK6ItKKsGoCA3y9kgssOeiuCzATfwbSARuGAXt/NDHVBEwldKYjxjczI0RStKbK5r4Y+vL2PG6P6cOX2o03Ekik0b3o+Xr5xBdloS5z/0Ga8sqnQ60j5p7ejkyqcKscA95xZoGzEJGZ9H2xJGssKyavqlJTJyQLrTUSRgt2uCrbUrgUsBjDGzrbXH9FkqEYkYPq+b91dUqTlWFPjFK8W0dfr5w2n5+rOUkBveP52XrpzBZU8s4LpnF7F+exNXHTUmov7u/e4/yyiqrOXBC6aR2199ESR0+mck43GnaPlRhCosr6Ygt19E/f8W7Xq7T/COAtgYE9fzFrpoIhIJfB4XWxvaqKpvdTqK7Ic3ijfyZslmbjhuHCN0pVr6SFZaEk9cchCnTfXyl7dW8uN/LqGtw+90rF55dfEGnvi0jO8dPpLj8wY7HUdiQJ6aY0WkmqY2Vm9ppED7A4eVXhWxxpgCY8wnxphGoD1w6wj8KiIx7IvmWDoxR6ra5nZ+/koJeR4Xlx420uk4EmOSE+K57azJXHvMWF5YUMF3/vF52Df/Wb2lgZtfXML04f348YkTnI4jMSLf62bt1kYaWjucjiJ7YWF5DQBTtR44rPR2JPcx4D1gOjAqcBsZ+FVEYtjEIS6MUYfoSHbLf5exvbGNW884gIR4TfCRvmeM4cbjxvGXMyczb912vnXfx6zf3uR0rF1qbuvkyicLSU6M5+5zp5KofzPSR3xeF9bC0g0630aSwvJq4uMMk4dmOR1Feujt/9zDgZ9aa5dZa8t63kIZTkTCX3pyAqMGpGuKVoT6ZPU2nvl8PZccNnLHqL6IU741bSiPXXwQm+taOO3ej1m8vsbpSP/j568Us7KqnjvOnsIQd6rTcSSGaOZVZCosr2bC4EzSk3fbikkc0Nsi+GXg+FAGEZHI5fO6KdFJOeK0tHfyk5eLyM1O44ZjxzkdRwSAGaMH8NKVM0hJjOPsBz/hzZJNTkfa4fl56/nnggquOXoss8YNdDqOxJiczBRyMpNVBEeQTr9lUXmN9gcOQ70tglOAl40xbxljHu95C2U4EYkMPo+bDbUtbGtQc6xIctfsUtZubeQPp+WTmqStXSR8jMnJ5OUrZzJ+sIsrnlzAQx+uwVrraKZlG+v4+SvFzBzTn+uOGetoFoldPjXHiigrNtXT2NZJwfAsp6PITnpbBC8FbgXmAqt3uolIjMvzBvYv1DqliLF0Qx0PzFnDt6YN5bCxA5yOI/I/BmYm8+z3DuHEvMH87rVl/PLVEjo6nekcXd/SzpVPFeJOTeSOs6cSH6dtTsQZPq+bVVUNNLd1Oh1FeqGwvBqAabnZDieRnfVqcrq19tehDiIikSvP88U6pSM0RTDsdfotN720hH5pifz06xOdjiOyW6lJ8dxzbgG3vLGcB+esoaK6mbu/PbVP19ZZa7npxSLKtzfx9KUHMzAzuc/eW2RnPo8Lv4WlG+uYpi13wl5hWTUDMpIYlq3+AeFmtyPBxphZPb4+ene3vokpIuHMnZrI8P5plGiKVkT4x9y1LKmo5Zcn59EvPcnpOCJ7FBdn+MnXJ/LbU328v6KKsx74hM11LX32/o9/UsZrRRv54fHjOXhU/z57X5Fd6W6OpfNtZCgsr2Zqbj+M0eyRcLOnS6n3Ar7A1w/v5hiLtkkSEbrWBRepWUfYW7+9ib++tZJjJuTwjQOGOB1HpNcuOGQ4Q/ulcvVThZx6z1wevuhAJnlcIX3Pxetr+N1rSzlmQg6Xz9KPO+K8Ie4U+qcnUVSh822429bQyrptTZxzUK7TUWQXdjsSbK319fh65G5uOiOICNC1Lrh8exO1Te1OR5HdsNbyk5eLiDPw21N9ujItEeeo8Tm8cMUMrIUz7/+Y91dUhey9aprauPKpQnIyU/jrWZOJ0zpgCQPGGPK8bvXgiAALy2sA1Bk6TGmHdxEJCl9gXXDJRl2dDlcvL6zkw9Kt/N/XJuDJ0vokiUyTPC5evmoGuf3TueSx+Tz1WVnQ38Pvt/zg+cVU1bdwz3kFZKVp2YCED5/HRenmelra1RwrnC0oryYhznDAULfTUWQXVASLSFDkBaYlllTq6nQ42trQym/+s5SC3CzOP3i403FE9ssQdyovXHEos8YO4KcvF/PH15fh9wdvC6UHP1zD7OVV/PTrE5kyLCtorysSDPleNx1+y4pN9U5HkT0oLKsmz+MiJVFbEIYjFcEiEhT9M5LxuFO0f2GY+u1/ltLY2sGtZxygaZ0SFTKSE/j7hdM5/5BcHpizhqueLgzKyNhna7bx5zdXcFL+EC6aMWL/g4oEWXdzLJ1vw1d7p58lFbVM1VTosKUiWESCJs/rpljNscLOe8ureGXRBq48cgxjB2U6HUckaBLi4/jtKT5+dtJE3ijZxLf//ilbG1r3+fW2NrRyzTMLyc1O45Yz8rVuXsLS0H6puFMTKdbMq7C1fGM9ze2dFGgbq7ClIlhEgsbncbNmayMNrR1OR5GAhtYOfvpyEWNyMrjyqNFOxxEJOmMMlx4+ivvOK2DZxjpOu3cuq6oa9vp1Ov2W655dSG1zO/eeV0BmSmII0orsP2MMPq9LF53DWGF5NQAFuVnOBpHdUhEsIkHj87qwFpZt1NXpcPGXN1ewsa6FW8/IJzlB65Ikep3oG8Kzlx1Kc1snp987l09Wb9ur5981u5S5q7bx21N8TBwS2q2XRPaXz+NmxaZ62jr8TkeRXSgsr2aQKxmvmlCGLRXBIhI0+d3rlHR1OiwsLK/msU/WccEhw5k2PNvpOCIhN2VYFi9fOZMcVwoXPvIZLxVW9Op5c1Zu4a53SzmjYChnTh8a4pQi+8/nddPW6ae0Ss2xwtGCsmoKcvtpSUUYUxEsIkGT40phYGay1imFgbYOPze9WMRgVwo/OmG803FE+syw7DRevGIG04dnc+Pzi7n97ZVYu/vO0ZtqW7j+uUWMy8nkd9o/WyKETxedw1ZVfQsV1c3aHzjMqQgWkaDyeVyUqGOl4x74YDUrNtfzu1N9WtsoMcedlshjFx/EGQVDuXN2KT94fjGtHf/bObq908/VTxfS2t7JPecVkJqkJQMSGYZnp5GRnKCLzmGosKwGQE2xwpyKYBEJKp/XTWlVQ1C2KpF9s6qqgbvfXcU3DhjCMRMHOR1HxBFJCXH85cwDuPG4cby0sJILH/6c2qb2Lx3z5zdXML+smj+cns+YnAyHkorsvbg4Q57HRZFGgsPOwvJqkuLj8HnVWyCcqQgWkaDK87jp9FuWb9I6JSf4/ZabX1pCalI8vzw5z+k4Io4yxnDtMWO54+wpLCyv4bT75lK+rQmAt0o28eCcNZx/SC6nTPE6nFRk7/m8bpZtrKOjU82xwsmCsmryvC41owxzKoJFJKi6r3xqnZIznv68nHnrqvnZSRMZmJnsdByRsHDqVC9PXHIQ2xraOO3eufx78QZ++MJi8r1ufv6NSU7HE9knPq+L1g4/q7c0Oh1FAto6/CyprNV64AigIlhEgsqblUpWWqLWBTtgU20Lt/x3OTPH9Odb09ThVqSng0f156UrZ5CenMA1zyzEAvecW6DRGolY3TsyaEp0+Fi6sY62Dj/TtB447KkIFpGgMsbg87h1UnbAL14ppr3Tzx9Oy1eHW5FdGD0wg5evnMHpBV7uPa+A3P5pTkcS2WcjB2SQlhSvmVdhZEFZNYBGgiOAimARCbo8r4sVm+pp69A6pb6yoGw7by3dzLXHjGV4/3Sn44iErf4Zydx21hQOHzvQ6Sgi+yU+zjBpiHZkCCeF5dV43CkMdqc4HUW+gopgEQm6fK+b9k7Lys1qjtVXbn+7lP7pSXx35gino4iISB/xed2UbKij07/7vbCl7ywsq9bWSBFCRbCIBJ3P07VOSVen+8Zna7bx0aqtfP/I0aQlJTgdR0RE+kiex0VTWydrt6o5ltM21jazobZFU6EjhIpgEQm63Ow0MpMTKK6sczpKTLj9nZUMzEzm/EOGOx1FRET6UP5QXXQOF4VlNQAaCY4QKoJFJOji4gyTPC6KdVIOuY9Xb+XTNdu56sjRpCSqy62ISCwZMzCD5IQ4iip0vnVaYXk1yQlxTBricjqK9IKKYBEJCZ/XzbKNdXR0qjlWqFhrue2tlQx2pXDOQblOxxERkT6WEB/HhCG66BwOCsurOWCom6QElVeRQH9KIhISPq+LlnY/a7ROKWQ+LN3K/LJqrjp6jEaBRURiVL7XRUllHX41x3JMS3snxZW1Wg8cQVQEi0hIdDfH0hSt0LDWctvbK/FmpXLW9KFOxxEREYf4PG7qWzso397kdJSYVbKhlvZOy1QVwRFDRbCIhMSogRmkJMZpilaIvL9iC4vW13D10WNITtAosIhIrPJ5uy4663zrnC+aYmU5mkN6T0WwiIREfJxh0pCuKVoSXN2jwMOyU/nWNI0Ci4jEsnGDMkmMNxRVqgh2yoKyaoZlp5KTmeJ0FOklFcEiEjL5XjclG2q1TinI3l66maLKWq49eiyJ8fpvXEQkliUlxDF+cKYuOjvEWkthebXWA0cY/fQkIiGT53XT2NbJum1qjhUsfr/l9ndKGdE/jdOmep2OIyIiYSDf66Z4Qy3W6qJzX6usaaaqvpVp2h84oqgIFpGQ6W6OVbxBV6eD5c2STSzbWMd1x44lQaPAIiIC5Hnc1DS1U1Hd7HSUmLOgrBpAI8ERRj9BiUjIjB2UQVJ8HCVapxQUXaPAKxk9MJ1vTtYosIiIdOlujlWi5lh9bmF5DamJ8UwYnOl0FNkLKoJFJGQS4+OYMCRTHSuD5LWijazc3MD1x44jPs44HUdERMLEhMGZxMcZirUuuM8VlldzwFC3ZmdFGP1piUhI5XncFFfWaZ3Sfur0W+54ZyXjBmVwUv4Qp+OIiEgYSUmMZ2xOhjpE97Hmtk6WbqjTeuAIpCJYRELK53VR26x1Svvr1cWVrN7SyA3HjiNOo8AiIrITn9dNcaWaY/WlJRU1dPit1gNHIBXBIhJSO5pj6er0Puvo9HPnO6VMHOLihLzBTscREZEwlO91s62xjc11rU5HiRmF5TUATM3NcjSH7D0VwSISUuMHZ5IQZ7QueD+8vLCSdduauOHYsRoFFhGRXfJ5XQCaEt2HCsurGTkgnf4ZyU5Hkb2kIlhEQiolMZ6xgzLVrGMftXf6uevdUvK9bo6bNMjpOCIiEqYmDnERZzTzqq9Yayksq9YocIRSESwiIefzuLROaR+9uKCC9dubufG4cRijUWAREdm1tKQERg/MUBHcR8q3N7GtsU3rgSOUimARCTmf1intk9aOTu5+dxVThmVx5PiBTscREZEw5/O6tfyojxSWVwOoCI5QKoJFJOS61ynp6vTeeX5+BZU1GgUWEZHe8XndbK5rpaq+xekoUW9BWTXpSfGMH5zpdBTZByqCRSTkJg5xYQy6Or0XWto7uefdVUwf3o/Dxw5wOo6IiEQAn6fronOJ+nCEXGFZDVNys4hXw8qIpCJYRELui3VKOin31rOfl7OprkWjwCIi0muTPJp51RcaWztYvqlOU6EjmIpgEekT3c2x5Ku1tHdyz/urOWRUNjPGaBRYRER6JzMlkVED0jXzKsQWV9Tgt1AwXEVwpFIRLCJ9wud1s6muhS31ao71VZ78tIwt9a3ccOw4p6OIiEiEyfO6NfMqxArLAk2xhqkIjlQqgkWkT+R53ACU6Or0HjW1dXDf+6s5bMwADh7V3+k4IiISYXweF5U1zWxvbHM6StQqLK9h9MB03GmJTkeRfaQiWET6RF6gQ3TJBl2d3pPHPyljW2MbNxw31ukoIiISgfK9uugcStZaCsurmaap0BFNRbCI9AlXSiIj+qdpXfAeNLR28MAHqzli3ECmDc92Oo6IiESg7plXRTrfhsSarY3UNLWrKVaEUxEsIn0mz+tWs449eOzjdVQ3tXPDcVoLLCIi+8adlkhudpq2SQqRHeuBNRIc0Rwvgo0x2caYt40xpYFfd/k3yhhzUeCYUmPMRT0e/70xZr0xpqHvUovIvvB53Kzf3kxtU7vTUcJOXUs7D85Zw7ETc5gyLMvpOCIiEsF8XpdGgkOksLyGzJQExgzMcDqK7AfHi2DgJmC2tXYsMDtw/0uMMdnAL4GDgYOAX/Yolv8deExEwpxvx7pgnZh39shHa6ltbud6dYQWEZH9lOdxU769SRedQ2BheTVTc/sRF2ecjiL7IRyK4FOAxwJfPwacuotjTgDettZut9ZWA28DJwJYaz+11m7si6Aisn+61ylpSvSX1Ta18/CHazkhbxC+QEMTERGRfbWjOdZGnW+Dqa6lnRWb6ynIzXI6iuyncCiCB/UoYjcBg3ZxjBdY3+N+ReAxEYkg2elJeLNSKdI6pS956KM11Ld2aBRYRESCIs/TNfNKzSiDa/H6GqxFTbGiQEJfvIkx5h1g8C6+9dOed6y11hhjQ5jjMuAygNzc3FC9jYjsQZ7HRYlOyjtUN7bxyEdrOSl/CBOHuJyOIyIiUaB/RjIedwrFuugcVIVlNRgDUzQSHPH6pAi21h67u+8ZYzYbY4ZYazcaY4YAVbs4rBI4ssf9ocD7+5DjQeBBgOnTp4es2BaR3fN53by1dDP1Le1kpmiT+Qc/XENTeyfXHat9gUVEJHh82pEh6BaUVzMuJxOXfn6JeOEwHfpVoLvb80XAK7s45k3geGNMv0BDrOMDj4lIhOlep7RsY73DSZy3taGVR+eu45uTPYwblOl0HBERiSI+r5u1WxtpaO1wOkpU8PstC8urKRie5XQUCYJwKIJvAY4zxpQCxwbuY4yZbox5CMBaux34LTAvcPtN4DGMMX8yxlQAacaYCmPMrxz4PYhIL+V5tU6p2wMfrKa1o5Nrj9EosIiIBJfP68JaWLpBU6KDYfWWBupbOpiq9cBRoU+mQ++JtXYbcMwuHp8PXNrj/iPAI7s47sfAj0OZUUSCJyczhZzM5JifolVV18Ljn5Rx6lQvo7XXoIiIBFn3bgPFlbUcNDLb4TSRb07pVgCmDVcRHA3CYSRYRGKMz+umJMabddz3wWo6/JZrj9YosIiIBN+Oi86aebXfllTU8Oc3lzN9eD9GDUh3Oo4EgYpgEelzPo+L0qp6mts6nY7iiE21LTz1WTlnFHgZoZOpiIiESL6aY+23TbUtfO/x+fRPT+b+C6ZhjHE6kgSBimAR6XN5Xjd+C8s3xeZo8D3vrcLvt1yjUWAREQmhPK+bVVUNNLWpOda+aG7r5HuPz6ehpYOHvzOdARnJTkeSIFERLCJ9ruc6pVhTWdPMs/PKOevAYQzLTnM6joiIRDGfx4XfakeGfeH3W37wwiKKN9Ry17enMmGwy+lIEkQqgkWkz3ncKfRLS6Q4BtcF/+3dVRgMVx01xukoIiIS5fKHdl10LtGU6L12+zsreb1oEz/52kSOmTjI6TgSZCqCRaTPGWPwxeA6pfXbm3hh/nrOOWgY3qxUp+OIiEiUG+xKoX96EkUVsXW+3V+vLKrk7ndXcfb0YVx6+Ein40gIqAgWEUf4vG5Wbq6ntSN2mmPd/W4pcXGGK4/UKLCIiISeMYY8r5ti7RXca4Xl1fzon0s4eGQ2vz3Vp0ZYUUpFsIg4wudx095pKd3c4HSUPrFuayMvFlZy3sG5DHanOB1HRERiRL7XRenmelraY+ei876qrGnmsscXMMSdwv3nTyMpQaVStNKfrIg4wuftajARK82x7ppdSmK84ftHjnY6ioiIxBCfx02H37Jik5pj7UljaweXPDqP1o5OHr5oOv3Sk5yOJCGkIlhEHJGbnUZmSkJMrAteVdXAvxZVcuGhI8jJ1CiwiIj0nR07MsTA+XZfdfot1z27iNKqBu45t4AxOZlOR5IQUxEsIo4wxpDnccVEh+i7ZpeSkhjP5bNGOR1FRERizNB+qbhTY3NHht7605vLeWfZZn7xjUnMGjfQ6TjSB1QEi4hjfB43yzbW0dHpdzpKyKzcXM+/l2zgohkj6J+R7HQcERGJMV07MrhiZvnR3nph/noe+GANFxwynItmjHA6jvQRFcEi4hif101rh59VW6K3Odad75SSnpTAZYdrFFhERJzh87pZsameto7ovei8Lz5fu52fvFzEYWMG8IuTJzkdR/qQimARccwXzbGic4rW0g11vFa0kYtnjlCDDRERcYzP46at08/KzWqO1a18WxOXPzGfYf3SuOfcAhLjVRbFEv1pi4hjRg7IIC0pPmqnaN3xzkoyUxK45DCNAouIiHO6m2OVqDkWAHUt7Vzy2Dz8Fh7+zoG40xKdjiR9TEWwiDgmPs4waYgrKk/KRRW1vLV0M5ceNkonVxERcdTw7DQykxOidubV3ujo9HPN0wtZu7WR+84vYOSAdKcjiQNUBIuIo3xeNyUb6vD7rdNRguqOd1biTk3ku4eNcDqKiIjEuLg4wySPi6IonXm1N37/+jI+WLmF357qY8boAU7HEYeoCBYRR+V5XDS1dbJ2W6PTUYJm0foaZi+v4rJZo3ClaBRYRESc5/NG/44MX+Wpz8r4x9x1XDxzJN8+KNfpOOIgFcEi4qjudUrRtC74trdX0i8tUVstiIhI2MgP7Miwekv0XHTeGx+v2sovXynhqPED+elJE52OIw5TESwijhqTk0FSQhwlG6JjndL8dduZs3ILVxwxmozkBKfjiIiIAF/syBCLU6LXbGng+08VMmpgOnd9eyrxccbpSOIwFcEi4qjE+DgmDs6kqCI6Tsq3v7OSARlJXHDocKejiIiI7BDtOzLsTm1TO5c+Np/4OMPDFx1IppYpCSqCRSQM5HndFG+oxdrIbo716ZptzF21jSuOGE1akkaBRUQkfETzjgy7097p58qnF1BR3cwDF0xjWHaa05EkTKgIFhHH+Txu6ls6WL+92eko+8xay21vr2RgZjLnH6JRYBERCT/dOzJ0RtmODLtireVXr5Ywd9U2/nB6PgeOyHY6koQRFcEi4rjudUrFEXx1+pPV2/h87XauOnI0KYnxTscRERH5Hz6vu2tHhq3R3xzrsY/X8dRn5VxxxGi+NW2o03EkzKgIFhHHjR+cSUKcidh1StZa/vr2Soa4UzhHWy6IiEiY2nHROULPt731/ooqfvOfpRw/aRA/PmG803EkDKkIFhHHJSfEM25QJsUR2iF6TulWFpRVc9VRYzQKLCIiYWvMwAySE+Kiuggu3VzPNU8vZPxgF7efPYU4dYKWXVARLCJhwed1UVIZec2xutcCe7NSOWv6MKfjiIiI7FZCfBwTh7gievnRnmxvbOOSx+aTnBjPQxdNJ11bFcpuqAgWkbDg87rZ1tjGproWp6PslfdWVLF4fQ3XHD2GpAT9lyoiIuGt66JzHf4oa47V1uHniicXsKmuhb9fOA1vVqrTkSSM6Sc2EQkLeR43AMWVkTMlunsUeFh2Kmeo6YaIiEQAn8dNfWsH5dubnI4SNNZafvpyEZ+v3c6fv3UAU3P7OR1JwpyKYBEJCxOHZBJnoCiC1im9tXQzxZV1XHv0WBLj9d+piIiEP583cNE5iqZE//3DNbywoIJrjxnLKVO8TseRCKCf2kQkLKQlJTB6YAYlEVIE+/2W299eycgB6Zw2VSdcERGJDOMGZZIYbyLqovOevLN0M3/873JOyh/C9ceMdTqORAgVwSISNnxed8RcmX6jZBPLN9Vz3TFjSdAosIiIRIikhDjGD86kJIKWH+3Oso11XPfsQvK9bv5y5mR1gpZe009uIhI28jwuNte1UlUf3s2xOgOjwKMHpnPyZI/TcURERPZKfuCic6TtyNDTlvpWLn1sPpkpifz9wumkJmmLQuk9FcEiEjbyA+uUSsJ8v+DXijZSWtXA9ceOI15XnUVEJMLkedzUNLVTUd3sdJR90tLeyeVPzGdbYysPXTSdQa4UpyNJhFERLCJhY5LHBRDW64I7/ZY73lnJ+EGZnJQ/xOk4IiIie+2Li87he77dHWstN724hMLyGu44e8qORl8ie0NFsIiEjcyUREYOSA/rbZJeWVTJmi2N3HDcWK09EhGRiDR+cCbxcZHZHOve91fzr0Ub+NEJ4znRp4vRsm9UBItIWMnzuMK2OVZHp587Z5cyaYiL4ycNdjqOiIjIPklJjGdsTkZYX3Telf8WbeTPb67g1CkerjxytNNxJIKpCBaRsOLzuqmobqamqc3pKP/jpYWVlG1r4objxmkUWEREIlq+101xZeQ0xyqurOWG5xdRkJvFLWccgDE6D8u+UxEsImHF5+la2xNuV6fbO/3cNbuUfK+bYyfmOB1HRERkv/i8brY1trGpLrx3ZADYXNfCJY/No396Mg9cMJ2URHWClv2jIlhEwkpeoDlWuE2J/ueCCiqqm7nxuHG6+iwiIhHP5w2cb8PsovPOmts6+d7j82lo6eChi6YzMDPZ6UgSBVQEi0hY6ZeehDcrleIwatbR2tHJ3bNLmTIsiyPHD3Q6joiIyH6bOMRFnCGszrc78/stP3xhMUWVtdx5zlQmDnE5HUmihIpgEQk7Pq8rrPYKfn7eejbUtvCD4zUKLCIi0SEtKYHRAzPCugi+Y3YprxVt5OavTeDYSYOcjiNRREWwiISdfK+btVsbqW9pdzoKLe2d/O29VRw4oh+HjRngdBwREZGgyfe6w275UbdXFlVy1+xSzpo+lO8dPsrpOBJlVASLSNjJC2x8vzQMRoOf+byczXWt3KC1wCIiEmXyvG4217VSVR9ezbEWllfzo38u4aCR2fzu1HydfyXoVASLSNjZ0SHa4SK4ua2Te99fzSGjspkxWqPAIiISXXyBZpQlYdQcq7Kmme89voDBrhTuP38aSQkqVyT49LdKRMLOwMxkBrmSKXF4ndKTn5axpb6VG48b72gOERGRUOieeRUu64IbWzu49LH5tLZ38vBF08lOT3I6kkSpBKcDiIjsis/jpsjBk3Jjawf3f7Caw8cO4KCR2Y7lEBERCZWM5ARGDUh39Hzbze+3XP/cIlZsquMf3z2IsYMynY4kUUwjwSISlvK8blZvaaCprcOR93/8kzK2NbZx/bHjHHl/ERGRvpDndYfFjgx/enMFby/dzC++MYkjxmk7QgktFcEiEpZ8Hhd+C8s21vf5e9e3tPPAnNUcOX4g04b36/P3FxER6Sv5XheVNc1sb2xzLMM/F1Rw/werOf+QXC6aMcKxHBI7VASLSFjyBdYplTiwdcNjH6+jpqmdGzQKLCIiUW5HM0qHpkTPW7edm19awswx/fnlyXnqBC19QkWwiISlIe4UstOT+vykXNfSzoNz1nDsxBwmD8vq0/cWERHpa3k7dmTo+yJ4/fYmLn9iAcP6pXHvudNIjFdpIn1Df9NEJCwZY/B53RT38bYND3+4lrqWDq0FFhGRmOBOSyQ3O63Pt0mqb2nnksfm0em3PPydA3GnJfbp+0tsUxEsImHL53GxcnM9rR2dffJ+NU1tPPLRWk7MG7xjOraIiEi083ldfdohutNvueaZhazZ0sh95xUwckB6n723CKgIFpEw5vO66fBbVm5q6JP3e+jDtdS3dnD9cWP75P1ERETCgc/rpnx7E7VN7X3yfr9/bRnvr9jCr0/JY8aYAX3yniI9qQgWkbDl68N1Stsb2/jH3LWcdMAQJgx2hfz9REREwkX3+bZkY+jPt09/Vs4jc9fy3ZkjOO/g4SF/P5FdUREsImFrWHYqmSkJfTJF68E5a2hq7+T6YzQKLCIisaV7CVCom1F+vHorv3ilmCPHD+SnX58Y0vcS2RMVwSIStowx+DxuSkJ8Ut5S38pjH6/jm5M9jB2UGdL3EhERCTfZ6Ul4s1JD2oxy7dZGvv9kISMHpHPXt6eSoE7Q4iD97RORsObzuli2qZ72Tn/I3uOBD1bT2tHJdRoFFhGRGJXncYVs+VFtUzuXPDqP+DjDwxcdiCtFnaDFWSqCRSSs+bxu2jr8rKoKTXOsqroWnvi0jNOmDmXUwIyQvIeIiEi483ndrN3aSENrR1Bft73Tz1VPF7K+uon7z59Gbv+0oL6+yL5QESwiYS3PE9p1Sve+v5oOv+XaY8aE5PVFREQiQb7XjbWwdENwp0T/5t9L+WjVVv5wWj4HjcwO6muL7CsVwSIS1kYNSCc9KZ6SIJ+UATbWNvP05+V8q2Aow/trj0IREYlded6unRGC2YzysY/X8cSnZVx+xCjOnD4saK8rsr9UBItIWIuLM0zyuEIyEnzPe6vw+y1XH61RYBERiW05mSnkZCYHrRnlnJVb+PW/Szh24iB+fMKEoLymSLCoCBaRsJfncbN0Yx2dfhu016yobuK5ees568BhDMvW+iQREZF8rzsozbFWVdVz1VOFjB/s4s5zphAfZ4KQTiR4VASLSNjzed00tXWydmtj0F7znvdWYTBcfZRGgUVERADyvG5WVTXQ1LbvzbGqG9u4+NH5JCfG89BF00lPTghiQpHgUBEsImHPF1inFKwp0eXbmnhhfgXfPmgYnqzUoLymiIhIpMv3uvFbWLaxfp+e39bh5/InF7CproUHL5yGV+dYCVMqgkUk7I0ZmEFyQlzQiuC73y0lLs5wpUaBRUREdui+6FyyD1OirbX87F9FfL52O3/+1gEU5PYLdjyRoFERLCJhLyE+jglDXEFZp7R2ayMvLazk/IOHM8iVEoR0IiIi0WGwK4X+6UkUVez9+fbhj9by/PwKrj16DKdM8YYgnUjwqAgWkYjg87goqazDv5/Nse6aXUpivOGKI0cFKZmIiEh0MMbg87op3sttCWcv28zvX1/G1/MHc/2x40KUTiR4VASLSETwed3Ut3awvrppn19jVVU9ryyq5KJDR5CTqVFgERGRnfm8Lko319PS3tmr45dvquPaZxbi87j565lTiFMnaIkAKoJFJCLke90AFFfu3dXpnu6cvYqUxHgum6VRYBERkV3xedx0+C0rNn11c6ytDa1c8uh8MlIS+PuF00lNiu+DhCL7T0WwiESEsYMySIw3+7wueMWmev6zZAPfmTGC/hnJQU4nIiISHXzdF52/4nzb0t7J5U8sYFtjKw9deCCD3ZphJZFDG3eJSERITohn3KDMfe4QfefslaQnJfC9wzUKLCIisjtD+6XiTk3c4/nWWsvNLxWxoKyae88rIH+ouw8Tiuw/x0eCjTHZxpi3jTGlgV932U/dGHNR4JhSY8xFgcfSjDGvGWOWG2NKjDG39G16EelLPo+bkg11WLt3zbFKNtTyetEmLp45gn7pSSFKJyIiEvm6mmO59rj86N73V/Pywkp+ePw4vp4/pA/TiQSH40UwcBMw21o7FpgduP8lxphs4JfAwcBBwC97FMt/sdZOAKYCM40xX+ub2CLS13xeF9sb29hQ27JXz7vjnVIyUxK45DCNAouIiHwVn9fNik31tHX4/+d7bxRv5M9vruCUKR6uOmqMA+lE9l84FMGnAI8Fvn4MOHUXx5wAvG2t3W6trQbeBk601jZZa98DsNa2AYXA0NBHFhEn5O1ojtX7KdFFFbW8vXQz3zt8FO60xFBFExERiRo+j5u2Tj8rN3+5OVZxZS03PLeYqblZ3HrGARijTtASmcKhCB5krd0Y+HoTMGgXx3iB9T3uVwQe28EYkwWcTNdosohEoYmDXcQZKNmLIvj2d1biTk3kuzNHhC6YiIhIFOnekaGkR3OsqroWLn1sPv3SEnnwgumkJKoTtESuPimCjTHvGGOKd3E7pedxtmuh394t9ut6/QTgGeAua+2aPRx3mTFmvjFm/pYtW/b69yEizkpNimdMTgbFG3q3TdLC8mreXV7FZbNGkZmiUWAREZHeyM1OIzM5Yce64Jb2Tr73+HzqWtp5+DsHMjBTuyxIZOuT7tDW2mN39z1jzGZjzBBr7UZjzBCgaheHVQJH9rg/FHi/x/0HgVJr7R1fkePBwLFMnz59r4ttEXGez+Pmo1Vbe3Xs7e+Ukp2exEUzRoQ2lIiISBSJizNM8rgoqqzFWssPXljMkspaHrxgOhOHuJyOJ7LfwmE69KvARYGvLwJe2cUxbwLHG2P6BRpiHR94DGPM7wA3cH3oo4qI03xeN1X1rVTV7bk51vx125mzcguXzxpFRrJ2gxMREdkb+V43yzbW8de3VvLako3cdOIEjpu0q1WLIpEnHIrgW4DjjDGlwLGB+xhjphtjHgKw1m4HfgvMC9x+Y63dbowZCvwUmAQUGmMWGWMudeI3ISJ9w7djndKep0Tf9vZKBmQkc+GhI/oglYiISHTxed20dvj523urOHPaUC6bpR0WJHo4Pjxird0GHLOLx+cDl/a4/wjwyE7HVABqSycSQyZ5uqZhFVfWctSEnF0e88nqbXy8ehs//8YkUpPUuENERGRv5Q/tuuh80Ihsfn9avjpBS1RxvAgWEdkbGckJjBqQTvGGXXeIttZy+zsryclM5ryDc/s4nYiISHQYPTCD+84rYMaYASQlhMPkUZHg0d9oEYk4eV73jo6VO/t49TY+X7udq44ao+0bRERE9sPX8ofgTtXuChJ9VASLSMTxeVxU1jSzvbHtS49ba/nrWysY4k7h7AOHOZRORERERMKZimARiThfNMf68pToD1ZuobC8RqPAIiIiIrJbKoJFJOLk7WiO9cWUaGstt7+9Em9WKmdN1yiwiIiIiOyaimARiThZaUkM7Zf6peZY7y6vYnFFLdceM0YNPERERERkt/SToohEpHyvm5LKriLYWsttb68kNzuN0wuGOpxMRERERMKZimARiUg+r5t125qoa2nnzZLNlGyo49pjxpIYr//WRERERGT39NOiiESkL9YF13LHOysZOSCdU6d4HE4lIiIiIuFORbCIRKQ8T1eH6NveWsnyTfVcd8xYEjQKLCIiIiJfQT8xikhEGpiZzGBXCvPLqhmTk8HJkzUKLCIiIiJfTUWwiEQsn7drSvT1x44lPs44nEZEREREIkGC0wFERPbVaVOHkpqUwNd9Q5yOIiIiIiIRQkWwiESskw4YwkkHqAAWERERkd7TdGgRERERERGJGSqCRUREREREJGaoCBYREREREZGYoSJYREREREREYoaKYBEREREREYkZKoJFREREREQkZqgIFhERERERkZihIlhERERERERihopgERERERERiRkqgkVERERERCRmqAgWERERERGRmKEiWERERP6/vbsOl6u63jj+fZPg7u4U9+JaihQtUNwpULRooUBxSilQnOJWXIs7xSnuFHeX4h7s/f2x9jQn95eEJNy5Z2bu+jwPDxm5uXsmM+ectffaa6WUUkq9RgbBKaWUUkoppZR6jQyCU0oppZRSSin1GhkEp5RSSimllFLqNTIITimllFJKKaXUa2QQnFJKKaWUUkqp18ggOKWUUkoppZRSryHbdY+hFpL+C7xa9ziGYHzg/boH0ULy/RhYvh8D5HsxsHw/Bsj3YmD5fgws348B8r0YWL4fA8v3Y4B8LwbWDu/HVLYn6Hpnrw2CW52kB23PW/c4WkW+HwPL92OAfC8Glu/HAPleDCzfj4Hl+zFAvhcDy/djYPl+DJDvxcDa+f3IdOiUUkoppZRSSr1GBsEppZRSSimllHqNDIJb18l1D6DF5PsxsHw/Bsj3YmD5fgyQ78XA8v0YWL4fA+R7MbB8PwaW78cA+V4MrG3fj9wTnFJKKaWUUkqp18iV4JRSSimllFJKvUYGwW1EkuoeQ0oppZRSSim1swyC24htS8p/s5RSSimllFIaThlQtQFJS0g6TdLktn8o9+W/XUoppabJ80xKKaVOlSe49jAWMAFwnqSdJfXLYHjQJI1U9xhSe+vN2w5682tPofoZaJxnUkpDT1Lf8v8xK/flsTX1Wq36+c8Aqj1cA+wOXAL8CrhG0mow4CKlVT9gPUnSrMCOkmarTg500nsjqV/5/5jlv/HrHlOnaFy4AH0lTShpYklj1TqoJuv63ShbLtRJ35lhVbmAXUDSJpXPRceT1Ld8BuaRdLCk0eoeUyeofKYWKe/tyHWPqZkaxw9Jo9Q9ljrY/r788VJJe5b7OqoVS286LrabyvFmCkm/bEzGVL6XTTu/N669JfWVNFLjGrVVP/8ZBLcB29/bfgo4HdgfeBjYVdI5kuYuz2nJD1gPmwtYD9gDWE/S1NA5742kPra/kzQqcAHwKHCkpO0lzVDv6DrKwcDtwFXAHpJW6MQMg/J5sqQxJK0u6UBJC7vorVkmlQvYM4CJgMbEU7/aBtVDKq/9FKAv8LWkfmXCbez6Rta+yvfse0njABcD4wHflMc6LkisHFfGAnaSNHP1oruXHVeOAVaUtCa052uvBFTjSJpW0jIw0LEitZjKv80FwHLAV10eb8o1cfnu/yBpXOBvwF3AwWU753jN+J0/VfYJbnGSNKgPbDkQrQvMCDwA/Nn2Bz09vlYjaVJgV2Bm4HXgQuAh2x/VOrCfQNIYwErABeXi4h/AmMCRRGbArMAHwK3Av2y/W9dY25GkbYFrbb8saV7ifVwAWBhYBBiDmHC42fY9tQ20mzWOLZKuACYDXiA+T/cAv7P9ZvV5NQ61x5SV0O8l7QqsbnvBEvzuBvwauN72vvWOsjkqr30DYA/bs5b7jwUWIo6nW9t+p85xtpvK9+wS4AvbG0uaDFgdmA+4GzixU75jlQvhfwJf2t6w3D8W8IPtz+odYc8px45dgBWAzWw/X/OQhknl33Jk4FLiXPg5cV5czPZjtQ4w/T+Vf7P1iLhgunL/tsAMxL/fEc2IFyrHuiuB94BTiSD8t8D0xATg+7a/6+7fPbzablaqt2mcGCWtKulvko6RtK3tm4DtgROB2ct/vVbJ4BzR9lvAv4BvgXWA44gU6fkkjVjrIIffQsC5wG2SFgFeJi5S77S9F3AU8CWwEbBNbaNsQ+XkviXwn5K2Nj7wF9tP2T6VmFC5HZgD+JOkaeobbfcqJ6spgUmJi5p1iYvyb4DnJB3XeF59o+wZjdWOEgT2BWYBzisPnwosCJwPbCRpsXpG2Rwls6Tx2gVMAdyu2A5wNDAb8T2YgJiMS8OgfM/GIY4tu5e7LwQWB34o/++YTJNyAT4vsASwOYCkPxPXKg9KWqrO8TVTJd10BADb39k+GHgEOKu8L+2UStw49h8HfAz8AtgTGA14U9JUZdUvtYhKHYfFgJMAJO0P/A4YAVgUaMp1TDnW/YxYnNvO9r3EBNBxtr8FVgTmb8bvHl4ZBLewShrKRsC+xEn0QyLV91ZgEuLCbCvbt9U1zlZh+xtJ0xEpIAcSq1sHEjNRJwFbS5qlxiEOF9s3AqMCLwF3AlsD61cevx3Yifgs3FjHGNuV7a9tz0Gk0W8LXARsIGnC8vj7to8lPkeX2X65vtF2P9uvATcDI5cs6BdsrwqsCvxa0q/qHF9PKJkWW0qatcxkf0/UYVhN0rnEDPamto8CniaCxI5QVqr2k7SGpNHKhMflwFREOvh0wOa2bwVeAyaubbBtRNLsklap3PUF8CzwUMnk+c72GsQxZzbiorGTTApcabu/pG2ICdqLiWPNnLWOrIlKEDAF8DdJh0vaTLEt6zzg30QQ0DapxJW09qmBQ8q4/wYcaft9YGni3za1nhuATSVdBSwDbGB7G2IyY5Em/t53geeB7xS1i8axfWh5bBfK9qJWkenQbUDS48COtm9R7E2citj3+p7t3eodXWuRtDmwgu3fVO4bkzgBjQWsZ/uuusY3PCSNUGbRKEH84cBSwN7AMba/GtLPp8Grvrfl9k7AX4B7gT/YfmQQP9PW6cGVtNffEJMpywLXEdkFL1ae16+V0paaRdIKxHfqPuJ9uIs4kW9EpHQ9WVLlVwZOsz1hbYPtZpJmJj7vPwDPENspbpM0PyDgZdvvldW7S4HJbH9e34jbg6StgEOIrKQ/2X62rA7+HvgIuMn2myXtfm3b89Y43G4naVrinPsdsV3rBNs3SToEmML2erUOsAkqqaC/AVYhJj3WJzK3+hCT8QBnAzvY/riWgQ4HSScSE/CvAefbnrzc/wRwsO1z6xxfGrQShI5PbAl8WNIcxPdyWtv/7e5rmZIJMSIxkdoPmAdY2vYjkvYBlrW9aHf9vu6QQXALKx+osYlZxFNt/7Py2MpEitq6jb17vZGkmWw/UzkBLQJcCaxq+87K8/4AjGT7oNoGOxyqBylJE7ns95W0FnAs8Bmwq+3Lahxm26rsn5nR9rPlvjGA04g9eycT+2reqnOczSDpHeL1fUlsp5icCAKPtf1FnWPraZKmB3YA5iYKD14M3FuZfFoO+DNwvO0zOmmCoKz0rEak5U5ErIJfZfv18vjiRBrvjWU1PP2Iss1idmA74JdEhsmfbH9dHh+l3H86sLLt+xuTU3WNuRkkrQTcVy64pwAeB5YqF+R93OYtuCrnj+ltv1CCjpVsb1Z5zizAp8DPgZmIAp4X2760lkEPha7BkaTNiGyoMYgVxcslbQ9sYXu2usaZBqhcA08LzEtMQN3qUg9H0kzEdc0ttvdu5vGmbLE5nkiFvhT4mji/bGj7yVY61mUQ3AYkHUEcPFdufHAUe/luBebobResDZLmAfaz/esu9x9B7OG8jth79Q3wH2CtssrRNiffyqrdTsSBbY+Swtp4fF8iVX4P24fUNc52VHlvJwMuI1bWb7Pdvzw+NzEBNRYwVXXFuF1VLtp+Daxie7OSEjsjsd9rGWBK4uLmwRqH2iPKRKM8oNXcUsS++vGJVbwbgQeJ9M6FbV9Y11ibQdJIJWV1BuAAYh/Z50RxtFuIGf1vgZ+3WwZNK1BU1F4C+APxGTrC9vHlscWAKW2f207npEGpHEsXJS52+xAps1+Ux2cg0mjfs/27dn+9VeVa7BXgLCJD60+2z1bUKPmmy3P7EUWCtgeWt/1GT493WEhaxlF/BkWhpYOIIpzvEUHWAbYfqHGIiYG+fwsSNSyeJLYdjAUsWRaKZgEWtH16+ZluWQXu8rtnB0azfZSiEvoyRB2J/wB3lQC4pb77GQS3AUmTA/8kKrsdRrSuWAm4zh1aqXRolPdlhJKquCowk+2Dyyz7tsQF3dLERexLtn9b32iHXSVgGY/YD7yc7XvKjPq8xEHlv4qiK9/b/rTWAbeZyszpjcAztrcvq8ALA31sX1ee18g2aJnZy5+ifF6OJgpUbGz7vnL/aET60qLExXr/+kbZs7qemCWtDWxBZFpcS1QPf6M81tbp8IMi6UVipfsiYsVqA6JC+j3EqvC1NQ6vrQzq8yFpdKIwzRbA+8BejloOg/2ZdlE5jk5JpABfSBxDJiAmVo511OuYh9ha0L/VLoR/KkkTE1W+pwB2JjL3vmpkjCiKBb1j+zPFlraPgJ+1chZfCWruJibDdrH9aLl/bSIt+gXb/61vhKkrSQ8B59o+QlHP4xTbU0qaHXi2MSnTjQFw47s/PVH87XpiAWpsYCfb5w3p51tBBsEtpMyc9CsnjPGISq1fNU6WZSZuS+A54DHbf69vtK1F0nZENegPiAv428qFx2TA98Ar5WTUdoFMWdme2PZ6ij0dxxMFaiYDFrX9UDtfRNWpvJ9XEXtkvpd0DTHJtCzwN3fgnntJUxGF1BYGniJOXDfa/rA8PrLtrzvtQnVQKrPYMxETZhMRexhvJ1Y6diYCwkNtn1bfSJtH0qxEUb2FqllFks4g0tn+nOeaoVe5MJyNKKo2JVFU73VFdfnfE2nSqzQm2jqBYsvR+Lb3KLc3JNr4vQ3s6xZO/x0eioJfI9s+otw+lggOdya2mOxi+7KSnnou8Cvbn0r6OTCP7VPqGvvQKhOmJxFbg04DdnMbt5vsZGUi5h/Ab2x/Kek1oq7JxZJOBp62fWSTfvchRKyyn6L2wbbAfsR++O1aOYsog+AW0TWIkXQvUaxkXqIgwbG2L69peC2pslI6KrHnYEGiqu1iwBPA0bafrHGI3ULSb4nZtfuBHYmAZW9JJwH3d+rFeU9Q9JU+iHhvZwB+YXsuSQsTgeKm7oC+lpUViVFtf1nu+yWwNjAhUfX4DuKz1dGBb0Pl+DEhUQjtFqIacn/iYnZ/R/GiWYkCUV92wmST/n8dhdGJrTUX2j6s8ry5iTTe7RsTJGnIuqQFHw18Raz6LU20CdlF0fVhLtsP1TnW7qQosHYkURH6+Or3pASHv7DdMW0cJYm41rjP9lvl3/s+D6ghcCDwR6LI3mjAI7a3qmu8Q2twxzdFobwziaJHxxHXVm21mNDpyiLalURNh6mA+WwvpSgM+xzwS9tPNWkV+HDgzOpEl6TxiWPCbLbn/qm/r1myRVLruFrSLgCSFiDy6hcmmks/ARwl6R+SFi3pvr1audj4QdES6WQiFfpu4st4MLGad76kPeocZze5A5gVWJJIy9y73P9LouBGGn4fEumJKxFtTBrtHlYExu6EABiiX2X5452SzpY0ju1biEmVy4kWGDvQQe1/fkwl2D+MqIq8ue0liQIwExPHj9FtP9mYOOiAAHgk4EJJ0zVei6Pa89FEC7nTJc1YJgYOBd7NAHjoVQKDY4CjHJVQVyNW1BeR9Efb37d7ACxpUkkTVe6ag7jw3kfSytXvie3tiG0WjT2xba+8vstLADwe8FfgBknrl8f3Io4h/yYmP7aCuG6pa8xDoxHUSDpW0iSV++8HNibqA/wuA+DWU85nJxET2zsAh5bj+IlENfqnysTvTzqHSRpXUUui8fcsT+wFPkiVHuCO9pIbElsjWva7nyvBLUAD9rCuTxRxuhH41PbfKs+ZhbgomZ1IpfmgjrG2GkmNAi77u1KEQrFvdhUiBeTmdlrBqazaTU+sIIgovPGSB1QwPojYIzxPfSNtP11WKKp/Htf2h5JGJLIvriEKIT3djin0g6MoxnMsccG6n+2jy/1TA3O7l1UZLys6RwMPOIrZNGa3JyYqRG9s+6V6R9l9yoXIFI46CtMCuxHV5T+VtAywKTEB9AyxtWRld0gV7J5Szj3nAb+3/Vjl/u2JbRZrEamDbXE+GhRJFxN9Yx8sK1B9iX7HGwILEStPR1Rffyfpcu7oQ+yfX4Y4X79NtC78d+PxMmHfFtcgkpYmUrpHBa4gJnMar/UwYmvIezUOMTHQ56oxsTKCYxvTakQL1ZeIgpe3AXuWTKafvMVJ0h3ANrb/U26PRWytWp3YTvQkcLbbJAszg+AWUS5OpiFm29YnUmjmt/1Kl+fN2i4frmZTFG440/aM5XbjAnYsYBTb79Q7wmHX5eT6DJGmOhEwEpEWfwWRvroy8Nf8LAybSrriCsQKzRhEMaCHbb+iqBS9I/Bf24d2UgBcpWh5cRjwIrHP6+bKY21xsdZdJO1J7NFczfY9lfufBzZpXMx2GknzAScAYxIXuo2qxRMSx5zn3IuKo3UnSacBnxD7QhuVxyckKo4v5TYvKCRpIUeRxn7EHudbifZHoxHVoX9DtAK6Gdi9044nlfPIDMCItv9TVoTnJ84rsxL1Fvaw/X6dYx0alYn3kYFRiImMKYmgfgyiOOAURPunmeobaWqoXO8eCPwKeJ34Hl5EbMGYnNib/oHtb39qAFwJun9p+5aSVbQusQXiwzL5tyKwCFEY6zZiIqylv/sZBLcYRXXa2YE9icJYpxGVJDvuQvynUuxDOgZY0/bHKi0JFFWjjwW2bLcZy8qB5lCiLclSZaavP1HleiRiherW6gV7+nGVC5cZib1aJxIX+8sTF2sXEVkF3wPflRNMWweElc/Two7tAtXHRiVaF0xNrHieXccYW4GkI4k2dE8RhbEWI1bGF651YE1QuXgSEQBvQGQifQbsY/uGWgfYART9cU8g0mGPIlpubQJ8bnuT7liRaQWSFiK2Iz1DtCS80fYbJZV2VeBL22fWOMRu12Wi+jEiQ+8yD6i1MDKwBhEg7GT7udoGO4wkXUVMsj9DtEF6kjhGbEas7u9r+6n6RphgoGP4skRRw02J4HN6IvC9jmj32G3Vx0vQ+30jM0hRffqfxDXT8UTK9feS5iQ++487q0OnYVVy7Rt9StciVqXGJvaVHFfj0FqOpAkYUMJ/p8pJ6EhgOnfpH9wuFK1qLgAOKrPt/wTesL2DpCeIGb/VcpVm+Ei6HnjU9u6K4j+3lv8WAi4heh+21eRJV5Ima5wAS2bEVUSRnmNsX1N53lbEitWFnXBR/mO6XMBODcxCVIL+gQgGf0HsYfoHkWXyUidmAyi24ExDrBK8W8mAWItoc7NyHl+GTmWiaURgEqIX7ldlZeTvxAra58QEy/ZlorYjgmCAEvBuT6wAPwNcSrTv+6TynLaeTKyq/HsfQmyZWawEvisSK6fX2r5K0uRlQqAlX3tJ414VuNv2O+X1zENM2swGzAyMTFxfXVj990z16XIO2xAY3fYJ5fb8xJ7g6YntLLt1V9aJpF2JxbntbZ9V7puQKCy6NLGN8zjbj0kawQOKxLXk578hg+CaVVanZiFa/MxE7MU4zNHmZ2xiln5+26vUONSWVIKYw4im4HcR1QuXBZZwVHZtu4uNcjG1AnFB8SVwE9G+5ENFqftzbN9R5xjbVckSOIoo2/+2pKeJvbEXSrqLSIvevtZB/kSKveQ7ADs2gjdF9dKViAvVp4lg+DFJjZS9K1r9ZNUdKhewfyW2FHxJHG+PdmlZ0sgoKX/umPekcq7ZkNhyMy4RtF1L7F/9VtLiwOw54TrsFNX6FyfSSc8GzncUo5mYKGD4TUk5bbtz0qAoqs6Obfu1cnse4rgzFRHw79tdF+CtpqyK3URkmz0t6Wziu/Qh8b1axZV2Y61IUVT0IWLV8BTieHiOo+ViH2IycEliv/ObwFadNhnYziRtShRkuwPY0PbXlcfWBCZyN7a2K5N6axJZAR8RGaq3lccWJApKTkpUqN7f9lfd9bubKYPgFlFW+O4kCiCNRwS+ZxIFCkz0D/6ytgG2gEoKyDhEj9x+th+VNCVxgb8ycWK62/a97b6CU9IVpwAuBPYlUncPtT3JEH8wDVZ5TxcDnif2PB1he5GScn4x0Vfv5Xa+UFX0Pp7Y9o2K9j5TEbO0IwBLEfv1ViUubD60vURdY+1JlePHxETK82pEa7X5iVXQL4liPx1XHKzy2sciejduSKQ7jkxcSH0PrN/KK1etqPK+LkVkkcxKrIqsTXzfrib2AT/bzueihspEyjLEtcl8RMrs7i7bcyStTayQ7lDjUJtK0Qv1BKKI4lVEUaCFiOrJNwJ/dJftJ61Isad7a2Ly4nPiGnQPR8X4xva8FYB3bN9e20ATktYFXvOAgmuTE9WglwcOAQ4eVPZFd17LlM/LTMAWxPnzDuKz3sg624JYgFq/O35fT8gguAVIWoMooLFg5b55iDz7P+aq30An39mI92V04sLtIeBA22/UOsAmKundWxGFR/5s++qah9QRJM1EXKQeRqSBzWR78XpH1b0qKW53EAUsHivp9lMShTMesf1+u08YDQtFG5NFbG9Tbo9ITBRsCOwCrG77uhqH2DRl9WA12ytX7puEmAA6wpU+j2nolaBwWtsnldsjExPZqwAfA5t10qqopBeBM4gAcAeioOf5xPXKW5Xnte1k4o8pAeIxwAvANWVCfkUiJXTqWgc3jErG4YFEwHsksZr3prMyfEsok/T7AOfZflbSpI3vmWJv7olEvZjdidX8pn7nSjC8KHG+nAM4w/a+XcfcDtcUGQS3AEmrEI3V1wDegf/1azsNeI3Yo5j/UICkRvrO8cSJ9wDgXWJG7BBX2iR1krLaLduv1j2WTiJpd2Bz4DEiRfqtdjl4D071wlNRsXQtoqf0d0Shnmtsv1zjEGtTUsUbKzi/Jy4qGvurRiNqCTxe4xCbqqStnQhsZPvxymrBX4kqt3+oeYhtR9I6REukB23P3+Wx6YDFbP+jjrF1p8pWgkWAtavbRkrGyUlEq5Q1OnkyRdKkwJS2763cJ6KewJnEPszzVSou1zTM4VImhs8AviCuse5ym9fH6BSSxnS0spuYaOF4E5EZ+GF5fGcG9Lxftpt/d+O7PwpRLXx8lwJpkjYisgmmJyb97mmneCWD4BagKPB0cfnvFKIC2/eSLiUK+BxQ6wBbhKTliL17jZZIrxBpwgsQK6Xn2d6gvhGmdlT2d41g+/N2X7monKxGJfZz3eQoxDMrkaI5J7Fv7V9UAsDeoqzQrU2seIwE3ANc7w7tZ9qVopDJKcSEyF7A+8R+1UeIQnzn1Di8tlQyCbYlenO+DPxuUBMpnZBmXtKALyXOuevYvqXL42sAd9p+t47xNUslE20TBlzwfwb8yfZ5JQhenMgwOajGof5k5bWsCJxL7O08ouYhpYpyDvsdMbE9DlF7oJGBMgKwgO27uutapnJNMRYxMTI9sY3mG2BrR6/wyYnCkic3gvJ2kUFwDSoH1AmBWRwFsNYGjgOeIParTQ78HJi5nS/Ku5OiHcM8to+TtBOR1re4orn7osDfS2pnWwcy6acrFyvXEZVau3VfTCurnLDOBfoBm9v+rPL43MCuREuPi+saZ08aVPBR0v82IlZvPiK2Gpxj+4MeH2ATVT4P1eyA8Ym2NosQBYxGBV6xvXaNQ2175Xx+KJFWfxaRWfJ5vaPqXpLGJWpvrENUFz+dKLL3dZfntX3A31B9LZJeAvYmVuK2APYH7ie2sz3QjH2YdSmTO6PZ/qjusfR2lc/V/EQ16FskzU58F5chJrbPsH11d3/3Kr/7EmJrx+lE5entiH3BO9m+SAN6TbfVdz+D4BpJuoFITzzB9n/LitQ+RHXBZ4HbbT9S5xhbiaJi4QSOlh6HE1nju0g6kfgsb1nzEFMLKOl6d9ruM5TPbxy81wK+sn1Vc0fYHJWT1TxE3+OpbX8iaWOi9zjERdvXLu0LOl0lCOxHrACvRly0vmb7Akk/Jyolz0CkCLfVLPaQdLl4PwBYgijac6XtJ8pF1MxEFfpXnS1QhkqXSeyFiff1FWIv6HflM3UaMJbtaWocalOU8/BUxGrhioCAs9wGPUGHR+UYshKwjCsFv0rGzfHEhNpGmUmRmknR0nBdop/77WW709wMaM+1iu2XmvB7JyLOHctWszwkHQhMZXvD7v6dPSWD4B5WuVBdBTiqcZJUm+9D7Gnl/dsLeJGYCZvB9gedMAObfhpFC5iVbK8taQNgVtt7DOa51UDha6Io0jWDem67kLQnMKntbcvrP4AoAPZzYt/8le02Wzu8KhewpwITA/cB0xHpnPO6tDGRNKOj4EjHHD8q55qjgQWJVkiLEkHLDcBFwOvl/ekVn4fuVCaxIfqo/gW42vaqlcentv1Kp5zby4XwtET2wJdEb+25iH2AaxDFv+6pbYBNpKgXcBGRObKF7XO7PD4L8FLXFfGUupOiLdkuROC7i+1ny/1TER0h7mvWsVzSxUQLyb9W7puOaAe3jkurtHbTr+4B9CZdToYLEXsuGjn+jcbSCwHjEw3X2/7E2US3ADMSqYzHlQC47QpRpKZ4FPirpMuI79lmMNhKpX2A70ugcEu7B8DFLcAJ5SJ9FCJd6QpJfydWra7sLQFPCfCmItpIzFGOEzcR78EXZTLtwcbFRAcFwI3VyhGI/b8blSC/L7F/dTUiIL5IUq/bGz68KhMLywHT2J6h3L8BcGF5v1cGrrP9CkA7n8crWTKrEG3E5iWOrzcQ36GHJD0LXGX7gfpG2nT9iBXf94C9JS0AHO5SqNLRD1p1DjB1nsrxZmSiy8NrtveRtA9wj6QtbV9cPoeNz2K3HMsr55BVgbGJrNUNJT0PXE90Z1kB6NOuATBkENxjJI3ogSsXPwNsL2m/LrOHGwGftGtKZk9x7HM8tMt9GQAnbD8BTC7pLWJrwfyS7uma6lo5yE8B/JYBKcNtzfY9iqrX0wGPOYpkjEWk/S4Hnd26ZBD6Ag+UAHhpog7DMuWx3YA9iZ7JHaMSeB1LXDzdz4BetceU/V37Ad9lADz0Ku/VBER7PiTtTWwxOF9RufX3RF2P1+sZZfepnFOPI7pULCnpCqKuwJKSLiKK73VcAFxdUStbBa4pE4u/Kf+dLelGoj9rfo9St6t8pvYs/90g6RuiNddowM6SviSKO3bbZFv57Df+voOBTW3fragOfSrwMFEl+nuiKG3bZrNmOnQPUDS5/iPwF9uXlPvGBf5JtPc5nejjuShRIXpWV3rt9WaDS+2ozJA1ZqpnJNKResVexzR4kkaw/a2kW4hsiz8SVRT/BJxWSX9ufIZuJ9J8dqpv1MOvSzA/CzAecINLkSdFe60jgW9sr9vLAuBGEawHiD6maxO9TK+QtCWwre056hxfM0naEdiZyDRay/ZD9Y6oM5T0178TkyhXASuWVdHTgDFtr9kpKeaSNgfWtb2UYg/sy8CqRP2ShYBt3KH7gQEUtSLmBEYkJtMuKv/+SwHrERVyH61xiKnDSZoWOAR4kmjnuCmxJWFN4tpl3m7+fY1tRMsByxKdA94vj41JfP9fI1amX2rnY10GwT1A0ZtxZaIa51tENcV7Jc1BVBicjyg7fhdws+1jahtsCxjaL1TlizoS8d4tart/80eY2o2k7YC/EieRvW3fWO6fErjR9kx1jm94Vb4DjcIVzxP79mYEflVWgacj0qAvcge0gRoekuYjZrTnBHYiUoT3B7a0fWu7zmIPDUXxlIOJC6dLiNf8ca2DanOSRicmljYm2kutS7Qs2Z/oYPBup3zPFAWhJrN9kqSTgLEd9RbWIvaa7122FrTthXBXlYnFnYlA9y6indj+RCGgN8rWgmlsv1DnWFNnkzS27Y9LvHAysQ3hIEW/6omIOO7h7j6HlVXf24ktEDvZPrq7/u5WkkFwDykXIvMTMyhzEiu/BwOfABMSKzj3ucNaKgyryuqcgB2AS2y/MZjnNgKAM4CHbP+9RwebWkqXFdGlicqtnxCzmB8qqpqeBSxoe/rKz43e7t+7kt76nu1tyut/DhiLqOL6duP1ddKF6uBUMgEmAyYFRiqTAXMQe2EXJyYLrrd9eSe9J5Vj4gjEfvcxbf+3PDYncDgRrG3oLsV90uBVzksTA/0a5yRFX9x9iOrQbxLFsa5p90mVyuudyfYzkia1/Zak44F7bZ8l6U7gXNsndkrAX1W+Q08Ca9h+XNJxxGTAqmVi4EXbT9c7ytTJJP2C6An8BjHJ/TCROfoMkYbf1Ir+kuYitlDtTEwE7exS66BTvvMZBDdZ1wssSeMQm8lXBKYk0jVP6oQPU3eoBDLHAZMRvRZf7/IcAX1LGvQsxMFhynwPE4CkO4iCac8R1TxnA3awfXJ5fBTbX6lDCqmVVakzibYJT0p6ELjc9oGS9iX6Cu5a7yibT9LILvUVynaTe4jVm7GJlnN/bKzaNALl8ueOCIK7TCAeQ6z+P0JU0L/I9jPleWsTaZ3d3kqjE1W23MwHHEFUWb8euJSoGPwt0Q7p4/pG2f0UBeVOJIqqNSZSdiTegxuIjgzT1TfC5iqv/xRilX8s4EFgLtuvKSrlXtbJaeCpfpJ+RvTkFlHT4xvgCaIjyknEOb/brnsr199TE5mrMxNZU7cS2ayrA1cQK8Ntf86EDIKbrnICnQFYEhiT2J/Wj/iALUOkNOxs+9/1jbR1SJqcOOHM7Eqj9pL2/F11hl3SXcBu+d4lAEmrAfu7ss9T0nrAn4FNbN9Z2+CaSNLJwIfAS8SxZKZy/wvldke3RSr7lPYCbrV9naTDiKJo+xCrwVsTe5suBfZq9gx6HbpMIM4IHEVkH21JtIa6CrjC9nv1jbJ9SJofmNv2SeX2Y8S+8suJ1PJFiZXCS4BHSwp0x3zHynfqXCKbZAPbj5f7VyImqG8vq8QdMZkI/7+4j6R/ElVxFyaKDP5Z0Yf+n8DknfK6U2urZDetSqQnLwA8b3ubJv2+B4GPiQyXnxGZqvsQK9J/BbayfVczfndPyyC4iaonREnPAE8TVSVHJWaS7wJMnExPtf1yXWNtJZIWA/YmVstNFMn7XtIkwDbA38sFxwrAn2wvWuNwUwtRtCpZj+gT/ENJgTZx8Xq77RNqHWCTKFp2HEgEPbsQBfb+CCzeG74firoLewOfA48TNRb+7ihW1JeoZLkQUWGzj+2FaxtsE5UJxIeB+Wy/qqjk+w3xvqxIzOJvmVkzP07SOsB5RBXoPYjv1rGOzgSNz9w2xPamI2yfWddYm0nSMcBXtnereyzN1OV67QDgb0Q/1nOAyYltBOMCuwNn2j6ukyYAUusZ3KSaom/11+W6uFvSkitbaVYE9rU9f1l46kvUPliXmEx+3fanP/X3tYo+dQ+gwwlA0qHAm7ZXI1LU5iIqCx5IpFZd0JsD4JJmRglYINL3pgNWc7QeaMzM/pIo9vNuuT0esEqPDja1uruJC5U1JY1l+4fKSWSiGsfVbUq6a+PP/SSNZPs+osbAo8SK551EGvDG5Xl9e36kPcf2vUQ/6PuIVlcLAn+RNLXt70uq6o1EatkG0LHvyTREBfRXJS0BzGt7TaKI0z3AiRkADx3bFxCT1g8A1xGB8OqVx++1vRFRtfVWGPi72W66HFdGrDx0OrCypDPKRXGn2kLSpmUidTPbn9m+g8jgO4RIP12B+H4dB9mWMXWvrsePrgFw4xrZ9heV6+JuWcmsLBr8DHisTPD0t/0lMan+PbBQJwXAkCvBTVdmbC4givPcU9Jr3rC9g6QniPSCVd1LqxorirWcbHuBLvfvCGxHXLieQgTFfwN+b/vqnh5nan3lBNIP+AOxGnwN8BkwMlFcYgbbn7V7ymIl7fX3RFD3GXAzkZb5KnES+wJ433b/dn+9Q6PLKs5cxOTY4sS+8FuICuAdlwINA83gj2r7S0mz235C0h7AFI5iaRsQBX5WrXm4bUnSbMSWipWIVof71Tui5pG0JjF59jBRwPM9IjXydOAfts+pb3TNoWj9tCcwE1FU8QTbu5fH/rfXvnoc7a4VuJQkjdkILn/sfN3lXDe5B1M4djjHMT2R+TIiseXj+saWRElXAQ/a3r+7fl8ryCC4ycqM6gpENbcvgZuI2ZQPyz6+c8psY68laTzbH0jahNjrsJ1jH/UqxMl4ceIi/37bh5efyRNQGixJywC/JbJd3iUKRXVMKxxF38CngI2IzJLpiRnhfwH/6o2ZJYO4SF2Q+AxMRBx/b7Z9U13jazZFj9p/2r623F4FOIxoq7EXURH6yhqH2DaGkIa4OvGejgDsUlaL214l0OtDXPyOQAT8/YGJiXTgvsRWro078XNUXvuhwObEddqbRPXrB8rjWwP3Evu/88I5dQtJsxILPlcAtzQWxIZwDGrUGdoBGKe7J+RKhtQWxHaqq4G3ga+JrR8zO/Ymd8z1dwbBPaSsUk0BXAjsS1yYHWp7kloHViNJPwe+sf1Eub0qsa9vFGK2/dxy/9jE/odG5deO+QKm7tX1s9FYHavc7pQg+FdEX+y9y+1ZidXvmYlqtXu6l/SvrKyML06sAI9B1F+4hthasS6wIREgnlzfSJtH0hjAAcAkRDXfb8r9RxMt+G63fWKNQ2wrlaBwGWAG4nt1qu1Hy+N7EivDa9u+uL6Rdo/K692C+Kw8W+6fmKiwvgBRYG52Ij14W5dCWZ2g8vpnIK4/ZiSq4Y5GpMPfRwQpM9l+s76Rpk4jaVlir+23wH+A6xoTL+Xx6spvI+tnJOAdojjbF00a19hES72NiWKAx9q+vRm/q04ZBPcwSUcCWxHFW/7cW1N7ywr52UT59X8RX/x3JI0PbELMRL1NVHLtyIq+qXmqwXCnpQOXYO98ou3PGrY/rDy2PPBz2wfWNb6eVLl4nYTo/ft34mJdwEjAUbbvVrQ7eaeT08MVvegvJrYE/K4SyGTxnmFQmVRZmugrfgexMroa8f6uVx6fwKV1UDurvN5fEdWgfwE8M6jPTLn4PhF4zfa+PTvS5qgcQ8YjWi++V+7/GfBrYDFiO9b5tg/qlInU1DpKwLkxUSNoQqKLwU2NjK7KZ7TxXT0VeMg9UOizpEifBXwFHAfcYfv9Zv/enpJBcA0kTUm896/WPZY6KapAr0Kkcr5G9B682fbXkmYi0i82JFKSfl/fSFMrqqbwDS4zoLpfkmgV83eX/rDtqGSUjAacQRTpOYXoFfhu9Tk/9r50ispr3RiYx/YO5f5ZiMnGxYBlOyFY6WpQwbykUYgg5Tnbf6lnZJ1B0nXEueeccntqoi/w48AWnfbdknQPcLzts7usPo3lyn56SYcDC7gDqs5Xgoo5gaOJIOQaYuXrBtsfSZqAaM3Y2BvZkZNoqR6SRrT9jaTfEtkH8wNvEUUubyL25X5Wef7MRK2cqXrqGFSuO1YkJsn2t31ET/zenpDVoWtg+7XeHgAD2L7T9i7AP4gUxs2APSTNb/sZ29sDaxOz721deTM1RV9J0wzlieAMYMZ2DYA1oJLxxLY/d1T8XYBo+/OspO3LKs3/Kkp22kX6oJQAeA7i2FFd+X+KKJD2OTBbjUNsmvLaJ5f0N0nzlO0l3wPHANtKOkDSCDUPs62UfaGNgo0fA/8L/my/QvTKnI6oGt0xyiroB0T9hMZnq195+Pfls9V4f+4k9s22vcqK7hlEhe/FifdgO+BASUsBP5RgWOVnMgBO3aKcq76RNB1wLLAbMCVRw2FUYD/goPI5bDiB6NvdY+d3h6uJ494ZPfV7e0KuBKfaVNOKykl4XaKF1PdEg/obbD9X4xBTC5O0HrFnZTnbj3VNU6vM8v+cKKw2ue3P6xrv8KqmQhGtWh4j0nzfLI9vQpxA3wbmcNk731uUtNXDib2bm7vUEiiP/ZdIX+3IgliKXum7ApMBTxIB/0VEhfA1gNltP1nfCNuTpHOIwlCPEq2RHioXq+MRRdbmtP1WjUPsdop+wCMB23Q5L78EzOUOKrZXAtq+jgJDkxMZZ8c2zg9ly8lWxF7wo9yhPaBTa5C0FnHuWraSvTYKkZUwHrEH/66yXXAt28fXOuAOkkFwqlXZGzyR7dfL7RmIAj9zE21efl/d85hSg6SRiWqesr3dEJ53P1Ed+qAeG1w3qpwU1yJSuuchKkNfSlygNS5YV7R9TW9Ig64qkwOTEbUENiNautxO1BuY2PYmnfqeVD4bkxFFsUYjsme+ACa1vX6tA2xjktYmAqFPgfuBb4A5gY9sb9dpe60lLUykO/4HOIqYSFmRaOm4dafuhZX0EnH82Nz22V0e+y2xB/LFTINOzSJpRiITYWvbV1Tu3wqY0vafKvfl57AbZRCcelxlhW4jovDEosSJ94+2Hy7PWQaYxPZZNQ41tajK6uhsRMX1/xCttd4rs/wqwcHGwAG2p6p1wMOpEuTMTswK/w4Yl6g0vxwR7Jzg0han/EyvPEmW9M1ZgJ2BVYnPxIbuUlykvhH+dF32ak5DTBY+bfvpLs/rR6Rxdlzg32xdMpQmAHYggsEpgSOB09t9FbhyXBmBmDwZkQj2vyJe48zl9p3AweW5bT+RVM4NhxLdJz4u9y1MrPYvA+xt+2/1jTD1VpJ2JVr63Upkdo0OXA+sY/tfnToJVbcMglOPqpx8xyOquR5IBDEPAeMQM9F7u9KGoBMuXtNPV5k8GclR5bfx/ymJdiXX2L6oy8/cAhxp+6paBt1NJJ0I9LG9Rbk9BlFU7kQiDfY+otp8xxWAGlaSRiP2Sm9DrNyd7g4pElX5DuxA9HP9ggj8zybaYn1anpfHzJ+gOpFWbs8E7AJMA9wD3Abc7Ur7tXakaKG1AFGT421ixfvPRJugzz2g1VbbB8AAkuYFFrF9dDlOTO4BVdQ3AA4heiPv0O7njNS6KsfxvkTGxTtEBfrFiUyeFYG7iCrtO9Q30s6XQXCqRbmoH8H2ZiUV5DZgfeAy4oS8qO27axxialGSngCeI/pXvk30b9yZOHFsa/v8ynMXsH1fLQPtRmVFezVg9S77no8DXiZOnte6w3vBDm1wV4KYCYjPxG7AQe2eVVLJfhiX2Kf5G9u3SLoc+BVRS2Fv20fWOc528mPBXdfHJa1CZGOMBaxv+7UeGGa3qkxEr0qkPc9LrHJPT2RmvVZNv+w0lQBkW2Lf/MVE+6OPSgbFPkRhoo7oAZ1aS+X7NzJwHjAxMBFwN5GF8SiR7WXgw3LM74hJqFaUQXDqceXLfzDwqO1/SLoduMv2npIOIr74h9U7ytSKyp7xEYjUte+INkGfE5VNNyBOIFvZfrCuMTZDWcG4jGiNsHUp0jM6kfK7GvBLYE1gRdsf1DfS5iivdcRGfYAfC4YrFxpzAiN3yERI4zX9BZjB9pqS5ibaaMwMXAAsCWxv++91jrXd/FiqoUrV6PL+T0e042rrAKlMRH9ke4/KfSsBpwIrddoxtKEymbQwsDSRLfIlcIXtS8pzJrH9dp3jTJ2p8vk7HRjP9irle3clMbnWt5Gqn5ovg+BUm5IKMjZwNbHv4VVJ/wE2tv1Qzn71bpWTxSLAf20/J+kHouDPO5XnTUmksE1NFI6aC1ih+pxOUCYAziPSX28jZo9ftL1Wyaa4lMig+Ki+UTaHpL2BSYFLgNtdChINKhjusm/2SSK18V89PebuUgLdF1x6RUr6FTC27QslXQY8bntfSb8H3rb9zzrH2y4kPUj0xT293P5foDuI5zYmICYl9ukt0e7fM0nrE3vmlyu3G6/xIuCyakZNp1L0j1+SCIanA14BLrF9R53jSp1N0ljAtUSl5zclXQm8ZHtHSX8kJqdOqXeUvUP2CU49oqQZIWl+STtI2gP4VVm1uge4rKT1fWv7IegdfU7T4FWCm9WAeyU9TqStvQMgaaQS8Lxm+13b99neFHiTWBltSxrQq3RkSb+UdIikZWw/Z3teIsX3BmBrYKPyYycQVUzb+sJ8UEpq89vENoktgT9KmgsGfEbKcxoa79++wJdtHgAvSPRl3F3SYgC2bwCuVLTQ+BZo/JvvRJ7Th0r5vFwBHCrpYUlz2/6hBIF9h/CjxwBPdMj37BFgFkl3KgoMNopE/Qq4o9zWEH6+rZVzx5e2ryH2Al9MFAlbst6RpU5n+xPgM2B5ScsSLch2LA+vQ2S3pR6QK8GpR0l6g0jhfB+YEHi93B6RSHO90PbzP5aeljqfpOkcrSlGALYFjgBeAw6xfULleTMQbXE+LRexDxMVk9tyJrWyInM6Uf33JaII1pXA32zfU3nu6ETAvzuxCtyxE0eSJiHqBixEXCTcDVzX2JdZLtj7lP1+YxOrOovbfryeEf90kp4mgpVviAD3P8BVLtWgJW0DbEFU9f3G9hJ1jbUdKQrMHQNsDJwE7F4uUAcqXlP+vzCRtTSJ7f71jXr4VDJr+hLfk28VBSoPJl7/88B/iQKDf+sN5+CumSSSZgXe6pBJjtRCVFqqSZqQqLy+PDHBvxRxTXOMouDh5rZnr3OsvUkGwanHSPoNkX61mqQpiAv8ZYmKm68TPYG/+7H9fqnzlYuRbW1vU25PAyxCpD3vS1TF3dv2jZLeI/bJ/lPSSESK0dmD+7tbWSUAno9Il5rJ9geS7iKKZUwLnAPsVVkRH4vYL9uRlaEbq1GVVd95iQqaMxCr/v8C/mX708qF/iVEddtNahr2TyZpceBs21NJmpjYq/kV8dm/nWiZ9SWwMvAh8FinbQFolkpgOxORTfErYDyiSM2fXaqJV7fkSHoIONf2EXWNe3hJGqEEvTMRLZ9+SWSTHOhoKzcJMB/w75Kd1asqjA8iGB7Z9td1jim1v8r5aJzGxEo5l29FTOjvQ9Q3uQuYn6htcoDtu3vDJFQryCA4NVWXi4jxge2B/T2gD+MMRGXbJYHfuc1bTqTuodjjOoHtu0rQMzkR6HwuaVpi9WsrIk32TdtL1zjcbqcoWvON7e0V/bT3tT2dpH8S6dBr2b6y3lHWS9IKwG+IugLvAIfbflnSzMRFxZS2v6hxiD+JpHGAk4lerT8nvgO/JdKeG/sX/wnc244rk62g7Au+kOjLKaK/9LHAW8R56p/leTsQq8ST1DTU4aIo4jWp7TvL7SeAh4maAtsRk2oHulKIstOC38rE4hhER4oPh+JnDiWy0h5q/ghTp5N0EzHJ9iBRVG/eymNLEZmQAPfZ/rDTvoOtLIPg1FSVmbBDgOWAmYD9gcttP1WeMxIwpu3/KothpS7KZ2ceoofl9UQlcZdsgjmAB22/W9L8fmjnk4cGrmo8ie3rJd0GnGL7XEm7A/fbvqXekfaMyordpETq2IpEGvThtr9S9PrckMgq2ap8LuYjjic31zfyn06xN3xVov3X/MCewGFAXyKDZg2iWNhdRAuoPG4Og/KZuhTYopoyL2lH4r1+3PZS5b7licyCO+sY6/CStAuwGXAVkVmykaNuQuPx9YG/ASMRFaHvGeRf1AEUBb/Os335YB5vpKuuBRxne4IeHWDqaJLOB9YitjWtV85fjevjUYkuBj86QZO6VwbBqWkqX/AliCIk6xMrvtMRe4/uAG6x/VaNw0wtrszgr0GkLPYlguFrGpMonaA681te7+jA+yWF8Twi7fd44GlgYdsP1zfanifpFqJv4g3AH4njx9EufZEljdbOq75DIukcYEaikMorwEVECvjIwObA847iPmkISobAV7Zfqdx3OrHXejfb75b7xicmav9k+5NGcFTHmH8qSVMDCxKTKRMSWyrW63rslHQ4cJbtx3p6jM1UmVScBTjd9oKDeV71+Psysep/YU+ONXWmyuTKCkTRq58BswF/Bo4twfAFRNHPK+oca2+UQXBqOkm/A0azfVS5vRixp29yIo1xL9vv1zfC1EoqFy4CxnLpmSdpMqIX8ALE3uCbgDPaeeW3obLiuQfR7/cjonjcacCoxDaCCYhV8K17Q8ZE5XOwCnCE7enK/Y8DjxOp0M8BmzYmBToxjUzSqLa/lDQHsCswFZEifYXt++sdXfuQdDUR3PxH0hi2P1O0XzsMeIzow/0DkVkwru2Vahxut1K02VoU2IbYU37goFZEO/H7AyDpz8Se57Vsf1ruqwa+jePvvsBytheqcbipQ1QWgiYB+ntAn/sNiEKfnxITu+vaHrfGofZaGQSnppK0KtF+4E2i/+/rlcc2Aias7kdKqRL87EGkfY5FXKheXoKBuYhq0Vd30syppImAZ4mUqTGB2YliYB8Se/jOI1Iyv+sNQXCDpOOBT2zvIWkv4De25yn7pucGtutNwaCiwOBmxB6ztW2/WvOQ2oKkqRy96Mcmqqlfb/u2skq4P7FKOi4xsbJ12ZvXdt+zrmOWNAFRPO1iYGZiVXhRIqvg6E7f9yppeuAAYivFFcDBla1Y/+sNrSgw+AZRZb+jVsRTvSTtRyz8nEVM6PYv9/+J6Ipyte2H2jnrpF1lEJyaquzT3Ar4E3A+cCbwgu2vyuONgKftLjZS96vMnC4G3EzsA12CSId+grho68j9sIoKwNvZ3rNye0GicNyyxCRSR1+wdlXqBYwAzAo8QHwmDrJ9k6SjiBZJN3TqCtbglPdlBduX1T2WdlA5roioI3AcsSJ6K1Hx+fWyR/hz4Lsy2da256TyOi8lWh9dQLT92bw8NgGxx3wlojLtb9ttr/OwKvUjliRecz9iK9a5rlTUl7QtMKPt7esZZepUpcbHogz4/J1u+/zyWNseZzpBBsGpR5TZ96OIAkenEEU6Xs4vf2rQwJXE1yWKG51Ubk8KHEQEhHcQ7ZPafg9oJQ1vSmAxYBeiRcullefMTLRK6uiApzIh1khVHZPIANi27I3uQ7QJGpPYF3sOMHXWFEjDqgSJmxKpz58ClwB3VPcLtzNF/98ziDoKXxEZV990SQGeEZh5UGnR7a4y6TEKUV9BjlZQUxG1SeYu9//R9hOVn8uAJP1kg5qUVRRxnJMoELsyUaX9FNv31jDEVGQQnHqUok/hBcCrwKq9afUmDZ1SQOJc4Frb63d57BfEnq3daxha00h6lOj5OilR+OvfwE2VtL3/rWR1+ndGUcX1FKIq8nu2N648thzRImgkYk/skcp+imkolYmVeYGniJ6cowJ/IPrmvg7s6FIgqxNIeoEI9kYh+qofU3lsa2I19NNOOq5UJhanJ6p8LwM8ShxfjwLuAZYn9ggfUI6rjZ/pmPch1acyobtIuevBSgr0pEQmyqzAybkdsF4ZBKceV2bhp7D9Ws68Jkm/JHri3lVuz0ysiK5DTJjsXk1bq/xcW392KifK5Yk+wAtK+hkDVireJmaLL7b9UZ1j7QnluNAPOJRIf5+ImPC4pcsK1qzAs429U3nhmoZEA6qzrkOs/C4IvAA8Apxt+9+SFib2gh5a51i7SyWom9n205K2IDJp3iPqKSxPpNPPVutAm0jS3UQV9WuIooJLEFXWd7H9nKSRbX/d7ueR1DokjWf7g/LnkYGriSKelxGt7J4v38ulie/gbuXYlOewmvSpewCp93F4rfw5Tz69WElxXYtoeYOkSW0/bXszYj/wpMADkv7Q9Wfb/bPT2AsPTA/cW06Ez9vej+jdCVHEplccp8tx4VvbOxEp708AJ0j6GzCTpBHKU7ciKsv/7+d6frSpXXhAoZkjiQyDSYgVwpGAAyVNbfvuRgDcKJbUjspEEuVCe2JgRElj2j6ZqCp+A7FXeE5ioqlRt6PtVf/dykTZuMBfbd9n+2rgaGBEosI6tr8u/2/r80hqDZImBN6TdJikscrnax0is+u3xOdubUnzA/sC72YAXL9cCU4p1apcpH1aTiLHAHcTqa6vShqdCJIbvWGX6KSLlpKy9xDRmmUjYl/iJ+UxAXPYfqy3nCgljVD2/05q+y1JSxGVXUcBTidSWeexPUetA01tRdGrfn/bv6jcJ+BG4GHbu9U1tu5UWQHen2gh9gmx5/li22eU54xItIB6pxNXQSX1I4rpXUEEwbdWtpPMTRxP1rP9Wa0DTR2jktW1IjGBPS6x/eCU8vjswHbAtERNi49tL1vbgNP/ZBCcUqqFpGmABT2gSuIUxGzpZMR+vZuJNiafSJoaGN/2g5124VZWYrYkUsAvJSqov2j7y1oH1oO6pDtPCSxN7OP7j6Ogz7bERf1LwFG2n8y9wGloKXqM30fs+b2kcv8awLrAmu1+TKkEelMSE2urEO3lZgdWIPqOn2L7hhqH2RSSngJObOx5LlkjxxE917e1fV45zh5FbMVata6xps5Tat285wF9gHcCDiRaHu5k+/Zy/6zE9/CrMvGf57CaZRCcUqqFpPWICr83Eft+Hyn3L0VcvEwCPA3cAvyr3S9Sf4wGVFCfk+jpebQ7oAL20KisYO0NLAWMTcym3wUcY/vesoLVp+zj6xUr46n7KHpyLg9cTxx3Pib2jF5i+5BOmVwrgf2itncst8clujKsQFSl3dQd1hKpBB1/JP5Nt7R9R7l/V6KQ3rdEQDIesGKnroKnekg6Gbjc9rWV+/oBJwObENXn/2D79XpGmAYng+CUUm0U1VpPIfannUEEw+8r+qCuSVy0jg/8rrGPvNNJmg3Y1ZWqyL2BpEmIC9XFSgr4dMA+ROXe1W3fX+sAU9uoTKoIGA34uuy/+z3xefoFUSH6Hdtr1DjUbiVpDgbse94UuMUD2s5NRfTBvbHGITaNpLGA/Yi00xuIYP9dRWuadYDXgKdsv5krcKk7SZrG9ssl2+BM4IKyD73Riuw0YAHgYNt71zjU1EUGwSmlWjSqtpY//5zY8zk10Sf3sHL/FMDctq+sbaA16g0Xa5U0zsWJ1LHVuqRHn0vs2zy83pGmdiPpBKLK+LhEO5LzJI1KFFYbEXiupNt3xPesTB7uAPyaaPl0BXCP7Ve7PK+jMim6HC9mJmpLLAkc5g5rp5daR1ntnQt40vZXZaJpP6LY5TPAEbafLs9dD5je9gE1DTcNQgbBKaXadL0Yk7QJcDjRymO3avDbaRduaaD2NVMRfTvPIFqYnFR5zq7AvLbXrmucqX1UitRsT6wKHgyMQ6yMvg/s1UiX7VSKVms7AXMADwC3EqvCn9c6sCaTNIFLOz1JKxEVwcci/s1PrnVwqeNI2hLYDDgLuM32fySNByxOZLdNC1wHHFktxJap+K0jg+CUUo+rXKhORuzTmhC4tbEao2iL8wfgt7bPrHGoqUnKXsWpbD8i6RFgR6Io2upEf+T7gVeJAmk72L40Lx7SkFSyCvoA/wCOtf2ApFGAaYgL1nWBfwNrt/tnqXIcbbRaWxC42/YL5fGliImAsYFf2/60tsE2QWUSbVGicN68RGXo/W1fX56zDzC/7ZVqHGrqQIpewNsRe+2fY0Axz4/KxO7ywErAFMAatp+vbbBpkDIITin1qMp+vZmIvTITEvvzfgD+YfuK8ryJiIqLeZDqQJIOIIKS+4E5bU8raRyip+LPiT1UbwB35j6qNCxKcag9iIJ6u1XuH534XE1UUqPbOrukEgQfAixHtESamyjIs5ftr8rz5nUHVtZvkPQKcC4xebYQsQp+OrB1CZIb55yOSHtP9euSgr8Y0Xrr58DlxMrwXcA3RFG6eW2fWNNQ0xBkEJxSqoWkfwO3AX8m9rHtBjxPtPc4q1QEzouWDiZpI+Ak4AUiaLmjtI4YDRgdWBi4slzAduQFfOpepRjW1sQKzDhEZdbrbT/ZeLxy8dq2QXAlAJ4NuBNYxPZTku4HZgBMrIgeVec4m03SZkSLq+Uq980IXERkkNxW19hS7yDpeuBeogr54kQv4FuB8ykT/I0MlTyHtZZ+dQ8gpdT7lPS1CWzvWW5vRlQCngzYnDg23ZsBcMe7Bti3/PnvwEOSjrF9u6TTgEcbn4G8eEhDowS1x0u6DtgQWBSYRdIdxMrwm12e25Yq34edgbNLALwKMDEwKbESdYSkV21fVtc4e8BbwASSprD9epk4fVbSA8AixERrSk0haWNg6sokzF8k/Q44GlgG+JPtmyDPYa0og+CUUh0+AQ4FkLQF8LHtvyuayY8PNILjnDntYLY/YMDn4CLgL8AZkh4mLmA3KY+17Ypdar5Kums/IgD8wvbLwAGSFiGK1GxC1B84or6RNsWlQGOycFdgH9tfSrqUaDnXcS2RKnu/FyCySN4AVi+v+V3i/ZgBeKz6/NoGnDrZW0Ttiv+xfUrJRpiOyGxLLSqD4JRSj6ik741h+wlJ75WHxiZSiQC2AUZsVPjMALj3sP0KsL6khYk+p3vZ/lqVVlopdVUCnEYQeDpRkXUeSWcBf7X9b0l3E71iH6j8TEcERbavljRyqUr7MUBpA7UTsGK53TGvtzLh8QtiQmM74EJiO8XiQH9JYwCj2T4W2nvFP7W8p4BpS+bSYS4tkYhiWJfY/jAn81tX7glOKTVdJQAei2hZcrrtxgXpcsBxwIPAUsActt/KE0dK6cdUgqJ9gVWIVkijEBWgvwAOBI62/XWNw+w2lWPpyET7nwls/6c8thex6v0D8LzttTspAK6S9BhR/fvUcns84HfEXugXgYdsv5x1JVKzSVoI2IroSf4NkZmwFvHd7LjvXifJIDil1HSV9LVLiVToLWx/W3l8LWA04D+lpUleuKSUhkoppPYfYAXbT0s6jmiV8yBwIpEyO7vt/jUO8yfrMpl4PNEWaSQi6N0SeJyYCHiHCAK/6MTJREmzE6v+SwFfAn1sf1NaRa1LrMC19b91ai+S5gFmBpYAngVusv14ZjK1tkyHTik1TSP4LQHwz4h2AbPb/rYSGI8G3Fz2hwKQAXBKaRhMSlRj/UDSDMCawGzAd0SxvXts9++AgLCxanEakfq8E/AB8HuiNcuWti8a6Afa+/UOznNAf6Ii9nWV+8cj6kncSuzVTKlH2H6YaNF1bteHahhOGkp96h5ASqlzNdoClBn6/sAzRKoiDHz8OULS1D09vpRSe5LUt/x/JNvPEyuhHxN9cu+1/R4wO7CS7evLj7X1BWk5nk4E/AzY0/bdtp+1vR1wBrHvuaOVydP+wN3AKZK2KfdPAJwAPNDYTlPnOFPnkLRKqVXRuD3Ez1b18ZzQb215kEgpNYWkXSRNa/uHshrxOTAVcJikiSsnh62BmUthpJRS+lGV48c5kray/a3tb4hqrFNIuhY4i+hD3dg73NZBMIDtd4mV0E27PHQGUaBnyp4fVc+p/BvuRtSX2KAUWbyYmGD9XV1jSx3rMiLLoDHpNtjsisqWhcklHdNjI0zDJfcEp5S6XVnVPR4YA7gSOKakI84GHEBsxXiJWLnZGFjD9kO5FzilNDQq2yk2J9KBD7R9SdlesQowDfCh7RNqHWg3qBT/WpWopj820QP5r8D1REugzYH1bS9Y0zB7XMkGGBeYA/gQeK7sg87zSOoWpdXRqbYXK7evA9a1/fFgnt84Ll1LFAC9pOdGm4ZVBsEppW5X0oFmJlpW/JoIek+zfYGkmYDlgKWBp4HrbN/SAfv1Uko9rBxrdgUWJQruvT2o57TrsaVa3VnSM8Cmtu+WtAexGvowMdn4PbCV7UczCEype5Qq7BcRBa+eIQrObSNpBOD76nGlMlm1JHCU7TnrGXUaWhkEp5SaRtIoRIGaVYiA+DXg4EpLj/9dnHZqK4+UUveprLRUg8MxiLTnWYjiUPd1SiBYSa9cDlgWOMj2++WxMYFViePqa7ZfyuNoSt1P0rHAtsATwAa2nyj39wV+qH7nJD0JrGb7uVoGm4ZaBsEppW5XuXDrR6Tu9QUWJFpazAvcQ8yUvl7fKFNK7UjSOEQKdH+iDdKdRI/OzYhtowfUOLxuVyYTbyeOnTvZPrrmIaXUK1SuZbYn9pxPQFRlv5TIPPmoPK+xCrwrMI/tdesbdRpaGQSnlLpV5WQwH/BHYHngKuAm4HVgQmAN4Evb69c30pRSO5K0ILAf8CKwFrE68zGRsjgO8Bvbl9c0vKaQNBexjWRn4C5g50YxwXZO906pVQ0uq6J8F48mJqVOsL1L5bHziG0Jn/bYQNNwyyA4pdQUJSXoCuDvwOlEj+CrgWuBb4BHbb+WF3AppR8zhAvSvkRw+DWwCDC57S16enzdrTKZODXxumYm+h7fCqwMrE4cX3fK9OeUuleX7RYbEcXXJgUusH1luX914FjgF43UZ0mj2f6ipmGnYZRBcEqp20laC9jD9tzl9ivAQcAWwMTEKsZF9Y0wpdSOJM1D9AJ+BnjX9gtdHm+kL3bKnuAHiVXuV4j+wLMA+wBvENWht7J9V13jS6kTVSah/gYsADwFfETsC76NKFD3vqR+tr/Lyfz21K/uAaSUOtLIwD8AJB0KvGj7ZEmfE6s2d5THsohLSmmIKheamxN9xccheuW+L+kG4FrbHwA0LkTbOQCuBPIrEkV3lpY0ElFbYWNgXeJ9WDjTLlPqfiUAHh9YB5i90RJJ0snAicR38Fjb35XnZwDchvrUPYCUUuexfRaR+gzRZP748ufViBYD72QAnFIaGiUAFpFNspftaYm+sL8g+uMeKOnXNQ6xW5UAuA+x8vtYmQTob/tL4GKiHdJCGQCn1FTjAW8S38OGV4je3ItJGq0cl1KbyiA4pdQUtl8sf3wNuFjS8cAyRCuTlFL6UaXCPMCGwL22r5M0GXEsWYIoirU8MFJNQ2yWaYH9gQ2ANUtFbEp7pM+ByWocW0odz/azwPPE92+Ucp+JQHgS21/kRH57y3TolFKzHQB8QbQw+bXtrxvpjTWPK6XUoiQtYPu+sgrcF3gBOLc8vDdwte0XJV0NCLis/FxHZJjYfkHSuEQdhYOAhSW9TRQAmxn4DWRl6JSaoXIcOY3Y2vULSWcBUxC9uXcvz+uI2gO9VRbGSimllFLLkDQakUHyFvBb2w+W+8e1/aGk/Ym9svtLegI43vYJnRoQShobOJzYD3w5sRfx9jrHlFJvIukvwKzEcekB22fXPKTUDTIITimllFLLkPRb4EaiCvJmwJXAZrY/Ko+vA5wHPAh8b3uhusbakyRND5wFfAUcB9xR0qNTSk1QzVqTNLLtryuP5Spwm8sgOKWUUkotQdKawJm2Ry23ZwaOBJYEDrK9f7l/cqJd0MOlVUmvuCAthXhWJFLD97d9RM1DSqmjNYpf2XaldVJHZp30NlkYK6WUUkqtYjYGtFfbCFjE9nJEq5KNJb0jaS3bb9i+sbES2hsCYIgLcdtXAxMAZ9Q9npTa1dBWdi7fOZc/N44z20kao2mDSz0ig+CUUkoptYqbgPUkXUa0VrsRwPZlREGoo4BzJD1QqRzd69j+ppEenlIaNo3CV5JGlbRy18cG8zP9yv83BFay/VkPDDU1UaZDp5RSSqllSJoYeBgYGzgQONx2/8rjUwAL2L6kU6pBp5R6TiOdWdK5wKe2t/6R5//vOCPpVWB+2+/2xFhT82QQnFJKKaWWUaohX1D+2wSYBDjY9v9L/80gOKU0LCqrwHMDtwGT2/5M0jREz/G3iP7AT1OyoSt7gf8MjGh7t9peQOo2GQSnlFJKqaVIGqNcmE4MbABsDrxDFIO6td7RpZTanaS7iQrru0taDtgX+AEYl2iFtIfthytB8/hEv/IJbX9T38hTd8k9wSmllFKqVWW/3SyStgPWlrQ48LHtw4BVgVeAnWobZEqpI0iaAZgfGEPSbMDRwCm2F7E9M/AecIakUSqZJrsSrdoyAO4QuRKcUkoppZYg6QUi2B0beAl4Brja9v3l8cYKca9oiZRSag5JsxM1B5YGHrG9aKMvsKSfAX8ngt43yvMnsf12jUNO3azXVlZMKaWUUv0qRWp+Dbxie2lJ4wJrE/2Bp5X0NLFS8x70npZIKaXuJakP0Mf2E8Aqkn4FjNrlaVMBU1cC4D4ZAHeeXAlOKaWUUq1Kz82diYvRPWz/UO7/GbAxMAuwke3P6xtlSqkdDaqAnqSRqlXnK/dPANwN/M32yZl10rkyCE4ppZRSrSQtC1wPfA8sY/u2Lo9PYfv1xqpxHWNMKbWnSrbJ3sDLts9p3E+sCn9Xbo9JVKRfwfZytQ049YgMglNKKaVUO0kjAccBmwJnA3+y/Wa9o0optbNKdef5gXuBF4FXgT1t31ee09gL3AcYCRjZ9ke5CtzZsjp0SimllGolaRrb/W1vTqQ+zwQ8LenAcmGaUkrDrJIGvS4xubYOUXDvAkmnSZqwsRIMrAAI+Lj8bAbAHSxXglNKKaXUoyorL8sAawGLlYcOt31Kec7GwK9tr17XOFNK7U/SiMAvge9t3yRpdGBhYBtgDuAo4HbgDmAq2x/XNNTUgzIITimllFItJL0BHAPcRLQq2Ql4GFi9WrQm0xJTSj9FCYRHsf1J5b6JgeWJfcCLAQfZ3iuPN71DBsEppZRS6nGS1gK2sL105b6xgDuJi9ELahtcSqmtVStCSxqrEfyW7RWuVouWtDuwle2pu/5s6ly5zyallFJKdXgXmEbSnPC/C89PgKuBeWsdWUqpbVWKYU0kaV/gakkXSBrF9g/lMVV+ZGvgwPKz/TIA7h0yCE4ppZRSHe4HbgDWlrQ4MHq5fzHgbYiL2ZrGllJqf6cD0wAnA/MA60uaRNLIlVXi0YD1bJ8KUCmSlTpcpkOnlFJKqeka++wkTQssBfQDpiWqQb9FVIT+DhjR9iLlZzItMaU01CqrwMsCZ9ierNz/NnA38CywI/Bn23+tb6Spbv3qHkBKKaWUOl+l0MwlQH/gM+Al4BPge6JC6/vERWoWw0opDbPKpNnawGEAknYlJti2tP2+pLuBSyU9bfvyekaa6pZBcEoppZSaSlIf2z9IWh7ob3shSVMQK8LzAOMB8wN/bbQnyQA4pTSsKtkjBwKflrs/BjYoAfBItq+WdDEweV3jTPXLIDillFJKTVUC4D7AdMCDJSh+HfiHpAeAXxF9O0euc5wppfYlaSJgc0lX2X68cX+l97gqrdemA26u3J/bLnqZ3BOcUkoppaaTND3wEGBgI+A2259WHp/a9it5QZpSGh6SVge2BV4F7gGuK5NtA22vkLQVsJvtaWobbKpdBsEppZRS6hGS+gJbArsAlwJnAi/Y/qrWgaWUOoKknwPrAhMAXxPHmbtsf1EeXw7YlyiMdW1piZQVoXuhDIJTSiml1KMkjU0UwpoTuBg4unGRmlJKw6q0U+tr+ztJvyJWhJcDHgBuBa61fbekiYGpbd9b43BTC8ggOKWUUkq1kDQbsKvtjeseS0qp/ZW+v88DmwGvAEsDywKjAlcQKdLP1zbA1DIyCE4ppZRS7bIlUkrpp5K0AfB72wtW7psRuBIQsIvtK+saX2odfeoeQEoppZRSBsAppW7wEDB6CXwBsP0s0TP4euCqugaWWksGwSmllFJKKaW2VlqvPQ08Alwhaety/+jAdsC9tl3ataVeLtOhU0oppZRSSm2nBL4/lD+PbvtzSeMA6wPrALMCDwO2vXSNQ00tJoPglFJKKaWUUlup9hSX9CdgcWBSovXaA8BzwFzA28CLJUDO2gMJyCA4pZRSSiml1GYaAa2kvYFfAwcAUwBrAf2B7Ww/V+cYU+vKIDillFJKKaXUdiSNTBTD2sD2I+W+PsD5wCTAUra/rXGIqUXlxvCUUkoppZRS2yg9xgF+AF4G/tcSqewR3g34Gpig50eX2kEGwSmllFJKKaW2IGkRYH9JU9v+BrgZ2EDS+pLGLE+bCfiZ7bdqG2hqaZkOnVJKKaWUUmoLkiYnVnrHAra0/ZWkg4AZgb7AqMB4wLG2/5HFsNKgZBCcUkoppZRSahuSxgBOA8YEtgXeAFYGRgemAa62/UB9I0ytLoPglFJKKaWUUstqtEPq0hZpJGJFuI/t/Yb0cz041NQmck9wSimllFJKqWVVAtlxG/t+bfcHrgYWk3S1pPGH8HMpDSRXglNKKaWUUkotp9ILeAXgt8CEQD/gLtu7NZ4DnAR8Chxm+61cAU4/JleCU0oppZRSSi2nBMB9gAuIKtAnAccBy0r6RNLmpejVAURBrM3Kz2UAnIaoX90DSCmllFJKKaXBWB14zPaJjTskXQRsDfxB0vi2D5Z0CnCqpLeAM0q/4JQGKVeCU0oppZRSSq3qGWAiSctJEoDt74gV4QOB30iaxPZDwHzAzRkApx+TQXBKKaWUUkqpVb0A3ETsCZ6tcaftH2yfC3wOLFzu+872K3UMMrWXDIJTSimllFJKLaGx2ttg+yvgIKIH8L8l7StpeklTSJoAWAh4soahpjaW1aFTSimllFJKLUXSgsCKwB22byr3rQb8lagE3Q/4vjz+B0l9Mg06Da0MglNKKaWUUkq1awSyknYCNgLeA34JHGd7x8rzfgkIeAt4tvxMBsFpqGUQnFJKKaWUUmoJkkYB3gRWsH2vpPmAXYFTgeWA6xorwykNr9wTnFJKKaWUUmoVCwKP27633H6OaJO0PDAzcLqklesaXOoMGQSnlFJKKaWUWsULwPSSTpM0O7ECfLPtnWwvD1wCLCYp45g03PLDk1JKKaWUUmoJtl8HtiDilKOACYGDK0/pC0yY+3/TT5F7glNKKaWUUkq1kCR3CUiqRa4k7Q/MB+wDfA38G5jH9otZDCsNr351DyCllFJKKaXUOzUCYEm/ANYGHgXOAL4pT7kZmBE4BfgCOKgEwH1tf9/T402dIVeCU0oppZRSSj2u0hJpT2Al4EVgSaIY1sq2Py/PmxUYCfhvSZce5ApySkMrg+CUUkoppZRSLSSNQwS/S9h+QpKIlOe/2L6m3tGlTpWFsVJKKaWUUkp1+S1wRwmARymru3cD6zWeIGlBSdPXNsLUcTIITimllFJKKdXlQeB2SSPb/qrcdz4wh6QRJI0I3AmMU9sIU8fJdOiUUkoppZRSj5K0A3CG7U8ljWb7i+o+X0n3AesAmwFz2l459wGn7pJBcEoppZRSSqnHSJobOI6o9nym7XMqj41s+2tJBwOzAwsBs9l+K1sipe6S6dAppZRSSimlnvQUsCNwK7CRpPMlzQdg++vynMeA5YFjSgDcNwPg1F2yT3BKKaWUUkqpx9juD9wvqT+x13c7YFZJtwGH237V9vmSJrN9WPmxDIBTt8l06JRSSimllFKPk3QPcDXwMjAGsBQwBXAmsV+4f3lepkGnbpVBcEoppZRSSqlHSVoMOMf2VOV2X2Bu4GRgWuBU27vUOMTUwXJPcEoppZRSSqmnvQ68LmnBcvsH2w8ChwD/AA6GWAWuZ3ipk+WHKqWUUkoppdSjbL8CvAscJmmWSuujXwJ9bL9fnpdp0KnbZTp0SimllFJKqaka+3oljU4EugsDrwG7AlMBNwJ9gemAeWx/nHuBU7NkEJxSSimllFJqKkmybUmXEZWeRyVSoj8HBLwPPAq8ZPvp0hLp+9oGnDpatkhKKaWUUkopNVUJgOcDFrQ9CYCkyYDVgfWA7W3fX3l+BsCpaXJPcEoppZRSSqknjAI81Lhh+03bxwCPAMvXNqrU62QQnFJKKaWUUuoJrwDzStq3y/0fANP3/HBSb5V7glNKKaWUUko9QtKywH7Al8ClxPbMvYFf2H4yi2GlnpBBcEoppZRSSqlHSBIwO7AasA5wM3Cn7QszAE49JYPglFJKKaWUUu0aFaTrHkfqfBkEp5RSSimllFLqNbIwVkoppZRSSimlXiOD4JRSSimllFJKvUYGwSmllFJKKaWUeo0MglNKKaWUUkop9RoZBKeUUko9QNKJkvbu7ucOxzhWk/S6pM8lzd2M35FSSim1sqwOnVJKKf0ISa8Am9v+V91j+akkvQjsbPuKbvi7DPzM9gs/fWQppZRSz8iV4JRSSuknktSv7jEMg6mAJ+seBICkvnWPIaWUUu+TQXBKKaU0BJLOBqYEriopxH+UNLUkS9pM0mvALeW5F0t6R9Inku6QNGvl7/mHpAPLn38h6Q1Jf5D0nqS3Jf12OJ87nqSrJH0q6QFJB0q6axCvYyRJnwN9gcfKijCSJpX0T0n/lfSypO0rPzO/pHskfVx+798ljVgeu6M87bHyvqwtaZOuv7u8T9NXXtcJkq6V9AWw5FD8/gfLa3tX0hHD9Y+YUkopVWQQnFJKKQ2B7Q2B14CVbY9u+9DKw0sAMwO/KrevA34GTAg8DJw7hL96YmAsYDJgM+A4SeMMx3OPA74oz9m4/Deo19Hf9ujl5py2p5PUB7gKeKz83UsBO0pqvJ7vgZ2A8YGFyuPblL9v8crfNbrtC4fwWqvWA/4CjAHc/SO//2jgaNtjAtMBFw3l70gppZQGK4PglFJKafjtZ/sL218B2D7d9me2+wP7AXNKGmswP/stcIDtb21fC3wOzDgszy3pxKsD+9r+0vZTwJnDMP75gAlsH2D7G9svAacA65TX85Dte21/Z/sV4CQi8P8prrD9b9s/ALMP6feX1z29pPFtf2773p/4u1NKKSXaaQ9TSiml1Gpeb/yhBKR/AdYEJgB+KA+ND3wyiJ/9wPZ3ldtfAqMP4nlDeu4ExLn89cpj1T//mKmASSV9XLmvL3AngKQZgCOAeYFRy+96aBj+/kGpjm+Iv59Y9T4AeEbSy8D+tq/+ib8/pZRSL5dBcEoppfTjBtdKoXr/esAqwNLAK0T68keAmjiu/wLfAZMDz5X7phiGn38deNn2zwbz+AnAI8C6tj+TtCOwxhD+vi+IYBkASRMP4jnV92yIv9/288C6JW37N8Alksaz/cUQxpBSSikNUaZDp5RSSj/uXWDaH3nOGEB/4AMiEDyo2YOy/T1wKbCfpFElzQRsNAx/xf3AZ5J2kzSKpL6SZpM0X3l8DOBT4PPyd2/d5ee7vi+PAbNKmkvSyERK+HD/fkkbSJqgpE5/XH7mh8H9ZSmllNLQyCA4pZRS+nF/BfYqVZJ3GcxzzgJeBd4EngJ6av/q74lV53eAs4HziWD8R5UgeiVgLuBl4H3g1PL3AexCrHB/RuzV7Vr8aj/gzPK+rGX7OSJ9+V/A88D/q1I9jL9/OeDJUtX6aGCdxv7rlFJKaXjJHlyGV0oppZTajaRDgIltD7JKdEoppdTb5UpwSiml1MYkzSRpDoX5iWJSl9U9rpRSSqlVZWGslFJKqb2NQaRAT0rs0T0cuKLWEaWUUkotLNOhU0oppZRSSin1GpkOnVJKKaWUUkqp18ggOKWUUkoppZRSr5FBcEoppZRSSimlXiOD4JRSSimllFJKvUYGwSmllFJKKaWUeo0MglNKKaWUUkop9Rr/B/bGmW6fnJqAAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -590,7 +599,7 @@ "outputs": [], "source": [ "cg_train_influences = compute_influences(\n", - " TwiceDifferentiable(nn_model, F.cross_entropy),\n", + " TorchTwiceDifferentiable(nn_model, F.cross_entropy),\n", " *train_data,\n", " *test_data,\n", " influence_type=\"up\",\n", @@ -618,7 +627,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Percentage error of cg over direct method:0.0007946275658844653 %\n" + "Percentage error of cg over direct method:0.000655835626812189 %\n" ] } ], diff --git a/src/pydvl/influence/__init__.py b/src/pydvl/influence/__init__.py index fe8fa3f51..bb01db465 100644 --- a/src/pydvl/influence/__init__.py +++ b/src/pydvl/influence/__init__.py @@ -7,5 +7,5 @@ probably change. """ -from .frameworks import TwiceDifferentiable +from .frameworks import TorchTwiceDifferentiable, TwiceDifferentiable from .general import calculate_influence_factors, compute_influences diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index 70b7ae04b..b8ae80b1e 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -1,40 +1,8 @@ -import logging -import os - -from .base_twice_differentiable import BaseTwiceDifferentiable - -logger = logging.getLogger(__name__) - -available_frameworks = [] -try: - import torch - - available_frameworks.append("torch") -except ImportError: - pass - - -if available_frameworks == []: - raise ValueError("No supported framework is installed. Currently supported: torch.") -elif len(available_frameworks) > 1: - logger.warning( - f"There are multiple available frameworks: {available_frameworks}. " - f"Environment choice will default to {available_frameworks[0]}" - f"You can select the one you want to use by setting os.environ['FRAMEWORK']= preferred_framework" - ) - -FRAMEWORK = os.environ.get("FRAMEWORK", "Not Set") -if FRAMEWORK == "Not Set": - FRAMEWORK = available_frameworks[0] - -if FRAMEWORK == "torch": - from .torch_differentiable import TorchTwiceDifferentiable as TwiceDifferentiable - - TensorType = torch.Tensor - # etc. (or something like that) -else: - raise ValueError(f"Unknown framework: {FRAMEWORK}") +from .torch_differentiable import TorchTwiceDifferentiable +from .twice_differentiable import TensorType, TwiceDifferentiable __all__ = [ "TwiceDifferentiable", + "TorchTwiceDifferentiable", + "TensorType", ] diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 847f57882..af0a3cf36 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -5,14 +5,19 @@ from typing import Callable, Optional, Tuple import numpy as np -import torch -import torch.nn as nn from numpy.typing import NDArray -from torch import autograd -from torch.autograd import Variable from ...utils import maybe_progress -from .base_twice_differentiable import BaseTwiceDifferentiable +from .twice_differentiable import TwiceDifferentiable + +try: + import torch + import torch.nn as nn + from torch import autograd + from torch.autograd import Variable + +except ImportError: + pass __all__ = [ "TorchTwiceDifferentiable", @@ -27,7 +32,7 @@ def flatten_gradient(grad): return torch.cat([el.reshape(-1) for el in grad]) -class TorchTwiceDifferentiable(BaseTwiceDifferentiable[torch.Tensor, nn.Module]): +class TorchTwiceDifferentiable(TwiceDifferentiable[torch.Tensor, nn.Module]): """ Calculates second-derivative matrix vector products (Mvp) of a pytorch torch.nn.Module """ diff --git a/src/pydvl/influence/frameworks/base_twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py similarity index 90% rename from src/pydvl/influence/frameworks/base_twice_differentiable.py rename to src/pydvl/influence/frameworks/twice_differentiable.py index af22cdce4..fea2a28d0 100644 --- a/src/pydvl/influence/frameworks/base_twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -7,7 +7,7 @@ ModelType = TypeVar("ModelType") -class BaseTwiceDifferentiable(ABC, Generic[TensorType, ModelType]): +class TwiceDifferentiable(ABC, Generic[TensorType, ModelType]): def __init__( self, model: ModelType, @@ -19,7 +19,10 @@ def num_params(self) -> int: pass def split_grad( - self, x: TensorType, y: TensorType, progress: bool = False + self, + x: TensorType, + y: TensorType, + progress: bool = False, ) -> NDArray: """ Calculate the gradient of the model wrt each input x and labels y. From 9b7b4be451a2e013be2d2721e2ca3e0dd77470e0 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 3 Mar 2023 11:49:25 +0100 Subject: [PATCH 026/436] fix typing --- src/pydvl/influence/frameworks/twice_differentiable.py | 4 ++-- src/pydvl/influence/inversion_methods.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index fea2a28d0..dff468c3b 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -1,9 +1,9 @@ from abc import ABC -from typing import Callable, Generic, Optional, Tuple, TypeVar +from typing import Callable, Generic, Optional, Sequence, Tuple, TypeVar from numpy.typing import NDArray -TensorType = TypeVar("TensorType") +TensorType = TypeVar("TensorType", bound=Sequence) ModelType = TypeVar("ModelType") diff --git a/src/pydvl/influence/inversion_methods.py b/src/pydvl/influence/inversion_methods.py index fe062978b..5f0dba0db 100644 --- a/src/pydvl/influence/inversion_methods.py +++ b/src/pydvl/influence/inversion_methods.py @@ -54,7 +54,7 @@ def invert_matrix( i.e. it returns $x$ such that $Ax = b$ """ if inversion_method == InversionMethod.Direct: - return (np.linalg.inv(mvp(np.eye(mvp_dimensions[1]))) @ b.T).T + return (np.linalg.inv(mvp(np.eye(mvp_dimensions[1]))) @ b.T).T # type: ignore elif inversion_method == InversionMethod.Cg: return conjugate_gradient( LinearOperator(mvp_dimensions, matvec=mvp), b, progress From fec23a78b3890c0cc1d68d2cbee457cd8da9295d Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 3 Mar 2023 12:26:54 +0100 Subject: [PATCH 027/436] fix torch tests --- tests/influence/test_influences.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 66b3bc67e..73d036a72 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -10,7 +10,7 @@ from numpy.typing import NDArray from torch import nn -from pydvl.influence import TwiceDifferentiable, compute_influences +from pydvl.influence import TorchTwiceDifferentiable, compute_influences from pydvl.influence.general import InfluenceType, InversionMethod from .conftest import ( @@ -144,7 +144,7 @@ def test_influence_linear_model( ) direct_influences = compute_influences( - TwiceDifferentiable(linear_layer, loss), + TorchTwiceDifferentiable(linear_layer, loss), *train_data, *test_data, progress=True, @@ -154,7 +154,7 @@ def test_influence_linear_model( ) cg_influences = compute_influences( - TwiceDifferentiable(linear_layer, loss), + TorchTwiceDifferentiable(linear_layer, loss), *train_data, *test_data, progress=True, @@ -257,7 +257,7 @@ def test_influences_nn( multiple_influences = [] for inversion_method in InversionMethod: influences = compute_influences( - TwiceDifferentiable(nn_architecture, loss), + TorchTwiceDifferentiable(nn_architecture, loss), x_train, y_train, x_test, From 2a040b7a74cc51ce28c4cec7b7916806cd6d14a4 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 8 Mar 2023 18:05:14 +0100 Subject: [PATCH 028/436] remove unnecessary type conversions in influence calculation --- docs/pydvl.bib | 157 ------------- notebooks/influence_imagenet.ipynb | 85 +++---- notebooks/influence_synthetic.ipynb | 76 +++++-- notebooks/influence_wine.ipynb | 64 ++++-- notebooks/support/common.py | 6 +- notebooks/support/torch.py | 31 ++- notebooks/support/types.py | 10 +- src/pydvl/influence/__init__.py | 2 +- src/pydvl/influence/frameworks/__init__.py | 50 +++- .../frameworks/torch_differentiable.py | 214 ++++++++++-------- .../frameworks/twice_differentiable.py | 34 ++- src/pydvl/influence/general.py | 90 ++++---- src/pydvl/influence/inversion.py | 105 +++++++++ src/pydvl/influence/inversion_methods.py | 84 ------- tests/influence/test_influences.py | 33 ++- tests/influence/test_torch_differentiable.py | 75 ++---- 16 files changed, 537 insertions(+), 579 deletions(-) delete mode 100644 docs/pydvl.bib create mode 100644 src/pydvl/influence/inversion.py delete mode 100644 src/pydvl/influence/inversion_methods.py diff --git a/docs/pydvl.bib b/docs/pydvl.bib deleted file mode 100644 index f6aca21f8..000000000 --- a/docs/pydvl.bib +++ /dev/null @@ -1,157 +0,0 @@ -@inproceedings{ghorbani_data_2019, - title = {Data {{Shapley}}: {{Equitable Valuation}} of {{Data}} for {{Machine Learning}}}, - shorttitle = {Data {{Shapley}}}, - booktitle = {Proceedings of the 36th {{International Conference}} on {{Machine Learning}}, {{PMLR}}}, - author = {Ghorbani, Amirata and Zou, James}, - year = {2019}, - month = may, - eprint = {1904.02868}, - eprinttype = {arxiv}, - pages = {2242--2251}, - publisher = {{PMLR}}, - issn = {2640-3498}, - url = {http://proceedings.mlr.press/v97/ghorbani19c.html}, - urldate = {2020-11-01}, - abstract = {As data becomes the fuel driving technological and economic growth, a fundamental challenge is how to quantify the value of data in algorithmic predictions and decisions. For example, in healthcare and consumer markets, it has been suggested that individuals should be compensated for the data that they generate, but it is not clear what is an equitable valuation for individual data. In this work, we develop a principled framework to address data valuation in the context of supervised machine learning. Given a learning algorithm trained on n data points to produce a predictor, we propose data Shapley as a metric to quantify the value of each training datum to the predictor performance. Data Shapley uniquely satisfies several natural properties of equitable data valuation. We develop Monte Carlo and gradient-based methods to efficiently estimate data Shapley values in practical settings where complex learning algorithms, including neural networks, are trained on large datasets. In addition to being equitable, extensive experiments across biomedical, image and synthetic data demonstrate that data Shapley has several other benefits: 1) it is more powerful than the popular leave-one-out or leverage score in providing insight on what data is more valuable for a given learning task; 2) low Shapley value data effectively capture outliers and corruptions; 3) high Shapley value data inform what type of new data to acquire to improve the predictor.}, - archiveprefix = {arXiv}, - langid = {english} -} - -@inproceedings{jia_efficient_2019, - title = {Towards {{Efficient Data Valuation Based}} on the {{Shapley Value}}}, - booktitle = {Proceedings of the 22nd {{International Conference}} on {{Artificial Intelligence}} and {{Statistics}}}, - author = {Jia, Ruoxi and Dao, David and Wang, Boxin and Hubis, Frances Ann and Hynes, Nick and G{\"u}rel, Nezihe Merve and Li, Bo and Zhang, Ce and Song, Dawn and Spanos, Costas J.}, - year = {2019}, - month = apr, - pages = {1167--1176}, - publisher = {{PMLR}}, - issn = {2640-3498}, - url = {http://proceedings.mlr.press/v89/jia19a.html}, - urldate = {2021-02-12}, - abstract = {``How much is my data worth?'' is an increasingly common question posed by organizations and individuals alike. An answer to this question could allow, for instance, fairly distributing profits...}, - langid = {english} -} - -@article{jia_efficient_2019a, - title = {Efficient Task-Specific Data Valuation for Nearest Neighbor Algorithms}, - shorttitle = {{{VLDB}} 2019}, - author = {Jia, Ruoxi and Dao, David and Wang, Boxin and Hubis, Frances Ann and Gurel, Nezihe Merve and Li, Bo and Zhang, Ce and Spanos, Costas and Song, Dawn}, - year = {2019}, - month = jul, - journal = {Proceedings of the VLDB Endowment}, - volume = {12}, - number = {11}, - pages = {1610--1623}, - issn = {2150-8097}, - doi = {10.14778/3342263.3342637}, - url = {https://doi.org/10.14778/3342263.3342637}, - urldate = {2021-02-12}, - abstract = {Given a data set D containing millions of data points and a data consumer who is willing to pay for \$X to train a machine learning (ML) model over D, how should we distribute this \$X to each data point to reflect its "value"? In this paper, we define the "relative value of data" via the Shapley value, as it uniquely possesses properties with appealing real-world interpretations, such as fairness, rationality and decentralizability. For general, bounded utility functions, the Shapley value is known to be challenging to compute: to get Shapley values for all N data points, it requires O(2N) model evaluations for exact computation and O(N log N) for ({$\epsilon$}, {$\delta$})-approximation. In this paper, we focus on one popular family of ML models relying on K-nearest neighbors (KNN). The most surprising result is that for unweighted KNN classifiers and regressors, the Shapley value of all N data points can be computed, exactly, in O(N log N) time - an exponential improvement on computational complexity! Moreover, for ({$\epsilon$}, {$\delta$})-approximation, we are able to develop an algorithm based on Locality Sensitive Hashing (LSH) with only sublinear complexity O(Nh({$\epsilon$}, K) log N) when {$\epsilon$} is not too small and K is not too large. We empirically evaluate our algorithms on up to 10 million data points and even our exact algorithm is up to three orders of magnitude faster than the baseline approximation algorithm. The LSH-based approximation algorithm can accelerate the value calculation process even further. We then extend our algorithm to other scenarios such as (1) weighed KNN classifiers, (2) different data points are clustered by different data curators, and (3) there are data analysts providing computation who also requires proper valuation. Some of these extensions, although also being improved exponentially, are less practical for exact computation (e.g., O(NK) complexity for weigthed KNN). We thus propose an Monte Carlo approximation algorithm, which is O(N(log N)2/(log K)2) times more efficient than the baseline approximation algorithm.}, - langid = {english} -} - -@inproceedings{koh_understanding_2017, - title = {Understanding {{Black-box Predictions}} via {{Influence Functions}}}, - booktitle = {Proceedings of the 34th {{International Conference}} on {{Machine Learning}}}, - author = {Koh, Pang Wei and Liang, Percy}, - year = {2017}, - month = jul, - eprint = {1703.04730}, - eprinttype = {arxiv}, - pages = {1885--1894}, - publisher = {{PMLR}}, - abstract = {How can we explain the predictions of a black-box model? In this paper, we use influence functions \textemdash{} a classic technique from robust statistics \textemdash{} to trace a model's prediction through the learning algorithm and back to its training data, thereby identifying training points most responsible for a given prediction. To scale up influence functions to modern machine learning settings, we develop a simple, efficient implementation that requires only oracle access to gradients and Hessian-vector products. We show that even on non-convex and non-differentiable models where the theory breaks down, approximations to influence functions can still provide valuable information. On linear models and convolutional neural networks, we demonstrate that influence functions are useful for multiple purposes: understanding model behavior, debugging models, detecting dataset errors, and even creating visually-indistinguishable training-set attacks.}, - archiveprefix = {arXiv}, - langid = {english}, - file = {/Users/fabio/Zotero/storage/HW6BK957/D9MZ9MUI.pdf;/Users/fabio/Zotero/storage/J4YQYLEN/Koh and Liang - 2017 - Understanding Black-box Predictions via Influence .pdf;/Users/fabio/Zotero/storage/MHFVLFHJ/Koh and Liang - 2017 - Understanding Black-box Predictions via Influence .pdf} -} - -@inproceedings{kwon_beta_2022, - title = {Beta {{Shapley}}: A {{Unified}} and {{Noise-reduced Data Valuation Framework}} for {{Machine Learning}}}, - shorttitle = {Beta {{Shapley}}}, - booktitle = {Proceedings of the 25th {{International Conference}} on {{Artificial Intelligence}} and {{Statistics}} ({{AISTATS}}) 2022,}, - author = {Kwon, Yongchan and Zou, James}, - year = {2022}, - month = jan, - volume = {151}, - eprint = {2110.14049}, - eprinttype = {arxiv}, - publisher = {{PMLR}}, - address = {{Valencia, Spain}}, - url = {http://arxiv.org/abs/2110.14049}, - urldate = {2022-04-06}, - abstract = {Data Shapley has recently been proposed as a principled framework to quantify the contribution of individual datum in machine learning. It can effectively identify helpful or harmful data points for a learning algorithm. In this paper, we propose Beta Shapley, which is a substantial generalization of Data Shapley. Beta Shapley arises naturally by relaxing the efficiency axiom of the Shapley value, which is not critical for machine learning settings. Beta Shapley unifies several popular data valuation methods and includes data Shapley as a special case. Moreover, we prove that Beta Shapley has several desirable statistical properties and propose efficient algorithms to estimate it. We demonstrate that Beta Shapley outperforms state-of-the-art data valuation methods on several downstream ML tasks such as: 1) detecting mislabeled training data; 2) learning with subsamples; and 3) identifying points whose addition or removal have the largest positive or negative impact on the model.}, - archiveprefix = {arXiv}, - langid = {english} -} - -@inproceedings{okhrati_multilinear_2021, - title = {A {{Multilinear Sampling Algorithm}} to {{Estimate Shapley Values}}}, - booktitle = {2020 25th {{International Conference}} on {{Pattern Recognition}} ({{ICPR}})}, - author = {Okhrati, Ramin and Lipani, Aldo}, - year = {2021}, - month = jan, - eprint = {2010.12082}, - eprinttype = {arxiv}, - pages = {7992--7999}, - publisher = {{IEEE}}, - issn = {1051-4651}, - doi = {10.1109/ICPR48806.2021.9412511}, - url = {https://ieeexplore.ieee.org/abstract/document/9412511}, - abstract = {Shapley values are great analytical tools in game theory to measure the importance of a player in a game. Due to their axiomatic and desirable properties such as efficiency, they have become popular for feature importance analysis in data science and machine learning. However, the time complexity to compute Shapley values based on the original formula is exponential, and as the number of features increases, this becomes infeasible. Castro et al. [1] developed a sampling algorithm, to estimate Shapley values. In this work, we propose a new sampling method based on a multilinear extension technique as applied in game theory. The aim is to provide a more efficient (sampling) method for estimating Shapley values. Our method is applicable to any machine learning model, in particular for either multiclass classifications or regression problems. We apply the method to estimate Shapley values for multilayer perceptrons (MLPs) and through experimentation on two datasets, we demonstrate that our method provides more accurate estimations of the Shapley values by reducing the variance of the sampling statistics.}, - archiveprefix = {arXiv}, - langid = {english} -} - -@misc{wang_data_2022, - title = {Data {{Banzhaf}}: {{A Robust Data Valuation Framework}} for {{Machine Learning}}}, - shorttitle = {Data {{Banzhaf}}}, - author = {Wang, Jiachen T. and Jia, Ruoxi}, - year = {2022}, - month = oct, - number = {arXiv:2205.15466}, - eprint = {2205.15466}, - eprinttype = {arxiv}, - primaryclass = {cs, stat}, - publisher = {{arXiv}}, - doi = {10.48550/arXiv.2205.15466}, - url = {http://arxiv.org/abs/2205.15466}, - urldate = {2022-10-28}, - abstract = {This paper studies the robustness of data valuation to noisy model performance scores. Particularly, we find that the inherent randomness of the widely used stochastic gradient descent can cause existing data value notions (e.g., the Shapley value and the Leave-one-out error) to produce inconsistent data value rankings across different runs. To address this challenge, we first pose a formal framework within which one can measure the robustness of a data value notion. We show that the Banzhaf value, a value notion originated from cooperative game theory literature, achieves the maximal robustness among all semivalues -- a class of value notions that satisfy crucial properties entailed by ML applications. We propose an algorithm to efficiently estimate the Banzhaf value based on the Maximum Sample Reuse (MSR) principle. We derive the lower bound sample complexity for Banzhaf value estimation, and we show that our MSR algorithm's sample complexity is close to the lower bound. Our evaluation demonstrates that the Banzhaf value outperforms the existing semivalue-based data value notions on several downstream ML tasks such as learning with weighted samples and noisy label detection. Overall, our study suggests that when the underlying ML algorithm is stochastic, the Banzhaf value is a promising alternative to the semivalue-based data value schemes given its computational advantage and ability to robustly differentiate data quality.}, - archiveprefix = {arXiv} -} - -@inproceedings{wang_improving_2022, - title = {Improving {{Cooperative Game Theory-based Data Valuation}} via {{Data Utility Learning}}}, - booktitle = {International {{Conference}} on {{Learning Representations}} ({{ICLR}} 2022). {{Workshop}} on {{Socially Responsible Machine Learning}}}, - author = {Wang, Tianhao and Yang, Yu and Jia, Ruoxi}, - year = {2022}, - month = apr, - eprint = {2107.06336v2}, - eprinttype = {arxiv}, - publisher = {{arXiv}}, - doi = {10.48550/arXiv.2107.06336}, - url = {http://arxiv.org/abs/2107.06336v2}, - urldate = {2022-05-19}, - abstract = {The Shapley value (SV) and Least core (LC) are classic methods in cooperative game theory for cost/profit sharing problems. Both methods have recently been proposed as a principled solution for data valuation tasks, i.e., quantifying the contribution of individual datum in machine learning. However, both SV and LC suffer computational challenges due to the need for retraining models on combinatorially many data subsets. In this work, we propose to boost the efficiency in computing Shapley value or Least core by learning to estimate the performance of a learning algorithm on unseen data combinations. Theoretically, we derive bounds relating the error in the predicted learning performance to the approximation error in SV and LC. Empirically, we show that the proposed method can significantly improve the accuracy of SV and LC estimation.}, - archiveprefix = {arXiv}, - langid = {english} -} - -@inproceedings{yan_if_2021, - title = {If {{You Like Shapley Then You}}'ll {{Love}} the {{Core}}}, - booktitle = {Proceedings of the 35th {{AAAI Conference}} on {{Artificial Intelligence}}, 2021}, - author = {Yan, Tom and Procaccia, Ariel D.}, - year = {2021}, - month = may, - volume = {6}, - pages = {5751--5759}, - publisher = {{Association for the Advancement of Artificial Intelligence}}, - address = {{Virtual conference}}, - doi = {10.1609/aaai.v35i6.16721}, - url = {https://ojs.aaai.org/index.php/AAAI/article/view/16721}, - urldate = {2021-04-23}, - abstract = {The prevalent approach to problems of credit assignment in machine learning \textemdash{} such as feature and data valuation\textemdash{} is to model the problem at hand as a cooperative game and apply the Shapley value. But cooperative game theory offers a rich menu of alternative solution concepts, which famously includes the core and its variants. Our goal is to challenge the machine learning community's current consensus around the Shapley value, and make a case for the core as a viable alternative. To that end, we prove that arbitrarily good approximations to the least core \textemdash{} a core relaxation that is always feasible \textemdash{} can be computed efficiently (but prove an impossibility for a more refined solution concept, the nucleolus). We also perform experiments that corroborate these theoretical results and shed light on settings where the least core may be preferable to the Shapley value.}, - copyright = {Copyright (c) 2021, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved.}, - langid = {english} -} diff --git a/notebooks/influence_imagenet.ipynb b/notebooks/influence_imagenet.ipynb index 52fa941de..0bd47a5c2 100644 --- a/notebooks/influence_imagenet.ipynb +++ b/notebooks/influence_imagenet.ipynb @@ -52,7 +52,16 @@ "metadata": { "nbsphinx": "hidden" }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/fabio/.local/lib/python3.8/site-packages/requests/__init__.py:109: RequestsDependencyWarning: urllib3 (1.26.9) or chardet (5.1.0)/charset_normalizer (2.0.12) doesn't match a supported version!\n", + " warnings.warn(\n" + ] + } + ], "source": [ "%autoreload\n", "%matplotlib inline\n", @@ -163,7 +172,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -219,22 +228,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "No pretrained model found. Training for 50 epochs:\n" + "Cached model found, loading...\n" ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "2abf9960efa04a92a0036a80d3ce93f5", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Model fitting: 0%| | 0/50 [00:00" ] @@ -296,7 +291,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -340,7 +335,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9566b9d6e81c43d3b79d68baefd5e9d0", + "model_id": "e3987ef307b244daa52901a37e8c6a74", "version_major": 2, "version_minor": 0 }, @@ -354,7 +349,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "afb3f25bbe9148259b435432b2077c33", + "model_id": "c3bbbc02169c4fbea47abc3a223a73bb", "version_major": 2, "version_minor": 0 }, @@ -368,7 +363,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "fc101405997f43e3817bdc0218d18932", + "model_id": "1d377c04ea2e42e985d2ac84c40c736c", "version_major": 2, "version_minor": 0 }, @@ -415,7 +410,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -458,7 +453,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -492,7 +487,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -538,7 +533,7 @@ "metadata": {}, "outputs": [], "source": [ - "avg_influences = np.mean(influences, axis=0)" + "avg_influences = np.mean(influences.numpy(), axis=0)" ] }, { @@ -555,7 +550,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -586,7 +581,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -639,22 +634,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "No pretrained model found. Training for 50 epochs:\n" + "Cached model found, loading...\n" ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "52b8115cf41e4fa0b1177a60e4c2ec4c", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Model fitting: 0%| | 0/50 [00:00" ] @@ -736,7 +717,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "cb4c9bf44ef84b26bf38bdfddc725e37", + "model_id": "fd88eebcafe240609c436d98bfe60d17", "version_major": 2, "version_minor": 0 }, @@ -750,7 +731,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "26ea34222a6d453dbeb9ae94aa0923de", + "model_id": "a1199fbf27064c98921b21f235d7c527", "version_major": 2, "version_minor": 0 }, @@ -764,7 +745,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d3941d119c1b456c8857207d8615a4d4", + "model_id": "627478999b414264a1fe6df061e6573c", "version_major": 2, "version_minor": 0 }, @@ -804,7 +785,7 @@ "metadata": {}, "outputs": [], "source": [ - "avg_corrupted_influences = np.mean(corrupted_influences, axis=0)" + "avg_corrupted_influences = np.mean(corrupted_influences.numpy(), axis=0)" ] }, { @@ -814,7 +795,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -847,7 +828,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -902,7 +883,7 @@ " tables\n", " -0.156153\n", " -3.846006\n", - " 3.689852\n", + " 3.689853\n", " \n", " \n", " 1\n", @@ -917,7 +898,7 @@ ], "text/plain": [ " label avg_non_corrupted_infl avg_corrupted_infl score_diff\n", - "0 tables -0.156153 -3.846006 3.689852\n", + "0 tables -0.156153 -3.846006 3.689853\n", "1 boats -0.030673 -3.689159 3.658486" ] }, diff --git a/notebooks/influence_synthetic.ipynb b/notebooks/influence_synthetic.ipynb index 7ac280e42..2084f59fd 100644 --- a/notebooks/influence_synthetic.ipynb +++ b/notebooks/influence_synthetic.ipynb @@ -217,7 +217,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -265,10 +265,20 @@ "id": "bdef13ee", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Converting tensor to type torch.Tensor.\n", + "Converting tensor to type torch.Tensor.\n", + "Converting tensor to type torch.Tensor.\n", + "Converting tensor to type torch.Tensor.\n" + ] + }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f4b626fcdb0a4efe80f3904c00725b57", + "model_id": "487c5262408849c89263b290a2f24d30", "version_major": 2, "version_minor": 0 }, @@ -322,7 +332,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -354,7 +364,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 12, @@ -363,7 +373,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -441,7 +451,18 @@ "execution_count": 14, "id": "f817a6c3", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Converting tensor to type torch.Tensor.\n", + "Converting tensor to type torch.Tensor.\n", + "Converting tensor to type torch.Tensor.\n", + "Converting tensor to type torch.Tensor.\n" + ] + } + ], "source": [ "influence_values = compute_influences(\n", " differentiable_model=TorchTwiceDifferentiable(model, F.binary_cross_entropy),\n", @@ -474,7 +495,7 @@ "metadata": {}, "outputs": [], "source": [ - "mean_train_influences = np.mean(influence_values, axis=0)" + "mean_train_influences = np.mean(influence_values.numpy(), axis=0)" ] }, { @@ -503,7 +524,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -548,7 +569,18 @@ "execution_count": 17, "id": "643977a7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Converting tensor to type torch.Tensor.\n", + "Converting tensor to type torch.Tensor.\n", + "Converting tensor to type torch.Tensor.\n", + "Converting tensor to type torch.Tensor.\n" + ] + } + ], "source": [ "y_corrupted = np.copy(y)\n", "y_corrupted[:10] = [1 - yi for yi in y[:10]]\n", @@ -563,7 +595,7 @@ " inversion_method=\"direct\",\n", ")\n", "\n", - "mean_train_influences = np.mean(influence_values, axis=0)" + "mean_train_influences = np.mean(influence_values.numpy(), axis=0)" ] }, { @@ -576,8 +608,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average mislabelled data influence: -0.7618193132719681\n", - "Average correct data influence: 0.008644202479956366\n" + "Average mislabelled data influence: -0.7444811400091976\n", + "Average correct data influence: 0.00821720819296775\n" ] } ], @@ -604,7 +636,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -661,12 +693,22 @@ "id": "e508f38c", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Converting tensor to type torch.Tensor.\n", + "Converting tensor to type torch.Tensor.\n", + "Converting tensor to type torch.Tensor.\n", + "Converting tensor to type torch.Tensor.\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "Average mislabelled data influence: -0.7618190305526785\n", - "Average correct data influence: 0.008644202231215354\n" + "Average mislabelled data influence: -0.7444808863702257\n", + "Average correct data influence: 0.008217208115930281\n" ] } ], @@ -680,7 +722,7 @@ " influence_type=\"up\",\n", " inversion_method=\"cg\",\n", ")\n", - "mean_train_influences = np.mean(influence_values, axis=0)\n", + "mean_train_influences = np.mean(influence_values.numpy(), axis=0)\n", "\n", "print(\"Average mislabelled data influence:\", np.mean(mean_train_influences[:10]))\n", "print(\"Average correct data influence:\", np.mean(mean_train_influences[10:]))" @@ -702,7 +744,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3sAAAIfCAYAAADJ38UbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAAsTAAALEwEAmpwYAACyCUlEQVR4nOzdd3gU1f7H8fd3Nz0h9N5VRAkdVMSCIoqKP7l2xQa2y7X3a+/1Yq9XEXvDXi7YCyKKilIDiijSCS2QXnb3/P7YVUMSIIEks9l8Xs8zT3ZnZmc+u2n73XPmHHPOISIiIiIiIrHF53UAERERERERqXkq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0RkR1kZseZ2W9mFjSzZ83sADNzZtbB62zRJPK6zDOzUjP7cgv73GRmi+o4mifMrEvk52Rfr7NsS1V/piM//5/WVa5YY2Z/mNl11XxMvfk5EpG6p2JPRCRie96ompkfeBp4DegEXFQb2WLE48BPwE7A0VvY5x5gUJ0lKsPM9o28ae5SR6dcBrQFvqvOg8wsYGajayXRln1DOOvKSIa6fq2ikpk9taUPLqKZmV1nZn94nUNEap+KPRGRHdMWSAMmO+dWOOc2eR0oinUDPnHOLXPObahsB+dcnnNuXR3n8oRzLuicW+2cK/U6y7Y450oiWUNeZ6kqM4uvyjoRkVimYk9EZAv+bOkzs3PMbImZ5ZjZe2bWOrJ9NOHWGYCvIi0dB1RynEq7wJVvoTGz1pFzrjWzXDObZmb7V3Kcg83sKzMrMLP5ZnZYueO2MrNnzCzLzIrM7BczO6PM9l3M7E0z22hm2Wb2sZn1KrM9PfL41WZWbGbLzOy+bbxW3c1skpnlRZb3zWyXsrkBP/B85DmM3sJxNuvG+ed9MxtpZj+bWb6ZfWlm3crsMzryWg4zs8zIc/7OzPqW36fcuTr8+T2LtFBNjWxaHFn/5VaerzOziyKvY76ZrTCzi8rt09bMXo28zoWR3APLbN+s+12Z+8eb2f8i39/fy/2M/BF5HZ+J7Osi66v1PTOzF8zspTL3x0SOd1aZdS+Z2SuR23/9DFfltdrS78xW8sSZ2Y0W7g5dHHk9H67Ga/lnvhFm9rWZFQFn2d+/wxdEXrtiM0uOPP6pchk2a+0q89hLInkKzOx1M2sW2X4TcCYw5M/vxZ/fKzNLM7MHyzxuppkdXe58fczsm8jz/dXMjt/aa1TmccdHfieKzOwboHe57WZm4yOvZWHkZ+gOM0uMbB8N3Ap0LpP7psi2URb+3dlkZuss/Du9a1VyiUh0UrEnIrJ1ewAHAiOA4UAvwl0NASYCe0ZujyTcyvfN9pzEzJKBL4BGwGFAP2Ay8ImZ7V5u93uAO4A+hLsATjSzpmWOMyWy7WSgB3ABUBDZ3hr4GlgD7Ee4y+QvwJdm1jJy/NuA/pHn1A04AViwjewfA0nAkMiSBnxoZgn83QUQ4PzI7YnVeHnaAv+KPJ/BhF+jp8vt4wP+A5xL+HuyFpgUyVYVywg/XyKPb8uWu5r+6UbgS8Lfq/8A95rZSAi/4QbeAXYDjogcM4vw97PFNo57F/A84TfxrwJPlXnDvQcQBC6OZPzzda3W94zwz9qBZe4PJfyaDS2z7kDg80oeu63Xamu/M1syATgPuInwz+wxwO9Q7dfyXuBuYHfg/TIZh0Yy9wFKtpGlrD0jz+VQ4HCgbyQrkef0MvAtf38vJkbyvh851wlAT8JdmF81s4MizymZ8O/3xsg5TgOuAFptLYyZ9QNeAV6PHP8e4MHyuxH+/R5F+HW4GBgDXBPZPpHwa7S8TO4/vz+J/P2zdDDhn7VJkd9jEamPnHNatGjRosU5gGeBT8vdXwMklln3b2BVmftdAAfsW2bdAZF1HSq7X2a/ADA6cns04TdfceX2+Rx4oNxxji6zvXVk3fDI/TOBovLnKrP/TcD0cusM+A24OHL/XeDZarxuZxIuJluUy1UInFZmnQNO2caxbgIWlbsfAFqWWXcCEAKSyrx2DjiozD5NgTzgzDL7BMqdq0PkcQdE7u8bud+lCs/ZAS+UW/cyMDVy+6DIPj3KbE8EVgE3VPazU+b+pWUe4wdygX9W9nNTZl11v2ddyuaL/OxdRuRnm3CR4ICdt/AzXelrRRV+ZyrJskvkWMduYXtVXss/851aSZ6NQFq59V8CT5Vbdx3wR7nH5gGNy6w7JHKeXSL3nwK+LHecAwj/DjYut/5p4J3I7bMix25aZnvPyLGv28pr9SIwrdy68yn3N6iSx10C/Lql57qVxzWLHHufqv5sadGiJbqWOEREZGt+ds4Vl7m/knAhU9P2ANoAG8MNA39JJFw0lTXrzxvOuSwzC5bJNACY75xbvpXzDDCzvHLrkwm3CAE8BrwZ6Sb3GfAh8JHb8vVaGZFz/nWtXSTXL5FtO2qlc25t2fuEC9RWwNIy678tc/5sM1tQQ+ffkm/L3Z9GuHsckfOud87NL5Op2My+q0KmWWUeEzSzNWz7Z65a3zPn3B+RLotDIz8/TSLHuMHMehBuzVrqnPttG+etTHV/Z/pHvn68he3VeS2/r+TxC5xz5X/eq2q+2/w63GmRrz2ALY0auweQAKwo97ucAPxa5vELnHPZf250zs0zs21d89uD8Pe3rK/L72RmZxMuKLsAqUAcVejNZeGuzzcSbsFsQfj3DKAzfz93EalHVOyJiGxd+S5fjr/fAFXVn2+4/3qchUfxLPvmy0e4291RlTy+YBuZ/nx8VfgIv1k8v5JtmwCccx+ZWSfCXfAOINyaMNfMDnLOBat4nppU2fcAqncpQmVFT7QO1lHZ893qc93O79nnhFvNgsDXzrlCM/uKcJfHLXXh3N781f2d2V75VVwXomKmmvp58BH+Xdqjkm3V6UK6XczsOOBR4CrCXbpzgOOA27fxuBTCBffXhLt9ZkU2ZRIuVEWkHtI1eyIitW9N5Gu7Muv6svmbzRmEpyTIcc4tKresrMa5fgR62JbnQ5tBuDVkeSXn+av1zDm3wTn3inPun4SvvRpCuFWhMpmRc/51/VTk2sDuwLxqZN9Rf03ZYGZNCHdF/LM1aA3gLzdQSH829+cbcX91zxcxuMz5MoHmkVayPzMlAnux469JSWUZq/k9g/B1e0OAYfzdWvRnAXgAWy/2qvtabc1Pka+HbGF7bbyWa9j89xEq/jwA7G5m6WXuD458/fP7XNn3YgbhltKkSn7HlpZ5/O6Rn1MAzCwDaLyN3PPLZPjTPuXu7w/MdM7d55z70Tn3K+EWvrIqy7070BK41jn3pXNuAeHu0HVVqItILVCxJyJS+xYBS4CbzGw3C4++eD9/t1ABvAQsJjwYwiEWHplxLzO72sz+UY1zvRI513sWHp2yq5kdZGYnRLY/QvhN3rtmtl/kPPua2e1mNhggcvtoC4+w2Y3wwCh5bN5lsqyXCQ/uMdHM+pvZAMIDi6ygegOx7AgH/MfM9rfwyKLPE77W7eXI9u8j9+8ys25mdihwQ7ljLCHc4nO4hUc03dYb7yPM7PzI8S4gfC3hvZFtn0fO+bKZ7WNmPSOZkggP1rEjFgMHmlm7Pwvs7fie/ZmxKXAkfxd2nxMeBKUZWy/2qvtabZFzbhHhn//HzOwUM9vZzPawv0c3rY3X8lNgmJkdZ+HRaa8iPGBRhXiER5DtaeGRcR8F3otkhvD3YjczyzCzFpEi9PPI8d8ys3+Y2U5mNsDCI4KeHXncy4R/Hl+08Kicgwhf01e+y3Z59wN7R77fu5rZUYSvtSzrF6CXhUew3TnyOpYfbGgx0MbM9o7kTiH8PS0GLog87iDCg784RKTeUrEnIlLLnHMBwoVAK2Am4TeM11Kma6FzrohwK8sM4BlgIfAW4ZH6llTjXAWR48wjXHAtiJwvObI9C9gbWBc5/i+E32h3JjzgBYQHl7iFcCvhDMKjQh7mtjCHoHOukHCrTDHwFeGuY/nAoc65Wu+2FhEiPNrgE4QztwFGRF4PXHhev5MIt8bNAa4Hrix7gMhrczXh7m+rCA96sjW3EG4Vmx0595XOubcjx3LAP4CfgUnAD5FMB7sdn0fwMsLXZv5BuMiGan7PIhlXEv45yyX8cwnh12YjsNA5t2Irj63ua7UtYwh/724j/DP7NtA1cq7aeC2fI/x78Sjh16sj8FAl+31PuFvjJ4Svg5wLnFFm+4RInm8Ify9OiuQ9kvDv1/1lco8gPBDSn7+nhwPNI+d4KbLvGrbCOfcj4VE2T4xkuYrw4CtlPQG8QPjvyEzCLaA3ldvnHcIjek6K5L4y8lqeQngUzkzCI3ReTuVdoEWknrDw3yQREZH6ycLzhj3lnKuz69AtPL/dqc65F+vqnFK3zOxZwqOPDvM6i4jI9lLLnoiIiIiISAxSsSciIiIiIhKD1I1TREREREQkBqllT0REREREJAap2BMREREREYlBKvZERERERERikIo9ERERERGRGKRiT0REREREJAap2BMREREREYlBKvZERERERERikIo9ERERERGRGKRiT0REREREJAap2BMREREREYlBKvZERERERERikIo9ERERERGRGKRiT0REREREJAap2BMREREREYlBKvZERERERERikIo9ERERERGRGKRiT0REREREJAap2BMREREREYlBKvZERERERERikIo9ERERERGRGKRiT0REREREJAap2BMREREREYlBKvZERERERERikIo9ERERERGRGKRiT0REREREJAap2BMREREREYlBKvZERERERERikIo9ERERERGRGKRiT0REREREJAap2BMREREREYlBKvZERERERERikIo9ERERERGRGKRiT0REREREJAap2BMREREREYlBKvZERERERERikIo9ERERERGRGKRiT0REREREJAap2BMREREREYlBKvZERERERERikIo9ERERERGRGKRiT0REREREJAap2BMREREREYlBcV4HqG0tWrRwXbp08TqGiIiIiEhU+fHHH9c551p6naOqhh+Y6tZvCNb4cX+cU/yRc+7QGj9wFIj5Yq9Lly7MmDHD6xgiIiIiIlHFzJZ4naE61m8I8v1HnWr8uP62v7ao8YNGiZgv9kREREREpP5zQIiQ1zHqFRV7IiIiIiJSDziCTsVedWiAFhERERERkRiklj0REREREYl64W6czusY9Ypa9kRERERERGKQWvZERERERKRe0AAt1aNiT0REREREop7DEXTqxlkd6sYpIiIiIiISg9SyJyIiIiIi9YIGaKketeyJiIiIiIjEILXsiYiIiIhI1HNAUC171aJiT0RERERE6gV146wedeMUERERERGJQWrZExERERGRqOdAUy9Uk1r2REREREREYlBUFHtm1tHMvjCz+WaWaWYXVbKPmdlDZrbIzOaYWX8vsoqIiIiIiDdCtbDEsqgo9oAAcJlzrgcwCDjPzHqU2+cwoFtkOQd4vG4jVt+vv/7K2rVrvY4hIiIiIiINUFQUe865Vc65nyK3c4EFQPtyu40Enndh04EmZta2jqNWmXOOU045hYyMDN544w2v44iIiIiI1GsOR7AWllgWFcVeWWbWBegHfFduU3tgWZn7y6lYEP55jHPMbIaZzfCqZc3MmDBhAp06deK4447j+OOPZ82aNZ5kERERERGp9xwEa2GJZVFV7JlZGvAmcLFzLmd7j+Oce9I5N9A5N7Bly5Y1F7CaevbsyfTp07nzzjt59913ycjIYOLEiTiNIiQiIiIiIrUsaoo9M4snXOi95Jx7q5JdVgAdy9zvEFkX1eLi4rjqqquYOXMmO+20EyeeeCLHHnssWVlZXkcTEREREak3HBqgpbqiotgzMwMmAAucc/dtYbf3gNMio3IOAjY551bVWcgd1KNHD6ZNm8bdd9/NpEmT6NGjBy+//LJa+UREREREpFZERbEH7AOcCgw1s1mR5XAzG2tmYyP7TAZ+BxYB44FzPcq63eLi4rjyyiuZNWsWu+66KyeffDJHHXUUq1bVm5pVRES2ojS4gZU5L7J042PkFM/SB3oiIjXKCNbCEsvivA4A4Jz7Grb+Srvwf8zz6iZR7dptt934+uuveeCBB7juuuvIyMjgwQcf5JRTTiHcyCkiIvVNduE3zF/zT8ARciUs2/Q4zVMOonuL+zCLls9WRUTqLweE9Blatei/j0f8fj+XXXYZs2bNYvfdd+e0007jyCOPZMWKqL8MUUREygm5EhasPZ+QKyTkioAQIVfI+oLPWVfwodfxRESkgVKx57Hu3bvz1Vdfcf/99/PZZ5/Rs2dPnn32WXX9ERGpR3KKfgJX8TL/kCsgK+9NDxKJiMQmdeOsHhV7UcDv93PxxRcze/ZsevbsyZgxYxgxYgTLly/3OpqIiOTkwOOPw9lnw3nnwfvvQzC4+T5b7YIf228kREQkeqnYiyLdunVjypQpPPjgg0yZMoWMjAwmTJigVj4REa+8/TZ07Yr7/HM27dKDgrYd4bbboGdPWLTor93SE/tDJdfl+SyF1mnH1GViEZGY5VDLXnWp2IsyPp+PCy+8kDlz5tCvXz/OOussDj30UJYuXep1NBGRhuWbb2DsWBY+8Ayn5A7i1HfyOf79Ei7tcQ55Z5wDBx8cbvUDfBbP7i0fwWfJ+CwJ8OGzZJqnHESLlOHePg8RkRgSclbjSyxTsReldt55Zz7//HMeffRRpk2bRs+ePRk/frxa+URE6sqdd7Lpsqu54rE5rMvKobiolNKSIAvmLuPCaX7cgAHwwgt/7d40eTB7dviKrk2vpnOTi+nd5iV2a3m/RuIUERHP6D9QFPP5fJx77rnMnTuXgQMHcs4553DIIYewZMkSr6OJiMS2vDz4/HPetp0IBDYfeCUUdGxYm8sfQ46AiRM32xbvb0q79JPp1ORcGiX2rsvEIiIxT904q0/FXj3QtWtXPv30Ux5//HGmT59Oz549efzxxwmFKo78JiIiNSA3F9LSWL6mkEAgWOku632psGlTHQcTERGpOhV79YTP52Ps2LHMmzePQYMGce655zJs2DAWL17sdTQRkdjTvDmUljKoazKJyfEVNgcDIXYpWAU77eRBuOhSFFjJ8k3jWZL9EHnF87yOIyIxzGEE8dX4Esti+9nFoM6dO/Pxxx8zfvx4ZsyYQa9evXj00UfVyiciUpMSEuCUUzhg/qc0aZpKXLz/r02JSfEccNCuNHlxQng6hgYsK+9dflxxMH9k38fSTY8we/WJLFp/s64vF5FaowFaqkfFXj1kZpx11lnMmzePfffdl/PPP5+hQ4fy22+/eR1NRCR2XHMNcZPe58m+2RxzVB9at2tC551bceFpfbl07ovhVr1DD/U6pWdKg5tYtP4aQq4YRykQIuSKyMp7g5ziH7yOJyIiqNir1zp16sQHH3zA008/zaxZs+jVqxcPPvigWvlERGpCmzYwdSpJ8+dyxj1n8Lz7hCfXvsaw607Hdt89PDiLr+H+G80u/AojrsL6kCtiTd77HiQSkVjn5QAtZnaomf1iZovM7KpKtiea2cTI9u/MrEsNP/3t0nD/S8UIM2PMmDHMmzePAw88kIsvvpghQ4bw66+/eh1NRKT+69AhPLH6rFlw3nlw7bWwZAn85z/hrp4NmJmPLXXW1HQTIhJLzMwPPAocBvQATjKzHuV2OxPIds7tAtwP3F23KSunv8YxokOHDvzvf//jueeeY968efTu3Zv777+fYLDyUeRERKQaOnaEESPgkEMgLc3rNFGhafL+QMX/MT5LolXqyLoPJCINgBF0vhpfqmBPYJFz7nfnXAnwKlD+D91I4LnI7TeAg8zM8wsCVezFEDPjtNNOIzMzk2HDhnHppZey33778csvv3gdTUREYkycrxG7trgHnyXhsySMeHyWSLtGp5Ge1N/reCIi1dHCzGaUWc4pt709sKzM/eWRdZXu45wLAJuA5rUVuKoqdraXeq9du3a89957vPTSS1x44YX07duXW2+9lUsuuQS/37/tA4iIiFRBy9RDaZy0B+vyPyTkimiWciAp8ZqOQkRqhwNCtdNWtc45N7A2Duw1tezFKDPjlFNOITMzk0MOOYQrrriCfffdlwULFngdTUREYkiCvznt0k+mQ+MzVeiJSK3zaICWFUDHMvc7RNZVuo+ZxQGNgfU18JR3iIq9GNe2bVveeecdXnrpJRYuXEi/fv24++67CQQCXkcTEREREakPfgC6mVlXM0sATgTeK7fPe8DpkdvHAp+7KJh0VMVeA2BmjBo1iszMTEaMGMFVV13F4MGDyczM9DqaiIiIiEiVOOfNAC2Ra/DOBz4CFgCvOecyzewWMzsystsEoLmZLQIuBSpMz+AFFXsNSJs2bXjjjTeYOHEiixcvpn///tx5551q5RMRERER2Qrn3GTn3K7OuZ2dc7dH1t3gnHsvcrvIOXecc24X59yezrnfvU0cpmKvgTEzjj/+eDIzMxk5ciTXXHMNgwYNYu7cuV5HExERERHZqhBW40ssU7HXQLVq1YrXXnuN119/naVLlzJgwABuu+02SktLvY4mIiIiIlKBA4L4anyJZbH97GSbjj32WObPn88xxxzD9ddfz1577cXs2bO9jiUiIiIiIjtIxZ7QokULXnnlFd566y1WrlzJwIEDufnmmykpKfE6moiIiIhIhDcDtNRnsf3spFqOOuooMjMzOeGEE7jpppvYY489mDlzptexRERERERkO6jYk800b96cF198kXfffZc1a9aw5557csMNN6iVT0REREQ85YAQvhpfYllsPzvZbkceeSSZmZmMGjWKW2+9lQEDBjBjxgyvY4mIiIhIAxZ0VuNLLFOxJ1vUrFkznnvuOf73v/+xYcMGBg0axLXXXktxcbHX0UREREREZBtU7Mk2jRgxgszMTE477TTuuOMO+vfvz/fff+91LBERERFpQBymqReqKbafndSYJk2a8PTTT/PBBx+Qk5PD3nvvzVVXXUVRUZHX0UREREREpBIq9qRaDj30UObNm8cZZ5zB3XffTb9+/Zg+fbrXsURERESkAQg5X40vsSy2n53UisaNGzN+/Hg++ugj8vPz2WeffbjiiisoLCz0OpqIiIiIiESo2JPtdsghhzBv3jzOOuss7rnnHvr27cs333zjdSwRERERiUEOdM1eNcX2s5Nal56ezhNPPMEnn3xCcXEx++67L5deeikFBQVeRxMRERGRGOKo+WkXNPWCSBUMGzaMuXPnMnbsWO6//3769OnD1KlTvY4lIiIiItJgqdiTGtOoUSMee+wxPv/8c4LBIEOGDOGiiy4iPz/f62giIiIiEgNC+Gp8iWWx/ezEEwceeCBz5szhvPPO46GHHqJ3795MmTLF61giIiIiIg2Kij2pFWlpaTz88MN8+eWXABxwwAFccMEF5OXleRtMREREROol5yDofDW+xLLYfnbiuSFDhjBnzhwuuugiHn30UXr37s0XX3zhdSwRERERqXeMUC0ssUzFntS61NRUHnjgAaZMmYLf72fo0KGce+655Obmeh1NRERERCRmqdiTOrPffvsxe/ZsLr30Uv773//Sq1cvPv30U69jiYiIiEg94FA3zuqK7WcnUSclJYV7772Xr7/+msTERA4++GD++c9/kpOT43U0EREREZGYomJPPDF48GBmzZrFFVdcwVNPPUXPnj35+OOPvY4lIiIiIlEsiK/Gl1gW289OolpycjL/+c9/+Oabb0hLS2P48OGcddZZbNq0yetoIiIiIhJlHEbI1fwSy1Tsief22msvfvrpJ6666iqeeeYZMjIymDx5stexRERERETqNRV7EhWSkpK48847mT59Ok2aNGHEiBGMGTOG7Oxsr6OJiIiISJRQN87qie1nJ/XOHnvswY8//si1117LCy+8QM+ePfnf//7ndSwRERERkXpHxZ5EncTERG677Ta+++47mjdvzv/93/9x6qmnsmHDBq+jiYiIiIhHHBByvhpfYllsPzup1wYMGMCMGTO44YYbePXVV8nIyODdd9/1OpZItWwsnMKclYfx/dLdmL3iINbnT/I6koiIiDQQKvYkqiUkJHDzzTfz/fff07p1a/7xj39w8skns379eq+jiWzTxsIp/Lp2LIWlP+NcMUWB3/l9/RWszXvT62giIiL1kBGshSWWqdiTeqFfv358//333HTTTbz22mtkZGTw9ttvex1LZKuWZt9FyBVtti7kClm28T845zxKJSIiUj+pG2f1xfazk5iSkJDAjTfeyIwZM2jbti1HH300J554IuvWrfM6mkilikoXV7q+NLgOR0kdpxEREZGGRsWe1Dt9+vTh+++/59Zbb+Wtt96iR48evPHGG17HEqkgIa5tpev9vnSMhDpOUz+UBjfwR/Z/mLXycDKzTmNj4VSvI4mISBRRN87qUbEn9VJ8fDzXXXcdP/74Ix07duS4447j+OOPZ82aNV5HE/lLh8aX4bPkzdb5LJn2jc/HLLb/uWyP0uAGZq06nFU5T1NQ+jObir7m57VjWZnztNfRRERE6iUVe1Kv9erVi+nTp3P77bfz7rvvkpGRwcSJE3U9lESFFmlH0KXpLcT7WgI+/L4mdGhyGW0aneF1tKi0MucZAsGNm3VxDblClm68l2Ao38NkIiISDZwzXbNXTVHz7MzsaTNbY2bztrD9ADPbZGazIssNdZ1RolN8fDzXXHMNP/30E127duXEE0/k2GOPJSsry+toIrRsdCz9OnzHHh0zGdDhJ9qmn6lWvS3YWDSl0msZjTjyS372IJGIiESboPPV+BLLounZPQscuo19pjrn+kaWW+ogk9QjGRkZfPPNN9x1111MmjSJHj168Morr6iVTzxnZvh8SSrytiHB37rS9Y5S4v3N6ziNiIhI/Rc1xZ5z7itgg9c5pH6Li4vj3//+NzNnzqRbt26MGjWKo446ilWrVnkdTUS2oV36mRWucYQ4UuJ3Jzm+ixeRREQkijgghNX4Esuiptiror3NbLaZfWBmGVvayczOMbMZZjZj7dq1dZlPosTuu+/OtGnTGDduHB999BEZGRm88MILauVrwEKulDW5E5m/+gQWrD6Z9fnv41zI61hSRuOkQXRpei0+S8FvafgskUYJfdit1RNeRxMREamXLJre/JpZF+B/zrmelWxLB0LOuTwzOxx40DnXbVvHHDhwoJsxY0bNh5V645dffuGMM87gm2++4YgjjuCJJ56gXbt2XseSOuRciJ/XjCaveAYhVwiAz1JolnIoO7e41+N0Ul4wVERB6S/E+5uTFNfB6zgiIjHLzH50zg30OkdVtcto6s589YAaP+5tvd+pV69DddSblj3nXI5zLi9yezIQb2YtPI4l9UD37t356quvuO+++/jss8/IyMjgueeeUytfA7Kp6Gvyin/8q9ADCLkCNhRMpqBkgYfJpDJ+XxKNEvuo0BMRkc04IOSsxpdYVm+KPTNrY5HRDcxsT8LZ13ubSuoLv9/PJZdcwuzZs+nVqxejR49mxIgRLF++3OtoUgc2FU0j5AoqrHcuRE7RdA8SiYiIiNS+qCn2zOwV4Fugu5ktN7MzzWysmY2N7HIsMM/MZgMPASc6Nc1INXXr1o0vv/yShx56iClTppCRkcGECRPUyhfj4n3NMRIrrDeLJ87X1INEIiIisj2C+Gp8iWVR8+yccyc559o65+Kdcx2ccxOcc/91zv03sv0R51yGc66Pc26Qc+4brzNL/eTz+bjggguYM2cO/fr146yzzuLQQw9l6dKlXkeTWtIi9R+YVfxzZ/homnKIB4lEtqC0FL7+Gj76CBYv9jqNiIjUc1FT7InUtZ133pnPP/+cRx55hGnTptGzZ0/Gjx+vVr4YlBDXil1bPoHf1zgyymMq8b6W7Nb6efy+FK/jiYBzcP/90LkzXHQR3Hsv7LknHHoo/KwJ5UVEABw1f71erF+zF+d1ABEv+Xw+zjvvPA4//HDOPPNMzjnnHF577TXGjx9Ply5dvI4nNahx8n707/AD+SVzMfykJvSqtLXPK845snJfYFXOkwRC2aQl9qVT02tJTejhdTSpC1deCV98wYxxTzI+M4cNm/LZe+RFnJ07n0YHHABTpkD37l6nFBGReiZ63umIeKhr1658+umnPP7440yfPp1evXrx+OOPEwppHrZY4rN4GiX2Jy2xT1QVegDLNv6HZRvvoiS4gpArIKfoG+avPo7C0t+8jia1bcECeOEFJl54B/+e/BvzFq5kZdYm3v3qF074JYX88y+Gq67yOqWISFQI4avxJZbF9rMTqQafz8fYsWOZN28egwYN4txzz2XYsGEs1nUzUssCoVxW5z6z2dQQACFXzIpNj3iUSurMU09RctponvhwPkXFpX+tDgRDFBQW82KrPuGWvVWrPAwpIuI95yDorMaXWKZiT6Sczp078/HHH/PEE08wY8YMevXqxaOPPqpWPqk1xYFl+IivZEuQ/OI5dZ5H6tiiRazuvCtx/or/kksDIb5duAa6dYM//qj7bCIiUq+p2BOphJlxzjnnMG/ePPbZZx/OP/98hg4dym+/qUud1LwEf1tCrrSSLUZy/M51nkfqWHo6jQs2URqs/AOl1s0bwZo1kJ5ex8FERKKPBmipHhV7IlvRqVMnPvzwQyZMmMDMmTPp3bs3Dz/8sFr5pEbF+5vSPHUEPkvabL3PEmnX+DyPUkmdOf54Gr/xKr12bUt83Ob/lpMS4zi7bQBSU6GHBusREZHqUbEnsg1mxhlnnEFmZiZDhgzhwgsv5IADDmDRokVeR5MY0rX5nbRMOzFS8PlJjOtIt5b/JS2xj9fRpLYdfjiUljKuaDYDenYiPt5PclI8aSmJXD+yJ7vcdg1cdx1YbH/6LCKyLeGpF3w1vsSy2H52IjWoQ4cOTJo0iWeeeYY5c+bQu3dvHnjgAYLBoNfRJAb4LIEuzW5kYMe5DOw4mz7tptAkeYjXsaQu+P0weTKJn3/Kva/fyuSMIl7t7+eDxLkc8M/j4Pzz4cQTvU4pIhIVgliNL7FMxZ5INZgZo0ePJjMzk4MOOohLLrmE/fffn19++cXraBIjzOLw+1IxteI0LG3awPTpcO+9pKxYSotZ3+Pr2iU8LcPFF3udTkRE6ikVeyLboX379rz33nu88MILLFiwgL59+3LvvfeqlU+kniss/Z3VuS+zLn8yIVdctyf3+WDYMHj8cXj+ebjmmnARKCIiADiib4AWM2tmZp+Y2a+Rr00r2aevmX1rZplmNsfMTtihk1aDij2R7WRmnHLKKWRmZnLIIYdw+eWXs++++/Lzzz97HU1Eqsk5x2/rr2P2qhH8kX0bv62/ih+W70Ve8Tyvo4mISHS7CvjMOdcN+Cxyv7wC4DTnXAZwKPCAmTWpi3Aq9kR2UNu2bXnnnXd46aWXWLhwIX379uXuu+8mEAh4HU1EqmhD4UeszX+HkCsm5IoIujyCoRwWrD0L5zT6rohIdIjKAVpGAs9Fbj8H/KP8Ds65hc65XyO3VwJrgJY7euKqULEnUgPMjFGjRjF//nxGjBjBVVddxeDBg8nMzPQ6mohUQVbuq4RcQYX1wVA+eSVzPUgkIiKVCWE1vgAtzGxGmeWcakRq7ZxbFbm9Gmi9tZ3NbE8gAaiTyZtV7InUoNatW/PGG28wceJEFi9eTP/+/bnjjjvUyicS5UKuqNL1huHq+tq9KnLOEQwV4pyuFRYR2UHrnHMDyyxPlt1oZp+a2bxKlpFl93POOcKXFlbKzNoCLwBjXB11G1GxJ1LDzIzjjz+ezMxMRo4cybXXXsugQYOYO1etAyLRqmXqUfgsudJtaYl96zZMFWwo+IIfVhzIN0v78s3Sfvy+4W6c04dKIvVFIJRLYelS/d5Wk3MQdFbjy7bP64Y553pWsrwLZEWKuD+LuTWVHcPM0oFJwLXOuek1+LJslYo9kVrSqlUrXnvtNV5//XWWLl3KgAEDuPXWWyktLfU6mkjUKgmsYVPR95QEsur0vC3TjiYtoQ8+SwHAiMdnSXRrcT8+S6jTLNuyqehHFqy9gOLAciBIyBWwKvcFFq2/xetoIrINwVAhP6+5hOlL9+KnlSP4dtmerM59w+tYsmPeA06P3D4deLf8DmaWALwNPO+cq9NvuIo9kVp27LHHMn/+fI455hhuuOEG9tprL2bPnu11LJGoEnKlLFx3KT+uGMLPa87mxxUHsHDtxYRc3Xw44rN4Mlq/wK4tHqRN2ql0aHwefdt9QrOUg+rk/NWxdOPDFbqdhlwRa/LfJBDK9SiViFTFwnVXsb7wYxwlhFwhwVAOv224mezCqV5HqzeicICWu4CDzexXYFjkPmY20MyeiuxzPLA/MNrMZkWWvjt64qpQsSdSB1q0aMErr7zCW2+9xcqVKxk4cCA33XQTJSUlXkcTiQrLNj7IhoIPcRQTdLk4illf+DFLN95XZxnM/DRLOYidmt9MxyYXkhTXvs7OXR2FpYsrXW/EURKotPeQiESB0mA26ws+qTCHZ8gVsnTj4x6lkh3lnFvvnDvIOdct0t1zQ2T9DOfcWZHbLzrn4p1zfcsss+oin4o9kTp01FFHkZmZyYknnsjNN9/MnnvuycyZM72OJfVMyBWzJvclfs46gYVrz2Rj4RdeR9phq3NfrNBa5VwRWbkveZQoeqUlZgAVrzFxhEiMa1f3gUSkSkqD6zGLr3RbSXBVpetlc46an1B9RydVj3Yq9kTqWPPmzXnhhRd49913ycrKYs899+SGG25QK59USciV8nPWiSzbeBu5xd+xqfAzflt3Lsuy7/Y62g4Juvwtrg8PbiZ/6tzkQnyWtNk6nyXTIf0s/L7KB5kREe8lxXes5GMaAB/piQPrOE39VUtTL8QsFXsiHjnyyCPJzMxk1KhR3HrrrQwcOJAff/zR61gS5bILJlNY+gshV/jXupArJCv3aUoC9feT4bSEPltY3xuz2P5HXF2pCbvRu81LpCfugc+SSfS3Z6emV9OpyYVeRxORrfBZIp2bXlpu5F8ffkuhU5PzPcslsU3FnoiHmjVrxnPPPcf777/P+vXr2Wuvvbj22mspLo7Oeb3EexsLP6908m+zOHKLv/cgUc3YqdmNkZEw/ZE1fnyWQtdmN3kXKoo1SuxNn7avsE/nuezZcQpt00epKBapB9qnn85uLe8jLaEPCf42tEwdQb9275Ac39nraPWCA3XjrKY4rwOICBxxxBHMmzePSy+9lDvuuIN3332XZ555hj322MPraBJl4n0tCBdE5SfSNuJ8jT1IVDPSEnvRp+3/WJnzJHklmaTG96B943NIju/qdTQRkRrVPOVgmqcc7HUMaSDUsicSJZo2bcozzzzD5MmT2bhxI4MGDeLqq6+mqKho2w+WBqNlo5MqvcDfZ0mkJ+3rQaKakxzfhZ2b30Gftu+yS4s7VeiJiEgFUTj1QlSL7WcnUg8ddthhZGZmMmbMGO666y769+/Pd99953UsiRLJ8bvQtdk4fJaC3xrhs1QS/O3o3uolzNRZQ0REYlgtdOGM9W6cKvZEolDjxo156qmn+PDDD8nNzWXw4MFceeWVFBYWbvvBEvOap/4f/dr/xC4tn6R7q5fp3W4aKQndvY4VPb7+Go47DtLTITkZ9tsPXn0VNKqniIg0MCr2RKLY8OHDyczM5KyzzmLcuHH069ePb775xutYEgV8viTSk/YmLbGPBuYo67HH4MQT2bj33rzw9lv894PJLDvjDBg3DsaMgVDI64QiIrKdHJp6obpU7IlEufT0dJ544gk++eQTioqK2HfffbnssssoKKg4IqM0DMWB5SxccyYzlnbjx2W7s3j9vwmGcr2O5b05c+CWW/jkuecYHB/H7ZmZ3DNrFofm5XLbbbfhfv4ZJkzwOqVIVMgu/IaZK//BtCU9mbH8ENbmf+B1JBGpBSr2ROqJYcOGMXfuXMaOHct9991H3759+frrr72OJXUsGMpl/uqRbCr6AkcpIVfI+vy3+TlrlCYff+wxiv75Ty6an0lRIEBJMEjIOQoDAV5Z9Cu/XHghPPywunPugPyShcxdfTrTlmQwfeleLN34CM4FvI4l1ZRd+A3z15xDXsk8Qq6IwsDvLFx3Batz3/Q6msg26Zq96lGxJ1KPNGrUiMcee4zPPvuMQCDA/vvvz8UXX0x+fr7X0aSOrMt/h1CoAPi7O6KjhKLAb+QVz/AuWDSYOpXv+vfDX0m31qJAgBdbNIfffoPc6GwFzSuey6rcF9hQ8BkhV+p1nAqKAiuYveo4NhZ9Q8gVUxpaz7JN/2Xhumu9jibV9Ef2fwi5zUd6Drki/sgepw+NJKppnr3qU7EnUg8NHTqUOXPmcN555/Hggw/Su3dvpkyZ4nUsqQMFJZmEqDhQjyNEYeBXDxJFETNsK+9TzSzcqhdl1ziGXCnzs85gXtaJLNlwJ7+uu5ifVuxPUekyr6NtZvmmCYRcCeG3W2EhV8Ta/P9REljjXTCptoLS3ypdHwhlE3K6REAklqjYE6mn0tLSePjhh/nyyy8BOOCAA7jgggvIy8vzNpjUqpT43fBZcoX1hp/kuJ09SBRFhgxhrxkzCFbSMpEUF8epWWuge3do1MiDcFu2KudZcoqnE3KFhCgi6PIpCa5l4boLvY62mbySOTgqtjj6LGGLxYNEp0R/u0rX+3wplf59EYkmatmrHhV7IvXckCFDmDNnDhdddBGPPvoovXv35osvvvA6ltSS5mlH47Mkyv75NuJJiutCWuKe3gWLBueeS+L48fx3991JiosjKS6OeJ+PpLg4xnTblV0feAAujK4CCiAr79UKXeogRH7JAkqCaz3JVJmU+F0Bf4X1jhKS4jvXfSDZbp2bXlyhqPNZMh3Tx2Kmt4YisUS/0SIxIDU1lQceeICvvvqKuLg4hg4dyr/+9S9yo/TaJNl+cb50dm/zLulJ+wF+jASapRxJ99YvawqGjAy44w72P/U0vs/L55Zdu3NtRk8+j0/g8iuugIEDYfRor1NW4LZwfZ6ZbXGbFzo0PgufJWy2zkikadJ+JMVV3lIk0all6mHs0uwm4n0tMPz4fY3o1OR8OjQ+x+toIlvl0KTq1WWxfiHuwIED3YwZDXzQAmlQCgoKuP7667n//vvp1KkTTz31FMOGDfM6ltSCP/9+N/gir7wffgiPuvnhh1BaCnvsAeeeCyNHRt31egBLssexMmcCjpLN1ifFdaVfu0+j6vubU/QTv66/noLSX/FZPK1Tj2OnZlfj8yV6HU22g3OOkCvAZ8lq0WugzOxH59xAr3NUVePdWrt9nzyhxo87ecjD9ep1qA4VeyIx6ptvvmHMmDEsXLiQc845h3HjxpGenu51LGkggqF8zPyRLqeyNYFQLnNXH0txYAUhV4BZIj7i6NH6RRol9vE6HhAuCsoWnSFXghGnAkGknquPxd7gJ0+s8eN+OOShevU6VEec1wFEpHYMHjyYWbNmccMNN3DffffxwQcfMH78eIYPH+51NIlh+SXz+GP9vyko/QUDmiQPo0uzu4jzN/E6WtSK8zWiT9v32VDwEZuKfiApriOt0o4m3t/c62hkF07ltw23UVj6G3G+JnRofDYd0s+u0J1TRKROOGK+22VN00dyIjEsOTmZcePGMW3aNFJTUzn00EM588wz2bhxo9fRakzIlfB79sNMWzaEqUsH88v6mygJbvA6VoNUElzDz1knUFCaCQRwBNhY+Bm/rNGE79viswRapP4fOze/hfaNz46KQm9T0Y/MX/MvCiMjbQZCG1m68RGWbLzf42QiIlJVKvZEGoBBgwYxc+ZMrrzySp599ll69uzJBx984HWsGjE7658s3fQUxcHVlIbWszL3dWasOo5gqPzohlLb1ua9UmFAEUcpRYE/yC+Z6VGq6Jdf8jML1pzN98sGMnvlEazPj47fzSUbH6hk4u1CVuQ8o98vEfGEJlWvPhV7Ig1EUlISd999N99++y2NGzfm8MMP54wzzqjXrXw5xXPZVDyTEH+/8XQEKA1uYE3+ZA+TNUyFJQsrDDISZhSW/s7avIn8nDWKX9eezcZCTQ8CUFCykLmrjyW78HMCoQ3kl87n1/WXszLnOa+j/dWiV5FRWktTQuQVz2dJ9sMs2/QkRaXLt/s4zjkCoTycC9VgOhGR+kfFnkgDs+eee/Ljjz9y9dVX8/zzz5ORkcGkSZO8jrVdckvmE/6cb3NBV8CmYrUk1bW0xAGVTsjsCJKV8wxLs28it/gbNhZ+wm/rzmNZ9l0epIwuSzfeT8gVUvbnOOQKWbbxXkKussK57qTEd9vitgR/qxo/328bbmP26uNZuulhlmTfz48rh5OV+2a1j5OV+xbfLdub6UsH8u3S/izZ+KiKPpEYopa96lGxJ9IAJSUlcccddzB9+nSaNWvGEUccwemnn052drbX0aolKa49Vskkzz5LJDm+S90HauBapB2Lz9IoO/G2kUhy3M4UBxdHipqwkCsgK/cZigMrPUgaPfJKZlHZBxaOECWBVXWep6zOTS6uMJqqz5LpkH5mjU+1sKnoR1bnTox0Gw3hKCXkilm04QZKg1X/u7Qu/+PwY0LrcAQIujyWb/ovSzc9XqN5RcQbmmev+lTsiTRgAwcOZMaMGVx33XW89NJLZGRk8N5773kdq8qaJe1NvL8ZlCv4jHjaph3lTagGLM6XTkab92iW8n/4rRHxvpa0ST+HpLhdCLmCCvubxZFbPN2DpNEjMa59pesdwRobpKWwdDGL1l/D7FUj+W39tRSW/lGlx6Un9SOj1XhS43cD/MT7WtC5ySV0anJRjeQqa23+/ypcHxjmZ0Phl1U+zhavM9z0JM4FdyykiEg9pGJPpIFLTEzk1ltv5fvvv6dly5aMHDmSU045hfXr13sdbZvM/Axo8xJNk/YMz/lFPKnx3enf5kUS/M28jtcgJcS1ZecWD9C/41z6dviBDk0uIz6uFZXP9GPE+ZrUccLo0qHx+RW6vvpIomXqP/D70nb4+LnFs5m96v9Yk/c6+SVzycp7jdmrjiCveG6VHt8keW/6t/8f+3X5hUGdptOh8Rm1Msm74QMqO65FtlVNcWBFpetDroRgKH/7wolIVHHOanyJZSr2RASA/v3788MPP3DTTTcxceJEMjIyePvtt72OtU2Jca3p1+ZZ9uv0Hft2/Jq92r9Ho8TdvY4lZbRMOwGzisWez+JJT9rXg0TRo2nyAezU7BbifE3wWRJGIi3TjmKnZjfXyPEXb7gp0qr6Z6tWkJArYHH2LTVy/JrSKu1IfFZZ19AATZMPqPJxtnSdod/XqEaKZxGR+kbFnoj8JSEhgRtvvJEZM2bQtm1bjj76aE466STWrVvndbRtivOlEa+Ju6NScvwudG32H3yWgs/S8Fkq8f7WdG/1kibnBlqlHcMeHX6gX7vP2bPjT+zc/PYaeV2cc+SVzKl0W27xrB0+fk1qlNiH9ulj8FkiRgI+S8JniezafBzx/sZVPk6XZldUcp1hEl2bXoaZ3vKIxIIQVuNLLKusX41Ig+Wcg8ACCGZBfE/M39LrSJ7o06cP33//PXfddRe33norn332GY899hjHHnus19GknmqeeiRNkw8hr+QnfJZEakJfvfkuw8xPYlybGj6m4bdUgi6vwja/pdbouWpCl6aX0irtKDYUfI7PEmmRMpyEuOr9DW6StBcZrZ5icfZ/KChdRKK/LZ2bXkTL1MNrKbWI1CXniPkBVWqaij2RCBdcj8s+A4J/AH5wJbiUk7BG19TKNSrRLj4+nuuvv55//OMfjBkzhuOOO47jjjuORx55hFatan7YdYl9Pl8S6UmDvY7RoLRuNIrVuc9vNmiJz5Jo0+gUD1NtWUp8V1Ian7lDx2iSPIh+yW/VUCIRkfpNH6uKRLiNF0HgV3CF4PKAEih4DYre9Tqap3r16sX06dO54447ePfdd8nIyGDixInhVlARiWqdmlxKs+RDMBLxWyOMRJqlDKdjLYyoKSJSFzRAS/Wo2BMBXHAtlM4CAuW2FOLyn637QFEmLi6Oq6++mp9++omuXbty4okncuyxx5KVleV1NBHZCp8lsGvLBxjQ/kt2a/UkA9pPYdcW9+OzeK+jiYhIHVCxJwLg8ik/V9vf23LrNEo0y8jI4JtvvuHuu+9m0qRJ9OjRg1deeUWtfCJRLiGuNY2T9iIhTl2wRaQ+06Tq1aViTwTA3xF8KZVsiIfEg+o8TjSLi4vjyiuvZNasWey6666MGjWKo446ilWrVnkdTURERETKULEnQngkPEu/A0ji7xa+JPA1w9LGepgseu222258/fXX3HPPPXz00UdkZGTwwgsvqJVPREREao2u2aseFXsiEZZ0INb8TUg+FhIGQ9r5WItJmK+Z19Gilt/v57LLLmPWrFnsvvvunHbaaRx55JGsXLnS62giIiISYxyoG2c1qdgTKcPiu+FrfCu+Zs/iSzsH86V7Hale6N69O1999RX33Xcfn332GRkZGTz33HNq5RMRERHxUNQUe2b2tJmtMbN5W9huZvaQmS0yszlm1r+uM4rIlvn9fi655BJmz55Nz549GT16NCNGjGD58uVeRxMREZFY4MITq9f0EsuiptgDngUO3cr2w4BukeUc4PE6yCQi1dStWzemTJnCgw8+yJQpU8jIyODpp59WK18NCYYKyCueSXFgmddR6sTCnCwemP8J4+Z9yKwNDeM5i4iI1JSoKfacc18BG7ayy0jgeRc2HWhiZm3rJp2IVIfP5+PCCy9kzpw59O3blzPPPJPDDjuMZcv0Zn1HrM6ZwKwVA/hlzanMXXUwC7KOJxDM9jpWrXl20TRGffUkzy6axgu/T+fsb5/j9jn/8zqWiIh4KITV+BLLoqbYq4L2QNl3issj6yows3PMbIaZzVi7dm2dhBORinbeeWe++OILHn74YaZOnUpGRgbjx49XK9922Fj4BSs23UPIFRJyeThXRF7xTBat+5fX0WrF6sJNPPzz5xSHAgRxOBxFwVLeWTaL2WrhExFpkBwajbO66lOxV2XOuSedcwOdcwNbtmzpdRyRBs3n83H++eczd+5cBg4cyDnnnMPw4cNZsmSJ19HqldU54wm5wnJrS8krnklJIPbmOPwqayG+Sj5tLQ6W8tmqBR4kik4lgTXkFv1IaXBrHWNERKShqk/F3gqgY5n7HSLrRKQe2Gmnnfj00095/PHH+fbbb+nZsyf//e9/1cpXRaXBynspmMVRGlpfx2lqX7wvDrOKxZ7PfMT7/JU8omEJuWJ+XXsBs1bszy9rxjBz+d4sXn8dzgW9jiYiUotqftoFTb0QPd4DTouMyjkI2OSci72Ps0VimM/nY+zYscydO5e99tqLf/3rXwwbNozFixd7HS3qNU4eghFf6bbk+F12+Pg5RVNZsOpQZi7dhXkr9mV93ps7fMwdcWCb7jgXqrA+znyM6NDbg0TRZWn2XWQXfIKjmKDLxVHCuvy3WJnzpNfRREQkikRNsWdmrwDfAt3NbLmZnWlmY81sbGSXycDvwCJgPHCuR1FFZAd16dKFTz75hCeffJIffviBXr168eijjxIKVXxzL2Ft0/+J39d4s4LPZ8l0bHItPkvaoWPnFn3Lb2vPpLB0Po4SSoJLWZp9DWtzn9vR2NutSUIKd/Y/hiRfHCn+BJL88ST64rikx8Hs1Khhd893LsTavFdxFG+2PuQKycp5xqNUIiJ1Q1MvVE+c1wH+5Jw7aRvbHXBeHcURkVpmZpx99tkMHz6cs88+m/PPP5/XX3+dCRMmsPPOO3sdL+rE+1vSs+2HrM4Zz6air0jwt6FN+jmkJ+29w8desfEunCvabJ1zhazcdC8t0k7BzJtuk8Pa9WCPFl34cvVCAi7Ifq270Sop3ZMs0cRRSsiVVLot4HLqOI2ISN2K9QFValrUtOyJSMPUqVMnPvzwQyZMmMDMmTPp3bs3Dz30kFr5KhHvb0HHplfTs+0H7NrqmRop9ACKShdVuj4UKiAYyq2Rc2yvxgkpjOzUl2M6D1ChF+GzRJLjK/9ApFHigDpOIyIi0UzFnoh4zsw444wzyMzMZMiQIVx00UUccMABLFpUeREiNSsxrmOl680S8PvS6jiNVEWXZrfis2T+/jfux2cpdGp6rZexRERqVbjbpaZeqA4VeyISNTp06MCkSZN49tlnmTNnDr179+b+++8nGNQIg7WpXZPLMUvebJ3Pkmmd/i/Moqa3v5SRnrQXGW3epnnqkaTE96Bl2vH0ajuZ1IQeXkcTEZEoomJPRKKKmXH66aeTmZnJQQcdxKWXXsr+++/PL7/84nW0mNU4eRidm91DvL8d4MPva0ybxpfQJv18r6PJVqQkdGeXFvfTq90kdmp+B0nxnb2OJCJS6zT1QvWo2BORqNS+fXvee+89XnjhBRYsWEDfvn2555571MpXS5ql/h+92k+nb8eF9G4/hzbpYyud505ERETqDxV7IhK1zIxTTjmFzMxMhg8fzhVXXMG+++7LggULvI4Ws3yWoCJvO4VCRYRCRdveUUREtpumXqgeFXsiEvXatm3L22+/zcsvv8zChQvp168fd999N4FAwOtoIhQHlvNz1kn8tLwnPy3vyc9ZJ1IcWOZ1LBGRmKQBWqpHxZ6I1AtmxkknncT8+fMZMWIEV111FYMHDyYzM9PraNKAhVwRC1YfTW7xdzgCOALkFn/P/NVHN+hWvo2FXzM/azSzVo5gSfY9lAY3eB1JRKRBUrEnIvVK69ateeONN5g4cSKLFy+mf//+3HHHHWrlE09kF3xM0OUDZeeFDBFyBWQXflitY4VcCYHgRlw971O0MudZfl77TzYWfUVB6QJW5jzF7FUjKA1mex1NROo5R8236u1oy56ZNTOzT8zs18jXplvZN93MlpvZIzt00mpQsSci9Y6Zcfzxx5OZmcmRRx7Jtddey6BBg5g7d67X0aSBKQ4sJeQKK6wPuQKKA0urdIyQK2HJhhv5aXlvZq3Yg9kr9mJD/uSajlongqEClm4ct9lr4iihNJjNqtxnPEwmIlJrrgI+c851Az6L3N+SW4Gv6iRVhIo9Eam3WrVqxeuvv85rr73G0qVLGTBgALfddhulpaVeR5MGIiVh98jk5pvzWQrJ8btV6RhLNtzAuvyJOFeEo5TS0BoWb7iMnKJvazpurSso/RnDX2G9o4Tsgi88SCQiscbVwrKDRgLPRW4/B/yjsp3MbADQGvh4x09ZdSr2RKTeO+6448jMzOSYY47h+uuvZ6+99mLOnDlex5IGoHHSASTGdcBI+GudEU+Cvx1Nkodu8/GBUA7r898m5Da/vi/kClm56eEaz1vb4nzNcFTepTohrnUdpxGRmONqbYCWFmY2o8xyTjVStXbOrYrcXk24oNuMmfmAe4HLd/g1qCYVeyISE1q2bMkrr7zCm2++yYoVKxg4cCC33HKLWvmkVpn52a3167RMOxG/ryl+XxNapJ3I7m3ewCxum48vDa7d4n6FpYtqOm6tS47vQkr87sDmz8lnybRLP9ObUCIi27bOOTewzPJk2Y1m9qmZzatkGVl2Pxe+6LqyxsJzgcnOueW1+Bwqte3/RCIi9cjRRx/NkCFDuOCCC7jxxht56623ePbZZ+nbt6/X0SRGxfnS6dzsFjo3u6Xaj030t8e5UKXbAqENBEP5+H2plW4vDWazPv89SoJZNEocSJPkIZhV7EJZ13Zr9QS/rBlLful8jDgcQbo0vZrGSXt7HU1EYoEHY1g554ZtaZuZZZlZW+fcKjNrC6ypZLe9gf3M7FwgDUgwszzn3Nau76sRatkTkZjTvHlzXn75Zd555x2ysrLYY489uPHGGykpKfE6mshmfL4kGiftW+k2I47sgsoHaskrnsmsFfuxdONdrMp5nEXrLmD+6uMJueLajFslCf4W9Gr7Bn3bfkiP1s+zR4cZtGl0itexRERqy3vA6ZHbpwPvlt/BOXeyc66Tc64L4a6cz9dFoQcq9kQkho0cOZLMzExOOukkbrnlFgYOHMhPP/3kdSyRzSTH717pekcppcG1Fdc7x69rzyfk8nGRa/1CroCC0vmsznm2NqNWS1J8Jxol9sXvqziAjYjI9oq2qReAu4CDzexXYFjkPmY20Mye2pEDm9mBZtY1crutmT1nZs+YWZuqHkPFnojEtGbNmvH888/z/vvvs379evbcc0+uvfZaiou9bwERAWiUvCc+S6mw3meJpCXtWWF9UeB3AqGKc9aFXBHr8t+ulYwiItHCuZpfdiyPW++cO8g51805N8w5tyGyfoZz7qxK9n/WOXd+FQ//GBCM3L4XiCc8seuTW3xEOSr2RKRBOOKII5g3bx6nnnoqd9xxBwMGDOCHH37wOpYI6Yn7kJrQB7Okv9b5LJm0xD1ISxhQYf/w1AaVvzupbNoDERGpt9o755ZaeCSv4cA5wL+AwVU9gIo9kRgTCiyleOO/KVhzIIXrTydY/J3XkaJG06ZNeeaZZ5g8eTIbN25k0KBBXH311RQVFW37wSK1xMzYtdVzdGx8FcnxPUiJz6BDk2vo1vIpzCp2L0qM60y8v2IPHp8l0zLthLqILCLiCUdUduOsTTlm1hoYAsx3zuVF1sdX9QAq9kRiSCiwmMJ1hxMofB0X/J1QyZcUbTid0oL3vI4WVQ477DAyMzMZM2YMd911F/379+e771QUi3d8lkDr9NH0bDuZjLaTaN3oVHxW+f9yM2PXlv/F72uCz1Ix4vFZMulJg2jdaFQdJxcRkVr0MPAD8BLwaGTdPsDPVT2Aij2Rei4UXEtJ/kuU5L9Acc6t4PL5u3s3QCElOTfiXHBLh2iQGjduzFNPPcWHH35IXl4egwcP5oorrqCwsNDraCLblJLQnf7tv6Vr8zvo2PRKdmv9Eru2nFCluf1EqioQyqUosEL/PyR6OMBZzS9Ryjl3N+FBX/Zxzr0aWb0CqHAt4Jbov4JIPVZS8CZFG68C80WuMC7CAF/5rl+uABdajfnbexEzqg0fPpx58+ZxxRVXcM899/Dee+/xzDPPMHhwlbvDi3jC50uiReqRXseQGBQMFbBw3VWsL/gUMx9+S2HnZjfRMu1wr6OJ7PCAKvXQYmCQmQ10zk0kXOxVmVr2ROqpUDArXOhRDK4QCF93Fu7PXv4vYQizxnWcsP5IT0/niSee4JNPPqG4uJh9992Xyy67jIKCAq+jiYjUuZ/XXsz6gk9xlBByRZSGNrBw/ZVsKvrR62giDYqZ9QIWAuOBCZHVQ4Cnq3oMFXsi9VSg6COg8q4Hm5d6ifiTDsN8aXWQqn4bNmwYc+fOZezYsdx333306dOHqVOneh1LRKTOlATWkF34NY6SzdaHXBHLNz3hUSqRMlwtLNHrceAG59xuQGlk3RRg36oeQMWeSD3lXIDK/0IZEAeWRrjQG0pik7vrNlw91qhRIx577DE+++wzAoEAQ4YM4eKLLyY/P9/raCIita44mIXPEirdVhRYWsdpRBq8DODFyG0H4JzLB5KregAVeyL1VHzSsC1sSSS5+RskNX+NlFbTSGr6X8yq/DdBIoYOHcrcuXM599xzefDBB+nTpw9fffWV17FERGpVSvxOOAKVbImjcdJedZ5HZHM1P+1ClE+98Aew2YSrZrYnsKiqB1CxJ1JP+eI6kZh+GZAE+An/OieTkHomcYn98cdnYP6W3oas59LS0njkkUf44osvcM4xZMgQLrjgAvLy8rb9YBGResjvS6VD43/h2+xDQh9+XwodGv/Ts1wiDdT1wCQzuxlIMLOrgdeB66p6AI3GKVKPJaaNJS5xKKWF/wOCxCcfhj++p9exYs4BBxzAnDlzuOaaa3jooYeYNGkSTz/9NAcccIDX0aSKluSv5v2V37C2KJu9mmdwUOv+JPor76om0tB1anwuyXGdWb7pCUpD62mctDedm1xEUlw7r6OJRPs1djXKOfc/MzsUOJvwtXqdgaOdc1UeLckqjtoXWwYOHOhmzJjhdQwRiRFTp07ljDPOYNGiRZx77rncfffdpKVp8JtoNnXtbO5e8BKloSAhQiT5EmiV1JSH+19MSlyS1/FERDxjZj865wZ6naOqErt2cG1vOb/Gj7vktKvr1etQHWrZExGphv3224/Zs2dz7bXX8uCDDzJ58mSeeuopDjroIK+jSSVKQwHu/flVikOlf60rCpWwunA97674mpM6b+naV5Hal1s8k8UbbiO/JJM4fxPap59D20ZjsPJzpYpIg2Rmt2xpm3PuhqocQ9fsiYhUU0pKCvfffz9Tp04lPj6eYcOGMXbsWHJycryOJuX8nreSUCV9fkpcgK/Wzqr7QCIR+SULyMw6hbySmThKKA2uYenGe1m6cZzX0USiW8OaeqFjuWUP4HJg56oeQMWeiMh22meffZg9ezaXX34548ePp1evXnz88cdex5IyUuKSCLlQ5dv86sIp3lm28SFCrmizdSFXyKrcZwmGNNWLiIBzbky55TDgaKh0yNxKqdgTEdkBycnJjBs3jmnTppGSksLw4cM5++yz2bRpk9fRBOiY0oo2Sc0xNu8Wl+RL4B8d9vMolQjkl86n8iYFP8WBlXUdR6QesVpY6pWPgX9UdWcVeyIiNWDQoEHMnDmTK6+8kqeffpqePXvy4Ycfeh1LgFt7nUmrxCYk+xNJ8SeS4ItjRLvB7Nuit9fRpAFLjtul0vWOAAlxbeo4jUg90oC6cZrZTuWWnsBtwLKqHkMDtIiI1JCkpCTuvvtujjnmGMaMGcNhhx3GmDFjuO+++2jSpInX8RqstskteH7QdczbtJjsklwyGnehRWITr2NJA9exyQXkZH27WVdOnyXRKvU44nyNPEwmIlFkEeFy9M/mxwJgJnB6VQ+glj0RkRq255578tNPP3HNNdfw/PPPk5GRwaRJk7yO1aD5zEfvJjszpFVfFXp1rKDkZ5Zl38ey7PsoKPnZ6zhRo1FiX3Zr+QRJcTsBhs9SadvoTLo2q9IAeyINVwNq2XPO+Zxz/shXn3MuzTm3X3Xm2VOxJyJSCxITE7n99tv57rvvaNasGUcccQSnn3462dnZXkcTqTPLNz5M5uqjWJnzKCtzHiNz9VEs3/iQ17GiRpPk/ejf/lMGdfqZvTrOoXPTyzDzex1LRGKIij0RkVo0YMAAZsyYwfXXX8/LL79MRkYG7733ntexRGpdYelvrMx5NNJNMQQECbkiVuY8RmHpb17Hiyo+i9fceiJV4QBnNb9EETNbZmZLt7VU9Xi6Zk9EpJYlJiZyyy23cNRRRzFmzBhGjhzJySefzIMPPkjz5s29jidSK7ILPsFVMu2FcyGyCz4huXGVp4kSEfmLi+JulzXklJo8mIo9EZE60q9fP77//nvuvPNObrvtNj799FMef/xxjjrqKK+jidQ4szgMq3A5jGGY6e2HiEhlnHNTavJ46sYpIlKHEhISuPHGG5kxYwZt27bl6KOP5qSTTmLdunVeRxOpUc1SDoXKuiaahbeJiGyPBjRAC4CZ9TWzC8zsZjO75c+lqo9XsSci4oE+ffrw/fffc+utt/Lmm2/So0cP3njjDa9jeWv+fDjnHGjWDBISoFcvePhhKCz0Oplsh8S4DnRpeiNmiZglhRcS6dL0RhLjOngdT0Qk6pnZOcA0YCjwb6AXcBlQ+USdlVCxJyLikfj4eK677jp+/PFHOnXqxHHHHcfxxx/PmjVrvI5W9z7+GIYMobRDa+ZNuY+vf/svq8ZdhPvwAxg2DPLyvE4o26FVo5Po224KnZteR+em19G3/RRaNTrJ61giUp/F+AAt5VwJHOqcOwoojHw9Fiit6gFU7ImIeKxXr15Mnz6dO+64g3fffZeMjAwmTpyIawBXoQOQkwOjRrHulQd49PhMPo57h29yX+fVzpN49eEMQrvsBNdc43VK2U4Jca1p3ehkWjc6mYS41l7HERGpT1o556ZGbofMzOec+wD4v6oeQMWeiEgUiIuL4+qrr+ann36ia9eunHjiiRx77LFkZWV5Ha32vfACbuhQXu/0ISWhQgKuGIBSV8Sq4l+Zd8UB8OKLkJvrbU4REfGcuZpfothyM+sSub0QGGlm+wElVT2Aij0RkSiSkZHBN998w913382kSZPo0aMHr7zySmy38n39NXmH7k1RsGJXzYAr5qeUmbDrrjB7tgfhREQkatTG4CzR/e/1P8Dukdu3AC8CnwM3V/UAKvZERKJMXFwcV155JTNnzqRbt26MGjWKo48+mtWrV3sdrXaYgQO3hf+4PnzhiZU06bSIiDQgzrlnI902iXxtCjR1zj1e1WOo2BMRiVK7774706ZNY9y4cXzwwQf06NGDF198MfZa+YYMIe1/X5Ea16TCpjhLpH9eX1i0CPr2retkIiISVWphcJYoHqDFzB4wsz3+vO+cK3HOVWvEMhV7IuWUBJaRnf8GOYWf4VyVBzsSqRV+v5/LL7+cWbNmsdtuu3HqqacycuRIVq5c6XW0mnPyydi0aRz/61ASfanEWxI+/MRbEp2SepJx+4cwejSkplJc+jsrNlzL72tOJGvT/QSCG7xOLyIiUlsMeNfMfo3Ms9e9ugeIq4VQIvWSc45VG29iQ96LmPkBH2ZJ7NRqIknx1f7dEqlRu+22G1OnTuXBBx/k2muvJSMjgwceeIDTTjsNq+/dG9PS4PXXaXrccZw/5jR+OzaD3MaOzvNKaP7wRMzng2efI69oGn+sG41zJUCQguIfWJ/3LN1af0B8XDuvn4WIiNSFGOvcsjXOuYvM7BLgIOAkYLqZ/Q685Jy7ryrHUMueSERO4UdsyH8FRzEhV0DI5REMreOPtafHXrc5qZf8fj+XXnopc+bMoWfPnowePZojjjiCFStWeB1txw0ZAt9+i78kyK7H3MiAvS6jxd3PYKecAh98gEtKYvmGy3CuEAgC4CgmGNrI6k33eJtdRETqTsMaoAXnXMg594lz7gygJ7AeGFfVx6vYE4nYkPc8zhVUWB8MZVNUOt+DRFXjXDHOhbyOIXWoW7duTJkyhQcffJAvvviCjIwMnn766fr/ocTOO8P998PSpZCdDd99B2eeCQkJBEJrCQQrm2w+SF7R53UeVUREpC6YWaqZnWJmkwhPvxAATq/q41XsiUSEXP4WthghV1inWaqioOhzlq7am8UrduKPlbuyfuPtOBfwOpbUEZ/Px4UXXsicOXPo06cPZ555JocddhjLli3zOlqt8FkKW/r41edrVLdhapBzjk0lBRQHdX2wiEiVNKCWPTN7HcgCzgH+B3R2zh3unHuxqsdQsScS0TjlH5glV7LFSE7oXed5tqaoeAZZ688iEPwDCOFcPjn5E1i38Tqvo0kd22WXXfjiiy945JFH+Prrr8nIyGD8+PH1v5WvHL8vjbSkA4H4zdabJdM87QxvQu2gH9Yv4pip4zjiyzsY9vnN3DhnIgWBYq9jiYhI9PgB6OGc298597hzbl11D6BiTySiWdpJJMV3j7QgAMRjlkSHZvfjswRPs5WXnXNf5NqlvzlXSF7+q4RCuR6lEq/4fD7OO+885syZw8CBAznnnHMYPnw4S5Ys8TpajerY/D6SE3phlozPGmEk0iTlHzRPq3JvlqjxW+5qLv/peVYWZlPqgpSGgnyRNY+rZ73kdTQRkejlaFBTLzjn/uOcW7ojx4iaYs/MDjWzX8xskZldVcn20Wa21sxmRZazvMgpsctnSezc6m3aN7uHJinH0qLRWXRr/TGNUw71OloFpYFFlW+weALBVXUbRqLGTjvtxKeffsrjjz/Ot99+S8+ePfnvf/8bM618fl8Tdmn9Hru0ep+OzR+me9updGg2DrOo+VdWZS//MZXS0ObdrktCAWZmL2ZlgaaTEBHZEnM1v8SyqPgPaeFx7h8FDgN6ACeZWY9Kdp3onOsbWZ6q05BSq0qD6ygOLPP8TalZPE1SjqRj8wdo2+RaEuN38jTPliTE9yQ89Up5AeL8Heo6jkQRn8/H2LFjmTt3LoMGDeJf//oXw4YNY/HixV5HqzFJCbuRnjysXk+3sCR/LaFKLhRJ8MWxqjDbg0QiIhKLoqLYA/YEFjnnfnfhCZReBUZ6nEnqQElwDQuyjmf2isHMW3Uws1fuTU7RNK9jRb2m6ZdhlrTZOiOZxmlj8flStvAoaUi6dOnCxx9/zJNPPskPP/xAr169ePTRRwmFNHJrNOjdpAvx5q+wviQUoGta679XzJsHd90FN98Mb70FpRrIRUQauAY0QEtN2KFiz8xOq6Ec7YGyQ8gtj6wr7xgzm2Nmb5hZx63kOsfMZpjZjLVr19ZQRKlpzjl+yRpFXvGPOEoIuSJKg6v5de1ZFJXG1rVGNS0xIYO2Ld4gMWEPjCT8/nY0a3w9TdOv9DqaRBEz4+yzz2bevHnss88+nH/++QwdOpTffvvN62gN3old9iHRH4+vTAt9ki+e/2s/kGaJabBhA4wYAYccQmjVKoKBUnjwQejSBT7+2LvgIiJSp8ysuZmdamZXRu63M7Mqd+OqUrFnZj0qWTKAf25n7u3xPtDFOdcb+AR4bks7OueedM4NdM4NbNmyZZ0FlOrJK/mJkuBK/pwg+U8hF2BNXpVHlG2wkhL7077Ve3TtsJjObX+kcaMxmEXvRcbinU6dOvHhhx8yYcIEZs6cSe/evXnooYfUyuehVkmNeXbv8zmgdQaN4pJpl9yUc3c9lMt2/z8IBGDECAI7deXOSQ+w/4jG7LOP49Q7juWPJx6AU04Jz0EoIiIxzcyGAL8AJwPXR1Z3Ax6v6jHiqrjfdOANKl4k1LmqJ9qGFUDZlroOkXV/cc6tL3P3KeA/NXRu8UhpcDWVf95QSnFghwYeEpFyzIwzzjiDQw45hHPOOYeLLrqIN954g6effppddtnF63gNUoeU5tzR9+SKG95/F4BLTu3HzLXzKIkM5PJL7ipOT1zPOzddS9NbboFJk+oyroiI1L0HgBOcc5+Z2Z8XdH9H+BK4KqlqN84FwBXOuTFlF2B2teJu2Q9ANzPramYJwInAe2V3MLO2Ze4eGckk9VhqQm+cq3j9iY9k0hP39iCRSOzr0KEDkyZN4plnnmHOnDn07t2bBx54gGAwuO0HS9144QXWjTmZWRuX/FXo/ak0FOD5vTvAtGmwrtrTLYmI1HsNbDTOLs65zyK3/0xaQtUb7LZe7JnZnwc6GNhYfrtzbkRVT7Q1zrkAcD7wEeEi7jXnXKaZ3WJmR0Z2u9DMMs1sNnAhMLomzi3eSYzrSLPUI/GVmcjciCfO34wWacd6mEwktpkZo0ePJjMzk6FDh3LJJZew//7788svv1Tp8SEXIK/kd4qDKjZqxdq1rGrdmHhfxf/lARfil9JsaNVKxZ6INEwNaJ49YL6ZDS+3bhgwt6oH2FZV+IGZHeWcy6l2tGpyzk0GJpdbd0OZ21cDV9d2DqlbXZvdTVpCX7LyniMUyqdpyqG0TT8Pvy/N62giMa99+/a8//77vPjii1x44YX07duX2267jYsvvhi/v+JIkQCr8j5kwfqbCblSnAvQJGkAfVrdS4K/Sd2Gj2Xt29Nx6TpKugcqbIr3+enrbwZZWdC6dSUPFhGRGHIZ8D8zmwQkm9kTwP9RjVkLttWNcxYwzcz+mszIzPY3s6nbEVakAjMfrRqdTK+2H9On/TQ6Nb2eeH8zr2OJNBhmxqmnnsr8+fM55JBDuPzyy9l33335+eefK+y7qXgu89ZdQ2loE0FXQIgSsot+YGbWuR4kj2FjxtDkqWc5oNmuJJZp3TOMRF88oz5fCIccAk2behhSRMQDtTHtQhR343TOTQd6A5nA08BiYE/n3A9VPcZWiz3n3BWER3uZZmYnmtknwGvAO9sbWkREok/btm155513eOmll1i4cCF9+/Zl3Lhxm13L98em5wi54s0e5wiQU/Iz+aV/1HHiGHbwwdCuHbfcO4kzWgygaUIqib54BrfoxsQVbUkbdx/ceKPXKUVEpJaZWSKw1jn3H+fcec65u4CsyPoqqcoALd8COcBLhOfC6+qcu3e7EouISNQyM0aNGkVmZiaHHXYYV155JYMHD2b+/PkAFAaWU9lHoD7iKQ6sqeO0Mczng7fewpeSwpiDRvPRk3OZ+uZq7j/5Tlre+zBMngw9e3qdUkTEGw2oZY/wdHMDyq0bQHickyrZ1gAtbwNfAm8CRwPDgaHViigi9UJuwXssyTqE31f2Z9X68ygNaGL7hqpNmza89dZbvPLKK/z222/069ePu+66i8Zxe2EkVNg/5IpplNDdg6QxLDkZJkyABQvg0EOhXz945hmYPRsGDvQ6nYiIZxrYaJy9CE+1UNb3QJ+qHmBbLXsLgZ2dc7c4594FDgUeMbPzqhVTRKLahpxHyMq+hJLSeQRDq8krfJelWcMpDSwP71BSAi++CEOHQrduMGgQPPww5NT62E0xwzlHMLCCUHCD11GqxMw48cQTmT9/Pv/3f//H1Vdfzakjnmf5Ih9WZmwvvyXTpfEZxPsbe5g2hrVpA6NHw9ixMHgwWFSPGiciIjVrE1B+NK7WQH5VD7Cta/b+7ZzbUOb+XGBf4OxqhBSRKBYKFbAh936cKyy7lpArYENupKAbOhTGj2fpKafwwb33seCCC3BTpsCAAbBELYDbUlo8jY1Ze7FxzRCyswayad3xhIL1o9tjq1ateOONN3jttddYumQFY0fMY9L4VsS79jRO6EXPFrexS9MLvI4pIiINRcPqxvkm8LKZ9TSzFDPrBTxPeAyVKqnqpOp/cc6tAPar7uNEJDqVBBZhVDbMfoDC4m/h3HMJdu/O6eeex+E5eVzx+2JOWLeB4YcfQf6YMXDsseCi+y+ll4KBJeRsGE0otBIoAkoIlHxPzvoTcfXodTvuuOPIzMzk6KOP5qE7P+PyY9eTsv5a2qQdhqm1SUREpDZcS3gO8u+BXGA68AtwTVUPUO1iD8A5l7s9jxOR6BPnb4NzpZVuS1zXAiZN4rHjjueHVaspDAQoDATILy1lycaNXNx9N8jNhWnT6jh1/VGU/xy48vOlBQgGlxMonelJpu3VsmVLXn31Vd58801WrFjBwIEDufnmmykpKfE6moiINBRR1rJnZs3M7BMz+zXytdJ5ccysk5l9bGYLzGy+mXXZ1rGdc0XOufOAVKANkOacO985V1TVfNtV7IlI7IjztyIl6QCMzUfxNUum+Y99YdgwXvp9McWBzQuWQCjEV0uWEjj6aPioyoNCNTjBwB9AZcW0j1BwZR2nqRlHH3008+fP57jjjuOmm25izz33ZNasWV7HEhGRGFcbg7PUwAAtVwGfOee6AZ9F7lfmeWCcc253YE+gStdzmFljYA/Cg7UcaGZDzazKA2aq2BMR2jR7lNTk4RgJmCXj8zWjVZN7SLAukJhISSi4xccGk5IgUL7lSv4UnzgYSK64wZUSF1/lwbSiTvPmzXnppZd45513yMrKYo899uDGG29UK5+IiDQ0I4HnIrefA/5Rfgcz6wHEOec+AXDO5TnnCrZ1YDMbDawE3gcmlFmeqmo4FXsigs+XQtvm/6Vruzl0bv0lO7WdTXrqUeEh3j//nEM6dyauzHVZ8b4AR3b7iccOfRkmP0B+72Kc23JB2JAlppyAz9cUiC+zNpmE5CPxx3X0KtZ2CYUK2JDzKEuzDmX52uPILZjEkUceSWZmJieddBK33HILAwcO5Mcff/Q6qoiIxCpnNb9ACzObUWY5pxqJWjvnVkVur6bi6JkAuwIbzewtM5tpZuPMrLIBE8q7HTjWOdfaOde1zLJTVcPFbXsXEWko/L50/L70v1f06AHdu3Pd/Ey+atyUnOIiikpLuevAN9m56SqaTc3Dt3QTqwa/S+qGXNo2H+9d+Cjl8zWiccsPKMx9gJKiDzFfGokpo0lKPdXraNUSckUsW3MEpYE/cIQvFSgqmUlRyQxaNruR559/nuOPP55//vOf7LXXXvz73//mhhtuIDExcRtHlprmXJDSwB/4fGnE+St7zyEiIuWsc85tcRJTM/uU8DVz5V1b9o5zzplV2jE0jvAAl/2ApcBEYDThVrqtiQM+3sY+W6WWPRHZugkTSHvkEab8PJ/bd+3GhXsF6WGrafvkRlpfvInVjzbF+QvJL/qcopI5XqeNSj5/c1Kb3ErTNj/QpNUXJKedjln9+vObW/AOpcGlfxV6AM4VsCnvWUoD4WsPjzjiCObNm8epp57KHXfcwYABA/jhhx+8itwg5RV+ym8r+/JH1nB+X7kXS7P+QaCeTPMhIlIlHgzQ4pwb5pzrWcnyLpBlZm0BIl8r+6O7HJjlnPvdORcA3gH6V+HZ3g1cZzvwpqF+vdsQkbq3007w3XfEmzHy5JM5f8QN7DJ4GQm/BljxejOK9kgAwq0JhcXfeRxWakt+4WdUenmBxVNU8ndB17RpU5555hkmT57Mxo0bGTRoEFdffTVFRVUeOEy2U3HpQlau/yfB0HqcK8BRQmHJjyxfe1K9muZDRKSeeQ84PXL7dODdSvb5AWhiZi0j94cC86tw7EuA64BcM1tadqlqOBV7IrJt7drB/ffD2rVsmn83v2d2Iuv+JpTs+vd1aGbxxPlbeBhSalO8vy1UOh8j+H0Vv++HHXYYmZmZjBkzhrvuuov+/fvz3Xf6MKA2ZedOwLnyA+QEKQksobh0rieZRERqWhSOxnkXcLCZ/QoMi9zHzAaa2VMALjywweXAZ2Y2FzCgKte+nBI55uHAqeWWKlGxJyJV5/fTqO3JkFDxcl8jjtSk4R6EkrrQOO1UzBLKrTX8vnSSE/eu/DGNG/PUU0/x4Ycfkpuby+DBg7nyyispLCys/cANUGlwGVBxoCTDTyC4quIDRETqoyibZ885t945d5Bzrluku+eGyPoZzrmzyuz3iXOut3Oul3NutKv46Vxlx56ypaWq+VTsiUi1xPlb0L7Fi/h9LTFLxSyFOH9HOrR8HZ8vxet4UksS4rvRuunD+CwdszTMUoiP25n2LV/f5vWHw4cPJzMzk7POOotx48bRr18/vv322zpK3nCkJu6PWVKF9c4Vk5RQf6f5EBFpqMws0cxuN7PfzWxTZN0hZnZ+VY+hYk9Eqi05cRBd286kY8t36NhqEl3aTCcxoafXsaSWNUo5nJ3azaFDy9fo1OoDOreeQkJc1yo9Nj09nSeeeIKPP/6YwsJC9tlnHy677DIKCrY5zZBUUeO0Ufh9zYC/W2DNkmmcdgpx/soGkRMRqWeic1L12nQ/0BM4mb/bIDOBf1X1ACr2RGS7mPlITMggMb47VmYOPoltZgkkJfQlIb7bdn3fDz74YObNm8c///lP7rvvPvr27cu0adNqIWnD4/el07n1RzRNG0O8vwuJ8b1o3fQuWjW51etoIiKyfY4CRjnnvgVCAM65FUD7qh5AxZ6IiNSpRo0a8fjjj/PZZ59RWlrKfvvtxyWXXKJWvhoQ529Oq6Y3slO7b+jS5iMapx6nD2NEJLZE2TV7tayEcvOiR0b0XF/VA6jYExERTwwdOpS5c+dy7rnn8sADD9C7d2+++uorr2OJiEg0a1jF3uvAc2bWFf6ax+8R4NWqHkDFnoiIeCYtLY1HHnmEL774AuccQ4YM4cILLyQ/P9/raCIiIl67BlgMzAWaAL8CK4Gbq3oAFXsiIuK5Aw44gDlz5nDhhRfy8MMP06tXL7744guvY4mISJRpSAO0OOdKnHOXOOfSgNZAo8j9bU7b8CcVeyIiEhVSU1N58MEH+eqrr/D7/QwdOpTzzjuPvLw8r6OJiIjUOTPb6c8FaAR0LXO/SlTsiYhIVNlvv/2YPXs2l1xyCY8//ji9evXis88+8zqWiIhIXVtEuOvmojLLr5GlSlTsiYhI1ElJSeG+++5j6tSpJCQkMGzYMMaOHUtOTo7X0URExEsNaIAW55zPOeePfPUB7YAngVOregwVeyIiErX22WcfZs2axeWXX8748ePp2bMnH3/8sdexRERE6pxzbjVwMXBnVR+jYk+kgQuGcsna9DALV4/g9zWnkFOo7nISXZKTkxk3bhzTpk0jNTWV4cOHc/bZZ7Np0yavo4mISF2qhcFZonmAli3oDqRUdWcVeyINWDBUwK+rjyAr50EKS+aQWzSFP9b9i9Ub79/q44pLf6egZDahqg8GVe85V8qm3CdYvno/lq/aiw2b7iAUyvU6VoMyaNAgZs6cyb///W+efvppevbsyQcffOB1LBERkVphZlPN7KsyywzgO+C+qh5DxZ5IA7Yh71VKAqtwrvivdc4VsibnUQLBDRX2Lwms4NfVh/Br1nAWrzmBBSv6kJ3/Th0m9s6a9WeyMeduAoFFBIJLycl9glVrRlCN0Y+lBiQlJXHXXXfx7bffkp6ezuGHH84ZZ5zBxo0bvY4mIiJ1oQFdswc8BUwos9wF9HbOqRuniGxbTtFnOAorrDdLoKBk5mbrnHMsXjuKotJfcK6QkMsj5HJZkX0FhSWZdRXZE8Ulcykq/hrnyr5WJQSCK8kvnORZroZszz335KeffuKaa67h+eefJyMjg0mT9L0QEZHY4Zx7rtzyhnOuyiNxAsTVVjgRiX7x/jaEP/MJldsSIs7XbLM1hSWzCQRXAcHN1jtXzPrcp+nQ/N7ajOqpkpKZlX7y51w+RcXTSUs5qu5DCYmJidx+++0cffTRjB49miOOOILTTjuNBx54gKZNm3odT0REakN0t8TtMDO7pSr7OeduqMp+atkTacBaNBqNWWK5tT7i/a1ITui72dpAaB3gr+QoIUqDq2opYXTw+9uCVfbcE4nzd6rzPLK5AQMGMGPGDK677jpeeuklMjIyeO+997yOJSIiNcxoEAO0dKzC0qGqB1OxJ9KApST0okPTO/FZKj5LwyyZpPhu7NTqZcys3L79Kr0+zUimUfJBVTqfc46C4pnkFH5EaTCrRp5DXUhOOhCfpVH+T6ZZHI1Sj/cmlGwmMTGRW2+9le+//56WLVsycuRITjnlFNavX+91NBERker40Tk3xjk3Brj9z9vlljOqejAVeyINXLO0Y8joMIudWr3Erm0m0b3tpyTEVfzAKM7fnBaNxmKW/Nc6I5H4uNY0TT1xm+cpDazi19UHsnjtCSxbfzG/rNybldk341z0faRWnlkcbVq9S0J8byABsyTi/F1o0+I1/P6WXseTMvr3788PP/zAjTfeyMSJE8nIyOCdd97xOpaIiNSU2B+g5fYyt3/a0YPpmj2ROuBckDW5r5KV9wIhV0jzlBG0bTyWOF+619EA8FkSqYn9t7lfmyZXkJLYm3W5TxMMbSQ9+VBaNDoTvy91m49dsv5sigOLKXvNX3b+S6Qk9qVJysgdiV8n4uM60a71BwSCa8CV4Pe3r9D6KdEhISGBm266iX/84x+MGTOGo446ipNOOomHHnqIFi1aeB1PRERka343s3uBTCDezCptxXPOPV2Vg6nYE6kDv627lOzCTwhFRnNclTOBDQUf0qvtZHy+JI/TVU968nDSk4dX6zElgRUUlSyg/OAuIVfAutwJ9aLY+1Ocv5XXEaSK+vbty/fff8+dd97JbbfdxmeffcZjjz3GMccc43U0ERHZHtF5jV1NOwG4EjgJiAdOrWQfB1Sp2FM3TpFaVlj6GxsKP/6r0ANwlFASzGJ9wfseJqs7oVAuZpV/thQM5dRxGmlI4uPjueGGG5gxYwYdOnTg2GOP5YQTTmDt2rVeRxMRke0R4904nXMLnXNnOecOBqY45w6sZBla1eOp2JOoUxrcyIaCz8gp+hHnyk8JUP/kFc/CKvlVC7kCNhV960GiupcYvwtmCRXWGwk0Tj7Mg0TS0PTu3Zvp06dz++238/bbb9OjRw9ee+01r2OJiIhskXPurxHwzMxXdqnqMVTsSVRZsekJZizfm1/XXcL8NaP5acUQCksXex1rhyT42xAeLHhzRgKJlQyEEovM4ujQ7F7Mkvhz+gYjiTh/a1qm/9PbcNJgxMfHc8011zBz5ky6dOnCCSecwLHHHktWVv0ZGVZEpMGL8Za9ssysv5l9a2b5QGlkCUS+VomKPYkamwq/Ydmmh3AUE3R5hFw+xcGVzF8zpl6M2Lgl6UmDiPM1ofwcdWZ+WqVtexTLWJGefAi7tJ5Es9RRNEoaSpvGV9GtzSf4fU28jlbrQqF8NuU9z5oNF5Cd8yCBoLoQeikjI4Nvv/2Wu+66i/fff5+MjAxeeeWVev13RkREYtJzwBfAQGCnyNI18rVKVOxJ1FiV+8Jm17WFOUqD68gvmedJpppg5qdHm4mkJmRglojPkknwt6V7q6dJjGvndbw6lRTfnfbN7qRLy+dpkX4Wfl+a15FqXSC4lmVZ+7Fh083kFbzBxpz7WbZ6MMUlc72O1qDFxcXx73//m5kzZ7LLLrswatQojj76aFavXu11NBER2YoGMKl6WZ2Ba51zC5xzS8ouVT2Aij2JGoHQxkrXGz6Cody6DVPDEuPa07Ptu/RtN4VebSfTt/000pMGeR1L6sCGTXcQDK7FuQIAHMU4l8fa7Es8TiYAPXr0YNq0aYwbN44PPviAHj168OKLL6qVT0QkWjWgbpzA28AhO3IAFXsSNZqlDMdnFachcARJS+zjQaKalxDXmqT4LrU2P1sglMPyjfcyd+UwMlcfybq8N/Sm1WMFRR8R7l6/uZLSXwiGNtV9IKnA7/dz+eWXM3v2bHbbbTdOPfVURo4cycqVK72OJiIiDVsS8LaZfWxmz5ddqnoAFXsSNVqnnUBSXGd8lgxA2k8l7HLFBgb8owj/AYfBvffChg0ep4xeoVAR81ePZHXOkxQFFlFQMocl2dezZMM1Xkdr0IzELW4x4us0i2xd9+7dmTp1Kvfddx+ffPIJGRkZPPfcc/rApJ4LuWJy8t8ia8O1bMgZTzCY7XUkEdletdGqF91/4ucDdwPTgN/KLVWiSdUlavh9yfRq8zZr894k/so7SJ+0joIzTiOzfz8a+YN0nfkVvnvugfffh4EDvY4bddblv01pcDWO4r/WhVwh6/Lfom3jc0mM6+hhuoarUerJbMp9FEdRmbVxJCftj8+X4lkuqZzf7+eSSy7hiCOO4IwzzmD06NG89tprPPnkk7Rv397reFJNwdBGlmSNIBBcg3P5mCWxPudeOrZ6i6SEHl7HExHZKufczTt6DBV7ElX8viTavJIHPyQx8dSHeO4/HxOfMAWHIzU9lYevu40WRx4Jv/wCjRp5HXeb1udPZnXOU5SGNtA4aQjtG59HQlyrWjlXTtHUSga4CU97kFf8k4o9jzRNv4Dikp8oKplOeAoOI87fjlZNH/A4mWxNt27dmDJlCo888ghXXXUVPXr04P7772fMmDG11g1bat66TfdSGlgBlADgXBGOIlZvuJAubT71NpyIbJcoH1Blh5nZ/s65ryK3tzh5unPu86ocT8WeRJdQCO69l5/PvZYXr/+E0uJSSovDU4kU5RVxyX0/8fzgwdiLL8K//uVx2K1bvvEhVuX8968CbE3ey2womETvdh8S729R4+dLiOtA+Fe64vVh8f7aKTBl28wSadvyZYpLMikpnUdcXEeSEvZWwVAP+Hw+LrzwQg4//HDOPPNMzjzzTF577TXGjx9Px461/+FJyBWSX/ghgWAWSQkDSUoYoJ+basoteJ8/C72yikt/JRjcgN/frO5DiYhs3WNAz8jtCVvYx1HF6Rd0zZ5El99+g+JiXvlyNUX5xZttcg42rc1h5Z5D4X//8yhg1QRCOazMeaxcS1uAYCiX1TnP1Mo5W6WdjM/KXwPmI87XlEaJe9XKOaXqEhMyaJR6AsmJg/WGvZ7ZZZdd+OKLL3j44YeZOnUqGRkZPPXUU7V6LV9x6UIWr9qDrOwrWbfpTlasO5GV607GuSrPoyuEezZseaN/y9tEJHrF+DV7zrmeZW533cKiefakniouhtRU8jYWVLrZfEYhfiip+EltNCko+RkfCRXWO0rYVPR1rZwzKb4zu7T4L3G+5vgsBbNEUuJ7sFvrVzHTr7rIjvD5fJx//vnMnTuXgQMHcvbZZzN8+HCWLl1aK+dbtf5sQqFsnMsHSnGugMKS79iY92ytnC9WNU49EaP8KM9+khMH4Pc19iSTiOyYBjbP3g7TO0CJLjvtBFlZHHLwLiSmVCyWQsEQXVYthL596z5bNST4W+Go7BN4IzGuQ62dt3HyEPq2/54ebd6lV9vPyGj7v1o9n0hDs9NOO/Hpp5/y+OOP8+2335KRkcETTzxRo618pYGlBALLKP9xs3OF5OS/UmPnaQiapZ9PUmJ/zFIwEvFZGnH+NrRt9rDX0URE6oSKPYkuKSlw8skM+30KHXdtR1JqeNh6n99HYnICl9/0f8S9+Dz8858eB926pPgupCT0rDC0vs+SaJt+Vq2e28xPcnw3FXkitcTn8zF27Fjmzp3LXnvtxdixYzn44IP5448/auT4jhBsoauvq+SaXNkynyXRseXrdGw5kZZNrqdt80fZqe23xMdpZFWReivGu3HWNBV7En1uuQX/jB94pNdarrj2UAaP3IPDRg9h/C37MeTRq+Gaa2CXXbxOuU3dW46nUdJeGAn4LAW/rzFdm91FWmI/r6OJSA3o0qULn3zyCU888QTff/89PXv25PHHHycUCu3QceP9nfH7WlZYbySRnnLsDh27ITIzkhMH0LTRGaQlH7z16/hERGKMxfpksQMHDnQzZszwOoZU16ZNcMcd8MwzkJAAeXnQsydccQWMHOl1umopDa4lEMohKa6z3mSIxKilS5dy9tln8/HHH3PAAQcwYcIEdtqpytfPV1BUMovla48HgjhXiFkqCXG70qHVG/gsueaCi0iDZmY/OufqzeTFya07ul1OvrTGjzvv/kvr1etQHSr2JLqVlEBWFiQnQ4uan65ARKSmOOd4+umnufTSSwkEAtx9992ce+65+Hzb14kmGMomt+AdAoFVJCfuSUrSgZhGkBSRGlTfir2UWir25sZwsRc13TjN7FAz+8XMFpnZVZVsTzSziZHt35lZFw9iSl1LSICOHVXoiUjUMzPOPPNM5s2bx/77788FF1zAgQceyKJFi7breH5fU5qkjaFFk2tITR6mQk9ERKotKoo9C/8HexQ4DOgBnGRmPcrtdiaQ7ZzbBbgfuLtuU0ptKAqsILtwKkWBFV5HERGpER07dmTy5Mk888wzzJ49m969e/Pggw/u8LV8IiKCBmippqgo9oA9gUXOud+dcyXAq0D5C7NGAs9Fbr8BHGSambjeCrli5q85jxkrDmHBmguZseIQ5q85j5Ar3vaDRUSinJkxevRoMjMzGTp0KBdffDH7778/Cxcu9DqaiIg0INFS7LUHlpW5vzyyrtJ9nHMBYBPQvLKDmdk5ZjbDzGasXbu2FuLKjvoj+36yC6bgXDFBl4tzxWQXfMkf2fd5HS1mhUJFrMp5msxVR7Mg61Q2FHxco3OD/cm5UK0cV6Q+at++Pe+//z7PP/88mZmZ9OnTh3vvvZdgMOh1NBGRekmTqldPtBR7Nco596RzbqBzbmDLlhWHrxbvrc59lRBFm60LUczq3IkeJYptIVdM5upjWb5xHHklM8kp+prf1l3M0uzba+wcRaW/83PWKGYs24Ufl3Xn93WXEQjl1Njxpe6FQjkEg+u8jlHvmRmnnnoq8+fP55BDDuHyyy9n33335eeff/Y6mohI/aNunNUSLcXeCqBjmfsdIusq3cfC49c3BtbXSTqpcUFXUK31smM25E+mKLCYkPu7wA65QrJyX6Q4sJKi0iWsynmKVTkTKA4sr/bxA8GNzM86itzib4EQjhI2FLzPL1knq5WvHgoE17Bq7Qn8sbInS1YNYNnq/SgqmeV1rHqvbdu2vPPOO7z00kssXLiQvn37Mm7cOLXyiYhIrYmWYu8HoJuZdTWzBOBE4L1y+7wHnB65fSzwudO7yHorfQsTi29pveyYjYVfEKqkkDaLY1n2f5izajjLsv/Dsuz/MHvlMFbnvFCt46/Nfy1yveXfv5KOEooCv5FfMnNH40sdci7EqrVHU1j8DVAKlFAaWMSqtccSCK72Ol69Z2aMGjWKzMxMDj/8cK688koGDx7M/PnzvY4mIlI/qGWvWqKi2Itcg3c+8BGwAHjNOZdpZreY2ZGR3SYAzc1sEXApUGF6Bqk/dm5+E35LxYgHwIjHZyns3OxGj5PVvmCokHX5k8nKnUhR6bJtP6AGxPtbARUndHcuxIaCyThXjKMURwnOFbN04+0UV2OE1IKSBThXVOm2otLftje2eKCoZHqkqAtstt65UnLzX/ImVAxq06YNb775Jq+++iq//fYb/fr148477yQQCGz7wSIiIlUUFcUegHNusnNuV+fczs652yPrbnDOvRe5XeScO845t4tzbk/n3O/eJpYdkZawO/3bT6Zto1GkJw6kbaNRDGg3mbTE8jNuxJbc4lnMWD6I39b/m8XZtzBz1SH8kX1XrXd1bNXoJHxWvtgzzHy4yj7ScpBd8HGVj5+akIHPkivZ4kiK37VaWcVbgS124y2hRIV7jTIzTjjhBObPn8+RRx7JNddcw9577828efO8jiYiEp1qYXAWDdAiUkuS4tqzc/Pr6dP2VXZufj1J8R28jlSrnAuwYM2ZBF0uQZdPyBXiXDGrc19kU9HXtXru5Pid2an5ffgtDb+l4bMUEuM60SrthC3nrUa/hhZpx0WKvb//pBiJpMT3IDWh945ElzqWmNAHqHgNmVkKSYmD6j5QA9CqVStef/11XnvtNZYsWUL//v257bbbKC0t9TqaiIjUcyr2ROpITvEMnKv45i3kCsjKq/1RSJunHkb/jj/SvfVzZLR5gz7tvqBVo1FYhRY/wKBZyiFVPnYwlE+npreQnrgvRgI+S6VF2vHs2up5NB1m/ZIQ353kxCGYJZVZG4/P15RGKcd4lqshOO6448jMzOToo4/m+uuvZ6+99mLOnDlexxIRiS66Zq9aVOyJ1JGtTRgfDBXWSQafJdAosT8pCbtjZiTH70z7xhdglgjEY8RjlkjHJv8mMW7bLa3BUCG/rDmL2SuHsnj9NWwq+p4WaafQv8M8ujS7Fb8vtfaflPx/e3ceH0V9/3H89dlkc3MECOEQRLwTbhARKp4ogheKVvEsWrV41KsqFhUP6oFarVqqluItKgJKxWJRFEVQ+CFHAmoRuc8YAgkh535/fyS2CBvIkt1Msnk/H495sDs7O/POzs4un/3OfL9hl978RZo2upXYmHbE+NJolHwxB7X8Fz7tz4hLS0tj4sSJvPvuu6xfv56ePXty//33U1JS4nU0EZE6QadxhibIT/oiEgmN44/BBTk9zmdJpKWc40GiCm2bjKBZ0sD/XqPXLOkMEvwHV+u5q3LvYXvRFzhXTDkVxezWgokkxHagVePLI5ZZIsvMT2rjG0ltfKPXURqs8847j/79+/P73/+e0aNHM2XKFF566SW6devmdTQREalH1LInUktifEkc2uxRfJbAz7+z+CyJRvG9aJE0qNbz7N4pTKK/I22aXEebJtdVu9ALuGJ+2jkNt0eLZcDtYlP+38OaVaQhatGiBa+//jpTp05l8+bNHHPMMdx3331q5RORhk2ncYZExZ5ILUpLOZOurafTtvE1pKdcwpFpz5DR8h/Br5urroICmDIFXnoJvvgC9tOzZ07BVL5Z14+v13Rk4bo+bMl/54A2GwjsoqpPyLLy7Qe0ThHZ2znnnEN2djYXX3wxDzzwAL169WLhwoVexxIRkXpAxZ5ILUv0d+Dg1Ns5tPmDpCaehNkBHoaBANx/P7RvD3/7G3zyCVx7LWRkVNwOIqdgGj/mjqSkfAMApeWbWb3tPrbkvx3y5mN8TfDHpAd5xGiccGzI6xORqjVr1oxXXnmFadOmkZOTQ+/evRk1ahTFxVVfCywiEo3q2jV7ZtbMzP5tZv+p/De1iuUeM7NsM1tuZn+xWurBTsWeSH116624jz5i9tjXGJ58JuetzWDkiXey8ZZRcNFFMHv2Xk9Zt30sgT0GPw+4Xazb/mTImzczDmk+pvK01J8/SvzEWArtUu86gD9IRPbnzDPPJDs7m8suu4wxY8bQs2dPFixY4HUsEZHaEYlTOGt+GuddwMfOucOBjyvv/4KZ9QX6AV2ATsAxwAk13nI1qNgTqY9WrIDXX2fSRXfz+EuLWL82l50FxSz8+keue3U1W+59GP7wh72eVly2IejqSss341wg5BhNE/uT0epdmiefRVJcJ9IbXUznNh+S6O8Y8rpEpHpSU1OZMGECH3zwAXl5efTp04eRI0dSVFS0/yeLiEi4nQO8XHn7ZeDcIMs4IAGIAyq6QIfNtRFOxZ5IffTSS5RdchmvvbOY4qJfjt1XXFzG39emwKZNkJX1i8eqGk4hLqbVAZ9OmhyXwWEtnqJz62l0aHY/8bFtD2g9IsGUleewZdvdrNzQk1Wb+pOX/9IB/TARjQYNGkRWVhZXXHEFjzzyCD169OCrr77yOpaISGRFpmWvhZkt2G26JoRE6c65jZW3NwF7XePinJsLzAI2Vk4znHPLQ9jGAVOxJ1IfrV3L9rYdgg5Y7pzj2283wdFHw9q1v3isXdM7Kk+7/B+fJXJQ071bAUW8Vh7YwZrNp7F95+uUBzZSWraCnB0PsnnbbV5HqzOaNm3K+PHj+fDDD8nPz6dv377ceeedauUTEQlNjnOu127TC7s/aGYzzSwryPSLsbNcRVfne50YamaHAUcDBwFtgZPN7PgI/j3/pWJPpD5q3pxG23MoK9t73D6Atm1TYc0aaN78l09LHkTH5o8TH3sw4CMu5iAOafYwaSnn1UJokdDs2PkmAZcH/K/12rldFBROpbRsbZXPa4gGDhxIVlYWV111FY899hjdu3dn7ty5XscSEQkrw5sOWpxzpzrnOgWZ3gM2m1lrgMp/twRZxRBgnnOuwDlXAHwIHBe2F2YfVOyJ1EeXXELca68w4LQM4uN/OWxDfIKfq3smQnk59Oq111ObJw+mW9tPOfbgH+h+0Oe08HBAd5F9KSz+EueCtFCZn6KSJbUfqI5r0qQJL7zwAh999BGFhYX069eP22+/nV27dnkdTUQkfOpeBy3vA1dU3r4CeC/IMmuAE8ws1sz8VHTOotM4RaQKPXtCt27cuPwdBp/ZmfgEP7GxPlqkNeLe33bn0IfuqBiWwadD3EvOOcoDO3GuzOsoYVVSupKc7Y+zJe9+Covm4fYztuOBios9BAg2BmUAf2ybiGwzGgwYMICsrCyuvfZannjiCbp27coXX3zhdSwRkWj1CDDAzP4DnFp5HzPrZWZ/r1xmEvADsBRYDCx2zk2rjXAWqS/puqJXr15O3VJLVCoshOHDYdYsAhddRGlqC+Kyl2AffwyPPALXhHJtcR0QCMDHH8M330BcHAwcCEcd5XWqA5Zf9DnrckdSUrYeI4ZmKRfSJvU+fBbvdbQa2V7wFpvzRlYWsOWYJZKSOJDWzZ4Jeg1pTZSUrWLN5lNwbveWqVjiYg+jffrHYd9eNPrkk0+46qqrWL16Nb///e8ZM2YMSUlJXscSkTrCzP7PObf3aUB1VHJaO3f0ObeEfb3/N/62evU6hEI/+4vUU4FEPznjL+XH9waSl5KNL381NmAArFpV/wq9r7+uKOxuvx23eTPuu+/gxBNh8GD46acar764bD1b8l9ja8HblJXn1Xh9+1NYksWPW6+ipGw1UIajmNyCd1j7U/i/oGpTeSCPzdtGVp5aWQY4nCukYNe/KCz6LOzbi4vtQJvmrxAb0xar7LE6Mf442qa9pUKvmk4++WSWLl3KiBEjeOqpp+jSpQuzg4zBKSIi0SnY+TEiUscFXAlZm4ZRWPotgdaFbLwmBp9toGOzM2mZ0tjreKFZtgzOPJPNY8YyeksCi77bgD82hkH3n8Vt2TPwDxwIX3wB8QfWIrZx+19Zv/1pMMPwsWbbvXRs/hdSk04L8x/yP1u2P7fXtWaOIrYXfkRp+Rb8MS0jtu1I2lk0Gyx2r+sbnCtkR+EUkhNPDPs2kxL60aHV15SVb8DnSyLGlxr2bUS7lJQUnn32WYYOHcrw4cM54YQTuOGGG3j44YdJSUnxOp6ISPWF5xq7BkUteyL10JaCyRSWLifgCivnlBNwRazMHUV5oJ51xjBmDIU33MSwBQV88+16As5RXFrGB1/9hxvTjoOUFHj33QNadWFJNht2/AVHMc4VEXCFFa/TTzdRFtgR5j/kf4rLVhDs28gsjtKy9RHbbjDlgXxy8l9mfe5Ifsp/nfLAzgNel+EneHuaYRE8PdXM8Me2VaFXQyeeeCJLly7lxhtv5Nlnn6VLly7MmjXL61giIiHxojfO+kzFnkg9lLNzGgG3d1FnxJBfvNCDRAeosBDef5/JhxxDSWnZL8qjktJylq/awoYLLoGXXz6g1efsnErAlQR5JIbtuz45oHVWR1JcdyBmr/nOlRDnPyRi291TcdkqvtvYj015D5G781U2br+f7zceT2nZhgNaX3LCCbigRWwCTZIvqGlcqQXJycn85S9/4bPPPiMmJoaTTz6Z66+/noKCAq+jiYhIBKjYE6mHYnzBT71yBIjx1aPOF/LyICWFpbnFlJTuPWagz+djdVIz2LTpgFbvXAnBz/dwOFcaZH54tGw8Yq/B680Sad7oMmJ9TSO23T2tzx1JeSAPR8UPA84VUhb4iQ15ow9ofT5fEm1bvIhZImbJFf8ST7OU60iMPyaMySXS+vfvz+LFi7nlllsYN24cnTt35uOPP/Y6lojI/tW9oRfqNBV7IvVQq0aX4LPEvebH+lJIievqQaIDlJoKBQV0a5ZAnH/vlrBAIECHwlxoc2Dd7DdLGrxX0QXgXDlNInB92c/i/R04LH0KKQkn4LMk/DFtad3kLto0vSdi29yTcwF2Fs8BAns8Uk7+rgP/T31ywokc2uYb0lP/RFrTe+nQ+jNaNP1DjbKKN5KSknjyySf5/PPP8fv9nHrqqVx33XXs2BG5U5xFRKR2qdgTqYdSE/vTutFwjHh8lkyMJRPra8bRLf+BWT06rBMTYcgQzl0xl/i4WHbvYDHOH0Nmx1a0futVuPLKA1p9SvwxNE8eUlkYGxCLWQLtUv+IPyYtHH9BlRLjjubQlq/Rud13ZLSdR1rj4bW8bwwLciopgFnN+uaK8TWmSfIFpKZcQVxs+xqtS7zXr18/Fi9ezO23386LL75I586d+fe//+11LBGRoHTNXmjq0f8KRWR3B6feRo+2szi0+UMckfYMvQ6aS3Lc0V7HAiC/eCE/5j7Aj7kPUVC8ZN8L//GPJI57jold4zk282BiY3wkJfg5r++R/GX9Z1BcDEOGHFAOM+Pg1DEc2fI1WjX6LW0ajyCz1T9Jb3T5Aa2vPjEzGieeAfh/OZ84miYd2Osp0SsxMZGxY8cyZ84ckpKSOO2007jmmmvYvn2719FERKQGNKi6SBXyi5fwY+5jFJRkEx+bTvumN5KWPNjrWHXej7kPsbngTQKuCDB8Fkebxr+lfdN9jDG3cCFcfnnFwOoDBsDOnfDee3D88TB+fMXpnhKysvJtrNxyPqXl63GuHDMf8bGHckjLt4nxNfI6ntRRRUVFjB49mrFjx9KmTRtefPFFBg4c6HUsEYmAejeoeot2LnNw+Mesnf+KBlUXaVDyi7NYsmkY24vnUe7yKSxdwfc5d7F+xyv7fW55oIh128fzzYZzWLzx12wpmIpze143FZ12lixjc8EblT2FOiBAwBWxYccL7Cr9seon9ugBS5fC3/4GhxwC3bvDvHkwebIKvRqIjUnl8FYzObjFP2idei8dWrzCoenTVejJPiUkJPDII48wd+5cGjVqxBlnnMFVV11FXl6e19FEpKGLwCmc0X4apwZVFwli9bYnKlum/ifgdrF6259p3ehifOYP+ryAK2XJpospLP3Pf59fULKMbbu+5Mi0xyKe22s/Fc4MOtSBc45tuz4h0X9V1U82g/79KyYJGzMfKQn9SKGf11GknunduzcLFy7kgQce4NFHH2XGjBm88MILDBo0yOtoIiJSTWrZEwmioGRZ0PmOUkrLf6ryeT8VzqSw9IdfFIoBt4ucwukUlvwQ9px1jc/ignYKYubDLM6DROHjnGNr/ttkbRzI4vX9WJ17L6XlOV7HEomohIQE/vSnP/HVV1+RmprK4MGDufLKK9m2bZvX0USkodLQCyFRsScSRHxs2yof29c4aXm75hBwhUEf2148v6ax6rwWSYMxC9YDpKN5Uv2+5mfNttGsybuPXaXfUlK+ni0Fb5K9aTBlAXVgIdGvV69eLFiwgFGjRvHaa6+RmZnJtGnTvI4lIiL7oWJPJIiDm9601/hsPkugVaOLifHtPW7bz+Ji0zH2bsEyYoiLaRH2nHVNgr8dh6SOrhwSIqlyiuew5mOJi/BQB5FUUraZrQUTK69F/FkpZYHtbM1/w7NcIrUpPj6eBx98kK+//pq0tDTOPvtsLrvsMnJzc72OJiINhKFr9kKlYk8kiGZJJ3JY8zH4fS0w/PgskdaNLqNj6p37fF6rlPODtGwZPosnNbFhXIuW3uhCeh30BR2bjaZjswfo2XYuLZLP9DpWjRSWZgU9DdW5InYUzYn49kvLt7A1/zW25r9CSdnGiG9PZF969OjB/Pnzue+++5g4cSIZGRlMnTrV61gi0lA4F/4piqnYE6lCeso5HNvuS45t9yXHtV9Ix2Z37ncw6vjYNmS0HEesL5UYS8ZniSTEtqdzq9fx1fNr1kLhj2lOy5ShtEw5D39MU6/j1FhcTCugLMgjMcT7D47otn8qeIes9f1Yl/cg6/IeIntDf7bs+EdEtymyP3FxcYwePZr58+fTunVrhgwZwrBhw8jJ0XWsIiJ1iYo9kX0w8+GPSa2y981gUhN/RZ928+jS6g26t55Cr7YzSY47PIIpJdIS/RkkxHZkzw6MfRZHeqPfRGy7JWWbWJN7N45inNuFc0U4ilm//RGK9jWUhUgt6datG19//TUPPPAAkyZNIjMzk3fffdfrWCISxXQaZ2hU7IlEgFkMKfGZJMUdhpl5HUdqyMw4ouXLNIrvjRGHzxLx+1pyaIu/kug/LGLb3b7ro4ohKfbgXBnbCj+I2HZFQuH3+7nnnntYsGABBx10EEOHDuXXv/41W7du9TqaiEiDp2JPRKQa/DEtOCr9Dbq2nUtm6xl0bTuPpoknRXSbjrIqriVw4IKdVirinS5dujBv3jzGjBnDlClTyMjI4J133vE6lohEk0gMu6CWPRER+Zk/pjkJse0xi/zHZ5PEARVdj+3BzE/Tej6UhUQnv9/P3XffzcKFC+nQoQMXXnghQ4cOZfPmzV5HE5EoYYHwT9FMxZ5EpUCgmG27ZpNb+BnlgaL9P0GkDoqPbUfrJrdhlgDEADGYJdCy0dUkxh3ldTyRKnXq1Im5c+fy8MMPM23aNDIzM5k4cSIuynu9ExGpa/bdtaBIPbRt12yWb7lptzkBjkp7mmZJkT3lTiQSWjW+jiaJJ7Nt5wdAGU2TBpEUl+l1LJH9io2N5a677uLss89m+PDhXHzxxbz11luMGzeOVq1aeR1PROor/WYUErXsSVQpLc9l2ZbrKXcFu02FLN96IyXl6hJc6qdE/xG0aXoLbZr+QYWe1DsZGRnMmTOHsWPH8uGHH5KZmcnrr7+uVj4RkVqgYk+iSs7OfxHsJx/nHFt3hr/3wvJAET/mPs68tX2Yu6YX3+fcTUn5T2HfjohIfRYTE8Ptt9/OokWLOPLII7n00ks555xz2LBhg9fRRKSe0dALoVGxJ1GlzBUQCNJLoaOU8kB+WLflnCNr829Yv2MCpeU5lAXy2FIwmUUbz9N1giIiQRx11FF8/vnnPPHEE/z73/8mMzOTV155Ra18IiIRomJPokpqwq/w2d6XovosntTE48O6rfzibygoycZR/N95jjJKy7eRUzg9rNsSEYkWMTEx3HrrrSxevJhOnTpxxRVXcOaZZ7J+/Xqvo4lIXeeoGJIo3FMUU7EnUSUlPoO05LPxWeJ/5/ksieZJp5ES1yWs2yooWQ5u7/56A66Q/OLFYd2WiEi0OeKII/jss894+umnmTVrFpmZmUyYMEGtfCKyTzqNMzQq9iTqHN58DEen/YUWSQNpnnQ6R6U9yZEtHscsyIBlNZDob4dZzF7zfZZAYuwhYd2WiEg08vl83HTTTSxZsoSuXbsyfPhwBg0axNq1a72OJiISFVTsSdQxM5olncTRLZ8lo+VzNE86NeyFHkDThH74Y5pTMf7Zf7eOWRwtU4aEfXsiItHqsMMOY9asWTzzzDPMnj2bTp06MX78eLXyicjeXASmKKZiT+QAmcXQtdVEmib0xYjFiCUlrhNdW03EH9PE63giIvWKz+fjhhtuYOnSpfTo0YOrr76agQMHsmbNGq+jiYjUWyr2RGogLrYlnVtN4Lj239Cn/QK6t5lCctwRXscSEam3OnbsyMcff8xf//pX5syZQ6dOnXj++efVyiciGLpmL1Qq9kTCIMaXSKwvxesYIiJRwefz8bvf/Y6srCyOOeYYrrvuOgYMGMCqVau8jiYiXopET5xR/kOSij0RERGpkzp06MDMmTN5/vnn+eqrr+jUqRPjxo0jENi7J2QREdmbij1pMAKumIAr9TqGiIiEwMy45ppryMrKom/fvowYMYJTTjmFlStXeh1NRDyg0zhDo2JPol5h6UoWb/w1c1Z35svVnVm2ZQSl5blexxIRkRAcfPDBzJgxg7///e8sXLiQzp0788wzz6iVT0RkH1TsSVQrLd/O4o0XsKN4IRDAUUZu4Scs2TQMF2RAdBERqbvMjKuuuoqsrCz69+/PTTfdxEknncSKFSu8jiYitUVDL4RExZ5EtS0FUwi4YnY/kh1lFJdtZHvRV94FExGRA9auXTumT5/OhAkTWLx4MV26dOHpp59WK59IA6DTOEOjYk+i2s7S/xBwRXvNdwTYVbaq9gOJiEhYmBlXXnkl2dnZnHzyydx8883079+f77//3utoIiJ1hoo9iWqN4jrjs8SgjyX7j6zlNCIiEm5t27Zl2rRpvPzyy2RnZ9O1a1eeeOIJysvLvY4mIuHmgIAL/xTFVOxJVGuZcjaxvkZAzH/nGXEkxx1No/ju3gUTEZGwMTMuv/xysrOzOe2007j99tv51a9+xbfffut1NBERT6nYk6gW40uiW+sppCUPwmdJxPqa0LrRMDqnv4SZeR1PRETCqE2bNkydOpXXX3+d77//nm7dujF27Fi18olEE3XQEhLPiz0za2Zm/zaz/1T+m1rFcuVmtqhyer+2c0r9FR+bzlFpf6bfwUs4rv3/cWjzUcT4kryOVaeUlOewbdeX7Cpd7XUUEZEaMTOGDRtGdnY2Z5xxBnfccQd9+/Zl2bJlXkcTEal1nhd7wF3Ax865w4GPK+8Hs8s5161yOrv24olEL+cCrMi5j6/X9mf5lutZuGEwSzddTlmgwOtoIiI10qpVKyZPnsybb77JDz/8QPfu3XnkkUcoKyvzOpqI1IB64wxNXSj2zgFerrz9MnCud1FEGpYN+a+xeedkHCWUu3wCrojtRQtYkTPK62giIjVmZlx00UVkZ2dz1llnMXLkSI477jiysrK8jiYiB8q58E9RrC4Ue+nOuY2VtzcB6VUsl2BmC8xsnpmdu68Vmtk1lcsu2Lp1azizikSVDTsmEHC7fjHPUUJO4QzKA7uqeJaISP2Snp7OpEmTePvtt1m1ahU9e/ZkzJgxlJaWeh1NRCSiaqXYM7OZZpYVZDpn9+Wcc/u6TPJg51wvYBjwlJkdWtX2nHMvOOd6Oed6paWlhe8PEYkyZYH8Kh/bswiUyAi4UnIL/8W6vKfIKZhKwBV7HUkkal1wwQUsW7aMc889l1GjRtGnTx+WLFnidSwRCYFO4wxNrRR7zrlTnXOdgkzvAZvNrDVA5b9bqljH+sp/VwKfAuo3X6SGmib0JdjHQFxsOrG+oH0lRZ0t+e/yf+tPYO7qo1m88Wy2F82ttW2XleexdMPp/JBzO+u3P82PuX9k0brjKS5bV2sZRBqatLQ03nrrLSZNmsS6devo1asXDz74oFr5RCQq1YXTON8Hrqi8fQXw3p4LmFmqmcVX3m4B9APUrZZIDXVIvZ1YXwqGv3JODD5L5PDmYxrE0BQbdrzEym33Uly2FkcxO0uyWL7lKnYUfV0r21+z7WGKy9YRcDsBCLhCSgO5rPypqn6qRCRczj//fLKzsxk6dCj33nsvvXv3ZtGiRV7HEpF9icSwC2rZi7hHgAFm9h/g1Mr7mFkvM/t75TJHAwvMbDEwC3jEOadiT6SGEv3t6dnmX7RtfCWN4nuQnjKEbq3fJTWxn9fRIs65MtbmPbXX6aoBV8TqvMdrJUNu4Yc49mxNKGdH0TwCrqRWMog0ZC1atOCNN95gypQpbNy4kWOOOYbRo0dTUqLjT6QuMsCcC/sUzWK9DuCc+wk4Jcj8BcDVlbe/BDrXcjSRBiEutiWHNLvT6xi1rjSQR4Dg18cVln5fy2lExEvnnnsu/fv35/e//z33338/U6ZMYcKECfTo0cPraCIiNVIXWvZERGpdrK8JVsXvXQmx7WslQ7PkM3c7hfZnPpok/AqfxdVKBhGp0KxZM1599VXef/99tm7dSu/evbnnnnsoLlanSSJ1SiACUxRTsSciDZLP/LRp/Ft8lrjH/ATaN72lVjK0T72LBH8HfJYM+PBZMnEx6RzS/OFa2b6I7O2ss84iOzubSy+9lIceeoiePXuyYMECr2OJiBwQFXsi0mC1a3IjBzW5nhhrDPiIi2nNYc0fJzXxpFrZfqyvMZ1bf8hhLf7CQU1vo2PzR+na9lPiY1vXyvZFJLjU1FReeukl/vnPf7Jt2zb69OnDyJEjKSoq8jqaSIOna/ZC4/k1eyIiXjEzDmoygraNf4ejBCOu1nshNYshNelkUjm5VrcrIvs3ePBgsrOzue2223jkkUd47733mDBhAscee6zX0UQapgbQe2a4qWVPRBo8M8Nn8Q1iuAkRCU3Tpk0ZP348H374Ifn5+fTt25c777xTrXwiAoCZXWBm2WYWMLNe+1huoJl9Z2YrzKzWxlhSsSciIiKyHwMHDiQrK4urrrqKxx57jO7duzN37lyvY4k0MA5cBKaayQLOA2ZXtYCZxQDPAWcAGcDFZpZR0w1Xh4o9ERERkWpo0qQJL7zwAjNmzKCwsJB+/fpx++23s2vXrv0/WUSiknNuuXPuu/0s1htY4Zxb6ZwrASYC50Q+nYo9EZHIWrsWHngALrsMbrgBZs8Ox6+IIuKh0047jaVLl3LttdfyxBNP0K1bN+bMmeN1LJEGwVz4J6CFmS3YbbomzLHbAmt3u7+ucl7EqdgTEYkE5+Chh6BbN8o3b2Frjz7satkKrrsOTjwRcnO9TigiNdC4cWPGjRvHzJkzKSkp4fjjj+eWW26hsLDQ62giEroc51yv3aYXdn/QzGaaWVaQqVZa52pCxZ6ISCS88AJMnMj0597i9IIjufibcs74LoW7rxxDaecuMGSIWvhEosApp5zC0qVLGTFiBE899RRdunRh9uwqL90RkZry4Jo959ypzrlOQab3qpl6PdBut/sHVc6LOBV7IiLhVl4OY8awZOSfePyDbAp3lVBYVEpJaTlfLl7Nfe1Phi1b4PPPvU4qImGQkpLCs88+y6xZswgEApxwwgncdNNN7Ny50+toItHFgQXCP9WC+cDhZnaImcUBFwHv18aGVeyJiITbV19Baip/+76QouKyXzxUUlrOnEWr2XXxJfD22x4FFJFIOPHEE1m6dCk33XQTzzzzDF26dOHTTz/1OpaIRJCZDTGzdcBxwAdmNqNyfhszmw7gnCsDbgBmAMuBt51z2bWRT8WeiEi47dgB6els+akg6MP+WB87U5pWLCciUSU5OZmnn36a2bNn4/P5OOmkk7j++uspKAj+eSAiIapjQy8456Y45w5yzsU759Kdc6dXzt/gnBu023LTnXNHOOcOdc6NqeGrUG0q9kTqgLJAPuu2j2fZlhtYte3PFJdt8jqS1MShh8KSJfQ8Ih2fL8hA7Wak/rC8YjkRiUrHH388ixcv5pZbbmHcuHF07tyZTz75xOtYItLAqNgT8Vhx2SYWrBvA6rw/81Phv1i3/UUWrD+N/OKlXkeTA3X44XD00fyubBVJCXG/KPgS4mO5ZeDRxLz5Jgwf7mFIEYm0pKQknnzyST7//HP8fj+nnHIKv/vd78jPz/c6mkj95SIwRTEVeyIe+3HbWEoD2wi4IgAcJQRcId/n3OVxMqmRP/+Zpo88yNtdHWf2O4I2LZvQ7ei2PHVGRwaPuRluuQXatdvvauqLQKCIHUXzKChehHO1c7W7SH3Rr18/Fi9ezG233cbzzz9Pp06dmDlzptexROolcy7sUzSL9TqASEO3bdenQPle83eV/kBZIJ9YX6NazyRh0K0bfPQRTW+9lbuWLYPOnSt64MzLg7vvhmvCPV6rd3IK3ufH3JEYPhyOWF9jjmz5D5LijvI6mkidkZiYyOOPP87555/Pb37zGwYMGMBvf/tbxo4dS5MmTbyOJyJRSsWeiMd8lgBsD/KIYfhrO46EU7du8MknsGIF/PADNG4MvXtDTIzXycJmV+kKfsy9878t0wAl5TtZvvlSuh80F5/pPSyyu+OOO45vvvmG0aNH8/jjj/Phhx/y4osvMnDgQK+jidQPUd4SF246jVPEY60aXVRZ8P2PEUuzxBOI8SVU8SypVw47DE4/HY47LqoKPYAt+RMJuNK95gdcETuKvvQgkUjdl5iYyKOPPsqXX35Jo0aNOOOMMxg+fDh5eXleRxORKKNiT8Rj7ZpcS9OEX+GzBGIsGZ8lkeQ/gsNbPOx1NJH9Ki3PIdhpyABl5dtqN4xIPXPssceycOFCRo4cySuvvEKnTp2YPn2617FE6i4HBCIwRTEVeyIe81kcmel/o3vrqRzWfAydW71C9zbv4Y9J9TqayH6lJp2Cz5L2mu9cGY0SjvUgkUj9kpCQwJ/+9CfmzZtHamoqgwcP5sorr2TbNv1YIrInI/yds0R7By0q9kTqiKS4w2iZciaN47thFmRsNpE6KDVpIEn+I/FZ4n/n+SyJVo1/Q3xsaw+TidQvvXr1YsGCBYwaNYrXXnuNzMxMpk2b5nUsEannVOyJiMgB85mfo1u9SfvUUTSK70PTxFM5PO1Z2qfe6XU0kXonPj6eBx98kK+//pq0tDTOPvtsLrvsMnJzc72OJlJ3OBf+KYqp2BMRkRrxWTzpjYaR0epNjmz5Ik0TT/I6kki91qNHD+bPn899993HxIkTyczMZOrUqV7HEpF6SMWeiIiISB0TFxfH6NGjmT9/Punp6QwZMoRhw4aRk5PjdTQRb6llLyQq9kRERETqqG7dujF//nzuv/9+Jk2aRGZmJpMnT/Y6lojUEyr2REREROowv9/Pvffey4IFCzjooIM4//zz+fWvf83WrVu9jiZSuzT0QshU7ImIiIjUA126dGHevHk89NBDTJkyhYyMDN555x2vY4nUKg29EBoVeyIiIiL1hN/v549//CMLFy6kQ4cOXHjhhQwdOpTNmzd7HU1E6iAVeyIiIiL1TKdOnZg7dy4PP/ww06ZNIzMzkzfffBMX5a0UIuqgJTQq9iQkzpXxU+G/WbXtz2zKn0R5oNDrSCIiIg1SbGwsd911F9988w2HHnoow4YN47zzzmPTpk1eRxOROkLFnlRbWSCfhRvO5rutt7F2+3P8kPsAX687gcLSlV5HExERabAyMjKYM2cOjz76KB9++CEZGRm8/vrrauWTKBSBVr0oP05U7Em1rcn7C7tKV1HuKlrzAq6QskAe3239g8fJREREGrbY2FjuuOMOFi1axJFHHsmll17Kueeey8aNG72OJhI+DhV7IVKxJ9W2Zec0HCV7zHXsLFlGWfkOTzKJiIjI/xx11FF88cUXPPHEE3z00UdkZGTw6quvqpVPpIFSsSfVZvt6u5jVXhARERGpUkxMDLfeeiuLFy8mMzOTyy+/nLPOOov169d7HU2k5jTOXkhU7Em1tUw+ByNuj7k+GsV3IdbXyJNMIiIiEtwRRxzBZ599xp///Gc++eQTMjMzmTBhglr5RBoQFXtSbe2b3khy3JH4LAmIwWfJ+H3NOKLFWK+jiYiISBAxMTHcfPPNLFmyhC5dujB8+HAGDRrE2rVrvY4mckA0qHpoVOxJtcX4kujW+l0yWv6VDqm3ckSLP9G73Wck+tt7HU1ERET24bDDDuPTTz/lmWeeYfbs2XTq1Inx48erlU/qH3XQEhIVexISMx+pib+iXZNrSUsejM/ivY4kIiIi1eDz+bjhhhtYunQpPXr04Oqrr+b0009nzZo1XkcTkQhRsSciIiLSgHTs2JGPP/6Y5557ji+//JLMzEyef/55tfJJ3eeAgAv/FMVU7ImIiIg0MD6fjxEjRrB06VJ69+7Nddddx4ABA1i1apXX0UQkjFTsiYiIiDRQhxxyCDNnzuT555/nq6++olOnTowbN45AIMr7o5d6KgLX60V5i7aKPREREZEGzMy45ppryMrKom/fvowYMYJTTjmFlStXeh1NRGpIxZ6IiIiIcPDBBzNjxgxefPFFFi5cSOfOnXn22WfVyid1i1r2QqJiT0RERESAila+q6++mqysLPr378+NN97ISSedxIoVK7yOJlJBxV5IVOyJiIiIyC+0a9eO6dOnM2HCBBYvXkyXLl14+umn1conUs+o2BMRERGRvZgZV155JdnZ2Zx88sncfPPN9O/fn++//97raNJQaeiFkKnYExEREZEqtW3blmnTpvHyyy+TnZ1N165defLJJykvL/c6mojsh4o9EREREdknM+Pyyy8nOzubAQMGcNttt3H88cfz3XffeR1NGhQHLhD+KYqp2BMRERGRamnTpg3vvfcer732Gt9++y1du3Zl7NixauWT2qMOWkKiYk9EREREqs3MuOSSS1i2bBlnnHEGd9xxB/369WP58uVeRxORPajYExEREZGQtWrVismTJ/PGG2+wYsUKunfvzqOPPkpZWZnX0SRaqYOWkKnYExEREZEDYmZcfPHFZGdnM3jwYO666y769u1LVlaW19FEBBV7IiIiIlJD6enpTJo0ibfeeosff/yRnj17MmbMGEpLS72OJtFG1+yFRMWeiIiIiNSYmXHhhReybNkyzj33XEaNGkWfPn1YsmSJ19EkmqjYC4nnxZ6ZXWBm2WYWMLNe+1huoJl9Z2YrzOyu2swoIiIiItWTlpbGW2+9xaRJk1i3bh29evXiwQcfVCufiAc8L/aALOA8YHZVC5hZDPAccAaQAVxsZhm1E09EREREQnX++eeTnZ3N0KFDuffee+nduzeLFi3yOpbUaxFo1VPLXmQ555Y75/Y3ImdvYIVzbqVzrgSYCJwT+XQiIiIicqBatGjBG2+8weTJk9m4cSPHHHMMo0ePpqSkxOtoIg2C58VeNbUF1u52f13lvKDM7BozW2BmC7Zu3RrxcCIiIiJStSFDhpCdnc1FF13E/fffz6xZs7yOJPWRAwKB8E9RrFaKPTObaWZZQaaItM45515wzvVyzvVKS0uLxCZEREREJATNmzfn1VdfZf78+Zx++ulexxFpEGJrYyPOuVNruIr1QLvd7h9UOU9ERERE6pFevarsj09k/6L8Grtwq5ViLwzmA4eb2SFUFHkXAcO8jSQiIiIiIrVKxV5IPL9mz8yGmNk64DjgAzObUTm/jZlNB3DOlQE3ADOA5cDbzrlsrzKLiIiIiIjUdZ637DnnpgBTgszfAAza7f50YHotRpMwKQ8UsnXnPykoWUaS/whappxNrC/F61giIiIiUq84CKhlLxSeF3sS3YrLNrJo4/mUBQoIuEJ8lsiavKfo1vpdEvzt9r8CERERERE5IJ6fxinR7YfchygpzyHgCgEIuF2UBvL4z0/3epxMREREROoVB84Fwj5FM7XsSUTl7voU2PMgCpBXNAfnApjp9wYRERERqSadxhkS/U9bIsqIqWK+D7DaDSMiIiIiEkZmdoGZZZtZwMyCjitiZu3MbJaZLatc9ve1lU/FnkRUWvKZGP5fzDP8tEg6HTMVeyIiIiISAufCP9VMFnAeMHsfy5QBtznnMoA+wPVmllHTDVeHTuOUiOrYbCQFJVnsKl0FrhyzWOJjW3No89FeRxMRERERqRHn3HJgn40YzrmNwMbK2/lmthxoCyyLdD4VexJRsb5GdG/9HtuLvqKw9D8k+jvSNOE4XasnIiIiIqFxDgIR6VClhZkt2O3+C865FyKxITPrAHQHvorE+vekYk8izsxomtiHpol9vI4iIiIiIvVZzU+7DCbHORf0ejsAM5sJtAry0B+dc+9VdyNmlgK8C9zsnNsReszQqdgTERERERGpgnPu1Jquw8z8VBR6rzvnJtc8VfWo2BMRERERkXrBReY0zoiyigv6xgPLnXNP1ua2deGUiIiIiIjIATCzIWa2DjgO+MDMZlTOb2Nm0ysX6wdcBpxsZosqp0G1kU8teyIiIiIiUg+EZaiEsHLOTQGmBJm/ARhUefsLPBpgWi17IiIiIiIiUUgteyIiIiIiUvc5IFC3WvbqOhV7IiIiIiJSP7j610GLl3Qap4iIiIiISBRSy56IiIiIiNR5DnA6jTMkatkTERERERGJQmrZExERERGRus85XbMXIhV7IiIiIiJSL+g0ztDoNE4REREREZEopJY9ERERERGpH3QaZ0jUsiciIiIiIhKFzLnoPu/VzLYCqz2M0ALI8XD7on1QV2g/eE/7wHvaB97TPvCe9kHd0AJIds6leR2kuszsX1TkDrcc59zACKzXc1Ff7HnNzBY453p5naMh0z6oG7QfvKd94D3tA+9pH3hP+6Bu0H5oGHQap4iIiIiISBRSsSciIiIiIhKFVOxF3gteBxDtgzpC+8F72gfe0z7wnvaB97QP6gbthwZA1+yJiIiIiIhEIbXsiYiIiIiIRCEVeyIiIiIiIlFIxZ6IiIiIiEgUUrEXZmZ2g5ktMLNiM3upGsvfYmabzGyHmf3DzOJrIWZUM7NmZjbFzHaa2WozG7aPZUebWamZFew2dazNvNGiuq+7VXjUzH6qnB41M6vtvNEohH2g932EhPIdoM//yKjuPjCzK82sfI/j4MRaCxrFzCzezMZXfg7lm9kiMztjH8vrWAizUPaBjoXopmIv/DYADwH/2N+CZnY6cBdwCnAw0BG4P6LpGobngBIgHbgEGGdmmftY/i3nXMpu08paSRl9qvu6XwOcC3QFugBnAdfWUsZoF8p7X+/7yKjWd4A+/yOq2t/DwNw9joNPIxutwYgF1gInAE2AUcDbZtZhzwV1LERMtfdBJR0LUUrFXpg55yY756YCP1Vj8SuA8c65bOfcNuBB4MoIxot6ZpYMnA/c45wrcM59AbwPXOZtsugW4ut+BfCEc26dc2498AR639eY3vt1QwjfAfr8j5AQv4clApxzO51zo51zq5xzAefcP4EfgZ5BFtexEAEh7gOJYir2vJUJLN7t/mIg3cyae5QnGhwBlDnnvt9t3mIqXuuqnGVmuWaWbWa/i2y8qBXK6x7sfb+v/SPVE+p7X+97b+nzv27obmY5Zva9md1jZrFeB4pGZpZOxWdUdpCHdSzUgv3sA9CxELW0I72VAmzf7f7PtxuhXyQPVAqwY49526l4TYN5m4pBRTcDxwLvmlmec+7NyEWMSqG87sHe9ylmZk4Df9ZEKPtA73vv6fPfe7OBTsBqKgqOt4Ay4GEvQ0UbM/MDrwMvO+e+DbKIjoUIq8Y+0LEQxdSyFwIz+9TMXBXTFwewygKg8W73f76dX/O00aka+2DP15TK+0FfU+fcMufcBudcuXPuS+BpYGhk/4qoFMrrHux9X6BCr8aqvQ/0vq8T9PnvMefcSufcj5WnuC0FHkDHQViZmQ94lYpriW+oYjEdCxFUnX2gYyG6qdgLgXPuROecVTH96gBWmU1FJxU/6wpsds7pl6wqVGMffA/Emtnhuz2tK1WftrDXJgD1DBm6UF73YO/76u4fqVpN3vt639c+ff7XPToOwqiyl+XxVHQYdb5zrrSKRXUsREgI+2BPOhaiiIq9MDOzWDNLAGKAGDNL2Md5z68AV5lZhpk1paKnpJdqJ2l0cs7tBCYDD5hZspn1A86h4letvZjZOWaWahV6AzcB79Ve4ugQ4uv+CnCrmbU1szbAbeh9X2Oh7AO97yMnhO8Aff5HSHX3gZmdUXkdE2Z2FHAPOg7CaRxwNHCWc27XPpbTsRA51doHOhainHNOUxgnYDQVv4jsPo2ufKw9FacrtN9t+VupuG5mBzABiPf6b6jvE9AMmArsBNYAw3Z77HgqThn8+f6bVFwTUAB8C9zkdf76OlX1ugd5zQ14DMitnB4DzOv80TCFsA/0vo/cPgj6HaDP/7q3D4DHK1//ncBKKk5d83udPxomKoZQcEBR5Wv+83SJjoW6tw90LET3ZJU7WURERERERKKITuMUERERERGJQir2REREREREopCKPRERERERkSikYk9ERERERCQKqdgTERERERGJQir2REREREREopCKPRERERERkSikYk9ERCLCzB4zs6m73R9rZh+bWZyHsURERBoMDaouIiIRYWbNgZXAicCxwPXAr5xz273MJSIi0lCo2BMRkYgxs9HAeUATKgq9tZXzHwX6AquA4c65Uq8yioiIRCudxikiIpH0DdAZGLlbodcVaOucOx74FhjqYT4REZGopWJPREQiwsw6A+OAl4Hhuz3UF/io8va/gH61HE1ERKRBULEnIiJhZ2ZtgWnAdcAIoLOZnVj5cCqwo/L2dqBZbecTERFpCFTsiYhIWJlZY2A68KRz7n3nXCEwFhhTuUge0LjydhMgt9ZDioiINADqoEVERGqVmXUDbnXOXW5mdwM/Oufe9DiWiIhI1FHLnoiI1Crn3CJgs5l9DmQC73qbSEREJDqpZU9ERERERCQKqWVPREREREQkCqnYExERERERiUIq9kRERERERKKQij0REREREZEopGJPREREREQkCqnYExERERERiUIq9kRERERERKKQij0REREREZEo9P94PVwhF9490QAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index 51d7fab8d..98b516c9b 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -178,7 +178,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "93a2375c77b8416faafe2a0f6cc50f47", + "model_id": "70d232738d66467ea8e5955b62a3f557", "version_major": 2, "version_minor": 0 }, @@ -237,7 +237,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -268,7 +268,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -345,7 +345,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a1bbb2086dd54478b09ace458fd73e62", + "model_id": "1ae41116adb044cda7a7bf447621902a", "version_major": 2, "version_minor": 0 }, @@ -359,7 +359,21 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "99f8e4b9ba75452e84d0d6acddd519e1", + "model_id": "7fe6346a4d184823b53e8ab6abc9fdab", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "MVP: 0%| | 0/547 [00:00" ] @@ -465,8 +479,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average influence of corrupted points: -0.03877732371354803\n", - "Average influence of other points: 0.031097713459676678\n" + "Average influence of corrupted points: -0.038253907\n", + "Average influence of other points: 0.030877113\n" ] } ], @@ -506,7 +520,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8d1b0dc5afa54ff688dc2d87551b74fc", + "model_id": "70dddd078acb4d96b077c07a2c5dfe19", "version_major": 2, "version_minor": 0 }, @@ -520,7 +534,21 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5524f3d894ab4a70bbb6c3c6877ecbb1", + "model_id": "58448c5a30374b789e08b8b9f0f36200", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "MVP: 0%| | 0/547 [00:00" ] @@ -564,7 +592,7 @@ } ], "source": [ - "mean_feature_influences = np.mean(feature_influences, axis=(0, 1))\n", + "mean_feature_influences = np.mean(feature_influences.numpy(), axis=(0, 1))\n", "\n", "_, ax = plt.subplots()\n", "ax.plot(feature_names, mean_feature_influences)\n", @@ -600,13 +628,15 @@ "source": [ "cg_train_influences = compute_influences(\n", " TorchTwiceDifferentiable(nn_model, F.cross_entropy),\n", - " *train_data,\n", - " *test_data,\n", + " torch.as_tensor(train_data[0]),\n", + " torch.as_tensor(train_data[1]),\n", + " torch.as_tensor(test_data[0]),\n", + " torch.as_tensor(test_data[1]),\n", " influence_type=\"up\",\n", " inversion_method=\"cg\",\n", " hessian_regularization=0.1,\n", ")\n", - "mean_cg_train_influences = np.mean(cg_train_influences, axis=0)" + "mean_cg_train_influences = np.mean(cg_train_influences.numpy(), axis=0)" ] }, { @@ -627,7 +657,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Percentage error of cg over direct method:0.000655835626812189 %\n" + "Percentage error of cg over direct method:0.0006940939783817157 %\n" ] } ], diff --git a/notebooks/support/common.py b/notebooks/support/common.py index 2219fc310..a941d3470 100644 --- a/notebooks/support/common.py +++ b/notebooks/support/common.py @@ -1,6 +1,5 @@ import logging import os -from collections import namedtuple from copy import deepcopy from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple @@ -13,8 +12,9 @@ from pydvl.utils import Dataset +from .types import Losses + logger = logging.getLogger(__name__) -Losses = namedtuple("Losses", "training val") def plot_gaussian_blobs( @@ -426,7 +426,7 @@ def plot_losses(losses: Losses): """ _, ax = plt.subplots() ax.plot(losses.training, label="Train") - ax.plot(losses.val, label="Val") + ax.plot(losses.validation, label="Val") ax.set_ylabel("Loss") ax.set_xlabel("Train epoch") ax.legend() diff --git a/notebooks/support/torch.py b/notebooks/support/torch.py index 1c4851bec..66d4aba8d 100644 --- a/notebooks/support/torch.py +++ b/notebooks/support/torch.py @@ -2,7 +2,7 @@ import os import pickle as pkl from pathlib import Path -from typing import Callable, List, Optional, Tuple, Union +from typing import Callable, List, Optional, Tuple import numpy as np import pandas as pd @@ -13,6 +13,7 @@ from torch.utils.data import DataLoader, TensorDataset from torchvision.models import ResNet18_Weights, resnet18 +from pydvl.influence.frameworks import as_tensor from pydvl.utils import maybe_progress from .types import Losses @@ -89,10 +90,10 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: def fit_torch_model( model: nn.Module, - x_train: Union[NDArray[np.float_], torch.tensor], - y_train: Union[NDArray[np.float_], torch.tensor], - x_val: Union[NDArray[np.float_], torch.tensor], - y_val: Union[NDArray[np.float_], torch.tensor], + x_train: torch.Tensor, + y_train: torch.Tensor, + x_val: torch.Tensor, + y_val: torch.Tensor, loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], optimizer: Optimizer, scheduler: Optional[_LRScheduler] = None, @@ -101,8 +102,8 @@ def fit_torch_model( progress: bool = True, ) -> Losses: """ - Method that fits a pytorch model to the supplied data. - It represents a simple machine learning loop, iterating over a number of + Fits a pytorch model to the supplied data. + Represents a simple machine learning loop, iterating over a number of epochs, sampling data with a certain batch size, calculating gradients and updating the parameters through a loss function. :param x: Matrix of shape [NxD] representing the features x_i. @@ -112,12 +113,11 @@ def fit_torch_model( :param num_epochs: Number of epochs to repeat training. :param batch_size: Batch size to use in training. :param progress: True, iff progress shall be printed. - :param tensor_type: accuracy of tensors. Typically 'float' or 'long' """ - x_train = torch.as_tensor(x_train).clone() - y_train = torch.as_tensor(y_train).clone() - x_val = torch.as_tensor(x_val).clone() - y_val = torch.as_tensor(y_val).clone() + x_train = as_tensor(x_train) + y_train = as_tensor(y_train) + x_val = as_tensor(x_val) + y_val = as_tensor(y_val) dataset = TensorDataset(x_train, y_train) dataloader = DataLoader(dataset, batch_size=batch_size) @@ -196,7 +196,7 @@ def train( lr: float = 0.001, batch_size: int = 1000, use_cache: bool = True, - ) -> Tuple[NDArray[np.float_], NDArray[np.float_]]: + ) -> Losses: """ :return: Tuple of training_loss, validation_loss """ @@ -226,10 +226,7 @@ def train( self.model.eval() return losses - def save( - self, - losses: Losses, - ): + def save(self, losses: Losses): """Saves the model weights and training and validation losses. :param training_loss: list of training losses, one per epoch diff --git a/notebooks/support/types.py b/notebooks/support/types.py index d5c6123ed..5f3988745 100644 --- a/notebooks/support/types.py +++ b/notebooks/support/types.py @@ -1,3 +1,9 @@ -from collections import namedtuple +from typing import NamedTuple -Losses = namedtuple("Losses", "training val") +import numpy as np +from numpy.typing import NDArray + + +class Losses(NamedTuple): + training: NDArray[np.float_] + validation: NDArray[np.float_] diff --git a/src/pydvl/influence/__init__.py b/src/pydvl/influence/__init__.py index bb01db465..570c4056a 100644 --- a/src/pydvl/influence/__init__.py +++ b/src/pydvl/influence/__init__.py @@ -8,4 +8,4 @@ """ from .frameworks import TorchTwiceDifferentiable, TwiceDifferentiable -from .general import calculate_influence_factors, compute_influences +from .general import compute_influence_factors, compute_influences diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index b8ae80b1e..389f82b75 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -1,8 +1,42 @@ -from .torch_differentiable import TorchTwiceDifferentiable -from .twice_differentiable import TensorType, TwiceDifferentiable - -__all__ = [ - "TwiceDifferentiable", - "TorchTwiceDifferentiable", - "TensorType", -] +# FIXME the following code was part of an attempt to accommodate different +# frameworks. In its current form it is ugly and thus it will likely be changed +# in the future. + +from .twice_differentiable import TwiceDifferentiable + +__all__ = ["TwiceDifferentiable"] + +try: + import torch + + from .torch_differentiable import TorchTwiceDifferentiable + + __all__.append("TorchTwiceDifferentiable") + + from .torch_differentiable import ( + as_tensor, + einsum, + identity_tensor, + mvp, + solve_linear, + stack_tensors, + ) + + TensorType = torch.Tensor + ModelType = torch.nn.Module + +except ImportError: + pass + +__all__.extend( + [ + "TensorType", + "ModelType", + "solve_linear", + "as_tensor", + "stack_tensors", + "einsum", + "identity_tensor", + "mvp", + ] +) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index af0a3cf36..dcafa92bb 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -2,23 +2,17 @@ Contains all parts of pyTorch based machine learning model. """ import logging -from typing import Callable, Optional, Tuple +from typing import Any, Callable, List, Sequence, Tuple import numpy as np -from numpy.typing import NDArray +import torch +import torch.nn as nn +from torch import autograd +from torch.autograd import Variable from ...utils import maybe_progress from .twice_differentiable import TwiceDifferentiable -try: - import torch - import torch.nn as nn - from torch import autograd - from torch.autograd import Variable - -except ImportError: - pass - __all__ = [ "TorchTwiceDifferentiable", ] @@ -32,9 +26,76 @@ def flatten_gradient(grad): return torch.cat([el.reshape(-1) for el in grad]) +def solve_linear(matrix: torch.Tensor, b: torch.Tensor): + """Computes the solution of a square system of linear equations""" + return torch.linalg.solve(matrix, b) + + +def as_tensor(a: Any, ensure=True, **kwargs): + """Converts an array into a torch tensor""" + if ensure and not isinstance(a, torch.Tensor): + logger.warning("Converting tensor to type torch.Tensor.") + return torch.as_tensor(a, **kwargs) + + +def stack_tensors(a: Sequence[torch.Tensor], **kwargs): + """Stacks a sequence of tensors into a single torch tensor""" + return torch.stack(a, **kwargs) + + +def einsum(equation, *operands): + """Sums the product of the elements of the input :attr:`operands` along dimensions specified using a notation + based on the Einstein summation convention. + """ + return torch.einsum(equation, *operands) + + +def identity_tensor(dim: int): + return torch.eye(dim, dim) + + +def mvp( + grad_xy: torch.Tensor, + v: torch.Tensor, + backprop_on: torch.Tensor, + progress: bool = False, +) -> torch.Tensor: + """ + Calculates second order derivative of the model along directions v. + This second order derivative can be selected through the backprop_on argument. + + :param grad_xy: an array [P] holding the gradients of the model + parameters wrt input $x$ and labels $y$, where P is the number of + parameters of the model. It is typically obtained through + self.grad. + :param v: An array ([DxP] or even one dimensional [D]) which + multiplies the matrix, where D is the number of directions. + :param progress: True, iff progress shall be printed. + :param backprop_on: tensor used in the second backpropagation (the first + one is along $x$ and $y$ as defined via grad_xy). + :returns: A matrix representing the implicit matrix vector product + of the model along the given directions. Output shape is [DxP] if + backprop_on is None, otherwise [DxM], with M the number of elements + of backprop_on. + """ + v = as_tensor(v, ensure=False) + if v.ndim == 1: + v = v.unsqueeze(0) + + z = (grad_xy * Variable(v)).sum(dim=1) + + mvp = [] + for i in maybe_progress(range(len(z)), progress, desc="MVP"): + mvp.append( + flatten_gradient(autograd.grad(z[i], backprop_on, retain_graph=True)) + ) + mvp = torch.stack([grad.contiguous().view(-1) for grad in mvp]) + return mvp.detach() # type: ignore + + class TorchTwiceDifferentiable(TwiceDifferentiable[torch.Tensor, nn.Module]): """ - Calculates second-derivative matrix vector products (Mvp) of a pytorch torch.nn.Module + Calculates second-derivative of a model wrt. a given loss """ def __init__( @@ -43,7 +104,7 @@ def __init__( loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], ): """ - :param model: A torch.nn.Module representing a (differentiable) function. + :param model: A (differentiable) function. :param loss: Loss function $L(f(x), y)$ maps a prediction and a target to a single value. """ if model.training: @@ -55,74 +116,74 @@ def __init__( self.model = model self.loss = loss + def parameters(self) -> List[torch.Tensor]: + """Returns all the model parameters that require differentiating""" + return [ + param for param in self.model.parameters() if param.requires_grad == True + ] + def num_params(self) -> int: """ Get number of parameters of model f. :returns: Number of parameters as integer. """ - model_parameters = filter(lambda p: p.requires_grad, self.model.parameters()) - return sum([np.prod(p.size()) for p in model_parameters]) + return sum([np.prod(p.size()) for p in self.parameters()]) def split_grad( self, x: torch.Tensor, y: torch.Tensor, progress: bool = False, - ) -> NDArray: + ) -> torch.Tensor: """ Calculates gradient of model parameters wrt each $x[i]$ and $y[i]$ and then returns a array of size [N, P] with N number of points (length of x and y) and P number of parameters of the model. - :param x: A np.ndarray [NxD] representing the features $x_i$. - :param y: A np.ndarray [NxK] representing the predicted target values $y_i$. + :param x: An array [NxD] representing the features $x_i$. + :param y: An array [NxK] representing the predicted target values $y_i$. :param progress: True, iff progress shall be printed. - :returns: A np.ndarray [NxP] representing the gradients with respect to + :returns: An array [NxP] representing the gradients with respect to all parameters of the model. """ - x = torch.as_tensor(x).unsqueeze(1) - y = torch.as_tensor(y) + x = as_tensor(x).unsqueeze(1) + y = as_tensor(y) params = [ param for param in self.model.parameters() if param.requires_grad == True ] - grads = [ - flatten_gradient( - autograd.grad( - self.loss( - torch.squeeze(self.model(x[i])), - torch.squeeze(y[i]), - ), - params, - ) - ) - .detach() - .numpy() - for i in maybe_progress( - range(len(x)), - progress, - desc="Split Gradient", + grads = [] + for i in maybe_progress(range(len(x)), progress, desc="Split Gradient"): + grads.append( + flatten_gradient( + autograd.grad( + self.loss( + torch.squeeze(self.model(x[i])), + torch.squeeze(y[i]), + ), + params, + ) + ).detach() ) - ] - return np.stack(grads, axis=0) + + return torch.stack(grads, axis=0) def grad( self, x: torch.Tensor, y: torch.Tensor, - ) -> Tuple[NDArray, torch.Tensor]: + ) -> Tuple[torch.Tensor, torch.Tensor]: """ Calculates gradient of model parameters wrt $x$ and $y$. :param x: A matrix [NxD] representing the features $x_i$. - :param y: A matrix [NxK] representing the predicted target values $y_i$. - :param progress: True, iff progress shall be printed. + :param y: A matrix [NxK] representing the target values $y_i$. :returns: A tuple where: \ - first element is an array [P] with the gradients of the model. \ - second element is the input to the model as a grad parameters. \ This can be used for further differentiation. """ - x = torch.as_tensor(x).requires_grad_(True) - y = torch.as_tensor(y) + x = as_tensor(x).requires_grad_(True) + y = as_tensor(y) params = [ param for param in self.model.parameters() if param.requires_grad == True @@ -132,54 +193,27 @@ def grad( grad_f = torch.autograd.grad(loss_value, params, create_graph=True) return flatten_gradient(grad_f), x - def mvp( + def hessian( self, - grad_xy: torch.Tensor, - v: torch.Tensor, + x: torch.Tensor, + y: torch.Tensor, progress: bool = False, - backprop_on: Optional[torch.Tensor] = None, - ) -> NDArray: - """ - Calculates second order derivative of the model along directions v. - This second order derivative can be on the model parameters or on - another input parameter, selected via the backprop_on argument. - - :param grad_xy: an array [P] holding the gradients of the model - parameters wrt input $x$ and labels $y$, where P is the number of - parameters of the model. It is typically obtained through - self.grad. - :param v: A np.ndarray [DxP] or a one dimensional np.array [D] which - multiplies the Hessian, where D is the number of directions. - :param progress: True, iff progress shall be printed. - :param backprop_on: tensor used in the second backpropagation (the first - one is along $x$ and $y$ as defined via grad_xy). If None, the model - parameters are used. - :returns: A matrix representing the implicit matrix vector product - of the model along the given directions. Output shape is [DxP] if - backprop_on is None, otherwise [DxM], with M the number of elements - of backprop_on. + ) -> torch.Tensor: + """Calculates the explicit hessian of model parameters given data ($x$ and $y$). + :param x: A matrix [NxD] representing the features $x_i$. + :param y: A matrix [NxK] representing the target values $y_i$. + :returns: A tuple where: \ + - first element is an array [P] with the gradients of the model. \ + - second element is the input to the model as a grad parameters. \ + This can be used for further differentiation. """ - v = torch.as_tensor(v) - if v.ndim == 1: - v = v.unsqueeze(0) - - z = (grad_xy * Variable(v)).sum(dim=1) - params = [ + grad_xy, _ = self.grad(x, y) + backprop_on = [ param for param in self.model.parameters() if param.requires_grad == True ] - all_flattened_grads = [ - flatten_gradient( - autograd.grad( - z[i], - params if backprop_on is None else backprop_on, - retain_graph=True, - ) - ) - for i in maybe_progress( - range(len(z)), - progress, - desc="MVP", - ) - ] - hvp = torch.stack([grad.contiguous().view(-1) for grad in all_flattened_grads]) - return hvp.detach().numpy() # type: ignore + return mvp( + grad_xy, + torch.eye(self.num_params(), self.num_params()), + backprop_on, + progress, + ) diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index dff468c3b..e1e9c8e0b 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -1,7 +1,5 @@ from abc import ABC -from typing import Callable, Generic, Optional, Sequence, Tuple, TypeVar - -from numpy.typing import NDArray +from typing import Callable, Generic, List, Sequence, Tuple, TypeVar TensorType = TypeVar("TensorType", bound=Sequence) ModelType = TypeVar("ModelType") @@ -16,6 +14,11 @@ def __init__( pass def num_params(self) -> int: + """Returns the number of parameters of the model""" + pass + + def parameters(self) -> List[TensorType]: + """Returns all the model parameters that require differentiation""" pass def split_grad( @@ -23,32 +26,27 @@ def split_grad( x: TensorType, y: TensorType, progress: bool = False, - ) -> NDArray: + ) -> TensorType: """ Calculate the gradient of the model wrt each input x and labels y. - The output is therefore of size [Nxp], with N the amout of points (the + The output is therefore of size [Nxp], with N the amount of points (the length of x and y) and P the number of parameters. """ pass - def grad(self, x: TensorType, y: TensorType) -> Tuple[NDArray, TensorType]: + def grad(self, x: TensorType, y: TensorType) -> Tuple[TensorType, TensorType]: """ - It calculates the gradient of model parameters with respect to input x + Calculates the gradient of model parameters with respect to input x and labels y. """ pass - def mvp( + def hessian( self, - grad_xy: TensorType, - v: TensorType, + x: TensorType, + y: TensorType, progress: bool = False, - backprop_on: Optional[TensorType] = None, - ) -> NDArray: - """ - Calculates second order derivative of the model along directions v, - which can be a single vector or a matrix (thus the method must support - broadcasting). This second order derivative can be on the model parameters or on - another input parameter, selected via the backprop_on argument. - """ + ) -> TensorType: + """Calculates the explicit hessian of model parameters given data ($x$ + and $y$).""" pass diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 9cd6543fe..c1c7cddc0 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -1,16 +1,22 @@ """ -Contains parallelized influence calculation functions for general models. +This module contains parallelized influence calculation functions for general +models, as introduced in :footcite:t:`koh_understanding_2017`. """ from enum import Enum -import numpy as np -from numpy.typing import NDArray - from ..utils import maybe_progress -from .frameworks import TensorType, TwiceDifferentiable -from .inversion_methods import InversionMethod, invert_matrix +from .frameworks import ( + ModelType, + TensorType, + TwiceDifferentiable, + as_tensor, + einsum, + mvp, + stack_tensors, +) +from .inversion import InversionMethod, solve_hvp -__all__ = ["compute_influences", "InfluenceType", "calculate_influence_factors"] +__all__ = ["compute_influences", "InfluenceType", "compute_influence_factors"] class InfluenceType(str, Enum): @@ -22,8 +28,8 @@ class InfluenceType(str, Enum): Perturbation = "perturbation" -def calculate_influence_factors( - model: TwiceDifferentiable, +def compute_influence_factors( + model: TwiceDifferentiable[TensorType, ModelType], x: TensorType, y: TensorType, x_test: TensorType, @@ -31,8 +37,8 @@ def calculate_influence_factors( inversion_method: InversionMethod, lam: float = 0, progress: bool = False, -) -> NDArray: - """ +) -> TensorType: + r""" It calculates influence factors of a model from its training and test points. Given a test point $z_test = (x_{test}, y_{test})$, a loss $L(z_{test}, \theta)$ ($\theta$ being the parameters of the model) and the @@ -45,8 +51,8 @@ def calculate_influence_factors( more info, refer to :footcite:t:`koh_understanding_2017`, paragraph 3. :param model: A model wrapped in the TwiceDifferentiable interface. - :param x_train: An array of shape [MxK] containing the features of the input data points. - :param y_train: An array of shape [MxL] containing the targets of the input data points. + :param x: An array of shape [MxK] containing the features of the input data points. + :param y: An array of shape [MxL] containing the targets of the input data points. :param x_test: An array of shape [NxK] containing the features of the test set of data points. :param y_test: An array of shape [NxL] containing the targets of the test set of data points. :param inversion_func: function to use to invert the product of hvp (hessian @@ -56,27 +62,31 @@ def calculate_influence_factors( :returns: An array of size (N, D) containing the influence factors for each dimension (D) and test sample (N). """ - grad_xy, _ = model.grad(x, y) - hvp = lambda v: model.mvp(grad_xy, v) + lam * v - n_params = model.num_params() + x = as_tensor(x) + y = as_tensor(y) + x_test = as_tensor(x_test) + y_test = as_tensor(y_test) + test_grads = model.split_grad(x_test, y_test, progress) - return invert_matrix( + return solve_hvp( inversion_method, - hvp, - (n_params, n_params), + model, + x, + y, test_grads, + lam, progress, ) -def _calculate_influences_up( - model: TwiceDifferentiable, +def _compute_influences_up( + model: TwiceDifferentiable[TensorType, ModelType], x: TensorType, y: TensorType, - influence_factors: NDArray, + influence_factors: TensorType, progress: bool = False, -) -> NDArray: - """ +) -> TensorType: + r""" Given the model, the training points and the influence factors, calculates the influences using the upweighting method. More precisely, first it calculates the gradients of the model wrt. each training sample ($\grad_{\theta} L$, @@ -95,17 +105,17 @@ def _calculate_influences_up( number of train points. """ train_grads = model.split_grad(x, y, progress) - return np.einsum("ta,va->tv", influence_factors, train_grads) # type: ignore + return einsum("ta,va->tv", influence_factors, train_grads) -def _calculate_influences_pert( - model: TwiceDifferentiable, +def _compute_influences_pert( + model: TwiceDifferentiable[TensorType, ModelType], x: TensorType, y: TensorType, - influence_factors: NDArray, + influence_factors: TensorType, progress: bool = False, -) -> NDArray: - """ +) -> TensorType: + r""" Calculates the influence values from the influence factors and the training points using the perturbation method. More precisely, for each training sample it calculates $\grad_{\theta} L$ (with L the loss of the model over the single @@ -131,24 +141,24 @@ def _calculate_influences_pert( desc="Influence Perturbation", ): grad_xy, tensor_x = model.grad(x[i : i + 1], y[i]) - perturbation_influences = model.mvp( + perturbation_influences = mvp( grad_xy, influence_factors, backprop_on=tensor_x, ) all_pert_influences.append(perturbation_influences.reshape((-1, *x[i].shape))) - return np.stack(all_pert_influences, axis=1) + return stack_tensors(all_pert_influences, axis=1) influence_type_registry = { - InfluenceType.Up: _calculate_influences_up, - InfluenceType.Perturbation: _calculate_influences_pert, + InfluenceType.Up: _compute_influences_up, + InfluenceType.Perturbation: _compute_influences_pert, } def compute_influences( - differentiable_model: TwiceDifferentiable, + differentiable_model: TwiceDifferentiable[TensorType, ModelType], x: TensorType, y: TensorType, x_test: TensorType, @@ -157,8 +167,8 @@ def compute_influences( inversion_method: InversionMethod = InversionMethod.Direct, influence_type: InfluenceType = InfluenceType.Up, hessian_regularization: float = 0, -) -> NDArray: - """ +) -> TensorType: + r""" Calculates the influence of the training points j on the test points i. First it calculates the influence factors for all test points with respect to the training points, and then uses them to get the influences over the @@ -186,8 +196,12 @@ def compute_influences( train points. If instead influence_type is 'perturbation', output shape is [NxMxP], with P the number of input features. """ + x = as_tensor(x) + y = as_tensor(y) + x_test = as_tensor(x_test) + y_test = as_tensor(y_test) - influence_factors = calculate_influence_factors( + influence_factors = compute_influence_factors( differentiable_model, x, y, diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py new file mode 100644 index 000000000..77837b3aa --- /dev/null +++ b/src/pydvl/influence/inversion.py @@ -0,0 +1,105 @@ +""" +Contains methods to invert matrices +""" +import logging +from enum import Enum +from typing import List + +import numpy as np +from numpy.typing import NDArray +from scipy.sparse.linalg import LinearOperator, cg + +from ..utils import maybe_progress +from .frameworks import ( + ModelType, + TensorType, + TwiceDifferentiable, + as_tensor, + identity_tensor, + mvp, + solve_linear, +) + +__all__ = ["solve_hvp"] + +logger = logging.getLogger(__name__) + + +class InversionMethod(str, Enum): + """ + Different inversion methods types. + """ + + Direct = "direct" + Cg = "cg" + + +def solve_hvp( + inversion_method: InversionMethod, + model: TwiceDifferentiable[TensorType, ModelType], + x: TensorType, + y: TensorType, + b: TensorType, + lam: float = 0, + progress: bool = False, +) -> TensorType: + """ + Finds $x$ such that $Ax = b$, where $A$ is the hessian of model, + and $b$ a vector. + Depending on the inversion method, the hessian is either calculated directly + and then inverted, or implicitly and then inverted through matrix vector + product. The method also allows to add a small regularization term (lam) + to facilitate inversion of non fully trained models. + + :param inversion_method: + :param model: A model wrapped in the TwiceDifferentiable interface. + :param x: An array containing the features of the input data points. + :param b: + :param lam: regularization of the hessian + :param progress: If True, display progress bars. + + :return: An array that solves the inverse problem, + i.e. it returns $x$ such that $Ax = b$ + """ + if inversion_method == InversionMethod.Direct: + return solve_linear( + model.hessian(x, y, progress) + lam * identity_tensor(model.num_params()), + b.T, + ).T + elif inversion_method == InversionMethod.Cg: + grad_xy, _ = model.grad(x, y) + backprop_on = model.parameters() + reg_hvp = lambda v: mvp(grad_xy, v, backprop_on) + lam * v + hvp_dimensions = model.num_params() + return as_tensor( + conjugate_gradient( + LinearOperator((hvp_dimensions, hvp_dimensions), matvec=reg_hvp), + b, + progress, + ), + dtype=x.dtype, + ensure=False, + ) + else: + raise ValueError(f"Unknown inversion method: {inversion_method}") + + +def conjugate_gradient( + A: LinearOperator, batch_y: TensorType, progress: bool = False +) -> NDArray: + """ + Given a matrix and a batch of vectors, it uses conjugate gradient to calculate the solution + to $Ax = y$ for each $y$ in ``batch_y``. For more info: + https://en.wikipedia.org/wiki/Conjugate_gradient_method + + :param A: a real, symmetric and positive-definite matrix of shape [NxN] + :param batch_y: a matrix of shape [PxN], with P the size of the batch. + :param progress: True, iff progress shall be printed. + + :return: A matrix of shape [PxN] with each line being a solution of $Ax=b$. + """ + batch_cg = [] + for y in maybe_progress(batch_y, progress, desc="Conjugate gradient"): + y_cg, _ = cg(A, y, atol="legacy") + batch_cg.append(y_cg) + return np.asarray(batch_cg) diff --git a/src/pydvl/influence/inversion_methods.py b/src/pydvl/influence/inversion_methods.py deleted file mode 100644 index 5f0dba0db..000000000 --- a/src/pydvl/influence/inversion_methods.py +++ /dev/null @@ -1,84 +0,0 @@ -""" -Contains - -- batched conjugate gradient. -- error bound for conjugate gradient. -""" -import logging -from enum import Enum -from typing import Callable, Tuple - -import numpy as np -from numpy.typing import NDArray -from scipy.sparse.linalg import LinearOperator, cg - -from ..utils import maybe_progress -from .frameworks import TensorType - -__all__ = ["matrix_inversion_algorithm", "conjugate_gradient"] - -logger = logging.getLogger(__name__) - - -class InversionMethod(str, Enum): - """ - Different inversion methods types. - """ - - Direct = "direct" - Cg = "cg" - - -def invert_matrix( - inversion_method: InversionMethod, - mvp: Callable[[TensorType], NDArray[np.float_]], - mvp_dimensions: Tuple[int, int], - b: NDArray[np.float_], - progress: bool = False, -) -> NDArray[np.float_]: - """ - Finds $x$ such that $Ax = b$, where $A$ is a matrix of size ``mvp_dimensions``), - and $b$ a vector. - Instead of passing the matrix A directly, the method takes its mvp, i.e. a - (callable) matrix vector product that returns the product Ax for any vector - x. This is done to avoid storing a (potentially very large) matrix in memory. - - :param inversion_method: - :param mvp: matrix vector product, a callable that, given any array $x$, - returns the result of $Ax$. - :param mvp_dimensions: dimensions of matrix $A$ - :param b: - :param progress: If True, display progress bars. - - :return: An array that solves the inverse problem, - i.e. it returns $x$ such that $Ax = b$ - """ - if inversion_method == InversionMethod.Direct: - return (np.linalg.inv(mvp(np.eye(mvp_dimensions[1]))) @ b.T).T # type: ignore - elif inversion_method == InversionMethod.Cg: - return conjugate_gradient( - LinearOperator(mvp_dimensions, matvec=mvp), b, progress - ) - else: - raise ValueError(f"Unknown inversion method: {inversion_method}") - - -def conjugate_gradient( - A: LinearOperator, batch_y: NDArray[np.float_], progress: bool = False -) -> NDArray[np.float_]: - """ - Given a matrix and a batch of vectors, it uses conjugate gradient to calculate the solution - to $Ax = y$ for each $y$ in ``batch_y``. For more info: - https://en.wikipedia.org/wiki/Conjugate_gradient_method - - :param A: a real, symmetric and positive-definite matrix of shape [NxN] - :param batch_y: a matrix of shape [PxN], with P the size of the batch. - :param progress: True, iff progress shall be printed. - - :return: A matrix of shape [PxN] with each line being a solution of $Ax=b$. - """ - batch_cg = [] - for y in maybe_progress(batch_y, progress, desc="Conjugate gradient"): - y_cg, _ = cg(A, y, atol="legacy") - batch_cg.append(y_cg) - return np.asarray(batch_cg) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 73d036a72..5fc0f93a6 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -76,25 +76,24 @@ def analytical_linear_influences( return result -class InfluenceTestSettings: - INFLUENCE_TEST_CONDITION_NUMBERS: List[int] = [3] - INFLUENCE_TRAINING_SET_SIZE: List[int] = [50, 30] - INFLUENCE_TEST_SET_SIZE: List[int] = [20] - INFLUENCE_DIMENSIONS: List[Tuple[int, int]] = [ - (10, 10), - (3, 20), - ] - HESSIAN_REGULARIZATION: List[float] = [0, 1] +INFLUENCE_TEST_CONDITION_NUMBERS: List[int] = [3] +INFLUENCE_TRAINING_SET_SIZE: List[int] = [50, 30] +INFLUENCE_TEST_SET_SIZE: List[int] = [20] +INFLUENCE_DIMENSIONS: List[Tuple[int, int]] = [ + (10, 10), + (3, 20), +] +HESSIAN_REGULARIZATION: List[float] = [0, 1] test_cases = list( itertools.product( - InfluenceTestSettings.INFLUENCE_TRAINING_SET_SIZE, - InfluenceTestSettings.INFLUENCE_TEST_SET_SIZE, + INFLUENCE_TRAINING_SET_SIZE, + INFLUENCE_TEST_SET_SIZE, InfluenceType, - InfluenceTestSettings.INFLUENCE_DIMENSIONS, - InfluenceTestSettings.INFLUENCE_TEST_CONDITION_NUMBERS, - InfluenceTestSettings.HESSIAN_REGULARIZATION, + INFLUENCE_DIMENSIONS, + INFLUENCE_TEST_CONDITION_NUMBERS, + HESSIAN_REGULARIZATION, ) ) @@ -151,7 +150,7 @@ def test_influence_linear_model( influence_type=influence_type, inversion_method="direct", hessian_regularization=hessian_reg, - ) + ).numpy() cg_influences = compute_influences( TorchTwiceDifferentiable(linear_layer, loss), @@ -161,7 +160,7 @@ def test_influence_linear_model( influence_type=influence_type, inversion_method="cg", hessian_regularization=hessian_reg, - ) + ).numpy() assert np.logical_not(np.any(np.isnan(direct_influences))) assert np.logical_not(np.any(np.isnan(cg_influences))) assert np.allclose(direct_influences, analytical_influences, rtol=1e-7) @@ -266,7 +265,7 @@ def test_influences_nn( influence_type=influence_type, inversion_method=inversion_method, hessian_regularization=hessian_reg, - ) + ).numpy() assert not np.any(np.isnan(influences)) multiple_influences.append(influences) if influence_type == InfluenceType.Up: diff --git a/tests/influence/test_torch_differentiable.py b/tests/influence/test_torch_differentiable.py index cb1a0ff2b..cce84334a 100644 --- a/tests/influence/test_torch_differentiable.py +++ b/tests/influence/test_torch_differentiable.py @@ -24,67 +24,32 @@ from pydvl.influence.frameworks.torch_differentiable import TorchTwiceDifferentiable - -class ModelTestSettings: - DATA_OUTPUT_NOISE: float = 0.01 - - TEST_CONDITION_NUMBERS: List[int] = [5] - TEST_SET_SIZE: List[int] = [20] - TRAINING_SET_SIZE: List[int] = [50] - PROBLEM_DIMENSIONS: List[Tuple[int, int]] = [ - (2, 2), - (5, 10), - (10, 5), - (10, 10), - ] - - -test_cases_linear_regression_fit = list( - itertools.product( - ModelTestSettings.TRAINING_SET_SIZE, - ModelTestSettings.TEST_SET_SIZE, - ModelTestSettings.PROBLEM_DIMENSIONS, - ModelTestSettings.TEST_CONDITION_NUMBERS, - ) -) - -test_cases_logistic_regression_fit = list( - itertools.product( - ModelTestSettings.TRAINING_SET_SIZE, - ModelTestSettings.TEST_SET_SIZE, - [(1, 3), (1, 7), (1, 20)], - ModelTestSettings.TEST_CONDITION_NUMBERS, - ) -) +DATA_OUTPUT_NOISE: float = 0.01 + +TEST_CONDITION_NUMBERS: List[int] = [5] +TEST_SET_SIZE: List[int] = [20] +TRAINING_SET_SIZE: List[int] = [50] +PROBLEM_DIMENSIONS: List[Tuple[int, int]] = [ + (2, 2), + (5, 10), + (10, 5), + (10, 10), +] test_cases_linear_regression_derivatives = list( itertools.product( - ModelTestSettings.TRAINING_SET_SIZE, - ModelTestSettings.PROBLEM_DIMENSIONS, - ModelTestSettings.TEST_CONDITION_NUMBERS, + TRAINING_SET_SIZE, + PROBLEM_DIMENSIONS, + TEST_CONDITION_NUMBERS, ) ) -def lmb_fit_test_case_to_str(packed_i_test_case): - i, test_case = packed_i_test_case - return f"Problem #{i} of dimension {test_case[2]} with train size {test_case[0]}, test size {test_case[1]} and condition number {test_case[3]}" - - def lmb_correctness_test_case_to_str(packed_i_test_case): i, test_case = packed_i_test_case return f"Problem #{i} of dimension {test_case[1]} with train size {test_case[0]} and condition number {test_case[2]}" -fit_test_case_ids = list( - map( - lmb_fit_test_case_to_str, - zip( - range(len(test_cases_linear_regression_fit)), - test_cases_linear_regression_fit, - ), - ) -) correctness_test_case_ids = list( map( lmb_correctness_test_case_to_str, @@ -112,9 +77,7 @@ def test_linear_grad( output_dimension, input_dimension = tuple(A.shape) # generate datasets - data_model = lambda x: np.random.normal( - x @ A.T + b, ModelTestSettings.DATA_OUTPUT_NOISE - ) + data_model = lambda x: np.random.normal(x @ A.T + b, DATA_OUTPUT_NOISE) train_x = np.random.uniform(size=[train_set_size, input_dimension]) train_y = data_model(train_x) @@ -146,9 +109,7 @@ def test_linear_hessian( output_dimension, input_dimension = tuple(A.shape) # generate datasets - data_model = lambda x: np.random.normal( - x @ A.T + b, ModelTestSettings.DATA_OUTPUT_NOISE - ) + data_model = lambda x: np.random.normal(x @ A.T + b, DATA_OUTPUT_NOISE) train_x = np.random.uniform(size=[train_set_size, input_dimension]) train_y = data_model(train_x) model = nn.Linear(input_dimension, output_dimension) @@ -182,9 +143,7 @@ def test_linear_mixed_derivative( output_dimension, input_dimension = tuple(A.shape) # generate datasets - data_model = lambda x: np.random.normal( - x @ A.T + b, ModelTestSettings.DATA_OUTPUT_NOISE - ) + data_model = lambda x: np.random.normal(x @ A.T + b, DATA_OUTPUT_NOISE) train_x = np.random.uniform(size=[train_set_size, input_dimension]) train_y = data_model(train_x) model = nn.Linear(input_dimension, output_dimension) From cb95d50453a556972418def406904886e7f5c9c4 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 8 Mar 2023 18:10:59 +0100 Subject: [PATCH 029/436] minor changes to docstring --- src/pydvl/influence/inversion.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 77837b3aa..0172023b1 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -1,9 +1,8 @@ """ -Contains methods to invert matrices +Contains methods to invert the hessian vector product. """ import logging from enum import Enum -from typing import List import numpy as np from numpy.typing import NDArray From dbd6e855846d9ba7f0a91436a088f35410bc3d68 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 8 Mar 2023 18:40:33 +0100 Subject: [PATCH 030/436] fix tests --- docs/pydvl.bib | 141 ++++++++++++++++++ .../frameworks/torch_differentiable.py | 8 +- tests/influence/test_torch_differentiable.py | 13 +- 3 files changed, 154 insertions(+), 8 deletions(-) create mode 100644 docs/pydvl.bib diff --git a/docs/pydvl.bib b/docs/pydvl.bib new file mode 100644 index 000000000..2a35ee51b --- /dev/null +++ b/docs/pydvl.bib @@ -0,0 +1,141 @@ +@inproceedings{ghorbani_data_2019, + title = {Data {{Shapley}}: {{Equitable Valuation}} of {{Data}} for {{Machine Learning}}}, + shorttitle = {Data {{Shapley}}}, + booktitle = {Proceedings of the 36th {{International Conference}} on {{Machine Learning}}, {{PMLR}}}, + author = {Ghorbani, Amirata and Zou, James}, + year = {2019}, + month = may, + eprint = {1904.02868}, + eprinttype = {arxiv}, + pages = {2242--2251}, + publisher = {{PMLR}}, + issn = {2640-3498}, + url = {http://proceedings.mlr.press/v97/ghorbani19c.html}, + urldate = {2020-11-01}, + abstract = {As data becomes the fuel driving technological and economic growth, a fundamental challenge is how to quantify the value of data in algorithmic predictions and decisions. For example, in healthcare and consumer markets, it has been suggested that individuals should be compensated for the data that they generate, but it is not clear what is an equitable valuation for individual data. In this work, we develop a principled framework to address data valuation in the context of supervised machine learning. Given a learning algorithm trained on n data points to produce a predictor, we propose data Shapley as a metric to quantify the value of each training datum to the predictor performance. Data Shapley uniquely satisfies several natural properties of equitable data valuation. We develop Monte Carlo and gradient-based methods to efficiently estimate data Shapley values in practical settings where complex learning algorithms, including neural networks, are trained on large datasets. In addition to being equitable, extensive experiments across biomedical, image and synthetic data demonstrate that data Shapley has several other benefits: 1) it is more powerful than the popular leave-one-out or leverage score in providing insight on what data is more valuable for a given learning task; 2) low Shapley value data effectively capture outliers and corruptions; 3) high Shapley value data inform what type of new data to acquire to improve the predictor.}, + archiveprefix = {arXiv}, + langid = {english} +} + +@inproceedings{jia_efficient_2019, + title = {Towards {{Efficient Data Valuation Based}} on the {{Shapley Value}}}, + booktitle = {Proceedings of the 22nd {{International Conference}} on {{Artificial Intelligence}} and {{Statistics}}}, + author = {Jia, Ruoxi and Dao, David and Wang, Boxin and Hubis, Frances Ann and Hynes, Nick and G{\"u}rel, Nezihe Merve and Li, Bo and Zhang, Ce and Song, Dawn and Spanos, Costas J.}, + year = {2019}, + month = apr, + pages = {1167--1176}, + publisher = {{PMLR}}, + issn = {2640-3498}, + url = {http://proceedings.mlr.press/v89/jia19a.html}, + urldate = {2021-02-12}, + abstract = {``How much is my data worth?'' is an increasingly common question posed by organizations and individuals alike. An answer to this question could allow, for instance, fairly distributing profits...}, + langid = {english} +} + +@article{jia_efficient_2019a, + title = {Efficient Task-Specific Data Valuation for Nearest Neighbor Algorithms}, + shorttitle = {{{VLDB}} 2019}, + author = {Jia, Ruoxi and Dao, David and Wang, Boxin and Hubis, Frances Ann and Gurel, Nezihe Merve and Li, Bo and Zhang, Ce and Spanos, Costas and Song, Dawn}, + year = {2019}, + month = jul, + journal = {Proceedings of the VLDB Endowment}, + volume = {12}, + number = {11}, + pages = {1610--1623}, + issn = {2150-8097}, + doi = {10.14778/3342263.3342637}, + url = {https://doi.org/10.14778/3342263.3342637}, + urldate = {2021-02-12}, + abstract = {Given a data set D containing millions of data points and a data consumer who is willing to pay for \$X to train a machine learning (ML) model over D, how should we distribute this \$X to each data point to reflect its "value"? In this paper, we define the "relative value of data" via the Shapley value, as it uniquely possesses properties with appealing real-world interpretations, such as fairness, rationality and decentralizability. For general, bounded utility functions, the Shapley value is known to be challenging to compute: to get Shapley values for all N data points, it requires O(2N) model evaluations for exact computation and O(N log N) for ({$\epsilon$}, {$\delta$})-approximation. In this paper, we focus on one popular family of ML models relying on K-nearest neighbors (KNN). The most surprising result is that for unweighted KNN classifiers and regressors, the Shapley value of all N data points can be computed, exactly, in O(N log N) time - an exponential improvement on computational complexity! Moreover, for ({$\epsilon$}, {$\delta$})-approximation, we are able to develop an algorithm based on Locality Sensitive Hashing (LSH) with only sublinear complexity O(Nh({$\epsilon$}, K) log N) when {$\epsilon$} is not too small and K is not too large. We empirically evaluate our algorithms on up to 10 million data points and even our exact algorithm is up to three orders of magnitude faster than the baseline approximation algorithm. The LSH-based approximation algorithm can accelerate the value calculation process even further. We then extend our algorithm to other scenarios such as (1) weighed KNN classifiers, (2) different data points are clustered by different data curators, and (3) there are data analysts providing computation who also requires proper valuation. Some of these extensions, although also being improved exponentially, are less practical for exact computation (e.g., O(NK) complexity for weigthed KNN). We thus propose an Monte Carlo approximation algorithm, which is O(N(log N)2/(log K)2) times more efficient than the baseline approximation algorithm.}, + langid = {english} +} + +@inproceedings{kwon_beta_2022, + title = {Beta {{Shapley}}: A {{Unified}} and {{Noise-reduced Data Valuation Framework}} for {{Machine Learning}}}, + shorttitle = {Beta {{Shapley}}}, + booktitle = {Proceedings of the 25th {{International Conference}} on {{Artificial Intelligence}} and {{Statistics}} ({{AISTATS}}) 2022,}, + author = {Kwon, Yongchan and Zou, James}, + year = {2022}, + month = jan, + volume = {151}, + eprint = {2110.14049}, + eprinttype = {arxiv}, + publisher = {{PMLR}}, + address = {{Valencia, Spain}}, + url = {http://arxiv.org/abs/2110.14049}, + urldate = {2022-04-06}, + abstract = {Data Shapley has recently been proposed as a principled framework to quantify the contribution of individual datum in machine learning. It can effectively identify helpful or harmful data points for a learning algorithm. In this paper, we propose Beta Shapley, which is a substantial generalization of Data Shapley. Beta Shapley arises naturally by relaxing the efficiency axiom of the Shapley value, which is not critical for machine learning settings. Beta Shapley unifies several popular data valuation methods and includes data Shapley as a special case. Moreover, we prove that Beta Shapley has several desirable statistical properties and propose efficient algorithms to estimate it. We demonstrate that Beta Shapley outperforms state-of-the-art data valuation methods on several downstream ML tasks such as: 1) detecting mislabeled training data; 2) learning with subsamples; and 3) identifying points whose addition or removal have the largest positive or negative impact on the model.}, + archiveprefix = {arXiv}, + langid = {english} +} + +@inproceedings{okhrati_multilinear_2021, + title = {A {{Multilinear Sampling Algorithm}} to {{Estimate Shapley Values}}}, + booktitle = {2020 25th {{International Conference}} on {{Pattern Recognition}} ({{ICPR}})}, + author = {Okhrati, Ramin and Lipani, Aldo}, + year = {2021}, + month = jan, + eprint = {2010.12082}, + eprinttype = {arxiv}, + pages = {7992--7999}, + publisher = {{IEEE}}, + issn = {1051-4651}, + doi = {10.1109/ICPR48806.2021.9412511}, + url = {https://ieeexplore.ieee.org/abstract/document/9412511}, + abstract = {Shapley values are great analytical tools in game theory to measure the importance of a player in a game. Due to their axiomatic and desirable properties such as efficiency, they have become popular for feature importance analysis in data science and machine learning. However, the time complexity to compute Shapley values based on the original formula is exponential, and as the number of features increases, this becomes infeasible. Castro et al. [1] developed a sampling algorithm, to estimate Shapley values. In this work, we propose a new sampling method based on a multilinear extension technique as applied in game theory. The aim is to provide a more efficient (sampling) method for estimating Shapley values. Our method is applicable to any machine learning model, in particular for either multiclass classifications or regression problems. We apply the method to estimate Shapley values for multilayer perceptrons (MLPs) and through experimentation on two datasets, we demonstrate that our method provides more accurate estimations of the Shapley values by reducing the variance of the sampling statistics.}, + archiveprefix = {arXiv}, + langid = {english} +} + +@misc{wang_data_2022, + title = {Data {{Banzhaf}}: {{A Robust Data Valuation Framework}} for {{Machine Learning}}}, + shorttitle = {Data {{Banzhaf}}}, + author = {Wang, Jiachen T. and Jia, Ruoxi}, + year = {2022}, + month = oct, + number = {arXiv:2205.15466}, + eprint = {2205.15466}, + eprinttype = {arxiv}, + primaryclass = {cs, stat}, + publisher = {{arXiv}}, + doi = {10.48550/arXiv.2205.15466}, + url = {http://arxiv.org/abs/2205.15466}, + urldate = {2022-10-28}, + abstract = {This paper studies the robustness of data valuation to noisy model performance scores. Particularly, we find that the inherent randomness of the widely used stochastic gradient descent can cause existing data value notions (e.g., the Shapley value and the Leave-one-out error) to produce inconsistent data value rankings across different runs. To address this challenge, we first pose a formal framework within which one can measure the robustness of a data value notion. We show that the Banzhaf value, a value notion originated from cooperative game theory literature, achieves the maximal robustness among all semivalues -- a class of value notions that satisfy crucial properties entailed by ML applications. We propose an algorithm to efficiently estimate the Banzhaf value based on the Maximum Sample Reuse (MSR) principle. We derive the lower bound sample complexity for Banzhaf value estimation, and we show that our MSR algorithm's sample complexity is close to the lower bound. Our evaluation demonstrates that the Banzhaf value outperforms the existing semivalue-based data value notions on several downstream ML tasks such as learning with weighted samples and noisy label detection. Overall, our study suggests that when the underlying ML algorithm is stochastic, the Banzhaf value is a promising alternative to the semivalue-based data value schemes given its computational advantage and ability to robustly differentiate data quality.}, + archiveprefix = {arXiv} +} + +@inproceedings{wang_improving_2022, + title = {Improving {{Cooperative Game Theory-based Data Valuation}} via {{Data Utility Learning}}}, + booktitle = {International {{Conference}} on {{Learning Representations}} ({{ICLR}} 2022). {{Workshop}} on {{Socially Responsible Machine Learning}}}, + author = {Wang, Tianhao and Yang, Yu and Jia, Ruoxi}, + year = {2022}, + month = apr, + eprint = {2107.06336v2}, + eprinttype = {arxiv}, + publisher = {{arXiv}}, + doi = {10.48550/arXiv.2107.06336}, + url = {http://arxiv.org/abs/2107.06336v2}, + urldate = {2022-05-19}, + abstract = {The Shapley value (SV) and Least core (LC) are classic methods in cooperative game theory for cost/profit sharing problems. Both methods have recently been proposed as a principled solution for data valuation tasks, i.e., quantifying the contribution of individual datum in machine learning. However, both SV and LC suffer computational challenges due to the need for retraining models on combinatorially many data subsets. In this work, we propose to boost the efficiency in computing Shapley value or Least core by learning to estimate the performance of a learning algorithm on unseen data combinations. Theoretically, we derive bounds relating the error in the predicted learning performance to the approximation error in SV and LC. Empirically, we show that the proposed method can significantly improve the accuracy of SV and LC estimation.}, + archiveprefix = {arXiv}, + langid = {english} +} + +@inproceedings{yan_if_2021, + title = {If {{You Like Shapley Then You}}'ll {{Love}} the {{Core}}}, + booktitle = {Proceedings of the 35th {{AAAI Conference}} on {{Artificial Intelligence}}, 2021}, + author = {Yan, Tom and Procaccia, Ariel D.}, + year = {2021}, + month = may, + volume = {6}, + pages = {5751--5759}, + publisher = {{Association for the Advancement of Artificial Intelligence}}, + address = {{Virtual conference}}, + doi = {10.1609/aaai.v35i6.16721}, + url = {https://ojs.aaai.org/index.php/AAAI/article/view/16721}, + urldate = {2021-04-23}, + abstract = {The prevalent approach to problems of credit assignment in machine learning \textemdash{} such as feature and data valuation\textemdash{} is to model the problem at hand as a cooperative game and apply the Shapley value. But cooperative game theory offers a rich menu of alternative solution concepts, which famously includes the core and its variants. Our goal is to challenge the machine learning community's current consensus around the Shapley value, and make a case for the core as a viable alternative. To that end, we prove that arbitrarily good approximations to the least core \textemdash{} a core relaxation that is always feasible \textemdash{} can be computed efficiently (but prove an impossibility for a more refined solution concept, the nucleolus). We also perform experiments that corroborate these theoretical results and shed light on settings where the least core may be preferable to the Shapley value.}, + copyright = {Copyright (c) 2021, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved.}, + langid = {english} +} diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index dcafa92bb..23d8221e6 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -145,8 +145,8 @@ def split_grad( :returns: An array [NxP] representing the gradients with respect to all parameters of the model. """ - x = as_tensor(x).unsqueeze(1) - y = as_tensor(y) + x = as_tensor(x, ensure=False).unsqueeze(1) + y = as_tensor(y, ensure=False) params = [ param for param in self.model.parameters() if param.requires_grad == True @@ -182,8 +182,8 @@ def grad( - second element is the input to the model as a grad parameters. \ This can be used for further differentiation. """ - x = as_tensor(x).requires_grad_(True) - y = as_tensor(y) + x = as_tensor(x, ensure=False).requires_grad_(True) + y = as_tensor(y, ensure=False) params = [ param for param in self.model.parameters() if param.requires_grad == True diff --git a/tests/influence/test_torch_differentiable.py b/tests/influence/test_torch_differentiable.py index cce84334a..35b390404 100644 --- a/tests/influence/test_torch_differentiable.py +++ b/tests/influence/test_torch_differentiable.py @@ -22,7 +22,10 @@ import torch.nn.functional as F from torch import nn -from pydvl.influence.frameworks.torch_differentiable import TorchTwiceDifferentiable +from pydvl.influence.frameworks.torch_differentiable import ( + TorchTwiceDifferentiable, + mvp, +) DATA_OUTPUT_NOISE: float = 0.01 @@ -121,8 +124,10 @@ def test_linear_hessian( test_hessian_analytical = linear_hessian_analytical((A, b), train_x) grad_xy, _ = mvp_model.grad(train_x, train_y) - estimated_hessian = mvp_model.mvp( - grad_xy, np.eye((input_dimension + 1) * output_dimension) + estimated_hessian = mvp( + grad_xy, + np.eye((input_dimension + 1) * output_dimension), + mvp_model.parameters(), ) assert np.allclose(test_hessian_analytical, estimated_hessian, rtol=1e-5) @@ -162,7 +167,7 @@ def test_linear_mixed_derivative( for i in range(len(train_x)): grad_xy, tensor_x = mvp_model.grad(train_x[i], train_y[i]) model_mvp.append( - mvp_model.mvp( + mvp( grad_xy, np.eye((input_dimension + 1) * output_dimension), backprop_on=tensor_x, From 6b3135673c261f98f43a0c29a9d7de15d249b727 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 8 Mar 2023 18:48:29 +0100 Subject: [PATCH 031/436] updating bib --- docs/pydvl.bib | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/docs/pydvl.bib b/docs/pydvl.bib index 2a35ee51b..f6aca21f8 100644 --- a/docs/pydvl.bib +++ b/docs/pydvl.bib @@ -50,6 +50,22 @@ @article{jia_efficient_2019a langid = {english} } +@inproceedings{koh_understanding_2017, + title = {Understanding {{Black-box Predictions}} via {{Influence Functions}}}, + booktitle = {Proceedings of the 34th {{International Conference}} on {{Machine Learning}}}, + author = {Koh, Pang Wei and Liang, Percy}, + year = {2017}, + month = jul, + eprint = {1703.04730}, + eprinttype = {arxiv}, + pages = {1885--1894}, + publisher = {{PMLR}}, + abstract = {How can we explain the predictions of a black-box model? In this paper, we use influence functions \textemdash{} a classic technique from robust statistics \textemdash{} to trace a model's prediction through the learning algorithm and back to its training data, thereby identifying training points most responsible for a given prediction. To scale up influence functions to modern machine learning settings, we develop a simple, efficient implementation that requires only oracle access to gradients and Hessian-vector products. We show that even on non-convex and non-differentiable models where the theory breaks down, approximations to influence functions can still provide valuable information. On linear models and convolutional neural networks, we demonstrate that influence functions are useful for multiple purposes: understanding model behavior, debugging models, detecting dataset errors, and even creating visually-indistinguishable training-set attacks.}, + archiveprefix = {arXiv}, + langid = {english}, + file = {/Users/fabio/Zotero/storage/HW6BK957/D9MZ9MUI.pdf;/Users/fabio/Zotero/storage/J4YQYLEN/Koh and Liang - 2017 - Understanding Black-box Predictions via Influence .pdf;/Users/fabio/Zotero/storage/MHFVLFHJ/Koh and Liang - 2017 - Understanding Black-box Predictions via Influence .pdf} +} + @inproceedings{kwon_beta_2022, title = {Beta {{Shapley}}: A {{Unified}} and {{Noise-reduced Data Valuation Framework}} for {{Machine Learning}}}, shorttitle = {Beta {{Shapley}}}, From 25e64e8b89680a0eecd1e535784cb5055239c52f Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 8 Mar 2023 18:59:47 +0100 Subject: [PATCH 032/436] remove file from bib --- docs/pydvl.bib | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/pydvl.bib b/docs/pydvl.bib index f6aca21f8..4fc575d05 100644 --- a/docs/pydvl.bib +++ b/docs/pydvl.bib @@ -62,8 +62,7 @@ @inproceedings{koh_understanding_2017 publisher = {{PMLR}}, abstract = {How can we explain the predictions of a black-box model? In this paper, we use influence functions \textemdash{} a classic technique from robust statistics \textemdash{} to trace a model's prediction through the learning algorithm and back to its training data, thereby identifying training points most responsible for a given prediction. To scale up influence functions to modern machine learning settings, we develop a simple, efficient implementation that requires only oracle access to gradients and Hessian-vector products. We show that even on non-convex and non-differentiable models where the theory breaks down, approximations to influence functions can still provide valuable information. On linear models and convolutional neural networks, we demonstrate that influence functions are useful for multiple purposes: understanding model behavior, debugging models, detecting dataset errors, and even creating visually-indistinguishable training-set attacks.}, archiveprefix = {arXiv}, - langid = {english}, - file = {/Users/fabio/Zotero/storage/HW6BK957/D9MZ9MUI.pdf;/Users/fabio/Zotero/storage/J4YQYLEN/Koh and Liang - 2017 - Understanding Black-box Predictions via Influence .pdf;/Users/fabio/Zotero/storage/MHFVLFHJ/Koh and Liang - 2017 - Understanding Black-box Predictions via Influence .pdf} + langid = {english} } @inproceedings{kwon_beta_2022, From baad2514f040c42b200c201d716de79d8567fb70 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 9 Mar 2023 11:19:58 +0100 Subject: [PATCH 033/436] addressing MR comments --- notebooks/support/torch.py | 12 +++--- src/pydvl/influence/frameworks/__init__.py | 4 +- .../frameworks/torch_differentiable.py | 39 +++++++++---------- .../frameworks/twice_differentiable.py | 28 +++++++++++-- src/pydvl/influence/general.py | 10 ++--- src/pydvl/influence/inversion.py | 2 +- tests/influence/test_influences.py | 2 +- 7 files changed, 58 insertions(+), 39 deletions(-) diff --git a/notebooks/support/torch.py b/notebooks/support/torch.py index 66d4aba8d..012b54e3b 100644 --- a/notebooks/support/torch.py +++ b/notebooks/support/torch.py @@ -176,17 +176,17 @@ def __init__( name: str, model: nn.Module, loss: torch.nn.modules.loss._Loss, - train_x: NDArray[np.float_], - train_y: NDArray[np.float_], - val_x: NDArray[np.float_], - val_y: NDArray[np.float_], + train_x: torch.Tensor, + train_y: torch.Tensor, + val_x: torch.Tensor, + val_y: torch.Tensor, data_dir: Path, ): self.name = name self.model = model self.loss = loss - self.train_x, self.train_y = train_x, train_y - self.val_x, self.val_y = val_x, val_y + self.train_x, self.train_y = as_tensor(train_x), as_tensor(train_y) + self.val_x, self.val_y = as_tensor(val_x), as_tensor(val_y) self.data_dir = data_dir os.makedirs(self.data_dir, exist_ok=True) diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index 389f82b75..f4a679a29 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -19,7 +19,7 @@ identity_tensor, mvp, solve_linear, - stack_tensors, + stack, ) TensorType = torch.Tensor @@ -34,7 +34,7 @@ "ModelType", "solve_linear", "as_tensor", - "stack_tensors", + "stack", "einsum", "identity_tensor", "mvp", diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 23d8221e6..46d26fb54 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -31,14 +31,18 @@ def solve_linear(matrix: torch.Tensor, b: torch.Tensor): return torch.linalg.solve(matrix, b) -def as_tensor(a: Any, ensure=True, **kwargs): - """Converts an array into a torch tensor""" - if ensure and not isinstance(a, torch.Tensor): +def as_tensor(a: Any, warn=True, **kwargs): + """Converts an array into a torch tensor + + :param a: array to convert to tensor + :param warn: if True, warns that a will be converted + """ + if warn and not isinstance(a, torch.Tensor): logger.warning("Converting tensor to type torch.Tensor.") return torch.as_tensor(a, **kwargs) -def stack_tensors(a: Sequence[torch.Tensor], **kwargs): +def stack(a: Sequence[torch.Tensor], **kwargs): """Stacks a sequence of tensors into a single torch tensor""" return torch.stack(a, **kwargs) @@ -78,7 +82,7 @@ def mvp( backprop_on is None, otherwise [DxM], with M the number of elements of backprop_on. """ - v = as_tensor(v, ensure=False) + v = as_tensor(v, warn=False) if v.ndim == 1: v = v.unsqueeze(0) @@ -94,18 +98,15 @@ def mvp( class TorchTwiceDifferentiable(TwiceDifferentiable[torch.Tensor, nn.Module]): - """ - Calculates second-derivative of a model wrt. a given loss - """ - def __init__( self, model: nn.Module, loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], ): - """ + r""" :param model: A (differentiable) function. - :param loss: Loss function $L(f(x), y)$ maps a prediction and a target to a single value. + :param loss: :param loss: A differentiable scalar loss $L(\hat{y}, y)$, + mapping a prediction and a target to a real value. """ if model.training: logger.warning( @@ -145,8 +146,8 @@ def split_grad( :returns: An array [NxP] representing the gradients with respect to all parameters of the model. """ - x = as_tensor(x, ensure=False).unsqueeze(1) - y = as_tensor(y, ensure=False) + x = as_tensor(x, warn=False).unsqueeze(1) + y = as_tensor(y, warn=False) params = [ param for param in self.model.parameters() if param.requires_grad == True @@ -174,7 +175,7 @@ def grad( y: torch.Tensor, ) -> Tuple[torch.Tensor, torch.Tensor]: """ - Calculates gradient of model parameters wrt $x$ and $y$. + Calculates gradient of model parameters wrt the model parameters. :param x: A matrix [NxD] representing the features $x_i$. :param y: A matrix [NxK] representing the target values $y_i$. :returns: A tuple where: \ @@ -182,8 +183,8 @@ def grad( - second element is the input to the model as a grad parameters. \ This can be used for further differentiation. """ - x = as_tensor(x, ensure=False).requires_grad_(True) - y = as_tensor(y, ensure=False) + x = as_tensor(x, warn=False).requires_grad_(True) + y = as_tensor(y, warn=False) params = [ param for param in self.model.parameters() if param.requires_grad == True @@ -202,10 +203,8 @@ def hessian( """Calculates the explicit hessian of model parameters given data ($x$ and $y$). :param x: A matrix [NxD] representing the features $x_i$. :param y: A matrix [NxK] representing the target values $y_i$. - :returns: A tuple where: \ - - first element is an array [P] with the gradients of the model. \ - - second element is the input to the model as a grad parameters. \ - This can be used for further differentiation. + :returns: the hessian of the model, i.e. the second derivative wrt. the + model parameters. """ grad_xy, _ = self.grad(x, y) backprop_on = [ diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index e1e9c8e0b..9b8f7f35b 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -6,6 +6,10 @@ class TwiceDifferentiable(ABC, Generic[TensorType, ModelType]): + """Wraps a differentiable model and loss and provides methods to compute the + second derivative of the loss wrt. the model parameters. + """ + def __init__( self, model: ModelType, @@ -31,13 +35,24 @@ def split_grad( Calculate the gradient of the model wrt each input x and labels y. The output is therefore of size [Nxp], with N the amount of points (the length of x and y) and P the number of parameters. + + :param x: An array representing the features $x_i$. + :param y: An array representing the predicted target values $y_i$. + :param progress: True, iff progress shall be printed. + :returns: An array representing the gradients wrt. the parameters of the + model. """ pass def grad(self, x: TensorType, y: TensorType) -> Tuple[TensorType, TensorType]: """ - Calculates the gradient of model parameters with respect to input x - and labels y. + Calculates gradient of model parameters wrt. the model parameters. + :param x: A matrix representing the features $x_i$. + :param y: A matrix representing the target values $y_i$. + :returns: A tuple where: \ + - first element is an array with the gradients of the model. \ + - second element is the input to the model as a grad parameters. \ + This can be used for further differentiation. """ pass @@ -47,6 +62,11 @@ def hessian( y: TensorType, progress: bool = False, ) -> TensorType: - """Calculates the explicit hessian of model parameters given data ($x$ - and $y$).""" + """Calculates the full Hessian of $L(f(x),y)$ with respect to the model + parameters given data ($x$ and $y$). + :param x: An array representing the features $x_i$. + :param y: An array representing the target values $y_i$. + :returns: the hessian of the model, i.e. the second derivative wrt. the + model parameters. + """ pass diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index c1c7cddc0..819675de7 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -12,7 +12,7 @@ as_tensor, einsum, mvp, - stack_tensors, + stack, ) from .inversion import InversionMethod, solve_hvp @@ -39,11 +39,11 @@ def compute_influence_factors( progress: bool = False, ) -> TensorType: r""" - It calculates influence factors of a model from its training and test - points. Given a test point $z_test = (x_{test}, y_{test})$, a loss + Calculates influence factors of a model for training and test + data. Given a test point $z_test = (x_{test}, y_{test})$, a loss $L(z_{test}, \theta)$ ($\theta$ being the parameters of the model) and the Hessian of the model $H_{\theta}$, influence factors are defined as - $s_{test} = H_{\theta}^{-1} \grad_{\theta} L(z_{test}, \theta)$. They are + $$s_{test} = H_{\theta}^{-1} \grad_{\theta} L(z_{test}, \theta).$$. They are used for efficient influence calculation. This method first (implicitly) calculates the Hessian and then (explicitly) finds the influence factors for the model using the given inversion method. The @@ -148,7 +148,7 @@ def _compute_influences_pert( ) all_pert_influences.append(perturbation_influences.reshape((-1, *x[i].shape))) - return stack_tensors(all_pert_influences, axis=1) + return stack(all_pert_influences, axis=1) influence_type_registry = { diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 0172023b1..92e7b9a5a 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -77,7 +77,7 @@ def solve_hvp( progress, ), dtype=x.dtype, - ensure=False, + warn=False, ) else: raise ValueError(f"Unknown inversion method: {inversion_method}") diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 5fc0f93a6..b41819e7f 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -46,7 +46,7 @@ def analytical_linear_influences( :param y_test: An array of shape (N, L) containing the targets of the test set. :param influence_type: the type of the influence. - :param hessian_retularization: regularization value for the hessian + :param hessian_regularization: regularization value for the hessian :returns: An array of shape (B, C) with the influences of the training points on the test points if influence_type is "up", an array of shape (K, L, M) if influence_type is "perturbation". From 103435d8102aebe4d0530eed34d016336cfa10d4 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 9 Mar 2023 11:31:42 +0100 Subject: [PATCH 034/436] minor changes --- src/pydvl/influence/frameworks/twice_differentiable.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index 9b8f7f35b..a097371d5 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -67,6 +67,6 @@ def hessian( :param x: An array representing the features $x_i$. :param y: An array representing the target values $y_i$. :returns: the hessian of the model, i.e. the second derivative wrt. the - model parameters. + model parameters. """ pass From 7634a1014795ba3ba4aedc202ddcf68382aa2583 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 9 Mar 2023 11:40:00 +0100 Subject: [PATCH 035/436] minor change --- src/pydvl/influence/frameworks/twice_differentiable.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index a097371d5..e30572fbc 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -66,7 +66,6 @@ def hessian( parameters given data ($x$ and $y$). :param x: An array representing the features $x_i$. :param y: An array representing the target values $y_i$. - :returns: the hessian of the model, i.e. the second derivative wrt. the - model parameters. + :returns: the hessian of the model, i.e. the second derivative wrt. the model parameters. """ pass From adee6ce4ef12181d9d768a08ab0f51561f69a302 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 9 Mar 2023 11:53:50 +0100 Subject: [PATCH 036/436] fix docstrings --- src/pydvl/influence/frameworks/torch_differentiable.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 46d26fb54..b2bd4e738 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -203,8 +203,7 @@ def hessian( """Calculates the explicit hessian of model parameters given data ($x$ and $y$). :param x: A matrix [NxD] representing the features $x_i$. :param y: A matrix [NxK] representing the target values $y_i$. - :returns: the hessian of the model, i.e. the second derivative wrt. the - model parameters. + :returns: the hessian of the model, i.e. the second derivative wrt. the model parameters. """ grad_xy, _ = self.grad(x, y) backprop_on = [ From f1fb97243923ace57edab9508a50b8809594781c Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 4 Apr 2023 13:55:34 +0200 Subject: [PATCH 037/436] implement cg in pytorch --- src/pydvl/influence/frameworks/__init__.py | 2 + .../frameworks/torch_differentiable.py | 63 +++++++++++++++++++ src/pydvl/influence/inversion.py | 33 +--------- 3 files changed, 67 insertions(+), 31 deletions(-) diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index f4a679a29..5ff207700 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -18,6 +18,7 @@ einsum, identity_tensor, mvp, + solve_batch_cg, solve_linear, stack, ) @@ -33,6 +34,7 @@ "TensorType", "ModelType", "solve_linear", + "solve_batch_cg", "as_tensor", "stack", "einsum", diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index b2bd4e738..d852dc97a 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -31,6 +31,69 @@ def solve_linear(matrix: torch.Tensor, b: torch.Tensor): return torch.linalg.solve(matrix, b) +def solve_batch_cg( + hvp: Callable[[torch.Tensor], torch.Tensor], b: torch.Tensor, progress: bool = True +): + """ + Given a callable Hessian vector product (A) and a batch of vectors, it uses + conjugate gradient to calculate the solution. More precisely, it finds x + s.t. $Ax = y$ for each $y$ in ``batch_y``. For more info: + https://en.wikipedia.org/wiki/Conjugate_gradient_method + + :param hvp: a Callable Hvp, operating with tensors of size N + :param batch_y: a matrix of shape [PxN], with P the size of the batch. + :param progress: True, iff progress shall be printed. + + :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$. + """ + batch_cg = torch.zeros_like(b) + for idx, y in enumerate(maybe_progress(b, progress, desc="Conjugate gradient")): + y_cg, _ = solve_cg(hvp, y) + batch_cg[idx] = y_cg + return batch_cg + + +def solve_cg(hvp, y, x0=None, rtol=1e-7, atol=1e-7, maxiter=None): + """Conjugate gradient solver for the Hessian vector product + + :param hvp: a Callable Hvp, operating with tensors of size N + :param y: a tensor of shape [N] + :param x0: initial guess for hvp + :param rtol: maximum relative tolerance of result + :param atol: absolute tolerance of result + :param maxiter: maximum number of iterations. If None, defaults to 10*len(y) + """ + if x0 is None: + x0 = y + if maxiter is None: + maxiter = len(y) * 10 + + y_norm = torch.sum(torch.matmul(y, y)).item() + stopping_val = max([rtol**2 * y_norm, atol**2]) + + x = x0 + p = r = (y - hvp(x)).squeeze() + gamma = torch.sum(torch.matmul(r, r)).item() + optimal = False + + for k in range(maxiter): + Ap = hvp(p).squeeze() + alpha = gamma / torch.sum(torch.matmul(p, Ap)).item() + x += alpha * p + r -= alpha * Ap + gamma_ = torch.sum(torch.matmul(r, r)).item() + beta = gamma_ / gamma + gamma = gamma_ + p = r + beta * p + + if gamma < stopping_val: + optimal = True + break + + info = {"niter": k, "optimal": optimal} + return x, info + + def as_tensor(a: Any, warn=True, **kwargs): """Converts an array into a torch tensor diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 92e7b9a5a..ae0a31d57 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -16,6 +16,7 @@ as_tensor, identity_tensor, mvp, + solve_batch_cg, solve_linear, ) @@ -69,36 +70,6 @@ def solve_hvp( grad_xy, _ = model.grad(x, y) backprop_on = model.parameters() reg_hvp = lambda v: mvp(grad_xy, v, backprop_on) + lam * v - hvp_dimensions = model.num_params() - return as_tensor( - conjugate_gradient( - LinearOperator((hvp_dimensions, hvp_dimensions), matvec=reg_hvp), - b, - progress, - ), - dtype=x.dtype, - warn=False, - ) + return solve_batch_cg(reg_hvp, b, progress) else: raise ValueError(f"Unknown inversion method: {inversion_method}") - - -def conjugate_gradient( - A: LinearOperator, batch_y: TensorType, progress: bool = False -) -> NDArray: - """ - Given a matrix and a batch of vectors, it uses conjugate gradient to calculate the solution - to $Ax = y$ for each $y$ in ``batch_y``. For more info: - https://en.wikipedia.org/wiki/Conjugate_gradient_method - - :param A: a real, symmetric and positive-definite matrix of shape [NxN] - :param batch_y: a matrix of shape [PxN], with P the size of the batch. - :param progress: True, iff progress shall be printed. - - :return: A matrix of shape [PxN] with each line being a solution of $Ax=b$. - """ - batch_cg = [] - for y in maybe_progress(batch_y, progress, desc="Conjugate gradient"): - y_cg, _ = cg(A, y, atol="legacy") - batch_cg.append(y_cg) - return np.asarray(batch_cg) From b9755b78b2e673ef416e0368c1caf5233e05c4e2 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 4 Apr 2023 17:06:23 +0200 Subject: [PATCH 038/436] WIP lissa --- src/pydvl/influence/frameworks/__init__.py | 2 ++ .../influence/frameworks/torch_differentiable.py | 13 ++++++++++++- src/pydvl/influence/inversion.py | 11 +++++------ 3 files changed, 19 insertions(+), 7 deletions(-) diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index 5ff207700..527d3622e 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -20,6 +20,7 @@ mvp, solve_batch_cg, solve_linear, + solve_lissa, stack, ) @@ -35,6 +36,7 @@ "ModelType", "solve_linear", "solve_batch_cg", + "solve_lissa", "as_tensor", "stack", "einsum", diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index d852dc97a..878fbd29a 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -64,7 +64,7 @@ def solve_cg(hvp, y, x0=None, rtol=1e-7, atol=1e-7, maxiter=None): :param maxiter: maximum number of iterations. If None, defaults to 10*len(y) """ if x0 is None: - x0 = y + x0 = torch.clone(y) if maxiter is None: maxiter = len(y) * 10 @@ -94,6 +94,17 @@ def solve_cg(hvp, y, x0=None, rtol=1e-7, atol=1e-7, maxiter=None): return x, info +def solve_lissa(model, x, y, b, lam, maxiter=1000, damp=0, scale=10): + h_estimate = torch.clone(b) + for i in range(maxiter): + # for x_i, y_i in zip(x, y): + # grad_xy, _ = model.grad(x_i.unsqueeze(dim=0), y_i.unsqueeze(dim=0)) + grad_xy, _ = model.grad(x, y) + reg_hvp = lambda v: mvp(grad_xy, v, model.parameters()) + lam * v + h_estimate = b + (1 - damp) * h_estimate - reg_hvp(h_estimate) / scale + return h_estimate / scale + + def as_tensor(a: Any, warn=True, **kwargs): """Converts an array into a torch tensor diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index ae0a31d57..fa0215283 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -4,20 +4,15 @@ import logging from enum import Enum -import numpy as np -from numpy.typing import NDArray -from scipy.sparse.linalg import LinearOperator, cg - -from ..utils import maybe_progress from .frameworks import ( ModelType, TensorType, TwiceDifferentiable, - as_tensor, identity_tensor, mvp, solve_batch_cg, solve_linear, + solve_lissa, ) __all__ = ["solve_hvp"] @@ -32,6 +27,7 @@ class InversionMethod(str, Enum): Direct = "direct" Cg = "cg" + Lissa = "lissa" def solve_hvp( @@ -54,6 +50,7 @@ def solve_hvp( :param inversion_method: :param model: A model wrapped in the TwiceDifferentiable interface. :param x: An array containing the features of the input data points. + :param y: labels for x :param b: :param lam: regularization of the hessian :param progress: If True, display progress bars. @@ -71,5 +68,7 @@ def solve_hvp( backprop_on = model.parameters() reg_hvp = lambda v: mvp(grad_xy, v, backprop_on) + lam * v return solve_batch_cg(reg_hvp, b, progress) + elif inversion_method == InversionMethod.Lissa: + return solve_lissa(model, x, y, b, lam) else: raise ValueError(f"Unknown inversion method: {inversion_method}") From ca7b50fde674a7ed935baab6e87a4ccfa4ea90f9 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 5 Apr 2023 09:33:36 +0200 Subject: [PATCH 039/436] iterative solver - include lissa --- src/pydvl/influence/frameworks/__init__.py | 2 - .../frameworks/torch_differentiable.py | 100 ++++++++++++++---- src/pydvl/influence/general.py | 6 ++ src/pydvl/influence/inversion.py | 39 +++++-- tests/influence/test_influences.py | 61 +++++++++-- 5 files changed, 170 insertions(+), 38 deletions(-) diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index 527d3622e..521736fb1 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -16,7 +16,6 @@ from .torch_differentiable import ( as_tensor, einsum, - identity_tensor, mvp, solve_batch_cg, solve_linear, @@ -40,7 +39,6 @@ "as_tensor", "stack", "einsum", - "identity_tensor", "mvp", ] ) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 878fbd29a..62cc0b702 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -2,7 +2,7 @@ Contains all parts of pyTorch based machine learning model. """ import logging -from typing import Any, Callable, List, Sequence, Tuple +from typing import Any, Callable, Dict, List, Sequence, Tuple import numpy as np import torch @@ -26,29 +26,60 @@ def flatten_gradient(grad): return torch.cat([el.reshape(-1) for el in grad]) -def solve_linear(matrix: torch.Tensor, b: torch.Tensor): - """Computes the solution of a square system of linear equations""" - return torch.linalg.solve(matrix, b) +def solve_linear( + model: TwiceDifferentiable, + x: torch.Tensor, + y: torch.Tensor, + b: torch.Tensor, + lam: float = 0, + progress: bool = True, +): + """Computes the solution of a square system of linear equations + + :param model: A model wrapped in the TwiceDifferentiable interface. + :param x: An array containing the features of the input data points. + :param y: labels for x + :param b: + :param lam: regularization of the hessian + :param progress: If True, display progress bars. + + :return: An array that solves the inverse problem, + i.e. it returns $x$ such that $Ax = b$ + """ + matrix = model.hessian(x, y, progress) + lam * identity_tensor(model.num_params()) + return torch.linalg.solve(matrix, b.T).T def solve_batch_cg( - hvp: Callable[[torch.Tensor], torch.Tensor], b: torch.Tensor, progress: bool = True + model: TwiceDifferentiable, + x: torch.Tensor, + y: torch.Tensor, + b: torch.Tensor, + lam: float = 0, + inversion_method_kwargs: Dict[str, Any] = {}, + progress: bool = True, ): """ - Given a callable Hessian vector product (A) and a batch of vectors, it uses - conjugate gradient to calculate the solution. More precisely, it finds x - s.t. $Ax = y$ for each $y$ in ``batch_y``. For more info: - https://en.wikipedia.org/wiki/Conjugate_gradient_method - - :param hvp: a Callable Hvp, operating with tensors of size N - :param batch_y: a matrix of shape [PxN], with P the size of the batch. - :param progress: True, iff progress shall be printed. + It uses conjugate gradient to calculate the solution of a linear equation. + More precisely, it finds x s.t. $Ax = y$. For + more info: https://en.wikipedia.org/wiki/Conjugate_gradient_method + + :param model: A model wrapped in the TwiceDifferentiable interface. + :param x: An array containing the features of the input data points. + :param y: labels for x + :param b: + :param lam: regularization of the hessian + :param inversion_method_kwargs: kwargs to pass to the inversion method + :param progress: If True, display progress bars. :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$. """ + grad_xy, _ = model.grad(x, y) + backprop_on = model.parameters() + reg_hvp = lambda v: mvp(grad_xy, v, backprop_on) + lam * v batch_cg = torch.zeros_like(b) for idx, y in enumerate(maybe_progress(b, progress, desc="Conjugate gradient")): - y_cg, _ = solve_cg(hvp, y) + y_cg, _ = solve_cg(reg_hvp, y, **inversion_method_kwargs) batch_cg[idx] = y_cg return batch_cg @@ -94,11 +125,44 @@ def solve_cg(hvp, y, x0=None, rtol=1e-7, atol=1e-7, maxiter=None): return x, info -def solve_lissa(model, x, y, b, lam, maxiter=1000, damp=0, scale=10): +def solve_lissa( + model, + x, + y, + b, + lam, + progress: bool = True, + maxiter: int = 1000, + damp: float = 0, + scale: float = 10, +): + """ + It uses LISSA, Linear time Stochastic Second-Order Algorithm, to approximate + the solution of a linear equation. + More precisely, it finds x s.t. $Ax = y$. For + more info: https://en.wikipedia.org/wiki/Conjugate_gradient_method. + This is done by iteratively approximating A through + $$ + A^{-1}_{j+1} y = y + (I - A) \ A^{-1}_j y + $$ + where I is the identity matrix. Additional damping and scaling factors are + applied to help convergence. More info can be found in + :footcite:t:`koh_understanding_2017` + + :param model: A model wrapped in the TwiceDifferentiable interface. + :param x: An array containing the features of the input data points. + :param y: labels for x + :param b: + :param lam: regularization of the hessian + :param maxiter: maximum number of iterations, + :param damp: damping factor, defaults to 0 for no damping + :param scale: scaling factor, defaults to 10 + :param progress: If True, display progress bars. + + :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$. + """ h_estimate = torch.clone(b) - for i in range(maxiter): - # for x_i, y_i in zip(x, y): - # grad_xy, _ = model.grad(x_i.unsqueeze(dim=0), y_i.unsqueeze(dim=0)) + for i in maybe_progress(range(maxiter), progress, desc="Lissa"): grad_xy, _ = model.grad(x, y) reg_hvp = lambda v: mvp(grad_xy, v, model.parameters()) + lam * v h_estimate = b + (1 - damp) * h_estimate - reg_hvp(h_estimate) / scale diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 819675de7..10555df65 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -3,6 +3,7 @@ models, as introduced in :footcite:t:`koh_understanding_2017`. """ from enum import Enum +from typing import Any, Dict from ..utils import maybe_progress from .frameworks import ( @@ -35,6 +36,7 @@ def compute_influence_factors( x_test: TensorType, y_test: TensorType, inversion_method: InversionMethod, + inversion_method_kwargs: Dict[str, Any] = {}, lam: float = 0, progress: bool = False, ) -> TensorType: @@ -57,6 +59,7 @@ def compute_influence_factors( :param y_test: An array of shape [NxL] containing the targets of the test set of data points. :param inversion_func: function to use to invert the product of hvp (hessian vector product) and the gradient of the loss (s_test in the paper). + :param inversion_method_kwargs: kwargs to pass to the inversion method :param lam: regularization of the hessian :param progress: If True, display progress bars. :returns: An array of size (N, D) containing the influence factors for each @@ -75,6 +78,7 @@ def compute_influence_factors( y, test_grads, lam, + inversion_method_kwargs, progress, ) @@ -165,6 +169,7 @@ def compute_influences( y_test: TensorType, progress: bool = False, inversion_method: InversionMethod = InversionMethod.Direct, + inversion_method_kwargs: Dict[str, Any] = {}, influence_type: InfluenceType = InfluenceType.Up, hessian_regularization: float = 0, ) -> TensorType: @@ -208,6 +213,7 @@ def compute_influences( x_test, y_test, inversion_method, + inversion_method_kwargs=inversion_method_kwargs, lam=hessian_regularization, progress=progress, ) diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index fa0215283..1f420fc24 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -3,13 +3,12 @@ """ import logging from enum import Enum +from typing import Any, Dict from .frameworks import ( ModelType, TensorType, TwiceDifferentiable, - identity_tensor, - mvp, solve_batch_cg, solve_linear, solve_lissa, @@ -37,6 +36,7 @@ def solve_hvp( y: TensorType, b: TensorType, lam: float = 0, + inversion_method_kwargs: Dict[str, Any] = {}, progress: bool = False, ) -> TensorType: """ @@ -53,6 +53,7 @@ def solve_hvp( :param y: labels for x :param b: :param lam: regularization of the hessian + :param inversion_method_kwargs: kwargs to pass to the inversion method :param progress: If True, display progress bars. :return: An array that solves the inverse problem, @@ -60,15 +61,33 @@ def solve_hvp( """ if inversion_method == InversionMethod.Direct: return solve_linear( - model.hessian(x, y, progress) + lam * identity_tensor(model.num_params()), - b.T, - ).T + model, + x, + y, + b, + lam, + **inversion_method_kwargs, + progress=progress, + ) elif inversion_method == InversionMethod.Cg: - grad_xy, _ = model.grad(x, y) - backprop_on = model.parameters() - reg_hvp = lambda v: mvp(grad_xy, v, backprop_on) + lam * v - return solve_batch_cg(reg_hvp, b, progress) + return solve_batch_cg( + model, + x, + y, + b, + lam, + **inversion_method_kwargs, + progress=progress, + ) elif inversion_method == InversionMethod.Lissa: - return solve_lissa(model, x, y, b, lam) + return solve_lissa( + model, + x, + y, + b, + lam, + **inversion_method_kwargs, + progress=progress, + ) else: raise ValueError(f"Unknown inversion method: {inversion_method}") diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index b41819e7f..d9e03119b 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -80,7 +80,6 @@ def analytical_linear_influences( INFLUENCE_TRAINING_SET_SIZE: List[int] = [50, 30] INFLUENCE_TEST_SET_SIZE: List[int] = [20] INFLUENCE_DIMENSIONS: List[Tuple[int, int]] = [ - (10, 10), (3, 20), ] HESSIAN_REGULARIZATION: List[float] = [0, 1] @@ -161,10 +160,36 @@ def test_influence_linear_model( inversion_method="cg", hessian_regularization=hessian_reg, ).numpy() + + lissa_influences = compute_influences( + TorchTwiceDifferentiable(linear_layer, loss), + *train_data, + *test_data, + progress=True, + influence_type=influence_type, + inversion_method="lissa", + inversion_method_kwargs={ + "maxiter": 1000, + "scale": 1, + }, + hessian_regularization=hessian_reg, + ).numpy() assert np.logical_not(np.any(np.isnan(direct_influences))) assert np.logical_not(np.any(np.isnan(cg_influences))) assert np.allclose(direct_influences, analytical_influences, rtol=1e-7) assert np.allclose(cg_influences, analytical_influences, rtol=1e-1) + upper_quantile_mask = lissa_influences > np.quantile(lissa_influences, 0.9) + assert np.allclose( + lissa_influences[upper_quantile_mask], + analytical_influences[upper_quantile_mask], + rtol=1e-1, + ) + lower_quantile_mask = lissa_influences < np.quantile(lissa_influences, 0.1) + assert np.allclose( + lissa_influences[lower_quantile_mask], + analytical_influences[lower_quantile_mask], + rtol=1e-1, + ) conv3d_nn = nn.Sequential( @@ -253,7 +278,15 @@ def test_influences_nn( y_test = torch.rand((test_data_len, output_dim)) nn_architecture.eval() - multiple_influences = [] + inversion_method_kwargs = { + "direct": {}, + "cg": {}, + "lissa": { + "maxiter": 6, + "scale": 100, + }, + } + multiple_influences = {} for inversion_method in InversionMethod: influences = compute_influences( TorchTwiceDifferentiable(nn_architecture, loss), @@ -264,17 +297,29 @@ def test_influences_nn( progress=True, influence_type=influence_type, inversion_method=inversion_method, + inversion_method_kwargs=inversion_method_kwargs[inversion_method], hessian_regularization=hessian_reg, ).numpy() assert not np.any(np.isnan(influences)) - multiple_influences.append(influences) + multiple_influences[inversion_method] = influences + if influence_type == InfluenceType.Up: - assert np.allclose(*multiple_influences, rtol=1e-3) - assert influences.shape == (test_data_len, batch_size) + for infl_type, influences in multiple_influences.items(): + if infl_type == "direct": + continue + assert np.allclose( + multiple_influences["direct"], influences, rtol=1e-2 + ), f"Failed method {infl_type}" + assert influences.shape == (test_data_len, batch_size) elif influence_type == InfluenceType.Perturbation: - assert np.allclose(*multiple_influences, rtol=1e-1) - assert influences.shape == (test_data_len, batch_size, *input_dim) + for infl_type, influences in multiple_influences.items(): + if infl_type == "direct": + continue + assert np.allclose( + multiple_influences["direct"], influences, rtol=1e-1 + ), f"Failed method {infl_type}" + assert influences.shape == (test_data_len, batch_size, *input_dim) else: raise ValueError(f"Unknown influence type: {influence_type}") - # check that influences are not all equal + # check that influences are not all constant assert not np.all(influences == influences.item(0)) From a7f9b4ac5ad19cff195401a4f16d1821e076979c Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 5 Apr 2023 15:28:17 +0200 Subject: [PATCH 040/436] included data loaders --- notebooks/influence_wine.ipynb | 176 +++++++++++++----- notebooks/support/torch.py | 16 +- src/pydvl/influence/frameworks/__init__.py | 3 + .../frameworks/torch_differentiable.py | 121 +++++++----- src/pydvl/influence/general.py | 126 ++++++------- src/pydvl/influence/inversion.py | 13 +- tests/influence/test_influences.py | 58 ++++-- 7 files changed, 314 insertions(+), 199 deletions(-) diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index 98b516c9b..55308e940 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -48,8 +48,11 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/fabio/.local/lib/python3.8/site-packages/requests/__init__.py:109: RequestsDependencyWarning: urllib3 (1.26.9) or chardet (5.1.0)/charset_normalizer (2.0.12) doesn't match a supported version!\n", - " warnings.warn(\n" + "/Users/fabio/.local/lib/python3.8/site-packages/torchvision/io/image.py:13: UserWarning: Failed to load image Python extension: dlopen(/Users/fabio/.local/lib/python3.8/site-packages/torchvision/image.so, 6): Symbol not found: __ZN3c106detail19maybe_wrap_dim_slowExxb\n", + " Referenced from: /Users/fabio/.local/lib/python3.8/site-packages/torchvision/image.so\n", + " Expected in: /Users/fabio/.local/lib/python3.8/site-packages/torch/lib/libc10.dylib\n", + " in /Users/fabio/.local/lib/python3.8/site-packages/torchvision/image.so\n", + " warn(f\"Failed to load image Python extension: {e}\")\n" ] } ], @@ -69,7 +72,8 @@ "from pydvl.influence import compute_influences, TorchTwiceDifferentiable\n", "from pydvl.utils.dataset import load_wine_dataset\n", "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, f1_score\n", - "from torch.optim import Adam, lr_scheduler" + "from torch.optim import Adam, lr_scheduler\n", + "from torch.utils.data import DataLoader" ] }, { @@ -159,6 +163,27 @@ ")" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "5de58672", + "metadata": {}, + "source": [ + "and let's wrap it in a pytorch data loader" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "816f688d", + "metadata": {}, + "outputs": [], + "source": [ + "train_data_loader = DataLoader(list(zip(*train_data)), batch_size=32, shuffle=False)\n", + "val_data_loader = DataLoader(list(zip(*val_data)), batch_size=32, shuffle=False)\n", + "test_data_loader = DataLoader(list(zip(*test_data)), batch_size=32, shuffle=False)" + ] + }, { "cell_type": "markdown", "id": "a018e72c", @@ -171,14 +196,14 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "00dc59af", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "70d232738d66467ea8e5955b62a3f557", + "model_id": "7271779863904a54bedbfd1344d2de2e", "version_major": 2, "version_minor": 0 }, @@ -191,9 +216,8 @@ } ], "source": [ - "feature_dimension = train_data[0].shape[1]\n", - "unique_classes = np.unique(np.concatenate((train_data[1], test_data[1])))\n", - "num_classes = len(unique_classes)\n", + "feature_dimension = 13\n", + "num_classes = 3\n", "network_size = [16, 16]\n", "layers_size = [feature_dimension, *network_size, num_classes]\n", "num_epochs = 300\n", @@ -209,10 +233,8 @@ "\n", "losses = fit_torch_model(\n", " model=nn_model,\n", - " x_train=train_data[0],\n", - " y_train=train_data[1],\n", - " x_val=val_data[0],\n", - " y_val=val_data[1],\n", + " train_data=train_data_loader,\n", + " val_data=val_data_loader,\n", " loss=F.cross_entropy,\n", " optimizer=optimizer,\n", " scheduler=scheduler,\n", @@ -231,13 +253,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "f4b57b77", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7MAAAHmCAYAAAChwtkCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAABOu0lEQVR4nO3deZxcZZ3v8e+vqnpN70vS6e4knX2FEBJ2RFYFL+J2dVgUdFxnLl6X8TqOK3hn5s54GfWOirsDqCOiIiqDioiAyBqWhASSkD2dvZPu9L5U13P/OFXd1d3VW1JVp6r783696nWqnuc5p35JypJvPec8x5xzAgAAAAAgmwT8LgAAAAAAgMkizAIAAAAAsg5hFgAAAACQdQizAAAAAICsQ5gFAAAAAGQdwiwAAAAAIOuE/C7gVFRVVbmGhga/ywAAAAAApMBzzz3X5JyrTtSX1WG2oaFB69ev97sMAAAAAEAKmNme0fo4zRgAAAAAkHUIswAAAACArEOYBQAAAABkHcIsAAAAACDrZPUCUAAAAACQDfr6+tTY2Kju7m6/S8k4+fn5qq+vV05OzqT2I8wCAAAAQIo1NjaquLhYDQ0NMjO/y8kYzjkdO3ZMjY2Nmj9//qT25TRjAAAAAEix7u5uVVZWEmSHMTNVVlae1Iw1YRYAAAAA0oAgm9jJ/r0QZgEAAAAAWYcwCwAAAAA4ZVdddZXuvPPOtL0fC0ABAAAAwDRVVFQ08Lyzs1N5eXkKBoOSpG9/+9u64YYbJnys3/72t0mvbyyEWQAAAACYptrb2weeNzQ06Hvf+54uv/zyEePC4bBCocyKj5xmDAAAAAAY4pFHHlF9fb3+9V//VTU1NXrPe96j5uZmXX311aqurlZ5ebmuvvpqNTY2Duxz8cUX63vf+54k6Y477tCFF16oT3ziEyovL9f8+fOTPnNLmAUAAAAAjHDo0CEdP35ce/bs0Xe+8x1FIhG95z3v0Z49e7R3714VFBTo5ptvHnX/p59+WkuXLlVTU5M++clP6r3vfa+cc0mrL7PmiQEAAABgirv1N5v18oHWlL7HitoSfeGNK0/pGIFAQLfeeqvy8vIkSQUFBXrb29420P+Zz3xGl1xyyaj7z5s3T+9///slSTfddJP+9m//VocPH1ZNTc0p1RVDmAUAAAAAjFBdXa38/PyB152dnfrYxz6m3/3ud2pubpYktbW1qb+/f2DRqHjxobWwsFDS0Gt0TxVhNpV6O6T+Xqmg3O9KAAAAAGSIU50xTRczG/L63/7t37R161Y9/fTTqqmp0Ysvvqg1a9Yk9dThyeCa2VTp65K+tEB68na/KwEAAACAU9bW1qaCggKVlZXp+PHjuvXWW32thzCbKjkF0szl0p4n/K4EAAAAAE7ZRz/6UXV1damqqkrnnnuurrzySl/rMb+mhJNh3bp1bv369X6XMbrff0Z65rvSp/ZKOfnjjwcAAAAwJb3yyitavny532VkrNH+fszsOefcukT7MDObSvMukPp7pP3P+V0JAAAAAEwphNlUmnuuJONUYwAAAABIMsJsKhVWSLNWSnse97sSAAAAAJhSCLMptH73cbXOOkva94zU3+d3OQAAAAAwZRBmU+REV5/e9f1n9Mvj86W+TunAi36XBAAAAABTBmE2RUoLcnTt2XN0+85qr4FTjQEAAAAgaQizKfS+1yzQMZXpaN48FoECAAAAgCRKS5g1sx+Y2REz2zRK/zIze9LMeszsE+moKR3qygr05jV1+mPXYkX2PClF+v0uCQAAAACmhHTNzN4h6cox+o9L+p+SbktLNWn0odcu0JP9SxXobZMObvC7HAAAAABICjPT9u3bfXv/tIRZ59xj8gLraP1HnHPPSppyS/4umlmsnEUXS5J6tj3kbzEAAAAAEOfKK6/U5z//+RHtv/rVr1RTU6NwOOxDVRPDNbNpcOMVZ+ulSIOOPn+/36UAAAAAwICbbrpJP/rRj+ScG9L+wx/+UDfccINCoZBPlY0v68KsmX3AzNab2fqjR4/6Xc6EnF5fpkPVF6qm9SU1HjzodzkAAAAAIEl685vfrGPHjunPf/7zQFtzc7Puv/9+XXPNNTrvvPNUVlam2bNn6+abb1Zvb6+P1Q6VdWHWOfcd59w659y66upqv8uZsDMve4dCFtEDv/qJ36UAAAAAgCSpoKBA73jHO3TXXXcNtN1zzz1atmyZioqK9JWvfEVNTU168skn9cc//lG33367j9UOlblzxlNM5dIL1BMsUmnjo3pix406f2GV3yUBAAAA8MNvPyUdeim171FzmnTVv0xo6E033aSrr75aX//615Wfn6+77rpLN910k9auXTswpqGhQR/84Af16KOP6qMf/WiKip6cdN2a5yeSnpS01Mwazey9ZvYhM/tQtL/GzBolfVzSZ6NjStJRW9oEQwotvlSXhjbq1l9tVm844ndFAAAAAKALL7xQVVVVuu+++7Rjxw4988wzuv7667Vt2zZdffXVqqmpUUlJiT796U+rqanJ73IHpGVm1jl33Tj9hyTVp6MWPwWXvE7VW34tO/qyvv5wjT7+uqV+lwQAAAAg3SY4Y5pON954o+666y5t3bpVr3/96zVr1ixdf/31WrNmjX7yk5+ouLhYX/3qV/Xzn//c71IHZN01s1lt0WWSpJvn7NI3HtmhDfta/K0HAAAAAOSF2Yceekjf/e53ddNNN0mS2traVFJSoqKiIm3ZskXf/OY3fa5yKMJsOpXUSrNW6cq8lzSzOE8fv+dFdff1+10VAAAAgGmuoaFB559/vjo6OnTNNddIkm677Tb953/+p4qLi/X+979ff/VXf+VzlUOxAFS6Lb5CoSe+pq+8dZ6u/dFW/ctvt+iWa1b6XRUAAACAae6RRx4Z8vqiiy7Sli1bhrR98YtfHHg+/N606cbMbLotf6MUCevcvqf01xfM1x1P7Nb9Gw/4XRUAAAAAZBXCbLrVnimVzZVe/pU+ddUyrZ1Xrr//+UZtP9Lmd2UAAAAAkDUIs+lmJq14k7TjT8rta9U3rj9T+TlBfehHz6u9J+x3dQAAAACQFQizfljxZinSJ239rWpK8/W169Zo59F2ffynLyoS8fe8cwAAAADIBoRZP9StlUrqpZfvkySdv6hKn7t6hR58+bBue3Crv7UBAAAASAm/F0zKVCf790KY9cPAqcYPS90nJEnvPr9B1509V7c/skP3Pt/oc4EAAAAAkikYDKqvr8/vMjJSX1+fQqHJ32iHMOuXlW+W+nulbb+XJJmZvvimlTp3QYU+9YuX9Nye4/7WBwAAACBpysrKdPjwYUUiEb9LySiRSESHDx9WaWnppPe1bJ7qXrdunVu/fr3fZZycSET66iqp5jTp+p8ONDd39Oott/9F7T1h3fc/LlB9eaGPRQIAAABIhkgkosbGRnV0dPhdSsaZMWOG6uvrFQiMnGs1s+ecc+sS7Tf5uVwkRyAgnfZ26YmvSW2HpeJZkqTyGbn63k1n6S23/0Xvu3O9fvE352tGHv9MAAAAQDYLBAKaO3eu32VMKZxm7Kc175Rcv7Tx7iHNi2YW6RvXn6lXj7TrI3ezwjEAAAAADEeY9VPVYmnOOdILP5KGne590ZJqfe6/LddDrxzWl37PCscAAAAAEI8w67c175SatkmNI6/9ven8Bt1wzlx969Ed+sVzrHAMAAAAADGEWb+tfIuUUyi98MMRXWamW65ZqfMXVuof7mWFYwAAAACIIcz6La/Yu+fspnul3s4R3TnBgG6/4UzVluXrA3c9p8bmkWMAAAAAYLohzGaCNe+Uetukl+9L2F1W6K1w3Nsf0fvuXK/2nnB66wMAAACADEOYzQTzLpCqlkpPf2vEQlAxi2YW6fYbvBWOP3r3C+pnhWMAAAAA0xhhNhOYSed8UDq4Qdr71KjDXrO4Wp+/eoUeeuWIvvPYzjQWCAAAAACZhTCbKVZfK+WXSk9/c8xhN543T284rUZf/sNWbdp/Ik3FAQAAAEBmIcxmitwZ0pk3Sa/cL7XsG3WYmemf3nyaKmbk6qM/fVHdff1pLBIAAAAAMgNhNpOc/X5JTnr2u2MOK5+Rq9vevlrbj7TrX367JT21AQAAAEAGIcxmkrK50rKrpefulHo7xhz6msXVevf5Dbrjid16bk9zmgoEAAAAgMxAmM00539Y6m6R1v/HuEP/1+uXanZpvj573yaF+yOprw0AAAAAMgRhNtPMOVuaf5H0xL9Lfd1jDp2RF9IX3rhCrxxs1R1P7E5PfQAAAACQAQizmeii/yW1H5Ze+OG4Q1+/skYXL63WV/6wTQdPdKWhOAAAAADwH2E2EzW8RppzjvT4V6Vw75hDzUxfvGaVwhGnf36AxaAAAAAATA+E2UxkJl30Sam1Udp497jD51YW6n2vma/fbDjAvWcBAAAATAuE2Uy16DJp9hnSY7eNOzsrSR+4aKFKC3J024NbU18bAAAAAPiMMJupzKRLPyu17JGev3Pc4aUFOfqbixfqka1H9fTOY2koEAAAAAD8Q5jNZIsul+aeLz32f8e976wk3XReg2aV5OlLv98q51waCgQAAAAAfxBmM5mZdPkXvJWNn/7WuMMLcoP6yGVL9NyeZj285UgaCgQAAAAAfxBmM93cc6UlV0p/+X9SV/O4w9++rl51ZQX69qM701AcAAAAAPiDMJsNLv2c1N0q/fnL4w7NCQb01xfO1zO7j+uFveOHXwAAAADIRoTZbFCzSlp9nXeqcfPucYf/1VlzVJwf0nf/zOwsAAAAgKmJMJstLvucZEHpoVvHHVqUF9I7z52n3206pD3Hxl84CgAAAACyDWE2W5TUSud/WNp8r7TvmXGHv/v8BgUDpu8/visNxQEAAABAehFms8kFH5GKZkm//7Q0zq13ZpXk601n1Ome9fvU0tmbpgIBAAAAID0Is9kkr0i69LNS47PS5l+OO/w9FzSouy+i+17Yn4biAAAAACB9CLPZ5owbpFmrpIdukfq6xxy6srZUp9WV6u5n98mNM5MLAAAAANmEMJttAkHpdf8oteyRnvn2uMOvPXuOthxq04bGE2koDgAAAADSgzCbjRZeIi1+vfTYbVJH05hDr1ldq4KcoH767N40FQcAAAAAqUeYzVav+99Sb4f0yL+MOaw4P0dXnz5bv37xgDp6wmkqDgAAAABSizCbraqXSmvfLa3/gXR025hDrz17jjp6+3X/xgPpqQ0AAAAAUowwm80u/gcpd4b0h8+POezMueVaPLNIP312X5oKAwAAAIDUIsxms6Jq6TUfl7b9Vtr56KjDzExvObNOz+9tUWNzZxoLBAAAAIDUIMxmu3P+RiqdKz34GSnSP+qwq0+rlST918aD6aoMAAAAAFKGMJvtcvKly78gHXpJ2vCTUYfNrSzU6vpS3U+YBQAAADAFEGanglVvk+rWSn/6Z6mve9RhV59eq5f2n9Dupo40FgcAAAAAyUeYnQrMpMu+ILXul577j1GHveH02ZKk/3qJ2VkAAAAA2Y0wO1UseK00/yLpsduknvaEQ+rKCnTm3DL9ZgO36AEAAACQ3QizU8mln5c6m6SnvzXqkKtPr9WWQ23afiRx4AUAAACAbECYnUrmnCUtuUr6y79LXc0Jh/y302fLjFWNAQAAAGQ3wuxUc+lnpZ4T0lPfTNg9qyRfZ8wp08NbDqe5MAAAAABIHsLsVFOzSlr636RnvjPqtbOXLZupDY0ndKRt9JWPAQAAACCTEWanogs/5p1m/PydCbsvXTZLkvTIlqPprAoAAAAAkoYwOxXNOUuad6H0xNelcO+I7uWzizW7NF8PbzniQ3EAAAAAcOoIs1PVaz4mtR2QXrpnRJeZ6ZJlM/XnV4+qJ9zvQ3EAAAAAcGoIs1PVwsukmtOkx78qRSIjui9bNlMdvf16Ztfx9NcGAAAAAKeIMDtVmUkXfFQ69qq0448jus9fWKW8UIBTjQEAAABkJcLsVLb8GmlGtbT+ByO6CnKDumBRlf74yhE553woDgAAAABOHmF2KgvlSmveJW37ndSyb0T3Jctmau/xTu042uFDcQAAAABw8gizU93ad0vOSc/fNaLr4iXVkqTHX+UWPQAAAACyC2F2qiufJy2+wguz/X1DuuZUFGpORYGe2HHMp+IAAAAA4OQQZqeDde+V2g9JWx8Y0XXBwio9tfOY+iNcNwsAAAAgexBmp4PFV0gl9QkXgjpvYaVau8PatP+ED4UBAAAAwMkhzE4HgaB0xvXSzkeltkNDus5fWCVJnGoMAAAAIKsQZqeLVW+T5KSXfzWkubo4T0tmFemJHU3+1AUAAAAAJ4EwO13MXCbNWiVt+sWIrvMXVunZ3cfVE+73oTAAAAAAmDzC7HSy6q3Svqellr1Dmi9YVKXuvohe2NviT10AAAAAMEmE2elk5Vu97eZfDmk+e36FAiY9sZ1TjQEAAABkB8LsdFIxX6pbO+JU49KCHJ1WX8YiUAAAAACyBmF2uln1NungBunYjiHN5y+s1Iv7WtTVy3WzAAAAADIfYXa6WfkWSSZtvndI81kN5QpHnF7c1+JLWQAAAAAwGYTZ6aakVqo7U9r24JDmtXMrJEnrdx/3oyoAAAAAmBTC7HS06HJp/3qpczC4lhbmaMmsIq3f0+xjYQAAAAAwMWkJs2b2AzM7YmabRuk3M/t3M9tuZhvN7Mx01DVtLbpCchFpx8NDmtc1VOj5Pc3qjzifCgMAAACAiUnXzOwdkq4co/8qSYujjw9I+mYaapq+6s6UCiqk7X8c0rxuXrnaesLadrjNp8IAAAAAYGLSEmadc49JGutizDdJust5npJUZmaz01HbtBQISgsvlbY/JEUiA81nNXDdLAAAAIDskCnXzNZJ2hf3ujHaNoKZfcDM1pvZ+qNHj6aluClp0eVSxxHp0MaBpvryAs0szuO6WQAAAAAZL1PC7IQ5577jnFvnnFtXXV3tdznZa9Fl3nb7HwaazExnNVRo/W7CLAAAAIDMlilhdr+kOXGv66NtSJWimdLsM6RXHxrSvHZeufa3dOlAS5c/dQEAAADABGRKmP21pBujqxqfK+mEc+6g30VNeYsulxqfkboGZ2IHrpvlVGMAAAAAGSxdt+b5iaQnJS01s0Yze6+ZfcjMPhQd8oCknZK2S/qupL9NR13T3qLLvVv07H58oGn57GIV5gZZBAoAAABARgul402cc9eN0+8k/Y901II4dWdKwTxp71PS8jdKkkLBgFbXl+mFvS3+1gYAAAAAY8iU04zhh1CeF2j3PjWk+Yy5ZXrlYKu6+/p9KgwAAAAAxkaYne7mnisdfFHq7RxoWl1fpnDE6eWDrf7VBQAAAABjIMxOd3PPkyJh6cDzA01nzCmTJG3Y1+JPTQAAAAAwDsLsdDfnbG+798mBpprSfNWU5OtFwiwAAACADEWYne4KyqXq5SOum109p5SZWQAAAAAZizAL77rZfc9IkcEFn1bPKdPuY51q6ez1sTAAAAAASIwwC++62Z5W6cjLA01n1JdJEqcaAwAAAMhIhFl4M7PSkFONT6svlZm0Yd8Jn4oCAAAAgNERZiGVzZWKa4csAlWcn6NF1UXa0NjiX10AAAAAMArCLCQzb3Z2xCJQZdqwr0XOOZ8KAwAAAIDECLPw1K+TWvdLbYcHmlbPKdOxjl41Nnf5WBgAAAAAjESYhWf2am97aONA05o5ZZJYBAoAAABA5iHMwlNzmrc9+OJA05JZxcoJmjYdYBEoAAAAAJmFMAtPfqlUsUA6uGGgKTcU0NKaYm3e3+pjYQAAAAAwEmEWg2avlg5uHNK0qrZUmw6cYBEoAAAAABmFMItBs1dLLXukruaBppV1pWrp7NP+FhaBAgAAAJA5CLMYFFsEKm52dlVtiSRp8wFONQYAAACQOQizGFQTC7OD180uqylRwKTN+1kECgAAAEDmIMxi0IxKqaR+SJgtyA1q0cwibWJmFgAAAEAGIcxiqNmrh4RZKboIFDOzAAAAADIIYRZDzV4tHdsu9bQNNK2sK9WRth4daev2sTAAAAAAGESYxVCzV0ty0qFNA00rWQQKAAAAQIYhzGKo2IrGhwZXNF4RC7OcagwAAAAgQxBmMVRxjTRjpnTgxYGmkvwcNVQWatN+ZmYBAAAAZAbCLIYyk2atlI68PKR5ZV2pNh9kZhYAAABAZiDMYqSZy6WmbVIkMtC0qrZU+4536URnn4+FAQAAAICHMIuRqpdJfZ1Sy56BpsFFoJidBQAAAOA/wixGql7mbY9uHWiKhdlNhFkAAAAAGYAwi5Gql3rbo68MNFUW5am2NJ/b8wAAAADICIRZjFRQJhXXSke2DGleWVeqTdyeBwAAAEAGIMwisZnLhszMSt4iUDubOtTRE/apKAAAAADwEGaRWPVy6ejQFY1X1pbIOemVg5xqDAAAAMBfhFkkNnOZFO6SWnYPNK2qK5UkTjUGAAAA4DvCLBJLsKLxrJI8VRXlsggUAAAAAN8RZpFYbEXjI4PXzZqZVtaWahNhFgAAAIDPCLNILL9UKqmTjg5b0bi2RK8eblN3X79PhQEAAAAAYRZjqV42ZGZW8q6bDUecth1u86koAAAAACDMYiwzl0tN26TI4CzsqlpvESiumwUAAADgJ8IsRle9TAp3S827B5rmVBSoOD/EisYAAAAAfEWYxegGVjQevG7WWwSqhEWgAAAAAPiKMIvRxVY0bto2pHllbam2HGxVuD/iQ1EAAAAAQJjFWPJLpKJZ0rHtQ5pX1paoJxzRrqYOnwoDAAAAMN0RZjG2ykVS09Awu6K2RJL08kFONQYAAADgD8Isxla5cMTM7MLqIuWGAnqZ62YBAAAA+IQwi7FVLpY6m6Su5oGmnGBAS2cVMzMLAAAAwDeEWYytcpG3PbZjSPOK2SXafKBVzjkfigIAAAAw3RFmMbaqxd626dUhzStqS3S8o1eHW3t8KAoAAADAdEeYxdjK5kkWTLiisSS9fPCEH1UBAAAAmOYIsxhbKFcqb5CODZ2ZXTbbC7Ob93PdLAAAAID0I8xifJWLRlwzW5QXUkNlIYtAAQAAAPAFYRbji4XZSGRI84raEsIsAAAAAF8QZjG+qkVSuEtq3T+keWVtqfYc61Rrd59PhQEAAACYrgizGN/A7XmGrWgcvW52y8G2dFcEAAAAYJojzGJ8ldHb8wy/12xsReMDrGgMAAAAIL0IsxhfcY2UM2PEvWZnFuepqiiX62YBAAAApB1hFuMzkyoXjrjXrJlp+ewSbT5AmAUAAACQXoRZTEzV4hHXzEreqcavHm5XbziSYCcAAAAASA3CLCamcpHUsk/q6x7SvLK2VL39Ee042u5TYQAAAACmI8IsJqZykSQnNe8a0hxb0ZhTjQEAAACkE2EWE1M+39seHxpm51fNUH5OQC8TZgEAAACkEWEWE1OxwNsOm5kNBkzLakr08kFuzwMAAAAgfQizmJjCCimvZMTMrCStrC3Rywda5ZzzoTAAAAAA0xFhFhNjJlXMl47vHNG1orZErd1hNTZ3+VAYAAAAgOmIMIuJK58/4jRjaXARqJcPct0sAAAAgPQgzGLiKhZILXul/vCQ5mU1JQqYWAQKAAAAQNoQZjFxFfOlSFg6sW9Ic0FuUAuqi7g9DwAAAIC0Icxi4mIrGie6bnZ2iV7hNGMAAAAAaUKYxcTF7jWb6LrZ2hLtb+lSS2dvmosCAAAAMB0RZjFxxbOlUP6ot+eRuG4WAAAAQHoQZjFxgYBU3pAwzC5nRWMAAAAAaUSYxeRULEh4zWxVUZ5mleQxMwsAAAAgLQizmJzy+VLzbikSGdG1sraUFY0BAAAApAVhFpNTMV8Kd0nth0Z0rZhdou1H29Xd1+9DYQAAAACmE8IsJqciuqJxgutmV9SWqD/i9Orh9jQXBQAAAGC6Icxicsa4Pc/AisYHT6SzIgAAAADTEGEWk1M2V7JgwkWg5pQXqigvxHWzAAAAAFIubWHWzK40s61mtt3MPpWgf56Z/dHMNprZI2ZWn67aMAnBHKlsTsLTjAMB0/LZxaxoDAAAACDl0hJmzSwo6RuSrpK0QtJ1ZrZi2LDbJN3lnDtd0hcl/Z901IaTMMrteSRvEahXDrYqEnFpLgoAAADAdJKumdmzJW13zu10zvVKulvSm4aNWSHp4ejzPyXoR6Yon+/NzLqRgXVlbak6evu153inD4UBAAAAmC7SFWbrJO2Le90YbYu3QdJbo8/fIqnYzCrTUBsmq2KB1HNC6moe0bUitggUpxoDAAAASKFMWgDqE5Jea2YvSHqtpP2SRtyw1Mw+YGbrzWz90aNH010jpDFvz7N4VpFCAWNFYwAAAAApla4wu1/SnLjX9dG2Ac65A865tzrn1kj6TLStZfiBnHPfcc6tc86tq66uTmHJGFXFAm+b4LrZvFBQi2YWsaIxAAAAgJRKV5h9VtJiM5tvZrmSrpX06/gBZlZlZrF6/kHSD9JUGyarvMHbJrjXrOSdakyYBQAAAJBKaQmzzrmwpJsl/V7SK5Lucc5tNrMvmtk10WEXS9pqZtskzZL0T+moDSchp0Aqrh11ReOVtaU62tajI23daS4MAAAAwHQRmuhAM7tE0m7n3C4zmy3pXyRFJP2Dc+7QePs75x6Q9MCwts/HPf+5pJ9PtB74rGJ+wmtmJWlVdBGozQdaNXNpfjqrAgAAADBNTGZm9nYNLsj0b5Jy5IXZ7yS7KGSBivmj32s2Fmb3swgUAAAAgNSY8MyspDrn3F4zC0l6vaR5knolHUhJZchs5fOljiNST7uUVzSkqzg/R/OrZmjTfq6bBQAAAJAak5mZbTWzWfJum/Oyc6492p6T/LKQ8WIrGjfvTti9srZEmw4wMwsAAAAgNSYTZr8mb1XiH0v6RrTtAklbkl0UssDAvWYTn2q8qq5Ujc1daunsTWNRAAAAAKaLCYdZ59y/Srpc0gXOubujzfslvS8VhSHDlUfD7Ci351lVWypJ3KIHAAAAQEpM6tY8zrltzrkd0sDqxrOdcy+lpDJktoIyqaBijNvzeItAbWIRKAAAAAApMOEwa2aPmtkF0ed/L+luSf9pZp9OVXHIcGPcnqd8Rq7qygq0iZlZAAAAACkwmZnZVZKeij5/v6RLJJ0r6UPJLgpZomLBqGFWklbVlXB7HgAAAAApMZkwG5DkzGyhJHPOveyc2yepPDWlIeOVz5daG6VwT8LuVbWl2tnUobbuvjQXBgAAAGCqm0yYfVzS1yXdJumXkhQNtk0pqAvZoGKB5CJSy96E3avqvEWgXjnYls6qAAAAAEwDkwmz75bUImmjpFuibcsk/b+kVoTsMXB7nsSnGq+sYxEoAAAAAKkRmuhA59wxSZ8e1vZfSa8I2aNigbcdZUXjmcX5mlmcR5gFAAAAkHSTWc04x8xuNbOdZtYd3d5qZrmpLBAZbEa1lFs06r1mJen0+lJtJMwCAAAASLLJnGb8JUmXy1u9eHV0e6mkf01BXcgGZlJ5g9S8e9Qhp9WVacfRdrX3hNNWFgAAAICpbzJh9u2SrnHOPeic2+qce1DSWyS9IzWlISuUN4x5e57T55TKOemlRmZnAQAAACTPZMKsTbId00F5g9SyR4pEEnavri+TJG1sbElbSQAAAACmvsmE2Z9J+o2Zvd7MlpvZlZLuk3RPSipDdihvkMLdUvuhhN0VM3JVX16gjczMAgAAAEiiyYTZT0p6SNI3JD0n6WuS/iSpNwV1IVvEbs8zxnWzq+vLtIGZWQAAAABJNOEw65zrdc593jm3yDlX6JxbLOmfJP1d6spDxisf+16zkreicWNzl46196SpKAAAAABT3WRmZhNx4prZ6a10jmSBMWdmT49dN8stegAAAAAkyamGWckLtJiuQrlSSf2Y95o9rb5UZtLGfYRZAAAAAMkRGm+AmV06RnduEmtBtqpoGHNmtigvpIXVRaxoDAAAACBpxg2zkr4/Tv/eZBSCLFbeIG15YMwhp9eX6rFtTXLOyYwz0wEAAACcmnHDrHNufjoKQRYrny91Nkk9bVJeccIhq+vLdO/z+3XwRLdqywrSXCAAAACAqSYZ18xiuitv8LZjLgJVKknasK8l5eUAAAAAmPoIszh1E7jX7IraEuUGA3qRMAsAAAAgCQizOHWxmdkx7jWbFwpqVV2JntvTnJ6aAAAAAExphFmcuoJyKb9szJlZSVo7r1wb959QT7g/LWUBAAAAmLoIs0iO8oYJhdnecESbD7SmpSQAAAAAUxdhFslRMV9qHv00Y0k6c265JOl5TjUGAAAAcIoIs0iO8gapZa8UGf0U4pkl+ZpTUcB1swAAAABOGWEWyVE+X4qEpRONYw5bO7dc6/c0yzmXpsIAAAAATEWEWSTHBO41K3nXzR5t61Fjc1fKSwIAAAAwdRFmkRwD95od57rZedHrZvdyqjEAAACAk0eYRXKU1EmBnHFnZpfOKtaM3CDXzQIAAAA4JYRZJEcgKJXNlY6PPTMbCgZ0xtwywiwAAACAU0KYRfJM4F6zkrcI1CsHW9XeE055SQAAAACmJsIskmcC95qVpHUNFYo4af3u42koCgAAAMBURJhF8pQ3SN0npK6xTyFe11CunKDpyZ3H0lMXAAAAgCmHMIvkid2eZ5zrZgtzQ1pdX6andhBmAQAAAJwcwiySpzx2e57d4w49b2GlXtp/Qq3dfamtCQAAAMCURJhF8pTP87YTuG72vIWVijjp2V1cNwsAAABg8gizSJ68YmlG9YRmZs+cW67cUEBPcqoxAAAAgJNAmEVylTeMe82sJOXnBHXm3DIWgQIAAABwUgizSK7y+VLzngkNPW9BlV4+2KqWzt4UFwUAAABgqiHMIrnKG6TWRik8fkA9b2GlnJOe5rpZAAAAAJNEmEVyVcyXXEQ6sW/coavnlCo/h+tmAQAAAEweYRbJNcF7zUpSXiiodfMq9JftTamtCQAAAMCUQ5hFcg3ca3b8MCtJFy2p0qtH2nWgpSuFRQEAAACYagizSK6iWVIof0K355GkS5bOlCQ9svVoCosCAAAAMNUQZpFcgYB3qvEEw+yimUWqKyvQn7YeSWlZAAAAAKYWwiySb4L3mpUkM9PFS6v1xPYm9YT7U1sXAAAAgCmDMIvkK5/vzcw6N6HhlyydqY7efq3f3ZzaugAAAABMGYRZJF95g9TXIXVM7DrY8xdVKjcY0COcagwAAABgggizSL6K2IrGuyc0vDA3pHMWVOhPLAIFAAAAYIIIs0i+2L1mJxhmJenipTO1/Ui79h3vTElJAAAAAKYWwiySr2yet53gIlCSdPHSakniVGMAAAAAE0KYRfLl5EvFtZOamV1QNUMNlYV68OXDqasLAAAAwJRBmEVqVMyXmic+M2tmunLVbD2545hOdPalsDAAAAAAUwFhFqlR3jCpmVlJumpVjcIRpz+8wuwsAAAAgLERZpEa5fOltoNSX9eEdzm9vlR1ZQX63aaDKSwMAAAAwFRAmEVqDKxovGfCu5iZXr+yRo+92qT2nnBq6gIAAAAwJRBmkRoD95qd+HWzknTVaTXqDUf08BZWNQYAAAAwOsIsUuMk7jUrSWvnlqu6OI9TjQEAAACMiTCL1CislHKLJ3WvWUkKBEyvWzFLf9pyVF29/SkqDgAAAEC2I8wiNcxOakVjSXrDabPV1dfPqcYAAAAARkWYRepUNEz6mllJOndBpWaV5OmXLzQmvyYAAAAAUwJhFqlT3uCtZhyJTGq3YMD05jV1emTrUTW196SmNgAAAABZjTCL1CmfL/X3ePebnaS3nVmvcMTp1y8eSEFhAAAAALIdYRapc5IrGkvSklnFOq2uVPdyqjEAAACABAizSJ2TvNdszFvPrNOm/a3aeqgtiUUBAAAAmAoIs0id0jmSBU9qZlaSrlldq1DAdO/zzM4CAAAAGIowi9QJ5kil9ZO+12xMZVGeLl46U798Yb/6+ie3iBQAAACAqY0wi9Q6yXvNxlx71hwdaevRg5sPJ60kAAAAANmPMIvUqph/0tfMStIly2ZqTkWB7nxyd/JqAgAAAJD1CLNIrfIGqfOY1N16UrsHA6Ybz23QM7uO65WDJ3cMAAAAAFNP2sKsmV1pZlvNbLuZfSpB/1wz+5OZvWBmG83sDemqDSlUHlvRePdJH+Lt6+qVnxPQnU+c/DEAAAAATC1pCbNmFpT0DUlXSVoh6TozWzFs2Gcl3eOcWyPpWkm3p6M2pNgp3Gs2pqwwV29ZU6f7Xtyvls7epJQFAAAAILula2b2bEnbnXM7nXO9ku6W9KZhY5ykkujzUkkH0lQbUukU7zUbc+N5Derui+ie9fuSUBQAAACAbJeuMFsnKT6FNEbb4t0i6Z1m1ijpAUkfTk9pSKn8Uqmg/JRmZiVp+ewSnbegUt9/fJe6+/qTUxsAAACArJVJC0BdJ+kO51y9pDdI+qGZjajPzD5gZuvNbP3Ro0fTXiROQvn8k77XbLwPX7pIh1t7mJ0FAAAAkLYwu1/SnLjX9dG2eO+VdI8kOeeelJQvqWr4gZxz33HOrXPOrauurk5RuUiqU7zXbMx5Cyu1bl65vvnIDvWEmZ0FAAAAprN0hdlnJS02s/lmlitvgadfDxuzV9JlkmRmy+WFWaZep4KK+dKJfVJ/+JQOY2b6yOWLdfBEt362vjFJxQEAAADIRmkJs865sKSbJf1e0ivyVi3ebGZfNLNrosP+TtL7zWyDpJ9IerdzzqWjPqRYeYMUCUutpx5AL1xUpTVzy/TNR3aoNxw59doAAAAAZKW0XTPrnHvAObfEObfQOfdP0bbPO+d+HX3+snPuAufcaufcGc65B9NVG1IsCbfniTEzfeSyxdrf0qW7n917yscDAAAAkJ0yaQEoTFXl0dvzJGERKEl67ZJqnbegUl/+wzY1d3DfWQAAAGA6Iswi9UpqpUBOUmZmJW929gvXrFBrV5++/IdtSTkmAAAAgOxCmEXqBYJS+TypOTkzs5K0rKZE7zp3nn789B69crA1accFAAAAkB0Is0iPJN2eJ97Hrlii0oIc3fLrzWKtMAAAAGB6IcwiPcrnS8d3S0kMnWWFufpfr1+mp3cd138+w2JQAAAAwHRCmEV6lDdIPSekruakHvbas+boNYur9I/3v6KdR9uTemwAAAAAmYswi/SoiK5onMTrZiUpEDD93/++WrmhgD52zwb19XPvWQAAAGA6IMwiPWL3mk3S7Xni1ZTm65/eskob9rXoaw9vT/rxAQAAAGQewizSo3y+JJOO70zJ4a8+vVZvPbNOX3v4Vf3h5cMpeQ8AAAAAmYMwi/TILZTK5khNqbsv7D+/5TSdVleqj9z9ArfrAQAAAKY4wizSp2pJSsNsfk5Q371xnYrzQ3rfnevV1N6TsvcCAAAA4C/CLNKnaonU9KoUSd0iTbNK8vXdG9epqb1HN/3gGZ3o7EvZewEAAADwD2EW6VO1WOrrlFr3p/RtTq8v07fetVavHm7XjT94Wq3dBFoAAABgqiHMIn2qlnjbFJ5qHHPJ0pn6xg1navOBVr37B88QaAEAAIAphjCL9BkIs6+m5e2uWDFLX7tujTY2ntA7vvWkDrR0peV9AQAAAKQeYRbpM6Nayi9Ny8xszFWnzdYd7zlb+5u79OZv/EWb9p9I23sDAAAASB3CLNLHLOUrGidy4eIq/exvzlMoYHr7t57UPc/uk3MurTUAAAAASC7CLNIrtqJxmi2rKdF9/+MCnTGnTJ/8xUZ95O4X1cZ1tAAAAEDWIswivaoWS+2HpO70n+47syRfP3rfOfq7K5bo/o0H9LqvPKbfbz6U9joAAAAAnDrCLNKraqm3bdruy9sHA6YPX7ZYP/vQ+SotyNEHf/ic3nfneu1u6vClHgAAAAAnhzCL9Erj7XnGsnZeuX7z4Qv16Tcs01+2N+myLz+qT/58g/Yd7/S1LgAAAAATE/K7AEwz5fOkQI7vYVaScoIBfeCihXrzmjp985Ed+vHTe3Xv8/t15aoavfv8Bq2dVy4z87tMAAAAAAkQZpFewRypYkFGhNmYmcX5+sIbV+oDFy3Q9/68S/es36f7Nx7Usppive3Mel1zRq1mleT7XSYAAACAOJbNtyhZt26dW79+vd9lYLLuvsFb0fjmZ/yuJKGOnrB++cJ+/ey5Rm3Y16KASesaKvS6FbN0+fJZaqia4XeJAAAAwLRgZs8559Yl7CPMIu0eulV64mvSZw56M7UZbOfRdt334gE9uPmQthxqkyTVlRXonAUVOnd+pc5ZUKG5FYWcjgwAAACkwFhhltOMkX7VS6VIn3R8p/c8gy2oLtLHr1iij1+xRPuOd+rhLUf01M5jemTrUd37/H5J0uzSfJ05t1zLZxdr+ewSragtUU1JPgEXAAAASCHCLNJv1kpve+iljA+z8eZUFOqm8xt00/kNcs7p1SPtenrnMT2167heajyh/3rp4MDYssIcLa8p0YLqGZpfNSO6LdKc8gKFgiwiDgAAAJwqwizSr2qpt6Lx4U3Saf/d72pOiplpyaxiLZlVrHed1yBJauvu05ZDbXrlYKtePtCqLYfa9JsNB9TaHR7YLxQwza0s1IIqL+TOryqKbmdoZnGeAgFmcwEAAICJIMwi/UK53ozsoU1+V5JUxfk5OquhQmc1VAy0OefU3NmnXU3t2nm0Q7uaOga2j73apN5wZGBsXiiguRWFmldZqLkVM7xtZaHmVRSqrrxAeaGgH38sAAAAICMRZuGPWaukXY/6XUXKmZkqZuSqYkaF1s6rGNIXiTgdONGlXU0d2t3UoT3HOrXneKf2HuvU49ub1N0XiTuOVFtaMBh2Kws1Ly7wluRn9kJaAAAAQLIRZuGPmlXSxruljmPSjEq/q/FFIGCqLy9UfXmhXrO4ekifc05H23q053in9hzr1N5jHQPPH3z5sI539A4ZX16Yo7mVMzRvYGa3MBp8OX0ZAAAAUxNhFv6YtcrbHn5JWnCxr6VkIjPTzJJ8zSzJH3Lackxbd5/2RmdxBwLv8Q49v7dZ9288oEjcHbfGOn25vrxQuSEWpAIAAED2IczCHzWnedtDmwizJ6E4P0cra0u1srZ0RF9vOKL9LV3ac6xDe6NBd8+xTu07PvL05YBJs0sLNK+yUHVlBZpdmq/ZZQWqKc33npcWqCQ/xG2GAAAAkHEIs/DHjCqpqMZb0RhJlRsKDKyQPNxYpy8/9upRHWnrkXND9ynMDQ4E25rSfNWW5qu6OE9VRXmqLMpTVVGuqorzVJxH6AUAAED6EGbhn5pVU25F40w33unLff0RHWnr0aETXTrQ0q1DJ7p18ES3Dp7o0sET3Xr81SYdaesechpzTG4ooKoZXrCtiobcyqI8lRfmqLQgR6UFuSotyFFZ9HVZYY4KcoIEYAAAAJwUwiz8M2uVtPNRKdzr3a4HvssJBlRXVqC6sgKtnZd4TLg/ouOdvWpq61VTe4+OdfQMPD/a3qOm9l4dbu3W5gMndKy9V+FEyXfg/UylBbmDAbfA25YU5KgoL6QZeSEV5QVVlB/SjNyQivJDKsobfMzIC6kwl0AMAAAwHRFm4Z+a06RIn9S0zZulRVYIBQOaWZyvmcX54451zqmjt18tnb060dWnE519OtHVp5au6Db6+kSX13+otVtbD7eptatPHb396h8jCMcETANBtyA3qIKc6CM3qPycUV7nBlSQE309bJ+C3KDyQ0Hl5QSUGwwoLyeo3GBAOUEjNAMAAGQQwiz8M7Ci8SbC7BRlZgOzqPXlk9vXOafuvojae8Jq7wmrI7pt7w6rozestm6vraMnrLbotqsvoq7esLr6+tXRE1ZTe6+6+/rV1duvrj7v0RuOjP/mo8gNBZQXfcQH3dxQYKAvN0FfXlxfKBBQKGgKBUyhaEiOtcWeD20LjBibE/RehwLR/qApJ3bc6HNuxwQAAKY6wiz8U7lICuZJh16SVl/rdzXIMGY2MFNaXZyXtOP2R5y6+/rV2dvvBd1hYbe71+vr7Y+oNxxRT9gLwN5z7zHYF1FvrL8/op5o+B7sGxwT22/4AlupEjApGDAFzBQMmIJmCgQsrk1D2gaeD7RpZJuZAgGNPGb0tffc61d0a5Is9ty8f1dT3GtF2+LGBwLeNv4Y441X/Pto5PvF9o03fKZ9+MT7iJ8Dho8fu1umsY9/MscY5+XAn8mGtA3bxvWOeL+4Bhs2JrZf/D7DxyjBsQfHjHHsIcccuuPQP8vQP1+i/QLRf/eAeZ+NwdfRtrjPT6zN4voG+gOTHD/s+JzJAQCpR5iFf4IhaeZyVjRGWgUDphnR62390B9x6uuPKBxxCvdH1NfvFI5EFO53I9r6+r3X4dg+8e0D/aOP7XdOkYhTfyTuuXPqj2jg+WCbUyS67Y9o4Plgm/c+/WGnfufNnMfaB8d6fz4np0h0AjzinJyT1+bkPXdOLr5vYMxgWyQ6RnHPY31ANogPuGbe2RhBMwWDgz8AxR6h6I9BoeiPTaEEY7xHYHDMiL7B409mTOzsjlBg5Bkhg32DY+LbYmeJ5MT+HMPOICHQA0g1wiz8VXuGtPmXUiQiBQJ+VwOknPcflEG/y8hqo4Vfr29k+HUJQvDwTOyGDRjZP3z/sQ843v6JjjHpGkcJ9vHtsfeItbkh49yQtsH9XNwYjTImwbHH6EtUX6Ixg+8ztLZE9SXez9s3EreNODfkcxJrG9ofG+/9EDOp8S5ufCTx+NgPR+FI3Na5gR+d+of3JRjT1xdRONI/bExEESdvG/G2gz8+DTtOJP0/BsWCek4woGDAxryEIhiIv1zCC8ihIWE5Fp5HBmnvGLEgnegSjsCISzIS1ZJoHJduAJmNMAt/1Z8lPXeHdOxVqXqp39UAyAKx04wlKTjyZGAAo4g/EyMWeGNndCQ6W6Qv7myP/ogb0RZ/ZshYZ514/RH1xd6v3w08j42L7d8bjqijtz9uXPRMk8jo750OAfMWQMwdMTMdF3yjbQOBOMGaB7HxOaHEoXygP5g4lA9ZK2Gc/lAgrl5COaYowiz8VX+2t933DGEWAIAUCgRMAZlyptDJIc7Fgvhg8A33R0aE5b7w2P3hfqfe4ZdzDAvPfdHjjHcZSOx1ezg85AeA2PtlQijPiQvZI2ajhy006C1emDiUDwnVCUJ5/Oz68JAfm7Effjp8KBAYcRp+olPyY2MDAXlbrlWflgiz8FflIim/TGp8RjrzXX5XAwAAsoiZRQOZVKDsTeku7nTzvv7BsJwodA+E4fDY/eH+iHpHCeXxob4vPPbaDO09iUN5/Pv1pTmUj2ZIAI67Pnzo9eJe8I2F5lAw8TXmoXECdnyojh07YMMWTYwuJhcbYzZYo1ns2vjBxeQGF1OM29di4xV3nFgtw/Yd2CruON7ijSP2jVvUsSAnmLWz9oRZ+CsQ8E413ves35UAAAD4wix2jbCUn8VT58NDeXx47ksQgmOnvMf26XdO/dEFEWOLF/ZHx8eu/Y6d8h7/emD/SET9EXn7xPUNv458+D7x16j3hiOD17IPf99Rrk+PbWN//kiWLVb44Mcu0pJZxX6XcVIIs/DfnLOl7Q9J3Sek/FK/qwEAAMBJmCqh/FTFFh6Mv1tAbMX/gbsJRBeciy0QF0kwdsS+cXchGNg37s4FI8YOv4PBkLscDP74UFWUvFsgphthFv6rP0uSkxrXS4su87saAAAA4KQN3A99il2jnom4Fwr8V7dWkkmNnGoMAAAAYGIIs/Bffok0c7m3ojEAAAAATABhFpmh/izvNONIxO9KAAAAAGQBwiwyw5yzpZ4T0rFX/a4EAAAAQBYgzCIz1J/tbTnVGAAAAMAEEGaRGSoXSQUV0p4n/K4EAAAAQBYgzCIzBALSgtdKO/8kuSy70zQAAACAtCPMInMsuERqOygd3ep3JQAAAAAyHGEWmWPhJd5255/8rQMAAABAxiPMInOUzZUqFko7CLMAAAAAxkaYRWZZeIm0+3Ep3Ot3JQAAAAAyGGEWmWXBxVJfh9T4rN+VAAAAAMhghFlklobXSBaQdjzsdyUAAAAAMhhhFpmloEyqW8siUAAAAADGRJhF5llwiXTgBamr2e9KAAAAAGQowiwyz6LLJBfhVGMAAAAAoyLMIvPUnyUVVklb/svvSgAAAABkKMIsMk8gKC29Str2oBTu8bsaAAAAABmIMIvMtPyNUm+btOvPflcCAAAAIAMRZpGZ5r9Wyi2StvzG70oAAAAAZCDCLDJTTr606HJpywNSJOJ3NQAAAAAyDGEWmWvZ1VLHEanxWb8rAQAAAJBhCLPIXEteJwVypC33+10JAAAAgAxDmEXmyi+V5l/khVnn/K4GAAAAQAYhzCKzrbhGOr5TOrjB70oAAAAAZBDCLDLb8mu8U403/dzvSgAAAABkEMIsMlthhbToMmnTvaxqDAAAAGAAYRaZb9V/l1r3S3uf9LsSAAAAABmCMIvMt/QqKVTAqcYAAAAABhBmkfnyirxAu/k+qb/P72oAAAAAZIC0hVkzu9LMtprZdjP7VIL+r5jZi9HHNjNrSVdtyAKnvV3qOi7tfMTvSgAAAABkgLSEWTMLSvqGpKskrZB0nZmtiB/jnPuYc+4M59wZkr4m6d501IYssegy776zG+/xuxIAAAAAGSBdM7NnS9runNvpnOuVdLekN40x/jpJP0lLZcgOoTxp5VulV34jdZ/wuxoAAAAAPktXmK2TtC/udWO0bQQzmydpvqSHR+n/gJmtN7P1R48eTXqhyGBr3iWFu6TNv/S7EgAAAAA+y8QFoK6V9HPnXH+iTufcd5xz65xz66qrq9NcGnxVd6ZUvVx64Ud+VwIAAADAZ+kKs/slzYl7XR9tS+RacYoxEjGT1rxTanxWOrLF72oAAAAA+ChdYfZZSYvNbL6Z5coLrL8ePsjMlkkql/RkmupCtjn9r6RASHqR2VkAAABgOktLmHXOhSXdLOn3kl6RdI9zbrOZfdHMrokbeq2ku51zLh11IQsVVUtLrpQ23M09ZwEAAIBpLJSuN3LOPSDpgWFtnx/2+pZ01YMstuad0pb7pW2/k5a/0e9qAAAAAPggExeAAsa26AqpdI701Lf8rgQAAACATwizyD7BkHTOB6U9j0sHXvC7GgAAAAA+IMwiO515o5RbLD35Db8rAQAAAOADwiyyU36pF2g3/1I60eh3NQAAAADSjDCL7HXOByUXkZ7+tt+VAAAAAEgzwiyyV/k8acWbpOfulLpa/K4GAAAAQBoRZpHdLvy41NMqPfolvysBAAAAkEaEWWS32adLa98tPfNt6cgWv6sBAAAAkCaEWWS/Sz8n5c6QfvtJyTm/qwEAAACQBoRZZL8ZldIln5V2PSptud/vagAAAACkAWEWU8O6v5ZmrpD+6xPcqgcAAACYBgizmBqCIelt35f6OqUfv0PqbvW7IgAAAAApRJjF1DFrhfSOu6SmrdLPbpL6+/yuCAAAAECKEGYxtSy8RLr6q9KOh6WfXCd1HPO7IgAAAAApQJjF1HPmu6Srv+ItCPWtC6Xdf/G7IgAAAABJRpjF1LTur6X3PSTlFEh3Xi3d/zGp/ajfVQEAAABIEsIspq7Zq6UPPiqd9X7puTulf18jPf4Vqa/b78oAAAAAnCLCLKa2vGLpDV+S/vYpqeFC6aFbpK+fJW36heSc39UBAAAAOEmEWUwP1Uuk6++Wbvy1VFAq/fyvpe9fIe171u/KAAAAAJwEwiymlwWvlT7wqPSmb0gt+6TvXy797D3SkS1+VwYAAABgEgizmH4CQWnNO6UPPye99u+lrb+Vbj9H+uFbvOe9HX5XCAAAAGAc5rL4usF169a59evX+10Gsl1Hk/Tcf0jPfE9qPyQFQtLsM6TZp0szZkozqqQZ1XHbaim/TArwWxAAAACQSmb2nHNuXcI+wiwQFe6Vdj0m7fmL92jaJnU1Jx5rQam4RqpcKFUtkSoXS1WLpcpFUtEsKSc/vbUDAAAAU9BYYTaU7mKAjBXKlRZf7j1i+sNS5zGps0nqOOrN4nZEn7ful5pelTb+TOo5MexYBd5KyoGQd1qzBaLb4OA2GJIKKgZnfAsr455XRZ9XSXklkll6/y4AAACADEeYBcYSDEnFs7zHaJzzwm3TNunYdi/8djVL3a2S65cikei2P24bkfp7pc7jUvMuLyD3to9SQ2403FbGBd1q73Vh3KnPZXOlopkEXwAAAEwLhFngVJl5IbJopncv25PV1x03A3zM28a/jj0/tsMLv30JFqoKFUjl86SyeVJ5g/e8vMF7XVrnXetL2AUAAMAUQJgFMkVOvlRa7z0moq9r8JTn9iNSy16pZY/UvFtq3iPteULqbRu6T6hAKqn1HsWzhz2vk0pme9f8BoJJ/+MBAAAAyUSYBbJVToFUNsd7JOKcdxpzy24v4LYelFoPSG0HvOd7n5LaDkqRvqH7WUAqqvGCbXzILa4dDL+FlVJ+KbO8AAAA8A1hFpiqzKLX2VZKdWsTj4lEvGt8W/d7wbb1QDTwHhxc4GrXY1JPa4LjB6WCcqmwwlvIamBbPuz1sG0oN7V/bgAAAEwLhFlgOgsEpKJq76EzRh/X0+bN5sZmdTuPSV3HvZnf2LZlr3TgRe91uHv0Y+UWebO6ecXe87xiKa9Iyi0efD7QVyLlFnqz0DmFcY+CwW0on3v+AgAATEOEWQDjyyuWqoul6iUTG9/bOTLsdh2XOpu9bXerdz1vT5vU0y61HfJWc+5p9V67/snVFyoYGnBzCrxVoEN53jaY680IB3OlYF7c89wE4/KkYI43LpgTfR1ry43ebil6y6VgztDXA89jr4f1c1o2AABA0hBmASRfbqH3mOhiVvGc82Z2e6Jht6/TW+yqr9MLyQOvu4b2DXne5d36KNwr9XZI/cel/j4p3OO19/dGn/dJ/T1SJJz8v4NEbFjgDQ4Pv8NeWyD6iHs+0G4j+wb6J9I3keOaJIsL4TasLX47rF8aY+wo24F9JrHviLEa+Tz+uEOeD+8ba79h7zXpvvGOOYH3P6W6U/FnGq9P4/Sd6p/pVN4/Sf8WA/9bins/AEDaEGYBZBazwdnVopnpec9IZDDkJgq74bj2SNi7V3AkHPfo9xbSGvI6rr8/PGz8OPv09w3ej3jIo98L+y7i1TxkTOx5rH/4/v0T6xvoj7bJeX9H8c8BDBX7ASgQjNvG/1AU3xcYNmZ4W9zWLMH+QQ39AWq0YyeoIxAadozQ0LEj3is09P3i9084Nu79T/q9+GEAwMQRZgEgEJAC+d7tkTA+5wbD7Wjb2Lixxrj4cZrA2AT7JnxPjTxufD0n1Rf/XqP16ST3G6NvUnUnev9T/TNNpE8j+yZV96n+WyR4/3T9fcd+DIr9ABT7oWjgB6P4vmGv48cN2X/YccI9YxwnkvjY8T9IjWiLKLPZ5MPwwNjAsGAcbRtyrNH2DyQI1ol+BBhn/2T+YJBw/1FqjZ0xwI8BmGYIswCAyeE/mIDsNTzgRsLDAnF4WP/woB0eGp4zev+Id2aN6xr9mJHwsB8UYvtHhh2/X3G/GGU4izv9fbznSRxvAQ2G6thzJW4fUu7w/z9JdJlAEvsS9o/WN9Z+EzzmkB/eRvsRbljf8B/rRt1nrP0m+F6S9JZvSxXzR3/PDEaYBQAAmC7MvOv1+U/AyUs0Az6ZMHyqYToW0BMdc+CslbjLTWJnIox4rjHGREYea2BMEt5jxJkBkwhcE+4b/hYJwt+IM4MSHPdU+pISwicapOOv4x9+6Am+l2XvXSH4JgMAAADGEwhICngr2QPICNkbwwEAAAAA0xZhFgAAAACQdQizAAAAAICsQ5gFAAAAAGQdwiwAAAAAIOsQZgEAAAAAWYcwCwAAAADIOoRZAAAAAEDWIcwCAAAAALIOYRYAAAAAkHUIswAAAACArEOYBQAAAABkHcIsAAAAACDrEGYBAAAAAFmHMAsAAAAAyDqEWQAAAABA1iHMAgAAAACyDmEWAAAAAJB1zDnndw0nzcyOStrjdx3jqJLU5HcRyFh8PjAaPhsYC58PjIXPB0bDZwNjydTPxzznXHWijqwOs9nAzNY759b5XQcyE58PjIbPBsbC5wNj4fOB0fDZwFiy8fPBacYAAAAAgKxDmAUAAAAAZB3CbOp9x+8CkNH4fGA0fDYwFj4fGAufD4yGzwbGknWfD66ZBQAAAABkHWZmAQAAAABZhzALAAAAAMg6hNkUMbMKM/ulmXWY2R4zu97vmuAfM3vEzLrNrD362BrXd330M9JhZveZWYWftSK1zOxmM1tvZj1mdsewvsvMbIuZdZrZn8xsXlxfnpn9wMxazeyQmX087cUj5Ub7fJhZg5m5uO+QdjP7XFw/n48pLvpv/P3o/1+0mdmLZnZVXD/fH9PYWJ8Pvj8gSWb2IzM7GP133mZm74vry9rvD8Js6nxDUq+kWZJukPRNM1vpb0nw2c3OuaLoY6kkRT8T35b0LnmflU5Jt/tYI1LvgKR/lPSD+EYzq5J0r6TPSaqQtF7ST+OG3CJpsaR5ki6R9EkzuzIN9SK9En4+4pTFfY/877j2W8TnY6oLSdon6bWSSiV9VtI90aDC9wdG/XzEjeH7Y3r7P5IanHMlkq6R9I9mtjbbvz9YACoFzGyGpGZJq5xz26JtP5S03zn3KV+Lgy/M7BFJP3LOfW9Y+z/L+2K5Pvp6oaRXJFU659rSXijSxsz+UVK9c+7d0dcfkPRu59z50dczJDVJWuOc22JmB6L9D0b7/7ekxc65a335AyClEnw+GiTtkpTjnAsnGM/nYxoys42SbpVUKb4/MEzc5+M58f2BOGa2VNIjkj4iqUxZ/P3BzGxqLJEUjgXZqA2SmJmd3v6PmTWZ2V/M7OJo20p5nw1JknNuh7wZ/SXpLw8+G/5Z6JC0Q9JKMyuXNDu+X3ynTFd7zKzRzP4j+mu6+HxMT2Y2S97/V2wW3x8YZtjnI4bvj2nOzG43s05JWyQdlPSAsvz7gzCbGkWSWoe1nZBU7EMtyAx/L2mBpDp59/D6TXQWtkjeZyMen5XpaazPQlHc6+F9mB6aJJ0l7zSvtfL+7X8c7ePzMc2YWY68f/87nXNbxPcH4iT4fPD9AUmSc+5v5f3bvkbeqcU9yvLvj5DfBUxR7ZJKhrWVSOK00WnKOfd03Ms7zew6SW8QnxUMGuuz0B73untYH6YB51y7vOuYJOmwmd0s6aCZFYvPx7RiZgFJP5R3Fs/N0Wa+PyAp8eeD7w/Ec871S3rczN4p6W+U5d8fzMymxjZJITNbHNe2WkNP9cD05iSZvM/E6lijmS2QlCfvM4TpZfhnYYakhZI2O+ea5Z0OtDpuPN8p01tswYsAn4/pw8xM0vflLRj4NudcX7SL7w+M9fkYju8PSN6k5kJl+fcHYTYFouea3yvpi2Y2w8wukPQmeb+UYZoxszIze72Z5ZtZyMxukHSRpN/JO83njWb2muiXxxcl3cviT1NX9DOQLykoKRj7XEj6paRVZva2aP/nJW2MniImSXdJ+qyZlZvZMknvl3SHD38EpNBonw8zO8fMlppZwMwqJf27pEecc7FTv/h8TA/flLRc0hudc11x7Xx/QBrl88H3B8xspplda2ZFZhY0s9dLuk7SH5Xt3x/OOR4peMhb2vo+SR2S9kq63u+aePj2WaiW9Ky8UzJaJD0l6Yq4/uujn5EOSb+SVOF3zTxS+nm4Rd6v4vGPW6J9l8tblKFL3iqDDXH75cm7XUurpMOSPu73n4VH+j4f8v6jY1f0e+KgvP+4qOHzMX0e8q53dPJO9WuPe9wQ7ef7Yxo/xvp88P3BI/rfoo9G/zu0VdJLkt4f15+13x/cmgcAAAAAkHU4zRgAAAAAkHUIswAAAACArEOYBQAAAABkHcIsAAAAACDrEGYBAAAAAFmHMAsAAAAAyDqEWQAA0sjMfmtmN/ldx0SYWYOZOTML+V0LAADD8X9OAACMw8za414WSuqR1B99/UHn3I8neizn3FXJrA0AgOmKMAsAwDicc0Wx52a2W9L7nHMPDR9nZiHnXDidtQEAMF1xmjEAACfJzC42s0Yz+3szOyTpP8ys3MzuN7OjZtYcfV4ft88jZva+6PN3m9njZnZbdOwuMxt15tbMas3sF9Fj7zKz/xnXd4uZ/dzMfmpmbWb2vJmtjutfHn3vFjPbbGbXxPUVmNm/mdkeMzsRrakg7q1vMLO9ZtZkZp9J1t8fAACngjALAMCpqZFUIWmepA/I+//W/4i+niupS9LXx9j/HElbJVVJ+pKk75uZDR9kZgFJv5G0QVKdpMskfdTMXh837E2Sfhat5z8l3WdmOWaWE933QUkzJX1Y0o/NbGl0v9skrZV0fnTfT0qKxB33QklLo+/5eTNbPu7fCgAAKUaYBQDg1EQkfcE51+Oc63LOHXPO/cI51+mca5P0T5JeO8b+e5xz33XO9Uu6U9JsSbMSjDtLUrVz7ovOuV7n3E5J35V0bdyY55xzP3fO9Un6sqR8SedGH0WS/iW678OS7pd0XTQk/7Wkjzjn9jvn+p1zTzjneuKOe2v0z7ZBXpheLQAAfMY1swAAnJqjzrnu2AszK5T0FUlXSiqPNhebWTAaWIc7FHvinOuMTsoWJRg3T1KtmbXEtQUl/Tnu9b64Y0XMrFFSbazPORc/27pH3gxvlbzQu2OMP+OhuOedo9QHAEBaEWYBADg1btjrv5N3Su45zrlDZnaGpBckjTh1eJL2SdrlnFs8xpg5sSfRGdd6SQdifWYWiAu0cyVtk9QkqVvSQnmzrgAAZAVOMwYAILmK5V0n22JmFZK+kKTjPiOpLbrYVIGZBc1slZmdFTdmrZm9NXpf2I/Ku4XQU5Keljej+snoNbQXS3qjpLuj4fYHkr4cXWAqaGbnmVlekuoGACAlCLMAACTXVyUVyJvxfErS75Jx0OgpyldLOkPSrujxvyepNG7YryT9laRmSe+S9FbnXJ9zrldeeL0qut/tkm50zm2J7vcJSS9JelbScUn/Kv4bAQCQ4cy54WdHAQCAbGNmt0ha5Jx7p9+1AACQDvzqCgAAAADIOoRZAAAAAEDW4TRjAAAAAEDWYWYWAAAAAJB1CLMAAAAAgKxDmAUAAAAAZB3CLAAAAAAg6xBmAQAAAABZhzALAAAAAMg6/x+Wd2BveRGXNAAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -262,7 +284,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "08f1cba4", "metadata": {}, "outputs": [ @@ -298,7 +320,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "ca48f9d5", "metadata": {}, "outputs": [ @@ -308,7 +330,7 @@ "0.9906846833902615" ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -338,19 +360,19 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "218d0983", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1ae41116adb044cda7a7bf447621902a", + "model_id": "1021b2f7371a43f19faa46dd31009488", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Split Gradient: 0%| | 0/107 [00:00" ] @@ -471,7 +493,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "8bc72789", "metadata": {}, "outputs": [ @@ -479,8 +501,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average influence of corrupted points: -0.038253907\n", - "Average influence of other points: 0.030877113\n" + "Average influence of corrupted points: -0.05309211\n", + "Average influence of other points: 0.03483218\n" ] } ], @@ -513,19 +535,19 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "id": "462d545e", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "70dddd078acb4d96b077c07a2c5dfe19", + "model_id": "b2a154955e3343f3b9fd241485eeb792", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Split Gradient: 0%| | 0/107 [00:00" ] @@ -621,20 +643,76 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "id": "efdb4050", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a538c4f868774d3fa1fa69b006ce4acd", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Batch Test Gradients: 0%| | 0/4 [00:00 torch.Tensor: def fit_torch_model( model: nn.Module, - x_train: torch.Tensor, - y_train: torch.Tensor, - x_val: torch.Tensor, - y_val: torch.Tensor, + train_data: DataLoader, + val_data: DataLoader, loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], optimizer: Optimizer, scheduler: Optional[_LRScheduler] = None, @@ -114,19 +112,12 @@ def fit_torch_model( :param batch_size: Batch size to use in training. :param progress: True, iff progress shall be printed. """ - x_train = as_tensor(x_train) - y_train = as_tensor(y_train) - x_val = as_tensor(x_val) - y_val = as_tensor(y_val) - - dataset = TensorDataset(x_train, y_train) - dataloader = DataLoader(dataset, batch_size=batch_size) train_loss = [] val_loss = [] for epoch in maybe_progress(range(num_epochs), progress, desc="Model fitting"): batch_loss = [] - for train_batch in dataloader: + for train_batch in train_data: batch_x, batch_y = train_batch pred_y = model(batch_x) loss_value = loss(torch.squeeze(pred_y), torch.squeeze(batch_y)) @@ -139,6 +130,7 @@ def fit_torch_model( if scheduler: scheduler.step() + x_val, y_val = next(iter(val_data)) pred_val = model(x_val) epoch_val_loss = loss(torch.squeeze(pred_val), torch.squeeze(y_val)).item() mean_epoch_train_loss = np.mean(batch_loss) diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index 521736fb1..b140ce1a0 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -15,6 +15,7 @@ from .torch_differentiable import ( as_tensor, + cat, einsum, mvp, solve_batch_cg, @@ -24,6 +25,7 @@ ) TensorType = torch.Tensor + DataLoaderType = torch.utils.data.DataLoader ModelType = torch.nn.Module except ImportError: @@ -38,6 +40,7 @@ "solve_lissa", "as_tensor", "stack", + "cat", "einsum", "mvp", ] diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 62cc0b702..967df0489 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -2,13 +2,14 @@ Contains all parts of pyTorch based machine learning model. """ import logging -from typing import Any, Callable, Dict, List, Sequence, Tuple +from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple import numpy as np import torch import torch.nn as nn from torch import autograd from torch.autograd import Variable +from torch.utils.data import DataLoader from ...utils import maybe_progress from .twice_differentiable import TwiceDifferentiable @@ -28,17 +29,17 @@ def flatten_gradient(grad): def solve_linear( model: TwiceDifferentiable, - x: torch.Tensor, - y: torch.Tensor, + training_data: DataLoader, b: torch.Tensor, lam: float = 0, progress: bool = True, ): - """Computes the solution of a square system of linear equations + """Given a model and training data, it uses conjugate gradient to calculate the + inverse of the HVP. More precisely, it finds x s.t. $Hx = b$, with $H$ being + the model hessian. :param model: A model wrapped in the TwiceDifferentiable interface. - :param x: An array containing the features of the input data points. - :param y: labels for x + :param training_data: A DataLoader containing the training data. :param b: :param lam: regularization of the hessian :param progress: If True, display progress bars. @@ -46,27 +47,34 @@ def solve_linear( :return: An array that solves the inverse problem, i.e. it returns $x$ such that $Ax = b$ """ - matrix = model.hessian(x, y, progress) + lam * identity_tensor(model.num_params()) + all_x, all_y = [], [] + for x, y in training_data: + all_x.append(x) + all_y.append(y) + all_x = cat(all_x) + all_y = cat(all_y) + matrix = model.hessian(all_x, all_y, progress) + lam * identity_tensor( + model.num_params() + ) return torch.linalg.solve(matrix, b.T).T def solve_batch_cg( model: TwiceDifferentiable, - x: torch.Tensor, - y: torch.Tensor, + training_data: DataLoader, b: torch.Tensor, lam: float = 0, inversion_method_kwargs: Dict[str, Any] = {}, progress: bool = True, ): """ - It uses conjugate gradient to calculate the solution of a linear equation. - More precisely, it finds x s.t. $Ax = y$. For - more info: https://en.wikipedia.org/wiki/Conjugate_gradient_method + Given a model and training data, it uses conjugate gradient to calculate the + inverse of the HVP. More precisely, it finds x s.t. $Hx = b$, with $H$ being + the model hessian. For more info: + https://en.wikipedia.org/wiki/Conjugate_gradient_method :param model: A model wrapped in the TwiceDifferentiable interface. - :param x: An array containing the features of the input data points. - :param y: labels for x + :param training_data: A DataLoader containing the training data. :param b: :param lam: regularization of the hessian :param inversion_method_kwargs: kwargs to pass to the inversion method @@ -74,36 +82,48 @@ def solve_batch_cg( :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$. """ - grad_xy, _ = model.grad(x, y) + total_grad_xy = 0 + total_points = 0 + for x, y in maybe_progress(training_data, progress, desc="Batch Train Gradients"): + grad_xy, _ = model.grad(x, y) + total_grad_xy += grad_xy * len(x) + total_points += len(x) backprop_on = model.parameters() - reg_hvp = lambda v: mvp(grad_xy, v, backprop_on) + lam * v + reg_hvp = lambda v: mvp(total_grad_xy / total_points, v, backprop_on) + lam * v batch_cg = torch.zeros_like(b) - for idx, y in enumerate(maybe_progress(b, progress, desc="Conjugate gradient")): - y_cg, _ = solve_cg(reg_hvp, y, **inversion_method_kwargs) - batch_cg[idx] = y_cg + for idx, bi in enumerate(maybe_progress(b, progress, desc="Conjugate gradient")): + bi_cg, _ = solve_cg(reg_hvp, bi, **inversion_method_kwargs) + batch_cg[idx] = bi_cg return batch_cg -def solve_cg(hvp, y, x0=None, rtol=1e-7, atol=1e-7, maxiter=None): +def solve_cg( + hvp: Callable[[torch.Tensor], torch.Tensor], + b: torch.Tensor, + x0: Optional[torch.Tensor] = None, + rtol: float = 1e-7, + atol: float = 1e-7, + maxiter: Optional[int] = None, +): """Conjugate gradient solver for the Hessian vector product :param hvp: a Callable Hvp, operating with tensors of size N - :param y: a tensor of shape [N] + :param b: a tensor of shape [N] :param x0: initial guess for hvp :param rtol: maximum relative tolerance of result :param atol: absolute tolerance of result :param maxiter: maximum number of iterations. If None, defaults to 10*len(y) """ if x0 is None: - x0 = torch.clone(y) + x0 = torch.clone(b) if maxiter is None: - maxiter = len(y) * 10 + maxiter = len(b) * 10 - y_norm = torch.sum(torch.matmul(y, y)).item() + y_norm = torch.sum(torch.matmul(b, b)).item() stopping_val = max([rtol**2 * y_norm, atol**2]) x = x0 - p = r = (y - hvp(x)).squeeze() + p = r = (b - hvp(x)).squeeze() gamma = torch.sum(torch.matmul(r, r)).item() optimal = False @@ -126,32 +146,29 @@ def solve_cg(hvp, y, x0=None, rtol=1e-7, atol=1e-7, maxiter=None): def solve_lissa( - model, - x, - y, - b, - lam, + model: TwiceDifferentiable, + training_data: DataLoader, + b: torch.Tensor, + lam: float = 0, progress: bool = True, maxiter: int = 1000, damp: float = 0, scale: float = 10, ): """ - It uses LISSA, Linear time Stochastic Second-Order Algorithm, to approximate - the solution of a linear equation. - More precisely, it finds x s.t. $Ax = y$. For - more info: https://en.wikipedia.org/wiki/Conjugate_gradient_method. - This is done by iteratively approximating A through + It uses LISSA, Linear time Stochastic Second-Order Algorithm, to calculate the + inverse of the HVP. More precisely, it finds x s.t. $Hx = b$, with $H$ being + the model hessian. + This is done by iteratively approximating H through $$ - A^{-1}_{j+1} y = y + (I - A) \ A^{-1}_j y + H^{-1}_{j+1} b = b + (I - H) \ H^{-1}_j b $$ where I is the identity matrix. Additional damping and scaling factors are applied to help convergence. More info can be found in :footcite:t:`koh_understanding_2017` :param model: A model wrapped in the TwiceDifferentiable interface. - :param x: An array containing the features of the input data points. - :param y: labels for x + :param training_data: A DataLoader containing the training data. :param b: :param lam: regularization of the hessian :param maxiter: maximum number of iterations, @@ -162,7 +179,8 @@ def solve_lissa( :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$. """ h_estimate = torch.clone(b) - for i in maybe_progress(range(maxiter), progress, desc="Lissa"): + for _ in maybe_progress(range(maxiter), progress, desc="Lissa"): + x, y = next(iter(training_data)) grad_xy, _ = model.grad(x, y) reg_hvp = lambda v: mvp(grad_xy, v, model.parameters()) + lam * v h_estimate = b + (1 - damp) * h_estimate - reg_hvp(h_estimate) / scale @@ -185,6 +203,11 @@ def stack(a: Sequence[torch.Tensor], **kwargs): return torch.stack(a, **kwargs) +def cat(a: Sequence[torch.Tensor], **kwargs): + """Concatenates a sequence of tensors into a single torch tensor""" + return torch.cat(a, **kwargs) + + def einsum(equation, *operands): """Sums the product of the elements of the input :attr:`operands` along dimensions specified using a notation based on the Einstein summation convention. @@ -220,7 +243,8 @@ def mvp( backprop_on is None, otherwise [DxM], with M the number of elements of backprop_on. """ - v = as_tensor(v, warn=False) + device = grad_xy.device + v = as_tensor(v, warn=False).to(device) if v.ndim == 1: v = v.unsqueeze(0) @@ -240,11 +264,15 @@ def __init__( self, model: nn.Module, loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + device: torch.device = torch.device( + "cuda" if torch.cuda.is_available() else "cpu" + ), ): r""" :param model: A (differentiable) function. :param loss: :param loss: A differentiable scalar loss $L(\hat{y}, y)$, mapping a prediction and a target to a real value. + :param device: device to use for computations. Defaults to cuda if available. """ if model.training: logger.warning( @@ -252,8 +280,9 @@ def __init__( "computation, e.g. due to batch normalization. Please call model.eval() before " "computing influences." ) - self.model = model + self.model = model.to(device) self.loss = loss + self.device = device def parameters(self) -> List[torch.Tensor]: """Returns all the model parameters that require differentiating""" @@ -284,8 +313,8 @@ def split_grad( :returns: An array [NxP] representing the gradients with respect to all parameters of the model. """ - x = as_tensor(x, warn=False).unsqueeze(1) - y = as_tensor(y, warn=False) + x = as_tensor(x, warn=False).to(self.device).unsqueeze(1) + y = as_tensor(y, warn=False).to(self.device) params = [ param for param in self.model.parameters() if param.requires_grad == True @@ -321,8 +350,8 @@ def grad( - second element is the input to the model as a grad parameters. \ This can be used for further differentiation. """ - x = as_tensor(x, warn=False).requires_grad_(True) - y = as_tensor(y, warn=False) + x = as_tensor(x, warn=False).to(self.device).requires_grad_(True) + y = as_tensor(y, warn=False).to(self.device) params = [ param for param in self.model.parameters() if param.requires_grad == True @@ -343,6 +372,8 @@ def hessian( :param y: A matrix [NxK] representing the target values $y_i$. :returns: the hessian of the model, i.e. the second derivative wrt. the model parameters. """ + x = x.to(self.device) + y = y.to(self.device) grad_xy, _ = self.grad(x, y) backprop_on = [ param for param in self.model.parameters() if param.requires_grad == True diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 10555df65..8cc655611 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -2,15 +2,17 @@ This module contains parallelized influence calculation functions for general models, as introduced in :footcite:t:`koh_understanding_2017`. """ +from copy import deepcopy from enum import Enum -from typing import Any, Dict +from typing import Any, Dict, Optional from ..utils import maybe_progress from .frameworks import ( + DataLoaderType, ModelType, TensorType, TwiceDifferentiable, - as_tensor, + cat, einsum, mvp, stack, @@ -31,10 +33,8 @@ class InfluenceType(str, Enum): def compute_influence_factors( model: TwiceDifferentiable[TensorType, ModelType], - x: TensorType, - y: TensorType, - x_test: TensorType, - y_test: TensorType, + training_data: DataLoaderType, + test_data: DataLoaderType, inversion_method: InversionMethod, inversion_method_kwargs: Dict[str, Any] = {}, lam: float = 0, @@ -53,10 +53,8 @@ def compute_influence_factors( more info, refer to :footcite:t:`koh_understanding_2017`, paragraph 3. :param model: A model wrapped in the TwiceDifferentiable interface. - :param x: An array of shape [MxK] containing the features of the input data points. - :param y: An array of shape [MxL] containing the targets of the input data points. - :param x_test: An array of shape [NxK] containing the features of the test set of data points. - :param y_test: An array of shape [NxL] containing the targets of the test set of data points. + :param training_data: A DataLoader containing the training data. + :param test_data: A DataLoader containing the test data. :param inversion_func: function to use to invert the product of hvp (hessian vector product) and the gradient of the loss (s_test in the paper). :param inversion_method_kwargs: kwargs to pass to the inversion method @@ -65,17 +63,16 @@ def compute_influence_factors( :returns: An array of size (N, D) containing the influence factors for each dimension (D) and test sample (N). """ - x = as_tensor(x) - y = as_tensor(y) - x_test = as_tensor(x_test) - y_test = as_tensor(y_test) - - test_grads = model.split_grad(x_test, y_test, progress) + test_grads = [] + for x_test, y_test in maybe_progress( + test_data, progress, desc="Batch Test Gradients" + ): + test_grads.append(model.split_grad(x_test, y_test, False)) + test_grads = cat(test_grads) return solve_hvp( inversion_method, model, - x, - y, + training_data, test_grads, lam, inversion_method_kwargs, @@ -85,8 +82,7 @@ def compute_influence_factors( def _compute_influences_up( model: TwiceDifferentiable[TensorType, ModelType], - x: TensorType, - y: TensorType, + input_data: DataLoaderType, influence_factors: TensorType, progress: bool = False, ) -> TensorType: @@ -98,24 +94,27 @@ def _compute_influences_up( model) and then multiplies each with the influence factors. For more details, refer to section 2.1 of :footcite:t:`koh_understanding_2017`. - :param model: A model which has to implement the TwiceDifferentiable interface. - :param x_train: An array of shape [MxK] containing the features of the - input data points. - :param y_train: An array of shape [MxL] containing the targets of the - input data points. + :param model: A model which has to implement the TwiceDifferentiable + interface. + :param input_data: Data loader containing the samples to calculate the + influence of. :param influence_factors: array containing influence factors :param progress: If True, display progress bars. :returns: An array of size [NxM], where N is number of test points and M number of train points. """ - train_grads = model.split_grad(x, y, progress) + train_grads = [] + for x, y in maybe_progress( + input_data, progress, desc="Batch Split Input Gradients" + ): + train_grads.append(model.split_grad(x, y, False)) + train_grads = cat(train_grads) return einsum("ta,va->tv", influence_factors, train_grads) def _compute_influences_pert( model: TwiceDifferentiable[TensorType, ModelType], - x: TensorType, - y: TensorType, + input_data: DataLoaderType, influence_factors: TensorType, progress: bool = False, ) -> TensorType: @@ -129,28 +128,29 @@ def _compute_influences_pert( to section 2.2 of :footcite:t:`koh_understanding_2017`. :param model: A model which has to implement the TwiceDifferentiable interface. - :param x_train: An array of shape [MxK] containing the features of the - input data points. - :param y_train: An array of shape [MxL] containing the targets of the - input data points. + :param input_data: Data loader containing the samples to calculate the + influence of. :param influence_factors: array containing influence factors :param progress: If True, display progress bars. :returns: An array of size [NxMxP], where N is number of test points, M number of train points, and P the number of features. """ all_pert_influences = [] - for i in maybe_progress( - len(x), + for x, y in maybe_progress( + input_data, progress, - desc="Influence Perturbation", + desc="Batch Influence Perturbation", ): - grad_xy, tensor_x = model.grad(x[i : i + 1], y[i]) - perturbation_influences = mvp( - grad_xy, - influence_factors, - backprop_on=tensor_x, - ) - all_pert_influences.append(perturbation_influences.reshape((-1, *x[i].shape))) + for i in range(len(x)): + grad_xy, tensor_x = model.grad(x[i : i + 1], y[i]) + perturbation_influences = mvp( + grad_xy, + influence_factors, + backprop_on=tensor_x, + ) + all_pert_influences.append( + perturbation_influences.reshape((-1, *x[i].shape)) + ) return stack(all_pert_influences, axis=1) @@ -163,10 +163,9 @@ def _compute_influences_pert( def compute_influences( differentiable_model: TwiceDifferentiable[TensorType, ModelType], - x: TensorType, - y: TensorType, - x_test: TensorType, - y_test: TensorType, + training_data: DataLoaderType, + input_data: Optional[DataLoaderType] = None, + test_data: Optional[DataLoaderType] = None, progress: bool = False, inversion_method: InversionMethod = InversionMethod.Direct, inversion_method_kwargs: Dict[str, Any] = {}, @@ -174,17 +173,17 @@ def compute_influences( hessian_regularization: float = 0, ) -> TensorType: r""" - Calculates the influence of the training points j on the test points i. - First it calculates the influence factors for all test points with respect - to the training points, and then uses them to get the influences over the - complete training set. Points with low influence values are (on average) - less important for model training than points with high influences. + Calculates the influence of the input_data point j on the test points i. + First it calculates the influence factors of all test points with respect + to the model and the training points, and then uses them to get the + influences over the complete input_data set. :param differentiable_model: A model wrapped with its loss in TwiceDifferentiable. - :param x: model input for training - :param y: input labels - :param x_test: model input for testing - :param y_test: test labels + :param training_data: data loader with the training data + :param input_data: data loader with the samples to calculate the influences + for. If None, the samples in training_data are used. + :param test_data: data loader with the test samples. If None, the samples in + training_data are used. :param progress: whether to display progress bars. :param inversion_method: Set the inversion method to a specific one, can be 'direct' for direct inversion (and explicit construction of the Hessian) @@ -201,17 +200,15 @@ def compute_influences( train points. If instead influence_type is 'perturbation', output shape is [NxMxP], with P the number of input features. """ - x = as_tensor(x) - y = as_tensor(y) - x_test = as_tensor(x_test) - y_test = as_tensor(y_test) + if input_data is None: + input_data = deepcopy(training_data) + if test_data is None: + test_data = deepcopy(training_data) influence_factors = compute_influence_factors( differentiable_model, - x, - y, - x_test, - y_test, + training_data, + test_data, inversion_method, inversion_method_kwargs=inversion_method_kwargs, lam=hessian_regularization, @@ -221,8 +218,7 @@ def compute_influences( return compute_influence_type( differentiable_model, - x, - y, + input_data, influence_factors, progress, ) diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 1f420fc24..77b346028 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -6,6 +6,7 @@ from typing import Any, Dict from .frameworks import ( + DataLoaderType, ModelType, TensorType, TwiceDifferentiable, @@ -32,8 +33,7 @@ class InversionMethod(str, Enum): def solve_hvp( inversion_method: InversionMethod, model: TwiceDifferentiable[TensorType, ModelType], - x: TensorType, - y: TensorType, + training_data: DataLoaderType, b: TensorType, lam: float = 0, inversion_method_kwargs: Dict[str, Any] = {}, @@ -62,8 +62,7 @@ def solve_hvp( if inversion_method == InversionMethod.Direct: return solve_linear( model, - x, - y, + training_data, b, lam, **inversion_method_kwargs, @@ -72,8 +71,7 @@ def solve_hvp( elif inversion_method == InversionMethod.Cg: return solve_batch_cg( model, - x, - y, + training_data, b, lam, **inversion_method_kwargs, @@ -82,8 +80,7 @@ def solve_hvp( elif inversion_method == InversionMethod.Lissa: return solve_lissa( model, - x, - y, + training_data, b, lam, **inversion_method_kwargs, diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index d9e03119b..33ec20fc9 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -9,6 +9,7 @@ import torch.nn.functional as F from numpy.typing import NDArray from torch import nn +from torch.utils.data import DataLoader from pydvl.influence import TorchTwiceDifferentiable, compute_influences from pydvl.influence.general import InfluenceType, InversionMethod @@ -141,10 +142,18 @@ def test_influence_linear_model( hessian_regularization=hessian_reg, ) + train_data_loader = DataLoader(list(zip(*train_data)), batch_size=5, shuffle=True) + input_data = DataLoader(list(zip(*train_data)), batch_size=5) + test_data_loader = DataLoader( + list(zip(*test_data)), + batch_size=5, + ) + direct_influences = compute_influences( TorchTwiceDifferentiable(linear_layer, loss), - *train_data, - *test_data, + train_data_loader, + input_data, + test_data_loader, progress=True, influence_type=influence_type, inversion_method="direct", @@ -153,8 +162,9 @@ def test_influence_linear_model( cg_influences = compute_influences( TorchTwiceDifferentiable(linear_layer, loss), - *train_data, - *test_data, + train_data_loader, + input_data, + test_data_loader, progress=True, influence_type=influence_type, inversion_method="cg", @@ -163,8 +173,9 @@ def test_influence_linear_model( lissa_influences = compute_influences( TorchTwiceDifferentiable(linear_layer, loss), - *train_data, - *test_data, + train_data_loader, + input_data, + test_data_loader, progress=True, influence_type=influence_type, inversion_method="lissa", @@ -178,13 +189,13 @@ def test_influence_linear_model( assert np.logical_not(np.any(np.isnan(cg_influences))) assert np.allclose(direct_influences, analytical_influences, rtol=1e-7) assert np.allclose(cg_influences, analytical_influences, rtol=1e-1) - upper_quantile_mask = lissa_influences > np.quantile(lissa_influences, 0.9) + upper_quantile_mask = lissa_influences > np.quantile(lissa_influences, 0.7) assert np.allclose( lissa_influences[upper_quantile_mask], analytical_influences[upper_quantile_mask], rtol=1e-1, ) - lower_quantile_mask = lissa_influences < np.quantile(lissa_influences, 0.1) + lower_quantile_mask = lissa_influences < np.quantile(lissa_influences, 0.3) assert np.allclose( lissa_influences[lower_quantile_mask], analytical_influences[lower_quantile_mask], @@ -258,13 +269,13 @@ def test_influence_linear_model( @pytest.mark.torch @pytest.mark.parametrize( - "nn_architecture, batch_size, input_dim, output_dim, loss, influence_type", + "nn_architecture, data_len, input_dim, output_dim, loss, influence_type", test_cases.values(), ids=test_cases.keys(), ) def test_influences_nn( nn_architecture: nn.Module, - batch_size: int, + data_len: int, input_dim: Tuple[int], output_dim: int, loss: nn.modules.loss._Loss, @@ -272,8 +283,8 @@ def test_influences_nn( hessian_reg: float = 100, test_data_len: int = 10, ): - x_train = torch.rand((batch_size, *input_dim)) - y_train = torch.rand((batch_size, output_dim)) + x_train = torch.rand((data_len, *input_dim)) + y_train = torch.rand((data_len, output_dim)) x_test = torch.rand((test_data_len, *input_dim)) y_test = torch.rand((test_data_len, output_dim)) nn_architecture.eval() @@ -282,18 +293,25 @@ def test_influences_nn( "direct": {}, "cg": {}, "lissa": { - "maxiter": 6, + "maxiter": 10, "scale": 100, }, } + train_data_loader = DataLoader( + list(zip(x_train, y_train)), batch_size=10, shuffle=True + ) + input_data = DataLoader(list(zip(x_train, y_train)), batch_size=10) + test_data_loader = DataLoader( + list(zip(x_test, y_test)), + batch_size=10, + ) multiple_influences = {} for inversion_method in InversionMethod: influences = compute_influences( TorchTwiceDifferentiable(nn_architecture, loss), - x_train, - y_train, - x_test, - y_test, + train_data_loader, + input_data, + test_data_loader, progress=True, influence_type=influence_type, inversion_method=inversion_method, @@ -308,9 +326,9 @@ def test_influences_nn( if infl_type == "direct": continue assert np.allclose( - multiple_influences["direct"], influences, rtol=1e-2 + multiple_influences["direct"], influences, rtol=1e-1 ), f"Failed method {infl_type}" - assert influences.shape == (test_data_len, batch_size) + assert influences.shape == (test_data_len, data_len) elif influence_type == InfluenceType.Perturbation: for infl_type, influences in multiple_influences.items(): if infl_type == "direct": @@ -318,7 +336,7 @@ def test_influences_nn( assert np.allclose( multiple_influences["direct"], influences, rtol=1e-1 ), f"Failed method {infl_type}" - assert influences.shape == (test_data_len, batch_size, *input_dim) + assert influences.shape == (test_data_len, data_len, *input_dim) else: raise ValueError(f"Unknown influence type: {influence_type}") # check that influences are not all constant From 20390a4015588f0c58b3fe91ef5eabea5fd62aa9 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 6 Apr 2023 13:14:28 +0200 Subject: [PATCH 041/436] update notebooks and clean tests --- notebooks/influence_imagenet.ipynb | 193 +++++++++++++++++----------- notebooks/influence_synthetic.ipynb | 180 +++++++++++++++----------- notebooks/influence_wine.ipynb | 37 +++--- notebooks/support/torch.py | 48 +++---- src/pydvl/influence/general.py | 9 +- tests/influence/test_influences.py | 60 +++------ 6 files changed, 290 insertions(+), 237 deletions(-) diff --git a/notebooks/influence_imagenet.ipynb b/notebooks/influence_imagenet.ipynb index 0bd47a5c2..790ae93c5 100644 --- a/notebooks/influence_imagenet.ipynb +++ b/notebooks/influence_imagenet.ipynb @@ -52,16 +52,7 @@ "metadata": { "nbsphinx": "hidden" }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/fabio/.local/lib/python3.8/site-packages/requests/__init__.py:109: RequestsDependencyWarning: urllib3 (1.26.9) or chardet (5.1.0)/charset_normalizer (2.0.12) doesn't match a supported version!\n", - " warnings.warn(\n" - ] - } - ], + "outputs": [], "source": [ "%autoreload\n", "%matplotlib inline\n", @@ -70,6 +61,7 @@ "import numpy as np\n", "import os\n", "from torch import nn\n", + "from torch.utils.data import DataLoader\n", "\n", "from support.common import (\n", " plot_sample_images,\n", @@ -205,6 +197,32 @@ "test_x, test_y = process_imgnet_io(test_ds, label_names)" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, let's wrap the datasets in pytorch data loaders" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = 256\n", + "train_data_loader = DataLoader(\n", + " list(zip(train_x, train_y)), batch_size=batch_size, shuffle=False\n", + ")\n", + "val_data_loader = DataLoader(\n", + " list(zip(val_x, val_y)), batch_size=batch_size, shuffle=False\n", + ")\n", + "test_data_loader = DataLoader(\n", + " list(zip(test_x, test_y)), batch_size=batch_size, shuffle=False\n", + ")" + ] + }, { "attachments": {}, "cell_type": "markdown", @@ -221,7 +239,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -238,10 +256,8 @@ " \"model_ft\",\n", " model_ft,\n", " nn.CrossEntropyLoss(),\n", - " train_x,\n", - " train_y,\n", - " val_x,\n", - " val_y,\n", + " train_data_loader,\n", + " val_data_loader,\n", " MODEL_PATH,\n", ")\n", "# Set use_cache=False to retrain the model\n", @@ -250,12 +266,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -279,19 +295,19 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "f1_score of model: 0.8750542770299609\n" + "f1_score of model: 0.9167028513533073\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -329,18 +345,32 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e3987ef307b244daa52901a37e8c6a74", + "model_id": "412bb574c84a43acb7c996f051525f44", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Batch Test Gradients: 0%| | 0/1 [00:00" ] @@ -482,12 +510,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -529,7 +557,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -545,12 +573,12 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -576,12 +604,12 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -627,7 +655,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -648,14 +676,19 @@ "\n", "corrupted_train_x, corrupted_train_y = process_imgnet_io(corrupted_dataset, label_names)\n", "\n", + "train_data_loader = DataLoader(\n", + " list(zip(corrupted_train_x, corrupted_train_y)),\n", + " batch_size=batch_size,\n", + " shuffle=False,\n", + ")\n", + "\n", + "\n", "mgr = TrainingManager(\n", " \"corrupted_model\",\n", " corrupted_model,\n", " nn.CrossEntropyLoss(),\n", - " corrupted_train_x,\n", - " corrupted_train_y,\n", - " val_x,\n", - " val_y,\n", + " train_data_loader,\n", + " val_data_loader,\n", " MODEL_PATH,\n", ")\n", "losses = mgr.train(n_epochs=50, use_cache=True)" @@ -663,12 +696,12 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -685,14 +718,14 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "F1 score of model with corrupted data: 0.8112659060991664\n" + "F1 score of model with corrupted data: 0.801975664599427\n" ] } ], @@ -711,18 +744,32 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "fd88eebcafe240609c436d98bfe60d17", + "model_id": "698b9b04ee834883b6736787bff83a76", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Batch Test Gradients: 0%| | 0/1 [00:00" ] @@ -823,12 +868,12 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -847,7 +892,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -881,16 +926,16 @@ " \n", " 0\n", " tables\n", - " -0.156153\n", - " -3.846006\n", - " 3.689853\n", + " -0.077502\n", + " -2.547895\n", + " 2.470393\n", " \n", " \n", " 1\n", " boats\n", - " -0.030673\n", - " -3.689159\n", - " 3.658486\n", + " -0.054209\n", + " -2.377989\n", + " 2.323780\n", " \n", " \n", "\n", @@ -898,11 +943,11 @@ ], "text/plain": [ " label avg_non_corrupted_infl avg_corrupted_infl score_diff\n", - "0 tables -0.156153 -3.846006 3.689853\n", - "1 boats -0.030673 -3.689159 3.658486" + "0 tables -0.077502 -2.547895 2.470393\n", + "1 boats -0.054209 -2.377989 2.323780" ] }, - "execution_count": 24, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } diff --git a/notebooks/influence_synthetic.ipynb b/notebooks/influence_synthetic.ipynb index 2084f59fd..47e0dcefe 100644 --- a/notebooks/influence_synthetic.ipynb +++ b/notebooks/influence_synthetic.ipynb @@ -60,8 +60,11 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/fabio/.local/lib/python3.8/site-packages/requests/__init__.py:109: RequestsDependencyWarning: urllib3 (1.26.9) or chardet (5.1.0)/charset_normalizer (2.0.12) doesn't match a supported version!\n", - " warnings.warn(\n" + "/Users/fabio/.local/lib/python3.8/site-packages/torchvision/io/image.py:13: UserWarning: Failed to load image Python extension: dlopen(/Users/fabio/.local/lib/python3.8/site-packages/torchvision/image.so, 6): Symbol not found: __ZN3c106detail19maybe_wrap_dim_slowExxb\n", + " Referenced from: /Users/fabio/.local/lib/python3.8/site-packages/torchvision/image.so\n", + " Expected in: /Users/fabio/.local/lib/python3.8/site-packages/torch/lib/libc10.dylib\n", + " in /Users/fabio/.local/lib/python3.8/site-packages/torchvision/image.so\n", + " warn(f\"Failed to load image Python extension: {e}\")\n" ] } ], @@ -91,7 +94,8 @@ " TorchLogisticRegression,\n", ")\n", "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n", - "from torch.optim import AdamW, lr_scheduler" + "from torch.optim import AdamW, lr_scheduler\n", + "from torch.utils.data import DataLoader" ] }, { @@ -265,20 +269,10 @@ "id": "bdef13ee", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Converting tensor to type torch.Tensor.\n", - "Converting tensor to type torch.Tensor.\n", - "Converting tensor to type torch.Tensor.\n", - "Converting tensor to type torch.Tensor.\n" - ] - }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "487c5262408849c89263b290a2f24d30", + "model_id": "0aa94baf14a84fcb88c46b8fd0fc3e8f", "version_major": 2, "version_minor": 0 }, @@ -298,21 +292,29 @@ "num_epochs = 50\n", "lr = 0.05\n", "weight_decay = 0.05\n", - "batch_size = 128\n", + "batch_size = 256\n", + "\n", + "train_data_loader = DataLoader(\n", + " list(zip(train_data[0], train_data[1].astype(float))),\n", + " batch_size=batch_size,\n", + " shuffle=True,\n", + ")\n", + "val_data_loader = DataLoader(\n", + " list(zip(val_data[0], val_data[1].astype(float))),\n", + " batch_size=batch_size,\n", + " shuffle=True,\n", + ")\n", "\n", "optimizer = AdamW(params=model.parameters(), lr=lr, weight_decay=weight_decay)\n", "scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=num_epochs)\n", "losses = fit_torch_model(\n", " model=model,\n", - " x_train=train_data[0],\n", - " y_train=train_data[1].astype(float),\n", - " x_val=val_data[0],\n", - " y_val=val_data[1].astype(float),\n", + " training_data=train_data_loader,\n", + " val_data=val_data_loader,\n", " loss=F.binary_cross_entropy,\n", " optimizer=optimizer,\n", " scheduler=scheduler,\n", " num_epochs=num_epochs,\n", - " batch_size=batch_size,\n", ")" ] }, @@ -332,7 +334,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -364,7 +366,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 12, @@ -451,25 +453,17 @@ "execution_count": 14, "id": "f817a6c3", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Converting tensor to type torch.Tensor.\n", - "Converting tensor to type torch.Tensor.\n", - "Converting tensor to type torch.Tensor.\n", - "Converting tensor to type torch.Tensor.\n" - ] - } - ], + "outputs": [], "source": [ + "train_data_loader = DataLoader(list(zip(x, y.astype(float))), batch_size=batch_size)\n", + "test_data_loader = DataLoader(\n", + " list(zip(test_data[0], test_data[1].astype(float))), batch_size=batch_size\n", + ")\n", + "\n", "influence_values = compute_influences(\n", " differentiable_model=TorchTwiceDifferentiable(model, F.binary_cross_entropy),\n", - " x=x,\n", - " y=y.astype(float),\n", - " x_test=test_data[0],\n", - " y_test=test_data[1].astype(float),\n", + " training_data=train_data_loader,\n", + " test_data=test_data_loader,\n", " influence_type=\"up\",\n", " inversion_method=\"direct\", # use 'cg' for big models\n", ")" @@ -524,7 +518,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -569,28 +563,19 @@ "execution_count": 17, "id": "643977a7", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Converting tensor to type torch.Tensor.\n", - "Converting tensor to type torch.Tensor.\n", - "Converting tensor to type torch.Tensor.\n", - "Converting tensor to type torch.Tensor.\n" - ] - } - ], + "outputs": [], "source": [ "y_corrupted = np.copy(y)\n", "y_corrupted[:10] = [1 - yi for yi in y[:10]]\n", "\n", + "train_corrupted_data_loader = DataLoader(\n", + " list(zip(x, y_corrupted.astype(float))), batch_size=batch_size\n", + ")\n", + "\n", "influence_values = compute_influences(\n", " differentiable_model=TorchTwiceDifferentiable(model, F.binary_cross_entropy),\n", - " x=x,\n", - " y=y_corrupted.astype(float),\n", - " x_test=test_data[0],\n", - " y_test=test_data[1].astype(float),\n", + " training_data=train_corrupted_data_loader,\n", + " test_data=test_data_loader,\n", " influence_type=\"up\",\n", " inversion_method=\"direct\",\n", ")\n", @@ -608,8 +593,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average mislabelled data influence: -0.7444811400091976\n", - "Average correct data influence: 0.00821720819296775\n" + "Average mislabelled data influence: -0.7553824006631059\n", + "Average correct data influence: 0.01002977552148307\n" ] } ], @@ -636,7 +621,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3sAAAIfCAYAAADJ38UbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAACyjElEQVR4nOzdd3gU1f7H8fd3d9MDofcuWAhVEBFRFFFsP70W7AWsXHu/9l4vNmxcC2JX7OLF3hBBRKQHFSnSe00vu+f3x67ekARIIMlsNp/X88yT3ZnZmc9u2n73nDnHnHOIiIiIiIhIbPF5HUBEREREREQqn4o9ERERERGRGKRiT0REREREJAap2BMREREREYlBKvZERERERERikIo9ERERERGRGKRiT0RkN5nZEDNbaGZBM3vJzA4xM2dmrbzOFk0ir8tcMys0s++2s8+dZragmqN5wszaRX5O+nudZWfK+zMd+fn/qrpyxRoz+9PMbq3gY2rMz5GIVD8VeyIiEbvyRtXM/MCLwNtAG+DKqsgWI0YB04EOwInb2edhoG+1JSrGzPpH3jS3q6ZTLgOaAz9V5EFmVmRmQ6sk0fZNJpx1ZSRDdb9WUcnMXtjeBxfRzMxuNbM/vc4hIlVPxZ6IyO5pDqQCnzjnVjjntngdKIp1Ar50zi1zzm0sawfnXJZzbn015/KEcy7onFvtnCv0OsvOOOcKIllDXmcpLzOLK886EZFYpmJPRGQ7/mrpM7OLzGyJmW01s3Fm1jSyfSjh1hmA7yMtHYeUcZwyu8CVbKExs6aRc64zs0wzm2RmB5dxnMPN7HszyzGzeWZ2VInjNjGzMWa2xszyzOx3Mzuv2PaOZvaemW02s01m9oWZdS22vW7k8avNLN/MlpnZozt5rfYys/FmlhVZPjazjsVzA37glchzGLqd42zTjfOv+2Z2vJn9ZmbZZvadmXUqts/QyGs5yMwyIs/5JzPrUXKfEudq9df3LNJCNTGyaXFk/Xc7eL7OzK6MvI7ZZrbCzK4ssU9zM3sr8jrnRnL3LrZ9m+53xe6fYmb/jXx/F5X4Gfkz8jqOiezrIusr9D0zs1fN7PVi94dFjndBsXWvm9mbkdt//wyX57Xa3u/MDvIEzOwOC3eHzo+8nk9W4LX8K98xZvaDmeUBF9j/focvj7x2+WaWFHn8CyUybNPaVeyxV0fy5JjZO2bWILL9TuB8YMBf34u/vldmlmpmI4s9boaZnVjifN3NbHLk+f5hZqfs6DUq9rhTIr8TeWY2GehWYruZ2fOR1zI38jN0v5klRLYPBe4B2hbLfWdk2xkW/t3ZYmbrLfw7vWd5colIdFKxJyKyY/sBhwLHAIOBroS7GgKMBfpEbh9PuJVv8q6cxMySgG+BOsBRQE/gE+BLM9unxO4PA/cD3Ql3ARxrZvWLHWdCZNuZQGfgciAnsr0p8AOwFjiIcJfJ34HvzKxx5Pj3AvtGnlMn4FTg151k/wJIBAZEllTgMzOL539dAAEui9weW4GXpznwz8jz6Uf4NXqxxD4+4N/AJYS/J+uA8ZFs5bGM8PMl8vjmbL+r6V/uAL4j/L36N/CImR0P4TfcwIfA3sCxkWOuIfz9bLST4z4IvEL4TfxbwAvF3nDvBwSBqyIZ/3pdK/Q9I/yzdmix+wMJv2YDi607FPimjMfu7LXa0e/M9owGLgXuJPwzexKwCCr8Wj4CPATsA3xcLOPASObuQMFOshTXJ/JcjgSOBnpEshJ5Tm8AP/K/78XYSN6PI+c6FehCuAvzW2Z2WOQ5JRH+/d4cOcc5wPVAkx2FMbOewJvAO5HjPwyMLLkb4d/vMwi/DlcBw4CbI9vHEn6NlhfL/df3J4H//SwdTvhnbXzk91hEaiLnnBYtWrRocQ7gJeCrEvfXAgnF1v0LWFXsfjvAAf2LrTsksq5VWfeL7VcEDI3cHkr4zVegxD7fAI+XOM6JxbY3jawbHLl/PpBX8lzF9r8TmFJinQELgasi9z8CXqrA63Y+4WKyUYlcucA5xdY54KydHOtOYEGJ+0VA42LrTgVCQGKx184BhxXbpz6QBZxfbJ+iEudqFXncIZH7/SP325XjOTvg1RLr3gAmRm4fFtmnc7HtCcAq4PayfnaK3b+m2GP8QCZwcVk/N8XWVfR71q54vsjP3rVEfrYJFwkO2GM7P9NlvlaU43emjCwdI8c6eTvby/Na/pXv7DLybAZSS6z/DnihxLpbgT9LPDYLSCu27ojIeTpG7r8AfFfiOIcQ/h1MK7H+ReDDyO0LIseuX2x7l8ixb93Ba/UaMKnEusso8TeojMddDfyxvee6g8c1iBz7wPL+bGnRoiW6lgAiIrIjvznn8ovdX0m4kKls+wHNgM3hhoG/JRAumoqb+dcN59waMwsWy9QLmOecW76D8/Qys6wS65MItwgBPAO8F+km9zXwGfC52/71WumRc/59rV0k1++RbbtrpXNuXfH7hAvUJsDSYut/LHb+TWb2ayWdf3t+LHF/EuHucUTOu8E5N69Ypnwz+6kcmWYWe0zQzNay85+5Cn3PnHN/RrosDoz8/NSLHON2M+tMuDVrqXNu4U7OW5aK/s7sG/n6xXa2V+S1nFrG4391zpX8eS+veW7b63AnRb52BrY3aux+QDywosTvcjzwR7HH/+qc2/TXRufcXDPb2TW/nQl/f4v7oeROZnYh4YKyHZACBChHby4Ld32+g3ALZiPCv2cAbfnfcxeRGkTFnojIjpXs8uX43xug8vrrDfffj7PwKJ7F33z5CHe7O6GMx+fsJNNfjy8PH+E3i5eVsW0LgHPuczNrQ7gL3iGEWxPmmNlhzrlgOc9Tmcr6HkDFLkUoq+iJ1sE6ynq+O3yuu/g9+4Zwq1kQ+ME5l2tm3xPu8ri9Lpy7mr+ivzO7Kruc60KUzlRZPw8+wr9L+5WxrSJdSHeJmQ0BngZuJNyleyswBLhvJ49LJlxw/0C42+eayKYMwoWqiNRAumZPRKTqrY18bVFsXQ+2fbM5jfCUBFudcwtKLCsrcK5fgM62/fnQphFuDVlexnn+bj1zzm10zr3pnLuY8LVXAwi3KpQlI3LOv6+filwbuBcwtwLZd9ffUzaYWT3CXRH/ag1aC/hLDBSyL9v66424v6Lni+hX7HwZQMNIK9lfmRKA/dn916SgrIwV/J5B+Lq9AcAg/tda9FcBeAg7LvYq+lrtyPTI1yO2s70qXsu1bPv7CKV/HgD2MbO6xe73i3z96/tc1vdiGuGW0sQyfseWFnv8PpGfUwDMLB1I20nuecUy/OXAEvcPBmY45x51zv3inPuDcAtfcWXl3gdoDNzinPvOOfcr4e7Q1VWoi0gVULEnIlL1FgBLgDvNbG8Lj774GP9roQJ4HVhMeDCEIyw8MuP+ZnaTmf2jAud6M3KucRYenbK9mR1mZqdGtj9F+E3eR2Z2UOQ8/c3sPjPrBxC5faKFR9jsRHhglCy27TJZ3BuEB/cYa2b7mlkvwgOLrKBiA7HsDgf828wOtvDIoq8Qvtbtjcj2qZH7D5pZJzM7Eri9xDGWEG7xOdrCI5ru7I33sWZ2WeR4lxO+lvCRyLZvIud8w8wONLMukUyJhAfr2B2LgUPNrMVfBfYufM/+ylgfOI7/FXbfEB4EpQE7LvYq+lptl3NuAeGf/2fM7Cwz28PM9rP/jW5aFa/lV8AgMxti4dFpbyQ8YFGpeIRHkO1i4ZFxnwbGRTJD+Huxt5mlm1mjSBH6TeT475vZP8ysg5n1svCIoBdGHvcG4Z/H1yw8Kmdfwtf0leyyXdJjwAGR7/eeZnYC4Wsti/sd6GrhEWz3iLyOJQcbWgw0M7MDIrmTCX9P84HLI487jPDgLw4RqbFU7ImIVDHnXBHhQqAJMIPwG8ZbKNa10DmXR7iVZRowBpgPvE94pL4lFThXTuQ4cwkXXL9GzpcU2b4GOABYHzn+74TfaLclPOAFhAeXuJtwK+E0wqNCHuW2M4egcy6XcKtMPvA94a5j2cCRzrkq77YWESI82uCzhDM3A46JvB648Lx+pxNujZsN3AbcUPwAkdfmJsLd31YRHvRkR+4m3Co2K3LuG5xzH0SO5YB/AL8B44GfI5kOd7s/j+C1hK/N/JNwkQ0V/J5FMq4k/HOWSfjnEsKvzWZgvnNuxQ4eW9HXameGEf7e3Uv4Z/YDoH3kXFXxWr5M+PfiacKvV2vgiTL2m0q4W+OXhK+DnAOcV2z76EieyYS/F6dH8h5H+PfrsWK5jyE8ENJfv6dHAw0j53g9su9adsA59wvhUTZPi2S5kfDgK8U9C7xK+O/IDMItoHeW2OdDwiN6jo/kviHyWp5FeBTODMIjdF5H2V2gRaSGsPDfJBERkZrJwvOGveCcq7br0C08v93ZzrnXquucUr3M7CXCo48O8jqLiMiuUsueiIiIiIhIDFKxJyIiIiIiEoPUjVNERERERCQGqWVPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEBrwNUtUaNGrl27dp5HUNEREREJKr88ssv651zjb3OUV6DD01xGzYGK/24v8zO/9w5d2SlHzgKxHyx165dO6ZNm+Z1DBERERGRqGJmS7zOUBEbNgaZ+nmbSj+uv/kfjSr9oFEi5os9ERERERGp+RwQIuR1jBpFxZ6IiIiIiNQAjqBTsVcRGqBFREREREQkBqllT0REREREol64G6fzOkaNopY9ERERERGRGKSWPRERERERqRE0QEvFqNgTEREREZGo53AEnbpxVoS6cYqIiIiIiMQgteyJiIiIiEiNoAFaKkYteyIiIiIiIjFILXsiIiIiIhL1HBBUy16FqNgTEREREZEaQd04K0bdOEVERERERGKQWvZERERERCTqOdDUCxWklj0REREREZEYFBXFnpm1NrNvzWyemWWY2ZVl7GNm9oSZLTCz2Wa2rxdZRURERETEG6EqWGJZVBR7QBFwrXOuM9AXuNTMOpfY5yigU2S5CBhVvREr7o8//mDdunVexxARERERkVooKoo959wq59z0yO1M4FegZYndjgdecWFTgHpm1ryao5abc46zzjqL9PR03n33Xa/jiIiIiIjUaA5HsAqWWBYVxV5xZtYO6An8VGJTS2BZsfvLKV0Q/nWMi8xsmplN86plzcwYPXo0bdq0YciQIZxyyimsXbvWkywiIiIiIjWeg2AVLLEsqoo9M0sF3gOucs5t3dXjOOeec871ds71bty4ceUFrKAuXbowZcoUHnjgAT766CPS09MZO3YsTqMIiYiIiIhIFYuaYs/M4ggXeq87594vY5cVQOti91tF1kW1QCDAjTfeyIwZM+jQoQOnnXYaJ598MmvWrPE6moiIiIhIjeHQAC0VFRXFnpkZMBr41Tn36HZ2GwecExmVsy+wxTm3qtpC7qbOnTszadIkHnroIcaPH0/nzp1544031MonIiIiIiJVIiqKPeBA4GxgoJnNjCxHm9lwMxse2ecTYBGwAHgeuMSjrLssEAhwww03MHPmTPbcc0/OPPNMTjjhBFatqjE1q4iI7EBBcBNLt77Jws3/YXPeLH2gJyJSqYxgFSyxLOB1AADn3A+w41fahf9jXlo9iarW3nvvzQ8//MDjjz/OrbfeSnp6OiNHjuSss84i3MgpIiI1zYbcH5mx5jIcjpArYLE9T+PkQ+nW+N+YRctnqyIiNZcDQvoMrUL038cjfr+fa6+9lpkzZ7LPPvtwzjnncNxxx7FiRdRfhigiIiWEXAEz115F0OUScnlAiKDLZV3Ot6zJ+cLreCIiUkup2PPYXnvtxffff89jjz3G119/TZcuXXjppZfU9UdEpAbZnDcT50pf5h90uazI/MCDRCIisUndOCtGxV4U8Pv9XHXVVcyaNYsuXbowbNgwjjnmGJYvX+51NBER2boVRo2CCy+ESy+Fjz+GYLDETjt6sxDbbyRERCR6qdiLIp06dWLChAmMHDmSCRMmkJ6ezujRo9XKJyLilQ8+gPbtcd98w5ZOnclu0QbuvRe6dIEFC/7erV5ijzKvy/NbEi3rnFCdiUVEYpZDLXsVpWIvyvh8Pq644gpmz55Nz549ueCCCzjyyCNZunSp19FERGqXyZNh+HB+f/JlTvcN4PRvizjpe+PK/S8j6/yL4fDDw61+gM/i6NHkcfyWhM8SAR8+S6Jx8qE0TT7c2+chIhJDQs4qfYllKvai1B577ME333zD008/zaRJk+jSpQvPP/+8WvlERKrLAw+w+fqbuea131i3LpP8/CIKC4PMm7eCS2cn4Xr1gldf/Xv3hkkHcHDrr9mrwQ10qn85fZq/RPcmD2skThER8Yz+A0Uxn8/HJZdcwpw5c+jduzcXXXQRRxxxBEuWLPE6mohIbMvKgm++4b3EPSkq2vb6vFDIsWFDJn8OPA7Gjt1mW7y/Hm3qnkaHeheTltC1OhOLiMQ8deOsOBV7NUD79u356quvGDVqFFOmTKFLly6MGjWKUKj0yG8iIlIJMjMhNZXlG/IoKirrb62xLpACW7ZUezQREZHyUrFXQ/h8PoYPH87cuXPp27cvl1xyCYMGDWLx4sVeRxMRiT0NG0JhIQe0jCcxMVBqczAYYs+tK6BDBw/CRZfcopUs3jyaBZueZmv+PK/jiEgMcxhBfJW+xLLYfnYxqG3btnzxxRc8//zzTJs2ja5du/L000+rlU9EpDLFx8NZZzFw1ufUq5dCXJz/702JiXEc2n8P6r06OjwdQy22MvNjflh+DH9seoKFm0fx06qzmLf+Xl1fLiJVRgO0VIyKvRrIzLjggguYO3cu/fv357LLLmPgwIEsXLjQ62giIrHj5psJ/PdjRrdfzUlHdaZp0zTatWvEVSd15vqfXgq36h15pNcpPVMY3ELGhtsJuXwchUCIkMtjZdYHbMr7xet4IiKCir0arU2bNnz66ae8+OKLzJw5k65duzJy5Ei18omIVIZmzWDiRBLnzeHCe87ljS3/ZfTC1zj8hrOxffYOD87iq73/Rtfn/oDhL7U+6PJYlf1fDxKJSKzTAC0VV/pCBKlRzIxhw4Zx+OGHc/HFF3PVVVfx7rvv8uKLL9KpUyev44mI1GytWoUnVl+2DGbPhrg46NcPUlO9ThYFfLCdN0mmz5JFRKKC/hrHiFatWvHf//6Xl19+mblz59KtWzcee+wxgsHgzh8sIiI71ro1HHMMHHGECr2IRsn9cZT+H+OzBFqkHudBIhGJfUbQ+Sp9iWWx/exqGTPjnHPOISMjg0GDBnHNNddw0EEH8fvvv3sdTUREYkycrw5dGz2IzxLwWSJGHD5LoG3ds6iX2MPreCIigrpxxqQWLVowbtw4Xn/9da644gp69OjBPffcw9VXX43fX/r6ChERkV3RLPUI6if1Yk32l4RcHo2TBpAS397rWCISoxwQUltVhejVilFmxllnnUVGRgZHHHEE119/Pf379+fXX3/1OpqIiMSQBH9D2tQ9jXZpQ1XoiUiV0wAtFaNiL8Y1b96cDz/8kNdff5358+fTs2dPHnroIYqKiryOJiIiIiJSI5jZkWb2u5ktMLMby9ieYGZjI9t/MrN2HsQsRcVeLWBmnHHGGWRkZHDMMcdw44030q9fPzIyMryOJiIiIiJSLs55M0CLmfmBp4GjgM7A6WbWucRu5wObnHMdgceAhyr56e8SFXu1SLNmzXj33XcZO3YsixcvZt999+WBBx5QK5+IiIiIyPb1ARY45xY55wqAt4DjS+xzPPBy5Pa7wGFm5nkfURV7tYyZccopp5CRkcHxxx/PzTffTN++fZkzZ47X0UREREREdiiEVfoCNDKzacWWi0qctiWwrNj95ZF1Ze7jnCsCtgANq+ZVKD8Ve7VUkyZNePvtt3nnnXdYunQpvXr14t5776WwsNDraCIiIiIipTggiK/SF2C9c653seU5j59qpVGxV8udfPLJzJs3j5NOOonbbruN/fffn1mzZnkdS0REREQkWqwAWhe73yqyrsx9zCwApAEbqiXdDqjYExo1asSbb77J+++/z8qVK+nduzd33XUXBQUFXkcTEREREYnwZoAW4Gegk5m1N7N44DRgXIl9xgHnRm6fDHzjnHOV9tR3kYo9+dsJJ5xARkYGp556KnfeeSf77bcfM2bM8DqWiIiIiIhnItfgXQZ8DvwKvO2cyzCzu83suMhuo4GGZrYAuAYoNT2DF1TsyTYaNmzIa6+9xkcffcTatWvp06cPt99+u1r5RERERMRTDgjhq/SlXOd27hPn3J7OuT2cc/dF1t3unBsXuZ3nnBvinOvonOvjnFtUda9E+anYkzIdd9xxZGRkcMYZZ3DPPffQq1cvpk2b5nUsEREREanFgs4qfYllKvZkuxo0aMDLL7/Mf//7XzZu3Ejfvn255ZZbyM/P9zqaiIiIiIjshIo92aljjjmGjIwMzjnnHO6//3723Xdfpk6d6nUsEREREalFHFZVUy/ErNh+dlJp6tWrx4svvsinn37K1q1bOeCAA7jxxhvJy8vzOpqIiIiIiJRBxZ5UyJFHHsncuXM577zzeOihh+jZsydTpkzxOpaIiIiI1AIh56v0JZbF9rOTKpGWlsbzzz/P559/TnZ2NgceeCDXX389ubm5XkcTEREREZEIFXuyy4444gjmzp3LBRdcwMMPP0yPHj2YPHmy17FEREREJAY50DV7FRTbz06qXN26dXn22Wf58ssvyc/Pp3///lxzzTXk5OR4HU1EREREYoij8qdd0NQLIuUwaNAg5syZw/Dhw3nsscfo3r07EydO9DqWiIiIiEitpWJPKk2dOnV45pln+OabbwgGgwwYMIArr7yS7Oxsr6OJiIiISAwI4av0JZbF9rMTTxx66KHMnj2bSy+9lCeeeIJu3boxYcIEr2OJiIiIiNQqKvakSqSmpvLkk0/y3XffAXDIIYdw+eWXk5WV5W0wEREREamRnIOg81X6Esti+9mJ5wYMGMDs2bO58sorefrpp+nWrRvffvut17FEREREpMYxQlWwxDIVe1LlUlJSePzxx5kwYQJ+v5+BAwdyySWXkJmZ6XU0EREREZGYpWJPqs1BBx3ErFmzuOaaa/jPf/5D165d+eqrr7yOJSIiIiI1gEPdOCsqtp+dRJ3k5GQeeeQRfvjhBxISEjj88MO5+OKL2bp1q9fRRERERERiioo98US/fv2YOXMm119/PS+88AJdunThiy++8DqWiIiIiESxIL5KX2JZbD87iWpJSUn8+9//ZvLkyaSmpjJ48GAuuOACtmzZ4nU0EREREYkyDiPkKn+JZSr2xHP7778/06dP58Ybb2TMmDGkp6fzySefeB1LRERERKRGU7EnUSExMZEHHniAKVOmUK9ePY455hiGDRvGpk2bvI4mIiIiIlFC3TgrJrafndQ4++23H7/88gu33HILr776Kl26dOG///2v17FERERERGocFXsSdRISErj33nv56aefaNiwIf/3f//H2WefzcaNG72OJiIiIiIecUDI+Sp9iWWx/eykRuvVqxfTpk3j9ttv56233iI9PZ2PPvrI61giFbIh53t+WnEc3y3pxpTlR7I2+1OvI4mIiEgtoWJPolp8fDx33XUXU6dOpWnTpvzjH//gzDPPZMOGDV5HE9mpDTnfM2fd5WQX/k7I5ZNTtJh5629iVeYHXkcTERGpgYxgFSyxTMWe1Ag9e/Zk6tSp3Hnnnbz99tukp6fzwQd6wyzRbcGmhwm5vG3WhVwuCzc/inPOo1QiIiI1k7pxVlxsPzuJKfHx8dxxxx1MmzaN5s2bc+KJJ3Laaaexfv16r6OJlCm38M8y1xcE1xNyBdUbRkRERGodFXtS43Tv3p2pU6dyzz338P7779O5c2feffddr2OJlJIQaFbm+oCvDj6Lr+Y0NUNBcBN/bHyEH5cfzy+rz2dDziSvI4mISBRRN86KUbEnNVJcXBy33norv/zyC61bt2bIkCGccsoprF271utoIn/rUO8qfJa4zTqfJdEu7Z+YxfY/l11RENzElBX/YMmWl8kqnM/G3MnMXHs5S7a87HU0ERGRGknFntRoXbt2ZcqUKdx333189NFHpKenM3bsWF0PJVGhaerR7NXgDuJ9jQAfAV8aHepdSeu6Q72OFpWWbHmZguBmHIV/rwu5XBZsepyiULaHyUREJBo4Z7pmr4Ki5tmZ2YtmttbM5m5n+yFmtsXMZkaW26s7o0SnuLg4br75ZqZPn0779u057bTTOPnkk1mzZo3X0URoXudEDmz9AwPazOCg1j/RJm2YWvW2Y0PuDzhKX8toBMgqmO9BIhERiTZB56v0JZZF07N7CThyJ/tMdM71iCx3V0MmqUHS09OZPHkyDz74IOPHj6dz5868+eabauUTz5kZfl+iirydSPA3KXO9o4h4f4NqTiMiIlLzRU2x55z7HtjodQ6p2QKBAP/617+YMWMGnTp14owzzuCEE05g1apVXkcTkZ1omza01DWORoA68XuRHNfWo1QiIhItHBDCKn2JZVFT7JXTAWY2y8w+NbP07e1kZheZ2TQzm7Zu3brqzCdRYp999mHSpEmMGDGCzz//nPT0dF599VW18tViIVfIysx3+GXVWcxYPZQ1WeNxLuR1LCmmQVIf9mxwI35Lxm+p+CyBugld6dH0aa+jiYiI1EgWTW9+zawd8F/nXJcyttUFQs65LDM7GhjpnOu0s2P27t3bTZs2rfLDSo3x+++/c9555zF58mSOPfZYnn32WVq0aOF1LKlGzoWYueYCtuRPJ+RygfComE2SB9O58UMep5OSgqE8sgr/IN7XgKS4ll7HERGJWWb2i3Out9c5yqtFen13/luHVPpx7+32YY16HSqixrTsOee2OueyIrc/AeLMrJHHsaQG2Guvvfj+++959NFH+frrr0lPT+fll19WK18tsjFvMlvyZ/xd6EF4lMe1OZ+RVfCbh8mkLH5fImkJXVXoiYjINhwQclbpSyyrMcWemTWzyOgGZtaHcPYN3qaSmsLv93P11Vcza9YsunbtytChQznmmGNYvny519GkGmzKnUzI5ZRa71yITXk/eZBIREREpOpFTbFnZm8CPwJ7mdlyMzvfzIab2fDILicDc81sFvAEcJpT04xUUKdOnfjuu+944oknmDBhAunp6YwePVqtfDEuztcAI77Uep/FEeer70EiERER2RVBfJW+xLKoeXbOudOdc82dc3HOuVbOudHOuf845/4T2f6Ucy7dOdfdOdfXOTfZ68xSM/l8Pi6//HJmz55Nz549ueCCCzjyyCNZunSp19GkijRLPQ4zfxlbjMbJg6o9j8h2FRbCDz/A55/D4sVepxERkRouaoo9keq2xx578M033/DUU08xadIkunTpwvPPP69WvhiUEGhCtyZPE/DVxW+p+C2FeF8jejYbg9+X7HU8EXAOHnsM2raFK6+ERx6BPn3gyCPhN11XKiIC4Kj86/Vi/Zq9gNcBRLzk8/m49NJLOfroozn//PO56KKLePvtt3n++edp166d1/GkEjVIOpD+rSeTmT8XMz914rtgFj2fdznnWJH5Bku3vEBhaDN1E7rTsf6/qJOwj9fRpDrccAN8+y0/P/ocz87PZOPWHPoNuYqLN2RQ55BDYMIE2Gsvr1OKiEgNEz3vdEQ81L59e7766itGjRrFlClT6Nq1K6NGjSIU0jxsscRncaQl9qRuQreoKvQAFm56hAWbRpAXXEnQ5bAp70emrz6D7IKFXkeTqvbrr/Dqq7x5zQNc99Ui5ixYxYq1W/hg8nxOWppC9uVXwY03ep1SRCQqhPBV+hLLYvvZiVSAz+dj+PDhzJ07l759+3LJJZcwaNAgFuu6GaliRaEslme+ss3UEABBl8efW/7jUSqpNi+8QME5Qxn1za/kFRT9vbooGCInr4BXWnQPt+ytWuVhSBER7zkHQWeVvsQyFXsiJbRt25YvvviCZ599lmnTptG1a1eefvpptfJJlcktXIYRV8aWEJn5c6o9j1SzBQtY1X5PAv7S/5ILi0JMWrgeOnWCP/+s/mwiIlKjqdgTKYOZcdFFFzF37lwOPPBALrvsMgYOHMjChepSJ5UvMdAM5wrK2GIkx3Wo9jxSzerWpV72FoqKyv5AqVmDOrB2LdStW83BRESijwZoqRgVeyI70KZNGz777DNGjx7NjBkz6NatG08++aRa+aRSxfnr0yTlaHyWuM16nyXQrt7w7TxKYsYpp5D2zlt07diMuMC2/5YT4wMMb1gAKSnQubNHAUVEpKZSsSeyE2bGeeedR0ZGBgMGDOCKK67gkEMOYcGCBV5Hkxiyd6N7aJE6BJ8lYvhJDLSia+MnqZvQzetoUtWOPhoKC3l0y0x679Oa+ICfpIQ4UpMTuPOoznS852a49Vaw2P70WURkZ8JTL/gqfYllsf3sRCpRq1atGD9+PGPGjGH27Nl069aNxx9/nGAw6HU0iQE+i2fPhrdycJtfOKjNzxzQ8isaJh/sdSypDn4/fPIJCd98xeOv3c3ne+TwTmfjy+AsDr1gCFx2GZx2mtcpRUSiQhCr9CWWqdgTqQAzY+jQoWRkZHDYYYdx9dVXc/DBB/P77797HU1ihM8CBHwpmFpxapdmzWDKFHjkEZKXL6XxjKn42rcLT8tw1VVepxMRkRpKk6qL7IKWLVsybtw4Xn/9da644gp69OjBvffey1VXXYXf7/c6nojsouzCxWzKnUqcvx6Nkg7B70uovpP7fDBoUHgREZFSHMT8gCqVTS17IrvIzDjrrLPIyMjgiCOO4LrrrqN///789ttvXkcTkQpyzjFv/Z1MWXECv298kIx1t/D9soPZmp/hdTQREZFdpmJPZDc1b96cDz/8kNdff5358+fTo0cPHnroIYqKinb+YBGJCmtzvmR11jhCLp+QyyPosikKbWXmmktwTqPviohEBw3QUlGx/exEqomZccYZZzBv3jyOOeYYbrzxRvr160dGhloFRGqCFZnvEHS5pdYXhbLYWjDXg0QiIlKWEFbpy+4wswZm9qWZ/RH5Wr+MfXqY2Y9mlmFms83s1N06aQWo2BOpRE2bNuXdd99l7NixLF68mH333Zf7779frXwiUS7k8rezxUeozAnvveecIxjKxTmNCCwi4qEbga+dc52AryP3S8oBznHOpQNHAo+bWb3qCKdiT6SSmRmnnHIKGRkZHH/88dxyyy307duXOXPmeB1NRLajWer/4bOkUusNSIvCuQ7X5XzHD8sP55sl+/Htkv2Yv/FhQk4fKonUFIWhTHIKl+n3toKcg6CzSl920/HAy5HbLwP/KJ3bzXfO/RG5vRJYCzTe3ROXh4o9kSrSpEkT3n77bd555x2WLl1Kr169uOeeeygsLPQ6mkjUyi9ay6a8n8kvWlOt522R+g/SErrit2QAjDh8lkiXJv/GZ/HVmmVnNudNZ/baq8krWgEECbpclm19nd833Od1NBHZiWAol1lrr+e7JQcxecU/+HZpf5Znvu91LIFGZjat2HJRBR7b1Dm3KnJ7NdB0RzubWR8gHli4i1krRFMviFSxk08+mUMOOYTLL7+c22+/nQ8++IAxY8bQvXt3r6OJRI2QK+S39bewNvtTzBJwLp9GyUfQufGD+Cyuys/vszh6NXuR9bnfsz7nB+L9DWiR+g+S4lpW+bkrauHmZwi5vG3WhVweK7M+oFODawn4Uj1KJiI7M3f9razN+YYQBeF5BFwuv264j0R/UxolH+h1vBqhigZUWe+c6729jWb2FdCsjE23FL/jnHNm5nZwnObAq8C5rppG/1LLnkg1aNSoEW+++Sbvv/8+K1eupHfv3tx5550UFETntUAi1W3xpidZm/M5IQoIukxCFLA+9ysWbXq82jKY+WmcfCj7NLqNPepfGpWFHkBO4eIy1xsB8ovWVnMaESmvguBm1mZ/Xeoa4ZDLZdGW5zxKJeXhnBvknOtSxvIRsCZSxP1VzJX5h9jM6gLjgVucc1OqK7uKPZFqdMIJJ5CRkcFpp53GXXfdRZ8+fZgxY4bXsaSGCbkClm99k+mrzmLWmuGsz5ngdaTdtiLrzTJbq1ZkvulRouhVNz4dyhg9zhEkMdC8+gOJSLkUBDdgVnanuryiVWWul205jJCr/GU3jQPOjdw+F/io5A5mFg98ALzinHt3d09YESr2RKpZw4YNefXVV/noo49Ys2YNffr04fbbb1crn5RLyBUyfdVZLNj0IJvzf2ZD7rfMXXclCzY+7HW03VIUyi5zfdDl4Nx2e8TUSh3qX4rPErdZ57Mk2qWdj99XepAZEYkOyXGtt7PFR/3EXtWapSaLtqkXgAeBw83sD2BQ5D5m1tvMXojscwpwMDDUzGZGlh67e+LyULEn4pHjjjuOjIwMzjjjDO655x569+7NL7/84nUsiXJrsz8nu/CPbVrBQi6X5VtfJq9otYfJdk/d7Yx4WTe+K2a7/Y84ptSJ34vezV+mXkJvfJZEYqAleza4gQ71LvU6mojsgM/i6VT/yhIj//oIWDJ71PunZ7lk9zjnNjjnDnPOdYp099wYWT/NOXdB5PZrzrk451yPYsvM6sinYk/EQw0aNODll1/m448/ZsOGDey///7ccsst5Odvb84vqe025H5L0OWUWm8WYHPezx4kqhx7Nrg1MhKmP7LGj9+S2bPhbV7GilppCV3Zr8WrHNZuOge1/orWdU9TUSxSA7RNO5vujf9NWnxXEvxNaZZyJH1bvkNyXBuvo9UIDqKxG2dU02icIlHg2GOPZe7cuVxzzTXcf//9fPTRR4wZM4b99tvP62gSZeJ9jQgXRCUn0jbifGkeJKocdRO6sF+LD1m65QUyC+aRGr8PbdMuIDmundfRREQqVZOUw2iScpjXMaSWUMueSJSoX78+Y8aM4ZNPPmHz5s307duXm266iby8vJ0/WGqNFnVOKXMqAp8lUj+pnweJKk9yXFv2bnQP+7V4j30a3atCT0RESgk5X6UvsSy2n51IDXTUUUeRkZHBsGHDePDBB9l333356aefvI4lUSIlfg/2bng/fkvGb6n4LZkEf3N6NnsJ33ZGeRMREYkJVdCFM9a7carYE4lCaWlpvPDCC3z22WdkZmbSr18/brjhBnJzc72OJlGgWeox9G/9I92aPEPPZi/Tr9W3pMbv6XWs6PHDDzBkCNStC0lJcNBB8NZboFE9RUSkllGxJxLFBg8eTEZGBhdccAEjRoygZ8+eTJ482etYEgX8vkTqJ+1P3YRuGpijuGeegdNOY/MBfXnlw/cZ9cUnLD3vPBgxAoYNg1DI64QiIrKLHFE59UJUU7EnEuXq1q3Ls88+y5dffkleXh79+/fn2muvJSen9IiMUjvkFa1gzpqL+f7PdCYu6c7v62+hKJTldSzvzZ4Nd9/NF6+8RN/kAPf+PpcRc2YwuGAr9zx4D+6332D0aK9TikSFDbk/8uOKk/nyz32ZuPwYVmd/7nUkEakCKvZEaohBgwYxZ84chg8fzqOPPkqPHj344YcfvI4l1awolMX0lSexMXcCjkJCLpc1WR8xa/U5mnz8mWfIu/hirpifQV6wiIJQkJBz5BYV8caiP/jtqivgySfVnXM3ZBX8wS+rzuPrP3swYUl/Fm0aRcgVeR1LKmhD7o9MX3MpWwvmEXJ55BQuZs66m1iR+YHX0UR2StfsVYyKPZEapE6dOjzzzDN8/fXXFBUVcfDBB3PVVVeRnZ3tdTSpJmuyPiLocoH/dUd0FJBbuIit+b94FywaTJzIlF498ftK/+POKyritSYNYeFCyMz0INzObc3PYNnWN1iX8y0hV+h1nFJyC1cwdeXpbMybQsjlUxDawOItz/Hres2FWNPM3/goIbftSM8hl8f8jY/qQyOJappnr+JU7InUQAMHDmT27NlceumljBw5km7dujFhwgSvY0k1yCqYR8iVHqjHESK7cIEHiaKIGbaDN6qGhVv1ouwax5ArZPrqi/l51dnM3ziCOWuv54dlh5NbuNzraNtYsvUlQi6f8NutsJDLY3X2J+QXrfUumFRYduGiMtcXhjYTdLpEQCSWqNgTqaFSU1N58skn+e677wA45JBDuPzyy8nK0rVbsSw1fm98llRqveEjOW4PDxJFkQED6PvzLwTLKPgSAwHOWb0W9toL6tTxINz2Ld3yKpvyphJyuYRcHkGXTX5wHbPXXuN1tG1szZ+Do3SXTR8JZBcu9iCR7KrEQPMy1/t9yfjL+PsiEk3UslcxKvZEargBAwYwe/ZsrrzySp5++mm6devGt99+63UsqSJNU/+B3xIp/ufbiCMp0Ja0hN7eBYsGl1xCwvPP82zHziT6AyQGAsT5fCT6A5zXYU/2fPRxuOIKr1OWsiLznVJd6iBEVsHv5Bet8yRTWVLjOgH+UutDFJAU17r6A8ku61j/cnyWuM06nyXRPu1CzPTWUCSW6DdaJAakpKTw+OOP8/333xMIBBg4cCD//Oc/yYzSa5Nk1wV8dejZ/B3qJx4I+DHiaZJyLN2bvaopGNLT4f77GXDWOUzblMO9Hfbi1r268J0lcP01N0Dv3jB0qNcpSwmxnevzzMpsSfNK27Tz8Fn8Nut8JNAwqT9JgRYepZJd0SxlMJ0b3k68vxGGn4CvDh3rXUL7tPO9jiayQw5Nql5RFusX4vbu3dtNmzbN6xgi1SYnJ4fbbruNxx57jDZt2vDCCy8waNAgr2NJFfjr73etL/JK+vnn8Kibn30GhYWw335wySVw/PFRd70ewB8bH2XJlpdxFGyzPjnQln6tPo2q7+/mvBn8uv4usgr/wGdxtEg9iT0b3IDfl+B1NNkFzjmCLge/JalFr5Yys1+cczWmW0ja3k1d/+dOrfTjfjLgyRr1OlSEij2RGDV58mSGDRvG/PnzueiiixgxYgR169b1OpbUEsFQNkYAn4qAnSoKZTF15WnkFa0i6HLwWQJGgF7Nx5CW0NXreEC4KChedIZcAUZABYJIDVcTi71+z51W6cf9bMATNep1qIiA1wFEpGr069ePmTNncvvtt/Poo4/y6aef8vzzzzN48GCvo0kMy8yfx/wNN5Nd8DtgNEweyJ4N7yXOX8/raFEr4Eulb8v3WZv9JZvyppMUaEmLOv8g3t/A62hsyJnEbxvvJ6dwEXG+erRNO492aeeX6s4pIlItHDHf7bKy6SM5kRiWlJTEiBEjmDRpEikpKRx55JGcf/75bN682etolSboCvht4yg+XzKYT/8cyKx195Ef3OR1rFopv2gts1afSVbBPBxBHEVsyPmWWavP1dxdO+GzeJqlHsM+jW6jXb3zoqLQ25w3nZlrLyMnMkx/YWgzizaPYsGmkR4nExGR8lKxJ1IL9O3blxkzZnDDDTfw0ksv0aVLFz799FOvY1WKn1ZfwR9bXiIvuIaC0EaWZH7A9yvOJBgqObqhVLVVWWNLTQbuKCS3aAmZ+bM8ShX9sgp+Z9aa4UxcegBTV/yDtdmfex0JgIWbnixj4u1clm59Rb9fIuIJTapecSr2RGqJxMREHnroIX788UfS0tI4+uijOe+882p0K9+m/Aw25s2MTPQc5igiP7iJFVHyhrk2ySlYWGqQEQhPZp5TuIhVme8wa/W5zF3zTzbkTPAgYfTJKviDX1adxobc7ygMbSSr8Ffmrf8Xy7a+6nU0sgsXlrneMAqC66vknJn5v7Jw0zP8ufkFcgtX7PJxnHMUhbJxLlSJ6UREah4VeyK1TJ8+ffjll1+46aabeOWVV0hPT2f8+PFex9olW/J/LXN90OWyMW92NaeRugk9ypzw3RFk+daXWbDxXjbn/ciG3K+Zt+4KFm0c4UHK6LJ480iCLpfw59VhIZfLok2PE3KlC+fqlBLXabvb4v2NK/18v214gKmrzmDR5qdZsOkJJq84hpWZH1T4OCszP+T7pQfx3ZK+fLtkfxZtGqWiTySGqGWvYlTsidRCiYmJ3H///UyZMoUGDRpw7LHHcu6557JpU8261i050AIr48+YzxJIjWvjQaLarVmdk/BbCsUn3vaRQHJcB3KLlhByuX+vD7lclm99mbyiVR4kjR5b82dRvND7iyNIXtHq6g9UzB7bmXi7bdqwSp9qYXPe9GKTy4dwFBJy+fy64S4KKnAN7trsL8OPCW3AUUTQZbF4y/Ms3vxspeYVEW9onr2KU7EnUov17t2badOmceutt/L666+Tnp7OuHHjvI5Vbo2T9o8MZOHfZr2PAK3rHOdNqFos4KtDrxbv0yTlGPxWh3h/I1qlnU9yYA9CLqfU/j4LsCXvJw+SRo+EQMvtbAlV2iAt2YV/Mm/d7fy0Ygjz1t1BTuGScj2uXmIPejYdRWrcXoCfeH8jOta/gg71LquUXMWtzvqk1PWBAIaf9Tnfl/s4C7ZzneGfW0bjXHC3c4qI1DQq9kRquYSEBO655x6mTp1K48aNOf744znrrLPYsGGD19F2ysxP/xYv0iipd3jOL+KoG78n/VuMJsFf3+t4tVJCoBn7NH6Y/m1/4YDWk2lf/yriA40pe6YfI+BLq+6IUaV92j9LdX31WQJNU44j4Evd7eNvyZ/DTytOYkXW+2wtmMuKrPeYsuJEtuZnlOvxDZL6ckCrDzm8/VwGtJlI27ShVTLJe3i+vrKOaxWayy+vaGWZ60OugKJQ9q6FE5Go4pxV+hLLVOyJCAD77rsvP//8M3feeSdjx44lPT2dDz6o+PUy1S0p0IQDmz/LUe0mcGTbrzi01dukJeztdSwppnnqEHxWutjzWTz1kw70IFH0aJg8gL0a3EHAVw+fJeKzBJql/IO9Gt5eKcf/bf09BF0O8FerVpCgy+G3DfdVyvErS7PUY8ucu89RRKOkg8t9nNT4jmWuD/hSK6V4FhGpaVTsicjf4uPjueOOO5g2bRrNmzfnxBNP5PTTT2f9+qoZea8yxflSiPfX7laiaJUcvwd7NrwfnyXjt1T8lkK8vyndmr2kybmB5nVO4KDWkzmg5Rcc1Pon9m50d6W8Ls45thbMLXPblvzoGsAoLaEbbeuei88SMOL/LnzTGz1AXAV+rzvWv6aM6wwT6Vj/6gq1EIpI9Aphlb7EsrL61YjUWs45KPoVgmsgrgtWBSPO1QTdu3dn6tSpPPjgg9xzzz18/fXXPPPMM5x88sleR5MaqmnqsTRKHsTW/Bn4LYk6Cd305rsYMz8JgaaVfEzDb8kEXenuiwFfSqWeqzJ0bHAVzescz/qcCfgsnibJh5MQqNjf4AZJfejZ9Fn+2Pgw2YULSQg0o2P9y2macmQVpRaR6uQcMT+gSmVTsScS4YIbcJvOg+CfgB9cAS75dKzOzVVyjUq0i4uL47bbbuMf//gHw4YNY8iQIQwZMoSnnnqKJk2aeB1PaiC/L5H6SQd4HaNWaVX3NJZtfX2bQUt8lkirOqd5mGr7UuLak5LWfreO0SCpD/u3fLuSEomI1Gz6WFUkwm2+Eor+AJcLLgsogJy3Ie8jr6N5qmvXrkyZMoX777+fjz76iPT0dMaOHRtuBRWRqNax/hU0ST4MH/EErM7fLWZ71K/8ETVFRKqDBmipGBV7IoALroPCmUBRiS25uOyXqj9QlAkEAtx0001Mnz6d9u3bc9ppp3HyySezZs0ar6OJyA74LJ6uTR7mwNZf0r3pU/Rv9SVdm/wbn8V5HU1ERKqBij0RAJdNybna/rcts1qjRLP09HQmT57MQw89xPjx4+ncuTNvvvmmWvlEolxioAkNkvqQEFAXbBGpyTSpekWp2BMB8LcGX3IZG+Ig4bBqjxPNAoEAN9xwAzNnzmTPPffkjDPO4IQTTmDVqlVeRxMRERGRYlTsiRAeCc/q3g8k8r8WvkTwNcBSh3uYLHrtvffe/PDDDzz88MN8/vnnpKen8+qrr6qVT0RERKqMrtmrGBV7IhGWeCjW8D1IOhni+0HqZVij8ZivgdfRopbf7+faa69l5syZ7LPPPpxzzjkcd9xxrFy50utoIiIiEmMcqBtnBanYEynG4jrhS7sHX4OX8KVehPnqeh2pRthrr734/vvvefTRR/n6669JT0/n5ZdfViufiIiIiIeiptgzsxfNbK2Zzd3OdjOzJ8xsgZnNNrN9qzujiGyf3+/n6quvZtasWXTp0oWhQ4dyzDHHsHz5cq+jiYiISCxw4YnVK3uJZVFT7AEvAUfuYPtRQKfIchEwqhoyiUgFderUiQkTJjBy5EgmTJhAeno6L774olr5KkkwlMPW/FnkFdaOIvqPzNU8+fvnPPrrJ8zetNTrOCIiIjVK1BR7zrnvgY072OV44BUXNgWoZ2bNqyediFSEz+fjiiuuYPbs2fTo0YPzzz+fo446imXLlnkdrUZbvuUlJi87gNmrh/HzyqOYueoMCoObvI5VZV5dNJFzJ4/i1UUTeePPyfzz5xd5KGOc17FERMRDIazSl1gWNcVeObQEir9TXB5ZV4qZXWRm08xs2rp166olnIiUtscee/Dtt9/y5JNPMnHiRNLT03n++efVyrcLNuRMYPHmxwi5XIIui5DLZ2v+TDLWXeF1tCqxOnczz/zxFfmhIoI4HI68YCHjlk9njlr4RERqJYdG46yomlTslZtz7jnnXG/nXO/GjRt7HUekVvP5fFx22WXMmTOH3r17c9FFFzF48GCWLFnidbQaZfnW0YRc7jbrHEVk5s8kv2i1R6mqzqR18/GV8WlrfqiQb9bM8yBRdMovWsuWvOkUBHfUMUZERGqrmlTsrQBaF7vfKrJORGqADh068NVXXzFq1Ch+/PFHunTpwn/+8x+18pVTQbDsXgpGICbf6Mf5/JiVLvZ8+Ijz+ct4RO0ScgXMXXs1Py4/jJlrLmLSsgH8tv4OnAt6HU1EpApV/rQLmnoheowDzomMytkX2OKcW+V1KBEpP5/Px/Dhw5kzZw77778///znPxk0aBCLFy/2OlrUa5B0MEZcmdtS4vbY7eNvyp3E9JX/xw9/dubn5YeyJvOD3T7m7ji4yT6EyvggIODzcVSL7h4kii4LNv6b9TlfE6KAoMvEUcDq7A9ZsmW019FERCSKRE2xZ2ZvAj8Ce5nZcjM738yGm9nwyC6fAIuABcDzwCUeRRWR3dSuXTu+/PJLnnvuOX7++We6du3K008/TSgU8jpa1GqddiEBX91tCj6fJdGh/o34fAm7dezNuVOYt/Zisgt+xVFAXtEyFmy8nZVbX9vd2LusXnwy93YfQoIvjiR/PIm+OOJ9AS7fazDtU5t4lisaOBdiZdY7hMjfZn3I5bE882WPUomIVA9NvVAxAa8D/MU5d/pOtjvg0mqKIyJVzMy48MILGTx4MBdeeCGXXXYZ77zzDqNHj2aPPXa/pSrWxPsb0bvlf1m+5UU25k4kIdCU1nUvoF7S/rt97D83jSDk8rZZF3K5LNn8GM3rnI6ZN90mBzZL59MG7fl+7W8UuSD9G+9F48S6nmSJJo4iQq6gzG1FocxqTiMiUr1ifUCVyhY1LXsiUju1adOGzz77jNGjRzNjxgy6devGE088oVa+MsT7G9KhwfX0bjmOrk2fr5RCDyCncGGZ64OhHM+Lh7T4ZP6v1b6c0Ho/FXoRPosnJa5DmdvSEnpWcxoREYlmKvZExHNmxnnnnUdGRgYDBgzgyiuv5JBDDmHBggVeR6sVEgOty1zvswQCvtRqTiPlsWfDO/FZIv/7N+7Hb8l0bHCTl7FERKpUuNulpl6oCBV7IhI1WrVqxfjx43nppZeYPXs23bp147HHHiMY1AiDValt/asjhcP/+CyJVmkXYRY1vf2lmPqJ+9G7+Ts0TTmW1Ph9aJF6Evu1+Ig68Xt7HU1ERKKIij0RiSpmxrnnnktGRgaHHXYY11xzDQcffDC///6719FiVsPkgezZ8CES/M0BHwFfGm3qXU7rtH96HU12IDV+T9Ibj6BPiw/Zu9E9JMe18TqSiEiV09QLFaNiT0SiUsuWLRk3bhyvvvoqv/76Kz169ODhhx9WK18VaZx6DH1aT+TAtnPp23oardMuKnOeOxEREak5VOyJSNQyM8466ywyMjIYPHgw119/Pf379+fXX3/1OlrM8lm8irxdFAzlEQzl7XxHERHZZZp6oWJU7IlI1GvevDkffPABb7zxBvPnz6dnz5489NBDFBUVeR1NhLyiFcxafTaTlu7LpKX7MnPVWeQWLvM6lohITNIALRWjYk9EagQz4/TTT2fevHkcc8wx3HjjjfTr14+MjAyvo0ktFgrlM2PVKWzO+xlHEY4ituRPY8aqU2t1K9/G3MnMXH0BU1ccz8KNj1IQ3Oh1JBGRWknFnojUKE2bNuXdd99l7NixLF68mH333Zf7779frXziifU5X1IUygaKzwsZIuRyWJ/zRYWOFXIFFAY342p4n6JlW19h9tpL2Jg3kazC31i6dQxTVx5PYXCT19FEpIZzVH6rnlr2RESijJlxyimnkJGRwXHHHcctt9xC3759mTNnjtfRpJbJLVpGyJVuwQu6XPKKyteVM+QK+GPDPUxa2psflx3IlOUHsTbrs8qOWi2CoRwWbnqEkMv9e50jXMQu2/qKh8lERKqGmTUwsy/N7I/I1/o72LeumS03s6eqK5+KPRGpsZo0acI777zD22+/zdKlS+nVqxf33nsvhYWFXkeTWiI1fm/8JeYoBPBbEinxe5XrGH9suIvVWe8Qcnk4CikIruX3DTewOfenyo5b5bIKfscoPTejo4D1ud9VfyARiTmuCpbddCPwtXOuE/B15P723AN8v/unLD8VeyJS4w0ZMoSMjAxOOukkbrvtNvbff39mz57tdSypBRokHUxCoCVG/N/rjDgSAi1omHTITh9fFMpkTdZHpVoHQy6PJVueqey4VS7O3wBH2V2qE/xNqzmNiMQcF5UDtBwPvBy5/TLwj7J2MrNeQFOgYn38d5OKPRGJCY0bN+bNN9/kvffeY8WKFfTu3Zu7775brXxSpcz89Gz+Fs3rnELAV4+AL43mdU6hZ7O3MCvdwlVSQXAdvu3sl12woLLjVrnkuLakxu0NJVr3fJZEm7pDPckkIlIOjcxsWrHlogo8tqlzblXk9mrCBd02zMwHPAJcVwlZK2Tn/4lERGqQE088kQEDBnD55Zdzxx138P777/PSSy/Ro0cPr6NJjAr46tCp4e10anh7hR+b4G9ByIXK3FYU2kQwlI3fl1Lm9sLgJtZm/5f8ojWkJfaiQdLBmPkrnKGydWv6DLPXXkpWwa8YARxBOta/gfpJfb2OJiKxoGrGsFrvnOu9vY1m9hXQrIxNtxS/45xzZlZWwkuAT5xzy6t7LlsVeyIScxo2bMgbb7zBqaeeyvDhw9lvv/24+eabueWWW4iPj9/5AUSqid+XSP2kA9mY+3WpbWYB1mV/TrM6J5batjV/FrNXD8URJOTyWJGZTGrcXnRv9go+X0J1RN+ueH9Dejd/i9zCZRSENpIatyd+X5KnmUREdodzbtD2tpnZGjNr7pxbZWbNgbVl7HYAcJCZXQKkAvFmluWc29H1fZVC3ThFJGYdf/zxZGRkcPrpp3P33XfTu3dvpk+f7nUskW2Euz2WFnKFFATXlVrvnGPe2isIuuy/r/ULuRyyCn9lRearVZq1IpLiWpOW0F2FnohUqii8Zm8ccG7k9rnAR6UzuzOdc22cc+0Id+V8pTyFnpkdambtI7ebm9nLZjbGzMpqZSyTij0RiWkNGjTglVde4eOPP2bDhg306dOHW265hfz8fK+jiQBQL6k3Pksutd5n8aQllu5VlFu0mMLQ5lLrQy6P1VkfVkFCEZHo4VzlL7vpQeBwM/sDGBS5j5n1NrMXdvPYzwDByO1HgDjCE7s+V94DqNgTkVrh2GOPZe7cuZx99tncf//99OrVi59//tnrWCLUS+xHnfiu+IpN4eCzRNISe1M3Yd9S+xt+tnfRSnibiIhUF+fcBufcYc65Ts65Qc65jZH105xzF5Sx/0vOucvKefiWzrmlFh7xazBwEfBPoF9586nYE4kxoaKl5G7+F1lrDiF7wzkU5de8ubqqSv369RkzZgyffPIJmzdvpm/fvtx0003k5ZWeFFukupgZ3ZqNpn2960iJ24fU+M50qP8vujT5D2VdyJ8YaEOCv3QPHp8l0bzOkOqILCLiCUdUduOsSlvNrCkwAJjnnMuKrI8r7wFU7InEkGDRYrLWHUVhztuEgosI5n9HzsZzKMgZ53W0qHLUUUeRkZHBsGHDePDBB9l333356ScVxeIdn8XTKu0cerf8iF4tPqRl3TPxWdn/y82M9CZPEfCl4bcUjDh8lkS9xP1pUee0ak4uIiJV6EngZ+B14OnIugOB38p7ABV7IjVcKLiO/OzXyc9+hbwt94DL5n/duwGXS/7W23EuuN1j1EZpaWm88MILfPbZZ2RlZdGvXz+uv/56cnNzvY4mslMp8XvSt9VE9mx4D+3rX0v3pi/Tpcmz5ZrbT6S8ikJZ5Bau0P8PiR4OcFb5S5Ryzj1E+DrAA51zb0VWrwBKdQ/dHv1XEKnB8nPeI3fzv8B8kSuMw90RfWz7h8u5HFxwNRZo6UHK6DZ48GDmzp3L9ddfz8MPP8y4ceMYM2YM/fqVuzu8iCf8vkSapB7rdQyJQcFQDhnrbmFtzjeY+fBbMns3vJVmqUd5HU2kMgZUqWkWA33NrLdzbizhYq/c1LInUkOFgmvChR754HL5q9ADcCUHb3AhzJdWrflqkrp16/Lss8/y5Zdfkp+fT//+/bn22mvJycnxOpqISLWbvfY61uV8g6OAkMujMLSRjPU3szlPU9eIVCcz6wrMB54HRkdWDwBeLO8xVOyJ1FCFeZ8BZXc92LbUSyCQdDTmS62GVDXboEGDmDNnDsOHD+fRRx+le/fuTJw40etYIiLVJr9oLRtzJxGiYJv1IZfH4s3Pe5RKpBhXBUv0GgXc7pzbGyiMrJsA9C/vAVTsidRULkjZf6EMCIClAgkEEgeSlPZQ9WarwerUqcMzzzzD119/TVFREQMGDOCqq64iOzvb62giIlUuL7gWs/gyt+UWLa/mNCK1XjrwWuS2A3DOZQNJ5T2Aij2RGiqQOGg7WxJIbfgeKY3eIbXpZJIbPIv5yv03QSIGDhzInDlzuOSSSxg5ciTdu3fn+++/9zqWiEiVSolrj6OojC0B6if2rvY8Ituq/GkXonzqhT+BXsVXmFkfYEF5D6BiT6SG8gfakFj3WiAR8BP+dU4iIeV8Agn74o9Lx+dv7G3IGi41NZWnnnqKb7/9FuccAwYM4PLLLycrK2vnDxYRqYECvhTap12Ez4p/SOgj4EuiXb0LPcslUkvdBow3s7uAeDO7CXgHuLW8B9BonCI1WGLqP4lLOIyC3I+BIHFJRxOI6+J1rJhzyCGHMHv2bG6++WaeeOIJxo8fz4svvsghhxzidTQppyXZqxm/6gfW52+mT4N0Dm3SiwR/2V3VRGq79vWGkxzXhj+3vEB+cAMNEvuyR/3LSQq08DqaSLRfY1epnHP/NbMjgQsJX6vXFjjROfdLeY9hLsbHL+3du7ebNm2a1zFEJEZMnDiR8847jwULFnDJJZfw0EMPkZqqwW+i2aR1sxjx+6sUhoKECJHgi6dJYn0e73ENyYFEr+OJiHjGzH5xztWY/rkJ7Vu55ndfVunHXXLOTTXqdagIteyJiFTAQQcdxKxZs7jlllsYOXIkn3zyCS+88AKHHXaY19GkDIWhIh6b/wb5ocK/1+WHCliTu4GPV07k1DaHe5hOarvNeTOZv/FBtub/Sry/Hm3TzqNN3XMwi+priESkmpjZ3dvb5py7vTzH0DV7IiIVlJyczGOPPcbEiROJi4tj0KBBDB8+nK1bt3odTUpYnL2SUBl9fgpcERPXzfAgkUhYZv5v/LJ6GFvyZ+EoID+4lgWbRrJg02NeRxOJbrVr6oXWJZb9gOuAPcp7ABV7IiK76MADD2TWrFlcd911PP/883Tt2pUvvvjC61hSTLI/gZALlb0toFFqxTuLNj9DyOVvsy7kclm69RWKQprqRUTAOTesxHIUcCKUOWRumVTsiYjshqSkJEaMGMGkSZNITk5m8ODBXHjhhWzZssXraAK0Sm5Ks8SGGNt2i0v0xXNci4M8SiUCmQW/UlaTghEgr2hV9QcSqTGsCpYa5QvgH+XdWcWeiEgl6Nu3LzNmzOCGG27gxRdfpEuXLnz22WdexxLgjvQLaZxQnyR/Asn+BOIswFHND+TARt29jia1WEpc2b2wHEUkBppVcxqRGqQWdeM0sw4lli7AvcCy8h5DA7SIiFSSxMREHnroIU466SSGDRvGUUcdxbBhw3j00UepV6+e1/FqreZJjRjT5zYytixic2Em+9RtT6OEel7HklquQ71/sjHvJ0Iu7+91PkukReqJBHwa4VdEgPDk6Y7/NT/mADOAc8t7ALXsiYhUsj59+jB9+nRuvvlmXnnlFdLT0xk/frzXsWo1n/noWq8jBzXuqUKvmmUV/M7iTY+zeNPjZBX87nWcqJGW2J0eTZ8iOdAeMPyWQtu657J3w5u9jiYS3WpRy55zzuec80e++pxzqc65gyoyz56KPRGRKpCQkMB9993HTz/9RIMGDTj22GM599xz2bRpk9fRRKrNks1PM2PVEJZu+Q9LtzzLjFVD+HPTU17HihoNkw7kwNafcFi7WRza9mc6NrgKM7/XsUQkhqjYExGpQr169WLatGncdtttvPHGG6SnpzNu3DivY4lUuZzCRSzd8p9IN8UQECTk8li29VlyChd5HS+q+CxOc+uJlIcDnFX+EkXMbJmZLd3ZUt7j6Zo9EZEqlpCQwN13380JJ5zAsGHDOP744znzzDMZOXIkDRs29DqeSJVYn/M1zgVLrXcuyPqcr2mT1sGDVCJS07ko7nZZSc6qzIOp2BMRqSY9e/Zk6tSpPPDAA9x777189dVXjBo1ihNOOMHraCKVzvBTdgciX2SbiIiU5JybUJnHUzdOEZFqFB8fzx133MG0adNo3rw5J554Iqeffjrr16/3OppIpWqcMrjMrolmRuOUwR4kEpGYUIsGaAEwsx5mdrmZ3WVmd/+1lPfxKvZERDzQvXt3pk6dyj333MN7771H586deffdd72O5a158+Cii6BBA4iPh65d4cknITfX62SyCxIDLdmj/q34LAGfJeKzRIwE9qh/K4mBll7HExGJemZ2ETAJGAj8C+gKXAt0LO8xVOyJiHgkLi6OW2+9lV9++YU2bdowZMgQTjnlFNauXet1tOr3xRcwYACFrZoyd8Kj/LDwP6wacSXus09h0CDIyvI6oeyCFnVPpU/Lr9ij/k3sUf8m9m/1FS3qnup1LBGpyWJ8gJYSbgCOdM6dAORGvp4MFJb3ACr2REQ81rVrV6ZMmcL999/PRx99RHp6OmPHjsXVgqvQAdi6Fc44g/VvPs7Tp2TwReBDJme+w1ttx/PWk+mEOnaAmzX3WE2VEGhKi7qn06Lu6SQEmnodR0SkJmninJsYuR0yM59z7lPg/8p7ABV7IiJRIBAIcNNNNzF9+nTat2/Paaedxsknn8yaNWu8jlb1Xn0VN3Ag77T5jIJQLkUuH4BCl8eq/D+Ye/0h8NprkJnpbU4REfGcucpfothyM2sXuT0fON7MDgIKynsAFXsiIlEkPT2dyZMn89BDDzF+/Hg6d+7Mm2++GdutfD/8QNaRB5AXLN1Vs8jlMz15Buy5J8ya5UE4ERGJGlUxOEt0/3v9N7BP5PbdwGvAN8Bd5T2Aij0RkSgTCAS44YYbmDFjBp06deKMM87gxBNPZPXq1V5Hqxpm4MBt5z+uD194YiVNOi0iIrWIc+6lSLdNIl/rA/Wdc6PKewwVeyIiUWqfffZh0qRJjBgxgk8//ZTOnTvz2muvxV4r34ABpP73e1IC9UptClgC+2b1gAULoEeP6k4mIiJRpQoGZ4niAVrM7HEz2++v+865AudchUYsU7EnUkJ+0TLWZ7/P5txvCblyD3YkUiX8fj/XXXcdM2fOZO+99+bss8/m+OOPZ+XKlV5HqzxnnolNmsQpfwwkwZdCnCXiw0+cJdImsQvp930GQ4dCSgq5hYtYuOF2MlafxbLNT1AY3Oh1ehERkapiwEdm9kdknr29KnqAQBWEEqmRnHMs3XQ367LewMwPGD5LYu8mb5AUv6fX8aSW23vvvZk4cSIjR47klltuIT09nccff5xzzjmnzImra5TUVHjnHeoPGcJlw85h4cnpZKY52s4toOGTYzGfD156mS15P/Lr2gsIuQIgyNb8X1iV+Srdm48jIdDc62chIiLVIcY6t+yIc+5KM7saOAw4HZhiZouA151zj5bnGGrZE4nYnPsF67PH4sgn5HIIuWyKQuuZv+682Os2JzWS3+/nmmuuYfbs2XTp0oWhQ4dy7LHHsmLFCq+j7b4BA+DHH/EXBNnzpDvotf+1NHpoDHbWWfDpp7jERBas/xchlwsEAXDkUxTazNLNj3mbXUREqk/tGqAF51zIOfelc+48oAuwARhR3ser2BOJWJv1GiGXU2p9UWgjuYXzPEhUPiGXj3Mhr2NINerUqRMTJkxg5MiRfPvtt6Snp/Piiy/W/A8l9tgDHnsMli6FTZvgp5/g/PMhPp7C0HoKgmVNNh9kc+531Z1URESkWphZipmdZWbjCU+/UAScW97Hq9gTiQiGsrezxUfQ5VVrlvLIyv2WP1b147flHfl9xd6s2Xw/zhV5HUuqic/n44orrmD27Nl0796d888/n6OOOoply5Z5Ha1K+C2J7X386velVm+YSuScY0thDvlBXR8sIlIutahlz8zeAdYAFwH/Bdo65452zr1W3mOo2BOJaJh8HGZJpdYbkBLftfoD7UBO/jSWbbiQwqIlQIiQy2Zj1ous3nS719GkmnXs2JFvv/2Wp556ih9++IH09HSef/75mt/KV4Lfl0q9pAEYcdus91kSzeuU+wPOqPLzhgWc/MO/+b/v7uPwb+7kjtlvkVOU73UsERGJHj8DnZ1zBzvnRjnn1lf0ACr2RCIa1zmN5Lg98VlyZE0cPkukfcNH8Fm8p9lKWrf1cZzL3Wadc7lszn6LYCjTo1TiFZ/Px6WXXsrs2bPp3bs3F110EYMHD2bJkiVeR6tUnRqOICW+Cz5Lwm91MOJplHwczeqc7XW0CluYuZrrZ7zMytxNFLoghS7Id2vmcvOscn9YKyJS+zhq1dQLzrl/O+eW7s4xoqbYM7Mjzex3M1tgZjeWsX2oma0zs5mR5QIvckrs8lkiezd9l3YNHqJh8ok0q3M+6c0+pX7yYK+jlVJQuKDM9WYBioIxOvG27FSHDh346quvGDVqFD/++CNdunThP//5T8y08gX8aXRr/h5dm71Pp0aPsm/Lb+nY6AHMouZfWbm9sWQihaFtu10XuCJmbFrMyhxNJyEisj3mKn+JZVHxH9LC49w/DRwFdAZON7POZew61jnXI7K8UK0hpUoVBDeQV7jM8zelPoujYcr/0aHRo7SufyOJce09zbM9iXHphDuYbssRJM7fsvoDSdTw+XwMHz6cOXPm0LdvX/75z38yaNAgFi9e7HW0SpMSvxcNkg+r0dMtLMleR6iMC0XifQFW5W3yIJGIiMSiqCj2gD7AAufcIudcAfAWcLzHmaQaFBStZdaq05m67CB+WXkUU5cfxKbcyV7HinqN067BLHGbdWZJNEy9GJ8veTuPktqkXbt2fPHFFzz33HP8/PPPdO3alaeffppQSCO3RoPu9doSZ/5S6wtCRbRPafq/FXPnwoMPwl13wfvvQ6EGchGRWq4WDdBSGXar2DOzcyopR0ug+BByyyPrSjrJzGab2btm1noHuS4ys2lmNm3dunWVFFEqm3OO2WvOZmv+dBwFhFweBcHVzFt7MbmFsXWtUWVLjE+nbeO3SYrfDyORgL8FTdNupXHa9V5HkyhiZlx44YXMnTuXAw88kMsuu4yBAweycOFCr6PVeqe27U+CPw5fsRb6RF8cx7bsTYOEVNi4EY45Bo44gtCqVQSLCmHkSGjXDr74wrvgIiJSrcysoZmdbWY3RO63MLNW5X18uYo9M+tcxpIOXLyLuXfFx0A751w34Evg5e3t6Jx7zjnX2znXu3HjxtUWUComM38G+UWr+GuC5L84V8SqzDe8CVWDJCfsS/umH7JP64Xs2eJnGtQZiln0XmQs3mnTpg2fffYZo0ePZsaMGXTr1o0nnnhCrXweapKYxpi+lzOgSRfqBJJokdSAf+55JNfufRwUFcExx1DUoT0PjH+cg49J48ADHWfffzJ/Pvs4nHVWeA5CERGJaWY2APgdOBO4LbK6EzCqvMcIlHO/KcC7lL5IqG15T7QTK4DiLXWtIuv+5pzbUOzuC8C/K+nc4pH84GqszOvOCskr3K2Bh0SkBDPjvPPO44gjjuCiiy7iyiuv5N133+XFF1+kY8eOXserlVolN+T+HmeW3vDxRwBcfXZPZqybS0FkIJffM1dxbsIGPrzzFurffTeMH1+dcUVEpPo9DpzqnPvazP66oPsnwpfAlUt5u3H+ClzvnBtWfAFmVSju9v0MdDKz9mYWD5wGjCu+g5kVvxL/uEgmqcHqxHclROlJwH2WRFrSAR4kEol9rVq1Yvz48YwZM4bZs2fTrVs3Hn/8cYLB4M4fLNXj1VdZP+xMZm5e8neh95fCUBGvHNAKJk2C9RWebklEpMarZaNxtnPOfR25/VfSAsrfYLfjYs/M/jrQ4cDmktudc8eU90Q74pwrAi4DPidcxL3tnMsws7vN7LjIbleYWYaZzQKuAIZWxrnFO4lxrWmSfCy+YhOZG3HE+erTNPVED5OJxDYzY+jQoWRkZDBw4ECuvvpqDj74YH7//fdyPT7kisgsWExe0Yad7ywVt24dq5qmEecr/b+8yIX4vXATNGmiYk9EaqdaNM8eMM/MSs4BNgiYU94D7Kwq/NTMTnDOba1wtApyzn0CfFJi3e3Fbt8E3FTVOaR6dWr0AHUye7Ay8xWCoRwapRxB67R/EvCleh1NJOa1bNmSjz/+mNdee40rrriCHj16cO+993LVVVfh95ceKRJgeeaXzFh/HyFXgHNBGib1pE/TB0nw16ve8LGsZUtaL11PwV6lez7E+fz08DeANWugadMyHiwiIjHkWuC/ZjYeSDKzZ4H/owKzFuysG+dMYJKZtfhrhZkdbGYTdyGsSClmPprXPZ1eLT+lT+sJdGhwC3H+Bl7HEqk1zIyzzz6befPmccQRR3DdddfRv39/fvvtt1L7bszL4Jd1t1MY2kLQ5RKigPW5v/Djqis9SB7Dhg2j3gsvcUiDPUko1rpnGAm+OM74Zj4ccQTUr+9hSBERD1TFtAtR3I3TOTcF6AZkAC8Ci4E+zrmfy3uMHRZ7zrnrCY/2MsnMTjOzL4G3gQ93NbSIiESf5s2b8+GHH/L6668zf/58evTowYgRI7a5lm/B5lcJuvxtHucoYkvB72QWaLqUSnP44dCiBXc/Mp7zGvWifnwKCb44+jXqxNgVzUkd8SjccYfXKUVEpIqZWQKwzjn3b+fcpc65B4E1kfXlUp4BWn4EtgKvE54Lr71z7pFdSiwiIlHLzDjjjDPIyMjgqKOO4oYbbqBfv37MmzcPgOyilZT1EagRR15Qc5pWGp8P3n8fX3Iyww4byufPzWHie6t57MwHaPzIk/DJJ9Cli9cpRUS8UYta9ghPN9erxLpehMc5KZedDdDyAfAd8B5wIjAYGFihiCJSI2zO+Zg/Vh/Jryt7s3TD5RQUqaWmtmrWrBnvv/8+b775JgsXLqRnz548+OCDNIjrjY/4UvuHKCAtfk8PksawpCQYPRp+/RWOPBJ69oQxY2DWLOjd2+t0IiKeqWWjcXYlPNVCcVOB7uU9wM4GaJkPnO+c2whgZouAcWbWzjn3dEWSikj0Wrv1KdZuHYlzuQBsyfmIzNyv6NTsS+IDraCgAN5+G158EZYtg4YN4cwz4dxzoW5dj9PXDM45gsEVmCXh9zf0Os5OmRmnnXYaAwcO5JJLLuGmm27i3fd6MOzeBFp0DOAi06b4LYlOaWcR79fPQZVo1gyGDvU6hYiIeGML0BRYXWxdUyC7vAfY2TV7//qr0IvcnwP0By6sWE4RiVahUM42hV5kLSGXy7qtT8HWrTBwIDz/PEvPPItPH36UXy+7HDdhAvTqBUvUArgz+fmTWLNmP9auOZg1q3uxft0QgsG1XscqlyZNmvDuu+/y9ttvs3TJCq7+v+l8PboBCa4F9RO60KvJnezT4J9exxQRkdoiyrpxmlkDM/vSzP6IfC1z9Cwza2NmX5jZr2Y2z8zalePw7wFvmFkXM0s2s67AK4THUCmX8k6q/jfn3ArgoIo+TkSiU37RQoyyhtkvIjt/ClxyCcG99mLoxZdx7OZs/rXgT05fu4mjBv8f2cOGwckng4vuPhBeKipawsYN5xAKrgTygAIKCn5iw/pTcTXodRsyZAgZGRmceOKJPP3AF9x2yioabryeVqlHYBbVcxSJiIhUpRuBr51znYCvI/fL8gowwjm3D9AHKM+nvrcQnoN8KpAJTAF+B24ub7gKF3sAzrnMXXmciESfgL8pzhWWuS1xfUMYP55RJ53KtJWryS0sIrewiOyCQpZs2szVHfeBzEyYNKmaU9cc2Vkv4VzJ+dKKCAaXUVg4w5NMu6px48a89dZbvPfee6xYsYLevXtz1113UVBQ4HU0ERGpLaKsZY/wnHcvR26/DPyj5A5m1hkIOOe+BHDOZTnncnZ2YOdcnnPuUiAFaAakOucuc87llTfcLhV7IhI74vxNSE08BGPbUXzNkmgyvTsMGsTrCxeTX7RtwVIUCjHxz6UUnXgSfF7uQaFqnaLgYqCsYtpHMLiyuuNUihNPPJF58+YxZMgQ7rzzTvr06cPMmTO9jiUiIjGuKgZniQzQ0sjMphVbLqpArKbOuVWR26sJX1NX0p7AZjN738xmmNkIMyurW1Xp52yWBuxHeLCWQ81soJmVe8BMFXsiQpuGT1I36QiM+PAAIr76tKw/gkRrBwkJFBaba604BwQTEqCoZMuV/CUh/kAgqdR65wqJiyv3YFpRp2HDhrz++ut8+OGHrFmzhv3224877rhDrXwiIlITrXfO9S62PFd8o5l9ZWZzy1iOL76fC1+fUVZbYYDwZXDXES7cOgBDdxbKzIYCK4GPgdHFlhfK+8RU7IkIPl8ybRqNYp+WM9mz2Tfs02Im9VP+ER7i/ZtvOLx9WwK+/12XFfAVcfSe03ns6DcJfTqSzK4FOFd2QVjbJaechs9XH4j730pLIinpeAKB1p7l2hWhUA7rtj7DH6uPZtHaU9iSM57jjjuOjIwMTj/9dO6++2569+7NL7/84nVUERGJVc4qf9nZKZ0b5JzrUsbyEeFJzpsDRL6WdS3ecmCmc26RC1/b8SGwbzme7X3Ayc65ps659sWWDuV9uVTsicjf/L66xAda83fPgs6dYa+9uOXXuTRMTiEpLoDhuOuw9zi750T2nrEA/9ItLOk3jqUbNCJjWXy+OjRu8jnJKWfj87cgEOhE3bq3U6/+o15Hq5CQy2PB2v9jzZZHySucTXb+ZJZtvJpVm++hQYMGvPLKK3z88cds2LCB/fffn1tuuYX8/HyvY9dKzgXJK1xEYXCN11FERGqDccC5kdvnAh+Vsc/PQD0zaxy5PxCYV45jB4Avdiecij0R2bHRo0l9+im+XZDBPXt34tJ+IfbxraHlc5tofdUmlj1VH+fPJTPvW3IL5nidNir5/Q2pV+9emjWbRpOmE0hNPRezmvXnd3P2RxQULcPxv2vCncthY9bLFBaFrz089thjmTt3LmeffTb3338/vXr14ueff/Yqcq20Jfdr5qzozW+rj2buigP5fc1JFNaQaT5ERMol+gZoeRA43Mz+AAZF7mNmvc3sBQAX7v50HfC1mc0BDHi+HMd+CLjVduNNQ816tyEi1a9DB/jpJ+LMOP7sM7j82FtJP3AJiQuKWPR2I3L2Cw/s4lyQ7PyfPA4rVSUz7xvKGjjMLI7sgml/369fvz5jxozhk08+YfPmzfTt25ebbrqJvLxyDxwmuyi3cD6L1l9CUWgDIZeDo4Ds/OksWHtWjZrmQ0SkJnHObXDOHeac6xTp7rkxsn6ac+6CYvt96Zzr5pzr6pwb6pwrz0XuVwO3AplmtrT4Ut58gQo/IxGpfVq0gMceg4cfZuPKp1hdOBIXt+3fKJ/FEfA18iigVLU4fzPAD5S+NjPga1hq3VFHHUVGRgbXXnstDz74IB999BFjxoxh//33r/qwtdS6zJco/d4hSH7RUnIL55Ac382TXCIilclq12dXZ+3uAdSyJyLl5/dTr8WZWHzpz4mMAHWTBnsQSqpDg9SzMIsvsdbw++qSknBAmY9JS0vjhRde4LPPPiMzM5N+/fpxww03kJubW/WBa6H8omWUVYyDj4Ki1dUdR0SkakRfN84q45ybsL2lvMdQsSciFRLwN6Jdo1cI+BrjsxTMkonzt6J9k7fx+UpPMSCxITGuE60bjMRndfFZKmZJJAT2oH3jsTu9/nDw4MFkZGRwwQUXMGLECHr27MmPP/5YTclrj7qJB2GWWGq9cwVq1RMRqYHMLMHM7jOzRWa2JbLuCDO7rLzHULEnIhWWktiXvVv8QocmH9Cx6cfs1fxHkuLTvY4lVSwt+Wj2aTmT9o3fomPTT+jU7FsS4tqX67F169bl2Wef5YsvviA3N5cDDzyQa6+9lpyc0tcByq5plHoaAV99rNg0Hz5LolHqmcQHmnmYTESkklTdpOrR6jGgC3Am/2uDzADKPQS6ij0R2SVmPpLiO5MYtxdmO5+jRmKDz+JJTuhBYlynXfq+H3744cydO5eLL76YRx99lB49ejBp0qQqSFr7+H112afZpzSuM5T4QFuS4rrQuv59tKp/p9fRRERk15wAnOGc+xEIATjnVgAty3sAFXsiIlKt6tSpw6hRo/j6668pLCzkoIMO4uqrr1YrXyUI+BvQqv5tdGkxkX2af0LD1JP1YYyIxJZadM0eUECJATUjc/VtKO8BVOyJiIgnBg4cyJw5c7jkkkt4/PHH6datG99//73XsUREJJrVrmLvHeBlM2sPYGbNgaeAt8p7ABV7IiLimdTUVJ566im+/fZbnHMMGDCAK664guzsbK+jiYiIeO1mYDEwB6gH/AGsBO4q7wFU7ImIiOcOOeQQZs+ezRVXXMGTTz5J165d+fbbb72OJSIiUaY2DdDinCtwzl3tnEsFmgJ1IvfLMyE7oGJPRESiREpKCiNHjuT777/H7/czcOBALr30UrKysryOJiIiUu3MrMNfC1AHaF/sfrmo2BMRkahy0EEHMWvWLK6++mpGjRpF165d+frrr72OJSIiUt0WEO66uaDY8kdkKRcVeyIiEnWSk5N59NFHmThxIvHx8QwaNIjhw4ezdetWr6OJiIiXatEALc45n3POH/nqA1oAzwFnl/cYKvZERCRqHXjggcycOZPrrruO559/ni5duvDFF194HUtERKTaOedWA1cBD5T3MSr2RGq5olAmK7Y8zdxVx/HbmnPYlPON15FEtpGUlMSIESOYNGkSKSkpDB48mAsvvJAtW7Z4HU1ERKpTFQzOEs0DtGzHXkByeXdWsSdSiwVDOWSsOp4VW54ku2AOW/ImsmD9ZSzfPHKHj8srXExW/mxC5R8MqsZzrpCNW59l0aqDWLRyf9Ztvp9gKNPrWLVK3759mTFjBv/617948cUX6dKlC59++qnXsURERKqEmU00s++LLdOAn4BHy3sMFXsitdi6rLcpCK7Gufy/14VcLiu3jKIwuLHU/vlFK5iz8mjmrDqaX9ecyfRlvVif9VF1RvbMivUXsH7rvyksWkhhcBmbMp9j6ZpjqcDox1IJEhMTefDBB/nxxx+pW7cuRx99NOeddx6bN2/2OpqIiFSHWnTNHvACMLrY8iDQzTmnbpwisnObc78h5HJLrfdZHFn5M7dZ55zjtzXnkFM4n5DLI+SyCLosFm+8keyCedWU2Bt5BXPIyf8BV+y1chRQGFxJZs54D5PVXn369GH69OncfPPNvPLKK6SnpzN+vL4XIiISO5xzL5dY3nXOlXskToBAVYUTkegX529K+DOf0DbrHSHi/A22WZddMJuC4GoguM36kCtg9daX2KPRv6s2rIfyCmaW+cmfc9nk5E+hbsoJ1Z5JICEhgfvuu48TTzyRoUOHcuyxx3LOOefw+OOPU79+fa/jiYhIVYjulrjdZmZ3l2c/59zt5dlPLXsitVizOufis/gSa33E+5uSEt99m7WFwfVYmX8yQpEiMHYF/M0w85dabyQQF2jjQSIprlevXkybNo1bb72V119/nfT0dMaNG+d1LBERqWRGrRigpXU5llblPZiKPZFaLCWhC+0a3I/PUvBbKj5LIimuE3s3fQUz22bf1IQehFxhqWP4SKRe0qHlOp9zjqz8mWzK+YKC4NpKeQ7VISXxUHy+VEr9ybQAaSmneJJJtpWQkMA999zD1KlTady4MccffzxnnXUWGzZs8DqaiIhIRfzinBvmnBsG3PfX7RLLeeU9mIo9kVquceoJ9Gr9C3s1fYUuzcfRrcVnJARKf2AU529I87oX4rOkv9eFW7aa0SR15wVPQdFq5q4axO9rz2DRhmuZvaI/Szfdg3PR95FaSWYBWjf5kIS4bhjxmCUS529L68ZjCfgbex1Pitl33335+eefueOOOxg7dizp6el8+OGHXscSEZHKEvsDtNxX7Pb03T2YrtkTqQbOBVmZ+TYrM18n5HJpnHw0bepdRMBXx+toAPgsgToJPXe6X+v615KS0JU1W1+iKLSF+smDaVZ3KH5fyk4fu2D9xeQV/Unxa/7WZb1BSnx3GqYctxvpq0d8oA3tmn1CUXAtzhUQ8Lcs1fop0SE+Pp4777yTf/zjHwwbNowTTjiB008/nSeeeIJGjRp5HU9ERGRHFpnZI0AGEGdmZbbiOedeLM/BVOyJVIPf1t/A+pyv/h75cvnWMazP+ZxeLcbh9yV6nK5iGiQfQYPkIyr0mPyiFeQU/kbpwV1yWZM5pkYUe38J+Jt4HUHKqUePHkydOpUHHniAe++9l6+//ppnnnmGk046yetoIiKyK6LzGrvKdipwA3A6EAecXcY+DihXsadunCJVLKdwEetzvthmigNHAfnBNazLrh1DxQdDWdh2PlsKhrZWcxqpTeLi4rj99tuZNm0arVq14uSTT+bUU09l3bp1XkcTEZFdEePdOJ1z851zFzjnDgcmOOcOLWMZWN7jqdiTqFMY3My6nG/ZnDcD50I7f0CU25o/Cyg9kmPI5bIpb0r1B/JAUtwemMWVWm/EUz/5SA8SSW3TrVs3pkyZwn333ccHH3xA586defvtt72OJSIisl3OucP+um1mvuJLeY+hYk+iyp+bX+D7ZYcwZ+0NTF99AT8sP5zswj+9jrVbEvxNMUpf22XEk1jGQCixyCxA+wYj8Fkif/3ZMRKJ8zehWd2LvA0ntUZcXBw333wzM2bMoF27dpx66qmcfPLJrFmzxutoIiJSXjHeslecme1rZj+aWTZQGFmKIl/LRcWeRI2NuVNYuPkZQi6foMsi6HLIK1rFjNUX1YgRG7enXuL+BPz1KPnrZuaneZ3aM2x//eTD6dx0HI1TzyAt8RBa1buBLs0/I+BL8zpalQuFstmY+SorNlzBui1PUBRUF0Ivpaen8+OPP/Lggw/y8ccfk56ezptvvlmj/86IiEhMehn4FugNdIgs7SNfy0XFnkSNZVtf3+a6tjBHQXADmQXzPMlUGcz89Gj2OnXi0/FZAj5LIsHfjK5Nnycx0NzreNUqKX5P2jW4lz2bvESzuufh96V6HanKFQXXsWD1ANZsuYstOe+xfuvjLFjVn9yCuV5Hq9UCgQD/+te/mDFjBh07duSMM87gxBNPZPXq1V5HExGRHagFk6oX1xa4xTn3q3NuSfGlvAdQsSdRo3C7A3X4KAplVmuWypYYaMG+Ld6jT8uv6N1iHPu3mkC9xD5ex5JqsGbzAxQF1+EiH2Q48gm5LFZuvNrjZALQuXNnJk2axIgRI/j000/p3Lkzr732mlr5RESiVS3qxgl8AFRsCPQSVOxJ1GiSPChyTde2HEXUTejqQaLKlxBoSlJc2yqbn60olMniTSP5ecVR/LLyJFZnva83rR7LyvuCcPf6beUXzicY2lL9gaQUv9/Pddddx6xZs9h77705++yzOf7441m5cqXX0UREpHZLBD4wsy/M7JXiS3kPoGJPokbLOieTHGiDz5IASJuRR/oNaznoxK0EDjkKHnkENm70OGX0CobymL7yZJZteZ6cwoVkFczhjw138ceG272OVqsZ8dvdYpQeoVS8s9deezFx4kQeffRRvvzyS9LT03n55Zf1gUkNF3L5bMr+gOUbb2Xd1tEUBTd5HUlEdlVVtOpF95/4ecBDwCRgYYmlXDSpukQNvy+JPi3GsjLzQ+JvuI/6n2wkZ9g5zOvVgzr+IO1nfI/v4Yfh44+hd2+v40adNVnjyA+uxlHw97qQy2VN9oe0TruIpLjWHqarveqlnsmGrc/gyCu2NkBq4kH4fMme5ZKy+f1+rr76ao499ljOO+88hg4dyttvv81zzz1Hy5YtvY4nFVQU2swfq4+jKLiWkMvGLJHVWx6hY9P3SIrfx+t4IiI75Jy7a3ePoWJPoorfl0jrt7bAtHjGnj2Sl0d8QVz8BByOlLopPHnrvTQ67jj4/XeoU8fruDu1Nvszlm4ZQ2FoIw2SDqJd2nASAk2q5Fyb8n4oY4AbMAJk5s9SseeRRnUvI7dgOjn5PxFuzTMC/ha0aPCY19FkBzp16sSECRN46qmnuPHGG+ncuTOPPfYYw4YNq7Ju2FL51mx+jMKi5bjIKOXO5eHIY+mGK9mr+RcepxORXRHlA6rsNjM72Dn3feT2didPd859U57jqdiT6BIKwSOP8Nslt/DabV9SmF9IYX74n3ReVh5XPzqdV/r1w157Df75T4/D7tjiTU+zZOvzfxdgKzPHsjb7M/Zv+THx/oaVfr7EQEvCv9Klrw+L9zeu9PNJ+fgsgbaNXyevIIO8wrnE+duQnNBXBUMN4PP5uOKKKzj66KM5//zzOf/883n77bd5/vnnad266j88CYVy2ZL7OYXBNaQk9CY5fl/93FTQ5pz//l3oFZdfuICi4CYC/voepBIR2aFngC6R26O3s4+jnNMv6Jo9iS4LF0J+Pm9+t5q87PxtNjkHW9ZtZWWfgfDf/3oUsHyKQpks2frsNi1tjiKKQpks2/JylZyzRZ3T8VnJz298xPnrk5a4X5WcU8ovMT6deimnkpJ4gN6w1zAdO3bk22+/5cknn2TixImkp6fzwgsvVOm1fHmF85m3cn+Wb7yRVZsfYtHaM1i87hycK/c8ugJYqb+JxbfpLZBIjRTj1+w557oUu91+O4vm2ZMaKj8fUlLI2pxT5mbzGbn4oaCgzO3RIqvg9zIH5nAUsDFvcpWcMymuDelNnibO1wCfJeOzBFLj96F7s1f1pkZkN/l8Pi677DLmzJlD7969ufDCCxk8eDBLly6tkvP9ue5igqHNhFw2UEjI5ZCV/xPrM8s9AJsADVJOxSg5yrOf5IR98fvSPMkkIrunls2zt9v0DlCiS4cOsGYNRxzekYTk0sVSKBii3ar50KNH9WergHh/4zK7DoGRFKi6QR4aJB3EAa0nsW/zd9mv5Wf0avFBpHuniFSGDh068NVXXzFq1Ch+/PFH0tPTefbZZyu1lS+/aCkFweWU/LjZuVw2Zr9ZaeepDZqkXUJyQk98loyRgM9SiPM3pU3DJ7yOJiJSLVTsSXRJToYzz2TQogm03rMFiSkJAPj8PhKS4rnuzv8j8NorcPHFHgfdseS4ttSJTy81tL7PEmiddl6VntvMT0p8RxV5IlXE5/MxfPhw5syZw/7778/w4cM5/PDD+fPPPyvnBC60/U0uWDnnqCV8lsgeTcbSocmbtKh/K20bPcU+LSYRH2jhdTQR2VUx3o2zsqnYk+hz9934p/3MU13Xcf0tR9Lv+P04augAnr/7IAY8fRPcfDN07Oh1yp3q1uQZ6iXuhxGP35IJ+Oqyd8P7SEvo7nU0EakE7dq148svv+TZZ59l6tSpdOnShVGjRhEKbb9YK4/4QFvifKUHVTISqZ9y0m4duzYyM1IS9qVRnaHUTRq0w+v4RERijcX6ZLG9e/d206ZN8zqGVNSWLXD//TBmDMTHQ1YWdOkC118Pxx/vdboKKQiupzC4haS4tmUMoCIisWDp0qVceOGFfPHFFxxyyCGMHj2aDh3Kff18KTn5M1m49nQcQZzLxWcpJMZ1Yo8mb+PzJVVichGpzczsF+dcjZm8OKlpa9fxzGsq/bhzH7umRr0OFaFiT6JbQQGsWQNJSdCokddpRES2yznHiy++yDXXXENRUREPPfQQl1xyCT7frnWiKQpuYnPORxQWrSIlsQ91Eg/BzF/JqUWkNqtpxV5yFRV7c2K42IuabpxmdqSZ/W5mC8zsxjK2J5jZ2Mj2n8ysnQcxpbrFx0Pr1ir0RCTqmRnnn38+c+fO5eCDD+byyy/n0EMPZcGCBbt0vIC/Po3qDKV5/Zuom3SYCj0REamwqCj2LPwf7GngKKAzcLqZdS6x2/nAJudcR+Ax4KHqTSlVIbdwBRtyJpFbuMLrKCIilaJ169Z88sknjBkzhlmzZtGtWzdGjhy529fyiYgIGqClgqKi2AP6AAucc4uccwXAW0DJC7OOB/6ajfpd4DDTzMQ1VsgVMGvNlUxecQyz1l4V/rrmCkIuuufPExEpDzNj6NChZGRkMHDgQK666ioOPvhg5s+f73U0ERGpRaKl2GsJLCt2f3lkXZn7OOeKgC1Aw7IOZmYXmdk0M5u2bt26Kogru2vBxsdZnzuBkMsn6LIIuXzW53zPHxsf9zpazAqG8li+5SWmrxrCrNVDWZ/9ZaXODfYX50JVclyRmqhly5Z8/PHHvPLKK2RkZNC9e3ceeeQRgkFNoSAisis0qXrFREuxV6mcc88553o753o3blx6+Grx3vLMtwm5/G3WhchnRebbHiWKbSFXwMzVp7F486Nk5s9ic95kfl1/HYs2PVhp58gpXMys1efw/ZLOTFzSld/W/YuiUGalHV+qXzC0laLgeq9j1Hhmxtlnn828efM44ogjuO666+jfvz+//fab19FERGoedeOskGgp9lYArYvdbxVZV+Y+Fp4kJw3YUC3ppNIFXW6F1svuWZf9KTmFfxJyeX+vC7lcVmS+QV7RKnILl7Jsy4ss3zKGvMLlFT5+YXAzM1adwua8n4AQjgLWZo9n1upz1cpXAxUG17Jo7en8uqI7v63sw/xVh5CTP9PrWDVe8+bN+fDDD3n99deZP38+PXr0YMSIEWrlExGRKhMtxd7PQCcza29m8cBpwLgS+4wDzo3cPhn4xuldZI1VL6FHhdbL7tmQ8x0hl1NqveFn0caHmbbyGBZveoRFmx7h55VHsWLr6xU6/uqs9yIttf/7lXQUkFO4iMz8WbsbX6qRcyEWrR1Cdv6POApxFJBftIDF606lMLja63g1nplxxhlnkJGRwdFHH80NN9xAv379mDdvntfRRERqBrXsVUhUFHuRa/AuAz4HfgXeds5lmNndZnZcZLfRQEMzWwBcA5SankFqjr0b3obfUjDCk4wbAfyWzN4Nb/U4WdULhnJZm/0ZKzPfIbdw2c4fUAkSAk2AMiZ0d471OZ8Rcvl/v7EPuXwWbXqQvKKV5T5+VsGv27QaFpdTuGgXU4sXsvN/oii4GijaZr1zhWzMetObUDGoWbNmvPfee7z11lssXLiQnj178sADD1BUVLTzB4uIiJRTVBR7AM65T5xzezrn9nDO3RdZd7tzblzkdp5zbohzrqNzro9zTu8ga7A6CXtzQMuPaFX3dOol9KJV3dM5oOU46iTs43W0KrUlfxY/LOvPr+tvZv7G+/hp5TEs2PjvKu/q2Dz1FHxWstgzzHyU9ZGWc7A+58tyH79OfDo+SyxjiyM5vmOFsoq3CoNld+MNt/AtrOY0sc3MOPXUU5k3bx7HHXccN998MwcccABz5871OpqISHSqgsFZNECLSBVJimvJ3g1vZr8Wr7F3w5tJiis5AGtsCbkiZq+5mKDLIuiyCblcQi6f5ZlvsClvcpWeOzl+D/ZuNAK/peK3VHyWRGKgNc1Sh2yn94ILV3zl1Cz1JPyWRPE/KUY8qfH7UCe+6+7Gl2qUFN8NR+lryMySSYnf34NEsa9Jkya88847vP322yxZsoR9992Xe++9l8LCQq+jiYhIDadiT6SabMn7pcx5BEMul5XVMApp45TB9Gszha5NR9Oz+Vj6tPySFnVPK6PFL9zi0Ch5ULmPXeSy6djgDuonHogRj99SaF5nCN2ajkbTYdYsiXF7kZpwMLZNS20cAV896qWc6Fmu2mDIkCFkZGRw4oknctttt7H//vsze/Zsr2OJiEQXXbNXISr2RKpJeACTsguf6hqF1GfxpCX2JDV+b8yM5LgOtE27FJ8lYAQw4vBZAu3rX0diXKudHi8YymXumuH8vOII5m+4jS15U2lR93QObDOdTg3v4P/bu+/4qKr8/+Ovz0wmnRKSEAhFxJ6EIiAirIgFReyKZa0suui6rqKyu7o2RLEhrq7ugxWXL3ZRUVR+6lqwYEGERUoCFlSkI50U0mbO749EFyWBDJnJTSbv5+NxH8zcuXPvO3NnJnxyzj3H70tpgJ9KIm2fjEdp23IUAX8n4nwZtEk5j/2z3tT5bACZmZlMnTqVl156idWrV9O7d29uv/12yst3/UORiEhz1Ni6cZpZGzN7x8y+qf43rZbt7jOzAjNbamb/sAb6a7iKPZEG0jqxT43d43yWRFbKqTU8o2F0bn05vbNfo0vaKLqkjaJP9ut0bHnJnp8IfLNpDFtKPyHkygi6QkKUsbbwBdYUhjeapzQuZgHatryKg7Nnc0iHBXRoczdx/nSvYzUrZ555JgUFBZxzzjmMGTOGvn37smDBAq9jiYjIrm4AZjrnDgBmUsMgkmbWHxgAdAfygMOAoxoinIo9kQbi9yVzSPpd+Czx51FIfZZM64TetE0Z0uB5dh4UJjmwL51bjaRzq9+TFOhcp+eHXNVcelUtljuv38Gq7VMimlWkOcrIyOCZZ57hlVdeYf369Rx22GHcdtttauUTkeat8XXjPA14ovr2E8DptaROBOKBBCAArK/3keughrHYRSRaslKH0iIhl7VFL1MZ2kZ60tGkJx1ZPSrmXioqgnfegW3bYP/9YcAA2E3PgHVFM/h2ywTKgmtJ8Gexb+tryG5xVtiHDYZKqO0bsjK0Lez9iUjNTjvtNI488khGjRrF2LFjmT59Oo8//ji9evXyOpqISKzIMLN5O92f5JybVMfnZjnn1lbfXgdk/XoD59xsM3sfWEvVNT2POOeW1itxHallT6SBJQf2Yb+0azkofQwZyUftfaEXCsHtt0PnzvCvf8F778Hll0NOTtXtGqwrep0vN91MWbDqO6ksuJ6vN9/BmsJpYR8+zteKhLhdvs8Ao1VC37D3JyK1a9OmDU8++SQzZsxg48aN9O3bl5tvvpmysrI9P1lEJIZE6Zq9jc65Pjstvyj0zOxdM8uvYTlt5+1cVbepXf4Sbmb7A4cAHYEOwDFmdmS0XqOdqdgTaaquuw739tvMuv9pftfyFM5Yk8sNx9zA2utuhvPOg1mzdnnKd1sf2GXy85DbwXdbHwr78GbGAeljq+fXq/oqMQL4LZWubf68Vz+SiOzeySefTEFBARdddBHjxo2jd+/ezJs3b89PFBGJBdHowlmHbpzOueOcc3k1LK8C682sPUD1vz/WsIszgM+cc0XOuSLgTeCIvXoNwqRiT6QpWrYMnnmGaeffxPgnF7J65WaKi8qYP/d7Ln9mBT/edjf8edeCq6xybQ07g/LgjzgXCjtGm6TfcGj752mbchKp8bm0b3EefTrMIDmwb9j7EpG6SUtLY8qUKbz++uts3bqVfv36ceONN1JaWrrnJ4uISKS9Bvw0st0lwKs1bLMCOMrM4swsQNXgLOrGKSK1ePxxKi+4iKdeXEhZ6S8nXi4rq+Sxlamwbh3k5//iscS4mieuT/Bn7XV30tT4QzgkcwK9s6dzQPotJMZl79V+RGpSEdzIqs03s2R1X75cM4iNhU/s1R8mYtHQoUPJz8/nkksu4Z577qFXr17MmTPH61giItHV+AZouQcYbGbfAMdV38fM+pjZv6u3mQZ8CywGFgILnXMz6n3kOlCxJ9IUrVzJtg5dMN+uA7E45/jyq/VwyCGwcuUvHuva+vrqbpf/47NEura+LqpxRfZGMLSdb9adyKaiZ6kIrqWs8lvWbB3Hys2jvY7WaLRu3ZrJkyfz5ptvUlhYSP/+/fnrX/+qVj4RkQbinNvknDvWOXdAdXfPzdXr5znnLqu+HXTOXe6cO8Q5l+Oca7D/eKnYE2mK0tNpsW0jlZW7ztsH0KFjGqxYAem/nBstK3UIh6TfQ1JcZ8BHor8DB6ffSfsWp0c/s0iYNhVNpTK0Ffhf67VzO9ha/BrllStrfV5zNGTIEPLz87n00ku57777OPTQQ5k9e7bXsUREIspofJOqN3Yq9kSaogsuIP7pJxk8OIeEhF/OoJKQGOCynokQDEKfPrs8NSv1RI7o+A7HdFlK/07v0S71lIZKLRKW4tLZOLdrC5VZgJLyxR4katxatWrFpEmTePvttykpKWHAgAGMHj2aHTt2eB1NRCRyGl83zkZNxZ5IU9S7N/TsydUFL3DSSXkkJMQRF+cjI7MFt13ak/3v/EvVtAw+fcS95JwjGCrGuUqvo0RUacX3rNn6AKu23EFh6RyqRpqOvPjAvtQ8HWyIeH/7qBwzFgwePJj8/Hwuv/xyJkyYQI8ePfj444+9jiUiIh7Q/wRFmqpnn8WH44oJv+fVnuuZfpzjmcRP6XPNBXDjjVXTLzQloVDV5PD33QcPPghfful1onrZuuNjvlhzDJ+v7MlnK7vx7aZbCLmmPyfaxqIXWLruBNZtf4QfC//NtxsuYfmmUVEp+DJSL6Zq0LKdxREf15mk+J4RP14sadGiBRMnTmTmzJlUVFQwcOBArr32WkpKSryOJiJSL+ZcxJdYpmJPpIkKJQVY9++L+Wr6yWxKXYIVrsAGD4bly2HkSK/jhefzz+Hgg2H0aNz69bivvoJBg+Ckk2DTpnrvvrRyDWu2P8e6wpeoCG6t9/72pKi8gC83jKS08gccQZwr48eiaXyzsWnPP1gZ2srKLTdVd62sBBwhV8K2HW9RWLrrvI71lRDoQtfMxwn4O2AkYsSTmtCPrm2fxWzXwYlkV8cccwyLFy/myiuv5MEHH6R79+7MqmEOThERiU019Y8RkUYu5MqZt/YSisq/Jti+hBWX+fHZRnLST6F9i5ZexwvPkiVw8smsHzeeMT8msuDrNQTi/AwdewrX579FYMgQ+PhjSEjYq92v2DqJH7Y9TNVl3T6+2Xw7h2Q8QEbKcRH9MXa2etu/dmnFc5SxueQdyoMbiPdnRu3Y0VS44yOMAI5f/mwhV8Lm4ldomXRUxI+ZmtifQ7JnUxFci8+SiPOnRfwYsS41NZVHHnmEYcOGMWLECI466iiuuuoq7r77blJTU72OJyJSd83gGrtIU8ueSBO0pvBVCsu/Iuh+6pIVJORKWbppDMFQExuMYdw4Sq66mvP/W8QXX60m5BxlFZW8Pucb/tT2CEhNhZde2qtdF5Ut4YdtjxByZYRcKSFXUvU6bbyOylBhhH+Q/9lRsYyafhv5LJ6yyjVRO25NgqFC1hc+xfLNN/Fj4bMEQ8V7va9du1T+/Ajm27tivG7HNeLjslXo1dOgQYNYvHgxf/rTn3jkkUfo3r0777//vtexRETCotE4w6NiT6QJWlf8OiFXU1HnZ2vZgoaOs/dKSuC113i562GUV1T+ojwqrwiydPmPrDn7Anjiib3a/fri1wi58l3WGz42lUTvP7mp8T0B/y7rQ66cpLguUTvur5VW/MCiNQNZteUuNhQ9w8qtd7J4zSDKK9fu1f5aJh5FzUVsIukpw+qZVhpCSkoK//jHP/jwww/x+/0cc8wx/PGPf6SoqMjraCIiEgUq9kSaoDhfbV2vHH5LatAs9bJ1K6SmsnhzGeUVu84Z6PP5+CGlDaxbt1e7ryr0di1OHC6qI2R2bHVFDZPXJ9GuxQXE+VtF7bi/9sPmm6gMbSNE1R8GQq6EitAmVmwZu1f78/mS6JrxKD5LwmcpmCViJNC2xUhSE3ad5kMar4EDB7Jw4UKuvfZaJk6cSLdu3Zg5c6bXsURE9kxTL4RFxZ5IE9SxxXn4aijq4nwptEro7kGivZSWBkVF9GyTSHyghpawUIguxZshO3uvdp+ZcuIuRRcALkSb5IF7tc+6SAzsQ7d2L9I68Uh8lky8P5vOrf9Ml7S/Re2Yv+ZciO1lnwKhXz0SYuuO9/Z6vy2TBtKtw1w6pd1Bx9a3kJM9k+zW19crq3gjOTmZBx54gI8++ohAIMBxxx3HFVdcwfbt272OJiIiEaJiT6QJykj+Dfu0vBifxeO3ZPyWQsCXxqHtJmHWhD7WSUlwxhmc/s1sEuLj2HmAxfiAn9yu7Wj//FMwfPhe7b5VQh+yUk6tLowNiMNniXRtcwPx/oxI/AS1Sok/mJysJ+jXOZ8+HT8mu+XwBj43htXQlRTArH5jc/l9LUlPHUZmi4tIiOtcr32J9wYMGMDChQsZPXo0jz32GN26deOdd97xOpaISI10zV54mtD/CkVkZ/u3GcWAjm9zSMbtdG/7AAM7f0iL+IO8jgXAttIv+HrTOL7ZdDfbyxbvfuObbiJp4j+Z2j2Bw3P3Ic7vIzkxwJn9D+Ifqz6EsjI444y9ymFmHJA+lu5Zj9Ox5Qj2aXU5vdtPp0PLC/Zqf02JmZGWPATjl4OqGPGkp5zmUSpprJKSkhg/fjyffPIJycnJHH/88YwcOZJt27Z5HU1EROrBojERbmPSp08fN2/ePK9jSBO0rWwx32y+n8LypST429K19ZW0Sx3qdaxG75vNd7O68HlCrhQwfBZP55aX0jXt6tqfNH8+XHxx1cTqgwdDcTG8+ioceSRMnlzV3VPCVhncwtL151IeXI1zQcx8JMbtx8FZz+L3tfA6njRSpaWljBkzhvHjx5Odnc1jjz3GkCFDvI4lIlFgZv91zjWZi65TMjq53JOujfh+5z55fZN6HcKhYk+kBtvLCpi79sLqgqWKz5I4IO06Ore6cLfPDYZKWbV9KmuLZ+CzBDq1PI92KSc3re6Ve6mwbCn/XXfeL143AJ8l0Df7NZIDXWp/snPw0UdVhV8gAEOGwH77RTdwM+BciMKyzyit+JakwIGkJvTVhORSJ59//jnDhw9n6dKljBgxggkTJtC6dWuvY4lIBDW5Yi+9k8uLQrH3+VOxW+xpUnWRGizb8uAuBUvI7eDbrf+gY8tz8dUy31jIVTBv7UUUVSz7+flFG79k047Z5GXeHfXcXttQMrPGqQ6cc2ws+YDOrYbX/mQzGDiwapGIMfPRMrE/LRP7ex1Fmpi+ffsyf/58xo4dy7333stbb73FpEmTGDpUPRxERJqK2G9qENkL28uW1Lg+5CooD26u9XkbSt6juOK7XxSKQbeD9cX/obj8u4jnbGz8vvgaBwUx89VaIDcVzjnWFk5j3upT+GzlIL7ZNJby4CavY4lEVWJiInfddRdz5swhLS2Nk046ieHDh7Nlyxavo4lIc6WpF8KiYk+kBklxHWp9LOCrfZ60TSWfEnQlNT62pTT2uxO3TT6xlu6qjrYpJzR4nkhatvlOlm2+g+KKrygLrmFt4VT+u+Y0KoMapl5iX58+fZg3bx4333wzTz/9NLm5ucyYMcPrWCIisgcq9kRq0DXtjzVMip1Ixxbn4vfVMG9btYS4thjxu6w3/FEf6r8xSAp04sA2t+LjpykhkvFZAoek39Okf/6yyvWsLXyBkNvx8zpHJZWhbawpfM7DZCINJyEhgTvuuIPPP/+czMxMTj31VC666CI2b669t4OISCQZmnohXCr2RGqQmXwUOem3E+9LxwjgsyQ6tbyAA9qM3u3zOrQ4s4aWLcNnCWQk/yZ6gRuR7BbD6N/pQw5scwsHpt/GgI6zyGrio5gWlS+psRtqyJWxtfSzqB+/vHIDawufY832pymrXBv144nsTq9evZg7dy633XYbU6dOJScnh1deecXrWCLSXDgX+SWGqdgTqUX7FqcysPMsBnb+kKP3mcOBbUbj28Nk1Ilx7emZ9QgBX1p1q1YSSXGd6NP+CXy2a4tfrIr3t6F9izNpn3o6AX9rr+PUW4I/C0ewhkf8JEZ5UvH1hS/x+epBfLf5Lr7fcg9zVx3H6u1PRPWYInsSHx/PmDFjmDt3Lu3bt+eMM87g/PPPZ+PGjV5HExGRnajYE9kNMx/x/rSwBhdJTxrAUZ0/ok/7pzg8+0UGdPwPqfH7RzGlRFtK/CEkB/bl1wMY+yxAh5YXRe24ZZXrWbb5VpwrI+R2EHKlOMpYvuU+dlQsj9pxReqqZ8+efP7554wdO5Zp06aRm5vLSy+95HUsEYlh6sYZHhV7IlFg5qdlQg6p8ftpTrMYYGZ0y5pM68TDMOLxWRLx/kxyMh8mJYqF/KaSd6i6QuGXnAuyofjNqB1XJByBQIBbbrmFefPm0bFjR4YNG8a5557Lhg0bvI4mItLsqdgTEamDeH86Pdo9Qb9Os+iTPYN+HT8iPfmoqB7TEcTVcC2BI4RzlVE9tki4unfvzmeffca4ceOYPn06OTk5vPjii17HEpFYEo1pF9SyJyIiP4n3tyEp0LmWKSYiKz3pWGpqGPZZPBkpx0f9+CLhCgQC/O1vf2P+/Pl06dKFc845h2HDhrF+/Xqvo4lIjLBQ5JdYpmJPYlIwVMbGko/ZWPIRwVDpnp8g0gglBjrSufU11dOA+AEfPkukQ8vfkRJ/kNfxRGqVl5fH7Nmzufvuu5kxYwa5ublMnTq1xpZqERGJnt0PLSjSBG0s+ZhFP47if9c6hejWdgKZyYO8CyWylzq1GkmbpKPZWPwGjiAZyUNITcjxOpbIHsXFxXHDDTdw6qmnMmLECH7729/y/PPPM3HiRNq1a+d1PBFpqvQ3o7CoZU9iSnlwCwt//BNBV0zQFVUvJSz68VrKghoSXJqmlPgD2CftGrqkXadCT5qcnJwcPvnkE8aPH8+bb75Jbm4uzzzzjFr5REQagIo9iSnri9+q5RHH+qLIj14YDJXyzeYH+HDFkXzwQz8KNtxCeXBzxI8jItKU+f1+Ro8ezYIFCzjooIO48MILOe2001izZo3X0USkidHUC+FRsScxJRgqqnGUwpCroDJUGNFjOeeYv/73rNj2JOXBjVSEtrG26BXmrDlb1wmKiNTg4IMP5qOPPmLChAm888475Obm8uSTT6qVT0QkSlTsSUxJTxqA2a6XovosnvTk30T0WNvKFlBYVkCIsp/XOSqpCG5lffF/InosEZFY4ff7ue6661i4cCF5eXlccsklnHzyyaxevdrraCLS2DnAucgvMUzFnsSUFgmH0C7lZPyW9PM6vyWTlXw8LeO7RfRYheVf4mq4SjjoSthWtiiixxIRiTUHHnggH374IQ899BDvv/8+ubm5TJkyRa18IrJb6sYZHhV7EnNyMsbSre0DtE0+gbbJg8nLHE9u5j1YTROW1UNSXCcM/y7rfZZIcqBLRI8lIhKLfD4fV199NYsWLaJHjx6MGDGCoUOHsnLlSq+jiYjEBBV7EnPMjMzkQfTIepAeWf+gbcoxES/0ANKTjiDe3wZ+UfAZPguQnXpaxI8nIhKr9t9/f95//30efvhhZs2aRV5eHpMnT1Yrn4jsykVhiWEq9kT2kpmfw9o/TXrSERhxGHG0jM/lsPbPEPC38jqeiEiT4vP5uOqqq1i8eDG9evXisssuY8iQIaxYscLraCIiTZYmVReph4S4tvRq9xjB0A4cIeJ8KV5HEhFp0rp27crMmTN59NFH+fOf/0xeXh7jx49n5MiRUemlISJNhxH719hFmlr2RCLA70tSoSciEiE+n48//OEP5Ofnc9hhh3HFFVcwePBgli9f7nU0EfFSNEbijPHu4ir2REREpFHq0qUL7777Lo8++ihz5swhLy+PiRMnEgqFvI4mItIkqNiTZiPkygm5Cq9jiIhIGMyMkSNHkp+fT//+/bnyyis59thj+e6777yOJiIe0NQL4VGxJzGvuPx75q65gJnLD+W95b1YuP5qyoNbvI4lIiJh2GeffXjrrbf497//zfz58+nWrRsPP/ywWvlERHZDxZ7EtIrgNj5f+1u2ln0BhHBUsqHkfeatvQjn9B8EEZGmxMy49NJLyc/PZ+DAgVx99dUcffTRLFu2zOtoItJQNPVCWFTsSUxbU/QqIVfGzp9kRyWllWvZUvq5d8FERGSvderUiTfeeIMpU6awcOFCunfvzkMPPaRWPpFmQN04w6NiT2Jacfk3hFzpLusdIUoqfvAgkYiIRIKZMXz4cAoKCjjmmGMYNWoUAwcO5Ouvv/Y6mohIo6FiT2Jay4Ru+C1pl/WGkRp/oAeJREQkkjp06MCMGTN44oknKCgooEePHkyYMIFgMOh1NBGJNAeEXOSXGKZiT2Ja+9STifO1APw/r/NZPKnxB9MqoadnuUREJHLMjIsvvpiCggKOP/54Ro8ezW9+8xu+/PJLr6OJiHhKxZ7ENL8vmb7ZL5KVMgS/JRPna0XHFufRu92/MTOv44mISARlZ2fzyiuv8Mwzz/D111/Ts2dPxo8fr1Y+kViiAVrC4nmxZ2ZtzOwdM/um+t+0WrYLmtmC6uW1hs4pTVdiXFu6t72fY7r8l6P3+YyD0m/E70v2OlajUhbcyKYdsympWOF1FBGRejEzzj//fAoKCjjxxBP5y1/+Qv/+/VmyZInX0UREGpznxR5wAzDTOXcAMLP6fk12OOd6Vi+nNlw8kdjlXIilG8fy8YpjWfTjNcxefSr/XTuCylCx19FEROqlXbt2vPzyyzz33HN8++23HHroodxzzz1UVlZ6HU1E6kGjcYanMRR7pwFPVN9+AjjduygizcvK7c+ypugVQpRTGSok5MrYUvpflmy81etoIiL1Zmacd955FBQUcMopp3DjjTdyxBFHkJ+f73U0EdlbzkV+iWGNodjLcs6trb69DsiqZbtEM5tnZp+Z2em726GZjazedt6GDRsimVUkpqzY/iQht+MX6xzl/Fj8DsHQjlqeJSLStGRlZTFt2jReeOEFli9fTu/evRk3bhwVFRVeRxMRiaoGKfbM7F0zy69hOW3n7Zxzu7tMch/nXB/gfOBBM9uvtuM55yY55/o45/pkZmZG7gcRiTGVocJaHwvWMD+hRF7IVfBj8dt8t+Vh1hW9RjBU5nUkkZh19tlns2TJEk4//XRuvvlm+vXrx6JFi7yOJSJhUDfO8DRIseecO845l1fD8iqw3szaA1T/+2Mt+1hd/e93wAfAoQ2RXSSWtUnsR01fAwlxbQn4Wjd4Hi+sLpzOxysHM3N5Tz5bPYzNO+Y02LErgluZs/pklm68geXbHuGrTbcxe9Wx7Khc3WAZRJqbzMxMnn/+eaZNm8aqVavo06cPd9xxh1r5RCQmNYZunK8Bl1TfvgR49dcbmFmamSVU384ABgAaVkuknvZvcx1xvlSMAACGH58lkpMxtllMTbFi21N8uekOdlSuIuTKKCwv4Iv1V7CldF6DHH/ZlvsorVxF0FUNiBN0JZSHNvHlxpsb5PgizdlZZ51FQUEBw4YN49Zbb6Vv374sWLDA61gisjvRmHahni17Zna2mRWYWcjM+uxmuyFm9pWZLTOz2gakjLjGUOzdAww2s2+A46rvY2Z9zOzf1dscAswzs4XA+8A9zjkVeyL1lBzoRP8OM+jc8mJaJRxK+9TTODz7BdKT+nsdLepCrpJvtz6yyzWLIVfKss0PNkiGH4vfwvHrkQFDbC2dQ8iVN0gGkeYsIyODZ599lunTp7N27VoOO+wwxowZQ3m5Pn8ijZEB5lzEl3rKB84EZtWa28wP/BM4EcgBfmtmOfU9cF3ENcRBdsc5twk4tob184DLqm9/CnRr4GgizUJCXFsOTB/tdYwGVxnaRsjVfH1cUcU3DZLBiP3WU5Gm4PTTT2fgwIFcc8013H777UyfPp0pU6bQq1cvr6OJSCPnnFsK7KlHVF9gWfXlaJjZVKpmJIh641VjaNkTEWlwcb6WGP4aH0uK69QgGdqmDP25C+3/+EhL7I/P4hskg4hUadOmDU899RSvvfYaGzZsoG/fvtxyyy2UlWnQJJFGJRSFBTJ+Gsm/ehkZ4dQdgJU73V9VvS7qVOyJSLPkswD7tBqBz5J+tT6R/dL+1CAZ9ksbTVJgH/yWAvjwWwoJ/rYcnHFngxxfRHZ1yimnUFBQwIUXXsidd95J7969mTevYa7jFRHPbPxpJP/qZdLOD9Z1ZoHGyPNunCIiXuna+kqMOH7YPpnKUDEJ/rYc2OavZCYf1SDHD/hbcnj2a2za8RFF5V+RHOhMRvKxatUT8VhaWhqPP/44Z599NiNHjqRfv378+c9/5rbbbiMxMdHreCLNWgSusQubc+64eu5iNbBzt6GO1euiTsWeiDRbZkbXtMvZt/VIHBUYgQYfhdTMT0byIDKSBzXocUVkz0466SQKCgq4/vrrueeee3j11VeZMmUKhx9+uNfRRJqnCIye6ZG5wAFmti9VRd55VM0dHnXqxikizZ6Z4bP4ZjHdhIiEp3Xr1kyePJk333yTwsJC+vfvz1//+ldKS0u9jiYijYCZnWFmq4AjgNfN7K3q9dlm9gaAc64SuAp4C1gKvOCcK2iIfCr2RERERPZgyJAh5Ofnc+mll3Lfffdx6KGHMnv2bK9jiTQzDlwUlvokcm66c66jcy7BOZflnDuhev0a59zQnbZ7wzl3oHNuP+fcuHq+EHWmYk9ERESkDlq1asWkSZN46623KCkpYcCAAYwePZodO3bs+ckiIh5QsSciEk0rV8LYsXDRRXDVVTBrVr3/iigi3jr++ONZvHgxl19+ORMmTKBnz5588sknXscSaRbMRX6JZSr2RESiwTm4807o2ZPg+h/Z0LsfO7LawxVXwKBBsHmz1wlFpB5atmzJxIkTeffddykvL+fII4/k2muvpaSkxOtoIiI/U7EnIhINkybB1Km8PvEFBpcdzLn5IU74LpUbL7uLim7d4Ywz1MInEgOOPfZYFi9ezJVXXsmDDz5I9+7dmTVrltexRGJXI7tmr7FTsSciEmnBIIwbx8Kb7mL8fwooKS2npLSC8oognyz+gVu7Hgs//ggffeR1UhGJgNTUVB555BHef/99QqEQRx11FFdffTXFxcVeRxOJLQ4sFPkllqnYExGJtDlzIC2Nict2UFpe+YuHyiuCfLzoB3acfyG88IJHAUUkGgYNGsTixYu5+uqrefjhh+nevTsffPCB17FEpBlTsSciEmnbt0NWFhu2FNX4cCDOR1Fqq6rtRCSmpKSk8NBDDzFr1ix8Ph9HH300f/zjHykqqvn7QETCpG6cYVGxJ9IIVIQKWb71cRasH8U3Wx6mtHK915GkPvbbDxYtovf+Wfh9NU3UbrRZtrRqOxGJSUceeSQLFy7k2muvZeLEiXTr1o333nvP61gi0syo2BPxWGnlej5eNZRvtv6D9SVv8/3Wf/PxqpPYVpbvdTTZWwccAIccwpVl35OUGP+Lgi8xPo7rjj8Y/3PPwYgRHoYUkWhLTk7mgQce4KOPPiIQCHDsscfyhz/8gcLCQq+jiTRdLgpLDFOxJ+Kxrzc/QHlwKyFXCoCjgqArIX/DLR4nk3r5+99pffcdTMsJcfIRB5Cd2YqeB3XgoeP35eSxo+Daa6FTJ69TRkwwVMqWHXPYXrYI52L8aneRMA0YMICFCxdy/fXX8+ijj5KXl8e7777rdSyRJsmci/gSy+K8DiDS3G3YMQsI7rK+uOJbKkKFBHwtGj6U1F/PnvD227S+7jpuXLIEunWrGoFz61b4299g5EivE0bMuqL/x1ebbqHq74ch4nwt6ZE1idT4g7yOJtJoJCUlcf/993PWWWfxu9/9jsGDB/P73/+e8ePH06pVK6/jiUiMUrEn4jG/JVBZ4yOGj0ADp5GI6tkT3nsPli2Db7+Fli2hb1/w+71OFjHF5d/y5aabfm6ZBggGS/hi3XAGdJqFz/QeFtnZEUccwRdffMGYMWO4//77efPNN3nssccYMmSI19FEmoYYb4mLNHXjFPFYpxbn4LPEX6wz4shIHojfl1jLs6RJ2X9/OOEEOOKImCr0ANYUvUDIVeyyPuTK2LJjtgeJRBq/pKQk7r33Xj799FNatGjBiSeeyIgRI9i6davX0UQkxqjYE/HYvq0vIz2pPz5LwG8p+C2Z1PgDyMu4w+toIntUHtxETd2QASpCWxs0i0hTc/jhhzN//nxuvPFGnnzySfLy8njjjTe8jiXSeDkgFIUlhqnYE/GYz+LplfUIR2RPIzfjdvq0m8wR2dOI97f2OprIHmUkHY3PknZZ71wFrRP7epBIpGlJTEzkrrvu4rPPPiMtLY2TTjqJ4cOHs2XLFq+jiTQ6RuQHZ4n1AVpU7Ik0Eqnx+9E+dSitE3tgVtPcbCKNT2bK8aQGDvpFweezJDq2vITEuHYeJhNpWvr06cO8efO4+eabefrpp8nNzWXGjBlexxKRJk7FnoiI7DWfBejV/ikOSLuB1ol9SU86mrzMh9i/zWivo4k0OQkJCdxxxx18/vnnZGZmcuqpp3LRRRexefNmr6OJNB7ORX6JYSr2RESkXnwWT4eW59Gr3VP0yPoXGclHeR1JpEnr1asXc+fO5bbbbmPq1Knk5ubyyiuveB1LRJogFXsiIiIijUx8fDxjxoxh7ty5ZGVlccYZZ3D++eezceNGr6OJeEste2FRsSciIiLSSPXs2ZO5c+dy++23M23aNHJzc3n55Ze9jiUiTYSKPREREZFGLBAIcOuttzJv3jw6duzIWWedxbnnnsuGDRu8jibSsDT1QthU7ImIiIg0Ad27d+ezzz7jzjvvZPr06eTk5PDiiy96HUukQWnqhfCo2BMRERFpIgKBADfddBPz58+nS5cunHPOOQwbNoz169d7HU1EGiEVeyIiIiJNTF5eHrNnz+buu+9mxowZ5Obm8txzz+FivJVCRAO0hEfFnoQl5Cr5sXgm32z+B6sLX6YyVOJ1JBERkWYpLi6OG264gS+++IL99tuP888/nzPPPJN169Z5HU1EGgkVe1JnlaEiZq8+i0Ub/sp32/7F0k3jmLXyOIrLv/c6moiISLOVk5PDJ598wr333subb75JTk4OzzzzjFr5JAZFoVUvxj8nKvakzpZteYTiih8IuqrWvKDbQUVoG4s33OhxMhERkeYtLi6Ov/zlLyxYsICDDjqICy+8kNNPP521a9d6HU0kchwq9sKkYk/qbG3xGzjKf7XWsb18CRXB7Z5kEhERkf85+OCD+fjjj5kwYQJvv/02OTk5PPXUU2rlE2mmVOxJnRlW6yNYbY+JiIhIQ/L7/Vx33XUsXLiQ3NxcLr74Yk455RRWr17tdTSR+tM8e2FRsSd11j7lVHwW/6u1Plol5BHwtfAkk4iIiNTswAMP5MMPP+Tvf/877733Hrm5uUyZMkWtfCLNiIo9qbP90v5AauBA/JYM+PFbCvH+NnTLvMfraCIiIlIDv9/PqFGjWLRoEd27d2fEiBEMHTqUlStXeh1NZK9oUvXwqNiTOovzJdMveyo9s/7BAWnXkJsxlqM6vUtyoJPX0URERGQ39t9/fz744AMefvhhZs2aRV5eHpMnT1YrnzQ9GqAlLCr2JCxmPjKS+tO19WW0Tz2xhm6dIiIi0hj5fD6uuuoqFi9eTK9evbjssss44YQTWLFihdfRRCRKVOyJiIiINCNdu3Zl5syZ/POf/+TTTz8lNzeXRx99VK180vg5IOQiv8QwFXsiIiIizYzP5+PKK69k8eLF9O3blyuuuILBgwezfPlyr6OJSASp2BMRERFppvbdd1/effddHn30UebMmUNeXh4TJ04kFIrx8eiliYrC9Xox3qKtYk9ERESkGTMzRo4cSX5+Pv379+fKK6/k2GOP5bvvvvM6mojUk4o9EREREWGfffbhrbfe4rHHHmP+/Pl069aNRx55RK180rioZS8sKvZEREREBKhq5bvsssvIz89n4MCB/OlPf+Loo49m2bJlXkcTqaJiLywq9kRERETkFzp16sQbb7zBlClTWLhwId27d+ehhx5SK59IE6NiT0RERER2YWYMHz6cgoICjjnmGEaNGsXAgQP5+uuvvY4mzZWmXgibij0RERERqVWHDh2YMWMGTzzxBAUFBfTo0YMHHniAYDDodTQR2QMVeyIiIiKyW2bGxRdfTEFBAYMHD+b666/nyCOP5KuvvvI6mjQrDlwo8ksMU7EnIiIiInWSnZ3Nq6++ytNPP82XX35Jjx49GD9+vFr5pOFogJawqNgTERERkTozMy644AKWLFnCiSeeyF/+8hcGDBjA0qVLvY4mIr+iYk9EREREwtauXTtefvllnn32WZYtW8ahhx7KvffeS2VlpdfRJFZpgJawqdgTERERkb1iZvz2t7+loKCAk046iRtuuIH+/fuTn5/vdTQRQcWeiIiIiNRTVlYW06ZN4/nnn+f777+nd+/ejBs3joqKCq+jSazRNXthUbEnIiIiIvVmZpxzzjksWbKE008/nZtvvpl+/fqxaNEir6NJLFGxFxbPiz0zO9vMCswsZGZ9drPdEDP7ysyWmdkNDZlRREREROomMzOT559/nmnTprFq1Sr69OnDHXfcoVY+EQ94XuwB+cCZwKzaNjAzP/BP4EQgB/itmeU0TDwRERERCddZZ51FQUEBw4YN49Zbb6Vv374sWLDA61jSpEWhVU8te9HlnFvqnNvTjJx9gWXOue+cc+XAVOC06KcTERERkb2VkZHBs88+y8svv8zatWs57LDDGDNmDOXl5V5HE2kWPC/26qgDsHKn+6uq19XIzEaa2Twzm7dhw4aohxMRERGR2p1xxhkUFBRw3nnncfvtt/P+++97HUmaIgeEQpFf6qEul6SZWScze9/MllRve029DhqGBin2zOxdM8uvYYlK65xzbpJzro9zrk9mZmY0DiEiIiIiYUhPT+epp55i7ty5nHDCCV7HEYmUPV6SBlQC1zvncoB+wB8b6pK0uIY4iHPuuHruYjXQaaf7HavXiYiIiEgT0qdPrePxiexZI7vGzjm3FKpGo93NNmuBtdW3C81sKVW9FJdEO1+DFHsRMBc4wMz2parIOw8439tIIiIiIiLSoKJT7GWY2byd7k9yzk2KxoHMrAtwKDAnGvv/Nc+LPTM7A3gYyAReN7MFzrkTzCwb+LdzbqhzrtLMrgLeAvzA/znnCjyMLSIiIiIisWGjc253U8C9C7Sr4aGbnHOv1vUgZpYKvASMcs5tDz9m+Dwv9pxz04HpNaxfAwzd6f4bwBsNGE0ipDJUwrriN9letpTU+APITj2ZOF+K17FEREREpElxEGr4bpwRuCQNMwtQVeg945x7uf6p6sbzYk9iW2nlOj5bcy6VoWKCrgSfJfHtloc5PHsqyYGOXscTEREREYkqq7qgbzKw1Dn3QEMeu6lMvSBN1NJNd1MW3ETQlQAQcjsoD21lyabbPU4mIiIiIk2KA+dCEV/qw8zOMLNVwBFUXZL2VvX6bDP7qVfiAOAi4BgzW1C9DK1llxGllj2Jqo07ZgG//hCF2LRjNs6FMNPfG0RERESkjjzoxrk7dbkkzTn3MVD7cJ1RpP9pS1RZLW+xqvWevOdFRERERJoFFXsSVe1STsII/GKdESArZfBu5yMREREREdmFc5FfYpiKPYmqg9L/TGr8/vgtGR8J+C2F5EBnDkm/xetoIiIiIiIxTdfsSVQFfC04InsaW0rnUlSxjJRAF9ok9tO1eiIiIiISHucgVL8BVZobFXsSdWZGm6S+tEnq63UUEREREWnKYrzbZaSpeUVERERERCQGqWVPRERERESaBKdunGFRy56IiIiIiEgMUsueiIiIiIg0AbE/VUKkqWVPREREREQkBqllT0REREREGj8HhNSyFw4VeyIiIiIi0jQ4DdASDnXjFBERERERiUFq2RMRERERkUbPAU7dOMOilj0REREREZEYpJY9ERERERFp/JzTNXthUrEnIiIiIiJNgrpxhkfdOEVERERERGKQWvZERERERKRpUDfOsKhlT0REREREJAaZc7Hd79XMNgA/eBghA9jo4fFF56Cx0Hnwns6B93QOvKdz4D2dg8YhA0hxzmV6HaSuzOw/VOWOtI3OuSFR2K/nYr7Y85qZzXPO9fE6R3Omc9A46Dx4T+fAezoH3tM58J7OQeOg89A8qBuniIiIiIhIDFKxJyIiIiIiEoNU7EXfJK8DiM5BI6Hz4D2dA+/pHHhP58B7OgeNg85DM6Br9kRERERERGKQWvZERERERERikIo9ERERERGRGKRiT0REREREJAap2IswM7vKzOaZWZmZPV6H7a81s3Vmtt3M/s/MEhogZkwzszZmNt3Mis3sBzM7fzfbjjGzCjMr2mnp2pB5Y0VdX3ercq+Zbape7jUza+i8sSiMc6D3fZSE8ztA3//RUddzYGbDzSz4q8/BoAYLGsPMLMHMJld/DxWa2QIzO3E32+uzEGHhnAN9FmKbir3IWwPcCfzfnjY0sxOAG4BjgX2ArsDtUU3XPPwTKAeygAuAiWaWu5vtn3fOpe60fNcgKWNPXV/3kcDpQA+gO3AKcHkDZYx14bz39b6Pjjr9DtD3f1TV+fcwMPtXn4MPohut2YgDVgJHAa2Am4EXzKzLrzfUZyFq6nwOqumzEKNU7EWYc+5l59wrwKY6bH4JMNk5V+Cc2wLcAQyPYryYZ2YpwFnALc65Iufcx8BrwEXeJottYb7ulwATnHOrnHOrgQnofV9veu83DmH8DtD3f5SE+XtYosA5V+ycG+OcW+6cCznn/h/wPdC7hs31WYiCMM+BxDAVe97KBRbudH8hkGVm6R7liQUHApXOua93WreQqte6NqeY2WYzKzCzP0Q3XswK53Wv6X2/u/MjdRPue1/ve2/p+79xONTMNprZ12Z2i5nFeR0oFplZFlXfUQU1PKzPQgPYwzkAfRZilk6kt1KBbTvd/+l2C/QXyb2VCmz/1bptVL2mNXmBqklF1wOHAy+Z2Vbn3HPRixiTwnnda3rfp5qZOU38WR/hnAO9772n73/vzQLygB+oKjieByqBu70MFWvMLAA8AzzhnPuyhk30WYiyOpwDfRZimFr2wmBmH5iZq2X5eC92WQS03On+T7cL6582NtXhHPz6NaX6fo2vqXNuiXNujXMu6Jz7FHgIGBbdnyImhfO61/S+L1KhV291Pgd63zcK+v73mHPuO+fc99Vd3BYDY9HnIKLMzAc8RdW1xFfVspk+C1FUl3Ogz0JsU7EXBufcIOec1bL8Zi92WUDVIBU/6QGsd87pL1m1qMM5+BqIM7MDdnpaD2rvtrDLIQCNDBm+cF73mt73dT0/Urv6vPf1vm94+v5vfPQ5iKDqUZYnUzVg1FnOuYpaNtVnIUrCOAe/ps9CDFGxF2FmFmdmiYAf8JtZ4m76PT8JXGpmOWbWmqqRkh5vmKSxyTlXDLwMjDWzFDMbAJxG1V+1dmFmp5lZmlXpC1wNvNpwiWNDmK/7k8B1ZtbBzLKB69H7vt7COQd630dPGL8D9P0fJXU9B2Z2YvV1TJjZwcAt6HMQSROBQ4BTnHM7drOdPgvRU6dzoM9CjHPOaYngAoyh6i8iOy9jqh/rTFV3hc47bX8dVdfNbAemAAle/wxNfQHaAK8AxcAK4PydHjuSqi6DP91/jqprAoqAL4Grvc7fVJfaXvcaXnMD7gM2Vy/3AeZ1/lhYwjgHet9H7xzU+DtA3/+N7xwA91e//sXAd1R1XQt4nT8WFqqmUHBAafVr/tNygT4Lje8c6LMQ24tVn2QRERERERGJIerGKSIiIiIiEoNU7ImIiIiIiMQgFXsiIiIiIiIxSMWeiIiIiIhIDFKxJyIiIiIiEoNU7ImIiIiIiMQgFXsiIiIiIiIxSMWeiIhEhZndZ2av7HR/vJnNNLN4D2OJiIg0G5pUXUREosLM0oHvgEHA4cAfgd8457Z5mUtERKS5ULEnIiJRY2ZjgDOBVlQVeiur198L9AeWAyOccxVeZRQREYlV6sYpIiLR9AXQDbhxp0KvB9DBOXck8CUwzMN8IiIiMUvFnoiIRIWZdQMmAk8AI3Z6qD/wdvXt/wADGjiaiIhIs6BiT0REIs7MOgAzgCuAK4FuZjao+uE0YHv17W1Am4bOJyIi0hyo2BMRkYgys5bAG8ADzrnXnHMlwHhgXPUmW4GW1bdbAZsbPKSIiEgzoAFaRESkQZlZT+A659zFZvY34Hvn3HMexxIREYk5atkTEZEG5ZxbAKw3s4+AXOAlbxOJiIjEJrXsiYiIiIiIxCC17ImIiIiIiMQgFXsiIiIiIiIxSMWeiIiIiIhIDFKxJyIiIiIiEoNU7ImIiIiIiMQgFXsiIiIiIiIxSMWeiIiIiIhIDFKxJyIiIiIiEoP+P1eD2D0Cr1FBAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -689,38 +674,83 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 39, "id": "e508f38c", "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "Converting tensor to type torch.Tensor.\n", - "Converting tensor to type torch.Tensor.\n", - "Converting tensor to type torch.Tensor.\n", - "Converting tensor to type torch.Tensor.\n" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c84c700bd92f46a5a8f0512b3ee4ffc6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Batch Test Gradients: 0%| | 0/8 [00:00" ] diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index 55308e940..0e39af38c 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -203,7 +203,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7271779863904a54bedbfd1344d2de2e", + "model_id": "e66b7ce90e0c43d18a94be867c19edca", "version_major": 2, "version_minor": 0 }, @@ -233,13 +233,12 @@ "\n", "losses = fit_torch_model(\n", " model=nn_model,\n", - " train_data=train_data_loader,\n", + " training_data=train_data_loader,\n", " val_data=val_data_loader,\n", " loss=F.cross_entropy,\n", " optimizer=optimizer,\n", " scheduler=scheduler,\n", " num_epochs=num_epochs,\n", - " batch_size=16,\n", ")" ] }, @@ -259,7 +258,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -367,7 +366,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1021b2f7371a43f19faa46dd31009488", + "model_id": "92bfe19a467c4873a8410ffd24bfb875", "version_major": 2, "version_minor": 0 }, @@ -381,7 +380,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6aaf901a28aa429f82811c8372196d49", + "model_id": "527fb6934e6e4cedad7794fd29d0ee16", "version_major": 2, "version_minor": 0 }, @@ -395,7 +394,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9878efee3ef04160bf32e8e8dbb3c8b1", + "model_id": "523cf605e928469baef1010e8114e90b", "version_major": 2, "version_minor": 0 }, @@ -461,7 +460,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA68AAAH3CAYAAABU2mlaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAAyz0lEQVR4nO3debhdZXk3/u9NAjITIWEmCSgo4ouoEQeU4lC1BaW1tkBfaB3R9kUc+msFbJWfWKDVt1RtHagiKlSKFrUKdagKWEUtKFoBBYQwhEEigoZBQJ73j72SHg7nJDvknLNXwudzXfvK3s+a7pXzsDnfPGs9q1prAQAAgD5bb9QFAAAAwKoIrwAAAPSe8AoAAEDvCa8AAAD0nvAKAABA7wmvAAAA9J7wCsC0qKrfr6qfVNWvq+rUqtqvqlpV7Tjq2kiq6tyq+tBkn6f4WMdW1ZWTfZ6G451aVf8xXfsHYDSEVwBW6qEEgaqaleSUJGcmmZ/k9dNRG1PqJUneNMyKVbVj9w8R+w2573cledpDrGtldRxaVRM9sP71SX5/qo8HwGjNHnUBAKyTtkuyaZJzWmtLkqSqRltRz1XV+q21e0d1/NbarVO9z6paL0m11pYlWTbV+59Ma+32mToWADPHyCsAq2X5SGxVHV5V11TVL6rq36pqm275y5Jc161+/mQjdJNdRlxV93X7WP55m+6Yt1TVL6vqG1W177htHlVVn6qqW6vqzqr6QVUdMGb5k6vqS1W1rNvPWVW1YBXneWBVfa/b321V9Z2qeuJqHPO3q+qiqvpVVf20qt5XVZtM8Pf4uqpanORXVbXRqs63qtavqr+rquu7fd9YVWes4lwWVNUXququqrquql43wTrjLyN+ZnfsX3av71fVC7rFy3++X+t+hou7bY6tqiur6qCq+lGSe5LsNtllwlX1h1V1VVXdXVVfrqqFY5Y9aJuuplZVC7s+9fGuvXWvU8f+3Y7Zrqrq/+uOdU8NLmd/w7h9L66qt1fVu7uf6c1VdVJV+Yd+gJ4QXgF4KJ6S5NlJ9k/ygiT/K4NLQ5PkX5Ls3b0/MINR2G8+lINU1UZJvpZksyS/leSJSc5J8uWq2r1bZ9tu/3OSvLir5a+S3N8tf1yS85JckGRRkuck+XW3jw0nOe62ST6Z5BNJ9kjy9CR/n+S+IY+5Z5J/S3J+kick+eMkByT5wLhD7d3Vc2C33nqrOt8kr0vyB0kOTbJrd/xvreTvsJJ8OslWSfZL8qJumyetZJvZXf3f7tZ7UpJjk9zZrbJ829/L4Of7lDGbb5/kT7tzflyS6yc5zHbden+Q5FlJNk9yVlfvML6Z5Igx+9ouk1+e/qdJjktyYgY/z3cmObGqXjluvdcluTHJU7v3R3TnAUAP+NdEAB6KXyV5WWvtV0lSVR9I8oYkaa3dVVW3dOvd2lq7qVvnoRznoAxCzUGttfu6tr+uqucmeU13zP+TpCU5sLV2R7fOT8bs4y+SfL619rblDVV1aJKfJ3lhks9McNztkqyf5MzW2uKu7bIxy1d1zD9P8t3W2hu7zz/qRjs/XVV/2Vq7pmu/P8lh3WW1y0etV3W+C5JcnuS81lpLcm2S/5rgHJZ7bgYh+DGttcu74/xht91kNkvyyCT/1lq7omu7YszyB/18x9iwO6cV+5/kZ79xBn3oym6dw5L8OIMw/5WV1JYkaa3dU1W3d+/H1zDeUUne21o7efm5VNVjkrwlyYfHrPf11tqJY9Z5eZLnjVsHgBERXgF4KH60PLh2bkiyzTQc5ylJtk1y27gA9Igkd3Xvn5zkm2NC5ET7eHRVjb/ncsMMRi4n8oMkX0zyw6r6cpJzk5zVWlt+ueyqjrlHkq+OazsvSWUwGrk8vF62PLiOqXVV5/uRJF9OcmVX25eTfK61ds8ktTwuydLlwTVJWmu3VNWPJ1k/rbWfd5cQf7GqvtrV/unW2qTbjHHz2OC6ErcsD67dMS+vqqUZ/N2tMrwOq6o2T7JjBqPgY52X5PVVtXFrbfmI8sXj1rkhyc5TVQsAa0Z4BeChGB+UWgbBbHXc3/25YrsazFI89paW9TIY8fzdCba/c4K2iayXwb2RJ06w7GcTbdBa+3VV/VYGYfJ5GVwee2JV/X5r7fNDHncY48PvKs+3tXZxVe2c5DczuHT73UmOq6qntdZ+MVWFtdZeXVXvTvL87ljHVdURrbUPrmLTyQL96ro/D+5T60/RviczUb92ixVAT/hCBmBUftr9uf2Ytr3ywMByYZJdkvyitXbluNcN3ToXJXnG2MmQxrkwyZ5JfjLBPn4+WXFt4DutteNba/tmMFL38iGPeUmSfce1/UYGYeiSyY455Pmmtbastfbp1tqRGdzHu3u3/4lcmmRuVa0YZa6quUkes5I6lh/nh621v2ut/VYGl84e3i1aHvJmrWofKzGvqh41pqbdkszt6k0G/WPr7h80lht/n+493baT1tEF+usz8c/j6jGjrgD0nPAKwKhcmcHls8dW1WOr6plJTsog4C13epKrk5xdVc/vZpl9alUdXVW/063zvgz+f/bZqtqnqnauqgO6kdMkOT6DcHdaVe3dLX92N6vsLhMVVlXPqKq/6o41v7vndM/8T7Ba1THfmeRJ3Wy1j62qFyZ5b5LTV3FJ7SrPt6r+vKr+d1Xt0Y3AviKDCagun2SfX0ny/THnv1d3nEkfy1NVj66qv6nB7L4LqurpGUyqtPz8l2bw6JvnV9W2VfXIlZzTZO5M8pGqWlRVi5J8NIPLdpdfMvy1DO6LfXsNZnb+/QzuNR7r6u7PF1fVvKradJJjnZDkdVX16qratapek+RPMugbAKwlhFcARqKbkOigJFsn+V6Sf8xgAp37x6xzdwYjZBdmcK/n5UnOymCW3mu6dW5M8swkv8xgZt5Lkvx1uhHc1tplSZ6RwXNnv5hBAPunJBsluW2S8m7PYIbhz2YwUdEpGQS+44Y85g8ymNF33wyC48eTnJ3ktav4O1nl+Sb5RZI3ZTB78n9ncInx7012P2o3qdPvdOd0fpLPdzV/dyWl3JHB/cBndDX8a8bM7ttauz+DIPkHGYxqfm9l5zWJG5OcnORTSf4zgzD7kq7edOfz6iSHJPlhBiH9mHHn9l8ZXDb9wQxGav9hkmO9P8lbu+0vTfLmJEe11kzEBLAWqe7/EQAAANBbRl4BAADoPeEVAACA3hNeAQAA6D3hFQAAgN4TXgEAAOi92aMuYHXNnTu3LVy4cNRlAAAAMA0uuuiipa21eePb17rwunDhwlx44YWjLgMAAIBpUFXXTNTusmEAAAB6T3gFAACg94RXAAAAek94BQAAoPfWugmbAAAAVse9996b66+/PnffffeoSyHJrFmzMmfOnMydOzfrrTf8eKrwCgAArNOuv/76bLbZZlm4cGGqatTlPKy11nLvvffm5ptvzvXXX5/58+cPva3LhgEAgHXa3Xffna222kpw7YGqygYbbJAddtghd9xxx2ptK7wCAADrPMG1X1bncuEV20xDHQAAADClhFcAAAAepKpy5ZVXjrqMFUzYBAAAPOwsPOrsad3/4hP3n9b9PxwZeQUAAFjL3XfffaMuYdoJrwAAACO0cOHCvOtd78qee+6ZLbbYIgcddNCKZ9L+0z/9Ux796Ednyy23zItf/OLccMMNK7arqvzjP/5jdt111+y6664599xzs+OOO+Zv//Zvs/XWW2e77bbLZz7zmZxzzjnZbbfdsuWWW+b4449fsf13vvOdPP3pT8+cOXOy3Xbb5Ygjjsg999wz4+c/LOEVAABgxM4888x84QtfyNVXX50f/OAHOfXUU/PVr341Rx99dM4888zceOONWbBgQQ4++OAHbPeZz3wm3/72t3PppZcmSW666abcfffdWbJkSd7+9rfn1a9+dU477bRcdNFF+frXv57jjjsuV199dZJk1qxZOemkk7J06dJccMEF+cpXvpL3ve99M37uwxJeAQAARuzII4/M9ttvny233DIvetGLcvHFF+f000/PK17xijzpSU/KIx7xiJxwwgm54IILsnjx4hXbHX300dlyyy2z0UYbJUnWX3/9vOUtb8n666+fgw8+OEuXLs3rX//6bLbZZtljjz3yuMc9Lt///veTJE9+8pPztKc9LbNnz87ChQvzmte8Juedd94oTn8owisAAMCIbbvttiveb7zxxlm2bFluuOGGLFiwYEX7pptumq222ipLlixZ0bbTTjs9YD9bbbVVZs2alSQrAu0222yzYvlGG22UZcuWJUkuv/zyHHDAAdl2222z+eab55hjjsnSpUun/uSmiPAKAADQQ9tvv32uueaaFZ/vuOOO/OxnP8sOO+ywoq2qHvL+/+RP/iSPfexjc8UVV+QXv/hFjj/++LTW1qjm6SS8AgAA9NAhhxySj3zkI7n44ovzq1/9Ksccc0ye+tSnZuHChVOy/1/+8pfZfPPNs+mmm+ZHP/pR3v/+90/JfqeL8AoAANBDz3ve83Lcccfl937v97LddtvlJz/5Sc4444wp2/+73vWu/PM//3M222yzvPrVr85BBx00ZfueDtXnYeGJLFq0qF144YWjLgOAh4npfoj9VFp84v6jLgGgly677LLsvvvuoy6DcSb7uVTVRa21RePbjbwCAADQe8IrAAAAvSe8AgAA0HvCKwAAAL0nvAIAANB7wisAAAC9J7wCAADQe8IrAAAAvSe8AgAAMOX222+/fOhDH5qy/c2esj0BAACsLY7dYpr3f/v07n+aLV68ODvvvHPuvffezJ7dj9ho5BUAAGAtdt999w3VtrYTXgEAAEbouuuuy0te8pLMmzcvW221VY444ojcf//9ecc73pEFCxZk6623zh/90R/l9tsHo7mLFy9OVeXDH/5w5s+fn+c85zk59dRTs88+++SNb3xjttpqqxx77LE59thjc+ihh644zvLtlgfb/fbbL0cffXT23nvvbL755jnwwANz6623Jkn23XffJMmcOXOy6aab5oILLkiSnHLKKdl9993zyEc+Mi94wQtyzTXXrNj/l7/85Tz2sY/NFltskSOOOCKttSn9exJeAQAARuTXv/51DjjggCxYsCCLFy/OkiVLcvDBB+fUU0/Nqaeemq997Wu56qqrsmzZshxxxBEP2Pa8887LZZddli9+8YtJkm9/+9vZZZddcvPNN+ctb3nLUMf/2Mc+llNOOSU33nhjZs+enSOPPDJJcv755ydJbrvttixbtixPf/rT89nPfjbHH398zjrrrNxyyy151rOelUMOOSRJsnTp0rzkJS/JO97xjixdujSPetSj8o1vfGOq/pqSCK8AAAAj853vfCc33HBD3vnOd2aTTTbJhhtumGc+85k5/fTT86Y3vSm77LJLNt1005xwwgk544wzHnA58LHHHptNNtkkG220UZJk++23z+te97rMnj17RduqHHbYYXn84x+fTTbZJMcdd1zOPPPM/PrXv55w3Q984AM5+uijs/vuu2f27Nk55phjcvHFF+eaa67JOeeckz322CMvfelLs/766+cNb3hDtt122zX/CxpDeAUAABiR6667LgsWLHjQpEg33HBDFixYsOLzggULct999+Xmm29e0bbTTjs9YJvxn4cxdpsFCxbk3nvvzdKlSydc95prrsnrX//6zJkzJ3PmzMmWW26Z1lqWLFmSG2644QH7qqqHVM/KCK8AAAAjstNOO+Xaa6990ARL22+//QPuJ7322msze/bsbLPNNivaquoB24z/vMkmm+TOO+9c8fmmm2560PGvu+66Bxxj/fXXz9y5cx+0r+W1fvCDH8xtt9224nXXXXflGc94RrbbbrsH7Ku19oDPU0F4BQAAGJG999472223XY466qjccccdufvuu/ONb3wjhxxySE466aRcffXVWbZsWY455pgcdNBBq/XYmr322ivnn39+rr322tx+++054YQTHrTOaaedlksvvTR33nln3vrWt+alL31pZs2alXnz5mW99dbLVVddtWLd1772tTnhhBNyySWXJEluv/32fPKTn0yS7L///rnkkkty1lln5b777st73vOeCcPymhBeAQAARmTWrFn53Oc+lyuvvDLz58/PjjvumH/5l3/JK17xihx22GHZd999s/POO2fDDTfMe9/73tXa92/+5m/moIMOyp577pknP/nJOeCAAx60zmGHHZaXvexl2XbbbXP33XfnPe95T5Jk4403zlve8pbss88+mTNnTr71rW/ld3/3d/PmN785Bx98cDbffPM8/vGPz7//+78nSebOnZtPfvKTOeqoo7LVVlvliiuuyD777LPmf0Fj1FRPXzzdFi1a1C688MJRlwHAw8TCo84edQlDW3zi/qMuAaCXLrvssuy+++6jLqN39ttvvxx66KF51ateNZLjT/ZzqaqLWmuLxrfPyMhrVZ1SVT+tqh+Oa39dVf2oqi6pqr+diVoAAABY+8zUZcOnJnnh2IaqenaSA5M8obW2R5J3zVAtAAAArGWGv9t3DbTWzq+qheOa/yTJia21X3Xr/HQmagEAACA599xzR13CahnlhE27JXlWVX27qs6rqqeMsBYAAAB6bEZGXldy7C2TPC3JU5KcWVW7tAlmkKqqw5McniTz58+f0SIBAIC1X2ttwmeXMhoPZeLgUY68Xp/krDbwnST3J5k70YqttZNba4taa4vmzZs3o0UCAABrt1mzZuXee+8ddRmMcdddd2X99ddfrW1GGV4/k+TZSVJVuyXZIMnSEdYDAACsg+bMmZObb745999//6hLedhrreXOO+/MkiVLsvXWW6/WtjNy2XBVfSLJfknmVtX1Sd6W5JQkp3SPz7knyR9PdMkwAADAmpg7d26uv/76/PjHPx51KSRZf/31s80222TzzTdfre1marbhQyZZdOhMHB8AAHj4Wm+99cydsw4Y5WXDAAAAMBThFQAAgN4TXgEAAOg94RUAAIDeE14BAADoPeEVAACA3hNeAQAA6D3hFQAAgN4TXgEAAOg94RUAAIDeE14BAADoPeEVAACA3hNeAQAA6D3hFQAAgN4TXgEAAOg94RUAAIDeE14BAADoPeEVAACA3hNeAQAA6D3hFQAAgN4TXgEAAOg94RUAAIDeE14BAADoPeEVAACA3hNeAQAA6D3hFQAAgN4TXgEAAOg94RUAAIDeE14BAADoPeEVAACA3hNeAQAA6D3hFQAAgN4TXgEAAOg94RUAAIDeE14BAADoPeEVAACA3hNeAQAA6D3hFQAAgN4TXgEAAOg94RUAAIDem5HwWlWnVNVPq+qHEyz7s6pqVTV3JmoBAABg7TNTI6+nJnnh+Maq2inJ85NcO0N1AAAAsBaakfDaWjs/ya0TLDopyV8kaTNRBwAAAGunkd3zWlUHJlnSWvv+qGoAAABg7TB7FAetqo2THJPBJcPDrH94ksOTZP78+dNYGQAAAH00qpHXRyXZOcn3q2pxkh2TfLeqtp1o5dbaya21Ra21RfPmzZvBMgEAAOiDkYy8ttb+O8nWyz93AXZRa23pKOoBAACg32bqUTmfSHJBksdU1fVV9cqZOC4AAADrhhkZeW2tHbKK5Qtnog4AAADWTiObbRgAAACGJbwCAADQe8IrAAAAvSe8AgAA0HvCKwAAAL0nvAIAANB7wisAAAC9J7wCAADQe8IrAAAAvSe8AgAA0HvCKwAAAL0nvAIAANB7wisAAAC9J7wCAADQe8IrAAAAvSe8AgAA0HvCKwAAAL0nvAIAANB7wisAAAC9J7wCAADQe8IrAAAAvSe8AgAA0HvCKwAAAL0nvAIAANB7wisAAAC9J7wCAADQe8IrAAAAvSe8AgAA0HvCKwAAAL0nvAIAANB7wisAAAC9J7wCAADQe8IrAAAAvSe8AgAA0HvCKwAAAL0nvAIAANB7wisAAAC9J7wCAADQe8IrAAAAvSe8AgAA0HszEl6r6pSq+mlV/XBM2zur6kdV9YOq+nRVzZmJWgAAAFj7zNTI66lJXjiu7ctJHt9a2zPJ5UmOnqFaAAAAWMvMSHhtrZ2f5NZxbV9qrd3XffxWkh1nohYAAADWPn255/UVSf59soVVdXhVXVhVF95yyy0zWBYAAAB9MPLwWlVvSXJfktMnW6e1dnJrbVFrbdG8efNmrjgAAAB6YfYoD15VL0tyQJLnttbaKGsBAACgv0YWXqvqhUn+IslvtNbuHFUdAAAA9N9MPSrnE0kuSPKYqrq+ql6Z5B+SbJbky1V1cVV9YCZqAQAAYO0zIyOvrbVDJmj+8EwcGwAAgLXfyCdsAgAAgFURXgEAAOg94RUAAIDeE14BAADoPeEVAACA3hNeAQAA6D3hFQAAgN4TXgEAAOg94RUAAIDeE14BAADoPeEVAACA3hNeAQAA6D3hFQAAgN4TXgEAAOg94RUAAIDeE14BAADoPeEVAACA3hNeAQAA6D3hFQAAgN6bPcxKVfW4JD9rrd1cVZsm+fMk9yd5Z2vtzuksEAAYzsKjzh51Catl8Yn7j7oEANYiw468fiLJnO79u5Lsm+RpST44DTUBAADAAww18ppkYWvtx1VVSV6S5HFJ7kpy9bRVBgAAAJ1hw+vdVbVZBqH12tba0qqanWTD6SsNAAAABoYNr/+c5KtJNkvyD13bk2LkFQAAgBkwVHhtrb2xqp6f5N7W2te65vuTvHHaKgMAAIDOUBM2VdV7WmtfGhNc01q7MMmLp60yAAAA6Aw72/DLJmk/bIrqAAAAgEmt9LLhqnrF8vXGvF9ulyRLp6UqAAAAGGNV97wuH1ndIA8cZW1Jbk7yx9NRFAAAAIy10vDaWnt2klTVO1prfzkzJQEAAMADDTvb8F8mSVVtnWTTccuumoa6AAAAYIWhwmtVvSDJKUm2G7eoJZk11UUBAADAWMPONvy+JMcl2aS1tt6Yl+AKAADAtBtq5DXJI5N8sLXWprMYAAAAmMiwI68fTvLy6SwEAAAAJjPsyOvTkhxZVUcluWnsgtbavlNeFQAAAIwxbHj9UPcCAACAGTfso3I+Ot2FAAAAwGQmDa9VdVhr7ePd+1dMtl5r7ZTpKAwAAACWW9nI6yFJPt69P2ySdVoGz39dqao6JckBSX7aWnt817Zlkn9JsjDJ4iR/0Fr7+VBVAwAA8LAyaXhtrf32mPfPXsPjnJrkH5J8bEzbUUm+0lo7sZsI6qgkb17D4wAAALAOGnbCplTVI5O8KMkOSZYk+dywI6WttfOrauG45gOT7Ne9/2iScyO8AgAAMIGhnvNaVU9P8pMkr02yZ5LXJPlJ1/5QbdNau7F7f1OSbdZgXwAAAKzDhh15/fskf9paO2N5Q1UdlOQ9SZ6ypkW01lpVtcmWV9XhSQ5Pkvnz56/p4QAAAFjLDDXymmS3JGeOa/tUkkevwbFvrqrtkqT786eTrdhaO7m1tqi1tmjevHlrcEgAAADWRsOG1yuSHDyu7fczuJT4ofq3JH/cvf/jJJ9dg30BAACwDhv2suE3JPl8VR2Z5JoMHm+zawaPv1mlqvpEBpMzza2q65O8LcmJSc6sqld2+/yD1SkcAACAh4+hwmtr7ZtV9agk+yfZPsnnkpzTWrt1yO0PmWTRc4eqEgAAgIe1oR+V01r7eVV9LYPwesOwwRUAAADW1LCPyplfVV9PsjjJ2UkWV9XXq2rBdBYHAAAAyfATNn00yUVJ5rTWtk7yyCQXdu0AAAAwrYa9bPjJSZ7fWrs3SVpry6rqzUl+Nm2VAQAAQGfYkddvJdl7XNuiJBdMbTkAAADwYMOOvP4kyTlVdXaS65LslOS3k/xzVb19+UqttbdOfYkAAAA83A0bXjdMclb3fuskv0ry6SQbZRBkk6RNbWkAAAAwMOxzXl8+3YUAAADAZIa95xUAAABGRngFAACg94RXAAAAem/S8FpV7xzz/jkzUw4AAAA82MpGXg8f8/4z01wHAAAATGplsw1/v6o+leTSJI8Y+zzXsTzbFQAAgOm2svD60gxGXxckqfzP81zH8mxXAAAApt2k4bW19tMk70iSqprtWa8AAACMyspGXldorb28qh6Z5EVJdkiyJMnnW2u3TmdxAAAAkAz5qJyqenqSnyR5bZI9k7wmyZVdOwAAAEyroUZek/x9kj9trZ2xvKGqDkryniRPmYa6AAAAYIWhRl6T7JbkzHFtn0ry6KktBwAAAB5s2PB6RZKDx7X9fgaXEgMAAMC0Gvay4Tck+XxVHZnkmiQLk+ya5IDpKQsAAAD+x7CzDX+zqh6VZP8k2yf5XJJzzDYMAADATBh25DWttZ8nOW0aawEAAIAJDXvPKwAAAIyM8AoAAEDvDRVeq0rIBQAAYGRWGUqralaSO6rqETNQDwAAADzIKsNra+3XSS5PstX0lwMAAAAPNuxsw6dn8JzXdye5PklbvqC19tXpKAwAAACWGza8/kn357Hj2luSXaasGgAAAJjAUOG1tbbzdBcCAAAAkxl6FuGqWr+qnlVVB3WfN6mqTaavNAAAABgY9lE5/yuDSZv+KcmHu+bfSHLKNNUFAAAAKww78vr+JG9trT02yb1d23lJnjktVQEAAMAYw4bXPZKc1r1vSdJauyPJRtNRFAAAAIw1bHhdnOTJYxuqau8kV051QQAAADDesI/K+askZ1fVB5JsUFVHJ3ltkldPW2UAAADQGWrktbX2+SQvTDIvg3tdFyR5SWvtS9NYGwAAACQZfuQ1rbXvJfnTaawFAAAAJjTso3I2qKq3V9UVVXVH9+dxVbXhmhZQVW+sqkuq6odV9Ymp2CcAAADrltV5VM5zkhyZ5Cndn/sled+aHLyqduj2tai19vgks5IcvCb7BAAAYN0z7GXDv5PkUa2127rPl1bVtzOYbfgVU1DDRlV1b5KNk9ywhvsDAABgHTPsyOtNGQTLsTZKcuOaHLy1tiTJu5Jc2+3rdpNAAQAAMN6kI69V9ZwxHz+e5AtV9d4k1yfZKcn/SfKxNTl4VT0yyYFJdk5yW5JPVtWhrbXTxq13eJLDk2T+/PlrckgAAADWQiu7bPjDE7QdM+7za5L8zRoc/3lJrm6t3ZIkVXVWkmckeUB4ba2dnOTkJFm0aFFbg+MBAACwFpo0vLbWdp6B41+b5GlVtXGSu5I8N8mFM3BcAAAA1iLD3vM6LVpr307yqSTfTfLfXT0nj7ImAAAA+meo2Yar6glJTkqyV5JNlzcnaa21DdakgNba25K8bU32AQAAwLpt2EflfCLJv2bwTNa7pq8cAAAAeLBhw+u2Sd7aWjNZEgAAADNu2HteP5rkD6ezEAAAAJjMsCOvJya5oKqOSXLz2AWttedMvAkAAABMjWHD66eSXJ3k03HPKwAAADNs2PC6V5KtWmv3TGMtAAAAMKFh73n9epLHTWchAAAAMJlhR16vTvKlqvp0HnzP61unvCoAAAAYY9jwunGSs5NskGSn6SsHAAAAHmyo8Npae/l0FwIAAACTGSq8VtUuky1rrV01deUAAADAgw172fCVSVqSGtPWuj9nTWlFAAAAMM6wlw0/YFbiqto2ydsymIUYAAAAptWwj8p5gNbaTUnekOSEKa0GAAAAJvCQwmvnMRnMQgwAAADTatgJm76e/7nHNRmE1j2SvH06igIAAICxhp2w6UPjPt+R5PuttSumuB4AAAB4kGEnbProdBcCAAAAkxn2suENkrwsyV5JNh27rLX2R1NeFQAAAIwx7GXDH03yhCSfS3Lz9JUDAAAADzZseH1hkp1ba7dNYy0AAAAwoWEflXNtkkdMZyEAAAAwmWFHXj+W5LNV9e6Mu2y4tfbVKa8KAAAAxhg2vB7R/Xn8uPaWZJepKwcAAAAebNhH5ew83YUAAADAZIa95xUAAABGRngFAACg94RXAAAAek94BQAAoPeEVwAAAHpPeAUAAKD3hFcAAAB6T3gFAACg94RXAAAAek94BQAAoPeEVwAAAHpPeAUAAKD3hFcAAAB6T3gFAACg94RXAAAAem/k4bWq5lTVp6rqR1V1WVU9fdQ1AQAA0C+zR11Akncn+UJr7aVVtUGSjUddEAAAAP0y0vBaVVsk2TfJy5KktXZPkntGWRMAAAD9M+rLhndOckuSj1TV96rqQ1W1yYhrAgAAoGdGHV5nJ3lSkve31p6Y5I4kR41fqaoOr6oLq+rCW265ZaZrBAAAYMRGHV6vT3J9a+3b3edPZRBmH6C1dnJrbVFrbdG8efNmtEAAAABGb6ThtbV2U5LrquoxXdNzk1w6wpIAAADooT7MNvy6JKd3Mw1fleTlI64HAACAnhl5eG2tXZxk0ajrAAAAoL9Gfc8rAAAArJLwCgAAQO8JrwAAAPSe8AoAAEDvCa8AAAD0nvAKAABA7wmvAAAA9J7wCgAAQO8JrwAAAPSe8AoAAEDvCa8AAAD0nvAKAABA7wmvAAAA9J7wCgAAQO8JrwAAAPSe8AoAAEDvCa8AAAD0nvAKAABA7wmvAAAA9N7sURcAwBo6dotRV9Bfx94+6gpYiYVHnT3qElbL4hP3H3UJAA9rRl4BAADoPeEVAACA3hNeAQAA6D3hFQAAgN4TXgEAAOg94RUAAIDeE14BAADoPeEVAACA3hNeAQAA6D3hFQAAgN4TXgEAAOg94RUAAIDeE14BAADoPeEVAACA3hNeAQAA6D3hFQAAgN4TXgEAAOg94RUAAIDeE14BAADoPeEVAACA3utFeK2qWVX1var6/KhrAQAAoH96EV6TvD7JZaMuAgAAgH4aeXitqh2T7J/kQ6OuBQAAgH4aeXhN8vdJ/iLJ/ZOtUFWHV9WFVXXhLbfcMmOFAQAA0A8jDa9VdUCSn7bWLlrZeq21k1tri1pri+bNmzdD1QEAANAXox553SfJi6tqcZIzkjynqk4bbUkAAAD0zUjDa2vt6Nbajq21hUkOTvLV1tqho6wJAACA/hn1yCsAAACs0uxRF7Bca+3cJOeOuAwAAAB6yMgrAAAAvSe8AgAA0HvCKwAAAL0nvAIAANB7wisAAAC9J7wCAADQe8IrAAAAvSe8AgAA0HvCKwAAAL0nvAIAANB7wisAAAC9J7wCAADQe8IrAAAAvSe8AgAA0HvCKwAAAL0nvAIAANB7wisAAAC9J7wCAADQe8IrAAAAvTd71AUArNKxW4y6AoC1zsKjzh51Ceu0xSfuP+oS4GHHyCsAAAC9J7wCAADQe8IrAAAAvSe8AgAA0HvCKwAAAL0nvAIAANB7wisAAAC9J7wCAADQe8IrAAAAvSe8AgAA0HvCKwAAAL0nvAIAANB7wisAAAC9J7wCAADQe8IrAAAAvSe8AgAA0HvCKwAAAL0nvAIAANB7wisAAAC9N9LwWlU7VdXXqurSqrqkql4/ynoAAADop9kjPv59Sf6stfbdqtosyUVV9eXW2qUjrgsAAIAeGenIa2vtxtbad7v3v0xyWZIdRlkTAAAA/dObe16ramGSJyb59ohLAQAAoGdGfdlwkqSqNk3yr0ne0Fr7xQTLD09yeJLMnz9/hqt7CI7dYtQV9Next4+6AgCAh52FR5096hKGtvjE/UddAj018pHXqlo/g+B6emvtrInWaa2d3Fpb1FpbNG/evJktEAAAgJEb9WzDleTDSS5rrf3dKGsBAACgv0Y98rpPksOSPKeqLu5evz3imgAAAOiZkd7z2lr7zyQ1yhoAAADov1GPvAIAAMAqCa8AAAD0nvAKAABA7wmvAAAA9J7wCgAAQO8JrwAAAPSe8AoAAEDvCa8AAAD0nvAKAABA7wmvAAAA9J7wCgAAQO8JrwAAAPSe8AoAAEDvCa8AAAD0nvAKAABA7wmvAAAA9J7wCgAAQO8JrwAAAPSe8AoAAEDvzR51AQAAa4OFR5096hKAHlrbvhsWn7j/qEt4yIy8AgAA0HvCKwAAAL0nvAIAANB7wisAAAC9J7wCAADQe8IrAAAAvSe8AgAA0HvCKwAAAL0nvAIAANB7wisAAAC9J7wCAADQe8IrAAAAvSe8AgAA0HvCKwAAAL0nvAIAANB7wisAAAC9J7wCAADQe8IrAAAAvSe8AgAA0HvCKwAAAL038vBaVS+sqh9X1ZVVddSo6wEAAKB/Rhpeq2pWkn9M8ltJHpfkkKp63ChrAgAAoH9GPfK6d5IrW2tXtdbuSXJGkgNHXBMAAAA9M+rwukOS68Z8vr5rAwAAgBWqtTa6g1e9NMkLW2uv6j4fluSprbUjxq13eJLDu4+PSfLjNTz03CRL13AfrHv0C8bTJxhPn2A8fYLx9AnG0ydW34LW2rzxjbNHUckYS5LsNObzjl3bA7TWTk5y8lQdtKoubK0tmqr9sW7QLxhPn2A8fYLx9AnG0ycYT5+YOqO+bPi/kuxaVTtX1QZJDk7ybyOuCQAAgJ4Z6chra+2+qjoiyReTzEpySmvtklHWBAAAQP+M+rLhtNbOSXLODB92yi5BZp2iXzCePsF4+gTj6ROMp08wnj4xRUY6YRMAAAAMY9T3vAIAAMAqCa8AAAD03joZXqtqy6r6dFXdUVXXVNUfrmTdZ1fV16rq9qpaPMHyxVV1V1Ut615fmtbimTZT3C8WdsvvrKofVdXzprV4psVq9omqqr+pqp91r7+pqhqzvHX7Wf5d8aGZOQvW1LD9YIg+sFdVXdR9L1xUVXvN2EkwpaawT/heWEesRp/w+8PDxBT2CVljNayT4TXJPya5J8k2Sf53kvdX1R6TrHtHklOS/PlK9vei1tqm3ev5U1sqM2gq+8UnknwvyVZJ3pLkU1X1oAcp03ur0ycOT/I7SZ6QZM8kL0rymnHrPGHMd8WrpqdkpsGw/WDSPlCDx719NslpSR6Z5KNJPtu1s/ZZ4z4xhu+FdcOwfcLvDw8fU9UnElljaOvchE1VtUmSnyd5fGvt8q7t40mWtNaOWsl2z0vyodbawnHti5O8qrX2H9NWNNNuKvtFVe2W5L+TzG2t/bJr+3qS01trH5i+s2AqrW6fqKpvJjm1tXZy9/mVSV7dWnta97kl2bW1duVMnQNrbnX6wcr6QFU9P8lHkuzYuv+xVtW1SQ5vrX1h5s6INTVVfaL77HthHfBQfofw+8O6bar6RNe+OLLG0NbFkdfdkty3vCN1vp9kstGUYZxeVbdU1Zeq6glrVh4jMpX9Yo8kVy3/H88a7ovRWd0+sUe3fGXrnl9VN1XVWVW1cMoqZTqtTj9YWR/YI8kPlgfXzg8m2Q/9NlV9YjnfC2u/qfodwu8P646pzhuyxpDWxfC6aZJfjGu7PclmD3F//zvJwiQLknwtyReras5DLY6Rmcp+sWm37VTsi9FZ3T4x/ud+e5JNx9zf9hsZfFc8NskNST5fVSN/ljartDr9YGV9wPfCumOq+kTie2FdMVW/Q/ieWHdM5e+VssZqWOvCa1Wd202AMNHrP5MsS7L5uM02T/LLB+9t1Vpr32it3dVau7O1dkKS25I8a41Ogik3w/1iSvsY02Ma+sT49TdPsmz5SFtr7fzW2j2ttduSvD7Jzkl2n8pzYlqsTj9YWR/wvbDumKo+4Xth3TFV/337nlh3TNnPUtZYPWtdeG2t7ddaq0lez0xyeZLZVbXrmM2ekOSSqSohSa1yLWbUDPeLS5LsUlVj/3VtKvsYU2Aa+sQl3fJh1k18V6wtVqcfrKwPXJJkzzEjbslgAh/fC2ufqeoTE/G9sHaaqt8h/P6w7pjOvOF7YiXWuvC6Kq21O5KcleTtVbVJVe2T5MAkH59o/apar6o2TLL+4GNtuHx2yKqaX1X7VNUGXfufJ5mb5BszczZMlansF939DRcneVvX/rsZ/JL6rzNwKkyR1e0TST6W5E1VtUNVbZ/kz5KcmiRVtUcNHpMyq6o2TfJ/kyxJctl0nwdrZjX7waR9IMm5SX6d5MiqekRVHdG1f3U662fqTVWf8L2w7lidPuH3h4eHqeoTssZD0Fpb515JtkzymQympr42yR+OWfasDC7pWf55vwz+hWPs69xu2R4ZTLhxR5KfJflKkkWjPj+v0faLbvnCDH5ZvSvJj5M8b9Tn5zXtfaKS/G2SW7vX3+Z/Zmx/TtcP7kjy026fu476/LzWrB+sTh/olj8xyUXd98J3kzxx1OfmNbo+4Xth3XqtRp/w+8PD5DUVfSKyxmq/1rlH5QAAALDuWecuGwYAAGDdI7wCAADQe8IrAAAAvSe8AgAA0HvCKwAAAL0nvAIAANB7wisAD2tVdUlV7Tfkuo+pqour6pdVdWRVnVpV75jeCgGAJJk96gIAYJRaa3usxup/keRrrbW9kqSqTp2OmgCABzPyCgDDW5DkklEXMSpV5R+9ARgZ4RWAh7WqWlxVz+veH1tVZ1bVx7pLgy+pqkXdsq8meXaSf6iqZVW127j9vKyq/nNcW6uqR3fvH1FV76qqa6vq5qr6QFVtNGbdA7tLkn9RVT+pqhd27VtU1Yer6saqWlJV76iqWZOcy95VdWG3j5ur6u/GLHtmVX2zqm6rquuq6mVj9v+xqrqlqq6pqr+sqvXGnNM3quqkqvpZkmNXdR4AMF2EVwB4oBcnOSPJnCT/luQfkqS19pwkX09yRGtt09ba5au53xOT7JZkrySPTrJDkrcmg9CZ5GNJ/rw77r5JFnfbnZrkvm6bJyZ5fpJXTXKMdyd5d2tt8ySPSnJmt/8FSf49yXuTzOtquLjb5r1JtkiyS5LfSPJHSV4+Zp9PTXJVkm2S/PXKzgMAppPwCgAP9J+ttXNaa79O8vEkT1jTHVZVJTk8yRtba7e21n6Z5PgkB3ervDLJKa21L7fW7m+tLWmt/aiqtkny20ne0Fq7o7X20yQnjdluvHuTPLqq5rbWlrXWvtW1/2GS/2itfaK1dm9r7WettYu7EdyDkxzdWvtla21xkv+b5LAx+7yhtfbe1tp9Se5exXkAwLRx7woAPNBNY97fmWTDqprdhbeHal6SjZNcNMixSZJKsvzy352SnDPBdguSrJ/kxjHbrZfkukmO88okb0/yo6q6Osn/31r7fLf/n0yw/txu/9eMabsmg9HU5cYea1XnAQDTRngFgKlxRwbBLklSVduOWbY0yV1J9mitLZlg2+syuMx3ovZfJZk7THhurV2R5JDuntWXJPlUVW3V7WfvCTZZmsFo7YIkl3Zt85OMrbGtxnkAwLRx2TAATI3vJ9mjqvaqqg2THLt8QWvt/iT/lOSkqto6Sapqh6p6QbfKh5O8vKqeW1Xrdcse21q7McmXkvzfqtq8W/aoqvqNiQqoqkOral53vNu65vuTnJ7keVX1B1U1u6q2qqq9ukujz0zy11W1WXdv7JuSnDbR/oc4DwCYNsIrAEyBbgKntyf5jyRXJPnPcau8OcmVSb5VVb/o1ntMt+13Mpgk6aQktyc5L4PR0GQwgdIGGYyM/jzJp5JsN0kZL0xySVUty2DypoNba3e11q7N4N7ZP0tyawaTNS2/l/d1GYwaX9XV/M9JTlnJqU56HgAwnaq1tuq1AAAAYISMvAIAANB7wisAAAC9J7wCAADQe8IrAAAAvSe8AgAA0HvCKwAAAL0nvAIAANB7wisAAAC9J7wCAADQe/8PgUdkZZxepH4AAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -501,8 +500,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average influence of corrupted points: -0.05309211\n", - "Average influence of other points: 0.03483218\n" + "Average influence of corrupted points: -0.053527612\n", + "Average influence of other points: 0.034987032\n" ] } ], @@ -542,7 +541,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b2a154955e3343f3b9fd241485eeb792", + "model_id": "3558af103c304e5a8ff3616a0989736a", "version_major": 2, "version_minor": 0 }, @@ -556,7 +555,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8e9f266c82bf4e8995e5210b2737ab5f", + "model_id": "052b7b08f90d425bacf0eadc88ace35a", "version_major": 2, "version_minor": 0 }, @@ -570,7 +569,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "13d32b5e25bc4921b9dc58123a751fc8", + "model_id": "f63bb46d1c7343348ed06e91058ce3c7", "version_major": 2, "version_minor": 0 }, @@ -602,7 +601,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -650,7 +649,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a538c4f868774d3fa1fa69b006ce4acd", + "model_id": "94839462e31841d6a1531cd173dfa338", "version_major": 2, "version_minor": 0 }, @@ -664,7 +663,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9363249c4aff49cda4d1c486b1ece9a9", + "model_id": "b34a60745e114bc68e112bcd9e9aa8b9", "version_major": 2, "version_minor": 0 }, @@ -678,7 +677,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8e749eb0b8634e039b4f0848564188a2", + "model_id": "2033ef6c05d94db8a8654584a9c31b58", "version_major": 2, "version_minor": 0 }, @@ -692,7 +691,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b91b298c6cde4c3c9d6ed3fdc52de194", + "model_id": "31f470a77f0348c6a2959b951c9ca9e8", "version_major": 2, "version_minor": 0 }, @@ -735,7 +734,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Percentage error of cg over direct method:2.751033605363773e-05 %\n" + "Percentage error of cg over direct method:3.449632117735746e-05 %\n" ] } ], diff --git a/notebooks/support/torch.py b/notebooks/support/torch.py index b2ee6fedc..b9779c5b0 100644 --- a/notebooks/support/torch.py +++ b/notebooks/support/torch.py @@ -10,7 +10,7 @@ import torch.nn as nn from torch.optim import Adam, Optimizer from torch.optim.lr_scheduler import _LRScheduler -from torch.utils.data import DataLoader, TensorDataset +from torch.utils.data import DataLoader from torchvision.models import ResNet18_Weights, resnet18 from pydvl.influence.frameworks import as_tensor @@ -90,13 +90,12 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: def fit_torch_model( model: nn.Module, - train_data: DataLoader, + training_data: DataLoader, val_data: DataLoader, loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], optimizer: Optimizer, scheduler: Optional[_LRScheduler] = None, num_epochs: int = 1, - batch_size: int = 64, progress: bool = True, ) -> Losses: """ @@ -104,12 +103,12 @@ def fit_torch_model( Represents a simple machine learning loop, iterating over a number of epochs, sampling data with a certain batch size, calculating gradients and updating the parameters through a loss function. - :param x: Matrix of shape [NxD] representing the features x_i. - :param y: Matrix of shape [NxK] representing the prediction targets y_i. + :param model: A pytorch model. + :param training_data: A pytorch DataLoader with the training data. + :param val_data: A pytorch DataLoader with the validation data. :param optimizer: Select either ADAM or ADAM_W. :param scheduler: A pytorch scheduler. If None, no scheduler is used. :param num_epochs: Number of epochs to repeat training. - :param batch_size: Batch size to use in training. :param progress: True, iff progress shall be printed. """ train_loss = [] @@ -117,7 +116,7 @@ def fit_torch_model( for epoch in maybe_progress(range(num_epochs), progress, desc="Model fitting"): batch_loss = [] - for train_batch in train_data: + for train_batch in training_data: batch_x, batch_y = train_batch pred_y = model(batch_x) loss_value = loss(torch.squeeze(pred_y), torch.squeeze(batch_y)) @@ -130,14 +129,21 @@ def fit_torch_model( if scheduler: scheduler.step() - x_val, y_val = next(iter(val_data)) - pred_val = model(x_val) - epoch_val_loss = loss(torch.squeeze(pred_val), torch.squeeze(y_val)).item() + with torch.no_grad(): + batch_val_loss = [] + for val_batch in val_data: + batch_x, batch_y = val_batch + pred_y = model(batch_x) + batch_val_loss.append( + loss(torch.squeeze(pred_y), torch.squeeze(batch_y)).item() + ) + mean_epoch_train_loss = np.mean(batch_loss) - val_loss.append(epoch_val_loss) + mean_epoch_val_loss = np.mean(batch_val_loss) train_loss.append(mean_epoch_train_loss) + val_loss.append(mean_epoch_val_loss) logger.info( - f"Epoch: {epoch} ---> Training loss: {mean_epoch_train_loss}, Validation loss: {epoch_val_loss}" + f"Epoch: {epoch} ---> Training loss: {mean_epoch_train_loss}, Validation loss: {mean_epoch_val_loss}" ) return Losses(train_loss, val_loss) @@ -168,17 +174,15 @@ def __init__( name: str, model: nn.Module, loss: torch.nn.modules.loss._Loss, - train_x: torch.Tensor, - train_y: torch.Tensor, - val_x: torch.Tensor, - val_y: torch.Tensor, + train_data: DataLoader, + val_data: DataLoader, data_dir: Path, ): self.name = name self.model = model self.loss = loss - self.train_x, self.train_y = as_tensor(train_x), as_tensor(train_y) - self.val_x, self.val_y = as_tensor(val_x), as_tensor(val_y) + self.train_data = train_data + self.val_data = val_data self.data_dir = data_dir os.makedirs(self.data_dir, exist_ok=True) @@ -186,7 +190,6 @@ def train( self, n_epochs: int, lr: float = 0.001, - batch_size: int = 1000, use_cache: bool = True, ) -> Losses: """ @@ -204,14 +207,11 @@ def train( losses = fit_torch_model( model=self.model, - x_train=self.train_x, - y_train=self.train_y, - x_val=self.val_x, - y_val=self.val_y, + training_data=self.train_data, + val_data=self.val_data, loss=self.loss, optimizer=optimizer, num_epochs=n_epochs, - batch_size=batch_size, ) if use_cache: self.save(losses) diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 8cc655611..feece56ba 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -164,8 +164,8 @@ def _compute_influences_pert( def compute_influences( differentiable_model: TwiceDifferentiable[TensorType, ModelType], training_data: DataLoaderType, - input_data: Optional[DataLoaderType] = None, test_data: Optional[DataLoaderType] = None, + input_data: Optional[DataLoaderType] = None, progress: bool = False, inversion_method: InversionMethod = InversionMethod.Direct, inversion_method_kwargs: Dict[str, Any] = {}, @@ -179,11 +179,12 @@ def compute_influences( influences over the complete input_data set. :param differentiable_model: A model wrapped with its loss in TwiceDifferentiable. - :param training_data: data loader with the training data - :param input_data: data loader with the samples to calculate the influences - for. If None, the samples in training_data are used. + :param training_data: data loader with the training data, used to calculate + the hessian of the model loss. :param test_data: data loader with the test samples. If None, the samples in training_data are used. + :param input_data: data loader with the samples to calculate the influences + of. If None, the samples in training_data are used. :param progress: whether to display progress bars. :param inversion_method: Set the inversion method to a specific one, can be 'direct' for direct inversion (and explicit construction of the Hessian) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 33ec20fc9..bf1ad0208 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -77,51 +77,29 @@ def analytical_linear_influences( return result -INFLUENCE_TEST_CONDITION_NUMBERS: List[int] = [3] -INFLUENCE_TRAINING_SET_SIZE: List[int] = [50, 30] -INFLUENCE_TEST_SET_SIZE: List[int] = [20] -INFLUENCE_DIMENSIONS: List[Tuple[int, int]] = [ - (3, 20), -] -HESSIAN_REGULARIZATION: List[float] = [0, 1] - - -test_cases = list( - itertools.product( - INFLUENCE_TRAINING_SET_SIZE, - INFLUENCE_TEST_SET_SIZE, - InfluenceType, - INFLUENCE_DIMENSIONS, - INFLUENCE_TEST_CONDITION_NUMBERS, - HESSIAN_REGULARIZATION, - ) -) - - -def lmb_test_case_to_str(packed_i_test_case): - i, test_case = packed_i_test_case - return ( - f"Problem #{i} of dimension {test_case[3]} with train size {test_case[0]}, " - f"test size {test_case[1]}, if_type {test_case[2]}, condition number {test_case[4]} and lam {test_case[5]}." - ) - - -test_case_ids = list(map(lmb_test_case_to_str, zip(range(len(test_cases)), test_cases))) - - @pytest.mark.torch @pytest.mark.parametrize( - "train_set_size,test_set_size,influence_type,problem_dimension,condition_number, hessian_reg", - test_cases, - ids=test_case_ids, + "train_set_size", + [50, 30], + ids=["train_size=50", "train_size=30"], +) +@pytest.mark.parametrize( + "influence_type", + InfluenceType, + ids=[ifl.value for ifl in InfluenceType], +) +@pytest.mark.parametrize( + "hessian_reg", + [0, 1], + ids=["hessian_reg=0", "hessian_reg=1"], ) def test_influence_linear_model( train_set_size: int, - test_set_size: int, influence_type: InfluenceType, - problem_dimension: Tuple[int, int], - condition_number: float, hessian_reg: float, + test_set_size: int = 20, + problem_dimension: Tuple[int, int] = (3, 20), + condition_number: float = 3, ): A, b = linear_model(problem_dimension, condition_number) train_data, test_data = add_noise_to_linear_model( @@ -152,8 +130,8 @@ def test_influence_linear_model( direct_influences = compute_influences( TorchTwiceDifferentiable(linear_layer, loss), train_data_loader, - input_data, test_data_loader, + input_data, progress=True, influence_type=influence_type, inversion_method="direct", @@ -163,8 +141,8 @@ def test_influence_linear_model( cg_influences = compute_influences( TorchTwiceDifferentiable(linear_layer, loss), train_data_loader, - input_data, test_data_loader, + input_data, progress=True, influence_type=influence_type, inversion_method="cg", @@ -174,8 +152,8 @@ def test_influence_linear_model( lissa_influences = compute_influences( TorchTwiceDifferentiable(linear_layer, loss), train_data_loader, - input_data, test_data_loader, + input_data, progress=True, influence_type=influence_type, inversion_method="lissa", From 48d564c39832fd2a81a1158b5d30f67062ab8b13 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 6 Apr 2023 13:27:48 +0200 Subject: [PATCH 042/436] makes x requires grad optional --- .../frameworks/torch_differentiable.py | 6 ++++- .../frameworks/twice_differentiable.py | 7 +++++- src/pydvl/influence/general.py | 2 +- tests/influence/test_influences.py | 24 +++++++------------ 4 files changed, 20 insertions(+), 19 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 967df0489..fcb5eafa4 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -340,17 +340,21 @@ def grad( self, x: torch.Tensor, y: torch.Tensor, + x_requires_grad: bool = False, ) -> Tuple[torch.Tensor, torch.Tensor]: """ Calculates gradient of model parameters wrt the model parameters. :param x: A matrix [NxD] representing the features $x_i$. :param y: A matrix [NxK] representing the target values $y_i$. + :param x_requires_grad: If True, the input $x$ is marked as requiring + gradients. This is important for further differentiation on input + parameters. :returns: A tuple where: \ - first element is an array [P] with the gradients of the model. \ - second element is the input to the model as a grad parameters. \ This can be used for further differentiation. """ - x = as_tensor(x, warn=False).to(self.device).requires_grad_(True) + x = as_tensor(x, warn=False).to(self.device).requires_grad_(x_requires_grad) y = as_tensor(y, warn=False).to(self.device) params = [ diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index e30572fbc..e7854969f 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -44,11 +44,16 @@ def split_grad( """ pass - def grad(self, x: TensorType, y: TensorType) -> Tuple[TensorType, TensorType]: + def grad( + self, x: TensorType, y: TensorType, x_requires_grad: bool = False + ) -> Tuple[TensorType, TensorType]: """ Calculates gradient of model parameters wrt. the model parameters. :param x: A matrix representing the features $x_i$. :param y: A matrix representing the target values $y_i$. + :param x_requires_grad: If True, the input $x$ is marked as requiring + gradients. This is important for further differentiation on input + parameters. :returns: A tuple where: \ - first element is an array with the gradients of the model. \ - second element is the input to the model as a grad parameters. \ diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index feece56ba..aaa18246d 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -142,7 +142,7 @@ def _compute_influences_pert( desc="Batch Influence Perturbation", ): for i in range(len(x)): - grad_xy, tensor_x = model.grad(x[i : i + 1], y[i]) + grad_xy, tensor_x = model.grad(x[i : i + 1], y[i], x_requires_grad=True) perturbation_influences = mvp( grad_xy, influence_factors, diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index bf1ad0208..130229c0f 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -299,23 +299,15 @@ def test_influences_nn( assert not np.any(np.isnan(influences)) multiple_influences[inversion_method] = influences - if influence_type == InfluenceType.Up: - for infl_type, influences in multiple_influences.items(): - if infl_type == "direct": - continue - assert np.allclose( - multiple_influences["direct"], influences, rtol=1e-1 - ), f"Failed method {infl_type}" + for infl_type, influences in multiple_influences.items(): + if infl_type == "direct": + continue + assert np.allclose( + multiple_influences["direct"], influences, rtol=1e-1 + ), f"Failed method {infl_type}" + if influence_type == InfluenceType.Up: assert influences.shape == (test_data_len, data_len) - elif influence_type == InfluenceType.Perturbation: - for infl_type, influences in multiple_influences.items(): - if infl_type == "direct": - continue - assert np.allclose( - multiple_influences["direct"], influences, rtol=1e-1 - ), f"Failed method {infl_type}" + elif influence_type == InfluenceType.Perturbation: assert influences.shape == (test_data_len, data_len, *input_dim) - else: - raise ValueError(f"Unknown influence type: {influence_type}") # check that influences are not all constant assert not np.all(influences == influences.item(0)) From d8d4dac1ac01bfd5d96fa9ac428d6d5e51c2cf2c Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 6 Apr 2023 15:11:44 +0200 Subject: [PATCH 043/436] shuffling data loader before lissa --- .../frameworks/torch_differentiable.py | 34 +++++++++++------- src/pydvl/influence/general.py | 8 ++--- tests/influence/test_influences.py | 36 ++++++++----------- 3 files changed, 39 insertions(+), 39 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index fcb5eafa4..82af4a0a3 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -20,7 +20,7 @@ logger = logging.getLogger(__name__) -def flatten_gradient(grad): +def flatten_gradient(grad) -> torch.Tensor: """ Simple function to flatten a pyTorch gradient for use in subsequent calculation """ @@ -33,7 +33,7 @@ def solve_linear( b: torch.Tensor, lam: float = 0, progress: bool = True, -): +) -> torch.Tensor: """Given a model and training data, it uses conjugate gradient to calculate the inverse of the HVP. More precisely, it finds x s.t. $Hx = b$, with $H$ being the model hessian. @@ -66,7 +66,7 @@ def solve_batch_cg( lam: float = 0, inversion_method_kwargs: Dict[str, Any] = {}, progress: bool = True, -): +) -> torch.Tensor: """ Given a model and training data, it uses conjugate gradient to calculate the inverse of the HVP. More precisely, it finds x s.t. $Hx = b$, with $H$ being @@ -104,7 +104,7 @@ def solve_cg( rtol: float = 1e-7, atol: float = 1e-7, maxiter: Optional[int] = None, -): +) -> Tuple[torch.Tensor, Dict[str, Any]]: """Conjugate gradient solver for the Hessian vector product :param hvp: a Callable Hvp, operating with tensors of size N @@ -154,7 +154,8 @@ def solve_lissa( maxiter: int = 1000, damp: float = 0, scale: float = 10, -): + h0: Optional[torch.Tensor] = None, +) -> torch.Tensor: """ It uses LISSA, Linear time Stochastic Second-Order Algorithm, to calculate the inverse of the HVP. More precisely, it finds x s.t. $Hx = b$, with $H$ being @@ -171,23 +172,30 @@ def solve_lissa( :param training_data: A DataLoader containing the training data. :param b: :param lam: regularization of the hessian + :param progress: If True, display progress bars. :param maxiter: maximum number of iterations, :param damp: damping factor, defaults to 0 for no damping :param scale: scaling factor, defaults to 10 - :param progress: If True, display progress bars. + :param h0: initial guess for hvp :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$. """ - h_estimate = torch.clone(b) + if h0 is None: + h_estimate = torch.clone(b) + else: + h_estimate = h0 + shuffled_training_data = DataLoader( + training_data.dataset, training_data.batch_size, shuffle=True + ) for _ in maybe_progress(range(maxiter), progress, desc="Lissa"): - x, y = next(iter(training_data)) + x, y = next(iter(shuffled_training_data)) grad_xy, _ = model.grad(x, y) reg_hvp = lambda v: mvp(grad_xy, v, model.parameters()) + lam * v h_estimate = b + (1 - damp) * h_estimate - reg_hvp(h_estimate) / scale return h_estimate / scale -def as_tensor(a: Any, warn=True, **kwargs): +def as_tensor(a: Any, warn=True, **kwargs) -> torch.Tensor: """Converts an array into a torch tensor :param a: array to convert to tensor @@ -198,24 +206,24 @@ def as_tensor(a: Any, warn=True, **kwargs): return torch.as_tensor(a, **kwargs) -def stack(a: Sequence[torch.Tensor], **kwargs): +def stack(a: Sequence[torch.Tensor], **kwargs) -> torch.Tensor: """Stacks a sequence of tensors into a single torch tensor""" return torch.stack(a, **kwargs) -def cat(a: Sequence[torch.Tensor], **kwargs): +def cat(a: Sequence[torch.Tensor], **kwargs) -> torch.Tensor: """Concatenates a sequence of tensors into a single torch tensor""" return torch.cat(a, **kwargs) -def einsum(equation, *operands): +def einsum(equation, *operands) -> torch.Tensor: """Sums the product of the elements of the input :attr:`operands` along dimensions specified using a notation based on the Einstein summation convention. """ return torch.einsum(equation, *operands) -def identity_tensor(dim: int): +def identity_tensor(dim: int) -> torch.Tensor: return torch.eye(dim, dim) diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index aaa18246d..1a12525b7 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -80,7 +80,7 @@ def compute_influence_factors( ) -def _compute_influences_up( +def compute_influences_up( model: TwiceDifferentiable[TensorType, ModelType], input_data: DataLoaderType, influence_factors: TensorType, @@ -112,7 +112,7 @@ def _compute_influences_up( return einsum("ta,va->tv", influence_factors, train_grads) -def _compute_influences_pert( +def compute_influences_pert( model: TwiceDifferentiable[TensorType, ModelType], input_data: DataLoaderType, influence_factors: TensorType, @@ -156,8 +156,8 @@ def _compute_influences_pert( influence_type_registry = { - InfluenceType.Up: _compute_influences_up, - InfluenceType.Perturbation: _compute_influences_pert, + InfluenceType.Up: compute_influences_up, + InfluenceType.Perturbation: compute_influences_pert, } diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 130229c0f..689dead87 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -201,7 +201,6 @@ def test_influence_linear_model( test_cases = { "conv3d_nn_up": [ conv3d_nn, - 10, (5, 3, 3, 3), 3, nn.MSELoss(), @@ -209,37 +208,33 @@ def test_influence_linear_model( ], "conv3d_nn_pert": [ conv3d_nn, - 10, (5, 3, 3, 3), 3, nn.SmoothL1Loss(), InfluenceType.Perturbation, ], - "conv_2d_nn_up": [conv2d_nn, 10, (5, 5, 5), 3, nn.MSELoss(), InfluenceType.Up], + "conv_2d_nn_up": [conv2d_nn, (5, 5, 5), 3, nn.MSELoss(), InfluenceType.Up], "conv_2d_nn_pert": [ conv2d_nn, - 10, (5, 5, 5), 3, - nn.MSELoss(), + nn.SmoothL1Loss(), InfluenceType.Perturbation, ], - "conv_1d_nn_up": [conv1d_nn, 10, (5, 3), 3, nn.MSELoss(), InfluenceType.Up], + "conv_1d_nn_up": [conv1d_nn, (5, 3), 3, nn.MSELoss(), InfluenceType.Up], "conv_1d_pert": [ conv1d_nn, - 10, (5, 3), 3, nn.SmoothL1Loss(), InfluenceType.Perturbation, ], - "simple_nn_up": [simple_nn_regr, 10, (10,), 1, nn.MSELoss(), InfluenceType.Up], + "simple_nn_up": [simple_nn_regr, (10,), 1, nn.MSELoss(), InfluenceType.Up], "simple_nn_pert": [ simple_nn_regr, - 10, (10,), 1, - nn.MSELoss(), + nn.SmoothL1Loss(), InfluenceType.Perturbation, ], } @@ -247,19 +242,20 @@ def test_influence_linear_model( @pytest.mark.torch @pytest.mark.parametrize( - "nn_architecture, data_len, input_dim, output_dim, loss, influence_type", + "nn_architecture, input_dim, output_dim, loss, influence_type", test_cases.values(), ids=test_cases.keys(), ) def test_influences_nn( nn_architecture: nn.Module, - data_len: int, input_dim: Tuple[int], output_dim: int, loss: nn.modules.loss._Loss, influence_type: InfluenceType, - hessian_reg: float = 100, + data_len: int = 20, + hessian_reg: float = 1000, test_data_len: int = 10, + batch_size: int = 10, ): x_train = torch.rand((data_len, *input_dim)) y_train = torch.rand((data_len, output_dim)) @@ -271,24 +267,20 @@ def test_influences_nn( "direct": {}, "cg": {}, "lissa": { - "maxiter": 10, - "scale": 100, + "maxiter": 100, + "scale": 10000, }, } - train_data_loader = DataLoader( - list(zip(x_train, y_train)), batch_size=10, shuffle=True - ) - input_data = DataLoader(list(zip(x_train, y_train)), batch_size=10) + train_data_loader = DataLoader(list(zip(x_train, y_train)), batch_size=batch_size) test_data_loader = DataLoader( list(zip(x_test, y_test)), - batch_size=10, + batch_size=batch_size, ) multiple_influences = {} for inversion_method in InversionMethod: influences = compute_influences( TorchTwiceDifferentiable(nn_architecture, loss), train_data_loader, - input_data, test_data_loader, progress=True, influence_type=influence_type, @@ -303,7 +295,7 @@ def test_influences_nn( if infl_type == "direct": continue assert np.allclose( - multiple_influences["direct"], influences, rtol=1e-1 + influences, multiple_influences["direct"], rtol=1e-1 ), f"Failed method {infl_type}" if influence_type == InfluenceType.Up: assert influences.shape == (test_data_len, data_len) From 3f385a6088f5f8fbd0fee920cdbdb65c0f869ecc Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 6 Apr 2023 15:20:08 +0200 Subject: [PATCH 044/436] cleanup a few more tests --- tests/influence/test_torch_differentiable.py | 59 ++++++-------------- 1 file changed, 16 insertions(+), 43 deletions(-) diff --git a/tests/influence/test_torch_differentiable.py b/tests/influence/test_torch_differentiable.py index 35b390404..3d09dd175 100644 --- a/tests/influence/test_torch_differentiable.py +++ b/tests/influence/test_torch_differentiable.py @@ -29,9 +29,6 @@ DATA_OUTPUT_NOISE: float = 0.01 -TEST_CONDITION_NUMBERS: List[int] = [5] -TEST_SET_SIZE: List[int] = [20] -TRAINING_SET_SIZE: List[int] = [50] PROBLEM_DIMENSIONS: List[Tuple[int, int]] = [ (2, 2), (5, 10), @@ -39,41 +36,17 @@ (10, 10), ] -test_cases_linear_regression_derivatives = list( - itertools.product( - TRAINING_SET_SIZE, - PROBLEM_DIMENSIONS, - TEST_CONDITION_NUMBERS, - ) -) - - -def lmb_correctness_test_case_to_str(packed_i_test_case): - i, test_case = packed_i_test_case - return f"Problem #{i} of dimension {test_case[1]} with train size {test_case[0]} and condition number {test_case[2]}" - - -correctness_test_case_ids = list( - map( - lmb_correctness_test_case_to_str, - zip( - range(len(test_cases_linear_regression_derivatives)), - test_cases_linear_regression_derivatives, - ), - ) -) - @pytest.mark.torch @pytest.mark.parametrize( - "train_set_size,problem_dimension,condition_number", - test_cases_linear_regression_derivatives, - ids=correctness_test_case_ids, + "problem_dimension", + PROBLEM_DIMENSIONS, + ids=[f"problem_dimension={dim}" for dim in PROBLEM_DIMENSIONS], ) def test_linear_grad( - train_set_size: int, problem_dimension: Tuple[int, int], - condition_number: float, + train_set_size: int = 50, + condition_number: float = 5, ): # some settings A, b = linear_model(problem_dimension, condition_number) @@ -98,14 +71,14 @@ def test_linear_grad( @pytest.mark.torch @pytest.mark.parametrize( - "train_set_size,problem_dimension,condition_number", - test_cases_linear_regression_derivatives, - ids=correctness_test_case_ids, + "problem_dimension", + PROBLEM_DIMENSIONS, + ids=[f"problem_dimension={dim}" for dim in PROBLEM_DIMENSIONS], ) def test_linear_hessian( - train_set_size: int, problem_dimension: Tuple[int, int], - condition_number: float, + train_set_size: int = 50, + condition_number: float = 5, ): # some settings A, b = linear_model(problem_dimension, condition_number) @@ -134,14 +107,14 @@ def test_linear_hessian( @pytest.mark.torch @pytest.mark.parametrize( - "train_set_size,problem_dimension,condition_number", - test_cases_linear_regression_derivatives, - ids=correctness_test_case_ids, + "problem_dimension", + PROBLEM_DIMENSIONS, + ids=[f"problem_dimension={dim}" for dim in PROBLEM_DIMENSIONS], ) def test_linear_mixed_derivative( - train_set_size: int, problem_dimension: Tuple[int, int], - condition_number: float, + train_set_size: int = 50, + condition_number: float = 5, ): # some settings A, b = linear_model(problem_dimension, condition_number) @@ -165,7 +138,7 @@ def test_linear_mixed_derivative( ) model_mvp = [] for i in range(len(train_x)): - grad_xy, tensor_x = mvp_model.grad(train_x[i], train_y[i]) + grad_xy, tensor_x = mvp_model.grad(train_x[i], train_y[i], x_requires_grad=True) model_mvp.append( mvp( grad_xy, From 7df43942db40c68a4daa9d424560b6c1b1fe6860 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 11 Apr 2023 12:49:37 +0200 Subject: [PATCH 045/436] add tests for lissa --- .../frameworks/torch_differentiable.py | 25 ++----- tests/influence/test_influences.py | 49 +++++++------ tests/influence/test_torch_differentiable.py | 73 ++++++++++++++----- 3 files changed, 87 insertions(+), 60 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 82af4a0a3..55dc1acfc 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -40,7 +40,7 @@ def solve_linear( :param model: A model wrapped in the TwiceDifferentiable interface. :param training_data: A DataLoader containing the training data. - :param b: + :param b: a vector or matrix :param lam: regularization of the hessian :param progress: If True, display progress bars. @@ -75,7 +75,7 @@ def solve_batch_cg( :param model: A model wrapped in the TwiceDifferentiable interface. :param training_data: A DataLoader containing the training data. - :param b: + :param b: a vector or matrix :param lam: regularization of the hessian :param inversion_method_kwargs: kwargs to pass to the inversion method :param progress: If True, display progress bars. @@ -170,7 +170,7 @@ def solve_lissa( :param model: A model wrapped in the TwiceDifferentiable interface. :param training_data: A DataLoader containing the training data. - :param b: + :param b: a vector or matrix :param lam: regularization of the hessian :param progress: If True, display progress bars. :param maxiter: maximum number of iterations, @@ -192,6 +192,8 @@ def solve_lissa( grad_xy, _ = model.grad(x, y) reg_hvp = lambda v: mvp(grad_xy, v, model.parameters()) + lam * v h_estimate = b + (1 - damp) * h_estimate - reg_hvp(h_estimate) / scale + if torch.isnan(h_estimate).any(): + raise RuntimeError("NaNs in h_estimate. Increase scale or damp.") return h_estimate / scale @@ -324,10 +326,6 @@ def split_grad( x = as_tensor(x, warn=False).to(self.device).unsqueeze(1) y = as_tensor(y, warn=False).to(self.device) - params = [ - param for param in self.model.parameters() if param.requires_grad == True - ] - grads = [] for i in maybe_progress(range(len(x)), progress, desc="Split Gradient"): grads.append( @@ -337,7 +335,7 @@ def split_grad( torch.squeeze(self.model(x[i])), torch.squeeze(y[i]), ), - params, + self.parameters(), ) ).detach() ) @@ -365,12 +363,8 @@ def grad( x = as_tensor(x, warn=False).to(self.device).requires_grad_(x_requires_grad) y = as_tensor(y, warn=False).to(self.device) - params = [ - param for param in self.model.parameters() if param.requires_grad == True - ] - loss_value = self.loss(torch.squeeze(self.model(x)), torch.squeeze(y)) - grad_f = torch.autograd.grad(loss_value, params, create_graph=True) + grad_f = torch.autograd.grad(loss_value, self.parameters(), create_graph=True) return flatten_gradient(grad_f), x def hessian( @@ -387,12 +381,9 @@ def hessian( x = x.to(self.device) y = y.to(self.device) grad_xy, _ = self.grad(x, y) - backprop_on = [ - param for param in self.model.parameters() if param.requires_grad == True - ] return mvp( grad_xy, torch.eye(self.num_params(), self.num_params()), - backprop_on, + self.parameters(), progress, ) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 689dead87..341c6d088 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -78,27 +78,22 @@ def analytical_linear_influences( @pytest.mark.torch -@pytest.mark.parametrize( - "train_set_size", - [50, 30], - ids=["train_size=50", "train_size=30"], -) @pytest.mark.parametrize( "influence_type", InfluenceType, ids=[ifl.value for ifl in InfluenceType], ) @pytest.mark.parametrize( - "hessian_reg", - [0, 1], - ids=["hessian_reg=0", "hessian_reg=1"], + "train_set_size", + [200], + ids=["train_set_size_200"], ) def test_influence_linear_model( - train_set_size: int, influence_type: InfluenceType, - hessian_reg: float, + train_set_size: int, + hessian_reg: float = 0.1, test_set_size: int = 20, - problem_dimension: Tuple[int, int] = (3, 20), + problem_dimension: Tuple[int, int] = (3, 15), condition_number: float = 3, ): A, b = linear_model(problem_dimension, condition_number) @@ -120,11 +115,11 @@ def test_influence_linear_model( hessian_regularization=hessian_reg, ) - train_data_loader = DataLoader(list(zip(*train_data)), batch_size=5, shuffle=True) - input_data = DataLoader(list(zip(*train_data)), batch_size=5) + train_data_loader = DataLoader(list(zip(*train_data)), batch_size=40, shuffle=True) + input_data = DataLoader(list(zip(*train_data)), batch_size=40) test_data_loader = DataLoader( list(zip(*test_data)), - batch_size=5, + batch_size=40, ) direct_influences = compute_influences( @@ -158,8 +153,8 @@ def test_influence_linear_model( influence_type=influence_type, inversion_method="lissa", inversion_method_kwargs={ - "maxiter": 1000, - "scale": 1, + "maxiter": 5000, + "scale": 100, }, hessian_regularization=hessian_reg, ).numpy() @@ -167,17 +162,23 @@ def test_influence_linear_model( assert np.logical_not(np.any(np.isnan(cg_influences))) assert np.allclose(direct_influences, analytical_influences, rtol=1e-7) assert np.allclose(cg_influences, analytical_influences, rtol=1e-1) - upper_quantile_mask = lissa_influences > np.quantile(lissa_influences, 0.7) + abs_influence = np.abs(lissa_influences) + upper_quantile_mask = abs_influence > np.quantile(abs_influence, 0.9) + import logging + + logging.info( + np.max( + ( + lissa_influences[upper_quantile_mask] + - analytical_influences[upper_quantile_mask] + ) + / analytical_influences[upper_quantile_mask] + ) + ) assert np.allclose( lissa_influences[upper_quantile_mask], analytical_influences[upper_quantile_mask], - rtol=1e-1, - ) - lower_quantile_mask = lissa_influences < np.quantile(lissa_influences, 0.3) - assert np.allclose( - lissa_influences[lower_quantile_mask], - analytical_influences[lower_quantile_mask], - rtol=1e-1, + rtol=0.1, ) diff --git a/tests/influence/test_torch_differentiable.py b/tests/influence/test_torch_differentiable.py index 3d09dd175..a09dc7e18 100644 --- a/tests/influence/test_torch_differentiable.py +++ b/tests/influence/test_torch_differentiable.py @@ -21,10 +21,14 @@ import torch import torch.nn.functional as F from torch import nn +from torch.utils.data import DataLoader from pydvl.influence.frameworks.torch_differentiable import ( TorchTwiceDifferentiable, mvp, + solve_batch_cg, + solve_linear, + solve_lissa, ) DATA_OUTPUT_NOISE: float = 0.01 @@ -37,6 +41,16 @@ ] +def linear_mvp_model(A, b): + output_dimension, input_dimension = tuple(A.shape) + model = nn.Linear(input_dimension, output_dimension) + model.eval() + model.weight.data = torch.as_tensor(A) + model.bias.data = torch.as_tensor(b) + loss = F.mse_loss + return TorchTwiceDifferentiable(model=model, loss=loss) + + @pytest.mark.torch @pytest.mark.parametrize( "problem_dimension", @@ -50,19 +64,14 @@ def test_linear_grad( ): # some settings A, b = linear_model(problem_dimension, condition_number) - output_dimension, input_dimension = tuple(A.shape) + _, input_dimension = tuple(A.shape) # generate datasets data_model = lambda x: np.random.normal(x @ A.T + b, DATA_OUTPUT_NOISE) train_x = np.random.uniform(size=[train_set_size, input_dimension]) train_y = data_model(train_x) - model = nn.Linear(input_dimension, output_dimension) - model.eval() - model.weight.data = torch.as_tensor(A) - model.bias.data = torch.as_tensor(b) - loss = F.mse_loss - mvp_model = TorchTwiceDifferentiable(model=model, loss=loss) + mvp_model = linear_mvp_model(A, b) train_grads_analytical = linear_derivative_analytical((A, b), train_x, train_y) train_grads_autograd = mvp_model.split_grad(train_x, train_y) @@ -88,12 +97,7 @@ def test_linear_hessian( data_model = lambda x: np.random.normal(x @ A.T + b, DATA_OUTPUT_NOISE) train_x = np.random.uniform(size=[train_set_size, input_dimension]) train_y = data_model(train_x) - model = nn.Linear(input_dimension, output_dimension) - model.eval() - model.weight.data = torch.as_tensor(A) - model.bias.data = torch.as_tensor(b) - loss = F.mse_loss - mvp_model = TorchTwiceDifferentiable(model=model, loss=loss) + mvp_model = linear_mvp_model(A, b) test_hessian_analytical = linear_hessian_analytical((A, b), train_x) grad_xy, _ = mvp_model.grad(train_x, train_y) @@ -124,12 +128,8 @@ def test_linear_mixed_derivative( data_model = lambda x: np.random.normal(x @ A.T + b, DATA_OUTPUT_NOISE) train_x = np.random.uniform(size=[train_set_size, input_dimension]) train_y = data_model(train_x) - model = nn.Linear(input_dimension, output_dimension) - model.eval() - model.weight.data = torch.as_tensor(A) - model.bias.data = torch.as_tensor(b) - loss = F.mse_loss - mvp_model = TorchTwiceDifferentiable(model=model, loss=loss) + + mvp_model = linear_mvp_model(A, b) test_derivative = linear_mixed_second_derivative_analytical( (A, b), @@ -148,3 +148,38 @@ def test_linear_mixed_derivative( ) estimated_derivative = np.stack(model_mvp, axis=0) assert np.allclose(test_derivative, estimated_derivative, rtol=1e-7) + + +REDUCED_PROBLEM_DIMENSIONS: List[Tuple[int, int]] = [(5, 10), (2, 5)] + + +@pytest.mark.torch +@pytest.mark.parametrize( + "problem_dimension", + REDUCED_PROBLEM_DIMENSIONS, + ids=[f"problem_dimension={dim}" for dim in REDUCED_PROBLEM_DIMENSIONS], +) +def test_inversion_methods( + problem_dimension: Tuple[int, int], + train_set_size: int = 50, + condition_number: float = 5, +): + # some settings + A, b = linear_model(problem_dimension, condition_number) + output_dimension, input_dimension = tuple(A.shape) + + # generate datasets + data_model = lambda x: np.random.normal(x @ A.T + b, DATA_OUTPUT_NOISE) + train_x = np.random.uniform(size=[train_set_size, input_dimension]) + train_y = data_model(train_x) + mvp_model = linear_mvp_model(A, b) + + train_data_loader = DataLoader(list(zip(train_x, train_y)), batch_size=128) + b = torch.rand(size=(10, mvp_model.num_params()), dtype=torch.float64) + + linear_inverse = solve_linear(mvp_model, train_data_loader, b) + linear_cg = solve_batch_cg(mvp_model, train_data_loader, b) + linear_lissa = solve_lissa(mvp_model, train_data_loader, b, maxiter=5000, scale=5) + + assert np.allclose(linear_inverse, linear_cg, rtol=1e-1) + assert np.allclose(linear_inverse, linear_lissa, rtol=1e-1) From bccc7d0987feb08053086e3336c23f3844bfd426 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 11 Apr 2023 16:21:32 +0200 Subject: [PATCH 046/436] log residuals in lissa solver --- notebooks/influence_synthetic.ipynb | 2 +- .../frameworks/torch_differentiable.py | 49 +++++++++++++------ tests/influence/test_influences.py | 6 ++- tests/influence/test_torch_differentiable.py | 4 +- 4 files changed, 41 insertions(+), 20 deletions(-) diff --git a/notebooks/influence_synthetic.ipynb b/notebooks/influence_synthetic.ipynb index 47e0dcefe..679a697fa 100644 --- a/notebooks/influence_synthetic.ipynb +++ b/notebooks/influence_synthetic.ipynb @@ -305,7 +305,7 @@ " shuffle=True,\n", ")\n", "\n", - "optimizer = AdamW(params=model.parameters(), lr=lr, weight_decay=weight_decay)\n", + "optimizer = AdamW(params=model.parameters, lr=lr, weight_decay=weight_decay)\n", "scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=num_epochs)\n", "losses = fit_torch_model(\n", " model=model,\n", diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 55dc1acfc..06aab02a9 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -54,7 +54,7 @@ def solve_linear( all_x = cat(all_x) all_y = cat(all_y) matrix = model.hessian(all_x, all_y, progress) + lam * identity_tensor( - model.num_params() + model.num_params ) return torch.linalg.solve(matrix, b.T).T @@ -64,7 +64,10 @@ def solve_batch_cg( training_data: DataLoader, b: torch.Tensor, lam: float = 0, - inversion_method_kwargs: Dict[str, Any] = {}, + x0: Optional[torch.Tensor] = None, + rtol: float = 1e-7, + atol: float = 1e-7, + maxiter: Optional[int] = None, progress: bool = True, ) -> torch.Tensor: """ @@ -77,7 +80,10 @@ def solve_batch_cg( :param training_data: A DataLoader containing the training data. :param b: a vector or matrix :param lam: regularization of the hessian - :param inversion_method_kwargs: kwargs to pass to the inversion method + :param x0: initial guess for hvp + :param rtol: maximum relative tolerance of result + :param atol: absolute tolerance of result + :param maxiter: maximum number of iterations. If None, defaults to 10*len(y) :param progress: If True, display progress bars. :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$. @@ -88,11 +94,13 @@ def solve_batch_cg( grad_xy, _ = model.grad(x, y) total_grad_xy += grad_xy * len(x) total_points += len(x) - backprop_on = model.parameters() - reg_hvp = lambda v: mvp(total_grad_xy / total_points, v, backprop_on) + lam * v + backprop_on = model.parameters + reg_hvp = lambda v: mvp( + total_grad_xy / total_points, v, backprop_on + ) + lam * v.type(torch.float64) batch_cg = torch.zeros_like(b) for idx, bi in enumerate(maybe_progress(b, progress, desc="Conjugate gradient")): - bi_cg, _ = solve_cg(reg_hvp, bi, **inversion_method_kwargs) + bi_cg, _ = solve_cg(reg_hvp, bi, x0, rtol, atol, maxiter) batch_cg[idx] = bi_cg return batch_cg @@ -123,7 +131,7 @@ def solve_cg( stopping_val = max([rtol**2 * y_norm, atol**2]) x = x0 - p = r = (b - hvp(x)).squeeze() + p = r = (b - hvp(x)).squeeze().type(torch.float64) gamma = torch.sum(torch.matmul(r, r)).item() optimal = False @@ -155,6 +163,7 @@ def solve_lissa( damp: float = 0, scale: float = 10, h0: Optional[torch.Tensor] = None, + rtol: float = 1e-4, ) -> torch.Tensor: """ It uses LISSA, Linear time Stochastic Second-Order Algorithm, to calculate the @@ -187,13 +196,21 @@ def solve_lissa( shuffled_training_data = DataLoader( training_data.dataset, training_data.batch_size, shuffle=True ) + lissa_step = lambda h: b + (1 - damp) * h - reg_hvp(h) / scale for _ in maybe_progress(range(maxiter), progress, desc="Lissa"): x, y = next(iter(shuffled_training_data)) grad_xy, _ = model.grad(x, y) - reg_hvp = lambda v: mvp(grad_xy, v, model.parameters()) + lam * v - h_estimate = b + (1 - damp) * h_estimate - reg_hvp(h_estimate) / scale + reg_hvp = lambda v: mvp(grad_xy, v, model.parameters) + lam * v + residual = lissa_step(h_estimate) - h_estimate + h_estimate += residual if torch.isnan(h_estimate).any(): raise RuntimeError("NaNs in h_estimate. Increase scale or damp.") + max_residual = torch.max(torch.abs(residual / h_estimate)) + if max_residual < rtol: + break + logger.info( + f"Terminated Lissa with {max_residual*100:.2f} % max residual. Mean residual: {torch.mean(torch.abs(residual/h_estimate))*100:.5f} %" + ) return h_estimate / scale @@ -266,7 +283,7 @@ def mvp( flatten_gradient(autograd.grad(z[i], backprop_on, retain_graph=True)) ) mvp = torch.stack([grad.contiguous().view(-1) for grad in mvp]) - return mvp.detach() # type: ignore + return mvp.detach() class TorchTwiceDifferentiable(TwiceDifferentiable[torch.Tensor, nn.Module]): @@ -294,18 +311,20 @@ def __init__( self.loss = loss self.device = device + @property def parameters(self) -> List[torch.Tensor]: """Returns all the model parameters that require differentiating""" return [ param for param in self.model.parameters() if param.requires_grad == True ] + @property def num_params(self) -> int: """ Get number of parameters of model f. :returns: Number of parameters as integer. """ - return sum([np.prod(p.size()) for p in self.parameters()]) + return sum([np.prod(p.size()) for p in self.parameters]) def split_grad( self, @@ -335,7 +354,7 @@ def split_grad( torch.squeeze(self.model(x[i])), torch.squeeze(y[i]), ), - self.parameters(), + self.parameters, ) ).detach() ) @@ -364,7 +383,7 @@ def grad( y = as_tensor(y, warn=False).to(self.device) loss_value = self.loss(torch.squeeze(self.model(x)), torch.squeeze(y)) - grad_f = torch.autograd.grad(loss_value, self.parameters(), create_graph=True) + grad_f = torch.autograd.grad(loss_value, self.parameters, create_graph=True) return flatten_gradient(grad_f), x def hessian( @@ -383,7 +402,7 @@ def hessian( grad_xy, _ = self.grad(x, y) return mvp( grad_xy, - torch.eye(self.num_params(), self.num_params()), - self.parameters(), + torch.eye(self.num_params, self.num_params, device=self.device), + self.parameters, progress, ) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 341c6d088..2f2d8da7d 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -254,7 +254,7 @@ def test_influences_nn( loss: nn.modules.loss._Loss, influence_type: InfluenceType, data_len: int = 20, - hessian_reg: float = 1000, + hessian_reg: float = 1e3, test_data_len: int = 10, batch_size: int = 10, ): @@ -296,7 +296,9 @@ def test_influences_nn( if infl_type == "direct": continue assert np.allclose( - influences, multiple_influences["direct"], rtol=1e-1 + influences, + multiple_influences["direct"], + rtol=1e-1, ), f"Failed method {infl_type}" if influence_type == InfluenceType.Up: assert influences.shape == (test_data_len, data_len) diff --git a/tests/influence/test_torch_differentiable.py b/tests/influence/test_torch_differentiable.py index a09dc7e18..3c952ddab 100644 --- a/tests/influence/test_torch_differentiable.py +++ b/tests/influence/test_torch_differentiable.py @@ -104,7 +104,7 @@ def test_linear_hessian( estimated_hessian = mvp( grad_xy, np.eye((input_dimension + 1) * output_dimension), - mvp_model.parameters(), + mvp_model.parameters, ) assert np.allclose(test_hessian_analytical, estimated_hessian, rtol=1e-5) @@ -175,7 +175,7 @@ def test_inversion_methods( mvp_model = linear_mvp_model(A, b) train_data_loader = DataLoader(list(zip(train_x, train_y)), batch_size=128) - b = torch.rand(size=(10, mvp_model.num_params()), dtype=torch.float64) + b = torch.rand(size=(10, mvp_model.num_params), dtype=torch.float64) linear_inverse = solve_linear(mvp_model, train_data_loader, b) linear_cg = solve_batch_cg(mvp_model, train_data_loader, b) From 7327de85e8706f1f6e4259119ce6fdac028129cf Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 11 Apr 2023 16:26:44 +0200 Subject: [PATCH 047/436] fix typing --- .../influence/frameworks/torch_differentiable.py | 4 ++-- .../influence/frameworks/twice_differentiable.py | 2 ++ tests/influence/test_influences.py | 11 ----------- 3 files changed, 4 insertions(+), 13 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 06aab02a9..1ff051aa7 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -196,7 +196,7 @@ def solve_lissa( shuffled_training_data = DataLoader( training_data.dataset, training_data.batch_size, shuffle=True ) - lissa_step = lambda h: b + (1 - damp) * h - reg_hvp(h) / scale + lissa_step = lambda h: b + (1 - damp) * h - reg_hvp(h) / scale # type: ignore for _ in maybe_progress(range(maxiter), progress, desc="Lissa"): x, y = next(iter(shuffled_training_data)) grad_xy, _ = model.grad(x, y) @@ -283,7 +283,7 @@ def mvp( flatten_gradient(autograd.grad(z[i], backprop_on, retain_graph=True)) ) mvp = torch.stack([grad.contiguous().view(-1) for grad in mvp]) - return mvp.detach() + return mvp.detach() # type: ignore class TorchTwiceDifferentiable(TwiceDifferentiable[torch.Tensor, nn.Module]): diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index e7854969f..3b1b3fb14 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -17,10 +17,12 @@ def __init__( ): pass + @property def num_params(self) -> int: """Returns the number of parameters of the model""" pass + @property def parameters(self) -> List[TensorType]: """Returns all the model parameters that require differentiation""" pass diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 2f2d8da7d..f039874c2 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -164,17 +164,6 @@ def test_influence_linear_model( assert np.allclose(cg_influences, analytical_influences, rtol=1e-1) abs_influence = np.abs(lissa_influences) upper_quantile_mask = abs_influence > np.quantile(abs_influence, 0.9) - import logging - - logging.info( - np.max( - ( - lissa_influences[upper_quantile_mask] - - analytical_influences[upper_quantile_mask] - ) - / analytical_influences[upper_quantile_mask] - ) - ) assert np.allclose( lissa_influences[upper_quantile_mask], analytical_influences[upper_quantile_mask], From 041d5a2c7c2f958ed3c19fce6a62d55f2756c49a Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 11 Apr 2023 16:31:23 +0200 Subject: [PATCH 048/436] minor docstring changes --- .../frameworks/torch_differentiable.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 1ff051aa7..68d1952c4 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -34,8 +34,7 @@ def solve_linear( lam: float = 0, progress: bool = True, ) -> torch.Tensor: - """Given a model and training data, it uses conjugate gradient to calculate the - inverse of the HVP. More precisely, it finds x s.t. $Hx = b$, with $H$ being + """Given a model and training data, it finds x s.t. $Hx = b$, with $H$ being the model hessian. :param model: A model wrapped in the TwiceDifferentiable interface. @@ -45,7 +44,7 @@ def solve_linear( :param progress: If True, display progress bars. :return: An array that solves the inverse problem, - i.e. it returns $x$ such that $Ax = b$ + i.e. it returns $x$ such that $Hx = b$ """ all_x, all_y = [], [] for x, y in training_data: @@ -72,18 +71,18 @@ def solve_batch_cg( ) -> torch.Tensor: """ Given a model and training data, it uses conjugate gradient to calculate the - inverse of the HVP. More precisely, it finds x s.t. $Hx = b$, with $H$ being - the model hessian. For more info: + inverse of the Hessian Vector Product. More precisely, it finds x s.t. $Hx = + b$, with $H$ being the model hessian. For more info: https://en.wikipedia.org/wiki/Conjugate_gradient_method :param model: A model wrapped in the TwiceDifferentiable interface. :param training_data: A DataLoader containing the training data. :param b: a vector or matrix :param lam: regularization of the hessian - :param x0: initial guess for hvp + :param x0: initial guess for hvp. If None, defaults to b :param rtol: maximum relative tolerance of result :param atol: absolute tolerance of result - :param maxiter: maximum number of iterations. If None, defaults to 10*len(y) + :param maxiter: maximum number of iterations. If None, defaults to 10*len(b) :param progress: If True, display progress bars. :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$. @@ -120,7 +119,7 @@ def solve_cg( :param x0: initial guess for hvp :param rtol: maximum relative tolerance of result :param atol: absolute tolerance of result - :param maxiter: maximum number of iterations. If None, defaults to 10*len(y) + :param maxiter: maximum number of iterations. If None, defaults to 10*len(b) """ if x0 is None: x0 = torch.clone(b) @@ -209,7 +208,8 @@ def solve_lissa( if max_residual < rtol: break logger.info( - f"Terminated Lissa with {max_residual*100:.2f} % max residual. Mean residual: {torch.mean(torch.abs(residual/h_estimate))*100:.5f} %" + f"Terminated Lissa with {max_residual*100:.2f} % max residual." + f" Mean residual: {torch.mean(torch.abs(residual/h_estimate))*100:.5f} %" ) return h_estimate / scale From 5606e5c38a0d2d23e9d9f9a2893bac3fdb10f6aa Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 11 Apr 2023 21:42:40 +0200 Subject: [PATCH 049/436] fix docs --- .../influence/frameworks/torch_differentiable.py | 13 +++++++------ .../influence/frameworks/twice_differentiable.py | 9 +++++---- 2 files changed, 12 insertions(+), 10 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 68d1952c4..624ec6270 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -298,7 +298,7 @@ def __init__( r""" :param model: A (differentiable) function. :param loss: :param loss: A differentiable scalar loss $L(\hat{y}, y)$, - mapping a prediction and a target to a real value. + mapping a prediction and a target to a real value. :param device: device to use for computations. Defaults to cuda if available. """ if model.training: @@ -336,11 +336,12 @@ def split_grad( Calculates gradient of model parameters wrt each $x[i]$ and $y[i]$ and then returns a array of size [N, P] with N number of points (length of x and y) and P number of parameters of the model. + :param x: An array [NxD] representing the features $x_i$. :param y: An array [NxK] representing the predicted target values $y_i$. :param progress: True, iff progress shall be printed. :returns: An array [NxP] representing the gradients with respect to - all parameters of the model. + all parameters of the model. """ x = as_tensor(x, warn=False).to(self.device).unsqueeze(1) y = as_tensor(y, warn=False).to(self.device) @@ -369,15 +370,15 @@ def grad( ) -> Tuple[torch.Tensor, torch.Tensor]: """ Calculates gradient of model parameters wrt the model parameters. + :param x: A matrix [NxD] representing the features $x_i$. :param y: A matrix [NxK] representing the target values $y_i$. :param x_requires_grad: If True, the input $x$ is marked as requiring gradients. This is important for further differentiation on input parameters. - :returns: A tuple where: \ - - first element is an array [P] with the gradients of the model. \ - - second element is the input to the model as a grad parameters. \ - This can be used for further differentiation. + :returns: A tuple where the first element is an array [P] with the + gradients of the model and second element is the input to the model + as a grad parameters. This can be used for further differentiation. """ x = as_tensor(x, warn=False).to(self.device).requires_grad_(x_requires_grad) y = as_tensor(y, warn=False).to(self.device) diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index 3b1b3fb14..124327c86 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -51,15 +51,16 @@ def grad( ) -> Tuple[TensorType, TensorType]: """ Calculates gradient of model parameters wrt. the model parameters. + :param x: A matrix representing the features $x_i$. :param y: A matrix representing the target values $y_i$. :param x_requires_grad: If True, the input $x$ is marked as requiring gradients. This is important for further differentiation on input parameters. - :returns: A tuple where: \ - - first element is an array with the gradients of the model. \ - - second element is the input to the model as a grad parameters. \ - This can be used for further differentiation. + :returns: A tuple where: the first element is an array with the + gradients of the model, and the second element is the input to the + model as a grad parameters. This can be used for further + differentiation. """ pass From be62a777c55be4de2f4759669888eec6650a0409 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 12 Apr 2023 10:05:12 +0200 Subject: [PATCH 050/436] fix keyword only args --- notebooks/influence_synthetic.ipynb | 38 ++++++++------- .../frameworks/torch_differentiable.py | 47 ++++++++++++------- src/pydvl/influence/general.py | 28 +++++------ src/pydvl/influence/inversion.py | 21 +++++---- tests/influence/test_influences.py | 30 ++++++------ 5 files changed, 90 insertions(+), 74 deletions(-) diff --git a/notebooks/influence_synthetic.ipynb b/notebooks/influence_synthetic.ipynb index 679a697fa..edb0f0517 100644 --- a/notebooks/influence_synthetic.ipynb +++ b/notebooks/influence_synthetic.ipynb @@ -60,6 +60,8 @@ "name": "stderr", "output_type": "stream", "text": [ + "/Users/fabio/.local/lib/python3.8/site-packages/requests/__init__.py:109: RequestsDependencyWarning: urllib3 (1.26.9) or chardet (5.1.0)/charset_normalizer (2.0.12) doesn't match a supported version!\n", + " warnings.warn(\n", "/Users/fabio/.local/lib/python3.8/site-packages/torchvision/io/image.py:13: UserWarning: Failed to load image Python extension: dlopen(/Users/fabio/.local/lib/python3.8/site-packages/torchvision/image.so, 6): Symbol not found: __ZN3c106detail19maybe_wrap_dim_slowExxb\n", " Referenced from: /Users/fabio/.local/lib/python3.8/site-packages/torchvision/image.so\n", " Expected in: /Users/fabio/.local/lib/python3.8/site-packages/torch/lib/libc10.dylib\n", @@ -272,7 +274,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0aa94baf14a84fcb88c46b8fd0fc3e8f", + "model_id": "56806ebeaca4424587b44d08cf6d3fb3", "version_major": 2, "version_minor": 0 }, @@ -305,7 +307,7 @@ " shuffle=True,\n", ")\n", "\n", - "optimizer = AdamW(params=model.parameters, lr=lr, weight_decay=weight_decay)\n", + "optimizer = AdamW(params=model.parameters(), lr=lr, weight_decay=weight_decay)\n", "scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=num_epochs)\n", "losses = fit_torch_model(\n", " model=model,\n", @@ -334,7 +336,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -366,7 +368,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 12, @@ -375,7 +377,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -518,7 +520,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -593,8 +595,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average mislabelled data influence: -0.7553824006631059\n", - "Average correct data influence: 0.01002977552148307\n" + "Average mislabelled data influence: -0.7102711705390644\n", + "Average correct data influence: 0.009479014696434519\n" ] } ], @@ -621,7 +623,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -674,14 +676,14 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 20, "id": "e508f38c", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c84c700bd92f46a5a8f0512b3ee4ffc6", + "model_id": "9cc1439cea994625ba7508e6f0fa226e", "version_major": 2, "version_minor": 0 }, @@ -695,7 +697,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "381bc60559194a228ed848886d2584d1", + "model_id": "a47a99d0a93c4bffb9d26b525582e49c", "version_major": 2, "version_minor": 0 }, @@ -709,7 +711,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ceb35010f9b144c789013905535b2fd8", + "model_id": "7abb27628ba64f5c878547e964658788", "version_major": 2, "version_minor": 0 }, @@ -723,7 +725,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e02b2a55b943410ca414de73f820d9a0", + "model_id": "98af5b6c9fed48f19fc90c6d0afb0047", "version_major": 2, "version_minor": 0 }, @@ -738,8 +740,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average mislabelled data influence: -0.7552845286625567\n", - "Average correct data influence: 0.010028835431038661\n" + "Average mislabelled data influence: -0.7101729888381574\n", + "Average correct data influence: 0.009478249408447392\n" ] } ], @@ -768,13 +770,13 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 21, "id": "8e33f972", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3sAAAIfCAYAAADJ38UbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAACyjElEQVR4nOzdd3gU1f7H8fd3d9MDofcuWAhVEBFRFFFsP70W7AWsXHu/9l4vNmxcC2JX7OLF3hBBRKQHFSnSe00vu+f3x67ekARIIMlsNp/X88yT3ZnZmc9u2n73nDnHnHOIiIiIiIhIbPF5HUBEREREREQqn4o9ERERERGRGKRiT0REREREJAap2BMREREREYlBKvZERERERERikIo9ERERERGRGKRiT0RkN5nZEDNbaGZBM3vJzA4xM2dmrbzOFk0ir8tcMys0s++2s8+dZragmqN5wszaRX5O+nudZWfK+zMd+fn/qrpyxRoz+9PMbq3gY2rMz5GIVD8VeyIiEbvyRtXM/MCLwNtAG+DKqsgWI0YB04EOwInb2edhoG+1JSrGzPpH3jS3q6ZTLgOaAz9V5EFmVmRmQ6sk0fZNJpx1ZSRDdb9WUcnMXtjeBxfRzMxuNbM/vc4hIlVPxZ6IyO5pDqQCnzjnVjjntngdKIp1Ar50zi1zzm0sawfnXJZzbn015/KEcy7onFvtnCv0OsvOOOcKIllDXmcpLzOLK886EZFYpmJPRGQ7/mrpM7OLzGyJmW01s3Fm1jSyfSjh1hmA7yMtHYeUcZwyu8CVbKExs6aRc64zs0wzm2RmB5dxnMPN7HszyzGzeWZ2VInjNjGzMWa2xszyzOx3Mzuv2PaOZvaemW02s01m9oWZdS22vW7k8avNLN/MlpnZozt5rfYys/FmlhVZPjazjsVzA37glchzGLqd42zTjfOv+2Z2vJn9ZmbZZvadmXUqts/QyGs5yMwyIs/5JzPrUXKfEudq9df3LNJCNTGyaXFk/Xc7eL7OzK6MvI7ZZrbCzK4ssU9zM3sr8jrnRnL3LrZ9m+53xe6fYmb/jXx/F5X4Gfkz8jqOiezrIusr9D0zs1fN7PVi94dFjndBsXWvm9mbkdt//wyX57Xa3u/MDvIEzOwOC3eHzo+8nk9W4LX8K98xZvaDmeUBF9j/focvj7x2+WaWFHn8CyUybNPaVeyxV0fy5JjZO2bWILL9TuB8YMBf34u/vldmlmpmI4s9boaZnVjifN3NbHLk+f5hZqfs6DUq9rhTIr8TeWY2GehWYruZ2fOR1zI38jN0v5klRLYPBe4B2hbLfWdk2xkW/t3ZYmbrLfw7vWd5colIdFKxJyKyY/sBhwLHAIOBroS7GgKMBfpEbh9PuJVv8q6cxMySgG+BOsBRQE/gE+BLM9unxO4PA/cD3Ql3ARxrZvWLHWdCZNuZQGfgciAnsr0p8AOwFjiIcJfJ34HvzKxx5Pj3AvtGnlMn4FTg151k/wJIBAZEllTgMzOL539dAAEui9weW4GXpznwz8jz6Uf4NXqxxD4+4N/AJYS/J+uA8ZFs5bGM8PMl8vjmbL+r6V/uAL4j/L36N/CImR0P4TfcwIfA3sCxkWOuIfz9bLST4z4IvEL4TfxbwAvF3nDvBwSBqyIZ/3pdK/Q9I/yzdmix+wMJv2YDi607FPimjMfu7LXa0e/M9owGLgXuJPwzexKwCCr8Wj4CPATsA3xcLOPASObuQMFOshTXJ/JcjgSOBnpEshJ5Tm8AP/K/78XYSN6PI+c6FehCuAvzW2Z2WOQ5JRH+/d4cOcc5wPVAkx2FMbOewJvAO5HjPwyMLLkb4d/vMwi/DlcBw4CbI9vHEn6NlhfL/df3J4H//SwdTvhnbXzk91hEaiLnnBYtWrRocQ7gJeCrEvfXAgnF1v0LWFXsfjvAAf2LrTsksq5VWfeL7VcEDI3cHkr4zVegxD7fAI+XOM6JxbY3jawbHLl/PpBX8lzF9r8TmFJinQELgasi9z8CXqrA63Y+4WKyUYlcucA5xdY54KydHOtOYEGJ+0VA42LrTgVCQGKx184BhxXbpz6QBZxfbJ+iEudqFXncIZH7/SP325XjOTvg1RLr3gAmRm4fFtmnc7HtCcAq4PayfnaK3b+m2GP8QCZwcVk/N8XWVfR71q54vsjP3rVEfrYJFwkO2GM7P9NlvlaU43emjCwdI8c6eTvby/Na/pXv7DLybAZSS6z/DnihxLpbgT9LPDYLSCu27ojIeTpG7r8AfFfiOIcQ/h1MK7H+ReDDyO0LIseuX2x7l8ixb93Ba/UaMKnEusso8TeojMddDfyxvee6g8c1iBz7wPL+bGnRoiW6lgAiIrIjvznn8ovdX0m4kKls+wHNgM3hhoG/JRAumoqb+dcN59waMwsWy9QLmOecW76D8/Qys6wS65MItwgBPAO8F+km9zXwGfC52/71WumRc/59rV0k1++RbbtrpXNuXfH7hAvUJsDSYut/LHb+TWb2ayWdf3t+LHF/EuHucUTOu8E5N69Ypnwz+6kcmWYWe0zQzNay85+5Cn3PnHN/RrosDoz8/NSLHON2M+tMuDVrqXNu4U7OW5aK/s7sG/n6xXa2V+S1nFrG4391zpX8eS+veW7b63AnRb52BrY3aux+QDywosTvcjzwR7HH/+qc2/TXRufcXDPb2TW/nQl/f4v7oeROZnYh4YKyHZACBChHby4Ld32+g3ALZiPCv2cAbfnfcxeRGkTFnojIjpXs8uX43xug8vrrDfffj7PwKJ7F33z5CHe7O6GMx+fsJNNfjy8PH+E3i5eVsW0LgHPuczNrQ7gL3iGEWxPmmNlhzrlgOc9Tmcr6HkDFLkUoq+iJ1sE6ynq+O3yuu/g9+4Zwq1kQ+ME5l2tm3xPu8ri9Lpy7mr+ivzO7Kruc60KUzlRZPw8+wr9L+5WxrSJdSHeJmQ0BngZuJNyleyswBLhvJ49LJlxw/0C42+eayKYMwoWqiNRAumZPRKTqrY18bVFsXQ+2fbM5jfCUBFudcwtKLCsrcK5fgM62/fnQphFuDVlexnn+bj1zzm10zr3pnLuY8LVXAwi3KpQlI3LOv6+filwbuBcwtwLZd9ffUzaYWT3CXRH/ag1aC/hLDBSyL9v66424v6Lni+hX7HwZQMNIK9lfmRKA/dn916SgrIwV/J5B+Lq9AcAg/tda9FcBeAg7LvYq+lrtyPTI1yO2s70qXsu1bPv7CKV/HgD2MbO6xe73i3z96/tc1vdiGuGW0sQyfseWFnv8PpGfUwDMLB1I20nuecUy/OXAEvcPBmY45x51zv3inPuDcAtfcWXl3gdoDNzinPvOOfcr4e7Q1VWoi0gVULEnIlL1FgBLgDvNbG8Lj774GP9roQJ4HVhMeDCEIyw8MuP+ZnaTmf2jAud6M3KucRYenbK9mR1mZqdGtj9F+E3eR2Z2UOQ8/c3sPjPrBxC5faKFR9jsRHhglCy27TJZ3BuEB/cYa2b7mlkvwgOLrKBiA7HsDgf828wOtvDIoq8Qvtbtjcj2qZH7D5pZJzM7Eri9xDGWEG7xOdrCI5ru7I33sWZ2WeR4lxO+lvCRyLZvIud8w8wONLMukUyJhAfr2B2LgUPNrMVfBfYufM/+ylgfOI7/FXbfEB4EpQE7LvYq+lptl3NuAeGf/2fM7Cwz28PM9rP/jW5aFa/lV8AgMxti4dFpbyQ8YFGpeIRHkO1i4ZFxnwbGRTJD+Huxt5mlm1mjSBH6TeT475vZP8ysg5n1svCIoBdGHvcG4Z/H1yw8Kmdfwtf0leyyXdJjwAGR7/eeZnYC4Wsti/sd6GrhEWz3iLyOJQcbWgw0M7MDIrmTCX9P84HLI487jPDgLw4RqbFU7ImIVDHnXBHhQqAJMIPwG8ZbKNa10DmXR7iVZRowBpgPvE94pL4lFThXTuQ4cwkXXL9GzpcU2b4GOABYHzn+74TfaLclPOAFhAeXuJtwK+E0wqNCHuW2M4egcy6XcKtMPvA94a5j2cCRzrkq77YWESI82uCzhDM3A46JvB648Lx+pxNujZsN3AbcUPwAkdfmJsLd31YRHvRkR+4m3Co2K3LuG5xzH0SO5YB/AL8B44GfI5kOd7s/j+C1hK/N/JNwkQ0V/J5FMq4k/HOWSfjnEsKvzWZgvnNuxQ4eW9HXameGEf7e3Uv4Z/YDoH3kXFXxWr5M+PfiacKvV2vgiTL2m0q4W+OXhK+DnAOcV2z76EieyYS/F6dH8h5H+PfrsWK5jyE8ENJfv6dHAw0j53g9su9adsA59wvhUTZPi2S5kfDgK8U9C7xK+O/IDMItoHeW2OdDwiN6jo/kviHyWp5FeBTODMIjdF5H2V2gRaSGsPDfJBERkZrJwvOGveCcq7br0C08v93ZzrnXquucUr3M7CXCo48O8jqLiMiuUsueiIiIiIhIDFKxJyIiIiIiEoPUjVNERERERCQGqWVPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEq9kRERERERGKQij0REREREZEYpGJPREREREQkBqnYExERERERiUEBrwNUtUaNGrl27dp5HUNEREREJKr88ssv651zjb3OUV6DD01xGzYGK/24v8zO/9w5d2SlHzgKxHyx165dO6ZNm+Z1DBERERGRqGJmS7zOUBEbNgaZ+nmbSj+uv/kfjSr9oFEi5os9ERERERGp+RwQIuR1jBpFxZ6IiIiIiNQAjqBTsVcRGqBFREREREQkBqllT0REREREol64G6fzOkaNopY9ERERERGRGKSWPRERERERqRE0QEvFqNgTEREREZGo53AEnbpxVoS6cYqIiIiIiMQgteyJiIiIiEiNoAFaKkYteyIiIiIiIjFILXsiIiIiIhL1HBBUy16FqNgTEREREZEaQd04K0bdOEVERERERGKQWvZERERERCTqOdDUCxWklj0REREREZEYFBXFnpm1NrNvzWyemWWY2ZVl7GNm9oSZLTCz2Wa2rxdZRURERETEG6EqWGJZVBR7QBFwrXOuM9AXuNTMOpfY5yigU2S5CBhVvREr7o8//mDdunVexxARERERkVooKoo959wq59z0yO1M4FegZYndjgdecWFTgHpm1ryao5abc46zzjqL9PR03n33Xa/jiIiIiIjUaA5HsAqWWBYVxV5xZtYO6An8VGJTS2BZsfvLKV0Q/nWMi8xsmplN86plzcwYPXo0bdq0YciQIZxyyimsXbvWkywiIiIiIjWeg2AVLLEsqoo9M0sF3gOucs5t3dXjOOeec871ds71bty4ceUFrKAuXbowZcoUHnjgAT766CPS09MZO3YsTqMIiYiIiIhIFYuaYs/M4ggXeq87594vY5cVQOti91tF1kW1QCDAjTfeyIwZM+jQoQOnnXYaJ598MmvWrPE6moiIiIhIjeHQAC0VFRXFnpkZMBr41Tn36HZ2GwecExmVsy+wxTm3qtpC7qbOnTszadIkHnroIcaPH0/nzp1544031MonIiIiIiJVIiqKPeBA4GxgoJnNjCxHm9lwMxse2ecTYBGwAHgeuMSjrLssEAhwww03MHPmTPbcc0/OPPNMTjjhBFatqjE1q4iI7EBBcBNLt77Jws3/YXPeLH2gJyJSqYxgFSyxLOB1AADn3A+w41fahf9jXlo9iarW3nvvzQ8//MDjjz/OrbfeSnp6OiNHjuSss84i3MgpIiI1zYbcH5mx5jIcjpArYLE9T+PkQ+nW+N+YRctnqyIiNZcDQvoMrUL038cjfr+fa6+9lpkzZ7LPPvtwzjnncNxxx7FiRdRfhigiIiWEXAEz115F0OUScnlAiKDLZV3Ot6zJ+cLreCIiUkup2PPYXnvtxffff89jjz3G119/TZcuXXjppZfU9UdEpAbZnDcT50pf5h90uazI/MCDRCIisUndOCtGxV4U8Pv9XHXVVcyaNYsuXbowbNgwjjnmGJYvX+51NBER2boVRo2CCy+ESy+Fjz+GYLDETjt6sxDbbyRERCR6qdiLIp06dWLChAmMHDmSCRMmkJ6ezujRo9XKJyLilQ8+gPbtcd98w5ZOnclu0QbuvRe6dIEFC/7erV5ijzKvy/NbEi3rnFCdiUVEYpZDLXsVpWIvyvh8Pq644gpmz55Nz549ueCCCzjyyCNZunSp19FERGqXyZNh+HB+f/JlTvcN4PRvizjpe+PK/S8j6/yL4fDDw61+gM/i6NHkcfyWhM8SAR8+S6Jx8qE0TT7c2+chIhJDQs4qfYllKvai1B577ME333zD008/zaRJk+jSpQvPP/+8WvlERKrLAw+w+fqbuea131i3LpP8/CIKC4PMm7eCS2cn4Xr1gldf/Xv3hkkHcHDrr9mrwQ10qn85fZq/RPcmD2skThER8Yz+A0Uxn8/HJZdcwpw5c+jduzcXXXQRRxxxBEuWLPE6mohIbMvKgm++4b3EPSkq2vb6vFDIsWFDJn8OPA7Gjt1mW7y/Hm3qnkaHeheTltC1OhOLiMQ8deOsOBV7NUD79u356quvGDVqFFOmTKFLly6MGjWKUKj0yG8iIlIJMjMhNZXlG/IoKirrb62xLpACW7ZUezQREZHyUrFXQ/h8PoYPH87cuXPp27cvl1xyCYMGDWLx4sVeRxMRiT0NG0JhIQe0jCcxMVBqczAYYs+tK6BDBw/CRZfcopUs3jyaBZueZmv+PK/jiEgMcxhBfJW+xLLYfnYxqG3btnzxxRc8//zzTJs2ja5du/L000+rlU9EpDLFx8NZZzFw1ufUq5dCXJz/702JiXEc2n8P6r06OjwdQy22MvNjflh+DH9seoKFm0fx06qzmLf+Xl1fLiJVRgO0VIyKvRrIzLjggguYO3cu/fv357LLLmPgwIEsXLjQ62giIrHj5psJ/PdjRrdfzUlHdaZp0zTatWvEVSd15vqfXgq36h15pNcpPVMY3ELGhtsJuXwchUCIkMtjZdYHbMr7xet4IiKCir0arU2bNnz66ae8+OKLzJw5k65duzJy5Ei18omIVIZmzWDiRBLnzeHCe87ljS3/ZfTC1zj8hrOxffYOD87iq73/Rtfn/oDhL7U+6PJYlf1fDxKJSKzTAC0VV/pCBKlRzIxhw4Zx+OGHc/HFF3PVVVfx7rvv8uKLL9KpUyev44mI1GytWoUnVl+2DGbPhrg46NcPUlO9ThYFfLCdN0mmz5JFRKKC/hrHiFatWvHf//6Xl19+mblz59KtWzcee+wxgsHgzh8sIiI71ro1HHMMHHGECr2IRsn9cZT+H+OzBFqkHudBIhGJfUbQ+Sp9iWWx/exqGTPjnHPOISMjg0GDBnHNNddw0EEH8fvvv3sdTUREYkycrw5dGz2IzxLwWSJGHD5LoG3ds6iX2MPreCIigrpxxqQWLVowbtw4Xn/9da644gp69OjBPffcw9VXX43fX/r6ChERkV3RLPUI6if1Yk32l4RcHo2TBpAS397rWCISoxwQUltVhejVilFmxllnnUVGRgZHHHEE119/Pf379+fXX3/1OpqIiMSQBH9D2tQ9jXZpQ1XoiUiV0wAtFaNiL8Y1b96cDz/8kNdff5358+fTs2dPHnroIYqKiryOJiIiIiJSI5jZkWb2u5ktMLMby9ieYGZjI9t/MrN2HsQsRcVeLWBmnHHGGWRkZHDMMcdw44030q9fPzIyMryOJiIiIiJSLs55M0CLmfmBp4GjgM7A6WbWucRu5wObnHMdgceAhyr56e8SFXu1SLNmzXj33XcZO3YsixcvZt999+WBBx5QK5+IiIiIyPb1ARY45xY55wqAt4DjS+xzPPBy5Pa7wGFm5nkfURV7tYyZccopp5CRkcHxxx/PzTffTN++fZkzZ47X0UREREREdiiEVfoCNDKzacWWi0qctiWwrNj95ZF1Ze7jnCsCtgANq+ZVKD8Ve7VUkyZNePvtt3nnnXdYunQpvXr14t5776WwsNDraCIiIiIipTggiK/SF2C9c653seU5j59qpVGxV8udfPLJzJs3j5NOOonbbruN/fffn1mzZnkdS0REREQkWqwAWhe73yqyrsx9zCwApAEbqiXdDqjYExo1asSbb77J+++/z8qVK+nduzd33XUXBQUFXkcTEREREYnwZoAW4Gegk5m1N7N44DRgXIl9xgHnRm6fDHzjnHOV9tR3kYo9+dsJJ5xARkYGp556KnfeeSf77bcfM2bM8DqWiIiIiIhnItfgXQZ8DvwKvO2cyzCzu83suMhuo4GGZrYAuAYoNT2DF1TsyTYaNmzIa6+9xkcffcTatWvp06cPt99+u1r5RERERMRTDgjhq/SlXOd27hPn3J7OuT2cc/dF1t3unBsXuZ3nnBvinOvonOvjnFtUda9E+anYkzIdd9xxZGRkcMYZZ3DPPffQq1cvpk2b5nUsEREREanFgs4qfYllKvZkuxo0aMDLL7/Mf//7XzZu3Ejfvn255ZZbyM/P9zqaiIiIiIjshIo92aljjjmGjIwMzjnnHO6//3723Xdfpk6d6nUsEREREalFHFZVUy/ErNh+dlJp6tWrx4svvsinn37K1q1bOeCAA7jxxhvJy8vzOpqIiIiIiJRBxZ5UyJFHHsncuXM577zzeOihh+jZsydTpkzxOpaIiIiI1AIh56v0JZbF9rOTKpGWlsbzzz/P559/TnZ2NgceeCDXX389ubm5XkcTEREREZEIFXuyy4444gjmzp3LBRdcwMMPP0yPHj2YPHmy17FEREREJAY50DV7FRTbz06qXN26dXn22Wf58ssvyc/Pp3///lxzzTXk5OR4HU1EREREYoij8qdd0NQLIuUwaNAg5syZw/Dhw3nsscfo3r07EydO9DqWiIiIiEitpWJPKk2dOnV45pln+OabbwgGgwwYMIArr7yS7Oxsr6OJiIiISAwI4av0JZbF9rMTTxx66KHMnj2bSy+9lCeeeIJu3boxYcIEr2OJiIiIiNQqKvakSqSmpvLkk0/y3XffAXDIIYdw+eWXk5WV5W0wEREREamRnIOg81X6Esti+9mJ5wYMGMDs2bO58sorefrpp+nWrRvffvut17FEREREpMYxQlWwxDIVe1LlUlJSePzxx5kwYQJ+v5+BAwdyySWXkJmZ6XU0EREREZGYpWJPqs1BBx3ErFmzuOaaa/jPf/5D165d+eqrr7yOJSIiIiI1gEPdOCsqtp+dRJ3k5GQeeeQRfvjhBxISEjj88MO5+OKL2bp1q9fRRERERERiioo98US/fv2YOXMm119/PS+88AJdunThiy++8DqWiIiIiESxIL5KX2JZbD87iWpJSUn8+9//ZvLkyaSmpjJ48GAuuOACtmzZ4nU0EREREYkyDiPkKn+JZSr2xHP7778/06dP58Ybb2TMmDGkp6fzySefeB1LRERERKRGU7EnUSExMZEHHniAKVOmUK9ePY455hiGDRvGpk2bvI4mIiIiIlFC3TgrJrafndQ4++23H7/88gu33HILr776Kl26dOG///2v17FERERERGocFXsSdRISErj33nv56aefaNiwIf/3f//H2WefzcaNG72OJiIiIiIecUDI+Sp9iWWx/eykRuvVqxfTpk3j9ttv56233iI9PZ2PPvrI61giFbIh53t+WnEc3y3pxpTlR7I2+1OvI4mIiEgtoWJPolp8fDx33XUXU6dOpWnTpvzjH//gzDPPZMOGDV5HE9mpDTnfM2fd5WQX/k7I5ZNTtJh5629iVeYHXkcTERGpgYxgFSyxTMWe1Ag9e/Zk6tSp3Hnnnbz99tukp6fzwQd6wyzRbcGmhwm5vG3WhVwuCzc/inPOo1QiIiI1k7pxVlxsPzuJKfHx8dxxxx1MmzaN5s2bc+KJJ3Laaaexfv16r6OJlCm38M8y1xcE1xNyBdUbRkRERGodFXtS43Tv3p2pU6dyzz338P7779O5c2feffddr2OJlJIQaFbm+oCvDj6Lr+Y0NUNBcBN/bHyEH5cfzy+rz2dDziSvI4mISBRRN86KUbEnNVJcXBy33norv/zyC61bt2bIkCGccsoprF271utoIn/rUO8qfJa4zTqfJdEu7Z+YxfY/l11RENzElBX/YMmWl8kqnM/G3MnMXHs5S7a87HU0ERGRGknFntRoXbt2ZcqUKdx333189NFHpKenM3bsWF0PJVGhaerR7NXgDuJ9jQAfAV8aHepdSeu6Q72OFpWWbHmZguBmHIV/rwu5XBZsepyiULaHyUREJBo4Z7pmr4Ki5tmZ2YtmttbM5m5n+yFmtsXMZkaW26s7o0SnuLg4br75ZqZPn0779u057bTTOPnkk1mzZo3X0URoXudEDmz9AwPazOCg1j/RJm2YWvW2Y0PuDzhKX8toBMgqmO9BIhERiTZB56v0JZZF07N7CThyJ/tMdM71iCx3V0MmqUHS09OZPHkyDz74IOPHj6dz5868+eabauUTz5kZfl+iirydSPA3KXO9o4h4f4NqTiMiIlLzRU2x55z7HtjodQ6p2QKBAP/617+YMWMGnTp14owzzuCEE05g1apVXkcTkZ1omza01DWORoA68XuRHNfWo1QiIhItHBDCKn2JZVFT7JXTAWY2y8w+NbP07e1kZheZ2TQzm7Zu3brqzCdRYp999mHSpEmMGDGCzz//nPT0dF599VW18tViIVfIysx3+GXVWcxYPZQ1WeNxLuR1LCmmQVIf9mxwI35Lxm+p+CyBugld6dH0aa+jiYiI1EgWTW9+zawd8F/nXJcyttUFQs65LDM7GhjpnOu0s2P27t3bTZs2rfLDSo3x+++/c9555zF58mSOPfZYnn32WVq0aOF1LKlGzoWYueYCtuRPJ+RygfComE2SB9O58UMep5OSgqE8sgr/IN7XgKS4ll7HERGJWWb2i3Out9c5yqtFen13/luHVPpx7+32YY16HSqixrTsOee2OueyIrc/AeLMrJHHsaQG2Guvvfj+++959NFH+frrr0lPT+fll19WK18tsjFvMlvyZ/xd6EF4lMe1OZ+RVfCbh8mkLH5fImkJXVXoiYjINhwQclbpSyyrMcWemTWzyOgGZtaHcPYN3qaSmsLv93P11Vcza9YsunbtytChQznmmGNYvny519GkGmzKnUzI5ZRa71yITXk/eZBIREREpOpFTbFnZm8CPwJ7mdlyMzvfzIab2fDILicDc81sFvAEcJpT04xUUKdOnfjuu+944oknmDBhAunp6YwePVqtfDEuztcAI77Uep/FEeer70EiERER2RVBfJW+xLKoeXbOudOdc82dc3HOuVbOudHOuf845/4T2f6Ucy7dOdfdOdfXOTfZ68xSM/l8Pi6//HJmz55Nz549ueCCCzjyyCNZunSp19GkijRLPQ4zfxlbjMbJg6o9j8h2FRbCDz/A55/D4sVepxERkRouaoo9keq2xx578M033/DUU08xadIkunTpwvPPP69WvhiUEGhCtyZPE/DVxW+p+C2FeF8jejYbg9+X7HU8EXAOHnsM2raFK6+ERx6BPn3gyCPhN11XKiIC4Kj86/Vi/Zq9gNcBRLzk8/m49NJLOfroozn//PO56KKLePvtt3n++edp166d1/GkEjVIOpD+rSeTmT8XMz914rtgFj2fdznnWJH5Bku3vEBhaDN1E7rTsf6/qJOwj9fRpDrccAN8+y0/P/ocz87PZOPWHPoNuYqLN2RQ55BDYMIE2Gsvr1OKiEgNEz3vdEQ81L59e7766itGjRrFlClT6Nq1K6NGjSIU0jxsscRncaQl9qRuQreoKvQAFm56hAWbRpAXXEnQ5bAp70emrz6D7IKFXkeTqvbrr/Dqq7x5zQNc99Ui5ixYxYq1W/hg8nxOWppC9uVXwY03ep1SRCQqhPBV+hLLYvvZiVSAz+dj+PDhzJ07l759+3LJJZcwaNAgFuu6GaliRaEslme+ss3UEABBl8efW/7jUSqpNi+8QME5Qxn1za/kFRT9vbooGCInr4BXWnQPt+ytWuVhSBER7zkHQWeVvsQyFXsiJbRt25YvvviCZ599lmnTptG1a1eefvpptfJJlcktXIYRV8aWEJn5c6o9j1SzBQtY1X5PAv7S/5ILi0JMWrgeOnWCP/+s/mwiIlKjqdgTKYOZcdFFFzF37lwOPPBALrvsMgYOHMjChepSJ5UvMdAM5wrK2GIkx3Wo9jxSzerWpV72FoqKyv5AqVmDOrB2LdStW83BRESijwZoqRgVeyI70KZNGz777DNGjx7NjBkz6NatG08++aRa+aRSxfnr0yTlaHyWuM16nyXQrt7w7TxKYsYpp5D2zlt07diMuMC2/5YT4wMMb1gAKSnQubNHAUVEpKZSsSeyE2bGeeedR0ZGBgMGDOCKK67gkEMOYcGCBV5Hkxiyd6N7aJE6BJ8lYvhJDLSia+MnqZvQzetoUtWOPhoKC3l0y0x679Oa+ICfpIQ4UpMTuPOoznS852a49Vaw2P70WURkZ8JTL/gqfYllsf3sRCpRq1atGD9+PGPGjGH27Nl069aNxx9/nGAw6HU0iQE+i2fPhrdycJtfOKjNzxzQ8isaJh/sdSypDn4/fPIJCd98xeOv3c3ne+TwTmfjy+AsDr1gCFx2GZx2mtcpRUSiQhCr9CWWqdgTqQAzY+jQoWRkZHDYYYdx9dVXc/DBB/P77797HU1ihM8CBHwpmFpxapdmzWDKFHjkEZKXL6XxjKn42rcLT8tw1VVepxMRkRpKk6qL7IKWLVsybtw4Xn/9da644gp69OjBvffey1VXXYXf7/c6nojsouzCxWzKnUqcvx6Nkg7B70uovpP7fDBoUHgREZFSHMT8gCqVTS17IrvIzDjrrLPIyMjgiCOO4LrrrqN///789ttvXkcTkQpyzjFv/Z1MWXECv298kIx1t/D9soPZmp/hdTQREZFdpmJPZDc1b96cDz/8kNdff5358+fTo0cPHnroIYqKinb+YBGJCmtzvmR11jhCLp+QyyPosikKbWXmmktwTqPviohEBw3QUlGx/exEqomZccYZZzBv3jyOOeYYbrzxRvr160dGhloFRGqCFZnvEHS5pdYXhbLYWjDXg0QiIlKWEFbpy+4wswZm9qWZ/RH5Wr+MfXqY2Y9mlmFms83s1N06aQWo2BOpRE2bNuXdd99l7NixLF68mH333Zf7779frXwiUS7k8rezxUeozAnvveecIxjKxTmNCCwi4qEbga+dc52AryP3S8oBznHOpQNHAo+bWb3qCKdiT6SSmRmnnHIKGRkZHH/88dxyyy307duXOXPmeB1NRLajWer/4bOkUusNSIvCuQ7X5XzHD8sP55sl+/Htkv2Yv/FhQk4fKonUFIWhTHIKl+n3toKcg6CzSl920/HAy5HbLwP/KJ3bzXfO/RG5vRJYCzTe3ROXh4o9kSrSpEkT3n77bd555x2WLl1Kr169uOeeeygsLPQ6mkjUyi9ay6a8n8kvWlOt522R+g/SErrit2QAjDh8lkiXJv/GZ/HVmmVnNudNZ/baq8krWgEECbpclm19nd833Od1NBHZiWAol1lrr+e7JQcxecU/+HZpf5Znvu91LIFGZjat2HJRBR7b1Dm3KnJ7NdB0RzubWR8gHli4i1krRFMviFSxk08+mUMOOYTLL7+c22+/nQ8++IAxY8bQvXt3r6OJRI2QK+S39bewNvtTzBJwLp9GyUfQufGD+Cyuys/vszh6NXuR9bnfsz7nB+L9DWiR+g+S4lpW+bkrauHmZwi5vG3WhVweK7M+oFODawn4Uj1KJiI7M3f9razN+YYQBeF5BFwuv264j0R/UxolH+h1vBqhigZUWe+c6729jWb2FdCsjE23FL/jnHNm5nZwnObAq8C5rppG/1LLnkg1aNSoEW+++Sbvv/8+K1eupHfv3tx5550UFETntUAi1W3xpidZm/M5IQoIukxCFLA+9ysWbXq82jKY+WmcfCj7NLqNPepfGpWFHkBO4eIy1xsB8ovWVnMaESmvguBm1mZ/Xeoa4ZDLZdGW5zxKJeXhnBvknOtSxvIRsCZSxP1VzJX5h9jM6gLjgVucc1OqK7uKPZFqdMIJJ5CRkcFpp53GXXfdRZ8+fZgxY4bXsaSGCbkClm99k+mrzmLWmuGsz5ngdaTdtiLrzTJbq1ZkvulRouhVNz4dyhg9zhEkMdC8+gOJSLkUBDdgVnanuryiVWWul205jJCr/GU3jQPOjdw+F/io5A5mFg98ALzinHt3d09YESr2RKpZw4YNefXVV/noo49Ys2YNffr04fbbb1crn5RLyBUyfdVZLNj0IJvzf2ZD7rfMXXclCzY+7HW03VIUyi5zfdDl4Nx2e8TUSh3qX4rPErdZ57Mk2qWdj99XepAZEYkOyXGtt7PFR/3EXtWapSaLtqkXgAeBw83sD2BQ5D5m1tvMXojscwpwMDDUzGZGlh67e+LyULEn4pHjjjuOjIwMzjjjDO655x569+7NL7/84nUsiXJrsz8nu/CPbVrBQi6X5VtfJq9otYfJdk/d7Yx4WTe+K2a7/Y84ptSJ34vezV+mXkJvfJZEYqAleza4gQ71LvU6mojsgM/i6VT/yhIj//oIWDJ71PunZ7lk9zjnNjjnDnPOdYp099wYWT/NOXdB5PZrzrk451yPYsvM6sinYk/EQw0aNODll1/m448/ZsOGDey///7ccsst5Odvb84vqe025H5L0OWUWm8WYHPezx4kqhx7Nrg1MhKmP7LGj9+S2bPhbV7GilppCV3Zr8WrHNZuOge1/orWdU9TUSxSA7RNO5vujf9NWnxXEvxNaZZyJH1bvkNyXBuvo9UIDqKxG2dU02icIlHg2GOPZe7cuVxzzTXcf//9fPTRR4wZM4b99tvP62gSZeJ9jQgXRCUn0jbifGkeJKocdRO6sF+LD1m65QUyC+aRGr8PbdMuIDmundfRREQqVZOUw2iScpjXMaSWUMueSJSoX78+Y8aM4ZNPPmHz5s307duXm266iby8vJ0/WGqNFnVOKXMqAp8lUj+pnweJKk9yXFv2bnQP+7V4j30a3atCT0RESgk5X6UvsSy2n51IDXTUUUeRkZHBsGHDePDBB9l333356aefvI4lUSIlfg/2bng/fkvGb6n4LZkEf3N6NnsJ33ZGeRMREYkJVdCFM9a7carYE4lCaWlpvPDCC3z22WdkZmbSr18/brjhBnJzc72OJlGgWeox9G/9I92aPEPPZi/Tr9W3pMbv6XWs6PHDDzBkCNStC0lJcNBB8NZboFE9RUSkllGxJxLFBg8eTEZGBhdccAEjRoygZ8+eTJ482etYEgX8vkTqJ+1P3YRuGpijuGeegdNOY/MBfXnlw/cZ9cUnLD3vPBgxAoYNg1DI64QiIrKLHFE59UJUU7EnEuXq1q3Ls88+y5dffkleXh79+/fn2muvJSen9IiMUjvkFa1gzpqL+f7PdCYu6c7v62+hKJTldSzvzZ4Nd9/NF6+8RN/kAPf+PpcRc2YwuGAr9zx4D+6332D0aK9TikSFDbk/8uOKk/nyz32ZuPwYVmd/7nUkEakCKvZEaohBgwYxZ84chg8fzqOPPkqPHj344YcfvI4l1awolMX0lSexMXcCjkJCLpc1WR8xa/U5mnz8mWfIu/hirpifQV6wiIJQkJBz5BYV8caiP/jtqivgySfVnXM3ZBX8wS+rzuPrP3swYUl/Fm0aRcgVeR1LKmhD7o9MX3MpWwvmEXJ55BQuZs66m1iR+YHX0UR2StfsVYyKPZEapE6dOjzzzDN8/fXXFBUVcfDBB3PVVVeRnZ3tdTSpJmuyPiLocoH/dUd0FJBbuIit+b94FywaTJzIlF498ftK/+POKyritSYNYeFCyMz0INzObc3PYNnWN1iX8y0hV+h1nFJyC1cwdeXpbMybQsjlUxDawOItz/Hres2FWNPM3/goIbftSM8hl8f8jY/qQyOJappnr+JU7InUQAMHDmT27NlceumljBw5km7dujFhwgSvY0k1yCqYR8iVHqjHESK7cIEHiaKIGbaDN6qGhVv1ouwax5ArZPrqi/l51dnM3ziCOWuv54dlh5NbuNzraNtYsvUlQi6f8NutsJDLY3X2J+QXrfUumFRYduGiMtcXhjYTdLpEQCSWqNgTqaFSU1N58skn+e677wA45JBDuPzyy8nK0rVbsSw1fm98llRqveEjOW4PDxJFkQED6PvzLwTLKPgSAwHOWb0W9toL6tTxINz2Ld3yKpvyphJyuYRcHkGXTX5wHbPXXuN1tG1szZ+Do3SXTR8JZBcu9iCR7KrEQPMy1/t9yfjL+PsiEk3UslcxKvZEargBAwYwe/ZsrrzySp5++mm6devGt99+63UsqSJNU/+B3xIp/ufbiCMp0Ja0hN7eBYsGl1xCwvPP82zHziT6AyQGAsT5fCT6A5zXYU/2fPRxuOIKr1OWsiLznVJd6iBEVsHv5Bet8yRTWVLjOgH+UutDFJAU17r6A8ku61j/cnyWuM06nyXRPu1CzPTWUCSW6DdaJAakpKTw+OOP8/333xMIBBg4cCD//Oc/yYzSa5Nk1wV8dejZ/B3qJx4I+DHiaZJyLN2bvaopGNLT4f77GXDWOUzblMO9Hfbi1r268J0lcP01N0Dv3jB0qNcpSwmxnevzzMpsSfNK27Tz8Fn8Nut8JNAwqT9JgRYepZJd0SxlMJ0b3k68vxGGn4CvDh3rXUL7tPO9jiayQw5Nql5RFusX4vbu3dtNmzbN6xgi1SYnJ4fbbruNxx57jDZt2vDCCy8waNAgr2NJFfjr73etL/JK+vnn8Kibn30GhYWw335wySVw/PFRd70ewB8bH2XJlpdxFGyzPjnQln6tPo2q7+/mvBn8uv4usgr/wGdxtEg9iT0b3IDfl+B1NNkFzjmCLge/JalFr5Yys1+cczWmW0ja3k1d/+dOrfTjfjLgyRr1OlSEij2RGDV58mSGDRvG/PnzueiiixgxYgR169b1OpbUEsFQNkYAn4qAnSoKZTF15WnkFa0i6HLwWQJGgF7Nx5CW0NXreEC4KChedIZcAUZABYJIDVcTi71+z51W6cf9bMATNep1qIiA1wFEpGr069ePmTNncvvtt/Poo4/y6aef8vzzzzN48GCvo0kMy8yfx/wNN5Nd8DtgNEweyJ4N7yXOX8/raFEr4Eulb8v3WZv9JZvyppMUaEmLOv8g3t/A62hsyJnEbxvvJ6dwEXG+erRNO492aeeX6s4pIlItHDHf7bKy6SM5kRiWlJTEiBEjmDRpEikpKRx55JGcf/75bN682etolSboCvht4yg+XzKYT/8cyKx195Ef3OR1rFopv2gts1afSVbBPBxBHEVsyPmWWavP1dxdO+GzeJqlHsM+jW6jXb3zoqLQ25w3nZlrLyMnMkx/YWgzizaPYsGmkR4nExGR8lKxJ1IL9O3blxkzZnDDDTfw0ksv0aVLFz799FOvY1WKn1ZfwR9bXiIvuIaC0EaWZH7A9yvOJBgqObqhVLVVWWNLTQbuKCS3aAmZ+bM8ShX9sgp+Z9aa4UxcegBTV/yDtdmfex0JgIWbnixj4u1clm59Rb9fIuIJTapecSr2RGqJxMREHnroIX788UfS0tI4+uijOe+882p0K9+m/Aw25s2MTPQc5igiP7iJFVHyhrk2ySlYWGqQEQhPZp5TuIhVme8wa/W5zF3zTzbkTPAgYfTJKviDX1adxobc7ygMbSSr8Ffmrf8Xy7a+6nU0sgsXlrneMAqC66vknJn5v7Jw0zP8ufkFcgtX7PJxnHMUhbJxLlSJ6UREah4VeyK1TJ8+ffjll1+46aabeOWVV0hPT2f8+PFex9olW/J/LXN90OWyMW92NaeRugk9ypzw3RFk+daXWbDxXjbn/ciG3K+Zt+4KFm0c4UHK6LJ480iCLpfw59VhIZfLok2PE3KlC+fqlBLXabvb4v2NK/18v214gKmrzmDR5qdZsOkJJq84hpWZH1T4OCszP+T7pQfx3ZK+fLtkfxZtGqWiTySGqGWvYlTsidRCiYmJ3H///UyZMoUGDRpw7LHHcu6557JpU8261i050AIr48+YzxJIjWvjQaLarVmdk/BbCsUn3vaRQHJcB3KLlhByuX+vD7lclm99mbyiVR4kjR5b82dRvND7iyNIXtHq6g9UzB7bmXi7bdqwSp9qYXPe9GKTy4dwFBJy+fy64S4KKnAN7trsL8OPCW3AUUTQZbF4y/Ms3vxspeYVEW9onr2KU7EnUov17t2badOmceutt/L666+Tnp7OuHHjvI5Vbo2T9o8MZOHfZr2PAK3rHOdNqFos4KtDrxbv0yTlGPxWh3h/I1qlnU9yYA9CLqfU/j4LsCXvJw+SRo+EQMvtbAlV2iAt2YV/Mm/d7fy0Ygjz1t1BTuGScj2uXmIPejYdRWrcXoCfeH8jOta/gg71LquUXMWtzvqk1PWBAIaf9Tnfl/s4C7ZzneGfW0bjXHC3c4qI1DQq9kRquYSEBO655x6mTp1K48aNOf744znrrLPYsGGD19F2ysxP/xYv0iipd3jOL+KoG78n/VuMJsFf3+t4tVJCoBn7NH6Y/m1/4YDWk2lf/yriA40pe6YfI+BLq+6IUaV92j9LdX31WQJNU44j4Evd7eNvyZ/DTytOYkXW+2wtmMuKrPeYsuJEtuZnlOvxDZL6ckCrDzm8/VwGtJlI27ShVTLJe3i+vrKOaxWayy+vaGWZ60OugKJQ9q6FE5Go4pxV+hLLVOyJCAD77rsvP//8M3feeSdjx44lPT2dDz6o+PUy1S0p0IQDmz/LUe0mcGTbrzi01dukJeztdSwppnnqEHxWutjzWTz1kw70IFH0aJg8gL0a3EHAVw+fJeKzBJql/IO9Gt5eKcf/bf09BF0O8FerVpCgy+G3DfdVyvErS7PUY8ucu89RRKOkg8t9nNT4jmWuD/hSK6V4FhGpaVTsicjf4uPjueOOO5g2bRrNmzfnxBNP5PTTT2f9+qoZea8yxflSiPfX7laiaJUcvwd7NrwfnyXjt1T8lkK8vyndmr2kybmB5nVO4KDWkzmg5Rcc1Pon9m50d6W8Ls45thbMLXPblvzoGsAoLaEbbeuei88SMOL/LnzTGz1AXAV+rzvWv6aM6wwT6Vj/6gq1EIpI9Aphlb7EsrL61YjUWs45KPoVgmsgrgtWBSPO1QTdu3dn6tSpPPjgg9xzzz18/fXXPPPMM5x88sleR5MaqmnqsTRKHsTW/Bn4LYk6Cd305rsYMz8JgaaVfEzDb8kEXenuiwFfSqWeqzJ0bHAVzescz/qcCfgsnibJh5MQqNjf4AZJfejZ9Fn+2Pgw2YULSQg0o2P9y2macmQVpRaR6uQcMT+gSmVTsScS4YIbcJvOg+CfgB9cAS75dKzOzVVyjUq0i4uL47bbbuMf//gHw4YNY8iQIQwZMoSnnnqKJk2aeB1PaiC/L5H6SQd4HaNWaVX3NJZtfX2bQUt8lkirOqd5mGr7UuLak5LWfreO0SCpD/u3fLuSEomI1Gz6WFUkwm2+Eor+AJcLLgsogJy3Ie8jr6N5qmvXrkyZMoX777+fjz76iPT0dMaOHRtuBRWRqNax/hU0ST4MH/EErM7fLWZ71K/8ETVFRKqDBmipGBV7IoALroPCmUBRiS25uOyXqj9QlAkEAtx0001Mnz6d9u3bc9ppp3HyySezZs0ar6OJyA74LJ6uTR7mwNZf0r3pU/Rv9SVdm/wbn8V5HU1ERKqBij0RAJdNybna/rcts1qjRLP09HQmT57MQw89xPjx4+ncuTNvvvmmWvlEolxioAkNkvqQEFAXbBGpyTSpekWp2BMB8LcGX3IZG+Ig4bBqjxPNAoEAN9xwAzNnzmTPPffkjDPO4IQTTmDVqlVeRxMRERGRYlTsiRAeCc/q3g8k8r8WvkTwNcBSh3uYLHrtvffe/PDDDzz88MN8/vnnpKen8+qrr6qVT0RERKqMrtmrGBV7IhGWeCjW8D1IOhni+0HqZVij8ZivgdfRopbf7+faa69l5syZ7LPPPpxzzjkcd9xxrFy50utoIiIiEmMcqBtnBanYEynG4jrhS7sHX4OX8KVehPnqeh2pRthrr734/vvvefTRR/n6669JT0/n5ZdfViufiIiIiIeiptgzsxfNbK2Zzd3OdjOzJ8xsgZnNNrN9qzujiGyf3+/n6quvZtasWXTp0oWhQ4dyzDHHsHz5cq+jiYiISCxw4YnVK3uJZVFT7AEvAUfuYPtRQKfIchEwqhoyiUgFderUiQkTJjBy5EgmTJhAeno6L774olr5KkkwlMPW/FnkFdaOIvqPzNU8+fvnPPrrJ8zetNTrOCIiIjVK1BR7zrnvgY072OV44BUXNgWoZ2bNqyediFSEz+fjiiuuYPbs2fTo0YPzzz+fo446imXLlnkdrUZbvuUlJi87gNmrh/HzyqOYueoMCoObvI5VZV5dNJFzJ4/i1UUTeePPyfzz5xd5KGOc17FERMRDIazSl1gWNcVeObQEir9TXB5ZV4qZXWRm08xs2rp166olnIiUtscee/Dtt9/y5JNPMnHiRNLT03n++efVyrcLNuRMYPHmxwi5XIIui5DLZ2v+TDLWXeF1tCqxOnczz/zxFfmhIoI4HI68YCHjlk9njlr4RERqJYdG46yomlTslZtz7jnnXG/nXO/GjRt7HUekVvP5fFx22WXMmTOH3r17c9FFFzF48GCWLFnidbQaZfnW0YRc7jbrHEVk5s8kv2i1R6mqzqR18/GV8WlrfqiQb9bM8yBRdMovWsuWvOkUBHfUMUZERGqrmlTsrQBaF7vfKrJORGqADh068NVXXzFq1Ch+/PFHunTpwn/+8x+18pVTQbDsXgpGICbf6Mf5/JiVLvZ8+Ijz+ct4RO0ScgXMXXs1Py4/jJlrLmLSsgH8tv4OnAt6HU1EpApV/rQLmnoheowDzomMytkX2OKcW+V1KBEpP5/Px/Dhw5kzZw77778///znPxk0aBCLFy/2OlrUa5B0MEZcmdtS4vbY7eNvyp3E9JX/xw9/dubn5YeyJvOD3T7m7ji4yT6EyvggIODzcVSL7h4kii4LNv6b9TlfE6KAoMvEUcDq7A9ZsmW019FERCSKRE2xZ2ZvAj8Ce5nZcjM738yGm9nwyC6fAIuABcDzwCUeRRWR3dSuXTu+/PJLnnvuOX7++We6du3K008/TSgU8jpa1GqddiEBX91tCj6fJdGh/o34fAm7dezNuVOYt/Zisgt+xVFAXtEyFmy8nZVbX9vd2LusXnwy93YfQoIvjiR/PIm+OOJ9AS7fazDtU5t4lisaOBdiZdY7hMjfZn3I5bE882WPUomIVA9NvVAxAa8D/MU5d/pOtjvg0mqKIyJVzMy48MILGTx4MBdeeCGXXXYZ77zzDqNHj2aPPXa/pSrWxPsb0bvlf1m+5UU25k4kIdCU1nUvoF7S/rt97D83jSDk8rZZF3K5LNn8GM3rnI6ZN90mBzZL59MG7fl+7W8UuSD9G+9F48S6nmSJJo4iQq6gzG1FocxqTiMiUr1ifUCVyhY1LXsiUju1adOGzz77jNGjRzNjxgy6devGE088oVa+MsT7G9KhwfX0bjmOrk2fr5RCDyCncGGZ64OhHM+Lh7T4ZP6v1b6c0Ho/FXoRPosnJa5DmdvSEnpWcxoREYlmKvZExHNmxnnnnUdGRgYDBgzgyiuv5JBDDmHBggVeR6sVEgOty1zvswQCvtRqTiPlsWfDO/FZIv/7N+7Hb8l0bHCTl7FERKpUuNulpl6oCBV7IhI1WrVqxfjx43nppZeYPXs23bp147HHHiMY1AiDValt/asjhcP/+CyJVmkXYRY1vf2lmPqJ+9G7+Ts0TTmW1Ph9aJF6Evu1+Ig68Xt7HU1ERKKIij0RiSpmxrnnnktGRgaHHXYY11xzDQcffDC///6719FiVsPkgezZ8CES/M0BHwFfGm3qXU7rtH96HU12IDV+T9Ibj6BPiw/Zu9E9JMe18TqSiEiV09QLFaNiT0SiUsuWLRk3bhyvvvoqv/76Kz169ODhhx9WK18VaZx6DH1aT+TAtnPp23oardMuKnOeOxEREak5VOyJSNQyM8466ywyMjIYPHgw119/Pf379+fXX3/1OlrM8lm8irxdFAzlEQzl7XxHERHZZZp6oWJU7IlI1GvevDkffPABb7zxBvPnz6dnz5489NBDFBUVeR1NhLyiFcxafTaTlu7LpKX7MnPVWeQWLvM6lohITNIALRWjYk9EagQz4/TTT2fevHkcc8wx3HjjjfTr14+MjAyvo0ktFgrlM2PVKWzO+xlHEY4ituRPY8aqU2t1K9/G3MnMXH0BU1ccz8KNj1IQ3Oh1JBGRWknFnojUKE2bNuXdd99l7NixLF68mH333Zf7779frXziifU5X1IUygaKzwsZIuRyWJ/zRYWOFXIFFAY342p4n6JlW19h9tpL2Jg3kazC31i6dQxTVx5PYXCT19FEpIZzVH6rnlr2RESijJlxyimnkJGRwXHHHcctt9xC3759mTNnjtfRpJbJLVpGyJVuwQu6XPKKyteVM+QK+GPDPUxa2psflx3IlOUHsTbrs8qOWi2CoRwWbnqEkMv9e50jXMQu2/qKh8lERKqGmTUwsy/N7I/I1/o72LeumS03s6eqK5+KPRGpsZo0acI777zD22+/zdKlS+nVqxf33nsvhYWFXkeTWiI1fm/8JeYoBPBbEinxe5XrGH9suIvVWe8Qcnk4CikIruX3DTewOfenyo5b5bIKfscoPTejo4D1ud9VfyARiTmuCpbddCPwtXOuE/B15P723AN8v/unLD8VeyJS4w0ZMoSMjAxOOukkbrvtNvbff39mz57tdSypBRokHUxCoCVG/N/rjDgSAi1omHTITh9fFMpkTdZHpVoHQy6PJVueqey4VS7O3wBH2V2qE/xNqzmNiMQcF5UDtBwPvBy5/TLwj7J2MrNeQFOgYn38d5OKPRGJCY0bN+bNN9/kvffeY8WKFfTu3Zu7775brXxSpcz89Gz+Fs3rnELAV4+AL43mdU6hZ7O3MCvdwlVSQXAdvu3sl12woLLjVrnkuLakxu0NJVr3fJZEm7pDPckkIlIOjcxsWrHlogo8tqlzblXk9mrCBd02zMwHPAJcVwlZK2Tn/4lERGqQE088kQEDBnD55Zdzxx138P777/PSSy/Ro0cPr6NJjAr46tCp4e10anh7hR+b4G9ByIXK3FYU2kQwlI3fl1Lm9sLgJtZm/5f8ojWkJfaiQdLBmPkrnKGydWv6DLPXXkpWwa8YARxBOta/gfpJfb2OJiKxoGrGsFrvnOu9vY1m9hXQrIxNtxS/45xzZlZWwkuAT5xzy6t7LlsVeyIScxo2bMgbb7zBqaeeyvDhw9lvv/24+eabueWWW4iPj9/5AUSqid+XSP2kA9mY+3WpbWYB1mV/TrM6J5batjV/FrNXD8URJOTyWJGZTGrcXnRv9go+X0J1RN+ueH9Dejd/i9zCZRSENpIatyd+X5KnmUREdodzbtD2tpnZGjNr7pxbZWbNgbVl7HYAcJCZXQKkAvFmluWc29H1fZVC3ThFJGYdf/zxZGRkcPrpp3P33XfTu3dvpk+f7nUskW2Euz2WFnKFFATXlVrvnGPe2isIuuy/r/ULuRyyCn9lRearVZq1IpLiWpOW0F2FnohUqii8Zm8ccG7k9rnAR6UzuzOdc22cc+0Id+V8pTyFnpkdambtI7ebm9nLZjbGzMpqZSyTij0RiWkNGjTglVde4eOPP2bDhg306dOHW265hfz8fK+jiQBQL6k3Pksutd5n8aQllu5VlFu0mMLQ5lLrQy6P1VkfVkFCEZHo4VzlL7vpQeBwM/sDGBS5j5n1NrMXdvPYzwDByO1HgDjCE7s+V94DqNgTkVrh2GOPZe7cuZx99tncf//99OrVi59//tnrWCLUS+xHnfiu+IpN4eCzRNISe1M3Yd9S+xt+tnfRSnibiIhUF+fcBufcYc65Ts65Qc65jZH105xzF5Sx/0vOucvKefiWzrmlFh7xazBwEfBPoF9586nYE4kxoaKl5G7+F1lrDiF7wzkU5de8ubqqSv369RkzZgyffPIJmzdvpm/fvtx0003k5ZWeFFukupgZ3ZqNpn2960iJ24fU+M50qP8vujT5D2VdyJ8YaEOCv3QPHp8l0bzOkOqILCLiCUdUduOsSlvNrCkwAJjnnMuKrI8r7wFU7InEkGDRYrLWHUVhztuEgosI5n9HzsZzKMgZ53W0qHLUUUeRkZHBsGHDePDBB9l333356ScVxeIdn8XTKu0cerf8iF4tPqRl3TPxWdn/y82M9CZPEfCl4bcUjDh8lkS9xP1pUee0ak4uIiJV6EngZ+B14OnIugOB38p7ABV7IjVcKLiO/OzXyc9+hbwt94DL5n/duwGXS/7W23EuuN1j1EZpaWm88MILfPbZZ2RlZdGvXz+uv/56cnNzvY4mslMp8XvSt9VE9mx4D+3rX0v3pi/Tpcmz5ZrbT6S8ikJZ5Bau0P8PiR4OcFb5S5Ryzj1E+DrAA51zb0VWrwBKdQ/dHv1XEKnB8nPeI3fzv8B8kSuMw90RfWz7h8u5HFxwNRZo6UHK6DZ48GDmzp3L9ddfz8MPP8y4ceMYM2YM/fqVuzu8iCf8vkSapB7rdQyJQcFQDhnrbmFtzjeY+fBbMns3vJVmqUd5HU2kMgZUqWkWA33NrLdzbizhYq/c1LInUkOFgmvChR754HL5q9ADcCUHb3AhzJdWrflqkrp16/Lss8/y5Zdfkp+fT//+/bn22mvJycnxOpqISLWbvfY61uV8g6OAkMujMLSRjPU3szlPU9eIVCcz6wrMB54HRkdWDwBeLO8xVOyJ1FCFeZ8BZXc92LbUSyCQdDTmS62GVDXboEGDmDNnDsOHD+fRRx+le/fuTJw40etYIiLVJr9oLRtzJxGiYJv1IZfH4s3Pe5RKpBhXBUv0GgXc7pzbGyiMrJsA9C/vAVTsidRULkjZf6EMCIClAgkEEgeSlPZQ9WarwerUqcMzzzzD119/TVFREQMGDOCqq64iOzvb62giIlUuL7gWs/gyt+UWLa/mNCK1XjrwWuS2A3DOZQNJ5T2Aij2RGiqQOGg7WxJIbfgeKY3eIbXpZJIbPIv5yv03QSIGDhzInDlzuOSSSxg5ciTdu3fn+++/9zqWiEiVSolrj6OojC0B6if2rvY8Ituq/GkXonzqhT+BXsVXmFkfYEF5D6BiT6SG8gfakFj3WiAR8BP+dU4iIeV8Agn74o9Lx+dv7G3IGi41NZWnnnqKb7/9FuccAwYM4PLLLycrK2vnDxYRqYECvhTap12Ez4p/SOgj4EuiXb0LPcslUkvdBow3s7uAeDO7CXgHuLW8B9BonCI1WGLqP4lLOIyC3I+BIHFJRxOI6+J1rJhzyCGHMHv2bG6++WaeeOIJxo8fz4svvsghhxzidTQppyXZqxm/6gfW52+mT4N0Dm3SiwR/2V3VRGq79vWGkxzXhj+3vEB+cAMNEvuyR/3LSQq08DqaSLRfY1epnHP/NbMjgQsJX6vXFjjROfdLeY9hLsbHL+3du7ebNm2a1zFEJEZMnDiR8847jwULFnDJJZfw0EMPkZqqwW+i2aR1sxjx+6sUhoKECJHgi6dJYn0e73ENyYFEr+OJiHjGzH5xztWY/rkJ7Vu55ndfVunHXXLOTTXqdagIteyJiFTAQQcdxKxZs7jlllsYOXIkn3zyCS+88AKHHXaY19GkDIWhIh6b/wb5ocK/1+WHCliTu4GPV07k1DaHe5hOarvNeTOZv/FBtub/Sry/Hm3TzqNN3XMwi+priESkmpjZ3dvb5py7vTzH0DV7IiIVlJyczGOPPcbEiROJi4tj0KBBDB8+nK1bt3odTUpYnL2SUBl9fgpcERPXzfAgkUhYZv5v/LJ6GFvyZ+EoID+4lgWbRrJg02NeRxOJbrVr6oXWJZb9gOuAPcp7ABV7IiK76MADD2TWrFlcd911PP/883Tt2pUvvvjC61hSTLI/gZALlb0toFFqxTuLNj9DyOVvsy7kclm69RWKQprqRUTAOTesxHIUcCKUOWRumVTsiYjshqSkJEaMGMGkSZNITk5m8ODBXHjhhWzZssXraAK0Sm5Ks8SGGNt2i0v0xXNci4M8SiUCmQW/UlaTghEgr2hV9QcSqTGsCpYa5QvgH+XdWcWeiEgl6Nu3LzNmzOCGG27gxRdfpEuXLnz22WdexxLgjvQLaZxQnyR/Asn+BOIswFHND+TARt29jia1WEpc2b2wHEUkBppVcxqRGqQWdeM0sw4lli7AvcCy8h5DA7SIiFSSxMREHnroIU466SSGDRvGUUcdxbBhw3j00UepV6+e1/FqreZJjRjT5zYytixic2Em+9RtT6OEel7HklquQ71/sjHvJ0Iu7+91PkukReqJBHwa4VdEgPDk6Y7/NT/mADOAc8t7ALXsiYhUsj59+jB9+nRuvvlmXnnlFdLT0xk/frzXsWo1n/noWq8jBzXuqUKvmmUV/M7iTY+zeNPjZBX87nWcqJGW2J0eTZ8iOdAeMPyWQtu657J3w5u9jiYS3WpRy55zzuec80e++pxzqc65gyoyz56KPRGRKpCQkMB9993HTz/9RIMGDTj22GM599xz2bRpk9fRRKrNks1PM2PVEJZu+Q9LtzzLjFVD+HPTU17HihoNkw7kwNafcFi7WRza9mc6NrgKM7/XsUQkhqjYExGpQr169WLatGncdtttvPHGG6SnpzNu3DivY4lUuZzCRSzd8p9IN8UQECTk8li29VlyChd5HS+q+CxOc+uJlIcDnFX+EkXMbJmZLd3ZUt7j6Zo9EZEqlpCQwN13380JJ5zAsGHDOP744znzzDMZOXIkDRs29DqeSJVYn/M1zgVLrXcuyPqcr2mT1sGDVCJS07ko7nZZSc6qzIOp2BMRqSY9e/Zk6tSpPPDAA9x777189dVXjBo1ihNOOMHraCKVzvBTdgciX2SbiIiU5JybUJnHUzdOEZFqFB8fzx133MG0adNo3rw5J554Iqeffjrr16/3OppIpWqcMrjMrolmRuOUwR4kEpGYUIsGaAEwsx5mdrmZ3WVmd/+1lPfxKvZERDzQvXt3pk6dyj333MN7771H586deffdd72O5a158+Cii6BBA4iPh65d4cknITfX62SyCxIDLdmj/q34LAGfJeKzRIwE9qh/K4mBll7HExGJemZ2ETAJGAj8C+gKXAt0LO8xVOyJiHgkLi6OW2+9lV9++YU2bdowZMgQTjnlFNauXet1tOr3xRcwYACFrZoyd8Kj/LDwP6wacSXus09h0CDIyvI6oeyCFnVPpU/Lr9ij/k3sUf8m9m/1FS3qnup1LBGpyWJ8gJYSbgCOdM6dAORGvp4MFJb3ACr2REQ81rVrV6ZMmcL999/PRx99RHp6OmPHjsXVgqvQAdi6Fc44g/VvPs7Tp2TwReBDJme+w1ttx/PWk+mEOnaAmzX3WE2VEGhKi7qn06Lu6SQEmnodR0SkJmninJsYuR0yM59z7lPg/8p7ABV7IiJRIBAIcNNNNzF9+nTat2/Paaedxsknn8yaNWu8jlb1Xn0VN3Ag77T5jIJQLkUuH4BCl8eq/D+Ye/0h8NprkJnpbU4REfGcucpfothyM2sXuT0fON7MDgIKynsAFXsiIlEkPT2dyZMn89BDDzF+/Hg6d+7Mm2++GdutfD/8QNaRB5AXLN1Vs8jlMz15Buy5J8ya5UE4ERGJGlUxOEt0/3v9N7BP5PbdwGvAN8Bd5T2Aij0RkSgTCAS44YYbmDFjBp06deKMM87gxBNPZPXq1V5Hqxpm4MBt5z+uD194YiVNOi0iIrWIc+6lSLdNIl/rA/Wdc6PKewwVeyIiUWqfffZh0qRJjBgxgk8//ZTOnTvz2muvxV4r34ABpP73e1IC9UptClgC+2b1gAULoEeP6k4mIiJRpQoGZ4niAVrM7HEz2++v+865AudchUYsU7EnUkJ+0TLWZ7/P5txvCblyD3YkUiX8fj/XXXcdM2fOZO+99+bss8/m+OOPZ+XKlV5HqzxnnolNmsQpfwwkwZdCnCXiw0+cJdImsQvp930GQ4dCSgq5hYtYuOF2MlafxbLNT1AY3Oh1ehERkapiwEdm9kdknr29KnqAQBWEEqmRnHMs3XQ367LewMwPGD5LYu8mb5AUv6fX8aSW23vvvZk4cSIjR47klltuIT09nccff5xzzjmnzImra5TUVHjnHeoPGcJlw85h4cnpZKY52s4toOGTYzGfD156mS15P/Lr2gsIuQIgyNb8X1iV+Srdm48jIdDc62chIiLVIcY6t+yIc+5KM7saOAw4HZhiZouA151zj5bnGGrZE4nYnPsF67PH4sgn5HIIuWyKQuuZv+682Os2JzWS3+/nmmuuYfbs2XTp0oWhQ4dy7LHHsmLFCq+j7b4BA+DHH/EXBNnzpDvotf+1NHpoDHbWWfDpp7jERBas/xchlwsEAXDkUxTazNLNj3mbXUREqk/tGqAF51zIOfelc+48oAuwARhR3ser2BOJWJv1GiGXU2p9UWgjuYXzPEhUPiGXj3Mhr2NINerUqRMTJkxg5MiRfPvtt6Snp/Piiy/W/A8l9tgDHnsMli6FTZvgp5/g/PMhPp7C0HoKgmVNNh9kc+531Z1URESkWphZipmdZWbjCU+/UAScW97Hq9gTiQiGsrezxUfQ5VVrlvLIyv2WP1b147flHfl9xd6s2Xw/zhV5HUuqic/n44orrmD27Nl0796d888/n6OOOoply5Z5Ha1K+C2J7X386velVm+YSuScY0thDvlBXR8sIlIutahlz8zeAdYAFwH/Bdo65452zr1W3mOo2BOJaJh8HGZJpdYbkBLftfoD7UBO/jSWbbiQwqIlQIiQy2Zj1ous3nS719GkmnXs2JFvv/2Wp556ih9++IH09HSef/75mt/KV4Lfl0q9pAEYcdus91kSzeuU+wPOqPLzhgWc/MO/+b/v7uPwb+7kjtlvkVOU73UsERGJHj8DnZ1zBzvnRjnn1lf0ACr2RCIa1zmN5Lg98VlyZE0cPkukfcNH8Fm8p9lKWrf1cZzL3Wadc7lszn6LYCjTo1TiFZ/Px6WXXsrs2bPp3bs3F110EYMHD2bJkiVeR6tUnRqOICW+Cz5Lwm91MOJplHwczeqc7XW0CluYuZrrZ7zMytxNFLoghS7Id2vmcvOscn9YKyJS+zhq1dQLzrl/O+eW7s4xoqbYM7Mjzex3M1tgZjeWsX2oma0zs5mR5QIvckrs8lkiezd9l3YNHqJh8ok0q3M+6c0+pX7yYK+jlVJQuKDM9WYBioIxOvG27FSHDh346quvGDVqFD/++CNdunThP//5T8y08gX8aXRr/h5dm71Pp0aPsm/Lb+nY6AHMouZfWbm9sWQihaFtu10XuCJmbFrMyhxNJyEisj3mKn+JZVHxH9LC49w/DRwFdAZON7POZew61jnXI7K8UK0hpUoVBDeQV7jM8zelPoujYcr/0aHRo7SufyOJce09zbM9iXHphDuYbssRJM7fsvoDSdTw+XwMHz6cOXPm0LdvX/75z38yaNAgFi9e7HW0SpMSvxcNkg+r0dMtLMleR6iMC0XifQFW5W3yIJGIiMSiqCj2gD7AAufcIudcAfAWcLzHmaQaFBStZdaq05m67CB+WXkUU5cfxKbcyV7HinqN067BLHGbdWZJNEy9GJ8veTuPktqkXbt2fPHFFzz33HP8/PPPdO3alaeffppQSCO3RoPu9doSZ/5S6wtCRbRPafq/FXPnwoMPwl13wfvvQ6EGchGRWq4WDdBSGXar2DOzcyopR0ug+BByyyPrSjrJzGab2btm1noHuS4ys2lmNm3dunWVFFEqm3OO2WvOZmv+dBwFhFweBcHVzFt7MbmFsXWtUWVLjE+nbeO3SYrfDyORgL8FTdNupXHa9V5HkyhiZlx44YXMnTuXAw88kMsuu4yBAweycOFCr6PVeqe27U+CPw5fsRb6RF8cx7bsTYOEVNi4EY45Bo44gtCqVQSLCmHkSGjXDr74wrvgIiJSrcysoZmdbWY3RO63MLNW5X18uYo9M+tcxpIOXLyLuXfFx0A751w34Evg5e3t6Jx7zjnX2znXu3HjxtUWUComM38G+UWr+GuC5L84V8SqzDe8CVWDJCfsS/umH7JP64Xs2eJnGtQZiln0XmQs3mnTpg2fffYZo0ePZsaMGXTr1o0nnnhCrXweapKYxpi+lzOgSRfqBJJokdSAf+55JNfufRwUFcExx1DUoT0PjH+cg49J48ADHWfffzJ/Pvs4nHVWeA5CERGJaWY2APgdOBO4LbK6EzCqvMcIlHO/KcC7lL5IqG15T7QTK4DiLXWtIuv+5pzbUOzuC8C/K+nc4pH84GqszOvOCskr3K2Bh0SkBDPjvPPO44gjjuCiiy7iyiuv5N133+XFF1+kY8eOXserlVolN+T+HmeW3vDxRwBcfXZPZqybS0FkIJffM1dxbsIGPrzzFurffTeMH1+dcUVEpPo9DpzqnPvazP66oPsnwpfAlUt5u3H+ClzvnBtWfAFmVSju9v0MdDKz9mYWD5wGjCu+g5kVvxL/uEgmqcHqxHclROlJwH2WRFrSAR4kEol9rVq1Yvz48YwZM4bZs2fTrVs3Hn/8cYLB4M4fLNXj1VdZP+xMZm5e8neh95fCUBGvHNAKJk2C9RWebklEpMarZaNxtnPOfR25/VfSAsrfYLfjYs/M/jrQ4cDmktudc8eU90Q74pwrAi4DPidcxL3tnMsws7vN7LjIbleYWYaZzQKuAIZWxrnFO4lxrWmSfCy+YhOZG3HE+erTNPVED5OJxDYzY+jQoWRkZDBw4ECuvvpqDj74YH7//fdyPT7kisgsWExe0Yad7ywVt24dq5qmEecr/b+8yIX4vXATNGmiYk9EaqdaNM8eMM/MSs4BNgiYU94D7Kwq/NTMTnDOba1wtApyzn0CfFJi3e3Fbt8E3FTVOaR6dWr0AHUye7Ay8xWCoRwapRxB67R/EvCleh1NJOa1bNmSjz/+mNdee40rrriCHj16cO+993LVVVfh95ceKRJgeeaXzFh/HyFXgHNBGib1pE/TB0nw16ve8LGsZUtaL11PwV6lez7E+fz08DeANWugadMyHiwiIjHkWuC/ZjYeSDKzZ4H/owKzFuysG+dMYJKZtfhrhZkdbGYTdyGsSClmPprXPZ1eLT+lT+sJdGhwC3H+Bl7HEqk1zIyzzz6befPmccQRR3DdddfRv39/fvvtt1L7bszL4Jd1t1MY2kLQ5RKigPW5v/Djqis9SB7Dhg2j3gsvcUiDPUko1rpnGAm+OM74Zj4ccQTUr+9hSBERD1TFtAtR3I3TOTcF6AZkAC8Ci4E+zrmfy3uMHRZ7zrnrCY/2MsnMTjOzL4G3gQ93NbSIiESf5s2b8+GHH/L6668zf/58evTowYgRI7a5lm/B5lcJuvxtHucoYkvB72QWaLqUSnP44dCiBXc/Mp7zGvWifnwKCb44+jXqxNgVzUkd8SjccYfXKUVEpIqZWQKwzjn3b+fcpc65B4E1kfXlUp4BWn4EtgKvE54Lr71z7pFdSiwiIlHLzDjjjDPIyMjgqKOO4oYbbqBfv37MmzcPgOyilZT1EagRR15Qc5pWGp8P3n8fX3Iyww4byufPzWHie6t57MwHaPzIk/DJJ9Cli9cpRUS8UYta9ghPN9erxLpehMc5KZedDdDyAfAd8B5wIjAYGFihiCJSI2zO+Zg/Vh/Jryt7s3TD5RQUqaWmtmrWrBnvv/8+b775JgsXLqRnz548+OCDNIjrjY/4UvuHKCAtfk8PksawpCQYPRp+/RWOPBJ69oQxY2DWLOjd2+t0IiKeqWWjcXYlPNVCcVOB7uU9wM4GaJkPnO+c2whgZouAcWbWzjn3dEWSikj0Wrv1KdZuHYlzuQBsyfmIzNyv6NTsS+IDraCgAN5+G158EZYtg4YN4cwz4dxzoW5dj9PXDM45gsEVmCXh9zf0Os5OmRmnnXYaAwcO5JJLLuGmm27i3fd6MOzeBFp0DOAi06b4LYlOaWcR79fPQZVo1gyGDvU6hYiIeGML0BRYXWxdUyC7vAfY2TV7//qr0IvcnwP0By6sWE4RiVahUM42hV5kLSGXy7qtT8HWrTBwIDz/PEvPPItPH36UXy+7HDdhAvTqBUvUArgz+fmTWLNmP9auOZg1q3uxft0QgsG1XscqlyZNmvDuu+/y9ttvs3TJCq7+v+l8PboBCa4F9RO60KvJnezT4J9exxQRkdoiyrpxmlkDM/vSzP6IfC1z9Cwza2NmX5jZr2Y2z8zalePw7wFvmFkXM0s2s67AK4THUCmX8k6q/jfn3ArgoIo+TkSiU37RQoyyhtkvIjt/ClxyCcG99mLoxZdx7OZs/rXgT05fu4mjBv8f2cOGwckng4vuPhBeKipawsYN5xAKrgTygAIKCn5iw/pTcTXodRsyZAgZGRmceOKJPP3AF9x2yioabryeVqlHYBbVcxSJiIhUpRuBr51znYCvI/fL8gowwjm3D9AHKM+nvrcQnoN8KpAJTAF+B24ub7gKF3sAzrnMXXmciESfgL8pzhWWuS1xfUMYP55RJ53KtJWryS0sIrewiOyCQpZs2szVHfeBzEyYNKmaU9cc2Vkv4VzJ+dKKCAaXUVg4w5NMu6px48a89dZbvPfee6xYsYLevXtz1113UVBQ4HU0ERGpLaKsZY/wnHcvR26/DPyj5A5m1hkIOOe+BHDOZTnncnZ2YOdcnnPuUiAFaAakOucuc87llTfcLhV7IhI74vxNSE08BGPbUXzNkmgyvTsMGsTrCxeTX7RtwVIUCjHxz6UUnXgSfF7uQaFqnaLgYqCsYtpHMLiyuuNUihNPPJF58+YxZMgQ7rzzTvr06cPMmTO9jiUiIjGuKgZniQzQ0sjMphVbLqpArKbOuVWR26sJX1NX0p7AZjN738xmmNkIMyurW1Xp52yWBuxHeLCWQ81soJmVe8BMFXsiQpuGT1I36QiM+PAAIr76tKw/gkRrBwkJFBaba604BwQTEqCoZMuV/CUh/kAgqdR65wqJiyv3YFpRp2HDhrz++ut8+OGHrFmzhv3224877rhDrXwiIlITrXfO9S62PFd8o5l9ZWZzy1iOL76fC1+fUVZbYYDwZXDXES7cOgBDdxbKzIYCK4GPgdHFlhfK+8RU7IkIPl8ybRqNYp+WM9mz2Tfs02Im9VP+ER7i/ZtvOLx9WwK+/12XFfAVcfSe03ns6DcJfTqSzK4FOFd2QVjbJaechs9XH4j730pLIinpeAKB1p7l2hWhUA7rtj7DH6uPZtHaU9iSM57jjjuOjIwMTj/9dO6++2569+7NL7/84nVUERGJVc4qf9nZKZ0b5JzrUsbyEeFJzpsDRL6WdS3ecmCmc26RC1/b8SGwbzme7X3Ayc65ps659sWWDuV9uVTsicjf/L66xAda83fPgs6dYa+9uOXXuTRMTiEpLoDhuOuw9zi750T2nrEA/9ItLOk3jqUbNCJjWXy+OjRu8jnJKWfj87cgEOhE3bq3U6/+o15Hq5CQy2PB2v9jzZZHySucTXb+ZJZtvJpVm++hQYMGvPLKK3z88cds2LCB/fffn1tuuYX8/HyvY9dKzgXJK1xEYXCN11FERGqDccC5kdvnAh+Vsc/PQD0zaxy5PxCYV45jB4Avdiecij0R2bHRo0l9+im+XZDBPXt34tJ+IfbxraHlc5tofdUmlj1VH+fPJTPvW3IL5nidNir5/Q2pV+9emjWbRpOmE0hNPRezmvXnd3P2RxQULcPxv2vCncthY9bLFBaFrz089thjmTt3LmeffTb3338/vXr14ueff/Yqcq20Jfdr5qzozW+rj2buigP5fc1JFNaQaT5ERMol+gZoeRA43Mz+AAZF7mNmvc3sBQAX7v50HfC1mc0BDHi+HMd+CLjVduNNQ816tyEi1a9DB/jpJ+LMOP7sM7j82FtJP3AJiQuKWPR2I3L2Cw/s4lyQ7PyfPA4rVSUz7xvKGjjMLI7sgml/369fvz5jxozhk08+YfPmzfTt25ebbrqJvLxyDxwmuyi3cD6L1l9CUWgDIZeDo4Ds/OksWHtWjZrmQ0SkJnHObXDOHeac6xTp7rkxsn6ac+6CYvt96Zzr5pzr6pwb6pwrz0XuVwO3AplmtrT4Ut58gQo/IxGpfVq0gMceg4cfZuPKp1hdOBIXt+3fKJ/FEfA18iigVLU4fzPAD5S+NjPga1hq3VFHHUVGRgbXXnstDz74IB999BFjxoxh//33r/qwtdS6zJco/d4hSH7RUnIL55Ac382TXCIilclq12dXZ+3uAdSyJyLl5/dTr8WZWHzpz4mMAHWTBnsQSqpDg9SzMIsvsdbw++qSknBAmY9JS0vjhRde4LPPPiMzM5N+/fpxww03kJubW/WBa6H8omWUVYyDj4Ki1dUdR0SkakRfN84q45ybsL2lvMdQsSciFRLwN6Jdo1cI+BrjsxTMkonzt6J9k7fx+UpPMSCxITGuE60bjMRndfFZKmZJJAT2oH3jsTu9/nDw4MFkZGRwwQUXMGLECHr27MmPP/5YTclrj7qJB2GWWGq9cwVq1RMRqYHMLMHM7jOzRWa2JbLuCDO7rLzHULEnIhWWktiXvVv8QocmH9Cx6cfs1fxHkuLTvY4lVSwt+Wj2aTmT9o3fomPTT+jU7FsS4tqX67F169bl2Wef5YsvviA3N5cDDzyQa6+9lpyc0tcByq5plHoaAV99rNg0Hz5LolHqmcQHmnmYTESkklTdpOrR6jGgC3Am/2uDzADKPQS6ij0R2SVmPpLiO5MYtxdmO5+jRmKDz+JJTuhBYlynXfq+H3744cydO5eLL76YRx99lB49ejBp0qQqSFr7+H112afZpzSuM5T4QFuS4rrQuv59tKp/p9fRRERk15wAnOGc+xEIATjnVgAty3sAFXsiIlKt6tSpw6hRo/j6668pLCzkoIMO4uqrr1YrXyUI+BvQqv5tdGkxkX2af0LD1JP1YYyIxJZadM0eUECJATUjc/VtKO8BVOyJiIgnBg4cyJw5c7jkkkt4/PHH6datG99//73XsUREJJrVrmLvHeBlM2sPYGbNgaeAt8p7ABV7IiLimdTUVJ566im+/fZbnHMMGDCAK664guzsbK+jiYiIeO1mYDEwB6gH/AGsBO4q7wFU7ImIiOcOOeQQZs+ezRVXXMGTTz5J165d+fbbb72OJSIiUaY2DdDinCtwzl3tnEsFmgJ1IvfLMyE7oGJPRESiREpKCiNHjuT777/H7/czcOBALr30UrKysryOJiIiUu3MrMNfC1AHaF/sfrmo2BMRkahy0EEHMWvWLK6++mpGjRpF165d+frrr72OJSIiUt0WEO66uaDY8kdkKRcVeyIiEnWSk5N59NFHmThxIvHx8QwaNIjhw4ezdetWr6OJiIiXatEALc45n3POH/nqA1oAzwFnl/cYKvZERCRqHXjggcycOZPrrruO559/ni5duvDFF194HUtERKTaOedWA1cBD5T3MSr2RGq5olAmK7Y8zdxVx/HbmnPYlPON15FEtpGUlMSIESOYNGkSKSkpDB48mAsvvJAtW7Z4HU1ERKpTFQzOEs0DtGzHXkByeXdWsSdSiwVDOWSsOp4VW54ku2AOW/ImsmD9ZSzfPHKHj8srXExW/mxC5R8MqsZzrpCNW59l0aqDWLRyf9Ztvp9gKNPrWLVK3759mTFjBv/617948cUX6dKlC59++qnXsURERKqEmU00s++LLdOAn4BHy3sMFXsitdi6rLcpCK7Gufy/14VcLiu3jKIwuLHU/vlFK5iz8mjmrDqaX9ecyfRlvVif9VF1RvbMivUXsH7rvyksWkhhcBmbMp9j6ZpjqcDox1IJEhMTefDBB/nxxx+pW7cuRx99NOeddx6bN2/2OpqIiFSHWnTNHvACMLrY8iDQzTmnbpwisnObc78h5HJLrfdZHFn5M7dZ55zjtzXnkFM4n5DLI+SyCLosFm+8keyCedWU2Bt5BXPIyf8BV+y1chRQGFxJZs54D5PVXn369GH69OncfPPNvPLKK6SnpzN+vL4XIiISO5xzL5dY3nXOlXskToBAVYUTkegX529K+DOf0DbrHSHi/A22WZddMJuC4GoguM36kCtg9daX2KPRv6s2rIfyCmaW+cmfc9nk5E+hbsoJ1Z5JICEhgfvuu48TTzyRoUOHcuyxx3LOOefw+OOPU79+fa/jiYhIVYjulrjdZmZ3l2c/59zt5dlPLXsitVizOufis/gSa33E+5uSEt99m7WFwfVYmX8yQpEiMHYF/M0w85dabyQQF2jjQSIprlevXkybNo1bb72V119/nfT0dMaNG+d1LBERqWRGrRigpXU5llblPZiKPZFaLCWhC+0a3I/PUvBbKj5LIimuE3s3fQUz22bf1IQehFxhqWP4SKRe0qHlOp9zjqz8mWzK+YKC4NpKeQ7VISXxUHy+VEr9ybQAaSmneJJJtpWQkMA999zD1KlTady4MccffzxnnXUWGzZs8DqaiIhIRfzinBvmnBsG3PfX7RLLeeU9mIo9kVquceoJ9Gr9C3s1fYUuzcfRrcVnJARKf2AU529I87oX4rOkv9eFW7aa0SR15wVPQdFq5q4axO9rz2DRhmuZvaI/Szfdg3PR95FaSWYBWjf5kIS4bhjxmCUS529L68ZjCfgbex1Pitl33335+eefueOOOxg7dizp6el8+OGHXscSEZHKEvsDtNxX7Pb03T2YrtkTqQbOBVmZ+TYrM18n5HJpnHw0bepdRMBXx+toAPgsgToJPXe6X+v615KS0JU1W1+iKLSF+smDaVZ3KH5fyk4fu2D9xeQV/Unxa/7WZb1BSnx3GqYctxvpq0d8oA3tmn1CUXAtzhUQ8Lcs1fop0SE+Pp4777yTf/zjHwwbNowTTjiB008/nSeeeIJGjRp5HU9ERGRHFpnZI0AGEGdmZbbiOedeLM/BVOyJVIPf1t/A+pyv/h75cvnWMazP+ZxeLcbh9yV6nK5iGiQfQYPkIyr0mPyiFeQU/kbpwV1yWZM5pkYUe38J+Jt4HUHKqUePHkydOpUHHniAe++9l6+//ppnnnmGk046yetoIiKyK6LzGrvKdipwA3A6EAecXcY+DihXsadunCJVLKdwEetzvthmigNHAfnBNazLrh1DxQdDWdh2PlsKhrZWcxqpTeLi4rj99tuZNm0arVq14uSTT+bUU09l3bp1XkcTEZFdEePdOJ1z851zFzjnDgcmOOcOLWMZWN7jqdiTqFMY3My6nG/ZnDcD50I7f0CU25o/Cyg9kmPI5bIpb0r1B/JAUtwemMWVWm/EUz/5SA8SSW3TrVs3pkyZwn333ccHH3xA586defvtt72OJSIisl3OucP+um1mvuJLeY+hYk+iyp+bX+D7ZYcwZ+0NTF99AT8sP5zswj+9jrVbEvxNMUpf22XEk1jGQCixyCxA+wYj8Fkif/3ZMRKJ8zehWd2LvA0ntUZcXBw333wzM2bMoF27dpx66qmcfPLJrFmzxutoIiJSXjHeslecme1rZj+aWTZQGFmKIl/LRcWeRI2NuVNYuPkZQi6foMsi6HLIK1rFjNUX1YgRG7enXuL+BPz1KPnrZuaneZ3aM2x//eTD6dx0HI1TzyAt8RBa1buBLs0/I+BL8zpalQuFstmY+SorNlzBui1PUBRUF0Ivpaen8+OPP/Lggw/y8ccfk56ezptvvlmj/86IiEhMehn4FugNdIgs7SNfy0XFnkSNZVtf3+a6tjBHQXADmQXzPMlUGcz89Gj2OnXi0/FZAj5LIsHfjK5Nnycx0NzreNUqKX5P2jW4lz2bvESzuufh96V6HanKFQXXsWD1ANZsuYstOe+xfuvjLFjVn9yCuV5Hq9UCgQD/+te/mDFjBh07duSMM87gxBNPZPXq1V5HExGRHagFk6oX1xa4xTn3q3NuSfGlvAdQsSdRo3C7A3X4KAplVmuWypYYaMG+Ld6jT8uv6N1iHPu3mkC9xD5ex5JqsGbzAxQF1+EiH2Q48gm5LFZuvNrjZALQuXNnJk2axIgRI/j000/p3Lkzr732mlr5RESiVS3qxgl8AFRsCPQSVOxJ1GiSPChyTde2HEXUTejqQaLKlxBoSlJc2yqbn60olMniTSP5ecVR/LLyJFZnva83rR7LyvuCcPf6beUXzicY2lL9gaQUv9/Pddddx6xZs9h77705++yzOf7441m5cqXX0UREpHZLBD4wsy/M7JXiS3kPoGJPokbLOieTHGiDz5IASJuRR/oNaznoxK0EDjkKHnkENm70OGX0CobymL7yZJZteZ6cwoVkFczhjw138ceG272OVqsZ8dvdYpQeoVS8s9deezFx4kQeffRRvvzyS9LT03n55Zf1gUkNF3L5bMr+gOUbb2Xd1tEUBTd5HUlEdlVVtOpF95/4ecBDwCRgYYmlXDSpukQNvy+JPi3GsjLzQ+JvuI/6n2wkZ9g5zOvVgzr+IO1nfI/v4Yfh44+hd2+v40adNVnjyA+uxlHw97qQy2VN9oe0TruIpLjWHqarveqlnsmGrc/gyCu2NkBq4kH4fMme5ZKy+f1+rr76ao499ljOO+88hg4dyttvv81zzz1Hy5YtvY4nFVQU2swfq4+jKLiWkMvGLJHVWx6hY9P3SIrfx+t4IiI75Jy7a3ePoWJPoorfl0jrt7bAtHjGnj2Sl0d8QVz8BByOlLopPHnrvTQ67jj4/XeoU8fruDu1Nvszlm4ZQ2FoIw2SDqJd2nASAk2q5Fyb8n4oY4AbMAJk5s9SseeRRnUvI7dgOjn5PxFuzTMC/ha0aPCY19FkBzp16sSECRN46qmnuPHGG+ncuTOPPfYYw4YNq7Ju2FL51mx+jMKi5bjIKOXO5eHIY+mGK9mr+RcepxORXRHlA6rsNjM72Dn3feT2didPd859U57jqdiT6BIKwSOP8Nslt/DabV9SmF9IYX74n3ReVh5XPzqdV/r1w157Df75T4/D7tjiTU+zZOvzfxdgKzPHsjb7M/Zv+THx/oaVfr7EQEvCv9Klrw+L9zeu9PNJ+fgsgbaNXyevIIO8wrnE+duQnNBXBUMN4PP5uOKKKzj66KM5//zzOf/883n77bd5/vnnad266j88CYVy2ZL7OYXBNaQk9CY5fl/93FTQ5pz//l3oFZdfuICi4CYC/voepBIR2aFngC6R26O3s4+jnNMv6Jo9iS4LF0J+Pm9+t5q87PxtNjkHW9ZtZWWfgfDf/3oUsHyKQpks2frsNi1tjiKKQpks2/JylZyzRZ3T8VnJz298xPnrk5a4X5WcU8ovMT6deimnkpJ4gN6w1zAdO3bk22+/5cknn2TixImkp6fzwgsvVOm1fHmF85m3cn+Wb7yRVZsfYtHaM1i87hycK/c8ugJYqb+JxbfpLZBIjRTj1+w557oUu91+O4vm2ZMaKj8fUlLI2pxT5mbzGbn4oaCgzO3RIqvg9zIH5nAUsDFvcpWcMymuDelNnibO1wCfJeOzBFLj96F7s1f1pkZkN/l8Pi677DLmzJlD7969ufDCCxk8eDBLly6tkvP9ue5igqHNhFw2UEjI5ZCV/xPrM8s9AJsADVJOxSg5yrOf5IR98fvSPMkkIrunls2zt9v0DlCiS4cOsGYNRxzekYTk0sVSKBii3ar50KNH9WergHh/4zK7DoGRFKi6QR4aJB3EAa0nsW/zd9mv5Wf0avFBpHuniFSGDh068NVXXzFq1Ch+/PFH0tPTefbZZyu1lS+/aCkFweWU/LjZuVw2Zr9ZaeepDZqkXUJyQk98loyRgM9SiPM3pU3DJ7yOJiJSLVTsSXRJToYzz2TQogm03rMFiSkJAPj8PhKS4rnuzv8j8NorcPHFHgfdseS4ttSJTy81tL7PEmiddl6VntvMT0p8RxV5IlXE5/MxfPhw5syZw/7778/w4cM5/PDD+fPPPyvnBC60/U0uWDnnqCV8lsgeTcbSocmbtKh/K20bPcU+LSYRH2jhdTQR2VUx3o2zsqnYk+hz9934p/3MU13Xcf0tR9Lv+P04augAnr/7IAY8fRPcfDN07Oh1yp3q1uQZ6iXuhxGP35IJ+Oqyd8P7SEvo7nU0EakE7dq148svv+TZZ59l6tSpdOnShVGjRhEKbb9YK4/4QFvifKUHVTISqZ9y0m4duzYyM1IS9qVRnaHUTRq0w+v4RERijcX6ZLG9e/d206ZN8zqGVNSWLXD//TBmDMTHQ1YWdOkC118Pxx/vdboKKQiupzC4haS4tmUMoCIisWDp0qVceOGFfPHFFxxyyCGMHj2aDh3Kff18KTn5M1m49nQcQZzLxWcpJMZ1Yo8mb+PzJVVichGpzczsF+dcjZm8OKlpa9fxzGsq/bhzH7umRr0OFaFiT6JbQQGsWQNJSdCokddpRES2yznHiy++yDXXXENRUREPPfQQl1xyCT7frnWiKQpuYnPORxQWrSIlsQ91Eg/BzF/JqUWkNqtpxV5yFRV7c2K42IuabpxmdqSZ/W5mC8zsxjK2J5jZ2Mj2n8ysnQcxpbrFx0Pr1ir0RCTqmRnnn38+c+fO5eCDD+byyy/n0EMPZcGCBbt0vIC/Po3qDKV5/Zuom3SYCj0REamwqCj2LPwf7GngKKAzcLqZdS6x2/nAJudcR+Ax4KHqTSlVIbdwBRtyJpFbuMLrKCIilaJ169Z88sknjBkzhlmzZtGtWzdGjhy529fyiYgIGqClgqKi2AP6AAucc4uccwXAW0DJC7OOB/6ajfpd4DDTzMQ1VsgVMGvNlUxecQyz1l4V/rrmCkIuuufPExEpDzNj6NChZGRkMHDgQK666ioOPvhg5s+f73U0ERGpRaKl2GsJLCt2f3lkXZn7OOeKgC1Aw7IOZmYXmdk0M5u2bt26Kogru2vBxsdZnzuBkMsn6LIIuXzW53zPHxsf9zpazAqG8li+5SWmrxrCrNVDWZ/9ZaXODfYX50JVclyRmqhly5Z8/PHHvPLKK2RkZNC9e3ceeeQRgkFNoSAisis0qXrFREuxV6mcc88553o753o3blx6+Grx3vLMtwm5/G3WhchnRebbHiWKbSFXwMzVp7F486Nk5s9ic95kfl1/HYs2PVhp58gpXMys1efw/ZLOTFzSld/W/YuiUGalHV+qXzC0laLgeq9j1Hhmxtlnn828efM44ogjuO666+jfvz+//fab19FERGoedeOskGgp9lYArYvdbxVZV+Y+Fp4kJw3YUC3ppNIFXW6F1svuWZf9KTmFfxJyeX+vC7lcVmS+QV7RKnILl7Jsy4ss3zKGvMLlFT5+YXAzM1adwua8n4AQjgLWZo9n1upz1cpXAxUG17Jo7en8uqI7v63sw/xVh5CTP9PrWDVe8+bN+fDDD3n99deZP38+PXr0YMSIEWrlExGRKhMtxd7PQCcza29m8cBpwLgS+4wDzo3cPhn4xuldZI1VL6FHhdbL7tmQ8x0hl1NqveFn0caHmbbyGBZveoRFmx7h55VHsWLr6xU6/uqs9yIttf/7lXQUkFO4iMz8WbsbX6qRcyEWrR1Cdv6POApxFJBftIDF606lMLja63g1nplxxhlnkJGRwdFHH80NN9xAv379mDdvntfRRERqBrXsVUhUFHuRa/AuAz4HfgXeds5lmNndZnZcZLfRQEMzWwBcA5SankFqjr0b3obfUjDCk4wbAfyWzN4Nb/U4WdULhnJZm/0ZKzPfIbdw2c4fUAkSAk2AMiZ0d471OZ8Rcvl/v7EPuXwWbXqQvKKV5T5+VsGv27QaFpdTuGgXU4sXsvN/oii4GijaZr1zhWzMetObUDGoWbNmvPfee7z11lssXLiQnj178sADD1BUVLTzB4uIiJRTVBR7AM65T5xzezrn9nDO3RdZd7tzblzkdp5zbohzrqNzro9zTu8ga7A6CXtzQMuPaFX3dOol9KJV3dM5oOU46iTs43W0KrUlfxY/LOvPr+tvZv7G+/hp5TEs2PjvKu/q2Dz1FHxWstgzzHyU9ZGWc7A+58tyH79OfDo+SyxjiyM5vmOFsoq3CoNld+MNt/AtrOY0sc3MOPXUU5k3bx7HHXccN998MwcccABz5871OpqISHSqgsFZNECLSBVJimvJ3g1vZr8Wr7F3w5tJiis5AGtsCbkiZq+5mKDLIuiyCblcQi6f5ZlvsClvcpWeOzl+D/ZuNAK/peK3VHyWRGKgNc1Sh2yn94ILV3zl1Cz1JPyWRPE/KUY8qfH7UCe+6+7Gl2qUFN8NR+lryMySSYnf34NEsa9Jkya88847vP322yxZsoR9992Xe++9l8LCQq+jiYhIDadiT6SabMn7pcx5BEMul5XVMApp45TB9Gszha5NR9Oz+Vj6tPySFnVPK6PFL9zi0Ch5ULmPXeSy6djgDuonHogRj99SaF5nCN2ajkbTYdYsiXF7kZpwMLZNS20cAV896qWc6Fmu2mDIkCFkZGRw4oknctttt7H//vsze/Zsr2OJiEQXXbNXISr2RKpJeACTsguf6hqF1GfxpCX2JDV+b8yM5LgOtE27FJ8lYAQw4vBZAu3rX0diXKudHi8YymXumuH8vOII5m+4jS15U2lR93QObDOdTg3v4P/bu+/4qKr8/+Ovz0wmnRKSEAhFxJ6EIiAirIgFReyKZa0suui6rqKyu7o2RLEhrq7ugxWXL3ZRUVR+6lqwYEGERUoCFlSkI50U0mbO749EFyWBDJnJTSbv5+NxH8zcuXPvO3NnJnxyzj3H70tpgJ9KIm2fjEdp23IUAX8n4nwZtEk5j/2z3tT5bACZmZlMnTqVl156idWrV9O7d29uv/12yst3/UORiEhz1Ni6cZpZGzN7x8y+qf43rZbt7jOzAjNbamb/sAb6a7iKPZEG0jqxT43d43yWRFbKqTU8o2F0bn05vbNfo0vaKLqkjaJP9ut0bHnJnp8IfLNpDFtKPyHkygi6QkKUsbbwBdYUhjeapzQuZgHatryKg7Nnc0iHBXRoczdx/nSvYzUrZ555JgUFBZxzzjmMGTOGvn37smDBAq9jiYjIrm4AZjrnDgBmUsMgkmbWHxgAdAfygMOAoxoinIo9kQbi9yVzSPpd+Czx51FIfZZM64TetE0Z0uB5dh4UJjmwL51bjaRzq9+TFOhcp+eHXNVcelUtljuv38Gq7VMimlWkOcrIyOCZZ57hlVdeYf369Rx22GHcdtttauUTkeat8XXjPA14ovr2E8DptaROBOKBBCAArK/3keughrHYRSRaslKH0iIhl7VFL1MZ2kZ60tGkJx1ZPSrmXioqgnfegW3bYP/9YcAA2E3PgHVFM/h2ywTKgmtJ8Gexb+tryG5xVtiHDYZKqO0bsjK0Lez9iUjNTjvtNI488khGjRrF2LFjmT59Oo8//ji9evXyOpqISKzIMLN5O92f5JybVMfnZjnn1lbfXgdk/XoD59xsM3sfWEvVNT2POOeW1itxHallT6SBJQf2Yb+0azkofQwZyUftfaEXCsHtt0PnzvCvf8F778Hll0NOTtXtGqwrep0vN91MWbDqO6ksuJ6vN9/BmsJpYR8+zteKhLhdvs8Ao1VC37D3JyK1a9OmDU8++SQzZsxg48aN9O3bl5tvvpmysrI9P1lEJIZE6Zq9jc65Pjstvyj0zOxdM8uvYTlt5+1cVbepXf4Sbmb7A4cAHYEOwDFmdmS0XqOdqdgTaaquuw739tvMuv9pftfyFM5Yk8sNx9zA2utuhvPOg1mzdnnKd1sf2GXy85DbwXdbHwr78GbGAeljq+fXq/oqMQL4LZWubf68Vz+SiOzeySefTEFBARdddBHjxo2jd+/ezJs3b89PFBGJBdHowlmHbpzOueOcc3k1LK8C682sPUD1vz/WsIszgM+cc0XOuSLgTeCIvXoNwqRiT6QpWrYMnnmGaeffxPgnF7J65WaKi8qYP/d7Ln9mBT/edjf8edeCq6xybQ07g/LgjzgXCjtGm6TfcGj752mbchKp8bm0b3EefTrMIDmwb9j7EpG6SUtLY8qUKbz++uts3bqVfv36ceONN1JaWrrnJ4uISKS9Bvw0st0lwKs1bLMCOMrM4swsQNXgLOrGKSK1ePxxKi+4iKdeXEhZ6S8nXi4rq+Sxlamwbh3k5//iscS4mieuT/Bn7XV30tT4QzgkcwK9s6dzQPotJMZl79V+RGpSEdzIqs03s2R1X75cM4iNhU/s1R8mYtHQoUPJz8/nkksu4Z577qFXr17MmTPH61giItHV+AZouQcYbGbfAMdV38fM+pjZv6u3mQZ8CywGFgILnXMz6n3kOlCxJ9IUrVzJtg5dMN+uA7E45/jyq/VwyCGwcuUvHuva+vrqbpf/47NEura+LqpxRfZGMLSdb9adyKaiZ6kIrqWs8lvWbB3Hys2jvY7WaLRu3ZrJkyfz5ptvUlhYSP/+/fnrX/+qVj4RkQbinNvknDvWOXdAdXfPzdXr5znnLqu+HXTOXe6cO8Q5l+Oca7D/eKnYE2mK0tNpsW0jlZW7ztsH0KFjGqxYAem/nBstK3UIh6TfQ1JcZ8BHor8DB6ffSfsWp0c/s0iYNhVNpTK0Ffhf67VzO9ha/BrllStrfV5zNGTIEPLz87n00ku57777OPTQQ5k9e7bXsUREIspofJOqN3Yq9kSaogsuIP7pJxk8OIeEhF/OoJKQGOCynokQDEKfPrs8NSv1RI7o+A7HdFlK/07v0S71lIZKLRKW4tLZOLdrC5VZgJLyxR4katxatWrFpEmTePvttykpKWHAgAGMHj2aHTt2eB1NRCRyGl83zkZNxZ5IU9S7N/TsydUFL3DSSXkkJMQRF+cjI7MFt13ak/3v/EvVtAw+fcS95JwjGCrGuUqvo0RUacX3rNn6AKu23EFh6RyqRpqOvPjAvtQ8HWyIeH/7qBwzFgwePJj8/Hwuv/xyJkyYQI8ePfj444+9jiUiIh7Q/wRFmqpnn8WH44oJv+fVnuuZfpzjmcRP6XPNBXDjjVXTLzQloVDV5PD33QcPPghfful1onrZuuNjvlhzDJ+v7MlnK7vx7aZbCLmmPyfaxqIXWLruBNZtf4QfC//NtxsuYfmmUVEp+DJSL6Zq0LKdxREf15mk+J4RP14sadGiBRMnTmTmzJlUVFQwcOBArr32WkpKSryOJiJSL+ZcxJdYpmJPpIkKJQVY9++L+Wr6yWxKXYIVrsAGD4bly2HkSK/jhefzz+Hgg2H0aNz69bivvoJBg+Ckk2DTpnrvvrRyDWu2P8e6wpeoCG6t9/72pKi8gC83jKS08gccQZwr48eiaXyzsWnPP1gZ2srKLTdVd62sBBwhV8K2HW9RWLrrvI71lRDoQtfMxwn4O2AkYsSTmtCPrm2fxWzXwYlkV8cccwyLFy/myiuv5MEHH6R79+7MqmEOThERiU019Y8RkUYu5MqZt/YSisq/Jti+hBWX+fHZRnLST6F9i5ZexwvPkiVw8smsHzeeMT8msuDrNQTi/AwdewrX579FYMgQ+PhjSEjYq92v2DqJH7Y9TNVl3T6+2Xw7h2Q8QEbKcRH9MXa2etu/dmnFc5SxueQdyoMbiPdnRu3Y0VS44yOMAI5f/mwhV8Lm4ldomXRUxI+ZmtifQ7JnUxFci8+SiPOnRfwYsS41NZVHHnmEYcOGMWLECI466iiuuuoq7r77blJTU72OJyJSd83gGrtIU8ueSBO0pvBVCsu/Iuh+6pIVJORKWbppDMFQExuMYdw4Sq66mvP/W8QXX60m5BxlFZW8Pucb/tT2CEhNhZde2qtdF5Ut4YdtjxByZYRcKSFXUvU6bbyOylBhhH+Q/9lRsYyafhv5LJ6yyjVRO25NgqFC1hc+xfLNN/Fj4bMEQ8V7va9du1T+/Ajm27tivG7HNeLjslXo1dOgQYNYvHgxf/rTn3jkkUfo3r0777//vtexRETCotE4w6NiT6QJWlf8OiFXU1HnZ2vZgoaOs/dKSuC113i562GUV1T+ojwqrwiydPmPrDn7Anjiib3a/fri1wi58l3WGz42lUTvP7mp8T0B/y7rQ66cpLguUTvur5VW/MCiNQNZteUuNhQ9w8qtd7J4zSDKK9fu1f5aJh5FzUVsIukpw+qZVhpCSkoK//jHP/jwww/x+/0cc8wx/PGPf6SoqMjraCIiEgUq9kSaoDhfbV2vHH5LatAs9bJ1K6SmsnhzGeUVu84Z6PP5+CGlDaxbt1e7ryr0di1OHC6qI2R2bHVFDZPXJ9GuxQXE+VtF7bi/9sPmm6gMbSNE1R8GQq6EitAmVmwZu1f78/mS6JrxKD5LwmcpmCViJNC2xUhSE3ad5kMar4EDB7Jw4UKuvfZaJk6cSLdu3Zg5c6bXsURE9kxTL4RFxZ5IE9SxxXn4aijq4nwptEro7kGivZSWBkVF9GyTSHyghpawUIguxZshO3uvdp+ZcuIuRRcALkSb5IF7tc+6SAzsQ7d2L9I68Uh8lky8P5vOrf9Ml7S/Re2Yv+ZciO1lnwKhXz0SYuuO9/Z6vy2TBtKtw1w6pd1Bx9a3kJM9k+zW19crq3gjOTmZBx54gI8++ohAIMBxxx3HFVdcwfbt272OJiIiEaJiT6QJykj+Dfu0vBifxeO3ZPyWQsCXxqHtJmHWhD7WSUlwxhmc/s1sEuLj2HmAxfiAn9yu7Wj//FMwfPhe7b5VQh+yUk6tLowNiMNniXRtcwPx/oxI/AS1Sok/mJysJ+jXOZ8+HT8mu+XwBj43htXQlRTArH5jc/l9LUlPHUZmi4tIiOtcr32J9wYMGMDChQsZPXo0jz32GN26deOdd97xOpaISI10zV54mtD/CkVkZ/u3GcWAjm9zSMbtdG/7AAM7f0iL+IO8jgXAttIv+HrTOL7ZdDfbyxbvfuObbiJp4j+Z2j2Bw3P3Ic7vIzkxwJn9D+Ifqz6EsjI444y9ymFmHJA+lu5Zj9Ox5Qj2aXU5vdtPp0PLC/Zqf02JmZGWPATjl4OqGPGkp5zmUSpprJKSkhg/fjyffPIJycnJHH/88YwcOZJt27Z5HU1EROrBojERbmPSp08fN2/ePK9jSBO0rWwx32y+n8LypST429K19ZW0Sx3qdaxG75vNd7O68HlCrhQwfBZP55aX0jXt6tqfNH8+XHxx1cTqgwdDcTG8+ioceSRMnlzV3VPCVhncwtL151IeXI1zQcx8JMbtx8FZz+L3tfA6njRSpaWljBkzhvHjx5Odnc1jjz3GkCFDvI4lIlFgZv91zjWZi65TMjq53JOujfh+5z55fZN6HcKhYk+kBtvLCpi79sLqgqWKz5I4IO06Ore6cLfPDYZKWbV9KmuLZ+CzBDq1PI92KSc3re6Ve6mwbCn/XXfeL143AJ8l0Df7NZIDXWp/snPw0UdVhV8gAEOGwH77RTdwM+BciMKyzyit+JakwIGkJvTVhORSJ59//jnDhw9n6dKljBgxggkTJtC6dWuvY4lIBDW5Yi+9k8uLQrH3+VOxW+xpUnWRGizb8uAuBUvI7eDbrf+gY8tz8dUy31jIVTBv7UUUVSz7+flFG79k047Z5GXeHfXcXttQMrPGqQ6cc2ws+YDOrYbX/mQzGDiwapGIMfPRMrE/LRP7ex1Fmpi+ffsyf/58xo4dy7333stbb73FpEmTGDpUPRxERJqK2G9qENkL28uW1Lg+5CooD26u9XkbSt6juOK7XxSKQbeD9cX/obj8u4jnbGz8vvgaBwUx89VaIDcVzjnWFk5j3upT+GzlIL7ZNJby4CavY4lEVWJiInfddRdz5swhLS2Nk046ieHDh7Nlyxavo4lIc6WpF8KiYk+kBklxHWp9LOCrfZ60TSWfEnQlNT62pTT2uxO3TT6xlu6qjrYpJzR4nkhatvlOlm2+g+KKrygLrmFt4VT+u+Y0KoMapl5iX58+fZg3bx4333wzTz/9NLm5ucyYMcPrWCIisgcq9kRq0DXtjzVMip1Ixxbn4vfVMG9btYS4thjxu6w3/FEf6r8xSAp04sA2t+LjpykhkvFZAoek39Okf/6yyvWsLXyBkNvx8zpHJZWhbawpfM7DZCINJyEhgTvuuIPPP/+czMxMTj31VC666CI2b669t4OISCQZmnohXCr2RGqQmXwUOem3E+9LxwjgsyQ6tbyAA9qM3u3zOrQ4s4aWLcNnCWQk/yZ6gRuR7BbD6N/pQw5scwsHpt/GgI6zyGrio5gWlS+psRtqyJWxtfSzqB+/vHIDawufY832pymrXBv144nsTq9evZg7dy633XYbU6dOJScnh1deecXrWCLSXDgX+SWGqdgTqUX7FqcysPMsBnb+kKP3mcOBbUbj28Nk1Ilx7emZ9QgBX1p1q1YSSXGd6NP+CXy2a4tfrIr3t6F9izNpn3o6AX9rr+PUW4I/C0ewhkf8JEZ5UvH1hS/x+epBfLf5Lr7fcg9zVx3H6u1PRPWYInsSHx/PmDFjmDt3Lu3bt+eMM87g/PPPZ+PGjV5HExGRnajYE9kNMx/x/rSwBhdJTxrAUZ0/ok/7pzg8+0UGdPwPqfH7RzGlRFtK/CEkB/bl1wMY+yxAh5YXRe24ZZXrWbb5VpwrI+R2EHKlOMpYvuU+dlQsj9pxReqqZ8+efP7554wdO5Zp06aRm5vLSy+95HUsEYlh6sYZHhV7IlFg5qdlQg6p8ftpTrMYYGZ0y5pM68TDMOLxWRLx/kxyMh8mJYqF/KaSd6i6QuGXnAuyofjNqB1XJByBQIBbbrmFefPm0bFjR4YNG8a5557Lhg0bvI4mItLsqdgTEamDeH86Pdo9Qb9Os+iTPYN+HT8iPfmoqB7TEcTVcC2BI4RzlVE9tki4unfvzmeffca4ceOYPn06OTk5vPjii17HEpFYEo1pF9SyJyIiP4n3tyEp0LmWKSYiKz3pWGpqGPZZPBkpx0f9+CLhCgQC/O1vf2P+/Pl06dKFc845h2HDhrF+/Xqvo4lIjLBQ5JdYpmJPYlIwVMbGko/ZWPIRwVDpnp8g0gglBjrSufU11dOA+AEfPkukQ8vfkRJ/kNfxRGqVl5fH7Nmzufvuu5kxYwa5ublMnTq1xpZqERGJnt0PLSjSBG0s+ZhFP47if9c6hejWdgKZyYO8CyWylzq1GkmbpKPZWPwGjiAZyUNITcjxOpbIHsXFxXHDDTdw6qmnMmLECH7729/y/PPPM3HiRNq1a+d1PBFpqvQ3o7CoZU9iSnlwCwt//BNBV0zQFVUvJSz68VrKghoSXJqmlPgD2CftGrqkXadCT5qcnJwcPvnkE8aPH8+bb75Jbm4uzzzzjFr5REQagIo9iSnri9+q5RHH+qLIj14YDJXyzeYH+HDFkXzwQz8KNtxCeXBzxI8jItKU+f1+Ro8ezYIFCzjooIO48MILOe2001izZo3X0USkidHUC+FRsScxJRgqqnGUwpCroDJUGNFjOeeYv/73rNj2JOXBjVSEtrG26BXmrDlb1wmKiNTg4IMP5qOPPmLChAm888475Obm8uSTT6qVT0QkSlTsSUxJTxqA2a6XovosnvTk30T0WNvKFlBYVkCIsp/XOSqpCG5lffF/InosEZFY4ff7ue6661i4cCF5eXlccsklnHzyyaxevdrraCLS2DnAucgvMUzFnsSUFgmH0C7lZPyW9PM6vyWTlXw8LeO7RfRYheVf4mq4SjjoSthWtiiixxIRiTUHHnggH374IQ899BDvv/8+ubm5TJkyRa18IrJb6sYZHhV7EnNyMsbSre0DtE0+gbbJg8nLHE9u5j1YTROW1UNSXCcM/y7rfZZIcqBLRI8lIhKLfD4fV199NYsWLaJHjx6MGDGCoUOHsnLlSq+jiYjEBBV7EnPMjMzkQfTIepAeWf+gbcoxES/0ANKTjiDe3wZ+UfAZPguQnXpaxI8nIhKr9t9/f95//30efvhhZs2aRV5eHpMnT1Yrn4jsykVhiWEq9kT2kpmfw9o/TXrSERhxGHG0jM/lsPbPEPC38jqeiEiT4vP5uOqqq1i8eDG9evXisssuY8iQIaxYscLraCIiTZYmVReph4S4tvRq9xjB0A4cIeJ8KV5HEhFp0rp27crMmTN59NFH+fOf/0xeXh7jx49n5MiRUemlISJNhxH719hFmlr2RCLA70tSoSciEiE+n48//OEP5Ofnc9hhh3HFFVcwePBgli9f7nU0EfFSNEbijPHu4ir2REREpFHq0qUL7777Lo8++ihz5swhLy+PiRMnEgqFvI4mItIkqNiTZiPkygm5Cq9jiIhIGMyMkSNHkp+fT//+/bnyyis59thj+e6777yOJiIe0NQL4VGxJzGvuPx75q65gJnLD+W95b1YuP5qyoNbvI4lIiJh2GeffXjrrbf497//zfz58+nWrRsPP/ywWvlERHZDxZ7EtIrgNj5f+1u2ln0BhHBUsqHkfeatvQjn9B8EEZGmxMy49NJLyc/PZ+DAgVx99dUcffTRLFu2zOtoItJQNPVCWFTsSUxbU/QqIVfGzp9kRyWllWvZUvq5d8FERGSvderUiTfeeIMpU6awcOFCunfvzkMPPaRWPpFmQN04w6NiT2Jacfk3hFzpLusdIUoqfvAgkYiIRIKZMXz4cAoKCjjmmGMYNWoUAwcO5Ouvv/Y6mohIo6FiT2Jay4Ru+C1pl/WGkRp/oAeJREQkkjp06MCMGTN44oknKCgooEePHkyYMIFgMOh1NBGJNAeEXOSXGKZiT2Ja+9STifO1APw/r/NZPKnxB9MqoadnuUREJHLMjIsvvpiCggKOP/54Ro8ezW9+8xu+/PJLr6OJiHhKxZ7ENL8vmb7ZL5KVMgS/JRPna0XHFufRu92/MTOv44mISARlZ2fzyiuv8Mwzz/D111/Ts2dPxo8fr1Y+kViiAVrC4nmxZ2ZtzOwdM/um+t+0WrYLmtmC6uW1hs4pTVdiXFu6t72fY7r8l6P3+YyD0m/E70v2OlajUhbcyKYdsympWOF1FBGRejEzzj//fAoKCjjxxBP5y1/+Qv/+/VmyZInX0UREGpznxR5wAzDTOXcAMLP6fk12OOd6Vi+nNlw8kdjlXIilG8fy8YpjWfTjNcxefSr/XTuCylCx19FEROqlXbt2vPzyyzz33HN8++23HHroodxzzz1UVlZ6HU1E6kGjcYanMRR7pwFPVN9+AjjduygizcvK7c+ypugVQpRTGSok5MrYUvpflmy81etoIiL1Zmacd955FBQUcMopp3DjjTdyxBFHkJ+f73U0EdlbzkV+iWGNodjLcs6trb69DsiqZbtEM5tnZp+Z2em726GZjazedt6GDRsimVUkpqzY/iQht+MX6xzl/Fj8DsHQjlqeJSLStGRlZTFt2jReeOEFli9fTu/evRk3bhwVFRVeRxMRiaoGKfbM7F0zy69hOW3n7Zxzu7tMch/nXB/gfOBBM9uvtuM55yY55/o45/pkZmZG7gcRiTGVocJaHwvWMD+hRF7IVfBj8dt8t+Vh1hW9RjBU5nUkkZh19tlns2TJEk4//XRuvvlm+vXrx6JFi7yOJSJhUDfO8DRIseecO845l1fD8iqw3szaA1T/+2Mt+1hd/e93wAfAoQ2RXSSWtUnsR01fAwlxbQn4Wjd4Hi+sLpzOxysHM3N5Tz5bPYzNO+Y02LErgluZs/pklm68geXbHuGrTbcxe9Wx7Khc3WAZRJqbzMxMnn/+eaZNm8aqVavo06cPd9xxh1r5RCQmNYZunK8Bl1TfvgR49dcbmFmamSVU384ABgAaVkuknvZvcx1xvlSMAACGH58lkpMxtllMTbFi21N8uekOdlSuIuTKKCwv4Iv1V7CldF6DHH/ZlvsorVxF0FUNiBN0JZSHNvHlxpsb5PgizdlZZ51FQUEBw4YN49Zbb6Vv374sWLDA61gisjvRmHahni17Zna2mRWYWcjM+uxmuyFm9pWZLTOz2gakjLjGUOzdAww2s2+A46rvY2Z9zOzf1dscAswzs4XA+8A9zjkVeyL1lBzoRP8OM+jc8mJaJRxK+9TTODz7BdKT+nsdLepCrpJvtz6yyzWLIVfKss0PNkiGH4vfwvHrkQFDbC2dQ8iVN0gGkeYsIyODZ599lunTp7N27VoOO+wwxowZQ3m5Pn8ijZEB5lzEl3rKB84EZtWa28wP/BM4EcgBfmtmOfU9cF3ENcRBdsc5twk4tob184DLqm9/CnRr4GgizUJCXFsOTB/tdYwGVxnaRsjVfH1cUcU3DZLBiP3WU5Gm4PTTT2fgwIFcc8013H777UyfPp0pU6bQq1cvr6OJSCPnnFsK7KlHVF9gWfXlaJjZVKpmJIh641VjaNkTEWlwcb6WGP4aH0uK69QgGdqmDP25C+3/+EhL7I/P4hskg4hUadOmDU899RSvvfYaGzZsoG/fvtxyyy2UlWnQJJFGJRSFBTJ+Gsm/ehkZ4dQdgJU73V9VvS7qVOyJSLPkswD7tBqBz5J+tT6R/dL+1CAZ9ksbTVJgH/yWAvjwWwoJ/rYcnHFngxxfRHZ1yimnUFBQwIUXXsidd95J7969mTevYa7jFRHPbPxpJP/qZdLOD9Z1ZoHGyPNunCIiXuna+kqMOH7YPpnKUDEJ/rYc2OavZCYf1SDHD/hbcnj2a2za8RFF5V+RHOhMRvKxatUT8VhaWhqPP/44Z599NiNHjqRfv378+c9/5rbbbiMxMdHreCLNWgSusQubc+64eu5iNbBzt6GO1euiTsWeiDRbZkbXtMvZt/VIHBUYgQYfhdTMT0byIDKSBzXocUVkz0466SQKCgq4/vrrueeee3j11VeZMmUKhx9+uNfRRJqnCIye6ZG5wAFmti9VRd55VM0dHnXqxikizZ6Z4bP4ZjHdhIiEp3Xr1kyePJk333yTwsJC+vfvz1//+ldKS0u9jiYijYCZnWFmq4AjgNfN7K3q9dlm9gaAc64SuAp4C1gKvOCcK2iIfCr2RERERPZgyJAh5Ofnc+mll3Lfffdx6KGHMnv2bK9jiTQzDlwUlvokcm66c66jcy7BOZflnDuhev0a59zQnbZ7wzl3oHNuP+fcuHq+EHWmYk9ERESkDlq1asWkSZN46623KCkpYcCAAYwePZodO3bs+ckiIh5QsSciEk0rV8LYsXDRRXDVVTBrVr3/iigi3jr++ONZvHgxl19+ORMmTKBnz5588sknXscSaRbMRX6JZSr2RESiwTm4807o2ZPg+h/Z0LsfO7LawxVXwKBBsHmz1wlFpB5atmzJxIkTeffddykvL+fII4/k2muvpaSkxOtoIiI/U7EnIhINkybB1Km8PvEFBpcdzLn5IU74LpUbL7uLim7d4Ywz1MInEgOOPfZYFi9ezJVXXsmDDz5I9+7dmTVrltexRGJXI7tmr7FTsSciEmnBIIwbx8Kb7mL8fwooKS2npLSC8oognyz+gVu7Hgs//ggffeR1UhGJgNTUVB555BHef/99QqEQRx11FFdffTXFxcVeRxOJLQ4sFPkllqnYExGJtDlzIC2Nict2UFpe+YuHyiuCfLzoB3acfyG88IJHAUUkGgYNGsTixYu5+uqrefjhh+nevTsffPCB17FEpBlTsSciEmnbt0NWFhu2FNX4cCDOR1Fqq6rtRCSmpKSk8NBDDzFr1ix8Ph9HH300f/zjHykqqvn7QETCpG6cYVGxJ9IIVIQKWb71cRasH8U3Wx6mtHK915GkPvbbDxYtovf+Wfh9NU3UbrRZtrRqOxGJSUceeSQLFy7k2muvZeLEiXTr1o333nvP61gi0syo2BPxWGnlej5eNZRvtv6D9SVv8/3Wf/PxqpPYVpbvdTTZWwccAIccwpVl35OUGP+Lgi8xPo7rjj8Y/3PPwYgRHoYUkWhLTk7mgQce4KOPPiIQCHDsscfyhz/8gcLCQq+jiTRdLgpLDFOxJ+Kxrzc/QHlwKyFXCoCjgqArIX/DLR4nk3r5+99pffcdTMsJcfIRB5Cd2YqeB3XgoeP35eSxo+Daa6FTJ69TRkwwVMqWHXPYXrYI52L8aneRMA0YMICFCxdy/fXX8+ijj5KXl8e7777rdSyRJsmci/gSy+K8DiDS3G3YMQsI7rK+uOJbKkKFBHwtGj6U1F/PnvD227S+7jpuXLIEunWrGoFz61b4299g5EivE0bMuqL/x1ebbqHq74ch4nwt6ZE1idT4g7yOJtJoJCUlcf/993PWWWfxu9/9jsGDB/P73/+e8ePH06pVK6/jiUiMUrEn4jG/JVBZ4yOGj0ADp5GI6tkT3nsPli2Db7+Fli2hb1/w+71OFjHF5d/y5aabfm6ZBggGS/hi3XAGdJqFz/QeFtnZEUccwRdffMGYMWO4//77efPNN3nssccYMmSI19FEmoYYb4mLNHXjFPFYpxbn4LPEX6wz4shIHojfl1jLs6RJ2X9/OOEEOOKImCr0ANYUvUDIVeyyPuTK2LJjtgeJRBq/pKQk7r33Xj799FNatGjBiSeeyIgRI9i6davX0UQkxqjYE/HYvq0vIz2pPz5LwG8p+C2Z1PgDyMu4w+toIntUHtxETd2QASpCWxs0i0hTc/jhhzN//nxuvPFGnnzySfLy8njjjTe8jiXSeDkgFIUlhqnYE/GYz+LplfUIR2RPIzfjdvq0m8wR2dOI97f2OprIHmUkHY3PknZZ71wFrRP7epBIpGlJTEzkrrvu4rPPPiMtLY2TTjqJ4cOHs2XLFq+jiTQ6RuQHZ4n1AVpU7Ik0Eqnx+9E+dSitE3tgVtPcbCKNT2bK8aQGDvpFweezJDq2vITEuHYeJhNpWvr06cO8efO4+eabefrpp8nNzWXGjBlexxKRJk7FnoiI7DWfBejV/ikOSLuB1ol9SU86mrzMh9i/zWivo4k0OQkJCdxxxx18/vnnZGZmcuqpp3LRRRexefNmr6OJNB7ORX6JYSr2RESkXnwWT4eW59Gr3VP0yPoXGclHeR1JpEnr1asXc+fO5bbbbmPq1Knk5ubyyiuveB1LRJogFXsiIiIijUx8fDxjxoxh7ty5ZGVlccYZZ3D++eezceNGr6OJeEste2FRsSciIiLSSPXs2ZO5c+dy++23M23aNHJzc3n55Ze9jiUiTYSKPREREZFGLBAIcOuttzJv3jw6duzIWWedxbnnnsuGDRu8jibSsDT1QthU7ImIiIg0Ad27d+ezzz7jzjvvZPr06eTk5PDiiy96HUukQWnqhfCo2BMRERFpIgKBADfddBPz58+nS5cunHPOOQwbNoz169d7HU1EGiEVeyIiIiJNTF5eHrNnz+buu+9mxowZ5Obm8txzz+FivJVCRAO0hEfFnoQl5Cr5sXgm32z+B6sLX6YyVOJ1JBERkWYpLi6OG264gS+++IL99tuP888/nzPPPJN169Z5HU1EGgkVe1JnlaEiZq8+i0Ub/sp32/7F0k3jmLXyOIrLv/c6moiISLOVk5PDJ598wr333subb75JTk4OzzzzjFr5JAZFoVUvxj8nKvakzpZteYTiih8IuqrWvKDbQUVoG4s33OhxMhERkeYtLi6Ov/zlLyxYsICDDjqICy+8kNNPP521a9d6HU0kchwq9sKkYk/qbG3xGzjKf7XWsb18CRXB7Z5kEhERkf85+OCD+fjjj5kwYQJvv/02OTk5PPXUU2rlE2mmVOxJnRlW6yNYbY+JiIhIQ/L7/Vx33XUsXLiQ3NxcLr74Yk455RRWr17tdTSR+tM8e2FRsSd11j7lVHwW/6u1Plol5BHwtfAkk4iIiNTswAMP5MMPP+Tvf/877733Hrm5uUyZMkWtfCLNiIo9qbP90v5AauBA/JYM+PFbCvH+NnTLvMfraCIiIlIDv9/PqFGjWLRoEd27d2fEiBEMHTqUlStXeh1NZK9oUvXwqNiTOovzJdMveyo9s/7BAWnXkJsxlqM6vUtyoJPX0URERGQ39t9/fz744AMefvhhZs2aRV5eHpMnT1YrnzQ9GqAlLCr2JCxmPjKS+tO19WW0Tz2xhm6dIiIi0hj5fD6uuuoqFi9eTK9evbjssss44YQTWLFihdfRRCRKVOyJiIiINCNdu3Zl5syZ/POf/+TTTz8lNzeXRx99VK180vg5IOQiv8QwFXsiIiIizYzP5+PKK69k8eLF9O3blyuuuILBgwezfPlyr6OJSASp2BMRERFppvbdd1/effddHn30UebMmUNeXh4TJ04kFIrx8eiliYrC9Xox3qKtYk9ERESkGTMzRo4cSX5+Pv379+fKK6/k2GOP5bvvvvM6mojUk4o9EREREWGfffbhrbfe4rHHHmP+/Pl069aNRx55RK180rioZS8sKvZEREREBKhq5bvsssvIz89n4MCB/OlPf+Loo49m2bJlXkcTqaJiLywq9kRERETkFzp16sQbb7zBlClTWLhwId27d+ehhx5SK59IE6NiT0RERER2YWYMHz6cgoICjjnmGEaNGsXAgQP5+uuvvY4mzZWmXgibij0RERERqVWHDh2YMWMGTzzxBAUFBfTo0YMHHniAYDDodTQR2QMVeyIiIiKyW2bGxRdfTEFBAYMHD+b666/nyCOP5KuvvvI6mjQrDlwo8ksMU7EnIiIiInWSnZ3Nq6++ytNPP82XX35Jjx49GD9+vFr5pOFogJawqNgTERERkTozMy644AKWLFnCiSeeyF/+8hcGDBjA0qVLvY4mIr+iYk9EREREwtauXTtefvllnn32WZYtW8ahhx7KvffeS2VlpdfRJFZpgJawqdgTERERkb1iZvz2t7+loKCAk046iRtuuIH+/fuTn5/vdTQRQcWeiIiIiNRTVlYW06ZN4/nnn+f777+nd+/ejBs3joqKCq+jSazRNXthUbEnIiIiIvVmZpxzzjksWbKE008/nZtvvpl+/fqxaNEir6NJLFGxFxbPiz0zO9vMCswsZGZ9drPdEDP7ysyWmdkNDZlRREREROomMzOT559/nmnTprFq1Sr69OnDHXfcoVY+EQ94XuwB+cCZwKzaNjAzP/BP4EQgB/itmeU0TDwRERERCddZZ51FQUEBw4YN49Zbb6Vv374sWLDA61jSpEWhVU8te9HlnFvqnNvTjJx9gWXOue+cc+XAVOC06KcTERERkb2VkZHBs88+y8svv8zatWs57LDDGDNmDOXl5V5HE2kWPC/26qgDsHKn+6uq19XIzEaa2Twzm7dhw4aohxMRERGR2p1xxhkUFBRw3nnncfvtt/P+++97HUmaIgeEQpFf6qEul6SZWScze9/MllRve029DhqGBin2zOxdM8uvYYlK65xzbpJzro9zrk9mZmY0DiEiIiIiYUhPT+epp55i7ty5nHDCCV7HEYmUPV6SBlQC1zvncoB+wB8b6pK0uIY4iHPuuHruYjXQaaf7HavXiYiIiEgT0qdPrePxiexZI7vGzjm3FKpGo93NNmuBtdW3C81sKVW9FJdEO1+DFHsRMBc4wMz2parIOw8439tIIiIiIiLSoKJT7GWY2byd7k9yzk2KxoHMrAtwKDAnGvv/Nc+LPTM7A3gYyAReN7MFzrkTzCwb+LdzbqhzrtLMrgLeAvzA/znnCjyMLSIiIiIisWGjc253U8C9C7Sr4aGbnHOv1vUgZpYKvASMcs5tDz9m+Dwv9pxz04HpNaxfAwzd6f4bwBsNGE0ipDJUwrriN9letpTU+APITj2ZOF+K17FEREREpElxEGr4bpwRuCQNMwtQVeg945x7uf6p6sbzYk9iW2nlOj5bcy6VoWKCrgSfJfHtloc5PHsqyYGOXscTEREREYkqq7qgbzKw1Dn3QEMeu6lMvSBN1NJNd1MW3ETQlQAQcjsoD21lyabbPU4mIiIiIk2KA+dCEV/qw8zOMLNVwBFUXZL2VvX6bDP7qVfiAOAi4BgzW1C9DK1llxGllj2Jqo07ZgG//hCF2LRjNs6FMNPfG0RERESkjjzoxrk7dbkkzTn3MVD7cJ1RpP9pS1RZLW+xqvWevOdFRERERJoFFXsSVe1STsII/GKdESArZfBu5yMREREREdmFc5FfYpiKPYmqg9L/TGr8/vgtGR8J+C2F5EBnDkm/xetoIiIiIiIxTdfsSVQFfC04InsaW0rnUlSxjJRAF9ok9tO1eiIiIiISHucgVL8BVZobFXsSdWZGm6S+tEnq63UUEREREWnKYrzbZaSpeUVERERERCQGqWVPRERERESaBKdunGFRy56IiIiIiEgMUsueiIiIiIg0AbE/VUKkqWVPREREREQkBqllT0REREREGj8HhNSyFw4VeyIiIiIi0jQ4DdASDnXjFBERERERiUFq2RMRERERkUbPAU7dOMOilj0REREREZEYpJY9ERERERFp/JzTNXthUrEnIiIiIiJNgrpxhkfdOEVERERERGKQWvZERERERKRpUDfOsKhlT0REREREJAaZc7Hd79XMNgA/eBghA9jo4fFF56Cx0Hnwns6B93QOvKdz4D2dg8YhA0hxzmV6HaSuzOw/VOWOtI3OuSFR2K/nYr7Y85qZzXPO9fE6R3Omc9A46Dx4T+fAezoH3tM58J7OQeOg89A8qBuniIiIiIhIDFKxJyIiIiIiEoNU7EXfJK8DiM5BI6Hz4D2dA+/pHHhP58B7OgeNg85DM6Br9kRERERERGKQWvZERERERERikIo9ERERERGRGKRiT0REREREJAap2IswM7vKzOaZWZmZPV6H7a81s3Vmtt3M/s/MEhogZkwzszZmNt3Mis3sBzM7fzfbjjGzCjMr2mnp2pB5Y0VdX3ercq+Zbape7jUza+i8sSiMc6D3fZSE8ztA3//RUddzYGbDzSz4q8/BoAYLGsPMLMHMJld/DxWa2QIzO3E32+uzEGHhnAN9FmKbir3IWwPcCfzfnjY0sxOAG4BjgX2ArsDtUU3XPPwTKAeygAuAiWaWu5vtn3fOpe60fNcgKWNPXV/3kcDpQA+gO3AKcHkDZYx14bz39b6Pjjr9DtD3f1TV+fcwMPtXn4MPohut2YgDVgJHAa2Am4EXzKzLrzfUZyFq6nwOqumzEKNU7EWYc+5l59wrwKY6bH4JMNk5V+Cc2wLcAQyPYryYZ2YpwFnALc65Iufcx8BrwEXeJottYb7ulwATnHOrnHOrgQnofV9veu83DmH8DtD3f5SE+XtYosA5V+ycG+OcW+6cCznn/h/wPdC7hs31WYiCMM+BxDAVe97KBRbudH8hkGVm6R7liQUHApXOua93WreQqte6NqeY2WYzKzCzP0Q3XswK53Wv6X2/u/MjdRPue1/ve2/p+79xONTMNprZ12Z2i5nFeR0oFplZFlXfUQU1PKzPQgPYwzkAfRZilk6kt1KBbTvd/+l2C/QXyb2VCmz/1bptVL2mNXmBqklF1wOHAy+Z2Vbn3HPRixiTwnnda3rfp5qZOU38WR/hnAO9772n73/vzQLygB+oKjieByqBu70MFWvMLAA8AzzhnPuyhk30WYiyOpwDfRZimFr2wmBmH5iZq2X5eC92WQS03On+T7cL6582NtXhHPz6NaX6fo2vqXNuiXNujXMu6Jz7FHgIGBbdnyImhfO61/S+L1KhV291Pgd63zcK+v73mHPuO+fc99Vd3BYDY9HnIKLMzAc8RdW1xFfVspk+C1FUl3Ogz0JsU7EXBufcIOec1bL8Zi92WUDVIBU/6QGsd87pL1m1qMM5+BqIM7MDdnpaD2rvtrDLIQCNDBm+cF73mt73dT0/Urv6vPf1vm94+v5vfPQ5iKDqUZYnUzVg1FnOuYpaNtVnIUrCOAe/ps9CDFGxF2FmFmdmiYAf8JtZ4m76PT8JXGpmOWbWmqqRkh5vmKSxyTlXDLwMjDWzFDMbAJxG1V+1dmFmp5lZmlXpC1wNvNpwiWNDmK/7k8B1ZtbBzLKB69H7vt7COQd630dPGL8D9P0fJXU9B2Z2YvV1TJjZwcAt6HMQSROBQ4BTnHM7drOdPgvRU6dzoM9CjHPOaYngAoyh6i8iOy9jqh/rTFV3hc47bX8dVdfNbAemAAle/wxNfQHaAK8AxcAK4PydHjuSqi6DP91/jqprAoqAL4Grvc7fVJfaXvcaXnMD7gM2Vy/3AeZ1/lhYwjgHet9H7xzU+DtA3/+N7xwA91e//sXAd1R1XQt4nT8WFqqmUHBAafVr/tNygT4Lje8c6LMQ24tVn2QRERERERGJIerGKSIiIiIiEoNU7ImIiIiIiMQgFXsiIiIiIiIxSMWeiIiIiIhIDFKxJyIiIiIiEoNU7ImIiIiIiMQgFXsiIiIiIiIxSMWeiIhEhZndZ2av7HR/vJnNNLN4D2OJiIg0G5pUXUREosLM0oHvgEHA4cAfgd8457Z5mUtERKS5ULEnIiJRY2ZjgDOBVlQVeiur198L9AeWAyOccxVeZRQREYlV6sYpIiLR9AXQDbhxp0KvB9DBOXck8CUwzMN8IiIiMUvFnoiIRIWZdQMmAk8AI3Z6qD/wdvXt/wADGjiaiIhIs6BiT0REIs7MOgAzgCuAK4FuZjao+uE0YHv17W1Am4bOJyIi0hyo2BMRkYgys5bAG8ADzrnXnHMlwHhgXPUmW4GW1bdbAZsbPKSIiEgzoAFaRESkQZlZT+A659zFZvY34Hvn3HMexxIREYk5atkTEZEG5ZxbAKw3s4+AXOAlbxOJiIjEJrXsiYiIiIiIxCC17ImIiIiIiMQgFXsiIiIiIiIxSMWeiIiIiIhIDFKxJyIiIiIiEoNU7ImIiIiIiMQgFXsiIiIiIiIxSMWeiIiIiIhIDFKxJyIiIiIiEoP+P1eD2D0Cr1FBAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 624ec6270..c2f498be7 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -16,11 +16,19 @@ __all__ = [ "TorchTwiceDifferentiable", + "solve_linear", + "solve_batch_cg", + "solve_lissa", + "as_tensor", + "stack", + "cat", + "einsum", + "mvp", ] logger = logging.getLogger(__name__) -def flatten_gradient(grad) -> torch.Tensor: +def flatten_all(grad) -> torch.Tensor: """ Simple function to flatten a pyTorch gradient for use in subsequent calculation """ @@ -31,15 +39,16 @@ def solve_linear( model: TwiceDifferentiable, training_data: DataLoader, b: torch.Tensor, + *, lam: float = 0, - progress: bool = True, + progress: bool = False, ) -> torch.Tensor: """Given a model and training data, it finds x s.t. $Hx = b$, with $H$ being the model hessian. :param model: A model wrapped in the TwiceDifferentiable interface. :param training_data: A DataLoader containing the training data. - :param b: a vector or matrix + :param b: a vector or matrix, the right hand side of the equation $Hx = b$. :param lam: regularization of the hessian :param progress: If True, display progress bars. @@ -52,7 +61,7 @@ def solve_linear( all_y.append(y) all_x = cat(all_x) all_y = cat(all_y) - matrix = model.hessian(all_x, all_y, progress) + lam * identity_tensor( + matrix = model.hessian(all_x, all_y, progress=progress) + lam * identity_tensor( model.num_params ) return torch.linalg.solve(matrix, b.T).T @@ -62,12 +71,13 @@ def solve_batch_cg( model: TwiceDifferentiable, training_data: DataLoader, b: torch.Tensor, + *, lam: float = 0, x0: Optional[torch.Tensor] = None, rtol: float = 1e-7, atol: float = 1e-7, maxiter: Optional[int] = None, - progress: bool = True, + progress: bool = False, ) -> torch.Tensor: """ Given a model and training data, it uses conjugate gradient to calculate the @@ -77,7 +87,7 @@ def solve_batch_cg( :param model: A model wrapped in the TwiceDifferentiable interface. :param training_data: A DataLoader containing the training data. - :param b: a vector or matrix + :param b: a vector or matrix, the right hand side of the equation $Hx = b$. :param lam: regularization of the hessian :param x0: initial guess for hvp. If None, defaults to b :param rtol: maximum relative tolerance of result @@ -99,7 +109,7 @@ def solve_batch_cg( ) + lam * v.type(torch.float64) batch_cg = torch.zeros_like(b) for idx, bi in enumerate(maybe_progress(b, progress, desc="Conjugate gradient")): - bi_cg, _ = solve_cg(reg_hvp, bi, x0, rtol, atol, maxiter) + bi_cg, _ = solve_cg(reg_hvp, bi, x0=x0, rtol=rtol, atol=atol, maxiter=maxiter) batch_cg[idx] = bi_cg return batch_cg @@ -107,6 +117,7 @@ def solve_batch_cg( def solve_cg( hvp: Callable[[torch.Tensor], torch.Tensor], b: torch.Tensor, + *, x0: Optional[torch.Tensor] = None, rtol: float = 1e-7, atol: float = 1e-7, @@ -115,7 +126,7 @@ def solve_cg( """Conjugate gradient solver for the Hessian vector product :param hvp: a Callable Hvp, operating with tensors of size N - :param b: a tensor of shape [N] + :param b: a vector or matrix, the right hand side of the equation $Hx = b$. :param x0: initial guess for hvp :param rtol: maximum relative tolerance of result :param atol: absolute tolerance of result @@ -156,13 +167,14 @@ def solve_lissa( model: TwiceDifferentiable, training_data: DataLoader, b: torch.Tensor, + *, lam: float = 0, - progress: bool = True, maxiter: int = 1000, damp: float = 0, scale: float = 10, h0: Optional[torch.Tensor] = None, rtol: float = 1e-4, + progress: bool = False, ) -> torch.Tensor: """ It uses LISSA, Linear time Stochastic Second-Order Algorithm, to calculate the @@ -178,7 +190,7 @@ def solve_lissa( :param model: A model wrapped in the TwiceDifferentiable interface. :param training_data: A DataLoader containing the training data. - :param b: a vector or matrix + :param b: a vector or matrix, the right hand side of the equation $Hx = b$. :param lam: regularization of the hessian :param progress: If True, display progress bars. :param maxiter: maximum number of iterations, @@ -250,6 +262,7 @@ def mvp( grad_xy: torch.Tensor, v: torch.Tensor, backprop_on: torch.Tensor, + *, progress: bool = False, ) -> torch.Tensor: """ @@ -279,9 +292,7 @@ def mvp( mvp = [] for i in maybe_progress(range(len(z)), progress, desc="MVP"): - mvp.append( - flatten_gradient(autograd.grad(z[i], backprop_on, retain_graph=True)) - ) + mvp.append(flatten_all(autograd.grad(z[i], backprop_on, retain_graph=True))) mvp = torch.stack([grad.contiguous().view(-1) for grad in mvp]) return mvp.detach() # type: ignore @@ -291,6 +302,7 @@ def __init__( self, model: nn.Module, loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + *, device: torch.device = torch.device( "cuda" if torch.cuda.is_available() else "cpu" ), @@ -330,6 +342,7 @@ def split_grad( self, x: torch.Tensor, y: torch.Tensor, + *, progress: bool = False, ) -> torch.Tensor: """ @@ -349,7 +362,7 @@ def split_grad( grads = [] for i in maybe_progress(range(len(x)), progress, desc="Split Gradient"): grads.append( - flatten_gradient( + flatten_all( autograd.grad( self.loss( torch.squeeze(self.model(x[i])), @@ -366,6 +379,7 @@ def grad( self, x: torch.Tensor, y: torch.Tensor, + *, x_requires_grad: bool = False, ) -> Tuple[torch.Tensor, torch.Tensor]: """ @@ -385,12 +399,13 @@ def grad( loss_value = self.loss(torch.squeeze(self.model(x)), torch.squeeze(y)) grad_f = torch.autograd.grad(loss_value, self.parameters, create_graph=True) - return flatten_gradient(grad_f), x + return flatten_all(grad_f), x def hessian( self, x: torch.Tensor, y: torch.Tensor, + *, progress: bool = False, ) -> torch.Tensor: """Calculates the explicit hessian of model parameters given data ($x$ and $y$). @@ -405,5 +420,5 @@ def hessian( grad_xy, torch.eye(self.num_params, self.num_params, device=self.device), self.parameters, - progress, + progress=progress, ) diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 1a12525b7..94a5416e4 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -36,9 +36,10 @@ def compute_influence_factors( training_data: DataLoaderType, test_data: DataLoaderType, inversion_method: InversionMethod, - inversion_method_kwargs: Dict[str, Any] = {}, + *, lam: float = 0, progress: bool = False, + **kwargs: Any, ) -> TensorType: r""" Calculates influence factors of a model for training and test @@ -57,7 +58,6 @@ def compute_influence_factors( :param test_data: A DataLoader containing the test data. :param inversion_func: function to use to invert the product of hvp (hessian vector product) and the gradient of the loss (s_test in the paper). - :param inversion_method_kwargs: kwargs to pass to the inversion method :param lam: regularization of the hessian :param progress: If True, display progress bars. :returns: An array of size (N, D) containing the influence factors for each @@ -67,16 +67,16 @@ def compute_influence_factors( for x_test, y_test in maybe_progress( test_data, progress, desc="Batch Test Gradients" ): - test_grads.append(model.split_grad(x_test, y_test, False)) + test_grads.append(model.split_grad(x_test, y_test, progress=False)) test_grads = cat(test_grads) return solve_hvp( inversion_method, model, training_data, test_grads, - lam, - inversion_method_kwargs, - progress, + lam=lam, + progress=progress, + **kwargs, ) @@ -84,6 +84,7 @@ def compute_influences_up( model: TwiceDifferentiable[TensorType, ModelType], input_data: DataLoaderType, influence_factors: TensorType, + *, progress: bool = False, ) -> TensorType: r""" @@ -107,7 +108,7 @@ def compute_influences_up( for x, y in maybe_progress( input_data, progress, desc="Batch Split Input Gradients" ): - train_grads.append(model.split_grad(x, y, False)) + train_grads.append(model.split_grad(x, y, progress=False)) train_grads = cat(train_grads) return einsum("ta,va->tv", influence_factors, train_grads) @@ -116,6 +117,7 @@ def compute_influences_pert( model: TwiceDifferentiable[TensorType, ModelType], input_data: DataLoaderType, influence_factors: TensorType, + *, progress: bool = False, ) -> TensorType: r""" @@ -164,13 +166,14 @@ def compute_influences_pert( def compute_influences( differentiable_model: TwiceDifferentiable[TensorType, ModelType], training_data: DataLoaderType, + *, test_data: Optional[DataLoaderType] = None, input_data: Optional[DataLoaderType] = None, - progress: bool = False, inversion_method: InversionMethod = InversionMethod.Direct, - inversion_method_kwargs: Dict[str, Any] = {}, influence_type: InfluenceType = InfluenceType.Up, hessian_regularization: float = 0, + progress: bool = False, + **kwargs: Any, ) -> TensorType: r""" Calculates the influence of the input_data point j on the test points i. @@ -186,9 +189,6 @@ def compute_influences( :param input_data: data loader with the samples to calculate the influences of. If None, the samples in training_data are used. :param progress: whether to display progress bars. - :param inversion_method: Set the inversion method to a specific one, can be - 'direct' for direct inversion (and explicit construction of the Hessian) - or 'cg' for conjugate gradient. :param influence_type: Which algorithm to use to calculate influences. Currently supported options: 'up' or 'perturbation'. For details refer to :footcite:t:`koh_understanding_2017` @@ -211,9 +211,9 @@ def compute_influences( training_data, test_data, inversion_method, - inversion_method_kwargs=inversion_method_kwargs, lam=hessian_regularization, progress=progress, + **kwargs, ) compute_influence_type = influence_type_registry[influence_type] @@ -221,5 +221,5 @@ def compute_influences( differentiable_model, input_data, influence_factors, - progress, + progress=progress, ) diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 77b346028..352a99d2d 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -35,9 +35,10 @@ def solve_hvp( model: TwiceDifferentiable[TensorType, ModelType], training_data: DataLoaderType, b: TensorType, - lam: float = 0, - inversion_method_kwargs: Dict[str, Any] = {}, + *, + lam: float = 0.0, progress: bool = False, + **kwargs: Any, ) -> TensorType: """ Finds $x$ such that $Ax = b$, where $A$ is the hessian of model, @@ -51,9 +52,9 @@ def solve_hvp( :param model: A model wrapped in the TwiceDifferentiable interface. :param x: An array containing the features of the input data points. :param y: labels for x - :param b: + :param b: Array as the right hand side of the equation $Ax = b$ + :param kwargs: kwargs to pass to the inversion method :param lam: regularization of the hessian - :param inversion_method_kwargs: kwargs to pass to the inversion method :param progress: If True, display progress bars. :return: An array that solves the inverse problem, @@ -64,8 +65,8 @@ def solve_hvp( model, training_data, b, - lam, - **inversion_method_kwargs, + **kwargs, + lam=lam, progress=progress, ) elif inversion_method == InversionMethod.Cg: @@ -73,8 +74,8 @@ def solve_hvp( model, training_data, b, - lam, - **inversion_method_kwargs, + **kwargs, + lam=lam, progress=progress, ) elif inversion_method == InversionMethod.Lissa: @@ -82,8 +83,8 @@ def solve_hvp( model, training_data, b, - lam, - **inversion_method_kwargs, + **kwargs, + lam=lam, progress=progress, ) else: diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index f039874c2..63e5b2768 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -124,9 +124,9 @@ def test_influence_linear_model( direct_influences = compute_influences( TorchTwiceDifferentiable(linear_layer, loss), - train_data_loader, - test_data_loader, - input_data, + training_data=train_data_loader, + test_data=test_data_loader, + input_data=input_data, progress=True, influence_type=influence_type, inversion_method="direct", @@ -135,9 +135,9 @@ def test_influence_linear_model( cg_influences = compute_influences( TorchTwiceDifferentiable(linear_layer, loss), - train_data_loader, - test_data_loader, - input_data, + training_data=train_data_loader, + test_data=test_data_loader, + input_data=input_data, progress=True, influence_type=influence_type, inversion_method="cg", @@ -146,16 +146,14 @@ def test_influence_linear_model( lissa_influences = compute_influences( TorchTwiceDifferentiable(linear_layer, loss), - train_data_loader, - test_data_loader, - input_data, + training_data=train_data_loader, + test_data=test_data_loader, + input_data=input_data, progress=True, influence_type=influence_type, inversion_method="lissa", - inversion_method_kwargs={ - "maxiter": 5000, - "scale": 100, - }, + maxiter=5000, + scale=100, hessian_regularization=hessian_reg, ).numpy() assert np.logical_not(np.any(np.isnan(direct_influences))) @@ -270,13 +268,13 @@ def test_influences_nn( for inversion_method in InversionMethod: influences = compute_influences( TorchTwiceDifferentiable(nn_architecture, loss), - train_data_loader, - test_data_loader, + training_data=train_data_loader, + test_data=test_data_loader, progress=True, influence_type=influence_type, inversion_method=inversion_method, - inversion_method_kwargs=inversion_method_kwargs[inversion_method], hessian_regularization=hessian_reg, + **inversion_method_kwargs[inversion_method], ).numpy() assert not np.any(np.isnan(influences)) multiple_influences[inversion_method] = influences From 493a5f4fdb823ac7ad62c0c68218d055d771a133 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 12 Apr 2023 10:09:36 +0200 Subject: [PATCH 051/436] very minor change --- src/pydvl/influence/frameworks/torch_differentiable.py | 10 +++++----- src/pydvl/influence/general.py | 4 ++-- tests/influence/conftest.py | 2 +- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index c2f498be7..a0f06a8ab 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -40,7 +40,7 @@ def solve_linear( training_data: DataLoader, b: torch.Tensor, *, - lam: float = 0, + lam: float = 0.0, progress: bool = False, ) -> torch.Tensor: """Given a model and training data, it finds x s.t. $Hx = b$, with $H$ being @@ -72,7 +72,7 @@ def solve_batch_cg( training_data: DataLoader, b: torch.Tensor, *, - lam: float = 0, + lam: float = 0.0, x0: Optional[torch.Tensor] = None, rtol: float = 1e-7, atol: float = 1e-7, @@ -168,10 +168,10 @@ def solve_lissa( training_data: DataLoader, b: torch.Tensor, *, - lam: float = 0, + lam: float = 0.0, maxiter: int = 1000, - damp: float = 0, - scale: float = 10, + damp: float = 0.0, + scale: float = 10.0, h0: Optional[torch.Tensor] = None, rtol: float = 1e-4, progress: bool = False, diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 94a5416e4..51a1c9e11 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -37,7 +37,7 @@ def compute_influence_factors( test_data: DataLoaderType, inversion_method: InversionMethod, *, - lam: float = 0, + lam: float = 0.0, progress: bool = False, **kwargs: Any, ) -> TensorType: @@ -171,7 +171,7 @@ def compute_influences( input_data: Optional[DataLoaderType] = None, inversion_method: InversionMethod = InversionMethod.Direct, influence_type: InfluenceType = InfluenceType.Up, - hessian_regularization: float = 0, + hessian_regularization: float = 0.0, progress: bool = False, **kwargs: Any, ) -> TensorType: diff --git a/tests/influence/conftest.py b/tests/influence/conftest.py index 59790b726..ce13e9b32 100644 --- a/tests/influence/conftest.py +++ b/tests/influence/conftest.py @@ -72,7 +72,7 @@ def linear_derivative_analytical( def linear_hessian_analytical( linear_model: Tuple[NDArray[np.float_], NDArray[np.float_]], x: NDArray[np.float_], - lam: float = 0, + lam: float = 0.0, ) -> NDArray[np.float_]: """ Given a linear model it returns the hessian wrt. its parameters. From 2e153e4b1410160cc74a397a784808495a205863 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 13 Apr 2023 14:12:45 +0200 Subject: [PATCH 052/436] =?UTF-8?q?Bump=20version:=200.6.1=20=E2=86=92=200?= =?UTF-8?q?.6.2.dev0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .bumpversion.cfg | 2 +- setup.py | 2 +- src/pydvl/__init__.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.bumpversion.cfg b/.bumpversion.cfg index 4a9b23366..033a1a3bc 100644 --- a/.bumpversion.cfg +++ b/.bumpversion.cfg @@ -1,5 +1,5 @@ [bumpversion] -current_version = 0.6.1 +current_version = 0.6.2.dev0 commit = False tag = False allow_dirty = False diff --git a/setup.py b/setup.py index 002249cea..2a8bcd635 100644 --- a/setup.py +++ b/setup.py @@ -12,7 +12,7 @@ package_data={"pydvl": ["py.typed"]}, packages=find_packages(where="src"), include_package_data=True, - version="0.6.1", + version="0.6.2.dev0", description="The Python Data Valuation Library", install_requires=[ line diff --git a/src/pydvl/__init__.py b/src/pydvl/__init__.py index 43c4ab005..c46296a16 100644 --- a/src/pydvl/__init__.py +++ b/src/pydvl/__init__.py @@ -1 +1 @@ -__version__ = "0.6.1" +__version__ = "0.6.2.dev0" From 7194a14a68217d2c667585e58dcdf6e5c442060e Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Sun, 16 Apr 2023 13:28:44 +0200 Subject: [PATCH 053/436] Use correct local env variable for release pipeline, add branches filter --- .github/workflows/publish.yaml | 4 +++- build_scripts/release-version.sh | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/publish.yaml b/.github/workflows/publish.yaml index 2ea899fa3..3ebf2c962 100644 --- a/.github/workflows/publish.yaml +++ b/.github/workflows/publish.yaml @@ -2,6 +2,8 @@ name: Publish Python Package to PyPI on: push: + branches: + - "**" tags: - "v*" workflow_dispatch: @@ -52,7 +54,7 @@ jobs: echo "Should be on Master branch instead" exit -1 - name: Fail if running locally - if: ${{ !github.event.act }} # skip during local actions testing + if: ${{ env.ACT }} # skip during local actions testing run: | echo "Running action locally. Failing" exit -1 diff --git a/build_scripts/release-version.sh b/build_scripts/release-version.sh index 2d4f671b7..e57d860a6 100755 --- a/build_scripts/release-version.sh +++ b/build_scripts/release-version.sh @@ -239,7 +239,7 @@ echo "🔨 Merging release branch into master" git checkout master git pull --ff-only "$REMOTE" master git merge --no-ff -X theirs "$RELEASE_BRANCH" -git tag -a "$RELEASE_TAG" -m"Release $RELEASE_VERSION" +git tag -a "$RELEASE_TAG" -m "Release $RELEASE_VERSION" git push --follow-tags "$REMOTE" master echo "🏷️ Bumping to next patch version" From 17ec7f0b02d7d030a4ce3b3569719b836abd6148 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Sun, 16 Apr 2023 15:23:42 +0200 Subject: [PATCH 054/436] Trigger publish CI pipeline on release instead of tag creation --- .github/workflows/publish.yaml | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/.github/workflows/publish.yaml b/.github/workflows/publish.yaml index 3ebf2c962..8bdec2369 100644 --- a/.github/workflows/publish.yaml +++ b/.github/workflows/publish.yaml @@ -1,19 +1,17 @@ name: Publish Python Package to PyPI on: - push: - branches: - - "**" - tags: - - "v*" + release: + types: + - published workflow_dispatch: inputs: reason: description: Why did you trigger the pipeline? required: False default: Check if it runs again due to external changes - tag: - description: Tag for which a package should be published + tag_name: + description: The name of the tag for which a package should be published type: string required: false @@ -29,22 +27,24 @@ jobs: - uses: actions/checkout@v3 with: fetch-depth: 0 - - name: Fail if manually triggered workflow does not have 'tag' input - if: github.event_name == 'workflow_dispatch' && inputs.tag == '' + - name: Fail if manually triggered workflow does not have 'tag_name' input + if: github.event_name == 'workflow_dispatch' && inputs.tag_name == '' run: | - echo "Input 'tag' should not be empty" + echo "Input 'tag_name' should not be empty" exit -1 - name: Extract branch name from input id: get_branch_name_input if: github.event_name == 'workflow_dispatch' run: | - export BRANCH_NAME=$(git log -1 --format='%D' ${{ inputs.tag }} | sed -e 's/.*origin\/\(.*\).*/\1/') + export BRANCH_NAME=$(git log -1 --format='%D' ${{ inputs.tag_name }} | sed -e 's/.*origin\/\(.*\).*/\1/') + echo "$BRANCH_NAME" echo "branch_name=${BRANCH_NAME}" >> $GITHUB_OUTPUT - name: Extract branch name from tag id: get_branch_name_tag - if: github.ref_type == 'tag' + if: github.release.tag_name != '' run: | - export BRANCH_NAME=$(git log -1 --format='%D' $GITHUB_REF | sed -e 's/.*origin\/\(.*\).*/\1/') + export BRANCH_NAME=$(git log -1 --format='%D' ${{ github.release.tag_name }} | sed -e 's/.*origin\/\(.*\).*/\1/') + echo "$BRANCH_NAME" echo "branch_name=${BRANCH_NAME}" >> $GITHUB_OUTPUT shell: bash - name: Fail if tag is not on 'master' branch From da2b68f2c16d9a22a35d5f6be39d64d241849140 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Sun, 16 Apr 2023 15:26:41 +0200 Subject: [PATCH 055/436] Update release instructions --- CONTRIBUTING.md | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 6bd181636..34dc3ff80 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -397,8 +397,11 @@ If running in interactive mode (without `-y|--yes`), the script will output a summary of pending changes and ask for confirmation before executing the actions. -Once this is done, a package will be automatically created and published from CI -to PyPI. +Once this is done, a tag will be created on the repository. +You should then create a Github +[release](https://docs.github.com/en/repositories/releasing-projects-on-github/managing-releases-in-a-repository#creating-a-release) +for that tag. That will a trigger a CI pipeline that will +automatically create a package and publish it from CI to PyPI. ### Manual release process @@ -441,8 +444,11 @@ create a new release manually by following these steps: ``` 7. Delete the release branch if necessary: `git branch -d release/${RELEASE_VERSION}` -8. Pour yourself a cup of coffee, you earned it! :coffee: :sparkles: -9. A package will be automatically created and published from CI to PyPI. +8. Create a Github + [release](https://docs.github.com/en/repositories/releasing-projects-on-github/managing-releases-in-a-repository#creating-a-release) + for the created tag. +9. Pour yourself a cup of coffee, you earned it! :coffee: :sparkles: +10. A package will be automatically created and published from CI to PyPI. ### CI and requirements for publishing From 8d24fdfe95b6627452b9ef5ca4cc70f29b3f60b8 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Mon, 1 May 2023 14:34:25 +0200 Subject: [PATCH 056/436] Create CITATION.cff --- CITATION.cff | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 CITATION.cff diff --git a/CITATION.cff b/CITATION.cff new file mode 100644 index 000000000..2fd9043d7 --- /dev/null +++ b/CITATION.cff @@ -0,0 +1,41 @@ +# This CITATION.cff file was generated with cffinit. +# Visit https://bit.ly/cffinit to generate yours today! + +cff-version: 1.2.0 +title: pyDVL +message: >- + If you use this software, please cite it using the + metadata from this file. +type: software +authors: + - given-names: Anes + family-names: Benmerzoug + email: a.benmerzoug@appliedai.de + affiliation: appliedAI Initiative GmbH + - given-names: Miguel + family-names: de Benito Delgado + email: m.debenito@appliedai-institute.de + affiliation: appliedAI Institute GmbH + orcid: 'https://orcid.org/0000-0002-3045-3786' + - given-names: Fabio + family-names: Peruzzo + email: f.peruzzo@appliedai.de + affiliation: appliedAI Initiative GmbH +repository-code: 'https://github.com/appliedAI-Initiative/pyDVL' +abstract: >- + pyDVL is a library of stable implementations of algorithms + for data valuation and influence function computation +keywords: + - machine learning + - data-centric AI + - data valuation + - influence function + - Shapley value + - data quality + - Least core + - Semi-values + - Banzhaf index +license: LGPL-3.0 +commit: 0e929ae121820b0014bf245da1b21032186768cb +version: v0.6.1 +date-released: '2023-04-13' From a48651c02cc60698a60d60291b6ffcb503803ad6 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Mon, 1 May 2023 14:49:19 +0200 Subject: [PATCH 057/436] Replace authors by "tfl team" --- CITATION.cff | 16 +++------------- 1 file changed, 3 insertions(+), 13 deletions(-) diff --git a/CITATION.cff b/CITATION.cff index 2fd9043d7..503b05b4f 100644 --- a/CITATION.cff +++ b/CITATION.cff @@ -8,19 +8,9 @@ message: >- metadata from this file. type: software authors: - - given-names: Anes - family-names: Benmerzoug - email: a.benmerzoug@appliedai.de - affiliation: appliedAI Initiative GmbH - - given-names: Miguel - family-names: de Benito Delgado - email: m.debenito@appliedai-institute.de - affiliation: appliedAI Institute GmbH - orcid: 'https://orcid.org/0000-0002-3045-3786' - - given-names: Fabio - family-names: Peruzzo - email: f.peruzzo@appliedai.de - affiliation: appliedAI Initiative GmbH + - given-names: TransferLab team + email: info+pydvl@appliedai.de + affiliation: appliedAI Institute gGmbH repository-code: 'https://github.com/appliedAI-Initiative/pyDVL' abstract: >- pyDVL is a library of stable implementations of algorithms From 81bb6b92ad47ab311e29dfd6eddd2c31a74008e7 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Mon, 15 May 2023 00:23:08 +0200 Subject: [PATCH 058/436] fixing docstrings --- notebooks/influence_synthetic.ipynb | 214 +++++---------- notebooks/influence_wine.ipynb | 253 +++++------------- src/pydvl/influence/frameworks/__init__.py | 37 +-- .../frameworks/torch_differentiable.py | 64 +++-- tests/influence/test_influences.py | 47 ++-- 5 files changed, 213 insertions(+), 402 deletions(-) diff --git a/notebooks/influence_synthetic.ipynb b/notebooks/influence_synthetic.ipynb index edb0f0517..39a4dfb58 100644 --- a/notebooks/influence_synthetic.ipynb +++ b/notebooks/influence_synthetic.ipynb @@ -1,6 +1,7 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "id": "6bd4dc3a", "metadata": {}, @@ -33,6 +34,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "eaef59fe", "metadata": {}, @@ -52,24 +54,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "23cb0e79", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/fabio/.local/lib/python3.8/site-packages/requests/__init__.py:109: RequestsDependencyWarning: urllib3 (1.26.9) or chardet (5.1.0)/charset_normalizer (2.0.12) doesn't match a supported version!\n", - " warnings.warn(\n", - "/Users/fabio/.local/lib/python3.8/site-packages/torchvision/io/image.py:13: UserWarning: Failed to load image Python extension: dlopen(/Users/fabio/.local/lib/python3.8/site-packages/torchvision/image.so, 6): Symbol not found: __ZN3c106detail19maybe_wrap_dim_slowExxb\n", - " Referenced from: /Users/fabio/.local/lib/python3.8/site-packages/torchvision/image.so\n", - " Expected in: /Users/fabio/.local/lib/python3.8/site-packages/torch/lib/libc10.dylib\n", - " in /Users/fabio/.local/lib/python3.8/site-packages/torchvision/image.so\n", - " warn(f\"Failed to load image Python extension: {e}\")\n" - ] - } - ], + "outputs": [], "source": [ "%autoreload\n", "%matplotlib inline\n", @@ -114,6 +102,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "001696b5", "metadata": {}, @@ -157,6 +146,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "99733a2f", "metadata": {}, @@ -165,6 +155,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "6623665f", "metadata": {}, @@ -188,6 +179,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "ebc8a087", "metadata": {}, @@ -207,6 +199,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "ec223a74", "metadata": {}, @@ -223,14 +216,12 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABagAAALYCAYAAACZoRUeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzddVhWSRsG8Hvo7g6xELtARezuzrW7u2tt11117e7u7u4Wu7tQQUK6eef7A9bPQEKBg3r/rotrhTNn5j6vrg4P884IKSWIiIiIiIiIiIiIiDKamtIBiIiIiIiIiIiIiOj3xAI1ERERERERERERESmCBWoiIiIiIiIiIiIiUgQL1ERERERERERERESkCBaoiYiIiIiIiIiIiEgRLFATERERERERERERkSJYoCYiIiKiVBNCSCFEKwXHLyCEuCyEiBRCvMigMbMmPHfpjBgvo/3qz0dEREREmRML1ERERET0GSHEyoRCpRRCxAohXgohFgohzH+gz9IJ/WVNo5hTAAQDyA2g2DfGHJXGxevXAGwBXPrRjoQQR4UQK3840df9LhVCnEzrfpMYL61fYyIiIiL6zbBATURERESJOYP4YmxWAH0ANAKwWslAX3AGcEpK+UJK6fsjHQkhtFLSTkoZJ6X0llLG/Mh4RERERET0fyxQExEREVFiohOKsV5Syl0AZgKoLoTQTayxEMJWCLFRCBEohIgQQpwUQrglXMuK+II3ADxPWEl98lsDJ9eXEEICyAFgfEJfYxPpox2ACQCcPlkNPjbh2gshxEQhxHwhhP9/2YQQfYUQN4QQoUII74QMtp/0+dkWGJ983lQIsVcIES6EeJYw9jclrJyuBKDtJ9nKJ1yzTljB7iuECBFCnBNClP3kXk0hxHQhhJcQIkoI8U4IsTHh2lgAHQGU+6Tfb2ZJyP0kYZuU8wAKfnFdCCGWCCGeJvw+PBNC/CWE0E7Ba9xCCHFJCBEkhPATQuwTQuRK6nUhIiIiot+ThtIBiIiIiOinEIH4xQ1fzR+FEALATgDaAGoDCAIwCsARIYQz4rfGqAdgF4DiCZ9HJzZICvuyBXAFwDrEF85DE+lqE+K3/2iJ/28B8mm7PgCmAyj5xTMNAvAUgA2AfwFsBFAusayf+BvAMAD9AHQAsFQIcV5K+egb7fsCyA7gXcKvASAgofh/AsB9ADUABAJolvDshaWU9wH0BtAUQCsAzwBYAyiV0Mc0xK8szwagYcLXghILIIQoAmAD4rdKWQkgH4BZXzYD8B5ACwA+iC9gLwIQA2AMkn6NtQFMBHAPgBGAcQD2CSHySSkT/b0nIiIiot8TC9RERERElCQhRF4APQFcklKGJNKkIuILz/mklPcS7mkD4AWAHlLK8UKIgIS2vlJK7ySGS7YvAN5CiDgAod/qS0oZIYQIBRD3jTZXpJRjv7jn0wLtcyFETwDXhBD2Uso3SWSeK6XcnJD1T8QXkSsASLRALaUMEkJEA4j4NFvCimQjAM2klLEJX54khKgEoCviC+BOCf2eklJKAK8QX6yHlDJUCBGBhNXvSeQFgIEALkophyd8/lAIYQdgzic5VQBGfnLPCyFEDgA9AIxJ6jWWUq749POEZ/NHfCH7XDLZiIiIiOg3wi0+iIiIiCgx5RO2uogAcAfxq3VbfKNtPgD+/xWUAUBKGYX4wwTzpXLctOwrKZe//IIQorwQ4pAQ4rUQIgTA2YRLTsn0deO/X0gp4xC/6tg6oc8RCa/jfx9lkuinGOJXbgd+eg+AMohfGQ0AKwAUAPBExB9c2UikcA/tL+QFcP6Lr539spEQonPCVh0+CVkmI/nXA0KIwkKIHUKI5wmv5auES8neS0RERES/F66gJiIiIqLEXALQFkAsgLe/4LYMYZ9+IoTIAmA/gDUAxgPwA+AA4CiA5ArAX742Ev9fCLIQwOZPriW1ElsN8dt7NEjkWjgASClvCCGyAaiC+FXaswBMEEK4SymDk8mZKkKIJgDmIX77klMAggE0ATApmfv0ABxGfMG7PeK3BwGAu0j+tSQiIiKi3wwL1ERERESUmAgp5ZMUtr0LwFwIkfeTbTm0AZQAMD+hzX9FXPU06CulolMw3n+KAdAF0E9KGZEwrmsqx/uKlDIAQEAilxLL5gmgDYBgKeX7JPoMBbADwA4hxF+I38u6HIA93+g3MfcAeHzxtVJffF4WwHUp5fT/viDiD7xM7jnyALAEMDJh32wIITwQv6c1EREREdFnuMUHEREREf2o44jfMmO9EKKUECI/gNUAdAAsSGjzEoAKQE0hhJUQwvgH+kqp5wBshBAlhRAWCSt7v+Ux4lc+DxRCZBNC1AcwOpXjpTabqxAiR0I2TcQf+vgc8YcJVhVCZBVClBBCDE/IAyHEYCFESyFEvoSV1B0AxOH/+10/B5A74bpFQnE/MTMAlBRCTBJC5BJCNED8vtSfegiggBCiXkLOvvj/4YufPseXr/FLAFEAeifcVwnxK73ld79aRERERPTLYoGaiIiIiH5IwmF99QE8ALAP8Yf22QCoIqX0S2jjA2A44reLeAdg1/f2lQo7AWxJ6McXwJAknuEW4g837Ir41cWDEH8oYXr5F/HbiNxMyFZKShmJ+JXQnojfa/oRgO2IPzTyZcJ9wQAGALgA4DbitwNpJKV8mHB9GeJfs/MJ/f6R2OBSyquI31O8eUI/wwD0/6LZIsRvebICwHXEr2If+0WbnfjiNU74fWqF+G1I7gKYhvjXU5X8y0JEREREvxsR/z0AEREREREREREREVHG4gpqIiIiIiIiIiIiIlIEC9REREREREREREREpAgWqImIiIiIiIiIiIhIESxQExEREREREREREZEiWKAmIiIiIiIiIiIiIkWwQE1EREREREREREREimCBmoiIiIiIiIiIiIgUwQI1ERERERERERERESmCBWoiot+AEKKdECJW6RxERERERERERJ9igZqIKJMSQhwVQqxMo+42AbBPo76IiIiIiH5paTwX/6/PpUKIk2nZJxHRr0BD6QBERPT9hBBaUsro5NpJKSMARGRAJCIiIiIiIiKiFOMKaiKiTChhtUYlAG2FEDLho13Cf1sKIfYLIcIATBDxlgghngohIoQQz4QQfwkhtD/p77MtPv77XAhRSghxTQgRLoS4KoQolvFPS0RERESUeXxjLl5eCGEthFgphPAVQoQIIc4JIcp+cp+mEGK6EMJLCBElhHgnhNiYcG0sgI4Ayn06v1fg8YiIMh2uoCYiypz6AsgO4F3CrwHAKOG//wAYCqBnwucCwHsALQD4ACgIYBGAGABjkhhDDcDkhP59AcwAsFkI4Syl5H7VRERERPS7SmwuHgHgAoD7AGoACATQDMARIURhKeV9AL0BNAXQCsAzANYASiXcPw2AM4BsABomfC0ovR+EiOhnwAI1EVEmJKUMEkJEA4iQUnoDgBBCJ+HyIinlui9uGfnJr18IIXIA6IGkC9QCQD8p5bWE/scCuAggB4CHP/4UREREREQ/n2/MxdshfsFIs08Wc0wSQlQC0BVAPwBOAB4BOCWllABeAbiS0GeoECICQPR/fRIRUTwWqImIfj6Xv/yCEKIzgE4AsgLQR/zf78lt4yQB3Pzk87cJ/7UGC9RERERERJ8qBsAGQKAQ4tOva+P/Z72sAHAEwBMhxJGEX+9JyZkxRES/MxaoiYh+PmGffiKEaAJgHoBhAE4BCAbQBMCkZPpRSSnjPvlcJvyX5xMQEREREX1ODfHbezRI5Fo4AEgpbwghsgGoAqACgFmIPzPGXUoZnGFJiYh+MixQExFlXtEA1FPQriyA61LK6f99QQiRNb1CERERERH9Br6ci3sCaAMgWEr5/ls3SSlDAewAsEMI8Rfi97EuB2BPIn0SERG4So6IKDN7DsBVCJFDCGEBQPMb7R4CKCCEqJfQti/+f/AKERERERGl3pdz8c0JX9snhKgqhMgqhCghhBguhKgPAEKIwUKIlkKIfAkrqTsAiEP8vtT/9Zk74bqFEEI74x+LiCjzYYGaiCjz+heAH+L3ifbF/08A/9IiAGsQv+fddQAlAIzNgHxERERERL+qL+firohfCe2J+Hn3IwDbARQH8DLhnmAAAwBcAHAb8duBNJJS/ne+yzLEH5p4PqHPPzLiQYiIMjsRf7AsEREREREREREREVHG4gpqIiIiIiIiIiIiIlIEC9REREREREREREREpAgWqImIiIiIiIiIiIhIESxQExEREREREREREZEiWKAmIiIiIiIiIiIiIkVoKB3ge1lYWMisWbMqHYOIiIiIfkJXr171k1JaKp3jZ8L5NxERERF9r6Tm3z9tgTpr1qzw9PRUOgYRERER/YSEEC+VzvCz4fybiIiIiL5XUvNvbvFBRERERERERERERIpggZqIiIiIiIiIiIiIFMECNREREREREREREREpggVqIiIiIiIiIiIiIlIEC9REREREREREREREpAgWqImIiIiIiIiIiIhIESxQExEREREREREREZEiWKAmIiIiIiIiIiIiIkWwQE1EREREREREREREimCBmoiIiIiIiIiIiIgUwQI1ERERERERERERESmCBWoiIiIiIiIiIiIiUgQL1ERERERERERERESkCBaoiYiIiIiIiIiIiEgRLFATERERERERERERkSJYoCYiIiIiIiIiIiIiRbBATURERERERERERESKYIGaiIiIiIiIiIiIiBTBAjURERERERERERERKYIFaiIiIiIiIiIiIiJSBAvURERERERERERERKQIFqiJiIiIiIiIiIiISBEsUBMRESUICQnBtm3bcP78eaWjEBERERFROvP29saJEycQEBCgdJTflo+PDzZv3ozbt28rHYUUpKF0ACIioswgPDwcrsXdEQI9RPi/xcghAzF40AClYxERERERUTq4fv06yleqAj1ze8QEv8eVi+eRLVs2pWP9Vt68eYPCRYtB2zoHgr3uY82KZahXr57SsUgBXEFNREQE4OLFiwiKFnBqOhEO9YZh7oKFSkciIiIiIqJ0MmfeAhgXrQunFlOgnd0dq1evVjrSb2fv3r3QdsgPhwajYFWhE+YsWKx0JFIIC9REREQAnJycEO7/Dh8eXULgvZPImTOH0pGIiIiIiCidONjbIdr7EcJ9XyLG9xns7OyUjvTbyZEjB8Le3EfQs+sIe3IRuXM5Kx2JFMICNREREeInRyuXLYb+04NwtVbDulUrlI5ERERERETpZNjQIShXICsC9v+DBlVKo0OHDkpH+u1UrlwZY4cPgfb9najm5ox/Jk9SOhIpREgplc7wXdzc3KSnp6fSMYiIiIjoJySEuCqldFM6x8+E828iIiIi+l5Jzb+5gpqIiIiIiIiIiIiIFMECNREREREREREREREpggVqIiIiIiIiIiIiIlIEC9REREREREREREREpAgWqImIiIiIiIiIiIhIESxQExERERH9QoQQjkKIE0KIe0KIu0KIvom0KS+ECBJC3Ej4GK1EViIiIiIiDaUDEBERERFRmooFMFBKeU0IYQjgqhDiiJTy3hftzkgpayuQj4iIiIjoI66gJiIiIiL6hUgp30kpryX8OgTAfQD2yqYiIiIiIkocC9RERERERL8oIURWAEUAXErkckkhxE0hxAEhRL5v3N9FCOEphPD09fVNz6hERERE9JtigZqIiIiI6BckhDAAsA1APyll8BeXrwFwklIWAjAHwM7E+pBSLpZSukkp3SwtLdM1LxERERH9nligJiIiIiL6xQghNBFfnF4npdz+5XUpZbCUMjTh1/sBaAohLDI4JhERERERC9RERERERL8SIYQAsAzAfSnl9G+0sUloByFEccR/X+CfcSmJiIiIiOJpKB2AiIiIiIjSVCkArQHcFkLcSPjaCABZAEBKuRBAYwDdhRCxACIANJdSSgWyEhEREdFvjgVqIiIiIqJfiJTyLACRTJu5AOZmTCIiIiIiom/jFh9EREREREREREREpAgWqImIiIiIiIiIiIhIESxQExEREREREREREZEiWKAmIiIiIiIiIiIiIkWwQE1EREREREREREREimCBmoiIiIiIiIiIiIgUwQI1ERERERERERERESmCBWoiIiIiIiIiIiIiUgQL1ERERERERERERESkCBaoiYiIiIiIiIiIiEgRLFATERERERERERERkSJYoCYiIiIiIiIiIiIiRbBATURERERERERERESK0FA6ABERERERERGRkvz8/LBu3TqYmJigZcuW0NBguYSIKKPwb1wiIiIiIiIi+m1FRkaimLsHooycEBv8HkeOn8TaVSuUjkVE9NvgFh9EREQpoFKp8PDhQ/j5+SkdhYiIiIjS0KNHjxAcEYMsdQbBoe5Q7Nq5U+lIRES/FRaoiYiIkhEbG4vK1WqieOnyyJo9J3bv3q10JCIiIiJKI05OTlBFhcH74jb4nFmHQkWKKB2JiOi3wgI1ERFRMs6cOYNbD58hd7dlcKg7BIOHj1I6EhERERGlEWNjY5w8dgTFzcJRt3h27Nq2RelIRES/Fe5BTUT0izl69CgmT50OB3s7zJg2BWZmZkpH+ukZGRkhJjwE0cF+iPL3gqWRkdKRiIiIiCgNFSpUCJs3rFU6BhHRb4krqImIfjKPHz9Gi9Zt0a5DJ3h5eX127dWrV2jQqCle6uXH0TveaNGmnTIhfwGHDh3C6NGjcebMGbi6uqJfr+54vLIPNJ6fwoqli5SOR0RERERERPRLYIGaiOgnEhMTgzLlKuLsG+DY4xBUrFL9s+tPnz6FvqU9LApWgnnRWrh7965CSX9u27dvR9OW7bD85GPUrNsAp0+fxrixoxEaFIjHD+4iX758SkckIiIiIiIi+iVwiw8iop+Iv78/QkJDkL/0H5CqOHhOrovY2FhoaMT/de7m5gatuHC83jkZkX6v0K19qxT3HRMTgzlz5+Lly1fo3Kkj8ufPn16Pkent2rsfpsUawqZ4XUCo4ciRIyhbtqzSsYiIiIiIiIh+OSxQExFloNjYWAwfMQqnzp5HvTo1MWLYUAghUny/lZUVcuVywavtEyHjolGxcrWPxWkAMDQ0xHXPy9i5cydsbW1Ro0aNFPfds3df7Dx+Cdp2ebCybHncv3MLdnZ2H68HBQUhJiYGFhYWKe7zZ1W+TGnsGTUeQgiE3DuBkkNbKh0pxQICAmBgYAAtLS2loxAREREREREli1t8EBFloH+nz8CqHYcRnL06ps9fhk2bNqXqfjU1NZw5eQx/9miBCQM6Y9/uHV+1MTc3R8eOHVGzZs1UFb+PnTgJ6/LtYV+uNQxssuPmzZsfry1ZuhQ2dvZwdMqGocNHpipzSgQEBODixYsIDg5O876/R7t2bTF1/CiUtgrH0vmzULNmTaUjJUulUqFR0+awc3CEpbUtzp49q3QkIiIiIiIiomRxBTURUQa6e/8B9HKUgEkOV4Q8v4EHDx6kug8DAwP06NEjzbNVrlgBO44th5ZNboR6P0PhwoUBAFJK9O3bH7nazYSmvgnmzO2I/n17w8bGJk3GvXPnDsqUrwgtIwsgIhhXLp1HlixZ0qTv7yWEQMeOHdCxYwdFc6TGqVOncOqCJwr234gPDy+gV7+BuOF5SelYREREREREREniCmoiogzUoW1r+F/ajDd7piLk3jE0btxY6UgfzZszC6N6tUOz4vY4f+YUbG1tP17T1NJCbEQIYiPDIFUqaGpqJtvfzZs34ZwnP8wtbTB79txvtps1Zy4MC9ZEttYzoOHkhhUrVqTJ8/xu1NXVIVVxkKo4qGKjoa6urnQkIiIiIiIiomRxBTURUQYqX748Lp49jWvXrqFUqcXInj270pE+0tDQQJ8+fb76uhACa1evRItWrREdFYVpU6fB3Nw82f7+aN0WcTkrw758HowYPQI1a1ZHzpw5v2pnbWWFmAunEPnhHWICXsHKqlqaPM/vpkyZMqhbowrWTGsKE1MzbNq/V+lIRERERERERMligZqIKIPly5cP+fLlUzpGqtSpUwfBgR8gpYSaWsrefBP4IRBmxbNDx9wBmrr6CAwMTLTd8GFDcevOPVzYPALVq1dHp06d0jD570MIgRVLF2PR/LnQ1NRM1f7jREREREREREphgZqIiFJECJGqoudfE8ahZ59+0NTRQ8nirihatGii7fT19bF7x9a0ivnb09LSUjoCERERERERUYqxQE1EROmiXbu2qFy5Ej58+IB8+fKleOU1EREREREREf0+WKAmIqJ04+DgAAcHB6VjEBEREREREVEmxeVsRERERERERERERKQIFqiJiIiIiIiIiIiISBEsUBMREaWhwMBA9B84CO06dMK9e/eUjpMpLVu2HAWLFkeTZi0QEBCgdBwiIiIiIiJSEAvURETf4dSpU1i+fDm8vb2VjkKZTP1GTbHp5G0cfxmH0uUqICQkROlImYqnpycGDB2OmLwNcP5ZILr37KN0JCIiIiIiIlIQC9RERKk0d9481GvSAqPnrEOhIm7w9fVVOhJlIp6el2Fbvj3sSjeH0NLDixcvPrseFBSEixcv4sOHD8oEVNiLFy+gb50dxjmKwjBXKTx68lTpSERERERERKQgFqiJiFJpyfLVsK3WGw51h0DDwgknT55UOhJlIjWq14TXnql4vW8m9LXU4Ozs/PHa8+fPkdMlD+q16IAcuXLjwYMHCiZVRqVKlaAW6o3XW8fi7cHZ6Nuzm9KRiIiIiEhBhw8fRtWaddClew8EBQUpHYeIFMACNRFRKhUskA9Bd47A/94ZhLx5BBcXF6UjKSIqKgqHDh3ClStXlI6SqaxbsxLjB3ZB36YVcOXieejo6Hy8tmTJUmhlL4lsrWdAP29lzFuwUMGkyjA1NcXtG9cwZ8JgnDp6EO3atVU6EhEREREp5NmzZ2jUtDmeauXG3ktP0K5jF6UjEZECNJQOQET0s5k/ZxYGDh6KB48uY/LiBShYsKDSkTJcbGwsylaojOfeAYgO+YCB/Xrhz5Ej0qRvPz8/REdHw87OLk36y2haWlro2rVrotcsLS0QG/AaUYHeiPF/CWvLvBmcLnMwNTVFw4YNlY5BRERERAp79OgRDG2ywbJQZYRaOOLWmd9vAQcRcQU1EVGqGRoaYvHC+Th9/DAaN26sdBxFXL58GfceP0O2VtPg1HQ8Zs6anSb9zp+/AFmyZkdOlzzoO2BgmvSZmfTo0QMVXF3weuMweOS2x4AB/ZWORERERESkGHd3dyDUF6/3TMHbAzPRpuUfSkciIgVwBTUREaXaoKHDER4cgKCn1xD27jEcHBzTpt/BQ5Crw2xo6BlhyfwOGDZ4EGxtbT9eDwsLQ0xMDExMTNJkvLR27tw59Ow7AGpqalg4dxZsbW2hp6cHc3NzAIC2tjY2rlujcEoiIiIioszBxMQE169ewc6dO+Hg4ICaNWsqHYmIFMAV1ERElCpxcXG4eP4sstcZAK+Tq+FzcRsWzkubFdTaOjqICvJFTOgHSKmClpbWx2srV62ChaU1rG3tMfLPMWkyXlqKiYlBzdp1EZa1EoLty6BchUpwyVsADk5ZsXLlKgCAv78/du/ejYcPHyqcloiIiIgoeVJK/DNlKtzcS6NP/4GIjo5O8zGsra3RtWtX1KpVC0KINO+fKL14eXlh8JChGD9+AkJCQpSO81NjgZqIiFJFXV0dufMWQMSbezDN6QYLMzO4ubmlSd8b16+Fz4F/8WT1QMyc/u/HlccA0LNXHzi3/Rf5ey7HjJkz4e3tnSZjppWwsDBERkbCNJc7THOXQmREOPJ0W4ycLaeg/6DBePfuHfLmL4TuwybCrYQHDhw4oHTkTCsiIgIfPnxQOgYRERHRb2/79u34Z9YChOWshU0HTmPy3/8oHYkoU4iKikIJj9LYcOYxFmw7jtr1eMbOj2CBmoiIUu34kYOoXcQeVZz1cfb0CWhqaqZJv9WqVUOArw/CQoLQtcvnJ3ira6hDFRMFVWwMpEoFdXX1NBkzrZiYmKB+gwZ4uro/nqzsA01tXcRFhSM62Bd6enrYvXs3NO3ywLHJBFhX6Ijps+elqv8zZ85g5cqV8PHxSfE9T58+xaNHj1L7KIrau3cvLKysYWvvgC7dekBKqXQkIiIiot/W48ePoZelEIxzFIVejpK4e5/vBCQCgNevXyMsMgYOVbvCoWZfXDh3WulIPzXuQU1ERKlmY2ODhfPnZuiYq5YvQ6vWbRETE43JkyfD0tIyTfuPi4v74aL3hrWrcebMGaipqeGK5zWMGtUb+gaG2LJpPSIjIxH+7jFCXt9D+ItryOmRJ8X9zl+wACPGTICBnQuGDh+FO7euJ/v8o8eMw/RZsyHU1NC2VUvMnT3zh54to3Tv1RdZGoyCgZ0zNi3tjj69eiB//vxKxyIiIiL6LTVs2BCTp0zDm8ggBD6/iS5bNykdiShTcHR0hIGuFl4fXghV2Ad4lC6ndKSfmvhZVya5ublJT09PpWMQEVEGUqlUUKlU0NBIu5+v+vv7o3K1mrh53RPuHmVwaP8eGBoapln//5FS4u9/pmDV2g0oXKgAliycn+JxihQriUiXujDOURRe2ydg+p990LRp02+2j42Nha6ePgr2WQ2hrok7c1rj3RsvmJqaptXjpJtsOV2gVawlDBzy4PGynrh8/jRy586tdCz6BQkhrkop02Z/ot8E599ERL+nV69e4cyZMyhUqBAXDhB94s2bN5gzdx4M9PXRr19fGBgYKB0pU0tq/s0V1ET023r9+jV0dHTSfCUu/V9UVBQWLVoEXz8/dO7UCVmyZPmh/tTU1KCmlra7U/0zZSp8YI5iI/bg+a4pmD9/PoYOHZqmYwCAEALDhw3F8GGJ9339+nXcv38fFStWxMuXL9GsRWuEBAdj8l8TkD9fHhy7eRRx0eEIfvMQuXLlSnIsNTU16OrpIdz7GdQ0taGmpg4dHZ00f6b0sHzJQtRv2BjhYSEYMHAwi9NERERECsuSJQtatmypdAyiTMfe3h5/T/5L6Ri/BBaoiei3I6VEl249sGHjJqjiYjF71gx06thR6Vi/pDbtOuLk9UfQMLXH4iUeePLofrqsTv4RUdHRUNPSBYQahKYOotLhZPLkbN26FR26dIeRY15E9h8IHR1d6Lg1hb2lE/r2H4ib1zyh8+8M3H94ARMWzEXhwoWT7E9NTQ3btmxGu45dEBcXi3VrVkFXVzdjHuYHVahQAYEBfoiNjU2zvc2JiIiIiIgo8+IWH0T023n27BkKFi2GPN2XISrQBy83jkDQB3+lY/2SzCys4NTqXwg1dbzcOBIHdm5C8eLFlY71GS8vL3iUKYeAgA+ws7PFhbOnYW5unqEZKlapgdfGRWCerxy89v4L33vn4NJ+BnRMbXF9Rkvs3bEF1apVy9BMRL86bvGRepx/ExEREdH34hYfRESf0NHRgYyLQ0zoB0QF+kBXT0/pSL8sj1KlcXrrRIT5voYQapg5ey7WrVkFIYSiuZ4/f46NGzciS5Ys+OOPP/Ds8UP4+vrCysrqhw9K/B5587jg/slzUNfWR5jXPZhbWODeigFQ19KFloEx3r17l+GZiIiIiIiIiDJC2m7kSUT0E7Czs8M/kyfh8cp+CDi+EIULF4aZhRUqVa2BDx8+KB3vl7Jp/RpEB7xB/o6zUKT/OuzZtx/Pnz9P0zFu376NKVOm4PDhwylq//79e7iVKIm5uy6i74iJGDp8JDQ0NGBra6tIcRoApvz9F2q554HB0wOYOGYE2rVpA2MrB5jnKwcRFarIqvO3b99i69atePToUYaPTURERETx3r17hxMnTiAwMFDpKERE6YYFaiL6LfXq1RNhIUGYNmUyrj18BadW/+K+v8SfY8YpHS1TCw4ORvlKVaGjp4/qteogPDw8yfb6+vowMzdHhL8XooJ8EBcbA700XLF+9+5dlCpTHrN3XkTTVu2xatXqZO+5cuUKdCyc4FitB2yqdMfO3XvSLM/30tPTw9LFC+F58Sx69uiBCePH4s8BPVCrgAUO7N2NvHnzZmieJ0+eIF/Bwug3fiZci7vj5MmTGTo+EREREcXPW13y5keLLv3gkic/vLy8lI5ERJQuWKAmot9aQEAANI1toG1sBS2LLPDz417USZkydRoeBqiQv/dq3HgRgPnz5yd7z6b1axF2YRVebhiO6dOmwMbGJs3yHDlyBMZ5SsOhSldYlG6FTdt2JHtP/vz5EfL2Cbwv7YTfxc0o6V4izfKkFXV1dfTr2wdLFi1EmTJlMnz8rVu3Qt+5FBwa/Alzjz+waMnyDM9ARERE9LubPnsuTIs3gVOLKdBwLIz169crHYmIKF2wQE1Ev7WWLVtCzf8xnq7ohUDPHRg6eAD8/f2xevVqrhpNRHBICNQNzKGhYwB1A3MEB4d8dl1Kibnz5qFGnfqYPn0mpJQoU6YM3rx6gaAP/ujWtWua5ilatCiCH13E++uHEHTzADxKFEv2HicnJxzcvwceluHo1KAiFs2f+/FaTEwMwsLCEr1v8ZIlKF+5Gv6a/DdUKlWaPUNmlD17dkR43UHwy9uIfHENzjmzp2n/AQEBGPXnaAwdNhw+Pj5p2jcRERHRr8LB1hbR3g8Q/v4Fov1ewNbWVulIRETpQkgplc7wXXiKOBGllfDwcNy7dw/Zs2eHuro68hUsDGniiHDv5xgxuD8GDxqgdMRM4/nz5yhZqiyiVYCetgauXDz/2UR548aN6DFwBMzdm+HDle34Z8wQdOzYMV0zbdu2Des2bkHxYq4YPHDAd+8jffToUTRo1BhRkZHo3KUr5s6e+fEwx3nz5qH/0JFwrNwZ3he3YWjPDhj956i0fIxMRUqJ8RMmYuuO3fBwL47ZM6dDW1s7zfov7Foc72EGoaEFnQ+P8PjBPaip8WfmlLGSOkWcEsf5NxFRxgoNDUWb9p1w+coV1KtTG3NmzeCciYh+WknNv1mgJiL6xP79+9FpwGhkaTYJIa/vIebicjy6d1vpWJlKREQEXr16haxZs35VtBw0eAg2XvGGQ7mWeHd+K2o4a2PhJyuUExMXF4cu3Xpgy5YtyFegIHZt2wwrK6v0fIREZXPODe1irWDgmBePl/fE2eOHUaBAAQBA/gKF4K+fA07VuuL99YMw8b6Aa5cvZnjGX0F0dDR0dfXgNnIPAIHbM5rhxdPHivye0++NBerU4/ybiIiIiL5XUvNv/uiNiOgTOXLkQKjPCwTcP4vA20eQN08epSNlOrq6unBxcUl0RW3DBvURdHMf3hyejwDPHWjauGGy/W3duhW7j55BzvZz8DrWBEOHj0yP2KnzxQ9vXVxywffGIbw4OB+vjy1HmZKZb9/qn4WWlhYKuxbD6z3T8frAHDg4OMDCwkLpWERERERERKQQFqiJiD7h4uKCNSuXwfL9eVTMZ4MVSxcpHemn4uHhgVPHjmBQ84o4dmg/KlasmOw9gYGB0DSyhKahOTRNHeAf8CEDkn5tyYK5eLNvGm7NbIHWLZojf/78H68tWrgABfLnQ+CtI6hYthSmT5+eqr6vX7+OIUOHYeXKlfjvnUtHjx5FsZKlUbl6TTx79ixNnyWzO3b4ALrWL4OO1V1x7vRJvlWViIiI6CcUFxeHZcuWYfz48b/dfJaI0ha3+CAiIkUFBgaimLsHAkIiEBsRgqOHDqBYseQPO0wPsbGxiI6Ohp6e3g/1ExISAnV1dejp6eHx48dwLeYOo0LVEfniKvp0aoVePXvAKVsO2FTtiegALxj43cLdm9fS6CmIKCV+5S0+hBCOAFYDsAYgASyWUs76oo0AMAtATQDhANpJKZP8i4jzbyKiHxcXF4eYmBjo6OgoHeWH9ezdF5v3n4CWVU5EPj2Ph/fu8J1xRPRNmX6LDyGEoxDihBDinhDirhCir9KZiIgoY5iYmODOzes4cWAXXjx9rFhxGgA0NDR+uDg9fuIkWFrZwNzCCitWrsTFixdhnL0IHMq3gZnHH5g9byFy5HJBLNRhlqcUzApWxssXXHFCRGkqFsBAKWVeAO4Aegoh8n7RpgYA54SPLgAWZGxEIqLfz/Hjx2FqbgFDI2P0HTBQ6Tg/bO/+A7Ct0h2OVbtC29QO169fVzoSEf2kMkWBGimbRBMR0S9KW1sbBQsWhKmpqdJRfoifnx8mT/4b+XosQ652M9CzZ2+4ubkh8Nk1vD23GW8OL4LK0BpZmk+BSgKPVw3Ey02j0KVzZ0RHR+OvyX+jTfuOOHv2rNKPQkQ/MSnlu/9WQ0spQwDcB2D/RbN6AFbLeBcBmAghbDM4KqWz+/fvKx2B6Kdy69YteHp6Ir3ead6xaw/Y1uiPQv3XY8Wqtbhz5066jJNRSnmUxPuza/H2/BaEvn+JfPnyKR1JUdHR0fDz80u3Pz9Ev7JMUaBO4SSaiIgoU4vfS1lCFRcLVWw0hJoacufOjUP796JmLl2ULJofetY5oGtuB4uCFVG6sDO2r1+Jf6dOwYBBQzBr5TacequJGrXr4vHjx0o/DhH9AoQQWQEUAXDpi0v2AF5/8rkXOP/+pVy7dg0FCxZE3759ERcXp3QcokxvyLARKFOxKqrUbogWrdumyxgqlQpCTR0QAkJNDSqVKl3GySjLFi9E18ZVUSmLwImjh2FnZ6d0JMV4enrCxs4Bjk7ZUKNWXcTGxiodieinoqF0gC8lMYkmSlZ0dDRGjRqFYcOGwczMTOk4RPSbMTMzw6SJEzFsWCeoa2hg5fLlEELAw8MDHh4eePr0KUp4lMbzt3cQGxqAf8+dgbOzMwDg9NnzMHdvCqOsBaHyvocbN258vEZE9D2EEAYAtgHoJ6UM/s4+uiB+CxBkyZIlDdNReitUqBB69eqFmTNn4tmzZ9iwYQMMDAyUjkWUKalUKsyY/i8K9l0DdU0d7JrdGj4+PrC2tk7TcZYsmIuGjZsgJjoGHTp2RIECBdK0/4ymq6uLcWPHKB0j3URFReHWrVtwcHCArW3SbzLqP2goTDxaImfByri2fgj279+PunXrZlBSop9fplhB/Z/kJtFCiC5CCE8hhKevr2/GB6RM79q1a5g1axbKlSuHd+/eKR2HiH5DA/r3Q1hoCEKDg9CsWdPPruXIkQNPHt7HrvXL8fTRg88K0PXr1sL7E0vx+ugSBL++B3d394yOTkS/ECGEJuLn1euklNsTafIGgOMnnzskfO0zUsrFUko3KaWbpaVl+oSldKGuro4ZM2Zg3rx52L9/P8qUKQMvLy+lYxFlSkIIGJuaIfj5DYS8ugs1NaTLD3SqVq2KAD9f+L73xoJ5cxB/Xm3msmfPHrRp3xELFiz8rbeqCAsLg2uJkqjRoDly5c6HgwcPJtleQ0MDMiYKUMVBxsVCQyPTrQclytQyTYE6BZNoTpApWe7u7ti3bx+eP3+OMmXK4Pnz50pHIkJERAT6DRiIilVqYOPGjRk+/vLlK5A1Ry4U9yid6baN+PDhA6rWqA0rWwf07jfgq7c5SikRHR2tULrvp6mpCXV19USvmZiYwN3dHSYmJp99fdyY0Zj515/oUrUALp0/C0dHx0TvB4COnTrD2MIG+Qu5wt/fP8ks/v7+iRYkpJR4/Pgx/Pz8kn8ghcXFxeH69et48+ar2hkRJULEVzyWAbgvpZz+jWa7AbQR8dwBBEkp+dP9X1CPHj2wd+9ePHnyBCVKlOAhZkSJEEJgz87tUH+wF1GXV2Hzxg3Q19dPl7G0tLRgZGSUbLsjR45gyZIl8PHxSZcciTl16hRatuuE0z46+HPyDMyeMzfDxk5PUkocOHAA69atQ2hoaIruOXDgAPwj1ZGjwzzYVO2BsRMmJ9l+zsx/EXlrL65OaYRKpYujevXqaRGd6LeRKQrUKZxEE6VI5cqVcfToUfj7+6N06dK4d++e0pHoNzd46HBsPHwJr02Komuvvrh0KeN2MHr69Cn6DhgE/XLd8V4/N5q3bJNhY6fE0BEjcddPBdtG47Bhx35s3/7/n09evXoVljZ20NM3QPuOnX/5FRxCCLRq1QpjxoxB7ty5v9luwYIFWLt5B+xrDcTbKG2Ur1Tlm21XrVoNR6dscMlbAJ26dPv4GsbFxaFmnXpwcy8Np2w5PnvdM5uYmBiUq1gFlWrWh0ue/Ni8ebPSkYh+BqUAtAZQUQhxI+GjphCimxCiW0Kb/QCeAXgCYAmAHgplpQxQo0YNnDt3Durq6ihTpgz27NmjdCSiTKdkyZJ4cOcWnj16gJo1ayqaZcrUaWjauiPGzd+IQkXckl2QkFYuXboE49xlYFOsLoyL1sHJM7/Gwd0DBw9Bq869MHjSHBQvWQpRUVHJ3mNubo6oYF9EBrxBlM9TWFpaJNk+f/78eOv1EhHhYdi4bk3C2TRElFKZ5f+YRCfRSoein5e7uztOnz4NlUqFsmXL4sqVK0pHot/YtRu3YJy/MszzloVRlvy4f/9+ho3t6+sLbQMTGDjkhmG2wvD29s6wsT8VEhKC+o2awjFbDvQbMPDjSul373ygZZ0TuuYO0DZ3wPv373Hv3j0Ucy+FshWrQsOpOIoM2ozdB4/h1KlTimT/UlxcHGbMnIUOnbookunKlSswzJIfRlkLwixPabx+8+0Fj/0HDUaOln8jb88V2LR1G54+fQog/puPy9fvwKX7cmRpMAKDho3MqPipdu7cOTx88QbOnRfCsf5wjBg9TulIRJmelPKslFJIKQtKKQsnfOyXUi6UUi5MaCOllD2llDmklAWklJ5K56b0VbBgQVy6dAl58uRBvXr1MGvWrF/+h79EP6vlq9fCrkZfONQdAjUTO5w7dy5Dxq1YsSIC756A1/GV8L+wEfVr18qQcdPbypWr4NjwTzg2Hov3H0Jw9+7dZO8pX748undogzdbRsE27g0WzJ2V7D1CCGhpaaVFZKLfTqYoUH9rEq10Lvq5FShQAGfOnIGhoSEqVqyIkydPKh2JfmExMTGYOXMm+g8YiDt37nx2rWPbVvA+thhee/9F2Os7qFSpUoblcnV1hXNWBzxb2RcvtozFyOFDMmzsT40eMw6Xn/nDtNpgrNu+/+Mq2OFDBsL/3Do8X90fagHP0KRJE9Rv1BS+pgWRpc4g+N06itiIUAg1dcTFxX3WZ2xsLCb/MwXNW7bGoUOHkhw/NDT0q/tTQqVSYfny5Rg2bDhu3rwJABgzdjz+mrMMx14L1K7fELdv3051v6m1ceNGFClWEg0aN0Pz5s3x4eFF3JjTDs/3z0XlcqW+eZ+Ojg6ig/0QExYEVWwMTp06hRwuedG+YxdEhQUj+MVNhLy6DSNDw3R/hu9lamqK6NBARPp5IcL7CSzMzZWORET007K1tcXJkydRv3599OvXD71790ZsbKzSsYjoC4ULFMCHGwfgd+cEQt89Ra5cuTJkXDc3Nxw5uA8dKjhj9ZL5aNs2c7378ns5u+SG/7V98L9zAlGhgXBwcEj2HiEEJk0cDz+fd7h07nSK7iGi75cpCtRE6SVnzpw4ezZ+L9fq1avz7YyUbnr16Ye/5q/GlqveKFW2/GeHdHbs2AF7tm3En10a4cbVK0nuLZzWNDU1cfrEUWxftwxXLpxFj+7dM2zsT71+8xZatrmhZ50NWpZZP74+Hh4eePzgHnasW4oHd2/D0tIS3u/ewsTZHUbZCkGoa+Luws4o614UFSpU+KzP0WPGYcbS9bgUaIImf7TCtWvXvho3Li4OjZo2h5m5Baxt7RNt8x+VSoVXr14hIiLi49fGjB2PIeOnYu35lyhTviKePXuGE6fPwqx4Y9i6N4RJDtdE36Fx9+5dlCxdDgWKuCVbPE/O/fv30bl7L0Q418KVN1GYOWce3IoXg6G9C+xLNcXxU2cQFBSU6L3r16xCwPGFeLisJ4YPGYw+/QZAq3gbxOSsjNjYGDzd/jd8Lu9GoUKZ9wT5QoUKYcTQQfDa+icMfa9i9YqlSkciIvqp6evrY+vWrRg0aBDmzZuHunXrIjj4q/PpiUhBixfOQ52SLnAKvYV1q1ckuf1bWnN3d8f48eNRt27dDBszve3YshHF7TRgH3Qdu3dsg5WVldKRiOgL4md9W5ebm5v09OQ7ESll/Pz8UKNGDVy/fh2rVq1Cy5YtlY5Ev5jsufJAv3wv6NvmxOstf2Lpv+NQo0aNH+73xo0b6NN/EABg5r9TULRo0RTf6+vri05de+Dps+cY2LcX2rdv98N5vtf58+dRvVYd6Fs4QIYF4JrnJdjZ2SXadtyEiZg+ex40dQ2R39kJWzdtgIXF13u+lalQBe+tS8HUpSTe7J+BMV0bo1OnTp+1OXDgANp064dsrabB79Yx2AbfwrlTx7/qKyIiAmUrVMaDhw8hIDFx3Bh06dIFHmUrIiJ3PRhnK4w3u//GlCFd8Oq1F6bMWQzdrK4Ivn0EnpcvfLWqJVtOF8C5ErSMrfFm/wx4vXrx1aGIKXXw4EG07zMcTn/8jZDX9xB9YRne+3gjR9tZ0DKywNMVvXB412YUKVIkyX6ePn2KIsVKInePFYj0f4M7S3qi6KBNgEqFmzNbICw0lG9JpN+KEOKqlNJN6Rw/E86/fz2LFy9Gjx49kDdvXuzduxdZsmRROhIR/WTCw8Nx9epVZM2aNUMX4hDRzyep+bdGRochUoKFhQWOHTuGevXqoXXr1ggKCkKPHjwLiNJOlUoVsePYMmjZ5kGo9zMULlz4h/tUqVSoXK0GjIo1AYQaqlSviffv3kBdXT3Je/z9/WFubo6OXbrj6rsYGBVojL4Dh6Bo0SIoVKjQD+f6Hh4eHrh/5xYePnyIokWLJlmsHfPnKNStXQtBQUEoXbo0NDQS/6eqcf26GPfPdIS9voPgJ1dQrtycb/Qoks23detWeAXFIG/vNfC5sgdDR0/E6nUbUb5sKazZsR5hbx8h8PlNuLq6onnz5nB0sMe9+/fReM6wRN9y+e6tF/LWLQ1NfRO809CCv7//dxeoS5cuDV0ZjldbRiPM9xUmjhmFcxcu4sS+6dAwsYUWYuDi4pJsP9mzZ0eZUh64uKI3YiJCoamphbA3jyDjYqCrp//N15mIiH5dXbp0QbZs2dC4cWOUKFECe/bsgZsbf25DRCkTFBSEosVKICRGDREB3ti6eQOqVav2Q33GxMTg/PnzMDU1RcGCBdMoKRFldvxulH4bRkZG2L9/P5o1a4aePXsiMDAQw4cPhxDJF6+IkjN39kzknT8fL1+9Rod5J2Fra/vDfUZERCDoQwCyF6oCAPA6sghhYWEwMjJKtL2Pjw9Kl6uAN15v4ODoAKGmDiPXVjDOVghBVlnw8uXLJAvUb968Qd2GTfD44QO0bNkS8+fOTtP/P+zt7WFvb5+itsmtBgaAPn16wcnJEffu3UPdRWPh7Oz8VZuqVauiTPFC2DutCQyNTbD1YOLHG+jo6CAuKhyqmCjEhAVB3zEfnr1+jgXNmiKLowPuP3iE9hP3fyxGt2jRIslsvXv1xtJVQ6Gho49ibq7Inj17Cp46cQYGBrhx9QqOHDkCBwcHlChRAt26dsHy5csREBCAdu2WQE9PL9l+hBDYvXMbLl68CAMDA7x9+xZde/SGmpoadm7flmYnjZ86dQpDR46GoaEhFsyZiZw5c353X1JK7Ny5E/fu3UO9evWQP3/+NMlIRET/V6VKFZw/fx61atVC2bJlsX79etSvX1/pWET0E9izZw8itMyR/Y/R8L9zEpP+mfZDBeq4uDhUrFIdD569RlRYEEYNG4whgwelYeKMFxYWBg0NDWhraysdBYGBgfD390e2bNnSbO5PlGaklD/lh6urqyT6HtHR0bJly5YSgBw8eLBUqVRKR6JMysfHRzZv2VqWq1RVHj16VJEMDRo3lRZZXKSlU25Zr0HjJNsOHTZc2hWvLYv/eUDautWUtWrVloZmVtI2t5vMmsNZBgUFJXl/46Z/SIfSTWXhfmukuaOz3L17d6qyqlQqGRcXl6p7pJTyxo0bsk6DxvKPVm2kl5dXqu9PiZCQEBkbG/vN67GxsbJJ8xYSQk1qGVlKmxKNpIaOgSxUtJi8du1aqsdTqVTy/Pnz8siRIzImJuZHon/TjRs3ZJnylaRH2QryypUr6TJGYkJDQ2W7jp2la4lScv6CBZ9dCwwMlIbGpjJHw6EyS6X2Mlee/D801qxZc6SpbVZpV7KhNDQxk48ePfqh/og+BcBTZoI57c/0wfn3r83b21uWKFFCCiHktGnTOEcmSiE/Pz95+/btFM35goKCZEhISAakyhiHDx+WprZOskC3hdLevb5s1qLVD/V3/fp1aWrjKIuP2icLdl8szSyt0yipMoYOHyk1tXWkrp6B3Lp1q6JZDh48KPUNjaWhqaWsWKV6un2PQpSUpObf/JEJ/XY0NTWxevVq9OzZE1OnTkXXrl0RFxendCzKhJq2aI0zT4PhZVQY9Rs1wZs3bzI8w5aN67Fy/r9YMW8atm3ZmGTbuLhYqGKiAEggLhpubm44dfQgFvw9CjeveX5z5fV//D98gJaZA7QMLaBlaI7AwMAU59ywYSMMDI2hb2iEZcuXp/i+sLAwVKhcFbfCLXDmRSSq10qfw1gMDAw+bo0SFxeH9+/fQ6VSfbyurq6OzRvW4emTx3B3Kwjfa3uRre4ABNt5oGadeqkeTwiBkiVLonLlyl9tnREXF4f4f5u/n5QSVarXhJd+XrwzLoSq1WsiNjY21f3MmTsPufMXRr2GTeDv75+iewYOHoqDVx4jNEcNDB89AadPn/547f379xAaWjDPVw4Whari5Ytnqc70qa07d8OibFs4VukC45zFcPLkyR/qj4iIvs3a2honTpxAo0aNMGjQIHTv3h0xMTFKxyLK1I4fP46s2XOiTOUaKOFR5rPDtr80YdJfsLK2hYWVDRYvWZKBKdNP5cqV0bNzO/jt+xu5DCMwe8a/P9SfhYUFosNCEPLqDoKeesLGNvEza34GL1++xJy581Cg9ypkaz4BXbr3VDTPoGEjYV+zH/L0XIlbD5/jxIkTiuYh+hIL1PRbUlNTw5w5czBy5EgsWbIELVq0QHR0tNKxKJN5cP8+zIvUgkWBitA1scLLly8zPIO6ujpq1aqFWrVqJbn39PPnz7Fi5RoEPLqMyxNrwTTWD3379kGRIkVQr169ZIvTADBhzCj4nl6Jx0u6wEwzCg0aNEhRxtjYWHTo1Ak5Wv2DXO1molevPggPD0/2voiICBw6dAixcYB18Xqw9miGh/fvpmjMT8XExCAsLCxFbd++fYucLnmQNYcz8hUs/FVRNnv27NiwZjW0dXRg4lwMZnlKw9fHGyEhIRgwcDAaN2uBc+fOpTrjf8ZPnARdPT2YmJnjyJEj391PVFQUPvj7wqJgZVgUqIiwsDCEhoZ+s72UEqdPn8bp06c/FscvXLiAP8dNgppba3h6RaBHr75f3ffkyRM4584HbR1ddOvRC1JK3Hv4CIYupWGS0w0GDrnx+PHjj+2zZ8+OPC658HLDcLzYNAIdOnRM1XN5eXnh+PHjCA4OBgCU8XBH4NWd8PHci6CnnnB1dU1Vf0RElDq6urrYtGkThg0bhkWLFqF27doICgpSOhZRpjVi9DjYVOmOXF2W4E1gFA4cOJBou4CAAEyaNAl5eyxF7g6z0advv88WS2RWUkrMnj0XVWvWwdRp079aZCGEwIRxY/H21XMcP3wQVlZWPzSeg4MDli1ZiKiLK2EVchfbNq3/of6UJISIPwpHSkClgprCW4sa6OsjOtgXMeFBiI0Mg4GBwVdtYmJi0KVbD2TN6YL2nbqwRkIZintQ029LCIGJEyfCxMQEgwcPRnBwMLZt25aivVzp99C2TWssXT0Z2mZ2MNRCmhx8mF6WLl0G7ZweyFmlC7yOr0DFojYwNTVNVR+lSpXCi6eP8ebNG7i4uEBLSytF90kpERcbC3UdAwg1daikKtl3JXz48AGuxd0RHBmHiPBQvNgyFjI6HPUbNkpV5gMHDqBx0+aIiY5Cr969MX3a1M+ur1u3Htt27kbpku7o168Ppk77F5HmeVGgxWw82zEF48ePx6xZsz67x9bWFhUrVsSFVf0RFxOJ7j16ol3HLjj/0Ac69nlRo1Zd3LtzEw4ODqnK+vz5c0yZ+i/y91qJCJ8XaNuxM96+epGqPv6jo6ODBo2a4PiagYiNjkLp0qWTPISxdbsOOHD0FACgRuVyWLtqBV69egV962wwcsqPuKgwPH1++Kv7uvfui2gHd+SvMwZbNgxHw/pH0KtrJ3Tq3gvhD08hyucJatSo8bG9uro6Th0/ggMHDsDAwACVKlVK8TOdPn0ates2gL6lA0RkIK57Xsa4saNhZGSIG7fuoO36tShatGjKXyQiIvouampqmDx5MnLmzIlu3bqhVKlS2Lt3L7Jmzap0NKJMx8TEGG/9vRAd7IeYsA8wNjZOtF38fr8CMjYacTFRkFJix44dqFu3LjQ1NTM2dCps2LABY6fMgHnJ5vhn9iIYGxmiS5fO6Tpms2bN0KxZs3Qd43vFxsbixo0bsLS0hJOTU5Jts2TJgkH9+2Py5LbQ1NTC+nVrMihl4pYumo/a9Rri3smV6NWrF9zd3b9qs2DBAuw8fhHWlfph/8nlmD1nDgYNHKhAWvodcQU1/fYGDRqEJUuW4NChQ6hatWqqtjWgX9vff03EumXz8ffgLrh25ZJiP7yIjY3F4KHD4VqiFEaPHZfoagsLC3PEBnghKtAbsR/ewNrS8rvGMjMzQ4ECBVJcnAbit82ZMmUqHizpjvuLumD0n/EH5CVl8+bN8A2NQbSaLvQd88JSMxKzJg7H+jWrUpW3XcfOgIElNExssWDhIjx8+PDjtUOHDqFn/0G4GW2P8dNmoVmz5nj06BFio8IBqUJcXDR27NrzVZ9CCOzctgVbVi/G/h2bMXvmdHh6esLCvQmsi9WBvlUWPHjwIFU5gfjfR6GuDjUNbahp6yL2B982vWj+XGjKKGjoGuDyFU/s2rUr0XahoaHYvHEDsredgextZ2Dzxg0IDQ1F1apVoR7mjVebRuLdwdkY1K9XIveGQdPIAho6BtDQMUBYWBiaNm2KU0cPYeqw7rhz8zrs7D5/66W2tjbq16+PypUrp+qQzanTZ8GiTGs4tZgCYeWCLVu2QENDA0OHDMaGtatQvXr11L1AP2jp0mXIV8gVdRs0hq+vb4aOTUSUGXTs2BEHDx6El5cXSpQogcuXLysdiSjTWTh3NowD7+HJit5o07wRKlasmGg7ExMTTJvyD+4t6ob7K/pB29Ac3YeMRZ16DX9467fU+PDhA9q074gyFapg9+7dyba/fuMm9HJ6wDxvWei5lMG1GzczIGXyoqKisH//fly8eDHDxoyNjUWFytVQrW4T5CtYGKtXJ19wHjd2NIKDAhEUGIB69VK/bWBaypcvH54/eYjI8DBMm/JPovP0115voGXjAn2b7NCydcHLV68VSEq/rW9tTp3ZP3hIC6W1zZs3S01NTVm4cGHp4+OjdByij/6dPkNa5igkc7eaLM2z5JYrVqz4qk1kZKRs+kdLaW5lI+s1bCLDwsIyPOeHDx+kv79/su1UKpVs1Kix1LPOJnO3/lvq2zrLEiU9vmtMLT1DmaVaN5m71WSppqEtz549+/HapEmTpH2pxjJvu2lSXcdAWhWuLHX1DaWmrqGEUJN61tllrrwFUjTOgEGDpXkWF2nnVkNa2djLgICAr9qsXbtONmzaXM6aPeebB0v16NVHauvpS119A7l585bveub/bNiwQdrlKylLjD4onZuOlsVKlpFeXl4yMjLys3axsbHSxMxC5mgwVOZoMFSamFl8PDAyMDBQ7tmzR965cyfRMU6fPi0NjU2loZmVLFm63Fd9p6XuPXtL2yJVZIGuC6S5o7OiB8lcu3ZNGppZydyt/5H2JerKuskcUEo/J/CQRM6/KUXu3bsns2XLJnV0dOSWLT/2bxfR7y44OFiqa2jIYiN2y2Ij90otHT354cOHDBu/XsMm0s61uszZeIQ0MDaTDx8+TLL9+fPnpYGxqXQsUUcamJjL48ePZ1DSb4uOjpZu7h7SKnt+aWxpJ8eNn5Ah4545c0aaO+aUxUftk3nb/SudcuTKkHEz0v3796WxmYW0ze0qjUzN5e3bt5WORL+YpObf3OKDKEGTJk1gaGiIhg0bokyZMjhy5AiyZMmidCwiPHj4CDrZ3GCcvQhCXtzEw4ePvmqjra2NTevXKpDu/5LaYuJTbTt0wt4Dh2FRrB6MsxVGqEtJ5HfW+a4xNdXVYOpcHNom1tDSM/i4utzX1xf29vYIujMNQS9uwdajMexLN8ebMxsgn5xCSIQ+4sL9MW3JzBSNM/Wfv1HMtSjevn2LZs2WfLV9yv79+9Gz/2CYuTfDqalzoK6uhp49eiAqKgorV65EREQE2rVrh3lzZmH82NHQ0dGBvr5+suMGBwfH75udM+dXhy3a2dkh3Pc1Qt8+Qujzq/B/+QQueQtAR0cbJ48dQf78+QHEb7txYN8edO/dDwCwdt+ej/uZGxsbo3bt2t8cv0yZMnjz+iXev3+PbNmyJbw9NX1MnjQBXu064vqhqWj/R1M0bNgw3cZKzqtXr2BglQXG2QoBUoWnt7cqloWISGl58uTBxYsXUb9+fTRp0gR///03hgwZkqp3yRBRPAMDA1hY2sD36n5AXR2GRkaJ7gWcXu7euwcTj04wdMiDsFsH8eTJE+TKleub7UuWLImzp07g9OnT8PAYkynOA7l9+zaevnwD504LERnwBrNmj8DoP0el+7hmZmaIDg1EhO9LhL19AEsLi3QfM6Plzp0bj+7fxY0bN1CwYEHY2NgoHYl+IyK+gP3zcXNzk56enkrHoF/Q2bNnUatWLRgbG+Po0aNJ/oNNlBHOnz+PajVrwyRbYQS9uImzp06gYMGCSsf6Lr6+vsiSNTuyNR2Lx5vGQ9/OGSq/Zzh25BCKFSuW6v4mTPoL02bMRpzQRHRYINQFMLB/X8yetwA6xhYQ0aEo7loUZ6/dh2WpP+B/YROmjhuGEiVKwMrKCpbfuRXKl8aOHYulxx7AoWJ7+HjuhYd5KNatXoEatevh2pN3UNcxgHGsH27fuPZVoflbLl++jCrVa0JoaCOLvS3Onzn51Tcw48ZPwMLFy2BkqI9AqY+sTcfB5/IuFND1w54d6V9UValUuHz5MvT19VGgQAHExcUhOjoaurq66T52egoODkahom6I0jBC6PtXmDntH3To0F7pWJTGhBBXpZRuSuf4mXD+/XuLiIhA+/btsWnTJnTs2BELFizI1HvnEmVWd+/eRf9BQ6FSqfDvlMkoVKhQho39z5Sp+Hv6bOhZZwc+vMS92ze/uW92ZvXu3Ts4584Lh1oDEO79FGbB93DD8/u2IIqLi8OrV69gbW2dou0cZ82ag0n//AMbGxts2bAOLi4u3zUu0e8qqfk3C9REibh+/TqqVasGIH4f2yJFiiiciH53Dx8+xNWrV+Hu7o7s2bNn2LhSSsTExKRqT+qkhIWFwdrWDo71hiHC3wt+Z9bg+rWrcHZ2/uY9Bw8exIkTJ1G+fLnPDuT7z4YNG9ClR1/k7rYY4T7P8WDdSJjmckfOhkPxeu+/GNKmFqKiY3DwyHHUqFoZgwb2T/NVX5cvX0alqtVhkr8Sgu+fxsqlC1G/fn1oaGqi6JBtUNPQxv25bXD7+pVkD1T5T7WadfBYLTssi9bAq23j8M/Q7mjTps3H6z4+PijiWhxxOkbwe/UYOuYOyNd+Ot6d2wR3W2DLxnVp+oxfklKiXsPGOHfpKmKiItCkYV1s374ToSHBaNmqNVYsW/JTr64LDg7GyZMn4eTklKHfOFLGYYE69Tj/JpVKhdGjR2PSpEmoVKkStm7dmuJ3UBFR5nD8+HG8evUKderUgbm5udJxvsvu3bsxauwEmJubYdmiBd/1/VFYWBhKla2AZy9eQkNIHD96GIULF077sET0UVLzb27xQZSIIkWK4MyZM6hSpQrKly+Pffv2oXTp0krHot+Yi4tLhv+E/uXLl6hYpRpePH2CCpWrYt/uHdDW1v6hPvX19bF54wb06NMfmpqaOHhgf5LF6f3796N56/YwLlgNC5e1x/pVy1CrVq3P2ri6ukJKFWLCghD54S20ja0Q8OAsIvxbITrgDSwtLdGiRQsMGTzoh7J/S1hYGCb8FX/QiEnoMyxZ9/8D/QoUKop3J1ZATdcYutpaqXqbnJGhIWLe+SA2PAixYYFfHTy5bds2CKtc0LPNDQOpBQ0dA1z5uwGMTMwwbXX6F5BevHiBE6dOI0+PFYgJDcTqRd3gVLMXcuYqid2r+uLcuXM/9d+bRkZGqFu3rtIxiIgyFTU1NUycOBHOzs7o3LkzPDw8sHfv3gz94TnRr8rPzw9nzpyBi4sL8ubNm27jfOsgx59J3bp1f3ietmnTJvhEqiNPz1V4f2U3Ro0dj707t6dRQiJKrfTbTJLoJ+fi4oKzZ8/CxsYGVatWxcGDB5WORJShRo4ei2ibInAdvgt3Xvpi3bq0WZFbs2ZNvHjyEI/v30m2gHno8BGYFKkN+7ItYVy4Ng4ePvJVm1y5cmFQ/z64Nb8z3pxcC1uPJlBXU8ObLSPRoFo5NG/eHHFxcVi8eDGGDx+Be/fupclz/Gfav9Nx5el75Gg7C++jND/r/9D+PahdxAHlsqjjzKnjqSrwz/h3CsxCn+L+gk6oXan0Vyd/29vbI/L9c0QH+wFSImfDobAv1QT16tVN8SrtH2FsbAxVTDRCXt1D8PPrUFfXgBBqgACEEPhZ36FFRETJa9u2LQ4fPgxvb2+4u7vjwoULSkci+ql5e3sjX4HC6DVqCkqUKos9e/YoHemXp6enh7jIUMRFhyM2LAAGKTgfhj539OhRdO7aDYsWLebcn34YC9RESciSJcvHn2LXrVsXmzdvVjoSUYaJjYmFmqY2hJoahLomYmNjv9n2xIkTsLZzgLGpOZYuW5ZmGSqUL4fgWwfx7uIOBN86iArlyibabuyY0Zg1cwZkRCC8jy3G+rVrsGv7VvTt3RNSSgwcPAQj/5mLNWefoWTpsnjz5k2aZfTz94emqSO0jS2haWoPf/+Aj9esra2xcP5crFm5PNX72Ts4OODmtSsIDwvBimVL4let/TUZdo5ZUbp8Rbi5uaFr2z+g5nUFcQEvceWvuvhw6xAG9O2dZs+WFDMzM6xZtQKR55dD7eEBtGzWCN5HFuDm9OaoUancT716moiIkle+fHlcuHABRkZGqFChAjZt2qR0JKKf1p49e6BpmweOjcfCumInzJy7QOlIv7zGjRujQolCuDn9DxgFPsTUv/9SOtJP5fLly2jYpDkOP1dh5KR/Me3fGUpH+iEhISF48uQJ4uLilI7y2+Ie1EQpEBgYiNq1a+P8+fNYtGgROnfurHQkonR17NgxtO/cFd7v3kEIgYIFC+HU8SPfPDzE0toO5pW6Q8vYCk/WDMarF89gkYqTrWNjY+Hv7w9LS0uoqX3+s9OtW7fi8NFjqFKpIpo0aZJkPyqVClJKVK1RGzfvPUJooB9iIsMh1DXgWKkjrIvVgdf2cZg3cehXK5K/1+PHj+FeqgzUdY0hosNw+eK5NF/BvHLlKixatgI3b95EjuYTEXjvFApbxGHPzm04ceIEGv7RBjbV+iDo3klUyG2JdWtWpqr//+YC37Nn9H+HeJrmcMWHJ1exf+8ulClTJtX9EGU07kGdepx/U2L8/PzQoEEDnD17FhMnTsSIESN+6jMIiJRw5MgRNG3dEbbV+yDw5gHULZkHC+fPVToW0TfNnj0bU9cfg321HvC/cxI5ou7h4N5dSsf6LpcvX0bV6jUh1TSQI1tWnD11PEWHZlLqJTX/5gpqohQwMTHB4cOHUa1aNXTp0gVTp05VOhJRuomJiUH9ho2gW6INstYZCE0NdVw4eyrJf6TDw8OgY+4AbWMrCDV1REREpHi8J0+ewNEpO7LlzIWixdwREhLy2fXGjRtj8cIFyRangfi9Me/fv4+rN27Bvt4wxEENhfutRY6Gw+F1cjXenNmIYK+HyR58+u7dO8yYMQMbNmyASqVKsq2zszOePX6I/dvW4cmj+ykuTkspsXDRItSq1xAzZsz65tviDhw4gH5DR8LXsgSEvjmCX9yCnkNevH3nDQB48+YN9KyywjhrQRhkK4oXr16naPz/LF22DPoGRjA2M8euXSmbVB44cACDBw/G3r17sXrtepi6NYRd7UEwLlwDe/buS9X4RET0c7OwsMDRo0fRsmVLjBo1Cu3bt0d0dLTSsSiTunXrFuo3aoIWrdvCy8tL6TiZRpUqVTBiUD+I6xtQPr8Dpv4zWelIirl48SK69eiF2XPm/FSrWR8+fIjc+QrCwMgYw0aMUjpOuitbtiwCH5yB18k18L+4CXVqVlM60ncb8edYmJVqhdw9VuJdqAo7duxQOtJviYckEqWQnp4edu3ahVatWmHIkCH48OEDJk2axBUi9EsJDw9Hu46dEREVg+AXN2BXtgWiIiMRHR0NDY1v/5Px919/YeiIflBT10DLFn/A0dExxWOOm/gXNHOVR4EyLfBqx19YtWoVevXq9d3PYG5ujpjIMIR6PYQAoKahBQ0dfejpaqNWbn10nnoYWbJkARBfjI+MjPzsAMKgoCAUdSsBNbt8iPZ9ifOXrmDOzOlJjmlsbAw3t9QtxNy6dStGjJsMM/fmuDRjPvT19VCsmBvOnTsHDw8PFC1aFABw/fp1GOR0h0WBilDFRMH7zDqoIw7rVq/Ehw8f4OPjgyjvR3ixfijCfF9j2uoVKc4QHByM3n36Ile7mYiNDEXL1m0REvQhyb/X2rTrgHXr1wMQmLdoORrWrYmIZzcQaJ0NkS+uIm/7Kql6HYiI6Oenra2NNWvWwNnZGWPHjsWLFy+wfft2mJmZKR2NMpGIiAhUqFwVhkXrI+59IKrVrIO7t64rHSvTGDxoAAYPGqB0DEU9fPgQVarXhKlrfWw7tARv3nrjn8mTlI6VIp269kCkvTucqwzBomXDUbd2TXh4eCgdK90ULlwYRw7ux86du1Ckx2Q0bdpU6UjfzcDAALF+voiNCEFseDAMDAyUjvRb4gpqolTQ0tLChg0b0KlTJ0yePBk9e/ZMdnUl0c9k/MRJOHPnNfK0mYKgp1dxf35ndO7S9Zurp6Ojo7Fjxw7kzJkdTx7ex50bV7FowbxUjampoQEZHQGpioOMjYKmpuYPPYOtrS2WLV6EuDt7YGygj9uzW+PF1nFYuXQxFs6fC1dXVwDAqVOnYG5lDXNLK7Tr0AlSSkRGRqJe/UYIilGDY81+sK3ZD9t37PyhPN9y9eo16DmXhkWBCtDPUx579u1D2YqV8c/aQyhXsQpOnz4NAKhVqxaC7p7Am8Pz4Xd+PUYN6Y87N6+jatWqcCtREtPX7AX0zFHEJQuue15K1YnmMTExkAA09IyhZWCKmOioJA848fX1xcaNG1Gk31oU7L4QkRGhCAwJQ9eWDWH84jD6dm6Ntm3b/uhLQ0REPyEhBMaMGYO1a9fiwoULKFmyJJ48eaJ0LMpEfHx8EBOrgnXx+rAp1QwP79/lwWrfycvLC3XqN4J7mfI4fPiw0nHSjKenJ0yyF4Zd6Waw8PgDx06cUjpSigUFB0PbzB5ahmbQ1DdCcHDwZ9djYmLg5+f3S/2Zd3d3x99/T0azZs1+6oV7s6ZPheGHe7g7ty1qVSqNOnXqKB3pt8QV1ESppK6ujsWLF8PU1BRTp05FcHAwVqxY8cNFNaLM4OVrL2jb54O+bU6YZC2EJiWzYebMmYm2lVKicrWaePjaF3HR4ahTpTxWLFuS6jEnjBuDc1Wqw3NyXVSoVPWrAufq1WswdsIkWFlZYe2q5ciZM2eyfTZv3gzNmzcDEL83pq6uLvS/OJm7e6++sKnSE8Y53LBrZW9cunQJZ86cwR2vD4gJDYD3ld0If30XxQoVRGBgIExMTFL9bEmpX78e5i2qBREdisAHZyHKlYFJkTqwL/MHhL4lWrVtj5PHjqBQoUI4f+Ykjh07BlfXQR/3d75+/TqCwqOR849hiAryxYkl3TFk6HBUq1oFXbp0TtEk0dzcHP379cfMWR0BKdGkSVNUrVkX7sVdMebPUV/9vaalpQUhBKJDAxAXEQIBoHyZ0hg0aAAmTkjTlydJUVFRuHbtGuzs7NJ8v28iIvoxLVu2RJYsWdCgQQO4u7tj586dPDiXAACOjo7IltUJr7aPR1xkGOo3bJRpi1rv37/H/AULoK2lhV69en32brvMoGHTP+Ct4QBtm1Jo1LQ5Hj+4BxsbG6Vj/TB3d3cEPe8DeXI1Il9eQ5N2zb/ZNiQkBKPHjMPrN28xsF9vlCxZMgOTfm3KXxPQuNkf8DmmiwL58qBixYofr926dQsVq1RDWFgYShQvgcMH90FLS0vBtPQpJycnvpsjE+AhiUTfSUqJv//+GyNGjECdOnWwadMm6OrqKh2L6IdcuHAB1WrWhqFNdkQFeOHq5YvfLAC+fv0aeQoURr7eaxAXHYkb05sjJjrqu7/RiImJ+aog+vz5cxQo7AqnhiMR6nUPFsH3cfXS+e/q/0v5ChZBtEstmORwxZOVfXBw11Zs3bYdG84/h7GLB17snwszrTi8f/8eQgiMHTsGw4YM/qqfd+/eYefOnXByckKNGjVS9fzXrl3DqVOn4PX2LWbPmg11A3M4VmqPN6fWQdfcHnY6Ubh93RO+vr4YNmIUPgQGYdTwIShatCgCAgKQLWcumJX8A2HeTxD05CrioiOgb2iCscMHoX//vinO4ePjg/Pnz6N9156wLNsOwbcOoVuLuhg3dsxXbZctX45evftASqBtm9ZYMH/eVwdbpqeIiAi4lyqDt35BiAjyw+oVy9CwYcM0Hyc6OhpnzpyBubk5ChcunOb9k/J4SGLqcf5NqfHkyRPUqlULL168wPLly9GyZUulI1EmEBoaio0bN0JXVxfNmjVLcgs5pcTGxiJ3vgIIN8oOGRWG7CYC506fUDrWZ8ytbODYbDK0TW3xZFkPHNq1OdXbzX2vd+/eYe3atbC0tETr1q2hrq6epv1fv34dGzZuQp7cLmjbtu0355n1GjbB5WcB0LbNjYCLG/Hg7m3Y2dmlaZbU8vf3h6+vL3LlyvVZ7uq16+JhnAOs3Grj5aZRmDl+CJo3/3bxPT1JKXHu3DkIIeDh4ZFpf0hEvyYekkiUDoQQGD58OObPn4+9e/eiRo0aX72Nh349+/btg62jE+wcnbB//36l4yTp0KFDMLOwgq6+AebNm5+ie0qWLIm7t25g+cyJeHD3dpKrU83NzaGhJuB3+zj8rh+Ao1M2BAQEoFK1GrC0tUeffgNS9Ra2xN6F4OPjAx1DUxg45oVRdle8e/s2xf0lZ9H8OfA9thA3pjeHoZ4OevQZAJdczoh8fAZ+xxdBOzYEPt7vkLfrIuTtthhjxoxBeHj4Z334+/sjV+586DNgCOo3+QODhgwFAJw5cwYtW7fBsBEjEBgY+Nk94eHh6Nt/IKrUqI1Xr16hR48emDtnLvJ1WwTjHK54sW8uLItUg2OVznj18gUAoG7DJjh0+x2uhZqiYpVqCAwMhJmZGfr36YU3x5cj4N5ZZK3ZK371tZE1jp5M3dshra2t8erVKxhmd4N5vnIwzFcJV67dSLRtxw4dEBEWisjwUCxauCBditNSSsTExCR67ejRo/AJiUX2dnPgUGsgxk78O83Hj42NRdkKlfFHp14oV6kapkydluZjEBH96nLmzPlxq49WrVph3Lhxv9Rb2+n7GBgYoFOnTmjZsmWmLE4DgLe3N3ze+yJLzT5wrDsYF86dznTbOnbu1Amvto7Dq81/ws7SBAULFsyQcUNCQuBazB0zN5/AkAnT0a3H958b8y1FihTB35P/Qrt27ZKcZ3pevQrLkk1hU7wu9C0c8OjRozTPklrm5ubInTv3V7k1NTShio2CVMVBFReT5kX91GjdrgPqNm2FOk1aokOnLorlIPoSC9REP6h79+5Yu3Ytzp49i0qVKsHPz0/pSJROYmJi0LR5C5hW7AWTij3RpNkfiI2NVTrWN/3Rqg2saw6ES4c5GDx0GHx9fVN0n6OjI6pVqwYLC4sk2+np6eHAvj2wDbwOZ/W3OLR/D4YMG4EHAWqwbzQB63fsw/bt2z+2j42NRe9+A5A7f2H07T8wRa+dq6srcjrZ49mqfni5ZQyGJ7KC+XuVLl0a/r4+KOzqBji4ISRrZfQfOARnTh7H7o0r8fDeHaipqyMuKgxxUeEQQnw12Vy1ahWi4lTI0/5fWBevj0VLl2P69BkoX6kqjj8Jw7I9F1CjTr3P7unbfyA2H72C53r50aZDZ9y6dQtCTQ1SFQeb4vUgVTGIfHIBLzePRvdu3QAAd27dhJVHc1gXqwd1HQO8evUKw4aPwIRJk5Gr1d/IVrsvnu+dBf87JxHt9xzVq1REk2YtYGpuhVp1GyAsLCzZ16NGjRoIengObw7Mhu+Z1Wjb8turOi5duoQNGzaky993z549Q3ZnF+jo6KJW3QZfFaqtrKwQGfQeEe9fIPzNfdjYWKd5hps3b+Lx89fI1no6nJpNwLTpM9J8DCKi34GZmRkOHz6Mtm3bYuzYsWjTpg2ioqKUjkWUJGtra5gYG8HryCJ4HZgTf3h2Br5bLCUmT5qAbetXYPaEIbh47kyGbRdx+/ZtxGnpw7FmX9jV7I9du/ek+RiT/5kCHV09mJhZJLm/duOGDfDuwCy83j8TMiwARYoU+arNy5cv0a5DJ7Tr0AkvX75M86wp9e+UyYh7dBxX/2mIkoVc0KBBA0VyhISEYPOmjcjRbhZytJ2FtWtWf7UAh0gpmfNHlkQ/mRYtWsDIyAhNmjRB2bJlceTIEdjb2ysdi9JYTEwMYqKjoGedLf7z6ChER0dn2tUfUZGR0DI0h4aeMYSaGqKjo9Osbykljh07hoiICBw/fODjpNjb5z20bZyhY24PdSNrrF27Fu7u7rC3t8f8+fOxad9xWJZthw17VsI5x0L06pX0qgtNTU2cPnEUFy5cgIWFBfLly5dmzwDE7yn/8sVL2DZoBx0LRwScX4fg4GCUKFECALB08WJ07toVUkrMnzcXOjo6n91vYmICDT1j6FpkQbS9H0LvHMbYCROhrmMAp6pdEBcdgSvTPj/R+tqNWzAuFL+1SOTTi3jy5AnmzZ2Dnj3jX4tZ06chi6MjTExMPu7Z2aBhQxzc+Rc0jCxhaqCDkJAQzF+0FGpautCzdIKGriFUUaFwymKHCg3/QER4OE7ffIqsbabj6rElmDJ1WqLbdXwqV65cuHr5Ig4fPoxChYZ/c7/QpUuXYeCwkTCwc4YcPAy3b16Dubl5sq91XFz8dilWVlZJrhoZPGwk4hzd4dp8Ojw3jcKWLVvQokWLj9dLlCiBoQP6YvbcyXDK6oSlC9cmO3ZqWVlZISo0EMEvbiH83SPY8e9zIqLvpqWlhRUrVsDZ2RmjRo3Cy5cvsWPHjhT920GkBE1NTVw4exrTZ8yElpYWhqbhAom0IoRAhQoVMnxcZ2dnRAa+h/fFbYh+/wzFihVL0/69vLwwcdJfyN9jGSL8XqN1uw7weeuVaNsZ/06Fe3E3vHv3Ds2bL4OxsfFn16WUKFuhElQO8RlPVKiEF08fK7KlRa5cufD6xTPExMRAS0sLR44cwcOHD1G7dm1kzZo1w3Lo6upCV1cPgY8uQ8o4GBgaQVtbO8PGJ0qSlPKn/HB1dZVEmc3JkyeloaGhzJo1q3zy5InScSgdDBw8RBqYmEsDE3M5eOiwFN3z4sULWb9RU1m5Wk15+fLldE74f4sWL5Y6+gZS18BI9u43IE377tKthzSzzyatsueXZStUliqVSkop5dmzZ6WhiZk0tHKSGjoG0qZIFWlt6yCDgoJkn779pEO5VrLE6IPSvmxL2W/A15lUKpVcu3atnDdvnoyOjk7TzF/y9vaWNWrXlRa2DlLXyEza5Coq8xUqIiMjIz9rFxcXJ+Pi4r7K+eTJE+nl5SVz5ckvdU1tpJauvly9erV0yu4sNQ0tpGXRGtI4p5ssVbb8Z/fOmTtXmlg5SHvXqtLM0lpu3rxZdunSRS5atOirsf8TGxsr161bJ+fNmyf9/f3loUOHpEXWPNKiUBWpaWAmNbT1ZImSpaSeuZ3Us84u1TS1pW2J+rLE6IPSoWwL2aNn7zR73Qq7uUuXlpNkidEHpV0+D7lp06Zk73n79q3MmsNZ6huZyhy5cksfH59vtq3boLF0qtJZFh+1T1rnLiZXrVqVZtlTY9OmTdI5T37pUba8fPz4sSIZKH0B8JSZYE77M31w/k0/asOGDVJbW1vmzJlTPnz4UOk4RCmyY8cOOXr0aOnp6al0lEzB09NT/tGqjew/cJAMCgpK9f0qlerj9w5fevbsmdQ3NpOuQ7bJ/J3nSFMLq+/OGRQUJDW1dWTxUftk8VH7pKa2jgwODk7ynps3b8qrV69+M9+3qFQqeenSJXnx4sVk7507b1789wJuNaSJuaV8/fp1qsZKzuvXr+Xx48dlYGBgotfPnDkjCxRxkwWKuMnz58+n6dhEyUlq/q34RPd7PzhBpszqypUr0tzcXNrY2Mhbt24pHYfSwaNHj1JVsMqTv5B0KNdCZqvVRxqbWcjQ0NB0TPc5Pz8/+ebNmxS1vXHjhlyxYoV8+vRpsm01tbSk6+AtsviofdLAxFy+ePHi4zVvb29pYmYp83ddIEuMPiits+eV586dkzdu3JCGJmbSLl9JqaWrL7PmdJGly5SVe/fu/XhvCY8yUsvQQmqb2Ehr+yxfFYbTUu16DaW9e32Zp+1UqW9sLqdOnZqi35u4uDhZv1ETaWBqIfUMjOSatWvl5cuX5atXr6SU8ZP2rDlzSX1DI9mkSVMZEhIiz58/L0ePHi2XLFkio6Oj5ZEjR+T8+fPl1KnTpJa+iTR1KSnVtXRlvYaNU5Q9KipKlvAoI02sHaWuvqFcuHChVNfQlE41e0mbEg2kmpau1NLVl5ZZnKWZpbV88ODBZ/ffvHlTlqlQWXqUrZDqH5r80aqNtC1aVeZqPk4amlnJU6dOJTsRHzR4iLQrUU8W//OAtHWrKf/8c/Q32965c0da2thJXX0jWbJ0ORkREZGqfEQpxQI159+kjHPnzkkLCwtpZmYmT548qXQcoiQtXLRImthkkfalm0kDY9M0/f4uLi5Obt68WS5ZsuSbxcRfzZKlS6WOnr7UNzSSmzdvSbRNrz79pI6egdTVN5Br16777rFUKpV0L1VWWuctKa3zlpTupcomOWftN2CgNLKwkcaWdrJdh06pGqtTl27SxMpBmlg7yFZt2snRY8bKTl26yhs3bnzVtrhHWenyx/j4RTuFK8jVq1en+tm+5cyZM9LQ2Eza5Cwobe0d5bt3776rn9evX8uKVavLXHkLyJUrlVksQr8mFqiJMti9e/ekvb29NDU1lRcuXFA6DmWgBw8eyNr1Gspqtep8nMBqamnHF3P/3C8NzaxSVAB++vSpLFaylLTLkk3OnTcvvWPLgwcPSgMTc+lQtJI0MjWX9+7dS7J91hy5pFOVzjJHw6HS0NhUhoSEfHa9dr2G0qZgBZmlckdpZGou379/L6WUcunSpdLEzEJqm9pJ5yajpI65g9TS0ZfTZ8yUU6dOlRBq0m3odllsxG6ppqElT58+LQMCAuSzZ89SvZIhOXkLFZW5W02WJUYflDYuReWuXbtSdN/Vq1elibWjLDZit8zbfrq0z5Ltm21jYmKkR+kyEmoaUsvYSmoZWch8BQp/LLwXLV5S5mo2VpYYfVCa5SkthVBL0XPGxsbKJUuWyJ49e8pLly5JKaU0MjGXOmb20qFCO6mmpSOLuBWXnp6eX33Do1KppJWtvcxas5fMVqe/NDW3TNVq9cDAQNmyTTtZyLW4tLS2lZraOrJoMfckV6SMGDlK2hatKouP2idtClWU4ydMSHKM6Oho+f79+zT/PSf6FAvUnH+Tcp4+fSpz584tNTU1FXunDFFKVKtVV+ZsNDz+XWnudeWsWbPSrO8OnbpIC6c80rZAaZkrT75vvpMuMfMXLJAGxibS2s7hp/lBT0hIiNTR1ZcFeyyR+TvPkbp6Bt9cjPL+/ftkVzunRFhYmJw3b56cN2+eDAsL+2a76OhoqaGpKV0Hb5Fuw3ZKbV09GRAQkKIxQkNDpYamlnQbul26Ddsp1bV1pXW+UtKxYjtpZGouvb29P2vfvWdvaZ3XQ+ZoMEQamlrIq1ev/tAzfqpuw8Yya63e8e90LFr1u/+8lqtUVTqWaS7ztPlHGpiYy/v373+z7YcPH+SyZcvkzp07f4q5e1xcnNy+fbtcvnz5d70DgH5MUvPvzLXTP9EvIk+ePDh79izMzMxQuXJlHD16VOlIlAGklKhUtTpuh5niQZw9KlaphpiYGDT7owVebv4Tr7aMgXOO7HByckq2r5Zt28NH1xlmVQdg+KgxuHv3bopz3Lt3D2XKV0LR4iVx4sSJFN2zbOUaWHi0gH3twTB0KYudO3cm2f7gvt3IJl/C6NUp5MuXD6XKV8LmzZs/Xt+wdhVa1yiBsvYqnDp+FJaWlvD29kavvv0Ro2MGy0KVYZanNCwLVYHU0MGEyVMwdcV2qGloIuD+WXx4dBEA8ODBAzhkyYqCRYuhVJly6Ni5K6bPmIm4uLgUvx5SSuzfvx8rV67Ehw8fPn59cL8+eLPvX7zcMAx6qrAU7+Onr6+P2KhwRIcEIDLgLfQNDAAA27ZtQ4069TF8xChERUUhKioKhYq44eLFy7B2rQk1DS0YOObDM+8PWLhwEQCgSKGCeH9tPwIenEfwqzuwc8iSon3x+vQbgOF/zcT2yy9Rs3Y9BAQEoIirK+zLtYJ9meawyF8BVSqWh6urKwwNDXHixAmcPn0aUkpER0fD3/c9LAtVgUXBiggPD0dISEiS40VERGD58uVYuXIldHR0sHbVCpRyLwGtHCVRZMh2vI3UwuLFi795/6CBA2CrHowrf9VBFr1o9OndO8nxNDU1YWlpqcgegURElP6yZ8+O8+fPo0yZMmjbti1Gjx6N+O9biTKXcqU9EHh1F7yv7EbQw/MoXrx4mvW9efNmODYcBcf6I+EXGIpHjx6l6D5vb28MHDwU2VtOhXGZTmjWolWaZUpPcXFxkFJCQ9cQGrpGiI2NgUqlSrStpaUlDA0Nf3hMPT099OjRAz169ICent4326mrq0PfwAjBL28h5NUdaGhoQFdXN9n+4+Li0KBRU6gkEPTsGoKeXQUgYF22LexKN4eeuT3u37//2T3Tp01B61plkCPqPlYvX4KiRYv+6GN+5Ghvj6i39xH+/gWi/F7A1tb2u/p5+fIlDJ1LwNCpIPRMbfDmzZtE20VGRqKYuwf+nLkCHXsPRp/+A38kfobo3qs3uvQbjpHTl6F4yVJpek4T/ZjMebIX0S8ga9asOHv2LKpWrYpatWph48aNip3WSxkjOjoa7954wbVVPQg1ddw6vRbBwcFYtXwpdu3ahfDwcDRo0CDJA+L+4+PzHgal6kLPNie0jczh6+ub4hw169SDcK4MDUtz1K3fEG+9XiU7wSuQLw9Ord6OQGNLhL+6gTx52iTZ3sXFBSeOHEL5ytXwNNIY+rkKokPnbihQoADy5MkDAwMDTPl78mf3nD59GnFCE9aFquD10WWICvRBwP0zUNfSRaC/L9w6L4LhvbN4sX8uNDQ0MHzoEEz5dyay1BsGDQMTXFoxAG90XbDnxAr4vPfFP5Mnpej1GD7yTyxZtR46Fg4YN/Ev3Ll5Hfr6+mjXri3c3Fzx6tUrlC1bNslJ65fPPmLYEEya1Aem5hbYtGUTLl26hPadu8OqXDtc23EEUdFRqFCuLLzeB8AoW2FkrdEDIa/u4OWRpbAsXBXXb94EAMyeOR2B7Tvi+MmlyO+SE9u2bEpRht1790LL0R3eF7ZBShX+/ucfNKxXB+P+mYnooPcIf3YZjRuPAwA0ad4Cpy54QqriULd6ZaxYtgSNmzbD0bWDoKaugUqVq8DMzOybY0kpUbFKdbwIiIIqLgZrN2zG0UP7U5TzP6amprh6+QLi4uJS9OefiIh+faampjhw4AC6d++OCRMm4PHjx1ixYsVXBxITKWnokMHQ09OD57XraLFuNdzd3dOs77z58uPNxa3QNHVAbGQoHBwcUnRfREQE1NQ1oGVkAUiJd2FhaZYpPRkbG6NlixZYPa8TAImhQ4ZkmsPm1dTUsGfXDnTs2h3RsXHYtmVziv4uunTpEq7evg+XFhPwfP88yIggVK9aBZePzIOGeTZEBrxDgQIFPrtHR0cHU6f8nS7P8dfE8XjVtgOuHZiCtk0boXHjxqnuw8/PD3Y21vDcNAZGlg6wNtKCh4dHom1v376NwLBo5Gg2CpEf3mH9+mGYM3P6jz5Gutq4YSOyt5sFLUMLPFnWHffv30ehQoWUjkUAt/ggSm8BAQGyZMmSUk1NTa5cuVLpOJTO6jRoJC2z55fWzkVkuYpVvvttTitWrJQGxmbSwjGnLOZeSkZFRX3VRqVSyRs3bny1v7CmlpYsOmhzovtDf0t0dLQcNHiodC9dXk77d0aKc2fJllPm7zRH5m4zRappakt1DU3Zf+CgbzzTCqljYiX1bZ2lmpauVNPUkToGxrL5Hy1koaJu0q5YLWlfuom0sLT+uD1KwSJuMludftKpWjdpkquELDH6oHRpOUkWK1kmRfmklNLGwUkW6LZQlhh9UFplyyNPnz792fX79+9Lx6zZpRBqsk69BsnuAXjt2jW5bds2+eHDh49fW7JkiXRwrSJLjD4onZuOlqXLV5YnT56URha2UkPXSDpV6yYNs+SXelZZpb6RqTx27FiK8yemQaOmUqhrykK9V8qCPZZILW0dGR0dLVevXi179ekrT5w4IaWU0t/fX2rr6sliI3ZLt2E7pLqGpoyKipJxcXHywIEDcu/evTImJibJsfz8/KSOnoEsPmqfLDZyr1RT15ARERHSy8tLZnd2+WyLDy8vL3nnzp103TucKK2AW3xw/k2ZgkqlkpMnT5YApIeHx8dtwYh+dd7e3rJV2/ayZp36H7dsSwmVSiU7dOoi9Y3NpK6BkVywcGE6pkw7wcHB0sjETGavN1BmqdhW5sqTX+lIP+zOnTvS0NRSFuq1XGar1VsWci0mY2JiZPUataSWjp40NLWULdu0S9X2LUorXb6itCtWS9qWair1DAyll5fXN9v6+PhIA2NTmb3uAGnvXl+WKlchA5N+n+IeZaS9R0OZrXZfaWhiJv39/ZWO9FtJav6t+ET3ez84QaafSUhIiKxSpYoEkKb7llHmExMTIzdv3iw3bNiQaFE5NZ48eSLPnTv3zf2BW7ZpJ40tbaWBibkcM278x6/36NVHmto6ScuseWTFytXSdS+waf/OkEbmNlJT31g6NxsjXQdvkUbm1vLmzZtftX358qU0MjWX5i4lpLahmTSwySqz1uwlDUzM5Llz52Tvvv2knWNWaWqXTRqYmMtZs+bIa9euSQenbFJLW0dq6xlI+9LNpbljLjl+wsQUZ6xUtYa0K15H5qg/WBoYm351Unbl6jWlY8X2Ut8+t9TQM5b6hsby4sWLifa1cuUqaWhqKe3ylpAOTtk+7k33/PlzaWxmIe2L1ZTGVvZy0eLFUqVSyUGDh0odPX1pYmEtW7VuI2fNmpUm+8z5+PhIDU1tWbjvGlmo13Kppa0jr1y5IrPldJFGpuZyytRpUsr4wxSNTMxkzobDZPa6A6S5lU2q/zzExMRIazsHmaVSe+lYrqV0yp7zYx8qlUoGBwdLlUolly1bLvUMjaWxha2sXa/BL1Wkjo6Oln9N/lu2btfhqx9w0M+LBWrOvylz2bx5s9TR0ZHZs2dPcr9TIoqfgz179uyr/Y3TUkREhFy8eLFcuHBhmhzy/uTJE2loZiWL/7lfFh20WWpp66RBSuX99fc/0sjUXOZ0yStv3bolY2NjpYamliw6cKO09WgqhZq61NHTl1u3blU6aooYm1nIwn1XyxKjD0oLhxzJfu9y+vRpWbl6LdmyTbt0/fOYVt69eyf/aNVGVq1ZR54/f17pOL+dpObfIv76z8fNzU16enoqHYMoxaKiotCiRQts374dY8eOxejRo7m/Kn3Trl270GfAYOjo6GDVssVfvZ3w7du3yOmSB/l6r0ZcZBjuzOuAqMgICCEgpcSpU6dw4sQJGBsbo3HjxsiSJUuaZwwKCkKV6rXgeekCNHX1ka3+UBhmyYfHy3rixKG9KFKkyFf3PH36FLt27cK8BYuhVbI9jLMVxptdkzF1WDc4OzujSp1GcO44HxG+L+Gz+y/4vH398d5z585h9549yJ8vH1q1avXV/z+enp549OgRKlWqBGtr649f9/PzQ7+Bg/H2nTdGDh2ESpUqfbwWGhqK6rXr4VGwNqICvZG71V/wvXEIWSMf4PjhA1/lL1KsJCJy1YZJTje83joWs8YN/PjWuadPn2L//v0QQsDc3BxVqlSBhYXFd722O3bswIIly5Evjwv+mjgh0T3w/p0+AyNGjoQQArNmzsDseQsQkaUcjJwK4um6IfC8eA4uLi44d+4cevUbCHV1dSyaNxuurq6pzvPo0SOM+HMs1NXV8PekCciWLdtXbaztHWFVcyh0rbPi8dLuOHFwDwoXLvw9j5/p9Ok/EJv2n4JOVjcEXNoMz0sX4OLionQs+kFCiKtSSjelc/xMOP+m9Hbp0iXUrVsX0dHR2LZtGypWrKh0JKLfVvlKVfHgbRCEmjqyGKvj4rnTP/T9q0qlgkeZ8njhG4LYyFC4F86LkLAImBgbY/aMaSk6pyezkVJi7rz5OHzsBGpWq4xuXbsCAMwsrGDi0Qqvjy5FoV7LERXwFu/2TIb/e+8MyxYdHY3p02fg+ctX6Nq5Y4r3uu7YuSt2Hz0LLWNraIV64d7tmynaj5soJZKaf2eODX+IfgPa2trYtGkTOnfujLFjxyIwMBD//vsv1NR4Vil9Ljg4GC1atUaWBiMRE/YB9Ro0gs+7zw+mMDAwgIBE2NsniAn7AGNTs48TRiEEzl24iLlL10DXPg8m/T0F927f/KxomxbmzJ2L1xHaKDZyD55sHI3n2ydBCIGWLVslWpgMDAxEdHQ0+vTpg4ioaEyftxjBDgUQ9vouSpUqBZVKheiwIIS+eYjwtw9hZW0FIH7i17V7T6xauRJa2lrYvnXLx2f19vZG0xatcfvmDUTGxME8WwFEDxyMW9evwsYm/kCP69ev45+/JsLe3v5jFikl2rTviE0b1kNbRxexMdGAniliI4IRG/weRuaJ79ntnCM7zj06B6GmhvfP76JDpy6Ii1OhWbOmMDU1xZr1G3Hj9l2YOuaG2qChuH3zWqqL1NevX0fbjl1gVb4jbh06i4iIwVg4f+5X7QYO6I8G9eth0aLF8PX1RWBgIExcnaBlYg01LR00aNIMBgaGmDdrOq5fuZiqDF/KlSsXtm5an2QbExNThL9/DqGhiejwEFy+fBkaGhrInz//D42dGZw5ex5mJZrCOFshqHwe4Pr168kWqKWUmL9gAbbt3ItypUti1MgR3H+biCgZJUqUwKVLl1CrVi1Uq1YNixYtQocOHZSORfTbiYiIwNnTJ+E6bCcgBG5Oa4J58xdg87adKFq4AP7+a1Kq94tXU1PDyWOHsXfvXkgp0bFLN1iWa49n/u9Qq24D3Ll5LX0eJh2tXLkSY/+ZCVO3Bjg3YQrMTE3RrFkz7NqxDS3btAdUsYBUQariIJB0cT8yMhL79++HsbExKlas+MOL2Xr06oM9p69B2z4fNlSqgru3bsDR0THZ+xYvnI/Kmzfjw4cPaN68OYvTlGFYoCbKQBoaGli2bBlMTEwwc+ZMBAYGYsmSJZnmcAjKHEJDQwGhBkPHvIiLDMOrvTPi3/LyySTFyMgIq1euQJ/+g6Cjo4Od27Z81sf6jVtgXaUnjJzyw2v7eJw7dw4NGzZM05yxMbEQGlqAUIOuhSNa1SqDsWNGw9TUFABw+fJl7NmzB66urjAzM0PtuvWhpqWDHFmdcObkMeTO5YzHjx+jUaOpHydL82bPwujxE2Fhbo51G9YBAG7evInN23eiYL91CHl9D1169Mbzxw8AAN179cWzKGPE6lvDsWQjmOX2gNfuv3Ho0CG4urrCo0w5aBqYIzzgHU4cO/JxJfq5c+ew7/BxFBqwCYGPLkL3+RHkzZMHO+e2Qw5nF8xatTPRZ144fw46d+uJ3dsmw6poDZjmLoV2HTqiXr266NytJ249eIbs9QbDJKcbnm38E9u2bUPXhJUUKfHhwwds374dBva5YFGgAjR0DXH1+sFE28bExKBilWqIscgDVWQI9HV08Hj9KEBDEzIuBpHuzRAFoFqNWvD1eZeq4qhKpUK/gYOxbfsOuBYtinWrVyR70OaGNSvR9I9WeH12DbS0tDB25lKEDh2BpYvmo2nTpikeOzOqX6cm5ixdhuCnBRD66g5KliyZ7D27du3CnxOnwKJ0a8xdtQUGBgYYOKB/BqQlIvq5Zc2aFefPn0eTJk3QsWNHPHnyBBMnTuSiDqIMpKOjA0enrHh7ag2EuiYMDPQxcuxEWFfshI0Hj0BN7U/kdsmFA4ePokrF8ujerVuKCqo6Ojpo3Lgx7t+/DzVNHVgUrIyYsA+4MWsLjh49isqVK2fA06WdS1euwiB3eVgUrISoQG9cueKJZs2aoWzZsnj94inGjB2PyZPbQlNTC+vXrflmP7GxsShdriK8PkQgJiwQbZo3wox/p/1QtlNnzsKyTFcY2OVC3Lt7uHXrVooK1Orq6vjjjz9+aGyi78F/5YkymJqaGqZPn45x48Zh5cqVaNasGaKiopSORZmIra0tateujcfLeuLxyr4YPGRYohO+Ro0a4c2r53j66D5KlSr12bVibkUR4LkT768fRJDXA+TLly/Nc/bq1RMGYa9xZ2ZzaPrexbChQz4Wp69fv45KVatjxaknaN+tDzp06Q6rip3h0m0ZnvuGYu/evWjUqBGGDRsGZ2fnj322bdvmf+yddXSU19bGn0zG3SITd3eF4O7u7l7cipcKFEpbpDgFSrHiTnAvVlyKu2uMeOb5/si9+W4KgUChoe381pq1ypxz9nlemXS/+z1nb9y8egnHjhyEn58fgNzfTG5eKjOYk53vAfX+/QeQO/pDbueBJ6e3I+HyUSTfuQBvb2/MnTcfZoUt0nMIkY0H6tRviOzs7FceS3paOpYsXID0tFScO32iwC2Ger0eSxb+BGRnwC62LiQ6E8zmHGRmZuLCxUuQ2bjg6dndeH7pMJ7fvoABgz/FxYsXC3U+b9y4AR+/QMxatBoPLx7D9RWf4+H2GWjb6tUO4u3bt/Ho8VM4V+0B55r9cP3aNWjdQ+BUvj1gLYFIpoYhsAySkxKRnp6eNy4xMfG1f3NIonfv3vjpl7UwVB+M324kYOSo0W/UHxERgSsXz+OHyd9DbvKFS6MvYF/lE3w7aeor+6elpWHkqM/Qtn1HHDt27I32i5KRI4Zj8tej0KlSEA4d2FeoLahnzpyB3CMGev+SUPqWxrETp/4CpRYsWLDwz0Cj0WDjxo3o0qULxo4di6ZNmyItLa2oZVn4GzDys9GwsXdAVLE43Lp1q6jl/G2xsrLC7h3bUMZdipJOVujTqyfUriHQ+5WAKqA8tu3YhcGjvsLpLGcM/2oCfv654ODrq/D29oadUYfz8/rhwsJh0HhG4ZM+/d/KxoMHD3Dy5MkC/fuCWLRoMdy9/BBVLA6///77W439I40a1MPz31bj7raZSDixEXXq1M7XPvqzkUhKTEBiwjPUqVOnQDsXL17E1Zu34dp0DFwafYE5c378U7oAoGqVyni4czZu7/gRLx5eK3SKj4+V27dvY9Rnn2Hy5MmW+Mk/lYKSU3/sH0uRFgv/BCZNmkQArFSpEpOTk4tajoWPCLPZzKNHj/LMmTPvNP7FixfsP2AQa9VtwC1btrxndf9PTk4OHzx4wOzs7HzfT5gwgU7F6zJ2ZDw96w6ktVRBh1LNGd53ESU6e3bp0rXQc5jNZvbs049CkZhqrY67du3Ka1u9ejUVai2Nzj7UGGwZHlOcs2fPIUlOnjyZVkIRI/ovZcyIzZRrjZw7dy5//fVX5uTksGWbdhRYCykQSajU27Jr908KrWn0F19SrtJQrtJy4OAhJMmp06ZRpbelVGdPoUxFtxq96BDXiEOHDiuUzVGjRtGhWD3Gjoync7k2LFGqDLdt21Zg/xat21IoVdAuujYNAaWptTHRs94gxo6Mp01wWSq0NjQ4ebJJ85Z557FLtx4US+VUqNTcvHnzK+1+M+E7yjUGGkMqMHZkPF2rdWeDxs0KfW72799PjY2J/q3H0yGyKlu0bvvKfs1atqZdYBydK3agSqvn3bt3Cz3H34GTJ09SodJQqrOntUTOjp06F7UkC38AliKJFv/bwkeP2WzmhAkTaGVlxdjY2L9FAS4LRce+ffuotXNiSPfZdCrTnFWq1/xT9mbNnk1P3wCWq1SFd+7ceU8qi4YDBw6wWs06bN2uAx89evTW42/cuEGtwYZOkZWoNtiyctWq1PnF0aNOfzqVb8vuPXq+tc29e/dSrtbRq8FQetQZwODwqEKPXbt2LRVqLXX2zowpXpLp6emFGnf79m0qVFr6t5lAtypdGBAS/ta6/8jBgwc5YcIEHjly5J1tPHnyhEpN7rlwLteKQWF//v+32dnZnDlzJocMGfq3LzybnJxMewdnOsTWoa1fDBs0blrUkiy8I6/zv4vc0X3Xj8VBtvBPYf78+RQIBCxWrBifPXtW1HIs/A3IyMjgjh07eOrUqaKWwq/HjaeTmyfLVKjMe/fu5X2/f/9+qnQ2dK3ajXIbF+oDSlPh4EMroZhyk3eBQcvXkZaWxpycnLx/z503jxKZnCKxhD0+6cnU1FSSucH5CxcuMCUlhUY7B5riGtO9Zm+KJDLqnbyotXVivQYN6OrpQ4FYTr9WXzNy0EpaC0XMysoqtJ7bt2/zxo0bzM7O5jfffMsmzVtywoQJbNq0GY3eEQzqNIVGj2DOmDGjUPamT59OG68whnSfTbvAkhz12ejX9tfojQzoMImmuEaUqfX86quvqNIZ6RhckgYbey5evJjbtm3LO2enT5+m2mjPqMGr6NdiDF3cvV5pt2TZivSo3Y9ijS3ldh6UKlRvXeF68pQf6BsUSr/AEDZr0eqV96qLuxeDu0xj7Mh4mnwjCgzGP3v2jGXKV6JCrWGjps2ZmZn5VlqKkti4UnQq3ZxBnadRbbB7YxV0C38tlgC1xf+28Pdh9erVlMlkdHNz49mzZ4tajoWPlDVr1tDOO4wxIzbTu8kohscUf2dbZ86coUpnpH+bCXQq1YTlK1d9j0r/Wh49ekSVVk/3Gr3oGFuLJcuWfyc7N27c4OzZs3ngwAEGh0VS5RxAlXMgRTLlaxdVFITZbOYnvfvS2lpIg609Dx8+XOixQWGR9G32OWNGbKKte2CBCy/+yIkTJ3KD2sM3MrjbTBps7d9a94di+/btjC1RmlVq1OK1a9eKWs5HxbFjx2h09mLsyHiG91lIjd5Y1JIsvCOv878tKT4sWChi2rRpgxUrVuD48eMoU6YMHjz46yr7Wvj7kZWVhVJlK6Bp+x4oWa4Svv1uYqHGHTp0CM1atMagT4fgxYsXbzWn2WxGx85dIZHK4BcYguvXrwMAfv31V4ydMBHaSn1xNV2NLt175o0pUaIEli6cjzKmTNgqxVA5B8KnySgIZSow+SFaNmvyVhqA3Jx1/03vYTab0a17D/i2m4TAbnMw58e5yMzMxOXLl+Hm6Y3iZSoiMCQMWzatR3FHARySTkMoEkMX0xCKoIpYvXotpMXawKNmL1xZORbPLvwKncFYYJ7m/fv3Y/369flSZTg5OcHV1RVfjRmLcdPn43CCDqO/+hrdunVFzdKRSN0zDY2rl0PHjh0B5L4QXrt2LaZPn46HDx/CbDbjxo0buTnHAXTs2BE1ykTj0bovUSrQGYMGDnjt+YiIiMDzk5sgUmghFgrQrVs3HNizE98N74mzp0+gWbNmqFixYt45u3PnDnKys0FzDsw5WQXm8ixXpiSSzmyFbUR1mFMeY93qlYXKufy/9PykB3y8vJAg0GL/AyFKl6uAJ0+e5OtTs0Z13N86Dbe3zkDGs7sIDw9/pa3RX3yJSwkC+HacgT3HLmDevHlvpaUoSUpOhtIlCHI7d0g1Nnj48GFRS7JgwYKFvyV169bF3r17kZ6ejri4OGzbtq2oJVn4CKlcuTLslEJc+bE77m+ejC9GDntnW/fu3YNMZw+VSyBUHtG4dev2e1T613Lz5k1IVHrYRlaHMaYBzp09+052XF1d0bFjR/j7++PSxd/h3+Yb+LUeB3NWxkvpBguDlZUVpkz8DunpaXj84B5iYmIKPVav0yHt0XVkPH+AjJTneWkGC3MMWempOPVDe/w+rz86d+wAIDddyNGjR/P5+n81FSpUwKH9exC/YR3c3d2LTMfHiKenJ8zpybi752fc3zEbxYvHFbUkCx8AS4DagoWPgHr16mHTpk24du0aSpYsiRs3bhS1JAtFTE5ODvr2HwDfoFB07f4JsrKyAOTmdr5y8y7cW38Ht0ajMX7Ct7h//z62bNlSYPDrzp07qFytBg4+VeDnTb+ifcfCF+0DgM2bN2NN/E4E9VyAVLsw9OzTHyTx4MEDyPQOkNt7Qu4cjDt37wHILfLRqUs3dOr2CdJS07Bi+VJYXdmBc9M7okzxKOzavhVVq1Z9aZ5bt27BPygUEpkcJUqVzpdrkiQWL16MAQMH4eDBgwVqHT/hW0h8y8Gnyxxk6rywZcsWrFy2BBvWrkJ2Tg7u/7ocKbfOQiAUQunoB7VHBHLSkqG+sxebN6zLy/V97tw5HD9+HCQxbPhI1GrYDB37DkfJMuVfynO398AhaCNqwS6qBjTesThz5gzmzZmFqxfPY+qUSXlB7+EjRqFVx+4Y/Pk38A8IQrESpeEXGASjjR1WrVoFoVCIeXNm4fzpE/huwrg3VsxeuWwpGpTwR5xtOnbv2AadTofg4GA0atQIx48fx+LFi/OC34sWLUbjZi1BWOH4t01xf/NE/Dhr+ivtjhoxHMN6d0IlDxE2rV+LSpUqvbLf8+fPMXv2bKxatQpms/ml9kOHDsGuTFs4lGgCqdYWly5dytc+eeJ3GD+iH7pWj8Bvhw/CYDC8cp5nzxMg0pogUupgrbZBYmLia8/Lx8SoYZ/izvpvcHV+T5h0MpQrV+6DzJORkYGpU6di/PjxL70IsGDBgoV/ClFRUThy5AhcXV1RrVo1zJ49u6glWfjIkMlkOHroALasXYaLv59FjRo13tlWqVKlYFRY48aigbiz7msM7v/3LXQcGBgItdQat9aMwd21Y9G0ydsvFPlf1Go1dDoDHhxcgQe//gIHJ2dIpdIC+588eRLLli3Do0ePXtkuFAoLVWDxf5k7ewY0z87g1pJP0feTroiNjS3UuEWLFkHh5A+POgNgDC6HW3fuYufOnfD2C0C1+s0QFhmNpKSkt9LyMXHmzBlMmTIFR44cKWop7xWNRoNf9+1BrUAdOtQpjeVLFxW1JAsfgoKWVn/sH8sWQwv/RA4ePEidTkcHBweeO3euqOVYKEJmzZpFo3sQA9tPpK1PJMeNG08yd2udQq2lf+txdKnQnn6BwVTrDHTwi6JGb3xlfrGtW7fS5BPO2JHxDOo8jS4e3nlt2dnZPH78OG/fvl2gll9++YV23uGMGbGJ7rX60NbBmdbWQnr6+NHD25e2bv5UanRcuXIlSXLmzJm08QxlSLdZtAsswZGjPmN2dvZLear/SKky5WktVVKstqHM1o1xpcty8pQfWLxUOZYtX4laB3c6lmlFpUbHEydO5KX4EEuk/Pa770mS/QYMpCmiCiMHraDRO4qOzq4sV7EKr169SolMwYh+SxgzYjOlaiPVRnuqDXZ5OaT/y5BhI6jS21Jr68hmLVtTq7dhaM95jBmxmTp7F548eTJf/+kzZlBr50zHuAZUafQF/nZtTY4UyjV0KNmUQpmKYqWOKtcQ2kXXplimYEJCApctW0aZUkWZUkNHV0+GRsZy2bJlrz1vf+STXn2od/KkvV8MA0PDmZGRQb+gUPq1+poxIzbTxj2Aa9as4bDhI9iwSXPu3LnzreyTZGpqKj28fekQUoYGFx92/6TXS33atu9IG69QOsTWpq29IxMTE996noyMDPbt159ShYoaowNd3D358OHDt7ZTlFy/fp0HDhxgRkbGB5ujRu16tPWNpimiMt29fD7oXP8kYEnxYfG/LfwtSUxMZLVq1QiAAwYMyJf+y4KFwnLr1i3u3Lnztf5Jamoqt27d+o9IK/Ps2TPOnDmTK1aseC+/mYsXL7J+o6Zs2KQ5r1y5UmC/ZcuW5aWgs7F34P379//03H+GmTNn0s4vhtHD1tMxrgHbd+zMMhUq07PeIMaM2ExTQDH+/PPPJMmrV6+ydr2GrFilOo8ePVqkuv/IlStXeOPGjXzfHT16lEqNjk6xNanSGj5oHSILFt6V1/nflhXUFix8RBQrVgx79uyB2WxG6dKl8dtvvxW1pH8V586dQ8Uq1VGmQmUcO3Ys7/sXL15g165duHbt2l+m5fr1G5A4BEDp5AexUzCuXr+BzMxM2NraYtb0acg6sgBOmdcQFRkJdWh1ODf+EsqACpg7b/5LtiIjI5GV+AC3N0/Bgy2TUb9ubnXprKwslKtYBRWq14FfQDCWLFn6Si21a9eGi0GOC1Pb4sGOOcgWyhE+YBkyTZEIDAzEsvnTsW/3TkRHR4Mk7t+/D5GNB2Q2LhDbeWPnrl1QKFVQqNSY/9NPBR7zsRMnYSreAB61+yIz+SkO/XoAg4Z/jqeOZXHi2gMIdM5wKtMCOr+S2L9/P9q1bYvE58+QmPAc/fr2AQAMHzoE7ooMnJ3cCol3LkAW2xJXzfao17AJgoJD8PDQCjw6thESa2L1L4uwd8cWjP96TJ4Gs9mMb8aPg3e7yfDuMA1r1qyBydEBz87uwvNLh5CVlgx7e3sAwMOHD/HTTz8hOCgIC2ZPRbfq4di/dxcCAgJeeXxqlQp20bXhXL4tHEo1R3ZmOjxq9oZbte4Qq21w9uxZ9Ok/CO4NP4PYzhvZdkFI96mB9p264sqVK4W5bQAACxYsgEuDz+DSaDTuPXyKCxcuwN7eDi9unUHqgyvISHyCuT8twMzlW/BbsgF16jd8aXXzmzh79iyS0nPgXHcInOoMxdJffnmpz+yZ0/HlwO7oVjMavx05CLVaDQC4dOkSatapjyrVa+HUqVOvnadn775YtHEPjLENkJ2Zim3xm2Bra/tWWosaNzc3xMXFQSwWf7A5tm+Nh3OdwXCp2Q/Pk1Isu3AsWLDwj0atVmPdunXo0aMHJkyYgIYNGyI1NbWoZVn4GzF+/Hh4ePuiTotO8A0IKnBlr0wmQ6VKlRAYGPgXKwROnTqFNWvWICEh4Y19Hz58iOq16sAvOAw//jj3lX10Oh06d+6MBg0aFJjm7W3w8fHBymVLsHzpInh6ehbYb8qM2bCr0AVO9YZDbO+LjRs3/um5/wytW7dGsKsRv42tA1XiZXwxehRsjEakP7yKjOf3kZHwEEajEQBQuVpNnEiQ44rQE5WqVHvnvzOPHj1Ci9ZtUbFqDezevftPH0Ovvv0RGhmDgJAwfPHV/z/HrF27FprgKnCs8gn0sY2w5Jflf3qu/yUpKQljx47F5198gadPn75X2xYsAJYUHxYsfHQEBwdj3759UKlUKF++/Hv5n5iFN0MSlapUw1UrV9yWB6BS1erIzMxEUlISQiOi0LRjT4RGRGH58uW4cuUKMjMzP6ieVq1aIuX3nbizcjQSj6+Dk4MJGq0eWp0eN27ewuXfz+LA3l0ICQpE5r3f8eLBVaTeOY8ffvgBNnYO2Lx5c54tvV6P40cPo3fD0pj41XB8+814AMDBgwfx+9Vb8O44Ay71hmLYqNGv1CKVSnFw/x4cO3wAkyZ+B7FcDYFYCmuFDhkZmXj69ClKlCoN/6BQNG3RCq1bt0bGtYO4uXgQEo6vw5HDR+DX4Qf4tp2Irt2656Ur+SMioQA6vzio3cNgLZZBIFZC7RkFnU8s9MEVkXr7PO79uhzPL/6alxNZIpHk21Ko0+lwYO8uHD50EEqNDnr/EtAFlMHZs2dgMtmjlLscAcI72LZlM8qXL4/Q0FCcO3cOs2bNwpkzZ2BlZQWNTo+kG6eRfOd3WIH4ZdHP8BE/hvLaFixbsgh2dnZ49OgRgkLCMPT7eahRtxHuP3iAYcOGISQkpMBr+vlnI/HsZDwe/rYBz09sgMDaGje3zsTdvYuRmfQYvr6+kMpkyEx+iozn92EMqQCtdwzkBhNu3bpVoF2z2Yxx30xAnfqNsGjRYnh5++DJ8Q14cmYHstNT4OjoiPlzZsHJfAfPt36PEcMGY/vOPbAp1gh2UTUgsfXAmTNnCr4Z/0Nqaip27tyJq1evws3NDRnJz/Do+GY8ObIKgYFBL/UXCoXo3Lkzhg8fDmdnZwC5v7MKlaviTKoOl+CCCpWrFng/AMCuvftgU7IVHEs2hdbZDxcvXnyjzldx7949lK1YBS4eXpjw7ffvZONjJiwiCvd3/oh7exdBaEU4OTkVtSQLFixY+KAIhUJMmTIFEydOxJo1a1CmTBncv3+/qGVZ+Btw584dDB/9FZwrd0VAp6nIUrtg5cqV732eRYsWo2XrdvjppwXIXTRYeBYs+BmlylVC96FjEBIeiefPn7+2f7tOXXD6qRCCiOboO/DTNy4AeFsSExORnJz8TmP9fb2RcvlXJF49jpS7F+Hl5fXKfvfv38eePXs+eCo3qVSKbfEbkZWZid/PnoKDgwMmfz8BLtZPcWfZULRv0RhVqlQBSdy4ehl2MXVhG1EN2Wa+cxq1xs1aYs/lBFyX+qNW3fp/qubUs2fPMGvmDPh1mQ3fjtPwxeej89IPhoaGIvXqITw9txcvLuxBRHjYO8/zKipVrYHJS7dixpoDKFG67CtT/Fmw8KcoaGn1x/6xbDG08E/nzp07DAgIoEQi4bp164pazj+ejIwMCqyFjB6yltHDNlAqV/Lx48dcunQpTQGxjB0ZT7fqPSmWKaixyU018KG3qN29e5dr167ljRs3KFeoGNxlOsP7LsrT9l/d7Tp2pqunD4USOQM7TKR/6/FUqjU0m82vtX/69Gmq9LYM7jaTrpU7Myo27o2aXrx4wahicVRqDdQabHjs2DE6uXnSv803jB6ylmqjA48dO8anT59y165dvHbtGsVSGcP6/MywXvMplkgLTD8w9utxVOpsKDM6UyCS0r/99xTKNdT5FKNKZ2SPHp+wS7cehUpJkZWVxehiJahx9KZIZaB9sfq08Y7gjBkz8vU7ePBg7la4qKpUafWcNm0ao2PjqNbb0MnV45W/vfT0dAaFhtPKWkiJ1p7uNfswIubN544klyxZwpZt2nHUqFHUm9zoWKYljSEVqFLrSOamY5HIVbQSWFOs0NLeN4o+/oF88eJFgTbHj59Ao1sAPer0p9po4uLFi1mvYROWqVCZe/bsean/0aNHKdcYKbN1o21kDVqLJLx3795rdSclJdHL15+2HoF56VwOHDjAqjVqs3W7Dnz06BHJ3O2e+/fvZ2ZmZr7x//13RkYGBQJrRg9dx5jhGylVqPLGkmRaWhpnzpzJqVOnMjk5mX369afRPYiOJRpTozfy7t27hTrPf6R6rbp0KtGIQZ2mUGM08dChQ+9k52Pl6dOn7N23H9t16MSLFy8WtZy/DbCk+LD43xb+Eaxbt44KhYLOzs48ffp0Ucux8JFz4MAByjRGGkMrMbjLNEp1Jq5evfq9zrFy5Upq7ZzoVr0ntfYuXLJkyVuND4sqRt/mXzJ2ZDxNAbFcvnz5a/v7BYXRv/U4xo6Mp71PONevX/9n5Ofji6/GUCKVUyJTcPr0GW8e8AeSk5PZul0HhkUV4w9Tp76yz+HDh6nS6mnvGUw7kxPv3LnzVnPcunWL58+ff+Ozz9vSrGVrGt38aecTyZjiJd85NYrR3oEhPeYwdmQ8jS4+/OKLLzh8+HAeO3bsrW2lpKRQKlcysMMk+rUcm++Zz2w2c+q0aaxcvRbHfj3uvaY/yszMpJVAwJjhGxkzYjNlSvXfLu2ehY+D1/nfRe7ovuvH4iBb+Dfw+PFjRkVF0dramgsXLixqOf94GjVtTqOrL208glipanWazWbu2bOHGltHBnWaQqWDN01xjRg7Mp4OUTU4evTot57j1KlT7Ni5C0eMHPXaoOP/YjabKVeqGdxl2ksB6v/y9OlTSmRyhnSbRa1vcQqlikI5299M+I4GW3sGhka8Mn/1q8jJyeGNGzeYmppKknR296JX/U8Z3ncRBUIJVVo99TZ2XLZs+X/m+DbXsZXKOWnyDyRzc7r17defX3zxJZOSkrhixQrOmjWLu3btokgqo9ozggqTN8U6E/0CAvM5cA8ePGCd+g0ZFlWMv/zyS4E6b968SaVGRwDUesfSPqIyx44dm69Pn3796FS2Ve4DQMmmFMsUdK/Vl47F67NYydKvtLtgwQIaPcMYM3wjncq1oczoxDbtO+a179ixgx07dmSJ0uXYq0+/vPNEMs+BfPLkCdVaPd2qf0LH2FosUaYcSbJHz140BJZhWK+fKNE7sm7dukxOTn5Jw4oVK1ijZm327NmTNerUo0ftfowdGU+nuPocN25cXr9NmzZx+PDh+QLVd+/epVyloX1cI2rcwxgcFlHgOfwvy5cvp8kvmrEj4+nTZNQrA/IzZ82iUmugwdmLsXGlmJmZyfT0dFauVpMCgTU9ff158+ZN1q3fiDYeQbTzDmfpchXzPUyUrVCZdn6xtA8swYjoYszKyuK0adMYFBJGG5MTm7VszbS0tDfq/SMhkTH0bfYFY0Zspr1vxFs/iG7cuJGTJk16Kdefhb83lgC1xf+28M/h+PHjdHBwoEql4ubNm4tajoWPmLS0NHr6+FGms6NQqmRcydLvPbDZp18/OpVry9iR8XSp2JHde/TMa8vIyOB3333H/v0HFOh7N2zcjA7RNejX6muqDXZvzH88Z86PVOlsaO8dRi9f/1f6jn8kMTGR3333Hb/77jsmJSW9sk9CQgIlMgXD+y1m6CdzKZZI31hT5l1o3KwlXat0zX3Giq7Ob775ptBjp06bRrlKQ7XBjo2aNn+v1zI7O5urVq3i4sWL38n//C/9BgykwcmLDsElabQzUWtypWPJplRqdO9Ud2rp0l9osLGnnYMT4+Pj31nX2xISHkVTVDU6Fq9HN0/vD3IvWPjnYwlQW7DwNyYxMZFly5allZUVpxbw1tnC+yE7O5vr1q3jqlWr8q0AHfv1OLq4e9HNw5v2YRUZOXgl7QLi+O23376V/YcPH1KjN9K5fFvaBZZkw8bNCj120aLFlMoVFEukHPufgol/pG//ARTJlLSLqUPvxiOp1Oj+koBao8ZNKJRraGUtppVQzIC2ExjYYRJlcmWeM5eYmJjn/CYnJ9PG3oGOJRvTLqgUXT28aXTxpSmkNN08vSkQiilU6CjW2FIgFL3kNFesWoOOxevRt9nnVKh1PHPmzCt1devRkw6xtRk9dB3VbqHU6PR5q97NZjOPHj3KUaNGUefkRZ8mo6ixd6PaxokxIzYzrNdP1OptXmn3p59+yl1JMXwjncu1pZuXb57G6TNmUGWwpz6wNIUyFY2+0ezSrQfNZjP7DRhIkVhMB2dXbt26lcuWLWPNOvXZrkMnXrlyhXv37mVM8RJ0rtgxd4VFaCW6eXiRzF25fvnyZWZmZnLFihWUaYx0qdiRIoWWaq2OaoM9nYrXpVKjyyviuGLFCqqNJjqWbk6l1pAvSL1hwwaGxxRnlRq1ePPmzTde4/3791Nj48CgjlPoWLw+69Rv9FIfZ3dPBnaYxJgRm2hw9uL+/fs5b9482vpEMHrYejqXasrmrdowKyuLy5cv55IlS5ienp43Pj09nQKB9X9WZmyiVKHi2bNnaWtyopXAmnKTF218ojh27Ndv1PtHli1bRqVGT1s3f/oFBjMlJaXQYyd8+z119i50jKpKndH2nVdxW/j4sASoLf63hX8Wd+7cYVhYGAUCgcVntvBakpKSuGTJEu7YseO9B6dJctu2bbmFAUs1pUpvy02bNuW1tWnfkbY+kXQs1ZRag02+nWT/5enTp6zXsAkDQyM5a9bsQs156tQpbtiw4aXgdHJyMp8/f57vO7PZzIjoYrQPLk374NKMio2j2WxmRkYGnzx5kndOkpKSKJEpGNpzXu5qc7nilatyT548yalTp75USLyw9BswkPah5RjcbSYNrv6cMmVKoYOfGr2Rwd1mMnroOqr0th/lTjKz2cz169dz7ty5LFm2Ir0bDc9dWBJdndOmTStqeYXmyZMnHDhoMPv262/xhy28M5YAtQULf3NSU1NZq1YtAuBXX331QRwpC2/m+fPnjCtVliKxhJWq1si3MrYw7Nmzh/ZewYwdGc+Q7rNp7+T6VuMzMjLe+PbeztGFwV2mMWbEZtq4+nHv3r2v7Pf06VNevHjxvWz9mjVrFg0uvvRuOJxWAmtG9FvCiAHLKJbKXrki4+TJkzQ4ejB2ZDzD+y2mQCRlaM/5jB0ZT4OTJ2UKBd2qfUKn8m2p0mhf0ujm5cvADpMY+slcCqVKCqytWb1W3ZfSSrTr0InOZVowZsRm2gWXzbd6um37jtTaOlFjY2LxEqVZqlwlfvb5F/TxC6QpqAQNzj7s9j+rXf6X9PR0lilfiWKJjCZHZ44d+zXdvf1YrGRphkXF0qfpaMaOjKc+sAzti9WntVTJ6GJxlGttGNF/Kd1r9aFQqqBKb8sGjZvy5s2btLV3pJ1HEKVyJQUiCWW27hTKNaxcrSZ///13GmztqTba09svgG3bd6RLpU65jm25thTJVdTojHRwcuGiRYs4ffp0LlmyhK3atqdr1e6MHRlPx9LNOXz48D91nceN/4Yu7l4sX7kqHzx48FJ7VGwcXSq2Z2CHSVRqDbx48SJnzZpF+4DijBmxiS4V2rFhk+YF2jebzfT08aNTycZ0LtuKJkcX9urTl3ZRNRgzYhP1gWWodg/jJ716v5P+K1eucNeuXW/9uw2LKka/lmNzz2NIqbfepmvh48USoLb43xb+eSQnJ+f5zH369LGs8CuAc+fOMTQymk5unpw//6eilvOPZPfu3Rw1ahR37NiR73snNw8Gd52Ru3vPO+yl9vfJnB9/pESmoEQm54iRn+V9n5CQQLFExpgRmxgzYhNFYgl37NhBjc5AqVzJGrXr5v12pk2bTrFESqlcwSVLlr40x/79+6nU6ukcU4NKrZ779u17a51JSUmsU78RbR2cqNEbKVdp6eHt+0p/8484u3nSq/6nDO4ynXKV5qMPnH7+xZc0ugXQtUpXKrUG/vbbb0Ut6W/Bnj17GBwexfDoYjxy5EhRy7HwJ7AEqC1Y+AeQmZnJFi1aEAAHDBhgCVL/DXn27BmNtiY6FqtHG68wtu/Y+b3P8cVXY6i1daK9XzR9/ANfGYzbtGkTFf/ZClemfKWXAruF5eHDhwwOi6SVQEA3L1/GxOWugBZJ5ZQpNRz06dBXjktJSaGdyZGOxevTLiCOBjtHOsbWonvN3lRp9Vy+fDk9fPzp7u3Hvn378qeffsqn8bvvJlJjNFGms6djmVaMHraetp4hXLx4cb55rly5QnsHZyq1BvoHheStHklISKBILKVzhQ65AWShMG8lb0JCAufOncs1a9bQbDZzw4YNLFmmApu3bMMnT57k2TabzUxMTOSlS5eo1OgZ0PZbupRvS1sHZ9oGFKdX/U8plKloLVPTtWo3quzdKNHaMXrYevo0HU2hQsvooeuoMZrYq1cvOsTWYtSnq6nxiKTWYEOZQsnQyBjeunWLzVu1oUv5trmB9pCyrFixIsUqHZ3Kt6VQoaVAKGFgx8l0qdiBMpWWppAyNLoFMK5kaaptnelarTvVRlO+1Tvvm9TUVLbv0IlaG3vamJw4Y+bMvGsdGVOcMqWatvaOvHDhwmvt3L59m23bd2SL1m155coV9urTlw6xdRkzYjP1AaUokcl59uzZD3Ycr6Jj5660CyxBjzr9qdQaLPlN/0FYAtQW/9vCP5Ps7Gz27t2bAFi7du1CpTv4t+EfHEq3qt0Y0O47KtRa3rp1q6gl/Wto3a4DbX2i6FiqGTV64wfL42s2mymTKxnSfTYj+i+lVK7MW61tNpvp7uVDp7iGdIyrTw9vX0YXL0mPOgMYPWw9ja6++fzG7OzsAhe19Ordh07l2uQunCjflj1793lnzYM/HUKHmFq5qT5ianLI0GFvHHPw4EG6enhTb7TjzFmz3nnu/+Xp06f89ttvOW3atLdO7WE2m/nZ6M/p7ObJKtVr5nt+IHNTJU6cNJlt23fktm3b3ovefzrp6elUaXT0ajiMHnUG0GBjZ4mF/I15nf8tKIK6jBYsWHgHRCIRFixYgB49emDChAno3LkzcnJyilqWhbdAp9Ph6OFf0alqKL4Y0BUzp09973MMHzoE61YsxuTPB+K3wwchk8le6tO5ey841ugHv25zce7qLezZsydf++nTp7Fw4ULcunXrlXNMnTYN0cVLoWKVangitEPUkHVIkxiRlZGKNKkdbKLrwpyTjeZNG+eNOXLkCAJDw+HlG4ANGzagRo3qMGbcQusaJXD8yK+oEGALP9xA/Mb1aNiwIS6eOw2pRIyl249hwOffoXnLNnm2+vbtjfj1qxDo4wGhRAorKwGshKK8Ctb/xdPTEzevX8H50ydw5uRxaLVaAIBMJoOVtTUSr/4GWFmBVtb48ssvceDAAWg0GrRr1w516tTB9evX0bRFKzwwxmL3xSdo1bY9AOT97hYuWoSWbTvAbGUNhZMf1B6RsLayQvOqcdDe2wd7gxYa91DYRdeGtVwL5mThxPctcHX1OFhZC5GR8BDZmelwcHBA1pObuLTsCwhEYsj9ykOuUGLfru1wdnaGUqlAzounuLNnIZ5cPII9vx6BIDsT0ruH4eZoD7WNCQqTF1QuwcjKyoZL3SFwrjsUh48cAUk8PPALIkMDUa1atbe/oQpJrz79sPHQeeiLN0daWhpKligBAFAoFDh66ACuX7mEO7euw9fXN29MZmYmJnz7LXr27oMzZ84AAJycnDDvx9lY+NM8eHp64tNBAyF99jtOflMf2qxHOHv6FAIDAz/YcbyKyRO/Q8tqJeBrvoqlC39CcHDwXzq/BQsWLFh4O6ytrTFx4kT88MMP2LBhA0qXLo179+4VtayPisePHkHlFgqloy9EMhWePn1a1JL+NcyeMQ0DOzdFw0h7HNy/F7a2th9sLmuhNcyZ6TBnZQAgBILc8I+VlRX27d6JGqF2qBlqwt5dOyAWicDsDORkZsCcnQ2hUPj/dqyt88b+kfCwUKRe/hXPft+PtMu/Iizk3f0kkUgEZqWB5hyYM9MgFoneOKZYsWK4cfUSnj5+gM6dOr31nGfOnEHxkmUQFhWLXbt2ITs7G8VKlMKEnzfhs8nzUb9R07eyt337dkya/iM0lfvhzBOgd78B+doFAgF69+qJeT/ORsWKFQtt12w2v5WOvwOPHz9GWlraG/ulpKQgMzMTOp9Y6P3ikPD8GbKysv4ChRb+cgqKXH/sH8sKDgv/VsxmM4cNG0YAbNy4MTMyMopakoWPBLPZzG49elIskdLd2zdvteqEb7+nnYMzI2OLc8GCBRTJ1XSp3JlhfX6mXGvLQ4cO5dnYtGkTlVoDncLKUaM38vLly/nm2LZtG7W2TvRt/iX1PrFUOfnnFp4Lq0CdwcigTj8wdmQ8lY5+NNraMTk5mWazmTb2DvSsN4i+zb+kUKqgKbIqnUo3p629I9PS0jh12jS6evqwVLkKvHXrFi9dukSN0cSYEZsZOWgFxRLpS8d79uxZ2tg7UKpQMbZEKY4fP57jxo3Lt1LKbDZz586dXL16db4VEDobO4b2+JGxI+MpMzrTJrgsVTpjvpUM27Zto71XCGNHxufmXnb1oKuHFwUCa8YWL0GdyY1eDYZQbutKqcZIa4mcQrGEQ4cOyy3WYudKgVBMpcZAdy8fBodFUGPnTKlCRaOtPdVaPSdOnMysrCx27NyVApGE4f0W56Y6cfTIy+P38OFD+voHUajQMqT7bDqUakZrqYL+QSE8d+4cffwDqTO5UaHWUSJX0D6uIW2CylAoUzJm+EZGDlpBa6Hog640CI2MpV+rr3PTYASXzCteeejQIY4ZM4Y7d+58aUzHzl1p6xNJpzItqdYZCtySmZOTw+fPn/8lKyWysrJ47tw5Pnv27IPPZaHogWUFtcX/tvCPZ+PGjVQqlXR0dOSJEyeKWs5Hw6RJU6jUGqh3cGe5ilUsqVD+oSxfvoJyhYoisYTfT5z82r4nT56kSqOnlcCaAqGIk6dMKdQcZrOZ47/5luUqVeO48RP+lL/27NkzRsYUp5VAwKjYuJdyZ38InFzd6Vb9E3o3Gk6lWsvTp09TbbBjzIjNjPp0Da2ForeyN3/+fDoEl2LsyHh61f+UpcpX+lP60tPTWbVGbQoE1gwIDitUCpM7d+7w4MGDf6qw44ckJyeHDRo3pVSholKt5fbt2984pkHjptQ7elBn78KOnbv+BSotfChe538XuaP7rh+Lg2zh386ECRMIgFWrVuWLFy/+lK0VK1awUdMW/O77ie8lJ7GFP8/q1asZEhnDytVqFnrb5Y4dO6h3cGPEgF/oWqkTy1aozBMnTlCpNVLjGUGxxpZ6G1vahlagzNaNArGU3n6BzMnJ4YYNG7hq1SrWrFufzhXaMWrwKjrG1OKQIUPYp28/fvHFl0xJSeG0adPoFFmFsSPj6VlvMGVqHRVqHf0Cg9m1ew/KbV1pG1WTIqWeRhdv7tu3jzk5ORSKxIwY8Aujh64jrASMGryKsSPjqTGauGHDBqp0NgxsP5HOpZuxbMXKTElJoc5oS5dKnehYvD7DImPyjjMjI4O7du3i+fPnmZmZyTt37tDVw5NCmYoihY5ypSavOGT/gYOos3elnVcoI2OKMysriyTZqElz2voXo014VQrEMgrlGmp9irNHz14kc53B+/fv08Xdk3YBxSlRGymWK2kTVpnRQ9ZSrjXSoWRTxo6Mp2uVrrQWSenX4isGd51Ba7GM1lIl9QGlaS1VsHLlyszMzGRmZiaPHDnCO3fu5B1Leno6+w8YxHKVqjE8Koa2/sXoUKwu7R2cmZKSwkePHvG7775jr169qHb0oUOp5tR4xVBm606l0US5SkPH0DKUKVRctmwZq9eqQ6nGSIlKR7FMSY+6A+haqSPdPH3e1635SsZ/8y11Jlc6RlWj3saO9+7d44EDB6jU6OkU15AqvS3XrVuXb4y7t1/eCw0H/yhu3rz5refNycl5b3+zXrx4wfCoWGptHanS6PIVlbTwz8QSoLb43xb+HZw8eZJOTk5UKBTcsGFDUcv5aLhw4QIPHjxoCU7/DTl37hznz5/PS5cu5fs+JyeHFy9ezJdWIicnp1DXOCsrixKpjCHdZzO053xKpPK3Kir9Pvmvv/46jh8/zojoYvQLCmV8fPw7zWM2mykUiRk5cDmjh22gQq3jpUuXqDXY0LF0C9qEVaG1WMZp06cX2uazZ89ynx88g6jU6N7Jv/1f5syZQ1ufSEYPXUfHuAasU78Bm7ZoxW49er6UPoQkN2/eTKVaR6OzN/0Cgz/KFEf79u2j3sGd0UPX0bvJKPoHh71xTE5ODnft2sV9+/a980uQy5cvc8iQoZwyZco7p7i08Od5nf9tSfFhwcLflP79+2P27NnYsmULKleujISEhHeys3v3brTv0gO/pRjx1cSZ+Pa7ie9VZ1Gyfv16VC1VCp1bt37n81MU3Lp1Cy3btEO6dw38/kKNRs1a5LU9e/YM06dPx9KlS1/a6pWamgpriQJCqRIitRE3bt7EkGEjkJWdA4nWHl71P0VyWhaSrxyBwSMUSpUGX44eidZt26Nt937oMmAkdu7chXv7l+HExFZIuHwYP0yfgeVH7+CHX+LRuFlL1KxZE6m3TuLO2rF4tPtHzJ05DXt2bsPJY0cxdcpkeNjrkHb/EmwiqyPl8T2cPXsWJNGnb19cmd8bV+Z+ApOTC26tHYdbG76HXqtCeno6ZDo7KBx9oXQLx92796BQKLBn53ZE61JQyV+PzRvWAshNCxFXqiwat+2KmLhS+HHuXCQmJuLBg8fQB5RGRP8lUAWWw5BhwwEAs2bNhmuTL+Dc8DOcO38e/fv3x8mTJ9GqRVN0ql8RyZcPwrVKFwS0nYDkm6fg7uqClStXQqc3wsXVDfXq1EHSjTMwhlWBe51BeHp+H0hCqtLj2YmNuLN5Cp4eWg4BCJmNKwTWIjAnC3q/EvBuOBSulbtg176DuHz5MkQiEaKjo+Ho6Jh3zYYMG46f1u3CbU04zv1+EZUjvdC+YjCOHDoAgUCAqNjimPDzZixevwsZCQ+Q+uAKVC4ByEx6jMzUZOjCqsOpzhAYizXGhk3x2LF9O1yq9YRApkFOjhnSq9vgJbiL+I3rPug9O3BAPyycMw2DW1fD8aOHYTKZsHnzZmhCqsCxYkfoYxpgxeq1+cZUrlgBD3fNwZ1d8/Hi4Q2EhYW91Zyz58yBXKGEUqXB4sVL/vQxbNiwAfeTs+HTZQ5sy3XEsFGf/2mbFixYsGCh6AkNDcXhw4fh6+uL2rVrY8qUKUUt6aPA19cXxYoVg7W1dVFLeSeuXbuG69evF7WMv5z9+/cjNq4kRkxeiMjoYjhx4gQAIDs7G1Vq1EJU8VJwdffEunW5vp9AICjUNb5//z6ysrJgJbCG1X/SeeTGkv56/je9SEHUqF0Xz+2LwRxUHw0aNUFycvJbz2NlZYXOXbri2s/9cf3nfihZogS8vLxgMBhx/+BKkGb4tRqL3r37FioVBZCb0vHc6ZNYPGsSzpw8jqpVq761rv8lIyMDArEcVtYiCKQqxG/Zhl8firH28FXUrtfwpf6fffk17Ct3h0fbyUjIkWLTpk1/av4PgUgkgjk7C+bsTORkvICoEKlcBAIBypYti5IlS8LKyuqt53zy5AliipfAT3su4/PJc9G5W493kW7hA/PmX74FCxY+Wjp27AiNRoMWLVqgXLly2LJly1vnMfvtt9+g9ikO24hqsLIWYf+vBzHwA+n9K7l06RLaN2uGL8QS7D5zFl0TE7F07do3D/wIuHfvHmQaI7TeMZBo7XBj3VcAgPT0dEQXi0O63AGZiQ+xfeduzJk1I29c5cqV4e82CSemtkVmRhokSh3OZzsgOzsLWq9oqJwDoHX0wsAOjSAUChEe3gexsbFo2rQZIgevQvKts0iOn4aInj8j4dIhJB74CTlWSjiVb4/M5KfYP68nnJ2dcebkcWzduhUzZ/+Ilm3aQ2BtDXs7Wxw6sA97d+/EwMGfYsWqNVC5BGDk+B+we98BLF30M5o1aYzMzEyEhITgxx9/xJUrV7Bw8Qk0bd4CCpUG1xf0RVriY/ww8TsAgLOzMxYtmAeJRJJ3jIcPH8bNB0/g0WYyXty7hLHjJ6BO7drIzEhFZvIT5GSkIjPxMVau2oYNGzbA1d0DT09vx7OLhyG28cDC+EOYOmMWbN0Dkfn8LjIz0iG3cYNEZ4JAJEXx4sVRuWp1uDf9AlK9A6b90B7m7EzYF6sHK4EQzMnGuR9aw83NHdefEgmXj8DWRo/2bfvhiy875Tq6nTth7sJleH7pMJ6e2wOZwRHx8fHw9fWFQCDI51QdPXYSutAq0PuXxPMLv2LL1u149PA+AODUqVN4kWmGV63+yEx+itNTO8K1chdIDY54cmo7gj0dcO3mCSReC0H6jaMIqtoKK6wFuLp6HDzrDYY5OxP3ds7E2VMnCu3Imc1mnDhxApOmTMW1G7fQpUNbtGrVslBjq1evnu/f0dHRmDJrPh5p7ZF8dhtK1BuUr/2HyRMRNGMGbt66jfYz98Le3r5Q8wC5L2N69eoD3w5TwOwsdOjUCY0bN8p7oCGZ++LjFTnY/5cLFy5g/ITvoNdpUSw2BlkvEpCV8gyZz+9Bq9UUWo8FCxYsWPi4cXBwwN69e9GiRQv06tULly9fxvfff/+3Dc7+2xk8ZCimTp8JkOjV8xOM+fLv9VL5woULePz4MWJjYyEWi99q7IKFi6CPbgBTXEOYd83HsmXLER4ejl9//RUnzl2Cf/d5SLx+EgM+HYbatWsX2m6/AYOhcQvFmZndQHMOOrTvAKVS+baH9pdAEo8fPkCIb3FYS+S4ayVAYmIiVCrVW9v6YfJENG3cEOnp6ShXrhysrKygUChAcw4cS7d4p2CoUqlE+fLl33ockPu8V79RU+zasR1h4RGoWb0KRCn3cH5KS4iF1pDKFTDFNULWiwScmtX5pfH2dja4e/8i0m1ckZHwEDY2Nu+k40MSExOD5o3rY+a3TaE1GLF0w4ddSAPk5hqX6ExwrtgBqY9vYtumcR98TgvvQEFLqz/2j2WLoQUL/8/mzZspk8no4+PDmzdvvtXYEydOUKnR0TGuITU2Dlyw4OcPpPKvZdOmTYwzGHjHwYlrjTYM9vAoakmFJj09nZ4+vhQrtBRKlWzVug3J3K1sBkcPxo6MZ1jvn6nWGV4am5OTw2vXrrFC5Wr0ajCEsSPjqfeOpESuop1XGF3cPfPy665fv55ypZpW1kKq3cNoKtGYYpWBEQOW0a16D0YXL0lbe0c6FK9PW//irFW3Qd48EyZMoMLoRJuI6owdGU/7mFocMHAQSfLatWtU6W1z80cPXklroYge3n60thayWcvWedsMS5evRPcaPRk9dB2Nrn786quveOHCBZrNZrZo1YZiqZxKjZbbtm1jfHw8d+3axQsXLlCpNTCg3Xd0LteGxUqW5oEDB6h39KLWO4ZWQhGtpUq6Vu3OOg0a8dq1a6xUrWZuLrsha2gMrUTXqt3yqoMLrK1pLVVQrDZSKJHzxYsXFIgkDGj3HSP6L6VAJGXT5i2pMZqotnGgWmdDmVxBOwcXejceRdvoWrSyFtLRxY1nzpxhSkoKFyxYQFd3T4rVRmq9Y6nQGqlSaykQimktEtNga8/du3dz2bJlDAgJp0AipyG4PIVyDUVicd45TkhIoFZvpEuljjRFVKZYpqLS0Ze2kTWoVOv47Nkzjhj1GSNi4jhw8BBmZ2dz+fLlFAjFjBqyhpGDcs99UlISu/XoyejipTjlhx8KvO+ys7NZsWp1StV6CkRS2hdvSLUhf47yt+WnnxawQZPm/GHq1PeaQzopKYkSqZzhfRcxrNdPFEukeVv1zp07R3sHZwpFItasU6/AbaJJSUnU29jRuVxr2oeWp7O7Jz18AiiVyRkSHpWXJsbCPxdYUnxY/G8L/zqys7PZr18/AmCNGjWYlJRU1JIsvCUpKSkUSaSMGLCMEQN+oUgsYWpqalHLKjTTpk+nUmug0cWbMcVLvnWqgUGDB1Os1FGiM1FpsOeCBQtIkseOHaPaaM+w3gvoVr0HI2OKv5XdMhUq07PuQEZ9uob2ftH8+eeP+5mwb/8B1Ng40ODowZp16r1XP/PIkSNUqDS0EljTWijmxEmvz9/9Ppk4cSLt/IsxvO9iipQ6Gv3jaHQPZL2GjZmYmEh3Lx+awivS1iuMjZu1eGn83bt3GVe6HG1NThw+ctRfUsPlXcnKyvrL9D18+JAavZFOZVvRzr8Ym7dq85fMa+FlXud/F7mj+64fi4NswUJ+9u3bR41GQ2dnZ168ePGtxh47doxfffXVn86R9THx/PlzuptMrKHX012l5vgxY97Z1rlz5zhmzJiXcuh+SIx2JnrWH0y/FmMoV6mZnJzMp0+fUq0z0LVadzrE1GKJMuUKHP/D1KnUObjTsXRzKjU6rlq1ips2bWJiYmJeH5OTK/1bj2PkoBUUyVUMj45l46bNKBSJ6ezmwdOnT/PGjRsc/OkQjhs3Lp/zP2zYcKqcA2gILMPoYRtoE1yOzVu0YGyJ0qxSrSY1OgPdqnWnc+lmVOtt6FK+DaM+XU2dkzeNtva0c3BmQEh4vgD1+vXrSZK//vordfYujBqyht5NRlGlM9Lo6ku9gxs7d+3OOXN+pJunD4uXLMNr167x4cOHueelajcaAktTZudBtb07+/cfkKc3ulgJOkRVo9oliFrvGAZ1+oEKW1dKpDIKhCKKxBJ+Nno009PTKZMrKBDLaGUtokgiY0JCAo8fP86g0HC6Vu7CsN4/U6I2UO0eRpmNKyMG/ELncq1ZtWZtTps+nToHdzqUbUmRTMG40uVo7+BM12rdKZSpGNZ7AX2ajKJIKqdYoaFH3QFUOftTKFFQrNSwbLkK+a7jqVOn2LRla9Zv2Ih6Jy+61ehJu+hatLV3zOtz6NAhTpo0iadPnyZJtmzTjlo7J2psTOzRszf7DxhEu4A4+jb7glo7J27ZsuWV98y+fftocPRgzPCN9G89jjJbNzqGleVPP/30yv5nz57l7t27i6xQ61djvqZEpqBEpuCkyf8feK9SoxZdK3dm9LD1tPEI4sqVK/Panjx5wt27d/Px48c8ffo09Q5ujB0ZT2NIRWo8o+heszeVWv1b/w218PfEEqC2+N8W/r1Mnz6d1tbWDA0N5e3bt4tajoU3sG3bNtZt2JiDPx3KhIQEyhQqBrT9lv5tJlCuUBUqZ/HHgqOrBwM7TmbMiE00Ontx//79bzXeyy+AbtV60L/1eIqlCt67dy+vbcTIzyhXqujh7cczZ868ld1du3ZRqdHR4OhB/6CQj/7ljdls5uHDh7l79+4PkkfdbDbz+fPnL9V6Sk1N5eAhQ9moaQvu3bv3vc/7xRdf0BRVncFdZ1CsyV3wE95vMRUqNUny8ePH/P777zl37txC3/cvXrxg1+6fsESZCvz554XvXfOHJiUlhT1792WlajW5du3ad7Zz5swZdu/Rk1+NGcM7d+78rf5u/JN4nf9tyUFtwcI/hJIlS2L37t1IT09HyZIl8/KRFYaIiAgMHTr0T+fI+pjQarU4cvo0GkyYgNmrV2HgkCHvZOfy5csoVqIUpq4/itadP8HUadMKNS4xMRGlylaAWCJFhcrV8OLFi0LPaTabkfDsKTTu4VC5BIIEkpOTodfrsX3LZoRIH6FqiAlrViwr0Eb3bt0w4/uv0SrOFdu3bEa9evVQrVo1qNXqvD5WVlagOQc0myERi/HLop/xy5LFyMxIx63rVxEcHAxXV1d8PXYMBg0alC9dQpcunSHLSkTyjZM4+lUtGPkMa9dvwFNTSZx/oYa9yQEBonsoZrJCcHAwrGUaCIRiZJqtIPQsAUOVvrh2+SISjyzDyQmNUCIiCIGBgTh06BDu3buHtNTUXG3ZmUhLS4d7y2/h3nICfpw9C+3bt8OGtaswc9oUuLm5wdbWFtviNyFKnQBbPEN20mOINbaYM3cuJk+ejOCwSJw9cxqG7EdoWKk4SgY44eaK0RCIZVAHlgcE1gCsMGn6HASHReDHObMhEgkhEIoRVyIOMpkM4eHhMBOQGhwhVumh1Oihyn4GgUgCoUwFkdoWKSkvsG3HbkjdovDw0BpkZ+fg8KGDePT4CQRCCayEYghlaohUBuSYCbVnNGxCKsIuph4EYgmcynfAyfOXsHr16rzzHBISgiU//4TvJnyDzOSnkKhtIJIq4OntBQCIj49HpWo18c3i7YgrVQbDhw+HUi7H2M+GYcfm9Zgy6Xuc/f0ClD4loPWOhsI5GJcuXXrlPaPRaJCZloKMhIdIfXwT5owXSL93AZUqVXqp7w9Tp6J4qbJo2LozSpWtgKysrELf3++LoUMG48G9O3h4/y569fz/PHLmHDOs/nNNrawEebnaL1++DG+/ADTt2AvefgHIysqCXGSFW5smIen6cTiWagrbiGrQOPri/Pnzf/nxWLBgwYKFv46uXbti48aNuHbtGmJiYnDs2LGilmShAC5evIh6jZrgVLoJ89ftRv9Bn2LJop/xOP5bPNnyHZYuWVSonMV/FUuX/gKjrQkmJxds27btpXaTvT2Sr59Eyp0LSE969tbpGR89fAiNZyRULoGQKdV49uwZAGDu3HlYt3Ezatasjd8O/4qgoKB849LT03HhwoUCcymXLVsWVy9dwJa1y3DityPvlC7jr8TKygoxMTEoU6bMB0nVY2VlBa1WC5lMlq/uT+duPTB/3R4cSdCgeq267z0PeseOHSF8cgG3V36OnNREPDyyFg8PLEVwSCgAwGg0ok+fPmjXrl2h7/u+/Qdizb7TeGQXhx59+uHw4cPvVfOH5pPefbF85zFckwagZdsOOHv27DvZCQoKwrcTxmPzlu3w8vGDg7Mrzp07957VWvhTFBS5/tg/lhUcFiy8mgsXLtDZ2ZlqtZr79u0rajl/e2bOnEmnqKqMHRlP78YjWbp85UKNGz5iJO1DKzBq8CraBZXk2LFj32reQZ8OpdpgR529Mxs0aso27TsyMDSSY8Z+/d62QsXHx1OhUlMoEnPg4E/fevyLFy948uRJJiYm8sSJE9SbXBkzYjNDe86nRm/M63f06FFq9UYqNHpai2UM7TmPUZ+uoUyp5u3bt5mcnMyVK1dSodbS6OxFhUZPpZM/rQTWFAjFlMmV9GowhG7VutPRxY19+w+gWm9LtdGeXbr1yKepdPnK9Go4LHfFslxDhb0HJRpbhvaaT4OzN2vVqUsnNw/aOrhQ61OMIoWOTmVbUyhX06/V1zSFlGXTpk1p9AhmYMfJtPWJ5Lhx40mSGzdupEKlodpgxzIVKjEpKYkxxUvmatHquX//fs6ePYdihYbuNftQZutGgUROoUxNK5GUApGUQomMAqGYzpU70Vqqok14FYqVOhqCyjF2ZDwdS7fgp58O4d27d5mQkJDv2FauXMng8GiWKFOOv/76K0myVdv2/5+ypEQTytR6OlfoQKVGz+PHj5Mk16xZQ5XOSKewctQabHj9+vUCr+mXY8ZSpdHR0dWdn3/+Oe/evUuSfPToEb/55hvOnDmTGRkZdHB2Y1CnHxgzYhMNTp48ePDgW98/H4rTp0/TaGeiWCpnpao18rbODhr8KR1KNGLsyHg6lW7Bnr378MGDBxw7dixr1alLvaMHHaOrU29jxwcPHhTxUVj4K4BlBbXF/7bwr+fMmTN0cXGhXC7nmjVrilqOhVewfPlyOgaXYOzIePq3+YZBYVFFLalAkpOTKVMoGdhhEv1ajqFaq3vJb798+TJjipeiq4c358z58a3nGPP1OKp0NtQ7erBi1erMycnh0aNHqTbY0rfFV3SIrMomzVvmG3P37l06urhRZ+dMO5MTr1279qeO88+Qnp7OlStXMj4+/qNOP0GShw8fpq29I4UiMQcMGkyS9PIPYmCHSbm+t3903g7Q90l6ejp///137t+/n3UbNGK7Dp348OHDd7ZXrGRZ+jT5LPdZ4zW7Iz9WQiJi6Nfq61z9wSW5bNmyd7b1888/084nkjHDN9K1cmdWr133PSq1UBhe539/PK8aLViw8F7w9fXF/v37UalSJVSuXBmrVq36R62M/quJiIhA4tVhEB3bhJSLe9GoSa1CjUtJSYG1QgdriRzWch1evEh9q3nHjf0KLZo1QUZGBpb+shyLtxyCLrIpvpkyDVKJGI6OjqhQoQIMBsO7HBYAoEqVKkh8/gxZWVmQSqV53584cQIvXrxA8eLFX7siQS6XIzQ0FNnZ2dBqtXC0M+LmL8OQmfwUnTp2zOsXFRWFe3du4cmTJ5j30wKMn9Af1kIRmjRuDCcnJwDA6K++hlONftB4ReP4hEbwr9ETEr0jri/sj88/7Ysff1oIqUSCKatXIrZYMYT2WQwrgTXmTWyB8V+PyVsZHuDng0v79+P5rQvwbfY5FA4+ODOzGzKeP4SVWIldB47AveFIPNi/GIkXD8OlQgfYx9SGOScbCZcOIyflKVJSVJA4BEDp4IMkxyCc+/13PH/+HNWrV8fN61exfft2LFy6HH37D8T6NSuRlJQEOzs7qFQqxMXFYcLESXhw8VcoHHwQ3GU6bm6dCXNWJpIu7MGOrVvQrGVrZN8+BYlYiGfndkPlFoHEq7/h1tYZSDq/B8cVcfD2CwBoxvy5P6JRo0YAgHr16mHV2vVYt2ETKlWtgc9GDkdURDg2fTsNTxVaPDu3G7qg8nAo0QhIfoCDBw8iPDwctWrVwnfjx+LOnTvo0OEnODs7F3hNhw35FMOGfJrvu/8W58zUeiAn5Qm27tgFe5MJT64dhzkrI2/1z7Vr13Dx4kXExsZCr9e//Q35nggODsaDu7eRnJwMjUaTV9zGZG+H7MfbkPbkNrIeX4WDfTDs7Ozw6aefgiTWrl2L69evo0GD6bCzsysy/RYsvA+srKzmAqgJ4BHJoFe0lwWwFsB/l36tIvn3qjJmwcJ7ICgoCIcPH0bt2rVRr149fPvtt+jTp887FUaz8GEoUaIEUu/3wJ34H5B29zz6dOtQ1JIKJCMjA2YzITU4wZyVjrTUVJjN5nz+tJeXFw7/uved5xgyeBBq1aiOxMREFCtWDAKBANeuXYPS3hNaz0iAxKXLG/ONmTFjJmgfDJ+qPXB351x8P2kyJk/8/p01vCtmsxnlKlbBtQcJyE5PQYNaVTBz2tS/XEdhad+pK1TFW8DJMxKz5/ZB86ZN0KBuHcxZNBUSe1+kP7mF2NjY9z6vRCKBn58fgNz7/21ISUnBsBGjcPXadfT+pBsqVaqETu1ao+/goXhxaS/S712AVCpFrboN4OrijLFfffHRr5Zv27I5Ph/3LZKd/JH+8ApKly79zraEQiGYkwXSDGZnQiQUFdj3558XYsLEKfBwd8Os6T98lAUn/3EUFLn+2D+WFRwWLLyehw8fMiwsjCKRiL/88ktRy/lbs2HDBjZs2oJfjRmbl6vKbDbzi6/G0CcwhE1btOKDBw/y5bG6efMmTU4u1Ng40NnNI19+uLelZp36dK/VN7cYYXhlSuRKOgTF0eTowidPnvzp4/tfhg0fSbXRnnpHD1apXpPNWramUq1lqXIV+fTp07x+T548YWpqKu/evUsXd08qNXq6e/pwzpw53LFjx2tXRFy5coXnzp3L16di1Rp0LtOcwV1nUKrSUKm3o513GINCw5menp7XLzs7myqNlr7NPqdfyzFUqNT52pOSkujo4k5rqZKmuMb0a/U1rcUyKnW2dHRxp314pdzCkQFlKBDLKNbY0qVSJ1pLlRQIRazfqAnPnDlDjd5Ix4DYvBzHErmClatU5chRo6jS6OhW/RM6RNdgmQovr6jfuHEjhSIxtd6xjBm+kYbgCrQSSVihUmXqDDYUisQsWaYcR44cScfQMowdGU/nCu2pN9hw5MiR1BhNjBqyhgFtv6XJyTXP7o0bN6jQ6Bk1ZA1De86nTK5kTk4Ox349jlVq1GaDho2pd/SkU9lWVGp0PHnyJM1mM+vUb0i9owe1tk7s2affW98TZ8+epd7kwtiR8Yzov5RypYqXL19mbIlSdPfy5fz5P3H79u2UKlRUOvhQKJEXmOe6KMnIyGCrtu1pcnJls5atmZaW9kHmWbFiBe0dXejq4c09e/Z8kDksvB/wD15BDaA0gAgAZwtoLwtgw9vatfjfFv6pvHjxgg0aNCAAduvWzZKb9CPj+vXrnDBhAletWvXRr7rt0bM3lVoD5Wotv/zq7XZQvitPnz6lg7MrHQKKUaW35bx58/O1jx8/nnYBcYwcuJz2oeU5fMTIv0TXH7ly5UpuIfXhGxkx4BeKJdIi0VFYvHwD6Nv8S0YPXUedyZUHDx6k2WzmkiVLOG7cuNfuSiwqmrZoRfuQsnSv1ZcqrZ6XL18mSe7fv59z587lwYMHqdTo6F6rD01hFdiwcbMiVlw4tmzZwmnTpv3pmgGZmZmsXqsuBdZCOrm6552fP3LmzBmqdEb6Nv+SjrG1WKtugz81r4X/53X+d5E70O/6sTjIFiy8mefPn7NkyZK0srLirFmzilrOP4oNGzZQZ3Kjf9tvKbdxoUAoolqrz5dWJT09nZcvX/7TReS2bNlCpVZPx6A4iiRyetTun7utLKgElyxZ8mcPJR9SuYLhfRYyetgGSuRKGj1CGN53Ee3DKjIiKoY9evZivQaNKZEpKFcoabR3pEAso01ENZoiq3PEOzq8N2/eZExcKdo5OPOrsV9z//79HDNmDA8dOvRS3x07dtDN04cu7l4vFfY8f/48NUYTQ3vOp9o9jEKpknKFkiKRmIOHDKGdyZE2HkG0lihoZS2ie62+tIuuTYFYTpXJk0q1lqdOneK9e/c4b948ShUqRg5aweBuMykQSalzC6LC6MTYkfEM7TmfSo2WX375JTdu3MjGTVswJDyaCrWWpuiaFCk0BKyoMHnTvmRjaox29KgzgFFD1lBj68RBgwZRoVZTanCitURBjaMX1TYOFMuUDO+7iN6NhtPd2y/v2J48eUKZQsWgjlPo3Wg4bU2O+Y7dbDbz559/Zv/+A/jrr7/SbDZzwYIFlMiVjB66jpEDl9NaKGJOTs5bXZukpCTqbezoXL4tTZFVX1mcs1ylKnSv1YexI+NpCC5PW3uHl/qsXbuWdeo3YsvWbbh169a3esA8c+YM+/Xrz8mTJ3/UQYOkpCTKlbmFm3yajKLOYPPRP0j/m/knB6hzDw9ulgC1BQuFJycnh4MHDyYAVqlSJV9haQv/Dq5du8ZadRuwXKWqr/RBC8uVK1d48+bN96jszTx79ozLly/nsWPHXmp78eIFK1erSalMwTLlKxXZvZ2YmEiVRkfPugPpUqE9vf0CP/icqampfP78eYHtV69e5ZAhQzlx4sSXntk2bdpEhUpNmVLNhk2avbUP/T7IycnhF1+NYYUqNfjD1Klv9Cu9A4IZ0P77vBQk69aty9e+efNmmnwjGTsynoEdJ+d71vg3kZ6e/tpzuX79etr/5zz5t/mGvkGhf524fziv878tRRItWPgHo9VqsWXLFlSpUgWdO3fGN998U9SSPlru3LmD2vUaonjpcq8saPJHbt68CbmDD6ysrJCTlYGIActhW7Erun7SO6+PRCKBl5cXxGLxn9K2feduZKalIuPxDZQqWRJpd84g4cpvSLl3GZ6enti8eTMqVauJLt17ICkp6U/NZWtnj4TLR5B84zTM2VkQaWwhVhmQeOcibmXIsXzveWzYsg3+XWcCKntkKU0I7TEHaY9uIPXRdYglBR8rSdy5cwfPnz9/qc3FxQWHD+zFg7u38OmggRg5+kt8O+1HVK5eG1+N/Tpf3/Lly+P40UMYOexTZGZm/jfYAiC3cEhWRioynt+D3i8OViDUwZVhG9cYk6dMxdb4TZBkp0DjGQlrsQzPf98Pc3YGBNZC+LX7Hprwmpg2YyZMJhOqV68O0IyHxzYh4dIRWEvkcKrWExnJz3B73Thc/2UEsrKJ6ZtPoV7Dpth+/DIu33kEK7UDXKp9Au8mn8FapoRf668hlihhZWUFKysrJFw8hJTEZ5i3ahvS0zOh8Y6BQCyFb/vJ8Gg2FqAZZ6e2R8LeuVgwdzaePXsGs9kMg8GAmdOn4cH6Mcj4bSlWLf8l33mxsrJCy5YtMWHCNyhevDhGjf4cvQaNQFZWNhKvHsPziweh1Rkw+vMv0KlLV5w6dapQ94RKpcK+3TtR1kWARiX9sW7VCgDA1q1b0bBpC3w2+nMYdFokXD6ClLsX8eL+FWRkZOSzceTIEbRs2wGnsxyxZucR1GnYDF269XjVdC9x7949xJUqg6VH7mH4N9PRvGXrQo0rClJTU0FaQW7vCYWjL1KSE/PdnxYsfGQUt7KyOmVlZbXZysoqsKjFWLBQ1AgEAnz99deYPXs2duzYgRIlSuDmzZtFLcvCX0jVGrVxMlGOG1I/VKlWAykpKe9kx9PTEy4uLq9su337NmrWqY9iJcsU6pmjsOh0OjRs2BAREREvtcnlcmzZtB5pqSnYvWNrvqLpfyVqtRob16+F3bPf4Ct+hE3r13zQ+VatWgWDjR3sTI7o2affS+0JCQmIKV4CP+25iDHTfka7jp3ztVerVg0P7t3F1UsXsHzpYggEueEzkpjyw1TUrNsA06ZP/6C+3pQfpmLi7IW4qQrFiC/HY9WqVa/t37JpYzyIn4w7G79H1vO7KF68eL72mJgYmJMe4PaG73B/8yQ0b9L4g2n/mJFIJK9N5VS6dGlIshJxa/kI3N0wAb17dP0L1f2LKShy/bF/LCs4LFgoPBkZGWzUqBEBcMiQIZYVfa8gqlgJOpVqQq8GQ6jU6AoskvbgwQOePXuWt27doo29A41u/hSrDIz6dA29Gg5lYGhEXt+cnBxevnz5pWJ3b8ORI0eosTExvN9iutfsxbDIWDZv2Ybh0cX5449zeenSJSq1enrWHUhTWAU2atritfZOnz7NpUuX8v79+69sP3nyJMMiY+jlF8iff/6Zrh5e1Du40UpgzcAOk+hQqhkFEjmlBieq3cIo1tjRuXw7an2L083Ds8AVGWazmS1at6VcpaVMoeLixQWv/N6xYwelagNjhm9k6CdzaS2SsH6jpjx+/DjHjh3LJUuW0NXDi6bg0jQ4ebFv/wH5xq9atYpefoGMjC1OiVxFhaMfDcHlaS2W8fTp09Tb2NE2ojoVjv4UWItoJRBQ4ejHoE4/UOUSyEH/KYLy/PlzavU21HhFUaQyUG7vSVv/YqxdtwGnTZvGylWq0aVix9yie+XaUOHoR6WjP4UyNV0qd6HaPYxitZECkYRunt5ctmwZtXojraVKejcaztiR8dR4RFBq4/qflCSN6FS+LYVSBZctW8aHDx/SzcOLIomMHt6+b50mxtXTh0GdptCv5RgK5RqKFBoKJXIa/YrRuXxbqnWGNxYDTE9P56FDh3jnzp18358+fZoqrYFuNXrS1jeKXbt/QgdnNwplKgolclasXJXRxUtxwrff02w2c8aMGXSMrJJbbLTRcGo8I2ltLSzUSpT169dT4xqUt9JDKFPy8ePHb3Uu/kradehEtcGOSo2eo0Z/XtRyLLwG/LtXUKsBKP/z39UBXH6Nnc4AfgPwm4uLy5886xYs/D3Ytm0bNRoN7ezseOTIkaKWY+EvQiSWMHLgcsaM2ESV3pZXr15973NExhanU6mm9Go49LXPHB8DV65cYa8+fTnqs9FMTk4uajlvja3JkQHtvmPkoJVU6ow8e/Ysnz17ltd+4MAB2nkE5O6M/GQubewdX2Pt/5k3bx71jp70rDeIOgd3Ll68+EMdQr6C6I4lm3DkyNfvVjWbzVy7di0nT578kv/+X+7du8cpU6Zw9erVlrjAa0hISODKlSt59OjRopbyj+J1/neRO8/v+rEEqC1YeDuys7PZqVOnvNx6RbFF6WNGZ7Rl6CdzGTNiMw2O7vztt99e6rNq1SrKVRpqbBxYulxF3rt3j2vXrmX9ho0pEkvypfjIyMhgqbIVqNbbUqnWcvv27e+ka/fu3TQ4eTJ62IbcvMt/2F60fv16OvhHM3ZkPAPafUfvgOACba1bt44qnZGOwSWpt7HjrVu33jh/WloaT506xYioWFqLZTQElaNAKKbUmJuTOKjTDxTKlHT38smXo/qPnD17lmqDfW5u5fbf087BucC+Xj7+FIhl9Gs1jq5Vu1FqdKbRNyY393axutTYuVCht2PsyHiG9JjzWmdSrtIwrPfPjB0ZT5nOngsXLmSpMuWodg+je83eFMkUrFS1OuU6e4qUOuqMdty3bx/Hjx/PgQMH0t4nPDcw2mESdTb2/HrcuLzcxQsWLKDOwZ3uNXtTYbCnSCKjyiWIQoWW1hI5Hcu0ZMSAZbS2FuY5fykpKVTpjDQEl2dA2wkUKrTUB5Shb4uvKBBJqXINoVv1TxhVrCQ9ffwp0ZkoUhmodg1m337933i9/pdadRvQIbIKPeoMoLVYxtCe8ylW2zC428zcfOZeIdy5cydJcunSpWzRqi3nzPkxT+uLFy8YHBpBg5MnlWod58+fn+foLliwgE7h5Rk7Mj43N1/xUszJyeHZs2fZtl17ql2D6dv8S8r19ly9ejUvX75MlUZH24jqFGtsaQgqS0cXt0Idx507dygQSehYuiXVbqGUaY0fdbDAbDbz7NmzvHTpUlFLsfAG/s0B6lf0vQHA+KZ+Fv/bwr+Jc+fO0c3NjTKZjCtXrixqORb+Alq360Cjiy/tfCIZXawEs7Oz3/scOsP/P3PoHdxemZLjYyA5OZlGOxMdSzahfXBpVq5W863GJyYm8tixY0Ua2DY5u9Kv5RhG9F9KmVJDuVJFsVTOtu070mw28+nTp9QZbelUpgXtAuPYoHHTQtnt3qMnnSt0yFuk0u8tffS3IT4+niqtgU4xNanU6F75jPoxk5GRwTlz5nDSpEmvTbVi4d/D6/xv4V+zTtuCBQtFjbW1NWbOnAmtVotvvvkGiYmJmD9/PkSigivX/pvo2KED5iwYDbHKCHuDFsHBwS/1+XT4KLjUHgy1eyjOL+iLCxcuoHbt2qhduzZevHgBqVSaV6V7+/btuHDzPvy6z8PziwcxaOgIHDtc4ZVzX7x4EdnZ2QgICHhpq1HJkiURExaIfVPbgDnZWP7LknztcXFxyEm4jzvrv0Hqgyvo37Pg7Uc/zJgN2zLtYAypgDubvse6devQo8fr0yxIpVKEhISgfLnSeCB1h3P5tri9cx6eHNuAp+f3IfX2GURFRmDXti3Izs7Ghg0b4OLigpCQEOzatQs9+/TDtWvXYW9vh/QXSbiy8muIFDrIpVKcP38eM2bNhqPJhD59esNsNuPzL7/CtevXYF+8Ia6tnQBYWcG32ee4vXM+5M5BcK7cFQlXfsPV1ePw+ORWpD+4DK1OA1dPbzg6OGLxz/Ph5uaGFy9e4MmTJ4iKisbFvT9DYuOGzNRkdOn+CZydXeBQohk0HuHIunUCbVu1QKvmTZGSkgIbGxtUqVEbUqcgJFw+DCsrayjP7kbC5SNIT0+HVqNF3/4DkfLiBYYOHojxo4dh287dqDbhazg4mFCjdj241uiFm/HTYS1V4tGR1fD08cu7rgsXLkRqWjqs01NwY8sMWAmsofEIg8YjAiKFFoagskh/cAUGGw3O/X4BoT1/QsbzBzg7p2fetsLCkJqairS0NDw+tw+Km6cgkUiRlfIMIrkaN9Z9B4WTH1Kf3kVoaCg2bNiALj37QRddH5tGfgmBQIB27dpiy5YteJwGeLb7Ac8vHULHbj0hsrbCoAED0K5tayT17gtunYHUW6fQoe8nIIlz585h1Zq10MU2htYrCs/dwrF+/XrUrVsXhw8ewJQpU7DtxXXYGwSYvmR9oY7F0dERdWrXRvyOLRApdDBoVAgMfHU2gnnz56Nnr94QicRYMH8uatWqVehz9r6wsrIqUN+rIImJEydj/eYtqFCuNIYMHvRW19qChXfBysrKHsBDkrSysooBIADwtIhlWbDwUREQEIDDhw+jTp06aNCgAcaPH48BAwa8dlu4hb838+bMwoYNG5Camoo6derk+fXvk44dc585JGojnOwMCAoKeu9zvAqz2YyUlBSoVKpC3cPXrl0DhVI4lW+HrJTn+HVOt0LPdeXKFRQrUQpWEiWss9Nw+OABuLq6/hn578T8ObPQoFFjpKelQa3Vw6Zid6hcQ7Bm7ifocewYoqKicGDvbkydNgMm+wD069e3UHYb1K+LBQ0ag6lPkXB+L+p8tvqDHUOVKlWwY+tmHDlyBGXKjH3v90tOTg5+/PFH3Lx5C23atIaPj897td+4aQscPHsN1nI1ps2cjbOnTkAotIQhLRRAQZHrj/1jWcFhwcK7YTabOWbMGAJgrVq1mJqaWtSSPgpWrFhBiVROiUzBOvUb5q0wP3LkCMtUqMwqNWoxJDySrpU7M/STuVQb7V+74mH37t3UmVwZ3m8xXSt1YulyFV/Zb+jwkVTqjFQb7NipS7dX9jGbzbx+/XqBqUIePHjAmTNnvlQw8I/07tuP9kGl6NdyDLV2zoyPj39t//9l8eLF1Dt60rvxSBrdAtilSxcWL1WOjZu24KNHj5icnExPHz/a+4RTpbPh2LFfUyyTUyCW06F0CxqCK1CstqHOL47WEgVd3D2p1hnoVLoFbf1i2LxlG/oFhlCs0lPtHpZbkNAjhCKpnPZeIbQWSWktVdKtRk8qnQMoMzpRrtazRu06VGoNDOwwic5lW7Fk2fL89ddfqdbqqdQaGF2sBB1d3Kl0DqDaLZRilZ5BwSHUObjTMaYmtQabfNvfGjdrSbcaPXNXGMfWo0zvQLFcTY1nJH1bjKFQIqdDTE26lG9Do50p7/dz+/ZtxsSVokAkYXC3mQxo/z2tpUraObhwzpw5effKxIkTKVbpaQytRM96gygQyymUqqgweVOic6BIqWdAcBj3799PgVBC/9bj6Vq1G4VSBR89ekQyN3XM0aNHefbs2QKv17hx42gXEMeIAb/QPqQsK1WuSi+/QAaHR1Km0lHtHka5Ssv9+/dzyNChdCzdgrEj4+latRvbdehEkty7dy+1dk4M6TaLprhG1HrHMqL/UorEEqalpfHixYv8+uuv87YHtmjdlka3AGrcwygQy6nzL0VrsYyTJ08u9H1WENnZ2Vy4cCEnTZqUdx7+SFJSEqVyBYO7zmBAu++oVGv+FtsWFy1alPvbajScBlc/Tp06ragl/WvAP3gFNYAlAO4DyAJwB0AHAF0BdP1P+ycAzgE4BeAQgLjC2LX43xb+jaSmprJJkyYEwE6dOjEzM7OoJb0zZrPZsouyiDGbzdyxYweXL1/OFy9eFNhnwMDBdHLzYO16DZmYmMgNGzawV+8+XLNmzVvPefnyZTo4uVAkkbJ0uYp5uwFfR0pKCu0dnOlQrB5t/YuxZp36hZ6vZ+8+dCzVNLdQX/F6HDp0WKHHTp8xgyqNjvaOzty9e3ehxxVETk4OMzMz6RsQTO9Gwxk5aCXVRhOPHz/+p+weOnSI33777Ue9q68w9OjZm0aPYDrENaLWYPPeU86IxBJGDl7JmBGbqTHa88qVK+/V/j+JZ8+esUTpcpTJlaxVrwHT09OLWtIH4XX+d5E70O/6sTjIFiz8OaZOnUoALFOmzL+2Svnjx485ffp0rly5ks7uXvRvPZ7RQ9dRZ+/Mo0ePMi0tjVq9ke41e9O1Ygc6OLvRNzCEap2BNWvXYXh0cbZq255JSUkv2Tabzezdtx+lMgW9fAN44cKFl/pkZWVRKBIzov9SRg1eRYlMwSdPnrz340xLS+P27dv522+/sUOnLgyLKsbvv5/0VjbMZjMnfPs9S5evzNGff/HSw8369evz0mH4tx5HOycXWotldK7QngoHH8rtPWkILk+ZjQuDu86gzjuGSpNXbpqObrOo0hooUhmo9Y6lwtGPEp2JnTt35s2bN7l9+3ZaCQT0aTqahuDyFIhlDO31EzU2Dvzpp59o4+bPmBGbGdB2Al08vFmybAV61OnPmOEbaecVyiZNm1GqsaFtVE0GdphElcHEMWPGcMKECS/lFvxq7NfUuATQu8koSvQOVNk4USyRMqzXT4wespawsmLEgF9ecrJq1qlPp1JNaAiuQIFIQmuJnCqVgSKpgvY+4VTrbTl12jQ+f/6cHt6+FIhlFCl1tLIWUSSRUCKT0+DoTmc3D27bto316tWjUKGjzMaVCgcfSmTKvOvQsEkzau2cqNLbcsTIz155vYYOHUaH2Dr/yVfXmL379CVJ1m/clB61++VuSSzRkGPHjuWePXuo0hroWKop1Qa7fA8+Iz8bTRt7RwqlCvo0+YyB7SdSJlcyKyvrpTklUtl/8jZuplCmpliqYERUzEsPQcePH+cvv/zy3vNIP336lBK5gpEDlzOs9wKKJdJCbc09deoUZ8+ezfPnz79XPYVl8OBP814QuFTqxE5duhaJjn8j/+QA9Yf6WPxvC/9WcnJyOGzYMAJgxYoV/5Zb1bdv306t3kiRWMKx48YXtRwLr2HZsmU0OPswuMt0msIqsGatOlQb7OhcoT01RhNXr179VvYaNmlO53Jtcn1j3yjOmzevUONu3rzJoUOH8ZtvvilUUPu/fDb6c9oFlWJ4n4W08y/GCRMmMDMzs8CA/H958OABZUo1Q7rNok+Tz2jvWHBKwLdl79691OgMFIpE/KR3379kEcN/04hkZGR88Ln+yP379xkfH//GGjYePv4M6jQl92WCfzQ3bdr0XnWER8XSsVgdulRoR4OtvWVx3Gvo068/TZFVGDFgGW19ozl16tSilvRBsASoLViw8EoWLlxIa2trRkVFfdRFx/4MZrOZDx48eMmpSklJobObBx3CytHg7EO9rT096w5keJ+FVOlsePbsWd65c4cKtY4xwzcy6tM1FAismZOTk+vg2Jjo2+IrmsLKs2Pndwsomc1mqnV6+jQdTf8231CuVL3RcXtb0tLSGBwWQRv3ACq1Bs6ePYdk7kNKSEQ0i5UozdOnT+f1v3HjBk+dOsWcnBw+f/6cXbt/wtr1Gubl1n4Vz58/Z/ESpSmUKulSqRPltm402NhT71eCsSPj6dPkM1qLZRRKpNR6xzB2ZDzdqvWgQCShKa4xVS5BFIhldK3anaa4xhRrbGllLeLo0aPz5qhesw5tvSOo9YygUJa74thoa8+EhARq9DaUGpxoLVVSpdGxQuWqdKnQnpGDVtDg7MV169bRxdOHPk1GMXZkPE0BsVy6dOkrjyUrK4v9Bgyk0eRMjd7IXn36cczYr6nUGihVaWklENLKWpgbxPYLyFtFFRtXmt6NhjNiwDJaCUU0CUVsL1dQYeuWmx+87bf09A0gmbsaePjw4RTKlFS6BtOlSjc6uLjx+PHjnD5jJlV6Wxq8wikQSehcsQMNweVp55hbmOzWrVtUqHWMHrqO4X0XUSyRvvI4bt++TZOjC/UmV+qNtgyPiqW3XyADgkMpVupoCCpLpdbAAwcOkMx12keNGsWtW7e+0t6yZcupNdhQa7B5ZR5Os9lMo70j7Ys3oFu1HlSqtTxz5sxLLzIWLVpMld6GjkElaGdy4sOHDwu8r/6XHTt20N3bj+7efty2bVuB/QYO/pQypZoyhYrffvf9G+3u2bOHSq2ezlFVqNToiySv3+HDh6nU6OgcU51KjT4vL7iFD48lQG3xvy1YeFvmzZtHkUhEf39/Xrt2rajlvBUmJxf6Nv+SYX1+plyl4c2bN4takoUCmDRpEh3+U1zarUZPenr70ql827yX2d26f/JW9t41QP2upKSksHqtutTojazXoDHXrVtHhUpNkVjCXn37FTju2rVrVGj0jPp0DUO6z6ZYKue5c+fem66cnJy8YPH69evz7QYtDG8T1M7OzmbNOvUokSmo1Rt5+PDhd9L8Lpw/f54avZEOflFU6wz5nvX+y/HjxxkZG0e9rYlG70g6l29LlVbP27dvv1ctDx48YKcuXdmsZev3ei3/y995R8sfad+xM53Ltsp9Xo2swq+//rqoJX0QLAFqCxYsFMi6desolUrp7+9fYKXfvyvZ2dmsXrMOZQo1VRod9+/fn9e2f/9+2rr5567g7T6belsTTU4ulEhlHDX6c5K5TkipshVo6xVKo6svm7VsTTL34cQxrBxjR8bTu9FwlihT4Z017ty5k64e3nRwdnunLXtvYvv27bR1D8hbYezh48+kpCQq1Vp6NxpOt+o96OzmQZKcNn06FWottbaOrFG7LqvVrENTRGW61ehJlVbPu3fvkswNki5YsIAnTpwgSXbu2p32YRVpKtaAApGU7jV70zawJEUyJR3LtKTa3p2fDhnK7du3U29jR4OLL2UKNbVO3jSVaJybCkKqZMyIzYwcuJwQWFOitafWYJO3ojwjI4Pz5s2jm4cXbYLK0bFUM+pt7Hj06FFaCcX0ajiMIT3mUOfgzlWrVtHByZUCkZQSuZLTZ8zgypUrqdToaecVQncvnwLTpbx48YKnTp16qaDL6dOnKZbkFhoM6TGHQpGYDx48YFZWFnfv3s0pU6ZQqdbR4OhBG72ew9Qa7rKxo0Qip1P5tlQ6+jI0IoqJiYn85ptvKFVq6FlvEDVeUbSWKKg32jIlJYUBIRH0bfEVY4ZvpNI5iHJ7L8rsPFipSnWSuS8D5Eo1/VqNo2e9QbRzcCrw2qempvLs2bP09guka+XO1HjFUOdXgt6NhlOiUHPGjBnMycnhyM9GM7p4KfYfMIi7d+8udND4fzly5AjVBvvcwLeTP718/F7Zr1jJsvT+z4sCh5DSXLBgwRttZ2VlUaXR0qfpaPo2+5xKtaZAZzQrK4vTpk3j5MmTC/Wyp1OXrnSp2DF3pXnp5hw8+NM3jvkQnD59mu3atWPHjh156tSpItHwb8QSoLb43xYsvAu7du2iTqejjY0NDx48WNRyCo3Bxo5BHacwcvBKKrUGXr58uaglWSiA+/fv097BmfZeIVRp9Bw3bhzVBns6V+hAtdHEVatWFdpWZmYmP//8c2p0RgrFkkKn+HifOLt50q/FGEYOWkGV3rbAQKXZbGa7Dp0okikpEEmp9S1GrcHmtYXY34Vr165RqdHRu9FwOsbWfmMByN9//52uHl60thayXYdOhQpUb9q0iUZXX0YPW0+POv0ZW6L0+5L/RgYMGEjHkrkpVpzKtGTP3n3ytZvNZtqZnOheqw+9GgyhWCpn+46d/nTakw9JRkYGjxw5kvc8+ujRIwaFRtBKIGCxEqVfuaP578aFCxdotDVRZ+dMVw+vd3om+zvwOv/bkp3cgoV/ObVq1UJ8fDxq1aqFkiVLYtu2bfDy8ipqWa/FbDZj7969EAgEKFWqVIGFPnbs2IEjpy8gqM8iPPt9P3r3H4TfDh0AAHh6eiIt4SEeHd+MjAeXERkRga2bN+Qbb2Vlhe1bNmHdunWQSCSoUaMGAKBatWoYPGQ47qz+Ekl3L+KLaVPe+VjKlSuHG1cvvfP4P3L//n389ttvCAkJgaurK0wmE9ISHiHl9nkkXzsOdycnPH/+HLQSQOtTDDkZqTi9bTZIYuRnn8Oj2RhIjc7YP6sLRALAVH8U5DauSPt9F65cuYL09HRExhSD0jkIiTdOo16d2li4aCEAAWyjakBh8oJtRDUk27pBmvYQjWMcENz+M7Rq1QpWVla4df0qjh8/Dq1Wi2o1a8P89BqSrp+HtVSFi0tGIjPpMZSOfghs9y1urvkaS5cuRY8ePSAWi9G2bVt07dYdQb3GQShV4MKF3Vi0aBGkOhOent2N1AdXkZrwGOXLl4fA2hoetftBZuOC/gMG4/LF8zjx22HcuHEDxYoVg1KpfOnc3b59G7HFSyAtm8h4kYz69eqgc8cOCAkJgaenJ2CVe0/ASgArKwF++eUXLFm2Ehev30FOxgt07tQRTZs0wsOHD9GmQQMk5JjBjHTc/3UFTMUb4NrpLfD29UOmQAaJnReMweUhlKlxK/EJEhIeQGOwBUCI789E2pM7EIjE8KjVH4AZ6c+O4tmzZ5g6dSoiI8Px+7bJMBoNWLd6ZYH3gkwmQ2BgIO7dvQ2HUBOy0/fDuUxLaDwjkPr7Luh0OsybNw9T5y2BJqI2Jk75AXOXrkbOi2fYtX0rIiIiXnuvHT58GCkpKShTpgyysrJgLZbAo3Y/JF49DvPJ5a8c4+fjhS3H90MgFOPFvcu55/UNZGZmIi01FUonfyTfOY+0tDSkp6e/ssBr42YtsP/477AWy/Dz4l9w6MDe1xYcDAkOwuot0/Dc4IS0a0cQ3Ln6K/tdv34dNevUx/WrV9C6TRtMnzrlvRbJ2rQ5Hmu37YPMLRK/lCmHY0cOwdvb+73Zt2DBggUL74+yZcvi4MGDqFGjBsqVK4cFCxagUaNGRS3rjUz6/jt06tIFhBXatmnz0fv7/2bs7e1x4fwZHDt2DD4+PnBycoK/vz+2bt+BCp9MQ926dQttq037jthx+CzknjGQ3j2FubNnQCKRfDjxfwIrKyt8/tlILFqyFEonPziVboFH26fh4sWLKF68+CvHkCzQJ3v8+DG6dO+Jm7duY3D/3mjcuDGAXL9OYXSE3r8kJFo7XNg+CRcvXsSGDRvg7++PatWq5bPZo1dfwLMcwhpWxbrFg7F161ZUqVLltcdibW0NmnNyP9mZEH6AgpsF4eLijMw12/HiwVVk3v8dLrWa5WsniSePHiDMvxQEIjHubpmKLz8fDZPJ9JdpfBtevHiB2BKl8OBJIjKSn2PZ0kXYvmMnnolNiB76BW6sHYfp06dj0KBBRS31T+Hr64sb1y7j1q1b8PDw+Gh/px+UgiLXH/vHsoLDgoX3y9GjR2kwGGhvb//KbUAfE02at6Te0YN6B3e2atu+wH47d+6k3tGDUYNX0b1GTxYrWSZf+759+1i9Vl126NTlrd/MP3z4kEuXLn2nN80rVqygh48/I6KLvbbQ3dty4cIFavRGOgYWo0qrzyvaMXPWLHr4+LNkmfK8efMmzWYzq1SrSaOLD3X2Lvykd25+Yi+/QLrX6sugzlOpUGvZvmMnGlx86BBRkQ7OrkxKSuL3339Px5gaDGw/kVrvWAqsRQzvu4iBHSbRSiSllVBMm5AKVBidKFOqWbFK9QLzND5//pzr1q1jXMnS1PuVoG1ULQpEEtpFVGVY7wU0uPqzYcOGnDZtGjMyMliidFkKhGKKFDoq7b1oZS2kWCKjVKWjPqA0ZTo79us/gCSp0RsZ3HUGo4espUpvy4sXL77x/A0bNpymmFqU6Ey0i61LsdpIsVJHmULF8ePH84uvvqJIIqVQJKFMpaMpojIFIglDe85jWK+fKFOo8mypNHqqXIKp842jY5ncrVquVbpSrrdneN9FtJYqqQ8sQ7HGjhK9Ax1KNadddC2q3cIo0Tsw6tPVdKnUiVK1kUqNjvPnz6dGZ6DczoPWEgUVejsuXLjwjcc0fMQoSlU6ipQ6iuRqipU6OoaVo629Ix89esT+AwbSsXQLOldoT5uwKnlbR1u0bkuSTEhIYI+evVmvYeO8dCAkOXjIMGpsHGh08WH5ilWYlZXFRk2bUyiR0Uooolgq5xdfjXlJT2JiIlu0bsuwqGKcPmPGG/X/l249elIkV1GisaVQpqKdk9tLaVpycnIoEFgzeshaxozYRIVG/8ZdITk5Ofxs9OcsWbYivx43vsAVMdVq1aFz2VaM6LeEeifPNxYkfRUnT57kxIkTeejQoZfaipUsS99mnzN2ZDydIyt98K23FnKBZQW1xf+2YOFP8PjxY5YoUYIAOGbMmL9FYd7ExMT3XgTNwrtz8+bN955S4Y9o9TYM6/0zgzpPpbVYSqlCzeIly/ylq6jj4+PzUnz0fk2KD5IMCY+iqXh9ulbrTmuJnEZb+1fWS0pOTmbpchVpbS1ksRKlX7k7smrN2nQsVoc+TUdTqTXk1QRKSUmhu5cPbX0iqdAa2blrV6p1BtpHVadIoaNcqc5XoLF4qbL0qDuAMcM30tYjqFC7XnNyctisZWtaC0W0sXfgyZMn3zjmfZGZmcnOXbvTzcuX7Tt1eSkH9qVLl1ipSjVq7JxocPJirbr1X/v3KykpiefPn+e48d9Qb7SlT0Awz5w586EPI48VK1bQzieCMSM207vRcEbHlWLPXn3oGNeAMSM20xReiV999dVfpsfCn+N1/neRO7rv+rE4yBYsvH/Onz9PR0dH6nS6j3bLYmJiIsUSGaOHrGXUp2soFIkLLLZgNpvZvmNnWlsLae/g/E5b57Ozs7l69WouX778vRS4ePDgAeUqDf1afU23at3p7Rf4p23+l2HDh9MhrlFukKtCB3bs3IVk7jE0atqc1kIRbU2OPH36NLOysrh161bu27cvzyE5fvw4vf2DaGPvwBkzZ9JsNnPhwoUsU64CS5Qpz6VLl3Ljxo1U6u1yg4SxdWktVdK9dl/ax9alxiuawd1mUWnvSbFSy9Ce82iKqMyevfvywIEDHDNmDKdPn86ZM2fmy9vo7R9ItUc4Va7BlMiVjIqNo1pnoFylpSmmFm28IxgdW4xitZFhvebTvlgDWgnFDO+zkEGdp1EilbNStZoc/fkXPH78OMuUr0Qvv0BKZUqq9LZs0rxl3jGmpaXxyJEjr3w4mzBhAo3eERRIFJSbvKlyCWbMiM10r9WXYqWOYpmCWltHqvS2efmsdb7FaV+sPl2rdqdSa+CRI0fo7u1Ha4mcMlt3CkQSCmUqulTqRLWNA6VyJX2bfUHbsIrUGYwUSOSU2rgwaug6OpdvR6VzIOW27owZvpGu1XowMDSCN27c4JgxY2gXVTMvgKx0CWK5CpXy6b969Sp37NjBlJQUms1mnjhxIrcIZ78ljB6yllKFikuXLuWPP/7IZcuWcdmyZdy3bx+VGh0V9p6U23kwtMePtAspywGDBjMnJ4cVKlelKbwS3ap/QpVWn1doRaZQMbzPQsYM30iV3paXLl1iUlISRRIpw3otYHjfRRSJJYX+zZjNZq5evZrTpk17ZR7Aq1evUqHRU+tbnHbRtXNTfWgN/P333/P18/T1p3OZFnSt0pV6G7v3Vv26RJny9Kw7kDEjNtHOJ5zLli17q/H/zTPtFFubSq2B8fHx+dqHDB1OG88QulTuQqVW/5c6/f9mLAFqi/9twcKfJT09nc2bNycAtm/fvkiKoVn4+Hny5AmvXLmSLwg4eMgwytVaylUafvb5F+91vpycHH73/UQ2bdGKoRFRNIVVoNzOg65Vu+XmofaJ4KJFiwptb/v27RwydCi3bNnyzpqysrLy0q89e/aMhw4demVahv8tui3TGLhr1y6Sub7i0GEj6OjqwSrVa3L48OG0Cy7N6CFraQqryGHDR7xky9M3gAHtvmPsyHjaeYfm87/2799PuVJNW68wyuRKmsIq5qZvbDyCCkc/urh75fU9cOAA1Vo9FRo9A0PCGBNXmi1at+WzZ8/eeNzp6ekf1curgwcPUqnR0zG0DGVKFWfPnv3aouKnTp2izmhLlcGOQqmSId1m0a16D4ZGRL+zhmfPnjGuVFmKJVJWrlbzjYUTd+3aRZ29C0N6zKFz6WasUbseb9++TWc3j9zn6sDg954GxsKH43X+d8H7Xi1YsPCvw9/fH/v374der0fFihWxffv2opb0EjKZDDK5HM8u/opnF/ZDpdYUuP3FysoKP86eiYyMdNy7cxMhISEv9SGJH3+ci2Yt22DRosUvtTdp3hKd+w5Dj0+/QOlyFZCQkPCn9D99+hQiqRxq12BoPKPw8MH9fO2zZs+Gp28Aylasgtu3b+fTefDgQRw9ehS5f9dfxt3NDZn3zyPl7kVk3DkNT3d3AMCWLVuw69djiBi4AvLwuujZpz+EQiEqVaqEkiVL5m1hCw8Px6XzZ/Do/l106dwZVlZW2HfgIC4+zsRDm2Lo3L0XbG1tERcVBtvImnCr0hVOZVvhVvx0PD6+CTKdPeQ2LlC6hcBapoVUZ4LY6IazZ86gSo3amLL+GD7pMwDDJsxEYHAoOnTshE2bNiEhIQEZCQ+R+ugGBEIxpv8wCdviN0Gpt4NL1R5wrNYbZ8+eg0ipg1hjB5mNS+4BW1nBSiCAtbU1tmxchxHDh6FqjVq4KfVBjldFSGVS/LpnB5YsXAAAOHHiBAJDQlG9QXN4+fpj9+7d+c5fy5YtwaSHAM0QqwzITk9GVsozpD+9C7nJBxDJ4dNlNnIgwLOTm/Hk7C4k3TyDx6e2496+xShftjSq16qNZKkjTHGNkJH4CLaRNSAwZ6OCCzH7h+/x4+xZkF7agDhPPY7/dhRGvQ7ZLxJw4vsWuLt3MV7c/R1aCXFsfEPcjJ+O38+fw4EDB2AymZDx4DJSH15H0s0zSHt0E6dOn87TvnbtWoRGRKF5594ICY9E81ZtULZydZghQNLN00i+cwGZGRlo0bI1Rnz2OTr3GoBeI8aj2ye90LfXJxDADKmNK87N6wdJyl3079sH/oHB2LlzJxQe0XhyeidevHiB9h07gyRMDo54fuEAEq78BnNWBgwGA4RCIawF1shOS0Rm4mOIRGJYF3I74+Ahw9Cx50B8OXsFwiNjkJycnK/dYDDAnJ2FtEc3YAgqC613DBQ2Trh582a+ftvjNyHWzowg6UPs2r71vW2NG/vFZ3i0+0dcnN4BzjoZatWqBQBIT0/Hrf9j7yzDq7qatz/H3d3i7h7iENzdXYK7SxIciru7F7dA0lJoixQKFHco7ho0xM79fjh98j75B0kolLbP+V3X+ZK91qzZO/sks2fPuufmTcrPz//g/K3bthHfKYye3bpAucShyVOmFjo+csQwGtC5FSWa82n75o3k5+f3Wfy2Y8eOHTtfFh6PRytXrqShQ4fS4sWLqVKlSvTs2bOv7ZadvxGbNm0iBycXCgovRTVq1yWr1UovX76kKVMmk1f7+eSVNJdGjxpF2dnZn2W9rKws6td/AI2eOo8OPZPT79euU4KPntQiNlmzXxPy8ygvO4u4XG6x7H3//fdUu35jWn7gBtVr3Jx27NhRZMzr168pqUMnioxJoMWLl7zTDpvNJqFQSOfOnSMXd0+q0bAluXt6F3reISKqW78B3dwwjG5uGkmuTg4UGxtLREQZGRk0d8lKUlbqS6cfgbbvzCCWQEpMDo+YQhm9efOmyJpdO3ag29sn0M31qSREFsXExBQcW7t+AylDa5Bzk29I7BFFTy8fpkcnvqcHR7aTQO1A2Tn///cRHR1N9+7com2b1tP1GzfpmTmBfjz3gNokdfzo9ePxeJ9VFu7PsnT5SlKE1SJzzUGkDK5KV678/sF4fdTY8SQJrknmGgOIxRcTX2UiodaFnv6Jv3NjvxlH115zyb/nKjp5/QnNmzfvg+MTEhKoc7tWdGd9Mulzb9HcWdPJbDbTtSuX6Orli3T21AlSKpWf7I+dvxHvy1z/3T/2Cg47dr4c9+7dg7+/P7hcbomacPxV/PLLLwgKi0RweKk/3RF52bJlUBid4Vy1O2RaMzZv3lxwLCcnxyYZMHgbIpJ3gMnhQSyV/6nq8vz8fCSWrwSV2RVSpbaQDMKZM2cgUajh02oSzHGNULpchYJjjZu1gELvALnWhE5dur3Xdq8+feHu44927TsWVPFs27YNGicfBHRdBKlzCFRqDeo3bIwFCxbCarXi1atXyMjIwLlz5wpsZWRkYNKkSQgIjYBHo+G2JnJBZbB8+XJs27YNMq0ZztV7QWl2w8xZs3D9+nXoTRZwRHJwRAqwBFII1WZIFSrUqFkL5jItbdW/5dpB7lEKHLEC5jKtwJcowOIJ4VCxI4K6LwVPrMCRI0fw9OlTyFUaWMq0gN4/ARUqV4NYrgJXogKDxbZJSTBZYHN4WL5iBQBbdTSLzUHYwC3w6zgHXD4fT548QV5eHipVrQ6BVAkmhw/3hkPhUrMvEitULnT9Bg0eAn1gWfCVJvi2mwZteHUw2FxwZVqITF5gC+UwxjaGVGNE46bNEFu6HNgcHhwqtIfcLQzVatYCk82DOrAC+CoLmFwB+BpHVKpUeJ3/JjMzE8OGDUNSUhLOnz+PN2/eICIqChyRHKEDNsKt3hBIlBrk5eWhcdPmYPFEEGgcoQ2tCm//wAI7EdHxcG+QisjUDGg9QsAViBA2aAs8G48EiyuAUKqAwjsOIX3Xgq80walqN0SkpENpdEb//v2h94tFRMpOmBOaok79hmjVujXYQhnkHqVssivhNRHUfRl4Mi22b9+OM2fOoFRMPHwCgjFjxgw0a9kavfv2w6JFiyGVKyFXqkv0t8Pk6AL/jnNtFS6ufgXVMv+hV5++4AnFYLA54Ihk0HqEwsXds0gzyy9JZmYmLly4gyI7+wABAABJREFUUFBlcu7cOah1BojlKvgHhX6wOcu6devA5PDgVmcgPBoNB08g+mi1iJ0vD9krqO3xtx07n5EVK1aAy+XC09MTV65c+dru2Pmb4OzuCa/m4xA+ZDsUBkccPHgQWVlZEAjF8G07DT6tJoHLF2Dz5s1/utL29u3bMJodwJMo4Fq7v61JXqmamDx5MmbPng0WTwBiMMAViIstU9i9Z0+ogyrCp/VkWMq2RafOXYuM6dCpC/T+8fBoNBxStb5QY/r/S1KHjrCUtsnfGSNrYvjw4YWO5+XlYe3atVi0aFGh2Grw4MGQmTwQ2G0pXGv1Q2zpsnBwdoVUpYXR4oibN2++c70DBw5g3bp1RSRAJkycCK1nGPzaz4bGLRht27aFo6snODwhBCIx1q1bh/v37yO2dCLUeiP69h+Ibdu2weAZisjUDPi0mghP34BiXcMvxcaNG9GqTTssXrykyL1jtVrx4sWLIj+fMnUqNK6B8Go+DipHbyxevPiDayR16AhTZHUE914DnlQFkVIHkUSOlSuLX4H/f+nYuSvMcbYmjoawyhgxYsQn27Lzz+ND8fdXD3Q/9WMPkO3Y+bI8ffoUUVFRYDKZWLp06dd2p1g8ffoUBw8efKdO2ftI6tARDhXa2xKwCc3Rv/+AgmNWqxUmByc4lGsLx8pdwBEr4FSlK8pVrPKn/MzNzcXevXuLSI7s2rULWhdfRKSkw6fVRLh6+gAAnjx5Ap5AiPBBWxHafyNYbE6JtpDm5uYioUxZMNlcyD0iweLbOmMLFRqMHDUKrh5e0LkFQCxXYeXKVZg3fz5kWhPMkdXBF4ohUelhCikPpUaH48ePIy0tDVOmTkXdhk0wc9YsWK1W3LhxA/GlE8FX6BA2aCssia3AF8vRt98AVKpcBTy5Ds7Ve4En10Ooc4VDuXa2oDmxFbhSNbyajkFE8g6oLe4FyckzZ84gqUNHDB6SjCNHjmDFihWYO3cunFw94N4gBcG9VkOq1uO3334rONcateuCJ1GCLZCCzRNg3rz52LdvH5QmF4QPSYNXszHgqx1giqqNRk2bF7pOXbv3gCm2ITTBFcEWSiEyuEMiU4DF5YPFFUAbVg1S50B4+PgDsHXnNnqFITI1A75tp0OuVEHhGozI1Ax4t5wAlkACbVh1sDkc5OXlYc+ePZg+fTouX7783t/VkOQUyCze4Ml1CBu4Be4Nh0IsVwMAdu/eDbOTK9h8EfRGM44ePQoAuHbtGhISy8IYUR0+radAJFODyxfApWYfGOObQKHSICquNJyr90JEyk6ILT6Qu0fArd5giGUKXLlyxdYFm80Fk80Bl8uH2cm1QMZE5h4BbVhVRKSkQ2T0gN5oKkgMP3nyBDKlGgqvaPCVBji7eSInJ+ed53b8+HEEhUbA3csXaWlphY5VqV4LhtCKcK7eExKZspAe47179yAQSxHafwMCuy4Gl8fH+vXrS/Q9/xI0aNQUDmXbICIlHXq/WMyZM+e9Y3NycsBksRDaf4NNbkUofqeUyedm//79GD16NPbu3fvF1/onYk9Q2+NvO3Y+N3v37oVSqYRarf5gks7O/w7+QaFwrt4LQT1WQKLUFsh4rV27DnKVBiyuAEonPyhNrug/cPCfWis5OQXGyJpwqdEbXKkGhqi6EMsUOHHiBBxc3MHiicDkCqH0jMQ333zzUXtWqxXBYRHgKQzgyrTgSxRYsmQJHjx4UGhcTEJZuDdIsT1PBScWSXparVacP38et27dwuAhNmmOoO5LoXEPwaxZsz7qx7p16yBRaKDyiQOLy4dQLMWuXbuQk5ODa9eufZK0TnZ2Nlq3aw9HVw8kdeiE3NxcADY5xv/EmA2bNIOpVC0EdFkIpckF69atg8nBCUb/WMi1JkyZMq3E634uMjIyIFXp4VipMxRGZyxa9P+veWZmJoLDIsHh8WEwO6JLl67YvXs3Nm7cCKVGB6FEBmc3T3Tp2h3ffPMN1qxZ896XIw8ePEBEVCwEIgnqN2qCY8eOfbTHy8f4/fffoTOYINMY4ejiVuR+svPvxp6gtmPHzifx6tUrlC9fHkSEadOK9w84KysLtes2gFypQfVadQu0xr40Z8+ehVylgdbJCxq9EdevXy/WvLS0NEiUWphiG0IsVxWp3Lxw4QJCwkuBJ1HBq9kYWOIaoU79Rl/gDIA3b97ALzAYWmdfiOUqLFy4CIDtmoqlcng0HAq3OgOhUGk+WmHx7NkzbN++HUuXLkX1WnURG18a6gCbtppz9V7gynTgqy3g8EXQuPgjMjUDnk1GwT84HNHxiQVBpjmsIvr06YN58+Zh7969kKs0MHpHQCJXFqpe9/EPgimmPnhKI3gKA9h8MVxq9oXWPQQJpRMhNbpB4RkNrlgJndEMkUILh/JJYAtlNi1rnhAcoQxmJ1fozY6oUbteQdXE999/D7FcCXNAHOQqDRxd3OHRaDjCBm6GXGvC4cOHcenSJXTo0AEcDhdsgQThg7fBv8McKNVajB49BlyRHEE9VsCpiq3ZXlhkFNLT0wslU/8TLDE5PDhV6wGnaj3A5otgiG0EgcYRkakZCO61ClK5EgDw8OFDKDU6GEvVhECuhVChA4snhEuN3pC5hUPhGQXPxiMhlSuxeMkSyDQGmCOqQqpQFVRW5ebm4uzZswUadnUbNoFj5a7QhlQGg8UBg83B/PnzsWXLFjDZtnMT6t3A5glRuVoNLFmyBGKZAiqLO8RyFXgiKSRaB3AFYjDYPIh0zrA4uSA9PR0sDg8ckRxciQoKjR6RsQkFWoLjxo0DRySHyr8spC4h4ImkUHpFwb3hULAFEjBYHHDESgg0jtC5BWL79u0AbNrKUo0JfKUJHg2HQmz2xoiRo955T1qcXOBcrQc8m4yCSCIr1Dzz2bNnSOrYCZWq1SzyHXzy5An4IjECuiyEd4vxkClUfwstvxat2sAcXQ/hg7ZC4xaMkLBwlK9UtaA56f+lW8/ekGkMUOgdirwc+Rzs378fMQmJqFClGi5fvow9e/ZAIlfBHFMfEoW6iO61nQ8HyPaPPf62Y+dTuXTpEtzd3cHj8bB69eqv7Y6d/2LmrFlQafVw8/LF8ePH/5I1jx07BouzKwQiCYYOL1wp+tNPP0Hn4ofI1Az4d5wLo4Pzn1pr/Pjx0PlEI7Tfesid/FG6dBn89ttvOHHiBIRyDcIGbYF3ywlg80XYuXPnR+117d4TTA4f4UO2I7TfejCYLAhEYvBFkkI7OlesWGl7ngoqDZVWjzt37hQcs1qtqNegMfgSBdg8Adq1S0LVGrWh1OjQpHnL9xY2/DeVqtUsqAg3hlXGsGHDPu0CvYedO3eiUdMWiC+dCIPFEVVr1EZmZiZKl6sI11r9bJW+ftFYtmwZHj9+jBUrVpTo5f/t27cxf/78ghj31atXBQnxTyU1NRWmP6qQnSp3QbOWrQuOjRs3DvqAMohISYc2rBrEFtuzJU8ghE+bKfBpNRECkQQKtRamyOpQOXhg4ODkP+VPSXnz5g0uXbpk1+3/H8SeoLZjx84n8/btW9SpUwdEhGHDhn00MTR+/HhovUshqOcK6HxjMGrUX9NRt0OnLjD/sV3MVKo2UlJTiz139+7dGD58OPbt2/fO4/n5+WjTrj0EIgkCgsO+aLftrKws/PDDDzh79mwRHz19A+AbGPJRiZHHjx/DaHGExsUPTA4fztV6QOufAI5QCs/GIyB1DgKLJ4R/hznQhVYCTyiGT+vJMEXVQflKVSGSKiCx+MKlZh+IZCocOnQIADBs2DAYo+oUSHW0bN0WgK2Cl8VmI6TvOoQN3GJ7Wx9SAZGpGXCrNwQJZSuidt0GUGp0qNegMbKysrBx40Z06twV9Rs0BJvDhVgqQ7t27aBy9IJ/p3lQuoYgMDgUs2fPQa26DeBcrYftdxtRDR06dIBYKgOXJ0CLVm0QE18aTBYHLL7YJq3B4cO/0zy41RkIJlcAnlAMgdYJDBYHErkKEyZMgEgqh9LojLBS0QWN9Pbu3Yvk5GTwBSL4d5iNkL7rwOYLbddOrIAxpiHkHpHg8EVYuMj28uDq1asYPXo0WGwOQvuth0fj4eAKZRCIJGDxxWALJIgoFQOfgGC41RtsS/qHV8KcOXPw/PlzKLUGMDk8cARipKWlYffu3ZDIlTD6RYPNE8DRxR2LFy+Gm5cvPBuPRPiQNAg0jiBiwBBaGUqtAZ6NRyAiJR1ykysUFg9EpKTDu8U48FVmRKZmQO8Rgq1bt+L06dNo2qwF+vbrX5AQf/jwIdavX4+BAweCLZAiIiUdYQO3gIiBMmXLo1RsaQSHhYMjkoPJFUAdXAkSpbagE/nLly8hkcmh/aOBo3O1Hqhdr+E770seX4DgXqsQPmQ7xHIVrl27Vuzvxdx58yAQiiFXqj/4QPX69WscPXr0L3kxdvv2bfj4B4HJYkGiUMMUXRdOVbtBplS/U3rEarXi6NGjOHjw4GdPsL98+RJSuRIutfrCoWxruHn6oHfvPoWkdd61Jfd/HXuC2h5/27HzpXj8+DHi4+NBRBgxYsTf4sXqv5k3b95g+IiRSOrQsSBG+b9cvXoVIqkC/h3nwrl6Tzi5evzFXhbl1q1bkMiUcKnRG8awyqhYpdqfsvf69WtUrFIdAqEYZcpVLCj2OH/+PMQKNYJ7r4ZbvSHQGswftXXv3j3w/4hn3RukwLlaD7C4fPglzUDogI0QyZSFpGwOHz6M5cuX4969e4XsXLp0CTyRDOGDtiKg03wwObx3NoN++fIlduzY8c5jAwcNgdYrAu4NUiDTGPHDDz+U9NK8l0OHDkGiUEMTVBECtQP8O82D2jcBUoUa/fv3txWCmN2g0urhHRCMNkkdPijTZrVa8d1332Hr1q3IycnB3bt3odLqYQopB5nGiICgEJtcIZePefPmvdfG48ePP9i8cO/evRDLVTDFN4VUrS/UwLtQgjq8OvSRtWGIrgcWm4OQvusQ0udbsDlcGLzCbTtB20yF+x87RO3Y+dLYE9R27Nj5U+Tm5qJVq1YgIvTo0QP5+fnvHdt/wECYouvakomxDdGzV++/xMfUocOg84tDYLel0HqEYsaMGX/Juv+XLVu2IDahLJq3alOszs4f4tmzZ9i1axdu3LhRonnLly+H0T8Onk1GQWzxRWRqBvzazYBKZ4TRwQViuQpiowd8206DyuKBVq1awdXTBxWrVMPIkSNhDKkAc+nmEJu9ERYZVWB34cKFUDl6w7fddOi8S2H4iJFYtmw5RDIFhEo9uGIFdF7h8PENgESmgDa4EjgiObx8/d+rFXz79m2cOXMG+fn5mDhxIoxhleHfYQ5YfDEsZdtC5egNLx9/yFyC4d1iHGR6R2zevBnZ2dl48uQJOnbsCIVzACKSd8CS2BoKr2gQiw0mmwee0ghTQjMweSLIXENhKdcWHJ4Qbl5+8Go2xha0Ofviu+++w549eyCWq6CPrAmeSAo2lweeQIievfuieq260BnMYHH5UAdVgG+76eALRYW07FzcveBYri1ca/eHWCqHTG1AZGoGQvtvAJsnhFBlgMTBD661B0Ci1GL58uVo27YtxGZvBPdaBXVA2YKqmQsXLsDN0wuawHLgiBRgMNkQy9UwlW4Bv6SZYIvkkHtEwrX2AKj0ZljiGsGv/WyIFWqI5Cr4tZ8Fc0Iz8FUm+LSeDKlKVyAH8t/s3LkTYokMGrdAiKS2qhZjbGOoAsuDLZKDwWRCb7JAIJEhfPA2BPVYDiabi/nzFxSy8/PPP4MvFEMfWAYShRqLFi1CZEwcjA7OmDp1esG4uvUbgC2UgifTQmuwIDc3FydPnkTTFq3Qq0/fItqAJeXQoUPgCmzyNWyeoEgl9peiT7/+YDDZYPGEcKufDKlS+5drj169ehUShQYRyTsQ2m89OFwe1q1bB7nOAc7Ve0FhdMby5cv/Up/+CdgT1Pb4246dL8nbt2/RvHlzEBGaN29e8ELczuenUdPm0PlEw5LYClKFCvfv3y8y5vjx45CqjQgfkga/pBlgcQX4/vvvP2g3KysLu3fvxvnz5z+rv1arFfv27UNGRga+//57VKhSHa3bJuHJkyefdZ3/JnXocHC4XKh1Bhw4cOCj4x8+fAiBSALXOgMh1DqDI5BApdXDs+loBPVcAaFE9l7d5//mzp07YHH58O8wB251B4MjkBRKpgLAixcv4OLuCb1HMCQKNZYtKxyzZGdno2+/AYhLLI/5CxZg06ZNGD9+PC5fvgyr1frJL4CWL18BvdkRArUZpoRmUPmXsVUkV+kKmWsoRFIFDh48iPHjx0NhcIJ3i/HQ+Uajb/+B77XZNqkDVGZXaF38EFemLCZPngxTYIJtt2rjkWALpQgbuBnu9ZPBEYiLVFJnZmbCPygUfKEYDs6uH7zGP//8M4YMGVJEOi8zMxNBoRFgc3lg80UwJTSDVKVDg0aNIZIqIJTK0a17T4hlCjhW6gydbwyat2rzSdfQjp2SYk9Q27Fj50+Tn5+Pnj17gojQqlWrgn+mv/zyC0aMGIFdu3YBsCVKNHojNA7uUGsNH9Tb/Zy8evUKNWrXg0qrR+NmLb7KdqELFy5ALFPCrd4QGEMroVbdBh8cf+rUKZQpVxFlylUsUu1x79496I0W6N0DIZEp8dNPPxXLh6lTp8PZzRN8mdoWBPHF0AQkQmV2w6A/tm69fv0aTZu3gpunL/yDQsBgMGG0OOLs2bPYsGED5HpH6CNqQeboiy7deiCpQyeo9SaweUIQkwWhRIbIqGg8ffoUTq4e8Gk1Ca51BoInUaJUVBQSK1SCyeIIsd4Z7g1SoPOPx4gRI4v4OmfuXAjFMkiUWjRs0gy3b9+GzmCGVGOC0icekakZ8Gg4DGy+GEqfOPA1DhCIpIiOT8TgISlo0rwlJGoTxGZvhA9JgymhOfgqM7gyHbhSDcIHb4Nr7QFg8UTgKYzQhFQGX6aB2dEFltIt4N9xLoQyFY4cOYJu3btDE1QBbIEUPIUBIqkCEdFxiCgVgzbtkhCbkAgGk4Wg7ksR2m89+EJb85S4MuVQv2ETHDhwAGUrVoazuzcUKg04fCHMCU1hCK0IJpuDoF6rYYxvCq5IDoFQBIXeArFECpV/YoEWt8XJteDaGC1OkDoHw6F8e4QN3g6uRAm2QGKrtuYLoXL0hlAix4oVKxAdXwYavQmt27TF2G/GwWBxQlBYJGLiy8DFwxszZs4scu3Hjh0LFk8ItkgOJk8Ic2JrePsFgs0Xga+ygCvTILT/RjhV6gw2XwzvlhPhUrMvVFoDXr16VciW1WrFhAkTUCaxLObOnYv4MuVgKd0c3q0mQSRXF9zbbl6+cKrcBV4txkFpdEZaWhpkSjUcyrWFIbgcyleqWqx7/H0EBodCqLNpjbvU6gt3b78/Za84XL16FSKZEqH91sOn9WSweEIEh0V+sOLlU8jPz/9gtU5+fj6iYhOgcwuEyuyGdu07AgAWL16Ceg2bYP78BfbqvXdgT1Db4287dr40VqsVI0aMABEhPj4ejx8//tou/Sv572bLevdA7N69u8iY/Px8uHv5giNRgS2QQOVX5oNJuTdv3sA3MBhaZx+I5SosWbL0s/nbrEULsAVisHhCuHv7fLD453NS0lhg4qTJ4HB5EIok2Lx5M3bt2gWZQgUOl4dvxk8olo1OXbqBzReByeaBxRdDqlAWqbLesmUL9H80H/RqOga+gYX/1/y339+MGw+l0RmmyBoQiqXg8QSQyBQF8nPF5eLFixDLVfBq/g30UXXBUxrB4gog0DiCJZDAu9VEqEwuOHjwIKZMmQJTeJU/pBJ7okbteu+0abVabbsq+2+Ef8c5YHJ4EIjlYAvEcKs7GBqfGLD44oIENYsnKiR5BwATJkwoqH42x9RDh05dsGPHDmzevLlYcij/7UtmZiaWL1+Odu07YOvWrQCA69evFxQ/7d27Fw0aN8PAwUPszbvt/GXYE9R27Nj5LFitVgwfPhxEhNq1a2PPnj3QiEToLJXCKBZj8+bNAGxvwY8ePfrVm5j91aSlpf3/zs6tJ793q9SLFy/QrGVrcPhCOFbuDKcqXaHS6gsltaZPnw5DULkC2YTqteoWsrFx40Z07NwVmzZtKvjZ7t27Idea4dV8HKQmDyg0BlSqWgNjx47Fxo0biwSlGRkZUJndEDZwM5wqdURCYnk8fPgQQrEMmqAKEGkdULZ8BWjcguDfYY5Nm1iuh8w1FFrvUoiOK42wyGhoQyqDI1HBuXovCLVOUHhGQeYWDl14dVslfXRd9OnbD1arFZcvX8bdu3cBAHKVBv4d5yJ80FZIlFpcuHABz549w9KlSyGSymGKbwqFyRU8oU1TOqj7UjDZHLjXT4HaJQBsHh9BPVZA7h5h08QTS2GwOICrMILB4YPB5oHB4UMdWAFezb8BWyABT2EAX2UCV6oBkyuAQKlDk2bNbI0QBRK41OyDiJR0SJ0CoQ2tCrlHJNhCOWRu4TCXaQUmhweuQIQOnbpALFNAX6oOJCZPBIaE4ezZsxDLVfBLmgljtO1lSeUqVeHp4wdTqZpwKJ8EnlAMc4JNikbjGwe+SAquVAM2T4DvvvsOVqsVc+fOQ2hEKXCEUjiUT4J/p/k2Xe0/tkayuXzIdBaIpArMmj0b27Ztg1imhN49CBYnl49W3+Tm5oLDE8Cz8Uh4NhkFJocPntKMipWrQihVQGTyBF9lRviQNLjVGQhXTx/IlFqwBRJIdY7w9gso9AJo+oyZUJhcYElsDbFcBQcXD5hKt7Q14uHwUa5CpT+a7ETCuWo3BPVYDqlKh5UrV0Lj4IHI1AwE9VgOhUpbvC/aHxw9ehTLly8v0DmMjIoBX2VG2MDNcKjYEb4BwSWy9ylcv34dIqkCIX2+hXeL8ZAqVJ9dXuTIkSNQqrVgc7ho2rzlex9i3759i40bNyI9Pd2ejC4m9gS1Pf62Y+evYvXq1eByuXBzc8PFixe/tjv/OpI6dILGLRDGqDpQanTvfRHw7bffQqoxwalaD6id/TBp8pT32szIyIDO1f8P6bTxBU2yP4W1a9eiToNGmDRpCvLz88HiCeFcrQf8O8wBk/vX7fr6FPLy8grFHj///DN8AoLhHxyGX375peDnr169wpo1a5CRkVEQh/yn0XvogI0I6fMtmCz2OyXefvvtN0hVWni3nABTVK2C556srCxUqloDLBYbwWGRePDgAYLDo+DVbIytkbdrKBhMNpgcHvhCcYninz179kDr7IOIlHT4tpkKhUaP1atXo0fPnhDJFFA7uCMyOg45OTm4fv26Ta/ZPwZimbKgh8u7cHRxg2OFJEgcA2Au08omw+fgDQ+fAHTp1gNObh5gMFlgcniIjUsoMn/SpEnQ+cUhImUnTKVqwcPbD2oHD2hc/JBYvtLfMsbLzs7+05radv53+FD8zSY7duzYKSYMBoNSU1NJLpdTjx496MSJE1SPwaTBYikZX7+inZs2Ua1atUgikVBoaOjXdvcvJyYmhhhvHtOtLWPozYOrNLhvr3eO69WnH+06dpXycnNIG1yJiMGgO7sX0uvXr0kqlRIR0eXLl+nZzXOkun+Vnl89RpooLyIiunnzJlWuVoOuXLtJ+qh6tHpdF2IwGFSrVi26du0aiUweJHMOpLxS9cj0/DdKT9taZP1r167RL7/8Qs+fPycGm0PXds6kzIsH6ZlYTHv27CG5xYMsNXrTqzsX6aeVg0kbUpmEOmcSGdzp1c0zFNhtMRFAv35Ti/b+/BPVa9CQlF7RpA2uSAwGg55dOUpckZIen/6Rnl/YR3KJhLqtnkTNW7ambWk7KT8vhyZPHE8cLpeyHt0kIqL8nGxaunwFTZk8mcRSGXVMakvzFiyivLxc8vb2ocuLulDWqxfEkajpyqZviMnmkEgkpkeHN5HcLYysj3+nm9d+JyIilUZHDAaTACsxiEFSlyCSOQeRUO9Gbx5eI58W40mgcaCzi3qSyi+BNm1dR5qQKvTs/C/0+t7vJHHwp+wXj4mvspAurDq9vHmWBBpHMsU1ouzMB6TJuUWR4aG0et0menbxIKn8ytCZw1to9erVxBMrSKh3obdP79KDo2l06s4ren73HkVbLCSVvyZmjRq0/8oTyn2dSYycVzRp/FiKiYkhJycnkslkNHPWLEoeOZ44Bi9iwkpPD2+guz8tI2Iw6e3Tu5T15BYRk0We7edT5uXD1LvfQMrNziKOVEtc5wjKvXOGduzYQc2bNy/0Oz9//jylpaWRv78/xcfHkzU/j8QWHyIiQn4uWbOek7Ojhc4+jaXn929Qbl4mHZvYkMiaRz98n0E1atchIqK3b9/SpStPqF6DRrR+7Rri8XiUsWs3KSPqk9q/DOHNU4pzldC3G9aTe4OhJDZ70pGFnenkyZM0afxYqlGnPt3es5Rq16hKtWrVov6DhtDNHdMoL/MuVa1WlYiIzpw5Q7/++ivFxMSQl5fXO79D69evp7Ydu5DUwZey+vSjk8eO0srlSyk0MoqOflOHhBIZbd//c4m+v5+Co6Mj9e7Zg8aObUFcHp/WfbuahELhZ12jU7eeJI9uRi6+8ZSxvDf99NNPlJiYWGQcj8ejOnXqfNa17dixY8fO56Fx48bk4OBAtWrVoqioKNq8eTPFx8d/bbf+NcyeOZ1CFy2iO3fvUquVE0ilUhU6/uDBA1qxYgXJ5XIaOrAvbduZQaVb1qce3bu916bBYKA3T+/TqzsX6OW1Y+RhNhXbn7dv39LatWuJiEij0VBS5x6kim5EP0+fR0RETAaDRAZ34qstxOLwicVifcJZ/zX8t2+5ublUvWZt0pbrRGTNpyrVatCTRw8oLy+PImPi6Ek2m3JePqaWjerS5IkTiM/nE5PJoqwH1yg/5y2JJRJydHQsskZISAiNGz2Cps6YTQEuzrRw3mwiIlq6dCkd+/0+BffbQPd+XESDhiSTkM+lm4c2UPaz+/Ty1lnybDaGOCIZnZnXhQAQg8Eo1nmVKlWK1GIu3VgzgLKe3afRw1OpcePG1LhxY2qflESPHj2iqKgo4nA45OjoSGdPnaADBw6Qp6cnrduwkcZOmEL169Sgzp06FbKbsWM7derWg7Jyn5E16zlZc7Mpzwq6f/cWVa1ckaZPnUzbt28nFotFlStXLuJX+/btad3GLXR0bE1ycfegKxcvUMiAjcRkcejg1Mb04MED0uv1JfkVflEmTZ5CgwYNIhabTUsWLaJGjRp+bZfs/JN5X+b67/6xV3DYsfN1WbZsGZhMJrhMJlKlUnhLpVi4YMHHJ/7LefToEZYuXYo9e/a8d0x0fCLcG6RC6RMPodYJcrMHqlSvVWhMeFQclL4J4KstECh0qFOnDmbMmIHImDhIzD6wlG2LyNQMWMq2RbfuPQDYZEG0ehOMvlGQKFQFFe3Pnz9Hz159UL9RU6xZswZShQrm4DIQy5RwdHKByOiB4N6roQ+pgFat20AsU8CpSlcoPKMgd48Ak8OD0skXDBYHTA4PxtiGMETVBYsnhFSuxLJlyyCWKWCKrgOeRAmeWA6xyQtezcdBafHAggULcPHiRUgUGoQP2gr/jnMhksggEEvBESvB5PJRvWYtCKVyBPVYAY9Gw8Hmi+BePxn+neZBIJIiIyMDU6dOBVsgQWi/9XBvOBQagxkylRYMJguVqlTHmzdvYHFyhcjkCZ5cD0NMQ+giaoLJFUBs8QVLIIFQ7wqldywcK3UCiyeEyskHCo0BTlW6QelfBnyVGRyxAgKtE/gaR3BEchCTBa5EDb7KDCaHB0NUPYhlCogVqoLmjfpStcHmCaHQ6KEwOIHLE0AfWhmRqRlwqdG7oBLk8ePHiI4rDaFYgnoNGhfZqhdfpixYfDEUntFg8UTo2bMnrl27hkpVqkIgkkJnNEMgksC75USIDO4wRNVDSN91EOqcIdA4gieWF7n3Ll26BIlcCVOpmpBrzZg4aRL0JgewBBJbVblcB63ehF9//RVimQLEYCB8SBqCeqyAUCLH3bt3odQaoQ2rBr7KBM+mo6F0C8WgITbJmP9UUJsTW0EsV+Hw4cNwdHGHe/1khPT5FhKFBmfPnkWFytVgiqwJp2o9wRaIbfIjM2Zi5MiRiCgVBRcPb7Ro2RoimQKWsIqQyJTv1M4GgDLlK8Ot7iBbhX5oecydO7fgWEkqOPLy8jBs+AiUKV8ZM2fNKva8/8vbt29LJOuxf/9+LFy4sFgNV0Mjo+Faqx/CB2+Dyuz2WRsD/a9D9gpqe/xtx85fzJUrV+Dp6QkOh2PvDfAX8fr1a7gYjWgok6OUTI7WjRsXe+7sOXPg5OaJhLIVit0k3Wq1IiGxPHQeodB5hMLF1b2gP49z9V6oXa8hRowYCTZPCK5YgYiomL9E4uPs2bNYtGhRkUbsxcFqtWLr1q2YOnUqODw+wgZtQdjAzWBzuHjz5g2OHTsGpcEJESnpCOy2FHKlpmDupk2boDdZYHJwxq5du5Cbm4tGTZtDIBQjrFQMHjx4UGit+/fvY//+/Xjx4gUmT54MQ1AiIlLSYSndHDKlBvqA0hBpzNCbnWwyej1XwK/9bHD5ghJXF79+/Ro7d+7E8ePHiz1nzDfjoHENhHv9ZMj1Du+VFrl79y58A4NBDAakzsHwajoaIom02PFiVlYW8vPzYbQ4wrFCezhX7wW5Ul1Iy/7ly5c4efJkEfm9v4onT56ALxQhqMcK+LWfBaFY+res8Lbz9+JD8TfzayfI7dix88+kRYsWtGHDBrIymTSDwaDWQ4ZQm7Ztv7ZbXx21Wk0tW7akMmXKvHdMlw7t6P6uOcRn5hMn5wVNHTWYtm5aX2iMj7cn8ThsMkbXp7cvntLWtHTqP2ICHT1ylCTOwfTgyFa6s+9bevrbVqpQvhwREen1ejp7+gTNGNGXftn7E9WqVYuIiBo3a0lrfzxBh59JqGXrNiT2SSRT9QGkjKxPbDaL+AoDccVK4shNlJtnpR3bttC9n1cQWygl5+q9iM8X0LDeHejKpQt05uRxcuc+oecXfyH/jnNJFdeSlqxYTXt/3E3dakTQ1vWrKS4mipTesSRzDiSBYzBdu36dRCIR5efmUHbmA8p6fItYLCapAspRUI/lJHMNp1+PHiNrvpXYAjFxxAqy5uUSX20hnlxHLC6XnJ2daev2HUQMJjFYbGKyufT61WvK48lJE1yZjpy+SDNnzqRHmS/Jt81U8mr+DT0+8T1Zc7OJySDisBjEIiuF+7iQnv2Ccs+mU1xMKerfuRVVKFeGbu2aT8+vHKWc54+IiEHZzx+SNrA8Kf3KEIcvJmv2K8rOvE9skYJe3j5HPJmWGtevSw8PbaT7v26hJ2d+Itd6yZSTZ6Vp40bQrJnTKfvOWcr8/Td6dekAeXt5EBGRSqWiA3t/pNcvX9D6tauJw+EU/M5fvnxJd+7cIXNCMzLFNyGe0kjbtm+nqjVq08kH+STziiGpVEr169Wly2uHUXbmfeIpDMQWSIgrUZPKP5F4HHaRey89PZ2kruFkrtCJNAmtaMq0mWTVeJFno+HEVxooMSqEfjtyiCIiIujQgX1ksjjSrfQZ9OjwZlKplKTRaKhKpQr0+s4FkjgGkNw1lGTe8XT23AUiIurapTNN/2Y41fGXU9qWjRQeHk6rli+hJz/Op1PTW1DXzh3Jx8eHzp0/T3L/svT07E+kDa1G3MiWNCg5lX6/doNuvuGSIK4jbdq5mwSOIaRNTCK+SzitWrX6nd8hPx8venVxP2VePkyvbp4lT09Pmjp1OoVHxVGPXn3o7du3xfq+TpkyjWYuW0+35aGUMnIcbdmypVjziIguXrxIM2bMoJ9//pl4PF6xq5+WLl1GVWrVo2GzvqWA4FC6ffv2B8fPnDqJnuxdQicnNaQyMeEf/Ntix44dO3b+3ri6utLBgwcpNjaWWrRoQampqWR7Xrfzpbhw4QJx37yhSSIxTefzKW3Hjo/OAUAPHz6kdm3b0rXLF+inH74js9lcrPVevnxJvxzYR44NRpBjgxF088Z1en52D93+YQE9Ofgt1a9Ti1JSkun3S+fpyIGf6OD+vcRkfv60zLNnz6hpi1YUGZNAI0eOpMjoWBo6ey1FRsfSoUOHSmRr4OBkatOlD41fupW4fCH9vrQH/b60B7Vo2YoEAgGZzWbKefOcnpz5iZ6cSCc3D4+CuaVLl6YpE8fTujUrqVy5crRmzRrafegkeXdeRPdITYOGpBSMPXToELl7+VCd5knk5etPVapUIWnOQ7owuyW9ObeL8gFyqDmAvNtMpycP79L4cePo7Ox2dHlFX1q6eHGxq6f/g1AopMqVK1NQUFCx5xw/cYrEXgmk9I4lkXMYnT59moiIrly5QuvXr6dbt24Rka0C/5e9PxGHwyP3eoNJqHel7LdvKT8/v1jr2KrPmfTDd+nkRrfI9PIUfZ+xk3g8HhERXb16lVzcPSmxSi1y8/CmmzdvftRmfn4+LVmyhIYPH06///57sc/5fVitViJiEIPFIgaLTbBa/7RNO//jvC9z/Xf/2Cs47Nj5e/DDDz9AJBLB1dX1nZpi/6vk5eVh3bp1WLZs2Ts1aX/77TesWbOmSNXAf3jx4gVatG4LB2dXCNRmOFbujMjUDKj8SoMnEEGmc4BGZyiokv4QOqMFAV0WIjI1A1KNCXKjC7yajoHGLQhimQJcmfaP6mA+1q9fDwBYtmw5BCIx+EIxpAoVBGIZ5GotwqNi0aNHT6gdPBHabz0sZZqjWs06hdY7cOAAxDIFzEEJkMiVOH36NABbFYpMoYLJwRnjx48HVyAGV66HUOcKlxq9wRPJwBMIweRwIVCZwOTywRFI0LRFKxw7dgwyja3RIZPDB5PNBZvDgzmxNTQhlcGTqjB9+nSwuHy41RkIQ3R9MLl8sLhCsPkilC6TiM2bN6NR0+bQeEXBoVw7cHhCVKhcFTrfWGhCq4HJEcCU0AJChR58qQo+baZA5hYGjd6E9PR0iKRyOFbuArd6g8Fkc3Hp0iV4+/qBxRdBF14D/h3ngskVFFT9tm7bDmy+rQFO9Vp1P1gdk5eXh4DgMAjVFogM7mDxxTAlNIPI6A4mh4uIlHREpKSDyebC4uQKr+bfwKlaTzA5fLCFUvDkOmg8w9GgcdNCdi9dugS5Ug0WXwzn6r0gNnuBxRPAFN/0j/upDMIjIgvNefz4Mfr1H4DuPXvh9u3bAIBnz54hrnQZsDg8qL2iIJarsGPHjg/ed1artdA5165b74/GRFL4tZuBiJR0qB08EFc6Ec5VuyMyNQO64AoQyNRgC6TgKwyQKdXv7F7++vVrtO/YGRHR8Zgzdy7S0tKg0DvAs8ko6LxLYeCgIR/07T80atYCTpW72CqxY+pj5MjCzTzT0tLg5uWLgOAw/PbbbwU/v3DhAiRyJcwRVSFV67Fq1epirQcAMQll4d4g1bZmcCIWL178znFnz55FUoeOGJKcgmfPniEzM7PYa9gpHmSvoLbH33bsfCWys7PRunVrEBEaN26MrKysr+3Sv5anT59CK5NhsFSG+jI5qpQu88Hxr1+/RkRULAQiKbR6E86fP1+i9fLz82E0O8AhsRUcElvCaHHEkSNHMHbsWHz//fd/5lRKRL0GjWEIrQiPhsPAE0mhC69ha8xdpiW69+hZbDv5+fkwOjgXNKHUOvti+vTpOHDgQKFq2d27dyMmIRE169QvqDbPzMyExckFRr9oyDQGTJs2AzNnzoQhIAERKelwrNAedRv8/4r22vUaFDzzGEPKY9q0acjNzcW1a9fw9OlTqHUGWMq0hDGiOkIjogD8f/3je/fuYezYsZg7d26JmgmWlLS0NEgUapjDKxc85+zfv9/27BMQB6lCVeie6dWnL0QyJURSBVJShwGwxf2jx36DWvUaYOPGjZ/kR89evWGKbWCLJ6PqYMDAQR+d06NXb6idfWGMqg2FWvve59CSMGLUaHD5AvAFIixZuvRP27Pz7+dD8fdXD3Q/9WMPkO3Y+ftw8OBBKBQKGI3GT9o29m8jIyMD/oEhUDp4Qe8VjpDwUgWJupcvX+LSpUvFliHYv38/eCIpVH6lEdB5ASQGF4wfPx67du0q9sNMh05dbMFIWCXojWYkp6QiNDIGvfv2g6unD1xq9YNX0zEQyZW4cOFCwbynT5+iQ8dOMJaqaUsmBpSF0q80JEotQsJsjQmFEjl27dpVZM2LFy9izZo1731p4RcYAkNkTZjim4IjUiB8yHaYwyohOTkZfJEEESnpCOqxHAwGE2/fvsWlS5cglqkQ2G0JHKt0hYOzG2QaEyJTMxDSdy1YbC4WLlwIqd4RXLkeLL4YQoMHtGHVofIvC7ZQBonaALFcBf8OsxGZmgGx2RtcgQi+bafBUrZtQeDuUrMP3H384ejmCa5ADGNweQglMjC5fLAFEpgSmoMvlqJx0+YQqgxgcPhgC2XgiBWQ6J2xePFirFu3DmyeEF5NxyB88DZwJCpExcbB2d0LyalDi2x/u3nzJkQyJTQhVcBgcSBx8C9otsnii6EKKAt1UAVwhFJ4+gaAI1GBpzDYEtRcHiKjYjBmzNgi90S79h1gTmgKh4odwRZIwRZIwVNZwOIJwZVpwZXrIJQqUbVGbdy/f/+j99LNmzexatUqnDx5shh3XmH27NkDkVwFqUsImDwBuFIVDCYH7Ny5E2KZAgavMKi1evgHBsOU0Mz2cBJRA8OGDfuo7cmTJ8MUUbWIpMrH2LlzJ8RyFczhVSCRKXHixImCY5mZmRCKpfBsMgrO1XvBaHEsODZ16lSYIqohMjUDrrX7o/L/kej5EJ26dIPOLxbu9ZMhVekKNRj6D0+fPoVcpYGldHPo/eOLvAT63OTn52P9+vWYP39+kW7y/2bsCWp7/G3HztfEarVizJgxICLExMTg4cOHX3zN69evo1WjRmhat26hmO/fzsmTJ9GmSRP07dHjo//nFi1aBL13JCJSdsKxXFvUrtcQBw4cQHJyMrZt21as9S5duoQ69RuhTv1GOHPmDC5cuIA3b958hjMpPj4BIfBuMQ6RqRlQuwVDojbBo9FwqBy8MH/+/I/Oz8vLQ/1GTcBksiCUyqH1i4dLjd6QyJTFljvZvn079P9pIN9qIjx9A/Ds2TO4e/lAoTNDrtIUir06dekGQ0gFBHRZCLWTN9asWVPI3oULF9C8VRt06tKt0Pfl8ePH0BlN0IdWgtY9pEjBxufg7du3mD17NiZMmIDvv/8ec+bMKfgOtWzdFg4V2v8h+1cHfIEQffr1L4j3r1y5gqtXrxbYGjZ8BDSuAXCu3gsSpRb79+8vsT8jRoyEzi8OIb3XQOcTjXHjxn10jouHN/ySZthibO9w7Ny5s8TrvouXL1/+5fe3nX8u9gS1HTt2vjinTp2CXq+HSqXCkSNHvrY7X43169dDotSBmCyEDdiEiJSdECvUuH79On777TfIlWpI1Xr4B4Xi5cuXRea/q8p27tx5UOvNEMuV6Ni5a4l16vLy8rBixQpMnDgRd+/eLXTs4MGD0BpM4PL4GD5yVMHPR44eA5FECqlcBX1IRUQk74DSJx7mMq2g94kBTyiGV/NxcKyQBJ+A4BL5k5+fDwaTifDB2xCRkg4WTwS5RymwODwsX74cji5uMEXVhjG8KvwCQwrmjRs/AWKpDGZHZ3To2AlSpRoqjzBoXINQt0EjzJkzB4aAeESkpENs9gZfaYJb3cFgsDgI7b8BYQO3gM3lQ6hzgS68BtgiOfgiCVQOnlD7xILFFcBcujm4Mi00Oj2GDx8OU1RtRKZmQKBxhEOF9gjsthRsoQyhEZHg8EVgcvjgSjXQhtcET2mCSKaEQq2FzjMcLJ4I2tCqCOnzLVgCCfhKI3zbTYfS5IqtW7cWuiZv374FXyACX2WGX9JMsHhCGOOaQGRwh0ShgtQpCNqwapCodOjZsyfkLsEQaJ3gWmcAgrovg1imxKVLl4pc6569+8AQWgl8lRlOVbrAs+loMNhcsDg8aL2jwBbKoYuoCVNUHYRFRiEgJByR0XGflIAuDnPmzoW3XyC4QimcqnaD2tkPI0aOwtWrV7Fjxw48fvwYg4ckQ++fgKAey6HxCMWsYmhD//7775CrNDAHlYZEoUZaWlqxfTp8+DBmz56Nc+fOFfr5jRs3IJIpET5kO0J6rwGHyys4tmfPHkhVerjWGQCtewhShw4r9npv3rxB1+49EVemPJYvX/HOMYcOHYLW0RORqRkI6r4UKq2+2PY/hfadOkPt6AWDfzzcPL3/Zyr57Alqe/xtx87fgXXr1oHP58PFxaXE1bolxdvJCd1lcgyUyWHWaErUt+F/hWXLlkHrHmwrnkhognIVK0MsU8IU1xgyjQkrVqwstq1bt27BaHaAQmeG3mjB9evXv6DnhZk5axZkagOMfrEwWhwxaPAQRMcnYsTIUcV6lti4cSM0zj4IG7QFDokt4eDijoioWIRGRqFO/UbFSlKfPXsWYrkKHg2HwRheFTVq1wNgq3o+d+4cXrx4UWj8s2fPULFKNeiMFnTq0q1Yfp44cQJShQpsvhhikxcCui6CVK786LySUrVGbWg9w6EPKge+SAoWm4PadRsgJycHo8eMhdYjDN4tJ0CgdYJD+SQojc747rvv3mmrQpXqcKszEJGpGdAElodKo8PevXtL5M+rV69QsUo1iKVyVK1Ru1gJ4uat2kDnXQoO5dpBIle+c5fi34E3b94UuTfs/HuwJ6jt2LHzQYYNGQIBhwNHnQ6HDx/+ZDtXrlyBk5MTxGIxfvzxx8/n4D+Ips1bwalKVwh1LjDGNoJj5c5QqDR4/fo1qtSoBafKnRGRkg69TxQWLVpUMO/WrVvw9PEHg8lElWo1kZ2d/dXO4cyZM5AoNAjqvhQOFTtAKFGAwWCCIxDD4B8PqUIJmdaEiOQdCOi8AEq1tsRrlK9UFTqvCKh9YsDkCsDkicDkCsDm8vHdd9+hW4+e6N2n7zuriTp37Q6tRygcyieBL5Rg+PDhePr0KZ49ewZPHz/ItSZIFUo4urja5EA4PLjXT4Zn4xEQiqVwdHaFSKGFRKnB8BGjsHr1anzzzTcQSWWQe0bBpWZfqMyuCAoNB0ckhza8BjgiOTybjkZE8g7IjS5o1LgxtCGVbFsdQ6tAH1UPDCYLHB4fUqdARKZmwKPRcLAEUjBYbDB5IkidgxGZmgFDUFn06dMH/sFh8PQNwMqVK+HtHwQmmwuewoDw5J0wxjeDSCJHgwYNcfHiRQSHl4JaZ8DI0WOQkZEBud4BXKkGPq0nI3zwNvCkKmzYsAFWqxVXr15F0xat0LRFKxw/fhylYuLBYLER1HMFwoekgSNSQKU1QKpQgytWIKT3Gng2GQ3WH9fJqUpXmBycilz3Bw8efLAJi9VqRf+Bg6E1mBGfWP692wZnzJgB8x/Vx251B6N85WqFjr98+RJVqteCQq1FwybNPvhdyM3NxaNHj5Cfn49Vq1aha9euOHjw4HvHlwSr1YrqtepAaXSGTG3AgP8jG7JixUpUqFIdyalDi7WVND8/H0uWLMHgwUNw5syZD459/vy5reFpZE1o3EPQuFmLP3UuH0OmVCOox3JEpKRDZXLGsWPHvuh6fxfsCWp7/G3Hzt+FgwcPQqvVQi6XY/fu3V9kjZycHLCYTFwzmHDTYIKMz/8sW/z/bWRnZ6NilepgMllwdvNA3759YYqp90eTw56o36j41bkDBw2GMbKmTYYhuh569+n7BT0vyoEDB7Bq1So8fvwYq1evgaOLOwJDw3Hq1KmPzl2zZg10HiGISN4BpypdUbpsBUjlSjhX7wlzXEMEhoQXy4e1a9ciPCoOjZo2x5MnT9455ttvv0VIRDTq1G+ER48elegcq9WqC8eKHRGRkg6pczBkFm8klq9UIhvFgcvjI7T/RkSkpIMjVsI3aQYkZi9Ex8Th4cOH6NKtB8QKDRQ+cQhP3gm9V3iRCvD/sGjRYsg0tgbkLL4YjpU6Qq5U4+rVqyU+/5KQlZWFYcNHoFWbdn/qmf9Lsnz5CvAFInD5AqQOHf613bHzBbAnqO3YsfNeTp8+DYNYjN90BkyTKxDi6fWn7N2+fRs+Pj7g8XjF3gb3b2Lu3HlQmt1gLtMSXJEMYaViCpI9DZs0gzm2IUL7rYfG2RfffvttwbzmrdrAHNsA4YO3Qese8l5d2ndx8uRJNG3RCj169f4s2/MPHToEhcER4UO2w7vlBDi6uCMnJwe//PILFi9ejBs3biA2IRFygzP4EgV69uoNADh//jz27t1brGTd9u3bIZUrCpK3YQO3ILDbEjBYHEydOrXQ2OfPn6NW3QZwdPXA4CEp8AkIgU+riYhMzYDC7AEOjw8uX4AxY8cVVGRkZmZi//79GDFiBAYOHAg3L1+4enrj+++/x9u3b5Geno5ff/21YI1ff/0VbJ4AfJUFLIEULK4AfKUJuoia4IpkSEwsB6FEBpnagITE8qhZqzY0/mUQkbwDKt8ECOQaOLp62MZL1fBqNgbqgLJgcgVgcPjgynRg8YQQKvUgBhMsDg/mMi3g0XAYOAIxzPFNEdR9KbhSDdhCKVgcHg4ePIhz585hwoQJSE9PL/B17dq1YHP5IAbLVg3Nl0Bk9ARfLAWLxQZXKIGhVG2Y4xtDKJGjeq26qFe/IdhCKfhqC7gSFfgyNfySZkAXUQMChQ4iuRJsvgjhQ9IQ2m89WGxOwbZEq9WKxs1agC+SQCSRvnc74M6dO6E0OiOg8wKYomqhUdPm2LZtGxo0bob6DRoiMiYe7Tt2xtGjRyGRKWGKrgu5zoK58+a9096LFy/e+yDzn/tNqzeBLxTD5OgCucEBcpMblBodVq4sfnXTh8jPz8f+/fsL6U9/KoOHpEDl6AVTbENI5EocO3bsg7rSN2/exLBhwzBr1qwvqqUIANFxpWEqVRNOVbtBIlfi8ePHX3S9vwv2BLU9/rZj5+/E1atX4ePjAzabXaI4sCTUKF8esXIFysoViAsLKyI5Zuf/85//vXv27IFUqYVjpc5Qmlwxsxg7u/7D6DFjoPOLRWj/DdAHlMawYSVLuD19+hRDklPQt1//IrsgS8Ldu3chlMjg3XIinKp0hbuX70fnZGVlITquNIQSORQqDTZs2AC51oSIlHSE9F4DgUgCwBYnjv1mHErFlsagwcnIy8srkW/nzp2zVVk3Gg5TZHVUrVG7RPMbNmkGS1wjhA3cDKnJA1WqVvsifTsiomJhDKsCU0IzsAUShA3cAoVnFKRmLzRq2hyATYdbLFNAaXSCb0AQfvjhBzRr2RqpQ4cV2Z22Zs0asDhc+LadhuDea8Di8iGSKSEQSbBs2fLP7v8/AavVCqFYCv+OcxHS51sIRJJiSRB+KfLz87Fr1y7s3LnTvtvkM2JPUNuxY+e9HD58GM5SKX43mLBWpYa3g8Oftvno0SOEhYWBxWJh1apVn8HLfw5WqxVz585D42YtsXbt2kLHbt26Bf+gUPD4AjRu1qJQANegUVM4lG1jq672jcGcOXOK2H7w4AF+/fXXQlu4nj59CrlSDYeybaHxLw2hVAGBSIzylaoWkRDZtWsXVFo9hGIpZr/D/n/Iz89HtZq1IVFqIRRLsW7duiJjpk2fDpFCC01gOUhkStSqXQdsvghckRwBQaH45ZdfMHDgIKxevbrIw09OTg5EEin0UfUgc48EiyeCX/tZ8Gg4DEwOr6BRIwDcu3cPwaHhUPslwC9pBpQmV9SpV98mRxBVDwwmGwGdFyC41yowWBx079kLP//8M4QiMZhcAXSBZSEUS9G9e3dcvny5kB+bN29GnQaNERgSDhaHCxZPCJ9WkyC2+EBs9oJ7g1TwFAZItBbMnDkTgwYNRouWrdCjZy/ITS7gyXUgYkBrMGPRokU2OY2gsjDFNwVbIAFHKAWDzYVn09HwajoGCrUOMp0DwgZusTUsdPBD+OBtYAvEcKs3GBEp6RAZPcATiDB+wgRcunTJ1oivVE3ItWbMX7AAb968AU8ghm/baQjttx4MDg9chRF8tQOEejeEDdwCfak6UAeWR0TyDjBYHJjjm8JgdsDQoUPh6eOP2PjS0HuF26q8Gw6Fm5cfGjVuCq5MA4HWCRyJCmERpQqu05EjRyCSq2Ep1w7O1XvC4uSC7777rkjyeNmyZTD4RRfoMgeHl4JEoYFT1W4Q6lygDiwHvV8cOnbuihMnTmDUqFHvfYm1aPFi8IUi8IQiDByc/M4xPgHBsCS2RkTyDkgsPlAHlANXpoVDhQ6QqA3vvG+/JgEhEfBuMd6mBekZAQ6XB75QhMVLlnxt1/DgwQM0b9UGVarX+mwV6P8E7Alqe/xtx87fjWfPnqFcuXIgIgwaNKjEsm4fIzs7G0uWLMGCBQve2cTbzrvZunUrWrRui3nz5sNqteLgwYMICotEQEj4B/WDX716hXIVq4AnEKJMuQolli0IjYiCIbg8jJE14eji9slJsjNnzkCmMdh2P3ZZCLlKU6x5VqsVd+7cQVZWFnJzcxEQHAq9dyTUDp5om9QBALB69WoozW7wbGzTVZ40eUqJfNu5cyf0HsF/6FRPgru3X4nm37x5E95+gWCxOajXoPEXSyQ+fvwY3Xv0Qq069SCSyMAWyiA0uMG9wVD4B///avIHDx7gt99+w8WLFyGRKeFQoQN03qXQqm1SIXszZ80CVygBRyQHmy8CX6JA2KAt8Gs344tLu/1dsVqtkMjk8G03HUE9V4AvFP8l2vzvo3mrNlCZXaF29ESVajXtL/Q+E/YEtR07dt5Lfn4+mtSpA5VAALlAUEQb91N5/vw5SpcuDQaDgdmzZ38Wm39XLly4gK7t2yN54EA8f/78k2ycPHkSGr0RIpkSAcFh2LZtG9avX1+QjN6/fz8kciXUDu5wcffE06dPAQBHjx6F2uxqk46IaQiZayhC+nwLnV8chg8fUWgNlVYPz6ajEdBlIQQiyQf/4VutVly+fLlgm9njx49x69YtHD9+HDk5OTBYnMDk8CAyekLjFQUmhw+fVhPhUL49OAIJhBIZTPFNoDC5oGXL1ujZuzd++OEH7Nu3D/PmzQOby4N/x7lgC2UQW/zA5PDAFkqhDamC6LjSAGwVtEqNDjylEc7VeyEyNQO6wEQkJSVh4cKFSElJAf+PJoe6iFpgsnkgNgcagwlSlxA4Ve4C9/rJNukQoQwcgRjHjx/Hzz//jNGjR0MsV0GocwVXpkX4oK1wqzsIIoMH+Ao9nKv3tMl3hFQGWygHhyeA0iUQptgGYPMEMCY0h9jiA4HWGUKFFi1atcHz589RuVpNSOQKyB19EZGSDtc6A8AWysDii8Hh8qAwuSJ88Da41h4AFl8MmdaC+NKJEMsUUOgd4O7lU1CtO3v2bBiCEqHwjAJXpoNSZ4BMoQaLJ4R3ywkI7r0aDDYP+lJ1IDR5Q+ochIiUdFjKtQNfoYPE0R9S5yCED9kOYjAxYsRI9OnTFxMmTICbpw+0zj4QyxTYvHkzwqNi4Vy9F7yajoHMNQw6g6ngXhgzdizYQik0IZXB4gnB5HBh8AiGVm8qpD94/vx5aHR6yLRmiGUKdOnSBebI/0h5DILCKxru9ZMRW7pcwZzc3FyMHz8BzVq2LrSlWSiWIqDTfIT0XQu+SIJ79+7h1atX+O2335CZmYkjR46AK5LBlNAMYYO3Q6hzAU9hhLlMS1sCOKAcNEYLqtWs86cqjj4nPXr1hsYtGJZybcHk8ODbbjr8O86FWCr72q79z2JPUNvjbzt2/o7k5OQgKSkJRIT69evbm4/9zcjLy4NcqYZr7f5wqzsIMoXqiyRF8/LywGAyEZG8A5GpGRDJlLhz506hMXv27IGLhzec3b3w/fffv9dWfn4+ylWqAqXRGWKFGuPGT/gkn16+fInly5djy5YtBS9PUlJSYIxpgMjUDDhUaI+g0HBMnToVb9++LZbNFy9ewNHFDQafSMjUBkybNqPImM2bN8PNyxchEVE4ffr0O+38lcnDW7duQa0zwOgfC5nagFn/51l3wsRJEIql4Ahl8Gs/C75tpsLdx7/QGI3BBN+kWfBtNx1ihQYCsQyB3ZbAvX4yLE6uxfbFarVi6dKl6Nuv/99WtqMkrF+/AQKh7blp/ISJf8pWZmYmEstXglgqR+16DYp9TwJ/SCKx2AgbuAXhQ7aDL5LYJZE+E/YEtR07dj6I1WrFzZs3P/t2qKysLNSoUQNEhDFjxvwr3zo+f/4ceoUCvaQy1JTJUDWxbInm379/Hz7+QWAwmYiOS8ClS5fQs3dfKI1O0HmEICg0Ajk5OahUtQYcKnaEW52BULkGYsGCBQCA169fw+TgBE1AIrhSDXQRNp07Y3Q99Ordp9BaIokUAZ0XIHTARggl8mI1xrBarWjTrj04PAEYLA6YXAG4fCGEWgeE9PkWhugGYPOF4EnViEjeAf+Oc8Hk8GEKs+kz6yJqgi/TwFymFQQSOUQyJUyBCRBJFZAotBDLlDAYzeAIpVD5l4F7w6EFlRM7d+6EWOcMr+bfgC2QQKi3aUqrHDwRV7os8vPzsWDhIjA5fMjdI2Eu0xJMDh9svhCa4EoQm33AUxjg1fwbRCTvAF9pQkBgIOQ6CyQaM/gqM2RuYeDKtAgbuAUutfqCxRPBZHEERyCB0jceTK4AAZ0XwBBdHyyuEGyBFAwmG3y1BWyhDBEpOxHUYwUYbC62bNkCAEhLS4NAYUBQjxUwxjSE0OAOr+bjwOMJYLQ4gsnmgi2UQumbgPIVKyM/Px8PHz7EiRMnCkk5HDx4EJw/kvZ+7WaAI1ZC6hwMpXccWHwxiMECk8OD0OAOYrLA4olsyXCeCEEhYXBycYPI6A6JxRdisw+YHB5McY2hcQ1EUodO2LNnD06fPo127TvC4uQGYrIhdvADiy9GRFRsgR8Vq9aAa+0BiEzNgMqvNPgqMySOAZA6eKN169Y4d+4c7t27B5VWD1NQIsRKLcZPmGDTMv9DyoMrUUHu4AmJUouVK///rooBg4ZA4xYIx0qdIJYpsWvXLuTk5EAqV8KnzRQEdV8GvlCMEydOQGcwQWV2hUKtxYIFC6A0u4GnMBbojHP4QrD5Iugja4PJ5cOj0XCYY+ohoWyF997fe/fuxfTp0794UyrAloyfMHESmrVoCR5fiKDuy+DdcgIUn6DhbufzYE9Q2+NvO3b+rlitVkyYMAEMBgORkZFfdZu7HRtnzpzB9OnTsWfPHrA5HFviatBWcHmCDxaoWK1W3L17953N0T9GZHQc9IGJMIZXhYu7Z6Hdl3l5eZDI5PBoOAyejUdCLJV9UBIsLy8Pv/zyC86ePVtiPz7EiRMnbDv+QsqBxRVA5R0NrVcEatdtUGwbmZmZWLdu3Tt3cT169AgiiQxeTcfAqUoXuLj/OTnKz8XDhw+xYsWKIhX0Fy5cgFiuQmCXRXCu3hNcmQZqRy/0GzCo0DifgGA4Ve4M37bTIJLKMSQ5BQKRBDqj+YNV+f+X0WO/gdLiDlN8UwjEUuzbt++znN/XJC8v77PI2/UfMBCGoLII6b0GWs9wzJhR9OXH+7BardAbLXCq0hWutfpBplCVKMFt5/18KP5mkx07dv7nYTAYZLFYPrtdPp9PGzZsoNatW9PgwYPp2bNnNG7cOGIwGJ99ra/FtWvXSAZQH7GEHuTnU/nDv5Zo/qjRYylTaKHwwaPp981jKS0tjRYvXkwuLacSV6qhywva0/nz50kul9G9Ld+SUO9Gbx7cpH37D1C7du1IKBTS9i2bqErV6pSf/Zoen95Dz87vJwmfTd1Wji+01sQJ46l3n97EYLKoZYvmxfqdnzlzhjZs3kaBvVbTqzuX6NqOaYS8PGLxZcQWyoivNJCzswvJZVI6Pbsd5b55SeXLlqEDhw4T6+BGen7xFzLENiZtaBXKz35Nua+ekblmX8KmEdSndV1SKBTUe2AKudVPpYe/7aDr2ybRyqWL6JtxE2josKGUl5dPWY9vktjBl15cO0mOFTuSJqg8HZ/Vkm7evEkCPo+IQeRYsQPxlUZ6fGo3ybigl5cP0NusbGKwOZT16Abx5DrKy3pBly8/J7fmE+jJub10//BWcq0ziK7vnEFHx9cltkBCLIGEHjy4TyAGPb9ylHgKAxERPT69h3SRNUli9qbLG8aQQ/n2dHn9SHp28SA9Ov49MYioSfNWtPfHH+jWrVuU//YlnZrTnnhSDeW8fERXvk0hYnHpJVNGoHvkWLETPTqeQTqdI127do2ePn1KISEhxGKxCq59qVKliM/nk8w1hERGd+KrTCR1DqT7BzcRk80lBoFYfDEJdc7Ek2mJGExyrJBEz68eJ2X2Bdqw7lvy8fMnQ+nWlJf1ghgMInOZlvTqzkVauXoYXbx0mUxGA+0+foUyn2aS2OhBWQ+vkV6jpjUrlxX4EREWQsdWbSUioue//0YSBz9S+ibQte1TadvPXFq/OY6SWrcgvsGTzDX6k/jyYVq/aRv169uX9v28h3bs2EGm9tWJwWCQl5cXRUREFNj+ed8BUobXJbl7BL28cYqq1qhFCrmCxo0dTX36DaC83BwaOXIU1a7XgB4+fEhcqZoU7lF08PARcncw0Omz54ijcyKfVpPowZHtpHxyjEyaPDqgtZDcPYK4EiVd/WHqO+/t9evXU7uOXUnqFk5DUofRoQP7yMfHp+D4gQMHaNGSZeTt5Um9evYgNvvPhUxsNpv69ulNREQhwSE0cGAH4vH5tHbN6j9l144dO3bs/PtgMBjUt29fcnFxoWbNmlGpUqUoLS2NfH19v7Zr/5OcPHmS4hISSeYVTc8vjaS4+NJ0YlkPYjCYVKdePZJKpe+cZ7VaqVHT5pSWlkZMBtH6td9S5cqVi73u9+lpNG36dMp+m03duy8uFCfm5ORQ1ps3JHH0JwaDQTnZOfT27VvicDjvtMVisSgqKqpkJ14MAgMD6bfDh2j16tU05fYFcqufSjkvn9DuJd2KbUMmk1H9+vXfeezp06fE5PBI6hxIfJWJLu9b8cm+3r9/n4akDKU3WVmUOmQQeXt7FzoOgJ48eUJyubxQ3Pf06VPq1bc/3bp9hwb27UUVKlQgjUZDzZo1K7LGixcviMMXEVeuI8Gb5yRgM2jKqCHUpEmTQuPWr1lJjZq1oCdn02n6lMnUpk1rGjVyRLHO4/Hjx3Tnzh3y9vamnRm7SB3TjBQekZT1+BZVrlqNLp4/R0aj8ROu0N8DFotV6F7/VJ5lZhJbbiSOWEFsqZYyMzOLPZfBYNB36WnUpXsvysnMpRU7thOPx/vTPtn5MPYEtR07dr4oHA6Hli9fTnK5nCZMmECZmZk0Z86cz/JP5++Au7s7ZfMFNPjVS7rBYFCFcuVKND83L4+YHAERg0lMDo/y8vLI2cWVHp/IIL7akXKzXpHRaKQ6NavTjj0HyavpKHp15yLt/Xl2gY3mrdoS2zWWzAEKur93Bc2ZNoEaNGhAIpGo0FodO3SgunXq0Nu3b4v9QoLNZhOs+WTNyyFrzhtiMJhkJVDWoxt0bFIjQn4ecdlMWrd/L926dYtmzplHmS9e0YA+PenGrdv0VleZ0nZtobzs1/TwtzQSqh3oyfn99PLOJSpbtizt37+fBDoXkjr6Ue7rZ+QiyaUqVaqQSqMl304L6dXt83R16yRSq9Ukk0rImv2KnpzdSwxrPqnValIoFMThCejKpnEk1LtSzvNHNOvbVTR95mw6/4JHutCqdGHFQLq9ezEplAp68ugxnVnUgxgsLkkdA+jKxtHEV5qIyeGTNTeHrDlZxOQKiCuUEnKzifU2k66s7E/52W9J5VeaBGoHYgullPXoOhEx6Oq2KUQA+XeYQy9vn6P6jZrSwwf3SeYVS8+vHiOeQkcRAZ506fIVEoTUpedXjxH7qYSupk0jkUJHeTk5FBQaQRyhhIJ9vej7jB2FvhvZr1/StbTpdO/gRsp6eJ3Yua+JzcwnBpNNzo1H0pPTP9KLG6eIyeJQzutMurR2OFlfPqS5mzaQq6srDR8+nFJTUojH5xNAdOfnVZT5+xHiGTzp8hsxHdy8jVSB5UiQnUteTUdR5pWjhBNrC/mQMmQwMYjo8G/HiensRORXjvLfviapcyC5NRpOT87upZ/2/0gvb/1O9w9voxcX9lJk6Qjav38//fTTTxQbG0ulS5d+5/1Vu0Y1GjdtDr24foqe/36MfJNm0rOzP9H+g7/SqxeZZLVaacWKFfTcKqDwQVvozv619PTMHtKWbUHzft5DEydOpEnzVxGs+fTi+im6c+0UXbzIJy6PSzfXJVPW07s0uF+fd669cs06Usc2I01QBSImm9LT0wu+F3fu3KFKVauTMqIepf28ku4/eECTJox/p533cenSJapdvxHdvX2bevfqQSnJQwqO9erZnXp070oMBuNf9cLOjh07dux8XurUqUM///wz1ahRg6Kjo2njxo1UroSxpp0/T1paGkl9y5CpXBKx1c6kkT6jrUNTyGq1Ulxc3HvnHTlyhH74aT/5dV9JL66fom49+9CVEiSopVIppSQn0/Xr16nvgEHEIKIRw1LJ0dGRBAIBdezchZYv7kIMBoNatW5NEonkM5xtyXF3d6devXrRjNlz6c5Pyykv8y6Vior+LLbd3NwoMiKMji/tTrlZr6hPn3fHdcUhMiqW7ty7R8Rg0o60NHpw7w4JBAIiIsrKyqKyFSrT8WO/EYfDIbFESiaTidasXEY9evejE/eySWAJoLoNGtE3o0fS0pXfkrOjA82ZNZ1UKlXBGqGhoRQdEUL75ralvJy3NH/ObGratHBy2mq10r1792jiN2OobNmyJXou/umnn6h6rTrEFUrJoFVSjapVaPriZZT16Aa9uH6SlA7etGPHDkpKSvrk6/QhTp06RU+ePKHY2Nj3vgz5u9CnV0/aFF+arlzaT3w2qG3bBSWaHxAQQPt+2v2FvLPzTt5XWv13/9i3GNqx88/CarViyJAhBXp62dnZX9ulz8bt27cxfPhwTJ8+vcRbf27cuAGzo7Ots7Z/IJ49e4br16+jao3aKBWbgN27d+PZs2dITU0FXyyFe4NUmCJroFLV6gU2OFwuQgdsRERKOiRKLa5evfpZz2/AoCFgsTlgsrl/SEkIwVNZoA2tComDH0QaCyZNmoSyFSrDVKoW3OsnQyxTYMyYMZgyZQqCQkLBEStsOtASFZRaA9asWYOp02aAJxCBweaCr7aAweYiJi4epctVAIPBglDvCqlzMLh8PnJzc3Hx4kUklq+EyJj4gu1rVqsVXbv3AI8nAJPFglSlh8nBGRyBGIaYhohISYfSKwpJSUlgCyQI7b8RXk3HgMkVQGTyBoPFhkDrDAZHACaHD310PUSkpEMdWB5MLh8LFy5EXl4ePLx9bc1QdM7gCsRQqrRwcvMEi8MDR6RA+JDtcKrcBUw2BwrP6D8aEA4DWyDB+vXrwRNJwREpoAmuBK+mY8Dii6FUa6HWGeGXNBMRyTug0Dvg0KFD+PHHH3HkyBG8ffsWPJEUEqdAKLxiwOYJsGPHDsyZMwd6zzBEpmbAs8ko8CUKuHv5wss/CA0bN8GVK1cK/f7y8/NhtVpx4sQJJJYtZ5NBEcrA5AmhDqpgkwYRSOHVbCzUgeXBkyghksqxcOFCVKhcDSZHFySnDv2jAehcsPliiAzu4IgV8G45EYbg8mjTrj169eoNNl8EmdkDWr0RYrkKptgGkCi12Llz5zvvLavVirVr16Jq1WpQOvkhfMh2mKLroHadupg0aRL27duHJUuWQOsRhojkHTAlNIPe7FTQZCg3Nxc1atcFk2mTOwnoNB9hAzZBKFVg7ty5H2z4N3LUaGjcAuFWZyBkGiM6dOoMHl8IHl+Ips2awxxUBpGpGfBqNhYhEdEl/t5ExSbAsXw7BHZZBKlaj6NHj5bYhp0vC9klPuzxtx07/xBu3LgBPz8/sFgszJ8//2u78z9Ffn4+tm/fDrnObNOcNntCrtKgcrUaePz48QfnHj9+HFKVHiF918G19gD4BAQBsMlAHDlypFhNMPPz82FxcoElvjHMcY3g4OxaIJv4n/ju+PHjfwspxYsXL6JT564YkpxS4oaQHyIvLw8///wzjh07VqI5/01WVhYYLDZ8202HT+vJYLDYiC1dFrXrNcSNGzewZMkSqFz8YYiuDyZXAN82U+FQrg3CIqPh4OwGv6SZNi1wrSNYXAE8Gg6DMaIaqtWsU2Rtq9WK8+fP4969e+/0rVnL1lCZXKB28EDN2vXeOeb58+d49uxZkZ/HlSkH11r9EJGSDr1XBFasWIG4+NIQahzgUKE9ZBoTZsyYgUuXLhX7WhWX8RMmQaLUQu3oiajYhC/WkPJz8uLFC5w8edKu5f834kPx91cPdD/1Yw+Q7dj5ZzJx4kQQESpVqvSXdA9/+/YtevTqjej4RMyZO/eLr/cp5Obm4v79++8MUnNycuDp4wdDQAJkeieo9GbUb9ikUIPDBo2bQuPiB71vNAKCw5CXl4cff/wRlarWQNukDgUNFf+sj3l5eXjy5AkWLVqEgKAQMLkCuDdIgTasGkrFxsPi7FoQvEn0LpCb3KEPKA0WVwAGk43gXqsQPngbuEIJrl69Ci6Pj6Duy6AOrACuTAuR0RNMLh9K7xiw+CJ4Nh0Nfak64AqlGDR48HsD3by8PNSu1xAO5ZMQ1GM5pGYv8CUK8BQGsHhC8MUyTJ8+3Zag7rcenk1GgckVgCWQQl+qDnTh1SEyekAgFEMTWB7hg7dB5hICnlSNWbNmAbAFmlHR0WCL5DDFNQGLK8Du3btx584dVKleE1KlFkwOH+qgimDxhHCp0RtSlxCwBRKIZXJYyrUDV6qBV9MxiEzNgNjsg6VLl8I3MAROlTvDr90MCCVyxCaUgdriDpnGgM5du0EoVUDlnwi5ZxSIGOjWoxeatWgFi5MLNC5+tpcFAhGCQiOwc+dOJCcnIz09HVarFTNmzkSN2vUwb76t47zVaoVUroRX82/g1342GCwOQvuth0/rSSAGAzylCRyxAiF918Gz6WjIVFrInQNhKdcWcr0jMjIyMGnSJKi9IuFaewBkrqGQq/Vo0KgpMjMzEREdD/cGqbbzU5tgLt3C1jCnfBI6dOrywfsrKysL5SpWAYPJhJOrO0RSOcxRtSBRaLBx40bElykHDo8Po8URly9fBmDr2t6tWzdMmTIF2dnZ0OiN8Gw8AgGdF0Agln5Qr9NqteLt27cYOmw4Klatgfnz59vuxx7LEdRjOThcLiQyBUyxDaGyeGDY/2k4Whw8fQPg2XQ0IlJ2QuPohV27dpXYhp0viz1BbY+/7dj5J/H8+XNUqlQJRIR+/foVK7lp59P5/fff4eLhBSaThXoNGmPuvHkIjYyGQKqCb9vpMIZXRbOWrT9qp2//AWBzuNDojfj1118xdtx4iOUqyPUWVK9V56OJ5efPn4PLEyAiZScikneAw+WVOPmblZWFPXv24Ny5c8Wec+jQIezcufMfp7t74cIFWJxcwGSy0KRZi4LvyYsXL8BkcxDSdx2Ce68GMVlwrNwZlvgm8PYLxKRJk8Dk8qENqQKOWAmnqt3g23YazE6uSB02HAqDE7S+MWBy+JA4+CEyNQM+rSYV9M4pLm/fvgWL/YeG+eBt4AlEePLkCQDb81ZK6lCERpQCm8sDTyDEiFGjC82vVbcBzHENEdR9GZQmF+zcuRMvX75Ei9ZtERASATdPH1szTLkKs+fM+aRrePXqVSxYsAC//vproZ9r9Eb4d5yLiJSdUBqcPkvxRXZ2Nq5evfqvKl57F/n5+Th58mSxekD927EnqO3Y+Zdx7NgxbNiwoeCf2T+NhQsXgslkIiYm5p1vhj8n/QYMgs4rEh4Nh0KmNX3RJNHTp0/RrGVrRMWVwcaNGz863mq1ot+AQZArNQiJiMKNGzeKjLl48SJkGiP8kmZBH1kbbA630ANJZmYmWrRuC09vP3Tq1AkvX77ElStXIBBJ4Vy9FwyhlVC5Wo13rn/58mU0aNQUDZs0w++///5ePx88eIBTp07h+fPn6NGrNypUqY4RI0ZAYnCxBSi+CWCyOdCbLJBpTTD4lAKTw0dQz1XwaDQcXJkWXKkaLrX62hoecvl4+vQphCIJfNtOA4PDhyGmIcyJrcEWKcBTmiAyuCMiJR2+baeBpzCALZRBIBKjd+/e+O677wp827dvH6RyJZgsNgRqC9hCORSe0WDzxRCrjeALJZgwcSJevnwJmVIDYjDBYLERHBoGBpMFtkAKdWB5OFfrAQ5fCJODM4jBBF9lglimwIULFwrWkqn1cKs3GJGpGdAEVUCrVq0Kfo8XL14Ely8AV6oGR6IGX2WG1CkQDDYXSqMLIlMzYCnXFiy+uKBhYamYOPz666/wCwqBweyIYcOGgSeWIyJ5B4J7rgRfKIZMpYVA4wiB1gk8kRSG0MqwlG4OlVaP0PAI6MKrISIlHQonP/DFMpjim0Cq0qNr165Qmt3gUqsv5AZHrF27Fvn5+X8kYVcgtP9GsDg8qBy9ITW4gCeUgM3lQSBVwb/DHJgTmoAjEEPqHAyxyQtClQlLlizByJEjoTB72BpAhlZC1+49C65Pg0ZNYYqsDt+20yCUKiFRG+FcrQcUBicsX778o98HwBa8DR06FKbYhohMzYBT5S5o1sL28PfixYuCe//hw4fgCsSQuYSAI1aiXIWK2LNnDzR6I8RS2QcD8sOHD0OtM4DF5qBrj14FyWqeQIiAzgsQ0HkBeAIhjh49iuTkZCxfvvyTqpI2bdoEkVQOudaM6LjS//rA+5+IPUFtj7/t2PmnkZubi06dOoGIUKdOnb+k2OPvyosXL9C5bVtUiosrVtxdUmrVbQBL6eYIG7QFGmc/rFu3DkuWLIExIA6RqRlwqzPwg42Y/5v/jt3FUjkCuy5G+JDtkCq1uHjx4gfnWq1WW7NE32jofKIQFZtQorgkKysLAcFh0Dh5QSxXYeHCRR+dM3zESMg0BmhdfBFWKvqLVspmZ2d/1urWcpWqwLF8O4QN3AK1gye2b98OANi/fz+4QglYPCGYHB7YPCEiUtIR2m892Bwuxo0bB7VvPCJTM+DecCh4EiXEchXmzpsHq9WK9PR0NGjQABrfWPBVJkidg8GXKjF16vQS+We1WqHWGeBcrUdB873s7GxkZ2fD2c0TbIHNRxZfDPdGw8ATiAo9L9+6dQuhkVGQyBRo3qo1Ll26VJATOHz4MJQGR0Qk74Bf0kzoTQ4lvn6XL1+GVKGCObRCQaHIfwgICYdj+XbwbjEOIqn8ncnW/Px8dO7aHQaLE6rXqvvBlyl37tyB2dEZUpUOZkdn3L59u8T+/hPIz89HparVIdMYIZTIsGDhwq/t0lfFnqC2Y+dfxPJly6AXiVFWpYazwfCPTVKvW7cOHA4HQUFBePDgwRdbp2LVGnCt3R+RqRkwh1cpUffeklK7XkMYQyvZJC7kqiJVCjk5OeialAQ/Jyd0TUpCRkYGFAZHBHZbAkt8Y1StUbuIzVevXkEiV4LB4kJs8QFPaURiuQoFgWLDJs1gCC4P9/rJ4IttSVwOXwieXI/I1Az4d5wLo4Nzgb3bt2/jwoULyMvLg9HiCEuZFrCUbg6zo/M7g9309HSIpHIodBZoDWZovaPhWrs/eCIp2HwRBFpn8JRGhPReA0t8Y8TGl8aaNWsQFBoOY2QNKL1iIHePhG+76QUVzcRgIq50Ir799luIJFIwuXzI3CPA4onA4ovB5ArAFoghMriBI1HBsVIniM0+YIvkYPHFkCh1mDhpCpYuXQaeSAa3ekMQNnAz2HwRVH6lEZmaAdfaA8ARSKB1C4Raa8CNGzfw448/QiiWQqY1w83TG7du3QJPKIF/p3mITM2A1sUXe/fuxbZt2zB27FicPn0aVqsVK1euhK9fADh8IfgqCyyJrcHkCrBq1apC16p0mbKwlG2D0H7rIXEKBF/jCA6PD4PJAmNoRcgdvMETiCE2eSGo50roA8tg2LDhBfOHDR8BJocHz8Yj4Vi5M9g8IVg8ASQOfmDxxWAwWQjtvxGRqRngiuXgCKVg8UXwbTcdQqUBpvimiEzNgGPFjvDyDYBDuXZwqzcYHJECSo0ehw4dwoSJkyAUyyCSKtCxc1cYTGYoHLyhcvBC26QOGDd+AvQmBwQGh0MgVdgC9wEbwWAy0aVbd0iUGvAkCvCEEiSUrVBQnZ+ZmYnI6FiweEKIZEqMGj0Gy5YtR8MmzbBw4aIPPkh9//33mD9/Pu7evQsA2LZtG+Q6M1xr94fa0QvTphf9zk6dOhUig7uteqXNFHCEkoJjP/74I6pUr4X2nToXBPTZ2dlIT0/HL7/8goCQcLjU6ovQ/hsgVRtw4MABAMCixYvB4wvA4wuwaPHi9/pbEu7du4eTJ08W2WZq5++BPUFtj7/t2PknYrVaMXnyZDAYDISHh79XRuDvyvLlK1Cxag0MHTb8TyU+WzdujFoyOeYqlNCKRDh9+vRn9BKoVLUGnCp3RkTKTug8Q7FixQo8efIEFicX6NwCIJYpkJ6eXmK7Ds5ucKnRGz6tJ0MokRXrOejVq1eYPXs2Zs+e/dGXEo8fP0ZaWlqB5NsPP/wAjZM3IlLS4dNqElw8vAEA9+/fR43a9RAUVgrffvttIRtKtRYBXRYiImUnFAbHEklrlIR169ZDIBSDw+Mjdejwj08oBnFlysG5ek9EJO+A1jWgIME6duxYmGPqIajHCjiUT4JCa4DeKxwCuRYcvgg8gQg8kQwy11BwRHK4eHgVuacePHgAi5MLlEYnCMUSLF269JN8PHbsGErFxCOsVEyBHN2WLVsgMbohInkHXGsPAE9hgDGuMXgCEZ4/f15o/vCRoyCSKcEVSsEVSiEUS7Ft2zb8/vvvEEkV8G07DY4VO8A/OKzEvk2dOhWmiGqITM2AS82+qPJfz6eXLl1Cqdh4uHr6YM2aNe+cv3LlSqidfBDQaT70gYno1afve9caMHAQjKVqIjI1A8ZStdB/wMAS+/tP4LfffoNCb0H4kDT4tZsBndHytV36qnwo/rY3SbRj5x/GgqlTaRyPR2V5fGqdnUW7du2ihg0bfm23Skz9+vVJIpFQnTp1KC4ujnbt2kUODg6ffZ2k1i2odftOlH3jGL28foKqVJnx2df4D+fOXyB5eHOSOPjRq9MZdOXKlULdoWfPnk3H162jCRwejVq3jl7m5BBXoiKeXE88rTM9vre/iE2RSETubu50+dEbEpu96dHxDNp78FeSqzS0bs0qOnP2PMkDG5LUKYDuHdpEKp8EEmgsdGntcLq8cSy9vnuROrZqSkREc+bOpb79BhKLy6PyZcvQ44cPKail7d45/ss6ev36NYnFYiIiOnz4MG3atJnWrt9AhordSOkVRecWdiOZ1pXU/on07MyPxJSoiMXi0psHV4ktkhNHbiD2m6fUqFEjSkxMpOShw2jfvut0+eplupb2mHJfZZI2tDI5lGtLp9ck07Nnz+j3y5fIydWdeDIdicJdyVymBd3YPokq+BtIrVbT7Lnz6cGR7ZTz8gm51upHsObRtR0zaMLESfT06RMCi/dHkzkGMVkcenvnHD27eJAen/yehAYPcm4ymq7vmEaVqlQlnd5ImthmpAuvTre2fkNpaWnUuVMHWr5uIvHUFuLmv6GgoCCSSCRUvXp1IiKaNHkqDR0zgcSuYWSlq2R99YRen95JyQP7FenG7ehgpv3rNhARUdaDa5Sf/Ybmz5tL1apVpVWrVpFKpaIdO3bS3mtviCdVE/Ek9Or164L5d+7cJYVXDN3cvYhynj8ih/IdKPv5A3p86gcK7LKQTs/vQtc2jia2WEFWq5WCeq6kh0fT6Pzy/hQUEEBXzu2h+0IZPT+VTg2aNaBZc+ZT1tss8miQSnlvX1Lteg3o7q0b1KRxI8rNzaXnz5/Tui1p5FBrEL25d4nWrp1JLzKfEhHRth3pRNZ8enBkG+W/fkbunj40b+4cCuy5mhhMFp2a1oy2bFhLcrmciIjGjZ9AN17zKKjnCrqdNoW4HDa1aNGcWrRoXuSefvbsGTEYDJLL5TRp8lQaNX4yiYyeNCR1GJ09dYKqV69Ok8Y8pk3b0iihaxJ17dK5iI2QkBDKenKbnp7fT5mXDxc0Bbp16xbVqFWX1PEt6Piv5+huq7a0ZeM6SkgsT7/ffUy5r58TmwFSuouIyebS29w8ql2vPp347Si1ad2aWrZoQUT0p5u45uTk0I0bN8hisZBer/9TtuzYsWPHjp3/hsFgUK9evcjFxYWaNGlCkZGRtGPHDvLz8/varn2U3bt3U9fe/UkT34KOrdxETCaTUlOSP8nW2ZMnqQ+bTTE8Pm1gMunixYuf9RqMHTWcEstXpEcH1pCfnx/Vq1eP+Hw+nT11gg4fPkyurq7k5ORUYrubN6ylpi3b0POTL2nhvLmk1Wo/OkckElGnTp0+Ou7OnTsUHBZBbLmRXt77nWZNn0pXr16l10/u0qvb5+nltWPkZDISEVGL1u3obCaHxO5VqV3HLhQUFESenp5ERGR2cKTM8/tIoHOjnNfPv1gsk9ShI7k0Hk08uY4mTGpPp8+eod0/7KbAoGDasnEdKZXKEtucNG4MVahUhR78tITCIyKoWrVqREQUFxdHo8dNJAZfSq/O7aERKUOICNS3/0AK6L6c8rJe0smZrYn95gV5NhlFD/ctp7S0wt8rrVZLF8+doQsXLpCzs3NBHFxSgoOD6eD+nwv9TCgUEiMvm/LevqacF48o981zenhoI02fNo2kUmnBuPz8fBo1cgT5dV1KTA6PTkxtTpbKPal3/0F0+fwZmjp5Ag0dMZo0GjV9u3pFiX3z9vam19cn0tMLv9CrCz9RUP3/39TT3d2dDu77+Z3zANCmTZto6dKlxFY5kEDjQDy9B92+c++9awkFArK+eU75uW/JmvWcREJhif39JyCTySjnzSt6+/gWvb5/hRSfcF//z/C+zPXf/WOv4LDzv0rLhg3RSCbHGpUaRrG4iDbUP419+/ZBJpPBYrEUklP4nBw+fBiLFy8ukNCwWq1YtmwZBg4chOPHjxfbTnZ2NhYsWIApU6YUqVzPz89HzVq1wRPLIbd4wmhxLLQdKz8/Hx3atUMPiRS3jWb0kEjRvUsXBASHQml0glimwPfff18w/vXr1+jWoxfKlK8MmVKDgM4LEJmaAYHWCRKnQAj17uDyBEhq3wF8qQoqtzAwOTwEdluKwK6LwWRzofCMhkKpLqjelClU8O80D+GDtkIsVyM0ohR0XhHQeYYjvky5grVPnToFsUwBU3xT8BR6yN0jENR9KURKPYRyFVS+CWCyuRAotDBE1webJ4REpYdUrsSePXuQkjoUjZu1wL59+6DWGeDbbjo8m40BSyCBMa4xIlJ2QuochMjoWMQklIVaZ4DE5AVNUAWEDdoCnXcpTJs2DQBw5coVVKxUBcTiIGzQFgT1WA4Gmwupoz/YIjnEjv5g8URgMG1NFbkCIYwOLuCI5JC7R8Kv/WwItM5QB5QFTyiBMbIGgnutgtrZF6tXr4bVasWmTZswZ84cPHjwAMmpQ+HhG4BmLVvj9evXiIxJgGfjkYhMzYDKrwzkjn6YOnVqod/9q1evMGvWLLi7u4MjUUHhFQu+ygwmV4BTp04V2tZpdnIFV6oGV6oBiysoVHlTs3YdMNk8m5yHXI+IlHT4Jc0ER6xAZGoGdMHlUbFiRQhFYgi0TgjtvwGm6Hpo0rwlAGD9+vWoXrM2OnfujN27d0MkkYGvtoArVcOnzRTwhSIAtu3Ba9euxfz58yEUScDiiSDQOoEvlmLevHlQmt3g0XAolA5e8PLxR0BwKHr16gWJTA6PRsPh1WwMhGIpsrKyCnzv1qMnTDH1EZmaAUN4NSSnpACw6SbGlykHHl+AchWrYOiwEeALReALRZg0eQp8A0PhVi8ZjpU7Q2HxxIYNG4r9fUxJSbFtCXRyLahw2b17N3RuAbbdAx1mw+LkilOnTkGuMyMiZScCuy2FSCIDly8Ek8OHyr8MDOHVMGRIcrHX/Rj379+Ho4sbZBojdAbzB+Vz7HxdyF5BbY+/7dj5h3P06FEYDAZIJBJkZGR8bXc+yqRJk2COrGGrzqzVF1Xf0WCuuEyfMgVOEglqKlUwazR49OjRZ/PzzJkzGDFiBFatWoVbt279Y/S+p02bBlNoJUSmZsC5Wg9whVKYwypCIJFDazAhtnQirl+/DgCwOLvDp80UW4zp6l/oOeTKlStIKFsBfkGh2LJly2f10Wq14tmzZ6hUtQaIGOCrLfBrPxs8gRhKR28E91oFY1hldO7a/ZPXyMrKwt27d4vs4Nu1axe6dOuOVatWwWq14unTpxCIxPDvOBdezb8Bg82FPqquTZovsRXad+z8Z0+32FitVrTv1BlsDhdKjR7r169/5w48q9UKqUIJzyaj4NNmCphcIRwrdURwWORn82XuvHmIK1MeffsNKLZE3azZs6EwOEIfXhMsDh8aJx9I5EocOnTovXNevHiBuNJlwWJzEJuQ+Fkba/7dmDFjJlRaPdy9/XDixImv7c5X5UPx91cPdD/1Yw+Q7fyv8vTpUzSvVx+Rvn5YMG/e13bns3D8+HFoNBpoNJovtoUMAH766SdYnFwhlishVhlgimsEiVxZ0HTtY9Su2wBa9xAYghLh5umNnJycgmMzZs6EysETLjX7QqTUY+XKlQXHXr9+jfBSMRCIpOAzmIhVKKGWSHD69Gnk5OTg2LFjRbb3te/YGXq/OLjVHQSuSAqlWwiMsY3A5ArAVRjBUxggMnpAaXKBk5MLSgsEaCCWgc3lg8MTIDA4DLXqNiika2dydIZr3UEwJ7YGh8vH3r17sXDhQixatKhQsnHWrFmwRFS1abDVTwZbpACTw4OPnz9YfzQXdKzSDXyxFElJSdi/fz/OnTuHzMxMtG7XHjKTO8QmL/AEInj5+kMTkAjX2gPAYHPBFsnB5PLB4omgDywD9/rJEMkUqFWnLvQmB7DYbJSvVLWQFt3u3bvBEYjBESvB5ArBYLLAlWnhWmegTRZEIIUxrolNxiWqFoJCI2ApnwR1YDlwxEqILb4IT94BqUqHwNBwiKVytGjdtkjQt379eiiMLvBpMwUK93C0bN0GffsNgMo1CE5VuoLFE0Kp0uLOnTuwWq1YsmQpWrRuC3dPH+h9o8GVqmGIbYSIlHRYyrYFk8OHQCwFg8lEzTp1YbVa4e7tC7e6g+DbbgYkCg1OnToFAFiwYAHYXD4COs2Hc/WeYHJ44KsdIJSpIJTIoDQ6wezojD59+0IfWhnqgLJgsDjQ6E24c+cOAJtsjkShhsk/FgKJDJbE1jbpkpAq4PIFGDV6LACgSvWa0Dj7QuceDKlSWyCBY/CLQZWq1WCKt11Lh3LtoDNaoPOPhyGkIswOTnBy9YCDsxt27txZ6Npdu3YNeqMFIpkSTDYXbC4PkyZPQXJKKvSBiQjtvxE631iw2BwE91qFoB4rwOHyULdeQ7D4Yqj8SoMn16FT5w83U/wYz58/h9HsAGNwWajMbug3YBAePHgAkdSWXHco1wY+AcEYMHAQNL5xCB+0FTr/eIwePfrjxovJiBEjYAirYrsf4xqiU+eun822nc+LPUFtj7/t2Pk3cPPmTQQEBIDFYmH27Nlf250Pcu7cOUjkSpgjq0Gq0hWRligpe/bswaJFiz6rzMmVK1cgkSthjK4HpckF4ydM+my2i8vRo0cRGROPiOg4HD58uNjzNm3aBKXJFb5tp0HjGwuxybMgWV2nfqOCcZmZmRBKZOCIFBBbfCCWKfHq1asvcSqFePToEXwDgsFgsiC1+CJ88DboI2uBxeWjYuUqMASVhS6iJjhiJSxOrp/dp+zsbBw5cqRAVg4AFi5aBJFEBiaHD+eqPcAWySEyuEMiV370uTQnJwcLFy7E1KlT/1LZzR9++AFGixNEUgW4XD4cXNwKkp6TJk+BQCSBzmjG/v37S2z78uXLOHLkSInl6SpUqQ63urZePabQSujWrVuh6/xXsWPHDvTs3btAe9zO348Pxd/Mr1u/bceOnZKiUCho+fp1dOjMaWrXvv3XduezEBQURPv37yc+n0+lS5em/fuLSl38N7du3aIFCxbQvn37ir0GAKpdtz4JSrUgh9rJ9OZlJhmiG5DMOZh++eWXYtnYsWM7WWoNIkv1fvT42XO6du1awbFfj/xGYt+ypAksR3KfBLp06VLBsfXr19PNzBzy7/0tqRKaUI6XN536Yxsih8Oh4ODgItv7jp04RTL/CqTyTSC1SyBVCPOksi48CvD1ImQ9I2tOFvm2nUaO9UfQjVu36AiLS5vevKRIf19asmgBVa9aiTp3aEceHh7/3481q+jhnvn0+OQuUvjGU7Wa/4+98wyTokrbcE3nrs45Ts459yRyTkPOOeec06AiQSQIEkVFFAQRA0GCa0Aw54iKrgFERQUFJMP0/f1o7P1mZ4CBxTVs39fFH+qcU6eqq6ff89Z7nqeN8OuvvwrNmzcXVCpVsF1BQYHwy2evCd+/+rjw7YuPCK7CtoLGYBI+++JrIaXPIsGZ31L4bt/DglprFPr37y8kJiYKx44dEwDhmWeeFc6c/Fmw5TQVpDq78PlnB4TT3x4QDu5cIgzo21sozMsRfPk+ITY2VjCmNxTMyTUEQ3iy0LVzJ+H7wweFN15/XRg2eIBw8eJFQRAEYd++fULz0tbCxXNnBYXJJagtHiFvylbBcXkOYZIwwZJULBx5/Qnh8yfuEI5/8pLQvUtH4Zc3HxdUYeVC2KXzgpwLwuEtcwWP2ym8+erLwq8nfhEeXHNfJRmHr7/+WpDZ4wSdN1kwxBcKjzz6uDDztluEMX07Cmnyb4UObVoJvsJC4f41Dwhr1jwgjJ16q7DnkCD885+fCxFtpwtyvV048urjwptzWgqH964TwsLCBEftXkLO+EeFnc+8IGzdulVYs3qVcOyF+4RP144VBg3oK7z99jtCZGyCMGTkWMEPwqVzpwSF1iKEyZTCxdPHBa1KKTRt0kRo36Kx8P47bwkOu10oP3VMCJNIBZXJKTRv2lhwuwNbNZeuuldw1B8keNtMF2Qai3DuyGfCuWPfCuXHvxGmT50iTJs6Wbjl1pnCrh1PCce+/VLQpjcWzpw5JZz99hPhzI9fC+d//k5o3KihcOL9XcK3O+8Sfn7zCeGH774RFPY4QWYOF37+5bjwyosvCAe//Fxo2rRphXsXFRUlfPXFZ4JEQFCa3cKlixeFSVOnC99++60g1ZgFmUojSDVmQQgLE8rPnxHKz50SJFKp0LFDW0HniBDi2k4W4tpPE55+9vlqfRevhF6vF959+01hWv+2wn1L5wvz5s4W7Ha7sGnDekF5YLsQVX5I2Pr4o8KUyZOEeLNUeOfOdkKiVSGMHDnyPzrv/0er1Qr+M8eFS+dPC+Wnfha0Ws1NGztEiBAhQoT4d8LDw4WXXnpJaNy4sTB06FBh7NixQnl5+R89rSpJTk4W3nj1ZWFC14bC9ice/Y9lCuvWrSv07dv3pkpQvPjii4IhJkcIb9BfsNXqLTyxdfsV2+7atUsYP2GisGvXrmuO++WXXwoPPfSQ8NFHH121nd/vFxo3bS78aM4VjlrzhcZNm1f6POfdOV+IT04TWrfrKPzyyy/B/2/durUwrH8P4fzLq4Vku1KQXjgVkGo4sE8w6rXCmHHjhPXr1wufffaZoDE5hIROtwjWjAaCTBomaDTXF6988cUXwuOPPy4cPny42n3m3jFPOHJeKXhqdxckSlEIk8oFmWgQEhOThAfuv0+48O2HwqlDHwnJPe4QzmvdwqzZc65rTlfjzJkzQn5hsdC4VUchPilF2LlzpyAIgtCvb1/h5PGfhZKSYuH0J88JWp1eqJWTKHzy0QdCdnb2Vcfs3K2HMHXecmHe2m1CQXEN4cKFCzdtvlejfv36wreHvhJOnfhZOH/+rHDwi8+FzMxM4eDBg0LZrbcJCX3vFvQlvYWuPXpf17hLly4XsvIKhEal7YTmpa0Fv99f7b51apYIv7z1pHDk9S3CiS/eFLp37y64XK5K7S5evCjs2rVL2Lt3rxDIVd48du3aJXTp2Vd47L2fhW59Bgpbt269qeOH+C9wpcz1n/1fqIIjRIi/HwcPHiQhIQG1Wl2pQvM3Dh06hMNopJ3Zgler497LzsrXory8HLlCQfaYh8mb/CQSuQpPza5oDaZKZoZV8dBD65ApRWxZjQmv1wezzVHhrf62bdvQme14i9ugNZgqSK9s2LABW2wG+VO2El67G+07drnm+VasXInB5saT2xCzzRGskoWA0YJGbyS2zUTcNbug8STiSK3BnXfeydNPP43OZMNTqyt6s50dO3ZUGNcTEYVcY0IiUyLXmjBHp+NweTl69GiFds899xzpWTmIRivOlEJsDidqexS+sl0kdZuDVKmhecvWtG7XAYXGgMEejtXhorCoGEd+aWDrZsuxiK74QCWCJwG5SkO/fv3x+/0sXbYMvdWFNbkYmVKNr6iEqVOnojPZcCXlERUbz4kTJ/BGxqD1JKGyRhAmVyE6Y8mf9hQRDQeg1pkIb9CPqOYjUFm8SFUaJAqRxJQMHnroIW6//XZmzpzJnXfeyerVqysZjBw7doxly5axfv16Lly4wIMPPohEpsAQk4tM1COTK4MmgPv27UNvthPdciw6RwQujxdPre74ynYi0xixZjUiTConpc8iMoevIUymQKLUEN9hOvnTtqM0ufAVFgOBrXkXL17k/fffR2eyktR9Lva8Fmg9SUGTSEEiCVSuK9RENByAJcFHRnYe3377LQarA3tOMyIbD8ZgsvDdd9+xdu1a6jdsgjOjDknd5qC3OqlZux4Odzi9+w3g4sWLfP/996hEHTljN5I2YBkShRqT1U69Rk1whUcxdVoZfr+fjz/+mFWrVrFhwwbUWgPm5BqYEotQafTXNDNSqDXYcluQM+4RtOEpTJw4EacnHKPdgyciilmzZyNTicjVOoYNG87evXvR6AxEl47BlVW/Wt+NG2Hbtm106tSJ+fPnV9iqWJ2/HdfLmTNnaNS0BXKFkuKadSpI/YT4cyGEKqhD8XeIEH8jLl68yIgRIxAEgZYtW/5XKmL/jrz//vvojBYimwzFFpfFhElTqmz31FNPBaTG6vZCb3Hw1FNPXXHMjz76CJ3RTHhOfbSGgCTelTh9+jQyuYL8KVvJn7oNuVJVIYZ99tlnMTrCSel7F+7cJvTs0++KYy1dugyrKxyJTI5UocZbpydmTyx3zJuH1eHCXdweR3Ihbdp3qsad+RevvvoqOoMZT3oJelNlY/iq+OWXXzBa7KhtkUhVOmSiHqlCRCYaMEUmM61sRmAXWn7AoC+i4QC69+pzXfO6EidOnCA5JQ21LbCWie84gxxfcYU258+fZ9u2bTz77LPVjg+VapHcCZvxle3CaPf8bnKV1eXjjz9GZ7aTN2ULaQOWYrE7r6u/xe4kffAqfNN3YLR7eP/996vdt7y8nLuXLqN33/5XlBsqLy+nToNG2KJTMLkiGT5qzHXN71qMHjsWb73ewZ2gQ4eNuKnjh7g5XC3+/sMD3Rv9FwqQQ4S4Pvx+P4cPH/5dg9Vff/2Ve+65h7Vr11Zbr+rf+eGHH8jKykIul7Np06ZKx++//37aWCwcdnu532RBL5Fgc7qrpeX0m+OxzmynsKQm/QcO4sUXX7xmv/Pnz6NUiyT3XoAlvT4ypVildvXevXuZP38+b7/9doX/v3jxIq3atEcikRKbkMxXX311zXNCYNviqlWrOHToUKVjL7zwAq7waERHNJkj1uLMqMPChQsZPeZfP8zhDfpV+mF2hUcR2WQo+dO2o7ZFEdV8JO6UAp588klee+01wqNiMZitLF+xAr/fz86dO1m3bh3ffvstot6E0uhEIldRp159OnXtji2tDvEdpiPXmLBl1GPAwIEo1Boc+S2Ra4zIdVYkChGJXIkjvxSFwUHPXr05c+YMZouNMKmc6JbjcBV3QKrSktTjDgpm7MYUlUbXrl0xWmzIdRZ803eQMew+JAo1YVIZErmSMJkCQRCQa0146/dFdCeii8oiptV4FCo1YVI5UqWIStTy5ptvVrgPzz33HEazBXNMJkZ3DGarHZXOjEzUIVWoMXviaNaiVbD9kiVL8Ba0wF2zC2p7FPacpkjkKpyFbRF1RjR6M2EyBZnD15Az/lHCZApq1KwVkDVR6zEmFCBXqLj33ntZtmwZJ06cYPv27TgTciiYsZvknvOC91Yfk03uhM3oItPRuANbM9MGLEWuNZOV60Oj05M9dgO+sl2YnBGkZmThSMrHGpVCZEw8WXmFLK9ii++iRXchkSnIHruBtP5LkSnVQYmR/095eTlJqRnIRANhUjm+sl34ynYilcqC0itvvvkmzz//fKWEdV5BIXKdhTCZAoXOwty5czl79iwHDhzg3LlzdOjcDVdOY+I7zkAh6hD1ZpSilozsXIaNGPW7aM8tXrwEhdaEKaEQqVKs8Ln++3W//fbbQdf7EH9/QgnqUPwdIsTfkbvvvhuJREJOTk6FAoe/Eh9//DFz585ly5Ytv8vL5Gvx7LPP0qpNe5JS06ldv1GVMhvDR44ivH6/QMxdvx8jRo7ihRdeYPjIUTzwwAMV5n3rrbfiLm5PwYzdRDYZQreeva96/k5du2PxxmEJj6ddx84Vjj3wwAPo3XFoPUnoY3IorlnniuNs2bIFa1QyEY0GYssOaFPHtZtKo2alfPnll0yYOIk777yzgtRfdejbfyARDfpTMGM37uIOlF32HrkaDzzwAM7UEgpm7Ca29QTkKg3OzPrkT9tObNtJNGpWyqFDh7A53Thj09GbLLz11lvXNa8rUVyjFlKliEQhYstthqdmZ/IKiiiuVZfmLdtw//33U6dBY/r2H8jx48evOtaRI0cYNWYso8aMJSvXh9vXgoj6fSsVL1XFxYsX2bx5M4888sgNr5Wvht/vp1vP3mgMZtQaHQ8++NB19U9ISSeq+QhS+y1BrdXTo3cfRo0Zy48//ggEJFr27t17TTmTn3/+mcWLF3PvvfdWuM4vv/wSrcmKb/oOcsY9gkKpuv6LvMwPP/xQqQhk27Zt6K0uIhoOwGBz8/jjj9/w+CF+P0IJ6hAh/se5dOkSLVq1uZxIM/DMM8/c9HOUl5eTlevDmVqMPSGHZqWtb3is48ePU6NGDcLCwrj33nsrHHv11VdxabWsMpmppVLhzW1GdPMRlNSqG2zz1FNP0bS0NePGT6ygZQwBXbn9+/dfV7B79uxZFEoVWaPXkTV6HQqlKjiu3+9n1cqVDOzVq1K18r9zsw1WDh48SHhUDCpRS2pGFh06dSU2MQW13kRk06EYHeGVkvx1GjQmsvFg8qduQ22PwlnYDq3Rwv79+4mMiSe27STSh9yDqDNUSoz/8ssvZOfkolCqUYlawmPiSeoxj4IZuzHE5qJ3RbNixQo2bNiAQq3BWdQWiVyFt14fzCm1KJixm8Rus1GotbzzzjvobS7Utkjypm4nofNtSFVabDlNSeo+F5lajyU+j5i4BCQyBUnd5xLZdChSlRZTQhGW9Pq4a3bBklYXqVIMmPyZPRgTi8iZsJkwqZz0IfeQ3Gs+EoWaqdOmBa/jxRdfRNSbcBV3RKbWI1PrMCYUIpGrCK/fD5laz7Rp07j33nvZsGEDFy9e5JNPPkFnNKPQW0nttySg7RyfTVxCAgqVGqlSRKYOJHTDZAqsDhcnTpxA1OoJb9gfb60u6ExWHIl5ONNrkZGdy/Hjx4mJT8QUlYZMrUNpdiNXKHHmBfS/7fktkSpU2HObI7oS0LgTESQSFGot5ohkXBm1iY5LQNQZ8ZXtJG/KFiQS6RWfs6i4ROy5zQmTKQiTyklKScEbGXh+RL2ZqJh4evXpx4CBA5FrTJcrv504fK2w5zbHZHNw5MgRRo8Zh8HmwuKNo17DJhXO171HLxx5pfjKdmJKLOL222+vMIfUzFySeswjfcg9yEQD+VO2ktZ/KVaHq8o5P/roozRs2oLxEyZd9+LpNxJTM0nqPjfwnMblI1coeffdd2nRuh2du/UImh81aV6KyRnQ0V66dNkNnSvEX4tQgjoUf4cI8Xfl9ttvR6FQYLfb/3KGXF988QV6kwVPURtMrkgWL777uvr7/f5K8f+NEJuQTHjdXkS3GIXRbOX06dMVjj/xxBMYbG4iGg3EYHMzf/58tAYz3nq9MXtiK8z7kUceweyJJbHrLGxx2dwx784qz7lx4yMYLTYsdiczZ87k6aefrhTXPf744yh0ZpJ6zMOUVEzT5qVXvIYtW7Zg8MSR0mcRUrWO8Pp90dojWbDwrhu/McDcO+ZhT8gjpfcCLJFJPPDAA9fss3PnTszuaNKH3IO7oCUtWrZGb7Lg9TXHYHWxbl3Av+eXX37hhRde4MiRI1WOs2PHDrr16M2iuxZfMea9//41xCenUbdhY/75z38SJpHirtGZuHZTCJPIcLjDA7tR207CW6srMpWGuLaTceU0qqDV/e/4/X4SUtJwF7TEU9iaqNh4Bg4eSpfuPXniiSdITM3A6nBVWSgCUNqmHbaYNOzxWdRp0IhXX32VocNHsGzZ8uvWfL7aHL/++usbMg19//33ScnIxumJwGxz4Clpj9vXgtSMbPbv34/RbMUZl47Z5riih9OFCxeIT0rBlVUPe0IOrdt2CB47ceIEWr2RuPbTiGo8iKjYhBu6xjHjxqPS6FBrtNx3//0Vjm3ZsoUhQ4eHktN/YkIJ6hAh/sfZs2cPFm8s+dO2E9/pFlIysm/6Ob755hs0BjO+sl3kT9121UTZtfjyyy957rnnaNSoEYIgMH/+/ArHH16/nsK0NAw6E7kTHyOm1TgKSmoB8MEHH6A1WohpNQ5Hakm13ZfPnDnD9u3befXVVzlw4AD1GzelqGadYIX1nQsWohI1qEQN8+YvCPZbsmgRaXoDt+kNODXaalVk/8bZs2dZsGAB06ZNr7JKujpcunSJo0eP0qV7T1w5jUjscjuiwUKz0pYVjBp/48MPP8Tu9CCTK4iMTaBWvYZBd26j2Ub6oBXkT92G3uKosF3vm2++oWev3qh0ZvImbyG172K0BhMGmxtLYiFShZqOXbpx4cIFLly4QGFJTaRyJQpRh6tGJ2RqPVHNhmMKT0GqUBMdl4haoyVMrkKm1iHTGBGkciRyFVKVFqlaj7OwLWFhEhRqEYXehkJrRNTqURgcAbNIvQ2V2UNi11n4ynYhOqKRKEWUJjdhMgW5EzaTNXItYRIZd9xxR9DUsqysDFtWI0yJxSj0NqJLxwQSwrnNCG/QH3NKLRxON87kAmwx6cHKlVFjxiJVihhic4lsMhRRa8Dg8JIzdiPe2j1QWcLJGf8ohrj8YGL2tddeo16jpuT6CpEoVKjtUaT0WYRcJRIeHYcnMpoWLVrQrVs3pkyZyt69e/FGRmNyeLE5XDz77LOYLVa0ngTkWjO5kx4nrv00zFY7S5cu5bHHHkMiV+Jt0B+NOwFRo72imU5hjVpE1Ot9OWkv4ixsiyO/FI0rHrneiimxGE/NLkhkSsJkStIGrsBbvw8SuQpDXD7R8QmoNTrCpLKAFIlMiVKj57PPPuP111+n/8BBFJXUxFPUFl/ZTpwZdSp9d5evWIHB6sKemIdUoSZz+Bri2k+tFKA+//zzTJkyBY3BTGzbSVjisuh1lS2sV6NT1+6Yk2sEDD/VOlLTMzFZbEQ2GYy3RkfSMnN4//33Mdjc5E97ivTBqypsibxw4QIDBg0hKi6RfgMGVTBHDfHXJpSgDsXfIUL8HXniiSdwa7V00miRhIWhVquvWUTxZ+L+++/Hm9uQghm7Seh8G8W16lW775dffklEdCxSmZx6DZtw7ty5G5qD3+9HKpOTO+lxfGU70RotfP3115XaPfbYYwwcPJTHH3+cxYsX4y1sGahSbjuZJv9vx5bf72fuHfPwFddi/MTJVUqmnT59OlB00v9uknstQKPTV7mWWr16Ne7s+sHz1G3Q5IrXcfHiRdIyswOxm1qP2uqlUeMm/3FV+vnz5xk6fCSpmblMmjKtWms+v9/PxMlTcXoiqNuwMT/++CMHDhzg7rvvZs+ePdU679y5c5GrdagdMZg8ccyeM7dSm/3796M1WkjutYDwmp1JTElFIlfiLGiDwuAgTCpj586dmBzh+Mp2kTVqHRK5ioIZu0npswiT3cV9991X5T369ddfkckV+Mp24ivbhUyhDCaCk9MziWo2gvRBK9AYzJV25J07dw6JVEb+1G34pu9AoRLR6k146/XGGp3K1GnXrkK/Xvx+/w1Vah85cgRRZwjsopy+gzCJhMFDhuGt3S1ggljSgUmTq5a++eyzzzDY3PjKdpE78bFKVdLPPfcc2fmF1KxTv1rSMP/O4cOHUWv1ZI9eT9rglWh0+useI8QfSyhBHSLE/zivvvoqRruX3AmbiW4xihxf0U0/x7lz57A6XETU74u3RicSU9JvaJyH16/HIoqkGI0UZGTQvn17BEFg6tSpFQKF36rClWoNRrOV1157DQjoPXsyAtW6Sd3nkJ1feM1znj9/noKMDHwmMxE6HVaLlcgG/YhtPQG90cyvv/4KBN7o/6ZJ/BudWrRgsdHEYbeXXlod06dPr/a1tmzTHntyIe7C1jhc3v9IfiU7v4jErrMCW+3SinnkkUfw+/3BZNrp06eDwWN5eXmlc+3btw+lWovkcsK4Ras2wft94cIFvJHROLIbIVVqyBq9jviOM4iIjmPv3r2sXbuWH374ITjWhAkTUOjMSNU6BIn0ssyGBrlCjUSmILp0NIndZiNTabFkNsQQm4uvbBfRzUeiNHuwZjQgY+i9qMxuJFIZWmcMvrKdxHcsIzMnH5XeSmTjQUjkKiRyFRpPImmDViJT6wmTKpDIVZhTaiFVaQiTKZAqlBgdXrJzfZw5c4bHH38ciVxJVPMR6CLS0UWkkdD5NmRaMwq9HZlaj0SmJLLpMMyptZEoRXLzC1CJGjKG3ou7pCNyUUdpaSkqgw2HrxXRpWMCOtNluzAnlzB37r8C5p9//hm1VkdK74XEtZuCTNQTJpWT0Pk2ErvOQiJXYrB7uOuuJUDgu9S3/0CkMjlmm4Pt27fTrXsP1AYreZOfJL7jDCQKNVKVBpk6UHUu15pRmT2B61aog1UNDzywluj4JIpq1Ob5558nv6gEpycClTYQdOZOejygl61Qkz3mYQpm7Eaht6HxJAXur0KN1haOQiUSJldgSqmF0uQivtMtZI1eh0ShZvv27egMZsLr98McnY7ebEWhVJOV6wtqJp49ezb4PL300kusX7+e22fNRqPT4/JG8MorrwTv18RJk9CaHTjS6yBVarDnlSITDchUGqaV3XLd342TJ0/SrkMnHN4oGjdpyptvvonebL8cOD+OXKHk0KFDiDoDqf3vJrrFKOKT0zhz5gyjxowlKS0TvTOatIHLsSXksnDhwmue8/jx47z33ns3pYIrxO9HKEEdir9DhPg7MqBHD243GDns9tJPo8XpdCKRSFi6dOkfPbVq8c4776AzWYhqPgJ7fE6VGtC7d+9m5syZFTxfIPBSOrxOd3zTd+BIyGXNmjU3PI9uPXtjjUzCkZBDQXHNayZh33rrrUAFdd3emL1xLF5yfZXfv/zyCwpVQNM4e8zDyBSKKl+Kf/fdd9icbtxpxehM1mChyZU4c+YMdeo3QiqT4yuqcU15hj8rBw8eRClqSew6C0/tHqjtUTRqVrl6/JlnnsEenRrQmu4wgzCpLChvEttmEll5BVy4cIHM3HycibmYXFFoDCac6bVQ6CwY4vIxh8dXqnI/evQoy5YtIyI6DnNSCeaUWsg1Rrr26AWA0xNBWv+l+KbvwOSMqCRP4vf7cXsjiGzYn6gmQ9DqDHiz6wXWrN3mkFdY46ber48++giXJxyJVEb7Tl2uq0K7vLyc5LQMXFkNcKTVoLhmHWbPnoMjuZCMofdiS8hlyZIlVfY9ffo0ZpuDiPp9cPtKyS0orrLdjfLdd98hU2kIk8qRa83ojeabOn6I359QgjpEiP9x/H4/I0aPRSqT4/SE88477/wu5/n4449p17EL3Xr25ptvvrnu/mfPniXO5WKTxco3Lg/ZJhO7du1iwIABCILA0KFDKwSHJ0+epF3HzqRm5ga30X377beYrHY8eU0xOSNZuGjxNc/7+uuvk2Q08o3Lw/M2B2JYWMDwYvoOtCbrVTWj75gzB4dUykitDlEqIzuvoNrXqzOYyB67gYIZu7F6Y6vUta4ua9Y8gN5ix51WgssTHqgMsNiQSGVExychkyuwuzx8+OGHlfp+9dVX1GvYiMimw4hpPQG11UurVq05evQod955JzNmzEBrtFIwYzfeen0Ik0ix2l3s27ev0lgnT55EqdagsngwJZVgiMtHJhpRa/SoZTLCJFJyxm4MmL6odVgzG6BxxZMzdiPOwrbIdRaiW4wK6FAnFeOp0wOZxoTS5EZjdjBw4CDsManIdRbS+i8lb/KTSFVawmRKJAoRlTUCiUJN5rD7yRh2P1Klmshmw/CV7cIRn80jjzzC3XffjUpnwle2i+yxGwIJYqsDqUyOQm8jf9pTpPReiFSlRR+biz4mmzCpHFFnxFO7O57a3QmTygLbAdtPxZhQgEwlohQ1l++Nk48++ih4Tw4ePIhGbyJ/ylayRq8jTCpHkEixpNdHH51FmFRGfKfbSMvKA+C9995Db3GQM/5R4tpNJS4plfikFJQaA2ESKWEyJSprOGkDlmFKLEKq1CBVaUkfvIqCGbsRHdHMmTOHzz//HK3BTErvhUTU601+UQkQqKZJTsvAHJuFVK0LJqJ1kRm48ksxmK0oVGrkShVTpk5jxIgRSORKzMk1LhtRqkntt4S8yVsQDRbuvvtuPGnFwcqTxNRMjh8/jt/v59y5c9Rr2ASJVEZkTNw19dcfeGAtclEffNmij8ogTCond8JmcsY9gkyuuGHNvjfeeIMu3XsydtwEUjOycaYWYYtJo2OXbkBgO6jTE0FyeibvvfceAwcPxZFWg9g2k5CpdaQNXI63djdGjb66ocv7778f2J7riSYiOjao2xfiz0coQR2Kv0OE+Dty3733kqTXc4fBSLhWy2OPPUarVq0QBIGRI0feNCmB35OdO3fSoXM3Zt4+q1KS9pFHHsGr1TJUr8eq0VRIUrfv1JWIer0DCeokH/fdd98Nz+HSpUts2bKFjRs3VltmbO/evYwcNZqHHnoIv9/PTz/9RGmDBsS73cycMeOqlctnzpwhv7AYuUqDSqPj9tlzKrXx+/34/X5+/PFHHnvssSrj+r8rr732GiZXwOQwffAqpEqRlatWVWp35swZUjOysMekodbq0dkjgusLtT2arNx87C4vrdp2YP369Tz99NMcOXKE7t27Y0vMp2DGbuI7zqB2/cYVxoyMicOdVQ+9PQKF1kh4vT6kDVwelKm797770OiNGB1eGjVpXuX37NNPP6VpaSsaNWsRLPDw1OqGJTKJsltu/Y/uz6VLl9iwYQMrVqzg559/pl7DJkQ1Ccg6WiOT2LZt23WNd+zYMebOncvChQv59ddfOXv2LJ26dsfpjaRnn35X3VG4f/9+uvboxaAhw256HPzYY49h9CaSP207EQ0HkPs7FN6F+H0JJahDhAgB3HwN5Oqya9cuchITqZmTc0U34EuXLlHb58MplzNGq2O3zY5Lo+G9997D7/czYcIEBEGgW7duwR/E/gMH48qqT1KPeRjsnqAj9tdff82SJUuqvZ3x0KFDmEWRB80WRhuMRNhsWLyx2GPTqVG73hXv26VLl6hdtz5yrQV3jc5El44hIjqu2velcbNSnOm18NTsjNXhqmQQ98UXX/DCCy9csQrzxx9/pGuPXtRt2ITnnnuON954g40bN/LTTz+RnJZJXLupxLaZiNoWSf7UbUQ2GUyDJs0qjLHqnnvQ6I0odRZkGhMyjZGopsMwhidiszuxxOdhTchHrTXgymmCPaXGVc1YvvjiCzQGC1KlGDTXEyRSwmQKPnA46aTVI1XpMDojqN+wMeFRMUjkSqRyJRKFGkNcPhK5EtEajlxnwZ7bHH10FjEtx6LWGXn11VcpKK4ZkAlpMZrUAcuRyFVovck4i9qR2G12IFktUyDqTai0BiRyJSqLF53VTXpmNlqbF5mowxidgc4Zg0JnRiJXESZXIlVpyRx2P9EtRiFViChNLqKaDkOuNeNwuVBozeijsgJSHzG5AV3trrOQi3pS0rNwpNfGU9QOlyecM2fO8N577zF4yDAyc/LQmOxIlSL6mBxkogFrZkPiO0xHqhSxJPqChjlvvPFGYMfDpMeJbDYclUaPLbkIX9kupKIRpcmF6Iwje+wGIpsMCSaYLWl1iW4xColcyYsvvsiGDRuweGPxle0irf9SPJExwc/p+PHjWOwuYlqPJ23AUhRqDSNHjmTGLbfwzTffcPr06WCVfdu2bbHnNKVgxm6iS0cjVYrIlWrUWgO9+/bnm2++QW+y4C7pgDUqhfETJwfPs2bNGhyJefim7yC8dldKW7Vl6tRpLF26tMrANregBGNCAebkGsS1m4pSY0CuVJHSeyFJPeah0Rlu6O/Yd999h85oJqLRIJwZdWjRqg333XcfGzduvOJCPbeghMRus4Ma60ZXNHqT5ZqLwa49ehHRIGCa5MppWK2K6xB/DKEEdSj+DhHi74jf72f1PffQu1MnNm7cCARi1rFjxyIIAs2bN/9dTIn/W/To0IF5lyvEBxuMzJo1K3jswIEDOJweZHI50bHxHD169A+cKfTp0oWeBiP/sNmJ0+t5+umnr9h24JChOFJLCG84AI3BVGnNdM/q1ahEDRqd4Yr6uufOnWPp0qXMmTOnwu7G/5QPPviAJ554otJO0v8Uv9/P8hUr6NytJ5s3b75q2/Pnz5OdV4A1KgW1wUKPnr2u2PbMmTM8/fTTbNu2DdnlIgy51oTHG44tPpfM4WtwpBZz++3/enbef/99tAYT3rq9KlVQv/HGG1jD4wLG5QOXIZErCa/bE0d6LUpbtwu2O3jwIO+++261Y9W33nqLkaNGs3LlyhuKb/1+Py+99BI7duygZ+9+2KJTcWXUITYhiRp16hPdfCT5057CFpPGk08+ed3j/xnZvHkz9th08qc9RVSTITRs0vyPnlKI6ySUoA5xRU6cOMGBAwf+Em/SQ/w1OX78OMbLyd+5RhPxXm+V7T777DPcWi0v2RzkyRVow8JYsmhR8Ljf72fOnDkIgkBpaSlnzpyhVr1GxLWfGtDCyqrH/f9mkvD/+fbbbxk0ZBh9+w+ssopzy5YtFKal0bxePb766it2797Nk08+edVqza1bt2IJT0DtiEZ0xqLQGIIyDdXh119/5ZZbb2PEqNGVjCbWrFmDUaUi02gkIz4hKDMCgSrlfgMGYbQ6ceWXEtN6PKLWwKxZs4JGOPFJqSR0vo3YtpNQ26PJn7adqKZDqdewok6dzeUhbeBy8qc9hUQpYs1sEEhEthiNRK5CdMQgE/UIgoBcoUIqVzBm3PgrXlN5eTmFxTWRKjU4C9vg8LVCbY9GEMJIFHVEKNWESWTIFUruWrwk2Gf8+PFBI8XolmPRGi3oDCYUWhOJXW4PVG9n1+PBBx/kzTffRH65kjdMKkcQwpCqApp9vrJdqG0RKFVqOnbsiNLiJXv0ehz5pdgc7oDGtVKDRK5CEATCo2KQ6ywkdZ9L/tRtSEUDErkKuVqLTKHEmtGA/Gnb8dbtjcFiJ6X3wkCVsisOiUyJKbEYpdGBPbcFksuVvgUzdqMx2dm8eTMqUYMuMh1jRAqlrdqQ6ytAolAjEw2k9l0cGMsZiyCRoTdbsdhdtGjVlnYdOiFRqJFrzUhkSiQyJVmjHkJpdKCLysSWFZBbCZMqCJMp0HhTAtem1hETG09aZjYaoxWZSoPJG4daZ6KgqISHH36YX375hZZt2iNVqMgYsjqoOf7JJ59U+Znee++9KPRWErvMRBeRhlytwZmUh93l5ujRo1y4cIHt27czbNhwxo4dy+HDhyv0dSYX4CvbSUS93qi0BtxFbbEl5NK9V59K5+rWszeOjHqYkkpQaAzMmTOHJ554IuDo7gln165d1/hWVc2ePXtwxKZTMGN3wJwnIvqafe5eugyjw4snrzFGs5WHH36Y77777pr9ho8cjS2tFrrIdOQaA737VL7OqvD7/bz22mu88sor/7E2ZIjqEUpQh+LvECH+11ixYgVSqZTMzMwb2u34Z2D50qWk6Q3cYTDi0Wr5xz/+ETzm9/spLKmJI7kQR0ohRTVq/6G/qY1r1GC5ycxht5fGZgtr1669YtscXzFJ3eYE1jWZtXn44YeDx06cOIFSrSFj2H2k9r8bUVu1PnVp63bYk3y4cpsQER17wxrc/5+NGzeiM1lxpxTg9kbc1KT/lKlT0dojiGo+Ar3FWeGzrIqzZ8+yc+dO3nzzzWqNf8stt6D3JmHPa4ElvR7JKWm4i9oG1hW1uzN02IgK7V988UXq1qtPclomI0ePCUrVvfXWW8iUaiKbDsWZ05S8gmIGDBrMtOllnDp1ivPnz/P6669XiIGrw60zb0euVKFSa3j44Q3X1Rdg8tTpGO1e7DGpyBQqskevp2DGbszuKDZu3IjZakclamnUpPnfxkPlwoULNGrSHIVSjc3p5oMPPrjuMcrLy/nxxx9veg7szJkz7Nixo5K8S4iKhBLUIark1VdfxarT49XpKMzMrORMHOJ/j59//pnbbr2VW2bMuGnBx1dffYVdFPnK5eEdhwtRoaiy3fHjxzFrtSw1mplkMJKZULWr74oVKwgLC6N27dqsW7cOncmCO7UIu9NzRbdngITkNDxFbfDW7IwnIuqm/CA99thjmLxxiEoRjUSKVae7KYHg+vUPI5UrUSrUWFQaZDIFTZuXBgPsxs1aYEouQa41kTH0Xgpm7EZl9mBPKUFrMPHKK6/wj3/8A4lMQZhcGTANlMowWWyVnNwTUzOIbj6StIHLkao0SJUaXEXtUOtMmJNKKJixm6hmw5HIlaT2XUzO+EcR9UYOHjx4xfmfPHmSrNz8gP6zSofK5EaqFIlrP5UwqZyMofeSNfJB5EoVRrMVrd5A+/btkao0RDUbgTY8BVd4FMeOHWPS5MkYHRF4fC0wmK0cPHgQX1FJQIpj6jaSe81HafZcTvoa0UWkIdMYCZMqkMrk6GNygvrWClGHNTNguuPwtUKmFIlNSEam1hPbZhI5Yzei0BjQGUyX565BaXKhMNjRGCzEJiQFqp47zggk7SUyBIkUY2Ixhtg8pEoNpsRCHPktkan1iDoDKqsXd80uSNU6PBHR+P1+9u/fT3RcInKtKdgva/Q6nIVtMKfUxJlRl9KWrVDbIvGV7SSh820o9FYkUjlhUjkShRprRoPLRpF2XDU6Ba4pvyX2vBaBanS5CqXZjdLixeX2oNQacdfqisHupaRWHeyZDXAVtQ9oTJvttG7X4aoLuOnTywiPjsdsdxHfoSygdZ5eg/vuu4/k9EwMNndABiQiAZ3RFHzOTp8+TUFxTZRqDRabA6MzEmdhW5yF7bC7PJXOc/z4cbp270V2fhH333/jupH/zi+//ILd6cGd3xxrVCpD/m1BciX+8Y9/sHz58qs+7//OsWPHMFgdeGp2JaX3ArRGM59++uk1+/UbMAijw4vREU7PGzSEDHF9hBLUofg7RIj/RXbt2oVOp8PtdvP222//0dO5bvx+PyuWLaN3p048+uijFY6dOHEChVIdMLGbvgO5UnVTq8VPnToVNMWrDrt378ai0ZBrNpMQEXHVCuS77lqC0RkRkCm02iskO48dO4ZSLZIz7hEyR6xFoVTxwQcf8Oqrr1ZIVKtFbbBYwuQIvyETun/HV1yLhE63BGO/qkzYb4Tvv/8ehagPSvu5itpVqIa/FmfPnmXo8JEUlNRmxcqVlY4fPXoUo9mKMS4fhcGOPjyJPn36YbE7ccSkYrTY2L9/f4U+rdu2RyJXEtl4MNa02jRv2YY1DzyATKlGqtKiskUhVagqvGg4c+YMGdl5WLyxaPSmKqU0Tp06Rf+Bg/EV1+LeewOyM0eOHEGt0ZEzdiNpA1fckNmf3mgma+RafGU7UYh6XL5SIpsMRW+y8PPPP3P+/Hl++umnv0zhg9/v54UXXuCZZ5656lrd7/dz/PjxG1rPHz16lKTUdNQaPVGx8dUqPqkO586dIz0zB0dcBnqLgwUL77op4/47L774Ilu2bPlL+9yEEtQhqqRZnTrMN5j4xuWhtslU4S1tiL8+n3zyCY1r1KAkKzsofXE1/H4/vvR02hsMdNIbyE5Kuik/Zn6/n5aNGpFqNBKh0zF1/JWrb/fu3Utdn4+WDRtWcj7+/zz88MNIpVLy8vLYt28fjz32GD/99BMvv/wy/QcOYv6ChRXcsc+fP49EIsU3fUegwlajvyl6WOfPn8djMnOHwchBl4cCvYFNmzbd8Hj3rF6NQqVGIlcFNH6nbEGmMZLUbTYmT2xwa5bR6iS172LcNTqjNDoxxuYi11nIm7IFT+3ujJ8wEQjcJ5WoQSVq6d23f5WO4e+//z4JKWko1FrUOhOiVkevXr0CFc0RiWQOX4M9uxEqTcDkL2fcI4g6A4cOHbridSxfvhx7Qi7ZYzdgz6hL3Xr1Mdi95E/bjkSuJHPY/WSNeogwqQxHQWvSBq9EJWrxRkSiMlhQqEQaNG5KfHIa4ydO5qmnnqKsrIzadevjK65JWmY2MlFP1uh1xLaZhOiIQWlyEiZTIggCKlskEoWIu1Y3REcMCoOdMJkCQSLFnFyD/GlPYYjNw2y1IVeKpPRZiEJvQwiT4AqPClRQ6yyk9luCr2wXKpOTxMQkHE4XUqUGrTcZe35LwmQKwmRy9LF5SOQq7HmtCJNIcRS0IWvUOuRaczDoNiYUUK9+wwr3SdTq0UVnoY8OJNEjGg3EklaHiIb9adikKQqticzha/DW7Y3oiEWm0hLf6ZbAc6HWo41Iw1unJxK5iugWo1GZPSiMDhSinsQut5PSb3FAPkUpIhP1SEUD5pRaKLVGYttMuqzxnMmMa2gi/vrrr2Rk52K0e1CKOpzZDUnqPge91cmUKVNwpZXgK9uFq7gjUqVImFSO2e4Matb5/X6OHj3Kp59+ikSuxF2jM4bYXLxRsTfwLblxvvnmG+bNm8eDDz74u8sdRcbEk9p3Mb6yXdgiE3nhhRcqtfn222+ZP38+Dz30EKdOnUImV5A3+UnyJm+56QvqEFUTSlCH4u8QIf5X+eCDD4iIiEAURbZu3fpHT+emUV5eTnhUDOG1uuCt2Rm7001CchpxiSk8++yzNzTmwkWLsbk8RMXGoRK1qEQt/QYMqvY66euvv2bPnj0VdkNeiZ07d7JkyZIqd3uWzbj18vk1NG/REo3ejN7qweGJoHGzUt5//31q1K6HK6cx4XV6YLE76dy1O0q1SGZO/nVX9/5Gt569cec2DkgqWl28/PLLNzTOv/Pss89idEWhMNgvx5DqoOl9dRgzbjyOlGISu8zEYPdU+nwXL16M3hFJUo95gblbHJw4cYJffvmFl156qVIx1okTJ5DJFWjcCRTM2B0wA3R6UGu0pA9aQVL3OYTJFJiSihF1xuCuvq1bt+KIy8RXtouETreSlVfI+fPn2bhxI5s2beL8+fP06tsPZ3qtwFytLl588UV++OEH1Bod2WMeJm3AUnQG43Xfw5SMbCLq9yWh0y2IWj1du/ekVdv21aowf++9934X2Zbq8sMPP7Bly5YKu4j7DRiE2R2FJTyelm3a/S6J9dtmzsSV0xhf2S7cha0ZM3bcTRl33759WCMSAtKKAypKK94sZtx6G0a7F0d8FhnZeTfsy/NHE0pQh6iSzq1aMcpg5H2Hi3SD8W8VnISA5KgoZhiMrDKZMWk0wS1KV+L06dMopFK+cXn4xuVBq1Bc1w/WDz/8wPPPP19lVcGlS5fYs2dPJaft/4Tt27ejUqlITk7m8OHDfPrpp2gNJiIa9McWl8m4y0na36hRux7OlGKcGbXJyM67aQmqNk2aMNlg5DOnm0yj8apO2k899RTtO3Vl9py5lZLFJ0+eRCpXkj7kHpRGJ/EdppM18sGAJvLwB3CmllBWVsZXX31F7br1UJpcmNPqIpEpyc3NxeSJJa79NMye2Aovm44fP85jjz3Giy++WOFH/vvvv+fFF18MBsuXLl3i448/Dn7m5eXlDBoyDIvdSb2GjVm3bh2iRodMruCWW2cCAaOP6PhE5AoFg4YMC44/a9Ys3HnNKZixm/C6PenTbwCZOXmIjhikKh1hkoBZosoSjsoWhS4qA5lKw4YNG3jttdcYO248tkQfqf2WYI5IYsCAAcTEJ+Kt1YW49tMCiV2jmTCJFIlciSCVoTDYyRr5EIY4H1KlBplKS5hEhtoRi9zgQKo1I1Fq0UWkIwgCEpkSV41OSBQqIpsOI7x+P2QaE8U166DS6JFrTXjr9ialzyIksoCGtbtG54DchkKNVKlBrrOgsngxJRXjqtEZZ1E7JAo1pqQSXMUdkCjUqJ1xhNfvh0qjq6RdPH369EClt1qHVKVFKldi9sSiN1l4++23GTo8YE4oU+sQpDJkoh53zS7kTnocqUpL2oClATkRT1JANkVvRSJTkJiShrduL/RRmUS3GIVv+g50kel4anVDqtIiCAJSlRaNJwmJXMXGjRvZs2dP8Jn0+/0VtgE+9NBDl2U6dhHRZDBObxTp2fncOX8+rdu0RTTaSR+6GrnehrdOT/KnbkNti8AYmYqv6F+O5C+//DImT0C/L3PEA+iNJgYMGswDDzzwl6nsqC4rVq5EZ7Jii0oiO9dXaWfF8ePHcbrDcec1xRqVysDBQzGYLMS1n0p8h+nojKa/zVbMPzOhBHUo/g4R4n+Z77//nvz8fMLCwli0aNHf5rf466+/pmfvvvTo1QedwUR8xzISOt+GVm+47oTOhx9+iM5kI33QSuRaE8m95pM3+Un0VifvvPMO8+bdydBhIyrtUPy9+Omnn/j555+RqzWB4gOVFolSg7tmZyx2Jz/88ANjx0+g/8BB3HXXXdiiU8kZ/yjekg507tbjhs75yy+/0KFzN1Izc5k1ew4ff/xxpWflvffeY9CQYcyaPafahpI//fQTJqsdc3IJoslBq9Ztr2teDZu2CBZcWNPq0K1bt+Dn+/HHH6PRG7FlN0Gus2CMTLvm9Z8/fx6VqEWuNWHNaIBoj6JXn0AMnzvxcbJGPkiYVI6vbBdRzUbQsUt3IBDfGu0eMoasJrx2Vxo1bU7dBo2xx2Vhi03HbHchU+uI7zA9IN+S/S9Zytlz7kCuUKISNWza9OjVplcln3/+ObXrNyIz18fOnTuv2vbChQt069kbs81BRnYuWqMVV7IPd3gkx44du+5z/yd8/fXXmG0O3CmFaA0mnn/+eS5cuIBUKiNv0hPkT92GSqP7XYzG58yZgzOjDr7pO3DlNWXCxEk3ZdyAD5OJpG5zCK/VheJadW/KuP8fq8NFxtB78ZXtwuKJqbbUzZ+NUII6RJUcPHiQ3OQUtEolg/v0+cMM9EL8PogKBe87XBx0eXBqNHzxxRdXbe/3+8lJTqar3kB3vYH0uLhqPxMfffQRNr2eAosVh9HIgQMHbsYlXJMXXngBnU5HVFQUc+fOxRqbSebwNSR1n0t2fkVH39OnT7N06VLuuuuuKpP1fr+fl19+mb17917Xd+Hzzz8nKTISqURCr06drrjV6I033kBnshLdfCS2uEymTZ9R4fixY8cIk8rJGf8oce2nIZErkStVKEUtZncUGr0JkzMCjd7E8hUryS8oQq3R0rJNW86dO8e8OxfQoElzFi++Oxg0+v3+gByIKwq5WodCJTJ+4mReeukldEYz9uhkPBFR1f7xv3jxYoVEW90GjYls2J/cCZsxe2J45plnAnrSEyaiUGtQGuwoRS0vvfQSPXv3xRRfQFL3OUi1ZjTuBCxpdZCJBjTeZCKbDkVrNLN//358hSVENBxAVLMRyHUW5BoDcq0ZZ2FbfGW70Ns8TJkyha+++ooNGzYgVahR26JIH7wKd43OKEwu7Hml+Mp2IjrjCbssjaGPziZMKkMIk2KM9wX0rpuPQqExIFWosdgcvPvuuzRv2QaFwYZUpUOq1CBViiR0vi2g6ZZcA5/PR5hESs64R8if9hQytR6lyY1UoUam0mJKKsaRV4pCZ0GutyFVaujcuUul+1lQXIOIRgPxTd+BPbM+pS1bUlK7HtOml3Hp0iUuXbpESa26KPUWJHIVDl+rywnmMKQKNaIrHldxB2QaI46CNsi1JpRmN1KFCplai1SlxVu3F3mTnkB0xGCM86EUtYHxZEp00VlIFGpEvQmLN44GTZpx4MABIqJjkUiktGjdlttnz8bpjSRMIkN0xuLMb0HbDp0pLy8nLjEZV35zrGl1kCpE5FoTMrWO8Ab9EJ1xJHS+FYlURp36jdixYwdjx01AqlDhLGoXqGzX6IloOACTO7pKF/abwenTp5kwcTJtO3Rmz549Vbb57LPPWLFiBa+88spNPff+/ft57rnnqpT92bdvH46YtGCFjtMTwUsvvURKRjbJ6Vns3bv3ps4lRNWEEtSh+DtEiP91Tp8+Tdu2bREEgSFDhlS52+6vyrlz55DJ5eROfJy8yU+iUKo5fvx4pXbnz59n5u2z6NG7b6Xq4D179mANj8dXthOlyUlCp1vJGfcIWqOFdh06YU/Iw1unB3qThW+//fa/cl1ff/01UqVI3uQnyRh6L2FSOdljNlRK6N1///04U4vxle0isulQmrVsfcUxL126xKpVqxg/YeIVNX3vWb0aUWdAb3HQtkOn4Hrj+++/R2+yEF63F47kwio9Rq7EP//5T6ZNn87KlSuv69krLy/n9ttvD8jrJZcgVWmQq3UUFNfk4sWLLFq0CG9BSwpm7Ca29QTCYxKq/Oz/P3fdtQS9PRylyYVEpqR3796Ul5czbMQoNAYzCrUGld5MQufbsMfnMGv2nGDf22bejs3pJr+oBh988AFKtYhv+g7yp20nTCJFYXAgVeswxOah0RkrPCvnzp37r3zv7rnnHmxx2WSNfBCl0RFc2zhTi4Jmqv8tFi5ciCc/UMwU1XwErdt3xO/3Y3d6iG4xirh2U9AbzdV+2XE9nDhxgvzCEiQSKWmZOdcl2XMtNm7cSEpmDvUbN73qbuMbJa+wGG+trsR3ugWt3vRf+5tzswklqEOE+B9kzLBhxOn15JhMNKpZs1pJ159++ompkyYxecKE63J+HjVsGGP1Bg67vQzV65k8ceK1O90k3nzzTcxmM1KJhEiZDFEqQ2d1M+PW24BAENe5Ww/aduh8VR22EQMHEq3Xk2gw0LXtv97g//zzz8yfP58lS5ZcVaf9Wvd31apVePOaUDBjN/Edy3BHxpKamcvM22cFA7zI2HgkClXAnFBn5Ndff+Wnn35i7dq1mN3R+KbvILXfkmpvGTp06BAagxlDXD7eur3IGrUOtdFOckoaUc1GEFW3F6JMTozLdUMvFXzFNYltOymQYI1NZ+vWrSy5eykmbzwSpYbwBv2x5zQhIiYOpzcKU2IgSA6TysidsBlf2S5kopGY0rEBs5Ksuqxfvx6nJxyJUkSm1pPSZxHOonboo7MDyd+oNORqHe7s+tgcbuKTUvGUdCS8QX8kclUgGS1TXE5Q70IiV5I2cDk54x65XG0tx5hYhEShxlunJxpXPG3bd+Ttt9/GHR6JVCqjT78BdOzSjbzCGtxzzz1IlWpERywRDQcgUagwhSci6gxENx9BQqdbCZMpcBZ1wJrVCIlSgzm1Ng5fa+RaM3KdhahmI5CJBpYs+ZeB5ocffohMGTBLlOusAUNEUY+zqB3W6DTmzruT1157DZMzAk+tbrhKAjrTUU2HYUqpicoWgdoRjcLgJKHL7egiM1BZw/GV7SKm1TjUtkgyh69BrrMghEkCppBhEmyXNbjdNbviyG+Jt15vbDlNiS4dg0JjICo2gYh6vUnqcQdyUYfa7CK29QQUBjvmtDoYLA6++eabwLZErR5f2S7Sh65GqtKSP207mcPXECaTIzqicfhaIhMNGBOLkIt6dAYTid1m4S7phFylwVPcPvCSoHQM7Tp1ve7nDwLfzzfeeIPnnnuuyoVHt569cabVDGibG0yVXtR9+umn6IxmvPlN0ZntPPbYYzc0j+vlyJEj6IxmIhsPxplZjxatrq9q6PfkhRdeIDYxhej4JJ5++uk/ejq/K6EEdSj+DhEiRCCGnTBhAoIg0KRJk2vuuvwrMXT4SAw2F0a7h779B1bZZuDgodiTfEQ0GojWYK4gM3jhwgWKatTG7IpCJWoRtXpkcgXTym4hJiE5uJvNnZx/zQrW/wS/38+7777LJ598wg8//IBCLZIxZDUJnW9DqlDjiM+mZp16FSqbT548SVpmNgabG6PZelXjtnETJmKNTsNTsws6o7lK7w2L3Un6oBWXzbWdfPTRRwA8/fTT6GxedJEZ2HKaEX4DEm5nzpzhhx9+uGYV//fff8+BAwcoqVUXrclGmEyOs6g9ST3nBSql7R42bdrEzp070VudxLQejzk6jfSswJrrahX0rdp2IKbV+MCapLgtd955Z/DY119/zeHDh7nrriUU16rHhElTrrjT7eLFi9icbqIaDyKifl+kShG1PZqUfkvw1u2F3eW97vtzM5gzZw5uX4vLuy8TsabXJ6nHPOSinhdffPGa/cvLyxk1ZixRcYl07d7rP9JAfuyxxzB740jpswhHag0mTJwMwDvvvENBcU2y8wurNScIJJwHDx1Os9LWPPfcc9Wew19RHuPgwYM0btaCbF8RTz311B89nRsmlKAOEeJ/EL/fz549e9ixY8fvvlX8jrlzqWcw8rzNQQ1DxUTcf4MFCxagDJNgCAtjqk5PenR0MMCJSUgivFYXIhr0xe70VHkvLly4gFwq5ROnm3+6POiUSn766ScuXbpEUmo6zqz6OFKKqV2vYaW+1eXAgQPojGY8RW0QzU50rhiSe83H7I1j8+bNQOAHdtjwEfTo1adCwvjAgQNojRbSBi4nsvFgMnPz+eabb9i0adNVzdd+/fVXtHojoiOa+A7T8ZXtRGePRieRoLVHYVao2Gd3ME1voG5BAc888wwubwQWu7Na28z27t2LzmBCa7JSs059zp8/T59+A7DntUDjiqdgxm7seaXowlOI71iGXGsKaCKrddiym+Ct2xuJTBnQnitsg95k4euvv6Z2/UYY4/LReBLxle0iqfscFHob8UmpOD1eVNZwJHIlosVNmERC3pQtAW1xnRGtwYAj2YdUqUamUCKVK0ntfzfZYx5Godawc+dO6jdsjEypQmWwYjCZWbFiBXmFJUQ1G0buxMcwuSKDFawvvPACtshkVPZIJHI18R1nkD12A2qNjryCYlzeKEwxAd05T+0eSJQixngf9vxSJAoRmWjAmtkIY2IxTZs2BQLfzTFjxxImU6C2R2FMLMIQm0t06RhkGiOeur2wODyEhUmQKtSEN+iHQm8lpuVYlGYPUo05YOKoFJHrLEgUanRGCzLRQHiDfjhymyNVqLBGJWEwW5ErVaQNWIarpAO6yHRyxj+KOaUWxvgCFDoramcccq2J+A7TURpsqKwRSBUintrdURjsxLQaj6OgDebU2pgdblq2ac+BAweCFdT2tFpIFSpS+t5FTMuxeCKiGTh4KEarA1NyDQxx+cS1nYxc1GNNrUVs20moRR2izog2PA2l1siCBQuBwEuyVm07kJKREzSRuRIbNz6CQiUikSvRu+NwuDyVKgniU9JJ7bs4sHhM8VUyrlm4cCGeyxU2Ma3GUdq63TWf+5vFG2+8Qacu3Rk7fsKfRm+6vLwcvdFEfKdbSOw6C41Of1OMX/+shBLUofg7RIi/MydOnGDlypU8+OCD1VoLrF69GqlUSnp6+nWZA/+Z8fv9vPPOO7z11ltXTH4mp2eT0mdRQH4hrYQnnniiwvGLFy/y5ptvcvDgQfx+f3C35JBhI7DFZuKp0QmD2cr3339/3fO7dOkS7777Lm+++SZtO3Smdv1GlXwr/H4/nbv1wGj3oDVZGTlqDEpRG5CcU6ip36ABGzZsqPL3+uLFixw4cOCa+tcpGTmk9F4YuAfpJTz++OOV2kTHJRLbegLpg1eh0RuDFaJ33303ams4Sd3moHHFU1RSo1Lfq7Fnzx60eiMqjY7W7Tpcsehn2bLlqLV6lKIWvTsW3/QdxHeYHij20JowJdcMGHa7o3G4vNx9993UadAYhVpDRKNB2BPzGD5y9BXn8cADazE6vHhqdEJrMFVK6JeXlzPvzgWUtm7Hgw8+dNVr+uijj2jaohXNSltTWFIDiVxJYpeZeGt0+l2kH6rD4cOHcbrDsUUmIEjlGOJ9aDyJKEUt33zzzTX7r127FmtUCmkDluFILWHa9LIbnovf72fGrbeRmJpJzz79rloEdi3atO+EM6Mu9twWqETNVX2sQvw5CCWoQ4QI8bty7tw5+nbtSpzbzaDevf/r2qn79u3Do9HgkkiRCQJ1S0qAQFAWJpGQP217QO5BZ+DIkSOV+vv9flxmC4uNJlabLJi1Ws6ePcvhw4fRGMz4ynZd3qIloby8nFOnTrF9+3beeeed65rnRx99xNy5cymuUYuoZiMCQWBBaYU39FWxbds2mjRtht5sJTElnZ07d2IwW/Fm1ERnNF9RuuCrr76ifYeOGC0Bk0Clxki2qGO92YJJpSZGLueQy8Nyk4kopxOt3khit9mk9l2MWqOtlpnLyZMn+eqrr4LB5PPPP49Gb0KuNaGLTEehMRLTahwFM3bjyG1K69atycjKweZ04yss4oknnmDVqlXMmjWLTz75BAgEUPUbNQlWHEiVGmRKke3btxMeHY+7Rmdyxj+KyuIlIzsXe1wWzpQi3OGRuAtaUzBjNxFNhtCuQ8DdXS1qkSuUzJw1m2+++YZLly6xf/9+mpe2xBKRiCO5EKWoI7btZPKnPYU5PJ6GjRozavRo9u/fj1ylQRueguiIDshq5DamVt0GQKCCNyo2PiDvIRqQyFUBc8jc5lgzGxLReHDQWNFsc3D06FHWrVuH1uxEYXRhTCpG600hqce8gGlhdBZhUjmCIKCPzcUYm4taZ0SqFFEYHYRJ5UETzfwpW1FqTTRq3ARrTHogCawxESZTIDpiUGl0rFu3DqlMTvaYh8kcuRaJQk2YTIFC1FO/URNEnQGdNxmJQk1K7wVow9NQ26NxFrYNVjerbZGB6nSZHIevJRH1ehEZE8cPP/zA5ClTKSubwap77sHljSQxNT0Y0M+ZewdKbUD7sWDGbtzZDcjzFVCzbgOefvppYhKScOQ0wV3cHk9EFBcvXqR1u464faXEtp2CQqMnPTuPrVu30qy0NVq9kSbNW3Lq1CkAnJ4IDHH5RDYZGnB/z2nMwoULKzyfffr2R++Mwp3XHIvdWUnO5umnn8Zg9xDXfhr2+Bxuubzz4s/IG2+8wd69e2/Isby6BLdDT9gc2A6tEvnll19+t/P90YQS1KH4O0SIvysXL14kNyWFJkYThUYjnVu1rla/Z555Br1ej9Pp/Mvqm14vk6dOxxKRhLuoLQaztdrb5i9evMiKFSuYOGlyMIa9Hi5cuEBJrbqYnOHIVBrcxe2JaTUercFUQXbg0KFDiDoj+VO2kj3mYWRyBd6cwI64xC4zKaxR57rP/e+MGD0WW1wW3rq90BnNVZo0vvHGG0TGxGO02Fi+YkXw/ydPnoKnZueA90z9fvQfOLhCv19++YX2HbuQkpHD0mXLKo2blpVLfIfp5E/dhsUTc8V1jajVkznsfhK73o5CZyV7zMNENuxPUlom2Xn5mO1OPJd3HLqL2jB16jQ2btyIN7M2BTN2k9TjDrLyCiuNe/78+WBstW3bNmbMmFGlb9LCRXdhjUohpvV4DDb3dVXMb9q0iYxcH42btahWMvj34uTJk7z++usU16yDI7UGrpxGxCelVBlb/uMf/2DWrFm88cYbAMyePRt3QavAOqvRwOuScvk9iYxNQBueii48FbUtgtqX12hX4ocffmDp0qVs2rQpJHH7BxFKUIcIEeKavPHGG6xbt+6G3v7/GZg/dy5xbjc6rRaZTEbnzp359NNPadK8Jfb4bJwpheQVFF+xeuLNN9+kKDMTX0pqMDC6cOECLm8E3pqdcftK8UREs2XLFhJT0nDGZ6E326sMtK7Fc889F6imTi/BaLFdVR98zZoHMNg9KI1OlEYnos5Ax44dcRcGErGRTYfSuVtPLly4wPbt24NBxKlTp7A7PXiK22NPq4lS1CJKpKwymilVi3Rv3556RUV4NBokMgXm6AwEiYTssRvInfQ4SrWm2ppcJ0+epGWbdjjc4dSuU4/6DZvQrVs3Zs+ejVyhQqbSYk6piUSm5Pbbb0dnshLRcABmb9xV79+7776L0xOOUh3Qzvb7/dSp3yhg/Fe2E2tcNitXrmTZsmXMmTOHRYsWodJbMMTmoXVEBZONFy9e5MMPP8Tu9KAxmEnPzOGZZ55BqdaQNXodvrJdyHVmBKkMlUaHTKVBqtIhUYjBhLCvbCf5U7YihIUxbPjIoJnkr7/+SkJyKlp7IIkrkSnQR2ehtkUSXToafXQW8Z1uCQTL6TVZt24d7dp3QKrS4KnVDaXRiVxrQaG3YctqjESmRBuRhlQpBiusE5LTsGY2RKIIaGGrrOHEtZtC5oi1gSpqlZboFqMCLwF8rVDbo4Kae/UaNaVdh45ILldcq22RKEUdS5ctY968ebh9pcHnSGOPRKEx4CrphFxrJqLRILS2cNq0acuaNWtQaXQBPb2p25BIpNV6ETV27DhEow1PbmMMZmtwwXPp0iXCJBJ803fgK9uFRm/iu+++Iz07n6Ruc9BFpuMq7kBc+6koRS3WhHxyxm7EkVaT22+fBQQqedSOGExJJYFqHnsU69atAwKLofoNGyMXdehd0YhaXfC78e/cd9/91GvUjClTp1e6ptOnT/PGG29Ucnr/bzNh0hQMNhcWTwzNWrT6XY2sRo4Zi97qxGBz0W/AoN/tPH8GQgnqUPwdIsTflS+++AKXVss3Lg+fOt0oZLJq992/fz9RUVGo1epK1cR/R8rLy3nooYe47bbb/ms+OnBZ3zoiAV/ZTmRqHVkjH8RXtguTK5J333032O6uxYuRyBUk91pAXLspWOxOtIaATJgtNpNJU6b9x3O5ePEidy1ezNBhI64qBVIV7777bkAuLbseWoOpko539159cOc2JrnnPAw2Fy+99FKF4zn5hcS0HEvuxMcxOSMqHP/xxx/5+OOPKS8vx2p3kdjldtIGr0KuElGJGuKTUoOf2a23zcSRXitQKJJcyPz58zl06BB6kwV3URt0VjclNWpVeKanTp+BTK5Ao9NfM+Fc2rpdMN72lLRn9uzZV21/6tQp9u3bd1MT0mfOnKFN+07YnB669ex9wzIVp06dYuHChcyePbvKGHfTpk3oLU48JR3QGky88cYbfPXVV5htDlyJueiM5iqT+H8Eo0aPDazVpu8gb8oWJBLpFTW9T548GShoymmANTKJ4aPG/C5zOnToEGvWrPmfecl3vYQS1CFChLgqD69fj0urpbnFgtvy3zP5+D0YN34iMoUKQRBQiQFzyLVr13Lvvffe0Pahr776iu49e6HS6HFm1EZn86CzuvGV7SKlzyKi45NuaJ4HDhzgscce47vvvrtqu+at2uIq7oDGfVnuoscduDzhmL1xJPechz3JR9mMGXisNhRhYajCJAwcNJgPP/wQszuQqMwZ9whqjZaGjRoT63TRrV077rrrLqZMnUpevg93za6Xq3ezA9XCRgtDh4+85jXs37+fxJT0QPLbEYO7VjdUZg/RpWPQWV3Mnj0bjS2ClL534arRCYVCzaBBg/AWtwtKKrRu3zE43ueff87mzZs5dOhQoFpEb0IIkyCVKfjHP/4BwGuvvYbBZEFvcRAZE49CpUamFFGIOiQyBXKtmejS0SiNTurUrRuUT+naoxfeOj3IGr0eW0oRCpWIwmDH4WtFdItRSNU6pGo9KemZCGFh5Ix7BKlKQ9rA5ci1JiIaD8JTqztag7nCPXjkkUfQeZPwle0iodOtRMYmojOYUBjsSBRqZBoj1vR6JPech87ioGu37tSuXRtzWh2iS0ejDU8lTKpEJggoFCKCVIEgkZI95mGyxzxMmETKypUrkSpFVGYPCZ1vI7H7XCQKFWFSGWFyJXKdFbmox5XbFIlchVxvI63/UhzZjejbfyCXLl2iV59+ONzhlNSqG1w4bNy4EUtEAqn9lmBPKaFx02YsXLgQlahFY3Yg6ozcdddd+P1+/H4/JbXq4kjIxRaTRqs27av9rO/Zs4dly5Zx//33s3btWg4ePMiLL75IfmEJ9tQaGCNTsdodfPLJJzzwwFp0JhtSpUjm8DX4ynahtbqxpte9vCDowJix44CAa7pEocIQl4/S7EalNweT0A2bNMeaXo/IxoORiQacaSWsXbs2OKfnnnuOjJx8Copr8v7771c57x9//JHwqBhsEfHoTZbrXrBdD+fPn+f555+/ojGRQqkiZ+xG8qc9hcZg5uuvv/7d5gLw3nvv8c477/yuifA/A6EEdSj+DhHi78rp06dxmkxMNxgZaDCSn5p2Xf2PHDlCQUEBYWFhzJ8//2//e/B7cPbsWZq2aIVSpaa4Zp1gccNvvPfee+jNdjKG3os+KhO12Y0zuYCU9Kxg4vGtt95Cb7Hjqd0DucaIzmTllVde4fnnn6dnn37MX7Cw2gZ7r7zyCtFxiTjcXtavf7ja1/HRRx8xefIUVq9efcVdXP/85z9Zt25dlZXkBSW1g8UanoyawWKC33jrrbewOlxIpTIGDRkWfNa2bt2KRmfAYHVRp0EjnnnmGewuDzqDiVmzZ7Nly5YKhVWnTp2iSfOW6AwmWrZpHzTY27p1K3l5eSjUGrx1emB0eFm3bj1ffPEFGoOZnHGPkNRjHk5P+BXvwYxbbgusOVRaXL6WaA2mq+6k/W2HpT06Ba3BxDPPPHPlG3wd3DbzdhypJWQOX4MtIZelS5deV/9Tp07Rpn0nXOFRDBoy7IqfZ8cu3YloOIDM4WvwFLdn1qxAcchPP/3E7t27/9Aq8H/n7NmzaPVGopuPJKJBP7yR0Vdsu2fPHvR2L3Htp5I+aCUO95U/8xvlq6++wmix4c2pj85s+6/52/yVCCWoQ4QIcVUaFhVxr8nCYbeXVmYLa9as+aOndFUuXbrE4kWLGNS7d6VtYGlZeSR2nY0+JgdBEOjdu/d/fL5HH30UT3rJ5e1hATOJpO5z8ZZ0oF6jJv/x+BCQGfnwww8rVVMvWLAIoysKmcZI2sDleOv0oGad+sy8fRYZOT6GDBvBkiVLiJfL+dLlYb7BhF4mCyxM3OF4itriSC2hSfOWwTGHDh+JLTYDd3EHpAoVans0SrM7oGusUKESNUFztIsXLzJ46HAiYxNo3rIVdRo0JiE5jZEjR5KRnUdk48FENhmKVK1DrrUQ3mhAQG6hqAPNmzdHpdGT2OV2nAWtsTvcvPLKK2gNZjy1e2B0RgR1hl966SW0BhPejJroTRZq16mLQm9HaXQiEw1IFSoOHTrEpUuX6Nm7LwazBZlKQ1z7achEA3mTn8Se2yyYbI9sPBitNwmjI5wHHlhLtx69UOityEQ9UqUGXUQaKX0XI1Vq0Edn4yrpiEJnoU37QLVxQufbkKp1xLQaT1z7aUiUGpR6C1OmTAUCifJJkybTvXt35FoTaQNX4Cxqh85k48SJEwwfMYLu3buzadMmmrZoSVR8EkpRi6dmZwzeBMKkchQGO7FtJ6GzRzFRb0QdFobGk0SYTEFS9zmkD1qBSi1y/vx5IqLjcBV3QKrSEiaRIlVpyR6zAW+9Psh1VsIjoliwYAFjxo4nLjEFi8NNaeu2/Pzzz5w7d45du3ZVeovv9/uZNGUacUmpdOvZmzNnzjB81BiMrigsMelk5foqLHrOnj3L+vXr2bRpU7UXQ88//zwtWrUl11eIyR2NPTEPmVLEHp2C3mgm31eA3hWDu7ANBrOVw4cP895779G2fQdMzkiciXkkpqRhd3qweKKxOz18+eWXwfHTsnKIbDSQlN4L0eiNQc1Mq8NF5vA1FMzYjdoehag388orrwCB4FyrNxLfYTrRzUbgCY+qcu6LFy/GfXkLbWTjwbS/QSPHa3HhwgV8RTWwRiaiM9lYvPjuSm28kdFEtxhFYpfb0egM13SiD1E9QgnqUPwdIsTfmQ8//JCubdsyoGfPGyo+OXPmDB06dEAQBAYOHHjDEn5nzpxh7969VcpG/NVYt249dRo0YfTYccEE6JVYsmQJjuRCcic+jiunMeMnVDaRn3vHPMxWOykZ2axatYp169bx66+/Bk2g169fjys5PyDn0W026dn51z3nd955h/FjxqA3GIltO5nUfksQtfpq7Q77rQLZU6Mz1uhUxlVxDb/xwgsvMHDwUFasWFlBOmHTpk1ojRZcyT7c3ogqz+v3+3niiSfwREQTFZvAnj17SEhJJ7HbbHzTd2ANj+f5558HflszmPGkFmG02K6qOfzxxx+jM5hxFbRGobcRXTqa6OYj6dy9J59//jkag5ncCZtJ6b0Qu8tT5Ri//vorCpWanHGPENdhOhKplNGjR/Pggw9WSPD++uuvrF+/nu3bt7NmzRrc6TUCOxrbTKRuwybcs3o1kTHxFNaoVSGWvR6GDB2Ot3b3yzImbZk2bfp19Z88ZSrO9FpkDFmNNSb9imv+Hj17IZErkYkGFBo9u3fvvqH5/rd46623qNOgMY2atbiqP1O9ho0RHTFoPImozG6aNC+96XO5++678eQ1CX72jZrd/HP81QklqEOECHFVRgwcSKnRyINmC16drtLWq2tx9uxZZs2cyfCBA4MVgIcPH6aOz4fbbGb6pEk3tfLi1unTyTcYuEVvwKrRVKiAHDJsBPaEPMIb9EMqC2j53nrrrezbt48hgwfTo30HNm3aVK3zrFu3nqjYBJLTMtDoTcS2noAzvRY169QjJSOb+o2b8vnnn//H1/Ob+YnB6kJjMHPn/AXBY+Xl5dy9dBm5vkLMdhe+opqVAvwNGzYQLZPxucvD7QYjFlEDBJx+J06azJy5czl9+jTvvPMOmzZtIiImnrSByymYsRtDeDIytZ7IJkPIGvUQMrU+oB2t1nDgwAFWrVqFLTaTlH53I1WoiWwyBG/dXshEPXKVhqhmw5FrTcS1m4IxLh+pSos1qzESuRKJXBXoExNPvYZNgoujffv2MX7CxGB1M0DPPv2IaDQwkNwubItCqUYm6vFN30HWyAeRyFXMnj2b++67D2t0KhGNB6Mw2FEYHUiVGjKG3kt4/b5IFGqcBW2QiQYSOt9GdOkY2nXqSt++fTEn18BXtgtXcQcUoo6oZsMRjXbkKk1A41mtpVbdBtxzzz3oTVZkyoDJoUSmID4xiQULFnHx4kVefvlltAYTnlrdMDgjkSpUyLVmFEYHNpeHuxYvCQbmy1esQNQaUGn0mONyKZixm+ReC5AqRVxFgUryqKbDqK3Ro5LKyBn3CJa0OoTJ5IRJZdyzejUQCLzCo2IRtXrSMzNR26Pxle0krt0U5FozGpODvMLiCovHgwcP0rRFK3QmK+aIJPRWJ3PvmHfVZ1Gj05M95mF8ZTtRG6wkp2cx8/ZZV/z+/vrrr9x9990sXbo0qA197tw5li1bxtixY9HojUS3GIVMrQt8Rg36Yc1sENSvM1qdpPReEDQm+s2Ux+/389xzz/Hoo49y6tQpTp06xfvvvx88x2988skn5BYUERWbwEMP/asiZ8CgIVijUrCl10Up6li5clXw2DfffIOoN5I/7SlyJ2xGCJPw2WefVbq2hx56CFtMGlkjH8Sd26RauwpuhFdffRWLNxZf2U4SOt+GzeGu1Obdd98lJ7+QxNSM69I8DHF1QgnqUPwd4s/Da6+9Rq+OHZk6cWKlv/Uh/sWZM2f45ptv/mvaqeXl5UydOhVBEGjYsOF1vyA9efIk8Ukp2KOT0RpMbN269Xea6e/Pyy+/jN5sJ679VBzJhYwaM/aq7WfNmoUrtykFM3bjrdWVgYOHVus8H330EUaLDVtEAnaXB09EVEBWwWxj7doHr9jvxIkTvPPOOxU8ZL788kssWi1jdHqS5XI8uc3In7IVjaFqnel/54knnsCTFijSSemziOT07Crbvfvuu2gNZiIa9McSmcTts+dUOP7BBx/w5JNPVqoi/43Tp08janUk95xHQufb0JvM5BeWENV4MFkj12KwuoI72bp270Vk48GBJG1h66tKbSxbtgyvrzkFM3YT134qojMWozOS++8PJGZHjx2HQqlGrdFdUc7m7NmzqNQa0gauILXfEiRSOa7s+thi0undtz8QKDZIzczGlVyAJTyO5qUtMbmjSR+8CrevlNLWbdEaLaT0vYvwur0orFHr6jf+Cuzfvx+jxYYjJgWrw3XNRPelS5fo1rM3KrWGnPxC2nboRESD/oF75ytlzpw5VfZzuMMDfjdTt6Ex2a+42/CvxKlTp5DJFeRP207+tKeQyhU33Qz2448/xmi2ItcYSeh0K47kQsZPnHxTz/F3IJSgDhEixFU5deoUQ/v1o05eHvfde+919+/VsSMNDUYm6A1Y9Xp++OEHOrVsyRCDkX12B3F6Pc8+++xNm2+DwkLWmgMV3+0tVu67777gsfPnzzNr9hx69O7LCy+8QJ8+fRAEAZlcQaRMxh0GI16t9ppvgg8dOoRGbySl9wKiGg8iIjqWwhq1yMzOZf6CBdw5fwEKlRqlSuTupVXrKPv9/mtWV0BgK5DGYCZ/ylYyR6xFrdFd1/0oLy+nTmEhEkFAlEpZvnx5pTbr1q1HZ7JhjkxGrtSgtkXirRt4O67SGkjqNgff9B2oLOEk97wTe25zBg0axLRp03EXtydn7EakSjGoQSyESZCpdQgSKYaYnEBlR9dZSNV6pGo97ppdAzp6iUVYbI5rXsPsOXMxRSRhTChErjFhTqkdqCTuNofIJkORqXXIlSokUhmm+HxkGiOugtaYNUbkUhlKtQab00OzZs1JTk5BpdET0XAAJnc0JTVroRB1qMxuTMk1sCT6aNq8Bd169mbVqnvYtGkTlohEMofdjyu3CTanB43OgDkuB1/ZLqKbj8TqCqdmnfoYDGakShGlyUXG0HsDGskGO0qDHalSJLLJ0IBBoagjOj4JhVKFPjormLT31uuN1puMIJUjUaix5zZHqtIikSmRqXRoPEnINEYsqbXwREQFKzPOnTvH4sWLiY1PxBKXi9LkDlRTS+WoHdHkTdmK2R1VoUo6IycPXUQKMo2RqOYjSRu0EtsVqkN+IzUzh/C6PYhtOwmJXEV8hzLM3njWr19fqa3f7ye/sARHagnO1BIKimsC0LZDJ+wJeZji81FZvahtkUhVWswptbDlNEN0RJMx7D6cmfVITElD74zGVRzQuKuO8/ZXX31F91596N6rzxUXV5cuXWL9+vUsXryYH374odK8U9IzUVm8KM0edBFpVRq9XLp0ib79B2Ky2qnXsMkVF1X/KV9++SUagwlLen2kKi0ypcgtt838Xc4VoiKhBHUo/g7x5+Dw4cNYtFpu1RtoYTDSvV31ZaT+l3jrrbcwmq1oDGaKatSuVox5s1izZg0ymYyUlJTrqoR+9NFHcSX7KJixm/iOM8gvqvn7TfJ35t5778Wb2/DytZRRs27Da7ZXiDrkoh6TxVbtopb+AwcRXrdnMIk4bdo0tm7detUk4YEDB7DYnVjD43C6wzl06BAQqF5uZrVx2O1ls8WGQSrDYHXRuVuPahUPffXVVwF96Xq9scVnM2zEqCrbrVy5knBfs+DnXLtB42pd6y+//MKPP/7I0aNHUao15E1+kpzxm5DJFbz//vvEJ6Wi1RuZ8f9MrMtm3IIjuZCUPouwRCTy8MP/kis5c+YMffoPJDUzl5mzZvPKK6+gM9mIbjEKc1QqufmFPPTQQ5w6dYq6DRojlcrIyS+8puTiww9vQGcwotEb0FtdFMzYTdbIBzGabYyfOBlvVBxKrYm8yVvIGrUOrd7IlKnTcYVH0aBxM7Zs2XJZb3wXKX3vIjImvlr3pyqOHj3Kyy+/XC0T6w0bNmCLTiVn/CY8xW1pVtoKvcmCMzYdm9MdfE7+ndjEFGLbTCJz+Bo0BvNV4/Pz58/z+uuvX3GsPwvl5eU43F4iGw0gqvEgbE73TTceb9GqLZEN+xPVbARKg43GTZv/V/9O/1UIJahDhAhx07lw4QKvvvoqX375JbEuF8/bHBx2e/FZrOzZs4f6hYWsNJn5xuWhttnMI488ctPOvWDePJL1eobr9Fi02qsampSXl6MWNQiCQK5cwdcuD8N0em677TaOHDnCjBm3MGfOnArVBhDYDmdyhuObvoP0waswWW2BAK1OD6yxGcgUKrJGrSNzxFoUSlUlk4r3338fu8uDVCanfacuV/0B/OmnnxC1elL7LSGu3dSraqBdiV59+2OJzcCcVheZUk2ffv05c+ZM8Hh+UU28dXoi11kIr98Puc6CPiab2LZTMJqtiDoDctGAXGsmofNtAU1fUcvevXsxWmw4E3OQKkU07gRERwxqRwwypYjF7kSqFDEn10CuMaKxeJHJFDh8Lcmf9hT6mGxsDtc15//ll18iV4k4C9uij8pErrMiSOXIVFqUWgNqjY6knneSMew+JDIFSrMbi1LkQbOFRmo1wwcMrDDerl276NGzNxFOJ2ESGZaMBuhjcohpORapXMWIESN49dVXAVi+fDnu7PqBauZmI5CqtOijslCavehjcpDIVci0Ztw1uxAmUxDXbgrhDfoj11lRWyMIb9Cf8Pp9saTXu1yhMS2gPZ3ZEKlKS1y7KRji8hHCJNhzmhLRaBCCTIHGk4SzuANShUhyzztxFrZF44pHplTTpVsPvv76ax577DHqNmhCbGIK9sR87HmlKPRWcic9jtERTmR0LMb4fGxZTZAr1ezatQsIBIuSyzIiMa3GozS5MSfXIMdXdMXP4Pz58/QfOBiLw4PB4sCa1ZjkXvNx5JUyY8aMSu2PHz+OQqnGV7YTX9lO5Aolv/76K1q9keyxG8ga9RBhMjnxHaYT2WQIEoWIVK0jKycvYKhZrwGizoA5uQSpUs20adOuuVjy+/1ERMcSXqsL3lpdCY+KuaEqshUrVmAMTySp5zzcRW3p23/gtTv9jqxadQ8SqZzcCZvJGbsRmVxxw8Y3IapPKEEdir9D/Dl45plnKLQECg/+YbOT6PX+0VP6U1K/UVOimo/AN30HjvjsmxpbV4fnn38eo9GI3W7ntddeq1afffv2YbR7SRu4HE9xW1q363jtTn9SDh48GNCWzW2EwerigQfWXrHtkSNHEHUGknvOI6rpMGITkqt9nslTpuLMqEvWqIewxeewYsWKq7Y/cuQI7dp1wFPSMZDULmjF9LIyIGCWadFqmaDT4zMYGNyvHx988MF17Wx98803GTRkGPMXLKxS5uXbb79l7969wd2FZm8c8xcsuua496xejUrUoBK1jJ84iX4DBqG3OtGarEyeemXpirNnz9J3wCASUzOZMnV6hWuZOGkKjtQSknvNx+yJ4YknnmDbtm106NyNufPuDK7HFixYgD2lmLwpW3DlNGbCxEkVzvH888+zevVqDh8+XOH/jx07ht5kIbLRQFy5jfGEh6PUWzCn1kYfnY0xsQhvjU6V4u3z58+TnVeA1uxAoRK5c/78a96fm8Hq1atxpgV2kEY1HUppm/YcOXKEF154gddee42GTZpTt2GTSnrar7/+Ot7IaLR6A/MXLKxy7GPHjrFkyRKi4xKxeGLQ6I03VW/5wIEDvPXWW1eM83/66SfaduhMZm4BDz74ULXG/Pjjj2nSvCWNm5fy0Ucf3bS5/kZp63ZENuhH/rSnsMdlsmHDhpt+jr8Df4kEtSAIawRB+FEQhI+q0z4UIIcI8cdx/vx5aublkWQwYhFFGtaqRbHBwCC9HqfJxNGjR3n66acxazQkGY1kJyVVSgD/J/j9fjZs2MD06dMruFxfibzCEtTWcARBIFoqxaxW89RTT2G2OXDkNMGRXosatetV6HPp0iVq1W2AxRuLzmSlV+8+QR3qlD6LkKm0ZA5fQ8bQe1GqxUoBW+16DYlqNoz8KVuxRiSyY8eOq85x/fqHcbi9RMclBrVyrwe724tCb0V0xiKRq9C5Yxl92UwOoEfvvmidMbhrdLmciB2OMaEAb53uxCUm88orr/Dhhx+iM1rReJKIaDQQR1wmzzzzDD/88ANPP/00e/bsQSpXIlXrkciVLFu2jO+++44pU6bQsmVLVFojOrmSFhodSqUaQQhDqhSDUh7vvvsud955J8899xwQ+BwXLVpMrXoNKSoqRqbWorJGIFPrkYkGskevR2+PYPfu3Tg94ST1mEfO+E2IOiN6o4kGapHDbi/3mSw0LCrizvkLsDk9ZObmc9ttM/9Vca1Qo7KGk9RtDmkDlyNVqHHlNUVnsvLUU0/x008/4YmIQm1yBhLQl7cAChIpMrUe0RWHXGfBltsiWEWeM/7RQBW5QklUi9HYsxshkSsD8iF6G6IzHlNiEabEIgpm7Cah0y3ozTa0zhj00VmoHbFIVTokchWiPToo/SE6YlCbHLz88su8++67KEUdSrMbqVIkbfBKCmbsRmVyYU2vi93pxhMRhSW1FhpXHKLVi85oYdu2bYwZN4EwqZzwen0omLGb8Hp9cIdHBrcCnjp1ipGjx9K8ZZugAeXU6WXYE/OI71iG1uwgTCpHdEQjkSt59NFHKz1z5eXlRETH4q3ZCU9xOyKiY/D7/dRv1BRXVn1chW0q3K8wqQy1Iza4xbWsrAxXcYfLch+DkCjUKFRqFt215IrP+cmTJ5ErlPim78A3fQcKpZq33nqLPXv2cO7cuWp/X36rnAmTSEhMSf/DjWHPnDmDWqMjte9iknveiajV3/SqjhCVCSWoQwnqEH8Ojh07httioYfBQJbBwLgRI/7oKf0pad6qDRH1epM3+UmsUck8+eST//U5fPLJJ8TExKBSqSpItV2NWXPm4omMoU6DRhVM7f6KfP3119xzzz3s27fvqu3279+PwerCN30HmcPXoDear9r+/3Py5EmatmiFyWqnS/eeV9X+3rdvHzqjGb0jErloIH3wPdgT81m8eHGwzVtvvcXo4cNZunTpTY8txk+chFqrR63RMXrMOCZMnMT48eOZO3fuNROAoiYg/5Y7YTNqrZ5vv/2WDz/8sEqjxepw4cIFWrVrT3SLUQHpuPzmLFxYdXJ15MiRWDMCxSnOona079g5eGz5ihUYbG48OQ2w2J2Vntm3336bjp270aFTZ1TagKeJLjIDucaEUmOgboNGlRLbAD1798UclYorpzHu8Mj/ipTRiRMnSE7LwGhzYzRbefvtt4HAGszliSCy0UCimg3HbHNcl8b8mTNniI5LwByTgeiIxle2i8Sus0jJqFoC5npZuGgxWqMFkzOc5i1bV/lCpVXbDrh9pSR2nYXOZP1TyJB8+umnuDwRyOQKGjZpfsO6/X93/ioJ6lqCIOSEEtR/T1avWkWLunWZOWNGaNH9N+C5554jw2jikMvDYxYbaVHRrFixgunTplXYAvTdd9/xxhtvXFfi6Pfg0KFDNG5eisVmRxAE8vLySIyMRKHUUDBjN/lTtxEmkVT68bt48SIvvvgi+/fv5+DBg+iMZjy1u2GLzaB+o8YoVWqUKjVrHnig0jlr1KlPdItR5E/bji0qhW3btl33vE+dOkWnzl1QqjWIooaOHTuxZMmSSluF7r9/DXK1ljCZAqXJhT2/BbrIdOo3bhZsc/z4cYqKayBVagiv1weFzoLV7kTUGbHFpKE1Wli3bj3jJ07GEp6AM7MeGp2B3n37VzBuPHbsGNu3b+ezzz5j69atzJw5k3feeYeLFy+SlJKOXKHGkdmQyKZDkaq0OLMbkZqZTXZ+EUpRg6ewNXqLg0cffZQHHnggYAApGlEYnZiTA2Yi4Q36ozS58JXtQmvzEBefQPv27VFrdMjkCiZPnc6BAwcwqtXUVqrQh4XRsGFD9GY76YNXEV6vNxKpnMzha8ge8zByqRxRpkChs6JxxeIsbBtM0nfp3guA7j17ozLYUBgc2HOaYozLRyJXkT5oBb6yXSiNTiRKHRKFiOiMRWXxIlVpUKlFimrWIS0jC2NUOp5a3TAmFBImUyJIZSjUGtw5jVDpzdSsWZO09AwM8QUk9bwTrTseU2w2ans0oiMWqUqL2hGLXDSwdOlScvMLkGmMpPRZhDWzIUqzG0+trog6A6NGj2bnzp2Y3VEUzNhN9tgNyNQ6YlqOpbR1O2rUaRBIsIsGHAVtkCjUFV6SdOvZG2dGbWJajkVrNHPgwAGalrYmpvX4QLCe0wR9REogedxwAN169q7yGT148CCNGjdFrlQjVygZNGQYx48fZ9LkKfQfOIic/AJUFi8KvQ2pSotK1AWrvNevX4/S5CSxy0y04alI5CqSe89HrtISHZ/MxMlTK1VN+P1+imvWwZFciCOliJi4RLRGC7bIJLJyfdf8W+P3+xk9dhxSmRyL3Xndevu/J5s3b8Zic2Jzuq/5QivEzSGUoA4lqEP8eTh06BDz5s1j3bp1/zV95b8an3/+OdHxiUilMjp36/GHral+/PFHiouLEQSBuXPn3lSfmb8L5eXlNGjSDLMnBp3Zzqw5cyscv3jxInfOX0CffgOumey+Go2atiCm5VgKZuzGnOBDJWpo26HTf2Xt9dNPP6EUNeRO2EzWyAdRKFWsXLUKo8OLp6gNOqO5ymTzs88+y5w5c9DqjaT0XkjmiAdQiVp++umnG57LvPkLkCuUKNUiKlGLJ60Es81xRTmaMWPHIteakOusyEQD9Rs2JDwqFqPFRnhULIldZwWS3Bm1rlgF+/DDD+NKr0H+lK1IlRriO0wnpuVY7E5Pld8Js81B1si1FMzYjS0igddff/2Gr/d6OHbsGHkFRUhlcmrWqc+JEyc4d+4cEqmM/KnbyJ/21HXf/7fffhurN5bUfktQ6G2B9VedHtRp0OimzNlgtpIx9N7Ablyrk48//rhSm5SMHJJ7zgv4FyXl/WH69idPnuSll14KSgr6/f6Qj8I1+EskqAPzFKJCCeq/H9u3bydap2OVyUyBwcCdc+deu1OIPzUffPABTo2Gp212JhuM1CssvOnn+Oyzz3jyySc5cuTITR33wQcfRCqVIg0Lw6FQ4fa1wpxam7yC4mv2fe+99xg9dizLly/n0qVLXLx4kYsXL1bZ9q233sJgtiKVKwkPj7qqDAkEzObefvttli1bFny73ay0NfrYPBwF7ZAo1FjT62FPKqBJ85bBfh9++CEavQmZqCdzxAPEtB6PXGNCIep49NFHOXnyJCdOnACgS/eemFNqYs1siMETT6dOndA7Ikgfcg9J3eagNdmYv2DRZSPFOFy5TXD6WmIwWYIGdb37DSA7v4guXbthdITjKQloB3/44YecOnUKpVoTDL7U9ijC6/dFqbeQ0OlWVBYPcW0nE9ViFNl5PjKyctBFZ6FxJyBRqBFdcWSPeRhrRoPL2thG5Foz3jo9kSo19OrTl08//ZRhw0cyZtx4RK0OT+0eJHSZiUKlxhqRiK9sJ4nd5yCRyUkftILMEQ8QJpUhU6gwJ+SjUGsRTQ7i2k1FdMRQUFTC8ePHkSuU5E1+krzJWwiTSHG4vag0ery1e5DU4w4kchUSpYhUETB+lKg0hNfvhzejJps3b2b+/PkY4/Lwle3EWdAapcWLTDSgMtqRKgLV5DK1DrXFi0wpojDYkCrUaHQG7AnZhMkU6KKziW4xGltiPmPHjkXUWzAmFAa1Dk02F0OHjQi6U584cQKjxUZEg35YMxuiccVjT/IxdXoZ9913PyqtkTCZgjCJlOYtSimsUQuHO5xhI0YSn5xGSp9Fga2gKYVs2bKFzZs3ozPb8eY2Qq3VYw5PIGPovRgjU9EaTChFHaJWz7w7K25LjIpLJLHrLHInPY7B6uK9997j4sWLHDx4kNOnT7NmzRo6duxIv379KizC/H4/8UmpKLQmpCodUqUGQ5wPQ0wOqf2WYI1MqlL7+vTp06xcuZKVK1cSFZdISu+F+Mp2YYtKDlbnX4m3334bg81F7oTNxLadREpG1hXbXrx4kVdeeeWaEkIbN25k0aJFf3gVdojrJ5SgDiWoQ4T4K/JnSOCfPXuWzp07IwgCffv2rbYs1Zo1D9CuU1dWr773b5/YvnTpEi+99BIffvhhpWPjJkzEFpdFRMMBaHQGHn74YY4dO1atcT/++GMmT57CqlWr6NazN56ClmQOX4PFG8eWLVuqPb+zZ8/yySefVJAEvB6OHz+OStSQPuQeUnovRKs3UK9RU+LaTwsYQ/qasXz5cvx+f/BlyubNm9FbnXiL26MSNYhaPUqVmqVX8POpDh9//DEqjY6s0etI7bcEjd7A448/ftVq/TVr1mCOTCau/XRscdmYrA7i2k4mffAq5CoRW1IBce2mojPbKslf/MaRI0ewOlw4UkuQyJXkT91G7sTHkUplVb48atikOa7shkQ07I/BbOXo0aM3fM3Xw8yZt+PMqEPe5C04M+pw62U977YdOmGLSsEem06Dxk2v6/t49OjRgNRJ06HoI1JQiDpyC4quS5/+asTEJxFdOprUvosRdYYqNcJX3XMPerMdV7KPiOjY6zZw/XcOHDjAhImTuOuuu6r99+y7777D5YnAHp2Mzmiu4AUU4sqEEtQh/lDmzJnDAIOBw24vdxiMdG8fMj75O3D3XXcR5XBQIyenWsZm18Nzzz2HzmjGnVqI2ebg66+/vqnjP/7444QJAgaJhDilGpfN/h8boPn9fn788UfOnz/PpUuXAtWQBgODdXrGGozEeqp+m+73++nWszdSmRyJXIU1owEKtZann34arcGIXGNCkMiQiQYKZuwmd9LjwQqFpqWt6T9gIGZvHEqjk/yp20jpexcKUcuePXtYvnwFSpWIUiUyZ+48atWtF5BR0NuQa4woRS3mlJpI1TrMKbXQRaShtTjp3LkzEqmMtIHLkWmMGGKyA0lZqRydK4bEbrORqTTINEbUtggMcfmU1KhJeXk5AwYNwRKZjDmpBJlai1ylwZrVOPB2u7gjxoQCNGYXelcM3nq9A4lfhUh8hzJsl40ERVc8aq2exJR0opuPvNy3A25vBFaHC2dRO6wZDQKyFwOWkTN2IyqNjpz8QszuKDR6IyNHjkQlalAoVbRu0xZzgg9f2S7MSTUIk8qQKjUY4wuwxmawYsUK9CYzce2mEtd+GmEyBQpRh1qnR22LRGlyIVVpsWY2RKLUIFXrUOgsuEs6oVJrWL16NevXr0eh/ddnJVFpMSXVwF2rG1pvMvnTtuMqao8hLh+F3oZv+g5S+y1BqhSJT0zCklSEwmAnTConPSuHbdu2YXRHozS5A9XFCjXFlx2/f/75ZwYOGUpp63Y8+OCDlw1PrIh6C61atw1WzTz77LPcdttt7Nu3j8bNS/HW6BQIvDUmFCoRozMST24TtHoTBSW1mT7jFl566SXuuecePvvsMwYOHord5UGmUKGyhBPTahyZw9egNVgqJG2j45NI6HwbuRMfQ29xsHfvXuKTUtCarLg84Vd1GD9z5gxGi53oFqMCzuhyJZaM+mhc8SiNDoYNG3bV711J7bqE1+lBSt+70Jms7N+//6rtX331VUzOCPKnbCWxy0ziElOqbHfp0iVq122AxROD1mhhWRXGowBjxo3HEpGIO68JDpe3WoY1If48/N0T1NeSzxMEIUwQhLsFQfinIAgfCIKQc60xQ/F3iBAhfsPv91NWVoYgCMTHxzNz5syr/g4++uijGB0RRJeOweSOpqysDE9kNAazlVX33PPfm/hN4uLFi6xZs4b58+dfd0FNbkEJSd3nkDnsfkSZnDSdDpNWy8yZM6+aqP72228xmK14anTCFpNO/4GDqV2vIVaHi1FjxlY7yfjtt9/iiYjC5AjH4fJeNVa7GvevWYNGp8dotrJ9+3bKbrkVW2wm0S1GoTPZWLduHS5POFKpjL79B9Khc7d/SXCUdOD222//j164jB47DqVaRCJTkDPuEdIHr0LU6q/Zr7y8nPETJ5OUlsWgIcMwWWykD1pJ/tRt6CwOOnftRu0GjYMSd//H3nmHSVVkfbg6576d8+Sc8wwDDDnnnHPOOcOMIqCgGDArCoiiKFFZgnER84LiKoKIKIKKIopIZph5vz+a7XV2iIbV9ev3eeZ5YG5V3bq37+05deqc31m27DHSsvJo1bZDleLbX3/9NY888ggldetjD8Rh8UQwbMSoS57zxx9/ZNz4iXTv1eeyTu/fg2nTZ+Cr0TZ4z2u0Z9LkKUDQ1l23bh2rV6/+RVIU77zzDm07dGLg4KG/Kvr9UuzcuZPk9Cx8EdEsX/74Zdtt376d1atX/2r7+7vvvsPqcAXfq8Q8+vQfeE39br/9dnx5wXVuVNNhdOne61fN4/8LfxkHtRBiiBBihxBiR2Rk5O9wq8L8HnzwwQfYjUZ62Ox4jMZfJHUQ5v8X7Tp1CTkmr6Qf9mt46qmnUKlUWCSJHTt2/Kqxzp07R90GjdEaTNicbho3bY4jOgWDL4F8vYnPPT40SuUldbi3bduGzReNp0YH/HV7XZS4GEhBUTEOT4CYVmPJm7wKuUqLr3Y3vLlNSUrNwOqNIq7DVGyBBFzeADopKKGg1hl44okVlJeXo9ZoyRq9lJzxK1BrdXgCUST3vJnCWRtR6aWQPrG/bm9URhvxHaaj1JnwFLZFoTEgUyjROiIomPEcUc1HYEutg1JvJqXfQuQqDemD7yWuw1Tkah1mVwTr16+noqKCJ598koULF7Jq1Soef/xxjJKNQH5TdAYzJfUa4PAESOh6A0VlW7Cn1UWhVOOp0YH0IfcHtZ5zmqI3mjGZJRQ6ExENB6DQmWjeohVKrYHC0s0UzNyAEDJUGi1KlRp/dBxJaZncddddoSrSFRUVHDp0CJXOgEKjD0Zia43kTV1zMSXNga+4PWVlZbz++uuodCaUBguxbSchxeaiUmtRaPRoHZHEd5iGu7ANlqRiErveGIyGNphwp9TAHoinZeu2qI0WPDU6oHPHYQykoJbcQRkQewSFpZsJ1O+L1hmFXK0jffA9RDYZgs4ZhdnmJqn7HApLN+FOyGH16tWUl5eTnVeAXK1DrtbhqdEBld7M/fffj9XpwZHZgOgWo9HqjZitdrzFHfHU6ICQK9BodSxbtoznn3+e/Bq1aNSsJamZOSR2m01h6WZMURk4shpTq6QuAwYMQHJHkND1BpyxGSy8vWpRm08//TRYqNLqJbX/HRTM3IDk8oei/CFYSMYkWVCq1IweN4FbbrkFb07j4DWXdGXo8Ms7mYcOH4lCrSNz+MMUzPwbBqsTmUJJYtcbiW07EbvLc8l+/4pMOXDgALXq1CcqLvGaFrcVFRV06d4TrcGEwSzx/PPPX7Ldjh07sHqjKJy1kfQh9+PyXbpgVyA6loyhQW1wT3wmr7zyylXnEObPw/8DB/UV5fOEEC2EEJsvOqprCCHeudqYYQd1mDBh/pO0hARkQmCUy0mLi7usw3HChIkE6vcNyoc1GoRRshHfaWbQqXiZKMnfgzfeeIOC4trUrFOf999//xePM7h3b4okC10tFmK83utK65990xzsEYlIvkSGG4xMM5mRq3UYfIlo9EYOHTp0yX4bNmzAl1pEUdkW0gYuIiEl/RfNvbS0DF9h62Ckc+0ujB477heN85+Ul5cz75b5dOjSjfXr11OzpB7RLUaRP3UtNn8sI0eNwh6ZREzr8UhOL1u2bPnF5zp48CB6k4X0IfdhjEgLrlt0hks6NN99910aNmlO89Zt+eSTT6odf+jhh9EbJcw2F5279aji6P/www8xWR0k97oZf3F7mrdqU61/RUUFf//733njjTf+dJkBX375JYHIaCSHB19E1GWfrf/PvPLKK3gSsigq20LG8IfwR8VeU7/ly5fjiEkja+SjeHMaMW78xKt3CnNF+1sp/ocAHhZCPCyEEPn5+fzB0wlzjWRkZIjXt28Xr7zyihidmytq1KjxR08pzO/EuXPnxObNm4VOpxNNmjQRMpnsF42TEBsr3tr4ujjhjBJnvv5YREcP+I1nKkS3bt1EdHS0aNGihWjTpo148cUXRWpqqhBCiPPnz4sFt94mdn/8iRg8oK9o0KDBFcdav3692HPoO5E5fqU48u4m8crLS0TOxKeEXKES793aUXQ/fUrULS4WRqPxsmPonFHi8Furhc4ZJY5+8LLwx/tFfHyc+FYmE3KVRhjtbpElnRKpNTJFRUWqWPXut8KRXl9cOHVc1PGcE926dBKAKCwsFE6nU5w7d05cqKgQleXnhABRXl4uvj92XGi+PyS0dp+QcUGc3PeGOOaMEqc+fVPIK86JQy8+LFRGmzj1zWfCklAoopuPEPtWzRVfvPCIOPv9IWGKTBMnDn4ovnnlUSFXqITOGSnkKo2QyRVCbbSJefNvFavXPSvmz5sj/H5/6NoyMjLE9u3bRUnJInHj7Dni3V2fiFOvLBNnvv1cHP/sPSEl1RBH339BfLdzi/B5PeLonteECyG+k9xCa1KLw2+tFbLKC8JsNgkqLoj96xeKyvOnhUKrFyajQVQihCqlqRAWr5hZeoPo06ePEEIIuVwuduzYIRByEdl4gDj2yduCygpRef6suHDmhKg4d0ac2/+W6PvEQhEbGyuSEmLFUV2scGY1EuePHxHlP30npMQa4pt31otv/7FOVFy4IPx1ewlrUg1hDKSIs9/sE1GdbhDnfvxGbH5wuBAymTiyY6NwZDcSx/e/J7JHLxFnv/9KfPToGLFjfnshk8uFzhUrzv3wtdj92BShkVzCYHOLzEhJ/GPzXeK4M0LoOS0aN24slEqleOn5zSIlPUOcUVrF97u2Ckd2UzF63EQhV2tFSu3uQueIEN+8s078dOywOPnuZkFlhdA5IoRGcomBQ4YLtVolAs3HiG+PHhTyEx+LbzcsFAc1JoEQ4sLp4+KCPkL4/X5hiK8hbEnF4vzxI+L9Dz6s8lz6/X5RWXFBiPNnxZ7Hpwm5Ui3kQojvv/8+1KZ+/fri2PdHRXl5udBqtWLRokWi8twpQUW5qDx7Umi1fnE5nn76GeGp2UnsXj5FyOUKkZWWLD744ANhjEwTR3b8Tfxw9Dtx+PBh4fV6hRBCHDlyRDRq2kLs+mCnKKnbQGz+27Pi9VdfEUII8f7774uCGrXE2XPnxF0LF4iGDRtWO59cLhdPP/mEOHLkiDAajUKv119yXna7XZw/9ZP47v0XxeG3Vgv5hdPirbfeEsXFxVXa5efli3feWSU03hRx6uiXIjEx8bLXGibMfxtgm0wmi75Ck7ZCiOUXFwtvy2Qyi0wm8wKH/zszDBMmzP865eXlYs+nn4qnbA4x9Nj3Yvf+/WLTpk2iVatW1dq2atVSLF7SWYjzp8Xx3X8XVFYIvTNKaCxuoVCqxalTp373+Z49e1Y0b9laOOr2Fye+2CXq1msgvv7q0GXtgSuxYcMGsV6jFQGlUjQ9c0rs2bNH5OfnX1Pf0lkzRWxMtHhs2TLx0TuHxc4LiLi2E4Utpbb4+IkZ4pZbbhH33XdftX5ZWVnixNf7xNevPSXOfrVLtG9Q57rnLYQQJpNRVJz8Xlw4e1JcOHFUSObkK7bfsWOH2Llzp6hfv76Ij48XFRUVYtKUqWLjlhdEQV6OaFivrsjLyxNZWVlixrSpoX5zbrlVKLQGIVOqhVypEi2aNxcJCYli2xtviU6L7hBNmza9rnmfPn1a3HHHneKbI0dE186dRGXFBfHxipnCllxLlJ/8XkwYMUj07t2rSp9z586JRk2bC6mwq6g8c0o0btZCHNi/r0qbIYMHi1YtW4oTJ06IxMTEKmvYgwcPCoMjIKTYXCFTqMRnOx6vNi+5XC7q1at3Xdfye3Hq1Cmxe/duERcXJ2w2m/D7/WL/vr3iyy+/FIFAQKjV6j96in860tPTxdkfvhZfbX1cnD+yTzSue23vVY8ePcTrb70t1q+9QeTl5YnZN5b9zjP9f8DlPNd/xI8IS3yECfM/S0VFBTVL6uGKy8QeiGPw0OG/eKxTp07Rd8AgUjJyuHH2Tde0E/3tt98yf/587r333usqDPLBBx/g8XjQarWoFQqSo6Lo3a8/rsR8opqPwGixXVU2YM2aNTijU4ORxo0GYpBsRDboR3SLURjMFh588MFqhQ3/RWVlJb369kehVCFTqFAZJNRaPW+++SY7duzA5nCh0mhp3LQ58UkpqDVa2nfshMFsIaJGW4wWeyj6YNu2baxatYqffvqJPv36B6UmVBpkciUqo530QfegUOtQKlS4VWpio6KpXa8RN98yn8lTpmD2J5LU/SaUBgu+2t0oKtuCI7MRktWOSmtArTeh0OhQKFWkpGdhtDqRq7RoTRYUai1RjQcRqNWJ1IzsS17r5KnTUeklknvPJ7bNBDRWL77a3bGn18NXuytJPefh9kfSw2pDIZNTMHMDhbM2Ileqkat1BOr1wej0B++VXIHBm0D6sAeRKZTkjHuCwlkbMVqddO3Rk+69+rBr1y4+/fRTVBo9arMTjc2PUKiQKZTIVRrMFjt5RTV54403ANi1axc6oxkpkIRCpSWu/VSKyrYgBZLIycnF6fKg0BqR4oORzTK1DldeS7xFbZGrdeRNWUNyr1uQKVTI1TpS+y0kqtlwTFYHaq2OnHFPkDVqCTKlGrlCSVJqBr37DeDEiRPs3r2bzZs3h6LsH310CQ2btmTw0GGotXqS+9xK+tD7ETIZ7oI26D3xWJNroTJayRq9DJXJjkyhImv0MgpLN6M2OzFaXRSWbiJ7zDLMVjv79++nuFZt5God0S1GY45IISI6Dr3BTER+M4wWOy+88AKffPIJSakZ6I0mmjZvSXRsPHqHH70njsyRjxDbbgp1GjQGgum6MfFJZOUV8MEHHwDB97d+o6bI5Qpy8ouumPZXs059fEVt8Nfrjd5o5ttvv6V9py5ojBak2FxcOU2Iio0PacG1at0GvSsGf93eOJIKufPOO0NjeQORxLQaS0KXMoxmy2UjmSorK/nxxx+v+r3yyCOPolBpiGs/hbj2U5Gs9mqagj/99BNjx02gQ+duf6qCi2GuDfEXj6DmKra1EOJvQojaP/v/y0KI/CuNF7a/w4QJ85/kpqTQX7LQ02hCqVCg0Wh46qmnLtn2jTfeYN68eWzbto377r8fvVHCZHXSs3ff3zzydM2aNTRo0pyRo8eGbIJvv/0WrcGENaU2xog0jBGpFBbX+kUyEy0bNKRQpyNGb0KvM/Dll19e9xhnz54l2utDodHjyGpCav87UBmt3HzzzZft8+677zJs+EhuvfW2XyTNAEFbrWmL1mh0eurUa8i2bdsuO/+NGzditNgJ5DdFb5Jo3bY9derVxx6TTtrARZgi0pD88ZisjmpFnl9//XXMFhs6o5lmLVtftnbPtdKuYxfcabUI1O2J1eGie48emCIzKCrbQmLXG4iIjqsmDfn111+jN0kUztpI/vT1yOWK6yoweuLECWITkvAk5WKyuX6xHM0nn3zC66+//os/s2vh66+/xhcRhTKqF3oAAQAASURBVDMyEcnm+FUZAv/f+Oijjxg9dhwLbr31v1Jk9P8zV7K//3DDOTQRIZ4SQhwWQpQLIb4UQgy8UvuwgRwmzH+f8vJy3n77bfbv31/t2GeffYbJGtTWzZ30DCq1huPHj19S1uK35uzZs0RdLOrnSiqgdfuO19X/8ccfRymToZfJ6GswYLG5SO51czDtLbseK1asuGL/8vJy2nfqglyuwB8ZzQsvvECrth1o1KzFJTXGTp06xYoVK3j22WdDBnHpDTdi8cbgLWyN2WILpV99+OGHtGrbAW9ENJEN+5M76Wls/ljuu+8+7rzzTt566y0A5sy7GYsrgDe5gMSUNFLTM3BkNaFw1kaiW41BZbCQ2O0mHHIFHrkcj1yOXiZjwa23AjBoyFAiGw+mqGwLrrwWKC7KOii1RlatWsXhw4dRqTVkj32cnPErUKk1bN++nZtvvvmi9psGd2Fb8qetR6FQVllkVFZWcvDgQRRKJZ7ijujdsXhqdEB50dmt0BpIG7iIQP1+GC12bDodBqUGU0Q6GosHpUaP96J2WmzbieQX1USpM5LQpZTC0s1orF5UJjsaqwfJ7sJb0JKIhgOwOd2cOHECq8OFt2YXfCU9kKu0ZOYUYDBbiW46jLh2kzFbbOzdu5f33nuPb775hhdeeIG0jCy0Nh/2rEbIVVrsaXVwJRVic3owBFLROYLOUJXRQnxCEjKlFktiMXHtp6FQqVGqtaiMNlR6M0OHDmXKtOkoVBqETBEsjuiKxChZefHFF6s9H88//zwWl5/4jjNwxmdTo2YJOoMZjU6P2xeB1uLCaHOj1OiIaTMhWH3b5sdstePKD1Zz1+qNZObk447PwuqJZPLU6QDcfffd2FNLQoa81hGcxx133BF6Vus2aExUo4HkjHsCtdmBFJGC0+3F6PSTOWIx/uL2dOnWk2+++Qa9SSKlzwKiW4wiLjGlynVc68ZSn/4Dad6qbahAUEVFBUqVivypa4MbBA4v+/bt45133kFjMOPKbY7s4kZD/YZBR3lFRQUKpYq8yasomLkBvclyyYXW999/T2pGNmqtnsSUtCoVt5cuXUbP3v14/PFgYcaTJ0+iVKnJn76e/OnrUak1/5XvszD/PcIO6mtzUIuwxF6YMGGuwDfffMPYESMYMWgQ7733HiUlJQghmDNnzlVtgS+//JK9e/f+5s7pnTt3YrI6iO8wDU9GHQYMHgoE/943b9kGIWQUzHiOwtJN6E2Wq8qLfPzxx/Ts04/Bw4aHiu+9/PLLaI0W4jvOwJVSzKgx437RXOs1aoqvpAcqow2FxkB8Usov1mUuLy+/rr7nzp2juFYdrJ5IDCYLq1evrtamY9cexLQcQ2K3G5GrtATq98XoS8Bbs3NwrdSgH+6CNsS0Hk+b9lVrTX311Vc88MADrF+//jf5jB1uL1mjg8XYXTEpPPPMMxglK/66vVGodVhjMjBJttD6CIKfee26DXAlZOOMTqVztx5Vxvz2229p17ELOQXFIc3p/+Snn35i/fr1VSTurofFjzyCQbJhD8RRVLPkd3FSnzx5kvHjx+PJaXJRRmcgPfv0+03GXrToHtKy8ujWszfHjx//TcYM8/+X/wkH9fX+hB3Ufz3ef/99BvXuzbRJk/jpp5/+6On8adi6dSvTp037w7W7z58/T4PiYhIlCbtez9IlS6ocP3HiBCbJSly7yUQ2GoDL7sSgVmPUaFj8Oxc+2b17N1Z3RLCI4ORV6PTG6+r/3HPPkWaWSFAqUQqB02bH5o/DV9wes9V+TUUat27dSou69ejdufMVq0ZfuHCB4uxs6lhtZEgWhvXvD0BWXhHJvRcENaEzS1i5ciXnzp3D4fYS2WggWnuAuPZTKJy1EXd8FmvXrq0yri8yhvQh95Mz4amglrJGh1ylxRSThVytw2i2oFFp0AnBaKOJQ14/bXQ6YuISgGD0tVGyEshrjEZvxOTw4kouwuZ007p9J26aOw+NVk90i1FEtxqLUqVm6LARGCUr6YPvIW/qGhRaI7ao5JA22+nTpzlz5gw1S+qh0hkRQoZcpUXIlciVKt58802OHj2KQq1FoTUh5Arkah02pxuZXIExIpW0gYvQe+JQa/VENhqExuLB5nTjqdERpc6MxuZDZbThyGmGUqVCqVKTN3kVhaWb0Zrt7Ny5E5lMTuGsjRSWbkKmVNGuXTsUCiXZY5eT3Hs+Ko0OvUnC4o6gboPG3Dj7JnQWFxqbD2dOM5R6icLSzeRPW4dcoUQrOYluMYqisi34anVBZzAS0XAA7sK2KLUGbr31ViZOnIjeZEYIgcZkQ6MzUKduPVRqDeaYHIrKthDXfgp1GzSp9owsXLiQwL8c8m0m0LxVW0rqNQwWkHTH4chsgMPlZvLkyai1ejQGM+nZuaxZs4b2nbpQp0Fjtm3bxpkzZ1i/fj1bt24NLQrmzJmDQq3DXdQejdWL3pOA3R9TZSMlp6BG0Pk/ayMGfxKJ3Waj1hkZOXoMTo+f2vUa8M0337B7927Mdg+FszaSNWoJJsl61ffkP9m1axfLly8nIycPi8uPUbLyyiuvUFSzBG9OEwIlXXF7/dx+x53kFRThyWmMymAlbeAicic9jc4ohTTHR40dj8UdCGqCt2lXbSF08uRJZpWW4s1tQmHpZnyFrZg8ZSoAK1aswOqNIrrFaCzuAGvWrAGgZ+++2Hwx2PyxdO/V57qv78/G3r17ad66LY2aXnrz7P8bYQe1eEgI0f1n/98rhPBeabyw/R0mTJircfbsWXr16oUQgj59+vwh0YhPPvkk/szghnxSz3nkFtYMHbtw4QLeQCSBuj2JajIEu8tzxTmeOXMGp8dHRP2++Gu0Iy4phS7de9GiZSv82Q1Cm/416zT4RXPdvn07VrsTvclCSb2Goayx62XO3JuRK5QoVBrmzJlzTX1eeOEFnNEpFJZuIrnnzSSnZ1VrM3fezdiigwW7VSY7haWbSR14F3KlGldiHnKVhqhmw3EnFzJjVmmo39dff43d5cGf0wDJ4WXx4kd+0XX9nG49e+NKKsBX3AGH28uPP/7I3//+d1LTM/EUBm3nyMaD6d1vQJV+Z8+e5emnn2bdunXVoqebtmiFv7gdid1mY7QEC4GXl5dzx513MmLk6EvWKjp79iw3zZlLvwGDeOedd64678jYeFIH3Elh6SYcEQm89tprQNB5fi3BD5s2baJGST06dO52yXXmp59+itPjw+TwodQaSBtwF96cRkyYNPmqY1+JDz/8kPqNmqIxSiR0noU3pxEDBg35VWOGCRN2UIf503P06FGcZjPTzRJtJQsdmjX7o6f0p2Dbtm24DAbGG01EGo2sXLnysm0rKyt59dVX2bJly69On7oUr732GimShYNeP886nCQFqhcNe+211yguqUfdho0xqFS86/ayzeVGr1ZfVyrV9XLy5EkcLi8R9XrjzW1KrTr1r7nvmjVr0BlMGORyrGo1CrkcuVzO6NGjmTdvHh9//HG1PufPn2f37t38+OOPANx88y1oZTLusFgZaDJTv6josuf75JNP8BuNHPL6+cDtxaDRADBsxCjcyUVEtxiN0WJj9+7dfPXVV+hNlqDR2Hs+MqUKk81JcUndkCG9efNmatdtgMPjx1+zI9bUEpzZTSks3Yw7pykarQ6hUGGOy0cpBN11errr9Oz1+ChWa8j92Xfphx9+yJIlS/j444957rnnmDp1KgbJRkyrsZj98ciUahRaEwqdCaXORGSjQSg0epJ6ziN73OMoNTqUKg0anYGk1HQUShV2pwuzJxqdK4b8qWuJaDQIS0Ih1kACGzZsoKKiApvDiRSbS/7UtdgzGgRTBePyQoV0vDU7I1OoMPiTiWg0GL3NiyUqjZg2E1AbJGQqHVJ8IUqVBrlahykyHVtaPRQaPf/85z/Rm22YY3KQEgpRGawMGjSIjp27IldpUBmtQTmO/ndQOGsjJmeAjKxsFBoDUlw+MmVwTF9JDxxZjcnOKyQ5LR2l3oy3uCNytS5UuDF/2jrkSjUWVwCjJxatI4L8qWtRS0703ngM/mScOc3QOSPJHP4wrtwW1L7Es7p7925MFhuBwhaYbC46dOyEJ6s+uROeQorLJ6Lx4ODmQyAFvTMSg9mKweJEZ7KSnZPL8ePHqaio4Nlnn+Xmm2/m4YcfpqR+I1q368g999yD1R+Hr3ZXpPgC9I4A8UkpVSRoXnjhBZRqDQqNIVgAMzobk2SrFu1RUVFBo2YtsPljMdlczL35lks+82+//Tb5NWpRUFyb7du3h36/adMmTBY7tshkDL5ECks3E9dhKvHJ6ai1OhQqNcW1S5g0aTLWQAL+ur2QqzQotAZS+99BzoQn0RnNoUjpyspK3njjDV555ZVq3zfTZ5ai0mhRqbVYYjKDDuqCliEH9fARo0IZBIH6fZkwYWJozK1bt7J169YrRiQdOnSIRx55JLTguF4++ugjRowczdy58y4rB/RrqaysJBAVQ2SjAUS3GInN4frFi+C/CmEHtWgpqhZJ/MfVxgvb32H+SrzxxhsM6t2beTfd9P/++/C3prKyktmzZyOEoE6dOnz//ff/1fMfPnw46BzNbYzFFeCee++tcvyzzz6jY5futGrXkQ8//PCKYx04cCCYJVq6mfzp6xEyGZFNh+NIKkCjNxLIa4Lk/HUO2DNnzvDVV1/94ijjI0eOoFAFMx3TBi5CrlRdk+TIjh07MDs8ZI5YTGSjAZdcQ5WXl9OzVx/0zgh0rmjsafUwBVJo0qwlzz33HGVlN1BYsw6jx02o4uh//PHHcaYUBx343WaTW1Sz2tjXy7lz57jzzjuZMmUq999/f2gt8dhjj+GISiFt4CLcKTW44cbZ13wvYxKSSRtwF0VlWzDYvdhdPgLRcdhj0gnU74vJYuPzzz8HgsE3hw4dov/AIbiSi4hsNAiTxcYXX3xxxXMUFNcistEA0gYuwmix8/HHH3Pw4EFi4hNRqTXUqFXCgQMH2LhxI0W16tCidbvQmAcPHsRothLfaSb+4g7UbVg1uOXw4cO4/ZHI1Tpc+a1w5bZAqzfQpHmr0Fr1l3Dy5ElsTjeRDQfgymuJKSKN+E4zqV2v0S8eM0wYCDuow/wP8Pbbb5Nps/GlL8CbLg9+m+2PntKfghtuuIHRJjNf+gLcLFkY0KPHZduOHzGCOLOZLIuVlg0aXPGPcmVlJbNLS0mNiqJrmzbX9Mdrz549uAwGtjhdzJIslFzhHTx+/DhGjYY3XR5ecLowabW/OFXtWvn4448ZMGgI4ydO4uDBg3z++edXPWdlZSUGk0TaoLvJHLUUtVbHrl27qFevHjKZjPvuu69anxMnTpCelYvFFZRUeP7551Frdfi1Bg55/bzl8uCWpCp9vvvuO1auXMmOHTs4fvw4dpOJ2yQrYyULuclBWYSzZ89SWnYDnbv15KWXXgKCDsC8wmI8qTVwJeTQpHlLPv3009B13XPvvSjUWiIa9Mdf0gOtUcLrj8Sd0yS4Q59eL6jfrNJgjstDJQQrbA6yVSrkQmA2WrnrrruqXeO3335LrZwcVHI5VoubgpkbsKXVxRSdjRSXh7dmZwL1+lyUA2mJRmdArdGi1OiI7zwTU1QGcpWWrDGP4Uivh1ZyYgykUDhrI7FtJ6LUmZEplPTpF4wenzp1Ks6sRhcjkrti8CUR0XhQcN4x2chVGnSuaOI7zqCwdDOexDyaNG1Ojdr1iE9KxV3QGrlahyWxCFt6PZQ6M75aXZEpNRw8eJAXXngBhVKNQqNHqdEjU2owmi2ojFbs6fVQS24imwwhY+gDKDR65HJFyDnur9MTa0ptXHkt0VtdrF+/nuat2+Ep7kSgfl80khOV0YYlsQiDLxGlRkf2mGUUlm5CbXaQPuQ+VEZbsPJ3nZ6Y4wsuSqgYUOolImPimTGztIpD9dSpU7Rs0w6nN0B2XgFGiw3/RU1wZ25zNJILhUZPYekm8qetQ8jkyFRa7BkNsSYVk5NfREm9BshVWqzJNVFo9LgL2xFRpwcZ2Xn06tsfvdFEbGIKo0eP5uabb64WHZKamY2vdneyRj6KymiluGatS36nXLhwgddff52nnnqKuMQUnB4fjzz6aOh4eXk5FpuD2LaTiG0zAZvDFXp+W7XtQGybCST3vBmN1Uv2uMeJqNcbpdZA5vCHyRn3BEqVBpXOSEzr8cHnLasR2Tk5aHR6VGoNs+fMveI7DhervJst5E56mrQBd13cSFGTnJ7JkSNHgKC+osnmwl/SDZPVEXoHr4Uvv/wSm9NNIKcRZoeHJUuWXnNfCH4/WOxOAnV74U4ppkv3ntfV/1opLy9HLlcEU5pnbURnMPPNN9/8Luf6X+Gv7qC+lHyeEGKYEGLYxeMyIcR9Qoj9QogPr6Y/Tdj+DvMX4tNPP8VuMHCDWaKuZGHU4MF/9JT+kqxYsQK1Wk1CQgKffPLJf+28lZWVTJg4mci4RDp37fargncuXLhASnom3sx62ONz0FlcFJVtIW3gIqLiEnjwwQfZunXrNY/3wQcfsGbNGo4ePUplZSXvvfce77333q+SwDh8+DBypZrciSvJuFifZenSpVftd+ttt2NxuFHrzSSnZ7Jv3z5OnTrF+vXrQzVaIGibxiYk4U4uRG+20bx5i6tu6tx7770otUYSOs/CnlhEclLqL76+n1NZWUm9Rk1wxWXgiEyiW8/eVFRUMHHyFBJS0uk7YBCjx45DqVLj8UVcVpbj+PHjfPTRR0yeMhWlXkLnigll6TlzmmLwJgbXAhm1WL16NcuXL8dotqA1SujNNtIGLgquXVIL2bBhQ5WxX3rpJcrKymjesjV9+g/kzTffJL+oJoHoOB548EEABgwaQqB2FwpnbcQan49SpUauVBOo35eIOj3ILSwGggFgzqhkisq2kDHsQbyBqCrn6tmnH96ituSMX4Hem4DkT+COO+741fd57969SE4fhaWbyZuyGplCicliv6QMTJgw10PYQR3mT89PP/1EpNtNL7NEDcnC4N69/+gp/Sl44YUX8BmNzDZLJJrNLPmZ4+c/0SiVfOD2csDrx6nXX1GWYsOGDSSZzWxyuOgkWRg56NqM8gfuu48Yt5virCz27t17xbb33X03OpUKo1bLU08+edl2e/fuZfv27dfswH7hhRdI9AewazREezyhVPx/8eabb2I3mXDp9TQoLr5iyl5lZSVavYGskY+SO3ElWr2RI0eOcPr0aVq3bo0Qgnnz5lUxGJctW4YntQa5k1cT2WQIdRsEJTEsVi+1DSaiFErGjRgRan/kyBE8vgh86TUx2VwsX/44b731Fi3q1aNrmzbVPqc33niDth07M3zkaL7//nuGDh+JZHeSlVcQcqb9C5c3gJAr8dXujtrsRKEJFldMy8pByORorF5MEWm48loS1XQYWnsArVqLWqFEqdTgcHv56quvqt2XUUOG0FeS2OPxkadWo3NFIZMrg8UWTXZi201CqbcQaNAPs8PL6tWrOXbsGBqdDoXWRFyHqbgL22KOySGiQX/szmBxQbk6GM0dqNeH7HGPY5CCBSiPHDmC0+1DZbCiNjlQGW0ImRyXN4BSqcLoTyS5180otAa0kpPk9MzQ8zd67HiEXIkQMnLGr/h3AUOFCr1J4raFt+OLjMFoc6PS6pGptEQ2HoIpOieoPzhzA5nDH0ah0aMy2pDJVUw2mrG4Y0nudQt6dyw6ZyTeWl2QbA6OHj0adGZa7PjSi1FoDKT0u53oFqNQm53BYo71+5LY9QbkSjVCrrjojLbiLu6ITK1DrtaiMdtRS24Su83GGZfJwtvvCD2T3Xv2wplai7RBd6NzROCu0R6F1oDa7ERvksjJzUOu0RPRcCC+Or3QOiKRqzQUlm4OypjIFWgMJlx5LUK63ebobNQWDzJFUAbF7vTQtl071DojjuQaGCUb27ZtCz0DOYXFJHQpo7B0M8ZAKgbJxttvv13tWTl79iwzZ5VikGzEtptE+uB70Zuk0HN1/PhxVBotBTOeI3/6epQqNadOnQJg0uSpuNNqEddpJmq9Ga3eSHpWLmqtjozhD5E99nEUah3+ur1RSy68xZ3QmyS2b9/OhQsXrjll+ODBg+hNErkTV5La/46QNvl/LgRfeuklbrjhhutaZELwO8Gf8+8U3+KSa8/gAHj11VfxxAcL/GSOfASP//fT+O3QuSvOmFRcCdmU1Gv4m2t+/q/xV3dQ/x4/Yfs7zF+FtWvX0tjh5EtfgHV2J3lJSX/0lP6yvP766zgcDmy2qrbG78ljjz2GPTKJ5F634IzP5raFt/+q8X788UfuuusuFi5ciNXhwlfYGntkElOmzbiucVatWhW0IdNq4PFF0KffQCSnF8npZdiIUb9qjkaLHblKi1ytR++K4dErrBsB3nrrLSSnl/TB9xCo1ZmWbdpz9uxZMrJycSdkY3H5uWnuvFD7Y8eOsWzZMjZv3nxN9sPSpUvJMpgoNFmoozfRsLi4WpsTJ05cd/bC4cOH0RnNwaKH06oXPfzHP/6B5PSRO+kZYttMIDuvkE8//ZQ333wzlA347rvvItkcWNwBXF4/9pRaSPGFSNGZFJVtIaHzLNRaI77a3TFbbHTu2h2NyY7KZMdTowMayYUlkIgrrwVypRq7y8OqVauAoNNfcgWwJBSh1Et481uRW1Cj2nX0HziYQElXCks3YYnPJ7LJkKDNHpNN1uilWGxOIBi1nZCcije1BlZPJGU3zq4yTm5+IXp3HM7cFpijMsnIyvlNsvHOnz9PYkoa3qx6OOOyqFGr5KrZBmHCXAthB3WY/wm+/PJLbrnlFhYvXvy7SFT8r/Lss88yrH9/li1dekVjICEigpskCw9ZbVgNhkvqeFdWVvLuu+8yZcoU2lqsfOkLcKfFStvGjX+XuZeXl19R2uOu22/HqdcTazbTrlmzqzqpz549i9Vg4DGbncVWO5JMhkGl4uGHHw71bVyrFndarHzh9VPDaq3mwP5PHnr4YbR6AxqdntKyG0O/P3/+PD179kQIweTJk0P3fu3atRjtXuTqoMZzUko602bMQq3To1KrGTFyZJXPacWKFfgyaofS2wqKSy47l6+//hqTxUZ0i9F4c5uQnZuPIyqFzBGL8eQ0oqiomDHDh7N7924AMnLy0Vi8qM1OMkcsxlujA207dOKbb75BazBRWLqJxG43ojJYiWoxBrlKgyOrCWqLhxo1a4UKxP0nrZs0waLWYVZpSNMGCxlmDHuQzBGLkcmD2naxCUkMGjyE9evXc+7cObr37IXDG0Cpt1BYupnMEYuRq7XYnW70ZiuWhKJgBLPWGLwP059FZbDg9Ufw9ddf8+mnn2Ky2PBlN8Bkc4XSJI8fP05sQhL26FSUWj0OSUKtM6A3Sdyy4FZOnTqFUqVB74lD64jEld+KjGEPojY7aNq0OZI3FpXRRsHMvwXnpFRTWLqJzJGPBvWuU+vgzG0elI5QqrBo9Xzk9tJcb0SpNSLFF2BNrYNGZ6hilC1fvhy90YxCpUFttKKx+ZGrtBi8iSh0ZtSSC4VKE4ye7nkzlsQayDUGZEo1cpUWpdaIt2Ynisq2ENV0WEgrb8KkyWhMVqKajwhGTOc0I1C/D6bIdOQaPRqDxKxZs4ILEJUGucaANbk2cpUWd35rXDlNUeuNyBVKVEYbiV1vxBiZHpJnsSTWQKZUo9RbUBltRDQcgNJgwZXfmjZt24Wub+PGjSjUWjQ2HwZ/EjZ/zCUdt8NHjsaZVIBCayRz+MMUzHgOk83Nnj17Qm1atG6L2R2FxRtNt57/3nw8ffo0nbt0Q6nRYYtKRbI5+Oijj3jsseVodHrUGi1Ob4C49lOJbTMBtUYXMv6vl7IbZqNSa9AZTKxbt+4XjXE53n77bcx2FwmdZ+FJL7nuBeYPP/yAzenGV7MTzsS8arqJvyUXLlxg7dq1PP300+EK5VzZQA7/hO3vMH9tvvrqK5xmM0PMElmSROm0aX/0lP7SfPrppyQlJaFSqXj88cd/9/PNnDULf+2uIU3i31I398CBA8yfP58nn3zyujd6a9VtSELnWUEJu/TaKJRq8qauIW/qGlRqTWgT/2o8//zz9BswiPvuuz+0Bpp383xMzgjcuc0xW+2hGh2XY926dXiSciks3UxS95vIyivirbfewhERT2HpZjKGPYjJYr9qAcnLcfToUWK8Xmra7DgMhmr1lEaNHY9Ko0VvNLNx48Zq/U+dOsXtt9/O7Nmzq+gunz17FovNQUyrsUQ1GUwgKqZKv9deew2bL4aCGc+R2G02vogYjJINuz+WopolHD9+HE8gisimwygs3YwzpRi9ZCfQoD9KlQa7Oxa1WovBYMXgjKRr1+6otXryp60nb8oaZAolGnsE+fn5yJVqtI4INFYvWr2BEydOkJyeTWq/hRSVbcEcm0tsuylodYZq13fgwAEiY+JQqjWoDRI5E58iqvlINJIDqzeKSVP+/Z10/PhxnnzySV555ZUqY+zevRv9RfkPe3p9zDbnr5L1+E9++OEH7r77bpYsWfKrCjuePHmSDRs2sHPnzt9sbmH+dwk7qMOE+X/Arl27qFdYSGFaGi+//PIl20wZN44Ik4kYkwmbVkux3Y7dYODFF1/8Xef2yiuvMHPmTLZs2VLl9y5JYqvTzedePwGjkV27dl1xnGPHjmFQq/nE4+Mjjw+1EFhlMpKNRsYNHw5Am8aNmSZZ+MjjI02S2LRp01Xnd/z48Utq41VUVDBy5EiEEAwePJgLFy5QUVGBSqsjY9iDwYKMRjOHDh3i6NGjlzQIgs4rN0k95uLNaXxF59O2bdtwxaYFIymHP4xJsuLLDVZijmo+Aq/exHizhNti4YcffmDPnj1ERsdiikihsHQz8Z1mkJ1fg6+++orC4tp4UopwJWSTnpVNw6YtGTN2LFOmTOHee++tZlB/9tlnPPnkk6xevRqlRodMrsCe2RC5SotKrSF77HJyxj2BWqPlxIkTjJ84CV9kDK3adqBRk6aYItNJ7HojKqMNsy8eyR3J2PETWL16NVZ/PAZfItljHsOZ3QSFWodCY8CR1QhvYZuQDvAXX3zBQw89xN13382yZcvo1KIlLerWpd+AAeg0etJVam63WDGrtCR0LUOuVBMZm0hMXBwyhTJY+bzjdIrKtuBOKSIhKRmlwYJcqSFtwF3EtBqLXK3DEEhB745DptIiU6iQKVQMHz6CM2fOMGrwYLRKJTaTibvuuou0jCyy8goYNGgQTo+PhOQ0tm3bRlZeIfEdp1Mw4zlUOjPGyHSyxz2ONakmMqUKb80uyBQq7Gn1yJnwJFqbH5lcQdaoJeRNWYNcpUGm0mJLroVRsoXeWYPJTEKXMpR6M3pPPHKVBqVOwpJYRMbQB9C7Y4lPTCZQpweFpZuxJBRiSSjEmdUYrz8CjcmGQmvEnl4vtIkiUwejaWJajaWobAuO7CbYUuviyGyIM7sJjsyGKA1WNDpDlfTbJ598Eo3OgEZnJDYhiVtuuaXawik7vwbJvW4huvnIoB63XsIfGR16vg4ePIhkc+BIzMcg2bn/gQeq9J84cRL+km4X5VR6MHbceCCoMXjmzBneeecd/JHRaLQ6rE4PcUmpvPrqq5d9h67EmTNnfrfNz8cff4KS+o0ZOXrsNS8uDx06RK069fFFxjB16nSmT5/BPffc87tUdg9zacIO6rD9Heb/N3v37uXGG29k+fLlv7sUXZigs6tevXoIISgrK/tFWTwVFRX8+OOPV+374YcfBut5ZNfDKFl5/fXXf+m0f1MGDBqCN6cRyb0XYHZ40RtNJHa9kcSuN2KSLNdkp7z99tsYLXaimg7DHpnMglsXAsFApDVr1jB//vxrklM5efIkyWkZOKOTMUpWVq1axcGDBzGYLSR2vRFvzS5oLB68/sjLFvL75JNPqFO/EZm5BZdcc/34449s2rSpWubt7t27Mdlc5E1ZTXLv+Sg0eoYMH1HlPWzTuDGNJYmeZomEiIgqkdbbt2+nToPGNG7WskpQBASfkbYdOqE3WTCYJNy+AKn9bg/KH0YmMmbMGFQGC66C1uROXInZl0C37t3Jr1Gb2jVrYTcYMOnNJPWcS3SLUbRo3Q6jWSKx22wSOs9CplQFAzNyC4hpPY6isi1Yk2uiVGs4cuQInbv2wJvTmPiO01FoDFgDCVUCNP5zrj/88AM9evVBrlDi8vpZuHAhL7/88jW9H8899xze5AKKyraQ2m8hiWmZV+3z3+bkyZMkJKfiScjGZHPx4EMP/dFTCvMHE3ZQhwnz/4Dnn38eg8mMSq1hxKgxVFZWUlFRwYEDBzhx4gQXLlxApVDwocfHp14/kkbDypUr+eyzz37Xeb300ku4DQbGmsz4jEaeffbZ0LG0mBgWSBaedTix6HR89dVXVFRU8NJLL/H8889fMvp6aL9+eDVabHI5dpmcplotrzpdRDqDaVCffPIJqTExqJVKhvbrFzJ0PvroI2pmZZMSGcmTK1Zc8/wrKyuZOXMmQgi6dOnCuXPnsDndJPdZgL9uL1Q6Iw8//HCVPu+88w5btmwJGVKLFz9CTkExPfv0u+Ku9k8//YQvIgpfbmPskUkMHDwUbyASV0wqCpWGxdagTnuG9d9yCydOnCA5LQOLJzoYiarRYNHpePjBB3n00UdZvnx5aB4vvPACRrOERqenV9/+IcPngw8+CBnxKp2R2DYTyJuyBo3Nh0JnIj0z+6Kj0sD8W2/jmWeewR6ZGNRBy2mMxmghtu3EoPMzqzEaoxW92cZdd93N999/j1myYk2uSVHZFqKbjyQxJR1nSk3yZ2zAm9OIWaVloXswZNgIbL5oTCoNY01mbpOs6OQKnI4IltjsfOkL0FxvDBYd9CWS0HkWKpMdnSsGjU6PwWTBGZ2MQbKh0puQq7R4itqj1EtIdhd6mRy5EFjMToQIajerzQ58EVGhrIMdO3YweMhQjJIVb3I+CnUwWlnriEShNaEzGMnKKyS23STyp61DoTXiym8V1KEr6YHG4qaobAum6CwUaj0aqxdXXiuUBgvJvW4hc/jDyFVa1GYnEVHRvP/++5w9e5YFCxZgsdrxFLXHHJuHTKFEplAiZHL03gRyJ67Emd2ErJw8AjU7UThrI+aYbPx1emJ0RV2UFFHiu6hXHdlkKDpXNBnDH7pY7DCL5N7zUUsuErqU4SnqENQoV2qwpdbFk5hbJYLl5MmTpGZkozbakKt1WKPSaNG6HeXl5Tz44IPMnj2bqdOmo5ZcuPJbotCZkGsMKDX6kBzN3XffjTu9zkX5ixupWacBDz70EL6IaLLyCpg6bRrOxDwyhj2IK6mA2xYurPZenD59GoPJTFLPeSR0KcNgMrNv375q7+lzzz3Hfffdd8nq5v9JeXk5t8xfQM/e/S67ofd707RFKyJKupE+5D4kh7daFfhjx47RoXM3ktIyWXj7nX/IHP/qhB3UYfs7TJj/JQ4fPsyjjz5aLYryf4lz587Rr18/hBD06NHjuqQI/hVxqtboKCyuzcmTJ6/Y/vPPP+fJJ5+8ZMHzP4rjx4/TrWdv0rPzufuee3n55ZeJS0zB7Y9k5MiRl81u/DmLFi0iUNSGorItxHeYRtOWbX7xfE6fPs3WrVvZv39/6HfPPvssar0ZKS6f7LGP44xKqmaj/IuU9CwiGw0gsesNGMwWvvvuu2ptXnnlFQJRsbi8flaufBoI1g4yWZ3kTV5FUs95qC0e9BYXxSV1Q4FTOpWK3R4fX/oCRJrM16VhXllZyZdffsmJEycoqlVCZMMBpA++B5PVQatWrdDa/Ri8CciUavRmC+vXrw+ti5YvX45cpUEjuVBq9WzcuJEXX3wRb0Q0Co2BiIYDcKTVIT4pFU9BK7JGLUFr89O4STMg+BkPHDyUWnUbMGzYMJ544olr2ng4f/78dW/a/PDDD/gCkfiz6mJxBbht4a/Xnv6t2bx5M+74oHRKSt+FJKSk/9FTCvMHE3ZQhwnz/4DI2ASSeswlb8oazHY37777Lk1KSnDp9diMRrZu3YrXZuMei43lNjsWvf6aI/1+zs6dO6mdk0NucjIvvPDCVdtPnTyZiRcLPd5olhgxaFDo2Pvvv09eSgpxXi+PL18OwIAePUiWJNIkC13aVDe4Kisr2bFjB/feey8GjYabTGa6ShbaNm5Sre3PyUlK4ibJwhq7E6tOf02VrX/OwoULEULQpEkTbrzxRlRaHVp7gJhWYzHbPaF7ccPsm5CcXpwxqRTXqnNFiZNL8c0333D33Xfz9NNPU1FRwU8//cRrr71G59atqSNJDDRL+B0Ojh8/Hrof9Ro0xuTwYpXL2e/1s9Hxb4f9z4lPSiWx22zyp63H4o4IGZszZs4MpUFqbD4SOs+iYMZzaCxujBFpaPRG9u3bx7Fjx4Cg0/Ffkd3RLUdjtjpQaI1YU4JSE1mjlpDa/w7ik9OA4KaB0+PD6o3GbLXz8ssvU1SzBJlcTkGNWhc17R6jZp36yJVqcsY/iUqh5EOPl4NePzaVCpVGj1uporvBiFYmCxbOuxgR7MprhVytQ2d1c/vtt3PfffcFU/tmbiC5180XK47XoWZREZ10eg56/TQ3mJDJ5ES3HEtSr5vRmB3k5BexY8cOJJsDc3Q2Omc0WrsfmVqLPb0+RWVbiGg0ELlKS3RsAkqVBiGTY02pjVIvYXQGsNiDOtGB+v1wxOeQm5dPRHQs/pIeJPWYi0KjR6ZQ4a3VFbXFRUpGFq+++ioWe1C/WqE1IeRKZCotce2nkNh9DgqNHnt6PZRaAzaHi3/84x8kJKcilytw+SKwu7woVGpyJjxJZNNhaCxuErqUonfHBiVXZm1Eis5GodGjtfmQa/QY/MnIFCoyht5PSt/bkKs0eP0Roc8Y4KmnnsKVEEz9jG03CXNMNgazRL+Bg3HGZ+EraovD7aVJ06ZBh7vkQqExhJ6t06dP4/EFUOqCuuTW+Hz69O2PUbKRNuhuopoMITMnn34DBxOIjqVP/4GcO3cu9M5s2LCBqLhE4pNSUGt05E9bR97kVcjkCoxmaxVN7LIbZ2PzxeDPbYzbG+CHH3644ns2aco0nPHZRDUbjlGy/SGaehk5BST1mEth6Wbc8dnVUl/79B+IL68pqf1ux+IK8Pe///2/Pse/OmEHddj+DhPmf4UjR44QcDppa7MTbTJxzyWKXP+vUFlZyc0334wQglq1al3SqXkp+g0YFNLs9aTV4t577/2dZ/rfYdCQYThi0vDlNiEQFXNVx/vOnTvR6I34andDK7lo1aoNhw4d+k3n1LRFKzzZDZHi8pArNSSlZoQcxJWVlUyYNBmLzYlSayC1/50Ulm5CcvqqZcNWVlZitTtJ7DabtAF3oTMYQ2uYiZOnIJMrkCnVGPwpmKOziG45GqNkY9euXTQsLqajJDHKLBHhcv1iXeVPP/2UvKJifBHR3HPvvcyZMwdHZkPyJq9CqZdwpNXB6oth9k1zAMirUYuEzrOC8h9xmaxduxYIOq79mf8OusgtLKakfiOsdhc9+/T9w7Iwjhw5wtKlS0MbV7t27aL/wMFMnTb9kpKf/2127dqFyeogufd8/DU70qR5qz96SmH+YK5kf8tFmDBh/hLIZLKL/wq+3G+99Zb4/sNdYrtkFTcp1eLGSZPEuk2bxGNet1hotYiVa9cKvV4vhBDipZdeEoN79xZ33XGHqKiouOJ52jdvLtp8dkCMOvKd6Nqunfjoo4/EsP79xaghQ8TXX39drX1cQoJ4urJC3HHiuHi4/LzIKy4OHcvKyhI7du8Wn379tejVu7c4d+6cePzpp8UGnUE8pzeITVu2iB9++KHadWq1WnHjnHmiUq0Td6m1wtqxg1j69Morzvvwt9+KOmqNyFerhaRUiqNHj17DXf03EydOFA899JB44YUXxK1z5giFkAlvzU7CldtcmJNrix07dgghhFi06B4R3XWeiOm1UOzet1/UqltfxCeniVGjR4tFixaJ/fv3X/E8brdbjB49WnTp0kXI5XJhMplE7dq1xROrV4tOc+YI35jR4o0dO4TZbBZCCPHFF1+IHe+9J2K6zhHlCpX4suKCeOXsGfHNiVNCrdGK6TNLQ2MrlUpReeG8oPKCoPKCUCqVQgghEhMSxNmD74vjn+0UWq1OHPzbneLdWzsJpcEi/PX6CLlMCJVKJYxGoxBCiA4dOohjn7wjPnhgiDj0wmJx9uxpIUVniuOfbhcKmRBnv/9SHN/zqkiIjxNCCJGQkCC++OxT8eKG1WLXP3eKhxYvEV99/ZUYMnS4eOv1V8WePXvEmIlTxHfeOsIcky32r79VGByRovDYcZH+43FxQS4X5efOCKnTLPF6cTch05vEzKmTxMGXHhGfrpkvvv9oq0jrf4eoFHJx/vx5seC2O8RPx46KC6eOi3PHj4hzP34rftz/nnj//X8KnUwmZEIIbeUFIWRycfSfL4pPnrpRmOPyxRFtjGjfsYs4c75CnPn+oKgsPycSOpcKreQRZ44eEud+/FacOvypQAjx9Xc/CCmhUNhT64hTX+0VWq1GzJwwUhzYv0+8tvUV0SrZIKYM7SmGDB4slCq1+P69DWLf6nlCplAJhEx88/Za4cxpIU55i0TL1m1Fuc4hNJJTRDcbJpQ6o5DJZOLoP18Sn2+4U8hVOhHfYZowWhxi7epnRHp6usjKyhIqnUF8990Rcez4cQGIyvNnhTkqQ5z/6Xtx5N1NQu+NFxXlZ8W7t3cXlT8eEutXPy1k5WeEXKURleXnhBBCqM1OobF4hKBCBCIiRbNWbcU777wjhBBCkiRx4fRxcf7EUXHmyBfizHdfCMliE0+tfFp4m44WEU2HC4XRLkpnzRKtWrYQKrlMOOJzhGTQiPT0dLF7925RLteI6JZjxNF/viTOfL1XDOjfV6gNkjB44oQxMl18/vnnYt26dcLtdosxI4eL7LxCoVKrRf1GTUSXbt2Frri/EOnthEKlFh89MFj88/7BwlvcSVgL2osly5aHnu0nnlwpvM3HiUCriUJudou33377iu/ZttffFLbCTsJT2FZY43LEe++9d43fBL8dpdMni6823i4+Xz5OOAwy0bBhwyrH9392QOhj8oUpMk3oPbHiiy+++K/PMUyYMGHC/DnYtm2bSK5E3KfViQVqjXhi8eI/ekq/GJlMJqZPny6efvppsWPHDlGjRg2xd+/eax8AhBD8qjk8+eRTon7j5mL8xEni7Nmzv2qsX8vadeuEv9VkEdFqgjgn1OKjjz4KHXvrrbdEq3YdRP+Bg8V3330nhBDi2LFjwi5DNHhvg6h99iexZ8tmUZSdHTr+W/DMUytE/VSvOPfdAZEx/CFx1lcoBg4dLoQQ4sUXXxTLnlwtonreJly5LcT+VbPFgRWTRWpSgkhOTq4yDiBOnvhJGLzxQueKEkLIxZkzZ4QQQjRt3EjoTBYRqNtLnDv2lfDV7ibceS2FJTpDfPDBB2LcjBnipUrEY+XlYuyUqUKr1f6ia/H5fOLJ5cvE55/uFaNGjhT9+/cXsiN7xP4npgiVySY8NbsIb9PR4vGnnhZCCOGw28TZI5+Lc8cOi/KTx4TNZhNCCNGkSRNRfmS/+HL9PPHNS/eLsSOHi22vvCh+OPqteOKxZUIu/2Nca06nU/Tr10/Ur19fHDt2TNSuW1+89Nl58djmt0Xnbj3+kDn9nLS0NHH3HQuF7P2VItNWLh5b8r/73RXmv8DlPNd/9p9wBEeYMFV58cUXMZollCo1o8dN4KWXXiJJkvjQ46NMstC8bt1L9nvvvfdwGgzMNksUSBI3lZVdsh0Ed8HVymBk62deP3adjki3m9FmicGSREZ8fJX2k0aPxqHXo1EqUWp0WP3xJCSnVtnNPXfuHG+88Qb79++nsrISn93OrZKVRRYrDrP5kpWdO3TuRlTjQcEIitRiFi9efNX7c/uCBXgMBpIliWZ16153ZDMEpTu8ej0qIXDL5Sh1Jvy1OmGUrOzYsQOAtKxcIhsNIKn7HJQaHZ78lvhrdMClUNBDsuA0mzlw4EC1sY8ePcqyZcuuSW5gxRNPEO/zkZWQwGuvvYbRbCG+00ycSTXRyeXoDGZi20wgd8JTmB2eUEGK119/HYvNgUKpYvS4CaE0ssrKSspunE1OQTETJk3mp59+Yv369UTHJeLxR5KakYVWb8Tl8bN7927Wrl2LLSKRxO5z8NbshFpyYY7NRYorIL+oJlaXD7laSyAqppoUw4yZs3Cnl5Ax7EEcMek8+uijLFmyBH9Og2DV7C5lSHY3SrWW+A7TiGk9HoVaiykqA1tqHRxZjYhLTGH02HEYzRIypRpvrS5kjXwUjdGCPyIKW2odrCm1kcmVaCweLKklyFVaXAWtkSQXOpkci1aLLyIarT2AymhDLbnwFHVAodET1Ww4yb3nI1fryJ3wFP56fUNFCZV6CU+tbgiZnJhWY9HaAyg0ehYtWlTlOk+fPk2rtu1R6kzYMxrizGmBXK1FptYRaNAPhdYc1IhW65ArVGgkN4H6/Sgq24LOHUNch6kUlW1Bii9EqbdgTSpGsjk4duwYN82ZiyOpiMyRj2COzsIck43KIKFQqlBptPgCUVhTSlDqTEQ2GoTG6kFrMNG0RSuETE7+1LUUlm5GoTUGI5+1evQmiZiWY4htOxGLzcH58+d59913KSqudbGoooRco8OT3wpjRBqWhEIiGvRDsjk4cuQIFRUVPP3009x3330cPXoUICjvYrUT1Ww4voKW1G3QmPLyckrqNcDmi0FnlNBbnGSPWUZESTei4xLx1+xAwcwNuJIKUWm0FEx/ltyJK1EoVZSVlSF5Y0jucysmdxT16tfnvffeA6BTl+54sxsS22YCRslaJVX1UsxfcCs2fxy+mh0xWWxXbf978dlnn7Ft27ZLRgWtW7cOo8WONzkfXyDymiPMwlw7IhxBHba/w4T5H+GDDz7AZTDwgNVGO8nCgB49/ugpVeONN95g2bJl1yS19S/efPNNnE4nVqv1qplCX3zxBdFxCajUGmrUqnPVSOMrndNsdxHfaQbu1JqMGjv+F43zW9GoaQu8uU2JajoMs9Ue+nv/3XffBYuntxyNr7A1JfUbAfDMM89Qx2bjkNfPQ1YbtdQa6jscTJs2nczcAho3b3XJAoknT568rs9my5YtOGNSLxZdn016dvD7f+XKlXiSCygs3Uxch6mkZ+dRr2Fj/FGxDB46PCRncfLkSY4fP86ceTdjMFsx2VwMGjIsNP6sWbPw1+lBUdkWLMk10dt9+Gu0RbI5OHjwIHaXJ3jewfegMxivmh13Kfbt24fT48Pi8hEdlxCSUPnhhx/o0bMnCrUOtdmJzu6jU5fuQFBKJqegBlaHi+kzZlFeXs5rr73GP//5T7799lueeOIJ/vGPf4TO8cMPP1yTNMsvYevWrbRs056hw0deU/HD7du344hIoKhsC9ljH8dqd1JRUUG/gYPR6Y1kZOf95tH218uMmaVINgepmTm8+OKLvyij+9dSWVlJ6Q03kpFTwPCRoy/pbwjz+3El+/sPN3R/6U/YQA4Tpjrl5eWcPn0aCH7xjho8BI1SSXJUVLUCEv/ioYceostFbd9HrXaalZRc8RyTxowh2mQmRZJo1agRZo2GQ14/X3j9KOTy0Bf80aNHMWk0fOTxkWKQSOh6Q7BidXIBzzzzDBAsWlacnU2qxYJdr2fFE0/w3nvvUb+oiLp5+bz11luXnEP3Xn2IKOlGwYzncCVk89hjj13T/dm1axevvfbaLy6U9vnnn2PT65lpklAKgVqlYvLkyWzfvj3UZt++fdSu24DUzBwiomJJ7nUz3kAySy/e4/Z2B0uWLKky7o8//kggKgZfRgkWd4Bb5i+47BwOHz6MRavjWYeTBWYLOoWCbt26kZqZTe26Dfjoo4+IS0olqec8CmY8h9UbxZtvvhnqX1lZeV1F2JYvX447KY/CWRuJajyINu078dRTT+FOyKFw1kaiW45GqTeT2G02xkAKSrUWW2QS2WOX485vQZ16DUlKy8TmdHP7HXfRu98AIhsNCuo1F7Vl7ty5fPnll9icbvw5DTDb3dx7732oNToyRz5C/rR1CJmMxO5zkeLy8EVE8sgjj2CPTCSyyRD0njj0njgUWiMKrQG5SoMrtwUqkx2lzkR8p5noPfHIFErcRe0omPEcxsg0evXqhdHuobB0E1mjliBXaZBr9MiUarJGLaFw1kaUegmNzY9cqcGZ1SSk+WzwJyNXaVFojaQNuItAg37k16gFBBc9Y8aOo2WrNjiSa5A2cBEGbwLe2t3QWDx4anQkc8RiZEo16YPuIXPEYuRKNVm5ecjVOlx5LZCrdNjS6pLSdyEKrRFLTDa2xEJS0jOprKyke8/e+Ov2oqhsC54aHTBFZaLUS1jicnGl1cbh8aMySLgLgvqEsW0nIcUX4CtsjdFix5ndBH+dnkFdbZMFvdEcdFxPX0/BjOeQK9V4/ZGYbG6UWgNqyUXOxJVBPfLB95I/bT16yUGbdu3ZsWMH+/fvv2za5fbt22nfqQuDhw0POa7Ly8t5++23ufPOO/Ek54cWOC5fBBH1elNYuhlPRh1y8vKxuCMw2VxMmzGLiooKJk+ZhkZvQiO58dbsjN4ksWfPHn766SeGjxxNs1ZtqxV9/eCDD3j44Yf56KOPqrwHTz/9NDfddFOVdNSzZ8+G5vlnYM+ePTz33HNVpFfC/HaEHdRh+ztMmP8l1qxZQ7OSEkYOGvSnSN3/OY888ihmhwd/Vl2cHh/ffPPNNff97LPPSElJQaVSsWzZMgC+/fZbtmzZwldffVWlbWVl5WUL9l37XB8hkNsoFBhRu16jXzXer+XYsWOMHD2WTl17VFlTbN++HUcgjqKyLWSNXobV4QKC9Weyk5KJ0WgxyGQM1Bux6nToTRJJ3W8iok53impVXc9t3rwZg8mMVm+iuFZtpk2fflld6X9x7tw5imvXxeLyYzBb+Nvf/gYEHbIurx+tyYbWYKRv3364U4rJGPYgzvgsHnzwQR5evBitzoBGq2fuvFvYv38/e/bsobKyklOnTjFy9FgycvLQma0E6vfD7PAxYcIEFixYwL59+6isrESj05M95jHyp61Db5I4ePAgO3fuvK6ggkFDhhKo2zO4Bs1rys033xw6ZrE7yRyxmMxRj6JQ65g0aVI1R2VFRQWNmrXA5o/FZHNx09x5VY4/vHgxOoMRrcHEhEmTr3le18LBgwcxSTZiWo3Fm9OY1u06AlfWqr5h9k3IVRqcOU2xRmfQvVcf1q5diyMyidyJK4ko6RZyxP9aPvvsM1auXFmtAOaVeP3117G4A6QOvAuV0YbGZMfp8TF12nQiouMoqd/wumU4fwkrVqzAHplISt/bcCUVMOc/Ptcwvy9hB3WYMGEuy549e7AbjYwwmUkym1l0x5WLK1RWVvL222/z97//nfPnz1OUmUkri4XGFguNa9cOtfvpp58wa7VsdrjI15twF7QhffC9WFx+XnvtNSBYtC/XauWQ188Sqw1JsuJwexk0ZNgVI5wPHjxIYko6crmCVm3bX5PDddu2bYwYNIhFd931i6Kn/8WKJ54gIzaWnNRUTCYTERERly2+8thjyzFa7FgkO8UaLXdZrHiMRmbPvonikvoMHDyUEydOsHnzZjyJORSVbSFtwF2odCZmz5lDs5atiYyJZ/ZNc0KGyJ49e3CqNXzu9dNVpydVqaSf0YTHag1FXPztb39DbzRjkGy07dCJiooKjh07xohRY+jQuVsV7d6r8cQTT+CKz6Zg5gYi6velXccunDlzhtyCIpRaAwqVBlta3aAedYtR6BwR6CwulHozGrsfuVqL3hNHZNNhGC12Vq9ejcliw5OQhd3lCUWTf/nllyxZsoQ333yTiZOnoNIaUah1aExWapbUxRcRhdXuIC8/H71JQqHW4c5vjdrsIHXgItSSCyFkaKw+8qevJ6b1OPRmG1aHmxo1a+MLRKG2uBEyGQqtAa3eiFKjI6nHXCIa9EfnikGpMyPkShRaIxqLF7lKh7d2d4yBNAL1elNYuglzdBYxcQksX74coyuCwtJNpA1cRERMHB988AFGyUqgfl+0ZgdRTYcFNbJzWyBTqHDkNEOhMaA0WJAp1cR3mE7uxJWoNFp+/PHHoE68PwKFWhOM2FbrETI5hbM2Uli6KRhJLtnQ6AwoNAZ0jkjkKg0ylRq5SkvBrE0UzNyAEDJ8dXqhNFgI1OuDWnIR03ocCZ1nkZKRTWFRMQq1FpVWjy8qlugWo3FkNUZr86G1+TEGUpAplKT0vS0YOa3WodSZ0NojkKt1uJMLiEtM5sCBA0THJSA5PLi9gesuuHry5EkysnKx+aIxStbgZogvgEZvwub0sGXLFrZv315FH/q5555DKzlI6FIWLMqZUY+HrlANfNu2bRgtNiLym2GUrFUiXv6T119/HbMleH/bdez8q74nwvxvEHZQh+3vMGHC/Dbk16hNUvebKCrbgj+zDiuuoyA5BJ20DRs2RAjB8OHDkWwOfMn5mK32UCbgr+HZZ5/FG4giEBXLihUrsNid+PMaIzm8LFmy9FeP/3tw+vRpYuIT8WbWxRGVzNDhI0PHzpw5wyuvvMLQAQPo3KIlixYtwhERT2HpZjKGPYjbF1FlrPikVJK6zyGq2XA0kgt/SQ+MkpX333//inO4cOECH374YZUI4VFjx+NKzCeq2QiMkpVOXboR0SCYBegr7sDMWbPQ6PRkjnyEnPEr0Oj0VaKfhw4fiSe9hITOs9CbLPTo2TOk8/xzbr1tIVqDCY1Rol3HTnRq1Ypokxm7Xs9NN9zAmHHjmTmr9IqRxeMnTsKb15S8KWtwJxdxzz33hI7FxCcR3WIUKqMNV35rnIl5dO3Rq0r/PXv2YHZ4KJy1kazRSzGaLaFjR44cQas3kjliMXmTV6EzmqttqPwaXnrpJTwXiwtmDL2fQFQsrdt1QC5XEBUbz6efflql/cmTJ1FrdaQNvgdvcScUSiUnT55k+fLleFKKKCzdTEyrsTRu1hIgFFmtN5rILajBhx9+yPr16y8b1PZzunXvgZAr0Doj0RrMPP/889d0TRs2bMAVl0Ggfl+cWcF6Rq6cpmjNNtIH30Ogdleat/rlRT+vlTlz5uAr7kBR2Raimg6jV9/+v/s5w/ybsIM6TJi/EEePHmXqpEmMHzXqF6XoVFRUsGrVKu6///6QQ3Pnzp2UlZXxzDPPXHf14OPHj3PXXXdx7733VkvReXLFClyShNdmIyu3AH9ULDffMj90fOfOnXgNBp53usjRGXCk1yNr9FIcMWk8/vjj13Qt18KuXbtwGAzMuihjUjZ9+nVdY2VlJd9++201R/jOnTtxuVw4nc6Q1MCGDRuYOnlyqGjiu+++y6OPPsqU8ePp2Lw5t956Kyabk4SuNyAlFGG2OXn11VcxSjbiO83Akd0EKS4Ppc6EM62E9MH3YvVEhcarqKggMyEBr1yOXggWSBa+8Pqp5XDw/PPP89lnn3Hbbbfx2GOPceDAgdDn2bRFK7y5TYhqPgKTxXbNkS3nzp2jWcvWKJQqIqJj2bx5M1u3bsUjSQzUG5ltNiNXqrGm1EKpM2OwODHZnMS0Ho+nqB1SXD5x7aegNFhQag0YJSu5+QV0696drNx8ElMzqhSH++mnn1BrdORNXkXuxJXI5ArGjJuAwWzFmdMMmVJNar/bSR90DzKFihS1Fo1Kgyu3GQUz/4YUm4s9syH26DQmTppCnfoNiUlIZvCQIbg8PvTeBMwxOQiZDJlSjUJnwuBLInPEIxh8iThzmqFzRqFzxSBTaUjqMRe11YPKaEOhMaDSmejStRvTZ8wkv6gm9oh4jBY7Dz70EA899BARBc0oKttCoOEAFGodroTcoENZrUPIlejdsRSWbiKuw9SQxEZcYgoAjz32GI6YDJR6MxEN+mP0xmFzegjU6oy/Tg+UOhPJfRag1JtJH/YgcrWW7HGPkzPuCWRyBZ4a7bEm17rotNZh9kSi0mhRaAwY/CkotEYaXiwmeuLECb7++mvatO+IO78VWWMeQ2txI1coyZ++Pih5UqMDxohUdI5IIhoOCBmR6enpbN68mdmzZ2P0xKL3xKJ3x9B/wKBLPkNXe7527tzJkSNHABgybAT2uEwiGg/GKFmrScS8/PLL6CQ7Rn8yUU2HodIaQu/epRg6fCQRDQcGF8x1ejJp8pTLts0pqEFch6kUzHgOe0RCtUjsMH89wg7qsP0dJkyY34Z+AwfjyaxPQtcbMNlcVSKBr5Xz588zcOBAhBBo7QEKZjxHRIN+DBk2ghMnTjB67Hhatml/TUXaf86ZM2fQG02k9LmVpB5zMUkWPv/8cx566CG2bdt23fP8b/L999/z4IMP8tRTT3HrbbcxaMjQKpmR/+Ls2bNk5uThjs9GcnqZd8t8Tp48yfCRo6nbsCkR0XHEtZ+KJbGI+I7Tg7ZqjTbVJOr+k1OnTnHrrbcydeo06tRvhE5vRHJ4SO51S3CMrLrccsstmK12vInZ2JxuPvnkk6CcxND7yR6zDI3OEHIinzt3Dk8gCp0rmkCDfviz6oUyYU+cOFElI++W+QuQPFG481qgN5rxGwx85vWzxeFCqdbir9UZT3ZDatdtcMX7V1y7Lhqtjhat2lYZ/9133yUiJg6tzReUxBjzWChK/V98++236E0Syb0XEN1iFLEJyUAwqMFksSFXaUjpextZo5ehM5hC9uz1cPDgQbp060mLNu149913Q7//8ccf8foj8eU2wh6Ip1XrNrjiMoPvxcWgoZ9z+vTp4MbAiMVkDHsQjU5PeXk5u3fvxu31oTNKmCy2UKDS6tWrcUSlBOUMa3VCZ7TgSy3CKNnYuHHjZee7du1aFBo9vtrdUJnseIra0aJN+2u61rNnz5JfoyY6kwVzdCZ5U1Zjjc3BEplKYelmkrrPISOn4Lrv4fXy8ccfI9kcBDJLMErWP/33wF+NsIM6TJi/EDWysuguSQyRJOL8/muSq/jss89Cjp7xI0aQKUm0tdpIiIj4xfptvxWL7riDWI8Hl8sTijj15TXljqtEcl8PS5cupYPDwZe+AMttdhoUFl5z31OnTlFYXBudwRzSYP45e/fuJSIiArPZzNy5cwkYjUwymfEYDNx77704JQm33kDtvDxOnz7N448/jiu1Jqn9bkehNSLkcuKTUlm8eDFKnQlLYhG5k55Baw/gq90teD8yS0IpjxDcpHCbzXjkcqIVCjJUKmwGA506d0VjMOHKbIAtEB+qRg3g9PjJHPkIRWVbMHtjqdugEcuWBQ3CI0eOcPz4cSoqKpg5q4y8olrMmFlaZQPgzJkz3HXX3ZisDqy+aHQyGa+63Bzy+nHK5WRkZROflMYdd9xFz9798BW1xRgIRmsEtZTzsSbXJnPEYlRGG1p7BFJ8Pkk952EwSSFZhTNnzqDR6UntfwcpfW5Frtbj8vpR6kwUzPwbMoWKnPEryJn4NHKlimSlktZGM76anSks3YwjvS5JKalMmTodtc6Ar3Y3fLW7o9Qa6D9gIHrJjiWxBoWzNuLMbR6KmNY6IoPnKmiNXKMnouFAtAYTJsmKQmMgrv00skY+ilJnxplRH3dWAzQGMyq1mv4DB1FZWRmMoLbYCNTvh9YRgd4RuOgs1iJX6zDH56NzRJI74SkC9fpgjsnBld+KRk2bA0FD0Wj3Yk+rR1HZFpJ6zCU7vwYdO3dBYwhqVntrdkFpsGBPrYVcqSZtwF0kdpuNxeZAqzciV2nQe+JQ6swUFNXgwQcfxBZIIKLRQGxRKcxfcCtvvPEG77zzDpWVlQSiYtA5o4LOcrUOjd6IPSIByenH6nCj1OiQa3TYUkvIGr0UvScea3weJquD1PRMDL5E/HV6IVfrcHr8v1rXLi0rj5S+C4OLnozarF69usrxyspKho0YhUKlxmxzMnjwYB544IHLRs/cd9/92KNSSOx6I7ZAMPL9chQU1yam9Xjyp60LRhdFRFerRh/mr0XYQR22v8OECXN5Tpw4USXY4WptBw0ZRnFJfR5//Ikrtt2/fz/1CgpICkTwyMMPVzlWWVlJ+/btEUKgc8fgiM/h5ptvoVvP3ngy6xHTevwlN7CvxI8//ohaqydvyhpyJz2DUqX+n9OcHTdhIs74bCIaDsQo2S55/adPn+a5554LSSQOGDwUT0Yd4jvNQG+2YLU7kSuUmDyxRDYZisliv6rMR5PmrXCn1sQUSMGSUEje5FUYvXGYXJH4ittjttr54osvOHz4MC+//HLInn/yyafQ6g1BvfCaJfTq25/9+/dz4+ybsMXlkNJnAVp7AINJ4tChQxTVrI1MoUSh1nH77cE1YI3a9ULrCG96bcxqNZscLqabzKgNEkVlW8ifuhaVWsP+/ftZuHAh69evDz2vW7ZsYcqUqWzevPmy13fs2DGsDheBuj2xJxfjCURVqwe0atUqYhKSyc4r5IMPPgjdl5jW40jsfhNylRaVWsPdd997jZ9mVVIzsomo053o5iOw2J1V1ubffPMN9957L2vXruWxxx77t+xikyG0bBt0Ch8+fJh169axb98+Hnn0UTQ6PVq9gSeeWMEPP/yAw+3FV9QWe2wGvfsNCI29ZMkSPGk1KSzdTHTL0ejsforKthDXbjKNLkZZX4oRI0eF6uYEa934GTNuwjVfb3l5Of/4xz9o1LQ5Gp2eopolJKak44xOxiBZQ1KgvzVvvfUWY8eN55FHHqGiooJDhw6xatUqPvnkk9/lfGEuT9hBHSbMX4QLFy4gk8n43OvnkNePQ6+/airRjTNn4tDrcen1TB4zhoDdzjaXmy99ATKstsvqPP+32b59O3qjGaMzAslq/01TpPbu3YvdaGSMyUya2cz8uXOvue+jjz56MS1qE1GNBtK+U9dqbQ4ePEhSUhJKhYLmGi0TTWbaanUkREUxX7Jw0OunyGBg8eLFHD58GJNkRWW0Ed9xBvlT16KVnGzduhWL0YharcVgcaMzmDCYLbjjM4mIjuX7778Pne/8+fMoZDI+9vjY7/WjVyiIionDW9gGX+1uaCxuknsvIC3r39+TvogY9K4YbGn1kKt1RDUficUdoG6tWqiVKrRKJX1698EelUJSz3k4olN58MEHq1ynxx9J+pD7yZ30NCq5AqdaS6pWj1mtDumhPfTQw3Tr0Yv0rFwMZgs6ixNfXlPkKg2x7SaT1HMuSoMVnSsGldFG1uhlmO3uKvplDz30EHKVFqVewhqfS7OWbVBp9bgL26H3xCJTapCrdaj0ZhRqHSqZHLlSg0pnJDImngEDBqLR6ZEplMgUKgL1eiNTqFCo1Ki1OqzJtYI6x8Udkas0ZI5YTHKv+QghQ64xIFNqkcmVOLKbYHEFGDJkKHKVJlgyXq7AU9wpqI0tZGSPX4HR6qBVm3bMnXczM2bMQKUzonPFkNL3NlRGG7FtJ2HwJ2GMSMOV1zJogGsNyNVaNDYfLVq3A4Lvd4tWbZAp1fjq9MAWkchNc+ZSv1FTIhv2J3vc46jNDhwuD/Xq10dtMKPUmVBo9Dz99NPY3f5/F1eMy6O4Vq0qBTDHT5xEl+49sXqjsLj8jBg1BrVGS+7ElRTO2ojKYEVrNOOLjCUlPZtdu3Zxww03IFNp0Vg9wc9EZ6Zw1kYiGg5EsrtJG3AXRWVbMEakIeRKdEYztyy4NfRZnjt3jt27d19RK/PcuXO8+uqrfPzxx8ycVYY9MglPUVs0ehOt2na4ZKQQQNcevXDGZeLNKCElPfOSUj8VFRXcNGcutes1Yv6CW6+4yH733Xex2p0ImRx7Wj2img0nKTWdBx988JrSHQHuvudeImPiqVW3/iULFIX5cxF2UIft7zDVef/990mKjMSs03HjzJl/9HTC/EG89tpr2IxGnHo9TevUua76JVejXmEhUyULzzqcOA2GalJ5Fy5coEmz5shkMoxGE++//z4JqRmkDrjzYj2bfEpLS6+qfVtZWclLL73EunXrGDpiJCabC6PFztTpv+9zffToUXr07ktJ/UZXjES9HrLyikjpsyC4gZ9Zh5UrV161T15RLZJ6zK0iu1JeXs799z/AgEFDrkmWQaszkDd5Fd5aXXAXtg3JeLRq3Ya5c+dW++x+ro984cIF4pNSCNTqRETdnvgCkXTp0YuoZiOCn2NRO6ZOncqaNWtQmxzkjF9BRMMBqHQmAKZNn4kzLpPIJkMwWmxMmjgRnd6ERm/CZLHhK2yNO60Wtes2CEq2FLbC6oth/oJb2bRpE2abi0C93pjt7pB+9qXYvXs38YkpGD2xRDUficEkXVESDqBH7774a7Qje8wyzM4Ao0eP5ssvv+T111/npZdeuq56Ryq1mrwpqyks3YzJ5mLfvn307T8Qrc5AelZuyJ48c+ZMUOJSpUGu0tC4aXP279+P1eHCn1aMUbKydetWKioqQkFGr776Kp74DIrKtpA5YjGeQFTovD/99BOpGdlY3MGNApPNQ2q/2/FmN2DYiFGXne+aNWswWN1BeRSTnaTkVE6ePMnRo0dp3qoNkbEJ1bS6r8bp06fZunVrNdmS34pdu3YFZRjr9cEemcSceTdfvVOY342wgzpMmL8QDYqLaSlJdDIYsajVjB027LJ/BM+fP49GqeSfbi8feXwY1Gqa1qlDT8nCfMmC3Wi8riImvycvvvgiPoOBcUYTeT9zIn/44Yf87W9/u6KD61qkPt577z2mT5vG8uXLr+ikuu/uu7EaDES6XLz66qs89thjuBJyyJnwFDZfIgmRUZfUa/v222/x+XwIIbAkFKE22YmNimac0cQej48EtYaMrBwgGDmiMZhJ6DyL/GnrkVwB3nzzTXbv3k37Fi1o26IFBw4c4PPPP+ell16qdu1PPvkkOoWChRYrD1ptGNVqhExGSr/b8dbsjEylxR6fy8DBQ0N9tDoD0a3GYoxIJVCvL0VlW4LOapUGf91eSBYPKrkShUyGQWfCmd2UseOqVjXPzi8kqtFAUvrehlqnx+nxExkdyxtvvAEEnXO2QDxRTYdhsgalS1588UUaNmqM2RePTKVFplST0HkWgfp9UerNKLUGGjZpVu0zfOWVV2jQpDkdO3flm2++Ydjw4ciUajQ2P7HtpqDQ6Mmfvp7sMcuCusgJuZSWlqI3W7Em1USu1pHSZwG5E1ciV+uQq3Vkj11OVItRKDT6oBa0XkItudC5olFb3Ch0JqT4AhQ6E8aI1FDxnNjEVKTIFJR6CW+trkEHuUqLTKHCHJONTKUhsvFgXIn5pGZk4S5sh9Jgw5HVGGd2UF8trsNUlHpzMAI8rwB7VAqZIxbjzW7E6LHjOXLkCMlpGai1emLiExkxchRLly6loqKCrLwiEjrPorB0E/boVFavXk1mbuHPFiolPP3007Tp0AlXXgsyhj2IWnLyyCOPVLmn3333HVq9kYLpz5I3ZQ0KpYrRY8ejlZzoHJGoTQ6EXElilzKimg0jLjGFlq3bYEutQ/a4x/HW7IxKayC2zQSsvhgaNm6CwZuAr6QHSr2EUm8hqftNKJQqPv/8c3744QcSklOxuANY7U7++c9/Vntvzp49S25BDRyRiRgtdh5evJjly5eTkp6JO6MuUc2GY7LYLlkwRaMNSsEUlm5Gcvquq0jL5di2bRs2X8xFJ/wAlFoDgYJmmCTbVXUad+7cicnmCmqS1+lB/cZNf/V8wvy+hB3UYfs7THVqZmUx32LlH24PfqPxijJKYYL8yxG6du3ayxYN/l/iwIEDJEZFMcZo4guvnzyrtYoc268lKRDgOYeTQ14/aRbLZdPr33nnHdxuN5Ik0bdvP2y+GHy5TVCqtdSw2nAYDJd0AJ85c4YlS5bQpEED4kwmiqxW6hQUsGvXrt/EVrgazVq2xlfQkviOMzBK1uuu0XEpZs4qwx6VjL92V8xWe6iGy5W4/4EHkJw+/DmNsLs8HD58+LrPW7dBYzxZDfDkt0Sh1mH1RODxRVzy/OMnTkKpUiFZ7Wzbto1z584hlytCtVR0BjPr168POgqz6iDZHOzdu5fly5ejc0ZRWLqJhM6zUOmDDuoLFy6w8PY76DdgEFu3bqVBk2ZE1OlO2sBFGK1OBg0azIIFC1i2bBn+zDoUlW0hudct5BTUYMzYcSF5uoiGAxk1ZuwVrzMuKZW0gYuIbj4SuVKNWqtnxqyyy7b/5ptvKC6ph95oRmuy4s+uj85oxuzwYY9IoFnL1tcsm9mtZ2+cMWl4UorIyi1g1apVOKKSyZ30NBEl3ej4s6KGLm+ApB5zyZu6FsnpY+zYsfiLWgdrATUfSeduPauM/e2332K22olo2B93egkdu3Srcvz8+fN89NFHHDt2jFvmLyA5PZtuPXtftQjrihUr6NG7L0uXLg39rmeffvgKWpE++B6snsg/lVTe4sWLichvSlHZFhK73kjteg2ve4xz585x5513MmXqtOvK4AhTnbCDOkyYvxAnTpygffv2+DUaHrfZqSlJ3HH77ZdsW1FRgUVv4Gm7g/UOJ2atjq+++orhAwbQqUWLkGPxz8Btt93GAIuVL30B7rBY6dqqFY89thyT1YEnMZfouASOHz9epU9lZSUjBg5EKZcT6/NdMR3/3LlzV3Vkf/XVV1h0Ol5xulhssRHj8XDu3Dmat2qDXiang07PTLOES5I4duxYtf7z589HZbQihAxnbnNyC4sxqdQo5HI8ScWYrfZQ21deeQWj2YJao6N3vwEhI2br1q2MHD2GpUuXVjNsvvjiC9q3bk1CXBy2pCJc3gSsZjv1GjSioEZNFGod/rq90Fq9NGjUpMoiqU37TriSCrDFB/WtfYVtkCuUOLIaU1S2hfiOM1Br9Ox0e3nYaseoUFTTD/zkk09ITE5DodKg0mi5//4Hqhxv16kLsW0mBJ2mNTuyYMECADp17YG/fh9kKi0qk53C0k1kj3s8WIxQZ6hmMFdWVjJ69Bg0OgN2rQ6X04XaaMWeVg9PjY7INfqgvMWgu0noUopCo8fji2DcuHEotUa0jgjkKg2pA+4kb/KqYJE/vZmCGc+R2m8hcpUWnd6IUq3FaLEjU6hQmV3I1HoUGn3Qoa3RE9t24kX5CwNytY7oFqMpKtuC1h5BdIuRFMzcgNYRidYRSVHZFlL73U4gKhalRhfsowpGYjtzmqLUS3Tq1JlPP/2UiooKho0YhdsXQa069YiKTUCjM2CKSAlGduc2pVHjJrz44osU1KiFQqlCodJgdnioUasOS5cuJS+/AGtUGlFNh2GUrOzdu5cjR45Qt0FjLDYnjRs3reZQPX36NEazRGLXG4hrPxW7001FRQUvvPAC+YVFqA0SGosHjdUbLLKoVKE1SlgTa6DQmdCYbJhtLuISU7jv/vvp3W8AcrUWa3It0gYuQmP1EtV0GHK1Fovdybx58/Bm1aOwdDORjQfTqWuPau/M1q1bcUYlUVi6mdT+dxAVlwhAIDqWjKEPUFS2BU9CVrV0S4Cc/CL8xR2IajoUq93JiRMnqrW5HPv372fjxo2hVNR/UV5eToPGzZCcXlQ6I1HNg1E+/lqduemmm6445ubNm3HFplNYupnk3gtISsu85vmE+WMIO6jD9neY6mTGxfGkzcHnXj9JkhTW5rwGJo4aRYLZHHKE/i8X2T148CAuSaKN3oBbLmeO2UKyJP2mzqbFDz2EU28gzWKhJD//inIbBw4cIC0tDaVSyahRo+jWrRtNLBa+9AW4x2KjZb361frUbdAYd1IBpsh0svQmvvD4CBhNly1q/lsTGZtA+uB7KCrbgjs+k5deeulXj1lRUcHSpUuZMWNmleLRl+OLL77g1ltvZdasWTz00EO/ODP1+PHjzCotY/TYcezevZvdu3dz+vTpau3++c9/Yra7yZu8ioQupcQnpwFQr2ET3ClFeNJrk5NfRGVlJR9//DErV64MycKdO3eOqNgElDoTcqWasrJ/O4YrKyv55ptvOHfuHMnpWST3nk9h6WZccRkh6Y5gdKyNmFZjcafUYOjwkaxdG3TgRjUdhuT0s2bNGr7++utqa8l/MavsBqy+WGQKJdljlpE7cSVavaFKBuuKFU9idbhwef2h6POadRqQ0PUGisq2YEkoJKrZCApm/g2DZLvmTLoLFy7w9NNPs3TpUg4ePEhOQREqg4WIRgOJaDiQ3PzCUN2ouKRU4tpPJWv0UgySjUWLFmELxJPa73bcqTWZMXNWtfHff/99BgwawqzSsmr1on5LSuo3Cumb+zKqylP+0YQiqOv3wx6ZXC3Cu7KykoMHD16x4Gavvv1xJebhq9UZm9Nd5dkIc32EHdRhwlyksrKSBfPmUZCSwtB+/X7XL+nfk6mTJzPGZOZLX4DJJjNjhg+/bNvNmzcT5XITcDguWSH5z8KHH36I3Wikn9WGz2hk5cqVZOQUkNRz3sV0voJq83/55ZdJkiR2e3zcJFloUqv2JccunToVjVKJ1WC4YmGVffv2YVGpUAuBWSZD0utDx+xGI9vdXr70BYjSai9Z/OWtt97CaLGjc0QihKBx4yb4IqLw5jXDGZ9N9159qrQ/f/58FUNp+/btGCUbEQ36Y/PHceed/y5ccvz4cSxaLVaNDq1eQqZUY4tIxCTZeO2111i0aBGenCYXo35LqdeoWZVznT17lvvuu49bbrmFtWvX4o2IwhaXi0KjJ7LRILR2P3qFin0eH6vtTnwWK0ePHmXchIkMGTaC/fv3U1lZidliI6XvQrJGLUFrMFb547xkyVIkVwB/nR4YJVsoPe61117DYLIgU2kwRqShd8eiNjsxuGNITE2rljb6wAMPoncEiGk9HrXBglyjQ6ZUkzd1TdBBbLZRdsMNaPQmlFojaosLlc5AZlY2trS6FEx/Fo3Nh0ypRq7SoDI5MARSgs5nlRZjRCpWp4cffviB3IIaaGw+5OrgOQxmKwsXLqRZs2ZozA4UOhOBBv1RaPRoLB6iW4xCoTUFDdAZz6H3xCNXafHUaI89Kpni4mD0dnzH6TgyG6EzWWnfvj0P/4fG4r9ISE4jpvV4Mkc+glytJ7n3fOzp9TEFktHoDDhTalJYuglfQRs6d+3G3Hk3YwvE46vdFZVWT6vW7Xj11VdD47355psYJSsRBc0xWoLPxs956aWXSErLJD0rN1QkBUBnlEjpdztqswNjROpFiRUzxohUCks3offEI0Vnkj74Hhyxmdx///1YbE7i2k8J6lcr1cGNAIOVpJ7z8GWUEBUdi94TT+6kp/EVtakS0f/FF1+wcuVKNm3ahNFiJ3XAnUTU70NxSV0AxoybgCMqGV9+c1wef5Xq7//i8OHD9O0flN25WnTzf94Dg9mCKz4Ll8dfbdFWUVHBrl27KLvhRpyxGSR0KUVn8zD9KsVVT58+TUZ2Ls6oJPQmC7dfg47+rbctxGAy44uIqvJ5hPnvEHZQh+3vMNV59tlnsej1eAwG2jZt+j/tbP1vIel07HB7Oej1E2EyXbMs1J+RRx99lPb2YN2WR612zHI5IwcNuu4i6lfj448/5tVXX70mLegff/yRJk2aIISgS5cuxJpMPOtw0kmyMGLgwCptT548iVKlDkbtztqIQqFioWTBZjRe0pb4rTl//jyzb5qL1ROJL6OEyJi4q0ajXis//PADd9xxB/fff/8VI/WPHj2Kw+XFV9gKe1QyE39WILqiooLDhw9fNvv2tdde4+67775uZ/67776L5PSRP209ST3mEh2fBARtowceeIB77rmHEydOcOzYMQYPHU6zVm35+9//XmVeH374YZUig2fOnKFWnWBkss3pZu7ceRglG86oZDKyc6s4yrds2ULbjp2ZNmNm6N4888wzDBoylJUrV9Kzd190RjN6o4l169ZVm39lZSVt2nVAplCSNnARmSMfQaMzhNZpP/30EzqDkfRB95Dc6xbMFiuVlZUMHT4ST3oJCV1vQKU3463ZiYQupRhMEnv27LluaZyeffrhzW9O2sBFKHVm5CoNrrhMrA4Xn376Ke+88w7+qBgMJjO33raQyspKSm+4keT0bPoPGvKHZnBs3LgRo2S9pDzln4E333yTUWPG8vDDD1cJWquoqKBjl24YzFb0RjPPPvvsJft7/JGhek7uuIzw5u2vIOygDhPmIs8++yyJZjOr7U6aSxamTrh2Qf8/Ex9++CEOk4lGDid2o7FKxd+fs3v3bl5++WXOnj37X55hdT7//HP27t17RQP3ww8/5I477ggZLG07dMZf1IaUPrditrnYsWNHlfYbN24k22LhgNfPvRYbdXKrfy/s3bsXl17PB24vK2wO4ny+y55///79mJVK3nd7edruwGU2h47lZ2SQqdHQxmDCoFRz9913h47t27ePpi1bU6dBY26//Xa69ehNdnYOQgjGjBnD/PnzWbx48VX1yO666y4CNdpcjGieTkn9RqFjmzZtQimT4fDGU1i6ifgO04hNTAml2O3cuTPo3G40EHtkMvNuvuWy5zl+/DgqjTYY6dnrFhQqDZLNgT2Qgk6uQC2TMWzoUPIKi/HltyBQ0g2PL4IzZ86g1RvIGvkoeZNXoTOaq0U/r1u3jukzZlSLzj9w4AAanRGZQo1QqJArVBglK3qzlcSUtCqRrD169yO6+cjgxkStrpiis1AaLFgSCnHmNMMbiOTrr79GozNQMPNvFMx4DplcgZAr0dr86FzRqAxW9N543AVtcWQ2wl2jIzKlmtxJz1A4ayMymZzz588TiIrFldMcteQie+xyIpsOpahmCRs2bMBgdWFPr48lvgBv7e746vQISoOo1JitdmRyBbbUEnSeBORKdVA6RKnC4E0MRlT3vwOF1ojO7kOj07NgwYJqC32zzUnqgDspmLkBtdmJkCtRm53kTnoGa3ItbEnFFJZuIlCrE0OGjSAlPQtPjQ6h4xlZ2VXGGzdhAoF6fYJR7A36MXL0GCDozP36669D7U6dOsW2bds4ePAgJ06cQKHR48hqgjEiDbXZQfqQ+ymYuQGVwUpUsxFoDFJoXH/trkyaPJmiWnXw5jUjstEgjJKVvv0H4k6rRVy7ycHo97gs7Bn1kas0aI0SPXr14YcffmD37t2YrXYCWXUxSlYmTZ5MVGwCNWrXCaXBVlRUsGLFCm677bZLyntcD99//z1vvfVWaJGRk1eAXKVFoTFg9MRctoL9hQsXggVczA5saXUxWp3VHP7/ybFjx4hPTMbqicIoWXnqqacu23b//v0YJBtZo5cS12EqcYkpv/wiw/wiwg7qsP0d5tJ8//337Nu37zd3Sv5VyUlKYopk4X6r7b/mCP29ePvtt/EajTxgtdFYsjB+5Mg/ekpAMMNp2LBhCCFIT0sjIzaWHh06VIt4/FcB6Ih6vYio3wedwUTd/HxeeeWVXz2HK70PlZWVjBw9FoVShc3hYtGiRTz22GO/mZOuvLycpNR0vNkNcCcX0rRF68u23bJlC96kPIrKtpA++B5iEpIBWLt2LQ6jEaNCQaTLzf79+6v0W7VqVVC3ubAlJouNjz766JrnV1lZSb8Bg9Do9BhMZrZs2XLJdi3btMeX15SY1uPR6I20atP+ssFDTz75JO7EXApnbSS6+QiatmzNJ598wtatW6/LEbtz504kp4+C6c+S0mcBEdFx1docPHgQvclCXLvJKDQGZAolDy9eHDr+L5m8vClryBm/ApVaQ0VFBadOnWLo8JEUl9Rnzty5FNUsISU9C28gCqPVgT8y+rpqkuQWFhPfaQZFZVvQ2/1ENOgf0v3+eWT55bgW2cvfk88+++yS8pR/Zv7xj39g8URQMOM5knvPD2Vz/idde/TCnVKDQJ0eWOzOalmYYa6dsIM6TJiL3HXXXfS4KCOx0GKlS8tWf/SUfjGHDh1i3bp1IQflli1baFq7Nv27d+e7777jkYcfxmUwkG21UpSZ+YfuqM6ddwsGsxWT1cnQ4UFD91r+gO7Zs4fIqBiMko2Ro6oXaygvL6dVw4bYdTpsRuMlnUd79uzBYzCw+2JkcIzHc9nz7du3D5dez0ceH886nPjt/5bkGDBoMNbkWkQ2How7rzk33nhj6FhkTDwRDfoR22YCktXOqVOnuHDhAoMHD0YIwfDhw694vU+uWEFGbCx56enozRYC9fuhtXrR6IwsWbI0dB06hRKt5CRn/Ar8dXvRqGmLKuNs3fp/7J11gFTl+7d3Os6ZOWc6t7t7FxaW7lq6u0G6u0FARAkRVBQDJQxEyi4EFRUU+YoiSNmtNMtc7x+D83PdJY1vvHv9uXPOc55zduJ+7ue+P59XGDDoFlauXFXmei+88ALtO3Vl5qzZnD9/nkAgQFxiMt7CEnxVSoiJT0Sj1WNQacjVaLlFELGJIkqlivyJT4dMOz777DNW3H03ekFEL5jKVGRUxFtvvcXESZN48MEHyatSRJhSicbsQAxPRak1IPqTyZ+yFU92febODbZanThxgnnz5qE2mHBXaRWsRm4/FVN0Nkq1lqpF1Xj99ddZsGABBkHEmd+C8Pr90JodKLVGskasxeCMRKU1EN18BHJCFVQ6I2EKJWqdEUd2I+zptcnIzgMgKTUDKS4PgzOKmBajMbqiMducfPvtt/Tq0xelRofW7CCp6zwKpm7H7ItnxowZ3H333dSp1wCVWo1KJ+DMa0ZEw4Eo1FpUehNSXB4a0Yo9uxEqvQnBl4jZE0v7TmW14bp06Rp0/xZtqIxyUL5EaySm5TgEZyQ6wYxaqyMqNp7JU6ZilJ1IMTloBAsqgxm1RlsmCHzggQewhScQ3z5oNnjvvfcye+48DKIZg2hm2vSZzJ49B41ewGgPR2cQuO+++xBEE3pHZPB+JScxJaNJH3A3So2eyNh4Jk6aFDSkSS7AJFuQrXYEyYbd5aWkVVveffddzpw5w8jRY2jQpDn9+/fHnV6Dgqnb8dfugSkyA09uQ5q2aMX06dPxVm0TdP9uMCDkKP7pp5/y4IMPVijVEwgEeP3119m2bdt1VVv9xoEDB5BtDpxRSTjcXo4ePYpRlEjts4S88U+i1ovcddddVzy/aUlrYluODSb8q7bk9ivIKf3Gjh07/k/mo+s8ktIyr3jsBx98gOTwkD9pM6l9luDy+q/7vir5a6hMUFfG35VU8lfw6aef0rxePWrl5/8lidB/N4899hhNa9Vi7PDh/1Ga2oFAgMWLF6NQKCgoKLiipvLhw4fp0Lkr7Tt2+Uu0Yo8dO0ZiSjoqlZrW7TpUWHDy9ttvIzt95I57gtjW40nNyL6pa/388880bNIMq8NFyzZtWbFiBbt37+bo0aOYLA4Kpm4nb+ImVCr1FRPmx44dwyRZiWw0GHdaMR27dOPEiROoNFrq6vSc8PgYKpro171sZ2fzlm2IKRkdLEYoLGHRokWh106ePHldBQPff//9Vd8zdpcHf+3u5I7diNEVg6uwJSbZxgcffFDu2I0bN+KITiN/0mYi6vSkXsPGV5VguBL/+te/MFkc5Ix6jLi2k0LyI7/niy++wCCayR7xCEndb8Nid5Y7ZuiIUYiSFaNJYt78BVe8Xq/evXFlB/WOfUVtGfYHT58rce7cOUySjEovIvoSUWl1OJOqkD5gBY7YjCt2YwKham6VSo3HH3FDnYUVcfz4cZqVtKZKca3rlvc5ePAgVarXICktk02bNv2p6/+T7N+/H5PVSfbItcS2HEvyFWL3s2fPcuut80NyN5XcPJUJ6koqucyxY8dwWyzUt9uxC8J1uRf/N3D06FFsgsBy2Uo3SaZ5vXqkRkWx6bIBSZbFUqGGa0X8MZF6IzuxgUCAc+fO8csvv9C3a1eKMjK4a9kyNFod2SPXkjf+SXRGkbpFRSgVCgrT08u0cv2RkvoN6C7JrLRYsQlCuZ3+36558uTJCuVa5sy7lbjEVOLikzBqNEgGwxXbdn5jzLBhCFotZr2eJ554IvT3999/H8lqxxWbht3l4bPPPgOC7UJhCiW545+gYMpWBMnKsWPHQnMbO3YsYWFhdOrUiZ07d5bbRT927BhWo5GlsgWvQUSjN6IxmIgpGUtyj9uI+V1V5SOPPILeaCJMocIXHsW+ffto3a4jcUmpzJ47r1yg+sMPP5CZnYdaqcYmOZEsTm4ZOpyPP/6YZi1aEZ+YQsdOndm7d2/Q2ENr4EWHi5NePylaLelZ2bhSquLJaUBsQlIoIP/+++/LmGt+9dVX7N27t0wb2/vvv48oWfAVd0InSsjxBeRNeApLcjUMrhgybrkPgyOS2NYTcKVWZ/jw4cS43ZhUanR6IxqdHmtKDQzOaJRqLaaINHw1u9G6XQdMshWDzYfBHo5OdqPUGglTaxG8iaT1W4bRZMGVkBuqYvZHxSFIVtxV26IXJJq3KOGHH37gyJEj6AxGdDZ/qKI2sfMc3LmNadW2AxAMtjp37oxBNGOPiCcqJg6TxY4/twFmi42nn34apVpL9si1FEzdjtZkQ2cwoVDrUIs2EjrOQqnRUzBlK3kTN6FUqkJV1MeOHWPQLUPwR8agUKoxumKIbDw4KEWi1iJ6YonvMAPJ7uGFF14gPjmNlF6LKZy2A8GbgCWhCnaXhx9//JGlS5eyYsUKTp8+zfwFC6lZtyHzbp3P/v37UapURDcbTvaox1Cq1EFzx6jMUKW+VjCzYcMGElPSMckyCrU+qMOt1qE1iKGFxsmTJ9m6dStNm7ckol6foF52ajVWrVoVer/9liz/6aefSEnPwihZUWr1eKq2xV2lDb7IGB555BFs4QkkdVuAMyGXebfO54MPPsAkW/Fn10GUrbzyyiuh99KpU6eoW68+BpMFe0QS1WvWuer30okTJxh0y1CGDB1Ot5698NfqFqzGLyhh0KBBePyRJHaeQ/bItWiNpquaF61efT+yy4+vWntEycLevXuveCwEW1zNNhdp/e8ivFZXatZtcMVjA4EA7Tp2RpRtGEUzDz/8yFXHruSvpzJBXRl/V1LJfyPHjx+/Zlfi/zJPPfUURqORyMjI69Jj/rO079iF8BqdyJuwCUdMOo8++mi5Y3bt2oXFE0n+xKdJ6DCDhJT0m7rW6DHj8GTVJbn7ApRaPe7MOpisTtauXYvT7SO8Vjd8hc3Jyi246jhvvPEG7Tt1ZdyEiZw+fZonnngChUpNNaPIZx4fvQSBwX37ljln1uw5OOIyiWs9AcnhDVU2z542DVmvR9brmTmlvMbx9TJx0mQMshMpNheVwYRatJI7/gn82XV46KGHyh1/8eJFWrVtj1KpwmiSMYgSRtHMM888c8PXnjJ1OhqtFrvLE+ry3LRpE7mF1Shp3Y4vv/yS+QtvQ6PVIZgktmzZwqVLlzh16lSZcQ4fPszbb799xerZp59+Gq1BQE6oQv6kzbiz6zNu/ITrmuPx48cRJCsZg+8lof10wsIUdOnWk4joOAYOHnJVuaVXX30ViyeS3HFPEN10KIVFxdf3YK5ATkFV/MUdiWszEVGy8PXXX1/znKS0TCLr9yOx8xyMJqnMWvE/neD7Q4fbFx6SqKzk76MyQV1JJb/jyy+/5PHHH/+v1of7Iy+//DK5VisnvX6ecziJ93qpX60aIySZTXYHTkG45k7fkSNHSI2JQaVU0rFlK06dOkVJgwYoFQryUlOv6fz88ccfE+P1olYqSYyIoESSecxmJ8JkQjRJJHaaTWqfJWi0WupLEoc9PrpJEiMrqIz+jQSfjxZ6A/laLREG4xV3cN977z2yEhKIcrl48LIhw7PPPovFHUlK7zuwxGaTlJrGhg0brvEkg/z0008V7v5/8803vPrqq2VaN3v27hvUVXbHIvoSiYiOK5M8CwQCzJo1i7CwMDR6I0aTFEp8v/baa7Rq0w67Xk+20URE7R6k9VuOSi8S22o84bW7U1Rci9sWLSanoIjadeshu8LxFXdElCy0bN0GT3b94D16Isu1040ZOw6t2Y5PreERq51Cg4Df68fl8ePKa4pKJ6DS6qnboDEjRo3GpFBSRatlkCgiKJSsWbOGO++8k3nz5oXMOf7I9u3bEcwyFncE/sgYVqxYwYULF1i2bBn+wmYUTtuBGJ6KM7dJULOrsCXm2GDy2JpcjTCFguo16+Awm7lTtnCnbMGoM6JUqalaXItqNWtjNJkJL2iCKNsYPHgwtrgcVHqR/MlbyJvwFGEKJWFKNQqlGo3eyPgJE7G7PHhyGiA6/GRkZeMvakvhtB1ENx9J68sO1r6IaEzRWcjxBYQp1Qi+pJADeFpWXpn7PHLkCDt37gxWl1w2gvQVtmDRokWkZmRjcEYjJxTi9PgxCCb8tbpjSayKWh98xlFNhxJRtzfhUbHs27eP77//Hm94JL5qbfFk10MryMS3m0LhtB3YM+oiyZaQ0Ygvpz4rV66kRau2ePMaBx3O9QJVqhWzb98+MnPycacX40oupNbvEqInTpxAstpx5jRBbw/HkliESmfEW9wJreQkfeBKXAUt0MluRLNEs5LWvPLKK+jNdgqmbCVzyP3o9Eb+SNcevfBXa0f+xKdxxmWxZs0aJk+dHkz2G4RQS2RpaSn79+9HaxSxJFVDji/EGx5FIBBg+sxZZOYWMnTEKC5cuMC0adPwVmsXqqru0atP6POTV1iEFJONFJuHFJOD2e6+ojbipUuXiIyJw1/UFl+VlticLhwp1cgcugZTRCo6g8DMmTORrXY0Wh1z5l5ZCuc3Nm/ezIwZMyrUna+IRbffgccfSUFRcYUu978nEAhw+PDhq27UVfL3UZmgroy/K6nkv42ld9yBxWDALQj06979/9sk9TvvvIPH48FsvrKcxF9Fs5ZtiGw4kIKp23AnF3L//feXef3nn3+m/8DBuMOjUWt1iGbppo0Ru/boRUS9PkQ2HBgyMo9tNY5GzUr45JNP6NGrD4NuGXpdCcPf884776A2mHFGpKEIUyAoVWWk3yCYEJ4+YyYNm7bggQeC66kzZ86gV6vZ6/Kwz+XBoNHclIfToUOHUBtEUvsupXDaDkyeOIyyA1/VVpgttlDhz9NPP01cUirZeYWhqupXXnkFqzea/MnPkNhlLnGJKRVe4+eff6Zv/4HUrteIzZs3l3v995+Vw4cPI0oWEjpMx1fUmlr1gvFzaWkpgUCAffv2YXd5UGu0tG7XIZQcHjh4CEaThF4Qufe++8pdo1PXHkQ06I8Uk0OYQoEvIvq6ZV4uXbpEdl4h7pSqOOMyadGqzXWdB/D8889jj0ggf/IzxLWdRFZeIRCsyj558uQNS3/IVgeZQ9dQMHU7Vm8U77333jXPMVtsZA65n4IpW5Gdvn9k8+iv5P/X79J/B5UJ6koq+Tdx4cIFDh48+LfrMP36668kRETQ0Gol3iwxc+pU3n//farl5JAcEcF9V2kJ+o1OrVoxUpI55PGRJ8v07duXGpLMpx4ffSS53C77H2nbpAkTJZnDHh8etYaVlmDCvMRqY8yYMXjDo7C7PHTu3IXWkhRsL7vCuI+uXUuvjh1JjYujlk7POpsdt1JJhNtdLpgCSI6KYpFsYYvdiWww8PnnnzN9+nQcKdVI6DgTjWglvG5vJLuH5cuX07l1a9o1bXrNakgIBlSt23WkVdsOfPzxx+VenzN3Ho6EPMLr9UUvOdGEhaFRKIj1ekOB1ZYtWxDtXsLCFBicUSSnZ7F///6gmV29Phhd0ai1epJ7LKJg6jZMrijsLi+F1Yq55557sHiiSOoyLyi90HJMSG4gLiGJ2FbjgknMrDplWr/eeecd8guqoNDo6GoUOOn1M1+SSYyMRG8UkWJziWkxipwxGxCsbmpUq4ZRrcasUJCv0WIxGK7YFnnmzBmeeuopXn75ZXIKiohvP5WCqdsRvAlInmjatu/E22+/jUm2EdFgADqL+7KMhTVkRmiwh6PSGpg5czanTp1Cr1ZzyOPjkMeHRqlCoVSza9cuHG4vKrWarJxcNmzYgNPjQ2N2oFBriWk5hshGg1Bq9CT3vB1PtfaEKdW0aduO5cuXo9UbMUdnozGaUetF3FVaI7sjiU9KRbbaUWi06CxeNKIVc3QOSo0OU1QGKr3I7NlzQvcbCAR4/PHHGTBwIA0bNcYel010i1HoRJkq1Yoxy1ZUquAcH3nkEbzJ+aHq7fiUdN59913qNmhMrboNsNidWD1RGEQzGqNEfPuppPa+E4VKg1Zy4q7aBqVGz8yZMzFZHfgya2J1uDh+/Dg//PADXXv0oqhGnVDr3FdffYVBNFMwdTvpg+4hTKEIac6vW7cOX0aNYNK923zUggWlRo8tvS4GVwwqvYjRE49SaySu7WQ82fUYMGgwUbHxeHIa4EzIo2XrduX+/ydOnCApNQOFQkl4dBz+qFjUeiPZIx4hY/C96I1CKMj7/vvv0RkECqZup2DqNlRqTRlTm3PnznH27FkeffRRLL5YEjvPQfQmULd+AwKBwO/O3xbUDleqEEzSFYP9P15PoVAGNwn0Ao6sBsS2Gk+NOsGx/906fZX8+6lMUFfG35VU8t+GZDCw0+nmE7cXu9F4zY3Q/2QCgQCbN29m6dKlnDhx4obPP378OBkZGahUKlauXFnhMa+88gqdWrVi/KhR5aphr5f3338fq8OFKNvIzissN06Hzl3xZNUlttV4BMnC+++/f1PXAdi3bx+S1Y7k9KO5XLzgSipgwsTJFR5fWlrKCy+8wM6dO6+pkd20RUsE2YHOaGLFiruveOx3331HYVExOoORFi3bYNLrecbuZIvdiUmvvyGpNQh24Dm9fpRaPfashsHuPYPAXXfdxbx580JFY9999x2CSSKpyzyimw4l6rIW8HvvvYfZ7iZ75NqgsXh2HocOHWL4iJHMmTM3lDBv37ELnux6xLWegEm2XbUY7eWXX8YZnXJZp3s5/j/oUhfXrkd006HkT9qMPTKRJ598kiNHjiBIwarv9IErMUmW0PFnzpzh+++/Z+my5dgiEokpGYPk8LFly5YbelanTp3i3nvv5eGHH74hg8XS0lKaNCvBaJIwSRZeeeWV0PtWMFvIr1KtTPx9LcaMm4DVG4U7MY+M7Nzr+p/PmDUbye7BERnsdqw02K3kSlQmqCup5N/Azz//THZSEuEmEw5JuuLO48mTJ6lbtSpRThdzZ8686ev98MMPrFmzhmeffZYdO3ZgEQTcgkCjmjXL/MAdP36c7du3l6uIbdO4MTMlmeMeHzUtFrp06UJzWeaEx8cYSaZPly5/vGQZWjZsyAwpaFiYIAjY9Hoa2Oz47PYy1dfff/89GfHxOI0CkW53ufb6TZs2ESmKzDKZkZRKFl/WDO9oMFKo0zOkf/9y13aYzbzicHHE48MnisHqaUFA1OjRijb8dXoGKzPr9UVQKukriMw0SzglmVOnTrHq7rspqVePW2fPLvNjGggE8IZHElGnBxF1e+HxRZRLap0/f57+AwfjjYjGoTfgVyrZ6/IwR5KpmReswn3rrbeQ7B7C6/YmLEyByWxmyZIl+HODlRGJnWahk12oDSZ0spvElPRQILBo0SK8Bc3IGvEwBoMJvc1HZKNBmCwObrvtNkTZiicpF7c3PFRN8cILL6A1mlDrRZQaHRqVlrpGEUGhYNmyZRRUrY5OchBery9Gdyzm6GyMSiWvOl3cbbFi0xt49tlnOXbsGAMG3cKQocP58MMPWb16NTt27CAnvxBXfBYWTyTR8Un4a3Yhc8j9qEVryHF606ZNPPfcc7Rp1wGj2UJ0i1EIviSUShU2fzzJPReR1OM2ImLiAOjRoQN+lYpwlRqDWotodZJXpRpRTYaQP2kzVl8seoOAWpAxR2VhTa2JTpBQ60XClCrURglHVgPURgmD1YNeMGNJKEQjWohuPoLoZsMxCCYKi6rjKywhrs0klFoD/jo9iWs9AbXBjM7qRy+5UCiUNGr8f/reK1etQpDtqPQCRldMUH/ObMFTWIK3WnuUOiP+2j2x+uNYtWoVVrsTb25DLJ4ohg4fEVowjBw1Gl+1djiyGmBNqUFcm0mo9CJ6ixtvcRfi20/FFJFObl4+c+fOZfv27TzyyCN8/vnnQLD7Y9ToMYwaPYavvvqKs2fP8tZbb+Hy+pFic1EbTGhECw5vOGPHT2Tfvn2IspWoJkMwR2XiLmyFv25v1EYZlcFMmEqLwR6BGJEWrC5vOozmLdvwzTffsHDhQu644w4OHz5cbsHz448/kpqZjUZnQG0wkdh5LqIvCV/NLiR1vRWNQSQ+OZ35CxaWq2iOT0oNjbdy1Sq0egNavYGlS5eRlJqB3ubHmdsU2RXOyy+/TGlpKd7wSPw1u+ApaoteKF8pdenSJZYtX07XHr3YvHkz6Vm5uDNr406vgUprIL7tFHSym+TuC3Bn1qHfgEFX/S6r5P8fKhPUlfF3JZX8txHucLDaYuM5hxNJr79ih9t/A/PnzCHBbKaDxYLHar3hqmCAX375hSZNmhAWFsbo0aPLxPFHjhzBJgjcKsk0lWV6depU7vxAIMAzzzzDfffdd1Vzy7Nnz3Ls2LEKN7cTUzNJ6bkoaGaXUnBNOcFr8f333/PWW2+x/K4V1KzbkDFjx1eYIAwEAjRpVoI9PB6LO4LBQ4ZdddxAIMD+/ftDUoRX4pahw/HmNyV37EacCbkMGDAAhyThkCQ2Xmc36u/p0r0n3qptyBr2IFqzA61opVu37uWO++STTzBZneRP3kLW8IcxCKbQaxMmTUGr0+OLiOLVV1/F5nTjq94BV2o1WrRqC5T9P3iS88v9H86dO8eiRYsYM2Ys77//PvFJKXiS8pGdPubdOr/MsdVr1SW66TDyJ21GcEWiVKpwef3oBROZQ+4nsfMcHG4vEOy0M4omdAaBPv0HsGjRYkpat+O++1azfv161q9ff0PJ5pslEAjwxRdfhBL2TUtahSr/XUn5rLncZVwRX3/9NfUbNSUiJp75CxYSCAR4/vnn2bBhQ4UV8z///DPr1q3j1VdfLfP3d955hxdeeOEfud+/ioo05Sv5e6lMUFfyP8Hp06eZNHYsXdu2rdAM7z+NVatW0chi4YTHxyxJpn2zig0Z2zRuzCBJ5gWHiyiT6S+5t8LUVFZbbBz1+MiQ5ZDW9q5du7CJIsV2Ox6rNdROBUHtVKckYTcYKM7L48svvyQnORmn0Yjf4aiwevj3fPDBB3htNkw6HQ2Ki3n77bdZv359ha3rpaWlnDhxosyP16FDh3j11VcZM2oUo01mmugMxKhU2JRKaul0iAoF0Wo1GqWSWgWFZYLIpXfcgd1oJMpkpk3Tpqxdu5ZmdgcH3F7aGgxoBYnwun1QGyXUYQoOuL2c8PjwGAXuvvtuYkwmVlis5EoSdy5eHBr3119/Ra3RUjBlKwVTtqLVGfj555/L3Msvv/xCt7btiHI4iNJoSVFr+Mzj4wGrjbzk/9OPnjvvVhweH3GJSeh0OmJjYxFMMr7iTkjeGLQGAcnhw+50Y3W4yS2syqTx46mZm4tRZ8BklBlgFJholjBpdEydOhUIBnNbt24t8zzad+yMUmsgb/yTZA1/GIVShVanY+DgW0LPWhBNKHUiSq2B9IGrsGoNHPL4eM7hxClJ9O7bD7PFjq9aOzwFLdAYRLyZtTA7fBjMVgqmbidr2BpEs0xGTh4KlYYwpZqU3neS0msxBsHExYsXOXPmDGbJglJnxJJcHbXOgEE0k9h5Dr5q7UIavZcuXSI3vwA5PBlPYQkeXzhFNWoT3Ww4+ZOfwez0oxOtqHRG7Jn1UGp02BwupIgUFGot1uRiCqftIL7dFOT4QuI7TEdtMKFQa8mftJn8iU+jVGuoXqsuMS1GBatrlWpyRq+jYMpW1IJMmFKNWqPDXdgKo+zgwQeDenhNWrTC6I4LSXDYEvJQKJTB98XU7ah0AjqrD41BRKXWIMg23F4fBo0Gl9FI22bNuHTpErNnz8GVVh3BE09y9wXBseJyyM3LwxGXRWqfJZjDkxHtPrwFzXB5/Pzyyy988803FFStjkprwJXXFG9Bc+KTUvFHRKE3WdHoDag0OjKHPkD+pM2oBRlrVBqTpkzlhRdeICElDbUgk9LnTuS4fETZhkKlQqnRoZNdKDV6zN44TJKV1157DQhK5AgmCY1BxGi2MGDQLaFF3/z583Fn1glqUBe2wl3YCm/1DqjUGjR6AVdWPVJ6LUZ2hfPCCy9w4sQJBg4ewi1DhoU2qy5cuIBObyBzyP1kDl2DVm8gt7CI+HZTguMm5rFx40Yg2IbZpXtPuvfszbFjxzh69CiF1YrxRkRzxx1LWLRoMbaIJCIbD8ZkcbB9+3YWLlzIokWLsDs9xLYajzO/BWqDiXYdO1+xo+XHH39kyLARdOjUlXfffffKX3aV/M9QmaCujL8rqeS/jVdffZVYrxeXLLPmgQf+9HhffPHFv00rNicxkSdtDk56/dSx2XnqqadCr61fv56cgiJatml/zcT1xYsXGTJkCGFhYbRs2TJU4bxlyxZq2u2c9Pp5xu4kPSam3LkTx4whWZJoYrWSGBl5w1XWp0+fpmmz5ghWN96sOrg8/ivqE//VnDx5EqNJJn/yFnLHbkSl1vwl3WFde/Qiok6PYKI3u941DaKvRau2HYis34+CqduRYnMorFpUoZRiIBCgYZNm2HwxmO1upk6bUeF4e/bswRGRQOG0HWQNfxiLzQHAgoWLglKIWbVxe8PLddt16todZ2IBvuodsNidHD16lA0bNlS49n7vvfewOlyoNVr0koO8iZuIqNeb1IwsDEYRq8MVknHxR8aQ1G0BeeOfxGx3h6Qt6tRviCUiGUtkSjlj+3+CNu07EV6rK/kTn8YRk85jjz12xWNbt+uIr0pL0vouQ3b6QuuBijh9+jRxicl4UgqRXX5mz533d0z/b+fTTz8lKjYepVJFy9btKhPV/yCVCepK/ifo1akTjSWJOZKMTRDLJFf/k/juu+/45ZdfePTRR8mTZT5weegnSVesQK6enc1qi40THh/VrbYyxnw3S+3CKsyQZN5zeYg2m0NmEL06dWKGWeKk108PSeLWW4P6qz/++CNZiYnYDQa8djuffPIJEEwkHz9+PCQZcC0uXrzId999x6xp05AMBhIjru4i/PXXX/Pxxx/zyMMPYzcKpMsWkqKiMOt02BRKWukNvOBwUaI3oA8Lo5pOz0duLx0kmXGjRpUZ67333qN9SUta1K3L/fffj00QmGgyUyhJtGnZElGyYEuvg9UdS7JGQ3Wdjoz4eKZPn84gk5mTXj9zJZnenTuXGbdO/Ua4EnJxJeRSo3Y9AoEAH3zwAV3btmVQ79706dqVVpLM03YHXpUKs0qFSalEMhiYO3cuCX4/XklCrVQS6XLx7rvv8sorr2AymfB6vfTvP4CHHnqIkydPct999yE7fWQMvhdrQhVitTrut9rIMJkQ1Wpul4MbHtUEkYcffrjc8/zmm29o2KQZFocHhVpDWt9lJHaeg2CWQ1WrL730EqJkQXBGoBEsqAUJT/WOyDYfkkqFpNcjiia81dqh1OqDUglTthKmUJA/eQspvRajNojEtZ1MeK2uZOTkM2TYcAxmK2qDCUd2I3JGr0Oj1XH27Fn27t2LRmdETqwSrHJOrUFBQSFqg4jGINKuQyfuu+8+CqtURaXWoNbqSElNo06DxsyYMROr3YlWbyQtMwuVzkhko8HBgLmoLWqNBld2faKbj0BtMBPbejymiHRsGfVwZDUgPikFjdaI3upDZ/EGE7cOF3qjiNUbjShZ0clOjK4YNCY7Sp0RZ25TCqftIKZkDE5fJBm5BfTq1Qe92YYju1EwiWz3kpGdhyUuF0tSEYI3Ab0jCjE8BWduU7SSE53sYrZZ4ojHR4zZzJ49e/jpp5/wRcagUGlQag1oTTasdidffPEFg24ZSnxyGgZRIuOW+yictgNndDK7d++m38BBuHMaBc0WL0tXKFVqVFoD4XV6YY7KRGMQiWk5hpRei1HpRaKaDKVRs6AZpGxzYIpIQyPImGUr7ozaWFNqENX4Fgqn7cCdUYvhw4fz9NNPs3TpUj788EMSUzNI6DiT/MnPoLeFI3liuO+y1t5tt92GK70GBVO34cxpgmDzIFnt7N+/nxp16oe0s72ZNcvpNP5GRQnq9evXozWI6ExWvP4rLxJr1m1AeK2upPVbjtnqpEatusS2HBuSvvm96/xbb71FUloGkbEJFeoR/p56DZvgyqpHRP1+KDW6Cg17/ml++uknTp48+e+exv8slQnqyvi7kkr+F/npp5/YtWvXNbVvJ06eikE0YxBMzF94G5988gkbNmxgYO/etGzQgO3bt9/U9QOBwHUlevt06UIzSeZ22YJdEELFMAcPHkSUbSR0nImvSksaNm1+XdddsmQJSqWS3NxcPv/8c7799lu8NhtdZAupksS0iUHDwBMnToTi4kiHk5cvG4RnWCzs3LmzwvtZsngxJfXqceftt5fpLKvXsAmu1CKs8flY7Y5rVif/lZw6dQrRHJQBiWoyBFGyEhmbQKu2HSrcjP/111/5/PPPr6m1+9FHH2FzupGdPmLiE8sk3Hfv3k1uYRGFRcW888471zXPDz74AKvDhcnqJD0z56rSl6Wlpbz22mtX1Tz++eefcbi9+Ira4EyuEjI2B3juuee49957K9x0cXnDybxlddATJzb9qknY3+Zy33334YzPpmDKVqIaDqBx85Jyx0XFJpDQcSY5Y9YjWux89NFH/PDDDyhUavInbyF/8hYUKjXTpk1jwYIFNyX9efr0aRYuXMiUKVNDnZXX4rPPPiM2IRmlUkWrtu2vmoDNr1pMfIfpwTVWSiHr1q274rFl5FH634U/qvzGz38DJa3bEl67B/mTNuOMSWf9+vX/7in9f0NlgrqS/wnSo6PZYndy0uunht3O1q1b/91TKseYoUMxaXWY9HoefughenbsiKjTUTUzs0LtZAi2BVmNRlJlC9lJSTetj/Z7Dhw4QEp0NKJOx/iRI0OByJQJE2gkyWy3O8mSpFCS8/bbb6dECsp5DJdkBvTsedPX3rdvHx5B5C2nm/mSTJX0DIByrT5tW7VCr1BgUalwGI08arVx1O3FoVaTJgh4tFqMYWH4VSoMCgVt27ShoxRMrg+XZG7p16/MeO2aNaO9JHOnbMEmCDz55JMM6d+fJXfeyZkzZ1Cq1MFK2kmbUShVNG7ShF9++YX33nsPmyDQzWLFJQjl3lfnzp3jwQcfZM2aNZw9e5bDhw8j6fVMNkv0NEt4Lpv7nfT6aW2xMn36dA4cOMDx48fRq1Sssdq432pDVihZKMlUyQg+jz179mCz2XC5XCGtuk2bNuGKz6Jg6nZsiVUZdTlxPtFkpk2LFsgGA+GCQH5aWrn3yYULF2jUtDm+KiWk9lmC1mhGozciWe1ljFrqNGhMTMloCqftwBKfj93ppnqN2vQdMJDdu3ezY8cOHBHxFEzdhtEVgyWpGo64PFRaI3GtJ+DJrk9CchqS3U1MfCKPP/44YQoluWM3kjf+SRQqNQbRzPQZswAYO2483uJOweRhnZ7oBDMGo0jagBVk3LIatV5Ab3Ghk93orF6kuHxUWgOxrcYhOYPabR999BFag4DKKGNwRRPfbgpaswPRn4RksSNIVhwuN1aXH6M7DoMrBqMjgi5dumA1iugsXtxV2lAwdRtyfAFGyY5BMAVN/Wx+nDmNyZ+0GTm+ELXBRHSz4QiuaOTYXBI6zkRrEEhISsZksSPbXcy7dQGnT59myJAhaPVGvJk1UWp0ZI14mMJpOzA4IlHrBUr0emaZJRwGIx999BEPPvgglvBE1EaJtH7LiKjfD39kDOvWrWP79u38+OOPNG3RCndG7aBmutXOd999F3SPr9cXwZuANbUmjrSauNxexPBgcJjaZwmibCcmPgmVzog1JhOzzcW6devYtWtXKIjMGHI/BkHElloDZ14zHNmNyBy6BntkMuPGjcNkseMvbIZJspKUmkF08xHkjFmPTnZhT6vFzMsSRL/88gsFVaujVKmJS0xm3bp1oYXA5s2bESUrnsRcrA4XkTHxJKdl8uabb5b7rlh1zz0hiY/ly+9iyLARuFKCmuZmm6vCRSJAYmoGSd3mUzB1O86YVEaOHBWsmKneAVGyXJeRS0VYHS6yhq0J/Q91euO/tUVxw4YNGEQTRpNEl+49K81b/gYqE9SV8Xcllfyn8uGHH/LSSy9dd5HIb3z22Wd4bTayrFacksSBAwcqPO6nn35CpzeSOfQB0geuQq3RIkgW5MhU9Jpg/PL7pHFFVFSte+zYMRIjI9Gp1dSuUuWqhnqnTp1izLBhtGncuIx8144dO3DFZwb9PHrfQewVTPEq4plnnkEQBPx+P++//z7Hjh1j0aJFbNiwgVdffRWrKGIzGGhWty4XL16kSa1adJdk7pAt2EQxlPx74403mDZtGtu2beOhhx4i2WzmbouVFLOZB35Xua7Raskb/ySF03Yg2T0V+rd88803f5kUy/Hjx/nkk09CMcGLL75IenYekdGxCI5w0votx51Rm6HDR5Y5b8eOHQgmM0aTROt2Ha5ZaX3q1CkOHjxYRlrkwoULSBYbsS3HEt18JDan+7pjk9OnT3PkyJG/TJf4yJEjjBs/gdtuu61cNfZ3331Hh85dKSiqEerGA+jYpRuOxAKk2Fy0gsTAwUOuqa187tw5atapj84g4HB7KzT+e/nllzFbrKg1GsZf1go/ePAgKq2e8Pr98Nfri1Krx51dD1d6DapUq3HD99uwSXNcKUV4C1vgDY+ssAL9SlT0v96zZw+F1WpQpXpN3nnnHZ566ilEyYorNo2Y+ET27dtHz9596TdwULkcxpEjRxAlC/Htp+Kr2oo69Rve8P38J9C4WQmRjQZSMGUrrsSgj1Al/wyVCepK/ieYPG4c6ZJEN0nGY7X+x2muffbZZ9iNRg64vWy3B2USrpfjx4/zxhtv3NCPzc1w+vRpenXqRGpkJONGjAj9YC1fvpw6lw0Oe0kyQ/oPYMmSJYwdNeqKge2V2LlzJwmSxGceH+tsdpIjI6lVWIhSoSAjPp4mzUsoKq6FUaHgabuDIx4fTpWKjqLI3bIVm1LJcY+Pt5xuzHo9M2bMYO/evXzzzTckRkYSbjLhdzj49NNPy1w3KTyc7Zc3MAptNp5//vkyr5e0aosjOg05MgWzWWZQ796hoH///v0sW7aswiTa7yktLSXa58OlVHLC42O/24tBo8EuCNSw2Ql3OkMSBg899BAahYKDbi8fub3owsK412IlOyEhNN6BAwfw+XzIssxLL73ECy+8QHJaBjZfDAajCVmvp4PNjl0QeP311/nxxx85cOBAuaTZjz/+SEZ8AnqDicjGtxDfbgrWqFSq5eTSulGjkFkjQFZOPo7sRmQMuget5GLKlCllApdff/0Vty8cb0FzzOEpWNVaRotmYgxGktOzaNSkGWabm/h2U3Am5JKaEaxsTug4k6Sut6LVlzVXvOeee5B88SR1W4DRHUdsfCJWuxPRYMKoUhOmVKNQqcmbuIn8SZtRqrWo9Kag8WNRG2699VaWLl2K1mQjtvUEtGZn0IW8oAW+ojYMGDSYzz//nIsXLzJ33nwMkiNYLa0XSc3MweN0oTXbsWc1IH3A3egsHhI6zsSaWjNYyazRo9QaMEUEZTAcOY3RCWYEs0z6wJUUTN2OTnajUOvw1eiCweanZ6/eQPDztG7dOlasWEGN2nVxpdfEV6MLSo0Ory8ctSCjlZxERMdy6dIl7rzzTmwJ+ejtERRM2UpqnyWo9aagcWF0Gh5fBIcPH2b8hIn06NUntHHx/vvvI9scSA4fVpuDyVOm8NFHH6EzBo0fRU9cSFf50KFD3H333aHk7vPPP49Kq0ehUqPU6FEolah0RhRqHSqDCbXOSP9Bg2nfqQtRTYZefu5tGTx4MA6XlzCFEtHuxWJ3ltOLP3v2bIULk4MHD7Jx40aMoonELnOJbT0eu8tT4WfqN5NEgOLa9YlvPzW4mZFdL1Sx/UfWrn0UQbJgD48nK7eAs2fP8tRTTzF9+nTeeuutCs+5Hrr17IXRFYM9ox462Y1ao70hp/rt27eTV6UaDZs2/0tMqzz+SFJ6LSZv4iYku6fM57iSv4bKBHVl/F1JJf+JrFi+HJcgkCFbqJaTc0OmdFMmT6avOVjgMMosMbBPH+6++27uvffeMuuMU6dOodPo0KrU6FRqtEoV0ZcLGNxJRcyXZIotlgq7jz755JNQa3zHLt3KJB0H9OzJLZLMMY+P+rLMXXfddcP3/+uvvxITn4gnuQDJ7uGOO5bc0Pl79+7F5/MhiiLbtm0L/b04J4e7LFaOenxkyRa2bdvGt99+S99u3WhWpw4vvfQSEJREFCUrvuKOmO0emjRuzPjLRSMTTGZGDBkSGrOouBae7Pr4q3fA7Q0vt5abPmMWeqOI3iiy8LZF/BluX3xH0ATP4qBn7/8zmb9w4QJm2YItrXbQU6TZcJq3bFPm3PjkNBI7zSZ/0mYsnki2bNlywxvfP/zwA1q9kfxJm8mbsAmVWvO3r11vhuYt2+DNb0p8h+mIvzNLPHfuHD169MBo9ZDYaTbOxDxmzJx1zfF+M+2+WgVyIBAosz47ffo0ksWG0R2L3uZD9buuVKVSdcMFEDq9gdyxGymctgPR5uZf//rXDZ3/e0pLS7HancS0GEV085FYHS4uXbrEp59+ygsvvMBPP/2E1x+Bv0ZnfFVbk5SaUW6MzZs3k19UTKu2Hf5tEkF/lvfffx+b041BNFO1es3/yPfy/yqVCepK/icIBAI89thjLFy48IqL/1OnTvHRRx/dsLvwzVJaWsqxY8c4e/YsJ06cwGIwsMflYb3Njt9u/0fm8Fdw5swZmtapg1KhID81jd5dulBNkhhuMuMwm8vsnH7zzTc0LC7Ga7Uy8pZbygU3paWltGzUCLcgIBsMdO/WjWaSxDGPjw5GAUt4Mo6s+igUSoYKIjudbsxKFVWzs4lxuzFptay22JgkyWRdTubu2rWLcJ+fsLAwfE4nBw8eLHcPM6dOJcFspsRiJcLppHnduuQkJnLfvfcCweBtyJAhhBsMbLTZqSvJzLys43y9fP3110g6HclqNc30BtI1Gjq1asUnn3zCM888U6aV8vnnn8csmHBoDViVKgSFAovRWM7g7bPPPiM6OhqFQkGMaMJiNLJs2TI+//xzPvzwQ+655x5Wr16NNyIayeZkzJgx5Z750qVLaS7LDBdFlBo9YkQaBoWSsZLMjMsbOr8FQrXrN0TwJlyWtDCg0RtJTssoM/cTJ04wa9Ys5s+fT838fCyCQJ8uXSgtLeWOO+7AX9gsKIPRcgzR8clY4/PQW32oDSZGjBgRGicQCNCiVRs0gozaYEbwJmDxxVCUm8tQ0cRRtxetWotKLxLTYhSxLceiVGvRC2b8hS0wSVb27dvHnDlzcBeUhIJug9mCQTDhcHlwef3INgf3rV5NvwGDEL3xofFiWozCYnPQpVsPLE4PJosdvdlKcq/FKDU6ckavI/OW1ShUalRqLUqNDoVai0aQ8YVHITm8GF0xqAUZvSOKqMZDgseoNIwZN55oj4cUiwWnJLF7924mTppMvwGD2LBhA0qtgajGtyCGp6A1mjh06BAjR41BL5jRGM1ozXaUWgNGdywxLccEJTGy6rBq1aoK33u//PIL//rXv8p8tx08eJDhI0bQrHlz5t16K7/++mu58/yRMcS1nkD2iEdQG0zEtByH2mAmofMcoluMIie/CgCLFi3GHp1KXJuJyK7w0IL0oYceola9BkybPv2KgfkXX3xB1eKa2Jwe2nXoxFtvvcWXX36JQTSTP/FpcsasR63RXrNa58EHH8Jsc+HLrovF7uT48eNXPPbw4cO8/vrrnD17lh69+qBSqYmMiavwu+E3Ll68SIfOXTGKJqpUKy63yVlaWkrT5i3Q6gwYRYkJk6Zcdb67du0iLSuXlIxsnnrqKYTLbbb+mp3JKah61XOvh+i4ROLbTSF75FpEyRqSXqrkr6MyQV0Zf1dSyX8icV4vW+1OTnh8pMryDfnTLF26lGJJ4g2nm4ZmM7FeL/VlCzVlmca1aoWOKy0tRadS84bTzV6XB51SiSutBim9FqMz26mi0WJQKiuUrGjUtAUR9XqTN2ET9sikMmZ0/bp3Z+hl0/WGsszy5ctDrx0+fJgubdrQsaTkmgm2n3/+mY0bN7Jr167rvvffc/LkSbKzs1EqlaE51C8qYpYk8y+3lwRJ4sUXX6zw3FmzZuGr3oHCaTuIajqUeg2bYBcEelis2AWhjDHcjz/+yLjxE7hlyLBy8pO//PILWr2BnNHryBrxMBqt7k91ZhmMIplD15A3YROC2RKKkz7//HMMooRWcmKKTEep1pW7t/SsXGJajiGxy7ygB4lRpF7Dxjc8n1Zt22P1x2KQbDi8ESxZsqzC41588UWmTp16xWf8dxKfnEZKr8VBuYqEnDLdsQsWLMCT34S4NhNxV2lN63YdefTRR1m2bNlfXvz24Ycf0rFLN/r0H4A/IhpfUTBxnpqRfcNjibINa3IxnqJ2KDV6Pvzww5ue1y+//IJGpw959Gi0ujKduV999RVGkxRKqCuUyv8q08Mb4fz583z55ZeVXYr/MJUJ6kr+v+DAgQO4LRaizGaSoqL+9grrX3/9lYL0dJxGIx6rlQ8//JCF8+ah12iwimK5ROTfwe8rFk6cOMFdd91VplIAgoHTyZMnr+uL97cEUmpkJDscwWrkYru9jAZdv+7d6S7J7HS6SZcknnzyyXLjBAIBDh06xHfffcecOXNoK0mc8PjoJQhYI9Lx6Y3cIogYwhRowsKoUVQUOnfHjh1USU+nYXExn3zyCQcPHkSrNyKqNHQ1ipgUChrUrFXhNUeNGIGg0yFqNDQ0Cmyw2XELAo8//jgefwQKhZJYvcBxj4+ZZqlCN+8/jnnhwgVOnz7N8IEDqV+1Kn6nk3ZmMxl6PXGRkVf8wQ4EAgwfOQqDIBKXENQS/mMC8ZdffuHDDz/kjjvuQFSp0IaF0c8o0qBaNSBoXNm+eXMEjZaYkjEkdpqNUq1l6bKyweDq1aspkmVqmmRiWowKap2FhXHY4+OYx4ek14cMZtaseRBBtqPU6FHpBMzR2bgz6zJnzpyrPovf+PjjjzFbbITnN8JkdbJq1Spq1a2PZLXTtUevMknML7/8EoNgJn/SZnLHPY5CqcbgjMIqmuhrljjq8VHFZCI2IRG9KKMTzDRr3oIaeXmkx8aG9M8++OADRMmCN68xgmRjxowZQZNHjY6EDtNJH7ACg2DCaJIRvImEKVXkT3ya/EmbUWm0oeceCASYOGkKeqOIQqUhc+gaUvsuRWcwUlSjFjqr77JJ3zYsEUHZC6Vai69GV4zuOBRKNZlDHyB75FrUGh1tL+u5TzBL9O3WLXTfy5cvR/Am4KvZlagmQ9AKZiZPmYojLpuYVuMwynZUajUqo4TRHYs1tSapfZZg8USFgujt27cTk5BMYmo6b7zxBhcuXGDS5MkkpqTRrEVLjh49yoULF4iKjceT1wRXWjE1atcDgouy7du3c/z4cTQGgeQei8iftBmNaEWlF9EKZpRKFTanmz179gDBaujmJS2JT05jwcKFQNCJ2yTbiGoyFEdsJlOmTa/wPdGqbQf8RW3JuOU+dJITo9nK7Lnz6NC5K7I7HLPdzdjxE8ud9+yzz5KYmkFGTn5Ix/CNN95g9erVnDhx4rrej+vXr8cg2bCm1MBdUELdho2veOyaNWtwxGaSM3od3oJm9Bs4qMLjPvvss2t6HFy6dAnZaieu9QTi2k5GNMtY3JEUTN1O5pD7sdid1zX/q/H6668jWWyo1BomT532p8e7cOECBw8erHAj499JaWnpv82YpjJBXRl/V1LJfyI18/MZK8k8aXNgNxorlI24EufPn6dXp074bTZaNmqEWafjuMfHUY8PtVIZ6h68dOkSJr2eZx1OdjrdCFotrdq0R6Uz0sIoMttkxmkwcvjw4XLXqFWvIdHNhgdb4+Oz2LBhQ+i1zz77jDi/H0GjoTgvL5T4CgQCxIeHM1qSmSTJ+B2Ov/27/9dff6V58+aEhYUxfPhw3n//feL8fjQqFbf07XvFtdGzzz6L2eYmqskQrL5YVq5cxbvvvsuSJUuuW3cZglW0eoNA+sCVpPVbht4g/CmJC6vdhRSXjyWxCJ1BCGlDl5aWkpyWiTO1GDkimcKq1cudu2fPHlweHyqdkejmI8mfvAVnTBqbNm26oTlcunSJzl26Yk/II7HTbGR3BFu2bClzzI4dOzBZHPiKO2GyOK64Jr506RKbNm2iWbPmWB0uioprhTpRf+Obb76hQeNmRMTEM+/W+dc1x8WL70RyePGmFREeFcPmzZvp2qMX8xcs5N1330WtM2KKSENrshGXkIQ9KgVvVl0iomNvqHPuRjh58iRDhg1n5KjRfPPNNzd8vtPjx5HTGFdhK0x2z58y8z59+jQ5efkIFidWfyztOgb9lz766COKimuRmpFDZHQs7oyauFKqULNO/auOFwgEWLXqHrp061lGUqWSSq5EZYK6kv8v6NOlC+MvJ4zayvKfdhy+Fvfccw8NLEHTuimSTKdWrYBgkPB378J9/vnnZCUmolQoaFqnDseOHcNrs9HOYiXWZGbRggUAbFi/HslgwGow0Ltz5+ue1+A+fSiWJEaazNhNJk6ePMlPP/1EIBCgVcOGLJSCmssNRVNIl/ZKfP/992QmJGDRG7AajVgMAissVk56/XQ1CjTTGyipV4+33nqLd955p9wcH3zwQcw2LxMvt9aNN5lJjo4ud50ff/wRk07Hcw4n6212JIWCEx4fRVYbaZnZRDYcSN7ETegtHhLUGqxG41UrUt599128NhtqpZKcpCQaSTL3WWx4BIFePXsya+ZMfvrpp+t6nhWxf/9+LHYnFnc4bl8EkYJAslqDIiyMovx8fvrpJ+xmM7Mkma5GAYcnLqjxrNbSvFWwbe/o0aNs3LiRTz75hI4lJWg0WiwJhST3uA2z3ki2yUR1i4W6RUVlnmtmbkFoYWGKSEMKT2b+/PJB39GjR2ncrIT8qtXKVIu8/vrrzJkzh2YlLVFrNMhWe4UVLqdPnw6at7SfRkyLUUGJCY0BMSINk1qNUqGgUc2a9O7XH09OA9IHrEBQqZksySyQZJySHFpI/etf/2L58uXs3r2buMQUEjrORKUTyBxyP3kTNqHWCegkBwVTtyMnVEFn8aC3RyDbXeXmJcp2XPktUKqD1dBJKamotXoUai1STC5Zwx/GZPcxffp0fBnFFE7bQVK3+SiUatIHrCBzyP2otToKzBJvu9y0liTG/q5yvEWrNoj+ZJz5zVFq9AwdOowWrdoS02JUUL6iSgk2hxOD3Y9O9mD0BKu+Bw0OdiScPn0awWQmsfMc4tpORrY5qFO/ISZ/Ct7qHVDpBCKiYvjss88wWZ0UTtsRTMar1Lz77ruYZCvepDw0eiM6sxOFWoNKJ2DPqEdEo0FExydx/vz5Mu+JTl2744zPwVvQDI8vnF9//ZVVq1bhy2tI4bQdxLefRk5BUblnCVCtZh3iWk+47M6eR3j9viFdwrfeequcUWppaSnvvPMOgslMQseZxJSMxuX1s3LlKvoPHBxqsf09P//8M1179CI7vyr3XO6KAMjIzsOeUY/IRoNR6UUKisovyn5j6dKleDKD7a8R9fvRvmPFxrVX47ZFi/FGRFNYrQZqjZa8CU+RN3ETWp2BtKwcXPHZWNwRTLxG9fX1MGnyVCzuSNxJBSSnZfyp1sMffviBhORUZEdQrqUiDcV/B488sha9UUCr03PXXSv+8etXJqgr4+9KKvlP5PDhw9StUpXUqCjW/E7v+Ea5ePEikS43YySZIZJMclR0md/+9evWYdLrMWg0rFoR/A7u2rYt+bJMQ4uFvNTUCpPIe/bsQbY5MJpkqtesU04n+9KlS6F1w2+cO3cOtVLJZ5eLJ0w6XRnzvb+L0tJSRo4cSVhYGM2bN+fXX3+9rvXQ448/TtcevVi16p4/ta578MGHMBhFNAYBhVJJXGLKNTfBr0REdBzuwpb4anRBstjLFMn88MMP3HbbbSxZsqRMkvXMmTPs2bMnVLhVu15Doi6viewRCRV6OgUCAcYMG4ZeoyEhPLxcte7vY1pfQbNya+6hw0cQXrc3hdN2EF63N0OHj6Aiuvfqg2D3ohEsaEQLjsy6tO1Q1qy+bYfO+KqUkNZ3GbLLzyuvvHJdz+r1119n7dq1vP7660HzyEaDcMRl0rlrN2zh8RRM3U76wJWodAbkhEK81Tti88fy9ttvX9f4N8r+/ft5+OGHy3UknD17lp9//vma5y9ffhcG0Yzk8NCkWck1uxJ/4/z58+zbty/0/w8EAhQWFeNOLsQem0V2XmForMSUdCIb9COh40wEk8Ts2bNZvnw5Z86cueo1Vq26B6s/jqgmQzHbPTdtrlrJ/z9UJqgr+f+C4YMH00WS2O/2UF2Sueeee/7W6z344INUlWUOub0MkuRrVuP+lQzq3Zt+ksQRj49askz//v2pZ7Nz0utno81BQUrQTCTa7WaT3cEhtxe/KF63humFCxdYvHgxo4YNY8eOHcT6fBg1GmoVFgalK7RaItVqHEolVlG8ais+BAPVr776inPnztGlY0dSDQZmmWWsSiWJgkDVrCyizWYiTCZGDCpb1Xjw4EF0BiORWh1LZSt+lYpbb721zNivvfYaW7ZswazT8S+3l7ecbtRhYVSRgxUabocTR1YD8iY9g80RSZLBwNy5c6865+rZ2TQ1iqSLMka1lpVyMKne0mbj/vvvL3Ps+fPnWbZsGVOmTg3Jz+zbt4/Nmzdf0am5U9fuRFwO3rzZ9WhQty4Rdgc2WSYsLIzx48cTe7ny/D2XB61CgcZkQ2eycP/9D7B3715MshVnUiE6g8imTZs4fvw49Rs1ISElg9lz5vLYY4/xyCOPlEtsNWrWgoi6vcib8BR6m5+EpJQK5xkTn4hKJ6DSi6h1Rp544glmzp6DQTSjM5owmK3kTXiKuNYTSM/Oq/A+77jjDpQ6I4Ivkbh2U1DqRSwpxYhWN8888wwATZq3JLr5iGAbWVgYh9xejnp8WPR6Vq9ezfz580PSDZs3b8Zic+Kp3oHwen1RanSodAJGTzwKtZbETrNwV22HUmfE6I7F4fFjsTtp1aZ9KMByesOJbj6S7FGPotSbUKk1ZI9cS/aoR1EoVai1ekaNGcuRI0cwyVZ8NTpji0xBrdWHktoGwUSPDh2wmUwU5xewfft2GjRuRtv2nbA63WQOuZ/CaTuw+uN54403eOKJJzBZnfjzm2CSrezcuZPw6Dji202hcNoO7Ol1aNa8BQDffvsteqNI3sRN5I7dSJhCicYokT5gBYXTdmCKyiQsTMGbb76JNzwSX1FbPDkNKKhanf4DBxNep2dQQ7JKa7zVOxLVdDgaky0YcHoTEc0yb775JnXqN8Ttj2TylGnIVjtZw4Mmj46IBPbs2cPHH3+MRm/EXdgyaGJpFMtVtkDQMV0wyehkF3qrD19xZ9Kycipc1J4/f56qxTUxWZwoNcH2wpwxG1CqVFh8cYTX7YMo20KV3YFAgDvvXEp4dBzO9Fokdp6D2e5m165dBAIBzLKVuDaTKZi6DZ3FU063+tKlSwwdMYqI6DhKWrclOi4Bizsci90Z0vi+Xvbs2YPZ7iat33L8xR3xRcZgcUdg8UTSpXtPzpw5w5NPPskrr7zyl2xSOtxeMgbfS8HU7djD466pkX81li1bhiezFgVTtxNRrw8dOnX90/P7s5SWlqI3BivLMoeuQWcQbsrZ/s9QmaCujL8rqeR/nUOHDtGjQwf6dO1aoVzHpUuXylT1Xrx4kbVr13Lvvfde9Tv57Nmz192h+Rst6tenSLZQy2KhdpUq/2hb/YoVK1AqlWRnZ3Py5Ml/7LoAjz32GI6YNPImbiK8Vldat+t4w2NcvHgRhVJJ/uRnKJi6HcFsKWde90e+//57ouMSsPtjMclW3nzzTQ4cOIA3PBKlSk3HLt0qTHTu3LmTaLOZ910eZkkytQsLy7z+zDPPYLLYcCUVoDWaaN2uQ5m5bNy4EYPJisZkQ2M0s3Llygrnp9YEfWfi200hokF/NCY7Nf5QrVtYrWYoVvakVOHRRx+93kcGwAMPPEB4bn0Kp+0gsdNssvOrIJotxLebgq+oDSqdQHTzkchx+eiMJr755huWLltOw6YtWHT7Hdd8jz766GM0b9mGufNupbS0lJWrVuFwe0lITgsVaDz77LOYZBv+rNpIVnvIeHT9+g3oDQIanZ5xEyZd8RojR49BqzeiNwgsWrToupPTp06dIj0zB6snElGy8PLLL4fWGAVTt5E/eQtKlTq0ThTNMlnDHqRgylYkh+e6da67dOtJVJOhFEzdjrdae6ZPn35d51Xy/y+VCepK/r/gu+++o1ZBAaJOR8eSkr9Vh7q0tJTXX3+dhjVrolIqyUpMvO6W9L+CPl26MEoKJseLRJEhQ4bgEATulC00l2X6dg0mH1KiolhlsbLH5cFhNN6Uhmmfrl0ZHjI7sbBixQpyk5KYZ5Y45PHRxO5g/fr11xznt+D3/PnzTJk0ibrVq1O3uJi5s2cjaLV84vbyL7cXrUpVrhJj9+7d1KpZk5ykJJbeUTZYaNuhE1ZvNLI7nJz0DGwGA5Jez+jhw0mNjcWkUCAqFLiUKtRKNQkGAafRGEqAXYn4iAhMFjeJnecg+pIwaXS0stpwWyzlAtvO3XrgSMjFkV4bs0aDT5aRdXqq2WwkRUVVuDM+6JahePOakDN6Hc747FBi7dy5c7Ru3ZqwsDAkQaCu3kCKVktafDzduvcItU6NHDUaX40uwYrcWt3QGQRsDheehGxMspVdu3YxbMAAbCYTNfLyygSOvze36dC56xUDHY1BDCWOje5Y9KKMUqUme9Sj5IzZgEKlJnvUY8S1nVyhntpXX32FSbYixeWhMdnQSk6UOiNaiwdRsoY2TF5++WVMkhVHdComrY4UQaTQYiElJhbZHYmvSkvMFhvz589HYzBhcESh0hkJUygRJAtmbxxyUjVsabUR/SkYXTGYY3IQ3LEIdj9Zwx/ClVLEvMsbG7t370aUrCiUKmrVrYfeKJDWbznpA+5GbxDKvP/27dvHmLHjuOuuu1Cq1MR3nI6nqB0arY5XXnkFyWrH6o1CrTMQUb8fnqK2qHRGHMlFhNfqhmxzhCqEdu3axYoVK0KBafuOnTDYI/DX6YnaYCI1M4dvvvmGM2fO0KV7T2SnH6NkQ3RHY0uvgxieire4M0qNHr3NT5VqNTh+/DjDRoxkwsRJ/PDDD8yddyvOxALS+i1H8MRhcEbjrdYRvVFAb3Hjrd4Jf40uRMcl4qtSQvrAlVi8UeTmF+LOrI0zpzEqrR6NTk9R9WIEk4Qztynx7afhjsvg5ZdfrvC98sUXX7BgwQISUtIRZBsanQGDaCKvSjWGDBsRkpXYunUrzphUcsZuDOqgq3VoBQmDSUKh0qCTXbgzarPssozN6tWrsfrjMLhi8NfqTvrAlfgyavDQQw8xfOQo9JI9KCti9+OPjC7XmvnQQw9hj0ohfcAK3Ok1GD1mHAcOHLiuapU/smXLFlxxmRRM3U5i5zmkZOSwa9cudu7c+bcssqtUr4G/Wjvi2k5CNFv4/PPPb3qsBx54AGdcFrljN+ItbEG/AQM5ceIECxYs4MEHH7zuxc5fSWlpKTq9gcwh95M9ci06g/CnulJuhsoEdWX8XUklf5aPP/6YdevWVZj8raQs58+f56GHHuKBBx64ZlVmIBD4y9ZyBw8e5M0332TLli2YTCZ8Ph979+79S8a+Hh588EHcSfkUTN1GVKNBNGnR8qbGqdewCa6kfNxpxWRk513zt/vuu+/Ge7lzLKrJUJqVtGbPnj1YHS6UKjU9+/SrMH557rnnyJAtHPX4uNdio0paWrljnn/+edQ6A+F1e+MuLCE96/9+G958800E2UFav+X4qrWjYdPmFc4vOjYBtcFMwZSt5Ixeh0KpCmlWP/PMM8ybN48lS5YgShZcsWlExyWUiRMCgQAvvvgizz777BWlUz799NNgZ2FRO6y+WBYsvI2tW7dSWL0mBVWr4UoquNwpuYD45HTWrl2LxRdDXJuJ2MITuPd3XXt/5MUXX8RscxNTMhp7TDpjx41DMMuk9b+L6GbDSUgOPrfW7TsR1fSyEXmVEhYsWEAgEEAvmIOFMYKMSqNDMEm0btehzPv+yJEjCJKV3LEbSe19JzaH+4rz+SOPPfbY5ffddmJbjaO4dj0uXryI2xtORJ2ehNfsTFRsfOg9MGnyVCSHF0dkEsW16l53bLhhwwYEyYbaYCJMoaRj55svgvjggw8oqlGbvCrVQobvlfzvUZmgrqSSv5BLly7Ron594iUJlyCwqAJphN+zcN48HGYzGXFxf8rQ4PccOnQIv8OBqFQSrQnKVcyYMYOWDRowasiQkN7bzp078dntGDQa5s26tktxRfTt1o1hlxPU9WQLd999NyMHD6aGJDHDLGEThFDCrSL2799PlNuNWqmkd9euVM3KIsJkwiqKvPLKK5w7dw6rIHKfxUpdnQ5JqaLbZUO+a/HbLnD+pM3kjn8ClVrD4cOH+eKLL9i6dStpgsBRj48VFivJajXp0TF0LCkJVe7+xqNr19KrY0fuX72as2fP8sYbb9C+fXvchS0pnLaDyEaDaNCoKatXr66w6sLu8pA59AFkycEi2cITNgcmhYL3XR6qW20V6rt99913xCUko9ILmCx27C430bHxtG7enJp5+YgmibCwMBRKFYVaHVaDoYwO4F133YXgiSOl56KgjprRjCcvaF4Y0WAAxTVrkSYFJSgGSDJd2rThgQce4Pbbbw/pUV8r8IiIiSe8zv9VWkc2HoxCpSal12JS+y5FodKgUGtRavSMHTu23Pm7d+/GEZlIwdTtxLedjEmyUFyrDvHJadx332ogmAC+/fbbWbBgAXpBxF3YEqNkZciQIeRXLSax0+xgQJdVG41BRG00o9IZUWr0GO0RJHScgUqrR6/SYJLdxLYej97mI6ZkDJENByJ44oPnV2vPyFGjQ3ObMWs2Gq0encFI9+49EUxmjKKZRx5Ze8XnUbtuPdQGE97izmgFiWrFNYlsOIDCaTuwJBUR0XAgOaPXEaZUo9ToUGq0JKdllNGae+KJJ+jWszf33HMv+/fvR2cwYopMx+yJJik1HbXOgFZv5OGHHyYnvwCFWo9CpUFtsiP4kjHH5GD0JmBJql5h1fq5c+fo0bsvZqsTvezAFJGGRqdn/PjxOBPzyZ+0GV/V1njCo4htPT5YwZ9WjZUrVzJ+wkTMVgdxbSeRNeJhVHoRKSoDndmGt6A5NqebOXPnMXT4CPbt28drr71GYVExmdl5PProo2zbtg2Hx49OdpHQeQ4qvUhsy7G402vSrWdvINhyKbvCceQ0xZJUjeyRa7HEZGGwuMmfvIXwur3QGARq129It5696dajJ/46vTA4IkNGnCYpWDWkUmvIHbuR/Emb0eqFCr9f58+fj7egeehz0alr9yv+f9etW49sc2B1uMoYPv3G6dOnScvMxhGZiCBZrmtj7s/w+eefU9K6HVWKa/1pT4MLFy7Qpn1H9AaB3MIiPvnkE5xuH978ZtijUhk8ZNhfNOsb4+6VK9Hpjej0RubduuAfv35lgroy/q7kf4Mff/yRAwcO/ONGXq+//jo2QaCJ3YHdZLruisP/VAKBwL9lw/KP7N27F7/DgVqppE/XKxdSXA9L77gDpyAQZ5ZoWqcOe/fuJTw8HEEQeOaZZ1h9771YRRGfzcbzzz9/zfEuXLjAZ599dkPJ89OnT5NXpQhBsmKxO8tJn0HwN78wPR1Bp6NXp06UlpZy+vRpRo8ZR/OWbXjuuec4e/Ysq1atYtmyZdfVcbR+/XrskclkDVuDt6AZvfr0I7ewiJgWo8ib8BRWb1SFkhkXL16kaZ06uAQBiyBU+FwGDhqM2mimYOp2csc/gVKl5rvvvmPevHn07t0bV3xWcEO/02wycgsqnN/hw4dxePwIzkhMdi99+vUHYOWqVciucHxFrTHJVp577jleeOGFMkZ+AD1798Xqi8EekUCzklZXLBbYv38/M2bMYP369WWO+eKLL7DYnfjym2LxRDF/wUJGjxmLv1a3oDxJvT4MHHTLFZ/v/PnzcWfVp2DKVmJKxlCzTj1kp4/8yVtI638XDrcXgGnTZ+BMzCexy1ws3mieeuopdu/ejVa0kjv+CWJbjUelE0jttwxnQl4ZY9Fjx45hNMvkjHqM5O4LQ2NeD9u3b8fqiyFr2IOEF3ekpHU7ILip1rZDZzp26VZObubNN9/kueeeu+Hv0qi4RGJbjiV37EYkx81pZAcCATy+cKKaDCG29XjMsvWaG1mV/HdSmaCupJK/kAMHDuAXRT7z+HjN6cKk1V6x3Wj//v14BJHXnC7mSDJFmZlXHPf8+fP06dKFaJeLnh07lqsi/iOPPvooxZc1sO+x2KiZV7HEAvCnqvuOHj1KfHg4erWaOlWrcvr0ac6fP8+82bPp06ULvXv0wKjVEulyVajb1aBaNeZIMh+7vcQJAimiiRMeH8tkK3WrVAHghRdewCPLZGg0rLRYcatUtGzW7KrzOnHiBF3atEGj0xPffioxLcdgc7r57LPPWLhwIVOnTiVWFNnv9jLNLGFXq1lx+Qf/5ZdfZtq0aYwePZqhQ4cSbhQYLpqINAqER8VgD4/HIJgwiGZ8WXUQJetVXahLWrfDlVaMTqVml9PNEY8vKF+iF9DoBDp37cZXX31V5pxPP/0UwWwhpecirO5YUjVaWhpFjAol40QzWpMdV2FLwsLC0ClVpMsyTz75JPlVq2O22OjavScmyYJGtGKKSEdvFLBFJgcrRdOKadK0GfUsVk54fDQ0iqi0BjSCBWdazQorTSvi4MGDONw+whQKTFGZ+Is7YtJqMWh0aNRarKk1yR33OLbEAgqqFDFh4iR+/fVXPvzwQ5q0aEmT5iV4/RF4M2tji0hgyPCRZcZ/5513ECUL/iol6E0ytqSqFE7bQUzJaEpat2Pk6DE4EnKJajoUvWDC6IymYMrWYCBnMGHPbhSUx0jMxximoK7eQJZgRqnWYE0pRi+YUao0GOzhKDU6br/9dmLiElBrtCiUarJHPELWsAfRaHWcO3cu9DkJBAJs3bqVZcuWlZGvGTJseBlNPUGy4MppRPbItQjuWDSiBbVgQak3YYpII2/CJjz5zUhJS6dz584sXLgQs91NZOPBWH2xrFp1D6+//jp9+w9gxMiR6Mx28ic+TWKnWWgMIgqNHr3Vhz2jLvbM+mgEmexRj2GOyUar0/Pcc8+F5nbp0iVefPFFnn/+eUpLS7G5PBhdMchx+RgckTRq0pz6jZqiUCpJSc/iscceQzRbcEYlExOfyI8//giAyxdOSq/F5E98Gq3kJLHLXJQaHYJZxh8Viy0mE3+tbggmCZ1RJKJ+P0R/Cgq1BqXWQHTzkfhrdkOp0WOKzKBw2g6Suy8kNTM39GzHjJuAUqMPdQDY0uuhM9nIGbOB8Lq90RpMRDYciK9qKxweP0qNHp3VS8HU7aT1W47LF0EgEMDh9hLTckxQusQsVfiePnbsGHaXJ9RZ8NZbb1X4Xj9z5gx6o0hq36Wk9FqMUTBVuEl27tw5XnvtNY4cOXLNz89/Mi+//DLuuOD/J33gSrwR5XX9/yl+/fXXm6po/yuoTFBXxt+V/Peze/dubCYTUWYzeamp/6gRbL/u3Zl+2f9mgMn8b29tP336NI888ghPPfXUDSd1169bh9lgQNDpuO8GZRK/+eYbDh48+Jclt+tUqcJ82cInbi9JksQLL7xw02N5rVZedLg46vERZTKzb98+vvjiC/Ly8lAqlejUal50uHjUascly1cd6+uvvyYqNh6zzYnXH3FDVfOXLl3ixIkTV/ST6NmxIwMuS1XmyjLr1q2je68+uNOKiW4+AlG2huTurvd6w0eORrTY0QlmqhbX4ttvvyUrr5C41hPIn7QZmz/uiuubQCDAZ599Vu73+dSpU6xYsYKsnFyUWiNyQhUEXyKSzUl8UgqenAY4kwsRJSuOyCREyXJV47wLFy6wfft2XnvttVAcXrdhE+LaTg52iRY04a677qrwPJVKTd6Ep8if/Ax6wRQqwLkRjh49yh133MHmzZsJBAK88cYbiLIVf5UWiLLtis/n008/xeZ0o9KLaEQrosXJww8/QuNmLZCdPgSzzN2XpU3Onz/P0BGjyKtSnYW33U4gEGDnzp2YHX7yJz5NfPupaARLUMYkvymzZ88uc60Zs2aj1moRTBLbtm277nsLBAIMHzkKs8VGTkHVULd3IBD4yzv/4pNSSew0m/xJm7F4Iiv0JroWpaWlwf/p+CfJn7wFg2iuUFqwkv9+KhPUlVRyk/z666+8/vrrZb4cv/jiC2SDgSdtDuZLMj6ViiiTqcJqup07d5IkyRz1+Nhoc5ASGQkEf1S7tG6DZDBQp0oVvvvuOxYvXkwNSeJVp4s6ksSC+fN5//33qVdURO3CwnKJlZdffplok5kXHS4GSjLtm1fcPvVXEAgEKgz4gwl4gXdcHu6ULeQkJpU7plZeHgskmQ4mGdFgwqrV8o7LwyhJpnWjRqHj6hYVhcwXexsFXBbLVeeUk5TMLZJMT0FAaxDJyM5nx44dOCSJRoJIoihSNSsLrUqFy2zmtttuIxAI8PTTT+M2GpF0BiyJRZj9SZg1esJVKvRhYZh9CZd3/GeRlJrBQw89dM3K99OnTzN9xkyqFlbBYTAQYzJhMRhwZDcmrd8yNKIVnUFg7drgRsZnn32G2xdMmnqrd8So0fOm081Jr58IlZo1VhtqjZ6EznMwRWYE5T5EkVZt2+MrakPW8Icw2vw0MRhpZRTQ6/S8+OKLDLustZubnUusx4PDYMSm0aAVraT1X4GroEUw2Rked0Mu5Nu3b6ewqAZNW7Ri69atSFotqrAwlGodgsWJSqsnvE4v3Bm1aNqiFQ63l8gG/Yis1wePL4K7776bJ554olwwNGvWLNyFLYlrPQFXQUs0RjNRTYZii0ji9tvv4MKFC8ycNZs2HTozb948BJs3mMSs0wudKCFKVrwphXh84fTp3RujQolerUG0eImOjcftiyCmZDQJHWagM9tRaQ1YkqqhNpgJU6rJGHwv6YNWoVCqy7SRLbxtERZPJL68RlgdrtDn//HHH0d2+YlsNBiNaMWSXB21XkSl1hIZE4/giUOKy0dtlLAkV6dg6nZ8xZ3R28NRGSWUGh2ugpJgq2XToXTq2oNnn32WIcOGM2/ePNRGM7ljNxLXZiIqnRHBl4RCpaFg6nYKpm5HqdFiFE0UFlUnOi4RrU5P/4GDCQQCdOneE5svBlt4HK3atqdGrbpoRCsFU7eTM3odeqMABBcshw4d4uOPP+bEiRO89tprnD59mnfeeQenNxyV1kCYUoVSa8DgisEUlYVWdmNJqILGZCe1z5Jgxbg/Dktc3uUE9AJEfwruKq1xZDcic+gDqPQiCrUWa3J1JFc4C2/7PwOdAwcOEBamCH4uLN7g+8gRgVKjw2J3YLI6g/Mesx61Roc9uyEqvUByj9sIr92DvMKgWePbb79NelYuCSnpZZL1f+T777/n+eefv6rm5M8//4xWbyBnzAayRz2KWqv9W2Wi/t188cUXmGQrEQ0G4E6vSas27f/dU/q3UJmgroy/K/nvp1mdOiyUggUbdSxWHnzwwX/s2vPnzqVYktlgs5Nulnj44Yf/sWv/kdLSUqpmZVHTYiFDkunfo8cNnWvS63nW4eQ1pwtRp7vuRP+GDRuQDUa8okhJw4bX1QF5LWrm5bFEtnDE4yNdlv9UF1FWQgJzJZmn7Q4sBkOo8ODUqVM0btyYsLAwOhuNvOoI3vfVEnczZs7Ek9ckmDit1u6K5n83Q9smTZgtyZzw+GhgsXDfffeRnJ5NSs9FwU7AtKo8+eST1z3eY489hj0yifQBd+NMr4Xd7aVWvQasX78es2xFZzDSul2HG9pUCAQCFFStjju1CNEdhehPJqrJENxVWhMVl4hosVMwdTv5kzajUCh55ZVXbmpDf/qMmThiM4huOgyT1cHu3bvLvP7cc88xceJELHYn0U2HEtsqWG17reKu6+W9995jyZIlV5WD7Nt/AP4anSmYuh1nRm369+/P2bNneeSRR7jtttt46aWXGDZiJNNnzKzws3Tp0iU6dumGzmDEaDJjkizYfNF4wyMr1Ba/cOHCX7IBtPr++9EbBYyimfXrN/zp8X7jqaeeCnr1aHS4fBE37SnSu2//YFV8ZCKNmja/qUT64cOH6dS1O526di/TffzfzIULF3jppZf+UWmiv5PKBHUlldwEX3/9NTFeL1lWKzZR5I033gi99ujatbhMJiJVKp5zOJlqlhg6cGC5MS5evEiT2rUJN5mQDAaGDRvGW2+9xb333ks1WeZ9l4cukszwQYMYP2YMg81mTnr9DDdLjBw2DL/Dwa2yhcWyBYcklUuYTBk/HqfJRFpMDJ9++unf/kz+yNtvv0202cxhj4/1NjtJERHljnnjjTfQGwQsSUXEt5+KTpAQ9XryUlLYtm0bS5cu5c0332T16tWYlUraGowICgXtSkrKjfX111+zd+9eLly4gFat5iO3lxMeHx5B4MiRI0yfPh1jWBhOpRJ1WBhGpapcIrZPly4ME03IJiuF03aQM3odSpWGYx4fc80SGkEifcDdhNfoRMMm5au4P/30U1rUr0/dKlV49dVXefHFF3nxxRdDQcOBAwd46623KCiqETL1kOILsGfUx6rT06R2bfSijFZyBeUqDGb0SiUlBiNTTWb0CgX1ZQtWs5mElAxyCqrSoUMHwsLC0BuMRDUZQsHU7ZgjM5hkCpooxktSqJXqvffewyOKbLU7GSrJeKxW5Mh0CqftIK7tZAyOSCSrnR9++OGq/9t33nmH7PwqpGbmlKseOHv2LHv27OHQoUP069cP2RtL4bQdZA59AJvTg85gpGDKVvInP4NSpQq2y0XFUqdBozLVDY8//jhqvYA5Ogut2UF2bh4du3ZnydJl5YKwQCBA/0GDUWu0uLzh7N27l/379/Pkk0/y6KOPYnO4MQomDCY5JD2iMTsxhaeit/kxeuKJaBCU4/AUtUOpE1Eo1SjVWmzpdajXsEnoWunZ+SR3XxBcEKRXY8OG/wvgHn30UWrWqYfZE43aKOGr2Q3BE4daoyVnzAYKpm5HI1iCVb+ChFJnRG0wEdGgP46shih1RnzVOyLKdurWrYvRbCG8bm9kVwSy1U6YQolKZ8RiswfvQbBgS6uNLb0u8cmpBAIB6jVqSkTd3uSM2YDVF8PmzZtRKFXkTdxE/qTNaHQGPvzwQ3RGkaimQ/FVa09mTj4A3Xv2QmMQ0QkSQ39X0e6LiCamxShSei5CqdHhLmqHp6g9Blc0Sp2IzuJBZ/EgeBNwF7ZGaxBRG0TMMTkY7BH4anbFV7MratGCTnbhqdYBpVbP8OHDy7l5J6VmoLO4saTWQG/14S3uFJQaqdqacePHk5Sajie9Bo6YdGrXbYAo27BGZ6DWi2TlFvxtweb4iZMxmmUMopnZc+f9Ldf4T+Ltt9+mY9fujBk7/h+tOPxPojJBXRl/V/LfT+fWrRksybzn8pAuSTz11FP/2LUvXLjA6CFDqJqezqxp066aTNmxYwdjR41i8+bNf8tcDh06hFcUOeHxsd/twajVXve5Fy9exKDRsNvp5j2XB0GrvW5PgOSICDbaHHx2OR69VuXkpUuXmDlrNjXqNOC2RYsrfGa7du3CbjZj0mpp26zZn0p679+/n4K0NOK8Xh5cs6bcXHIyMwkLC0OtVLLwWrKNCxfiSqtO/sSn8eQ0YPyEiTc9rz/y7rvv4pAkwk0mclOC5uWz5szF6o3Gl98Eq8NVrhvz91y8eJG9e/eGkpuLFy/GmxfsNIxsPBhzVBbhtXuQmZvP+fPn+f777294jj/99BNanYGCqduC6yeNDlNEGmqjhN4o4vL48FfvgCevMTn5VW76WZSWlnLrgoW069il3Odl48aN6E1W3FXboFDriIpLILew6Ib1ir/55hv27t3Lr7/+yu23387IUaP56KOPrvv8YcNH4s1vSt7ETbiSq7B06VKq1aiNKyEHR3QqetGMr3oHXOk1qN+o6RXH+f777zl37hw///wz+/bt4/Tp03z11Vd06d6TRk1b8PLLL9Ole0/Co+MYMOiWCg3Ir5fTp0+jNwhkDLqHtH7L0RuFv2RDCWDWrNk4U6qRMegebAn5ONw+DIKJEaNG31CS+Tdd8e3bt9/UvV66dAl/ZDThtboSXqsrvoio/wjZoj9DaWkp1WvWwR6RgNnmYu6tV/+e+m+gMkFdSSXXQSAQ4J5Vq7ilXz9eeOEFli1bRmtLsKL3Vkmm/R8kJ5599lk8gsAokxmvKF4x4Lx06RI7d+4kwumkgc2OVxTp0K4dbWWZk14/E80yvTp14pNPPsEly+TbbDgliX379qFRqTjk9nLE48Ok1fLdd9/x4YcfsmzZMg4cOEBqXBwRGg3RWi01/+Cw/Bu7du1i7ty5VzQ3Ky0tveIPx+p77yXK5SInKYn333+/wnvr1KoVdqMxWFV+hZ39rLwqJHaeE0xCpVfnscceY8+ePdgEge4WK05BYMeOHaxZs4YaRUWMHD683C74c889h1UQiJUkCtLT6dSyFXmyTD2LhcKMDEpLS6mWmckw0USyWs0hj49FsoVaBWV1z1YsX06yyYxRoyO8Xh/cuU3Q6oy85nQxW5KJ9Plx+yKoUr1GGXmH38iIj2e8JLNEtqA3GLH6YrD5YujwB0OIzZs3YzTJGByR6Cwe9Co1KyxWugsCGpONgilbSeu3HJVOoG6dOrRp3pwWDRpw//33s2bNmnJB6MSJEwkLCyNMoUJrdqI1mrDqdIQbDGQmJoa0wrZt20b+ZWmPdTY7UQ5H0LDOFpRKSExK5tVXX63w//QbIfmEFqOIbz8V0Sxz5syZMj/wly5dIis5mQytFs1lHWqVXqBh46bUqtsAc3gyeqsXlcEU1CJuPQF3QQuaNC/h8ccfZ8+ePezcuRPZG0PB1O2kD1yJyxfc4HjiiSeIdDqJ8/muKq2yevX9JKZmojEIxLefRkTDQeisXvInbSamxShUegF7VkMUKg2+ml0Rw4PtZzqLB4VKg8pgxhyTg0a00rxlm9C4Pfv0w51WTFTTYWiNIoXVapR5b3/11VeYzDJyXH6ogthotuLMaxZ0IRcshIWFsW7dOrQGEa3konDaDrJHrkWpNeLyeDGKZkz+JDxF7UMV1XXqN6J27TpoDAJmu4fCqtVRa/VoTHaM9nBS0jMZMmQoVpcXe1YD8icHTfvmzp2LUqMnuvlIYluORa3Vc+HCBd566y0aNmlO+45dOHnyJHv27CFMqSRnzHpyxz2OUq0JtW4aRRNZw9aQP/kZ1AYTYkQaCR1nojNZ0BsFBG8CBVO24iooQSeY8eQ1IanbfFR6Ewq17v+qrh2RKNVaTFYnPXv35YknnqC4Tn369BsQupbBKJI+6B68xZ1Ra/U4kquSOXQNzoQ8lixZwk8//cTKlStZu3YtpaWlvPvuu6xateqGWltvluPHj1+10vqfYPfu3SxevPiGuhwquTkqE9SV8Xcl//2cOHGCqpmZSAYDg/v0+Y9MRuzYsQOPIDDOZMYvitddCXv69Onr1oL95ZdfsJvNLJQsDJdkcpLKdzVejeVLliDqdJh0OubNnHnd5xWmpTFfktnldOMRBPbv33/V45cuW4Y9KoX4DtOx+mKvKJN49uxZjhw58reYEP/G/v37efnll5k1axYqlYr09PSrynacOnWKWnUboFKpKaha/ZrFHjfKL7/8wscffxxKzAUCATZt2sQdd9xx1XmdO3eO/CrVsLjDMYhmevfuzT333IPT7cMRk4ZCrcOWURdTZAZG0XzTn5FLly7h8YVjjkxDis5ErTMS2XAQaf3vwh2Xzrp16xg4eAgjRo3m22+/valrXIsGjZsS1fiWYMFJtQ6YzPINj/Hyyy8jShas3igsdheO+Fx8xR2RbY4yvjFX49tvvyUnvwoqlZr6jZpy9OhRDGLQ8DF/0mbCFIqQ+aNglkLnHTp0iI0bN4bkNlbcfTcZOQV07tojFCdXqV4TX9WWRDcbjt4o4ojPJX3A3ThiM1l5WTbkZvj555/R6Y3kjHqMrOEPo9Hq/jLd/jFjx+Gr2prCaTvQ2/2E1+kV9JlxR14xB/F38Msvv6DR6SmYspWCKVvR6PT/Nhm5v4r3338fiyucgilbybjlPiw25797Sn+aygR1JZVcB4tvu410s8RUs4RDEJg3bx4ZlyU3OkgyQ/v3L3fO888/z8QJE8pVCP6RjRs3Utdm46TXz6NWOwUpKSRFRRFjNuO2WEISEt999x2vvvpq6Ee9Z8eOpEoymbJM6yZNePzxxzEqlegVCgSFEoNCwZ2yhXYGI4JCWc5I4LXXXsMhCAyUZDyCyJYtW0KvBQIBBvfpg1qpJNzpLNcycvToUUwaDfowBTalkvjw8ArvLRAIcOzYsZCG7Ysvvki3du2YPWNGqOL77pUrkewefJm1cLi9fP3110yZMoWhpmDF+EyzdM1WxFr5+ay8nHitZrGybt06HnvsMVavXh2q/uvQogVNjEYS1Wo+9fi4vYIEdSAQYOmdd9Kodm0Ki6rTb+Agpk2adNnIMv6ach5GrZYPXB4OujwolCryJz5N/sSn0WjLt0MePnyYZs2bIyhVWJRKjnt8bLY5UGr0pPVdRmSjQah0RkSd7orXu3jxIitXrqRLly6YHH4UKjUa0YJkcyJ545Gis7DYHKFKlzNnzpCbkkKGxYKs1eJSqxksiKjDwhDUaiKNRmRRvGrLXWlpadCAbtwT5E/ajM4gEhOfhFKponmrNly4cIEHHngAbZiC1bIVvUZHxuB7iW8/FV9ENOfPn0er16PUGkjoMIPo5iPQyS7i201BYzDhSS7AbHMx79ZbEc0Wwuv3wxSejNPjY/6CBZj1epbLFm4RRCyCWG5x8q9//YvImHiUai32rAa4CkqQYvOIazsZnewmb+ImopoORaUTsMdkkJCShtUfh052oxEt+Gp1R6UXiWszicJpOxBcMaxdGzRHPH78OG+++SYjRo4mPDoOZ2p14lpPwCTbypja7Nq1C71gwlezG/boNAYNugVBsmJ0x+BILSYtM4cXXngBk2xFqdEjJ1ZF8CUhehNIz8zCn9eQ5O4LUBslwuv2Ric5EK1ulBodUU2HkT9pM6JsDwZZU7dRMHUbYQolaqNEZKNb0JhsaHRGqhbX5Nlnn0Vy+DBFZmBwRRMdl1jh/3XChAkoVBqSus4jucciFCpNaCNozrxbMZhkNGJwvlrRgiDbWLp0Gfv27cNotpLU9VZ8hSXIDk9ow8kck4M5OhuDIxI5JhtBsnL//ffz0UcfsX//fkwWO3FtJ+HJrkfHLt0AGDJsBFZvNK64THILqlLSph12l4dqxbUYNnz4NTdQfs+lS5c4cuTI/0wF8PPPP49JtuGvUoIoWct07lTy11OZoK6Mvyup5J9g3JgxjL0c8043S9zSr9+1zxkxAr1ajWw0XnWd8cMPP4R+y9966y2a1q5Nx5KSG9JH/o0ff/zxhitr9+3bR3JUFBZB4NY/aOdWRJ9+/Ymo3y/YpVbckYkTJ5U75uDBg0S4XBg1GhrWqPGXSTdA8B67tGlDlMuFTacjXbZQIz+frVu3YjabcbvdV5V2gD/n7VMRr7zyCp1btWLS2LE3ZQq3bds2nDGpQYkyo4QjqwE2fxxjx0/g2WefxenxYYpMJ779NLQmK0qlksiYuKua3FfEuXPn8PgjcOU2wRqfjyc8EkdsBt7CEuwuT2gt+Hfx8ccfo1Fp0MpuopsOQ2u243B5bnicGnXqE9tybLDr0WgmfdAqCqftwB2fyUsvvXRDY/32Xjh//jxWh4uoRoPw1+6BUqPHld8Cc0w21WrUBoJdxaJkwZce9BNau3Ytkt1DUtd5eLLr0aN3XwAkq52MIfeTP2Urgs2LK795qNNwytSpN3y/v2fGrNnojSJ6o8DiO+78U2P9nmPHjuHxhWNxh6MTJeLaTqZg6jacMWl/W9dIRQQCAarXrIMrqQBXciHVatT+Wze5/gm++OILBJNMUtdbiWzQj+T0rH/3lP40lQnqSiq5Dlo1aMBdFisnvX56WKwsXryYUUOGEOlwUlK/wZ/aJX/vvfdwCwIPWm20l2R6tG/PuXPn+PDDD6+q0XTp0iWeffZZtm7dSmlpKZkJCYwUTRz3+EjXaEjRaDjp9bPD4cSi0ZT7Ap4wfjyjLgfEM8wSg3r3Dr326quvEmc285HbywLZQq38/DLnbtq0CZNCwdsuNystVswq1TXv88CBA9gFgbmSTA1JZtSQIaHXXn/9dR544IEyer5xZjMrLFayJInly5ZddezWjRoxXJJ5w+kmzmyusLL2iy++oG7Vqlh0OrRKJS6L5ZpBJgQ1lsMdDlyyXK79748M6dePZEmiUJbR6AxEl4zGkdMYrUaLQ5KI8XhCc/vuu++wiiKLJZkotZo0nY4ESSIvJwel1oBeZ2SAUShnynLs2DHS4+IwarWkx8VRaDbT3WRGqzOi1BmDldRhYRjUWhqYLBiUSlavXh06/+zZs7zyyivkpaRwnyW4MRKlUuNTqWhvMFJLpyMzseIk5m8MumUoFnc4Nl8M/qhYwmt0In/SZuzRqcQkJKFUqVFp9Gj0Iiq9QN7ETaQPuBu1Vs/Zs2cpLKqOSmckf/Iz5I7dGJSu0JsIUyopnLaDpG4LSMnIYc6cOaj1AlJMDiq9iOyLQ6tUImj1eGKyUaq1fPTRR/zwww/07tufhk1bkJyaTmTDAWQNexCt5CSqyVDUehGDScLtjyBMoUSp0ZGalsHixYs5e/YsmzdvxmJzENl4CBmD7kGtM+LKbkBCh+mIkpVDhw5x3+rV6IwCBlGiuGZtMnMLSeo6LxgUplVjyZIloUTol19+SXhUNEq1Bn9EFN9//z3Hjh1j4OAhDBsxkq+//hq7K5jITe2zBKVag85gJCMnjw0bNqAxiMHKCHs4EVExSJcryePbTcHoiiat7zIMohl/ZHSwXbJqG5RaA64qbZDi8jE4o9Cb7YwZN4FLly5R0rotBsGMaJZ58cUXOXz4MK+99loZM55nn30WhUoTNHM0mLE5XJw9e5YpU6ZSv0Ej5s2bR3pWDrGtJ1IwdTvu5AIee+wxAO6//wFSMnNo3rINS5ctw2RxIEWkojZKKNRackavuyxvImMQJabPnMX69evxJBeGqsx/b5Q4fsIEjCYJq8PFtm3bgo7tnkj8tXugF6UKXeX/yLlz5ygqroVosWOW/zOSuZ9++inPPPPMTVcO9Rsw8P8W7jW7Mnbc+L94hpX8nsoEdWX8Xcl/FxcvXvxLk5X/FFu2bMEnikwzS1f0rfk9Bw8exCUIfOj2ss5mJ8ZTPgkXCATo2bEjolaLVRRvOLH2+3GmT5pEXlISQ/v3/9uf70svvYQoWfHnNUKULGW6hR579FFyEhKItNmYeNnDp7rF8pdqe/fq1IkOkoxHqeRZh5PjHh9Jkszu3bvZv38/kZGRGAyGf0wq5tNPP8UmCMyTZBpJMn27dr32SX9g9+7dSA4vUU2HhgyqU3otJjE1A4BGTVsQ03JM0Fg8sx62tFpE1u9L/cZXN6T/Ix9//DGy00fhtB3kjnscrU7Pvffey+zZs29qQ+RGSUpIQKlUoVSqUKi1KFWaKxponjlzhjlz5jJk2PByHXit2nbAX709WcPWoDfbsMXl4K3WHqNo/lPJ1H379tGwaXOsTi/+Or3wFnfC7IkOrdF69OpDRIP+wXVFURtatmyJN6MGhdN2EN9+GlWLg4nsnPxCFJfvUa0X0BhEnDFpWOzOv0TS89tvv70piZersXPnTjZs2MB7770X7CDVG9EJZnLyC/9xT5czZ85w7733cu+9997Uhs9/Ihs3biQuKZXCouJ/pKP076YyQV1JJdfBXcuWkWg2M8pkxiYIvPfee3/Z2IFAgM4dO+I3maialXXTye4ahYXcIpo46vGRr9Ei6/U0FkSidDpGDx9e7vinnnqKaJOJhZKFJLOZ+3+XxHz++edJlWWOeHzcbbFSNTOzzLl79+7FodZwyONjk92By2y+5vweffRRmtrtnPT6WWezU+3ymGfPnqV148aIOh31ior48ccfCQQCrFyxgpb167Nw3rxrtpsdO3aMatnZOCWJSWPGXHM39Ndff70uXa1AIIBFELhLthCpUqEMC6NWYRVOnz59xeO3b9/O448/zksvvUSEP4IYjTaoa61QsECScUgSgUCA999/nxhzUCd652XTmQkTJjBl8mRuGTw4+ONtMDFnzpwy16iSnY2kUJCq1iApFMy+7BCfoNXhrtKapC7zCAsLQ1QoeMnhYphoYtjvNgMuXrxIIBBg5NChJGg0TDZLGBQKLAolJzw+Dnl8qJTKcs/wySefpGXb9vQfMJCnnnqKl19+mVdeeYWS1u2IbNCPgqnbEOx+3LmNCa/bG0tSEflTtiH4klDpjCi1BlR6EY8/nDZt2mDQGdCLNjSXZT40ggWl1oinqD2evCa0bNOekjbtiG42nMJpO3DmNsWR2wRBlIhsPDhYzVDQgnnz5tGwSTO8eY2D0h1aAzEtx1EwZSt6mx+DKHHbbYvYuXMn4ydMZMqUKezfvz+0yPr++++5//77iYlLQKnRodToGDJ0GK3bdSS3sBqPP/44ALLVjkawBLWiNTp69uqN7PTjzaqD1iAiWhxIFhu7d+9m2IiReAtLgonczNrceuutAOzZs4eZM2eyefNmRLNExqB7yB3/BAbBTHxyGi5vOJ27dEEOT8SWVhspOpPCqtUQrG4yBt2Dr1o7RNmO0+PjgQfWcOzYMfr2H0DV6jUwOSNQ6QTURpmCKVvJHrkWg1EMvS+/+uorTp8+zYYNGxDMMvaIBFLSs/j000+55557SEnPwmJ3Iduc5ORX4eTJk7Rt3wkpJhtfza4oNToSU9LwV2tLxqB7sLgj2bhxI0U1amOxORg8ZBiBQIAPP/yQO+64gwkTJpCUkobRbMFbtU1wo8AokT74XlRaPSq1BpVGhz0uG9np5447lgDB9ju9USSt/10kd1+ISqNDkGyhxZMzrxkms8SpU6eu+tl94okncMZlUjBlKzElY6hWs841P+83w7fffsudd97JmjVrrqqHF1x0W/Am52N3ekLtmzfCPffci9UfT2yr8Vg8UddMYlTy56hMUFfG35X897B161YkoxGdWs30SeWrbv/T2bRpE0P69w/5Wnz55ZdXlBO4ngT1G2+8QazZzCGPj9UWG9kJCTc1r0ceeYR0s8STNge1JJk5NyDvcb08+OBDVC2uTb8Bgzh16hR79+5l1apVHDhwIHTMkSNHsBmNrLPZSdNoGGcy85nHR5H81yaoa+Xlcb/VRoFWyziTmSdsDmxGY6iz8KuvvqKgoACFQsGiRYv+9urLp59+mtqX105P2x1kx8ff1DjTZszELFtR6/4fe+cdLTXZve3pJZNJMr2e3nsv9N5777333jl0EEQQFUUUeAFRRLGgIkexYRd77woKKgoqSC/n+v6Y47we6Qjq+/vOtVaWS5I8eZLJnNnZ2fu+zUQ3G4E3vQY9eocKkxYsWIDOJOLIqIfWbMWgeIltOZYadepf1jGOHj2KxxckWL0j3ux61Khd74rmeiUcP34cjVZH1rDVZA1fg0ajpU7d8x+/TbuOuFKq4K/eGY3OwIByU3GAPXv2kF9cDdnuZPjIUcxfsACnx48rPgvFHWTW7Dl/aa5r165DcrgJZNbE7Q2E/XfmL7gOd2IeKb1uwBGZxPLly/H6I/CnVcVqd7Fx40Y+//xzLLKdxM6zMUgu0gfeSrBaB4qr1eTdd9+9otjyWjNj1mwUdxBPfDZZeQXkF1XFl9uQQNV2+IKRV5Sg/vjjj3nuuef+TxuW//9MZYK6kkougbKyMjZu3MjE8eMvavBxuaxZs4Y0SeJ2m51USWLtRap0z8dXX32FV1bQqlQkR0Wxa9cuVq5cyWOPPXbeAGr9unV0b9+e22+7rcI2p0+fpl2zZsgmE3ZRPKutvqysjF6dOqGU69GdL1Hy3nvv0atjR0YMGhRKaksS/SSZZKuV5g0bUr+4mGYNG1JHkvnA66e9LDN5/PgrOv8/89lnn1E1K5sYj4dbb775isY4ffo0Bp2OliYzaTodiVotLq2WmkVFrFu3jmEDBrD8loqmfQcPHqRmQQEatRqvILDOHqpSbmM2UyLJmPR6zpw5w8mTJ8lPS6O2zU6KLFOzqIg0SWKYVUJvEoio3YOEjjOwSEo4ePn+++9xGAzc73DxrS9Ask5PrMHIZEnGajDgSioivv00DEYzuvIkdZxZYNmyZUwaP57a1aqh12pxWq1s376dZs1bYNJqkRU7ssHAENFKR1Gkem5uhevw8ssvIypOLIEk1DoDZqOA0+HEHxmDPyIatc6A1iigOD1E1OlJTPPRiMFU8iZuxpnTGEO53nRUo8HYkqthlN0IehNmkwWDSUStC2l+a00iOkFGcXrYvXs3k6dOw51cRHL36zDafFhdAWrUqoMrMZ+UntdjD8Zz77334ouIJmPw7RTNKMUemYTJbEFyePAEIhCtCikZ2dhdHgJV22GLy0NrFModqjcRjIzGnVyEXrQT2XAQUQ0H0qxVm/C5v/jii/QfMACd2UpMizHhZPmkSZN46qmn6NevH+6EXApLHiemxRhq12/EyNFjCBS3Drl3p9eidp063H///aHWvWodkVx+ouMS0ZmtGEwCdreP6KbDSeoyB4Mg4ozPoXD6VrwFzdEbBaSoDLRGgcjYBPbu3XvO+3TqtBKSUtPRGUwkdppFVMNB55TziE9KQy/aUGu0mKx2BKuMXpCJbjqM1N5LsFiVsImOw+Mjc+idIamTQBIur59qterg8gaYOq2Ebj16EyhuTfbItTgjkxg3bjxWxYEnMReN3oSvagdkfxzJaZnlVeGjiWwwAL1oJ3/Sg8S1nUQwOq5CZdf+/fvRG01YAklYAkmoNFqUhGKMNh8R9fuhE2S0poqSROfi8ccfxxERT96E+4ms1/ecpqZ/lWPHjhEVG48vpz6uuEy69+pz3m1btetATLORocqY/CbceOONl328srIybrzxJpq2bMNtK1b8z7cl/tupTFBXxt+V/O8Q6XJzv8PFux4fDrOZr7/++p+e0hUzfeJEZJMJyWhk2ZIl59zmd4kP+TwSH6+99hrRVisfe/3carNTkJp6RXOZO3cu/aX/dlv269btisY5H6+++ioWyYYrKgPZFaRXn37n3O6ll14iVVH41hfgPzY7ZrUarUpFSlTUFSepysrKeOedd3jnnXfCv6cbN27EY7FQpCjYDQZSIiO5a/36CvsdOXKE9u3bo1KpGDRo0FXT6T0X+/btw2uz0V2xkSbLf/nly7PPPkub9p0YP2Eis+fOo12nrtxyyy2YrTLB2j0J1O4R6ly0OXjttdcue/yvvvqKEaNGM216ySUbaV4Njh8/jk5vIHvkWrJHrkWt0Z7TH+l3nB4fWSPWUjSjFMEbj9Xu4fnnnwdCcpS33347n3/+OQ0aN0OlVmOy+Sgs2UbmkDtweQN/eb6vvfYaGzZsqGAOf+LECYYOH0l6dj7Tps/g6NGjlMyYQfPmLdiyZQsQqlIXbU5iW4/HGpVBYck2EjvPxh8Zi2CVEawyJTNmXdIcfvjhBzZu3HiWjOfVxuH2kjlsFYUl27D5otFotBRMfYSiGaVY7W527doV3vbUqVPceeedzJ8//7zJ9ttXrkRUHLiiksgtKK5MUv8fpDJBXUkl/zCjhw9ncrnUxkSrxNhzVDtfKmVlZVetXeX3qss/ygD8ef233357Xk2xQ4cO4ZZlpksy3WSFusXFfPrppyxYsICRI0eSIkmstTvIFgTyTSb2+IOMKtfeO378OHfddRd33333OX94jh49ypYtW3jhhRfOO/+a+flMlRVKXW48Fku4EmPtf/5DcXoGXdq0Yf/+/RX22bdvH0uXLmXt2rWcPn2aw4cPoxiNWFRqWprMFOkNtDSZmWiVMKnVjLNK5Moyc2bMCI9x3XXX0USSGCFa8Wm1JBqNTJdkBLUa2WRi0fz54W1/++037r77brZu3UqtvDw22ENVEga9kawRaykseRzZHeDdd99l+/btyCYTLq2WkaKVx5xuFK2Wfr17M7hPX1555RWGjxxNzboN2bBhA0MHDsRkMGA0GAi4XPSWJFqbzOTo9ay3O/ArCmvXrg1f36+++orhAwcyYcyYs67LrbfeihxMRkksInfcvdgSq2C0+cgYshIxmExEgwFENhxEenYuTo8PvUVGa7ai1ujQWx1oDAKCJ5aiGaVkDrkDg+ItN+S7j7xJD6DW6pDj8ohpPipUdZxcyF133cWxY8cYPHQ4yRnZ1KpTlzvvvJOJk6dgtEgYLDIZWTkMGz6C2nXrYw/G4c+uQzAqhq+//pqNGzdiEhUMsgeD5MJgdVA0ozRk/GGxkdxjEbLNgTcpL9Tu2HsJgieWiDq9aN2uIwA7d+5ElO3oRTtyYjFiRBrx7adisXnCD4SPPPIIzsgk8ibcT0SdHjRv1ZbvvvuO+KQUtHoDekHCV9wGkyDiza5PzugNmFxRuDLrkdRtPhbFidZgwpFeB63ZikZnIBgZjd5gxOFy48+sFZI96b6AvKJq573ff2fbtm1ExyWgK69Snjp9RoX1tvJkeP7kh9CZJSLq90NvsZE59E4Kp29FdvnCJkbtOnRCDKbgrdIOrclCnfoNK4zVsGkLYlqMprBkG76M6sQkppDYaWZIfzomh7i2k0jusYiE1Aw2b96Mxx/E5fEjuYMUTNlCQseSs7TSTp48idFsIb7tZOJaT0BrtJDcewlqnQF7Wi3sabXRmiyXpAHZb8Ag9AYDcYkpfP755xe9dpfL22+/jSMQEza5lBT7ebcdO24C3oyapPVdhj0YzwMPPHDV51PJ1aUyQV0Zf1fyv0PQ6eQhh4v3vX6cgnBN/uZfLnv37qUwPR2DTkfn1m0uKZH5888/IxoMvO/18Zrbi0mvP2/H3+HDhzl58iQ//vjjWcmcsrIyRg4ahF6rxa2EJCquhE8//RSXJNHQ6cRhsVww7r4Sli9fjlmrY6ok01QQ8dkcLL/pJpIjImhYvXr4vE6cOEGV7GzybDYUjYbeZoHX3B5cglBB1uDnn3+mT5cu1CkoDFej/87mzZvJjIujZl4eH330EWOGDiUgigRFsYKX0HvvvcdDDz10wY7WM2fOMHnyZFQqFQ0bNrymydhdu3axePFi7rvvvqv2Ynr2nLm4YjOIqN8Pk0Widdu2yDYH8UmpPPnkk/+T0gc337IcvdGEzmCkZu26DBs+8rySF526dkeKzsRb3Ba91YEjIoHS0lKW33orsjtAIK8BgmjFnZhP1oi1aI0CCZ1mElGjM0XVavDyyy8TjIpFcbi4feVKINSZXKVGHbr26HVeiYxHHnkEu8uDYndyzz0hmbxTp07xzTffnPX3oV3HzrhTiglU64jd5Qk/b48YPRa90YzWYMYWjMci2dDqdOSOu5fccfeiN5rO2+n7O3v37sXp8RHIqI7V5uT++++/nEt9WeQVVSGiVjeCtXuiM1kwWxVcKVXx5TchJj6xwnn36T8QV1wW/sIWuL2Bc36vomITSOu7jMKSbTgjEy/Lm6aS/w0qE9T/H3D06FE6t25NwG6nZ7m+cSX/Hp5//nmcFgvd7Q6c5wn+Hn74YWrl5dOlTZsKb1svh7feeoslS5bw4osvnnP9vn37ePPNN6/a/fH+++8TJ4fkJ97x+FAEIbxu+vTpDP+DIYzTYiFGkvA7HDz11FNE2u34dHrSRSutGlZMip08eZKc/EJskSmYZRfdevRk06ZNVM3KItrlomH16nzyySekREbykMPFN74AaYrCjh07ePvtt/FaLNxtd9JRkqheVMR7770HhCoi4gIBOsgKBbLCwJ49+eijjwgYTVQxGFim2HBoNLzu8bHHHyRKq6PU5Wad3UH94uLw/ObMmUOMXk9Lk5lxohVBq0U2mnBYLNxy003nvV7TJk6kWJaZIckIRjMG0Y5RdqPVGZg3dy6yycRo0UqWXo9fo8FuMHDD9dfTpHkrrLKNZi3b8Mwzz/DKK69UaFNLTExEpVKxxmZnly+ARqVis92JRWfAnZhL0xatL/pZfvLJJxhMZtz5ISMOX9X2iBFpIZmN4rb4qoakOIqr1wq1+PkjSOu7DF/VDugECZ3VgUZvxJlZD8EbhzUqC7VWT1LXeaT0XIRGZ0QnyPiqdiB33L04I5N4+OGHz5rHk08+ieyOIGPISjyFrTDIbsSINFyJ+dSuW4+VK1eG9X1vuukmtCaRyIaD8BS0CCXJvXHIcfnYkqqS1HUeGr0JkyiT0LEEd3YDNHoTUbHx4YB24cKFBKq2Q6MzkjPmbgI1u6G3yCy4bmF4TmfOnKF33/7oDUaSUjPCbaBlZWVk5haQ1P260HVKq4bBZEFrsmKQnP81EozORPDFozGYyZ/0IBmDb8dilfntt9/46KOPsEgKtqSqmG1eOne5tMqliOg4krrMJXfcvZhEmUcffZQvv/ySQUOG4fIGiG42goJpj2KUHDiSivBVaY/WJGJ1BqhZp164I+DkyZMMGDAAfzCSmnXq8sgjj1R4YfTiiy9iVew4gnHEJ6XQvmNn/PlNSOm1OGTEk9MIiy+BWnX+22ZZVlZG1+49MZoFrLLtLPfuX3/9FYPRTMGULeRPfhiVRoPk9GIWZQyyB2tMDqLT/7e6fp+PX375BdnuJKrhAPz5TS/Yznr48GG6du9FQmoG02fMrKx+/h+gMkFdGX9X8r/DQw89hGQ2I+j1ZCYkoNVoSI6KviqarFdK/x49GCgrfOz1U6worP9TJe65OHToEFajkWdcHrY4XciCcMHfiztuvx3ZZMJmMjN6yJCz1p84ceIv/97s2bOHBx544Jpcy0cffZRYXcgz5yW3F7sg4BNFHnO6GS4rNKv7X3muY8eOUVpaitdmY3P5y4g/J6g7t25NZ1lhlc2B22IJm5t///33KGYz9zqczJIVMuPjMep0fOT184nXj1mvvyJD5dWrV6PT6UhLS7viqv2jR4+yd+/evzUuaNCkOcG6fdGZJQRvHBq9EcnmCBco/C9x4MABXnjhBQ4cOMCRI0eoXqsu3ux6BGt0xu0NnDNZe+LECYYMGYLeaEaQbNSt34iTJ0+SV1QtHJ/LgXhcqVVDidCMuji8QZq0aMW3335LICqG+PZTyRh8O4JV5vnnn0eU7SR0mI4/vwkt27Q/65inT59GECVSey8hvf8tmASR3bt3E5uQhGhzEoiM5ptvvglv73B7yR4ZqvJ2Ryfz6quvhtf9+uuv/Pzzz+zYsYNPP/0UsyCS1ncZaX2XYRbEi74Mu/POOwnk1KdoRinx7aZSq36jv/AJXJhdu3ZRv3EztHojiZ1mhcw4jSZmzJhxVk7D6fGTNWw1RTNK8cSknjNnUVy9JhF1epLaZymi4vg/oblcSUUqE9T/H7Bg3jwayDIvu73UlmWWLl36T0/pb+XXX39l4tix9OvWjXfeeeefns45eeutt1i+fPk522y++OILHILAKpuDvrJC83qXpwkGoVYih8VCX5sdr+Xs9vhnn30Wu8VCoqyQnZR0QXPGS+X48eMkR0fTRrFRrCj07NgxvO7tt9/GIYq0dzhxWiw88cQTfPzxxxw5coTUmBjGiFaWKjbsGg1atZourduQHh3NjClTePPNN7E4Qq1WWcPXoNUbcZnN3G6z09BkothgIC02lnVr1+IQBBJlmfSEBFrUrUub5s2pbrfzvtePT6Mh32jCY7Fwz9138/rrr5Nqs7HHH+Q1txePrPDFF1/gkmVq6A1Y1Go8Gg25BgOdrRKCRsNQ0UqaJFWoit6/fz8WjZadHi97/EEitDqukxW2Ot1IJlOFAPiNN97gscce48iRI5w6dYqlN9zAoN69WbhwIVaTgM0bhyMiFbMgUlcJGcL0F0QktRqr2Ywo25AjU8gZew+K7CLCZCZGkioYXu7btw+T0YhapSLbYETUaDCo1cS3n07B1EfQaLQX1fiGUMubKNswyS70BnO5oZ4drUFApVbj9PjC2uw337wcq82FzR+L1mDCk1KMYFXo1KkT0bHxJKamo1KpMNr96AQJg+JFispEb7JgEiz06TeAM2fOcODAAQYPHYrRLOALRjJnzhycCfnlAdUULP5E5PgCMoasJBAVW2G+N954Ixq9CTm+AK3JitHmQ6M3kpqWUW7KKBJRvx/+iCiKqtWiS/ee/PDDDxXGeP7557HaXEixuRisDmR/LHUbNK7gyj167DiKqtVi6dJlZz1cjB0/AVd8Nt7C1mj0RtQaLWZnBDEtx6KzKCgxWWgNJhK7zkVrtJA1fA1JXeehM5gB+PLLL0lNz0T0JxBRrx+ibLukQMwXjCKl1w3kTXoAnSBjtkg43F6CNTrjzWkYus4WK1Vr1EJvFtFby7XA9QbMokz3Xn0qnMv69XchynYcEfFk5xZUeIn1008/8cYbb3Ds2DEOHDhAm/ad8EfGYBRlxIhUjCbhnLJIP//8MydOnOD9998nNiEZiyQzY1ZI27Jjl27YA7HYvFGkZmQxbtw4vMFI1FodWpOIRXZedjXYtm3b6D9wEHfeueqqPgS+/fbbdOjcjSHDRrB//34OHz5M+45diIiOY/ioMZf03ark30llgroy/q7kf4MVt95K3cJCRg0ZwqpVq8hTFD73BZggK3Rs0eIfm1eXNm0okUOyFHUFgVrVqp+3svKu9eupkpFJ59atuXnZMqwmE4JWS0IwyJNPPnneYyiCwHMuDx97/djN5ivWoP29K/Ji/g5Xm0OHDhHhctHFaiXfaqVZ/foU2Ox86wtwr8NJ7jm0sx955BFksxmzXs+UceMqrMtNSmKzw8Uef5CaDkdYGuH9998n0mplty/AC24vDtGKXRRZa3ewzu7AZrGcM6n34osvUj0nlzpFRed9hnz66adRFAW3210hiXgpvPLKK8g2B4JVpm6DxtdULuSP3HHnnRhFhYh6/UJFFEWtkWNz6dK9599yfIDlt95KtVr1GD9h0hXLNHz66afYnG48cSGTwN+TtXkT7qdoRik2bwQfffTRefc/ePAgX331VTgu7D9wMN70GsS3nYyo2ElITsMi2fD4gnz22Wfh/WSbg4whKymYsgWrzcUdd9yBNzE3bEAZn5x21rFOnjyJzmAgZ8zd5I6/D4NJYMqUqfjym4TMr6u2Z+ToMeHt23XsjKe8gtrh9p63YxlC3QFmMdRd2rJ1Ww4cOMC9997LM888c86Y99lnn0VxB0jutgBvZi0GDx1+jlH/e42rVK9FYmrGFVdaHzt2DJ1eT97EzeRPehCD0czBgwfD68vKyujTfyB6s4iSWIyvSnssVvms5zIIdfxWqVGLqLhE7rxz1RXNp5J/N5UJ6v8PGDNiBKPKjdQGSTJTJk36p6f0t9KqYUPayQrTJBmXJF11Z9przVNPPUWe3c4ef5DHnW6SIyIue4ySkhJGlFcsz5UVBvToUWF94xo1WKbY+NYXoKrZzJgxY84z0uWxf/9+li1bxpo1a84yEPv0009ZtWrVWRphJr2e971+vvEFcGg02MxmWpYneFNlmVWrVqEzmMpbrbpiMQk0LD+3dXYHRQYDZr2esrIyZkybRmZcHIJazU2yjfoWEafFgqLVUmwwsMcfZK3dQY2cHA4cOIBLkpgpK3SSFTITE7GZzfgsFmJ8PlITEhg0YABLly5l4cKFlJaWMnniRNavX3/Wj3+PDh2oLsn0LDcgfMHl4SOvH6vRyP79+3nwwQepUVCArNcT1Btwl2tC/86CBQtQqdQUTH2EwpLH0RpMKGYzhXoDueWmi2a9kfgOJWj0RnLHb0Kv1vCZ18+nXj9Gna5Ce96XX35JVFQUarWakpISHG4PkfX6EqzeiaTUDCAUYDds2oIBgwafFQTt2bOH559/nq+++or333+fLVu2YDIKBKp1IqrBAHQG01lSMO+99x5PPfUUH330EWvXruXdd9+lZp166CUXgjcBtUaHxiigE+2odUZ0goRaqw8/TLzxxhuIsg2D7EZrsiBGZhCbmEx0XAImux+twYzGYEaKycGVkEvPP+kWDh0+gkCt7iHN3xpdsEZloNYZuOmmmxAVB0ld5xMobn3BCvITJ05wxx130LxlayZMmMgTTzxR4T6eMXMW7qR8krrMxeaLCs/9d06dOsUNS5bi9kcQ02IM+ZMfwiC5CNbphRSVTuMmzZgybToWxYnGKKDW6kMV52YrmzdvxunxYbT5Se6+IHQeWbWpWr0mvfr0q1Bl8WceeughdOWGj96i1niy62OWQxIn+ZMfQqc3sG/fPm677Tb8eY0omlGKXrSR1u8m8qc8jOTw8MEHH7Bjxw62b99OfHIanvIku0ZvZH75C5mff/6Zjp27kZlbeFaQuHnzZiZNmnzRduC8wipENxlK9sh1SE4vb731FmfOnOHpp5/G7nSVG2gqaI0CuWM3ktxjIRbZdllJ5hdeeAGTxYrJEcRotTNv/oJL3vdymTh5Ct6MmmQMWoEzOvWSKuYq+XdSmaCujL8r+ffzxBNPEG21ss7uoJ6s0KZZc6rbbOz2BZgnK7Rq0PDig1wj3n//fTyKgqLREKXV0kGSK1QEV9jOYmGD3UkvWaFDs2bEBQJcp9hYbQslT89XOOKz27nH7uR5twfJZDqvseIf+f777xk9bBjDBw5k9+7dHD9+nCa1a+Mwm7GL4lWX8bgYe/fuZeHChaxevZrffvuN3JQUsmw2nILAhvMYIJ48efKcyfRbli0j0mqlscNBjM8XjmfPnDlDo5o1SVMU/KLIdXPn8swzz5AWE0NqdHSFGPx3jh07hsNqZbliZ6FiI8LtpqysjAMHDpwl//Hxxx8TGxuLyWS6rCRelRq1iW01jsLpW3HFpJ0VR14Jx48fZ3rJDNp36spTTz113u26duuOLSGfjEErEIMpyNEZF0xU/s6ZM2comTmLrLwiRo8dd0GD6PPx2GOPoXgiSOw0E3diPjNmzrrsMQDGjRtPoHqnUIK3RmfGjB1Hk+at8KRUwV/YgkBk9HmlKs/FkSNHGDFqDHUbNmHz5s2cOXOGvXv3nvXi4LYVKxCsMla7m87devDLL78QjIrBn1EdxR1k8Q3nLgacN/86BDGkFT1x8lQWLlyIJ70GBVMfwZfbiImTJoe3PXbsGIuuv57x4ydcVLLovvvuwx6IJanrPFwJOTg9Xnwphdi8keHijz9zy/Ll5BRUoXe/ARd8MZWWlUtUg/4kd1+Axaqc0wvnUhgxeiyS04vs8jFgUMVuj88//xzR5iRn7D2IEemh5zuXn4ZNmvLZZ5+dV+aokv+bVCao/z/gk08+waMoZNsd+Ox2vvzyy396Sn8rPpuNV9yhatZ0m51t27ZRIy8fyWSmV6dOV/TDeqmUlZXx008//aVjHD58mJSYGOo6HERbJa5fsIC9e/fSvV17mtety5NPPsm0SZMY3KdvBcfrP/Lwww8TY7Vyk2IjU5K5dfnyCuu7tm3LANHKy24vcTodstEYlr64EA899BB9OnfmtuXLr1pV4qDevUmxSuSazARsNprWrs0iWWGPP0gnxcZNN91Ev969EcxWIswiksmEW5ZpKlhwabR4zWZGDR7MHXfPHtEWAAEAAElEQVTcQYpoZYXNTrRWx02KjbvtTmLdbgrNAn6NlvscTjqKIr3Kq7vfeustenboyOihQ/HZbDzpcvOlL4DPbGbHjh08+eSTFd5Gf//99yxZsoT169dX+PE8ePAgy5cvZ86cOUyZOBGb2YxTEBg3fDiPP/44AVFktiQTodUSo9VSIslIBkO4FTE6Igqt3kSgRlciGwzAqDdiF0W8osjjTjd7/EHyRZn4tpNRa3XYfdEY1RpW2uyssNlxSlKFys2ysjJuueUWLFYrKpWKXr160bZDZ7r17M23337L7t27EWUbsS3H4s9rRPNWbcP73nzzcvQmCxq9CZ3BxI3LbuKdd94JJdCnbKGw5HH0JiHcnjhm6FAEgwGP1UrrJk3C9+SZM2fQGswEClvjN1loYhYw6/SoNFrEiFSSus3H5Ahidzi57bbbaN2uI1GNBoeMD1NrYvbEYpHtHD16lKlTp2IWRTQ6AzqjmdT0rAoJ+f379zNhwgTsMRmk9r0RwRuPSq3BaAtgc7pZs+Y/pGbl0rxV2wrtZSdPnuTkyZPs37+f9Kxc1BotOqOA4gnStHmrs6ph27TvREzzUaHAuKgl119/PWVlZYwdPwFBtJKYks6nn35KREw88W0nUzD1EYw2L3rZjcEiE4yOIz4pjVtvvTWUxC4fy1vYirZt2+IIxqM1ipicEeVO40a8+c0IVu9EbGIyx48fZ8mSpVSpVh23P4KE5DTWrVsHwJx587FHJhPbajxWhxdfIBJfXmM8qVVo0LgZEKoq1uhNBGp1R2u0kNBhOtmj1mORbHTu2h2bLwpnRAI2lweN3kTWiLWk9Foc1lru3K0H/rzGJHdfgOTwsHPnzsv+viekpJPcbQGF07fiiIgPa8nt2LEDrclCxqAV+Kp0QGsQyJu4mdS+N+L0+M451pkzZxgwaAiK3UWN2vX46aef+PHHHxk9ejRak4XEzrPxFrXB7b/8l3yXStfuvYhsOCj0QqGwBQsXLrz4TpX8K6lMUFfG35X8+7n55pvpagsVcdyk2GhVvz51iouxm814bLZrbgB2MZ555hmSJIldvgDPuz0EHY6ztnn00UepWm6ovdnhIjs+Hr1Gw3seH1/7AthNJnbv3n3O8bdv347XZkMym1nxp9j+fOQkJ9NHVhgiK3htdswGA/E6Hbt8AZYrdmrl5f+lcwbYsmULOQkJ1C4ouGAF6x85c+YMv/zyC0ePHuXZZ5+tULH6R44cOcKaNWvYsGHDWYnDXbt2MXPmTBYvXnyWn8qpU6d49tlnL/me2LdvH7LJxFe+AJ94/eg0GubMnY9JCHX73bCkYhLyxx9/pGrVqqhUKq677jp++OGHiz7/1a7fkOhGg8mf/BCOiPhzGl5eLoOHDseTXER00xGIiv281//o0aN07NINi+xAb7JQVK1mWCbvQqxbtw5HZDLJPRbhis/h+sU3VFj/4osvkpVbQMAXYEDPnueU2LjhhhsIFLWkaEYpMS3G0Kpthys618WLF+NOKiBr2GrcyUUsuv56jh49ypIlS5g5a1bY9PtasGfPHj755JPwM+GBAwdYv349zz333EX3+73I5LfffqNG7XpoNFryi6pecRHd3Llz8VdpS9GMUqIaD8UsOyks2UbG4NvxBiKvaMzfsbs8IZ+aksexeSN4++23+eWXX+g3YBD1Gze7YIfHHykrK+Pdd9/l7bffPitn8O233yKIMlnD16ATZDIG305a/1vQ6I2INhdpWTlXpbu7kv8NKhPU/5/w888/8/LLL18VE4dHHnmEvORk6lepyqeffnoVZndt6d+jB8WyTFdZIdrro1/3HvSWZd71+Ci6RE24K+HIkSPULChAMhqJ9Hj+0rX69ddfuffee8MOw/np6bSyiCyQFWSdjlayzARJxi3L520BWr1qFe2bNmXp4sVnJdr27t2LWxCwazQMtog0cTjYuHHjBef0zDPP4BNDc0g0GmnVrNlVSfafOXOGxx57jE2bNnHs2LGQ/IggUNXuIOhysWfPHsrKyti0aRMzZ85k2pQp1C4spFmTJsydO5enn36aAwcO4JYkpvzBfDJZp8Oj0VKrRg06yQrjLFa8Gg3psbHnDAhSoqK4SbHxtMuDRaXCLFhxBOOxB2Lp0asPmzZtwuH24s9rjDMmjQGDhnDq1ClatWmPVqfHF/hvW9k333wT1iaeNnUqo/5QzV7PaGSPP0hTi4X//Oc/vPrqq3gMBh5wOEkxW1CMAttdHqrbbFg0GnL1BkaLVkwqNRq9CcGqMLB/f/LT0ohyOslPSamg2VVWVkbntm3R6I0kdp6N4IlFpVIxYcIEzpw5w5hx47G5PJhkJ3kT7id94K1ExsSzfft2VqxYgUkQ0BoF8ibcT/bItRiMJs6cOUN2bj6iLx4lOpOsnPxw1Wu8JPGOx8cUq0SyTo/PHkoql5WVYRAkFJPIg+XtlwUWKaT73HhISG+sqDViIBlXfA6Jqel4c5uQPeouxEAynvwW6Mwi869biMUqI3hiiW83hYJpj+KISKBmUREBu51m9esjSgo2XxR2lxenN4DGICDF5ZPcY+FZRnZlZWWsX7+e5s2bozcYMRhN1G/YCJPNh0ZvInPIHRRMewzZ5Qu/QPidxx9/HFFxEMypi2Rz8Omnn/L888+jeCLIGb2BqAb9qVW3Ae07dERrFMI62O7C1mgMJuLbTyOh4ww0OgNz585FkOw4M+uhMZgxWiSMZjNakxV/zW74qnVCL7lI7rmIwulbUas1tGrbHkdcTrnWt4zgiUNnttK5S1eOHTvGgusW0qJ1O+66K+QUPn/+fJYtWxZO5j/33HPYfNH4qnbEldMEndGM0Swwf8F1aLU68iY9ENKqNotoDWbyJtxP5pA7sFglAHILq5LUZW4oGZtWlU2bNl329/3hhx/GYpWRHB7qN2oS/hvy9NNPY7L7KSx5nJReN6A1WlBrdai1enr16nPOsTZt2oQzKoXskevwFzYnISUNkyCiNxgxuyIpmlFKWv+bMVuVs2SOrhZ33303WqMZtVaHYJUvWOleyb+bygR1Zfxdyb+fr776Crcs08rhwGOx8NBDD1FWVsbevXv/FZ47hw8fJj4YpLXNRpYsM3ro0LO2OXjwIImRkdR2OPCLIhMnTMBpMBCl1ZKo0+G1Wq9aEciJEyfQajQ87HAxXrSiV6mYK8nEl+sxz5IVGlWv/peO8eOPP6IIAhvsIb3nrISEi+6za9cu4oNBRIOBarm559SDPnXqFONGjMBpNlPNYqFYUWjfvHl4/QcffIDTaqWZ04XDYjmv586lUlZWRtsmTchQFJJkmX7du2MwmckZczfZo+/CYDSddY8dO3aMdu3aoVKp0Or0+COi2LVr13mP8eGHHxKMikGj0dKjd9+rIguWlVdEco9FoeKJzBrce++9f3nMPzJt+nQC1TpSNKOUyPr9adi4aXjdDz/8gGCViWk2Em9WA1xm8Zza6J9++imSzUEwrwFWm5NHHnnkiuZy/PhxunTviccfQeduPf7W7/yJEyd4+eWXK2iPf/zxx9x+++288cYbFbY9ffo0n332WQVZiz/yV7/fH374IVbFTkRuPSySDZMgEt9+GoGq7ahR5/KlQf/I/OsWIjk8OCOTqFqjNqdOnaJ5q7b4chsR22o8omy7Yv31P3LjspsxW6zoTSIxzUchxxcQ2WAAhSXb8KZXZ2W5GWUl//e5ZglqlUrV86/s/1eWygD52rFv3z4UQWCd3cF0WSEnKemfntJFOXHiBB3btSM7IYH58+bRtW1bZpZrwrVQbCy/xIqDy+WOO+6gnmLjG1+ASbJC93ZnGyZcCc899xwmtZoMvZ4YrRazShXWO06z2c76UbxUblq6lChBoLVZwKzRsHr16gtuv3DhQgaUS8csVWwE9XqmXwP5mDfffBOPoqDXaOjWrl2F4O3BBx8kXpJYZXNQJMvcsGgRACtWrKCKKOLQaOgqWBDUagSdjprFxezbtw+vLGNVq5HUalo2bgyEAt89e/aEqzF27tyJ3WRCUaspsUpodQYKpj5C/uSHUKs1JFpEBEeAohmlZA1fg+JwMmTIEGzBeAqmPkJUwwE0atr8rPN59tlncVssjLFKODQaPBoNw0UrksHAp59+yhNPPEGmrLDbF2Cd3YFHq+UGxRYyW1SpqGEwUKDXY1SpSB+0AmdmXYIGA6ttDoplmamTJtGle0/adezCRx99xMcff4zTZEa2OigseZyMoXdgNJlRqVTUr18fqzNAdLORODLqYnFHYg/GUb9hYxRPkEBug3JZBxMZQ1aS0msxZouVMWPGsHXrVu6++27WrFkTro545JFHyCtvrV1hs1NsMOATxXByfsuWLYgGI41NZm5SQgn3uPjEUJVyQiEavZGMISvJGrYal9dPUdUaaPRGDIoXnSAT3WwUOr0Bnd6ANTIdT2ErTI4gWqOFJKOJl91e0g1GBF88ST0WYnVHUVhchezcPHQGA0azwN1331Ph85g/ezYZksRQi4igN5HccxFanQGD4sbsiiKm+SjS+t103ra2rVu3EhUTh+zw0LR5SzZt2oQ7Jo3C6VtJ6FhCTkExr732GhbJhje1Ghq9EavDi0qtIXf8JvInP4xaZyCvqCoOhwsxkEzGkJXEtZlESkY2OpOIv3pn4ttNRa3VY3ZHI8XmYnZGYLRIZA65g6IZpYiBZDQGIRTURaUxcfJUjh49ys6dO8/b8nvkyBHiEpPxpRajeCKYM3ceEAqUveUV3fHtp2KVbYwcPTYkkyFYWFX+t2HduvVYbS78qcV4/AF69u5L7779w5/3pfLTTz/xySefVPhunzx5krzCKgh2LwazBa1Oj6egJSqNDrVWx4QJE86qjlqxYgX+rDoUzSgluulwDBaZ/MkPk9R1LnqTBTkyFZ0gY0uujtXmuiZtzAXF1YhuOpycMXcjOX289tprV/0Ylfw9/BsT1P9kbH0pS2X8Xck/wTfffMO6deuuOP691vz0008sX76cTZs2nTcB+euvv7J582Z27tzJjh07SJIk7nM4GSdK5CYlX9X55KWnY1WrGWQRsWs0TLdKdDYLaFQqYv3+83ZjXioffvghEeV6zy+7vdhF8aL7DOrdm+Gywje+AI1lhZvOYSq+7MYbybVakdVqvvEF+MIXQKvRhDsYS0pKGFJeAFIiyQzq3fuS5vvll1/yyiuvnFP/+fTp05SWlvL0009z9OhRTGYLGUNWkjFoBSahom71Cy+8wD333MOcOXOwuKNCXiuym+49e3HkyBH+85//cM8995zzOH++L86cOcP27dt54oknLlveYO78BdgDcfiLWqI4XHz11VcXTNx+9NFH1G/clJp1G/D6669fdPwPPvgAQZRQYnMx6o04zWa2bt0KwEsvvYTijw09Gw1bjWQw06hatXOO8+WXX7Jq1apzHvP48eOsX7+etWvXXpZEx9/FsWPHyM4rxBkRjyjb2LRpE++88w5W2U6woAlWxUFpaSkQqlTPL66K5PBglW2XHXuWlZWxZMmNNGnRmltvu+28yewvv/ySdevW8d5777F161aKqteidbuOfP/993/1dHnrrbd46qmnwvduZGwC6QOWh7o+E7LOKZFzpbzzzjskp2chSDb8VdqRN/EB3HGZ3HUeuZ8r4aGHHsLmcCHbHNxzz4UL8ir5+/nLCWqVSpV6jiVNpVK9dCn7X4ulMkC+dvzRZOJltxeH1fpPT+mirLjtNrJkmRU2O4mSxKJFi3DLMtGSRHp8/Fk6YleLNWvWUENR+NoXYJSs0Ltz56sybuuGDblBCZn5NTCZkE0mqsshveMoj/eSXahPnTrFypUrmVFSwueff87JkycRDAYGCCJ3KHYks/mCZh2vv/46stHIUItIpFbLQItIgypVrso5Qih59vbbb1MzL4/Fso3PvX5SZJl2rVoR4XCQER9P/fr1GVSeJJ8vK/Tq1AmAe+65h1xZ4S67kyKTmWYNGoTbsI4ePYpBo+F9r58PvH50KhVbtmwhNTYWlyAQFwiETWYG9e5Ne1nhbrsDrc5AXJtJxDQfhUZr4E7Fhqg3EtVoMPa4HCSdjjayglmjJW3AcqKbDKV2/Ya8+OKLZwUHzz77LJMmTGDI4MFkJiVRrbg4nMg6efIk9atVI8JqxSYItGvdmg7NmlEtOxutSsUuX4BvfAFMajU5Y+5BjsujnxiqSu5oFlAEAWtEKo70Wrg8fj7//HNsJhNpZhHFGYlekJk9Zy7Tpk1DpVKh0RkwOoIYFA9pWbk88sgjZOYWktz9ulDgkVqMIEpodHqMgohWb0LyJ6A1Wli8eHGF8zpx4gS1ioowGsxo9SYEgxmH3VmheuTQoUOMHDSY7IQEzHo9tRwOXLLM/Pnzsco2Iur0xJNWnTbtQ5/lZ599ht5oJK7NJJK6zkOxO+nctRtqnRG1Vk9S13kkd78OvVbPww4XBr0Jd24TtCYRo92P1ijgq9oBg+xGpzeFk6u/UyMnh3vsTvb4g9QTZSIbDUZvNKE1mIlrOxmj4sUgWFm7NiSd8fbbb7N48eKw03kwMhqdIJPUZQ6O9DrUqF0XrVFAZ5bQ6o3hSt2XX36ZuXPn8tBDDxHl8eDQ6TFrNBhkN9bIdGrVbYDN6cYguUJJ4Yg0ataqg85oQmMwo9EZURIK0ZkljI4gSlJV9GYLrsSCkPyH3oicUEjRjFISO82kuHotYuITcUYmYFXsvPTSS+f8nu3atYvBgwezcOHCcND7wgsv0Lhpc0yijFZvJCMzm6NHj7Jv376zOjTeeustNm/eTEJyKoGqbQnW7Io/IopTp07xxhtvsHbt2iuuIj516hSvv/46n332GQajCa3ZSu7YjeUV1QIeX7CCgcqBAwdC5xyMQ5RtCFaF3HH3ktBpJlFxCeQXFuOv2ZWiGaUEq7ThhhtuuMDRr4yUjGwSO8+mYNpjOCISeOaZZ676MSr5e/gnE9T/xtj6UpbK+LuSSv46Z86coWPLligmEzaL5YI6wlfC9OnTw4nchbKCVavFYjBQMnnyxXe+BM6cOUPDGjVIVxSCopU5M2ZcdJ8hffsxuLw4o6GscMstt5y1zcghQxgvWvFoNJRYJUZaJdJi/2uQvX79ejIlmU0OJ9VkhcXlRSsX4ndD9WRZoVZh4UXN+v6zdi1mQUSwWCsUPCxdugzZ5ceXVgXF4cKVVEhMizGo1GoURSEjKxdvShHuuExatbl4wVKfLl1IkWXSFYVOrVpddPs/UlZWxubNm1m0aBE33LAEo1nAYDSdJUny+7b+iCiiGg4kpvkobA7XRauQy8rK6Nm1K23MZp53e5hslRg3ejQQ6hgIREZjSyrG4ghiMZ1fR/xC1G3QGE9iLp7EPGrWqX9Vza3/yLZt22jbsTMzZs66LKPGbdu24Y5Np7BkG8ndF5CSkc3s2bPxV+0QktloMpRuPUIvSO677z48iTkUljxObOvxVK9d77LmuHLlHTgiEolrOwmbP+aqV8RfCdNnzMTuj8GfXQd/RNRV6dD/M3v37iUjOw+9wUC7jp2vmiTr6dOnESxWUvveSPqAWzAJYgWZyEr+ea5GgvqQSqVao1Kp/vOnZc+l7H8tlsoA+dpx+vRp6lWtSpZiI0K0Mruk5J+e0kUZ3KcvM8uTmKOtElMmT+bQoUN8+OGHV+wafCkcP36cZnXrotNoSI6KvmCL1+UwqHdvuskKz7o8JAoW7rrrLm677Tbmzp3Lnj17zrvfb7/9ViG5NHLQIIpkmYGSjEdR2L17Nyadjvc8Pt7z+DDpdOfUDfsjmzdvxmww0MgskCBJ3HzjjVd8XidPnqR/9+4EHQ6a16tHlMdDkqKg6HQsU2x86QuQZLEQIwjscHtoYxbw63SIOh2dHA4UvR6NWk2018vbb7/NgJ49sYsitQsL2bdvH2fOnOHXX3/l5MmTmLRaNjmc3OdwYlarada0KV3L75EBssy4UaOAUNtllzZtUHQ6Yg0GBLOIuzw5nKbTY1apMJgsZCQkMr9cJ7ufKKLV6bE5XUS43WTb7ThEsUKCcOr48Rh1OmwWC0888cRZ1+L06dN8+OGH4crXsrIyVq5ciaTVUmgwUNVgxGkR0RtMOJweRL0et0ZLNaMRg0qFHF+AyR7EYBL4/vvvad6oEZJajdVgqNAxoFJrUKlUyHF5aAwCS5eGgtdeffvjzahJXNtJWG2OsB551bw8HIFkimaUktxtAf7ImLPmPn7iJDwZtcgathqLPwklLo+4xGTOnDnDpk2bWLp0KXv27KFTixZcJ8ns9HjpKCvceOONvP/++/QfOIiWrVoxdepUvvjiCwCWLr0R0Srj8vp56qmn+PzzzzGLEmqtjrwJ95M36QHUWh0ukwlf1Y7h4FCjN+PMakDRjFISOpZgjc7CJFgqBLpTxo+nWFYoKTe01BuMLFl6IzfddDMub4D0rNywVMsDDzyA1mAKJaCNAqWlpajVGuT4AopmlJLUbT4GQUKKzSWp+wKsEWmMGjWKp59+GlG2YfdF4fV46VV+r/UTRXQqNcGoGD788EPuuPNOdAYTOrMVa3QmJquCziSil1zIcXmh5HPn2ejMEjHNRiI4/HTs1IlevfuiUmvQGMx4ClqitzqIT0jCl1krpO/XbORZZpCvvfYaNWrXxyLbcSfmYfPHMGXqdD777DNE2UagVnc0BjP2lOroLTLtO4T0AV955RU2bdoUltr5/bur0WgpnL6VwpJtmEWJNWvWYLU5CebUDVfw/M727dtp2boNnTt3CSf6L8Z1CxeiKZcZSet3E3qLDWd8dvh+3rlzJ3fddRdff/01b775Jvv372fKtBJ0egOK3cmOHTtYvXoNiieCQI3OiLKNN998kwMHDvDcc89dkrHUpfD4449jscqINicNG18d2aNK/hn+4QT1vy62vpSlMv6upJKrQ1lZGd99991F4/Ar4YknniAoiiyUFdIkmWVLl55XHvBKOXnyJE8//fRZVe379+9n3MiRDO7Tt4Lx2zfffENKdAxGnY46xcV88skn1MzPJ8LpZO7MmUDIPNshilRTbMg6HS0bNKjwbFVWVsacGTOompnJhFGjLlhk8zupUVE86HDxjS9AgtnMrbfeetF9ysrKzkqYJqSkk9pnKUUzShG88bi9fjQaLRFRMUiShEqtJqX3DRRM2YJGo72glMexY8cwaLV87vXzpS+ARa+/omKqM2fOYBIsZAy+nexRd2E0Wyp8zi+//DKdunZHrdWRO/4+CqdvxWyRKrz4/zM7d+7E73Cg02hw6PVMt0oERbGCRMdPP/3EggULGDZsGC+//PJlz/vw4cPo9IZQTDl9KwajOZwA/emnny6YTPz555+p27AxNqebvv0HXrD6/N1330VUHMQ0G4k7qYBRY8aetc3Bgwd55ZVXzpKCfOONN5AcHtIH3kZE7e7Urt+QBx54AJsvmoSOJThjM1h8wxIgFBc6gvHkjruXiDo9aNKi1Tnnc/DgQWbOnMX4CRPDhVIAAwYNJrLBgJBkS63uTJx4dbuVv/rqKz744IPLeglQVlbG1q1bueOOO65a/Px3ceLECXQGAzlj7iZ3/CYMJvN5pVcq+We4Ggnq11QqleMc/771Uva/FktlgHxtOXHiBE888cT/TOvy9u3bcVks9LDZcVgsvPrqq3/r8Y8fP/6X3/y+8847jBwyhMXXX893331H83r1iXa7mTR27CWNvW7tWqwmE6LBwIwpUwBIjojgSZebXb4AMYJA07r16NG1Kw6zGYfZHN7uYnzwwQfMnz+fBx988LLOc+fOnSxatCisq71ixQqqyjIvub0kGU10F0X2+IN0FixYDQYsegMFGRm0+UPFdBOTCclsZty4cURYRD7y+lkg26hTVMTp06e58847mTZ1Kk8//TSJkZEIej3pcXHUqlEDq0aDQ6PBajIxdswYmksSX/sCdJRCMhkQkhcJOp2Y1Gqy9HoedDhxWixhDenBFpEYg4HslBSKZZk1dgcJksS6detYtmwZda1W6loVMs0izeuF3ph/+umneCwW3vf6udvuJD4QAEKVwjfffDPPPvtshet05swZ2jdvjlsQsBoM1KlTh3nz5nH48GF+/fVXTp8+TXp0NA84XNyg2HBoNDQURMxaHWZTKNj2mEyMFK00lGSmTpgQHltvFrGn1kSlUqNSq8Pu4YcPH2b4yNHUa9SMO++8k6VLl/LAAw/Qt1cv9CYBuz2ATq3G73CGHwC+++47tm3bRvuOnYms34+iGaW485oSrNMLrU5HRlYugjMCT04D3F4/g/r1QzYJmIwCer0xXC0zaMgwrO5INDoDao2WmrXqYDKLZIoSDlHkrbfeAkIBX1RsAkZRwWp302/gIBYtWoRJdhHXZiKCJxaTIwKNwUxU4yFYAkm481sgiBJbtmzh/vvv54svvmB6SQltWrViQK9ebN++ncOHDzNz1hx0egOSYqtQuZSelYOvansKS7ZhT6tF9Ro1qFOvAVqjgBSTjV6QMZktOLMbUTSjFF+V9nTv0ZOqNesQ13YShSXbsDr9NLKIfO7109Rkpn7duhU+7y7deoQDUXtaLcRAEql9l6G32EjoOANbUlXEYEpI+6/hIAYMGkxZWVmoAjsqBYPkwqB4UKLSED1RZI34D/7C5vTuNwAItRpu2rQJi1UipsVognV6YXZFkjH4dnwR0dx3330EM2sQ02IM9tSa5cn9GQRj4rnppltCDtxRGWj0JuISkli2bBkLFiygqGp1PKlV8GbWIjMnn4ZNWxDXZmIooM5vwuzZs9mxYwc7duzAbLGiM0s4M+tjEqyXbFg0dvxEtDoDap0ejd6E2RWF0+1l2LBhoftFq0OUbBU6Fk6fPl3h79LDDz9MSUkJ69atwx8ZjUZnwOoKINudZ2mMX4hPPvmE9h270LlbD77++mtuWb6cjJwCOnfrwe7du/nqq6+uWcVPJX8P/3CC+l8XW1/KUhl/V1LJxfn+++/JSEjAbDDQo0OHy5ZwuBrcd9999OrUiRW33vq3/lbVzM+nq6wwWpIJulwV5BvKysrCCflWDRoysrwYJ9pqDetJf/XVV9x///3nNY28XGoVFDBZkil1ubGpNchmczjOvByat2qDK7shCZ1mohNk9EZTONH7/vvvo9FqUWm0OFKqEpeUcsGxysrK8NkdXC/bWKbYcMnyJSXb/8zvCerMIXeQM3oDJsESTnR/8803WGV7qAs0sQiT5MQdm07dBo0veD8UZ2SwTLHxoddPUBDo0KYNDz/88GXP7UL8XtUdWbcXkfX64gtEcPr0aTp364FJEBEl+bySEsNGjMKX14jskWtxxaZX8Jk6fPhwhXNbv349wZy6oQKTrvMoqFKjwli7d+/G7Q3gjk5GcbjOihGvX7wEbyCSwio12LVrF2VlZdx8y3Jq1WvEjFmzw9/rsrIyBg4ZitEskJKedV4ZvOq16uLNqkOguA2ByOhwEd327duxKg4iilshyrbzdkReCTcsWYpFsiE5vXTp3vP/m7h13vzrMIsSZlFiyrR/f7Hl/29ccYJapVLpyv8rqVQq7YW2/buXygC5kj+zc+dObr75Zt55552/7ZinTp1i1apVLFy48JzatZfKnj17cFqtjLdK1JRlhvbrd9ljKILAUy4P73l8yCYT3333HX27dqW+LFPdYCRbb2C2JOMsr+g9V7X31TDugFCglhwTg0WjoZ8k47VYeOyxx5g9ezZ9ypPP9U0mqpoF3vT4aCXLTJkwgb179/Liiy8S5fEQr9djVaupaRFpWrsOK1euJEYU+czrZ4XNTtWsLCaNGUOeLDPUKiHrDQyVZL7xBahjMmN1RxAdG09JSQlvvfUWO3bswKrTo1apsOr0vPbaayycNw+LVktfixjSKzeZyTaZSE9IoI5V4nm3h5pGI2NECafVSsnkydQvLub6664LG+/p9EaiGw3GX7UDdqcHCBloeC0WPvL6uc/hJNbn4/PPPw+ZhRQ2Q3J4Wb/+v+1wL7/8MvGSxFe+AJscTlKjosPrvv76a+oUFeMyCxSZzWTo9Kwrd4KvbzSRZzQiGQw4k6vi8MSSJ4h0btkyvP+EiRPRmUQ0BhMqlQq3x8O+ffvC6zdt2oRREHFlN8Bs95ObX0y010t3ITT/qrLM6tWreffdd5FsDvwp+ZgEEY3OGNaGdibmE4yKQW9RwnplUjCJ3Lw8bAkFFJZsI1inFx06dwPAFxGNxmAifeBtZI9ci1qrJ6rJUAwWhTiDkVHDh4fnd/DgQW699VY2btwYrgrJzS9Ab7UT2WAAGYNvx2C2kJmTh1anx2S2UL1mbZyRSbjjMjAKIv7ClriTC2nTriMQ0nCzyHZyx24kqes8/BH/vd516zXAldOYwulbkePykRUbGr0Re0oNLP5EzKKEoDjRmkR0Fhsmwcpnn31Gi9btCNboTPbItdi8UdjMAhq1Gqc3FrNVwR8ZTVxSCs899xwbN25E8UQQ1XgIguxAdHjJGLISW2IROrMVwRuPxiDgr9oBq90dlhA5fvw448ePR/ZGUjD1EdIG3ILV5sTu8lCrbgN++uknTpw4QWZOPu74LPSijWDtHuRNegCVWoO/sDn1GzXl22+/RbY7sSUWoTVbSegwHTkujx69+oQqhHovoWhGKdbIdEyOABZvHJ68pticbq6//nrat+9AdHwS0XGJOBPySOw8G9HhxSSIuGNScLo8WLwxRDcdEUriF7dl7ty5l/S349ixY+zatYtAZCzRzUL72+Nz0OiNpPS8nuxR69HoTSxbtuyC4xw5cgSHx09MizFkjViLXrThKWjB0GEjLmkev/zyC3aXh8h6fYio1RVfIIjs8pPcYyG+nPrhlwGV/G/zTySo/82x9aUslfF3JZVcnKLsbPxaLTUMRmxaLWvXrv1L4x06dIgVK1bwn//855p2hl4NjDodn3j97PEHCVqt4U65P1M1K4s1dgff+gJUtduvehL0dz7//HP8koRXo2GBrNDLZr9oDHEufvzxR/QmC2IgmagmwzCaLRVkD3bs2IHd4UClUjF+/PiLJgLfeust6hQVUSs//y8VVv1n7dqwxMfC6/8ry7dt2zZ8SaHOvPQBt+ANRvHggw9eNBGem5TEapuDL3wBEmX5irw8Dh06dNGXMp999hltO3SmVdv2lJSU0LlLV6wOLwVTtpDYeTZRcQnnvIYdOncjsuGgkHl3bgNuvPFGjhw5QtUatdHpDUTFxodfbuzatQvJ5iBQ3AqbL5obltxYYayZM2fiL2oVkoWr1YN2HTpd9rleDjq9gfzJD1M0oxTZ6eXLL78Mr3v11Ve58cYbr+jlyYUQRImsEf+hYMoWLLL9sj1kLoWjR48ybvxEGjZtwUMPPXTVx79Svvvuuwt2nl8qp0+fZvENS+jRu+9Vl2P6/5W/kqDerlKpxAtt808tlQFyJf8GBvToQbEs002WifJeujb0n9m6dSu1nCGN3G1ON+nR0Rff6U84rFa2OF3s9HiRTCb27dvHsWPHmDdnDrEuF3eVa/C2cThZt25dhX1PnjxJx5Yt0Wo0pMfFXZJUydGjR5k5bRp9u3bllVdeqbAuOzGRIoOBAYKFPf4gs8uNTL755huCLhfZdnvIhbtePRxWKy3q1+ftt98m4HQSJUnEB4OsWLGCvj16MGbECFyyjKRW49RoENUabBYLO3bsIDcxkS1OF3v8QaJNJgaVJ6hrW6xENhqM7PTx6aefAtBvwEAi6vWlsORx/FXbM2XKFIw6Hd0FC70FC9/4AjQwCxTl5bF37166tGmDqNGQoTfQUJJo36wZ4ydMwKDTo9MbGD9xEnfffTcGQaKwZBv5kx5Eq9OFg6mxw4cj6PXIZjOPPfYYt9xyC8GCphTNKCW+3RRsdhd+u51F8+fz7rvv4rOIvO7xsUSxUZCWFr6W9YqrME5W2OJ0oeh0BG02GgoW7rA58Gg03GN3YFCrKZpRSs7oDWh0hvCP5x133olgldEaLXirtCOm5XhUKhWRkZHs3r2bDz74AJPFijUqk6IZpaT2WYrB6iA7OYUp0u8mowo333wzw0eOIli7B0UzSjE5gkQ3HU5Sl7lYbB769+9Ph85dMXtisaVUJ7rpcDR6E0bFgxhMoWDqI3iL2pCakQ1A+45dUGv1ZA1bTc7Ye9DojeRNuB9f1Y4YrA5almvx/fLLL0TGxCH7YlBrdegMJqbPmMWePXswClYcGXWweGIYUp50fOqpp2jVrj0anYGsEWtJ6DQTveQMXZsxd6MzmFDsLjp16YrJIpEx5A5S+yzFZJGIT05jztx5fPfdd3gCkajUaowWGX+NzmiNAoXTt5I7fhNqjY68SQ+QN3EzWp0+XMk7b/4CzFYbBsHKgEGDcXq8aAxm1DoDWrNEZMNBxLebilVWOH36NLfddhu9+vbj/vvvZ/acuXj8EVSpUYtNmzbRt/9ARo0ezaxZs3j66afD98KJEycYNGQoBpMFT3YDHJGJjJ9QsQ1w586dOAKxFEx7jMyhd6I1WlACcdhdXpJS0lm1ahUQ0tkWJRu2hCJMNh++yGg+//xz7G4/rtzGIZkRi4JOkMkYfHuopdUTQ4OGDZHsblL7LCVQtT3R8UkUV69FdHwiCR2mUzSjFGdMBnqjGYsvgfh2UxEdvktybx89dlzIHFNWaNGqNb7chqT2uwmNzojWFGphzZtwPxqDmQceeOCCY9WqUw+d2Yo7rzn5U7dgtPmwx6Qzb978i87jiy++wOHyoNEbKSx5nIJpj6FWqwlkheRUEjpMp2rNuhcdp5J/P/9QgvpfG1tfylIZf1dyrXnppZe46667/nVt5Y8++ii18vLp1LIl33333QW3dZhMPOly860vQLxOx7hx4674uGfOnKEwI4NGio1qikK7pk2veKyrxb59+1i9evU5kzWtGzWirqzQQVZIiYk5b0L00UcfxS4IJCsKBenp10Tq5HeWLl5MhiRTIsm4LBZ27tx5RePce+8mzIKIwWji1ltvO2v98ePH6d69OyqVil69ev1tLxOOHTt21vX76aefcLi9+Atb4IxKYez4CefZuyJPPfUUiiBgNJoxWyTatO94yZ/NqVOnaNG6LXqjCYfbyzvvvMMPP/zAc889d14Jk9Fjx+GKyyRQs1vISH3wCuLbTkYvWGnbodNZSeo33ngD2e7EFZlAMCqGH3/8kdtuuw1PahUKp28lWKMTvfr8t9Drs88+Y9GiRTz88MNnjbV8+XLkqHSyRqzFllQFoyBWKOK52tSoXQ9vZm38Ra0IRsVw4sQJzpw5w5IlN9KmfSc2btzI0aNHz5ncf+6557juuusuu7vdG4ggvv1U0vrfjCBK/PTTT1frdMIMHjocT2pV4tpMxGpzXvUk+z/N1GkluOIyiWo0GFG2/63FkP9X+SsJ6sUqlepdlUrl/8O/1VSpVC9caL+/Y6kMkCv5N+Cz2XjF7WWPP0iGzX7Fb8C///57XJLEcKtEsSwzesiQyx7joYceQhYETHo9S6+/vsK6nJQUonU6BllERJ2uwhtbgA0bNlCsKHzg9ZOm12PV62nbpAmHDx8+7/H6detGI1lhliTjEMXw2+qysjLsRhOKWo1JpaKzWSBZFFl5++3s3r2bH374gYcffphRo0ZRmJFBuyZN+Prrrxk2YACjyquru0oy8+bNA6B6cTFejYbFso14rQ6HXh+WDBkxcCA1ZZkpVglFEIgPBtGp1chWB1FNhiMp9rDm1Nx583ElFeCr1gmjwUxGXByCwcBddgfxOh1qlQqn2YxGraZB9eocPnyYL774gnGjRzN/3jxKS0uxqjVMskrY9QZMajX5NjsWrRaLw48jMpkOnbtWuEYHDx4MG5Hs2LEDyeklru0kpMg0qpgtPOfyEBBF3nzzTSaOHYtgMBAfCPDmm2+Gx0iNiuJhp4tvfQEyFRuPP/44LsWGrNGSYzAQrdVh1umIajQYb15T8gr/a2Lp9PhIH3grgjeepC5zQ1XB7iAWi4VAIMCSJUvwJBWgNVmIaTYSW3I1rNHZ1KhTD6/NhrP8XujTbwALF12POymf9IG3YpSdRNbvR96E+3EE43jiiSe48847UeuMiIFktCYraq0BJaEIjcGMSq3B5AiSlpULhKpbmzZvgVZvRGcwojeLeIpaoxNk3PnNiQxGAnD//ffjTS5AaxTIGHw7uePuxWSxsmXLFjQ6I3JcPia7n779B/LBBx9gkZTQ5x6VgcZgRifIaAwm/FU7IMdkYZCcJHaejdZgQo5IQa3VozUK6EU70c1GYvfHhF3KT58+TSAqltQ+NyJFZ2GNSMMenYZGp8fsjkHwxiGIVk6fPs3bb7+N1e4mqslQLN44ouMSEUSJ1L43kjPm7pDERHQ2aq0Ojd5IZnYeJkFEbxYxmgV69xtQoXth6rQS9CYLao2G6PhEvvzySw4dOsTsOXNxJ+YT12YSguxg9OjRZwXbL730Etryay54Y4lLTGHOnDmYrQpSbC4W2cmGDRuYNHkKetFG0YxS8ibcj1kQadqiNe6shmiNFnRmqVzzWkBJLCaywQC0JhHR4ccenR7SKO++gNTM0GfatkNnAlXakDHoNhRPBMuWLaN6zdpk5hawYsXtZ/39eP/99xk/YSIrVqzg9OnTfPDBB0h2N3kT7iex82wiY+JD8/EFMZhFYlqMCSf86zVsfN6/SxCS+DDKLuLbTsbsikJjMGMQrHTs0u2SnOJHjBpNoHpHrFEZSDHZKNHp1KpTH68/An9qMaLi4L777rvoOJX8+/mHEtT/2tj6UpbK+LuSa8kdt99OQBRp6nAQ6fFck2TKlbB7927sgsCdNgeDZIWG1atfcPuq2Tn0s4issjkQNJqwz8eV8O233+ISBL71BfjcF0Cr0Vy1jscr4cCBA3j9EQSy66B4giy+oaIx37Fjx7jllltYtGjRRT+/PXv28Nprr100kfvdd9/9pU7VsrIy7rzjDoYNGPCXKyDPnDlzwergsrIyZs2ahUqlolatWmdpG/+d7Nq1i4ULF7Jhw4bLumeWLFmCMyGXrOFr8KRVY/acUBfcDz/8QHFmJgadjvbNmp31uT3yyCO4olMpmPYoMc1GkFdQjNNqpcDhwO9wVCiAmjt/AS6vH0F2hLW9HQl5qFRqdBaFlF7XIyqOs55ZIaRzvnPnzvBz6q233oo3rRqFJY8TUbMrPXv3vaTzPHHiBIJkQy/asafWxB2TxnPPPXfJ1+lyOXToEHPnzWPylKnh+3np0mU4opKJbTkWk2RHo9Uh2xzhZ10Ivcyx2t0EqrZDlM9vin4uHnvsMcxWG1q9idr1GlyTvx0FVWqQ1GVuSPIvuzZ3XYFp5r+ZqjXrkth5dqjSPr8hq1ev/qen9D/PX9KgVqlUg1Uq1dcqlapzedXHDyqVatzF9rvWS2WAXMm/gdaNGtFGVpgqybgk6S8FIR999BGTJ07k1ltvvSLTrY333EOs10tGXFyFyoBff/0Vs07HTYqNkaIVvVbLr7/+yosvvsgnn3wCwOrVq6lrszHdKlHLaOR1j4+mssLc2bPPe7yMmBi2Ot3s8Qep6XTy+OOPA+XVh0Yjn3n9POXyYFZrWLJ4MdXz8nALAg5rSGe4nsmEQ6OhmSCQnZREdnIyrQWBD71+6lglbrrpJtasXo1ZrWZiuR70dEnGotWya9cuTp8+zXXz5pGblkazBg14/fXXKSsr46OPPqJ1u47UbdikQmX38ePHifB4ENRq0nUh+RDRYMAuitgsFpo2aEBPWeFrX4BGssLSpUtZs2YNwwYMoLS0lFmzZjHEEtLMLtAbmFtumNjWLJBpMOCz2S5qwLBhw900atYSr8PFepuDb3wBsm025s2bh0VSsHkjKCiuVsFde/WqVbgtFjIUG1Wyszl8+DBqtYbUvjeiNVlCGsZ2Dzl5hQwYPKTCw0BMQhKxLccS1WRYeSWvlfyiqjisVlQqFUaDAVFSsMVmozVaEFwRiIqDxx57jJGjxuBMKiJj0AqcMWmsXr2afgMGER2fRKcu3YhNSEJvMDBg0BDKyspYuHAhgSptKZpRSmzLsQjeuJCGcv3+CN447MF45i24rsL1+O233zh48CDz589HrdHi9CVg0Zsw6fVAyOTPanejNVpI63dT2ACmWo2aSDHZFM0oJa7tZLQGMzqNBp1KjdlgRvDFE1G/P4Ul23AlF5OUnILOJGKNzkRrtuIpaEnRjFL0FhtRjYcQ33YyOrOEL6sOK1as+O+1X70Gi2TDLNlRabSo1Gp0BjPx7afirdIOo0Xi4MGDbN26FWdUMjpBIrrpCGyJRRgEK+kDbyV3/CZ0BjNmdwwF0x4jom5vzDYPjow6+Kq2J3fcvTijknnwwQeBkCa6WVSw+BLIm/QA3qod0JtEtCYLWoMJe0p1soavIVClDdOnT+f555/nxx9/5LvvvmPAoMFExSURrNWdgqmPYPXHs3z5cgYNGoTWKOCr0h6D4iErJw+92YLGYMaV0wQpJofa9RqQnV+Mp6gN9pQaFJZsI75DCYJkR29REIMppPW/GW9xGxxuL564DETFEZaq+eGHH6hdvyH+yJjwg8z5+Pbbb0MtlzU644rNYPTYcbz33ntITi95kx4gudsCImPiKSsrY/KUaVhtLizOAJLDy+Chw84a78SJE6xYsYLrr7+en376KdSyWe6yHt1kGEZBqmBGczFKZszEm1mb7JHrsHpj6dixIydOnGD//v1s3rz5LyUaKvl38U9pUP9bY+tLWSrj70quJVUyMrmnvOOvgcPJpk2b/ukpAfDCCy+QabPxrS/AdpeHGI/ngtt/9913tG3alMK0tIt2/FyM48eP43c4mCIrDJYVspOSzrvtgw8+SITLRZTbzeOPP87p06f55ptv/nIl76ZNm8hJSKB+larcfvvt+FMLKZpRSkqvG0hOz/5LY1+M2XPnIYgyZlGiZMasa3qsq8mGDRswGAwkJiZWMIv8X2DatOn4y2P6YK3uDBkakt4b2r8/fWSFT71+aigKd955Z4X9QgnqUOdkdNNhRPr8TC4vPuorycwuf6587bXXkF0+MoasxBqZgTWYRLB2D6yKHbcvQGzrCaT2WYogSuzfv/+i8z18+DAFxdUwmASCUTF8/fXXl3yu/QcOxhWXhb+oFU6P74rMKv8KjZo1x6h4UWv1CJ4YXLlN0Yt21GoNg4cOp6ysjN59+xPVaHAoAVyzK9OmTbvk8Xv26Ye/qCXZo+7CGZVyTQosblm+HMUTJJAfMq+8GrIa/yYW37AUeyAWf7UOWBU7n3322T89pf95/mqCOqu80uNMudu4+WL7/B1LZYBcyaVQVlbGhx9+eFk/VJfDwYMHmTRuHP26d7/q7R7Hjh1j5KBBVM/OZunixeFKyXfffZdu7doxtF//cPvjTz/9hGw2s8Xp4mbFTtDhICcxkeLMTHbu3InHZmOYxUoVgwHJZKZmQQGpioJLELj9tts4cuQI1XJzseh09LWEZDlGSDJjRpxfr3XSmDFkyzJ9JRmvzRaey969e1HMZp53e1hjdxDj9XLXXXdR02bjG1+AliYzrcqlP5YrdmobjVg1GjoIFtJ0evQqFZJWy9NPP016TAzDLSKiWs0Ai4hVrWZk+ZzmzZpFgSxzvWzDJ4qsXr2aGJ8Pk17PtAlnt7H9+uuvSBoN18s29viDNDOZiROEsGng8IEDGSrJfOsL0FaWad2qFSmSxAxJxmOxcNNNN+E0mZguyShqNU1NZp52ecjQ61mu2EmR5UtuGRw/fjxmtRqvRkuc309qZg6JnWZSWPI47riMsObw73zyySc899xz4cS1wxPAZA+gJFWhaEYpiZ1nU6VGnbOO89prr6E1mNEaBeT4QlxuHzXz81ks23jS6UanVmM2mxk6dCirV69mw4YNvPvuuwB07t6TyIYDQxpvBc24/k9V+X/mmWeeQbK7iW42AskXi0lykdLzehxxWTRu3IT77ruPsrIyTp48yc6dOyskDI8ePYrf6aS+WaCu1UqTWrXD625bsYJAZDRavRGNTo9aq0Ot0aHWG/FX74xetOOv2R2TzsBLbi8POFwY1Wr8VdqRP/kh3PFZRMbEEajVHb3VgUZvxCB7SOt/Myq1hryJD5A5fA1arQ6LxVqhUuPbb7+lT99+aPRG9FYnYkQaBtlNYck2MoetQmu0MHPmTH777TeCUdFhY8O0fjfhDUZhEkSMJoGWrdvgisumcPpWlKQqaE0iBsVDdNMRxLQYjeDwM2xYKPjfsWMHos2NFJtDYcnjSLG5yPEFIckNQcIanY3WYMZgNKM3WRBsHiSbg5j4RAJV2yJ4YolsOJDC6VvxJOWzfv16RowYgTOzXkhepv004pPT0BoFknssJFCze2g+ZgtGs4DRbEFrFMKO54OHDqdXr14YjGb8qcVINgdvvvkmW7ZsYdKkSSxatOi8wfyZM2fClRpvv/02xdVrUVClOosWLSKQHrp3U/veSFJaFmVlZQweOhyD0YzFKlFaWsqGDRtwRCaR0usGbJGp9O8/4Jx6hK3bdsCdmI8vtyHRcQm88soriLKNQGFzzFblLEmji3Ho0CHqN2qKxSrRrGWbC7rJV/K/zT+YoP5XxtaXslTG35VcS/p06UI7WWGN3YHX8l/T5FOnTvHpp59etBDgYuzbt4+77rrrLGm6i3H06FEyExKoZbcTY5WYf4ECjmvBRx99RLd27ejfo8dZyZ/fJTSOHTuGZDbzkMPFJocTyWwmMzERtyAQ6fGcsxL1fBw7doz5c+cycsgQtm/fjl0QuNfhZLKskJOUhKg4iG83FV9OAzqW+4uca4xBvXqRk5BAyeTJV2TOduzYMfQGI7ljN5I77l70RtMFuzuvJUePHqVN+064vAG69rg0+Y4XXngBh8OBw+G4Ii3nf4qvv/4ap8eHJzYVxeHiww8/BELfz0nyfyUAb7rppgr7nT59mtr1GqDV6bE73QwZOJDGssyzLg/Fsswdd9wBhKQt3XEZFJZsI7HTLHyBSEaOGs3bb7/Nzp07SUzNIBAZw8aN9553jmfOnGH2nLnUqNOARdcv5syZM/zyyy+XXSF86tQp7rjjDubMmXNJEpdXm4LiqgRqdCVv4gOYnBEYbT6imw4nb+JmbL4oduzYwcqVd2APxhPbciyKJ3hZeu3NWrX5rydMZk1Wrlx5Tc7jySefZPny5f/INbzWlJWVsWnTJmbOnBl+Tq7kr/FXJD4eUqlUv6hUqhkqlaqVSqXaq1Kpml1on79rqQyQK7kYZWVl9OzYkYAoYjebuWnp0ovv9Ad++eUXvvjii3/E7fbnn38mPS6O6kYT99idxEsSjz76KIcOHcIthzTUeskKtQoKgJDpm1sQ+NIX4BW3F4NKzTq7gxsUGzG+kP6rRaulRJLJFgSiTSa+8QV43OnGZjBQLTuHZ555hldffZWg00mqzYbPbg+/8X/xxRcZ3KcvSxYvDld3nzlzhvXr1zN//ny++uorfvnlF7788kvKysq49eabUQSBCJeLHTt2sHnzZnIUhU+8ftpbLHj0IaO/2kYTTq0OSa3mKZeHPf4gaTodtQ1GhgwaRINq1RgrK0yzWjGq1US4XCyaH9KQbVW/PrfZ7OzxB+lhs5Pg93ODYuNtj4+gaK0gkwGhAEQ2GGhlMrPN6SZSq8VutYbfzO/atYsYnw+H2UxWYhLtmjRhqRJKZg+UFRYuXMi2bduoXbUqSdHRyFotilpNqk7HVNGKTRBIiopCMBgYNWTIee+bH3/8EUGvx6RSoVepsKrVuCWJiDo9yRrxHxR3MOxkfj6q1aqLHF+ATpCJazsJZ3IRw0aM4umnn+aBBx5g//79oUrSqVOx6fXIGg1mrY78rCyy4hNYpthC5ieSRDAYxGw2s23btgrHeP3115FsDjxx6Xh8QXbt2sWOHTsq/DD//PPP3HjjjaxcuZITJ05w8803kxyXQIO6dRk7bgKZuQUMHzmKkydPUlZWxl133UUgMgbFF4VREEnNyGb2nLmcPn2a3bt3M3HcOAYNGMCmTZv45ZdfmDJpEqlJybRp355du3ah1RvIGLKSjMG3o9boQm2AJgv+ml0RdAY+8Pp5zuVB0OtJy8xBq9NTtUYtsnPz0eiNpPa+gfQBt6DVG4mKS8QbjMSkeDBrtPSxiDSSZFo3agSEKpmtih2dSSSt300UTHsMnaCgMZiwRqZjtPnQGAUkp58+/QYwvWQmGr0RZ1YDBGeQwUOGMWDgYDp07EhiSjqi4kCrN6C3KKT1XYYtuSpqrR6j4iW66XAkhzdc7VSzdl20Rgsag4DWJIa1ne2pNYlpPgpnRl30okJqn6VIsblIcbmo1GoKp28lfeBtaPRGzKJMcbWaHDt2jFdffRVBshHddDi2yGRmzZ6DzeXFV60jiZ1no9GbyByxhoROM0lITmPp0qW0bt+RGTNnMWrMWCyyHVswnuS0jLCUT7WadfCkVcebXY+UjKyzHgjuuivkJm8SLKxeswanx0dM81HEth6PVbEhyjaCtXviis9h6PCR4f0OHToUfuibN28e/uLWFM0oJarRYLr17H3O74PJbCFvwv0UzSjF5gny8ccf8+6777Js2bKLtkHu2bOHVatW/U89OFZy9fiHJD7+tbH1pSyV8Xcl15KDBw8yoEcP6hQUcveGDUCoOrIoM5Og1YrDar1iOb19+/YRdLlo5nDiF0VWl3syXCqHDh3ivvvuY8eOHVd0/N85ffo069evZ9myZX9JZ/vEiRO0atgQrUZDSnQ07733HoJezwdeP+96fGhUKlqUm4CPkhUG9+lzyWP3aN+BhrLC2HIZvxirlW98AZ52eQg6HDz88MPUrNuQfgMGnfelwcxp02hQ7qGSIcncfffdl32OJ0+exCyE4rC0/jdjFsQKXYZ/J7PnzMWTVo2s4WtwJ+Zz8803X9J+n3/+OYmJiRgMBjaU39MQek7987PCJ598QrWadUjLyj2rWOXv5pdffuGJJ56gRq26WGUbHTp35d1338XvcOATRbISE8Pm5b/zxBNPICoO/Nl1EGUbr7/+Ol3btiXW62Vov36cPHmSmbPnkJaVi8sXwOaLxiIpV2Ssd8vy5TijU0nsNBN7ML7CtT0fR44coXe/AWTkFLDo+hsu+5gX4o4776RWvUZMnjKNVatWE5eUSrWadS5qStigcTOim42gsORx5Kh01Hoj8e2nUTDtMZyRiTz55JOUlZVxy/LltO3YmbVrL6/oYseOHZgECxYlVMzy58/s/xIbNtyNxSphlRU2baqU4vs381cS1ItUKpX9D/+fUd6SOOxC+/0dS2WAXMnF+OKLL3ALAp/7Arzg9mKzWC5539LSUhRBwGux0Kxu3SuS3PgrtGzUCJdGE5a26CbJLF26lA8//JAYSeJbX4B3PT5ksxmA0UOGIGq1ODUabAYDkk7HV+XbGHU6HnroIeqVmwnebrMjajRscbqYYpWI0+lYYbNjF0UOHTrE559/zquvvhoOOD/55BMcFgslkkyR1cqkMWMqzLWsrIyOrVtjUauRNBoykpPPqiY/ffo0PTt2RK/VkhEfz4K5c6mdn0/zhg2JDwZpbzLj02jI0ukxq9Wk6fTIJhOPPfYYdQqLEPV6vFot6To9TpOJ7du3s3rVKqKtVvqXB88pkZFssDv5qtx1+lxJ3qeffpoImw2bXk/NKlXOMrk5deoU3333HadPn2b1qlXEWa2Ms0o4BQuvvvoqjzzyCHFWiXV2B1UtFhS9noDRSNBmo2puLlMlmXc9PvxaLXPmzDnnZzt62DAMKhWWcukSo0qFRa8nJT0L2e5k2vQZF70/3nzzTexON1qtDrNFIiM9g+GDBhEvSSRbREwaDVajEbNawztuL594/YhqNUa1GoPZimIWMOv0uL0BYhNTiI6ORq/Xn9VK+/3337Njxw4OHDhAXEISRsWLziwyaMhQTp06RUZ8Aq1khZqyQvP69fHabIyVZNrJCjXy8vEFI9FodXTs0o1Zc+YiyE6sBhMuZwSBWj0wOSNwxqRx47JQBcbNN96IXxSpYrfjUxSy9HrGWSXMWh0p6ZlodHpyRm8ge/RdqDVamjdvjmCVMchujBotRpUa0WhkVXmFxoLrFmLzReHNrIVKoyFnzN3kTbgfrd6AVbKhNVmREwrx6nTs8Qd51+NDNBg4dOgQAwYNIaJub0yOINboTFw5TdCaJUzOSNRaPWqdEWt0FkpiEWq1Bk8gksSu84io3x/R5sbu8hCo3glHRl3M7hjiO5RgMpvxphSGq97tHj/RTYaFWvZqdKGkpASAPv0H4strTMbg29EJMlqTiByfj8ZgJrrJMHSChD21JkUzSomo3w/BGSQ6LhFPSjHezFqkZ+WwZ8+eCg8+W7dupXO3ntxww1JOnz7Nrl27qFazDjEJyVhkBxmDVuDOa0p6Zk54nxdffBGN3ojFn4hR8SI5/bz44os0aNwMjc6IK7sRBdMeQ7DKYbNICD1QGs0h3fDMIXdgMJnR6nTkT36YgqmPYDRbePbZZxk6bARLli49r4HS559/juJwEUivgijbz/vipmqN2vjzmxBRpxcOt/eSq6v27t0b+pxy6iE5vaxeveaS9qvk/w7/UIL6XxtbX8pSGX9Xci05cuQIixYtYkZJSThGu+uuu6hts/OtL8D1so3mda/MpPaee+6hscPBHn+Q9XYHNXJyLr7TNaBv9+6kiiItJZn4YPCKzQHXrl1LNUXhq/IEdM+OHZk4ejRuQUDUaIjW6ahpNPKlL0AvWWHU0KGXPHa0283z7lDhSL7DQWZyMlmKDZ9F5IaFCy9pjN6dOjFHCsnh9ZFkFixYcEXn+cADD6DYncg2x1VPOu3Zs4dly5bxwAMPXLQgaeiwEQRrdQ91FlZpy9Sply6zcODAAWrXro1KpWLWrFnccstyTIIFm8NFaWlpeLvktEyiGvQnsfNsLFb5HzcKHTd+Ir7s+uSMuRt3Yh4rVqzg6NGjfPnll+d8Nu7UtTvRTYeH4tqq7cJ+Qr+zceNGHBEJpPRajDu5kIGDBl+WBNsfGTBoMJH1+4dlLyZPnnLWNnv27KFbu3Y0r1uXl19+mdFjx+FNr0Fyj0XYvJFh35m/SmlpKYo7SEKH6TjjczCYLaT0uoGIOj0pqlbjgvu+/vrrKHYnVpuL/OKqPPjgg1hlG4JVoUmzlvzwww9/SaKnXsMmuBPzcacUk1tQ9I8U3v0dHDt2DJPZQsag20gfcAsmwfK3528quXT+ksTHWTuoVAGVSvXO5e53tZfKALmSi7Fv3z5kc6hadoXNTqzPd8n75qek8B+7g12+AOmK8pcNNc7HyZMnuf3221m0aFHYNfjBBx/EptPR0SxgVqkp0BuwmQXeeOMNXn75ZVJjYmip2ChWQsHol19+iUsQ+MDj4xbFhlOSaN+8OUmyTGR5Qvm7777DJUkMtEpkyzLNGzYkMRBEVKvZ6nTzldePqNPhMpmQdDoi3O5w9fQ999xDA6uVPf4g95ZXnXz00Ufhc3jkkUeI1uu52+7AqlZT22jEbjbzxBNPnHW+5/pRnDF1KopWS1CrxaRS09BoZI8/yGSrxOA+fWjTuDF+rZZWJjNLFBtmtZp6tWuzefNmBg8ezNSpU3nvvffYunUrilnAKQi0b96cU6dOsWrVKsaNHn3Fbt333HMPvXr25NFHH+XHH39k4MCBdCl/aXC9bKNp7dps27aNY8eOUS07m9tsdnb7AqSYLZgFy1nn++uvv2IxGHjb4+MVtxeTSo1BpcKsVlf4ET148CAjBg6kVYMG57yOEDLD81osrLU7aGERkXQ6XnV7idFquc/h5FOvH7tGwzxJZrPDhagOHcurNxLp9ZGTX0REnZ4k91iIRVLIy8tDpVIRiIimZOasCnN/5JFH0FsUCqdvJWvYanQGE1988QUB0cq3vgCzJBldeUX4QlnhXY8Pk1ZLdKNBFEzZgjMqiZi4RCRBZpYks87uwKTVIcXkENVoMD3L3bZTIiN51BlyvU/UG5hbrltXLCpotFoEUUKjN6LW6tEYRXRmK7JiJ1i7J76C5iSnZlSoDEjJyCGl1w0UzSjFJLvQ6E0hLWejgL9aJxI6TEdntiIYzAy0iNQ3mVFEhbSsHObOnYczIRetSSRYtw+25GoI3viQYaIrEq1JxJFeh9hW49AaTKRlZhNZtzcpPRdhtkpY7W6KZpSSP/lh1Bod+VMeRm80Ex2XENJvlu2MHTsOyeElUKMzovLf9s+GTVsQ23IsRTNKURKKcOU2xZFRF7XOgMlqw1ulHTqLgjUyA43eRK069dm/fz+33nory5Ytu2gL9NNPP82aNWv48ccfKSsro1uPnmh0BuSYLCxWJVyd1qpdh3BboCO9DgajmYGDh+DLrk/2qPWIgWRs8fkEo2Iq3L9btmxBazBjckYQ324qBpOZzl174AjG4YxMokXrtpfw7Qvx3Xff8dBDD12wNfnAgQOMHDWGXn368fHHH1/y2GvXriWQXSf0wqDTLIqr177kff8uXn31VW688cazOkIquTr8UxIff17+LbH1pSyV8Xcl15IW9evTSJbpKcnEBQIcP36chx9+mEwlFFuMlBU6t259RWO//vrr+ESR/9gdtJEVBvTocZVnf3EOHDiARaMhXqfDodEQLVp54403rmisVatWUbdcPm+KrFAlN5cOzZoxYtgwlHIvmLpGE2qVioL0dJ5++mma1alDq4YNK8Tx52JAjx5Ul2UGSRI+u50ffviB7du3hyVXLoUXXngBh8VCXacTj6JclsTInzl9+vRVr5zev38/Lq+fQH5jHMH4ixaIfPTRRygOF57YVJxu30UrY//MiRMn6NWrFyqVCq1WR8aQlaFEqdMd3sYq28geuTZkau7y88EHH1zRuV0t+vQbEEqyzijFl9+U66677oLbz79uIa74bBI7z8bmiw77q/zOggUL/tsZ13gonbv3vOK5Pffcc4iynWB+o3C19p+pmp3NYFlhsWzDYbVSv3FTYluNCyW18xtzyy23cPLkSdp17IzJbKGwSnU+++wzfvjhh8uayw033ECgqGXYh8ckOSks2UZ6/1sQJBsrbr/9gonhw4cP8/XXX4e7EY8cOcLu3btp3KwFJkFEsTsv+iy7e/duNm7cWCEOPnHiBBqNlsLpWykseRyzRfrHX3pcK3777TcMJjO5YzeSM+Zu9AbjP9ZtUcnFuaoJ6tB4KuuV7Hc1l8oA+d/PL7/8wrPPPntWlerfybq1awk4HCRHRvHyyy9f8n61CwqYJyu85fERZbVetlbdpdK9XXuqywqdZIX4YJCjR4/SpXVrFpfrJPcULFhMJtavXx+qElYUEiMjWbRoEWvXruXUqVN888032MxmXvf42OhwEul2h9sHI91udBoNA3r04OOPP2bmzJmsXbs2/AM4YuBAEiSZaEEgQqdjk8NJXaORqkYj/bp3B0KV6CaVmqEWkdTyCme72czGjRuBkMFiHbOZqVaZHuXa0gtlha5t2lzSNbjvvvsotoaqwm+32fFoNDzl8lDDYGTOzJnotVritTpKXSFDxly9Ab1KRZIg0FGxEeF2h5OSH3/8MQ2qVyfG6yUxMpJ0i8g4q4RiNpMaHYNdFJl1DmOJ1157jRr5+aTHxLCm3Jn34MGDZCUmES/LKIKAQxQpsJUnyGUFt8VS4c37Qw89hFGtRtGbcPoS0OoNLFq0qEI152+//YZoNPK828MTLjcmlQpzeZJ6+R903Lq2bUtbWWGZYsNhsfDFF1+cNecNGzZQt1wvfJ3dgaLRMEaSCWq1rLE7eM/jw2U241UULGo1OpWK6ySFz71+dCoVLl+A9IG3UViyDZs/huo1aqAzWVCpVAiys4ID8/bt29HoDCT3WERUo0EYzWJIN9rhYKwkY1CpeMnt5SW3F4NKRYFeT8DpIqb5KAqmPYYrNp2mzZpj0GjY6fGyyxdA0WhwJRUgKg62b9/OkSNHqFVQyGBJ5m67E1GjIUmvZ4RoxazRUlhcBWcwnqwR/0FjtJDYeTaRDQdid/to36kL/QcO4ssvv2TM2PE0a9mGhx9+mO69+uDNrEVsq/EYBImIev3IHrUerd5I1vA1FJZsC1VfCyHz0EC1juRNegjF5Wfz5s0osg2jzUfRjFKyR65FazDj8vrR6ozoRTvp/W+haEYp7visUCVTzTrEJ6exbt16YuIT8eU1xp5QgMEiY/NF0bxlG+ISUzCZLfTpF9JTLi0tZebMmbz44othw8W1a9dile24Y9OwOd3oDUZMgoW7776Hjl264Umpgq+4LYJoPWdAfiGuX7wExRPEn1ULfzCSn3/+malTpxGo1ilUkV2vHwMGDQZg0OChONJqkTFkJSZHkJTUNLr36kNEvb6h885pSFGVqmHZDwhVMFisEsndFpDYaRZqnZ751y3kzJkzbN++ndLSUk6fPn1Zc75WvPrqq0gONwkdpuNNr8GgIWcbMP6TbN++HaviIFjcClG5PNf2Si6Nf0uCmn9JbH0pS2X8Xcm1RDAY+MjrZ48/SJQk8emnn3LmzBkG9e6NaDSSn5pa4Tfnclm/bh218/MZ2KsXhw4duoozvzRuvfVWGpsF9viDzJMVFL3+ig3Wjxw5Qs2CAmSTCYckEWmxsEyxkSXLeBSF1laJBrJCwxo1OHnyJF6bnfmyQomsEOPzXTBhdvLkSW6++WbGjh7Np59+eqWny5dffsmWLVsuO+H3R5566insoohBq2X8qFH0796d9OhoJo4efdl6w39k69at+JLzw94hcUmpF93nwIEDvPTSS1csk1BWVsbEiRNRqVSIweSwEeDvTJs+A9nlxxWdQrWada44Xjpy5Ah1GzRGpzdQXK3mFRv/ffjhh9icbhyBWAKR0Rd9pj916hQTJ0+las26LF267Kx77LPPPkO2OwlkVEeUbRXkcnbu3Em9hk1o3qpt+GVGWVlZuADi4MGDPP/88xXupXfeeYc77rjjvC9cbBYLb3h8fOsLECNJ3HbbbVgVB4GMajjcXr755htWr16NOyGHvAn3o8RmozMYMVmsjBo77qzxTp8+zd69e8+qzP3kk0+wKnYCeY0QFSex8YkogTi0JhFnVn1svmjuvff8etrn4tFHH8UVnUrBtMeIbTmWKjVqn3fbjz/+GMnmIJhVC6ti57nnngtfv7jEZII1OhFRpye+QMRfqiouKytj0pRpxCam0Klr939MD/58zJozF7PFitliZcHCRf/0dCq5AFc9Qf1vWCoD5H833377LUGXi3y7A4coXnEF6z/F+++/T3JUFBajkSnjx1+Vdpjjx49z77338uCDD4YDDpvFwlseH3v8QRJkhXfffZeF8+dTLMussNkJmgUa1a2L22ika3lA29xmP8vgYNH8+Zj0epxWK08++ST79+/HY7EwzSrxiddPiiSfpTEMoRb3jRs3kpKcTFdBCCeXk3R6kiMiyIyLo3+fPkhqNXl6PYJKjaBSsdJmp1pWFseOHWPp0qU4ZRmHRkNAq+Ueu5PassKs6dPDxzl06BBff/31Oa/jM888Q6wk8bzbwxCLSFCjxaPR4LZYePnll0kIBskxGIjV6mhiMuHQaJBVKp4oT1gXOxw8+eSTANSrUoXqJhMZej3JOh13lTvBR+j1TJdkXnF7ibRaee2118LHX7JoEYJGg6RW08Zkxm2x8PHHH7N27VoalLeU1jUaGSaGqshHWiUa1K1Lg+rVcVqtdGjePGyiNmbcBAxGM2qtjnyzQBNZpkH16hXOd9Udd2AxGjGo1ZjUat73+njR7UUwGMLXJyM2lkedofOr7nDy+OOPn3Xd9u3bh0WrpaHRhE+jJUoQqFlQQHZSEjaLBYNWR8nkyQAMGzkao0rNrTY7t9nsmNVqRowciWR3Y49MQm8009wiYtbokKKzUalUVK9ePTyfsrIyalapgs4ooDdZWFqu5/7xxx/Tu3NnDBoNL7q9vOj2YlSpkNRq7rzzTmwOFyaLlfqNmnD48GHqVK+Bx2AgRbRSs6CA2267jTfffJO1a9eGAgrZgUWjxW61Y0+uitcfpH6dOsyaNYsDBw5gd3lwZNRDJ8gUTt8akvrQ6hGsMg888ADdevbGnV6DmBaj0ehNNG7SnOEjR9OoWUsmTJiA7A4QqNEFrd6EziggWGSMZoGnnnqKrNwCgtU6EN10OLLdSXpsLDMlBbvBhDOrAc7YTFq3bc/Jkye58847CURGY3EE8GfXwxeIPOthZd++fcydO5clS5bw3HPPcfvtt6MXrETU7UPO6A3YvJE8//zz4e1/+eUXImPi8CbmIioOVqxYwY4dO/jtt984ffp0+G/GsWPHmDdvPkOHjTirsmbp0mVExsRTs26D8zpoJ6Zlktp7SagaJjmfRx99lNWrV+OITiWl1w24EnK4/vrFQEjiwyiGkvTuvOaIUuhvlGx34opMxB8RddbDyi+//ILBJJA/6UHyJtyPTqf/S62JV4PDhw+fN4jesOFuqteuz5BhI664zfpqc+TIEVatWkWt2nXCLwMCtbozceKkf3pq/+f4NyWo/1eWyvi7kmtJg+rVaSPLDJFkIj2eKzKp/d3Q6sYbb2Tv3r3XYJYX54033iAlOhqPonDrH7SK77nnHnIkmZ0eL10tIh1atbroWJs3b6Y4I4PWDRueJYdQVlbGvn37mDlzJkPKu86ukxUcej1uk4ms1FQOHz7M/v37sRqN7PIF+MIXQKfRXLC6cP/+/WQlJiIZjMT6/ReVYSgrK+PgwYOUlZWxe/duhg8fTmpMDE1q1TpnkcXlkBQRwXq7g/e9fhwGA1VEK4873eTIMmvXrr3icb/66itE2UZM81F4M2vTqWv3S9731KlTfylmaNSkGSqVCrVazZy5cyuse/XVV3niiSf+Uuy0ePFiPGnVyJ/8ML7chkycNPm8227bto3xEyae8zkRQonhd95556rFSHv27OH++++v8OLjyJEjWGUbJkcQlVqNINkoLS1FtjlQa7R4/JFYFTue2DSsiv2S8wrD+vcnQ5apZ7OTm5LCyZMn+fDDD7n//vvDie5ly5bhy65LYck2NAYzGUNWkjdxM4JVrnDf79u3j7jEZCyynciYuLP+tkwvmYFOb8BktnDPxo20aNkaT3EbimaUEqzdk3Hjxl/Wddq2bRuSK4A9rTZyfAHVatY577Zz587FX6Xtfz1bevQOr9u9ezfde/Whc7cefPbZZ5c1hz9z33334YhIJK3/zXgzazF2/IS/NN61YN++ff9nq8T/L1GZoK7kb2fhwoV0l0O6YzMlmT5duvzTU7ogZ86cYeXKlYwdNeqaJNPL/h97Zx1mVdX24dOxe5+O6W4GJunubpAQBUGku0FSFExETEwsLEDCwH5Bxe5CFBAFQQERiZm5vz9mPJ/jDKWob8x9XV4Xzl577bX3qbWe9Ty/X1kZLerXp56uU1vT6Ne9OwCtGzakl6oxRSnPdjh06BAnT55k/pw5dGrenOaNGtHcKXCz7sJlNHGH7iZLUVi9enW19/Diiy8yY8YMLujblxiLhWs1na+CYXIEoYoBxfXXXIPqcOByOJCMRrQKeQ7BaES2Whmgqjzh8eKz2hgmSuwORXGZKNHIZueiihLLtk2a0FTTaKdqZCclMXvGDOpl59C6WTMee+wxysrKePbZZ9FFEZ8gVKvnXVZWxuxp0wi5XNROTSUvPZ2OLVpw77334hVF2stKRaaxAZvBQG2LlSKrlXYOJ4tVDclup0PTpixesIBYr5fGNjvLNBcTZIUMi5UpsoJsLDeN/DoYppamRwLapaWlOKxWXvcH+DAQQjYayVRVFixYwOTJk8lUVV7zBajrcFDsdPKc109jVaNd69a0UVXe8AdpqapceeX/79K+9957eJwC69xeFqkaRoMhkuFx4MAB1q5dy0cffcS3336L02zmJZ+fNR4vdqORpUuXsmvXLhbOnUuKotBNdxHt850y82Fg796kOJ30FER86v9r1f024+DX+2xcty5uk4mQyYRXVTl8+DBvv/023bt0YVxF8H2yrKC6g1htdgwGA8OHD+fdd9/llltuwa9pOC1WurZtS0lJCSdPnuTymTPp0LQpA/v1w2owYjcYGCxIqHY7u3bt4l//+hcrV67k4MGD7Nixg9WrV/PEE0/w7LPPRsb39ttv47Q7CTfoQ9HsTXhqtSCq6YXUHnsfoqJWut/PPvsM3e3FbBdweKKxihqhBn1JG7CYhOS08uDrRddQNHsTakIeksvP888/Hzl/7dq1zJw5k67t2lFfKs+u98gye/bs4ZtvvqFPvwG07dCZbdu2EXK5eNbr50HdjWCxMHLkyErPtKysjHXr1rFixYrIJHfPnj289NJL/PTTT1Xe45Lqwq4HSe41i8KZ69GjU1i/fj179+7l008/5f777yeUWTciN5FfXHlj40y8/vrrKJ4AmUNuIKpBb1q361Btu/zCYgRfLN46bZFUFx9//DHfffcdwy8bSWatPEaOHhvRhD548CCqy0Nsq6GECtpTr2Jy/MMPP/D666+fMug7ZOilqJ4gssv3j09eb1h2I3aHgN0hcO11Z2do9E9SVlZGUb2G+NOLcMXnYJd0ErtN+UPZNzWcmf/2ALXBYGhjMBg+NRgMXxgMhqnVHB9kMBi+NxgM71T8N+RMfdbMv2uoju+++4558+ZxzTXX/KGg8q8cOnSIWdOnM27UKHbs2PGH+pg+cSJZqkofTSfK660yh3ruuefIS0ujKCvrDxsuno5HH30Ur8NBkc3GY24vbkGI3EtJSQnDL74Yr6JQLzeXWikpJIfD3H8KA8Evv/wStyByt8vNSFWjRb161bZ74403cIsigzUdxWhkmabzZTCM5nDw7bffUlZWRrumTSnSdepoGn06dzntPcybO5fuFTJuAwSRuEDglH4Re/fuJSc5GafVSnZyMl5Foa3Did9kooNToCAzky+++IK5c+dy5513nnPWc3I4zINuDx8HQnisVi6tWJNcrKjMnTuXe++9l1tvvbXK3OtseP755+nUrQdjx0046/M3b96MrGpYrDYuvWzkH05iWrt2LR6PB13XIxmv54t58+YRzG9XHhxt0IsRvzGj/pWSkhJuv/12ZJePqCYDUdz+82rMWFpayoEDB87q9f7qq6+wOSW8tdtQMONJ5LhaWJ0Sid2mkDf5EaySCy2pIBKA7d337DYTSktLeeKJJ7j77rtP+foeOHCApNR0NF8Yk9VO+sCrqDWqPHHmV/lNgNmz5xDMb0vhrI2Eirsw/jcB5wMHDuAQRHJH303mkBsQZZWnn34aSXMTVa8rkuqqlJRyNnzyySdYHSJx7UahJubRuWv3U7Z94IEHcEUlkTZgMd6UPBYs/GN672fi6quvJlzQlqLZm4hrN4puPXv/Jdc5F7799lvmzp3L0qVL/20STWo4MzUB6hr+du6++27yVI3nvH46qhrTJp7bruHfzeUzZ5KrqEyUFdyi9KfK2arj22+/RXc4+DoY5vNACLPJRElJCT/++CMTx4zhkoED+eCDDygrK+Odd96hd5cuBDSNaLVcr3d3KIrmdjt2o5FuHTpU+2P/yiuv4BVFxsoKQbudDLsdt8mEbDTidji4qG9fvv/+e6A8CCLYbGz1BfgoEMJhMJJtsTBEFFENBuqkpHBnxXUbyQphp5MrVY2Aw0FcIEC3Nm3Ys2cPJqORHcEwu4JhdIeD7du3kxwdTQeXi3RVZcbkyRRnZXGbXq7nnakoDBkyJBI03L9/P6OGDWNgz168/fbb7N27ly+++IIvv/ySiy+4IGKucqko0drhwGM0YjUYEKxWOrVtS6OiIkKCwHWaTp6iIFosKEYjAZOZYYKI1WBAMhqRDOXZytGSRIv69SOT7LKyMlyyzENuD097fdiNRoKaRqaiUqxpJAQCeGSZhnl59OvRg6RQiCH9+zNu9Gguq8hUGaaoTJ30/0G4EydO4Nd17HYBb0ZDLDYHq1ev5t133yXG76eR24NHFHnyySdJj4vDaTDiMBjIsljwmkxIVisPPPAATz75JCtWrKhkPgflWRtr165l7dq1/PLLL1x33XVMnjiRTz75BCjPVm/TviO6x8cFAy5k2XXX4bRakex2glExmK02/KGoyC767bffTo6icpfLTbYsM2zoUL7++msmTZqEwWDAYTbjNptZqum85guQqaps2LCBhfPmUVfVuFl3ESvL3HbbbTQrLiYvLY1HH32UZTfeiOIJEEwrIBQVg6TqROU0RNZcvP3225H7ufXWW0kVJAKZTcibtBolLgfZG4UrHM/oseMr3fuxY8c4ePAg+UX10FKLMQsKuaPvJr7DGGrVKWDuvPk4XUE8tVpgld2o/miat2xFdu0Crr76mkhQOdrlimTgN/B4mDRpEkuXLq2UDbHsuuvQ7A7MVgeetLrIqquK+edveemll3CIMnIgHo8vWGn3/vDhw5gsVlL7LcDslLE4FRKSU7n//vsRZBXZ5aNug0YongAZg64mVNiBXn36nfJa1bF27Vr8ybkUztpIar+FZNYq/41ct24dY8eNZ926daxZswbVGya+wxic7jAjR45i+fKbcIoygqwyYtSYKv2+/fbb9Oh9AZdcOpz9+/efcRzvvPMOa9euZcuWLbz//vvndA/nm2PHjmGzO8gdfRe5Y+7B5nD+qcDJ38G+fftwiDKFszZQMONJjCYTrdt3YvlNN/3XGtv8k/w3B6gNBoPZYDBsNxgMCQaDwWYwGN41GAwZv2szyGAw3Hgu/dbMv2v4PcePHyclJoZ+ikorVaNTy5aRY2VlZX/7d1dadHTkN76uu1xG7Fd++eUXXJLEbbqbGzQXAZfrvI7vs88+wyOK3KG7uVAQaWV3ECPLvPvuu1XaZsTHs1jVeNztRXM6q8z3oFzHOUvT2RUM87TXR+Jp/HTefvttlixZglfTuErVuUV34RLFyO/e8ePHefjhhytVcp6KhQsX0tbhZGcwTG+ngMNgYM2aNdW2nTpxIv0UlV3BMHlOJ+0rkh5u093Us9lwiRJ+TWOIolJHVZk0Zsxpr33s2LFKr8mGDRtQnU4Eq5U+3bqhCwKFuo5PVWnVtj2+pFoEMuuRUzv/b5EQS0xNJ6XPXPKmPIrqCVaa054r27dvJy0tDavV+qeywX/P3r17iUtMRnH7CYSiq2z2HD58mOxadbBLGmaHRPalNxPdfDAjR485L9f/7rvvSEpNx+4USc+qdcb5Y2lpKf5QNIGiLhTO2ojTG4dV9pDSZy4F09Zg1/zYXWFyLruNYG5zxv5OfmPTpk2MHD0mYvb+3nvvUb9RU/KL65+VPNrx48d54403mDp1KqKkYHc4ue76ZZXaLFi4kEBOEwpnridYpzVTp02PHPv+++9xCBJ1JjxIzmW34ajwIdqyZQtLliypVLl7tjz++OOEs8oTVzIGXU1aVu4p25aVlTFv/gJy84sZNXb8KTeT/iy7du3C4w8SSstHUl2VJFr+CY4fP05MfCKh/Pb4M+vRsk37f3Q8NZw9NQHqGv52SktLGXPppSQGg/Tp3PkP7WqfL06ePMmOHTsipWz/+te/uGTgQBbNnx8pn2qcl8eqCjmILh4P99xzT+T8jz76iBnTp3Pbbbf94YnPsWPH8GsaV2g6U1WN5OjoKm3Kysro1707focD0WhkkqSQ53TitVho63Aim0zEBgKnNECbM2cOIysM/K5QNcKahtVkwmE0cq2qMUDVaNe0aeRauijygNvDM14/TqMRxWhEN5vp0aUL9erUQTWZSRREgrpOXlYWTYqKeOCBBzhy5EjkWeYkJzNMVRmnqMT6A2zevJnaLhe7Q1Fs9vpJCARoWlTE/ArjPL/ZTAdJJihKPProozQrLqafqjFLURHMZiSzGdFkwu100rJRI9JFkWGiRLzZzFWqhsVgoEFeXmSHtEvnzhHd66s1nSSLhYfdHhrYbIQCAUIWC9Mq9K1bCiK9evWiY/PmjBw6NPIcN2zYgGa34zAaEaxWTAYDnwRCfB0M4xUEdu7cCZSb68yZM4eBffsyYdw4Qi4X6Xp5ds7vJ36t23UkvsMYimZvwp/XHo/Dgd1ioZXDyRfBMHlWG1ajkViPh0KHg0Krld2hKJ7weEkwm8mMjz/le6lnx47kahq5mkbPjh2rHJ80ZSqBWs3IHXMP3qRc7BYLW3wBxkoycnQGhTPXE9VkAKFQNPv27aO0tJQr5s+nZd26LJo3r9Lmh+x0YjAYcBlNpNvsSEYTotFEnz596NOxI1dr5VrpF2kaS5YsqTSO5IxsMgaVGxSKrgBRTQZUSBX0Y+z48Rw/fpyffvqJQRcPwWi2YLU5MZrMpGfmsGrVKp5++mnKysp49NFHccpauTmiyUzt/CK2bduGPxiFxS5gsljxBaPYtm0bTz31FKNHj8YpiJgtVhJT0vHlNCOt3yIsToX0rGxEzYuiesm12RgpK8g2G1myTF9VI9rn4+DBg5HPSM/eff/fIbxBH6b9ZjIK5ZsREVmW2vnEtx9N7QkPIkVncNFFF1X6bOseP2pSAUpiPma7yIMPPkhsQrmTecGMJ3GF4hg3bjzJGdl07NL9rILBv+XIkSOkZ9fCF5eOpLp44IEHWLduHYo7QFSzQSjuAD179iLcqF+FOc1wBl08BKcoU2vEHeRNfhRBVk8pDXI23Hrbbci6l0BKbRJT0k77vb9z5042bdoU2TT7Kzh+/Dh2h5OcEbdTa+RKbA4nv/zyy192vfPByZMn8QejiGl+EdGN+xGXmFwTmP4L+S8PUNc1GAxP/eb/pxkMhmm/a1MToK7hT/P5558TXWGm/XEghMNqBeDG669HsNlwyXIlz46/mr5du9JZ1bhC1dAEgQv79mXGlCkcOnSoXOrCZuPzYJiPAyGsZvN5DeY8/fTTFFYkeKzz+FBNJnp16lRtYolHLpe32xEME/6dAfmv/PLLL9RJT6eey0W0LLPkDCZ1AG+99RYN69ShKCurUhXZuXDw4EEUkwmzwUAtq5U6VltE3u33/DZA3UQU8drt3KK7aGx34LZauaBXLxp5ytdYGzw+suLjuWbJEnq0a8ftt90W6ae0tJQhAwZgNZsJud2VDBmPHTvGoUOHePvtt/EqKm6Hg6KcWpjMFvKnPk7hrI1IuoevvvrqD93v888/z9y5c6t9Xs8++yz9unfn8pkzOXbsGAkpvwlQe4PnZBxZHT/++CPNmjXDYDAwc+bMP6Wr/VtOnDjB9u3bq5VyufnmmwlkNaBw1kaimw9GDKehekNVTA1/29eaNWvYuHHjWY1v4qTJhIo6UjhrI8E6rbl87twznvPZZ5/h9gWwOkRMdhE5JguzXcBoseF0h7EJEt5AmA6du1VaCz/33HPIupfo5oPRAjHcddddBELRxLUbSWLXySia64xzv59//pmU9EwCKXVQ3H5uuGFZlTaHDh2iuH4jjCYTdQqKq2jHz5p9OXangN0pctvtt0f+/s033zBl6jTmzZt/Trr33333HS6vn1BBB1xRScy+/MzP8LccPXqUpUuXMnvOnPMqdbR//342btx41hUuX3/9dcRQ9OTJk7z77rvVbsb9ET7//HNUb4ii2ZvIm/IoVpv9vPRbw19PTYC6hv9Z9u/fT2ZiIkFRJMbv57nnnsMtisxWVBqpGqOHDQPg8hkzqKOqTJYV3KLIJ598wvr161m+fDkeWeYyWSFfVZk8duwfHstbb71F+6ZN6damTbUaUJ9++ilBUeSLYJgXvH7cJhPTFZW2LVowevRolixZctqg1dNPP01IkpivaqQqCrfdeisbNmwgWy3P9H3O6yfO9/9O0bNnz0YymdCNJi4RJeqkpPDFF1/Qr3t3BlRkdPhtNmIEgaWaTqws069XL5xWK7LDwUMPPsju3bu59KKLGNy/P1988QW7du3CJYpcq+n0UlTq5+fz0ksvkRIdjc1koo7Nxq5gmMWqxoCePdFFkbcrNLhDJhM2g4G3/UE+CIRwmM3oViv1K2RH/ILAuJEjIxOjQ4cO4bRa0Y0mBgoimrE8W9xrMlFfkpk+eTLpcXH0EUTeD4QolhUkm43rNJ1uqsYF3boBsHXrVhIUhc8DIVa63OhWK1MrHJ+9qsrRo0dZv349HkFANpoYJ8k0lxX6dOnCm2++yfXXXssFXbuy8o47eP7555k1axb9+g9Ejkonudds7JKLOzUXgsFAjNnMJYJEfZudjwIheskKPl1HNBq5WXfR3SkgG42YDQYmjx3LY489hk9V8SgKDz7wAIcPH8ZhsbA9GGZ7MIzDYokEAX8NYl00+BKimw0q1xguaI/NbOYdf5BpsoIUlUbhzPVEN+pHvFNiYK9ep33P5qWn085RHqQ2Ggys0HVW6C7sRiOPPPIIQUmib4XO/EcffcS1115PVm4+F/S/kFZtOxAu7kzqBQuwO0Xc8VlkDFqKNyGbIUOGYLHZMBhN2BUPtcetIrrFYEJRsVWCcXZRIb7jWHJG3I7ZLuBOKeLyy+fyxBNPYHWI2FQvJpuT+GCQXF0nLEksXrCAo0ePkldUn6img8gdey96at3ySa4/Hqc/Aauo0LVTZ8JuN897/ewORZHvdrN+/XrqNmiM2WwhPjEZT0I2qf0W4o5O4ZZbbuHIkSOUlJTQq28/TCYzoehYPvroI6Ljk7Dr5eWBDncUFruz0oK8cbOWuLObEijuhk12EYqJJz4puTz7e9SdyLr3D7m1v/DCC6TFxZGZkMBTTz3F888/H9F7HD1mbETDOLr5YDp17orNKREo7oZD1lm7di26x0da/0XkXHYbTlH+UwHj1KxapA+8iqLZm1B80cQnp9G3/8BI0P9XtmzZgqy5CKbm4fYFznlB+c033/DDDz/w7bffcv/99582e+n2O+7A7nBidzhZsGjRP7pZerZ88skndO/Vl94X9P/DJe41nB3/5QHqHgaD4fbf/P+A3wejKwLU3xoMhvcMBsMjBoMh+kz91sy/a/g9v/zyC9E+HyMVlR6qSrPiYvbt24ficLDFF+ARtxevqv5t4zl8+DATx4yhe7t2eGSZ8YpKZ1WlY4sWAAzo2ZNkVSVeURg1dOh5vfZPP/1EWlwczdxuYiSJyRMmUFpayp49e6rIYl195ZV4nQJuu53U+Hg+//zzavv8+eefWbNmzV8iR3I6urVrRzuHk1t1Ny67ndtvv52rr766SnXU3r17qZWSgtNqJS8jg5tvvpnW9evTvWNHnnvuOb7++mvcksQsRaWFqtG4sIgcReV6TSdeliMShJs3byZVVfksEGKJqtOkoKDqmNq0Yb6qsTMYpomu4w+E0JLy8Od3wOX9Y5rlTz31FLLuJdygN7Lu5amnnooc++ijj/CIIleoGs0q1o3PPvsssqphtdkZNnzEedlEPn78OBdffDEGg4HevXv/5Zvpd999N76kXPKnPk6objdS0rOqlY+E8vVF2yZNyNN1MlWNIQMGnLH/yVOmEsxvR61Rd+JwBQnFxLNu3TqOHz/ObbfdxjXXXFPtmvbkyZNcOvwyfDnNUOJrYzCaCERFs3z58lPOh0aNGhWRCYxrN4q+/Qdirti4KJjxJE5ROaNJ5zPPPIM/Ias8W/nia4lPTjtl29Mlq/3444+VgtDHjx8nKjaeUHFnAjlNaNS0xWnH8Xt27NjBkiVLeOSRR875fda2Q2f86XUJFXYkHB33p95Tf1QPfd6ChQiKhqi6GDVmHMX1G6H5oxEV7ZQVGefCL7/8gj8YRVSD3gRrt6DeaYwka/j3oiZAXcP/LIsXL6aHWr6rP1pRad28Oa0qdvEfc3spSE8HynftV6xYwdiRI3nttdcYO3w4GapKpiRR5HCwOxTFWo+X2snJf9lY9+zZg+Z08pTXx42aqzxb1WZj4oQJZ/2j8vjjjzP0wgtZeccdHDt2jAZ5ecgmE03sDpIEkem/kaI4cuQIuamp5Og6bkGM7Jo3rFMnIu9RXxDpXWHOeLEoIVksvOsPssHjw6MoVa5/8OBBunbujFfXkW02cnQdjyzz5ptvsmHDBmIkmWs1nVxV5fprr+XC3r0p1jQ6STJ6RYB5tdvLWo8Xu8nErXp5NnZrTWPBggWVrvXss8/iMJt50O2hvs1OXauN3aEoJsgKmfHxHD16lH379tEoPx/Jbqdp3brUr7ivNR4vOYmJQLl2r18QqCdp5AsyaTGxdGnViraNGkVKsvr36MFQUSKv4hov+vzE+/2sXLmSJFHkak0n5HTiVHTCDftiFRTMdgm75EIymXje68NqMDBOkvGZTHRxOtkdimKMJJNus2EyGGhos9PHKWA3GNjqCxAQRCS7nbUeLxs9PiS7nZ9//pmgy8UiVWeRqhNyuykpKeGSYcMxW6zEJiSxZs0aNLcXb0wKwXA0E8aMQbLZEG02glGxGE1mgnYn8xWVFnXrnvb99PHHH9OwTh18mobBYCDLYuVfPj8mg4Hjx4+zZcsWli9fzieffMKzzz6L5osifeCVuJPzEBUdm0MkKjaBe+65l3ETJpJZK4/xEydhsTmxa35sWgCnJ5rCmetJ7jULq0OsNAErKyvDZHOScdE1FMx4EqvsRk+szaxZs2nTvgNWyUXBjCdJ6jkTv9nMzorNnZDLxf79+1FdHhyeaExWB2angsFkoWDGOgqmrcFgNLFp0ya8skJbh4O5iopbkhg3fgKBWs0pmLYGf1YjiurWI7t2AfUaNsZksWI0W0hKTcMTk0rBtDXEthpKQnIaZqsNk82JHJtN0exNJPWYQVH9RpF7efnll5FUHbPVQWLXKaT0noMgKcQmJCMpGgsWnTkrqrrPm9XuxB2dgSAoCA5Hpe+KNWvWoHgCxLQYguIJ0qpNW9zJ+Xhrt0XS/cyZM4e27TsgqTqCpLDi5purvc4TTzzByNFjWLt27WnH07ZDJ8J1uxLT+lIsgkpa/ysI1m7JhRcPqdSuT/+BxLa+lKLZmwgVdWTx4sVndb9lZWUMGnwJgqzicArIqk44pyGy7jnlwgrKN7Nq5xehuHxoLg/btm07q+vV8N9PTYDa4DYYDPaKfw8zGAzPnaKvoQaD4Q2DwfBGTEzMn37uNfxnsH//fubMns3cyy8/pRfGr3z55ZeMHj6caZMm8eOPP/LNN9+gORx8EAjxvNePKgh/06j/n7fffps0rVwq7g1/EI8sA+Vz/pdffpmtW7ee1wqV0tJSduzYwe7du3nwwQd5+eWXKSkpoWfHjugOJ7oo8uyzz1Y6p0eHDjSQZYYpCkGXq9Jzfvjhhxncrx933H77Gcd58uRJLr3oImK8Xnp26HBeNmMPHTrEpRddRIviYsaOHYfiCRBV3BlZdVUJUpeVlXH48OFTjvO1116jZaNGRLndxPl8EQm/UbLCrFmzgPJEm0xNY3swzA2ai4Z16lTpp2/XroxVNT4LhMhyOrEaDLRzOPFarMy7/PKzuq8TJ06wefPmSObzqEqb+RczaszYSNsHH3yQdh4vu0NRPOT2UDc7Gyh/3qfy4fijlJWVsXjxYgwGA3Xr1mXfvn389NNP3HHHHTzwwANVPHzOhTVr1jBmxAieeOIJoPwZdOnWE7PFSlatOqfNsP3mm29wOZ18FQzzaYVM5ZmyqL///nsysnMx25yEGvYlpfccJEWnbYdO+FLqEMxtTmJKWpXA53PPPUfnlq0IRcVisdpo0brdaTcdbly+HIcoY3FIRDe7CM0fzd1338Ogi4fgDifgjU2jbYdOZ/z8fPLJJ0iam7R+i4iq34Nmrdqctv3Zsn37dlRPgKLZm8if+gQWq+289Hs2OAWJOhMfpmj2JvRAdLUVGmfim2++ISU9C5PJTKOmLc5pA+jkyZNYbTZqj7+/XEfc7sQdk0rhrA2k9p1PRk7tcx5PdXz55ZeMGDmaKVOnVTGsr+Hfl5oAdQ3/s1x//fW0UFU+D4Top2oMrTAmGaYo1FJVZk+bVu15uiiyzR9ka4X8xVRZoZGqMvKSS/7S8a68/XZCLhdJ4TBeWWGwrNBMVelzFi7fv2fz5s3kaDrv+YNcKkrEB4JVfqCPHj3KSy+9FCm9gfLJmFcUqedyE+Xx4BcEhqkqLqcTxWbjLX+QtZ7K2TDvvPMOjz76KFnJKUhGI60dDpwGA30Ege5OgQt79+bYsWM0LCzEa7eTnpQUMYS88847ufLKK2mYn4+lQjNaNRpxmC20FkTuc3kICgJbtmyJXO9XM5jGdjtWgwGLyUR9UeKjitd57IgRkbY7d+5k6rTpzJ49m7DXS1fdRbKisGjePKB8AWZ3isR3HIu/sAvpWbWqPMvFCxeSL8u4TOXZ5vUkicH9+xMbFcXMCi3qQruDcONyGYuYVsOwKh7yp69FsDmRzGbiAwE8Tic+QcQny3gtFkSjEbPBiGA0MkdRma+ouE0mPvQHCYkiNrOZt/xB3vUHEaxWDh8+zDvvvEObhg1p07Ah77zzDs888wyucAJ5kx8httVQmjRvFTGx+3WB8sMPP7B82TIEmw2LwUCcIOAWxVOW3JaWlnLHHXcwY/r0SFZvWmIiBoMBs8FAuxaVMwD27t1Lcb36uNPrUTR7E1bZTVKP6WRfejMWu5NLLxtZaVJjstioNeouao2+G4vVjuhUcFhs2I1GOnXtXmni27R5C0xWOxZBxWwTSEpN5/vvv2f6jJkYLXYSOk0gWL83TpOJVS4PU1WN4pwcGjVqhFVyoafVJ6bVMMx2AacoE99xHHHtRqK5PPTpN4BgcVe0uFzsTpl27dszfsJEwsVdKZy1EcEbi9FsxWSxYbaL+As7kT38FowmC1IggcKZ64lrNwqjyUxyr1mY7CI21U/W0Jvw5bUnr7C40nP67rvvMJst5E1+lIJpa3AI0p/KWF6xYgVW2U2wbg+Se8/F4hCrOFc//vjjXDZiFI899hh5hcXYtQAOdxRaXBYOUSGm1VAEV4ArTlE2/Pjjj6N4AkQ3H4zs8jNhwgRGjBzNfffdx9VXX83DDz8c+V757rvvaNexC6GoGHwZ5e+F5F6zqduwsvP4lGnT8Wc2IOuSG/HEpnPvvfdWOn7ixAlWrVrFypUrKxmefPLJJ8guX7krfYPeuNLql28GdJ9GkxanXkzce++9+NMKKJy1gbj2o6hbvxGxCcnYnQITJ0+tkdD4H+a/PEB9RomP37U3GwyGQ2fqt2b+/b9BWVkZtdPS6KWodFdVCrOzz/m7csq4cSh2O7Ldzh2/kXL4uzhy5AhxgQADFZVGqkq/bqc2GfuzHD9+nOb16uEXRVySxCuvvAKUVzmlqxpfBsPcrrsjiTG/EuP18rIvwO5QFHluNy+//DIA69evJ1qSWKhqpMgKK++447TXv/322ylSVV7ylXv/TJ88+bzeX6euPUjoPKFc8qxulyqybmdix44duAWBB9weuggimtnMxboLtyhGkkFKSkro1akTss2GR1Eiz+L3/WQnJWExmVDMZjray5OIVrrctCgurtL+93z33XfUKSjGHZOC7PIxbPhlrFixAi0QQ1z7UWiBmIiOMZRr7vpUlUGqSpqisPh3yTJ/BatXr8bhcBAfH09qehaBjLp4E7Lo1ffM3iTff/89n332WaXP6tq1a4mSJGYoKtGSFAlSl5SUcNUVV9C/R4/TJiAcPXoUj6JwraZzuaqRGA4D5dmr/S+8iPjkNMaMG18laF1WVobLGyBnxO3lEiyeEDa7g7xJqymctRHNF47450CFIagocpWq01nV6N+9xxnv1xsMkzX0JlIvWIBD+n/T+rKyMp599lk2btx41oH9++5bRWatPNp17MKePXvO6pwzcezYMcIxcYSLuxLIaUKDxs3OS79nQ5PmrQjUakZUw954A6EzGggeOHCAVatWRb67AC65dDjhet0onLkef0YxN95441lff9++fdidAmkDriRz8PXYnQKi5iFYryfeWi3+1mdRw78fNQHqGv5nOXr0KB2aNy8PYNauzffff88nn3zCnDlzuOeee065A1yUnc0YVeM6TUd1Ohk8YCBXXnHFHy5xOVfefPNNMvRyfd9t/iDearKVz8Tbb79NUJLY7PUzTdVoWnTmiduvbNmyhdZNm9Kibl0WL17MokWLeO2111g0dy42kwmr0UiMz8f9999PWlwcislEQkVQeoai8rTXh2w0MkaSiTVbaNm4MeNHj6aezc59Lg9hs5mGRUVVrpublMSaikyF+pKMZjaTYLYg2WyVdn6XLl3KYE1ntduL12RCtFjIz87GabXSKL8gUjZ29OhRguEYQsVd8GfUo2nL1qxYsYL169dHJm+LFy/GoXgonLWR3LH3Iqs6O3bs4JZbbon8SJ88eZI506fTKD+fNq1asWzZMj755BMckoJqczBYVrAbDFhFjdi2l+FwR2GVdEL1e2OxOXj66ae58847ufvuu/noo484duwYebXr4EqtS/6Ux5CjswiZzLjtdmSHA9Fmo1eXLowbORLN4URzOJgzvbL+8dGjRyktLWXdunV44zPJHXMvgXo9yM0vrPJcjx07hmi385LPz/0uNxaTibvvvrtSm82bNzP8spGsXLmSGZMnk+FwMlyUcBpNPPPMM5SVlbF8+XJEUSQuLq5SKWq9Rk3xpNfH7JCwyR5MFhvZw2+hYNoaLIKKFJ1OSkpq5PMjKjpRjQeQ3HsORoMRs8WGwWDArgdRvOFKZaxlZWU8/PDD3HjjjezatSvymf3ll1/w+ENYJR2T1U6f3r2pk5JCs+JiHnvsMaxOibQBi/EXdcHuCpNfWMy2bduo16gpDZs055133qFrj954cprjcIVJ6DQe2R9T7lAdE4eg6NhkN/HtxyD4E0jrfwVSdCbBej0wWqxYHCJmu4hF0DCarWQOvgGHOxo5Jgu7K4RNdtO27f9nfpSVlbF69WqK6tZH8QTRg7GVFhu//PILAy8aTHJ6FgMuHMS0qVO57777ThkQOHbsGG5fgGD93nhzW2FTfYSjYqtt++v1JVUjudcs0gYsxmi24ivoFNGjtglStVIbI0aOJrrF4PIMjLQGiO4QoYb9MFkdBPPa4o5OZvqMWZXO2bdvH4FQNKHMusi6hwceeKDS8Z9//pm+/QcSl5TK+ImTqnwPd+7aA19iDoH0IvKL6kWO79ixA1HRyR1zL1FNLsQm6aResIBAdiN6X9CP5557rtrv6EcffRRPbDp5k1YT3fgCXP4QcW0vo/b4+9F8YbZu3XrK51bDfzf/5QFqi8Fg+NJgMMT/xiQx83dtgr/5d1eDwfDqmfqtmX//b/DDDz8gVciy7QqGsVssfyhjdO/evf9oVtvu3buZO3cuy5Yt+0vn8I8//jiFus7XwTDXazrNKua4W7ZsIV5R+CAQYqmmUz83t9J5F3TrRssKLxefqkbmrzNnzmRMha/MfFXjkjPIKixatIgBFQkT0xX1rGQYzsSnn35KvdxcEgIBunbugichm4QuE1E8wSqZ4Gdiy5YtZGhaxOwxqOtcffXV1eo3f/vtt3Tv0AGT0UhGfHy10g7/+te/iBIE/CYTK3QXjewOhgwcyMVDhnLR4Euqnc+sXr0axW5HMZkIJOWjucKEzRZcgsCYMWPp2/9C7rrr7irnff7551x55ZU8+uijf9uG9quvvorb7cZgNJLW/4oKfd3TZ98+8sgjCJKC7PLRrkPniBTF+NGjmVrxXpqhqIypSOJZcPnlFKoqi1WNgCiddi60detWmtetS7smTSLrsdlzLsefXrc82SAugzvvvLPKebMvn4tDcSMHEtHtAqKsESpoT0yzQbi8/krfKRs2bKC+u7zKeb3HR1Zc3BmfU3p2LnFtLyNz8PWIivaHNcj/Snbv3s3ESZO5/PK556RB/Wc5dOgQ02fMZOSoMWzfvv20bX/88UfCMXGEshqgeoNcX2EQedHgS4hq1JfCWRvxZtRnxowZZ3XtkpISUtIz0RPrYHZIWB0CNyxbhkOQ8dVph131MnPW7D99jzWUs2/fPho0aYbu8XHZyNH/EYk3NQHqGs47r776Ktddd92fci7+OznXD+rOnTvp1bEjrerX56WXXjpt2x9//JE5s2YxfcqU8yb6/+OPP6I7naRYLGQ4HHRp3fq07fft28egPn1oVb8+GzdujPz96iuvJORykRwTw8qVK0/7HL744gu6tGpFi3r1aFJURD9V40atPLvh1wzrDz/8EJ8g8JzXxxhJxmEw0MzuYJPXR7bVitdkJstiZaAg0qNCGuRm3UW7Ro1oXrduxFSvnyCgS1Kl67/66qukx8RQ3ykwS1ERzWaWqOUlgD3dHm7/jeHEK6+8QkCU8JhM3Oly85zXj+pwVNEY+/DDD3EFYyiavYk6Ex/GKZaXd+7YsYPGBQXEer2IFgthh4A7rhaCJ5oL+g/Eqyj0dLkJiiLz582LTChKSkrYv38/ZWVlfPjhh5gsNqKaDERNKsDtDSBKCmI4jVCDvpisDtLSs3jooYdwCwItRJFYUWTh/Pl88cUXjBw9hmDdbhTN3kSgTlt6CyLx/gBHjx6lbp06hEURnyAwe/p0du/ezSeffEL7tm1p3KABeVlZWM1mAi4Xr732GgXF9XAYjdS22dAFoYpb/C+//ILTamW1y4PLaKK7UyBKkiJB6ldffRVJcxPdYjCucCLRus6j7vKNgnp2J7rmivS1bds23G43fr8/ch1Fc2G2i4QaXkB8hzFYHQJ2p4TFqeDNbUVqv0Uogsz1118PlLtrxyUk4/YFGTBgAFIohYLpawk1vACrIFcpHf09d955FwVF9bBrfgpnridj0FIk1cX99z+AQxCxWKwo4RSKZm8i/cIlmB1StcYvH3zwAQ5Rihg4xrS8hKGXXsbx48dZs2YNou4lULc7wfq9y0s/WwzGaLERjo4lu1ZtbIoHIZCI3SkiSDJ2hxNvIIzBYMTpi8OXWkSvPuVB6KVXX4seiidYtzuCpPDggw9WCszOnDUbf0ZdMgdfj9MTTWuHgwxFYekp5C+2b9+O4vZHygaNJjN79+495TMrKSnBYrVRZ+JD5E99AptTxOIQiWoyAJvqwxWbzsMPP8xPP/1USRfwiSeeqMigvhibqBLfcSwpfeYiR2dSNHsTmYOvJykts8r19u/fz+rVq3nnnXdO+1r+fow7duzAZDJTMG0NhbM2ICp6JePGARcOwmgyY7LaSUnLoE5hXQrrNkDSvXhiUimq17CK4VVpaSn9L7wIq81OelYtktOzSOl9OYUz1+OJSTnnhfb5pKysrFoDoxr+Hv6bA9Tlt2doZzAYPjMYDNsNBsOMir/NMxgMnSr+fYXBYPiwInj9vMFgSDtTnzXz7/8OHn74YWonJ9Oibr1qtY9LS0vJTkpigKpygapRJz39P2LR+0+xadMm0lWV9wMhpqkaHZo3B8q/48eNGIHVbCbG5+PNN9+sdN7Ro0dZOH8+Yy67rFIixksvvYRXFBktK4SlcmPx07Fr1y6ifT5qu1x4ZPm8rM8a1K7NTFVjg8eHVxAYO248HTp349577zvnvo4fP05xrVrk6TohSeKa02Rg33///aSKEtlWK7FmC62bNKnS5sknn6ROZiaixYJmNtO9UyfiEpOJatCLqIa9iYlPrLL5nRodzSNuL18GwwSsdhJsdnYFw9zpclOvVq1zvqe/mo8++giT2YzBaEJPLiAjO/e07eMSU0kfeGXEePvXgPO6desISxLTZIUoSYpo/3Zq3pwVFVKK/V2uc8qOBbjwosERI/FQcVfmVVSm/paSkhKMBgO36i7u092YrXZsTomieg348MMPK7U9cOAAUV4vvTSddEWtkphTHR988AHZtfMIRcdxxx0rT9v2z5pPLll6DSmZOXTt0fu8b7qVlZVx4MCB82rYei6sXbuWYFp+xbppKakV1cRffvklbl8Ak9WOXfEgqfpZSYV88803iKqLwlkbKZjxJEaTidtvv52oOi0pmr2JlD5zq1RX1vDHGXjRYMJFHak16k7cMSmnNDv9d6ImQF3DeeWpp57CJ4pcqOu4RfFvN+34d6N+nTp0V1UGKippcXGnNU84W2677TayJImVLjfJNhtXVZQsVUdpaSm5ycn0EyVuqiiX+3UH+cSJExTl5NBAd5GmqowfOTJy3okTJ7h85ky6tGzJ/atWUSs5mckVWeOKycQmr4/doSjSrTZ6du1KaWkpW7duJVlV+SoYZoAgkm6xMqciY2OAICJbraQnJiIZjUhGI7MVlWxZ5sqFC3n44YeRTCZaOhwIRiP9evaMjGXfvn24JYnLFZVcu4PEQIBhQ4aQq6pMrTCu/L2B3IYNGxAtVl70+fk0EMIjCFWyLH7++Wf8wTDh+j3xZjaImCe0btiQCarGU14fusnEoy43E2UZn6py44030stVPmG7SXfhsVhwORyMHjmS+GAQ2W6nfp06zJ8/n+aiSKao4rE6CASjsFusZDllrHaBPJudeFkmNhAgz1auXf2Ex4tqMuEXBIpzcwmEorHLOharHafZzPz582naqBG6yUS21Uqe1Ypbkvj666/RbXbq2myMlGScRiOv+fzlJjKFhUyeMIGRssLdLje1rVaaNmhQZSK27LrrsJnNdK7Qv75Jd6Gazay8/XauueYaooo7UzR7E4ldp6BYLHisDkwmE2arA6PZWqmvDz/8kFAohKZpbNmyhdzaeRjNloqyvQ04pHLzC5tDxJfdDE31UuQUmDljBt9//z2Xz5nDgvnzOXjwICtXrsSbkkfhrA1EtxiCxSFWW9YJ5VnDc+fORVTdRDcfjNkhkT38FmJbD8NiF5AUlayhy8kZuRKzzYkem4FNVMnPL2D2rFmVArgnTpygrKyMZ555BlF1EVWvO7LuYdOmTUD5JtHQSy/DYDRhtNjQkwsQFY1Vq1bx4osv4pRUUi9YQKhBH2Ljk3CKMg5JpX7DxvgSyoO3OSNuR1RdFNVvTEJKBil95lI0exNRdVqycmXlifQF/S+M6DIH8tozRVa40+WmZb161T6LEydOkJiSRrBOKzwpBcTEJ0XGfiqmTJuB7PKheoN079WH1m3a4NT9eHKaIyoaU6ZMwSlK2J0i7Tt2Zs2aNZSUlLBmzRpGjxnLqNFj0AIxBOp2x2R1ENduFIHsRvTtP7DSdR577DFSM3No3LwVX375JTcuX07r9p248qqlp1wg/PDDD6RlZiPpHqwOkahGfYltNRS3L1ApgBsdl0jagCspmLYGzRfmrbfewheMInvYCgpnbcAViuP1118/7XPYtGkToqwi615atG77p3Qd/wxvvfUWHn8Qs8VKvwEX/unFUw3nzn97gPqv+K9m/v2fz65du9Ar5BamqRpFFbq6v2fv3r1MnTiR6VOm/Ck5qv8FysrKGH7xxdgsFtLj4qqYof+R7/eXXnqJWbNmnfG3/VcOHjzIK6+8UkXqqzoWXH45LkkiKzGxSqDwV1Kiyv13dgbDpGtapdL/P8Ivv/zCxo0bqwTpf8+tt96K02jkDt1dviax2Sptjqy84w7iZJnBsoImCBFJO6vNTuHM9RTO2oDNIVQxaM5LT2eppvOqL4BqMqObTDzv9TNKkmndqNHvh8G2bdvo0qo1/bv3YNeuXX/q3k/H4cOHufHGG7n11lurbFi/9NJLeLw+DAYDI0aMOO37KDs3j/gOY8gdfTeyy1cp2WPdunWMGzWqkpTHbbfcQrwsM1RVI2bnv6WkpIQFCxfR/hSbEq+//jqy5iKUno/u8Z0yS7cgK4uBqoZoc5DSew7Zl96MU6reuPCbb77hhhtu4LHHHjtvG2I7duwgKTUDk8lMt569/9Cc77nnnkPzRZEx6GpCea2reKv8GU6ePEm7Dp2xOwV0t5c33njjvPV9tnzwwQfImpvk3nMI5belS/dekWOduvUgptUwCmdtIFzc+azkfU6cOEE4Jo6o+j3LzTLrFPDmm28ia27iO4zBl5LP+ImTzthPDWdHmw6die8whqLZmwjmNOLWW2/9p4d0RmoC1DWcV4YNGsTlFUHJMbLC9FPoOP8vcPLkSYxGI18Fw+wOReF2Os+LbtWYkSOZUlGONUlWCOj6KX+ol11/ParJxNMVAeVMQeThhx8G4P333ydeUdgVDPO6P4AuipSUlPDYY4/RvUsX6ikqyzQXYUnCabXyrj/IzmAY3WYj2m6nmd1BlNlMkiDQqLCQqRMn0rZpU6IkCdFmw22zoxiN1LJaEUwmLhs+nG7t27NA1XjQ7SHDZqdHt26UlpZy58qV+FQVp9VKalJypR/grVu3klUhafKKL4BqtfHDDz+w4qabGD18+CknxVMnTSrXqnM6GTZoUJVn9Oabb1JYqxZWs5VEQcQlCLzyyivkJiXxgMvNElXDbTYTIwgEKzI6XnzxRaIkmQWKRi2LFdVgoJnNjsVgQDcaWe320FrT6N+/P3GCwMWCiF1QSeg8EcEfTy2bnTYVxpr3ujzYjSZcFSWIXZxOciwWdgbD1BHLM5hV3YPmCqOqHpxmM2rFhHlnMEzAZMZiNGEyW5Ar/r47FEWGxcq9Lg/XaTqN8/NZtmwZmaKI12RigaqRJQhctWhRlee1adMmQqLIjZqL+jY7AyuMGF988UUk1UVUk4HooXjMBiOyO4q8yY8QbngBistbpa8vv/ySxMREBEFgwICBOD3RCIFEpOgMomLjKSkp4dlnn0VyOIiTJEJuN9u3b6dWSgq9FZUuqkr9OnX4+eefkVUdi9WBzWpHEnUaNGnOsWPHmDV7Dr369ue5557j2LFjZOXURg0nYVP9BOv3wp3dFIvVge4QqZOREQlQ1x63Cocgce+995KXmUl9UaSdKJEeH8/x48fp1bcfJrOFYDiaDz74gFdffZXFixfz8ssvU1paSp9+A7DZnSiaixdeeIHPP/+cm2++mfiERKwOAZPFhkMPUjhrI9nDbsLikEjtt5CC6WuxSi5ERSNYtztKTCZOV5DUvvNwKC5c8VnEtrkMWXNXyizesWMH9957L7LqIpCaj9lqZ6Qkk6eqzJt96hK477//nh49euKUdcJNLkTWvTz//POR41u2bGHwkKFcedVVkY2z9957j4sGD8EpKQiyRtMWLanXoDEOUcZkdZA55AbyJj+K2S7iCifSrWfvSH9lZWU89NBDjB03nmuvvZZuPXszcdKUSiWan376KWabg9S+8wg3vIBwdCx6KJ6k7tNwx6Ry000rqr2Xa665hkCtphTO2kigqDNxSanUzi9i+vTpkQqG7du3E46JI6HLZGqPvx9Z9/LRRx+Rm19ITIuLSR941VmXeB48eJDt27f/oxmBxQ0aE99hDPnTnsAdlcgzzzzzj43lf5WaAHXN/Pt/kTfeeINERWVnMMzzXj9hl/ufHtJ/Je+99x433XTTGQOyfzdvvfUWIUliiy/APFWr1owQygPBHkEgVdVoVrfu35bd+dVXX+E0mfgiGObDQAiryVQpqNi5RQuWV2T+DtBd3HDDDQAU129EILM+gawG5BfVq3ZNkBwVhep0cslFF+G12wmYTMRaLLSvyHj/lcOHD+NRFK5QNUaoGgWZVSvFfs8bb7zBxHHjuOWWW6rVY16y9BoaN2/NgkVXRI6XlpaSUzufQFZD9NgMMrNrsXPnzkrnnjhxgmHDhmEwGOjZs+cpjerefvttYhOSEWWFeQsWnnG8UB64XrRoUZXKS4BFi6/Ek5BNYpdJKJ5gtXOUnTt3snHjxtNuiuzdu5exI0ZgtTvJuew28qc+gai6qpVu+Svo1rMP0U36kz/tCbwJWTz44IPn3Mdtt92GP7N+xAS9QZMWZz7pLFm7di3euAwKZqwjvsMYGjRpfuaT/gIefvhhCus14oL+F1Yya503fwG+5Dok95yJ5o9iw4YNZ9Xfzp07GTFyNOMnTIxscD755JN07dGbOZfP/ceyxf8beeWVV5A1F57oJBKSU89oavzvQE2Auobzys0rVpCjqNyouUiSFVavXv1PD+kfpUFeHt1UlQGKSnp8/HnJoH7mmWdwGo30dAq4TCbsZnMkE6C0tJSnn36aJ598kpMnTzKod29a2x1EmUwkmMuN99ySxKeffsr+/ftxiRI3aC7GVGTJXNi7N7maRp7DQXpFsLSf7qJpvfqkqyp1dZ2G+fm0atKEzg4nz3h9SEYj8xSN9qrGgJ49+fDDD/n222+55+67ad2oEd27dCEzMZFUVUO2WikWRTZ5feSoKg888AA7d+5Edzp50uNjsaoRZTbjVZRIidSRI0cIuVy0dzjJsVpJs9kqZXtXx+233UZIkmik64Q93kqyBPevWkWn5s1RHQ6a2mwMFSV2h6KYragMvfBC7l+1CsViIdNqZZAo4ZYknnvuucj5gwYMQDKZCJjMuI1GFKOR+jYbfpMJzWAgZLEQDgTIEQQUkwl/QUeKZm8ivuM4vN4AqsXCtZpOC1UjJzmZRJudGLMZ0WDkMlHiPX+QKJOJwsJCHEYjIySFMbKCYjSSa7EyVVZ4wO1BNRoJ2BwkdZ+O02yl2GZjhCghGo1YDQZUh4NXX32VkydP0qhePfoKIrtDUdyouejcsiUjhg4lPTqa/r1707J+fUS7nYLsbBSTicGCyBu+AJLNxv79+3nxxRcZP34C999/P1kpKSjhcqfl+A5jaHiKydKePXvIzs7GZrORnpmN2WIhLSOrUqbytm3baNu8Of179uStt95CsZeXVO4MhrGYTBw9ehSTwcAWX4DtgRCy2ULzVm0YNnwEvrQi4tqNRFJ1spOS8JrNOK0OErpMwmRzIOlemtSvz6hhw9i3b19E4sNmdzB/4SKOHz+OyWrHpQeRnDKi3cHdd9+NJzaVgmlriGt9Kc1aVjbXe/HFF3GF4imYtoak7tPIrp0PQGFxPQR/PNHNLsJkc2JTfOUBed2H2S6Q0HkCdSY8iFXSsdoFpHAKVtkd2dEOFbSjfYeO9O1/YaVJ/rJlNyIqGqo3SKu27Vm7di2PPfYYwy8ezLIbbjhj1lWffgOJbz+63LioQW/mzp0LwMcff4xDlIlufjFCIIGGjZvy+uuvo7o8GIwmao9bRd6k1dgcAqKsUGvEHdhUH2n9r6D2uFWYnTI5I+7AbLGekwTFzJkzsWt+CmZuIFDcHaPFTrhh3wrz0KEMGTqs2vOWL1+OP72oXOqlqBPh6DhMNgdGkxndF2TVqlWIqo4rKgmrU8RitTFr9uVAuT5k3QaNSUzN4L77Vp31WP9pCus1JKHLRAqmr8UTk3LWWXI1nD9qAtQ18+//RU6ePEnjwkJqaeVyC9VtaNfw53j11VdxiyIXuNx4RbHSHPOf5oUXXiBT0/g6GOYBt4ecxMRTtv3iiy/YunXr315p1LdrN5IVhVhZZuzw4ZWOLZw7l0JV5SpVJ/gbQ8ojR46wbNkybrjhhohJ+Kl4+OGHaeRysSsY5mbdRdPCyv4tn376KVGyzK5gmPf8QUS7/bT9ff7557glifGyQu1q5CnuvfdeXOFEknvNxh2bFtms/+abbxAVneTec1BsDprZHfhUtUo2cllZGUuXLsVoNFJUVFRt9vH5pnO3niR0Gv+HjTF/z/LlNyFIKpLmZtDFQyptIJw4cYLdu3f/JZVk7Tp1Ia7NcApnbSCQVlDFg+dMHD16lLTMbMx2ATGcilNSI0aT58rJkyerbDCsWbMGT0zFuqTtZTRu1vIP9f1XceLECaZNn0njFq1ZcfPN//RwajgF+/btY9u2bafcwPp3oyZAXcN5paysjGuWLKFr69bcfNNN//OadAcPHuTyOXOYMW3aeZswlJWVER8Ok2qz0VoUyU1NjehTdWzVihRJJlMUaZCXx6OPPopPEBCMRro4nMSbzahGI15J4vHHH+eFF16gWVER+Tk5XHHFFVhMJj4NhPg6GEYyGulaUdr16aefsnHjRlavXs1XX31FvdxcJJOJoN1OttXK7lAUm7w+MmJiI+P84IMPCLndKDYbPouFzwJBbtRcxLk9ZMTGMm3iRMrKynj33XdxOxz0cApMkhV8RiOpmlZJI2/gwIGELBamygpzZIX+Paq6N7/55puMHz+e5cuXU5SZxSqXh6+CYRrqOpMmTWL58uU8/vjjhCSJZZqLOlYbYZOJTIuV1W4vDVWVxQvLswqSgsFI1nl9j4enn346cp0Yr5envD6+CobRjUbudZWbdhRabXRyOLlRc+EwGvnAH2SpqmGy2gkXd0Zx+3nooYdYu3Yt3du2ZcbkyXz33XfYzGbGSzIrNRei0YjNYEA0GPCZzDgMRm7XXewMhrEZDIwSJXSTiXizmZt1F21FmZhWwxBUN6kJCcRHRZGdmEhyTAwjLr2UgwcPMnrYMFKio5GtVkbICgmyQucOHcix2XjI7SHFYiXGauODQIgWqkr3Ll2Q7XYEiwWHxYrRZELV3bzwwgvMnzOHnOQU7DYnVoeIyWLD7hTx+IPV7pofOHCA4uJiTCZTFYOUkydPEuP3M1nVGKVqpMfFkRYbyyBFoY+ikF+RkVI7NZVLJJnJsoJosfDJJ5+QWasO6QOvomj2JqRgIpk2OzuDYW7T3bhkN8Ho2Gr14Y8fP87Ro0c5fPgwDz30EHbZReHM9dQacQcWm4MVK1ag+GOoNfqe8uB708pZEC+//DJ6MJb8qU+Q2HUyuXnlixZfOJaU3pdTNHsTrszGyLG5WG0OmjRpgsFgwGwXMJqt6Gn1MNkECmeuJ7n3HMx2gXBuU1SXp1qdT9XlIWf4rRRMX4vi9vPxxx9XaXMqysrKqNewEVbZTVSzQQiKzosvvgjA3XffjZZcSNHsTaT1W4TFKSNICt467TDbRdIvXELWkGU4BIlAOJqk7tOIbXMZRnP5+0FPq09c60sJhKLP6Tv+3nvvxSaqONxhbKqf2DYjMNucBPLaImlunn76aUpLS3nhhRfYunVrpO9ffvmFlm3aYzKZyamdj9kukNh1MvlTHsMmu4mOTyat3yIKZ23En1SLdevWnfWYAD755BPGjB3H4sVX8ssvv5zTuX8VW7duRXN5sDsFOnfrcV42N2s4N2oC1DXz7/9Vjh8/zjPPPFOtSV0Nf54pkyYxTpLZHYpilqIy4pJL/ukhRTh58iRtmzQhSpLRBOHfUq+0tLSUl19+mVdffbXKHKSkpISrrriCft26/eGxHzlyhDrp6aRpGi5RrLJBfPLkSQqysmiuu6itaQzu35+ysjK+/vprDh06VKW/++67j04VJu8PuD00rF270vGJkyYTbtQv4mcybHi5UeHx48fxB6PwuKO49lefHk3nuuuuq3bcjz/+OE6nk7i4uCrSh+ebhx56CMUTIKq4M7Lq4o033uC5556LSIf89NNP9L6gP8npWVw+d95p54p79+7lyJEj7Nmzhy+++KJS288++4xAKBpRdZFVq04VaZbf89NPP/HNN9+c9dz0nXfeweX1I6ouCorrn3MAb/369fiTcqgz8WGimgwkITntnM6H8lhBm7btsdjsWKw2xk+cxE8//UTdBo0xmkxobh8mswVfMMx77713zv3XUMN/GjUB6hpq+A9j4dy5BEWRRKeTtNhY9u7dy1dffUXQ5cJoMPBpIMSOYBjBaGTJlVcyf/58iitMCR9ze0m2WHjE7UV2OLjttttIiYsjV5ZpoevodjuTVI3FqoZbkli6dCmffvpppev3696dwarGZq+faIcD0WqlrtNJjqIwZdy4SLvenToxS9XYGQxTbLMzVVa4VNXo06VLpf4efPBBwlYrV6oaIZOZOKuVlJgYfvrpJ/bt28eq++4jLIpcJIoIRiOyycTkCRMq9bFhwwY0q5W2Diei0YhfUWgiiIgGAyaDAdEpEqrdAlFW6F6RSXyT7iLTUp5VHqWqjBsxIlJSNKhPH1qpGjOU8gD9N998E7lWTlISCxSVDZ7y7PHeToGH3B5Eg4EeTidr3F40k4mLBBHFaKTQZkew2aroCkO5DrZkt7Pa5WGwKGI2GPAZDGRYrOwMhrnb5cZrMtPA4SAnOZnenTrRt1cvRJOJApsNp9GIwWAk2uvF7XTilmWsBgMxJjOCwUBaUhJ1FYXH3V6yJIn27dvzxBNP0LpZM6ZVyMSMlBQkS7kOdn9FZe7cuTzzzDMIqgur7KbOxIdI7jkT3e3Da7agGI0sUlQUgwGTyUzGRdeQNuBKnILEwEEX06V7z8jmws8//8y1115LWloaBoOh0qR67969qA4HO4NhdgTDmE0miuo3RJI0nE6RyVOmAuUO15cMHMiAHj25//77ywOUVjsWQcNbpz0ms4Uos5mtvgATZIWw280XX3xxys/P559/jtsXwBWKw2S1kzbgSmJbX0p0XCKyqqPFZWOy2FA0vYrWW1lZGRdeNBiL1Yru9kY09keMHIXDHUW48QBMVjtWh4hDDyHqQRxWB1anjNkhY7TYSMvMxp9Zn2Buc+KTklm5cuUpZSdiE5JJ6DKRrEtuRJDVSu/DM7Ft2zY0XxQJXSajpzcgGBVDaWkpBw4c4NNPP8VktRNq2BchkITZVm5M48ltRUqfyzHbReyCRGZObZLSsvAFw3gDIe688y62bdtG4+ataN6qbWQBVFZWxrwFC0nLyqX/hRdVkvX4LSUlJfTo3RejyYS3dpvy7PGGfcmpVZvXXnuNsrIyOnftgTucgOaPYuTosVWeP4CguEjqMYOCaWuwqV7qFBYT1bAPWZcsQ/EEzkmjb//+/WhuL1GNLsCXVkTvC/qf9bl/NSdOnPiPKMX7b6UmQF0z/66hhj/K0aNHWbt2bcSM7resWrWKdEXhVt1NLUVhxU03nVPfx44d47777uO+++7j+PHj52vIEUpLS/noo4/Yu3cvH3/8MbNnz+bOO+/8j/RC2L59O/kZGbhlmekViTFnw7Fjx3j99ddPKc34008/cdddd/HII49w/PhxOnTuiqi6EGW1kiE9lAdZ3aLEZFkhX1WZNXVqpeOvvfYakqoTXdgOSS2Xj/vtuTmZWTQUBO51eUhQlCr9/5Y33niDQCCAoiiVkmv+Cp5//nmuvvpq3nrrLfIK6+KNTUPWPSy78UZGjRlHIKcpmRdfhysUHzFf/C1lZWUMGHQxDlFGkORqkwv6X3gR0U0GUDhrI8GcxhFD9erYuHEjoqwgyCrdevY+6/frL7/8wq5du/7Q+/vNN99EcfvJGrKMqIZ9aN667Tn30aZdR8wOCac3ltjWlyJpHiZPnow/qyGFM9cTKuzAiFGj/5akv88//5xx4yewaNEV/zHZtv/JXLXkavyhaPKK6vLll1/+08P5t6EmQF1DDWfBnStX0r1tW65ctOgfn6C5ZZl/+QJ8FQwTVWFcMX/+fC5SVASjkXmKynWajmo0Uj8nh08++QSPKHKNptPS7qCrw8nHgRA2g4Fkh4NRkozLZOIlrx+n0Uit5GQ6NGt2yiBPi7p1I87OxTY7XZ1OUpxOLuzfv9KzGdCjJ2NVje3BMHmCgCoINC4oqBJkGz9mDFMrgqUzFJUm9evz/vvvkxYXh+pwEJAkrqnIHBgkiPR2CsTLcqUJWr9u3VisauwORdHJ4UAxmVBNZhSjkaZ2O4LRSEqfuYi+WESjke5OgbDZzHWajt1sruK4/Pzzz9O8SRPat2hZ5TnccsstqHYnqqQTLOqGZLEiGAxYnDLBut2x2JykxMYS1rSISeQwUWL0qFHVPs/pU6ciG43Ems2k2OyoZgtek4mXfH4myQqS2cIll1zCzz//HDkn5HIxS1H4l9ePYrNTV1X5OhhmoaohmExImg+L1YHZasdssaEYDORYrST6fFw2eDA9e/TAYTTSRFRwmsw4nSJxikJSVBTffvstmzdvRvNHY1P95E97grT+ixCtNgaLIr2cAglmM8NECZvZSt6k1dSZ8CBmm5Nw3a7Etr4Uze3l8OHD1G/UFF96Me6EWqiajsFgYMKECbz66qs0btYSq91JWJBoqGo0KSpC9QbLM5pH3YmiuSo9p1lTp+K0C/jy2lN7/P04fXEYjCY6OZyMkWQUo5GgopzSiAXKJ8ONmzYjVL8XRbM3oScX4vIFyS+qR9fuPYluMbg8aFqvBzNmzDhlP0ePHq30Xi8rK2PZsmX069ef8ePHYzRbKJi+loJpazAZTfhEibr1G3L33Xezb98+rrvuOpYsWVKuwTZqDK3adWT9+vVVrrNt2zYSU9LxBkLcfscdpxxPdbz99tuoniB5kx8huedMElPSiU1Iwu4Uyamdz+Vz52Kx2jGZTNidImabE7NTxmAwoLp9ZGTnEtNsUPnnRtFOWwGydu1aXKF4MgZdTSC7EWPGjT/t2B588EEESSaYUYykuiKLqD179uCUFAqmryVv8iOYzZZKz3nnzp08/PDDLFu2DKtDwGyx0aZ9R7766ivqN25KODaBa6657pye08svv4wnLp2i2ZuoNeIO/KHosz739ddf56mnnvpLAgQ1/PPUBKhr5t811HDkyBHefvttOrdqRVIoxKypU88YKDp+/DiF2dkU6S5iZJmFc+fywQcfRLR4y8rKuO7qq2nfpAlXLlx4TuuKsrIy2jVtSr6iEu90kp+d/ZcFrnbv3o1XURgmK+SqKjMm/XPGZSdOnPhD66/2zZoxWdV41RcgQVEilWS/5+TJk3+4Uumll17CFU6gYMY6UvvOIzUzp9LxL774gtqpqXgEgd49qq+Iev/991mxYkWl6tFfOXbsGONGjKBxXh7LTpE9/Vu+/vprsrOzMZvNf4sh2iuvvII7OonCWRvJGrKMUEw87Tt1jUiAhPJas2zZsirnvf3226jeEPlTnyBtwGKi45OqtBkydBjhul0pmLEOf1ohK1ZU71UCkJyeRWrf+RRMX4sejOVf//rXebm/srKy08rYXHvt9UTHJ9KgSbMqGuGnY//+/bz77ruIqhtvbivSBlyJVXZjFxXGjx9PMLcFhbM2Eq7fg8tGVL+GPJ8cPHgQty9AuEFv/Bn16Nyt519+zf9lft3cyB62guimA2nU9Pxpl/+nUxOgrqGGM/Dkk08SJ8vcoLmoo6pce/XV/+h4shOTmF9hNKg5Bfbu3csdd9xBgariNBjQjEYyLFZyrVYG9x8AlBvgdW3dmrzMTCSDkYDJRNhkZlWFPEUbh4P2Dgdek4lkWeaRRx6pdM3jx4+zbds2du7cye23345LEEgVRXxmMx8HQtyguejRrl2lIOqOHTvIiI/HZDRSkJ1NvMdDdkJiJSfod955h1rJyWhmM10FEb8o8tRTTzF5wgQuUlR2BcPUcTjIcgos1XR8RiOdHU4koxGfKDH8kkv44YcfWDB3Lvl2Oyt1F06DkSWqzrWajlZhUtnC7sCp+DDbHMxXVFIsFhItFuoqCm2bNKl0r1u3bsUjioxQVKIkiYceeqjS8RdffBGT2YrgicEq6thtduqKMnFtR5RPxBr0pm2bNgQlCZ/JRKrZjNtookk1LuClpaX4VJWFispiVcNrMuEWBLq0b49HkkgKhSKmlr9l9erVqE4nqsNBq6ZNydU0PguEGCJKOEwmshxO9JRiao26E3c4lcGChGw0cr/LQ7MKqYyxokTY7sThEPj+++/5+OOPOXDgAFMmTKB2RgZOScFkc2Ky2DFarMT5A8ySFT71B3EbjWRYrXQUFSw2AZPNgcVqp87EhymctRHNG+Ktt97CbLEgx2RjU30YzVbS09MxGAyYLDa8tVqSO+YetOhUBg8ezM6dOxFklYQuExHD5VkYv07Ujx8/jt1iobGkEtv2MgpnbURPq4cvvwMOo5F+uougKPHII4/w0UcfsXnz5mqlGh588EEcigs9tR61x63CnZzP0qVLAViwcBG+tEIyB1+PJy6DW2+9NWLAdy4U1W+ExSmT0Gk88R3GYLHYCFituDx+9EA0vkA4skt+Qf8LCeQ0JaHLRGTNzSeffHJO1zp58iSXjRxNfHIaFw0ZWilQWlZWxuhx4zFbrKi6m85duxFVr0e50WBOU5YsWUJpaSmZOXVI7j2HghnrkHzRXDhoEEeOHEF1eag1ciWFszag+aMrGTf+nhtuuIFwfpuI1nr7Tl0jx0pKSpg3fwEt23bg5ltu4frrl6F6QwSz6qN7fJWyy37++WdERSW512ziO47DH4yKHPvoo49QdDdROQ2RVJ3nn3++ysbSubJ582ZcvgAmi51gvR7IMVl07NItcnzfvn3Ua9QURXNx8ZChlRaV8xYsRPUE8calU1y/0d+uwVnDX09NgLpm/l3D/zZbt27FoyhoFgs9BZFnvH7SFPWMMlKvvvoqaarGrmCY57x+FKuVGFlGF8TTZr+eDYcOHcJhsRA0menhdBIym5k7a9af6vNUPPbYY7SokKZ4wuMlLzX1L7nOmVhw+eXYLRY0Qah2M/901M/N5Vbdzc5gmEJdrzaT9/obbsRmd+AQRO6//4Fq+3nvvfeYPXs2q1atqrIhsG3bNlRvkDoTHiS+41hq5xdVOt6suJgpqsZTXh8BUYzIYPyVHDp0iDZt2mAwGJg4ceJfmlz1xRdfIKku0i9cSkyzCyms25BnnnkGSdUJpRfgDYSqrQD88MMPkV0+6kx4sDyRIjWjSps9e/aQkZ2L0WSiRet2p5Vhy87NI6HLROpMfBjFEzynarpT8d577xEMR2M2Wxgw6OLz9hxfeuklZFXHFYzFLqqkXrCgXLYwKoNWrdvwww8/kJ6VgyCrRMclnFPg+2zYvHkzvmAYVXdzR0WF7+uvv443NpWi2ZvIHXMPusd3Xq9ZQ2WeeuopfPGZFM7aSFr/RaRl1fqnh/RvQ02AuoYazsCCBQsYVpEJu7jCCPCfoqysjD7duyObTLhsNm6qKAssKSlh1NChBDQNm8mEZjZTlJNTpTxnz549KA4H16s6zWx2sm02ujkFZKORkMnEC14fQxWVBQsWRM45cuQIeRkZJCoKkslESBDwKAqXX345bkFgvKyQJEn4NQ2b2Uybxo0rTSA+/PBDnEYjN2k6De0ORIfAnXfeyeHDh1FsNhYqKjdoLkSrlaeeegqA6VOm0Ectd5HvrCi0a92apsXFCFYrMWYLW30BLhMlEq1Wmle4h7dt0QK30YjFYODzYJgvKnSb+zgFPEYjDqORS4cNK3cdV1TSEhO58847IyZvn332Gc899xyzZs3iMkWJvN7Ruk5xdnak5K5Pjx7IRiOjJZmQyYzVYGCeqqHqwfKApKNcJ/oel5u2DgfN7HZmyAq6KNK8qIjRw4ZFAvk//vgjNpOJ7cEw2yvGKxkMNK5f/4zB0UOHDvHtt99SUlLCgJ49MZtMyA4HLZ0CvWWNqKYXUjR7E8E6benhFPCYzSzXXeRarYgmEx8EQjzr9eOSpEifF3TrRktBYJai4jAaSe41h9rj78fhicbuFNEFAb/DQUZ8PONGjiTR5yM5NpYJEybQqWt3vAnZBLMbkZaZzfHjx/H6g4gVhopJ3aZicUjlmc8GA2Iopbx0rXaLSMneo48+il2QCTXsS2yb4ehuL7/88gslJSXoosgCVUW02rFKOnZXiJgWg4mJT2TZsmW88sor3HHHSiTNjSc2jXBUDHXr1qVHz94RfeepU6cRrN8bPa0+ZrtAXFJK5L16/Phx+vQbgO4LkpyWjiDJWO0OLhk2/Jyyk4YMvRR3Uh2EQCJmh0R7h4MMu4NAQYeIWeGoMWMBSMvKJWPQ0vKNjYziSsYqjz/+OG5vAN3jY/XqR6pcp7S0lOuvvx5PQg5Zl9yIL7WAxYuvrNLuxIkTlJWVMWLkaMLFXcqNYLIbsXTpUrZs2UIwOo74DmPIm7QazR/Nli1bAJg5ew6aL4wvIYvCug145plnCEXH4fYFqpgN7tq1C7cvQCijGElzRT7HAEuWXI0nPouk7tPRAjHEJCSTfuGS8vdmekEVM5nNmzeTkVObOgXFvPnmm5G/z5kzh1C9HuWGii0vYdDFQ876NamOsrIyVN1Nat/5JHabhtFiQ45KY/HixZE2Fw8ZSqiwI7lj78UTl8EDD/z/wlV3+8gZcTuFszagB6KrzXqq4T+bmgB1zfy7hv9t2jRsyNWaTiu7I6IB3NHlOmNW6q5du3AJAne73IxRVDwVpuN36G6Ks7P/1JhKS0vxqhp1bXZ2h6J43O2lTkrKn+rzVHz55Ze4JYmZikojVWXU0KF/yXV+z/79+5k3dy4LFy7k/fffx+V08i+vnwddHqI8nnPq66mnnkIXRaJFEc1mQ7DZuPw3FXIHDx7E7hTJHX0X2cNuwilIVYKQ27dvxy1JDJcVMhSFxb9ZI0H5XL4gv7BCJziqinZ7Vnw8j7i97AqGydH0KqaYt6xYQV5aGn06d+bAgQPndH+n4+TJk1x22WUYDAa6du1aKYnofHDPPffi8vgJRsUwZepUElLSqdeoSaSS8fPPP2fdunWVjOp/z9TpM7FYbbg8Pl5++eVTtjubwPDrr7+OPxjGYrUxYdLkc76fdevW0b5TVyZNmRZZGzRs0py4tpeRP/UJ3FFJlea31XH06FHee++9M67hmrRoTULnCRTO2ogaSsQuqbgTahGKio0kX5SWlvLdd9+dFw+S48ePs2PHjoiUpdsXIPWCBWQPW4FTlNm/fz+HDh3C4w8Srt8Tf3oxXXv0/tPXreHUHDt2jDoFxbijEhEVrUpC3P8yNQHqGmo4A2+99RZuUWSQ7iIgitxzzz1AeVZyQXo6TQoKqphRlJaW/qkflAcfeIBoj4ekcJjnn38+8vf169eTqWq86w8yQdXo3raq1tWBAwdOqZkGcP+qVaRGR5OVkECd2rXxVOg/J1ks1BZE3JJU6X4efvhhGrpcLFRUWtsdfOQP0tzhICc9nfXr1zNl0iQa163LWEVlRyBEmiDQqVOnSMDmvvvuI2w2M0bR0P3xRLcYjNnqIOByYfqtZrbJxLfffsvatWtZunQpuWlpmE0mGtTJi5hiXHHFFRRLEruCYW7UXKRaLNgtFmL9fpw2GxeJEj2dAkkWC7FmM5rRSE+ngGI0Itvt7Nu3j88//5wHHniAwqwsolwurly0iPtXrcLtdBIvSgTcbgKCwGJVI85ioYdT4GbdhUuS+OWXX+jUsSP9K3Ssb9BcRGsaUU4nTpOZFKfEAEGghd3B7lAUK11uGtjs3K67cZlM3Oly01KSKMjNZcuWLdRJT0c3W0g0W0i1WEgwm4kzmZGMRuLDYZ5++ukq8gG7du1i7JgxdO/WjUuHDeOCrl255+67KS0t5V//+heK1cpYScZqsSF6ojFZ7MgOB5LDgddk5hpNJ2C1IlgsyHY7d/1GGzva5WKz18/uUBRpNjue3FZkXbIMq6TjS8lj5cqVfPbZZ5Fs0eeeew5ZcxGV0xBFd7N06VKuuOIKsmrVxu5wUrd+AwRXkNrjVhHdZCAWQSVQ3B2jxYbBYMDqEIiOS+D7778HyjdaDEYj+dOeoHDWBsx2IVKi99RTT5EQDBLj9XLhwAuJjk+iVl7lz15SWibpFy4lvs1lCDYn7uRCgvV6obk8HD58mFdffRVR0fCm18MqyPS5oF9kE+fkyZNExcYTrt8Dq+Qite888qc8huoNnpNR1E8//cSQoZeSmZuH6HBQ4HajSRK+9LrkTVpNoFZTZs2eU/5+XnwlejCWcJ2WeAOhyHM4ceIETlEm46JryBx8PVabo5Lr/JYtW/CqKkajiWDd7uXGOk0vpFmLVmzbtq3ace3Zs4fktEwsViuFdRvQt/9AbKKK0xePxalgMJoYPmJUpWD8li1bWL9+Pb/88gsuj4+UPnPJHHIDTlGqYlSzd+9eHn/88Sqa9b0v6E9cu1Hlwfl6PciqVZtgndYk95qFrLnP2sjnnnvuwR2TSvqFS/Cm5LHoisWnbFtaWsr+/ftPu6ApKSnBarNRe/z95E95DJPNieIL8+STT0badOrWg9i2l5UH03OaRDYEAbJy84hpcTGpFyxAVLTTfufW8J9JTYC6Zv5dw/82XVu3ZqqqcYfuRjAaqaUoJIbD7N+/n6+++uqU/hEATzzxBMVZWTTMzydaknjVF2CaqtHmd9V0H3zwAStXrqy2gqqsrIzS0lI+/fTTyPwAyrV2ZYuFazWdDorCRX37nrd7Pnr0KNu2bYtcb+vWrQwbNIgrFi6sVs7q+PHjDO7Xj8RgkIsvuOBPS16VlpZSKyWFXqpKZ0UlLzMT1WzBbjDgMZlwy/I59/n999+TlZjIlarGNn+QkCRFqsJ++OEH7E6B2uNWkTPiduwOZ5W5wz333EMXT3nF6X0uD03y8ysdb9+sGT1UlemygldRqnhH3HvPPbgFgTRVo2F+fqVntG7dOgJCuZdNP1WjX/fu53x/p+Po0aPkFRRiMBjwen1nnYlbVlbGqlWrmD59RqVkgV/54YcfcIoSWZfcSGrfebi8/j88xpKSkvMqU/NHspzfeecdZN1DQqfx+NOLGV4hqVFUvxEJnSdSMONJvHHpPPnkkxw4cIDt27dXGfN3331HUlQUSapGQNcrVQz/nm49+xDVoBe5Y+7BHZXEsmXLeOKJJ85oAvlH2LVrF+GYOBS3j5j4RL799lucgkStUXeSP+UxBFll9+7dQPlmzKTJU7jqqqv+bUzD/5s5ceIEr776Kl9//fU/PZR/K2oC1DXUcBa89957tGvdGsFqRbHbmT9nDpogcKfLzXxVIy02FijPar3l5pvRRBGH1co1V111ztc6ePAgqtPJWo+Xu1xu/Loe+RF86KGHqKfr7AyGuVbVSAoGkR0OaiUnR7JEz4Ynn3wSvyhSyykwWJTYHYpiiarjdTp57bXXKrXdvHkziYrCDFkh12qlwGqjrcNBN1GkVkoKpaWlDOjRk0mKSn2bjaCpXJ9Yczr56KOP+OGHH1CsVhSHREqfueWBqvQG1HY4kU0mki3lwVmvKDLmsstIU1S66i7iAkH27dvHK6+8wtALL+SqxYv58ccfycvIIGA24zAYaVKhLz1TUbhLd+MwGGljtyMbjSgmEzdrOvVsdhwGA+nx8ZGd4+KcWkxTFDZ5fchGI6nhMA1sdmpby6VRksJhBvbsicVo5HWvn3/5Akg2G/v27ePFF19Et1qZq6ikORy0bdGCaFEkzmajo8NBHUHCYTTSwGZHM5bLqXjsdjpWOLbfortwqz4cTpHmmsZXgRCDBBHdaCRoNNHQZkc1GpGNRtJlhQZ5eZHJ7JEjR4j2ehkgiBX9m+jmdBIny5GyxY0bN9K3SxemTpzISy+9xHfffcfJkyeZNm0aQ2SFqzUdp8GAw2Cgdnp6JKC4detWNKuVLIuVCwQRp8WK2S5isjsRvNHoHm+VIFyvvv3/X9qkuAsLFiygb/+BRNXvQd6k1bhi07HaHBjNFkw2J57c1uXaz+n1ycmphcFgoGnTppHg648//ojZLiD449GiMvDbBaK83rOeJDVu3oroRhfgD6fhsNipPW4VRbM3ofiiueuuuwjoLqwmE06rjdg2l+HPbEC/gYMA+PbbbxFkjcJZG3H64kjpPYe8yY+iuAOnlbeA8ontgw8+WEWnec+ePbzwwgvs2bOHNu074RQkmrZoVSmzYsOGDdx000289957bN68mWeffRavP4TBZKb2+AeoPeEBjGYLrdq0xRsI4/L6SYiKYrnuYqPHh8lsxeGOwmix4k3JQ3H5uP/++6sdZ1lZGT///DMHDhzAandgETVyx9xL0exNuMKJpyyH3Lt3Lxabndyx95I/9XGcosK33357Vq/JunXrkHUPUYUdkFUXL730Ev0vvIjiBk2qla85FWVlZcycNYfs2gWMGDUm8lmubqzJaRk4BInktIyI5md1XD5vPqKiYxdVvMEorr+hskbi66+/jqK7cYfjSUhOrZTZ9Nlnn9GgcTPSs3N5/PHHz/o+avjPoSZAXTP/ruHvY9euXZEgyb8Ln3/+OZkJCdgsFi7o0YPNmzdz+PBhZk+bhsvpxOV00r9PHyaOG8ejjz5abR9lZWXMnDIFlyRRJy2t0lz95Zdfxi2KdHd7cEtS5De4rKyM0cOGYTWb0R0OPE4nmiBUqjj6Vbpv/MiRlTaw/wz79+8nJSaGDF3HI8tV1gPVcfXVV9NIVXne66eJqrLkD6x7fsu+fftQHQ52BcPsDIYxGY2kOp1sD4a5QtWok5r2h/rNjIvjQbeHL4NhklW1kj7x/IWLsDsE7E6BW2+7LfL3vXv3MnP6dEYMH45LELhcUSlWVaZPnFipb5+q8ro/wO5QFBl6VYNtKM9G37JlS6W5y5o1axBtNooqsuHvcbmpk5Jy2tfzxIkTrF27lk5du9OsVVs2bNhw2vueN38B/vRiYltfisFoRNd13n333TM+r6uWXI0rKolwwz7IqouPP/640vFvvvkGp6SQP+Uxcsfcg93h/FtM/P4q7r33XsK5TSiavYnUCxaQX9wAKF8bqbobp6jQpn1HHnnkEQRJQdI9dOjctVIy2uLFi+lb4Yc0XJJJSEymXuNmbNq0qcr1du/eTV5RXRTNxcjRY//SZzd+wkTCdbuWr9UKOzJjxkyuve4GBElFVF0MvfSyv+zaNdTwR6gJUNdQw+/Ys2cPfbp0oXlxccS866effkKwWnnbH2SbP4jdYsEvCHwVDPOWP4hot5dr1ckKTqORx9xeXvcHUB0Odu/ezUcffVQp+6E6fvrpJ4b070/tlBQki5VPAyG2+YM4rNbID9d3331HcmwsLocDyW4nQZR4yx9kqqrRoXnz0/b/0ksvUZydTYPatWnfsiVXqBobPD5Eo5GhokTYbKa+08mU3028fp1cBzSNKF3HaDDwdTDMrmAYzeFg7969fPbZZwTdbnSjkVt1N7tDUXQVBFasWBHJ/oiNT8DhChNu2BfB6iDa4SAxPh7BaMRuNJIolEuNbPL62B2KIleSWLFiBbLdjmI0IhqNdGzblhMnTtCxdRsmVgR8R4gSeVYbw0UJm8GA02BAMRhQbTZirFb6OJ286w9SKCs0LC6mICMDl9PJEx4vO4NhkswWvIKAyWDgi2CYr4NhnCYTw4cPJzpcLrshGo0kh8OR12HDhg3079mTPr17E+XxcJOqc5PmQjGZEHxx5I65Bzk6E81sQbDbeeCBBwjoOi2cAprVTmLXKbii08gQJd70BxkiSjgrxh40mlCMRtZ6yssBMzUtYuryzjvvkFCxofCWP4hiNFJkszFGVpg5c2bkNVu9ejW9O3Rg4bx5kWznXysBRKORejYbnRxORkkyfk3j8OHDXHfddfTXdK5WNGpZrSTHxfH000+jCwIFioJHlqtkA8yeczm+1ALSB16JQw+iiiKNmrYgrkIn2pWUh9lsIeuSZWQPW4HRbCWmxRAEWSMtMxuz2YLBYCAvL48DBw5w4sQJXG4vRoOBebLK58EwUbJcaUF3+PBhevTqS1xSKlOmzag0qdu5cyeNmrbA4/EhOwRccbXwF3TE5fWTFZ/ACt3Fe/4gutlC9rCbyBx8Pbo3SElJCSUlJaRlZhOs3RI9LhuLzYHFajvjxPHRRx9F1j2Esxvg8QX/0AL7o48+QnN7ccdmYHGIJHQaj55aH6PZgtFkRgynYrYLJHQaT9qAKzBZbCxQVN7xBZCMJmrZnSgmEwntR5PccyYNm7as9Pn9dfzff/89CxYs4IoryvuQojNxZTQi3HgAVodQrabz559/ju7xofhjMNkciKqbIUMvPaf727p1K8uWLePDDz8852dzrkyfMZNQfnsKZ20klN+eadNPbXZ57NgxcmrnobgDCLIa0bY8fPgw33zzDWVlZfzwww+8/fbbNZkk/4PUBKhr5t81/D1cPmMGutOJ5nAwf/bsatuUlJQwYeRIaicnM3b48L9V9/+3c4CjR4/isFh4zx/kdt2FbDQyRVaIk2VW3XffOfU74pJLmFEhIThGVphSYUL4wgsvkKQofBAIMVdRaWizc7/LQ62kqiZy55Ply5fTpiLYukDV6N2x4xnPmTR+PCMrjM7HKCoTxo79U2MoKSkhLS6Oi1WVfqpGUkwMOVq54fpiTadV/fp/qN81a9agOZ34BIHu7dtXybI9dOgQR44cqTSOjIQE+isq3VSVnORkBvXty1WLF1d57w0ZMIBiVaOPppEQCnHw4EHGXHopeampTJ0w4ZQZvcVZWdyk6cSZzeTZbMhGE2FRJNpXfaZzSUkJLerXR3VKeLKbkth1CpKq88UXX5zyvocMHUZ0s0EUzd6EJ7spsiwj/85ovjoaNGlBSu855RV6+a257TeB+1+5ZNhwJM2NIKtcPnfeWWUuHz9+nKGXXkZKRg7jJ076y7Sxt2zZwvz583n22WfPqv2uXbvQ3F7CBe3RAjFcd90NkWPHjh1j7969lJWVkZCcRlr/KyiYsQ5XKK7SRseKFStopGq87Q/idYr4CzuT1H0aNqfIrl27zvs9ni0zZ80mkNucgmlrCGQ3ZuHChUD5JsOXX375H72xUMN/JzUB6hpq+B3NiosZpqrcpLtwiSJ79uzh6NGjSHY7z3r9bPL6kOx22jZpQpamEScrTB0/nvZNm7JE1dGNJp72+ng/EEJ3OGiQn0+0LKP/ztxjzZo1jBs1irVr1wIwetgwOqkaD7k9eKxWfE4nbqfA6MtGcMcdd/Dhhx+SmZhIa91FuizTsXVrCiuyqW/SXTTJz+fIkSPVZhYeO3YMlyRxs+7iWk1HFwTyFIWbdReKxUqmzcZ9LjdtBIH87Gzuuusuvv76a1566aVKEzaA/MxM+qkqgxWVlJiYyO7xm2++iW61kme1sUDVkE0mxo4ahcNiwWE0YjQYyLZYUUxmHAYDBQ4nstHEAEGktsWCbjTiNZlIMVtYrGqIRiOxfj92o5EnPT7WeXxYDQYOHDjAiptuopaqskJ34TabaWCzM0gQcRqMtLTbEY1GZKsV2WQiaDLzrj9IB1Ei0+HkYbeHKHt5VnWi2UKUxUJebi6iwUA/p8AQQcRqMKCbTAwVJTSjkXtdHuJkmW3btvHaa6/x0EMPEeXx0FN3EWO14jAYCVXclxZOJJzVhGy7k65OJ4LRSHpcHO+//z4tWrVGCycTbngBDruDxGAQm8FAvNnM814/cTYbGSkpBCSJSarGGo8XryBGSj8PHz6MT1UZIcm0czgJm8zUstnwiGJkkjRn1ixkk4k4s5lsSWLebxZ7b731Fi6hXPLkbX+Q3aEoklWVd999l3fffRfd6SRsNmM3GNAFgf69ezOuYuExSlaY/LvNi2PHjtGqTTskQWaCorNQ0WhYUIDm8qB6gvhDUZhMZmqPvY8648szgRWHgGi14smoT+GsDbhSCjGZzGRlZdG5W3fccRmo8bnIdid9ZYXk6OhK5ZCjx44nUKspWZcsQwnEsWjRoirv97KyMlbcdBN1Cwtp375D+b3ZbNzv8vB5IITHZEJLrYfgT0BwBSN6kgcOHGDhwoUsWbKEgwcPVtFwr46mLdqQ1H1aeWVAnRbccsstZzzn94wdN55Qgz7kTVqNVfWR1GMGJpuTrKE3kTPi9kgGelyHMZidMlZJx2p3YjYYyLZa2R2KYrXbi0vxEMhpzKWXjQTKv2NkTccpSKy4+WaS0zII1mmNP6sBgqJjlVxYRB2TXTilGcqcOXMI1e1WLnNRrxftOnRk6dKl3H///X+p6c4foaysjFat2+BwhQg36kegdktmzao+2AHlkkm+hCwKZ20gpffl1MorZP369QiygiCrdO/V59/uHmv4+6gJUNfMv2v46/n5559xWq286w/ytj+Iw2KtdkNw+fLlFKkqaz1e6qkq115zzT8w2vIMVqUiyaG3U2BkRbLEIlVjcL9+Z93Pjz/+yPjx46mlKNztcpOlqNx9990ATJ8+nUSLha+CYVboLmpbrSxUNRrUrv1X3RYAQy+5BIfRiGo0kmmzMfziwWc855NPPsGnqhS6PfhU9bSyBmfLnj17mDh2LFMmTuS7776jV6dOOCwWAi5XFcm1kydP8sMPP5xVkO2HH34464Dcd999h+5wsqsiccVoMGA3m/FpWhUptZMnT3LHHXewZMkSvv32W5ZcdRUNVJUnPF7qKCq33357tddo17QpE1SNJ91eHAYDFzgFdoeiuEhRmV2N8eX7779PrCwT7ZTJHHw9RbM3EUipXW2G7q+89dZbKLob2ReFxSGSV1hMVlYWJpOJ5cuXn/K8OXPn4YnPJKblJUiqq9pKwrKyMp5//nkCoSicokJO7XwOHTp0yj4BrrhiMb7UAjIvvg5PfOYpn82f4ZVXXkHS3IQb9EJ2+ao1xqyOL7/8kuuuuy6Slb5161byi+tTVK8hb7zxBsePH0fz+DHZHMgxWciap9JzOX78OH27dkMXRawOkezht1A4ayMOV5i5c+ee9/s8Ww4ePEjdBo0xmy00bNL8vFVc1FDDX0VNgLqGGn5H2OXiJZ+fXcEw6ZoWKXG79557UCrK7B5+6CFOnjzJM888w5YtW8rNCzt3ZoyqsVBRsRuNiFYrfbt3J1fT+ToY5i6Xm8KMcofiJ554goDDwTRZwW02s3z5cto3acJy3VWefazrzJ07l7vuugtfRfmf4nSSWmHe94ovQEjXaVJURFiS0EWRXl264LRa0QShionD/v37kW02vgiG+SQQwmIyMXfWLDo2a8Y1S5dSKyUFp9WKYjIxU1FJFkQkm41c3UVaXFylzMrvv/+eyRMmMH706EquzGVlZYwaOhS7yYRisTB16lQ0h4PX/QGu03RcRhN+o6k808Ri5RbNRZLZQm+ngGgwEGM286DbQyO7nWSzhXtdbowGAyaDgXcqFi5Wg4ElS5ZQWlrKkiuuoFPz5ih2O29VBFvjzGae9voYKkrUttrYFQzTwyngsttxO51coZSXXvXQXRTl5+NVFNo2acr8+fNxGowkmi1YDAZSLRZmVWS1TJIVLhREAqLImJEjiZIkEkWROhU602s8XnwmExcIIqrRiK67cRiNvOYrL/dLsljItlhpkF/AyZMnuf7668lNz6C5ojBHUVGMRq6veI9k2uw8/vjjbN++nSZFRaRFR3P777IWPvvsMzq1bUt6XByd27alVatWjB07liNHjvDdd98hW62s8Xi5WtMJm810admy0vlPPfUUqtVKsc3OAEkmLhDk559/5uTJk6TFxhJntuA1mejkdJKekEAjVeVpr4/6qhoxMzxx4gR33HEH1113HXfffTe5Snm28yWihGIy47RaGdi7N4cOHSInMwuTxYbF5sBps7M9GGa8LKOn1qVw1kbCdbvSuUtXRFHEYDCQNXR5ucyG4mLM6NFVZDM6du1OdPPBFMx4End2M8w2O+lxcSxfVlmeYffu3cQFgiSpGl5VJeR0ohqN5XrkZjNKQh2Suk0lVK8n06ZN/wPfFOUMHzGKQE5j0vovQvNFsXnz5krHz2YhNG/+fCyCisnqwGwXMZitGE1mckffTe3x92O22nEoLswOieSeMymctRFfYg4xcfHIRiMPuD0MkhWCuotLhg3nyJEjlJWVISkqGRddQ85lt2F3OBFVF4WzNlIwYx1GowmrU8Iq6kjeKC4ZNrzasd122214ErLJGrocb0o+kqoTLmiLJzaNseMn/OHndi6cPHmSffv2nfFZrl69Gi1YLs8iBJIIhmOqaEH+ln/9619ovihqjbqTmGaDaNKiFYkp6aT2W0jB9LXogRheffXV8307NfyHUBOgrpl/1/DXc/z4cWSHg3UeH2s9XmSHo9rs6EnjxzOmYsN8oqwwZsSIv3Rchw4d4oJu3ciOj2fB5ZdX+v15/PHHCblcuGUZr8PBTEUlQZa55+67+fzzz8lLT8cjy8yZXv3cYvv27QRdLnJdLjSnk+KcHBYvWBCpeHJarfhM5dV0doMBp8VCjNfL66+//pfes1uW2ez180kghGI2V+u/8dprr7Fo0SLee++9yN++//57nn/++dNKav1ZDh8+XMXb5/333yfkdiPZbLRt0uRP61//lpKSElJjY7lAEOnkdCIZjVyn6Vyt6TQpKDjleatXr6Z2ejo9nM7yKk9ZYfq0adW23bFjB/Vq10YwmlCDSbQUZLb5gzRRVK677roq7b/99ls0p5OeooyoeNCTC7E5BHp26nTawPBjjz2G7A6SdcmNhIu70Klrd9q3b4/BYGDs2LHVeiaVlJRw3fU3cPGQoZW8kH7PxUOGEtWwD4WzNhLIacy11157yrZQkdHd/OJyuYl6PZnxm+rP88GxY8corluXUIO+FM3eRGyby7jwD5hqnzhxAlV3k9hlEvEdx+H2+rn55pvxJOVSZ8KDeLKbUVh86mz+9Kxa2PUAalIBVsnFgt8Za/4T1GRK1/CfQk2AuoYafsfMKVNIVlSaulzUSkmtlMnx23L53/P111+Tl56BZLczuH9/vv/+e7Zs2UKsLPOaL8BMVaNlvfIfswF9+kTK+qbKCorNxhNPPIFPFGnp8RD2eNizZw8XdO3KFRV6Vv0lGdlm42pNZ7Cq0aJePUpKSvj000/ZsmULQVHio0CIVS4PKVFRVcbXt2tX0lSVREVh+MUXR/5+7Ngxmtevj8NkYlCF+d+1mk6x1cbuUBStXe6IMeTp+OGHH5g4ZgyD+vblnXfeYceOHXgEoTxj22giyWxBMhrxOp3INhuFVhu5Vis9nAJWg4HuFZO5qzWdNIuFnv/H3nnGV1Vmb/vscurup5c0EiAhoQVCQu+9V2lSpEhTOiJVRFQsYC8zWEHFAogoiIpid0TEggUUUKpjAUVFRMi53g8nnr+ZUILKODNvrt+PL+y9n+fZp+SsvZ617tvtQRVFalapgmKzodpsVHI6ufXWW0vN261tWzoZJmNVDUUQuNfrI0OSKLDb+SwSo7NuMHHCBFatWkVAUWjt9xP1+ZLJ9US7pp1WJQnn0YqKJghkSjLXGhYhSUIWRebNmkXEshinqDR1OHDabCwyLdo7XTQt0Y8zBQGPKGJJEl1dbmZpOn5R5CrdoEo4nFxzXnoGf7O8jFRUAqKYkCURRGpUrsyxY8c4dOgQn3322Sk/a9deey2NGjQgJRCgh2HQ3jBo2aAB27dvJ+zxsCsS45VgGJcgcN+995a6dvPmzbSqX5+czEzGjhmTfB02b95MhqKwJxLjuUAInyjSoUULmjVqRNiyGDlkSLI6v9d5/QhWySdSuyWZVXKompKCaLPhE0SmaTrvhyJk63pyo+Srr75i165dWCWu9lcbJk63gsPpJqtqDvv37+cf//gHkiQhOtxEG/fD9AXKVO9/++23ZGRVRXQkErl21Utq6+FkOt3YHW7SMqvw7rvvcuDAAbKzcxhUIodygaqh2u3cZFpcoOkU5OahmV5iuUUYXv8fqvj58ccfGTp8JLUL6nPzLf/32Txw4ADVa9VBkmQ6dunOsWPHOHHiBHfffTeXXXYZn3zySfLcK6+8El9uEwrnPE2osBt2l8KFo0bj8ijIDheS3YHT7cHwBUlpdj61x9+PxxvGW7UeGe3HYjrd1KtenS+//DI5ZnFxMU6Xm1oX30edqY/idCtEUtKINepNpKAD+QVF7Nixg9lz5nDHHXecsl36xIkTjLt4AhmVs2ndtj3hyrUomrueGqNuJ7VS1lm9Vo8++ihNW7Zl1Jhx5a7g2LlzJ9GUNNyKTu26hae9bv78+cQa9Uk+lAwcNPSM48+aPRfd8lG9dh127NhBXs18srpPo86Uh9H94aTZawX//1GRoK6Ivyv49/DYo48SNAyChsmqVatOes7WrVvxaxqtAwF8qnrO/zZffOGF9DRMnvQHqarrpQx0f8vatWu5ePRoli9fDkC7Jk1o5XKhCQKqKJ60QvTSSy5h1K/SHrrBpIsvTh77xz/+gSGK3GN5ae104rHZqKsbNLcsmhUW8vXXX9O0oACX3U6P9u35+eef/7R7Tg0EWOb180owIVH4r14T999/P7ok0dDpxC0IPPjgg394zrfffpvCvDxqZGby5JNPljq2c+dOmhYUUCUW487fmBT/Src2bZlnmHweidHAsnj44YfLNWc8Hj+tkf0tN95IxLJICQTIcLqYpGrcblrUK3kGa16vHgcPHqRB42a43ApdevTi559/5pFHHiFdVZmtG1iiSH6JPN7p5M3i8Thuj0ruiJsIZdTCJQj06tSp1Pu6fv16pk2ZwpNPPsnKlSuplZVFpZQU/E4nS70+ehkm40acOgn78MMPE8ktomjueqqcN4d6DZpw4sQJxo8fj81mo0uXLr+7qnbUmHHEGvSgcPZaQrkNuOVfikX+lU2bNiXi77z6GF5/GW3rP8rUSy7FTKmCQw9QqfMEjHAGS5acfZX2t99+i8Plod7MNRTMWI1st3PVVVcRqdM2IXvScijnD7nglNe/9NJLuBQVM5aF5Qvw2Wef/YG7qqCC/7+oSFBXUMG/sGPHDgYNGsSIESO47777GNizJ9dfc81pg5nTMXfGDCxFoXbVqkmphjFjxuATRWZqBlFRQrbZgEQA/thjj7F37166tG6NQxTJdzi4z+sjRZZp1qQJXVq25IL+/UtVln7wwQdEFJUPw1GWef1kp6aWWUdxcTEbN27klVdeSSY+9+3bR3ZGBnl2O4/7AlglCcaoJFHX6eS5QIg0RWHOnDmnrUSERFB+nmEyXTeSusaTxo7FEEXu9/r4PBylhsPB5MmTefzxx1FkmbdKKp/TPR7cgkAzR8Lg0Gmzockyoy64gH379hFQEtXJiiiSlpaBLxhm3uXzgUSCcP68eUy86CL69eqFLgh4bDaqShKCzUZE15OmdB9++CErV64slcg7dOgQLlmmsiyzMRCiv8eDIopUCoepXaUqd991V/L1Sg8EqGN3MFc3UAWBpg4nDRwOskSJEYqKVbL2Ry0f3V1uFFviHEMUufo3UhR5WVkogsA4RaWN00XlWIzHHnuMeDzOqlWrkjp553XtSnFxMTt37uTVV1/l2LFjXHXVVeiCyGRNxyeK3Gl62V1iJHPs2DGa1Csk5nSiSxJV09NZsWIFx44d4+ILL6ROdjaGy8U1hskCwyQlEEje2+7du/F6PKz0BZil6Zh2Ow2bNCOUXY9wXiPyC4qScgcut0LdaY9ROOdpzGCM87p350JNp6acSALvicSobrezcOHCUp+R9evXU6tyZQrz8ti0aRPfffddqST8hg0bcLnc2B0OHjiJluP1119PuFYLCuc8TaRhH/TMfIxgBg67i+ojbqFS5wlUza1Bs1ZtMTJq0Nit8F4oQhddZ0C/fjSvV48+nTuzb98+9uzZw5o1a8oYP/7KF198wUsvvVRuR+21a9dSr0ETunTvxf79+xk6bAThuh2oe+kqglXrctdddzFx8hT8lfKINuiJ6Qskv8PXXnst4RrNKJyzjnC9zvTp2w9IPKiqpp+6l6wgZ+BVRGJp1MgvQDe9VK+VT0rzQQnpjbrtuOaaa8qs6ZZbbsXlUXEpGtNnzGL37t2Mu2g8U6ZO45tvvkmet3PnTiZMnMS8y+fz3XffsXz5cpYsWVKmGmnv3r1oppf0DmMJ12xBj959y/XaQKLNVLP8VO49i3DN5gwdPrJc1w0eOozUZgMTr031Jqd9+Hn//ffRTC+pBe1QTV/SQ+BkvPvuuyxcuLBMt8nKlSvxB8PIdgeXXPr7K+sr+O+nIkFdEX9X8J/F3r17Wb169Un1ef9surVpw42mxb5oCj0tL7efJEF6MmpVqYJXFHk9mOgerByNlTln0aJFNDcMXg+GaWMYXFWiCQsJs7a2Jcnr+70+dEFgZ4lhoOlyMXr4cAYaJh+HozQ3zNPKNJSXH374gXfeeYcnn3ySqM+H7nZza0nH3G+pU7UqS0p8Zto5XWRnZCSPFRcXs2nTJj744IOzmrtSJMIi0+Ihrx/T7S4VczUvKmK6YfKUP0hQUcoUE/Tq0IFZhsmuSIx6llUu4+XNmzcT8/uRRZHxo0aVKQT55JNPCHg8PB8IMUbR8EkSK30BBigqiigSsizeeustJkyaTLSgA3WnPUYwu4Dbb7+dsSNGMK/kvZuq6fTs3r1c2sP33ncfLreC0+Vh3vwrSh1bv349EUXhEk0nRVWTpsx///vf6e5NdN3eYnrp1LzFKcc/fPgwWVVzCGbmoRpWUloS4JZbbkEURfLz88/aQyUej/Pqq6+SWTUHUZRo3KwlR44cOeN1a9eu5YorrmD37t1nNV95aNWuI5V7zaRyz0tRgukMGDDwd1cO9+h9Hr7UKvhimQwcNISvvvqK9MzKeCNpeAOhM/qq7Nq1iyeffLLUM2cFfz6//PILe/fu/d15mgr+86hIUFdQwW/45ptvEtWiukGBqmHZ7VxrWOSqKtkpKdSrlnvapMevHDly5LR/KPft24dbFAmLIl5RpLBGjVLHly9fTn3T4tNwlCYOJz5RZKRHIU/TTlnNPOWii3DJMpaiJNcYj8dP2fK2cuVK0kyTVEkmR5b5OBxloNtDVBRRHI4SIw43iiDgl2Sifj8HDx4sM87HH39M83r1cAoCSywvy7x+0tyeZPtf51at6KuqhEoSx2pJEteQZXpqGtM1HZcgYLlc9HV7WOsLkKGo3H333cTjcT766COiqsqOSIxnA0E8soOaY5dgBKK8/vrrpdZy7NgxVKeTPDmhy/u0P0BWJFJmzfF4nFnTpxPSdcKWRcOiIgxZRhEELLudqf+itQywfft2MoNBHvT62RdNoZXTxfkeD2lSQnvaU2Km6BBF2nsU7rC86C4XY8aMKaU9DtCgdm1SJYl90RTeCUXQnU6eeuop0oNBDEniEZ+fnZEYWbrO5fPm4fN4yDUMqmVmUSUzkwklmodXGCY17HaGGAa5mZlEIjF8gkhPtwe3zcZEVcOUJFq3bEkVl5vz3R4cNhv3e30MVXUkUUx2CDz//PM0rVePsK7TqHZt3n//fQRRpN6spyicsw63qieDrMIGjYkWdiGt9XAsf5CPP/4YXZZx2GxogkBYlEiTJBo2LN3+dsVll5Hi89G0oOCUgemOHTuoVKkSmqaVaSu86aabCFZrQL1ZTxGs2wnJ6cEpyzgVk3qznqLGqDvwhyKkZGSRe8FiIlXq4RREGtWpk9yk+Ff279/Pef0G0qpdR1599VUg0cKqmV5CWdUJR1NLSdmcjL1796LqFlXOm0NK4/OoU1gfRTeRnB484SyCuQ1YuHAhbt0ib8TNiaRytXrJz8Xhw4cpKGqIbLdTNbd6smrpo48+QvMGkwnq1Iz/q1j++OOP8QXDWKFU0jMrnzIA/uabb8rIpPyWH374gUA4SqzxeYSqN8XwBREdLpxGkFA0tUx11uuvv07vvgOYPHXaaStutm7dSo38uqRkZLF06TKWL19OrEbjhEP6wCupU9iw1PnvvPMOdQobUK1G7VJJ42EjLiSlUe9EdU61Iu64445TzgmJ7+mSJUu4/vrrGTVmHCtWrChzzvvvv49qeIk16IkRiLBgwQJmzppFl67d8OgWqun7XfIl8XicS2fOxvIFqFW3XkXFzH85FQnqivi7gn8fn332GRPHjWPW9OknNez9d/PMM8/gVxQa+/ykBoNlqolPxU033URAFNkZibHaHyDzJDHozz//zODzziPm9dG/R89Sfhf//Oc/ifn9dPL6iCoqEa+XSYbJHMMk6vMxcvBgJhtmQsLOMLn22mv/0H1+/vnnpAQC5JgWMb+fnTt3nvLc7h060MnlZrnPT0gUadagAZD47Tuva1cydZ2wonDlGfR2f/75Z5YuXcrSpUtxyTLP+INcoZsYTieff/558rzc9HRWlxiGVzdNXnzxxVLjbNu2jYxwBLsk0atTp3IZZzasXZvFpsVH4SiVdJ3XXnuNeDyejIU3bdpElq7zeSTGGn+AoK6TX6UKfTp35vPPP+fEiRPs2rWLPv0GkNpicEKqoqRIYOXKlaSpGpdqOhFFZf369WzcuJHs1DQyI5FkcvlkHDly5KRx6rQpU7ikRNrmMt1g3MjE5v4///lP0kIhmvr8+BXllBX+vx1/48aN7Nq1q8yxtWvXoqoqsVis3J0J8Xic3n37o1kB3KrOknJqSV959UIU04fsVhElO2MvGl+uBPL333/PsBEXUr9xc5YtO7UZ6QMPPIjuC5FStx2G13/S+y0vxcXFPPfcczz//PPJAp2ff/6ZDz74oELH+T+EXbt2EYmloRhecvJqnLGYroL/DioS1BVU8Bs2bNhAfV8iAbkhECIgJpKIYVHkSsPkHq8PS1FOqfUVj8cZNXQoTlnGr+vJhNfJePfdd+ndsycTJkwoY2z40EMPUd8wud6waOl0kS1KFDkcOGw2wqZ5yh35I0eOcOjQIV566SVeeuklKkUiyKJI327dSgVun376KX5F4W7LxxC3h0qShGSzYdjt1KpalQ0bNrBv3z4UUWStP8gi08InSckWxt9Su2pVLjNMMiSJqCiRLSekPF544QUgkQBM9/vp4/aQK9v5PBLjTstLpiThdbkosDt4zh+kqW5gKAp2SWLYgAG8+eabtCgqolGdOphOJ88HQtxqetE9BjVG30kgM69MOyAktAF1Waa+00WaonDV/PnJY9u2bWPw4MHUr1+/RFZDYKqmkypJZITDyQSrw2ajsHZtNm3axMypUzE9HnRJIt/uIEuWGatquEpMH6epOn5BwG6z8WowzGp/AI8s07Ko6JTGJU899RQeQWSwR6Gx00W3tm0x3B4e8wWoKsvcYFq8FYoQURRS/X4e8fkZqahEJYkUhwNLFJmnG0Qlidp5eUy66CLqNWiMP5CerPi5wKMwWzfor+oIokhDu4MOLheKzYbsUkhteQFuI8D999/PNddcg+FwcrVh0vo3rYJZ2dVIaXweqS2GEIrE2LNnDxs3buTdd99l1Jhx9Bs4iA8++ICjR49ilyQaORzUdji5ybTIsDvIzavOK6+8AsArr7xChqbxYiDEBMOkW5s2vPPOO8mugt+yb98+KleujCAI6KaX665fnPx8V69VB5tNQIlWoWq/y0mtlEWtOvUwgjEU3WL+FQuIpKRjV0ysSjWompN3WrPDgvqNSGnUm0pdJqGZXg4ePEinrt1Jbzc68eBR0IHrr7++1DU//vgjL7zwQjIB+frrr+NPrULhnKepMfpOPJpJtGEvCuc8jTe3Cbpp4VI0JIcHJVqV1NbDcXnUMlVgR44cKROoT5w8BbvDiaLpZap9f/zxRz766KNkEvmZZ57hiiuuOCvd5Pfeew9frBJFc9cnjCxlBznnX03hnHW4fCmnNd85HVVza5DRcRy5FyxG0Uy2bNmCPxQhlt8SIxDltn+pRoumpicq4PvOQ9GM5IPa3r17qZydiyhKNGvZplzGlU888QSGP0Jam5EYgSgrV64sdfz6668npX43iuauJ7P7VBwenVjjfjitCLHmgxNmlU7XKTc1TsVLL72EGUql1kX3kNp8EG06dD6r6yv4z6IiQV0Rf1fw7+Ho0aOkhUKM1Q16GgatShKf5eGXX37h888/P6lB+B9lx44drFu37qTFGaeiuLiYHh06EHC7Mdxulj/00FnP+89//pOlS5fyxhtvsGvXLgb07Ml5nTvzwQcfsH37dmJ+PymaRrVKlfj666/PevwPPviAV199lePHjzNj+nQuLKn6HasbTJk48ZTXHT58mHrVq+OVZaqmpycrbnft2kWwRF7uzWAYzeU67fwdW7SgkWnRyLSompKCRxDo5HKT4nBw3dVXJ8+75+67CSgKeaZJ47p1T1pw89vkcnkozM3j75aPnZEYOYbBqlWrqFW1KnJJsVDXbj1JCQRJVRQst7uMTN7EMWMIeDzoTieKZmCFUsjIqpLU3169ejVTJk5k3bp1xONx/LrOfV4fK3wBDLe7XBXGv+Wpp54iRVWZqxtkaFqpKvGDBw/y5JNPsn379rMaExJFAc1ataV5q7a8++67vPvuu6SkpKAoykmfrf6V999/H8Mfod7MNVQfcQvBSNlOgZNh+YNoaTVIbTOSOlMexgilnlbj+leGDBtBpHZLqva9DM0bLGNU+VteffVV7rzzzj+UnK7gv4MRF44ipWn/RGdt7VZcd911f/WSKvgTqEhQV3DO2LlzJ4sWLeKJJ574rxHm/+KLL/BrGpfqBq01HUOWGWkYyDYb74UifBaJEfR4TlkZ9/rrr5Op62wPR7nD8lKvxBTxww8/ZMK4cVx91VVlAqnjx4/z0UcflaoYOXbsGFViMarJds7zeHCVyEnsicQYpRuMPYXW2Ndff01WLEYdrxdVlhmkqOyMxKhjmqUqCZ977jkKSlrDnvIHMUSJOtWqldoR/vDDDwnY7eyKxNgYCOERhKRh5G/RnU4sQUS22Xg/FOHzSAxDFEv9SAzo2ZPzPB4yJImt4SjzdYM82U6a18cETWdnJEZNu52Rw4fz888/c/z4cYKmySLT4hrDxPQoBA2DqGXhsNkIiBIe2c6MGTNOGpgdPnyY5cuXs3HjRn766SeOHj3Knj17UJxOXB6DcP2eCJKdVFGkuiyTW5JUfzsU4VrDoqbdTkAUcUoSIZebTaEwMzSdZg4HQzwKss2GW5J4xOtnVyRGVBSx22xcphkM8yg4JIlZl1xCUV4el0yceNKqjrfffpvhw4ZxzTXXcPDgQVyyzNZwlId9fjyCgOJ0Mn3KFHRJYoKiYrfZWOnz08XlRhVFMqNRhgwenBy7eu26hGq3o6pb5WrDxBAE2rs9KA4XNlHivVCEvZEYss2WNA/J6DCOrKwqWHYHlktlnmnxmNefNPPcu3cvg4YOo13HzliahlsQyHW58SkqL730Uqn76dmhA7U0Hbcko0sydkkmVL0pui/EsmUP8Pjjj1NgmKz0+blRN/B5/RiBKKrpY/6CK8u8PgVFDXHofmyCiFvRk07Z27dvR9EtsnpOJ5Lfht7n9ae4uJi3336bnTt30qlrD1KbDaRynzmo1qndu+PxOMuWLcPpVqg9YVnCadsIomgGksONt1pjao75O6o/hi8YoUZ+Xd577z2+/fZbstPTqev14lMU1q5dy9GjR6lWvSbhnALMUCr1GzYmWtiZwtlrCeTUx+50U33krWQPvBLJqeAOpDNq1KiTrutk/GpieToee+wxYqrKGN3Aryi88cYbpzz3o48+omefvhQU1mfatGkEIzGi9XvgzylCcnpIaTGEGqPvRHbrJzVJKg/eQCjhYD57LWYwxnvvvcfWrVuZOHEijz32WKlz4/E4doeDOlMfod6sJ/HoVpnk/dmYH02YOInUlhdQNHc9aa1HMHbcxaWOb9y4Ed0XolKXSaiRLOwek6p951G13+UosRyqDbkOj6qdteHS6tWrCVWuTeGcp6ly3hzyC8ufZKngP4+KBHVF/F1Bgn379tG5VSvqVK3K0vvv/9PH/+STT0jVEp1hH4ejuOz2cl134MABqqSmElFUKqeknLHb6d9FPB7n9ddf55Jp07j++uvLtbF6Nvz00098+umnyaT8d999x9zZs5k2efIZ5U8WXXMNYUUhxzBo36wZCxcupI1h8HYoQgfDYMFvijrKy8GDBzHdbh7zBbjBtMiMRk957g8//IBLlvk8EuPzSAynJNHITHjtrPQFqJudXer8Tz75hFdeeeVPM0B84YUX8CoqutNJv+7dmXTRRQw1DPZEYrRxuTEy80lrNwrd8pbyCgH48ssv0Z1OPgpH2RQK45RlPvzww1PqgB8/fhyHJPNeKML2cBTN6WTPnj08+eSTJ32e+i1vvfUW9913H3v37uXxxx/nogsvLJeESXk4ceIEvmCYSp0uJqPjOPyhCMXFxezfv59YNIrNZiPk9fLee++dcoxdu3ah6Ba1xt1NVs/pZFbJOe2chw8f5u9//zspaRm4fClU7j2Twtlr8WdUK9NlejIK6jcmu/8VFM1dT6xmkz+kfx6Px7l64TUUNWrGtOkzylV5/9/MsWPHePjhh3n44YfPyUbeX8m4iycQLepCvVlPEsptwM033/xXL6mCP4GKBHUF54R9+/YRNAzONy2q6jrz5sz5t2jG/Sv79+/n4lGjuHjUqHLpgEFiV3nMsOFcMW8eb7zxBldddRV9uncnQ9PIM026tmlzyoT7a6+9Rqau80k4yp0lCeqvvvqKgK4zSdNpaRgM7dcvef6PP/5IverVSdc0fKrGa6+9ljyWGQ6zMRBiXzSFGopCPbc7kaA2Tp2gvuOOO+hmJRLP1xkWte2JiuX6lsUjjzzCvn372Lt3Lz/++CPVKlWihc9HqqoybvRonn/++VJVIvF4nK5t2xKy21EEgfRgkC1btvDggw/yzDPPEI/HE9IGJdrNMUniMt3gTsuLSxCSwfPUqVPp2aMHHkHEabMh2mx4BAHd7ebhhx9GEQQkm43mTiduu53jx4/z3Xffodgd7IzE+DQSwyFJ/PTTT1zQvz8zdJM5ukG6JDNU1Qjoeim5iL1797Jq1Sp27drFjddfj8fhQHE4yEpJwelwk9l1MrUnLMMtybR1umjscHKjaaELAg9ZPm4wLHyCQGOHM6kf/Xk4yt2WjzRRwiMIjFFUqsl2FFHEkCQ0WcYrSWiCQIHdgUsQyLU7WOELUNft4YbFi8u8V8eOHWPv3r0cOXKEC/r3J6goGLJMwONhxpQpxONxHnroIbxOJw0dThSbDUsQmKsZjFU1NFlGMbzUzK/L4cOHufrqqxEkO7LdhS7J5DuciLIDl2rgcrgY7lGYoGoYgoDsUkltNRwzlIpdtmMF0qnSZzYeI4RPEBg/ZgxzZs/mnnvuobi4mJb169Pd5aa7K2Fkea1hkeoPlAref/nlFx555BGWLl3K3LlziZUYiVTuNZNW7Try7rvvYne68fhTEWUHot1JvRlPkD/xAZwud5nXp3JOHlX6zUfLqInNZmP8+PHJY0899RQtWrdn+MhRvPjii6xfvz75gNCgSXOyek5PGA5WrXPKgP7mG26gmq5T2+XB5Y1iZubj0PyoadXJ7DoZb25TRIcHVZTwGkFCBZ2pkpOX0If0JjQY77C8tGmYkKr44YcfeOyxx3jxxRf56quvyKuZjyCKFBQ1wKVo1J2+ktoTliKIEllVc35X1dPpuKBfv6Sh6jjd4PJTtNgeOXIEXyBESoshBOt0xKn7qVuvPo2aNMWl6OiRDGSXisOtMnHS5NPOGY/HmTvvcrKyc+l9Xv9SFceLb7gJ1fThjWbQun1HPvnkEyx/kGhOAZrpLVP9MnHyFMxgCr6ULDp17f6HNjXXrVuH5g2S0mIIui9cSm/xVx599FFSMiqjxaqS1XM6kktFj2ahmV7CsdSTXnMmfvrpJ+rUK8IbSUfRTZ5++unffQ8V/PVUJKgr4u8KErRv2pSxhskjPj8BRTlp59Mf4dixY1RJTeV83aCtYdCldetyXTdz+nSGllT/DtMNLp027U9dV3n56aef6NetG2HTpF/3Hnz77bdkxWIM0g3aGAbd27U7p/O3atCAHobBhbpBRiSSjIe+//77Un4TAGHT5MVAiN2RWMLE/c036dO5Mz5No0f79mdd4fsrjz32GNmpqdTNyWHz5s2nPK+4uJiMcIRLDZNLDZMUvx+fx8ONpkVXw+SC/v1/1/xnw08//ZSURZswdiwXGgZ7IzE6utzEmg+icM46FMNb5rnx8OHD6C4X6wNBHvL68Wv6GWOVy2bOJKQoRFWVkUOGkBWNUsvtJuJ2c/2/+LT8ymOPPYbmDZCS3xLLHywle/Jn8P333yM7nGR0nkD2gAXYHc5kDOt1uWjicJYkqX1lkrfxeJxnnnmG1atXc+11i9AMi5SMzNN27h0/fpw61arRzvJSR9fxGyaS3Ylb99KsRetTJk1XrFhB+87duHTGLO6482/o/jCxWs0JhKOnla47E8uXL8ebUpnsAQsIVK7FtdcmCqoOHDhAp649qFW36E/bDPgz2b9/Px06d6V6fkG5DUEB2rTvRDCrFsGsWrT7H+vs+/LLL6mZX4AgirRo3e5P3wys4K+hIkFdwTlh+fLlNDJN+nk8dHe5MQQRr9vN2OHD/23V1PF4nNxKlRhpGIwyDLLT03/33L9WQ2zYsKHMj/XGjRupXaUKdbKzeemllxgxaBBuux2fpvHyyy/z4osvUs+XSGi9GAiRGQ4nr33ggQdobnnZG4mxyLTo2Lx58ljfrl3pYphcphv4VJXCmjXx2O1kp6efMtm+atUq8gyD5wMh+uoGptOJ5nTSvlmzRDWuKOISBIpq1uTgwYPJhGJA16nn8xG2LHbs2EFxcTFXXHYZzesW4JYk/DYbss2GJkm09HqpoutMmziRrm3aYIgiLRxOBrs9aIKAJghJndialStT2+5gpKKiCgIjdYMlhoXpdrNjxw5++OEHHILA68EQrwbD2EUxGaic17UrNUyTPNNkUJ8+AIwZPpwMWcYQBB4q0YLu7PMnDfWWL1+Ox+Ggtq5jeTy4ZJk3g2E2BoLINhszdRPDn0q4fi8yJImYKJIuSczVDQqczoQ5Y4lW9s5wlD2RGA5BIOzxoEkSmihSq0Tf+gl/gKrRKKNGjGC4bvBiIESuLJNvt+O22RhfohM9XdNp26K0ecnOnTtJD4UIeDwENY08uwOvIOKw2aidU43i4mI6tGuHKUrookhYknCX6HfvKUnaCzYb9WavJVyjCbfddhtFeXksMkye8QdJEyUGexQMj4e+ffrQ3qNQU7bjEwR6u9zYRZHRY8bxyCOPEA1HSWt7YULOonE/REHAp6qc71GIOV307NqVFkVFDPYoVJPtbAiE6K6o+GLZVK1W/aSfw5dffhndH6Zy75kEcwqZNn0GkyZPIda4X0J/uWFvZMlO7tDrqdxrBqFoSpkxli9fjqKbWJE0TMuLzWZjzJgxpbTdr73qKmKqSl3LolGdOvzyyy+88MILeDQD1QpSo3bdUz5sdW3VijtLvnvNVY1QJEalzhMJ5LcnULsteSNuRpVk5ukGy7x+3LIDw/KzYcMGMnWdZwJBhhgmQ84776TjA8nP8uixF6EYXjyawcxZs89JtcYdt91Gnm6w0DBJUVVGjx7NddddV0aP7dNPP0X3hSmc8zR1L1mJKDsRRBHTG6DWRfdQOGcdVjg1WbF+Op544gm80UrkDb+JSO1WjL1ofKnjf/vb3xgydCgbNmxg3rx5RIp6JNzPWw3ngn8xSYzH4/zjH/9g48aNf4rRybp165gyddppdRmr5NYg94LFFM1dj5mex4iRF/7huX/55RfeeeedP/TwVMF/BhUJ6or4u4IEuenpPFGiBVzH8rJhw4Y/fY4vvviCeZddxnXXXVfuJOn8yy+nm26wIxKju2Ewb+7cP31d5WHh1VfTxjB4MximtWEwbepUMvSEbvAH4Siq03lO53fIMp+Eo+yLphBTNT766CM6tG6NUxTxyDKjhg2j93n96TdwENUqVWK+YbLSF8DyeE5Zdf7xxx8zZvhwLp06NWlceOLEid9Vyfz+++/z5ptvJnV8t2/fTr9u3ejXrRvbtm1j7dq1dG3Violjx56Vtm9xcTE7duz4Q5rl+/bto2paGprTSUg38KXnEs4ppKCoYXK9v+WBZcsIGgapgUC5PIkgIS+4detWJk2YQIYss7fEUyfF6z3p+a3bdyKr5/REtXBBuz/FCPO3HDx4EMPpopXLTVCSqVm9JkOHjUD1hrC7NUZoJp1dbmw2Gx07dixVfHDh6LF4Y5kEs2rQqGmLk75G/8r27dtJ1TT2RmJsDUdQnE4OHz7Mzp07T3n9m2++iWYFyOo+jWBOIZOmTOW1117j/vvv/8Px1WWXXUa0UR+K5q4nvd1oBg0dBkCLNu1IadSb7P7zUQ0vn3766R+a50x88803rFy58rSV6r+leeu2ifUNWIBqlK3w/1fi8TjXXX89omyn3qynqDfrqeRmxP8a5fkcVvDfQ0WCuoJzwiuvvIJLEJil6XRyuakkSWwPRwl6POzYsaPc4+zdu5ebb76ZNWvWnHVy+YcffsApy+wpcb9W7I5S7tBnQzwe54cffiizhl9++QWvqnKX5ePvlg+/pnHixAm+//77ZBLqm2++IWSajNF0mhgGIwcNSl6/Zs0a8kpa6y4yTPp161Zq/ZdOncrQfv146623iMfjHD58mOLiYi6fPZuCnBy6tm9PYV4eHZo148MPP+TAgQNcMmkSmeEw3du25csvv+Trr7/m6NGjeESRQR6FTaEw2bKde+65B4DxY8YwuaQCZZSmM2vGDG6/7TbydYP7vT4qyzK9XG6WWj7SJIm9kRgvBUNYLhfdDJOn/UEyJZlMSaa23U4/w+TGG2/k8OHDqILAs4Eg+6IpVJVkmtarR+P8/GR14hdffIEmy7gFAU9JJfUV8+dz6NAhTpw4wbp161i/fn3yh+fSadNo73Yz1KNQ3+HgasPE5/HwwQcfsHnzZgyHg3GKSkAUcdlsSDYb/dwe/GJCgqSlw0lnlwe33YlXEBjg9vCkP0hIFFEEgbssH59FYlSSZLq4XFys6WTFYlTPymK0YTJHN3HZBKaoGgUOJ+NGjuTyyy6js64TEkWmaToDPR4Umw2XzUY7pwtNEBg+fHipz83oC4YxocTkpoPLTVgUucm02BGJUdntZtasWSiCwLWGRZHDgSZJxPx+YpJEI6eT6g4HljdKvZlrCFaty9///nca5+ezyLT4OBwl5nDQoKCA1157jSkTJpAuy/R2uxmhqLgFgam/qUZeuXIldpeCr3oLRLuT8/r0IV830ASBqrJMZVmmTZMmGIqSqHyWHZihTGqM+Ttuj3rS78uJEyfo2bUbKaZFy+YtOHr0KNdcey3BnCJSmwzAdLipLEloDjeqZp5SjmL79u1Mnz6dTu3a4ZQkbDYbVbOykp+HFJ+P5wMh9kZiVDUMNm3axKZNm/CqKrVMk/RQiAMHDpQa8/jx4/QbOAiPy01lh5MZmo5fUbj99ttRDQtvNBPV9JGeWRXFbufNYJjPIzFMUeSS6TOIx+MsmDePKtEYnVu1TuoOnomdO3eesYvj9ddfp2HTFrRs056PP/64XOP+Sjwe5/Zbb2XweeeRn5tLG8Okp2FSq2rVUknXX375hcrZ1fDmNERLzcPtT6FuYQNq5BeQ1uoCsvvPR9HNchlC3XrrrcTqtEloOXedTJMWrZP6/CtWrED3R4g1HYhq+mjStBmeUBbVL7wNvVJtBp4/6Ayjn3sWXnMtZiiVWK3mRGJpFeYqFZSiIkFdEX9XkOD2W28loqgUeb3k5+T8x1SpHT58mJYNGiCJIi3q1//dMf4fZeqkSYwriaNH6waTJ0wgJRDgIt2gp2HStnHjczp/u6ZNaa+qnK+oRCyLyRdfjMtmo4HDwcWKiiQ7SWs5lNRmA4mlZdCgZi2qpaXx0ClkEr7//nvClsWUEk3w9s2a8fTTT2N6PDgkiWmTJpVJCH3yySe8+eabZTZ5L5s5k4iikqnr9O/R408rUvrll19o17QpEUUpZQ7/eyguLuabb77hl19+Yfny5dx3333n5DPepU0bNJuNmnY7QVEkYponPW/ylGmEchtStd/lGMEYzz///J+6jtWrV9O8pHBqhS9A7cqVcboVCi5dTd1pjyEIIobLxYgRI5AkiVq1aiXjV7vDSZ2pj1I4ey2qVT4Twh9++IGgYTDfMBllmNSvWTN57Msvv+Tdd98tU7hx1113kVK3DVX7XY5dtXB41KRk3xtvvMGVV17Jxo0bicfjbNiwgSeeeKLcmydbt25FM72k1GmFanqTnklpmVXIG3EzhXOeJpiZl/z/c8FXX31FJJZKNK8+muU/qcfTv5KWWYW84Tcl1lcp94zru/W227BilZE9JqmtR5DeZiShSEpFMreC/3gqEtQVnBNef/118kqqB14NhgmIIq8Fw5hud9JU40x8+eWXRLxe+loJmZCFCxac1Rri8TiN69alo2HS2TBpULv27wqMvv/+exrVqYNLlsmtVKlUtcH333+P225nezjKtnAUpyyXCWo+/PBD8ipVwnS56NG1a6lWpuLiYsaNGInhdlNUo0a5ZFAefPBBqusGq3wBGjic9HS7ucQw0SQJ0+WiW7t2ZX7ob1q8WnF2FAABAABJREFUGE0QuKJEAqCN08VNN90EwPhx42jidPJSMESBw8F5ffowfswYLi1xjZ6s6XR0uXg5EMJls3GLaTFSN0j3ellYMl4vt5tBHgXBZsPvcDBk8GC+/fZbdLudpg4n01Qdl81Gdnp6qdfv559/JmxZzNENUkWJjm43vQyDOtWqEY/H2bZtG+d16cJ5nTvz8ccfM23yZIYrKrsiMera7aiCQKVYwphj4cKFDC9Zs1cQWekLsDkUQRMEFhomOyMxsiQZRZapKssU2B0ssRIBWkOni4CuYwkCubKMXxDx2gRUSWLnzp3YSzZY9kZiWIJIG4cTXRDo3K4dX3/9NVXS0jAFkb2RGB+Ho0g2Gw5BIEdRcAkCPoeTgf37M3/uXOpVq0adatUYpCe0t5s4E2MtMi0+DUepomo0btyY9k4X+6IpLPX6MEWRDz74gFmzZtGnTx8WLVpETl4NBEFEsrtIC4VYsWIFKX4/os2GaQawIulMnTadvXv3IthsfBqJsS+aQsjtLqOhvnnzZm6++WbeeecdPvvss4QGdkmC+hGfH1kQcCsquRcspvrIWxBkO2Y4lQmnkIC4cfFi6hkG93p9VNN1HnroIb744guat2xFQJJ42OenndNFQFH48MMPT/lZ79qmDc1NE7cg8GogxCCPgs1mQ5JkDMtH9cwsphkmD3n9eD0e9uzZw/m9e3O5ntATbK4ojBw5stQD0913302gcm1qT3wAIy2P/Bo1k87w+/fv54033kh+hy+bOZNUVaOaptOssPCcBnVHjhxBN71kdptKetuRpFXK+l3jFBcXIwoCOyMx9kZiBD1KmcT4oUOHmDdvHq1bt2HqtEs4dOgQO3bsoFnLNlSqksPo0aPL9bfowIEDhCIxwlXrINpdOBUNRdN5++23GTpsBOntxyQqgJoOxPCH8NVoiTuQjl3z43IrZVqP/wqee+457r777nJvNFTw/w8VCeqK+LuC/+Odd95h7dq1v1sC4lzyR5KeP//8c6kYYf/+/cydM4frrruu3EnKTz/9lIjXSw2vl6jPx44dO9i5cycTxo5l9owZ5zxx/sADD+B1OGjtdJGlqmTGYqRJEndZPvJkGUF2UDhnHfVmPYUoyafUTP6V999/nyolutDvhiJYikJ6MMjtpkXE6UG0O6lctVpSFvC2m28m4FGorBt0atky+XrG43FcdjtbQhF2RmL43G7uuece6mRn07yoiI8++uh33e8PP/zA9OnTyVM1dkdi3GX5qF/95B19f5SjR48ypG9fsiIRxgwb9oc64Jbefz+mKHGRqrHWHyTgcvHOO++UOe+nn35i7EXjqd+4ObeXdKT+mXz44YcEFIU7LC+9DZMBPXqiaDo5A6+iynlz0U1vskp5/fr1aJpGJBJh8+bNZFbJIb3NCLJ6TEc1zHIbiG7ZsoXzOndm2IAByefAdevWJTolw6nULWxQyqPps88+Q7d8iLKDakOuo9qQ63ErGi+88AKq6SOlUR80b5COnbvgjVYimFmdhk2alztO37FjB/fddx9bt25N/t/1i27A8EcIZ9clO7f6Of1bt2zZMmI1m1A0dz1V+l5G/cbNz3jNDTfchO4PE65ah5y8Gmf8+9Rv4GAyOl1MjTF/wxPMoGpu9TN+53744QceeOABnnrqqf8a/7AK/veoSFBXcE74/vvvSQuFGGgY1FU1LKcTzeXi5htuKPcYq1atopU/IeOw6iTGGeVdx6JFi1i0aFGysu9sWbRoEZ0Mkz2RGCN0g4tHjy51fNTQoVTSddI1jYtGjixzfaPatZlnmGwMhAgrCh988MHvWsevXHnllQwrqdSYr5v0dXt4LRjGEAQ+i8SoZZqsW7cuef7+/fvxOBxkSRLeEkkL0+nk3nvvZfyYMQwbNowqdgdeUSQqijTIz+e1117Dpyj09vsxXS5cv6ly1gUBXZSYN28epstFDbsdSxDQS7Sl+6saHQ2Ddk2bsmHDBryKgmKzcY2ekFoZfcEFpe7n3XffpVPLVsgl8hV7IzE0h4Ovv/6a9HCYGYbJLMMkZBh0aN4ctyCQKkmkSRIBQSCg60BCaiWiqlxpmLhtAusDQbaGo+iCwJW6yY5IjFzZjuVwYDmd2G02FJuNapKMX9PwOZ28EAgxTzcwS6q5vU4nR44coV+37tQ3TZq6XGRJMrsjsYQutCzTvX176us6QVGivctNgdNJpUAgYZgZjZJvd7DQMNEFgbDTyUpfgJZ6oj1QtNlQRRGtpOJastnQJYmbbroJtyAkZDYkiYZFRcnX68SJExw9epTVq1dTXdfp6HITFEWqpqayefNmrHAahXOeptbF92F4/QC0adyYjrrBQD0hdXM6k4zDhw/jFASGeBQ6uVwYNht+TcPucJI/6UHqTH0Uye7goYceOmXwcuGQIcwr+YyOUTUqVc7G6fagagZdTYt90RTutLx0aNr0lOsoLi5GEkV2RGKkihKdXW4mKSqizYbNZkPLqIWi6rRt3ISaWVlUy6tBZtVqtG/Vmp6GSWtVx22F0ULp1K5bLxlsL1q0iEidNuRPepBA7XZ079UnOeenn37KxEmTufLKq5KB31tvvcXzzz9/zk1U9u7di6JbFM5eS93pK5Ek+XcHh0U1ajDYMBmvG6SHwuWuKrn9jjswgzFS6rbD8gfLtZl48OBBRo0ahUP3o6XVwB2sRFpmFe67737MSDrp7ceg+yMUFDUkkN+OKn1mI3sMdF+E999//3fd37JlD5Bbqw7tOnY+56ZY+/fv58UXXyzV4lrB/x9UJKgr4u8K/reZMWUKTllOVuAePXqUSpEIQ3SD1nr5taOLi4u54447GD16dLnksf5sLpk6laklBRpzdYOs9PSkzNxsTUczLELVighWrUPrdh1LXbt27Vo6NW/O2OHDk4n0n376icxolIGGQVPDoF/37qT4/XRSVGJF3Smc8zTh2q256qqrAEjx+Xk2EOTzSIxKemlz5bRgkJtMi4d9fgy3G8PtZpnXzzzDpGblKmd9r1988QW1srPJ1zTCksSWUIR5hknrBg3/wCt4ahbMn08bw+CFQIiGhsHtt9/+h8arGo3yiM/P3kiMAq/3L/OqWL16Ne0aN2bEoEHs2rWLp556ivSsqmRl5/Lyyy+XOnfr1q2kpaXh8Xi47bbbaNW2A5GUdByS9Lur19955x3cmoVd9VKpy0SCWTVKeX/ce+995OTVQpBk6kx9lLrTHsPucDJlylRiTQcm5Tlkp5s6Ux6mcPZadG/wD8tyvPHGG6xateqcy2C8+uqrGP4IOYMWEqnTNikzciY2bdrEE088wY8//njGcx999FF0X5hYoz6ohve0OuGQ8ALIq1mbSLUifCmVuWj8xHKtqYJT86sM0V/V3fPfSkWCuoJzxv79+1m4cCH33HPP79L13LZtG35FYZFp0ckwGXH++edglWdm0aJFdCmRY7jQMLh41KhSx+PxOG+++SabNm06aUKpWloaK3wBdkdiVDNNXnnllTPOeeOiRVQKhWhaUFCm2vXTTz8laBi09ftRJIlsVSMk22ntdLEtHCXHMHjuueeS5+/YsQPd4aChw8n7oQjjVZXa1aqRoWrM1g3Cbg8eUeR8j8L1poXudPLPf/6TDz/8kLvvvpsXXniBKikpNHY4eTcUpoHDSUAQGTdyJEMGDqS/x8PWcJTRiorPntBn/jQcRRZFNm7ciO50EpMkash2xukGIwaVbe3//vvvyUpJoZuq0lfVqFapEmvWrEG22fisxOnbbrOx0DCp5XThstkIlehd5+f8n3P06tWrqZuXR7WS6mqXLVEJbAoCcomGs8dmY5KmsyUUIUOSktXOGU4XuyMxHvcFsASBCapGvsvFtddeyy+//MKyZcuoW7cuakl7XkSUMOVEcvvNYJgPwlHCbjczZ85MJgRTdJ2/lZhW9nB7qFLy+iwwTLwOBw6bQFSW0QSBlV4fj3j9pEkSDz/8MJdfdhnVsrI4v39/Hli2jIa1atGmSRO8iopDkujUpg0pTifdXW42BkJUcziTMhWVe80ktekA8uvVBxI74gsXLmTUyJGsWLEimWx9++23adqsOd2690hWQRw4cABNFGnldHGBR8FlE0gNhbh8/hXYnW4ku4vKikalSOSUP7gvvPACPo+HDqaJ4nDgz6xB4ey1pLQYjOZw0NbvJ6SorFix4rTfg3p51emvaeiCQF+3h0zZjlOSSWk+GJvNhiCK/PjjjzRt0ZrUpgPIHboIxbBo1bgxgiBSMGM19WauQZAdBMMxDh06xFdffUU4moJbFKnlcOBXVbZt28Z3332HLxjGX6MFTiNAMJr2hwPdEydOsHXr1nLp5W3btg1vMIIazsSMVGLIBQlZmH379tG+aVNy09O57ZZbOHLkCL3P608wmkqdgnosWLCgzPvw5ZdfMnHcOMYMG87OnTvLvd56DZqQ3X9+ouq5dguWLVt2ynMPHjyYNIRcvHgxktND4ey1FFz6OIIgcuLECe67736GDhvBihUr+Prrr6larToO1cKMVaZmfsHvchPftm0bqukj5/yrSGnUhxZtzp351KuvvopmegllVieaknbWuoe//PILV129kPOHXJCs0q/gv4eKBHVF/F3B/y7btm0jpChsDUd50OuncizGI488QkiW2RdNYWs4guZylWusSyZOJN8wuEA3CFvWv70j54orrsCw2xmt6YQVhRtvvBHL7aa3buDzeHj66adZsmQJ9957b6nq6U8++QS/onCL6aWXYTKgZ8/ksS+++IIFCxZw6623cuzYMVatWoXD4SRQux2Fs9cSqtGU665LmMvlZ2ezwDB5yh/E6/GUMvXbtGkTdXNyqJaWxqBBg7CcTj4NR/lHMIylKGd1n7fdfDOK3U5IlNgTjjLYo2C32citVOl3V2OfiYsuvJBpJcn/C3WD2bNm/aHxHli2DL9HoYZpkuL1Upiby1Xz55+zatV4PM7y5cuZNXMmb7/9dqljd9x6K3aHG5sgoJu+076GX3zxBfXq1UMQBKZMmUJMUfk4HGWp10e19PSzXlflnDwqdZ5A9RG3JEyq/eHk8/HmzZvRvEGy+1+BFquC3a2iGl4uuXQmjz/+OGYohUpdJuKNZREMx0hrPYzKvWagGdZ/VSLwtttvp3rtAvoOOP93rfuHH35Imn2eimeffZYFCxbw5ptvnnG89957L1nkVHvCUnTz5BrpJ+Po0aP/EV2R/0kcO3aMRk1boHmDaIbFxo0b/+ol/ddQkaCu4D+GLVu2MHbECK5asCAZQD3zzDP06tCBqePHl2u38Fxw+PBhGtSujWJ3kJORUW6Jkl956MEHsdweMjSddk2bnbESc8uWLURUlWcCQaYYJu2aNClzzv79+1mxYgUffvghTz31FEuXLiUtGEQUBHp27pwMdE6cOEE8Huf8Pn3QShK1HoeDPl27Jitcp2o6qsPBK8Ew+6Ip5FlWcpf1+PHjZMVijFA1+ro95Nvt1LHbkWw2/nbnnTz44INkaRoLDZMMVSVsWYwyDHobBs3qFdK+SROmqBqX6wZ5sozPMMpokH/33XfkZGRQ17RQRBG3KBG2LLxuN3XtDoocDmrZ7aRKEm8EQiwuqUZ22wRaO510btmy1Hgff/wxAV2nqc+H5nIRcbpIEUUe9fkZ6FFIFSVuMi32RGLUstu5VNPZGoqgSxKpHg9uWyKJPUpR8QoifXr3To69efNmdKeTqrKMbLPRvEkTurZpS3fD5NISM8vfBuYXjR1LWJIYqii4RRHV7qCV5UV3OMi3O/ggHKWzy41iE6gh20mTJMKiSK9OnZJjfPjhhwQVhaVeHwM9CvXsDraFo2RoGimWl/l6og2zr26waNEinnvuOeo3bkbnbj1LyTQsmDePmKqSZ5q0a9qUb775BlW2U+T2kOVwkh6JJc/1yDLvhiLsi6aQJkmoDgetGzdGFQQK7Q7utnw08PlYv379ST/DJ06coHn9+vidTlSHAz2cTr1ZT5LeZgQt27bn0UcfLZcpyD//+U86tWtHoUdhXzSFJ/1BYqaJW9WRHU4EQaBRo0akZ1Uld+iipC7bs88+iz8UoVLnCWR2m4KsmISz6yQ7C8aMGJGsNhqr68yYPp1NmzbhS62M7NbJ6jmdlBZDTmkCWR5++eUXmjRvhRmMoegmq1atOu35mVVySGs1jHBRT9weNRmsdm7VinGGyRp/gIiiMGr0GIK5DfGEMvFWa0KgejNq1alX7oebEydOcMMNNzBo0KAywdKoMeMI5TWics9L0byBMg8zv7Jz5068gRDhrBoYXj9vvPEGDrdCpc4TSGkx5JTyJPF4nKeffpqHH374tK2Te/bsIbdGbWS7g/P6Dyy1wblhwwaCmXkUznma3GE3kFH57DtrykvXnr3J6HhxwkC0ThtuueWWs7p+4uQpBKvUIb3daFTDOmtd8Qr+WioS1BXxdwX/u3z00UdEFIWPwomK1sxIhMqxGD5RZJyi0t7lpmWDBuUaq3pGBuv8Cb+VJn5/qS7Gk7F79262b99e7t/t5557jiVLlpTxhtiyZQttGjfGstsZ6PZgORzMmTMHSMSOd95550klJH7lqaeeoonPnzT+rlW58mnXkfhtroUoStRv1DRZZbp161YKq1cnMxzm3hJ/m98Sj8dp3agRTU2Luk4XAbudVE1j3lkke4uLi/E4HKzzBzEFkRtNi7G6QaP8/NNe98UXX5BqebHbbKRYFtu3by9zzqZNmyjMy6NW5cpl4tr3338fv6ZT+Bsj+VPxww8/sG3btuTm+5EjR1i7di3PP/88y5Yt4/XXX+fIkSNs2bKFoYMG0UI3eNTnp5qun7Fg4/dy46JF5Og64zUdn6Ikk9AnTpzAIctY/lTqzXiCtDYjaN667WnHOnLkCL169cJms6HIMu+HItzv9ZGbkVGutcTjcaZOm47lD2J3KdQYfWfCuE8xGTHywuR5jz76KNG8hhTNXU/2gAVUq1Gbjz76iI8//pgjR45w//1L6dV3ALffcQfbt2+nZdv2FDZsUu4E4I8//viHjDX/E1izZg0eVcOlaJw/5II/ZYPjm2++QTMsMrtNJaXxedQtKt/fv+effx5VN3G6FfoOOL9CGqSENWvWEMysTuHstVTuNYN6Dc6tF8Gfye7du2nYtDmx9EwWL77x3z5/RYK6gv8I9u3bh1/TuFQ3aGGYXDh48Dmb68svv+SDDz44q6rueDzOd99997v/6O7bt4933323XHM+88wz1LEs9kZiPOLzk1+ldAtccXExf/vb35h08cXJRPL3339Pdno6Tb0+IqrKnbffzgX9+yOJIlmxGO2aNmWQntAEDngUbrrpJtJUjemaTkRR6NWtG3mGQSfLS05GRlLe4MCBA/jcbvaWVDELJZXLHpstqU913733ckG/fjywbBm7d+9m8vjxzLr0Uvbt20dhfj5GiVSFIggsXLiwzP0+8sgjtPAmtKDvtnw0cDiYpRu4BYG1/gDXGSZumw2HzYYlJMwML/AovBwM4RIEnnvuOT755BM2b96c1B777LPPeOCBB7jhhhtwCgINHA72RVO4y/JRy27HXSJV4rTZmK8nTCotl4t6dergsNkYUZIQnacbZEWjpda78OqriblcTNB0DIeDXr16ccGgQegOBwGXi4BhlKq8veeee2jfvj0+t5t+uoHqdNK9SxeGlswxQlFxSxKyzcb2cJRPw1HcdntSUmDt2rU09PrYE4kx0O3BKwg0tjsIu90sWbIEr6JQ1+sjNZiQZPj22285ceIEd9x+O6MvuIANGzYQj8fxOBwM8iis9QeIut3ccsst+EpML98NRbALQnLN9WvVoq3LxRhFRRUEcjOzUESRFk4nN5kWXlFEdzopyMujWUEBb731VqnX6MUXXyTXNPksEmOZ109I1ZAkGYfLQ0YoxGOPPXbG78Gv7Nq1C5+icKVh0sEwk/p1X331FY899hh2u53U1FQ8moE3lkn1WvkcPXqULVu24A+n4DRDRJsNRDW9fPjhhyxfvpyBAwbQVDdYHwhS3zC44447OHz4MJYvgKyY1Lr4XnyBdNyCQI3cPNp17MIjjzzC+vXry71R9vzzz+NPz6Zw9lqyB15Jdl7CFKa4uJj77ruPGTNmlkrS/6vxzK+dE3Wys5PtoIWWl/YdOhFr0h/R7qRwztMUznkau9N1SgmKb7/9lovGT6Rv//PZvHkznbp2xxPMwMisi+xSkqYzkGjrnTBpMq3adTztezRr1myiDXpSNHc9qc0HMWrMON566y1atGlPhy7dzugsfibO6zeQ1Cb9qDt9JYHM6jz88MPJY0eOHCEnrwbhKrXRvUFuufXWPzTX6Rgz7mIi+W2oMeZv+NKq8uijj57V9fn1GpBz/tUUzV1PSu3mPPTQQ+dopRWcCyoS1BXx9/8CL774Ii2Liujaps1ZddT8/8Dkiy7CY7djuN2sXbsWv66z3OdjmKJg2O1s3ry5XOMMHziQtobJ3JJChdN5ONxw3XVYbjdhRWHU0KFnHPuG66+nkqbRw+sjJRDg66+/BhJdTH5dZ65u0NvtoZXTxTzdYOyIEaWuX7NmDTUyM6lfo0aZZPWhQ4dID4Xp5vWSpetcc+WV5brfs+1+OnToEKrDwe5IjM8iMeyiWEZG4kzE43G8qspqf4BbTAtDFOndqRP79u3jtptvJmxZVM/MLCUvAtCqRQsaOpw87POjCgIOQaBft+6ldLJjfj83mhb3e31YHqVMnPfll1/ywgsvnLZC9L333iNomKRpGjWrVOHAgQPk1qhFMKsmslsjV1XxOZ24ZRmP3U7t7GyuNky2hqPUd7no37//7+o2PhPtmzThrhK/nb4+H3/729+ARCzqstvxhipROHstlTqNp3HzVmccr7i4mEsuuSTRxSgIWIpSbhPH9evX441VotZF92Bm1cXuUjBDqXTs3K2UdvRXX31FMBwlklsf3Rdk8Q03kpqRiRVKxR+K/KHuxoceWo7Lo+JweZh6yfTfPc6p+Oabb5h+6QymTrvkrLvuzobUSpXJGbSQghmrMQJRtmzZQjweZ8+ePX+okvmll16iWau29OzTr9wFeTnVa1Gl72XUm/EEViSdV1999ZTnPv3000yZOo21a9f+7jX+t/D8889jRTOoM+Vh0tuMoEXrc9fx+WfTsm17UpsOoPrIW9B9oVMWLJ0rKhLUFfxH8PTTT9OkRG96fSBI3u9oFyoPa9aswfJ4SNM0WjdqVK4gKx6PM/miiwgZJi2KispUMPzZHD16lAa1a5Nrmvg8HpaXJDUOHjxI28aN0Z1OInYHU1UtuRu+Zs0aikpMKR/zBciOxahumHwSjnKZYRLyeFjtDyQMAb0+1q1bxxNPPMGUiRNZv3498Xicxx9/nCVLlnDo0KHkWk6cOEFeVhY9PB5aOl3ERJF90RQWmxaFpzEk2bNnD2mhEH6HgxkllaqXaDqTJ0woc+4rr7xCmqbxlD/III9CV5ebsZpORJJQS3SifTaB0R6FvZEY3d1uhnsSrWVel4vL5swh4PFQSdfp3r594gdBUVBFEUNMjBEQRWrIdjyCgGCzEbashGmlquEWBOyShOlwMNijMNijoAoC1+omWbKMJAhUy8zE7/Fw0ZgxDOjRg0UlOsrDFZV0ScIjSaiCQHeXG00QGNivH/F4nO+//57i4mKGDRjAlSWGkuN0g/P69MEjCIRFEUMQ0F0u/LrO7ZaXOy0vXk3j+PHjyTGy09Op6vFQRZa53+ujiizjEQRGDR3K66+/zpQpU1i6dCnR1HTsTjeGbpDjcnGZbmA6HORmZZEly4xXNQxBwGGzsWrVKpyCwALdYIyqETZMIBF8Gm43/dweerrcOCWJXbt2YckyD3oT39GmTiduu50bTYvrDZOAaZYKLt966y2iHg9vhSJcaZgU5OYSM00uVTXusny4RbGMcd/pePnllxnYqxczL7mkTOXt+vXrcblcSIJAisdDdnp68gHu8OHDXDhmLK3bd+Lpp5+mfbNmNDAt6pkm2amp5KWnM3706GRXw5QJE5AdbjSnh0mqzivBMEG7AzOrHqooUs/ykpeVVS494s2bN6P7w9S66B7S246kfqOE3vbceZfjS8sh1rgfmulNJgwuHDMWbyyTYGZ1mjRvmXw9ly1dSkBRqGN5yc/J4c0330S3fNg9GsG6nYgWdiEQjlG3qBFjLxpfxvyoTftOROq0Ja3tKHTLh2R3JBLhc57Grvlo37FLud+HX7n11lsJVMmn5tglhHIbMv+KszOwPROduvUgo/2YhM5lbn3u+ZeKrB9//JEnn3yS6667jo5dezBz9pxy62yfDd999x0du3QnkprBxMlTznqDcv4VC/ClViHasBe65SvVXVHBfz4VCeqK+Pu/nW+//RavqnKL6WWqYVLnN5JoFSQ4fPhw8vfj5htuwOfxkKpp9Ovevdx/83/66SfGjx1LjcpVGNy//2mN41Snk9eDYT4JR/G63Wc0JC7IyWGFLxG/t/T5efzxx4FEjJFrJWLRN4NhdEEgRVWT3Vrbtm2jdcOGuEWRh7x+rjUsKsdSyoz/5ZdfsmTJEi6dPp1WRUWMvuCCP+S5UFxcXOb3+MSJE6SFQswwTKYaJlmx2O8q+HniiSfwaRqay8WSkkTrzp078Xk8PB8IcZ1hUetfinqK6talt9tDY4eT602LHZEY1U0zqf1cXFyMXZLYGo6yIxLDdLl+13PegJ49masn5CA7mxYTJkwgWCmXwjlPkzf8JlLcKoYg8EwgyPuhCLrDgely4ZUk2rpc5Ot6csPi7iVLCFsWVVJSeO2118rMdfz4cS7o3x/F6STd7+eK+fNPmdxeMG8edQyDy3SDgKKU2qR4YNky7E43ouxA0YyzSkItWbIEWZapXr16uWObhx56iHC1QgrnPE1Wj+kUFDVky5YtpZ4fDh06RE5eDVTTh+kLsGrVKhYsWECkoCMZHS/C7U+jZn7d3x3zmV4/1UfcQt1pj+HRTHbv3v27xjkV1WvVIVK3A9HCLmRVzTln5upZ2blU6TObOlMeRvMG2bp1K0MuGI6iW7gVjfvuu/+013/xxRdl3rdXX30VfyiC3eFk3vwryr2WGrXrktVjOnUvWYkZjJ1S63rt2rVo3iApLYag+8KlNMf/F4nH44y9aDxOt4fK2bkn7d74TyW3Zj4551+V6EzOqnHGrqA/m4oEdQV/Gfv37+fhhx9OarQGDYNRukGhYTBxzJhzMmfdnByWen3sjsSoaZrlMnZ44oknyDUM3giGGWGYDOnb95ys7bccO3aMV199lccff5yXXnqJ4uJixo8ezQDDZFMoTB27gxtNi94+P3fffTfzL78cXRB50JuQsaidnU2BafF5JMb1pkW1SpVI1TRamAmzwV8D3NOxd+9eFixYQP/+/Ul1OgmLImmiyOO+AO1dLpoUFfHJJ58wbMAAclJTGT9qVDJAmjVjBkM1ncWmRWVZ5nbLS7amsWzZMuLxeDK59MADD/D666+z6JpryElNJcPvTxjgiWJJxbRAQBRx2Wy0cDrZEYnR1OlEKtGTDqoqAV1nYyDEZ5EYKapKbqVK9HS5sQSRT8NRXg6GUEvMCK/SDT4KR7FkmUtLEudTNZ2gbuCxCXwQirA3EsNhs6HbbNR0ODHtduraHczUDDyCwJBBg8hRVebrJkFR5FGvH0sQkon4CapG4wYNaNukCS5Zxq+qeFWVKnY7iw0TS5JQZBmnIDBSUZimG9StVo3XXnuNwrw8CqpVY+3atTQtqIcsinRo1pxly5bhEiUu+U2y/wKPgkuSUOx2cl1udEnCm9uUwtlrMd0ad5ZoX/dxe/AJAg+UJJfbOl24JAnL46GyoqDb7RRUr55sWzx+/DhOWebtUISt4Siqw8G3337L9KlTidjt9FAU/JqGS5ZZ6w8SFkVkm43u7dsnE70//PADmj2xIRARJdJCIZyCwKZQmD2RGH5RZPny5UDC1dxbIg/z6w/gt99+y88//8x77713xoc3gA6tWuG02YhKEm01nRtOYsZ68OBBNIeDzyMxdkZi2CWplGP4li1biKoqzwdCpEgS93h97I3EqO7R8BnBZHK+kdfL6tWrz7gmSCQoDa+fnOq12LZtGwB1Chv+pqq2BQ8++CCQCGSee+45nnjiiTKB99tvv819992XfGj86quvWLVqFaPHjKNb954YgRjZAxYQqlafS2eUbpn1BkLUuvg+iuauJ5CeTTQljXD9HqS3H4vocDF33uXlupff8ssvvzB0+EjCKemc12/gGZ3Ef8uKFSvwBkL4g+FS1du/5Z133sHyB9G8QWrVrXfSqvU333wTzRsgs9tUgtn1mDL1krO+j3NNPB7noYceYt68eXz44Yd/9XIqOEsqEtQV8fd/O9u2bSNF1dgTibElFEF3u//qJf3Hs2vXLt5///2zSqAePXqU1GCQi3WDvoZJs3qFpzw35vdzj9fHEsuLS5ZLdQjF43HuvvtuJl50UbLCeGi/fvQwTG6zvAQUJflbcuTIESqnpNDHtKijatTNy+PJJ59MjpWXmck4TcMniuyKxHgrFEF1Ok+6prfffpuwojJF1anicFBUu3apAp7XX3+dGrXrklsz/7R+Ci+++CJ+TcchSUyfNKnUsW3bttGve3cG9Ox5WpmMMxGPx0u9N1u2bCFD0/ksEmOdP0haIFDq/Ndeew1FFDEFgWsNi08jMfJMs5SUx7QJE0jVNCrrOgN69jzle3/s2DEunzOHft26cfPNN7Nw4UKeeeYZAEYNHcoww2BrOEKRaXLNNdegGl5yzr+aSINeZHs0VEHgCX+AzaEIhsvF3XffTaaS6KZ8KxTBp2n885//xHC5eDYQ5E7LS2YkUmYdS5cupbqq4RVFLtMNarvdXDZz5knXXFxczC0338zoCy44aaXziRMn+OKLL35Xwve5557DMAxCoRCbNm064/k//PAD1arXxBfLRDWsk65n0aJFhGu1pHDO06Q0G8gFw0dy0003YaRk47QiVO07D6tSLeZeNi95zS+//FLuONQXCFNtyPXkT3oQj2qctWzn6Th69CiiJFM4Zx2Fc57G5VHPmS7zq6++itcfRLY7uHTmbLZt24bmDVJw6Wqqj7wVXyB0ymtvuvlW3KqOYngZNWZc8v8zq1ajSp/Z5E96ENX0lTuh+o9//AOvP4gk2xl70fhTfn8mTJxEassLEt2XrYcz7uLxZ3fTFfzbWL58OYph4U+rSs38umf1nPdnUJGgruAv4bPPPiNkmnTw+wkoCuvWreOTTz5h9qxZ/P3vfz8nbU4ALevXZ45h8nowTKqqlcs04N5776Wt5WVvJMZi0yqjefxHOHjwIEPOO4/mBQVl2senTZhAuqaRYxj07tyZ83v35rKSKtzObjctnU68Hg833ngjTRs0oK/LQ127g2qyHcXtRpVlVFkmYBi8+eab3HPPPahOJ0M1nVRV5aGSxNjJ+P7770kLhRisGxQqCXmOurKMy2bDJ4qYDgeWqqLZ7TRxuXk2EKSoxN36iy++IKgmpCFaOZxkSxJhScKnqlw8dixV0tPx2e10dnvwCAKpqsqUiy4CEgG3U5KYoGo0cDho4XSyNxJjYYnutCQIeGwCyy0vRXYHhigS9fm41rB40h/EcrvRNANPMAOXKPJsIMjfLR+63U6K18sNhsWH4SiqIJAjy9xt+ciUZTq4XLRyOMmSJDq73NSxOxisqDSoV0jQ5eKxkuqVfLsDT8nrqgoCLRwOGjgcOG028mQ7y7x+qtgdDB48mGYlGwSTVI0asowhCERFkbAosiMS4x6vD0OS0O12UmOpXDL9Ul555RWWLVvGRWPG0EvXGaOopNvt+AyD2bqOIgh0dLkwBIErNB2PINDH7WGARyFNkvB6oxTOXovHl0Kqw8UEVUMRBHSbjRp2OzM1A7fNhuVwINlspEsSLXWd2267rdT7v3DBgkRlh9vN6GHDGNznPIb268f999/P9ddfzw033EDzhg3xSzKX6wa7IjHqmlaycmf37t0EPB4+j8TYGo7gkGWqpKQQkSRq2O1oksS+ffs4fPgwmtPJs4Egj/kCWKrKgJ498ch2nC4FzRdG0U3uuefek35O9+/fz4033kintm3poKqYgoBkE5h1El3D48ePE/X5mGeYzDJMMiKRUkHUCy+8QLqiMFnV6Of24BZFYk4nmtOFqZoMVRKtpVFVLSNpcjZMveRSAlm1SG09HNWwkonrAwcO0LJ+faJeLzOnTuWnn37io48+4uWXX0a3fGi+IDXzC8o4iy9evJhYYWeK5q4ns+tkunTvVer4sBEXEsisTrRuO2JpGXzyySfUq98QfySVYSNGcPToUS65dCYNmrRg0eIbz6l23M8//4zbo5I37EZyhy7Co2in1OQ/cuQIu3btOuVvwZIlS0ip24aiueup0vcyGjdvfc7WXcH/n1QkqCvi7/92Tpw4QZOCAhpYFtmGwcSxY//qJf1PsmPHDmKqxr5oCtvDUZyyfMpzX3rpJdKCQdyCwBBdp5KmcUdJDLbo2muprhtcqun4FYUtW7bw/fffM27ESDo2a1Zmc/xXk+L77ruvzG+l4nTyTjBMB5eLmCQR8XhOmcRcvnw5DQ0TnyiywDApcDqTCebi4mJMr5/KPS+lSp/ZaIZ1yu7TvEqVmK8bpJfI1l0wcOA516MtLi6mZ8eOpGoaltvNPXffXeac7LR0LlRU/CUFFd3aty9V2RqPx9m8eTOvvfbaaStep0+eTFPD5DrDSnRNqiqpqsoDy5bxz3/+k0b5+ShOJ4P69OH48eMsW/YA1WrUJiOrKqYoEpVl7DYbTlnmmiuv5NChQ/g1nfm6yWDDpFWDBuzYsYOQovBpJMZSrw/V5Sqjl3zrrbdS2+2hp9vNvmgK93t9tCqq/6e9pmfDihUrUD0eZFnm3nvvPeP5P//8M2+99dYp5S9uvfVWQjlF1Ju5hlhRF8aOu5ijR49SLbc6gfz2FM1dT6Uuk+jWsw8Aq1evxq1o2B1OZsyac8b5n3zySRTNwO5wsODKq8/qXstDfkER4dqtiNRpR3ZujXNWQQ2Jz+2v4+/evRtFN6l18X1U6XsZsbRKp7zO7VGpddE9FExfhUf7vyR9NDWD3KHXl8iGRHj33XfPai1n6kpfvXo1uj9CWpuRGIEYK1euLPf4Ffz72blzJy+//HKZztx/BxUJ6gr+Em688UYGlMgkLDItenfs+LvG+f7779m5c2e5fwC2bdtG7apV8aoql8858w/ZG2+8QYuiIoIeDxmahk9Vz1o37XSc16ULAw2Te7y+UpUR8XgcuyiyNRxhVySG4XCwfv16ArpOdkkVdKOGDalXowYFpkVNRcUn25mh6WglmstBUcRwudi6dSurVq1i8ODBDCsxRlxkWvTv3v2U6/rHP/5BjZIK3DeCYQxBYF80hTmaTqOCAto1bcpCw2SIR2G0ojJN02nsdKE4ndhFkQLZzlzNIEOSCAoC20IRKtntpEgS7V0uxikqEVGivdPFAt1EFkXi8TjHjx/Hq2lcqKiERZE82c7boQgXKiqpTidPPvkkTQoKCEkSMzWdB71+NIeDqN9PWiDATTfcgCjbyZ/0IJkdL0a2CThlGcPpJENR0WUZ0WajncPJTE0nJEm4bTbaOp3ogoAuy+iiyGhVw+v2sHz5cjq2bUtV2c44RUUXBG4wLXZHYlS323HabBQ5HLwSCFFVkvGKIhmxGB6HgyKni92RGJNVjagkozo9SJIdvyjyYTjKzaY3MafdSbRxP7zZ9bF7NGK1mqG6PdR1OKgqyYRFEU0Q6OByc6dp4SjRANdlGbsosjcSY28khtNmwyMkzvXIDpzeGLLDhSaK3Gd5ucIwSZdlGjVqRDWHgx2RGDM0nZBsL1XB8yv79u1j165dpIfCTDNMJhgmlVNTqZ2dTUuvl2qGQXogwBWGya5IjDqGkUxQx+NxOrVsSU3TJEvXmThmDF9++SUdW7cmv1o1alStSsg0uWjUKDSnkw/CUTaFwrhkmWxd5zbLwuVSqT3xQfJG3Ew4lsbevXuZNnkyc2fP5ttvv+XQoUOkBAL0NS2yNY2I14soOxBECVEU2bBhQ5l72rp1K93atqVXhw7JxPCvrFq1CrtbI9KwD5LTw5QpU3jrrbd4+OGHuemmm+jcsiU1MjO5/Qyax8XFxaxZs4YHH3zwpEaAx48fZ9HiGxg5anSp1s3+PXowyjB5ORgiU9UIhKNY4VQcbgXR4UaQ7Hi80aTcxbPPPsvUaZewZMkSDK+flNot0Cw/Tz31VKn5Tpw4wf3338/ixYtP+kBw5dULCVSuTdV+l2NFK50zox5IVM/YnS7qTH2UOlMexu5wlqpiPxt27dqFbvmIFXbCDKZwx513/smrreD/dyoS1BXx9/8CR48eZeXKlTz77LMV5lXniF9++YWcjAz6GQZtDIMurU+/YbpkyRL6+P7Pe6Vto0YAdGnZMtn9dr7Xx61/wGNh0rhxVNEN6pgmBTVqlNLT/umnn1i/fj3vv/8+kEh0W5pGW5eLfdEUHvD6aVbyXT569Ciy3U7B9FUUzFiN7HCyf//+k86Zk5ZGddnOAt3gvVCENEXh9ddf/933cCpOnDjBRSMvJMXno1vbthw6dIitW7eeUjouMxzhcV+A7eEoMVU9q8Tbb2ldvz73lXjmdHK5ud60uNG0OK9z59Ned37v3iwsKTAarutcccX/ySds3ryZfl27MmbYML7++mvi8ThD+/XDcrpQBIFCTaNSJFKqEvfQoUNkpaTgFgTGKirZqsp1V//5ydYzcejQIfy6zlRNxy9J2Gw2rr322nL9nYnH41x5+eXUzMpicJ/zkh2CP/30E63bdUQUJWrVqceXX34JwPbt29EtHyl12qBZ/qQ8hD8UIXfo9dSZ+giKbiX9W05HcXHxKYsjTsXbb7/N9OmXcv/995/2/r799lsunz+fyy6bd86qp0/FosU34vaoBMPR0+YqvIEQ2QMWUGP0nbiU/6vyfuyxx/CoGh7NYODgoefk92LVqlWMGjPuDz9rbN26ld59B3DB8JHnXHq1gn8/FQnqCv4SnnzySSrrOg/7/LQzTGZMnXrWY7zyyiv4NI2IotC8qOhP3+H56aef8Os6N5gWcwyTjFCIr7766k+dI79KFVaVVOc28vmS7XmHDx/GLQhcb1rc5/XhtNmYMWMG77zzDkuWLMHn8dDHtLDbbHwWiXGNYeKw2XCLIv3cHvZFU2jldOFzOmlevz51TYvqmoYly1xrWNQ2DG64/nr279/PRx99lPwR2rdvHxs2bGDXrl0EDYNLdYPOmkZAllnlC9C+5L3q07kzUw2TZZYPtyAwyKNQy26njt3BRFWjqcNJJUnmOsMiRZLo4nLjKjEmfC8UYV80hTRJQrHZsNts2AWBYUOHklu1KpokoYki3hJDEafNRook4RIEvIrC5XPmYLhcvBwMsScSIyCKFNjt6E4nS5cuxeVw48trjjeQTl27g3CJ/t6eSIxapsUFgwdTq6RCRZFlJpdUvUxSNdyyzLXXXsvMGTPo2KoVqZqG3+MhoGmJam9RYpqq8UE4SmWXG9lmY7iisi+awng1cU5UFFFsNiqVVJA4bTYkh4ec8xdiVK6HVxCwl+hiO2w2TDNM0dz11J64DMmlUTR3PaG8xon7FUTaOl0M8ihJU0dTSFSGT9INgopCL1Wjt0fB53bjtNm40/IyUlFRBIHqtfJp0bAhLZ0u7rC86LIdy+ejhj0hdXGFbhBSlFNu8HzzzTdoDgd7SkwyZVGkimGwNxLjjWAYr6LgFkXsgoBqd5Rq/Tx+/Djr16/npZde4tChQ8yZOZOpkybRpLCQTh6FlwIhcgyDvj164HW7MVwuLh4zhqjHg8fhQk3Nxa5YpDQbRKXKVcmIRBihG/Q0DFoUFbF+/XoalbjPP+0P4lYNsgdeSa3xS5HsTpxOJ+vWrWPPnj0sX7486Vx+MlauXIlLlpEFkcy2o0hpPpip036fZMS4ESPIMwyaWV6KatYsdxDctlEjbjUTnRoZbjfhuh0pmrueaKO+GFkFFMxYjdMMMW/ePJ577jk0K0BK80EY/gh/+9vfWLZs2e966Oo3cDAZHcZRNHc9sYa9WLDgj+tJb9++nWXLlp20PXD6jFkouoVHN5l7WVl5kQ0bNtCzT18unTnrjMnrTz/9lBtvvDHZYltBBX8mFQnqivi7ggrKy5dffsmCBQu48cYbT9sOfeTIETZt2kRIUbjOsGhimMycNg2AxdddR55ucElJBfW/mhqeDfF4nBdeeIEnn3yylHzDTz/9RN3cXAq8XsKKwt/uuANIyGaZLhcjNJ1MVaVThw6sXLmSeDzOsJEX4tR8eDQ/MbdC+2bNTjrn008/jSFJ3G35+KxESuNkxQLFxcWsW7eONWvWnHWiEGDZsmXUMQxeCYbpbZhMKunCPBWPPvoohtuN1+2md+fOFNSsSUY0ypK//73ccx48eJChgweToSgMLjFyn6Hp1DEMrjuJAfxvueaqq6hvGMzUDLwOB8OGDaNTy5ZUz8g4adFDPB6nce3a/K1ks6K918fSpUtLnfPzzz+zYsUKpk2bxvLly/9QMvGtt95i8sSJVM/IoFPLlhw4cKBc123ZsoVsM5F4fzkYwinL2Gw2Ro4cecZq2ieffJKqus4T/gDdDLNMd8fJ7mfXrl3cc889pTZbEgnqRWeVoD5btm/fjmZ4iTXpjze1CldcedWfPse/kw0bNhAIR9EMiyV33VXq2HfffXfKDaj/FI4cOYI3ECK9zQhi9buTX1D0Vy+pgj+ZigR1BX8J8XicRddeS4MaNRk3YsTv0rZpVb8+N5oWeyIx6lvWn94qsm/fPnxuN59HYmwLR5FE8YyV2sXFxTz00ENcf/315TKBu/mGG0hVNdp4fWTFYnz33XdAYlfaLcvk2+2ERZF0SWK4bhC2LEYOG8YMTWd3JIYpCMzUE1IPzwdCPOrz4xEEbjctNEGgaVERqsPBZ5EYO0oSjP179OCmG27g3rvvxnS7CTqdVInGuPHGG/EqCgVeLymBABs2bGDU0KHMnD6duTNnUpCTw4WDB7Nx40Y6duyIIssINhtZssy+aAqvBMNogkAXpwuXzZbUS56tG6SHQmSnp5Nlt9PM6eR8T0L7WLLZeCMY5sVACMlmwyMIPOrz86DXj0uS6NKyJc2bNUMRRUaWJGk1u51Rw4YRVRQyJZlKksQgt6ekgljAW5LMdthsvB+K0MThZLqm82IghCWKLFu2jL///e9MGDeOyZMmke/xsNIXoK7dQWeXm3p5eWzatAm/x8OnkRj/CIax22y0drqoI9tRBQFZEFBEkYsVFbfNRqYk47IJNLQnZD7CokiR3U5I08hyOOjmUVAVk7T2Y/CIIoV2OxmiSDunC1F2ECzogplZG7c3Snb/K1CtAKYss8zrp3+JuUste6L6Ot9uZ28kxnKfn5qVK3PZ3LnMnT2bZ555hmxNY28kxkvBEIogkGMY1KtVC03RCKfmktJ8MC6PQqokowsCliDidblOubkTj8dpWq8eTXSDpoZJy4YN8SoKN5oWow2TKrEY4cKuxOp2QnW4qRSOnNQcqFm9QnoaBnUdTkxBICSK1JHtNLcsHnzwQfbs2cOBAwe4afFiPB6NSl0mUTR3PWZOAzySRKxEDubNYDj5Of7ss8/wKSoLDZMuukEklkpq0/5UH3krqjdAdnY2sizjVjRiNZuimt6T6t3F43EsReEpf5B/BMM4RQnNH0lWg5eH3bt3s23bNuLxOLrbzTslWuZpmsbHH39crjE2bNiA5fEQ9Ci43Qq+KnWpM/VRfHnNMLMbUjBjNR5flA0bNjB9+qXEmg2iaO560tuNpmPnzsyZM4fnnnuu3Gv+lWeffRbV9JFStw2a6eWDDz446zF+y6ZNm9AMLyn5LdEM70l1CT///POTGtNs27YN1fRSqdN4QrkNGT5y1B9aSwUV/BEqEtQV8XcFFfxZfP/99zQpKMAhSVSvXJn777+fft26ccVllyWTefF4nPvvv5/JEybw6quv/u65vv32W1asWHFSObINGzaQb1nsjcR4wh8gLyMjeeyjjz7ikksuwfJ4GGKY5Og6CxcsYMeOHfjdHh73BfgkFMEuSaec+6mnnsL0eAh4PHRp3fqkCeghfftS3TTJNy26tWt31snVxYsXc15JYvRy3WBgr14nPe/jjz/mmmuuYc2aNXz33Xfs3buXmGnRyOGkgcOBIcnl2tj/7rvvyAiHaa6q6KKIzzCYM3s2A3r04Pprrjnjs+Hx48cZN2oUqiQxuaRzcYSWSM5GVLVUwvVXhg8cSD/D5HFfgHRNO6329x/h0pmz0XwhXGaYfI/GhbpO97Zty3XtTz/9RNW0NHqWmI+POP98Zs2ahc1mo3Xr1mWkSX7LbbfdRu+SBPxi0yr3nP/K448/npD4cLqYPqOsvN+fwb333ktqiaRcdv8rqN+4+TmZ53+Bo0eP8tBDD7Fy5cpzJtf66aefovvDFM55mrqXrMDhdJ2TeSr466hIUFfwX0vXNm241DDZGo5QzTCSjsx/FvF4nHZNm1JgWuQZBiMGDTrjNZdMnEgtw2CgaRHz+zl06NAZr3n11Vd56KGHypy7YN48VIcDTRTZEAixL5pCA7+fyZMnU0M3+JvlJd3lIic9A0+JbMQbwTAOUaRFYSE3LF7Mzz//TNiyuMow6evx4DeMZDIyLRBgnT/IrkiMiCjhFEV0QcAlCFRxOLjuuuvKrPXFF1/EcDpRBYEuLjeNHA7cNoHpmk4rp4tGDgcdXS68JSaGo0o031x2O7t37+bSSy6hbZs2TJ0yhW3btuGSJDaFwrwcDCUqwAWBj8JRtoYjSDYbN5kWAbuDKwyToYpCliRT026nZtWqXDx2LC6bjZgoYggCFykqAzyJ6vFRqobbZqO328MIRUETBBRBoKHdkWylPHToECtXrqRZo0b4RZELPAoD3R4yZZmoz4fucvGEP8DtlpeomNCmriHbqZWXR0p6Bk5BJE2SeMjr43FfgIgoJpPyHVwuHJJEms/Hs4Eg+6Ip5NodCFKi0jtTkoiJIr1dLiSbjf4DBnDNNdcwbMSF1GvQhJEXXkjzkjbCh31+DEGgh8tNrixTx+4gTZKxXK5S0hw///wztbNzaO71EpEkBnkUdkdipCsK0ZQ0nIKIWxComZ2D02ajvsOBVxCIeDzJNs9/5eeff6ZVo0a4ZRm/pvHuu+/y4osvkl+1Kuk+Hy2aNEH1R8l0eXgpGKK3otCqWTMee+yxZGASj8eRSnS3XTYbqlsjVqcDot1JRjSWbOt7+eWX8Tkc+EQRXTHJ7r8ARTUYVvKaDldUMiWZLFmmcmoqkHCETjFNRJuN/JwcatUtRDV9NG7SjE8++YSMjAxsNhuVOk8go8M4zut/fpl7jMfjaC4XLwZCrPUFcIoit956W5nzTsVNixdjud1EFIURgwZRLy+P8YbJYtPCp2nJTafycNm8y7HScsjoPBGHYuBwecgvKMQwvdgdTvqfPzhZeaT7wqS1vRDFDODWLWJN+qN5g6xdu7bc8/3Ku+++y9133/2HjIt+ZfyEiaQ0TyTPU5oPYsLESWe+qIQVK1YQq9GIornrqTbkOvJq/ff9ln/22WfMmjWbG2644S/Rbavgz6MiQV0Rf1dQwZ/FokWL6GyY7InEGG6YTBz3f+Zkx44dY/fu3b+rmvhf+fbbb6mckkILn4+IqpapEv7oo48IKAqP+QJcbJi0a9Kk1PFHHnmEDv5Ed9ojPj/1q9fg559/JiMcYZRR0sVW//R6x4cPH+azzz47aeL52LFjyGLCxPyzSAzN6eTrr78u173t2LGD9957jy+++IJKkQi1vF78mnbSjfAdO3bg1zSGGSaZmsZtt9zCN998g0sQ2BOJ8VkkhmizlUtq4JprrqGm3c6+aAqrfAFSJYnmRWdXtXn33XfTu6TrL1uWeajEeLuh13tSw+gDBw5QWKMG6T4fV8ybd1ZznQ1uj0r+pAepN+spVJfKTaZF3Zyccl//9ddfc9NNN7F06dJk3H/vvfdit9vJzc1l165dJ73uwIEDpAQCNPX58SvKH+qEO3bs2Ekl9f4sPvzwQ1TDIrX1cPyVqjNr9txzNteZiMfjzL9iATXy6zFqzLj/qDgzHo/ToHEzQlXrEMjIpU+/AedknuPHj5OTV4NIzWYEK9emZ5++52SeCv46KhLUFfzX8umnn1KjcmXcdjvjRow4J1pJx44d4/HHH2fdunXl0rnOTklJJiQb+P2nrGh86qmnaFCzJh1btDjljzckAs0BPXvS1jCZqRv4VJX9+/czbtQoLFmmlkfBqygM6d8fr9uN7nJx8w03lBpjy5YtZPgD5Did1DMM2jdrRjwep3I0ymLTYmMghFcUCUkSN5oJh+t0WWbSpEm0KCrCKct0ad2aI0eOMG3yZJo6nCiCwN5IjN2RGDabjQZ2B5VEkU/CUe62fMQ0DclmY4yissTy4rbb2b59O3v37uX222/n8ccfJx6PU5CXh7NE5sMnCNS3OzAEAUMQaO5wsi+aQjuXm1iJEeF7oQh7IjEiikLM52N9IMjuSIyIKDLQ46GV08X2cJSuLjeWy4VqsxEVRTw2G41Lxi6qVYuDBw+SGY3S3Ocn4HajSRJOm41UUUQVBFw2Gy2aNEGTZYKiyBP+ADM0Ha/LxZIlS4hUq0e4VltUQeAy3eDZQBDTlrguV5ZRZJnNmzfTt1s3ehgmCw0TVRC4xTAJCCI9XG60EsmOPEnG8Hho26YNF198MTt27KB5URGKJNFEUQk4HIQMk1pVqqA5nZgOB35VJSMU4s7bby/1Xv/www88/PDDpAVDzNF0VvsDeASBFK+Xx3wBPg1HiXk85FWuTAuPwnhVI6Drp0yiPvDAAzQ0TT6PxJitG7Ru2JAXX3yRFFXlLstHG90gI6MSbd0e9kRipLsU9NRc9Fhl6hXV54YbbmD//v20btSILoaJ2+GiUucJFM1dT7ioB5deemlyrkmTJpEuSTzg9dHN5cZjd5CTU40Oms6H4Sht3R4k2U6kYW88pp9HH32UBVdcQTddZ1c4ynmGgaEbpDTuS7SoC3k183nggQewOz3YbDaUQCqXzSsrKQFwz1134ZEkFEEgVGJwU96/J4bbzavBMJ+Go/g9Hl577TX6detGx2bNSmlMl4defQckX59Yw15cXaIpeOLEiTLmiKtXr+bC0WPp2KkzKS2GUjR3PWmtRzBoyNCzmrO87Nu3j/feey/5d/DAgQPcd999ZfQl77jjDvwZueQMvAp/Ri53noU29IEDB7D8QWKFnfHGMpm/4Mo/9R7ONYcPHyYQjhJr0JNgdiF9+p6b4LyCfw8VCeqK+LuCCv4srrvuOroaJnsjMS40DMaPHg2Q9PoIKwrVK1f+w7q1q1atopnv/wocCnNzy5xz3733Uisri44tWpTp9vzoo4/wKwoLDZPWhsnFF14IJDrFJo8fz+wZM85q4/1ficfjpIVCXGGYXG9aBE2zlATJqVh87bX4PR7SNI0BPXvy/fff8/rrr7NixQoy/H40u52+3bolq9HvuuuuZEL4Hq+PNg0acPz4cYK6zjRNZ7yqockyhw8fPuPcrRs3wRAE7rJ89Hd7aOpwkpueDiTev7lz53LnnXeedoPhgw8+wKcoXKrpZLjdmA4HBV4vNSpXKRPf7dmzh/bNmtHKMOlvGFRNSyvXa/Qrx48fL7c3U3pmFTI6XkT2gAVIsgO/x8PS++8v91ynYuPGjViWRSAQ4I033jjpOd988w1PPfUUn3766R+e71zzyiuvcOHosdx8yy3nrDK4PDz66KN4UypTbfA1BHMKmXvZvL9sLf/Kvn37UHSLwtlrKbh0NaIonTOTyO+++45bb72Ve++994xyMhX891GRoK7g/yuOHj3K1VddxeTx48uYpP0Z9O/Rky6GyQLDxKeqJ5X5+OKLL7A8Hu71+phqmDSoVSt57Pjx4wzp2xfd5aZpQQFffvklP/30E5fPncuooUN5++23ARgzbDhzSgwPL9Z0Zs6YwZ49e5ImaOvXr6dxfj5dWrdm+/btyQrWzyMxVLudVJ8fV0lC1WGzUeBwYkgyi5MJajuyIOArkbFooessXryYRx99lBRPQm5hlKIy0ONBEQR0SUK02fBLMgG3m3atWtHc5UokewUBw+XCI8t4RJFupkmuYTBz2jQ2btyI7nCQVaLX/Os/h82GYrMxyPLiUxSumD+fsK4zVTe4saQytW61aswzTJ7yB9HtifWqJdIeDRxOLEGgi8uFXxBQbTYMQaCe3UH/fv148MEHaVMSwN/n9WFJEimiiN1mY0sowluhCHZRxPR4CIoi1WQZlyCwZMkSNm3ahO4PE0ypxmRVo7bdnkiqiyIxSaKm3Y4qiowdPRrT40GVZaK6Tle3mwK7A00QCAgCOyIx7rZ8hEURb8lrbQkifrebkYbBGl+AkNtdyiRn06ZNSWmUSpKEJssnbfvr16sXmZJMZVmmndNF1DT5m+XlnVAEUxTxaRoDeveme/v2dGrZkqZ1655UIuehhx6iltPFrkiMSzQdQ5a55ppr6ONNtOXdYXlp06gRlVNSqGaaSA43hXPWEW7QG5c3RqygPcFwjN27dzNu3Diys3PwBNLI6j4N1Rdm3bp1ybkWLFhAUBTxiyLekk2FXqaFIcu4ZBlFlAgVdado7noyOl1M//OH0L17d2RJxinJNHJ7cDmc1Ju9jrS2FyI5FeZdPp/L5l2Oafmw2Wxccsklp0w86243r5VIiAQ9ntNuHP2W1ECAJZaPZwJBDJeLr7/+mp07d9KsVVuq167L6tWryzUOJCqIdV+IlAbdUQ2LLVu2nPGahQsXYle9ZHQYh8MIUb1W7XLPV16WLXsARTMxgzFat+vA3r178QXDxGq3QPeFuPfe+5LnFhcXM2v2XArqN2bW7LlnHZzu2rWL6667Lql9+d/Em2++STA9O6EpP/5+vIHQX72kc8aaNWuoVVBE6/ad+Pzzz//q5ZwTKhLUFfF3BRX8WXz33XcU1qiB6nBQNS2Nffv2AXDRhRdysZ7w9uhtGMydO5ft27f/7sTOO++8Q1hRecDrZ6Bh0u80huin4rnnnmNAjx7MnTnzT6vQ/OSTT7juuutYs2YNW7dupX2TJrRq0OCk1c8nw1IUXi2J0UIehR07dnDw4EE0h4OuLjdvhSIUOF3JTfHNmzcTVBSuMUwa/0bne/v27XRu1YpWjRrx3nvvlWvuMcOG0dDtwSsIKDYBjyxz3733cvDgQSJeL8M1ndpOJzmpaafVQH711VcZP2YMt992Gx9++CHPPPMMR44c4eOPP2Zgr14MGzCASyZPxnInPG4+CkfZF00hXddP6ulxMm6+5VYcThcuj8Ly5WUN0H/LmjVrqFm5MqY3QKUqOcyfP/+0fi2QMOLTDIvUjMwzvnfbtm0jKysLl8vFI488Uq71V3B6rr76amL1S56FTtEZ+ldx9OhRLH+QjI4XkdZyCJWqZP/VS6rgv5SKBPWfwJdffsn0qVOZPnVq0m22gj9OcXExi669ln5duvDgAw/8KWMO6NmTNobBeF0nZJrlkuA4G3744QcumTSJgb16nbJ6csuWLWSVGM29EgwTMs3ksfvvv58i0+S9UIShhkGfbt24cMgQ5s2ZU0qne/gFF1DD4WCp10c1VWXZsmXJY19++SWWR+Hvlo8phklh9epkRqPMNkyuNi1cgkB/t5s0SaK9y4XbJuARBIacfz4hy8IuikREia2hCOd7PFSRZIKixLx584jH49x9112EDANDkrBkmbq1a5Ov62wLRxmvG3Rq2ZJZ06fT0zB4LRgmQ7bjFgSK7HaqluhVPxcI8f/YO88wKaqtjVbqULmqcxgmMeQch5wlI0EBJSgKiChJQRQURARFQVBBRTEAXkREFAyIESPXhAlBRBAJKoYrGMm9vh/TzOdITtdwZz2PP6SrTp2q6bDPPnu/b14iAUCpjAKDwqWBEKog8FQowsexBLbHw9ixYwv14TZs2ECDGjUI+/3kZWTw0EMPUadSZUrG49x3773s2bOHCjk53OEGWBGJ4YoFSc4hhslwwyRDlvEIAo7PR+UyZUgaBguCIc61bWxFwUhXcr8QjvJsOIJPkuh25pmYokgzr49yioe+vQoCgekzZhC0bDprGi+Go5QzDDyiyAfpCm9HFFEEgXvdAGUVpUAfWxC4xrRYGAyjiiIvhaPc6rjoae3stbEEH8cSyILAdKdAH7BpIMBDDz0EwE0TJ6IrCnFJ5ulQhEoeD428PrKjUVatWlVkR/+KESNI+P0M0AzCPh/du3fH8npRBIGLdYOSiocMx6VK6dJcYDvcHwgS0nXWrVtX5L369ttvowoCkseP4vERUjyc06MnEdumczCI4/ORFQpRu2JFQpqGIUpEarbDawapeNEd5I9dRrx0NUZddRUxw6BpMEjYtDijTTtmzy5aoXHzzTfTyOtjSzzJlaaFKYr8OxJjgGVz/fXXk1+tGh7NIrvtYMxoFjNm3IFP1ah08UwqXzILSVbILV0WO6sC/kCCUt3GEMouz4wZd7Bv3z769euHIAgMHDjwkAu/7FiMO90AT4Ui2Kp6VEPUX3/9ldFXX0PLNu3ICIeJuS6zH3gAgIpVq+OWrkMsvzOa6RzWcOTLL7/kgw8+KPK3W758OZMnTz5mw8Mnn3wSO5JJuFprYnXPpmK1msd03uHu6a233jro3kvklKT8BVOpfc3TBBLZjBkzhmTVJuSPXUbp7teesB7fBx98wOChw5g2bdo/ogJi+/btBMJRMhr1IFqhAR06HVoX8+/OgSqZ0udcR4nGPalZp96fPaXTQnGC+q8ffxdTzOlg8+bNDLroIoYMHHhMhnFr1qzhxhtvZPHixUfcWE2lUvzwww9FYpDhQ4bQ03ZYH0/SzDRRvV4ShkGL+vWPq2r298yZPZu6lSrT86yzTqoi+5tvvuGVV145qYppKPCdCFsW59sOeZbFrbfcctxjlEwkmO4EePJ3Mdp7771H2OstlNfrqmp069q18JynnnqKHp07M+G6604qxvj222+pUbESpijRya+iiiKtmzXjhRdeoFZaju+lcJSIJFGldGl27drF2rVrj0l2Yvfu3SRDIUbZDpfaDpoo8m4kRmlFobrHwyWmRUY4fExeTTt27MCn6lQdMpuKF92JqhuH3ej48ssvcTWNOYcoljoc69evR7cDVLn0Pkp2uoK8MgdX5/+R7777jvr16yMIAhMnTvzbFR781fjss8+wAyEyKjfEdAK89NJLJz3m/v37Wb16NV9//fVJj/Xee+9xRut2dOh01imRDSzmf5PiBPVJkkqlqFyqFL0sm962TeVSpYq/fE8R06ZMoaptM9VxKWEYLFu27KTHzAgGeSMSY2sig2rB4HG34J8K9uzZQ71q1anlumSbJteNGVP42owZM+iQTk5eazvYHg9XWzYtbYc+55wDFLSRW34/3VSNih4PAU0r8p778MMPybEstsSTrIjECFsWa9eupWPLlrSoWxfL56Oix8PjwTBbExk08vqYbDtoXi/79u2jV69etPb72RJPMsq06Kpq2KJY+Py3bduG7fezMZ7k01gCURRp4haYVU6wHTq3as2OHTto2aABfkVBE0V6aBq2IKIKIpNtly6qSrnMTACqlC2LJoo4ooQuijwSCPFeNI6rqmzevJlvv/2WJ598kvfffx9bVXkoEOIuN0A8EDjos/bmm2/i+v1oYoEutkcQ+CKe5J1IDH86Ad1X08n1q3hEESutTV3HU6B9HExXYJuiiE+WefrppylrGGxNZPBGJEYyEAAKHK8dTSOQTnrrHg+6KHKFaTHDCeBLV4LX83q5yrT4dyRGWJKY7rhsiieJSBKiIGCJIpogoIsi8wIhHggE8UsSrqZRwXWplFeKn376iY8//phYunpkku1Q1eMh3+vlDsfFK4hkGAbN69Vj9+7dvPjii4R1nc66gU8Q6Khq5JombVq0oKVl09jr4wJd58lQhKAsc4vtsjWRQa1AgKVLlxZZiJzfoweKx09el6uo2H8GkuIlkFmWQYOHMHHiRIJ+lcWhMJcbJmUVhbmBIH5RRPdqBMrWK0gm2wHqVqrEnHQQ3zIY5KGHHuK7774r1J8GuP/++6npV/ksnqS/bmClzT5zTJPp06eTaZrMcAI0M2xsTWPXrl14fX6qDn2QasP+hdevsmXLFpo2bUay4bkFkhdn9KffRQNYsGABfllGFAQEQaBdu3YHLVb+/e9/Uz47m8xwmAf/4JZ+KHr0Op9ohfpkthyA6QSYMuUWEiWyqVC5GopXxSldBzO7Cl7DKex8+D2PPPJIQVVytAQNGjc74cXTb7/9RuVqNQiVyMOw3WPSUzwU//nPf8guWYpQZilMJ1BEuqNytZpkt72UygPvwXCCzJ8/HysYpXT3a4lVakT/AQOP+3pbtmzBdAJkNOlNOK8aAy8dfELz/quxdu1aLh00hHHXjT+tmoh/Jm+//TbBZC61xzxD5UtmEYrG/+wpnRaKE9R/7fi7mGJOB/v27aNUiRJcbDv0tR0q5eUVxpp79uxh4vjx9OzShaeeegr4f63jvpZNnmUdJLN3NL777jvqVq2KLEnEjII4Z1M8SXXXPSFPiRPls88+o3GtWpTLzGTO7NmsXLmSkGlSMxgkIxwu7AhNpVLs2LGjyMb6jz/+yOiRI7mkXz9umDCBGmXLclbbtoVFW3PmzKFjWm5jbiBIk5pH30hfuXIljerWpW2LFmzcuJG33nqLirm5ZEUi/CtdlLNz505yk0l0UaSELBORJDJ0/bg6147G22+/TcRxMCSJG+0CY8YBukHA5+Opp54iaBiMNC3O8Pnp6FfxKQqlMzPJtiySodBBhR9/5PPPP8fx+tgcT3KnG0BNyxxmSBK1vV6SrnvMZts//PADPlWj2uUPUeXS+/Cp2mET1CtXriQvXSz1aiRK3HWPOv4HH3yAHU5Qa/QTVOh7G9FEiWOa165du+jZsyeCIHDBBRec8MbL/yqpVIqlS5cye/Zstm/fztatW3nkkUdOSSf4vn37aNG6LXYojmbaxZXuxfwlKE5QnyQ//fQTqsfDlniSLfEkmsdzTHpWxRydnl26cHM6eXaR7XDDDTec9JjndetGE9vmYtMiHggc0WH4dLJz506efPLJgxLkP/zwAxXz8si2LAK6TpV0MPRcOELZtDHcl19+iZtO5L0XjeNTFFKpFKtXr+aywYOZOGECdapWJd8NkGuanNWhQ2GCLJVK0fOsswh6PLTy+bnCsLAFkZtth4jjFDqIO7JMUJIwRZHzVQ1bkhiaNnTZuXMnIcviVsfletshMxqlXrVqxHSdiOMUkSXIiscZaphsTWQwzrLRBYE2fj/NfD6CPh979+4lJxplUTDM+niSmM+H4ffjUxRuGD+ezZs3Ew8EqGfZqKKIRxD4LJ7ko2gcrywzZMAA6lepwpRJkwoXEM888wxhXaetbaOLIpmygprWe67r8dDM58MvCLwZifFCOIolijT0+rg8XYHRQ9Xor+l4RZHPP/+csGVxjWXT2bbp1KoVAMMGDaKyx0Ndr4+2fj8lZJl73QCmKFLP6+V2x8WTTkA/EAiyOZ6kjKJgiSI5ckHSPicWw/T7iaoqajopbooi53brxtatW1mxYgU7d+4ECpKnpWybjfEkjwbDGKJIhqLQzq+SJyt8EUtQ1XV59tlnGXzxxVxt2YwwCqqQSyoKCVmmYfXq9OvVi7DPV5gszjcMgn4/DU2LiOMQNE1UReGs9u3Zt28flUqWxKt4qXzpvdQa/QSKapHV5lIaNWvJK6+8QkWnQE/xiVCYXFnm83gSUxRRBQGv7KFWnfq89tprXHDuuXR3HB4OhkgaBmd17YbHpyIrXlo2a8bOnTvZvXs3ndu0QRIEwpLEhapG3OPhon792LJlC66qsjQU4WbbpVLJkgDcdPNkPD4/suKlQb36/Pzzz7zzzjsYtktGrTb4dYuQZeEVRZaFI7waiaKkk9QdOnQ4poqUw5GdV4aK/WeQP3YZkdxK+HWLCn1vI6ftYGSfTu0xz1Br1BIEUTxkMJ5XtgJle0+i9jVPEypR6ohVEP/5z3+4atRoho+44pDV2Lt27WLFihUnJbUwc+ZMElWaFkqotOvYufC1VatWUaZCZQKhKLdMvRWA2bPnULdhUy66+BJ++eWX477eE088QbJCHfLHLqNC39soVb7SCc+9mP8uu3fvpkqNWkTzquBEklw3/vo/e0qnheIE9V87/i7mr8fOnTuZN28eCxcuPCWGf38G33//PaavoJtrczyJR5YLY7GrR46kvu1wk+0Q1Q3effdd7rvvPs5KJ19nB4K0OIqB4OHYt28fefE4YUmimc9HUtdZvnz5KbyzQ3NAbiOq64yyHB4PhglqGl3PPJNr0lKCvS2bG2+8kT179tC+eXM0j4dkKMTHH38MQNumTels2/TWDSxJYkEwxIW2w9nt2rF//34++OADIrrOzbZLE9thxJAhR5zTjh07MGSZel4fMUkill6fHIoffviBBrVrM0A3+CyW4DLTYtTv/E1Olia1ajHVcRllWlRUPNztBsiRFYJ+PytXrmTlypWUCIXI8atUsCxqVa3KOXbBcxtm2VzSr99hx96/fz9N69QhqCjUS3vtLA6FWRAMYYkim2IJskzrqLIbAA/OnUv/3r3p1q07Pr+Gz69x9x8MMn/Pnj17qF+9OjVdl0zT5Pprrz3qNVKpFF26dscMRNAMizlzjlzMsWPHDuo1bIKseGjQuBmjRo1CEASaNm16yjuY/8lcNfoaAokc4hUbkJNX+oRi7sPxxhtvFBQcXPM05c67meySxbIcxfz5FCeoT5IDRm9n2TZn2zY1K1QorqA+RSxcuJCEYdDXcQnq+jHpsR6NXbt2MerKK0kGg0Rsm8lpE7K/Ert372b16tVs3LiRmOtyoWVT07YZNrCgSjGVSnF+9+5kmSYBr5dKJUsydcoUIrbNMNOimW3Tq2tXZs+eTdhxOCMQJKbrhRUHqVSKp556iohpkuHx4BdFIo7DCy+8ABQEyed06oQgCJSUZXpqGl11g3YtWxJ3XTJCIaZMmUKT2rVp1aBBobzExo0bD0r4BUyTErLMHW6Asulq49x0lYPu8bBt2zYq5+VxhxvgnWicqK6zevXqwoXN+PHjOTcdIE+yHXJlmbAk4coyDWrXppntMD8YorRl8fjjjxded9myZfgVhRoeD5og8HwowjvROD5B4E7HxRIlloYi3OG6yIKAXxBo41dZGY1T2+tFEgRits1XX31FzfLlMTwe8itXLqwunj59Ol5BZFUszvJwBDctA+ITBF4MR5kTCKKJInW9XvyCUHC/6epsnyAwyrC4wrLJCga5/PLLaZ52TF8cClO9zMHBwb59+zjzjJYEZbnA9FBVqV6pEnklSjDcKqjQzjRN3nzzTe6//37KWRbVPR6uSCfdO/hVqlaqxMaNGzn/vD4Ykkx5VaVcdjYlolGq6jpBWaa3pmOlE+UdW7emWunS9NZNNK8fj2ric+M40RJMnzGDXbt2UbdqVSo7Lq7Hg+vxkJRlbFGkhCjRSVVxfT5WrVrF9u3b6X12V/IrVGDCdeNRTYcaIxdRoe9teD0+rh45svBeO7dqxfi0031j12Vuupr5hgkTMGQZQ5KpWKUamzdvJiMzG1UUud6y6WDZnN+tG1BgRnPttdfi+v0sC0XwCAIrIjHej8ZRRZGseBxRFGncuPEJbyheNnwEoaxyJPI7YrkB7EiS2tc8TaWLZyJ7VUo0v5BkvbMpc5jEa+26Dclq2Z/Kl8zCCkR4//33D3utajXziddoRaJOR7Jy807Lwn/hwoUEM8tQZfADJGq144K+/U/5NX7Pli1bsNwgyUY9CJeswqAhw07r9U6WPXv2/CNkSE4Vv/32G0888cSf0oX036I4Qf3Xjr+LOX2cyDomlUrRrG5d6rsu1R2HHl26nIaZnX5SqRS1K1XiTNuhjW3TuHbtwtda1qvHfW7BBn/XYJCzOnWiUY0aWF4vN1o29X+ndXws13nvvfcKq2PnzZtHFdPi5XCU9n4VS5apXq7caS16SqVSZEVjXG87xCSJZeFIQUGFbXN+r150sB1eiUSpZdvcf//9LFiwgHzHZWM8yTjbKSzacHWd96JxHggEqerxsjWRwYJgiLDfjySKtGzYkEWLFnFOx46Mu+aaIpv2n3/+OTNmzChcg0CBH0e2rPBYMMziYAhDFAs3CQ7Fk08+SVzXGWjZhHWdV1999aBjPv74Y6ZOncrll11Go+rVuaRv32PqcjqQoF4bSxDyeAh4PHgkiVHDhxce89tvv/HQQw+xZMkSbrvtNpraDqtjCbrZDiMvv/ygMXfs2MGLL77I66+/TlzX+SQaZ6RR0PW5Opbgg2gcjyBwk11QOHK0Yqp58+aRa5pMsB0yDYN58+YdZLx4gFtvuYUqeXl0P/NMvvzyS5566qnDmhgeilQqxbp16wo9j47EmLHXEqvanJqjFhOr1JgJEyfy4IMP4vV6KVOmTLEExDESy8ii0sC7Cwpissvx2muvnbKxV61ahemGqTLofrLbDqJKjVqnbOxiijlRihPUp4AffviB8dddx/jrriveETzFvPTSS9x8881HTN4cL03y87nadlgejhI3jGPWej2dpFIp1q5dy5IlS5g/f37h+2jDhg1cd9113HfffUXa6VKpFKNHjaK0bjDdCZCpaeToOlsTGbwcjpIbi/Hggw/SNm0EeP8fWurmzJnDGW6ALfEkUx2X/IoV6dquHdeNGVOYhPn222+pUb48ps9HwnVRBAE1bY5oa9oxuRgPHjSIiCjRyOsjLklUVDwMNUw0UaRCyZLs37+fN998k8xIBM3rZcK4cYXnvvfee5h+lRxF4YlQmNZ+P300vUATWRCIGgY3pSvMz7cdbr75Znbv3s3KlSu55ZZb8Isi11o2/XSD8oqHp0IRfIKAK4rYsoxPECiRNuO7RDcKjBAFAV0Q8YoSjz76KDUqVSIoSVTxeMgzjMK2wX379hF1HMoqCrpQIO1xvqbhTyegVUGkjCRhqiq6IJAQCwwY8ySJkCgy1XaZ5riUUzwETRPL62W85dDA56dTmzacecYZ6D4frRs3LpTBuKRfP2RBwBAE7nACaF4vn376KVVLlyZgGFw7ejSpVIqRw4YRtW1CmkYX3eDFcARTFKmevo5XlDA8flQ7Qtt2HSjnFDzDymmzxxfCUdbFEoT8fm699VaCmkYZyyKvRAnGjRvHkiVLCv9Gu3bt4qWXXmL16tW88847DOjXD0XxESpZg2ip2phelfPPP7/Ie+KLL77ApxlUu2weZXvegOVV6d6+feHrH3zwAVHXJaRpNKhRg6+//ppUKsXZ3c4ls/kF1B6zlGi5fM455xzcnMrUNArmvyQUpmT0/03pVqxYQRnbZlM8yUW6nt4cEDE9Hp5//nnmzZuHLMvUrFmT77777qjv5T+yf/9+5s6dyw033MCGDRto0botbjwL3Q4w+uprOLt7D3qdf0GhEdIf+eSTTyhfuRpuMMLEGycd9jr79u1DlCRqX/M0tcc8g265R9TEfO6555g6deoxG+r8/n4GXjqYYCRG4+YtT+iZHC+rVq1i+PARzJgx4y9Tbbdv3z5GXHElVWrkc+Woq9m/fz933TUTr1/F51e59777/uwpFvNfojhB/dePv4s5tezfv5+LL7gAjyxTJjPzuFrIv/rqK1y/n03xJJ/Fk8iSdExx4l+RHTt2MGXKFKZOncrmzZtZvnw5X3/9NXdMn06uadHXdrB9fsoaBrPcIGV0nXq1ajFx/Phj2shMpVL07tqVLNMkqutMGDeOadOm0c0p6Bq93nbooqq0dVzuvPPO45r7ypUruXr0aObNm3fUjYa9e/eiSBLrYgmut2xMUaR8Oin/ww8/0P3MM8mJRrm0Xz/27dvHI488Qi3H5fN4kjG2Q63KlWlRty7lsrNpYNl0Ny1MRaF+IEDA66WuqvJ5PElr2+GWQ+hOH9CmPtcNkGkYXDN6NGvWrKF/nz4EJIkcWSFPVsj4g/zERx99xNKlS4tUkr700ktMmDDhkJumH3/8MUHDoLdtE5AkLtUN2toOl6U7Qw/HJ598wr333kvYtvErCr27dmX//v1HNLDcuXMnZ7Vti+7z0axOHX744QcWLFhAg6pVOadjR1atWkVWLEatYJCAruOoKrc7Aa6yHeK2TUTTCKoqVcuWpV3Tprz++utHnCMUGG2OTRfzXGFaXPG75PnvefXVV8k0TR4PhulhO1xw7rmHHfO7777jzjvvZOHChSds2Dl8xBUk63Ymf+wyErU7MPrqawrnEQwGCQaDx3R//+s0O6MVyfwOlOw8EsMOFMrtnCom3jgJywmQV6Y8q1atOqVjF1PMiVCcoC7mf44qJfNYEAyxOZ6kkuOeEoOBk2H//v10O/NMHJ+PgCTR2LLIy8g4qinJReefzzjLZrzl4BcKqnMb+nw0sm369e7NihUrSBoFTt5n2Q79e/cuPPeJJ56gvG3z70iM/paNoyhMdVwa/qH6I5VKsWnTJlRF4a1IjDcisYJryfIxOXunUinObN0aS5KwRbFQ97qBptGpUyf+85//cN+sWeQlEiRsB8fnI6LrDB04kD7nnMM1psVw0yIuy6hpDek8SUJLa0drgkArxyVsWaxatYpaFSuSpar4BIGAJLElnmR1LIEiCPhFEUEQeCgQpKHHQ56s4BdE/IKAKQgYgshsN8Dz4Simz8fwYcPQRJEnQxGutWwissLs2bOBgmqNpK4zzrKJShIzHJcLdZ0emsbn8SQNvD4kQSDkuoQlCUMUuUDTMUWRi3UDWxRxRYnHgyEyDAPV4+EMn5+2Pj+610szv8rqWIKOts24tKO75vNT2XDooVu4okj1smXp1LIlMcfhwh49+Omnn5g8eTJlTJMLdYPSXi+50Sia10vb9ObFVMfFEUUm2g7lFQ+OaRNMJ/rb6gaaKHKfG+TVSBTb5+PLL79kw4YNvPrqqwf9vQ+VUPzwww8RJZnaY5ZSe8xSRNmDLcvcNnVqkeOGXzESUZLwKF5sv/8gffmdO3eyatUqqpUti+7xUqV0aTqd1ZUSjXtS6+qniJSuTr9+/TATpTBUkw6aTobHi+rz8/LLL/PFF1+wd+9eWjVqRK5lEdA07rjjDt59990i1UhPPvkkfr+fcuXKHTaR/Edm3X03TWvVZsiAAUU6Bvbt28fbb799VL3BEyG/XkNiVZoSr9mGvDLlDrvov2fWLOxIkoz89lhusLA65aeffuK2225jxowZRSqG7pk5k5jrUiYz87gqaP7JTJ8+nVBuJcqdd1PaZHMGPlWjyqD7qXzpvfj8anEl9f8IxQnq4vj7f41ly5ZR3rZZHSsw1m7XrNkxn7tr1y6irssE2+FK26FMZtbpm+h/iU2bNpEMhagdDBEyTd59912eeOIJJk2aRM/u3RltFiQFhx8hKXgoNm/eTFBVWR9P8k40jub18vXXX5MVi1FOVTFEkQWBEPUchwfS5svHwtq1awkaBkNMi3KWxZSbbjrqORf26EEF26Ga49K0bl1efvnlw/7G7dmzh06tWuFTFKKui6so3O0GaOHzU6NiRa6//nrWrVvHE088wblnn80lVoHG8dm2zQ033MDjjz/O2LFjaZKfT6XcXC644AI6pwtpGnl9RBSFkN+PIgi8F40XyMZJUpH45P777iOq6+QHAlTKK3VMcgdTpkzhgnQxxjTHpaOqcpcboE2jRoc9Z/KNN2LLCpIgEFTVYy5m2r9/f5H4eO3atYR1nTmBIBfaDtXLleNs1y3sDG1aty7N8vNp37w569at47PPPuPzzz9nw4YNlM/JQZYkep199hE3e5588kkShsEw0yKq6zz//POHPO5f//oXrdPPe5YbpFnt/EMe98svv5CXkUFHN0Bl2+HyQYOO6d7/yJYtW0hmZmMFo5TIzi1SXPHZZ59RqlQpvF4v8+bNO6Hxj8aaNWuoXqsOWbmlePDBf52Wa/w3+O677+jR+3yatGhVpNPgVLJ9+/YjdikcLz///PNRzeaLKeZwFCeoi/mfY8GCBbiaRq5l0bROnT892fD++++TZZpU8nhYlE7g1jZMmtSrV2jCciieeeYZIpqGVxB4KxLj7WgMryRx0003sWvXLu664w4a1KhBmRIl6NuzJz/++CM//vgjl/brR9vGjencrh2OXyXo9VHS62VdLMEsN0jrhg2LXOfXX39F93p5IxLjlbSG7+CBAzm7XTvaN2vGu+++e8T7a1anDj1th/peH1U8XoabFoYo0sY0qVSqFCFN44lQmNGmhSWK9NMNKmka7Vu3prPt8HokRu10hXTAsrBFkaY+Hz01jbAkYXu9fPHFFyxcuJD6boB73AAxUUQTRRp4fZRXPJRL6+XlZWQw2naISxLZssyGeJLbnQARSSJXkhlmmPw7EsNQFLyiSAlJ4gyfj1xZxisIPP/882zbto2RI0YUymdca9lkSjIJSWKQYbIlnqSt30/5dEW2KghcmT52tGkTUBSqlCtHVdumZdoIMaJqrI8nGWPaBEWR87WChPIAw2T40KH07dcfPV6KMj0mYAcS+GSZyqVKUd7n4+VwlDqWTdhxyNI0TFGknV+lp6YTVDUWLVpEWcvm6VCYqoqHiCTxTjTO3W6AhCxTvlQpbI8HryAQMgyctByJ7fcfcpPkl19+oXm9ekiiSK2KFYsEIOVzcjAUL8Fy9YnW6YLs8RWYQXq91ChThs6tWhUGqFu2bOHhhx8u1DD8I2OvuYbu6cVNT9tm0MCBZJcshSQrtGjVll9++QWPqiPIHrxOlNyOwzFUg5BfJaCq3Hj99ezbt4+VK1ceUZv55ZdfxjRNsrOz+eyzzw56fefOnaxfv57du3ezfPlyMk2TOYEgrdI6ip988gk1ypUjEQhwyzEsBk+EHTt20LptO3JLl+Pqa8YctpqlcfNWlOp6Dfljl5FRszUzZ84klUpRt2pV2tgOZ9gOzevVA2Dr1q04qsrz4Sh3uAFKlzg2s5v/Jrt27WL58uXHpL94qrh08BAymp5P/thlJBv1ZMiQoXj9KlWHzqXK4Afw+vzFBj//IxQnqIvj7/81Hn/8cWq5BWbOtzouzY5TT/n999/nzDPOoGv79v+I9v2JEydyfroy9RqroPjjAK+88gohXefcYJCgrh/XJu/27duxVZVFwTAznACZkQhQYDb4+OOPU7V0GTyyTNf27Y9rjTJr1iy6phOQDwSCnJH+vT8cb7/9Nud17UrXzp1ZsGDBUTuZ9u/fz2WXXkpONErZvDya+PyFxocxTSty7BdffEFOPE5Y06iUl8fokSMpa1mcrenYosR9bhDX7yeiaUywHHRRLPTWUcUCQ/V/BUJoslwkFq1eujSPpDW/6wQCx2Qk+cILL5BhGNzmuFT0eCmvacQMg0ceeeSw51iqSlWPp0DX2jCPabNmyZIl2JqGT1EK48Fly5aRn/Z9WRIKkxuNUtG2eT4c5SzbYejAQ5tMdz/zTEbYDutiCao5DgsXLjzitZ999lmuvvrqo/qZ5CYSNAgGCWkad9111yElZFasWEGldBL91UiUEqFQkde/+uor/vOf/xztcQAFspWff/75IeOm//znPzRq1AhBEKhctdopT1SXr1yN7FYDKN9nCprpsHnz5lM6/ulg5cqVDBoylFtvvfW/0lmYSqUYMPBSvH4NzTCPmHc4VhYseARVN/BrBhcNvKRY+raY46Y4QV3MP5YdO3YweuRIBl988UGB8tatW3nvvff+Em3l69evJ6RptPD5OFfTeCAQxBIlzlE1HFmmTuXKfPjhh0XOee6554i5LrrXi1eSWB6O8kokiu7zsXPnTu65+27KWRY32y4xj4eGtWvzySefcF63bnSxHWY4AWy/nyzD4OFgiDP8fir5fGSbJvfMnHnQHGfecQeqx4Pq8TDl5pspl53NSNthku0QsZ0jms3ZqsoH0ThfxJOE/H78ksQzoTBb4klkUaSkbrA5nmRpKEKJtIZxD91g3LhxdG7dmoxgkHrVqxPQdXSpQCrj01iCrYkMXFHCLwjMnz+fF198kSzDQBcEbFGkv6ZjiyJZsoytKIwfP54XXniBji1bEnVdsmSZdbEEN9suAVEkT1bwpSU6NFHEEUSCokR3VeM+N4guipTUdIKGwYQJE4ioGiNMC1eSqKooyIJAXJJwxYKK6WDaVVwTBLJkmamOS4Ys07xZM/bs2cPDDz/MrFmzmDNnDhXLlsWRZSRBoJeqkSXLJCQZ169yUf/++Dw+MlsOIH/sMuL1zkYRBK61bJr7/HRVNer7/OQoHjbHEoiCwJJQgelkRFXZuHEjXTp0wJJlKioeuqkariiSkCRa+HxEZZmxlk1CkvGLIiujcbYmMihlOwe97wCmTp1KG9vmi3iS3rbN8LTZTSqVQpckyioKmbKMKkq09vl4MRTBEkXmB0NcZDu0b978mD4X144ZQ7e0w/i5ts3Vo0aRSqUKK7l//fVXkiWysLIro2gWXjOMX5JYE0uwMm0eeqztxe+88w7BYJBoNMqHH37Inj17ePTRR5k5cybReBI7FCe7ZCkmT55M10CArYkM7nQDtGvShEY1ajD2gGSQbpyW9rgHH3yQQEYepbpegxkugWG7mLbLffffDxQk2XudfwGNmjQjXKo6uR1HYAYi/Pvf/y40fNocT7Ipbfj022+/sXbtWmK6zvp4khfDUSK2fcrnfTLs2rWL6rXqEM4qi+EEuemmm3nggQd46623Tut133nnHUw7QEaVxphOgPfff59pt95eIPGhatxxx/G1Wxfz96U4QV0cf/+vsXv3bs5o0ICwphE0zX+0xvyxcN9991HLtnkpHKWd7XDNH8z33n//fe666y4++uij4x770UcfJS+RoHJeHm+++eZBr59IUufDDz8koKqMtWzKezyYHs9BHWwH+PrrrwkaBuMsm462Q7cOHY46/rx586iafh61VQ1NFOnoV4lJEiWTyYOO37NnD1u3bmXfvn1UL12axaEwm+JJanm83OG4VHVdrh07lrZNmqApCguDYe5yA/gFgYqKh4gk07Ft2yJjdjyjJQNsh0eDYWK6ccg49VD868EHObttW0aNHMncuXMPW1yzd+9etm7dSiIcpo7Xy+Z4kvGWTdsmTUilUrz11lusXLnykH+fiO2wOBTm7WgMy+9n27Zt/Pzzz5TLyaFJIFiQJJ86lauGD6dUIkHX9u0P2y3b8YyWTEz7sTR0Xf71r0NXAO/du5fBF11EhawsBl544VE3NHbs2MHixYtp2agRIVXD0TSWLl1a5Jht27YRNAwm2Q49bIe2TZsWvjbk4otx/H4sv58HToHk2QMPPIBX1REEAY9PPeKmwfESisapdPFMal/zNG6sxCnxsjqdbNy4EdMJkNGkN+GSVRh62cH65aeaVatWYQWj1LzyMcr2nkSJ7JInPWYknqT8hdOoeeVjmG74uKSiiikGjhx//+mB7on+VxwgFwPQol49zrJthlg2yVDoiEnUP4M9e/Zw0w030K93b4YMGkTANInoOjFNp6+mE5IkpjkuN9gOGeFwkWAoHggwPxji1UgUzeNB83rRvN7CYKFfr15MSOszDzZMGvh8ZEajVCtVqlBmo7Su0yntNH2HG6BKXt4Rd053797Nnj172L9/P7Ik8WkswaZ4kpCqcUn//lQvXZohAwYctEveu2tX6joOXRyHstnZVChZkp6WTW1VxS+KWJJMhiwTkCQ6qyp2unr3wE73xx9/TEzXeT0SY5LtEE4nVpv5fETSieCgZRXsAvftiyqKXJiWtJjmuDTyFlTxdjYtXE3js88+Y9myZRiShCwIxCSZKw2rsOK5mdfHR9E4plBgFrg4VPC8qno8zAkEmWQ72IpCyK+Sk0gwatQoSkQilPd4CIgiAVHEEgRGGCZbExm08fkKtK1FkYb5+UWSplMnT6aMZdHA7yff6+XJUBhDFGmsGziqyty5c7EkiQm2je5VCZSug6x4qagobE1k8Ew6+VvV4yVHUWjl8+MXRTJlmZAkkR2LsWDBAnJMk5Ak8WokytZEBnmyQkJRCHu8jLP+v0U1LMtU03U6Oy6lS5RgyZIlRaqPf/jhByLBIO39KlviSQZaNoMHDAAKNMs1WebzeJJPYwkkQaCHqvKvQJCKiqfQBLJiTs4xfT7+85//UKN8efyKQrWyZYtoIv/yyy+UzsqirGFgSxKhUJixY8di+f08FYowPxgiYJrHtcBbvXo1yWQSx3GoW706tV2XkKqRqN+tYGOgZhtGjBhB1HE4MxgkbhgsWLCACtnZLAwWLLoqOA633nor53frxtirr2b16tVFFgtbt25lwYIFx10RPOKKkSQb96L2mGeQfTple91IpYtnouoGb775JqYTIKvVxYRLVSe/bn3adezCo48+ChRIj5RMJhlsOwywbSrk5pJKpUilUvQ6+2wShoGrqtx1xx3HNadDsX//fkZfPYaKVWtyyaAhJ9Wd8vLLLxPOKkPtMc9Q/sJpKH6DjGrNsAIRHn744ZOe65FYv349Dz/8MJ9//nnhv/3666/HZKhUzD+H4gR1cfz9T+e7777j7rvv5vHHHy/8vTwg7XYs0gn/dPbt28fgiy6iZDzOuZ27HPRMfvnlF8aPG8fwoUPZsGHDnzTLAvbv38/TTz+N4fNhiyLdVY3l4QiOz3fILrJXXnmFmulq6+XhKDm/8/A4HKNHjyYuywREkQxJwlYUZFHEMYxDJtl/T9+ePWlp2ZSUFax0l2P53NxCWYHHHnuMkK5jShK1PB4sSaJBzZoHJXC/+uorOrRoQdW8PGbdc89xPKGj880331A+N5ewpuFqGkZaTtD0enn//ffp26sXOZZFCcM8pH51wDB4LhxhVSyO4/fz5ZdfAgWV8QsXLmTFihXHPJf33nuPqOMQ0jQa1659WPmF22+/nbq2zbJwhEa2zS1Tphx17FdeeYWyts3n8SRzA0Gqlip10DGvv/46Z7dty8ALLyyslv7iiy8IqiqfxBK8EI4SMIxjvp/DcdHFl1CiRT8ympyHIAhkZGTw/fffn/S4ALdMvRXTDRFM5tK4aYu/vCb+okWLSFaqT/7YZZTvcwvlK1c/7ddcs2YNphum+ohHKHPueLJKlj7pMZOZOZQ593qqXf4Quh34078bi/n7UZygLuYfi+7z8XG60jbbsv6UHby9e/dyxdCh1ChThiuGDi3y49ilfXtq+vyMs2wCmlbo5H3njBlkGQV6wJ/Hk3wWS6BIErnxODHXZc7s2TiaxiuRKGtiCQxJ5r777mPHjh2kUim2bdvGWV264MoyZ/j8aKLIHDeA7vEwftw4ci2LToEA8WCQuBugVShE0O9H9XrxKQqTJkwAChLor776KqtXrz7ovs7r1o2qjkN916V8bi5VTZOemkZCUWjVrBlffPEFX3/9NZcNHkypRMH8y2Zmsn79er755huuuuIKdI+HuYEga6JxNFlGF0WikoSmKDz55JOF11qxYgWlbJuN8SQ32w5qusK5sc+HK0qUUxR8igIUJNFdo0DjeYLtUCaddC4jy2xNZNBZ1WjRpAkAd999N5bHw0jDpLSiMMF2KCHLVPd46KVqqIJIXa+XkCRR1+vFEEWeCYXppuk09/nYFE9SzXV55plnWLhwIVVsmzcjMXpqGkFRop1f5Z1onBpeH/nVqxcGXOvXr6dhjRqUjMcpEY1ygaYzxDDpqBYkffubFs0bN2bdunU89thjJDweBhsm02wXQxQpkw7ue2s6lQ0DS5Z5OxLjg2gcPW0MuTWRQXvdYPz48YwcMYIRpkV7v0o7v8rVpoVfFBkyZAijR48mqWmMNC1sSaJkiRLcfffdjBs3jpjr0iAYImgYhY7RNStWJFeWcdNBe9g02bRpE1AghRE0TW60HcZZNo7fTzSdrDdEkRqaRtwwuHPGjGP+/KRSKX7++eeDEs2tmzYlKctkyzKurODVHQLhKLdMnkwiECArGuW5557j559/ZubMmcyePfuYZBk2btxIdnY2giDwYCBIP9MmWLEJNa98jGi5ukybNo2tW7cyZ84c3n77bQDmP/QQrqqSY1nUrVaNkK4zwXao4/Nh+jVyS5Xh22+/Zf369TjBMBmVG2I4gePSkXvzzTcxbJdEzdaIkkzVIbOpMXIRqm5xxx13kFG1Cfljl1GieV+i8Ywin58D9zWgTx8GXti3iNZ2KpVizZo1J9X2uH//fjZu3MjPP//MnDlzCGaWpdz5UwiXrsGNk05c8uSTTz7BcIKUv2AqGU1643ei5I9dRt5Zo2h6RpsTHvfvwpo1a3j88cdP2UKtmOOnOEFdHH//k/n555/Jy8jgTDdAedvmystPf7XeP40zzziDdrbDJelCmD8rqb9v3z7OPOMMIj4fuijiiBLPhCJ8Fk/iStIhNYl37NhBiUiEnrZDddtm6MUXH/U6NSpWpK3PT2Ovj96azoJgiKimHVNl6q+//krbVq2ol451r7cdOrVsWfj6a6+9RtAwKK9p6JJE+exsli9fflzP4WS5duxYelo2n8USeAWBdyMxloYi+BSFr776CsPr5bNYgjWxBF5ZPiiufHDuXEy/H8Pr5erf+fkciv379/P9998fsZBi586dbNmy5YgmhSNHjGBwWkbwcstm2DHoRb/zzjuUMEzej8a52XapV6UKCxcupFylqjRu3rLI5vzv+frrr7H9flZEYjwUCJHxB+mPE+Gpp57CCkTIaHguft3E4/FQqlSpU+bnsnr1al577bW/RMf00di0aROmEyDZqCeh3EpcPuLI76FTxYiRV6J4PFiOy4svvnjS47344ovYbhCP18t11084BTMs5n+N4gR1MX8bli1bxjkdOzJ29OhjMujr1KoVLWybXpZNXkbGMZ2zY8cO+vXqRdNatXjooYdOes7Tp08n37ZZHAqTb9tMnz4dgGGXXootiixI66g11/Qi11uyZAnlcnMpqWmUtSxcn5/73CDPhiPYfj+3TJmCP22+d4bPhy5JeGWZ6uXKEQ+FsAWRkCiSLcs08fkwJYlmdeuSSqV49tlnueeee/j000+pV706oiiiyjKLQ2FWRuPYPh8dWrYkNxajvG0T1XVm3HZb4dyeffZZymZmkgyHufrqq7nqyitp6PNTzePlVsfBEEVCPh+210t5xUNTn591sQSdVBXX52P0FVdwdvv2RGQZR5QYYpg4qsqCBQsYP348CxcuZOgll3DViBH88MMP7Nu3j46tWuGmtZHrer1cn64Ov0DX8QgCY0aN4porr0SVZRypQCrjLFXjBsvBFEUqKx5mugHikkwiECi8lxkzZqCLIqVkhbP8KiUVhQ4+H4Ig0DutAz3YMNEFgagkEVBVMmyH4abF29EY2ekW2P379zOo/0VEbJuk43CmX6We14sqilSvWJExY8bwzjvvANA0P5+Rls2lukFIkmjl9+OKIqog4IoiYcvi008/BdLBoKoSkiSSkswtjksHv4pXlunYsSOuYVBWKUhYd9cNEo5DT9vh7WiMmo7Dgw8+yPLly4noOv1MC0OSSbouN998c+EzeOKJJ7h86FDmzp1buIEyZcoUeqbd5CfaDj26dGHPnj3IaY3ADbEEqiBwSbp6+gDndOmCJkn4JYke55xDQNM40w3gqio333wzK1euPOnP1Pbt29E8Hj6LJ1kbSyALIjVHLSGz+QX06H1+4XH79+8nv3JlWjku9RyHs9JtonfdcQdRx6FsVlbh3+T3bNq0CUWWkQWBjqqKqpl4vF7OaN3usF0YW7Zs4b333uPhhx+mdajgM70wGCYSySZevRU33HADN910E8n8M8kfu4zsdoM5q3uP47rvEVdcidev4TdsFK8f3XIZNGQYX3zxBZYbJFi+YUGVcZPe2OE4ixYtOq7xj4dNmzYxf/58PvzwQxo2aY7hBLGcAH369CFRryv5Y5eReUZ/Lujb/6Suc8+sWWSVLE3FqtUx3BClu48jWr7ef6Xt8c/kiSeewHCCJMrnE40n+frrr//sKf1PUpygLo6//8m8+uqrVEtLVh1rBe3/EitXriyM7w6Hq+t8cEAWzXFOSOrjAEuWLOGi88/nvnvvPW55j9dff50y6UKOBcEQEUlCFUUCokTS52PZsmVs27aNzz77rMjYW7duZfLkycydO/eI9wkwacIEYopCo7Sh+4H1S/1gkCeeeOKY5rlgwQJqOA4fRuPU9vkoGQ4zLy1d0a19eyalY/sOfpWzVJWArrNt27bjehYnw8SJE+lg26yNJfAJIs+FIzwbjmD4fPz888+4us7sQJCZboCwbR/0d3rrrbe46aabePnll9m9ezc3TpzIgD59DtIn37p1K2WysjC9XmpWqMD27dtPeM5r1qwhbFk0DBUYeR7re/DS/v3xyTLZsRhLly5FtxzK9ryBEk3Pp3rtuoc97/Zp09B9PiKOc1gzxuPl+eefZ+zYsbz88su88cYbhEIhAoEAr7zyyikZ/+/EBx98wPDhI7jzzjv/qxXfu3fvPup3wPGQSqX+8hXrxfx1KU5QF/O3YNWqVYR1nZttl2a2w7DDmEr8nt9++41p06Yxfvz4Y17gn9+tG2fbDvcHgkR1/bhcm6++4gqqlynDoP79C3fVhw8bxuUHdrZNi8uHDuX7779HVRQyJIkKiocBuoEqikVa8J544gkCmkZpw6BMVhaGz8cbkRjrYgmCqsqmTZsoGYvxYNp4o5ys0FvTUNKmfK4ooYkir0VibE1kkCUrXJXWztu3bx/79+9n3NixdLZsNsSTaILAVNvltUgUTRTpqWlkyjKb40meDUfITi9c7rn7bvySxIOBEHMCQQJGgeau6fFylWkx0DAK5TW6qxr1PF7OVTW2JjJo4vVhiiKWJBHwevk8nuSVSBS/KBbKC+zatYusaIyBlk0326FRzZpcPXIklUuWJDMUQhYEuqkaDb0+Hg6GyJJl+vfvz1tvvUWmafJ2NMb4tGlhpqxQzbSoX706pqJQyeOhtqpxdrt2AIweMQLH78cnCMTTJojR9HNr5vMTkCQGGwXSGJYoYvn8BfINPXoQNQwsv58RQ4fyyCOPsGLFCjZt2sSIyy5jxOWX06JhQ0onk3Tt3Jkc0+RSy8b0emnVsiWurtPQ6yNDlnkokA7wvT68af3rkpmZNMvP58IePfjhhx8ol5VFO7+fgCgRlmQyw2FWr15N4/r1OTudRL/edsgJh3nsscdoUb8+Ycuif+/ehcHBa6+9xvXXX1/EPGX//v0sXLiQGTNmHOS0/PDDD1PJtlkaitDedrhqxAhSqRSZkQhjLZubbRe/IDD5d6aAB1r/1sQSPBeO4BdFLhs0iFmzZh2yCv9E2b17NwHDYKYbYLoTwC/JVBs+n0Tt9lx8yf9XjmzZsoWwprElnuSzeBJZkti4cSMBVeXFcJRbHZfyh5EbWb58OY5pIggCEydOPOa5bd26lbBl0ccwyfb4yGxwDtFydRg2bBj5deuhhzIo2/smouXqcM2Yscd1304wTOWB91Dr6qcwAxGee+65wtfWrFlDgwYNSTbuTf7YZWS1upi+/S86rvGPlbVr12K5QTKqNMavGwSzy1P7mqcp2ekKqtbML3itckMMO3DK9Evfe+89/LqB3w7j163TovP9V6Jpi9bkdbmqwKixajNmzZr1Z0/pf5LiBHVx/P1P5ssvvyRoGExxXHrYDh1atPizp/SXYdTw4WQYBnmWxTmdOh02YdylTRvOsGz6Giauqp5wwu7FF18kbhiMtxzKWRZ3H8IL5kh8+OGHxA2Df0di3OC4BH0+Il4vrUyLEpEIM++6C1tViek6Pbp0OSF96zIZBbJyWxMZxCQZW5apHwhSNjubn3766ZjG2LdvH727dsUvijTw+ZnpBkgYBm+88QaDL7qIbmk/j/KKh5lOgLKOc8hCgtPFTz/9RNM6dZBEkTJZWdiahqvrPDx/PlCQSK1csiTVSpfm9ddfL3LuCy+8QETXOd8NENJ1zjrzTBrbDtdYNkHDKFKVPOzSS+mf9ljpbNvceOONJzXvr7/+mmeeeYYvv/ySNWvWULtiRXKiUWbdffchj3/hhRcwbJd4merEEiVYunQpwWQutcc8Q6WLZxKOH6wn/ntOt+nd+vXrKVu2LB6Ph7lz557WaxVTTDF/PYoT1MX8LZg3bx7t0pWJ84MhGlStelquk1+hIvMPVDUHQ0d1TT7A7NmzqWrbLAmFaWw73JCWyXj//fcJGgbNg0ECus7777/Pjh07UGWZEpJEFY8HSxQpnZlZZLwG1apxnxtkSzxJ/UCASmXLoooitizTs2tXUqkUN15/PZmaRl2vD0MU8QsijiiSkGS+iCfJlGV6aQVyA6Yg0OOss7j7zjvRvF5Mv59OHTpwgWXzViSGKYrkyAp+USTq9bEiEsMVJR4PhrnasqlbpQofffQRQVVFFgSut2w+TBvR/fbbbyxevBjH56OUotDBrzLTDWAe0G4TRWxBQBVFnk8nBnVR5KlQhKmOS7msLHbv3s2iRYsYO3YsYb/K1kQGn8USyKJIZdvmyVCExj4/2bKCIQiYoogjSfQ85xzGXH01SavArPDpYJg5gSAlJAlVUfDKMobPx3XjxnFOx45cduml7Nixg48++gjD62VVLMGbkRheWeb666/ngQceoExaImOCZeMXBG51XG60HVxRIiwr1NU0RhpmwdiqSr5lk2EYhE2TAZZNG1VFF0Ua1KhB+2bNuM1xmWA5WKJInqKgiyJXmxaVFQ8tfX7ucgMYoshdrsucQIEZ4yw3yLm2wzkdO9KsTh1G2Q5LQxFcn5/hw4dzfq9elFM1Kioeng9HaafrGIpCVNNo2bQpjz32WBFn7s2bN3NWmzY0rlmTZ555BoDhgwdTUtdJKAq2onD5oEGFCe1UKsXoESOokJXFed268csvvzBtyhSqlCxZINfh8XCX46L7fIXnfPXVV9h+P29GYswPhohKEj5FOay0RiqVYvfu3dw0eQo+VSMcTfDqq68e0+ftlVdeoWa58pRwXWRBwCeKlK9YpYhO9TPPPIMmFWw4NParVC1ThlWrVhFXVTakN15MxXPYzopffvmFM844A0EQmDZt2jHNC2DdunVcc801lCxVBsXjoXGzFhi2S1brSzATpXDCcQYMvPSYOjp+T8nS5chpP5QKfW9DN51CbcMDLF26FCsYI7PlRTjREqfcDf0AEyZMIFGnM/ljlxGp2R49lKTGFQvJOqMfzVu1YfPmzSxcuJDPPvvslF2z30UDKNGsD/ljl5Go24Vrxow5ZWP/Fek/YCDxqs0pd/4UnGiJU1alVMzxUZygLo6//+m8/PLLdGrZkosvuKBQZ/Z/nVQqhVdR+CgaZ0M8SUBVi0hj/Z7ffvuNZo0bE/V4uFg3COr6cW3Ip1Ipvv/+e8aNG8fAdOx5k+1wXrduxz3vG8aPx9V1ymVn88EHH/DYY48xffp0vvrqK7IiEZ4KRVgfT5Jpmoc0Fvzuu+94/vnnWbFixSGN+9o1a8aFtsM9bhBXVVmyZAlLliw55uT072lVvz73uAUFNmcFgsyaNYvt27fTuXVrwppOzOuluetSuVSpw2ovn04OVJIe8Os4Fi7t358x6b/h5aZF3HVZkvawaREK8/jjjxcee/ngwfSxbTbHk3SwnSJdjSdLrQoVGGc7PB2KENS0Q+r/tm7fkdwzLy/YBK9+Brfffjs1atclklsBKxRj0k2nbj4nyg8//ECzZs0QBIGxY8ee9qR4McUU89ehOEFdzN+CLVu2ELYsznMcSlsWU246cW3TIzHzzjvJME3aBINkRWPHrP957bXXMsAqqJQeY9lcdP75ha9defnleGUZS1UL2+Au6tsXRRDwCwKlvD5GXnZZkfG6tG7NINvhpXCUDE0jW9d5MxJjgGXT86yzgIKqSdvvp4XPTyWPhy/iSW6yHRxR5JVIlF5qgcGHRxDwiyLjx4/H8Pl4PRLjuXTLWslkEsPjobeu80U8STOfH0tRqO/1UkKSCUsSpiSxZs0aFi1ahCVJdFU1KqcT68N/p3U2atQo8mSZKoqCRxBYHArzeDCMTxBQBIGAKLEhnuT5cEGVti6K5MRi6D4fiigSVRS62g6qKFLH4yFLljFVlfPTRo7jLYduqsZMxyUvkeCC3r2pVbkymigyzrK5Pp1Q1gQBQ5YxPB4+jiV4OhQhYtu89957/Pbbb4wYPBjH78crCLwYjvJ4MIyr66RSKXbs2EHMdbnctGjhK6iuLtQBFwSuMi3yPR4ikkRbv5/yioIuCNxg2YTSOtefxBL4BZH2tkPFsmUpLSvYosjjwTBb4klKygrzA0FWRmL4BIF6VaogiSK32A632A5VPF62JjJ4LBgmpussWrSIOpUrE3UcbJ+Pnm6AsOKhi9/PxbpBWJIxJInHgyFKyQolZQUjbVpzQMOtYY0aDLYd7nYDOJpGtzPPxFQUPF6VYJk6aB4f5TWNOw5jlLd06VJKWhYLgiGa+nycp+m8HI6iejy8+OKL3HjjjaxYsYLJkyahCAKOKHGdZWOp6iFbvN5++21igQCKJOHx61QdModS3cYel3v0a6+9Rp5l8WkswW2OS90qVYq8ngyGeDBQYCSqyzLvvfceqVSKhG0TlSQcUSRb045oDLpr1y66dOmCIAhce+21JxQgv/jii8TyKpM/dhmVBtx1zPe4e/duXn/9ddavXw8UbHaVq1SFeEYWs2fPOeQ5ixcvpv+Ai0+JPNHhePjhhwlm5FG29yTCpWtSo3YdFI+XnFJlCqVpTjXjr59AtFwdKg24k3DJytx9mKqgfwo//fQT5/TsTblK1Zg8ZeqfPZ3/WYoT1MXxdzH/m5SIRLjVcXkwEMLRtMMmYX/88UeCqkpUkohIEs0chzlzDv37/Ef27NlDhxYtML1eXNMkqKoMMy2yDLNQ9uJUUTE3l9udAK9FYoQOkbRcu3YtEdumgs9XUAyjaYXeIwf45ptv6NGlC01r1T5mSY8DpFIpZt1zD5f068dzzz3H7AceIGkYdA0Eidh2kQ7SVCrF008/zdy5c/noo4945513/vJSAa+++ioBwyBXUbjDDVDatOjYvj1VbZsBlkXYsooUFWzbto0qpUvjkWUa1qx5Qkl+KJBcnDRpUpFu3+xolGdCETbFk+TZdqFfyu8ZeOlg4lWbU6Hf7QSSuSxZsoRdu3axbNky3n333ROaywHuvOsuAqEoOXllDnnt42H37t1ceOGFCILAueee+6dsVhRTTDH/fYoT1MX85UmlUnzzzTd88sknTJ48mcWLF5/WndQ33niDf/3rXwfJHhxqXg888ADDhw1j6NChGH4/jQJBgoZRqDe2detWXFXlvWicx4Jh4mn941QqxVXDh1MuM5PeZ3c9yFhly5YtNM3PJzMcpmvnzjRzA2yJJ7nVcWnbuDFQYCxRPxjkgUCQ8oqHz2IJrjEtTFHE9HiIuS5ldZ318SQ32y6Na9XC8Hp5LxrnjUgMv8fDzp07mTBhAvVtmz6aTlWPl3GWjSaKDDNMVoSj+GSFdevWMXXqVLI9HrYmMngrEsPx+7nyssuolJND/969ufbaa6nm9fJRNIZHEPgoGuejaByPKHLPPfeQEQgQkiRsUaSMomB5vcQch4XBMO9F49iiyNvRGJU8HmxRZKxlE5IkDEUhX9dRRZFrTZsMr4pHd/HqLhleP4ogsCGeZGM8iVcQqKYoWD4fls/HymiceYEQuiASUhTCloXh9bI6luA8TcMrCPgFkWaNG5NKpXjjjTeYP38+/c8/n47t21OnalXKajolZJlqHg8xScInCMQkiTmBII4okZBkgmlH8l6aTjOfjwZeHx1thzZt2pDj8RISJYYZJktCYUxRpLamU9Oy6X5mR3qdfTZlNb2wutr1+2no8xGVJFqkFwvvvfced911F93cAl3omW4AWxRpGQgQtiySwSADdYOaHi9b4knmBIJkywqXDxkCQNx1eTUSZUs8SVBR6GPZ1NBMsttcWlCVWrsj9b0+hg8bdsj3+vTp0+nuFmhV3uq4WKKELAjokoQqSfS3bMK6zvLly5n/0EMEDAND04mXyKF7j178/PPPRcZrUK0atzouTwdDyF6Vkp1GUu6CWwhF48f8OX3llVcobdt8Fk9ylxugTqVKRV53dZ3l4Shr07I4BxZArRo2pL9h8mQwTI5pHrQI+yN79+6lT58+CILAkCFDjlujbfv27UTjGSRqtCaYWYbLho846jk7d+6kWo3ahDJLYdgB5s598LiueTQ+/fRTmrZoRY38esdtiJJKpRg/YSJVa9Zh0JBhRzWfXLRoEdVq16VDp7NOWEt5586d9DyvD5m5pbj4kkF/+cVqMf8MihPUxfE3FGwYFSdG/l7s3r2bzZs3n7Ax2jvvvEPtChWoXLJkYdfZoZg5cybNDYMt8SRjTRtbUY7aPbRnzx6GXHwxpRIJMnw+1scS3GQ71K5UidGjRh138vdI3DF9OqWTSWpVqEBWNEpA15k2efJBx11x+eUMSssRDjFMmvt8nFG//imbx21Tp1LBshhr2UR0nX//+9+8+uqrzJw5s0hy+vc8cP/9BDWNkpZFy4YN/+smdy+//DKX9OvHHTNmHDXuK5WRwT1OgKGGiSvLTBg/nn379jF79mzGjh3L2rVrDzonlUod1tfkWHhw7lwyTZN+lk1Q1wu1p+++6y5CmkaeZdOqUaNDxks//vgj7Tt2IagbuF4fmaEQo4YPP2kN4k2bNqGZNpUG3EVupxHklip7UuNBwXO68cYbEQSB+vXrH3VtXkwxxfz9KU5QF/OX5rfffqNpnTrYfj/JUOiUatmeLDdNnEhFy6KsrBCTJM60Clq6fm9QsWnTJgKqyqpYvLCS92j8MUD46aefqFqmLHl2gY7ZAdOIHTt2UDKZpIUbIODxIIkiOfF44e730qVLqWg7rE9XVjevW5dRV1yBVxTxiSK6x8OUKVP4+uuv6duzJwFF4cG0JnJrvx9PWjpBk2UsRaGa46CKEqMtm466gaUoOLLMrbZLC9th1MiROF4vsiDgiCJG2tQw1++nRvnynNetG701nTcjURr5fOTXqEHYsngqFOHjWAJTFLnSNFEFkb5pbeXxlkNVxYPu9RL0eomIIpIkU/OqxdS88jFkSUYXBMopHsoqChUUhV6aRv3q1YmYVkH1uCDQ1OdjfjBEUpaRRZGrTAtNEDhb1bjDDaCJIg3y84moKiUMg4EXXgjAFUOH4voKJFRKSzL3B4JUM0w0SSJPVgplWCoqHmp7PAw1TKp7vHhFkRrly7N582aqly+PXxCorBRUXuckEtx333089NBD/Pzzz3hkmc/iST6PJ1EEkYgk4REEHggUbEpYoki50qVZtGgRQY+H250A+V4vMUmmQ4cObNq0iVdffRVNlgmIEktDEQboBiUUhQnXXw/AiKFDyTFN6rsBbMXDi+EoV1ouZrIsZc4dj+pEMfx+3n///UO+Jzdv3kzMdWkdChHWdYKWRUCSuMwwCYoiww2TkabFiHQnwOLFiwkkc6lw4a3EKjdl8NCiHQJ1KlXiLjdAL00jU1ao6PGgSzKzj7Hy6MDn5Lxu3QreG4dINN8zcya2309AVRn0Oz3mdevWUa1MGVxdZ3RaW/tYrjVs2DAEQeD8889n79697NixgzfeeOOYuiy+/PJLpk2bxoIFC47pes8//zzhnPLUHvMM5c67mVLlKh71nD8yd84cKubk0DS/TmEV9gFKla1A1hn9yDt7NKbtHrKd91SwYcMGDNuldPdxJOudRZMWLU/Ldf7bfPfdd7Q7szN5ZSswdeqtf/Z0ijlNFCeoi+Pv0SNGoHk8WH6VRx999M+eTjHHwMaNG8mOxYhoGpXy8gp/oz/88EOmTp16zFJix8KDDz5IvuOwJpagr2FStWxZJk+eXPibum7dOsZccw333HNPYaLwlsmTaWDbPBEKU8njYbzlcJ3t0rZp01M2L4CPPvqImK7zdCjC5bZDywYNDnvsLbfcQgPDZHk4SiOvj8Z+P2e1aXPIYz/55BMq5OQQt20mpmPMI/H5558TUVVudwqKHC50XG655ZYix+zfv5+nnnqKhx56iF9//RWAUskkT4TCrInGydR1li1bdhx3f3K8//77hHSdMZZNNdtm4nXXHfH4kGXR1Oujp6YR0TTWrFlz2ud4dtu23Jo2M7/gD890/fr1vPXWW0fczL+0X3/OMkyeC0copSiU1LST9rv4+OOPsUNxao1+gkoD7iQYiZ3UeL/nkUcewe/3k5ube8iE//Hy7bff0rlVKyrl5HDrH96PxRRTzJ9LcYK6mL80c+bMobHrsimeZKzt0K19+z97SoW0rFePs1SViCRRz+ujksdDFdc9KFE2esQI9LTu84KHHz7seHv27KFr+/bIkkSlvDw2b95c+Nru3bt5//33i2jsjrvmGhxNIzsa5V//+ldhdcEvv/zCjz/+yL59++jRpQs+RSEWCLBy5UqmT59OR9vhsWAYSxQp7/FgKAorVqyg3wUXkKMoXKIb2KKI6/Uy0w2wIZ4kT1ZYEAzR0jSpVakShqKwOBjmVseljKIw1rLp17s3n376Ka2aN6d0MolfFFmYlrXI0XQee+wxcuJxTK+XGhUq8Pjjj9O3b990ElkskBNJS39YoshgwyQpy8x0A9R3XTq0bo0hiKiKl1LdxlKq6zUoihdbValXrx45qsrGdPVwvcqVkUSRWW6AbEnmVsfli3iSDn6VsG1TVvHQwa+SlGXWxRLkyQpeQaCVz09QkvDIMtu3b8enKKyKJfgklsAjCFT3eIk7Di+++CJRw2CwYfJKJEpckmmQNn48U1XRJAlbVZkwYQLPP/88s2fPJsOycBSF6hUq8NNPP7F+/XpGjRyJreuMNS0apU0kaygeOvr91PZ6qaQoJCSZLrpOzHVp3rQptijSwOvlHFWjdEYGANeOHk3I4yGQfnamKNI4P59NmzaRl0ziE0VMWeaKK65g1IgRlLZtznADBJwAlWvUpvd5fdi4ceMR3+9ff/01CxYsYNWqVZSIRhlsmAwzTDyCgCGKJDWNBQsWAHD77beTqNGK/LHLyOlwGe3O7FxkrFdffZWgaaIIAqticTbHkziSRNvmzY+7O2L79u3s2bPnkK99++23hZ+jVCrFggULmDp1Klu2bDmuaxw4/7rrrkMQBFq2bEkoGieSUw4nGObjjz8+7vGOxIcffogZiFCx33RKNOlNw6bNj+v8DRs2ENQ0Hg2GGWnZVC9fvkhVl1/TqX75fGpf8zRWMFooBXOipFIpJtxwI1Vr1uGSQUMK9bWXL19OJKc8+WOXUbH/jOOScPkr0+2cniRqt6f8BVOxw4lDVuHv27ePAQMvJZmVS7dzehYuuov5+1CcoP7fjr83btxIUFVZFUvwROj/O+D+aezdu/cf1ZUy6KKLuNR22BJPcnbagO69994jqOv0cQPEdYPFixefkmvt3buXnl3OwqcohFSVM0yLM22HOlWqsG3bNiJpiYfatl1o7j744osZmdYqHmQUxEGZ0egpjyOef/55qrouW+JJHg2GqZSbe8jj3nnnHXLjcQxJwpUk/JJE1TJl2LBhA/PmzePWW29l27ZthceXjMW42rRYHAqjiWIR8+1DcX737rRQVfJkhctNC8fnO0hGYlD/iyhv2zRyA9SpUoW9e/dSt3IVLjctYpJElqIQMs3/mkHy3XffTfdggUb2fW6Q1g0bHvbY7777DtvvZ4JdIENoiiKdWrcu8pnat28fq1atOuEuskNx8403UsO2mWy7JAyDl19++bjO79SyJbekE9ydVJWmPj9XXnHFSc0plUrR+exuWMEYmmkz8xTLsb3xxhs4joOu68dc8HE4zu3cmT62w5JQmBKmecpMvYspppiT52+RoBYEobUgCJ8KgrBeEISrjnb83yFA3rdvH7NmzWLMmDGnTbfzn8C8efOo4zhsiCcZbjuc27nz0U/6L3HD+PFYksSL4QLphDxFQfN4mDp16kHB/o4dO47ayvXggw9SxymoeB5kO/Q555xDHrdixQqijoMmiPgEgaAkUbtSJT788EPKZWWhiiKyKDL4kkuAgoT1/v37mTJpEqbPhyVJNPJ4GZlu57tQ16lQujS7d++mcrlyGB4PlqpSpVQppjgun8QSJGWZaY5LJdtmxIgRRFStUE/alCSChsG9995LyLKQBIGmXh8RSWKgbjAzXaHc97zzaNGsGbWqV2dg//7kWRbtAwEyIxEGDxpE27Ztqejx8FYkRhdVxRZFSkgyF+o6ptfLunXrmD9/PobPh8+voxk2l156KevXr+fHH3+kbHY2dQJBwrrOzJkzCes65T0eTFHEKwjoaT1uTRR5IxJjayKDLFkmKkp4BYGrjYLn0VfX0Xw+9u7dS8AwmBMIMiCdtK+ieIjaNtOmTePSgQOpXbEittdLJZ+P0oqCKAi4osgHkRh1vF5yPR7K2jaVypShsc/Ps+EIFTwe8qtXJx4IMMCyaWRaBHWdml4fT4UiVFI81PJ48AsCrijxSNq0s4lpcdlllxFUFLbEk3wSS+BTFFauXInq8fBuNM7n8SSWLDNt6lSWL1+OX1HIlRXejcYZoBskHYdUKsWiRYvITiRw/X6yYjE2bNjAlEmTiDkO1cqUOWKnws8//8zIkSMxxYJNhQ+icW53ApSMxUmlUrzwwgskSmSj+DTcZB6G7R7S5G3Xrl2UCAYZYVrc6rgEJAnL5yuyEDpeUqkU9917Lz06d+aeu+8uEryOvGo0wRKlSdZqQziWOCFDqBUrVhAIRRAEAUW1qHnV42Q06c2AgZee8JwPx223TSeZlUudBo2OunnwRwYNHkKGLLMlnqSVbuFRLQw7wHXXF5i3Dh52OW48i0huReo3bFLYtfHLL7+wffv2457rwoULCSRzKdt7EpGytRl77TgAfv31V0qXq0CsbE3scOIvYbxzKqhVtyGlu19bII9ToS7z588/6Jh7772XcG4lKl08k2iFBlwzZuyfMNNiTobiBPX/doL6QAfcB9E4i4JhksHgnz2lU86d06ejejwYPj8PnSZjXSjQOB7Qpw9XDBvGDz/8cErH3rdvH/feey/jxo1jw4YNDB8yhJ52wbqhpe0wbdo0JkyYwIB0UniS7dC7a9dDjrV79+4TSnr9/PPP+BSFzfEkW+JJdI+XRYsW0TBt7v5sOEL5rCwAVq5cWWCeHgoTMs1Cf4xD8csvvzBt2jQmTZp03DHLrl27qFOlChUdl5CmMWf2bH777Tf6dO9OXiLBpf36sXfvXirn5VHP66VT2uA8pGmsWrWKoRdfTFXbppvjkhOPF+okW4pCZ1WlntdLQBQZcxTT4t5nd+UKy+YOxyXb5+fKK6886BgrLYW4JW3iuGbNGtasWUNGJMK56Y7Kqyyb/uedx9CLLyYnGuXsdu2OS7t53bp1PP/880UkFbdu3UrN8hXwyDLndOpcWOywevVqgrrOUNOinGVxyxFMDN955x3Kp+X3/h2JEZYkKjoOzz77LFBQfHRGgwZkmSaupvHYY48d85yPxL59+5gyaRINa9SgeYsWLFmy5LjOf+mll3BVlXIeD7Yk42pakQ7gI/HCCy8QCEdRNYPbp88o8loqlWL16tUnVAhyNHp2OYtMTUMUBARBoHqlSie8udawenUeCBRsQjQNBgsLbIopppg/n798gloQBFkQhA2CIOQKguAVBOFDQRDKH+mcv0OAfMXQodS0bQZYNhHbPqW7qv8k9uzZQ5c2bZAliTKZmYd0Iz4UqVSKDz744LS2We3fv58KubkMMEzudYOookgTv0ot22bwRRcdfYA/MGPGDEr6/ZyravTTDRrUqHHIoLVSyZL00XTqer18EU9ylWkRNwxKJpO09vkpqygM0A38osjKlSuBgsAsrGk8FQqTpygogkBDr48Xw1FqeLyUSgfO+/fvZ/369Wzfvp1XXnmFjHAYRZIol5VFXjxBqYwMLFHEFkUsWcH1+xl86aVs2rSJOpUqcbsTYG0sQVyS8QkCcUmigdfHOMvGlCTyvV766jqmKPJ0KMLWRAZ1gkGee+45br75ZjppWoHRpGmhCwLnqhot04aGqqJg+HxMvukmPvjgg4P06H7++WeefPJJGtWujUeSKK8U6GU/EgxhixK3OC4b4klCksTZqsY4y8YviFyo6ZRQFAKSRA2PhxKKwrhxBQm2F198kYxQCFsUeTgY4ty08WQdn5+LTItEMMgXX3xB53btMBQFQRCwRJFlwYLKkg3xJOtiCfyCUOju3UfTcQ2DaunA6PVIDNfvZ0R6w+AS3UD1ernxxhtp0bAhZxgGUx234LmrKmUyM+nkONQ0TXyqjhHOQPb4uNw0eSgQwvT62L59OzXLluO8tCb2lniSybZL0rIAmDp1Kh3SFUZDbYeuHTsS0wuMD6+zHRpUq3bI9+i3335LbiJBtUAA3eslpiisjyeZHwxRPiub/fv3Y9oOZXpMoNx5N+FTdT7++GMeuP9+GlWvTvVy5TinUyfef/99HnroIbI0HVsUqaB4GGlaBHS9yEbOhx9+yLmdO9P/vPOO6TtywYIFlDRNbnFcSuo6iWCQzHCYef/6F9l5ZajYfzr5Y5cRL1PjhNpFY8kS5J01mmTDHgiCgBrOJly2DteOO3L7J8CTTz7J1VdffVTN65Pl66+/xq+bBKO5ZPk0JMVLzasep9pl8/B4vezfv59UKsXy5ct58sknCzWkH5w7F9PvR/d6GXOIBeSRuPHGG0nW6UT+2GVktx1E13N6Fr72008/8eijj/6jqlMWLlyI4QSJla5GZk7JQyb1x48fTyK/I/ljl5HZoi99Luz3359oMSdFcYL6fztBDXD92LH4FAVb03jyySf/7OmcUn766ScMn48VkRjPhwtkvk5Wg/ZQ/PLLL8QDAYZbNt1shxb16p3S8YcNHEgt26afZRNzXdauXUudKlWQJYnWjRvz66+/8vTTT5NlmNzuBKhu20z7Q0v/b7/9RsuGDZEliYolS7J169bjmkMqlaJCbi59LZv+tk3Z7Gy2bNlC0DC4yrJpbjv069Wr8PhNmzaxePFiBvbrR9x1qV6+PNVKl6Za6dJFfCFaNmxIK9uhi21TpXRp/v3vfzNx4kReeOGFY5rX7t27efXVVws7qK4fN46WtsOL4Sh1bJu77rqLnGiMcory/8UQrsuiRYvIDId5NRJlayKDqoFA4W94zC7wqTFEEUcUuf322484h3Xr1pEVjWF6vTTJzz9ksU6tChUYajtMc1yCpln4mzpz5kzq2TZvRmJ0tB06tmtHNdtmeThKJ9vhisP4pvyRRx55hJCuUzMQoHxuLj/++CMAfXv2ZIBtszaWoI7jMHfu3MJz3nnnHUZdeSXz5s074qbFb7/9RunMTFqrGhUUDz01nVKWzfLly4GCdUQlp6AT+KFAiGqlSh3TnI+F++9/ADeeTWbLAZiBCM8999xxnb9p0yYefPBB5syZc1gt8EMRjiYo02MCVQbdj2pY/5Ucxs6dO/HIMjU9Xm6xHRp4fQiCwDnnnHNC31uPPPIIYV0nPxCkTFbWaZO6OxL79+/nnXfeOekuxn8q+/fv59FHH2XWrFn0ubAfqmZQvlLV4y7aKebvx98hQV1XEIRnf/f/owRBGHWkc/4OAXKl3FyeSifomoTCPPXUU3/2lP7SHK6F/3D0792bEqZJTNcZO2rUaZpVwe5713btqF66NKVMk62JDJaHo5SMH7vZ2wG6tG1LK1VltGnhFwRyNY2rR4486Li8RIIhhlmYoL7CtGiSn49PUajp8fLwgSDT5+PudHvV+++/T5Zpcp6mc56m81E0TlKWsSQJS/EUMWXZtm0bFfPyUD0ealWsWCgr8vXXXyMLAqtiCdakJS8+/vhjvv/+e84/7zwims49bpDP4kkyZJmJto0uilxj2dTyeNFEkdfSlcshSaKbaTHdCRDUdTZs2MA333xDbiJBKcPAUVU8osj6eJLPYglkQeDNSIzXIjG0dJLtABs3bmTr1q388ssvXHXVVVT2eHk6FCEgSTwWDNNfN3BFkZtsh8/iSUpIEhUUBUuWyTdNPorGsUSR+wNBrjItMkMhLurTB6+iUD4nhxkzZlAvnTyeHyxIVq9I30eVQICJEyeSF4txiWESkCQyZBk1Xd1+m+MyyXZw0jIm1dLPof8FF+AaBjW9XiqqKq2aNiVoGDQJBgnoOu+88w5QYGRSPjubmh4vDwZC9HFcrr/+erp06oRjmMTrnkX+2GXE8juhihIlZQXN6+WyQYOImRYjDJPyae1rvyBy//33AwWbIc1th43xJH1thy4dOlDOdtiUbgU9UOnzR+688046pStFbrRsgmlZFp8osmDBAvbs2YPi8VB9xAJqXLkIr19j6dKlJA2DBwJBzvD5qef1EbFthgwaxAjT4plQhJKyQmYgwLPPPstF551HmYwM+p13HhHbZqzl0M92qFulylE/Q8OHDePK9N/qasumhc/Hk6EItt9Pxy5diVVqTHbbwZh24LiC8QOomkHVIbOpNWoJitdfsCFh2QdpPP+RefMewg4nSDbqgeEET2uydsuWLWimTbXLHyKr9SWIsofyF0yldPdrCYQih11oBQyD58IRPorGcfz+Io7zR2PdunXYgRAZVRpjOIFjXjz/nfnkk09YunRp4UL3j2zcuJFgJEasVBUsN1i4WVjM34fiBHVxghoKknz/JAmMA+zYsQPD62VlNF4YW52O+1yzZg05VsHv8qpYHMuvntLxy5YowXPhgvVU/VCoMEn3x6TV7Ace4Kw2bZg0cSKTb7qJAX36FHq63HnnnTR3HL6IJxlg2bRs0oSFCxcelzHfV199xdBLLmHoJZcU/n6uXLmSgRf2ZeL11xdKXx3gqaeeoqxl81o4iimKzHAC3OcGCRgGu3btYt++fUiiyMZ0VXbA78dVVQbYNgnDOCFN9Ev69ePKdLHERZbNmGuu4Y4ZM1BlmbAk0VLXKRGO8P3339OpZUvOtm2utx2ChsG2bdsKpO9EiY+icd5OG6K3bd36qNfdt28f33///WHjj02bNtGtQwfaNGzE66+/Xvjve/bs4cIePYi7Lp1bt2bChAmcaztsTWRwnWXTtG5dxo8fz5AhQ0gEAsQDARYtWnTQ+PWrVmVOuiikcSDIwoULATinUyfGpos1WrkuM2fOPO5nCvD9998zevRoQraNLIpc2q9f4b2uXLmSpGHweiTGWNuhSe3aJ3SNQ9Hr/AvIbjuI/LHLSDY8h7FjD92p9eOPP57SzSfTdqk08G5qXLkI/QTj6eMllUqREQ5TRlG40XIK1m4eD4Ig0LVr1xMynFy7di3Lli07yMj9v8H+/ftp0/5MnFgJDCfI1Gm3/dfn8Fen/4CBhLLKEilXF0U1qDpkLiWa9KJ9xy5/9tSKOc38HRLUZwuCcO/v/r+3IAgzjnTO3yFAHnjBBTSxbUaZFkHDKKI3/L/E3r17uWXyZC46//zCQPFk+eabb7B8PtbFEnwYjeNVlGMKurdv3164C7xmzRpeeuklfvnlF+666y6uufrqg5y5N27cyKOPPsrGjRvZtm0bpt9PXa+X2prOuZ2P/8szKxwprFao5vFwk+0Uasb9+OOPLF26lE8++YRHH30Uy+/HkmUUUSRkGMydO5fLBw0ioHio7vFyrWWjSRLz58/nm2++YcWKFZzdvj2OojDcMNkST9LRdhg6dGiRNqxffvmFXueeyzmWxZZ4ki62zcSJEwufq1cQmWK7NPH50AWRjz/+mNJZWdiixJl+Pz5BwC9JlE23OnZVNTRBoLemE5ckmvr8XGaYqKLEed2707ZxY5YuXVp4/V9//ZV3332X//znP9StXp2AKBEQRfyCwIpIjEXBEIai0KFZc2655RZipokhSvhlGVVR8IoiWZLMtZaNmdZizpRkHEkiJElIgoAlSbgeD127diWo6/TVdMKSxOZ4kjcjMQy/nwq2zepYgqtshzZNmhBzHGp5vUQliZgo0cTnY4hh4qgqmYZBnqyQ7/VyfTpwbuP3E/V4iBkmJWSZdn4/ZRSF8mXLct999/HBBx/g+v10VTUSXi833XADU6ZMYcCAAXzyyScAjB01Cq8sY3p9lNE0bnVckobB1KlTyTZNztEM3JI1qXbZPMK51VAEkRfCURRBoI2mkynJGGJBotwVRVRJKkx8//bbb1QtV75AOzoYZMOGDbRq1Ihs08LVtENKFgA8+uijVExXr3RRNbr7VWa7QaKqxr///W8Arhx1NYYbwgpEuPiSQdx33310Si8MZrlBGvt8lLIdHnjgAUK6zgVugLCu88ILLzD55ptpZNs8H45SzyrQKtwST/JxLIHm9RaZyxNPPEHvrl255eabCz/fL730EhFd52LbwRRFbnNcPosnCaoq5XJzkWQPyWRmkQqlQ/HJJ5/w7rvvHhTQ33jTzeh2ADsU55yevXn++efRdZ2SJUvy+eefH3a87j16kdNuSMEiokE3rj+CsdCGDRsO+q45Grt27WLNmjWFQfblI67Arxn4NYNLLhlENFmCzJw8Xn75Zfbv38/DDz/MHXfcUcTgMWzbLAmFeTsaw/L7j1tqZfPmzcyfP/+/Yg70d+E///kPL730UnGH1N+U4gR1cYL6n85NEyeie73oXi/3nGBy7mjs2rWLUiVKcI7t0Mh26NahA1Bg5H377bezadOmkxr/wh49OMO2GW0VGIkfSA4/PH8+EdsmEQwWqX6/euRI6tg2Yy2bkK6zevVqbr/9dto6BYnKIYZJhtdLTceha3qup4O5c+fSIhBgQyyBIgisiSX4LJ7E8HoL5TxqV6pEb9vmUtshbJoMSBfC3Gg7XHAYGcAPP/yQHl26MPDCC/nmm2+AAsPECRMmMG3aNEKmSX4wRMx1efrppwmZFrUCARxdZ9KkSYW//Tt27GDYJZdwbufOvPnmm0DBGsEvyzwfjrIkFMYrCDSqWfO0PaM/8uWXX5IZiVDW50MVBFRRpI9hUt7joaNfZUkojOb1UrFUKQyfjz7nnMPevXvpfuaZ9LUdngxFKGGarFixovC5xFyXuK5TM+0PcyT279/Pxo0bi8iE/JFDrTcnXncdYcuiWpkyhTH+qWD+/PnYkSTJxr0xnOBB6+g9e/bQoUULVI+HmOty5513nlAi94/cM2sWqm6imTYXXzLopMc7VlatWkX96tWxvF4USWLghRdy8803I4oi+fn5JyUReDJs376d119/vYhP1NFYtWoVdjhOraufovLAe3CDkdM4w78nlhOg6rAHqT3mGbx2mIr9Z5DbcQQNm7b4s6dWzGnmH5OgFgThIkEQ3hUE4d3MzMzT8rBOJbt27eKGCRO4+IILC5NG/4uMvuIK6tg211o2wXSgeLL88ssv2KrKI8EQs9wgkbTu7qFIpVJ89NFHTJk8Gcvvx/b7adWkCRFdp4rrUiIYpLZlMcCyiToO3377LUCB4Yph0CoUImgYTLz+ejI1natMi4DXWyTpeii2bdvG+d27065p00Jji0v69qWWZXGuphMQJZpbNmd36EDdKlWxFYU8TcP1+bjhhhvYsWMHrZs0oaSqogkCGR4PAZ8PR9NQ5QLDvqGGiaPrBA2DpKYR8npp0bAh8XQwVqV06SJagF999RXZsTglVRVTFHkuFCmSoAbodOaZqKLIZYbJ5aZFTjyOLAjU83rppRUke8/q2BHH5yNDlrFFkTxZoYrHwxjTwi9JVK9YsbCC9Mknn6RJzVqc07FjYRLn559/pm+vXgQUhYQkoYsiWlpH2pRlupoW02wHvyhynxvk0UAIRRB4NRLlvWi80LTviWCYy3QTS5a5ZMAA8hIJfKLInECQu90AflFkwoQJhL1eSkoySUnCFiWaN2lCftqYc5rjkl+xIueeey4Jv5/ufhU1fb9VPR5cTWOMadHW78cWRWqkNbSreTz00XVa1K+PJkkMNUy6axqu18ug/v259dZbKen1Uk7xUEKWCakq9RyH6pqOpSjkxGLYXi8PukGqeDxYokjD2rW5ddo0HnjgAdoHgnwWS1BZM5EVLwFfgfSILhVUUduiSDu/ykDdwBQEDEEgJIq0SBu9vPHGG8QNg9udAI3SbZLr16/n/fffP2LlbCqVYuSwYeREo+REIpT0+QmmzTYrlixZGPiuXbuW1atXk0ql+PLLL4m5Li11A1eSqKXplM3OZufOnbz77rtMnTq1cPFz2eDBXJaugB5sWsTcAG0dl3zHodfZZxfO44033iCmG0yyHWraNjeMH1/ktRtuuIFLL76YkKaRYZhUyM2ln2XxWTxJI8dh1qxZfPfddzzxxBMHVT9PvHEShhPEiZag89ndDvruWL9+PR999FHhv7/55pu4rksikTjs99fMu+8mkCxJVuuBmIHIYSuMrxk7Dt0OYDhBhlx2+WH/Dr/n+++/p1xODjmWRcx1C+fw3XffFVb3plIp7p45k369etGqbTtC2eWIVWlKNJ5RWPmyePFibE3D7/Fwy003HdO1iynmn0xxgro4Qf2/wI8//njaKwi/+eYbJk2axJ133smuXbuYNmUKuaZFd9cl6jh89dVXJzz2zp07GX/ttQzo06fQfO/XX3/F9Pt5OhRhUTCMo2ns37+fvXv3kpeRQSufnyWhMJ1CIebMmcNPP/1EnSpVsH0+VFHktXCUDfEkiiQdVPn8R7799lsa16qF4fMV0TE+Gj/++COVS5WirONgeTyU0HRKWhbnd+9eZOzLBw9m0EUX8cADD1DCMLjZdqlo2dw5Y8ZBY/70009EbJtemk51n49q5cqxdu1agobBRZZNSdNi0g038OKLL/L9999zSb9+hYaN/dMV1UfjhgkT8KYNzZN+lck33nhM93uqWLFiBVFVZYbjku/1sjWRwXPhCLmywg3pzs1cWaGax0MN2+Zf//oX27Zto0OLFlTIymLalCnMmzePy4cO5ZVXXuG3337j888/L5JYTqVSB/3dd+3aRdM6dYjqOsHfJbk/+eQTbr/9dl599VUAfvjhBwb1v4iubdsVqQY/XSxZsoQrr7zqkGaVCxYsIN9x2RhPMsa0iXu91KxQ4ajv6WPh+++/P24pnFPJ7/9eixYtQlVVsrOzT0ke4Xj44osvCEcTRHPKYwdCx2zkuXXrVnTTocKFt5LTfih5Zcqf5pn+/civ15Bk3c7ktBuC4vVjBqKYTuC0SyUW8+fzd0hQ/yMlPoopoHGNGvwrUCBJcSBQ/CMrV66k4xktOadTp2PWHVq8eDGlkkkq5OQc9osslUpxTqdOlDBNNFFkkGGwJpbAkCRmuQG2xJOU9Hi4OV0VWy8UKjR7u2zw4ELN4MtMi2ply3Jj+rjBpsW11157xPm1qFePvmm9tYCus23bNvbt28d9993HgAEDOKtde6656iryK1XiastmcShMQJKYZDkEZJl58+YhiSJJWU7LJni53DB5NhxBEQQ+S1dimJJEP92ghCwzPxiig2EyoE8fNm7ceFDr4qRJk+iZvoerTAs9bb54QAtu165dxAMBfILApniSL+JJ/IpCwOenRbqiWBVF7rrrLkZfeSWGUKBV3U/XScgy5XJyWLZsGR988AFr167liy++IKjrzHKDXGQ7tEonTwf06UM70+RW28UrCHwcS7AyWpAIz4lGeTYcYXM8iSwIvB+N82k6Kf1cOMKbkYKWw4Ao4qarr32iiFeWsTwePILAurREiSIITJ8+HdfrxRJFGvl8jDItdEWhbrVqRDQN2+8nomr0dANYXi+WoqCLIpvT96+IIgFFoaXPz8PBEDFFwSsIVPT6KKEbTL75ZuK6zpa0FrUsCNSxLPr3748uinyerg6WBIG3w1EsUWRJKMwDgWC68lliquMy0rTQRZGQpjHwwgvJjEZpGgxiiBJ2WhM8J5GgZtqxvaLiYV4gxBfxJDFJwklrBfpkmR07dnDXXXdxlhtgTSzBcMNEk2WiWkFC/YAm8dHYtWsXcdsm4dPQfRpej79QQuSPfP7550ycOJFRo0Zx2223Fanc/T2rVq0ibFnUC4UImSb33nsv06dPZ+7cuUXer7fffju93QBbExnc6Qbo2OLQu+nr169n1apVnN+9O1em2zjbOW6BPnAwSG3HRfV4uOyyywqDXc2wCmQ8Rj+B4YaOSfd+1apVxONxgsHgITccU6kUs2bdS58L+7F48eJDjlEgj+Kl+vCHqTHyUbx+7Zg08aZOncpZBz63ls2FPXocdMwFffrg9+tkqgayx0fVIbPJH7sMfyCB5QQKv1cPLOCLKaaY4gT1ifxXHH8XcyzUq1yZ+Wk5ujahEA8//PApHX/79u3oXi+r0vGjT1HYs2cPo0aMoLqmMcq0MEURR9MKN6l/v6F+ne0w2nbITSSOapo4eMAAets2q2IJ6ppWobTesbBz507eeecdvv76a9566y1ef/31wut9+umnLF++nJ07dxYe/9C8efQ6+2xm3H77Iee1Zs0awqpKXJK5SDfQRJGrrrqKDrbDJNthhGHRplGjwuMPaFK/FI5SN61JDQUdUS+//PIhNy4ef/xxmtevT4P8fO65557jNpVMpVJ8+OGHJ5xI/Oabb3A1rdCb5RrLprmuY8kytiTxaDDMlniSyh4PtXWj8J4OcNcdd1DGsrjStAjrOm+99VaR199++21igQAeWWZAnz5MuekmsiIRyubkkJ+WwpvquLSs34A33ngDW1GIyTKu18uCBQvo2LIl3dPPO2gYJ7X5cih+/PFHPv3002PqDF6wYAG10wnqa9LFNBUd9x+Z4Hv77beJxWJYlnXcWtwnw7XXXksi7cFSoul59B9w8TGfO2fOXBIlsilXqQoffPDBaZzl35Ovv/6anuf1oU37jrz++uusXbv2T9EKL+a/z98hQa0IgvC5IAg5vzNJrHCkc4oD5L8PN15/PRUsm0vSUid/rGb87bffiNgOE22Hy2yHSnl5p+zan3zyCTFNZ0M8yfJwFFeUeDMSQ5Mk+psWi0NhHMVDvmEw0rIJmWZhle/06dPJt20eC4apaVrk16pFtqZztWUT142jSggkAgFej8TYEk9S3nF5++23D3lc9u8SsrmyQuu0hm/7pk1xvV66qxqX6AaGKHKX47I5niTu9VJSNyhr21TIzaWOqtLOr7I1kcHdboAWdepwZqtW5CQSjB49mlQqxWOPPUbHjh2pY1q8FYnRxXYYNmhQkcBz06ZNhFWVhl4fjX0+anq8tGzYEEdV0dOGKVHFw/PPP8+uXbuoXqUKbfx+tiYyCvSH69alzznnEPT5CMgyVcqVo3I6ofpcOELCcTijXj1yw2EeDIRYF0vgEwSWhiIsTJsO1q5ShTKWRcdAgLBhEPD6cEUJTRDwCQKyIDBtyhQybJvbHJeqHg93uQE+jSUKkuSKQkSSiEgSjs/HsMGDaWdZ5KRbFrcmMqjk8VC1cmVmz55Nq4YNmZlOhHYPBKlavjwlZIXmPj91vT7qVatWaA65NZFBJ8Oke/fuTJ48mWeffZa9e/dSMS+PjrpBRVnBEEUUQSDmONh+P7PcIJPsguqZc00LQxT5NL2gkgQBUxTZFE8WJtRXR+OYXh/r1q1j1KhRqILAhniSd6NxFEEg4PfzRChMY5+PoCRRS9PIlmU2xpPc7QawZZndu3dzx4wZeEURnyDiSBLTnQCb4klquu5hncBXrVrFLbfcUljtDFAqO5twpeaU6XUDPlnBI4pc0KMHb7zxRuHC5uuvv6ZEOExcVUkGg4Wf8Y8++ogmtWtTp2LFIhXF27Zt48orr0IzbYIZJaleq85B1R4ff/wxQd1ggGWT4fdzXq9eR6wIWbt2LclQiIimUaN8eW666SY6WTaR9AZOFZ+foRcXBJUZWTnkdhpB+T63oBnWYZPpf2T9+vXk5ORgmmahOc7xsH//fnTTJrfTFQTDmRiSxIyjmA8BzJo1i/q2w6pYnJ62w9CBA4u8vmXLFjx+jXLn3URm8wvx+TTCVc8gu82lKJpNtHpLJk2adNzzLaaYfzrFCeriBHUxp4dL+valte1wq+MS1nU++uijYz733XffZfr06YdN6LzyyitMmjSJ8849l6Cq4qoqN6ZltepXqcKCdGK8pWlx4yGqfz/66CM6ntGSs9q04dNPPz3qfC4491yusmy2xJO09asko1H27NlDKpU6qrne4sWLC5OFo4YPx6coZMdijL/uOsK6TmXXpXalSkWS1Edi9+7dxAyTSelN6wGGSe/evVFFkY5+lbAk0bFt2yJzOL9bN0rG4wy88EL27t3L888/T0DXqR4IUKpEiUK5ESjoGIvpBrc4LvVthzFXXXVM8/o9F19wARlGgUfQ1VdccdznAzz99NPkV6hAfpUqdO/UiXFjxrB27VoaVK/OCMvmmVAEW5KIBYO89957Rc7t2q4dtzkFXip9HZcpU6YUeb1BtWpMc1w+jSUoaRgEVZXnwhE6azq5Xm+h/F+nli3Jr1KFHprOklCYuCTTtG5dsiMRXk6vJ6oFAoWV1aeC119/naBpkjQM6levfpBcx0svvcQdd9xRKDm3Z88eOrZqhUcUcSWJm2yHoKYdUZLu78ymTZuoWLEisixzzz33/FeueeeddxLOq0aVQfcTq9iQsdeO+69ct5hi/sn85RPUBXMU2gqCsE4QhA2CIFx9tOOLA+S/D6lUinnz5jFmzJhDBqibNm0iomlsjidZG0vgkeXj3q3/I/v27WPevHlMmDABXZZZFo5wm+NipGUkGtWtS4t69SiflcXMO+/khgkTuLR//yLB8N69exk5bBiVc3OxPB56uC62z8eZbdvyzDPPHHUOVwwdSnnbplUgQMW8vMMGn3fcfjsRXaek348pitRSPDQyLUYOG4YkimxIm6eYoogk/B975x0lRbW97UodKlfnNIkh55wRkKxIlCRBMoIgSlIRRMwRVBQEFcQMGNCrVzDHixEVRFERUMAAiiI5zPTz/dFtf45kMP/6WYu1lK46daq6m95nn73fVyDoctOwRg2WLl3KSy+9xJYtW2jRsCGaJNFUN4joOmUKCtBEkZ6qhimKdOvalTKWxVDTwna5CJkm7Zo14/vvvy/xrIuKiqhTuTJtbYeyqkrNKlXYvXs3HlnmtXCERwNBvKKI5nLRvkUL3n77bcK6zrW2QyPb4fxzz8V0u8mXZeb7A9RzuQioKrXdbsJpKY+JpkU1VSXsdtPOMHELAqogEpEkGni8XDRuHE8//TR33nknW7Zs4b333sOrKNxg2XgEAU0QqF21KjXKlWOsaVFFcTHb5+fzaJyYLHOJYVLK46VRw4asW7eO4QMHcaFlM0Q3qOZyMVDTUQWR4bpOTNfp2bUr5bwqlRQXPpeLxx57jM5t25IXiXD22WdnFhgBVaWJx4MjisQ1rUQ10Jo1ayiVSL1HFRWFp4IharvcdOnShfqVK9O0dm1eeOEFhg8cSEjT8Kcrno10tXYVxUW+LNPG4+WZYBjT62X79u08//zzeASBhYEgt6Q/v5Xy8wl4PJRWXAzWDLyKQp6q8VE0zlW2Q60KFYDUBskNtsPjgRC2JDPJdvgoGqe8ZWW6BH7N9GnTUEWRZh4vAZcr0+kwefJknLL18PtizPcH+CwaJyhJlLEsCuNxNm/eTNPGjemuamyK5zDKMBk+eDDFxcXEfX6uth3u9AUwPR4ef/zxzOetbMUqVDz7eupduoRQQcVDzundd98l7PfTUNNpajt0a9/+iN+5vXv3smHDBoqKili8eDG5mka9X7WHVsjNZdOmTbz44ouUr1yVRH5h5n3cv39/CTmcw/H1119TqVIlPB5Pxnh00aJFnNmzN9Om3XxUk5qlS5fiuD1MMC2eCoYJ6/pR9Qr379/PWV26Ynq9nFq//kEJ9eXLl2MG49S79BmqjpiDpHgoV7Eyqj9OqY7jCORX4MEHHzzqvf1VFBcXM2fOHEaff0GJzZEsWf5osgnqbII6yx/D7t27uXDMGLq0bVtCH/povPTSS4R0nX7+AAFdz8gs/MIzzzxDVNcZZjuEdJ1FixaV8FmZOnkyNSyb89NFMUfrkEomkzz//PMsWLDgsDIoq1atQkv7nASkVFdbl44dsVQVR9NYeIjq8H379lGvalUa+v0UmCbDhwwh1zRZEYkxzfER9Hh4JF0JXNvnO2pF6IEDBzh38GDKxOPUrVaNCqrGjbaPXMNg3LhxnO6kEtb3+gM0/5Vm9K5duw6Stzi9WfNMAvd0v79EZ9zs2bPp4Q9wve1giyKOx8PoUaPo1akTDz7wQOa4r776ioceeuigKukffvgB0+3ms2iclZEYbln+Xbu21q1bR9M6dcgLBjHcbtoFgwR0I+ORAjDzttuoaFlMTFdQ/zauaFCtGrN8fr6IJSijG5Q1DDbGEjzkDxC3bNyKQuXCQtasWUOtcuWYl/ZYaejx0LN7d8aPHk1V26aLz0dhPP67yue0adyEm9PFSI19PhYuXMj69esZO3o0nc44gxzDoJfPT8iySnQcr169mvYtWlC3UiUWLVoEpIpHbrnlFhYsWPC7GigejpNdux8rP//8M+3atUMQBCZMmPC73VtxcTFXXn0NLdu25/aZMzP3s3//fvoNGEQ4lkPnM3uwa9eu3+V6WbL8X+YfkaA+3j/ZAPnfQ3FxMU1q16aZz0dNx6Ff9+4nPeaw/v2pZdt09Pkw0/IOjihykWFS6FUPaxB3KK6++mqGpfXbLjEt8gMBcoNBpkyceMQf42QyyVNPPcX8+fOP2q7yySef8NprrzFn9mxaN2zI2FGj2LNnD+2aNaO1bdNR1ciTZT6OxMjTtEPu1m/ZsoVFixYx7oILMCWJEbrBpngOV9kOfpeLu32pAKu730/tSpUwPR4MlwtZkqhTqXJGl/jbb7+lab16lI3FuGrqVIqLi3F0naeDYZp7PFxm2ayPJahtmJxzzjksXryYft27c93VV/PDDz/gdbnolU5W3uL4MAQBTRAZZ1jMcPwERZF2bg8Br5ce3brRt3t3Ah4PqizTqnFjVq1axbx580oElCMGDcItCIQkiatth3KKgioI5Moyctq00S1JNKxRgxb16nHxuHEZjcCPPvqIoGFQIMu40hXYOZLEONNiimkRME3iHg8zHR9l3G5aNmvG7t272b9/P6+88kpmU+Wcc86hnVfl/UiMa2yHwX36ACkjzYBpoqd1u6+1HUKSRD2Xi3gkkqlMuf+++2jVsCGGJFFFVphh+yhn2fTr14+Qy0ULd8qU0lFVHkonE5PJJGXz8zHSZpAtPF66tmtH3O/ntXCEjbEEFWyb3meeiVtRKJ1IZLST/R4P+bJMRJLwCgK6JKEIArbLXaLd8euvv6Z6uXKIgkALj4dN8Rzm+QM0rFoVSOmFuzwauihyty/A6miciCSxJBimu+PjlltuwdF1TvV4+CQap7NXJWgY1KlcGVkQ+CgaZ30sgSHJ2JFcJl6S0j9s0rwFuaeeTZWht2P6w6xYseKgz/SaNWvIMVOGn59E46gu10HHfPfdd7z++usHGd8kk0nGjxmDJklcZFq0sCyqFBZiKgpeSeKsXmdlvr9vv/02IdvGcLvp3qHDUdsqf/jhB+rWrYssy0ycOBErEKFUhwsI5FfkppumH/FcgAq5uTwZTC1MqzhOxvTmhRdeYOg5w5kz5/haag8cOEDDJs1w4oV4TYdR553Hrl276HP2AEqXr8T4Cy/+UxYnJ8pll19BIL8iOc3PxrB9v6vBUJYsR+LfnqAWBKGdIAifCYLwhSAIFx/idY8gCAvTr78tCELB0cb8p8ffn376Kaefeiqn1qv3r2yD/6czatgwJqdj7rGmxYXjx5d4fcSgwVz2q9cvvuiiEq8XFxczd+5cLpow4Zha6idfdBFlLIvmfj81ylc4bKdW6dxcWrg9rIslmOH48EgSL4RSHZCGx3tQEvbdd9+lnJ2qun41HCFoWpSzbdbGEtznDxBWVc5Pm/oFPB4GDxrEp59+mrmHu+++mwvHj89UB99xxx00tG1eCkVoZVl0OO10+nTtykMPPsg777yD7fHQ2uOlrq4z+pxzgNTmddCy8Hu91KpUKZNYG9ynD31th+dDEQo8HqqVLcdDDz0EpOIun5aK+V4KRbjTF8CSUlJ0eabJnXfeSd8ePbDcbtr4/DgeD+eff35mnbNjxw50t5uFgSDz/AGClnXCicuioiJeeOEFXnvttYPGuGTiREalZRgvMW3OHTIk81oymeTee+/l/JEjD9nt+sADD+BoGrrbTa8uXWhYowYVbAf/b4pPAB555BF8Hg/VvSoR22b9+vU8+uijXHHFFdx+++0Z36LfizNPO42xtsOKSIzKts3jjz9ObjjMcMsmX1Eya7kz/QHuuuuuw47z888/kx+N0sPxUd22GTfqjzM6/Omnn2jQuCmyrNCsReuTTtjv3LmTzm3b4tN1urRrd8iE8IEDBxgxYgSCINC1a9fjThofOHCA66+5hn7du2c8pW65dQaBgkqU6TYJX6yARx999KTuI0uWLIcnm6DO8rdn9+7d3HfffTzyyCPHpLkFqcTU0H796N6+/UGasAHT5N1IjE3xHMqYFj5dx3G5iBkGN1x77XEFS08//TSlTJNZPj8xl4uhhskroQg5bvdxVYUcjuLiYh555BHuvvvugxLZu3btYvr06aiSxHTbYU00TkySqV6+PC+++GImCPjhhx8YeNZZtGncmDI5OYw3LAplhdk+PxUVF4WyTE2Xi6ttB8vjoZplsT6W4CbHR2O3h3NshyH9+gEwctgw2pkWjwVCFGoapqpieL3objemJDHZslkXS1DZ5aJa2hX7l8B89+7dnNm1K6oo0lZVsdIJZE0UWR2NszQYRhYEXGm5jqCicGanTtSrVIkxI0fR+8wz0SSJdrpBVNe57LLLWLRoET///DOm10s/TWdTPIfbHD9hUWKOz48uilxp2fSwbE5r1uyg57tixQp8mkYnTcMnikQlifv9QSoqLlRBQBEEOqgq5RWFrqpKU6/K6aeeSvP69fErCmJaF/uee+4hbhhMtWzKGCYDzj6bIX370r17dwLp6vbPonE2xBIYoogmCLRWNTq3acO0adPwuVz00jTqu1y083gx0rrShighCgJ+SSIiSphuN0uXLuXi8eMZOXQon332GcMHDcbyeqldsSJr166lSd26uNLu5iHHx5YtWw6SavF5PKyNJVgeieESJTQnwoP+IFdYDr06d84ce+6QIQxNS9n4JYm5Pj+VFIXa1avz448/sn79ekxX6ln9IrFS0e3m9VCEmrbNddddh60oFMoKnrR55UzbRz23h5qKizxZpkBxESldiyrDZxNNpAxu161bR92GjYnlFnDLLSVlLl588UUa16hBq8aNCTsOEyybvrbDKb/5d/+tt94iYBjU9PspiMYy8jy/5v3332fEoMGMGT0anytV1bM0FEaVpMz3t3m9ekx3fKyNJajqOMfUIbF9+3ZOPfVURFHEKVWd+lOWUthxLJ279TjquXPvvpuQrlPZcWhSuzb79u3j7bffxnAC5LUeSiC3HDceQ6L71+zfv5+XXnrpH6lx16BJM8qfdWVK3692a+65556/ekpZ/o/wb05QC4Igp7sSC38ln1fpN8ecKwjC7PR/9xIEYeHRxv2nx98VCwqYZDvMcPz4DeMPNw/McnzcOWcOVS0rFb9a1kHdP3PvvpuKlsV0x0cp0+Sxxx47qesl/IHMhn9FxzlIr/gXHnzwQYJyKkHYVNfxSBLvR2K8E4nidbkO8vb4+uuv8es6c30BzrcdmtSqRfcOHVKSJJrG/PnzadWoEVHDoLTXy7mmRdi22bx5M1MnTaKGZXHBr6QRL508OVMsc6FlM3Lo0My17r7rLgpUjQvTXZK/SJB1aNmSsopCOSUlPzd82DAgtWbo2Ko1QVWlisfDXJ+fqGHwwQcfAKlOL7/bzZponJfS3imb4jkMMi0cVWWMaXGGV6W1x8vVtkOh2021suXYsmULA/r0oVBVCUoSliwfVlLuaCSTSbqdcQaVHYfSlkW7li0J2Skz+8WLFzNv3jxq2DaPBEI0sm1uuuGGYxr37jvvJKzrVLGdjJngvn37ePPNNzOG0r/l008/ZcmSJWzZsoXq5cpzij9AvmlmZGV+T9avX0/NChXQPR5GDhnC6tWrKbBSifjBukFDt5vbHT+xX1WNL1y4kBHnjuLpp5/OjPPqq69SO135/VIoQmE0+rvP9RcmXjKJWM1W1J34JJEqp5y0pNzVV13FabbNh5EYbW2ba6+55pDHJZNJpk+fjiiK1K1b95BrgMNx2SWX0MC2udZ2COs67777Lv0GDCK/3QjqT1lKoklPpkyZclL3kSVLlsOTTVBn+VfSrG5dBtkOV9kOQcvKGP0BtGzYkLNthyssh5Bl8fXXXx/U4nY83DVnDh1btqQgEOSOtLlifbeb09u0Oen7GDFoENVtm7Y+P9XKljsoyN21axeKJKV0mNOJzwqKgilJ+HSdF198kS5t29LHdpjl82MqCvkuFwFJwkrrIX8UjjLZtPApCmPHjqWKk0p2X2HZnOrxMMl26N21K59++ik+l4tp6da/zqrGMN1IJfRcLpYvX05+JIosCLTxeFkfjZMwDNasWUMymaRWlSqU9Xqp4vGgpBOaDV0uvIKAkU7CegSBeb4Ab4WjuAWBsKLwWCBEHU0jkE4Sb4rn0FVVCcsytd1uDEki4ffjFQSaut34pZQmdSuPl3xZYVM8h/+Fo8R8voOe77Rp0xiYvp9bHB9VFFfGJFIVBFq63SmzQkliYyzBmlgCWRSxZDlTea8JAm5JoteZZzJi0GAGnn02FS2Lq2yHkMeDLop0VzWqu1zUdLkwRZHnAyGeC4XJDQbxpSvPq7tcdPKq1HO5qai4GG+YdPKqfBVL0MmrEk4n0AOaxpm2zfmWTTwQYMeOHTz22GNcdtllzJ8/n3wjJVfS3uulnarRqGZNzhs2DEfTqF+1KqtWrcJRVRakpUEsw4ceLuB62+Es22FUepECcFqrVjTxenkxGKZiehFT1+OlU1oPfuXKlUR1nddCEWbbPqKOQ8dWrUn4/fTo0pVuHTtyvmHRW9MJyzId01roF5sWpdPV9KLsorDTeBL1O9Kiddsjfh9++uknfLrObJ+fybZD+dxcBvfty+jhw/n+++9LHNu7a1euTOsw9nB83HzzzYcd94knnkCTUhr09/oDGG4v06enksAtGzbkOsfHmmicyrbDs88+e7SvLZAyP2rWrBmCIGDlVcYKRnnggWOT0vjss8947bXXMt/3m266iUT9DtSfspQyZ06kbfuOxzTOyVJcXMyHH354TEaRv+aZZ56hQpXq1Knf6JDV78fD1N+pgvrRRx+lUdMW9BswqMTvQZYsh+NfnqA+qgG5IAjPCoLQMP3fiiAIPwiCIB5p3H96/O1WFD6KxvkqliCsaYdNSmX5a0gmk9x0/fV0bNmSGTfffFBBSTKZZNbtt3NW587ccxjT5uPh1Pr1GZ6On/26fkTDu3lz59KmUSPGjhrFFZdeiuXxYHk8TLv++kMe//TTT9O4Rg06tm7NV199RTKZZMOGDfz888+ZYyrm5vFcKMymeA61NI05c+ZQs2xZFqR1tFtpOvfeey9r164l6vNRP5AymP717+5ZnTszPR3nDrOdTIKwRZMmlFUUXg9F6OBV8et6iW6zBlWqZIwsWwWCGWmIZDLJoN69iWg6ltuNz+NhqJ3yVSmTrlpeHomlzMfdHiYYFhFVxafrhGSZioqLz6NxmgSDLF269ITel++++w7b62VdLMGHaaP0/wbDPBkMYakq+/btY8rEidSvXJnxo0cfs4xIpfx8nkh3sFX3+XjppZeO6byFCxfSplkzyqpqxlfnj0z6/sKePXsoFYsxwLRo6vYQlyQiLhdDBg0CUhsndjiHvFZDMP3hzPP+5ptvCBgGV9sOZ9oOZ/5Kl/x42LZtG19++eURC7vOHzOWRKNu1J+ylFjd9kyZctkJXesXJowdyznpzZhhls3FR9Exf/LJJ9E0jby8vGPWum93yimZavQe/gBz5szh2WefxXQC5NQ7A8P28d57753UfWTJkuXwZBPUWf6V+HSd9yIxNsYSFFp2iR+l77//nhGDBtGrc+eT/oHZt28fN95wA2POO48ePXqgiyIV0pWhHVufeIJ68+bNbNy4scR9xNIGhL9m//79NG/YkCqyQg3FRRXFRSXFxfpYgsssi0qFhVTIzeWZYCrArWEYVHB7eCkUoalhUqtKFeo4Di18PhpUr87+/fvp37MniiRhKApBVSXm97Nq1SouufhizvCqBCSJJm4P3nRA+GEkhksU2b59O8lkktoVKzLMsrnCsgnbNjt37uTSiy+mlKzQT9PRRZEngyGeC4ZQBZE8WcYQRV4PRbjMsmnl8fBmOIoiCPT4VUKzUFZIyDLz/AH8ksSz6aC9gqKkZCoEgUZuN2UUhSplynDRRRdREInSyeejhu1k2hp/zauvvkrMMLjedqigpJLlHb0qfkkiLsnc6vioo2moLhener2c6VWxJSkjT/Fx2sjxzVCEgKry5Zdf0q97d65PJ0ZHWDaq4uI0j5dcWSEeCpEbDtPYtMhXVYKOw5lpuZU7fQF8oogliuTIKQf2lh4PObKc1qJOJes9gsD/wlE2xXMosCy6n3kmOZrGuaaF41UpbRioosjGWIINsQRuSSJPlnkvEmOkadGrUyeefPJJSkUimGJK2sOSZAxBIC8QyMiOzL37bnJ1nX6ajlcQ0WUZRRD4NBpnYyxBwjBZs2YNQ/v1I6Cq2F4v9993H0VFRZzRsiWlLAtLcVHH7eb9SIyKLhe210uLYIiAYTCgb1/6de/OrbfeSrOWbTir79lHbYdcs2YNMd3gq1iC9yMxDI/nsMeOGTWKbrbDq+EINWz7sDrLX3zxBabtx4qXQxEEVFlBt+yMicwHH3xAPBDAJcv079nzqHIY69atY82aNZnv52mnnYYgCHTr1u2EWlnXr19PMBxFcntJNO2DEyvgtttvP+5xjpdkMkmnrt1wwgl028/0m289pvN++ukndNOm/FlXUKr9eeSVOn5j261bt/L555+TTCYpLi7mzjvv5PwLxpywBvUTTzyBSzUo230ysVptObPHWSc0Tpb/W/zLE9TdBEG4+1f/308QhNt/c8wqQRByfvX/awVBCB5irGGCILwnCMJ7eXl5J/3c/0pGDhlCBdumjs9Hq8aN/9byR/9UiouLGTV0GH7DoEmtWhkJub8jX3/9Nb06daJlgwYHbU5v3ryZlStXHjb5uWXLloM2zg/F5s2b6dquHTXKlGH2rFklXht29tk09HoZZ5hYokjItikIh6nlcnOxaaGLInPmzAFSlc8vvfQS3333Xeb8pUuXEjZNdFHiTFUjousZ6Zpnn30WS5KISBLn6gbtVI32LVpmzp1zxx3kGCan+QPkRSIl/C2SySRr1qzhm2++Ye7cuTSpV4/BgwaRH43Sz7JppOk4skINt4fJlo1PcTHd8WUKeLqoKgHDKKEP/gvff/89zz///BE3A3bv3o3fMJjt83Ol5eASBFZGYrwfieF1uY5omn0kWjZsyFjb4clgiLCu88knnxz1nCVLlpCj64TcXlRRYp4/wADDpEbFihlZlj+STZs20bRJExp7PKyJxrnyV12vAwcP/f9Vv836MPGSSzLnLVu2jLM6d2bMyJFHlZo8FP/9739xNI2QptH19NMPW+T11VdfEc/JwwqEyS8sU+LzeSKsX7+enFCIsrZDbjh8TJuIy5cvJx6PY5rmMW2KzLztNspYFsMsm4BhZMxS33nnHW6//XY++uijk7qHP4P9+/fTrcdZuD1eatapX+K5f/jhh7Rt34EOnc/MrFeyZPk7kU1QZ/lXMqx/f2o6Dqf7UiaEJxqsHI1zBgygqW0zxrQImiZhx6G6ZePXNF544YUTGvP2W2/F8nrxqSpx22aArnOd7WCKYgn5hW3btlG9XHlyTRM1XV2bJ8lEJYlLTBu/JFHodpMbDBKVZU7xePB5vQw1TDbFc7jAtDh/5Egefvhh5s2bx3fffcfoc86hffPmPProoxw4cID169ezZ88ebr7pJjS3m+ouF3N9fiorCm5BwEonVD2iSFFREcXFxfTs1Ak5bZ7yyCOPAFC9TBn+Ewwxzx/AEkW6qiq2IDAknZwdrhsM0HSGpCuXFUHA0XUMUaSOy4VHEPBKMoW6jk9RyPH5GJhuj9REkbYeD6YoUtvl5q1wlIjtAKmAfebMmSxcuDCz0Ny2bRtz587lscceo7i4mBkzZtCiYUNOb9MGv6bjFQTyZTk1XtqosIOmU9vtJiFJLA9HcAsCD/mDLAwEMUSRd8NRfF5vyhjmwQfJM0xGmxZBXWf8uHGE3W6GGSa210vUcSiraaiCQCRtDjnaMMmRZVRRpIHiwi+KuNLyJ/P9AV4ORTBFkbfCUQxJooFhUt/rxSvL1PJ4icsyl5g2vf0BciIRDFGkv6Yz0LSwFIWGLjcbYwludnxUzMtn586dXDF1Km0Mg5WRGG09Xs7WdKoUFGQ+Xx1atGC2z8+meA690oaalZTUJsN4wyIeCGQcxDds2JBJbL/33nuUsiy+jCV4JhhGT1eZa4JA+bJlWbBgAV999dUJfTeKi4tp1bgxtX0+SlsW40ePPuyx27Zto0u7duSHwpw/fHjm/d+xYwf9+w+gY6dOfPbZZzzyyCMkqjah/pSllOo4jpy8UmzatKnEWMlkMmNkeuDAAS6bejltTu/A/Pn3ljhu6qRJBDWNsKZz4QUXZOY8cuRIBEFgyJAhx92pcc6IkeSc0pOKA6ejR0px1lln/SlmM59++immP0zdS/5DtXPvwvIFjum8devWYfiC1J30NDXHPoRH1Y7ruv/5z3/QTRvTH6ZNu/Yn3NnyC3v37sW0Hcy8KtSfspSK/W+iQpUaJzVmlv8bZBPUx5ag/vWff3r8nUwmee6553jiiScO6ljL8vuwePFiqto270ZinGPbv4u3zB9JUVERS5cu5YUXXsjEEUuWLMGnaZSyLJrUrn1Yo/NjoUeHDgyyHR4LhAh5vSWqdvfu3YtHlumr6TwXDJNnpq53mlelj6aRo+kljn/ppZeIBwLYqsrZvXujKQoLA0GeCobxHkJSY/zYsdiixM2Oj3fDUWxVBeD1118nEQziURR6de9+2OKB77//npBlMcGyaWPZnNG6TUZ/+auvvmJY//706tyZ05o35zzbYXkkRllVpXWzZoeUS/mlErxRMFUJ/t5777Fo0SJmzZp1kAH0K6+8QoOqVWlauzbDBw3Cp6o4Xi9XT516wu/F+vXradWoEZXy87krnfj/5ptvuPbaa5k9e3bGv+bXTJ06lY6qRjCUR9kelxHwRdFEicZ+P0FdP2EZk+PhzTffJKDpDLUdYrqRMelesGABdjhBzqkDMJwgbZo2JT8UZkCvXif971uNsmW53x9kXSxBeds+pP/RL+zbt49169Yd8vmdCDt37mTlypXs3LnzmM/ZuHEj1atXR5Zl7rjjjqMe/8QTT3D11Vf/I5LRh2L+/PmEy9Sg9oWPkmjQmYGDU7I/e/fuxR+KUHDaueS1GEB+4fEXkWTJ8keTTVBn+VdSVFTEggULmD179h/azl0hNzfTftc4GOTRRx/l6aefPu6W+F9IJpPoHg/LwlE+jsbRFYVct5t2Hg/1XG4Kg0Fuvflmrr/+egYOHMhpaZOVyaaFJct4FIW61aqhiyLPhcJsiCWIyzIDNJ2LTQvN5SJkWdQPBAlZVgmH7SF9+9LRdpjp8xPW9cyP8tq1awloGi+Fwpzq9mCJIjVcLkxZprSuk1BVWjVtyhdffMEzzzxD5bQe9hWOL6P7PKRvX0q7PTiixJW2Q4GsUCDLtPZ4eS8S41SPB0UUqV2xIitXrmTlypUsXryYsMdDWJLoq+mYLhczZ87kyy+/pG/v3hhpiY3z9FTCvZNXRRdF+hkmMdOk8+mnM27sWBYsWJBJ6O3du5eqZcrS1uenuu3QsW1bgrpOy2CQRDDI119/TbvmzWmlaXT0eAkIIuG0vMfH0ThuQeDDSAxHlLDTbu1yOqFuyDKDBw7k2muv5dprr6VutWq0b9mShrVqcYOdaq+s4/HQP71BEJAkXglFeDoQwhFFfKJIdVlhmG5QWlGoV6sWPl3nlVCEz6JxDFEkKEpUL1+emhUrUktVqef20Mjt5tlgiKgk4fd4yNU0eqoqhqLQp0cPyuXkUE5RiEgSqihSS9OpXr48AV1HEgR6ahqDNA2/280Nv9Jymzp5MjU9Hm5yfEQkifKKwjBdp67bTV4gwOrVq9m3bx+LFi3KbGj8+vPybCjM1bZDXJIZoOtUVBSaeLxUL1f+oMD4wIEDnDd6NPUaNuGGG6cdMQG7b98+nn76aV555ZUTStTmFZTGKVOXUPXWeLw6q1atwvIFiDfuTiC/IhenjRoPxyWTJmMnSlNw+nnYoVimq2Hfvn14FIUVkRironE0lyvTqptMJpk0aRKCINC9e/fjWhicP2Ys8brtqXvJf4hUanREqZLfk2+++QbNtKk8ZAaFncaTX1j2mM5LJpO0Pe0MAjllsENxJlw08biuW7ZiFcr3uZp6k/9LILcMr7zyyolMP8PGjRvRLAePE8VXvhGK7jD9T3qGWf7Z/MsT1FmJjyx/CfPnz+cU22GBP8jllk2Hli2PftJxcODAAd57771DVuceL79oHVdxHCraNoP79gWgUfXq3O0LsCGWoK7Pl0kI/pa1a9dy3XXXsXDhwsPGK/UrV+FBf0pKo47bTSIUKmHq1rtrVxo6Dh0dH1XS0moV8vPxulycP3x4iXFzQyHuS+tmq2kZv/cjMT6OxjHc7kwhwS+0btKEOm4P9dxu4opC19NOA6B8bh53+gK8E4kS1LTDrmlef/11avkDzPL50dLXO5T28oYNG6hftSq2qjKwTx+efvppNm/efNBxl112GUPT8g0XWzY1K1Sgum3TyeejbG5uiedSVFTEgQMHWLVqFSNGjGDixImZzrffi127dlEqFqOPbdPEdji7x8E+IsuWLcNRVTwejYr9b8RXrh4ttZQZ/B0+P22bNDniNYqKihjarx+WqtK4Zs0SlePvv/8+A886iwvHjCkh/XIo3n33Xa6//vqDYqbFixczduw4Bg8cSCvb5rVwhGa2nZGxO1EaVKvGDbaPDyIxcgzjHyF5sX37dtq3b48gCIwdO/akCyD+zsycOZNYtWbUmvAIduk6VKhUhc2bN/Ptt9+imTb1Jv+XuhOfRJLkf/VzyPLPJJugzpLlJDh38GAa2zbnmRYhyzru1qWNGzfSs2NHWjdqxMsvv0wymSRoWSwKBHkpFEF3uwmqKl5RpJbLzUyfH78k0VrXyVFVqrndrIrGGaTp+F2ujCFkg2rVucR2eDwQQhNFHgkE+SQax/F6+eijj3jppZcOCg7rVarMwl/pzf3iULxixQpyDYO1sQT/DYYJmyYXTZjAM888Q8A0yZVlNEHAUlVuuOEGajk+1scSTHN8tGrUiJ9++okrr7wSlygyVNN5KxzlCsumtKJwulfNVH+fadmUzc3NVKIkk0lqlS/PLWntvL6miVuWsbxebI+HZ4MheqgaDd1ubnP82KKIT9OwFYXxhoUhipxnmBSqKsOHDiWZTPLhhx9SJp3UfycSRVcUbnV8PB0MU13TmDx5Mg2qVOUBf5ArbYcq6QrqCYZFTzVlpKiLIiFN45SGDdFEkbKyQlOXm+qKQkKSGGzZGJLEcMtmgmWjiiLlJZkbbB+6JNHIMHkrHCUuyfTXdG5z/PhEiZgkcafPT46ckttwZJm8UAgzbUCpSxKlc3LYsGEDkigyTDeo7nKhCwJ9NJ2CUIgq5cpxpZWSFxno8zN9+nSWLFmC5fUiCALvRWJsiCVwZJkrbIfPo3EKFAVb03j44YdLfB4OHDhA/759cRSFfF2nVDRK1cJC2jRpwrp160gmk5x+6qnU9/mo7fjo3qFD5tzZs2aRFwpRNpGDJUqpKvPDSO4kk0ka1apFrqIQdXsxdIs77zy8+/jJkEwmEUSRuhOfpP6Upbi8Bo8//jgff/wxkyZPZt68eUds6d60aROWx0M5r47mVglXacq0adOA1CLD0TQWBoIsDqR0EH9bVXXTTTchCALtDuM8fii2bNlCjdr1kCSZ5i3bHLcb+ckwf/69hOM5lKlQ+bgWHwcOHODll18+rKHUkahdryEFp4+ixvn3YwWiLF++/LjH+DXFxcXUrteQcNlamOFcGp/S7KTGy/L78tNPP3HaGZ2I5RYwfsJFf0p3wLHyL09QK4IgrBMEodSvTBIr/+aYkb8xSVx0tHGz8XeWo/Hiiy+iSRKVXC40UWTx4sW/29j79u2jWb16lLFtfKrGrJkzmTZtGo899hh79+7l/vvvZ/78+cdc8fzDDz9gut2siyX4PBpHEgR+/vlnTj/1VCbYDsvCUUqZVkY249d88803hG2bAbZNJcvmit+Yqn300UdULlWInu4ArOt2U05RqOg4LFu2LHPc/v37mTdvHjNmzODHH3884nwNr5eBms7iQAhbFBmuGym/FJeL8eedV+LY7du341UUvowl+DKWwCPJmXVBXijEf4Ih1kTjxA2DVatWHfJ6P/30EzF/Kjn9XCjM+5EYltd7yOQzwNtvv03AMGgaDBJxnIMS33feeSf1bJvnQxFa2zZ+VeWNtKRdFZ8vI/P16KOPYqkqHkVJxcaKQkXFRd0qVY/4G/LII49QGI1RqaCAN95445DH7Nu3j0ceeYTFixfz7rvvUsFJxdTvRmIETfOQ57z55pt06dKFRH4h1WvVJt8weCIYooftMOzssw87H0jpV9d0HD6MxBhq2wzq3Ztt27bxyiuvEDAMLrVsutgOXdq1O+I4v2Xbtm0lNiTGnHce56eT/yNMi4vGjz+u8X7L+++/T+l4AtXlYtJRdKD/ThQVFTF69GgEQaBTp07HVYX9T2Lbtm1UqFwVl2rgr9SUaO3TKFO+IgcOHKBx01OJlKtFqLAKXY7BvD1Llj+bbII6yz+anTt3MumiixjUuzfvvPPOn379/fv3c+utt3Lh+PHHpFX2WxrXrMko2+E2J2XA8v3337NkyRKiPh+OptG6WTP62g6tPF5uc1JyC901jSssh6cCISxJwisI1HC5KGOYvPrqqwB8/vnnNKtTh0r5+fTv2xfb68WvqlwwYsQh57F161bGjxlDgWnS1e8nEQyyefNmvv/+e+pWroIoCNjp5PB996ZkDaZNm0b3dDXwlbZDTZeLYQMGckbLlnglCU0QCVsWZfPyaGKa+NNyII4o4hYEIn4/UlompIXHw/uRGGVsp0Ty8torr6SebTPNdrBEkRm2j/v9AQxJYobjZ2kwjCoIVC4o4NLJk3nggQc4NRDkatuhh5qqYJjj8xNWFK654gq2bt1KwDC5znYYYjuUCkdooOkEJIluqobj9TJ16lQsSaKK4sokuc/SdGq4XEiCQMA0mTNnDhGvl1dCES42LYJpg8eAJLEkGEIUBNbFEmyMJdBFkXKyTFu3B0fT6d+zJz5VRRMEAqJIZUXhAt1EFwTqu91EJYl8SaKRy41PlDAlmWeffZYtW7ZQXFxMMpkk7KSe9xPBENVcLiqXKUPU76emYaKJIoM0nbCuZ4L5HTt2UKmwkFG2w6W2g8+V0gNcH0tQ3bIyUiyH4ssvv+S1117LyHn8+jNjut18GUuwNpbAJcuHXPTdc889WJLEID2l9W263SUWWd9++y26LLM2luCTaBxJEGl72tENWzZt2pR5LseD4w8SqtKcWP0uyC7vccmNXH/99ZyVNgGaYtmYbk+JLoRnnnmG/HCEnGCQxx9//JBj3H333UiSROPGjY+ru+OfrIX6zTff8Nhjj/H5558f9diVK1dSqkx5VN1k8qWX/S7X37lzJ3PnzuWBBx743VpMs/w+DD1nBLHabak6fDaBnDK/a7LqZPk3J6hTtyecLgjC52npjknpv7tCEISO6f/2CoLwiCAIXwiC8I4gCIVHGzMbf2d58cUXifp86B4Ptx6iSvPs7j2Ymk6U9bEdbrjhht/t2i+88ALVHR8bYgkWBILYskw1j5ew203F/HwaOj6a+Xy0aNjwmDbD9u3bh+Fyc6vjS0ntSRJ33HEHa9eupW7lygRNk8kXHXpj7bHHHqN1MFX08XggRJ0KFUq83qh6Da5OJ7lNSaaFqnGt7RAwDL799tvjvve5d99NjqoyVE/5kBiKwjmWTUhVmXcIw8ji4mJKxWJcaDtcaDuUisUoLi7ms88+o1/fvmguN35VZXDfvkd8VuvWrUN3u3k2FE6ZIx4hQT2kXz+mpN/7wZbNFVdcUeL1oqIiRp9zDuVzchh41lm0a9qUPraTeS6bN28mmUziNwz+GwzzTiSa8oEJR/gylsCU5cNqmv/000/YqsriQIjZvtQ657ckk0naNWtGfZ+Pmo5DtzPOwK/rTDAtOqgqMcs6JsnIm66/nuplytCrc+eD4rydO3dy3333ZWQG77rrLtr6/GyMJbjadmjZuDEhy6LAMLBlmVXROG+Eo+QEjk1mDeCO22/H9HgwPR6uTG+MrF69mrBtUzsQIOrznZT28N69e1m8eDHPPffc32pT+XiYMWMGkiRR62+ug38y7Ny5E1GUqHfpM9S7dAmqYbF582b27NnDQw89xCOPPHLMBqJZsvyZZBPUWf7WHDhwgLlz53LTTTcdMuDpe2Y32tsOl6WNDP5pPzJBM1VN+0tl6Ycfflji9f49ejDJdrjd8ROUJHqaFqoocr5hcrrt0PqUUzBlGa8oYrhch61Y/O677w5KxO3fv59rrrySTm3bYmsaeYaBpWlceOGFmRazCWPG0Md2+CqWoI6qUrtyZW6ZPp3i4mIefPBBKus6L4YidPSq5Lvd3HDddQwbNgxDFLnadqjrdmNLEuujccrLCjFJZnkkSr4s4xNTkhO3Oj4G6waVFBcRx8m4iC9btow5c+bQrWtXdFHEL0qogogqCBiShCoIqJLExRdeyNKlS3E0Da+i4Nc0Gls2higy1bKp4XLRR9WIGga5wSAd27ShY6tWDDzrLL744gsqFRRkFkujTYsLJ0zALcvc4wtwY3qcHo6PgGHw7rvvZjQqq9sOG2IJHvIH8YliymTG46WyrGArCrVdblp7vMTSMiA+SeLySy9lw4YNqJKETxSZZfsIpiuMVVmm+Smn4Egp48LyisKycJRBuk6FvDw6t2lLr06dWLduHd27dOGC9ObAWNOiWePG9E0bM061bKqWLn2QoeaGDRsY0KsXvTp14qGHHiJk29heLx1ateLAgQOsXLmS6mXLEvP5Drmo/C0HDhwg5vdzpe0w2XYoiEZ55plnaFC1Km1POSWTjHzrrbcoZ9v0VDWaeTyELKvEOLt27UKTZe7yBbjJ8eEVRfr06XPEa7/33nuYjp9Y+Vr4QxG++OKLox5/Sq1a1KtchRkzZlC1UmVK5RWwYMECNmzYQKtGjSgTj3PzTTcdcZz58+dT27Z5JRShvWEybODAoz6nQ7Fo0SJcLhc1atQ47ELueNixYwenndEJyxegS7eeJ6WH+XvzxRdf4ARCJKo0xrB9Jy3ZkeXfxWlndKJUhwuoP2Up8Rotjkkb8s/i356g/iP+ZOPvLPmRCPf6AywLR3FU9SBPh4vGjaOD7fBCKEJN2+b+++//3a79/vvvEzcMXgpFuNiycSSJzqrKIC0labYuluCrWALT4zlI0/hwdGjblkJFoYnbQxPD4Lbbbjum89asWUNA17nKdmhl25w7eHCJ16uUKsXCQJAvYwnKmCYd2rShQ8uWh/yNLC4uZvJFF1G3YkXOHz78kButXdq25fZ0IUs/x8fo0aO5+uqrj/ibu2bNGnp37Urvrl35/PPPWbt2LUHTpJ/jI98wuO6aa7h9xgwG9e59RC3lBQ8/jOHx4FVcXHfVVYc97vIpU2htOzwTDFPTtpk/f/5hj4VUBfu5gwfTpmlTpk+fzq5du0gmk1iqykuhCCsiMbyCwBjdYLrjw/J62bNnD1999RX9e/SgV6dOGbnCTZs24fN6WRON814khupyHZRc3bJlC5bHw5exBF/EEiiSRKVSpWjl8XKublDDcViyZMkR53wkDhw4QP1q1TjV56eGkzIz/Pnnn6lRvgIFVqoTt12zZlxuO2yMJWjlVanrValnOwz/Tby5ePFixp5//kHzKS4uRnW5eSMc5cNIDONXRSE//PADr7/++kFSL4ejuLiYRx55hLvuuitjpFhcXEyLhg2p6/NR3rYPaUD/d+f555/n3CFDGDVyJIZhkJOTc9D6+99Cjdr1iNVqQ7xeBwrLls/KeWT5R5BNUGf5WzOgVy8a2A49bIcyOTkHVXGWSyR4PhRhUzyHBoHgCRsT/lWMHz2aCrZNM7+fOpUrH6RNu3LlSiKOQ6FlkxeNct111/HQQw/Rt1s3Bp19NjfeeCO1HIf1sQQ32D7aNG58zNeecP75nGI7XGU7GKJISBSp7XKhKi7efPNNPv30Uy4YOZKhts0TgSCOJHGVZVNa0zirZ0927tzJ2FGjCBsGMdNk5JAhPPTQQ7hEkbZeL5viOdzvT59nO3TQDfyyzPmGSWdVZWMswRjDpK+msygQxJIk5s6dy9y77qJOlSoEPR7ODATQZJkG7pTJ3xTTppNXpbbbzWTT4lLbR4dWrSibSCWKP4nGCaoajRo1wiPL6IJIV69KQBRp7vHwRjhKE8vKLDDeeOMNrLQhYhuPl3yPhwULFtC0bl3a2g7tbIdq5cpxzTXXlKiQ37dvH01q1yZPVdFlGY8gcI5ucIrbQ9Dr5emnn06ZPKYrxA1RxCMILFy4kFaNGtHJq3KhaeERBMopCl/FEtzu+GlWuw4NqlcnLEk0St/zLY4PQxS5wrIZaztULiwk4vNhiiJN3R48okipSISALHOj7eMM22HiMbTu7d27l3Xr1lFcXMzmzZupVro019g+XgpFCOv6Qe7je/bs4YMPPihR/bxixQo6tGxJ5zZtWLZsGT5NZ54/wCW2Q83y5YHU5kjAMLjB9tHPdmjXtGmJcT/55BNatmyJKYrYoohXlo/aDTFw8FByWw5OJbUadGHqEUxxkskk8UCAaY6PWT4/XlGkVePGme/aGS1bcp7tsCQYJn4UHb2ioiLOGzaMUpEIPTp0yGymHI7XXnuNe+6555DSP0uXLkVVVcqVK3fCppG/MOWyqUSrNqXmmAcJV6h30tqCvyfXXXcdiQadqD9lKfmnnUuPs/r+1VPK8jfilVdewbT9RAqrkMgrOO6OiD+SbII6G39nOX5ClsVzoTCfRuOEDqFfvGPHDnp17kzZeJyxo0b97t1BN157LYlAgJrlyyMJAp9H45lutnGWzSTbIScUOubKwTVr1pAXieBXVepVrXrU3/1fM2TgQCxZRpNlrvpNnPLoo4/iqBoJw+CMli2PmDiaP38+NWybxwMhmtoO1//KL+QXrrvqKmrbNtfZDlFdP6yExZGYM2cOPfwBNsVzuMsXoFphIdUsm2tsh7DXS/euXQ+b8N6/f/9RN8f37NnD0H79qFqqFBdecMExvfd3zp5NVNep6/dTtUxZNm/ezPx58zA8HnS3m5ZNm5Ln81ExN5f//e9/AFQtU4bz0h2DMb+fvXv3kkwmGXjWWeQYBmFNP6SZ4r59+4j6fFxj+5hsOySCQRrUqMGFtsMroQg5hnFS3bqff/45CcNgYyzBR9EYuscDpJ7dJ598ws8//8w5AwYwwHZ4PxKjtm3Tq1cv5s2bV+LzsWjRIvIMg4tNi5hh8Oyzz2ZeKy4uxlJVlgTDvBGOYng8R9WvPhwjhwyhuu1wms9PlTJluOn666mYm4cjK3wYibIi8v/v4Z/C22+/TVjXmWLZVLVsxo0ZQ05ODoZh8PTTT//V0/vd2bp1K5MmX8qFF1183DKkWbL8VWQT1Fn+tuzevRvL4+G9SIxN8RzKOw4ffPBBiWPGjBxJLdvmbMsmHggc867wybJu3Tqeeuqpk15MJ5NJli5dysMPP3xYHazt27ezatWqEm1lA886iwLTIqyqxD0e1sQSXG77OD1tSngo1qxZw8ihQ7lo3Dh+/PFHmtaqlTFmaeHx4hNFOnhVKioudEkibhicfmoLyuTk4JZluqsa/TSd8opCba+XJrVrlwiY3njjDSy3m6AgoIkiA3SdHFmmZ7du9DjjDIb178/4Cy5AkSTqu918Go3TQ9WISBIhSWKAplM+L49Spkktl4tZvlQlSAevSq4k81E0zkBN5yxNo5Ks4BUEIpJEmXicRCDATMfPO+EouiSRqyjMcPw84A/gCAKqIHC2qnGZZVPT5WJ0WosvLxwhKqX0nyOShEcUufLKK9mxYwczZsxg3LhxhCyLgKpSq2JFpk6dyocffsjMmTOJ2jb1DYNcr0qBrLApnsPb4Si+tAv6K6+8giYIFMoKa2MJ7vUHKIxG8ek676c/0z5RJCfdwjfFdmh3yil89tlnlMvPRxNECmQ5k9yealp8Eokhp5O4flHEn37tVsfH3b4AXlGk5zFoqu3evZtWjRvjURRyQyFUw8SUFR70B5hq2YRVtYSm4g8//ECFggLK2Db+wwToH3/8MbmmyYZYIvUcdD3z2j333EOO45Dn9/PEE09k/v7zzz8nYBj00w1iksww3SCiaUfVHZ56+RVEKjWiyrBZBEtV4e677z7ssfv27cMly3wWjfNFLIEhilS37YypUZ2KFXnIH2RjLEF9v/93C1Bn3XEHdihGonpzwtHEIf+teOONN7Btm9zc3IM2BI6HkeeNJqdp73TCvjOTJh3Z6PHPZMGCBQRyy1Kx/01EKjZg8qVTjn5Slv9TbNq0iVdeeeW4Ej9/BtkEdTb+znL8zJ83D8vrxedVGTlkSKZKdfv27WzYsOFPlQSoX60abVSNvoZBXiRCr06d6Nmx43FL8u3fv59vvvmGXbt2HVUH+hd27dqFV1F4PxJjeSSG1+U6KIG7ZcsWVq9efdhE7YYNG3jkkUcYNWoUw9PyYpMtm3MGDDjo2OLiYm6+6SbO7tHjsKaNR+Ott94iomnc7Pio43ITNgxuTvvADNB1TvV4COn6n2qIV7VUKRYHQmyMJSivKKguF/fOn8/OnTszVb2/pri4GFmSWBNLsCGWIKhpmSr+ZDLJK6+8Qut2p1O1Zl3uuWf+Qed/8MEHtD/1VEqFQuTpOgldJz8cJu73H9IA8njYvn07QcviOtvhPNuhTqVKBx2zefNmmterh0/XGdy37yE3LkYMGpzp/BxnWlx80UUlXn9k0SIsVUVzu5lzEl1JAdPknUiqyzdHN8jRdZ4Mhuil6TR0e5hoO1QtU+aEx/8ruOWWW+ifXl/O9Pnp0rYtX3/9NbVq1UKSJGbMmPFXTzFLlv/zZBPUWf62dGvfnriicKaqMdG0CNv2QVpexcXFzJ8/n2uvvfaIVYhfffUVI4cOZfTw4SUckn/Ntm3beP/994+a3Hv11VcJ6DrNgkFifv9JVz8eL99++y2218uaWIIVkRiKKCKLIvmR6GGNTHbv3k0iGOR8y6a77dCiQQNuuOYayuo6A3UdQxSJSxKb4jm8FY7iiCLrYglKWzbLli2jerly2Gnt6I+icTbEEsR0o4S0QutmzYiKEkFJIleSUCWJbl26HLQY2bp1K3HbRhYEbEXB7/HwWCDIVV2CQ+8AAQAASURBVLZDqZwczrFsRhomzTwe7vYF8EsSTdzulKaeKCIKAnFJorLi4gF/kEouF/leL25BQBdFVFGkkqIwxjB5yB9EFQQauz2ogkg1xcUATScRCLBt2zbMdGXyc6EwligSE0VMtzuzeDmtaVNutH18FUtQ1eWmlaphud0UaBq5ksR026GT14sqiozSDVp5vETSidlkMolfVQlLEh9FY0x3fBSEQvTt1o36hkFXVSNPkmjh9iCLIuXz8li9enXmOc2bOxdVUTAEgT6qRhWXi1yvl25nnIEqSTwXCjNGN5AEgU/SyVfd5eL7778v8bx//PFHVqxYUaI6f86cOZzqpKRbRhomofyqFHYYiy6KtPZ6qedVSxiyzJgxg6aGSUBKvb9xxznIrK+oqIhTGzSghm2Tq2qMHj4881pBNMq1jo/ZPj9+w8ice8cdd9AzXa0zx+enlcdLM7+fBQsWHPE7sHv3bvqcPYD80uUYNfqCo7asDR84kByXi0I5ZcxZ1rK4/vrr+fjjj1MJVE2jqs9H7UqVDurSOBI//vgj06ZN4/bbb+fTTz/l448/znzea9RpQIU+11B/ylISVRqzcOHCQ47xwQcfEA6HCYVCvP/++0DKPGn27NkHbcgdjs8//5xAOEowtwyRWM6f/m/SkUgmk0yZejmVqtViyLDhfyv5kSxZjkQ2QZ2Nv7OcGFu3bi0h7fHcc8/h0zSCmkaX007709rMd+zYwbXXXsulkycfNvY/Vp555hkcTcNwuxkxaNBRE+0LFy7EJQg8FwqzNBRGc7uPywPh448/JmiatA0GUwbgmkabYJCAYfDmm2+e1L0ciRZNmlDR5WJk2mQ8oaqca5jYosiSYJgBPj8333zz73rNJUuW0Kh6ddq3aMG6detKvHZ68+aca9k8EggRlKTUusAwDjvWl19+SdgwkAWBfLebhjVqlNgA6NilG/F6HajQ5xpMX+iQ0g6PPvoo3vSa5yxVw6Mov9u9vv3223Ro2ZKzunTJxGpPPPEE4y64gKVLlx7TGAsWLKDANJlk2cQN45CyI8lk8qS7E5rXq8dg2+E628HwemnpTyV25/kDxHSd9i1aHJO3yN+JDz74gICuM8YwKWdZzLr9diCl19yxY0cEQeC8887LSmFkyfIXkk1QZ/nb4tN1XgtFOEc3CLndPProoyc0TlFREWVychhhOwy2HaqVLXtQYLl69WqiPh8VHIeCaOwgzbxf07tLF65J6/32cRxuOopu7e/Njh07sFWVBYEgs33+Eu1rK1euZNy4cQeZ3n322WfkW6nqi1GGiSwIhB2H4cOHY7nd3O740NO60b00nUqKizfCUSK6zurVq2nTuAnDdB1HlGjp8XCFZRMwzRIVb6bXyzuRKF9E45iiyLChQw97D8lkkh9++IEDBw4wdtQoPIpC2ZwcHnnkEQK6Th/Hh+NyEdU03GljxVxJoqLiQhUEeqlaRoP5YtNikG6QJ8tcbTu8Fo7gE0U0QUARhMxxE0yL3prOpngOlXw+XnvtNXRR5KlgmK9iCWKSzGzHx9m2zZAhQ3jnnXfo1KYNE22Hz6JxKioK9/gDdNF1eqkalihSy+WivVdFFQS6qipN3R4qlyrFli1baFa3HmHbxnS5Us9bkijQde6//36mT5+OrevUtW3Cun7I5OWlF19MXV3nOtshJEm08XiJqhqjh4/A5/XyWTROH02nnstNviyTL8vYikJOMMiDDzwApJzFA6ZJadumerlymTa/2bNn08Ky2BBLMNowcUL5hMs3xBZFNqbd6hVJynxPLrvsMmxR5AY7ZT5Ux+2hWvnyByVQX3jhBUyPhwa2Q9A0M5VBiiTxSTTO+lgCn9eb0Yp/8803ieoG0xwfNV1uom43HlHEoyhccemlJJNJlixZwsKFCzNJ7dWrV9OgajVKRSLcMXPmMX1nkskk9913H7nhMC5JIjcQoIbPR0TXuXP2bNauXcurr756XMnToqIiqpcrRyfboaluYCguTH+Yvv0Hkkwm6dt/ILEaLSjbfTKmP3TEZPNnn31GXl4elmUxe/ZsArpOV8PEkGXGjxt3TPP5+eefWb58OTt27Djme8iSJcvhySaos/H3P5VNmzb9rTxZ6lSsyDx/gHWxBJVsh5deeumvntJxUz43l4f8QT6LxskxjKNq1g7p25eeqoYtimiiyJldux7X9S699FJGpKumJ1k2/Xr25NFHHz2q58bJ0rNjR6amNZDb+vyMHDmS09q1o0DXU6bgus677757XGN+8sknTJgw4ZCx7ubNm/FpGnf7Aoy3HepXrVri9U2bNtGmSRMsSWKKlZI5iTgOAB9++CFjzjuPW2+9NSPZ0qtzZ863HT6Jxqmajrl/TaVqtajQ73rqT1lKrEKdQ2prVy9bljk+P6ujceKSTPw4DAqPl4ULF/5/uQ5d57nnnjum8x599FFGn3suTz311B82t++++47BffrQpW1bnnvuOcrm5tIoECCk60c0V/+7s2zZMi6aMIEFCxaUyAcUFRUxduxYBEGgffv2f7uurixZ/q+QTVBn+dvSoVUrzrBtRlo2iWDwhBMv33//PZbHw8ZYgv+FImiiiCxJ9OrcJRPQnDtkCOPS7VJnH8JZ+tdMHD+e022H/wRDVLZtFi1adNhj161bx5IlS465JfBYeeqpp6iQl0e1MmUymmvLly/HkmVyZBldFBk1cmTm+L1791I2N5czdANbkvggEuNuX4CK+flcNXUqIcuiXF4ebZs2pdUpp1AqGsVvGJw/ahQdW7emfYsW+DWNQlmhtVfF5/Vy55130qBqVaoWFvLkk09SpXRpqiouVFHElKRDBtHbt2/n9ttvZ/bs2ezZs4dkMsmiRYsYe/75mQXLRx99xK233krPM8+kl+3wbDBMgazglWVKxWK0b9sWKx3wt/Z60UWRGY4PnyjxWCDEl7EEtijS0uOlustFJcXFo4EQVRUXFRSF0aZFzO/n559/pmalSuiiSFSSMASRqZZFSFEo0HQimsaF48ZRPi8PWRRJuN1cbdmYkoQppKQ1PkhLdcQkiagkUUqWGXD22ZTLyaG9V+XZYJiAojApvcgYY5gYbje5oRCGy4XucnHF1Kls3ryZIX370rXdaSxbtozi4mLaNGrEXF8gI3PiF0Xu9Qeo6fVSpXx57LT2tSOKDNR0HEniHE3nv8EwttfL1q1b6dS6Ndf/aqExd+5cINV6muv34xVEcmUZVXZRXXERkiQmmBYDTIt6Vapk3reyOTnUc7u5wDD5KBqjvKJQ1+1Gc7s5pXZtzh8xgldffZXTWrbksvS9DrNsrky3Q44aOowylkUVx6Fzu3YlAsLFixfT9pRTUs9Elnk0EOLDSAy/qnL2gEH4E4VEy9emeu26HDhwgEbVa3CZ7bA0FCakaXz22WfH9d15+eWXqe7zsTGW4MlgiIp5ecd1/i9s2LCBsKaxMZZgbSyBJIrUvngxHlWnS9u2TL/pJoYMG07jZi2PWhH+y3jly5dHURS6eNXMotTvcmWNBbNk+QvIJqiz8fc/kamTJuF4vThe70G6x38Vp9SqxXW2w8pIjALT/EMrgP8oKpcqxT3+AB9F48R0I2O+dzjunDOHipbFdZZNrn58+rZFRUWcffbZVFZVHguEaGLb3HDddSd7CySTSbZu3coTTzzBhePHHzIZ+uGHHxJ2HBKGSa2KFfn5559JJpPce++9XDBq1HHHIytWrMCUZUorCpYoMWLYsIOuV8qyUmu0cPQgI+1fuPnGG/G6XPh0naeeeooNGzYQMAzGmhYNbJuxo0YB0Kl1a65Jm5g39/m47777Sowzc+YsvIaDk1+FaCL3kPrMNcqWZZ4/wOfROFFFOWiM35PhAwdyeXr9Oda0mHjxxYc99vvvvz+oe/FY2bdvH706d8FSVVo2bHhMkpj//e9/adukCYN692br1q38/PPPPPPMMyW6Pf+NzJo1C1mWqV69Ohs3bvyrp5Mly/85sgnqLH8LPvroIyoWFGCpKlMmTgRSlcJTp0xhzHnnHXPFQHFxMQ8++CA33XRTpgq6uLiYulWq0NF2KHC5GWmYfB6NU9dxeOihhwCYdNFFdLYd3ovEaGo73J5u+TkUu3btYlDv3lQrXZopEycess3vtddeI+bz4RFFyuop7btvv/32eB/LcTFixAjyZJmvYgmeCoaxXS5uvvlm9uzZw759+2jbrBmiIOCXJD6PxlnoDxIyTbqdfjoPPfggGzduJGzbRDyelMHGkiWEbYdrbIcxtoMmivwvHGVTPIcyqkZuOMz1tsND/iCOplG6oIBGbjcfReN0MU0mTpiQmduKFSuoVrYshqJQ2eultNuDLUlYigufJFFaVnC83oypy/bt2zmlXj2G6QZBSaJBWuKjfEEBbRo3ZqBucIlpYbtcmLJMgSxTSVZQJYmgoiAKAl/FEnwZjaMLAhUVhZDLRYf27Tl/5MhMUnPHjh1YmkYLr5dhuoHP48EriliCgEcQML1eIBXY3XjddQS9XsopCg/4gziiSC9V41LTwiuIdPaqaKLIlClTUEWRhCxTRlGopCj4PB76pJ+hIQjEJZlyisJTgRCay0WLBg0YaDucoxt4BAFdklAEgbiiMMgw8aavtSmew+WWjSmK5Hi9vB2OMtowyfEH8CgKb4WjfB6NY7vdbNiwgQG9ejHUtnk3EqOa7fDYY49l3pOLx42jtWXz30CIaDr5fLamE5VkqpYtW8JMI2RZPOQPUllxoQgCpWWZhi4X/TWdgCRRxu0h6nZTWlWJu1ws9AeoYtuZ71cymeTVV1/lueeeO6htrqioiLDjcLPjwy9KPBkM8VE0js/jQTVMal7wAPUuXYIVjPLwww9TJh7nIX+AL6JxytspCZrjYfXq1YQ0ncWBEBfYDq0aNTqu839h37595IbDXGA79NF0HDtMXqshhCWZmxwfFS2Lu++667jG3Lx5M/n5+Qhp083qLhe1NJ05c+ac0ByzZMly4mQT1Nn4+5/Gzp07UV0uVkRifBCJ4VVcPPbYY1TMy6dG2XJ/WWL4gw8+oDAex60oTDj//D9Vh/r34uWXXyZomrhlmYvGjDnq8clkktmzZnF2jx6ZWOhYufCCC6hjWTR0u3FkmaH9+x+XPMih+Pnnn2lQvTpeRSEoy0wwLaK6zvPPP3/QsTt37uSLL744ZiPJI3HuueeSJ8tsiCV4LhTGl46rf+HAgQM0rlWLej4fpSyLSw+RoE0mkxQVFVFUVMSaNWt49dVXWbRoEa2CITbFc3gyGKJWuXJAqlgnZNtEdZ1GNWselNAd0KsXjQ2D3pqGo2mH1NN+6aWX8BsGmsvF0LPP/kM/rw899BClTJPJabmOQ8l8JJNJzhkwANPtxlbVE6qanjNnDk3Sm0S9bIexaS+ew7F27VoCus4sn58+tsOZp52Wee2WadNoXL065w0bdkKybUuXLmXSpEl/606KpUuXYpomsVjsIF+ctWvX8uCDD56Ud0yWLFkOTzZBneVvwSm1anG17fBOJEqOYRx3+9gvjBs1ihq2zVmOQ244nNGs3rZtG9OmTaNO5cpcnt5ZP9Xn45577gFSgVuHVq0ImiZ9up5ZQq/3RCiIRpnrC/BKKIItipxuO8yaNeukxjwcjyxaRNCyMDweDFHk2VCYyyybhCzT0nbo1r49999/Pw0dH+uicWq63eiyjK4o1DYMbnF8JAyDCoWFtPF6GW9aOKLIKXXrEtF1NsQSfBqNo4kifTWN62wHryiiezy8G4mxPpYg4PaQ63bTO51EHW1ajPpVlUSdSpW41nZ4MRTBJ0rkSjJPB8NE0xW7d/oC6KLI5MmTKS4upl7VqjSyLNzpRN2meA4TTYuI20Pl0qW52xfgq1iCCoaB3+2mo1dlmG5QOh5n1qxZmJLEWZrGYN0gIop08qo4kkT96tVLvLebNm0ioKpsiCVYE0sgCgJneDyogkCZtBHhuSNGcOmllzJv3jxMUczIu/RSNVRRxJYkrrccuno1wpJEhcJCCmSZCoqLei43HknixRdfpHfv3kQVhevSFc0NXW5O93jxCALBtBFJOUWhj6bTzONhbSxBU7cbtyAgpo0n23i8+EQJvygRkGXeCEeZYDucfuqpDOzXD10UCUoSliwzePBgli9fTtM6dfAbBiOHDCmhR7dr1y769+hBpfx8BvTpg60otPWqjDcsgqZZorpizh134KgqUV2nbDxlNPh6erOiusuFSxC40XZ4wB/AVhRqlS/PlZdddlBQv3z5chrXqEHtChUzi6IdO3bgVRTWxBL0UDXc6c0Bv8tFYbkK5DbtTaReJ0TFje4L4dcN3IKAVxSpU7XqCS2g5t59N1UKCmhSqzb333//UXXnD8cXX3zBOQMG0L1LF+J5+Xi8akZS5vLDGBktX76cAb16MeGCCw5ZufPTTz8RDoUQBIGY203EcdiwYcMJzS9LliwnTjZBnY2//2ns3bsX0+vl6WCY/wRDGF4vtqrycCDITJ//D5UqOBb+ronp119/nRkzZhw14VRcXHxM64NvvvmGYf3707dbNz7++GO+/PJL3nnnnWOOV2qVL8+T6eRrq2CIxYsXH9N5R2Ls2LGU9Xho6vYwNd3pdrSK3d+DO++8E00UeTwQ4hLTonQ0mnntmWeeoV/37lx9xRXMmTOH8vn5mF4v5wwcyOhzzqFzmzZcfvnlOJqG1+Wif9++BDSNaj4fVcqUIWAYXJCuoB6XrqCGVHy7fv36Q+oIVyko4L/BMLc7fryiiOFyMfqccw76bO7bty9jwrhnzx6uuvxyhg8ceFQT7xNh0aJFnDd8+GETzx9++CE5hpEqLgoEKZeTc9zXuPHGG+meXr9cZNkM6dfviMc///zz1A+kujifCYYpn77mM888Q+l00Uob22Hi+PEHnZtMJlm4cCG33HLLQdrvTz75JPH0+xY5zAbJ34WVK1eSl5eHpmkZKZiVK1diOn5yajTHsH2ZLuYsWbL8fmQT1Fn+FtQsW5b7/UG+jCWo7Di8/PLLJzROmXicF0MRNsVzqBsIHLQ7++GHHxL1+Qhr2iF31n/Lvn37+PTTT487gRW0LF4KRfg8GicgSRQaxgm7ah+J/fv3ZxYjS0NhvJKE7XJhSxIvhyKsjMSwVJV77rmH5r6U2d8ky6Zy6dK0bNCAW9Lu3P0dH5rLxbJ00rGsotC+dWua1K5NM5+PmraNIcu09Hio4nJRsVQppk6aRNwwKGfbVCpdmnxZwRJFHFHC9nhYs2ZNZp6F0ShPBcN8GUsQl2TqutxsiudgiiLvRKIpp21J4t5772Xjxo2E0tIJUyybiorCf4IhGrtT1c3NGzXCp2nkGCYVS5emwONhuuMjLstcnA60586dS040ipXWf27u8fBGOEodt5tTGjakd9eulIpEGNa/Pw1r1KCV46OG10slRaGDV+V0r8pllo0mivhkmVGmheZ2k6+40NPyIV5BZObMmTRr2BC3IFAgyzQ0DPxeL1dZNgsDQVRRRHO5qFmpEqNGjsSnqvTTUjp+jihSWXGhSRIdTjuNuMeLmTaCzJNlVkdinO71UlFR+CKWYLxpkZAkKikK5d1u6lapQti2qV+1KmvXrmX8BWMYrhuM0k1yZJmOhkHIshg/fnymMv1QJJNJ9u7dS9RxeCEYZoxhEvV4SmgFfvfdd0yZMoVrrrmGl156iYhh0NKrMs4w0dPmlHVcbgpkGVNxlUi8FhUVMWnSJGrXqIHldnOT42OeP4BP1zPfq37du1PRtom43Vxp2ayOxhlh2YwbN44zOnXF7dUxFDeFXp1cWeaLWIIZjp+EZZ2wkcmDDzxASNep4/dTpUyZk9JuTiaTtDnlFCqYJoYoMsQwiRkHt/Ru2bKFoGkyxXLoajsljCh/za5du2jUqBGCIDBp0qQTnleWLFlOnGyCOht//xNZtHAhIdsmbNvMnTsX51em2m5FOWnjtJPlwIEDzJs3j2nTprF58+a/dC6QSg7GDIO+Pj8Bw+Djjz8+6THrVK7MMNvhEtvB0TQsl4s8r5fGtWodUyX0mHPPpZFtM8G0CBgGX3755UnNZ9WqVdgeD+fqBvmyjE8UmZKu2H3mmWdOauxj4ey+fQl6vZSJxTLP99133yWs61xrO9S3baqXKcMFtsP7kRhhl4vOpsl0x4cmisz2+XknEsWWJB7wB1NFHn4/M2bMYNwFF3Dbbbcdc/J/0oUXUtWysUSJZ4JhVkfjRHS9xJrltwzp25dWtsPE9PtxJJ+iw7Ft2zZOa9YMn67Tq3OXEhsdy5cvp1fnzgwfOJAtW7YcdO6qVauI6TofRWPM9QWoXKrUcV173bp1TJ8+nbxIhELLJurzHfVzvn37dnJDIZp6PMRkmaBhsnnzZm699VZ6p9eONzu+EpXVv3DRmDFUtW16OD7yIpFMsRjAyKFDuSwtaTLetLjwEAnuP5r9+/ezYcOGY/rMfPvtt9StWxdRFJk+fToTJ15CoklP6k9ZSl6rIQwZds6fMOMsWf5vkU1QZ/lb8NRTT+FoGjHd4IyWLU+4raxnx450sh2usBwChnFIk5g9e/awYcOGowbpW7dupVJhIXmmSdTn45NPPjni8c8++yzXXHMN7733HnfOno3t9eIoChHDYOrkySddOfLTTz8xevRo6tSowdjzzmPHjh3s3bsXr+Li/UiMDyMxVJeLzZs3kwgGGW3ZdLFtTmvWjN27d3NqgwYYioIuSpyl6ZgeDzFNo7/jQ5dlHJeL2i43Z2s6lsvF2rVr2b17N/fffz8XXXQRmsuFI8uUCoUyrs0ffPABb7zxBm2bNaO7qvFsKExckrnoootKzP2eefPwqSq5hkFBOIwnndBVBYGIJFHZ7aF6+fIUFRWxd+9e4oEAE22HcyybqG0TVlVMUWSwptPTduhy2mmsXr2aUcOGMSkd6FxoWowfM4ZPPvkE0+3GJ4qcqxv01VJuzZviOQzRddyiSBvLYphuoIkiecEglcuVI55OsIYliVfDqU2OioqLiCSxKZ7DGbaN4XLhEQSG6gajTZMqpUuzbds2WjZsiNflon2LFtheL/8LR/kylsAvSZyrG0QkmdGGSVDTqFhYiCVJPBEMsTGWoIqq4vN4qOn1Ut/t5r1IjHYeL2paX7qGy8VXsQSXWzZRScIrSQzo1StT2QGpQLJymTJYokiBLLMwEGRTPIeGbg/tvCohXee1114D4NLJk8m1baoUFvL6669TPi8fSRDICwaJKS7aeb2MNkwijsPPP//Mrl27KJ1I0N12qG1ZeGWZth4PTdwe/KrK8OHDyVVTGwpvhqPYXi+ffPJJ5vPeqFYt4rJMSBSRBYGPonHW/sYssbi4mMcff5xhw4aR0HWGWzZBXeftt98GwFZc3OkLsDAQJE+WWRONM83xEVQUBvTrR6dWrZiX1tc+VupVqsyD/tRzahwIHNIo51jZuHEjAVXlq1iChf4gkigecpNt2bJlVE+7oL8RjpJzhGq2ffv20bNnTwRBYOJhpIT+bL755puTXihnyfJPIZugzsbf/wbO7tGDUpZFTDeYfOGFf/V0GNS7Nw1sh+62Q5mcHHbv3v2XzqdZ3brc/Euxhu0wbdq0kx7TJct8Fo2zMZbASlcPb4glyFcUlixZctTzDxw4wM3TpzN6xIhMxW5xcTFbt249oQ2GmTNn0sefqoad4/MTcLupVbkyjevU4amnnmLe3Lnkh8PUKFfuiIbOvyezZ8+mveNwkWkxWDNIWBa3OCl/kKCc6rLcFM+hmsvNNbbDR9EYliwz0nZ4JhgmYRi88847x33dZDLJrbfeii3LxCWZcaaJX1X56quvDntOpfx8ng2l5nNKMHhIGY6jcfH48XS1bT6IxGhq2xkpyW3bthGyLKbaDv1th1Pr1z/k+ZMmTMAty4Rsm1dfffWYr/v5558TNE26BQJEdJ0ZM2awcePGQ37viouL+fTTTzMdlGe0aEFPTePhQJCuPj+zZs1i/fr1RByH9oEgYV0/pLZ62Xic59PFYvV+Uyz24IMPUto0udJ2yDOMk4q9T4RNmzZRJieHiK5ToaCghJzh4di1axddu3ZFEARatGiBP7ccFfpeS6hMdW6aNv1PmHWWLP+3yCaos/xt2Lp1K59//vlJJWK2b9/OhAsuoM+ZZx5Ra2/btm0M6t2bJjVqHJTY2rhxI4888ggTJ06kS1qO4WLLZlDv3ocd7+GHHiLHMDjHtgnoOsuXL+fbb79l7dq1v0tiqaioiKply9LW66Wpx0OOotA77Qh+7RVXYHu92F4vV06ZAsCaNWs4b/hwJl10UaaaNZlM0qZJE2amA/G+/gDnnXceI0aMoKxp8oAvQHlFQRNF7rzzzhLXr5iXz4JAkC9iCUpZViZxCCnTDkeWmeGkEm8tPB6qli9/0D1s2LCBFStW8NBDD+FXVUKyglcQCEkSQcsqscP+ySef0OfMMxnUpw+XX3YZbU89lQa2ndGaq1KqFG+++Sa33347EV3nHNshpOu8/PLLzJw5kxxFoaHbzdW2w4vBMLooUigrqGn5iP66QUxKSWRcYTlYksSHoQgDNR0jXdncR9OJShKmKDLFtDHdbhrWq0cwnTAequt4RZFqZcoydNAgLh4/nnvuuQef240jilhp+Y9uXi/XpdvqRqYNOMvl5DBEN1gYCGKIIpeYNuNMiz5piZQxlk1BJIIqy1iKgiqK+CWJKy0bQ5Lo0alTiUTh9OnTaW87POwPEpdl2moaMxw/pigy1xfgfNNi8uTJPP/886iiyE2Oj7M0HUNRUAQBtygiSQq6ovBu2vixos/H+++/z7vvvkslX+oz09qTSqL3UjVKyTKSKPLtt9/i03Xu8Pk537SwJImornPu4MFs2bIFVZJYE43zSTSOVxCISTKFqkb3Dh0y343XX38d0/Hji+aRX1iWyZMnl/iMBVSVOi43wzUdSxRRBIGwJBHzeKiQ1sgrMM1jWvj9Qtd27RhmOzwZDBHVdV588cVjPve37Nq1i6BlMd3xMdl2KHcY48Xt27eTH4lylu1Q13YYMWjQEcctKipi2LBhCILAiBEj/tLKt1unT8f2egmoKheMGPGXzSNLlj+LbIL63xd/7927l6+++uqEO2/+iSSTSd555x1WrFjxV08FgKBpZuKM8o7zpyVED8XGjRsxXS7quNzM9PkJK8ohjQOPlUkTJqC53QS8KnV1neYeD6YoMsm0eC4UxpIkHn300eMed8uWLVQrWxbT7aZqmTKHrLI9HD/88AP9+/bFcbm40naobdk0rV+fU22H6Y6PkKZhejz8NxjmRttHlcLC457f0bhl2jRiPh81ypVj1apVALzxxhuookh/TSdflgnrOqYkEfB4KBWNUs6yONPnJ2xZGG43psfDecOH07pxY8rGE9x8000nPJ/WjRsz3rJ5NhTGFkXGjB59xOPHnHsudW2bYZZNxHGO6/n/wohBgxmbLqjpY9lcddVVQMqjp3R6fbM8EsOn64cd48CBAyXWlDt37uTNN988YifCzTffTD/f/694rpSfj+52Y6kqTzzxROa4/fv307pJExKGgU/XWbJkCaOGDaO77fBcKExF284cv2nTJh566CFWrlx5yGv26NCBLrbNtXaqWOzXRoPJZJL777uPYf37l+jU/LOYMHYsQ371Pky59NJjOq+4uJgJEyYgCAKly5Sheu16jJ9w0e+i054lS5aSZBPUWf5PMrhPH7rZDvf7g8QNg7feeguAzz77jJBl0TYYxPZ4qKobrIrG6Wc7jB4+/LDj9e7ShZvSid+hts211177u87366+/xu/xsDGWYH0sgSQIlEskMq9/8803B+l8HYprr7ySWrbNFZZDOF2h+uGHHxLSNHyixI22jw5eFUtR+OGHHzLn1SpfgRmOnw8iMWK6kQlKvv76a26++WbiXi9+SaKmy40mirRv0eKwc6hVvjwPB4LUcrm4zx9gYyxBRcVFy6ZN6dutGytWrODzzz9nz549XH355dS2bS4xbTRJ4jTHRynTokH16uR6vQRlmajjUK1yZQb278+ePXt4++23cRSFpm4PjihiiyKaIHC3z8/TwRCqomCrKnmSxDxfgAtNC8vlorTLRZ4skyNJeNOVyDFJJuH3Y7s9GIKAKQioQsoAMSRJLAtHuci0KKUo9LYs4qbFZNPGL0oM1g3KKKmkeJ4sc5XtEHS7adWqFaYo0sDtprrLRTBdJR2TZERBIOhyEXEcVq9ezU8//cSBAweoUaECsiAQkCRaerw09Hgpn5+fCVR/SVBviCUYaFnkh8OEZYXWHi+WKBLTNJ5++mmuuuoqSisKm+I5PBUM4REE/heO8kQwhNflwVE1mpoWAy2bvEiEnTt3snXrVkKWxRQrpT3+UTS1sIzIMt06dgRSWnXN69bFkCSeDob4LBrH8nhYv349hizjShtD6oKA4XZz1113lUi2Vq9dj8KOY6l36RJilRpw//33l/jM1K9enVoud6pq2+slHgggiyIV8/O5wUol/wfbDtdff/0xfJtSfPvtt7Rv0YIcvx9NUTA9Hi6fPPmYz/8tb731Fq0aNeKMli2PqGP5zTffcMMNN3DPPfccU5IkmUxy4YUXIggCvXv3Zvv27dx6661ceeWVf7jx6q/noLndvBmO8kk0ju31/mnXzpLlryKboP53xd+ff/45OaEQEV2nZoUKJTbFs/x5tGvalJ62w2QrJUPyV74Pb775JhVtm/GGSTO3h6BpnvBY7733HrmmyfuRGNdYNposc45u0NDlIixJ+CUJn66fkJzYpZMm0duy2RhL0Md2mHQcutENqlenl23TVtMI6TrTb7qJ5nXqcG+6orqDz4/f62V9LMGLoQhRn++453ckPvnkEyK6zkuhCFfZDg2qVgNSWsTNfKnClhouFxNMi6eDYQxRpFq5cixYsIBZs2bx7bffsn379hK+KCdL9dKlWRRISYXU8PmOqoNcVFTEXXfdxZQpU44oBXIkPv30U6I+H2Udh8J4PLNm27t3L5UKC+ng+KjjOEfVhv6F77//nrK5uVTx+QgYxmG1kJcuXUqBaTLXF6COYRJwu/kkGuexQIiCSKTEcTWclBTkPH+ABlWqsG3bNrqfcQblc3KYfNFFx1xw9fPPPzNm1Ch6dezI66+/fkzn/FlMnjiRbrbNuliCDrbN1VdffVzn33nnnciyTNWqVY9YdZ8lS5YTJ5ugzvKP5fPPP2fx4sXH1J7zW5rWqpUJztoFAjz44IMAXH755QxOy0FMtWzK5eSgezw0rVOH77///pBj7dixgy6dOlFZ07jRThkOvvDCCyd1b79l//795IXDnGeYKQkOSaL1qace0mTtSBQXFzPjllsY0rdvpkXtxx9/pG3r1pSRU4nLJcEwtiSVkDTp0a0bWlqioXq58lw4ZgytGzXCUlWaBgJookgTr5e4JBEyjCMGcG2aNGG0adHI7Wa0YfJiKIJfkuisqoxIy27kGAa5oRAVCgsZoRtsiCXo6vjo168fjz/+OLrLxZpYglWRGJ500tgrirRu3hxIJWxtSaKCLDNaS5nqvR6OsjAQJGzbtGrVCksUKasoJGSZoCzjEQQe8AV4KhBCFgSutRzm+gJ4RZHzTItRukE3VWNtNE5ZWaGiorAhluAefwBTFIlLMoogUNrrpZnHw6Z4Dk8EQ+TKMjfaDgWyTMV0NbQuCNRQXKlzBYFSaUf1z6NxqpoWU6ZMYe3atZlnNnHCBDqYFq+FItR1uWju9qAIAhXy81m9ejXbt2+nStmymJJExLKoUlhIV6/KbY6f1prOqLR5zMqVK9EliRYeD6VkGa8g8FE0xqvhCC5JxvRo+D0emjZuzH//+1/aNmnC6c2b88gjj9C+ZUsCXi9ddIOzdB3d4ylRaZRMJgnZNvf6AzwRCGIoCnmBIEFFYVk4yiTTIjcQPMgAde5dd6GrOrEGXalxwf34EqVLGMUUFRUhiSJrYwk2xhIEVJVNmzZx4MABHn/88ZR2pOPDr+t89NFHx/V9SCaT6B4Pr4ejrIjEMD2eEhszR2PBggXUKFOG1o0a88UXXxzXtY+Xa665BkEQCEeihMrVIV6nPTn5pU7IQf14+eW9fTgQ5PlQBMvr5ccff/zDr5sly19JNkH974q/h/Trx7h0V1wH2+GWW275q6f0jyKZTLJz586T7gr88ccfuWDkSPr37MmHH3540vN67bXXmD179gnJT+3du5falSrRyJ/qwrr68stPah4VbJv1sQT3+QMEPB6usx2eDYUxXS6GDhzIunXrSpyTTCZ58MEHufjCC48oV3HZpZfSPV2E0NN2uPQYvSkOHDiAJIp8mY6f/F4v33zzDReMHk2Ox0Nvy0oV5TRvTinLIqBp3H7rrSf8DH6R/fv15vuyZcsoZ9t8GUvwRDCUMfhbt24dfk2nqduNT5IYpOtsiMaprLhoqBvceOONJzyP37J7926eeeYZ3n//fSDlQRLQNCo6Do1q1mTv3r2HPXf//v3cdtttXHzhhbz77rvMnDmTe++994QqZ7dv387KlSsPktfYunUrM2fO5IEHHjjm7o5Zs2bRKV0ZfZ3t0L19+8MeO+eOO2jTqBHDBg0ipGmsjMR4yB+kdDyeOeZ///sfBWnD9sG6QZm8fF555ZXjvse/Oz/++COn1K6DJIq0bNSI7du3H/cYzz//PJZlEYlETkhmJkuWLEcmm6DO8o/kxRdfJKDrtAwGifp8xx2Y3jt/PjHDoE0gSF4kkmnXat28OWUUhUcDIeq7PUy+5JKjjtWiYUPaWjbVvCoJy2bBggUndE9HY+3atVQqVQpdFKmoKLQxDGpWqHBS7UWbN28mPxKliT+ALorUdbkpUBTKJBKZIGnt2rVoosjNjo8uXi+GKNHM42Wa40tJZ0gykiAQsSzmz59fojL2mWee4eabby5R+dC7WzdyFIWwmJLP0NOSDetiCc43THprGutiCaKyzCmqSqGiEEsnfysXFvLpp59iejzM9weYZFk4osSnaWdrS1GAVDBaPj+fDo5DfcehUa1aGF4vIcsmPxajiaZhpIP2T6JxFEFgkmFipqU5FEFAS7ce6rLC6R4vtijSV9PZGEvQxatSKCtEJAlVFLnLF+AKyyaq6xTEYuhpA5pKikJCknktFKGlx8uVtkNLj5drbQdVFKnlcqPJMo6icJ3t8FUsQQ2PBzMQRbd9PPzwwySTSRYsWECtqlUxFIVoOqm+IhLjMtuhTeMmrFu3joCuc53t0MI00SSJ4bpBOUXBcrlYsWIFq1atolQsRo20jnaeJNPM5UYVRdyCgCK7eCMUThnRqCphx+F62+EKx0c8EMCUJCrICqYgoosS/U0L2+XilFq1Mm1/L7/8MmVzcghZFqU1naWhMGeqGn01nRmOn1Pr1QNSi7JpN9xA++bNqVK6NNdaNlU1C5fi5pTmpx60AK5apgzn2g4X2w45oVAJc5kBffrgkiQijnNEWZ9DkUwmcTSN/wbD/C8cxfR4jrma68UXX8TrcjNQ15lg2TSqUeO4rn0izJo1C0EQMHIqUfuix/DH8n4XQ6dj4bnnniMRCBIwTebPm/enXDNLlr+SbIL63xV/jxw6lEG2wxexBM0dhzvuuOOvntI/hm+//ZYqZcrgURQa1ax53MURfxTz77mHhGHQ3e8nbNsnlKTetWsXjz/+eIlKz2QyyX333cfEiy/OJDWPRlFREV1OO42wpuFoGrfffjtVCgsJWRbTD5Nsvfmmm6hoWVxgWgR0PSN/8Vu2bt1K3SpVcMsydSpXPq5q4rxAgHZeL91VDUOWWbJkCUFdp6uqEvR4uPqqqyguLmb58uUntdH+a+P0LqedlonjioqKOP3UUykwLWyPh86dOmV0h4cNHkwDVeVBf5AcWSYiSdRzu2lv2b9bgnrPnj3UqVyZun4/McNgxs03A6kE+bJly0rEk4fi3MGDaWTbnGtZaJJMG8umgePQr3v332V+J8qiRYuoZtu8Ho7Sx3Y4d/DgYzpvysSJuGUZn64fVGRyyfjx6G43hiQx1LIPafb9R7BixQpuvPHGk5LaO15OVjJv1apV5Ofno6oqjz322O80qyxZssCR4++/PNA90T9/5wA5y+9Dr44duT6t69vH8Z2Qqcl7773HggULSlRGl4pEGKTp1HK5yfF6ee655/jpp58yP2TJZJJ5c+cyfOBAnn76afbt24csSXyVrk6wvd4T0ib7hWQyyYYNGw65o/v111/jeL24BYFP0uYrccM4ZEC5ePFigqaJXzd48IEHDnu9u+66i45p07bbHT8VcnKZPHlyiWqCJUuWUM3tZlM8h6eDKb22X0z4mno8xMTU/bf9TcXDwP79sUSROi43hqzwySef8Omnn2IpCs3dHu5w/JSRU6aNjiTRxO2hrKxwqsfD4kCIHFlmYyzBO5EomijyUijCENOiV6dOPPHEEziKgpVOKH8UjXGvP0DENNm1axeNatYkomkYXi9Tp07N6LYtX76c8o7DmmgcSxS50fbR1O3BL4o0dnto4nbjlyRWRmIsDoQwFQXdlTJKHP0ryQ5dkgh5VfyWRWXDYF0swfW2Q8sGDTi7Rw9ae7zUdLlwRIlOXhWvIBKQZcYZJo4ocqlpEZMkBpkWtSpXxvF60dLJesPlIVauIeFSNcgtKGRI//5UsCw6+vwUxuMMGzaMKrrBl7EEs31+GteowdNPP03TYOo9GWOYtFJVNsVzeNAfpHrp0lQsVQq/x4Mjy7wQijDaMFAFgUJZxhIE+mk6hYpCV1Vliu1QqVQhpsfD+liCNbEEsihiCqmE/hDdYKxpMUg3aOHxcqvjI6IbJXQkf/25usXx4ZMVAqbJG2+8AcC8efOoYtnc6QtQXlUpVFWmOT5ihsGyZcsO+pxu3LiRQb170+fMM1m9enXm71euXElMN1gRiTHT56dG2XJH/oKlefzxx6lVrhwtGjTgtttuw9Y0NLebO9KmNUfju+++w3T8xBp1J5goTwfDIi8UOqZzT5YKlaogCCIuw48/lJJhyZIly+9PNkH974q/v/vuO+pWqYIsSXRs3fpP6T75tzBm1CgG2TYb0tXnN9xww182l+LiYm6ZPp1+3btTo0IF7vSluiHP9Ae46667fpdrXHfVVVS2LM43LQKGwWeffXZM5yWTSdavX58xsS4uLubWm2+md5cuPPzQQwcdf1rTptydnn8vf+Comya7du067nvJDQQYphuMNy2q+3wMGTKERqrG9bbDjbZDrw4djnvMQ2F6vbwbibE+liCi6SW6AIuKinjwwQfxqSrnmxYFpsm98+fTr3t3rkmv5QaZFo5p4lUUGtaoUWIT5GSq9l955RWq+VLmi/8NhimXyDmu88vn5GQM/6q4XDzkD/BkMIjX5Tqh6ttDsWfPHq656iouGDmyRPfqkSguLuaCESPICQQ4vXnz49q02Ldv32ETtJdMnMj5psWmeA6XWzbnDBhwzOOeCCtWrMCw/eQ07IwViP5hRV5/BN999x3169dHFEVuuOGGv4WZeZYs/waOFH9LQpYsf1MKypYVXhYE4d19+4T3k0mhVKlSxz1G7dq1hZ49ewrBYDDzdw0bNxa+cSlCW1UVdiuKMGncOCEnHBYqFBQIGzZsEO6aM0e4YcwYIfrY48LQnj2F//3vf0LVsmWFqbt2Ctfs3iUEAwHB7/cf0/XfeustoVfHjsLIIUOFrVu3CsXFxUL3Dh2EmuXLC/nRqPDss88KgDDuvPOEqM8n9O7SRSgCobTiEqbt+FmYvXOHkHS5hFgsVmLcoqIioXf37sJcj1d4WNOEoQMHCrt37z7kHPLy8oRVB4qE5fv3Ca8ki4WmLVsIV155peDxeDLH1K9fX/heN4SBP/4g9Nn6g7BfkoSx234SJmz7SVh14IAgiIIgCYKgK7JQVFSUOe+JBx8UbvP5hSdCYaGGLAvtW7cWenTqJAQQhNaqKkzavk0oFgThMssWihGEIgFhH0nhvX37he5bvxe2JpPCwj27hTt37xY8oih0+WGLsGDnDuGjjz4SVi5fLuwRBCHpdgt1GjcWam7ZLJy3e5fwwOOPC4sXLxZcX34pvGv7hMker7D89dcFRVEEURSFvLw84YeiIuHxPbsFRRSFG3b8LOiSKIw2LeH9/fuFhCwLpOePIAiGaQmKLAtVXW7BlCRhrGEKiKLgUhShdoP6wv0PPyyUql9fqLb1e2G6JAo3zJwpXHbttcKbB/YLm4qKhatsR5jpDwhdfD6haYcOwsf16wm63y8ssEwhp1IlYW/rVkIsFBYqJJNCZUUR6rjcwoED+4QB334idNryhbDtq/XCY/ffL1Q/UCTMUjXB2btX6Nmzp5CoXUtosH2bMHH/PuGKadOEBg0aCF+AMGH3LuE/AsK7xcXCXTt3CDOK9gvffPed8M1XXwnnuD1CM5db6PzDFuG1ffsEBEHYYVlCDVUTrnV8wg22T3gDhGWVKgmP/vdp4dSmTYVue3YLZ+7ZJbQ59VThgCgIT+3ZI3xdVCQ8vHuXsGzfXmGQbghnarpQx+sVPv7448x737lzZ2GV1yt03bdHuPLAfuG2e+cLX337rdC4cWNBEAThow8+ENqDcLqqCp0Vl5CoXl14t1lT4fZ77xUaNmx40Oc0JydHmPvgg8IDjz4qVKhQIfP3+/btE7yyJGiSJPglSdi3b98Rv3OPPfaYUDYnR+jbrZsw7ocfhUarPxXmz5ol/LRzp7Bjzx5h+MiRRzz/Fz788EPBiJYS8loNFqLtRwtLi4qF8ydMOKZzT5a3lr0hnNntTCG552fBZxnCtm3b/pTrZsmSJcs/mUgkIrzz0UfCgaIi4cnnnhO8Xu9fPaV/DIAgIQiiIAiSgJBMJn+3sd977z3hvvvuE7755ptjOv7mm24S5l9+uVD5ueeFTevWCXP27xOe3rNbeHP/PqFSpUq/y5ye+89/hAsVlzDBtIRmXq+wbNmywx67b98+IbWeFgRRFIWCggLBtm1BEARh5m23CfOmThVqvfyKMGHYMOG5554rcW7T1q2F25NFwpydO4QX9u0VGjRocMR5aZp23PfSsnVrYY0iC3tFUfg2mRTeevllQUkWC0/u2SNct2uncEqbNsc95qGIBoPCS3v3CG/t3yfsIyn4fL7Ma/v37xfuufNOIVZULDRyu4XRsiIsfeIJoXr9+sL1e3YLw/ekYtdlb78tbPnxR+F/778vWJYlbN++XWjZsKHgUhShRYMGws8//3zc80okEsI3+/YJ/9u/T3j2wH4hLz/vuM4/pXlz4Zr9+4Sbd+4QvigqEh7YtVs4e+uPQllJEupVqyZs3779uOf0W4b1O1t46cYbBeG++4XmDRsKP/zww1HPkSRJuHnWLGHjDz8I/3355WNeewqCILjdbkGSDp3mqVe/vvAfAWHh7l3CQgGhTqNGxzzuifDss88KTqWmQqL1cCHYuLew4NHH/9Dr/Z5EIhHh5ZdfFrp16yZceOGFwjnnnCMcOHDgr55Wliz/bg6Xuf67//k7V3Bk+X3YtWsXQ/v1o3b58lw1dervtmu5a9cuLps8mXMGDGDChAmcltZ8G2k7DB84iH7du3ODndL8Gp52Yf722285/9xzGTl0aMYw4ccff6Rlw4boHg9d2rU7qFJn8+bNBAyDa2yHPrbD6c2b8+qrr1Ihbdxwrz9ArfLleeKJJ6hs2ywLRxlsOzRv0ICw7RDQNNqccsohNXdXr16NLAi8F4mxMhLDLQhHbMe8cOw4HEUh4HJRKh4/pPnZt99+S5lEgtNMk5aGgTetm+ykpRVsr5daFSvy448/UlxczB2zZmHJCmeqGgsCQaKShFuWyfP5uDZdLXGubtDBm6r07eH4yI3FyFEUPovGeSIYokxODi0bNODM9u1RBIEPIzGWR2J4ZBnH6+XDdJVzzO/n66+/5rHHHuP999+nX79+RD0engyGON926NW5M5s3b+a8c85hSL9+PPzww3Ru0wbd5cIWRV5OV0aUVRSikoRHEFAEAUtVefLJJ7n2yitxyTKmKGKIIo8EQnwRSxCSJCpYFhULSrFu3bpMm+CXX35JuVKliLtc1Hd7uMPnJ8cwefnllw/5/CdccAFeUWRFJMbb4QimKLLxl8plQWBVJIYiCFxnOziaxrXXXstbb73F2rVrS7yvGzdu5Oabb+axxx7j5ZdfZujZZ1OpsJAxpsnLoQgJWSZPlhmsG2yK53CRadGnRw98qspUy6aBVyViGMT9fubccQf79+9n8eLFPPXUUxQVFTFz5kz8qoohCKiiSNi0yPGq9PT5iTgOmzZtAmD9+vWsWrWKbdu28cILL7BmzRpWrFhRQiv+9ddfJ6jr9PEHCGj6MZmoFBcX88MPP5So+kgmk5zdoweO14uTNoI8HN9//z22qnKD7ZCQZTbEErwWjhBxnKNe+7d88803WL4AOc36EShTi05dux33GCfCkiVLmDx5Mq+88gqvvPIKpmlSUFBwwqY9fyQbNmzgqaee4uuvv/6rp5IlywkhZCuos/F3FiDVwVehoADd5aJe1aqZCuGTZcGCBcQMgw6BlFzfxo0bj3pO9/btuSVtSj7I8dH8lFM4vVmzI3YLHi9TJk6krm0z2bJLSG+sX7+ecwYM4NzBQ9iwYQP9unfHJcvkhsMZ8/Bf07dbt8ya4ZxDGLIVFxcza+ZMzh0y5LAx4smyd+9ebrzxRiaMHcuyZcuwvV42xBJ8me6OO5rExbHywQcf0KBqVaoWFmYkPCD1zJo3/n/snXm4TdX/x8/eZ9jnnD2ffeZzL/dernmWeSbzmBCiTFGhMiSENCopKpWioqKoL18VUSmkKCQSMmQOJSmZ3fP6/XFP90fXcImm73k9T88jZ6211953X+ezPuuz3u9qVPRmy9BpgkBBWaZP796EZJmOXhldknjppZdyjXnfvffSUtfZHInRStcZOWLEJc1t6quvUq5QIZrUqcOOHTsuqu+xY8d45OGHuf3WW3nzzTdJ0XVeTngY1fJZueQdVqxYwaxZsy6qujotGGRxMHstcpVlsXjx4rO2O3LkCBs2bLjipz+mTJ5Mh1atePqpp654VfD777+P7o+Q0XIA/vTiPDz68mmP/1lkZWUxZMgQbDYb9evXv2z/PiZJ8r/K+eLvvzzQvdT/kgHyP5fZs2eTLxgkfzDInDlz/tK5PPnkkzRM6AL30nVu6d6dV15+mTRVpZ+iEpDlc7om3zVgAG11g6/DUerpBk/8znRk2bJllEiYWywJhon6fHz22WfkU1VWhyKM1k2qlSnDiy++SEOfj52RGI8ZJs3r1TvvnI8cOcLXX3+NkpC/UAUBvyyft0+fnj25XdOz5VI0nfvvvz9Xmx9//BHV5WJnJMb2ROK0ZyKofPvtt9m2bVtO4vCh+++nsCTRT1FRBIGwKBIT7cTsDrwJCY0+ioosCITcbrrrBobHQ8DjwRAErvF4SXU40d1uMnSdfKEQssvFvEAw2+FbkjDdbr4KR3jLH8CvacT8fmqZPrw2G4UdDnrJCm5BoFhGBtu2baNK6dLcqOsM1HRifj+rV69Gd7loILkp6nDSxuPFYxNQbDYsSeLxxx8/I2gvX7QoA1SNgg4H4w0fK0IR/KLIh4EQtTQNr8uFKcs8+8wzBDSNaxWVqMNBZv78NK1dm5enTDnn8z98+DD5AwE6emWGqBqq3U4Dw6CM00Vll4spPgvZ6aR25cpokkRrWcF0OpkxY8ZZx8vKymLp0qWsXLmSMgUL8oov26m8sMOBQxAo5ZF5PxCitqww/O67MRWF8i4XmQ4HAUHgEd3A5/Hmcqc+duwYsiAwUtOZYflxCwIvvvgi48ePz9F9fOLxx/F5PMQUhc5t23L06FFqVaxIuqZher0888wz9LzxRgbcdhuLFi3i6aefPq9J0rp163j33XfZunUrZQoXRpUkihcokMsYdc+ePRw6dOic4wBs2rSJiCyzKRylotNFAYeDmKLw0H33nbffuVi9ejW9+97GI4+MvmwLvPMxa9YsNCtMrGZHFMPio48+Yvny5ViWRSgUYvXq1Vd8Dnnliy++QDV8RItVQvf5/zSd7CRJLifJBHUy/k7y/2RlZfHTTz9d1oRVk1q1mGD6ciQ6nnvuuQv2eXnKFPKrKr307OTxpRot/vTTT7zwwgvMnj071z2dOnWKJ594glu6d89JFp46dYr0SIS+mk5P3aBANEpJw2BTJMYDukHjmjVz+v8WD8+YMYOYotBLN7BkmRUrVlzUHPfs2cOgAQMYPHDgRckHxuNxXnzxRfr07HmGzvDJkyfJHwozQDe4VTconpFxUfO5WDZu3IhfVWno8WKJIlN8FtVkmZt79WLA7XdwV0JKYpimc9stt+TqP3TwYLok1ifdNJ3Bd955ReebF65r0YJuusEsK0BMUfjss89yPpvwzDNEFIXqpkmhfPnynKTufv311NR1btZ0wqaZI9cRj8dzYtutW7eSGgySpmlkRKP/qs3/kSNHUiizEB2v7/SHfJUuF3v27KHsVZWQ3B7adbg+z3N68cUXcTgcFCtWjK1bt17ZSSZJ8i8mmaBOkiceHTUKnyxTKDWVlStXXpFrHD9+HM3j4U0rwAzLj+71/qVfVL/++iu1K1VCcjgompaeU9nx3//+lyGDB59zhxuyzXh+S/p2TFRan87hw4fJTE2lpWlSWte5rVcv4vE4d/Xrh+RwkB6J8MUXX3Dw4EFKFCxIEcPAUpRc1zx16lROcmzmzJl4nC50UaRANIrH6SJoGHz44Yfnvc8hd97JtbrO2nMk0yE72C6YksItqkZXWSbD7mBHOEo+h4OoLJMvFMpJaFYoVoznEguOVm4PmiDQSHKzLBimk8eLRxTJJ9pp6/HgFkVGjBjB3XffTYbTRaooIgsCJRwOdJvA2/4gPTSdls2b41MULFXlzTfeYNigQXicTlS3mx49etA2oXdcwO5glhXIrmzQ9JzKBqfdzsaEbndEUXjhhReo6rPYEYmhCAI9ZIXFgRCaINDZK1NQVXlk1ChGDB/OyHvuQRGy5/KWFUAWBJyCQAXJzbv+IEFRZIxucI+m47DZqOaS2BVN4XXLjymKDB88+JzP/pdffqFts2ak+v2ULVKEzm3asGzZMiZMmMDAgQMpnJpKsbQ0FixYwF133UW3RPXzw7pBodPct0/nhnbtCHu9aA4HblHEKwhERTsF7A6aShKKKOL3ernxuutYuXIlQbebVLsdOWEKGRHtWG53rmqgU6dO4bLZKO50UsHpwhCEXO7VPllhcTDE5oQG4aRJkyhvmuxInAowHA7u1HTa6wZ1K1c+73s5bepUArJMZZ9FQNe5TtPZGYlxo65z18CB5+17NuLxOK0bN6agphP2eul2440XvVj8K+na/SbyN7yZSiPmEat1PYOHDAHg66+/JhaLYRjGWfW7/wpu7d2X1Do3Zs+1+nUMuuvcvwNJkvxdSSaok/F3kitL/z59aKwbTPFZpCoqCxcuzFO/uXPn8uCDD17yeuTIkSMUy8igoc9HUV3nzttvv2Cf77//Hk2S/r9QQxAorRt8G4nxqG5Sv1o1srKy6HnjjThEkQKxGOvWreODDz7goYceuuh4Iysri2IZGdyo6Vyv65QrWjTPmwNPP/UURTWNYZpO8HfFNJs2baJL+/b06Nz5oquJL5YxY8ZwY6LafYxhUsjpJGQY7NmzhzfffJN0VWWUblBAVXnttddy9f/uu+/ITE0lIisUTEn5WyRlv//+e65p2JBSBQow/sknWbZsGQ899BALFiwgPRDgP4k1SAmnkzvy8F5B9vp33LhxDLnrrhxfoc2bN5MRjeJ2OGhQowa33XortyTWlV00neHDhl3Bu/zzWLlyJX5Zpp+ikqlpTHjmmb96StzYtTuxKtdQ/s43CBQoxSuvvJLnvh9++CGGYRAMBlm2bNkVnGWSJP9ekgnqJBdkw4YNBL0yS4JhHjNMyhYufEWuc+jQITxOJ1+Fo3wVjiA5HH+Zic3o0aOJqRoZ4TALFy686IqRTZs2EfP7ya9pZKam5qr4BNi/fz9PP/0006dPzyVbcDpHjx5lxYoVuaon3nnnHXSvF8nh4L7hwwkbBpYoMt7wUVty0/m66zh+/Dg3XncdEdOkbbNmZzVUO3jwIPWrVUORJFo3bpzzzHfv3s2t3Xtw0w03sGXLFqZNm4bldFLW4US22QiKIpYg8qrPoruq5VQ2dGh3HWl2B/0UFU0QcNts5Lc70AUBfyIB/VEgyK5oCmmindKZmZheL7LNxpZwlC9DESSbjTZuD0NVnSa6wUO/OxYJ2e/LsWPHmDNnDgU1jZlWgIJ2OxVdLoaqOrok8e233wJQr2o1amgarQyDkgUz2b9/PwViMa7WdGRB4CWfxafBbDPGz0NhnjBMTLebGzSd+l4ZQxDwiSLpdgdeQWDnzp00q1ePzGgUtyiyPBhGEQSeMkxMQWSsYdJActPa7cFls3Fbr1489sgj+BSFQqmpOQuVO/v1o6GqsSAQ5CrdYPLkyed8p+6//36idjvPmxZXOV0ENS1Xm7179+J1OMhnt3Odx4vbZuNWr4xfENgcjrI4GEJ3OnPa/+c//8ErCHT0eOmZSH4/ohtkRqO5DFSOHDmC7HDwvGnxuGEi2+0M7N+fadOm5byzGZEoT5s+3vUH0d0e5syZQz5VZUkwzF2ajs/hYFc0ha/CEVS3+5z3ClClVKmcY5RpHg+tFJUdkRgddYMhgwadt++5OHXqFEuXLj2rNM4fYevWrVQuVYqQYTAikTi+3EyZMgUjkp/8jW5FD0TOkDPZunUrBQoUwOv1nlEt9Vcx+tExBAqVp3j3J/BnlLyg8VOSJH9HkgnqZPyd5Mpy+PBh+vbsSZ0KFXh+woQ/7brLli2jeOIU48fBMDGf74J9srKyqFSqFE0Ng/qGQb2qVWnVsCGqK7sYZPny5cyfP59ius6GcJSRv6uqvlh+O7m4NhRhkKphF4Q8J2jbN2+eI4PSwzDPaWqZlZVFn5t6EtR16lerdoZp/OXg7bffJkPVmOKzqK4oNLr66jMqS195+WW6dezI5JdeOuc668SJE2zbto0TJ05c1rn9np9++olFixaxb9++PPf59NNP8csyvXQdQ5Kw7HY6e2Wm+vz4RRFLVc/ab//+/Rw4cOC8Y3du05YBusG2SIxahkmLZs1oqeu8HwhSQZbPetr1n8jjjz9O10RR03jDR+tGjf7qKXFNm+vI36AnFYe/S6RkzYuOYdevX09GRgZut5s33njjCs0ySZJ/L8kEdZILsnz5ctI1jW8jsWxt4HNUbl4OBvfvT9ArE/B6GXaJSag/yqpVq/AKAo8ZJo0kN36v94J9tm3bRvOrr6ZamTI5iaPDhw+zYcMGjh07dkXmGbMs3rQCfBmK4PN4sFSVhpKbXdEUXvH5qVKiBE8++SQ1dZ1lwTBNdIORw4fnefzShQpxk65zu26QFo7Qu3dvDFEkZrfjtdnQBYHSTiemIOCx2eh9660A7Nq1C3fi72SbjRIFC2K6XMyyAmyLxIjZ7ZRxOuklKyiCQB/dYFkwTFgUKeNwUtHpQrPZ8IoiHqeTZvXqnTWx/htZWVkMGzyYdL8fr82GZLNhOF051Rh39etHVJax3G6uKlMmJyj88ccfmTx5MpXKl0ey2RBtNlw2G2UdDgrLMv5EMnVjOIrdZsMQBKq4XJQrVeqM69erXh3JZsvR/X5EM1BsNvLZ7ThsNhRBIMPrxSdJfBwMM9YwKZ2Zyd69ewkoCrogUNDhoLWqMWTIEL777ruz3ufBgwexVJV0p5OYJDHwtttytTl8+DCG3Z6T2K0jSeiCQGpCf7qo3UFmyv87mJcpUoQ0u51XfBZR0c7jhkkpVWXc44/nGnvfvn1oksSWSIx14SiizcYdikoRTePJsWMBWLp0KUXz5yfF72dyQk/wvhEjCOo6VxUrRno0SlvdoKZucF3Llhw/fpxPP/00RyLkdE4/RhmRZUoXKoTTbqd8sWLnXEQdOHCAt99+m2+++easn18pmtWrR3/dYEkwTLqq8eGHH/Luu++yYMGCy3YcOh6PM3nyFG7o2v2sAe+ePXsoWbIkLpcrlybin82JEyfodUtvMouWoO8d/Tl16tRfOp8kSS6FZII6GX8n+Xeyd+9efLLM44ZJN92gQfXqeer3888/M27cOMaPH8/69ev56quv+OGHH3KSp2+99RblTZNtkRjjDJM6lSpd8hyzsrIoU7gwEbudZm4PLT1eyhcrlqeYYuJzz1FQVRmoavhl+QwZitOZPn06ZRIx+A26Qa8uXfI8v61bt9Lp2ja0a948R6P7bDw5diyZsRh+r5e6laucM8b9K9m2bRtRy+Iqy8KvanmWjRk+fDi3JWRKKrtc3CIraIJASaeTm7wKGZFIrj73jxiBKkmoksT4s5xY/Y3ObdpyZ0JmsrZhMn78eMqXKIFHECgkuSmWnn5ef6F/CkuXLiUoy9yj6ZTQdMY99thfPSW+/PJLTH8QPRClSPFL09z//vvvqVq1KjabjYceeuiKa3knSfJvIpmgTnJBsrKyaNOsGWFZRvd4eG3atCtynb1799K6USNKZWQw+uGHL2mMb775hs8+++wPJUQmTpxIBZeLXdEUZlkBNEG84BdLtbJluUM3eMG08MnyRQdgv/zyCz06daJG2bK8MGnSedsePnyYoYMGoblczPYH+Cocxe/1MnbsWDyCQFO3h4gk8cz48YwYPpzuiSNh/TWdvjffnKf5rFy5ElEQ2BaJsTMSw5AkvI5s+YwXTAvFJlDW6WRXNIV3/EFidju1KlQgHo+zdu1a0lSVzwIhFgZCqHY7EbudBzU9+/8FgaoJiYiA282Tho8d4Si6KHK7ojJAUfEIApooElIUnjvPzvXRo0epVLo0XkHAabOxOBji40AIt82GKkl88sknOO12vgpH2RSJobpc3DN8OL1vuumM45Y1qlRBFgQaSNlyF0UKFMArCPSUFVq6PfgEkVG6gW6356q+DekGb/sDFLbb8QoC3oSJoE8QWRAIMUTVCIgikiBQyOHgScPE53ZTqkgROijZVcudvDKq04nhdqO73TyeqHb55Zdf+Pjjj9m8eTPXNm9O1LLIzMjg3nvvPec72bppU2pK2c9VFQReMS0+CoRQbDaCpsnEiRMZPHgwt/XuTfG0NIo6HBRzOPEIAiXS03n80UfPqJ7+6aef+Pzzz/n5559p37IVRXSdVI+HEonNkAmmj+Z16+bpvfr+++8ZPXo0zz77LAcPHqRSqVIUMwx8Xm+upOu+ffvOOEYJ2VXckG142KdnTzq1acOqVauA7H8/8oVC1LT8+GWZt99+O09zuhxUK1OGF0yLnZEYFQ2TquXKUcowKKzr3Ny16582jwMHDlClShVEUTyr4VCSJEnyTjJBnYy/k/x7WbhwIc3r1aNbx44XVTULMP6JJ/B5PKQoKtdfe21OPHbixAka166dUzSSV9mteDyea91y4MABPvvsM5yiyM5ELK64XBesvP1tvOnTp3PngAHnlSN89tlnaZ6oJB+lG7Rt2jRP8wUolp7O7brBcN0galln9eKYO3cuVUuVwu9yMdsK0EvXad+yJbt376ZL+/a0adLkbyG1du+999I1sVYarOl5TtS//fbb5FdVHtVNUj0e/JJEdbcHlyAQMU0WLVp0RvuDBw+iuFx8GYqwNBjG43Sec726adMm0iMRvE4nV1erxtGjR6lbqVKOZnsVt5tyJUqctcDjj3Lw4EGGDRlCvz59/hQt5fnz53NL9+48/9xzf5tE7qFDh/jmm2/+UOX+0aNHad++PTabjW7duv0pfjVJkvwbSCaok+SJeDzON998c9FB3MXQqkEDuusG0y0/IVk+qyP2+Xhq3DgCXi8FNZ2mdevmkijIK/v27UN1Omnp8ZBit1O9QoXztt21axdhw2BxMMTOSIxMXb/ogKvnDTdwjW7wss8ipqgsXbr0nG27dexIY92gg9eL0ybgcToZMmAABw8eZM2aNTz11FN88MEHAGzfvp2UQICSPh8hw2DdunXnnceMGTOoUrIkutNJitNJVUmisaaTLxjEIwhsDEf5IhTBbrNhCiKv+PzcJCuERRG7zUZQ1+nSpQuWYaAm/k4WBGb4/BRzOPEKAoUzClDC5eIBzaCo14smSaSpGnabjW0JbT+PILAiGMYnilhuzzklGaZNm0bE6WSkphMURZ40TAKiSBWXC0UQcDscmLLMQ7rBKz4/qsNBVU3jOo8X3ePJCex8Hg/FHNkJ9wWBEIoootkEunplrvV4yCeK9NY0WjZseMb1V61aRcgrk2Z3EBPtDFM1QgnzxCGqRlWXxDBVQxMEPg2GeVAzUG02vDaBkChS0O5gQzhKM1nBY7ezNhzl81AYt9PJd999R3okQlmfD68ooiUkUio5XeiSRN++fc+ahD169Ch39e9Py/r1ifh8XOV04RdF3IJArSpVyJRlijudFLQ78LndaG43HqeThnXq5AqU169fT8gwKGn6SAkE2Lp1KwsXLuSFF17A7/UyTNMppek8egkbSu+88w4VzGwD0Fd8fioUK5bnvvWqVKGTbjBCMwjqOgcPHmTixIm09P3/McEmtWpd9Jwulblz52J6vRTQdcoXL47hdrM1EmNDOIpdFP/UCuJff/2V+vXrY7PZGJuobE+SJMnFk0xQJ+PvJEnOhqWqLAxk+21EZPmMU1vxeJzdu3dz5MgR4vE4P/zww3ljgPfeew+fqiI5HNw/YgQAUyZPRnO70SWJqGHQWdfpoukUz8i4rAm8AwcOUCQtjSKGgV9V86yZe+rUKURBYEskxo5IDJ/Hk6swZ/PmzViyzHjDx7UeL83cHp4zfdSpUJHKpUrRS9d5QDcI6Dpbt27lps6daV63LgsWLLhs9xePx3n80UdpVb8+Tz/11Dmf3XPPPUdlXWdRMERjXeeeYcM4evQob731FkuWLDnvNV595RWub92aZ8aP56OPPuLhhx/O5c/yG4cOHUKRJBYHQ7zrD6K63eddq2ZlZfHzzz/nzLvDNa3prum8FwiSz27nWlmmWtmyeXwaead+9eq01nVu1XRSg8Gc4pAkF088Hmf48OHYbDbq1q2bpw2mJEn+10kmqJP8bSibmckbCXOJKj6LOXPmXFT/iGky2wqwNRwl7SKOaJ2NrVu3cuuttzJq1KhzBg/jxoxBc7sx3G4MSSIs2inldBE1jJwd13feeYerihalbuXKbNiw4ZzXq33VVUw0fSwJhmnks85ryFAyPZ13/NkaztUtizfeeINHR41CcblQJImnxo07o/3PP//MsmXLWL16Nffddx/VypenZEaBXFW4X3zxBWFF4VnTR0PJTTu3h2JOF3Xq1OHaJk2o7nIREe3ogkDM5yNmWQQ9HuSECd+mcJTRukm6PbvNUDVbFqaE201xr5eOukFmaiqd27bldkWjpNOJ3WYjIxJhyZIlNKhRk1qGSWVJooTTyQJ/EF0QKOBw8p///IcNGzZQNC0Nt9PJ9W3bMnzYMHr37k3AbmecYfKqz8Jls9HM7WFXNIUnDJOgKBJ0OvGIIgFVxbDbKeZwUsbpxBRFrm3VipUrV3J1nTp4BIGxhkk7jxevLds40W0TcNls2AWBqGny+OOPs2bNGq7v2JGBAwbg83oZrZs8ZfhwCwKq00kBh4MdkRjTLT+qIOARBGIeD128Mo3dbvyCSD67nTetADVcEh6bDZcgoNjtvOsP8KYVQHa5qFyxIi08XnZFU3hAN2jq9rAhHMUjCFwtuanl9pCuquetuJ81axaW3cHmSIz5gexNhq/CUbZHYgRFkZ6yQr/bbz+nO3zfXr3od5qD+ojTJGI+/PBDet90E89NmJDnzaCTJ0/mHJX77LPPSFFU3g+EuEM3aHpaFfaqVat45plnzvk7bMoyX4Qi7IqmUFA3WLNmDe+99x4ZqsZ//QGu1Q1u7d49T3O6XOzZs4dVq1bxyy+/YKkqTxk+HtJN8ofCf+o8AI4dO8a1116LzWbjnnvu+dtUpCRJ8k8imaD++8ffO3fupGndupTNzOTlKVP+1GtfCsuWLeO2W27hqaeeSkof/YPJTEnhKcPHvEAQw+Ph888/59577+X555/PMXc/fPgwNStUQJUk8ofCbNy48axjZUQiTPX5WRWK4Pd62bJlC0E9Owm5IRzF7/HQs3t3Bt5xB4sWLaJEgQIYXu95DbgvxPbt22nTtCn1Klfm3XffZcWKFezfv/+ixmjTrBmVDZM6pkmNq67KFQfOnz+fKla23NwcfzBbDlAQKFeyJIoksSYUYWckRj5VpVzx4nRUVYarGprdjqUoDB048A/FLvF4nOs7dqSQJPGM6aOwpp3ViBGyY9NbunUjPRSifatrOHjwIFXLlqWiaZKmqtx7EfKIF+KFiRORJQnd6+WNGTMuqu/evXupUb48mihyp6LxcTBM2DD+8Jy2bdtG1w4d6NSmDRs2bMDrcrEuHGVXNIX8mvany+b9G5kyZQpOp5MiRYqwZcuWv3o6SZL8rUkmqJP8bXh+wgQiikJVn0WxjAwOHTqU575r165FsduRbDYquVyYHs8VdafOysrC43TyWTDMV+EokiAwxbQYp5s55m8//PADhtfL04bJHapG6czMs461ceNGWrVsifc3E0FR5Isvvjjnte8eNIiSuk5n3SDi87F161a8LhefB8P81wog2e1MmzaNjz76KCe427VrFyHDIGy300tWGK2beAWBYacFuFOnTqWJ5c+WbTB8aIJAUacTQ5KoUqkSfkGgjduD02bjxhtvzDFTfOuttyhuGGyJxHjCMEmz2ynqcDBS09kaiVHJMOnatSsPPvgge/fu5fPPP8frdNLC42FHJEZLTeehhx7i6NGjvPDCC/Tv3x/Fbsed0HH2iyLFMzOpVbEiw3SD9xOJ1ltUjTKaTqF8+ZBsNmRBpFThwsRcLqZbfhpIbsyETMl//QFUUaSGy0Wa3c7OSIx3/UEUQSDs9dLummsoUqQIfrebohkZGKLIHYpKf0XFY7cTkGUGqxqFFQWPINDG46W+y4VgszHd52dz4h348MMPKVWoMEGHA8Vm4xHdoLysYLhcdJMVesgKDpuNDonE8yjdoIjDwRfBMEU8HjwuFx5RpJCUncgu4XCyKBiihdtDQ8nNyz4LWRCQbTYWBoJ08HrJjMV4//33c36Os2fPpnHNmvTu0YOvvvoKn8fD4mCIZ0wfusPJEM1gnGGiCgJBt4cOHTowffr0s75rI4cPp76q8YppUcTjIWoYlCxQIOfY6u7du/NsqrN8+XJCponb4SAjFGbg7bfz4H33kRYMUatChZxq9o8//hi/LNPRZ+H/nfv8b3Tt0IGKukErw6RIWlqOzvvohx6iTMFMOrZuzYEDBzh8+HCe5na5WbJkCTXKlaNu5coXfRLkcnHy5Ek6duyIzWajZs2a59VxT5IkSW6SCeq/f/zdsEYN+iRO3gVk+byFAH81GzduxJJl7lI1Kug6d/9FPitJ/jifffYZRfPnJ2ZZPPXkk0Qti66aTmVdz9kcf/7556lnmOyIxLhTN7ihXbuzjpUaCDDbH2BdOErIm12NnT8U4mWfxdJgGNPjYefOnQDUqVSJkbrB56Ew+VT1nNrSZ2PCM89QuUQJurRvT4USJeij6TSU3Jh2OyOGDs1TMjgej/PY6NHULFeOO269lcmTJ/Piiy+eNdY6ePAgGdEodd0e8tvtdPJ6SbPbSZMVmtSrRznDoKFpUjAWQxEEFgRCNHK7uV1R+TQYpoCm8dFHH5113A0bNuTa4NmzZw8dW7emftWqvPfeezz7zDMEHA6GJ4os+ikqdyXM3C/EF198QUFdZ2ckxuJg6LIkgU8nHo9fcvL9xIkTVC5dmio+H+maxj1Dh3Lo0CGmT5/Ohx9+eEnjFktPp69uMFg3SA0GaVq3Lg10nc6aToFY7Ip5Kf3T+fHHH1m0aFGe10ELFy7ENE38fv9Z1zZJkiTJJpmgTvK3YtWqVbz11lsXlZwGaNWwISN0g62RGCWcLm695ZYrNMNs4vE4piwz0wqwIBDCJQg083iI2R0EZJlZs2axbt06LElCFQR0QUBzOnMFDt9++y1+VSWUcH7eFU2hu6ygSRJTX331nNd+7bXXGD16NNu2bePw4cN4nU6aud2Ygohks1FElsnQNEYOGwbAK6+8QjPLj8dmo4XbQ2O3m4AoUqZQoZxx9+zZQ8Tno7XPh253UC2hMfyc6SPN56ObV6ay00U+u53yikL18uVZsmQJaeEwmsOBJAh4BYG2Hi/uhLSHWxRpUqdOju7W/v37yUxNpbDHgyIIvOHz00bXc9yo169fT8zvRxFFmrg9jNFN0kQ77bwyAbebp00fzxo+qksSu6IpzLQCVChalEOHDvHdd9/lHOcrEAwS1XUMh4OFgRAPGSam3c5ifxBNEJhu+ekjK1hidjWzZLNhiiKWKOJ1OLA0jVRJwnA4aNWqFTcmNPqeNrMT9zsjMbp6ZXyCSFgUCYgiit3O6tWrCRkGAYeDiGhndShCZd3AJYrsSByFdAkCiiBQW5LwCgKt3G4qu1yERDteu51iThd3qRrdvF5ukhUCokiqz0dGJEJIValRrRqW200zt5tMh4N7NJ1AwgTn66+/xufxUNMlUcDponD+/BRJT8frcBAxDKZOnUrzq6+mZEYGJYoWRRFF0h0OTFGkc/v2ud61Dz74ANnhIJLQ155iWjxr+gibJgP69MnRzJ7wzDMX/J2pW7kyYwyTLZEYRRwOKsgy3a+/Ple7O/r0YXDCdGaQqtH/9ttztTl58iRTpkzhiSeeOGvVz+eff47PH8ThdHF95xsvWe7n78Cvv/7Kli1bLvoeTp48SfECBSjokrDZbMTC4ZzKriRJklyYZIL67x9/F82Xj9n+ADsjMcqa5mWVB7jcTJ06leb+7FOCr1t+qpcp81dP6V/Hxo0bGT16NLNmzfrTTg4tWrSIColK4YWBEOmhEACTJk2ilpFtmHibbtDlLDEWwBtvvIHmdqO6JG5PrF0WLFhAyDSRJYlxY8bktC1fpAhTfBbbIzFKGsYZxQkXmmNUlnnd8tNGN5CdTvoqKlVdLqb5/BRWFF5//fULjjNr1iwKaRpTfX5q6cYFK4t/+OEHenTvjlsQSLHbqeGSSFdVFi5cyPTp05k0aRLN69WjkeSmsMNBVLTzXEL6rYrpY+bMmZw4cYKFCxeyZs0aPv74YyxFJUVVqVau3BnSE1dXrUoPTWe84UOXJCRRxJUwdO/o8aI5XXnWBP/uu+/QPR7qShLFnU6KFyyYp35/FkeOHGHWrFksWrSIY8eOUbREKcJFKmCEUmnUoBG9unTJkXq8ECdOnMAuimxNrFF0t5utW7fy6KOPcs+IEX/I1HLnzp20btSI6mXLXrIvzKlTp1i6dCnr16+/5HlcCTZv3kzYNKlgWQR1na+//jpP/b755hsKFiyIJEnnrOhPkuR/nWSCOsm/gmtOS1BXNM1zVoReLLt37+b1118/q0P122+/TdAwMGWZO267Dc3hYIrP4gavjM/h4Jnx45Htdt4PhNgQjmI4nXz77bdnjDFx4kTaWBaGINDY7eabcJTGbg8NpGxt4J9++umM9vF4nPtGjKBQLEbL+g1yknP3jhyJIYpsisRyTAvf8wcJGQZHjx5l1apVBGUZvyjSXVZ4WDdw2wQUh4Ni6ek5QduuXbt4/vnnGTt2LOmqyhx/kBt0gwY1axKQZdyCwMpQhB2RGKmqSkY0yjMJaRJFEHgvIT1SxOHMqU4+XWrhueeeo3nC4GOMYaIJIqULFeLHH38EoGPr1jRyeyjqcFDW6UQVBBpLblYFs3WZfYqC5fEg2+3crelUlmVSfD56dely1grRsWPGZGsoFyhIuWLFKGOaGJJEmt+PVxSp4HSxMxJjvOEjkjCieVg38LlcPP/886xdu5YVK1bgl2XuVFQCDge6IFApIU/ym/miWxB4Ytw4Ordpy926wc5IjPpuDy5RpNpVV3FViRI01nWaajqKKDLV52OC6SPdbsdus1HYni0LMtG00AWB4aqOLAjUcXvwy3KuRfdbb71FZjjMM4ln2Uk3GD16NDNnziTgcNBDVmjj9uC22fAJIhHRTlVVpUX9+uzdu5eIz0cDOTvBvi0SY1kwjMduz/X8mterx6O6yc5IjGouifs0nWbu7M0F1W5nTSjC4mAIzePh9ddf5/bevZk3b95Zf5fqVKrE3ZrOxnCU4g4nAxWVYmlpuRKvL7zwAiU0jedNi+KaxuTJk8863vm4qnI1MloO4Koh/8UI52fSpEkcPHiQlq3bki8jk6F3D/9HyF589tln+DWNiCxTvXz5i9IB3LZtG2FZZkc4yu2Kis1mo1WrVjknH/4q1q1bx5AhQ3nuueeSR9yT/K1JJqj//vH3M+PHE5EVKpg+yhUt+rfWSt28eTOWotBP1Sir69wzdOhfPaV/Fdu3byegaXTRDQppGmMu0Wz9Ytm3bx9+VWWwptNY1+lwTWsg2w+kSZ06OESRwvnzn9fM7tdffz3rZvvv45Q5c+ZgeL3EFIWGNWvlycDt+PHjFCtYkCIOB4aQXVAR9fkIulzcm6gu7qVpjBw58oJjPfTQQ3RQtZxYueM111ywz2/zDpkmdkHgtl69cu7rpRdewOtwUMbhpJesoDidaJJEuqZRpUwZDh06xNXVqlHcMAjLMiXS0hiXqEqvZvrOWOul+v0sDGR7AeV3OHhcN/kyFMErCHgczos2jq5QogQdZJlHdAOfLF9RD6aLZeJzzxHUdWI+Hy1atMAI56Pi8HeJVWpFYaczp3Bl5cqVeRqv+dVXU8Mwudo0qV6+/GWLj2tXqkQf3eAF08Ln9eacBMgrWVlZNKtXj0xdJyjLjHvsscsyr8vB0MGD6fVbdb6qcfutt+a57/79+6lRowY2m43777//H7EeSZLkzySZoE7yj+HYsWPMnz//rF+469atI18ohORw0LJhwz/kuvsb3377LUFdp3Hi6Oi7774LZEsVjB8//gzjvnnz5lEuUfU52x8g3e6gZrlypAYCvOyz+CQYRpOkXNIdS5cuRXW5CAkCEVHEabOhCgLv+PwYbneunev58+dTUNOYHwjSSTfo1rFjzlwtj4elwTATTB8R0Y4ligQcDtLCEXbs2MF///tfPHY7XyR034KiSAG7nYAoYmlarvt/+IEHKJovHy3q1+f7779nzZo1FIhGGajpPG368CkKMZ+POf4g7/iDqKKdarJCH1XDLQgsDmYn5k93Hf/Pf/5DIVlmYSBEB6+XNJeLfr17k5WVRf8+fQh4vUREMaeC9nZFJep2k6np9Ovdm19++YWtW7fyySef0KB2bdyCgE8Q8Nvt9OraNWfuhw8f5q7+/bmuWbOcKoLjx4/z/vvvs2rVKgAeffRRUh0OPg+F6auo+EWRNaEIfRSVIk7nGcH64sWLqVOjBqVlmWdNHyFRxGu3M97wMcVnYXi9HD58mJu7dqWbbrA2HKWybpA/GsVhs+G22ShbqhSVypenvMtFUYeDeokK6hSPB68g8JYV4E5VwxJE6kluijld1Kxa9Zy78k+MHYvlcFLdJeG12SiclsauXbuw22ysC0cp7HAw3fKzLRKjUOLPoiDw+uuv08DvZ00ogioITPX5uU/Tieh6rmvceN113KTrfB4Kk253oNoE6kpu3g+EKOpwMkTVmG750b1eMlSVoapOWJb58MMPzxjnvffeQ/d48AgCHptARLTjtNnwO100rl37jMreeDzOo6NG0bR2bR4bPfqSArdyFatQoNWdVBgyG7cRxud2U6VqdSJl61PipvH4YgX473//e9HjnosNGzYwdMgQJkyYcFmTrk3r1OER3WBHJEYN08e0adPy3Pf48ePkC4W4TdO5XjdIi8Ww2WzUq1fvok+oXC6+++47dJ+fWLV2+DNKcnu//n/JPJIkyQvJBPU/I/7+8ssvmTt37t86Of0bK1eu5M4BA5g4ceI/+mTP35FXX32VZgmZumk+PzWugHncufjyyy/p1aUL99x9dy65i6NHj17WBNT+/fvZsGFDnt+fOXPmUERRcdsEFgZCvOSzCGk6o0ePxnS7aWH5sRTlghWgX331FWHDwC0IxJxO/F4v8+fPz/O84/H4GfHRr7/+iiJJvO8P0tkro9vtTJk8me+//57Vq1dz4sQJVq5cSYamsSMS48NACNPlor9usCoUoZiuM3fuXI4fP87ixYu5pUcPMjWNej4fimhnlhVgVSiC4nDw1ltv5XmevxH1ZRff7IqmUNw08yynsmXLFtavX3/Fko7fffcdhsfDB4EQE0wfVsIEPX/j3vj1IM+b2dX8HXwWz+ThdCNkr69ffPFFnn/++TPe319//fWCRQ2ffvopdStXpkmtWrneoXyBAB8mNg2KGUaeTTh/Y/Xq1eRXVbYlfv5h07yo/leSJ554ghoJY836usFDDzxwUf2PHTtGp06dsNls3HDDDUkZlSRJTiOZoE7yj+DEiRNULVuOcqZJVFF4bPToXG2ysrIuq87q448/zvVGtrTDo7pJu6bZyc6ALHO9z8KS5Ryn5kOHDlEgGuUql4uwKFLS4+GWbt1YsGABYdPEJQikeLz4ZJmFCxfmXGPowIGUlbMrajyiiCoIxOx2NLudq2vVolRGAWpXqpRjUDF58mQa+bKrZscbPkplZFClZEluuuEGCkSjOG02PIKA22bjxoRkyE2azqABAwC4uWtXSus61VwS+ex2CtntDFE1ZEFg6dKluZ55m2bNcIgiGdEo33zzDVu2bKFF/frUqViRjz76iJenTEGRJDyCQCdZRne5aNG0KYYsM9ln8brlx/B6OXDgACtWrCB/KIRDEFAFgbouiacNk4rFivHyyy9TVtd5PxCivtudLUXilTHcHkaPHs2CBQuIx+McPXqURx5+mIH9+lGlQgV6ywo7IzFaeTwUSkvLmXuPTp1orBuM1k00pxO/qhKzLIoXKIDu8XB11ars37+fAX37YsoyxTMyMN0eXDYbxRxOSrhc9O3b94zn0bV9ex7UDXZFU7hZ1ejevTspponpdNG6RQtOnTrF3r17qVa2LF6Xi2rlr8ISRaq4JLolgu+2LVowUNN5zvARcDi4WVHZFU3hBq+MZLMREUW8QrYxo+Fynff4ZrsWLajgcnGN20M+u53ihsHixYu5pnFjrlIUQnY7D2o6nwbD+EWR1h4PEcNg7dq1BGSZcYZJGcmNYbeTYpp8/PHHOWMfP36cSZMm8fTTT1OjfHn8qkqhlFSCTmeOnl9nJdt1PmQYNKpdm4cTz6aPpnPvvfeeMdeyhQox2WexORIjv9uNZLPhE0Vu9MoUN4xcCe0/wuLFi6lWpgyq04VNsNNM0VngD+KRNdKb96PSiHlEy17N008/fVmut2fPHgKaxi2qRkVdp3+fPpdlXIB2zZvTL7HhUUo3Ljqp/u2333Jrjx7079uXH374gSlTpmC326lcuXLOqYU/k7feeotY8cpUGjGP4t2fILNoiT99DkmS5JVkgjoZfyf557BmzRr8sszDukFt3aBf795/ynVPnjzJihUr2L59+59yvYtl0aJFpMgKPlHkm3CUhYEQHlFk3bp1rF27lldeeSXX6c6z0bpRI0bqBtsjMSqpKqNGjTpru507d/L+++/nFKaci4MHDyK7XHwZivBZ4pTk72XIdu7cienx8IYVYIRuUCozk3JFiqC63fTt2ZNjx45R46qrKG4YBLzZp1lfffVVpkyejOp243Y4eTAPleG/cfLkSW7r1YsSaWmUL16ckrpOM9NH4fz58+Rp8tB99+H3egnLMrd065bn614MmzZtIuSV2RSJ8VEghE8UaWKYFMgsTKmSpSmsqtymavi8Xm679Vaa1KrFk2PHXnTC/IGRI/E4nSiSxLSpU8/a5siRI/g1jXGGyUjdoGBKSq4x0lSVqj4f5YsVu+gk7K5duzA9Hmb7AzyoG+f0cvorOHHiBD06dyY9FKJz27aXdDoxHo9z33335XjF/BVxeZIkf0eSCeok/wiWLVtGESNbOuH9QIh8gcAVv+Zbb71FpqbxuuWnvm5w96BB3Ny1KyMTCbrbVY2hQ4bktP/555/p378/lcuU4Y5bb81Jlk+aNIkmCSmGxw2T5vXq5fSpXKIEb1jZmoQ1JIl7NJ0dkRgpXi+G2810y8/dukHFEtmJnAMHDpCZmkp5nw/D7SbsdvO65aeBopIuSeyIxBiqahR1OGjsdrM+HKW5rnNfIkDLyspi2LBhKB4P6aKdJxIJ+C6qxpjTdO4Apk+fToWEZvBg3aBt06ZnfU5t27blhkQy/DHDpH3Llnz00UcUzZ+fzFiMAf3743W58AgCZZ1OJpo+ijmcVHW6SLHbSfX7eeSRR+icSHCO1HTKFi+O7HTic7vp3qlTTmDVsXVrrtZ1+mg6stOJJWZrbqfZ7fh1PSeALFe4MLMSz7Wiy4VsE6gvuSnnzA6GO+gG/RKJxM8//xy/10vE4UBPSGKogoDudp+x4JgzZw4hWaaTz4clK/S74w5q6Drv+INU0nWeffbZM55LyYIFuckr81xCt1qx2ahZoQKRxM8uXyhEY6/MV+EotSQJyWbDabMREEWWBsM8qBtULlXqrM88Ho+juN18FY6wK5pCit2O7vawdetWTpw4wZQpU7j77rsJqRoeQaC0w0kdScJ0uWh+9dVUKFacWpUq0bdXL4pnZBBTFEy3m6qlSjFm9GhCikJRh5PSLhe1K1cmHo9z4sQJHnzwQRSnk7KKQtg0c57PlMmTSVdVBqsaIVnOZWxTuWRJxhkma8NRLFHkBdPim3AUXRCIyDLLly8/631eLD/++CM+RWGcYdJb01FFMWdhk5kvH4puEs4sQySWyt69e/M87pdffkn3m3oyfMQ9uRYpc+bMoZY/u2prrj9IyfT0y3IvAFu3bqV0oUJIDgc9One+LBV3s2bNwuVyUaJEiT+kLXgp7NixA9XwkVK3C8FC5el5c96PRCZJ8meTTFAn4+8k/yzmz59Ph1atGDls2J9SkXjixAnqVK5MAS07IXgu75jLweHDhxkycCDXX3stixcvzvn7gwcPsnHjRvbs2XPWfvF4nEF33IFityMnCkSaezyUL1r0rO23bt3Kq6++mkvasF3z5gzWsw3RKxrmWTWrP/nkEyxFobJlkRIIsGvXrvPe0/0jRqBJEqok8cTjj5+1zbSpUymelkbNq65i3bp1TJw4kSF33cWaNWtYvHgxxY1sGbq3/AEKnZYgPXHiRJ6Thr/++itffPEFjzzyCFV0nXf9QappGl26dOG5557LU+IwHo/jdjpZEYpkx7du9zl/Jn+EeDxO1w4dsFwuvIJAi4QU4Nq1a4nH47z++uvcPXQoA/v3p7yuM9G0KKRpvPHGG3m+xt69e9EkN6tCEd4LBDFl+aztdu3ahc/jYVskxoZwFIco5opTP/74Y2bOnHnJpuWvvPwymbEYlUqUPOPk8r+JadOm4XK5yMzMZOPGjX/1dJIk+ctJJqiT/CPYtm0bPq+X1yw/A3WD6uXKXfFrxuNxxjz8MFVLlaLPTTdx9OhRnh4/njK6zgTTR2FNY/r06WRlZXH3oEFULFaMAX365JIXmT17NkUTx4A66wY9OnfO+WzwgAFU1HXuVDW8osgtqspUnx/V7SZDVXOOtcV8Vk6fQ4cO8f7771Mwf35aejzsiqYwzjCJOhx8G4lxm6JSwekk0+HAKQg0qlmTX375BcgO9FIUhZs0HY8oks/pZJCqETitGvw3pk2bRlUz2+BlpG7QqmHDsz4j1e0mItoZa5gUcTi5d8SInM+PHTuG4nbTxStTxunkEd0gkJAWudbj4R5NJyMhQRLz+6mcOGoY1DTmBYJsCkeJKEqOOUbM5+MhzeBmWcFntzNS01kdihAV7WQ6nDkSCA+MHEkRTee6RHV4fcnNcE3nWo+XXdEUBms63a+/np9//hlLURigqLRweyjjdGYfjfPKRCSJq2vUYMppGsjLli3jqaeeYu3atbRs2hS/KJJit9PE7aFbly7UrVyZ8kWKENQ0HDYbXkHgacMkZrdT2OHM0bL7+uuv+emnn/B7PLhtAg3dblq7Pah2O+l2B1sjMaZbfkqcluzcvXs3zz77LBMmTCAlEEAWBNp4ZQaoGrLdwaunLYzWr1/Pxx9/zJw5c/AKAgNUjRIOJx6bjWG6waO6ieJ00qhBA1oaBr1kheouiSk+i6gkIdpsbInE2BaJ4bXbcxyqe3TqRDlVo54skxIMniEVMWPGDPrffjvvvfdervdk+fLlxPx+nHY7piQx2fQxPxBEEgQG9b88Mg9r167lpZdeIk3L1kdcHoqgSRLF09KoUb4869evZ9u2bbz//vu5tN3Px969e9FMi9S6XQgVr06bdh3O+Hznzp1YisJdmk4NTaddq1b8/PPPl3QPx44d46uvvrrk/nnlgw8+QJZlChQokKfKqcvJihUr6HnzrTzyyOgc89QkSf6OJBPUyfg7SZLzsXDhQoob2TJcb1qBM2K2y03XDh1oohs8oBtYssLWrVvpc1NP5N8Szy4XT44de87+K1euJEVRWBEMsyAQIurz5Wqzbt06/KpKc78/l//Jxo0bKRCL4RBF2jRrxsmTJ3l5yhTKFS5Ms3r12LVrFx1bt+aBRLFJR8PgsTxoBn///fdn1d8+ncWLF9OyWTNKlyhBKVWlr6phKUr2qVavl9n+AHfpBrUqVLjg9X7Pzp07yR8KU9Q00d1ubpDlHF3h/rfdludx4vE4QcNgss9itj+A5nZfsVguHo+zdu1aBg8aRNf27VmwYAHHjx/nhnbtCOo6LRs0oEuHDjka431UjeHnMbT87YTqb+zbtw/N7WZFKMJcfxCfopyzX+PatSlvmBTTdW664YbLfq//KyxZsgTLsvD5fGdsQCVJ8r9IMkGd5B/D9OnTKVeoEA1r1OCDDz7groEDGTdu3GXRmz6dTZs2MXr0aGbPnp3rSFRWVhaPPPggzerU4aknniAejzNp0iTKajr/sQJU1XXG/E5+JB6Pc1f//uQLBGhSu3ZOsg+y3YnHjx9Pv759mTlzJnUrV6ZsZibTp0+nTuXKlDRMIopC/Zo1Ud1uiqWn8/XXX/P+++9TWNMIitl6xaooUrZ4cQSbjbAokmJ3kBEMsm3bNrZv3077li1pWqcODWvW5PFE1XRXRcUpimgOJ03q1891r8eOHaNBjRqokkTUslizZk2uZ/Vbgnq4qtPY7UYSBESbjZYNGvDxxx8T1A0kQSCWcObeFU2hlduDT1EIer3oHg+vTZvG6Icfpki+fJQsWpR3330XU5KYaFo8oBkYdjv9+/blxIkTVK9QkbBoZ5CqoQkCz5k+tkViFHc4UWwCxdPS+Oijj4jH48yaNYsHHniAWCCARxDoLStogkBQFPGKInPnzuXLL7+kkJ4dwK0MRfAIAg9qOopNQBcE6rkk0hSFWbNm5XoPdI+H1y0/s6wALkEgXyDIA7rBBNOHZLPxSSDEvEAQt01AFgQWBYLsCEcJuFw4RJF8oRCN6tenhdvDV+EoVVwSLkHAFAQ0QUCy2XJMXX7boGmhqMScThq5PawMRYhKEo3q1DnD3frZp58mKMsUMwxqVaxI5XLlCEkSltuNYLOxMRxlWySGJgjkd7up6PWSclo1/bUeLx5BYLCqMVLT8QgC77zzDgAR02RpQpOvhOk7qybfKy+/TK3y5enRqdMZwXk8HicrK4sZM2bgU1V0r5fJeTStmfT88xSIRKhcshTr1q3L9fnYsU+gmgF8KQXxeb1UVVUKqyp33HJLnsY/H/PnzyeQXpxKI+ZR6taJRFLTcrVZuXIlN914I4FwFCOUguHz59mc5jf2799P0fR0Cug6QV1n9erVf3ju52PZsmWYpkk0Gs2z+3iSJP9LJBPUyfg7yf8mWVlZ3H7zzaSHQrRp2vScicY1a9YQlmU+CIS4+xITpHnh4MGDhDWNBpKbeYEgNazsk4dBjwdNEFgXjvJpMIwsSeeUcjh16hQNatSgqGEQOofh3AMPPMBNiaTm/bpBl+uuO+PzeDyes7G8bt06ArLMdMvPrbpB41q1GNSvHy10g/cCQUrrOq+99tpF3Wc8HmfVqlVnVMquWbMG1ekk1W6nriQREUXWhaPUMwy8LhdSQqaudsWKbN68+aKuBzBy5Ei6nGZ2pzld1PT78avqWdc95+Ojjz4iMyWF1ECAGacZOF5pTpw4Qb0aNQja7dzolWmu6XS87joCskwHK1uS8vceSL/x3XffUSozE4coUrtSpZzCk0cefBC304nqdvPGjBnnvfbs2bOZN29e0uzvD7Jp0yYKFSqEy+XilVde+aunkyTJX0YyQZ3kH8cPP/xAyDDorenU0HV6XsYd29NdwDM1jbG/k704G0OHDKFPwtRviKrR+6abLstcTpw4wYcffsjLL79MmqqxIhThXt2kTqVKfPrpp6SpKvP9Qdp5ZSqULAnAa6+9Rq3yV3FDu3Y5FQllixSht6rxqG7iEUXKatl/NkWRx3STTeEoQa/3rIFdPB5n//79uXThTufFSZNQJAlJFCnrcrEpHKW2YVAsLY3hms6WcJSQKBISRbqrGpYss27dOrZs2cIPP/zA4489hmW3c7OskGK343E6KS+58QsimiAwzjCpoRsMu+suurRvz0OJ6oxWbg+SzYYmZCeAb/R4edLw4ZNlvv/++5z5VyhRggy7A58gIttsvGX5uUPTubZxYw4fPkxGNEoHVaOi20OKz0eh/PkpJ0m8YQUo7XTSQHIzZPDgM+75+PHjSA4Hq0MRvg5H8TqdOESRteEoWyMxZEFgjj/IHH8QjyAQttuJud2UlRViDgcbwlEe0k2CXi+yICCJIlXKlcMn2nnF56eV20NMknKqkSuWKUMhhwNTzL4H3WZjqmlRVjeYOXNmzpzmzZtH1Odjrj/IjkiMIrrBxx9/zHvvvccnn3zCje3bU8QrU8ThICKKpIh2FEHAlpAWaZkwMowGgwREkUaSm5GaTpWE1EjLBg1orRsM0XQCmpbr2OPKlSuJKAqTfRZtTjPx/I0DBw6QGgzSzjQpruvcfeedF/w92LJlC5bXyzv+ICNPk7uB7MrsEhkZyHY7qbVvoHTfl3ALAqVkGU2SchLrl8pPP/1E4fz5cTglglc1w5degh49bz5r22effZZIqZpUHP4u+RvdTKtr217UtZ544glaJTYJhmk6ndtcXP9LYc2aNYTDYSzLumwyKxfL3r17+frrr5OGYUn+diQT1Mn4O8n/Jq+88gpldZ2FgRDX6AZ33nHHOduOHTOGFMuiUsmSOX4xl5uWDRrQUlYYpmqogoDsdCI7nbgFAY/NxoJAiNcsP0HDOO84J0+eZMmSJefclJ4+fTpFNY1pPj/VdZ2H7r//rO2efvJJJIeDTIeTnZEYs/0BiuXPz6FDh+hwzTUUTklh0B13XPT3eq8uXUhVVcKyzJCBAwF47rnnCNntjDNMMh0OPIJAOacTjyAwybRYGgyjStIFNa/PxZNPPkkt3WB5KEJzXaffbbcxd+5cdu/efUnj/RWMGT2aSl6Z2f4A5Z0uGrg93NK9OytWrODZZ589bxHCLT160DUhL9lYN3j8NKmVY8eOnXf9l+Ty8+OPP1K7dm1sNhv33HNPMumf5H+SZII6yT+ODz/8kEoJp+4PAyEKRqOXbeyXX36ZFomxX/X5qXXau7RhwwbGjRuXS1/3q6++wq+qNPIHsBQlz07PeeW9996jlJEttfGSz6JisWLE43GGDByIIkkUTUs7b/Dhttv5MhRhZySGTxBo0bQpHa+5hoBh8LxpsSAQQne72bFjB2vWrDmjwvtcHD58mPfeey+ncvfdd9/FY7fjSJgzVvR6cSe0nK/xeCmu6QwbNoxRo0adURmxf/9+TI+Hxm43+e126rgkXDYbHb0yo3SDaxISJs+ZPprUqsWUyZNJ83oZrukYgsBgReOTQIgCop0nEzp0mbqeUymwfft2ZEFgeyTGN+Eoos3G1nCUh3WDBtWrA9kmd6NGjeLZZ5/l+PHj3NqjB0PV7GqK1m4PqijSpkWLXMHvPUOH4vd6CXq9DOzbl9tvvpkCmkYxRUURBBw2G4ogUMLhpJnbQ53KlfFrGgUTUizjDR/5HQ7Wh6NUNQx69OhBvcTRwhd9FqbdkaMRrLrdOG02XjKtRIW8HY9NQHO52L9/P6dOnaJO5cqUNU0CDge1JTez/QH8v9t42LNnD5amYQkibT1e3vUHidntFHM4qemSqOGSyBcM8uGHH5KuanweCjNUN2hUowaQrbN+14ABdOnQgR5du9KpTZszzBWnT59OfcvK+f2pWqp0rne5SuLzeYEgRVJTL/iuff755xTUdbZHYswLBEkLhXI+K5SayjjDzN4IsDvwl2mYI+PymGHSpkmTC45/PiZNmkRj08fSYJj6kofSRYueM1ifOnUqgYwSlBvwOrHKrejSrcdFXeull16ismHwZShCJ92gT8+ef2jueWXz5s2kp6ejqmquf9uuNDNmzMCr6uj+CFc3bJxcCCX5W5FMUCfj7yT/m4wZM4YOusGHgRDN3G4an+Yd82fz008/4ZdlPk2cXivo8ZDq9fJtJMbTpg9VEJAEAdPjoU+fPhclYfZ74vE4Dz/wAOULFaJLhw5nPaG6f/9+NEnKXn/ZHRRzOgnLMs+MH39J19y3bx8jhg9n6JAhKE4X34SjfBWO4LLbOXHiBGvXrkV3OAiJIo8ZJouDIXSHA8nhZFEwxOqEnFte1i5n49ixY3S4pjV+VaVF/fpnSNf9U+jTsyeDE4VSvWUFRZL4+uuv+fjjjylbqBClChRg5syZnDp1KqdPPB6nz0034UwU+bzh89NCN3L5EZ2P34qYTh/3r+TLL7/kxRdfZNOmTX/1VP4Qx48fp0uXLthsNq6//vo/rKe/Zs0aVq9e/Y9KdsfjcT766CPmz5//t3m/kvx5JBPUSf5x7Nu3j4CmcYeqUUfXc1Vp/hFWr15NQJZ5JOECPqBvXyA7OW0pCp1Mk5ii8Orvjt5s376dN954gy1btly2ufzGyZMnaVy7NhFZwfB6efvtt5k6dSqTJ0/myJEjF+xfODWVwg4HtSSJiN3Oo48+CmQbV2REIgQ0jfFPPknl0qVJ1zR8v9Od+z2//voraZEIHpsNl83GLb16kR4M8qzpY0M4SlAU0ex2plt+NkVi+EWRpldffUYlxauvvEKbJk244frrqZE4WveGFUBPSFukiSKWIOC22eikG+RTVF6YNIl4PM6rr75KycxMPILArbJCHZcLr82GZrNRzOOhbJEiOUcQf/zxRyRBYIxhcreq4U0EYrIgEvb5zhrQfvTRR/i8MjV1Hbcg8LBu0F43aHF1/Zw2R44c4bvvvmPTpk05hhbxeJxFixYxb948vvrqK4oXKIBos5HucuH3emnUoAH2RNJaFgTcgkAnr8LOSIymusFDDz1EaiBAHVXF53TywGmVK41q18Zhs9FdlumWMKTsq6h4bDYefvhh1qxZQ5qqsSMS45NgGK/dTuGUVF584YUz7m3ixIm09FnUk9yMN7IlV+pIbgarGuUkN2WLFWPnzp3E43GGDhyIKcuUKVQol2lHt44dafQ7LUTIPt2QLxSisWURVRQmTZx4Rr/t27djyQoP6watdIP2rVqd8z37jZMnT9KwZk0ydR2/18uEZ57J+cxSVRYHQ2yJxDAdDqxgiPyebK36BrqRU4FzqcyaNYsSus4nwTBddYPu119/zranTp3i+hu64FVUrqpc7aJMGCH7Pm+87joMr5c6lSpd8mLrUti1axfFihVDkiTeeuutP+266ZlFKNL5ESoOm4MVyzhjsyNJkr+aZII6GX8n+d9k3bp1+HUdj81GS48Xy+Ph/fff/9PncfjwYYqmp5MhSZR0OmmrKER9PgqoGhvCUR42TGpVqEDntm2ppBs0M0xKFsy8ZOnDeDxOh2uuoaCmk6IoZ42h9uzZg+5281U4yvxAEI/TeU75iAtx6tQpimVkcL2m01LTUe12XrP89JQVdKeTl156iXg8zvz589GdTmb7A3wbiZGuaQwbOhRFklBcLu4dNizP9zdz5kyeeOKJCxo4/llkZWUxd+5cZs2adcm+HMuXL8dSFK72+/HJMp9++ilZWVn4NY1xhkkhhwNJECgQi7Ft27acPvlVlQ3hKBNNC1UQMV0uYj6LF34Xu5+Nn376iauKF0eVJArly8fOnTsvae6Xi/fff5+ALNM64WX0TzdUjMfjPPjgg9hsNqpXr37Ja4K+d/RHs0JoVpibb+1zmWd55bi1e3cyNZ0ShkHrxo3/Ucn1JH+cZII6yT+Sr7/+mjv69OGRhx++7E7d7777bo4L+G/BwhNPPEHnhIbyU4aPVvXrn3eMpUuXMn78eJYvX077Vq3IjEYZ0LfvJR9jz8rKYuPGjRw4cIA2TZtS1uulgsuF4XKdNzD8/vvvsTQNt82GXxQJKOpZE2dvvvkmVU0fOyMxnjF91KlQ4Zyae7Nnz8Zps+X857bZ0EU7z5sWm8JRYnY7EV3nadPHqlCEcMJdGrIDmsmTJ5OqKIwzTMqpGprLxbOmj+ZemVKFClEsI4Oo3Y5PFHGLItdffz09e/Zk/vz5LFmyhOLp6RSIRJgwYQL5QyFS7XbKO7PdrB02G7f+TmKlbctW+BwOLIeDkKbxpGGyORKjvuVn+mkacXv37uU///kPpiyjulyUKFKEUka2nMiiYIh8gQAAixYtwqcoGG43rRs35pNPPiEzJQW/pvH0k0+ece2NGzcyceJEXn31VRSXixWhCPP9Adw2G1XLl0eXJAxRRBZFXpg0ie+//55p06bRvnVrnHY7aeEwLZo2xbBnS3E4bTbKOp08Z/poKLkp53RSq1Yt9u7di+n1MsVnMVQ3zunOPm/ePApoGvdoOoogUMrrxfJ6Ud1uKpUqRZ+bb2bQgAEXTK6WzMjgHX+QXdEUqlsW//nPf85451599VWWLl161r6LFi3iuubN6d+nT45554U4efIky5Yty1UVMXjQIHS7HdNup061amRlZfH4o49SrXTpHGPTP0I8Hqdf795ETJP61aqxb9++PzTe35n9+/dToUIF7Hb7GYabV5KyV1UirUlvSvd5EdUXvGi9xyRJriTJBHUy/k6SmwMHDlxxI9+/kvfeew9TlvG7XGQkTKtHapdXTjCvfPLJJ5Q0TbZHYtylahiyzHfffcct3brhEEVSg0FWrVqFIkl8Fc4+KZlPVfn666+ZPn069913X078fT6OHTvG999/z9SpUzEkiS2RGGtCEVwOx1kTQ0MGDECT3KiSxKTnn7/k+9u9ezd+r5edCVNuURCIWBYhu51RukEBVc2JR1595RUMj4eoonBt06ZkZWXxyy+/5JxuPHbs2AWLdu4ZOpSims51hknM77+gOeMfZdu2bfTp2ZP+ffueM368qXNnius6FUyTBjVqXHIibuvWrcyaNSsnUXzs2DFcdjtDVI3Gbjc7IzF6azo3d+0G/H+C+ptwlBdMC9PpZKxhMi8QxPR4LphwHj16NK10g52RGL10ndsug+fLH6Fbx47cn5CA7KVp3HfffX/pfC4X06dPR5IkChQowIYNGy6q79GjR3E4XZQf9Cbl7/oPTunKGXdeTk6dOoVDFFkfjvJtJIbhdrNnz54L9svKyuLpp5+hR89e5y20S/L3J5mgTpIkD3z00UfEFIWnDB9VdYN7z+OG/PbbbxNWFK73WahOJ800jfcDIcro+h9O/Jw8eRJRENgSibEjEkMVBCoUL37O9rNmzaKOz2JxIMRDqk7JjAx63ngj11977Rm7y++//z6Zms5nwTB3aDqGw4HH6aRL+/Y5SfXjx48z5tFHue7aa5FsNt4LBFkTiuCxCfT1KrgTFdWK3U69WrWwZAXJ4eCeoUOB7MS/4fWiOJ10kRV2RVMYY5hYLomIqtKpXTt+/vlnXnzxRa6SZXZEYowzTAy7gy6GSX5VxVIUJpg+/mMF0D0emtSvT6rdjiWK/Ncf4MtQBN3lYseOHTn3Fo/HWbFiBStWrODG667jWt3gEd3AdDioV6UKq1evZuBtt6G6XEiCQHdZZkskRkFNI8Xvp7VpUkrXuaF9exrVqEFElnnW9PFtJEYJwyA1GGS84eNpw4csiPgVhWeffjrn+gP69EFxuXL0sgepKi6bjZqVKhHyennfH2S2FchxVF+8eDEFNI2vw1F6KyqGIDDZZ9Hc7cFjs+EVBNISCfwUQeSOhDbi22+/TZnMTDLT0njooYcYdf/9lM3MpHObtjkBSTweZ9T991MyI4Nm9evz6quvsnfvXuLxOCULFuQGTecGTadkwYLE43FOnTrFRx99xKeffnpG0Hz3oEGU1HSqebw4bQJup5MxDz/8h97tc3HixAm+//77XEF7PB4nalk0drtp5fage73/yKOZfyd++eUX6tSpgyAIPH3aO3yl+OqrryhYuBia4eOBh0Zd8eslSXIxJBPUyfg7yZk8MHIkisuFIkk8d9pppn8TVUqVYqJpsT0So5DDyW2KSnld54mxYy9pvJ07dzJ+/Hjeeeedi04+7t69G58sM84w6ZowIvyNkydP5oxXvVw5uuo6w7Xsk3/pkQiFVY1emo6lKOc1D3xjxgwUtxunIJCaMDt/xednnGGSmijMOBv79u3jp59+Iisri6lTpzJlypQ8neo8nZMnT1IoXz66aTptdYOqZcty54ABDErIVYzQ9DPkzvbs2cP69etzPcfJL76ILEl4nE4e/51R/emUSEs7rbjCz9y5cy9qvhd7b+mRCLdqOjfoBledZa0Wj8dxiCIbwlG2R2JYicTwvn37aFq3LpnRKA+MHHnOa5w6dYo7brmFwikpdGnfPtfzv/3mmzEliVqSm+2RGD11nVt79Mi59i3duuFxOvEpCqYssyAQ4ttIjBRFvaB59pgxY2iqG+yIxOiqG9zRu/clPKXLx+hRo6is60zxWRTWNN54442/dD6Xk6VLlxIIBDBN86Kk+E6dOoWqGxRqfy+FOz6ArGqXXKX/ZxKPx8kXCvGwYfKM6cOnKHn6t+WBh0Zh5S9Kvvo3oei+izarT/L3IZmgTpIkj0x99VUaVKtGwViMiiVK8MEHH5y1Xee2bXk4sYtb3OnkPi37z9frRo68xh8hLRTiDkVluKphiSKlMzPP2Xb58uWooh1ZEDBFkZCmcZOuM0w3CJsmhw8fBrK/DAbdcQc+RcHv8XCfprMpEqOQrrNo0SIg27ykpq7TV1Fx22zM9gdYHorgttm4U1FprKo0atQIy5OtEV1O17n/nnty5lK+SFEm+yze9QfxCgKdZAVTFBmsagzUDepVrgLA3LlzKabrrA5FGKDpFHC52BVN4RnDxCEIrAxF2BSOojocyC4XsiDgEQTe8gdYE4pgut05khO/5+DBg3Tr2BHD5WKQpnOfbhDQdRS7na/DUT4MhPAIAmvDUfKrKvPmzWP8+PG8/vrrRHw+HtJNCjscjNIN1oejFNQ0FJeLgChiCSIPaQYLAiEMt5vnn3+exx57DMXpREnM74NACKfNxjBVw6+q+DwelocivOyzyIhEgOzNguKGwbeRGF29MjUliV3RFKb4LHRBYKrPz85IjGIOJ/nD4Zxg49ChQ6SFI3TUDdIlN6Yoco3HQ0tN54b2Haherhypfj8PP/AAkF0BIycWmr169UISRXZGYuyMxPA4nfz8889c27QpxQyDdE2jf5//PxoWj8eZOnUqboeDhYEQy0MRFJfrgtqH+/bt45qGDSlTsGCOVMeBAwdYsmTJWStZVq1aRdg00SSJxrVrnxFYDR88GK9N4GrJTTuPF1kUL8nB/Upw4sQJ7r/nHjq0asWcOXP+6ulcFEePHqVFixbYbDYeeuih5LG6JP+zJBPUyfg7yf9z4MABFJeLVaEIS4JhvC7Xv9LctkG16ozQDVaGIqS6PVQuXZoHRo68JB3Uffv2EfH5aGf6yNQ0Rj/00EWPsWDBAprUqk3XDh1yDMDPdp3ShQtTzOlkvj9IisPBy75sv49r/H4mT558zvGDus7b/iCrQxEMQaCPrOBzuahQrBiff/75GW2zsrKYOHEiA/v1Y8WKFdkSHenpBEU7JZ1OCufPn6cE2BdffMEjjzzCRx99xO7du7mzf3/uHjyYAwcO8MEHHxCSZfqqGhFZvqDZdVZWFrIksTAQ4vNQGMXl4uDBgzmfx+NxPv30Uz799FM6tWlDC91gtG5iyTID+/WjQdWqPPzAA5c91vnuu++yE86RGFsT1eFne4cK5cvHMN3gccPEr2kcOXKEG9q2o6tu8F4gSIamnXO9OWnSJCroOu8FgjTQDe4dMeKMz+PxOB9//DEVSpTAabdTPCMjl7TJoUOHOHnyJM+MH4/P4yGfqtK2efMLPo9Dhw5Rs0IFnHY7pTIz81TheiU5efIkdw8aRL1KlXj80Uf/dbHr0qVLCYfDOBwOXnrppTz3W7BgAWkFC5O/QCHmz59/5SZ4mVm9ejW1K1akaukyLF68OE996tRvTGbbYVQaMY/Uik145l+6ifq/QDJBneRfxbx58xg7duwVM0gonC8f9+kGE00LU5bPelRmzCOPUFHXmWD6iHi9GB4PlSyLmN+fJ42ud955h1GjRp3zWN6mTZsoEA5jOByobvd5KwAee+wxmqpq9hEsRcUtCKwPR9kZiRE9R1VFldKledLwsTEcJVPXc74YiubLx3uB7MqDiCThtNmw22yYgkB9twfVbmfUqFG0MUx2RVN4wbRoWK1azrg1r7qKBxJBv08QKWJ3EE4kRf+bcACH7ICqXcuWuEQRv8eDT3LzuGFSUVHQE5XDflHEZ7ezIhRhaCLZ7nE4cDscFEpJQRQEqpYty48//pjr/k6cOIFdFNkcibEpHMXrcOAWBD4NhnnDypbfcNrtDOzblx07dvDII48wceJEXHY7myMx3vEH8QgCDlGkecOGFPR4+DgYprNXprHbzeZIDJ/dQQFFoalp4rEJuGw2Pg+FWROK4LYJVNE0bmjXjkcefBC300lA13OOI+3bt4/ihQvjcTjQPR4sRaGm5MYQRQpEInSTFV4wfRiCwBNPPJFzX8uWLaOk6WO65Scm2nnBtKgruWkouUk1TQYkDH9SFIXZs2fj83j4KhzlBq9MfrudqN1OM4+H1ppOhRIl2LlzJz6Ph28jMdaGozjt9jMCvqysLBTJzYeBEJ8Fw3idzrM+79Np26wZ3XWD/1gBIorCf//7XyI+H+Usi5BhsG7dujPaN6ldm4f0bIPQiqZ5RkVE4ZQURJuNTYn32bTb+fbbb897/SvN66+/TsOmLahSuQrVNJ3RuklQlv9xu/gnTpygU6dO2Gw27rzzzn9doJ8kSV5IJqiT8XeS/+fnn39GkSQ+CYaZFwiiut3/ygT1+vXrKZFRAEWSGHTHHX/o+2/mzJnUSxiv/8cKcFWRIkC2xnXpzEz8qsaQOwfRrWNHWjdqzLJlyy75Wr1vuoleus6OSIxCkkQFr8z9uoFfls8rnxUyDGb7A6wKRdAEgc6qRtO6dc/aduSwYZTRNPopKh5BoHqFCsiCyOJgiJ2RGDGHg+XLl593nsuXL8eSZXroBhFZOUMi7jcWLlzIPffcc87E7Olkx6LZpo3ZCWrpjAT1TTfcQIamka5pdO/UiQF9+9KuWTP69+9PaU3jJZ9FSU3jxRdfvOC1LoZTp05RulBhrtUNGuoG9RPG7L9nw4YNNK1bl6urVs2Rxru6ShUmJGQl6/ssXvmd7xEkYv6iRemqqOyKpjBU0+l5443nnM+RI0fO+y7//PPPdL3+eq6uVv2i5BGOHj2ajBGvMAcOHCAlEKCVpiM7HNhsNu6+++5/5b+/f4SxY5/AjGUQq9kRRTf/8Trk/8skE9RJ/jU89+yzpKkqnUwTv6pekWSVx+lkdSjCtkiMkCyf9RqnTp3igZEjaV63Ls9PmMDu3btZsGBBjk7ahe4hXVXpkTiWdy69qXg8zrZt284IwiDbUOX0pPnYsWNppBtsj8TorhsUTUujsmHQxDApU7gw//nPf+jQpg29b7opp+p42bJlBA0DyeGgR+fOOYHHrd27U03X6atqBDSNDRs2oLndNHK7qSNJRL1ehg0bhkcQuE1RyW930Kt7d7755hsK5cuHKAgEZBlJFGnmzk58RhwOCno8+L3eHEO/3bt3Y8oyYwyTfrpBwViM65o1o26tWtyqqCwKhmgiuSkmSWyPxHjetKhWpgzHjx/n/vvvp4mu820kRnvdYPA5TPLatWhBzOXCbrMhOxxIdjvuhARH0DTJyspiw4YN+FSVJopKOV2nREYGpQyDMobBtU2bcurUKV588UUa+rKDyMcNE10Q8IkiusPBokQyv4iiorhcuAUBjygSNgzuueeenCqTrKysnGd88uRJShQsyLW6Tj1VI6yqBDSN2jVrMmLECIYMHoxks6ELAgXtDkKGkXNP+/fvJ6BpNHK7ucbjYVc0hadNH6bDQZGUFBpIboo7nKRIbiZPnozhdrMyFKGIw8FMK8DacJSCXi8dO3Tghx9+4NChQ5iyzCTTYrRukj8UyvUcX54yBZco4rTZSPV4uK5ly/O+3xWLF2eaL3uxVsOyuLZ1a3pp2Uc579B0bv/dEcEW9eszXDfYHIlRxjB48sknc4xI2zVvTtTuoI3Hyy2yQszvv+x69BfDkiVL0KwgBa65Cz1/CZrK2YuG1pafF35nVvlncPLkSV544QXGjBlzzqqr85GVlUXv3r2x2WzcdNNNSRftJP9zJBPUyfg7yZk8O348XpcLzeNhxmkeHv9E4vH4WY+Nx+Nx7rz9dqI+H/WrVTvj+3Pfvn00qV2bgheQXviN9evX45dlxhomzXSDHp06AVCxRAlG6gZLgmF8dgctlWzzaL+q5mmtcDZ27txJ4fz58TidVCtXjgfuvZduHTteMMk7c+ZMVLcbl91O1DRpWrcuu3fvPqNNPB5nyZIllClYMCeGayq5iSZOCN6mqEwyLbyiyO7du9mxY0fOCc3fc//993Nzwhz9Yd3gxnbtLul+T+flKVNyJD7GjRmT8/eHDh3C43SyMRzlm3AUt8PBr7/+ypTJk0kLhRickBK5U9UYkJDLu5wcOHCARx55hLFjx/Lrr7/mud+cOXOwZJlypo8iaWm51np79uzBUhT6qyqqIFI6UczyR4ohrmvRgmtPqy7fvn37JY/1V7Fjxw5eeOGFc3rg/FOZN28e1RIbXW9bAQxFwWazcd111120rM6/mXg8zrRp0xg8eEiu0x9J/lkkE9RJ/jXUr1KFF8zsI23XWhaTJk267NcYeNttZGgapQyDJnXqXPZd46a1a/NcYte8g8+6qOMpU156CUWSkF0u7ktoZB86dIjalSrhEMVsSQxJon2bNgwbNoxalSph2u108MrcqmqkhcM5zt9ZWVm5gssTJ07wxBNPMGjgwJxK15Asc4ucbXjoFgS6dOpEF6/MbYpKC7eHO/r0oWWDBgzRDTaGo5QyDHp07UoRTeNmWcFrs5Hf40H3eJg/fz5r167FUlVMUWRHJMZX4QhelwuAFStWYMky1ykKik1AFUVCkoQpyznu6kOGDKGEJHGTrNBRVel3mizF6SxatIh8Xi/rw1HGGSaaKOKy2Yj4fCxZsoSdO3cSUDVqSm4Cosi9mk5GOMyMGTOoVLYsEdPkps6d+eGHHyiWkUExw0BxOAhoGm1btKBBjRp01g0e1c0c/T9TlhmpZSf4w5bFm2++mev92b59O2FZZmckxuZIDNFmY7RmoAgCzQwTVRR5w0q4mNsdaB7PGf1XrVpF2xYt0CSJa0wfAbeHcePGcV3btlRyuXjHH6SE08nAgQN5+IEHcDudqA4HdRWVB3UDv6zQq2tXXHY7QcNg7NixVChajGplyvLmm2/mWjgdOnQIyW5nXTjKlkgMt8NxXh3oV15+maAsU8VnUTQ9nVGjRlFT1/k4GKa+rvPg/fef0X79+vWkRyI4RJEi+fIRkWX8Xi+PPPggBw8epOeNN1IkLY1rmjX7y6unn3nmGVIqNKLSiHkUbHM3slela2LB+VtS/c+kS/v2VNYN2ugGmamplxTExuNxhg0bhs1mo127dldEu+7777/n4Ycf5umnn/5LNxiSJPk9yQR1Mv7+K1m4cCEvv/zyFTdyu1hOnTr1j6/ce2TUKDS7HbvNRqnMzDNim9mzZ1MsEZd01Q26deyY81mna9vQ7TTphQ8//PCC13r33Xe5pmFDBvTty6+//sodt9yCLoq8bvnZHomR3+5gQsKkvICu/yGz4Hg8zi+//HLRa5OTJ0+e11R6+ODBpKkqqW43xZ1O7lI1NEGgmMPJVZKEKgj4JYknnniCRrVq4fd6sVSVJUuW5Bpr7ty55FNUxhomZXSdJ8eNu+j7PBvHjx/PdQ8nT57EUlUmmD4mmD40t5sRI0YQkWWGqhqKINBKUbFkOU9JzT179jBk0CBGDBt2yRsJvycej/PkuHG0bdqUiQnDyS+++IKSBQqQallMmjgxV5/FixdTLiHhMtsfIGQYuTYVLpbCKSnMTxTWVLKsnHXVP4Xt27cTMgyusSwiisLUP8ns+89g27ZtWLLMw7pBS92gwzXXMHr0aGw2G1WqVPlXG7gn+d8kmaBO8o9g9+7dzJs377z/CN/Vrx+1DIOxhklYUa7I7tlvel7z58/n5MmTl3Xsn3/+mTatWlFBUXlENwgrSp6P+8XjcTSPhwWBEF+GImhud86zWrFiBYoo8rRhsiwYxnRJ+NxuJJsN0Wbj24TucMDrPacEydq1aymYkoLTbqdH5868/vrrfPXVV/gUhc+CYXZGYqQpCmPGjCFNzU52pikKVcqXR3c4uMrpopnbQylNY8aMGTRt2BDD4aCGS8qp9G1QrRrdOnZkkKpR0eXiKpeLTLcbv9eLX9OY8MwzvP3222guF7OsAB8HQmgezxmyEtXLl6elx0tPWUG2288p9bJo0SIK6TqbExXYpZ1OZlh+/B4vWVlZPPvss7Qxs6VKnjJ8pDmctG/ZkrsGDOAaXeduVSPocFC2eHFkScIuCNzZr1/O+GvWrKFW1arUrFiRuXPn8txzz+Fzu1kbipBqt9PY7aaErnNX//5nzOv48eOkBALUlCQqOF1k2u1Uc7l4JKFpHrXbeVTP/jlqgsAD53Cp3rZtGy+88ELO+1M4X76cSpFesoLX4WDa1KmcOHGCw4cPM2LoUDq1acOkSZOIKgpfhaM8Z/ooVbAghw4d4qrixUnXNCxFYcmSJfz666+0bNAAw+NFdTp52DB52DCJ+HwXrLRdu3Ytc+fO5dChQxw/fpyuHTqQLxCgY+vW56xm+vbbbzHdHjaFo3weCuN2Ov92Fb2bN29GMy1SKjZFD0S4/fY7GD169EW7bl8ufIrCilCEXdEUChkGX3755SWPNWbMGGw2G40aNTpnVdSlcOzYMfJnFCRSviHBwhVo3urayzZ2kiR/lGSCOhl//1U8/uijpKkqjX0WGdForgrKJJfO5s2bkR0O2nm87IjEaOnxcs9p2r0vvPACjU47Gde8Xr2cz+pVrpwjvXC1z2Lq1KkXde0ffvgB1SXxROLEnSWKZITDlNZ0rjZMIn4/jz/++EVV2/4ZWKrK0mCYreEohsuF6nLhsNlYm5BYiykKmzZt4q233qK8kS3L9qTho3bFimcd75WXX6Z9ixaMHTPmim92LF68mHKFC2M6ndRVVErIMoXdbnZFU7hX0ymakXFOScXTOXXqFEXS0rhR02mj61QtW/ayzG/i889TXNN5wjApoKq88cYbFE1L41HdZLY/gOHx8N13353R55dffiF/OEy7RJL/jltuOevYS5YsoX2LFtxx661nlaQ8nWF33UUxXaeN6SNfKHRBT5m/G88//zxtEkn7CaaPxjVr/tVTuqwsXLiQ65o3p3+fPvzyyy8AvPnmm3g8HtLT03NJJCZJ8k8mmaBO8rdn1apV+FWVGn4/QV3nm2++OWu748ePM2LoUNo0acKsWbP+3En+QY4cOUKJggWpY5oEJYlyhQvz1ltv5bl/PB7HlGXm+oN8HgqjSRI//PADAI1r1iQoisz2B9gUiWHZ7YzSDAxBoLTTST3JTXOPh1KZmRw8eJBhgwdzS/fuPP7447z66qscOXKEelWqcJ9usDYcJWq3U0HXCcgy1zRtSlFdp47PR/lixdi2bRt1q1WjcEoKabEYV7s9REQ7A1WNu1UN1enk119/pVSBAtyr6RR0OFgQCNFZVgjJMg1r16ajbrAsGKaQx4smyzxjmHwYCGF4PKxevRrd42GmFeAxw6RQauoZz8HlcPBNOMquaAqxs2hsHz16lKysLLKysri6enUkmw3JZuN508d4w4ch2nnvvfd4//33SVc1pvn81Pd6qVy2LIcOHaJH5840d3vwCgJjDJOrJTchUaSOJKEmTPp27txJ2DRpZVmEZZmYZVHLsjDsdvyiSGGHg13RFD4IhCiQMEYE2Lp1K3f270/QMLja7aGs04UqCEg2G9VdEi/7LAIJiRDZ5WLg7bfn+f3ITEnBEARqSRKyINDR66XJaW7wv7Fy5UryqyqbwlGm+vwUzZ+fV155hTqJ6p7HDJMmtWvzwH330UTX+TIUoYqiUDwtjTqVKp3TyOL777/n7bffvuQq559++gnd7eEtf4CJpoVXEGhcu3auTaIPP/yQZ555hm3btp13vEOHDtGvd29aN2rEe++9l+vzrKwstm/fftHJ2E2bNvHkk0/mqarqStOwRg3a6wZ3azpBXf/DCY5JkyYhiiLVqlW7bAuX9evXY4ZSqDRiHuXvfAO3R74s4yZJcjlIJqiT8fdfRakCBfivP8CuaArVLOuCRnFJ8s7KlSvxuVx08nrZGYnRxuNl+N1353z+008/USwjg+Jm9gm434zC4f+lF8r6fBRNT7/o79VDhw6hud287Q/yrOFD83o5fvw4M2bMoFBqKk10nYaGQd0qVS7b/V4OyhctymDd4EWfhen1snnzZkpkZHCrpvNgwmz80KFDvPfeexTRddaFowzXDBpUr3HBsfft23fek3eXg48//piyiU2HRcEQiijSwrKIKgovT5mSpzH27NmDL2F6uD1hevjbqdM/wi3dunNPQvKkn6IyZPBg/JrGomCIrYnk/++Tj1lZWWzevJnHH3+cqVOnnjXJv2vXLixFYZRucK1u0LZZs/POIx6PM3PmTJ566qm/3PDwN7799lvat2pF60aNLlhksXjxYlIUNdv/SDcY0LfvnzTLv5bPPvuMUCiErut50mxPkuSfQDJBneRvT5+ePRmU+PK+WdW4e+jQv3pKuTh+/Pgfqnj49NNPKW6a7IzEWBgIkS8QuKj+8XicgQMGIDkcSA4HYx99NOez5ldfzTUeL6ogoAoCEd2ggduDx2ZDttnQJIm+ffvy448/ck2jRjTXdfqrGrIgUFXXqVmhAtXKlGGC6WNbJEYhh5NXfH6eMExa1KvH3LlzmTp1Ktu2baNiyZL01A1GajoeQaC3V0a02RisaozWdRSnky+//JKMYBBTFMm0O1AEgXSHgxdNi4DXS9UyZTG8Xjpd24aApvFBIMSmSIyILLNhwwZef+01MmMxyhUpkktvrUmdOjTUda7XdArly5cjSRCPx+ndowcuux2/prFkyRI6t22LarPRwysj2Wx4BQGHzcbgu+7i8OHDtG/XjqKpqdx0w405icovv/wS2W6naqLy+7/+AKl2O88YJm6bwOuvv85zzz3HNYld/FtkhYrubD3oaT4/EVFEFwQe0Q1ae2V0h4NKJUvy9ddfkxII0FPTqClJNHN7+DocxWmz4bTZ6CbLVHK5cAkCKbJME8sifyh8QVPC3xj32GOE3G4K2+0YCZ3sSqVK5Qpq4/E4PTp3RpUkDK+XuXPnMnv2bIrrOitCEXonjpbd2b9/jobgTZpO1auuQpMkVEnixd9J62zfvp2Iz0ctvx9Lls9Y7F0Mr02bhupwELPbmWH5KWkYZySXJz3/PKmKQjufj6Cus2PHjlxjbN++naGDB1OxVClaJFzTLVk+o9L+yJEj1LjqKoJeLwFdZ8WKFUC2xve0adMuq7bd8ePHee2115gxY8ZlP5Fx4MAB+vXpQ9cOHVi9evVlGXPGjBk4nU7KlClzWY4U/vrrr1jBMKm1OxMp35CqNWpfhlkmSXJ5SCaok/H3X8V1LVrQQTd4zvQRSMQ+SS4PWVlZNK5TB1UUkWwCaaFQTkHHbxw5coTPPvuMvXv35uq/bds2Fi5ceMkx//TXXydmWaSFwjkxzI8//ojqcrEjkfx02u1/WFv222+/Zf78+Zel+n7z5s1UKl0a3enEJ8u8OGkSO3fu5IZ27bimYaOcOCkej1OvenVEmw1dtFMsI+Oc9xGPx7mlWzc0SUL3eHjzzTf/8DzPxd69e7EUhQcSsmeNa9fmpZdeuqh47tSpU+QLBunglWkhK1S7TBXU8+bNIyTLdDdN/LLMJ598wtgxYwh4vaRrGq0bNz4jVv/6669JDQZxOxy0bNDgnEnyjz76iKsSa5EPAiEKRqO52hw+fJhZs2bx8ccfX5Z7ySt79uxhzpw55zy1+xvF0tPprxvcpxuETfOCMnAvvfgi9atUoV/v3v9T2szbtm2jRIkSOBwOJp5FEiZJkn8ayQR1kr89ox58kDq6wfxAkMq6zrPPPvtXT+kMZs2ahebx4HY4uPvOOy+q78aNGxk7dizTpk3DJ8uMN3z00HQanOb2fOjQIfrc1JOG1aszY8aMs45z96BBFNd12pkmqYHAGdpoGzZsoEAse7e/ddOmjBw+HK8gEBRFrvV4ydQ0Ro8eTaXixVEcDj4LhtkVTaGow8nbVgBNFGl09dWYsowpSZgOB9N8Fk0SO9RZWVl0bN0658jfV4kjfyFRRLfZUASBMk4npZ1OQqpKo1q1uF03mOsPYjmd+LxeZloBdkZilDPNM5KOz0+YgOHxEJZlbrzuugvq6h0+fJjRo0cz8p57zlhYLFu2jHRNY0M4ygTTR/kiRRj1wAPkc7koYHdQ0emkmMPJf60AEdOkVqVK1NN16homV1erdsY1evfqhSIItPV4SbXbCQgCRR1OijscOGw23A4HXoeDsbpJFUXBcrp43fJzlcuV0OxzYNntmHY7JR1OJJuNFJ+Poka2pMjKUARVEOisqBRKTaV969aEZTk7WPX7mZ4wyqhr+Zk5c2ae37WPP/6Y8qVK0cDj4YNAiHK6zujRoxk3bhzz588/o+0PP/yQE9zF43H69uyJIkmkGAY9u3VjxIgRBA2DTMMgxe9HkyS+Ckf5KBBC93rPGGvMmDFcb2RLlDyUSHBfLMuXL6dsocKYLhftvF5WhiKkqSqffvppTpt6lSrzYiIYv8ayeOmll84Y4/Dhw+QLheih6QTtdmYnqtNq+f28/fbbOe2mTp1KDdPHjkiMh3WDZnXrcuDAAdIjERpYFjFFYcJFaMOfi3g8TqNatahimFQwTdpcoLrl78K8efPweDwUKlTospjobNiwgW49etJvwMDLpumYJMnlIJmgTsbffxUHDhygW8eO1Ktc+R93IvCvZNLzz1MiLY0G1auf9/spKyuLL7/8kjVr1uRJYuL48ePcP3IkXa67joULF17OKQPZyc+CKSn00Q166TrFMzJyxbtz5szh7rvvztMm//vvv48ly1SxLNLCkcuyoZwvGGSSaTHPH0Bxuc55mrVkRgZv+vzsjMQob/pyxZe/sXbtWqKKwjfhKLOsAGmhEHPnziU1ECDi8+WYcG7ZsoXly5ezdOlSZs6cmSNvcLF88MEHXF2tGt06dbqopP1PP/3E8uXLmT9/PiGvlyZuN+mS+5weN5fCJ598wqOPPsry5ctz/u6bb75h+fLlud7Paxo2ZIRusDUSo6JpMv0cZqUHDx4kfyhbBqSkrjPodyaQx48fp0KJElT1+UhTVe47TebmSrJ+/XoCmkYtvx+/qvLFF1+ctV1WVhZ2UWRTJMaOSAzL42HXrl1/yhz/iRw8eJCGDRtis9m46667Lqt0zi+//MKuXbsuu+9WkiTnIpmgTvK359ixY/S84QaK5c/Pbb16/aFKwx07dlx2w7IUv59ZVoCvwhH8Xu85ZQyWLVtG/WrVaFavHuvXr2fLli34VZVOpkmaqtLv9tupX7UqHVu3Zs+ePUx99VU6tGpF9fLlaaEbTDB9hGT5rMeciqbmY17C3KKKZZ1VtuA3zV7D6+XjYJhNkRh+USTkdKJIEi/6LMo5s7WfO3q8+ESRYaqGKYjU0HSGDRnCjh07GDtmDFVKlqRXly78+OOPjB07lnRFYXMkRjWXRAmXi3qKgm63U8zpwmmzsTUSY1skhlMQKFWwINOt7OC1tKpiuVz4RZGiTieplpVr1/u7775j48aNxONxjh07dklfkEuXLiVd09gYjjLRtChXuDDHjx+nRdOmBHw+XKLIh/4gL/ks8gWDSILA9kQli8tuP0Pq4ejRo3S+7jpSg0FaNW+O5nTylj+AKggsD0WY6w/iEQQ0p5Pr27Zl3NixFM/IwOdw8F4gSH9FJaJpxJwuunll1oajlHS68KsqNysqdSU3qaKdFJeL0aNHA9lJvE2bNtGifn1aerxMMi18LleezXRWrlzJmDFjaNOsWc5Rwk6ajtflynn/njvLxs/GjRspWbAgksOB6XTysG5QxumijMdDQJZ5+umn2bp1K5rbzdJgmJlWgICunzHGjBkzKK7rvO0P0kQ3GDJw4EX//ApEY4wzTGZaAdyCgNflYsiAAWe8C/169+Zq3eBp00fQ48ml375mzRoyE4nyvopKit1OW9NHzO8/w4Rq5syZlDEMNoSj9NcN2jVvzsyZM6mT2BiYbvmpUKzYRd/D79m/fz+qy8W2SIwtiYqpf4pJ4JIlS9B1ndTU1GRlX5J/LckEdTL+TvLPYd26dQRlmVlWgNt144xCjz/K7TffTC3d4D7NwLpCFe3btm3j5q7duLVHj1yJuBkzZpCiKNyuagTzcBKtxdVXMy5R9HCN6WPChAl/eH6G18uHgSDVXBKmKGJ4PMybN++MNidPnqRoWholnC7uVjVCssxXX32Va6yTJ0/y2muvYXk8rApFmOyzyIylYMoy0y0/b/uDaG43Tz35JH6vl6DbjeVwUDNhsH2xkiD79++nQCxGJcvCkmXmzp2bp35ff/01IcOguGliqiptE/rjE0wfTWvXvqg5XC5aNWzIPYkEdaXzJKghu1J53LhxTJ8+Pdfa6fPPP6eIYeSc3E2xrDzPYd++fdSvVo2IadK/T5+LWpcNuesubk144gzSdPrefPM523a45hquMgxqmSY1K1T4x5uzXmlOnjzJzTffjM1m49prr70snjFz5szBq2p4VZ1r27VP/gyS/CkkE9RJ/md4dNQoTI+HgNd7TkOJSyHF7+c/VoA1oQiWx3PWBPWRI0fwaxqPGSYjdIOCKSlnGDpMMi0anhZMz5s3j1RF4THDJOhwMM2XnRxr6Pfz+uuv5xq/fatWtNINHtYNLFk5b+VIWjjMBNPHvEAQyWYj3eHEcDjYHolxvdeL3WZDdjpJi0Yp5HAyLxDkPs2ga/v2ue7pquLFKaFlO2E/qhs8phtk5s/PhAkTmDp1Ktdeey2qKDJY1RisangFgRs7d8byeilhmKRHInTQDRYEQnTzyrRt3vyscz516hSd2rTBabeTGgyeNeD9jR9++IFB/ftz+6235jyHeDzOTZ0743U68SkKCxcupGfXrpRQFLpoOobHg9flImpZ3H777RiiyB2KSh9FxfJ6OXLkCI899hj3jBiRyym7Wb2raZWQRPkyFOH9QChbTkUUickyAVWlYGoqhV0SOyMxplt+SmVkoAoCQ1WNnZEY9SQ3w4cPp3zJktSSJDaFo9yqagy5664zrlWuSBGqulxUcrowJOm8xi67d++mQvESOEURRRAIiyKSIGB4PFSyLHRJIl/CjX2i4aN+1aq5xmhSpw5DdINhqkZLT7ZUyUTTop7k5kH9/9+JJ8eOxety4VMU3n77bQ4dOsS1TZoQ9fno0qEDdw8aRKkCBejWsWOeA6Y5c+YwduxYtmzZgubxsCwYZkskRsgrn3WT6fDhwxRKTSXkdOJ3u3Mlwn/99VdSAgFu0XSaaDoVy5Rh/PjxuX6ep06d4sbrrsMhipQoUIBvv/2WL7/8kpAsM9ln0V436Ni6dZ7u4XycPHmSqGVxr24wVDdIj0T+UdUJq1atIhgMEggEzlkBkyTJP5lkgjoZfyf557BgwQLKJKTyZlkBiqelXbaxK5cowYzEJnXj/2PvrMOjOLs2/sz6jj0zO+sbQoI7wd3d3aEU1yItLkUKFHiBAgUKLe5QKK4txYoUd3cCLRYskBDZ+/sj23ykEQIEQmF+15WrvJlnznNmNm9y5sw597Fak0wKvgvaNm+Okb5h2d0FEYMHD05yfZe2bdFApNhktSONTofGDRq8dnzh9XoxZMAA5AgIQPN69TF+7FhwBgMy+p4XZskKCufMGeecwf36oYgoYgyVIGo0GNi/fzy7UVFRqFSyFLJQCZJeD71GA5tPP9eo0+GIw4VTTjd4gwF+Vis2We0xHY6+rrdCFiVeYvxVzJ49G9V8GtRTpOQP0OvUpg16+Yo66vICRKMRjSwKrGYz7IIAO6VYMH/+a/nyuly+fBkLFizA2bNnAcRUnvvZbDDr9ahRvnyCEh9erxfr1q3DzJkzE5UCDA4OhoXlMEtW0I1KKJk/f7J9atOsGVpRCX/YnchOKVavXp3sc3/44QcUohQbrXaUpBRjx4xJdG1kZCSWLVuG+fPnf1KSHW+D1+vF+PHjwTAMChYs+NZ64ukzZUXmZiNRYMBayK60KSpzqKKSGGqCWuWTIDo6Gia9HgcdLpx1uiEajSnS8gYAa9asiZX4+DqBYAyISRZazGZcc3lw3umGVqPB3r174eR4TJRklPxXZenIkSPRwRcU1TGZ4dDrUduiwGO1xvPb6/Xiy65dQX0SDK/ScduzZw9sggCRYRCg1cKh0cCi1yM9z0PSaHDK6cZCixXpnE7YRBFVrDYoHBevrXHjxo0o4Buet0yxQmA0cFkscVrUXrx4gUA/P/A+SRFKGNQsXx6XLl3Crl27cP78eThlGWUUBaIpJkmbUPve+vXrkZNKuOjyoK7ZDGowIHfGjDhy5AgiIyNx7NixWEmPwrlzoxmV0JFKSOd2xwneHj9+jIiICPzv228habRYZ42pOi/9ksxDly5d4NbrUcxgQA6DAU3q1UOhoCD46XTIoTeAGo1IY7Whc5s2iIqKwo0bN9CySRPkzpgRBoaBkWGQU69HBZMJN10e9BdEFNLrkUGnQxqdDgrLYu6cOdBpNLBoNHBrtGAZBjdv3sSRI0eg8DxKW22wiSLOnj2LvXv3IihjJmRLGwA7pahiNOE737TvfwcKf/75J8aNG4d9+/ahTfPm6EApzjndyKPXY6IkowvHo2DevKhZsyYcBgOmyhbk0RuQwWRC3549Y+1ERETg/PnzKJ4nD6ZIMnbYHGAZBq14AS6tFs1YFvkpxYRx42LPiY6Ojn0AGty/P2pQCfvsThQTKaa9piTGpAkTkE4Q0UySQc1mCAYDRI0GaVgWjWrVSvBB69KlS3BxHK65PDjscIE3GuOtuXLlCr7q3h3Dhw59pX7kv/dYtHAhSubNi1ZNmqSYFMWJEydQq2JF1KtS5T9ZiXz+/Hn4+/uD4zh069YNBw4cSG2XVFRSDDVBrcbfKv8dwsLCUCBHDuSRZdg5Dj/NmJFitkcMHYrsIkVbkcImiq/Uzn1dLl++jKVLlyba4Tl71ixkEkR8QyV4eB6bNm1K0t6jR4+Q1d8fdq0Wn7EcMgviaw1eB2K6ybKKFBusdtSiEr7s2hWrVq1CWp7HQYcLg6mEisXiVqlXKlYMs+SYwpuGioIff/wxnt1jx44hQBBx3eXBdpsDDkmKjbdGDh0Ki9kMK8uid/fuyJ8tG0ZQCcUNRnzGclhgsYJnGJQsWPC1NMC3bNmCDKKIjVY7mlIJ7Vq0SNZ5A/v2RU0q4YDDiRKUYtiwYZg6dSpkjsMiixVbbDGV3imh8/1vIiIi8FnjxmC1WlQWRCgcF6sVHR0dnaTUyaC+fZFFpKgmW5AxTZpEK87Xr1+P4nnyoE6lSgnObUmMmuXLY5yvQr+KxYKZ/5o9kxSRkZHo0akTcgYGolPr1rGzglRSllWrVoFlWaRNmzbJoq5XkT1XHqSv3Rt5v1oK0erE0aNHU85JFZVEUBPUKp8EXq8XVlHEYosVG32tY48fP04x+5GRkUm+3f1Hbza/JCObSNG8fn0AwMqVK1G/alUMGTgwzh/pQ4cOQeE4tKMS3DyPoUOHYubMmbh9+3Y821u2bEEmkeIPuxMdqYTGtWol6WtERATslGI0lTBEpHBoNOgkiAjKnAV2kxlnnG4sUazI6PHg5s2bWLZsWYJac0ePHoWL47DeascXvqEjCSUOa1WqhK99yfYmLIe6deviyZMnOHfuHCIiInDnzh3UrlYNLpMJJWQZuTJmQlhYWBwba9asQV5Jxh67EwLD4BfFhv9RCRzDwMZxCBQEyCyLNWvWQMMwuOry4KbLAxvLJqhZZhNF1DKZUd5owlCRQjabcfXqVWzYsAFujkNhfYyetqjTYfLkyRAYBjNkC2qYzJAZBvMsCgpSCf3794ciCHByHMoULoyLFy/ii06dkDldOuTW63HK6UZzlkMzlsMphwtajQY7d+7EypUrUaF0achaLQSdHl3btYv17ebNm1ixYgUWLFgQc48tFkyTLegniJAYDYaIFG6tFvlz5kR0dDSOHj2KelWqoGKp0rCyLNpIMQ9nZYoXx2Aa075X2mjEYFFEVZMZ/lYrMphM+JzlEOz2wzhJRh6f5AkQ82CTO1NmpBEEiAYDtITAzDDImj49hg8fjk4dO6J6mTIYMXRorGzMv+ncti16+Vr4WrAcSpd49ST3lymRJw8WWqy46HTDyDDYbLNjiiSDN5kSlfh5+PAhJJbFHIuC4VRC1gSqp54/f461a9fGk/9QeXNWrFgBRqMBo9HCxAn4/fffU9slFZUUQU1Qq/G3SvJZv349urRrhwULFqRaN1BYWBh+++03nD59OkXter1eLFmyBCNHjkxUe/lNOXDgAESjEWU4DtRkijf8+5/958yejfYtW2LlypXJslurQgVMeAuZj0mTJqGhHHP+WCqjYbXq8Hq96N+rF6jZjJwZMsR7sT5tyhSkE0S0oRIUno8zgPofgoODIZvNWKnYMIxKyJM5c5zj165di03Unzp1CgWyZ0camw0Bdjs8Wh0mUAlVKMWYJCpv/43X68XIYcOQzT8t6lerluwB40+ePEHtSpXgoBI+a9gQL168gNfrhVmvxwGHM7bgqWDOnGANBlQuUxazZs3C1atXk+1bYgwfMgR+BgO6cDyC3X4YLFJ0bNUqWeemczqxzeZAsNsPeSyWNx5Onhi7d++GwvPIJsnIli4dHj58mKL2VVKGQ4cOweVyQRTFRLXgX8WBAwfgcHmg0xvQp9+AFPZQRSVh1AS1yifD1q1b4W+3wynLWLRw4Xvf/8WLF2jaqBHMOh14gwGTv/su0bWzZs5EkTx5ULpEiVe2si1ZsgSlLTGVzFMkC8oXKZLk+n+0b6+6PLjk8kBHCBZaFKSRZQi+QX8GQsAZja8czjNl0iRk9vNDhWLFEn373r93b1QXROywOZCH4zFkyBDYKUUaQUBQ5iwxQ9cYBnn0evhrtUjHC8iVIQNYgwEVS5dGZn9/pHM6UTAoCAaNBpRhwPkkK3hCkFmnww2XB/MsCgplz47yxYqhCqWoJwjwt9tx584dXL9+HTXKl0eRXLmwdu1aZA8MxBCRopGZjbGlKLh79y769OqF+mYWmXU6nHS60EeksPI8ihuMCHb7YaliBWUYzJBklDSzyOrvj4mSjOsuDwpKEpo3aoSyBQvCrNWivMEIM8OAZxhk5AVkoRR1q1eHTRRRTpZhZhh04QQUEESMGDo09n6FhobCRSUYSIxMiIYQbLfZ0ZUX8AUvxA4bbN2sGZ49ewY7lfANlZDXYERfX1J4gEDRvHFj2EQRslYLXqOBgRBkCwyEhmGwxWqHRaNBAzMLJ8fFeeCZNm0aqskydtkckBgNDjlc+ElWkMXfP8mfhZc5ceIETAyDbDo9XBotOIMhjs7zq+jesSPKUwkjqQQDITjpdOGQwwWjTpfoxHIA2LRpEwpkzYrSBQvGkz/5ZyBMQUmGYjKhdo0auHv3bpJ+hISEYNy4cZg8ebLaXpgIPb78Eq6iDcG6MoAwGlSsWDm1XVJRSRHUBLUaf6skj99++w0ujsPXIkUGQcCc2bOTXH/s2DGsXbv2jQfefUyULl489oX+l4KIhikgIQbESJ4oHIdCioK0DkecweHJ4datW/Cz2VBcsULhuGS/fF67di1Gjx6d5EuCRQsXIkuaNCiaOyjZLxO+7NYNHX0yJ81FiiHvaahfQowfMwaSKUYyMm/WrPicUvwoWyAwDKpSCoXnMXDgQGzYsOGN7M/88UcYNRroCYGfRoPFFivysWycrsWkqF6uPJpTCRMlGQrHp3jFPxCjQ33gwAE1Nv7AuXHjBnLlygWtVvtWWvT/JQlClf8+aoJaReUd8+LFC1y5cgX37t0DZzBgPJXRkuVg0GrjVYMeO3YM9evUgWw04gfJgtJUwqB/6RD/m6dPnyJPlizIRCVYOA6//fZb7LF/NORe1v/1er2oUb488kkSMukNcBoMsLIsTFot9tidYAnBdpsD66x2SCz31n+Unj59ikY1ayLQ4cAX7dujfrVqGO6r7K0sy8iXMydG+4LO2mYzTBoNGnA8hgkUZobBbIuClYoNgskE0WDAdNmCDhyP9FotArVa2DQa/GF3ohnHI0BR0KlNG5QqVgw2oxGVfHrfxfLkQXcqYY5FgYVlUbJQIVg0Gni0WvwgW1BJENChQwfMmzcP1GBAkF6PGy4PJkkyZJ0eDo0GNUxm2DQasITAo9Uip8EAtyiiH5Vw0umGy2xGDo7HPIuCDDod+gsiDjicYPUGrFmzBtu2bcOQIUNipVu+Fimasxy68QIcHIdCOXLgzz//xIgRI5BWp8Nxhwu9eBECw8DMMKB6PSSdHr0EEf48j1JFi6JiiRKwm8246fLgf1SCR6vFJElGFlHE3LlzYZckfC1QTJVkWHgeL168QO5MmdCGSmjGC7CIIrZv3x7n85o3bx4KSRJWKTbYNBpccLqx2hozYT25eL1eiGYzxlMZm6w2CEbja7VAhoWFYWCfPqhftSoa16sH2WwGNZkwZuTIZNv4N3v37kU2SUJHjkc2nR5VTGakc7sTbX2MiopCUObMqE0lVKASKpcq9cZ7f8wsXLgQsicdAmv0gM5gAsMwCbb1qqj811AT1Gr8rZI8hgwZgq6+JOtoGn9mycvMmjkTTo5DUYsFWQMD31uS2uv1om/PnnDJMsoWLpxgR2JqkCFNGgTp9fhZsSGXXo+aNWummO0DBw7A3+UCq9MhX/bs6NGlC+pVqYINGzZg+NdfI0/GjEnOBnnw4AE2btyY6PD398WLFy/QpX17WA0GWIxGZEyTJo627okTJ9C9SxeMGT36vQ2bDg4OxpUrV9CyUSMMoBLqm1mM8j3LfM5yyGUyI70gYrxv2HlyiYyMBGswYJfdgT/tThgIgaTRoH2rVol2EP6bgwcPImsafwRYrZg1a9abXJ7KR8STJ09QpUoVEELw1VdfJdr9qqLyoaAmqFVU3iHBwcFI7/HAzfNI53bDqNUijVaLr4SYwYIv6zrfvHkTVkHAl4KIfHoD2nE8JksW2E1m7Nq1K8l9wsPDcejQodgKiadPn8Lr9WL58uXITinWWm2oQin6+XSuIyIi8Msvv2D58uXYsmULDh06BMFoxArFBo5hcMLhwm67E5zR+FYJ6tWrV6NAtmyoXLJkbMtem2bN0I5SnHC4kF+SUKlcOdSnFNtsDmQwGJDe3x8iw6CuyQQtITjmcOG8T+ohvZmNnThtYWKG/wkGA0RjTLXyaCqhvkihGI1x2tuclGKHzYGbLg8yiSLS2O2oYDSiMctijqyAZRiUoBScVguHyQTep8tt4Xl81qwZ3Fotsup0cPoS1Jusdlx3eaCYzMjs7w+jToc82bKhj+8BrbcgwqTRgDcYMf6lNsS5c+cit0jxi2JDAYMB+Y1GGH1J+EmSDJfFggkTJiDHSwnyIgYDjjpcMGp1GDRoEAoGBcHP4UA7SjFKpBC0WpSVZOSlFEXy5kWDatUwbcoUhIWFwaDV4rzTjYsuDzi9ASEhIbh9+za6tm+Pjq1axWlD3Lt3L+bNm4ebN2+ief36MOv1SGOxQDIaQc1mLF++PN7nGxkZie3bt+PQoUPxjv3yyy+QOQ6c0Ygfp0/H7du3sW3btmS3Vr7MzZs33/ph8vr167CwLBwaDXa89LPxj6bfvwkODoaVjfl5u+LyQMMwalCXAF6vF5O/n4LK1WthzJj/xQbBY1/zoUxF5UNDTVCr8bdK8ti5cyfsHIfegogAQUiySzFflixY5hs4WNRieW1t5Ddl48aNyEJj5PDaUwnN69V/L/smRVRUFFwWCwRC4K/VgiUEU6ZMARCjMzy4Xz8UyJoVPbt0SbJ77N88fvwYrZs2RRqrFZ/7hnHXYDlkNJowXpIhGo3IzAtYY7WhKpXQ98sv39UlpghDBw1CSSphlqwgLc/H+Zn566+/YBVEfCWIKE1psvWlU4pTp07BKcuw+GL6BRYr/LU6/CgrmCBJsJvNyOrvn+zO3ZcT1PvsTph1Opw5cybZ/ni9XmRMkwa9qITBVILHak12Ylvl4yUyMhJdu3YFIQS1a9d+LQ13FZX3jZqgVlF5h/Tv0wetfRWzrUWKtE5nbLVwZ0HE8OHDY9euWbMG5XxTqtdabXBoNLBpNOjI8fBYrfFse71eTJowAbUrVMDk776D1+tFWFgYKpUsCZNOh3RuN3r37o3aYswwkm+phCZ16iToZ1RUFHJkzAgTw8BMCMxaLQSjETN++OGNr/327duQWRbzLQp6UwlBmTIhOjoat2/fRpHcucEbjahbtSp+/vln1KpYCeldLvTt2RMd2rdHR5/mWiG9AYJPziOvXg+LyYxCJjOcWi1ksxmLFy/GkSNHQE0m5NbrEez2w+82B3iGQQMziwmSDIXn0ffLL5FWEFBApOC1WuThBbAMA7tOBzPD4EtfYrk7LyCfXo82LAuHJKFe1arInjYABQsUgGA0gjUY4bFY0I9K+E6SoQhC7B/5LVu2wKzTIYdOD44QyDwfbzDFyw8cLRo2xIABA8Dr9bjk8uC00w2dRoPQ0FBkT5cOFq0WRkIwlkrYaLXDpNPBj+cxSKRQNBqMozHT6tMKAoYPH46lS5ciKioK586dw+zZs3H69Gl0bNUK6UURmSjFZw0bJvpZzZ0zB26eRw1FgVtR4lSm3Lp1K8Hq5+joaFQrWxbZJQl+PI8hAwbgypUryJslC0SzGd07dowdnHj48GFYBQGFFAUuiwVXr17F77//jnHjxuHEiRNv/DP2ukyYMAHUaERlkxmjfRqJt2/fRmRkZLwXMREREUjrdKKbSPE5pcifPft78/O/zIsXL9CoUSMQQjBgwAC1LVDlP4uaoFbjb5Xks23bNvTp1Qu//PJLkuvqVa2KNlTCMsUKJ8fh2LFj78W/BQsWoJxPDm+SJKPya87GSGmioqJQrWxZePR6UIZBMYMRNrM5VoN6zpw5CKIUKxUbilOKsaNHJ9t22+bNUZ9KqG4yoxnL4YbLgyomM4obDAh2+yELx6GRGBP3jqESGqdg1fa7oGH16rF62p9JMsaPHx97bOvWrShmjXnh8avNgcx+fu/dv9DQUJw6dQq9unVD4Rw5IBoMmEAl2LVafC3GfIay2ZzsQYSzZ84EazDArNdjyqRJr+XLixcvoNNocMXlwXWXB6LR+Eo5O5VPh0mTJkGj0SBfvny4detWarujopIgaoJaReUdMnzYMNSkFBedbtSkFLVr1EQmQcRQkcLFcdi2bVvs2n8qqHsIIgoKAliNBsst1hiZCIMhnu05c+YgmyhimmxBVlHE/PnzMXv2bJSUZFxzefCVSCEbDBA1Gig6HWSWjVOx/TLHjx+Pnaq9y+6ATRTfeujF4cOHkV6kuOGzyTIMqpYti/59++Kb4cPx048/wsZxKGCxIJ2fH4YMGYIdO3Zg6dKlyCyImGtRkJnjkM5kxq9WO5ZaFGQPCMTixYuxevXq2IqAXbt2IQul8NdqUdtsRjqtDtWMJtQ2m0G1WqxevRoAsGfPHpQoWBDDfS8MGlIJbdq0wZjRo1GUUqyz2pFLr0dGnQ7ptTqIej3qCQJGUQqRYdBXEBEoCPjfmDGoXLo0MgcGol+/foiKikJERARyZMiAKiyLfHoDyhmNaCDJmDx58ivvU7N69ZCRUvhzPIrmy4effvoJkZGRuHjxIubOmQNFEEBZFhk8HhQ1GHDG6cZAkcJpMKKSLCN3pv8fcHjw4EEoHI96Ps3AP/74A7t378bOnTsRHR2dqA9lChTAHEvM5PXqioKmDRsiS5o0qFa2bKK6hRcuXICL43HN5cEBhxPUbEbtihXRi0o44nAhC6WxQznat2yJAS+9qGnYoAHcPI9WPn2895Gk3rJlC2wch5qKAkFvQOWSpfDHH39gYO/eMGi1sFEab5DMlStX0LFVa3Tv3Bl37tx55z5+LERFRaF9+/YghKBz585J/uypqHyoqAlqNf5WSXnu3LmDelWqIF+WLJg1c+Z72/fx48fIlTETskgxcnipPdD36NGjCBRFXHN58KvNAU6jwbiXOu4GDRyIzr7iiYEiRcdWrZNtu1S+fPhOktCc5cAzDLSEIINWB4lhUJ7nYRVFOCUJZawxseLLzyIfIqtXr4aT51FfUWAVBFy4cCH22J07d2CnFJ0FEUUpRZe2bVPR0xg2bNiAupUrQzabsc3mwHWXB4GiiCNHjiTbxosXL95YrqRulSooLMkoKcsoW6SIWiigEoe1a9eC4zj4+fm9txeEKiqvg5qgVlF5hzx+/BjlixWDXqtF+aJF8ejRI8ybNw+dWrfBunXr4q0/ceIEevXsie+//x5tmjWDi+OhmFmMHTUq3truXbqgny947SuI+LJ7d8yePRulfEP7vhJE5NbrcdPlQTVBxODBgxP1859q5yWKFYOphLxZsrz1tUdGRqJ4vnzIotfDrdGilyDCrtWiBsejBqWwsxwWW6z4RbGBZxh0EClcPI9169Zh/NixKF+4MAb26YOMHg/cWi04hkHWdOnitaq9ePECRfPkQVaRgjcYYNBosMvmwO82Bzi9HmfPno1d+9UXX6A2lbDFZkcOSrF8+XJERkaiR6dOyJrGH6JGg+w6HVqyHEwMg1GihF6CiM6+iu7RVEL2wECYNTHyImaGQUaPBydPnoS/r43ylNMNHSHQE4LuX3zxyvsUHR2NX375BYLJhMYsh3yUom/PngCAhw8fYuCAAaAmE3qLFDVNZmTR6eDhefTr1w8zZ87E48ePAcRU1NeqXj22GryfIKJbp07J+qw6t2mDGlTCbIsCxWyGh2WxwWrH57yAKqVLJ3jO/fv3IbEsFlisGEElZA0IQLnChTFZsuCGy4OisgUrVqwAAPTq2RP5WQ4/K1YUpBRFg4Jiq2HaSNJ7kYNoVrdubPdCayph9OjROHXqFFwch5NOF2bJCrIHBr5zPz4VvF4v+vTpA0IImjVr9lrtySoqHwJqglqNv1U+LsLDw3HgwIHXHhj4LvhHdmyd1Y6RVEKezJnjHD99+jSsgoBKVhsUnse+ffuSbXvO7NngNBq04Xg0MrPw12px0+VBcyqhTp06uHbtGu7evYu1a9fi4sWLr+V3ZGQkhgwYgMolSmCaT44kIiICU6dOxcD+/V/bXnI5cOAAZs6cGSsX+DLnzp1Dvz598P3338d5Rjhz5gwqFiuOYkFBqfJCYtSIEVBMJmQSBFQsUeK9ycRFRERg0aJFmDdvHsLCwt7Lnir/LY4cOQKPxwOe5994mKeKyrtCTVCrqKQCXq8XY0eNQpWSJTF21KgE3257vV6cPn060eEkO3bsgJXj0FK2wMpx2LVrF8LCwlCheHGwej0sLIsGvICLLg9KSlK86b23b9/GoUOHYhNHK1asQFCGDChZoAAa1a4Nt8WCOpUrxyZAAWDz5s3o3qULli1blqzrDA8PR6DbjS94ISZhzDDYZnPgmMMFDSFoJ1LUN7PoyQsIdvthqEjRsVWrODackoTpkgX77A6kF2ls++PL3Lt3D7Nnz8aff/6J6hUrQtRoYCAEuVkOfjYbgoODAQDr169HUObMCLDZ0PfLLzF37lyMHz8ef//9N54+fQpZp8Man8xKQZMJBkKQVauFyDAYKFJ4dDq4DAbYNRqMphKuuTzIrtdjwYIFcMoyBlAJTVkWefT6mKpxgwERERGIjIzEihUrsHTp0thq55epXLYsrBot7BoNmrIs8mbKBAAomicPyvI8/LVaBLv9cMjhgmAwJPhyY9bMmbCZTMii02G+RUEQL2Da1KkAgOfPn+Po0aOxVfF3795F5ZIlkcZqRd+ePfH06VN0adsWZQsWRJfOnVGUj0nIz7YokLXaRB841q1bhzwZM6Jkvnw4efIkdu7cCQvPw48XUDxfPoSFheHs2bOwU4o8LAtWo0GTevXQ44svkIPnMVGSkUYQ8Ouvvybr5+ltGP711yhJJSy0WJFJFLFq1SocO3YMfjyP8043lilWZEqF1tCPnW+//RaEENSoUUOd9q7yn0JNUKvxt4rKu2TO7NlI73KhQPbs8STh/vzzT9StVg01q1V77SrHv//+G5LRiJs+mQeGELSiFArP49SpU2/l8+iRI1GYSvhJVpBOELBmzRp0at0aRSlFB0GEQ5Jw7969t9ojpciSNi2GUgnTZQtkjovzPPOuCQkJQTq3GwUphWI2Y+ZPP723vVVUkkNwcDDy5MkDjUYTq32vovIhoCaoVVRSgVmzZiGnSDFTVpBTFDHzDdscDx06hIkTJ8ZJ2nq9Xjx+/Bi3bt1Cgew5oNVoULtSpTitYuvXr4fMsgjkOOTKmDFO4mjmzJkoTCn22p2oajJDMhhQuVQpzJo1C06OwwCBIp0gYN7cuQBiKoCnTZ2KLu3axZNIAGLe0mYPDIRTkkDNZhgJgYEQpHe7Ub1cOfjb7fAzmTBOkpFFEFC8YEG0++yzWK22Qjlzoq8vsSizbGyy+R9Onz4NpywjPaWwCwJKiBRTZQtsGg3+RyU0oRLGjx+Pbdu2wcFx6CGI8PA8KpUtiwJUQkMqIa3Tie6dOiGdzYZsBiO+oRIUjkPvXr2g02jg0mjQwMzCX6dHXr0eAsNgoCDiosuDDDodypYuHXMdsgyzRoMNVhs2W20w6nT466+/0LBmTeSTZBSRZVQqWRJerxderxehoaG4c+cORIMBF5xuHHO4oCMEndu0QXh4OHQaDc47XUir1aK+mUUxkaJFgwYJ/iw0qVUL46mEfoKIdDodKpUrh+joaNy5cwfpPR4ECgIUQcCJEyfQumlTtKQSdtodyCrSOAnvx48fQzYakVuvh6LRIL8gYtGiRQnuGRUVFU++4eHDhzh37lxspUjfXr3Q1VfV3VMQkStjRvjxPGSDAXkyZ8HCBQsStJ3SvHjxAr26dUOpfPkwfuzY2M+gw+efQzAYILEs1q9f/158+dSYNm0aGIZBqVKl3usDoorK26AmqNX4W0UlNfjrr7+g8DyGiRS1qYQG1au/1vnR0dHInSkT6lOK6lRCnixZMHbs2HhJ8Dehef36sd1obUWKUaNGIaPbHTuYvLDVik2bNqFFgwbwWCxoUqduqr2cNuv1OO5w4ZrLAwfLJVrw8y5YsWIFyigx0nmLLFYUyZnrve2topJcnj59iho1aoAQgm7duqnD4FU+CJKKvzVERUXlnXDq+HFSBSCVzWZSFYScPn78tc4HQNatW0dOnz5NWrduTfLmzRt7jGEYIooicbvd5MCpkyQyKoqs2ryZGI3G2DUj+/cn44xmskuUiPfaNdL9iy9ij92/f5+kByH+Oh0J0uuJP0DyHz1GvuraldRlNKSzIJD2Gi3ZsXkzIYSQMSNHkh8HDCB06XJSr2pVcuLEiTi+5smTh5y6coXcDgkhUV4v2WxzkH0OF7n199/E4XKR05cvk5HTp5PDpUuR+wxDCpw7T/Rr1pLKpUoRAGTRqlXkSI7sZIJNITMXLCAejyeO/YljxpCW0V6ykxMIHxZOmmi1pJaZJcUNRvLNk8dkx7NQ4nQ6yW+//kqaMhrSSxBJQ8KQfTt2kGtPnxA/r5e8ePiQnF60iPSJiiZ3CciefHnJqk2byNj//Y/8b/x4Ukik5DvZQkoa9ORqdDRpyXJkUuhTkvmvW8RIGHJo924y1UtIcy9IgJ8fqff4Eanz4D4JNJlIzkyZyC/r15PlZpYsMbFk9569ZP/+/SSDnx9RJIk0r1ePeBmGnIiMJIcjIoieYYjT4yFGo5EEZc1KhoWFkUIsS3aajKTZ6G/JrEWLyKFDh8hnDRqSXt27k8ePHxNCCClZsSKZCS/RMwx5ZjSSwcOGEY1GQ+bPn0/Y+/fJ02fPSHToM9KqcWNy9++/SRDDkPQ6PQnQacndu3dj76coiqRd584kzGAgdc0suQovKVCgQLyfwWnff08Es5lIHEd+Xr489vuSJJHMmTMTrVZLCCHEnSYNOaphyJnICLKXEHL92jWyXaBki2whF65dJc2aN3+tn/03xWAwkP9NmkR2HDpEvuzdmzAMQ3bv3k2yBgWRLTt2kFv37pFq1aq9F18+NTp16kQWLVpE9uzZQ8qVK0fu37+f2i6pqKioqKh8kFy4cIEEGo2kDS+Q7gYj+WPPHlIyXz5SpmBBcuTIkVeer9FoyO/79pE8ffqQEgP6k50HDpDevXuTHDlyxFt77tw5smfPHhIVFRXv2L1790jtipVItrRpydhRowghhDRp1Yp8FxVFvgwPI6u80aRmzZqkeKlSZFTECzIx9Cm59CKC7N+/nwRv3Up+1hnI/d+3kUkTJ771PXkTOnXoQOqFPSN1wp+TPAXyk4CAgPe2d0BAADn34gXZFR5ONkRHkXSZMr63vf9h8+bNJHeGDKRg9uzk4MGD731/lQ8fnufJqlWrSM+ePcnkyZNJ7dq1SWhoaGq7paKSOIllrj/0L7WCQ+VDZ8+ePbByHBorSuwwu4R49OgRFi1aFE87rUenTshGKcrJFgR6/NC8fn2MGzPmlW8+w8PDER0djWJ586IbL2CX3QE/rRYBDkfsmlu3bsGjKAjU6mAiBHNkBbtsDog6HaxmM/r5hgXOnzcPAFCpWDHM9g3Ya6QomDFjRoJ7e71eiGYzttrsWKVYYSIElXgB7Vq0AAD8/vvvEDUa5NDpMUdWoNNoEBYWhsOHD+PMmTOJXtNX3bqhEZVw3OFCJpMZVoMBdUxmKBoNVis26AjBTz/9hPXr18OP5zFclGDV6dGNF7Db7oSfVgtJq8VMOeYa6igKZs2aFWv/3r17yODnhxyyDN5oRHlf5cgc2YIMWi3cZjMycTFT0tdYbbAYDMgYEIAmvgnpAwQRktGIfoKIb0QKntEgT+bM6OWTCCkhyShZogQUjRaZdDr05AXUqlAhdu/+ffqgz1df4a+//gIQMxDGKggYKlLUoxLqVq4ce3/nzp2Lru3bxw4nBICpU6dCTwhOOt046XTBoNFg8+bNUHgeOWUZWQICEBISErv+0KFDaFynDkoVK4aObdviwIED8e75w4cPIRiN2Gt3YrPNDs5oxJ49exL8+YuIiEDnNm2QJU0atGzUCKLJhDVWG6bLFlhY9q2Hcb4pS5cuhZvn0UK2vHbb619//YUqpUoho9uDcaNHv0MvPy7Wr18Pk8mErFmzxuuEUFH50CBqBbUaf6t8UISEhKBp3bookDUrpk+b9s728Xq9OHXqFC5duvTO9kiKEydOQBFFVOUF5BZFCAYDJksWjJNkuCxKig29mzp5Muwch6yShHJFi8ab8dKifgO0pBI2WO1w6vWoXrEiQkJCcPDgQcyYMQPnz58HAISFhWHUiBH4omNHnDhxAn179UJH32DsbiLFl926xbG7YcMGlC9SBJ81bIi7d+8m6NuzZ8/QpE4dpLXZ0bZFizeaY+H1erFjxw5s3Ljxvc3BCA0NxcyZMzF//nz8OGMGCufIgWb16uHBgwfvZf9/ePr0aeycmImSDD+b7b3ur/LfY9q0adBoNAgKCsLNmzdT2x2VT5ik4u9UD3Tf9EsNkN8Nc+fMQc1y5TB00KB4QYzK63PixAlMnz4dx48fT/B4aGgosgQEoLxFQaAo4ttvvok9ZhUE/Gl3Yq1ig6jR4FsqoSCl+GbIkARteb1e9OjUCQatFjZKMXLkSLAaDWSGQUGjCVXLlImzvnHt2lC0WnCEgGUYUIaBqNEgKGtW9OzWDT///HPs2nFjxiC7SNGTF6BwHE6fPo1ffvkFeXLkQJVKlfDo0aPYtUsWL4ZJowHLMPBotShoMKBorpi2t4x+fhhFJcy3KDAzDMoVK4YWDRrAajTCyDBwUor+/fvj559/jiMrERISggrFikEwmWDnefB6PViGwRCBYrwkw6rRxA4LXLFiBdq3bIls/v4YIIjYb3cgyGxG44YN4ccLqG9R4JCkWHmRf3j27Bn279+Ps2fPIq3TiXKKFTazGZUrVMCCBQtQskABZKUUPMOgmZmFS6NBOq0WCywK6lCKooUKIYPegApGE2qYzHCJIvpSCdddHpSSZIwYMQIKz6ODSBEoCLFadb///juKBQWhYvHiscMe//jjD+SUZWyx2bHZaoP/K4LO0NBQmLVarFBs+FmxQTSbERkZidu3b2Pv3r149uxZ7NoHDx7AKogYKlI0oxIqlSiRoM0HDx5AMBpx1OFCB44HZRhkpBS1K1d+5YPTnDlzwGs0cGm0KMNxqFyyZJLr3xUNqlXDd75Bja0kGePGjUv+udWroz2VsMlqh78gYM+ePe/Q04+LHTt2QBAEBAQEvLNhSioqKcHHmqAmhFgIIb8SQi76/isnsi6aEHLM97U2ObbV+FvlXfJ5o0ZoQiUsU6zwvObgwNehbYsWcPM8rCyL0SNGvJM9EuPs2bOwCgKqWxRQgwE9e/YEbzDgssuDC0439FptHMm+5LJg/nzUKFsWg/v1Q0REBB48eIA0Viu22Oy44fIgI6XxChLKFiqEH33FG6WNRhQxs2hQrdor97p06RJcFguCLBY4ZTk2kQ0AV69ehcJxmC5b8DmVUKN8+QRtDB8yBJWphF12B4pRiqm+mSqvy7lz5/Ddd9/ht99+e6Pzk8vq1avRtUMHZE+XDmVlGUUkCXWrVHmneybFrVu3IJtMuOTy4ITDBYNOl2IvNlQ+XjZu3Aie5+F2u3HkyJHUdkflE0VNUKski19//RX+goBpsgVFKMWIoUNT26WPln+0iX///Xfks1gQ7PbDZpsdmTye2DUl8uVDB0pRz2xGHTOLYLcfpssWVP9XovkfDh48CH9BwBmnG0NFClarRR5RBKfVomLJkrHVuf9g4XkcsDvBMwx22R244HRD0WjAGwzxqh28Xi/mz5+Pvr17488//8SpU6fA+ob9FTUYkdXfP856pyThV5sDV10eiAyDoMyZMahfP7AGA444XLjq8sBiMGLbtm2gRiPsGg322J0YS2U4dTrkohQ9OneOd41DhwxBY0pjJpXzAsyEwKPTQTKZsH379th1z58/R9aAAHi0WrAMg3R+fnj+/Dl27tyJGTNm4Pr160l+Pvfv38fPP/+Mo0ePxn7vxYsXWLBgAewsi6GCCKdGgwDfcEWXJOHw4cOwcBwkhgHPMLGJf7NOhwrFiyMsLAzHjh3DyJEjY3WQHz9+DNkXxA+hErIFBgKImUrOabRIq9WBYzRo3rBRrB9PnjzB1q1b41X9rFmzBmlsNvjb7UnqLO/YsQOZpZgK8QMOJ+yUJrp2xNCh4A0GGAjBPrsTV10eWA0G7N+/P97aqKgohISEoGu7dsgZEAi70YgbLg+OOlyQOS7J+/2uGDV8OApRiu8lC9LwrzeosVhQEOZaFNx0eVDSomDFihXv0NOPj4MHD0JRFDgcjkRf0KmopDYfcYJ6LCGkn+/f/QghYxJZF/q6ttX4W+VdUjJvXsz1dexVsChYsmTJa53/119/Yf/+/UlqIgcHB0M2mXHR6cZBhwtmvf69JvZGjhyJtr7q4xFUwueNGqFxrdrITiVkoRRtmjd/bZvbt2+Hh+cxTbagBJVQokABCEYjjIwGdc0s1lhtUFg2nkbzmjVrIJtMyKbXI4NOh2UWK7KlTZusPR8+fIi9e/fG6dADEOfZZsu/nm1epku7dujluw9tRYqvBw9+5Z6XLl1CrowZwRoM6NK2Lc6dOweF59FClpGG///ZOSnN2rVr4cfz6MEL4BgGN1weXHZ5oNVoUk3T1+v1omndusggUvjxPPp/9VWq+KHy3+P48eNIkyYNOI7D2rVrU9sdlU8QNUGtkizGjx+Plr5qw+8kGRVLlsSIESOwevXq1HbtP8vJkycxcuTIOPfw0qVLSOd2w6DVolShQlBYNrbKoHq5/68yuHXrFprXq4/CQUGgJhM6iDGDCxNrefzzzz8RKIq44HSjqsmErrzga70T0atnz3jrK5csiQZUgkWjwUxZwa82BziGAavRoGGNGknKMkycOBEerRbBbj8cc7hgZBhcu3Yttr0uZ/r0GEtlzJAsYBkGY6iEClRC4Vy5kUYQkJVS1K5UCSEhIeCMRgRotbjq8mClYkMGnS5GlkNR4u37zfDhqEspbrg8aEIp2nz+OSZNmoSDBw8CiGldsogiGEKQUafDTZcHiy1WWE2mZH1eieH1etGnRw/otVoIej1kvR5OjQbXXR7ssDkgGgwAgJ9++gkCo0FBgwF77E5UNBpRtWLFRB98Ll++DCfH4brLg+O+hyQAGDxoEFr5gvYvBDG2OvzBgwfI4OeHgrIFgk6PwvnyoX7NmmjTrFmy2lT7ffklWL0eLKNBTUFEPiqhfcuWia7fu3cvyhQsCKvJhF68gJ8VG1iGQbZ06eJc0+7du2EVBOg1GgQYDFilWJFRr0dhsxklqIRmdesl91anKJGRkRg5bBjqVq6MBfPnv9a5K1euhMKyyCNbkDNDRjx9+vQdefnxcvr0aXg8HkiShL1796a2Oyoq8fiIE9TnCSEu379dhJDziaxTE9QqHxSLFy2Cg+NQWlEQ6HK9lmzC9u3bYeE4ZJdlZEuXLtE49uHDh6BmM9ZYbfhJVuBOIN58lyxfvhxZRRGLLVaUoBSjvvkGUVFR2Lp1K7Zt2/ZGyfLJkyejmRyTFB4mUAhaLU473dhotYPTapHJzw9z58xJ8Nxjx47BpSioJMtIL4oYNXx4gusuXryIupUro2rp0rFxd0L80x1a0aIgnShi5LBhCa47efIkbKKIvJaYz+Dq1auvvM7aFSuiD5VwwuFCNkrRqVMnNPVd9zTZghply77SxpvQq2dP9BVEXHF5IDMaDBApulEJOdKnfyf7JZfo6Gjs3bsXhw8fTlU/VP573L59G/nz5wfDMJg4caJafa/yXlET1CrJ4uzZs1B4Hs0sCmwsC2oyob1IkV4QMPX771Pbvf8c58+fh8Lzvnsoxt7DZvXqxWoTF5dk9OjRA2ULFUKL+g3iVS5PnTwZktkMxWxGvqCgRF8W/PHHH8ibJQvcogiTTgfOYEAJXsB2mwMlKcX48ePjnfPw4UP06t4dVStUgFuWwWm1EDVaTJJkNKQSOnz+eaLXdunSJZgZBt15AWWNRvBaLZwchywBAbhz5w6OHTuGoEyZoAgCyvkSrcsVKwrnyIGDBw9ix44dsRUH33zzDcwaDURCYCIEBfUGNKMSqpYunaDPRYKCoNNokD97dty/fz/22E8zZsCl16Mtx0MkDGRGg99sDvTiBbCEYFC/fvBYLChdsOBra+MeOHAA/oKAk04XJkgyMrrdMDMMevACihgMMDMMvuzaFYcOHYJJo0ELlkOw2w+9BRG1kmj/i46ORsUSJZBXlpFBFNGzSxcAMS+LylKKww4XalAJQ31VJfPmzUNlX2XRD7IFlGHQluPxJZWQ1ulMUJbH6/UiIiICV65cgZVlcdLpxkKLApFlsXDhwkQrP0JDQ6EIAr6TZAykElhC4NBoIDIMeEaDEydOxK7NlyULpssWnHe64dFqsdZqQ1tBRIXy5fHDDz/gxYsXr3W/3xXnz59Hl3bt0KVDBxTIngMyx6Fbhw5JvkDYsWNHqk2n/xi4evUq0qdPD5ZlsXXr1tR2R0UlDh9xgvrRS/9mXv7f/1oXRQg5RAjZTwipnRzbavyt8q45fvw4fvnll3iVua+iaqnSmOgrtKlksWBuEtW0y5Yuhb/Nhsz+/ti9e/fbuvxaeL1ejBk5EiXy5EGvbt1SRDv5woULsAoCmloscLAsRIMBhxwuLFes8CQjAX/v3j3Mnj07znyTf5MlbVr0oxJGUwl2ShEWFpbo2ocPH2LBggWvlN24d+8edu/enexZJeWLFsVEScYNlwdFZBnDhw+Hi+cxUZJRjEoYMnBgsuy8zPXr1zFq1CjMmTMn0Zh448aNcPM8+goiHCyLUoUK4bOGDV/Zkami8iETGhqKOnXqgBCCLl26qPKuKu8NNUGtkmzOnTuHKVOmoHfv3mjoS4TNlBVUTkSnViVxZsyYkeA9bFKnDvq9pE08e/bsRG1YOB677A5cdLphS6A1D4hJclpFEdNlC2bKCmSOw4MHD9C2eXOkd7nQtnnzZCUIZ82ahRo+f6fKlld+5r/++iuKFSiAzAEBsYNSmogUQ4cOxeLFi/G///0PBw8ehJ1StKASMotiPJ2/KZMnw8NxKGwwwKPRYrnFCh0hcAoCRLMZA3v3TnDvhLT5apYrhx98VRTNWDZGU5thIGs0EPV6+JtM2GV3oAuV0KB69Vfej5fZvXs3MlGKyy4P5lkU5MmUCR3bt4dTo8EgkcLKMOA0GrgtFmRNmxYmQpBOp4NoNOLEiROIioqKo6n9MhEREdiwYQN27NgRmygNCwtDo5o1oQgCqpcrh8a16yC9y4UalSsjnShig9WOxmYzNITgmsuDGy4PJJMJd+7ciWP77NmzSO+JaUGsU6UKZJMJRx0u/KzY4Ge1JnnN169fh41lcd3lwRmnGxpC4NFqsd/uRA9BRK2KFWPX5suSBT/KCi443XBotShAJdhEERcuXHit+5wYwcHBbz185unTp3BZLOgpUqTT69GZF3DQV4GTmCTK/v37sWTJkjgvQlRen7/++gs5c+aEwWDAypUrU9sdFZVY/ssJakLIb4SQUwl81fp3QpoQ8jARGx7ff9MRQq4RQtInsq69L5F9yP9fkl4qKu+aY8eOoW2LFuj71Vd4/Phxous+b9wYrX2axlmT+Nue2oSFhaFL27YomC0bRgwdmmKVixcvXsSUKVOwa9cujBk5EkadDhLLol3r1qhQpAiGDR4cm4B98eIFvv/+ewz5+utkJVmjo6Oh1WhwwenGdZcHitmcKkPW/vjjDyiCABfHo1TBgggLC8OyZctQr0oVDP/660ST/YnF4CEhIfBYrfhMpMhPKbp16JDo3hs3bkSvnj2xbt26FLkWFZUPgejoaPTq1QuEEFSpUiXJ37EqKimFmqBWeW0OHjwIO8fhWyqhMKUYMmBAarv0nyOxe3j+/HmkdTrB6Q0oX6xYkhUIaR0OzJQV/GZzgJpM+Pvvv+OtCQsLg0GrxVmnGxecbnAGQ5yhhf8mNDQU8+fPx8qVK+MEbHfv3kWAy4ViihVWjsP69etx69YtbNy4EVevXsXWrVtx8uTJePZaf/YZ6vE8Lrk8qEIpypQogVyUopkkwa0oOHz4MMaNG4dVq1bFC8LzZsqElYoNwW4/FDEYMVyMGUL4tUhxwOFEgCAkWxpgxNChyMcLGE0liAyD/LlyoWSRIqjI8fiSF5HXYMBNlwfTZQtKFyiQLJterxfr16/HzJkzUadKVcgmE2SWxZYtW9C6aVOMojFazhWNJmT2SZPUpxSd27bFvn37cP/+fcz88UewBgN4kwmLFi5M1r4vM3zIEFSkErbbHChCKerUqAEHx8Gl18NPp0MRoxGVqYTCuXPHC8BrVayIQVTCRZcHQZKEZo0bxz6wbNiwIcl9IyIiEGC3I5tOj7RaLUwaDfKY2dh7WPKl38E7d+6ERRBg1uvRpG5drFy5Erdu3XrtawViZDn+/vtvREdHw+v14ov27SGZTBBNJsxN4mXOqzh58iQy+D6vEgYjJkoybro8KCVbsGjRonjrf5oxA26eR0VFQYDz9dqMVeITEhKCwoULQ6PRYE4ibcYqKu+b/3KCOqmv5Ep8/OucuYSQ+q9ap8bfKu+TBw8ewCaKGCBS1KE0zsvxf3Pnzh1ULF4cfoqCvj17Jpn4nTd3LsoVKoSu7dohNDQ0RXw9d+4cJkyY8MpuoSEDB6IclbBCsSGrSLF8+fIU2R+IiVv/ue6oqCgsXLgQWUURcywK8lOKyRMnAgA+a9gQJSlFK5HCz2bDkydPXmm7ZaNGyC1JKCrLKFukSKpJAjx58gSXLl1KNOn8MuHh4ahVsSI0vnk4/45Nt2/fjgJKTHHO7zYH0rtcidp6/vw51q9fH2/QpMqHR3R0NG7evJnkM7ZKXGbMmAGtVoucOXPixo0bqe2OykeOmqBWeSM2btyIzxo2xNhvv1VbPt6QjRs3okWDBhgzalScexgdHY1Hjx69MrjbtWsX0rlcsIkiZv74Y6LrvmjfHgGCiEBRRNsWLRJdFxkZiUK5cqGMbEFuKqHdv9Y+fPgQGzduxIULF3Ds2DFYBQElrVawWi2yixQOjsOP06fHrj927BhklkVarQ4MIQjKnBmZ/WIGPga7/VDMak2yXbBRzZpoxPGYY1HAMwz0hEBkGMyxKLju8iCLmcWmTZswZuRI1CpfHjN++CFBOz/NmIECWbMif/bsqFetGubMmQOv14v6VativCTHVvamY1lYOA6bNm1K1KeXGdinD7JQiioWCzL5++PixYuxWsSLFi1CGpZFX0GEkWFQx6f5PUykaFq3LgDg2bNnMOp0qG4yoQcvgDUYXvv/S53btkVfMWYwZFtBxNeDByMyMhLz5s3DuHHjMG7cOEyZMiVBjeSqpUtjtE9OJqfBgFJFiuDhw4fJCup//vlnpGdZuDQazJIVfE9lWM1mBIoiLBwX7wEsMjLyrXWar1y5gkCXC5LJhII5c+L48eOwsSzOOd3YarPDKopvbPv58+dI53ajuUgRxHHgdDoEiCIK5MiR4MNpoew5sESxItjth7KKOiQxJXj69CnKly8PQgi+++671HZHReVjTlD/719DEscmsEYmhBh9/7YSQi4SQrK9yrYaf6u8T/7880/k8HXH7bM74ZLlt7a5d+9euHkesy0KqlMJXdu1e2ubFy9ehFUQ8Jksw58XMHvWrETXNq5TB1VMJvQWRDQSBIwePfqt9weAdevWwSII4I1G/DBlCgBg4IAB6CaICHb74WuRomWTJqhaujQ4jQb77U4Eu/2QU7YkK+kaFRWF1atXY9myZQgPD8eTJ0/QsVUrlCtU+I0KMN4HM2fORElJwmWXBx0ojTd35a+//oJVEDBYpKhOJTSuXTtBO+Hh4cifPTsKWSzwEwSMS6HP7EPn8ePHyX4Z8KHw7NkzFChcDBy1wGJz4NixY6nt0n+GrVu3QhRFOJ3OJHXmVVTeFjVBraLykeP1evHnn39i3759SSa9L1y4AD9BwE2XByccLnBGY6Jrv+jYEb19QW1njkdXjsdqqw3ZAwJi14wfPx6tfHp/E6mE+lWrolGtWqhoZjGCSuB1uiSH9z148AANa9aEYjCAEAJJo4Gi0YAyDBwaDdyU4rvx45GHUkyTLUgviFi1alUcGwcPHoSL57FUsaI5lWKTwwCwefNmWDkOFaxWOGUZ69atw+3btxP1JyQkBL179kSHzz/HuXPnkMZqRRdOwExZQS5JipeU/eWXX9CrZ08sX74cgS4XclsssAoC/vzzTwDAqlWrIGs0GE0lZNHpYNRoEBERgZCQEJw+fRqRkZG4fv06zp8/n+jndvz4cYhmFmaGgY4Q9O/VC0sWL4ZoNoM3mTDH9xB05coVbNiwIY4cxeHDh2HhOJgZBgX0BlQTKXr36JHo9b/MrFmzUFAQEKDV4ozTjXGSjGJBQThx4kQ8rfS3xev1IioqCu1btkR3KuGmy4PqkoRhw4ZBMpux1+7EAosV/nb7W+1z+/ZtDB8+HJMnT8bt27exZs0anDp1KsG1Leo3QCNJwjyLAifH4+jRo2+1t0oM4eHhqFu3Lggh+Prrr9WhLCqpykecoFYIIdt8SeffCCEW3/fzE0Jm+v5dlBBykhBy3PffNsmxrcbfKu+Tp0+fIq3TiWaUojClSRZhJJe5c+eipq9qdrZFQblChd7a5rRp09DYJ5M3XbagWgJzVP6hSFAQShtNaGhmwWk0OHv27Fvv7/V6oQgCflFs2G13QjSZcP/+fRw5cgQKz6OBrzuyYqnSaE0llDIYUcFowpcihUOSkq0B/TLtWrRAbSphlqzAxfM4dOjQW19HSjN16lRU8XXM9aESWjZqFG/NwYMH0aZZMwzs2zfRavo//vgD2X12ttrsSOd0vmvXU50dO3bAwvNwcRzKFS36wcyTeRXz5s2DM0sBFBy8EWkrd0TVmgm/dFBJmFOnTiFt2rQwm83xnrlVVFIKNUGtovKJsWD+fBQPCkKL+g3iSBM8efIEVlHEaCqhK5WQP1u2RG2MHTMGJSnFZpsdufQGtON4dKMSKr2kTb1r1y64OB6jqYQ8lOJ/o0ejW+fOSKPTwa3RwK7TYcKECRg9YgRKBAVhYJ8+iVYQnzhxAhMmTIDMcWgqivBwHKZNmYLWTZtihE+aoYsgYsiQIXHOW7FiBcr4HjQWWqwokjNnnONnzpzBihUrEpRH+TflixZFQyrhK5HCKcvgdTrUM7PIoNPBzDAw6fTo0LYtvujYEd9NmBDnWp4+fYq9e/fG0YEePnw4OvuS/KOphGJ588YGfGkFERncbsgmE5wcl+RQSn+bDYssVhx0uGAxm8EaDNhqs2OHzQHeaMTmzZuhcBxKKFa4FSWOLuC4ceNQ21eBPYZKaFS9Oo4ePYoJEyYkKZ/y5MkTBGXODMVggIYQOGU5ySnhN2/exPbt2+O0iXq9Xpw9ezZJncJTp07B5ecPjUaL7Jkyo61Icc3lQXlJwpQpUzBpwgTwRiOcsoxt27Ylaud16dymDVwcDzvLYWgCQ3UePnyIVk2aoGTevFgwf37s94cOHAjBZEJGP78UrcoIDQ3Fzp07P4m2usjISHz++ecghKBbt27/qcoclY+LjzVB/S6/1Phb5X1z+/ZtjB49GjNnzkyRjs7bt2/DZbGgpqLAzfOYl8QwxeSyd+/e2GF9xamEwf36JbpWr9XiotONYLcfnByHK1eu4MmTJ5gwYQLGjx//RhqwXq8XvG/WykmnG9Rkwl9//QUgRnpk5syZOH78OCoWK4ZpsgUXnG5kMJtRqWxZnDlz5o2uuVju3Pic5VDPzCI3L2DJkiVvZOdd8uTJExTIkQNWloWfzYZz5869kZ0rV67AwrJYaLGiG5VQtnDhN/Zp/rx5kFgWEsvii65dce/evTe29S4pnT8/psoWXHd5kF+WsXr16tR2KVksXboUtnQ5kL//aqQp1Qx1GzRObZc+CG7cuIFK1WogKH9hrF27Nsm1f//9NwoVKgSGYTBu3Di1mEQlxVET1CoqnxDHjh2Dg+Mw36KgGZXQpE6dOMf//PNP1CxfHk3r1k0yGbZy5Upk9feHnyShYsmSyBEYiCqlSsU7Z/Xq1WhRvz4aNWiAQQMHonypUrBqNJhvUVDbbEagywV/nQ7zLAqCjEaMHjUq3l7Pnz9HkaAgpBVEyCyLjh07YuPGjQBiZFIcHIfPZAsUjouTJH306BE6t2sHi5lFcUmCk+MxNwl925UrV6JdixaYNXNmgn9sBZMJJ50uBLv94M9xyE9jhj+usdoQoNVirdUGEyHoI4goIor4smvXRPcCYiq4FbMZXUQKD8ehR48eKJwzJyZLFtx0eZBbr8dIUcIFpxuSwYjBgwfj4sWL8ey4ZAs2WO0463TDzrIw6HQ44HDisMMFVq9HvapVMdqXxG8iyZgwYULsuTdv3oRbUVDSaoXCcZg6dSoUjsPnsgWOBOROIiMjMfbbb/FZw4ZYu3Ytzpw5gwcPHiQZnGzfvh0WjkM+i4J0bjfu3r0Lr9eLzxo2hIvjIZvNmPb99wmeW6psBQRU7oT8/VZBdgUgo58fNAyDiiVK4Pnz50ne3zfl/v37EAwGnHe6cczhgkGrS9ZD75EjR+DheRxwODGaSiiSO3eK+BMSEoLMadMijyXmZ/xV+pUfA9HR0ejRowcIIWjZsqUqI6WSKqgJajX+Vkk+165dw5o1axAcHJzarrw1t27dwty5c7Fv374UsTdr5kxkS5MGGZxO9O3VK9FhfQBQqkABNKQSOokUaZ1OhIWFoVjevKhGJVSnEooEBSUacwUHB6N/nz4YPmxYPN3oGT/8ANFkgmg0ov9XXyV4/j8FDUGyBVkDAxOdWRMWFoadO3cm2QXZomlTBOp0+B+VYdVqE5zn8SEQHR2NW7duvXUF8PLly1EgWzZUK1v2jYsJQkNDIZhM+M3mwFqrDUaGQaDLleTsoNSiapkyGEAlHHe4kIlS/Pbbb6ntUrKIjIxEvYaNodFokSFzNly9ejW1XfogKFi0BNKUbIJMjYaAE+VX/h5//vw5GjRoAEII2rdvn+TvNBWV10VNUKuofEKsWrUKpXwVxcsUKwpkzfraNg4ePAgHx+F/VEZxSjGgd+8k13/ZtSsKUIoOIoVkNiO/wYBgtx++ESVwWi3KGIy46fJgqEhRrnjxeOcvX74cxeSYpO1kyYLyRYrEOb5v3z5MnjwZJ06ciPP9ulWqoB6VMECgEEymJCtsN2/eDA/PYwSVkEUUMfOnnwDE6AYuXrwYly5dQsMaNVCKSmhMJQS6XLCwLMZSGRVMJlQxmfCtKKGw79pWW23IlyVLovtt2LABEsvCZmYR4PHAbbWinKLAotOhuyDikMOFNDodvuQFbLLaYWIYNBIprIIQL5hasnhx7ENH47p1kTVtAEwaDTiDAaNHjEDvHj1Qg0pYb7UjG6Xx9JLv3buH9evX4/Lly3H0CIeJ8fX4hg4ahMKU4lsqwc5xyWrZrF2xIsb7pF5qyxZMnz4dFy5cgJPjcNHlwXabI1H96MLFSyFdrV4oMHA9bIHZsG7dugSDoIULFsDPakVmf3/s2bPnlT4lRWhoKKjZjJWKDXMtCqyimKzqgN27dyMzpbjq8mCxxYpc6dO/lR//MHfuXFS2xGhsfi9ZUKVkyRSx+6Hj9XoxbNgwEEJQu3ZtdZiNyntHTVCr8fenwOPHj7F37944EmCvy6FDh6DwPMpZbbAKIk6fPp2CHv63OXToEFw8jyWKFc2ohGb16iW5PiQkBP169UL3zp1x9epVPH36FCadDjdcHtxwecDq9QkmLF+8eIF0bjfaiBQ1RIqKCcTTISEhr+wYvHHjBnbt2oVnz54lePz58+fIly0bcskyFJbFksWLE1z38rDwrgl0OKqIsyGXAACc90lEQVTE5+HDh+AMBpxwuHDA4YSREBS2WLB58+bUdi0e58+fR4706cEaDOjeseN/ropW7c6Li83pQa5OP6Lg4E1Q/NLHylEmRXR0NPr37w9CCCpUqPBBvkhR+W+iJqhVVFKZCxcuoEu7dujXq9cb6by9Dg8fPkR6jwflfK2LLw81TC4//fQTGviS3LNkBRWLFUtyfY6AAGyyxgxGLKEosFKKIqIIM8OgOy8gvVaHnDodeIbB0KFD452/efNmZKEUhxwu9KAS6lWpkiw/A+wxMhfBbj/ktSjYvXt3omuHDBmCL3yJ2W+phNZNm+LgwYNQeB7VFStksxlr165FtcqVodNo4GezYcqUKWhYrTqqV6oEg0YTO8TxC15AbjOLvj174urVq8iVMSOMOh1aN20aGxAVzJYNcy0KLjjdUHQ6cIQgo1aHgnoDZIMBEsuiYe06SOdyQdDp0IHjEez2Qx3FirkJtJs+fvwY169fh41STJBk9BVF+DscAGISri0bNkTOdOnwdf/+CQaRly5dwtSpU/HNN98gvSDge8mCXCLFD9OmxVlXuUQJzJRjPvtGioLp06fD6/Vi48aNmDVrFkJCQuLZ7tS6NRpTCb/aHEir0yHQ7cZvv/0GyWzGVpsdP8gWZPB4Evxc9u3bByorMPMiKlSummAl7b1790BNJmyw2jFdtiCt77rfhlWrViHQ6UQmvzTYvn17vOOnT5/G1q1b4zzARUVFoXalSnByHCSWfWWLXHLZtGkTMokUv9oc+IxKaNWkSYrY/a8wadIkEEJQrly5tx60qaLyOqgJajX+/ti5fv06/Gw25LZYYKcUJ0+efCM7Xdq1Qz9fDNVFEDEgCQmLT434UnO5XnnOs2fPcOLECTx9+hRerxdZAwPRjlJ0oBRZAgISjOMuX74Mj28g9wWnGwad7l1cDjZs2ICCvqKRJYo10WKMlStXws3z6EAprByXYtXoHztDBgwAq9WCZRjUN7OwclySleoqKinB8G9GQLJ74MiYB7ny5HutjoJZs2ZBp9Mhe/bsakW6SoqgJqhVVFKR0NBQuBUF3UWKepSiwksVD7du3cLx48cRFRUV+73J332HTB4Pyhct+sYtZCEhIVi2bFmy3o4mxKVLl2AVBLSSJAQKAqb5poEnRoeWLVGGSugvUig8j+PHj6Njx46o7Zu8Pt+iQGAYVKtQIc61/oPX60XPLl0gsSwKZM+Oa9euJcvP7h07IohSNJRkpHU647U7vszu3btBTSYUMxjhMJuxbNky9OjaNXYQ5JeCCB0hoIwGhx0uTJJk+FksuHDhAoAYzcI8WbNCyzBIY7dj4sSJiIqKQsMaNdCTSjjtdCNIkmIHSpQvUhRfUwlf8AIyaLRgSUxiu48gghqNcRKxvbt3RykqYZwkw85xOHLkSOyxZ8+eoXObNsjsdoPV68FpNNhgteOC0w2tRhPnfnq9Xjx69AjR0dG4d+8eduzYgU5t2sAty6A6HepIEtw8j7atWqFu5cqY8L//xaswmPr998ggimjv+yzPnz+PXt26wWEwQE8ITBpNPFmQkJAQVCpVCoJGg2Ysi29FijyZM2Pmjz/CIUnI6OeXpN51WFgY/v7770SrM65evQory+Kiy4O9didEszlRWynBnNmzYec45JMtCMqcJU6S2uv14tKlS3G03d8Wr9eLr/v3R3qXC9XKlv1g9QjfJfPmzYNWq0WhQoVS9N6qqCSFmqBW4++PnWHDhqGVGCNX1kek6NS6Tbw1oaGhmDNnDpYuXZpgjAYAY0ePRglKscZqQ35K8eOPP75r1/8zhISEIL3HgzJKzLDApKTmgBiZjgCnCxmoBLei4MKFCwgODsYXHTqga/v2ibbev1xBXfNfzxMpyeHDh+HmeWy02vEFlVCtbNlE127btg2jRo3CgQMH3okvHwKhoaE4ceJEogMU34SzZ8+iRcOGqFKyJDZs2JBidlVUkuKPP/7AqlWrEu2eSIpt27ZBkiTY7Xbs37//HXin8imhJqhVVN6SZ8+eYe3atW/0C/nUqVMIFGOSoCedbggmE4AY2QaZZREgiKhUsiQiIyNx5MgRuHgeG6x2dHtFUJgcNm7ciLR2O9LYbK89iffcuXP43//+hw0bNmDjxo2wSxIklsXMBB5KwsPDMWrECHRq0yZWI/r06dNQOA4DBIr8lOLrAQPe6loSIjo6GosWLcKECRNih8EAwLBBg8AZjUjv9sQme5csXgyXmUUrQYBkMuHo0aOYMmUKglgOyxQrsuh0KGYwwK7R4LLLg2WKFQ6NBk5ZjlP1/m8Zguply2I0lXDD5UFJ2RKrwXfu3DnkypgRZq0OBkKgJQTzLQq+ozJ4vT5Oq+2LFy8wZOBANKpeHevWrYtjv0fnzqgiilhgscJPq0V7joOi1SH7vyptw8LCULFECZh1eiiiCInjkI7nkV6nwy67A43MLFqyHKbKFtQsVy7J+7p69WqMGDEiVlJFEQS4NVqcdbox16Igg9sd75wjR44gUBRx1eXBZpsd/jZbknv8m0ePHmHJkiUJatx5vV60atIEHp6HwrKYMHbsa9l+XfJmyoTlihU3XR4UlC2xeugq75ZVq1bBYDAgR44cuH37dmq7o/IJoCao1fj7Y2fatGkoRin22J2oTiV8/a+hwFFRUSgSFIQysox8koTm9esnaCciIgJftG+PPBkzok+PHokmsj9VHj58iJUrV8YpMEiMoUOHoqXvpUF3keKLjh1fec69e/cQHh6O4OBg9OvdO0EN6tdh/fr1aN+yJab/8EOCxQGTJkxAxrcslnkZr9eLUcOHI2+mTGjVpEmKJnvfJVevXoWfzYaMkoQ0dnuyC2hUVD5Gzp49i8DAQJhMJvz888+p7Y7Kfxg1Qa2i8haEh4cjf/bsKGyxII0gYGwCQ/4SY9nSpRBMJrAMg8a8gLJUQr2qVQEA2dKmxc+KDdddHmSlEnbt2oWNGzeigK+tbqliRd7Mmd/Y76ioKEgsi2WKFasUG0SzGeHh4a9tx+v1QhEErFBs2G5zQDSZcOfOnWSdu3v3bjRr2BDDhgyJfZgJCQnB+vXrYyuTU5pjx47BxfE46HBhnCSjYPbsAIDGtWphgk8nuY0kY8yYMYiKikK9GjVg0+lgIgQ5dToUNRhAGQYCw8Bfq4XdZIqj6RwdHY19+/bFJm8PHDgAG6VwchyK58sXb7DfkSNHoCcE6bVaeLRaFDMYIRmNiQbn0dHROHbsWGwQXLVUKfzgq0SvYzKjPccjwGbDxo0b41Q/z5s3D9k5HopGgzx6AwSGwUBBRFWTGcFuP4wSKQK0WvgbDGj+mhIS+bJnh12jwVmnG/MsCjKnSZOg37UqVUKAIEJhWUyfNg3BwcHJaiELDQ1FZv+0KGIywarRIJ3bHU/nzOv14tSpU7hy5cpr+f4mVC9XDp2ohFWKDU6Ow/Hjx+P5cvz4cRw7duw/p8n3ofPbb7+B4zikT5/+vXzWKp82aoJajb8/diIiItCmWTP4KQoaVK8eL/a4evUqnByHGy4Pzjnd0Gu16t+1d8zEiRNRlko45nChFqUY1L9/omujoqLQqFYtCEYjLDyPXbt2vfX+u3btgpPjMFyUkEOkmDxx4lvbfBVr165FZlHEaqsNNaiEr7744p3vmRJ06dQJ6XU6eLRa5DUY0bdXr9R2SUUlVbl79y6KFCkCQghGjx6t/r1QeSPUBLWKyluwZ88eZJdl3HR5sNVmR2Ay9W+jo6MhmEzYYrNjjWKDQavF2LFjYytwiwUFYSiVsMPmgIvjcfLkSTx//hz5s2dHLlmGleWwaOFCXLlyBTdv3nxtv8PDw2HU6XDc4cIpZ4w8xOPHj+Oti4qKwuRJk/BFx47Yv38/Dhw4gBUrVsQmCL1eL1iDAXvtTpxyumFiGGgYBrUrVXpl8rF9y5ZwcTwUsxljRo7E33//DX+HA8UVK6wc99aVqTt27MDChQsxasQIVCpWDMO//hq7d+9GRkpxxZfkzx4QAAAYN2YM8vr0m/14PrZSNzo6Gr26dYNdECAwDPpxPCwaDcZQCd+IFCLDwCoIuHHjBrxeL+pXr44MIoWL5/GNbyBMaGgoLl++jNDQUCyYPx/Vy5TBgN69Y+9P/Vq1wDEMfvXpZeeWZUyfPh0D+vfH0qVLY/+4R0dHo06VKkgrCLCYWcz44QcsX74cDp5HWZaFmWHA6fVYsmRJvHsxb948uPV6TJFiktlljUa0YjkIDIMArQ5mhkE2nR5DxBitwH8nXZMiODgY2QMDoWcYiCZTopO8o6OjcfToUZw8eRJF8+SBYjbDrSivHKa0bds2ZGc5BLv9sMlqh1WjxbAEtMrfF7du3ULVMmWQMzAQM374Id7xL7t2hYfn4ccL6NahQyp4+HGzf/9+yLIMt9utDuJSeaeoCWo1/v7UefbsGeyShG+ohG5UQtBbFEaoJI+wsDA0qF4dMsehapkyiVZCR0dHY+nSpcgiUlx2efCDbEHhXK/Wt34VY8eORVtfwcZESUbjGjXe2uarmDx5MhrKMXuOl+Rkz5pJbQoHBaEJy2Gn3YF0Oh1aNG+eovajoqIwaeJEdO3QQZVNUPnPEBYWhsaNG4MQgjZt2iQ43F5FJSnUBLWKyltw7do1KCyH+RYF3aiEsoULxzm+aOFC2CmFn9UaZwpzVFQUzHo9/rA7cdThAm8wxJGKOHPmDPJkzgyHJGGc7w3kgQMHsG3bNvz++++4ePEienbuDCvLQjKZMG706GT7/Pvvv2OSL+lsZVnY2JiBfgkxsHdvFKQU/XzayHaWRRlFQcY0aWIT2lMmTYJoMoHTalHYaMQVlwdFJBnz588HADx9+hR79+6NU1l969YtSCYTLjjdOOBwwqzXY8aMGahtiUmgTpYsqF6mTLKv6d+MGz0aAYKAXByPNDodZskKClCK8f/7H6qUKQOb2QzJbMbq1asBxAT648aMQeNatRJM8ALAzp07kcXfHwbC4IrLg0suD/SEoJrFgvnz5+PKlStwcByuuDwx07c1GjglCW0/+wy5M2WClmGgaHX4QbagFJUwoHfvWNvlixXD5yLFNNkC2edbd0FEJkHE977qlWPHjsGf5zFTtmAclWDzaTm7FQXZM2VCWpZFkE938N9vrMPDw5He6URdM4v1Vjs8Wi2MDAOXKGKoSFHUYMAcS8wQnwaKFTNnzsTvv/+OBQsWJDj4MCFCQ0MTHGL4D4cOHYK/3Q4tw6CkryJrIJXQpE6dJO1evnwZol6Pn2QFrVgO6XQ6DP5XG/KHwvPnz2HU6XDG6cZZpxtmvf6t2mxVEubEiRNwOp1QFOWj1rZUSV3UBLUaf6sAR48eRb0qVdC8Xn1cv349td1JEK/XG09i7WMmNDQURfPkgWw0gmUYrLfaME6SUSJv3re2ffDgQVg5Dt0FEYGCgNmzZqWAx0kTHBwMt6KgjK9AZcuWLe98z5SgepkyGO9L5ldgWUydOjVF7ffv1QuFfM9gCse9s+5SFZWUJjo6GoMGDQIhBGXLlo2T41BReRVqglpF5S1ZsWIFCufIgRrly8fRYnvy5AlEkwmbrHYsU6ywCEKcxOH0qVPBG43gDQaMfEVF6JdduyKtICAjpWhWrx7u3r0LwWjEGV+C16TXxxtolxAL5s+HH8+juWyB4qsUTmo6dPGgICxVrAh2+6Gc2YxuvgnhOUQRjRs3xq+//gogpqWnZsWKGOjTWy4jy5g9ezbu3LmDdG43clli9psxYwYqFS+BWhUrQjAasdZqw3c0ZkifQatFGoMBa6w21BVEVChZErdu3XrlNf3DD1OnIo3VirxZsiCTx4O1Vht68AI6cTyC3X4YJlLkypgRDpYFNRox7Ouvk237H7xeL+pUqYLsZjMy6nQoZDDAwfM4evQoHjx4AGo2Y5lixXhJhqLRYIokw8ww0BGCSkYj6ppZBLv98INsQY2XNMTv3LmDzxo2RMVixdC5c2c0syi46fLgB0mOTdRfvnwZgkaLPHo90mi14DUajJNkrFGs0BCCM043rrs8sLFsgg+RISEhUIxGpNfq0E8Qkd9iQbF8+dGZSmjL8Uir1aGrIELhefTu2ROBgoBKlpiXEYklWY8fP448mTPD32bDj9OnJ3nvCufMiQmSjJGUIrdej0suD7pQCZ83bvzK+z537lzYjCaIWi0ypU2bbBmZ901UVBQsPI95FgXzLQpkjlMrB94Rly5dQmBgIHiex/bt21PbHZWPEDVBrcbfKvE5cOAA6lSqhM8aNkx0YN/75OLFi0jv8UCv1aJ2pUqfxN/cmTNnopwkx7zoFyk4RgOP1Ro75yUxoqKisHDhQnz33Xf4+++/E123b98+DBo0KLaI431w7949rFmz5j+VhN25cycUnkdOWUYmf/8UH+JcLHduLPM9g1W32rB48eIUtf8qLl26hD///DPJ4hMVlaSYO3cu9Ho9smTJgsuXL6e2Oyr/EdQEtYrKSwwbNAi80YgMHj8cPXr0rWzdu3cPgsGI0043DjpcsUnkkydPonSBAiiQNStWrlz5ygrVqKgo6LVanHK6ccnlATWZcPHiRYgmEzbb7FiqWGEVBCxcuBBlCxZC+5YtE5TrAICa5cphmk+zuKnFgu+//z7JvYcOHIggkaKHIILTalGV49FPECEyGnwhiHBxfOzgvjNnzsDPZgM1mVCqYEE8f/4ckydPRj1fdcEIKkHS6fCdJKMnlZDR40Eamw02jkNLQcQphwuBJhNcogiLXo+qkgyXxZKsgWiXLl2ClWWx1WbHKCrDyQtoQSUMFijMDIMGsgVWlgWn1+N8bNW2Ic4LA6/Xi7Vr12Lq1KlJ7hkZGYkVK1agYd26qFOpEtasWQMgpko5V+bMEDUaiAyDL3geAVod5lkUHHG4IDMamAlBPUGEh+exwFdh/g/79u1DRj8/KDwPTquFmTAwEAaN6tUDEDNY0mUy4cY/FdoMg512B664POA1GgykEiZKMhRBSFTDulHNmqhJJQwVKRSex5EjR1C5ZElk9vNDyxYtMHDAABw5cgTZ0qbFBqsdwW4/FLRYsHXr1ni2vF4vcmXIgNFUwmabHQrL4urVq4netzyZMmGeRcE5pxsKowFDCBSzOdkDdqKiovD3339/8MOXtm3bhmwBAciaNm2C900l5QgODka2bNlgNBqxdu3a1HZH5SNDTVCr8bdKXB4/fgybKOJbKqEjlVAkd+7UdgmNa9VCXyrhisuDwpL83pN4qcGCBQtQWJJwyeXBF1RCiwYNkqX12rVde+SlEhpKMgJdLjx9+vQ9ePtxc/v2bezduxfPnj1LcdtDBgxAEKXo7iseeZ8Jvp9mzICVZZGRUlQsUUJNUqu8MTt27IAsy7DZbNi7d29qu6PyH0BNUKuo+Dh27BjcPI8DDifGUhmFcuR8a5u9vvgCVpaFbDbjf99+CwDI7O+PEVTCHIsCiWXjDXz7N16vF25FwSRJxhxfVebz58+xcMEC2ClFGpsNU6dOhZPjMUtWUJdKaNOsWYK2vh4wAMWphMmSBe5kDFSJjo7GpEmTYBVFpOV5cDod7FRCb0FEsNsPX4sUXdq1i10fERGBu3fvxgbKS5YsQRCl2GV3oKFIIev1uOHy4JjDBd5oBAB81rAhBlAJN10e1JAkZEiTBvN8chPVFAULFixI9L4cOnQIx48fx8GDB5FOFHHN5cFGqx1pbDa0bNgQZQsWwpQpU/Djjz9i586dEE0mbLDaMc+iwCHLceyNGDoUmUUR9WUL0tjtr10J8csvv6CgLOO6y4MevADOV+W8xmrDOacblGFgIAT9+/dP8L5nSpMGU2ULNlvt0BOCX20O/G5zgDMY8O2oUWjVogWo2YyfZAX9qIRAuwM2lkWgKKJiqVKoVqYMyhYujD179iTq49OnT9H3q6/weaNGSUoj1KlUCS2ohOmyBVaOi1dlHxYWhgrFi4NlGGyx2XHV5UGgKCY5oX7z5s0xUjAMg5omM1ZaFGT190/Gnf348Xq9+OqLL+CUJJQrUiTJyiaVuNy/fx8FChSAVqvFwoULU9sdlY8INUGtxt8qcTlz5gz8BQE3fXGcaDantktoUK0aBlMJ110eFJflRGPGj4mIiAjUr14dWo0GOTNkSLb0ip+iYLfdiWC3H3JZLNi3b9879jR53Lt3L1nFKG/K+vXrkT9rVpQrXATnzp17Z/ukNNHR0Zg1axb69u6NY8eOvde90zmd2GC147rLg0yUqhrYKm/F+fPnkSFDBhiNRixdujS13VH5wFET1CoqPvbs2YNMlOKqb4BejsDAFLH770GGnNGIIw4Xrrk8cLBsst6IHzhwAIVy5ECeTJliZTVeZtmyZajoawNbZLGiaCKDUiIiIjB00CDUqVQJixctSpb/gwcPRkWfNMUoKqFovnxIy/MYRSWkFwT8b+xYzJw5EydOnIh3bnR0NLp16AA/RUH1cuVQMGdOFJctyE4purZrDwA4deoUnLIMP0FAzgwZ0bpZM9SQJPwkK3DxfGwi9fDhw1i2bBnu3bsHAGjbogXSCgLcPI8+PXuiWtmyCBRFWMwsZv74Y4LXsmjhQrhkCwKdTvz+++94+vQpTp06hYMHD8JmMmGt1YZgtx9KKFZs2LAh9rw///wTkydPTjRA3LNnD9q1a4cAnsdJpxv9qYSKJUqgaMGCMDMMBIZBPr0BNlFMtArBIUn4zebAaacbOkJwwOHEIYcLel9i20AIWJ0OBbJlQ9UyZXDp0iVcvHgRhw4dipV32bNnDyZPnowzZ84k67NNjHv37uHzxo1RrnDhBCtT586dixKSjNFUgsgwcBkMqFmhwitlZu7du4fcmTMjryTByXH4IYX1+t4VISEhaFijBnIEBGD0iBEpbn/NmjXIRin22J1ok0zZE5X/58mTJyhTpgwYhklxDUiVTxc1Qa3G3ypxiYiIQL5s2VBBlhFEJbT77LPUdgmnT5+Gn80GwWBA+WLFEB4entouvTeSI+33MjXLV0ADKmG4KMEqCLh79+478iz5TPv+e4hGI6jJlOg8nH+IiIjAkiVLsGDBgmRrjt+9excyy2KeRcFgKiF3xowp4fZHT6GcOTGUSthotcPKsrh48WJqu6TyH+fevXsoXrw4CCEYMWJEsro+VD5N1AS1ioqP6Oho1K1aFQ6Wg2Q2x0o3vC2RkZFo06wZFEFAxeLF0b1TJ6QVBOSQJFQrWzZFfkHfvXsXaex2VLUo8OOFV+oBvw5pXS5k0+mx3+5EE5ZFi4YNsXjxYrRp1gzDhg6FheXQwDfY5Ndff8WNGzcSlWF4/vw5li5dig0bNsS57mfPnuHChQuIiIjA1O+/RxqLgnRWK2b+9BMAYP68eXDxPCooVvg7HDh//jwEgwEXnW6cdLph0GoRHh6Ow4cPJyoz8fjxY9y/fz/2f69atQqcTgenTgdOo0FunR41TGZ8J8lxqoa3bt0KO8fhM9kChePiVRFs2rQJDo5Da0mGqNdDr9Uie7p0uHDhAiZNnIi8goifZAtysCwmTpyIyMhI/P333/EeLGb88AMksxkujke2dOlh0mhg1mphYhist9pxzOECxzCYnshn+8svv8D1kr54Qi8MUor58+ejqCThqsuDDoKASmXKJPtB6fnz59iyZQuOHz/+zvxLadq1aIHGVMI6qx3pRDHBl0Rvw5w5c1BRtuCmy4MJkozqL+mTqySPsLAw1KxZE4QQjBw5Ug18Vd4aNUGtxt8q8Xny5Almz56Nn3/+OVl/95cvWwYLz8PC81iayBDqtyUyMhL3799Xf++/gocPH6JH585oWrfuBzFg2Ov1gjMa8YfdiVNON0SjMckOsrpVqqCQJKO4LKN8sWLJ+rxPnz6NNIKA6y4P9tudkDkuJS8h2Tx58gRr165975XQb8rZs2dRKGdOBDocKfpMqfJpEx4ejubNm4MQgpYtW+LFixep7ZLKB4iaoFZReQmv14vLly+/Uhf6dZg7dy4KUgkHHS40pRK6deiAffv24ddff31rTS+v14uNGzfi559/xvXr1zF//vwkJR4A4Ny5cxg9ejRWrVqVrODOKUmoazbDptFA1umwY8eO2GNf9eyJFiyHKy4POnI8qMkEO8uiQI4cCQ7W83q92Lp1K5YuXZqgTvL+/fvh5nkstljRkEpo3bQpAKBk3ryY65P9qKwomDNnDiSWxSKLFTNkC+ySlOS1zJk1C4LRCMFoxMDevQEANo5DT9/Qx/pmFm1YDq05DpJWG0fDsGOrVhgiUgS7/dBdEDGgf/84tjt8/jmGvnR84IABAGIqvjO6PZCNRmRyufB1//44ceIE0tjtkE1mFMiRI55WeHBwMHbs2AELx2GoSFFLECFqNFhnteOowwUzwyTaZte0Th2MpTF6322ohNGjRyd6P96WFy9eoHq5cjBotUjndn/0lRWVS5TAVJ92ezWLBbNnz05R+48ePUKODBmQRZKg8Dx27tyZovY/FSIiImID3169eqnJCpW3Qk1Qq/G3ytsREREB3mjERqsdm2128EbjJ1XhrJI0Xq8XiiBghWLDTrsDosmU6PPXixcvoNNocMXlwXWXB4LRGNtRmRRRUVEoX6wYcksy/AUBQ3wx+vvkyZMnyBIQgGKKAifHYfasWe/dBxWVDwWv14uhQ4eCEIJSpUql+HBRlf8+ScXfGqKi8onBMAxJly4dkWU5xWw+fPiQpGEY4tJqSQYQ8vBBCClcuDApX7480el0b2X7i/btSa8mTch37duT5vXqkcaNG5OiRYsmuv78+fOkWP785OK3o0mfli3JpAkTXrlH30GDyB6NhsiCQIqUKEGKFy9OCCHk7NmzZO5PP5HN4eGk1N2/yS8vwokrKoow4eEk5MJFMn/+/Hi2BvTuTbo2aEB+6NyZlCpYkERERMQ5fuXKFZLTaCIlTSZSVsOQ33/7jbRu2pTIDgdZFx1NdoSHkxMvXpCsWbOSxStWkBECR6YqFrJy3TrCMEyi19Dziy/IalEie2WFTP3+e3L79m0SGh5ObkRHkZDoaHIzOor8EhVJDur1pFT58qRx48ax5+YuUICsIoSsDXtONhJCcgcFxbGdt3BhsoIQsvL5M7KegOTNl48AIJVKlCBlHz8mn+sN5OZff5FDhw+T4rmDyN27d0l1jYbYb9wks2fPjmPLYrEQr9dLAo0m0oDlSGejiYiUkgYh90mRO38TSRQJx3EJXmPuAgXISuIla8Oek23eaJIrV67EP9S3xGAwkHW//UYePnlCLgUHkwwZMryzvT4EuvbtS4ZEvCANX4SRMyYTqVGjRorap5SSgydPkgW//krOXrlCSpYsmaL2PxX0ej2ZN28e6dq1Kxk3bhxp3749iY6OTm23VFRUVD5JoqOjSVS0lzi1WuLQaEm016v+Tv5A2bVrF+ncpi2ZPGlS7Gd07949Ur9aNZIvSxby04wZKb4nwzDkh1mzSMvHD0n5u3dJrpw5iSAICa7V6/UkrctFZjx/RmY9f0ZEQSCU0lfuodVqycbt28nYZUvJ8l9/JUNHjkzpy3gl27dvJ8rTp2SZ0Uwmmcxk6v/+9959UFH5UGAYhgwZMoQsXLiQ7Nu3jxQpUoRcunQptd1S+a+QWOb6Q/9SKzhUkuLu3buoX60a8mXJgp9mzHjn+927dw+Z/P2RSZJgE0UcPXo0xWyzBgOOO1zYZ3dA0GigZRg0rFkTERER8dZu374dnNGI8kYTgt1+mG9RUDp//mTtc+bMGezduzeOdEebZs3Q11c5XINloXAc6plZ7LU7kU2vR7uXhif+g0OSsMfuxE2XBxkpxeHDh+Mcv3PnDhSOg0ung6jRoCYvYLBIYRUENKlbF0Vz5Y6V/fjrr79QMn9+yByHTq1bJ9hqeurUKcyePRuKIGC11YY/7U6IJhPu3LmDPj17QtJqYWQYBNrt2Lp1K7Zs2RKvqj06OhrjxoxBrfLlMW3KlHhVmV6vF5MmTECDatVif57Cw8OhIQTXXB7ccHlgZhjkNRjwvWSBW6OFwmhQmBcwZcoUAMDVq1eR3hVTIe1nt0M2GmFkGJgZBjWrVYOD47DL7sBIKqFwzv/XF9+5cycWL16MR48eISoqCiOGDkWt8uUxa+bMZH2unxpRUVHYvn37G7W2Xrx4EZs2bXrlUFOV1Mfr9WLQoEEghKBBgwZqC6HKG0HUCmo1/lZ5a7795huIJhNEowkjhw5NbXdUEuDkyZNQOA6DRYr8lMZWGTesUQOtqITlihUuno8Xs6cEvbp3R31KccDhRBEq4SdfjJ8QFy9eRKOaNVG/alWcOnUqxX15Vxw9ehROjsMyxYrWVEL9atVS2yWVD5SjR4+ieJ48yJslC7Zs2ZLa7rxzdu3aBUVRoCgKdu/endruqHwgJBV/p3qg+6ZfaoCskhQNa9TA55TGBFwcjyNHjrzzPZ8/f46jR4/i4cOHKWo3d6ZM6E0lFDYY0IUXcNHlQWFJxsKFC+OtLZA1G74WKKwaDUZTCcUEAX169Hjjvbt36oRmlOKk040SkoQCOXJgmC9hXZPlMG7cuHjnlMiXD12ohKmyBRaOw507d+Ic//7771FAFLFMsUJgNPjDN208t8WCvXv3xlnbqkkTtBUpDjlcCKISfv755zjHd+3aBSvHoa5ihWAyQTSZYNbrMWnChNg1R44cwe7duxPVzH4bcqRPj8IGA0objaAaDaZIMRIRTVkWRkJQPH9+PH/+HACQwe3B5yyHXrwAkWGQ0WDEFZcH/6My8uXIgUyU4prLg5WKDVnSpAEAjB01CgGCgHIWBZnTpsXTp09T/BreJU+ePHntAT//cPv2bRTKmRMGnQ6Na9VO8IXMv/F6vahVqRKyUgoXy6FZo0ZqsvkjZ9y4cSCEoFKlSglKCqmoJIWaoFbjb5WU4e+//05SW/hT5Pjx4xg3bhy2b9+e2q5g9uzZqOsbtD7PoqBcoUIAgILZsmOJ7/slFAWrVq1K8b3bNG+O/qKEC0430uv1UFgWrZs2TVZclxKcPn0aHT7/HH2+/PKdxoSzZs5EvixZUL9atXjPPir/TaZPm4ZS+fKha7v2sc9zb0ugy4WxVMYciwKZZROUy/zYuHjxIjJlygSDwZBg/kLl0yOp+FuV+FD5KLl2+QqppNOTokYTyWA0kuvXr7/zPc1mMwkKCiKSJKWo3V82bSKXChcit3meWDRaYiSEcAwhL168iLdWq9cRi1ZDvqUSGff8GcneoCH5ZsyYN9578DffkFuZM5MiDx8Qd6lSZNKPP5Lv4SWVwp6RoxxLdm7aRDq1bk3u378fe87i1avJvZIlyC+ZM5Hla9YQu90ex+alc+dIGRBSzGgiGXQ60uXpY9LnWSh5pDeQHDlykLt375LSBQsSmePI7h07SDpCiEOjIQ6Nhjx+/DiOrSXz5pFOWh2ZbDSRVnoD6dy9O3kaFka69ewZuyZPnjykePHiRKvVvvF9+DfPnj0jY8aMIYxOTx4A5FJkFHnm9ZIhTx+Tno9CyC9hYaR1u3Zk98GDxGw2k4ULFpDLt2+RQVQi3QWRMISQCEJINCEkiiHEIookU/78pEToE9L2eSip16IF+euvv8ic6dPJVKOZzDOZifD0Kdm/f3+KXcO7ICwsjKxZs4Zs376d1KpYkTgUhQS4XOTMmTOvbWvYgAEk542b5ITVTq7v3EEWLVr0ynOuXbtG9u/+gwzT6Ul4WBg5tPIXkjtzFvL333+/yeWo/Af46quvyMyZM8mvv/5KKlWqRB49epTaLqmoqKh8cjgcDuJwOFLbjQ+GY8eOkbJFi5IzI0aSptVrkBUrVqSqP8WKFSM7X4STsU+fkLFRUaRizZqEEEK69OlNer4IJ41ehJF7gkDKli2bYns+fPiQ9OrenTx69IjM8EaREo9CSKBWS9bxIrmwYQP56aefXmnj1KlTZMyYMWTTpk1v5MOtW7dI4aAgIqz4hVyY8SNpXKvWG9lJDq3btCGHzp4lP69fH+/ZR+W/x/bt28m3ffuSNlevkUvLl5PBffu+tU0A5Pa9e6SyyURKGU1EA3wScWuGDBlipT6aN29Ohg0bRmJylCoqCZBY5vpD/1IrOFSSYu6cOXByPIopMZWn/x5U91/k5MmTcFkssLIsiubJk2C14IEDB+C0WKDXavFF+/bvZIDYvXv3sHnzZlg4DqOphOZUQuWSJZN9/oEDB6DwPKpbbTGDAocOxdixY3H79m0AMQMJP6cURx0u5BNE8CYT0okUuTNlivc5Tp40CfkpxTyLguyiiAULFqTotSZG1TJlUYVSNOM4yIwGlYwmnHS6UcBkQrWqVXH69OnYtXfu3AFvNMKu0aCA3oByRhNEnQ61KlWCXquFx2rFsWPHEB0djY0bN8IqiihmtULhedh4HgX0BvTiRVg5DpcuXXov1/cmREREoFCuXChiscBmMiMPy+Gqy4OvqYQ6lSq9tr3m9etjIJVw0+VBVUnG1KlTX3nOw4cPIbEsihoMGE0lBLv90FCSMWnSpDe5JJX/EMuXL4der0dQUJBauaSSbIhaQa3G3yoq74Bvv/0W7WhMx+FYKqNZ3bpvZe/Bgwf45ptvMHLkyCQ7NUNDQzF86FB81b07Ll++HOfYkSNHMKB/fyxYsCDO88Hx48exbt26FK/krFSiBBpSCX1FCjulqFO9Onr7ujBbiRRDhgxJ9NyTJ0+icK5coFotKnMcAgThjaTtWjRpgjRaLYLdfjjicEE0md7iilQ+JX744Qc0sMR0xk6VLahepkyK2O3TowfSCgKyUoq6Vat+UsO+X7x4gZYtW4IQgmbNmqkDdT9hkoq/3256m4rKB0rLzz8nefLmJdevXyelSpUioiimtkuvzdOnT0mzunXJnv37SYVy5ci8ZcvI1du3yf3794nL5SIaTfwGiAIFCpDb9++TqKgootfr34lfVquVyLJMXAYDaW7myLWoKNLw1Klkn1+gQAGy/+hRcvDgQTKpUCGSLl26OMcfP3pEshCGWDUa4tZqSeOvvyGVKlUimTNnJgaDIc7azl26kAd37pD527aRFjVqkGbNmqXINSYFAPLrrp2kidFEqpjNZHNYGOE1DJE1GpLHYCRytmwkW7Zs/389jx8TbVQUacVy5BFAZj8LJQePHSO5c+cm4eHhxGg0xg5/3Ld3L6lHCBlsMJFvwsLJgufPiMdkIrOfh5JqTZuS9OnTv/Pre1NOnjxJQq5fJ7+zPJkVFU1WhD1/K3v9hg4l5bdtI3OePiYOP79kfbaSJJFFP/9M2jdrRva8iCD5DJHkLLykvsv1Vr6ofPg0aNCAiKJI6tSpQ0qUKEF+/fVX4u/vn9puqaioqKh8guTJk4f84PWS7M+fkaXES5oVLvzGtgCQAjlykByPHpFoQsjy+fPJsXPnElzbrG5dEvXnARIAkJKLFpFzV68SnudjfcqTJ0+8c3LlyvVOhm4fOHKEbONFYtdqyS/PQknzVq1Ip927ydbw5+SB0UD2tG6d6Ll1q1Qhnz0NJW1EifR+9JAMoZSsWbKEtG7TJsH1kZGRpE2zZmT1unUkT44cZMXGjcRms5GIsDDyAiC9Hz0kl6MiSZYsWVL8OlU+TqpVq0aGDRhAOr4IJ4ciI8j3nTuniN3REyaQuo0bk7CwMFKiRInYZ8BPAYPBQObMmUMyZsxIBg0aRG7cuEFWrVpFFEVJbddUPiQSy1x/6F9qBYfKx87gAQNQk0o47HChDKUfVBXos2fPkDltWtSULchFKbp37PjWNqOionD//n306dMHZoaBU6dDxjRpEBIS8lp2rl69ig6ff45OrdsgODj4rf36N9OmTEFavR4DBAqJYcAbDHBQikBRhL/DgevXr8dZ7/V6IRmM+M3mwA2XB/5mMw4dOpSg7enTp6MwpdhqsyO9ToeaJjOC3X6YIVtQNFeuBM/5ULhx4wZ4oxFDBIquIoVLFGHW65HGbo9TUf46PH/+HJcvX4431PJVPH78GA2qV0cGtxt9e/b8pKoTPnX++OMPUEqRJk0anDt3LrXdUfnAIWoFtRp/q6i8IxbMn48G1aph7LffvvE8jqioKGzcuBEGwuCmbyi3lhA8e/YswfUyx+Gow4Vgtx8ySRKOHz/+NpcAr9f7xjNcmtevj2JUQiMqIYOfH8LCwvDgwQPs27fvlZ2tJr0eJxwuXHV5YGE0yCMI+CaJiuu5c+eisCThhMOFllRC5zZtAQD79u2DzLLwmFnIgoBr16690bWkJuvXr0fmNGmQM316/PHHH6ntDs6fP4/s6dLBrNejW4cOH3WMfevWLSxYsOCdDA/91Fm6dCmMRiMyZMiA8+fPp7Y7Ku+ZpOJvtYJaReUD5VFICAkEiEOrJWlBSMiDB6ntUiwsy5K9R46Q5cuXE6vVSurWrftW9m7cuEHKFStGbt25QxAVRSoaTeTPiBfk+bNnRJblZNuJjo4m5YoVI9WePScRBKTyzh3kxMWLhGEYsm7dOjLm66+J3eEgk2fOJH5+fm/k664tW0hPjif1WY785Y0iqyIjyZwlS0hAQAAJCAggZrM5znqGYciQUSNJ08GDiVWvJxmCgkju3LkTtN2mTRty+sgR0m3TJiJkzEh2nT9P1oY9JwvDnpMipUvHW3/8+HFy+PBhUrJkSZIhQ4Y3up6UwOv1ks6tWhGXXk8mPw8lnoAAsm/bNmKxWAjHcQlW+ycHs9kcr8I+OYiiSJavW/dGe6r8tylWrBjZsWMHqVSpEilRogTZsmVLghVjKioqKioq75LmLVqQ5i1avPH5Dx8+JGUKFyY3r18nBoaQQY8fkSgCwul08WLNfyhXujTpvfsPEkAICTMZ36rzbtu2baRxnTrkaVgYGTRwIBk0dOhrnT978WIyZ84c8vjxYzK5ZUtiMpmIyWQihZNRTd6lQwdSa/58YvJ6iWizkkbdu5Ov+vRJdP2TJ0+IncR0M/oD5OrjR4QQQgoXLkxOX7pELly4QIKCggil9LWuIbV59uwZad6wIZluZsmj0GekXo0a5K8HD1K16rZnx46k9oMQ0shiJfWXLCXb6tcn5cuXTzV/3iVut5s0b948td34KGnUqBHx9/cntWrVIoULFyarVq0ipUqVSm23VD4AmJgE9n+P/Pnz49ChQ6nthorKO+PChQukdJEiRPR6SbjJRPYcOkQ8Hk9qu0Xu3btHJk2YQAghpMdXXxGr1frWNju3aUuYFSuIDJCdL16QpVYb2f0inHR+/IiEREYm2879+/dJej8/ctpiJV5CSPo7f5Gnz56Re/fukaAsWch4k5kcjo4mp7JkJtvfcODgj9OnkxHdupEmJjOZ/SyUODmeDJ83l9SpUyfJ806dOkUePHhAihYtmmz5lf+NGUPWLl1KipQuTXr07k2WLl1KeJ4nn3/+Odm1axdpWrs2KWUyk+0vwsn2vXtJzpw53+ia3pZz586R8gUKkD0CJbejo0m1Z09JSGhoqviiokJIzO/PChUqkEePHpH169eTEiVKpLZLKh8gDMMcBpA/tf34L6HG3yoq74fvvvuO7Bw2nEw2s6Tc/bvkntdLojUaMnz0aNLzq68SPCcsLIxMmTKFPAoJIR06dXorqasMHg8ZGh5Bcuj1pMLTx2T/iRPvTWoOANm7dy95/vw5KVOmDNHpkq6pe/jwISlRoAB5du8eCdNoyNadO9+JbMn75u7duySjvz85LCskDCD5H9wjz8PDU3Tw++tSpkABUv/SFVLDbCb1wp+TwXPnkpq+oZsqKq/LlStXSLVq1cj/tXffYU1d/x/A3ycJkBA2gogLF+LEIop7K1r3rqPu2Wqtq2pbrataa+22tu5a966rzrrrpC7cVnEPEGSGkJDz+0O//mpVZAQu4/16Hp5qcnPOO9fbcPhw7jn//PMP5s+fjx49eigdibJASuNvzqAmygIGgwFd2rTBzr17Ub1yZaz74w+4uLik+BpfX19cDgvD9evXUbJkSej1+qwJmwIpJZrUro2y9x8AABpv2IC/L17M0G/y58+di53btqKexYKadlp8HxeL9QkJ2GBIQPlKldLUlru7O8r6+aH/9RswJJvhV6wYbG1tcffuXXjZ2qKRnRZFzGZsvnEj3Xn7DxyIW3fu4Nsvv4SjVgvnUiXRrFmzl467ceMGurRujX/CwjBg0CBMnTEjzedp9JgxGD1mDJKSkvBWmTIo8zgSjwD8uW0b9Ho9PtDYoLedFlNMJmzcuFGxArWbmxviky04lmTENbMZ3p75FclB9D++vr44dOgQGjdujODgYKxfvx5NmzZVOhYREVGqaLVaRANIEgI17fVIatIY02bOhI+Pz2tfo9PpMHr0aKv0bzKZ4KgS0AoBjRAwm81WaTc1hBCoWbNmqo93dXXF3xcu4Pr16yhYsCAcHR0zMV3W8fT0RIf27dFo82YkSYmPRoxQtDgNAJNmzULb5s0xNcaIcv7+HFtRhhQvXhxHjhxBhw4d0LNnT1y7dg2TJk3KU2tz04vSd981EaXJL7/8gvhjxxDi7gG3ixcx4/PPU/U6R0dH+Pv7p7o4ffbsWXRu2RI9O3fG7du3MxL5lWJjY3H5+nXM0Dtght4Bl69fR1wGZsru3LkTU0eNwkCDERsMCWgVGYGipUphTXEfqKpWgY9PMfw8Zw5Se6eHEALjJk/Gofg4HE1IQMStW5jx+ed46623oPP2RmejAX0SE9CqXXs0qFYN9atWxfHjx19q5969e/hg0CAMGTAAt27deqmPqVOn4ub9+9h9/Dj2HTsGrVb7UhvDBgxArVu3sVmnx8pffsGBAwdeOiY0NBQ9O3XG+/3649GjR699Xzdu3EB8RAS+0ztgjs4eW7ZvR5mKFbEVEnsSDdgHiTJlyqTqHGUGT09PzP9tCaY4OWKrjw9WbvpdsSzW8vjxYwTXrg1PZ2cM7tMHycnJSkeiNCpcuDAOHjyIMmXKoFWrVli9erXSkYiI8oSdO3eiXdOmGDFkSIbGiXlZ79694VS1Cso8vI9LRYvg29mzUyxOW9vXc+agR1wsqkZGoFP37vD19c2yvtPD1tYWfn5+uaY4/T/zly7F+n37sPPIEUyZMUPpOKhTpw7C7t3D4bNnsfPgwZc2sCdKKxcXF/zxxx/o27cvpkyZgm7duiExMVHpWKQQzqAmygJxcXHwlICTSgVvCcTFxFi9D4PBgCb16mGwRSICQKszjXHqNbt8pyQmJgZ79+5FkSJFXlq71dHREWVKlsSoe/cBAGVKlny+O3h6nD9/HnU0GtSztcNVkxahfqURHxODMxcuQGVMQkMnJ3z3xzZYkpPx3pAhqWpz1uefo5NOh2EOTugRGYFVy5dj3PjxOHDiBHbu3Al3d3d0btMWw5MtsBFAy+Bg3A0Pf377oJQSTevWRdCjcNgIgUbbt+NSWNhL6yi7u7unuOvwtcuX0UKlQiG1Gm54evvhv8XFxaFxnTroa5G4C6DD6VM48JrbpgsVKoQkjQY/xMfhDoDAihXx4ciRiHnyBL/t24dBHTqgffv2qTo/maV9+/aKZ7Cmz8aOg8e5UGzR2mPw+g1Y1agRunbtqnQsSiMPDw/8+eefaNmyJd555x1ER0ejf//+SsciIsq1rl69iq7t2uETG1vsO3oMQyMisGjlSqVj5TharRa/79wJKaUiswnbt2+Ppk2bIjExMcXxrjX9+eefWLtsOSpUDsDAQYPSvYdJbiKEQEBAgNIxXuDo6JjrfhFAyrKxscG8efNQqlQpjB07Fjdv3sTGjRvh4eGhdDTKYvzUJ8oC/fv3xwlnJ9SIjcF6O1sMHzPmpWPWrVuH+nXqoGOrVggNDU1zH48ePQKSktDXXo+hOnuEXr2a6pnH/xMbG4uqFStiVt++aF67DubPm/fC80II7Dx4EKWHDkHpoUOw8+DBDA2aW7Rogc1GIxo8eogQswnnTp9G74jHaKNSo6O9PXroHdBXY4sj+/enuk29TgcftQZuKhVcVWr4li8P4OnGjm3atEFgYCAeRz9BW3t7tNLZIz4+4YXZPYmJibh04wYm6B3wsb0eDx49wpMnT1LsMzIy8oVjHjx4gLD79zEqKhLVH97HlYSEl26Bu3v3LmzNZgyy12Okzh6nUvg31+v12HPoECJatkC+bl2x7o8/oNFoMHn6dOw6cgQfjhzJW6Gs7HH4I5SWQEGNBoWFQGRkpNKRKJ2cnZ2xfft2NGvWDAMGDMDMmTOVjkRElGtdvHgRFXQ6dLLXo6+NDc78/bfSkTIkOjoaXdq0QcXixfHF1KlpHltnVGaO74xGY4rvR6/XZ1lx+u+//8Y7rVrBY+1azP34Y8ycPj1L+qUXHTlyBD5eXnC2t8dXX3yR4rE5dS8zyp6EEBgzZgzWrl2Lv//+G9WqVcOldEy2oxxOSpkjvypXriyJchKj0SivXLkiExISpJRSRkVFyd5dusg6AQGyf+/eMr/GRr5jby+dhJDujo7yyZMn8ubNm3LHjh3y8ePHb2zfbDbLav7+spGrm6zq4iq7tG2b5oybNm2SNd3d5R3vQnK1ez4ZULp0mtv4r+joaBkfH//a53t27SpHOzrJO96FpKMQcr17PjnSwVHqhZDv6x2ku0olly9blur+QkJCpJveQRaws5OFPTzk1q1bZWhoqGxau7as4e8vd+3aJXt27izLOjvL8i4usnPr1i+1US8oSDZ1dpEtnV1kUMWK0mKxvLa/L6ZOlY52dtLRzk5+9/XXUkopr169Kp3UaukghHQRQjpqtS+85sGDBzKwXDmpE0I2tbeX1Z1dZLd27Z/n//HHH+Xp06dT/Z7J+k6cOCHzOTpKPxcXWbpoURkREaF0JMogo9EoO3fuLAHIcePGpfj/NeUNAE7KbDCmzUlfHH9TUlKS3Lx5s9y5c+crP0fDw8NlwXz5ZCdXN+nr5CSnTZ6sQErrGdynj+zo7CI35/OUJZ2c5Pbt25WOlGFGo1G2bNRIalQqWapwYfnPP/8oHUnOnj1bdnV7+jPIL65usnm9ekpHypPK+vjIOa5u8oinl8xnby+vXbv20jEPHjyQQRUqSLVKJdsEB8vExEQFklJudvToUenp6SldXFzknj17lI5DVpbS+JtLfBBlEVtbW5QqVer53z/oPwDGXbvQV63G8LNnMcPRGc10OphlJA6YzdiwYQNGDR2K0nZa3BTAsdOnUbBgwde2r1arsfvwYaxatQo6nQ4dO3ZMc8aiRYvin0QjDkJgp9mM4iVLpuu9/s+kTz/FzJkzoVKpMGfePHTr3v2lY8r5+2PTlq3QxsZCp9Gg6+MIVLa1g0VK/GJIwMhRo9DlDUsrRERE4LOxYxEZEYFR48fjxr27mDZ1KhbPno2PunXDA6MRg23tUESlRqc2bXD15k38/fffsFgsaNSo0Uvtbd69G/Pnz4fFYkG/fv1eO3slNjYWkydNwkG3fDBLibpjxqBp8+aoW706vITADi9vrElIwG/urujXvTvu3b6NYR9/jC3r16PCnbv4xdMLnWOeoHqrlliwYAH27duHDs2bo6FKjTEJ8ZAaDXwKFsTqzZtRrly59P0jvMHp06exadMmVKxYEW3atHnp+f379+Pw4cOoX78+qlevnikZsqPAwEBcDgtDWFgYypQpA51Op3QkyiBbW1ssW7YMzs7OmD59Op48eYIff/yRtxATEaWSlBKtmzTBozNnEG+xoH779vhpwYIXjsmXLx+OnzmDDRs24N2iRdG8eXOF0lrHrevX0VSo8JatLcpZkjO0x4vRaMSuXbvg5OSE2rVrK3b326pVqxB5MgRX8xfADzGxmPDRR1i6dq0iWf6nTp06mGBMhIfJhB0CGNyqlaJ5UiKlxP379+Hq6prrxofxCQkoqFYjn1oNrUqFhISEl46ZOmECyt66jaWeXuh37BgWL16MgQMHKpCWcqugoCAcO3YMzZs3R3BwMH755Rf06dNH6ViUFV5Xuc7uX5zBQTldULnycoV7PnnHu5AsodPJIK1WfuviKl1VKlnIw0N2btlSTnN2kXe8C8kuLi7y62ezczPb4kWLZJWyZWWnli3lo0ePpJRPZ5Nu2bJFJiQkyOvXr8vdu3fLmJiYFNu5d++edNZq5Zn8BeROD0/p5uDwyuPi4+NlkXz5ZHlbW1nQxkaWtdPKO96F5GxXN9msdm0ZExMjt23bJs+fP//8Nd989ZWsULy47NC8uYyIiJANq1eX7zq7yMlOLtLDyUlGRkZKbzc3uT2fp/zC2UXaAjIkfwF5s0BB6e3gIC9fvmyVcxUfHy8d7OzkPo/8cqeHp3Sws5M9OneWre31soLGRl4tUFBOdnaRRdzcZDdnF/mDi5t01+tll3bt5QhnF3m7QEHZysVFfvPNN1JKKd/r319+4uQs73gXkiMdnWQPe72c4uwi62TS59358+elu95BDnZ0kiUcHeWc2bNfeH7r1q3SS6+Xg5xdpIdeL/fv358pOYiyksVikWPGjJEAZNeuXWVSUpLSkUgh4Axqjr8pTW7fvi3z2dvLsAIF5QUvb6lRqXL93Sjbtm2T+fR6WcPdXRb18no+Nk4rs9ks6wUFyUBXN1ncyUmOHTHCyklTb9GiRbKeq6u8WaCgHOfsIt9p00axLP92/PhxOW7sWLlixYpse10ZjUbZtG5d6abTyXxOTvLIkSNKR7Kq5cuWSWetVnrY28senTq98t+hb/fucpST80s/xxBZ25MnT2Tjxo2f3/2YnJysdCSygpTG35w2RKSQvkOHYJQxEX2NiTA7OaP2oEFYUagQWnbrhpDQUBQpUQJHAISakhAqZYqzp62pZ69eOH7+PFZt2gQPDw98O2sW2tSvjyk9eqCinx+qVKiAcZ06460yZfD48WNYLBZ89OGHKO/jg77dusFgMAAAVCoVJIAkAEb5+jX0bty4AVVSEra5e2C9qzuuJxlx0JiIPywW+Pj6omrFipjS/V3Ur1oVM6ZPx+bNm/HNpEmYGhML3aHDGPHeezgdGooPtDr0cXCAq0qFmzdvwtvLC8OfRGKrwQBvtRotHoejXWICylSsiJIZnBn+P/b29vjhp5/QIiYaHeJiMW/RIggAxTQa+NpoUPr+XfwoLbAIgbuJBixNiIOLEHi7bRustrVBYMwT3MqfH7169QIAlChdGisT4rHFkIC1CfEIsLWFj1qD2P9sqpmQkIAjR47g4cOHGcq/d+9eNLWzwyeOThitscG2deteeH7LuvUYqNbgU70D3lWp8cfWrW9s859//kGdwECU9PbGzz/9lKF8RJlBCIEvvvgC06dPx/Lly9G+ffvnn1tERPR6bm5ukGo1NhkMWG1IQLGCBXP9HhjNmjXDkdOnMX7pUpy+eDHdm3ZdvXoV/1y4gPVaHVbq7PHzzz9bOWnqde7cGaJ0aZSPjMBSO1t8lk3We65SpQqmTZ+Od955J0uuq5CQECxYsAD//PNPql+zbds2RJw5i79d3PCxSo3xI0e+8LyUEl9Om4YqZcpgQI8eiI+Pt3bsTNWla1f8c+cOjp8/j8UrV77y3+Gj8eOx0s4WVWKe4Kbn//8cQ2Rtzs7O2Lp1KwYOHIjpzz4bOGbP5V5Xuc7uX5zBQbnB0aNH5fLly1+5vm1sbKzs1r69LFOkiBw3apRiMwlKenvL7R6e8naBgtJDpZY/uLjJO96FZHM3N7lw4UK5ePFi+Zazs9zu4SmbOLvIzz75REr5dBZEs+BgaaNWSyedTq5fv/6V7YeHh0tXvV7+4uomRzm7yOJeBWSNihXlwJ495bJly2TdZ2ti/+aWT7qp1VJvZyfrOz+dZTzf1V3Wr1JVDujZU1Z2dpGtXF1lmWLFpMFgkGfPnpUqQIYVKChvenlLexsbuWzZMmk0Gq1+jpKTk5//RvfatWuyuPfT/mpWrix7deki3WxtZV+9g1zs5i71KpU8c+aMTExMlDdv3pRms/mFdooVKCCLaGyki0olXdVq6WJvLzdv3vzC+SpVuLCs4Ooq3R0c5OHDh9Od+9ixY9JTr5efO7vIys7O8vNJk154fuGCBdLPyUnOdHaVxRwdX/tvKOXTdbe7tG0rC7u6yjFOznJbPk+ZX69/PvPdYrHIj0eNkr4FC8pOLVvK6OjodOcmspY5c+ZIIYSsW7cur8k8CJxBzfE3pdmhQ4dkvSpVZNPateWFCxeUjpNjPH78WLrq9XKuq7sc6+wiK/n6KprHYrHIiIgIaTKZFM2hlC1btkhPvV62d3eX+Rwd5cWLF1P1um3btslyzi7yspe3nODsIps3aPDC85s2bZK+Tk5ynbuHbO7iIkd/+GFmxFdcYmKiDAsLy7PXD2Uti8Uiv/rqKymEkEFBQfLBgwdKR6IMSGn8zTWoiRQUFBSEoKCgVz7n4OCQ5evBJSUlYeYXX+CfixfRc9Ag1K1bF0WLFsXWCxfxONkCg7TgsDERpWw0uJSUBG9vb4SEhOAtCZS3sUV1oxF3wsJw/PhxNG/QAO01GnjodPh24UK0bdv2lX3my5cPqzZswJSxY+Hs6opdc+eiePHiAIATJ07gqtGI41BhZ6IBtWxsUc/ODpMMCeio1uBaUiLmjPkIbdq0waomTRAVFYVFXbpAq9WifPny8CtWDDMjo6AF4Onujk6dOkGjsf7H3r/XsC1RogSu3r6N2NhYdG3bDsYtW2FnTkYHJ3uUt7GBj16PqKgo2NnZoUiRIi+1c/bKFfz2229QqVSoUaMGvL29n++gfvz4cfTs0BHx9+/jKxdXXLRIfPP556iRipnNr1K1alUsXrMGa5cuRffKlTF02LAXnu/VuzdMSUk4sHs3JrZs+dp/QyklmtSpg44JBiTHxaKaixvK29jAw2yD8PBwAMD69evx+7x5+NHWDr8cOIjPxo3DN7Nnpys3kbUMGjQIzs7O6NGjBxo0aIDt27cjX758SsciIsq2atasib3HjysdI8dxc3PDqg0bMHH0aDi7uGDN/PlZ0u+RI0dw/Phx1K9fHxUrVnz+uBDi+fgyL1o2fz5GaWzR1U6H8eZkbN68GX5+fm98XXBwMNa3aomyy5aheMGC2PSfsWxYWBgC1BoE2dkhLMGMvy5fzqy3oCg7OzsULVpU6RiURwghMHLkSJQoUQJdu3ZFtWrVsGXLlkzbo4kU9LrKdXb/4gwOIuv7cPBgWffZWs7uer28dOmSvHXrlmzRsKH00GrlAHsH+bZWJ93Vatm1Y0dpsVjk9evXpZerq6ydL590d3CQR48elZMmTZLvP1tLebqzi+z9zjtpyvHw4UN54cIFmZycLGf/8IMsXbCgdNdo5LZ8nnKEs4tsVr++/OOPP+SlS5dSbOfWrVuy37vvyl7vvPPKXaitwWQyyQ0bNsj169e/NIvAx9NT7vXILyc4OUsPlUoG2thKbzc3mZCQkOZ+kpOTpaeLi/zWxVV+5+Iq3VQq2cXJWQ7u08dabyXd4uLipJ1GI8MKFJRfObtIvRDSz9lZ1g4MfD5j/fvvv5cdXV3lHe9Ccoazi6xavrx8q1Qp2ally1feQUCUlbZs2SK1Wq0sU6aMvHPnjtJxKIuAM6g5/ibKAa5cuSL9S5WSLvb2cuyIEam+q3Lr1q0yv14ve7o+3QPlxIkTmZw055jy2WeylrOLXOTmLos7Or1wt+LrGI1GOaR/fxlQurQcN3LkK9fDvXXrlizg5iYbueeT+fR6uX379syIT5RnnThxQnp5eUknJye5c+dOpeNQOqQ0/lZ8oJveLw6QiayvWvnycvWzjRub5csnV61a9fy5RQsXygIODrKuu7ssWaiQjIqKev5ceHi43L59u7x9+7aU8untb4UdHORMZ1dZ3slJ/vDdd6nOsG7dOumis5eFHBxl03r1pMlkero8xOjRMp+jowyqUEHeuHHDWm85wzq0aCEDXFxkZRdX2SY4+IXnxo4cKX31etnQTitdhJBOtrZy27Zt6eonPj5e2mk08qqXt7xaoKC0AWTj2rWzTXH37fr1ZS0XV1nbxVXWCgyUhw4demHzufv378si+fPLIHd36arTSQ+dTq5z95DdnV3kux06Kpic6Kl9+/ZJR0dH6ePjI69evap0HMoCLFBz/E2UEzSrW1d+7OwiT+QvIIs7OckDBw6k6nV9u3WTU59tuD7E0UlOmDAhk5NmTExMjFy3bp08evRoul7/xdSp0svFRVYpV05euXIlxWOTkpLkuFGjZOPq1eWP33+fqvanTZki6zq7yN/zechKzs5y8eLFrzzuwYMHct26daleNoSI0ubmzZuyQoUKUq1Wy7lz5yodh9IopfG3ePp8zhMYGChPnjypdAyiXOXzSZOw4utvUB3A75D4+/x5FCpU6Pnzp0+fxo0bN9CgQQM4Ozun2NaK5csxc+IknP/nGrS2tli2Zg1atGjxxgz+JUti3JNo1LC1Q+1HD+Dm64v9R4/CyckJJpMJGo0m22zIEx8fD3cXF1zwyA8BoHzEI9yPiICTkxOAp78A3LRpE/bs2QO1SoXWbdqgXr166e6vT9eu+GvbNqgABDZpgiWrV1vlfViD0WjEypUrATzdfEer1b50zJMnTxASEoJLly5hw4TP8KtWh92JBiwoWgQH/v47qyMTvSQkJATBwcHQaDTYuXPnC7dDU+4jhAiRUgYqnSMn4fibcoKwsDB0ad0a/4SFYeDgwZg8fXq2GTumR81KldD71h0Ea7Vom5iASb/9hubNm7/xdT9+/z0WTJiA/io1ZplNmLVkCdq0aZP5gdMhPj4eQf7+cI96gutJSRg1aSKGjRiR6teHhISgdb16WG6vxw6jEcfKlMHuI39ZNePAXr2Qf8NGDHRwxJS4GHgNH46JEydatQ8iSp2YmBh07twZ27dvx6hRozBjxowXlt2k7Cul8TcL1ET0nJQSq1atwj///IOOHTvC19c33W1du3YNNfz98aeTCy6bTBihFrj58OEbX1c7IABN/rmBhlotOkSEw9deh0YffYSYx4/x3Y8/wkmvx/otW1C7du10Z8soKSWuXr0KJycnVKlYEQOSTFAB+Emjxq2HD6FWq63WV3R0NL6cNg1xsbEYOmIEbt++DSkl6tWrZ5Vvwvfu3cPjx49RtmxZq+ZOyZMnT1ClQgXkNxhwNTER382fj3feeSdL+qbXS0pKQt+u3bBtx3YEVa6MFb///sZfROVGFy9eROPGjREfH49t27ahevXqSkeiTMICddpx/E3ZwbVr1/Ber16IfPwYn06f/lLRtXWTJihx/AQ62GnxbmICFm3ejDp16igT1gp27dqFzm3bQi9UKFW+HLbv3w9bW9s3vs5isWDWl1/iyL59aNa2LfoPHPjSMQ8fPsS6detQoEABtGnTRrFC/u7duzGuc2ds1Nrj7yQjxjnoEXrjRppeP6pTJ2zW2uOQ0YiZ7q74+8qVDGWKjY3FokWLoFKp0Lt3b5w7dw4tGjfGW1odziQZcfD4cZQuXTpDfRBR+pnNZgwbNgw//fQT2rZti6VLl8Le3l7pWPQGKY2/uUkiET0nhEhToXDPnj24e/cuWrRoATc3t5faekrCAgmB1A14f1m6FI1r1sSM8Idoo9PhqtmM0PPncWjrVvztkR9HjEYM6dMHZ65eTXVOa7JYLOjUqhX+2rcfBksyPp44Eft37IC0WPDHd99ZvcjbJjgYrhcuwlsI1F+7Fldu3oROp3vlsVFRUTh27Bj8/Pzg4+PzxrZXrliB9/r1g5NajbKVK2PTrl2Zsonkf7m4uOBkaCgOHjyIYsWKcYOLbGLhwoW4uXs3dusd8fnp05g2eTJmzJqldKwsV6ZMGRw6dAiNGjVCo0aNsHHjRjRu3FjpWERE9Ey3tm3R4PYdlFdr0KdbN1S9ehXe3t7Pn496/BhlVGoUUauRX6NBZGSkgmkzrnHjxrh26xYePXqEUqVKpXqsqVKpMHrsWGDs2Fc+HxMTg2qV3kKAMRGXLBac+OsvTJs505rRU61IkSIIS0zEHggcTE5GsRIlXsj51YwZiI+LwwcjRrxyc746derA1dcX9S5eRJTZjHnTf85QHiklguvUgWtYGMwS2LB8Ofb89RdOnD2LM2fOoGrVqi9cc0SU9TQaDX788Uf4+vpi+PDhqFu3LjZt2oQCBQooHY3SiXPgiShdZnz+Ofq3bYsVw4cjyN8fMTExLzxfokQJDHj/fVSJCEf/hATMXrgwVe2WLVsWJ86fh6OrK7YmJiK/UGHX5s2QUsIWgFYImM3mTHhHqRMSEoJTBw/isJMzFtk7YN7332PLnj3Yunev1ZcDuHfvHg4fO46pegeMc3AEEhJw69atVx57//59+Pv5YWr3dxFYvjz27t37xvYnjx2LeTo9Djg44capUzh69KhV86fE2dkZLVq0yJTi9NmzZzHigw/wzTffwGQyWb39rBYaGor2zZqhU4sWuJLB2UApiY6ORmEAnmo1SkjgyePHmdZXdufj44NDhw6hRIkSaNGiBdavX690JCIieubWnTt4284Odezs4KrR4OF/7tD7ZNo0jDEaUDc+FihSBMHBwQoltR43Nzf4+flZdSLEyZMn4WFKwvc6Pb6z1WLt8uVWazutfH19MXvRIvxSqBBi6tTG/GXLnj/XoXlzhM6ejfjFv6JutWpITEx86fW2trbYdegQ1u3fj9CrV9G+ffsM5YmMjEToxYv4WafHPHs9Dh4/DoPBgGLFiqFNmzZ5rjgdERGB6OhopWMQvUQIgWHDhuH333/HxYsXERQUhHPnzikdi9KJBWoiSpcl8+bhRzsd5mvt4W4wvLK4OfXLL/E4OhoRMdGpWivvf7y9vVGlUiVMdXLBHFc3NLHTolj58giIjMDQxAR888svr3xdcnIy1q9fjxUrVrxy8GoNjo6OiDMn415yMq4nm+Ho6Jgp/QDA2rVrUchGg2FRkfjoSSQSLJbXzoxeu3YtqptMWGWnxRiNLeZ89eaZr66ubrhoNiEs2YwnZjNcXV2t/A6y3t27d9GwVi2Ixb9i/aRJGDlkiNKRMsRsNiO4Xj1UPHIUJQ4dRrP69ZFZS3P17NkTR/X2aJAQh19VAsM++ihT+skpvLy8sH//flSuXBkdO3bE4sWLlY5EREQAhg4fjq4JCWidmIDCfn6oUKHCC88HBwfj0o0bWH/gAPYfP/7aO89yk61btyKgdGnUqVwZoaGhqXqNr68vrhuNWB4fj7lJRvi/9VYmp0xZp06dcPjMaazatAn58+d//vjBY8cwXafHeAdHyIQE3L59+5Wv12g0qFSpklWKxy4uLvDMlw9fJsRjWkIcfIsWfeX+KnnBJ6NHo0ShQiicPz8WzJundByiV2rZsiUOHjyI5ORk1KxZE3/88YfSkSgdWKAmonQpU7YslpuSsNmQgH8SE1HiX7fi/Zu9vX26lo2oULky1koLthoScNhswtQvvsCtBw9w//FjNGnS5JWv6d2lC6b27YvZ77+PZvXqwWKxpLnfN/Hz88Po8Z+iVXws5jo5Yn4mzjYpXLgwbLU6+Gg0+DvZgk5dusDOzu6VxxYqVAjnki04m5SEvyBRqJjPG9ufu2wp1uX3RKckI0aNH58rlto4ffo0yttpMcLRCeNs7LBv926lI2VIdHQ0YmNj0ctejwH2etx++BBJSUmZ0peXlxdCr13D6n37cOXmTZQtWzZT+slJXF1dsWvXLjRs2BC9e/fGt99+q3QkIqI87+MJE7D+zz34YuVK7Dx48JXjTE9PT/j7+8PGxkaBhFkrMjIS3Tt1woiISDT95zo6pmJTcuDp2HHdli04VqM6vDp3emHWcnoyjB09Gh++/z5u3ryZ7nb+LSQkBIsXL0bNKlUw3BCPT+JiYePo+MolPqxNrVZjz+HDMLVtA1X7Dthx4ECO3mgzvR48eIDZP/6Iw67u2OzkghHDhmXaRAmijHrrrbdw7Nix53dAzp49W+lIlEbcJJGI0iUyMhKjhw7F7bAwfDBuHFqkcjCcWkajERM/+QRnT5xAx1690Kt379ceO++XX7Bp5Urs2L8fZz29YK9SoXJ0FE5dvoxChQpZNVdWklJi0qefYt3y5ahUORBzFi+Cg4PDa4+d+MknWLd8OfwrV8bPixdn6uzu7OrevXvw9/NDNwgcVwlU7dIF386Zo3SsdJNSolm9eog9dw5mCRSqXg3rtm1TOlaeYzQa0bVrV6xfvx4TJkzAxIkT8+QPqrkNN0lMO46/ibKfa9euoXalSjjq5IJwiwUNY54gOiEhSzPUCawC72vX4AbgD3sdLoeFpWojx9dZv3493uvRA9W1Ohw2JaHPoEGwtbXF4Pfe4/qyz+zfvx8jnm18+e28eZmygXxERARKFCqE7c6ueGRJRl9jIsKjozkGomwtLi4OXbp0wZYtWzBs2DDMmjXL6vtEUfqlNP5mgZqIso1r167hoyFDYExMxMSZM1GlSpU3vmbLli34oGtXjNHY4Kf4OORTqdBYq8M3kLh5/36evR0vvRISEhAWFoZixYrl2FtiQ0ND8evChShSrBgGDx6cJRs/Ziaj0Yj169dDpVKhXbt2eWI2WHZkNpvRv39/LF68GEOHDsW3334LlYo3ouVkLFCnHcffRNmPlBKtGjfG9ZMhiLUko/eQIZg0bZpV2n7y5AkG9uiBC+fOoWufPhj76acvFSellLDRaHA5fwHYAagS8wRHz5/P0Ezndk2bot6x42hvr8doQzyqT5qEoUOHZvDd5B4mkwle7u6YobGFBRKfmE14EBWVKUW42d9/j49Gj4adjQ1+XbECLVu2tHofRNaWnJyMkSNH4rvvvkPLli2xfPny1070oqyV0vg7Z//UTkQAgLCwMBw5cgQBAQEoXbq00nHSrVXjxmgd9QRuEGjeuDFu3r//xiLpuXPn0EilQgudPZ5YLFhgr8PhsmXxx5dfsjidRmFhYagTFARboxHJOnscPHE8R85AL1++PGZ+/bXSMazGzs4OXbp0UTpGnqfRaLBgwQK4uLjg22+/RXR0NBYsWJDjfwFCRETZ19WrV7Fv3z4EBASgcuXKrzxGCIEN27fj0KFDcHBwQGCg9X7vNnb4cIgDBzHdxhbDv/oKlYOCXlpqTwiBxrVrY8jp03AB4OrpiYIFC2aoX78KFbD56DG4JBpwxGxGbz+/DLWX2xiNRhgSE1HH3RESQGxsDIxGI+zt7a3e1/sffIDBQ4ZACMGZ05RjqNVqfPvttyhVqhQ++OAD1KlTB5s3b87wZxNlLk79Icrhzp8/j8AKFbD8gw9Qs3JlHDp0SOlIqfbTjz+icfXqGDdqFO7evYvLN2+il84ene3tIU0mREREvLGNFi1aYH1yMj5KNOAbswlfz52Lzbt3IyAgIAveQe7y43ffoXmiEfv1jmiQkICff/pJ6UjZmtFoREhICB4+fKh0FMoiKpUKX3/9NSZNmoQlS5agY8eOmbYhKxERZS93795F8/r14V+yJBYtXJjp/Z0/fx7VAwKwa+w4vF23boqbfmk0GtSrV8+qxWkAuH3jBmoJFd6ytUUZjQ3u3LnzyuPWbt2KBp98grIjR2L/sWMZ/uXt+MmTgUr+mCAtqNO6NRo3bpym1xuNRmzYsAHbt2/PlWsmOzg4oEe3bmiaEIem8bHo27NnphSn/0elUrE4TTnS+++/j82bN+Pq1auoWrUqTp06pXQkSgEL1EQKi4+Px40bN9K9od+qVavQSajws60W76s1+G3+fCsnzBxbt27FrI8/QbcrV/HX/AVo0aABfG1s0C4iHC0iHqFkqVKpmr1boUIFHDpxAjWnTMbve/ZYfS3svMTJ2Rl3BRBlseCuABydnZWOlG3Fxsaimn8ldGvUCGVLlMCff/6pdCTKIkIITJgwAd999x02btyIFi1aIC4uTulYRESUyfp364Zip05jwpMYjP3gA1y4cCFT+9u0aRPaqtT4RqvDCI0NVixalKn9vcqQMWMwyWREJ6MBoXa2aNWq1SuP0+v1GD16NMaPHw8PD48M97tyxQrcPXUKwyRw6PffsW7dulS/1mKx4O369TGjb1+MfOcdvN+vX4bzZEdzFi7Eip07sXLXLvw4b57ScYiyrbfffhuHDx+GWq1G7dq1sWXLFqUj0WsoXqAWQnQUQpwXQliEEFwHkPKUY8eOwcfbGzUqVED9atVgMBjS3Iavry8OCoFDxkTsFkCpsmUzIan1Xbx4EXWerRfdSgg8un8fEx0cMcrJCSY7O4yeMCHVv6n38/PDe++9h6CgoExOnbuNGDUKyQEBqPEkEtqgIK71l4LNmzfDNfwRduv0mGRjhxkTJigdibLYBx98gF9//RX79u1Do0aNEBkZqXQkIiLKRLdv3UIjjQ2CbG1R2NYO9+7dy9T+ypYti73Sgh0GA34HUK5SpUzt71WaNWuGo2fOYMKyZTh18SLy5cuXaX1JKbF7924sX74ch/fvRycIdLLXoy0EThw79trXRUVF4aPhwzGod29cunQJt27dwvkzZ7Faa4/VOj0WLFmSaZmVJIRAUFAQgoKCOLuZ6A0qVqyIY8eOwc/PD61bt8b333+vdCR6BcUL1ABCAbQDcEDpIERZbfKYMRgj1Dju5ILka9fw+++/p7mNbt264Z0Rw/FDoYKo1bs3PhwxIhOSpt/mzZvRrE4dDO7TB9HR0c8fb9WqFbZYkjHMmIiZJhPavfsuhicZsQRAsqsrGjVqpFzoPMrBwQFb//wTMQYDNu7YYfVbBaWU+Ozjj1GpVCn06949Xb+QUcLnkyahuJcXgmvXxoMHDwAAbm5uuGdOxs3kZJyXFrhZYbYQ5Tw9evTA2rVrcerUKdStWxf3799XOhIREWWSYWPHYlBiAtoaDbDk90TNmjUztb/WrVtj+OefY3VZPzQaPAgjP/ooU/t7nRIlSiA4OBjOmXxn3ZTPPsOg9u2xaOgH+HPnTvxsNmNKfByWWJLRPIWN+d5p1QphixbDcf0G1K9RA3Z2djCrVdhgSMAyQwJKFi6cqbmJKGcoUKAA9u/fj1atWmHYsGEYOnQozGaz0rHoX0R2WZNJCLEPwCgpZaq2Bucu4pQbdGzeHD6H/0JvnT3eMcRj6pIlr711Lie6dOkSagcGYrKtHf60WGDbsAGW/esWvRs3bmDv3r3w9/dH5cqVcfLkSdy8eRONGjXK9EHwf+3fvx/vduwIk8GAHoMG4Ysvv8zU2QhSSphMJtja2mZaH1nFaDRi1syZuH39Bvq+N/i16x+uWbMGk/r3x3QbW/xkMqFwu7awUavhWaAARo8di9DQUCxdtAglSpfG+0OGZIvN5/bt24c+rVphrtYea5KMiKlXFys2boSUEuNGjsSvixbBz9cXyzZsgLe3t9JxSSF79uxB69atkT9/fuzevRvFihVTOhKlQkq7iNOrcfxNuY3RaMTAnj2xZ/du1KpdBwuXL0txg+7Q0FDcu3cPtWvXfuNG3pQ2xb28MM8C+NnYoLkhAf0mT0JcXBzq16+f4l2Srno99jk6I59ajbrxsdh46BCio6Px2ahRsHdwwKyffkKpUqWy8J0QUXaWnJyMMWPGYNasWXj77bexcuVKODo6Kh0rz0hp/J0dZlAT5VkzfvgBOz098FbEIwS1apXr1k++du0aymq1aKWzRzeNDS6eO/fC88WKFUOfPn2e70oeGBiI9u3bZ3lxOjk5GS2aNoWIjMSHag1+++YbLFu2LN3trVmzBkMHDsSmTZte+fytW7dQvkQJ2Ot0aNGwIYxGY7r7yg6GDRyIPV/NguvatWhav/5rN9C5efMm3oJAgK0d6gBYs3QpHFavwbHvv0enNm3wdsOG0C9bjpUTJ+LTDM4SevDgAQb17o2enTtnaI3IR48eoaiNDfw0GgSq1Hhw9+ntvEIIfPH117gfFYW9x46xOJ3HNWzYEHv27EFUVBTq1q2LhIQEpSMREVEq/PTTTwjbvh2r1DaI3LsX38yaleLx5cuXR5MmTViczgSlS5fGiiQjNhsScDvJiNatW2Ps2LFvXMKvaZNgfJBowKj4OAhHR5QsWRI1a9bE7iNHsGnXLhaniegFarUaX331FebMmYMdO3agdu3auH37ttKxCFlUoBZC7BZChL7iq3Ua2xkghDgphDgZHh6eWXGJskzx4sVx5soVGE0mzFuyBCpV9vudkcViwbBBg1DQ3R3N69dP0zqrNWvWxE2NDd5LNGBEkhHdXrFJyfr16zFm9Gjs37//+WOhoaFYv349IiIirPIe3sRkMiHJaERXez266x3Q294Bfx1I36pDq1atwkd9+sJt5Sq8160btm3b9tIxkz/5BA0io3AtfwHE/X0KS5cuzehbUNTh/fsxysYW7zs6oZxWi7Nnz77yuI4dO2K3SqB7UiJmJhnhodXhAwdHjLPT4tjRY6im1WGIoxNGamyxf9fuDGVq3bgxzBs2ouD2nWhUu3a6lxNp1qwZHru5o3liAsYlJWLUxM8ylItyr6CgIBw4cADTpk2z+vI4RESUOcIfPoSflCiq0aCMlAh/+FDpSHnWr2vWILFRQ6zzK41la9eicCqX5vh11Uq8M30aKo0bi0MnT0Kr1WZyUiLKDQYNGoStW7fi+vXrCAoKQkhIiNKR8rwsuX9aSmmVxWSllHMBzAWe3mJojTaJKGVr1qzBgZWrsNpOi59OncaEMWPx47y5qXqtq6srjp89gy1btuCDokXRsGHDF55f8uuvmDh0KNpDoOOcOdi4cycePXqEgd27o4JWh2EqgRNnz8LLy+v5a+7du4dLly7hrbfegqurq1Xeo1arRYsWLfDTlq2ItliwMsmIFe3bp6utA7t3o5dKhX4OjkiIjcGBffvw9ttvv3CM2WSCDoAagB2Q49e+Cm7ZEhOWLEHlpERcEuL5jPj/Klq0KM5cuoRjx46hcOHCaNG4MT6Li8VFATRq1BC7du3CTKMRB1UCzVs0z1CmUxcv4jeP/LAXAotjnuDhw4fw8fFJczuOjo44dvYMQkJCUKRIERQpUiRDuSh3K1++PMqXL690DCIiSqV+Awag1rx5OJaYgPsqgX3vv690pCxjNpuxdu1aGAwGdOrUCXq9XtE8np6eWLp2bZpfZ2tri8GDB2dCIiLK7YKDg/HXX3+hefPmqFOnDpYvX47WrdM0j5asSPkFPokoW4uIiICPSsBHo0F5I3Dm4YM0vd7T0xN9+vR55XO7t2zBYJUGXfV6xMfFYu/evTi8cycm2dqhpZ0W7ycasHXrVvTt2xcAcPz4cbzdsCFK2tnhjhA48vffqZ5d8SZrf/8dCxYsQEhICNZ16oT69eunq51Gb7+NYStXwhAbg2WWZCx+xWaPn0yZgkb79mFu1GOUL1sW3bt3z2h8Rc345hss9vfHrVu3cKh7d+TPn/+1x3p6eqLls41uDp04gcWLF6Ny/vzo168fLly4gBXLlmGwr+9rr5nUavv22+hz8CBcIOBVuDAKFSqU7rZ0Oh1q1aqVoTxERESU/RQvXhwX/vkHFy9ehJ+fn9UmP+QEvbt0waXdu+EkBOZ+9x0OhYRArVYrHYuIKEuVL18ex44dQ6tWrdC2bVt89dVXGD58eKbuR0WvpvgmiUKItgB+AOAB4AmA01LK4De9jpu0EGWNiIgI1AgIgF1cHO6bTNiyaxeqVatmlbbnzZ2LWaNH4x0I/JJsxsqtW7Fm6VLcW7MWXTQafJRkxIKNG9GgQQMATwfSPtv+QD8HR4yNi0X5j8dhzJgxVsliTZs3b8aBvXvRKDgYwcGv/jgzm82IjIyEh4dHpn/zM5lMCA8Ph5eXV7ZcRiYzJCUlYenSpTAYDOjevXuWr2tORNkfN0lMO46/iXIHKSXsbGxwziM/9EKgSswTHAkNTdfdZkREuUFCQgJ69OiBdevWYdCgQfjhhx+g0XBOr7WlNP5W/GxLKTcA2KB0DiJ6tXz58uH0pUs4d+4cihcvDg8Pj3S1ExoaiqNHj6JGjRooW7YsAKBf//6wtbPD8UOHsLBdO9StWxcBAQEYFh+Pr86cwfB+/Z4XpwGgQOHCOCkEappMOC+AJgptTHf58mVM/fRT2NjY4LPp01G0aNEXnm/ZsuXzWcKvo9Fo4OnpmZkxATzdqLJhrVqIj4lB8RIlsPvwYTg5OWV6v0qztbXN8CxsIiIiouwiJCQEXdu2RURUFD6dMAHDR49Od1tCCJQvVQo/3n8ADwDSxibFO+CyK4vFgg8HD8byFStQ1tcXqzZvRoECBZSORUQ5kL29PVavXo2PP/4YM2bMwI0bN7B69eo88bNzdqH4DOr04gwOopzj8OHDaB0cjIZaHfYkGrB1z5437sj9KvHx8RjQowdOHjuGFm3bYuZ332X5jGCTyYQShQqhmzEJ8QD2uLni/PXrWZohLfp26wbXrdvwob0eAw3xaDp5MoYOHfr8+W3btuHDAQOgUqkwe9Gil9YJJyLKrTiDOu04/iZSTiVfX/QOj0BlWzu0i4vBX2fOoGTJkulu7/bt2/hk5EgY4uPx6bRp8Pf3t2LarLFx40aM79ULC7U6LEhMhCG4CX5dtUrpWESUw82fPx+DBw+Gn58ftmzZ8tKENEq/bD2Dmoj+39LffsP3X3yBIkWLYvaiRTlyJsOrrFmxAv1Vagyx0+LbpCSsXbUqXQVqvV6PZevWZULC1IuKikJMTAzec3VHMoCfbt6EyWSCjY2Norlex9bODrEATAAS8HRm8f8YjUZ069gRP+vskSQlOrVpg/Do6DyzDAgRERFRdnfixAnMnz0b9+/fR3GtDt5qNfRqDWJjYzPUbuHChbFk9WorpVRGdHQ0CqjUKKBSoyQEDjx+rHQkIsoF+vXrBx8fH3To0AFBQUHYtGkTqlatqnSsXI9VCKJs4sKFCxg5eDCGP3gE17+OYMC77yodyWrKVqyI7SqBXYkG7BAC5SpWVDpSunl4eKBCuXLok5iAHoYEvN2gQZYWp6WUuHTpEm7cuJGq48dPnYrjXvlR8sE9OFSujJ49ez5/zmg0Islkgr+NLd6ytUOcwQCTyZRZ0YmIiCgPS05Oxs8//4wxo0bh7NmzSsfJEW7fvo1mDRrAc8NGeCRb0OVJFGrGPEHV+vVy5Ixna2vXrh3CPT1QNz4OXySbMHby5Czt32Kx4MmTJ8ipd6UT0es1atQIf/31F3Q6HerWrYt1Ck+UywtYoCbKJm7fvo1idlrU0WrRXGODG//8o3Qkq+nXrx86jRyJFX6l0X3MR+jZsyeuXr2KVo0bo1GNGjh8+LDSEVNNCIHt+/ej04wZ6P31LKzZsiVL+x/Svz8aBAaiSrly+GLq1Dce7+3tjVOXLiHJZMLm3buh1WqfP+fk5IR+ffqgYVwMGsdGY8SwYbCzs8vM+ERElMmEEB2FEOeFEBYhxGuXMBFCNBVCXBZCXBNCjM3KjJQ3jR8zBgvGjoVx7jw0qFkTN2/eVDpStnf27FmU12oxyMERX+odUNjbG/v//hsrN27kHW8AHB0dcezsWWw4eABXbt5EjRo1sqzve/fuoXyJkijk6Ylq/v6Ijo7Osr6JKGuULVsWx44dQ6VKldChQwd8+eWX/IVUJuIa1ETZRHx8PIL8/eES9QQ3koz49IsvMPj995WOlWnKFS+O1pFRyC8EpiSbEXbvHhwcHJSOla09fPgQvkWL4oSrO2KlRK3ICIRHRmL58uUQQqB79+7Q6XRpalNKiQsXLkClUqFMmTIvPHf37l38+eefKFeuHAICAqz5VoiIFJdb16AWQpQBYAHwC4BRUsqXBsxCCDWAKwAaA7gD4ASALlLKCym1zfE3ZUTVsmUx7lEEqtrZoW+SEf1/noP27dsrHStbe/jwISqWLo3WEggRQMNevfDlt98qHStbMBqN6NauHbbt2oUq/pWwfvsfcHd3z7L+P3z/fcQtXYaJegcMSYhD9XHjMGbMmCzrn4iyjsFgQK9evbB69Wr069cPP/30U7Zd4jO74xrURDmAXq/HkVOnsHfvXhQsWBCVK1dWOlKm+uf2bXTL5wlHITA9+gkiIiJYoH6DjevXI9FoxGWzCVEWCxzt7dGycWOoL12GBcDqX3/FrkOH0tSmEALlypV76fFbt26hqr8/qqo1GJ1owOxff+UPkUREOYCU8iLw9PM9BVUBXJNSXn927EoArQGkWKAmyoh6TZrgy8WLUTvJiJPSgjn85fcb5c+fH4dOnMCyZctQvWhRPLhzB+6OjvDy8MCKjRtRMQcvm5dRCxYsQMThvxDi7oHPr17F5xMn4usffsiy/lUqFaQAJAALBNRqdZb1TURZS6fTYcWKFShZsiSmTZuGsLAwrFmzBi4uLkpHy1V4XxDlSJcuXULT2rVR6623sHfvXqXjWI2joyNatWqV64vTANCnRw90MsSjU2ICyvlXRJEiRZSOlK0lJCRg1PDhGOvkjP6Rj/FeVBTm/forjoeEYKHOHot19jh47Bji4uKs0t/WrVtRV6gwx06LT23s8F737ujVuTMSEhKs0j4RESmqIIDb//r7nWePEWWaaV99hS6TJyOpx7vYsW8fihUrpnSkHKFUqVKYOHEiqlSpgu9nzMBmewf0iHqCAd26Kx1NUfHx8cgHwEmlgheA+AxuGplWoz/+GMc9PFAq/CEeFy+GAQMGZGn/RJS1VCoVPv/8cyxatAj79+9Hw4YNkZycrHSsXIUzqClHatesGTpFPUEBlQrtW7ZE2L17cHJyUjoWpcHs+fOxo2NHJCQkoHnz5lxH7w3MZjMsFgva6ezRQqdDncjHaNq0Kbw8PPBtfDwsAAp7eUGv11ulP19fX8wwm/BnogFrDQmor1Lh0Y6d+GLqVEyeNs0qfRARUfoIIXYD8HrFU59IKX+3cl8DAAwAwF8mU4ZoNBp88MEHSsfIsWJiYuCk0cBbrUYJtQYxMXl7zePevXtj8c8/o3p4OJJtbbH344+ztP8CBQrg7JUrSEhIsNr4m4iyv169esHHxwcRERG8c8LKWBGiHCns7l200+rQTKuDHYCIiAilI1EaCSHQtGlTODo64scff8SFC7yrOCVOTk4YN24c6jyJRMOoSNSoUhXvtmuPSTNmIKpZU8S83Qy7Dh580y3dqdawYUOM/eILTLPXIVJaMNXFFVWlxJ2wMKu0T0RE6SelbCSlLP+Kr9QWp+8CKPyvvxd69tir+porpQyUUgZ6eHhkNDoRpVNQUBD8qlZFzdho9E+Iw6SvvlI6kqLy5cuH05cuYU9ICK7dvg1fX98szyCEYHGaKA+qV68eOnTooHSMXIebJFKONGLIEGz+7Tc4qdXwqFAB2/buzZMzcKWUCAkJQXJyMqpWrWq14mRWWfLrrxg/dCgaqDXYbDbh0IkT8PPzy7T+kpOT0bZFC/z1559wdXPDjsOHUbx48UzrLzM8evQIQ/v3h3H/AdSCwBfmJJw4dy7TbpO9efMmqgcEoLhKhUuJidi2Zw+qVq2aKX0REWWl3LpJ4v8IIfbh9ZskavB0k8SGeFqYPgGgq5TyfEptcvxNpCyLxYKrV6/C1dUVnp6eSschIiJKE26SSLnOrB9+QOuOHREfH4/GjRvnyeI0AHz43nv4fdkyqIRAw9atMW/JEqUjpcn6pUsxRmOD1jp7mA0J2L179xsL1BaLBdu3b4fZbEazZs1gY2ODBw8e4MKFC6hUqRLc3Nxe+9rvvvsOf+7YgW9d3PBXbCzerlcPl27dsvbbylSenp64eO4cptvYopKtLX43qnHp0qVMK1AXLVoU565cQUhICMqVK4eCBf9/idLExETcuXMHRYoUga2tbab0T0REaSOEaAvgBwAeALYKIU5LKYOFEN4A5ksp35ZSmoUQQwDsAKAGsPBNxWkiyjxSSuzfvx+PHz9Gs2bNYG9v/8rjVCoVSpcuncXpiIiIMh8L1JQjCSFQt25dpWMoymg0Ys68eTjjkR82ACqtWoWZ33+fo3aSrVyjBn47cRJJCfHYYzZhYKVKb3xN7y5d8PeOnbBTCcyvXBkTZ8xAcL16KGFri1tS4vDJk68t1l69ehWF1Go00+lQVKPGpkePMLhPXxQtWQIjRo3KMUXW9t26YfT3P6BCsglhGg2CgoIytT93d3c0adLkhceuX7+OetWrQxoMsHd1xcETJziTh4goG5BSbgCw4RWP3wPw9r/+vg3AtiyMRpTpIiIi4ODgAK1Wq3SUNJn06af47ccfUUCtwRfeBXD4779zzLiUiIjIGvLmtFOiXMDGxgbOej0OGBNxKMkIO1vb1862yK7GjR+PViNH4Gitmvhu4ULUqlUrxeNNJhOWr12LDTp7rNXaY//Bg/h+5kz0Eyqss9PhbXMylqQwi3zkyJG4JyXaRYSj++PHSExOhtvaddj+5UyMeP99a7+9TDNh8mRM+3Uxak2ahGOnT6c4azyzfDtzJtokGnHU0RmB0TGYO3dulmcgIiIiAp7eYdetfXsUL1QIBfN5YO/evUpHSpN5P/+MxVodVmp1iL1zF2fOnFE60nNSSoSGhuJWDrvrkIiIchbOoCbKoVQqFTZu24YP+vZFcnIy1vzyS46baaHRaDBu/Pg0He/t4YHlhgTohYCdVosixYvjmBC4bDIhVABB3t6vfX3JkiURev06Fi5cCKPRiBPzF+A9WztUSzLis/37rfGWsoQQAm3atFE0g72DA24IgTiLBeGQqOLgoGgeIiIiyrsOHz6Mk3v24JRbPuxLTMRH77+PEzloA+6SxYtjzdVrqKAyI9xsQqFChZSOBOBpcbpL27b4688/EW9OxrRZX2Hg4MFKx6IczmQy4dy5c/D29oaXl5fScYgom+AMaqIcrGbNmgi5dAmnr15FgwYNlI6T6YQQ2LZnD45W8sf2smWwbfdujPv0U3gFN8EgGzWqdOqMPn36pNhGkSJFMHHiRAwdOhRnk4yYEhuDiaYkNGnRIovehXJu3bqFymXKQmdri77duiE5OTndbY35+GOE+5WGf8QjaKtUwcCBA62YlIiIiCj1NBoNTFIiSUrESQs0NjZKR0qTZRs24F6N6lhWohiWrV2LAgUKKB0JAHDx4kUc2rMH+xycsNrBERM/+UTpSJTDGQwG1A4MROcGDVCuZEls375d6UhElE0IKaXSGdKFu4gTUUZdvnwZy5YuhU+xYujVq1eu32yza7v28PjzTwzQ2ePdxAR8Mn8+2rdvn6E2N23ahA3LlyOgenW8P3ToK8/hnTt3EB4ejooVK0KtVmeoPyIia0lpF3F6NY6/KbuSUuLDwYPx07x58HBxwe/bt6NKlSpKx8rx7ty5g4q+vljl4IgLJhN+cXHGhRs3XjouJiYGoaGh8PX1Rb58+RRISjnFhg0b8FXfflil1WF7YiKWFCuKAyEhSscioiyS0vibS3wQUZZ48OABpk+ahCSjER+NH//ajQyzUunSpTF5yhSlY2SZhLhYFADgLARchEB8fHyG2jtw4AAGde2GDzQaLNy+HaakJIwYPfqFY1auWIH3+vaDi40GJSpUwLa9e2GTw2Y1ERERUfYmhMB3P/+MWT/+CLVaDSGE0pFyhUKFCuHLb79Fr3Hj4OrqgiWrV790zJ07d1CjcmW4m824azZj14ED8Pf3VyAt5QRubm64bzYjLDkZoZZkuPMXGkT0TO6eLkhE2UbzBg0Qt2IFbNetR4MaNWE2m5WOlOd8Om0avoZE1ZhoGIoUyfDs6RMnTqCZjQ3e1Tugl1Dh6CvW8Z768ceYa6/HPr0j7p8/jyNHjmSoTyIiIqLX0Wg0LE6/gZQSJpMp1cf3GzAAdx8/Ruj16wgMfHnS22+//YZ6iUZs0dqjHwRmf/21NeNSLlOnTh28O+R9dExKxMnixfDdvHlKRyKibIIFaiLKdGazGacvXcJ4eweM1jsgJvoJwsPDlY6V5wQGBuLG3bs4eOY0DoWEQK/XZ6i9hg0b4ndTEj6Pi8W3yWY079DhpWPc3d1xzmzCdbMZkSYz3NzcMtQnERERUV7y559/omKJEqhUqhQOHDiQ5teHhITgvX79MP3zz3H58mWULV4cOq0WbYKDkZSUlOF8Hh4euCqAG2YzQoWABze9oxQIITBp2jTcj4rCob//RpEiRZSORETZBNegJqIs0bRuXVjOnIUOwN2C3jh+7lyuX/M5LwgJCcG2bdsQEBCA5s2bv/T8pUuX8G779rj34AFGjh370hIgRERK4RrUacfxN+V2N27cwJdTpsDWzg7jPvsMXgoXW00mE7zc3DDL1g5mCYw1J+FhVFSq9/S4ffs23ipbFgOECkdVKjxyc0WjyCgMs9ejuyEeA7/7Dj169MhQRrPZjPf79cMfW7ciKCgIi1auhIODQ4baJCKi3IlrUBOR4tb/8QcWLlyIpKQk9O3bl8XpXKJy5cqoXLnya5/38/PDifPn09V2QkICbt++jWLFisHW1ja9EYmIiIjeyGQyoUGNmmiVkIBYIdDiwAGcTOcYxloMBgMSjUbUcHCCBUBcbDSSkpKg0+lS9fpz586hvFaL9221qJWUhD6PHsFeYwMNADuINC318ToajQa/LF6c4XaIiChvY4WIiLKEvb09hgwZghEjRsDZ2fn544sXLUK18hXQpW1bPH78WMGElJ1cuXIFpYoUQXDVqqjo64tHjx4pHYmIiIhysfDwcMRGP8FovQMm2Otx6uJFJCcnK5rJyckJPbp3R5P4WDSJi8XAvn1TXZwGgICAAFw0mTAlLhafmYxo1ro1frO1QYWox0guVRJdunTJxPRERESpxwI1ESnm1KlT+PiDDzDs/gNo9u7DkH79lI6UrRw8eBBVy5VDtQoV8tzmgt98MQPvmMw47OCESk+isWjRIqUjERERUS7m5eWFoj4+GJIQj/4J8WhSp06ql9LITD8tWIC1f/6Jjfv34ds5c9L0Wi8vLxw8fhweQ4dg4FdfYf6SJbh+9y6u3LyJfceOwd7ePpNSExERpQ2X+CAixYSFhaG0nR3q2GkhjIn45spVpSNlGyaTCW2bN8fnGhskA2jdrBkeREbmmaVRHJwccUcIRFsseAhwLUMiIiLKVCqVCnv++gsLFy6Era0t+vbtq3QkAE83lQsMTP9y+b6+vpgyderzv6vVanh6elojGhERkdWwQE1EimnQoAE+0unQ3WDAZaMRn48coXSkbMNgMMCQmIiG7o6wABgR8QhGozFNt3XmZOMmTECHo0dR9fRpNG3YEP04u56IiIgymYuLC0aM4HiUiIgoq7FATUSKcXZ2xsnQUOzZswc+Pj4ICAhQOlK24eTkhM4dOqDZ1q2wAOj97rt5pjgNAG5ubvjz6FGlYxARERERERFRJmOBmogU5ezsjHbt2ikdI1tasGwZDh8+DJVKherVqysdh4iIiIiIiIjI6vLGYqZElGGRkZGYM2cOVq1aBYvFonScPEEIgVq1aqFGjRoQQigdh4iIiIgUIqXEpPHjUcTDAw2qVcPdu3eVjkRERGQ1LFAT0RsZDAbUrFwZ2z/5BF8MHIQPBg5UOlKudO3aNbRu0gSNa9bE4cOHlY5DRERERNnEvn37sOT77/GbUMPv0mWMGDxY6UiUw1gsFrzfrx/yu7igSa1aiIiIUDoSEdFzLFAT0RtduHABePIEP+n0+NlOi7Vr1iodKVdq27Qpyh4/gRYXLqJ1s2aIjY1VOhIRERERZQMREREopNGghEaDSioVHt1/oHQkymHWrFmDv9auxWY7HQqEnsf4jz5SOhIR0XMsUBPRG/n4+CDcnIwl8XGYbUxExfLllI6UK127dQvddPZoq7OHjcWC8PBwpSMRERERUTbQrFkzxHp6ItgQj3FJRnw0eZLSkSiHiYyMRBGVCgU1GpQGEMmfNYgoG2GBmojeyN3dHVt378Lp2rWgb9cWyzduVDpSrtSnRw90NsSjc2ICylSoAB8fH6UjEREREVEqJCUl4aMPP0SdgADMnD4dUkqrtu/g4IAjp09j4fbtOHflCpo1a2bV9in369y5M644O6NRQhy+sSRj5PjxSkciInpOWPsbZ1YJDAyUJ0+eVDoGEZHVSCmxY8cOJCQkoHnz5rCzs7Nq+5s3b8bn48bB1d0dsxctQvHixa3aPhFRTiKECJFSBiqdIyfh+Jvo9aZNmYIds77GILUGk81JmLJgATp06KB0LKIXJCYm4sKFCyhatCjc3d2VjkNEeUxK42/OoCaiPGvOjz/CzcEBRfPnx4EDB5SOAyEEmjZtinbt2r2yOH3//n18/fXX+O2335CcnJymtu/fv4+e77yD9+4/QMUzZ9G1TRsrpSYiIqK8KKdOdMosV0JDEQygjlaLmhC4cuWK0pEoB1u+bBl88udHuWLFcPToUau1q9VqERAQwOI0EWU7LFATUZ507949fPzRR/hd74CJ5mT07NxZ6Ugpio2NRfWAAJyYMgXfDh2K4e+9l6bXP3jwAK4aDerbadHCzg5ht29nUlIiIiLKze7cuYPKZcrCzsYGXdq0hdlsVjpStvDugAH4xmzCe0lG/C4taNeundKRKIeKiIjAe/374weLxJDoGHTltUREeQAL1ESUJxkMBtgKAS+VGkXVGsQlJCgdKUVnz56FW1ISvrJ3wLd2Wvy+YUOaXl+hQgV4lyqFtokJ6G5IwJBhwzIpKREREeVmEz76CEH37yPUIz/C9u/HypUrlY6ULTRs2BD7jh1Dx2++xslz5+Dn56d0JMqhYmNjYSsEytrYopKNLR4/eaJ0JCKiTKdROgARkRKKFy+ONh07ouaaNUiyWDDr+++VjpSikiVL4lZSEuabk3FWCARWr5am12s0Guw+fBh79uyBm5sbqlVL2+uJiIiIAMCQkIDCErAXAk7i6S/96aly5cqhXLlySsegHM7HxwdNmzdH/e3bYUhOxoTPPlM6EhFRpuMmiUSUZ0kpcfPmTdjb28PT01PpOG904sQJfP/ll8jv7Y0JU6bAyckJx48fx+Jf5qJoyRIYPnIkbG1tlY5JRJQjcJPEtOP4mwDg3LlzaFK3LpCUhCLFi2PPX3/BwcEhU/q6evUq+nTujEePwjFm4mfo069fpvRDlN1IKXHu3Dno9XqUKFFC6ThERFaR0vibBWoiyrDLly9j7k8/wcPLCx8OHw6tVqt0pDwhLCwMgRUqYKBQ45BKwL9zJ3z/yy9KxyIiyhFYoE47jr/pfwwGAx49eoRChQpBrVZnWj+13noL9W6EIcjGBn0S4nH07FkW64iIiHKolMbfXOKDiDIkMjISdatVwzsWiT0CuPD3KSxZs1rpWHnCmTNn8JZWh/ds7RCUZMSkffvS1c6lS5fwy48/wsPLC8NHjoROp7NuUCIiIspVdDodihYtmun9PHj4EDVtbFHexgb5bEwIDw9ngZqIiCgXYoGaiDLk4sWLKKhSY7S9DjfMZnTbv0/pSHlGYGAgziQZMdVoxHGVQJOWLdPcRmRkJOpVr453LBL7BBD69yksX78uE9ISERERpc3o8ePRc9Ro5LO1QYEyfqhcubLSkYiIiCgTsEBNRBlStmxZ3JMWfB4bgwsqgQbNmikdKc8oWLAgDhw7hmVLl+L94sXRq1evNLdx+fJlFFCpMNreHjfNZnQ+sN/6QYmIiIjSYeDgwajXoAEiIiJQtWpV2NjYKB2JiIiIMgEL1ESUIa6urjh4/Djm//ILWhUogCFDhigdKU/x8/PDlKlT0/36MmXK4CGAKXExuCgEGjZtar1wRERERBlUunRplC5dWukYRERElIlYoCaiDCtZsiS+mDlT6RiUDi4uLjh04gQWzJuHtvnz47333lM6EhERERERERHlISxQE1GudfToUdy5cwdNmjSBk5OT0nGyreLFi+Pz6dOVjkFEREREREREeZBK6QBERJnhh2+/RcfGTTB74CAE+fsjLi5O6UhERERERERERPQfLFATUa407/vvMVurxVKtDi4xsTh8+LDSkYiIiIiIiIiI6D9YoCaiXKlEqVLYaDJhT6IB/xgTUbRoUaUjERERERERERHRf7BATUS50tylS2GoVxdzCxfCDwsWwM/PT+lIRERERERERET0H9wkkYhyJQ8PD6zYuFHpGERERERERERElALOoCYiIiIiIiIiIiIiRbBATURERERERERERESKYIGaiIiIiIiIiIiIiBTBAjURERERERERERERKYIFaiIiIiIiIiIiIiJSBAvURERERERERERERKQIFqiJiIiIiIiIiIiISBEsUBNRmnzz1VcoUaAA6gcF4ebNm0rHISIiIiIiyrC9e/eiQokSKF+sOHbv3q10HCKiPIUFaiJKtZCQEHw1aRJ+Trag0uUreK9XL6UjERERERERZUhycjI6tGqFkU+i8VFMDDq1aQOTyaR0LCKiPEOjdAAiyjkePXoEbxtblNHYICLZgoMPHigdiYiIiIiIKEOSkpIQn5iIIAcnqAAkxsYgMTERNjY2SkcjIsoTOIOaiFKtfv36UBcuhKaGeAxNTMDoiROVjkRERERERJQhOp0Og/v3R5O4WDSOj0Wfnj3h6OiodCwiojyDM6iJKNW0Wi32Hz+OkJAQeHt7w8fHR+lIREREREREGfb17NnoOWAApJSoVKmS0nGIiPIUFqiJKE3s7OxQo0YNpWMQERERERFZjRCChWkiIoVwiQ8iIiIiIiIiIiIiUgQL1ERERERERERERESkCBaoiYiIiIiIiIiIiEgRLFATERERERERERERkSJYoCYiIiIiIiIiIiIiRbBATURERERERERERESKYIGaiIiIiIiIiIiIiBTBAjURERERUS4hhOgohDgvhLAIIQJTOC5MCHFOCHFaCHEyKzMSEREREf2bRukARERERERkNaEA2gH4JRXH1pdSRmRyHiIiIiKiFLFATURERESUS0gpLwKAEELpKEREREREqcIlPoiIiIiI8h4JYKcQIkQIMUDpMERERESUd3EGNRERERFRDiKE2A3A6xVPfSKl/D2VzdSSUt4VQngC2CWEuCSlPPCKvgYAGAAARYoUSXdmIiIiIqLXYYGaiIiIiCgHkVI2skIbd5/995EQYgOAqgBeKlBLKecCmAsAgYGBMqP9EhERERH9F5f4ICIiIiLKQ4QQeiGE4//+DKAJnm6uSERERESU5VigJiIiIiLKJYQQbYUQdwBUB7BVCLHj2ePeQohtzw7LD+CQEOIMgOMAtkoptyuTmIiIiIjyOi7xQURERESUS0gpNwDY8IrH7wF4+9mfrwPwz+JoRERERESvxBnURERERERERERERKQIFqiJiIiIiIiIiIiISBEsUBMRERERERERERGRIligJiIiIiIiIiIiIiJFsEBNRERERERERERERIpggZqIiIiIiIiIiIiIFMECNREREREREREREREpQkgplc6QLkKIcAA3lc5B2VY+ABFKh6Bsj9cJpRavFUotXis5R1EppYfSIXIShcff/H8r/Xju0ofnLf147tKH5y39eO7Sh+ct/Xju0ue14+8cW6AmSokQ4qSUMlDpHJS98Tqh1OK1QqnFa4Uoc/D/rfTjuUsfnrf047lLH5639OO5Sx+et/TjubM+LvFBRERERERERERERIpggZqIiIiIiIiIiIiIFMECNeVWc5UOQDkCrxNKLV4rlFq8VogyB//fSj+eu/TheUs/nrv04XlLP5679OF5Sz+eOyvjGtREREREREREREREpAjOoCYiIiIiIiIiIiIiRbBATURERERERERERESKYIGaci0hxBAhxEkhhFEIsVjpPJR9CCHchBAbhBDxQoibQoiuSmei7ImfI5QaQgg7IcSCZ58nsUKI00KIZkrnIsrJ0vL5K4ToJYRIFkLE/eurXpYEzWbS+n1LCDFcCPFACBEjhFgohLDLgpjZUlrGh0KIiUII03+uueJZmVdJqT1X4qkZQojHz75mCCFEVufNTtJw7vL0NfZfafyewM+1Z1J73vh99EVpHdvzmrMOFqgpN7sHYCqAhUoHoWxnNoAkAPkBdAMwRwhRTtlIlE3xc4RSQwPgNoC6AJwBfApgtRDCR8lQRDlcWj9/j0gpHf71tS/zomVrqT5vQohgAGMBNARQFEBxAJMyNV32ltbx4ar/XHPXsyRl9pDaczUAQBsA/gAqAmgJYGAWZcyu0nKd5eVr7L9S9dnGz7WXpOV7Kb+P/r9Uj+15zVkPC9SUa0kp10spNwJ4rHQWyj6EEHoA7QGMl1LGSSkPAdgE4F1lk1F2xM8RSg0pZbyUcqKUMkxKaZFSbgFwA0BlpbMR5VT8/E2fNJ63ngAWSCnPSymjAEwB0CsT42VbHB+mXhrPVU8As6SUd6SUdwHMQh69xgBeZxmRhs82fq79C7+Xpk8ax/a85qyEBWoiymt8AZillFf+9dgZAJxBTURWIYTIj6efNeeVzkKUh7wlhIgQQlwRQowXQmiUDpQDlMPTMdD/nAGQXwjhrlAeJaVnfNhSCBEphDgvhBicufGylbScq1ddY3l5zJ3W6yyvXmMZwc+19OP30dd4w9ie15yV8IIjorzGAUDMfx6LBuCoQBYiymWEEDYAlgH4VUp5Sek8RHnEAQDlAdzE0x8UVwEwA5iuZKgcwAFPx0D/878/OyLvzbZL6/hwNYC5AB4CCAKwTgjxREq5IvMiZhtpOVevusYchBBCSikzKV92lpZzl5evsYzg51r68Pvoa6RibM9rzko4g5pyJCHEPiGEfM3XIaXzUbYWB8DpP485AYhVIAsR5SJCCBWA3/B0bckhCschyrasPY6TUl6XUt54dhvuOQCTAXSwfnJlZcL4979jov/9OdeNiVJx7tI0PpRSXpBS3pNSJksp/wLwHXLhNfcaaTlXr7rG4vJocRpIw7nL49dYRuSZzzVryivfR9MqlWN7XnNWwgI15UhSynpSSvGar1pK56Ns7QoAjRCi1L8e8wdvxSeiDBBCCAAL8HTTo/ZSSpPCkYiyrSwYx0kAwgrtZCuZcN7O4+kY6H/8ATyUUua6GV+pOHcZHR/mymvuNdJyrl51jeXlMXdGrrO8dI1lRJ75XMtkef56S8PYnteclbBATbmWEEIjhNACUANQCyG0XEeJpJTxANYDmCyE0AshagJojae/GSV6AT9HKA3mACgDoKWU0qB0GKKcLi2fv0KIZs/Wh4QQwg/AeAC/Z13a7CON37eWAOgrhCgrhHAB8CmAxVmTNHtJ6/hQCNFaCOEqnqoK4APkkWsujedqCYARQoiCQghvACORR68xIG3nLi9fY6+Shs82fq79S2rPG7+PvlJqx/a85qyEBWrKzT4FYAAwFkD3Z3/+VNFElF28B0AH4BGAFQAGSynz8mwOej1+jtAbCSGKAhgIoBKAB0KIuGdf3ZRNRpSjvfbzVwhR5Nn/Y0WeHdsQwFkhRDyAbXhaAJqW9ZGzhVSfNynldgBfAtgL4Baerj36mRKhs4nXjg+FELWFEHH/OvYdANfw9BbuJQBmSCl/zeK8SnrluXrFefoFwGYA5wCEAtj67LG8LLXnLq9fY//1ys82fq69UarOG/h99AUpje15zWUekXeXfyIiIiIiIiIiIiIiJXEGNREREREREREREREpggVqIiIiIiIiIiIiIlIEC9REREREREREREREpAgWqImIiIiIiIiIiIhIESxQExEREREREREREZEiWKAmIiIiIiIiIiIiIkWwQE1EREREREREREREimCBmogohxNCfCmE2Pivv88UQuwRQtgqGIuIiIiIKNfiGJyIyHqElFLpDERElAFCCHcA1wHUAxAE4H0AtaSU0UrmIiIiIiLKrTgGJyKyHhaoiYhyASHERADtADjj6cD49rPHZwCoASAMQB8ppUmpjEREREREuQnH4ERE1sElPoiIcodTACoAGPevgbE/gIJSytoALgHooGA+IiIiIqLchmNwIiIrYIGaiCiHE0JUADAHwK8A+vzrqRoAdj7783YANbM4GhERERFRrsQxOBGR9bBATUSUgwkhCgLYDGAQgPcAVBBC1Hv2tCuAmGd/jgbgltX5iIiIiIhyG47BiYisiwVqIqIcSgjhBGAbgK+llJuklAkAZgL4/NkhTwA4PfuzM4DILA9JRERERJSLcAxORGR93CSRiCiXEkJUAjBCStlDCPExgBtSyhUKxyIiIiIiyrU4BiciSjvOoCYiyqWklKcBPBRCHARQDsA6ZRMREREREeVuHIMTEaUdZ1ATERERERERERERkSI4g5qIiIiIiIiIiIiIFMECNREREREREREREREpggVqIiIiIiIiIiIiIlIEC9REREREREREREREpAgWqImIiIiIiIiIiIhIESxQExEREREREREREZEiWKAmIiIiIiIiIiIiIkWwQE1EREREREREREREitAoHYCIiIiIKDVCQkJsNRrNPAC1AKiVzkPpYhFCPDCbzZMCAgJ2KB2GiIiIiJQnpJRKZyAiIiIieqNTp04Nc3FxGVq0aNFolUrFQWwOZLFYhMFg0IaFhdkajcYhLFITEREREZf4ICIiIqIcQa1W9/b29o5ncTrnUqlUUq/XG3x8fJI0Gs1nSuchIiIiIuWxQE1EREREOYKU0tnW1takdA7KOJ1Olyil9FI6BxEREREpjwVqIiIiIsophBBC6QxkBc9mwfNnESIiIiLioJCIiIiIiIiIiIiIlMECNREREREREREREREpggVqIiIiIiKFeHl5VTx8+LAuNccdPHjQPjP7ICIiIiJSAgvUREREREQKCA8PV0dERGgCAgISUzouIiJCHR4eblOpUqUUj8tIH0RERERESmGBmoiIiIhIASdPntT5+PgYdTqdfNNxXl5eSY6OjpbM6oOIiIiISCksUBMRERERvUZ0dLRKrVZXvnnzps3/Hjtx4oTWw8OjYlRUVIbG0qdOndL5+fkZAODu3buaBg0alHR3d/fX6/VvNWjQoGRkZKQKAE6fPq0rWrSosVu3bkWcnZ0rFS1atPyOHTsc/t3WrFmz8pUoUaKco6NjpTp16pS6e/eu5r99AMCFCxds69WrV9LV1dXfwcHhrRo1apTKyHsgIiIiIsooFqiJiIiIiF7D2dnZUqxYscQjR448X//5o48+KvThhx8+cHV1TfOM5n8LDQ21L1++fAIAREVFqYcOHfrozp07Z69fv342MjJS880333gAwLlz53Tnzp2zb9GiRXRkZOTpDh06PB48eHDR/7UzduxYr4ULF3r8/vvv18LDw88UKFAgadSoUQX/2wcAvPvuu8WCg4Ojw8PDzzx69Oj0xIkT72XkPRARERERZRQL1EREREREKfD3948PCQmxB4A//vjD4erVq7qRI0eGZ7TdCxcu6CpWrGgAgPLlyxvbtm0bo9PpZP78+ZPr1asXExUVpQGAixcv2g8cOPBhly5dotVqNYYMGRIRFhamNZlMuHv3rua7774rsGLFiuvly5c3arVa2b9//4jTp0/r/9sHANy6dcsuOTlZmM1mYW9vL5s0aRKf0fdBRERERJQRLFATEREREaUgMDAw/vTp0/YAMHbs2EKffPLJXa1W+8KazlWrVi0thKj8qq/KlSuX/m+bFosFV69e1QUGBhoAYOHCha4BAQF+bm5u/o6OjpVmz57t5evrmwgAV69e1Xbp0iXqf6998OCBxtHRMdnGxgZbtmxxMplMqpo1a5ZxdHSs5OjoWKlt27alHB0dk//bBwAsWLDgxtatW10KFChQsVOnTkUfPnyozqzzRkRERESUGhqlAxARERERZWfVqlWL/+GHH7wWL17sYjQaVQMHDoz87zHHjx+/nJY2L126ZKtSqaSvr2/Spk2bHCdMmFBo2bJl/9SoUSMBAAoVKlQxMDAw4cqVK7ZxcXHqAgUKmP/32jVr1rjWr18/GgAiIyPVjRs3jvrjjz+u/7ePCxcuPO/jf4+1atUqtlWrVrF3797VBAcHl5ozZ06+iRMnPkxLdiIiIiIia+IMaiIiIiKiFFSrVs0QERFh88knnxSePHnyHZUq40PokJAQe19fXwPwdCPDAgUKJAUFBRnCw8M1nTp18omMjNQEBAQkhoSE6NRqtVywYIFbcnIyVq5c6bxkyRKPKVOm3AOAKlWqJBw9etTx0KFD9gAQGRmpWrp0qYvFYnmhDwD49ddfXc6dO2dnsVjw5MkTdXR0tDogICDh1QmJiIiIiLIGZ1ATEREREaVAp9NJX19fg729vaVTp04x1mjz7NmzujJlyhgAoF+/fpEbN250c3Nzq1SyZElDcHBwdIkSJRK1Wq08e/asrl27do+PHDni4OLi4u3j42NcvXr1tQoVKhgBoFGjRvEjR46837lz5xJRUVEaR0fH5EaNGj3p3r37k3/3AQAHDx50GD16dJG4uDi1p6en6cMPP3zQqlWrWGu8HyIiIiKi9BJSyjcfRURERESksDNnzoT5+/tHZHW/iYmJolixYuWXLl16vWHDhtxU0ErOnDmTz9/f30fpHERERESkLC7xQURERESUgtGjR3sHBgbGsThNRERERGR9LFATEREREb3CoUOH7B0dHSv99ddfDnPnzr2tdB4iIiIiotyIa1ATEREREb1CrVq1EmJjY08rnYOIiIiIKDfjDGoiIiIiIiIiIiIiUgQL1ERERERERERERESkCBaoiYiIiIiIiIiIiEgRLFATERERERERERERkSJYoCYiIiIiIiIiIiIiRbBATURERERERERERESKYIGaiIiIiIiIiIiIiBTBAjURERERERERERERKYIFaiIiIiIiK3j48KG6cePGJXQ63Vve3t4Vfv75ZzelM2WladOmeZQvX76Mra1tQPv27X2UzkNEREREOYNG6QBEREREROlxv3xFf0tUVKaNZ1WuruYCoWfPpPb4fv36FbG1tZUPHjw4c/ToUfsOHTqUDAwMTAgMDEzMrIwAEPzFn/7RBlOmnQdnnY15x9gGbzwPBQsWNI0ZM+b+9u3bnRITEzkRhoiIiIhShQVqIiIiIsqRMrM4ndb2Y2JiVNu3b3cNCQk57+zsbAkODo5r2LBh9MKFC90DAwPvZmbOzCxOp6X9nj17PgGAEydO2N+9e9c2MzMRERERUe7BmQ1ERERERBl07tw5O41GIytWrGj832MVK1ZMuHTpkk7JXERERERE2R0L1EREREREGRQbG6vW6/WWfz/m7OycHBcXp1YqExERERFRTsACNRERERFRBjk6OibHx8e/MLaOiYlROzg4JCuViYiIiIgoJ2CBmoiIiIgogypUqGA0m83i3Llzdv977OzZszo/Pz+DkrmIiIiIiLI7FqiJiIiIiDLIycnJEhwc/OTjjz/2jomJUe3cuVO/e/dulz59+jxWOltWMZlMSEhIEMnJySI5OVkkJCQIk8mkdCwiIiIiyuZYoCYiIiIisoIFCxbcNBgMqvz58/v37Nmz+MyZM28FBgYmKp0rq4wZM8Zbr9cH/PTTT16///67m16vDxgzZoy30rmIiIiIKHvTKB2AiIiIiCg9VK6uZktUVKaNZ1Wurua0HJ8/f/7k3bt3/5NZeV7HWWdjjjaYMu08OOtsUnUevv7663tff/31vczKQURERES5EwvURERERJQjFQg9e0bpDNnBjrENeB6IiIiIKMfiEh9EREREREREREREpAgWqImIiIiIiIiIiIhIESxQExEREREREREREZEiWKAmIiIiopxCSimVzkBWYLFYBACL0jmIiIiISHksUBMRERFRjiCEiE5KSrJROgdlnMFg0AohHiidg4iIiIiUxwI1EREREeUIycnJi+7du6d/NvuWciCLxSLi4+N1YWFhtmazeZLSeYiIiIhIeYK3SRIRERFRThASEmKr0WjmAagFQK10HkoXixDigdlsnhQQELBD6TBEREREpDwWqImIiIiIiIiIiIhIEVzig4iIiIiIiIiIiIgUwQI1ERERERERERERESmCBWoiIiIiIiIiIiIiUgQL1ERERERERERERESkCBaoiYiIiIiIiIiIiEgR/wc4lUPp+BJDgQAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -248,6 +239,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "dce9b1d3", "metadata": {}, @@ -256,6 +248,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "3d6bbcac", "metadata": {}, @@ -272,18 +265,11 @@ "metadata": {}, "outputs": [ { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "56806ebeaca4424587b44d08cf6d3fb3", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Model fitting: 0%| | 0/50 [00:00" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -352,6 +337,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "779b9394", "metadata": {}, @@ -367,24 +353,12 @@ "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "" + "
" ] }, - "execution_count": 12, "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, "output_type": "display_data" } ], @@ -395,10 +369,11 @@ "\n", "cm = confusion_matrix(test_data[1], pred_y_test)\n", "disp = ConfusionMatrixDisplay(confusion_matrix=cm)\n", - "disp.plot()" + "disp.plot();" ] }, { + "attachments": {}, "cell_type": "markdown", "id": "ab0b0cf8", "metadata": {}, @@ -407,6 +382,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "416eb518", "metadata": {}, @@ -424,6 +400,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "62564ecc", "metadata": {}, @@ -443,6 +420,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "0bc2b6ff", "metadata": {}, @@ -472,6 +450,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "d1e98dc2", "metadata": {}, @@ -495,6 +474,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "f22020de", "metadata": {}, @@ -510,24 +490,12 @@ "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "" + "
" ] }, - "execution_count": 16, "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, "output_type": "display_data" } ], @@ -541,10 +509,11 @@ " suptitle=\"Influences of input points\",\n", " legend_title=\"influence values\",\n", " # colorbar_limits=(-0.3,),\n", - ")" + ");" ] }, { + "attachments": {}, "cell_type": "markdown", "id": "2d262071", "metadata": {}, @@ -553,6 +522,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "8989f90c", "metadata": {}, @@ -595,8 +565,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average mislabelled data influence: -0.7102711705390644\n", - "Average correct data influence: 0.009479014696434519\n" + "Average mislabelled data influence: -0.7792411677556543\n", + "Average correct data influence: 0.0076227822067402706\n" ] } ], @@ -613,24 +583,12 @@ "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "" + "
" ] }, - "execution_count": 19, "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, "output_type": "display_data" } ], @@ -645,10 +603,11 @@ " suptitle=\"Influences of input points with corrupted data\",\n", " legend_title=\"influence values\",\n", " # colorbar_limits=(-0.3,),\n", - ")" + ");" ] }, { + "attachments": {}, "cell_type": "markdown", "id": "80f76c03", "metadata": {}, @@ -657,6 +616,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "38a7f17f", "metadata": {}, @@ -665,6 +625,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "fe10a49c", "metadata": {}, @@ -681,67 +642,28 @@ "metadata": {}, "outputs": [ { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "9cc1439cea994625ba7508e6f0fa226e", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Batch Test Gradients: 0%| | 0/8 [00:00" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -802,6 +723,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "bfcbebd9", "metadata": {}, @@ -862,7 +784,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.9.16" }, "vscode": { "interpreter": { diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index 0e39af38c..6836aa789 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -1,6 +1,7 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "id": "a75acfec", "metadata": {}, @@ -13,6 +14,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "68ec440b", "metadata": {}, @@ -21,6 +23,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "9eb29a26", "metadata": {}, @@ -40,22 +43,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "be813151", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/fabio/.local/lib/python3.8/site-packages/torchvision/io/image.py:13: UserWarning: Failed to load image Python extension: dlopen(/Users/fabio/.local/lib/python3.8/site-packages/torchvision/image.so, 6): Symbol not found: __ZN3c106detail19maybe_wrap_dim_slowExxb\n", - " Referenced from: /Users/fabio/.local/lib/python3.8/site-packages/torchvision/image.so\n", - " Expected in: /Users/fabio/.local/lib/python3.8/site-packages/torch/lib/libc10.dylib\n", - " in /Users/fabio/.local/lib/python3.8/site-packages/torchvision/image.so\n", - " warn(f\"Failed to load image Python extension: {e}\")\n" - ] - } - ], + "outputs": [], "source": [ "%autoreload\n", "%matplotlib inline\n", @@ -90,6 +81,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "7487d30c", "metadata": {}, @@ -120,6 +112,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "be7ddf7c", "metadata": {}, @@ -143,6 +136,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "b96a15cc", "metadata": {}, @@ -185,6 +179,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "a018e72c", "metadata": {}, @@ -201,18 +196,11 @@ "metadata": {}, "outputs": [ { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e66b7ce90e0c43d18a94be867c19edca", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Model fitting: 0%| | 0/300 [00:00" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -274,6 +261,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "b3345522", "metadata": {}, @@ -289,14 +277,12 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -310,6 +296,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "cca76db8", "metadata": {}, @@ -339,6 +326,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "5332e2b4", "metadata": {}, @@ -347,6 +335,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "45dbdd1e", "metadata": {}, @@ -364,46 +353,13 @@ "metadata": {}, "outputs": [ { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "92bfe19a467c4873a8410ffd24bfb875", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Batch Test Gradients: 0%| | 0/4 [00:00" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -483,6 +440,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "8dd63529", "metadata": {}, @@ -500,8 +458,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average influence of corrupted points: -0.053527612\n", - "Average influence of other points: 0.034987032\n" + "Average influence of corrupted points: -0.05458507\n", + "Average influence of other points: 0.035084754\n" ] } ], @@ -517,6 +475,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "f1e747b1", "metadata": {}, @@ -525,6 +484,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "b00a6164", "metadata": {}, @@ -539,46 +499,13 @@ "metadata": {}, "outputs": [ { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "3558af103c304e5a8ff3616a0989736a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Batch Test Gradients: 0%| | 0/4 [00:00" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -616,7 +541,7 @@ "mean_feature_influences = np.mean(feature_influences.numpy(), axis=(0, 1))\n", "\n", "_, ax = plt.subplots()\n", - "ax.plot(feature_names, mean_feature_influences)\n", + "ax.bar(feature_names, mean_feature_influences)\n", "ax.set_xlabel(\"training features\")\n", "ax.set_ylabel(\"influence values\")\n", "ax.set_title(\"Average feature influence\")\n", @@ -625,6 +550,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "656e14dd", "metadata": {}, @@ -633,6 +559,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "3bf8c4dd", "metadata": {}, @@ -647,60 +574,14 @@ "metadata": {}, "outputs": [ { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "94839462e31841d6a1531cd173dfa338", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Batch Test Gradients: 0%| | 0/4 [00:00 torch.Tensor: +def flatten_all(grad: torch.Tensor) -> torch.Tensor: """ Simple function to flatten a pyTorch gradient for use in subsequent calculation """ @@ -40,7 +43,7 @@ def solve_linear( training_data: DataLoader, b: torch.Tensor, *, - lam: float = 0.0, + hessian_perturbation: float = 0.0, progress: bool = False, ) -> torch.Tensor: """Given a model and training data, it finds x s.t. $Hx = b$, with $H$ being @@ -49,7 +52,7 @@ def solve_linear( :param model: A model wrapped in the TwiceDifferentiable interface. :param training_data: A DataLoader containing the training data. :param b: a vector or matrix, the right hand side of the equation $Hx = b$. - :param lam: regularization of the hessian + :param hessian_perturbation: regularization of the hessian :param progress: If True, display progress bars. :return: An array that solves the inverse problem, @@ -61,9 +64,9 @@ def solve_linear( all_y.append(y) all_x = cat(all_x) all_y = cat(all_y) - matrix = model.hessian(all_x, all_y, progress=progress) + lam * identity_tensor( - model.num_params - ) + matrix = model.hessian( + all_x, all_y, progress=progress + ) + hessian_perturbation * identity_tensor(model.num_params) return torch.linalg.solve(matrix, b.T).T @@ -72,7 +75,7 @@ def solve_batch_cg( training_data: DataLoader, b: torch.Tensor, *, - lam: float = 0.0, + hessian_perturbation: float = 0.0, x0: Optional[torch.Tensor] = None, rtol: float = 1e-7, atol: float = 1e-7, @@ -82,13 +85,13 @@ def solve_batch_cg( """ Given a model and training data, it uses conjugate gradient to calculate the inverse of the Hessian Vector Product. More precisely, it finds x s.t. $Hx = - b$, with $H$ being the model hessian. For more info: - https://en.wikipedia.org/wiki/Conjugate_gradient_method + b$, with $H$ being the model hessian. For more info, see + `Wikipedia `_ :param model: A model wrapped in the TwiceDifferentiable interface. :param training_data: A DataLoader containing the training data. :param b: a vector or matrix, the right hand side of the equation $Hx = b$. - :param lam: regularization of the hessian + :param hessian_perturbation: regularization of the hessian :param x0: initial guess for hvp. If None, defaults to b :param rtol: maximum relative tolerance of result :param atol: absolute tolerance of result @@ -106,7 +109,7 @@ def solve_batch_cg( backprop_on = model.parameters reg_hvp = lambda v: mvp( total_grad_xy / total_points, v, backprop_on - ) + lam * v.type(torch.float64) + ) + hessian_perturbation * v.type(torch.float64) batch_cg = torch.zeros_like(b) for idx, bi in enumerate(maybe_progress(b, progress, desc="Conjugate gradient")): bi_cg, _ = solve_cg(reg_hvp, bi, x0=x0, rtol=rtol, atol=atol, maxiter=maxiter) @@ -168,9 +171,9 @@ def solve_lissa( training_data: DataLoader, b: torch.Tensor, *, - lam: float = 0.0, + hessian_perturbation: float = 0.0, maxiter: int = 1000, - damp: float = 0.0, + dampen: float = 0.0, scale: float = 10.0, h0: Optional[torch.Tensor] = None, rtol: float = 1e-4, @@ -184,17 +187,20 @@ def solve_lissa( $$ H^{-1}_{j+1} b = b + (I - H) \ H^{-1}_j b $$ - where I is the identity matrix. Additional damping and scaling factors are - applied to help convergence. More info can be found in - :footcite:t:`koh_understanding_2017` + where I is the identity matrix. Additional dampening and scaling factors are + applied to help convergence, i.e. + $$ + H^{-1}_{j+1} b = b + (I - d) \ H - \frac{H^{-1}_j b}{s} + $$ + More info can be found in :footcite:t:`koh_understanding_2017` :param model: A model wrapped in the TwiceDifferentiable interface. :param training_data: A DataLoader containing the training data. :param b: a vector or matrix, the right hand side of the equation $Hx = b$. - :param lam: regularization of the hessian + :param hessian_perturbation: regularization of the hessian :param progress: If True, display progress bars. :param maxiter: maximum number of iterations, - :param damp: damping factor, defaults to 0 for no damping + :param dampen: dampening factor, defaults to 0 for no dampening :param scale: scaling factor, defaults to 10 :param h0: initial guess for hvp @@ -207,15 +213,27 @@ def solve_lissa( shuffled_training_data = DataLoader( training_data.dataset, training_data.batch_size, shuffle=True ) - lissa_step = lambda h: b + (1 - damp) * h - reg_hvp(h) / scale # type: ignore + + def lissa_step( + h: torch.Tensor, reg_hvp: Callable[[torch.Tensor], torch.Tensor] + ) -> torch.Tensor: + """Given an estimate of the hessian inverse and the regularised hessian + vector product, it computes the next estimate. + + :param h: an estimate of the hessian inverse + :param reg_hvp: regularised hessian vector product + :return: the next estimate of the hessian inverse + """ + return b + (1 - dampen) * h - reg_hvp(h) / scale + for _ in maybe_progress(range(maxiter), progress, desc="Lissa"): x, y = next(iter(shuffled_training_data)) grad_xy, _ = model.grad(x, y) - reg_hvp = lambda v: mvp(grad_xy, v, model.parameters) + lam * v - residual = lissa_step(h_estimate) - h_estimate + reg_hvp = lambda v: mvp(grad_xy, v, model.parameters) + hessian_perturbation * v + residual = lissa_step(h_estimate, reg_hvp) - h_estimate h_estimate += residual if torch.isnan(h_estimate).any(): - raise RuntimeError("NaNs in h_estimate. Increase scale or damp.") + raise RuntimeError("NaNs in h_estimate. Increase scale or dampening.") max_residual = torch.max(torch.abs(residual / h_estimate)) if max_residual < rtol: break diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 63e5b2768..b11925b88 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -96,6 +96,7 @@ def test_influence_linear_model( problem_dimension: Tuple[int, int] = (3, 15), condition_number: float = 3, ): + A, b = linear_model(problem_dimension, condition_number) train_data, test_data = add_noise_to_linear_model( (A, b), train_set_size, test_set_size @@ -122,40 +123,22 @@ def test_influence_linear_model( batch_size=40, ) - direct_influences = compute_influences( - TorchTwiceDifferentiable(linear_layer, loss), - training_data=train_data_loader, - test_data=test_data_loader, - input_data=input_data, - progress=True, - influence_type=influence_type, - inversion_method="direct", - hessian_regularization=hessian_reg, - ).numpy() + def compute_method_influence(method: InversionMethod): + return compute_influences( + TorchTwiceDifferentiable(linear_layer, loss), + training_data=train_data_loader, + test_data=test_data_loader, + input_data=input_data, + progress=True, + influence_type=influence_type, + inversion_method=method, + hessian_regularization=hessian_reg, + ).numpy() - cg_influences = compute_influences( - TorchTwiceDifferentiable(linear_layer, loss), - training_data=train_data_loader, - test_data=test_data_loader, - input_data=input_data, - progress=True, - influence_type=influence_type, - inversion_method="cg", - hessian_regularization=hessian_reg, - ).numpy() + direct_influences = compute_method_influence(InversionMethod.Direct) + cg_influences = compute_method_influence(InversionMethod.ConjugateGradient) + lissa_influences = compute_method_influence(InversionMethod.Lissa) - lissa_influences = compute_influences( - TorchTwiceDifferentiable(linear_layer, loss), - training_data=train_data_loader, - test_data=test_data_loader, - input_data=input_data, - progress=True, - influence_type=influence_type, - inversion_method="lissa", - maxiter=5000, - scale=100, - hessian_regularization=hessian_reg, - ).numpy() assert np.logical_not(np.any(np.isnan(direct_influences))) assert np.logical_not(np.any(np.isnan(cg_influences))) assert np.allclose(direct_influences, analytical_influences, rtol=1e-7) From 33818cc2ae6ec7e3dd47d4a4ae7a152d7ac5c156 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Mon, 15 May 2023 11:51:39 +0200 Subject: [PATCH 059/436] refactor test and minor doc changes --- .../frameworks/torch_differentiable.py | 8 +-- src/pydvl/influence/general.py | 13 ++--- src/pydvl/influence/inversion.py | 12 ++--- tests/influence/test_influences.py | 51 ++++++++++--------- 4 files changed, 43 insertions(+), 41 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index e8b4c7323..215b9e742 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -185,14 +185,10 @@ def solve_lissa( the model hessian. This is done by iteratively approximating H through $$ - H^{-1}_{j+1} b = b + (I - H) \ H^{-1}_j b - $$ - where I is the identity matrix. Additional dampening and scaling factors are - applied to help convergence, i.e. - $$ H^{-1}_{j+1} b = b + (I - d) \ H - \frac{H^{-1}_j b}{s} $$ - More info can be found in :footcite:t:`koh_understanding_2017` + where I is the identity matrix, d is a dampening term and s a scaling factor that + are applied to help convergence. More info can be found in :footcite:t:`koh_understanding_2017` :param model: A model wrapped in the TwiceDifferentiable interface. :param training_data: A DataLoader containing the training data. diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 51a1c9e11..5a1c05dcd 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -37,7 +37,7 @@ def compute_influence_factors( test_data: DataLoaderType, inversion_method: InversionMethod, *, - lam: float = 0.0, + hessian_perturbation: float = 0.0, progress: bool = False, **kwargs: Any, ) -> TensorType: @@ -50,15 +50,16 @@ def compute_influence_factors( used for efficient influence calculation. This method first (implicitly) calculates the Hessian and then (explicitly) finds the influence factors for the model using the given inversion method. The - parameter ``lam`` is used to regularize the inversion of the Hessian. For - more info, refer to :footcite:t:`koh_understanding_2017`, paragraph 3. + parameter ``hessian_perturbation`` is used to regularize the inversion of + the Hessian. For more info, refer to :footcite:t:`koh_understanding_2017`, + paragraph 3. :param model: A model wrapped in the TwiceDifferentiable interface. :param training_data: A DataLoader containing the training data. :param test_data: A DataLoader containing the test data. :param inversion_func: function to use to invert the product of hvp (hessian vector product) and the gradient of the loss (s_test in the paper). - :param lam: regularization of the hessian + :param hessian_perturbation: regularization of the hessian :param progress: If True, display progress bars. :returns: An array of size (N, D) containing the influence factors for each dimension (D) and test sample (N). @@ -74,7 +75,7 @@ def compute_influence_factors( model, training_data, test_grads, - lam=lam, + hessian_perturbation=hessian_perturbation, progress=progress, **kwargs, ) @@ -211,7 +212,7 @@ def compute_influences( training_data, test_data, inversion_method, - lam=hessian_regularization, + hessian_perturbation=hessian_regularization, progress=progress, **kwargs, ) diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 352a99d2d..4cd48571b 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -36,7 +36,7 @@ def solve_hvp( training_data: DataLoaderType, b: TensorType, *, - lam: float = 0.0, + hessian_perturbation: float = 0.0, progress: bool = False, **kwargs: Any, ) -> TensorType: @@ -45,7 +45,7 @@ def solve_hvp( and $b$ a vector. Depending on the inversion method, the hessian is either calculated directly and then inverted, or implicitly and then inverted through matrix vector - product. The method also allows to add a small regularization term (lam) + product. The method also allows to add a small regularization term (hessian_perturbation) to facilitate inversion of non fully trained models. :param inversion_method: @@ -54,7 +54,7 @@ def solve_hvp( :param y: labels for x :param b: Array as the right hand side of the equation $Ax = b$ :param kwargs: kwargs to pass to the inversion method - :param lam: regularization of the hessian + :param hessian_perturbation: regularization of the hessian :param progress: If True, display progress bars. :return: An array that solves the inverse problem, @@ -66,7 +66,7 @@ def solve_hvp( training_data, b, **kwargs, - lam=lam, + hessian_perturbation=hessian_perturbation, progress=progress, ) elif inversion_method == InversionMethod.Cg: @@ -75,7 +75,7 @@ def solve_hvp( training_data, b, **kwargs, - lam=lam, + hessian_perturbation=hessian_perturbation, progress=progress, ) elif inversion_method == InversionMethod.Lissa: @@ -84,7 +84,7 @@ def solve_hvp( training_data, b, **kwargs, - lam=lam, + hessian_perturbation=hessian_perturbation, progress=progress, ) else: diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index b11925b88..4a2759148 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -1,5 +1,5 @@ import itertools -from typing import List, Tuple +from typing import Dict, Tuple import numpy as np import pytest @@ -88,8 +88,20 @@ def analytical_linear_influences( [200], ids=["train_set_size_200"], ) +@pytest.mark.parametrize( + "inversion_method, inversion_method_kwargs, rtol", + [ + [InversionMethod.Direct, {}, 1e-7], + [InversionMethod.Cg, {}, 1e-1], + [InversionMethod.Lissa, {"maxiter": 5000, "scale": 100}, 0.3], + ], + ids=[inv.value for inv in InversionMethod], +) def test_influence_linear_model( influence_type: InfluenceType, + inversion_method: InversionMethod, + inversion_method_kwargs: Dict, + rtol: float, train_set_size: int, hessian_reg: float = 0.1, test_set_size: int = 20, @@ -123,32 +135,25 @@ def test_influence_linear_model( batch_size=40, ) - def compute_method_influence(method: InversionMethod): - return compute_influences( - TorchTwiceDifferentiable(linear_layer, loss), - training_data=train_data_loader, - test_data=test_data_loader, - input_data=input_data, - progress=True, - influence_type=influence_type, - inversion_method=method, - hessian_regularization=hessian_reg, - ).numpy() - - direct_influences = compute_method_influence(InversionMethod.Direct) - cg_influences = compute_method_influence(InversionMethod.ConjugateGradient) - lissa_influences = compute_method_influence(InversionMethod.Lissa) + influence_values = compute_influences( + TorchTwiceDifferentiable(linear_layer, loss), + training_data=train_data_loader, + test_data=test_data_loader, + input_data=input_data, + progress=True, + influence_type=influence_type, + inversion_method=inversion_method, + hessian_regularization=hessian_reg, + **inversion_method_kwargs, + ).numpy() - assert np.logical_not(np.any(np.isnan(direct_influences))) - assert np.logical_not(np.any(np.isnan(cg_influences))) - assert np.allclose(direct_influences, analytical_influences, rtol=1e-7) - assert np.allclose(cg_influences, analytical_influences, rtol=1e-1) - abs_influence = np.abs(lissa_influences) + assert np.logical_not(np.any(np.isnan(influence_values))) + abs_influence = np.abs(influence_values) upper_quantile_mask = abs_influence > np.quantile(abs_influence, 0.9) assert np.allclose( - lissa_influences[upper_quantile_mask], + influence_values[upper_quantile_mask], analytical_influences[upper_quantile_mask], - rtol=0.1, + rtol=rtol, ) From ef6c82f09c28dc4bbe0ab17201d2607a3aab3541 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 15 May 2023 13:04:36 +0200 Subject: [PATCH 060/436] Initial work to migrate docs to mkdocs --- .github/workflows/tox.yaml | 2 +- .gitignore | 3 + build_scripts/generate_api_docs.py | 29 ++ ...ting-started.rst => 10-getting-started.md} | 31 +- docs/20-install.md | 79 +++ docs/20-install.rst | 78 --- ...ata-valuation.rst => 30-data-valuation.md} | 479 ++++++++---------- docs/{40-influence.rst => 40-influence.md} | 126 +++-- docs/assets/elsevier-harvard.csl | 239 +++++++++ docs/assets/logo.svg | 201 ++++++++ docs/{ => assets}/pydvl.bib | 0 docs/{index.rst => index.md} | 19 +- docs/javascripts/mathjax.js | 16 + docs/overrides/main.html | 9 + docs/pydvl/index.rst | 11 - docs/stylesheets/extra.css | 47 ++ mkdocs.yml | 123 +++++ requirements-docs.txt | 12 + src/pydvl/influence/conjugate_gradient.py | 2 - src/pydvl/utils/utility.py | 189 +++---- tox.ini | 18 +- 21 files changed, 1165 insertions(+), 548 deletions(-) create mode 100644 build_scripts/generate_api_docs.py rename docs/{10-getting-started.rst => 10-getting-started.md} (54%) create mode 100644 docs/20-install.md delete mode 100644 docs/20-install.rst rename docs/{30-data-valuation.rst => 30-data-valuation.md} (67%) rename docs/{40-influence.rst => 40-influence.md} (53%) create mode 100644 docs/assets/elsevier-harvard.csl create mode 100644 docs/assets/logo.svg rename docs/{ => assets}/pydvl.bib (100%) rename docs/{index.rst => index.md} (91%) create mode 100644 docs/javascripts/mathjax.js create mode 100644 docs/overrides/main.html delete mode 100644 docs/pydvl/index.rst create mode 100644 docs/stylesheets/extra.css create mode 100644 mkdocs.yml create mode 100644 requirements-docs.txt diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index 26e83fa80..718370422 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -126,7 +126,7 @@ jobs: uses: actions/download-artifact@v3 with: name: docs - path: ./docs/_build + path: ./docs_build - name: Deploy Docs uses: peaceiris/actions-gh-pages@v3 if: ${{ github.ref == 'refs/heads/develop' }} diff --git a/.gitignore b/.gitignore index 1ee9bb1d2..7445020d2 100644 --- a/.gitignore +++ b/.gitignore @@ -139,3 +139,6 @@ pylint.html # Saved data runs/ data/models/ + +# Docs +docs_build diff --git a/build_scripts/generate_api_docs.py b/build_scripts/generate_api_docs.py new file mode 100644 index 000000000..7558c3504 --- /dev/null +++ b/build_scripts/generate_api_docs.py @@ -0,0 +1,29 @@ +"""Generate the code reference pages.""" +from pathlib import Path +import mkdocs_gen_files + +nav = mkdocs_gen_files.Nav() + +for path in sorted(Path("src").rglob("*.py")): + module_path = path.relative_to("src").with_suffix("") + doc_path = path.relative_to("src").with_suffix(".md") + full_doc_path = Path("code-reference") / doc_path + parts = tuple(module_path.parts) + + if parts[-1] == "__init__": + parts = parts[:-1] + doc_path = doc_path.with_name("index.md") + full_doc_path = full_doc_path.with_name("index.md") + elif parts[-1] == "__main__": + continue + + nav[parts] = doc_path.as_posix() + + with mkdocs_gen_files.open(full_doc_path, "w") as fd: + identifier = ".".join(parts) + fd.write(f"::: {identifier}") + + mkdocs_gen_files.set_edit_path(full_doc_path, path) + +with mkdocs_gen_files.open("code-reference/SUMMARY.md", "w") as nav_file: + nav_file.writelines(nav.build_literate_nav()) diff --git a/docs/10-getting-started.rst b/docs/10-getting-started.md similarity index 54% rename from docs/10-getting-started.rst rename to docs/10-getting-started.md index 16b58185d..68ea55f09 100644 --- a/docs/10-getting-started.rst +++ b/docs/10-getting-started.md @@ -1,34 +1,37 @@ -.. _getting started: +--- +title: Getting Started +alias: + name: getting-started + text: Getting Started +--- -=============== -Getting started -=============== +# Getting started -.. warning:: - Make sure you have read :ref:`the installation instructions - ` before using the library. In particular read about how - caching and parallelization work, since they require additional setup. +!!! Warning + + Make sure you have read [[installation]] before using the library. + In particular read about how caching and parallelization work, + since they require additional setup. pyDVL aims to be a repository of production-ready, reference implementations of algorithms for data valuation and influence functions. You can read: -* :ref:`data valuation` for key objects and usage patterns for Shapley value +* [[data-valuation]] for key objects and usage patterns for Shapley value computation and related methods. -* :ref:`influence` for instructions on how to compute influence functions (still +* [[influence-values]] for instructions on how to compute influence functions (still in a pre-alpha state) We only briefly introduce key concepts in the documentation. For a thorough introduction and survey of the field, we refer to **the upcoming review** at the -:tfl:`TransferLab website `. +[TransferLab website](https://transferlab.appliedai.de/reviews/data-valuation). -Running the examples -==================== +# Running the examples If you are somewhat familiar with the concepts of data valuation, you can start by browsing our worked-out examples illustrating pyDVL's capabilities either: - :ref:`In this documentation`. -- Using `binder `_ notebooks, deployed from each +- Using [binder](https://mybinder.org/>) notebooks, deployed from each example's page. - Locally, by starting a jupyter server at the root of the project. You will have to install jupyter first manually since it's not a dependency of the diff --git a/docs/20-install.md b/docs/20-install.md new file mode 100644 index 000000000..cfca87ed4 --- /dev/null +++ b/docs/20-install.md @@ -0,0 +1,79 @@ +--- +title: Installing pyDVL +alias: + name: installation + text: Installing pyDVL +--- + +# Installing pyDVL + +To install the latest release use: + +```shell +pip install pyDVL +``` + +To use all features of influence functions use instead: + +```shell +pip install pyDVL[influence] +``` + +This includes a dependency on [PyTorch](https://pytorch.org/) and thus is left +out by default. + +In order to check the installation you can use: + +```shell +python -c "import pydvl; print(pydvl.__version__)" +``` + +You can also install the latest development version from +[TestPyPI](https://test.pypi.org/project/pyDVL/): + +```shell +pip install pyDVL --index-url https://test.pypi.org/simple/ +``` + +# Dependencies + +pyDVL requires Python >= 3.8, [Memcached](https://memcached.org/) for caching +and [Ray](https://ray.io) for parallelization. Additionally, +:mod:`Influence functions` requires PyTorch (see +:ref:`pyDVL Installation`). + +ray is used to distribute workloads both locally and across nodes. Please follow +the instructions in their documentation for installation. + +.. _caching setup: + +# Setting up the cache + +memcached is an in-memory key-value store accessible over the network. pyDVL +uses it to cache certain results and speed-up the computations. You can either +install it as a package or run it inside a docker container (the simplest). For +installation instructions, refer to the [Getting started](https://github.com/ +memcached/memcached/wiki#getting-started) section +in memcached's wiki. Then you can run it with: + +```shell +memcached -u user +``` + +To run memcached inside a container in daemon mode instead, do: + +```shell +docker container run -d --rm -p 11211:11211 memcached:latest +``` + +!!! Warning + + To read more about caching and how it might affect your usage, in particular + about cache reuse and its pitfalls, please the documentation for the module + :mod:`pydvl.utils.caching`. + +# What's next + +- Read on [[data-valuation]] +- Read on [[influence-values]] +- Browse the [[examples]] diff --git a/docs/20-install.rst b/docs/20-install.rst deleted file mode 100644 index e803487aa..000000000 --- a/docs/20-install.rst +++ /dev/null @@ -1,78 +0,0 @@ -.. _pyDVL Installation: - -================ -Installing pyDVL -================ - -To install the latest release use: - -.. code-block:: shell - - pip install pyDVL - -To use all features of influence functions use instead: - -.. code-block:: shell - - pip install pyDVL[influence] - -This includes a dependency on `PyTorch `_ and thus is left -out by default. - -In order to check the installation you can use: - -.. code-block:: shell - - python -c "import pydvl; print(pydvl.__version__)" - -You can also install the latest development version from -`TestPyPI `_: - -.. code-block:: shell - - pip install pyDVL --index-url https://test.pypi.org/simple/ - -Dependencies -============ - -pyDVL requires Python >= 3.8, `Memcached `_ for caching -and `ray `_ for parallelization. Additionally, -:mod:`Influence functions` requires PyTorch (see -:ref:`pyDVL Installation`). - -ray is used to distribute workloads both locally and across nodes. Please follow -the instructions in their documentation for installation. - -.. _caching setup: - -Setting up the cache -==================== - -memcached is an in-memory key-value store accessible over the network. pyDVL -uses it to cache certain results and speed-up the computations. You can either -install it as a package or run it inside a docker container (the simplest). For -installation instructions, refer to `Getting started -`_ in memcached's -wiki. Then you can run it with: - -.. code-block:: shell - - memcached -u user - -To run memcached inside a container in daemon mode instead, do: - -.. code-block:: shell - - docker container run -d --rm -p 11211:11211 memcached:latest - -.. warning:: - To read more about caching and how it might affect your usage, in particular - about cache reuse and its pitfalls, please the documentation for the module - :mod:`pydvl.utils.caching`. - -What's next -=========== - -- Read on :ref:`data valuation`. -- Read on :ref:`influence functions `. -- Browse the :ref:`examples`. diff --git a/docs/30-data-valuation.rst b/docs/30-data-valuation.md similarity index 67% rename from docs/30-data-valuation.rst rename to docs/30-data-valuation.md index b2ca10224..7fd6bd360 100644 --- a/docs/30-data-valuation.rst +++ b/docs/30-data-valuation.md @@ -1,8 +1,11 @@ -.. _data valuation: +--- +title: Computing Data Values +alias: + name: data-valuation + text: Computing Data Values +--- -===================== -Computing data values -===================== +# Computing Data Values **Data valuation** is the task of assigning a number to each element of a training set which reflects its contribution to the final performance of a @@ -23,47 +26,44 @@ interest, but a function of three factors: pyDVL collects algorithms for the computation of data values in this sense, mostly those derived from cooperative game theory. The methods can be found in -the package :mod:`~pydvl.value`, with support from modules +the package ::: pydvl.value , with support from modules :mod:`pydvl.utils.dataset` and :mod:`~pydvl.utils.utility`, as detailed below. -.. warning:: - Be sure to read the section on - :ref:`the difficulties using data values `. +!!! Warning -Creating a Dataset -================== + Be sure to read the section on + [the difficulties using data values][problems-of-data-values]. + +## Creating a Dataset The first item in the tuple $(D, \mathcal{A}, u)$ characterising data value is -the dataset. The class :class:`~pydvl.utils.dataset.Dataset` is a simple +the dataset. The class [Dataset][pydvl.utils.dataset.Dataset] is a simple convenience wrapper for the train and test splits that is used throughout pyDVL. The test set will be used to evaluate a scoring function for the model. It can be used as follows: -.. code-block:: python - - import numpy as np - from pydvl.utils import Dataset - from sklearn.model_selection import train_test_split - - X, y = np.arange(100).reshape((50, 2)), np.arange(50) - X_train, X_test, y_train, y_test = train_test_split( - X, y, test_size=0.5, random_state=16 - ) - - dataset = Dataset(X_train, X_test, y_train, y_test) +```python +import numpy as np +from pydvl.utils import Dataset +from sklearn.model_selection import train_test_split +X, y = np.arange(100).reshape((50, 2)), np.arange(50) +X_train, X_test, y_train, y_test = train_test_split( + X, y, test_size=0.5, random_state=16 +) +dataset = Dataset(X_train, X_test, y_train, y_test) +``` It is also possible to construct Datasets from sklearn toy datasets for illustrative purposes using :meth:`~pydvl.utils.dataset.Dataset.from_sklearn`. -Grouping data -^^^^^^^^^^^^^ +### Grouping data Be it because data valuation methods are computationally very expensive, or because we are interested in the groups themselves, it can be often useful or necessary to group samples so as to valuate them together. -:class:`~pydvl.utils.dataset.GroupedDataset` provides an alternative to -`Dataset` with the same interface which allows this. +[GroupedDataset][pydvl.utils.dataset.GroupedDataset] provides an alternative to +[Dataset][] with the same interface which allows this. You can see an example in action in the :doc:`Spotify notebook `, but here's a simple @@ -71,15 +71,16 @@ example grouping a pre-existing `Dataset`. First we construct an array mapping each index in the dataset to a group, then use :meth:`~pydvl.utils.dataset.GroupedDataset.from_dataset`: -.. code-block:: python +```python +import numpy as np +from pydvl.utils import GroupedDataset - # Randomly assign elements to any one of num_groups: - data_groups = np.random.randint(0, num_groups, len(dataset)) - grouped_dataset = GroupedDataset.from_dataset(dataset, data_groups) - grouped_utility = Utility(model=model, data=grouped_dataset) +# Randomly assign elements to any one of num_groups: +data_groups = np.random.randint(0, num_groups, len(dataset)) +grouped_dataset = GroupedDataset.from_dataset(dataset, data_groups) +``` -Creating a Utility -================== +## Creating a Utility In pyDVL we have slightly overloaded the name "utility" and use it to refer to an object that keeps track of all three items in $(D, \mathcal{A}, u)$. This @@ -89,14 +90,14 @@ valuation methods. Here's a minimal example: -.. code-block:: python +```python +import sklearn as sk +from pydvl.utils import Dataset, Utility - from pydvl.utils import Dataset, Utility - import sklearn as sk - - dataset = Dataset.from_sklearn(sk.datasets.load_iris()) - model = sk.svm.SVC() - utility = Utility(model, dataset) +dataset = Dataset.from_sklearn(sk.datasets.load_iris()) +model = sk.svm.SVC() +utility = Utility(model, dataset) +``` The object `utility` is a callable that data valuation methods will execute with different subsets of training data. Each call will retrain the model on a @@ -104,13 +105,12 @@ subset and evaluate it on the test data using a scoring function. By default, :class:`~pydvl.utils.utility.Utility` will use `model.score()`, but it is possible to use any scoring function (greater values must be better). In particular, the constructor accepts the same types as argument as sklearn's -`cross_validate() `_: +[cross_validate()](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.cross_validate.html>): a string, a scorer callable or `None` for the default. -.. code-block:: python - - utility = Utility(model, dataset, "explained_variance") - +```python +utility = Utility(model, dataset, "explained_variance") +``` `Utility` will wrap the `fit()` method of the model to cache its results. This greatly reduces computation times of Monte Carlo methods. Because of how caching @@ -118,8 +118,7 @@ is implemented, it is important not to reuse `Utility` objects for different datasets. You can read more about :ref:`caching setup` in the installation guide and the documentation of the :mod:`pydvl.utils.caching` module. -Using custom scorers -^^^^^^^^^^^^^^^^^^^^ +### Using custom scorers The `scoring` argument of :class:`~pydvl.utils.utility.Utility` can be used to specify a custom :class:`~pydvl.utils.utility.Scorer` object. This is a simple @@ -129,46 +128,48 @@ More importantly, the object provides information about the range of the score, which is used by some methods by estimate the number of samples necessary, and about what default value to use when the model fails to train. -.. note:: - The most important property of a `Scorer` is its default value. Because many - models will fail to fit on small subsets of the data, it is important to - provide a sensible default value for the score. +!!! Note + + The most important property of a `Scorer` is its default value. Because many + models will fail to fit on small subsets of the data, it is important to + provide a sensible default value for the score. It is possible to skip the construction of the :class:`~pydvl.utils.utility.Scorer` when constructing the `Utility` object. The two following calls are equivalent: -.. code-block:: python +```python +utility = Utility( + model, dataset, "explained_variance", score_range=(-np.inf, 1), default_score=0.0 +) +utility = Utility( + model, dataset, Scorer("explained_variance", range=(-np.inf, 1), default=0.0) +) +``` - utility = Utility( - model, dataset, "explained_variance", score_range=(-np.inf, 1), default_score=0.0 - ) - utility = Utility( - model, dataset, Scorer("explained_variance", range=(-np.inf, 1), default=0.0) - ) - -Learning the utility -^^^^^^^^^^^^^^^^^^^^ +### Learning the utility Because each evaluation of the utility entails a full retrain of the model with a new subset of the training set, it is natural to try to learn this mapping from subsets to scores. This is the idea behind **Data Utility Learning (DUL)** -(:footcite:t:`wang_improving_2022`) and in pyDVL it's as simple as wrapping the +[@wang_improving_2022] and in pyDVL it's as simple as wrapping the `Utility` inside :class:`~pydvl.utils.utility.DataUtilityLearning`: -.. code-block::python - - from pydvl.utils import Utility, DataUtilityLearning, Dataset - from sklearn.linear_model import LinearRegression, LogisticRegression - from sklearn.datasets import load_iris - dataset = Dataset.from_sklearn(load_iris()) - u = Utility(LogisticRegression(), dataset, enable_cache=False) - training_budget = 3 - wrapped_u = DataUtilityLearning(u, training_budget, LinearRegression()) - # First 3 calls will be computed normally - for i in range(training_budget): - _ = wrapped_u((i,)) - # Subsequent calls will be computed using the fit model for DUL - wrapped_u((1, 2, 3)) +```python +from pydvl.utils import Utility, DataUtilityLearning, Dataset +from sklearn.linear_model import LinearRegression, LogisticRegression +from sklearn.datasets import load_iris + +dataset = Dataset.from_sklearn(load_iris()) +u = Utility(LogisticRegression(), dataset, enable_cache=False) +training_budget = 3 +wrapped_u = DataUtilityLearning(u, training_budget, LinearRegression()) + +# First 3 calls will be computed normally +for i in range(training_budget): + _ = wrapped_u((i,)) +# Subsequent calls will be computed using the fit model for DUL +wrapped_u((1, 2, 3)) +``` As you can see, all that is required is a model to learn the utility itself and the fitting and using of the learned model happens behind the scenes. @@ -178,8 +179,7 @@ in :doc:`a dedicated notebook `. .. _LOO: -Leave-One-Out values -==================== +## Leave-One-Out values The Leave-One-Out method is a simple approach that assigns each sample its *marginal utility* as value: @@ -195,11 +195,11 @@ effect on training performance, despite any qualities it may possess. Whether this is indicative of low value or not depends on each one's goals and definitions, but other methods are typically preferable. -.. code-block:: python +```python +from pydvl.value.loo.naive import naive_loo - from pydvl.value.loo.naive import naive_loo - utility = Utility(...) - values = naive_loo(utility) +values = naive_loo(utility) +``` The return value of all valuation functions is an object of type :class:`~pydvl.value.result.ValuationResult`. This can be iterated over, @@ -208,8 +208,7 @@ indexed with integers, slices and Iterables, as well as converted to a .. _Shapley: -Shapley values -============== +## Shapley values The Shapley method is an approach to compute data values originating in cooperative game theory. Shapley values are a common way of assigning payoffs to @@ -222,8 +221,7 @@ Shapley values. They can all be accessed via the facade function enumerated in :class:`~pydvl.value.shapley.ShapleyMode`. -Combinatorial Shapley -^^^^^^^^^^^^^^^^^^^^^ +### Combinatorial Shapley The first algorithm is just a verbatim implementation of the definition. As such it returns as exact a value as the utility function allows (see what this means @@ -238,22 +236,20 @@ v_u(x_i) = \frac{1}{n} \sum_{S \subseteq D \setminus \{x_i\}} \binom{n-1}{ | S | }^{-1} [u(S \cup \{x_i\}) − u(S)] ,$$ -.. code-block:: python - - from pydvl.value import compute_shapley_value +```python +from pydvl.value import compute_shapley_value - utility = Utility(...) - values = compute_shapley_values(utility, mode="combinatorial_exact") - df = values.to_dataframe(column='value') +values = compute_shapley_values(utility, mode="combinatorial_exact") +df = values.to_dataframe(column='value') +``` We can convert the return value to a -`pandas DataFrame `_ +[pandas DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html) and name the column with the results as `value`. Please refer to the documentation in :mod:`pydvl.value.shapley` and :class:`~pydvl.value.result.ValuationResult` for more information. -Monte Carlo Combinatorial Shapley -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +### Monte Carlo Combinatorial Shapley Because the number of subsets $S \subseteq D \setminus \{x_i\}$ is $2^{ | D | - 1 }$, one typically must resort to approximations. The simplest @@ -262,18 +258,14 @@ this simple technique is called "Monte Carlo Combinatorial". The method has very poor converge rate and others are preferred, but if desired, usage follows the same pattern: -.. code-block:: python +```python +from pydvl.value import compute_shapley_values, MaxUpdates - from pydvl.utils import Dataset, Utility - from pydvl.value import compute_shapley_values - - model = ... - data = Dataset(...) - utility = Utility(model, data) - values = compute_shapley_values( - utility, mode="combinatorial_montecarlo", done=MaxUpdates(1000) - ) - df = values.to_dataframe(column='cmc') +values = compute_shapley_values( + utility, mode="combinatorial_montecarlo", done=MaxUpdates(1000) +) +df = values.to_dataframe(column='cmc') +``` The DataFrames returned by most Monte Carlo methods will contain approximate standard errors as an additional column, in this case named `cmc_stderr`. @@ -284,10 +276,9 @@ stop condition. This is an instance of a :class:`~pydvl.value.stopping.MaxTime` and :class:`~pydvl.value.stopping.StandardError`. -Owen sampling -^^^^^^^^^^^^^ +### Owen sampling -**Owen Sampling** (:footcite:t:`okhrati_multilinear_2021`) is a practical +**Owen Sampling** [@okhrati_multilinear_2021] is a practical algorithm based on the combinatorial definition. It uses a continuous extension of the utility from $\{0,1\}^n$, where a 1 in position $i$ means that sample $x_i$ is used to train the model, to $[0,1]^n$. The ensuing expression for @@ -302,17 +293,13 @@ Using Owen sampling follows the same pattern as every other method for Shapley values in pyDVL. First construct the dataset and utility, then call :func:`~pydvl.value.shapley.compute_shapley_values`: -.. code-block:: python - - from pydvl.utils import Dataset, Utility - from pydvl.value import compute_shapley_values +```python +from pydvl.value import compute_shapley_values - model = ... - dataset = Dataset(...) - utility = Utility(data, model) - values = compute_shapley_values( - u=utility, mode="owen", n_iterations=4, max_q=200 - ) +values = compute_shapley_values( + u=utility, mode="owen", n_iterations=4, max_q=200 +) +``` There are more details on Owen sampling, and its variant *Antithetic Owen Sampling* in the documentation for the function doing the work behind the scenes: @@ -323,11 +310,10 @@ Note that in this case we do not pass a the number of iterations and the maximum number of samples to use in the integration. -Permutation Shapley -^^^^^^^^^^^^^^^^^^^ +### Permutation Shapley An equivalent way of computing Shapley values (``ApproShapley``) appeared in -:footcite:t:`castro_polynomial_2009` and is the basis for the method most often +[@castro_polynomial_2009] and is the basis for the method most often used in practice. It uses permutations over indices instead of subsets: $$ @@ -341,50 +327,43 @@ terms!) one uses Monte Carlo sampling of permutations, something which has surprisingly low sample complexity. One notable difference wrt. the combinatorial approach above is that the approximations always fulfill the efficiency axiom of Shapley, namely $\sum_{i=1}^n \hat{v}_i = u(D)$ (see -:footcite:t:`castro_polynomial_2009`, Proposition 3.2). +[@castro_polynomial_2009], Proposition 3.2). By adding early stopping, the result is the so-called **Truncated Monte Carlo -Shapley** (:footcite:t:`ghorbani_data_2019`), which is efficient enough to be +Shapley** [@ghorbani_data_2019], which is efficient enough to be useful in applications. -.. code-block:: python +```python +from pydvl.value import compute_shapley_values, MaxUpdates - from pydvl.utils import Dataset, Utility - from pydvl.value import compute_shapley_values +values = compute_shapley_values( + u=utility, mode="truncated_montecarlo", done=MaxUpdates(1000) +) +``` - model = ... - data = Dataset(...) - utility = Utility(model, data) - values = compute_shapley_values( - u=utility, mode="truncated_montecarlo", done=MaxUpdates(1000) - ) - -Exact Shapley for KNN -^^^^^^^^^^^^^^^^^^^^^ +### Exact Shapley for KNN It is possible to exploit the local structure of K-Nearest Neighbours to reduce the amount of subsets to consider: because no sample besides the K closest affects the score, most are irrelevant and it is possible to compute a value in -linear time. This method was introduced by :footcite:t:`jia_efficient_2019a`, +linear time. This method was introduced by [@jia_efficient_2019a], and can be used in pyDVL with: -.. code-block:: python - - from pydvl.utils import Dataset, Utility - from pydvl.value import compute_shapley_values - from sklearn.neighbors import KNeighborsClassifier +```python +from pydvl.utils import Dataset, Utility +from pydvl.value import compute_shapley_values +from sklearn.neighbors import KNeighborsClassifier - model = KNeighborsClassifier(n_neighbors=5) - data = Dataset(...) - utility = Utility(model, data) - values = compute_shapley_values(u=utility, mode="knn") +model = KNeighborsClassifier(n_neighbors=5) +data = Dataset(...) +utility = Utility(model, data) +values = compute_shapley_values(u=utility, mode="knn") +``` +### Group testing -Group testing -^^^^^^^^^^^^^ - -An alternative approach introduced in :footcite:t:`jia_efficient_2019a` +An alternative approach introduced in [@jia_efficient_2019a] first approximates the differences of values with a Monte Carlo sum. With $$\hat{\Delta}_{i j} \approx v_i - v_j,$$ @@ -400,12 +379,13 @@ $$ \end{array} $$ -.. warning:: - We have reproduced this method in pyDVL for completeness and benchmarking, - but we don't advocate its use because of the speed and memory cost. Despite - our best efforts, the number of samples required in practice for convergence - can be several orders of magnitude worse than with e.g. Truncated Monte Carlo. - Additionally, the CSP can sometimes turn out to be infeasible. +!!! Warning + + We have reproduced this method in pyDVL for completeness and benchmarking, + but we don't advocate its use because of the speed and memory cost. Despite + our best efforts, the number of samples required in practice for convergence + can be several orders of magnitude worse than with e.g. Truncated Monte Carlo. + Additionally, the CSP can sometimes turn out to be infeasible. Usage follows the same pattern as every other Shapley method, but with the addition of an ``epsilon`` parameter required for the solution of the CSP. It @@ -415,23 +395,20 @@ note that the number returned will be huge! In practice, fewer samples can be enough, but the actual number will strongly depend on the utility, in particular its variance. -.. code-block:: python - - from pydvl.utils import Dataset, Utility - from pydvl.value import compute_shapley_values - - model = ... - data = Dataset(...) - utility = Utility(model, data, score_range=(_min, _max)) - min_iterations = num_samples_eps_delta(epsilon, delta, n, utility.score_range) - values = compute_shapley_values( - u=utility, mode="group_testing", n_iterations=min_iterations, eps=eps - ) +```python +from pydvl.utils import Dataset, Utility +from pydvl.value import compute_shapley_values -.. _Least Core: +model = ... +data = Dataset(...) +utility = Utility(model, data, score_range=(_min, _max)) +min_iterations = num_samples_eps_delta(epsilon, delta, n, utility.score_range) +values = compute_shapley_values( + u=utility, mode="group_testing", n_iterations=min_iterations, eps=eps +) +``` -Core values -=========== +## Core values The Shapley values define a fair way to distribute payoffs amongst all participants when they form a grand coalition. But they do not consider @@ -463,8 +440,7 @@ The second property states that the sum of payoffs to the agents in any subcoalition $S$ is at least as large as the amount that these agents could earn by forming a coalition on their own. -Least Core values -^^^^^^^^^^^^^^^^^ +### Least Core values Unfortunately, for many cooperative games the Core may be empty. By relaxing the coalitional rationality property by a subsidy $e \gt 0$, @@ -485,31 +461,25 @@ $$ \end{array} $$ -Exact Least Core ----------------- +### Exact Least Core This first algorithm is just a verbatim implementation of the definition. As such it returns as exact a value as the utility function allows (see what this means in :ref:`problems of data values`). -.. code-block:: python +```python +from pydvl.value import compute_least_core_values - from pydvl.utils import Dataset, Utility - from pydvl.value import compute_least_core_values +values = compute_least_core_values(utility, mode="exact") +``` - model = ... - dataset = Dataset(...) - utility = Utility(data, model) - values = compute_least_core_values(utility, mode="exact") - -Monte Carlo Least Core ----------------------- +### Monte Carlo Least Core Because the number of subsets $S \subseteq D \setminus \{x_i\}$ is $2^{ | D | - 1 }$, one typically must resort to approximations. The simplest approximation consists in using a fraction of all subsets for the -constraints. :footcite:t:`yan_if_2021` show that a quantity of order +constraints. [@yan_if_2021] show that a quantity of order $\mathcal{O}((n - \log \Delta ) / \delta^2)$ is enough to obtain a so-called $\delta$-*approximate least core* with high probability. I.e. the following property holds with probability $1-\Delta$ over the choice of subsets: @@ -521,23 +491,18 @@ $$ where $e^{*}$ is the optimal least core subsidy. -.. code-block:: python - - from pydvl.utils import Dataset, Utility - from pydvl.value import compute_least_core_values +```python +from pydvl.value import compute_least_core_values - model = ... - dataset = Dataset(...) - n_iterations = ... - utility = Utility(data, model) - values = compute_least_core_values( - utility, mode="montecarlo", n_iterations=n_iterations - ) +values = compute_least_core_values( + utility, mode="montecarlo", n_iterations=n_iterations +) +``` -.. note:: +!!! Note - Although any number is supported, it is best to choose ``n_iterations`` to be - at least equal to the number of data points. + Although any number is supported, it is best to choose ``n_iterations`` to be + at least equal to the number of data points. Because computing the Least Core values requires the solution of a linear and a quadratic problem *after* computing all the utility values, we offer the @@ -547,23 +512,17 @@ multiple experiments: use list of problems to solve, then solve them in parallel with :func:`~pydvl.value.least_core.common.lc_solve_problems`. -.. code-block:: python +```python +from pydvl.value.least_core import mclc_prepare_problem, lc_solve_problems - from pydvl.utils import Dataset, Utility - from pydvl.value.least_core import mclc_prepare_problem, lc_solve_problems +n_experiments = 10 +problems = [mclc_prepare_problem(utility, n_iterations=n_iterations) + for _ in range(n_experiments)] +values = lc_solve_problems(problems) +``` - model = ... - dataset = Dataset(...) - n_iterations = ... - utility = Utility(data, model) - n_experiments = 10 - problems = [mclc_prepare_problem(utility, n_iterations=n_iterations) - for _ in range(n_experiments)] - values = lc_solve_problems(problems) - -Semi-values -=========== +## Semi-values Shapley values are a particular case of a more general concept called semi-value, which is a generalization to different weighting schemes. A **semi-value** is @@ -578,21 +537,20 @@ where the coefficients $w(k)$ satisfy the property: $$\sum_{k=1}^n w(k) = 1.$$ -Two instances of this are **Banzhaf indices** (:footcite:t:`wang_data_2022`), -and **Beta Shapley** (:footcite:t:`kwon_beta_2022`), with better numerical and +Two instances of this are **Banzhaf indices** [@wang_data_2022], +and **Beta Shapley** [@kwon_beta_2022], with better numerical and rank stability in certain situations. -.. note:: +!!! Note - Shapley values are a particular case of semi-values and can therefore also be - computed with the methods described here. However, as of version 0.6.0, we - recommend using :func:`~pydvl.value.shapley.compute_shapley_values` instead, - in particular because it implements truncated Monte Carlo sampling for faster - computation. + Shapley values are a particular case of semi-values and can therefore also be + computed with the methods described here. However, as of version 0.6.0, we + recommend using :func:`~pydvl.value.shapley.compute_shapley_values` instead, + in particular because it implements truncated Monte Carlo sampling for faster + computation. -Beta Shapley -^^^^^^^^^^^^ +### Beta Shapley For some machine learning applications, where the utility is typically the performance when trained on a set $S \subset D$, diminishing returns are often @@ -608,26 +566,21 @@ $$ where $B$ is the `Beta function `_, and $\alpha$ and $\beta$ are parameters that control the weighting of the subsets. Setting both to 1 recovers Shapley values, and setting $\alpha = 1$, and -$\beta = 16$ is reported in :footcite:t:`kwon_beta_2022` to be a good choice for +$\beta = 16$ is reported in [@kwon_beta_2022] to be a good choice for some applications. See however :ref:`banzhaf indices` for an alternative choice of weights which is reported to work better. -.. code-block:: python - - from pydvl.utils import Dataset, Utility - from pydvl.value import compute_semivalues +```python +from pydvl.value import compute_semivalues - model = ... - data = Dataset(...) - utility = Utility(model, data) - values = compute_semivalues( - u=utility, mode="beta_shapley", done=MaxUpdates(500), alpha=1, beta=16 - ) +values = compute_semivalues( + u=utility, mode="beta_shapley", done=MaxUpdates(500), alpha=1, beta=16 +) +``` .. _banzhaf indices: -Banzhaf indices -^^^^^^^^^^^^^^^ +### Banzhaf indices As noted below in :ref:`problems of data values`, the Shapley value can be very sensitive to variance in the utility function. For machine learning applications, @@ -646,24 +599,16 @@ 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 :footcite:t:`wang_data_2022` show that Banzhaf indices are more +The authors of [@wang_data_2022] show that Banzhaf indices are more robust to variance in the utility function than Shapley and Beta Shapley values. -.. code-block:: python +```python +from pydvl.value import compute_semivalues, MaxUpdates - from pydvl.utils import Dataset, Utility - from pydvl.value import compute_semivalues +values = compute_semivalues( u=utility, mode="banzhaf", done=MaxUpdates(500)) +``` - model = ... - data = Dataset(...) - utility = Utility(model, data) - values = compute_semivalues( u=utility, mode="banzhaf", done=MaxUpdates(500)) - - -.. _problems of data values: - -Problems of data values -======================= +## Problems of data values There are a number of factors that affect how useful values can be for your project. In particular, regression can be especially tricky, but the particular @@ -682,16 +627,19 @@ nature of every (non-trivial) ML problem can have an effect: ` for scorer functions which can be used to squash a score. The following is defined in module :mod:`~pydvl.utils.scorer`: - .. code-block:: python - - def sigmoid(x: float) -> float: - return float(1 / (1 + np.exp(-x))) - - squashed_r2 = compose_score("r2", sigmoid, "squashed r2") - - squashed_variance = compose_score( - "explained_variance", sigmoid, "squashed explained variance" - ) + ```python + import numpy as np + from pydvl.utils.types import compose_score + + def sigmoid(x: float) -> float: + return float(1 / (1 + np.exp(-x))) + + squashed_r2 = compose_score("r2", sigmoid, "squashed r2") + + squashed_variance = compose_score( + "explained_variance", sigmoid, "squashed explained variance" + ) + ``` These squashed scores can prove useful in regression problems, but they can also introduce issues in the low-value regime. @@ -705,7 +653,7 @@ nature of every (non-trivial) ML problem can have an effect: every index set. A moving average is computed and returned once the standard error is small, see :class:`~pydvl.utils.config.MemcachedConfig`. - :footcite:t:`wang_data_2022` prove that by relaxing one of the Shapley axioms + [@wang_data_2022] prove that by relaxing one of the Shapley axioms and considering the general class of semi-values, of which Shapley is an instance, one can prove that a choice of constant weights is the best one can do in a utility-agnostic setting. So-called *Data Banzhaf* is on our to-do @@ -729,8 +677,3 @@ nature of every (non-trivial) ML problem can have an effect: but this would incur massive computational cost. As of v.0.3.0 there are no facilities in pyDVL for cross-validating the utility (note that this would require cross-validating the whole value computation). - -References -========== - -.. footbibliography:: diff --git a/docs/40-influence.rst b/docs/40-influence.md similarity index 53% rename from docs/40-influence.rst rename to docs/40-influence.md index d1a43017a..8b5e07179 100644 --- a/docs/40-influence.rst +++ b/docs/40-influence.md @@ -1,17 +1,21 @@ -.. _influence: +--- +title: Computing Influence Values +alias: + name: influence-values + text: Computing Influence Values +--- -========================== -Computing influence values -========================== +# Computing influence values +!!! Warning + + Much of the code in the package :mod:`pydvl.influence` is experimental or + untested. Package structure and basic API are bound to change before v1.0.0 -.. warning:: - Much of the code in the package :mod:`pydvl.influence` is experimental or - untested. Package structure and basic API are bound to change before v1.0.0 +!!! Todo -.. todo:: + This section needs rewriting: - This section needs rewriting: - Introduce some theory - Explain how the methods differ - Add example for `TwiceDifferentiable` @@ -28,55 +32,51 @@ parameter in the call to the main entry points, :func:`~pydvl.influence.linear.compute_linear_influences` and :func:`~pydvl.influence.compute_influences`. -Influence for OLS ------------------ -.. warning:: +# Influence for OLS - This will be deprecated. It makes no sense to have a separate interface for - linear models. +!!! Warning + + This will be deprecated. It makes no sense to have + a separate interface for linear models. Because the Hessian of the least squares loss for a regression problem can be computed analytically, we provide :func:`~pydvl.influence.linear.compute_linear_influences` as a convenience function to work with these models. -.. code-block:: python - - >>> from pydvl.influence.linear import compute_linear_influences - >>> compute_linear_influences( - ... x_train, - ... y_train, - ... x_test, - ... y_test - ... ) - +```python +from pydvl.influence.linear import compute_linear_influences +compute_linear_influences( + x_train, + y_train, + x_test, + y_test +) +``` This method calculates the influence function for each sample in x_train for a least squares regression problem. -Exact influences using the `TwiceDifferentiable` protocol ---------------------------------------------------------- +# Exact influences using the `TwiceDifferentiable` protocol More generally, influences can be computed for any model which implements the :class:`TwiceDifferentiable` protocol, i.e. which is capable of calculating second derivative matrix vector products and gradients of the loss evaluated on training and test samples. -.. code-block:: python - - >>> from pydvl.influence import influences - >>> compute_influences( - ... model, - ... x_train, - ... y_train, - ... x_test, - ... y_test,, - ... ) +```python +from pydvl.influence import compute_influences +compute_influences( + model, + x_train, + y_train, + x_test, + y_test,, +) +``` - -Approximate matrix inversion -^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +## Approximate matrix inversion Sometimes it is not possible to construct the complete Hessian in memory. In that case one can use conjugate gradient as a space-efficient approximation to @@ -84,33 +84,31 @@ inverting the full matrix. In pyDVL this can be done with the parameter `inversion_method` of :func:`~pydvl.influence.compute_influences`: -.. code-block:: python - - >>> from pydvl.influence import compute_influences - >>> compute_influences( - ... model, - ... x_train, - ... y_train, - ... x_test, - ... y_test, - ... inversion_method="cg" - ... ) - +```python +from pydvl.influence import compute_influences +compute_influences( + model, + x_train, + y_train, + x_test, + y_test, + inversion_method="cg" +) +``` -Perturbation influences ------------------------ +# Perturbation influences As mentioned, the method of empirical influence computation can be selected in :func:`~pydvl.influence.compute_influences` with `influence_type`: -.. code-block:: python - - >>> from pydvl.influence import compute_influences - >>> compute_influences( - ... model, - ... x_train, - ... y_train, - ... x_test, - ... y_test, - ... influence_type="perturbation" - ... ) +```python +from pydvl.influence import compute_influences +compute_influences( + model, + x_train, + y_train, + x_test, + y_test, + influence_type="perturbation" +) +``` diff --git a/docs/assets/elsevier-harvard.csl b/docs/assets/elsevier-harvard.csl new file mode 100644 index 000000000..0ef7b190f --- /dev/null +++ b/docs/assets/elsevier-harvard.csl @@ -0,0 +1,239 @@ + + diff --git a/docs/assets/logo.svg b/docs/assets/logo.svg new file mode 100644 index 000000000..3a846f7e2 --- /dev/null +++ b/docs/assets/logo.svg @@ -0,0 +1,201 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/pydvl.bib b/docs/assets/pydvl.bib similarity index 100% rename from docs/pydvl.bib rename to docs/assets/pydvl.bib diff --git a/docs/index.rst b/docs/index.md similarity index 91% rename from docs/index.rst rename to docs/index.md index 217c08e2b..bd2fb264f 100644 --- a/docs/index.rst +++ b/docs/index.md @@ -1,8 +1,8 @@ -.. _home: +--- +title: Home +--- -=================== -pyDVL Documentation -=================== +# pyDVL Documentation Welcome to the pyDVL library for data valuation! @@ -11,8 +11,15 @@ It runs most of them in parallel either locally or in a cluster and supports distributed caching of results. If you're a first time user of pyDVL, we recommend you to go through the -:ref:`Getting Started ` and -:ref:`Installation ` guides. +[[getting-started]] and [[installation]] guides. + +[TOC] + +=== "To the installation guide" + + Test + + :material-toolbox: .. grid:: 2 :gutter: 4 diff --git a/docs/javascripts/mathjax.js b/docs/javascripts/mathjax.js new file mode 100644 index 000000000..06dbf38bf --- /dev/null +++ b/docs/javascripts/mathjax.js @@ -0,0 +1,16 @@ +window.MathJax = { + tex: { + inlineMath: [["\\(", "\\)"]], + displayMath: [["\\[", "\\]"]], + processEscapes: true, + processEnvironments: true + }, + options: { + ignoreHtmlClass: ".*|", + processHtmlClass: "arithmatex" + } +}; + +document$.subscribe(() => { + MathJax.typesetPromise() +}) diff --git a/docs/overrides/main.html b/docs/overrides/main.html new file mode 100644 index 000000000..e573b98e9 --- /dev/null +++ b/docs/overrides/main.html @@ -0,0 +1,9 @@ +{% extends "base.html" %} + +{% block announce %} +
+ +
+{% endblock %} \ No newline at end of file diff --git a/docs/pydvl/index.rst b/docs/pydvl/index.rst deleted file mode 100644 index 02a140baa..000000000 --- a/docs/pydvl/index.rst +++ /dev/null @@ -1,11 +0,0 @@ -API Reference -============= - -.. automodule:: pydvl - :members: - :undoc-members: - -.. toctree:: - :glob: - - * diff --git a/docs/stylesheets/extra.css b/docs/stylesheets/extra.css new file mode 100644 index 000000000..d4d5c7d99 --- /dev/null +++ b/docs/stylesheets/extra.css @@ -0,0 +1,47 @@ +.announcement { + align-items: center; + display: flex; + overflow-x: auto; +} + +.announcement-content { + box-sizing: border-box; + min-width: 100%; + padding: .5rem; + text-align: center; + white-space: nowrap; + color: white; +} + +/* Indentation. */ +div.doc-contents:not(.first) { + padding-left: 25px; + border-left: .05rem solid var(--md-typeset-table-color); +} + +/* Mark external links as such. */ +a.autorefs-external::after { + /* https://primer.style/octicons/arrow-up-right-24 */ + background-image: url('data:image/svg+xml,'); + content: ' '; + + display: inline-block; + position: relative; + top: 0.1em; + margin-left: 0.2em; + margin-right: 0.1em; + + height: 1em; + width: 1em; + border-radius: 100%; + background-color: var(--md-typeset-a-color); +} + +a.autorefs-external:hover::after { + background-color: var(--md-accent-fg-color); +} + +/*Highlight code*/ +.highlight > :first-child { + color: #b30000; +} \ No newline at end of file diff --git a/mkdocs.yml b/mkdocs.yml new file mode 100644 index 000000000..0e5e1f512 --- /dev/null +++ b/mkdocs.yml @@ -0,0 +1,123 @@ +site_name: "pyDVL" +site_dir: "docs_build" +site_url: "https://appliedai-initiative.github.io/pyDVL/" +repo_url: "https://github.com/appliedAI-Initiative/pyDVL" +copyright: "Copyright © AppliedAI Institute gGmbH" + +watch: +- src/pydvl + +plugins: +- autorefs +- search +- section-index +- alias: + use_relative_link: true + verbose: true +- mkdocstrings: + enable_inventory: true + handlers: + python: + import: + - https://docs.python.org/3/objects.inv + - https://numpy.org/doc/stable/objects.inv + paths: [src] # search packages in the src folder + options: + docstring_style: google + docstring_section_style: spacy + line_length: 80 + show_bases: true + members_order: source + # separate_signature: true + show_signature_annotations: false + signature_crossrefs: true + # show_if_no_docstring: true + merge_init_into_class: true + docstring_options: + ignore_init_summary: true + # filters: [] # include all members +- gen-files: + scripts: + - build_scripts/generate_api_docs.py +- literate-nav: + nav_file: SUMMARY.md +#- git-revision-date-localized: +# enable_creation_date: true +# type: iso_date +# fallback_to_build_date: true +- bibtex: + bib_file: "docs/assets/pydvl.bib" + csl_file: "docs/assets/elsevier-harvard.csl" + cite_inline: true + +theme: + name: material + custom_dir: docs/overrides + logo: assets/logo.svg + favicon: assets/logo.svg + icon: + repo: fontawesome/brands/github + features: + - search.suggest + - search.highlight + - toc.follow + - navigation.tabs + - navigation.tabs.sticky + - navigation.sections + - navigation.tracking + # - navigation.top + - navigation.footer + - content.code.copy + palette: + # Palette toggle for light mode + - media: "(prefers-color-scheme: light)" + scheme: default + primary: teal + toggle: + icon: material/brightness-7 + name: Switch to dark mode + # Palette toggle for dark mode + - media: "(prefers-color-scheme: dark)" + scheme: slate + primary: teal + toggle: + icon: material/brightness-4 + name: Switch to light mode + +extra_css: +- stylesheets/extra.css + +extra_javascript: +- javascripts/mathjax.js +- https://polyfill.io/v3/polyfill.min.js?features=es6 +- https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js + +extra: + social: + - icon: fontawesome/brands/github + link: https://github.com/appliedAI-Initiative/pyDVL + - icon: fontawesome/brands/python + link: https://pypi.org/project/pyDVL/ + +markdown_extensions: +- admonition +- attr_list +- footnotes +- toc: + permalink: True + toc_depth: 3 +- pymdownx.tabbed: + alternate_style: true +- pymdownx.emoji: + emoji_index: !!python/name:materialx.emoji.twemoji + emoji_generator: !!python/name:materialx.emoji.to_svg +- pymdownx.highlight: + anchor_linenums: true + pygments_lang_class: true + line_spans: __span +- pymdownx.arithmatex: + generic: true +- pymdownx.inlinehilite +- pymdownx.snippets +- pymdownx.superfences +- pymdownx.details diff --git a/requirements-docs.txt b/requirements-docs.txt new file mode 100644 index 000000000..e7b37a0f8 --- /dev/null +++ b/requirements-docs.txt @@ -0,0 +1,12 @@ +mkdocs==1.4.2 +mkdocs-material +mkdocstrings[python]>=0.18 +mkdocs-alias-plugin>=0.6.0 +mkdocs-autorefs +mkdocs-gen-files +mkdocs-literate-nav +mkdocs-section-index +mkdocs-bibtex +mkdocs-gallery +mkdocs-nbconvert +mkdocs-git-revision-date-localized-plugin \ No newline at end of file diff --git a/src/pydvl/influence/conjugate_gradient.py b/src/pydvl/influence/conjugate_gradient.py index b4839dc6c..a19311c03 100644 --- a/src/pydvl/influence/conjugate_gradient.py +++ b/src/pydvl/influence/conjugate_gradient.py @@ -1,6 +1,4 @@ """ -Contains - - batched conjugate gradient. - error bound for conjugate gradient. """ diff --git a/src/pydvl/utils/utility.py b/src/pydvl/utils/utility.py index 5763edeea..b16cdd0a8 100644 --- a/src/pydvl/utils/utility.py +++ b/src/pydvl/utils/utility.py @@ -1,14 +1,16 @@ """ This module contains classes to manage and learn utility functions for the -computation of values. Please see the documentation on :ref:`data valuation` for -more information. +computation of values. Please see the documentation on +[Computing Data Values][computing-data-values] for more information. -:class:`Utility` holds information about model, data and scoring function (the -latter being what one usually understands under *utility* in the general -definition of Shapley value). It is automatically cached across machines. +[Utility][pydvl.utils.utility.Utility] holds information about model, +data and scoring function (the latter being what one usually understands +under *utility* in the general definition of Shapley value). +It is automatically cached across machines. -:class:`DataUtilityLearning` adds support for learning the scoring function -to avoid repeated re-training of the model to compute the score. +[DataUtilityLearning][pydvl.utils.utility.DataUtilityLearning] adds support +for learning the scoring function to avoid repeated re-training +of the model to compute the score. This module also contains Utility classes for toy games that are used for testing and for demonstration purposes. @@ -41,64 +43,63 @@ class Utility: An instance of ``Utility`` holds the triple of model, dataset and scoring function which determines the value of data points. This is mosly used for - the computation of :ref:`Shapley values` and - :ref:`Least Core values`. + the computation of [Shapley Values][shapley-values] and + [Core Values][core-values]. The Utility expect the model to fulfill - the :class:`pydvl.utils.types.SupervisedModel` interface i.e. to have - ``fit()``, ``predict()``, and ``score()`` methods. + the [SupervisedModel][pydvl.utils.types.SupervisedModel] interface i.e. + to have ``fit()``, ``predict()``, and ``score()`` methods. When calling the utility, the model will be - `cloned `_ + [cloned](https://scikit-learn.org/stable/modules/generated/sklearn.base + .clone.html) if it is a Sci-Kit Learn model, otherwise a copy is created using - ``deepcopy()`` - from the builtin `copy `_ - module. + ``deepcopy()`` from the builtin [copy](https://docs.python.org/3/ + library/copy.html) module. Since evaluating the scoring function requires retraining the model and that can be time-consuming, this class wraps it and caches the results of each execution. Caching is available both locally and across nodes, but must always be enabled for your - project first, see :ref:`how to set up the cache`. - - :param model: Any supervised model. Typical choices can be found at - https://scikit-learn.org/stable/supervised_learning.html - :param data: :class:`Dataset` or :class:`GroupedDataset`. - :param scorer: A scoring object. If None, the ``score()`` method of the model - will be used. See :mod:`~pydvl.utils.scorer` for ways to create - and compose scorers, in particular how to set default values and ranges. - For convenience, a string can be passed, which will be used to construct - a :class:`~pydvl.utils.scorer.Scorer`. - :param default_score: As a convenience when no ``scorer`` object is passed - (where a default value can be provided), this argument also allows to set - the default score for models that have not been fit, e.g. when too little - data is passed, or errors arise. - :param score_range: As with ``default_score``, this is a convenience argument - for when no ``scorer`` argument is provided, to set the numerical range - of the score function. Some Monte Carlo methods can use this to estimate - the number of samples required for a certain quality of approximation. - :param catch_errors: set to ``True`` to catch the errors when fit() fails. - This could happen in several steps of the pipeline, e.g. when too little - training data is passed, which happens often during Shapley value - calculations. When this happens, the :attr:`default_score` is returned - as a score and computation continues. - :param show_warnings: Set to ``False`` to suppress warnings thrown by - ``fit()``. - :param enable_cache: If ``True``, use memcached for memoization. - :param cache_options: Optional configuration object for memcached. - :param clone_before_fit: If True, the model will be cloned before calling - ``fit()``. - - :Example: - - >>> from pydvl.utils import Utility, DataUtilityLearning, Dataset - >>> from sklearn.linear_model import LinearRegression, LogisticRegression - >>> from sklearn.datasets import load_iris - >>> dataset = Dataset.from_sklearn(load_iris(), random_state=16) - >>> u = Utility(LogisticRegression(random_state=16), dataset) - >>> u(dataset.indices) - 0.9 + project first, see [Setting up the cache][setting-up-the-cache]. + + Args: + model: Any supervised model. Typical choices can be found at + https://scikit-learn.org/stable/supervised_learning.html + data: Dataset or GroupedDataset instance. + scorer: A scoring object. If None, the ``score()`` method of the model + will be used. See [score][pydvl.utils.score] for ways to create + and compose scorers, in particular how to set default values and ranges. + For convenience, a string can be passed, which will be used to construct + a [Scorer][pydvl.utils.score.Scorer]. + default_score: As a convenience when no ``scorer`` object is passed + (where a default value can be provided), this argument also allows to set + the default score for models that have not been fit, e.g. when too little + data is passed, or errors arise. + score_range: As with ``default_score``, this is a convenience argument + for when no ``scorer`` argument is provided, to set the numerical range + of the score function. Some Monte Carlo methods can use this to estimate + the number of samples required for a certain quality of approximation. + catch_errors: set to ``True`` to catch the errors when fit() fails. + This could happen in several steps of the pipeline, e.g. when too little + training data is passed, which happens often during Shapley value + calculations. When this happens, the :attr:`default_score` is returned + as a score and computation continues. + show_warnings: Set to ``False`` to suppress warnings thrown by + ``fit()``. + enable_cache: If ``True``, use memcached for memoization. + cache_options: Optional configuration object for memcached. + clone_before_fit: If True, the model will be cloned before calling + ``fit()``. + + Examples: + >>> from pydvl.utils import Utility, DataUtilityLearning, Dataset + >>> from sklearn.linear_model import LinearRegression, LogisticRegression + >>> from sklearn.datasets import load_iris + >>> dataset = Dataset.from_sklearn(load_iris(), random_state=16) + >>> u = Utility(LogisticRegression(random_state=16), dataset) + >>> u(dataset.indices) + 0.9 """ @@ -152,6 +153,11 @@ def _initialize_utility_wrapper(self): self._utility_wrapper = self._utility def __call__(self, indices: Iterable[int]) -> float: + """ + Args: + indices: a subset of valid indices for the + `x_train` attribute of [Dataset][pydvl.utils.dataset.Dataset]. + """ utility: float = self._utility_wrapper(frozenset(indices)) return utility @@ -164,13 +170,15 @@ def _utility(self, indices: FrozenSet) -> float: when computing utilities of permutations of indices or when randomly sampling from the powerset of indices. - :param indices: a subset of valid indices for - :attr:`~pydvl.utils.dataset.Dataset.x_train`. The type must be - hashable for the caching to work, e.g. wrap the argument with - `frozenset `_ - (rather than `tuple` since order should not matter) - :return: 0 if no indices are passed, :attr:`default_score`` if we fail - to fit the model or the scorer returns `NaN`. Otherwise, the score + Args: + indices: a subset of valid indices for the + `x_train` attribute of [Dataset][pydvl.utils.dataset.Dataset]. + The type must be hashable for the caching to work, + e.g. wrap the argument with [frozenset][] + (rather than `tuple` since order should not matter) + Returns: + 0 if no indices are passed, ``default_score`` if we fail + to fit the model or the scorer returns [numpy.NaN][]. Otherwise, the score of the model on the test data. """ if not indices: @@ -205,8 +213,9 @@ def _clone_model(model: SupervisedModel) -> SupervisedModel: """Clones the passed model to avoid the possibility of reusing a fitted estimator - :param model: Any supervised model. Typical choices can be found at - https://scikit-learn.org/stable/supervised_learning.html + Args: + model: Any supervised model. Typical choices can be found + on [this page](https://scikit-learn.org/stable/supervised_learning.html) """ try: model = clone(model) @@ -225,7 +234,7 @@ def signature(self): @property def cache_stats(self) -> Optional[CacheStats]: """Cache statistics are gathered when cache is enabled. - See :class:`~pydvl.utils.caching.CacheInfo` for all fields returned. + See [CacheStats][pydvl.utils.caching.CacheStats] for all fields returned. """ if self.enable_cache: return self._utility_wrapper.stats # type: ignore @@ -247,31 +256,31 @@ class DataUtilityLearning: """Implementation of Data Utility Learning algorithm :footcite:t:`wang_improving_2022`. - This object wraps a :class:`~pydvl.utils.utility.Utility` and delegates + This object wraps a [Utility][pydvl.utils.utility.Utility] and delegates calls to it, up until a given budget (number of iterations). Every tuple of input and output (a so-called *utility sample*) is stored. Once the budget is exhausted, `DataUtilityLearning` fits the given model to the utility samples. Subsequent calls will use the learned model to predict the utility instead of delegating. - :param u: The :class:`~pydvl.utils.utility.Utility` to learn. - :param training_budget: Number of utility samples to collect before fitting - the given model - :param model: A supervised regression model - - :Example: - - >>> from pydvl.utils import Utility, DataUtilityLearning, Dataset - >>> from sklearn.linear_model import LinearRegression, LogisticRegression - >>> from sklearn.datasets import load_iris - >>> dataset = Dataset.from_sklearn(load_iris()) - >>> u = Utility(LogisticRegression(), dataset) - >>> wrapped_u = DataUtilityLearning(u, 3, LinearRegression()) - ... # First 3 calls will be computed normally - >>> for i in range(3): - ... _ = wrapped_u((i,)) - >>> wrapped_u((1, 2, 3)) # Subsequent calls will be computed using the fit model for DUL - 0.0 + Args: + u: The [Utility][pydvl.utils.utility.Utility] to learn. + training_budget: Number of utility samples to collect before fitting + the given model. + model: A supervised regression model + + Examples: + >>> from pydvl.utils import Utility, DataUtilityLearning, Dataset + >>> from sklearn.linear_model import LinearRegression, LogisticRegression + >>> from sklearn.datasets import load_iris + >>> dataset = Dataset.from_sklearn(load_iris()) + >>> u = Utility(LogisticRegression(), dataset) + >>> wrapped_u = DataUtilityLearning(u, 3, LinearRegression()) + ... # First 3 calls will be computed normally + >>> for i in range(3): + ... _ = wrapped_u((i,)) + >>> wrapped_u((1, 2, 3)) # Subsequent calls will be computed using the fit model for DUL + 0.0 """ @@ -312,7 +321,7 @@ def __call__(self, indices: Iterable[int]) -> float: @property def data(self) -> Dataset: - """Returns the wrapped utility's :class:`~pydvl.utils.dataset.Dataset`.""" + """Returns the wrapped utility's [Dataset][pydvl.utils.dataset.Dataset].""" return self.utility.data @@ -336,9 +345,10 @@ class MinerGameUtility(Utility): If there is an odd number of miners, then the core is empty. - Taken from: https://en.wikipedia.org/wiki/Core_(game_theory) + Taken from [Wikipedia](https://en.wikipedia.org/wiki/Core_(game_theory)) - :param n_miners: Number of miners that participate in the game. + Args: + n_miners: Number of miners that participate in the game. """ def __init__(self, n_miners: int, **kwargs): @@ -392,8 +402,9 @@ class GlovesGameUtility(Utility): Where $L$, respectively $R$, is the set of players with left gloves, respectively right gloves. - :param left: Number of players with a left glove. - :param right: Number of player with a right glove. + Args: + left: Number of players with a left glove. + right: Number of player with a right glove. """ diff --git a/tox.ini b/tox.ini index 3433fe113..ab7711de3 100644 --- a/tox.ini +++ b/tox.ini @@ -91,30 +91,18 @@ commands = ; read_the_docs does) with possibly fewer external dependencies and use sphinx' ; ability to automock the missing ones. commands = - python build_scripts/update_docs.py --clean - sphinx-build -v --color -W -b html -d "{envtmpdir}/doctrees" docs "docs/_build/html" - sphinx-build -v --color -b doctest -d "{envtmpdir}/doctrees" docs "docs/_build/doctest" + mkdocs build deps = - sphinx==5.3.0 - sphinxcontrib-websupport==1.2.4 - sphinx-design - sphinx-math-dollar - sphinx-hoverxref - sphinxcontrib-bibtex - nbsphinx - furo - ipython + -r requirements-docs.txt extras = influence [testenv:docs-dev] description = This is a development environment for the docs that supports hot-reloading of the docs commands = - python build_scripts/update_docs.py --clean - sphinx-autobuild -W -b html -d "{envtmpdir}/doctrees" docs "docs/_build/html" --ignore "*.ipynb" + mkdocs serve deps = {[testenv:docs]deps} - sphinx-autobuild extras = influence From 00999959fe27501187af6e3c1560e3b33b97bb0e Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Mon, 15 May 2023 15:22:01 +0200 Subject: [PATCH 061/436] use TensorDataset to save memory --- notebooks/influence_imagenet.ipynb | 66 ++++++++++++++-------- notebooks/influence_wine.ipynb | 60 ++++++++++---------- src/pydvl/influence/frameworks/__init__.py | 2 +- tests/influence/test_influences.py | 8 ++- 4 files changed, 81 insertions(+), 55 deletions(-) diff --git a/notebooks/influence_imagenet.ipynb b/notebooks/influence_imagenet.ipynb index 790ae93c5..0abff86b8 100644 --- a/notebooks/influence_imagenet.ipynb +++ b/notebooks/influence_imagenet.ipynb @@ -1,6 +1,7 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -18,6 +19,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -29,6 +31,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -61,7 +64,7 @@ "import numpy as np\n", "import os\n", "from torch import nn\n", - "from torch.utils.data import DataLoader\n", + "from torch.utils.data import DataLoader, TensorDataset\n", "\n", "from support.common import (\n", " plot_sample_images,\n", @@ -151,6 +154,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -180,6 +184,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -213,13 +218,13 @@ "source": [ "batch_size = 256\n", "train_data_loader = DataLoader(\n", - " list(zip(train_x, train_y)), batch_size=batch_size, shuffle=False\n", + " TensorDataset(train_x, train_y), batch_size=batch_size, shuffle=False\n", ")\n", "val_data_loader = DataLoader(\n", - " list(zip(val_x, val_y)), batch_size=batch_size, shuffle=False\n", + " TensorDataset(val_x, val_y), batch_size=batch_size, shuffle=False\n", ")\n", "test_data_loader = DataLoader(\n", - " list(zip(test_x, test_y)), batch_size=batch_size, shuffle=False\n", + " TensorDataset(test_x, test_y), batch_size=batch_size, shuffle=False\n", ")" ] }, @@ -287,6 +292,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -329,6 +335,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -351,7 +358,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "412bb574c84a43acb7c996f051525f44", + "model_id": "e40224081c6c40c1bbe692d91919f153", "version_major": 2, "version_minor": 0 }, @@ -365,7 +372,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2a32719a303142aa97ab09d48a088f35", + "model_id": "9e211664a10e4a85a298c74e8ad0b656", "version_major": 2, "version_minor": 0 }, @@ -379,7 +386,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9e2d9a25311b4e3d94487a3a41914675", + "model_id": "78953e3bc7dd4e1ba2cf246237c4fa61", "version_major": 2, "version_minor": 0 }, @@ -393,7 +400,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a5c591c3b33945beb1f0cd52840abcf2", + "model_id": "bdf1ddf3c3264b18a312b219dfb19662", "version_major": 2, "version_minor": 0 }, @@ -419,6 +426,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -468,6 +476,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -502,6 +511,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -515,7 +525,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -547,6 +557,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -565,6 +576,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -596,6 +608,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -609,7 +622,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -643,6 +656,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -677,7 +691,7 @@ "corrupted_train_x, corrupted_train_y = process_imgnet_io(corrupted_dataset, label_names)\n", "\n", "train_data_loader = DataLoader(\n", - " list(zip(corrupted_train_x, corrupted_train_y)),\n", + " TensorDataset(corrupted_train_x, corrupted_train_y),\n", " batch_size=batch_size,\n", " shuffle=False,\n", ")\n", @@ -736,6 +750,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -750,7 +765,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "698b9b04ee834883b6736787bff83a76", + "model_id": "8a281ab67b4d4817a508c53ff7443307", "version_major": 2, "version_minor": 0 }, @@ -764,7 +779,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9b3a26b6dfda43f29ebebfece31f264b", + "model_id": "c70dfe0b9aca401cbccbfb291ab70f4f", "version_major": 2, "version_minor": 0 }, @@ -778,7 +793,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "70b38240c8d24e3c92ad5640f6f979e3", + "model_id": "4f491e87b6584c3d88f39232f60460ff", "version_major": 2, "version_minor": 0 }, @@ -792,7 +807,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3578d5754704481fb83b976e38b5c66c", + "model_id": "2011638fff5d4cfe98e7a68576349b82", "version_major": 2, "version_minor": 0 }, @@ -818,6 +833,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -840,7 +856,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -860,6 +876,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -927,15 +944,15 @@ " 0\n", " tables\n", " -0.077502\n", - " -2.547895\n", - " 2.470393\n", + " -2.547897\n", + " 2.470395\n", " \n", " \n", " 1\n", " boats\n", " -0.054209\n", - " -2.377989\n", - " 2.323780\n", + " -2.377988\n", + " 2.323779\n", " \n", " \n", "\n", @@ -943,8 +960,8 @@ ], "text/plain": [ " label avg_non_corrupted_infl avg_corrupted_infl score_diff\n", - "0 tables -0.077502 -2.547895 2.470393\n", - "1 boats -0.054209 -2.377989 2.323780" + "0 tables -0.077502 -2.547897 2.470395\n", + "1 boats -0.054209 -2.377988 2.323779" ] }, "execution_count": 25, @@ -959,6 +976,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -972,6 +990,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -983,6 +1002,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1016,6 +1036,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -1036,6 +1057,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index 6836aa789..80589045d 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -64,7 +64,7 @@ "from pydvl.utils.dataset import load_wine_dataset\n", "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, f1_score\n", "from torch.optim import Adam, lr_scheduler\n", - "from torch.utils.data import DataLoader" + "from torch.utils.data import DataLoader, TensorDataset" ] }, { @@ -127,12 +127,12 @@ "metadata": {}, "outputs": [], "source": [ - "train_data, val_data, test_data, feature_names = load_wine_dataset(\n", + "training_data, val_data, test_data, feature_names = load_wine_dataset(\n", " train_size=0.3, test_size=0.6\n", ")\n", "# In CI we only use a subset of the training set\n", "if is_CI:\n", - " train_data = (train_data[0][:10], train_data[1][:10])" + " train_data = (training_data[0][:10], training_data[1][:10])" ] }, { @@ -152,8 +152,8 @@ "outputs": [], "source": [ "num_corrupted_idxs = 10\n", - "train_data[1][:num_corrupted_idxs] = torch.tensor(\n", - " [(val + 1) % 3 for val in train_data[1][:num_corrupted_idxs]]\n", + "training_data[1][:num_corrupted_idxs] = torch.tensor(\n", + " [(val + 1) % 3 for val in training_data[1][:num_corrupted_idxs]]\n", ")" ] }, @@ -173,9 +173,11 @@ "metadata": {}, "outputs": [], "source": [ - "train_data_loader = DataLoader(list(zip(*train_data)), batch_size=32, shuffle=False)\n", - "val_data_loader = DataLoader(list(zip(*val_data)), batch_size=32, shuffle=False)\n", - "test_data_loader = DataLoader(list(zip(*test_data)), batch_size=32, shuffle=False)" + "training_data_loader = DataLoader(\n", + " TensorDataset(*training_data), batch_size=32, shuffle=False\n", + ")\n", + "val_data_loader = DataLoader(TensorDataset(*val_data), batch_size=32, shuffle=False)\n", + "test_data_loader = DataLoader(TensorDataset(*test_data), batch_size=32, shuffle=False)" ] }, { @@ -199,7 +201,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Model fitting: 100%|██████████| 300/300 [00:00<00:00, 386.78it/s]\n" + "Model fitting: 100%|██████████| 300/300 [00:00<00:00, 307.77it/s]\n" ] } ], @@ -221,7 +223,7 @@ "\n", "losses = fit_torch_model(\n", " model=nn_model,\n", - " training_data=train_data_loader,\n", + " training_data=training_data_loader,\n", " val_data=val_data_loader,\n", " loss=F.cross_entropy,\n", " optimizer=optimizer,\n", @@ -247,7 +249,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABSMAAAKvCAYAAACRY9qRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACE5klEQVR4nOzdeXyU5b3///c9W/aFEEgIhH1XDAioICoKivv2PVarVmtbj3q+/Vnr6Wlr69Jjz1e7WO1ytLZWa2uPretxrQuiuLMIggJhhxACCWHJvs/cvz/uzGSbQCaz3JPM6/l4TO977rmv6/4EQtq+cy2GaZqmAAAAAAAAACDKHHYXAAAAAAAAACAxEEYCAAAAAAAAiAnCSAAAAAAAAAAxQRgJAAAAAAAAICYIIwEAAAAAAADEBGEkAAAAAAAAgJggjAQAAAAAAAAQE4SRAAAAAAAAAGLCZXcBdvP5fNq3b58yMjJkGIbd5QAAAAAAAAADimmaqq2tVUFBgRyOo499TPgwct++fSosLLS7DAAAAAAAAGBAKy0t1ahRo456T8KHkRkZGZKsP6zMzEybqwEAAAAAAAAGlpqaGhUWFgZytqNJ+DDSPzU7MzOTMBIAAAAAAADop74sgcgGNgAAAAAAAABigjASAAAAAAAAQEwQRgIAAAAAAACICcJIAAAAAAAAADGR8BvYAAAAAAAAIH6Zpimv16u2tja7S0lIbrdbTqczYv0RRgIAAAAAACDumKapqqoqVVZWyuv12l1OQsvOzlZ+fn6fdss+FsJIAAAAAAAAxJ3y8nJVVVUpMzNTmZmZcrlcEQnD0HemaaqhoUEHDhyQJI0YMSLsPgkjAQAAAAAAEFe8Xq+qq6s1bNgw5ebm2l1OQktJSZEkHThwQMOHDw97yjYb2AAAAAAAACCutLa2yjRNpaWl2V0KJKWmpkqy/l7CRRgJAAAAAACAuMS07PgQyb8HwkgAAAAAAAAAMUEYCQAAAAAAACAmCCMBAAAAAACAQebrX/+6xo4da3cZPcRVGPnBBx/ooosuUkFBgQzD0EsvvXTU+/fv36+rr75akydPlsPh0G233RaTOgEAAAAAAID+MAyjT6/ly5fbXWpUuOwuoLP6+noVFRXpG9/4hi6//PJj3t/c3Kxhw4bpzjvv1EMPPRSDCgEAAAAAAID+e+qpp7q8/+tf/6qlS5f2uD5t2rSwnvPYY4/J5/OF1Uc0xFUYed555+m8887r8/1jx47Vb37zG0nSE088Ea2yAAAAAAAAgIi49tpru7xfsWKFli5d2uN6dw0NDUpNTe3zc9xud7/qi7a4mqYdC83NzaqpqenyAgAAAAAAAOLFwoULdfzxx2vNmjU6/fTTlZqaqh/96EeSpJdfflkXXHCBCgoKlJSUpAkTJuinP/2pvF5vlz66rxm5e/duGYahBx54QH/84x81YcIEJSUlae7cuVq9enXMvra4GhkZC/fff7/+8z//0+4yAAAAAAAAgF4dOnRI5513nq666ipde+21ysvLkyQ9+eSTSk9P1+2336709HS9++67uvvuu1VTU6Nf/vKXx+z36aefVm1trW666SYZhqFf/OIXuvzyy7Vz586YjKZMuDDyjjvu0O233x54X1NTo8LCQhsrAgAAAAAAQF+YpqnGVu+xb4yRFLdThmFEpe/y8nI9+uijuummm7pcf/rpp5WSkhJ4f/PNN+vmm2/WI488ov/6r/9SUlLSUfvds2ePtm3bpiFDhkiSpkyZoksuuURvvfWWLrzwwsh/Id0kXBiZlJR0zL8UAAAAAAAAxJ/GVq+m3/2W3WUEbLp3iVI90YnXkpKSdMMNN/S43jmIrK2tVXNzs0477TT94Q9/0ObNm1VUVHTUfq+88spAEClJp512miRp586dEar86BIujAQAAAAAAADi3ciRI+XxeHpc37hxo+688069++67PfZCqa6uPma/o0eP7vLeH0weOXIkjGr7Lq7CyLq6Om3fvj3wfteuXVq3bp1ycnI0evRo3XHHHSorK9Nf//rXwD3r1q0LtK2srNS6devk8Xg0ffr0WJcPAAAAAACAKEpxO7Xp3iV2lxGQ4nZGr+9OIyD9qqqqdMYZZygzM1P33nuvJkyYoOTkZK1du1Y/+MEP5PP5jtmv0xm8ZtM0w665L+IqjPzss8905plnBt7713a8/vrr9eSTT2r//v3as2dPlzazZs0KnK9Zs0ZPP/20xowZo927d8ekZgAAAAAAAMSGYRhRmxY9ECxfvlyHDh3Siy++qNNPPz1wfdeuXTZWFZq4+ttbuHDhUVPYJ598sse1WKW2A5Vpmnp7U4XSk1w6dWKu3eUAAAAAAACgn/yjGjvnYS0tLXrkkUfsKilkcRVGIvKe/GS3/vPVTZqan6F/3nqaHI7o7PAEAAAAAACA6Jo/f76GDBmi66+/XrfeeqsMw9BTTz01oAbrOewuANF12ayRSk9yaXN5rd7eVGF3OQAAAAAAAOinoUOH6rXXXtOIESN055136oEHHtDZZ5+tX/ziF3aX1meGOZCi0yioqalRVlaWqqurlZmZaXc5UfGrt7fod+9u1/QRmXr91gUyDEZHAgAAAACA+NXU1KRdu3Zp3LhxSk5OtruchHesv49Q8jVGRiaAby4Yp/Qklzbtr2F0JAAAAAAAAGxDGJkAslM9un7+GEnSb97ZNqDWEQAAAAAAAMDgQRiZIL61YLzSPE5t2l+jpYyOBAAAAAAAgA0IIxPEkDSPrp8/VpL0m2WMjgQAAAAAAEDsEUYmkG+dZo2O3LivRu8UH7C7HAAAAAAAACQYwsgEktNpdOSv3t4ir4/RkQAAAAAAAIgdwsgEc9PpE5SZ7NLm8lq99HmZ3eUAAAAAAAAggRBGJpisVLf+75kTJUkPLt2qplavzRUBAAAAAAAgURBGJqDr54/ViKxklVU16m8rSuwuBwAAAAAAAAmCMDIBJbud+u7ZkyVJ//3edlU3ttpcEQAAAAAAABIBYWQiaG2SavZ1ufR/ThylyXnpqmpo1aPv77CpMAAAAAAAACQSwsjBbsOL0i/GS6//e5fLToeh7y+ZKkl64qNdKq9usqM6AAAAAAAAhGH37t0yDENPPvmk3aX0CWHkYJc7WWqtl7Yvk5pru3y0aNpwzR07RM1tPv36na02FQgAAAAAAJA4Lr74YqWmpqq2trbXe6655hp5PB4dOnQohpXFBmHkYJd3nJQzXvI2S9ve7vKRYRj64XnW6MhnPyvV9gO9/yMAAAAAAABA+K655ho1Njbqf//3f4N+3tDQoJdfflnnnnuuhg4dGuPqoo8wcrAzDGnaxdb5pld6fDx7TI7OmZ4nnyn94s0tMS4OAAAAAAAgsVx88cXKyMjQ008/HfTzl19+WfX19brmmmtiXFlsEEYmguntYeS2pVJrY4+Pv3/uFDkM6e1NFVpTcjjGxQEAAAAAACSOlJQUXX755Vq2bJkOHDjQ4/Onn35aGRkZWrBggb73ve9pxowZSk9PV2Zmps477zytX7/ehqojhzAyERScKGUVdqwd2c3E4Rn6ypxCSdLP3tgs0zRjXSEAAAAAAEDCuOaaa9TW1qZnn322y/XDhw/rrbfe0mWXXab9+/frpZde0oUXXqgHH3xQ//Ef/6Evv/xSZ5xxhvbt22dT5eFz2V0AYsAwpGkXSSsekYpfkaZd2OOW2xZP1kvryrR69xEtKz6gxdPzbCgUAAAAAADgKExTam2wu4oO7lQrdwnRWWedpREjRujpp5/Wt7/97cD15557Tq2trbrmmms0Y8YMbd26VQ5Hx1jCr33ta5o6daoef/xx3XXXXRH5EmKNMDJRTLvYCiO3vCm1tUguT5eP87OS9Y1Tx+mR5Tv08zc368ypw+V0hP6PCQAAAAAAIGpaG6T7CuyuosOP9kmetJCbOZ1OXXXVVXrooYe0e/dujR07VpI1RTsvL0+LFi2S0+kM3O/1elVVVaX09HRNmTJFa9eujdRXEHNM004UhSdL6XlSc7W06/2gt9x0xgRlp7q17UCdXlizN8YFAgAAAAAAJA7/BjX+jWz27t2rDz/8UFdddZWcTqd8Pp8eeughTZo0SUlJScrNzdWwYcP0xRdfqLq62s7Sw8LIyEThcEhTL5Q+e1za9LI06ewet2SluPXtMyfqv14v1oNLt+rimQVKdjuDdAYAAAAAAGADd6o1GjFeuFP73XT27NmaOnWq/v73v+tHP/qR/v73v8s0zUBIed999+muu+7SN77xDf30pz9VTk6OHA6HbrvtNvl8vkh9BTFHGJlIpl9shZGbX5cu/LXk7PnXf+0pY/Tnj3errKpRT36yWzefMSH2dQIAAAAAAARjGP2aFh2vrrnmGt1111364osv9PTTT2vSpEmaO3euJOn555/XmWeeqccff7xLm6qqKuXm5tpRbkQwTTuRjFkgpeRIjYelko+D3pLsdur2sydLkh55b7uqGlpiWSEAAAAAAEDC8I+CvPvuu7Vu3brAe8laV9I0zS73P/fccyorK4tpjZFGGJlInC5p6vnWefErvd526ayRmpqfoZqmNv1++Y4YFQcAAAAAAJBYxo0bp/nz5+vll1+WpC5h5IUXXqjly5frhhtu0GOPPaZbb71VN998s8aPH29XuRFBGJlopl1iHYtfk3pZX8DpMPSDc6dKkv78yW7tq2qMVXUAAAAAAAAJxR9AnnTSSZo4cWLg+o9+9CP9+7//u9566y195zvf0dq1a/X666+rsLDQrlIjwjC7j/dMMDU1NcrKylJ1dbUyMzPtLif62pqlX06Ummukb7wljT4l6G2maeqqP67Qyl2H9S+zR+mBK4piXCgAAAAAAEhUTU1N2rVrl8aNG6fk5GS7y0l4x/r7CCVfY2RkonElSZPPtc439T5V2zAM/fA8a3Tki2v3avfB+lhUBwAAAAAAgEGMMDIRTfdP1X5VOsrA2Fmjh+jMKcPkM6WH39seo+IAAAAAAAAwWBFGJqKJiyR3mlS9R9r3+VFvvXXRJEnSi5+XqfRwQyyqAwAAAAAAwCBFGJmI3CnSpLOt86Psqi1ZoyNPnzxMXp+pR5YzOhIAAAAAAAD9RxiZqKZfbB03vXLUqdqS9J1F1k5Oz6/Zq71HGB0JAAAAAACA/iGMTFSTzpGcSdLhHdKBTUe9dfaYHJ06cahavaZ+v3xHjAoEAAAAAADAYEMYmaiSMqy1I6Wj7qrt951FkyVJz35Wqn1VjdGsDAAAAAAAQJJkHmM2J2Ijkn8PhJGJbFr7VO1jrBspSSeNy9Ep43PU6jX1xw92RrkwAAAAAACQyJxOpySptbXV5kogSW1tbZIkl8sVdl+EkYlsyrmSw2VN0z547M1pvn2mtbP2M6tLVd3ADwMAAAAAABAdbrdbSUlJqq6uZnRkHKipqZHT6QyExOEIP87EwJUyRBp3hrRjmTU68rTbj3r7qROHamp+hjaX1+rpVXt0y8IJMSoUAAAAAAAkmtzcXJWVlWnv3r3KysqS2+2WYRh2l5VQTNNUfX29ampqNGLEiIj8+RNGJrppF1ph5ObXjhlGGoahG08br39/br2e/GSXvrlgnDwuBtcCAAAAAIDIy8zMlCQdPHhQZWVlNleTuAzDUHZ2trKysiLSH2FkoptygfTa7VLZGqlmn5RZcNTbLyoq0M/f3KyKmmb988v9unTWyBgVCgAAAAAAEk1mZqYyMzPV2toqr9drdzkJye12R2R6th9hZKLLyJMKT5ZKV0ibX5dOuvGot3tcDl0/f6x++dYW/emjnbpkZgFDpAEAAAAAQFS53W653W67y0AEMMcW1lRtqU+7akvS1SeNVrLboQ1lNVqx83AUCwMAAAAAAMBgQhgJaWp7GLn7Y6nh2OHikDSP/mX2KEnS4x/tjGZlAAAAAAAAGEQIIyHljJPyjpdMr7T1zT41+cap4yRJ7xQf0I7KumhWBwAAAAAAgEGCMBKWaRdZx+JX+3T7+GHpWjxtuCTpf1bsiVZVAAAAAAAAGEQII2HxT9Xe8a7UUt+nJtecMkaS9OLne9XUyo5WAAAAAAAAODrCSFjyjpOGjJXamqTt7/SpyemThmlkdoqqGlr11sby6NYHAAAAAACAAY8wEhbD6BgdWfxan5o4HYaumGNtZPP0SqZqAwAAAAAA4OgII9HBv27k1jeltpY+NfnKnEI5DGnlrsPayUY2AAAAAAAAOArCSHQYdZKUNlxqrpFKPu5Tk4LsFC2cYm1k88zq0mhWBwAAAAAAgAGOMBIdHA5pyrnW+ZY3+tzsqrmFkqTn1+xVS5svGpUBAAAAAABgECCMRFdTzreOW96QTLNPTc6aOlzDM5J0qL5FSzdVRLE4AAAAAAAADGSEkehq3BmSK0Wq3iNVbOxTE5fToa/MsUZH/mM1G9kAAAAAAAAgOMJIdOVJlcYvtM5DmKp95dxCGYb04baDKj3cEJ3aAAAAAAAAMKARRqKnKedZxy3/7HOTwpxUzZ8wVJL0yvp90agKAAAAAAAAAxxhJHqa3L6Jzb61Us3+Pje7uKhAkvTKOsJIAAAAAAAA9EQYiZ4y8qSRc6zzrW/2udm5x42Q22loS0WttpTXRqk4AAAAAAAADFSEkQguMFW77+tGZqW6tXDKcEnSK+vLolEVAAAAAAAABjDCSAQ35XzruHO51FLf52aBqdrr98k0zSgUBgAAAAAAgIGKMBLBDZ8mZY+RvM3Sjvf63GzxtDylepwqPdyoz0urolcfAAAAAAAABhzCSARnGB2jI7f2fap2isepc6bnSWIjGwAAAAAAAHRFGIne+deN3PqW5PP1udnFM62p2q99sV9t3r63AwAAAAAAwOBGGInejZ4nedKl+kqpfH2fmy2YOEzZqW4drGvWip2Ho1ggAAAAAAAABhLCSPTO5ZHGL7TOt73T52Yel0PnzxghiV21AQAAAAAA0IEwEkc3cbF13L40pGb+XbXf2FCuljamagMAAAAAAIAwEsfiDyP3rpYa+j7l+qSxOcpN96i2qU2rdjFVGwAAAAAAAISROJbsQmnYVMn0STuX97mZw2Fo0VRrV+13iiuiVBwAAAAAAAAGEsJIHFtgqnbf142UpMXTrTBy6aYKmaYZ6aoAAAAAAAAwwBBG4tgmnW0dt78j+fq+/uOCiblKdjtUVtWoTftrolQcAAAAAAAABgrCSBzb6HmSO02qq5AqvuxzsxSPUwsmDpMkvbPpQLSqAwAAAAAAwABBGIljcyVJ48+wzreFtqv2Of6p2sXlka4KAAAAAAAAAwxhJPpm4iLruH1ZSM3OmjZchiFtKKvR/urGKBQGAAAAAACAgYIwEn0zsX3dyNKVUmNVn5vlpifpxNFDJEnvbGJXbQAAAAAAgERGGIm+GTJGyp0smV5p5/KQmp7dPlX7bcJIAAAAAACAhEYYib6b2GlX7RAsnmaFkSt2HlJtU2ukqwIAAAAAAMAAQRiJvptwlnXc+b5kmn1uNnF4usbnpqnVa+r9rZVRKg4AAAAAAADxjjASfTdmnuRwS9V7pCO7Q2q62L+rNlO1AQAAAAAAEhZhJPrOkyaNmmud73o/pKaLpg6XJH247aB8vr6PqgQAAAAAAMDgQRiJ0Iw73TruDC2MnDV6iNI8Th2ub9Gm/TVRKAwAAAAAAADxjjASoRl/hnXc9YHk8/W5mcfl0LwJQyVZoyMBAAAAAACQeAgjEZqRcyR3qtRwUKosDqnpgom5kqQPt7GJDQAAAAAAQCIijERoXB5p9DzrPMSp2qdNHiZJ+mz3ETW2eCNdGQAAAAAAAOIcYSRCF5iqHVoYOT43TSOzU9Ti9WnlrkNRKAwAAAAAAADxjDASoRvXHkbu/ljytvW5mWEYOm2Sf6o260YCAAAAAAAkGsJIhC7/BCk5W2qplfatDanpaZOsqdqsGwkAAAAAAJB4CCMROodDGneadR7iVO35E4bKMKStFXWqqGmKQnEAAAAAAACIV4SR6B//VO0QN7EZkubRCSOzJDFVGwAAAAAAINEQRqJ/xi+0jqWrpNbGkJoyVRsAAAAAACAxEUaif4ZOlDJGSN5mac+KkJr6N7H5aNtB+XxmNKoDAAAAAABAHCKMRP8YRqddtT8Kqems0UOU5nHqUH2ListrolAcAAAAAAAA4hFhJPpvzDzrWLoypGYel0OnjB8qiXUjAQAAAAAAEglhJPpvdHsYuXe11NYSUtP5E62p2it2Hop0VQAAAAAAAIhThJHov9zJUkqO1NYk7V8fUtOTx+VIkj7bfURe1o0EAAAAAABICISR6D/D6BgduefTkJpOG5GpjGSX6prbtGkf60YCAAAAAAAkAsJIhGf0KdYxxDDS6TA0d6w1OnLlLqZqAwAAAAAAJALCSIQnMDJyheTzhdTUP1V7xc7Dka4KAAAAAAAAcYgwEuEZUSS5UqTGw9KhbSE1Pbl9R+3Vuw/Lx7qRAAAAAAAAgx5hJMLj8kij5ljnJZ+E1PT4gkyleZyqbmzV5vLaKBQHAAAAAACAeEIYifAF1o1cEVIzl9Oh2e3rRq5i3UgAAAAAAIBBjzAS4evnjtpSx7qRK3exbiQAAAAAAMBgRxiJ8I2aKxkOqapEqtkXUlN/GLlq12GZJutGAgAAAAAADGaEkQhfcqaUd7x1HuLoyBNGZSvZ7dCh+hZtP1AXheIAAAAAAAAQLwgjERlj5lvHENeN9LgcOnH0EEnSCqZqAwAAAAAADGqEkYgM/yY2Jf1ZN3KoJGnlTjaxAQAAAAAAGMwIIxEZ/k1sKjZITdUhNT15POtGAgAAAAAAJALCSERGRr40ZKwkU9r7WUhNZxZmy+N06EBts3YfaohKeQAAAAAAALAfYSQiZ+Qc61i2NqRmyW6nigqzJEmrd7NuJAAAAAAAwGBFGInIGTnbOpatCbnp7DHWVO21JUciWREAAAAAAADiCGEkIqdzGBni2o+zx1g7aq8hjAQAAAAAABi0CCMROSNOkBwuqf6AVL03pKYnjs6WJG07UKfqhtYoFAcAAAAAAAC7EUYictwpUt5x1nmIU7WHpidpXG6aJGltKaMjAQAAAAAABiPCSERWGOtGnjjamqrNupEAAAAAAACDE2EkIisQRoa2o7bEupEAAAAAAACDHWEkIssfRu77XPJ5Q2rqDyPXlVapzeuLdGUAAAAAAACwGWEkIit3suRJl1rrpcrNITWdNDxdGckuNbR4tbm8NkoFAgAAAAAAwC5xFUZ+8MEHuuiii1RQUCDDMPTSSy8ds83y5ct14oknKikpSRMnTtSTTz4Z9TpxFA6nVDDLOg9x3UiHwwisG8lUbQAAAAAAgMEnrsLI+vp6FRUV6eGHH+7T/bt27dIFF1ygM888U+vWrdNtt92mb33rW3rrrbeiXCmOKoxNbFg3EgAAAAAAYPBy2V1AZ+edd57OO++8Pt//6KOPaty4cfrVr34lSZo2bZo++ugjPfTQQ1qyZEm0ysSxEEYCAAAAAAAgiLgaGRmqTz/9VIsXL+5ybcmSJfr00097bdPc3KyampouL0SYP4ys2CS1NITUtKgwWw5DKqtqVHl1UxSKAwAAAAAAgF0GdBhZXl6uvLy8Ltfy8vJUU1OjxsbGoG3uv/9+ZWVlBV6FhYWxKDWxZBZI6fmS6ZXKvwipaXqSS1PzMyVJa/cwOhIAAAAAAGAwGdBhZH/ccccdqq6uDrxKS0vtLmnwMYyO0ZF7Pwu5OVO1AQAAAAAABqcBHUbm5+eroqKiy7WKigplZmYqJSUlaJukpCRlZmZ2eSEKRp5oHVk3EgAAAAAAAO0GdBg5b948LVu2rMu1pUuXat68eTZVhIDAJjb9Hxm5cV+1mlq9kawKAAAAAAAANoqrMLKurk7r1q3TunXrJEm7du3SunXrtGfPHknWFOvrrrsucP/NN9+snTt36vvf/742b96sRx55RM8++6y++93v2lE+OiuYZR2r9kgNh0NqOmpIinLTPWr1mtq4jw2GAAAAAAAABou4CiM/++wzzZo1S7NmWUHW7bffrlmzZunuu++WJO3fvz8QTErSuHHj9Prrr2vp0qUqKirSr371K/3pT3/SkiVLbKkfnaRkS9ljrPPyL0NqahiGikZlS5LWl1ZFtCwAAAAAAADYx2V3AZ0tXLhQpmn2+vmTTz4ZtM3nn38exarQbyNOkKpKrB21x58RUtOZhdlatvmA1u+tik5tAAAAAAAAiLm4GhmJQSa/yDqGODJSkooKsyUxMhIAAAAAAGAwIYxE9OTPsI77vwi56QmjsiRJuw816Eh9SySrAgAAAAAAgE0IIxE9I06wjge3Sq2NITXNTvVoXG6aJDFVGwAAAAAAYJAgjET0ZIyQUnMl0ytVbAq5+czAVO3qCBcGAAAAAAAAOxBGInoMo2N0ZHnoU7WL2qdqMzISAAAAAABgcCCMRHT5143sTxjZPjJyXWnVUXdZBwAAAAAAwMBAGInoym8fGdmPTWymF2TK7TR0uL5Fe4+EtuYkAAAAAAAA4g9hJKJrRJF1rNgo+bwhNU1yOTV9RKYka3QkAAAAAAAABjbCSERXznjJnSa1NUoHt4XcvCiwiU1VZOsCAAAAAABAzBFGIrocTinvOOu8/MuQmxeNypbEyEgAAAAAAIDBgDAS0RfYUXt9yE1njs6WJG3YV61Wry+CRQEAAAAAACDWCCMRfWFsYjNuaJoykl1qavVpa0VthAsDAAAAAABALBFGIvoCIyO/kEwzpKYOhxGYqr2+tDrChQEAAAAAACCWCCMRfcOmSYZTajwi1ZSF3LyoMEuStK70SKQrAwAAAAAAQAwRRiL63MnSsKnWeT+mas8sHCKJkZEAAAAAAAADHWEkYqPzVO0QFY2yRkZuPVCruua2SFYFAAAAAACAGCKMRGyEsYnN8MxkFWQlyzSlDWWMjgQAAAAAABioCCMRG/nHW8cDG/vVfObobEnSutKqyNQDAAAAAACAmCOMRGwMn24dj+yWWupDbt6xo3ZVxEoCAAAAAABAbBFGIjbScqW04db5gc0hNy8qzJZEGAkAAAAAADCQEUYidoZPs479mKo9Y2SWHIa0r7pJB2qaIlwYAAAAAAAAYoEwErGTd5x1PFAcctO0JJcm52VIYt1IAAAAAACAgYowErHjHxlZ0b9NbALrRu6tikw9AAAAAAAAiCnCSMTO8P6PjJQ6rxtZHaGCAAAAAAAAEEuEkYid4VOtY/0Bqf5gyM2LCrMkWSMjfT4zkpUBAAAAAAAgBggjETueNGnIWOv8wKaQm0/Jy1Cy26HapjbtPFgf2doAAAAAAAAQdYSRiC3/VO2K0MNIl9OhGSPbR0eyiQ0AAAAAAMCAQxiJ2PJvYtOPkZESm9gAAAAAAAAMZISRiK286daxn2HkzNHZkhgZCQAAAAAAMBARRiK2hvvDyGLJDH0TGv/IyE37a9TU6o1gYQAAAAAAAIg2wkjE1tCJksMttdRJVXtCbj5qSIqGpnnU6jVVvL8mCgUCAAAAAAAgWggjEVtOt5Q72To/UBxyc8MwVFSYLYmp2gAAAAAAAAMNYSRiL7Bu5MZ+NZ/ZHkauI4wEAAAAAAAYUAgjEXud143sh8DIyL3VESoIAAAAAAAAsUAYidjzh5EV/dtRu2hUliRp18F6VTW0RKoqAAAAAAAARBlhJGLPP0374FbJ2xpy8+xUj8blpklidCQAAAAAAMBAQhiJ2MsqlDwZkq9VOrS9X134R0eu21MVwcIAAAAAAAAQTYSRiD3DkIZPs84rwtvEZv3eqsjUBAAAAAAAgKgjjIQ9/GFkmJvYrCutkmmaESoKAAAAAAAA0UQYCXv4w8iDW/rVfHpBptxOQ4frW7T3SGMECwMAAAAAAEC0EEbCHrmTrWNl/8LIJJdT00dkSpI+L62KUFEAAAAAAACIJsJI2GPYVOt4eKfU1tKvLgLrRhJGAgAAAAAADAiEkbBHZkH7jtptViDZD53XjQQAAAAAAED8I4yEPQxDGuafqr25X134R0ZuKKtWq9cXocIAAAAAAAAQLYSRsI9/qvbBrf1qPnZomjKTXWpu82lLeW0ECwMAAAAAAEA0EEbCPrnhjYx0OAymagMAAAAAAAwghJGwj39kZGX/RkZKbGIDAAAAAAAwkBBGwj7+NSMPbpV83n51MZORkQAAAAAAAAMGYSTskz1GciVL3mapqqRfXZwwKluStL2yTrVNrREsDgAAAAAAAJFGGAn7OJxS7iTrvHJLv7oYlpGkkdkpMk3py73VESwOAAAAAAAAkUYYCXvlTrGO/dzERpJmjs6WJK3bWxV+PQAAAAAAAIgawkjYKxKb2LRP1V63pyr8egAAAAAAABA1hJGwl38TmwiMjFzPyEgAAAAAAIC4RhgJe/lHRh7cKplmv7o4viBLToehippm7a9ujGBxAAAAAAAAiCTCSNgrZ7zkcEktdVJNWb+6SPE4NSUvQ5K0vrQqgsUBAAAAAAAgkggjYS+nW8qZYJ2HMVW7qDBbkvQ5YSQAAAAAAEDcIoyE/Yb5d9Tu/yY2s9rDSEZGAgAAAAAAxC/CSNgvEEaGPzLyy73V8vr6t/YkAAAAAAAAooswEvbrvIlNP00cnq40j1P1LV5tP1AXocIAAAAAAAAQSYSRsF/nkZH93FHb6TA0Y1SWJGld6ZFIVQYAAAAAAIAIIoyE/YZOlGRIjUek+oP97mZm4RBJ0rrS6ggVBgAAAAAAgEgijIT93CnSkLHWeRjrRs4s9I+MrAq/JgAAAAAAAEQcYSTig3+qdhjrRvo3sdlaUauGlrYIFAUAAAAAAIBIIoxEfMidZB3DCCNHZKUoLzNJXp+pDWU1ESoMAAAAAAAAkUIYifiQG/7ISEkqGpUtSVrPVG0AAAAAAIC4QxiJ+JA72TpWhhdGzhydLYl1IwEAAAAAAOIRYSTig3+ads1eqbmu393MbB8ZSRgJAAAAAAAQfwgjER9Sc6S0Ydb5oe397mbGqCwZhlRW1agDtU0RKg4AAAAAAACRQBiJ+OGfqh3GupEZyW5NHp4hSVpbUhWBogAAAAAAABAphJGIHxHYUVuSThwzRJK0ds+RcCsCAAAAAABABBFGIn74d9Su3BJWN3Paw8g1JYSRAAAAAAAA8YQwEvEjME17W1jdzG4PI7/cW63mNm+4VQEAAAAAACBCCCMRP4a1h5GHd0jetn53M2ZoqoamedTi9WlDWU2EigMAAAAAAEC4CCMRPzJHSa4UydsiVZX0uxvDMALrRq4pORyp6gAAAAAAABAmwkjED4dDyp1onYe5iQ3rRgIAAAAAAMQfwkjElwhtYjM7EEZWyTTNcKsCAAAAAABABBBGIr5EaBOb40dmye00dLCuWaWHGyNQGAAAAAAAAMJFGIn44t/E5mB4IyOT3U4dPzJLkrRmD+tGAgAAAAAAxAPCSMSXwMjIrVKY06v960Z+tpt1IwEAAAAAAOIBYSTiS84EyXBITdVSfWVYXc1mExsAAAAAAIC4QhiJ+OJOlrLHWOdhbmJz4mgrjNxSUavaptZwKwMAAAAAAECYCCMRfzpP1Q7D8MxkFeakyDSldaVV4dcFAAAAAACAsBBGIv7kTrKOYYaRkjRnTI4k1o0EAAAAAACIB4SRiD/DpljHCISRJ7avG7l2D2EkAAAAAACA3QgjEX8C07S3hd3V7PZ1I9eWHFGb1xd2fwAAAAAAAOg/wkjEH38YWV0qNdeF1dWU/AxlJrtU3+LVpv01ESgOAAAAAAAA/UUYifiTmiOl5lrnh7aH1ZXTYWjuWGvdyFW7DodbGQAAAAAAAMJAGIn4FKEdtSXp5PFWGLliJ2EkAAAAAACAnQgjEZ+GRS6MPGncUEnS6t2H5fOZYfcHAAAAAACA/iGMRHyK4MjI4woylepxqrqxVVsqasPuDwAAAAAAAP1DGIn45A8jK8MPI91Oh2aPsXbVZt1IAAAAAAAA+xBGIj75w8jDOyRvW9jdnTzOWjdy5a5DYfcFAAAAAACA/iGMRHzKKpRcKZK3RaoqCbs7/7qRq3YdlmmybiQAAAAAAIAdCCMRnxwOKXeidR6BdSOLCrPkcTl0sK5FOw/Wh90fAAAAAAAAQkcYifgVwU1sklxOzSrMliSt3Mm6kQAAAAAAAHYgjET8iuAmNlLHupGrWDcSAAAAAADAFoSRiF8RHBkpSSePt9aNXMm6kQAAAAAAALYgjET8CoSRW6QIhIezRmfL5TC0v7pJe480ht0fAAAAAAAAQkMYifg1dKIkQ2qqluorw+4u1ePSjFFZkqzRkQAAAAAAAIgtwkjEL3eyNGSMdR6pqdrjrKnaK3aybiQAAAAAAECsEUYivgU2sdkSke5OGW9tYvPpjkOsGwkAAAAAABBjhJGIb4F1I7dFpLuTxuXI7TRUVtWokkMNEekTAAAAAAAAfUMYifjWeRObCEj1uDSrcIgk6eMdByPSJwAAAAAAAPqGMBLxLcIjIyVp/kRr3chPtrNuJAAAAAAAQCwRRiK+DZtiHatLpZb6iHS5YGKuJOmTHQfl87FuJAAAAAAAQKwQRiK+peZIqdZIxkiNjiwqzFaax6kjDa0qLq+JSJ8AAAAAAAA4NsJIxL/c9tGREQoj3U6HThpn7ar98XbWjQQAAAAAAIgVwkjEv9xJ1jFCm9hI0qntU7U/Zt1IAAAAAACAmCGMRPwLbGKzNWJd+sPIVbsOq6XNF7F+AQAAAAAA0DvCSMS/YZGdpi1JU/IyNDTNo8ZWr9aVVkWsXwAAAAAAAPSOMBLxzz9N+9B2ydsWkS4dDkPzJlgb47BuJAAAAAAAQGwQRiL+ZY2WXMmSt0WqKolYt/6p2p/sIIwEAAAAAACIBcJIxD+HQxrq38QmcutGLmgPIz/fU6X65siMuAQAAAAAAEDvCCMxMORGPowszElVYU6K2nymVu06HLF+AQAAAAAAEBxhJAaGwCY2kQsjpY7RkR9uY6o2AAAAAABAtMVlGPnwww9r7NixSk5O1sknn6xVq1b1em9ra6vuvfdeTZgwQcnJySoqKtKbb74Zw2oRE/6RkZWRDSPPmDxMkvT+1gMR7RcAAAAAAAA9xV0Y+cwzz+j222/XPffco7Vr16qoqEhLlizRgQPBw6I777xTf/jDH/S73/1OmzZt0s0336zLLrtMn3/+eYwrR1TlTraOB7dKphmxbudPzJXTYWhHZb1KDzdErF8AAAAAAAD0FHdh5IMPPqgbb7xRN9xwg6ZPn65HH31UqampeuKJJ4Le/9RTT+lHP/qRzj//fI0fP1633HKLzj//fP3qV7+KceWIqqETJRlSU5VUXxmxbjOT3Zo9eogk6f2tkesXAAAAAAAAPcVVGNnS0qI1a9Zo8eLFgWsOh0OLFy/Wp59+GrRNc3OzkpOTu1xLSUnRRx99FNVaEWPuFCl7tHUe4XUjz5jin6pNGAkAAAAAABBNcRVGHjx4UF6vV3l5eV2u5+Xlqby8PGibJUuW6MEHH9S2bdvk8/m0dOlSvfjii9q/f3/Q+5ubm1VTU9PlhQEiSpvY+NeN/GT7QbW0+SLaNwAAAAAAADrEVRjZH7/5zW80adIkTZ06VR6PR9/+9rd1ww03yOEI/qXdf//9ysrKCrwKCwtjXDH6zb9uZIQ3sZk+IlO56R7Vt3i1puRIRPsGAAAAAABAh7gKI3Nzc+V0OlVRUdHlekVFhfLz84O2GTZsmF566SXV19erpKREmzdvVnp6usaPHx/0/jvuuEPV1dWBV2lpacS/DkSJf0ftCI+MdDgMnT6JqdoAAAAAAADRFldhpMfj0ezZs7Vs2bLANZ/Pp2XLlmnevHlHbZucnKyRI0eqra1NL7zwgi655JKg9yUlJSkzM7PLCwNEbnSmaUusGwkAAAAAABALLrsL6O7222/X9ddfrzlz5uikk07Sr3/9a9XX1+uGG26QJF133XUaOXKk7r//fknSypUrVVZWppkzZ6qsrEw/+clP5PP59P3vf9/OLwPR4J+mXV0qtdRLnrSIdX3apGEyDKl4f40qapqUl5l87EYAAAAAAAAISdyFkVdeeaUqKyt19913q7y8XDNnztSbb74Z2NRmz549XdaDbGpq0p133qmdO3cqPT1d559/vp566illZ2fb9BUgatKGSik5UuNh6dB2aURRxLrOSfPohFHZWl9apfe3Vuorc1hLFAAAAAAAINIM0zRNu4uwU01NjbKyslRdXc2U7YHgiXOlPZ9Kl/9JOuGKiHb94NKt+u2ybbrghBF6+OoTI9o3AAAAAADAYBVKvhZXa0YCxxSlTWwk6YzJ1rqRH207qDavL+L9AwAAAAAAJDrCSAwsgU1stkS865mF2cpKcau6sVXrSqsi3j8AAAAAAECiI4zEwOLfxObgtoh37XQYgdGRyzYfiHj/AAAAAAAAiY4wEgOLf5r2oe2Szxvx7hdNGy5JereYMBIAAAAAACDSCCMxsGSPllzJkrdFOrI74t2fMXmYnA5DWypqVXq4IeL9AwAAAAAAJDLCSAwsDqc0dKJ1HoWp2tmpHs0eM0SS9C5TtQEAAAAAACKKMBIDT2DdyMhvYiNJi9unar9TXBGV/gEAAAAAABIVYSQGHn8YWbk1Kt2fNTVPkrRy52HVNbdF5RkAAAAAAACJiDASA8/wqdaxsjgq3U8YlqYxQ1PV4vXpo22VUXkGAAAAAABAIiKMxMAzfLp1PLBZ8vki3r1hGFrUPjryHXbVBgAAAAAAiBjCSAw8OeMlp0dqrZeq90TlEYva1418b/MB+XxmVJ4BAAAAAACQaAgjMfA43R3rRh6IzlTtuWNzlJHk0qH6Fq3bWxWVZwAAAAAAACQawkgMTMOnWccDm6LSvcfl0OmTh0mS3mWqNgAAAAAAQESEFUbu2bNHH330UZdr69ev13XXXacrr7xSL730UjjdA70LhJGbo/YI/1Ttd4orovYMAAAAAACAROIKp/Gtt96quro6vfPOO5KkiooKnXnmmWppaVFGRoaef/55Pffcc7r88ssjUiwQMMwfRkZnmrYkLZwyXA5D2lxeq9LDDSrMSY3aswAAAAAAABJBWCMjV61apbPPPjvw/q9//asaGxu1fv16lZWVadGiRXrggQfCLhLowT8y8uAWydsWlUfkpHk0Z2yOJGnpJkZHAgAAAAAAhCusMPLw4cMaPnx44P1rr72mM844QxMmTJDD4dDll1+uzZujN40WCSx7jOROlbwt0uGdUXvMOdPzJElvbyqP2jMAAAAAAAASRVhh5LBhw1RSUiJJqqqq0ooVK7RkyZLA521tbWpri86oNSQ4h0MaNtU6r4zeVO0lx+VLklbtOqwj9S1Rew4AAAAAAEAiCCuMXLx4sX7729/qwQcf1HXXXSefz6dLL7008PmmTZtUWFgYbo1AcMOnW8corhtZmJOqaSMy5TOlZZvZVRsAAAAAACAcYYWRP/vZzzRt2jR973vf09tvv60HHnhA48aNkyQ1Nzfr2Wef1aJFiyJSKNDD8PaRkQc2RfUxganaG5mqDQAAAAAAEI6wdtPOy8vTxx9/rOrqaqWkpMjj8QQ+8/l8WrZsGSMjET3Do7+jtiSdc1yefrNsmz7YVqnGFq9SPM6oPg8AAAAAAGCwCmtkpF9WVlaXIFKSUlJSVFRUpJycnEg8AujJP0370A6prTlqj5k+IlMjs1PU1OrTB9sqo/YcAAAAAACAwS6sMHLZsmX65S9/2eXaE088odGjRysvL0/f/e535fV6wyoQ6FXGCCk5SzK90sFtUXuMYRg65zj/VO2KqD0HAAAAAABgsAsrjPzJT36i9evXB95/+eWXuummmzRs2DAtXLhQv/3tb/XAAw+EXSQQlGHEZBMbSTpnurWr9rLNFWrz+qL6LAAAAAAAgMEqrDCyuLhYc+bMCbx/6qmnlJmZqQ8//FDPPPOMbrzxRv31r38Nu0igV8Nis4nN3LFDNCTVraqGVq3efSSqzwIAAAAAABiswgoj6+vrlZmZGXj/5ptv6txzz1Vqaqokae7cuSopKQmvQuBoYjQy0uV0aNG09qnam9hVGwAAAAAAoD/CCiMLCwu1evVqSdL27du1YcMGnXPOOYHPDx8+rKSkpPAqBI4msKN2dEdGStI50zvWjTRNM+rPAwAAAAAAGGxc4TS+5pprdO+996qsrEwbN27UkCFDdMkllwQ+X7NmjSZPnhx2kUCv/GFkVYnUUi950qL2qNMmDVOy26GyqkZt2l+j4wqyovYsAAAAAACAwSiskZE//vGP9cMf/lClpaUaPXq0XnrpJWVnZ0uyRkUuX75cF198cSTqBIJLy5XShlvnlZuj+qgUj1OnTxomiV21AQAAAAAA+sMwE3y+aU1NjbKyslRdXd1l/UsMIH+5WNr1vnTx76QTr4vqo55fs1ffe269po3I1BvfOS2qzwIAAAAAABgIQsnXwhoZ2VldXZ2Ki4tVXFysurq6SHULHFv+DOtYviHqj1o0dbgchlS8v0alhxui/jwAAAAAAIDBJOwwcvXq1TrzzDM1ZMgQHX/88Tr++OM1ZMgQnXXWWfrss88iUSNwdIEw8suoP2pImkcnjcuRJL29ianaAAAAAAAAoQhrA5uVK1dq4cKF8ng8+ta3vqVp06zNRIqLi/X3v/9dp59+upYvX66TTjopIsUCQXUOI30+yRGxAb9BnTM9Xyt2HtbbG8v1zQXjovosAAAAAACAwSSsNSMXL16s3bt366OPPlJ+fn6XzyoqKnTqqadq3LhxWrp0adiFRgtrRg4C3lbpvpGSt1m6dZ2UE92AcO+RBi34+XtyGNJnd56tnDRPVJ8HAAAAAAAQz2K2ZuTKlSt100039QgiJSkvL0//+q//qhUrVoTzCODYnG5puDUqV+VfRP1xo4ak6riCTPlMaVkxU7UBAAAAAAD6Kqww0uFwqK2trdfPvV6vHFGeMgtIium6kZI1VVti3UgAAAAAAIBQhJUUzp8/Xw8//LBKSkp6fLZnzx498sgjOvXUU8N5BNA3+SdYx1iFkcflSZI+3FapxhZvTJ4JAAAAAAAw0IW1gc19992n008/XVOnTtVll12myZMnS5K2bNmil19+WU6nU/fff39ECgWOKsYjI6fmZ6gwJ0Wlhxv1/tZKnXt8z6UKAAAAAAAA0FVYYeSsWbO0cuVK/fjHP9Yrr7yihoYGSVJqaqrOPfdc/eQnP1Fubm5ECgWOKu8461hTJtUfktKGRvVxhmHonOn5evyjXXp7YzlhJAAAAAAAQB+EvaDj9OnT9b//+7+qqanR/v37tX//ftXU1OjFF1/Uq6++qsLCwkjUCRxdcqaUM946j8EmNpICAeQ7xRVqafPF5JkAAAAAAAADWcR2l3E4HMrLy1NeXh6b1sAeMZ6qfeLoIcpNT1JNU5tW7DwUk2cCAAAAAAAMZKSGGDxiHEY6HUZgI5s3N5bH5JkAAAAAAAADGWEkBo8Y76gtSeceZ03Vfntjhbw+M2bPBQAAAAAAGIgIIzF4+EdGHtwqtTbG5JHzJgxVZrJLB+uatXbPkZg8EwAAAAAAYKAKeTfttWvX9vneffv2hdo90H8ZI6TUXKnhoHSgWBp5YtQf6XY6tHh6nl5cW6Y3N5Rr7ticqD8TAAAAAABgoAo5jJwzZ44Mw+jTvaZp9vleIGyGYY2O3PmetaN2DMJIyZqq7Q8j77xgGt/zAAAAAAAAvQg5jPzzn/8cjTqAyAiEkbFbN/L0ycOU4naqrKpRG8pqNGNUVsyeDQAAAAAAMJCEHEZef/310agDiAwbNrFJdjt15tRh+ueX5Xpz437CSAAAAAAAgF6wgQ0GF/8mNuUbJJ8vZo9d0r6r9psbymP2TAAAAAAAgIGGMBKDy9CJkitFaq2XDm2P2WPPmjpcHqdDOyrrtf1AbcyeCwAAAAAAMJAQRmJwcbqkEUXWedmamD02I9mtBZNyJTE6EgAAAAAAoDeEkRh8Rs62jmWfxfSx5/qnam8kjAQAAAAAAAiGMBKDzyh/GBm7kZGStHh6nhyGtKGsRqWHG2L6bAAAAAAAgIGAMBKDz8g51rF8g9TaFLPH5qR5dPK4oZKktxgdCQAAAAAA0ANhJAaf7NFS2jDJ1yqVfxHTR597PLtqAwAAAAAA9IYwEoOPYXSMjtwb23Ujl7SvG7lmzxEdqIndqEwAAAAAAICBgDASg5NNm9jkZyVr1uhsmab09qaKmD4bAAAAAAAg3hFGYnCyaRMbqWNXbdaNBAAAAAAA6IowEoNTwYnW8chuqf5gTB/tn6r96Y5DqmpoiemzAQAAAAAA4hlhJAanlGwpd7J1HuPRkWNz0zQ1P0NtPlPvFB+I6bMBAAAAAADiGWEkBi//upEx3sRGYldtAAAAAACAYAgjMXjZtImN1BFGfrCtUnXNbTF/PgAAAAAAQDwijMTgNWqOdSxbI5lmTB89JS9D43PT1NLm07JidtUGAAAAAACQCCMxmOUdL7mSpaZq6dCOmD7aMAxdcMIISdLrX+yP6bMBAAAAAADiFWEkBi+nWxpRZJ3bMFXbH0Yu31qp2qbWmD8fAAAAAAAg3hBGYnCzcRObKXkZmjDMP1WbXbUBAAAAAAAIIzG42biJjWEYumCGNTryNaZqAwAAAAAAEEZikCs8yTru/0Jqrov54y84oUCS9AFTtQEAAAAAAAgjMchlj5ayRkumVypdEfPHT85L18Th6Wrx+vQOu2oDAAAAAIAERxiJwW/sAuu4++OYP7rzVG121QYAAAAAAImOMBKDXyCM/MiWx/t31f5g60FVNzJVGwAAAAAAJC7CSAx+/jBy31pb1o2cnJehyXntU7U3MVUbAAAAAAAkLsJIDH5DxkhZhZKvTSpdaUsJF8ywNrJ57Yt9tjwfAAAAAAAgHhBGIjH4R0eWxH7dSKljqvaH2w7qcH2LLTUAAAAAAADYjTASicHmdSMnDk/X8SMz1eYz9fqXbGQDAAAAAAASE2EkEoM/jCxbI7XU21LCJUUjJUkvf15my/MBAAAAAADsRhiJxJA9RsocZeu6kRcVFcgwpM9Kjqj0cIMtNQAAAAAAANiJMBKJwTBsn6qdn5WseeOHSpJeWc9GNgAAAAAAIPEQRiJxBMJIezaxkaRLZ1pTtV/6vEymadpWBwAAAAAAgB0II5E44mDdyHNn5MvjcmjbgToV76+1pQYAAAAAAAC7EEYicQwZK2WOlHytUukqW0rITHbrrCnDJUkvr2MjGwAAAAAAkFgII5E44mDdSEm6dFaBJGvdSJ+PqdoAAAAAACBxEEYisYw9zTrufM+2EhZOGa6MZJf2Vzdp5a7DttUBAAAAAAAQa4SRSCwTF1vHsrVSXaUtJSS7nTr/+BGSrI1sAAAAAAAAEgVhJBJL5ggpf4YkU9qxzLYyLj/R2lX7tS/2qaGlzbY6AAAAAAAAYokwEoln0jnWcdvbtpVw0rgcjc5JVX2LV29uKLetDgAAAAAAgFgijETi8YeR25dJPq8tJRiGoX+ZPUqS9Nxne22pAQAAAAAAINYII5F4Rs6RkrOlpipp72e2lfF/Zo+SYUif7jyk0sMNttUBAAAAAAAQK4SRSDxOlzRxkXVu41TtkdkpOnVCriTp+TWMjgQAAAAAAIMfYSQSUxysGylJV8yxpmo/v2avfD7T1loAAAAAAACijTASiWnCIkmGVP6FVLPftjLOmZ6vjCSXyqoatWLnIdvqAAAAAAAAiAXCSCSm9GHSyBOt8+3v2FZGisepC4sKJEnPMVUbAAAAAAAMcoSRSFxxNlX7jQ37VdPUamstAAAAAAAA0UQYicQ16WzruOM9yWtfCDirMFsThqWpqdWnV9fvs60OAAAAAACAaCOMROIaMUtKzZVaaqU9n9pWhmEYumruaEnS0yv3yDTZyAYAAAAAAAxOhJFIXA5Hx+jILW/YWsq/zB4lj8uhjftqtK60ytZaAAAAAAAAooUwEolt6oXWsfhVycYRiUPSPLpwxghJ0v+s3GNbHQAAAAAAANFEGInENnGR5E6Vqkul/etsLeWaU8ZIkl5dv09VDS221gIAAAAAABANhJFIbO6Ujqnam16xtZQTR2dran6Gmtt8emFtma21AAAAAAAARANhJDDtYutY/IqtU7UNw9C17aMj/2dlCRvZAAAAAACAQYcwEph0juT0SIe2S5WbbS3l0lkjleZxamdlvT7decjWWgAAAAAAACKNMBJIzpTGn2mdF79qaynpSS5dOmukJDayAQAAAAAAgw9hJCBJ09unatu8bqQkXXOyNVX7rQ3lOlDTZHM1AAAAAAAAkUMYCUjSlPMlwylVfCkd3mlrKdMLMjV37BC1+Uz95dPdttYCAAAAAAAQSYSRgCSl5khjF1jnxa/ZW4ukby4YL0n624o9amhps7kaAAAAAACAyCCMBPymXWQdi+2fqn329DyNGZqq6sZWPb9mr93lAAAAAAAARARhJOA37SJJhrR3tVSzz9ZSnA5D3zh1nCTp8Y92yeszba0HAAAAAAAgEggjAb+MfKnwJOs8DqZqXzFnlLJS3Co51KClmyrsLgcAAAAAACBshJFAZ3E0VTvV49I1J4+WJP3pQ3s31QEAAAAAAIgEwkigM38YWfKxVH/Q3lokXT9/rNxOQ5+VHNHne47YXQ4AAAAAAEBYCCOBzoaMlfJPkEyftOWfdlejvMxkXVw0UpL0pw932VwNAAAAAABAeAgjge6mX2wdi1+1t4523zrN2sjmnxv2a/uBWpurAQAAAAAA6D/CSKC7ae1h5I73pKZqe2uRNG1Eps6ZnifTlH6zbLvd5QAAAAAAAPQbYSTQ3bApUu5kydcqbX3b7mokSbctnixJeu2LfdpawehIAAAAAAAwMBFGAsH4R0cWv2xvHe2mF2TqvOPzrdGR72yzuxwAAAAAAIB+IYwEgvHvqr3tHamlwd5a2n1n8SRJ0utf7tfm8hqbqwEAAAAAAAhdXIaRDz/8sMaOHavk5GSdfPLJWrVq1VHv//Wvf60pU6YoJSVFhYWF+u53v6umpqYYVYtBaUSRlD1aamuUtr9jdzWSpKn5mbpgxghJ0q+XMjoSAAAAAAAMPHEXRj7zzDO6/fbbdc8992jt2rUqKirSkiVLdODAgaD3P/300/rhD3+oe+65R8XFxXr88cf1zDPP6Ec/+lGMK8egYhidpmrHx67akjU60jCkNzeWa+M++zfXAQAAAAAACEXchZEPPvigbrzxRt1www2aPn26Hn30UaWmpuqJJ54Iev8nn3yiU089VVdffbXGjh2rc845R1/96lePOZoSOCZ/GLn1Tamtxd5a2k3Oy9CFJxRIkh54a4vN1QAAAAAAAIQmrsLIlpYWrVmzRosXLw5cczgcWrx4sT799NOgbebPn681a9YEwsedO3fqn//8p84///yY1IxBbNRcKW241FwjlXxsdzUB3108SS6Hofe2VGr5luAjhgEAAAAAAOJRXIWRBw8elNfrVV5eXpfreXl5Ki8vD9rm6quv1r333qsFCxbI7XZrwoQJWrhwYa/TtJubm1VTU9PlBQTlcEiTl1jnW96wt5ZOxg9L19fnj5Uk/fS1TWr1+uwtCAAAAAAAoI/iKozsj+XLl+u+++7TI488orVr1+rFF1/U66+/rp/+9KdB77///vuVlZUVeBUWFsa4YgwoU9pH2G55QzJNe2vp5P9bNEk5aR7tqKzX31aU2F0OAAAAAABAn8RVGJmbmyun06mKioou1ysqKpSfnx+0zV133aWvfe1r+ta3vqUZM2bosssu03333af7779fPl/PEWN33HGHqqurA6/S0tKofC0YJMYvlFzJUvUeqWKj3dUEZKW49b1zpkiSHlq6VYfr42NNSwAAAAAAgKOJqzDS4/Fo9uzZWrZsWeCaz+fTsmXLNG/evKBtGhoa5HB0/TKcTqckyQwyki0pKUmZmZldXkCvPKnS+DOt8ziaqi1JV84t1LQRmappatNDS7faXQ4AAAAAAMAxxVUYKUm33367HnvsMf3lL39RcXGxbrnlFtXX1+uGG26QJF133XW64447AvdfdNFF+v3vf69//OMf2rVrl5YuXaq77rpLF110USCUBMIy5TzruOWf9tbRjdNh6O4Lp0uS/mdliYr3s/4pAAAAAACIby67C+juyiuvVGVlpe6++26Vl5dr5syZevPNNwOb2uzZs6fLSMg777xThmHozjvvVFlZmYYNG6aLLrpI/+///T+7vgQMNv5NbPatlWrLpYzgSwbYYd6EoTp/Rr7++WW5fvjCF3rhlvlyOePudwwAAAAAAACSJMMMNpc5gdTU1CgrK0vV1dVM2UbvHjtLKlsjXfQbafbX7a6mi/LqJp390PuqbWrTHedN1U1nTLC7JAAAAAAAkEBCydcYQgX0RWCqdnytGylJ+VnJuqt9uvavlm7Vjso6mysCAAAAAAAIjjAS6Isp51vHncullnpbSwnmitmjdPrkYWpp8+n7z38hry+hBzwDAAAAAIA4RRgJ9MXw6VL2aKmtyQok44xhGLr/8hlKT3JpTckR/eWT3XaXBAAAAAAA0ANhJNAXhtExOnJzfO2q7TcyO0V3nD9VkvSLtzZr+wGmawMAAAAAgPhCGAn0lX9X7e3vSHG679PVJ43Wgom5amr16f/+z1o1tnjtLgkAAAAAACCAMBLoq9HzJVeKVFcuHdhkdzVBGYahB68sUm56krZU1OrulzfYXRIAAAAAAEAAYSTQV+5kaeyp1vmOd+2t5SiGZyTrt1+dKYchPbdmr579rNTukgAAAAAAACQRRgKhmXCWdYzjMFKS5k/I1e1nT5Yk3f3yBm0ur7G5IgAAAAAAAMJIIDQTFlnHkk+k1kZ7azmGf1s4UadPHqamVp9u+dtaVTW02F0SAAAAAABIcISRQCiGTZEyCqS2JiuQjGMOh6FfXzlTI7NTtOtgvf71r2vU1MqGNgAAAAAAwD6EkUAoDEOaODCmaktSTppHT3x9rjKSXFq1+7D+4/kv5PPF507gAAAAAABg8COMBEI1QNaN9JuSn6FHvzZbLoehV9fv0y/f3mJ3SQAAAAAAIEERRgKhGn+mJEM6sEmq2Wd3NX1y6sRc/ez/nCBJ+v3yHXpqRYnNFQEAAAAAgEREGAmEKjVHKphlne94z95aQvAvs0fptsWTJEl3vbRBz64utbkiAAAAAACQaAgjgf4YYFO1/b6zaJK+Pn+sJOkHL36h59fstbcgAAAAAACQUAgjgf6YuMg67nxP8vnsrSUEhmHonoum67p5Y2Sa0n88v14vriWQBAAAAAAAsUEYCfTHqLmSJ0NqOCSVr7e7mpAYhqH/vPg4XXPyaJmm9O/PrdeznzFlGwAAAAAARB9hJNAfTrc07nTrfPsye2vpB8Mw9NNLjtdXT7ICye8//4V+v3yHTNO0uzQAAAAAADCIEUYC/TV+oXXc/ZGtZfSXw2HovsuO101njJck/fzNzbr3tU3y+QgkAQAAAABAdBBGAv01doF1LF0ptbXYW0s/GYahO86bpjsvmCZJ+vPHu3XbM+vU3Oa1uTIAAAAAADAYEUYC/TVsqpQ6VGptkPattbuasHzrtPH6zVUz5XYaemX9Pl31xxU6UNNkd1kAAAAAAGCQIYwE+svh6BgduftDe2uJgEtmjtSfv36SslLc+nxPlS783Uf6fM8Ru8sCAAAAAACDCGEkEI6xp1nHXQM/jJSkBZNy9cq3T9XkvHQdqG3WlX9YoWdXs9M2AAAAAACIDMJIIBz+MLJ0ldTWbG8tETJmaJpe/LdTteS4PLV4ffr+C1/otn98rtqmVrtLAwAAAAAAAxxhJBCOYVOk1FyprVEqG9jrRnaWnuTS76+Zrf9YMkVOh6GX1u3TBb9l2jYAAAAAAAgPYSQQDsMYVOtGduZwGPq/Z07UszedopHZKdpzuEFXPPqpfrdsm1q9PrvLAwAAAAAAAxBhJBCuce1TtQdZGOk3e0yO/vmd03ThCSPU5jP1q6VbdfF/f6wv91bbXRoAAAAAABhgCCOBcA3CdSO7y0px63dfnaWHrizSkFS3ivfX6NJHPtb9bxSrscVrd3kAAAAAAGCAIIwEwpU7WUobLrU1SXs/s7uaqDEMQ5fNGqWlt5+hi4oK5PWZ+sP7O7X4wff1+hf7ZZqm3SUCAAAAAIA4RxgJhKvLupEf2VtLDOSmJ+l3X52lx66bo4KsZJVVNer/Pr1WV/5xhTbuY+o2AAAAAADoHWEkEAmDdBObozl7ep6W/ftC3bZ4kpLdDq3adVgX/u4j3faPz7X7YL3d5QEAAAAAgDhEGAlEQud1I1ub7K0lhlI8Tt22eLKW/ftCXVRUINOUXlq3T4sefF8/fOELlVU12l0iAAAAAACII4SRQCTkTpLS8yRvs7R3td3VxNzI7BT97quz9Oq3F+jMKcPk9Zn6x+pSLfzle/r+8+u1o7LO7hIBAAAAAEAcIIwEIsEwpDGnWucln9hbi41mjMrSn284SS/cMk/zJwxVq9fUs5/t1eIH39ctf1ujdaVVdpcIAAAAAABsRBgJRMpYfxg5+DexOZbZY3L09I2n6IVb5mvxtDyZpvTGhnJd+vDHuuyRj/XyujK1en12lwkAAAAAAGLMME3TtLsIO9XU1CgrK0vV1dXKzMy0uxwMZAc2S4+cLLlSpB/ukVweuyuKG1sravWH93fq1fX71NIeQuZlJumquaN15dxCFWSn2FwhAAAAAADor1DyNcJIwkhEimlKv5woNRyUvvGWNPoUuyuKO5W1zXp65R79bWWJKmubJUkOQ1o4ZbiumluoM6cOl9vJgG0AAAAAAAYSwsgQEEYiop75mlT8inTWXdLp37O7mrjV0ubTGxv26x+rSvXpzkOB69mpbp0/Y4QuLirQSWNz5HAYNlYJAAAAAAD6IpR8zRWjmoDEMOZUK4xM4E1s+sLjcuiSmSN1ycyR2llZp2dWl+qFtWU6WGeNnHx65R6NyErWhSeM0CUzR+q4gkwZBsEkAAAAAAADHSMjGRmJSCr/Unp0geRJl35QIjnJ+/uqzevTip2H9cr6Mr2xoVy1TW2Bz8bnpumCE0borKnDVTQqmxGTAAAAAADEEaZph4AwEhHl80m/GCc1VUnfelcaNdvuigak5javlm+p1Cvr9+mdTRVqbuvYeXtomkcLpwzXWVOH67TJucpMdttYKQAAAAAAYJo2YBeHQxozX9ryT6nkI8LIfkpyObXkuHwtOS5fdc1temdThZYWV+iDLZU6VN+iF9bu1Qtr98rlMDR3bI7OmjpcCyblakpeBqMmAQAAAACIY4yMZGQkIu2T/5be/rE0aYl0zbN2VzOotHp9+mz3Eb27uULvbj6gHZX1XT7PSfNo3vihmjdhqOZPGKpxuWmsNQkAAAAAQJQxTTsEhJGIuLK10mNnSklZ0g92SQ6n3RUNWiWH6vXu5gNavqVSq3cfVkOLt8vn+ZnJmjdhqE4Zn6PZY3I0PjeNkZMAAAAAAEQYYWQICCMRcd426edjpZZa6aYPpBFFdleUEFrafPpib5U+2XFIn+w4qLUlVWrx+rrck53q1omjh+jE0dk6ccwQzSzMVqqH1SoAAAAAAAgHYWQICCMRFX/7F2n7UmnJ/dK8f7O7moTU1OrVmpIj+mTHQa3efUTrS6u6bIQjSU6HoWkjMnTCqGwdX5ClGSOzNDk/XUkuRrMCAAAAANBXbGAD2G3sqVYYWfIxYaRNkt1OnToxV6dOzJVkjZws3l+jNSVHtGbPEa0tOaL91U3aUFajDWU1gXZup6HJeRk6viBLx4/M1PSCLE3OS1cGu3YDAAAAABA2RkYyMhLRULpaenyxlDJE+o+d1i7biDv7qhr1+Z4qfVlWrY37qvVlWbWqGlqD3jsyO0WT8tI1JS9Dk/IyNCUvQxOHpyvFwyhKAAAAAEBiY2QkYLeCmZI7VWo8IlVulvKm210RgijITlFBdoouOGGEJMk0TZVVNWpDWU0gnNy8v1blNU0qq2pUWVWjlm+pDLQ3DGl0TqomDc/QlPx0Tc7L0NihaRqbm6asFEZSAgAAAADQHWEkEA1Ot1R4krRzuTVVmzByQDAMQ6OGpGrUkFSde3x+4Hp1Q6u2HajVlopabS2v1daKOm2tqNWh+haVHGpQyaEGvVNc0aWvnDSPxgxN1bihaRozNE1jc1MJKgEAAAAACY8wEoiWMQusMHL3R9JJN9pdDcKQlerWnLE5mjM2p8v1g3XN2lpRq20VddpSUavtFXXadahelbXNOlzfosP1Lfp8T1WP/vxBZeGQVI0akqKRQ1I0MjvFOs9OZeo3AAAAAGDQIowEomXsqdax5GPJNK05vRhUctOTlJuepPkTcrtcr29u0+5D9dp9sKH9WK+SQw19CiolK6wc1R5Qjsy2wsqC7BTlZyYrLzNZuekeuZysQwoAAAAAGHgII4FoGTlbciZJ9ZXSoe1S7iS7K0KMpCW5dFxBlo4ryOrxWV1zm0rag8q9RxqstSiPWOtR7j3SqLrmtkBY+cXe6qD9OwxpWEaS8trDSSuk7HjvDyyHpHrkcBCCAwAAAADiB2EkEC2uJGnUXKnkI2uqNmEkJKUfJag0TVM1jW3aW9UQCCj9x33VTaqoblJlXbO8PlMVNc2qqGmWFDywlKzQMictSbnpHuWmJ2lo52NaknIzPBqalqTcjCQNTfMo2c30cAAAAABAdBFGAtE09lQrjCz5WJpzg93VIM4ZhqGsVLeyUoOHlZLk9Zk6VGcFkeU1TSqvadKBmiaVV/vPm1VR26Sqhlb5TGtdy4N1zZJqj/n89CSXhqZ7lJ3q0ZBUt7JT3MpO9Si7/XxImkdZKW4N8V9L9SgjycXoSwAAAABAnxFGAtE0pn3dyN2sG4nIcDoMDc9M1vDMZM1Q8MBSklq9Ph2ub2kPI1t0qK5Zh+o6va+3Qkr/tVavqbrmtvZp5A19rsdhyAosU9zKSnUrM9mtjGSXMpLdykx2Bc67Hl3KTLbuTU92yUmYCQAAAAAJgzASiKZRcyWHW6rdJx3ZJeWMt7siJAi30xFYP/JYTNNUTVObFVjWt+hIfYuqGltV3dCqIw3WeVVDi6oaWnWkoVXV7dcaWrzymQqscdlfaR5nl6DSf57mcSk1yan0JJdSPS6lJTmto8ep1KT2Y/v1tCTr/mS3QwahPwAAAADELcJIIJo8qdZGNqUrpJJPCCMRlwzDUFaKW1kpbo0f1vd2Ta1e1TRaAWVVQ4uONLSqtqlVtU1t7a/282brWNPUptrGVuvY1KrmNp8kqb7Fq/oWr8prIvG1yAoxPVZAmepxKtXjVLLbeqW4nUp2O9qPna87lOLpfi3YvdZ7djMHAAAAgP4hjASibcx8K4zc/bE061q7qwEixh/QDe/D6MtgWtp8PcLLmk4hZkNLm+pbvGpobj+2tKm+udux0+eStRqCf7q5apsj+eV24XIYSnE75XE5lORyyNP55fSfO+VxOpTkdijJGexzR3v79n56uSfJ5ZDbab1cTkNuh0NulyGXwyG305DL6ZDLYcjtdDDlHQAAAEDcI4wEom3sqdJHD1ob2QAI8LgcGpqepKHpSWH35fOZamrz9hpWNrV51djiU1OrV42tXjW3HxtbvWpq9XW51tTqU2OLV01tXjW1eNXUZr1vbPUGntfmM1Xb3CZFL+/sF8OQ3A4rtPQHlNa5FVxa79tDTIfR6bzj6PLf5+gIOp0OQw7DkMtpHZ0OyelwyNn53CHrHv/9Duvcur/Tq9N7/z1Oo9P93e5xdurDkPUMw5AcDkMOo+O9oY73DsOQ4fCfW58ZRsf7QBum9AMAAAAxRxgJRFvhyZLhlKr2SFWlUnah3RUBg47DYSjVY60tKYUfbgZjmqaa26xAMxBgtnnV0uYLvJq9PjW3+tTi9XW67lVLt+vNbd3O/f10atfc6djq9anNZ6q1zadWn09tXlNtPjNIjbL68Ab5AtCDFWJ2CjC7BZbqEWB2DTO7t/GHm0bgP6xD5+tG4LrRZU8zwzD8TdqD0p73GerooGtfPZ9hdCqgS7/t73p7hoL0Fbge5PPOf5bqdrVL3T2uBbkvyGcK2kfvzz/Wfer2jOBfX+drQe7r59d6tD/LLiUe6/nd++/0YZDSwvtauxXV57/LYPcZ/l8udPx7crb/YsH/b8vZ7d+i09H535j1yw+j/dwR+KVE119EdFzvfM3qx9np/u71dP8Fh/+XIp1/seL/ZQu/yAAAIDyEkUC0JWVIBTOlsjVSycdS9lV2VwSgHwzDCExNjwemaQWSbV6zI6D0+tTqaz96TbW1X2/xHv1zf9jZ+Xpr+3Wfz5TXNOX1ST7Tep7PNOX1Wc/v+Lz9ZVrXgn7W7R5vt/46PpPafL5Oz/TJlBW2+kyzx9F69efPUDJl9WGdAcCxOQzJ5XDI4bCOwUZ/u5w9R3m7uoebTqN9lHnHCPOg/Tl7BqI9+vOPNG8f6e50GB0j5f2j3TuNmHc6OkbB+5f58I+Qd3a6z+1wBJ7PciAAgEghjARiYcypHWFkEWEkgPAZhtE+9VpKUXwEpHYz20NJ/zFYYNn9ns73Bg86g9/TvV8r0GwPOP3n7e+tczOQd3a/bna53tFWwe7p6EamaXY672jQ9Z6jP6fXezr1IXWrq8tJ+9fWqZ/OH5t9vE/d++9cV+dag/bb877ufQR7ftBnqeefS9f++ve1dunqaF9rkOcf9b5j/DlE5GsNck9f/847f092/rdimpLX1/XfnPXe/+/NlLfTuc8neU2z679FX+d/l2p/3/XfpL9t958BXt8xajHNoH8mfr72UejySpKv9xsHIcNQe7DZsayHFXy2h57+ZUA6rWvcOeh0tQe1LqdD7k7hqavL512XDul8rXvI2vm57kBNwUNVV/tz3N2WJGG0KwDEHmEkEAtjF0if/Fba9YHdlQDAoOWf9tltYi4AhMwffLb5fIHR2h2jtruO7G7rPvrbF+SaacrbPhq9exv/SPLgbazn+Nt7fbL66dTGP2rd31dbp+U8WttHxnt9ZpdlPtr8y394ra+n82j5tmMsB2KNnPdKrTb8xURJ93WTuwesPQPQrusrd2nfPpo0eFDaS5tO6zc7HcHD1c7tu68J3Xkzu87LhgBAvCKMBGJhzHzJ4ZKO7JYO75RyxttdEQAAAHrh/+WG0+EfeZ54I9DNTqGpP9RsbQ9juy7x0bG8h9fXdUmQnp+3Lwfi/6z70iH++9v78HZaiiRQR6d6/P32XHak6xIknZc1CTbqdbAFrEcPMIOEmUFGobp6hKJHD1JdvYSrwTbHcwcJUnsLV1kaABicCCOBWEjKkApPsXbU3r5MOokwEgAAAPGr83Ig8bJeciR0DjV7W0O5I+zsOoq0ewBqBaudz4/dvtXnO2obf5Dbtc7eg9hgBlO46l8aoPuaqU6HQ72todpjrdYga7QerW33dVidjl7aBPrtul6sVaujy729rR/r31ir67FjEy//Rl6dN9VyGNbzHI6Ojb8chLYYYAgjgViZcKYVRu54TzrpRrurAQAAABKOFfAMjnDVvwZq97Cz++jVHkFqL5vfdW4fPCjtrU1HsOtfRqB7uHqsZx5raQDJVHPs/4gHlB5BptEeZHYKPQOBZ7cg02n4g051ulc9wlLrXgXWWu0akipoP12frUCgakiB5xhGxzMd7QFs4L1htH/ey/1Gp/sdR7/fkORwHKV9l/s7rnXv/6g1dPrc6FGD9T7V40z45RQII4FYmbhIeven1rqR3lbJ6ba7IgAAAAADlGH4NwQaHKNXewtXj7Zua2Dd1U7ve1ujtWP91e5rtQZfj7X7+q892pjqx3O69tvmMwNfd+fNtfwba/naN9nqC6/PtPbVUt/uh30+u3OxctOT7C7DVoSRQKzkF0mpuVLDQal0lTT2VLsrAgAAAIC4MNjC1UjytYesPtOUz6dA2BkIMtuvBwsyu1w7VlvTCk+DB6OmvD6rlqPd6zVNme3PDjzH37a9jf9+SYG+fWb75mH++/zvzY77TTPI/WbX+/tyj6/Tczrfb3a6z/++1/Z9qCnYGrWSNToy0RFGArHicFhTtb98TtqxjDASAAAAAHBMDochhwiwBhqzW8Bpynqf5HLYXZrt+BMAYmnCWdZx+zJ76wAAAAAAAFFjtK+h6XI65HE5lORyKtnNepESYSQQW/4wcv96qf6gvbUAAAAAAADEGGEkEEsZ+VLe8ZJMaedyu6sBAAAAAACIKcJIINaYqg0AAAAAABIUYSQQa/4wcse76nV7LQAAAAAAgEGIMBKItdHzJFeKVFcuVWy0uxoAAAAAAICYIYwEYs2dLI1dYJ3vYKo2AAAAAABIHISRgB0mnW0dt7xhbx0AAAAAAAAxRBgJ2GHqBdZxzwqpttzeWgAAAAAAAGKEMBKwQ9YoadRcSaZU/Krd1QAAAAAAAMQEYSRgl2kXW8dNL9tbBwAAAAAAQIwQRgJ2md4eRpZ8LNUftLcWAAAAAACAGCCMBOwyZKw0okgyfdLm1+yuBgAAAAAAIOoIIwE7Tb/EOjJVGwAAAAAAJADCSMBO09rDyF0fSA2H7a0FAAAAAAAgyggjATvlTpSGHyf52qQtb9hdDQAAAAAAQFQRRgJ280/VLn7F3joAAAAAAACijDASsJs/jNzxrtRUY28tAAAAAAAAUUQYCdht+FQpd7LkbWFXbQAAAAAAMKgRRgLx4ISvWMc1f7G3DgAAAAAAgCgijATiwcxrJcMpla6QDhTbXQ0AAAAAAEBUEEYC8SBzhDTlPOt8zZO2lgIAAAAAABAthJFAvJhzg3Vc/3eptdHeWgAAAAAAAKKAMBKIF+PPkrJHS03V0saX7K4GAAAAAAAg4ggjgXjhcEgnXm+dM1UbAAAAAAAMQoSRQDyZda3kcLGRDQAAAAAAGJQII4F4kpHfsZHNZ3+2txYAAAAAAIAII4wE4s3sr1vH9f+QWuptLQUAAAAAACCSCCOBeDP+LGnIOKm5Wlr7V7urAQAAAAAAiBjCSCDeOBzSqd+xzj/+jdTWbG89AAAAAAAAEUIYCcSjmVdLGQVS7X5p3dN2VwMAAAAAABARhJFAPHIlSafeap1/9JDkbbO3HgAAAAAAgAggjATi1YnXS6m5UlWJtOF5u6sBAAAAAAAIG2EkEK88qdK8f7POP3xQ8vnsrQcAAAAAACBMhJFAPJv7LSkpSzq4Rdr8qt3VAAAAAAAAhIUwEohnyVnSyTdZ5+//ktGRAAAAAABgQCOMBOLdKbdIngyp4ktp44t2VwMAAAAAANBvhJFAvEvN6dhZ+93/ktpa7K0HAAAAAACgnwgjgYHglH+T0oZLR3ZJa/9idzUAAAAAAAD9QhgJDARJ6dIZ37fO3/+F1Fxnbz0AAAAAAAD9QBgJDBQnXi8NGSvVH5BW/N7uagAAAAAAAEJGGAkMFC6PdNZd1vnHv5HqD9lbDwAAAAAAQIgII4GB5LjLpfwTpJZa6cNf2V0NAAAAAABASAgjgYHE4ZAW32Odr35Mqiq1tx4AAAAAAIAQEEYCA82ERdLY0yRvi7T8frurAQAAAAAA6DPCSGCgMQxp8X9a5+v/Lh0otrceAAAAAACAPorLMPLhhx/W2LFjlZycrJNPPlmrVq3q9d6FCxfKMIwerwsuuCCGFQMxNmq2NO1iyfRJy+61uxoAAAAAAIA+ibsw8plnntHtt9+ue+65R2vXrlVRUZGWLFmiAwcOBL3/xRdf1P79+wOvDRs2yOl06oorrohx5UCMLbpbMpzSln9Ke1bYXQ0AAAAAAMAxxV0Y+eCDD+rGG2/UDTfcoOnTp+vRRx9VamqqnnjiiaD35+TkKD8/P/BaunSpUlNTCSMx+OVOkmZda52/8xPJNG0tBwAAAAAA4FjiKoxsaWnRmjVrtHjx4sA1h8OhxYsX69NPP+1TH48//riuuuoqpaWlBf28ublZNTU1XV7AgLXwh5IrWdrzqbT1TburAQAAAAAAOKq4CiMPHjwor9ervLy8Ltfz8vJUXl5+zParVq3Shg0b9K1vfavXe+6//35lZWUFXoWFhWHXDdgms0A6+WbrfOk9krfN3noAAAAAAACOIq7CyHA9/vjjmjFjhk466aRe77njjjtUXV0deJWWlsawQiAKTrtdSsmRDm6R1v7F7moAAAAAAAB6FVdhZG5urpxOpyoqKrpcr6ioUH5+/lHb1tfX6x//+Ie++c1vHvW+pKQkZWZmdnkBA1pylrTwDuv8vfukJpYeAAAAAAAA8SmuwkiPx6PZs2dr2bJlgWs+n0/Lli3TvHnzjtr2ueeeU3Nzs6699tpolwnEnzk3SEMnSg0HpY9/bXc1AAAAAAAAQcVVGClJt99+ux577DH95S9/UXFxsW655RbV19frhhtukCRdd911uuOOO3q0e/zxx3XppZdq6NChsS4ZsJ/TLZ19r3X+6cNS9V576wEAAAAAAAjCZXcB3V155ZWqrKzU3XffrfLycs2cOVNvvvlmYFObPXv2yOHomqFu2bJFH330kd5++207Sgbiw5TzpTELpJKPpGU/lS7/g90VAQAAAAAAdGGYpmnaXYSdampqlJWVperqataPxMBXtlZ67Ezr/JvvSIVz7a0HAAAAAAAMeqHka3E3TRtAGEaeKBVdbZ2/+h3J22pvPQAAAAAAAJ0QRgKDzTn/JaXkSAc2Sp/8zu5qAAAAAAAAAggjgcEmbah07v3W+fs/lw7tsLceAAAAAACAdoSRwGB0wpXS+IVSW5P02nelxF4aFgAAAAAAxAnCSGAwMgzpwockV7K0631p/T/srggAAAAAAIAwEhi0csZLZ/zAOn/zh9LhnfbWAwAAAAAAEh5hJDCYzf//pJGzpaYq6e9XS821dlcEAAAAAAASGGEkMJg53dKVf5PS86XKYunFf5V8PrurAgAAAAAACYowEhjsMgukq/5HciZJW/4pvff/7K4IAAAAAAAkKMJIIBGMmiNd/Fvr/MMH2NAGAAAAAADYgjASSBRFV0nzb7XO//cm6YMHJNO0tyYAAAAAAJBQCCOBRLL4J9LJN1vn7/5U+t+bpbZmW0sCAAAAAACJgzASSCQOp3Tez6ULHpQMp/TFP6S/XCRVl9ldGQAAAAAASACEkUAimvtN6doXpKQsqXSl9N9zpQ8fZJQkAAAAAACIKsJIIFFNOFO6cZlUeLLUWi8t+0/pkXnS1rdZSxIAAAAAAEQFYSSQyHInSd94S7rsD1J6nnR4h/T0FdJfL5H2fW53dQAAAAAAYJAhjAQSnWFYO23/f2us3badHmnX+9IfF0rPf0M6vNPuCgEAAAAAwCBBGAnAkpQhnfNT6dufSSdcKcmQNrwgPXyK9P4vpbYWuysEAAAAAAADHGEkgK6GjJEu/6N00wfS+IWSt1l677+kP5wu7Vlpd3UAAAAAAGAAI4wEENyIE6SvvSRd/icpNVeqLJaeWCL98/tSa6Pd1QEAAAAAgAGIMBJA7wxDOuEK6durpZnXSjKlVX+Q/nimVL7B7uoAAAAAAMAAQxgJ4NhSc6RLH5aueUFKG26NknzsLGnF7yWfz+7qAAAAAADAAEEYCaDvJi2WbvlEmnyutZbkmz+UnrpUOlJid2UAAAAAAGAAIIwEEJr0YdJX/yGd/4DkSpF2vS/9fr60+nFGSQIAAAAAgKMijAQQOsOQTrpRuuVjafQ8qaVOev126a8XS+Vf2l0dAAAAAACIU4SRAPpv6ATp6/+Uzv2ZNUpy94fSowukZ6+TDmy2uzoAAAAAABBnCCMBhMfhkE65Rfq3T6TjLpdkSJtelh45RXru69K2pZK31e4qAQAAAABAHDBM0zTtLsJONTU1ysrKUnV1tTIzM+0uBxj4KjZKy++Xil/tuJY6VDruMmn6pdLoUySn27byAAAAAABAZIWSrxFGEkYC0bH/C+nzv0kbX5TqKzuuJ2VK4xdKk86WJp9nbYgDAAAAAAAGLMLIEBBGAlHmbbN23P7yeWnbW1LDoY7PDIc05lTpuEulaRdL6cNtKxMAAAAAAPQPYWQICCOBGPL5pH2fS9uXSlvekPav6/jMcEiTz5XmfFOacJa1FiUAAAAAAIh7hJEhIIwEbHRkt7XZzcaXpH1rO65nj5Hm3CDNvJZp3AAAAAAAxDnCyBAQRgJxonKL9NmfpXVPS83V1jWHW5p+iTT3m9LoeZJh2FsjAAAAAADogTAyBISRQJxpabA2vVn9eNfRksOmSXO+IRVdKSVn2VcfAAAAAADogjAyBISRQBzb97n02RPW5jetDdY1d6o041+kGV+RRp8iOd321ggAAAAAQIIjjAwBYSQwADRVS+ufkT57XKrc3HE9KUuacKY06Rxp7AIpezRTuQEAAAAAiDHCyBAQRgIDiGlKez6V1j4lbXtLajjU9fOMAmu05Oh50uiTpbzjJYfTnloBAAAAAEgQhJEhIIwEBiif15rGvfUtace70v51kq+t6z2eDKlwrjR6vjR+oVQwS3K67KgWAAAAAIBBizAyBISRwCDR0iCVrZFKV0h7Vkilq6Tmmq73JGVZ07nHL7ReuZOY1g0AAAAAQJgII0NAGAkMUj6vdGCTFUzu+sB6NVV1vSejoCOYHH+GlJFvQ6EAAAAAAAxshJEhIIwEEoTPK+1fL+1cbr32rJC8zV3vGTbNCiVHzpZGzJSGTpQcDhuKBQAAAABg4CCMDAFhJJCgWhutQNIfTu5fL6nbj0NPhpR3nDWdO3eSNHSSlDtZGjJGcrptKBoAAAAAgPhDGBkCwkgAkqSGw9ZU7pJPrM1w9n8htTUGv9fhkoaMaw8oJ7aHlZOtsDJtaEzLBgAAAADAboSRISCMBBCUt006uNVad/LgNunQtvbjdqm1ofd2KUPaR1B2Hk05yQovXZ7Y1Q8AAAAAQIyEkq+5YlQTAAwsTpeUN916debzSbX7OoLJzkFldanUeETau8p6dWY4payRUuao9uNIKWtU+7H9fUoOa1QCAAAAAAY1wkgACIXDYYWIWaOkCWd2/aylQTq8I3hQ2VInVe2xXr0xHFYgmZYrpQ7teKXlSqnt19L819vfu5Oj+/UCAAAAABBBhJEAECmeVCl/hvXqzDSl2nIriKzZK1WXSTVlUvXe9mOZVH9AMn1Sw0Hr1ednpncLLbuf51pTx5PSrXuTMqyjK0kyjMh+/QAAAAAAHANhJABEm2FImSOsl04Ofk9bi9R4WKo/KDUcsgLJ+kOdzv3XO718bdaIy5Y6qaoktJocrq7hZCCsTLd2Ee/re0+a5Eq2XkwxBwAAAAAcA2EkAMQDl0fKyLdefWGaUlOVtQt4lwCzU2jpP288YgWWzXUdO4T72qz2TVWR+xqcSZI7xXq5kjsdU63p5P5r7hTJldJ+LaXjmtPTHmx6rL5cSX2/xihPAAAAABgQCCMBYCAyDGv6dcoQaeiEvrfzdhpN2VzX87y5ttv7Oqmltvf33pZOfTdbr0gGnH3l9AeT7UenS3K4rRGgzvZj5/PANXf7vZ3Pe2sX7F7/efu9hkNyOK0NixxO633gmqPbdac1mjSk6937dHbrn1AWAAAAQHwjjASAROJ0SSnZ1isSfF6ptdF6tTVKrU3tR/+1pk7Hhk6fN/Vs09Zsvbwt7cfmINdarL46h6CS9d7bIrUELzNxGFYwKaNTOGlYR8PR6bzT9R739tZOXfs4Zrtenn20ZwS+jCChapdrvd1r9PHeY7QP5d7eAuCI1tXts16fe6x7Iv35MZ4fkxqO8bktNQSRkH8OnX4W+H+J0vnff4/3wa710q77z5Iu93S/1tcaHOr6c+4YNUg9n+f/xVHgl0bBrjm7tgMAIAERRgIA+s/htNaPTEqP7XNNsyOg7Bxc+q/52iRvq3X0tVojQgPn/uttQc5brYDVf+5tfx/0vPu9bdYmRKbXuh449/Xjevt7n7fj3PT15Q/G+loAAAOA0UtI6bSCyh7XuoecoYafjhCu9+V5zk5BbPeR+kd7Xqd2wb7GYP12nwVw1K/RCF5DtO4BAISMMBIAMPAYhrVWpCvJ7kpixzQ7QsnOIaXPG+S6Kcl/v//c7Ag0A+dmL/d2b9e9jyi06/x1drwJcq3bn8lR7zWD3BvsWj/vPWb73u7t/PGxntXts177OtY9Mf68T330aGBDDfHw59DL94atNUTg8y7/1tXplyqd/v13ee+/Zga5FqRd958lQfvq9HOn88/QXtt1/3nl66VdsK+n26tPTFk/s9t/0YWBKaxAM9zPQ+yjyyyFYx3V++d96kshPKvbaOdjPb/PRwWpt8dfYLe30RgtH4tndG8SxWeE8r9/elzvQz9hP6M/NUWyr2PcL0knXmetmZ/ACCMBABgI/CNB5LTWqAQAxKcu4Wf3XxgFCS47j473B6Bd7u3ch6+X60H67tGH2ct1/7Wj1Wz243l9qbkP/fb2tXT+BVyX+3sJiPv6ebBA/6h/36EE0AAg6fh/IYy0uwAAAAAAGDQC6+Y6xP/dGoC6j6Ttb6gZiWA0ove039dl5HJfj+p5PTAyuC99KIRnBaszyPNDPdoyqyBentH99v4+o9NoyT6t5a1ervehn/60Cev6sT6L8LMZWMB/OwIAAAAAIKlbmAwAiAZ+wgIAAAAAAACICcJIAAAAAAAAADFBGAkAAAAAAAAgJggjAQAAAAAAAMQEYSQAAAAAAACAmCCMBAAAAAAAABAThJEAAAAAAAAAYoIwEgAAAAAAAEBMEEYCAAAAAAAAiAnCSAAAAAAAAAAxQRgJAAAAAAAAICYIIwEAAAAAAADEBGEkAAAAAAAAgJggjAQAAAAAAAAQE4SRAAAAAAAAAGKCMBIAAAAAAABATBBGAgAAAAAAAIgJwkgAAAAAAAAAMUEYCQAAAAAAACAmCCMBAAAAAAAAxARhJAAAAAAAAICYIIwEAAAAAAAAEBOEkQAAAAAAAABigjASAAAAAAAAQEwQRgIAAAAAAACICZfdBdjNNE1JUk1Njc2VAAAAAAAAAAOPP1fz52xHk/BhZG1trSSpsLDQ5koAAAAAAACAgau2tlZZWVlHvccw+xJZDmI+n0/79u1TRkaGDMOwu5yoqKmpUWFhoUpLS5WZmWl3OUBU8f2ORMP3PBIJ3+9INHzPI5Hw/Y5EM9i+503TVG1trQoKCuRwHH1VyIQfGelwODRq1Ci7y4iJzMzMQfENDvQF3+9INHzPI5Hw/Y5Ew/c8Egnf70g0g+l7/lgjIv3YwAYAAAAAAABATBBGAgAAAAAAAIgJwsgEkJSUpHvuuUdJSUl2lwJEHd/vSDR8zyOR8P2ORMP3PBIJ3+9INIn8PZ/wG9gAAAAAAAAAiA1GRgIAAAAAAACICcJIAAAAAAAAADFBGAkAAAAAAAAgJggjAQAAAAAAAMQEYeQg1tzcrB/84AcqKChQSkqKTj75ZC1dutTusoCwLF++XIZhBH2tWLGiy72ffPKJFixYoNTUVOXn5+vWW29VXV2dTZUDx1ZXV6d77rlH5557rnJycmQYhp588smg9xYXF+vcc89Venq6cnJy9LWvfU2VlZU97vP5fPrFL36hcePGKTk5WSeccIL+/ve/R/krAY6tr9/vX//614P+zJ86dWqPe/l+R7xavXq1vv3tb+u4445TWlqaRo8era985SvaunVrj3v5+Y7BoK/f8/yMx2CwceNGXXHFFRo/frxSU1OVm5ur008/Xa+++mqPe/kZb3HZXQCi5+tf/7qef/553XbbbZo0aZKefPJJnX/++Xrvvfe0YMECu8sDwnLrrbdq7ty5Xa5NnDgxcL5u3TotWrRI06ZN04MPPqi9e/fqgQce0LZt2/TGG2/EulygTw4ePKh7771Xo0ePVlFRkZYvXx70vr179+r0009XVlaW7rvvPtXV1emBBx7Ql19+qVWrVsnj8QTu/fGPf6yf/exnuvHGGzV37ly9/PLLuvrqq2UYhq666qoYfWVAT339fpekpKQk/elPf+pyLSsrq8d9fL8jXv385z/Xxx9/rCuuuEInnHCCysvL9d///d868cQTtWLFCh1//PGS+PmOwaOv3/MSP+Mx8JWUlKi2tlbXX3+9CgoK1NDQoBdeeEEXX3yx/vCHP+hf//VfJfEzvgsTg9LKlStNSeYvf/nLwLXGxkZzwoQJ5rx582ysDAjPe++9Z0oyn3vuuaPed95555kjRowwq6urA9cee+wxU5L51ltvRbtMoF+amprM/fv3m6ZpmqtXrzYlmX/+85973HfLLbeYKSkpZklJyf/f3r0HRVW/cRz/LILLbUBQUiQ0E1HTTEtxpJBfuZl4CfOSNjJexhnJyDK1GsvUtChDzcph1KYp8dIk1qg5hZfMsiTL1NLUII1ShPCGgCjIcn5/NJxcVoRMV1nfrxn+2Od895zv0WefxcfvOceMbdq0yZBkLF682IwdPXrU8PLyMpKSksxYZWWlERMTY9x6661GRUXFtTsZoBZ1zfdRo0YZfn5+te6PfMeN7NtvvzXKysocYllZWYbVajVGjBhhxqjvcBd1zXlqPNxVRUWFcddddxlt27Y1Y9T4f3CZtptavXq1GjRoYHbgJcnb21tjx45VZmamjhw5ch1nB1wdxcXFqqiocIoXFRVp06ZNSkhIUEBAgBkfOXKk/P39tWrVKldOE6gzq9WqZs2a1Tru448/Vv/+/dWiRQszZrPZFBkZ6ZDfa9eu1YULF/TEE0+YMYvFovHjx+vo0aPKzMy8uicA/At1zfcqdrtdRUVFNW4n33Eji46OdljxIklt2rRRhw4ddODAATNGfYe7qGvOV6HGw900aNBA4eHhKiwsNGPU+H/QjHRTu3fvVmRkpEMjRpKioqIk/X0JK1CfjRkzRgEBAfL29tb999+vnTt3mtv27t2riooKde3a1eE9DRs2VOfOnbV7925XTxe4anJzc1VQUOCU39LfNf7i/N69e7f8/PzUvn17p3FV24H6oLS0VAEBAQoMDFRwcLCSkpKc7gFMvqO+MQxDf/31l5o0aSKJ+g73Vz3nq1Dj4S7Onj2rEydO6NChQ3rzzTf1+eefq1evXpKo8dVxz0g3lZeXp9DQUKd4VezYsWOunhJwVTRs2FCDBw9W37591aRJE+3fv19z585VTEyMtm/fri5duigvL0+SavwMbNu2zdXTBq6a2vL71KlTKisrk9VqVV5enpo2bSqLxeI0TuK7APVDaGionnvuOd19992qrKxURkaGUlNT9dNPP2nr1q3y9Pz711nyHfXNihUrlJubq1mzZkmivsP9Vc95iRoP9zJ58mQtXrxYkuTh4aFBgwZp4cKFkqjx1dGMdFPnzp2T1Wp1int7e5vbgfooOjpa0dHR5uuHH35YQ4YMUadOnTR16lRlZGSY+V3TZ4D8R31WW35XjbFarXwXwC289tprDq+HDx+uyMhIvfjii1q9erV5E3fyHfXJwYMHlZSUpB49emjUqFGSqO9wb5fKeYkaD/cyceJEDRkyRMeOHdOqVatkt9tVXl4uiRpfHZdpuykfHx+VlZU5xc+fP29uB9xFRESE4uPj9eWXX8put5v5XdNngPxHfVZbfl88hu8CuKtnnnlGHh4e2rx5sxkj31Ff5Ofnq1+/fgoMDDTv8y5R3+G+asr5mlDjUV+1a9dONptNI0eO1Pr161VSUqIBAwbIMAxqfDU0I91UaGiouQz4YlWx5s2bu3pKwDUVHh6u8vJynT171ly+XtNngPxHfVZbfgcHB5v/kxoaGqr8/HwZhuE0TuK7APWXj4+PGjdurFOnTpkx8h31wZkzZxQXF6fCwkJlZGQ45CX1He7ocjlfE2o83MWQIUP0ww8/KCsrixpfDc1IN9W5c2dlZWU5PZFsx44d5nbAnRw+fFje3t7y9/dXx44d5enp6fBQG0kqLy/Xnj17yH/Ua2FhYQoJCXHKb0n6/vvvHfK7c+fOKi0tdXpqJd8FqO+Ki4t14sQJhYSEmDHyHTe68+fPa8CAAcrKytL69et1xx13OGynvsPd1JbzNaHGw11UXU595swZanw1NCPd1JAhQ2S327VkyRIzVlZWpvfff1/du3dXeHj4dZwdcOWOHz/uFPvpp5+0bt069e7dWx4eHgoMDJTNZtPy5ctVXFxsjlu2bJlKSko0dOhQV04ZuOoGDx6s9evX68iRI2bsiy++UFZWlkN+x8fHy8vLS6mpqWbMMAwtWrRIYWFhDvdfBW5E58+fd6jjVWbPni3DMNSnTx8zRr7jRma32zVs2DBlZmYqPT1dPXr0uOQ46jvcRV1ynhoPd1FQUOAUu3DhgtLS0uTj42M24qnx/+ABNm6qe/fuGjp0qKZOnaqCggJFRERo6dKlysnJ0XvvvXe9pwdcsWHDhsnHx0fR0dG65ZZbtH//fi1ZskS+vr56/fXXzXGvvvqqoqOjFRsbq3Hjxuno0aOaN2+eevfu7fCLDXCjWbhwoQoLC82n5H366ac6evSoJGnChAkKDAzUCy+8oPT0dN1///16+umnVVJSopSUFN15550aM2aMua9bb71VEydOVEpKii5cuKBu3bppzZo12rZtm1asWFHrPZuAa622fD99+rS6dOmixx57TO3atZMkbdiwQZ999pn69Omj+Ph4c1/kO25kkydP1rp16zRgwACdOnVKy5cvd9iekJAgSdR3uI265Hx+fj41Hm4hMTFRRUVF6tmzp8LCwpSfn68VK1bo4MGDmjdvnvz9/SVR4x0YcFvnzp0zpkyZYjRr1sywWq1Gt27djIyMjOs9LeA/eeutt4yoqCgjODjY8PT0NEJDQ42EhAQjOzvbaey2bduM6Ohow9vb2wgJCTGSkpKMoqKi6zBroO5atmxpSLrkz++//26O27dvn9G7d2/D19fXaNSokTFixAgjPz/faX92u91ITk42WrZsaTRs2NDo0KGDsXz5cheeEVCz2vL99OnTRkJCghEREWH4+voaVqvV6NChg5GcnGyUl5c77Y98x40qNja2xlyv/k8y6jvcQV1ynhoPd/Hhhx8aNpvNaNq0qeHp6WkEBQUZNpvNWLt2rdNYavzfLIZR7Y6YAAAAAAAAAHANcM9IAAAAAAAAAC5BMxIAAAAAAACAS9CMBAAAAAAAAOASNCMBAAAAAAAAuATNSAAAAAAAAAAuQTMSAAAAAAAAgEvQjAQAAAAAAADgEjQjAQAAAAAAALgEzUgAAABcVaNHj9Ztt912vafhMh988IEsFot27tx5vacCAABww6MZCQAAcJOwWCx1+tm6dev1nioAAADclOf1ngAAAABcY9myZQ6v09LStGnTJqd4+/bt/9Nx3n33XVVWVv6nfQAAAMA90YwEAAC4SSQkJDi8/u6777Rp0yaneHWlpaXy9fWt83G8vLyuaH4AAABwf1ymDQAAANP//vc/dezYUT/++KN69uwpX19fvfDCC5KktWvXql+/fmrevLmsVqtat26t2bNny263O+yj+j0jc3JyZLFYNHfuXC1ZskStW7eW1WpVt27d9MMPP9RpXoWFhZo4caLCw8NltVoVERGhOXPmOKzAvPg4b775plq2bCkfHx/FxsZq3759TvvcsmWLYmJi5Ofnp0aNGik+Pl4HDhxwGpebm6uxY8ea592qVSuNHz9e5eXlDuPKyso0adIkhYSEyM/PT4888oiOHz9ep/MDAAC4WbAyEgAAAA5OnjypuLg4DR8+XAkJCWratKmkvx/U4u/vr0mTJsnf319btmzR9OnTVVRUpJSUlFr3u3LlShUXFysxMVEWi0VvvPGGBg0apMOHD192NWVpaaliY2OVm5urxMREtWjRQtu3b9fUqVOVl5enBQsWOIxPS0tTcXGxkpKSdP78eb311lt64IEHtHfvXvNcNm/erLi4ON1+++2aOXOmzp07p3feeUf33nuvdu3aZTZTjx07pqioKBUWFmrcuHFq166dcnNztXr1apWWlqphw4bmcSdMmKCgoCDNmDFDOTk5WrBggZ588kl99NFH//JvAAAAwH3RjAQAAICD/Px8LVq0SImJiQ7xlStXysfHx3z9+OOP6/HHH1dqaqpeeeUVWa3Wy+73zz//VHZ2toKCgiRJbdu2VXx8vDZs2KD+/fvX+L758+fr0KFD2r17t9q0aSNJSkxMVPPmzZWSkqLJkycrPDzcHP/bb78pOztbYWFhkqQ+ffqoe/fumjNnjubPny9JevbZZxUcHKzMzEwFBwdLkgYOHKguXbpoxowZWrp0qSRp6tSpys/P144dO9S1a1fzGLNmzZJhGA7zbNy4sTZu3CiLxSJJqqys1Ntvv60zZ84oMDDwsn82AAAANwsu0wYAAIADq9WqMWPGOMUvbkQWFxfrxIkTiomJUWlpqQ4ePFjrfocNG2Y2IiUpJiZGknT48OHLvi89PV0xMTEKCgrSiRMnzB+bzSa73a6vv/7aYfzAgQPNRqQkRUVFqXv37vrss88kSXl5edqzZ49Gjx5tNiIlqVOnTnrwwQfNcZWVlVqzZo0GDBjg0IisUtV0rDJu3DiHWExMjOx2u/7444/Lnh8AAMDNhJWRAAAAcBAWFuZw+XGVX375RdOmTdOWLVtUVFTksO3MmTO17rdFixYOr6sak6dPn77s+7Kzs/Xzzz8rJCTkktsLCgocXletnrxYZGSkVq1aJUlmc7Bt27ZO49q3b68NGzbo7NmzKikpUVFRkTp27HjZ+VW50vMDAAC4mdCMBAAAgIOLV0BWKSwsVGxsrAICAjRr1iy1bt1a3t7e2rVrl55//nmHB8nUpEGDBpeMV7/cubrKyko9+OCDeu655y65PTIystZju8KVnh8AAMDNhGYkAAAAarV161adPHlSn3zyiXr27GnGf//992t+7NatW6ukpEQ2m61O47Ozs51iWVlZ5kNpWrZsKUn69ddfncYdPHhQTZo0kZ+fn3x8fBQQEHDJJ3EDAADgynDPSAAAANSqatXfxav8ysvLlZqaes2P/eijjyozM1MbNmxw2lZYWKiKigqH2Jo1a5Sbm2u+/v7777Vjxw7FxcVJkkJDQ9W5c2ctXbpUhYWF5rh9+/Zp48aN6tu3ryTJw8NDAwcO1KeffqqdO3c6HZsVjwAAAP8eKyMBAABQq+joaAUFBWnUqFF66qmnZLFYtGzZMpc05J599lmtW7dO/fv31+jRo3XPPffo7Nmz2rt3r1avXq2cnBw1adLEHB8REaH77rtP48ePV1lZmRYsWKDGjRs7XOadkpKiuLg49ejRQ2PHjtW5c+f0zjvvKDAwUDNnzjTHJScna+PGjYqNjdW4cePUvn175eXlKT09Xd98840aNWp0zc8fAADAndCMBAAAQK0aN26s9evXa/LkyZo2bZqCgoKUkJCgXr166aGHHrqmx/b19dVXX32l5ORkpaenKy0tTQEBAYqMjNTLL7+swMBAh/EjR46Uh4eHFixYoIKCAkVFRWnhwoUKDQ01x9hsNmVkZGjGjBmaPn26vLy8FBsbqzlz5qhVq1bmuLCwMO3YsUMvvfSSVqxYoaKiIoWFhSkuLk6+vr7X9LwBAADckcXg+hIAAAC4gZycHLVq1UopKSmaMmXK9Z4OAAAALoF7RgIAAAAAAABwCZqRAAAAAAAAAFyCZiQAAAAAAAAAl+CekQAAAAAAAABcgpWRAAAAAAAAAFyCZiQAAAAAAAAAl6AZCQAAAAAAAMAlaEYCAAAAAAAAcAmakQAAAAAAAABcgmYkAAAAAAAAAJegGQkAAAAAAADAJWhGAgAAAAAAAHAJmpEAAAAAAAAAXOL/9Nqye095TzIAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -356,16 +358,16 @@ "name": "stderr", "output_type": "stream", "text": [ - "Batch Test Gradients: 100%|██████████| 4/4 [00:00<00:00, 81.78it/s]\n", - "MVP: 100%|██████████| 547/547 [00:00<00:00, 1210.03it/s]\n", - "Batch Split Input Gradients: 100%|██████████| 2/2 [00:00<00:00, 50.77it/s]\n" + "Batch Test Gradients: 100%|██████████| 4/4 [00:00<00:00, 67.10it/s]\n", + "MVP: 100%|██████████| 547/547 [00:00<00:00, 742.01it/s] \n", + "Batch Split Input Gradients: 100%|██████████| 2/2 [00:00<00:00, 85.02it/s]\n" ] } ], "source": [ "train_influences = compute_influences(\n", " TorchTwiceDifferentiable(nn_model, F.cross_entropy),\n", - " training_data=train_data_loader,\n", + " training_data=training_data_loader,\n", " test_data=test_data_loader,\n", " influence_type=\"up\",\n", " inversion_method=\"direct\",\n", @@ -419,7 +421,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -458,8 +460,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average influence of corrupted points: -0.05458507\n", - "Average influence of other points: 0.035084754\n" + "Average influence of corrupted points: -0.05317057\n", + "Average influence of other points: 0.034408495\n" ] } ], @@ -502,16 +504,16 @@ "name": "stderr", "output_type": "stream", "text": [ - "Batch Test Gradients: 100%|██████████| 4/4 [00:00<00:00, 80.02it/s]\n", - "MVP: 100%|██████████| 547/547 [00:00<00:00, 1596.32it/s]\n", - "Batch Influence Perturbation: 100%|██████████| 2/2 [00:02<00:00, 1.49s/it]\n" + "Batch Test Gradients: 100%|██████████| 4/4 [00:00<00:00, 61.20it/s]\n", + "MVP: 100%|██████████| 547/547 [00:00<00:00, 1265.72it/s]\n", + "Batch Influence Perturbation: 100%|██████████| 2/2 [00:03<00:00, 1.66s/it]\n" ] } ], "source": [ "feature_influences = compute_influences(\n", " TorchTwiceDifferentiable(nn_model, F.cross_entropy),\n", - " training_data=train_data_loader,\n", + " training_data=training_data_loader,\n", " test_data=test_data_loader,\n", " influence_type=\"perturbation\",\n", " inversion_method=\"direct\",\n", @@ -528,7 +530,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -577,17 +579,17 @@ "name": "stderr", "output_type": "stream", "text": [ - "Batch Test Gradients: 100%|██████████| 4/4 [00:00<00:00, 72.05it/s]\n", - "Batch Train Gradients: 100%|██████████| 2/2 [00:00<00:00, 653.42it/s]\n", - "Conjugate gradient: 100%|██████████| 107/107 [00:04<00:00, 26.30it/s]\n", - "Batch Split Input Gradients: 100%|██████████| 2/2 [00:00<00:00, 106.95it/s]\n" + "Batch Test Gradients: 100%|██████████| 4/4 [00:00<00:00, 81.02it/s]\n", + "Batch Train Gradients: 100%|██████████| 2/2 [00:00<00:00, 535.33it/s]\n", + "Conjugate gradient: 100%|██████████| 107/107 [00:04<00:00, 22.66it/s]\n", + "Batch Split Input Gradients: 100%|██████████| 2/2 [00:00<00:00, 98.91it/s]\n" ] } ], "source": [ "cg_train_influences = compute_influences(\n", " TorchTwiceDifferentiable(nn_model, F.cross_entropy),\n", - " training_data=train_data_loader,\n", + " training_data=training_data_loader,\n", " test_data=test_data_loader,\n", " influence_type=\"up\",\n", " inversion_method=\"cg\",\n", @@ -616,7 +618,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Percentage error of cg over direct method:1.70863927451137e-05 %\n" + "Percentage error of cg over direct method:1.5124550145628746e-05 %\n" ] } ], diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index 81f40e5ec..a918ab1d9 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -48,5 +48,5 @@ except ImportError: logger.info( - "No compatible framework found. For influence computation install PyTorch 1.13." + "No compatible framework found. Influence function computation disabled." ) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 4a2759148..b105ae982 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -9,7 +9,7 @@ import torch.nn.functional as F from numpy.typing import NDArray from torch import nn -from torch.utils.data import DataLoader +from torch.utils.data import DataLoader, TensorDataset from pydvl.influence import TorchTwiceDifferentiable, compute_influences from pydvl.influence.general import InfluenceType, InversionMethod @@ -247,9 +247,11 @@ def test_influences_nn( "scale": 10000, }, } - train_data_loader = DataLoader(list(zip(x_train, y_train)), batch_size=batch_size) + train_data_loader = DataLoader( + TensorDataset(x_train, y_train), batch_size=batch_size + ) test_data_loader = DataLoader( - list(zip(x_test, y_test)), + TensorDataset(x_test, y_test), batch_size=batch_size, ) multiple_influences = {} From 613c8f0fa5cac8148db84c87296d0ab5d62f67f1 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 15 May 2023 15:30:04 +0200 Subject: [PATCH 062/436] Fix doc links --- docs/20-install.md | 6 +- docs/30-data-valuation.md | 104 +++++++++++++-------------- docs/40-influence.md | 28 ++++---- docs/assets/material-code.svg | 1 + docs/assets/material-computer.svg | 1 + docs/assets/material-description.svg | 1 + docs/assets/material-toolbox.svg | 1 + docs/{stylesheets => css}/extra.css | 22 +++++- docs/css/neoteroi.css | 1 + docs/index.md | 94 ++++-------------------- docs/requirements.txt | 0 mkdocs.yml | 5 +- requirements-docs.txt | 1 + src/pydvl/value/semivalues.py | 1 + 14 files changed, 114 insertions(+), 152 deletions(-) create mode 100644 docs/assets/material-code.svg create mode 100644 docs/assets/material-computer.svg create mode 100644 docs/assets/material-description.svg create mode 100644 docs/assets/material-toolbox.svg rename docs/{stylesheets => css}/extra.css (72%) create mode 100644 docs/css/neoteroi.css delete mode 100644 docs/requirements.txt diff --git a/docs/20-install.md b/docs/20-install.md index cfca87ed4..9eea857dc 100644 --- a/docs/20-install.md +++ b/docs/20-install.md @@ -39,14 +39,12 @@ pip install pyDVL --index-url https://test.pypi.org/simple/ pyDVL requires Python >= 3.8, [Memcached](https://memcached.org/) for caching and [Ray](https://ray.io) for parallelization. Additionally, -:mod:`Influence functions` requires PyTorch (see -:ref:`pyDVL Installation`). +the [Influence functions][pydvl.influence] module requires PyTorch (see + [[installation]]). ray is used to distribute workloads both locally and across nodes. Please follow the instructions in their documentation for installation. -.. _caching setup: - # Setting up the cache memcached is an in-memory key-value store accessible over the network. pyDVL diff --git a/docs/30-data-valuation.md b/docs/30-data-valuation.md index 7fd6bd360..7b5ba36e9 100644 --- a/docs/30-data-valuation.md +++ b/docs/30-data-valuation.md @@ -26,8 +26,9 @@ interest, but a function of three factors: pyDVL collects algorithms for the computation of data values in this sense, mostly those derived from cooperative game theory. The methods can be found in -the package ::: pydvl.value , with support from modules -:mod:`pydvl.utils.dataset` and :mod:`~pydvl.utils.utility`, as detailed below. +the package [pydvl.value][pydvl.value] , with support from modules +[pydvl.utils.dataset][pydvl.utils.dataset] +and [pydvl.utils.utility][pydvl.utils.utility], as detailed below. !!! Warning @@ -55,21 +56,21 @@ dataset = Dataset(X_train, X_test, y_train, y_test) ``` It is also possible to construct Datasets from sklearn toy datasets for -illustrative purposes using :meth:`~pydvl.utils.dataset.Dataset.from_sklearn`. +illustrative purposes using [from_sklearn][pydvl.utils.dataset.Dataset.from_sklearn]. ### Grouping data Be it because data valuation methods are computationally very expensive, or because we are interested in the groups themselves, it can be often useful or -necessary to group samples so as to valuate them together. +necessary to group samples to valuate them together. [GroupedDataset][pydvl.utils.dataset.GroupedDataset] provides an alternative to -[Dataset][] with the same interface which allows this. +[Dataset][pydvl.utils.dataset.Dataset] with the same interface which allows this. You can see an example in action in the :doc:`Spotify notebook `, but here's a simple example grouping a pre-existing `Dataset`. First we construct an array mapping each index in the dataset to a group, then use -:meth:`~pydvl.utils.dataset.GroupedDataset.from_dataset`: +[from_dataset][pydvl.utils.dataset.GroupedDataset.from_dataset]: ```python import numpy as np @@ -84,7 +85,7 @@ grouped_dataset = GroupedDataset.from_dataset(dataset, data_groups) In pyDVL we have slightly overloaded the name "utility" and use it to refer to an object that keeps track of all three items in $(D, \mathcal{A}, u)$. This -will be an instance of :class:`~pydvl.utils.utility.Utility` which, as mentioned, +will be an instance of [Utility][pydvl.utils.utility.Utility] which, as mentioned, is a convenient wrapper for the dataset, model and scoring function used for valuation methods. @@ -102,11 +103,11 @@ utility = Utility(model, dataset) The object `utility` is a callable that data valuation methods will execute with different subsets of training data. Each call will retrain the model on a subset and evaluate it on the test data using a scoring function. By default, -:class:`~pydvl.utils.utility.Utility` will use `model.score()`, but it is +[Utility][pydvl.utils.utility.Utility] will use `model.score()`, but it is possible to use any scoring function (greater values must be better). In particular, the constructor accepts the same types as argument as sklearn's -[cross_validate()](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.cross_validate.html>): -a string, a scorer callable or `None` for the default. +[cross_validate](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.cross_validate.html>): +a string, a scorer callable or [None][] for the default. ```python utility = Utility(model, dataset, "explained_variance") @@ -115,13 +116,14 @@ utility = Utility(model, dataset, "explained_variance") `Utility` will wrap the `fit()` method of the model to cache its results. This greatly reduces computation times of Monte Carlo methods. Because of how caching is implemented, it is important not to reuse `Utility` objects for different -datasets. You can read more about :ref:`caching setup` in the installation guide -and the documentation of the :mod:`pydvl.utils.caching` module. +datasets. You can read more about [setting up the cache][setting-up-the-cache] +in the installation guide and the documentation +of the [caching][pydvl.utils.caching] module. ### Using custom scorers -The `scoring` argument of :class:`~pydvl.utils.utility.Utility` can be used to -specify a custom :class:`~pydvl.utils.utility.Scorer` object. This is a simple +The `scoring` argument of [Utility][pydvl.utils.utility.Utility] can be used to +specify a custom [Scorer][pydvl.utils.utility.Scorer] object. This is a simple wrapper for a callable that takes a model, and test data and returns a score. More importantly, the object provides information about the range of the score, @@ -134,7 +136,7 @@ about what default value to use when the model fails to train. models will fail to fit on small subsets of the data, it is important to provide a sensible default value for the score. -It is possible to skip the construction of the :class:`~pydvl.utils.utility.Scorer` +It is possible to skip the construction of the [Scorer][pydvl.utils.utility.Scorer] when constructing the `Utility` object. The two following calls are equivalent: ```python @@ -152,7 +154,7 @@ Because each evaluation of the utility entails a full retrain of the model with a new subset of the training set, it is natural to try to learn this mapping from subsets to scores. This is the idea behind **Data Utility Learning (DUL)** [@wang_improving_2022] and in pyDVL it's as simple as wrapping the -`Utility` inside :class:`~pydvl.utils.utility.DataUtilityLearning`: +`Utility` inside [DataUtilityLearning][pydvl.utils.utility.DataUtilityLearning]: ```python from pydvl.utils import Utility, DataUtilityLearning, Dataset @@ -202,11 +204,9 @@ values = naive_loo(utility) ``` The return value of all valuation functions is an object of type -:class:`~pydvl.value.result.ValuationResult`. This can be iterated over, +[ValuationResult][pydvl.value.result.ValuationResult]. This can be iterated over, indexed with integers, slices and Iterables, as well as converted to a -`pandas DataFrame `_. - -.. _Shapley: +[pandas.DataFrame][]. ## Shapley values @@ -217,8 +217,9 @@ coalitions) in a way that ensures that certain axioms are fulfilled. pyDVL implements several methods for the computation and approximation of Shapley values. They can all be accessed via the facade function -:func:`~pydvl.value.shapley.compute_shapley_values`. The supported methods are -enumerated in :class:`~pydvl.value.shapley.ShapleyMode`. +[compute_shapley_values][pydvl.value.shapley.compute_shapley_values]. +The supported methods are enumerated in +[ShapleyMode][pydvl.value.shapley.ShapleyMode]. ### Combinatorial Shapley @@ -237,17 +238,17 @@ v_u(x_i) = \frac{1}{n} \sum_{S \subseteq D \setminus \{x_i\}} ,$$ ```python -from pydvl.value import compute_shapley_value +from pydvl.value import compute_shapley_values values = compute_shapley_values(utility, mode="combinatorial_exact") df = values.to_dataframe(column='value') ``` We can convert the return value to a -[pandas DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html) +[pandas.DataFrame][]. and name the column with the results as `value`. Please refer to the -documentation in :mod:`pydvl.value.shapley` and -:class:`~pydvl.value.result.ValuationResult` for more information. +documentation in [shapley][pydvl.value.shapley] and +[ValuationResult][pydvl.value.result.ValuationResult] for more information. ### Monte Carlo Combinatorial Shapley @@ -270,10 +271,11 @@ df = values.to_dataframe(column='cmc') The DataFrames returned by most Monte Carlo methods will contain approximate standard errors as an additional column, in this case named `cmc_stderr`. -Note the usage of the object :class:`~pydvl.value.stopping.MaxUpdates` as the +Note the usage of the object [MaxUpdates][pydvl.value.stopping.MaxUpdates] as the stop condition. This is an instance of a -:class:`~pydvl.value.stopping.StoppingCriterion`. Other examples are -:class:`~pydvl.value.stopping.MaxTime` and :class:`~pydvl.value.stopping.StandardError`. +[StoppingCriterion][pydvl.value.stopping.StoppingCriterion]. Other examples are +[MaxTime][pydvl.value.stopping.MaxTime] and +[AbsoluteStandardError][pydvl.value.stopping.AbsoluteStandardError]. ### Owen sampling @@ -291,7 +293,7 @@ v_u(i) = \int_0^1 \mathbb{E}_{S \sim P_q(D_{\backslash \{ i \}})} Using Owen sampling follows the same pattern as every other method for Shapley values in pyDVL. First construct the dataset and utility, then call -:func:`~pydvl.value.shapley.compute_shapley_values`: +[compute_shapley_values][pydvl.value.shapley.compute_shapley_values]: ```python from pydvl.value import compute_shapley_values @@ -303,10 +305,10 @@ values = compute_shapley_values( There are more details on Owen sampling, and its variant *Antithetic Owen Sampling* in the documentation for the function doing the work behind the scenes: -:func:`~pydvl.value.shapley.montecarlo.owen_sampling_shapley`. +[owen_sampling_shapley][pydvl.value.shapley.owen.owen_sampling_shapley]. Note that in this case we do not pass a -:class:`~pydvl.value.stopping.StoppingCriterion` to the function, but instead +[StoppingCriterion][pydvl.value.stopping.StoppingCriterion] to the function, but instead the number of iterations and the maximum number of samples to use in the integration. @@ -390,7 +392,7 @@ $$ Usage follows the same pattern as every other Shapley method, but with the addition of an ``epsilon`` parameter required for the solution of the CSP. It should be the same value used to compute the minimum number of samples required. -This can be done with :func:`~pydvl.value.shapley.gt.num_samples_eps_delta`, but +This can be done with [num_samples_eps_delta][pydvl.value.shapley.gt.num_samples_eps_delta], but note that the number returned will be huge! In practice, fewer samples can be enough, but the actual number will strongly depend on the utility, in particular its variance. @@ -508,9 +510,9 @@ Because computing the Least Core values requires the solution of a linear and a quadratic problem *after* computing all the utility values, we offer the possibility of splitting the latter from the former. This is useful when running multiple experiments: use -:func:`~pydvl.value.least_core.montecarlo.mclc_prepare_problem` to prepare a +[mclc_prepare_problem][pydvl.value.least_core.montecarlo.mclc_prepare_problem] to prepare a list of problems to solve, then solve them in parallel with -:func:`~pydvl.value.least_core.common.lc_solve_problems`. +[lc_solve_problems][pydvl.value.least_core.common.lc_solve_problems]. ```python from pydvl.value.least_core import mclc_prepare_problem, lc_solve_problems @@ -545,7 +547,7 @@ rank stability in certain situations. Shapley values are a particular case of semi-values and can therefore also be computed with the methods described here. However, as of version 0.6.0, we - recommend using :func:`~pydvl.value.shapley.compute_shapley_values` instead, + recommend using [compute_shapley_values][pydvl.value.shapley.compute_shapley_values] instead, in particular because it implements truncated Monte Carlo sampling for faster computation. @@ -563,12 +565,12 @@ $$ w(k) := \frac{B(k+\beta, n-k+1+\alpha)}{B(\alpha, \beta)}, $$ -where $B$ is the `Beta function `_, +where $B$ is the [Beta function](https://en.wikipedia.org/wiki/Beta_function), and $\alpha$ and $\beta$ are parameters that control the weighting of the subsets. Setting both to 1 recovers Shapley values, and setting $\alpha = 1$, and $\beta = 16$ is reported in [@kwon_beta_2022] to be a good choice for -some applications. See however :ref:`banzhaf indices` for an alternative choice -of weights which is reported to work better. +some applications. See however the [Banzhaf indices][banzhaf-indices] section +for an alternative choice of weights which is reported to work better. ```python from pydvl.value import compute_semivalues @@ -578,16 +580,14 @@ values = compute_semivalues( ) ``` -.. _banzhaf indices: - ### Banzhaf indices -As noted below in :ref:`problems of data values`, the Shapley value can be very -sensitive to variance in the utility function. For machine learning applications, -where the utility is typically the performance when trained on a set $S \subset -D$, this variance is often largest for smaller subsets $S$. It is therefore -reasonable to try reducing the relative contribution of these subsets with -adequate weights. +As noted below in the [Problems of Data Values][problems-of-data-values] section, +the Shapley value can be very sensitive to variance in the utility function. +For machine learning applications, where the utility is typically the performance +when trained on a set $S \subset D$, this variance is often largest +for smaller subsets $S$. It is therefore reasonable to try reducing +the relative contribution of these subsets with adequate weights. One such choice of weights is the Banzhaf index, which is defined as the constant: @@ -623,9 +623,9 @@ nature of every (non-trivial) ML problem can have an effect: that matters, and this tends to be accurate (wrt. to the true ranking) despite inaccurate values. - pyDVL offers a dedicated :func:`function composition - ` for scorer functions which can be used to - squash a score. The following is defined in module :mod:`~pydvl.utils.scorer`: + pyDVL offers a dedicated [function composition][pydvl.utils.score.compose_score] + for scorer functions which can be used to squash a score. + The following is defined in module [score][pydvl.utils.score]: ```python import numpy as np @@ -651,7 +651,7 @@ nature of every (non-trivial) ML problem can have an effect: variance, as will their Monte Carlo estimates. One workaround in pyDVL is to configure the caching system to allow multiple evaluations of the utility for every index set. A moving average is computed and returned once the standard - error is small, see :class:`~pydvl.utils.config.MemcachedConfig`. + error is small, see [MemcachedConfig][pydvl.utils.config.MemcachedConfig]. [@wang_data_2022] prove that by relaxing one of the Shapley axioms and considering the general class of semi-values, of which Shapley is an @@ -663,7 +663,7 @@ nature of every (non-trivial) ML problem can have an effect: approximations can converge slowly. Massive datasets are thus impractical, at least with current techniques. A workaround is to group samples and investigate their value together. In pyDVL you can do this using - :class:`~pydvl.utils.dataset.GroupedDataset`. There is a fully worked-out + [GroupedDataset][pydvl.utils.dataset.GroupedDataset]. There is a fully worked-out :doc:`example here `. Some algorithms also provide different sampling strategies to reduce the variance, but due to a no-free-lunch-type theorem, no single strategy can be optimal for all diff --git a/docs/40-influence.md b/docs/40-influence.md index 8b5e07179..94163bf60 100644 --- a/docs/40-influence.md +++ b/docs/40-influence.md @@ -9,8 +9,9 @@ alias: !!! Warning - Much of the code in the package :mod:`pydvl.influence` is experimental or - untested. Package structure and basic API are bound to change before v1.0.0 + Much of the code in the package [pydvl.influence][pydvl.influence] + is experimental or untested. Package structure and basic API are bound + to change before v1.0.0 !!! Todo @@ -23,14 +24,14 @@ alias: There are two ways to compute influences. For linear regression, the influences can be computed analytically. For more general models or loss functions, one can -implement the :class:`TwiceDifferentiable` protocol, which provides the required -methods for computing the influences. +implement the [TwiceDifferentiable][pydvl.influence.frameworks.torch_differentiable.TwiceDifferentiable] +protocol, which provides the required methods for computing the influences. pyDVL supports two ways of computing the empirical influence function, namely up-weighting of samples and perturbation influences. The choice is done by a parameter in the call to the main entry points, -:func:`~pydvl.influence.linear.compute_linear_influences` and -:func:`~pydvl.influence.compute_influences`. +[compute_linear_influences][pydvl.influence.linear.compute_linear_influences] +and [compute_influences][pydvl.influence.compute_influences]. # Influence for OLS @@ -41,8 +42,8 @@ parameter in the call to the main entry points, Because the Hessian of the least squares loss for a regression problem can be computed analytically, we provide -:func:`~pydvl.influence.linear.compute_linear_influences` as a convenience -function to work with these models. +[compute_linear_influences][pydvl.influence.linear.compute_linear_influences] +as a convenience function to work with these models. ```python from pydvl.influence.linear import compute_linear_influences @@ -61,9 +62,10 @@ least squares regression problem. # Exact influences using the `TwiceDifferentiable` protocol More generally, influences can be computed for any model which implements the -:class:`TwiceDifferentiable` protocol, i.e. which is capable of calculating -second derivative matrix vector products and gradients of the loss evaluated on -training and test samples. +[TwiceDifferentiable][pydvl.influence.frameworks.torch_differentiable.TorchTwiceDifferentiable] +protocol, i.e. which is capable of calculating second derivative matrix +vector products and gradients of the loss evaluated +on training and test samples. ```python from pydvl.influence import compute_influences @@ -81,7 +83,7 @@ compute_influences( Sometimes it is not possible to construct the complete Hessian in memory. In that case one can use conjugate gradient as a space-efficient approximation to inverting the full matrix. In pyDVL this can be done with the parameter -`inversion_method` of :func:`~pydvl.influence.compute_influences`: +`inversion_method` of [compute_influences][pydvl.influence.compute_influences]: ```python @@ -99,7 +101,7 @@ compute_influences( # Perturbation influences As mentioned, the method of empirical influence computation can be selected -in :func:`~pydvl.influence.compute_influences` with `influence_type`: +in [compute_influences][pydvl.influence.compute_influences] with `influence_type`: ```python from pydvl.influence import compute_influences diff --git a/docs/assets/material-code.svg b/docs/assets/material-code.svg new file mode 100644 index 000000000..cbbc31424 --- /dev/null +++ b/docs/assets/material-code.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/docs/assets/material-computer.svg b/docs/assets/material-computer.svg new file mode 100644 index 000000000..74162d034 --- /dev/null +++ b/docs/assets/material-computer.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/docs/assets/material-description.svg b/docs/assets/material-description.svg new file mode 100644 index 000000000..904da8a7b --- /dev/null +++ b/docs/assets/material-description.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/docs/assets/material-toolbox.svg b/docs/assets/material-toolbox.svg new file mode 100644 index 000000000..85146d8ac --- /dev/null +++ b/docs/assets/material-toolbox.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/docs/stylesheets/extra.css b/docs/css/extra.css similarity index 72% rename from docs/stylesheets/extra.css rename to docs/css/extra.css index d4d5c7d99..401dd36bd 100644 --- a/docs/stylesheets/extra.css +++ b/docs/css/extra.css @@ -41,7 +41,25 @@ a.autorefs-external:hover::after { background-color: var(--md-accent-fg-color); } -/*Highlight code*/ +/* Headers */ +.md-typeset h1 { + font-size: 2.5em; + font-weight: 500; +} + +.md-typeset h2 { + font-size: 1.7em; + font-weight: 300; +} + +/* Highlight function names in red */ .highlight > :first-child { color: #b30000; -} \ No newline at end of file +} + +/* Highlight svg logos on hover */ +/* The filter was generated using this link: https://codepen.io/sosuke/pen/Pjoqqp */ +.nt-card-image:hover, +.nt-card-image:focus { + filter: invert(32%) sepia(93%) saturate(1535%) hue-rotate(220deg) brightness(102%) contrast(99%); +} diff --git a/docs/css/neoteroi.css b/docs/css/neoteroi.css new file mode 100644 index 000000000..363c9229a --- /dev/null +++ b/docs/css/neoteroi.css @@ -0,0 +1 @@ +:root{--nt-color-0: #CD853F;--nt-color-1: #B22222;--nt-color-2: #000080;--nt-color-3: #4B0082;--nt-color-4: #3CB371;--nt-color-5: #D2B48C;--nt-color-6: #FF00FF;--nt-color-7: #98FB98;--nt-color-8: #FFEBCD;--nt-color-9: #2E8B57;--nt-color-10: #6A5ACD;--nt-color-11: #48D1CC;--nt-color-12: #FFA500;--nt-color-13: #F4A460;--nt-color-14: #A52A2A;--nt-color-15: #FFE4C4;--nt-color-16: #FF4500;--nt-color-17: #AFEEEE;--nt-color-18: #FA8072;--nt-color-19: #2F4F4F;--nt-color-20: #FFDAB9;--nt-color-21: #BC8F8F;--nt-color-22: #FFC0CB;--nt-color-23: #00FA9A;--nt-color-24: #F0FFF0;--nt-color-25: #FFFACD;--nt-color-26: #F5F5F5;--nt-color-27: #FF6347;--nt-color-28: #FFFFF0;--nt-color-29: #7FFFD4;--nt-color-30: #E9967A;--nt-color-31: #7B68EE;--nt-color-32: #FFF8DC;--nt-color-33: #0000CD;--nt-color-34: #D2691E;--nt-color-35: #708090;--nt-color-36: #5F9EA0;--nt-color-37: #008080;--nt-color-38: #008000;--nt-color-39: #FFE4E1;--nt-color-40: #FFFF00;--nt-color-41: #FFFAF0;--nt-color-42: #DCDCDC;--nt-color-43: #ADFF2F;--nt-color-44: #ADD8E6;--nt-color-45: #8B008B;--nt-color-46: #7FFF00;--nt-color-47: #800000;--nt-color-48: #20B2AA;--nt-color-49: #556B2F;--nt-color-50: #778899;--nt-color-51: #E6E6FA;--nt-color-52: #FFFAFA;--nt-color-53: #FF7F50;--nt-color-54: #FF0000;--nt-color-55: #F5DEB3;--nt-color-56: #008B8B;--nt-color-57: #66CDAA;--nt-color-58: #808000;--nt-color-59: #FAF0E6;--nt-color-60: #00BFFF;--nt-color-61: #C71585;--nt-color-62: #00FFFF;--nt-color-63: #8B4513;--nt-color-64: #F0F8FF;--nt-color-65: #FAEBD7;--nt-color-66: #8B0000;--nt-color-67: #4682B4;--nt-color-68: #F0E68C;--nt-color-69: #BDB76B;--nt-color-70: #A0522D;--nt-color-71: #FAFAD2;--nt-color-72: #FFD700;--nt-color-73: #DEB887;--nt-color-74: #E0FFFF;--nt-color-75: #8A2BE2;--nt-color-76: #32CD32;--nt-color-77: #87CEFA;--nt-color-78: #00CED1;--nt-color-79: #696969;--nt-color-80: #DDA0DD;--nt-color-81: #EE82EE;--nt-color-82: #FFB6C1;--nt-color-83: #8FBC8F;--nt-color-84: #D8BFD8;--nt-color-85: #9400D3;--nt-color-86: #A9A9A9;--nt-color-87: #FFFFE0;--nt-color-88: #FFF5EE;--nt-color-89: #FFF0F5;--nt-color-90: #FFDEAD;--nt-color-91: #800080;--nt-color-92: #B0E0E6;--nt-color-93: #9932CC;--nt-color-94: #DAA520;--nt-color-95: #F0FFFF;--nt-color-96: #40E0D0;--nt-color-97: #00FF7F;--nt-color-98: #006400;--nt-color-99: #808080;--nt-color-100: #87CEEB;--nt-color-101: #0000FF;--nt-color-102: #6495ED;--nt-color-103: #FDF5E6;--nt-color-104: #B8860B;--nt-color-105: #BA55D3;--nt-color-106: #C0C0C0;--nt-color-107: #000000;--nt-color-108: #F08080;--nt-color-109: #B0C4DE;--nt-color-110: #00008B;--nt-color-111: #6B8E23;--nt-color-112: #FFE4B5;--nt-color-113: #FFA07A;--nt-color-114: #9ACD32;--nt-color-115: #FFFFFF;--nt-color-116: #F5F5DC;--nt-color-117: #90EE90;--nt-color-118: #1E90FF;--nt-color-119: #7CFC00;--nt-color-120: #FF69B4;--nt-color-121: #F8F8FF;--nt-color-122: #F5FFFA;--nt-color-123: #00FF00;--nt-color-124: #D3D3D3;--nt-color-125: #DB7093;--nt-color-126: #DA70D6;--nt-color-127: #FF1493;--nt-color-128: #228B22;--nt-color-129: #FFEFD5;--nt-color-130: #4169E1;--nt-color-131: #191970;--nt-color-132: #9370DB;--nt-color-133: #483D8B;--nt-color-134: #FF8C00;--nt-color-135: #EEE8AA;--nt-color-136: #CD5C5C;--nt-color-137: #DC143C}:root{--nt-group-0-main: #000000;--nt-group-0-dark: #FFFFFF;--nt-group-0-light: #000000;--nt-group-0-main-bg: #F44336;--nt-group-0-dark-bg: #BA000D;--nt-group-0-light-bg: #FF7961;--nt-group-1-main: #000000;--nt-group-1-dark: #FFFFFF;--nt-group-1-light: #000000;--nt-group-1-main-bg: #E91E63;--nt-group-1-dark-bg: #B0003A;--nt-group-1-light-bg: #FF6090;--nt-group-2-main: #FFFFFF;--nt-group-2-dark: #FFFFFF;--nt-group-2-light: #000000;--nt-group-2-main-bg: #9C27B0;--nt-group-2-dark-bg: #6A0080;--nt-group-2-light-bg: #D05CE3;--nt-group-3-main: #FFFFFF;--nt-group-3-dark: #FFFFFF;--nt-group-3-light: #000000;--nt-group-3-main-bg: #673AB7;--nt-group-3-dark-bg: #320B86;--nt-group-3-light-bg: #9A67EA;--nt-group-4-main: #FFFFFF;--nt-group-4-dark: #FFFFFF;--nt-group-4-light: #000000;--nt-group-4-main-bg: #3F51B5;--nt-group-4-dark-bg: #002984;--nt-group-4-light-bg: #757DE8;--nt-group-5-main: #000000;--nt-group-5-dark: #FFFFFF;--nt-group-5-light: #000000;--nt-group-5-main-bg: #2196F3;--nt-group-5-dark-bg: #0069C0;--nt-group-5-light-bg: #6EC6FF;--nt-group-6-main: #000000;--nt-group-6-dark: #FFFFFF;--nt-group-6-light: #000000;--nt-group-6-main-bg: #03A9F4;--nt-group-6-dark-bg: #007AC1;--nt-group-6-light-bg: #67DAFF;--nt-group-7-main: #000000;--nt-group-7-dark: #000000;--nt-group-7-light: #000000;--nt-group-7-main-bg: #00BCD4;--nt-group-7-dark-bg: #008BA3;--nt-group-7-light-bg: #62EFFF;--nt-group-8-main: #000000;--nt-group-8-dark: #FFFFFF;--nt-group-8-light: #000000;--nt-group-8-main-bg: #009688;--nt-group-8-dark-bg: #00675B;--nt-group-8-light-bg: #52C7B8;--nt-group-9-main: #000000;--nt-group-9-dark: #FFFFFF;--nt-group-9-light: #000000;--nt-group-9-main-bg: #4CAF50;--nt-group-9-dark-bg: #087F23;--nt-group-9-light-bg: #80E27E;--nt-group-10-main: #000000;--nt-group-10-dark: #000000;--nt-group-10-light: #000000;--nt-group-10-main-bg: #8BC34A;--nt-group-10-dark-bg: #5A9216;--nt-group-10-light-bg: #BEF67A;--nt-group-11-main: #000000;--nt-group-11-dark: #000000;--nt-group-11-light: #000000;--nt-group-11-main-bg: #CDDC39;--nt-group-11-dark-bg: #99AA00;--nt-group-11-light-bg: #FFFF6E;--nt-group-12-main: #000000;--nt-group-12-dark: #000000;--nt-group-12-light: #000000;--nt-group-12-main-bg: #FFEB3B;--nt-group-12-dark-bg: #C8B900;--nt-group-12-light-bg: #FFFF72;--nt-group-13-main: #000000;--nt-group-13-dark: #000000;--nt-group-13-light: #000000;--nt-group-13-main-bg: #FFC107;--nt-group-13-dark-bg: #C79100;--nt-group-13-light-bg: #FFF350;--nt-group-14-main: #000000;--nt-group-14-dark: #000000;--nt-group-14-light: #000000;--nt-group-14-main-bg: #FF9800;--nt-group-14-dark-bg: #C66900;--nt-group-14-light-bg: #FFC947;--nt-group-15-main: #000000;--nt-group-15-dark: #FFFFFF;--nt-group-15-light: #000000;--nt-group-15-main-bg: #FF5722;--nt-group-15-dark-bg: #C41C00;--nt-group-15-light-bg: #FF8A50;--nt-group-16-main: #FFFFFF;--nt-group-16-dark: #FFFFFF;--nt-group-16-light: #000000;--nt-group-16-main-bg: #795548;--nt-group-16-dark-bg: #4B2C20;--nt-group-16-light-bg: #A98274;--nt-group-17-main: #000000;--nt-group-17-dark: #FFFFFF;--nt-group-17-light: #000000;--nt-group-17-main-bg: #9E9E9E;--nt-group-17-dark-bg: #707070;--nt-group-17-light-bg: #CFCFCF;--nt-group-18-main: #000000;--nt-group-18-dark: #FFFFFF;--nt-group-18-light: #000000;--nt-group-18-main-bg: #607D8B;--nt-group-18-dark-bg: #34515E;--nt-group-18-light-bg: #8EACBB}.nt-pastello{--nt-group-0-main: #000000;--nt-group-0-dark: #000000;--nt-group-0-light: #000000;--nt-group-0-main-bg: #EF9A9A;--nt-group-0-dark-bg: #BA6B6C;--nt-group-0-light-bg: #FFCCCB;--nt-group-1-main: #000000;--nt-group-1-dark: #000000;--nt-group-1-light: #000000;--nt-group-1-main-bg: #F48FB1;--nt-group-1-dark-bg: #BF5F82;--nt-group-1-light-bg: #FFC1E3;--nt-group-2-main: #000000;--nt-group-2-dark: #000000;--nt-group-2-light: #000000;--nt-group-2-main-bg: #CE93D8;--nt-group-2-dark-bg: #9C64A6;--nt-group-2-light-bg: #FFC4FF;--nt-group-3-main: #000000;--nt-group-3-dark: #000000;--nt-group-3-light: #000000;--nt-group-3-main-bg: #B39DDB;--nt-group-3-dark-bg: #836FA9;--nt-group-3-light-bg: #E6CEFF;--nt-group-4-main: #000000;--nt-group-4-dark: #000000;--nt-group-4-light: #000000;--nt-group-4-main-bg: #9FA8DA;--nt-group-4-dark-bg: #6F79A8;--nt-group-4-light-bg: #D1D9FF;--nt-group-5-main: #000000;--nt-group-5-dark: #000000;--nt-group-5-light: #000000;--nt-group-5-main-bg: #90CAF9;--nt-group-5-dark-bg: #5D99C6;--nt-group-5-light-bg: #C3FDFF;--nt-group-6-main: #000000;--nt-group-6-dark: #000000;--nt-group-6-light: #000000;--nt-group-6-main-bg: #81D4FA;--nt-group-6-dark-bg: #4BA3C7;--nt-group-6-light-bg: #B6FFFF;--nt-group-7-main: #000000;--nt-group-7-dark: #000000;--nt-group-7-light: #000000;--nt-group-7-main-bg: #80DEEA;--nt-group-7-dark-bg: #4BACB8;--nt-group-7-light-bg: #B4FFFF;--nt-group-8-main: #000000;--nt-group-8-dark: #000000;--nt-group-8-light: #000000;--nt-group-8-main-bg: #80CBC4;--nt-group-8-dark-bg: #4F9A94;--nt-group-8-light-bg: #B2FEF7;--nt-group-9-main: #000000;--nt-group-9-dark: #000000;--nt-group-9-light: #000000;--nt-group-9-main-bg: #A5D6A7;--nt-group-9-dark-bg: #75A478;--nt-group-9-light-bg: #D7FFD9;--nt-group-10-main: #000000;--nt-group-10-dark: #000000;--nt-group-10-light: #000000;--nt-group-10-main-bg: #C5E1A5;--nt-group-10-dark-bg: #94AF76;--nt-group-10-light-bg: #F8FFD7;--nt-group-11-main: #000000;--nt-group-11-dark: #000000;--nt-group-11-light: #000000;--nt-group-11-main-bg: #E6EE9C;--nt-group-11-dark-bg: #B3BC6D;--nt-group-11-light-bg: #FFFFCE;--nt-group-12-main: #000000;--nt-group-12-dark: #000000;--nt-group-12-light: #000000;--nt-group-12-main-bg: #FFF59D;--nt-group-12-dark-bg: #CBC26D;--nt-group-12-light-bg: #FFFFCF;--nt-group-13-main: #000000;--nt-group-13-dark: #000000;--nt-group-13-light: #000000;--nt-group-13-main-bg: #FFE082;--nt-group-13-dark-bg: #CAAE53;--nt-group-13-light-bg: #FFFFB3;--nt-group-14-main: #000000;--nt-group-14-dark: #000000;--nt-group-14-light: #000000;--nt-group-14-main-bg: #FFCC80;--nt-group-14-dark-bg: #CA9B52;--nt-group-14-light-bg: #FFFFB0;--nt-group-15-main: #000000;--nt-group-15-dark: #000000;--nt-group-15-light: #000000;--nt-group-15-main-bg: #FFAB91;--nt-group-15-dark-bg: #C97B63;--nt-group-15-light-bg: #FFDDC1;--nt-group-16-main: #000000;--nt-group-16-dark: #000000;--nt-group-16-light: #000000;--nt-group-16-main-bg: #BCAAA4;--nt-group-16-dark-bg: #8C7B75;--nt-group-16-light-bg: #EFDCD5;--nt-group-17-main: #000000;--nt-group-17-dark: #000000;--nt-group-17-light: #000000;--nt-group-17-main-bg: #EEEEEE;--nt-group-17-dark-bg: #BCBCBC;--nt-group-17-light-bg: #FFFFFF;--nt-group-18-main: #000000;--nt-group-18-dark: #000000;--nt-group-18-light: #000000;--nt-group-18-main-bg: #B0BEC5;--nt-group-18-dark-bg: #808E95;--nt-group-18-light-bg: #E2F1F8}.nt-group-0 .nt-plan-group-summary,.nt-group-0 .nt-timeline-dot{color:var(--nt-group-0-dark);background-color:var(--nt-group-0-dark-bg)}.nt-group-0 .period{color:var(--nt-group-0-main);background-color:var(--nt-group-0-main-bg)}.nt-group-1 .nt-plan-group-summary,.nt-group-1 .nt-timeline-dot{color:var(--nt-group-1-dark);background-color:var(--nt-group-1-dark-bg)}.nt-group-1 .period{color:var(--nt-group-1-main);background-color:var(--nt-group-1-main-bg)}.nt-group-2 .nt-plan-group-summary,.nt-group-2 .nt-timeline-dot{color:var(--nt-group-2-dark);background-color:var(--nt-group-2-dark-bg)}.nt-group-2 .period{color:var(--nt-group-2-main);background-color:var(--nt-group-2-main-bg)}.nt-group-3 .nt-plan-group-summary,.nt-group-3 .nt-timeline-dot{color:var(--nt-group-3-dark);background-color:var(--nt-group-3-dark-bg)}.nt-group-3 .period{color:var(--nt-group-3-main);background-color:var(--nt-group-3-main-bg)}.nt-group-4 .nt-plan-group-summary,.nt-group-4 .nt-timeline-dot{color:var(--nt-group-4-dark);background-color:var(--nt-group-4-dark-bg)}.nt-group-4 .period{color:var(--nt-group-4-main);background-color:var(--nt-group-4-main-bg)}.nt-group-5 .nt-plan-group-summary,.nt-group-5 .nt-timeline-dot{color:var(--nt-group-5-dark);background-color:var(--nt-group-5-dark-bg)}.nt-group-5 .period{color:var(--nt-group-5-main);background-color:var(--nt-group-5-main-bg)}.nt-group-6 .nt-plan-group-summary,.nt-group-6 .nt-timeline-dot{color:var(--nt-group-6-dark);background-color:var(--nt-group-6-dark-bg)}.nt-group-6 .period{color:var(--nt-group-6-main);background-color:var(--nt-group-6-main-bg)}.nt-group-7 .nt-plan-group-summary,.nt-group-7 .nt-timeline-dot{color:var(--nt-group-7-dark);background-color:var(--nt-group-7-dark-bg)}.nt-group-7 .period{color:var(--nt-group-7-main);background-color:var(--nt-group-7-main-bg)}.nt-group-8 .nt-plan-group-summary,.nt-group-8 .nt-timeline-dot{color:var(--nt-group-8-dark);background-color:var(--nt-group-8-dark-bg)}.nt-group-8 .period{color:var(--nt-group-8-main);background-color:var(--nt-group-8-main-bg)}.nt-group-9 .nt-plan-group-summary,.nt-group-9 .nt-timeline-dot{color:var(--nt-group-9-dark);background-color:var(--nt-group-9-dark-bg)}.nt-group-9 .period{color:var(--nt-group-9-main);background-color:var(--nt-group-9-main-bg)}.nt-group-10 .nt-plan-group-summary,.nt-group-10 .nt-timeline-dot{color:var(--nt-group-10-dark);background-color:var(--nt-group-10-dark-bg)}.nt-group-10 .period{color:var(--nt-group-10-main);background-color:var(--nt-group-10-main-bg)}.nt-group-11 .nt-plan-group-summary,.nt-group-11 .nt-timeline-dot{color:var(--nt-group-11-dark);background-color:var(--nt-group-11-dark-bg)}.nt-group-11 .period{color:var(--nt-group-11-main);background-color:var(--nt-group-11-main-bg)}.nt-group-12 .nt-plan-group-summary,.nt-group-12 .nt-timeline-dot{color:var(--nt-group-12-dark);background-color:var(--nt-group-12-dark-bg)}.nt-group-12 .period{color:var(--nt-group-12-main);background-color:var(--nt-group-12-main-bg)}.nt-group-13 .nt-plan-group-summary,.nt-group-13 .nt-timeline-dot{color:var(--nt-group-13-dark);background-color:var(--nt-group-13-dark-bg)}.nt-group-13 .period{color:var(--nt-group-13-main);background-color:var(--nt-group-13-main-bg)}.nt-group-14 .nt-plan-group-summary,.nt-group-14 .nt-timeline-dot{color:var(--nt-group-14-dark);background-color:var(--nt-group-14-dark-bg)}.nt-group-14 .period{color:var(--nt-group-14-main);background-color:var(--nt-group-14-main-bg)}.nt-group-15 .nt-plan-group-summary,.nt-group-15 .nt-timeline-dot{color:var(--nt-group-15-dark);background-color:var(--nt-group-15-dark-bg)}.nt-group-15 .period{color:var(--nt-group-15-main);background-color:var(--nt-group-15-main-bg)}.nt-group-16 .nt-plan-group-summary,.nt-group-16 .nt-timeline-dot{color:var(--nt-group-16-dark);background-color:var(--nt-group-16-dark-bg)}.nt-group-16 .period{color:var(--nt-group-16-main);background-color:var(--nt-group-16-main-bg)}.nt-group-17 .nt-plan-group-summary,.nt-group-17 .nt-timeline-dot{color:var(--nt-group-17-dark);background-color:var(--nt-group-17-dark-bg)}.nt-group-17 .period{color:var(--nt-group-17-main);background-color:var(--nt-group-17-main-bg)}.nt-group-18 .nt-plan-group-summary,.nt-group-18 .nt-timeline-dot{color:var(--nt-group-18-dark);background-color:var(--nt-group-18-dark-bg)}.nt-group-18 .period{color:var(--nt-group-18-main);background-color:var(--nt-group-18-main-bg)}.nt-error{border:2px dashed darkred;padding:0 1rem;background:#faf9ba;color:darkred}.nt-timeline{margin-top:30px}.nt-timeline .nt-timeline-title{font-size:1.1rem;margin-top:0}.nt-timeline .nt-timeline-sub-title{margin-top:0}.nt-timeline .nt-timeline-content{font-size:.8rem;border-bottom:2px dashed #ccc;padding-bottom:1.2rem}.nt-timeline.horizontal .nt-timeline-items{flex-direction:row;overflow-x:scroll}.nt-timeline.horizontal .nt-timeline-items>div{min-width:400px;margin-right:50px}.nt-timeline.horizontal.reverse .nt-timeline-items{flex-direction:row-reverse}.nt-timeline.horizontal.center .nt-timeline-before{background-image:linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%);background-repeat:no-repeat;background-size:100% 2px;background-position:0 center}.nt-timeline.horizontal.center .nt-timeline-after{background-image:linear-gradient(180deg, rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%);background-repeat:no-repeat;background-size:100% 2px;background-position:0 center}.nt-timeline.horizontal.center .nt-timeline-items{background-image:radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%);background-repeat:no-repeat;background-size:100% 2px;background-position:0 center}.nt-timeline.horizontal .nt-timeline-dot{left:50%}.nt-timeline.horizontal .nt-timeline-dot:not(.bigger){top:calc(50% - 4px)}.nt-timeline.horizontal .nt-timeline-dot.bigger{top:calc(50% - 15px)}.nt-timeline.vertical .nt-timeline-items{flex-direction:column}.nt-timeline.vertical.reverse .nt-timeline-items{flex-direction:column-reverse}.nt-timeline.vertical.center .nt-timeline-before{background:linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%) no-repeat center/2px 100%}.nt-timeline.vertical.center .nt-timeline-after{background:linear-gradient(rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%) no-repeat center/2px 100%}.nt-timeline.vertical.center .nt-timeline-items{background:radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%) no-repeat center/2px 100%}.nt-timeline.vertical.center .nt-timeline-dot{left:calc(50% - 10px)}.nt-timeline.vertical.center .nt-timeline-dot:not(.bigger){top:10px}.nt-timeline.vertical.center .nt-timeline-dot.bigger{left:calc(50% - 20px)}.nt-timeline.vertical.left{padding-left:100px}.nt-timeline.vertical.left .nt-timeline-item{padding-left:70px}.nt-timeline.vertical.left .nt-timeline-sub-title{left:-100px;width:100px}.nt-timeline.vertical.left .nt-timeline-before{background:linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%) no-repeat 30px/2px 100%}.nt-timeline.vertical.left .nt-timeline-after{background:linear-gradient(rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%) no-repeat 30px/2px 100%}.nt-timeline.vertical.left .nt-timeline-items{background:radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%) no-repeat 30px/2px 100%}.nt-timeline.vertical.left .nt-timeline-dot{left:21px;top:8px}.nt-timeline.vertical.left .nt-timeline-dot.bigger{top:0px;left:10px}.nt-timeline.vertical.right{padding-right:100px}.nt-timeline.vertical.right .nt-timeline-sub-title{right:-100px;text-align:left;width:100px}.nt-timeline.vertical.right .nt-timeline-item{padding-right:70px}.nt-timeline.vertical.right .nt-timeline-before{background:linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%) no-repeat calc(100% - 30px)/2px 100%}.nt-timeline.vertical.right .nt-timeline-after{background:linear-gradient(rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%) no-repeat calc(100% - 30px)/2px 100%}.nt-timeline.vertical.right .nt-timeline-items{background:radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%) no-repeat calc(100% - 30px)/2px 100%}.nt-timeline.vertical.right .nt-timeline-dot{right:21px;top:8px}.nt-timeline.vertical.right .nt-timeline-dot.bigger{top:10px;right:10px}.nt-timeline-items{display:flex;position:relative}.nt-timeline-items>div{min-height:100px;padding-top:2px;padding-bottom:20px}.nt-timeline-before{content:"";height:15px}.nt-timeline-after{content:"";height:60px;margin-bottom:20px}.nt-timeline-sub-title{position:absolute;width:50%;top:4px;font-size:18px;color:var(--nt-color-50)}[data-md-color-scheme=slate] .nt-timeline-sub-title{color:var(--nt-color-51)}.nt-timeline-item{position:relative}.nt-timeline.vertical.center:not(.alternate) .nt-timeline-item{padding-left:calc(50% + 40px)}.nt-timeline.vertical.center:not(.alternate) .nt-timeline-item .nt-timeline-sub-title{left:0;padding-right:40px;text-align:right}.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(odd){padding-left:calc(50% + 40px)}.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(odd) .nt-timeline-sub-title{left:0;padding-right:40px;text-align:right}.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(even){text-align:right;padding-right:calc(50% + 40px)}.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(even) .nt-timeline-sub-title{right:0;padding-left:40px;text-align:left}.nt-timeline-dot{position:relative;width:20px;height:20px;border-radius:100%;background-color:#fc5b5b;position:absolute;top:0px;z-index:2;display:flex;justify-content:center;align-items:center;box-shadow:0 2px 1px -1px rgba(0,0,0,.2),0 1px 1px 0 rgba(0,0,0,.14),0 1px 3px 0 rgba(0,0,0,.12);border:3px solid #fff}.nt-timeline-dot:not(.bigger) .icon{font-size:10px}.nt-timeline-dot.bigger{width:40px;height:40px;padding:3px}.nt-timeline-dot .icon{color:#fff}@supports not (-moz-appearance: none){details .nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(odd) .nt-timeline-sub-title,details .nt-timeline.vertical.center:not(.alternate) .nt-timeline-item .nt-timeline-sub-title{left:-40px}details .nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(even) .nt-timeline-sub-title{right:-40px}details .nt-timeline.vertical.center .nt-timeline-dot{left:calc(50% - 12px)}details .nt-timeline-dot.bigger{font-size:1rem !important}}.nt-timeline-item:nth-child(0) .nt-timeline-dot{background-color:var(--nt-color-0)}.nt-timeline-item:nth-child(1) .nt-timeline-dot{background-color:var(--nt-color-1)}.nt-timeline-item:nth-child(2) .nt-timeline-dot{background-color:var(--nt-color-2)}.nt-timeline-item:nth-child(3) .nt-timeline-dot{background-color:var(--nt-color-3)}.nt-timeline-item:nth-child(4) .nt-timeline-dot{background-color:var(--nt-color-4)}.nt-timeline-item:nth-child(5) .nt-timeline-dot{background-color:var(--nt-color-5)}.nt-timeline-item:nth-child(6) .nt-timeline-dot{background-color:var(--nt-color-6)}.nt-timeline-item:nth-child(7) .nt-timeline-dot{background-color:var(--nt-color-7)}.nt-timeline-item:nth-child(8) .nt-timeline-dot{background-color:var(--nt-color-8)}.nt-timeline-item:nth-child(9) .nt-timeline-dot{background-color:var(--nt-color-9)}.nt-timeline-item:nth-child(10) .nt-timeline-dot{background-color:var(--nt-color-10)}.nt-timeline-item:nth-child(11) .nt-timeline-dot{background-color:var(--nt-color-11)}.nt-timeline-item:nth-child(12) .nt-timeline-dot{background-color:var(--nt-color-12)}.nt-timeline-item:nth-child(13) .nt-timeline-dot{background-color:var(--nt-color-13)}.nt-timeline-item:nth-child(14) .nt-timeline-dot{background-color:var(--nt-color-14)}.nt-timeline-item:nth-child(15) .nt-timeline-dot{background-color:var(--nt-color-15)}.nt-timeline-item:nth-child(16) .nt-timeline-dot{background-color:var(--nt-color-16)}.nt-timeline-item:nth-child(17) .nt-timeline-dot{background-color:var(--nt-color-17)}.nt-timeline-item:nth-child(18) .nt-timeline-dot{background-color:var(--nt-color-18)}.nt-timeline-item:nth-child(19) .nt-timeline-dot{background-color:var(--nt-color-19)}.nt-timeline-item:nth-child(20) .nt-timeline-dot{background-color:var(--nt-color-20)}:root{--nt-scrollbar-color: #2751b0;--nt-plan-actions-height: 24px;--nt-units-background: #ff9800;--nt-months-background: #2751b0;--nt-plan-vertical-line-color: #a3a3a3ad}.nt-pastello{--nt-scrollbar-color: #9fb8f4;--nt-units-background: #f5dc82;--nt-months-background: #5b7fd1}[data-md-color-scheme=slate]{--nt-units-background: #003773}[data-md-color-scheme=slate] .nt-pastello{--nt-units-background: #3f4997}.nt-plan-root{min-height:200px;scrollbar-width:20px;scrollbar-color:var(--nt-scrollbar-color);display:flex}.nt-plan-root ::-webkit-scrollbar{width:20px}.nt-plan-root ::-webkit-scrollbar-track{box-shadow:inset 0 0 5px gray;border-radius:10px}.nt-plan-root ::-webkit-scrollbar-thumb{background:var(--nt-scrollbar-color);border-radius:10px}.nt-plan-root .nt-plan{flex:80%}.nt-plan-root.no-groups .nt-plan-periods{padding-left:0}.nt-plan-root.no-groups .nt-plan-group-summary{display:none}.nt-plan-root .nt-timeline-dot.bigger{top:-10px}.nt-plan-root .nt-timeline-dot.bigger[title]{cursor:help}.nt-plan{white-space:nowrap;overflow-x:auto;display:flex}.nt-plan .ug-timeline-dot{left:368px;top:-8px;cursor:help}.months{display:flex}.month{flex:auto;display:inline-block;box-shadow:rgba(0,0,0,.2) 0px 3px 1px -2px,rgba(0,0,0,.14) 0px 2px 2px 0px,rgba(0,0,0,.12) 0px 1px 5px 0px inset;background-color:var(--nt-months-background);color:#fff;text-transform:uppercase;font-family:Roboto,Helvetica,Arial,sans-serif;padding:2px 5px;font-size:12px;border:1px solid #000;width:150px;border-radius:8px}.nt-plan-group-activities{flex:auto;position:relative}.nt-vline{border-left:1px dashed var(--nt-plan-vertical-line-color);height:100%;left:0;position:absolute;margin-left:-0.5px;top:0;-webkit-transition:all .5s linear !important;-moz-transition:all .5s linear !important;-ms-transition:all .5s linear !important;-o-transition:all .5s linear !important;transition:all .5s linear !important;z-index:-2}.nt-plan-activity{display:flex;margin:2px 0;background-color:rgba(187,187,187,.2509803922)}.actions{height:var(--nt-plan-actions-height)}.actions{position:relative}.period{display:inline-block;height:var(--nt-plan-actions-height);width:120px;position:absolute;left:0px;background:#1da1f2;border-radius:5px;transition:all .5s;cursor:help;-webkit-transition:width 1s ease-in-out;-moz-transition:width 1s ease-in-out;-o-transition:width 1s ease-in-out;transition:width 1s ease-in-out}.period .nt-tooltip{display:none;top:30px;position:relative;padding:1rem;text-align:center;font-size:12px}.period:hover .nt-tooltip{display:inline-block}.period-0{left:340px;visibility:visible;background-color:#456165}.period-1{left:40px;visibility:visible;background-color:green}.period-2{left:120px;visibility:visible;background-color:pink;width:80px}.period-3{left:190px;visibility:visible;background-color:darkred;width:150px}.weeks>span,.days>span{height:25px}.weeks>span{display:inline-block;margin:0;padding:0;font-weight:bold}.weeks>span .week-text{font-size:10px;position:absolute;display:inline-block;padding:3px 4px}.days{z-index:-2;position:relative}.day-text{font-size:10px;position:absolute;display:inline-block;padding:3px 4px}.period span{font-size:12px;vertical-align:top;margin-left:4px;color:#000;background:rgba(255,255,255,.6588235294);border-radius:6px;padding:0 4px}.weeks,.days{height:20px;display:flex;box-sizing:content-box}.months{display:flex}.week,.day{height:20px;position:relative;border:1;flex:auto;border:2px solid #fff;border-radius:4px;background-color:var(--nt-units-background);cursor:help}.years{display:flex}.year{text-align:center;border-right:1px solid var(--nt-plan-vertical-line-color);font-weight:bold}.year:first-child{border-left:1px solid var(--nt-plan-vertical-line-color)}.year:first-child:last-child{width:100%}.quarters{display:flex}.quarter{width:12.5%;text-align:center;border-right:1px solid var(--nt-plan-vertical-line-color);font-weight:bold}.quarter:first-child{border-left:1px solid var(--nt-plan-vertical-line-color)}.nt-plan-group{margin:20px 0;position:relative}.nt-plan-group{display:flex}.nt-plan-group-summary{background:#2751b0;width:150px;white-space:normal;padding:.1rem .5rem;border-radius:5px;color:#fff;z-index:3}.nt-plan-group-summary p{margin:0;padding:0;font-size:.6rem;color:#fff}.nt-plan-group-summary,.month,.period,.week,.day,.nt-tooltip{border:3px solid #fff;box-shadow:0 2px 3px -1px rgba(0,0,0,.2),0 3px 3px 0 rgba(0,0,0,.14),0 1px 5px 0 rgba(0,0,0,.12)}.nt-plan-periods{padding-left:150px}.months{z-index:2;position:relative}.weeks{position:relative;top:-2px;z-index:0}.month,.quarter,.year,.week,.day,.nt-tooltip{font-family:Roboto,Helvetica,Arial,sans-serif;box-sizing:border-box}.nt-cards.nt-grid{display:grid;grid-auto-columns:1fr;gap:.5rem;max-width:100vw;overflow-x:auto;padding:1px}.nt-cards.nt-grid.cols-1{grid-template-columns:repeat(1, 1fr)}.nt-cards.nt-grid.cols-2{grid-template-columns:repeat(2, 1fr)}.nt-cards.nt-grid.cols-3{grid-template-columns:repeat(3, 1fr)}.nt-cards.nt-grid.cols-4{grid-template-columns:repeat(4, 1fr)}.nt-cards.nt-grid.cols-5{grid-template-columns:repeat(5, 1fr)}.nt-cards.nt-grid.cols-6{grid-template-columns:repeat(6, 1fr)}@media only screen and (max-width: 400px){.nt-cards.nt-grid{grid-template-columns:repeat(1, 1fr) !important}}.nt-card{box-shadow:0 2px 2px 0 rgba(0,0,0,.14),0 3px 1px -2px rgba(0,0,0,.2),0 1px 5px 0 rgba(0,0,0,.12)}.nt-card:hover{box-shadow:0 2px 2px 0 rgba(0,0,0,.24),0 3px 1px -2px rgba(0,0,0,.3),0 1px 5px 0 rgba(0,0,0,.22)}[data-md-color-scheme=slate] .nt-card{box-shadow:0 2px 2px 0 rgba(4,40,33,.14),0 3px 1px -2px rgba(40,86,94,.47),0 1px 5px 0 rgba(139,252,255,.64)}[data-md-color-scheme=slate] .nt-card:hover{box-shadow:0 2px 2px 0 rgba(0,255,206,.14),0 3px 1px -2px rgba(33,156,177,.47),0 1px 5px 0 rgba(96,251,255,.64)}.nt-card>a{color:var(--md-default-fg-color)}.nt-card>a>div{cursor:pointer}.nt-card{padding:5px;margin-bottom:.5rem}.nt-card-title{font-size:1rem;font-weight:bold;margin:4px 0 8px 0;line-height:22px}.nt-card-content{padding:.4rem .8rem .8rem .8rem}.nt-card-text{font-size:14px;padding:0;margin:0}.nt-card .nt-card-image{text-align:center;border-radius:2px;background-position:center center;background-size:cover;background-repeat:no-repeat;min-height:120px}.nt-card .nt-card-image.tags img{margin-top:12px}.nt-card .nt-card-image img{height:105px;margin-top:5px}.nt-card a:hover,.nt-card a:focus{color:var(--md-accent-fg-color)}.nt-card h2{margin:0}.span-table-wrapper table{border-collapse:collapse;margin-bottom:2rem;border-radius:.1rem}.span-table td,.span-table th{padding:.2rem;background-color:var(--md-default-bg-color);font-size:.64rem;max-width:100%;overflow:auto;touch-action:auto;border-top:.05rem solid var(--md-typeset-table-color);padding:.9375em 1.25em;vertical-align:top}.span-table tr:first-child td{font-weight:700;min-width:5rem;padding:.9375em 1.25em;vertical-align:top}.span-table td:first-child{border-left:.05rem solid var(--md-typeset-table-color)}.span-table td:last-child{border-right:.05rem solid var(--md-typeset-table-color)}.span-table tr:last-child{border-bottom:.05rem solid var(--md-typeset-table-color)}.span-table [colspan],.span-table [rowspan]{font-weight:bold;border:.05rem solid var(--md-typeset-table-color)}.span-table tr:not(:first-child):hover td:not([colspan]):not([rowspan]),.span-table td[colspan]:hover,.span-table td[rowspan]:hover{background-color:rgba(0,0,0,.035);box-shadow:0 .05rem 0 var(--md-default-bg-color) inset;transition:background-color 125ms}.nt-contribs{margin-top:2rem;font-size:small;border-top:1px dotted #d3d3d3;padding-top:.5rem}.nt-contribs .nt-contributors{padding-top:.5rem;display:flex;flex-wrap:wrap}.nt-contribs .nt-contributor{background:#d3d3d3;background-size:cover;width:40px;height:40px;border-radius:100%;margin:0 6px 6px 0;cursor:help;opacity:.7}.nt-contribs .nt-contributor:hover{opacity:1}.nt-contribs .nt-initials{text-transform:uppercase;font-size:24px;text-align:center;width:40px;height:40px;display:inline-block;vertical-align:middle;position:relative;top:2px;color:inherit;font-weight:bold}.nt-contribs .nt-group-0{background-color:var(--nt-color-0)}.nt-contribs .nt-group-1{background-color:var(--nt-color-1)}.nt-contribs .nt-group-2{background-color:var(--nt-color-2)}.nt-contribs .nt-group-3{background-color:var(--nt-color-3)}.nt-contribs .nt-group-4{background-color:var(--nt-color-4)}.nt-contribs .nt-group-5{background-color:var(--nt-color-5)}.nt-contribs .nt-group-6{background-color:var(--nt-color-6)}.nt-contribs .nt-group-7{color:#000;background-color:var(--nt-color-7)}.nt-contribs .nt-group-8{color:#000;background-color:var(--nt-color-8)}.nt-contribs .nt-group-9{background-color:var(--nt-color-9)}.nt-contribs .nt-group-10{background-color:var(--nt-color-10)}.nt-contribs .nt-group-11{background-color:var(--nt-color-11)}.nt-contribs .nt-group-12{background-color:var(--nt-color-12)}.nt-contribs .nt-group-13{background-color:var(--nt-color-13)}.nt-contribs .nt-group-14{background-color:var(--nt-color-14)}.nt-contribs .nt-group-15{color:#000;background-color:var(--nt-color-15)}.nt-contribs .nt-group-16{background-color:var(--nt-color-16)}.nt-contribs .nt-group-17{color:#000;background-color:var(--nt-color-17)}.nt-contribs .nt-group-18{background-color:var(--nt-color-18)}.nt-contribs .nt-group-19{background-color:var(--nt-color-19)}.nt-contribs .nt-group-20{color:#000;background-color:var(--nt-color-20)}.nt-contribs .nt-group-21{color:#000;background-color:var(--nt-color-21)}.nt-contribs .nt-group-22{color:#000;background-color:var(--nt-color-22)}.nt-contribs .nt-group-23{color:#000;background-color:var(--nt-color-23)}.nt-contribs .nt-group-24{color:#000;background-color:var(--nt-color-24)}.nt-contribs .nt-group-25{color:#000;background-color:var(--nt-color-25)}.nt-contribs .nt-group-26{color:#000;background-color:var(--nt-color-26)}.nt-contribs .nt-group-27{background-color:var(--nt-color-27)}.nt-contribs .nt-group-28{color:#000;background-color:var(--nt-color-28)}.nt-contribs .nt-group-29{color:#000;background-color:var(--nt-color-29)}.nt-contribs .nt-group-30{background-color:var(--nt-color-30)}.nt-contribs .nt-group-31{background-color:var(--nt-color-31)}.nt-contribs .nt-group-32{color:#000;background-color:var(--nt-color-32)}.nt-contribs .nt-group-33{background-color:var(--nt-color-33)}.nt-contribs .nt-group-34{background-color:var(--nt-color-34)}.nt-contribs .nt-group-35{background-color:var(--nt-color-35)}.nt-contribs .nt-group-36{background-color:var(--nt-color-36)}.nt-contribs .nt-group-37{background-color:var(--nt-color-37)}.nt-contribs .nt-group-38{background-color:var(--nt-color-38)}.nt-contribs .nt-group-39{color:#000;background-color:var(--nt-color-39)}.nt-contribs .nt-group-40{color:#000;background-color:var(--nt-color-40)}.nt-contribs .nt-group-41{color:#000;background-color:var(--nt-color-41)}.nt-contribs .nt-group-42{color:#000;background-color:var(--nt-color-42)}.nt-contribs .nt-group-43{color:#000;background-color:var(--nt-color-43)}.nt-contribs .nt-group-44{color:#000;background-color:var(--nt-color-44)}.nt-contribs .nt-group-45{background-color:var(--nt-color-45)}.nt-contribs .nt-group-46{color:#000;background-color:var(--nt-color-46)}.nt-contribs .nt-group-47{background-color:var(--nt-color-47)}.nt-contribs .nt-group-48{background-color:var(--nt-color-48)}.nt-contribs .nt-group-49{background-color:var(--nt-color-49)} \ No newline at end of file diff --git a/docs/index.md b/docs/index.md index bd2fb264f..cd2ee99c2 100644 --- a/docs/index.md +++ b/docs/index.md @@ -13,88 +13,22 @@ distributed caching of results. If you're a first time user of pyDVL, we recommend you to go through the [[getting-started]] and [[installation]] guides. -[TOC] +::cards:: cols=2 -=== "To the installation guide" +- title: To the installation guide + image: ./assets/material-toolbox.svg + url: 20-install - Test +- title: To the code + image: ./assets/material-code.svg + url: https://github.com/appliedAI-Initiative/pyDVL - :material-toolbox: +- title: Browse the API + image: ./assets/material-description.svg + url: code-reference/pydvl -.. grid:: 2 - :gutter: 4 - :padding: 4 +- title: To the examples + image: ./assets/material-computer.svg + url: examples - .. grid-item-card:: - :class-item: sd-text-center - - :material-regular:`home_repair_service;12em` - - .. button-ref:: 20-install - :expand: - :color: primary - :outline: - :click-parent: - - To the installation guide - - .. grid-item-card:: - :class-item: sd-text-center - - :material-regular:`code;12em` - - .. button-link:: https://github.com/appliedAI-Initiative/pyDVL - :expand: - :color: primary - :outline: - :click-parent: - - To the sources - - .. grid-item-card:: - :class-item: sd-text-center - - :material-regular:`description;12em` - - .. button-ref:: pydvl - :expand: - :color: primary - :outline: - :click-parent: - - Browse the API - - .. grid-item-card:: - :class-item: sd-text-center - - :material-regular:`computer;12em` - - .. button-link:: examples - :expand: - :color: primary - :outline: - :click-parent: - - To the examples - -Contents -======== - -.. toctree:: - :glob: - - * - examples/index - -.. toctree:: - :caption: Reference - :hidden: - - pydvl/index - -Indices and tables -================== - -* :ref:`genindex` -* :ref:`modindex` -* :ref:`search` +::/cards:: diff --git a/docs/requirements.txt b/docs/requirements.txt deleted file mode 100644 index e69de29bb..000000000 diff --git a/mkdocs.yml b/mkdocs.yml index 0e5e1f512..e6d32e8c4 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -21,6 +21,7 @@ plugins: import: - https://docs.python.org/3/objects.inv - https://numpy.org/doc/stable/objects.inv + - https://pandas.pydata.org/docs/objects.inv paths: [src] # search packages in the src folder options: docstring_style: google @@ -85,7 +86,8 @@ theme: name: Switch to light mode extra_css: -- stylesheets/extra.css +- css/extra.css +- css/neoteroi.css extra_javascript: - javascripts/mathjax.js @@ -103,6 +105,7 @@ markdown_extensions: - admonition - attr_list - footnotes +- neoteroi.cards - toc: permalink: True toc_depth: 3 diff --git a/requirements-docs.txt b/requirements-docs.txt index e7b37a0f8..87f6bea35 100644 --- a/requirements-docs.txt +++ b/requirements-docs.txt @@ -7,6 +7,7 @@ mkdocs-gen-files mkdocs-literate-nav mkdocs-section-index mkdocs-bibtex +neoteroi-mkdocs # Needed for card grid on home page mkdocs-gallery mkdocs-nbconvert mkdocs-git-revision-date-localized-plugin \ No newline at end of file diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 6dfb94116..4c0e21454 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -59,6 +59,7 @@ from pydvl.value.stopping import MaxUpdates, StoppingCriterion __all__ = [ + "compute_semivalues", "banzhaf_coefficient", "beta_coefficient", "shapley_coefficient", From a97b8b3b5d3ca2b57d3c8769931c69b36eed9647 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 15 May 2023 22:13:49 +0200 Subject: [PATCH 063/436] Lint code and fix publish path --- .github/workflows/tox.yaml | 2 +- build_scripts/generate_api_docs.py | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index 718370422..d45c1f86b 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -132,7 +132,7 @@ jobs: if: ${{ github.ref == 'refs/heads/develop' }} with: github_token: ${{ secrets.GITHUB_TOKEN }} - publish_dir: ./docs/_build/html + publish_dir: ./docs_build/ user_name: ${{ env.GITHUB_BOT_USERNAME }} user_email: ${{ env.GITHUB_BOT_EMAIL }} - name: Build and publish to TestPyPI diff --git a/build_scripts/generate_api_docs.py b/build_scripts/generate_api_docs.py index 7558c3504..ef3949c2f 100644 --- a/build_scripts/generate_api_docs.py +++ b/build_scripts/generate_api_docs.py @@ -1,5 +1,6 @@ """Generate the code reference pages.""" from pathlib import Path + import mkdocs_gen_files nav = mkdocs_gen_files.Nav() From 0b44769a0002a07f26d8a0e07c6ea41fcf8c518e Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 18 May 2023 17:00:11 +0200 Subject: [PATCH 064/436] Fix types --- .../frameworks/torch_differentiable.py | 24 ++++--------------- .../frameworks/twice_differentiable.py | 19 +++++---------- 2 files changed, 11 insertions(+), 32 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 215b9e742..b1251e63e 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -353,11 +353,7 @@ def num_params(self) -> int: return sum([np.prod(p.size()) for p in self.parameters]) def split_grad( - self, - x: torch.Tensor, - y: torch.Tensor, - *, - progress: bool = False, + self, x: torch.Tensor, y: torch.Tensor, *, progress: bool = False ) -> torch.Tensor: """ Calculates gradient of model parameters wrt each $x[i]$ and $y[i]$ and then @@ -378,10 +374,7 @@ def split_grad( grads.append( flatten_all( autograd.grad( - self.loss( - torch.squeeze(self.model(x[i])), - torch.squeeze(y[i]), - ), + self.loss(torch.squeeze(self.model(x[i])), torch.squeeze(y[i])), self.parameters, ) ).detach() @@ -390,11 +383,7 @@ def split_grad( return torch.stack(grads, axis=0) def grad( - self, - x: torch.Tensor, - y: torch.Tensor, - *, - x_requires_grad: bool = False, + self, x: torch.Tensor, y: torch.Tensor, *, x_requires_grad: bool = False ) -> Tuple[torch.Tensor, torch.Tensor]: """ Calculates gradient of model parameters wrt the model parameters. @@ -416,15 +405,12 @@ def grad( return flatten_all(grad_f), x def hessian( - self, - x: torch.Tensor, - y: torch.Tensor, - *, - progress: bool = False, + self, x: torch.Tensor, y: torch.Tensor, *, progress: bool = False ) -> torch.Tensor: """Calculates the explicit hessian of model parameters given data ($x$ and $y$). :param x: A matrix [NxD] representing the features $x_i$. :param y: A matrix [NxK] representing the target values $y_i$. + :param progress: ``True`` to display progress. :returns: the hessian of the model, i.e. the second derivative wrt. the model parameters. """ x = x.to(self.device) diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index 124327c86..e2d76621a 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -11,9 +11,7 @@ class TwiceDifferentiable(ABC, Generic[TensorType, ModelType]): """ def __init__( - self, - model: ModelType, - loss: Callable[[TensorType, TensorType], TensorType], + self, model: ModelType, loss: Callable[[TensorType, TensorType], TensorType] ): pass @@ -28,10 +26,7 @@ def parameters(self) -> List[TensorType]: pass def split_grad( - self, - x: TensorType, - y: TensorType, - progress: bool = False, + self, x: TensorType, y: TensorType, *, progress: bool = False ) -> TensorType: """ Calculate the gradient of the model wrt each input x and labels y. @@ -40,14 +35,14 @@ def split_grad( :param x: An array representing the features $x_i$. :param y: An array representing the predicted target values $y_i$. - :param progress: True, iff progress shall be printed. + :param progress: ``True`` to display progress. :returns: An array representing the gradients wrt. the parameters of the model. """ pass def grad( - self, x: TensorType, y: TensorType, x_requires_grad: bool = False + self, x: TensorType, y: TensorType, *, x_requires_grad: bool = False ) -> Tuple[TensorType, TensorType]: """ Calculates gradient of model parameters wrt. the model parameters. @@ -65,15 +60,13 @@ def grad( pass def hessian( - self, - x: TensorType, - y: TensorType, - progress: bool = False, + self, x: TensorType, y: TensorType, *, progress: bool = False ) -> TensorType: """Calculates the full Hessian of $L(f(x),y)$ with respect to the model parameters given data ($x$ and $y$). :param x: An array representing the features $x_i$. :param y: An array representing the target values $y_i$. + :param progress: ``True`` to display progress. :returns: the hessian of the model, i.e. the second derivative wrt. the model parameters. """ pass From ee8089e6c4014dee78e8a5d56fecf273e7bae037 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 19 May 2023 10:13:53 +0200 Subject: [PATCH 065/436] Fix bib after merge --- docs/pydvl.bib | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/docs/pydvl.bib b/docs/pydvl.bib index 2515bfbb7..69af8af14 100644 --- a/docs/pydvl.bib +++ b/docs/pydvl.bib @@ -87,21 +87,6 @@ @inproceedings{koh_understanding_2017 keywords = {notion} } -@inproceedings{koh_understanding_2017, - title = {Understanding {{Black-box Predictions}} via {{Influence Functions}}}, - booktitle = {Proceedings of the 34th {{International Conference}} on {{Machine Learning}}}, - author = {Koh, Pang Wei and Liang, Percy}, - year = {2017}, - month = jul, - eprint = {1703.04730}, - eprinttype = {arxiv}, - pages = {1885--1894}, - publisher = {{PMLR}}, - abstract = {How can we explain the predictions of a black-box model? In this paper, we use influence functions \textemdash{} a classic technique from robust statistics \textemdash{} to trace a model's prediction through the learning algorithm and back to its training data, thereby identifying training points most responsible for a given prediction. To scale up influence functions to modern machine learning settings, we develop a simple, efficient implementation that requires only oracle access to gradients and Hessian-vector products. We show that even on non-convex and non-differentiable models where the theory breaks down, approximations to influence functions can still provide valuable information. On linear models and convolutional neural networks, we demonstrate that influence functions are useful for multiple purposes: understanding model behavior, debugging models, detecting dataset errors, and even creating visually-indistinguishable training-set attacks.}, - archiveprefix = {arXiv}, - langid = {english} -} - @inproceedings{kwon_beta_2022, title = {Beta {{Shapley}}: A {{Unified}} and {{Noise-reduced Data Valuation Framework}} for {{Machine Learning}}}, shorttitle = {Beta {{Shapley}}}, From 9d1856a7618aa334244c423b361be5bd5ea27ceb Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 19 May 2023 14:48:30 +0200 Subject: [PATCH 066/436] More doc fixes --- .../frameworks/torch_differentiable.py | 21 ++++++++++--------- .../frameworks/twice_differentiable.py | 11 ++++++---- 2 files changed, 18 insertions(+), 14 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index b1251e63e..2d120e381 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -179,16 +179,17 @@ def solve_lissa( rtol: float = 1e-4, progress: bool = False, ) -> torch.Tensor: - """ - It uses LISSA, Linear time Stochastic Second-Order Algorithm, to calculate the - inverse of the HVP. More precisely, it finds x s.t. $Hx = b$, with $H$ being - the model hessian. - This is done by iteratively approximating H through - $$ - H^{-1}_{j+1} b = b + (I - d) \ H - \frac{H^{-1}_j b}{s} - $$ - where I is the identity matrix, d is a dampening term and s a scaling factor that - are applied to help convergence. More info can be found in :footcite:t:`koh_understanding_2017` + r""" + Uses LISSA, Linear time Stochastic Second-Order Algorithm, to iteratively + approximate the inverse Hessian. More precisely, it finds x s.t. $Hx = b$, + with $H$ being the model's second derivative wrt. the parameters. + This is done with the update + + $$H^{-1}_{j+1} b = b + (I - d) \ H - \frac{H^{-1}_j b}{s},$$ + + where $I$ is the identity matrix, $d$ is a dampening term and $s$ a scaling + factor that are applied to help convergence. For details, see + :footcite:t:`koh_understanding_2017`. :param model: A model wrapped in the TwiceDifferentiable interface. :param training_data: A DataLoader containing the training data. diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index e2d76621a..18d650d99 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -6,7 +6,8 @@ class TwiceDifferentiable(ABC, Generic[TensorType, ModelType]): - """Wraps a differentiable model and loss and provides methods to compute the + """ + Wraps a differentiable model and loss and provides methods to compute the second derivative of the loss wrt. the model parameters. """ @@ -36,7 +37,7 @@ def split_grad( :param x: An array representing the features $x_i$. :param y: An array representing the predicted target values $y_i$. :param progress: ``True`` to display progress. - :returns: An array representing the gradients wrt. the parameters of the + :return: An array representing the gradients wrt. the parameters of the model. """ pass @@ -52,7 +53,7 @@ def grad( :param x_requires_grad: If True, the input $x$ is marked as requiring gradients. This is important for further differentiation on input parameters. - :returns: A tuple where: the first element is an array with the + :return: A tuple where: the first element is an array with the gradients of the model, and the second element is the input to the model as a grad parameters. This can be used for further differentiation. @@ -64,9 +65,11 @@ def hessian( ) -> TensorType: """Calculates the full Hessian of $L(f(x),y)$ with respect to the model parameters given data ($x$ and $y$). + :param x: An array representing the features $x_i$. :param y: An array representing the target values $y_i$. :param progress: ``True`` to display progress. - :returns: the hessian of the model, i.e. the second derivative wrt. the model parameters. + :return: The hessian of the model, i.e. the second derivative wrt. the + model parameters. """ pass From 2e7e6303d6adee277910b6d3291c1505a2cffa88 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Tue, 30 May 2023 00:51:59 +0200 Subject: [PATCH 067/436] Add joblib as backend via loky. --- requirements.txt | 1 + src/pydvl/utils/config.py | 2 +- src/pydvl/utils/parallel/futures/__init__.py | 5 +++++ tests/utils/conftest.py | 6 +++++- 4 files changed, 12 insertions(+), 2 deletions(-) diff --git a/requirements.txt b/requirements.txt index e6c31a00b..0df829a93 100644 --- a/requirements.txt +++ b/requirements.txt @@ -10,3 +10,4 @@ pymemcache cloudpickle tqdm matplotlib +loky==3.0.0 \ No newline at end of file diff --git a/src/pydvl/utils/config.py b/src/pydvl/utils/config.py index 89ddd023f..e7c7f7d91 100644 --- a/src/pydvl/utils/config.py +++ b/src/pydvl/utils/config.py @@ -21,7 +21,7 @@ class ParallelConfig: :param logging_level: Logging level for the parallel backend's worker. """ - backend: Literal["sequential", "ray"] = "ray" + backend: Literal["sequential", "joblib", "ray"] = "ray" address: Optional[Union[str, Tuple[str, int]]] = None n_cpus_local: Optional[int] = None logging_level: int = logging.WARNING diff --git a/src/pydvl/utils/parallel/futures/__init__.py b/src/pydvl/utils/parallel/futures/__init__.py index 93b94fc27..f28d6459a 100644 --- a/src/pydvl/utils/parallel/futures/__init__.py +++ b/src/pydvl/utils/parallel/futures/__init__.py @@ -2,6 +2,8 @@ from contextlib import contextmanager from typing import Generator, Optional +from joblib.externals.loky import get_reusable_executor + from pydvl.utils.config import ParallelConfig from pydvl.utils.parallel.futures.ray import RayExecutor @@ -47,6 +49,9 @@ def init_executor( if config.backend == "ray": with RayExecutor(max_workers, config=config, **kwargs) as executor: yield executor + elif config.backend == "joblib": + with get_reusable_executor(max_workers=max_workers, timeout=10800) as executor: + yield executor elif config.backend == "sequential": with ThreadPoolExecutor(1) as executor: yield executor diff --git a/tests/utils/conftest.py b/tests/utils/conftest.py index df56a9583..0b68783c2 100644 --- a/tests/utils/conftest.py +++ b/tests/utils/conftest.py @@ -5,10 +5,14 @@ from pydvl.utils.config import ParallelConfig -@pytest.fixture(scope="module", params=["sequential", "ray-local", "ray-external"]) +@pytest.fixture( + scope="module", params=["sequential", "joblib", "ray-local", "ray-external"] +) def parallel_config(request, num_workers): if request.param == "sequential": yield ParallelConfig(backend=request.param) + elif request.param == "joblib": + yield ParallelConfig(backend="joblib", n_cpus_local=num_workers) elif request.param == "ray-local": yield ParallelConfig(backend="ray", n_cpus_local=num_workers) ray.shutdown() From c250a2f5a137909f041c7e83ef6ad2bd4dafa1b8 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Mon, 5 Jun 2023 19:12:21 +0200 Subject: [PATCH 068/436] WIP: converting args and a bunch of things to mkdocs --- mkdocs.yml | 6 +- requirements-docs.txt | 5 +- src/pydvl/influence/__init__.py | 2 +- src/pydvl/influence/conjugate_gradient.py | 44 +++-- .../frameworks/torch_differentiable.py | 36 ++-- src/pydvl/influence/general.py | 70 +++---- src/pydvl/influence/linear.py | 39 ++-- .../model_wrappers/torch_wrappers.py | 56 +++--- src/pydvl/reporting/plots.py | 64 +++--- src/pydvl/reporting/scores.py | 13 +- src/pydvl/utils/caching.py | 23 +-- src/pydvl/utils/config.py | 52 ++--- src/pydvl/utils/dataset.py | 186 ++++++++++-------- src/pydvl/utils/numeric.py | 95 +++++---- src/pydvl/utils/parallel/backend.py | 27 +-- src/pydvl/utils/parallel/futures/__init__.py | 6 +- src/pydvl/utils/parallel/futures/ray.py | 19 +- src/pydvl/utils/parallel/map_reduce.py | 38 ++-- src/pydvl/utils/progress.py | 6 +- src/pydvl/utils/score.py | 25 +-- src/pydvl/utils/status.py | 2 +- src/pydvl/utils/types.py | 7 +- src/pydvl/utils/utility.py | 4 +- src/pydvl/value/__init__.py | 2 +- src/pydvl/value/least_core/__init__.py | 37 ++-- src/pydvl/value/least_core/common.py | 47 ++--- src/pydvl/value/least_core/montecarlo.py | 32 +-- src/pydvl/value/least_core/naive.py | 21 +- src/pydvl/value/loo/naive.py | 7 +- src/pydvl/value/result.py | 85 ++++---- src/pydvl/value/sampler.py | 24 +-- src/pydvl/value/semivalues.py | 64 +++--- src/pydvl/value/shapley/__init__.py | 4 +- src/pydvl/value/shapley/common.py | 34 ++-- src/pydvl/value/shapley/gt.py | 68 ++++--- src/pydvl/value/shapley/knn.py | 11 +- src/pydvl/value/shapley/montecarlo.py | 74 +++---- src/pydvl/value/shapley/naive.py | 26 +-- src/pydvl/value/shapley/owen.py | 48 ++--- src/pydvl/value/shapley/truncated.py | 44 +++-- src/pydvl/value/shapley/types.py | 2 +- src/pydvl/value/stopping.py | 39 ++-- 42 files changed, 792 insertions(+), 702 deletions(-) diff --git a/mkdocs.yml b/mkdocs.yml index e6d32e8c4..a375d04a0 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -11,6 +11,7 @@ plugins: - autorefs - search - section-index +- mkdocs-version-annotations - alias: use_relative_link: true verbose: true @@ -62,13 +63,14 @@ theme: - search.suggest - search.highlight - toc.follow - - navigation.tabs - - navigation.tabs.sticky + # - navigation.tabs + # - navigation.tabs.sticky - navigation.sections - navigation.tracking # - navigation.top - navigation.footer - content.code.copy + - content.code.annotate palette: # Palette toggle for light mode - media: "(prefers-color-scheme: light)" diff --git a/requirements-docs.txt b/requirements-docs.txt index 87f6bea35..beedfc145 100644 --- a/requirements-docs.txt +++ b/requirements-docs.txt @@ -10,4 +10,7 @@ mkdocs-bibtex neoteroi-mkdocs # Needed for card grid on home page mkdocs-gallery mkdocs-nbconvert -mkdocs-git-revision-date-localized-plugin \ No newline at end of file +mkdocs-git-revision-date-localized-plugin +mkdocs-version-annotations +pypandoc +pypandoc_binary diff --git a/src/pydvl/influence/__init__.py b/src/pydvl/influence/__init__.py index 37f1ff9cf..10591ffb9 100644 --- a/src/pydvl/influence/__init__.py +++ b/src/pydvl/influence/__init__.py @@ -1,7 +1,7 @@ """ This package contains algorithms for the computation of the influence function. -.. warning:: +!!! Warning Much of the code in this package is experimental or untested and is subject to modification. In particular, the package structure and basic API will probably change. diff --git a/src/pydvl/influence/conjugate_gradient.py b/src/pydvl/influence/conjugate_gradient.py index a19311c03..41b0f3ebb 100644 --- a/src/pydvl/influence/conjugate_gradient.py +++ b/src/pydvl/influence/conjugate_gradient.py @@ -27,11 +27,12 @@ def conjugate_gradient( Given a matrix and a batch of vectors, it uses conjugate gradient to calculate the solution to Ax = y for each y in batch_y. - :param A: a real, symmetric and positive-definite matrix of shape [NxN] - :param batch_y: a matrix of shape [NxP], with P the size of the batch. - :param progress: True, iff progress shall be printed. + A: a real, symmetric and positive-definite matrix of shape [NxN] + batch_y: a matrix of shape [NxP], with P the size of the batch. + progress: True, iff progress shall be printed. - :return: A NDArray of shape [NxP] representing x, the solution of Ax=b. + Returns: + A NDArray of shape [NxP] representing x, the solution of Ax=b. """ batch_cg = [] for y in maybe_progress(batch_y, progress, desc="Conjugate gradient"): @@ -56,20 +57,21 @@ def batched_preconditioned_conjugate_gradient( See also [2]_ and [3]_. - .. warning:: + !!! Warning This function is experimental and unstable. Prefer using inversion_method='cg' - :param A: A linear function f : R[k] -> R[k] representing a matrix vector product from dimension K to K or a matrix. \ + A: A linear function f : R[k] -> R[k] representing a matrix vector product from dimension K to K or a matrix. \ It has to be positive-definite v.T @ f(v) >= 0. - :param b: A NDArray of shape [K] representing the targeted result of the matrix multiplication Ax. - :param max_iterations: Maximum number of iterations to use in conjugate gradient. Default is 10 times K. - :param rtol: Relative tolerance of the residual with respect to the 2-norm of b. - :param max_step_size: Maximum step size along a gradient direction. Might be necessary for numerical stability. \ + b: A NDArray of shape [K] representing the targeted result of the matrix multiplication Ax. + max_iterations: Maximum number of iterations to use in conjugate gradient. Default is 10 times K. + rtol: Relative tolerance of the residual with respect to the 2-norm of b. + max_step_size: Maximum step size along a gradient direction. Might be necessary for numerical stability. \ See also max_iterations. Default is 10.0. - :param verify_assumptions: True, iff the matrix should be checked for positive-definiteness by a stochastic rule. + verify_assumptions: True, iff the matrix should be checked for positive-definiteness by a stochastic rule. - :return: A NDArray of shape [K] representing the solution of Ax=b. + Returns: + A NDArray of shape [K] representing the solution of Ax=b. .. note:: .. [1] `Conjugate Gradient Method - Wikipedia `_. @@ -183,11 +185,12 @@ def conjugate_gradient_condition_number_based_error_bound( Error bound for conjugate gradient based on the condition number of the weight matrix A. Used for testing purposes. See also https://math.stackexchange.com/questions/382958/error-for-conjugate-gradient-method. Explicit of the weight matrix is required. - :param A: Weight matrix of the matrix to be inverted. - :param n: Maximum number for executed iterations X in conjugate gradient. - :param x0: Initialization solution x0 of conjugate gradient. - :param xt: Final solution xt of conjugate gradient after X iterations. - :returns: Upper bound for ||x0 - xt||_A. + A: Weight matrix of the matrix to be inverted. + n: Maximum number for executed iterations X in conjugate gradient. + x0: Initialization solution x0 of conjugate gradient. + xt: Final solution xt of conjugate gradient after X iterations. + Returns: + Upper bound for ||x0 - xt||_A. """ eigvals = np.linalg.eigvals(A) eigvals = np.sort(eigvals) @@ -209,9 +212,10 @@ def hvp_to_inv_diag_conditioner( """ This method uses the hvp function to construct a simple pre-conditioner 1/diag(H). It does so while requiring only O(d) space in RAM for construction and later execution. - :param hvp: The callable calculating the Hessian vector product Hv. - :param d: The number of dimensions of the hvp callable. - :returns: A MatrixVectorProduct for the conditioner. + hvp: The callable calculating the Hessian vector product Hv. + d: The number of dimensions of the hvp callable. + Returns: + A MatrixVectorProduct for the conditioner. """ diags = np.empty(d) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 8e3a370c3..0e3c73e22 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -44,8 +44,8 @@ def __init__( loss: Callable[["torch.Tensor", "torch.Tensor"], "torch.Tensor"], ): """ - :param model: A torch.nn.Module representing a (differentiable) function f(x). - :param loss: Loss function L(f(x), y) maps a prediction and a target to a single value. + model: A torch.nn.Module representing a (differentiable) function f(x). + loss: Loss function L(f(x), y) maps a prediction and a target to a single value. """ if not _TORCH_INSTALLED: raise RuntimeWarning("This function requires PyTorch.") @@ -56,7 +56,8 @@ def __init__( def num_params(self) -> int: """ Get number of parameters of model f. - :returns: Number of parameters as integer. + Returns: + Number of parameters as integer. """ model_parameters = filter(lambda p: p.requires_grad, self.model.parameters()) return sum([np.prod(p.size()) for p in model_parameters]) @@ -71,10 +72,11 @@ def split_grad( Calculates gradient of model parameters wrt each x[i] and y[i] and then returns a array of size [N, P] with N number of points (length of x and y) and P number of parameters of the model. - :param x: A np.ndarray [NxD] representing the features x_i. - :param y: A np.ndarray [NxK] representing the predicted target values y_i. - :param progress: True, iff progress shall be printed. - :returns: A np.ndarray [NxP] representing the gradients with respect to all parameters of the model. + x: A np.ndarray [NxD] representing the features x_i. + y: A np.ndarray [NxK] representing the predicted target values y_i. + progress: True, iff progress shall be printed. + Returns: + A np.ndarray [NxP] representing the gradients with respect to all parameters of the model. """ x = torch.as_tensor(x).unsqueeze(1) y = torch.as_tensor(y) @@ -110,10 +112,11 @@ def grad( ) -> Tuple["NDArray", "torch.Tensor"]: """ Calculates gradient of model parameters wrt x and y. - :param x: A np.ndarray [NxD] representing the features x_i. - :param y: A np.ndarray [NxK] representing the predicted target values y_i. - :param progress: True, iff progress shall be printed. - :returns: A tuple where: \ + x: A np.ndarray [NxD] representing the features x_i. + y: A np.ndarray [NxK] representing the predicted target values y_i. + progress: True, iff progress shall be printed. + Returns: + A tuple where: \ - first element is a np.ndarray [P] with the gradients of the model. \ - second element is the input to the model as a grad parameters. \ This can be used for further differentiation. @@ -141,14 +144,15 @@ def mvp( This second order derivative can be on the model parameters or on another input parameter, selected via the backprop_on argument. - :param grad_xy: an array [P] holding the gradients of the model parameters wrt input x and labels y, \ + grad_xy: an array [P] holding the gradients of the model parameters wrt input x and labels y, \ where P is the number of parameters of the model. It is typically obtained through self.grad. - :param v: A np.ndarray [DxP] or a one dimensional np.array [D] which multiplies the Hessian, \ + v: A np.ndarray [DxP] or a one dimensional np.array [D] which multiplies the Hessian, \ where D is the number of directions. - :param progress: True, iff progress shall be printed. - :param backprop_on: tensor used in the second backpropagation (the first one is along x and y as defined \ + progress: True, iff progress shall be printed. + backprop_on: tensor used in the second backpropagation (the first one is along x and y as defined \ via grad_xy). If None, the model parameters are used. - :returns: A np.ndarray representing the implicit matrix vector product of the model along the given directions.\ + Returns: + A np.ndarray representing the implicit matrix vector product of the model along the given directions.\ Output shape is [DxP] if backprop_on is None, otherwise [DxM], with M the number of elements of backprop_on. """ v = torch.as_tensor(v) diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index c7c7786de..634c1b73a 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -62,16 +62,17 @@ def calculate_influence_factors( """ Calculates the influence factors. For more info, see https://arxiv.org/pdf/1703.04730.pdf, paragraph 3. - :param model: A model which has to implement the TwiceDifferentiable interface. - :param x_train: A np.ndarray of shape [MxK] containing the features of the input data points. - :param y_train: A np.ndarray of shape [MxL] containing the targets of the input data points. - :param x_test: A np.ndarray of shape [NxK] containing the features of the test set of data points. - :param y_test: A np.ndarray of shape [NxL] containing the targets of the test set of data points. - :param inversion_func: function to use to invert the product of hvp (hessian vector product) and the gradient + model: A model which has to implement the TwiceDifferentiable interface. + x_train: A np.ndarray of shape [MxK] containing the features of the input data points. + y_train: A np.ndarray of shape [MxL] containing the targets of the input data points. + x_test: A np.ndarray of shape [NxK] containing the features of the test set of data points. + y_test: A np.ndarray of shape [NxL] containing the targets of the test set of data points. + inversion_func: function to use to invert the product of hvp (hessian vector product) and the gradient of the loss (s_test in the paper). - :param lam: regularization of the hessian - :param progress: If True, display progress bars. - :returns: A np.ndarray of size (N, D) containing the influence factors for each dimension (D) and test sample (N). + lam: regularization of the hessian + progress: If True, display progress bars. + Returns: + A np.ndarray of size (N, D) containing the influence factors for each dimension (D) and test sample (N). """ if not _TORCH_INSTALLED: raise RuntimeWarning("This function requires PyTorch.") @@ -92,12 +93,13 @@ def _calculate_influences_up( Calculates the influence from the influence factors and the scores of the training points. Uses the upweighting method, as described in section 2.1 of https://arxiv.org/pdf/1703.04730.pdf - :param model: A model which has to implement the TwiceDifferentiable interface. - :param x_train: A np.ndarray of shape [MxK] containing the features of the input data points. - :param y_train: A np.ndarray of shape [MxL] containing the targets of the input data points. - :param influence_factors: np.ndarray containing influence factors - :param progress: If True, display progress bars. - :returns: A np.ndarray of size [NxM], where N is number of test points and M number of train points. + model: A model which has to implement the TwiceDifferentiable interface. + x_train: A np.ndarray of shape [MxK] containing the features of the input data points. + y_train: A np.ndarray of shape [MxL] containing the targets of the input data points. + influence_factors: np.ndarray containing influence factors + progress: If True, display progress bars. + Returns: + A np.ndarray of size [NxM], where N is number of test points and M number of train points. """ train_grads = model.split_grad(x, y, progress) return np.einsum("ta,va->tv", influence_factors, train_grads) # type: ignore @@ -114,12 +116,13 @@ def _calculate_influences_pert( Calculates the influence from the influence factors and the scores of the training points. Uses the perturbation method, as described in section 2.2 of https://arxiv.org/pdf/1703.04730.pdf - :param model: A model which has to implement the TwiceDifferentiable interface. - :param x_train: A np.ndarray of shape [MxK] containing the features of the input data points. - :param y_train: A np.ndarray of shape [MxL] containing the targets of the input data points. - :param influence_factors: np.ndarray containing influence factors - :param progress: If True, display progress bars. - :returns: A np.ndarray of size [NxMxP], where N is number of test points, M number of train points, + model: A model which has to implement the TwiceDifferentiable interface. + x_train: A np.ndarray of shape [MxK] containing the features of the input data points. + y_train: A np.ndarray of shape [MxL] containing the targets of the input data points. + influence_factors: np.ndarray containing influence factors + progress: If True, display progress bars. + Returns: + A np.ndarray of size [NxMxP], where N is number of test points, M number of train points, and P the number of features. """ all_pert_influences = [] @@ -164,28 +167,29 @@ def compute_influences( get the influences over the complete training set. Points with low influence values are (on average) less important for model training than points with high influences. - :param model: A supervised model from a supported framework. Currently, only pytorch nn.Module is supported. - :param loss: loss of the model, a callable that, given prediction of the model and real labels, returns a + model: A supervised model from a supported framework. Currently, only pytorch nn.Module is supported. + loss: loss of the model, a callable that, given prediction of the model and real labels, returns a tensor with the loss value. - :param x: model input for training - :param y: input labels - :param x_test: model input for testing - :param y_test: test labels - :param progress: whether to display progress bars. - :param inversion_method: Set the inversion method to a specific one, can be 'direct' for direct inversion + x: model input for training + y: input labels + x_test: model input for testing + y_test: test labels + progress: whether to display progress bars. + inversion_method: Set the inversion method to a specific one, can be 'direct' for direct inversion (and explicit construction of the Hessian) or 'cg' for conjugate gradient. - :param influence_type: Which algorithm to use to calculate influences. + influence_type: Which algorithm to use to calculate influences. Currently supported options: 'up' or 'perturbation'. For details refer to https://arxiv.org/pdf/1703.04730.pdf - :param inversion_method_kwargs: kwargs for the inversion method selected. + inversion_method_kwargs: kwargs for the inversion method selected. If using the direct method no kwargs are needed. If inversion_method='cg', the following kwargs can be passed: - rtol: relative tolerance to be achieved before terminating computation - max_iterations: maximum conjugate gradient iterations - max_step_size: step size of conjugate gradient - verify_assumptions: True to run tests on convexity of the model. - :param hessian_regularization: lambda to use in Hessian regularization, i.e. H_reg = H + lambda * 1, with 1 the identity matrix \ + hessian_regularization: lambda to use in Hessian regularization, i.e. H_reg = H + lambda * 1, with 1 the identity matrix \ and H the (simple and regularized) Hessian. Typically used with more complex models to make sure the Hessian \ is positive definite. - :returns: A np.ndarray specifying the influences. Shape is [NxM] if influence_type is'up', where N is number of test points and + Returns: + A np.ndarray specifying the influences. Shape is [NxM] if influence_type is'up', where N is number of test points and M number of train points. If instead influence_type is 'perturbation', output shape is [NxMxP], with P the number of input features. """ diff --git a/src/pydvl/influence/linear.py b/src/pydvl/influence/linear.py index 5725c17f9..433d4c341 100644 --- a/src/pydvl/influence/linear.py +++ b/src/pydvl/influence/linear.py @@ -31,15 +31,16 @@ def compute_linear_influences( validation set for an ordinary least squares model ($y = A x + b$ with quadratic loss). - :param x: An array of shape (M, K) containing the features of training data. - :param y: An array of shape (M, L) containing the targets of training data. - :param x_test: An array of shape (N, K) containing the features of the + x: An array of shape (M, K) containing the features of training data. + y: An array of shape (M, L) containing the targets of training data. + x_test: An array of shape (N, K) containing the features of the test set. - :param y_test: An array of shape (N, L) containing the targets of the test + y_test: An array of shape (N, L) containing the targets of the test set. - :param influence_type: Which algorithm to use to calculate influences. + influence_type: Which algorithm to use to calculate influences. Currently supported options: 'up' or 'perturbation'. - :returns: An array of shape (B, C) with the influences of the training + Returns: + An array of shape (B, C) with the influences of the training points on the test data. """ @@ -84,17 +85,18 @@ def influences_up_linear_regression_analytical( This method uses the - :param linear_model: A tuple of arrays of shapes (N, M) and N representing A + linear_model: A tuple of arrays of shapes (N, M) and N representing A and b respectively. - :param x: An array of shape (M, K) containing the features of the + x: An array of shape (M, K) containing the features of the training set. - :param y: An array of shape (M, L) containing the targets of the + y: An array of shape (M, L) containing the targets of the training set. - :param x_test: An array of shape (N, K) containing the features of the test + x_test: An array of shape (N, K) containing the features of the test set. - :param y_test: An array of shape (N, L) containing the targets of the test + y_test: An array of shape (N, L) containing the targets of the test set. - :returns: An array of shape (B, C) with the influences of the training points + Returns: + An array of shape (B, C) with the influences of the training points on the test points. """ @@ -130,17 +132,18 @@ def influences_perturbation_linear_regression_analytical( """Calculate the influences of each training sample onto the validation set for a linear model Ax+b=y. - :param linear_model: A tuple of np.ndarray' of shape (N, M) and (N) + linear_model: A tuple of np.ndarray' of shape (N, M) and (N) representing A and b respectively. - :param x: An array of shape (M, K) containing the features of the + x: An array of shape (M, K) containing the features of the input data. - :param y: An array of shape (M, L) containing the targets of the input + y: An array of shape (M, L) containing the targets of the input data. - :param x_test: An array of shape (N, K) containing the features of the test + x_test: An array of shape (N, K) containing the features of the test set. - :param y_test: An array of shape (N, L) containing the targets of the test + y_test: An array of shape (N, L) containing the targets of the test set. - :returns: An array of shape (B, C, M) with the influences of the training + Returns: + An array of shape (B, C, M) with the influences of the training points on the test points for each feature. """ diff --git a/src/pydvl/influence/model_wrappers/torch_wrappers.py b/src/pydvl/influence/model_wrappers/torch_wrappers.py index 6aba15b16..3bd4c9f48 100644 --- a/src/pydvl/influence/model_wrappers/torch_wrappers.py +++ b/src/pydvl/influence/model_wrappers/torch_wrappers.py @@ -58,14 +58,14 @@ def fit( It represents a simple machine learning loop, iterating over a number of epochs, sampling data with a certain batch size, calculating gradients and updating the parameters through a loss function. - :param x: Matrix of shape [NxD] representing the features x_i. - :param y: Matrix of shape [NxK] representing the prediction targets y_i. - :param optimizer: Select either ADAM or ADAM_W. - :param scheduler: A pytorch scheduler. If None, no scheduler is used. - :param num_epochs: Number of epochs to repeat training. - :param batch_size: Batch size to use in training. - :param progress: True, iff progress shall be printed. - :param tensor_type: accuracy of tensors. Typically 'float' or 'long' + x: Matrix of shape [NxD] representing the features x_i. + y: Matrix of shape [NxK] representing the prediction targets y_i. + optimizer: Select either ADAM or ADAM_W. + scheduler: A pytorch scheduler. If None, no scheduler is used. + num_epochs: Number of epochs to repeat training. + batch_size: Batch size to use in training. + progress: True, iff progress shall be printed. + tensor_type: accuracy of tensors. Typically 'float' or 'long' """ x_train = torch.as_tensor(x_train).clone() y_train = torch.as_tensor(y_train).clone() @@ -105,8 +105,9 @@ def fit( def predict(self, x: torch.Tensor) -> "NDArray[np.float_]": """ Use internal model to deliver prediction in numpy. - :param x: A np.ndarray [NxD] representing the features x_i. - :returns: A np.ndarray [NxK] representing the predicted values. + x: A np.ndarray [NxD] representing the features x_i. + Returns: + A np.ndarray [NxK] representing the predicted values. """ return self.forward(x).detach().numpy() # type: ignore @@ -118,9 +119,10 @@ def score( ) -> float: """ Use internal model to measure how good is prediction through a loss function. - :param x: A np.ndarray [NxD] representing the features x_i. - :param y: A np.ndarray [NxK] representing the predicted target values y_i. - :returns: The aggregated value over all samples N. + x: A np.ndarray [NxD] representing the features x_i. + y: A np.ndarray [NxK] representing the predicted target values y_i. + Returns: + The aggregated value over all samples N. """ return score(self.forward(x), y).detach().numpy() # type: ignore @@ -148,8 +150,8 @@ def __init__( init: Tuple["NDArray[np.float_]", "NDArray[np.float_]"] = None, ): """ - :param n_input: input to the model. - :param n_output: output of the model + n_input: input to the model. + n_output: output of the model :param init A tuple with two matrices, namely A of shape [K, D] and b of shape [K]. If set to None Xavier uniform initialization is used. """ @@ -172,7 +174,7 @@ def __init__( def forward(self, x: torch.Tensor) -> torch.Tensor: """ Calculate A @ x + b using RAM-optimized calculation layout. - :param x: Tensor [NxD] representing the features x_i. + x: Tensor [NxD] representing the features x_i. :returns A tensor [NxK] representing the outputs y_i. """ return x @ self.A.T + self.b @@ -189,7 +191,7 @@ def __init__( init: Tuple["NDArray[np.float_]", "NDArray[np.float_]"] = None, ): """ - :param n_input: Number of feature inputs to the BinaryLogisticRegressionModel. + n_input: Number of feature inputs to the BinaryLogisticRegressionModel. :param init A tuple representing the initialization for the weight matrix A and the bias b. If set to None sample the values uniformly using the Xavier rule. """ @@ -206,8 +208,9 @@ def __init__( def forward(self, x: Union["NDArray[np.float_]", torch.Tensor]) -> torch.Tensor: """ Calculate sigmoid(dot(a, x) + b) using RAM-optimized calculation layout. - :param x: Tensor [NxD] representing the features x_i. - :returns: A tensor [N] representing the probabilities for p(y_i). + x: Tensor [NxD] representing the features x_i. + Returns: + A tensor [N] representing the probabilities for p(y_i). """ x = torch.as_tensor(x) return torch.sigmoid(x @ self.A.T + self.b) @@ -228,12 +231,12 @@ def __init__( init: List[Tuple["NDArray[np.float_]", "NDArray[np.float_]"]] = None, ): """ - :param n_input: Number of feature in input. - :param n_output: Output length. - :param n_neurons_per_layer: Each integer represents the size of a hidden layer. Overall this list has K - 2 - :param output_probabilities: True, if the model should output probabilities. In the case of n_output 2 the + n_input: Number of feature in input. + n_output: Output length. + n_neurons_per_layer: Each integer represents the size of a hidden layer. Overall this list has K - 2 + output_probabilities: True, if the model should output probabilities. In the case of n_output 2 the number of outputs reduce to 1. - :param init: A list of tuple of np.ndarray representing the internal weights. + init: A list of tuple of np.ndarray representing the internal weights. """ super().__init__() self.n_input = n_input @@ -274,7 +277,8 @@ def __init__( def forward(self, x: torch.Tensor) -> torch.Tensor: """ Perform forward-pass through the network. - :param x: Tensor input of shape [NxD]. - :returns: Tensor output of shape[NxK]. + x: Tensor input of shape [NxD]. + Returns: + Tensor output of shape[NxK]. """ return self.layers(x) diff --git a/src/pydvl/reporting/plots.py b/src/pydvl/reporting/plots.py index 8008bddf9..8865a4958 100644 --- a/src/pydvl/reporting/plots.py +++ b/src/pydvl/reporting/plots.py @@ -23,21 +23,22 @@ def shaded_mean_std( ) -> Axes: """The usual mean +- x std deviations plot to aggregate runs of experiments. - :param data: axis 0 is to be aggregated on (e.g. runs) and axis 1 is the + data: axis 0 is to be aggregated on (e.g. runs) and axis 1 is the data for each run. - :param abscissa: values for the x axis. Leave empty to use increasing + abscissa: values for the x axis. Leave empty to use increasing integers. - :param num_std: number of standard deviations to shade around the mean. - :param mean_color: color for the mean - :param shade_color: color for the shaded region - :param title: - :param xlabel: - :param ylabel: - :param ax: If passed, axes object into which to insert the figure. Otherwise, + num_std: number of standard deviations to shade around the mean. + mean_color: color for the mean + shade_color: color for the shaded region + title: + xlabel: + ylabel: + ax: If passed, axes object into which to insert the figure. Otherwise, a new figure is created and returned - :param kwargs: these are forwarded to the ax.plot() call for the mean. + kwargs: these are forwarded to the ax.plot() call for the mean. - :return: The axes used (or created) + Returns: + The axes used (or created) """ assert len(data.shape) == 2 mean = data.mean(axis=0) @@ -62,8 +63,8 @@ def shapley_results(results: dict, filename: str = None): """ FIXME: change this to use dataframes - :param results: dict - :param filename: For plt.savefig(). Set to None to disable saving. + results: dict + filename: For plt.savefig(). Set to None to disable saving. Here's an example results dictionary:: @@ -131,12 +132,12 @@ def shapley_results(results: dict, filename: str = None): def spearman_correlation(vv: List[OrderedDict], num_values: int, pvalue: float): """Simple matrix plots with spearman correlation for each pair in vv. - :param vv: list of OrderedDicts with index: value. Spearman correlation - is computed for the keys. - :param num_values: Use only these many values from the data (from the start - of the OrderedDicts) - :param pvalue: correlation coefficients for which the p-value is below the - threshold `pvalue/len(vv)` will be discarded. + vv: list of OrderedDicts with index: value. Spearman correlation + is computed for the keys. + num_values: Use only these many values from the data (from the start + of the OrderedDicts) + pvalue: correlation coefficients for which the p-value is below the + threshold `pvalue/len(vv)` will be discarded. """ r: np.ndarray = np.ndarray((len(vv), len(vv))) p: np.ndarray = np.ndarray((len(vv), len(vv))) @@ -176,16 +177,17 @@ def plot_shapley( ylabel: str = None, ) -> plt.Axes: """Plots the shapley values, as returned from - :func:`~pydvl.value.shapley.common.compute_shapley_values`, with error bars + [compute_shapley_values()][pydvl.value.shapley.common.compute_shapley_values], with error bars corresponding to an $\alpha$-level confidence interval. - :param df: dataframe with the shapley values - :param level: confidence level for the error bars - :param ax: axes to plot on or None if a new subplots should be created - :param title: string, title of the plot - :param xlabel: string, x label of the plot - :param ylabel: string, y label of the plot - :return: the axes created or used + df: dataframe with the shapley values + level: confidence level for the error bars + ax: axes to plot on or None if a new subplots should be created + title: string, title of the plot + xlabel: string, x label of the plot + ylabel: string, y label of the plot + Returns: + the axes created or used """ if ax is None: _, ax = plt.subplots() @@ -204,11 +206,11 @@ def plot_influence_distribution_by_label( influences: NDArray[np.float_], labels: NDArray[np.float_], title_extra: str = "" ): """Plots the histogram of the influence that all samples in the training set - have over a single sample index, separated by labels. + have over a single sample index, separated by labels. - :param influences: array of influences (training samples x test samples) - :param labels: labels for the training set. - :param title_extra: + influences: array of influences (training samples x test samples) + labels: labels for the training set. + title_extra: """ _, ax = plt.subplots() unique_labels = np.unique(labels) diff --git a/src/pydvl/reporting/scores.py b/src/pydvl/reporting/scores.py index 6e562b730..df617c847 100644 --- a/src/pydvl/reporting/scores.py +++ b/src/pydvl/reporting/scores.py @@ -20,12 +20,13 @@ def compute_removal_score( r"""Fits model and computes score on the test set after incrementally removing a percentage of data points from the training set, based on their values. - :param u: Utility object with model, data, and scoring function. - :param values: Data values of data instances in the training set. - :param percentages: Sequence of removal percentages. - :param remove_best: If True, removes data points in order of decreasing valuation. - :param progress: If True, display a progress bar. - :return: Dictionary that maps the percentages to their respective scores. + u: Utility object with model, data, and scoring function. + values: Data values of data instances in the training set. + percentages: Sequence of removal percentages. + remove_best: If True, removes data points in order of decreasing valuation. + progress: If True, display a progress bar. + Returns: + Dictionary that maps the percentages to their respective scores. """ # Sanity checks if np.any([x >= 1.0 or x < 0.0 for x in percentages]): diff --git a/src/pydvl/utils/caching.py b/src/pydvl/utils/caching.py index 94b60d9a4..248dcbb78 100644 --- a/src/pydvl/utils/caching.py +++ b/src/pydvl/utils/caching.py @@ -5,7 +5,7 @@ evaluations across processes and nodes in a cluster. You can run memcached as a service, locally or remotely, see :ref:`caching setup`. -.. warning:: +!!! Warning Function evaluations are cached with a key based on the function's signature and code. This can lead to undesired cache hits, see :ref:`cache reuse`. @@ -48,7 +48,7 @@ memoization. This behaviour can be activated with -:attr:`~pydvl.utils.config.MemcachedConfig.allow_repeated_evaluations`. +[allow_repeated_evaluations][pydvl.utils.config.MemcachedConfig.allow_repeated_evaluations]. .. _cache reuse: @@ -84,7 +84,7 @@ run across multiple processes and some reporting arguments are added (like a `job_id` for logging purposes), these will be part of the signature and make the functions distinct to the eyes of the cache. This can be avoided with the use of -:attr:`~pydvl.utils.config.MemcachedConfig.ignore_args` in the configuration. +[ignore_args][pydvl.utils.config.MemcachedConfig.ignore_args] in the configuration. """ @@ -157,7 +157,7 @@ def memcached( until the value has stabilized with a standard error smaller than `rtol_stderr * running average`. - .. warning:: + !!! Warning Do not cache functions with state! See :ref:`cache reuse` @@ -166,28 +166,29 @@ def memcached( cached_fun = memcached(**asdict(cache_options))(heavy_computation) - :param client_config: configuration for `pymemcache's Client() + client_config: configuration for `pymemcache's Client() `_. Will be merged on top of the default configuration (see below). - :param time_threshold: computations taking less time than this many seconds + time_threshold: computations taking less time than this many seconds are not cached. - :param allow_repeated_evaluations: If `True`, repeated calls to a function + allow_repeated_evaluations: If `True`, repeated calls to a function with the same arguments will be allowed and outputs averaged until the running standard deviation of the mean stabilises below `rtol_stderr * mean`. - :param rtol_stderr: relative tolerance for repeated evaluations. More + rtol_stderr: relative tolerance for repeated evaluations. More precisely, :func:`memcached` will stop evaluating the function once the standard deviation of the mean is smaller than `rtol_stderr * mean`. - :param min_repetitions: minimum number of times that a function evaluation + min_repetitions: minimum number of times that a function evaluation on the same arguments is repeated before returning cached values. Useful for stochastic functions only. If the model training is very noisy, set this number to higher values to reduce variance. - :param ignore_args: Do not take these keyword arguments into account when + ignore_args: Do not take these keyword arguments into account when hashing the wrapped function for usage as key in memcached. This allows sharing the cache among different jobs for the same experiment run if the callable happens to have "nuisance" parameters like "job_id" which do not affect the result of the computation. - :return: A wrapped function + Returns: + A wrapped function """ if ignore_args is None: diff --git a/src/pydvl/utils/config.py b/src/pydvl/utils/config.py index 89ddd023f..39a070cc7 100644 --- a/src/pydvl/utils/config.py +++ b/src/pydvl/utils/config.py @@ -13,12 +13,12 @@ class ParallelConfig: """Configuration for parallel computation backend. - :param backend: Type of backend to use. - Defaults to 'ray' - :param address: Address of existing remote or local cluster to use. - :param n_cpus_local: Number of CPUs to use when creating a local ray cluster. - This has no effect when using an existing ray cluster. - :param logging_level: Logging level for the parallel backend's worker. + backend: Type of backend to use. + Defaults to 'ray' + address: Address of existing remote or local cluster to use. + n_cpus_local: Number of CPUs to use when creating a local ray cluster. + This has no effect when using an existing ray cluster. + logging_level: Logging level for the parallel backend's worker. """ backend: Literal["sequential", "ray"] = "ray" @@ -35,18 +35,18 @@ def __post_init__(self) -> None: class MemcachedClientConfig: """Configuration of the memcached client. - :param server: A tuple of (IP|domain name, port). - :param connect_timeout: How many seconds to wait before raising - `ConnectionRefusedError` on failure to connect. - :param timeout: seconds to wait for send or recv calls on the socket - connected to memcached. - :param no_delay: set the `TCP_NODELAY` flag, which may help with performance - in some cases. - :param serde: a serializer / deserializer ("serde"). The default - `PickleSerde` should work in most cases. See `pymemcached's - documentation - `_ - for details. + server: A tuple of (IP|domain name, port). + connect_timeout: How many seconds to wait before raising + `ConnectionRefusedError` on failure to connect. + timeout: seconds to wait for send or recv calls on the socket + connected to memcached. + no_delay: set the `TCP_NODELAY` flag, which may help with performance + in some cases. + serde: a serializer / deserializer ("serde"). The default + `PickleSerde` should work in most cases. See `pymemcached's + documentation + `_ + for details. """ server: Tuple[str, int] = ("localhost", 11211) @@ -58,29 +58,29 @@ class MemcachedClientConfig: @dataclass class MemcachedConfig: - """Configuration for :func:`~pydvl.utils.caching.memcached`, providing + """Configuration for [memcached()][pydvl.utils.caching.memcached], providing memoization of function calls. Instances of this class are typically used as arguments for the construction of a :class:`~pydvl.utils.utility.Utility`. - :param client_config: Configuration for the connection to the memcached + client_config: Configuration for the connection to the memcached server. - :param time_threshold: computations taking less time than this many seconds + time_threshold: computations taking less time than this many seconds are not cached. - :param allow_repeated_evaluations: If `True`, repeated calls to a function + allow_repeated_evaluations: If `True`, repeated calls to a function with the same arguments will be allowed and outputs averaged until the running standard deviation of the mean stabilises below `rtol_stderr * mean`. - :param rtol_stderr: relative tolerance for repeated evaluations. More - precisely, :func:`~pydvl.utils.caching.memcached` will stop evaluating + rtol_stderr: relative tolerance for repeated evaluations. More + precisely, [memcached()][pydvl.utils.caching.memcached] will stop evaluating the function once the standard deviation of the mean is smaller than `rtol_stderr * mean`. - :param min_repetitions: minimum number of times that a function evaluation + min_repetitions: minimum number of times that a function evaluation on the same arguments is repeated before returning cached values. Useful for stochastic functions only. If the model training is very noisy, set this number to higher values to reduce variance. - :param ignore_args: Do not take these keyword arguments into account when + ignore_args: Do not take these keyword arguments into account when hashing the wrapped function for usage as key in memcached. """ diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index d3c6eadf7..2246df0ac 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -5,7 +5,7 @@ (the *utility*). This is typically the performance of the model on a test set (as an approximation to its true expected performance). It is therefore convenient to keep both the training data and the test data together to be passed around to -methods in :mod:`~pydvl.value.shapley` and :mod:`~pydvl.value.least_core`. +methods in [least_core][pydvl.value.shapley` and :mod:`~pydvl.value.least_core]. This is done with :class:`~pydvl.utils.dataset.Dataset`. This abstraction layer also seamlessly grouping data points together if one is @@ -57,19 +57,19 @@ def __init__( ): """Constructs a Dataset from data and labels. - :param x_train: training data - :param y_train: labels for training data - :param x_test: test data - :param y_test: labels for test data - :param feature_names: name of the features of input data - :param target_names: names of the features of target data - :param data_names: names assigned to data points. - For example, if the dataset is a time series, each entry can be a - timestamp which can be referenced directly instead of using a row - number. - :param description: A textual description of the dataset. - :param is_multi_output: set to ``False`` if labels are scalars, or to - ``True`` if they are vectors of dimension > 1. + x_train: training data + y_train: labels for training data + x_test: test data + y_test: labels for test data + feature_names: name of the features of input data + target_names: names of the features of target data + data_names: names assigned to data points. + For example, if the dataset is a time series, each entry can be a + timestamp which can be referenced directly instead of using a row + number. + description: A textual description of the dataset. + is_multi_output: set to ``False`` if labels are scalars, or to + ``True`` if they are vectors of dimension > 1. """ self.x_train, self.y_train = check_X_y( x_train, y_train, multi_output=is_multi_output @@ -149,10 +149,11 @@ def get_training_data( subsets of the data from indices. It is typically **not needed in algorithms**. - :param indices: Optional indices that will be used to select points + indices: Optional indices that will be used to select points from the training data. If ``None``, the entire training data will be returned. - :return: If ``indices`` is not ``None``, the selected x and y arrays + Returns: + If ``indices`` is not ``None``, the selected x and y arrays from the training data. Otherwise, the entire dataset. """ if indices is None: @@ -202,10 +203,11 @@ class and to override the :meth:`~Dataset.get_test_data` method. >>> _ = dataset.get_test_data(indices) - :param indices: Optional indices into the test data. This argument + indices: Optional indices into the test data. This argument is unused and is left as is to keep the same interface as :meth:`Dataset.get_training_data`. - :return: The entire test data. + Returns: + The entire test data. """ return self.x_test, self.y_test @@ -256,25 +258,26 @@ def from_sklearn( `sklearn toy datasets `_. - :param data: sklearn dataset. The following attributes are supported + data: sklearn dataset. The following attributes are supported - ``data``: covariates [required] - ``target``: target variables (labels) [required] - ``feature_names``: the feature names - ``target_names``: the target names - ``DESCR``: a description - :param train_size: size of the training dataset. Used in + train_size: size of the training dataset. Used in `train_test_split` - :param random_state: seed for train / test split - :param stratify_by_target: If `True`, data is split in a stratified + random_state: seed for train / test split + stratify_by_target: If `True`, data is split in a stratified fashion, using the target variable as labels. Read more in `scikit-learn's user guide `. - :param kwargs: Additional keyword arguments to pass to the + kwargs: Additional keyword arguments to pass to the :class:`Dataset` constructor. Use this to pass e.g. ``is_multi_output``. - :return: Object with the sklearn dataset + Returns: + Object with the sklearn dataset - .. versionchanged:: 0.6.0 + !!! version-changed 0.6.0 Added kwargs to pass to the :class:`Dataset` constructor. """ x_train, x_test, y_train, y_test = train_test_split( @@ -309,25 +312,26 @@ def from_arrays( returned by the `make_*` functions in `sklearn generated datasets `_. - :param X: numpy array of shape (n_samples, n_features) - :param y: numpy array of shape (n_samples,) - :param train_size: size of the training dataset. Used in + X: numpy array of shape (n_samples, n_features) + y: numpy array of shape (n_samples,) + train_size: size of the training dataset. Used in `train_test_split` - :param random_state: seed for train / test split - :param stratify_by_target: If `True`, data is split in a stratified + random_state: seed for train / test split + stratify_by_target: If `True`, data is split in a stratified fashion, using the y variable as labels. Read more in `sklearn's user guide `. - :param kwargs: Additional keyword arguments to pass to the + kwargs: Additional keyword arguments to pass to the :class:`Dataset` constructor. Use this to pass e.g. ``feature_names`` or ``target_names``. - :return: Object with the passed X and y arrays split across training + Returns: + Object with the passed X and y arrays split across training and test sets. - .. versionadded:: 0.4.0 + !!! version-added 0.4.0 - .. versionchanged:: 0.6.0 + !!! version-changed 0.6.0 Added kwargs to pass to the :class:`Dataset` constructor. """ x_train, x_test, y_train, y_test = train_test_split( @@ -360,24 +364,24 @@ def __init__( as logical units. For instance, one can group by value of a categorical feature, by bin into which a continuous feature falls, or by label. - :param x_train: training data - :param y_train: labels of training data - :param x_test: test data - :param y_test: labels of test data - :param data_groups: Iterable of the same length as ``x_train`` containing + x_train: training data + y_train: labels of training data + x_test: test data + y_test: labels of test data + data_groups: Iterable of the same length as ``x_train`` containing a group label for each training data point. The label can be of any type, e.g. ``str`` or ``int``. Data points with the same label will then be grouped by this object and considered as one for effects of valuation. - :param feature_names: names of the covariates' features. - :param target_names: names of the labels or targets y - :param group_names: names of the groups. If not provided, the labels + feature_names: names of the covariates' features. + target_names: names of the labels or targets y + group_names: names of the groups. If not provided, the labels from ``data_groups`` will be used. - :param description: A textual description of the dataset - :param kwargs: Additional keyword arguments to pass to the + description: A textual description of the dataset + kwargs: Additional keyword arguments to pass to the :class:`Dataset` constructor. - .. versionchanged:: 0.6.0 + !!! version-changed 0.6.0 Added ``group_names`` and forwarding of ``kwargs`` """ super().__init__( @@ -428,9 +432,10 @@ def get_training_data( ) -> Tuple[NDArray, NDArray]: """Returns the data and labels of all samples in the given groups. - :param indices: group indices whose elements to return. If ``None``, + indices: group indices whose elements to return. If ``None``, all data from all groups are returned. - :return: Tuple of training data x and labels y. + Returns: + Tuple of training data x and labels y. """ if indices is None: indices = self.indices @@ -454,26 +459,27 @@ def from_sklearn( `_ and groups it. - :param data: sklearn dataset. The following attributes are supported + data: sklearn dataset. The following attributes are supported - ``data``: covariates [required] - ``target``: target variables (labels) [required] - ``feature_names``: the feature names - ``target_names``: the target names - ``DESCR``: a description - :param train_size: size of the training dataset. Used in + train_size: size of the training dataset. Used in `train_test_split`. - :param random_state: seed for train / test split. - :param stratify_by_target: If ``True``, data is split in a stratified + random_state: seed for train / test split. + stratify_by_target: If ``True``, data is split in a stratified fashion, using the target variable as labels. Read more in `sklearn's user guide `. - :param data_groups: an array holding the group index or name for each + data_groups: an array holding the group index or name for each data point. The length of this array must be equal to the number of data points in the dataset. - :param kwargs: Additional keyword arguments to pass to the + kwargs: Additional keyword arguments to pass to the :class:`Dataset` constructor. - :return: Dataset with the selected sklearn data + Returns: + Dataset with the selected sklearn data """ if data_groups is None: raise ValueError( @@ -509,28 +515,29 @@ def from_arrays( as returned by the `make_*` functions in `sklearn generated datasets `_. - :param X: array of shape (n_samples, n_features) - :param y: array of shape (n_samples,) - :param train_size: size of the training dataset. Used in + X: array of shape (n_samples, n_features) + y: array of shape (n_samples,) + train_size: size of the training dataset. Used in ``train_test_split``. - :param random_state: seed for train / test split. - :param stratify_by_target: If ``True``, data is split in a stratified + random_state: seed for train / test split. + stratify_by_target: If ``True``, data is split in a stratified fashion, using the y variable as labels. Read more in `sklearn's user guide `. - :param data_groups: an array holding the group index or name for each + data_groups: an array holding the group index or name for each data point. The length of this array must be equal to the number of data points in the dataset. - :param kwargs: Additional keyword arguments that will be passed + kwargs: Additional keyword arguments that will be passed to the :class:`~pydvl.utils.dataset.Dataset` constructor. - :return: Dataset with the passed X and y arrays split across training + Returns: + Dataset with the passed X and y arrays split across training and test sets. - .. versionadded:: 0.4.0 + !!! version-added 0.4.0 - .. versionchanged:: 0.6.0 + !!! version-changed 0.6.0 Added kwargs to pass to the :class:`Dataset` constructor. """ if data_groups is None: @@ -557,11 +564,12 @@ def from_dataset( """Creates a :class:`GroupedDataset` object from the data a :class:`Dataset` object and a mapping of data groups. - :param dataset: The original data. - :param data_groups: An array holding the group index or name for each + dataset: The original data. + data_groups: An array holding the group index or name for each data point. The length of this array must be equal to the number of data points in the dataset. - :return: A :class:`GroupedDataset` with the initial :class:`Dataset` + Returns: + A :class:`GroupedDataset` with the initial :class:`Dataset` grouped by data_groups. """ return cls( @@ -590,12 +598,13 @@ def load_spotify_dataset( If this method is called within the CI pipeline, it will load a reduced version of the dataset for testing purposes. - :param val_size: size of the validation set - :param test_size: size of the test set - :param min_year: minimum year of the returned data - :param target_column: column to be returned as y (labels) - :param random_state: fixes sklearn random seed - :return: Tuple with 3 elements, each being a list sith [input_data, related_labels] + val_size: size of the validation set + test_size: size of the test set + min_year: minimum year of the returned data + target_column: column to be returned as y (labels) + random_state: fixes sklearn random seed + Returns: + Tuple with 3 elements, each being a list sith [input_data, related_labels] """ root_dir_path = Path(__file__).parent.parent.parent.parent file_path = root_dir_path / "data/top_hits_spotify_dataset.csv" @@ -625,10 +634,11 @@ def load_wine_dataset( """Loads the sklearn wine dataset. More info can be found at https://scikit-learn.org/stable/datasets/toy_dataset.html#wine-recognition-dataset. - :param train_size: fraction of points used for training dataset - :param test_size: fraction of points used for test dataset - :param random_state: fix random seed. If None, no random seed is set. - :return: A tuple of four elements with the first three being input and + train_size: fraction of points used for training dataset + test_size: fraction of points used for test dataset + random_state: fix random seed. If None, no random seed is set. + Returns: + A tuple of four elements with the first three being input and target values in the form of matrices of shape (N,D) the first and (N,) the second. The fourth element is a list containing names of features of the model. (FIXME doc) @@ -682,13 +692,14 @@ def synthetic_classification_dataset( ) -> Tuple[Tuple[Any, Any], Tuple[Any, Any], Tuple[Any, Any]]: """Sample from a uniform Gaussian mixture model. - :param mus: 2d-matrix [CxD] with the means of the components in the rows. - :param sigma: Standard deviation of each dimension of each component. - :param num_samples: The number of samples to generate. - :param train_size: fraction of points used for training dataset - :param test_size: fraction of points used for test dataset - :param random_seed: fix random seed. If None, no random seed is set. - :returns: A tuple of matrix x of shape [NxD] and target vector y of shape [N]. + mus: 2d-matrix [CxD] with the means of the components in the rows. + sigma: Standard deviation of each dimension of each component. + num_samples: The number of samples to generate. + train_size: fraction of points used for training dataset + test_size: fraction of points used for test dataset + random_seed: fix random seed. If None, no random seed is set. + Returns: + A tuple of matrix x of shape [NxD] and target vector y of shape [N]. """ num_features = mus.shape[1] num_classes = mus.shape[0] @@ -717,9 +728,10 @@ def decision_boundary_fixed_variance_2d( ) -> Callable[[np.ndarray], np.ndarray]: """ Closed-form solution for decision boundary dot(a, b) + b = 0 with fixed variance. - :param mu_1: First mean. - :param mu_2: Second mean. - :returns: A callable which converts a continuous line (-infty, infty) to the decision boundary in feature space. + mu_1: First mean. + mu_2: Second mean. + Returns: + A callable which converts a continuous line (-infty, infty) to the decision boundary in feature space. """ a = np.asarray([[0, 1], [-1, 0]]) @ (mu_2 - mu_1) b = (mu_1 + mu_2) / 2 diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index fbe8aabab..cd619bf7e 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -38,8 +38,9 @@ def powerset(s: NDArray[T]) -> Iterator[Collection[T]]: >>> list(powerset(np.array((1,2)))) [(), (1,), (2,), (1, 2)] - :param s: The set to use - :return: An iterator + s: The set to use + Returns: + An iterator :raises TypeError: If the argument is not an ``Iterable``. """ return chain.from_iterable(combinations(s, r) for r in range(len(s) + 1)) @@ -53,10 +54,11 @@ def num_samples_permutation_hoeffding(eps: float, delta: float, u_range: float) be ε-close to the true quantity, if at least this many permutations are sampled. - :param eps: ε > 0 - :param delta: 0 < δ <= 1 - :param u_range: Range of the :class:`~pydvl.utils.utility.Utility` function - :return: Number of _permutations_ required to guarantee ε-correct Shapley + eps: ε > 0 + delta: 0 < δ <= 1 + u_range: Range of the :class:`~pydvl.utils.utility.Utility` function + Returns: + Number of _permutations_ required to guarantee ε-correct Shapley values with probability 1-δ """ return int(np.ceil(np.log(2 / delta) * 2 * u_range**2 / eps**2)) @@ -65,10 +67,11 @@ def num_samples_permutation_hoeffding(eps: float, delta: float, u_range: float) def random_subset(s: NDArray[T], q: float = 0.5) -> NDArray[T]: """Returns one subset at random from ``s``. - :param s: set to sample from - :param q: Sampling probability for elements. The default 0.5 yields a + s: set to sample from + q: Sampling probability for elements. The default 0.5 yields a uniform distribution over the power set of s. - :return: the subset + Returns: + the subset """ rng = np.random.default_rng() selection = rng.uniform(size=len(s)) > q @@ -89,13 +92,14 @@ def random_powerset( :func:`Owen sampling `. - :param s: set to sample from - :param n_samples: if set, stop the generator after this many steps. + s: set to sample from + n_samples: if set, stop the generator after this many steps. Defaults to `np.iinfo(np.int32).max` - :param q: Sampling probability for elements. The default 0.5 yields a + q: Sampling probability for elements. The default 0.5 yields a uniform distribution over the power set of s. - :return: Samples from the power set of s + Returns: + Samples from the power set of s :raises: TypeError: if the data `s` is not a NumPy array :raises: ValueError: if the element sampling probability is not in [0,1] @@ -117,9 +121,10 @@ def random_subset_of_size(s: NDArray[T], size: int) -> NDArray[T]: """Samples a random subset of given size uniformly from the powerset of ``s``. - :param s: Set to sample from - :param size: Size of the subset to generate - :return: The subset + s: Set to sample from + size: Size of the subset to generate + Returns: + The subset :raises ValueError: If size > len(s) """ if size > len(s): @@ -137,9 +142,10 @@ def random_matrix_with_condition_number(n: int, condition_number: float) -> "NDA Also see: https://math.stackexchange.com/questions/1351616/condition-number-of-ata. - :param n: size of the matrix - :param condition_number: duh - :return: An (n,n) matrix with the requested condition number. + n: size of the matrix + condition_number: duh + Returns: + An (n,n) matrix with the requested condition number. """ if n < 2: raise ValueError("Matrix size must be at least 2") @@ -167,10 +173,11 @@ def linear_regression_analytical_derivative_d_theta( linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", y: "NDArray" ) -> "NDArray": """ - :param linear_model: A tuple of np.ndarray' of shape [NxM] and [N] representing A and b respectively. - :param x: A np.ndarray of shape [BxM]. - :param y: A np.nparray of shape [BxN]. - :returns: A np.ndarray of shape [Bx((N+1)*M)], where each row vector is [d_theta L(x, y), d_b L(x, y)] + linear_model: A tuple of np.ndarray' of shape [NxM] and [N] representing A and b respectively. + x: A np.ndarray of shape [BxM]. + y: A np.nparray of shape [BxN]. + Returns: + A np.ndarray of shape [Bx((N+1)*M)], where each row vector is [d_theta L(x, y), d_b L(x, y)] """ A, b = linear_model @@ -186,10 +193,11 @@ def linear_regression_analytical_derivative_d2_theta( linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", y: "NDArray" ) -> "NDArray": """ - :param linear_model: A tuple of np.ndarray' of shape [NxM] and [N] representing A and b respectively. - :param x: A np.ndarray of shape [BxM], - :param y: A np.nparray of shape [BxN]. - :returns: A np.ndarray of shape [((N+1)*M)x((N+1)*M)], representing the Hessian. It gets averaged over all samples. + linear_model: A tuple of np.ndarray' of shape [NxM] and [N] representing A and b respectively. + x: A np.ndarray of shape [BxM], + y: A np.nparray of shape [BxN]. + Returns: + A np.ndarray of shape [((N+1)*M)x((N+1)*M)], representing the Hessian. It gets averaged over all samples. """ A, b = linear_model n, m = tuple(A.shape) @@ -209,10 +217,11 @@ def linear_regression_analytical_derivative_d_x_d_theta( linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", y: "NDArray" ) -> "NDArray": """ - :param linear_model: A tuple of np.ndarray of shape [NxM] and [N] representing A and b respectively. - :param x: A np.ndarray of shape [BxM]. - :param y: A np.nparray of shape [BxN]. - :returns: A np.ndarray of shape [Bx((N+1)*M)xM], representing the derivative. + linear_model: A tuple of np.ndarray of shape [NxM] and [N] representing A and b respectively. + x: A np.ndarray of shape [BxM]. + y: A np.nparray of shape [BxN]. + Returns: + A np.ndarray of shape [Bx((N+1)*M)xM], representing the derivative. """ A, b = linear_model @@ -259,20 +268,21 @@ def running_moments( See `Welford's algorithm in wikipedia `_ - .. warning:: + !!! Warning This is not really using Welford's correction for numerical stability for the variance. (FIXME) - .. todo:: + !!! Todo This could be generalised to arbitrary moments. See `this paper `_ - :param previous_avg: average value at previous step - :param previous_variance: variance at previous step - :param count: number of points seen so far - :param new_value: new value in the series of numbers - :return: new_average, new_variance, calculated with the new count + previous_avg: average value at previous step + previous_variance: variance at previous step + count: number of points seen so far + new_value: new value in the series of numbers + Returns: + new_average, new_variance, calculated with the new count """ # broadcasted operations seem not to be supported by mypy, so we ignore the type new_average = (new_value + count * previous_avg) / (count + 1) # type: ignore @@ -288,10 +298,11 @@ def top_k_value_accuracy( """Computes the top-k accuracy for the estimated values by comparing indices of the highest k values. - :param y_true: Exact/true value - :param y_pred: Predicted/estimated value - :param k: Number of the highest values taken into account - :return: Accuracy + y_true: Exact/true value + y_pred: Predicted/estimated value + k: Number of the highest values taken into account + Returns: + Accuracy """ top_k_exact_values = np.argsort(y_true)[-k:] top_k_pred_values = np.argsort(y_pred)[-k:] diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index f9840d77d..3cf340a51 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -95,9 +95,9 @@ class SequentialParallelBackend(BaseParallelBackend, backend_name="sequential"): """Class used to run jobs sequentially and locally. It shouldn't be initialized directly. You should instead call - :func:`~pydvl.utils.parallel.backend.init_parallel_backend`. + [init_parallel_backend()][pydvl.utils.parallel.backend.init_parallel_backend]. - :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with number of cpus + config: instance of :class:`~pydvl.utils.config.ParallelConfig` with number of cpus """ def __init__(self, config: ParallelConfig): @@ -126,9 +126,9 @@ class RayParallelBackend(BaseParallelBackend, backend_name="ray"): """Class used to wrap ray to make it transparent to algorithms. It shouldn't be initialized directly. You should instead call - :func:`~pydvl.utils.parallel.backend.init_parallel_backend`. + [init_parallel_backend()][pydvl.utils.parallel.backend.init_parallel_backend]. - :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with + config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. """ @@ -165,10 +165,11 @@ def put(self, v: T, *args, **kwargs) -> Union["ObjectRef[T]", T]: def wrap(self, fun: Callable, **kwargs) -> Callable: """Wraps a function as a ray remote. - :param fun: the function to wrap - :param kwargs: keyword arguments to pass to @ray.remote + fun: the function to wrap + kwargs: keyword arguments to pass to @ray.remote - :return: The `.remote` method of the ray `RemoteFunction`. + Returns: + The `.remote` method of the ray `RemoteFunction`. """ if len(kwargs) > 0: return ray.remote(**kwargs)(fun).remote # type: ignore @@ -202,7 +203,7 @@ def init_parallel_backend( ) -> BaseParallelBackend: """Initializes the parallel backend and returns an instance of it. - :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` + config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. :Example: @@ -227,7 +228,8 @@ def available_cpus() -> int: """Platform-independent count of available cores. FIXME: do we really need this or is `os.cpu_count` enough? Is this portable? - :return: Number of cores, or 1 if it is not possible to determine. + Returns: + Number of cores, or 1 if it is not possible to determine. """ from platform import system @@ -242,11 +244,12 @@ def effective_n_jobs(n_jobs: int, config: ParallelConfig = ParallelConfig()) -> This number may vary depending on the parallel backend and the resources available. - :param n_jobs: the number of jobs requested. If -1, the number of available + n_jobs: the number of jobs requested. If -1, the number of available CPUs is returned. - :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with + config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. - :return: the effective number of jobs, guaranteed to be >= 1. + Returns: + the effective number of jobs, guaranteed to be >= 1. :raises RuntimeError: if the effective number of jobs returned by the backend is < 1. """ diff --git a/src/pydvl/utils/parallel/futures/__init__.py b/src/pydvl/utils/parallel/futures/__init__.py index 93b94fc27..7291eec29 100644 --- a/src/pydvl/utils/parallel/futures/__init__.py +++ b/src/pydvl/utils/parallel/futures/__init__.py @@ -16,9 +16,9 @@ def init_executor( ) -> Generator[Executor, None, None]: """Initializes a futures executor based on the passed parallel configuration object. - :param max_workers: Maximum number of concurrent tasks. - :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. - :param kwargs: Other optional parameter that will be passed to the executor. + max_workers: Maximum number of concurrent tasks. + config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. + kwargs: Other optional parameter that will be passed to the executor. :Example: diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 62ad8d26b..ca15c7d84 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -25,17 +25,17 @@ class RayExecutor(Executor): """Asynchronous executor using Ray that implements the concurrent.futures API. It shouldn't be initialized directly. You should instead call - :func:`~pydvl.utils.parallel.futures.init_executor`. + [init_executor()][pydvl.utils.parallel.futures.init_executor]. - :param max_workers: Maximum number of concurrent tasks. Each task can + max_workers: Maximum number of concurrent tasks. Each task can request itself any number of vCPUs. You must ensure the product of this value and the n_cpus_per_job parameter passed to submit() does not exceed available cluster resources. If set to None, it will default to the total number of vCPUs in the ray cluster. - :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` + config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. - :param cancel_futures_on_exit: If ``True``, all futures will be cancelled + cancel_futures_on_exit: If ``True``, all futures will be cancelled when exiting the context created by using this class instance as a context manager. It will be ignored when calling :meth:`shutdown` directly. @@ -92,12 +92,13 @@ def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": Schedules the callable to be executed as fn(\*args, \**kwargs) and returns a Future instance representing the execution of the callable. - :param fn: Callable. - :param args: Positional arguments that will be passed to ``fn``. - :param kwargs: Keyword arguments that will be passed to ``fn``. + fn: Callable. + args: Positional arguments that will be passed to ``fn``. + kwargs: Keyword arguments that will be passed to ``fn``. It can also optionally contain options for the ray remote function as a dictionary as the keyword argument `remote_function_options`. - :return: A Future representing the given call. + Returns: + A Future representing the given call. :raises RuntimeError: If a task is submitted after the executor has been shut down. """ with self._shutdown_lock: @@ -217,7 +218,7 @@ class _WorkItemManagerThread(threading.Thread): It runs in a local thread. - :param executor: An instance of RayExecutor that owns + executor: An instance of RayExecutor that owns this thread. A weakref will be owned by the manager as well as references to internal objects used to introspect the state of the executor. diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index c7fd3ff6a..2b686ffb4 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -82,21 +82,21 @@ class MapReduceJob(Generic[T, R]): Typing information for objects of this class requires the type of the inputs that are split for ``map_func`` and the type of its output. - :param inputs: The input that will be split and passed to `map_func`. + inputs: The input that will be split and passed to `map_func`. if it's not a sequence object. It will be repeat ``n_jobs`` number of times. - :param map_func: Function that will be applied to the input chunks in each job. - :param reduce_func: Function that will be applied to the results of + map_func: Function that will be applied to the input chunks in each job. + reduce_func: Function that will be applied to the results of ``map_func`` to reduce them. - :param map_kwargs: Keyword arguments that will be passed to ``map_func`` in + map_kwargs: Keyword arguments that will be passed to ``map_func`` in each job. Alternatively, one can use ``itertools.partial``. - :param reduce_kwargs: Keyword arguments that will be passed to ``reduce_func`` - in each job. Alternatively, one can use :func:`itertools.partial`. - :param config: Instance of :class:`~pydvl.utils.config.ParallelConfig` + reduce_kwargs: Keyword arguments that will be passed to ``reduce_func`` + in each job. Alternatively, one can use [itertools.partial][]. + config: Instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. - :param n_jobs: Number of parallel jobs to run. Does not accept 0 - :param timeout: Amount of time in seconds to wait for remote results before + n_jobs: Number of parallel jobs to run. Does not accept 0 + timeout: Amount of time in seconds to wait for remote results before ... TODO - :param max_parallel_tasks: Maximum number of jobs to start in parallel. Any + max_parallel_tasks: Maximum number of jobs to start in parallel. Any tasks above this number won't be submitted to the backend before some are done. This is to avoid swamping the work queue. Note that tasks have a low memory footprint, so this is probably not a big concern, except @@ -222,10 +222,11 @@ def _wrap_function(self, func: Callable, **kwargs) -> Callable: """Wraps a function with a timeout and remote arguments and puts it on the remote backend. - :param func: Function to wrap - :param kwargs: Additional keyword arguments to pass to the backend + func: Function to wrap + kwargs: Additional keyword arguments to pass to the backend wrapper. These are *not* arguments for the wrapped function. - :return: Remote function that can be called with the same arguments as + Returns: + Remote function that can be called with the same arguments as the wrapped function. Depending on the backend, this may simply be the function itself. """ @@ -237,14 +238,15 @@ def _backpressure( self, jobs: List[ObjectRef], n_dispatched: int, n_finished: int ) -> int: """This is used to limit the number of concurrent tasks. - If :attr:`~pydvl.utils.parallel.map_reduce.MapReduceJob.max_parallel_tasks` is None then this function + If [max_parallel_tasks][pydvl.utils.parallel.map_reduce.MapReduceJob.max_parallel_tasks] is None then this function is a no-op that simply returns 0. See https://docs.ray.io/en/latest/ray-core/patterns/limit-pending-tasks.html - :param jobs: - :param n_dispatched: - :param n_finished: - :return: + jobs: + n_dispatched: + n_finished: + Returns: + """ if self.max_parallel_tasks is None: return 0 diff --git a/src/pydvl/utils/progress.py b/src/pydvl/utils/progress.py index 17e925005..09dd301a3 100644 --- a/src/pydvl/utils/progress.py +++ b/src/pydvl/utils/progress.py @@ -57,9 +57,9 @@ def maybe_progress( """Returns either a tqdm progress bar or a mock object which wraps the iterator as well, but ignores any accesses to methods or properties. - :param it: the iterator to wrap - :param display: set to True to return a tqdm bar - :param kwargs: Keyword arguments that will be forwarded to tqdm + it: the iterator to wrap + display: set to True to return a tqdm bar + kwargs: Keyword arguments that will be forwarded to tqdm """ if isinstance(it, int): it = range(it) # type: ignore diff --git a/src/pydvl/utils/score.py b/src/pydvl/utils/score.py index 933706d98..561ac7fed 100644 --- a/src/pydvl/utils/score.py +++ b/src/pydvl/utils/score.py @@ -9,7 +9,7 @@ :class:`Scorer` provides additional information about the scoring function, like its range and default values, which can be used by some data valuation -methods (like :func:`~pydvl.value.shapley.gt.group_testing_shapley`) to estimate +methods (like [group_testing_shapley()][pydvl.value.shapley.gt.group_testing_shapley]) to estimate the number of samples required for a certain quality of approximation. """ from typing import Callable, Optional, Protocol, Tuple, Union @@ -35,20 +35,20 @@ class Scorer: """A scoring callable that takes a model, data, and labels and returns a scalar. - :param scoring: Either a string or callable that can be passed to + scoring: Either a string or callable that can be passed to `get_scorer `_. - :param default: score to be used when a model cannot be fit, e.g. when too + default: score to be used when a model cannot be fit, e.g. when too little data is passed, or errors arise. - :param range: numerical range of the score function. Some Monte Carlo + range: numerical range of the score function. Some Monte Carlo methods can use this to estimate the number of samples required for a certain quality of approximation. If not provided, it can be read from the ``scoring`` object if it provides it, for instance if it was - constructed with :func:`~pydvl.utils.types.compose_score`. - :param name: The name of the scorer. If not provided, the name of the + constructed with [compose_score()][pydvl.utils.types.compose_score]. + name: The name of the scorer. If not provided, the name of the function passed will be used. - .. versionadded:: 0.5.0 + !!! version-added 0.5.0 """ @@ -98,12 +98,13 @@ def compose_score( sigmoid = lambda x: 1/(1+np.exp(-x)) compose_score(Scorer("r2"), sigmoid, range=(0,1), name="squashed r2") - :param scorer: The object to be composed. - :param transformation: A scalar transformation - :param range: The range of the transformation. This will be used e.g. by + scorer: The object to be composed. + transformation: A scalar transformation + range: The range of the transformation. This will be used e.g. by :class:`~pydvl.utils.utility.Utility` for the range of the composed. - :param name: A string representation for the composition, for `str()`. - :return: The composite :class:`Scorer`. + name: A string representation for the composition, for `str()`. + Returns: + The composite :class:`Scorer`. """ class CompositeScorer(Scorer): diff --git a/src/pydvl/utils/status.py b/src/pydvl/utils/status.py index 52b0df1b0..fa794f844 100644 --- a/src/pydvl/utils/status.py +++ b/src/pydvl/utils/status.py @@ -60,7 +60,7 @@ class Status(Enum): bool(Status.Converged) == True bool(Status.Failed) == True - .. warning:: + !!! Warning These truth values are **inconsistent** with the usual boolean operations. In particular the XOR of two instances of ``Status`` is not the same as the XOR of their boolean values. diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index 05f9f724e..c93600623 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -35,10 +35,11 @@ def maybe_add_argument(fun: Callable, new_arg: str): returned as is. Otherwise, a wrapper is returned which merely ignores the argument. - :param fun: The function to wrap - :param new_arg: The name of the argument that the new function will accept + fun: The function to wrap + new_arg: The name of the argument that the new function will accept (and ignore). - :return: A new function accepting one more keyword argument. + Returns: + A new function accepting one more keyword argument. """ params = inspect.signature(fun).parameters if new_arg in params.keys(): diff --git a/src/pydvl/utils/utility.py b/src/pydvl/utils/utility.py index b16cdd0a8..97a0b4dbb 100644 --- a/src/pydvl/utils/utility.py +++ b/src/pydvl/utils/utility.py @@ -330,8 +330,8 @@ class MinerGameUtility(Utility): Consider a group of n miners, who have discovered large bars of gold. - If two miners can carry one piece of gold, - then the payoff of a coalition $S$ is: + If two miners can carry one piece of gold, then the payoff of a + coalition $S$ is: $${ v(S) = \left\{\begin{array}{lll} diff --git a/src/pydvl/value/__init__.py b/src/pydvl/value/__init__.py index 5fb7a82ad..27b17f161 100644 --- a/src/pydvl/value/__init__.py +++ b/src/pydvl/value/__init__.py @@ -1,7 +1,7 @@ r""" Algorithms for the exact and approximate computation of value and semi-value. -See :ref:`data valuation` for an introduction to the concepts and methods +See [Data valuation][computing-data-values] for an introduction to the concepts and methods implemented here. """ diff --git a/src/pydvl/value/least_core/__init__.py b/src/pydvl/value/least_core/__init__.py index 319b074a3..504411a58 100644 --- a/src/pydvl/value/least_core/__init__.py +++ b/src/pydvl/value/least_core/__init__.py @@ -1,21 +1,21 @@ """ -.. versionadded:: 0.4.0 +!!! version-added 0.4.0 This package holds all routines for the computation of Least Core data values. -Please refer to :ref:`data valuation` for an overview. +Please refer to [Data valuation][computing-data-values] for an overview. In addition to the standard interface via -:func:`~pydvl.value.least_core.compute_least_core_values`, because computing the +[compute_least_core_values()][pydvl.value.least_core.compute_least_core_values], because computing the Least Core values requires the solution of a linear and a quadratic problem *after* computing all the utility values, there is the possibility of performing each step separately. This is useful when running multiple experiments: use -:func:`~pydvl.value.least_core.naive.lc_prepare_problem` or -:func:`~pydvl.value.least_core.montecarlo.mclc_prepare_problem` to prepare a +[lc_prepare_problem()][pydvl.value.least_core.naive.lc_prepare_problem] or +[mclc_prepare_problem()][pydvl.value.least_core.montecarlo.mclc_prepare_problem] to prepare a list of problems to solve, then solve them in parallel with -:func:`~pydvl.value.least_core.common.lc_solve_problems`. +[lc_solve_problems()][pydvl.value.least_core.common.lc_solve_problems]. -Note that :func:`~pydvl.value.least_core.montecarlo.mclc_prepare_problem` is +Note that [mclc_prepare_problem()][pydvl.value.least_core.montecarlo.mclc_prepare_problem] is parallelized itself, so preparing the problems should be done in sequence in this case. The solution of the linear systems can then be done in parallel. @@ -52,30 +52,31 @@ def compute_least_core_values( """Umbrella method to compute Least Core values with any of the available algorithms. - See :ref:`data valuation` for an overview. + See [Data valuation][computing-data-values] for an overview. The following algorithms are available. Note that the exact method can only work with very small datasets and is thus intended only for testing. - ``exact``: uses the complete powerset of the training set for the constraints - :func:`~pydvl.value.shapley.naive.combinatorial_exact_shapley`. + [combinatorial_exact_shapley()][pydvl.value.shapley.naive.combinatorial_exact_shapley]. - ``montecarlo``: uses the approximate Monte Carlo Least Core algorithm. - Implemented in :func:`~pydvl.value.least_core.montecarlo.montecarlo_least_core`. + Implemented in [montecarlo_least_core()][pydvl.value.least_core.montecarlo.montecarlo_least_core]. - :param u: Utility object with model, data, and scoring function - :param n_jobs: Number of jobs to run in parallel. Only used for Monte Carlo + u: Utility object with model, data, and scoring function + n_jobs: Number of jobs to run in parallel. Only used for Monte Carlo Least Core. - :param n_iterations: Number of subsets to sample and evaluate the utility on. + n_iterations: Number of subsets to sample and evaluate the utility on. Only used for Monte Carlo Least Core. - :param mode: Algorithm to use. See :class:`LeastCoreMode` for available + mode: Algorithm to use. See :class:`LeastCoreMode` for available options. - :param non_negative_subsidy: If True, the least core subsidy $e$ is constrained + non_negative_subsidy: If True, the least core subsidy $e$ is constrained to be non-negative. - :param solver_options: Optional dictionary of options passed to the solvers. + solver_options: Optional dictionary of options passed to the solvers. - :return: ValuationResult object with the computed values. + Returns: + ValuationResult object with the computed values. - .. versionadded:: 0.5.0 + !!! version-added 0.5.0 """ progress: bool = kwargs.pop("progress", False) diff --git a/src/pydvl/value/least_core/common.py b/src/pydvl/value/least_core/common.py index 74d2922d4..cf82ffe72 100644 --- a/src/pydvl/value/least_core/common.py +++ b/src/pydvl/value/least_core/common.py @@ -39,8 +39,8 @@ def lc_solve_problem( Useful for parallel execution of multiple experiments by running this as a remote task. - See :func:`~pydvl.value.least_core.naive.exact_least_core` or - :func:`~pydvl.value.least_core.montecarlo.montecarlo_least_core` for + See [exact_least_core()][pydvl.value.least_core.naive.exact_least_core] or + [montecarlo_least_core()][pydvl.value.least_core.montecarlo.montecarlo_least_core] for argument descriptions. """ n = len(u.data) @@ -169,17 +169,18 @@ def lc_solve_problems( ) -> List[ValuationResult]: """Solves a list of linear problems in parallel. - :param u: Utility. - :param problems: Least Core problems to solve, as returned by - :func:`~pydvl.value.least_core.montecarlo.mclc_prepare_problem`. - :param algorithm: Name of the valuation algorithm. - :param config: Object configuring parallel computation, with cluster + u: Utility. + problems: Least Core problems to solve, as returned by + [mclc_prepare_problem()][pydvl.value.least_core.montecarlo.mclc_prepare_problem]. + algorithm: Name of the valuation algorithm. + config: Object configuring parallel computation, with cluster address, number of cpus, etc. - :param n_jobs: Number of parallel jobs to run. - :param non_negative_subsidy: If True, the least core subsidy $e$ is constrained + n_jobs: Number of parallel jobs to run. + non_negative_subsidy: If True, the least core subsidy $e$ is constrained to be non-negative. - :param solver_options: Additional options to pass to the solver. - :return: List of solutions. + solver_options: Additional options to pass to the solver. + Returns: + List of solutions. """ def _map_func( @@ -232,17 +233,17 @@ def _solve_least_core_linear_program( if `non_negative_subsidy` is True, then an additional constraint $e \ge 0$ is used. - :param A_eq: The equality constraint matrix. Each row of ``A_eq`` specifies the + A_eq: The equality constraint matrix. Each row of ``A_eq`` specifies the coefficients of a linear equality constraint on ``x``. - :param b_eq: The equality constraint vector. Each element of ``A_eq @ x`` must equal + b_eq: The equality constraint vector. Each element of ``A_eq @ x`` must equal the corresponding element of ``b_eq``. - :param A_lb: The inequality constraint matrix. Each row of ``A_lb`` specifies the + A_lb: The inequality constraint matrix. Each row of ``A_lb`` specifies the coefficients of a linear inequality constraint on ``x``. - :param b_lb: The inequality constraint vector. Each element represents a + b_lb: The inequality constraint vector. Each element represents a lower bound on the corresponding value of ``A_lb @ x``. - :param non_negative_subsidy: If True, the least core subsidy $e$ is constrained + non_negative_subsidy: If True, the least core subsidy $e$ is constrained to be non-negative. - :param options: Keyword arguments that will be used to select a solver + options: Keyword arguments that will be used to select a solver and to configure it. For all possible options, refer to `cvxpy's documentation `_ """ @@ -308,16 +309,16 @@ def _solve_egalitarian_least_core_quadratic_program( :math:`b_{ub}`, :math:`b_{eq}`, :math:`l`, and :math:`u` are vectors; and :math:`A_{ub}` and :math:`A_{eq}` are matrices. - :param subsidy: Minimal subsidy returned by :func:`_solve_least_core_linear_program` - :param A_eq: The equality constraint matrix. Each row of ``A_eq`` specifies the + subsidy: Minimal subsidy returned by :func:`_solve_least_core_linear_program` + A_eq: The equality constraint matrix. Each row of ``A_eq`` specifies the coefficients of a linear equality constraint on ``x``. - :param b_eq: The equality constraint vector. Each element of ``A_eq @ x`` must equal + b_eq: The equality constraint vector. Each element of ``A_eq @ x`` must equal the corresponding element of ``b_eq``. - :param A_lb: The inequality constraint matrix. Each row of ``A_lb`` specifies the + A_lb: The inequality constraint matrix. Each row of ``A_lb`` specifies the coefficients of a linear inequality constraint on ``x``. - :param b_lb: The inequality constraint vector. Each element represents a + b_lb: The inequality constraint vector. Each element represents a lower bound on the corresponding value of ``A_lb @ x``. - :param solver_options: Keyword arguments that will be used to select a solver + solver_options: Keyword arguments that will be used to select a solver and to configure it. Refer to the following page for all possible options: https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options """ diff --git a/src/pydvl/value/least_core/montecarlo.py b/src/pydvl/value/least_core/montecarlo.py index ddb9f2347..1bc1eeb29 100644 --- a/src/pydvl/value/least_core/montecarlo.py +++ b/src/pydvl/value/least_core/montecarlo.py @@ -47,19 +47,20 @@ def montecarlo_least_core( * $m$ is the number of subsets that will be sampled and whose utility will be computed and used to compute the data values. - :param u: Utility object with model, data, and scoring function - :param n_iterations: total number of iterations to use - :param n_jobs: number of jobs across which to distribute the computation - :param config: Object configuring parallel computation, with cluster + u: Utility object with model, data, and scoring function + n_iterations: total number of iterations to use + n_jobs: number of jobs across which to distribute the computation + config: Object configuring parallel computation, with cluster address, number of cpus, etc. - :param non_negative_subsidy: If True, the least core subsidy $e$ is constrained + non_negative_subsidy: If True, the least core subsidy $e$ is constrained to be non-negative. - :param solver_options: Dictionary of options that will be used to select a solver + solver_options: Dictionary of options that will be used to select a solver and to configure it. Refer to the following page for all possible options: https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options - :param options: (Deprecated) Dictionary of solver options. Use solver_options instead. - :param progress: If True, shows a tqdm progress bar - :return: Object with the data values and the least core value. + options: (Deprecated) Dictionary of solver options. Use solver_options instead. + progress: If True, shows a tqdm progress bar + Returns: + Object with the data values and the least core value. """ # TODO: remove this before releasing version 0.7.0 if options: @@ -97,7 +98,7 @@ def mclc_prepare_problem( ) -> LeastCoreProblem: """Prepares a linear problem by sampling subsets of the data. Use this to separate the problem preparation from the solving with - :func:`~pydvl.value.least_core.common.lc_solve_problem`. Useful for + [lc_solve_problem()][pydvl.value.least_core.common.lc_solve_problem]. Useful for parallel execution of multiple experiments. See :func:`montecarlo_least_core` for argument descriptions. @@ -138,11 +139,12 @@ def _montecarlo_least_core( ) -> LeastCoreProblem: """Computes utility values and the Least Core upper bound matrix for a given number of iterations. - :param u: Utility object with model, data, and scoring function - :param n_iterations: total number of iterations to use - :param progress: If True, shows a tqdm progress bar - :param job_id: Integer id used to determine the position of the progress bar - :return: + u: Utility object with model, data, and scoring function + n_iterations: total number of iterations to use + progress: If True, shows a tqdm progress bar + job_id: Integer id used to determine the position of the progress bar + Returns: + """ n = len(u.data) diff --git a/src/pydvl/value/least_core/naive.py b/src/pydvl/value/least_core/naive.py index fdcbb97ed..01f0b76c1 100644 --- a/src/pydvl/value/least_core/naive.py +++ b/src/pydvl/value/least_core/naive.py @@ -23,11 +23,11 @@ def exact_least_core( ) -> ValuationResult: r"""Computes the exact Least Core values. - .. note:: + !!! Note If the training set contains more than 20 instances a warning is printed because the computation is very expensive. This method is mostly used for internal testing and simple use cases. Please refer to the - :func:`Monte Carlo method ` + [Monte Carlo method][pydvl.value.least_core.montecarlo.montecarlo_least_core] for practical applications. The least core is the solution to the following Linear Programming problem: @@ -42,16 +42,17 @@ def exact_least_core( Where $N = \{1, 2, \dots, n\}$ are the training set's indices. - :param u: Utility object with model, data, and scoring function - :param non_negative_subsidy: If True, the least core subsidy $e$ is constrained + u: Utility object with model, data, and scoring function + non_negative_subsidy: If True, the least core subsidy $e$ is constrained to be non-negative. - :param solver_options: Dictionary of options that will be used to select a solver + solver_options: Dictionary of options that will be used to select a solver and to configure it. Refer to the following page for all possible options: https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options - :param options: (Deprecated) Dictionary of solver options. Use solver_options instead. - :param progress: If True, shows a tqdm progress bar + options: (Deprecated) Dictionary of solver options. Use solver_options instead. + progress: If True, shows a tqdm progress bar - :return: Object with the data values and the least core value. + Returns: + Object with the data values and the least core value. """ n = len(u.data) if n > 20: # Arbitrary choice, will depend on time required, caching, etc. @@ -84,10 +85,10 @@ def exact_least_core( def lc_prepare_problem(u: Utility, progress: bool = False) -> LeastCoreProblem: """Prepares a linear problem with all subsets of the data Use this to separate the problem preparation from the solving with - :func:`~pydvl.value.least_core.common.lc_solve_problem`. Useful for + [lc_solve_problem()][pydvl.value.least_core.common.lc_solve_problem]. Useful for parallel execution of multiple experiments. - See :func:`~pydvl.value.least_core.naive.exact_least_core` for argument + See [exact_least_core()][pydvl.value.least_core.naive.exact_least_core] for argument descriptions. """ n = len(u.data) diff --git a/src/pydvl/value/loo/naive.py b/src/pydvl/value/loo/naive.py index 1b7a1eecd..bda3f9094 100644 --- a/src/pydvl/value/loo/naive.py +++ b/src/pydvl/value/loo/naive.py @@ -12,9 +12,10 @@ def naive_loo(u: Utility, *, progress: bool = True) -> ValuationResult: $$v(i) = u(D) - u(D \setminus \{i\}) $$ - :param u: Utility object with model, data, and scoring function - :param progress: If True, display a progress bar - :return: Object with the data values. + u: Utility object with model, data, and scoring function + progress: If True, display a progress bar + Returns: + Object with the data values. """ if len(u.data) < 3: diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index 0c7ae7fe4..a069b5cce 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -17,14 +17,14 @@ updated accordingly. See :class:`ValuationResult` for details. Results can also be sorted by value, variance or number of updates, see -:meth:`ValuationResult.sort`. The arrays of :attr:`ValuationResult.values`, -:attr:`ValuationResult.variances`, :attr:`ValuationResult.counts`, -:attr:`ValuationResult.indices` and :attr:`ValuationResult.names` are sorted in +:meth:`ValuationResult.sort`. The arrays of [ValuationResult.values][ValuationResult.values], +[ValuationResult.variances`, :attr:`ValuationResult.counts][ValuationResult.variances`, :attr:`ValuationResult.counts], +[ValuationResult.indices` and :attr:`ValuationResult.names][ValuationResult.indices` and :attr:`ValuationResult.names] are sorted in the same way. Indexing and slicing of results is supported and :class:`ValueItem` objects are returned. These objects can be compared with the usual operators, which take -only the :attr:`ValueItem.value` into account. +only the [ValueItem.value][ValueItem.value] into account. .. rubric:: Creating result objects @@ -89,7 +89,7 @@ class ValueItem(Generic[IndexT, NameT]): ``ValueItems`` can be compared with the usual operators, forming a total order. Comparisons take only the :attr:`value` into account. - .. todo:: + !!! Todo Maybe have a mode of comparing similar to `np.isclose`, or taking the :attr:`variance` into account. """ @@ -177,24 +177,24 @@ class ValuationResult( Empty objects behave in a special way, see :meth:`empty`. - :param values: An array of values. If omitted, defaults to an empty array + values: An array of values. If omitted, defaults to an empty array or to an array of zeros if ``indices`` are given. - :param indices: An optional array of indices in the original dataset. If + indices: An optional array of indices in the original dataset. If omitted, defaults to ``np.arange(len(values))``. **Warning:** It is common to pass the indices of a :class:`Dataset` here. Attention must be paid in a parallel context to copy them to the local process. Just do ``indices=np.copy(data.indices)``. - :param variance: An optional array of variances in the computation of each + variance: An optional array of variances in the computation of each value. - :param counts: An optional array with the number of updates for each value. + counts: An optional array with the number of updates for each value. Defaults to an array of ones. - :param data_names: Names for the data points. Defaults to index numbers + data_names: Names for the data points. Defaults to index numbers if not set. - :param algorithm: The method used. - :param status: The end status of the algorithm. - :param sort: Whether to sort the indices by ascending value. See above how + algorithm: The method used. + status: The end status of the algorithm. + sort: Whether to sort the indices by ascending value. See above how this affects usage as an iterable or sequence. - :param extra_values: Additional values that can be passed as keyword arguments. + extra_values: Additional values that can be passed as keyword arguments. This can contain, for example, the least core value. :raise ValueError: If input arrays have mismatching lengths. @@ -271,13 +271,13 @@ def sort( """Sorts the indices in place by ``key``. Once sorted, iteration over the results, and indexing of all the - properties :attr:`ValuationResult.values`, - :attr:`ValuationResult.variances`, :attr:`ValuationResult.counts`, - :attr:`ValuationResult.indices` and :attr:`ValuationResult.names` will + properties [ValuationResult.values][ValuationResult.values], + [ValuationResult.variances`, :attr:`ValuationResult.counts][ValuationResult.variances`, :attr:`ValuationResult.counts], + [ValuationResult.indices` and :attr:`ValuationResult.names][ValuationResult.indices` and :attr:`ValuationResult.names] will follow the same order. - :param reverse: Whether to sort in descending order by value. - :param key: The key to sort by. Defaults to :attr:`ValueItem.value`. + reverse: Whether to sort in descending order by value. + key: The key to sort by. Defaults to [ValueItem.value][ValueItem.value]. """ keymap = { "index": "_indices", @@ -481,7 +481,7 @@ def __add__(self, other: "ValuationResult") -> "ValuationResult": to this is if one argument has empty values, in which case the other argument is returned. - .. warning:: + !!! Warning Abusing this will introduce numerical errors. Means and standard errors are correctly handled. Statuses are added with @@ -494,7 +494,7 @@ def __add__(self, other: "ValuationResult") -> "ValuationResult": different or overlapping indices. The result will have the union of indices, and the values. - .. warning:: + !!! Warning FIXME: Arbitrary ``extra_values`` aren't handled. """ @@ -581,9 +581,10 @@ def update(self, idx: int, new_value: float) -> "ValuationResult": """Updates the result in place with a new value, using running mean and variance. - :param idx: Data index of the value to update. - :param new_value: New value to add to the result. - :return: A reference to the same, modified result. + idx: Data index of the value to update. + new_value: New value to add to the result. + Returns: + A reference to the same, modified result. :raises IndexError: If the index is not found. """ try: @@ -625,11 +626,12 @@ def to_dataframe( ) -> pandas.DataFrame: """Returns values as a dataframe. - :param column: Name for the column holding the data value. Defaults to + column: Name for the column holding the data value. Defaults to the name of the algorithm used. - :param use_names: Whether to use data names instead of indices for the + use_names: Whether to use data names instead of indices for the DataFrame's index. - :return: A dataframe with two columns, one for the values, with name + Returns: + A dataframe with two columns, one for the values, with name given as explained in `column`, and another with standard errors for approximate algorithms. The latter will be named `column+'_stderr'`. :raise ImportError: If pandas is not installed @@ -655,16 +657,17 @@ def from_random( of random values from a uniform distribution in [-1,1]. The values can be made to sum up to a given total number (doing so will change their range). - :param size: Number of values to generate - :param total: If set, the values are normalized to sum to this number + size: Number of values to generate + total: If set, the values are normalized to sum to this number ("efficiency" property of Shapley values). - :param kwargs: Additional options to pass to the constructor of + kwargs: Additional options to pass to the constructor of :class:`ValuationResult`. Use to override status, names, etc. - :return: A valuation result with its status set to - :attr:`Status.Converged` by default. + Returns: + A valuation result with its status set to + [Status.Converged][Status.Converged] by default. :raises ValueError: If ``size`` is less than 1. - .. versionchanged:: 0.6.0 + !!! version-changed 0.6.0 Added parameter ``total``. Check for zero size """ if size < 1: @@ -699,8 +702,9 @@ def empty( Empty results are characterised by having an empty array of values. When another result is added to an empty one, the empty one is discarded. - :param algorithm: Name of the algorithm used to compute the values - :return: An instance of :class:`ValuationResult` + algorithm: Name of the algorithm used to compute the values + Returns: + An instance of :class:`ValuationResult` """ if indices is not None or data_names is not None or n_samples != 0: return cls.zeros( @@ -724,14 +728,15 @@ def zeros( Empty results are characterised by having an empty array of values. When another result is added to an empty one, the empty one is ignored. - :param algorithm: Name of the algorithm used to compute the values - :param indices: Data indices to use. A copy will be made. If not given, + algorithm: Name of the algorithm used to compute the values + indices: Data indices to use. A copy will be made. If not given, the indices will be set to the range ``[0, n_samples)``. - :param data_names: Data names to use. A copy will be made. If not given, + data_names: Data names to use. A copy will be made. If not given, the names will be set to the string representation of the indices. - :param n_samples: Number of data points whose values are computed. If + n_samples: Number of data points whose values are computed. If not given, the length of ``indices`` will be used. - :return: An instance of :class:`ValuationResult` + Returns: + An instance of :class:`ValuationResult` """ if indices is None: indices = np.arange(n_samples, dtype=np.int_) diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 86c29ec3d..0d4c4bd08 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -8,13 +8,13 @@ is the index of the element being added to the subset, and ``subset`` is the subset of the complement of ``idx``. -.. note:: +!!! Note This is the natural mode of iteration for the combinatorial definition of semi-values, in particular Shapley value. For the computation using permutations, adhering to this interface is not ideal, but we stick to it for consistency. -The samplers are used in the :mod:`pydvl.value.semivalues` module to compute any +The samplers are used in the [semivalues][pydvl.value.semivalues] module to compute any semi-value, in particular Shapley and Beta values, and Banzhaf indices. .. rubric:: Slicing of samplers @@ -92,12 +92,12 @@ def __init__( outer_indices: NDArray[T] = None, ): """ - :param indices: The set of items (indices) to sample from. - :param index_iteration: the order in which indices are iterated over - :param outer_indices: The set of items (indices) over which to iterate - when sampling. Subsets are taken from the complement of each index - in succession. For embarrassingly parallel computations, this set - is sliced and the samplers are used to iterate over the slices. + indices: The set of items (indices) to sample from. + index_iteration: the order in which indices are iterated over + outer_indices: The set of items (indices) over which to iterate + when sampling. Subsets are taken from the complement of each index + in succession. For embarrassingly parallel computations, this set + is sliced and the samplers are used to iterate over the slices. """ self._indices = indices self._index_iteration = index_iteration @@ -194,7 +194,7 @@ def __init__(self, indices: NDArray[T], *args, **kwargs): For every index $i$, each subset of `indices - {i}` has equal probability $2^{n-1}$. - :param indices: The set of items (indices) to sample from. + indices: The set of items (indices) to sample from. """ # Force sequential iteration kwargs.update({"index_iteration": PowersetSampler.IndexIteration.Sequential}) @@ -248,7 +248,7 @@ class PermutationSampler(PowersetSampler[T]): """Sample permutations of indices and iterate through each returning sets, as required for the permutation definition of semi-values. - .. warning:: + !!! Warning This sampler requires caching to be enabled or computation will be doubled wrt. a "direct" implementation of permutation MC """ @@ -276,7 +276,7 @@ class DeterministicPermutationSampler(PermutationSampler[T]): iterates through them, returning sets as required for the permutation-based definition of semi-values. - .. warning:: + !!! Warning This sampler requires caching to be enabled or computation will be doubled wrt. a "direct" implementation of permutation MC """ @@ -293,7 +293,7 @@ def __iter__(self) -> Iterator[SampleType]: class RandomHierarchicalSampler(PowersetSampler[T]): """For every index, sample a set size, then a set of that size. - .. todo:: + !!! Todo This is unnecessary, but a step towards proper stratified sampling. """ diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 4c0e21454..bfa138826 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -14,7 +14,7 @@ 1. A **subset sampler** that generates subsets of the set $D$ of interest. 2. A **coefficient** $w(k)$ that assigns a weight to each subset size $k$. -Samplers can be found in :mod:`pydvl.value.sampler`, and can be classified into +Samplers can be found in [sampler][pydvl.value.sampler], and can be classified into two categories: powerset samplers and (one) permutation sampler. Powerset samplers generate subsets of $D_{-i}$, while the permutation sampler generates permutations of $D$. The former conform to the above definition of semi-values, @@ -26,7 +26,7 @@ $$ where $\sigma_{:i}$ denotes the set of indices in permutation sigma before the -position where $i$ appears (see :ref:`data valuation` for details), and +position where $i$ appears (see [Data valuation][computing-data-values] for details), and $\tilde{w}(k) = n \choose{n-1}{k} w(k)$ is the weight correction due to the reformulation. @@ -36,7 +36,7 @@ :footcite:t:`wang_data_2022`, and the Beta coefficient of :footcite:t:`kwon_beta_2022`. -.. note:: +!!! Note For implementation consistency, we slightly depart from the common definition of semi-values, which includes a factor $1/n$ in the sum over subsets. Instead, we subsume this factor into the coefficient $w(k)$. @@ -76,8 +76,8 @@ class SVCoefficient(Protocol): def __call__(self, n: int, k: int) -> float: """Computes the coefficient for a given subset size. - :param n: Total number of elements in the set. - :param k: Size of the subset for which the coefficient is being computed + n: Total number of elements in the set. + k: Size of the subset for which the coefficient is being computed """ ... @@ -94,13 +94,14 @@ def _semivalues( r"""Serial computation of semi-values. This is a helper function for :func:`semivalues`. - :param sampler: The subset sampler to use for utility computations. - :param u: Utility object with model, data, and scoring function. - :param coefficient: The semivalue coefficient - :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. + sampler: The subset sampler to use for utility computations. + u: Utility object with model, data, and scoring function. + coefficient: The semivalue coefficient + done: Stopping criterion. + progress: Whether to display progress bars for each job. + job_id: id to use for reporting progress. + Returns: + Object with the results. """ n = len(u.data.indices) result = ValuationResult.zeros( @@ -135,15 +136,16 @@ def semivalues( """ Computes semi-values for a given utility function and subset sampler. - :param sampler: The subset sampler to use for utility computations. - :param u: Utility object with model, data, and scoring function. - :param coefficient: The semi-value coefficient - :param done: Stopping criterion. - :param n_jobs: Number of parallel jobs to use. - :param config: Object configuring parallel computation, with cluster + sampler: The subset sampler to use for utility computations. + u: Utility object with model, data, and scoring function. + coefficient: The semi-value coefficient + done: Stopping criterion. + n_jobs: Number of parallel jobs to use. + config: Object configuring parallel computation, with cluster address, number of cpus, etc. - :param progress: Whether to display progress bars for each job. - :return: Object with the results. + progress: Whether to display progress bars for each job. + Returns: + Object with the results. """ map_reduce_job: MapReduceJob[PowersetSampler, ValuationResult] = MapReduceJob( @@ -207,27 +209,27 @@ def compute_semivalues( For any other sampling method, use :func:`parallel_semivalues` directly. - See :ref:`data valuation` for an overview of valuation. + See [Data valuation][computing-data-values] for an overview of valuation. The modes supported are: - - :attr:`SemiValueMode.Shapley`: Shapley values. - - :attr:`SemiValueMode.BetaShapley`: Implements the Beta Shapley semi-value + - [SemiValueMode.Shapley][SemiValueMode.Shapley]: Shapley values. + - [SemiValueMode.BetaShapley][SemiValueMode.BetaShapley]: Implements the Beta Shapley semi-value as introduced in :footcite:t:`kwon_beta_2022`. Pass additional keyword arguments ``alpha`` and ``beta`` to set the parameters of the Beta distribution (both default to 1). - - :attr:`SemiValueMode.Banzhaf`: Implements the Banzhaf semi-value as + - [SemiValueMode.Banzhaf][SemiValueMode.Banzhaf]: Implements the Banzhaf semi-value as introduced in :footcite:t:`wang_data_2022`. - :param u: Utility object with model, data, and scoring function. - :param done: Stopping criterion. - :param mode: The semi-value mode to use. See :class:`SemiValueMode` for a + u: Utility object with model, data, and scoring function. + done: Stopping criterion. + mode: The semi-value mode to use. See :class:`SemiValueMode` for a list. - :param sampler_t: The sampler type to use. See :mod:`pydvl.value.sampler` + sampler_t: The sampler type to use. See [sampler][pydvl.value.sampler] for a list. - :param n_jobs: Number of parallel jobs to use. - :param kwargs: Additional keyword arguments passed to - :func:`~pydvl.value.semivalues.semivalues`. + n_jobs: Number of parallel jobs to use. + kwargs: Additional keyword arguments passed to + [semivalues()][pydvl.value.semivalues.semivalues]. """ sampler_instance = sampler_t(u.data.indices) if mode == SemiValueMode.Shapley: diff --git a/src/pydvl/value/shapley/__init__.py b/src/pydvl/value/shapley/__init__.py index 6f93cd60e..39ab64e7a 100644 --- a/src/pydvl/value/shapley/__init__.py +++ b/src/pydvl/value/shapley/__init__.py @@ -1,9 +1,9 @@ """ This package holds all routines for the computation of Shapley Data value. Users -will want to use :func:`~pydvl.value.shapley.common.compute_shapley_values` as a +will want to use [compute_shapley_values()][pydvl.value.shapley.common.compute_shapley_values] as a single interface to all methods defined in the modules. -Please refer to :ref:`data valuation` for an overview of Shapley Data value. +Please refer to [Data valuation][computing-data-values] for an overview of Shapley Data value. """ from ..result import * diff --git a/src/pydvl/value/shapley/common.py b/src/pydvl/value/shapley/common.py index 751185cbd..35bb82243 100644 --- a/src/pydvl/value/shapley/common.py +++ b/src/pydvl/value/shapley/common.py @@ -29,7 +29,7 @@ def compute_shapley_values( """Umbrella method to compute Shapley values with any of the available algorithms. - See :ref:`data valuation` for an overview. + See [Data valuation][computing-data-values] for an overview. The following algorithms are available. Note that the exact methods can only work with very small datasets and are thus intended only for testing. Some @@ -38,36 +38,36 @@ def compute_shapley_values( - ``combinatorial_exact``: uses the combinatorial implementation of data Shapley. Implemented in - :func:`~pydvl.value.shapley.naive.combinatorial_exact_shapley`. + [combinatorial_exact_shapley()][pydvl.value.shapley.naive.combinatorial_exact_shapley]. - ``combinatorial_montecarlo``: uses the approximate Monte Carlo implementation of combinatorial data Shapley. Implemented in - :func:`~pydvl.value.shapley.montecarlo.combinatorial_montecarlo_shapley`. + [combinatorial_montecarlo_shapley()][pydvl.value.shapley.montecarlo.combinatorial_montecarlo_shapley]. - ``permutation_exact``: uses the permutation-based implementation of data Shapley. Computation is **not parallelized**. Implemented in - :func:`~pydvl.value.shapley.naive.permutation_exact_shapley`. + [permutation_exact_shapley()][pydvl.value.shapley.naive.permutation_exact_shapley]. - ``permutation_montecarlo``: uses the approximate Monte Carlo implementation of permutation data Shapley. Implemented in - :func:`~pydvl.value.shapley.montecarlo.permutation_montecarlo_shapley`. + [permutation_montecarlo_shapley()][pydvl.value.shapley.montecarlo.permutation_montecarlo_shapley]. - ``truncated_montecarlo``: default option, same as ``permutation_montecarlo`` but stops the computation whenever a certain accuracy is reached. Implemented in - :func:`~pydvl.value.shapley.montecarlo.truncated_montecarlo_shapley`. + [truncated_montecarlo_shapley()][pydvl.value.shapley.montecarlo.truncated_montecarlo_shapley]. - ``owen_sampling``: Uses the Owen continuous extension of the utility function to the unit cube. Implemented in - :func:`~pydvl.value.shapley.montecarlo.owen_sampling_shapley`. This + [owen_sampling_shapley()][pydvl.value.shapley.montecarlo.owen_sampling_shapley]. This method does not take a :class:`~pydvl.value.stopping.StoppingCriterion` but instead requires a parameter ``q_max`` for the number of subdivisions of the unit interval to use for integration, and another parameter ``n_samples`` for the number of subsets to sample for each $q$. - ``owen_halved``: Same as 'owen_sampling' but uses correlated samples in the expectation. Implemented in - :func:`~pydvl.value.shapley.montecarlo.owen_sampling_shapley`. + [owen_sampling_shapley()][pydvl.value.shapley.montecarlo.owen_sampling_shapley]. This method requires an additional parameter `q_max` for the number of subdivisions of the interval [0,0.5] to use for integration, and another parameter ``n_samples`` for the number of subsets to sample for each $q$. - ``group_testing``: estimates differences of Shapley values and solves a constraint satisfaction problem. High sample complexity, not recommended. - Implemented in :func:`~pydvl.value.shapley.gt.group_testing_shapley`. This + Implemented in [group_testing_shapley()][pydvl.value.shapley.gt.group_testing_shapley]. This method does not take a :class:`~pydvl.value.stopping.StoppingCriterion` but instead requires a parameter ``n_samples`` for the number of iterations to run. @@ -75,21 +75,23 @@ def compute_shapley_values( Additionally, one can use model-specific methods: - ``knn``: Exact method for K-Nearest neighbour models. Implemented in - :func:`~pydvl.value.shapley.knn.knn_shapley`. + [knn_shapley()][pydvl.value.shapley.knn.knn_shapley]. - :param u: :class:`~pydvl.utils.utility.Utility` object with model, data, and + Args: + u: :class:`~pydvl.utils.utility.Utility` object with model, data, and scoring function. - :param done: :class:`~pydvl.value.stopping.StoppingCriterion` object, used + done: :class:`~pydvl.value.stopping.StoppingCriterion` object, used to determine when to stop the computation for Monte Carlo methods. The default is to stop after 100 iterations. See the available criteria in - :mod:`~pydvl.value.stopping`. It is possible to combine several criteria + [stopping][pydvl.value.stopping]. It is possible to combine several criteria using boolean operators. Some methods ignore this argument, others require specific subtypes. - :param n_jobs: Number of parallel jobs (available only to some methods) - :param mode: Choose which shapley algorithm to use. See + n_jobs: Number of parallel jobs (available only to some methods) + mode: Choose which shapley algorithm to use. See :class:`~pydvl.value.shapley.ShapleyMode` for a list of allowed value. - :return: A :class:`~pydvl.value.result.ValuationResult` object with the + Returns: + A :class:`~pydvl.value.result.ValuationResult` object with the results. """ diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index b4b093637..b2bf71f74 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -4,15 +4,15 @@ done in such a way that an approximation to the true Shapley values can be computed with guarantees. -.. warning:: +!!! Warning This method is very inefficient. Potential improvements to the implementation notwithstanding, convergence seems to be very slow (in terms of evaluations of the utility required). We recommend other Monte Carlo methods instead. -You can read more :ref:`in the documentation`. +You can read more [in the documentation][computing-data-values]. -.. versionadded:: 0.4.0 +!!! version-added 0.4.0 """ import logging @@ -43,12 +43,13 @@ def _constants( """A helper function returning the constants for the algorithm. Pretty ugly, yes. - :param n: The number of data points. - :param epsilon: The error tolerance. - :param delta: The confidence level. - :param utility_range: The range of the utility function. + n: The number of data points. + epsilon: The error tolerance. + delta: The confidence level. + utility_range: The range of the utility function. - :return: A namedtuple with the constants. The fields are the same as in the + Returns: + A namedtuple with the constants. The fields are the same as in the paper: - kk: the sample sizes (i.e. an array of 1, 2, ..., n - 1) - Z: the normalization constant @@ -98,15 +99,16 @@ def num_samples_eps_delta( (ε/√n,δ/(N(N-1))-approximation to all pair-wise differences of Shapley values, wrt. $\ell_2$ norm. - :param eps: ε - :param delta: δ - :param n: Number of data points - :param utility_range: Range of the :class:`~pydvl.utils.utility.Utility` + eps: ε + delta: δ + n: Number of data points + utility_range: Range of the :class:`~pydvl.utils.utility.Utility` function - :return: Number of samples from $2^{[n]}$ guaranteeing ε/√n-correct Shapley + Returns: + Number of samples from $2^{[n]}$ guaranteeing ε/√n-correct Shapley pair-wise differences of values with probability 1-δ/(N(N-1)). - .. versionadded:: 0.4.0 + !!! version-added 0.4.0 """ constants = _constants(n=n, epsilon=eps, delta=delta, utility_range=utility_range) @@ -121,11 +123,12 @@ def _group_testing_shapley( Computes utilities of sets sampled using the strategy for estimating the differences in Shapley values. - :param u: Utility object with model, data, and scoring function. - :param n_samples: total number of samples (subsets) to use. - :param progress: Whether to display progress bars for each job. - :param job_id: id to use for reporting progress (e.g. to place progres bars) - :return: + u: Utility object with model, data, and scoring function. + n_samples: total number of samples (subsets) to use. + progress: Whether to display progress bars for each job. + job_id: id to use for reporting progress (e.g. to place progres bars) + Returns: + """ rng = np.random.default_rng() n = len(u.data.indices) @@ -156,10 +159,10 @@ def group_testing_shapley( """Implements group testing for approximation of Shapley values as described in :footcite:t:`jia_efficient_2019`. - .. warning:: + !!! Warning This method is very inefficient. It requires several orders of magnitude more evaluations of the utility than others in - :mod:`~pydvl.value.shapley.montecarlo`. It also uses several intermediate + [montecarlo][pydvl.value.shapley.montecarlo]. It also uses several intermediate objects like the results from the runners and the constraint matrices which can become rather large. @@ -167,28 +170,29 @@ def group_testing_shapley( values can be approximated with a Monte Carlo sum. These are then used to solve for the individual values in a feasibility problem. - :param u: Utility object with model, data, and scoring function - :param n_samples: Number of tests to perform. Use + u: Utility object with model, data, and scoring function + n_samples: Number of tests to perform. Use :func:`num_samples_eps_delta` to estimate this. - :param epsilon: From the (ε,δ) sample bound. Use the same as for the + epsilon: From the (ε,δ) sample bound. Use the same as for the estimation of ``n_iterations``. - :param delta: From the (ε,δ) sample bound. Use the same as for the + delta: From the (ε,δ) sample bound. Use the same as for the estimation of ``n_iterations``. - :param n_jobs: Number of parallel jobs to use. Each worker performs a chunk + n_jobs: Number of parallel jobs to use. Each worker performs a chunk of all tests (i.e. utility evaluations). - :param config: Object configuring parallel computation, with cluster + config: Object configuring parallel computation, with cluster address, number of cpus, etc. - :param progress: Whether to display progress bars for each job. - :param options: Additional options to pass to `cvxpy.Problem.solve() + progress: Whether to display progress bars for each job. + options: Additional options to pass to `cvxpy.Problem.solve() `_. E.g. to change the solver (which defaults to `cvxpy.SCS`) pass `solver=cvxpy.CVXOPT`. - :return: Object with the data values. + Returns: + Object with the data values. - .. versionadded:: 0.4.0 + !!! version-added 0.4.0 - .. versionchanged:: 0.5.0 + !!! version-changed 0.5.0 Changed the solver to cvxpy instead of scipy's linprog. Added the ability to pass arbitrary options to it. """ diff --git a/src/pydvl/value/shapley/knn.py b/src/pydvl/value/shapley/knn.py index 22bb857fb..dcb0db452 100644 --- a/src/pydvl/value/shapley/knn.py +++ b/src/pydvl/value/shapley/knn.py @@ -1,7 +1,7 @@ """ This module contains Shapley computations for K-Nearest Neighbours. -.. todo:: +!!! Todo Implement approximate KNN computation for sublinear complexity) """ @@ -25,15 +25,16 @@ def knn_shapley(u: Utility, *, progress: bool = True) -> ValuationResult: of calls to the utility function to a constant number per index, thus reducing computation time to $O(n)$. - :param u: Utility with a KNN model to extract parameters from. The object + u: Utility with a KNN model to extract parameters from. The object will not be modified nor used other than to call `get_params() `_ - :param progress: Whether to display a progress bar. - :return: Object with the data values. + progress: Whether to display a progress bar. + Returns: + Object with the data values. :raises TypeError: If the model in the utility is not a `KNeighborsClassifier `_ - .. versionadded:: 0.1.0 + !!! version-added 0.1.0 """ if not isinstance(u.model, KNeighborsClassifier): diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index ad43edad1..e157310ef 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -1,9 +1,9 @@ r""" Monte Carlo approximations to Shapley Data values. -.. warning:: +!!! Warning You probably want to use the common interface provided by - :func:`~pydvl.value.shapley.compute_shapley_values` instead of directly using + [compute_shapley_values()][pydvl.value.shapley.compute_shapley_values] instead of directly using the functions in this module. Because exact computation of Shapley values requires $\mathcal{O}(2^n)$ @@ -18,7 +18,7 @@ reduce computation :func:`truncated_montecarlo_shapley`. .. seealso:: - It is also possible to use :func:`~pydvl.value.shapley.gt.group_testing_shapley` + It is also possible to use [group_testing_shapley()][pydvl.value.shapley.gt.group_testing_shapley] to reduce the number of evaluations of the utility. The method is however typically outperformed by others in this module. @@ -26,7 +26,7 @@ Additionally, you can consider grouping your data points using :class:`~pydvl.utils.dataset.GroupedDataset` and computing the values of the groups instead. This is not to be confused with "group testing" as - implemented in :func:`~pydvl.value.shapley.gt.group_testing_shapley`: any of + implemented in [group_testing_shapley()][pydvl.value.shapley.gt.group_testing_shapley]: any of the algorithms mentioned above, including Group Testing, can work to valuate groups of samples as units. """ @@ -69,15 +69,16 @@ def _permutation_montecarlo_shapley( :obj:`pydvl.utils.utility.Utility.data` by iterating through randomly sampled permutations. - :param u: Utility object with model, data, and scoring function - :param done: Check on the results which decides when to stop - :param truncation: A callable which decides whether to interrupt + u: Utility object with model, data, and scoring function + done: Check on the results which decides when to stop + truncation: A callable which decides whether to interrupt processing a permutation and set all subsequent marginals to zero. - :param algorithm_name: For the results object. Used internally by different + algorithm_name: For the results object. Used internally by different variants of Shapley using this subroutine - :param progress: Whether to display progress bars for each job. - :param job_id: id to use for reporting progress (e.g. to place progres bars) - :return: An object with the results + progress: Whether to display progress bars for each job. + job_id: id to use for reporting progress (e.g. to place progres bars) + Returns: + An object with the results """ result = ValuationResult.zeros( algorithm=algorithm_name, indices=u.data.indices, data_names=u.data.data_names @@ -122,18 +123,19 @@ def permutation_montecarlo_shapley( $$ where $\sigma_{:i}$ denotes the set of indices in permutation sigma before the - position where $i$ appears (see :ref:`data valuation` for details). + position where $i$ appears (see [Data valuation][computing-data-values] for details). - :param u: Utility object with model, data, and scoring function. - :param done: function checking whether computation must stop. - :param truncation: An optional callable which decides whether to + u: Utility object with model, data, and scoring function. + done: function checking whether computation must stop. + truncation: An optional callable which decides whether to interrupt processing a permutation and set all subsequent marginals to zero. Typically used to stop computation when the marginal is small. - :param n_jobs: number of jobs across which to distribute the computation. - :param config: Object configuring parallel computation, with cluster + n_jobs: number of jobs across which to distribute the computation. + config: Object configuring parallel computation, with cluster address, number of cpus, etc. - :param progress: Whether to display progress bars for each job. - :return: Object with the data values. + progress: Whether to display progress bars for each job. + Returns: + Object with the data values. """ map_reduce_job: MapReduceJob[Utility, ValuationResult] = MapReduceJob( @@ -165,13 +167,14 @@ def _combinatorial_montecarlo_shapley( This is the code that is sent to workers to compute values using the combinatorial definition. - :param indices: Indices of the samples to compute values for. - :param u: Utility object with model, data, and scoring function - :param done: Check on the results which decides when to stop sampling + indices: Indices of the samples to compute values for. + u: Utility object with model, data, and scoring function + done: Check on the results which decides when to stop sampling subsets for an index. - :param progress: Whether to display progress bars for each job. - :param job_id: id to use for reporting progress - :return: A tuple of ndarrays with estimated values and standard errors + progress: Whether to display progress bars for each job. + job_id: id to use for reporting progress + Returns: + A tuple of ndarrays with estimated values and standard errors """ n = len(u.data) @@ -215,26 +218,27 @@ def combinatorial_montecarlo_shapley( \binom{n-1}{ | S | }^{-1} [u(S \cup \{i\}) − u(S)]$$ This consists of randomly sampling subsets of the power set of the training - indices in :attr:`~pydvl.utils.utility.Utility.data`, and computing their - marginal utilities. See :ref:`data valuation` for details. + indices in [data][pydvl.utils.utility.Utility.data], and computing their + marginal utilities. See [Data valuation][computing-data-values] for details. Note that because sampling is done with replacement, the approximation is poor even for $2^{m}$ subsets with $m>n$, even though there are $2^{n-1}$ subsets for each $i$. Prefer - :func:`~pydvl.shapley.montecarlo.permutation_montecarlo_shapley`. + [permutation_montecarlo_shapley()][pydvl.value.shapley.montecarlo.permutation_montecarlo_shapley]. Parallelization is done by splitting the set of indices across processes and computing the sum over subsets $S \subseteq N \setminus \{i\}$ separately. - :param u: Utility object with model, data, and scoring function - :param done: Stopping criterion for the computation. - :param n_jobs: number of parallel jobs across which to distribute the + u: Utility object with model, data, and scoring function + done: Stopping criterion for the computation. + n_jobs: number of parallel jobs across which to distribute the computation. Each worker receives a chunk of - :attr:`~pydvl.utils.dataset.Dataset.indices` - :param config: Object configuring parallel computation, with cluster + [indices][pydvl.utils.dataset.Dataset.indices] + config: Object configuring parallel computation, with cluster address, number of cpus, etc. - :param progress: Whether to display progress bars for each job. - :return: Object with the data values. + progress: Whether to display progress bars for each job. + Returns: + Object with the data values. """ map_reduce_job: MapReduceJob[NDArray, ValuationResult] = MapReduceJob( diff --git a/src/pydvl/value/shapley/naive.py b/src/pydvl/value/shapley/naive.py index d903ff80b..070f2b5d4 100644 --- a/src/pydvl/value/shapley/naive.py +++ b/src/pydvl/value/shapley/naive.py @@ -18,16 +18,17 @@ def permutation_exact_shapley(u: Utility, *, progress: bool = True) -> Valuation $$v_u(x_i) = \frac{1}{n!} \sum_{\sigma \in \Pi(n)} [u(\sigma_{i-1} \cup {i}) − u(\sigma_{i})].$$ - See :ref:`data valuation` for details. + See [Data valuation][computing-data-values] for details. When the length of the training set is > 10 this prints a warning since the computation becomes too expensive. Used mostly for internal testing and simple use cases. Please refer to the :mod:`Monte Carlo ` approximations for practical applications. - :param u: Utility object with model, data, and scoring function - :param progress: Whether to display progress bars for each job. - :return: Object with the data values. + u: Utility object with model, data, and scoring function + progress: Whether to display progress bars for each job. + Returns: + Object with the data values. """ n = len(u.data) @@ -92,21 +93,22 @@ def combinatorial_exact_shapley( $$v_u(i) = \frac{1}{n} \sum_{S \subseteq N \setminus \{i\}} \binom{n-1}{ | S | }^{-1} [u(S \cup \{i\}) − u(S)].$$ - See :ref:`data valuation` for details. + See [Data valuation][computing-data-values] for details. - .. note:: + !!! Note If the length of the training set is > n_jobs*20 this prints a warning because the computation is very expensive. Used mostly for internal testing and simple use cases. Please refer to the - :mod:`Monte Carlo ` approximations for practical + [Monte Carlo][pydvl.value.shapley.montecarlo] approximations for practical applications. - :param u: Utility object with model, data, and scoring function - :param n_jobs: Number of parallel jobs to use - :param config: Object configuring parallel computation, with cluster address, + u: Utility object with model, data, and scoring function + n_jobs: Number of parallel jobs to use + config: Object configuring parallel computation, with cluster address, number of cpus, etc. - :param progress: Whether to display progress bars for each job. - :return: Object with the data values. + progress: Whether to display progress bars for each job. + Returns: + Object with the data values. """ # Arbitrary choice, will depend on time required, caching, etc. if len(u.data) // n_jobs > 20: diff --git a/src/pydvl/value/shapley/owen.py b/src/pydvl/value/shapley/owen.py index ec61b4f4d..2016c9f73 100644 --- a/src/pydvl/value/shapley/owen.py +++ b/src/pydvl/value/shapley/owen.py @@ -35,19 +35,20 @@ def _owen_sampling_shapley( of the integrand. For the integrand (the expected marginal utility over the power set), use Monte Carlo. - .. todo:: + !!! Todo We might want to try better quadrature rules like Gauss or Rombert or use Monte Carlo for the double integral. - :param indices: Indices to compute the value for - :param u: Utility object with model, data, and scoring function - :param method: Either :attr:`~OwenAlgorithm.Full` for $q \in [0,1]$ or - :attr:`~OwenAlgorithm.Halved` for $q \in [0,0.5]$ and correlated samples - :param n_samples: Number of subsets to sample to estimate the integrand - :param max_q: number of subdivisions for the integration over $q$ - :param progress: Whether to display progress bars for each job - :param job_id: For positioning of the progress bar - :return: Object with the data values, errors. + indices: Indices to compute the value for + u: Utility object with model, data, and scoring function + method: Either [Full][OwenAlgorithm.Full] for $q \in [0,1]$ or + [Halved][OwenAlgorithm.Halved] for $q \in [0,0.5]$ and correlated samples + n_samples: Number of subsets to sample to estimate the integrand + max_q: number of subdivisions for the integration over $q$ + progress: Whether to display progress bars for each job + job_id: For positioning of the progress bar + Returns: + Object with the data values, errors. """ q_stop = {OwenAlgorithm.Standard: 1.0, OwenAlgorithm.Antithetic: 0.5} q_steps = np.linspace(start=0, stop=q_stop[method], num=max_q) @@ -122,27 +123,28 @@ def owen_sampling_shapley( where now $q_j = \frac{j}{2Q} \in [0,\frac{1}{2}]$, and $S^c$ is the complement of $S$. - .. note:: + !!! Note The outer integration could be done instead with a quadrature rule. - :param u: :class:`~pydvl.utils.utility.Utility` object holding data, model + u: :class:`~pydvl.utils.utility.Utility` object holding data, model and scoring function. - :param n_samples: Numer of sets to sample for each value of q - :param max_q: Number of subdivisions for q ∈ [0,1] (the element sampling + n_samples: Numer of sets to sample for each value of q + max_q: Number of subdivisions for q ∈ [0,1] (the element sampling probability) used to approximate the outer integral. - :param method: Selects the algorithm to use, see the description. Either - :attr:`~OwenAlgorithm.Full` for $q \in [0,1]$ or - :attr:`~OwenAlgorithm.Halved` for $q \in [0,0.5]$ and correlated samples - :param n_jobs: Number of parallel jobs to use. Each worker receives a chunk + method: Selects the algorithm to use, see the description. Either + [Full][OwenAlgorithm.Full] for $q \in [0,1]$ or + [Halved][OwenAlgorithm.Halved] for $q \in [0,0.5]$ and correlated samples + n_jobs: Number of parallel jobs to use. Each worker receives a chunk of the total of `max_q` values for q. - :param config: Object configuring parallel computation, with cluster + config: Object configuring parallel computation, with cluster address, number of cpus, etc. - :param progress: Whether to display progress bars for each job. - :return: Object with the data values. + progress: Whether to display progress bars for each job. + Returns: + Object with the data values. - .. versionadded:: 0.3.0 + !!! version-added 0.3.0 - .. versionchanged:: 0.5.0 + !!! version-changed 0.5.0 Support for parallel computation and enable antithetic sampling. """ diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 23b871699..4a2af7ac5 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -31,7 +31,7 @@ class TruncationPolicy(abc.ABC): Statistics are kept on the number of calls and truncations as :attr:`n_calls` and :attr:`n_truncations` respectively. - .. todo:: + !!! Todo Because the policy objects are copied to the workers, the statistics are not accessible from the :class:`~pydvl.value.shapley.actor.ShapleyCoordinator`. We need to add @@ -55,9 +55,10 @@ def reset(self): def __call__(self, idx: int, score: float) -> bool: """Check whether the computation should be interrupted. - :param idx: Position in the permutation currently being computed. - :param score: Last utility computed. - :return: ``True`` if the computation should be interrupted. + idx: Position in the permutation currently being computed. + score: Last utility computed. + Returns: + ``True`` if the computation should be interrupted. """ ret = self._check(idx, score) self.n_calls += 1 @@ -78,9 +79,9 @@ def reset(self): class FixedTruncation(TruncationPolicy): """Break a permutation after computing a fixed number of marginals. - :param u: Utility object with model, data, and scoring function - :param fraction: Fraction of marginals in a permutation to compute before - stopping (e.g. 0.5 to compute half of the marginals). + u: Utility object with model, data, and scoring function + fraction: Fraction of marginals in a permutation to compute before + stopping (e.g. 0.5 to compute half of the marginals). """ def __init__(self, u: Utility, fraction: float): @@ -103,8 +104,8 @@ class RelativeTruncation(TruncationPolicy): This is called "performance tolerance" in :footcite:t:`ghorbani_data_2019`. - :param u: Utility object with model, data, and scoring function - :param rtol: Relative tolerance. The permutation is broken if the + u: Utility object with model, data, and scoring function + rtol: Relative tolerance. The permutation is broken if the last computed utility is less than ``total_utility * rtol``. """ @@ -125,10 +126,10 @@ class BootstrapTruncation(TruncationPolicy): """Break a permutation if the last computed utility is close to the total utility, measured as a multiple of the standard deviation of the utilities. - :param u: Utility object with model, data, and scoring function - :param n_samples: Number of bootstrap samples to use to compute the variance + u: Utility object with model, data, and scoring function + n_samples: Number of bootstrap samples to use to compute the variance of the utilities. - :param sigmas: Number of standard deviations to use as a threshold. + sigmas: Number of standard deviations to use as a threshold. """ def __init__(self, u: Utility, n_samples: int, sigmas: float = 1): @@ -207,7 +208,7 @@ def truncated_montecarlo_shapley( over all possible permutations of the index set, with a double stopping criterion. - .. todo:: + !!! Todo Think of how to add Robin-Gelman or some other more principled stopping criterion. @@ -224,20 +225,21 @@ def truncated_montecarlo_shapley( We keep sampling permutations and updating all shapley values until the :class:`StoppingCriterion` returns ``True``. - :param u: Utility object with model, data, and scoring function - :param done: Check on the results which decides when to stop + u: Utility object with model, data, and scoring function + done: Check on the results which decides when to stop sampling permutations. - :param truncation: callable that decides whether to stop computing + truncation: callable that decides whether to stop computing marginals for a given permutation. - :param config: Object configuring parallel computation, with cluster + config: Object configuring parallel computation, with cluster address, number of cpus, etc. - :param n_jobs: Number of permutation monte carlo jobs + n_jobs: Number of permutation monte carlo jobs to run concurrently. - :param coordinator_update_period: in seconds. How often to check the + coordinator_update_period: in seconds. How often to check the accumulated results from the workers for convergence. - :param worker_update_period: interval in seconds between different + worker_update_period: interval in seconds between different updates to and from the coordinator - :return: Object with the data values. + Returns: + Object with the data values. """ algorithm = "truncated_montecarlo_shapley" diff --git a/src/pydvl/value/shapley/types.py b/src/pydvl/value/shapley/types.py index 3b0d80d3d..7e1d202f2 100644 --- a/src/pydvl/value/shapley/types.py +++ b/src/pydvl/value/shapley/types.py @@ -4,7 +4,7 @@ class ShapleyMode(str, Enum): """Supported algorithms for the computation of Shapley values. - .. todo:: + !!! Todo Make algorithms register themselves here. """ diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index 09ba84475..2e56328d7 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -95,7 +95,7 @@ class StoppingCriterion(abc.ABC): :meth:`completion` should be overridden to provide an overall completion value, since the default implementation returns the mean of :attr:`converged`. - :param modify_result: If ``True`` the status of the input + modify_result: If ``True`` the status of the input :class:`~pydvl.value.result.ValuationResult` is modified in place after the call. """ @@ -180,15 +180,16 @@ def make_criterion( """Create a new :class:`StoppingCriterion` from a function. Use this to enable simpler functions to be composed with bitwise operators - :param fun: The callable to wrap. - :param converged: A callable that returns a boolean array indicating what + fun: The callable to wrap. + converged: A callable that returns a boolean array indicating what values have converged. - :param completion: A callable that returns a value between 0 and 1 indicating + completion: A callable that returns a value between 0 and 1 indicating the rate of completion of the computation. If not provided, the fraction of converged values is used. - :param name: The name of the new criterion. If ``None``, the ``__name__`` of + name: The name of the new criterion. If ``None``, the ``__name__`` of the function is used. - :return: A new subclass of :class:`StoppingCriterion`. + Returns: + A new subclass of :class:`StoppingCriterion`. """ class WrappedCriterion(StoppingCriterion): @@ -221,18 +222,18 @@ class AbsoluteStandardError(StoppingCriterion): r"""Determine convergence based on the standard error of the values. If $s_i$ is the standard error for datum $i$ and $v_i$ its value, then this - criterion returns :attr:`~pydvl.utils.status.Status.Converged` if + criterion returns [Converged][pydvl.utils.status.Status.Converged] if $s_i < \epsilon$ for all $i$ and a threshold value $\epsilon \gt 0$. - :param threshold: A value is considered to have converged if the standard + threshold: A value is considered to have converged if the standard error is below this value. A way of choosing it is to pick some percentage of the range of the values. For Shapley values this is the difference between the maximum and minimum of the utility function (to see this substitute the maximum and minimum values of the utility into the marginal contribution formula). - :param fraction: The fraction of values that must have converged for the - criterion to return :attr:`~pydvl.utils.status.Status.Converged`. - :param burn_in: The number of iterations to ignore before checking for + fraction: The fraction of values that must have converged for the + criterion to return [Converged][pydvl.utils.status.Status.Converged]. + burn_in: The number of iterations to ignore before checking for convergence. This is required because computations typically start with zero variance, as a result of using :meth:`~pydvl.value.result.ValuationResult.empty`. The default is set to @@ -272,7 +273,7 @@ class MaxChecks(StoppingCriterion): A "check" is one call to the criterion. - :param n_checks: Threshold: if ``None``, no _check is performed, + n_checks: Threshold: if ``None``, no _check is performed, effectively creating a (never) stopping criterion that always returns ``Pending``. """ @@ -308,7 +309,7 @@ class MaxUpdates(StoppingCriterion): number coincides with the maximum number of subsets sampled. For permutation samplers, it coincides with the number of permutations sampled. - :param n_updates: Threshold: if ``None``, no _check is performed, + n_updates: Threshold: if ``None``, no _check is performed, effectively creating a (never) stopping criterion that always returns ``Pending``. """ @@ -346,7 +347,7 @@ class MinUpdates(StoppingCriterion): number is a lower bound for the number of subsets sampled. For permutation samplers, it lower-bounds the amount of permutations sampled. - :param n_updates: Threshold: if ``None``, no _check is performed, + n_updates: Threshold: if ``None``, no _check is performed, effectively creating a (never) stopping criterion that always returns ``Pending``. """ @@ -378,7 +379,7 @@ class MaxTime(StoppingCriterion): Checks the elapsed time since construction - :param seconds: Threshold: The computation is terminated if the elapsed time + seconds: Threshold: The computation is terminated if the elapsed time between object construction and a _check exceeds this value. If ``None``, no _check is performed, effectively creating a (never) stopping criterion that always returns ``Pending``. @@ -426,14 +427,14 @@ class HistoryDeviation(StoppingCriterion): pinned to that state. Once all indices have converged the method has converged. - .. warning:: + !!! Warning This criterion is meant for the reproduction of the results in the paper, but we do not recommend using it in practice. - :param n_steps: Checkpoint values every so many updates and use these saved + n_steps: Checkpoint values every so many updates and use these saved values to compare. - :param rtol: Relative tolerance for convergence ($\epsilon$ in the formula). - :param pin_converged: If ``True``, once an index has converged, it is pinned + rtol: Relative tolerance for convergence ($\epsilon$ in the formula). + pin_converged: If ``True``, once an index has converged, it is pinned """ _memory: NDArray[np.float_] From d24ed426972470707d746eb61fdbd3fe30446b4e Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 8 Jun 2023 14:27:58 +0200 Subject: [PATCH 069/436] fix bugs --- .../influence/frameworks/torch_differentiable.py | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 2d120e381..310f553a1 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -66,7 +66,7 @@ def solve_linear( all_y = cat(all_y) matrix = model.hessian( all_x, all_y, progress=progress - ) + hessian_perturbation * identity_tensor(model.num_params) + ) + hessian_perturbation * identity_tensor(model.num_params, device=model.device) return torch.linalg.solve(matrix, b.T).T @@ -149,6 +149,9 @@ def solve_cg( optimal = False for k in range(maxiter): + if gamma < stopping_val: + optimal = True + break Ap = hvp(p).squeeze() alpha = gamma / torch.sum(torch.matmul(p, Ap)).item() x += alpha * p @@ -158,10 +161,6 @@ def solve_cg( gamma = gamma_ p = r + beta * p - if gamma < stopping_val: - optimal = True - break - info = {"niter": k, "optimal": optimal} return x, info @@ -269,8 +268,8 @@ def einsum(equation, *operands) -> torch.Tensor: return torch.einsum(equation, *operands) -def identity_tensor(dim: int) -> torch.Tensor: - return torch.eye(dim, dim) +def identity_tensor(dim: int, **kwargs) -> torch.Tensor: + return torch.eye(dim, dim, **kwargs) def mvp( From 719e470f660b8979210792847505dec8c3ea5949 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Wed, 14 Jun 2023 14:03:58 +0200 Subject: [PATCH 070/436] Finshed converting all params to args --- src/pydvl/reporting/plots.py | 87 +--------- src/pydvl/reporting/scores.py | 1 + src/pydvl/utils/caching.py | 35 ++-- src/pydvl/utils/config.py | 32 ++-- src/pydvl/utils/dataset.py | 167 +++++++++---------- src/pydvl/utils/numeric.py | 34 ++-- src/pydvl/utils/parallel/backend.py | 16 +- src/pydvl/utils/parallel/futures/__init__.py | 3 +- src/pydvl/utils/parallel/futures/ray.py | 29 ++-- src/pydvl/utils/parallel/map_reduce.py | 37 ++-- src/pydvl/utils/progress.py | 1 + src/pydvl/utils/score.py | 28 ++-- src/pydvl/utils/types.py | 2 +- src/pydvl/value/least_core/__init__.py | 10 +- src/pydvl/value/least_core/common.py | 41 +++-- src/pydvl/value/least_core/montecarlo.py | 15 +- src/pydvl/value/least_core/naive.py | 13 +- src/pydvl/value/loo/naive.py | 1 + src/pydvl/value/result.py | 66 ++++---- src/pydvl/value/sampler.py | 14 +- src/pydvl/value/semivalues.py | 17 +- src/pydvl/value/shapley/common.py | 16 +- src/pydvl/value/shapley/gt.py | 29 ++-- src/pydvl/value/shapley/knn.py | 7 +- src/pydvl/value/shapley/montecarlo.py | 34 ++-- src/pydvl/value/shapley/naive.py | 6 +- src/pydvl/value/shapley/owen.py | 20 ++- src/pydvl/value/shapley/truncated.py | 36 ++-- src/pydvl/value/stopping.py | 58 ++++--- 29 files changed, 435 insertions(+), 420 deletions(-) diff --git a/src/pydvl/reporting/plots.py b/src/pydvl/reporting/plots.py index 8865a4958..ba483ad07 100644 --- a/src/pydvl/reporting/plots.py +++ b/src/pydvl/reporting/plots.py @@ -22,19 +22,18 @@ def shaded_mean_std( **kwargs, ) -> Axes: """The usual mean +- x std deviations plot to aggregate runs of experiments. - + Args: data: axis 0 is to be aggregated on (e.g. runs) and axis 1 is the - data for each run. - abscissa: values for the x axis. Leave empty to use increasing - integers. + data for each run. + abscissa: values for the x axis. Leave empty to use increasing integers. num_std: number of standard deviations to shade around the mean. mean_color: color for the mean shade_color: color for the shaded region - title: - xlabel: - ylabel: + title: Title text. To use mathematics, use LaTeX notation. + xlabel: Text for the horizontal axis. + ylabel: Text for the vertical axis ax: If passed, axes object into which to insert the figure. Otherwise, - a new figure is created and returned + a new figure is created and returned kwargs: these are forwarded to the ax.plot() call for the mean. Returns: @@ -59,76 +58,6 @@ def shaded_mean_std( return ax -def shapley_results(results: dict, filename: str = None): - """ - FIXME: change this to use dataframes - - results: dict - filename: For plt.savefig(). Set to None to disable saving. - - Here's an example results dictionary:: - - results = { - "all_values": num_runs x num_points - "backward_scores": num_runs x num_points, - "backward_scores_reversed": num_runs x num_points, - "backward_random_scores": num_runs x num_points, - "forward_scores": num_runs x num_points, - "forward_scores_reversed": num_runs x num_points, - "forward_random_scores": num_runs x num_points, - "max_iterations": int, - "score_name" str, - "num_points": int - } - """ - plt.figure(figsize=(16, 5)) - num_runs = len(results["all_values"]) - num_points = len(results["backward_scores"][0]) - use_points = int(0.6 * num_points) - - plt.subplot(1, 2, 1) - values = np.array(results["backward_scores"])[:, :use_points] - shaded_mean_std(values, color="b", label="By increasing shapley value") - - values = np.array(results["backward_scores_reversed"])[:, :use_points] - shaded_mean_std(values, color="g", label="By decreasing shapley value") - - values = np.array(results["backward_random_scores"])[:, :use_points] - shaded_mean_std(values, color="r", linestyle="--", label="At random") - - plt.ylabel(f'Score ({results.get("score_name")})') - plt.xlabel("Points removed") - plt.title( - f"Effect of point removal. " - f'MonteCarlo with {results.get("max_iterations")} iterations ' - f"over {num_runs} runs" - ) - plt.legend() - - plt.subplot(1, 2, 2) - - values = np.array(results["forward_scores"])[:, :use_points] - shaded_mean_std(values, color="b", label="By increasing shapley value") - - values = np.array(results["forward_scores_reversed"])[:, :use_points] - shaded_mean_std(values, color="g", label="By decreasing shapley value") - - values = np.array(results["forward_random_scores"])[:, :use_points] - shaded_mean_std(values, color="r", linestyle="--", label="At random") - - plt.ylabel(f'Score ({results.get("score_name")})') - plt.xlabel("Points added") - plt.title( - f"Effect of point addition. " - f'MonteCarlo with {results["max_iterations"]} iterations ' - f"over {num_runs} runs" - ) - plt.legend() - - if filename: - plt.savefig(filename, dpi=300) - - def spearman_correlation(vv: List[OrderedDict], num_values: int, pvalue: float): """Simple matrix plots with spearman correlation for each pair in vv. @@ -180,12 +109,14 @@ def plot_shapley( [compute_shapley_values()][pydvl.value.shapley.common.compute_shapley_values], with error bars corresponding to an $\alpha$-level confidence interval. + Args: df: dataframe with the shapley values level: confidence level for the error bars ax: axes to plot on or None if a new subplots should be created title: string, title of the plot xlabel: string, x label of the plot ylabel: string, y label of the plot + Returns: the axes created or used """ diff --git a/src/pydvl/reporting/scores.py b/src/pydvl/reporting/scores.py index df617c847..13a4eea4f 100644 --- a/src/pydvl/reporting/scores.py +++ b/src/pydvl/reporting/scores.py @@ -20,6 +20,7 @@ def compute_removal_score( r"""Fits model and computes score on the test set after incrementally removing a percentage of data points from the training set, based on their values. + Args: u: Utility object with model, data, and scoring function. values: Data values of data instances in the training set. percentages: Sequence of removal percentages. diff --git a/src/pydvl/utils/caching.py b/src/pydvl/utils/caching.py index 248dcbb78..fd8335bcf 100644 --- a/src/pydvl/utils/caching.py +++ b/src/pydvl/utils/caching.py @@ -166,27 +166,28 @@ def memcached( cached_fun = memcached(**asdict(cache_options))(heavy_computation) + Args: client_config: configuration for `pymemcache's Client() - `_. - Will be merged on top of the default configuration (see below). - time_threshold: computations taking less time than this many seconds - are not cached. + `_. + Will be merged on top of the default configuration (see below). + time_threshold: computations taking less time than this many seconds are + not cached. allow_repeated_evaluations: If `True`, repeated calls to a function - with the same arguments will be allowed and outputs averaged until the - running standard deviation of the mean stabilises below - `rtol_stderr * mean`. - rtol_stderr: relative tolerance for repeated evaluations. More - precisely, :func:`memcached` will stop evaluating the function once the - standard deviation of the mean is smaller than `rtol_stderr * mean`. + with the same arguments will be allowed and outputs averaged until the + running standard deviation of the mean stabilises below + `rtol_stderr * mean`. + rtol_stderr: relative tolerance for repeated evaluations. More precisely, + :func:`memcached` will stop evaluating the function once the + standard deviation of the mean is smaller than `rtol_stderr * mean`. min_repetitions: minimum number of times that a function evaluation - on the same arguments is repeated before returning cached values. Useful - for stochastic functions only. If the model training is very noisy, set - this number to higher values to reduce variance. + on the same arguments is repeated before returning cached values. Useful + for stochastic functions only. If the model training is very noisy, set + this number to higher values to reduce variance. ignore_args: Do not take these keyword arguments into account when - hashing the wrapped function for usage as key in memcached. This allows - sharing the cache among different jobs for the same experiment run if - the callable happens to have "nuisance" parameters like "job_id" which - do not affect the result of the computation. + hashing the wrapped function for usage as key in memcached. This allows + sharing the cache among different jobs for the same experiment run if + the callable happens to have "nuisance" parameters like "job_id" which + do not affect the result of the computation. Returns: A wrapped function diff --git a/src/pydvl/utils/config.py b/src/pydvl/utils/config.py index 39a070cc7..ac5c737aa 100644 --- a/src/pydvl/utils/config.py +++ b/src/pydvl/utils/config.py @@ -64,24 +64,24 @@ class MemcachedConfig: Instances of this class are typically used as arguments for the construction of a :class:`~pydvl.utils.utility.Utility`. - client_config: Configuration for the connection to the memcached - server. - time_threshold: computations taking less time than this many seconds - are not cached. + Args: + client_config: Configuration for the connection to the memcached server. + time_threshold: computations taking less time than this many seconds are + not cached. allow_repeated_evaluations: If `True`, repeated calls to a function - with the same arguments will be allowed and outputs averaged until the - running standard deviation of the mean stabilises below - `rtol_stderr * mean`. - rtol_stderr: relative tolerance for repeated evaluations. More - precisely, [memcached()][pydvl.utils.caching.memcached] will stop evaluating - the function once the standard deviation of the mean is smaller than - `rtol_stderr * mean`. + with the same arguments will be allowed and outputs averaged until the + running standard deviation of the mean stabilises below + `rtol_stderr * mean`. + rtol_stderr: relative tolerance for repeated evaluations. More precisely, + [memcached()][pydvl.utils.caching.memcached] will stop evaluating + the function once the standard deviation of the mean is smaller than + `rtol_stderr * mean`. min_repetitions: minimum number of times that a function evaluation - on the same arguments is repeated before returning cached values. Useful - for stochastic functions only. If the model training is very noisy, set - this number to higher values to reduce variance. - ignore_args: Do not take these keyword arguments into account when - hashing the wrapped function for usage as key in memcached. + on the same arguments is repeated before returning cached values. Useful + for stochastic functions only. If the model training is very noisy, set + this number to higher values to reduce variance. + ignore_args: Do not take these keyword arguments into account when hashing + the wrapped function for usage as key in memcached. """ client_config: MemcachedClientConfig = field(default_factory=MemcachedClientConfig) diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index 2246df0ac..c938c1eb7 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -57,19 +57,20 @@ def __init__( ): """Constructs a Dataset from data and labels. - x_train: training data - y_train: labels for training data - x_test: test data - y_test: labels for test data - feature_names: name of the features of input data - target_names: names of the features of target data - data_names: names assigned to data points. - For example, if the dataset is a time series, each entry can be a - timestamp which can be referenced directly instead of using a row - number. - description: A textual description of the dataset. - is_multi_output: set to ``False`` if labels are scalars, or to - ``True`` if they are vectors of dimension > 1. + Args: + x_train: training data + y_train: labels for training data + x_test: test data + y_test: labels for test data + feature_names: name of the features of input data + target_names: names of the features of target data + data_names: names assigned to data points. + For example, if the dataset is a time series, each entry can be a + timestamp which can be referenced directly instead of using a row + number. + description: A textual description of the dataset. + is_multi_output: set to ``False`` if labels are scalars, or to + ``True`` if they are vectors of dimension > 1. """ self.x_train, self.y_train = check_X_y( x_train, y_train, multi_output=is_multi_output @@ -149,9 +150,9 @@ def get_training_data( subsets of the data from indices. It is typically **not needed in algorithms**. - indices: Optional indices that will be used to select points - from the training data. If ``None``, the entire training data will - be returned. + Args: + indices: Optional indices that will be used to select points from the + training data. If ``None``, the entire training data will be returned. Returns: If ``indices`` is not ``None``, the selected x and y arrays from the training data. Otherwise, the entire dataset. @@ -202,12 +203,11 @@ class and to override the :meth:`~Dataset.get_test_data` method. >>> _ = dataset.get_training_data(indices) >>> _ = dataset.get_test_data(indices) - - indices: Optional indices into the test data. This argument - is unused and is left as is to keep the same interface as - :meth:`Dataset.get_training_data`. + Args: + indices: Optional indices into the test data. This argument is + unused left for compatibility with :meth:`Dataset.get_training_data`. Returns: - The entire test data. + The entire test data. """ return self.x_test, self.y_test @@ -255,27 +255,24 @@ def from_sklearn( ) -> "Dataset": """Constructs a :class:`Dataset` object from an :class:`sklearn.utils.Bunch`, as returned by the `load_*` functions in - `sklearn toy datasets - `_. + `sklearn toy datasets `_. + Args: data: sklearn dataset. The following attributes are supported - - ``data``: covariates [required] - - ``target``: target variables (labels) [required] - - ``feature_names``: the feature names - - ``target_names``: the target names - - ``DESCR``: a description - train_size: size of the training dataset. Used in - `train_test_split` + - ``data``: covariates [required] + - ``target``: target variables (labels) [required] + - ``feature_names``: the feature names + - ``target_names``: the target names + - ``DESCR``: a description + train_size: size of the training dataset. Used in `train_test_split` random_state: seed for train / test split stratify_by_target: If `True`, data is split in a stratified - fashion, using the target variable as labels. Read more in - `scikit-learn's user guide - `. + fashion, using the target variable as labels. Read more in + [scikit-learn's user guide](https://scikit-learn.org/stable/modules/cross_validation.html#stratification). kwargs: Additional keyword arguments to pass to the - :class:`Dataset` constructor. Use this to pass e.g. ``is_multi_output``. + :class:`Dataset` constructor. Use this to pass e.g. ``is_multi_output``. Returns: - Object with the sklearn dataset + Object with the sklearn dataset !!! version-changed 0.6.0 Added kwargs to pass to the :class:`Dataset` constructor. @@ -309,25 +306,21 @@ def from_arrays( **kwargs, ) -> "Dataset": """Constructs a :class:`Dataset` object from X and y numpy arrays as - returned by the `make_*` functions in `sklearn generated datasets - `_. + returned by the `make_*` functions in [sklearn generated datasets](https://scikit-learn.org/stable/datasets/sample_generators.html). + Args: X: numpy array of shape (n_samples, n_features) y: numpy array of shape (n_samples,) - train_size: size of the training dataset. Used in - `train_test_split` + train_size: size of the training dataset. Used in `train_test_split` random_state: seed for train / test split - stratify_by_target: If `True`, data is split in a stratified - fashion, using the y variable as labels. Read more in - `sklearn's user guide - `. + stratify_by_target: If `True`, data is split in a stratified fashion, + using the y variable as labels. Read more in [sklearn's user + guide](https://scikit-learn.org/stable/modules/cross_validation.html#stratification). kwargs: Additional keyword arguments to pass to the - :class:`Dataset` constructor. Use this to pass e.g. ``feature_names`` - or ``target_names``. + :class:`Dataset` constructor. Use this to pass e.g. ``feature_names`` + or ``target_names``. Returns: - Object with the passed X and y arrays split across training - and test sets. + Object with the passed X and y arrays split across training and test sets. !!! version-added 0.4.0 @@ -364,22 +357,23 @@ def __init__( as logical units. For instance, one can group by value of a categorical feature, by bin into which a continuous feature falls, or by label. + Args: x_train: training data y_train: labels of training data x_test: test data y_test: labels of test data data_groups: Iterable of the same length as ``x_train`` containing - a group label for each training data point. The label can be of any - type, e.g. ``str`` or ``int``. Data points with the same label will - then be grouped by this object and considered as one for effects of - valuation. + a group label for each training data point. The label can be of any + type, e.g. ``str`` or ``int``. Data points with the same label will + then be grouped by this object and considered as one for effects of + valuation. feature_names: names of the covariates' features. target_names: names of the labels or targets y group_names: names of the groups. If not provided, the labels - from ``data_groups`` will be used. + from ``data_groups`` will be used. description: A textual description of the dataset kwargs: Additional keyword arguments to pass to the - :class:`Dataset` constructor. + :class:`Dataset` constructor. !!! version-changed 0.6.0 Added ``group_names`` and forwarding of ``kwargs`` @@ -432,10 +426,11 @@ def get_training_data( ) -> Tuple[NDArray, NDArray]: """Returns the data and labels of all samples in the given groups. + Args: indices: group indices whose elements to return. If ``None``, all data from all groups are returned. Returns: - Tuple of training data x and labels y. + Tuple of training data x and labels y. """ if indices is None: indices = self.indices @@ -459,27 +454,25 @@ def from_sklearn( `_ and groups it. + Args: data: sklearn dataset. The following attributes are supported - - ``data``: covariates [required] - - ``target``: target variables (labels) [required] - - ``feature_names``: the feature names - - ``target_names``: the target names - - ``DESCR``: a description - train_size: size of the training dataset. Used in - `train_test_split`. + - ``data``: covariates [required] + - ``target``: target variables (labels) [required] + - ``feature_names``: the feature names + - ``target_names``: the target names + - ``DESCR``: a description + train_size: size of the training dataset. Used in `train_test_split`. random_state: seed for train / test split. stratify_by_target: If ``True``, data is split in a stratified - fashion, using the target variable as labels. Read more in - `sklearn's user guide - `. + fashion, using the target variable as labels. Read more in + `sklearn's user guide `. data_groups: an array holding the group index or name for each data point. The length of this array must be equal to the number of data points in the dataset. kwargs: Additional keyword arguments to pass to the - :class:`Dataset` constructor. + :class:`Dataset` constructor. Returns: - Dataset with the selected sklearn data + Dataset with the selected sklearn data """ if data_groups is None: raise ValueError( @@ -515,24 +508,22 @@ def from_arrays( as returned by the `make_*` functions in `sklearn generated datasets `_. + Args: X: array of shape (n_samples, n_features) y: array of shape (n_samples,) - train_size: size of the training dataset. Used in - ``train_test_split``. + train_size: size of the training dataset. Used in ``train_test_split``. random_state: seed for train / test split. stratify_by_target: If ``True``, data is split in a stratified - fashion, using the y variable as labels. Read more in - `sklearn's user guide - `. + fashion, using the y variable as labels. Read more in + `sklearn's user guide `. data_groups: an array holding the group index or name for each - data point. The length of this array must be equal to the number of - data points in the dataset. + data point. The length of this array must be equal to the number of + data points in the dataset. kwargs: Additional keyword arguments that will be passed - to the :class:`~pydvl.utils.dataset.Dataset` constructor. + to the :class:`~pydvl.utils.dataset.Dataset` constructor. Returns: - Dataset with the passed X and y arrays split across training + Dataset with the passed X and y arrays split across training and test sets. !!! version-added 0.4.0 @@ -564,12 +555,13 @@ def from_dataset( """Creates a :class:`GroupedDataset` object from the data a :class:`Dataset` object and a mapping of data groups. + Args: dataset: The original data. - data_groups: An array holding the group index or name for each - data point. The length of this array must be equal to the number of - data points in the dataset. + data_groups: An array holding the group index or name for each data + point. The length of this array must be equal to the number of + data points in the dataset. Returns: - A :class:`GroupedDataset` with the initial :class:`Dataset` + A :class:`GroupedDataset` with the initial :class:`Dataset` grouped by data_groups. """ return cls( @@ -598,6 +590,7 @@ def load_spotify_dataset( If this method is called within the CI pipeline, it will load a reduced version of the dataset for testing purposes. + Args: val_size: size of the validation set test_size: size of the test set min_year: minimum year of the returned data @@ -634,6 +627,7 @@ def load_wine_dataset( """Loads the sklearn wine dataset. More info can be found at https://scikit-learn.org/stable/datasets/toy_dataset.html#wine-recognition-dataset. + Args: train_size: fraction of points used for training dataset test_size: fraction of points used for test dataset random_state: fix random seed. If None, no random seed is set. @@ -692,6 +686,7 @@ def synthetic_classification_dataset( ) -> Tuple[Tuple[Any, Any], Tuple[Any, Any], Tuple[Any, Any]]: """Sample from a uniform Gaussian mixture model. + Args: mus: 2d-matrix [CxD] with the means of the components in the rows. sigma: Standard deviation of each dimension of each component. num_samples: The number of samples to generate. @@ -726,8 +721,10 @@ def synthetic_classification_dataset( def decision_boundary_fixed_variance_2d( mu_1: np.ndarray, mu_2: np.ndarray ) -> Callable[[np.ndarray], np.ndarray]: - """ - Closed-form solution for decision boundary dot(a, b) + b = 0 with fixed variance. + """ Closed-form solution for decision boundary dot(a, b) + b = 0 with fixed + variance. + + Args: mu_1: First mean. mu_2: Second mean. Returns: diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index cd619bf7e..12fd1a3bb 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -38,10 +38,10 @@ def powerset(s: NDArray[T]) -> Iterator[Collection[T]]: >>> list(powerset(np.array((1,2)))) [(), (1,), (2,), (1, 2)] + Args: s: The set to use Returns: An iterator - :raises TypeError: If the argument is not an ``Iterable``. """ return chain.from_iterable(combinations(s, r) for r in range(len(s) + 1)) @@ -54,6 +54,7 @@ def num_samples_permutation_hoeffding(eps: float, delta: float, u_range: float) be ε-close to the true quantity, if at least this many permutations are sampled. + Args: eps: ε > 0 delta: 0 < δ <= 1 u_range: Range of the :class:`~pydvl.utils.utility.Utility` function @@ -67,9 +68,10 @@ def num_samples_permutation_hoeffding(eps: float, delta: float, u_range: float) def random_subset(s: NDArray[T], q: float = 0.5) -> NDArray[T]: """Returns one subset at random from ``s``. + Args: s: set to sample from q: Sampling probability for elements. The default 0.5 yields a - uniform distribution over the power set of s. + uniform distribution over the power set of s. Returns: the subset """ @@ -92,20 +94,19 @@ def random_powerset( :func:`Owen sampling `. + Args: s: set to sample from n_samples: if set, stop the generator after this many steps. - Defaults to `np.iinfo(np.int32).max` + Defaults to `np.iinfo(np.int32).max` q: Sampling probability for elements. The default 0.5 yields a - uniform distribution over the power set of s. + uniform distribution over the power set of s. Returns: Samples from the power set of s - :raises: TypeError: if the data `s` is not a NumPy array + :raises: ValueError: if the element sampling probability is not in [0,1] """ - if not isinstance(s, np.ndarray): - raise TypeError("Set must be an NDArray") if q < 0 or q > 1: raise ValueError("Element sampling probability must be in [0,1]") @@ -121,10 +122,12 @@ def random_subset_of_size(s: NDArray[T], size: int) -> NDArray[T]: """Samples a random subset of given size uniformly from the powerset of ``s``. + Args: s: Set to sample from size: Size of the subset to generate Returns: The subset + :raises ValueError: If size > len(s) """ if size > len(s): @@ -142,6 +145,7 @@ def random_matrix_with_condition_number(n: int, condition_number: float) -> "NDA Also see: https://math.stackexchange.com/questions/1351616/condition-number-of-ata. + Args: n: size of the matrix condition_number: duh Returns: @@ -173,6 +177,7 @@ def linear_regression_analytical_derivative_d_theta( linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", y: "NDArray" ) -> "NDArray": """ + Args: linear_model: A tuple of np.ndarray' of shape [NxM] and [N] representing A and b respectively. x: A np.ndarray of shape [BxM]. y: A np.nparray of shape [BxN]. @@ -193,11 +198,14 @@ def linear_regression_analytical_derivative_d2_theta( linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", y: "NDArray" ) -> "NDArray": """ - linear_model: A tuple of np.ndarray' of shape [NxM] and [N] representing A and b respectively. - x: A np.ndarray of shape [BxM], - y: A np.nparray of shape [BxN]. + Args: + linear_model: A tuple of arrays of shape [NxM] and [N] representing A + and b respectively. + x: An array of shape [BxM], + y: An array of shape [BxN]. Returns: - A np.ndarray of shape [((N+1)*M)x((N+1)*M)], representing the Hessian. It gets averaged over all samples. + An array of shape [((N+1)*M)x((N+1)*M)], representing the Hessian. + It gets averaged over all samples. """ A, b = linear_model n, m = tuple(A.shape) @@ -217,6 +225,7 @@ def linear_regression_analytical_derivative_d_x_d_theta( linear_model: Tuple["NDArray", "NDArray"], x: "NDArray", y: "NDArray" ) -> "NDArray": """ + Args: linear_model: A tuple of np.ndarray of shape [NxM] and [N] representing A and b respectively. x: A np.ndarray of shape [BxM]. y: A np.nparray of shape [BxN]. @@ -276,7 +285,7 @@ def running_moments( This could be generalised to arbitrary moments. See `this paper `_ - + Args: previous_avg: average value at previous step previous_variance: variance at previous step count: number of points seen so far @@ -298,6 +307,7 @@ def top_k_value_accuracy( """Computes the top-k accuracy for the estimated values by comparing indices of the highest k values. + Args: y_true: Exact/true value y_pred: Predicted/estimated value k: Number of the highest values taken into account diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index 3cf340a51..877c2a35a 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -97,6 +97,7 @@ class SequentialParallelBackend(BaseParallelBackend, backend_name="sequential"): It shouldn't be initialized directly. You should instead call [init_parallel_backend()][pydvl.utils.parallel.backend.init_parallel_backend]. + Args: config: instance of :class:`~pydvl.utils.config.ParallelConfig` with number of cpus """ @@ -128,6 +129,7 @@ class RayParallelBackend(BaseParallelBackend, backend_name="ray"): It shouldn't be initialized directly. You should instead call [init_parallel_backend()][pydvl.utils.parallel.backend.init_parallel_backend]. + Args: config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. """ @@ -165,11 +167,12 @@ def put(self, v: T, *args, **kwargs) -> Union["ObjectRef[T]", T]: def wrap(self, fun: Callable, **kwargs) -> Callable: """Wraps a function as a ray remote. + Args: fun: the function to wrap kwargs: keyword arguments to pass to @ray.remote Returns: - The `.remote` method of the ray `RemoteFunction`. + The `.remote` method of the ray `RemoteFunction`. """ if len(kwargs) > 0: return ray.remote(**kwargs)(fun).remote # type: ignore @@ -203,8 +206,9 @@ def init_parallel_backend( ) -> BaseParallelBackend: """Initializes the parallel backend and returns an instance of it. + Args: config: instance of :class:`~pydvl.utils.config.ParallelConfig` - with cluster address, number of cpus, etc. + with cluster address, number of cpus, etc. :Example: @@ -244,12 +248,14 @@ def effective_n_jobs(n_jobs: int, config: ParallelConfig = ParallelConfig()) -> This number may vary depending on the parallel backend and the resources available. + Args: n_jobs: the number of jobs requested. If -1, the number of available - CPUs is returned. + CPUs is returned. config: instance of :class:`~pydvl.utils.config.ParallelConfig` with - cluster address, number of cpus, etc. + cluster address, number of cpus, etc. Returns: - the effective number of jobs, guaranteed to be >= 1. + The effective number of jobs, guaranteed to be >= 1. + :raises RuntimeError: if the effective number of jobs returned by the backend is < 1. """ diff --git a/src/pydvl/utils/parallel/futures/__init__.py b/src/pydvl/utils/parallel/futures/__init__.py index 7291eec29..00cde41b7 100644 --- a/src/pydvl/utils/parallel/futures/__init__.py +++ b/src/pydvl/utils/parallel/futures/__init__.py @@ -16,11 +16,12 @@ def init_executor( ) -> Generator[Executor, None, None]: """Initializes a futures executor based on the passed parallel configuration object. + Args: max_workers: Maximum number of concurrent tasks. config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. kwargs: Other optional parameter that will be passed to the executor. - :Example: + Examples: >>> from pydvl.utils.parallel.futures import init_executor >>> from pydvl.utils.config import ParallelConfig diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index ca15c7d84..cc3453b1e 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -27,18 +27,17 @@ class RayExecutor(Executor): It shouldn't be initialized directly. You should instead call [init_executor()][pydvl.utils.parallel.futures.init_executor]. - max_workers: Maximum number of concurrent tasks. Each task can - request itself any number of vCPUs. You must ensure the product - of this value and the n_cpus_per_job parameter passed to submit() - does not exceed available cluster resources. - If set to None, it will default to the total number of vCPUs - in the ray cluster. + max_workers: Maximum number of concurrent tasks. Each task can request + itself any number of vCPUs. You must ensure the product of this + value and the n_cpus_per_job parameter passed to submit() does not + exceed available cluster resources. If set to `None`, it will + default to the total number of vCPUs in the ray cluster. config: instance of :class:`~pydvl.utils.config.ParallelConfig` - with cluster address, number of cpus, etc. + with cluster address, number of cpus, etc. cancel_futures_on_exit: If ``True``, all futures will be cancelled - when exiting the context created by using this class instance as a - context manager. It will be ignored when calling :meth:`shutdown` - directly. + when exiting the context created by using this class instance as a + context manager. It will be ignored when calling :meth:`shutdown` + directly. """ def __init__( @@ -92,13 +91,15 @@ def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": Schedules the callable to be executed as fn(\*args, \**kwargs) and returns a Future instance representing the execution of the callable. + Args: fn: Callable. args: Positional arguments that will be passed to ``fn``. kwargs: Keyword arguments that will be passed to ``fn``. - It can also optionally contain options for the ray remote function - as a dictionary as the keyword argument `remote_function_options`. + It can also optionally contain options for the ray remote function + as a dictionary as the keyword argument `remote_function_options`. Returns: - A Future representing the given call. + A Future representing the given call. + :raises RuntimeError: If a task is submitted after the executor has been shut down. """ with self._shutdown_lock: @@ -217,7 +218,7 @@ class _WorkItemManagerThread(threading.Thread): """Manages submitting the work items and throttling. It runs in a local thread. - + Args: executor: An instance of RayExecutor that owns this thread. A weakref will be owned by the manager as well as references to internal objects used to introspect the state of diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index 2b686ffb4..05f9ed652 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -82,28 +82,29 @@ class MapReduceJob(Generic[T, R]): Typing information for objects of this class requires the type of the inputs that are split for ``map_func`` and the type of its output. + Args: inputs: The input that will be split and passed to `map_func`. - if it's not a sequence object. It will be repeat ``n_jobs`` number of times. + if it's not a sequence object. It will be repeat ``n_jobs`` number of times. map_func: Function that will be applied to the input chunks in each job. reduce_func: Function that will be applied to the results of - ``map_func`` to reduce them. + ``map_func`` to reduce them. map_kwargs: Keyword arguments that will be passed to ``map_func`` in - each job. Alternatively, one can use ``itertools.partial``. + each job. Alternatively, one can use ``itertools.partial``. reduce_kwargs: Keyword arguments that will be passed to ``reduce_func`` - in each job. Alternatively, one can use [itertools.partial][]. + in each job. Alternatively, one can use [itertools.partial][]. config: Instance of :class:`~pydvl.utils.config.ParallelConfig` - with cluster address, number of cpus, etc. + with cluster address, number of cpus, etc. n_jobs: Number of parallel jobs to run. Does not accept 0 timeout: Amount of time in seconds to wait for remote results before - ... TODO + ... TODO max_parallel_tasks: Maximum number of jobs to start in parallel. Any - tasks above this number won't be submitted to the backend before some - are done. This is to avoid swamping the work queue. Note that tasks have - a low memory footprint, so this is probably not a big concern, except - in the case of an infinite stream (not the case for MapReduceJob). See - https://docs.ray.io/en/latest/ray-core/patterns/limit-pending-tasks.html + tasks above this number won't be submitted to the backend before some + are done. This is to avoid swamping the work queue. Note that tasks have + a low memory footprint, so this is probably not a big concern, except + in the case of an infinite stream (not the case for MapReduceJob). See + the [ray docs](https://docs.ray.io/en/latest/ray-core/patterns/limit-pending-tasks.html) - :Examples: + Examples: A simple usage example with 2 jobs: @@ -222,11 +223,12 @@ def _wrap_function(self, func: Callable, **kwargs) -> Callable: """Wraps a function with a timeout and remote arguments and puts it on the remote backend. + Args: func: Function to wrap kwargs: Additional keyword arguments to pass to the backend wrapper. These are *not* arguments for the wrapped function. Returns: - Remote function that can be called with the same arguments as + Remote function that can be called with the same arguments as the wrapped function. Depending on the backend, this may simply be the function itself. """ @@ -237,11 +239,12 @@ def _wrap_function(self, func: Callable, **kwargs) -> Callable: def _backpressure( self, jobs: List[ObjectRef], n_dispatched: int, n_finished: int ) -> int: - """This is used to limit the number of concurrent tasks. - If [max_parallel_tasks][pydvl.utils.parallel.map_reduce.MapReduceJob.max_parallel_tasks] is None then this function - is a no-op that simply returns 0. + """Used to limit the number of concurrent tasks. + If [max_parallel_tasks][pydvl.utils.parallel.map_reduce.MapReduceJob.max_parallel_tasks] + is None then this function is a no-op that simply returns 0. - See https://docs.ray.io/en/latest/ray-core/patterns/limit-pending-tasks.html + See [ray's documentation](https://docs.ray.io/en/latest/ray-core/patterns/limit-pending-tasks.html) + Args: jobs: n_dispatched: n_finished: diff --git a/src/pydvl/utils/progress.py b/src/pydvl/utils/progress.py index 09dd301a3..a96aeecca 100644 --- a/src/pydvl/utils/progress.py +++ b/src/pydvl/utils/progress.py @@ -57,6 +57,7 @@ def maybe_progress( """Returns either a tqdm progress bar or a mock object which wraps the iterator as well, but ignores any accesses to methods or properties. + Args: it: the iterator to wrap display: set to True to return a tqdm bar kwargs: Keyword arguments that will be forwarded to tqdm diff --git a/src/pydvl/utils/score.py b/src/pydvl/utils/score.py index 561ac7fed..19331ce24 100644 --- a/src/pydvl/utils/score.py +++ b/src/pydvl/utils/score.py @@ -35,18 +35,18 @@ class Scorer: """A scoring callable that takes a model, data, and labels and returns a scalar. + Args: scoring: Either a string or callable that can be passed to - `get_scorer - `_. + `get_scorer `_. default: score to be used when a model cannot be fit, e.g. when too - little data is passed, or errors arise. + little data is passed, or errors arise. range: numerical range of the score function. Some Monte Carlo - methods can use this to estimate the number of samples required for a - certain quality of approximation. If not provided, it can be read from - the ``scoring`` object if it provides it, for instance if it was - constructed with [compose_score()][pydvl.utils.types.compose_score]. + methods can use this to estimate the number of samples required for a + certain quality of approximation. If not provided, it can be read from + the ``scoring`` object if it provides it, for instance if it was + constructed with [compose_score()][pydvl.utils.types.compose_score]. name: The name of the scorer. If not provided, the name of the - function passed will be used. + function passed will be used. !!! version-added 0.5.0 @@ -92,16 +92,18 @@ def compose_score( Useful to squash unbounded scores into ranges manageable by data valuation methods. - .. code-block:: python - :caption: Example usage + Example: - sigmoid = lambda x: 1/(1+np.exp(-x)) - compose_score(Scorer("r2"), sigmoid, range=(0,1), name="squashed r2") + ```python + sigmoid = lambda x: 1/(1+np.exp(-x)) + compose_score(Scorer("r2"), sigmoid, range=(0,1), name="squashed r2") + ``` + Args: scorer: The object to be composed. transformation: A scalar transformation range: The range of the transformation. This will be used e.g. by - :class:`~pydvl.utils.utility.Utility` for the range of the composed. + :class:`~pydvl.utils.utility.Utility` for the range of the composed. name: A string representation for the composition, for `str()`. Returns: The composite :class:`Scorer`. diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index c93600623..a2da3bafe 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -37,7 +37,7 @@ def maybe_add_argument(fun: Callable, new_arg: str): fun: The function to wrap new_arg: The name of the argument that the new function will accept - (and ignore). + (and ignore). Returns: A new function accepting one more keyword argument. """ diff --git a/src/pydvl/value/least_core/__init__.py b/src/pydvl/value/least_core/__init__.py index 504411a58..b4aa155bc 100644 --- a/src/pydvl/value/least_core/__init__.py +++ b/src/pydvl/value/least_core/__init__.py @@ -62,15 +62,15 @@ def compute_least_core_values( - ``montecarlo``: uses the approximate Monte Carlo Least Core algorithm. Implemented in [montecarlo_least_core()][pydvl.value.least_core.montecarlo.montecarlo_least_core]. + Args: u: Utility object with model, data, and scoring function n_jobs: Number of jobs to run in parallel. Only used for Monte Carlo - Least Core. + Least Core. n_iterations: Number of subsets to sample and evaluate the utility on. - Only used for Monte Carlo Least Core. - mode: Algorithm to use. See :class:`LeastCoreMode` for available - options. + Only used for Monte Carlo Least Core. + mode: Algorithm to use. See :class:`LeastCoreMode` for available options. non_negative_subsidy: If True, the least core subsidy $e$ is constrained - to be non-negative. + to be non-negative. solver_options: Optional dictionary of options passed to the solvers. Returns: diff --git a/src/pydvl/value/least_core/common.py b/src/pydvl/value/least_core/common.py index cf82ffe72..874d4ccfd 100644 --- a/src/pydvl/value/least_core/common.py +++ b/src/pydvl/value/least_core/common.py @@ -169,16 +169,18 @@ def lc_solve_problems( ) -> List[ValuationResult]: """Solves a list of linear problems in parallel. + Args: u: Utility. problems: Least Core problems to solve, as returned by - [mclc_prepare_problem()][pydvl.value.least_core.montecarlo.mclc_prepare_problem]. + [mclc_prepare_problem()][pydvl.value.least_core.montecarlo.mclc_prepare_problem]. algorithm: Name of the valuation algorithm. - config: Object configuring parallel computation, with cluster - address, number of cpus, etc. + config: Object configuring parallel computation, with cluster address, + number of cpus, etc. n_jobs: Number of parallel jobs to run. non_negative_subsidy: If True, the least core subsidy $e$ is constrained - to be non-negative. + to be non-negative. solver_options: Additional options to pass to the solver. + Returns: List of solutions. """ @@ -233,19 +235,20 @@ def _solve_least_core_linear_program( if `non_negative_subsidy` is True, then an additional constraint $e \ge 0$ is used. + Args: A_eq: The equality constraint matrix. Each row of ``A_eq`` specifies the - coefficients of a linear equality constraint on ``x``. + coefficients of a linear equality constraint on ``x``. b_eq: The equality constraint vector. Each element of ``A_eq @ x`` must equal - the corresponding element of ``b_eq``. + the corresponding element of ``b_eq``. A_lb: The inequality constraint matrix. Each row of ``A_lb`` specifies the - coefficients of a linear inequality constraint on ``x``. + coefficients of a linear inequality constraint on ``x``. b_lb: The inequality constraint vector. Each element represents a - lower bound on the corresponding value of ``A_lb @ x``. - non_negative_subsidy: If True, the least core subsidy $e$ is constrained - to be non-negative. + lower bound on the corresponding value of ``A_lb @ x``. + non_negative_subsidy: If True, the least core subsidy $e$ is constrained + to be non-negative. options: Keyword arguments that will be used to select a solver - and to configure it. For all possible options, refer to `cvxpy's documentation - `_ + and to configure it. For all possible options, refer to [cvxpy's + documentation](https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options). """ logger.debug(f"Solving linear program : {A_eq=}, {b_eq=}, {A_lb=}, {b_lb=}") @@ -309,18 +312,20 @@ def _solve_egalitarian_least_core_quadratic_program( :math:`b_{ub}`, :math:`b_{eq}`, :math:`l`, and :math:`u` are vectors; and :math:`A_{ub}` and :math:`A_{eq}` are matrices. + Args: subsidy: Minimal subsidy returned by :func:`_solve_least_core_linear_program` A_eq: The equality constraint matrix. Each row of ``A_eq`` specifies the - coefficients of a linear equality constraint on ``x``. + coefficients of a linear equality constraint on ``x``. b_eq: The equality constraint vector. Each element of ``A_eq @ x`` must equal - the corresponding element of ``b_eq``. + the corresponding element of ``b_eq``. A_lb: The inequality constraint matrix. Each row of ``A_lb`` specifies the - coefficients of a linear inequality constraint on ``x``. + coefficients of a linear inequality constraint on ``x``. b_lb: The inequality constraint vector. Each element represents a - lower bound on the corresponding value of ``A_lb @ x``. + lower bound on the corresponding value of ``A_lb @ x``. solver_options: Keyword arguments that will be used to select a solver - and to configure it. Refer to the following page for all possible options: - https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options + and to configure it. Refer to [cvxpy's + documentation](https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options) + for all possible options. """ logger.debug(f"Solving quadratic program : {A_eq=}, {b_eq=}, {A_lb=}, {b_lb=}") diff --git a/src/pydvl/value/least_core/montecarlo.py b/src/pydvl/value/least_core/montecarlo.py index 1bc1eeb29..49bc23a72 100644 --- a/src/pydvl/value/least_core/montecarlo.py +++ b/src/pydvl/value/least_core/montecarlo.py @@ -47,18 +47,22 @@ def montecarlo_least_core( * $m$ is the number of subsets that will be sampled and whose utility will be computed and used to compute the data values. + Args: u: Utility object with model, data, and scoring function n_iterations: total number of iterations to use n_jobs: number of jobs across which to distribute the computation config: Object configuring parallel computation, with cluster - address, number of cpus, etc. + address, number of cpus, etc. non_negative_subsidy: If True, the least core subsidy $e$ is constrained - to be non-negative. + to be non-negative. solver_options: Dictionary of options that will be used to select a solver - and to configure it. Refer to the following page for all possible options: - https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options - options: (Deprecated) Dictionary of solver options. Use solver_options instead. + and to configure it. Refer to [cvxpy's + documentation](https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options) + for all possible options. + options: (Deprecated) Dictionary of solver options. Use solver_options + instead. progress: If True, shows a tqdm progress bar + Returns: Object with the data values and the least core value. """ @@ -139,6 +143,7 @@ def _montecarlo_least_core( ) -> LeastCoreProblem: """Computes utility values and the Least Core upper bound matrix for a given number of iterations. + Args: u: Utility object with model, data, and scoring function n_iterations: total number of iterations to use progress: If True, shows a tqdm progress bar diff --git a/src/pydvl/value/least_core/naive.py b/src/pydvl/value/least_core/naive.py index 01f0b76c1..3a342e9b6 100644 --- a/src/pydvl/value/least_core/naive.py +++ b/src/pydvl/value/least_core/naive.py @@ -42,13 +42,16 @@ def exact_least_core( Where $N = \{1, 2, \dots, n\}$ are the training set's indices. + Args: u: Utility object with model, data, and scoring function - non_negative_subsidy: If True, the least core subsidy $e$ is constrained - to be non-negative. + non_negative_subsidy: If True, the least core subsidy $e$ is constrained + to be non-negative. solver_options: Dictionary of options that will be used to select a solver - and to configure it. Refer to the following page for all possible options: - https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options - options: (Deprecated) Dictionary of solver options. Use solver_options instead. + and to configure it. Refer to the [cvxpy's + documentation](https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options) + for all possible options. + options: (Deprecated) Dictionary of solver options. Use `solver_options` + instead. progress: If True, shows a tqdm progress bar Returns: diff --git a/src/pydvl/value/loo/naive.py b/src/pydvl/value/loo/naive.py index bda3f9094..d13f371df 100644 --- a/src/pydvl/value/loo/naive.py +++ b/src/pydvl/value/loo/naive.py @@ -12,6 +12,7 @@ def naive_loo(u: Utility, *, progress: bool = True) -> ValuationResult: $$v(i) = u(D) - u(D \setminus \{i\}) $$ + Args: u: Utility object with model, data, and scoring function progress: If True, display a progress bar Returns: diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index a069b5cce..0b16b28fb 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -7,7 +7,7 @@ indexing and updating abilities, and conversion to `pandas DataFrames `_. -.. rubric:: Operating on results +# Operating on results Results can be added together with the standard ``+`` operator. Because values are typically running averages of iterative algorithms, addition behaves like a @@ -26,7 +26,7 @@ returned. These objects can be compared with the usual operators, which take only the [ValueItem.value][ValueItem.value] into account. -.. rubric:: Creating result objects +# Creating result objects The most commonly used factory method is :meth:`ValuationResult.zeros`, which creates a result object with all values, variances and counts set to zero. @@ -177,25 +177,24 @@ class ValuationResult( Empty objects behave in a special way, see :meth:`empty`. + Args: values: An array of values. If omitted, defaults to an empty array - or to an array of zeros if ``indices`` are given. + or to an array of zeros if ``indices`` are given. indices: An optional array of indices in the original dataset. If - omitted, defaults to ``np.arange(len(values))``. **Warning:** It is - common to pass the indices of a :class:`Dataset` here. Attention must be - paid in a parallel context to copy them to the local process. Just do - ``indices=np.copy(data.indices)``. - variance: An optional array of variances in the computation of each - value. + omitted, defaults to ``np.arange(len(values))``. **Warning:** It is + common to pass the indices of a :class:`Dataset` here. Attention must be + paid in a parallel context to copy them to the local process. Just do + ``indices=np.copy(data.indices)``. + variance: An optional array of variances in the computation of each value. counts: An optional array with the number of updates for each value. - Defaults to an array of ones. - data_names: Names for the data points. Defaults to index numbers - if not set. + Defaults to an array of ones. + data_names: Names for the data points. Defaults to index numbers if not set. algorithm: The method used. status: The end status of the algorithm. sort: Whether to sort the indices by ascending value. See above how - this affects usage as an iterable or sequence. + this affects usage as an iterable or sequence. extra_values: Additional values that can be passed as keyword arguments. - This can contain, for example, the least core value. + This can contain, for example, the least core value. :raise ValueError: If input arrays have mismatching lengths. """ @@ -272,10 +271,12 @@ def sort( Once sorted, iteration over the results, and indexing of all the properties [ValuationResult.values][ValuationResult.values], - [ValuationResult.variances`, :attr:`ValuationResult.counts][ValuationResult.variances`, :attr:`ValuationResult.counts], - [ValuationResult.indices` and :attr:`ValuationResult.names][ValuationResult.indices` and :attr:`ValuationResult.names] will - follow the same order. + [ValuationResult.variances][ValuationResult.variances], + [ValuationResult.counts][ValuationResult.counts], + [ValuationResult.indices][ValuationResult.indices] and + [ValuationResult.names][ValuationResult.names] will follow the same order. + Args: reverse: Whether to sort in descending order by value. key: The key to sort by. Defaults to [ValueItem.value][ValueItem.value]. """ @@ -581,10 +582,12 @@ def update(self, idx: int, new_value: float) -> "ValuationResult": """Updates the result in place with a new value, using running mean and variance. + Args: idx: Data index of the value to update. new_value: New value to add to the result. Returns: - A reference to the same, modified result. + A reference to the same, modified result. + :raises IndexError: If the index is not found. """ try: @@ -626,12 +629,13 @@ def to_dataframe( ) -> pandas.DataFrame: """Returns values as a dataframe. + Args: column: Name for the column holding the data value. Defaults to - the name of the algorithm used. + the name of the algorithm used. use_names: Whether to use data names instead of indices for the - DataFrame's index. + DataFrame's index. Returns: - A dataframe with two columns, one for the values, with name + A dataframe with two columns, one for the values, with name given as explained in `column`, and another with standard errors for approximate algorithms. The latter will be named `column+'_stderr'`. :raise ImportError: If pandas is not installed @@ -657,14 +661,16 @@ def from_random( of random values from a uniform distribution in [-1,1]. The values can be made to sum up to a given total number (doing so will change their range). + Args: size: Number of values to generate total: If set, the values are normalized to sum to this number - ("efficiency" property of Shapley values). + ("efficiency" property of Shapley values). kwargs: Additional options to pass to the constructor of - :class:`ValuationResult`. Use to override status, names, etc. + :class:`ValuationResult`. Use to override status, names, etc. Returns: - A valuation result with its status set to + A valuation result with its status set to [Status.Converged][Status.Converged] by default. + :raises ValueError: If ``size`` is less than 1. !!! version-changed 0.6.0 @@ -702,9 +708,10 @@ def empty( Empty results are characterised by having an empty array of values. When another result is added to an empty one, the empty one is discarded. + Args: algorithm: Name of the algorithm used to compute the values Returns: - An instance of :class:`ValuationResult` + An instance of :class:`ValuationResult` """ if indices is not None or data_names is not None or n_samples != 0: return cls.zeros( @@ -728,15 +735,16 @@ def zeros( Empty results are characterised by having an empty array of values. When another result is added to an empty one, the empty one is ignored. + Args: algorithm: Name of the algorithm used to compute the values indices: Data indices to use. A copy will be made. If not given, - the indices will be set to the range ``[0, n_samples)``. + the indices will be set to the range ``[0, n_samples)``. data_names: Data names to use. A copy will be made. If not given, - the names will be set to the string representation of the indices. + the names will be set to the string representation of the indices. n_samples: Number of data points whose values are computed. If - not given, the length of ``indices`` will be used. + not given, the length of ``indices`` will be used. Returns: - An instance of :class:`ValuationResult` + An instance of :class:`ValuationResult` """ if indices is None: indices = np.arange(n_samples, dtype=np.int_) diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 0d4c4bd08..7ce2e653f 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -92,12 +92,13 @@ def __init__( outer_indices: NDArray[T] = None, ): """ - indices: The set of items (indices) to sample from. - index_iteration: the order in which indices are iterated over - outer_indices: The set of items (indices) over which to iterate - when sampling. Subsets are taken from the complement of each index - in succession. For embarrassingly parallel computations, this set - is sliced and the samplers are used to iterate over the slices. + Args: + indices: The set of items (indices) to sample from. + index_iteration: the order in which indices are iterated over + outer_indices: The set of items (indices) over which to iterate + when sampling. Subsets are taken from the complement of each index + in succession. For embarrassingly parallel computations, this set + is sliced and the samplers are used to iterate over the slices. """ self._indices = indices self._index_iteration = index_iteration @@ -194,6 +195,7 @@ def __init__(self, indices: NDArray[T], *args, **kwargs): For every index $i$, each subset of `indices - {i}` has equal probability $2^{n-1}$. + Args: indices: The set of items (indices) to sample from. """ # Force sequential iteration diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index bfa138826..2d4ad0d02 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -76,8 +76,9 @@ class SVCoefficient(Protocol): def __call__(self, n: int, k: int) -> float: """Computes the coefficient for a given subset size. - n: Total number of elements in the set. - k: Size of the subset for which the coefficient is being computed + Args: + n: Total number of elements in the set. + k: Size of the subset for which the coefficient is being computed """ ... @@ -94,6 +95,7 @@ def _semivalues( r"""Serial computation of semi-values. This is a helper function for :func:`semivalues`. + Args: sampler: The subset sampler to use for utility computations. u: Utility object with model, data, and scoring function. coefficient: The semivalue coefficient @@ -136,13 +138,14 @@ def semivalues( """ Computes semi-values for a given utility function and subset sampler. + Args: sampler: The subset sampler to use for utility computations. u: Utility object with model, data, and scoring function. coefficient: The semi-value coefficient done: Stopping criterion. n_jobs: Number of parallel jobs to use. config: Object configuring parallel computation, with cluster - address, number of cpus, etc. + address, number of cpus, etc. progress: Whether to display progress bars for each job. Returns: Object with the results. @@ -221,15 +224,15 @@ def compute_semivalues( - [SemiValueMode.Banzhaf][SemiValueMode.Banzhaf]: Implements the Banzhaf semi-value as introduced in :footcite:t:`wang_data_2022`. + Args: u: Utility object with model, data, and scoring function. done: Stopping criterion. - mode: The semi-value mode to use. See :class:`SemiValueMode` for a - list. + mode: The semi-value mode to use. See :class:`SemiValueMode` for a list. sampler_t: The sampler type to use. See [sampler][pydvl.value.sampler] - for a list. + for a list. n_jobs: Number of parallel jobs to use. kwargs: Additional keyword arguments passed to - [semivalues()][pydvl.value.semivalues.semivalues]. + [semivalues()][pydvl.value.semivalues.semivalues]. """ sampler_instance = sampler_t(u.data.indices) if mode == SemiValueMode.Shapley: diff --git a/src/pydvl/value/shapley/common.py b/src/pydvl/value/shapley/common.py index 35bb82243..64862ac57 100644 --- a/src/pydvl/value/shapley/common.py +++ b/src/pydvl/value/shapley/common.py @@ -79,16 +79,16 @@ def compute_shapley_values( Args: u: :class:`~pydvl.utils.utility.Utility` object with model, data, and - scoring function. - done: :class:`~pydvl.value.stopping.StoppingCriterion` object, used - to determine when to stop the computation for Monte Carlo methods. The - default is to stop after 100 iterations. See the available criteria in - [stopping][pydvl.value.stopping]. It is possible to combine several criteria - using boolean operators. Some methods ignore this argument, others - require specific subtypes. + scoring function. + done: :class:`~pydvl.value.stopping.StoppingCriterion` object, used to + determine when to stop the computation for Monte Carlo methods. The + default is to stop after 100 iterations. See the available criteria + in [stopping][pydvl.value.stopping]. It is possible to combine several + criteria using boolean operators. Some methods ignore this argument, + others require specific subtypes. n_jobs: Number of parallel jobs (available only to some methods) mode: Choose which shapley algorithm to use. See - :class:`~pydvl.value.shapley.ShapleyMode` for a list of allowed value. + :class:`~pydvl.value.shapley.ShapleyMode` for a list of allowed value. Returns: A :class:`~pydvl.value.result.ValuationResult` object with the diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index b2bf71f74..986393693 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -5,10 +5,10 @@ computed with guarantees. !!! Warning - This method is very inefficient. Potential improvements to the - implementation notwithstanding, convergence seems to be very slow (in terms - of evaluations of the utility required). We recommend other Monte Carlo - methods instead. + This method is very inefficient. Potential improvements to the + implementation notwithstanding, convergence seems to be very slow (in terms + of evaluations of the utility required). We recommend other Monte Carlo + methods instead. You can read more [in the documentation][computing-data-values]. @@ -43,6 +43,7 @@ def _constants( """A helper function returning the constants for the algorithm. Pretty ugly, yes. + Args: n: The number of data points. epsilon: The error tolerance. delta: The confidence level. @@ -99,6 +100,7 @@ def num_samples_eps_delta( (ε/√n,δ/(N(N-1))-approximation to all pair-wise differences of Shapley values, wrt. $\ell_2$ norm. + Args: eps: ε delta: δ n: Number of data points @@ -123,6 +125,7 @@ def _group_testing_shapley( Computes utilities of sets sampled using the strategy for estimating the differences in Shapley values. + Args: u: Utility object with model, data, and scoring function. n_samples: total number of samples (subsets) to use. progress: Whether to display progress bars for each job. @@ -170,22 +173,22 @@ def group_testing_shapley( values can be approximated with a Monte Carlo sum. These are then used to solve for the individual values in a feasibility problem. + Args: u: Utility object with model, data, and scoring function n_samples: Number of tests to perform. Use - :func:`num_samples_eps_delta` to estimate this. + :func:`num_samples_eps_delta` to estimate this. epsilon: From the (ε,δ) sample bound. Use the same as for the - estimation of ``n_iterations``. + estimation of ``n_iterations``. delta: From the (ε,δ) sample bound. Use the same as for the - estimation of ``n_iterations``. + estimation of ``n_iterations``. n_jobs: Number of parallel jobs to use. Each worker performs a chunk - of all tests (i.e. utility evaluations). + of all tests (i.e. utility evaluations). config: Object configuring parallel computation, with cluster - address, number of cpus, etc. + address, number of cpus, etc. progress: Whether to display progress bars for each job. - options: Additional options to pass to `cvxpy.Problem.solve() - `_. - E.g. to change the solver (which defaults to `cvxpy.SCS`) pass - `solver=cvxpy.CVXOPT`. + options: Additional options to pass to [cvxpy.Problem.solve()](https://www.cvxpy.org/tutorial/advanced/index.html#solve-method-options). + E.g. to change the solver (which defaults to `cvxpy.SCS`) pass + `solver=cvxpy.CVXOPT`. Returns: Object with the data values. diff --git a/src/pydvl/value/shapley/knn.py b/src/pydvl/value/shapley/knn.py index dcb0db452..1b89ccb86 100644 --- a/src/pydvl/value/shapley/knn.py +++ b/src/pydvl/value/shapley/knn.py @@ -25,12 +25,15 @@ def knn_shapley(u: Utility, *, progress: bool = True) -> ValuationResult: of calls to the utility function to a constant number per index, thus reducing computation time to $O(n)$. + Args: u: Utility with a KNN model to extract parameters from. The object - will not be modified nor used other than to call `get_params() - `_ + will not be modified nor used other than to call `get_params() + `_ progress: Whether to display a progress bar. + Returns: Object with the data values. + :raises TypeError: If the model in the utility is not a `KNeighborsClassifier `_ diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index e157310ef..28d9ea63d 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -69,14 +69,16 @@ def _permutation_montecarlo_shapley( :obj:`pydvl.utils.utility.Utility.data` by iterating through randomly sampled permutations. + Args: u: Utility object with model, data, and scoring function done: Check on the results which decides when to stop truncation: A callable which decides whether to interrupt - processing a permutation and set all subsequent marginals to zero. + processing a permutation and set all subsequent marginals to zero. algorithm_name: For the results object. Used internally by different - variants of Shapley using this subroutine + variants of Shapley using this subroutine progress: Whether to display progress bars for each job. job_id: id to use for reporting progress (e.g. to place progres bars) + Returns: An object with the results """ @@ -125,15 +127,17 @@ def permutation_montecarlo_shapley( where $\sigma_{:i}$ denotes the set of indices in permutation sigma before the position where $i$ appears (see [Data valuation][computing-data-values] for details). + Args: u: Utility object with model, data, and scoring function. done: function checking whether computation must stop. - truncation: An optional callable which decides whether to - interrupt processing a permutation and set all subsequent marginals to - zero. Typically used to stop computation when the marginal is small. + truncation: An optional callable which decides whether to interrupt + processing a permutation and set all subsequent marginals to + zero. Typically used to stop computation when the marginal is small. n_jobs: number of jobs across which to distribute the computation. - config: Object configuring parallel computation, with cluster - address, number of cpus, etc. + config: Object configuring parallel computation, with cluster address, + number of cpus, etc. progress: Whether to display progress bars for each job. + Returns: Object with the data values. """ @@ -167,14 +171,16 @@ def _combinatorial_montecarlo_shapley( This is the code that is sent to workers to compute values using the combinatorial definition. + Args: indices: Indices of the samples to compute values for. u: Utility object with model, data, and scoring function done: Check on the results which decides when to stop sampling - subsets for an index. + subsets for an index. progress: Whether to display progress bars for each job. job_id: id to use for reporting progress + Returns: - A tuple of ndarrays with estimated values and standard errors + The results for the indices. """ n = len(u.data) @@ -229,14 +235,16 @@ def combinatorial_montecarlo_shapley( Parallelization is done by splitting the set of indices across processes and computing the sum over subsets $S \subseteq N \setminus \{i\}$ separately. + Args: u: Utility object with model, data, and scoring function done: Stopping criterion for the computation. n_jobs: number of parallel jobs across which to distribute the - computation. Each worker receives a chunk of - [indices][pydvl.utils.dataset.Dataset.indices] - config: Object configuring parallel computation, with cluster - address, number of cpus, etc. + computation. Each worker receives a chunk of + [indices][pydvl.utils.dataset.Dataset.indices] + config: Object configuring parallel computation, with cluster address, + number of cpus, etc. progress: Whether to display progress bars for each job. + Returns: Object with the data values. """ diff --git a/src/pydvl/value/shapley/naive.py b/src/pydvl/value/shapley/naive.py index 070f2b5d4..e7661e56d 100644 --- a/src/pydvl/value/shapley/naive.py +++ b/src/pydvl/value/shapley/naive.py @@ -25,8 +25,10 @@ def permutation_exact_shapley(u: Utility, *, progress: bool = True) -> Valuation simple use cases. Please refer to the :mod:`Monte Carlo ` approximations for practical applications. + Args: u: Utility object with model, data, and scoring function progress: Whether to display progress bars for each job. + Returns: Object with the data values. """ @@ -102,11 +104,13 @@ def combinatorial_exact_shapley( [Monte Carlo][pydvl.value.shapley.montecarlo] approximations for practical applications. + Args: u: Utility object with model, data, and scoring function n_jobs: Number of parallel jobs to use config: Object configuring parallel computation, with cluster address, - number of cpus, etc. + number of cpus, etc. progress: Whether to display progress bars for each job. + Returns: Object with the data values. """ diff --git a/src/pydvl/value/shapley/owen.py b/src/pydvl/value/shapley/owen.py index 2016c9f73..242582817 100644 --- a/src/pydvl/value/shapley/owen.py +++ b/src/pydvl/value/shapley/owen.py @@ -39,14 +39,16 @@ def _owen_sampling_shapley( We might want to try better quadrature rules like Gauss or Rombert or use Monte Carlo for the double integral. + Args: indices: Indices to compute the value for u: Utility object with model, data, and scoring function method: Either [Full][OwenAlgorithm.Full] for $q \in [0,1]$ or - [Halved][OwenAlgorithm.Halved] for $q \in [0,0.5]$ and correlated samples + [Halved][OwenAlgorithm.Halved] for $q \in [0,0.5]$ and correlated samples n_samples: Number of subsets to sample to estimate the integrand max_q: number of subdivisions for the integration over $q$ progress: Whether to display progress bars for each job job_id: For positioning of the progress bar + Returns: Object with the data values, errors. """ @@ -126,19 +128,21 @@ def owen_sampling_shapley( !!! Note The outer integration could be done instead with a quadrature rule. + Args: u: :class:`~pydvl.utils.utility.Utility` object holding data, model - and scoring function. + and scoring function. n_samples: Numer of sets to sample for each value of q max_q: Number of subdivisions for q ∈ [0,1] (the element sampling - probability) used to approximate the outer integral. + probability) used to approximate the outer integral. method: Selects the algorithm to use, see the description. Either - [Full][OwenAlgorithm.Full] for $q \in [0,1]$ or - [Halved][OwenAlgorithm.Halved] for $q \in [0,0.5]$ and correlated samples + [Full][OwenAlgorithm.Full] for $q \in [0,1]$ or + [Halved][OwenAlgorithm.Halved] for $q \in [0,0.5]$ and correlated samples n_jobs: Number of parallel jobs to use. Each worker receives a chunk - of the total of `max_q` values for q. - config: Object configuring parallel computation, with cluster - address, number of cpus, etc. + of the total of `max_q` values for q. + config: Object configuring parallel computation, with cluster address, + number of cpus, etc. progress: Whether to display progress bars for each job. + Returns: Object with the data values. diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 4a2af7ac5..68dfb13c9 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -55,10 +55,12 @@ def reset(self): def __call__(self, idx: int, score: float) -> bool: """Check whether the computation should be interrupted. + Args: idx: Position in the permutation currently being computed. score: Last utility computed. + Returns: - ``True`` if the computation should be interrupted. + ``True`` if the computation should be interrupted. """ ret = self._check(idx, score) self.n_calls += 1 @@ -104,9 +106,10 @@ class RelativeTruncation(TruncationPolicy): This is called "performance tolerance" in :footcite:t:`ghorbani_data_2019`. + Args: u: Utility object with model, data, and scoring function rtol: Relative tolerance. The permutation is broken if the - last computed utility is less than ``total_utility * rtol``. + last computed utility is less than ``total_utility * rtol``. """ def __init__(self, u: Utility, rtol: float): @@ -126,9 +129,10 @@ class BootstrapTruncation(TruncationPolicy): """Break a permutation if the last computed utility is close to the total utility, measured as a multiple of the standard deviation of the utilities. + Args: u: Utility object with model, data, and scoring function n_samples: Number of bootstrap samples to use to compute the variance - of the utilities. + of the utilities. sigmas: Number of standard deviations to use as a threshold. """ @@ -225,22 +229,22 @@ def truncated_montecarlo_shapley( We keep sampling permutations and updating all shapley values until the :class:`StoppingCriterion` returns ``True``. + Args: u: Utility object with model, data, and scoring function - done: Check on the results which decides when to stop - sampling permutations. - truncation: callable that decides whether to stop computing - marginals for a given permutation. - config: Object configuring parallel computation, with cluster - address, number of cpus, etc. - n_jobs: Number of permutation monte carlo jobs - to run concurrently. + done: Check on the results which decides when to stop sampling + permutations. + truncation: callable that decides whether to stop computing marginals + for a given permutation. + config: Object configuring parallel computation, with cluster address, + number of cpus, etc. + n_jobs: Number of permutation monte carlo jobs to run concurrently. coordinator_update_period: in seconds. How often to check the - accumulated results from the workers for convergence. - worker_update_period: interval in seconds between different - updates to and from the coordinator - Returns: - Object with the data values. + accumulated results from the workers for convergence. + worker_update_period: interval in seconds between different updates to + and from the coordinator + Returns: + Object with the data values. """ algorithm = "truncated_montecarlo_shapley" diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index 2e56328d7..2e1712d45 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -95,6 +95,7 @@ class StoppingCriterion(abc.ABC): :meth:`completion` should be overridden to provide an overall completion value, since the default implementation returns the mean of :attr:`converged`. + Args: modify_result: If ``True`` the status of the input :class:`~pydvl.value.result.ValuationResult` is modified in place after the call. @@ -180,14 +181,15 @@ def make_criterion( """Create a new :class:`StoppingCriterion` from a function. Use this to enable simpler functions to be composed with bitwise operators + Args: fun: The callable to wrap. converged: A callable that returns a boolean array indicating what - values have converged. + values have converged. completion: A callable that returns a value between 0 and 1 indicating - the rate of completion of the computation. If not provided, the fraction - of converged values is used. + the rate of completion of the computation. If not provided, the fraction + of converged values is used. name: The name of the new criterion. If ``None``, the ``__name__`` of - the function is used. + the function is used. Returns: A new subclass of :class:`StoppingCriterion`. """ @@ -225,20 +227,21 @@ class AbsoluteStandardError(StoppingCriterion): criterion returns [Converged][pydvl.utils.status.Status.Converged] if $s_i < \epsilon$ for all $i$ and a threshold value $\epsilon \gt 0$. + Args: threshold: A value is considered to have converged if the standard - error is below this value. A way of choosing it is to pick some - percentage of the range of the values. For Shapley values this is the - difference between the maximum and minimum of the utility function (to - see this substitute the maximum and minimum values of the utility into - the marginal contribution formula). + error is below this value. A way of choosing it is to pick some + percentage of the range of the values. For Shapley values this is the + difference between the maximum and minimum of the utility function (to + see this substitute the maximum and minimum values of the utility into + the marginal contribution formula). fraction: The fraction of values that must have converged for the - criterion to return [Converged][pydvl.utils.status.Status.Converged]. + criterion to return [Converged][pydvl.utils.status.Status.Converged]. burn_in: The number of iterations to ignore before checking for - convergence. This is required because computations typically start with - zero variance, as a result of using - :meth:`~pydvl.value.result.ValuationResult.empty`. The default is set to - an arbitrary minimum which is usually enough but may need to be - increased. + convergence. This is required because computations typically start with + zero variance, as a result of using + :meth:`~pydvl.value.result.ValuationResult.empty`. The default is set to + an arbitrary minimum which is usually enough but may need to be + increased. """ def __init__( @@ -273,9 +276,10 @@ class MaxChecks(StoppingCriterion): A "check" is one call to the criterion. + Args: n_checks: Threshold: if ``None``, no _check is performed, - effectively creating a (never) stopping criterion that always returns - ``Pending``. + effectively creating a (never) stopping criterion that always returns + ``Pending``. """ def __init__(self, n_checks: Optional[int], modify_result: bool = True): @@ -309,9 +313,10 @@ class MaxUpdates(StoppingCriterion): number coincides with the maximum number of subsets sampled. For permutation samplers, it coincides with the number of permutations sampled. + Args: n_updates: Threshold: if ``None``, no _check is performed, - effectively creating a (never) stopping criterion that always returns - ``Pending``. + effectively creating a (never) stopping criterion that always returns + ``Pending``. """ def __init__(self, n_updates: Optional[int], modify_result: bool = True): @@ -347,9 +352,10 @@ class MinUpdates(StoppingCriterion): number is a lower bound for the number of subsets sampled. For permutation samplers, it lower-bounds the amount of permutations sampled. + Args: n_updates: Threshold: if ``None``, no _check is performed, - effectively creating a (never) stopping criterion that always returns - ``Pending``. + effectively creating a (never) stopping criterion that always returns + ``Pending``. """ def __init__(self, n_updates: Optional[int], modify_result: bool = True): @@ -379,10 +385,11 @@ class MaxTime(StoppingCriterion): Checks the elapsed time since construction + Args: seconds: Threshold: The computation is terminated if the elapsed time - between object construction and a _check exceeds this value. If ``None``, - no _check is performed, effectively creating a (never) stopping criterion - that always returns ``Pending``. + between object construction and a _check exceeds this value. If ``None``, + no _check is performed, effectively creating a (never) stopping criterion + that always returns ``Pending``. """ def __init__(self, seconds: Optional[float], modify_result: bool = True): @@ -431,8 +438,9 @@ class HistoryDeviation(StoppingCriterion): This criterion is meant for the reproduction of the results in the paper, but we do not recommend using it in practice. + Args: n_steps: Checkpoint values every so many updates and use these saved - values to compare. + values to compare. rtol: Relative tolerance for convergence ($\epsilon$ in the formula). pin_converged: If ``True``, once an index has converged, it is pinned """ From 4bd7d4df0831e446b92ad2c468121ba40e91a8de Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Wed, 14 Jun 2023 14:18:00 +0200 Subject: [PATCH 071/436] Fix mkdocs-material admonitions --- docs/10-getting-started.md | 1 - docs/20-install.md | 1 - docs/30-data-valuation.md | 5 ----- docs/40-influence.md | 5 +---- src/pydvl/influence/conjugate_gradient.py | 9 ++++----- src/pydvl/utils/caching.py | 2 -- src/pydvl/utils/dataset.py | 8 ++++---- src/pydvl/utils/numeric.py | 6 ++---- src/pydvl/utils/status.py | 7 +++---- src/pydvl/value/least_core/naive.py | 10 +++++----- src/pydvl/value/result.py | 8 ++++---- src/pydvl/value/sampler.py | 18 +++++++++--------- src/pydvl/value/semivalues.py | 7 +++---- src/pydvl/value/shapley/gt.py | 14 +++++++------- src/pydvl/value/shapley/knn.py | 5 ++--- src/pydvl/value/shapley/montecarlo.py | 6 +++--- src/pydvl/value/shapley/naive.py | 10 +++++----- src/pydvl/value/shapley/owen.py | 4 ++-- src/pydvl/value/shapley/truncated.py | 19 ++++++++++--------- src/pydvl/value/shapley/types.py | 2 +- src/pydvl/value/stopping.py | 4 ++-- 21 files changed, 67 insertions(+), 84 deletions(-) diff --git a/docs/10-getting-started.md b/docs/10-getting-started.md index 68ea55f09..0b066bc83 100644 --- a/docs/10-getting-started.md +++ b/docs/10-getting-started.md @@ -8,7 +8,6 @@ alias: # Getting started !!! Warning - Make sure you have read [[installation]] before using the library. In particular read about how caching and parallelization work, since they require additional setup. diff --git a/docs/20-install.md b/docs/20-install.md index 9eea857dc..7259cfac4 100644 --- a/docs/20-install.md +++ b/docs/20-install.md @@ -65,7 +65,6 @@ docker container run -d --rm -p 11211:11211 memcached:latest ``` !!! Warning - To read more about caching and how it might affect your usage, in particular about cache reuse and its pitfalls, please the documentation for the module :mod:`pydvl.utils.caching`. diff --git a/docs/30-data-valuation.md b/docs/30-data-valuation.md index 7b5ba36e9..ccc9f3f45 100644 --- a/docs/30-data-valuation.md +++ b/docs/30-data-valuation.md @@ -31,7 +31,6 @@ the package [pydvl.value][pydvl.value] , with support from modules and [pydvl.utils.utility][pydvl.utils.utility], as detailed below. !!! Warning - Be sure to read the section on [the difficulties using data values][problems-of-data-values]. @@ -131,7 +130,6 @@ which is used by some methods by estimate the number of samples necessary, and about what default value to use when the model fails to train. !!! Note - The most important property of a `Scorer` is its default value. Because many models will fail to fit on small subsets of the data, it is important to provide a sensible default value for the score. @@ -382,7 +380,6 @@ $$ $$ !!! Warning - We have reproduced this method in pyDVL for completeness and benchmarking, but we don't advocate its use because of the speed and memory cost. Despite our best efforts, the number of samples required in practice for convergence @@ -502,7 +499,6 @@ values = compute_least_core_values( ``` !!! Note - Although any number is supported, it is best to choose ``n_iterations`` to be at least equal to the number of data points. @@ -544,7 +540,6 @@ and **Beta Shapley** [@kwon_beta_2022], with better numerical and rank stability in certain situations. !!! Note - Shapley values are a particular case of semi-values and can therefore also be computed with the methods described here. However, as of version 0.6.0, we recommend using [compute_shapley_values][pydvl.value.shapley.compute_shapley_values] instead, diff --git a/docs/40-influence.md b/docs/40-influence.md index 94163bf60..07d462903 100644 --- a/docs/40-influence.md +++ b/docs/40-influence.md @@ -7,14 +7,12 @@ alias: # Computing influence values -!!! Warning - +!!! Warning Much of the code in the package [pydvl.influence][pydvl.influence] is experimental or untested. Package structure and basic API are bound to change before v1.0.0 !!! Todo - This section needs rewriting: - Introduce some theory @@ -36,7 +34,6 @@ and [compute_influences][pydvl.influence.compute_influences]. # Influence for OLS !!! Warning - This will be deprecated. It makes no sense to have a separate interface for linear models. diff --git a/src/pydvl/influence/conjugate_gradient.py b/src/pydvl/influence/conjugate_gradient.py index 41b0f3ebb..a0a7c55cb 100644 --- a/src/pydvl/influence/conjugate_gradient.py +++ b/src/pydvl/influence/conjugate_gradient.py @@ -58,22 +58,21 @@ def batched_preconditioned_conjugate_gradient( See also [2]_ and [3]_. !!! Warning - This function is experimental and unstable. Prefer using inversion_method='cg' - + Args: A: A linear function f : R[k] -> R[k] representing a matrix vector product from dimension K to K or a matrix. \ - It has to be positive-definite v.T @ f(v) >= 0. + It has to be positive-definite v.T @ f(v) >= 0. b: A NDArray of shape [K] representing the targeted result of the matrix multiplication Ax. max_iterations: Maximum number of iterations to use in conjugate gradient. Default is 10 times K. rtol: Relative tolerance of the residual with respect to the 2-norm of b. max_step_size: Maximum step size along a gradient direction. Might be necessary for numerical stability. \ - See also max_iterations. Default is 10.0. + See also max_iterations. Default is 10.0. verify_assumptions: True, iff the matrix should be checked for positive-definiteness by a stochastic rule. Returns: A NDArray of shape [K] representing the solution of Ax=b. - .. note:: + !!! References: .. [1] `Conjugate Gradient Method - Wikipedia `_. .. [2] `SciPy's implementation of Conjugate Gradient `_. .. [3] `Prof. Mert Pilanci., "Conjugate Gradient Method", Stanford University, 2022 `_. diff --git a/src/pydvl/utils/caching.py b/src/pydvl/utils/caching.py index fd8335bcf..844bf382d 100644 --- a/src/pydvl/utils/caching.py +++ b/src/pydvl/utils/caching.py @@ -6,7 +6,6 @@ service, locally or remotely, see :ref:`caching setup`. !!! Warning - Function evaluations are cached with a key based on the function's signature and code. This can lead to undesired cache hits, see :ref:`cache reuse`. @@ -158,7 +157,6 @@ def memcached( `rtol_stderr * running average`. !!! Warning - Do not cache functions with state! See :ref:`cache reuse` .. code-block:: python diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index c938c1eb7..5f169e048 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -275,7 +275,7 @@ def from_sklearn( Object with the sklearn dataset !!! version-changed 0.6.0 - Added kwargs to pass to the :class:`Dataset` constructor. + Added kwargs to pass to the :class:`Dataset` constructor. """ x_train, x_test, y_train, y_test = train_test_split( data.data, @@ -325,7 +325,7 @@ def from_arrays( !!! version-added 0.4.0 !!! version-changed 0.6.0 - Added kwargs to pass to the :class:`Dataset` constructor. + Added kwargs to pass to the :class:`Dataset` constructor. """ x_train, x_test, y_train, y_test = train_test_split( X, @@ -376,7 +376,7 @@ def __init__( :class:`Dataset` constructor. !!! version-changed 0.6.0 - Added ``group_names`` and forwarding of ``kwargs`` + Added ``group_names`` and forwarding of ``kwargs`` """ super().__init__( x_train=x_train, @@ -529,7 +529,7 @@ def from_arrays( !!! version-added 0.4.0 !!! version-changed 0.6.0 - Added kwargs to pass to the :class:`Dataset` constructor. + Added kwargs to pass to the :class:`Dataset` constructor. """ if data_groups is None: raise ValueError( diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index 12fd1a3bb..47cce3b95 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -274,16 +274,14 @@ def running_moments( """Uses Welford's algorithm to calculate the running average and variance of a set of numbers. - See `Welford's algorithm in wikipedia - `_ + See `Welford's algorithm in wikipedia `_ !!! Warning This is not really using Welford's correction for numerical stability for the variance. (FIXME) !!! Todo - This could be generalised to arbitrary moments. See `this paper - `_ + This could be generalised to arbitrary moments. See `this paper `_ Args: previous_avg: average value at previous step diff --git a/src/pydvl/utils/status.py b/src/pydvl/utils/status.py index fa794f844..64f0a6687 100644 --- a/src/pydvl/utils/status.py +++ b/src/pydvl/utils/status.py @@ -61,10 +61,9 @@ class Status(Enum): bool(Status.Failed) == True !!! Warning - These truth values are **inconsistent** with the usual boolean operations. - In particular the XOR of two instances of ``Status`` is not the same as - the XOR of their boolean values. - + These truth values are **inconsistent** with the usual boolean operations. + In particular the XOR of two instances of ``Status`` is not the same as + the XOR of their boolean values. """ Pending = "pending" diff --git a/src/pydvl/value/least_core/naive.py b/src/pydvl/value/least_core/naive.py index 3a342e9b6..5575c507a 100644 --- a/src/pydvl/value/least_core/naive.py +++ b/src/pydvl/value/least_core/naive.py @@ -24,11 +24,11 @@ def exact_least_core( r"""Computes the exact Least Core values. !!! Note - If the training set contains more than 20 instances a warning is printed - because the computation is very expensive. This method is mostly used for - internal testing and simple use cases. Please refer to the - [Monte Carlo method][pydvl.value.least_core.montecarlo.montecarlo_least_core] - for practical applications. + If the training set contains more than 20 instances a warning is printed + because the computation is very expensive. This method is mostly used for + internal testing and simple use cases. Please refer to the + [Monte Carlo method][pydvl.value.least_core.montecarlo.montecarlo_least_core] + for practical applications. The least core is the solution to the following Linear Programming problem: diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index 0b16b28fb..367786c92 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -90,8 +90,8 @@ class ValueItem(Generic[IndexT, NameT]): order. Comparisons take only the :attr:`value` into account. !!! Todo - Maybe have a mode of comparing similar to `np.isclose`, or taking the - :attr:`variance` into account. + Maybe have a mode of comparing similar to `np.isclose`, or taking the + :attr:`variance` into account. """ #: Index of the sample with this value in the original @@ -483,7 +483,7 @@ def __add__(self, other: "ValuationResult") -> "ValuationResult": argument is returned. !!! Warning - Abusing this will introduce numerical errors. + Abusing this will introduce numerical errors. Means and standard errors are correctly handled. Statuses are added with bit-wise ``&``, see :class:`~pydvl.value.result.Status`. @@ -496,7 +496,7 @@ def __add__(self, other: "ValuationResult") -> "ValuationResult": indices, and the values. !!! Warning - FIXME: Arbitrary ``extra_values`` aren't handled. + FIXME: Arbitrary ``extra_values`` aren't handled. """ # empty results diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 7ce2e653f..a351ed473 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -9,10 +9,10 @@ subset of the complement of ``idx``. !!! Note - This is the natural mode of iteration for the combinatorial definition of - semi-values, in particular Shapley value. For the computation using - permutations, adhering to this interface is not ideal, but we stick to it for - consistency. + This is the natural mode of iteration for the combinatorial definition of + semi-values, in particular Shapley value. For the computation using + permutations, adhering to this interface is not ideal, but we stick to it for + consistency. The samplers are used in the [semivalues][pydvl.value.semivalues] module to compute any semi-value, in particular Shapley and Beta values, and Banzhaf indices. @@ -251,8 +251,8 @@ class PermutationSampler(PowersetSampler[T]): as required for the permutation definition of semi-values. !!! Warning - This sampler requires caching to be enabled or computation - will be doubled wrt. a "direct" implementation of permutation MC + This sampler requires caching to be enabled or computation + will be doubled wrt. a "direct" implementation of permutation MC """ def __iter__(self) -> Iterator[SampleType]: @@ -279,8 +279,8 @@ class DeterministicPermutationSampler(PermutationSampler[T]): definition of semi-values. !!! Warning - This sampler requires caching to be enabled or computation - will be doubled wrt. a "direct" implementation of permutation MC + This sampler requires caching to be enabled or computation + will be doubled wrt. a "direct" implementation of permutation MC """ def __iter__(self) -> Iterator[SampleType]: @@ -296,7 +296,7 @@ class RandomHierarchicalSampler(PowersetSampler[T]): """For every index, sample a set size, then a set of that size. !!! Todo - This is unnecessary, but a step towards proper stratified sampling. + This is unnecessary, but a step towards proper stratified sampling. """ def __iter__(self) -> Iterator[SampleType]: diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 2d4ad0d02..aa0e89a6d 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -37,10 +37,9 @@ :footcite:t:`kwon_beta_2022`. !!! Note - For implementation consistency, we slightly depart from the common definition - of semi-values, which includes a factor $1/n$ in the sum over subsets. - Instead, we subsume this factor into the coefficient $w(k)$. - + For implementation consistency, we slightly depart from the common definition + of semi-values, which includes a factor $1/n$ in the sum over subsets. + Instead, we subsume this factor into the coefficient $w(k)$. """ import math diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index 986393693..6c96671c8 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -163,11 +163,11 @@ def group_testing_shapley( in :footcite:t:`jia_efficient_2019`. !!! Warning - This method is very inefficient. It requires several orders of magnitude - more evaluations of the utility than others in - [montecarlo][pydvl.value.shapley.montecarlo]. It also uses several intermediate - objects like the results from the runners and the constraint matrices - which can become rather large. + This method is very inefficient. It requires several orders of magnitude + more evaluations of the utility than others in + [montecarlo][pydvl.value.shapley.montecarlo]. It also uses several intermediate + objects like the results from the runners and the constraint matrices + which can become rather large. By picking a specific distribution over subsets, the differences in Shapley values can be approximated with a Monte Carlo sum. These are then used to @@ -196,8 +196,8 @@ def group_testing_shapley( !!! version-added 0.4.0 !!! version-changed 0.5.0 - Changed the solver to cvxpy instead of scipy's linprog. Added the ability - to pass arbitrary options to it. + Changed the solver to cvxpy instead of scipy's linprog. Added the ability + to pass arbitrary options to it. """ n = len(u.data.indices) diff --git a/src/pydvl/value/shapley/knn.py b/src/pydvl/value/shapley/knn.py index 1b89ccb86..405f6ae5d 100644 --- a/src/pydvl/value/shapley/knn.py +++ b/src/pydvl/value/shapley/knn.py @@ -2,7 +2,7 @@ This module contains Shapley computations for K-Nearest Neighbours. !!! Todo - Implement approximate KNN computation for sublinear complexity) + Implement approximate KNN computation for sublinear complexity) """ from typing import Dict, Union @@ -34,8 +34,7 @@ def knn_shapley(u: Utility, *, progress: bool = True) -> ValuationResult: Returns: Object with the data values. - :raises TypeError: If the model in the utility is not a `KNeighborsClassifier - `_ + :raises TypeError: If the model in the utility is not a `KNeighborsClassifier `_ !!! version-added 0.1.0 diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index 28d9ea63d..cae5d853c 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -2,9 +2,9 @@ Monte Carlo approximations to Shapley Data values. !!! Warning - You probably want to use the common interface provided by - [compute_shapley_values()][pydvl.value.shapley.compute_shapley_values] instead of directly using - the functions in this module. + You probably want to use the common interface provided by + [compute_shapley_values()][pydvl.value.shapley.compute_shapley_values] instead of directly using + the functions in this module. Because exact computation of Shapley values requires $\mathcal{O}(2^n)$ re-trainings of the model, several Monte Carlo approximations are available. diff --git a/src/pydvl/value/shapley/naive.py b/src/pydvl/value/shapley/naive.py index e7661e56d..036f79ec0 100644 --- a/src/pydvl/value/shapley/naive.py +++ b/src/pydvl/value/shapley/naive.py @@ -98,11 +98,11 @@ def combinatorial_exact_shapley( See [Data valuation][computing-data-values] for details. !!! Note - If the length of the training set is > n_jobs*20 this prints a warning - because the computation is very expensive. Used mostly for internal testing - and simple use cases. Please refer to the - [Monte Carlo][pydvl.value.shapley.montecarlo] approximations for practical - applications. + If the length of the training set is > n_jobs*20 this prints a warning + because the computation is very expensive. Used mostly for internal testing + and simple use cases. Please refer to the + [Monte Carlo][pydvl.value.shapley.montecarlo] approximations for practical + applications. Args: u: Utility object with model, data, and scoring function diff --git a/src/pydvl/value/shapley/owen.py b/src/pydvl/value/shapley/owen.py index 242582817..7e0256c8f 100644 --- a/src/pydvl/value/shapley/owen.py +++ b/src/pydvl/value/shapley/owen.py @@ -126,7 +126,7 @@ def owen_sampling_shapley( complement of $S$. !!! Note - The outer integration could be done instead with a quadrature rule. + The outer integration could be done instead with a quadrature rule. Args: u: :class:`~pydvl.utils.utility.Utility` object holding data, model @@ -149,7 +149,7 @@ def owen_sampling_shapley( !!! version-added 0.3.0 !!! version-changed 0.5.0 - Support for parallel computation and enable antithetic sampling. + Support for parallel computation and enable antithetic sampling. """ map_reduce_job: MapReduceJob[NDArray, ValuationResult] = MapReduceJob( diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 68dfb13c9..256180666 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -32,10 +32,10 @@ class TruncationPolicy(abc.ABC): and :attr:`n_truncations` respectively. !!! Todo - Because the policy objects are copied to the workers, the statistics - are not accessible from the - :class:`~pydvl.value.shapley.actor.ShapleyCoordinator`. We need to add - methods for this. + Because the policy objects are copied to the workers, the statistics + are not accessible from the + :class:`~pydvl.value.shapley.actor.ShapleyCoordinator`. We need to add + methods for this. """ def __init__(self): @@ -81,9 +81,10 @@ def reset(self): class FixedTruncation(TruncationPolicy): """Break a permutation after computing a fixed number of marginals. - u: Utility object with model, data, and scoring function - fraction: Fraction of marginals in a permutation to compute before - stopping (e.g. 0.5 to compute half of the marginals). + Args: + u: Utility object with model, data, and scoring function + fraction: Fraction of marginals in a permutation to compute before + stopping (e.g. 0.5 to compute half of the marginals). """ def __init__(self, u: Utility, fraction: float): @@ -213,8 +214,8 @@ def truncated_montecarlo_shapley( criterion. !!! Todo - Think of how to add Robin-Gelman or some other more principled stopping - criterion. + Think of how to add Robin-Gelman or some other more principled stopping + criterion. Instead of naively implementing the expectation, we sequentially add points to a dataset from a permutation and incrementally compute marginal utilities. diff --git a/src/pydvl/value/shapley/types.py b/src/pydvl/value/shapley/types.py index 7e1d202f2..1e3eea4e8 100644 --- a/src/pydvl/value/shapley/types.py +++ b/src/pydvl/value/shapley/types.py @@ -5,7 +5,7 @@ class ShapleyMode(str, Enum): """Supported algorithms for the computation of Shapley values. !!! Todo - Make algorithms register themselves here. + Make algorithms register themselves here. """ ApproShapley = "appro_shapley" # Alias for PermutationMontecarlo diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index 2e1712d45..6a2bb4b3a 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -435,8 +435,8 @@ class HistoryDeviation(StoppingCriterion): converged. !!! Warning - This criterion is meant for the reproduction of the results in the paper, - but we do not recommend using it in practice. + This criterion is meant for the reproduction of the results in the paper, + but we do not recommend using it in practice. Args: n_steps: Checkpoint values every so many updates and use these saved From e19122254a99b2d23c4b16a972c5e81c1e8e7a80 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Wed, 14 Jun 2023 14:26:05 +0200 Subject: [PATCH 072/436] Minor --- src/pydvl/__init__.py | 9 +++++++++ src/pydvl/value/__init__.py | 9 +++++---- 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/src/pydvl/__init__.py b/src/pydvl/__init__.py index c46296a16..2036aa45b 100644 --- a/src/pydvl/__init__.py +++ b/src/pydvl/__init__.py @@ -1 +1,10 @@ +""" +# The Python Data Valuation Library API + +This is the API documentation for the Python Data Valuation Library (PyDVL). +Use the table of contents to access the documentation for each module. + +The two main modules you will want to look at are [value][pydvl.value] and +[influence][pydvl.influence]. +""" __version__ = "0.6.2.dev0" diff --git a/src/pydvl/value/__init__.py b/src/pydvl/value/__init__.py index 27b17f161..f49d7bc73 100644 --- a/src/pydvl/value/__init__.py +++ b/src/pydvl/value/__init__.py @@ -1,8 +1,9 @@ -r""" -Algorithms for the exact and approximate computation of value and semi-value. +""" +This module implements algorithms for the exact and approximate computation of +values and semi-values. -See [Data valuation][computing-data-values] for an introduction to the concepts and methods -implemented here. +See [Data valuation][computing-data-values] for an introduction to the concepts +and methods implemented here. """ from .result import * # isort: skip From 6ab053e257ad1d693694113b762798a7091804f7 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Wed, 14 Jun 2023 14:26:13 +0200 Subject: [PATCH 073/436] Instant nav with XHR --- mkdocs.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/mkdocs.yml b/mkdocs.yml index a375d04a0..007d8ad5b 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -65,6 +65,7 @@ theme: - toc.follow # - navigation.tabs # - navigation.tabs.sticky + - navigation.instant - navigation.sections - navigation.tracking # - navigation.top From a69961abafc0a204dc953524135db87d69b63aaa Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Wed, 14 Jun 2023 15:01:55 +0200 Subject: [PATCH 074/436] Fix returns and lots of minor stuff --- mkdocs.yml | 1 - requirements-docs.txt | 1 - src/pydvl/influence/__init__.py | 6 +-- src/pydvl/influence/conjugate_gradient.py | 3 ++ .../frameworks/torch_differentiable.py | 27 +++++----- src/pydvl/influence/general.py | 34 ++++++------ src/pydvl/influence/linear.py | 44 ++++++--------- .../model_wrappers/torch_wrappers.py | 12 +++-- src/pydvl/reporting/plots.py | 2 +- src/pydvl/reporting/scores.py | 1 + src/pydvl/utils/caching.py | 1 + src/pydvl/utils/config.py | 35 ++++++------ src/pydvl/utils/dataset.py | 54 ++++++++++++------- src/pydvl/utils/numeric.py | 23 +++++--- src/pydvl/utils/parallel/backend.py | 2 + src/pydvl/utils/parallel/map_reduce.py | 6 ++- src/pydvl/utils/score.py | 3 +- src/pydvl/utils/types.py | 1 + src/pydvl/utils/utility.py | 5 +- src/pydvl/value/least_core/__init__.py | 4 +- src/pydvl/value/least_core/montecarlo.py | 1 + src/pydvl/value/loo/naive.py | 1 + src/pydvl/value/result.py | 17 +++--- src/pydvl/value/semivalues.py | 3 +- src/pydvl/value/shapley/common.py | 3 +- src/pydvl/value/shapley/gt.py | 28 +++++----- src/pydvl/value/shapley/knn.py | 2 +- src/pydvl/value/shapley/owen.py | 4 +- src/pydvl/value/stopping.py | 1 + 29 files changed, 182 insertions(+), 143 deletions(-) diff --git a/mkdocs.yml b/mkdocs.yml index 007d8ad5b..aa86e7a22 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -11,7 +11,6 @@ plugins: - autorefs - search - section-index -- mkdocs-version-annotations - alias: use_relative_link: true verbose: true diff --git a/requirements-docs.txt b/requirements-docs.txt index beedfc145..66fe075de 100644 --- a/requirements-docs.txt +++ b/requirements-docs.txt @@ -11,6 +11,5 @@ neoteroi-mkdocs # Needed for card grid on home page mkdocs-gallery mkdocs-nbconvert mkdocs-git-revision-date-localized-plugin -mkdocs-version-annotations pypandoc pypandoc_binary diff --git a/src/pydvl/influence/__init__.py b/src/pydvl/influence/__init__.py index 10591ffb9..a31a74086 100644 --- a/src/pydvl/influence/__init__.py +++ b/src/pydvl/influence/__init__.py @@ -2,9 +2,9 @@ This package contains algorithms for the computation of the influence function. !!! Warning - Much of the code in this package is experimental or untested and is subject - to modification. In particular, the package structure and basic API will - probably change. + Much of the code in this package is experimental or untested and is subject + to modification. In particular, the package structure and basic API will + probably change. """ from .general import * diff --git a/src/pydvl/influence/conjugate_gradient.py b/src/pydvl/influence/conjugate_gradient.py index a0a7c55cb..f6c7375be 100644 --- a/src/pydvl/influence/conjugate_gradient.py +++ b/src/pydvl/influence/conjugate_gradient.py @@ -211,8 +211,11 @@ def hvp_to_inv_diag_conditioner( """ This method uses the hvp function to construct a simple pre-conditioner 1/diag(H). It does so while requiring only O(d) space in RAM for construction and later execution. + + Args: hvp: The callable calculating the Hessian vector product Hv. d: The number of dimensions of the hvp callable. + Returns: A MatrixVectorProduct for the conditioner. """ diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 0e3c73e22..6a2dac65b 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -54,11 +54,7 @@ def __init__( self.loss = loss def num_params(self) -> int: - """ - Get number of parameters of model f. - Returns: - Number of parameters as integer. - """ + """ Returns the number of parameters of the model """ model_parameters = filter(lambda p: p.requires_grad, self.model.parameters()) return sum([np.prod(p.size()) for p in model_parameters]) @@ -70,13 +66,16 @@ def split_grad( ) -> "NDArray": """ Calculates gradient of model parameters wrt each x[i] and y[i] and then - returns a array of size [N, P] with N number of points (length of x and y) and P + returns an array of size [N, P] with N number of points (length of x and y) and P number of parameters of the model. + Args: x: A np.ndarray [NxD] representing the features x_i. y: A np.ndarray [NxK] representing the predicted target values y_i. progress: True, iff progress shall be printed. + Returns: - A np.ndarray [NxP] representing the gradients with respect to all parameters of the model. + An array [NxP] representing the gradients with respect to all parameters + of the model. """ x = torch.as_tensor(x).unsqueeze(1) y = torch.as_tensor(y) @@ -116,10 +115,10 @@ def grad( y: A np.ndarray [NxK] representing the predicted target values y_i. progress: True, iff progress shall be printed. Returns: - A tuple where: \ - - first element is a np.ndarray [P] with the gradients of the model. \ - - second element is the input to the model as a grad parameters. \ - This can be used for further differentiation. + A tuple where: + - first element is a np.ndarray [P] with the gradients of the model. + - second element is the input to the model as a grad parameters. + This can be used for further differentiation. """ x = torch.as_tensor(x).requires_grad_(True) y = torch.as_tensor(y) @@ -151,9 +150,11 @@ def mvp( progress: True, iff progress shall be printed. backprop_on: tensor used in the second backpropagation (the first one is along x and y as defined \ via grad_xy). If None, the model parameters are used. + Returns: - A np.ndarray representing the implicit matrix vector product of the model along the given directions.\ - Output shape is [DxP] if backprop_on is None, otherwise [DxM], with M the number of elements of backprop_on. + An array representing the implicit matrix vector product of the model + along the given directions. Output shape is [DxP] if backprop_on is None, + otherwise [DxM], with M the number of elements of backprop_on. """ v = torch.as_tensor(v) if v.ndim == 1: diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 634c1b73a..077fe9332 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -71,6 +71,7 @@ def calculate_influence_factors( of the loss (s_test in the paper). lam: regularization of the hessian progress: If True, display progress bars. + Returns: A np.ndarray of size (N, D) containing the influence factors for each dimension (D) and test sample (N). """ @@ -98,6 +99,7 @@ def _calculate_influences_up( y_train: A np.ndarray of shape [MxL] containing the targets of the input data points. influence_factors: np.ndarray containing influence factors progress: If True, display progress bars. + Returns: A np.ndarray of size [NxM], where N is number of test points and M number of train points. """ @@ -121,9 +123,9 @@ def _calculate_influences_pert( y_train: A np.ndarray of shape [MxL] containing the targets of the input data points. influence_factors: np.ndarray containing influence factors progress: If True, display progress bars. + Returns: - A np.ndarray of size [NxMxP], where N is number of test points, M number of train points, - and P the number of features. + A np.ndarray of size [NxMxP], where N is number of test points, M number of train points, and P the number of features. """ all_pert_influences = [] for i in maybe_progress( @@ -167,31 +169,31 @@ def compute_influences( get the influences over the complete training set. Points with low influence values are (on average) less important for model training than points with high influences. + Args: model: A supervised model from a supported framework. Currently, only pytorch nn.Module is supported. loss: loss of the model, a callable that, given prediction of the model and real labels, returns a - tensor with the loss value. + tensor with the loss value. x: model input for training y: input labels x_test: model input for testing y_test: test labels progress: whether to display progress bars. inversion_method: Set the inversion method to a specific one, can be 'direct' for direct inversion - (and explicit construction of the Hessian) or 'cg' for conjugate gradient. + (and explicit construction of the Hessian) or 'cg' for conjugate gradient. influence_type: Which algorithm to use to calculate influences. - Currently supported options: 'up' or 'perturbation'. For details refer to https://arxiv.org/pdf/1703.04730.pdf - inversion_method_kwargs: kwargs for the inversion method selected. - If using the direct method no kwargs are needed. If inversion_method='cg', the following kwargs can be passed: - - rtol: relative tolerance to be achieved before terminating computation - - max_iterations: maximum conjugate gradient iterations - - max_step_size: step size of conjugate gradient - - verify_assumptions: True to run tests on convexity of the model. + Currently supported options: 'up' or 'perturbation'. For details refer to https://arxiv.org/pdf/1703.04730.pdf + inversion_method_kwargs: kwargs for the inversion method selected. + If using the direct method no kwargs are needed. If inversion_method='cg', the following kwargs can be passed: + - rtol: relative tolerance to be achieved before terminating computation + - max_iterations: maximum conjugate gradient iterations + - max_step_size: step size of conjugate gradient + - verify_assumptions: True to run tests on convexity of the model. hessian_regularization: lambda to use in Hessian regularization, i.e. H_reg = H + lambda * 1, with 1 the identity matrix \ - and H the (simple and regularized) Hessian. Typically used with more complex models to make sure the Hessian \ - is positive definite. + and H the (simple and regularized) Hessian. Typically used with more complex models to make sure the Hessian \ + is positive definite. + Returns: - A np.ndarray specifying the influences. Shape is [NxM] if influence_type is'up', where N is number of test points and - M number of train points. If instead influence_type is 'perturbation', output shape is [NxMxP], with P the number of input - features. + An array specifying the influences. Shape is [NxM] if influence_type is'up', where N is number of test points and M number of train points. If instead influence_type is 'perturbation', output shape is [NxMxP], with P the number of input features. """ if not _TORCH_INSTALLED: raise RuntimeWarning("This function requires PyTorch.") diff --git a/src/pydvl/influence/linear.py b/src/pydvl/influence/linear.py index 433d4c341..20816903c 100644 --- a/src/pydvl/influence/linear.py +++ b/src/pydvl/influence/linear.py @@ -39,9 +39,9 @@ def compute_linear_influences( set. influence_type: Which algorithm to use to calculate influences. Currently supported options: 'up' or 'perturbation'. + Returns: - An array of shape (B, C) with the influences of the training - points on the test data. + An array of shape (B, C) with the influences of the training points on the test data. """ lr = LinearRegression() @@ -83,21 +83,15 @@ def influences_up_linear_regression_analytical( validation set for an ordinary least squares model (Ax+b=y with quadratic loss). - This method uses the + Args: + linear_model: A tuple of arrays of shapes (N, M) and N representing A and b respectively. + x: An array of shape (M, K) containing the features of the training set. + y: An array of shape (M, L) containing the targets of the training set. + x_test: An array of shape (N, K) containing the features of the test set. + y_test: An array of shape (N, L) containing the targets of the test set. - linear_model: A tuple of arrays of shapes (N, M) and N representing A - and b respectively. - x: An array of shape (M, K) containing the features of the - training set. - y: An array of shape (M, L) containing the targets of the - training set. - x_test: An array of shape (N, K) containing the features of the test - set. - y_test: An array of shape (N, L) containing the targets of the test - set. Returns: - An array of shape (B, C) with the influences of the training points - on the test points. + An array of shape (B, C) with the influences of the training points on the test points. """ test_grads_analytical = linear_regression_analytical_derivative_d_theta( @@ -132,19 +126,15 @@ def influences_perturbation_linear_regression_analytical( """Calculate the influences of each training sample onto the validation set for a linear model Ax+b=y. - linear_model: A tuple of np.ndarray' of shape (N, M) and (N) - representing A and b respectively. - x: An array of shape (M, K) containing the features of the - input data. - y: An array of shape (M, L) containing the targets of the input - data. - x_test: An array of shape (N, K) containing the features of the test - set. - y_test: An array of shape (N, L) containing the targets of the test - set. + Args: + linear_model: A tuple of np.ndarray' of shape (N, M) and (N) representing A and b respectively. + x: An array of shape (M, K) containing the features of the input data. + y: An array of shape (M, L) containing the targets of the input data. + x_test: An array of shape (N, K) containing the features of the test set. + y_test: An array of shape (N, L) containing the targets of the test set. + Returns: - An array of shape (B, C, M) with the influences of the training - points on the test points for each feature. + An array of shape (B, C, M) with the influences of the training points on the test points for each feature. """ test_grads_analytical = linear_regression_analytical_derivative_d_theta( diff --git a/src/pydvl/influence/model_wrappers/torch_wrappers.py b/src/pydvl/influence/model_wrappers/torch_wrappers.py index 3bd4c9f48..ceb631b26 100644 --- a/src/pydvl/influence/model_wrappers/torch_wrappers.py +++ b/src/pydvl/influence/model_wrappers/torch_wrappers.py @@ -106,8 +106,9 @@ def predict(self, x: torch.Tensor) -> "NDArray[np.float_]": """ Use internal model to deliver prediction in numpy. x: A np.ndarray [NxD] representing the features x_i. + Returns: - A np.ndarray [NxK] representing the predicted values. + A np.ndarray [NxK] representing the predicted values. """ return self.forward(x).detach().numpy() # type: ignore @@ -121,8 +122,9 @@ def score( Use internal model to measure how good is prediction through a loss function. x: A np.ndarray [NxD] representing the features x_i. y: A np.ndarray [NxK] representing the predicted target values y_i. + Returns: - The aggregated value over all samples N. + The aggregated value over all samples N. """ return score(self.forward(x), y).detach().numpy() # type: ignore @@ -209,8 +211,9 @@ def forward(self, x: Union["NDArray[np.float_]", torch.Tensor]) -> torch.Tensor: """ Calculate sigmoid(dot(a, x) + b) using RAM-optimized calculation layout. x: Tensor [NxD] representing the features x_i. + Returns: - A tensor [N] representing the probabilities for p(y_i). + A tensor [N] representing the probabilities for p(y_i). """ x = torch.as_tensor(x) return torch.sigmoid(x @ self.A.T + self.b) @@ -278,7 +281,8 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: """ Perform forward-pass through the network. x: Tensor input of shape [NxD]. + Returns: - Tensor output of shape[NxK]. + Tensor output of shape[NxK]. """ return self.layers(x) diff --git a/src/pydvl/reporting/plots.py b/src/pydvl/reporting/plots.py index ba483ad07..8d0aa5424 100644 --- a/src/pydvl/reporting/plots.py +++ b/src/pydvl/reporting/plots.py @@ -118,7 +118,7 @@ def plot_shapley( ylabel: string, y label of the plot Returns: - the axes created or used + The axes created or used """ if ax is None: _, ax = plt.subplots() diff --git a/src/pydvl/reporting/scores.py b/src/pydvl/reporting/scores.py index 13a4eea4f..b12e52248 100644 --- a/src/pydvl/reporting/scores.py +++ b/src/pydvl/reporting/scores.py @@ -26,6 +26,7 @@ def compute_removal_score( percentages: Sequence of removal percentages. remove_best: If True, removes data points in order of decreasing valuation. progress: If True, display a progress bar. + Returns: Dictionary that maps the percentages to their respective scores. """ diff --git a/src/pydvl/utils/caching.py b/src/pydvl/utils/caching.py index 844bf382d..e2c290caa 100644 --- a/src/pydvl/utils/caching.py +++ b/src/pydvl/utils/caching.py @@ -186,6 +186,7 @@ def memcached( sharing the cache among different jobs for the same experiment run if the callable happens to have "nuisance" parameters like "job_id" which do not affect the result of the computation. + Returns: A wrapped function diff --git a/src/pydvl/utils/config.py b/src/pydvl/utils/config.py index ac5c737aa..871fbeb91 100644 --- a/src/pydvl/utils/config.py +++ b/src/pydvl/utils/config.py @@ -13,12 +13,12 @@ class ParallelConfig: """Configuration for parallel computation backend. - backend: Type of backend to use. - Defaults to 'ray' - address: Address of existing remote or local cluster to use. - n_cpus_local: Number of CPUs to use when creating a local ray cluster. - This has no effect when using an existing ray cluster. - logging_level: Logging level for the parallel backend's worker. + Args: + backend: Type of backend to use. Defaults to 'ray' + address: Address of existing remote or local cluster to use. + n_cpus_local: Number of CPUs to use when creating a local ray cluster. + This has no effect when using an existing ray cluster. + logging_level: Logging level for the parallel backend's worker. """ backend: Literal["sequential", "ray"] = "ray" @@ -35,18 +35,17 @@ def __post_init__(self) -> None: class MemcachedClientConfig: """Configuration of the memcached client. - server: A tuple of (IP|domain name, port). - connect_timeout: How many seconds to wait before raising - `ConnectionRefusedError` on failure to connect. - timeout: seconds to wait for send or recv calls on the socket - connected to memcached. - no_delay: set the `TCP_NODELAY` flag, which may help with performance - in some cases. - serde: a serializer / deserializer ("serde"). The default - `PickleSerde` should work in most cases. See `pymemcached's - documentation - `_ - for details. + Args: + server: A tuple of (IP|domain name, port). + connect_timeout: How many seconds to wait before raising + `ConnectionRefusedError` on failure to connect. + timeout: seconds to wait for send or recv calls on the socket + connected to memcached. + no_delay: set the `TCP_NODELAY` flag, which may help with performance + in some cases. + serde: a serializer / deserializer ("serde"). The default + `PickleSerde` should work in most cases. See `pymemcached's documentation `_ + for details. """ server: Tuple[str, int] = ("localhost", 11211) diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index 5f169e048..7467f90cf 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -16,6 +16,7 @@ object. """ +from __future__ import annotations import logging from collections import OrderedDict @@ -152,10 +153,11 @@ def get_training_data( Args: indices: Optional indices that will be used to select points from the - training data. If ``None``, the entire training data will be returned. + training data. If ``None``, the entire training data will be returned. + Returns: - If ``indices`` is not ``None``, the selected x and y arrays - from the training data. Otherwise, the entire dataset. + If ``indices`` is not ``None``, the selected x and y arrays from the + training data. Otherwise, the entire dataset. """ if indices is None: return self.x_train, self.y_train @@ -206,6 +208,7 @@ class and to override the :meth:`~Dataset.get_test_data` method. Args: indices: Optional indices into the test data. This argument is unused left for compatibility with :meth:`Dataset.get_training_data`. + Returns: The entire test data. """ @@ -271,10 +274,11 @@ def from_sklearn( [scikit-learn's user guide](https://scikit-learn.org/stable/modules/cross_validation.html#stratification). kwargs: Additional keyword arguments to pass to the :class:`Dataset` constructor. Use this to pass e.g. ``is_multi_output``. + Returns: Object with the sklearn dataset - !!! version-changed 0.6.0 + !!! info "Changed in version 0.6.0" Added kwargs to pass to the :class:`Dataset` constructor. """ x_train, x_test, y_train, y_test = train_test_split( @@ -319,12 +323,13 @@ def from_arrays( kwargs: Additional keyword arguments to pass to the :class:`Dataset` constructor. Use this to pass e.g. ``feature_names`` or ``target_names``. + Returns: Object with the passed X and y arrays split across training and test sets. - !!! version-added 0.4.0 + !!! info "New in version 0.4.0" - !!! version-changed 0.6.0 + !!! info "Changed in version 0.6.0" Added kwargs to pass to the :class:`Dataset` constructor. """ x_train, x_test, y_train, y_test = train_test_split( @@ -375,7 +380,7 @@ def __init__( kwargs: Additional keyword arguments to pass to the :class:`Dataset` constructor. - !!! version-changed 0.6.0 + !!! info "Changed in version 0.6.0" Added ``group_names`` and forwarding of ``kwargs`` """ super().__init__( @@ -429,6 +434,7 @@ def get_training_data( Args: indices: group indices whose elements to return. If ``None``, all data from all groups are returned. + Returns: Tuple of training data x and labels y. """ @@ -471,6 +477,7 @@ def from_sklearn( data points in the dataset. kwargs: Additional keyword arguments to pass to the :class:`Dataset` constructor. + Returns: Dataset with the selected sklearn data """ @@ -523,12 +530,11 @@ def from_arrays( to the :class:`~pydvl.utils.dataset.Dataset` constructor. Returns: - Dataset with the passed X and y arrays split across training - and test sets. + Dataset with the passed X and y arrays split across training and test sets. - !!! version-added 0.4.0 + !!! info "New in version 0.4.0" - !!! version-changed 0.6.0 + !!! info "Changed in version 0.6.0" Added kwargs to pass to the :class:`Dataset` constructor. """ if data_groups is None: @@ -560,9 +566,10 @@ def from_dataset( data_groups: An array holding the group index or name for each data point. The length of this array must be equal to the number of data points in the dataset. + Returns: - A :class:`GroupedDataset` with the initial :class:`Dataset` - grouped by data_groups. + A :class:`GroupedDataset` with the initial :class:`Dataset` grouped + by data_groups. """ return cls( x_train=dataset.x_train, @@ -596,6 +603,7 @@ def load_spotify_dataset( min_year: minimum year of the returned data target_column: column to be returned as y (labels) random_state: fixes sklearn random seed + Returns: Tuple with 3 elements, each being a list sith [input_data, related_labels] """ @@ -623,19 +631,23 @@ def load_spotify_dataset( def load_wine_dataset( train_size: float, test_size: float, random_state: Optional[int] = None -): - """Loads the sklearn wine dataset. More info can be found at - https://scikit-learn.org/stable/datasets/toy_dataset.html#wine-recognition-dataset. +) -> tuple: + """Loads the [sklearn wine dataset](https://scikit-learn.org/stable/datasets/toy_dataset.html#wine-recognition-dataset). + + !!! Fixme + Why does this function not return a [Dataset][Dataset] object? + And why is it part of this module? Args: train_size: fraction of points used for training dataset test_size: fraction of points used for test dataset random_state: fix random seed. If None, no random seed is set. + Returns: - A tuple of four elements with the first three being input and - target values in the form of matrices of shape (N,D) the first - and (N,) the second. The fourth element is a list containing names of - features of the model. (FIXME doc) + A tuple of four elements with the first three being input and target + values in the form of matrices of shape (N,D) the first and (N,) the + second. The fourth element is a list containing names of features of the + model. (FIXME doc) """ try: import torch @@ -693,6 +705,7 @@ def synthetic_classification_dataset( train_size: fraction of points used for training dataset test_size: fraction of points used for test dataset random_seed: fix random seed. If None, no random seed is set. + Returns: A tuple of matrix x of shape [NxD] and target vector y of shape [N]. """ @@ -727,6 +740,7 @@ def decision_boundary_fixed_variance_2d( Args: mu_1: First mean. mu_2: Second mean. + Returns: A callable which converts a continuous line (-infty, infty) to the decision boundary in feature space. """ diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index 47cce3b95..48550e566 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -40,7 +40,8 @@ def powerset(s: NDArray[T]) -> Iterator[Collection[T]]: Args: s: The set to use - Returns: + + Returns: An iterator """ return chain.from_iterable(combinations(s, r) for r in range(len(s) + 1)) @@ -58,9 +59,10 @@ def num_samples_permutation_hoeffding(eps: float, delta: float, u_range: float) eps: ε > 0 delta: 0 < δ <= 1 u_range: Range of the :class:`~pydvl.utils.utility.Utility` function + Returns: Number of _permutations_ required to guarantee ε-correct Shapley - values with probability 1-δ + values with probability 1-δ """ return int(np.ceil(np.log(2 / delta) * 2 * u_range**2 / eps**2)) @@ -72,8 +74,9 @@ def random_subset(s: NDArray[T], q: float = 0.5) -> NDArray[T]: s: set to sample from q: Sampling probability for elements. The default 0.5 yields a uniform distribution over the power set of s. + Returns: - the subset + The subset """ rng = np.random.default_rng() selection = rng.uniform(size=len(s)) > q @@ -125,6 +128,7 @@ def random_subset_of_size(s: NDArray[T], size: int) -> NDArray[T]: Args: s: Set to sample from size: Size of the subset to generate + Returns: The subset @@ -148,6 +152,7 @@ def random_matrix_with_condition_number(n: int, condition_number: float) -> "NDA Args: n: size of the matrix condition_number: duh + Returns: An (n,n) matrix with the requested condition number. """ @@ -178,11 +183,13 @@ def linear_regression_analytical_derivative_d_theta( ) -> "NDArray": """ Args: - linear_model: A tuple of np.ndarray' of shape [NxM] and [N] representing A and b respectively. + linear_model: A tuple of np.ndarray' of shape [NxM] and [N] representing + A and b respectively. x: A np.ndarray of shape [BxM]. y: A np.nparray of shape [BxN]. + Returns: - A np.ndarray of shape [Bx((N+1)*M)], where each row vector is [d_theta L(x, y), d_b L(x, y)] + An array of shape [Bx((N+1)*M)], where each row vector is [d_theta L(x, y), d_b L(x, y)] """ A, b = linear_model @@ -203,9 +210,10 @@ def linear_regression_analytical_derivative_d2_theta( and b respectively. x: An array of shape [BxM], y: An array of shape [BxN]. + Returns: An array of shape [((N+1)*M)x((N+1)*M)], representing the Hessian. - It gets averaged over all samples. + It gets averaged over all samples. """ A, b = linear_model n, m = tuple(A.shape) @@ -229,6 +237,7 @@ def linear_regression_analytical_derivative_d_x_d_theta( linear_model: A tuple of np.ndarray of shape [NxM] and [N] representing A and b respectively. x: A np.ndarray of shape [BxM]. y: A np.nparray of shape [BxN]. + Returns: A np.ndarray of shape [Bx((N+1)*M)xM], representing the derivative. """ @@ -288,6 +297,7 @@ def running_moments( previous_variance: variance at previous step count: number of points seen so far new_value: new value in the series of numbers + Returns: new_average, new_variance, calculated with the new count """ @@ -309,6 +319,7 @@ def top_k_value_accuracy( y_true: Exact/true value y_pred: Predicted/estimated value k: Number of the highest values taken into account + Returns: Accuracy """ diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index 877c2a35a..5cfd3766c 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -232,6 +232,7 @@ def available_cpus() -> int: """Platform-independent count of available cores. FIXME: do we really need this or is `os.cpu_count` enough? Is this portable? + Returns: Number of cores, or 1 if it is not possible to determine. """ @@ -253,6 +254,7 @@ def effective_n_jobs(n_jobs: int, config: ParallelConfig = ParallelConfig()) -> CPUs is returned. config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. + Returns: The effective number of jobs, guaranteed to be >= 1. diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index 05f9ed652..49a2a1dd4 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -227,10 +227,11 @@ def _wrap_function(self, func: Callable, **kwargs) -> Callable: func: Function to wrap kwargs: Additional keyword arguments to pass to the backend wrapper. These are *not* arguments for the wrapped function. + Returns: Remote function that can be called with the same arguments as - the wrapped function. Depending on the backend, this may simply be - the function itself. + the wrapped function. Depending on the backend, this may simply be + the function itself. """ return self.parallel_backend.wrap( _wrap_func_with_remote_args(func, timeout=self.timeout), **kwargs @@ -248,6 +249,7 @@ def _backpressure( jobs: n_dispatched: n_finished: + Returns: """ diff --git a/src/pydvl/utils/score.py b/src/pydvl/utils/score.py index 19331ce24..ecda778da 100644 --- a/src/pydvl/utils/score.py +++ b/src/pydvl/utils/score.py @@ -48,7 +48,7 @@ class Scorer: name: The name of the scorer. If not provided, the name of the function passed will be used. - !!! version-added 0.5.0 + !!! info "New in version 0.5.0" """ @@ -105,6 +105,7 @@ def compose_score( range: The range of the transformation. This will be used e.g. by :class:`~pydvl.utils.utility.Utility` for the range of the composed. name: A string representation for the composition, for `str()`. + Returns: The composite :class:`Scorer`. """ diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index a2da3bafe..81770f07f 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -38,6 +38,7 @@ def maybe_add_argument(fun: Callable, new_arg: str): fun: The function to wrap new_arg: The name of the argument that the new function will accept (and ignore). + Returns: A new function accepting one more keyword argument. """ diff --git a/src/pydvl/utils/utility.py b/src/pydvl/utils/utility.py index 97a0b4dbb..9f318948f 100644 --- a/src/pydvl/utils/utility.py +++ b/src/pydvl/utils/utility.py @@ -176,10 +176,11 @@ def _utility(self, indices: FrozenSet) -> float: The type must be hashable for the caching to work, e.g. wrap the argument with [frozenset][] (rather than `tuple` since order should not matter) + Returns: 0 if no indices are passed, ``default_score`` if we fail - to fit the model or the scorer returns [numpy.NaN][]. Otherwise, the score - of the model on the test data. + to fit the model or the scorer returns [numpy.NaN][]. Otherwise, the score + of the model on the test data. """ if not indices: return 0.0 diff --git a/src/pydvl/value/least_core/__init__.py b/src/pydvl/value/least_core/__init__.py index b4aa155bc..476736753 100644 --- a/src/pydvl/value/least_core/__init__.py +++ b/src/pydvl/value/least_core/__init__.py @@ -1,5 +1,5 @@ """ -!!! version-added 0.4.0 +!!! info "New in version 0.4.0" This package holds all routines for the computation of Least Core data values. @@ -76,7 +76,7 @@ def compute_least_core_values( Returns: ValuationResult object with the computed values. - !!! version-added 0.5.0 + !!! info "New in version 0.5.0" """ progress: bool = kwargs.pop("progress", False) diff --git a/src/pydvl/value/least_core/montecarlo.py b/src/pydvl/value/least_core/montecarlo.py index 49bc23a72..b55edd448 100644 --- a/src/pydvl/value/least_core/montecarlo.py +++ b/src/pydvl/value/least_core/montecarlo.py @@ -148,6 +148,7 @@ def _montecarlo_least_core( n_iterations: total number of iterations to use progress: If True, shows a tqdm progress bar job_id: Integer id used to determine the position of the progress bar + Returns: """ diff --git a/src/pydvl/value/loo/naive.py b/src/pydvl/value/loo/naive.py index d13f371df..6ec3cb90f 100644 --- a/src/pydvl/value/loo/naive.py +++ b/src/pydvl/value/loo/naive.py @@ -15,6 +15,7 @@ def naive_loo(u: Utility, *, progress: bool = True) -> ValuationResult: Args: u: Utility object with model, data, and scoring function progress: If True, display a progress bar + Returns: Object with the data values. """ diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index 367786c92..ebf3696a5 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -585,6 +585,7 @@ def update(self, idx: int, new_value: float) -> "ValuationResult": Args: idx: Data index of the value to update. new_value: New value to add to the result. + Returns: A reference to the same, modified result. @@ -634,10 +635,11 @@ def to_dataframe( the name of the algorithm used. use_names: Whether to use data names instead of indices for the DataFrame's index. + Returns: A dataframe with two columns, one for the values, with name - given as explained in `column`, and another with standard errors for - approximate algorithms. The latter will be named `column+'_stderr'`. + given as explained in `column`, and another with standard errors for + approximate algorithms. The latter will be named `column+'_stderr'`. :raise ImportError: If pandas is not installed """ if not pandas: @@ -667,13 +669,14 @@ def from_random( ("efficiency" property of Shapley values). kwargs: Additional options to pass to the constructor of :class:`ValuationResult`. Use to override status, names, etc. + Returns: A valuation result with its status set to - [Status.Converged][Status.Converged] by default. + [Status.Converged][Status.Converged] by default. :raises ValueError: If ``size`` is less than 1. - !!! version-changed 0.6.0 + !!! info "Changed in version 0.6.0" Added parameter ``total``. Check for zero size """ if size < 1: @@ -710,8 +713,9 @@ def empty( Args: algorithm: Name of the algorithm used to compute the values + Returns: - An instance of :class:`ValuationResult` + Object with the results. """ if indices is not None or data_names is not None or n_samples != 0: return cls.zeros( @@ -743,8 +747,9 @@ def zeros( the names will be set to the string representation of the indices. n_samples: Number of data points whose values are computed. If not given, the length of ``indices`` will be used. + Returns: - An instance of :class:`ValuationResult` + Object with the results. """ if indices is None: indices = np.arange(n_samples, dtype=np.int_) diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index aa0e89a6d..f615b4899 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -101,6 +101,7 @@ def _semivalues( done: Stopping criterion. progress: Whether to display progress bars for each job. job_id: id to use for reporting progress. + Returns: Object with the results. """ @@ -146,9 +147,9 @@ def semivalues( config: Object configuring parallel computation, with cluster address, number of cpus, etc. progress: Whether to display progress bars for each job. + Returns: Object with the results. - """ map_reduce_job: MapReduceJob[PowersetSampler, ValuationResult] = MapReduceJob( sampler, diff --git a/src/pydvl/value/shapley/common.py b/src/pydvl/value/shapley/common.py index 64862ac57..0a66e8d09 100644 --- a/src/pydvl/value/shapley/common.py +++ b/src/pydvl/value/shapley/common.py @@ -91,8 +91,7 @@ def compute_shapley_values( :class:`~pydvl.value.shapley.ShapleyMode` for a list of allowed value. Returns: - A :class:`~pydvl.value.result.ValuationResult` object with the - results. + A :class:`~pydvl.value.result.ValuationResult` object with the results. """ progress: bool = kwargs.pop("progress", False) diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index 6c96671c8..3e612953b 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -12,7 +12,7 @@ You can read more [in the documentation][computing-data-values]. -!!! version-added 0.4.0 +!!! info "New in version 0.4.0" """ import logging @@ -50,15 +50,14 @@ def _constants( utility_range: The range of the utility function. Returns: - A namedtuple with the constants. The fields are the same as in the - paper: - - kk: the sample sizes (i.e. an array of 1, 2, ..., n - 1) - - Z: the normalization constant - - q: the probability of drawing a sample of size k - - q_tot: another normalization constant - - T: the number of iterations. This will be -1 if the utility_range is - infinite. E.g. because the :class:`~pydvl.utils.score.Scorer` does - not define a range. + A namedtuple with the constants. The fields are the same as in the paper: + - kk: the sample sizes (i.e. an array of 1, 2, ..., n - 1) + - Z: the normalization constant + - q: the probability of drawing a sample of size k + - q_tot: another normalization constant + - T: the number of iterations. This will be -1 if the utility_range is + infinite. E.g. because the :class:`~pydvl.utils.score.Scorer` does + not define a range. """ r = utility_range @@ -108,9 +107,9 @@ def num_samples_eps_delta( function Returns: Number of samples from $2^{[n]}$ guaranteeing ε/√n-correct Shapley - pair-wise differences of values with probability 1-δ/(N(N-1)). + pair-wise differences of values with probability 1-δ/(N(N-1)). - !!! version-added 0.4.0 + !!! info "New in version 0.4.0" """ constants = _constants(n=n, epsilon=eps, delta=delta, utility_range=utility_range) @@ -130,6 +129,7 @@ def _group_testing_shapley( n_samples: total number of samples (subsets) to use. progress: Whether to display progress bars for each job. job_id: id to use for reporting progress (e.g. to place progres bars) + Returns: """ @@ -193,9 +193,9 @@ def group_testing_shapley( Returns: Object with the data values. - !!! version-added 0.4.0 + !!! info "New in version 0.4.0" - !!! version-changed 0.5.0 + !!! info "Changed in version 0.5.0" Changed the solver to cvxpy instead of scipy's linprog. Added the ability to pass arbitrary options to it. """ diff --git a/src/pydvl/value/shapley/knn.py b/src/pydvl/value/shapley/knn.py index 405f6ae5d..da69f1d3c 100644 --- a/src/pydvl/value/shapley/knn.py +++ b/src/pydvl/value/shapley/knn.py @@ -36,7 +36,7 @@ def knn_shapley(u: Utility, *, progress: bool = True) -> ValuationResult: :raises TypeError: If the model in the utility is not a `KNeighborsClassifier `_ - !!! version-added 0.1.0 + !!! info "New in version 0.1.0" """ if not isinstance(u.model, KNeighborsClassifier): diff --git a/src/pydvl/value/shapley/owen.py b/src/pydvl/value/shapley/owen.py index 7e0256c8f..4ff48cfb8 100644 --- a/src/pydvl/value/shapley/owen.py +++ b/src/pydvl/value/shapley/owen.py @@ -146,9 +146,9 @@ def owen_sampling_shapley( Returns: Object with the data values. - !!! version-added 0.3.0 + !!! info "New in version 0.3.0" - !!! version-changed 0.5.0 + !!! info "Changed in version 0.5.0" Support for parallel computation and enable antithetic sampling. """ diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index 6a2bb4b3a..fe6e88c4f 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -190,6 +190,7 @@ def make_criterion( of converged values is used. name: The name of the new criterion. If ``None``, the ``__name__`` of the function is used. + Returns: A new subclass of :class:`StoppingCriterion`. """ From b8b5bbd8b26b8666cd86d064ff6d611d6f1495c1 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Wed, 14 Jun 2023 15:07:18 +0200 Subject: [PATCH 075/436] Convert links --- src/pydvl/influence/conjugate_gradient.py | 6 +-- src/pydvl/utils/caching.py | 54 ++++++++++------------- src/pydvl/utils/config.py | 5 ++- src/pydvl/utils/dataset.py | 6 +-- src/pydvl/utils/numeric.py | 4 +- src/pydvl/utils/score.py | 5 +-- src/pydvl/value/shapley/knn.py | 2 +- 7 files changed, 38 insertions(+), 44 deletions(-) diff --git a/src/pydvl/influence/conjugate_gradient.py b/src/pydvl/influence/conjugate_gradient.py index f6c7375be..dfe18b62e 100644 --- a/src/pydvl/influence/conjugate_gradient.py +++ b/src/pydvl/influence/conjugate_gradient.py @@ -73,9 +73,9 @@ def batched_preconditioned_conjugate_gradient( A NDArray of shape [K] representing the solution of Ax=b. !!! References: - .. [1] `Conjugate Gradient Method - Wikipedia `_. - .. [2] `SciPy's implementation of Conjugate Gradient `_. - .. [3] `Prof. Mert Pilanci., "Conjugate Gradient Method", Stanford University, 2022 `_. + .. [1] [Conjugate Gradient Method - Wikipedia](https://en.wikipedia.org/wiki/Conjugate_gradient_method). + .. [2] [SciPy's implementation of Conjugate Gradient](https://github.com/scipy/scipy/blob/v1.8.1/scipy/sparse/linalg/_isolve/iterative.py#L282-L351). + .. [3] [Prof. Mert Pilanci., "Conjugate Gradient Method", Stanford University, 2022](https://web.stanford.edu/class/ee364b/lectures/conj_grad_slides.pdf). """ warnings.warn( "This function is experimental and unstable. Prefer using inversion_method='cg'", diff --git a/src/pydvl/utils/caching.py b/src/pydvl/utils/caching.py index e2c290caa..66a03888e 100644 --- a/src/pydvl/utils/caching.py +++ b/src/pydvl/utils/caching.py @@ -1,18 +1,17 @@ """ Distributed caching of functions. -pyDVL uses `memcached `_ to cache utility values, through -`pymemcache `_. This allows sharing +pyDVL uses [memcached](https://memcached.org) to cache utility values, through +[pymemcache](https://pypi.org/project/pymemcache). This allows sharing evaluations across processes and nodes in a cluster. You can run memcached as a service, locally or remotely, see :ref:`caching setup`. !!! Warning - Function evaluations are cached with a key based on the function's signature - and code. This can lead to undesired cache hits, see :ref:`cache reuse`. + Function evaluations are cached with a key based on the function's signature + and code. This can lead to undesired cache hits, see :ref:`cache reuse`. - Remember **not to reuse utility objects for different datasets**. + Remember **not to reuse utility objects for different datasets**. -Configuration -------------- +# Configuration Memoization is disabled by default but can be enabled easily, see :ref:`caching setup`. When enabled, it will be added to any callable used to construct a @@ -22,23 +21,21 @@ :ref:`caching stochastic functions`. You can see all configuration options under :class:`~pydvl.utils.config.MemcachedConfig`. -.. rubric:: Default configuration - -.. code-block:: python - - default_config = dict( - server=('localhost', 11211), - connect_timeout=1.0, - timeout=0.1, - # IMPORTANT! Disable small packet consolidation: - no_delay=True, - serde=serde.PickleSerde(pickle_version=PICKLE_VERSION) - ) - +## Default configuration + +```python +default_config = dict( + server=('localhost', 11211), + connect_timeout=1.0, + timeout=0.1, + # IMPORTANT! Disable small packet consolidation: + no_delay=True, + serde=serde.PickleSerde(pickle_version=PICKLE_VERSION) +) +``` .. _caching stochastic functions: -Usage with stochastic functions -------------------------------- +# Usage with stochastic functions In addition to standard memoization, the decorator :func:`memcached` can compute running average and standard error of repeated evaluations for the same input. @@ -51,8 +48,7 @@ .. _cache reuse: -Cache reuse ------------ +# Cache reuse When working directly with :func:`memcached`, it is essential to only cache pure functions. If they have any kind of state, either internal or external (e.g. a @@ -63,9 +59,9 @@ (input and output names) and code are used as a key for the cache. Alternatively you can pass a custom value to be used as key with -.. code-block:: python - - cached_fun = memcached(**asdict(cache_options))(fun, signature=custom_signature) +```python +cached_fun = memcached(**asdict(cache_options))(fun, signature=custom_signature) +``` If you are running experiments with the same :class:`~pydvl.utils.utility.Utility` but different datasets, this will lead to evaluations of the utility on new data @@ -75,8 +71,7 @@ cache between runs, but the preferred one is to **use a different Utility object for each dataset**. -Unexpected cache misses ------------------------ +# Unexpected cache misses Because all arguments to a function are used as part of the key for the cache, sometimes one must exclude some of them. For example, If a function is going to @@ -85,7 +80,6 @@ functions distinct to the eyes of the cache. This can be avoided with the use of [ignore_args][pydvl.utils.config.MemcachedConfig.ignore_args] in the configuration. - """ import logging diff --git a/src/pydvl/utils/config.py b/src/pydvl/utils/config.py index 871fbeb91..9a77bc058 100644 --- a/src/pydvl/utils/config.py +++ b/src/pydvl/utils/config.py @@ -43,8 +43,9 @@ class MemcachedClientConfig: connected to memcached. no_delay: set the `TCP_NODELAY` flag, which may help with performance in some cases. - serde: a serializer / deserializer ("serde"). The default - `PickleSerde` should work in most cases. See `pymemcached's documentation `_ + serde: a serializer / deserializer ("serde"). The default `PickleSerde` + should work in most cases. See [pymemcached's + documentation](https://pymemcache.readthedocs.io/en/latest/apidoc/pymemcache.client.base.html#pymemcache.client.base.Client) for details. """ diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index 7467f90cf..045967d11 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -258,7 +258,7 @@ def from_sklearn( ) -> "Dataset": """Constructs a :class:`Dataset` object from an :class:`sklearn.utils.Bunch`, as returned by the `load_*` functions in - `sklearn toy datasets `_. + [sklearn toy datasets](https://scikit-learn.org/stable/datasets/toy_dataset.html). Args: data: sklearn dataset. The following attributes are supported @@ -471,7 +471,7 @@ def from_sklearn( random_state: seed for train / test split. stratify_by_target: If ``True``, data is split in a stratified fashion, using the target variable as labels. Read more in - `sklearn's user guide `. + [sklearn's user guide](https://scikit-learn.org/stable/modules/cross_validation.html#stratification). data_groups: an array holding the group index or name for each data point. The length of this array must be equal to the number of data points in the dataset. @@ -522,7 +522,7 @@ def from_arrays( random_state: seed for train / test split. stratify_by_target: If ``True``, data is split in a stratified fashion, using the y variable as labels. Read more in - `sklearn's user guide `. + [sklearn's user guide](https://scikit-learn.org/stable/modules/cross_validation.html#stratification). data_groups: an array holding the group index or name for each data point. The length of this array must be equal to the number of data points in the dataset. diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index 48550e566..623a52f2d 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -283,14 +283,14 @@ def running_moments( """Uses Welford's algorithm to calculate the running average and variance of a set of numbers. - See `Welford's algorithm in wikipedia `_ + See [Welford's algorithm in wikipedia](https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm) !!! Warning This is not really using Welford's correction for numerical stability for the variance. (FIXME) !!! Todo - This could be generalised to arbitrary moments. See `this paper `_ + This could be generalised to arbitrary moments. See [this paper](https://www.osti.gov/biblio/1028931) Args: previous_avg: average value at previous step diff --git a/src/pydvl/utils/score.py b/src/pydvl/utils/score.py index ecda778da..862384d65 100644 --- a/src/pydvl/utils/score.py +++ b/src/pydvl/utils/score.py @@ -4,8 +4,7 @@ Scorers can be constructed in the same way as in scikit-learn: either from known strings or from a callable. Greater values must be better. If they are not, -a negated version can be used, see scikit-learn's `make_scorer() -`_. +a negated version can be used, see scikit-learn's [make_scorer()](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.make_scorer.html). :class:`Scorer` provides additional information about the scoring function, like its range and default values, which can be used by some data valuation @@ -37,7 +36,7 @@ class Scorer: Args: scoring: Either a string or callable that can be passed to - `get_scorer `_. + [get_scorer](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.get_scorer.html). default: score to be used when a model cannot be fit, e.g. when too little data is passed, or errors arise. range: numerical range of the score function. Some Monte Carlo diff --git a/src/pydvl/value/shapley/knn.py b/src/pydvl/value/shapley/knn.py index da69f1d3c..55d457843 100644 --- a/src/pydvl/value/shapley/knn.py +++ b/src/pydvl/value/shapley/knn.py @@ -34,7 +34,7 @@ def knn_shapley(u: Utility, *, progress: bool = True) -> ValuationResult: Returns: Object with the data values. - :raises TypeError: If the model in the utility is not a `KNeighborsClassifier `_ + :raises TypeError: If the model in the utility is not a [KNeighborsClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html) !!! info "New in version 0.1.0" From e464f3ae01ad4d8d617b23ae065e63aaf9e06a89 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Wed, 14 Jun 2023 15:10:35 +0200 Subject: [PATCH 076/436] Linting and a code block --- src/pydvl/influence/frameworks/torch_differentiable.py | 2 +- src/pydvl/utils/caching.py | 8 ++++---- src/pydvl/utils/dataset.py | 2 +- src/pydvl/utils/parallel/map_reduce.py | 2 +- src/pydvl/value/least_core/montecarlo.py | 2 +- src/pydvl/value/shapley/gt.py | 2 +- 6 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 6a2dac65b..8519fa1c5 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -54,7 +54,7 @@ def __init__( self.loss = loss def num_params(self) -> int: - """ Returns the number of parameters of the model """ + """Returns the number of parameters of the model""" model_parameters = filter(lambda p: p.requires_grad, self.model.parameters()) return sum([np.prod(p.size()) for p in model_parameters]) diff --git a/src/pydvl/utils/caching.py b/src/pydvl/utils/caching.py index 66a03888e..c68e835d0 100644 --- a/src/pydvl/utils/caching.py +++ b/src/pydvl/utils/caching.py @@ -153,10 +153,10 @@ def memcached( !!! Warning Do not cache functions with state! See :ref:`cache reuse` - .. code-block:: python - :caption: Example usage - - cached_fun = memcached(**asdict(cache_options))(heavy_computation) + !!! example + ```python + cached_fun = memcached(**asdict(cache_options))(heavy_computation) + ``` Args: client_config: configuration for `pymemcache's Client() diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index 045967d11..341aa3492 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -734,7 +734,7 @@ def synthetic_classification_dataset( def decision_boundary_fixed_variance_2d( mu_1: np.ndarray, mu_2: np.ndarray ) -> Callable[[np.ndarray], np.ndarray]: - """ Closed-form solution for decision boundary dot(a, b) + b = 0 with fixed + """Closed-form solution for decision boundary dot(a, b) + b = 0 with fixed variance. Args: diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index 49a2a1dd4..010751146 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -251,7 +251,7 @@ def _backpressure( n_finished: Returns: - + """ if self.max_parallel_tasks is None: return 0 diff --git a/src/pydvl/value/least_core/montecarlo.py b/src/pydvl/value/least_core/montecarlo.py index b55edd448..cfd8c0cb3 100644 --- a/src/pydvl/value/least_core/montecarlo.py +++ b/src/pydvl/value/least_core/montecarlo.py @@ -150,7 +150,7 @@ def _montecarlo_least_core( job_id: Integer id used to determine the position of the progress bar Returns: - + """ n = len(u.data) diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index 3e612953b..1e195adab 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -131,7 +131,7 @@ def _group_testing_shapley( job_id: id to use for reporting progress (e.g. to place progres bars) Returns: - + """ rng = np.random.default_rng() n = len(u.data.indices) From 4ff80c17a7db9d7b365f9c8a1f2b4874710d6c25 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Wed, 14 Jun 2023 16:08:37 +0200 Subject: [PATCH 077/436] Some refs and tips --- src/pydvl/utils/caching.py | 4 +-- src/pydvl/utils/dataset.py | 44 ++++++++++++------------ src/pydvl/utils/numeric.py | 5 ++- src/pydvl/utils/score.py | 2 +- src/pydvl/value/least_core/__init__.py | 4 +-- src/pydvl/value/result.py | 47 +++++++++++++------------- src/pydvl/value/shapley/gt.py | 8 ++--- src/pydvl/value/shapley/knn.py | 2 +- src/pydvl/value/shapley/owen.py | 4 +-- 9 files changed, 60 insertions(+), 60 deletions(-) diff --git a/src/pydvl/utils/caching.py b/src/pydvl/utils/caching.py index c68e835d0..6ee9a0722 100644 --- a/src/pydvl/utils/caching.py +++ b/src/pydvl/utils/caching.py @@ -15,7 +15,7 @@ Memoization is disabled by default but can be enabled easily, see :ref:`caching setup`. When enabled, it will be added to any callable used to construct a -:class:`pydvl.utils.utility.Utility` (done with the decorator :func:`memcached`). +:class:`pydvl.utils.utility.Utility` (done with the decorator [@memcached][pydvl.utils.caching.memcached]). Depending on the nature of the utility you might want to enable the computation of a running average of function values, see :ref:`caching stochastic functions`. You can see all configuration options under @@ -151,7 +151,7 @@ def memcached( `rtol_stderr * running average`. !!! Warning - Do not cache functions with state! See :ref:`cache reuse` + Do not cache functions with state! See :ref:`cache reuse` !!! example ```python diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index 341aa3492..fa7905d65 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -178,7 +178,7 @@ def get_test_data( be those of the training data and would not work on the test data. There may be cases where it is desired to use parts of the test data. - In those cases, it is recommended to inherit from the :class:`Dataset` + In those cases, it is recommended to inherit from the [Dataset][pydvl.utils.Dataset] class and to override the :meth:`~Dataset.get_test_data` method. For example, the following snippet shows how one could go about @@ -256,7 +256,7 @@ def from_sklearn( stratify_by_target: bool = False, **kwargs, ) -> "Dataset": - """Constructs a :class:`Dataset` object from an + """Constructs a [Dataset][pydvl.utils.Dataset] object from an :class:`sklearn.utils.Bunch`, as returned by the `load_*` functions in [sklearn toy datasets](https://scikit-learn.org/stable/datasets/toy_dataset.html). @@ -273,13 +273,13 @@ def from_sklearn( fashion, using the target variable as labels. Read more in [scikit-learn's user guide](https://scikit-learn.org/stable/modules/cross_validation.html#stratification). kwargs: Additional keyword arguments to pass to the - :class:`Dataset` constructor. Use this to pass e.g. ``is_multi_output``. + [Dataset][pydvl.utils.Dataset] constructor. Use this to pass e.g. ``is_multi_output``. Returns: Object with the sklearn dataset - !!! info "Changed in version 0.6.0" - Added kwargs to pass to the :class:`Dataset` constructor. + !!! tip "Changed in version 0.6.0" + Added kwargs to pass to the [Dataset][pydvl.utils.Dataset] constructor. """ x_train, x_test, y_train, y_test = train_test_split( data.data, @@ -309,7 +309,7 @@ def from_arrays( stratify_by_target: bool = False, **kwargs, ) -> "Dataset": - """Constructs a :class:`Dataset` object from X and y numpy arrays as + """Constructs a [Dataset][pydvl.utils.Dataset] object from X and y numpy arrays as returned by the `make_*` functions in [sklearn generated datasets](https://scikit-learn.org/stable/datasets/sample_generators.html). Args: @@ -321,16 +321,16 @@ def from_arrays( using the y variable as labels. Read more in [sklearn's user guide](https://scikit-learn.org/stable/modules/cross_validation.html#stratification). kwargs: Additional keyword arguments to pass to the - :class:`Dataset` constructor. Use this to pass e.g. ``feature_names`` + [Dataset][pydvl.utils.Dataset] constructor. Use this to pass e.g. ``feature_names`` or ``target_names``. Returns: Object with the passed X and y arrays split across training and test sets. - !!! info "New in version 0.4.0" + !!! tip "New in version 0.4.0" - !!! info "Changed in version 0.6.0" - Added kwargs to pass to the :class:`Dataset` constructor. + !!! tip "Changed in version 0.6.0" + Added kwargs to pass to the [Dataset][pydvl.utils.Dataset] constructor. """ x_train, x_test, y_train, y_test = train_test_split( X, @@ -378,9 +378,9 @@ def __init__( from ``data_groups`` will be used. description: A textual description of the dataset kwargs: Additional keyword arguments to pass to the - :class:`Dataset` constructor. + [Dataset][pydvl.utils.Dataset] constructor. - !!! info "Changed in version 0.6.0" + !!! tip "Changed in version 0.6.0" Added ``group_names`` and forwarding of ``kwargs`` """ super().__init__( @@ -455,7 +455,7 @@ def from_sklearn( data_groups: Optional[Sequence] = None, **kwargs, ) -> "GroupedDataset": - """Constructs a :class:`GroupedDataset` object from a scikit-learn bunch + """Constructs a [GroupedDataset][pydvl.utils.GroupedDataset] object from a scikit-learn bunch as returned by the `load_*` functions in `sklearn toy datasets `_ and groups it. @@ -476,7 +476,7 @@ def from_sklearn( data point. The length of this array must be equal to the number of data points in the dataset. kwargs: Additional keyword arguments to pass to the - :class:`Dataset` constructor. + [Dataset][pydvl.utils.Dataset] constructor. Returns: Dataset with the selected sklearn data @@ -511,7 +511,7 @@ def from_arrays( data_groups: Optional[Sequence] = None, **kwargs, ) -> "Dataset": - """Constructs a :class:`GroupedDataset` object from X and y numpy arrays + """Constructs a [GroupedDataset][pydvl.utils.GroupedDataset] object from X and y numpy arrays as returned by the `make_*` functions in `sklearn generated datasets `_. @@ -532,10 +532,10 @@ def from_arrays( Returns: Dataset with the passed X and y arrays split across training and test sets. - !!! info "New in version 0.4.0" + !!! tip "New in version 0.4.0" - !!! info "Changed in version 0.6.0" - Added kwargs to pass to the :class:`Dataset` constructor. + !!! tip "Changed in version 0.6.0" + Added kwargs to pass to the [Dataset][pydvl.utils.Dataset] constructor. """ if data_groups is None: raise ValueError( @@ -558,8 +558,8 @@ def from_arrays( def from_dataset( cls, dataset: Dataset, data_groups: Sequence[Any] ) -> "GroupedDataset": - """Creates a :class:`GroupedDataset` object from the data a - :class:`Dataset` object and a mapping of data groups. + """Creates a [GroupedDataset][pydvl.utils.GroupedDataset] object from the data a + [Dataset][pydvl.utils.Dataset] object and a mapping of data groups. Args: dataset: The original data. @@ -568,8 +568,8 @@ def from_dataset( data points in the dataset. Returns: - A :class:`GroupedDataset` with the initial :class:`Dataset` grouped - by data_groups. + A [GroupedDataset][pydvl.utils.GroupedDataset] with the initial + [Dataset][pydvl.utils.Dataset] grouped by data_groups. """ return cls( x_train=dataset.x_train, diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index 623a52f2d..115fd3427 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -94,8 +94,7 @@ def random_powerset( To generate subsets, `len(s)` Bernoulli draws with probability `q` are drawn. The default value of `q = 0.5` provides a uniform distribution over the power set of `s`. Other choices can be used e.g. to implement - :func:`Owen sampling - `. + :func:`Owen sampling `. Args: s: set to sample from @@ -105,7 +104,7 @@ def random_powerset( uniform distribution over the power set of s. Returns: - Samples from the power set of s + Samples from the power set of `s`. :raises: ValueError: if the element sampling probability is not in [0,1] diff --git a/src/pydvl/utils/score.py b/src/pydvl/utils/score.py index 862384d65..c3ab9b233 100644 --- a/src/pydvl/utils/score.py +++ b/src/pydvl/utils/score.py @@ -47,7 +47,7 @@ class Scorer: name: The name of the scorer. If not provided, the name of the function passed will be used. - !!! info "New in version 0.5.0" + !!! tip "New in version 0.5.0" """ diff --git a/src/pydvl/value/least_core/__init__.py b/src/pydvl/value/least_core/__init__.py index 476736753..b50f135ab 100644 --- a/src/pydvl/value/least_core/__init__.py +++ b/src/pydvl/value/least_core/__init__.py @@ -1,5 +1,5 @@ """ -!!! info "New in version 0.4.0" +!!! tip "New in version 0.4.0" This package holds all routines for the computation of Least Core data values. @@ -76,7 +76,7 @@ def compute_least_core_values( Returns: ValuationResult object with the computed values. - !!! info "New in version 0.5.0" + !!! tip "New in version 0.5.0" """ progress: bool = kwargs.pop("progress", False) diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index ebf3696a5..f3d3e923e 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -2,7 +2,7 @@ This module collects types and methods for the inspection of the results of valuation algorithms. -The most important class is :class:`ValuationResult`, which provides access +The most important class is [ValuationResult][pydvl.value.result.ValuationResult], which provides access to raw values, as well as convenient behaviour as a ``Sequence`` with extended indexing and updating abilities, and conversion to `pandas DataFrames `_. @@ -14,7 +14,7 @@ weighted average of the two results, with the weights being the number of updates in each result: adding two results is the same as generating one result with the mean of the values of the two results as values. The variances are -updated accordingly. See :class:`ValuationResult` for details. +updated accordingly. See [ValuationResult][pydvl.value.result.ValuationResult] for details. Results can also be sorted by value, variance or number of updates, see :meth:`ValuationResult.sort`. The arrays of [ValuationResult.values][ValuationResult.values], @@ -22,7 +22,7 @@ [ValuationResult.indices` and :attr:`ValuationResult.names][ValuationResult.indices` and :attr:`ValuationResult.names] are sorted in the same way. -Indexing and slicing of results is supported and :class:`ValueItem` objects are +Indexing and slicing of results is supported and [ValueItem][pydvl.value.result.ValueItem] objects are returned. These objects can be compared with the usual operators, which take only the [ValueItem.value][ValueItem.value] into account. @@ -95,7 +95,7 @@ class ValueItem(Generic[IndexT, NameT]): """ #: Index of the sample with this value in the original - # :class:`~pydvl.utils.dataset.Dataset` + # [Dataset][pydvl.utils.dataset.Dataset] index: IndexT #: Name of the sample if it was provided. Otherwise, `str(index)` name: NameT @@ -128,14 +128,15 @@ class ValuationResult( ): """Objects of this class hold the results of valuation algorithms. - These include indices in the original :class:`Dataset`, any data names (e.g. - group names in :class:`GroupedDataset`), the values themselves, and variance - of the computation in the case of Monte Carlo methods. ``ValuationResults`` - can be iterated over like any ``Sequence``: ``iter(valuation_result)`` - returns a generator of :class:`ValueItem` in the order in which the object + These include indices in the original [Dataset][pydvl.utils.dataset.Dataset], + any data names (e.g. group names in [GroupedDataset][pydvl.utils.dataset.GroupedDataset]), + the values themselves, and variance of the computation in the case of Monte + Carlo methods. ``ValuationResults`` can be iterated over like any ``Sequence``: + ``iter(valuation_result)`` returns a generator of + [ValueItem][pydvl.value.result.ValueItem] in the order in which the object is sorted. - .. rubric:: Indexing + # Indexing Indexing can be position-based, when accessing any of the attributes :attr:`values`, :attr:`variances`, :attr:`counts` and :attr:`indices`, as @@ -148,23 +149,23 @@ class ValuationResult( original dataset. This is the case for the methods :meth:`get` and :meth:`update`. - .. rubric:: Sorting + # Sorting Results can be sorted in-place with :meth:`sort`, or alternatively using python's standard ``sorted()`` and ``reversed()`` Note that sorting values affects how iterators and the object itself as ``Sequence`` behave: - ``values[0]`` returns a :class:`ValueItem` with the highest or lowest + ``values[0]`` returns a [ValueItem][pydvl.value.result.ValueItem] with the highest or lowest ranking point if this object is sorted by descending or ascending value, respectively. If unsorted, ``values[0]`` returns the ``ValueItem`` at position 0, which has data index ``indices[0]`` in the - :class:`~pydvl.utils.dataset.Dataset`. + [Dataset][pydvl.utils.dataset.Dataset]. The same applies to direct indexing of the ``ValuationResult``: the index is positional, according to the sorting. It does not refer to the "data index". To sort according to data index, use :meth:`sort` with ``key="index"``. - In order to access :class:`ValueItem` objects by their data index, use + In order to access [ValueItem][pydvl.value.result.ValueItem] objects by their data index, use :meth:`get`. .. rubric:: Operating on results @@ -182,9 +183,9 @@ class ValuationResult( or to an array of zeros if ``indices`` are given. indices: An optional array of indices in the original dataset. If omitted, defaults to ``np.arange(len(values))``. **Warning:** It is - common to pass the indices of a :class:`Dataset` here. Attention must be - paid in a parallel context to copy them to the local process. Just do - ``indices=np.copy(data.indices)``. + common to pass the indices of a [Dataset][pydvl.utils.dataset.Dataset] + here. Attention must be paid in a parallel context to copy them to + the local process. Just do ``indices=np.copy(data.indices)``. variance: An optional array of variances in the computation of each value. counts: An optional array with the number of updates for each value. Defaults to an array of ones. @@ -421,7 +422,7 @@ def __setitem__( raise TypeError("Indices must be integers, iterable or slices") def __iter__(self) -> Iterator[ValueItem[IndexT, NameT]]: - """Iterate over the results returning :class:`ValueItem` objects. + """Iterate over the results returning [ValueItem][pydvl.value.result.ValueItem] objects. To sort in place before iteration, use :meth:`sort`. """ for pos in self._sort_positions: @@ -659,7 +660,7 @@ def to_dataframe( def from_random( cls, size: int, total: Optional[float] = None, **kwargs ) -> "ValuationResult": - """Creates a :class:`ValuationResult` object and fills it with an array + """Creates a [ValuationResult][pydvl.value.result.ValuationResult] object and fills it with an array of random values from a uniform distribution in [-1,1]. The values can be made to sum up to a given total number (doing so will change their range). @@ -668,7 +669,7 @@ def from_random( total: If set, the values are normalized to sum to this number ("efficiency" property of Shapley values). kwargs: Additional options to pass to the constructor of - :class:`ValuationResult`. Use to override status, names, etc. + [ValuationResult][pydvl.value.result.ValuationResult]. Use to override status, names, etc. Returns: A valuation result with its status set to @@ -676,7 +677,7 @@ def from_random( :raises ValueError: If ``size`` is less than 1. - !!! info "Changed in version 0.6.0" + !!! tip "Changed in version 0.6.0" Added parameter ``total``. Check for zero size """ if size < 1: @@ -706,7 +707,7 @@ def empty( data_names: Optional[Sequence[NameT] | NDArray[NameT]] = None, n_samples: int = 0, ) -> "ValuationResult": - """Creates an empty :class:`ValuationResult` object. + """Creates an empty [ValuationResult][pydvl.value.result.ValuationResult] object. Empty results are characterised by having an empty array of values. When another result is added to an empty one, the empty one is discarded. @@ -734,7 +735,7 @@ def zeros( data_names: Optional[Sequence[NameT] | NDArray[NameT]] = None, n_samples: int = 0, ) -> "ValuationResult": - """Creates an empty :class:`ValuationResult` object. + """Creates an empty [ValuationResult][pydvl.value.result.ValuationResult] object. Empty results are characterised by having an empty array of values. When another result is added to an empty one, the empty one is ignored. diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index 1e195adab..9449e797b 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -12,7 +12,7 @@ You can read more [in the documentation][computing-data-values]. -!!! info "New in version 0.4.0" +!!! tip "New in version 0.4.0" """ import logging @@ -109,7 +109,7 @@ def num_samples_eps_delta( Number of samples from $2^{[n]}$ guaranteeing ε/√n-correct Shapley pair-wise differences of values with probability 1-δ/(N(N-1)). - !!! info "New in version 0.4.0" + !!! tip "New in version 0.4.0" """ constants = _constants(n=n, epsilon=eps, delta=delta, utility_range=utility_range) @@ -193,9 +193,9 @@ def group_testing_shapley( Returns: Object with the data values. - !!! info "New in version 0.4.0" + !!! tip "New in version 0.4.0" - !!! info "Changed in version 0.5.0" + !!! tip "Changed in version 0.5.0" Changed the solver to cvxpy instead of scipy's linprog. Added the ability to pass arbitrary options to it. """ diff --git a/src/pydvl/value/shapley/knn.py b/src/pydvl/value/shapley/knn.py index 55d457843..4e056f17d 100644 --- a/src/pydvl/value/shapley/knn.py +++ b/src/pydvl/value/shapley/knn.py @@ -36,7 +36,7 @@ def knn_shapley(u: Utility, *, progress: bool = True) -> ValuationResult: :raises TypeError: If the model in the utility is not a [KNeighborsClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html) - !!! info "New in version 0.1.0" + !!! tip "New in version 0.1.0" """ if not isinstance(u.model, KNeighborsClassifier): diff --git a/src/pydvl/value/shapley/owen.py b/src/pydvl/value/shapley/owen.py index 4ff48cfb8..272d2aec4 100644 --- a/src/pydvl/value/shapley/owen.py +++ b/src/pydvl/value/shapley/owen.py @@ -146,9 +146,9 @@ def owen_sampling_shapley( Returns: Object with the data values. - !!! info "New in version 0.3.0" + !!! tip "New in version 0.3.0" - !!! info "Changed in version 0.5.0" + !!! tip "Changed in version 0.5.0" Support for parallel computation and enable antithetic sampling. """ From 4f78edb8d504e838c30bfb2ae58c85ae5f4976a7 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 15 Jun 2023 09:15:07 +0200 Subject: [PATCH 078/436] Links to classes and functions --- src/pydvl/utils/caching.py | 6 ++-- src/pydvl/utils/config.py | 2 +- src/pydvl/utils/dataset.py | 32 +++++++++++--------- src/pydvl/utils/numeric.py | 2 +- src/pydvl/utils/parallel/backend.py | 11 ++++--- src/pydvl/utils/parallel/futures/__init__.py | 3 +- src/pydvl/utils/parallel/futures/ray.py | 2 +- src/pydvl/utils/parallel/map_reduce.py | 2 +- src/pydvl/utils/score.py | 22 ++++++++------ src/pydvl/value/result.py | 2 +- src/pydvl/value/shapley/common.py | 12 ++++---- src/pydvl/value/shapley/gt.py | 5 ++- src/pydvl/value/shapley/montecarlo.py | 2 +- src/pydvl/value/shapley/owen.py | 2 +- src/pydvl/value/shapley/truncated.py | 2 +- src/pydvl/value/stopping.py | 20 ++++++------ 16 files changed, 66 insertions(+), 61 deletions(-) diff --git a/src/pydvl/utils/caching.py b/src/pydvl/utils/caching.py index 6ee9a0722..d20bf000b 100644 --- a/src/pydvl/utils/caching.py +++ b/src/pydvl/utils/caching.py @@ -15,11 +15,11 @@ Memoization is disabled by default but can be enabled easily, see :ref:`caching setup`. When enabled, it will be added to any callable used to construct a -:class:`pydvl.utils.utility.Utility` (done with the decorator [@memcached][pydvl.utils.caching.memcached]). +[Utility][pydvl.utils.utility.Utility] (done with the decorator [@memcached][pydvl.utils.caching.memcached]). Depending on the nature of the utility you might want to enable the computation of a running average of function values, see :ref:`caching stochastic functions`. You can see all configuration options under -:class:`~pydvl.utils.config.MemcachedConfig`. +[MemcachedConfig][pydvl.utils.config.MemcachedConfig]. ## Default configuration @@ -63,7 +63,7 @@ cached_fun = memcached(**asdict(cache_options))(fun, signature=custom_signature) ``` -If you are running experiments with the same :class:`~pydvl.utils.utility.Utility` +If you are running experiments with the same [Utility][pydvl.utils.utility.Utility] but different datasets, this will lead to evaluations of the utility on new data returning old values because utilities only use sample indices as arguments (so there is no way to tell the difference between '1' for dataset A and '1' for diff --git a/src/pydvl/utils/config.py b/src/pydvl/utils/config.py index 9a77bc058..eb8d3fc55 100644 --- a/src/pydvl/utils/config.py +++ b/src/pydvl/utils/config.py @@ -62,7 +62,7 @@ class MemcachedConfig: memoization of function calls. Instances of this class are typically used as arguments for the construction - of a :class:`~pydvl.utils.utility.Utility`. + of a [Utility][pydvl.utils.utility.Utility]. Args: client_config: Configuration for the connection to the memcached server. diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index fa7905d65..477341412 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -5,14 +5,14 @@ (the *utility*). This is typically the performance of the model on a test set (as an approximation to its true expected performance). It is therefore convenient to keep both the training data and the test data together to be passed around to -methods in [least_core][pydvl.value.shapley` and :mod:`~pydvl.value.least_core]. -This is done with :class:`~pydvl.utils.dataset.Dataset`. +methods in [shapley][pydvl.value.shapley] and [least_core][pydvl.value.least_core]. +This is done with [Dataset][pydvl.utils.dataset.Dataset]. This abstraction layer also seamlessly grouping data points together if one is interested in computing their value as a group, see -:class:`~pydvl.utils.dataset.GroupedDataset`. +[GroupedDataset][pydvl.utils.dataset.GroupedDataset]. -Objects of both types are used to construct a :class:`~pydvl.utils.utility.Utility` +Objects of both types are used to construct a [Utility][pydvl.utils.utility.Utility] object. """ @@ -147,13 +147,14 @@ def get_training_data( """Given a set of indices, returns the training data that refer to those indices. - This is used mainly by :class:`~pydvl.utils.utility.Utility` to retrieve + This is used mainly by [Utility][pydvl.utils.utility.Utility] to retrieve subsets of the data from indices. It is typically **not needed in algorithms**. Args: - indices: Optional indices that will be used to select points from the - training data. If ``None``, the entire training data will be returned. + indices: Optional indices that will be used to select points from + the training data. If ``None``, the entire training data will be + returned. Returns: If ``indices`` is not ``None``, the selected x and y arrays from the @@ -174,7 +175,7 @@ def get_test_data( we generally want to score the trained model on the entire test data. Additionally, the way this method is used in the - :class:`~pydvl.utils.utility.Utility` class, the passed indices will + [Utility][pydvl.utils.utility.Utility] class, the passed indices will be those of the training data and would not work on the test data. There may be cases where it is desired to use parts of the test data. @@ -256,8 +257,8 @@ def from_sklearn( stratify_by_target: bool = False, **kwargs, ) -> "Dataset": - """Constructs a [Dataset][pydvl.utils.Dataset] object from an - :class:`sklearn.utils.Bunch`, as returned by the `load_*` functions in + """Constructs a [Dataset][pydvl.utils.Dataset] object from a + [Bunch][sklearn.utils.Bunch], as returned by the `load_*` functions in [sklearn toy datasets](https://scikit-learn.org/stable/datasets/toy_dataset.html). Args: @@ -523,14 +524,15 @@ def from_arrays( stratify_by_target: If ``True``, data is split in a stratified fashion, using the y variable as labels. Read more in [sklearn's user guide](https://scikit-learn.org/stable/modules/cross_validation.html#stratification). - data_groups: an array holding the group index or name for each - data point. The length of this array must be equal to the number of + data_groups: an array holding the group index or name for each data + point. The length of this array must be equal to the number of data points in the dataset. - kwargs: Additional keyword arguments that will be passed - to the :class:`~pydvl.utils.dataset.Dataset` constructor. + kwargs: Additional keyword arguments that will be passed to the + [Dataset][pydvl.utils.Dataset] constructor. Returns: - Dataset with the passed X and y arrays split across training and test sets. + Dataset with the passed X and y arrays split across training and + test sets. !!! tip "New in version 0.4.0" diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index 115fd3427..0f5351a2f 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -58,7 +58,7 @@ def num_samples_permutation_hoeffding(eps: float, delta: float, u_range: float) Args: eps: ε > 0 delta: 0 < δ <= 1 - u_range: Range of the :class:`~pydvl.utils.utility.Utility` function + u_range: Range of the [Utility][pydvl.utils.utility.Utility] function Returns: Number of _permutations_ required to guarantee ε-correct Shapley diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index 5cfd3766c..64bcc931c 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -98,7 +98,8 @@ class SequentialParallelBackend(BaseParallelBackend, backend_name="sequential"): [init_parallel_backend()][pydvl.utils.parallel.backend.init_parallel_backend]. Args: - config: instance of :class:`~pydvl.utils.config.ParallelConfig` with number of cpus + config: instance of [ParallelConfig][pydvl.utils.config.ParallelConfig] + with number of cpus """ def __init__(self, config: ParallelConfig): @@ -130,8 +131,8 @@ class RayParallelBackend(BaseParallelBackend, backend_name="ray"): [init_parallel_backend()][pydvl.utils.parallel.backend.init_parallel_backend]. Args: - config: instance of :class:`~pydvl.utils.config.ParallelConfig` with - cluster address, number of cpus, etc. + config: instance of [ParallelConfig][pydvl.utils.config.ParallelConfig] + with cluster address, number of cpus, etc. """ def __init__(self, config: ParallelConfig): @@ -207,7 +208,7 @@ def init_parallel_backend( """Initializes the parallel backend and returns an instance of it. Args: - config: instance of :class:`~pydvl.utils.config.ParallelConfig` + config: instance of [ParallelConfig][pydvl.utils.config.ParallelConfig] with cluster address, number of cpus, etc. :Example: @@ -252,7 +253,7 @@ def effective_n_jobs(n_jobs: int, config: ParallelConfig = ParallelConfig()) -> Args: n_jobs: the number of jobs requested. If -1, the number of available CPUs is returned. - config: instance of :class:`~pydvl.utils.config.ParallelConfig` with + config: instance of [ParallelConfig][pydvl.utils.config.ParallelConfig] with cluster address, number of cpus, etc. Returns: diff --git a/src/pydvl/utils/parallel/futures/__init__.py b/src/pydvl/utils/parallel/futures/__init__.py index 00cde41b7..5166a2769 100644 --- a/src/pydvl/utils/parallel/futures/__init__.py +++ b/src/pydvl/utils/parallel/futures/__init__.py @@ -18,7 +18,8 @@ def init_executor( Args: max_workers: Maximum number of concurrent tasks. - config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. + config: instance of [ParallelConfig][pydvl.utils.config.ParallelConfig] + with cluster address, number of cpus, etc. kwargs: Other optional parameter that will be passed to the executor. Examples: diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index cc3453b1e..4a357e5f0 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -32,7 +32,7 @@ class RayExecutor(Executor): value and the n_cpus_per_job parameter passed to submit() does not exceed available cluster resources. If set to `None`, it will default to the total number of vCPUs in the ray cluster. - config: instance of :class:`~pydvl.utils.config.ParallelConfig` + config: instance of [ParallelConfig][pydvl.utils.config.ParallelConfig] with cluster address, number of cpus, etc. cancel_futures_on_exit: If ``True``, all futures will be cancelled when exiting the context created by using this class instance as a diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index 010751146..116170e70 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -92,7 +92,7 @@ class MapReduceJob(Generic[T, R]): each job. Alternatively, one can use ``itertools.partial``. reduce_kwargs: Keyword arguments that will be passed to ``reduce_func`` in each job. Alternatively, one can use [itertools.partial][]. - config: Instance of :class:`~pydvl.utils.config.ParallelConfig` + config: Instance of [ParallelConfig][pydvl.utils.config.ParallelConfig] with cluster address, number of cpus, etc. n_jobs: Number of parallel jobs to run. Does not accept 0 timeout: Amount of time in seconds to wait for remote results before diff --git a/src/pydvl/utils/score.py b/src/pydvl/utils/score.py index c3ab9b233..9d5a05736 100644 --- a/src/pydvl/utils/score.py +++ b/src/pydvl/utils/score.py @@ -1,15 +1,17 @@ """ -This module provides a :class:`Scorer` class that wraps scoring functions with -additional information. +This module provides a [Scorer][pydvl.utils.score.Scorer] class that wraps +scoring functions with additional information. Scorers can be constructed in the same way as in scikit-learn: either from known strings or from a callable. Greater values must be better. If they are not, -a negated version can be used, see scikit-learn's [make_scorer()](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.make_scorer.html). - -:class:`Scorer` provides additional information about the scoring function, like -its range and default values, which can be used by some data valuation -methods (like [group_testing_shapley()][pydvl.value.shapley.gt.group_testing_shapley]) to estimate -the number of samples required for a certain quality of approximation. +a negated version can be used, see scikit-learn's +[make_scorer()](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.make_scorer.html). + +[Scorer][pydvl.utils.score.Scorer] provides additional information about the +scoring function, like its range and default values, which can be used by some +data valuation methods (like +[group_testing_shapley()][pydvl.value.shapley.gt.group_testing_shapley]) to +estimate the number of samples required for a certain quality of approximation. """ from typing import Callable, Optional, Protocol, Tuple, Union @@ -102,11 +104,11 @@ def compose_score( scorer: The object to be composed. transformation: A scalar transformation range: The range of the transformation. This will be used e.g. by - :class:`~pydvl.utils.utility.Utility` for the range of the composed. + [Utility][pydvl.utils.utility.Utility] for the range of the composed. name: A string representation for the composition, for `str()`. Returns: - The composite :class:`Scorer`. + The composite [Scorer][pydvl.utils.score.Scorer]. """ class CompositeScorer(Scorer): diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index f3d3e923e..e8aadf40f 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -487,7 +487,7 @@ def __add__(self, other: "ValuationResult") -> "ValuationResult": Abusing this will introduce numerical errors. Means and standard errors are correctly handled. Statuses are added with - bit-wise ``&``, see :class:`~pydvl.value.result.Status`. + bit-wise ``&``, see [Status][pydvl.value.result.Status]. ``data_names`` are taken from the left summand, or if unavailable from the right one. The ``algorithm`` string is carried over if both terms have the same one or concatenated. diff --git a/src/pydvl/value/shapley/common.py b/src/pydvl/value/shapley/common.py index 0a66e8d09..b9f26100a 100644 --- a/src/pydvl/value/shapley/common.py +++ b/src/pydvl/value/shapley/common.py @@ -55,7 +55,7 @@ def compute_shapley_values( - ``owen_sampling``: Uses the Owen continuous extension of the utility function to the unit cube. Implemented in [owen_sampling_shapley()][pydvl.value.shapley.montecarlo.owen_sampling_shapley]. This - method does not take a :class:`~pydvl.value.stopping.StoppingCriterion` + method does not take a [StoppingCriterion][pydvl.value.stopping.StoppingCriterion] but instead requires a parameter ``q_max`` for the number of subdivisions of the unit interval to use for integration, and another parameter ``n_samples`` for the number of subsets to sample for each $q$. @@ -68,7 +68,7 @@ def compute_shapley_values( - ``group_testing``: estimates differences of Shapley values and solves a constraint satisfaction problem. High sample complexity, not recommended. Implemented in [group_testing_shapley()][pydvl.value.shapley.gt.group_testing_shapley]. This - method does not take a :class:`~pydvl.value.stopping.StoppingCriterion` + method does not take a [StoppingCriterion][pydvl.value.stopping.StoppingCriterion] but instead requires a parameter ``n_samples`` for the number of iterations to run. @@ -78,9 +78,9 @@ def compute_shapley_values( [knn_shapley()][pydvl.value.shapley.knn.knn_shapley]. Args: - u: :class:`~pydvl.utils.utility.Utility` object with model, data, and + u: [Utility][pydvl.utils.utility.Utility] object with model, data, and scoring function. - done: :class:`~pydvl.value.stopping.StoppingCriterion` object, used to + done: [StoppingCriterion][pydvl.value.stopping.StoppingCriterion] object, used to determine when to stop the computation for Monte Carlo methods. The default is to stop after 100 iterations. See the available criteria in [stopping][pydvl.value.stopping]. It is possible to combine several @@ -88,10 +88,10 @@ def compute_shapley_values( others require specific subtypes. n_jobs: Number of parallel jobs (available only to some methods) mode: Choose which shapley algorithm to use. See - :class:`~pydvl.value.shapley.ShapleyMode` for a list of allowed value. + [ShapleyMode][pydvl.value.shapley.ShapleyMode] for a list of allowed value. Returns: - A :class:`~pydvl.value.result.ValuationResult` object with the results. + A [ValuationResult][pydvl.value.result.ValuationResult] object with the results. """ progress: bool = kwargs.pop("progress", False) diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index 9449e797b..9b01f40ee 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -56,7 +56,7 @@ def _constants( - q: the probability of drawing a sample of size k - q_tot: another normalization constant - T: the number of iterations. This will be -1 if the utility_range is - infinite. E.g. because the :class:`~pydvl.utils.score.Scorer` does + infinite. E.g. because the [Scorer][pydvl.utils.score.Scorer] does not define a range. """ r = utility_range @@ -103,8 +103,7 @@ def num_samples_eps_delta( eps: ε delta: δ n: Number of data points - utility_range: Range of the :class:`~pydvl.utils.utility.Utility` - function + utility_range: Range of the [Utility][pydvl.utils.utility.Utility] function Returns: Number of samples from $2^{[n]}$ guaranteeing ε/√n-correct Shapley pair-wise differences of values with probability 1-δ/(N(N-1)). diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index cae5d853c..7fd90211f 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -24,7 +24,7 @@ .. seealso:: Additionally, you can consider grouping your data points using - :class:`~pydvl.utils.dataset.GroupedDataset` and computing the values of the + [GroupedDataset][pydvl.utils.dataset.GroupedDataset] and computing the values of the groups instead. This is not to be confused with "group testing" as implemented in [group_testing_shapley()][pydvl.value.shapley.gt.group_testing_shapley]: any of the algorithms mentioned above, including Group Testing, can work to valuate diff --git a/src/pydvl/value/shapley/owen.py b/src/pydvl/value/shapley/owen.py index 272d2aec4..7fa5ab5b6 100644 --- a/src/pydvl/value/shapley/owen.py +++ b/src/pydvl/value/shapley/owen.py @@ -129,7 +129,7 @@ def owen_sampling_shapley( The outer integration could be done instead with a quadrature rule. Args: - u: :class:`~pydvl.utils.utility.Utility` object holding data, model + u: [Utility][pydvl.utils.utility.Utility] object holding data, model and scoring function. n_samples: Numer of sets to sample for each value of q max_q: Number of subdivisions for q ∈ [0,1] (the element sampling diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 256180666..69bb7a935 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -34,7 +34,7 @@ class TruncationPolicy(abc.ABC): !!! Todo Because the policy objects are copied to the workers, the statistics are not accessible from the - :class:`~pydvl.value.shapley.actor.ShapleyCoordinator`. We need to add + [ShapleyCoordinator][pydvl.value.shapley.actor.ShapleyCoordinator]. We need to add methods for this. """ diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index fe6e88c4f..2272a0a53 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -24,7 +24,7 @@ Objects of type :class:`StoppingCriterion` can be composed with the binary operators ``&`` (*and*), and ``|`` (*or*), following the truth tables of -:class:`~pydvl.utils.status.Status`. The unary operator ``~`` (*not*) is also +[Status][pydvl.utils.status.Status]. The unary operator ``~`` (*not*) is also supported. See :class:`StoppingCriterion` for details on how these operations affect the behavior of the stopping criteria. """ @@ -63,19 +63,19 @@ class StoppingCriterion(abc.ABC): must stop. A ``StoppingCriterion`` is a callable taking a - :class:`~pydvl.value.result.ValuationResult` and returning a - :class:`~pydvl.value.result.Status`. It also keeps track of individual + [ValuationResult][pydvl.value.result.ValuationResult] and returning a + [Status][pydvl.value.result.Status]. It also keeps track of individual convergence of values with :meth:`converged`, and reports the overall completion of the computation with :meth:`completion`. Instances of ``StoppingCriterion`` can be composed with the binary operators ``&`` (*and*), and ``|`` (*or*), following the truth tables of - :class:`~pydvl.utils.status.Status`. The unary operator ``~`` (*not*) is + [Status][pydvl.utils.status.Status]. The unary operator ``~`` (*not*) is also supported. These boolean operations act according to the following rules: - The results of :meth:`_check` are combined with the operator. See - :class:`~pydvl.utils.status.Status` for the truth tables. + [Status][pydvl.utils.status.Status] for the truth tables. - The results of :meth:`converged` are combined with the operator (returning another boolean array). - The :meth:`completion` method returns the min, max, or the complement to 1 @@ -88,8 +88,8 @@ class StoppingCriterion(abc.ABC): .. rubric:: Subclassing Subclassing this class requires implementing a :meth:`_check` method that - returns a :class:`~pydvl.utils.status.Status` object based on a given - :class:`~pydvl.value.result.ValuationResult`. This method should update the + returns a [Status][pydvl.utils.status.Status] object based on a given + [ValuationResult][pydvl.value.result.ValuationResult]. This method should update the :attr:`converged` attribute, which is a boolean array indicating whether the value for each index has converged. When this is not possible, :meth:`completion` should be overridden to provide an overall completion @@ -97,7 +97,7 @@ class StoppingCriterion(abc.ABC): Args: modify_result: If ``True`` the status of the input - :class:`~pydvl.value.result.ValuationResult` is modified in place after + [ValuationResult][pydvl.value.result.ValuationResult] is modified in place after the call. """ @@ -309,7 +309,7 @@ class MaxUpdates(StoppingCriterion): threshold. This checks the ``counts`` field of a - :class:`~pydvl.value.result.ValuationResult`, i.e. the number of times that + [ValuationResult][pydvl.value.result.ValuationResult], i.e. the number of times that each index has been updated. For powerset samplers, the maximum of this number coincides with the maximum number of subsets sampled. For permutation samplers, it coincides with the number of permutations sampled. @@ -348,7 +348,7 @@ class MinUpdates(StoppingCriterion): """Terminate as soon as all value updates exceed or equal the given threshold. This checks the ``counts`` field of a - :class:`~pydvl.value.result.ValuationResult`, i.e. the number of times that + [ValuationResult][pydvl.value.result.ValuationResult], i.e. the number of times that each index has been updated. For powerset samplers, the minimum of this number is a lower bound for the number of subsets sampled. For permutation samplers, it lower-bounds the amount of permutations sampled. From 660dede08d7bef0daeb0356fe7a1292bf0101dc5 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 15 Jun 2023 09:43:53 +0200 Subject: [PATCH 079/436] Tweaks to header bar logo --- docs/assets/logo.svg | 202 +---------------------------------------- docs/assets/signet.svg | 1 + docs/css/extra.css | 7 ++ mkdocs.yml | 4 +- 4 files changed, 11 insertions(+), 203 deletions(-) create mode 100644 docs/assets/signet.svg diff --git a/docs/assets/logo.svg b/docs/assets/logo.svg index 3a846f7e2..5869662b9 100644 --- a/docs/assets/logo.svg +++ b/docs/assets/logo.svg @@ -1,201 +1 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + \ No newline at end of file diff --git a/docs/assets/signet.svg b/docs/assets/signet.svg new file mode 100644 index 000000000..068ac68e8 --- /dev/null +++ b/docs/assets/signet.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/docs/css/extra.css b/docs/css/extra.css index 401dd36bd..2951125d5 100644 --- a/docs/css/extra.css +++ b/docs/css/extra.css @@ -63,3 +63,10 @@ a.autorefs-external:hover::after { .nt-card-image:focus { filter: invert(32%) sepia(93%) saturate(1535%) hue-rotate(220deg) brightness(102%) contrast(99%); } +.md-header__button.md-logo { + padding: 0; +} + +.md-header__button.md-logo img, .md-header__button.md-logo svg { + height: 1.9rem; +} diff --git a/mkdocs.yml b/mkdocs.yml index aa86e7a22..f4d385b8b 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -54,8 +54,8 @@ plugins: theme: name: material custom_dir: docs/overrides - logo: assets/logo.svg - favicon: assets/logo.svg + logo: assets/signet.svg + favicon: assets/signet.svg icon: repo: fontawesome/brands/github features: From 5f2bcec22bcb84e1d564dabcb5a9333d60bb5052 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 15 Jun 2023 09:48:54 +0200 Subject: [PATCH 080/436] Minor --- docs/20-install.md | 4 ++-- docs/index.md | 6 ++---- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/docs/20-install.md b/docs/20-install.md index 7259cfac4..785203488 100644 --- a/docs/20-install.md +++ b/docs/20-install.md @@ -66,8 +66,8 @@ docker container run -d --rm -p 11211:11211 memcached:latest !!! Warning To read more about caching and how it might affect your usage, in particular - about cache reuse and its pitfalls, please the documentation for the module - :mod:`pydvl.utils.caching`. + about cache reuse and its pitfalls, please read the documentation for the + [caching module][pydvl.utils.caching]. # What's next diff --git a/docs/index.md b/docs/index.md index cd2ee99c2..a8e832ab3 100644 --- a/docs/index.md +++ b/docs/index.md @@ -1,10 +1,8 @@ --- -title: Home +title: pyDVL documentation --- -# pyDVL Documentation - -Welcome to the pyDVL library for data valuation! +# The python library for data valuation pyDVL collects algorithms for data valuation and influence function computation. It runs most of them in parallel either locally or in a cluster and supports From 5fa738c10fbceecb1914c781aa47c66d48145724 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 15 Jun 2023 09:50:53 +0200 Subject: [PATCH 081/436] Citations --- src/pydvl/utils/utility.py | 3 +-- src/pydvl/value/semivalues.py | 19 +++++++++---------- src/pydvl/value/shapley/gt.py | 6 +++--- src/pydvl/value/shapley/knn.py | 2 +- src/pydvl/value/shapley/owen.py | 2 +- src/pydvl/value/shapley/truncated.py | 6 +++--- src/pydvl/value/stopping.py | 2 +- 7 files changed, 19 insertions(+), 21 deletions(-) diff --git a/src/pydvl/utils/utility.py b/src/pydvl/utils/utility.py index 9f318948f..0821aa478 100644 --- a/src/pydvl/utils/utility.py +++ b/src/pydvl/utils/utility.py @@ -254,8 +254,7 @@ def __setstate__(self, state): class DataUtilityLearning: - """Implementation of Data Utility Learning algorithm - :footcite:t:`wang_improving_2022`. + """Implementation of Data Utility Learning [@wang_improving_2022]. This object wraps a [Utility][pydvl.utils.utility.Utility] and delegates calls to it, up until a given budget (number of iterations). Every tuple diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index f615b4899..f147cc7ed 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -31,10 +31,9 @@ reformulation. -There are several pre-defined coefficients, including the Shapley value -of :footcite:t:`ghorbani_data_2019`, the Banzhaf index of -:footcite:t:`wang_data_2022`, and the Beta coefficient of -:footcite:t:`kwon_beta_2022`. +There are several pre-defined coefficients, including the Shapley value of +[@ghorbani_data_2019], the Banzhaf index of [@wang_data_2022], and the Beta +coefficient of [@kwon_beta_2022]. !!! Note For implementation consistency, we slightly depart from the common definition @@ -217,12 +216,12 @@ def compute_semivalues( The modes supported are: - [SemiValueMode.Shapley][SemiValueMode.Shapley]: Shapley values. - - [SemiValueMode.BetaShapley][SemiValueMode.BetaShapley]: Implements the Beta Shapley semi-value - as introduced in :footcite:t:`kwon_beta_2022`. Pass additional keyword - arguments ``alpha`` and ``beta`` to set the parameters of the Beta - distribution (both default to 1). - - [SemiValueMode.Banzhaf][SemiValueMode.Banzhaf]: Implements the Banzhaf semi-value as - introduced in :footcite:t:`wang_data_2022`. + - [SemiValueMode.BetaShapley][SemiValueMode.BetaShapley]: Implements the + Beta Shapley semi-value as introduced in [@kwon_beta_2022]. Pass additional + keyword arguments ``alpha`` and ``beta`` to set the parameters of the Beta + distribution (both default to 1). + - [SemiValueMode.Banzhaf][SemiValueMode.Banzhaf]: Implements the Banzhaf + semi-value as introduced in [@wang_data_2022]. Args: u: Utility object with model, data, and scoring function. diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index 9b01f40ee..e439acee5 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -1,6 +1,6 @@ """ This module implements Group Testing for the approximation of Shapley values, as -introduced in :footcite:t:`jia_efficient_2019`. The sampling of index subsets is +introduced in [@jia_efficient_2019]. The sampling of index subsets is done in such a way that an approximation to the true Shapley values can be computed with guarantees. @@ -94,7 +94,7 @@ def h(u: T) -> T: def num_samples_eps_delta( eps: float, delta: float, n: int, utility_range: float ) -> int: - r"""Implements the formula in Theorem 3 of :footcite:t:`jia_efficient_2019` + r"""Implements the formula in Theorem 3 of [@jia_efficient_2019] which gives a lower bound on the number of samples required to obtain an (ε/√n,δ/(N(N-1))-approximation to all pair-wise differences of Shapley values, wrt. $\ell_2$ norm. @@ -159,7 +159,7 @@ def group_testing_shapley( **options, ) -> ValuationResult: """Implements group testing for approximation of Shapley values as described - in :footcite:t:`jia_efficient_2019`. + in [@jia_efficient_2019]. !!! Warning This method is very inefficient. It requires several orders of magnitude diff --git a/src/pydvl/value/shapley/knn.py b/src/pydvl/value/shapley/knn.py index 4e056f17d..861ee2218 100644 --- a/src/pydvl/value/shapley/knn.py +++ b/src/pydvl/value/shapley/knn.py @@ -20,7 +20,7 @@ def knn_shapley(u: Utility, *, progress: bool = True) -> ValuationResult: """Computes exact Shapley values for a KNN classifier. - This implements the method described in :footcite:t:`jia_efficient_2019a`. + This implements the method described in [@jia_efficient_2019a]. It exploits the local structure of K-Nearest Neighbours to reduce the number of calls to the utility function to a constant number per index, thus reducing computation time to $O(n)$. diff --git a/src/pydvl/value/shapley/owen.py b/src/pydvl/value/shapley/owen.py index 7fa5ab5b6..d8a01eba7 100644 --- a/src/pydvl/value/shapley/owen.py +++ b/src/pydvl/value/shapley/owen.py @@ -98,7 +98,7 @@ def owen_sampling_shapley( progress: bool = False, ) -> ValuationResult: r"""Owen sampling of Shapley values as described in - :footcite:t:`okhrati_multilinear_2021`. + [@okhrati_multilinear_2021]. This function computes a Monte Carlo approximation to diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 69bb7a935..f1e367a69 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -105,7 +105,7 @@ def reset(self): class RelativeTruncation(TruncationPolicy): """Break a permutation if the marginal utility is too low. - This is called "performance tolerance" in :footcite:t:`ghorbani_data_2019`. + This is called "performance tolerance" in [@ghorbani_data_2019]. Args: u: Utility object with model, data, and scoring function @@ -209,7 +209,7 @@ def truncated_montecarlo_shapley( """Monte Carlo approximation to the Shapley value of data points. This implements the permutation-based method described in - :footcite:t:`ghorbani_data_2019`. It is a Monte Carlo estimate of the sum + [@ghorbani_data_2019]. It is a Monte Carlo estimate of the sum over all possible permutations of the index set, with a double stopping criterion. @@ -220,7 +220,7 @@ def truncated_montecarlo_shapley( Instead of naively implementing the expectation, we sequentially add points to a dataset from a permutation and incrementally compute marginal utilities. We stop computing marginals for a given permutation based on a - :class:`TruncationPolicy`. :footcite:t:`ghorbani_data_2019` mention two + :class:`TruncationPolicy`. [@ghorbani_data_2019] mention two policies: one that stops after a certain fraction of marginals are computed, implemented in :class:`FixedTruncation`, and one that stops if the last computed utility ("score") is close to the total utility using the standard diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index 2272a0a53..0b8a3470e 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -418,7 +418,7 @@ class HistoryDeviation(StoppingCriterion): r"""A simple check for relative distance to a previous step in the computation. - The method used by :footcite:t:`ghorbani_data_2019` computes the relative + The method used by [@ghorbani_data_2019] computes the relative distances between the current values $v_i^t$ and the values at the previous checkpoint $v_i^{t-\tau}$. If the sum is below a given threshold, the computation is terminated. From 0cbbc40f6fa13f5e8f6bb6086366769cdf1ef0fb Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 15 Jun 2023 09:51:08 +0200 Subject: [PATCH 082/436] Fixes --- src/pydvl/value/least_core/common.py | 2 +- src/pydvl/value/shapley/naive.py | 4 ++-- src/pydvl/value/shapley/truncated.py | 5 ++--- 3 files changed, 5 insertions(+), 6 deletions(-) diff --git a/src/pydvl/value/least_core/common.py b/src/pydvl/value/least_core/common.py index 874d4ccfd..1164b220f 100644 --- a/src/pydvl/value/least_core/common.py +++ b/src/pydvl/value/least_core/common.py @@ -219,7 +219,7 @@ def _solve_least_core_linear_program( solver_options: dict, non_negative_subsidy: bool = False, ) -> Tuple[Optional[NDArray[np.float_]], Optional[float]]: - """Solves the Least Core's linear program using cvxopt. + r"""Solves the Least Core's linear program using cvxopt. .. math:: diff --git a/src/pydvl/value/shapley/naive.py b/src/pydvl/value/shapley/naive.py index 036f79ec0..0a6aae744 100644 --- a/src/pydvl/value/shapley/naive.py +++ b/src/pydvl/value/shapley/naive.py @@ -22,8 +22,8 @@ def permutation_exact_shapley(u: Utility, *, progress: bool = True) -> Valuation When the length of the training set is > 10 this prints a warning since the computation becomes too expensive. Used mostly for internal testing and - simple use cases. Please refer to the :mod:`Monte Carlo - ` approximations for practical applications. + simple use cases. Please refer to the [Monte Carlo + approximations][pydvl.value.shapley.montecarlo] for practical applications. Args: u: Utility object with model, data, and scoring function diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index f1e367a69..165a6fb5f 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -33,9 +33,8 @@ class TruncationPolicy(abc.ABC): !!! Todo Because the policy objects are copied to the workers, the statistics - are not accessible from the - [ShapleyCoordinator][pydvl.value.shapley.actor.ShapleyCoordinator]. We need to add - methods for this. + are not accessible from the coordinating process. We need to add methods + for this. """ def __init__(self): From 6712dc79f0046acffb8e1d797362efc8c0737053 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 15 Jun 2023 11:14:06 +0200 Subject: [PATCH 083/436] Remove sphinx-related files --- docs/conf.py | 419 ---------------------------------------- docs/examples/index.rst | 21 -- 2 files changed, 440 deletions(-) delete mode 100644 docs/conf.py delete mode 100644 docs/examples/index.rst diff --git a/docs/conf.py b/docs/conf.py deleted file mode 100644 index b9e13dd9c..000000000 --- a/docs/conf.py +++ /dev/null @@ -1,419 +0,0 @@ -# -*- coding: utf-8 -*- -# -# pyDVL documentation build configuration file -# -# This file is execfile()d with the current directory set to its containing dir. -# -# All configuration values have a default; values that are commented out -# serve to show the default. - -import ast -import logging -import os -import sys -from pathlib import Path - -import pkg_resources - -logger = logging.getLogger("docs") - -ROOT_DIR = Path(__file__).resolve().parent.parent - -# If extensions (or modules to document with autodoc) are in another directory, -# add these directories to sys.path here. If the directory is relative to the -# documentation root, use os.path.abspath to make it absolute, like shown here. -sys.path.insert(0, os.fspath(ROOT_DIR / "src")) - -# For custom extensions -sys.path.append(os.path.abspath("_ext")) - -# -- General configuration ----------------------------------------------------- - -# If your documentation needs a minimal Sphinx version, state it here. -# needs_sphinx = '1.0' - -# Add any Sphinx extension module names here, as strings. They can be extensions -# coming with Sphinx (named 'sphinx.ext.*') or your custom ones. -extensions = [ - "sphinx.ext.napoleon", - "sphinx.ext.autodoc", - "sphinx.ext.doctest", - "sphinx.ext.linkcode", - "sphinx.ext.mathjax", - "sphinx.ext.extlinks", - "sphinx_math_dollar", - "sphinx.ext.todo", - "hoverxref.extension", # This only works on read the docs - "sphinx_design", - "sphinxcontrib.bibtex", - "nbsphinx", - # see https://github.com/spatialaudio/nbsphinx/issues/24 for an explanation why this extension is necessary - "IPython.sphinxext.ipython_console_highlighting", - # Custom extensions - "copy_notebooks", -] - -# sphinx_math_dollar -mathjax3_config = { - "tex": { - "inlineMath": [["\\(", "\\)"]], - "displayMath": [["\\[", "\\]"]], - } -} - -extlinks_detect_hardcoded_links = True -extlinks = { - "gh": ("https://github.com/appliedAI-Initiative/pyDVL/%s", "GitHub %s"), - "issue": ("https://github.com/appliedAI-Initiative/pyDVL/issues/%s", "issue %s"), - "tfl": ("https://transferlab.appliedai.de/%s", "%s"), -} - -bibtex_bibfiles = ["pydvl.bib"] -bibtex_bibliography_header = "References\n==========" -bibtex_footbibliography_header = bibtex_bibliography_header - -# NBSphinx - -# This is processed by Jinja2 and inserted before each notebook -nbsphinx_prolog = r""" -{% set docname = env.doc2path(env.docname, base=False).replace('examples', 'notebooks') %} - -.. raw:: html - -
- This page was generated from - {{ docname|e }} -
- Interactive online version: - - - Binder badge - - -
- - -""" - -# Display todos by setting to True -todo_include_todos = True - - -# adding links to source files (this works for gitlab and github like hosts and might need to be adjusted for others) -# see https://www.sphinx-doc.org/en/master/usage/extensions/linkcode.html#module-sphinx.ext.linkcode -def linkcode_resolve(domain, info): - link_prefix = "https://github.com/appliedAI-Initiative/pyDVL/blob/develop" - if domain != "py": - return None - if not info["module"]: - return None - - path, link_extension = get_path_and_link_extension(info["module"]) - object_name = info["fullname"] - if ( - "." in object_name - ): # don't add source link to methods within classes (you might want to change that) - return None - lineno = lineno_from_object_name(path, object_name) - return f"{link_prefix}/{link_extension}#L{lineno}" - - -def get_path_and_link_extension(module: str): - """ - :return: tuple of the form (path, link_extension) where - the first entry is the local path to a given module or to __init__.py of the package - and the second entry is the corresponding path from the top level directory - """ - filename = module.replace(".", "/") - docs_dir = os.path.dirname(os.path.realpath(__file__)) - source_path_prefix = os.path.join(docs_dir, f"../src/{filename}") - - if os.path.exists(source_path_prefix + ".py"): - link_extension = f"src/{filename}.py" - return source_path_prefix + ".py", link_extension - elif os.path.exists(os.path.join(source_path_prefix, "__init__.py")): - link_extension = f"src/{filename}/__init__.py" - return os.path.join(source_path_prefix, "__init__.py"), link_extension - else: - raise Exception( - f"{source_path_prefix} is neither a module nor a package with init - " - f"did you forget to add an __init__.py?" - ) - - -def lineno_from_object_name(source_file, object_name): - desired_node_name = object_name.split(".")[0] - with open(source_file, "r") as f: - source_node = ast.parse(f.read()) - desired_node = next( - ( - node - for node in source_node.body - if getattr(node, "name", "") == desired_node_name - ), - None, - ) - if desired_node is None: - logger.warning(f"Could not find object {desired_node_name} in {source_file}") - return 0 - else: - return desired_node.lineno - - -# this is useful for keeping the docs build environment small. Add heavy requirements here -# and all other requirements to docs/requirements.txt -autodoc_mock_imports = [] - -autodoc_default_options = { - "exclude-members": "log", - "member-order": "bysource", - "show-inheritance": True, -} - -# Add any paths that contain templates here, relative to this directory. -templates_path = ["_templates"] - -# The suffix of source filenames. -source_suffix = ".rst" - -# The encoding of source files. -# source_encoding = 'utf-8-sig' - -# The master toctree document. -master_doc = "index" - -# General information about the project. -project = "pyDVL" - -# The version info for the project you're documenting, acts as replacement for -# |version| and |release|, also used in various other places throughout the -# built documents. -# -# The full version, including alpha/beta/rc tags. -version = pkg_resources.get_distribution(project).version -release = version -# The short X.Y version. -major_v, minor_v = version.split(".")[:2] -version = f"{major_v}.{minor_v}" - -# The language for content autogenerated by Sphinx. Refer to documentation -# for a list of supported languages. -# language = None - -# There are two options for replacing |today|: either, you set today to some -# non-false value, then it is used: -# today = '' -# Else, today_fmt is used as the format for a strftime call. -# today_fmt = '%B %d, %Y' - -# List of patterns, relative to source directory, that match files and -# directories to ignore when looking for source files. -exclude_patterns = ["_build"] - -# The reST default role (used for this markup: `text`) to use for all documents. -# default_role = None - -# If true, '()' will be appended to :func: etc. cross-reference text. -# add_function_parentheses = True - -# If true, the current module name will be prepended to all description -# unit titles (such as .. function::). -add_module_names = False - -# If true, sectionauthor and moduleauthor directives will be shown in the -# output. They are ignored by default. -# show_authors = False - -# The name of the Pygments (syntax highlighting) style to use. -pygments_style = "sphinx" - -# A list of ignored prefixes for module index sorting. -# modindex_common_prefix = [] - - -# -- Options for HTML output --------------------------------------------------- - -# Add a tooltip to all :ref: roles -# This requires a backend server to retrieve the tooltip content. As of Nov 22, -# sphinx-hoverxref only supports Read the Docs as backend. -# See https://sphinx-hoverxref.readthedocs.io/en/latest/configuration.html -# for further configuration options -# hoverxref_auto_ref = True - -# The theme to use for HTML and HTML Help pages. See the documentation for -# a list of builtin themes. -html_theme = "furo" - -# Furo theme options: -html_theme_options = { - "sidebar_hide_name": True, - "navigation_with_keys": True, - "announcement": "pyDVL is in an early stage of development. Expect changes to functionality and the API until version 1.0.0.", - "footer_icons": [ - { - "name": "GitHub", - "url": "https://github.com/appliedAI-Initiative/pyDVL", - "html": """ - - - - """, - "class": "", - }, - ], -} - -# Add any paths that contain custom themes here, relative to this directory. -# html_theme_path = [] - -# The name for this set of Sphinx documents. If None, it defaults to -# " v documentation". -# html_title = None - -# A shorter title for the navigation bar. Default is the same as html_title. -# html_short_title = None - -# The name of an image file (relative to this directory) to place at the top -# of the sidebar. -html_logo = os.fspath(ROOT_DIR.joinpath("logo.svg")) - -# The name of an image file (within the static path) to use as favicon of the -# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 -# pixels large. -# html_favicon = None - -# Add any paths that contain custom static files (such as style sheets) here, -# relative to this directory. They are copied after the builtin static files, -# so a file named "default.css" will overwrite the builtin "default.css". -html_static_path = [] - -# If not '', a 'Last updated on:' timestamp is inserted at every page bottom, -# using the given strftime format. -# html_last_updated_fmt = '%b %d, %Y' - -# If true, SmartyPants will be used to convert quotes and dashes to -# typographically correct entities. -# html_use_smartypants = True - -# Custom sidebar templates, maps document names to template names. -# html_sidebars = {} - -# Additional templates that should be rendered to pages, maps page names to -# template names. -# html_additional_pages = {} - -# If false, no module index is generated. -# html_domain_indices = True - -# If false, no index is generated. -# html_use_index = True - -# If true, the index is split into individual pages for each letter. -# html_split_index = False - -# If true, links to the reST sources are added to the pages. -# html_show_sourcelink = True - -# If true, "Created using Sphinx" is shown in the HTML footer. Default is True. -# html_show_sphinx = True - -# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. -html_show_copyright = True -copyright = "AppliedAI Institute gGmbH" - -# If true, an OpenSearch description file will be output, and all pages will -# contain a tag referring to it. The value of this option must be the -# base URL from which the finished HTML is served. -# html_use_opensearch = '' - -# This is the file name suffix for HTML files (e.g. ".xhtml"). -# html_file_suffix = None - -# Output file base name for HTML help builder. -htmlhelp_basename = "pydvl_doc" - - -# -- Options for LaTeX output -------------------------------------------------- - -latex_elements = { - # The paper size ('letterpaper' or 'a4paper'). - # 'papersize': 'letterpaper', - # The font size ('10pt', '11pt' or '12pt'). - # 'pointsize': '10pt', - # Additional stuff for the LaTeX preamble. - # 'preamble': '', -} - -# Grouping the document tree into LaTeX files. List of tuples -# (source start file, target name, title, author, documentclass [howto/manual]). -# latex_documents = [] - -# The name of an image file (relative to this directory) to place at the top of -# the title page. -# latex_logo = None - -# For "manual" documents, if this is true, then toplevel headings are parts, -# not chapters. -# latex_use_parts = False - -# If true, show page references after internal links. -# latex_show_pagerefs = False - -# If true, show URL addresses after external links. -# latex_show_urls = False - -# Documents to append as an appendix to all manuals. -# latex_appendices = [] - -# If false, no module index is generated. -# latex_domain_indices = True - - -# -- Options for manual page output -------------------------------------------- - -# One entry per manual page. List of tuples -# (source start file, name, description, authors, manual section). -man_pages = [ - ( - "index", - "pydvl", - "", - ["appliedAI"], - 1, - ) -] - -# If true, show URL addresses after external links. -# man_show_urls = False - - -# -- Options for Texinfo output ------------------------------------------------ - -# Grouping the document tree into Texinfo files. List of tuples -# (source start file, target name, title, author, -# dir menu entry, description, category) -# texinfo_documents = [] - -# Documents to append as an appendix to all manuals. -# texinfo_appendices = [] - -# If false, no module index is generated. -# texinfo_domain_indices = True - -# How to display URL addresses: 'footnote', 'no', or 'inline'. -# texinfo_show_urls = 'footnote' diff --git a/docs/examples/index.rst b/docs/examples/index.rst deleted file mode 100644 index af5b87812..000000000 --- a/docs/examples/index.rst +++ /dev/null @@ -1,21 +0,0 @@ -.. _examples: - -Examples -======== - -The following examples illustrate the usage of pyDVL features. - -.. toctree:: - :caption: Data valuation - :titlesonly: - :glob: - - shapley* - least_core* - -.. toctree:: - :caption: Influence function - :titlesonly: - :glob: - - influence* From a1906ce0a037f2c19d703700461a5c7d5f00be6e Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 15 Jun 2023 11:14:31 +0200 Subject: [PATCH 084/436] Fixes --- src/pydvl/utils/numeric.py | 2 +- src/pydvl/value/shapley/common.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index 0f5351a2f..8ec0b8164 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -94,7 +94,7 @@ def random_powerset( To generate subsets, `len(s)` Bernoulli draws with probability `q` are drawn. The default value of `q = 0.5` provides a uniform distribution over the power set of `s`. Other choices can be used e.g. to implement - :func:`Owen sampling `. + :func:`Owen sampling `. Args: s: set to sample from diff --git a/src/pydvl/value/shapley/common.py b/src/pydvl/value/shapley/common.py index b9f26100a..fd51b0416 100644 --- a/src/pydvl/value/shapley/common.py +++ b/src/pydvl/value/shapley/common.py @@ -54,14 +54,14 @@ def compute_shapley_values( [truncated_montecarlo_shapley()][pydvl.value.shapley.montecarlo.truncated_montecarlo_shapley]. - ``owen_sampling``: Uses the Owen continuous extension of the utility function to the unit cube. Implemented in - [owen_sampling_shapley()][pydvl.value.shapley.montecarlo.owen_sampling_shapley]. This + [owen_sampling_shapley()][pydvl.value.shapley.owen.owen_sampling_shapley]. This method does not take a [StoppingCriterion][pydvl.value.stopping.StoppingCriterion] but instead requires a parameter ``q_max`` for the number of subdivisions of the unit interval to use for integration, and another parameter ``n_samples`` for the number of subsets to sample for each $q$. - ``owen_halved``: Same as 'owen_sampling' but uses correlated samples in the expectation. Implemented in - [owen_sampling_shapley()][pydvl.value.shapley.montecarlo.owen_sampling_shapley]. + [owen_sampling_shapley()][pydvl.value.shapley.owen.owen_sampling_shapley]. This method requires an additional parameter `q_max` for the number of subdivisions of the interval [0,0.5] to use for integration, and another parameter ``n_samples`` for the number of subsets to sample for each $q$. From f0f3dbc8c0d09b61d4670aaeb6a84d2ffad5a661 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 15 Jun 2023 11:15:05 +0200 Subject: [PATCH 085/436] Increase font size in banner --- docs/css/extra.css | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/css/extra.css b/docs/css/extra.css index 2951125d5..1d318766f 100644 --- a/docs/css/extra.css +++ b/docs/css/extra.css @@ -11,6 +11,7 @@ text-align: center; white-space: nowrap; color: white; + font-size: larger; } /* Indentation. */ From 3e0e9e868cad8d3b077a3e989019b17a43071783 Mon Sep 17 00:00:00 2001 From: Kristof Schroeder Date: Fri, 16 Jun 2023 17:26:58 +0200 Subject: [PATCH 086/436] Add util modul to compute approximate hessian and low rank approximations of these --- src/pydvl/influence/frameworks/util.py | 208 +++++++++++++++++++++++++ tests/influence/conftest.py | 15 ++ tests/influence/test_util.py | 113 ++++++++++++++ 3 files changed, 336 insertions(+) create mode 100644 src/pydvl/influence/frameworks/util.py create mode 100644 tests/influence/test_util.py diff --git a/src/pydvl/influence/frameworks/util.py b/src/pydvl/influence/frameworks/util.py new file mode 100644 index 000000000..3ce8c5899 --- /dev/null +++ b/src/pydvl/influence/frameworks/util.py @@ -0,0 +1,208 @@ +from dataclasses import dataclass +from typing import Callable, Tuple, Optional +import logging + +import torch +from numpy.typing import NDArray +from scipy.sparse.linalg import eigsh, LinearOperator, ArpackNoConvergence +from torch.utils.data import DataLoader + +logger = logging.getLogger(__name__) + + +def to_model_device(x: torch.Tensor, model: torch.nn.Module) -> torch.Tensor: + """ + Returns the tensor `x` moved to the device of the `model`, if device of model is set + :param x: + :param model: + :return: + """ + if hasattr(model, "device"): + return x.to(model.device) + return x + + +def hvp(model: torch.nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + x: torch.Tensor, + y: torch.Tensor, + vec: torch.Tensor) -> torch.Tensor: + """ + Returns H*vec where H is the Hessian of the loss with respect to + the model parameters. + + :param model: A torch.nn.Module, whose parameters are used for backpropagation. + :param loss: A loss function, which is a callable that takes the model's + output and target as input and returns a scalar loss. + :param x: Input tensor to the model. + :param y: Target output tensor. + :param vec: The vector with which the Hessian of the loss function is to be multiplied. + :return: A tensor of the same shape as vec, representing the product of the Hessian of the loss function + with respect to the model parameters and the input vector. + """ + outputs = model(to_model_device(x, model)) + loss_value = loss(outputs, to_model_device(y, model)) + params = [p for p in model.parameters() if p.requires_grad] + + grads = torch.autograd.grad(loss_value, params, create_graph=True) + + flat_grads = torch.cat([g.contiguous().view(-1) for g in grads]) + grad_vec_product = torch.dot(flat_grads, vec) + hessian_vec_prod = torch.autograd.grad(grad_vec_product, params) + hessian_vec_prod = torch.cat([g.contiguous().view(-1) for g in hessian_vec_prod]) + return hessian_vec_prod + + +def avg_gradient(model: torch.nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + data_loader: DataLoader) -> torch.Tensor: + """ + Returns the average gradient of the loss function with respect to the model parameters + :param model: A torch.nn.Module, whose parameters are used for backpropagation. + :param loss: A loss function, which is a callable that takes the model's + output and target as input and returns a scalar loss. + :param data_loader: an instance of :class:`torch.utils.data.DataLoader` + :return: average of batch gradients + """ + params = [p for p in model.parameters() if p.requires_grad] + total_grad_xy = None + total_points = 0 + num_batches = len(data_loader) + + for k, (x, y) in enumerate(data_loader): + logger.debug(f"Computing the gradient for batch {k+1}/{num_batches}") + outputs = model(to_model_device(x, model)) + loss_value = loss(outputs, to_model_device(y, model)) + grads = torch.autograd.grad(loss_value, params, create_graph=True) + flat_grads = torch.cat([g.contiguous().view(-1) for g in grads]) + + num_points_in_batch = len(x) + if total_grad_xy is None: + total_grad_xy = flat_grads * num_points_in_batch + else: + total_grad_xy += flat_grads * num_points_in_batch + total_points += num_points_in_batch + + return total_grad_xy / total_points + + +def get_hvp_function(model: torch.nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + data_loader: DataLoader, + use_hessian_avg: bool = True) -> Callable[[torch.Tensor], torch.Tensor]: + """ + Returns a function that calculates the approximate Hessian-vector product for a given vector. If you want to + compute the exact hessian, i.e. pulling all data into memory and compute a full gradient computation, use + the function :func:`hvp`. + + :param model: A PyTorch module representing the model whose loss function's Hessian is to be computed. + :param loss: A callable that takes the model's output and target as input and returns the scalar loss. + :param data_loader: A DataLoader instance that provides batches of data for calculating the Hessian-vector product. + Each batch from the DataLoader is assumed to return a tuple where the first element + is the model's input and the second element is the target output. + :param use_hessian_avg: If True, it will use batch-wise Hessian computation. If False, the function averages + the batch gradients and perform backpropagation on the full (averaged) gradient, + which is more accurate than averaging the batch hessians, + but probably has a way higher memory usage. + :return: A function that takes a single argument, a vector, and returns the product of the Hessian of the + `loss` function with respect to the `model`'s parameters and the input vector. + + """ + + def hvp_function(vec: torch.Tensor) -> torch.Tensor: + params = [p for p in model.parameters() if p.requires_grad] + avg_grad = avg_gradient(model, loss, data_loader) + + grad_vec_product = torch.dot(avg_grad, vec) + hessian_vec_prod = torch.autograd.grad(grad_vec_product, params) + hessian_vec_prod = torch.cat([g.contiguous().view(-1) for g in hessian_vec_prod]) + return hessian_vec_prod + + def avg_hvp_function(vec: torch.Tensor) -> torch.Tensor: + hessian_vec_prod_sum = None + + for inputs, targets in iter(data_loader): + hessian_vec_prod = hvp(model, loss, inputs, targets, vec) + + if hessian_vec_prod_sum is None: + hessian_vec_prod_sum = hessian_vec_prod + else: + hessian_vec_prod_sum += hessian_vec_prod + + return hessian_vec_prod_sum / len(data_loader) + + return avg_hvp_function if use_hessian_avg else hvp_function + + +@dataclass +class LowRankProductRepresentation: + """ + Representation of a low rank product of the form $H = V D V^T$, where D is a diagonal matrix and + V is orthogonal + :param eigen_vals: diagonal of D + :param projections: the matrix V + """ + eigen_vals: torch.Tensor + projections: torch.Tensor + + +def lanzcos_low_rank_hessian_approx(hessian_vp: Callable[[torch.Tensor], torch.Tensor], + matrix_shape: Tuple[int, int], + hessian_perturbation: float = 0.0, + rank_estimate: int = 10, + krylov_dimension: Optional[int] = None, + x0: Optional[torch.Tensor] = None, + tol: float = 1e-6, + max_iter: Optional[int] = None, + device: Optional[torch.device] = None, + ) -> LowRankProductRepresentation: + """ + Calculates a low-rank approximation of the Hessian matrix of the model's loss function using the implicitly + restarted Lanczos algorithm, provided by scipy wrapper to ARPACK. + + + :param hessian_vp: A function that takes a vector and returns the product of the Hessian of the loss function + :param matrix_shape: The shape of the matrix, represented by hessian vector product. + :param hessian_perturbation: Optional regularization parameter added to the Hessian-vector product + for numerical stability. + :param rank_estimate: The number of eigenvalues and corresponding eigenvectors to compute. + Represents the desired rank of the Hessian approximation. + :param krylov_dimension: The number of Krylov vectors to use for the Lanczos method. + If not provided, it defaults to $min(model.num_parameters, max(2*rank_estimate + 1, 20))$. + :param x0: An optional initial vector to use in the Lanczos algorithm. + If not provided, a random initial vector is used. + :param tol: The stopping criteria for the Lanczos algorithm, which stops when the difference + in the approximated eigenvalue is less than `tol`. Defaults to 1e-6. + :param max_iter: The maximum number of iterations for the Lanczos method. If not provided, it defaults to + $10*model.num_parameters$ + :param device: The device to use for the hessian vector product. + :return: A `LowRankProductRepresentation` instance that contains the top (up until rank_estimate) eigenvalues + and corresponding eigenvectors of the Hessian. + """ + + def mv(x: NDArray) -> NDArray: + x = torch.from_numpy(x) + if device is not None: + x = x.to(device) + y = hessian_vp(x) + hessian_perturbation * x + return y.cpu().numpy() + + try: + eigen_vals, eigen_vecs = eigsh( + A=LinearOperator(matrix_shape, matvec=mv), + k=rank_estimate, + maxiter=max_iter, + tol=tol, + ncv=krylov_dimension, + return_eigenvectors=True, + v0=x0.cpu().numpy() if x0 is not None else None + ) + except ArpackNoConvergence as e: + logger.warning(f"ARPACK did not converge for parameters {max_iter=}, {tol=}, {krylov_dimension=}, " + f"{rank_estimate=}. \n Returning the best approximation found so far. Use those with care or " + f"modify parameters.\n Original error: {e}") + return LowRankProductRepresentation(torch.from_numpy(e.eigenvalues), torch.from_numpy(e.eigenvectors)) + + return LowRankProductRepresentation(torch.from_numpy(eigen_vals), torch.from_numpy(eigen_vecs)) + + diff --git a/tests/influence/conftest.py b/tests/influence/conftest.py index ce13e9b32..130e95476 100644 --- a/tests/influence/conftest.py +++ b/tests/influence/conftest.py @@ -2,6 +2,7 @@ import numpy as np import pytest +import torch.nn from numpy.typing import NDArray from sklearn.preprocessing import MinMaxScaler @@ -43,6 +44,20 @@ def linear_model(problem_dimension: Tuple[int, int], condition_number: float): return A, b +def linear_torch_model_from_numpy(A: NDArray, b: NDArray) -> torch.nn.Module: + """ + Given numpy arrays representing the model $xA^t + b$, the function returns the corresponding torch model + :param A: + :param b: + :return: + """ + output_dimension, input_dimension = tuple(A.shape) + model = torch.nn.Linear(input_dimension, output_dimension) + model.eval() + model.weight.data = torch.as_tensor(A) + model.bias.data = torch.as_tensor(b) + return model + def linear_derivative_analytical( linear_model: Tuple[NDArray[np.float_], NDArray[np.float_]], x: NDArray[np.float_], diff --git a/tests/influence/test_util.py b/tests/influence/test_util.py new file mode 100644 index 000000000..22feea7e1 --- /dev/null +++ b/tests/influence/test_util.py @@ -0,0 +1,113 @@ +from dataclasses import dataclass +from typing import Tuple + +import pytest +import numpy as np +import scipy +import torch + +from torch.utils.data import DataLoader, TensorDataset + +from pydvl.influence.frameworks.util import get_hvp_function, lanzcos_low_rank_hessian_approx, hvp +from tests.influence.conftest import linear_model, linear_hessian_analytical, linear_torch_model_from_numpy + + +@dataclass +class UtilTestParameters: + """ + Helper class to add more test parameter combinations + """ + dimension: Tuple[int, int] + condition_number: float + train_size: int + batch_size: int + rank_estimate: int + regularization: float + + +test_parameters = [ + UtilTestParameters(dimension=(30, 16), condition_number=4, train_size=60, batch_size=4, rank_estimate=50, + regularization=0.0001), + UtilTestParameters(dimension=(32, 35), condition_number=1e6, train_size=100, batch_size=5, rank_estimate=70, + regularization=0.00001), + UtilTestParameters(dimension=(25, 15), condition_number=1e3, train_size=90, batch_size=10, rank_estimate=50, + regularization=0.000001), + UtilTestParameters(dimension=(30, 15), condition_number=1e4, train_size=120, batch_size=8, rank_estimate=60, + regularization=0.00001), + UtilTestParameters(dimension=(40, 13), condition_number=1e5, train_size=900, batch_size=4, rank_estimate=90, + regularization=0.00001), +] + + +dimensions = [(30, 16), (32, 35), (25, 15), (30, 15), (40, 13)] +condition_numbers = [4, 1e6, 1e3, 1e4, 1e5] +train_sizes = [60, 100, 90, 120, 900] +batch_sizes = [4, 5, 10, 8, 4] +rank_estimates = [50, 70, 50, 60, 90] +regularizations = [0.0001, 0.00001, 0.000001, 0.00001, 0.00001] + + +problem_params = [(tp.dimension, tp.condition_number, tp.train_size) for tp in test_parameters] + + +@pytest.fixture(params=problem_params) +def model_data(request): + dimension, condition_number, train_size = request.param # type: ignore + A, b = linear_model(dimension, condition_number) + x = np.random.uniform(size=[train_size, dimension[-1]]) + y = np.random.uniform(size=[train_size, dimension[0]]) + torch_model = linear_torch_model_from_numpy(A, b) + num_params = sum(p.numel() for p in torch_model.parameters() if p.requires_grad) + vec = np.random.uniform(size=(num_params, )) + H_analytical = linear_hessian_analytical((A, b), x) + x = torch.as_tensor(x) + y = torch.as_tensor(y) + vec = torch.as_tensor(vec) + H_analytical = torch.as_tensor(H_analytical) + return torch_model, x, y, vec, H_analytical + + +@pytest.mark.parametrize("model_data, tol", + [(problem_param, 1e-12) for problem_param in problem_params], + indirect=["model_data"]) +def test_hvp(model_data, tol: float): + torch_model, x, y, vec, H_analytical = model_data + Hvp_autograd = hvp(torch_model, torch.nn.functional.mse_loss, x, y, vec) + assert torch.allclose(Hvp_autograd, H_analytical@vec, rtol=tol) + + +@pytest.mark.parametrize("use_avg, tol", [(True, 1e-3), (False, 1e-6)], ids=["avg", "full"]) +@pytest.mark.parametrize("model_data, batch_size", + list(zip(problem_params, batch_sizes)), + indirect=["model_data"]) +def test_get_hvp_function(model_data, tol: float, use_avg: bool, batch_size: int): + torch_model, x, y, vec, H_analytical = model_data + data_loader = DataLoader(TensorDataset(x, y), batch_size=batch_size) + Hvp_autograd = get_hvp_function(torch_model, torch.nn.functional.mse_loss, data_loader, + use_hessian_avg=use_avg)(vec) + assert torch.allclose(Hvp_autograd, H_analytical@vec, rtol=tol) + + +@pytest.mark.parametrize("model_data, batch_size, rank_estimate, regularization", + list(zip(problem_params, batch_sizes, rank_estimates, regularizations)), + indirect=["model_data"]) +def test_lanzcos_low_rank_hessian_approx(model_data, batch_size: int, rank_estimate, regularization): + _, _, _, vec, H_analytical = model_data + + # artificially make the analytical hessian low rank + reg_H_analytical = H_analytical + regularization * torch.eye(H_analytical.shape[0]) + eig_val_analytical, proj_analytical = scipy.linalg.eigh(reg_H_analytical.numpy()) + eig_val_analytical, proj_analytical = torch.as_tensor(eig_val_analytical), torch.as_tensor(proj_analytical) + idx_analytical = torch.argsort(torch.abs(eig_val_analytical), descending=True) + eig_val_analytical = eig_val_analytical[idx_analytical[:rank_estimate]] + proj_analytical = proj_analytical[:, idx_analytical[:rank_estimate]] + low_rank_approx_analytical = proj_analytical @ torch.diag(eig_val_analytical) @ proj_analytical.t() + + low_rank_approx = lanzcos_low_rank_hessian_approx(lambda z: reg_H_analytical @ z, + reg_H_analytical.shape, + rank_estimate=rank_estimate) + + D = torch.diag(low_rank_approx.eigen_vals) + proj = low_rank_approx.projections + + assert torch.allclose((proj @ D @ proj.t()) @ vec, low_rank_approx_analytical @ vec, rtol=1e-1) From 4d4c29e207035ba4434f76753751266ac9938927 Mon Sep 17 00:00:00 2001 From: Kristof Schroeder Date: Fri, 16 Jun 2023 17:28:10 +0200 Subject: [PATCH 087/436] Suppress DeprecationWarnings for pkg_resources when running pytest --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index 2d453cf3e..206829f39 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -24,6 +24,7 @@ log_level = "INFO" markers = [ "torch: Mark a test function that uses PyTorch" ] +filterwarnings = "ignore::DeprecationWarning:pkg_resources.*:" [tool.coverage.run] branch = true From dbf74e74b8c97140b9bca8610ff9fa7a7868a683 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Fri, 16 Jun 2023 21:10:31 +0200 Subject: [PATCH 088/436] Improve readability of test_utils --- tests/influence/test_util.py | 54 +++++++++++++++++++----------------- 1 file changed, 29 insertions(+), 25 deletions(-) diff --git a/tests/influence/test_util.py b/tests/influence/test_util.py index 22feea7e1..d2d49c88c 100644 --- a/tests/influence/test_util.py +++ b/tests/influence/test_util.py @@ -1,4 +1,4 @@ -from dataclasses import dataclass +from dataclasses import dataclass, astuple from typing import Tuple import pytest @@ -12,47 +12,51 @@ from tests.influence.conftest import linear_model, linear_hessian_analytical, linear_torch_model_from_numpy +@dataclass +class ModelParams: + dimension: Tuple[int, int] + condition_number: float + train_size: int + + @dataclass class UtilTestParameters: """ Helper class to add more test parameter combinations """ - dimension: Tuple[int, int] - condition_number: float - train_size: int + model_params: ModelParams batch_size: int rank_estimate: int regularization: float test_parameters = [ - UtilTestParameters(dimension=(30, 16), condition_number=4, train_size=60, batch_size=4, rank_estimate=50, + UtilTestParameters(ModelParams(dimension=(30, 16), condition_number=4, train_size=60), + batch_size=4, + rank_estimate=50, regularization=0.0001), - UtilTestParameters(dimension=(32, 35), condition_number=1e6, train_size=100, batch_size=5, rank_estimate=70, + UtilTestParameters(ModelParams(dimension=(32, 35), condition_number=1e6, train_size=100), + batch_size=5, + rank_estimate=70, regularization=0.00001), - UtilTestParameters(dimension=(25, 15), condition_number=1e3, train_size=90, batch_size=10, rank_estimate=50, + UtilTestParameters(ModelParams(dimension=(25, 15), condition_number=1e3, train_size=90), + batch_size=10, + rank_estimate=50, regularization=0.000001), - UtilTestParameters(dimension=(30, 15), condition_number=1e4, train_size=120, batch_size=8, rank_estimate=60, + UtilTestParameters(ModelParams(dimension=(30, 15), condition_number=1e4, train_size=120), + batch_size=8, + rank_estimate=60, regularization=0.00001), - UtilTestParameters(dimension=(40, 13), condition_number=1e5, train_size=900, batch_size=4, rank_estimate=90, + UtilTestParameters(ModelParams(dimension=(40, 13), condition_number=1e5, train_size=900), + batch_size=4, + rank_estimate=90, regularization=0.00001), ] -dimensions = [(30, 16), (32, 35), (25, 15), (30, 15), (40, 13)] -condition_numbers = [4, 1e6, 1e3, 1e4, 1e5] -train_sizes = [60, 100, 90, 120, 900] -batch_sizes = [4, 5, 10, 8, 4] -rank_estimates = [50, 70, 50, 60, 90] -regularizations = [0.0001, 0.00001, 0.000001, 0.00001, 0.00001] - - -problem_params = [(tp.dimension, tp.condition_number, tp.train_size) for tp in test_parameters] - - -@pytest.fixture(params=problem_params) +@pytest.fixture def model_data(request): - dimension, condition_number, train_size = request.param # type: ignore + dimension, condition_number, train_size = request.param A, b = linear_model(dimension, condition_number) x = np.random.uniform(size=[train_size, dimension[-1]]) y = np.random.uniform(size=[train_size, dimension[0]]) @@ -68,7 +72,7 @@ def model_data(request): @pytest.mark.parametrize("model_data, tol", - [(problem_param, 1e-12) for problem_param in problem_params], + [(astuple(tp.model_params), 1e-12) for tp in test_parameters], indirect=["model_data"]) def test_hvp(model_data, tol: float): torch_model, x, y, vec, H_analytical = model_data @@ -78,7 +82,7 @@ def test_hvp(model_data, tol: float): @pytest.mark.parametrize("use_avg, tol", [(True, 1e-3), (False, 1e-6)], ids=["avg", "full"]) @pytest.mark.parametrize("model_data, batch_size", - list(zip(problem_params, batch_sizes)), + [(astuple(tp.model_params), tp.batch_size) for tp in test_parameters], indirect=["model_data"]) def test_get_hvp_function(model_data, tol: float, use_avg: bool, batch_size: int): torch_model, x, y, vec, H_analytical = model_data @@ -89,7 +93,7 @@ def test_get_hvp_function(model_data, tol: float, use_avg: bool, batch_size: int @pytest.mark.parametrize("model_data, batch_size, rank_estimate, regularization", - list(zip(problem_params, batch_sizes, rank_estimates, regularizations)), + [astuple(tp) for tp in test_parameters], indirect=["model_data"]) def test_lanzcos_low_rank_hessian_approx(model_data, batch_size: int, rank_estimate, regularization): _, _, _, vec, H_analytical = model_data From b18875d919b999c85c7c18c069c378a05a49b94a Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 18 Jun 2023 12:48:59 +0200 Subject: [PATCH 089/436] Links to methods and attributes --- docs/10-getting-started.md | 2 +- mkdocs.yml | 177 ++++++++++++------------ src/pydvl/utils/dataset.py | 9 +- src/pydvl/utils/parallel/futures/ray.py | 3 +- src/pydvl/utils/parallel/map_reduce.py | 5 +- src/pydvl/value/result.py | 26 ++-- src/pydvl/value/shapley/montecarlo.py | 4 +- src/pydvl/value/shapley/truncated.py | 10 +- src/pydvl/value/stopping.py | 14 +- 9 files changed, 132 insertions(+), 118 deletions(-) diff --git a/docs/10-getting-started.md b/docs/10-getting-started.md index 0b066bc83..693cbb793 100644 --- a/docs/10-getting-started.md +++ b/docs/10-getting-started.md @@ -29,7 +29,7 @@ introduction and survey of the field, we refer to **the upcoming review** at the If you are somewhat familiar with the concepts of data valuation, you can start by browsing our worked-out examples illustrating pyDVL's capabilities either: -- :ref:`In this documentation`. +- [In this documentation][examples/]. - Using [binder](https://mybinder.org/>) notebooks, deployed from each example's page. - Locally, by starting a jupyter server at the root of the project. You will diff --git a/mkdocs.yml b/mkdocs.yml index f4d385b8b..3643fe6e4 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -5,51 +5,51 @@ repo_url: "https://github.com/appliedAI-Initiative/pyDVL" copyright: "Copyright © AppliedAI Institute gGmbH" watch: -- src/pydvl + - src/pydvl plugins: -- autorefs -- search -- section-index -- alias: - use_relative_link: true - verbose: true -- mkdocstrings: - enable_inventory: true - handlers: - python: - import: - - https://docs.python.org/3/objects.inv - - https://numpy.org/doc/stable/objects.inv - - https://pandas.pydata.org/docs/objects.inv - paths: [src] # search packages in the src folder - options: - docstring_style: google - docstring_section_style: spacy - line_length: 80 - show_bases: true - members_order: source - # separate_signature: true - show_signature_annotations: false - signature_crossrefs: true - # show_if_no_docstring: true - merge_init_into_class: true - docstring_options: - ignore_init_summary: true - # filters: [] # include all members -- gen-files: - scripts: - - build_scripts/generate_api_docs.py -- literate-nav: - nav_file: SUMMARY.md -#- git-revision-date-localized: -# enable_creation_date: true -# type: iso_date -# fallback_to_build_date: true -- bibtex: - bib_file: "docs/assets/pydvl.bib" - csl_file: "docs/assets/elsevier-harvard.csl" - cite_inline: true + - autorefs + - search + - section-index + - alias: + use_relative_link: true + verbose: true + - mkdocstrings: + enable_inventory: true + handlers: + python: + import: + - https://docs.python.org/3/objects.inv + - https://numpy.org/doc/stable/objects.inv + - https://pandas.pydata.org/docs/objects.inv + paths: [ src ] # search packages in the src folder + options: + docstring_style: google + docstring_section_style: spacy + line_length: 80 + show_bases: true + members_order: source + # separate_signature: true + show_signature_annotations: false + signature_crossrefs: true + # show_if_no_docstring: true + merge_init_into_class: true + docstring_options: + ignore_init_summary: true + # filters: [] # include all members + - gen-files: + scripts: + - build_scripts/generate_api_docs.py + - literate-nav: + nav_file: SUMMARY.md + - bibtex: + bib_file: "docs/assets/pydvl.bib" + csl_file: "docs/assets/elsevier-harvard.csl" + cite_inline: true + #- git-revision-date-localized: + # enable_creation_date: true + # type: iso_date + # fallback_to_build_date: true theme: name: material @@ -71,58 +71,57 @@ theme: - navigation.footer - content.code.copy - content.code.annotate - palette: - # Palette toggle for light mode - - media: "(prefers-color-scheme: light)" - scheme: default - primary: teal - toggle: - icon: material/brightness-7 - name: Switch to dark mode - # Palette toggle for dark mode - - media: "(prefers-color-scheme: dark)" - scheme: slate - primary: teal - toggle: - icon: material/brightness-4 - name: Switch to light mode + palette: # Palette toggle for light mode + - media: "(prefers-color-scheme: light)" + scheme: default + primary: teal + toggle: + icon: material/brightness-7 + name: Switch to dark mode + # Palette toggle for dark mode + - media: "(prefers-color-scheme: dark)" + scheme: slate + primary: teal + toggle: + icon: material/brightness-4 + name: Switch to light mode extra_css: -- css/extra.css -- css/neoteroi.css + - css/extra.css + - css/neoteroi.css extra_javascript: -- javascripts/mathjax.js -- https://polyfill.io/v3/polyfill.min.js?features=es6 -- https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js + - javascripts/mathjax.js + - https://polyfill.io/v3/polyfill.min.js?features=es6 + - https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js extra: social: - - icon: fontawesome/brands/github - link: https://github.com/appliedAI-Initiative/pyDVL - - icon: fontawesome/brands/python - link: https://pypi.org/project/pyDVL/ + - icon: fontawesome/brands/github + link: https://github.com/appliedAI-Initiative/pyDVL + - icon: fontawesome/brands/python + link: https://pypi.org/project/pyDVL/ markdown_extensions: -- admonition -- attr_list -- footnotes -- neoteroi.cards -- toc: - permalink: True - toc_depth: 3 -- pymdownx.tabbed: - alternate_style: true -- pymdownx.emoji: - emoji_index: !!python/name:materialx.emoji.twemoji - emoji_generator: !!python/name:materialx.emoji.to_svg -- pymdownx.highlight: - anchor_linenums: true - pygments_lang_class: true - line_spans: __span -- pymdownx.arithmatex: - generic: true -- pymdownx.inlinehilite -- pymdownx.snippets -- pymdownx.superfences -- pymdownx.details + - admonition + - attr_list + - footnotes + - neoteroi.cards + - toc: + permalink: True + toc_depth: 3 + - pymdownx.tabbed: + alternate_style: true + - pymdownx.emoji: + emoji_index: !!python/name:materialx.emoji.twemoji + emoji_generator: !!python/name:materialx.emoji.to_svg + - pymdownx.highlight: + anchor_linenums: true + pygments_lang_class: true + line_spans: __span + - pymdownx.arithmatex: + generic: true + - pymdownx.inlinehilite + - pymdownx.snippets + - pymdownx.superfences + - pymdownx.details diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index 477341412..bf60bc9eb 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -179,12 +179,12 @@ def get_test_data( be those of the training data and would not work on the test data. There may be cases where it is desired to use parts of the test data. - In those cases, it is recommended to inherit from the [Dataset][pydvl.utils.Dataset] - class and to override the :meth:`~Dataset.get_test_data` method. + In those cases, it is recommended to inherit from [Dataset][pydvl.utils.Dataset] + and override [get_test_data()][Dataset.get_test_data]. For example, the following snippet shows how one could go about mapping the training data indices into test data indices - inside :meth:`~Dataset.get_test_data`: + inside [get_test_data()][Dataset.get_test_data]: :Example: @@ -208,7 +208,8 @@ class and to override the :meth:`~Dataset.get_test_data` method. Args: indices: Optional indices into the test data. This argument is - unused left for compatibility with :meth:`Dataset.get_training_data`. + unused left for compatibility with + [get_training_data()][pydvl.utils.dataset.Dataset.get_training_data]. Returns: The entire test data. diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 4a357e5f0..062de8494 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -36,7 +36,8 @@ class RayExecutor(Executor): with cluster address, number of cpus, etc. cancel_futures_on_exit: If ``True``, all futures will be cancelled when exiting the context created by using this class instance as a - context manager. It will be ignored when calling :meth:`shutdown` + context manager. It will be ignored when calling + [shutdown()][pydvl.utils.parallel.futures.ray.RayExecutor.shutdown] directly. """ diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index 116170e70..b4c67c280 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -211,8 +211,9 @@ def map(self, inputs: Union[Sequence[T], T]) -> List["ObjectRef[R]"]: return map_results def reduce(self, chunks: List["ObjectRef[R]"]) -> R: - """Reduces the resulting chunks from a call to :meth:`~pydvl.utils.parallel.map_reduce.MapReduceJob.map` - by passing them to a wrapped :func:`reduce_func`.""" + """Reduces the resulting chunks from a call to + [map()][pydvl.utils.parallel.map_reduce.MapReduceJob.map] by passing + them to a wrapped `reduce_func`.""" reduce_func = self._wrap_function(self._reduce_func) reduce_result = reduce_func(chunks, **self.reduce_kwargs) diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index e8aadf40f..4ba8f12be 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -17,22 +17,28 @@ updated accordingly. See [ValuationResult][pydvl.value.result.ValuationResult] for details. Results can also be sorted by value, variance or number of updates, see -:meth:`ValuationResult.sort`. The arrays of [ValuationResult.values][ValuationResult.values], -[ValuationResult.variances`, :attr:`ValuationResult.counts][ValuationResult.variances`, :attr:`ValuationResult.counts], -[ValuationResult.indices` and :attr:`ValuationResult.names][ValuationResult.indices` and :attr:`ValuationResult.names] are sorted in +[sort()][pydvl.value.result.ValuationResult.sort]. The arrays of +[ValuationResult.values][pydvl.value.result.aluationResult.values], +[ValuationResult.variances][pydvl.value.result.ValuationResult.variances], +[ValuationResult.counts][pydvl.value.result.ValuationResult.counts], +[ValuationResult.indices][pydvl.value.result.ValuationResult.indices], +[ValuationResult.names][pydvl.value.result.ValuationResult.names] are sorted in the same way. -Indexing and slicing of results is supported and [ValueItem][pydvl.value.result.ValueItem] objects are -returned. These objects can be compared with the usual operators, which take -only the [ValueItem.value][ValueItem.value] into account. +Indexing and slicing of results is supported and +[ValueItem][pydvl.value.result.ValueItem] objects are returned. These objects +can be compared with the usual operators, which take only the +[ValueItem.value][pydvl.value.result.ValueItem.value] into account. # Creating result objects -The most commonly used factory method is :meth:`ValuationResult.zeros`, which +The most commonly used factory method is +[ValuationResult.zeros()][pydvl.value.result.ValuationResult.zeros], which creates a result object with all values, variances and counts set to zero. -:meth:`ValuationResult.empty` creates an empty result object, which can be used -as a starting point for adding results together. Empty results are discarded -when added to other results. Finally, :meth:`ValuationResult.from_random` +[ValuationResult.empty()][pydvl.value.result.ValuationResult.empty] creates an +empty result object, which can be used as a starting point for adding results +together. Empty results are discarded when added to other results. Finally, +[ValuationResult.from_random()][pydvl.value.result.ValuationResult.from_random] samples random values uniformly. """ diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index 7fd90211f..11326c624 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -66,8 +66,8 @@ def _permutation_montecarlo_shapley( """Helper function for :func:`permutation_montecarlo_shapley`. Computes marginal utilities of each training sample in - :obj:`pydvl.utils.utility.Utility.data` by iterating through randomly - sampled permutations. + [Utility.data][pydvl.utils.utility.Utility.data] by iterating through + randomly sampled permutations. Args: u: Utility object with model, data, and scoring function diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 165a6fb5f..33b80f0ce 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -28,8 +28,14 @@ class TruncationPolicy(abc.ABC): """A policy for deciding whether to stop computing marginals in a permutation. - Statistics are kept on the number of calls and truncations as :attr:`n_calls` - and :attr:`n_truncations` respectively. + Statistics are kept on the number of calls and truncations as + [n_calls][pydvl.value.shapley.truncated.TruncationPolicy.n_calls] and + [n_truncations][pydvl.value.shapley.truncated.TruncationPolicy.n_truncations] + respectively. + + Attributes: + n_calls: Number of calls to the policy. + n_truncations: Number of truncations made by the policy. !!! Todo Because the policy objects are copied to the workers, the statistics diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index 0b8a3470e..f07953ef8 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -17,8 +17,8 @@ Alternatively, and in particular if reporting of completion is required, one can inherit from this class and implement the abstract methods -:meth:`~pydvl.value.stopping.StoppingCriterion._check` and -:meth:`~pydvl.value.stopping.StoppingCriterion.completion`. +[_check()][pydvl.value.stopping.StoppingCriterion._check] and +[completion()][pydvl.value.stopping.StoppingCriterion.completion]. .. rubric:: Composing stopping criteria @@ -238,11 +238,11 @@ class AbsoluteStandardError(StoppingCriterion): fraction: The fraction of values that must have converged for the criterion to return [Converged][pydvl.utils.status.Status.Converged]. burn_in: The number of iterations to ignore before checking for - convergence. This is required because computations typically start with - zero variance, as a result of using - :meth:`~pydvl.value.result.ValuationResult.empty`. The default is set to - an arbitrary minimum which is usually enough but may need to be - increased. + convergence. This is required because computations typically start + with zero variance, as a result of using + [empty()][pydvl.value.result.ValuationResult.empty]. The default is + set to an arbitrary minimum which is usually enough but may need to + be increased. """ def __init__( From 54570936e12d3938a17e27368324b3fef6d22b1e Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 18 Jun 2023 13:23:49 +0200 Subject: [PATCH 090/436] Migrating mathematics and markup, more cross-references. --- docs/30-data-valuation.md | 6 +- src/pydvl/utils/caching.py | 8 +-- src/pydvl/utils/dataset.py | 50 +++++++------- src/pydvl/utils/numeric.py | 4 +- src/pydvl/utils/parallel/futures/ray.py | 6 +- src/pydvl/utils/parallel/map_reduce.py | 12 ++-- src/pydvl/utils/score.py | 2 +- src/pydvl/utils/status.py | 8 +-- src/pydvl/utils/utility.py | 16 ++--- src/pydvl/value/least_core/__init__.py | 4 +- src/pydvl/value/least_core/common.py | 42 ++++++------ src/pydvl/value/result.py | 54 +++++++-------- src/pydvl/value/sampler.py | 22 +++---- src/pydvl/value/semivalues.py | 18 ++--- src/pydvl/value/shapley/common.py | 26 ++++---- src/pydvl/value/shapley/gt.py | 4 +- src/pydvl/value/shapley/montecarlo.py | 4 +- src/pydvl/value/shapley/truncated.py | 4 +- src/pydvl/value/stopping.py | 88 +++++++++++++------------ tests/utils/test_status.py | 4 +- 20 files changed, 192 insertions(+), 190 deletions(-) diff --git a/docs/30-data-valuation.md b/docs/30-data-valuation.md index ccc9f3f45..b2d7918d9 100644 --- a/docs/30-data-valuation.md +++ b/docs/30-data-valuation.md @@ -312,7 +312,7 @@ integration. ### Permutation Shapley -An equivalent way of computing Shapley values (``ApproShapley``) appeared in +An equivalent way of computing Shapley values (`ApproShapley`) appeared in [@castro_polynomial_2009] and is the basis for the method most often used in practice. It uses permutations over indices instead of subsets: @@ -387,7 +387,7 @@ $$ Additionally, the CSP can sometimes turn out to be infeasible. Usage follows the same pattern as every other Shapley method, but with the -addition of an ``epsilon`` parameter required for the solution of the CSP. It +addition of an `epsilon` parameter required for the solution of the CSP. It should be the same value used to compute the minimum number of samples required. This can be done with [num_samples_eps_delta][pydvl.value.shapley.gt.num_samples_eps_delta], but note that the number returned will be huge! In practice, fewer samples can be @@ -499,7 +499,7 @@ values = compute_least_core_values( ``` !!! Note - Although any number is supported, it is best to choose ``n_iterations`` to be + Although any number is supported, it is best to choose `n_iterations` to be at least equal to the number of data points. Because computing the Least Core values requires the solution of a linear and a diff --git a/src/pydvl/utils/caching.py b/src/pydvl/utils/caching.py index d20bf000b..a2265e2a6 100644 --- a/src/pydvl/utils/caching.py +++ b/src/pydvl/utils/caching.py @@ -37,7 +37,7 @@ # Usage with stochastic functions -In addition to standard memoization, the decorator :func:`memcached` can compute +In addition to standard memoization, the decorator [memcached()][pydvl.utils.caching.memcached] can compute running average and standard error of repeated evaluations for the same input. This can be useful for stochastic functions with high variance (e.g. model training for small sample sizes), but drastically reduces the speed benefits of @@ -50,12 +50,12 @@ # Cache reuse -When working directly with :func:`memcached`, it is essential to only cache pure +When working directly with [memcached()][pydvl.utils.caching.memcached], it is essential to only cache pure functions. If they have any kind of state, either internal or external (e.g. a closure over some data that may change), then the cache will fail to notice this and the same value will be returned. -When a function is wrapped with :func:`memcached` for memoization, its signature +When a function is wrapped with [memcached()][pydvl.utils.caching.memcached] for memoization, its signature (input and output names) and code are used as a key for the cache. Alternatively you can pass a custom value to be used as key with @@ -169,7 +169,7 @@ def memcached( running standard deviation of the mean stabilises below `rtol_stderr * mean`. rtol_stderr: relative tolerance for repeated evaluations. More precisely, - :func:`memcached` will stop evaluating the function once the + [memcached()][pydvl.utils.caching.memcached] will stop evaluating the function once the standard deviation of the mean is smaller than `rtol_stderr * mean`. min_repetitions: minimum number of times that a function evaluation on the same arguments is repeated before returning cached values. Useful diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index bf60bc9eb..241c2bb6e 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -70,8 +70,8 @@ def __init__( timestamp which can be referenced directly instead of using a row number. description: A textual description of the dataset. - is_multi_output: set to ``False`` if labels are scalars, or to - ``True`` if they are vectors of dimension > 1. + is_multi_output: set to `False` if labels are scalars, or to + `True` if they are vectors of dimension > 1. """ self.x_train, self.y_train = check_X_y( x_train, y_train, multi_output=is_multi_output @@ -153,11 +153,11 @@ def get_training_data( Args: indices: Optional indices that will be used to select points from - the training data. If ``None``, the entire training data will be + the training data. If `None`, the entire training data will be returned. Returns: - If ``indices`` is not ``None``, the selected x and y arrays from the + If `indices` is not `None`, the selected x and y arrays from the training data. Otherwise, the entire dataset. """ if indices is None: @@ -264,18 +264,18 @@ def from_sklearn( Args: data: sklearn dataset. The following attributes are supported - - ``data``: covariates [required] - - ``target``: target variables (labels) [required] - - ``feature_names``: the feature names - - ``target_names``: the target names - - ``DESCR``: a description + - `data`: covariates [required] + - `target`: target variables (labels) [required] + - `feature_names`: the feature names + - `target_names`: the target names + - `DESCR`: a description train_size: size of the training dataset. Used in `train_test_split` random_state: seed for train / test split stratify_by_target: If `True`, data is split in a stratified fashion, using the target variable as labels. Read more in [scikit-learn's user guide](https://scikit-learn.org/stable/modules/cross_validation.html#stratification). kwargs: Additional keyword arguments to pass to the - [Dataset][pydvl.utils.Dataset] constructor. Use this to pass e.g. ``is_multi_output``. + [Dataset][pydvl.utils.Dataset] constructor. Use this to pass e.g. `is_multi_output`. Returns: Object with the sklearn dataset @@ -323,8 +323,8 @@ def from_arrays( using the y variable as labels. Read more in [sklearn's user guide](https://scikit-learn.org/stable/modules/cross_validation.html#stratification). kwargs: Additional keyword arguments to pass to the - [Dataset][pydvl.utils.Dataset] constructor. Use this to pass e.g. ``feature_names`` - or ``target_names``. + [Dataset][pydvl.utils.Dataset] constructor. Use this to pass e.g. `feature_names` + or `target_names`. Returns: Object with the passed X and y arrays split across training and test sets. @@ -369,21 +369,21 @@ def __init__( y_train: labels of training data x_test: test data y_test: labels of test data - data_groups: Iterable of the same length as ``x_train`` containing + data_groups: Iterable of the same length as `x_train` containing a group label for each training data point. The label can be of any - type, e.g. ``str`` or ``int``. Data points with the same label will + type, e.g. `str` or `int`. Data points with the same label will then be grouped by this object and considered as one for effects of valuation. feature_names: names of the covariates' features. target_names: names of the labels or targets y group_names: names of the groups. If not provided, the labels - from ``data_groups`` will be used. + from `data_groups` will be used. description: A textual description of the dataset kwargs: Additional keyword arguments to pass to the [Dataset][pydvl.utils.Dataset] constructor. !!! tip "Changed in version 0.6.0" - Added ``group_names`` and forwarding of ``kwargs`` + Added `group_names` and forwarding of `kwargs` """ super().__init__( x_train=x_train, @@ -434,7 +434,7 @@ def get_training_data( """Returns the data and labels of all samples in the given groups. Args: - indices: group indices whose elements to return. If ``None``, + indices: group indices whose elements to return. If `None`, all data from all groups are returned. Returns: @@ -464,14 +464,14 @@ def from_sklearn( Args: data: sklearn dataset. The following attributes are supported - - ``data``: covariates [required] - - ``target``: target variables (labels) [required] - - ``feature_names``: the feature names - - ``target_names``: the target names - - ``DESCR``: a description + - `data`: covariates [required] + - `target`: target variables (labels) [required] + - `feature_names`: the feature names + - `target_names`: the target names + - `DESCR`: a description train_size: size of the training dataset. Used in `train_test_split`. random_state: seed for train / test split. - stratify_by_target: If ``True``, data is split in a stratified + stratify_by_target: If `True`, data is split in a stratified fashion, using the target variable as labels. Read more in [sklearn's user guide](https://scikit-learn.org/stable/modules/cross_validation.html#stratification). data_groups: an array holding the group index or name for each @@ -520,9 +520,9 @@ def from_arrays( Args: X: array of shape (n_samples, n_features) y: array of shape (n_samples,) - train_size: size of the training dataset. Used in ``train_test_split``. + train_size: size of the training dataset. Used in `train_test_split`. random_state: seed for train / test split. - stratify_by_target: If ``True``, data is split in a stratified + stratify_by_target: If `True`, data is split in a stratified fashion, using the y variable as labels. Read more in [sklearn's user guide](https://scikit-learn.org/stable/modules/cross_validation.html#stratification). data_groups: an array holding the group index or name for each data diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index 8ec0b8164..4e3340c7d 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -68,7 +68,7 @@ def num_samples_permutation_hoeffding(eps: float, delta: float, u_range: float) def random_subset(s: NDArray[T], q: float = 0.5) -> NDArray[T]: - """Returns one subset at random from ``s``. + """Returns one subset at random from `s`. Args: s: set to sample from @@ -122,7 +122,7 @@ def random_powerset( def random_subset_of_size(s: NDArray[T], size: int) -> NDArray[T]: """Samples a random subset of given size uniformly from the powerset - of ``s``. + of `s`. Args: s: Set to sample from diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 062de8494..545481bf0 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -34,7 +34,7 @@ class RayExecutor(Executor): default to the total number of vCPUs in the ray cluster. config: instance of [ParallelConfig][pydvl.utils.config.ParallelConfig] with cluster address, number of cpus, etc. - cancel_futures_on_exit: If ``True``, all futures will be cancelled + cancel_futures_on_exit: If `True`, all futures will be cancelled when exiting the context created by using this class instance as a context manager. It will be ignored when calling [shutdown()][pydvl.utils.parallel.futures.ray.RayExecutor.shutdown] @@ -94,8 +94,8 @@ def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": Args: fn: Callable. - args: Positional arguments that will be passed to ``fn``. - kwargs: Keyword arguments that will be passed to ``fn``. + args: Positional arguments that will be passed to `fn`. + kwargs: Keyword arguments that will be passed to `fn`. It can also optionally contain options for the ray remote function as a dictionary as the keyword argument `remote_function_options`. Returns: diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index b4c67c280..d0245d20d 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -76,21 +76,21 @@ def _(v: list, *, timeout: Optional[float] = None) -> List[Any]: class MapReduceJob(Generic[T, R]): - """Takes an embarrassingly parallel fun and runs it in ``n_jobs`` parallel + """Takes an embarrassingly parallel fun and runs it in `n_jobs` parallel jobs, splitting the data evenly into a number of chunks equal to the number of jobs. Typing information for objects of this class requires the type of the inputs - that are split for ``map_func`` and the type of its output. + that are split for `map_func` and the type of its output. Args: inputs: The input that will be split and passed to `map_func`. - if it's not a sequence object. It will be repeat ``n_jobs`` number of times. + if it's not a sequence object. It will be repeat `n_jobs` number of times. map_func: Function that will be applied to the input chunks in each job. reduce_func: Function that will be applied to the results of - ``map_func`` to reduce them. - map_kwargs: Keyword arguments that will be passed to ``map_func`` in + `map_func` to reduce them. + map_kwargs: Keyword arguments that will be passed to `map_func` in each job. Alternatively, one can use ``itertools.partial``. - reduce_kwargs: Keyword arguments that will be passed to ``reduce_func`` + reduce_kwargs: Keyword arguments that will be passed to `reduce_func` in each job. Alternatively, one can use [itertools.partial][]. config: Instance of [ParallelConfig][pydvl.utils.config.ParallelConfig] with cluster address, number of cpus, etc. diff --git a/src/pydvl/utils/score.py b/src/pydvl/utils/score.py index 9d5a05736..a061b0923 100644 --- a/src/pydvl/utils/score.py +++ b/src/pydvl/utils/score.py @@ -44,7 +44,7 @@ class Scorer: range: numerical range of the score function. Some Monte Carlo methods can use this to estimate the number of samples required for a certain quality of approximation. If not provided, it can be read from - the ``scoring`` object if it provides it, for instance if it was + the `scoring` object if it provides it, for instance if it was constructed with [compose_score()][pydvl.utils.types.compose_score]. name: The name of the scorer. If not provided, the name of the function passed will be used. diff --git a/src/pydvl/utils/status.py b/src/pydvl/utils/status.py index 64f0a6687..0cec6c0c3 100644 --- a/src/pydvl/utils/status.py +++ b/src/pydvl/utils/status.py @@ -47,14 +47,14 @@ class Status(Enum): :NOT: - The result of bitwise negation of a Status with ``~`` is ``Failed`` if - the status is ``Converged``, or ``Converged`` otherwise: + The result of bitwise negation of a Status with ``~`` is `Failed` if + the status is `Converged`, or `Converged` otherwise: ~P == C, ~C == F, ~F == C :Boolean casting: - A Status evaluates to ``True`` iff it's ``Converged`` or ``Failed``: + A Status evaluates to `True` iff it's `Converged` or `Failed`: bool(Status.Pending) == False bool(Status.Converged) == True @@ -62,7 +62,7 @@ class Status(Enum): !!! Warning These truth values are **inconsistent** with the usual boolean operations. - In particular the XOR of two instances of ``Status`` is not the same as + In particular the XOR of two instances of `Status` is not the same as the XOR of their boolean values. """ diff --git a/src/pydvl/utils/utility.py b/src/pydvl/utils/utility.py index 0821aa478..30d2ad2fb 100644 --- a/src/pydvl/utils/utility.py +++ b/src/pydvl/utils/utility.py @@ -41,7 +41,7 @@ class Utility: """Convenience wrapper with configurable memoization of the scoring function. - An instance of ``Utility`` holds the triple of model, dataset and scoring + An instance of `Utility` holds the triple of model, dataset and scoring function which determines the value of data points. This is mosly used for the computation of [Shapley Values][shapley-values] and [Core Values][core-values]. @@ -72,22 +72,22 @@ class Utility: and compose scorers, in particular how to set default values and ranges. For convenience, a string can be passed, which will be used to construct a [Scorer][pydvl.utils.score.Scorer]. - default_score: As a convenience when no ``scorer`` object is passed + default_score: As a convenience when no `scorer` object is passed (where a default value can be provided), this argument also allows to set the default score for models that have not been fit, e.g. when too little data is passed, or errors arise. - score_range: As with ``default_score``, this is a convenience argument - for when no ``scorer`` argument is provided, to set the numerical range + score_range: As with `default_score`, this is a convenience argument + for when no `scorer` argument is provided, to set the numerical range of the score function. Some Monte Carlo methods can use this to estimate the number of samples required for a certain quality of approximation. - catch_errors: set to ``True`` to catch the errors when fit() fails. + catch_errors: set to `True` to catch the errors when fit() fails. This could happen in several steps of the pipeline, e.g. when too little training data is passed, which happens often during Shapley value calculations. When this happens, the :attr:`default_score` is returned as a score and computation continues. - show_warnings: Set to ``False`` to suppress warnings thrown by + show_warnings: Set to `False` to suppress warnings thrown by ``fit()``. - enable_cache: If ``True``, use memcached for memoization. + enable_cache: If `True`, use memcached for memoization. cache_options: Optional configuration object for memcached. clone_before_fit: If True, the model will be cloned before calling ``fit()``. @@ -178,7 +178,7 @@ def _utility(self, indices: FrozenSet) -> float: (rather than `tuple` since order should not matter) Returns: - 0 if no indices are passed, ``default_score`` if we fail + 0 if no indices are passed, `default_score` if we fail to fit the model or the scorer returns [numpy.NaN][]. Otherwise, the score of the model on the test data. """ diff --git a/src/pydvl/value/least_core/__init__.py b/src/pydvl/value/least_core/__init__.py index b50f135ab..7279770ff 100644 --- a/src/pydvl/value/least_core/__init__.py +++ b/src/pydvl/value/least_core/__init__.py @@ -57,9 +57,9 @@ def compute_least_core_values( The following algorithms are available. Note that the exact method can only work with very small datasets and is thus intended only for testing. - - ``exact``: uses the complete powerset of the training set for the constraints + - `exact`: uses the complete powerset of the training set for the constraints [combinatorial_exact_shapley()][pydvl.value.shapley.naive.combinatorial_exact_shapley]. - - ``montecarlo``: uses the approximate Monte Carlo Least Core algorithm. + - `montecarlo`: uses the approximate Monte Carlo Least Core algorithm. Implemented in [montecarlo_least_core()][pydvl.value.least_core.montecarlo.montecarlo_least_core]. Args: diff --git a/src/pydvl/value/least_core/common.py b/src/pydvl/value/least_core/common.py index 1164b220f..f189ff054 100644 --- a/src/pydvl/value/least_core/common.py +++ b/src/pydvl/value/least_core/common.py @@ -221,27 +221,26 @@ def _solve_least_core_linear_program( ) -> Tuple[Optional[NDArray[np.float_]], Optional[float]]: r"""Solves the Least Core's linear program using cvxopt. - .. math:: - + $$ \text{minimize} \ & e \\ \mbox{such that} \ & A_{eq} x = b_{eq}, \\ & A_{lb} x + e \ge b_{lb},\\ & A_{eq} x = b_{eq},\\ & x in \mathcal{R}^n , \\ - - where :math:`x` is a vector of decision variables; , - :math:`b_{ub}`, :math:`b_{eq}`, :math:`l`, and :math:`u` are vectors; and - :math:`A_{ub}` and :math:`A_{eq}` are matrices. + $$ + where $x$ is a vector of decision variables; , + $b_{ub}$, $b_{eq}$, $l$, and $u$ are vectors; and + $A_{ub}$ and $A_{eq}$ are matrices. if `non_negative_subsidy` is True, then an additional constraint $e \ge 0$ is used. Args: - A_eq: The equality constraint matrix. Each row of ``A_eq`` specifies the - coefficients of a linear equality constraint on ``x``. + A_eq: The equality constraint matrix. Each row of `A_eq` specifies the + coefficients of a linear equality constraint on `x`. b_eq: The equality constraint vector. Each element of ``A_eq @ x`` must equal - the corresponding element of ``b_eq``. - A_lb: The inequality constraint matrix. Each row of ``A_lb`` specifies the - coefficients of a linear inequality constraint on ``x``. + the corresponding element of `b_eq`. + A_lb: The inequality constraint matrix. Each row of `A_lb` specifies the + coefficients of a linear inequality constraint on `x`. b_lb: The inequality constraint vector. Each element represents a lower bound on the corresponding value of ``A_lb @ x``. non_negative_subsidy: If True, the least core subsidy $e$ is constrained @@ -299,27 +298,26 @@ def _solve_egalitarian_least_core_quadratic_program( ) -> Optional[NDArray[np.float_]]: """Solves the egalitarian Least Core's quadratic program using cvxopt. - .. math:: - + $$ \text{minimize} \ & \| x \|_2 \\ \mbox{such that} \ & A_{eq} x = b_{eq}, \\ & A_{lb} x + e \ge b_{lb},\\ & A_{eq} x = b_{eq},\\ & x in \mathcal{R}^n , \\ & e \text{ is a constant.} - - where :math:`x` is a vector of decision variables; , - :math:`b_{ub}`, :math:`b_{eq}`, :math:`l`, and :math:`u` are vectors; and - :math:`A_{ub}` and :math:`A_{eq}` are matrices. + $$ + where $x$ is a vector of decision variables; , + $b_{ub}$, $b_{eq}$, $l$, and $u$ are vectors; and + $A_{ub}$ and $A_{eq}$ are matrices. Args: subsidy: Minimal subsidy returned by :func:`_solve_least_core_linear_program` - A_eq: The equality constraint matrix. Each row of ``A_eq`` specifies the - coefficients of a linear equality constraint on ``x``. + A_eq: The equality constraint matrix. Each row of `A_eq` specifies the + coefficients of a linear equality constraint on `x`. b_eq: The equality constraint vector. Each element of ``A_eq @ x`` must equal - the corresponding element of ``b_eq``. - A_lb: The inequality constraint matrix. Each row of ``A_lb`` specifies the - coefficients of a linear inequality constraint on ``x``. + the corresponding element of `b_eq`. + A_lb: The inequality constraint matrix. Each row of `A_lb` specifies the + coefficients of a linear inequality constraint on `x`. b_lb: The inequality constraint vector. Each element represents a lower bound on the corresponding value of ``A_lb @ x``. solver_options: Keyword arguments that will be used to select a solver diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index 4ba8f12be..3e967772d 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -3,7 +3,7 @@ valuation algorithms. The most important class is [ValuationResult][pydvl.value.result.ValuationResult], which provides access -to raw values, as well as convenient behaviour as a ``Sequence`` with extended +to raw values, as well as convenient behaviour as a `Sequence` with extended indexing and updating abilities, and conversion to `pandas DataFrames `_. @@ -92,12 +92,12 @@ class ValueItem(Generic[IndexT, NameT]): """The result of a value computation for one datum. - ``ValueItems`` can be compared with the usual operators, forming a total - order. Comparisons take only the :attr:`value` into account. + `ValueItems` can be compared with the usual operators, forming a total + order. Comparisons take only the [value][pydvl.value.result.ValueItem.value] into account. !!! Todo Maybe have a mode of comparing similar to `np.isclose`, or taking the - :attr:`variance` into account. + [variance][pydvl.value.result.ValueItem.variance] into account. """ #: Index of the sample with this value in the original @@ -137,7 +137,7 @@ class ValuationResult( These include indices in the original [Dataset][pydvl.utils.dataset.Dataset], any data names (e.g. group names in [GroupedDataset][pydvl.utils.dataset.GroupedDataset]), the values themselves, and variance of the computation in the case of Monte - Carlo methods. ``ValuationResults`` can be iterated over like any ``Sequence``: + Carlo methods. `ValuationResults` can be iterated over like any `Sequence`: ``iter(valuation_result)`` returns a generator of [ValueItem][pydvl.value.result.ValueItem] in the order in which the object is sorted. @@ -145,48 +145,48 @@ class ValuationResult( # Indexing Indexing can be position-based, when accessing any of the attributes - :attr:`values`, :attr:`variances`, :attr:`counts` and :attr:`indices`, as + [values][pydvl.value.result.ValuationResult.values], [variances][pydvl.value.result.ValuationResult.variances], [counts][pydvl.value.result.ValuationResult.counts] and [indices][pydvl.value.result.ValuationResult.indices], as well as when iterating over the object, or using the item access operator, both getter and setter. The "position" is either the original sequence in which the data was passed to the constructor, or the sequence in which the object is sorted, see below. Alternatively, indexing can be data-based, i.e. using the indices in the - original dataset. This is the case for the methods :meth:`get` and - :meth:`update`. + original dataset. This is the case for the methods [get()][pydvl.value.result.ValuationResult.get] and + [update()][pydvl.value.result.ValuationResult.update]. # Sorting - Results can be sorted in-place with :meth:`sort`, or alternatively using + Results can be sorted in-place with [sort()][pydvl.value.result.ValuationResult.sort], or alternatively using python's standard ``sorted()`` and ``reversed()`` Note that sorting values - affects how iterators and the object itself as ``Sequence`` behave: + affects how iterators and the object itself as `Sequence` behave: ``values[0]`` returns a [ValueItem][pydvl.value.result.ValueItem] with the highest or lowest ranking point if this object is sorted by descending or ascending value, - respectively. If unsorted, ``values[0]`` returns the ``ValueItem`` at + respectively. If unsorted, ``values[0]`` returns the `ValueItem` at position 0, which has data index ``indices[0]`` in the [Dataset][pydvl.utils.dataset.Dataset]. - The same applies to direct indexing of the ``ValuationResult``: the index + The same applies to direct indexing of the `ValuationResult`: the index is positional, according to the sorting. It does not refer to the "data - index". To sort according to data index, use :meth:`sort` with + index". To sort according to data index, use [sort()][pydvl.value.result.ValuationResult.sort] with ``key="index"``. In order to access [ValueItem][pydvl.value.result.ValueItem] objects by their data index, use - :meth:`get`. + [get()][pydvl.value.result.ValuationResult.get]. - .. rubric:: Operating on results + # Operating on results Results can be added to each other with the ``+`` operator. Means and - variances are correctly updated, using the ``counts`` attribute. + variances are correctly updated, using the `counts` attribute. - Results can also be updated with new values using :meth:`update`. Means and + Results can also be updated with new values using [update()][pydvl.value.result.ValuationResult.update]. Means and variances are updated accordingly using the Welford algorithm. - Empty objects behave in a special way, see :meth:`empty`. + Empty objects behave in a special way, see [empty()][pydvl.value.result.ValuationResult.empty]. Args: values: An array of values. If omitted, defaults to an empty array - or to an array of zeros if ``indices`` are given. + or to an array of zeros if `indices` are given. indices: An optional array of indices in the original dataset. If omitted, defaults to ``np.arange(len(values))``. **Warning:** It is common to pass the indices of a [Dataset][pydvl.utils.dataset.Dataset] @@ -274,7 +274,7 @@ def sort( # Need a "Comparable" type here key: Literal["value", "variance", "index", "name"] = "value", ) -> None: - """Sorts the indices in place by ``key``. + """Sorts the indices in place by `key`. Once sorted, iteration over the results, and indexing of all the properties [ValuationResult.values][ValuationResult.values], @@ -429,7 +429,7 @@ def __setitem__( def __iter__(self) -> Iterator[ValueItem[IndexT, NameT]]: """Iterate over the results returning [ValueItem][pydvl.value.result.ValueItem] objects. - To sort in place before iteration, use :meth:`sort`. + To sort in place before iteration, use [sort()][pydvl.value.result.ValuationResult.sort]. """ for pos in self._sort_positions: yield ValueItem( @@ -494,8 +494,8 @@ def __add__(self, other: "ValuationResult") -> "ValuationResult": Means and standard errors are correctly handled. Statuses are added with bit-wise ``&``, see [Status][pydvl.value.result.Status]. - ``data_names`` are taken from the left summand, or if unavailable from - the right one. The ``algorithm`` string is carried over if both terms + `data_names` are taken from the left summand, or if unavailable from + the right one. The `algorithm` string is carried over if both terms have the same one or concatenated. It is possible to add ValuationResults of different lengths, and with @@ -503,7 +503,7 @@ def __add__(self, other: "ValuationResult") -> "ValuationResult": indices, and the values. !!! Warning - FIXME: Arbitrary ``extra_values`` aren't handled. + FIXME: Arbitrary `extra_values` aren't handled. """ # empty results @@ -681,10 +681,10 @@ def from_random( A valuation result with its status set to [Status.Converged][Status.Converged] by default. - :raises ValueError: If ``size`` is less than 1. + :raises ValueError: If `size` is less than 1. !!! tip "Changed in version 0.6.0" - Added parameter ``total``. Check for zero size + Added parameter `total`. Check for zero size """ if size < 1: raise ValueError("Size must be a positive integer") @@ -753,7 +753,7 @@ def zeros( data_names: Data names to use. A copy will be made. If not given, the names will be set to the string representation of the indices. n_samples: Number of data points whose values are computed. If - not given, the length of ``indices`` will be used. + not given, the length of `indices` will be used. Returns: Object with the results. diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index a351ed473..0734a9d53 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -4,9 +4,9 @@ The classes in this module are used to iterate over indices and subsets of their complement in the whole set, as required for the computation of marginal utility for semi-values. The elements returned when iterating over any subclass of -:class:`PowersetSampler` are tuples of the form ``(idx, subset)``, where ``idx`` -is the index of the element being added to the subset, and ``subset`` is the -subset of the complement of ``idx``. +[PowersetSampler][pydvl.value.sampler.PowersetSampler] are tuples of the form ``(idx, subset)``, where `idx` +is the index of the element being added to the subset, and `subset` is the +subset of the complement of `idx`. !!! Note This is the natural mode of iteration for the combinatorial definition of @@ -17,13 +17,13 @@ The samplers are used in the [semivalues][pydvl.value.semivalues] module to compute any semi-value, in particular Shapley and Beta values, and Banzhaf indices. -.. rubric:: Slicing of samplers +# Slicing of samplers The samplers can be sliced for parallel computation. For those which are embarrassingly parallel, this is done by slicing the set of "outer" indices and returning new samplers over those slices. This includes all truly powerset-based -samplers, such as :class:`DeterministicCombinatorialSampler` and -:class:`UniformSampler`. In contrast, slicing a :class:`PermutationSampler` +samplers, such as [DeterministicCombinatorialSampler][pydvl.value.sampler.DeterministicCombinatorialSampler] and +[UniformSampler][pydvl.value.sampler.UniformSampler]. In contrast, slicing a [PermutationSampler][pydvl.value.sampler.PermutationSampler] creates a new sampler which iterates over the same indices. """ @@ -68,13 +68,13 @@ class PowersetSampler(abc.ABC, Iterable[SampleType], Generic[T]): >>> print(s, end="") ()(2,)()(1,) - .. rubric:: Methods required in subclasses + # Methods required in subclasses - Samplers must define a :meth:`weight` function to be used as a multiplier in - Monte Carlo sums, so that the limit expectation coincides with the - semi-value. + Samplers must implement a [weight()][pydvl.value.sampler.PowersetSampler.weight] + function to be used as a multiplier in Monte Carlo sums, so that the limit + expectation coincides with the semi-value. - .. rubric:: Slicing of samplers + # Slicing of samplers The samplers can be sliced for parallel computation. For those which are embarrassingly parallel, this is done by slicing the set of "outer" indices diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index f147cc7ed..94b7db9b2 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -91,7 +91,7 @@ def _semivalues( job_id: int = 1, ) -> ValuationResult: r"""Serial computation of semi-values. This is a helper function for - :func:`semivalues`. + [semivalues()][pydvl.value.semivalues.semivalues]. Args: sampler: The subset sampler to use for utility computations. @@ -209,24 +209,26 @@ def compute_semivalues( """Entry point for most common semi-value computations. All are implemented with permutation sampling. - For any other sampling method, use :func:`parallel_semivalues` directly. + For any other sampling method, use [parallel_semivalues()][pydvl.value.semivalues.parallel_semivalues] directly. See [Data valuation][computing-data-values] for an overview of valuation. The modes supported are: - - [SemiValueMode.Shapley][SemiValueMode.Shapley]: Shapley values. - - [SemiValueMode.BetaShapley][SemiValueMode.BetaShapley]: Implements the - Beta Shapley semi-value as introduced in [@kwon_beta_2022]. Pass additional - keyword arguments ``alpha`` and ``beta`` to set the parameters of the Beta - distribution (both default to 1). + - [SemiValueMode.Shapley][pydvl.value.semivalues.SemiValueMode.Shapley]: + Shapley values. + - [SemiValueMode.BetaShapley][pydvl.value.semivalues.SemiValueMode.BetaShapley]: + Implements the Beta Shapley semi-value as introduced in [@kwon_beta_2022]. + Pass additional keyword arguments `alpha` and `beta` to set the + parameters of the Beta distribution (both default to 1). - [SemiValueMode.Banzhaf][SemiValueMode.Banzhaf]: Implements the Banzhaf semi-value as introduced in [@wang_data_2022]. Args: u: Utility object with model, data, and scoring function. done: Stopping criterion. - mode: The semi-value mode to use. See :class:`SemiValueMode` for a list. + mode: The semi-value mode to use. See + [SemiValueMode][pydvl.value.semivalues.SemiValueMode] for a list. sampler_t: The sampler type to use. See [sampler][pydvl.value.sampler] for a list. n_jobs: Number of parallel jobs to use. diff --git a/src/pydvl/value/shapley/common.py b/src/pydvl/value/shapley/common.py index fd51b0416..fa3b90ff7 100644 --- a/src/pydvl/value/shapley/common.py +++ b/src/pydvl/value/shapley/common.py @@ -36,45 +36,45 @@ def compute_shapley_values( algorithms also accept additional arguments, please refer to the documentation of each particular method. - - ``combinatorial_exact``: uses the combinatorial implementation of data + - `combinatorial_exact`: uses the combinatorial implementation of data Shapley. Implemented in [combinatorial_exact_shapley()][pydvl.value.shapley.naive.combinatorial_exact_shapley]. - - ``combinatorial_montecarlo``: uses the approximate Monte Carlo + - `combinatorial_montecarlo`: uses the approximate Monte Carlo implementation of combinatorial data Shapley. Implemented in [combinatorial_montecarlo_shapley()][pydvl.value.shapley.montecarlo.combinatorial_montecarlo_shapley]. - - ``permutation_exact``: uses the permutation-based implementation of data + - `permutation_exact`: uses the permutation-based implementation of data Shapley. Computation is **not parallelized**. Implemented in [permutation_exact_shapley()][pydvl.value.shapley.naive.permutation_exact_shapley]. - - ``permutation_montecarlo``: uses the approximate Monte Carlo + - `permutation_montecarlo`: uses the approximate Monte Carlo implementation of permutation data Shapley. Implemented in [permutation_montecarlo_shapley()][pydvl.value.shapley.montecarlo.permutation_montecarlo_shapley]. - - ``truncated_montecarlo``: default option, same as ``permutation_montecarlo`` + - `truncated_montecarlo`: default option, same as `permutation_montecarlo` but stops the computation whenever a certain accuracy is reached. Implemented in [truncated_montecarlo_shapley()][pydvl.value.shapley.montecarlo.truncated_montecarlo_shapley]. - - ``owen_sampling``: Uses the Owen continuous extension of the utility + - `owen_sampling`: Uses the Owen continuous extension of the utility function to the unit cube. Implemented in [owen_sampling_shapley()][pydvl.value.shapley.owen.owen_sampling_shapley]. This method does not take a [StoppingCriterion][pydvl.value.stopping.StoppingCriterion] - but instead requires a parameter ``q_max`` for the number of subdivisions + but instead requires a parameter `q_max` for the number of subdivisions of the unit interval to use for integration, and another parameter - ``n_samples`` for the number of subsets to sample for each $q$. - - ``owen_halved``: Same as 'owen_sampling' but uses correlated samples in the + `n_samples` for the number of subsets to sample for each $q$. + - `owen_halved`: Same as 'owen_sampling' but uses correlated samples in the expectation. Implemented in [owen_sampling_shapley()][pydvl.value.shapley.owen.owen_sampling_shapley]. This method requires an additional parameter `q_max` for the number of subdivisions of the interval [0,0.5] to use for integration, and another - parameter ``n_samples`` for the number of subsets to sample for each $q$. - - ``group_testing``: estimates differences of Shapley values and solves a + parameter `n_samples` for the number of subsets to sample for each $q$. + - `group_testing`: estimates differences of Shapley values and solves a constraint satisfaction problem. High sample complexity, not recommended. Implemented in [group_testing_shapley()][pydvl.value.shapley.gt.group_testing_shapley]. This method does not take a [StoppingCriterion][pydvl.value.stopping.StoppingCriterion] - but instead requires a parameter ``n_samples`` for the number of + but instead requires a parameter `n_samples` for the number of iterations to run. Additionally, one can use model-specific methods: - - ``knn``: Exact method for K-Nearest neighbour models. Implemented in + - `knn`: Exact method for K-Nearest neighbour models. Implemented in [knn_shapley()][pydvl.value.shapley.knn.knn_shapley]. Args: diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index e439acee5..85470116d 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -177,9 +177,9 @@ def group_testing_shapley( n_samples: Number of tests to perform. Use :func:`num_samples_eps_delta` to estimate this. epsilon: From the (ε,δ) sample bound. Use the same as for the - estimation of ``n_iterations``. + estimation of `n_iterations`. delta: From the (ε,δ) sample bound. Use the same as for the - estimation of ``n_iterations``. + estimation of `n_iterations`. n_jobs: Number of parallel jobs to use. Each worker performs a chunk of all tests (i.e. utility evaluations). config: Object configuring parallel computation, with cluster diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index 11326c624..d1f94e2ae 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -17,12 +17,12 @@ :func:`permutation_montecarlo_shapley`, or using an early stopping strategy to reduce computation :func:`truncated_montecarlo_shapley`. -.. seealso:: +!!! info "Also see" It is also possible to use [group_testing_shapley()][pydvl.value.shapley.gt.group_testing_shapley] to reduce the number of evaluations of the utility. The method is however typically outperformed by others in this module. -.. seealso:: +!!! info "Also see" Additionally, you can consider grouping your data points using [GroupedDataset][pydvl.utils.dataset.GroupedDataset] and computing the values of the groups instead. This is not to be confused with "group testing" as diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 33b80f0ce..2a856cc03 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -65,7 +65,7 @@ def __call__(self, idx: int, score: float) -> bool: score: Last utility computed. Returns: - ``True`` if the computation should be interrupted. + `True` if the computation should be interrupted. """ ret = self._check(idx, score) self.n_calls += 1 @@ -233,7 +233,7 @@ def truncated_montecarlo_shapley( :class:`BootstrapTruncation`. We keep sampling permutations and updating all shapley values - until the :class:`StoppingCriterion` returns ``True``. + until the :class:`StoppingCriterion` returns `True`. Args: u: Utility object with model, data, and scoring function diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index f07953ef8..c38ea0ad6 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -1,32 +1,34 @@ """ Stopping criteria for value computations. -This module provides a basic set of stopping criteria, like :class:`MaxUpdates`, -:class:`MaxTime`, or :class:`HistoryDeviation` among others. These can behave in -different ways depending on the context. For example, :class:`MaxUpdates` limits +This module provides a basic set of stopping criteria, like [MaxUpdates][pydvl.value.stopping.MaxUpdates], +[MaxTime][pydvl.value.stopping.MaxTime], or [HistoryDeviation][pydvl.value.stopping.HistoryDeviation] among others. These can behave in +different ways depending on the context. For example, [MaxUpdates][pydvl.value.stopping.MaxUpdates] limits the number of updates to values, which depending on the algorithm may mean a different number of utility evaluations or imply other computations like solving a linear or quadratic program. -.. rubric:: Creating stopping criteria +# Creating stopping criteria The easiest way is to declare a function implementing the interface -:data:`StoppingCriterionCallable` and wrap it with :func:`make_criterion`. This -creates a :class:`StoppingCriterion` object that can be composed with other -stopping criteria. +[StoppingCriterionCallable][pydvl.value.stopping.StoppingCriterionCallable] and +wrap it with [make_criterion()][pydvl.value.stopping.make_criterion]. This +creates a [StoppingCriterion][pydvl.value.stopping.StoppingCriterion] object +that can be composed with other stopping criteria. Alternatively, and in particular if reporting of completion is required, one can inherit from this class and implement the abstract methods [_check()][pydvl.value.stopping.StoppingCriterion._check] and [completion()][pydvl.value.stopping.StoppingCriterion.completion]. -.. rubric:: Composing stopping criteria +# Composing stopping criteria -Objects of type :class:`StoppingCriterion` can be composed with the binary -operators ``&`` (*and*), and ``|`` (*or*), following the truth tables of -[Status][pydvl.utils.status.Status]. The unary operator ``~`` (*not*) is also -supported. See :class:`StoppingCriterion` for details on how these operations -affect the behavior of the stopping criteria. +Objects of type [StoppingCriterion][pydvl.value.stopping.StoppingCriterion] can +be composed with the binary operators `&` (*and*), and `|` (*or*), following the +truth tables of [Status][pydvl.utils.status.Status]. The unary operator `~` +(*not*) is also supported. See +[StoppingCriterion][pydvl.value.stopping.StoppingCriterion] for details on how +these operations affect the behavior of the stopping criteria. """ import abc @@ -62,41 +64,41 @@ class StoppingCriterion(abc.ABC): """A composable callable object to determine whether a computation must stop. - A ``StoppingCriterion`` is a callable taking a + A `StoppingCriterion` is a callable taking a [ValuationResult][pydvl.value.result.ValuationResult] and returning a [Status][pydvl.value.result.Status]. It also keeps track of individual - convergence of values with :meth:`converged`, and reports the overall - completion of the computation with :meth:`completion`. + convergence of values with [converged()][pydvl.value.stopping.StoppingCriterion.converged], and reports the overall + completion of the computation with [completion()][pydvl.value.stopping.StoppingCriterion.completion]. - Instances of ``StoppingCriterion`` can be composed with the binary operators + Instances of `StoppingCriterion` can be composed with the binary operators ``&`` (*and*), and ``|`` (*or*), following the truth tables of [Status][pydvl.utils.status.Status]. The unary operator ``~`` (*not*) is also supported. These boolean operations act according to the following rules: - - The results of :meth:`_check` are combined with the operator. See + - The results of [_check()][pydvl.value.stopping.StoppingCriterion._check] are combined with the operator. See [Status][pydvl.utils.status.Status] for the truth tables. - - The results of :meth:`converged` are combined with the operator (returning + - The results of [converged()][pydvl.value.stopping.StoppingCriterion.converged] are combined with the operator (returning another boolean array). - - The :meth:`completion` method returns the min, max, or the complement to 1 + - The [completion()][pydvl.value.stopping.StoppingCriterion.completion] method returns the min, max, or the complement to 1 of the completions of the operands, for AND, OR and NOT respectively. This is required for cases where one of the criteria does not keep track of the - convergence of single values, e.g. :class:`MaxUpdates`, because - :meth:`completion` by default returns the mean of the boolean convergence + convergence of single values, e.g. [MaxUpdates][pydvl.value.stopping.MaxUpdates], because + [completion()][pydvl.value.stopping.StoppingCriterion.completion] by default returns the mean of the boolean convergence array. - .. rubric:: Subclassing + # Subclassing - Subclassing this class requires implementing a :meth:`_check` method that + Subclassing this class requires implementing a [_check()][pydvl.value.stopping.StoppingCriterion._check] method that returns a [Status][pydvl.utils.status.Status] object based on a given [ValuationResult][pydvl.value.result.ValuationResult]. This method should update the :attr:`converged` attribute, which is a boolean array indicating whether the value for each index has converged. When this is not possible, - :meth:`completion` should be overridden to provide an overall completion + [completion()][pydvl.value.stopping.StoppingCriterion.completion] should be overridden to provide an overall completion value, since the default implementation returns the mean of :attr:`converged`. Args: - modify_result: If ``True`` the status of the input + modify_result: If `True` the status of the input [ValuationResult][pydvl.value.result.ValuationResult] is modified in place after the call. """ @@ -126,8 +128,8 @@ def converged(self) -> NDArray[np.bool_]: """Returns a boolean array indicating whether the values have converged for each data point. - Inheriting classes must set the ``_converged`` attribute in their - :meth:`_check`. + Inheriting classes must set the `_converged` attribute in their + [_check()][pydvl.value.stopping.StoppingCriterion._check]. """ return self._converged @@ -136,7 +138,7 @@ def name(self): return type(self).__name__ def __call__(self, result: ValuationResult) -> Status: - """Calls :meth:`_check`, maybe updating the result.""" + """Calls [_check()][pydvl.value.stopping.StoppingCriterion._check], maybe updating the result.""" if len(result) == 0: logger.warning( "At least one iteration finished but no results where generated. " @@ -178,7 +180,7 @@ def make_criterion( completion: Callable[[], float] = None, name: str = None, ) -> Type[StoppingCriterion]: - """Create a new :class:`StoppingCriterion` from a function. + """Create a new [StoppingCriterion][pydvl.value.stopping.StoppingCriterion] from a function. Use this to enable simpler functions to be composed with bitwise operators Args: @@ -188,11 +190,11 @@ def make_criterion( completion: A callable that returns a value between 0 and 1 indicating the rate of completion of the computation. If not provided, the fraction of converged values is used. - name: The name of the new criterion. If ``None``, the ``__name__`` of + name: The name of the new criterion. If `None`, the `__name__` of the function is used. Returns: - A new subclass of :class:`StoppingCriterion`. + A new subclass of [StoppingCriterion][pydvl.value.stopping.StoppingCriterion]. """ class WrappedCriterion(StoppingCriterion): @@ -278,9 +280,9 @@ class MaxChecks(StoppingCriterion): A "check" is one call to the criterion. Args: - n_checks: Threshold: if ``None``, no _check is performed, + n_checks: Threshold: if `None`, no _check is performed, effectively creating a (never) stopping criterion that always returns - ``Pending``. + `Pending`. """ def __init__(self, n_checks: Optional[int], modify_result: bool = True): @@ -308,16 +310,16 @@ class MaxUpdates(StoppingCriterion): """Terminate if any number of value updates exceeds or equals the given threshold. - This checks the ``counts`` field of a + This checks the `counts` field of a [ValuationResult][pydvl.value.result.ValuationResult], i.e. the number of times that each index has been updated. For powerset samplers, the maximum of this number coincides with the maximum number of subsets sampled. For permutation samplers, it coincides with the number of permutations sampled. Args: - n_updates: Threshold: if ``None``, no _check is performed, + n_updates: Threshold: if `None`, no _check is performed, effectively creating a (never) stopping criterion that always returns - ``Pending``. + `Pending`. """ def __init__(self, n_updates: Optional[int], modify_result: bool = True): @@ -347,16 +349,16 @@ def completion(self) -> float: class MinUpdates(StoppingCriterion): """Terminate as soon as all value updates exceed or equal the given threshold. - This checks the ``counts`` field of a + This checks the `counts` field of a [ValuationResult][pydvl.value.result.ValuationResult], i.e. the number of times that each index has been updated. For powerset samplers, the minimum of this number is a lower bound for the number of subsets sampled. For permutation samplers, it lower-bounds the amount of permutations sampled. Args: - n_updates: Threshold: if ``None``, no _check is performed, + n_updates: Threshold: if `None`, no _check is performed, effectively creating a (never) stopping criterion that always returns - ``Pending``. + `Pending`. """ def __init__(self, n_updates: Optional[int], modify_result: bool = True): @@ -388,9 +390,9 @@ class MaxTime(StoppingCriterion): Args: seconds: Threshold: The computation is terminated if the elapsed time - between object construction and a _check exceeds this value. If ``None``, + between object construction and a _check exceeds this value. If `None`, no _check is performed, effectively creating a (never) stopping criterion - that always returns ``Pending``. + that always returns `Pending`. """ def __init__(self, seconds: Optional[float], modify_result: bool = True): @@ -443,7 +445,7 @@ class HistoryDeviation(StoppingCriterion): n_steps: Checkpoint values every so many updates and use these saved values to compare. rtol: Relative tolerance for convergence ($\epsilon$ in the formula). - pin_converged: If ``True``, once an index has converged, it is pinned + pin_converged: If `True`, once an index has converged, it is pinned """ _memory: NDArray[np.float_] diff --git a/tests/utils/test_status.py b/tests/utils/test_status.py index 067b92eb8..20de30314 100644 --- a/tests/utils/test_status.py +++ b/tests/utils/test_status.py @@ -48,8 +48,8 @@ def test_and_status(): def test_not_status(): - """The result of bitwise negation of a Status is ``Failed`` - if the status is ``Converged``, or ``Converged`` otherwise: + """The result of bitwise negation of a Status is `Failed` + if the status is `Converged`, or `Converged` otherwise: ``~P == C, ~C == F, ~F == C`` """ From fb3c805e84bde572faaf34c47c1596e90217fd18 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Sun, 18 Jun 2023 13:27:57 +0200 Subject: [PATCH 091/436] fix typing --- src/pydvl/influence/frameworks/torch_differentiable.py | 4 +++- src/pydvl/influence/frameworks/twice_differentiable.py | 9 +++++++-- src/pydvl/influence/general.py | 8 ++++---- src/pydvl/influence/inversion.py | 2 +- 4 files changed, 15 insertions(+), 8 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 310f553a1..fd182926e 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -311,7 +311,9 @@ def mvp( return mvp.detach() # type: ignore -class TorchTwiceDifferentiable(TwiceDifferentiable[torch.Tensor, nn.Module]): +class TorchTwiceDifferentiable( + TwiceDifferentiable[torch.Tensor, nn.Module, torch.device] +): def __init__( self, model: nn.Module, diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index 18d650d99..3a767f87f 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -3,17 +3,22 @@ TensorType = TypeVar("TensorType", bound=Sequence) ModelType = TypeVar("ModelType") +DeviceType = TypeVar("DeviceType") -class TwiceDifferentiable(ABC, Generic[TensorType, ModelType]): +class TwiceDifferentiable(ABC, Generic[TensorType, ModelType, DeviceType]): """ Wraps a differentiable model and loss and provides methods to compute the second derivative of the loss wrt. the model parameters. """ def __init__( - self, model: ModelType, loss: Callable[[TensorType, TensorType], TensorType] + self, + model: ModelType, + loss: Callable[[TensorType, TensorType], TensorType], + device: DeviceType, ): + self.device = device pass @property diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 5a1c05dcd..40c95f41e 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -32,7 +32,7 @@ class InfluenceType(str, Enum): def compute_influence_factors( - model: TwiceDifferentiable[TensorType, ModelType], + model: TwiceDifferentiable, training_data: DataLoaderType, test_data: DataLoaderType, inversion_method: InversionMethod, @@ -82,7 +82,7 @@ def compute_influence_factors( def compute_influences_up( - model: TwiceDifferentiable[TensorType, ModelType], + model: TwiceDifferentiable, input_data: DataLoaderType, influence_factors: TensorType, *, @@ -115,7 +115,7 @@ def compute_influences_up( def compute_influences_pert( - model: TwiceDifferentiable[TensorType, ModelType], + model: TwiceDifferentiable, input_data: DataLoaderType, influence_factors: TensorType, *, @@ -165,7 +165,7 @@ def compute_influences_pert( def compute_influences( - differentiable_model: TwiceDifferentiable[TensorType, ModelType], + differentiable_model: TwiceDifferentiable, training_data: DataLoaderType, *, test_data: Optional[DataLoaderType] = None, diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 4cd48571b..ae5ec2c03 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -32,7 +32,7 @@ class InversionMethod(str, Enum): def solve_hvp( inversion_method: InversionMethod, - model: TwiceDifferentiable[TensorType, ModelType], + model: TwiceDifferentiable, training_data: DataLoaderType, b: TensorType, *, From 2b6124383cc08f56d1bb3b9150bb2ae26778920c Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 18 Jun 2023 13:42:57 +0200 Subject: [PATCH 092/436] Finalising cross-references --- src/pydvl/utils/numeric.py | 5 ++-- src/pydvl/utils/parallel/map_reduce.py | 4 +-- src/pydvl/utils/status.py | 12 ++++----- src/pydvl/utils/utility.py | 32 ++++++++++++------------ src/pydvl/value/least_core/__init__.py | 6 +++-- src/pydvl/value/least_core/common.py | 14 ++++++----- src/pydvl/value/least_core/montecarlo.py | 22 +++++++++------- src/pydvl/value/result.py | 28 ++++++++++----------- src/pydvl/value/sampler.py | 2 +- src/pydvl/value/shapley/gt.py | 9 ++++--- src/pydvl/value/shapley/montecarlo.py | 19 ++++++++------ src/pydvl/value/shapley/naive.py | 3 ++- src/pydvl/value/shapley/truncated.py | 22 ++++++++-------- src/pydvl/value/stopping.py | 20 +++++++++------ tests/utils/test_status.py | 2 +- 15 files changed, 111 insertions(+), 89 deletions(-) diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index 4e3340c7d..c5c7f7bec 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -31,7 +31,8 @@ def powerset(s: NDArray[T]) -> Iterator[Collection[T]]: """Returns an iterator for the power set of the argument. Subsets are generated in sequence by growing size. See - :func:`random_powerset` for random sampling. + [random_powerset()][pydvl.utils.numeric.random_powerset] for random + sampling. >>> import numpy as np >>> from pydvl.utils.numeric import powerset @@ -42,7 +43,7 @@ def powerset(s: NDArray[T]) -> Iterator[Collection[T]]: s: The set to use Returns: - An iterator + An iterator over all subsets of the set of indices `s`. """ return chain.from_iterable(combinations(s, r) for r in range(len(s) + 1)) diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index d0245d20d..1508e3882 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -89,7 +89,7 @@ class MapReduceJob(Generic[T, R]): reduce_func: Function that will be applied to the results of `map_func` to reduce them. map_kwargs: Keyword arguments that will be passed to `map_func` in - each job. Alternatively, one can use ``itertools.partial``. + each job. Alternatively, one can use `itertools.partial`. reduce_kwargs: Keyword arguments that will be passed to `reduce_func` in each job. Alternatively, one can use [itertools.partial][]. config: Instance of [ParallelConfig][pydvl.utils.config.ParallelConfig] @@ -188,7 +188,7 @@ def __call__( return reduce_results def map(self, inputs: Union[Sequence[T], T]) -> List["ObjectRef[R]"]: - """Splits the input data into chunks and calls a wrapped :func:`map_func` on them.""" + """Splits the input data into chunks and calls a wrapped `map_func` on them.""" map_results: List["ObjectRef[R]"] = [] map_func = self._wrap_function(self._map_func) diff --git a/src/pydvl/utils/status.py b/src/pydvl/utils/status.py index 0cec6c0c3..c369e0bec 100644 --- a/src/pydvl/utils/status.py +++ b/src/pydvl/utils/status.py @@ -4,16 +4,16 @@ class Status(Enum): """Status of a computation. - Statuses can be combined using bitwise or (``|``) and bitwise and (``&``) to + Statuses can be combined using bitwise or (`|`) and bitwise and (`&`) to get the status of a combined computation. For example, if we have two computations, one that has converged and one that has failed, then the - combined status is ``Status.Converged | Status.Failed == Status.Converged``, - but ``Status.Converged & Status.Failed == Status.Failed``. + combined status is `Status.Converged | Status.Failed == Status.Converged`, + but `Status.Converged & Status.Failed == Status.Failed`. :OR: - The result of bitwise or-ing two valuation statuses with ``|`` is given + The result of bitwise or-ing two valuation statuses with `|` is given by the following table: +---+---+---+---+ @@ -30,7 +30,7 @@ class Status(Enum): :AND: - The result of bitwise and-ing two valuation statuses with ``&`` is given + The result of bitwise and-ing two valuation statuses with `&` is given by the following table: +---+---+---+---+ @@ -47,7 +47,7 @@ class Status(Enum): :NOT: - The result of bitwise negation of a Status with ``~`` is `Failed` if + The result of bitwise negation of a Status with `~` is `Failed` if the status is `Converged`, or `Converged` otherwise: ~P == C, ~C == F, ~F == C diff --git a/src/pydvl/utils/utility.py b/src/pydvl/utils/utility.py index 30d2ad2fb..e7dc45aeb 100644 --- a/src/pydvl/utils/utility.py +++ b/src/pydvl/utils/utility.py @@ -48,13 +48,13 @@ class Utility: The Utility expect the model to fulfill the [SupervisedModel][pydvl.utils.types.SupervisedModel] interface i.e. - to have ``fit()``, ``predict()``, and ``score()`` methods. + to have `fit()`, `predict()`, and `score()` methods. When calling the utility, the model will be [cloned](https://scikit-learn.org/stable/modules/generated/sklearn.base .clone.html) if it is a Sci-Kit Learn model, otherwise a copy is created using - ``deepcopy()`` from the builtin [copy](https://docs.python.org/3/ + `deepcopy()` from the builtin [copy](https://docs.python.org/3/ library/copy.html) module. Since evaluating the scoring function requires retraining the model @@ -67,7 +67,7 @@ class Utility: model: Any supervised model. Typical choices can be found at https://scikit-learn.org/stable/supervised_learning.html data: Dataset or GroupedDataset instance. - scorer: A scoring object. If None, the ``score()`` method of the model + scorer: A scoring object. If None, the `score()` method of the model will be used. See [score][pydvl.utils.score] for ways to create and compose scorers, in particular how to set default values and ranges. For convenience, a string can be passed, which will be used to construct @@ -76,21 +76,21 @@ class Utility: (where a default value can be provided), this argument also allows to set the default score for models that have not been fit, e.g. when too little data is passed, or errors arise. - score_range: As with `default_score`, this is a convenience argument - for when no `scorer` argument is provided, to set the numerical range - of the score function. Some Monte Carlo methods can use this to estimate - the number of samples required for a certain quality of approximation. - catch_errors: set to `True` to catch the errors when fit() fails. - This could happen in several steps of the pipeline, e.g. when too little + score_range: As with `default_score`, this is a convenience argument for + when no `scorer` argument is provided, to set the numerical range + of the score function. Some Monte Carlo methods can use this to + estimate the number of samples required for a certain quality of + approximation. + catch_errors: set to `True` to catch the errors when `fit()` fails. This + could happen in several steps of the pipeline, e.g. when too little training data is passed, which happens often during Shapley value - calculations. When this happens, the :attr:`default_score` is returned - as a score and computation continues. - show_warnings: Set to `False` to suppress warnings thrown by - ``fit()``. + calculations. When this happens, the `default_score` is returned as + a score and computation continues. + show_warnings: Set to `False` to suppress warnings thrown by `fit()`. enable_cache: If `True`, use memcached for memoization. cache_options: Optional configuration object for memcached. - clone_before_fit: If True, the model will be cloned before calling - ``fit()``. + clone_before_fit: If `True`, the model will be cloned before calling + `fit()`. Examples: >>> from pydvl.utils import Utility, DataUtilityLearning, Dataset @@ -165,7 +165,7 @@ def _utility(self, indices: FrozenSet) -> float: """Clones the model, fits it on a subset of the training data and scores it on the test data. - If the object is constructed with ``enable_cache = True``, results are + If the object is constructed with `enable_cache = True`, results are memoized to avoid duplicate computation. This is useful in particular when computing utilities of permutations of indices or when randomly sampling from the powerset of indices. diff --git a/src/pydvl/value/least_core/__init__.py b/src/pydvl/value/least_core/__init__.py index 7279770ff..8451dd4f0 100644 --- a/src/pydvl/value/least_core/__init__.py +++ b/src/pydvl/value/least_core/__init__.py @@ -68,13 +68,15 @@ def compute_least_core_values( Least Core. n_iterations: Number of subsets to sample and evaluate the utility on. Only used for Monte Carlo Least Core. - mode: Algorithm to use. See :class:`LeastCoreMode` for available options. + mode: Algorithm to use. See + [LeastCoreMode][pydvl.value.least_core.LeastCoreMode] for available + options. non_negative_subsidy: If True, the least core subsidy $e$ is constrained to be non-negative. solver_options: Optional dictionary of options passed to the solvers. Returns: - ValuationResult object with the computed values. + Object with the computed values. !!! tip "New in version 0.5.0" """ diff --git a/src/pydvl/value/least_core/common.py b/src/pydvl/value/least_core/common.py index f189ff054..35b7ff280 100644 --- a/src/pydvl/value/least_core/common.py +++ b/src/pydvl/value/least_core/common.py @@ -35,7 +35,8 @@ def lc_solve_problem( solver_options: Optional[dict] = None, **options, ) -> ValuationResult: - """Solves a linear problem prepared by :func:`mclc_prepare_problem`. + """Solves a linear problem as prepared by + [mclc_prepare_problem()][pydvl.value.least_core.montecarlo.mclc_prepare_problem]. Useful for parallel execution of multiple experiments by running this as a remote task. @@ -237,12 +238,12 @@ def _solve_least_core_linear_program( Args: A_eq: The equality constraint matrix. Each row of `A_eq` specifies the coefficients of a linear equality constraint on `x`. - b_eq: The equality constraint vector. Each element of ``A_eq @ x`` must equal + b_eq: The equality constraint vector. Each element of `A_eq @ x` must equal the corresponding element of `b_eq`. A_lb: The inequality constraint matrix. Each row of `A_lb` specifies the coefficients of a linear inequality constraint on `x`. b_lb: The inequality constraint vector. Each element represents a - lower bound on the corresponding value of ``A_lb @ x``. + lower bound on the corresponding value of `A_lb @ x`. non_negative_subsidy: If True, the least core subsidy $e$ is constrained to be non-negative. options: Keyword arguments that will be used to select a solver @@ -311,15 +312,16 @@ def _solve_egalitarian_least_core_quadratic_program( $A_{ub}$ and $A_{eq}$ are matrices. Args: - subsidy: Minimal subsidy returned by :func:`_solve_least_core_linear_program` + subsidy: Minimal subsidy returned by + [_solve_least_core_linear_program()][pydvl.value.least_core.common._solve_least_core_linear_program] A_eq: The equality constraint matrix. Each row of `A_eq` specifies the coefficients of a linear equality constraint on `x`. - b_eq: The equality constraint vector. Each element of ``A_eq @ x`` must equal + b_eq: The equality constraint vector. Each element of `A_eq @ x` must equal the corresponding element of `b_eq`. A_lb: The inequality constraint matrix. Each row of `A_lb` specifies the coefficients of a linear inequality constraint on `x`. b_lb: The inequality constraint vector. Each element represents a - lower bound on the corresponding value of ``A_lb @ x``. + lower bound on the corresponding value of `A_lb @ x`. solver_options: Keyword arguments that will be used to select a solver and to configure it. Refer to [cvxpy's documentation](https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options) diff --git a/src/pydvl/value/least_core/montecarlo.py b/src/pydvl/value/least_core/montecarlo.py index cfd8c0cb3..f5410c8c2 100644 --- a/src/pydvl/value/least_core/montecarlo.py +++ b/src/pydvl/value/least_core/montecarlo.py @@ -100,12 +100,14 @@ def mclc_prepare_problem( config: ParallelConfig = ParallelConfig(), progress: bool = False, ) -> LeastCoreProblem: - """Prepares a linear problem by sampling subsets of the data. - Use this to separate the problem preparation from the solving with - [lc_solve_problem()][pydvl.value.least_core.common.lc_solve_problem]. Useful for - parallel execution of multiple experiments. - - See :func:`montecarlo_least_core` for argument descriptions. + """Prepares a linear problem by sampling subsets of the data. Use this to + separate the problem preparation from the solving with + [lc_solve_problem()][pydvl.value.least_core.common.lc_solve_problem]. Useful + for parallel execution of multiple experiments. + + See + [montecarlo_least_core][pydvl.value.least_core.montecarlo.montecarlo_least_core] + for argument descriptions. """ n = len(u.data) @@ -141,7 +143,8 @@ def mclc_prepare_problem( def _montecarlo_least_core( u: Utility, n_iterations: int, *, progress: bool = False, job_id: int = 1 ) -> LeastCoreProblem: - """Computes utility values and the Least Core upper bound matrix for a given number of iterations. + """Computes utility values and the Least Core upper bound matrix for a given + number of iterations. Args: u: Utility object with model, data, and scoring function @@ -150,7 +153,7 @@ def _montecarlo_least_core( job_id: Integer id used to determine the position of the progress bar Returns: - + A solution """ n = len(u.data) @@ -174,7 +177,8 @@ def _montecarlo_least_core( def _reduce_func(results: Iterable[LeastCoreProblem]) -> LeastCoreProblem: """Combines the results from different parallel runs of - :func:`_montecarlo_least_core`""" + [_montecarlo_least_core()][pydvl.value.least_core.montecarlo._montecarlo_least_core] + """ utility_values_list, A_lb_list = zip(*results) utility_values = np.concatenate(utility_values_list) A_lb = np.concatenate(A_lb_list) diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index 3e967772d..0dac4e755 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -9,7 +9,7 @@ # Operating on results -Results can be added together with the standard ``+`` operator. Because values +Results can be added together with the standard `+` operator. Because values are typically running averages of iterative algorithms, addition behaves like a weighted average of the two results, with the weights being the number of updates in each result: adding two results is the same as generating one result @@ -138,7 +138,7 @@ class ValuationResult( any data names (e.g. group names in [GroupedDataset][pydvl.utils.dataset.GroupedDataset]), the values themselves, and variance of the computation in the case of Monte Carlo methods. `ValuationResults` can be iterated over like any `Sequence`: - ``iter(valuation_result)`` returns a generator of + `iter(valuation_result)` returns a generator of [ValueItem][pydvl.value.result.ValueItem] in the order in which the object is sorted. @@ -158,25 +158,25 @@ class ValuationResult( # Sorting Results can be sorted in-place with [sort()][pydvl.value.result.ValuationResult.sort], or alternatively using - python's standard ``sorted()`` and ``reversed()`` Note that sorting values + python's standard `sorted()` and `reversed()` Note that sorting values affects how iterators and the object itself as `Sequence` behave: - ``values[0]`` returns a [ValueItem][pydvl.value.result.ValueItem] with the highest or lowest + `values[0]` returns a [ValueItem][pydvl.value.result.ValueItem] with the highest or lowest ranking point if this object is sorted by descending or ascending value, - respectively. If unsorted, ``values[0]`` returns the `ValueItem` at - position 0, which has data index ``indices[0]`` in the + respectively. If unsorted, `values[0]` returns the `ValueItem` at + position 0, which has data index `indices[0]` in the [Dataset][pydvl.utils.dataset.Dataset]. The same applies to direct indexing of the `ValuationResult`: the index is positional, according to the sorting. It does not refer to the "data index". To sort according to data index, use [sort()][pydvl.value.result.ValuationResult.sort] with - ``key="index"``. + `key="index"`. In order to access [ValueItem][pydvl.value.result.ValueItem] objects by their data index, use [get()][pydvl.value.result.ValuationResult.get]. # Operating on results - Results can be added to each other with the ``+`` operator. Means and + Results can be added to each other with the `+` operator. Means and variances are correctly updated, using the `counts` attribute. Results can also be updated with new values using [update()][pydvl.value.result.ValuationResult.update]. Means and @@ -188,10 +188,10 @@ class ValuationResult( values: An array of values. If omitted, defaults to an empty array or to an array of zeros if `indices` are given. indices: An optional array of indices in the original dataset. If - omitted, defaults to ``np.arange(len(values))``. **Warning:** It is + omitted, defaults to `np.arange(len(values))`. **Warning:** It is common to pass the indices of a [Dataset][pydvl.utils.dataset.Dataset] here. Attention must be paid in a parallel context to copy them to - the local process. Just do ``indices=np.copy(data.indices)``. + the local process. Just do `indices=np.copy(data.indices)`. variance: An optional array of variances in the computation of each value. counts: An optional array with the number of updates for each value. Defaults to an array of ones. @@ -325,7 +325,7 @@ def indices(self) -> NDArray[IndexT]: """The indices for the values, possibly sorted. If the object is unsorted, then these are the same as declared at - construction or ``np.arange(len(values))`` if none were passed. + construction or `np.arange(len(values))` if none were passed. """ return self._indices[self._sort_positions] @@ -333,7 +333,7 @@ def indices(self) -> NDArray[IndexT]: def names(self) -> NDArray[NameT]: """The names for the values, possibly sorted. If the object is unsorted, then these are the same as declared at - construction or ``np.arange(len(values))`` if none were passed. + construction or `np.arange(len(values))` if none were passed. """ return self._names[self._sort_positions] @@ -493,7 +493,7 @@ def __add__(self, other: "ValuationResult") -> "ValuationResult": Abusing this will introduce numerical errors. Means and standard errors are correctly handled. Statuses are added with - bit-wise ``&``, see [Status][pydvl.value.result.Status]. + bit-wise `&`, see [Status][pydvl.value.result.Status]. `data_names` are taken from the left summand, or if unavailable from the right one. The `algorithm` string is carried over if both terms have the same one or concatenated. @@ -749,7 +749,7 @@ def zeros( Args: algorithm: Name of the algorithm used to compute the values indices: Data indices to use. A copy will be made. If not given, - the indices will be set to the range ``[0, n_samples)``. + the indices will be set to the range `[0, n_samples)`. data_names: Data names to use. A copy will be made. If not given, the names will be set to the string representation of the indices. n_samples: Number of data points whose values are computed. If diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 0734a9d53..e1194066c 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -4,7 +4,7 @@ The classes in this module are used to iterate over indices and subsets of their complement in the whole set, as required for the computation of marginal utility for semi-values. The elements returned when iterating over any subclass of -[PowersetSampler][pydvl.value.sampler.PowersetSampler] are tuples of the form ``(idx, subset)``, where `idx` +[PowersetSampler][pydvl.value.sampler.PowersetSampler] are tuples of the form `(idx, subset)`, where `idx` is the index of the element being added to the subset, and `subset` is the subset of the complement of `idx`. diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index 85470116d..258eebabf 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -118,7 +118,8 @@ def num_samples_eps_delta( def _group_testing_shapley( u: Utility, n_samples: int, progress: bool = False, job_id: int = 1 ): - """Helper function for :func:`group_testing_shapley`. + """Helper function for + [group_testing_shapley()][pydvl.value.shapley.gt.group_testing_shapley]. Computes utilities of sets sampled using the strategy for estimating the differences in Shapley values. @@ -175,7 +176,8 @@ def group_testing_shapley( Args: u: Utility object with model, data, and scoring function n_samples: Number of tests to perform. Use - :func:`num_samples_eps_delta` to estimate this. + [num_samples_eps_delta][pydvl.value.shapley.gt.num_samples_eps_delta] + to estimate this. epsilon: From the (ε,δ) sample bound. Use the same as for the estimation of `n_iterations`. delta: From the (ε,δ) sample bound. Use the same as for the @@ -185,7 +187,8 @@ def group_testing_shapley( config: Object configuring parallel computation, with cluster address, number of cpus, etc. progress: Whether to display progress bars for each job. - options: Additional options to pass to [cvxpy.Problem.solve()](https://www.cvxpy.org/tutorial/advanced/index.html#solve-method-options). + options: Additional options to pass to + [cvxpy.Problem.solve()](https://www.cvxpy.org/tutorial/advanced/index.html#solve-method-options). E.g. to change the solver (which defaults to `cvxpy.SCS`) pass `solver=cvxpy.CVXOPT`. diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index d1f94e2ae..a6970c035 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -7,15 +7,18 @@ the functions in this module. Because exact computation of Shapley values requires $\mathcal{O}(2^n)$ -re-trainings of the model, several Monte Carlo approximations are available. -The first two sample from the powerset of the training data directly: -:func:`combinatorial_montecarlo_shapley` and :func:`owen_sampling_shapley`. The -latter uses a reformulation in terms of a continuous extension of the utility. +re-trainings of the model, several Monte Carlo approximations are available. The +first two sample from the powerset of the training data directly: +[combinatorial_montecarlo_shapley()][pydvl.value.shapley.montecarlo.combinatorial_montecarlo_shapley] +and [owen_sampling_shapley()][pydvl.value.shapley.owen.owen_sampling_shapley]. +The latter uses a reformulation in terms of a continuous extension of the +utility. Alternatively, employing another reformulation of the expression above as a sum over permutations, one has the implementation in -:func:`permutation_montecarlo_shapley`, or using an early stopping strategy to -reduce computation :func:`truncated_montecarlo_shapley`. +[permutation_montecarlo_shapley()][pydvl.value.shapley.montecarlo.permutation_montecarlo_shapley], +or using an early stopping strategy to reduce computation +[truncated_montecarlo_shapley()][pydvl.value.shapley.truncated.truncated_montecarlo_shapley]. !!! info "Also see" It is also possible to use [group_testing_shapley()][pydvl.value.shapley.gt.group_testing_shapley] @@ -63,7 +66,7 @@ def _permutation_montecarlo_shapley( progress: bool = False, job_id: int = 1, ) -> ValuationResult: - """Helper function for :func:`permutation_montecarlo_shapley`. + """Helper function for [permutation_montecarlo_shapley()][pydvl.value.shapley.montecarlo.permutation_montecarlo_shapley]. Computes marginal utilities of each training sample in [Utility.data][pydvl.utils.utility.Utility.data] by iterating through @@ -166,7 +169,7 @@ def _combinatorial_montecarlo_shapley( progress: bool = False, job_id: int = 1, ) -> ValuationResult: - """Helper function for :func:`combinatorial_montecarlo_shapley`. + """Helper function for [combinatorial_montecarlo_shapley()][pydvl.value.shapley.montecarlo.combinatorial_montecarlo_shapley]. This is the code that is sent to workers to compute values using the combinatorial definition. diff --git a/src/pydvl/value/shapley/naive.py b/src/pydvl/value/shapley/naive.py index 0a6aae744..4b56d3677 100644 --- a/src/pydvl/value/shapley/naive.py +++ b/src/pydvl/value/shapley/naive.py @@ -64,7 +64,8 @@ def permutation_exact_shapley(u: Utility, *, progress: bool = True) -> Valuation def _combinatorial_exact_shapley( indices: Sequence[int], u: Utility, progress: bool ) -> NDArray: - """Helper function for :func:`combinatorial_exact_shapley`. + """Helper function for + [combinatorial_exact_shapley()][pydvl.value.shapley.naive.combinatorial_exact_shapley]. Computes the marginal utilities for the set of indices passed and returns the value of the samples according to the exact combinatorial definition. diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 2a856cc03..44c9f445a 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -115,7 +115,7 @@ class RelativeTruncation(TruncationPolicy): Args: u: Utility object with model, data, and scoring function rtol: Relative tolerance. The permutation is broken if the - last computed utility is less than ``total_utility * rtol``. + last computed utility is less than `total_utility * rtol`. """ def __init__(self, u: Utility, rtol: float): @@ -225,15 +225,17 @@ def truncated_montecarlo_shapley( Instead of naively implementing the expectation, we sequentially add points to a dataset from a permutation and incrementally compute marginal utilities. We stop computing marginals for a given permutation based on a - :class:`TruncationPolicy`. [@ghorbani_data_2019] mention two - policies: one that stops after a certain fraction of marginals are computed, - implemented in :class:`FixedTruncation`, and one that stops if the last - computed utility ("score") is close to the total utility using the standard - deviation of the utility as a measure of proximity, implemented in - :class:`BootstrapTruncation`. - - We keep sampling permutations and updating all shapley values - until the :class:`StoppingCriterion` returns `True`. + [TruncationPolicy][pydvl.value.shapley.truncated.TruncationPolicy]. + [@ghorbani_data_2019] mention two policies: one that stops after a certain + fraction of marginals are computed, implemented in + [FixedTruncation][pydvl.value.shapley.truncated.FixedTruncation], and one + that stops if the last computed utility ("score") is close to the total + utility using the standard deviation of the utility as a measure of proximity, + implemented in + [BootstrapTruncation][pydvl.value.shapley.truncated.BootstrapTruncation]. + + We keep sampling permutations and updating all shapley values until the + [StoppingCriterion][pydvl.value.stopping.StoppingCriterion] returns `True`. Args: u: Utility object with model, data, and scoring function diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index c38ea0ad6..fa500585b 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -71,8 +71,8 @@ class StoppingCriterion(abc.ABC): completion of the computation with [completion()][pydvl.value.stopping.StoppingCriterion.completion]. Instances of `StoppingCriterion` can be composed with the binary operators - ``&`` (*and*), and ``|`` (*or*), following the truth tables of - [Status][pydvl.utils.status.Status]. The unary operator ``~`` (*not*) is + `&` (*and*), and `|` (*or*), following the truth tables of + [Status][pydvl.utils.status.Status]. The unary operator `~` (*not*) is also supported. These boolean operations act according to the following rules: @@ -89,13 +89,17 @@ class StoppingCriterion(abc.ABC): # Subclassing - Subclassing this class requires implementing a [_check()][pydvl.value.stopping.StoppingCriterion._check] method that + Subclassing this class requires implementing a + [_check()][pydvl.value.stopping.StoppingCriterion._check] method that returns a [Status][pydvl.utils.status.Status] object based on a given - [ValuationResult][pydvl.value.result.ValuationResult]. This method should update the - :attr:`converged` attribute, which is a boolean array indicating whether - the value for each index has converged. When this is not possible, - [completion()][pydvl.value.stopping.StoppingCriterion.completion] should be overridden to provide an overall completion - value, since the default implementation returns the mean of :attr:`converged`. + [ValuationResult][pydvl.value.result.ValuationResult]. This method should + update the attribute [converged][pydvl.value.result.ValuationResult.converged], + which is a boolean array indicating whether the value for each index has + converged. When this is not possible, + [completion()][pydvl.value.stopping.StoppingCriterion.completion] should be + overridden to provide an overall completion value, since the default + implementation returns the mean of + [converged][pydvl.value.result.ValuationResult.converged]. Args: modify_result: If `True` the status of the input diff --git a/tests/utils/test_status.py b/tests/utils/test_status.py index 20de30314..4c8cd1ec9 100644 --- a/tests/utils/test_status.py +++ b/tests/utils/test_status.py @@ -51,7 +51,7 @@ def test_not_status(): """The result of bitwise negation of a Status is `Failed` if the status is `Converged`, or `Converged` otherwise: - ``~P == C, ~C == F, ~F == C`` + `~P == C, ~C == F, ~F == C` """ assert ~Status.Pending == Status.Converged assert ~Status.Converged == Status.Failed From b821ed8489aa68956a09006d5812cc4f382e9b3e Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 18 Jun 2023 13:49:02 +0200 Subject: [PATCH 093/436] Fixing invalid relative refs --- src/pydvl/utils/dataset.py | 11 ++++++----- src/pydvl/value/result.py | 21 ++++++++++++--------- src/pydvl/value/shapley/owen.py | 5 +++-- 3 files changed, 21 insertions(+), 16 deletions(-) diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index 241c2bb6e..2857556ba 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -179,12 +179,13 @@ def get_test_data( be those of the training data and would not work on the test data. There may be cases where it is desired to use parts of the test data. - In those cases, it is recommended to inherit from [Dataset][pydvl.utils.Dataset] - and override [get_test_data()][Dataset.get_test_data]. + In those cases, it is recommended to inherit from + [Dataset][pydvl.utils.dataset.Dataset] and override + [get_test_data()][pydvl.utils.dataset.Dataset.get_test_data]. For example, the following snippet shows how one could go about mapping the training data indices into test data indices - inside [get_test_data()][Dataset.get_test_data]: + inside [get_test_data()][pydvl.utils.dataset.Dataset.get_test_data]: :Example: @@ -638,8 +639,8 @@ def load_wine_dataset( """Loads the [sklearn wine dataset](https://scikit-learn.org/stable/datasets/toy_dataset.html#wine-recognition-dataset). !!! Fixme - Why does this function not return a [Dataset][Dataset] object? - And why is it part of this module? + Why does this function not return a [Dataset][pydvl.utils.dataset.Dataset] + object? And why is it part of this module? Args: train_size: fraction of points used for training dataset diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index 0dac4e755..0278b1b91 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -142,7 +142,7 @@ class ValuationResult( [ValueItem][pydvl.value.result.ValueItem] in the order in which the object is sorted. - # Indexing + ## Indexing Indexing can be position-based, when accessing any of the attributes [values][pydvl.value.result.ValuationResult.values], [variances][pydvl.value.result.ValuationResult.variances], [counts][pydvl.value.result.ValuationResult.counts] and [indices][pydvl.value.result.ValuationResult.indices], as @@ -155,7 +155,7 @@ class ValuationResult( original dataset. This is the case for the methods [get()][pydvl.value.result.ValuationResult.get] and [update()][pydvl.value.result.ValuationResult.update]. - # Sorting + ## Sorting Results can be sorted in-place with [sort()][pydvl.value.result.ValuationResult.sort], or alternatively using python's standard `sorted()` and `reversed()` Note that sorting values @@ -174,7 +174,7 @@ class ValuationResult( In order to access [ValueItem][pydvl.value.result.ValueItem] objects by their data index, use [get()][pydvl.value.result.ValuationResult.get]. - # Operating on results + ## Operating on results Results can be added to each other with the `+` operator. Means and variances are correctly updated, using the `counts` attribute. @@ -277,15 +277,18 @@ def sort( """Sorts the indices in place by `key`. Once sorted, iteration over the results, and indexing of all the - properties [ValuationResult.values][ValuationResult.values], - [ValuationResult.variances][ValuationResult.variances], - [ValuationResult.counts][ValuationResult.counts], - [ValuationResult.indices][ValuationResult.indices] and - [ValuationResult.names][ValuationResult.names] will follow the same order. + properties + [ValuationResult.values][pydvl.value.result.ValuationResult.values], + [ValuationResult.variances][pydvl.value.result.ValuationResult.variances], + [ValuationResult.counts][pydvl.value.result.ValuationResult.counts], + [ValuationResult.indices][pydvl.value.result.ValuationResult.indices] + and [ValuationResult.names][pydvl.value.result.ValuationResult.names] + will follow the same order. Args: reverse: Whether to sort in descending order by value. - key: The key to sort by. Defaults to [ValueItem.value][ValueItem.value]. + key: The key to sort by. Defaults to + [ValueItem.value][pydvl.value.result.ValueItem.value]. """ keymap = { "index": "_indices", diff --git a/src/pydvl/value/shapley/owen.py b/src/pydvl/value/shapley/owen.py index d8a01eba7..d298ac856 100644 --- a/src/pydvl/value/shapley/owen.py +++ b/src/pydvl/value/shapley/owen.py @@ -42,8 +42,9 @@ def _owen_sampling_shapley( Args: indices: Indices to compute the value for u: Utility object with model, data, and scoring function - method: Either [Full][OwenAlgorithm.Full] for $q \in [0,1]$ or - [Halved][OwenAlgorithm.Halved] for $q \in [0,0.5]$ and correlated samples + method: Either [Full][pydvl.value.shapley.owen.OwenAlgorithm.Full] for + q ∈ [0, 1] or [Halved][pydvl.value.shapley.owen.OwenAlgorithm.Halved] + for q ∈ [0, 0.5] and correlated samples n_samples: Number of subsets to sample to estimate the integrand max_q: number of subdivisions for the integration over $q$ progress: Whether to display progress bars for each job From 4c4b06393d8c838bb782ca66ee46272be6d3c8f9 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 18 Jun 2023 13:50:51 +0200 Subject: [PATCH 094/436] Remove unneeded file for sphinx and update some of the doc --- CONTRIBUTING.md | 22 ++-- build_scripts/update_docs.py | 241 ----------------------------------- 2 files changed, 10 insertions(+), 253 deletions(-) delete mode 100644 build_scripts/update_docs.py diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 6bd181636..f233acfe2 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -164,13 +164,13 @@ Examples for hidden imports and plots are available in the notebooks, e.g. in ## Documentation API documentation and examples from notebooks are built with -[sphinx](https://www.sphinx-doc.org/) by tox. Doctests are run during this step. +[mkdocs](https://) by tox. Doctests are run during this step. In order to construct the API documentation, tox calls a helper script that -builds `.rst` files from docstrings and templates. It can be invoked manually +builds `.md` files from docstrings and templates. It can be invoked manually with: ```bash -python build_scripts/update_docs.py +python build_scripts/generate_api_docs.py ``` See the documentation inside the script for more details. Notebooks are an @@ -202,24 +202,22 @@ tox -e docs-dev ### Using bibliography -Bibliographic citations are managed with the plugin -[sphinx-bibtex](https://sphinxcontrib-bibtex.readthedocs.io/en/latest/index.html). +Bibliographic citations are managed with the plugins +[mkdocs-bibtex]() and [...][]. To enter a citation first add the entry to `docs/pydvl.bib`. For team contributor this should be an export of the Zotero folder `software/pydvl` in the [TransferLab Zotero library](https://www.zotero.org/groups/2703043/transferlab/library). All other contributors just add the bibtex data, and a maintainer will add it to the group library upon merging. -To add a citation inside a module or function's docstring, use the sphinx role -`:footcite:t:`. A references section is automatically added at the bottom of -each module's auto-generated documentation. +To add a citation inside a module or function's docstring, use the notation +`[@citekey]`. A references section is automatically added at the bottom of each +module's auto-generated documentation. ### Writing mathematics -In sphinx one can write mathematics with the directives `:math:` (inline) or -`.. math::` (block). Additionally, we use the extension -[sphinx-math-dollar](https://github.com/sympy/sphinx-math-dollar) to allow for -the more common `$` (inline) and `$$` (block) delimiters in RST files. +Use LaTeX delimiters `$` and `$$` for inline and displayed mathematics +respectively. **Warning: backslashes must be escaped in docstrings!** (although there are exceptions). For simplicity, declare the string as "raw" with the prefix `r`: diff --git a/build_scripts/update_docs.py b/build_scripts/update_docs.py deleted file mode 100644 index 98f84f47e..000000000 --- a/build_scripts/update_docs.py +++ /dev/null @@ -1,241 +0,0 @@ -#!/usr/bin/env python3 -""" -This script walks through the python source files and creates documentation in .rst format which can -then be compiled with Sphinx. It is suitable for a standard repository layout src/ as well as for -a repo containing multiple packages src/, ..., src/. -""" -import argparse -import logging -import os -import shutil -from typing import Optional - -log = logging.getLogger(__name__) - - -def module_template(module_qualname: str): - module_name = module_qualname.split(".")[-1] - title = module_name.replace("_", r"\_") - template = f"""{title} -{"="*len(title)} - -.. automodule:: {module_qualname} - :members: - :undoc-members: - - ---- - -.. footbibliography:: - -""" - return template - - -def package_template(package_qualname: str, *, add_toctree: bool = True): - package_name = package_qualname.split(".")[-1] - title = package_name.replace("_", r"\_") - template = f"""{title} -{"="*len(title)} - -.. automodule:: {package_qualname} - :members: - :undoc-members: -""" - if add_toctree: - template += f""" -.. rubric:: Modules in this package - -.. toctree:: - :glob: - - {package_name}/* - -""" - return template - - -def index_template(package_name: str, title: Optional[str] = None) -> str: - if title is None: - title = package_name.replace("_", r"\_") - template = f"""{title} -{"="*len(title)} - -.. automodule:: {package_name} - :members: - :undoc-members: - -.. toctree:: - :glob: - - * -""" - return template - - -def write_to_file(content: str, path: str): - os.makedirs(os.path.dirname(path), exist_ok=True) - with open(path, "w") as f: - f.write(content) - os.chmod(path, 0o666) - - -def make_rst( - src_root: str = "src", - docs_root: str = "docs", - clean: bool = False, - overwrite: bool = False, - only_update: bool = True, -): - """Creates / updates documentation in form of rst files for modules and - packages. Does not delete any existing rst files if clean and overwrite are - False. This method should be executed from the project's top-level - directory. - - :param src_root: path to project's src directory that contains all packages, - usually src. Most projects will only need one top-level package, then - your layout typically should be src/. - :param docs_root: path to the project's docs directory containing the - `conf.py` and the top level `index.rst`. - :param clean: whether to completely clean the docs target directories - beforehand, removing any existing files. - :param overwrite: whether to overwrite existing rst files. This should be - used with caution as it will delete all manual changes to documentation - files. - :param only_update: set to True if rst files should only be recreated if - their modification date is earlier than that of the modules. - :return: - """ - docs_root = os.path.abspath(docs_root) - src_root = os.path.abspath(src_root) - - for top_level_package_name in os.listdir(src_root): - top_level_package_dir = os.path.join(src_root, top_level_package_name) - # skipping things in src that are not packages, like .egg files - if ( - not os.path.isdir(top_level_package_dir) - or "." in top_level_package_name - or top_level_package_name.startswith("_") - ): - continue - - log.info( - f"Generating documentation for top-level package {top_level_package_name}" - ) - top_level_package_docs_dir = os.path.join(docs_root, top_level_package_name) - if clean and os.path.isdir(top_level_package_docs_dir): - log.info(f"Deleting {top_level_package_docs_dir} since clean=True") - shutil.rmtree(top_level_package_docs_dir) - - index_rst_path = os.path.join(docs_root, top_level_package_name, "index.rst") - log.info(f"Creating {index_rst_path}") - write_to_file( - index_template(top_level_package_name, "API Reference"), index_rst_path - ) - - for root, dirnames, filenames in os.walk(top_level_package_dir): - if os.path.basename(root).startswith("_"): - log.debug(f"Skipping doc generation in {root}") - continue - - base_package_relpath = os.path.relpath(root, start=top_level_package_dir) - base_package_qualname = os.path.relpath(root, start=src_root).replace( - os.path.sep, "." - ) - - for dirname in dirnames: - if not dirname.startswith("_"): - package_qualname = f"{base_package_qualname}.{dirname}" - package_rst_path = os.path.abspath( - os.path.join( - top_level_package_docs_dir, - base_package_relpath, - f"{dirname}.rst", - ) - ) - package_path = os.path.join(root, dirname) - add_toctree = True - package_dir_content = list( - filter(lambda x: x != "__pycache__", os.listdir(package_path)) - ) - if package_dir_content == ["__init__.py"]: - add_toctree = False - - try: - dir_path = os.path.join(root, dirname) - if only_update and os.path.getmtime( - dir_path - ) <= os.path.getmtime(package_rst_path): - log.info( - f"Package {dir_path} hasn't been modified, skipping." - ) - continue - except FileNotFoundError: - pass - - log.info(f"Writing package documentation to {package_rst_path}") - write_to_file( - package_template(package_qualname, add_toctree=add_toctree), - package_rst_path, - ) - - for filename in filenames: - base_name, ext = os.path.splitext(filename) - if ext == ".py" and not filename.startswith("_"): - module_qualname = f"{base_package_qualname}.{filename[:-3]}" - module_rst_path = os.path.abspath( - os.path.join( - top_level_package_docs_dir, - base_package_relpath, - f"{base_name}.rst", - ) - ) - if os.path.exists(module_rst_path) and not overwrite: - log.debug(f"{module_rst_path} already exists, skipping it") - - try: - file_path = os.path.join(root, filename) - if only_update and os.path.getmtime( - file_path - ) <= os.path.getmtime(module_rst_path): - log.info( - f"Module {file_path} hasn't been modified, skipping." - ) - continue - except FileNotFoundError: - pass - - log.info(f"Writing module documentation to {module_rst_path}") - write_to_file(module_template(module_qualname), module_rst_path) - - -if __name__ == "__main__": - parser = argparse.ArgumentParser( - description="A tool to create RST files for all source files in the library", - formatter_class=argparse.ArgumentDefaultsHelpFormatter, - ) - parser.add_argument( - "-s", "--source", help="Root of the sources", type=str, default="src" - ) - - parser.add_argument( - "-d", "--doc", help="Root of the documentation", type=str, default="docs" - ) - - parser.add_argument( - "-u", - "--update", - help="Whether to only update rst files if sources are newer", - action="store_true", - ) - parser.add_argument( - "-c", "--clean", help="Wipe docs before starting", action="store_true" - ) - args = parser.parse_args() - - logging.basicConfig(level=logging.INFO) - make_rst( - src_root=args.source, - docs_root=args.doc, - clean=args.clean, - only_update=args.update, - ) From 30007256c75deb6dae014c842f04e577988ed9f0 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 18 Jun 2023 18:45:52 +0200 Subject: [PATCH 095/436] More docstring fixes, types --- src/pydvl/influence/conjugate_gradient.py | 14 +++++---- src/pydvl/reporting/plots.py | 18 +++++++----- src/pydvl/utils/caching.py | 27 +++++++++++------ src/pydvl/utils/dataset.py | 31 ++++++++++---------- src/pydvl/utils/parallel/backend.py | 6 ++-- src/pydvl/utils/parallel/futures/__init__.py | 2 +- src/pydvl/utils/parallel/futures/ray.py | 2 +- src/pydvl/utils/parallel/map_reduce.py | 17 ++++++----- src/pydvl/utils/progress.py | 2 +- src/pydvl/utils/score.py | 2 +- src/pydvl/utils/types.py | 2 +- src/pydvl/value/least_core/__init__.py | 2 +- src/pydvl/value/least_core/common.py | 2 +- src/pydvl/value/result.py | 29 ++++++++++-------- src/pydvl/value/semivalues.py | 2 +- src/pydvl/value/shapley/common.py | 6 ++-- src/pydvl/value/shapley/gt.py | 2 +- src/pydvl/value/shapley/owen.py | 5 ++-- src/pydvl/value/shapley/truncated.py | 2 +- src/pydvl/value/stopping.py | 23 ++++++++------- 20 files changed, 110 insertions(+), 86 deletions(-) diff --git a/src/pydvl/influence/conjugate_gradient.py b/src/pydvl/influence/conjugate_gradient.py index dfe18b62e..00c71fd94 100644 --- a/src/pydvl/influence/conjugate_gradient.py +++ b/src/pydvl/influence/conjugate_gradient.py @@ -59,18 +59,20 @@ def batched_preconditioned_conjugate_gradient( !!! Warning This function is experimental and unstable. Prefer using inversion_method='cg' + Args: - A: A linear function f : R[k] -> R[k] representing a matrix vector product from dimension K to K or a matrix. \ - It has to be positive-definite v.T @ f(v) >= 0. - b: A NDArray of shape [K] representing the targeted result of the matrix multiplication Ax. - max_iterations: Maximum number of iterations to use in conjugate gradient. Default is 10 times K. + A: A linear function f : R[k] -> R[k] representing a matrix vector product + from dimension K to K or a matrix. It has to be positive-definite v.T @ f(v) >= 0. + b: An array of shape [K] representing the result of the matrix + multiplication Ax. + x0: rtol: Relative tolerance of the residual with respect to the 2-norm of b. + max_iterations: Maximum number of iterations to use in conjugate gradient. Default is 10 times K. max_step_size: Maximum step size along a gradient direction. Might be necessary for numerical stability. \ See also max_iterations. Default is 10.0. - verify_assumptions: True, iff the matrix should be checked for positive-definiteness by a stochastic rule. Returns: - A NDArray of shape [K] representing the solution of Ax=b. + An of shape [K] representing the solution of Ax=b. !!! References: .. [1] [Conjugate Gradient Method - Wikipedia](https://en.wikipedia.org/wiki/Conjugate_gradient_method). diff --git a/src/pydvl/reporting/plots.py b/src/pydvl/reporting/plots.py index 8d0aa5424..9d58a093d 100644 --- a/src/pydvl/reporting/plots.py +++ b/src/pydvl/reporting/plots.py @@ -19,9 +19,10 @@ def shaded_mean_std( xlabel: Optional[str] = None, ylabel: Optional[str] = None, ax: Optional[Axes] = None, - **kwargs, + **kwargs: dict, ) -> Axes: - """The usual mean +- x std deviations plot to aggregate runs of experiments. + """ The usual mean +- std deviation plot to aggregate runs of experiments. + Args: data: axis 0 is to be aggregated on (e.g. runs) and axis 1 is the data for each run. @@ -61,12 +62,13 @@ def shaded_mean_std( def spearman_correlation(vv: List[OrderedDict], num_values: int, pvalue: float): """Simple matrix plots with spearman correlation for each pair in vv. - vv: list of OrderedDicts with index: value. Spearman correlation - is computed for the keys. - num_values: Use only these many values from the data (from the start - of the OrderedDicts) - pvalue: correlation coefficients for which the p-value is below the - threshold `pvalue/len(vv)` will be discarded. + Args: + vv: list of OrderedDicts with index: value. Spearman correlation + is computed for the keys. + num_values: Use only these many values from the data (from the start + of the OrderedDicts) + pvalue: correlation coefficients for which the p-value is below the + threshold `pvalue/len(vv)` will be discarded. """ r: np.ndarray = np.ndarray((len(vv), len(vv))) p: np.ndarray = np.ndarray((len(vv), len(vv))) diff --git a/src/pydvl/utils/caching.py b/src/pydvl/utils/caching.py index a2265e2a6..a8c737ecc 100644 --- a/src/pydvl/utils/caching.py +++ b/src/pydvl/utils/caching.py @@ -43,10 +43,8 @@ training for small sample sizes), but drastically reduces the speed benefits of memoization. -This behaviour can be activated with -[allow_repeated_evaluations][pydvl.utils.config.MemcachedConfig.allow_repeated_evaluations]. - -.. _cache reuse: +This behaviour can be activated with the argument `allow_repeated_evaluations` +to [memcached()][pydvl.utils.caching.memcached]. # Cache reuse @@ -78,9 +76,10 @@ run across multiple processes and some reporting arguments are added (like a `job_id` for logging purposes), these will be part of the signature and make the functions distinct to the eyes of the cache. This can be avoided with the use of -[ignore_args][pydvl.utils.config.MemcachedConfig.ignore_args] in the configuration. +[ignore_args][pydvl.utils.config.MemcachedConfig] in the configuration. """ +from __future__ import annotations import logging import socket @@ -91,7 +90,7 @@ from hashlib import blake2b from io import BytesIO from time import time -from typing import Callable, Dict, Iterable, Optional, TypeVar, cast +from typing import Any, Callable, Dict, Iterable, Optional, TypeVar, cast from cloudpickle import Pickler from pymemcache import MemcacheUnexpectedCloseError @@ -109,7 +108,16 @@ @dataclass class CacheStats: - """Statistics gathered by cached functions.""" + """Statistics gathered by cached functions. + + Attributes: + sets: number of times a value was set in the cache + misses: number of times a value was not found in the cache + hits: number of times a value was found in the cache + timeouts: number of times a timeout occurred + errors: number of times an error occurred + reconnects: number of times the client reconnected to the server + """ sets: int = 0 misses: int = 0 @@ -119,7 +127,8 @@ class CacheStats: reconnects: int = 0 -def serialize(x): +def serialize(x: Any) -> bytes: + """Serialize an object to bytes. """ pickled_output = BytesIO() pickler = Pickler(pickled_output, PICKLE_VERSION) pickler.dump(x) @@ -133,7 +142,7 @@ def memcached( rtol_stderr: float = 0.1, min_repetitions: int = 3, ignore_args: Optional[Iterable[str]] = None, -): +) -> Callable[[Callable[..., T], bytes|None], Callable[..., T]]: """ Transparent, distributed memoization of function calls. diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index 2857556ba..26b96a336 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -257,7 +257,7 @@ def from_sklearn( train_size: float = 0.8, random_state: Optional[int] = None, stratify_by_target: bool = False, - **kwargs, + **kwargs: dict, ) -> "Dataset": """Constructs a [Dataset][pydvl.utils.Dataset] object from a [Bunch][sklearn.utils.Bunch], as returned by the `load_*` functions in @@ -299,7 +299,7 @@ def from_sklearn( feature_names=data.get("feature_names"), target_names=data.get("target_names"), description=data.get("DESCR"), - **kwargs, + **kwargs ) @classmethod @@ -310,7 +310,7 @@ def from_arrays( train_size: float = 0.8, random_state: Optional[int] = None, stratify_by_target: bool = False, - **kwargs, + **kwargs: dict, ) -> "Dataset": """Constructs a [Dataset][pydvl.utils.Dataset] object from X and y numpy arrays as returned by the `make_*` functions in [sklearn generated datasets](https://scikit-learn.org/stable/datasets/sample_generators.html). @@ -357,7 +357,7 @@ def __init__( target_names: Optional[Sequence[str]] = None, group_names: Optional[Sequence[str]] = None, description: Optional[str] = None, - **kwargs, + **kwargs: dict, ): """Class for grouping datasets. @@ -436,7 +436,7 @@ def get_training_data( Args: indices: group indices whose elements to return. If `None`, - all data from all groups are returned. + all data from all groups are returned. Returns: Tuple of training data x and labels y. @@ -456,7 +456,7 @@ def from_sklearn( random_state: Optional[int] = None, stratify_by_target: bool = False, data_groups: Optional[Sequence] = None, - **kwargs, + **kwargs: dict, ) -> "GroupedDataset": """Constructs a [GroupedDataset][pydvl.utils.GroupedDataset] object from a scikit-learn bunch as returned by the `load_*` functions in `sklearn toy datasets @@ -476,8 +476,8 @@ def from_sklearn( fashion, using the target variable as labels. Read more in [sklearn's user guide](https://scikit-learn.org/stable/modules/cross_validation.html#stratification). data_groups: an array holding the group index or name for each - data point. The length of this array must be equal to the number of - data points in the dataset. + data point. The length of this array must be equal to the number of + data points in the dataset. kwargs: Additional keyword arguments to pass to the [Dataset][pydvl.utils.Dataset] constructor. @@ -512,7 +512,7 @@ def from_arrays( random_state: Optional[int] = None, stratify_by_target: bool = False, data_groups: Optional[Sequence] = None, - **kwargs, + **kwargs: dict, ) -> "Dataset": """Constructs a [GroupedDataset][pydvl.utils.GroupedDataset] object from X and y numpy arrays as returned by the `make_*` functions in `sklearn generated datasets @@ -593,7 +593,7 @@ def load_spotify_dataset( min_year: int = 2014, target_column: str = "popularity", random_state: int = 24, -): +) -> tuple[list, list, list]: """Loads (and downloads if not already cached) the spotify music dataset. More info on the dataset can be found at https://www.kaggle.com/datasets/mrmorj/dataset-of-songs-in-spotify. @@ -609,7 +609,7 @@ def load_spotify_dataset( random_state: fixes sklearn random seed Returns: - Tuple with 3 elements, each being a list sith [input_data, related_labels] + Tuple with 3 elements, each being a list with [input_data, related_labels] """ root_dir_path = Path(__file__).parent.parent.parent.parent file_path = root_dir_path / "data/top_hits_spotify_dataset.csv" @@ -693,12 +693,12 @@ def load_wine_dataset( def synthetic_classification_dataset( - mus: np.ndarray, + mus: NDArray, sigma: float, num_samples: int, train_size: float, test_size: float, - random_seed=None, + random_seed: int = None, ) -> Tuple[Tuple[Any, Any], Tuple[Any, Any], Tuple[Any, Any]]: """Sample from a uniform Gaussian mixture model. @@ -708,7 +708,7 @@ def synthetic_classification_dataset( num_samples: The number of samples to generate. train_size: fraction of points used for training dataset test_size: fraction of points used for test dataset - random_seed: fix random seed. If None, no random seed is set. + random_seed: fix random seed. If `None`, no random seed is set. Returns: A tuple of matrix x of shape [NxD] and target vector y of shape [N]. @@ -746,7 +746,8 @@ def decision_boundary_fixed_variance_2d( mu_2: Second mean. Returns: - A callable which converts a continuous line (-infty, infty) to the decision boundary in feature space. + A callable which converts a continuous line (-infty, infty) to the + decision boundary in feature space. """ a = np.asarray([[0, 1], [-1, 0]]) @ (mu_2 - mu_1) b = (mu_1 + mu_2) / 2 diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index 64bcc931c..6477d407c 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -149,7 +149,7 @@ def get( self, v: Union[ObjectRef, Iterable[ObjectRef], T], *args, - **kwargs, + **kwargs: dict, ) -> Union[T, Any]: timeout: Optional[float] = kwargs.get("timeout", None) if isinstance(v, ObjectRef): @@ -165,7 +165,7 @@ def put(self, v: T, *args, **kwargs) -> Union["ObjectRef[T]", T]: except TypeError: return v # type: ignore - def wrap(self, fun: Callable, **kwargs) -> Callable: + def wrap(self, fun: Callable, **kwargs: dict) -> Callable: """Wraps a function as a ray remote. Args: @@ -183,7 +183,7 @@ def wait( self, v: List["ObjectRef"], *args, - **kwargs, + **kwargs: dict, ) -> Tuple[List[ObjectRef], List[ObjectRef]]: num_returns: int = kwargs.get("num_returns", 1) timeout: Optional[float] = kwargs.get("timeout", None) diff --git a/src/pydvl/utils/parallel/futures/__init__.py b/src/pydvl/utils/parallel/futures/__init__.py index 5166a2769..983feaa1a 100644 --- a/src/pydvl/utils/parallel/futures/__init__.py +++ b/src/pydvl/utils/parallel/futures/__init__.py @@ -12,7 +12,7 @@ def init_executor( max_workers: Optional[int] = None, config: ParallelConfig = ParallelConfig(), - **kwargs, + **kwargs: dict, ) -> Generator[Executor, None, None]: """Initializes a futures executor based on the passed parallel configuration object. diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 545481bf0..9c1aad7a3 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -86,7 +86,7 @@ def __init__( # Work Item Manager Thread self._work_item_manager_thread: Optional[_WorkItemManagerThread] = None - def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": + def submit(self, fn: Callable[..., T], *args: list, **kwargs: dict) -> "Future[T]": r"""Submits a callable to be executed with the given arguments. Schedules the callable to be executed as fn(\*args, \**kwargs) diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index 1508e3882..f809adc53 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -89,20 +89,23 @@ class MapReduceJob(Generic[T, R]): reduce_func: Function that will be applied to the results of `map_func` to reduce them. map_kwargs: Keyword arguments that will be passed to `map_func` in - each job. Alternatively, one can use `itertools.partial`. + each job. Alternatively, one can use + [itertools.partial][itertools.partial]. reduce_kwargs: Keyword arguments that will be passed to `reduce_func` - in each job. Alternatively, one can use [itertools.partial][]. + in each job. Alternatively, one can use + [itertools.partial][itertools.partial]. config: Instance of [ParallelConfig][pydvl.utils.config.ParallelConfig] with cluster address, number of cpus, etc. n_jobs: Number of parallel jobs to run. Does not accept 0 timeout: Amount of time in seconds to wait for remote results before ... TODO max_parallel_tasks: Maximum number of jobs to start in parallel. Any - tasks above this number won't be submitted to the backend before some - are done. This is to avoid swamping the work queue. Note that tasks have - a low memory footprint, so this is probably not a big concern, except - in the case of an infinite stream (not the case for MapReduceJob). See - the [ray docs](https://docs.ray.io/en/latest/ray-core/patterns/limit-pending-tasks.html) + tasks above this number won't be submitted to the backend before + some are done. This is to avoid swamping the work queue. Note that + tasks have a low memory footprint, so this is probably not a big + concern, except in the case of an infinite stream (not the case for + MapReduceJob). See the + [ray docs](https://docs.ray.io/en/latest/ray-core/patterns/limit-pending-tasks.html) Examples: diff --git a/src/pydvl/utils/progress.py b/src/pydvl/utils/progress.py index a96aeecca..24aa2ace8 100644 --- a/src/pydvl/utils/progress.py +++ b/src/pydvl/utils/progress.py @@ -52,7 +52,7 @@ def __setattr__(self, key, value): def maybe_progress( - it: Union[int, Iterable, Iterator], display: bool = False, **kwargs + it: Union[int, Iterable, Iterator], display: bool = False, **kwargs: dict ) -> Union[tqdm, MockProgress]: """Returns either a tqdm progress bar or a mock object which wraps the iterator as well, but ignores any accesses to methods or properties. diff --git a/src/pydvl/utils/score.py b/src/pydvl/utils/score.py index a061b0923..578ed76ae 100644 --- a/src/pydvl/utils/score.py +++ b/src/pydvl/utils/score.py @@ -45,7 +45,7 @@ class Scorer: methods can use this to estimate the number of samples required for a certain quality of approximation. If not provided, it can be read from the `scoring` object if it provides it, for instance if it was - constructed with [compose_score()][pydvl.utils.types.compose_score]. + constructed with [compose_score()][pydvl.utils.score.compose_score]. name: The name of the scorer. If not provided, the name of the function passed will be used. diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index 81770f07f..c0d9da5b1 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -27,7 +27,7 @@ def score(self, x: NDArray, y: NDArray) -> float: pass -def maybe_add_argument(fun: Callable, new_arg: str): +def maybe_add_argument(fun: Callable, new_arg: str) -> Callable: """Wraps a function to accept the given keyword parameter if it doesn't already. diff --git a/src/pydvl/value/least_core/__init__.py b/src/pydvl/value/least_core/__init__.py index 8451dd4f0..bac5c14bc 100644 --- a/src/pydvl/value/least_core/__init__.py +++ b/src/pydvl/value/least_core/__init__.py @@ -47,7 +47,7 @@ def compute_least_core_values( mode: LeastCoreMode = LeastCoreMode.MonteCarlo, non_negative_subsidy: bool = False, solver_options: Optional[dict] = None, - **kwargs, + **kwargs: dict, ) -> ValuationResult: """Umbrella method to compute Least Core values with any of the available algorithms. diff --git a/src/pydvl/value/least_core/common.py b/src/pydvl/value/least_core/common.py index 35b7ff280..9541d540f 100644 --- a/src/pydvl/value/least_core/common.py +++ b/src/pydvl/value/least_core/common.py @@ -297,7 +297,7 @@ def _solve_egalitarian_least_core_quadratic_program( b_lb: NDArray[np.float_], solver_options: dict, ) -> Optional[NDArray[np.float_]]: - """Solves the egalitarian Least Core's quadratic program using cvxopt. + r"""Solves the egalitarian Least Core's quadratic program using cvxopt. $$ \text{minimize} \ & \| x \|_2 \\ diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index 0278b1b91..626092236 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -18,7 +18,7 @@ Results can also be sorted by value, variance or number of updates, see [sort()][pydvl.value.result.ValuationResult.sort]. The arrays of -[ValuationResult.values][pydvl.value.result.aluationResult.values], +[ValuationResult.values][pydvl.value.result.ValuationResult.values], [ValuationResult.variances][pydvl.value.result.ValuationResult.variances], [ValuationResult.counts][pydvl.value.result.ValuationResult.counts], [ValuationResult.indices][pydvl.value.result.ValuationResult.indices], @@ -93,23 +93,26 @@ class ValueItem(Generic[IndexT, NameT]): """The result of a value computation for one datum. `ValueItems` can be compared with the usual operators, forming a total - order. Comparisons take only the [value][pydvl.value.result.ValueItem.value] into account. + order. Comparisons take only the `value` into account. - !!! Todo + !!! todo Maybe have a mode of comparing similar to `np.isclose`, or taking the - [variance][pydvl.value.result.ValueItem.variance] into account. + `variance` into account. + + Attributes: + index: Index of the sample with this value in the original + [Dataset][pydvl.utils.dataset.Dataset] + name: Name of the sample if it was provided. Otherwise, `str(index)` + value: The value + variance: Variance of the value if it was computed with an approximate + method + count: Number of updates for this value """ - #: Index of the sample with this value in the original - # [Dataset][pydvl.utils.dataset.Dataset] index: IndexT - #: Name of the sample if it was provided. Otherwise, `str(index)` name: NameT - #: The value value: float - #: Variance of the value if it was computed with an approximate method variance: Optional[float] - #: Number of updates for this value count: Optional[int] def __lt__(self, other): @@ -192,7 +195,7 @@ class ValuationResult( common to pass the indices of a [Dataset][pydvl.utils.dataset.Dataset] here. Attention must be paid in a parallel context to copy them to the local process. Just do `indices=np.copy(data.indices)`. - variance: An optional array of variances in the computation of each value. + variances: An optional array of variances in the computation of each value. counts: An optional array with the number of updates for each value. Defaults to an array of ones. data_names: Names for the data points. Defaults to index numbers if not set. @@ -229,7 +232,7 @@ def __init__( algorithm: str = "", status: Status = Status.Pending, sort: bool = False, - **extra_values, + **extra_values: dict, ): if variances is not None and len(variances) != len(values): raise ValueError("Lengths of values and variances do not match") @@ -667,7 +670,7 @@ def to_dataframe( @classmethod def from_random( - cls, size: int, total: Optional[float] = None, **kwargs + cls, size: int, total: Optional[float] = None, **kwargs: dict ) -> "ValuationResult": """Creates a [ValuationResult][pydvl.value.result.ValuationResult] object and fills it with an array of random values from a uniform distribution in [-1,1]. The values can diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 94b7db9b2..922a5e481 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -204,7 +204,7 @@ def compute_semivalues( mode: SemiValueMode = SemiValueMode.Shapley, sampler_t: Type[PowersetSampler] = PermutationSampler, n_jobs: int = 1, - **kwargs, + **kwargs: dict, ) -> ValuationResult: """Entry point for most common semi-value computations. All are implemented with permutation sampling. diff --git a/src/pydvl/value/shapley/common.py b/src/pydvl/value/shapley/common.py index fa3b90ff7..803401b5b 100644 --- a/src/pydvl/value/shapley/common.py +++ b/src/pydvl/value/shapley/common.py @@ -24,7 +24,7 @@ def compute_shapley_values( done: StoppingCriterion = MaxUpdates(100), mode: ShapleyMode = ShapleyMode.TruncatedMontecarlo, n_jobs: int = 1, - **kwargs, + **kwargs: dict, ) -> ValuationResult: """Umbrella method to compute Shapley values with any of the available algorithms. @@ -51,7 +51,7 @@ def compute_shapley_values( - `truncated_montecarlo`: default option, same as `permutation_montecarlo` but stops the computation whenever a certain accuracy is reached. Implemented in - [truncated_montecarlo_shapley()][pydvl.value.shapley.montecarlo.truncated_montecarlo_shapley]. + [truncated_montecarlo_shapley()][pydvl.value.shapley.truncated.truncated_montecarlo_shapley]. - `owen_sampling`: Uses the Owen continuous extension of the utility function to the unit cube. Implemented in [owen_sampling_shapley()][pydvl.value.shapley.owen.owen_sampling_shapley]. This @@ -116,7 +116,7 @@ def compute_shapley_values( n_jobs=n_jobs, progress=progress, truncation=truncation, - **kwargs, + **kwargs ) elif mode == ShapleyMode.CombinatorialExact: return combinatorial_exact_shapley(u, n_jobs=n_jobs, progress=progress) diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index 258eebabf..c5458561f 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -157,7 +157,7 @@ def group_testing_shapley( n_jobs: int = 1, config: ParallelConfig = ParallelConfig(), progress: bool = False, - **options, + **options: dict, ) -> ValuationResult: """Implements group testing for approximation of Shapley values as described in [@jia_efficient_2019]. diff --git a/src/pydvl/value/shapley/owen.py b/src/pydvl/value/shapley/owen.py index d298ac856..ff5831e93 100644 --- a/src/pydvl/value/shapley/owen.py +++ b/src/pydvl/value/shapley/owen.py @@ -136,8 +136,9 @@ def owen_sampling_shapley( max_q: Number of subdivisions for q ∈ [0,1] (the element sampling probability) used to approximate the outer integral. method: Selects the algorithm to use, see the description. Either - [Full][OwenAlgorithm.Full] for $q \in [0,1]$ or - [Halved][OwenAlgorithm.Halved] for $q \in [0,0.5]$ and correlated samples + [Full][pydvl.value.shapley.owen.OwenAlgorithm.Full] for $q \in [0,1]$ + or [Halved][pydvl.value.shapley.owen.OwenAlgorithm.Halved] for + $q \in [0,0.5]$ and correlated samples n_jobs: Number of parallel jobs to use. Each worker receives a chunk of the total of `max_q` values for q. config: Object configuring parallel computation, with cluster address, diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 44c9f445a..59575081d 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -89,7 +89,7 @@ class FixedTruncation(TruncationPolicy): Args: u: Utility object with model, data, and scoring function fraction: Fraction of marginals in a permutation to compute before - stopping (e.g. 0.5 to compute half of the marginals). + stopping (e.g. 0.5 to compute half of the marginals). """ def __init__(self, u: Utility, fraction: float): diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index fa500585b..47885c026 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -57,7 +57,7 @@ logger = logging.getLogger(__name__) -StoppingCriterionCallable = Callable[[ValuationResult], Status] +StoppingCriterionCallable = Callable[[ValuationResult], Status] #: Signature for a stopping criterion class StoppingCriterion(abc.ABC): @@ -93,22 +93,21 @@ class StoppingCriterion(abc.ABC): [_check()][pydvl.value.stopping.StoppingCriterion._check] method that returns a [Status][pydvl.utils.status.Status] object based on a given [ValuationResult][pydvl.value.result.ValuationResult]. This method should - update the attribute [converged][pydvl.value.result.ValuationResult.converged], + update the attribute [_converged][pydvl.value.stopping.StoppingCriterion._converged], which is a boolean array indicating whether the value for each index has - converged. When this is not possible, + converged. When this does not make sense for a particular stopping criterion, [completion()][pydvl.value.stopping.StoppingCriterion.completion] should be - overridden to provide an overall completion value, since the default - implementation returns the mean of - [converged][pydvl.value.result.ValuationResult.converged]. + overridden to provide an overall completion value, since its default + implementation attempts to compute the mean of + [_converged][pydvl.value.stopping.StoppingCriterion._converged]. Args: modify_result: If `True` the status of the input - [ValuationResult][pydvl.value.result.ValuationResult] is modified in place after - the call. + [ValuationResult][pydvl.value.result.ValuationResult] is modified in + place after the call. """ - # A boolean array indicating whether the corresponding element has converged - _converged: NDArray[np.bool_] + _converged: NDArray[np.bool_] #: A boolean array indicating whether the corresponding element has converged def __init__(self, modify_result: bool = True): self.modify_result = modify_result @@ -134,6 +133,10 @@ def converged(self) -> NDArray[np.bool_]: Inheriting classes must set the `_converged` attribute in their [_check()][pydvl.value.stopping.StoppingCriterion._check]. + + Returns: + A boolean array indicating whether the values have converged for + each data point. """ return self._converged From 011825668b8f936e0b11b5b05eca11e6e7b40b9e Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 18 Jun 2023 18:47:53 +0200 Subject: [PATCH 096/436] de-flufficationistic commit --- src/pydvl/reporting/plots.py | 2 +- src/pydvl/utils/caching.py | 4 ++-- src/pydvl/utils/dataset.py | 2 +- src/pydvl/value/shapley/common.py | 2 +- src/pydvl/value/stopping.py | 8 ++++++-- 5 files changed, 11 insertions(+), 7 deletions(-) diff --git a/src/pydvl/reporting/plots.py b/src/pydvl/reporting/plots.py index 9d58a093d..03364d9d8 100644 --- a/src/pydvl/reporting/plots.py +++ b/src/pydvl/reporting/plots.py @@ -21,7 +21,7 @@ def shaded_mean_std( ax: Optional[Axes] = None, **kwargs: dict, ) -> Axes: - """ The usual mean +- std deviation plot to aggregate runs of experiments. + """The usual mean +- std deviation plot to aggregate runs of experiments. Args: data: axis 0 is to be aggregated on (e.g. runs) and axis 1 is the diff --git a/src/pydvl/utils/caching.py b/src/pydvl/utils/caching.py index a8c737ecc..5bcd1d8e2 100644 --- a/src/pydvl/utils/caching.py +++ b/src/pydvl/utils/caching.py @@ -128,7 +128,7 @@ class CacheStats: def serialize(x: Any) -> bytes: - """Serialize an object to bytes. """ + """Serialize an object to bytes.""" pickled_output = BytesIO() pickler = Pickler(pickled_output, PICKLE_VERSION) pickler.dump(x) @@ -142,7 +142,7 @@ def memcached( rtol_stderr: float = 0.1, min_repetitions: int = 3, ignore_args: Optional[Iterable[str]] = None, -) -> Callable[[Callable[..., T], bytes|None], Callable[..., T]]: +) -> Callable[[Callable[..., T], bytes | None], Callable[..., T]]: """ Transparent, distributed memoization of function calls. diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index 26b96a336..f6178605e 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -299,7 +299,7 @@ def from_sklearn( feature_names=data.get("feature_names"), target_names=data.get("target_names"), description=data.get("DESCR"), - **kwargs + **kwargs, ) @classmethod diff --git a/src/pydvl/value/shapley/common.py b/src/pydvl/value/shapley/common.py index 803401b5b..f2b030090 100644 --- a/src/pydvl/value/shapley/common.py +++ b/src/pydvl/value/shapley/common.py @@ -116,7 +116,7 @@ def compute_shapley_values( n_jobs=n_jobs, progress=progress, truncation=truncation, - **kwargs + **kwargs, ) elif mode == ShapleyMode.CombinatorialExact: return combinatorial_exact_shapley(u, n_jobs=n_jobs, progress=progress) diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index 47885c026..24afbef66 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -57,7 +57,9 @@ logger = logging.getLogger(__name__) -StoppingCriterionCallable = Callable[[ValuationResult], Status] #: Signature for a stopping criterion +StoppingCriterionCallable = Callable[ + [ValuationResult], Status +] #: Signature for a stopping criterion class StoppingCriterion(abc.ABC): @@ -107,7 +109,9 @@ class StoppingCriterion(abc.ABC): place after the call. """ - _converged: NDArray[np.bool_] #: A boolean array indicating whether the corresponding element has converged + _converged: NDArray[ + np.bool_ + ] #: A boolean array indicating whether the corresponding element has converged def __init__(self, modify_result: bool = True): self.modify_result = modify_result From 064351e3db6a82ec0ae43230d7b2d4f2c5c5b339 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Wed, 21 Jun 2023 10:18:08 +0200 Subject: [PATCH 097/436] Add generator function for batch hessian vector products --- src/pydvl/influence/frameworks/util.py | 36 +++++++++++++++++--------- 1 file changed, 24 insertions(+), 12 deletions(-) diff --git a/src/pydvl/influence/frameworks/util.py b/src/pydvl/influence/frameworks/util.py index 3ce8c5899..4a609c998 100644 --- a/src/pydvl/influence/frameworks/util.py +++ b/src/pydvl/influence/frameworks/util.py @@ -1,5 +1,6 @@ from dataclasses import dataclass -from typing import Callable, Tuple, Optional +from functools import partial, reduce +from typing import Callable, Tuple, Optional, Generator import logging import torch @@ -53,6 +54,26 @@ def hvp(model: torch.nn.Module, return hessian_vec_prod +def batch_hvp_gen(model: torch.nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + data_loader: DataLoader) -> Generator[Callable[[torch.Tensor], torch.Tensor], None, None]: + """ + Generates a sequence of batch Hessian-vector product (HVP) computations for the provided model, loss function, + and data loader. + + The generator iterates over the data_loader, creating partial function calls for calculating HVPs. + + :param model: The PyTorch model for which the HVP is calculated. + :param loss: The loss function used to calculate the gradient and HVP. + :param data_loader: PyTorch DataLoader object containing the dataset for which the HVP is calculated. + :yield: A partial function H(vec)=hvp(model, loss, inputs, targets, vec) that when called, + will compute the Hessian-vector product H(vec) for the given model, loss, inputs and targets. + """ + + for inputs, targets in iter(data_loader): + yield partial(hvp, model, loss, inputs, targets) + + def avg_gradient(model: torch.nn.Module, loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], data_loader: DataLoader) -> torch.Tensor: @@ -119,17 +140,8 @@ def hvp_function(vec: torch.Tensor) -> torch.Tensor: return hessian_vec_prod def avg_hvp_function(vec: torch.Tensor) -> torch.Tensor: - hessian_vec_prod_sum = None - - for inputs, targets in iter(data_loader): - hessian_vec_prod = hvp(model, loss, inputs, targets, vec) - - if hessian_vec_prod_sum is None: - hessian_vec_prod_sum = hessian_vec_prod - else: - hessian_vec_prod_sum += hessian_vec_prod - - return hessian_vec_prod_sum / len(data_loader) + batch_hessians = map(lambda x: x(vec), batch_hvp_gen(model, loss, data_loader)) + return reduce(lambda x, y: x+y, batch_hessians) / len(data_loader) return avg_hvp_function if use_hessian_avg else hvp_function From 40bf75ee822c630eedd8bcf21a4d7a4cddb9d6e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Wed, 21 Jun 2023 10:27:59 +0200 Subject: [PATCH 098/436] Add inversion via low-rank approximation --- .../frameworks/torch_differentiable.py | 61 +++++++++++++++++++ src/pydvl/influence/inversion.py | 11 ++++ tests/influence/test_influences.py | 4 ++ 3 files changed, 76 insertions(+) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 2d120e381..2b3c2dad7 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -14,6 +14,7 @@ from torch.autograd import Variable from torch.utils.data import DataLoader +from .util import LowRankProductRepresentation, get_hvp_function, lanzcos_low_rank_hessian_approx from ...utils import maybe_progress from .twice_differentiable import TwiceDifferentiable @@ -423,3 +424,63 @@ def hessian( self.parameters, progress=progress, ) + + +def solve_low_rank(model: TorchTwiceDifferentiable, training_data: DataLoader, b: torch.Tensor, *, + hessian_perturbation: float = 0.0, + rank_estimate: int = 10, + krylov_dimension: Optional[int] = None, + low_rank_representation: Optional[LowRankProductRepresentation] = None, + x0: Optional[torch.Tensor] = None, + tol: float = 1e-6, + max_iter: Optional[int] = None + ) -> torch.Tensor: + + """ + Solves the linear system Hx = b, where H is the Hessian of the model's loss function and b is the given right-hand + side vector. The Hessian is approximated using a low-rank representation. + + :param model: A PyTorch model instance that is twice differentiable, wrapped into :class:`TorchTwiceDifferential`. + The Hessian will be calculated with respect to this model's parameters. + :param training_data: A DataLoader instance that provides the model's training data. + Used in calculating the Hessian-vector products. + :param b: The right-hand side vector in the system Hx = b. + :param hessian_perturbation: Optional regularization parameter added to the Hessian-vector product + for numerical stability. + :param rank_estimate: The number of eigenvalues and corresponding eigenvectors to compute. + Represents the desired rank of the Hessian approximation. + :param krylov_dimension: The number of Krylov vectors to use for the Lanczos method. + If not provided, it defaults to $min(model.num_parameters, max(2*rank_estimate + 1, 20))$. + :param low_rank_representation: A LowRankProductRepresentation instance containing a previously computed + low-rank representation of the Hessian. + If not provided, a new low-rank representation will be computed, + using provided parameters. + :param x0: An optional initial vector to use in the Lanczos algorithm. + If `low_rank_representation` is provided, this parameter is ignored. + :param tol: The stopping criteria for the Lanczos algorithm. + If `low_rank_representation` is provided, this parameter is ignored. + :param max_iter: The maximum number of iterations for the Lanczos method. + If `low_rank_representation` is provided, this parameter is ignored. + :return: Returns the solution vector x that satisfies the system Hx = b, + where H is a low-rank approximation of the Hessian of the model's loss function. + """ + + if low_rank_representation is None: + hessian_vector_product = get_hvp_function(model.model, model.loss, training_data) + low_rank_representation = lanzcos_low_rank_hessian_approx(hessian_vp=hessian_vector_product, + matrix_shape=(model.num_params, model.num_params), + hessian_perturbation=hessian_perturbation, + rank_estimate=rank_estimate, + x0=x0, + krylov_dimension=krylov_dimension, + tol=tol, + max_iter=max_iter, + device=model.device if hasattr(model, 'device') + else None) + else: + logger.info("Using provided low rank representation, ignoring other parameters") + + result = low_rank_representation.projections @ ((low_rank_representation.projections.T @ b.T) / low_rank_representation.eigen_vals.unsqueeze(1)) + return result.T + + diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 4cd48571b..7182c1400 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -17,6 +17,8 @@ __all__ = ["solve_hvp"] +from .frameworks.torch_differentiable import solve_low_rank + logger = logging.getLogger(__name__) @@ -28,6 +30,7 @@ class InversionMethod(str, Enum): Direct = "direct" Cg = "cg" Lissa = "lissa" + LowRank = "low_rank" def solve_hvp( @@ -87,5 +90,13 @@ def solve_hvp( hessian_perturbation=hessian_perturbation, progress=progress, ) + elif inversion_method == InversionMethod.LowRank: + return solve_low_rank( + model, + training_data, + b, + **kwargs, + hessian_perturbation=hessian_perturbation, + ) else: raise ValueError(f"Unknown inversion method: {inversion_method}") diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index b105ae982..6096f0ce7 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -94,6 +94,7 @@ def analytical_linear_influences( [InversionMethod.Direct, {}, 1e-7], [InversionMethod.Cg, {}, 1e-1], [InversionMethod.Lissa, {"maxiter": 5000, "scale": 100}, 0.3], + [InversionMethod.LowRank, {"rank_estimate": 47}, 0.3] ], ids=[inv.value for inv in InversionMethod], ) @@ -246,6 +247,7 @@ def test_influences_nn( "maxiter": 100, "scale": 10000, }, + "low_rank": {"rank_estimate": 20} } train_data_loader = DataLoader( TensorDataset(x_train, y_train), batch_size=batch_size @@ -272,6 +274,8 @@ def test_influences_nn( for infl_type, influences in multiple_influences.items(): if infl_type == "direct": continue + if infl_type == "low_rank": + continue assert np.allclose( influences, multiple_influences["direct"], From 1a28193a0529391b6db7ff6b3a1d634908e032ee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 22 Jun 2023 14:53:22 +0200 Subject: [PATCH 099/436] Set torch default dtype to float64 in test_influences.py, fix test for low rank approximation solver --- .../frameworks/torch_differentiable.py | 5 ++-- tests/influence/test_influences.py | 26 +++++++++++++------ tests/influence/test_util.py | 26 ++++++------------- 3 files changed, 29 insertions(+), 28 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 2b3c2dad7..94d330548 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -480,7 +480,8 @@ def solve_low_rank(model: TorchTwiceDifferentiable, training_data: DataLoader, b else: logger.info("Using provided low rank representation, ignoring other parameters") - result = low_rank_representation.projections @ ((low_rank_representation.projections.T @ b.T) / low_rank_representation.eigen_vals.unsqueeze(1)) - return result.T + result = low_rank_representation.projections @ (torch.diag_embed(1. / low_rank_representation.eigen_vals) @ + (low_rank_representation.projections.t() @ b.t())) + return result.t() diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 6096f0ce7..fae5abe9b 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -1,4 +1,3 @@ -import itertools from typing import Dict, Tuple import numpy as np @@ -19,9 +18,10 @@ linear_analytical_influence_factors, linear_derivative_analytical, linear_mixed_second_derivative_analytical, - linear_model, + linear_model ) +torch.set_default_dtype(torch.float64) def analytical_linear_influences( linear_model: Tuple[NDArray[np.float_], NDArray[np.float_]], @@ -93,8 +93,8 @@ def analytical_linear_influences( [ [InversionMethod.Direct, {}, 1e-7], [InversionMethod.Cg, {}, 1e-1], - [InversionMethod.Lissa, {"maxiter": 5000, "scale": 100}, 0.3], - [InversionMethod.LowRank, {"rank_estimate": 47}, 0.3] + [InversionMethod.Lissa, {"maxiter": 6000, "scale": 100}, 0.3], + [InversionMethod.LowRank, {"rank_estimate": 83, "hessian_regularization": 0.01}, 0.4] ], ids=[inv.value for inv in InversionMethod], ) @@ -106,10 +106,13 @@ def test_influence_linear_model( train_set_size: int, hessian_reg: float = 0.1, test_set_size: int = 20, - problem_dimension: Tuple[int, int] = (3, 15), - condition_number: float = 3, + problem_dimension: Tuple[int, int] = (4, 20), + condition_number: float = 2, ): + torch.set_default_dtype(torch.float64) + hessian_reg = inversion_method_kwargs.pop("hessian_regularization", hessian_reg) + A, b = linear_model(problem_dimension, condition_number) train_data, test_data = add_noise_to_linear_model( (A, b), train_set_size, test_set_size @@ -238,7 +241,8 @@ def test_influences_nn( y_train = torch.rand((data_len, output_dim)) x_test = torch.rand((test_data_len, *input_dim)) y_test = torch.rand((test_data_len, output_dim)) - nn_architecture.eval() + + num_parameters = sum(p.numel() for p in nn_architecture.parameters() if p.requires_grad) inversion_method_kwargs = { "direct": {}, @@ -247,7 +251,7 @@ def test_influences_nn( "maxiter": 100, "scale": 10000, }, - "low_rank": {"rank_estimate": 20} + "low_rank": {"rank_estimate": num_parameters - 1, "hessian_regularization": 0.01} } train_data_loader = DataLoader( TensorDataset(x_train, y_train), batch_size=batch_size @@ -256,8 +260,14 @@ def test_influences_nn( TensorDataset(x_test, y_test), batch_size=batch_size, ) + + nn_architecture.eval() multiple_influences = {} + for inversion_method in InversionMethod: + + hessian_reg = inversion_method_kwargs[inversion_method].pop("hessian_regularization", hessian_reg) + influences = compute_influences( TorchTwiceDifferentiable(nn_architecture, loss), training_data=train_data_loader, diff --git a/tests/influence/test_util.py b/tests/influence/test_util.py index d2d49c88c..a411e9270 100644 --- a/tests/influence/test_util.py +++ b/tests/influence/test_util.py @@ -33,23 +33,23 @@ class UtilTestParameters: test_parameters = [ UtilTestParameters(ModelParams(dimension=(30, 16), condition_number=4, train_size=60), batch_size=4, - rank_estimate=50, + rank_estimate=200, regularization=0.0001), UtilTestParameters(ModelParams(dimension=(32, 35), condition_number=1e6, train_size=100), batch_size=5, rank_estimate=70, - regularization=0.00001), + regularization=0.001), UtilTestParameters(ModelParams(dimension=(25, 15), condition_number=1e3, train_size=90), batch_size=10, rank_estimate=50, - regularization=0.000001), + regularization=0.0001), UtilTestParameters(ModelParams(dimension=(30, 15), condition_number=1e4, train_size=120), batch_size=8, - rank_estimate=60, + rank_estimate=160, regularization=0.00001), UtilTestParameters(ModelParams(dimension=(40, 13), condition_number=1e5, train_size=900), batch_size=4, - rank_estimate=90, + rank_estimate=250, regularization=0.00001), ] @@ -98,20 +98,10 @@ def test_get_hvp_function(model_data, tol: float, use_avg: bool, batch_size: int def test_lanzcos_low_rank_hessian_approx(model_data, batch_size: int, rank_estimate, regularization): _, _, _, vec, H_analytical = model_data - # artificially make the analytical hessian low rank reg_H_analytical = H_analytical + regularization * torch.eye(H_analytical.shape[0]) - eig_val_analytical, proj_analytical = scipy.linalg.eigh(reg_H_analytical.numpy()) - eig_val_analytical, proj_analytical = torch.as_tensor(eig_val_analytical), torch.as_tensor(proj_analytical) - idx_analytical = torch.argsort(torch.abs(eig_val_analytical), descending=True) - eig_val_analytical = eig_val_analytical[idx_analytical[:rank_estimate]] - proj_analytical = proj_analytical[:, idx_analytical[:rank_estimate]] - low_rank_approx_analytical = proj_analytical @ torch.diag(eig_val_analytical) @ proj_analytical.t() - low_rank_approx = lanzcos_low_rank_hessian_approx(lambda z: reg_H_analytical @ z, reg_H_analytical.shape, rank_estimate=rank_estimate) - - D = torch.diag(low_rank_approx.eigen_vals) - proj = low_rank_approx.projections - - assert torch.allclose((proj @ D @ proj.t()) @ vec, low_rank_approx_analytical @ vec, rtol=1e-1) + approx_result = low_rank_approx.projections @ (torch.diag_embed(low_rank_approx.eigen_vals) @ + (low_rank_approx.projections.t() @ vec.t())) + assert torch.allclose(approx_result, reg_H_analytical @ vec, rtol=1e-1) From 08810671f41bd7c7c11206528450bc1ac8f61864 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 22 Jun 2023 16:35:49 +0200 Subject: [PATCH 100/436] Changes due to linting --- .../frameworks/torch_differentiable.py | 61 +++++---- src/pydvl/influence/frameworks/util.py | 92 +++++++------ tests/influence/conftest.py | 1 + tests/influence/test_influences.py | 22 ++- tests/influence/test_util.py | 129 +++++++++++------- 5 files changed, 189 insertions(+), 116 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 94d330548..aea408adc 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -14,9 +14,13 @@ from torch.autograd import Variable from torch.utils.data import DataLoader -from .util import LowRankProductRepresentation, get_hvp_function, lanzcos_low_rank_hessian_approx from ...utils import maybe_progress from .twice_differentiable import TwiceDifferentiable +from .util import ( + LowRankProductRepresentation, + get_hvp_function, + lanzcos_low_rank_hessian_approx, +) __all__ = [ "TorchTwiceDifferentiable", @@ -426,15 +430,19 @@ def hessian( ) -def solve_low_rank(model: TorchTwiceDifferentiable, training_data: DataLoader, b: torch.Tensor, *, - hessian_perturbation: float = 0.0, - rank_estimate: int = 10, - krylov_dimension: Optional[int] = None, - low_rank_representation: Optional[LowRankProductRepresentation] = None, - x0: Optional[torch.Tensor] = None, - tol: float = 1e-6, - max_iter: Optional[int] = None - ) -> torch.Tensor: +def solve_low_rank( + model: TorchTwiceDifferentiable, + training_data: DataLoader, + b: torch.Tensor, + *, + hessian_perturbation: float = 0.0, + rank_estimate: int = 10, + krylov_dimension: Optional[int] = None, + low_rank_representation: Optional[LowRankProductRepresentation] = None, + x0: Optional[torch.Tensor] = None, + tol: float = 1e-6, + max_iter: Optional[int] = None, +) -> torch.Tensor: """ Solves the linear system Hx = b, where H is the Hessian of the model's loss function and b is the given right-hand @@ -466,22 +474,25 @@ def solve_low_rank(model: TorchTwiceDifferentiable, training_data: DataLoader, b """ if low_rank_representation is None: - hessian_vector_product = get_hvp_function(model.model, model.loss, training_data) - low_rank_representation = lanzcos_low_rank_hessian_approx(hessian_vp=hessian_vector_product, - matrix_shape=(model.num_params, model.num_params), - hessian_perturbation=hessian_perturbation, - rank_estimate=rank_estimate, - x0=x0, - krylov_dimension=krylov_dimension, - tol=tol, - max_iter=max_iter, - device=model.device if hasattr(model, 'device') - else None) + hessian_vector_product = get_hvp_function( + model.model, model.loss, training_data + ) + low_rank_representation = lanzcos_low_rank_hessian_approx( + hessian_vp=hessian_vector_product, + matrix_shape=(model.num_params, model.num_params), + hessian_perturbation=hessian_perturbation, + rank_estimate=rank_estimate, + x0=x0, + krylov_dimension=krylov_dimension, + tol=tol, + max_iter=max_iter, + device=model.device if hasattr(model, "device") else None, + ) else: logger.info("Using provided low rank representation, ignoring other parameters") - result = low_rank_representation.projections @ (torch.diag_embed(1. / low_rank_representation.eigen_vals) @ - (low_rank_representation.projections.t() @ b.t())) + result = low_rank_representation.projections @ ( + torch.diag_embed(1.0 / low_rank_representation.eigen_vals) + @ (low_rank_representation.projections.t() @ b.t()) + ) return result.t() - - diff --git a/src/pydvl/influence/frameworks/util.py b/src/pydvl/influence/frameworks/util.py index 4a609c998..4ec7dd393 100644 --- a/src/pydvl/influence/frameworks/util.py +++ b/src/pydvl/influence/frameworks/util.py @@ -1,11 +1,11 @@ +import logging from dataclasses import dataclass from functools import partial, reduce -from typing import Callable, Tuple, Optional, Generator -import logging +from typing import Callable, Generator, Optional, Tuple import torch from numpy.typing import NDArray -from scipy.sparse.linalg import eigsh, LinearOperator, ArpackNoConvergence +from scipy.sparse.linalg import ArpackNoConvergence, LinearOperator, eigsh from torch.utils.data import DataLoader logger = logging.getLogger(__name__) @@ -23,11 +23,13 @@ def to_model_device(x: torch.Tensor, model: torch.nn.Module) -> torch.Tensor: return x -def hvp(model: torch.nn.Module, - loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], - x: torch.Tensor, - y: torch.Tensor, - vec: torch.Tensor) -> torch.Tensor: +def hvp( + model: torch.nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + x: torch.Tensor, + y: torch.Tensor, + vec: torch.Tensor, +) -> torch.Tensor: """ Returns H*vec where H is the Hessian of the loss with respect to the model parameters. @@ -54,9 +56,11 @@ def hvp(model: torch.nn.Module, return hessian_vec_prod -def batch_hvp_gen(model: torch.nn.Module, - loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], - data_loader: DataLoader) -> Generator[Callable[[torch.Tensor], torch.Tensor], None, None]: +def batch_hvp_gen( + model: torch.nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + data_loader: DataLoader, +) -> Generator[Callable[[torch.Tensor], torch.Tensor], None, None]: """ Generates a sequence of batch Hessian-vector product (HVP) computations for the provided model, loss function, and data loader. @@ -74,9 +78,11 @@ def batch_hvp_gen(model: torch.nn.Module, yield partial(hvp, model, loss, inputs, targets) -def avg_gradient(model: torch.nn.Module, - loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], - data_loader: DataLoader) -> torch.Tensor: +def avg_gradient( + model: torch.nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + data_loader: DataLoader, +) -> torch.Tensor: """ Returns the average gradient of the loss function with respect to the model parameters :param model: A torch.nn.Module, whose parameters are used for backpropagation. @@ -107,10 +113,12 @@ def avg_gradient(model: torch.nn.Module, return total_grad_xy / total_points -def get_hvp_function(model: torch.nn.Module, - loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], - data_loader: DataLoader, - use_hessian_avg: bool = True) -> Callable[[torch.Tensor], torch.Tensor]: +def get_hvp_function( + model: torch.nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + data_loader: DataLoader, + use_hessian_avg: bool = True, +) -> Callable[[torch.Tensor], torch.Tensor]: """ Returns a function that calculates the approximate Hessian-vector product for a given vector. If you want to compute the exact hessian, i.e. pulling all data into memory and compute a full gradient computation, use @@ -136,12 +144,14 @@ def hvp_function(vec: torch.Tensor) -> torch.Tensor: grad_vec_product = torch.dot(avg_grad, vec) hessian_vec_prod = torch.autograd.grad(grad_vec_product, params) - hessian_vec_prod = torch.cat([g.contiguous().view(-1) for g in hessian_vec_prod]) + hessian_vec_prod = torch.cat( + [g.contiguous().view(-1) for g in hessian_vec_prod] + ) return hessian_vec_prod def avg_hvp_function(vec: torch.Tensor) -> torch.Tensor: batch_hessians = map(lambda x: x(vec), batch_hvp_gen(model, loss, data_loader)) - return reduce(lambda x, y: x+y, batch_hessians) / len(data_loader) + return reduce(lambda x, y: x + y, batch_hessians) / len(data_loader) return avg_hvp_function if use_hessian_avg else hvp_function @@ -154,20 +164,22 @@ class LowRankProductRepresentation: :param eigen_vals: diagonal of D :param projections: the matrix V """ + eigen_vals: torch.Tensor projections: torch.Tensor -def lanzcos_low_rank_hessian_approx(hessian_vp: Callable[[torch.Tensor], torch.Tensor], - matrix_shape: Tuple[int, int], - hessian_perturbation: float = 0.0, - rank_estimate: int = 10, - krylov_dimension: Optional[int] = None, - x0: Optional[torch.Tensor] = None, - tol: float = 1e-6, - max_iter: Optional[int] = None, - device: Optional[torch.device] = None, - ) -> LowRankProductRepresentation: +def lanzcos_low_rank_hessian_approx( + hessian_vp: Callable[[torch.Tensor], torch.Tensor], + matrix_shape: Tuple[int, int], + hessian_perturbation: float = 0.0, + rank_estimate: int = 10, + krylov_dimension: Optional[int] = None, + x0: Optional[torch.Tensor] = None, + tol: float = 1e-6, + max_iter: Optional[int] = None, + device: Optional[torch.device] = None, +) -> LowRankProductRepresentation: """ Calculates a low-rank approximation of the Hessian matrix of the model's loss function using the implicitly restarted Lanczos algorithm, provided by scipy wrapper to ARPACK. @@ -207,14 +219,18 @@ def mv(x: NDArray) -> NDArray: tol=tol, ncv=krylov_dimension, return_eigenvectors=True, - v0=x0.cpu().numpy() if x0 is not None else None + v0=x0.cpu().numpy() if x0 is not None else None, ) except ArpackNoConvergence as e: - logger.warning(f"ARPACK did not converge for parameters {max_iter=}, {tol=}, {krylov_dimension=}, " - f"{rank_estimate=}. \n Returning the best approximation found so far. Use those with care or " - f"modify parameters.\n Original error: {e}") - return LowRankProductRepresentation(torch.from_numpy(e.eigenvalues), torch.from_numpy(e.eigenvectors)) - - return LowRankProductRepresentation(torch.from_numpy(eigen_vals), torch.from_numpy(eigen_vecs)) - + logger.warning( + f"ARPACK did not converge for parameters {max_iter=}, {tol=}, {krylov_dimension=}, " + f"{rank_estimate=}. \n Returning the best approximation found so far. Use those with care or " + f"modify parameters.\n Original error: {e}" + ) + return LowRankProductRepresentation( + torch.from_numpy(e.eigenvalues), torch.from_numpy(e.eigenvectors) + ) + return LowRankProductRepresentation( + torch.from_numpy(eigen_vals), torch.from_numpy(eigen_vecs) + ) diff --git a/tests/influence/conftest.py b/tests/influence/conftest.py index 130e95476..fe753d155 100644 --- a/tests/influence/conftest.py +++ b/tests/influence/conftest.py @@ -58,6 +58,7 @@ def linear_torch_model_from_numpy(A: NDArray, b: NDArray) -> torch.nn.Module: model.bias.data = torch.as_tensor(b) return model + def linear_derivative_analytical( linear_model: Tuple[NDArray[np.float_], NDArray[np.float_]], x: NDArray[np.float_], diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index fae5abe9b..169b2d874 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -18,11 +18,12 @@ linear_analytical_influence_factors, linear_derivative_analytical, linear_mixed_second_derivative_analytical, - linear_model + linear_model, ) torch.set_default_dtype(torch.float64) + def analytical_linear_influences( linear_model: Tuple[NDArray[np.float_], NDArray[np.float_]], x: NDArray[np.float_], @@ -94,7 +95,11 @@ def analytical_linear_influences( [InversionMethod.Direct, {}, 1e-7], [InversionMethod.Cg, {}, 1e-1], [InversionMethod.Lissa, {"maxiter": 6000, "scale": 100}, 0.3], - [InversionMethod.LowRank, {"rank_estimate": 83, "hessian_regularization": 0.01}, 0.4] + [ + InversionMethod.LowRank, + {"rank_estimate": 83, "hessian_regularization": 0.01}, + 0.4, + ], ], ids=[inv.value for inv in InversionMethod], ) @@ -242,7 +247,9 @@ def test_influences_nn( x_test = torch.rand((test_data_len, *input_dim)) y_test = torch.rand((test_data_len, output_dim)) - num_parameters = sum(p.numel() for p in nn_architecture.parameters() if p.requires_grad) + num_parameters = sum( + p.numel() for p in nn_architecture.parameters() if p.requires_grad + ) inversion_method_kwargs = { "direct": {}, @@ -251,7 +258,10 @@ def test_influences_nn( "maxiter": 100, "scale": 10000, }, - "low_rank": {"rank_estimate": num_parameters - 1, "hessian_regularization": 0.01} + "low_rank": { + "rank_estimate": num_parameters - 1, + "hessian_regularization": 0.01, + }, } train_data_loader = DataLoader( TensorDataset(x_train, y_train), batch_size=batch_size @@ -266,7 +276,9 @@ def test_influences_nn( for inversion_method in InversionMethod: - hessian_reg = inversion_method_kwargs[inversion_method].pop("hessian_regularization", hessian_reg) + hessian_reg = inversion_method_kwargs[inversion_method].pop( + "hessian_regularization", hessian_reg + ) influences = compute_influences( TorchTwiceDifferentiable(nn_architecture, loss), diff --git a/tests/influence/test_util.py b/tests/influence/test_util.py index a411e9270..8a0596a5e 100644 --- a/tests/influence/test_util.py +++ b/tests/influence/test_util.py @@ -1,15 +1,22 @@ -from dataclasses import dataclass, astuple +from dataclasses import astuple, dataclass from typing import Tuple -import pytest import numpy as np +import pytest import scipy import torch - from torch.utils.data import DataLoader, TensorDataset -from pydvl.influence.frameworks.util import get_hvp_function, lanzcos_low_rank_hessian_approx, hvp -from tests.influence.conftest import linear_model, linear_hessian_analytical, linear_torch_model_from_numpy +from pydvl.influence.frameworks.util import ( + get_hvp_function, + hvp, + lanzcos_low_rank_hessian_approx, +) +from tests.influence.conftest import ( + linear_hessian_analytical, + linear_model, + linear_torch_model_from_numpy, +) @dataclass @@ -24,6 +31,7 @@ class UtilTestParameters: """ Helper class to add more test parameter combinations """ + model_params: ModelParams batch_size: int rank_estimate: int @@ -31,26 +39,36 @@ class UtilTestParameters: test_parameters = [ - UtilTestParameters(ModelParams(dimension=(30, 16), condition_number=4, train_size=60), - batch_size=4, - rank_estimate=200, - regularization=0.0001), - UtilTestParameters(ModelParams(dimension=(32, 35), condition_number=1e6, train_size=100), - batch_size=5, - rank_estimate=70, - regularization=0.001), - UtilTestParameters(ModelParams(dimension=(25, 15), condition_number=1e3, train_size=90), - batch_size=10, - rank_estimate=50, - regularization=0.0001), - UtilTestParameters(ModelParams(dimension=(30, 15), condition_number=1e4, train_size=120), - batch_size=8, - rank_estimate=160, - regularization=0.00001), - UtilTestParameters(ModelParams(dimension=(40, 13), condition_number=1e5, train_size=900), - batch_size=4, - rank_estimate=250, - regularization=0.00001), + UtilTestParameters( + ModelParams(dimension=(30, 16), condition_number=4, train_size=60), + batch_size=4, + rank_estimate=200, + regularization=0.0001, + ), + UtilTestParameters( + ModelParams(dimension=(32, 35), condition_number=1e6, train_size=100), + batch_size=5, + rank_estimate=70, + regularization=0.001, + ), + UtilTestParameters( + ModelParams(dimension=(25, 15), condition_number=1e3, train_size=90), + batch_size=10, + rank_estimate=50, + regularization=0.0001, + ), + UtilTestParameters( + ModelParams(dimension=(30, 15), condition_number=1e4, train_size=120), + batch_size=8, + rank_estimate=160, + regularization=0.00001, + ), + UtilTestParameters( + ModelParams(dimension=(40, 13), condition_number=1e5, train_size=900), + batch_size=4, + rank_estimate=250, + regularization=0.00001, + ), ] @@ -62,7 +80,7 @@ def model_data(request): y = np.random.uniform(size=[train_size, dimension[0]]) torch_model = linear_torch_model_from_numpy(A, b) num_params = sum(p.numel() for p in torch_model.parameters() if p.requires_grad) - vec = np.random.uniform(size=(num_params, )) + vec = np.random.uniform(size=(num_params,)) H_analytical = linear_hessian_analytical((A, b), x) x = torch.as_tensor(x) y = torch.as_tensor(y) @@ -71,37 +89,52 @@ def model_data(request): return torch_model, x, y, vec, H_analytical -@pytest.mark.parametrize("model_data, tol", - [(astuple(tp.model_params), 1e-12) for tp in test_parameters], - indirect=["model_data"]) +@pytest.mark.parametrize( + "model_data, tol", + [(astuple(tp.model_params), 1e-12) for tp in test_parameters], + indirect=["model_data"], +) def test_hvp(model_data, tol: float): torch_model, x, y, vec, H_analytical = model_data Hvp_autograd = hvp(torch_model, torch.nn.functional.mse_loss, x, y, vec) - assert torch.allclose(Hvp_autograd, H_analytical@vec, rtol=tol) + assert torch.allclose(Hvp_autograd, H_analytical @ vec, rtol=tol) -@pytest.mark.parametrize("use_avg, tol", [(True, 1e-3), (False, 1e-6)], ids=["avg", "full"]) -@pytest.mark.parametrize("model_data, batch_size", - [(astuple(tp.model_params), tp.batch_size) for tp in test_parameters], - indirect=["model_data"]) +@pytest.mark.parametrize( + "use_avg, tol", [(True, 1e-3), (False, 1e-6)], ids=["avg", "full"] +) +@pytest.mark.parametrize( + "model_data, batch_size", + [(astuple(tp.model_params), tp.batch_size) for tp in test_parameters], + indirect=["model_data"], +) def test_get_hvp_function(model_data, tol: float, use_avg: bool, batch_size: int): torch_model, x, y, vec, H_analytical = model_data data_loader = DataLoader(TensorDataset(x, y), batch_size=batch_size) - Hvp_autograd = get_hvp_function(torch_model, torch.nn.functional.mse_loss, data_loader, - use_hessian_avg=use_avg)(vec) - assert torch.allclose(Hvp_autograd, H_analytical@vec, rtol=tol) - - -@pytest.mark.parametrize("model_data, batch_size, rank_estimate, regularization", - [astuple(tp) for tp in test_parameters], - indirect=["model_data"]) -def test_lanzcos_low_rank_hessian_approx(model_data, batch_size: int, rank_estimate, regularization): + Hvp_autograd = get_hvp_function( + torch_model, torch.nn.functional.mse_loss, data_loader, use_hessian_avg=use_avg + )(vec) + assert torch.allclose(Hvp_autograd, H_analytical @ vec, rtol=tol) + + +@pytest.mark.parametrize( + "model_data, batch_size, rank_estimate, regularization", + [astuple(tp) for tp in test_parameters], + indirect=["model_data"], +) +def test_lanzcos_low_rank_hessian_approx( + model_data, batch_size: int, rank_estimate, regularization +): _, _, _, vec, H_analytical = model_data reg_H_analytical = H_analytical + regularization * torch.eye(H_analytical.shape[0]) - low_rank_approx = lanzcos_low_rank_hessian_approx(lambda z: reg_H_analytical @ z, - reg_H_analytical.shape, - rank_estimate=rank_estimate) - approx_result = low_rank_approx.projections @ (torch.diag_embed(low_rank_approx.eigen_vals) @ - (low_rank_approx.projections.t() @ vec.t())) + low_rank_approx = lanzcos_low_rank_hessian_approx( + lambda z: reg_H_analytical @ z, + reg_H_analytical.shape, + rank_estimate=rank_estimate, + ) + approx_result = low_rank_approx.projections @ ( + torch.diag_embed(low_rank_approx.eigen_vals) + @ (low_rank_approx.projections.t() @ vec.t()) + ) assert torch.allclose(approx_result, reg_H_analytical @ vec, rtol=1e-1) From 41468c9be1688e9b4d030135f83d512edfad0993 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 22 Jun 2023 18:52:46 +0200 Subject: [PATCH 101/436] Apply suggestions from code review Co-authored-by: Anes Benmerzoug --- src/pydvl/influence/conjugate_gradient.py | 1 + .../influence/frameworks/torch_differentiable.py | 3 +++ src/pydvl/influence/general.py | 3 +++ src/pydvl/influence/linear.py | 1 + src/pydvl/influence/model_wrappers/torch_wrappers.py | 12 ++++++++++-- 5 files changed, 18 insertions(+), 2 deletions(-) diff --git a/src/pydvl/influence/conjugate_gradient.py b/src/pydvl/influence/conjugate_gradient.py index 00c71fd94..1d2c44372 100644 --- a/src/pydvl/influence/conjugate_gradient.py +++ b/src/pydvl/influence/conjugate_gradient.py @@ -186,6 +186,7 @@ def conjugate_gradient_condition_number_based_error_bound( Error bound for conjugate gradient based on the condition number of the weight matrix A. Used for testing purposes. See also https://math.stackexchange.com/questions/382958/error-for-conjugate-gradient-method. Explicit of the weight matrix is required. + Args: A: Weight matrix of the matrix to be inverted. n: Maximum number for executed iterations X in conjugate gradient. x0: Initialization solution x0 of conjugate gradient. diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 8519fa1c5..92fc5152e 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -44,6 +44,7 @@ def __init__( loss: Callable[["torch.Tensor", "torch.Tensor"], "torch.Tensor"], ): """ + Args: model: A torch.nn.Module representing a (differentiable) function f(x). loss: Loss function L(f(x), y) maps a prediction and a target to a single value. """ @@ -111,6 +112,7 @@ def grad( ) -> Tuple["NDArray", "torch.Tensor"]: """ Calculates gradient of model parameters wrt x and y. + Args: x: A np.ndarray [NxD] representing the features x_i. y: A np.ndarray [NxK] representing the predicted target values y_i. progress: True, iff progress shall be printed. @@ -143,6 +145,7 @@ def mvp( This second order derivative can be on the model parameters or on another input parameter, selected via the backprop_on argument. + Args: grad_xy: an array [P] holding the gradients of the model parameters wrt input x and labels y, \ where P is the number of parameters of the model. It is typically obtained through self.grad. v: A np.ndarray [DxP] or a one dimensional np.array [D] which multiplies the Hessian, \ diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 077fe9332..ca1f32723 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -62,6 +62,7 @@ def calculate_influence_factors( """ Calculates the influence factors. For more info, see https://arxiv.org/pdf/1703.04730.pdf, paragraph 3. + Args: model: A model which has to implement the TwiceDifferentiable interface. x_train: A np.ndarray of shape [MxK] containing the features of the input data points. y_train: A np.ndarray of shape [MxL] containing the targets of the input data points. @@ -94,6 +95,7 @@ def _calculate_influences_up( Calculates the influence from the influence factors and the scores of the training points. Uses the upweighting method, as described in section 2.1 of https://arxiv.org/pdf/1703.04730.pdf + Args: model: A model which has to implement the TwiceDifferentiable interface. x_train: A np.ndarray of shape [MxK] containing the features of the input data points. y_train: A np.ndarray of shape [MxL] containing the targets of the input data points. @@ -118,6 +120,7 @@ def _calculate_influences_pert( Calculates the influence from the influence factors and the scores of the training points. Uses the perturbation method, as described in section 2.2 of https://arxiv.org/pdf/1703.04730.pdf + Args: model: A model which has to implement the TwiceDifferentiable interface. x_train: A np.ndarray of shape [MxK] containing the features of the input data points. y_train: A np.ndarray of shape [MxL] containing the targets of the input data points. diff --git a/src/pydvl/influence/linear.py b/src/pydvl/influence/linear.py index 20816903c..9010e4061 100644 --- a/src/pydvl/influence/linear.py +++ b/src/pydvl/influence/linear.py @@ -31,6 +31,7 @@ def compute_linear_influences( validation set for an ordinary least squares model ($y = A x + b$ with quadratic loss). + Args: x: An array of shape (M, K) containing the features of training data. y: An array of shape (M, L) containing the targets of training data. x_test: An array of shape (N, K) containing the features of the diff --git a/src/pydvl/influence/model_wrappers/torch_wrappers.py b/src/pydvl/influence/model_wrappers/torch_wrappers.py index ceb631b26..f4b773c98 100644 --- a/src/pydvl/influence/model_wrappers/torch_wrappers.py +++ b/src/pydvl/influence/model_wrappers/torch_wrappers.py @@ -105,6 +105,7 @@ def fit( def predict(self, x: torch.Tensor) -> "NDArray[np.float_]": """ Use internal model to deliver prediction in numpy. + Args: x: A np.ndarray [NxD] representing the features x_i. Returns: @@ -120,6 +121,7 @@ def score( ) -> float: """ Use internal model to measure how good is prediction through a loss function. + Args: x: A np.ndarray [NxD] representing the features x_i. y: A np.ndarray [NxK] representing the predicted target values y_i. @@ -176,8 +178,10 @@ def __init__( def forward(self, x: torch.Tensor) -> torch.Tensor: """ Calculate A @ x + b using RAM-optimized calculation layout. + Args: x: Tensor [NxD] representing the features x_i. - :returns A tensor [NxK] representing the outputs y_i. + Returns: + A tensor [NxK] representing the outputs y_i. """ return x @ self.A.T + self.b @@ -193,8 +197,9 @@ def __init__( init: Tuple["NDArray[np.float_]", "NDArray[np.float_]"] = None, ): """ + Args: n_input: Number of feature inputs to the BinaryLogisticRegressionModel. - :param init A tuple representing the initialization for the weight matrix A and the bias b. If set to None + init: A tuple representing the initialization for the weight matrix A and the bias b. If set to None sample the values uniformly using the Xavier rule. """ super().__init__() @@ -210,6 +215,7 @@ def __init__( def forward(self, x: Union["NDArray[np.float_]", torch.Tensor]) -> torch.Tensor: """ Calculate sigmoid(dot(a, x) + b) using RAM-optimized calculation layout. + Args: x: Tensor [NxD] representing the features x_i. Returns: @@ -234,6 +240,7 @@ def __init__( init: List[Tuple["NDArray[np.float_]", "NDArray[np.float_]"]] = None, ): """ + Args: n_input: Number of feature in input. n_output: Output length. n_neurons_per_layer: Each integer represents the size of a hidden layer. Overall this list has K - 2 @@ -280,6 +287,7 @@ def __init__( def forward(self, x: torch.Tensor) -> torch.Tensor: """ Perform forward-pass through the network. + Args: x: Tensor input of shape [NxD]. Returns: From 3f9fbb35dd6c7fdefa05fa686ac612354a827a4b Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 22 Jun 2023 18:53:55 +0200 Subject: [PATCH 102/436] Suggestion Co-authored-by: Anes Benmerzoug --- src/pydvl/influence/conjugate_gradient.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/pydvl/influence/conjugate_gradient.py b/src/pydvl/influence/conjugate_gradient.py index 1d2c44372..7c3bf6a63 100644 --- a/src/pydvl/influence/conjugate_gradient.py +++ b/src/pydvl/influence/conjugate_gradient.py @@ -27,6 +27,7 @@ def conjugate_gradient( Given a matrix and a batch of vectors, it uses conjugate gradient to calculate the solution to Ax = y for each y in batch_y. + Args: A: a real, symmetric and positive-definite matrix of shape [NxN] batch_y: a matrix of shape [NxP], with P the size of the batch. progress: True, iff progress shall be printed. From b7b3fd032722077e56e536e7216150216c446faf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Fri, 23 Jun 2023 15:06:02 +0200 Subject: [PATCH 103/436] Add first version of low rank approximation on GPU --- src/pydvl/influence/frameworks/util.py | 85 +++++++++++++++++++------- 1 file changed, 63 insertions(+), 22 deletions(-) diff --git a/src/pydvl/influence/frameworks/util.py b/src/pydvl/influence/frameworks/util.py index 4ec7dd393..cb967ab52 100644 --- a/src/pydvl/influence/frameworks/util.py +++ b/src/pydvl/influence/frameworks/util.py @@ -5,7 +5,6 @@ import torch from numpy.typing import NDArray -from scipy.sparse.linalg import ArpackNoConvergence, LinearOperator, eigsh from torch.utils.data import DataLoader logger = logging.getLogger(__name__) @@ -179,10 +178,11 @@ def lanzcos_low_rank_hessian_approx( tol: float = 1e-6, max_iter: Optional[int] = None, device: Optional[torch.device] = None, + eigen_computation_on_gpu: bool = True, ) -> LowRankProductRepresentation: """ Calculates a low-rank approximation of the Hessian matrix of the model's loss function using the implicitly - restarted Lanczos algorithm, provided by scipy wrapper to ARPACK. + restarted Lanczos algorithm. :param hessian_vp: A function that takes a vector and returns the product of the Hessian of the loss function @@ -199,38 +199,79 @@ def lanzcos_low_rank_hessian_approx( in the approximated eigenvalue is less than `tol`. Defaults to 1e-6. :param max_iter: The maximum number of iterations for the Lanczos method. If not provided, it defaults to $10*model.num_parameters$ - :param device: The device to use for the hessian vector product. + :param device: The device to use for executing the hessian vector product. + :param eigen_computation_on_gpu: If True, tries to execute the eigen pair approximation on the provided + device via cupy implementation. + Make sure, that either your model is small enough or you use a + small rank_estimate to fit your device's memory. + If False, the eigen pair approximation is executed on the CPU by scipy wrapper to + ARPACK. :return: A `LowRankProductRepresentation` instance that contains the top (up until rank_estimate) eigenvalues and corresponding eigenvectors of the Hessian. """ - def mv(x: NDArray) -> NDArray: - x = torch.from_numpy(x) - if device is not None: - x = x.to(device) - y = hessian_vp(x) + hessian_perturbation * x - return y.cpu().numpy() + if eigen_computation_on_gpu: + try: + import cupy as cp + from cupyx.scipy.sparse.linalg import LinearOperator, eigsh + from torch.utils.dlpack import from_dlpack, to_dlpack + except ImportError as e: + raise ImportError( + f"Try to install missing dependencies or set eigen_computation_on_gpu to False: {e}" + ) + + if device is None: + raise ValueError( + "Without setting an explicit device, cupy is not supported" + ) + + def mv_cupy(x): + x = from_dlpack(x.toDlpack()) + y = hessian_vp(x) + hessian_perturbation * x + return cp.from_dlpack(to_dlpack(y)) - try: eigen_vals, eigen_vecs = eigsh( - A=LinearOperator(matrix_shape, matvec=mv), + LinearOperator(matrix_shape, matvec=mv_cupy), k=rank_estimate, maxiter=max_iter, tol=tol, ncv=krylov_dimension, return_eigenvectors=True, - v0=x0.cpu().numpy() if x0 is not None else None, - ) - except ArpackNoConvergence as e: - logger.warning( - f"ARPACK did not converge for parameters {max_iter=}, {tol=}, {krylov_dimension=}, " - f"{rank_estimate=}. \n Returning the best approximation found so far. Use those with care or " - f"modify parameters.\n Original error: {e}" ) return LowRankProductRepresentation( - torch.from_numpy(e.eigenvalues), torch.from_numpy(e.eigenvectors) + from_dlpack(eigen_vals.toDlpack()), from_dlpack(eigen_vecs.toDlpack()) ) - return LowRankProductRepresentation( - torch.from_numpy(eigen_vals), torch.from_numpy(eigen_vecs) - ) + else: + from scipy.sparse.linalg import ArpackNoConvergence, LinearOperator, eigsh + + def mv_scipy(x: NDArray) -> NDArray: + x = torch.from_numpy(x) + if device is not None: + x = x.to(device) + y = hessian_vp(x) + hessian_perturbation * x + return y.cpu().numpy() + + try: + eigen_vals, eigen_vecs = eigsh( + A=LinearOperator(matrix_shape, matvec=mv_scipy), + k=rank_estimate, + maxiter=max_iter, + tol=tol, + ncv=krylov_dimension, + return_eigenvectors=True, + v0=x0.cpu().numpy() if x0 is not None else None, + ) + except ArpackNoConvergence as e: + logger.warning( + f"ARPACK did not converge for parameters {max_iter=}, {tol=}, {krylov_dimension=}, " + f"{rank_estimate=}. \n Returning the best approximation found so far. Use those with care or " + f"modify parameters.\n Original error: {e}" + ) + return LowRankProductRepresentation( + torch.from_numpy(e.eigenvalues), torch.from_numpy(e.eigenvectors) + ) + + return LowRankProductRepresentation( + torch.from_numpy(eigen_vals), torch.from_numpy(eigen_vecs) + ) From b6d0699f80645cfefcfebd725cb8476c5541ba13 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Mon, 26 Jun 2023 09:32:32 +0200 Subject: [PATCH 104/436] Add test for exception raise on ImportError, when cupy is not available --- src/pydvl/influence/frameworks/util.py | 2 +- tests/influence/test_util.py | 10 ++++++++++ 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/src/pydvl/influence/frameworks/util.py b/src/pydvl/influence/frameworks/util.py index cb967ab52..0ecd44a5d 100644 --- a/src/pydvl/influence/frameworks/util.py +++ b/src/pydvl/influence/frameworks/util.py @@ -178,7 +178,7 @@ def lanzcos_low_rank_hessian_approx( tol: float = 1e-6, max_iter: Optional[int] = None, device: Optional[torch.device] = None, - eigen_computation_on_gpu: bool = True, + eigen_computation_on_gpu: bool = False, ) -> LowRankProductRepresentation: """ Calculates a low-rank approximation of the Hessian matrix of the model's loss function using the implicitly diff --git a/tests/influence/test_util.py b/tests/influence/test_util.py index 8a0596a5e..5f8dbacf1 100644 --- a/tests/influence/test_util.py +++ b/tests/influence/test_util.py @@ -138,3 +138,13 @@ def test_lanzcos_low_rank_hessian_approx( @ (low_rank_approx.projections.t() @ vec.t()) ) assert torch.allclose(approx_result, reg_H_analytical @ vec, rtol=1e-1) + + +def test_lanzcos_low_rank_hessian_approx_exception(): + """ + In case cuda is not available, and cupy is not installed, the call should raise an import exception + """ + with pytest.raises(ImportError): + lanzcos_low_rank_hessian_approx( + lambda x: x, (3, 3), eigen_computation_on_gpu=True + ) From 597ad77a751a2ab31053bf901faa434dd6c66b07 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Mon, 26 Jun 2023 11:20:24 +0200 Subject: [PATCH 105/436] Fix type checking and linting issues --- src/pydvl/influence/frameworks/util.py | 23 +++++++++++++++-------- src/pydvl/influence/inversion.py | 2 +- 2 files changed, 16 insertions(+), 9 deletions(-) diff --git a/src/pydvl/influence/frameworks/util.py b/src/pydvl/influence/frameworks/util.py index 0ecd44a5d..6eef8ae6b 100644 --- a/src/pydvl/influence/frameworks/util.py +++ b/src/pydvl/influence/frameworks/util.py @@ -1,7 +1,7 @@ import logging from dataclasses import dataclass from functools import partial, reduce -from typing import Callable, Generator, Optional, Tuple +from typing import Callable, Generator, Iterable, Optional, Tuple import torch from numpy.typing import NDArray @@ -85,8 +85,8 @@ def avg_gradient( """ Returns the average gradient of the loss function with respect to the model parameters :param model: A torch.nn.Module, whose parameters are used for backpropagation. - :param loss: A loss function, which is a callable that takes the model's - output and target as input and returns a scalar loss. + :param loss: A loss function, which is a callable that takes the model's output and target as input + and returns a scalar loss. :param data_loader: an instance of :class:`torch.utils.data.DataLoader` :return: average of batch gradients """ @@ -109,6 +109,9 @@ def avg_gradient( total_grad_xy += flat_grads * num_points_in_batch total_points += num_points_in_batch + if total_grad_xy is None: + raise ValueError("DataLoader is empty") + return total_grad_xy / total_points @@ -149,7 +152,9 @@ def hvp_function(vec: torch.Tensor) -> torch.Tensor: return hessian_vec_prod def avg_hvp_function(vec: torch.Tensor) -> torch.Tensor: - batch_hessians = map(lambda x: x(vec), batch_hvp_gen(model, loss, data_loader)) + batch_hessians: Iterable[torch.Tensor] = map( + lambda x: x(vec), batch_hvp_gen(model, loss, data_loader) + ) return reduce(lambda x, y: x + y, batch_hessians) / len(data_loader) return avg_hvp_function if use_hessian_avg else hvp_function @@ -246,11 +251,13 @@ def mv_cupy(x): from scipy.sparse.linalg import ArpackNoConvergence, LinearOperator, eigsh def mv_scipy(x: NDArray) -> NDArray: - x = torch.from_numpy(x) + x_torch = torch.from_numpy(x) if device is not None: - x = x.to(device) - y = hessian_vp(x) + hessian_perturbation * x - return y.cpu().numpy() + x_torch = x_torch.to(device) + y: NDArray = ( + (hessian_vp(x_torch) + hessian_perturbation * x_torch).cpu().numpy() + ) + return y try: eigen_vals, eigen_vecs = eigsh( diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 7182c1400..b647ceb99 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -92,7 +92,7 @@ def solve_hvp( ) elif inversion_method == InversionMethod.LowRank: return solve_low_rank( - model, + model, # type: ignore # TODO the interface TwiceDifferentiable is not used properly anyhow training_data, b, **kwargs, From 68e63fc6f1afe3c8ff32056715e5b66c7866b0a4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Mon, 26 Jun 2023 12:01:24 +0200 Subject: [PATCH 106/436] [skip ci] Add misiing decorators to mark tests, which need torch --- tests/influence/test_util.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tests/influence/test_util.py b/tests/influence/test_util.py index 5f8dbacf1..3e39558d0 100644 --- a/tests/influence/test_util.py +++ b/tests/influence/test_util.py @@ -89,6 +89,7 @@ def model_data(request): return torch_model, x, y, vec, H_analytical +@pytest.mark.torch @pytest.mark.parametrize( "model_data, tol", [(astuple(tp.model_params), 1e-12) for tp in test_parameters], @@ -100,6 +101,7 @@ def test_hvp(model_data, tol: float): assert torch.allclose(Hvp_autograd, H_analytical @ vec, rtol=tol) +@pytest.mark.torch @pytest.mark.parametrize( "use_avg, tol", [(True, 1e-3), (False, 1e-6)], ids=["avg", "full"] ) @@ -117,6 +119,7 @@ def test_get_hvp_function(model_data, tol: float, use_avg: bool, batch_size: int assert torch.allclose(Hvp_autograd, H_analytical @ vec, rtol=tol) +@pytest.mark.torch @pytest.mark.parametrize( "model_data, batch_size, rank_estimate, regularization", [astuple(tp) for tp in test_parameters], @@ -140,6 +143,7 @@ def test_lanzcos_low_rank_hessian_approx( assert torch.allclose(approx_result, reg_H_analytical @ vec, rtol=1e-1) +@pytest.mark.torch def test_lanzcos_low_rank_hessian_approx_exception(): """ In case cuda is not available, and cupy is not installed, the call should raise an import exception From 7c8f8445153eecdd2c22a13f76da78a9b2d4871c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Mon, 26 Jun 2023 16:44:29 +0200 Subject: [PATCH 107/436] [skip ci] Fix type checking and linting issues --- src/pydvl/utils/parallel/backend.py | 2 +- src/pydvl/utils/utility.py | 4 +++- src/pydvl/value/least_core/common.py | 2 +- src/pydvl/value/least_core/montecarlo.py | 3 ++- src/pydvl/value/least_core/naive.py | 3 ++- src/pydvl/value/loo/naive.py | 3 ++- src/pydvl/value/result.py | 20 +++++++++++--------- src/pydvl/value/shapley/gt.py | 4 +++- src/pydvl/value/shapley/knn.py | 3 ++- src/pydvl/value/shapley/naive.py | 4 +++- 10 files changed, 30 insertions(+), 18 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index f9840d77d..43d64b62d 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -233,7 +233,7 @@ def available_cpus() -> int: if system() != "Linux": return os.cpu_count() or 1 - return len(os.sched_getaffinity(0)) + return len(os.sched_getaffinity(0)) # type: ignore def effective_n_jobs(n_jobs: int, config: ParallelConfig = ParallelConfig()) -> int: diff --git a/src/pydvl/utils/utility.py b/src/pydvl/utils/utility.py index 5763edeea..834a1b820 100644 --- a/src/pydvl/utils/utility.py +++ b/src/pydvl/utils/utility.py @@ -286,7 +286,9 @@ def __init__( self._utility_samples: Dict[FrozenSet, Tuple[NDArray[np.bool_], float]] = {} def _convert_indices_to_boolean_vector(self, x: Iterable[int]) -> NDArray[np.bool_]: - boolean_vector = np.zeros((1, len(self.utility.data)), dtype=bool) + boolean_vector: NDArray[np.bool_] = np.zeros( + (1, len(self.utility.data)), dtype=bool + ) if x is not None: boolean_vector[:, tuple(x)] = True return boolean_vector diff --git a/src/pydvl/value/least_core/common.py b/src/pydvl/value/least_core/common.py index 74d2922d4..a72a05d7b 100644 --- a/src/pydvl/value/least_core/common.py +++ b/src/pydvl/value/least_core/common.py @@ -95,7 +95,7 @@ def lc_solve_problem( # because given the equality constraint # it is the same as using the constraint e >= 0 # (i.e. setting non_negative_subsidy = True). - mask = np.ones_like(b_lb, dtype=bool) + mask: NDArray[np.bool_] = np.ones_like(b_lb, dtype=bool) mask[total_utility_indices] = False b_lb = b_lb[mask] A_lb = A_lb[mask] diff --git a/src/pydvl/value/least_core/montecarlo.py b/src/pydvl/value/least_core/montecarlo.py index ddb9f2347..73222925c 100644 --- a/src/pydvl/value/least_core/montecarlo.py +++ b/src/pydvl/value/least_core/montecarlo.py @@ -3,6 +3,7 @@ from typing import Iterable, Optional import numpy as np +from numpy.typing import NDArray from pydvl.utils.config import ParallelConfig from pydvl.utils.numeric import random_powerset @@ -156,7 +157,7 @@ def _montecarlo_least_core( for i, subset in enumerate( maybe_progress(power_set, progress, total=n_iterations, position=job_id) ): - indices = np.zeros(n, dtype=bool) + indices: NDArray[np.bool_] = np.zeros(n, dtype=bool) indices[list(subset)] = True A_lb[i, indices] = 1 utility_values[i] = u(subset) diff --git a/src/pydvl/value/least_core/naive.py b/src/pydvl/value/least_core/naive.py index fdcbb97ed..a33f88173 100644 --- a/src/pydvl/value/least_core/naive.py +++ b/src/pydvl/value/least_core/naive.py @@ -3,6 +3,7 @@ from typing import Optional import numpy as np +from numpy.typing import NDArray from pydvl.utils import Utility, maybe_progress, powerset from pydvl.value.least_core.common import LeastCoreProblem, lc_solve_problem @@ -103,7 +104,7 @@ def lc_prepare_problem(u: Utility, progress: bool = False) -> LeastCoreProblem: powerset(u.data.indices), progress, total=powerset_size - 1, position=0 ) ): - indices = np.zeros(n, dtype=bool) + indices: NDArray[np.bool_] = np.zeros(n, dtype=bool) indices[list(subset)] = True A_lb[i, indices] = 1 utility_values[i] = u(subset) diff --git a/src/pydvl/value/loo/naive.py b/src/pydvl/value/loo/naive.py index 1b7a1eecd..c990bf6a3 100644 --- a/src/pydvl/value/loo/naive.py +++ b/src/pydvl/value/loo/naive.py @@ -1,4 +1,5 @@ import numpy as np +from numpy.typing import NDArray from pydvl.utils import Utility, maybe_progress from pydvl.utils.status import Status @@ -20,7 +21,7 @@ def naive_loo(u: Utility, *, progress: bool = True) -> ValuationResult: if len(u.data) < 3: raise ValueError("Dataset must have at least 2 elements") - values = np.zeros_like(u.data.indices, dtype=np.float_) + values: NDArray[np.float_] = np.zeros_like(u.data.indices, dtype=np.float_) all_indices = set(u.data.indices) total_utility = u(u.data.indices) for i in maybe_progress(u.data.indices, progress): # type: ignore diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index 0c7ae7fe4..12e8929fd 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -258,7 +258,9 @@ def __init__( self._indices = indices self._positions = {idx: pos for pos, idx in enumerate(indices)} - self._sort_positions = np.arange(len(self._values), dtype=np.int_) + self._sort_positions: NDArray[np.int_] = np.arange( + len(self._values), dtype=np.int_ + ) if sort: self.sort() @@ -510,12 +512,12 @@ def __add__(self, other: "ValuationResult") -> "ValuationResult": this_pos = np.searchsorted(indices, self._indices) other_pos = np.searchsorted(indices, other._indices) - n = np.zeros_like(indices, dtype=int) - m = np.zeros_like(indices, dtype=int) - xn = np.zeros_like(indices, dtype=float) - xm = np.zeros_like(indices, dtype=float) - vn = np.zeros_like(indices, dtype=float) - vm = np.zeros_like(indices, dtype=float) + n: NDArray[np.int_] = np.zeros_like(indices, dtype=int) + m: NDArray[np.int_] = np.zeros_like(indices, dtype=int) + xn: NDArray[np.int_] = np.zeros_like(indices, dtype=float) + xm: NDArray[np.int_] = np.zeros_like(indices, dtype=float) + vn: NDArray[np.int_] = np.zeros_like(indices, dtype=float) + vm: NDArray[np.int_] = np.zeros_like(indices, dtype=float) n[this_pos] = self._counts xn[this_pos] = self._values @@ -553,8 +555,8 @@ def __add__(self, other: "ValuationResult") -> "ValuationResult": f"{other._names.dtype} to {self._names.dtype}" ) - this_names = np.empty_like(indices, dtype=object) - other_names = np.empty_like(indices, dtype=object) + this_names: NDArray = np.empty_like(indices, dtype=object) + other_names: NDArray = np.empty_like(indices, dtype=object) this_names[this_pos] = self._names other_names[other_pos] = other._names both = np.where(this_pos == other_pos) diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index b4b093637..cc14da315 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -131,7 +131,9 @@ def _group_testing_shapley( n = len(u.data.indices) const = _constants(n, 1, 1, 1) # don't care about eps,delta,range - betas = np.zeros(shape=(n_samples, n), dtype=np.int_) # indicator vars + betas: NDArray[np.int_] = np.zeros( + shape=(n_samples, n), dtype=np.int_ + ) # indicator vars uu = np.empty(n_samples) # utilities for t in maybe_progress(n_samples, progress=progress, position=job_id): diff --git a/src/pydvl/value/shapley/knn.py b/src/pydvl/value/shapley/knn.py index 22bb857fb..b67cd11de 100644 --- a/src/pydvl/value/shapley/knn.py +++ b/src/pydvl/value/shapley/knn.py @@ -8,6 +8,7 @@ from typing import Dict, Union import numpy as np +from numpy.typing import NDArray from sklearn.neighbors import KNeighborsClassifier, NearestNeighbors from pydvl.utils import Utility, maybe_progress @@ -57,7 +58,7 @@ def knn_shapley(u: Utility, *, progress: bool = True) -> ValuationResult: # closest to farthest _, indices = nns.kneighbors(u.data.x_test) - values = np.zeros_like(u.data.indices, dtype=np.float_) + values: NDArray[np.float_] = np.zeros_like(u.data.indices, dtype=np.float_) n = len(u.data) yt = u.data.y_train iterator = enumerate(zip(u.data.y_test, indices), start=1) diff --git a/src/pydvl/value/shapley/naive.py b/src/pydvl/value/shapley/naive.py index d903ff80b..8e22f5ab2 100644 --- a/src/pydvl/value/shapley/naive.py +++ b/src/pydvl/value/shapley/naive.py @@ -69,7 +69,9 @@ def _combinatorial_exact_shapley( n = len(u.data) local_values = np.zeros(n) for i in indices: - subset = np.setxor1d(u.data.indices, [i], assume_unique=True).astype(np.int_) + subset: NDArray[np.int_] = np.setxor1d( + u.data.indices, [i], assume_unique=True + ).astype(np.int_) for s in maybe_progress( powerset(subset), progress, From 17c65a4ab15d9afceb48fafbc3b29bac65a37173 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Mon, 26 Jun 2023 18:06:11 +0200 Subject: [PATCH 108/436] [skip ci] Fix wrong reference to Appendix in notebook --- notebooks/influence_imagenet.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks/influence_imagenet.ipynb b/notebooks/influence_imagenet.ipynb index 0abff86b8..f141fda71 100644 --- a/notebooks/influence_imagenet.ipynb +++ b/notebooks/influence_imagenet.ipynb @@ -343,7 +343,7 @@ "\n", "Let's now calculate influences! The main method is `:func:~pydvl.influence.general.compute_influences`, which takes a trained `nn.Model`, the training loss, some input dataset with labels (which typically is the training data, or a subset of it) and some test data.\n", "\n", - "Other important parameters are the Hessian regularization term, which should be chosen as small as possible for the computation to converge (further details on why this is important can be found in the [Appendix](#appendix)).\n", + "Other important parameters are the Hessian regularization term, which should be chosen as small as possible for the computation to converge (further details on why this is important can be found in the [Appendix](#theory-of-influence-functions-for-neural-networks)).\n", "\n", "Since Resnet18 is quite big, we pick conjugate gradient (`cg`) as the method for inversion of the Hessian. A naive computation would require a lot of memory. Finally, the influence type will be `up`. The other option, `perturbation`, is beyond the scope of this notebook, but more info can be found in the notebook [using the Wine dataset](influence_wine.ipynb) or in the documentation for pyDVL.\n", "\n", From ea8774e1790f641a71ef04ddebab3111b6162fd3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Mon, 26 Jun 2023 18:06:47 +0200 Subject: [PATCH 109/436] Pin scipy version below the current (1.11.0) as it breaks the docs build --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index e6c31a00b..0eb69024b 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,7 +2,7 @@ pyDeprecate>=0.3.2 numpy>=1.20 pandas>=1.3 scikit-learn -scipy>=1.7.0 +scipy>=1.7.0,<1.11.0 cvxpy>=1.3.0 ray>=0.8 joblib From 4482a24f1b4d2d08a1f408ba6af75c4bf15430e9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Tue, 27 Jun 2023 11:59:32 +0200 Subject: [PATCH 110/436] [skip ci] Move util function from conftest to test_util.py, in order to remove dependency of conftest on torch --- tests/influence/conftest.py | 16 ---------------- tests/influence/test_util.py | 26 ++++++++++++++++++++------ 2 files changed, 20 insertions(+), 22 deletions(-) diff --git a/tests/influence/conftest.py b/tests/influence/conftest.py index fe753d155..ce13e9b32 100644 --- a/tests/influence/conftest.py +++ b/tests/influence/conftest.py @@ -2,7 +2,6 @@ import numpy as np import pytest -import torch.nn from numpy.typing import NDArray from sklearn.preprocessing import MinMaxScaler @@ -44,21 +43,6 @@ def linear_model(problem_dimension: Tuple[int, int], condition_number: float): return A, b -def linear_torch_model_from_numpy(A: NDArray, b: NDArray) -> torch.nn.Module: - """ - Given numpy arrays representing the model $xA^t + b$, the function returns the corresponding torch model - :param A: - :param b: - :return: - """ - output_dimension, input_dimension = tuple(A.shape) - model = torch.nn.Linear(input_dimension, output_dimension) - model.eval() - model.weight.data = torch.as_tensor(A) - model.bias.data = torch.as_tensor(b) - return model - - def linear_derivative_analytical( linear_model: Tuple[NDArray[np.float_], NDArray[np.float_]], x: NDArray[np.float_], diff --git a/tests/influence/test_util.py b/tests/influence/test_util.py index 3e39558d0..392757322 100644 --- a/tests/influence/test_util.py +++ b/tests/influence/test_util.py @@ -3,8 +3,11 @@ import numpy as np import pytest -import scipy + +torch = pytest.importorskip("torch") import torch +import torch.nn +from numpy.typing import NDArray from torch.utils.data import DataLoader, TensorDataset from pydvl.influence.frameworks.util import ( @@ -12,11 +15,7 @@ hvp, lanzcos_low_rank_hessian_approx, ) -from tests.influence.conftest import ( - linear_hessian_analytical, - linear_model, - linear_torch_model_from_numpy, -) +from tests.influence.conftest import linear_hessian_analytical, linear_model @dataclass @@ -72,6 +71,21 @@ class UtilTestParameters: ] +def linear_torch_model_from_numpy(A: NDArray, b: NDArray) -> torch.nn.Module: + """ + Given numpy arrays representing the model $xA^t + b$, the function returns the corresponding torch model + :param A: + :param b: + :return: + """ + output_dimension, input_dimension = tuple(A.shape) + model = torch.nn.Linear(input_dimension, output_dimension) + model.eval() + model.weight.data = torch.as_tensor(A) + model.bias.data = torch.as_tensor(b) + return model + + @pytest.fixture def model_data(request): dimension, condition_number, train_size = request.param From 5f3e1c30475f73a35b8b7aaa722d2056f3674e45 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Tue, 27 Jun 2023 12:57:13 +0200 Subject: [PATCH 111/436] [skip ci] Explicitly run tests on CPU, slightly increase LISSA max iteration number due to randomly observed situtation, where LISSA does not converge do desired error tolerance --- tests/influence/test_influences.py | 6 +++--- tests/influence/test_torch_differentiable.py | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 169b2d874..8c8299dfc 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -145,7 +145,7 @@ def test_influence_linear_model( ) influence_values = compute_influences( - TorchTwiceDifferentiable(linear_layer, loss), + TorchTwiceDifferentiable(linear_layer, loss, device=torch.device("cpu")), training_data=train_data_loader, test_data=test_data_loader, input_data=input_data, @@ -255,7 +255,7 @@ def test_influences_nn( "direct": {}, "cg": {}, "lissa": { - "maxiter": 100, + "maxiter": 150, "scale": 10000, }, "low_rank": { @@ -281,7 +281,7 @@ def test_influences_nn( ) influences = compute_influences( - TorchTwiceDifferentiable(nn_architecture, loss), + TorchTwiceDifferentiable(nn_architecture, loss, device=torch.device("cpu")), training_data=train_data_loader, test_data=test_data_loader, progress=True, diff --git a/tests/influence/test_torch_differentiable.py b/tests/influence/test_torch_differentiable.py index 3c952ddab..96c5ba309 100644 --- a/tests/influence/test_torch_differentiable.py +++ b/tests/influence/test_torch_differentiable.py @@ -48,7 +48,7 @@ def linear_mvp_model(A, b): model.weight.data = torch.as_tensor(A) model.bias.data = torch.as_tensor(b) loss = F.mse_loss - return TorchTwiceDifferentiable(model=model, loss=loss) + return TorchTwiceDifferentiable(model=model, loss=loss, device=torch.device("cpu")) @pytest.mark.torch From 5a28716ce86378bfede15b155f52ed163e39977c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Tue, 27 Jun 2023 13:01:01 +0200 Subject: [PATCH 112/436] [skip ci] Explicitly reference tests directory in tox base and torch environment, in order to not invoke tests from other directories like /notebooks --- tox.ini | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tox.ini b/tox.ini index 3433fe113..9e1d9c2bb 100644 --- a/tox.ini +++ b/tox.ini @@ -17,12 +17,12 @@ setenv = [testenv:base] description = Tests base modules commands = - pytest --cov "{envsitepackagesdir}/pydvl" -m "not torch" {posargs} + pytest tests/ --cov "{envsitepackagesdir}/pydvl" -m "not torch" {posargs} [testenv:torch] description = Tests modules that rely on pytorch commands = - pytest --cov "{envsitepackagesdir}/pydvl" -m torch {posargs} + pytest tests/ --cov "{envsitepackagesdir}/pydvl" -m torch {posargs} extras = influence From 436728f96ca95ea5375b72029c2df08e766ef475 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 27 Jun 2023 17:29:08 +0200 Subject: [PATCH 113/436] WIP influence documentation --- docs/40-influence.rst | 203 +++++++++++++++++++++++------ docs/pydvl.bib | 11 ++ notebooks/influence_imagenet.ipynb | 82 +----------- 3 files changed, 177 insertions(+), 119 deletions(-) diff --git a/docs/40-influence.rst b/docs/40-influence.rst index d1a43017a..e16137bac 100644 --- a/docs/40-influence.rst +++ b/docs/40-influence.rst @@ -17,47 +17,172 @@ Computing influence values - Add example for `TwiceDifferentiable` - Improve uninformative examples -There are two ways to compute influences. For linear regression, the influences -can be computed analytically. For more general models or loss functions, one can -implement the :class:`TwiceDifferentiable` protocol, which provides the required -methods for computing the influences. - -pyDVL supports two ways of computing the empirical influence function, namely -up-weighting of samples and perturbation influences. The choice is done by a -parameter in the call to the main entry points, -:func:`~pydvl.influence.linear.compute_linear_influences` and -:func:`~pydvl.influence.compute_influences`. - -Influence for OLS ------------------ -.. warning:: - - This will be deprecated. It makes no sense to have a separate interface for - linear models. - -Because the Hessian of the least squares loss for a regression problem can be -computed analytically, we provide -:func:`~pydvl.influence.linear.compute_linear_influences` as a convenience -function to work with these models. - -.. code-block:: python - - >>> from pydvl.influence.linear import compute_linear_influences - >>> compute_linear_influences( - ... x_train, - ... y_train, - ... x_test, - ... y_test - ... ) - - -This method calculates the influence function for each sample in x_train for a -least squares regression problem. - +pyDVL holds several methods for the efficient computation of influence functions +(IF) for neural networks. Before delving into the details of the code, we will +give an overview of the mathematical theory. + +Theory of Influence Functions for Neural Networks +------------------------------------------------- + +First introduced in the context of robust statistics, *Hampel, Frank R. [The +influence curve and its role in robust estimation], 1974* +(:footcite:t:`hampel1974influence`), influence functions have been popularized +in the machine learning context with the work *Koh, Pang Wei, and Percy Liang. +["Understanding Black-box Predictions via Influence Functions"], 2017.* +(:footcite:t:`koh_understanding_2017`). Informally, their objective is to +quantify the effect (influence) that each training point has on each test point +of a neural network. In order to do so, it is necessary to rely on a first order +approximation that computes influence scores for pre-trained models. + +Following the formulation of the *Koh, +Liang*(:footcite:t:`koh_understanding_2017`) paper, let's start by considering +some input space $\mathcal{X}$ to a model (e.g. images) and an output space +$\mathcal{Y}$ (e.g. labels). Let's take $z_i = (x_i, y_i)$ to be the $i$-th +training point, and $\theta$ to be the (potentially highly) multi-dimensional +parameters of the neural network (i.e. $\theta$ is a big array with all each +neurons' weights, including biases, batch normalizations and/or dropout rates). +We will indicate with $L(z, \theta)$ the loss of the model for point $z$ when +parameters are $\theta$. + +Upon training the model, we typically minimize the loss over all points, i.e. +the optimal parameters are calculated through gradient descent on the following +formula: $$ \hat{\theta} = \arg \min_\theta \frac{1}{n}\sum_{i=1}^n L(z_i, +\theta) $$ where $n$ is the total number of training data points. In practice, +instead of taking the argmin of the loss the training is stopped when the +validation loss stops decreasing, so full convergence is not achieved. + +For notational convenience, let's define + $$ +\hat{\theta}_{-z} = \arg \min_\theta \frac{1}{n}\sum_{z_i \ne z} L(z_i, \theta) +\ , $$ i.e. $\hat{\theta}_{-z}$ are the model parameters that minimize the total +loss when $z$ is not in the training dataset. + +In order to check the impact of each training point on the model, we would need +to calculate $\hat{\theta}_{-z}$ for each $z$ in the training dataset, thus +re-training the model at least ~$n$ times (more if model training is +stochastic). This is computationally very expensive, especially for big neural +networks. To circumvent this problem, we can just calculate a first order +approximation of $\hat{\theta}$. This can be done through single backpropagation +and without re-training the full model. + +Approximating the influence of a point +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Let's define $$ \hat{\theta}_{\epsilon, z} = \arg \min_\theta +\frac{1}{n}\sum_{i=1}^n L(z_i, \theta) + \epsilon L(z, \theta) \ , $$ which is +the optimal $\hat{\theta}$ if we were to up-weigh $z$ by an amount $\epsilon$. + +From a classical result (a simple derivation is available in Appendix A of [Koh +and Liang's paper](:footcite:t:`koh_understanding_2017`)), we know that: $$ +\frac{d \ \hat{\theta}_{\epsilon, z}}{d \epsilon} \Big|_{\epsilon=0} = +-H_{\hat{\theta}}^{-1} \nabla_\theta L(z, \hat{\theta}) $$ where +$H_{\hat{\theta}} = \frac{1}{n} \sum_{i=1}^n \nabla_\theta^2 L(z_i, +\hat{\theta})$ is the Hessian of $L$. Importantly, notice that this expression +is only valid when $\hat{\theta}$ is a minimum of $L$, or otherwise +$H_{\hat{\theta}}$ cannot be inverted! At the same time, in machine learning +full convergence is rarely achieved, so direct Hessian inversion is not +possible. Approximations need to be developed that circumvent the problem of +inverting the Hessian of the model in all those (frequent) cases where it is not +positive definite. + +We will define the influence of training point $z$ on test point +$z_{\text{test}}$ as + +$$\mathcal{I}(z, z_{\text{test}}) = L(z_{\text{test}}, \hat{\theta}_{-z}) - +L(z_{\text{test}}, \hat{\theta}) .$$ Notice that $\mathcal{I}$ is higher for +points $z$ which positively impact the model score, since the loss is higher +when they are excluded from training. In practice, one needs to rely on the +following infinitesimal approximation: + +$$ + \mathcal{I}_{up}(z, z_{\text{test}}) = - \frac{d L(z_{\text{test}}, + \hat{\theta}_{\epsilon, z})}{d \epsilon} \Big|_{\epsilon=0} +$$ + +Using the chain rule and the results calculated above, we thus have: + +$$ + \mathcal{I}_{up}(z, z_{\text{test}}) = - \nabla_\theta L(z_{\text{test}}, + \hat{\theta})^\top \ \frac{d \hat{\theta}_{\epsilon, z}}{d \epsilon} + \Big|_{\epsilon=0} = \nabla_\theta L(z_{\text{test}}, \hat{\theta})^\top \ + H_{\hat{\theta}}^{-1} \ \nabla_\theta L(z, \hat{\theta}) +$$ + +All the factors in this expression are gradients of the loss wrt. the model +parameters $\hat{\theta}$. This can be easily done through one or more +backpropagation passes. + +Perturbation definition of the influence score +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +How would the loss of the model change if, instead of up-weighing an individual point $z$, we were to up-weigh +only a single feature of that point? Given $z = (x, y)$, we can define +$z_{\delta} = (x+\delta, y)$, where $\delta$ is a vector of zeros except for a 1 +in the position of the feature we want to up-weigh. In order to approximate the +effect of modifying a single feature of a single point on the model score we can +define +$$ +\hat{\theta}_{\epsilon, z_{\delta} ,-z} = \arg \min_\theta +\frac{1}{n}\sum_{i=1}^n L(z_i, \theta) + \epsilon L(z_{\delta}, \theta) \ - \epsilon L(z, \theta), +$$ +Similarly to what done in paragraph ???, we up-weigh point $z_{\delta}$, but +then we also remove the up-weighing for all the features that are not modified +by $\delta$. From the calculations in ???, it is then easy to see that +$$ +\frac{d \ \hat{\theta}_{\epsilon, z_{\delta} ,-z}}{d \epsilon} \Big|_{\epsilon=0} += -H_{\hat{\theta}}^{-1} \nabla_\theta \Big( L(z_\delta, \hat{\theta}) - L(z, \hat{\theta}) \Big) +$$ +and if the feature space is continuous and as $\delta \to 0$ we can write +$$ +\frac{d \ \hat{\theta}_{\epsilon, z_{\delta} ,-z}}{d \epsilon} \Big|_{\epsilon=0} += -H_{\hat{\theta}}^{-1} \ \nabla_x \nabla_\theta L(z, \hat{\theta}) \delta + \mathcal{o}(\delta) +$$ +The influence of each feature of $z$ on the loss of the model can therefore be +estimated through the following quantity: +$$ +\mathcal{I}_{pert}(z, z_{\text{test}}) = - \lim_{\delta \to 0} \ \frac{1}{\delta} \frac{d L(z_{\text{test}}, + \hat{\theta}_{\epsilon, \ z_{\delta}, \ -z})}{d \epsilon} \Big|_{\epsilon=0} +$$ +which, using the chain rule and the results calculated above, is equal to +$$ +\mathcal{I}_{pert}(z, z_{\text{test}}) = - \nabla_\theta L(z_{\text{test}}, + \hat{\theta})^\top \ \frac{d \hat{\theta}_{\epsilon, z_{\delta} ,-z}}{d \epsilon} + \Big|_{\epsilon=0} = \nabla_\theta L(z_{\text{test}}, \hat{\theta})^\top \ + H_{\hat{\theta}}^{-1} \ \nabla_x \nabla_\theta L(z, \hat{\theta}) +$$ +The perturbation definition of the influence score is not straightforward to +understand, but it has a simple interpretation: it tells how much the loss of +the model changes when a certain feature of point z is up-weighted. A positive +perturbation influence score indicates that the feature might have a positive +effect on the accuracy of the model. It is worth noting that this is just a very +rough estimate and it is subject to large approximation errors. It can +nonetheless be used to build train-set attacks, as done in the [original +paper](:footcite:t:`koh_understanding_2017`). + + +Inverting the Hessian: direct and approximate methods +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +As discussed in :ref:`theory of influence functions for neural networks`, in +machine learning training rarely converges to a global minimum of the loss. +Despite good apparent convergence, $\hat{\theta}$ might be located in a region +with flat curvature or close to a saddle point. In particular, the Hessian might +have vanishing eigenvalues making its direct inversion impossible. + +To circumvent this problem, many approximate methods are available. The simplest +adds a small *hessian perturbation term*, i.e. we invert +$H_{\hat{\theta}} + \lambda \mathbb{I}$, with $\mathbb{I}$ being the identity +matrix. This standard trick ensures that the eigenvalues of $H_{\hat{\theta}}$ +are bounded away from zero and therefore the matrix is invertible. In order for +this regularization not to corrupt the outcome too much, the parameter $\lambda$ +should be as small as possible while still allowing a reliable inversion of +$H_{\hat{\theta}} + \lambda \mathbb{I}$. Exact influences using the `TwiceDifferentiable` protocol --------------------------------------------------------- +The main entry point of the library is +:func:`~pydvl.influence.compute_influences` + More generally, influences can be computed for any model which implements the :class:`TwiceDifferentiable` protocol, i.e. which is capable of calculating second derivative matrix vector products and gradients of the loss evaluated on @@ -100,8 +225,8 @@ inverting the full matrix. In pyDVL this can be done with the parameter Perturbation influences ----------------------- -As mentioned, the method of empirical influence computation can be selected -in :func:`~pydvl.influence.compute_influences` with `influence_type`: +As mentioned, the method of empirical influence computation can be selected in +:func:`~pydvl.influence.compute_influences` with `influence_type`: .. code-block:: python diff --git a/docs/pydvl.bib b/docs/pydvl.bib index 69af8af14..45b6a8911 100644 --- a/docs/pydvl.bib +++ b/docs/pydvl.bib @@ -35,6 +35,17 @@ @inproceedings{ghorbani_data_2019 keywords = {notion} } +@article{hampel1974influence, + title={The influence curve and its role in robust estimation}, + author={Hampel, Frank R}, + journal={Journal of the american statistical association}, + volume={69}, + number={346}, + pages={383--393}, + year={1974}, + publisher={Taylor \& Francis} +} + @inproceedings{jia_efficient_2019, title = {Towards {{Efficient Data Valuation Based}} on the {{Shapley Value}}}, booktitle = {Proceedings of the 22nd {{International Conference}} on {{Artificial Intelligence}} and {{Statistics}}}, diff --git a/notebooks/influence_imagenet.ipynb b/notebooks/influence_imagenet.ipynb index 0abff86b8..8b391be6a 100644 --- a/notebooks/influence_imagenet.ipynb +++ b/notebooks/influence_imagenet.ipynb @@ -15,7 +15,8 @@ "\n", "However, in the [final part of the notebook](#detecting-corrupted-data) we will see that influence functions are an effective tool for finding anomalous or corrupted data points.\n", "\n", - "We conclude with an [appendix](#theory-of-influence-functions-for-neural-networks) with some basic theoretical concepts used." + "More information, including the basic theoretical concepts of influence\n", + "functions for neural networks, are available in [the main pydvl documentation](../40-influence.rst)." ] }, { @@ -988,85 +989,6 @@ "\n", "Nevertheless, influence functions offer a relatively quick and mathematically rigorous way to evaluate (at first order) the importance of a training point for a model's prediction." ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Theory of influence functions for neural networks\n", - "\n", - "In this appendix we will briefly go through the basic ideas of influence functions adapted for neural networks as introduced in *Koh, Pang Wei, and Percy Liang. [\"Understanding Black-box Predictions via Influence Functions\"](https://arxiv.org/pdf/1703.04730.pdf) International conference on machine learning. PMLR, 2017.*\n", - "\n", - "Note however that this paper departs from the standard and established theory and notation for influence functions. For a rigorous introduction to the topic we recommend classical texts like *Hampel, Frank R., Elvezio M. Ronchetti, Peter J. Rousseeuw, and Werner A. Stahel. Robust Statistics: The Approach Based on Influence Functions. 1st edition. Wiley Series in Probability and Statistics. New York: Wiley-Interscience, 2005. https://doi.org/10.1002/9781118186435.*" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Upweighting points\n", - "\n", - "Let's start by considering some input space $\\mathcal{X}$ to a model (e.g. images) and an output space $\\mathcal{Y}$ (e.g. labels). Let's take $z_i = (x_i, y_i)$ to be the $i$-th training point, and $\\theta$ to be the (potentially highly) multi-dimensional parameters of the neural network (i.e. $\\theta$ is a big array with very many parameters). We will indicate with $L(z, \\theta)$ the loss of the model for point $z$ and parameters $\\theta$. When training the model we minimize the loss over all points, i.e. the optimal parameters are calculated through gradient descent on the following formula:\n", - "$$\n", - "\\hat{\\theta} = \\arg \\min_\\theta \\frac{1}{n}\\sum_{i=1}^n L(z_i, \\theta)\n", - "$$\n", - "where $n$ is the total number of training data points.\n", - "\n", - "For notational convenience, let's define\n", - " $$\n", - "\\hat{\\theta}_{-z} = \\arg \\min_\\theta \\frac{1}{n}\\sum_{z_i \\ne z} L(z_i, \\theta) \\ ,\n", - "$$\n", - "i.e. $\\hat{\\theta}_{-z}$ are the model parameters that minimize the total loss when $z$ is not in the training dataset.\n", - "\n", - "In order to check the impact of each training point on the model, we would need to calculate $\\hat{\\theta}_{-z}$ for each $z$ in the training dataset, thus re-training the model at least ~$n$ times (more if model training is noisy). This is computationally very expensive, especially for big neural networks. To circumvent this problem, we can just calculate a first order approximation of $\\hat{\\theta}$. This can be done through single backpropagation and without re-training the full model.\n", - "\n", - "Let's define\n", - "$$\n", - "\\hat{\\theta}_{\\epsilon, z} = \\arg \\min_\\theta \\frac{1}{n}\\sum_{i=1}^n L(z_i, \\theta) + \\epsilon L(z, \\theta) \\ ,\n", - "$$\n", - "which is the optimal $\\hat{\\theta}$ if we were to up-weigh $z$ by an amount $\\epsilon$.\n", - "\n", - "From a classical result (a simple derivation is available in Appendix A of Koh and Liang's paper), we know that:\n", - "$$\n", - "\\frac{d \\ \\hat{\\theta}_{\\epsilon, z}}{d \\epsilon} \\Big|_{\\epsilon=0} = -H_{\\hat{\\theta}}^{-1} \\nabla_\\theta L(z, \\hat{\\theta})\n", - "$$\n", - "where $H_{\\hat{\\theta}} = \\frac{1}{n} \\sum_{i=1}^n \\nabla_\\theta^2 L(z_i, \\hat{\\theta})$ is the Hessian of $L$. Importantly, notice that this expression is only valid when $\\hat{\\theta}$ is a minimum of $L$, or otherwise $H_{\\hat{\\theta}}$ cannot be inverted!" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Approximating the influence of a point\n", - "\n", - "We will define the influence of training point $z$ on test point $z_{\\text{test}}$ as $\\mathcal{I}(z, z_{\\text{test}}) = L(z_{\\text{test}}, \\hat{\\theta}_{-z}) - L(z_{\\text{test}}, \\hat{\\theta})$ (notice that it is higher for points $z$ which positively impact the model score, since if they are excluded, the loss is higher). In practice, however, we will always use the infinitesimal approximation $\\mathcal{I}_{up}(z, z_{\\text{test}})$, defined as\n", - "$$\n", - " \\mathcal{I}_{up}(z, z_{\\text{test}}) = - \\frac{d L(z_{\\text{test}}, \\hat{\\theta}_{\\epsilon, z})}{d \\epsilon} \\Big|_{\\epsilon=0}\n", - "$$\n", - "\n", - "Using the chain rule and the results calculated above, we thus have:\n", - "\n", - "$$\n", - " \\mathcal{I}_{up}(z, z_{\\text{test}}) = - \\nabla_\\theta L(z_{\\text{test}}, \\hat{\\theta})^\\top \\ \\frac{d \\hat{\\theta}_{\\epsilon, z}}{d \\epsilon} \\Big|_{\\epsilon=0} = \\nabla_\\theta L(z_{\\text{test}}, \\hat{\\theta})^\\top \\ H_{\\hat{\\theta}}^{-1} \\ \\nabla_\\theta L(z, \\hat{\\theta})\n", - "$$\n", - "\n", - "In order to calculate this expression we need the gradient and the Hessian of the loss wrt. the model parameters $\\hat{\\theta}$. This can be easily done through a single backpropagation pass." - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Regularizing the Hessian\n", - "\n", - "One very important assumption that we make when approximating influence is that $\\hat{\\theta}$ is at least a local minimum of the loss. However, we clearly cannot guarantee this except for convex models, and despite good apparent convergence, $\\hat{\\theta}$ might be located in a region with flat curvature or close to a saddle point. In particular, the Hessian might have vanishing eigenvalues making its direct inversion impossible.\n", - "\n", - "To circumvent this problem, instead of inverting the true Hessian $H_{\\hat{\\theta}}$, one can invert a small perturbation thereof: $H_{\\hat{\\theta}} + \\lambda \\mathbb{I}$, with $\\mathbb{I}$ being the identity matrix. This standard trick ensures that the eigenvalues of $H_{\\hat{\\theta}}$ are bounded away from zero and therefore the matrix is invertible. In order for this regularization not to corrupt the outcome too much, the parameter $\\lambda$ should be as small as possible while still allowing a reliable inversion of $H_{\\hat{\\theta}} + \\lambda \\mathbb{I}$.\n" - ] } ], "metadata": { From 1fcdc794944698299c427ed67fe8e91a48281371 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Tue, 27 Jun 2023 20:28:20 +0200 Subject: [PATCH 114/436] Fix bug, due to pandas to_csv not automatically creating directories --- src/pydvl/utils/dataset.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index d3c6eadf7..232af83fa 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -16,8 +16,8 @@ object. """ - import logging +import os from collections import OrderedDict from pathlib import Path from typing import Any, Callable, Iterable, List, Optional, Sequence, Tuple, Union @@ -597,13 +597,15 @@ def load_spotify_dataset( :param random_state: fixes sklearn random seed :return: Tuple with 3 elements, each being a list sith [input_data, related_labels] """ - root_dir_path = Path(__file__).parent.parent.parent.parent - file_path = root_dir_path / "data/top_hits_spotify_dataset.csv" + root_dir_path = Path(__file__).parent.parent.parent.parent / "data" + file_path = root_dir_path / "top_hits_spotify_dataset.csv" if file_path.exists(): data = pd.read_csv(file_path) else: url = "https://raw.githubusercontent.com/appliedAI-Initiative/pyDVL/develop/data/top_hits_spotify_dataset.csv" data = pd.read_csv(url) + if not os.path.exists(root_dir_path): + os.makedirs(root_dir_path) data.to_csv(file_path, index=False) data = data[data["year"] > min_year] From e356ef5774b40d1e801ae99a945a6d8019b2c400 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Tue, 27 Jun 2023 20:35:25 +0200 Subject: [PATCH 115/436] Add new method to CHANGELOG --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7e51b51c5..010bfdab1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,8 @@ - Major changes to IF interface and functionality [PR #278](https://github.com/appliedAI-Initiative/pyDVL/pull/278) +- **New Method**: Implements solving the hessian equation via spectral low-rank approximation + [PR #365](https://github.com/appliedAI-Initiative/pyDVL/pull/365) ## 0.6.1 - 🏗 Bug fixes and small improvement From a9455bbe3e55258d0139c08329f43ba31d99649f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Tue, 27 Jun 2023 20:37:28 +0200 Subject: [PATCH 116/436] Set PYTHONPATH for tox notebooks environment, add torchvision to tox notebooks environemnt dependendencies --- tox.ini | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tox.ini b/tox.ini index 9e1d9c2bb..65406e6f9 100644 --- a/tox.ini +++ b/tox.ini @@ -28,6 +28,8 @@ extras = [testenv:notebooks] description = Tests notebooks +setenv = + PYTHONPATH={toxinidir}/notebooks commands = pytest notebooks/ --cov "{envsitepackagesdir}/pydvl" deps = @@ -35,6 +37,7 @@ deps = jupyter==1.0.0 nbconvert==6.4.5 datasets==2.6.1 + torchvision==0.14.1 extras = influence passenv = From 64f9a300fa863ac026c9ea193bda2d827b970f56 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Tue, 27 Jun 2023 21:15:09 +0200 Subject: [PATCH 117/436] Revert "Pin scipy version below the current (1.11.0) as it breaks the docs build" This reverts commit ea8774e1790f641a71ef04ddebab3111b6162fd3. --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 0eb69024b..e6c31a00b 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,7 +2,7 @@ pyDeprecate>=0.3.2 numpy>=1.20 pandas>=1.3 scikit-learn -scipy>=1.7.0,<1.11.0 +scipy>=1.7.0 cvxpy>=1.3.0 ray>=0.8 joblib From 83b02f151e84862b0a80bdf1a81a1a0166c45fe1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Tue, 27 Jun 2023 21:16:02 +0200 Subject: [PATCH 118/436] Pin numpy version below 1.25, as the latest release breaks a test --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index e6c31a00b..5e3e53a00 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ pyDeprecate>=0.3.2 -numpy>=1.20 +numpy>=1.20,<1.25 pandas>=1.3 scikit-learn scipy>=1.7.0 From 2ef6dee07e68dddd95ed97c11becb0878aca7a65 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 28 Jun 2023 12:09:38 +0200 Subject: [PATCH 119/436] Add one more test case for adding valuation results with different indices --- tests/test_results.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/tests/test_results.py b/tests/test_results.py index 50392aeaa..4ea80cf72 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -326,6 +326,18 @@ def test_adding_random(): ["a", "b", "c"], [0, 2, 3], ), + # Overlapping indices with different lengths, change order + ( + [1, 2], + ["b", "c"], + [3, 4], + [0, 1, 2], + ["a", "b", "c"], + [0, 1, 2], + [0, 1, 2], + ["a", "b", "c"], + [0, 2, 3], + ), ], ) def test_adding_different_indices( From 50ef1b7620e97998516380a56d59e3634226a046 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 28 Jun 2023 12:10:18 +0200 Subject: [PATCH 120/436] Fix adding valuation result with overlapping indices and different lengths --- src/pydvl/value/result.py | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index 0c7ae7fe4..545c9c088 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -553,18 +553,24 @@ def __add__(self, other: "ValuationResult") -> "ValuationResult": f"{other._names.dtype} to {self._names.dtype}" ) - this_names = np.empty_like(indices, dtype=object) - other_names = np.empty_like(indices, dtype=object) - this_names[this_pos] = self._names - other_names[other_pos] = other._names - both = np.where(this_pos == other_pos) + both_pos = np.intersect1d(this_pos, other_pos) + + if len(both_pos) > 0: + this_names = np.empty_like(indices, dtype=object) + other_names = np.empty_like(indices, dtype=object) + this_names[this_pos] = self._names + other_names[other_pos] = other._names + + this_shared_names = np.take(this_names, both_pos) + other_shared_names = np.take(other_names, both_pos) + + if np.any(this_shared_names != other_shared_names): + raise ValueError(f"Mismatching names in ValuationResults") + names = np.empty_like(indices, dtype=self._names.dtype) names[this_pos] = self._names names[other_pos] = other._names - if np.any(other_names[both] != this_names[both]): - raise ValueError(f"Mismatching names in ValuationResults") - return ValuationResult( algorithm=self.algorithm or other.algorithm or "", status=self.status & other.status, From 6c512f2fdced892370b490e401619a1ceebcd284 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 28 Jun 2023 12:12:47 +0200 Subject: [PATCH 121/436] Update changelog --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7e51b51c5..1b0f0a96b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,8 @@ ## Unreleased +- Fix adding valuation results with overlapping indices and different lengths + [PR #370](https://github.com/appliedAI-Initiative/pyDVL/pull/370) - Major changes to IF interface and functionality [PR #278](https://github.com/appliedAI-Initiative/pyDVL/pull/278) From 1c138e90d193e720513d73924109f5a9f21d6072 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 28 Jun 2023 12:39:33 +0200 Subject: [PATCH 122/436] Fix link to appendix in influence imagenet notebook --- notebooks/influence_imagenet.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/notebooks/influence_imagenet.ipynb b/notebooks/influence_imagenet.ipynb index 0abff86b8..af7af9b95 100644 --- a/notebooks/influence_imagenet.ipynb +++ b/notebooks/influence_imagenet.ipynb @@ -15,7 +15,7 @@ "\n", "However, in the [final part of the notebook](#detecting-corrupted-data) we will see that influence functions are an effective tool for finding anomalous or corrupted data points.\n", "\n", - "We conclude with an [appendix](#theory-of-influence-functions-for-neural-networks) with some basic theoretical concepts used." + "We conclude with an [appendix](#Theory-of-influence-functions-for-neural-networks) with some basic theoretical concepts used." ] }, { @@ -343,7 +343,7 @@ "\n", "Let's now calculate influences! The main method is `:func:~pydvl.influence.general.compute_influences`, which takes a trained `nn.Model`, the training loss, some input dataset with labels (which typically is the training data, or a subset of it) and some test data.\n", "\n", - "Other important parameters are the Hessian regularization term, which should be chosen as small as possible for the computation to converge (further details on why this is important can be found in the [Appendix](#appendix)).\n", + "Other important parameters are the Hessian regularization term, which should be chosen as small as possible for the computation to converge (further details on why this is important can be found in the [Appendix](#Theory-of-influence-functions-for-neural-networks)).\n", "\n", "Since Resnet18 is quite big, we pick conjugate gradient (`cg`) as the method for inversion of the Hessian. A naive computation would require a lot of memory. Finally, the influence type will be `up`. The other option, `perturbation`, is beyond the scope of this notebook, but more info can be found in the notebook [using the Wine dataset](influence_wine.ipynb) or in the documentation for pyDVL.\n", "\n", From c0ab226e8c2a6d6120e26f0b46ed0acf8d5d7a77 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Wed, 28 Jun 2023 16:11:56 +0200 Subject: [PATCH 123/436] Trigger exception raise test only when cuda is not available --- tests/influence/test_util.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/tests/influence/test_util.py b/tests/influence/test_util.py index 392757322..35dc3ef98 100644 --- a/tests/influence/test_util.py +++ b/tests/influence/test_util.py @@ -162,7 +162,8 @@ def test_lanzcos_low_rank_hessian_approx_exception(): """ In case cuda is not available, and cupy is not installed, the call should raise an import exception """ - with pytest.raises(ImportError): - lanzcos_low_rank_hessian_approx( - lambda x: x, (3, 3), eigen_computation_on_gpu=True - ) + if not torch.cuda.is_available(): + with pytest.raises(ImportError): + lanzcos_low_rank_hessian_approx( + lambda x: x, (3, 3), eigen_computation_on_gpu=True + ) From 4dba6c157eb4d5e05fd5f598f19232d7f9d1cb4d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Wed, 28 Jun 2023 16:13:42 +0200 Subject: [PATCH 124/436] Refactor tests/influence/test_influences.py: * add a test for computation via low rank approximation * extract common code from two tests --- tests/influence/test_influences.py | 234 +++++++++++++++++++++-------- 1 file changed, 175 insertions(+), 59 deletions(-) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 8c8299dfc..1cc1cab13 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -1,7 +1,8 @@ -from typing import Dict, Tuple +from typing import Callable, Dict, Tuple import numpy as np import pytest +from torch.optim import LBFGS, Adam torch = pytest.importorskip("torch") import torch @@ -225,7 +226,46 @@ def test_influence_linear_model( } +def create_random_data_loader( + input_dim: Tuple[int], + output_dim: int, + data_len: int, + batch_size: int = 1, + random_seed: int = 31, +) -> DataLoader: + """Creates DataLoader instances with random data for testing purposes. + + Args: + input_dim (Tuple[int]): The dimensions of the input data. + output_dim (int): The dimension of the output data. + data_len (int): The length of the training dataset to be generated. + batch_size (int): The size of the batches to be used in the DataLoader. + random_seed (int, optional): The seed for the random number generator. Defaults to 31. + + Returns: + DataLoader: DataLoader instances for data. + """ + torch.manual_seed(random_seed) + x = torch.rand((data_len, *input_dim)) + y = torch.rand((data_len, output_dim)) + + return DataLoader(TensorDataset(x, y), batch_size=batch_size) + + @pytest.mark.torch +@pytest.mark.parametrize( + "inversion_method,inversion_method_kwargs", + [ + ("cg", {}), + ( + "lissa", + { + "maxiter": 150, + "scale": 10000, + }, + ), + ], +) @pytest.mark.parametrize( "nn_architecture, input_dim, output_dim, loss, influence_type", test_cases.values(), @@ -237,75 +277,151 @@ def test_influences_nn( output_dim: int, loss: nn.modules.loss._Loss, influence_type: InfluenceType, + inversion_method: InversionMethod, + inversion_method_kwargs: Dict, data_len: int = 20, hessian_reg: float = 1e3, test_data_len: int = 10, batch_size: int = 10, ): - x_train = torch.rand((data_len, *input_dim)) - y_train = torch.rand((data_len, output_dim)) - x_test = torch.rand((test_data_len, *input_dim)) - y_test = torch.rand((test_data_len, output_dim)) - num_parameters = sum( - p.numel() for p in nn_architecture.parameters() if p.requires_grad + train_data_loader = create_random_data_loader( + input_dim, output_dim, data_len, batch_size, random_seed=18 ) - - inversion_method_kwargs = { - "direct": {}, - "cg": {}, - "lissa": { - "maxiter": 150, - "scale": 10000, - }, - "low_rank": { - "rank_estimate": num_parameters - 1, - "hessian_regularization": 0.01, - }, - } - train_data_loader = DataLoader( - TensorDataset(x_train, y_train), batch_size=batch_size - ) - test_data_loader = DataLoader( - TensorDataset(x_test, y_test), - batch_size=batch_size, + test_data_loader = create_random_data_loader( + input_dim, output_dim, test_data_len, batch_size, random_seed=19 ) nn_architecture.eval() - multiple_influences = {} + model = TorchTwiceDifferentiable(nn_architecture, loss, device=torch.device("cpu")) + + direct_influence = compute_influences( + model, + training_data=train_data_loader, + test_data=test_data_loader, + progress=True, + influence_type=influence_type, + inversion_method=InversionMethod.Direct, + hessian_regularization=hessian_reg, + ) + + approx_influences = compute_influences( + model, + training_data=train_data_loader, + test_data=test_data_loader, + progress=True, + influence_type=influence_type, + inversion_method=inversion_method, + hessian_regularization=hessian_reg, + **inversion_method_kwargs, + ).numpy() + assert not np.any(np.isnan(approx_influences)) - for inversion_method in InversionMethod: + assert np.allclose(approx_influences, direct_influence, rtol=1e-1) - hessian_reg = inversion_method_kwargs[inversion_method].pop( - "hessian_regularization", hessian_reg - ) + if influence_type == InfluenceType.Up: + assert approx_influences.shape == (test_data_len, data_len) + + if influence_type == InfluenceType.Perturbation: + assert approx_influences.shape == (test_data_len, data_len, *input_dim) - influences = compute_influences( - TorchTwiceDifferentiable(nn_architecture, loss, device=torch.device("cpu")), - training_data=train_data_loader, - test_data=test_data_loader, - progress=True, - influence_type=influence_type, - inversion_method=inversion_method, - hessian_regularization=hessian_reg, - **inversion_method_kwargs[inversion_method], - ).numpy() - assert not np.any(np.isnan(influences)) - multiple_influences[inversion_method] = influences - - for infl_type, influences in multiple_influences.items(): - if infl_type == "direct": - continue - if infl_type == "low_rank": - continue - assert np.allclose( - influences, - multiple_influences["direct"], - rtol=1e-1, - ), f"Failed method {infl_type}" - if influence_type == InfluenceType.Up: - assert influences.shape == (test_data_len, data_len) - elif influence_type == InfluenceType.Perturbation: - assert influences.shape == (test_data_len, data_len, *input_dim) # check that influences are not all constant - assert not np.all(influences == influences.item(0)) + assert not np.all(approx_influences == approx_influences.item(0)) + + +def minimal_training( + model: torch.nn.Module, + dataloader: DataLoader, + loss_function: torch.nn.modules.loss._Loss, + lr=0.01, + epochs=50, +): + """Trains a PyTorch model using L-BFGS optimizer. + + Args: + model (Module): The PyTorch model to be trained. + dataloader (DataLoader): DataLoader providing the training data. + loss_function (Module): The loss function to be used for training. + lr (float, optional): The learning rate for the L-BFGS optimizer. Defaults to 0.01. + epochs (int, optional): The number of training epochs. Defaults to 50. + + Returns: + Module: The trained model. + """ + model = model.train() + optimizer = LBFGS(model.parameters(), lr=lr) + + for epoch in range(epochs): + data = torch.cat([inputs for inputs, targets in dataloader]) + targets = torch.cat([targets for inputs, targets in dataloader]) + + def closure(): + optimizer.zero_grad() + outputs = model(data) + loss = loss_function(outputs, targets) + loss.backward() + return loss + + optimizer.step(closure) + + return model + + +@pytest.mark.torch +@pytest.mark.parametrize( + "nn_architecture, input_dim, output_dim, loss, influence_type", + test_cases.values(), + ids=test_cases.keys(), +) +def test_influences_nn_low_rank( + nn_architecture: nn.Module, + input_dim: Tuple[int], + output_dim: int, + loss: nn.modules.loss._Loss, + influence_type: InfluenceType, + data_len: int = 20, + hessian_reg: float = 20.0, + test_data_len: int = 10, +): + train_data_loader = create_random_data_loader( + input_dim, output_dim, data_len, random_seed=31 + ) + test_data_loader = create_random_data_loader( + input_dim, output_dim, test_data_len, random_seed=42 + ) + + nn_architecture = minimal_training( + nn_architecture, train_data_loader, loss, lr=0.3, epochs=100 + ) + nn_architecture = nn_architecture.eval() + + model = TorchTwiceDifferentiable(nn_architecture, loss, device=torch.device("cpu")) + + direct_influence = compute_influences( + model, + training_data=train_data_loader, + test_data=test_data_loader, + progress=True, + influence_type=influence_type, + inversion_method=InversionMethod.Direct, + hessian_regularization=hessian_reg, + ) + + num_parameters = sum( + p.numel() for p in nn_architecture.parameters() if p.requires_grad + ) + + low_rank_influence = compute_influences( + model, + training_data=train_data_loader, + test_data=test_data_loader, + progress=True, + influence_type=influence_type, + inversion_method=InversionMethod.LowRank, + hessian_regularization=hessian_reg, + # as the hessian of the small shallow networks is in general not low rank, so for these test cases, we choose + # the rank estimate as high as possible + rank_estimate=num_parameters - 1, + ) + + assert np.allclose(direct_influence, low_rank_influence, rtol=1e-2) From 553f3bf0974d81cc8b11048fa5d3bfa295296989 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Wed, 28 Jun 2023 16:31:38 +0200 Subject: [PATCH 125/436] Fix import issue, by moving torch import below pytest.importorskip --- tests/influence/test_influences.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 1cc1cab13..8f6d109e5 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -1,14 +1,14 @@ -from typing import Callable, Dict, Tuple +from typing import Dict, Tuple import numpy as np import pytest -from torch.optim import LBFGS, Adam torch = pytest.importorskip("torch") import torch import torch.nn.functional as F from numpy.typing import NDArray from torch import nn +from torch.optim import LBFGS from torch.utils.data import DataLoader, TensorDataset from pydvl.influence import TorchTwiceDifferentiable, compute_influences From 1125a345ff28cbec10dff78b6653b9952bbd71af Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Wed, 28 Jun 2023 16:48:17 +0200 Subject: [PATCH 126/436] Remove low rank method from linear model influence test, because low rank assumption is not valid --- tests/influence/test_influences.py | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 8f6d109e5..e53f12e6e 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -96,13 +96,8 @@ def analytical_linear_influences( [InversionMethod.Direct, {}, 1e-7], [InversionMethod.Cg, {}, 1e-1], [InversionMethod.Lissa, {"maxiter": 6000, "scale": 100}, 0.3], - [ - InversionMethod.LowRank, - {"rank_estimate": 83, "hessian_regularization": 0.01}, - 0.4, - ], ], - ids=[inv.value for inv in InversionMethod], + ids=[inv.value for inv in InversionMethod if inv is not InversionMethod.LowRank], ) def test_influence_linear_model( influence_type: InfluenceType, @@ -117,7 +112,6 @@ def test_influence_linear_model( ): torch.set_default_dtype(torch.float64) - hessian_reg = inversion_method_kwargs.pop("hessian_regularization", hessian_reg) A, b = linear_model(problem_dimension, condition_number) train_data, test_data = add_noise_to_linear_model( From 52725d583312a4c91a98de94829e3b8d3ade662b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Wed, 28 Jun 2023 17:33:09 +0200 Subject: [PATCH 127/436] Forward eigen_computation_on_gpu parameter --- src/pydvl/influence/frameworks/torch_differentiable.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index aea408adc..bbc4a4b37 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -442,6 +442,7 @@ def solve_low_rank( x0: Optional[torch.Tensor] = None, tol: float = 1e-6, max_iter: Optional[int] = None, + eigen_computation_on_gpu: bool = False, ) -> torch.Tensor: """ @@ -469,6 +470,12 @@ def solve_low_rank( If `low_rank_representation` is provided, this parameter is ignored. :param max_iter: The maximum number of iterations for the Lanczos method. If `low_rank_representation` is provided, this parameter is ignored. + :param eigen_computation_on_gpu: If True, tries to execute the eigen pair approximation on the model's + device via cupy implementation. + Make sure, that either your model is small enough or you use a + small rank_estimate to fit your device's memory. + If False, the eigen pair approximation is executed on the CPU by scipy wrapper to + ARPACK. :return: Returns the solution vector x that satisfies the system Hx = b, where H is a low-rank approximation of the Hessian of the model's loss function. """ @@ -487,6 +494,7 @@ def solve_low_rank( tol=tol, max_iter=max_iter, device=model.device if hasattr(model, "device") else None, + eigen_computation_on_gpu=eigen_computation_on_gpu, ) else: logger.info("Using provided low rank representation, ignoring other parameters") From effcad488ffa40b55b99c718855270b4483845cd Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 29 Jun 2023 09:34:53 +0200 Subject: [PATCH 128/436] Update changelog --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1b0f0a96b..49036e99d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,8 @@ - Fix adding valuation results with overlapping indices and different lengths [PR #370](https://github.com/appliedAI-Initiative/pyDVL/pull/370) +- Fixed bugs in conjugate gradient and `linear_solve` + [PR #358](https://github.com/appliedAI-Initiative/pyDVL/pull/358) - Major changes to IF interface and functionality [PR #278](https://github.com/appliedAI-Initiative/pyDVL/pull/278) From 7b90f27bae6761a220ce09b95dd1c915a5481042 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 29 Jun 2023 10:35:24 +0200 Subject: [PATCH 129/436] Improved text, fixed a bunch of sphinx nonsense --- docs/40-influence.rst | 197 ++++++++++++++++++++++++------------------ 1 file changed, 111 insertions(+), 86 deletions(-) diff --git a/docs/40-influence.rst b/docs/40-influence.rst index e16137bac..2fce6e89a 100644 --- a/docs/40-influence.rst +++ b/docs/40-influence.rst @@ -6,58 +6,61 @@ Computing influence values .. warning:: - Much of the code in the package :mod:`pydvl.influence` is experimental or - untested. Package structure and basic API are bound to change before v1.0.0 + Much of the code in the package :mod:`pydvl.influence` is experimental. + Package structure and basic API are planned to change extensively before + v1.0.0 .. todo:: This section needs rewriting: - - Introduce some theory - Explain how the methods differ - - Add example for `TwiceDifferentiable` - - Improve uninformative examples - -pyDVL holds several methods for the efficient computation of influence functions -(IF) for neural networks. Before delving into the details of the code, we will -give an overview of the mathematical theory. - -Theory of Influence Functions for Neural Networks -------------------------------------------------- - -First introduced in the context of robust statistics, *Hampel, Frank R. [The -influence curve and its role in robust estimation], 1974* -(:footcite:t:`hampel1974influence`), influence functions have been popularized -in the machine learning context with the work *Koh, Pang Wei, and Percy Liang. -["Understanding Black-box Predictions via Influence Functions"], 2017.* -(:footcite:t:`koh_understanding_2017`). Informally, their objective is to -quantify the effect (influence) that each training point has on each test point -of a neural network. In order to do so, it is necessary to rely on a first order -approximation that computes influence scores for pre-trained models. - -Following the formulation of the *Koh, -Liang*(:footcite:t:`koh_understanding_2017`) paper, let's start by considering -some input space $\mathcal{X}$ to a model (e.g. images) and an output space -$\mathcal{Y}$ (e.g. labels). Let's take $z_i = (x_i, y_i)$ to be the $i$-th + - Add example for ``TwiceDifferentiable`` + +The influence function is a method to quantify the effect (influence) that each +training point has on the parameters of a model, and by extension on any +function thereof. In particular, it is possible to estimate how much each +training sample affects the error on a test point, making the IF really useful +for understanding and debugging models. It is in a sense similar to, and +sometimes used with together with valuation functions, but have are more solid +theoretical foundation. + +pyDVL implements several methods for the efficient computation of the IF for +machine learning. + +The Influence Function +----------------------- + +First introduced in the context of robust statistics in +:footcite:t:`hampel1974influence` the IF was popularized in machine learning +with the work :footcite:t:`koh_understanding_2017`. + +Following the formulation of :footcite:t:`koh_understanding_2017`, consider an +input space $\mathcal{X}$ (e.g. images) and an output space $\mathcal{Y}$ (e.g. +labels). Let's take $z_i = (x_i, y_i)$, for $i \in \{1,...,n\}$ to be the $i$-th training point, and $\theta$ to be the (potentially highly) multi-dimensional -parameters of the neural network (i.e. $\theta$ is a big array with all each -neurons' weights, including biases, batch normalizations and/or dropout rates). +parameters of a model (e.g. $\theta$ is a big array with all of a neural network's +parameters, including biases, batch normalizations and/or dropout rates). We will indicate with $L(z, \theta)$ the loss of the model for point $z$ when -parameters are $\theta$. - -Upon training the model, we typically minimize the loss over all points, i.e. -the optimal parameters are calculated through gradient descent on the following -formula: $$ \hat{\theta} = \arg \min_\theta \frac{1}{n}\sum_{i=1}^n L(z_i, -\theta) $$ where $n$ is the total number of training data points. In practice, -instead of taking the argmin of the loss the training is stopped when the -validation loss stops decreasing, so full convergence is not achieved. - -For notational convenience, let's define - $$ -\hat{\theta}_{-z} = \arg \min_\theta \frac{1}{n}\sum_{z_i \ne z} L(z_i, \theta) -\ , $$ i.e. $\hat{\theta}_{-z}$ are the model parameters that minimize the total -loss when $z$ is not in the training dataset. - -In order to check the impact of each training point on the model, we would need +the parameters are $\theta$. + +Upon training the model, we typically minimize the loss over all $z_i$, i.e. +the optimal parameters are calculated with (stochastic) gradient descent on the +following expression: + +$$ \hat{\theta} = \arg \min_\theta \frac{1}{n}\sum_{i=1}^n L(z_i, \theta). $$ + +In practice, lack of convexity means that one doesn't really obtain the +minimizer of the loss, and the training is stopped when the validation loss +stops decreasing. + +For notational convenience, let's define + +$$ \hat{\theta}_{-z} = \arg \min_\theta \frac{1}{n}\sum_{z_i \ne z} L(z_i, \theta)\ , $$ + +i.e. $\hat{\theta}_{-z}$ are the model parameters that minimize the total loss +when $z$ is not in the training dataset. + +In order to compute the impact of each training point on the model, we would need to calculate $\hat{\theta}_{-z}$ for each $z$ in the training dataset, thus re-training the model at least ~$n$ times (more if model training is stochastic). This is computationally very expensive, especially for big neural @@ -68,15 +71,24 @@ and without re-training the full model. Approximating the influence of a point ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Let's define $$ \hat{\theta}_{\epsilon, z} = \arg \min_\theta -\frac{1}{n}\sum_{i=1}^n L(z_i, \theta) + \epsilon L(z, \theta) \ , $$ which is -the optimal $\hat{\theta}$ if we were to up-weigh $z$ by an amount $\epsilon$. +Let's define + +$$\hat{\theta}_{\epsilon, z} = \arg \min_\theta +\frac{1}{n}\sum_{i=1}^n L(z_i, \theta) + \epsilon L(z, \theta), +$$ + +which is the optimal $\hat{\theta}$ if we were to up-weigh $z$ by an amount +$\epsilon \gt 0$. + +From a classical result (a simple derivation is available in Appendix A of +:footcite:t:`koh_understanding_2017`), we know that: -From a classical result (a simple derivation is available in Appendix A of [Koh -and Liang's paper](:footcite:t:`koh_understanding_2017`)), we know that: $$ -\frac{d \ \hat{\theta}_{\epsilon, z}}{d \epsilon} \Big|_{\epsilon=0} = --H_{\hat{\theta}}^{-1} \nabla_\theta L(z, \hat{\theta}) $$ where -$H_{\hat{\theta}} = \frac{1}{n} \sum_{i=1}^n \nabla_\theta^2 L(z_i, +$$ +\frac{d \ \hat{\theta}_{\epsilon, z}}{d \epsilon} \Big|_{\epsilon=0} += -H_{\hat{\theta}}^{-1} \nabla_\theta L(z, \hat{\theta}), +$$ + +where $H_{\hat{\theta}} = \frac{1}{n} \sum_{i=1}^n \nabla_\theta^2 L(z_i, \hat{\theta})$ is the Hessian of $L$. Importantly, notice that this expression is only valid when $\hat{\theta}$ is a minimum of $L$, or otherwise $H_{\hat{\theta}}$ cannot be inverted! At the same time, in machine learning @@ -88,24 +100,27 @@ positive definite. We will define the influence of training point $z$ on test point $z_{\text{test}}$ as -$$\mathcal{I}(z, z_{\text{test}}) = L(z_{\text{test}}, \hat{\theta}_{-z}) - -L(z_{\text{test}}, \hat{\theta}) .$$ Notice that $\mathcal{I}$ is higher for -points $z$ which positively impact the model score, since the loss is higher -when they are excluded from training. In practice, one needs to rely on the -following infinitesimal approximation: +$$ +\mathcal{I}(z, z\_{\text{test}}) = L(z\_{\text{test}}, \hat{\theta}_{-z}) - +L(z\_{\text{test}}, \hat{\theta}). +$$ + +Notice that $\mathcal{I}$ is higher for points $z$ which positively impact the +model score, since the loss is higher when they are excluded from training. In +practice, one needs to rely on the following infinitesimal approximation: $$ - \mathcal{I}_{up}(z, z_{\text{test}}) = - \frac{d L(z_{\text{test}}, - \hat{\theta}_{\epsilon, z})}{d \epsilon} \Big|_{\epsilon=0} +\mathcal{I}_{up}(z, z\_{\text{test}}) = - \frac{d L(z\_{\text{test}}, +\hat{\theta}_{\epsilon, z})}{d \epsilon} \Big|_{\epsilon=0} $$ Using the chain rule and the results calculated above, we thus have: $$ - \mathcal{I}_{up}(z, z_{\text{test}}) = - \nabla_\theta L(z_{\text{test}}, - \hat{\theta})^\top \ \frac{d \hat{\theta}_{\epsilon, z}}{d \epsilon} - \Big|_{\epsilon=0} = \nabla_\theta L(z_{\text{test}}, \hat{\theta})^\top \ - H_{\hat{\theta}}^{-1} \ \nabla_\theta L(z, \hat{\theta}) +\mathcal{I}_{up}(z, z\_{\text{test}}) = - \nabla_\theta L(z\_{\text{test}}, +\hat{\theta})^\top \ \frac{d \hat{\theta}_{\epsilon, z}}{d \epsilon} +\Big|_{\epsilon=0} = \nabla_\theta L(z\_{\text{test}}, \hat{\theta})^\top \ +H_{\hat{\theta}}^{-1} \ \nabla_\theta L(z, \hat{\theta}) $$ All the factors in this expression are gradients of the loss wrt. the model @@ -114,55 +129,65 @@ backpropagation passes. Perturbation definition of the influence score ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -How would the loss of the model change if, instead of up-weighing an individual point $z$, we were to up-weigh -only a single feature of that point? Given $z = (x, y)$, we can define -$z_{\delta} = (x+\delta, y)$, where $\delta$ is a vector of zeros except for a 1 -in the position of the feature we want to up-weigh. In order to approximate the -effect of modifying a single feature of a single point on the model score we can -define +How would the loss of the model change if, instead of up-weighing an individual +point $z$, we were to up-weigh only a single feature of that point? Given $z = +(x, y)$, we can define $z_{\delta} = (x+\delta, y)$, where $\delta$ is a vector +of zeros except for a 1 in the position of the feature we want to up-weigh. In +order to approximate the effect of modifying a single feature of a single point +on the model score we can define + $$ -\hat{\theta}_{\epsilon, z_{\delta} ,-z} = \arg \min_\theta -\frac{1}{n}\sum_{i=1}^n L(z_i, \theta) + \epsilon L(z_{\delta}, \theta) \ - \epsilon L(z, \theta), +\hat{\theta}_{\epsilon, z\_{\delta} ,-z} = \arg \min_\theta +\frac{1}{n}\sum_{i=1}^n L(z\_i, \theta) + \epsilon L(z\_{\delta}, \theta) - \epsilon L(z, \theta), $$ -Similarly to what done in paragraph ???, we up-weigh point $z_{\delta}$, but + +Similarly to what was done above, we up-weigh point $z\_{\delta}$, but then we also remove the up-weighing for all the features that are not modified by $\delta$. From the calculations in ???, it is then easy to see that + $$ -\frac{d \ \hat{\theta}_{\epsilon, z_{\delta} ,-z}}{d \epsilon} \Big|_{\epsilon=0} -= -H_{\hat{\theta}}^{-1} \nabla_\theta \Big( L(z_\delta, \hat{\theta}) - L(z, \hat{\theta}) \Big) +\frac{d \ \hat{\theta}_{\epsilon, z\_{\delta} ,-z}}{d \epsilon} \Big|_{\epsilon=0} += -H_{\hat{\theta}}^{-1} \nabla_\theta \Big( L(z\_\delta, \hat{\theta}) - L(z, \hat{\theta}) \Big) $$ + and if the feature space is continuous and as $\delta \to 0$ we can write + $$ -\frac{d \ \hat{\theta}_{\epsilon, z_{\delta} ,-z}}{d \epsilon} \Big|_{\epsilon=0} +\frac{d \ \hat{\theta}_{\epsilon, z\_{\delta} ,-z}}{d \epsilon} \Big|_{\epsilon=0} = -H_{\hat{\theta}}^{-1} \ \nabla_x \nabla_\theta L(z, \hat{\theta}) \delta + \mathcal{o}(\delta) $$ + The influence of each feature of $z$ on the loss of the model can therefore be estimated through the following quantity: + $$ -\mathcal{I}_{pert}(z, z_{\text{test}}) = - \lim_{\delta \to 0} \ \frac{1}{\delta} \frac{d L(z_{\text{test}}, - \hat{\theta}_{\epsilon, \ z_{\delta}, \ -z})}{d \epsilon} \Big|_{\epsilon=0} +\mathcal{I}_{pert}(z, z\_{\text{test}}) = - \lim_{\delta \to 0} \ \frac{1}{\delta} \frac{d L(z\_{\text{test}}, +\hat{\theta}_{\epsilon, \ z\_{\delta}, \ -z})}{d \epsilon} \Big|_{\epsilon=0} $$ + which, using the chain rule and the results calculated above, is equal to + $$ -\mathcal{I}_{pert}(z, z_{\text{test}}) = - \nabla_\theta L(z_{\text{test}}, - \hat{\theta})^\top \ \frac{d \hat{\theta}_{\epsilon, z_{\delta} ,-z}}{d \epsilon} - \Big|_{\epsilon=0} = \nabla_\theta L(z_{\text{test}}, \hat{\theta})^\top \ - H_{\hat{\theta}}^{-1} \ \nabla_x \nabla_\theta L(z, \hat{\theta}) +\mathcal{I}_{pert}(z, z\_{\text{test}}) = - \nabla_\theta L(z\_{\text{test}}, +\hat{\theta})^\top \ \frac{d \hat{\theta}_{\epsilon, z\_{\delta} ,-z}}{d \epsilon} +\Big|_{\epsilon=0} = \nabla_\theta L(z\_{\text{test}}, \hat{\theta})^\top \ +H_{\hat{\theta}}^{-1} \ \nabla_x \nabla_\theta L(z, \hat{\theta}) $$ + The perturbation definition of the influence score is not straightforward to understand, but it has a simple interpretation: it tells how much the loss of the model changes when a certain feature of point z is up-weighted. A positive perturbation influence score indicates that the feature might have a positive effect on the accuracy of the model. It is worth noting that this is just a very rough estimate and it is subject to large approximation errors. It can -nonetheless be used to build train-set attacks, as done in the [original -paper](:footcite:t:`koh_understanding_2017`). +nonetheless be used to build training-set attacks, as done in +:footcite:t:`koh_understanding_2017`. Inverting the Hessian: direct and approximate methods ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -As discussed in :ref:`theory of influence functions for neural networks`, in +As discussed in `The Influence Function`_, in machine learning training rarely converges to a global minimum of the loss. Despite good apparent convergence, $\hat{\theta}$ might be located in a region with flat curvature or close to a saddle point. In particular, the Hessian might @@ -203,7 +228,7 @@ training and test samples. Approximate matrix inversion ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Sometimes it is not possible to construct the complete Hessian in memory. In +Most often it is not possible to construct the complete Hessian in memory. In that case one can use conjugate gradient as a space-efficient approximation to inverting the full matrix. In pyDVL this can be done with the parameter `inversion_method` of :func:`~pydvl.influence.compute_influences`: From 61c6c1e5fc9cf10f1ca9fb0a73b9564409c92ff0 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 29 Jun 2023 10:35:28 +0200 Subject: [PATCH 130/436] Fixed links --- notebooks/influence_imagenet.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/notebooks/influence_imagenet.ipynb b/notebooks/influence_imagenet.ipynb index 8b391be6a..739fd783c 100644 --- a/notebooks/influence_imagenet.ipynb +++ b/notebooks/influence_imagenet.ipynb @@ -344,7 +344,7 @@ "\n", "Let's now calculate influences! The main method is `:func:~pydvl.influence.general.compute_influences`, which takes a trained `nn.Model`, the training loss, some input dataset with labels (which typically is the training data, or a subset of it) and some test data.\n", "\n", - "Other important parameters are the Hessian regularization term, which should be chosen as small as possible for the computation to converge (further details on why this is important can be found in the [Appendix](#appendix)).\n", + "Other important parameters are the Hessian regularization term, which should be chosen as small as possible for the computation to converge (further details on why this is important can be found in the [documentation](../40-influence.rst#Approximate-matrix-inversion)).\n", "\n", "Since Resnet18 is quite big, we pick conjugate gradient (`cg`) as the method for inversion of the Hessian. A naive computation would require a lot of memory. Finally, the influence type will be `up`. The other option, `perturbation`, is beyond the scope of this notebook, but more info can be found in the notebook [using the Wine dataset](influence_wine.ipynb) or in the documentation for pyDVL.\n", "\n", @@ -987,7 +987,7 @@ "\n", "*Basu, S., P. Pope, and S. Feizi. [Influence Functions in Deep Learning Are Fragile.](https://par.nsf.gov/servlets/purl/10315557) International Conference on Learning Representations (ICLR). 2021*.\n", "\n", - "Nevertheless, influence functions offer a relatively quick and mathematically rigorous way to evaluate (at first order) the importance of a training point for a model's prediction." + "Nevertheless, influence functions offer a relatively quick and mathematically rigorous way to evaluate (at first order) the importance of a training point for a model's prediction.\n" ] } ], From a62fc1ac9e2a5b638c4ce827ed057006171fbd0f Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 29 Jun 2023 10:38:42 +0200 Subject: [PATCH 131/436] Avoid name duplication in notebooks --- notebooks/influence_imagenet.ipynb | 2 +- notebooks/influence_wine.ipynb | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/notebooks/influence_imagenet.ipynb b/notebooks/influence_imagenet.ipynb index 739fd783c..6bc43c0e3 100644 --- a/notebooks/influence_imagenet.ipynb +++ b/notebooks/influence_imagenet.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Influence functions for neural networks\n", + "# Influence functions for image classification\n", "\n", "This notebook explores the use of influence functions for convolutional neural networks. In [the first part](#analysing-influences) we will investigate the usefulness, or lack thereof, of influence functions for the interpretation of a classifier's outputs.\n", "\n", diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index 80589045d..25c797653 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -6,11 +6,11 @@ "id": "a75acfec", "metadata": {}, "source": [ - "# Influence functions and neural networks\n", + "# Influence functions for outlier detection\n", "\n", "This notebook shows how to calculate influences on a NN model using pyDVL for an arbitrary dataset, and how this can be used to find anomalous or corrupted data points.\n", "\n", - "It uses the wine dataset from sklearn: given a set of 13 different input parameters regarding a particular bottle, each related to some physical property (e.g. concentration of magnesium, malic acidity, alcoholic percentage, etc), the model will need to predict to which of 3 classes the wine belongs to. For more details, please refer to the [sklearn documentation](https://scikit-learn.org/stable/datasets/toy_dataset.html#wine-recognition-dataset)." + "It uses the wine dataset from sklearn: given a set of 13 different input parameters regarding a particular bottle, each related to some physical property (e.g. concentration of magnesium, malic acidity, alcoholic percentage, etc.), the model will need to predict to which of 3 classes the wine belongs to. For more details, please refer to the [sklearn documentation](https://scikit-learn.org/stable/datasets/toy_dataset.html#wine-recognition-dataset)." ] }, { @@ -634,7 +634,7 @@ "id": "9245791c", "metadata": {}, "source": [ - "This was a quick introduction to the pyDVL interface for influence functions. Despite their speed and simplicity, influence functions are known to be a very noisy estimator of data quality, as pointed out in the paper [\"Influence functions in deep learning are fragile\"](https://arxiv.org/abs/2006.14651). The size of the network, the weight decay, the inversion method used for calculating influences, the size of the test set: they all add up to the total amount of noise. Experiments may therefore give quantitative and qualitatively different results if not averaged across several realisations. Shapley values, on the contrary, have shown to be a more robust, but this comes at the cost of high computational requirements. PyDVL employs several parallelization and caching techniques to optimize such calculations." + "This was a quick introduction to the pyDVL interface for influence functions. Despite their speed and simplicity, influence functions are known to be a very noisy estimator of data quality, as pointed out in the paper [\"Influence functions in deep learning are fragile\"](https://arxiv.org/abs/2006.14651). The size of the network, the weight decay, the inversion method used for calculating influences, the size of the test set: they all add up to the total amount of noise. Experiments may therefore give quantitative and qualitatively different results if not averaged across several realisations. Shapley values, on the contrary, have shown to be a more robust, but this comes at the cost of high computational requirements. PyDVL employs several parallelization and caching techniques to optimize such calculations.\n" ] } ], From 490e1d801136b6c72612874dbd7a930bd1f282f3 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 29 Jun 2023 11:11:23 +0200 Subject: [PATCH 132/436] Remove unused dependencies, adapt script for copying notebooks, update configuration --- .../_ext => build_scripts}/copy_notebooks.py | 30 ++++++++++------- docs/10-getting-started.md | 2 +- docs/css/extra.css | 5 +++ docs/examples/index.md | 10 ++++++ mkdocs.yml | 32 ++++++++++--------- requirements-docs.txt | 6 ++-- 6 files changed, 54 insertions(+), 31 deletions(-) rename {docs/_ext => build_scripts}/copy_notebooks.py (54%) create mode 100644 docs/examples/index.md diff --git a/docs/_ext/copy_notebooks.py b/build_scripts/copy_notebooks.py similarity index 54% rename from docs/_ext/copy_notebooks.py rename to build_scripts/copy_notebooks.py index 84fe3cf2e..c8d6fdb64 100644 --- a/docs/_ext/copy_notebooks.py +++ b/build_scripts/copy_notebooks.py @@ -1,22 +1,26 @@ +import logging import os import shutil from pathlib import Path -from sphinx.application import Sphinx -from sphinx.config import Config -from sphinx.util import logging +import mkdocs.plugins logger = logging.getLogger(__name__) +root_dir = Path(__file__).parent.parent +docs_examples_dir = root_dir / "docs" / "examples" +notebooks_dir = root_dir / "notebooks" -def copy_notebooks(app: Sphinx, config: Config) -> None: - logger.info("Copying notebooks to examples directory") - root_dir = Path(app.confdir).parent - notebooks_dir = root_dir / "notebooks" - docs_examples_dir = root_dir / "docs" / "examples" + +@mkdocs.plugins.event_priority(100) +def on_pre_build(config): + logger.info("Temporarily copying notebooks to examples directory") + docs_examples_dir.mkdir(parents=True, exist_ok=True) notebook_filepaths = list(notebooks_dir.glob("*.ipynb")) + for notebook in notebook_filepaths: target_filepath = docs_examples_dir / notebook.name + try: if os.path.getmtime(notebook) <= os.path.getmtime(target_filepath): logger.info( @@ -28,9 +32,13 @@ def copy_notebooks(app: Sphinx, config: Config) -> None: logger.info( f"Copying '{os.fspath(notebook)}' to '{os.fspath(target_filepath)}'" ) - shutil.copyfile(src=notebook, dst=target_filepath) + shutil.copy2(src=notebook, dst=target_filepath) + logger.info("Finished copying notebooks to examples directory") -def setup(app): - app.connect("config-inited", copy_notebooks) +@mkdocs.plugins.event_priority(-100) +def on_shutdown(): + logger.info("Removing temporary examples directory") + for notebook_file in docs_examples_dir.glob("*.ipynb"): + notebook_file.unlink() diff --git a/docs/10-getting-started.md b/docs/10-getting-started.md index 693cbb793..d232ece22 100644 --- a/docs/10-getting-started.md +++ b/docs/10-getting-started.md @@ -29,7 +29,7 @@ introduction and survey of the field, we refer to **the upcoming review** at the If you are somewhat familiar with the concepts of data valuation, you can start by browsing our worked-out examples illustrating pyDVL's capabilities either: -- [In this documentation][examples/]. +- [[examples]]. - Using [binder](https://mybinder.org/>) notebooks, deployed from each example's page. - Locally, by starting a jupyter server at the root of the project. You will diff --git a/docs/css/extra.css b/docs/css/extra.css index 1d318766f..1eb1284fe 100644 --- a/docs/css/extra.css +++ b/docs/css/extra.css @@ -71,3 +71,8 @@ a.autorefs-external:hover::after { .md-header__button.md-logo img, .md-header__button.md-logo svg { height: 1.9rem; } + +/* Prevent selection of >>>, ... and output in Python code blocks */ +.highlight .gp, .highlight .go { /* Generic.Prompt, Generic.Output */ + user-select: none; +} diff --git a/docs/examples/index.md b/docs/examples/index.md new file mode 100644 index 000000000..a0f01159e --- /dev/null +++ b/docs/examples/index.md @@ -0,0 +1,10 @@ +--- +title: Examples +alias: + name: examples + text: Examples +--- + +This section contains worked-out examples illustrating pyDVL's capabilities. + +Use the navigation bar on the left to go through them. diff --git a/mkdocs.yml b/mkdocs.yml index 3643fe6e4..a6fd0ac19 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -7,6 +7,9 @@ copyright: "Copyright © AppliedAI Institute gGmbH" watch: - src/pydvl +hooks: + - build_scripts/copy_notebooks.py + plugins: - autorefs - search @@ -14,6 +17,13 @@ plugins: - alias: use_relative_link: true verbose: true + - gen-files: + scripts: + - build_scripts/generate_api_docs.py + - literate-nav: + nav_file: SUMMARY.md + - mkdocs-jupyter: + include: ["docs/examples/*.ipynb"] - mkdocstrings: enable_inventory: true handlers: @@ -29,27 +39,20 @@ plugins: line_length: 80 show_bases: true members_order: source - # separate_signature: true + show_submodules: false show_signature_annotations: false signature_crossrefs: true - # show_if_no_docstring: true merge_init_into_class: true docstring_options: ignore_init_summary: true - # filters: [] # include all members - - gen-files: - scripts: - - build_scripts/generate_api_docs.py - - literate-nav: - nav_file: SUMMARY.md - bibtex: bib_file: "docs/assets/pydvl.bib" csl_file: "docs/assets/elsevier-harvard.csl" cite_inline: true - #- git-revision-date-localized: - # enable_creation_date: true - # type: iso_date - # fallback_to_build_date: true + - git-revision-date-localized: + enable_creation_date: true + type: iso_date + fallback_to_build_date: true theme: name: material @@ -62,12 +65,11 @@ theme: - search.suggest - search.highlight - toc.follow - # - navigation.tabs - # - navigation.tabs.sticky + - navigation.top - navigation.instant - navigation.sections + - navigation.path - navigation.tracking - # - navigation.top - navigation.footer - content.code.copy - content.code.annotate diff --git a/requirements-docs.txt b/requirements-docs.txt index 66fe075de..6df4ff835 100644 --- a/requirements-docs.txt +++ b/requirements-docs.txt @@ -1,6 +1,7 @@ mkdocs==1.4.2 mkdocs-material mkdocstrings[python]>=0.18 +mkdocs-jupyter mkdocs-alias-plugin>=0.6.0 mkdocs-autorefs mkdocs-gen-files @@ -8,8 +9,5 @@ mkdocs-literate-nav mkdocs-section-index mkdocs-bibtex neoteroi-mkdocs # Needed for card grid on home page -mkdocs-gallery -mkdocs-nbconvert mkdocs-git-revision-date-localized-plugin -pypandoc -pypandoc_binary +pypandoc_binary \ No newline at end of file From 8d19a938de352b7536093d4d09bfa08c9ac8c8d5 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 29 Jun 2023 15:43:57 +0200 Subject: [PATCH 133/436] Update notebook cell tags to allow hiding cells in documentation --- docs/css/bootstrap.css | 33 +++++ docs/css/extra.css | 25 ++++ mkdocs.yml | 5 + notebooks/influence_imagenet.ipynb | 47 +----- notebooks/least_core_basic.ipynb | 181 ++++++++++------------- notebooks/shapley_basic_spotify.ipynb | 106 ++++++------- notebooks/shapley_knn_flowers.ipynb | 29 ++-- notebooks/shapley_utility_learning.ipynb | 170 ++++++++++----------- 8 files changed, 286 insertions(+), 310 deletions(-) create mode 100644 docs/css/bootstrap.css diff --git a/docs/css/bootstrap.css b/docs/css/bootstrap.css new file mode 100644 index 000000000..489c9cedc --- /dev/null +++ b/docs/css/bootstrap.css @@ -0,0 +1,33 @@ + + + +.alert { + --bs-alert-bg: transparent; + --bs-alert-padding-x: 1rem; + --bs-alert-padding-y: 1rem; + --bs-alert-margin-bottom: 1rem; + --bs-alert-color: inherit; + --bs-alert-border-color: transparent; + --bs-alert-border: 1px solid var(--md-accent-fg-color); + --bs-alert-border-radius: 2px; + --bs-alert-link-color: inherit; + position: relative; + padding: var(--bs-alert-padding-y) var(--bs-alert-padding-x); + margin-bottom: var(--bs-alert-margin-bottom); + color: black; + background-color: var(--bs-alert-bg); + border: var(--bs-alert-border); + border-radius: var(--bs-alert-border-radius); +} + +.alert-info { + --bs-alert-bg: var(--md-accent-bg-color); + --bs-alert-border-color: var(--md-accent-fg-color); + --bs-alert-link-color: var(--md-accent-fg-color); +} + +.alert-warning { + --bs-alert-bg: var(--md-accent-bg-color); + --bs-alert-border-color: var(--md-accent-fg-color); + --bs-alert-link-color: var(--md-accent-fg-color); +} \ No newline at end of file diff --git a/docs/css/extra.css b/docs/css/extra.css index 1eb1284fe..093a06280 100644 --- a/docs/css/extra.css +++ b/docs/css/extra.css @@ -76,3 +76,28 @@ a.autorefs-external:hover::after { .highlight .gp, .highlight .go { /* Generic.Prompt, Generic.Output */ user-select: none; } + +/* Remove cell input and output prompt */ +.jp-InputArea-prompt, .jp-OutputArea-prompt { + display: none !important; +} + +/* Alert boxes */ +.alert { + border-radius: 0.375rem; + padding: 1rem; + position: relative; + margin: auto; + text-align: center; +} + +.alert-info { + background: var(--md-typeset-ins-color); + border: 0.1rem solid var(--md-primary-fg-color); +} + +.alert-warning { + background: var(--md-warning-bg-color); + border: 0.1rem solid var(--md-primary-fg-color); + color: black; +} \ No newline at end of file diff --git a/mkdocs.yml b/mkdocs.yml index a6fd0ac19..29a4752fd 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -24,6 +24,11 @@ plugins: nav_file: SUMMARY.md - mkdocs-jupyter: include: ["docs/examples/*.ipynb"] + remove_tag_config: + remove_cell_tags: + - hide + remove_input_tags: + - hide-input - mkdocstrings: enable_inventory: true handlers: diff --git a/notebooks/influence_imagenet.ipynb b/notebooks/influence_imagenet.ipynb index d7494436a..bbc6e827f 100644 --- a/notebooks/influence_imagenet.ipynb +++ b/notebooks/influence_imagenet.ipynb @@ -333,52 +333,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "eb973044c7634b2eb8ca3a1bc0b1a79f", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Split Gradient: 0%| | 0/98 [00:00\n", - "If you are reading this in the documentation, some boilerplate has been omitted for convenience.\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, + "execution_count": null, "id": "f6656599", "metadata": { - "nbsphinx": "hidden" + "tags": [ + "hide" + ] }, "outputs": [], "source": [ @@ -60,7 +64,9 @@ "execution_count": 2, "id": "08ee61fd", "metadata": { - "nbsphinx": "hidden" + "tags": [ + "hide" + ] }, "outputs": [], "source": [ @@ -357,31 +363,15 @@ "errors_df = pd.DataFrame(all_errors)" ] }, - { - "cell_type": "code", - "execution_count": 13, - "id": "f2a4dd47", - "metadata": { - "nbsphinx": "hidden" - }, - "outputs": [], - "source": [ - "_ = shaded_mean_std(\n", - " errors_df,\n", - " abscissa=errors_df.columns,\n", - " num_std=1,\n", - " xlabel=\"Budget\",\n", - " ylabel=\"$l_2$ Error\",\n", - " label=\"Estimated values\",\n", - " title=\"$l_2$ approximation error of values as a function of the budget\",\n", - ")" - ] - }, { "cell_type": "code", "execution_count": 14, "id": "f3e02c36", - "metadata": {}, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "data": { @@ -395,6 +385,15 @@ } ], "source": [ + "_ = shaded_mean_std(\n", + " errors_df,\n", + " abscissa=errors_df.columns,\n", + " num_std=1,\n", + " xlabel=\"Budget\",\n", + " ylabel=\"$l_2$ Error\",\n", + " label=\"Estimated values\",\n", + " title=\"$l_2$ approximation error of values as a function of the budget\",\n", + ")\n", "plt.show()" ] }, @@ -408,35 +407,15 @@ "Still, the decrease may not always necessarily happen when we increase the number of iterations because of the fact that we sample the subsets with replacement in the Monte Carlo method i.e there may be repeated subsets." ] }, - { - "cell_type": "code", - "execution_count": 15, - "id": "1d0a490a", - "metadata": { - "nbsphinx": "hidden" - }, - "outputs": [], - "source": [ - "mean_std_values_df = values_df.drop(columns=\"budget\").agg([\"mean\", \"std\"])\n", - "df = pd.concat([exact_values_df, mean_std_values_df])\n", - "df = df.sort_values(\"exact_value\", ascending=False, axis=1).T\n", - "df.plot(\n", - " kind=\"bar\",\n", - " title=\"Comparison of Exact and Monte Carlo Methods\",\n", - " xlabel=\"Index\",\n", - " ylabel=\"Value\",\n", - " color=[\"dodgerblue\", \"indianred\"],\n", - " y=[\"exact_value\", \"mean\"],\n", - " yerr=[exact_values_df.loc[\"exact_value_stderr\"], mean_std_values_df.loc[\"std\"]],\n", - ")\n", - "_ = plt.legend([\"Exact\", \"Monte Carlo\"])" - ] - }, { "cell_type": "code", "execution_count": 16, "id": "48bccf93", - "metadata": {}, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "data": { @@ -450,6 +429,19 @@ } ], "source": [ + "mean_std_values_df = values_df.drop(columns=\"budget\").agg([\"mean\", \"std\"])\n", + "df = pd.concat([exact_values_df, mean_std_values_df])\n", + "df = df.sort_values(\"exact_value\", ascending=False, axis=1).T\n", + "df.plot(\n", + " kind=\"bar\",\n", + " title=\"Comparison of Exact and Monte Carlo Methods\",\n", + " xlabel=\"Index\",\n", + " ylabel=\"Value\",\n", + " color=[\"dodgerblue\", \"indianred\"],\n", + " y=[\"exact_value\", \"mean\"],\n", + " yerr=[exact_values_df.loc[\"exact_value_stderr\"], mean_std_values_df.loc[\"std\"]],\n", + ")\n", + "plt.legend([\"Exact\", \"Monte Carlo\"])\n", "plt.show()" ] }, @@ -547,12 +539,25 @@ }, { "cell_type": "code", - "execution_count": 20, - "id": "be2dde67", + "execution_count": 21, + "id": "1f95fb06", "metadata": { - "nbsphinx": "hidden" + "tags": [ + "hide-input" + ] }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots()\n", "\n", @@ -570,28 +575,7 @@ " title=\"Accuracy as a function of percentage of removed best data points\",\n", " ax=ax,\n", " )\n", - "\n", - "_ = plt.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "1f95fb06", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABlkAAALGCAYAAADGEfdTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd5wU9d0H8M/M9uudenBw9CIdC0iTosaCYgmiglijREmMTzQ+ETAaNGpii48FBWIvUcFKkaMpHVSQIuWOcr3X7fN7/pidvd3bvbLHHdc+79eLF7A7O/Pb3dnZu/nM9/uThBACREREREREREREREREFBK5pQdARERERERERERERETUFjFkISIiIiIiIiIiIiIiagSGLERERERERERERERERI3AkIWIiIiIiIiIiIiIiKgRGLIQERERERERERERERE1AkMWIiIiIiIiIiIiIiKiRmDIQkRERERERERERERE1AgMWYiIiIiIiIiIiIiIiBqBIQsREREREREREREREVEjMGQhIiIiopA4nU4sWrQIffv2hclkgiRJ+Pzzz1t6WI0yadIkSJLU0sM4a0ePHsU111yDzp07Q5IkxMTEtPSQqI16//33MWLECERGRkKSJCxcuLClh9ShpKSkICUlpcHLS5KESZMmNdt4WoOO8BxDtXjxYkiShI0bN7b0UIiIiAgMWYiIiDqsJ598EpIkQZIkHDlypKWHQ23Ic889h8cffxxdu3bFn/70JyxatAgDBgxo6WEFNW/ePEiShIyMjJYeSrNxu92YOXMmvv76a1xxxRVYtGgRHn744ZYeVpvU0U/mbtu2DXPmzEF5eTl+97vfYdGiRbj00ktbeljURrTmE/8ZGRmQJAnz5s1r6aG0Khs3boQkSVi8eHFLD4WIiKhN07f0AIiIiOjcE0Jg2bJlkCQJQgi88cYbePbZZ1t6WNRGfPnll4iIiMC6detgNBpbejhn5T//+Q+qqqpaehhnJT09HQcPHsSdd96J119/vaWHQ23YV199BSEE/vOf/+Ciiy5q6eEQUS0WLFiA3/72t+jRo0dLD4WIiIjAShYiIqIOae3atcjIyMDcuXPRuXNnrFy5Eg6Ho6WHRW1EVlYW4uPj23zAAgA9evRotVU4DZWVlQUA6Nq1awuPhNo67ktEbUNCQgIGDBiAsLCwlh4KERERgSELERFRh/TGG28AAO68807MmTMHBQUF+Oyzz2pd/syZM7j//vvRt29fWCwWxMXFYezYsfjb3/7W6GXrassTrMWTb6uPX3/9FTfeeCOSkpIgy7K3NcmePXvwwAMPYNiwYYiLi4PZbEbfvn3x4IMPori4uNbn9+GHH+KSSy7xPiYlJQWzZ8/G7t27AQCvvfYaJEnCkiVLgj4+JycHBoMBQ4cOrXUbvlasWIFZs2ahd+/esFgsiIqKwrhx4/DOO+8EXf7EiRO466670KdPH+9rOnToUNxzzz0oLCxs0DY///xz3HzzzejXrx/Cw8MRHh6OUaNG4cUXX4SiKA1ah/a+pKen4+TJk952c9r8AfW1HQk218CKFSsgSRJWrFiBtLQ0TJo0CZGRkYiKisJvfvMbHDp0KOi6qqqq8PTTT2P06NGIjIxEREQEBg4ciPvvvx+5ubkA1H1s5cqVAIBevXoFjBeofU4WRVHw6quvYsyYMYiIiEB4eDjGjBmD//u//wv6emn7c0FBAe666y506dIFJpMJgwcPxvLly+t5ZQPt2bMHs2bNQlJSEkwmE3r27Il7770X2dnZAdudOHEiAGDJkiXe51hf6xffz9Phw4cxc+ZMxMXFITw8HOPHj8fatWtrfez777+PyZMnIyYmBmazGQMHDsQTTzwBu91e6+uSk5ODO+64A926dYNOp8OKFSu8y+zcuRM33ngjunXrBpPJhC5dumD69On46KOPAta3Y8cOXHfddejcuTOMRiOSk5Nx9913e8MBX9p763K58Pe//907h1BycjL+/Oc/+wXL2n4IAJs2bfK+jjVfy1A/uwCwa9cuTJ8+3btfT506Fdu2bauztdLhw4cxb948JCcnw2g0olOnTrjppptCbu3Y0P1Ye/7avur7eamv1Z7v83jvvfdw/vnnIyIiwu9zVlVVhaVLl2L48OEIDw9HREQELrzwQrz//vsB6/M9juzevRuXXnopoqOjERsbi1mzZuH06dMA1OPib3/7WyQmJsJisWDy5Mn46aefgo4xOzsb9913H1JSUmA0GpGYmIhrr70We/bs8VvuqaeegiRJeOGFF4KuJysrC3q9HqNHj/a73eVy4ZVXXsEFF1yAqKgohIWFYcSIEXj55ZeDHi+EEHj55ZcxePBgmM1mdOvWDQsWLEBpaWmdr3VdsrKycMsttyApKQkWiwWjRo3Ce++9V+vya9asweWXX46EhASYTCakpqbioYceQklJScCyP//8M2bPno2UlBSYTCYkJiZi5MiRWLhwIZxOJwD1+K59R06ePNnvM9QQDocDf/vb35CamgqTyYRevXrhf//3f4MeV7Tn+/jjj2PcuHHe40HXrl1x00034eDBg37LLl68GL169QIArFy50m9s2rHI4XDg5ZdfxuWXX46ePXvCZDIhLi4OU6dOxTfffNOg5+C7Pe0zsXLlSowYMQIWiwVJSUmYP38+cnJygj7u6NGjuPXWW9GtWzfv87n11ltx9OjROrfhK5Tvonnz5mHy5MkA/L8/fNfrcDjw4osvYuTIkYiNjUVYWBhSUlJw9dVXY/369SG9LkRERO0Z24URERF1MLm5uVi9ejX69euHiy66CFFRUXjuuefw+uuv48YbbwxYfvfu3ZgxYwaKioowYcIEXHvttaiqqsLBgwexePFi/PWvf23Uso11/PhxnH/++ejXrx/mzJkDq9WKqKgoAGp49Nlnn2HixImYOnUqFEXBnj178M9//hPffPMNduzYgcjISO+6hBC47bbbsHLlSiQkJODaa69FYmIizpw5g7S0NPTv3x+jR4/GnDlz8D//8z9488038b//+7/Q6XR+Y3rrrbfgcrlw9913N+g5/O53v8PgwYMxYcIEdOnSBYWFhfj6669xyy234MiRI36BVHZ2NsaMGYOysjJcfvnlmDVrFmw2G9LT0/H2229jwYIFiI+Pr3ebDz/8MGRZxvnnn49u3bqhtLQUGzZswAMPPIBdu3bh7bffrncdM2fOREpKCp5//nkA8E6I3RSTrH/55ZdYtWoVLrvsMtxzzz04ePAgvv76a+zatQsHDx5EQkKCd9ni4mLvCdX+/ftj/vz5MBqNOH78OJYvX45rr70WnTp1wqJFi/D555/jp59+wgMPPOAdZ0PGe8stt+C9995DcnIy7rjjDkiShM8++wz33nsvtm7dinfffTfgMSUlJRg3bhyMRiOuu+462O12fPzxx5g/fz5kWcbcuXMb/FrMmjULQghcd9116NmzJ/bs2YP/+7//w6pVq7B161bvCcNFixYhIyMDK1euxMSJE73BZUPnFUlPT8eFF16IoUOH4u6770Z2djY+/PBDXHbZZXjvvfcCjgnz58/H8uXL0b17d8yaNQsxMTHYvn07/vrXv+K7777DunXroNf7/4pRVFSECy64ABEREbj22mshyzI6deoEQP3M/u53v4NOp8NVV12Fvn37Ii8vD7t378Yrr7yCG264wbuet956C3fddRdMJhOuuuoqJCcn4+jRo1i2bBm++OILbN++PWjrnJtuuglbtmzBZZddhqioKHz99df4xz/+gby8PO9Jx+HDh2PRokVYsmQJevbs6Tdvg+9rGcpnFwA2b96M6dOnw+1249prr0Vqair279+PyZMnY8qUKUHfk2+//RbXXnstnE4nrrzySvTp0wdnzpzBp59+iq+++gppaWkYOXJk/W8uGr4fa8+/sZ8XQJ2rad26dbjyyisxefJkb2BQUlKCKVOmYN++fRg5ciTmz58PRVGwZs0a3HTTTfjll1/wxBNPBKxv165dePrppzFx4kTceeed2L9/Pz799FMcOHAAq1atwvjx4zFgwADceuutOHnyJD799FNMmzYNJ06cQEREhHc96enpGD9+PLKysjBlyhTMnj0bp0+fxscff4yvvvoK//3vf3HFFVd4X69HH30U//nPf/DAAw8EjOmdd96B2+322z+092nNmjXo378/brrpJpjNZqSlpeH3v/89duzYEXB8XbhwIV588UV06dIFd911FwwGA1atWoUdO3bA4XCEXCVYXFyMiy66CDExMbjttttQUlKCjz76CHPmzEFmZiYeeughv+WXLFmCxYsXIy4uDldccQWSkpLw888/49lnn8XXX3+Nbdu2eb9Xf/75Z5x//vmQJAlXXXUVevXqhbKyMhw7dgyvvPIKnnjiCRgMBixcuBCff/45Nm3ahLlz5wYE6nURQuCGG27AqlWrkJqaigULFsDhcOCtt97C/v37gz5m8+bNeOqppzB58mTMmjULEREROHr0KD755BOsXr0a33//PYYNGwZA/QyXlJTghRdewLBhwzBz5kzveoYPHw5APU498MADuOiiizBt2jQkJiYiOzsbX3zxBS6//HK88cYbuOOOOxr+pgD417/+hbVr1+LGG2/EpZdeiq1bt2L58uXYuHEjduzYgcTERO+yu3btwtSpU1FeXo6rrroKgwYNwuHDh/HOO+9g1apVWL9+PcaMGdOg7Tb0u0h7HWp+fwDwvn/z5s3D+++/jyFDhuDWW2+FxWJBVlYWtm7dim+//RZTp04N6TUhIiJqtwQRERF1KEuXLhUAxN///nfvbaNGjRKSJImjR4/6LWu320VKSooAIN59992AdZ0+fbpRywohBAAxceLEoGOcO3euACDS09O9t6WnpwsAAoB45JFHgj4uIyNDuFyugNuXLVsmAIinnnrK7/bXXntNABBjxowRJSUlfve5XC6RlZXl/f99990nAIgvvvjCbzlFUUSvXr1EWFhYwDpqc+zYsYDb7Ha7mDJlitDr9eLMmTPe21988UUBQDz//PMBj6moqBBVVVWN3qbb7Ra33nqrACC2b9/eoPUIIUTPnj1Fz549A25PS0sTAMSiRYsa/Ljly5cLAEKn04n169f73ffwww8LAOLpp5/2u3327NkCgLjnnnuE2+32u6+8vNzvfQi2L/maOHGiqPkj8XvvvScAiBEjRojy8nLv7RUVFWLUqFFB93Ft37z99tv99sFffvlF6HQ6MXDgwKDbr6m8vFzExcUJWZbF5s2b/e576qmnBAAxbdo0v9vre92D8f08/elPf/K7b9euXUKv14uYmBhRWlrqvV17r6655pqA/W7RokVB91NtG7fccotwOp1+9/3yyy9Cr9eL2NhYceDAgYAx+h4zjhw5IgwGg0hNTfX7fAghxPr164Usy2LmzJl+t2vv7ciRI0VhYaH39oqKCpGamipkWRbZ2dkB463tuCREaJ9dt9st+vTpIwCIr7/+2u8x//d//+d9bdLS0ry3FxUViZiYGBEfHy9++eUXv8fs379fhIeHixEjRtQ6Pl+N2Y/r+7wEo733YWFhYu/evQH3a+us+Tm2Wq1ixowZQpIksW/fPu/t2v4MQLzzzjt+j5k/f74AIGJjY8UTTzzhd9/jjz8edB+cPn26ABCw/Pfffy90Op2Ii4vze3205ffv3x/wXAYNGiSMRqMoKCgIeP4LFizw++y7XC7veD///HO/7QIQqampfvul1WoVF1xwgQAQ9PhaG+21uv766/2OhydOnBCxsbHCYDCI48ePe2/fsGGDACAuvPBCUVxc7Lcu7TO+cOFC721//OMfA56DpqioyG+b2mvhu083xLvvvisAiAsuuEBYrVbv7YWFhaJ3795BP5e5ubmirKwsYF0//vijCA8PF5deeqnf7doxb+7cuUHHYLPZAn5OEUKIkpISMXjwYBEbG9vg71vtdTAYDAGfiYULFwoAYv78+d7bFEURAwYMCLrPf/DBBwKA6N+/f4Ne61C/i+r6/igpKRGSJIlRo0YF/dnK93NARETU0TFkISIi6kAURfGeXPQ9GfjSSy8JAOJ//ud//Jb/5JNPBABx1VVX1bvuUJYVovEhS6dOnYTNZmvQNjSKooioqCgxefJkv9uHDBkiAAQ9MVjTgQMHBABxxRVX+N3+7bffCgDitttuC2lMwfz3v/8VAMTKlSu9t2khy2uvvXbW6w9mz549AoBYsmRJgx/THCHLnDlzApY/ceKEACBmzZrlvS03N1fIsiy6dOkiKioq6h1rY0KWqVOnCgBizZo1AcuvX79eAAjYl7STzL6hhGbChAkCgN+J3Nq88847AoCYPXt2wH1Op9MbZJ48edJ7+9mELNHR0UFPVGqv24oVK7y3DR8+XOj1+oATs0KoJ5Tj4+PFmDFj/G4HIIxGo8jNzQ14zIIFCwQA8c9//rPe8WonJr/88sug98+cOVPodDq/56K9t+vWrQtY/rHHHgsamtYXstQm2Gd3y5YtQfcVIdQApl+/fgEnSZ9//nkBQLz88stBt6O9DjUDmGAasx+fTcjie2JeU1BQIHQ6nRg9enTQx/74448CgHjooYe8t2n78/jx4wOW37RpkwAgUlJSAk76ZmRkCABi3rx53ttOnz4tAIgePXoIh8MRsL6bb7454H3TTvgHCx+1kFHjdrtFXFyc6Ny5c0CIKIQQxcXFQpIkcf3113tvu+OOOwQA8dZbbwUsrz33UEMWnU4nTpw4EXCf9t4sXrzYe9vMmTMFgKDBphDq5zwxMdH7fy1kCbYf1ba9UEMWbV/dsGFDwH3ad0Qon8srr7xSmEwmv/e8vpClLs8995wAIDZt2tSg5bXXwTdI0ZSUlIjo6GhhNpu9P8ts3brVG3wFM378+IDt1xWyhPJdVNf3R2lpqQAgLrroIqEoSkOeOhERUYfFdmFEREQdyIYNG3D8+HHMmDED3bp1895+00034cEHH8SKFSu8rT8AYPv27QCAyy67rN51h7Ls2Rg2bBhMJlPQ+5xOJ1577TV88MEHOHjwIEpLS/364WdmZnr/XVlZiQMHDqBTp04YMWJEvdvVWgR98803OH36NJKTkwEAr7/+OgDgnnvuafBzOHXqFJ5++ml89913OHXqFKxWq9/9vuO86qqr8Je//AX33Xcf1qxZgxkzZmDcuHEYNGhQg3vdA0BhYSGeeeYZfP311zhx4gQqKytr3WZLqDnHAQDva+w7n86uXbugKAomTJiA8PDwZhnL3r17Icty0JZbEydOhE6nw759+wLu69u3r7fFji/f5+Hbxqi2bQMI2kpKr9djwoQJyMjIwL59+4K2xgrVyJEj/VroaSZNmoSVK1di3759mDt3LqqqqvDTTz8hISHB2y6uJpPJFHQOnZSUFCQlJQXcHsoxY9u2bQDU+VJ27doVcH9eXh7cbjd+/fVXjBo1yu++hu5bDRHKZ1fbR8aPHx+wHlmWcdFFF+HXX3/1u117nj/99FPQeXW05Q8dOoRBgwbVOdbG7seNNXbs2IDbdu3aBbfbXes8Qdp8HsH2m2DvW9euXQGoLZ5qtm3UvtPOnDnjvU17fhdffLH3e83XlClT8M4772Dfvn249dZbAQDXXHMNoqOj8e677+Kpp57ybkeb38m3Vdivv/6KoqIi9O3bN2jLMwCwWCx+z0/7jGtzKfkaP358wPNqiB49enhbCPqaNGkSlixZ4vc+b9u2DQaDAR9//DE+/vjjgMc4HA7k5+ejsLAQ8fHxuPHGG/HCCy9g5syZuO666zB16lSMGzcOqampIY+zNtq+GuyzUlfrw6+++gqvvvoqdu/ejYKCArhcLr/7CwoK0KVLlwaP45dffsEzzzyDzZs3Izs7Gzabze/+UL8ng73H0dHRGD58ODZt2oRDhw5h+PDhdR73tdu3bt2Kffv2YcKECfVutym+iwAgKioKV155Jb744gsMHz4cs2bNwsUXX4zzzz8fYWFh9T6eiIioI2HIQkRE1IFogYDvSSIAiIuLw5VXXon//ve/WLVqFa677joA8E6A6xvI1CaUZc9G586da73vxhtvxGeffYbevXvj6quvRufOnb2BzPPPP+83gW5jxnvvvfdi8+bNWLZsGZYsWYKcnBysXr0aw4cPD3qCMZgTJ05g7NixKC4uxsUXX4zp06cjOjoaOp3OO7eG7zh79uyJnTt3YvHixfj222/x6aefAlBPlvzpT3/C/fffX+82S0pKMGbMGKSnp2Ps2LG49dZbERcXB71e7+1TX9vkwudKsHkftLk93G6397ZzsZ+VlpYiLi4u6LwIer0eCQkJyMvLC7ivtrkrgj2PurYNoNYTg9rtwSanbgxtbpSatM+ZNp7i4mIIIZCfn++d3LqhavvMhvJeFhYWAgCeeeaZOperqKgIuK2h+1Z9Qv3saq9dba9xsNu15/nGG2/UOZZgz7Omxu7HjRXsfdaez65du4KGY5pgzyc6OjrgNu19q+s+LbgBGvd5slgsuOGGG/DGG29g7dq1uOyyy+BwOPD+++8jMTHRLxTUnt/Ro0fr/Fz4Pr+69gvtfQlVQz/H2phdLle9n+OKigrEx8dj7Nix2LJlC5588kl88skn3vll+vfvj0WLFmH27Nkhj7cmbV8NFoTVdvx44YUXsHDhQsTGxmLatGno0aMHwsLCIEmSd26hUL7Xtm/fjilTpsDlcuGSSy7BVVddhaioKMiyjB9//BGrVq0K+Xuyoe9LUx/3m+K7SPPhhx/i6aefxnvvvYdFixYBAMxmM6677jo8++yztT5HIiKijoYhCxERUQeRn5+Pzz//HAAwe/bsWk+MvP76696QRftFvSFXb4ayLABIkhRw1ammrhMJtVVv7N69G5999hmmTp2Kb775xm/ybUVR8I9//OOsxgvAO6H6m2++icceeyzkCe8B4J///CcKCwuxfPnygLDr/fff914t7WvgwIH48MMP4XK58NNPP2H9+vV46aWX8MADDyA8PBy33357ndtctmwZ0tPTsWjRooCrybdt24YXXnihweOviyzLAFDn+9rQSbRr05j3LVTR0dEoKiqC0+kMOOnncrlQUFAQ9Crhpto2AOTk5AS9Pzs722+5s5Wbmxv0dm372na0v0eMGOG96rqhavvM+r6XAwYMqHMd2vZLS0ub7bWvT6ifXW2ctb3GwW7XnudPP/2E884776zGe67342Dvs/Z8/vCHP+Cf//xnk22roRr7eZo7dy7eeOMNrFy5Epdddhm++uorFBYW4oEHHvB7LbXHXXPNNd4AvKFjys3NRe/evf3u096X7t27N2hdmoZ+jrV/K4qCoqKiBq//wgsvxJdffgm73Y49e/bg22+/xUsvvYSbbroJiYmJZz35eV37arD3zuVyYfHixejcuTP27t0bEE5oFWGheOKJJ2C1WpGWlhZQPbN06VKsWrUq5HWGenw9V8f9UFgsFixevBiLFy/G6dOnsXnzZqxYsQLvvPMOMjIysGXLlnM+JiIiotZIbukBEBER0bmxcuVKOBwOjBo1CrfffnvQP4mJiVi/fj3S09MBABdccAEA4Jtvvql3/aEsCwCxsbE4ffp0wO1utxs//vhjA59VtWPHjgFQ22v5BiwAsHPnzoC2PuHh4RgyZAhyc3Mb3DLHYDDgjjvuQGZmJr744gssW7YMERERmDNnTsjjnDVrVsB9mzZtqvOxer0eo0aNwp///Ge8//77AOANzpprm6GIjY0FgKDv67Fjx/yupm6ssWPHQpZlbN68OaDlWTBa651QrtwdMWIEFEXB5s2bA+7bvHkz3G43Ro4c2fBBh0BrXbdx48aA+1wul/eEVlNtf+/evSgvLw+4Xdu+Np6IiAgMHjwYv/zyS0gnZ+vSmONLc5/Qk2W51n0l1M+R9tpt3bo14D5FUfDDDz8E3N6Uz7Ml92ON9nltqROxvu9BsPA3LS0NQODnady4cejbty9WrVqF0tJSb4A2d+5cv+UGDBiAmJgYbN++3a+Cpi7atoLtM1u3bg3pWKU5deoUMjIyAm6v+TkG1H2suLgYv/zyS8jbMZlMuOiii/D444/jxRdfBAC/8KExx1tAfU0URQn6WQl2LCwoKEBJSQkuuuiigICloqIiaBBc39iOHTuGuLi4oO3JGvs9GexxpaWl+PHHH2E2mzFw4EAAdR/3gdr306YQynuWnJyMOXPmYM2aNejTpw+2bt3qreYiIiLq6BiyEBERdRBa+5lXXnkFy5YtC/rn7rvvhhACy5YtAwBceeWVSElJwerVq70n9X359r4PZVlAPfl26tQprF271u/2J554AidPngz5+aWkpAAIPEmRl5eH++67L+hjtFZbd999d0AAoCiK9+pRX3fddRd0Oh0WLFiA9PR03HTTTUHntAh1nGvWrPG+7r727NkTNJzQrpBtSF/02ra5b98+LF26tP5BN9CAAQMQFRWFVatW+bUhslqtDWpr1hCJiYn47W9/i+zsbPzpT3/ym3MHUE+w+b5e8fHxANSTkA01f/58AMAjjzyCqqoq7+1VVVV4+OGHAaDe6qHGmjlzJuLi4vD+++975yzRPP/880hPT8fUqVObZD4WQD3h9/jjj/vdtnv3brz77ruIjo7GNddc4739j3/8IxwOB+bPnx+02qy4uDikKpff/e530Ov1+Nvf/oaDBw8G3O97zFiwYAEMBgP+8Ic/BMxjAqjzSDTFifz4+PigISEQ+mdXm7ciLS0tIEh6/fXXgz6P2267DTExMViyZAl27twZcL+iKLWeiK2pJfdjTVJSEubMmYPdu3fjb3/7W9ATucePH/cG+02te/fumDZtGjIyMgLmEtqxYwfee+89xMbG+u3nmrlz58Jms+GVV17B119/jfPOOy9g/i69Xo/f//73yM7Oxv333x8Q5gNqFYLv/q1VQT355JN+gaXNZsMjjzzSqOfpdrvx5z//2e94mJ6ejhdffBF6vR4333yz9/Y//OEPAIA777wTWVlZAeuqrKz0O/b88MMPQZ9XsO+gxhxvAXW/B4BHH33Ubx6UoqKioHPdJCUlISwsDHv27PFrxeZ0OvHAAw+goKAg4DGxsbGQJKnWsaWkpKCoqAg///yz3+1vvvkm1qxZE9Lz0bz99tsBF3EsXrwYpaWlmD17tred6bhx49C/f39s3boVn3zyid/yn3zyCbZs2YJ+/foFnbPmbNX1nuXn52P//v0Bt1dWVqKiogJ6vT5oO0IiIqKOiO3CiIiIOoCNGzfi119/xdChQ+ucO+T222/Hk08+ieXLl2PJkiUwGo34+OOPMX36dNx000147bXXcMEFF8Bms+HQoUP47rvvvFcHh7IsAPzpT3/CmjVrcPXVV+PGG29EXFwcfvjhB6Snp2PSpEkNPpGoGTNmDMaNG4dPP/0UF110EcaPH4/c3Fx888036N+/v3fCZF933HEHtmzZgrfffht9+/bF1VdfjcTERGRlZWHDhg2YP39+QHutHj164De/+Q1Wr14NACG1CgPUeV2WL1+O66+/Htdddx26du2KAwcO4Ntvv8UNN9yADz/80G/5t99+G6+99hrGjx+P1NRUxMbG4vjx4/jiiy9gMpmwcOHCerd566234plnnsHChQuRlpaGvn374ujRo/jyyy9x7bXXBmyzsQwGAx544AH87W9/w4gRI3DNNdfA5XJh3bp16Nq1a9D3oDFefvllHDhwAK+++io2btyIGTNmwGg0Ij09HWvWrMHq1au9VyNfcskleOaZZ3DnnXdi1qxZiIyMRExMDBYsWFDr+m+66SasWrUKH330EQYPHoyZM2d6+/ynp6fjxhtvDKl6KRQRERF46623cP3112PixIm4/vrr0aNHD+zZswdr165F586d8dprrzXZ9iZMmIBly5Zhx44dGDduHLKzs/Hhhx9CURS89tprfu2k5s+fjz179uCVV15BamoqZsyYgR49eqCoqAjp6enYvHkzbrvtNrz66qsN2vagQYPwyiuv4J577sGIESNw9dVXo2/fvigsLMSuXbsQFRXlvYJ7wIABeOuttzB//nwMHjwYl156Kfr16wen04lTp05hy5YtSExMxOHDh8/q9bjkkkvwwQcf4Morr8TIkSNhMBgwYcIETJgwIeTPrizLWLZsGS699FJcddVVmDVrFlJTU/Hzzz9j3bp1uOyyy/DNN9942+wB6gnPTz75BNdccw0uuOACXHLJJRg8eDAkScLp06exbds2FBYWBkzIHUxL7se+Xn75ZRw9ehSPPfYY3n77bYwfPx6dOnVCVlYWDh06hF27duH9998POnF7U3j11Vcxbtw4PPTQQ1i7di1Gjx6N06dP4+OPP4Ysy1i+fHnQoPyWW27BY489hkWLFsHpdAZUsWj++te/4qeffsKrr76KL774AlOmTEG3bt2Ql5eHo0eP4vvvv8eTTz6JQYMGAVBPqP/+97/HSy+9hCFDhuC6666DwWDAqlWrEBsbG9JE7ZrzzjsPO3bswKhRozB9+nSUlJTgo48+QklJCf7xj3/4TVJ/ySWX4KmnnsIjjzyCvn374vLLL0evXr1QUVGBkydPYtOmTRg/fjy+/fZbAMA//vEPbNiwARdffDF69eqFiIgI/PLLL/jmm28QGxuLu+66y7vuyZMnQ5ZlPPLIIzhw4IC3uvF///d/6xz/7Nmz8eGHH2L16tUYMmQIrr76ajidTnzyyScYM2YMjh8/7re8LMu4//778dRTT2Ho0KG4+uqr4XA4kJaWhqKiIkyePNl77NBERETg/PPPx5YtWzBnzhz069cPOp0OV111Fc477zwsXLgQa9aswfjx43HDDTcgOjoau3fvxtatW3HdddcFhB8Ncdlll2HcuHG44YYb0KVLF2zduhVbt25FSkoKnnrqKe9ykiRh5cqVmDZtGm688UZcffXVGDBgAI4cOYLPP/8ckZGR+M9//uN3rGgq/fv3R7du3fDBBx/AYDCgZ8+ekCQJt9xyC4qLizFixAgMHToU5513HpKTk1FWVoYvv/wSOTk5uP/++0O6yISIiKhdE0RERNTu3XTTTQKAeOGFF+pddtq0aQKA+PTTT723nTx5Uvzud78TKSkpwmAwiLi4ODF27Fjx5JNPBjw+lGVXrVolRo0aJUwmk4iLixM33nijyMjIEHPnzhUARHp6unfZ9PR0AUDMnTu31rEXFhaK3/3ud6Jnz57CZDKJ3r17i0ceeURUVlaKnj17ip49ewZ93DvvvCMmTJggoqKihMlkEikpKeKmm24Se/bsCbr8559/LgCI0aNH1zqWunz//fdi8uTJIiYmRkRERIhx48aJzz77TKSlpQkAYtGiRd5lt2/fLu655x5x3nnnidjYWGE2m0VqaqqYN2+e2L9/f4O3+csvv4grr7xSJCYmirCwMDFy5EjxxhtvNOh1ramu11JRFLF06VLRu3dvYTAYRHJysnjooYdqfQ+WL18uAIjly5cHXR8AMXHixIDbKyoqxBNPPCGGDh0qLBaLiIiIEAMHDhQPPPCAyM3N9Vv2ueeeEwMGDBBGo1EA8BvDxIkTRbAfid1ut/j3v/8tRo0aJSwWi7BYLGLkyJHi5ZdfFm63u8HjFEIE3Z/rs3PnTjFz5kyRkJDgfR3vuecekZmZGbBssP2mPr7v+8GDB8VVV10lYmJihMViERdddJH49ttva33sF198IX7zm9+IxMREYTAYRKdOncSYMWPEo48+Kg4dOuS3bF2vi+aHH34Q1157rXd9Xbp0ETNmzBAff/xxwLI///yzmDt3rujRo4cwGo0iNjZWDB48WNx1113iu+++81u2tvdWiNr3u9zcXDF79myRlJQkZFkOeF1D+exqtm/fLqZOnSoiIiJERESEuOSSS8QPP/wg7rvvPgFA7Nu3L+Ax6enp4r777hN9+vQRJpNJREZGiv79+4ubb75ZfPbZZ3W+nr5C3Y8bs68uWrRIABBpaWm1LmO328VLL70kLrzwQhEVFSWMRqNITk4WU6ZMEf/6179EQUGBd9m6Xsv6jle17W9nzpwR99xzj+jRo4cwGAwiPj5eXH311WLnzp11PrdLLrlEABB6vV7k5OTUupyiKOI///mPmDJlioiNjRUGg0F07dpVjBs3Tjz55JPi1KlTAcu/9NJL3uNSly5dxL333itKSkrqPL7W9ZwzMzPFnDlzRGJiojCZTGLEiBHi3XffrfVxW7ZsEddff73o0qWLMBgMIiEhQQwbNkz84Q9/ELt27fIut2bNGjFv3jwxcOBAERUVJcLCwkS/fv3E73//e5GRkRGw3rffflsMGzZMmM1mAaDWz2BNdrtdLFmyRPTq1UsYjUbRs2dP8Ze//EXYbLag76vT6RTPPfecGDhwoDCbzaJTp07i5ptvrvVnCCGEOHr0qLjiiitEXFyckCQp4BjwxRdfiPPPP19ERESI6OhoMW3aNLFp06Z6v6dq8v1MLF++3Pt6JCQkiHnz5omsrKygjzt8+LC4+eabRefOnYVerxedO3cWc+bMEYcPH65zG74a8120c+dOMWXKFBEVFeV9XdLS0kRxcbFYsmSJmDx5sujataswGo2ic+fOYuLEieK9994TiqI06PUgIiLqCCQhhGjGDIeIiIio3Vm8eDGWLFmCZcuWNXu7HaLmkJGRgV69emHu3LlYsWJFSw+nQxo3bhx27NiB0tJShIeHt/RwiKiJaD8jpKWlBZ3jhYiIiNofzslCREREFILy8nK8+uqriIuLw+zZs1t6OETUilVVVQWdv2bFihX44YcfMH36dAYsRERERERtHOdkISIiImqAr776Cnv37sUXX3yB3NxcPPvssw2adJ6IOq5Tp05hxIgRmDZtGvr06QOXy4V9+/Zh69atiImJwXPPPdfSQyQiIiIiorPEkIWIiIioAT7++GOsXLkSnTp1wiOPPII//OEPLT0kImrlOnXqhDlz5mDTpk1IS0uD3W5H586dcdttt+HRRx/1m5CciIiIiIjaJs7JQkRERERERERERERE1Aick4WIiIiIiIiIiIiIiKgRGLIQERERERERERERERE1Qoefk0VRFGRlZSEyMhKSJLX0cIiIiIiIiIiIiIiIqAUJIVBeXo6uXbtCluuuVenwIUtWVhaSk5NbehhERERERERERERERNSKnD59Gt27d69zmQ4fskRGRgJQX6yoqKgWHg0REREREREREREREbWksrIyJCcne/ODunT4kEVrERYVFcWQhYiIiIiIiIiIiIiIAKBBU4xw4nsiIiIiIiIiIiIiIqJGYMhCRERERERERERERETUCAxZiIiIiIiIiIiIiIiIGoEhCxERERERERERERERUSN0+InviYiIiIiIiIiIiKjtcLvdcDqdLT0MaqMMBgN0Ol2TrY8hCxERERERERERERG1ekII5OTkoKSkpKWHQm1cTEwMOnfuDEmSznpdDFmIiIiIiIiIiIiIqNXTApakpCSEhYU1yQly6liEEKiqqkJeXh4AoEuXLme9ToYsRERERERERERERNSqud1ub8ASHx/f0sOhNsxisQAA8vLykJSUdNatwzjxPRERERERERERERG1atocLGFhYS08EmoPtP2oKeb2YchCRERERERERERERG0CW4RRU2jK/YghCxERERERERERERERUSMwZCEiIiIiIiIiIiIiImoEhixERERERERERERERORn3rx5SElJaelhtHoMWYiIiIiIiIiIiIiIWtCKFSsgSZL3j16vR7du3TBv3jxkZma29PCoDvqWHgAREREREREREREREQGPP/44evXqBZvNhu3bt2PFihXYunUrDhw4ALPZ3NLDoyAYshARERERERERERERtQKXXXYZRo8eDQC44447kJCQgKeffhqrV6/GDTfc0MKjo2DYLoyIiIiIiIiIiIiIqBW6+OKLAQDHjx8HADgcDjz22GMYNWoUoqOjER4ejosvvhhpaWl+j8vIyIAkSXj22Wfx+uuvIzU1FSaTCWPGjMGuXbsCtvP5559jyJAhMJvNGDJkCD777LOg46msrMSDDz6I5ORkmEwm9O/fH88++yyEEH7LSZKEBQsW4OOPP8agQYNgsVhw4YUXYv/+/QCA1157DX369IHZbMakSZOQkZFxti9Vi2ElCxERERERERERERFRK6SFD7GxsQCAsrIyLFu2DLNnz8add96J8vJyvPnmm5gxYwZ27tyJ4cOH+z3+vffeQ3l5Oe6++25IkoR//OMfuPbaa3HixAkYDAYAwNq1azFr1iwMGjQIS5cuRWFhIW677TZ0797db11CCFx11VVIS0vD7bffjuHDh2PNmjV46KGHkJmZiX/9619+y2/ZsgWrV6/GfffdBwBYunQprrjiCvzP//wPXnnlFdx7770oLi7GP/7xD8yfPx8bNmxohlew+TFkISIiIiIiIiIiIqI2RwjA6mrpUfiz6AFJavzjS0tLUVBQAJvNhh07dmDJkiUwmUy44oorAKhhS0ZGBoxGo/cxd955JwYMGICXXnoJb775pt/6Tp06haNHj3pDmv79++Pqq6/GmjVrvOv885//jE6dOmHr1q2Ijo4GAEycOBHTp09Hz549vetavXo1NmzYgCeeeAKPPvooAOC+++7D9ddfjxdeeAELFixAamqqd/kjR47g8OHDSElJ8Y797rvvxhNPPIFff/0VkZGRAAC3242lS5ciIyPDu2xbwpCFiIiIiIiIiIiIiNocqwsY+EpLj8LfoXuBMEPjHz916lS//6ekpOCdd97xVpXodDrodDoAgKIoKCkpgaIoGD16NPbu3RuwvhtvvNEbsADV7cdOnDgBAMjOzsaPP/6Ihx9+2BuwAMC0adMwaNAgVFZWem/7+uuvodPpcP/99/tt48EHH8Qnn3yCb775BgsWLPDefskll/iFJueffz4AYNasWd6Axff2EydOtMmQhXOyEBERERERERERERG1Av/+97+xbt06fPLJJ7j88stRUFAAk8nkt8zKlStx3nnnwWw2Iz4+HomJifjqq69QWloasL4ePXr4/V8LXIqLiwEAJ0+eBAD07ds34LH9+/f3+//JkyfRtWtXv4AEAAYOHOi3rtq2rYU4ycnJQW/XxtTWsJKFiIiIiIiIiIiIiNoci16tHGlNLGd5xn3s2LEYPXo0AGDmzJkYP348brrpJhw5cgQRERF45513MG/ePMycORMPPfQQkpKSoNPpsHTpUhw/fjxgfVrVS001J6pvDrVtuyXH1BwYshARERERERERERFRmyNJZ9eaq7XTwpPJkyfj5ZdfxsMPP4xPPvkEvXv3xqeffgrJZ/KXRYsWNWob2pwrR48eDbjvyJEjAcuuX78e5eXlftUshw8f9ltXR8N2YURERERERERERERErdCkSZMwduxYPP/887DZbN4qEN+qjx07dmDbtm2NWn+XLl0wfPhwrFy50q/d2Lp163Dw4EG/ZS+//HK43W68/PLLfrf/61//giRJuOyyyxo1hraOlSxEREREREREREREjaAIgSoXoAggwgDIPpUFRE3loYcewvXXX48VK1bgiiuuwKeffoprrrkGv/nNb5Ceno5XX30VgwYNQkVFRaPWv3TpUvzmN7/B+PHjMX/+fBQVFeGll17C4MGD/dZ55ZVXYvLkyXj00UeRkZGBYcOGYe3atVi1ahUWLlyI1NTUpnrKbQorWYiIiIiIiIiIiIgayO4WKLYLnK5QcLBYweFiBUdKFPxaoiDfKuBU2ua8EtR6XXvttUhNTcWzzz6LW2+9FX//+9/x008/4f7778eaNWvwzjvveOdxaYxLL70UH3/8MdxuNx555BF8+umnWL58ecA6ZVnG6tWrsXDhQnz55ZdYuHAhDh48iGeeeQb//Oc/z/ZptlmSaKuzyTSRsrIyREdHo7S0FFFRUS09HCIiIiIiIiIiImpFtGqVSidQ5lBQ6QIcbkAAMOnUPwBQ5QJcijrxebxJQqxJQpiBlS1NxWazIT09Hb169YLZbG7p4VAbV9/+FEpuwHZhRERERERERERERD7sbjVYqXAKlNgF7G7ALQC9rIYqYXr4TToOAFFGdZ4Mqxs4UymQaxWIMQFxJhlRRrYSI2qvGLIQERERERERERFRh+ZbrVLqqVZxutX7jDog3ADo5fpDEkmSEKZXQxi7W6DABhTaFEQYgASzjGgjYNQxbCFqTxiyEBERERERERERUYdTX7VKeJBqlVCYdBJMOsCtCFS6gONlCsI8rcRiTFLQahgiansYshAREREREREREVG75xYC1iaoVgmVTpaCtxIzAnFmthIjausYshAREREREREREVG7ZHMLVDnVapVSh4DNDShNWK0SCt9WYg63QKEdKLAriGQrMaI2jSELERERERERERERtQtuz9wqVT7VKg43IEGtVok0qJUlLc2ok2D0bSVWqsBiUFuJxbKVGFGbwpCFiIiIiIiIiIiI2iQhBOwKWk21SqhqthLL9GklFm+WEWkEdK107ESkYshCREREREREREREbYZbqC3Aqlytu1olFDVbiRXZgUKbgggDkGBRW4mZ2EqMqFViyEJEREREREREREStlhACdrcaqpQ7BcraWLVKqHxbiVW5gPQyBWa92kosxiS1q+dK1B4wZCEiIiIiIiIiIqJWRQsYKj3VKlVOwKEAkqSGKm2xWiVUOllCpKeVmE1rJVYlEG1SW4lFsZUYUavAkIWIiIiIiIiIiIhaVIOqVQwds4JDkiRY9IDF00qs2A4U2xSEs5UYUavAkIWIiIiIiIiojRNCQBGALHXME5BE1Db5VquUOBRYnYBTAdCBqlVC5W0l5pmX5kSZArMOiDdLiGUrMaIWwZCFiIiIiIiIqBUQQsAt1Ku2FQHvv2v+rQgBl1BPRLoUAZei3ieghizhegnhBgkmnXqS0iTzhBsRtQ5atUqlC6hwCpQ61P9r1SrmDlytEiqd5N9KLKtSIK9KIMqoVrdEMaAiOmcYshARERERERE1Ed+gJDAc8Q9KnArgEmpIogUlCtT7hWc54fm/BPXfGknyVK1A/VuWABnqegpsAnlWAQmAQQaMOiBCL8FikGD2BC9GBi9EdI64PNUqVS6gxK7A6lLnVpEl9fjEapWz49tKzKkIlDqAYrunlZhZRoyJrcTaghUrVuC2227Drl27MHr06JYejtfBgwfx0UcfYd68eUhJSWnw43788Uc8++yz2LRpE/Ly8hAeHo6RI0dizpw5uPXWW6HT6Zpv0C2AIQsRERERERGRDy0oCR6OwOc+NShxa3/XCEq0sKS+oESu8W+dXP3vs2n/JTzjcihAnk1AsQpIkhq8mGQg3CAhTK9WvJh16u0MXojobPlVqzgESp2sVjlXDLKEaJOnlZgLSC9XYK5iKzFqvIMHD2LJkiWYNGlSg0OWZcuW4Z577kGnTp1wyy23oG/fvigvL8d3332H22+/HdnZ2fjLX/7SvAM/xxiyEBERERERUbujeOYoqauaxC3U+QBcIrCiRAtGagYlGu0UlSR5AhL4ByV6ufr2lponRZLUvv1Gn4tFtWDIrgAVVgEhBGSp+sRnhEGCWVdd8cLghYgaQqtWqfS0AAuoVjGq7a3o3NBJEiINgNAHthKLN8uINrJ6iJrH9u3bcc899+DCCy/E119/jcjISO99CxcuxO7du3HgwIGz3o6iKHA4HDCbzWe9rqYgt/QAiIiIiIiIiIJRhIBLEbC7BawugQqnQJlDoMQuUGgTyLcK5FQJZFYoOFmu4FipG0eK3filyI0DRQp+KVZw0PPnULGCwyUKfi1RcKxUwYkyBafKFWRWqq21SuxApWfCZQH1l2WjrLZfiTAA0UYgzix5/8R6/sSYJEQbJUQaJUR4KkPMeglGnQSDLEEnS60qpJAlCSadOtZYk/pcooxqmGJzA9lVAifK1NfqoOc1O12hoMAmUO4UcPomTUTUYQmhHpcLbQIZZerx4kiJglMVathi1AGxJiDGpB4XGbC0DLWVmHqstxiAEgdwrFTBoRIFuVUCNjeP6W1NZmYm5s+fj06dOsFkMmHw4MF46623/JZxOBx47LHHMGrUKERHRyM8PBwXX3wx0tLSAtb3wQcfYNSoUYiMjERUVBSGDh2KF154AYDawuz6668HAEyePBmSpP5Ms3HjxlrHt2TJEkiShHfffdcvYNGMHj0a8+bN8/6/srISDz74IJKTk2EymdC/f388++yzEMJ/35QkCQsWLMC7776LwYMHw2Qy4dtvv23wa9LcWMlCREREREREzUapZTJ3/7ZbnooSBXAKAbcCuIRPRYnieQw87bZEddstrQWXNi+JNkeJ5FNRIvtVm/BEX01q8KJWrmi0iherGyh3CCgQ0HlajWkVLxZ99eMMvCKaqN2rWa1S5VKDaVartA0GWUKMST2++7YSizOpFw1EtNFWYkIIKHZ7Sw/Dj2wyNctrmZubiwsuuMAbOCQmJuKbb77B7bffjrKyMixcuBAAUFZWhmXLlmH27Nm48847UV5ejjfffBMzZszAzp07MXz4cADAunXrMHv2bFxyySV4+umnAQCHDh3C999/jwceeAATJkzA/fffjxdffBF/+ctfMHDgQADw/l1TVVUVvvvuO0yYMAE9evSo9/kIIXDVVVchLS0Nt99+O4YPH441a9bgoYceQmZmJv71r3/5Lb9hwwZ89NFHWLBgARISEpCSktLg16S5MWQhIiIiIiKiOgULSoK23/IJSrTWWzUncldQ3X4L8J+npGZQov3R6xiUnGt+wYtBvc0tBJxudfLqMoeAgPCeXDXrgAhPFY/WakzP4IWoTRNCbTWlfebLfeZWMcjq5zyCc6u0ObIkIcIAhHtaiWVXqRWd0Z5WYlHGtnX8Vux2/HTnnS09DD/D3ngDumZoY/Xoo4/C7XZj//79iI+PBwDcc889mD17NhYvXoy7774bFosFsbGxyMjIgNFo9D72zjvvxIABA/DSSy/hzTffBAB89dVXiIqKwpo1a4JORN+7d29cfPHFePHFFzFt2jRMmjSpzvEdO3YMTqcTQ4cObdDzWb16NTZs2IAnnngCjz76KADgvvvuw/XXX48XXngBCxYsQGpqqnf5I0eOYP/+/Rg0aJD3tjvuuKNBr0lzY8hCRERERETUAbhrzFFS279dnqDE1cCgRDsNExCU+MxHopN95yZhUNJW6SQJOj3ge9rIragVLxVOoMQuAK3iRQdYfOZ4MXmCGM4BQNS6uRSBylrmVjHrgCijepKe2j61lZjaFtOpCJQ4gGK7gjADkGBS22Ga9XyvWwshBP773//ihhtugBACBQUF3vtmzJiBDz74AHv37sW4ceOg0+m8oYmiKCgpKYGiKBg9ejT27t3rfVxMTAwqKyuxbt06XHrppWc9xrKyMgAI2iYsmK+//ho6nQ7333+/3+0PPvggPvnkE3zzzTdYsGCB9/aJEyf6BSyhvCbNjSELERERERFRGyCE8IYdtU3irpxFUOINTIK03NImRvetMJHAoITU0EQnBwYvDgUo9wQvAgJ6T/Di12pMBkx6thciaklatUqlS20NyGqVjqlmK7GMCgGzVahzd5mkVr0PyCYThr3xRksPw49sMjX5OvPz81FSUoLXX38dr7/+etBl8vLyvP9euXIlnnvuORw+fBhOp9N7e69evbz/vvfee/HRRx/hsssuQ7du3TB9+nTccMMNjQ5coqKiAADl5eUNWv7kyZPo2rVrQCijtSM7efKk3+2+YwdCf02aE0MWIiIiIiKicyQgKFEAN4JXlrg8FQIuRajzk9QRlAD+7bcYlFBL0skSLDLg25xD25/LnUCxp+JFC17C9ECEQfZWu5h0vFKeqDnVVq2ik9TPH6tVOi7fVmJ2N5BbJZBvFYgyAgmttJWYJEnN0pqrtVEUBQBw8803Y+7cuUGXOe+88wAA77zzDubNm4eZM2fioYceQlJSEnQ6HZYuXYrjx497l09KSsKPP/6INWvW4JtvvsE333yD5cuX49Zbb8XKlStDHmOfPn2g1+uxf//+RjzD+tVs+xXKa9LcGLIQERERERGFQAtK3IpPOIIa85UogILqKpJgQYk3LPH833duEkANR2oGIgxKqK3SyxL0PsGL8Mzz41SAUgdQZFNPlGitxsINQLhe9oYuDF6IGo/VKhQqSZJg1gNmTyuxMgdQ4mklFm+SEMtWYudcYmIiIiMj4Xa7MXXq1DqX/eSTT9C7d298+umnfp/rRYsWBSxrNBpx5ZVX4sorr4SiKLj33nvx2muv4a9//Sv69OkT0nEhLCwMU6ZMwYYNG3D69GkkJyfXuXzPnj2xfv16lJeX+1WzHD582Ht/XUJ5TZobQxYiIiIiIurQfE/2OpTq8MQtggclLkUNQ2oGJb4VJd72W975R/xDEb3sH5wwKKGORpIk6D2hoW/w4vJ8FovtQIFVDV4MsvpHC160ihcjgxeiWgWrVnF65lZhtQqFwiBLiPZpJXayQiDHKhDnCVsiGdCdEzqdDrNmzcJ7772HAwcOYMiQIX735+fnIzEx0bssoH6vau/Njh07sG3bNvTo0cP7mMLCQu9k8QAgy7K38sNutwMAwsPDAQAlJSUNGueiRYvw3Xff4ZZbbsGXX36JiIgIv/v37NmDAwcOYO7cubj88svx+uuv4+WXX8YjjzziXeZf//oXJEnCZZdd1mSvSXNjyEJERERERO2e78lbpwI43YBDEbC5BWwuwCkAl1sNVnzbbjEoITp3JEmCQVIDFY3vZ7fIBuQLxfv5M8jq/C5hevWKa5Pninx+DqkjEkLA6gaqnECZU0G5E7C7AQhAr1MrEiIkfj6o8YK1EsuzCkQbgXizjOhW2EqsLXrrrbfw7bffBtz+wAMP4KmnnkJaWhrOP/983HnnnRg0aBCKioqwd+9erF+/HkVFRQCAK664Ap9++imuueYa/OY3v0F6ejpeffVVDBo0CBUVFd513nHHHSgqKsKUKVPQvXt3nDx5Ei+99BKGDx/unRdl+PDh0Ol0ePrpp1FaWgqTyYQpU6YgKSkp6Pgvuugi/Pvf/8a9996LAQMG4JZbbkHfvn1RXl6OjRs3YvXq1XjiiScAAFdeeSUmT56MRx99FBkZGRg2bBjWrl2LVatWYeHChUhNTa339Wroa9LcJCGEqH+x9qusrAzR0dEoLS31Ts5DRERERERtj/dkrFutSFEDFTVI0a7gdSv+QYpOVtsTaVfU63gCiqjVE0JUB6ZKdbs9g6y2GovQSwgzSNUVLzI/19Q+ORW1skCrVqlyqdWWWrUK2+xRc9MqptyKOr9WgllCjEmCpZlaidlsNqSnp6NXr14wt7N5WFasWIHbbrut1vtPnz6N7t27Iy8vD48//jhWr16NnJwcxMfHY/Dgwbjxxhtx5513AlC/J5966im89tpryMnJwaBBg/C3v/0NH3/8MTZu3IiMjAwAwH//+1+8/vrr+PHHH1FSUoLOnTvjsssuw+LFi9G5c2fvtpctW4alS5fi5MmTcLvdSEtLw6RJk+p8Pnv37sVzzz2HjRs3Ij8/HxERERg5ciRuvfVW3HzzzZBl9YqKiooKPPbYY/jwww+Rn5+PlJQU3HXXXXjwwQf9vrslScJ9992Hl19+OWBbDXlNgqlvfwolN2DIwpCFiIiIiKjN0E6uupTqIMXhFrC61X7zrlqCFL3k8zeDFKJ2p67gxahTK14sesk7xwuDF2qLaqtWEUINGM069XuO+zada1orMYcLMOqBWKOEOHPTtxJrzyELnXtNGbKwXRgREREREbUqNU+W+gUpLngnkNeCFAk+FSmedkEMUog6FkmSYPTM06JRhPAGsrlWASEEZO04IQPhnlZjWsWLgcELtUJORaDS6T+3iktUV6tEc24VagW0VmJCL2D3HHPzbQJRRiCBrcSoA2DIQkRERERE51zNIMXhCVJsPkGKyxOkAAxSiCh0ci3Bi1MB7ApQ4RO8GDzHlQiDBItOgskzx4tRx2MMnVtCqEFKpUutVqlwAnaXelGBUQdYDOpE5EStkSSpFYNmndpKrNwJlNiVc9JKjKglMWQhIiIiIqJmIYTwtvRy+QQpVpentZdPRQoQGKSYdZ4J5RmkEFETkSXJO1eFRgtebG6g3BkYvEQaJJh9Wo3xBDc1tWDVKk6hfh+adEC0idUq1PboZQnRRvUYa3UBJysEcqoEYk0SYj2txLhfU3vBkIWIiIiIiBpNCdLay+4JUuzu6ooUobX2kqpDFIMMWBikEFELqy14cSiA1Q2UOwQEqoMXs0/worUaYxscCoVftYpDQYUrsFolivsUtROyJCHcAITp1eNqnqeVWKRPKzGG19TWMWQhIiIiIqI61QxSHG7AoQQGKYpWkRIkSNHxl2ciakNkn5Y3MKi3uRX1WFjlAso8wYtOqp5wPEKvtsHRAhsGL+TL4VYnBg9WrWJmtQp1AJJPoO3yVG+VelqJxZslxLKVGLVhDFmIiIiIiMgbpDgUwOnW5kkRqPIEKW5FDVOCBSlGGbDoAR1PDhFRO6aTJehkwOxzmxa8VDiBErsAPMGLUQteDBLMuupWYwycOw6tRVKVp1ql3KlepACowRyrVagj08sSonxaiZ2qEMitEogxSYhrQCsxIcQ5HC21V025HzFkISIiaiXcnh8wrS7A5haQof7wqZMBvedkpk6qnq+AEz4TUajcvhUpniBFnWhewK5UBym+rb30nuOOUQeEybzKlojIV7DgxeUJXsprBC8GHRCmA8IM/hUvDKjbD99qlRKHgM2lfq9ybhWi4LRWYuEGtd1svlWgwCYQafC0EjP5txLT69VT2S6Xq6WGTO2Ith9p+9XZYMhCRETUQhSfUKXCKVDu9FwtLtQTmxCAgHplhSSpE0LLUOcukGX13wZPKx6jToJBloIGMdqV5vyFjqhjcAvhDVC0yhRtjhSHEliRIvtWpDBIISI6a3pZgl4GLJ7/CyHgFuoxudQJFHqCF70WvOiBCIPsnd/FpONxuK1oSLUK55ogahiTTqpuJeYCSssUWPRAgllCjElCmF6CTqeDTqdDWVkZIiMjW3rI1MaVlZV596mzxZCFiIjoHFGEejVblVu9uq3MIeBwV/diNurUK3hq69+t/YKuaH+grku41JOqqFHqKknVJ0+1vw0yYJQlGGRWyRC1ZVp7GofvZPMuAatbDVJcCrzHCwk1WnsxSCEiOqckSYLecwyuGbw4FKDEARTZFADqz2IGWf2ZMFwve0MXBi+th1atUuGpVrF75lbRs1qFqElorcSEUD9rpysEcqoEYkxAnElGQmIicnNyYDKZEB4ezt9bKWRCCFRWVqKsrAxdunRpkn2IIQsREVEzUYSAze1TqeKoniBa9gQeYXWEKjVpv6A3hBBqDYxvKKO2BVLHpV7BXh3KyFLwKhm9rF5RxCoZonPPrQi/EMWpADZPkOKsLUjxBKdmvRaw8rNJRNQa+QYvGiEEXJ6f2YrtQIFVDV4MNYIX34oXnlxsflq1SqULKLMrqHD5V6uE8vM8ETWcVKOVWIEVKLQpiNBHwhBuRX5+AfLz81t6mNRGSZKEmJgYREdHN8n6GLIQERE1EeEJVbQ+zGXO6ivbZEmdGPpc/RImSZLaXiyEUEYRPqEMAKsbUJqgSkb2mdOBVTJE/rS+/b5/rC4Bm7u6tZe7RmsvveezxCCFiKh9kSQJBs/PVBrf4KXIBuQLBRI8lYkyEG5QW+iY9Z6KF5k/ZzWFWqtVZPU1jjHxdSY6l7RWYm5FoNIlwWXqBLMlATE6F6IMEiwGfh4pNAaDoUnahGkYshARETWS8KlUqXSp7b9sbvXqcglqSx6LAYhsA6GCJHkqVRqwbF1VMlrri/qqZPSeKzK1KplgQQyrZKi9cAW09lJbB9pqtPYSPhUpvkGKvg0cQ4iIqHn4BS+eMzhCVAf0BTYBRQhI8FS86IBIvXrCUat4MTJ4qZfiaUtUVaNaRcDTZpPVKkStgs6nlZjVrUOOU4dCNxAj1FZiUUb+/kgtgyELERFRAwmhtvtSfwHzD1UAz+SWHeCEaFNUyWgVP24hIDwnBqrXH7xKxiBLMPpUyXiDGFbJUAvzndDYN0ixutT2Xk4BuNyeIAXwfn60aq+OcNwgIqKmI0kSjDr15L/GN3jJswkoVgFJAgyeef8iPBUv2vwuDF7U9kNatUqpQ70Awi3U72eTDojR8zUiaq0kSUKYHgjTq5VnBTZPKzEDkGCWEW0EjDp+funcYchCRERUCy1UsbqBKk/7L6tL/eUVUH9h5VXm9WvqKhkJwlsnI0vqCWtdkCoZo05tXabz9DyvWSWj89xH1BC+7VqcCuB0Aw5FbeulHRe01l7a/qntc3pJvQKWISARETWXYMGLIgRcngsAcq3qhS1a20mTrAYvFr3knd/F0M6DF99qlVK7gkoXYPfMrWLSqfM+sFqFqO0x6tTjn9pKDDhepiBMD8SbJMSY1DCmPR/bqHVgyEJEROQhhIBdUdt/aaGKzXPyVGsVYNIBEQb+kNZcmr5KpjqU0dowyT4VMkGrZCT/k+Oyp9qAJ8jbP2+Q4q6uSHG41Ynm7e76gxQTgxQiImpF5FqCF6cC2BWgwqq2GtN+HjJ5Kl4sOgkmvdpqzNDGQ4f6qlViefKVqN3wbyUGnKkUyLEKxBiBeLOMSCMvsqPmw5CFiIg6LCHU+RCsPu2/rC715KoEQK+rvqqNv3y1To2pkvENZZyKegWjEqRKRvLMJcMqmfZFa6fiUgKDFK39X7AgRXufTToGKURE1HbJUnXLMI0WvFjdQLmzuuLFIKtBi1bxYvJWvLTe70CtWqXSCZQ51GoVbW4VVqsQdQw1W4kV2YFCu4JIgxq2xLCVGDUDhixERNSh2D2tfbyhilu9al1AO3nOUKW98q2SacgPQH5VMlBDGa1KRvHcp52G91bJQA1kvPPFyICRVTLnnG9femfNIMUFuET1ZPOAp+WcXP2eMUghIqKOJFjw4vZ8l1a5gDKHgIAavBh1aquxSIMEsyd4MetaNrjwrVYpsavVp26l+oIptgoi6rh8W4lVuYD0MgVmTyuxWLYSoybEkIWIiNo19cSq/5wqDk/vZb0WqvAHKwqiqapkyuupkpF8Ahlv6zJddZWM1judVTL+agYpDi1IcakVKe56ghSzzjOnD19LIiKiADpJgs4ToGjcSnXwUuoJXvQSYNABFh0QrveveGmu4MUt1J/pK51Aqadaxen5+d7IahUiCkInS4j0aSWWWSmQaxWINgIJbCVGTYAhCxERtStaqGJ1qS0CqnxaBGhXqPNqFWpq57pKRmvhoVXJ6OQgbcvaQZWM1tLPt72Xb5DiEuqVqoqofgyDFCIiouahkyXoZMDsc5tbUb+ry51AsV0AUOd4MeqqW42ZdRLMnuBF18jwI2i1iqj++Z4XTRFRQ9RsJVZsB4ptCsINQIJFRrQRMLGVGDUCQxYiImrTnIrW/ssnVFEAIaorVaL1ahsEotbibKtkXIoaHtZVJSN7wpjaqmR8W5q1ZJWMEqS1l90TpNjd1a29tCClZuWPhUEKERFRi9HJEiwyYPG5zeWpeCl3AiV2/4qXMB0QYZS91S4mXfCfPVitQkTNrWYrsRNlCix6IM7TSozhLYWCIQsREbUpWqhidQHlDgWVbvVks6KFKjIQbWSoQu1HY6tkFFSHMrVVycCz3tqqZAyeuWTOtkqmZpDicAMORaDKVd033SWCBylGGbDoWb5PRETUVuhlCXqf4EV4LgpxKkCpU52AGkB18KIHIgwyzDr1Z4EKp0Cpo7r9p4HVKkTUjHxbidncQFalQF6VQLQJiDfLiGIrMWoAhixERNSquXwqVcqd6lVsNUOVKIYqRF6+VTKGepatr0pGUReCgNq2DCFUybi0ihS3f5AivCU3PkGKDrBwrhkiIqJ2SfLMM1czeHF5gpcSB1BoU6qXh/qzQaSh8e3FiIhCJUkSLHr1Ai+tlViRTUGEQQ1bYkxsJUa1a5Uhy7///W8888wzyMnJwbBhw/DSSy9h7NixQZedNGkSNm3aFHD75Zdfjq+++qq5h0pERE3MpVTPqVLuVFDpVCcPV4R69TxDFaKm01xVMhLUWhlJgrcKxqgDwmR+domIiEj9GcTgqZ7VCM+VGKxWIaKW5m0lJtRWYunlCsxVQLyZrcQouFYXsnz44Yf44x//iFdffRXnn38+nn/+ecyYMQNHjhxBUlJSwPKffvopHA6H9/+FhYUYNmwYrr/++nM5bCIiaiS3J1RRJ7JUUOEbqngmzYxkeS5RqxBKlQwRERFRKHjCkohaG50kIdIACL3aSizb00osyggkWGREseKOPCQhhKh/sXPn/PPPx5gxY/Dyyy8DABRFQXJyMn7/+9/j4Ycfrvfxzz//PB577DFkZ2cjPDy83uXLysoQHR2N0tJSREVFnfX42wu7S+CrVz7D0EvHoW+/Ti09HCJqR7RJLK0utd9yuVN4QxVZUvstG2X+oEJERERERERErYtTEah0qm2QwwxAIluJtVuh5AatqpLF4XBgz549eOSRR7y3ybKMqVOnYtu2bQ1ax5tvvonf/va3tQYsdrsddrvd+/+ysrKzG3Q7tePdr5Cy6zNk/LgRf7/oz5gwpitm9gNiLTxgEFFo3ELA5tIqVdRQxeGZxFKW2G+ZiIiIiIiIiNoGgywhxqS2S670aSUWZ5IQa5YQwVZiHZJc/yLnTkFBAdxuNzp18q+c6NSpE3Jycup9/M6dO3HgwAHccccdtS6zdOlSREdHe/8kJyef9bjbI8sF41EQ2RXxzmLc8v3f8dbXZzBmGXDL5wo+OKggs0KgyKaeLLW5BZTWVRBFRC1IEQKVToECm8DJMgUHixQcKlZwvExBgU2dQDvcAMSZJcSYJITpJQYsRERERERERNRmyJKESIOEOJN6AWl2lcCvxQqOlSoosgm4FZ4r7UhaVSXL2XrzzTcxdOhQjB07ttZlHnnkEfzxj3/0/r+srIxBSxBj+sfA9fT/4sDixxGTl4O///okHuv7MDafTMHmk0CMWWB8T4HJvQVSY9UJbU06wKKTYNJJMHgmuDXI6h9OckvUfimeShWrW61UKXOolSouoU56bdKpoYqeQQoRERERERERtSOSJMGiByx6tZVYiQMosisI97QSizYBZrYSa/daVciSkJAAnU6H3Nxcv9tzc3PRuXPnOh9bWVmJDz74AI8//nidy5lMJphMprMea0egj4zE4CWL8OuSJUBODv5x9HGsvuB+fC6GocQm4csjEr48AqTGqWHL+B4C4SahNiWEenJVL6kBjFkHWPQSjLLkF74wgCFqexShTvhmdQGVToEyp4DdBTg9E9UbZLUvKUMVIiIiIiIiIuoofFuJVfm0Eos1SYgzSYgwsJVYe9UqJ74fO3YsXnrpJQDqxPc9evTAggUL6pz4fsWKFbjnnnuQmZmJ+Pj4Bm+PE9/Xz1lejiOPPw5HTg6g08Fx6bXY1ftS/JBpwM4zgEtRDw46SWBsd2B6H4ELugM6WcClqFezuxR1/gVtb5MlQC+rIYzJE8BoFTDaH6PMAw9RayB8QxWXQKlDnajepahhqtFbucbPKxERERERERERoJ5PsXvOp8gSEG0E4s0yooy8MLUtCCU3aHUhy4cffoi5c+fitddew9ixY/H888/jo48+wuHDh9GpUyfceuut6NatG5YuXer3uIsvvhjdunXDBx98ENL2GLI0jKOsDL/+7W9q0CLLMEyaBtvkK1EmR2B3poT1xyX8Wlh9cIgyCUzupQYu/eLVE7G+3ELAHWIAY5T9K2AYwBA1j5qhSrlD/b9TASQABp362dRL/BwSEREREREREdXHqQhUOQFFqN0/EkzqPLVmPc+rtFah5Aatql0YANx4443Iz8/HY489hpycHAwfPhzffvstOnXqBAA4deoUZFn2e8yRI0ewdetWrF27tiWG3CEYo6LQ9+GHcfSpp+DIyYEzbS0iqsoRPuUKTO7dFdP6ChRWAOuOy1h/AiiskrDqMLDqsISeMQLTUwUuSQUSwtT16SQJOh1gDLIttyLgFmoAU+4EShwCQghIUAMYnSeA8bYgYwBDdFa8V1a4Pe2/goQqZj0QwVCFiIiIiIiIiChkBllCtE8rsYwKAZNVII6txNqFVlfJcq6xkiU01pwcHH/uObWiRZIQNmwYzJOmoyy5P6oUHcKNgEGSsDcbWHtMwvenAIdbPUDIksDILmp1y7gegKkREZ9bEXAJtfLFpQBuBdB2YJ1PBYxZB5iDtCBjAEPkCVUUtVKlyjOnis0FOBT1fqMO3uCSnxciIiIiIiIioqZVs5VYlKeVWDRbibUabbpd2LnGkCV0lRkZOPHvf8PpCVosAwYgatx4OAeOQKEUBrcCRHoOCBUOYFOGGrj8kld9gAgzCEzqBUxPFRicFNhOLFRCCCjCv/1YrQGMHrDo1AoYbe4XA1sfUTsmhIBD8Z+o3uZSK1UAQK8DTAxViIiIiIiIiIjOOaeiVrcoCmDRAwlmCbFsJdbiGLKEgCFL45QeOoRTb73lDVrMffsieuRImIaNRHFEEorsanARoa8+aZtZBqw7LmHdMSC3svog0S1SYFofgWmpQKeIph9rXQGMBDWA0clqCGPWMYCh9sHuFmqliktt/2V1Aw63us/rZXVOFYYqREREREREREStg9ZKzOECjHogzqSGLZFsJdYiGLKEgCFL4wghULRvH7Lff19tHQbA0r8/wnr3RvTIkXD26IscK1DlBMKMgFlXfSBQBPBzjhq4bMoAbK7q+4Z1VudvmZACWAzn5nm4fduP1RLAGGS1AsYse+aA0VW3H2MAQ62Bw61+EVe51EoVqwtwutV92SBXtwDjvkpERERERERE1Hr5thKTPK3EEthK7JxjyBIChiyNp7hcKNi2DXlffAFHdjYAIGzwYBgSExE9aBDChw5DAczItwq4fFqI+bI6gS0n1cDlx2xAnd4eMOsFLu6pzt8yrLPam/Bc0wIYlyd40f4GAgMYi14NkoyyBIMngDHK6jI8qU3NweFWq1OsLqDMoahXOrjV+3SeShWGKkREREREREREbZdLEah0qeckwzytxGJMEixsJdbsGLKEgCHL2XHb7cjbvBmFaWlwnD4NAAgfOhS6mBiEJScjfswYOKLjkVOpqC3EZCCilhK33Apg/XFg7XEJmWXV9yeFC0xNVQOX7q3kLfINYHwrYIDqAEavAwwSYNZLsOgBg+zTgkxm8kyh0fpz1gxVBPzbf8kMVYiIiIiIiIiI2hVFqF1L7C61W0msSUKcma3EmhNDlhAwZDl7zvJy5KSloWz3btjT0wF4gpb4eBgiIhA3ahTCevdGsUNCTpWCSgcQZkCtkzcJARzKB9Yek5CWDlQ6q5cblCgwvY/ApBQgwnQunl3ovAGMVv1SRwBj0Usw6wGjLEHPAIZ8OBX1y1MLVSo9E9UrAt59xahjqEJERERERERE1FEIIWBX1CkaZEntHJRolhFlVC/wpqbDkCUEDFmahi0/H7kbN6Lq0CFYjx4FAEQMGQJDcjIUux3RgwcjdtgwuPVG5FkF8upoIebL4QK+Pw2sOyZhdxagCHVZgyxwUQ9gRh+BUV3V9khtQUAA4zlpDgCQPAGM5wS6WaeW/mlzvxgYwLRrLp9KlXKHgkrPRPUMVYiIiIiIiIiIqCbtXJLL00os3iwhlq3EmgxDlhAwZGk6ladOIW/zZtjPnEHVL78AAMIHDkTYoEGw5+UhPCUFcaNHwxQXhwqnQHYDWoj5KqwCvjuhVrhklFQvG2cRuKS32k6sV2yzPsVmJYTwm//F5RPASBKg9wQwhiABjFYBo2MA02a4tEoVtxqqVLiqQxWd5z01MVQhIiIiIiIiIqI6aK3EbG7AJAMxPq3EeF6p8RiyhIAhS9MqO3IE+d9/D3dJCSr27QMAhPXrh8jRo2HNzIQxJgZxo0YhPCUFAkCRHcipUlDhAMLraCHmSwjgWJEatmw4AZTaqx/TN15geqrAlN5AtLm5nuW5pwUw2vwvvgGM7FMBY5CBMJ0Ek95//heDDtDxoNqi3IpAlWei+nKngkonYK8Rqhj5PhERERERERERUSPZ3QJVTvWC7UgDkGCREc1WYo3CkCUEDFmalhACxfv2oWjvXsBmQ9nOnYAQsKSmIvqii2DPz4dwuRAzdChihgyBbDTC4RYhtRDz5XQDOzPVwGXHGcClqI/TywLndwempwqM7a6GDO2VEqQFmRDqhOhyjRZkFk8AY/RtQcYT+83CLarnVCl3KqjwCVVkSa1SMbL6iIiIiIiIiIiImliwVmIxJglhbCXWYAxZQsCQpekpLhcKtm9H2cGDkBQFpT/8AAgBc0oKYidMgKuiAvaCAkSkpiJu1CgYo6MBwNtCrNiuhgINaSHmq9QGbEhX52/5tbD6cdEmgcm91cClb7ya5HYUIQUwegkmnSeA0VW3IWNZYcO4hYDNBVS51H253CngcKuvu05Sq1RMDFWIiIiIiIiIiOgc0VqJ2d3qeb5oExBvltlKrAEYsoSAIUvzcNtsyNu8GVUnT0KWZRRv3gwoCszJyYidNAnC7Yb1zBkYExMRP2oUwpKTAagf/GI7kB1iC7GaMoqBtcclfHccKLRWPz4lRmB6H3UOl/iwJnu6bZIihF/7Mbfwb0Gml9Q2ViZZfQ/MOslb+aJVwnTkg7HiU6mihSp2t/o6ygxViIiIiIiIiIioFQloJWaWEW1iK7HaMGQJAUOW5uMsK0Puxo1wFBZCkiQUp6UBigJTt26ImzwZkGXYcnIAADHDhyN64EDIej0AnFULMV9uBdiTpbYT+/4U4PS0E5MlgdFdgWl9BMYlA0Z90z3v9qBmAOMSagWMBPVA7A1gdJ4WZDoJRp1PC7J2GMAoWqWKG6h0CpQ51EoVZ432X43ZT4mIiIiIiIiIiM4F31ZiFj0Qb5IQZ5ZgYSsxPwxZQsCQpXnZ8vKQu2kTFLsdshAo2rABwuWCsUsXxE2ZAtlggKOkBM6iIkT064e4kSNhiIz0Pv5sW4j5qrADGzOAdccl/JJXvY5wg8CkXsD0PgKDEjtWO7HG0AIYrf2YFsAA/hUwZp3agswot80ARhECNrdPpYpDrVRxeUIVgydkYqhCRERERERERERtjRACVs+5rygDMDBWbvR51/aIIUsIGLI0v8qTJ5G3eTNksxlwOlG0fj2E0wljUhLipk6FbDTCbbfDeuYMzJ06IX7MGFi6dvU+3q+FmBMI1zeuhZivM2Xq3C3rjgN5ldXr6hYlMC1VYFoq0CnirDbRIfkGMFoljF8AI6shjElXPQeMb/hilBsfop0t4QlVqlxAlUug1CFgd1VXqhhleMIiftkQEREREREREVH7UOUSkAEMiWPI4oshSwgYspwbpQcPomDbNhjj4yFsNhSuWwfhcMCQkID4adMgm0wQigJbVhYkvV5tHzZgACSdzrsO3xZiTgWIamQLMV+KAH7KUduJbTkJ2Fzq+iQIDO8CTEsVuLgnYDGc1WYI6sTw7gYGMGF6CUad5J37RfvTlAd64VOpUulS23/Z3OrYJKiBilGnjolfMERERERERERE1B4xZAmOIUsIGLKcG0JRULxvH4r27oWla1colZUoXLsWit0OfVwc4qdPh85sBgDYi4rgKitDVP/+iB05Evow/xnqm7KFmC+rE9hyUg1cfsypXp9ZLzChp9pO7LzOaiBATcutCLX9mE8AA58ARucJYLwtyBoRwAihtvvSKlW0UMXpCVUMOk/7L4YqRERERERERETUQTBkCY4hSwgYspw7itOJgu3bUXboEMJ69oS7vByFa9ZAsdmgj4lRgxZPoOK2WmHNyoKlWzfEjxkDc1KS/7qaoYWYr9wKYN1xtaVYZnn1ejuFC0xNVQOXbtxdmp0QAoqAfwCjePMX6HwqYMx6wKJTA5jquV+gtgBzCpQ5BawuNVQBPJUqzVAhQ0RERERERERE1FYwZAmOIUsIGLKcWy6rFfmbN6Py1CmEp6TAXV6OgjVroFRVQRcVhYQZM6ALDwcACLcb1sxM6MxmxI4cici+fSHJst/6HG6BfKtAbhO2EPMlBPBLHrD2uISN6UCVs3rdg5MEpvcRmJgCRBibbJPUQL4BjFb9UjOAkSX1PgFPpQpDFSIiIiIiIiIiIi+GLMExZAkBQ5Zzz1Fairy0NDiKixHWowdc5eUo/PZbuCsroYuIQPyMGdBHRnqXtxcUwF1ZiahBgxA7fLi3rZivCqdATpWCIpvaWiqyiVqI+bK7gB9OqYHLnixAEer6jTqBcT3U+VtGdVW3Ty1LCKHO+QK2/yIiIiIiIiIiIqoNQ5bgGLKEgCFLy7Dl5iJ340YoLhcsnTvDVVGBwjVr4C4vhxwWhoRLL4Xe5/1wVVXBlp2NsB49ED96NEwJCQHrbO4WYr4KqoDvTqjtxDJKqrcRbxG4JBWYniqQEtssmyYiIiIiIiIiIiJqEgxZgmPIEgKGLC2nIj0d+Vu2QBcWBmNsLNxVVShcswau0lLIFgviZ8yAISbGu7zicsF65gz0kZGIGzUKEb17B/3gN3cLMV9CAL8WAmuPSUhLB8rs1dvpF6+2E5vcC4gOLL4hIiIiIiIiIiIialEMWYJjyBIChiwtq/TgQRRu3w5jfDz0ERFwW60oXLsWruJiyCaTGrTExXmXF0LAnpcHxeFAzJAhiB46FDqTKei6z0ULMV9ON7DjjBq47DgDuD3txPSywAXdgWl9BM7vrk7UTkRERERERERERNTSGLIEx5AlBAxZWpZQFBTv3YuivXth6d4dOpMJit2OwrVr4SwshGQ0In76dBhrtAdzVVTAlpuLiN69ETdqFIyxwXtz1WwhFqYHLM3UQsxXiQ1IO6HO33K0sHp70SaBKb2B6X0E+sQBPG4RERERERERERFRS2HIEhxDlhAwZGl5itOJgm3bUHb4MMJ69oSs10NxOFC4bh2c+fmQDAbETZ0KU6dOAY+rOnMGxthYxI8ahbCePWs9EGgtxPI8LcQim7GFWE0nitW5W9YfB4pt1dvsFSswPVXgkt5AXNg5GQoRERERERERERGRF0OW4BiyhIAhS+vgslqRt3kzqk6dQnhKCiRZhuJ0omj9ejhycyHp9Yi75BKYunTxe5wQAracHAhFQczQoYgZMgSywVDrdrQWYsU2QD4HLcR8uRVgd5baTuyHU4BTUbcrSwKjuwHTUwUuSgaM+nMyHCIiIiIiIiIiIurgGLIEx5AlBAxZWg9HSQnyNm6Eo6QEYcnJANTJ7os3bIA9KwvQ6RA3ZQrM3boFPNZZVgZ7QQEiUlMRP3o0DHW8ly3VQsxXuR3YlKEGLgfzq7cdYRSYlKK2ExuYyHZiRERERERERERE1HwYsgTHkCUEDFlaF2tODvI2bYJwu2H2tAcTLheKNm2C/fRpQJYRN2kSzD16BDzWbbfDmpkJc2Ii4kaPRlj37nVuqyVbiPk6XQqsOy5h3XEgv7J6+92jBKb3EZiaCiSFn/NhERERERERERERUTvHkCU4hiwhYMjS+lSkpyNvyxbow8K8E9oLtxvFmzfDdvIkIEmInTgRlpSUgMcKRYE1OxuSLCN22DBEDRwIWV93/61Kp0B2C7UQ86UI4MdsYO1xCVtPAjaXOgYJAsO7qNUt43sAltq7oRERERERERERERE1GEOW4BiyhIAhS+tUcuAACnfsgCkxEfpwtYxDKApKtm6F9cQJQJIQM348wlJTgz7eUVICZ3ExIvv1Q9zIkdBHRNS5PUUIlNiBrBZsIearyglsyVADl59yqsdh0QtMSFEDl6GdgBYovCEiIiIiIiIiIqJ2giFLcAxZQsCQpXUSioLC3btR8uOPsHTvDp3J5L29dNs2VB09CgCIvugihPfrF3QdbptNbR/WpQviR4+GpUuXerfrVATyqlq+hZivnHJg3XE1cMkurx5L5wiBaanAtFSBrtx1idoVuwsQAMx1F+IREREREREREZ0VhizBMWQJAUOW1ktxOJC/bRvKf/0VYT16eNt+CSFQun07qo4cAQBEn38+wgcODLoOoSiwZmZCNhoRO2IEovr3hyTL9W67ZguxCAMgt/BBRgjgQB6w9piETRlAlbN6PEOS1PlbJqQAEcYWGyIRhcCtADkVwJky4EwpcKZMUv9dVj0/U2K4QPcoeP4IdI9W/905AtDVfygjIiIiIiIiIqoTQ5bgGLKEgCFL6+aqqkLe5s2oOn0a4Skp3oBECIGy3btR+csvAICo0aMRMWRIreuxFxbCVV6OqP79ETtyJPRhYfVuWwiB4lbUQsyXzQX8cApYc0zCvmxAEeq4jDqBcT2AGX0ERnThSViiliYEUGjVQhQgUwtSSoGscsAtGndM0UkCXSPhDV26RXnCmGgg3gLwZyIiIiIiIiIiagiGLMExZAkBQ5bWz1FSgtyNG+EsKUFYcrL3diEEyvftQ8XPPwMAIkeMQOSwYbWux221wpqdDUu3bogfMwbmxMQGbd+pCORbBXKrWk8LMV8FlcD6E2qFy6nS6nElhAlc0ludv6VnTMuNj6gjqLADZ8qBzBoVKWdKAaur9uOFSSfQTatUifZUq0QB3TxfR5naesokn6AGsLtrX6dZ71P9Eu1TARMJRJia+pkTERERERERUVvGkCU4hiwhYMjSNlizs5G3aROEosDcqZPffeU//YTyffsAABHnnYfIESNqPSAoLhesWVnQWyyIGzkSEX36NKh9GNA6W4j5EgI4UgisOyZhQzpQbq8eW/8EgempApN6AdHmFhwkURvmcKnVJ2eCBB8lttqPBbIk0CUC6Bbt0/bLE4AkhAGhZraKAAqqqqtjtFAnsxTIrqiubAsmxiwCAp3uUUDXSMDI+V+IiIiIiIiIOhyGLMExZAkBQ5a2o+LECeRt3Qp9eDiMMTH+9x04gLLduwEA4YMGIWrMmDoPCrb8fLgrKxE9ZAhihw+HztSwy7u1FmLZVQrKW1kLMV8ON7DjjFrdsvNMdUsivSxwQbLaTmxMN0DPdmJEftwKkF8JnPZWokje6pHcCkCg9s97vKV6zpSa86cYdOdm/E537fO8FFbVPnYJAp0i4FNVUx3AJIWz9SARERERERFRe8WQJTiGLCFgyNK2lOzfj8KdO2FKTIQ+PNzvvspDh1C6YwcAIKx/f0RfcEGdBwZXZSVs2dkIS0lB/OjRMMXHN3gcrb2FmK9iK7DhBLD2uITjRdVjjDELTOkNTE8V6NPwp07U5gkBlNh8KlJKJW9brswywKnU/lkOMwgkB6lI6RYFhBnO4ZNohCqnp/1YjQqY06VAlbP252yQBbpq4UuNACnGzPlfiIiIiIiIiNoyhizBMWQJAUOWtkUoCgp37ULJTz/B0r17QAVK5a+/ovSHHwAAlj59EHPRRXW2A1NcLlhPn4Y+Ohrxo0YhvFevkA4mlU6BnCoFhXZAJ7W+FmI1nShSw5bvjgPFPu2NescKTO+jzuESa2nBARI1odpChTOlQGU9oYJW0dGtRlVHewwVziZ0CjfUqN5pQ6ETERERERERETFkqQ1DlhAwZGl7FIcD+T/8gLJff0V4z56Q9f4TCVQdP46SrVsBIWDp3Rsx48fXGbQIIWDPy4PicCBm6FBEDxnS4PZh2uOL7UBOlYKyVtxCzJdbAXZlqoHLtlPVJ1FlSW0jNr2PwIXdOUcDtX5ae6zTpf7zpGSWAYXW+ttjBZufJJHtsby09mnB5qFpSPu0bkFe3y6R5659GhERERERERHVjSFLcAxZQsCQpW1yVVYib/NmVGVmIrxnz4AQxZqRgeJNmwAhYO7ZE7ETJkDS1X1Wz1leDnt+PiJ69ULc6NEB877Up2YLsQgjYGilLcR8ldmBjenq/C2HC6rHG2kUmNRLDVwGJLS/q/ep7eBE762Tw6W+/jUDrjNlQImt9vdElgQ6R1S3H+sW7R9wtYHDJhEREREREVG7wZAlOIYsIWDI0nY5iouRu3EjnKWlCEtODrjfdvo0itLSAEWBqXt3xE2aBElf91lVxelE1enTMMXHI27UKIT37BnyuNpaCzFfp0qAdcclrD8O5PtMkp0cJTCtj8C0VPUkKFFzKLXB26bK94R9Zhlgd9f+GbLofVtWqWFKt2igeyQQ0fCiNGpCFXbgTLkahHnbtHlatVldtb+XJl11qzbfYKxbFBBtPodPgIiIiIiIiKiDYMgSHEOWEDBkadusWVnI27QJAoA5KSngfltmJoo2bADcbpi6dkXslCkB7cVqEooCW04OhBCIPe88RA8eDNkQ2uQCbbGFmC+3AvyYA6w7JmHLyeoT3BIERnRRq1vG9wTMrASgENlcPkFKjRPw5fbaPyM6SaBrJKrDFJ/qhzgLK63aCiGAIqv//C9akJZVDrjqmP8l0iT8gjRtX+gaCVg4/wsRERERERFRozBkCY4hSwgYsrR95cePI3/LFugjI4O2+LJnZ6Pou+8gXC4YO3VC3NSpDQpNnKWlsBcVIbJPH8SNGgVDZGTIY/O2ELMKON1tp4WYr0oHsPmkGrj8nFs99jCDwIQUYHqqwJBObPFD1dyKOk9KsCAlv7LuHSUxPPiJ9M4RnCelvXMr6jwvpxuz34Sp+0q3KJ+2cNHqfqPnfkNERERERERUK4YswTFkCQFDlrZPCIGSAwdQtHMnTElJ0IeFBSzjyMtD4bp1EE4nDImJiJ86FXIDJrd32+2wnjkDc1IS4saMQVi3bo0ao9ZCrMiuhhFtqYWYr6xyYP1xtaVYdnn1+DtHqK3EpvVRqw2o/RMCKLTCp6WX5A1VssoBdx3zpET5ViT4VKR0jWJ1FAVncwFZZYEVMGfKgLJ6KqC6RALJnrCum08AE88KKCIiIiIiIiKGLLVgyBIChiztg3C7UbhrF0p+/hlhycmQjcaAZRwFBShcuxbC4YAhPh7x06ZBNtff5F8oCqxZWZB0OsQOH47ogQMh6XShj7GNtxDzJQRwIA9Ye0zCpgygyln9PIZ2Epieqla5hAe+DdTGVNh9Tmz7zJNypgywNWRujWifqhTOrUHNIGAunzJtLpi65/Ix633DPp8KmCjO5UNEREREREQdB0OW4BiyhIAhS/vhttuR/8MPqDh6FGE9ewade8VZVITCtWuh2GzQx8Yifvp06CyWBq3fUVwMR0kJovr3R9zIkdCHN24GeN8WYg43ENkGW4j5srmA708Ca49L2JsFCKjPxaRT522Z3kdgeGe2emrNHC61+iRYmFJiq33flCWBLhFQJ5mv0aYpIYwt5KhlKQIorKpuW3faJ4DJrgCUOqqtYsyekLBG27pukYCR1VZERERERETUjjBkCY4hSwgYsrQvrspK5G7aBFtWFsJSUoIeGJwlJShcswaK1Qp9dLQatDQwMHHbbLBmZcHSuTPixoyBpXPnRo+1ytNCrLCNtxDzlV9Z3U7sVGn1c0kIE5iaqs7f0iOm5cbXkbkVIK8y+ITjuRXV4Vgw8WG1z5NiCL2oi6jFOd21zxtUWFX7Z0GCQFK4T4WWT7u7pHCGyURERERERNT2MGQJjiFLCBiytD/2oiLkbdwIZ3k5wrp3D7qMq6wMhWvWwF1ZCV1kJOJnzIA+IqJB6xeKAuuZM9CZTIgdNQqRfftCkht3Zq09tRDzJQRwpECtbkk7AZQ7qp/TgASBaX0EJvcCotiSp0kJAZTYgp84zioDnErt+1a4oTo8SY6uvoq/WxQQZjiHT4KohVU5q9uPZfoEkqdLgUpn7Z8hgyzQ1RtG+geSMWbO/0JEREREREStE0OW4BiyhIAhS/tUlZWFvI0bAVmGOTEx6DKu8nI1aKmogC48XA1aQtgH7IWFcJWXI2rgQMSOGAF9A9uOBdPeWoj5criB7afV+Vt2Zla36DHIAhcmq+3ERncD9LwCvMG8J4FL/eehONOAk8C+4YnvVfg8CUxUNyGAUnv15+50qeQXxtQVYoYZRNC5X7pFce4qIiIiIiIialkMWYJjyBIChiztV/mxY8jfuhWGqCgYoqODLuOurETBmjVwl5VBDgtD/PTpMMTENHgbrqoq2LKzEZacjLjRo2sNdBqqPbYQ81VsBb47Aaw7JuF4cfXzijELXNJbDVxS41pwgK2I0w1kB5knJbMMKLTW3c6oU0TwybwT2c6IqFm4FbVdYrB5jeprxxdnCR7AdIlkOz4iIiIiIiJqfgxZgmPIEgKGLO2XEAIlP/+Mwl27YO7UCfqwsKDLuauqULh2LVwlJZDNZsTPmAFDbGyDt6O4XLBmZkIfHo64UaMQkZp6VgckIQRKHEB2ZftqIVbTsUK1ndiGE/6Tq6fGCkzvIzClNxDb+OKgNkERQEGV2oZInZC7ur1XTgMm5tZOzCb7TDjfJYITcxO1Jg4XkF0RvPKs2Fb7Z1yWBDpHVLcf6xbtH5i2k2JHomYnBOBU1M+izV3jb5dacVvzb5cCmHTq96lZ+1sPGHX+f5v0nuV0vIiBiIiIiNouhizBMWQJAUOW9k243SjcuRMl+/cjLDkZsjF4Xxa3zaYGLUVFkEwmxE+fDmN8fEjbsuXlwW21InrwYMQOHw6d6ewmHGnPLcR8uRRgV6baTmz76eqWOzpJYGx3YFqqwAXJ6gmMtqrUVj3Hg+8V7pllgN1d+3tq0VfP6aDN8dAtGugeCURwPhuiNq/C4dv6rzpkPVMKWF21HxuMuurWfzXnf4kysfUftX5CqN//djdgdwX52/NvLRCpvk0Kupzv38FCk7ouWmgqBll4QxdTkEDGL7DxBjcCRh38Hlfr3z7/boc/DhIRERFRC2LIEhxDlhAwZGn/3HY78r//HhXHjiE8JQWSLvjZesVuR+G6dXAWFEAyGNSgJcT2X67KSthychCekoK40aNhijv73ldVToEcq4JCW/tsIearzA6kpavtxA4XVD/HSJPA5F7A9FSB/gmt8wSi1QlklSPopPPl9toHrJcFukai+oSpz9XqcZbW+VyJqHkJARRZfdqPearcMsvU44yrjvlfIo2eAEarcvOEL10jAYvhHD4JapNciieYqKPqIzDYkGoNSeq67VwEHzXJkggaXtQMRHSSJ6Sp57k76rhQojl5A516whj/v4M/97puM+oY6BARERF1BAxZgmPIEgKGLB2Dq6ICuZs2wZaTg7CePWs9YCgOB4rWr4cjLw+SXo+4adNg6tQppG0pTiesZ87AEB2NuNGj1WDnLA9QNVuIWfRAWDtsIebrZIla3bL+BFBYVf1ce0Sr7cSm9gYSws/tmNyK2sZLa+91pkzyXoWeX1X3+5EYXh2eJPsEKZ0i2GKEiBrOrajzvASb/yWvsp7jUJgaunSL8pn/JRroHAHoeRxqtdxK7W2tag9EpNqXryX8sLlaJviQIBoeFvjdVkfQUMvferlpL15QRO3VM7W9R95gKlgQVUdlj7OOcLU5GXWB4Uzd1TnqY+pqr1ZbxQ9/nyciIiJqGQxZgmPIEgKGLB2HvbAQuRs3wlVZibBu3WpdTnE6UbRhAxzZ2WrQMmUKTF27hrQtIQRsubkQTidizjsPMUOG1NqqLBQuTwuxnHbeQsyXWwH2Zavzt3x/srq9liwJjOgCTO8jMK6H+gt6UxACKLTCp6VX9fwJWeWAu44TUFGm6vDEtyKla1TTjY+IqDY2l6eirtS/AuZMGVBWR0WdThLoEglv6OINYKKA+DCe+AzGrdReoVF3FUfoVR91fe80F9/go755SXz/9quWaGBwYmji4KO9ciuegCyE/U4NeaSAIC7Y430rdloq0DHpRB3BTW0BmggxnGOgQ0RERFQTQ5bgGLKEgCFLx1KVmYm8TZsg6XQwJSTUupxwuVCUlgZ7ZiYgy4ibMgXm7t1D3p6zvBz2vDxE9O6NuDFjYIyOPpvhe3WkFmK+Kh3A5gw1cNmfW/18wwwCE1PUwGVIUsN+ca6wB78S/EyZekKiNiad8ExC7TMXQpR6ZXi0+eyfIxFRcwiYG6oMyPQc9+qaG8qs95//RavE6xYFRLayuaG0k9BnW/XRkLCkrpZtzSnghHKNk8jBAxFRZyVBsL8NPAndobX3z5IEn7lwQpoPp54QkZ8lIiIiaqMYsgTHkCUEDFk6nvKjR5H//fcwREfDUMd7LtxuFG/cCNvp04AsI3biRFh69gx5e4rTiarTp2GKj1fbh/XocTbDrx5fB2wh5iurDFh3XMK640BORfXz7hIpMC1VYFoqEG+pnifltM88KZllQImt9tdKlgS6RMBn0vnqeQ3iw9ifnIjaD0UAhVXB55PKLq+7fVSM2TeA8Z//xaSvXn+9VRsNvPre90r7YCdxefU9UdvT4KqwJpgLqK1UhZnqaLlWV6s2VoURERFRYzFkCY4hSwgYsnQ8QgiU/PQTCnftgqVLF+gsltqXVRQUb94MW0YGIEmIvfhiWHr3Dn2bigJbTg4gBGKGDUP0oEGQDU0zA7HWQizXKmDvIC3EfCkC2J+rzt+yOQOw+lShSBAQqP21iA/zae/lc4Kwc4R65SERUUfmUoCc8uoqv9M+7ccK65iHSoJAuLH9zCMR7OQmJwYnantcSj1z6LTx+Y1kSa3QCTcCfeKAQYkCg5KAAQmApWl+7SAiIqJ2iiFLcAxZQsCQpWMSbjcKduxA6f79COvZs87AQygKSr7/HtbjxwFJQsy4cQjr06dR23WUlMBRVITIfv0QN3IkDJGRjX0KAapcAjlVagsxSQIiO0gLMV9WJ/D9KTVw2ZcNCEgINwgkR1fPk6Jddd0tCgjjL5xERI1idVaHL5k+87+cLgUqncG/ewxyCBOVB2vP08CqDwYfRNTStEDHXkdFXlNU59jd9Qc6siTQKxYYlAgMShIYlKhWHHawXxOIiIioDgxZgmPIEgKGLB2X225H/pYtqEhPR3jPnpB0tZcuCCFQum0bqn79FQAQfeGFCO/fv9HbtZ45A3OnTogbMwZhXbs2aj21jbNmCzGLDh3yAFliUyexjzHzl0gionNFCPX4W26vMVeIDtDJLT06IqL2RQhPoOMTupRYgUP5wMF8CQfzgfzKwB+EY8wCAxOBgYlq6NKf1S5EREQdGkOW4BiyhIAhS8fmLC9H3ubNsOXkIKxnzzoPJEIIlO3cicpDhwAAUWPHImLQoEZtVygKbFlZkPR6xAwfjugBA+oMeULV0VuIERERERERUFAJHNRClzzgaGFgK0dZEugdCwxK8rQZSwS6sNqFiIiow2DIEhxDlhAwZCF7QQFyN26E22qFpZ6qEiEEyvfsQcWBAwCAyJEjEXneeY3etqO4GM7SUkT174/YESOgDw9v9LqCYQsxIiIiIiLSONzAscLq4OVQHpAfZJ6tGLPwazHWL0Gdl4qIiIjaH4YswTFkCQFDFgKAqjNnkLdpEyS9HqaEhDqXFUKg4qefUP7jjwCAiGHDEDl8eKMPQm6bDdasLFi6dkX86NEwd+rUqPXURmshllOloMyh/nLUUVuIERERERGRv7xK4GBedbXLsSLAVaPaRScJpMYBA32Cl84RrHYhIiJqDxiyBMeQJQQMWUhT/uuvyPv+exhjYmBowL5Qvn8/yvfsAQBEDBmCyFGjGn0gEm43rJmZ0JnNiB05EpF9+0KSm7Z5PVuIERERERFRfRwu4GiRT/CSDxQGqXaJNYvqFmNJQL94dS4uIiIialsYsgTHkCUEDFlII4RA8Y8/onj3bpi7dIHOYqn3MRUHD6Js504AQPjAgYgaO/asDkb2ggK4KysRNXAgYkeMgM5sbvS6amN1CWSzhRgRERERETWAEJ5ql3zgUJ6EX/LVlmNuEVjt0iceapsxT/CSFM5qFyIiotaOIUtwDFlCwJCFfCkuFwq3b0fpwYMI69EDssFQ72MqjxxB6bZtAICwfv0QfeGFZ3VAclVVwZaVhbCePRE/enS97csaQwiBUgeQXaWg1A5YDGwhRkREREREDWN3Ab8WVgcvB/OBImvg7xLxFoGBWrVLolrtYmS1CxERUavCkCU4hiwhYMhCNbntduRv2YKK9HSEp6Q0qG1X1bFjKPn+e0AIWFJTETNu3Fm1+1JcLljPnIE+MhJxo0YhonfvZjnIsYUYERERERGdLSGA3Ao1dNHmdjleFFjtopcF+sSp1S4DkwQGe6pdiIiIqOUwZAmOIUsIGLJQMM7ycuRt3Ahbfj7CevRo0AHGmp6O4s2bASFgTklB7IQJZxW0CCFgz8+H22ZDzJAhiDnvPOhMpkavry5sIUZERERERE3J5gKOFlbP7fJLHlBiC/wdIyFMrXIZlKT+3SceMOpaYMBEREQdFEOW4BiyhIAhC9XGXlCA3LQ0uG02WLp2bdBjrCdPonjTJkBRYE5ORuykSZB0Z/cbgquiArbcXIT36oX40aNhjI09q/XVhi3EiIiIiIiouQgBZFcAhzyhy8F8tdpFqVHtYpB95nbxBC+JrHYhIiJqNgxZgmPIEgKGLFSXylOnkLd5M2SjEab4+AY9xnbmDIo2bAAUBaZu3RA3eTIk/dk1HlacTlSdOQNjbCziRo5U25g100GPLcSIiIiIiOhcsDo9c7t4gpdD+cGrXRLD/Od2YbULERFR02HIEhxDlhAwZKH6lB05gvzvv4cxLg6GyMgGPcaelYWiDRsgXC4Yu3RB3JQpkA2GsxqHEAK2nBwItxsxQ4ciZujQs15nXdhCjIiIiIiIziUhgOzy6rldfskD0ouDV7v0S/DM7ZIoMCgJSAhroUETERG1cQxZgmPIEgKGLFQfIQSK9+1D0Z49sHTtCp3Z3KDH2XNzUbR+PYTTCWNSEuKmToVsNJ71eJxlZbDn5yOiTx/Ejx4NQzPut2whRkRERERELcnqBI4UeIKXPLXNWJk98PeRpHD/uV1S4wADq12IiIjqxZAlOIYsIWDIQg2huFwo3L4dpb/8grCePRtcQeLIz0fhunUQDgcMCQmInzYNchNMXq84HLCeOQNjYiLiR41CWHLyWa+zLi5FoMAqkMMWYkRERERE1IKEADLLfVqM5QHpJYHVLkadQF/P3C6DPcFLHKtdiIiIAjBkCY4hSwgYslBDuW025G3ZgsqMDHVOFFlu0OOchYUoXLsWit0OfVwc4qdPb3A1TF2EosCanQ1JkhAzfDiiBw6EfJZzv9TH6hLIqRIosAlIUMMWthAjIiIiIqKWVKVVu+QBv3jmdikPUu3SOUJgYI1qF33Dfq0jIiJqtxiyBMeQJQQMWSgUzrIy5G7aBHtBAcKSkxt84HEWF6NwzRooNhv0MTFq0BLWNJdROUpK4CwqQkS/fogbObLB88Y0ll8LMQdg0bOFGBERERERtR5CAGfKqqtdDuYDGcWAeqlYNZOuem6XQZ65XWItLTRoIiKiFsKQJTiGLCFgyEKhsuXnI3fjRih2OyxdujT4ca7SUhSsWQOlqgq6qCgkzJgBXXh4k4zJbbfDmpkJc+fOiB81CpauXZtkvXWp2UIswgAYdTwQExERERFR61PpAA4XAIc8c7scygfKHcGrXQYlqaHL4CSgdyygY7ULERG1YwxZgmPIEgKGLNQYlSdPIm/LFshGI0zx8Q1+nKu8HIXffgt3ZSV0ERGInzED+iaqPBGKAmtmJmSjEbHDhyOqf39Iuuaf6dHqEsitEshnCzEiIiIiImojFAGcKQUO5nuqXfKAkyWB1S5mvUC/eHiDl0FJQMzZd38mIiJqNRiyBMeQJQQMWaixyg4fRv7338MYHx9Siy5XRQUK16yBu7wcclgYEi69FPom3PfsRUVwlZYiasAAxI4cCX0TtSWrC1uIERERERFRW1fhAA7ne4IXT7VLpTPwd5qukeqcLgM9c7uw2oWIiNoyhizBMWQJAUMWaiyhKCjetw9Fe/fC0rVrSJPZu6uqULhmDVylpZAtFsTPmAFDTEyTjc1ttcKalQVL9+6IHz0a5qSkJlt3XdhCjIiIiIiI2gtFAKdL/ed2OVkS+PuNWS/QPwEY7Kl2GZgIRLPahYiI2giGLMExZAkBQxY6G4rTiYLt21F26BDCevSAbDA0+LFuqxWFa9fCVVwM2WRSg5a4uCYbm3C7UZWZCb3FgriRIxHRpw8k+dxcXsUWYkRERERE1B6V29V5XQ55QpdD+UBVkGqXblFqlYvWYiwlhtUuRETUOjFkCY4hSwgYstDZcttsyNu8GZUnTyI8JSWkIEOx21G4di2chYWQjEbET58OY0JCk47PXlAAd2UlogYNQuzw4SFV3JwNrYVYTpWCEgdg1gFherYQIyIiIiKi9sOtAKdK/VuMnSoN/J3HohcYkAgMTGS1CxERtS4MWYJjyBIChizUFJxlZchNS4OjqAiW5OSQDkiKw4HCdevgzM+HZDAgbupUmDp1atLxuSorYcvJQVjPnogfNQqmJg5y6tw2W4gREREREVEHUmbX5naRcDAPOFwQvNqlu1btkqRWu/SMZrULERGdewxZgmPIEgKGLNRUbHl5yN24EYrDAUuXLiE9VnE6UbR+PRy5uZD0esRdcglMIa6j3m24XLCeOQN9VBTiR41CeK9e5/TA6dtCDACi2EKMiIiIiIg6ALcCnNTmdslT24ydKQv8XSjMIDAgARjkM7dLpKkFBkxERB0KQ5bgGLKEgCELNaXKjAzkbdkC2WyGKcT5VRSXC8UbNsCelQXodIibMgXmbt2adHxCCNjz8qA4HIgZMgTRQ4dCZzp3P7WzhRgRERERERFQalPnczmYr7YYO5wPWF2Bvxf1iFbDlkFJatVLzxhA5q9PRETUhBiyBMeQJQQMWaiplR48iMLt22GMj4c+IiKkxwqXC0WbNsF++jQgy4ibNAnmHj2afIzO8nLY8/IQ0bs34kaPhjEmpsm3URethViuTcDmYgsxIiIiIiLq2NwKkFHiqXbJV6tdMoNUu4Qb1LldtDZjAxOACFa7EBHRWWDIEhxDlhAwZKGmJhQFxXv3omjvXli6dQt5onnhdqN482bYTp4EJAmxEyfCkpLS5ONUnE5UnTkDU1wc4kaORHgzbKM+bCFGREREREQUXIlW7eJpMXakALAFqXbpGeOZ2yVRndslOZrVLkRE1HAMWYJjyBIChizUHBSnEwXbtqHsyBGE9egBWa8P6fFCUVCydSusJ04AkoSY8eMRlpra5OMUQsCWkwOhKIg97zxEDx4M2WBo8u3UNwathVipAzCxhRgRERER0f+z9+dBct/3nd///H6/fff03PcMZgaYAUBSvAkClKyVtFpJlKWSy7Y2lnftpbLJ7q9y2Dm8Vd6t2mQTJ6m4arVxKT5iJ5t47a1QsTaKVIw3a1GyKIKUKAIkAIIHSBAXQYAgMEdP39f3+Pz+6LkANED0YGZ6jtejamoGPT39fQ8wmO7+vvr9fovcxA/g/DycmoG3F4KXK/mbnze1RRZ3u9TDl3v6oC3SgoJFRGRLUMjSmEKWJihkkfXilctMv/ACpfffJzkxgWXbTX29CQKyP/sZpTNnAOj4xCdI7tu3HqXi5nJUZ2dJ7d1L92OPEU6l1uU4t+MFhrmK4WpZI8RERERERETuxHx5ebfLqWl4d+7mbhcLw3gn3Ne/0O3SB6PqdhERkQUKWRpTyNIEhSyynmrZLNM//jG1+XkSq9itYowh+/LLlE6fBqDj0CGS99671mUC4FerlD/4gFhfH90HDpAYHV2X43yUime4WjLMLowQS2mEmIiIiIiIyB3xAjifrne7LAYvVws3P59KRQz3Lu516YN7eiGpbhcRkR1JIUtjClmaoJBF1lvl2jWuPf88xveJDQw0/fXGGHKvvkrxrbcAaD9wgLb771/rMuvHCgLKV65gOQ5dDz1E+733Nj3qbE3q0AgxERERERGRNZEureh2WdjtUvNv7naZ6OK63S6j7aCnYCIi259ClsYUsjRBIYtshMKFC8y8+CJOIkGkq6vprzfGkD9xgsLrrwOQeuQRUg89tNZlLqnNz1Obn6d9/366H32UUFvbuh3rdvyg3tGiEWKyFRljMIAx1N+v/NhAcMOfG10nZEPEhrADjh7oiIiIiMga8AI4t9jtMm3x9swtul2i5rrQ5Z5eiG/sCk8REdkAClkaU8jSBIUsslEyb73F3MsvE+3rI5RMruo28idPkj9xAoC2Bx8k9cgj6/bLz69UKH/wAfGhIboPHCA+NLQux7kTN44Qa4vohLOsjaUghAaBx8L74BYBiKF+oQEsrn/PwseWtfB+8eOFPy/Ov7YBx17x3rJwLFjMEoueoeJDza/XYVkQtpffNEpPRERERNbCXGk5dDk1A+/Oghtc/1jTtgy7O+He/uXgZSSlbhcRka1OIUtjClmaoJBFNooJAuZefZXMa68RHx3FiUZXdTuFN98k9+qrACTvu4/2xx9ft1+AJggof/ABdiRC96OPktq3D8u21+VYH1mLRojtaIthSHCLIOTGz3HDn1eGH4sWL1sZeCyFIisDkYXrONbCe9vCAWwbQlb9Z3AxOFl8W7wN21r++oaX3cHPrxsYqj5UfCh7hoJbD17coP692QvBS8RZrkdERERE5G64/vXdLqdmYLp48+PMjujybpf7+mC/ul1ERLYchSyNKWRpgkIW2UiB6zLz0kvkT58mMT6+6n0nxbffJnvkCACJ/fvpeOKJdf0lWJ2bw8vnab/3XroeeYRQPL5ux/oo9RFicLUcUPYgpRFim8aN47FuCkRu+BzcHIxA466QlUEI1opAZEWnyFIIYi12h1g49uLl1wchix9bK27LvuXHm+vnyxhDLWApeCm6hqJbv8wN6tdxFjpdIgvfvx4kiYiIiMjdmi3BqWl4e8birWk4M9e422VPF9y32O3SB0PqdhER2dQUsjSmkKUJCllko3mlEtMvvkjp/fdJTkysujOk+O67ZF96CYD41BSdn/jEunaZeKUSlatXSYyO0n3gALG+vnU71p2oePVdLbNljRBrRqM9IbfsDmkwNgtu3RWy+Ne/1LHBzUGIbV3fFRKyrBXjsqybwo+bgpAVl90YmuzkBwLGLHe7VHwouAElr/4KRG/hH2tpv4td/7sWEREREbkbNR/Ozi10u8xYvD0NM6WbH2d2xha6XRZGjO3vhdjqXm8oIiLrQCFLYwpZmqCQRVqhlskw/fzz1DIZErt2rfp2SufOkfnJT8AY4nv20PnJT65r0BJ4HuUPPiCUTNL96KO0TU62bHwY1E8s51z4sBSQrW6fEWK3W5h+u3FZKy+7MQhZ6g5ZuSOE60OQlSOtrusKsayFQKQ+IsvGujkEWRl6cPNly0HJ1v632Up8Y6h6i8GLIe9qv4uIiIiIrK+Z4vUjxs7eottlshvuWwhe7u2HoTZ1u4iItIpClsYUsjRBIYu0SvnqVaaffx4TBMQGBlZ/O++9x/zhw2AMsfFxuj71KSzHWcNKb1aZmcEvlej42MfoevjhVe+XWSutGCHW1ML0WwQhcP1oLFZ8fMcL063lcViLC9MXx0PdKvBoFH4oCNkZ7nS/y+KbfhZERERE5G7UPDi7YrfLWzMw16DbpStmuKcPOmL1F89FQ4vvzYqP7+B9qN7BLSIid04hS2MKWZqgkEVaqXDhAtMvvkgokSDS1bXq26lcukT6xz+GICA6Okr3Zz6Dtcp9L3fKKxapfPghiYkJeg4cINrTs67HuxMVz3CtbJhZMULMBgJuMwqL24/LujH8WBmIWCsCj+vGYi2GGLA0CmvlwvTFPSG3Wph+U/jR6DLd6ckaaLjfxTPUfO13EREREZG1ZwxML3S7vL3Y7ZIGL1i7x5iOZW4KXhY/jjj1UWWN398i0LnNZY4CHRHZBhSyNKaQpQkKWaTVMm++ydyRI0T7+gglk6u+ncoHH5B+7jnwfaLDw3R99rPY6xy0BJ5H+dIlwh0ddB84UN8x0+JfxitHiOVry5cvBSHcEIhwdwvTb788XXdMsvXcbr+Lv/CIwdF+FxERERFZI1UPzszVw5aSC1XPouZDxePW7xfG4ta8+guGqh4YNv5xacg2HxHcQOSmkObOunNuvC0FOiKyXhSyNKaQpQkKWaTVTBAw98orZE6eJD46elejt6offkj6Rz/CeB6RgQG6P/c57HB4Dau9mTGG6vQ0Qa1G5wMP0PnAA9iRyLoe8074gaHoXb+EvdH+kPrndQcicju32+/iNxgzpoBRRERERDaSMfUXBS0GLh/1fjmwsW4b3DS+jdY81g2vDHTutOPGab47R4GOyM6jkKUxhSxNUMgim0FQqzHz0kvkz5whMTZ2Vx0otelp5n74Q4zrEu7ro+dzn8PegJ0pbj5PdXqatj176D5wgEhn57ofU0RaxwvMUrfLyv0uXlAfwaf9LiIiIiKyHRlTD2huCl8aBTI3hDMffZ3r39daGOjcOri5VUhj6iFNCGKL7z9iRFs0tLx3VERaRyFLYwpZmqCQRTYLr1Ri+oUXKF2+THJ8HMte/UtHarOzzP3gB5hajXBPDz2f/zx2LLaG1TYWuC6lS5eI9vTUx4eNja37MUVkczDG4AbLY8ZKrqGwsN/FC+r7jLTfRURERETkzgWLgc5C8FLzPmKM2tJ766bunMoNX39jqNPKQGexO2cxnFnZXRNrGNyYjwxwbuz4iTgKdERuRSFLYwpZmqCQRTaT2vw81w4fxstmiY+O3tVtuek0cz/4AUGlQqiri54vfAEnHl+jSm/NBAGVq1fBGDoffJCOj31s3UeWicjmpP0uIiIiIiJbw8pAp7l9OLfo0LnVew/coDWP+yO3Gp92y+6cBiPXbnG9mANdcY1ak61JIUtjClmaoJBFNpvyhx8y/fzzGCDW339Xt+VmMsw9+yxBuUyoo4OeJ5/ESSTWptCPOnY2SzWdJjU1RfdjjxFOpTbkuCKyud2436XgGsoL+10CU9+TFHa030VEREREZLvygxtGrn1EKNPsyLWVHTsbGehEHcPuLpjshsluw2Q37OmCuF53KpucQpbGFLI0QSGLbEaF8+eZfvFFQm1td73bxMvlmHv2WfxiESeVoufJJwm1ta1NoR/Br1Ypf/ABsb4+ug8eJDE8vCHHFZGtRftdRERERERkPSwGOnfanbM8Vs267norg5xGt1HxIDA3P0+xMAyn6sHLnm7DVHf9494E6GmNbBYKWRpTyNIEhSyyWWXeeIO5I0eI9vcTSibv6ra8fL4etBQKOMlkPWjZoJ93EwSUr1zBchy6Hn6YjnvvxXKcDTm2iGxNN+53KbuGvPa7iIiIiIjIJuUHcCUPZ9NwPm1xLg3n5mGu1Ph5SipaD1z2dC13vYx11Lv6RTaaQpbGFLI0QSGLbFYmCJh75RUyJ08SHx3FiUbv6vb8YpHZZ5/Fz+WwEwl6n3ySUEfHGlX70Wrz89QyGdr376f70UfvOjgSkZ3lxv0uRS+g6Nb3u3gLY8a030VERERERDaTTIV64JKGcwvhy/vZxl0vIdsw3gmTK4KXPd3Qfneng0Q+kkKWxhSyNEEhi2xmQa3GzEsvkX/3XRLj49ih0F3dnl8qMfeDH+BlMtixGD1PPkm4q2uNqr2D41cqlK9cIT40RPeBA8QHBzfs2CKy/dzJfpeQsxy8aL+LiIiIiIi0Ws2Di9kbul7SUHQbP1/pS17f9TLVDYOp+lhlkbWgkKUxhSxNUMgim51XLDL9wguUP/iAxPg4lm3f1e35lUo9aEmnsaNRur/wBSI9PWtU7Uczvk/5gw9wolG6HnuM1N69d/09iYgs0n4XERERERHZaoyBawWWxowtdr1cLTR+vhIPGfYs7HeZ7DZMdsFEF8Tu7rW5skMpZGlMIUsTFLLIVlBNp5l+/nncfJ7E6Ohd315QrTL3wx/izs5ihcP0fOELRPr61qDSO1edm8PL5+m47z46H36YUDy+occXkZ1B+11ERERERGSrKtTgwny96+Vc2uJ8uv5nN7j5OYttGUbbl4OXPV0w1Q3diRYULluKQpbGFLI0QSGLbBXlK1eYfv55jGUR6++/69sLajXSf/3X1KansUIhuj//eaIDA2tQ6Z3zSiUqH35IYmyMngMHiPb2bujxRWRn0n4XERERERHZqvwALmUXu16Wx41lKo2ft3TGzELwstz1squj/pxHBBSy3IpCliYoZJGtJH/uHDMvvki4vZ3wGiytD1yX9HPPUfvww3rQ8tnPEh0eXoNKm6jB8yh/8AGhZJLuxx6jbXJSv9BFZMP5i8GLp/0uIiIiIiKytRgD6TJLgcu5tMX5+XoYY7j5uUvEMUx0rgheumF3F7RFNr52aT2FLI0pZGmCQhbZSowxZN58k7kjR4gNDBBK3H3Pp/E80j/+MdUPPgDbpvuznyW2BiPJmlWZnsavVOj42MfoeughnGh0w2sQEVlpcb9L1a8/6Cy49SDG1X4XERERERHZAsouvJe5Png5l4aK1/i5y2CbYWpx3Fh3fdxYfxL0VGd7U8jSmEKWJihkka3G+D5zr7xC5vXXSezahR25+5cZGN9n/vnnqVy6BLZN16c/TXx8fA2qbY5XLFK5epXkxATdBw4Q7e7e8BpERG5l5X6Xqg8l7XcREREREZEtJjDwYX45eFnsfpkpNX7u0hap73dZ2fUy3gkRZ2PrlvWjkKUxhSxNUMgiW5FfrTLz0ksUzp4lOT6O5dz9PZsJAuZfeIHKe++BZdH1N/4G8T177r7YJgWuS+nyZSKdnXQ/9hjJiQn9gheRTUv7XUREREREZDvIVljqdDmXtjifrnfB+Obm5zCOZRjrhMmu5a6XyW7ojG142bIGFLI0ppClCQpZZKvyCgWuvfBCfXH8+Pia/BI0QUDmpz+lfO4cWBadP/dzJKam1qDaJuswhsq1axjPo/OBB+i8//416dgREdkIi/tdqj6UPe13ERERERGRrcn14f1sPXg5uxC8nEtDvtb4OUxPot7pshi+THXDUKr+wjPZvBSyNKaQpQkKWWQrq87NMX34MG4+T2KN9qgYY8j+7GeU3n0XgI6Pf5zk/v1rctvNcnM5qrOztE1O0v3YY0Q6OlpSh4jI3Vq536XsGfLa7yIiIiIiIluQMTBTYmnM2OLIsSv5xs9hYiHD7q7l4GWyG3Z3QTy8wYXLLSlkaUwhSxMUsshWV7pyhennnwfbJtbXtya3aYwhd/QoxbffBqD94EHa7rtvTW67WUGtRvnyZSJ9ffQ89hiJXbtaUoeIyFq61X4XdyF40X4XERERERHZSkou9U6X+eVxY+fnoebf/DzGwjDSDnu6Yaq7vvNlqht6EqCnPRtPIUtjClmaoJBFtoP8mTPM/PSnhNvbCa9Rt4cxhvyxYxTefBOA1KOPknrwwTW57aZrCQIqV68C0Pnww3Tcey92KNSSWkRE1svK/S5VHwq32O+yFLxov4uIiIiIiGxifgCXc/Xw5WzaWtr5ki43fi7THq13ukx1w56FrpexDghp3Ni6UsjSmEKWJihkke3AGEPm9deZO3qU2OAgoURizW63cPIk+ddeA6DtoYdIPfxwy37h1jIZ3HSatn376H70UcKpVEvqEBHZKNrvIiIiIiIi2818ecW4sfn6uLFLWQjMzc9nwrZhvJP6rpeFrpfJbkhFN77u7UohS2PN5Aab7qXgf/RHf8Q3vvENrl69ykMPPcQf/MEfcPDgwVteP5PJ8E//6T/lu9/9Lul0mvHxcb75zW/ypS99aQOrFmkty7LovP9+/FKJzBtvkBgbww7f/XBLy7JIPfwwOE69q+XkSfB9Uo891pJfupHOTpx4nPzp07iZDD2PP058eHjD6xAR2SiOZZEIQSIEXdH6791b7XcpexAYo/0uIiIiIiKyqXXF4cBI/a0+LBmqHryXMTd1vZRci7NpOJuG+svM6gaSZmHc2HLXy2Bbfd+lyEbbVCHLt7/9bX7rt36LP/mTP+HQoUN885vf5Mknn+T06dP09/ffdP1arcbnP/95+vv7+c53vsPIyAgXL16ks7Nz44sXaTHLceh69FG8UonCuXMkJyawHGdNbjv1wANYjkPu6FEKb76J8X3aDx5syYk7JxoluXs3lStXuPb883Q+9BAd99yzZt+riMhmF7It2mxoCwNYt9zvUvOh6AIY7BWhS0j7XUREREREZJOJhmB/b/1tMXgJDFwt1IOXc2lrqfvlWtFaeIOfXYLF8CURXu50mVwIXiY667ctsp421biwQ4cO8fjjj/OHf/iHAARBwK5du/jN3/xN/sk/+Sc3Xf9P/uRP+MY3vsE777xDeJWv2te4MNlu3Hye6RdeoHL1Konx8TU9kVY8fZrsz34GQGLfPjo+/vGWnqirptN4uRzt+/fT9eijazYmTURkq7txv0vRCyhov4uIiIiIiGwD+SpLnS6L4cvFDLjBzc9rbMuwqwP2dMFU93L3S1d84+verDQurLEtuZOlVquRSCT4zne+wy/+4i8uXf71r3+dTCbDM888c9PXfOlLX6K7u5tEIsEzzzxDX18ff/fv/l3+8T/+xzi3eFV7tVqlWq0u/TmXy7Fr1y6FLLKtVGdnuXb4MF6xSGJkZE1vu3T2LJmf/hSMIT45SefP/RyW3boNZH65TPnKFeIjI/QcOEBsYKBltYiIbGaBuX7M2OJ+F9cHX/tdRERERERkC/MCeD/LUtfL2XT942y18fOa7vjNXS+j7fUXo+00Clka25I7WWZnZ/F9n4EbTpAODAzwzjvvNPya8+fP89xzz/Frv/Zr/Lt/9+84e/Ys/8l/8p/gui7/zX/z3zT8mt/93d/ld37nd9a8fpHNJNrbS++hQ0y/8ALV2Vmivb1rdtuJqSksx2H+hRconzuH8X26PvWplgUtTjxOcmKC8gcfcO255+h69FFSe/e2NPgREdmMbO13ERERERGRbSpk17tV9nTB5ybrPQXGwFzJcO6GrpcPcpAuW6TL8OoVWBw3FnEMu7uWu14mu2FPNyTufu2xbHObppPlypUrjIyM8NJLL/Hxj3986fLf/u3f5vDhwxw5cuSmr9m3bx+VSoULFy4sda783u/9Ht/4xjf48MMPGx5HnSyyk+TffZeZl14i3NFBeI1/vssXLzJ/+DAEAbFdu+j6zGdavhelOjuLXyzSft99dD38ME4s1tJ6RES2mpv2uywEL64PblCfjOxov4uIiIiIiGxhZRcuLAYv8/Xg5cI8VLzGz22GU4tjxpa7X/qTsF2eCqmTpbEt2cnS29uL4zhcu3btusuvXbvG4OBgw68ZGhoiHA5fNxrs3nvv5erVq9RqNSKRyE1fE41GiUaja1u8yCbVtncvXqlE+pVXsMNhnPjaDZyMj49jffazpJ97jsqlS6Sfe47uv/k3sUKt+7US7e3FSyTIvP46tUyGngMH1rSLR0Rku7Msi4gDkaWHVlZ9v0sAFe/6/S5lt77fBQwh7XcREREREZEtIh6G+/rrb/WXkoEfwIf5xa4Xa6HzBWZLFlfyFlfy8JOLy891UpF68DLZDZNd9a6X8U4It/b1x9IimyZkiUQiPPbYY/zoRz9a2skSBAE/+tGP+I3f+I2GX/NzP/dzfOtb3yIIAuyF0UDvvvsuQ0NDDQMWkZ3Gsiw6H3gAr1gk++abJMbHscNr1+MYGx2l53OfI/3cc1Q/+IC5H/2I7s9+dk2P0axQIkFifJzy5ctcnZ8nOTlJas8ehS0iIqtkWRYxB2JLTxacW+53KbjgG4MF2Fb9lV32wtviZbYFNoufUyAjIiIiIiKt59gw2lF/+/TE8uCnbMUsBS6LXS/vZyBfszh5FU5ehcVxY45lGO9kqetlsrs+eqxDg1a2vU0zLgzg29/+Nl//+tf5X//X/5WDBw/yzW9+k3/zb/4N77zzDgMDAzz11FOMjIzwu7/7uwBcunSJj33sY3z961/nN3/zNzlz5gz/wX/wH/Cf/Wf/Gf/0n/7TOzpmM20/IluVX60y8+KLFM6fJ7l795rvK6leu0b6r/8a47pE+vvp/tznsFscdBpjcLNZaul0fW/L+DipqSliAwPa1yIisg5W7nepeIZaUL/MM/UllAYITP3NGAiov198IGpR/9i6bSijgEZERERERFqr5sPFTD14OZ+2OJuG8/NQqDV+jtKXWNH1shC+DKfqz282A40La2xLjgsD+NrXvsbMzAz/7J/9M65evcrDDz/M97//fQYGBgB4//33lzpWAHbt2sWzzz7Lf/lf/pc8+OCDjIyM8J//5/85//gf/+NWfQsim5ITjdJz6BB+uUzp0iUSY2Nr+kszOjBAzxe+wNwPf0htepq5H/yAns9/HruFo/ksyyLS2UmksxOvUCD/7rsUzp8nMTJCat8+4sPD2C0cbSYist2EbIs2G9rCsPhKrkXGGALqLfiLQYvPwvuFy3wDAQYvqIcybmDwVwQ0K7/WLNwmLIc00CiIqX+81FWz9LGeOIiIiIiIyOpEHNjbU39bfEZiDEwXV3S9pC3OzcOHeYuZksVMCY5chsXnSrHQ8n6XxeBldxfEdKpqS9pUnSytoE4W2Umqs7Nce/55/HKZ+PDwmt++OzfH3A9+QFCtEurupucLX9hUy+f9SoXqzAzG94kPD5Pat4/E6CiO9jSJiGxaxpjlEMYsBzI3/jkw9a4Zd0UHjR/UO2aWumfMckfNUufMwnGsFUGMAhoREREREVkLxVq9y2UpeEnDhXlwg5ufV1gYRtvrwcuebsNUd330WE+8/pxkvaiTpbFmcgOFLApZZIcpXbrEtcOHsSMRoj09a3777vw8c88+S1CpEOrsrActicSaH+duBLUa1dlZgmqVaG8vqf37SY6NEUomW12aiIisIWNMgzDm5veBqY83843BDerhjG+WA5rFkKbeQXPziLNGe2esBiGNnrCIiIiIiIgfwOUc9TFjC+PGzqUhU2n8fKEzdnPXy64OCK3RNHyFLI0pZGmCQhbZiXKnTzPz0ktEuroIp1JrfvteNsvss88SlEo47e30PvkkziYMMALPo5ZO4+XzRLq6SO3dS3L3biIdHa0uTUREWmxlQHNzKLPcTeMHix00Bj+g3kGz2DGzOOKMhWDGLHfPLD4Av10oszK80ZMdEREREZHtLV2Cczd0vVzOQWBufi4Qtg0Ti8FLVz142dMFbasY1qKQpTGFLE1QyCI7kTGG+ddeY/7VV4kNDeHE42t+DC+fZ+7738cvFnHa2uh58klC6xDorAUTBNTm53GzWcJtbST37CE1OUmkp0d3LiIi0rTghhFnt+qm8YP6DhrXXB/QrBxvFrDcPXPdPdKKzplGoYwCGhERERGRra/iwXuZevCy2PVyYR5KbuPH+INty10vU92GPd0w2Hb7cWMKWRpTyNIEhSyyUwWex9zLL5N96y0S4+PY4fCaH8MrFJh79ln8fB47kaD3i18ktIn/nxlj8HI5anNz2PE4ybExUlNTxAYHsew16sEUERG5jeAOR5x5CwGNZxbeN9g/sxjQwPUjzmgQxCx+vPLPCmhERERERDafwMDV/MK4sXlrofMFpouNH7snw/WwZWXXy0QnREL1zytkaUwhSxMUsshO5lerzLz4IoULF0hOTKxLkOCXSsw9+yxeNosdj9Pz5JOEOzvX/DhrzSsWqc7OYtk2idFRUlNTxEdG1iWMEhERWQvBHYw4uzGgWdxB81EBzeKIs+X9MrcIaZY+pydnIiIiIiIbKVeF8+kV48bm4WIGvODmx+a2ZRjrYGG/i2Gy2/Dr99nYth7HL1LI0gSFLLLTufk8155/nursLIldu9YlsfbLZeZ+8AO8+XnsaLQetHR3r/lx1oNfqVCdmYEgIDowQPu+fSTGxnCiqxhyKSIisgkZY5ZCFt/Ud8n43LB/JoCA5a4Zb2EXjRcs7J9ZOeaM5RFncENAc8tQRgGNiIiIiMhac324lL2+6+VsGvLV6x9zd0QNr/3/UMiygkKWJihkEYHKzAzTzz+PX60SHxpal2ME1SpzP/gB7twcViRCzxe+QKS3d12OtR4C16U6O0tQLhPp66N93z6SY2OE2tpaXZqIiEjLLAY0frAilGHhfbAiuFkIaNyFgMZfEdD4KzpoFgObxWBm0c1BzPIeGuu6j/WkUERERETkdoyB2RJLY8ZOz1kkw4Z/+WVLj6dXUMjSBIUsInXF999n+oUXsCMRoj0963KMoFZj7oc/xJ2ZwQqH6f7c54gODKzLsdZL4HnU0mm8fJ5wVxepqSnadu8msgVGoImIiGwmxpjb7p1ZHnVW75pZDGi8YDG4uX7E2Y0BzeLTQ8tqMOYMBTQiIiIiIqCdLLeikKUJCllEluVOn2bmpz8l0t1NOJVal2MErkv6r/+a2rVrWKEQ3X/rbxFdp+6Z9WSCgFomg5vJEE4mSe7ZQ9vkJNHeXt0hiYiIrDOzYv/M7YOahb0zK/bPeKbxiDPM9d0zjg0ha8V7BTEiIiIisg0pZGlMIUsTFLKILDPGMH/iBOnjx4kPDeHEYutynMDzmH/uOapXroDj0P3ZzxIbGVmXY603YwxePk91dhYnFiMxNkZq717ig4NYtt3q8kREROQGiwHN7UIaNzBUfEPZYymc8VeEMI5dD11WhjB6QioiIiIiW5FClsYUsjRBIYvI9QLPY/bll8mdOkVibAw7HF6X4xjPI334MNVLl8C26f7MZ4iNja3LsTaKVyxSnZ3Fsm3iw8Ok9u4lMTq6bn+HIiIisr7MilFli28131DxoeIZXAOeXw9gFlkWhBZDGAUwIiIiIrLJKWRprJncILRBNYnIFmGHQvQcOIBfKlG6eJHExMS6dGRYoRDdn/kM8y+8QOXiRdI//jFdn/408YmJNT/WRgklk4SSSfxqlfKHH1K6dInYwADt+/aRGBtbt84gERERWR+WZRG2IHzdQ6HlJ55eYK4LYNwAyl69C6YWQMVb7I6ppzD2is6XxSDG1hNZEREREZEtTSGLiNzEicXofeIJrlUqlC9fJr5r17ok2Zbj0PXpT5P5yU8onz/P/OHDGN8nMTm55sfaSE40SmJ0lMB1qc7Ocu2FF4h2d5Pat4/k+Pi67bsRERGRjRWyLUI2xK+7tP6YyV8IYGorApiKZyj7ZuHjBgHMDV0wCmBERERERDY/jQvTuDCRW6pMT3Pt8GGCapX4Oi6nN0FA9mc/o3TmDAAdn/gEyX371u14G834PtV0Gi+bJdzVRWpqirbdu4l0dbW6NBEREWkB3xhcf8UIsgCqvqHs1Ttg/AC8hf0wsDCC7IYuGAUwIiIiIrIWNC6sMY0LE5E1Eevvp/fgQaZfeIFqOk20u3tdjmPZNh2f+ATYNqXTp8m+9BL4Psl7712X4200y3GI9fVhenpws1nSr75K7p13aNu9m7bJSaJ9fboTExER2UEcy8IJwfWDRBc6YMyKEWQLQUzVr3fAVH2o+VDyljtgLOv6/S+OBY6txxUiIiIiIhtFIYuI3FZyfJzuAweYfekl7HB43UZdWZZFxxNPYIVCFN96i+yRIxjfp+3++9fleK1g2TaRri4iXV24uRyZt94if+YMibExUnv3Eh8cxHKcVpcpIiIiLeRYFo4DMQcIL15aD00Cc/0OmJoPtaDeAVP16x0xXgBLwwpuHEFm1ceS6cUdIiIiIiJrRyGLiHyk9v378Usl0sePY4fD67bA3bIs2g8cwHIcCq+/Tu7VVzG+T+qhh9bleK0Ubm8n3N6OVypRvHCB4nvvERsaon3fPhKjo9jh8EffiIiIiOwotmURdSB63Wsybg5gvIURZLWFEWQVv35ZJajvgQGDRX382MoQxlEAIyIiIiLSNIUsIvKRLNum88EH8Uolcm+/TWJ8HDu0Pr8+LMui/dFHsRyH/IkT5E+cqActjzyyLZ/0hxIJQmNj+NUqlatXKV++TLS/n479+0mMja1boCUiIiLby+0CGHNDB4y7GMD4hopXD2CqCwGMod4Fs7j/xVkxhmw7PhYTEREREblbCllE5I7Y4TDdBw7gl0oU33+f5MQElm2v2/FSDz2E5TjkXn2VwuuvYzyP9scf37ZP7p1olMToKIHrUp2b49rhw0R7ekjt3UtyYmLdxrSJiIjI9mdZFhEHIrcIYDxT3/9SWxHAVIJ6AOMudMXcGMAsjh9b7ILZro/RREREREQ+ikIWEbljoXicnieewC+XKV++TGJsbF2P13b//ViOQ/bIEYqnTmF8v763ZRs/ibfDYeKDgxjfpzY/z+zPfkb21ClSU1Mkd+8m2t3d6hJFRERkG7Esi7AFYRsSy5cCKwKYxQ6YhR0wFR8qnsE1UHKXR5BBfefLjV0w2/mxm4iIiIiIZZa2Iu5MuVyOjo4Ostks7e3trS5HZEuoXLvGteefJ/A84oOD63684rvvkn3pJQDiU1N0fuIT69pFs5kYY3AzGWrpNKG2NpITE6QmJ4n29+uEhYiIiLSUF5ilThdvIYip74AxS5f5Bhafca4MYBY7YGw9nhERERFpqZJnsIH7u22da1qhmdxAnSwi0rTYwAA9Bw8y8+KL1ObniXR1revxkvv2YTkOmZ/8hPLZsxAEdH7ykzsiaLEsi0hXF5GuLtx8ntypU+TPniU5NkZqaor40BCW43z0DYmIiIissZBtEbIhft2l9SfmiwHMyreKV98DU/94MYCpJzDWwt6XxfAlZCuAEREREZGtQSGLiKxK2+7d+OUycy+/jB0OE2prW9fjJSYnsRyH+cOHKZ8/j/F9uj71qR0VMIRTKcKpFF6pRPHCBQoXLhAfHqZ93z4SIyPYkUirSxQREREBbh/A+Mbg+svhSy2A6kIAUwug5kPJg2BFABO6oQtGAYyIiIiIbBYKWURk1drvuQe/VCJ9/DjxcBgnGl3X48UnJrAch/SPf0zl4kXSP/4x3Z/5DFZoZ/0qCyUShMbG8KtVKteuUb58mWhfH+3795MYGyMUj3/0jYiIiIi0iGNZOCGIXXfpigBmxQ4YN4CKXx9BVvUbBzCLnS+hhY8dWwGMiIiIiGwc7WTRThaRuxK4LrM/+xm5d94hMT6OvQGBR+WDD0g/9xz4PtHhYbo++9kNOe5mFXgetbk5vGKRSHc3qX37aJuYIJxKtbo0ERERkTUTmOtHkNV8qAWGslcPYDxT3wMTLDzDvWkEmVXfC6NZ4yIiIiLLtJOlsWZyA4UsCllE7ppXLjP9wguU3n+f5MTEhuxKqX74Iekf/QjjeUQGBuj+3Oeww+F1P+5mZoKAWjqNm80S7uggNTlJcvduoj09rS5NREREZF3dGMDUQ5h6AFNZCGD8oL4HBup9M459fQjjKIARERGRHUghS2MKWZqgkEVkbdQyGaaff55aJkNi166NOeb0NHM//CHGdQn39dHz+c9rLwn1BbJuNkstnSaUSJAcH6dtaopYf/+GBGAiIiIim4m5VQDjGyre9QGM4foAxlkxhkwnHURERGQ7UsjSmEKWJihkEVk75atXmT58GOP7xAYGNuSYtdlZ5n7wA0ytRrinpx60xGIf/YU7hJvPU5udxYpESIyO0r53L/HhYSzHaXVpIiIiIi23GMB4AdRuCGCqCzthVgYwsKIDZkUXjE5IiIiIyFalkKUxhSxNUMgisrYKFy4w/eKLhBIJIl1dG3JMN51m7gc/IKhUCHV10fOFL+Bo+ft1/HKZ6swMxhjiw8O079tHfGQEJxptdWkiIiIim5IxBs+s6IBZ2AFTWeiAcQ14/vUdMPbK7peF9zpZISIiIpuZQpbGFLI0QSGLyNrLvPkmc0eOEO3rI5RMbsgx3UyGuWefJSiXCXV00PPkkziJxIYceysJajWqs7P41Sqx3l7a77mHxNgYIf1diYiIiNwxYwz+QgBTWxpDVg9fKr6httAd4xtYfMZtr+h8WXxv60SGiIiItJhClsYUsjRBIYvI2jNBwNyrr5J57TXio6Mb1i3h5XLMPfssfrGIk0rR8+SThNraNuTYW03gedTm5vAKBSJdXaT276dtYoKwfg+KiIiI3DUvuHkPTMWrjyFzGwQw1g37X0K2AhgRERHZGApZGlPI0gSFLCLrI6jVmPnZz8i/+y6JsTHsUGhDjuvl8/WgpVDAjkZJPfooib17tfD9FkwQUJufx81mCadStE1O0rZ7N9He3laXJiIiIrIt+TcEMLUAqgsBTG1hB4xnIFgRwKwcP6YARkRERNaSQpbGFLI0QSGLyPrxSiWmX3iB0qVLJCcmNizo8ItF5v76r/Hm5wEI9/TQ8cQTRPr6NuT4W5ExBjebpZZO48TjJMfHSU1NERsYUEAlIiIiskF8Y67bAeMGLOyAMVRXBDBmcQ/Mis6XxSDG0ckRERERaYJClsYUsjRBIYvI+qplMlx7/nncTIbErl0bdlwTBBTfeYf8iRMY1wUgsXcvqUcfxYnHN6yOrcgrFKjOzmKFQiRGRkjt20d8eHjDupFERERE5GaBuaEDxodaYCh7hqpfD1+8oN4BY1sQtiHi1MMXnTARERGRW1HI0phCliYoZBFZf+UPP2T68GFMEBAbGNjQY/vlMrljxyifPQuAFQ6TevRRkvv3q0PjI/iVCtWZGYzvEx8eJrVvH4kN3LEjIiIiIndmZQBT9aHgGvLuQvgSgAWEHYjY9fBFJ1BERERkkUKWxhSyNEEhi8jGKJw/z/RPfkIomSTS2bnhx69NT5N9+WXcdBqAUFcXHU88QXSDQ5+tKKjVqM7OElSrRHt7Se3fT3JsjFAy2erSREREROQWAmOo+FDxoOgZ8rX6n92g/vmwA1GFLiIiIjueQpbGFLI0QSGLyMbJvPEGc0ePEu3ra8kJehMElN59l9zx45haDYD4nj20HziAk0hseD1bTeB51NJpvHyeSFcXqb17Se7eTaSjo9WliYiIiMhHMKbe2VL2oeQacq6h4kFtMXRZGC8WUegiIiKyoyhkaUwhSxMUsohsHBMEzL3yCpmTJ4m3cOyUX6mQP36c0rvvAmCFQqQefpjkvfdiOU5LatpKTBBQm5/HzWQIp1Ik9+whNTlJpKdHd8YiIiIiW4QxhmpQ73QpeYZczVD2wfXBACG7HrhEHLD1GE9ERGTbUsjSmEKWJihkEdlYQa3GzEsvkXv3XZLj4y1dpl6bna2PEJudBSDU0UHHoUNEh4dbVtNWYozBy+Wozc1hx+Mkx8ZITU0RGxzUvhsRERGRLcYYQy2Aig9lD3K1gJJXHy8WGHBWhC6OTsCIiIhsGwpZGlPI0gSFLCIbzysWmX7hBUoffEByfLylJ+SNMZTPniV37BhBpQJAbHyc9scfJ9TW1rK6thqvWKQ6O4tl2yRGR0nt3Ut8eBg7HG51aSIiIiKySjXfLIUu+VpA0YeavxC6WMvjxRxbJ2RERES2KoUsjSlkaYJCFpHWqM3Pc+3553GzWRK7drW6HIJqlfxrr1F85x0wBstxaHvwQdruv18jxJrgVypUZ2YgCIgODNC+fz+JXbtaNhpORERERNaOFxjKXn2vS94NKLpQ9cG/IXQJKXQRERHZMhSyNKaQpQkKWURap3zlCtOHD2OAWH9/q8sBwE2nyR45Qu3aNQCcVIqOQ4eIjY62uLKtJXBdqrOzBOUykb4+2vfvJzk2RiiZbHVpIiIiIrJGvGC506XgGvKuwfXBM2BZy+PFQhY6aSMiIrJJKWRpTCFLExSyiLRW/tw5Zl58kVAqRaSzs9XlAAsjxC5cIPfKKwTlMgDRXbvoePxxQvo90ZTA86il03j5POGuLtr37iU5MbFp/q1FREREZO34xlBZ6HQpuoZ8zVBdDF2AsANRhS4iIiKbikKWxhSyNEEhi0hrGWPIvPkm6SNHiA4MEEokWl3SksB16yPETp0CY8C2aXvgAdoeeAA7FGp1eVuKCQJqmQxuJkM4mSS5Zw9tk5NEe3t1By4iIiKyTQVmudOl5BlyC6GLG9Q/H3YgakPYVugiIiLSKgpZGlPI0gSFLCKtZ4KAuaNHybz+Ooldu7AjkVaXdB03k6mPEPvwQwCcZJL2gweJjY3pzqdJxhi8fJ7q7CxOLEZyfJy2qSnig4NYtt3q8kRERERkHZkVoUvZM+TceudLLah3uoTs5b0uepwtIiKyMRSyNKaQpQkKWUQ2B79aZeallyicOUNifHzTdYoYY6hcvEjulVfwi0UAosPDdBw6RKijo8XVbU1esUh1dhbLtokPD9O+bx/xkRHscLjVpYmIiIjIBjCm3tlS8Zc7Xco+uD4Yrg9dbJ30ERERWRcKWRpTyNIEhSwim4dXLHLt8GEqV66QmJjYlL/YA9el8MYbFN58E4KgPkLsvvtoe+ghhQOr5FcqVGdmML5PbGCA9n37SIyN4cRirS5NRERERDaQMYZasNzpkncNpYVOF2MWQpeF4EWhi4iIyNpQyNKYQpYmKGQR2Vyq6TTTzz+Pm8+TGB1tdTm35OVyZI8epXr5MgB2IkHHgQPEdu/WHdIqBa5LdXYWv1Ih2t1Nat8+2iYmCLW1tbo0EREREWmRml/vbil7UKgFFH2o+RAYcKzlThfH1mNwERGR1VDI0phCliYoZBHZfEpXrjD9/PNg28T6+lpdzm1VLl0ie/Qofj4PQGRggI4nniDc1dXiyrYu4/tU02m8bJZwVxepqSnadu8mor9TERERkR3PDcxCpwsUvICiC9WF0MVeEbqEFLqIiIjcEYUsjSlkaYJCFpHNKX/2LDM/+Qnh9nbCm3znifE8Cm+9ReH11zG+D5ZF8p57SD38MHY02urytiwTBLjZLLV0mlBbG227d9M2OUm0r093+iIiIiICgBcYKoudLm59xFjNB28xdLEh6ih0ERERuRWFLI0pZGmCQhaRzckYQ+b115l75RViAwOEEolWl/SRvEKB3CuvULl4EQA7FqP9wAHik5O6k7pLbi5HdW4OJxIhMTZGau9e4oODWI7T6tJEREREZBPxjaGy0OlSdA25hdDFXQhdwouhi4Ueo4uIiKCQ5VbWPWQ5cuQIhw4dWnWBm4lCFpHNy/g+c0ePknnjDRK7dmFHIq0u6Y5UPviA3JEjeLkcAOG+PjqeeIJIT0+LK9v6vFKJ6swMlmURHx4mtW8fidFR7HC41aWJiIiIyCYULIYufv0kUra2ELoE9c8vjhcL2wpdRERkZ1LI0ti6hyy2bTM1NcXf+3t/j1/7tV9jz549qy621RSyiGxufrXKzE9/SuHsWZITE1umc8H4PoVTpyicPInxPAAS+/fT/sgj2LFYi6vb+vxqlerMDMbziPb307F/P4mxMRz93YqIiIjIbRizPF6s5BlyNUN1RegSspeDF51oEhGRnUAhS2PrHrJ861vf4umnn+aHP/whvu/zxBNP8Pf+3t/jV37lV+ju7l514a2gkEVk8/MKBa4dPkzl6lUS4+Nb6he+XyySe/VVyhcuAGBFo7Q/+iiJvXuxbLvF1W19getSnZvDL5WI9vSQ2ruX5MQE4VSq1aWJiIiIyBZgTD1kKftQWtjpUvbB9cFQD12iTr3Txd5Cz0NERETulEKWxjZsJ8vs7Cx/8Rd/wbe+9S1efvllIpEIX/ziF/n1X/91fuEXfoHIFhjto5BFZGuozs1x7fnn8YpFEiMjrS6nadWrV8m+/DJeJgNAuKeHjkOHiPT3t7awbcL4PrX5edxslnBHB6mpKZK7dxPdYsG/iIiIiLSWMYZasNzpkncNZQ9qK0KXyEK3i0IXERHZDhSyNNaSxffnzp1b6nA5c+YMHR0d/O2//bd56qmn+OQnP7kWh1gXCllEto7SBx8wffgwluMQ7e1tdTlNM0FA8Z13yJ84gXFdAOJTU7Q/9hhOPN7i6rYHEwS42Sy1dJpQWxvJiQlSk5NE+/v1QEFEREREVqXm17tbyh7kagFlvx66BAacxdDFBsfW400REdl6FLI01kxusGazauLxOIlEglgshjEGy7J45pln+PSnP83jjz/OqVOn1upQIrJDJUZG6Hn8cfxyGXdhqfxWYtk2bffdR/8v/zLxqSkAymfPMv3d71J4+21MELS4wq3Psm0iXV20TU7iJBJkT53iyrPPMn34MKXLlzG+3+oSRURERGSLiTgWHRGLwYTFvk6H+7ps9nfaTKRsOhcGeORdSFcMmaqh5Bm8YE1ezyoiIiJbwF11suTzeb7zne/w9NNPc/jwYWzb5ud//ud56qmn+MpXvoJt23zve9/jH/2jf8Tg4CBHjhxZy9rXhDpZRLYWYwyZkyeZe+UVYoODhBKJVpe0arXpabJHjuDOzQEQ6uqi49AhooODLa5se/FKJWqzsxggPjxM+759JEZGsLfASEsRERER2fy8YLnTpeAGFNx6p4tvwLbqo8UiNoTU6SIiIpuQOlkaW/dxYc888wxPP/00//bf/lsqlQqPP/44Tz31FL/6q79KT0/PTdf/l//yX/Kf/qf/KbVardlDrTuFLCJbj/F9Zo8cIfvGGyTGx7HD4VaXtGomCCidOUPu+HFMtQpAfM8e2g8cwNnCAdJm5FerVGdnMa5LtK+P9v37SYyNEdKoNhERERFZQ/6K0KXkGnKuoeaDZ8Cylne6hCx0MktERFpOIUtj6x6y2LbNrl27+PVf/3Weeuop9u/ff9vrHz16lD/+4z/mX/2rf9XsodadQhaRrcmvVpl58UUKFy6QHB/HcpxWl3RXgkqF3PHjlN59FwArFCL18MMk7713y39vm03gedTm5vCKRSLd3bTv20dyYoJwKtXq0kRERERkGwqMoeJB2YeCa8i7hqoPXgAWEF7odAnbCl1ERGTjKWRpbN1Dlueff57PfOYzq61vU1HIIrJ1ufk80y+8QOXqVRLj49vijqA2O0v25ZdxZ2cBCHV01EeIDQ+3uLLtxwQBtXQaN5sl3NFBamqK5MQE0QYdmSIiIiIiayUw9ZCl7EHRM+RrhooP7kLoEloIXSIKXUREZAMoZGls3UOW7UQhi8jWVp2d5drhw/ilEvFtEkQYYyifPUvu2DGCSgWA2Pg47Y8/TqitrcXVbT/GGNxsllo6TSiRIDk+TtvUFLGBAT24EBEREZF1ZxZDF395vFjFg1pQ/3zIhqhT73Sx9fhURETWmEKWxprJDezVHOC/+q/+Kx5++OFbfv6RRx7hd37nd1Zz0yIiTYn29tJ76BCWbVNd6P7Y6izLIrF3L/2/9Esk770XLIvKxYvMfO975E+exHheq0vcVizLItLZSduePTjJJLl33uHDH/yAaz/+MaVLlzC+3+oSRURERGQbsyyLWMiiK2ox0mZzT6fNvd02+zttdrVZJEP10WLZKqQrhlzNUPEMwc5+zayIiMimsaqQ5Tvf+Q4///M/f8vPf+lLX+Lb3/72qosSEWlGYnSUnscfxyuVcHO5VpezZuxolI5Dh+j7yleIDAxgfJ/8iRNMP/MMlUuXWl3ethROpUju3k20u5vSxYt8+MMf8uEPf0jh/Hn8arXV5YmIiIjIDmBZFjHHojNqMZy0uafL4d4um/1dNuMpm1QYfAO5Wj10ydYMZc/gK3QRERFpidBqvuj9999ncnLylp/fvXs3Fy9eXHVRIiLNatu7F7dYZP7VV7HDYZx4vNUlrZlwdzc9X/wi5QsXyL3yCn4+T/pHPyI6OkrHwYOENOpwzTnxOImxMYJajerMDFcvXybW20v7vfeS2LWLUCLR6hJFREREZAeJOhZRBzoiMJhwcAND2avvdcm7AUUP8rX6vhfbgogDURscW2NfRERE1tuqQpa2trbbhigXLlwgFoutuigRkWZZlkXnAw/gl0pk33qLxNgYdjjc6rLWjGVZJPbsIbZrF/mTJym+9RbVy5eZvnKFtgceoO2BB7BDq/qVLrdhRyLEh4cJPI/a3BzThw8T6e4mtX8/bePjhBVwiYiIiEgLhG2LcATaIzCAg7cYuvhQcAMKLuTd60OXiA0hhS4iIiJrblWL73/lV36F559/nhMnTjAyMnLd5y5dusSjjz7Kpz/9ab7zne+sWaHrRYvvRbYXv1pl5sUXKZw/T3L3bix7VVMRNz03kyF75Ai1Dz8EwEkmaT94kNjYmJaUrSMTBNTm53GzWcKpFG2Tk7Tt3k20t7fVpYmIiIiILPEDQ9mvd7oUXEPBNdR88AzYFoTtevASstDzBxGRHU6L7xtrJjdYVchy+vRpDh48iGVZ/If/4X/Ixz72MQDefPNN/vRP/xRjDC+//DL33nvv6r6DDaSQRWT7cfN5pp9/nsrMDIldu7Zt0GKMofL+++SOHsUvFgGIDg/TcegQoY6OFle3vRljcLNZauk0TjxOcmKC1OQksYGBbfvzJiIiIiJbl28MlYVOl6JryNcM1YXQxQLCC50uYVuhi4jITqOQpbF1D1kAXn/9dX7zN3+TF1988brLP/WpT/H7v//7PPjgg6u52Q2nkEVke6rOzjLzk59QmZ4mPjKCs41HGAaeR+H11ym8+SYEAdg2bffdR9tDD22rkWmblVcoUJ2dxQqFSIyOktq7l/jwsMa3iYiIiMimFRhDZaHTpeQZcguhixvUPx9e2Omi0EVEZPtTyNLYhoQsi2ZnZzl//jwAe/bsoXeLjUxRyCKyfbn5PPMnTpB7913C7e1Ee3paXdK68nI5skePUr18GQA7kaD9wAHiu3frTnID+OUy1dlZjO8THx4mtW8fidFRnGi01aWJiIiIiNyWWRG6lD1Dzq13vtQWQxd7ea+LnluIiGwvClka29CQZatTyCKyvRnfJ3f6NPOvvUZQrRLbAR0GlUuXyB49ip/PAxAZGKDjiScId3W1uLKdIajVqM7OElSrRHt7ab/nHhJjY4QSiVaXJiIiIiJyR4wxVAOorOh0Kfvg+mCA0IrQxdYJORGRLU0hS2MbFrJcvnyZEydOkM1mCYLgps8/9dRTq73pDaOQRWRnqFy7xtyxY5QvXyY2OEgomWx1SevKeB6Ft96i8PrrGN8HyyJ5zz2kHn4YW50VGyLwPGpzc3iFApGuLlJ795LcvZuI9uWIiIiIyBZjjKEWLHe65F1DaaHTxZh66BK2IeoodBER2WoUsjS27iFLpVLh61//Ov/P//P/EAQBlmWxeDMr/yF832/2pjecQhaRncMrl8mcPEn21CmcWIxof/+2v/PwCgVyr7xC5eJFAOxYjPbHHiM+NbXtv/fNwgQBtfl53EyGcCpFcs8eUpOTRHp69G8gIiIiIltWza93t1Q8yNcCij7UfAgMONZyp4tj6zGviMhmppClsXUPWX7rt36LP/iDP+B/+B/+Bz7+8Y/zmc98hj//8z9naGiIb37zm1y5coV//a//Nffff/+qv4mNopBFZGcxQUDhwgXSx4/jZrMkRkd3xHL4ypUr5F5+GS+XAyDc10fHE08Q2eZ7ajYTYwxeLkdtbg47Hic5Pk5qcpLY4CCWbbe6PBERERGRu+IG9T0uZR/ybkDRhaoP/g2hS0ihi4jIpqKQpbF1D1nGxsb44he/yP/2v/1vzM3N0dfXx1//9V/z2c9+FoDPfvaz7N+/nz/+4z9e3XewgRSyiOxM1XSa+ePHKZw/T7Svj/AO+P9vfJ/i22+Tf+01jOcBkNi/n/ZHHsGOxVpc3c7iFYtUZ2awHIfE6CipvXuJDw/viMBPRERERHYGLzBU/PqIsYJbHzFW88EzYFv1wCXiQFihi4hISylkaayZ3GBVL52dnp7m4MGDAMTjcQCKxeLS57/61a/y3e9+dzU3LSKyIaLd3fR/6lN0P/44bj5P+coVTIPdUtuJ5Ti03X8//b/0S8T37AGgdPo01773PYqnT2/7738zCSWTJCcmiPb1Ubp8mWs/+hEf/uAH5M+exa9WW12eiIiIiMhdC9kWbWGLvrjF7nabj3Xb3NtlM9VuMxC3cCwou5CuGOYrhoJr8IJVrw0WERFpmVWFLAMDA8zNzQGQSCTo6uri9OnTS5/P5XJUKpW1qVBEZJ3YkQjdjzzCwGc+QyiVovjeezviBLeTTNL1qU/R88UvEurqwlSrZH/2M2b/v/+P2vR0q8vbUZxYjMSuXcSGh6nNzzP94x9z5a/+iuzbb+OtePGCiIiIiMhW51gWybBFb9xiPLUidOmwGUpaRGwoLYQuBdfgK3AREZEtYlXjwn7lV36FcrnMX/7lXwLw7//7/z5/9Vd/xe/93u8RBAH/6B/9Ix555BGeffbZNS94rWlcmIgAuPk86ePHyb/7LuHOTqLd3a0uaUOYIKD4zjvkT5zAuC4A8akp2h97DGehU1E2TuB51NJpvHyecFcXqT17SI6PE+npUcuuiIiIiGxrxhiKHuRqhnTVUPbAGIiGIOaArcfDIiLrQuPCGlv3nSw/+clP+L//7/+bf/7P/znRaJRLly7xuc99jjNnzgAwOTnJv/23/5b9+/ev7jvYQApZRGRR4HnkTp8mc/IkQbVKfGQEy3FaXdaG8MtlcseOUT57FgArHCb1yCMk77lHS9lbwAQBtUwGN5PBicWIj46S2rNHe1tEREREZEfwjaHg1gOX+aqh4oFlQSwEURudBBQRWUMKWRpb95ClkSAIeOONN3Ach3vuuYdQKLQWN7vuFLKIyI3KV6+SPnaM8gcfEBsaIpRItLqkDVObniZ75AjuwkjIUFcXHYcOER0cbHFlO5dXKlGbm8P4PtHeXlL79pEYHSWcSrW6NBERERGRdecG9cBlvhqQq0HFh5ANcQcijk4GiojcLYUsja1ryFIqlfj1X/91vvrVr/Jrv/Zrd1XoZqCQRUQa8cplMq+9RvbUKZxEgmhf3465ozFBQOnMGXLHj2MWdtTEd++m/fHHcXZQ4LTZBK67PEqso4Pk7t0kx8eJ9fer20hEREREdoSqb8jXIF0NKLjg+hB2IB6CkL0znq+JiKw1hSyNrXsnS3t7O//T//Q/8Q//4T9cdZGbhUIWEbkVEwQUzp8nffw4Xi5HfHR0R41qCioVcsePU3r3XQCsUIjUww+TvPfeHTNGbTMyxuBms9Tm57HDYeJDQ6SmpoiPjOBEo60uT0RERERk3RljKPtcF7gEBqILgYv2t4iI3DmFLI2te8jypS99icHBQf70T/901UVuFgpZROSjVOfmSB87RvG994j29++4MU212dn6CLGZGQBC7e20P/EEseHhFlcmfqVCdXaWoFYj2tND2969JHftItLZ2erSREREREQ2RGAMRQ9yVUO6aih79ctjIYg52t8iIvJRFLI0tu4hy/nz53nyySf52te+xn/0H/1HjI6OrrrYVlPIIiJ3wq9Wyb71Fpk33sCybWKDgztqRJMxhvLZs+SOHSOoVACIjY/T/vjjhNraWlydBJ6Hm8ngZrOE2tpIjI3RtmcP8YEBdR2JiIiIyI7hB4a8C9maIVMzVDywrXp3S8RW4CIi0ohClsbWPWRJpVJ4nketVgMgFAoRvWFEiWVZZLPZZm96wylkEZE7ZYyhdOkS6WPHqM7O7sjxTEG1Sv611yi+8w4Yg+U4tD34IG0f+xhWKNTq8nY8YwxeoUAtnQYgNjhI+9QU8dFRQtqnIyIiIiI7SM03FFyYrwbkalANIGzXA5ew9reIiCxRyNJYM7nBqs6IffWrX9VfuIjsOJZlkRwbI9LZSfr4cQpnzhDu6iLS1dXq0jaMHY3ScegQib17yR45Qu3aNfInTlA6e5aOgweJ7drV6hJ3NMuyCKdShFMp/GqVWjrNtcOHiXR20jY5Wf/57enRfbiIiIiIbHsRx6Lbge6YQ8Wrd7jMVQOKNcgbQ8SBuAOOAhcREblLq+pk2U7UySIiqxF4Hrl33iFz8iSB6xIfHt5xY5mMMZQvXCD36qsEpRIA0dFROg4eJKTfp5uGCQJqmQxuJoMTj5MYHa2PEhsawg6HW12eiIiIiMiGMcZQ8iBXM8xX67tcArO8v8XWi5FEZAdSJ0tj6z4ubDtRyCIid6P84Yekjx2jfOUKsaGhHTmSKXBdCidPUnjrLTAGbJu2+++n7cEHsTVCbFPxikVqc3NgDJHeXlJ795IYHSWcSrW6NBERERGRDRWY+jixxcCl7AFWvbsl6mh/i4jsHApZGlv3kOVf/+t/fUfXe+qpp5q96Q2nkEVE7pZXKjH/2mvk33kHO5Eg2tu7I++U3EyG3NGjVK9cAcBJJmk/eJDY2NiO/PvYzALXpZZO4xUKhDs6SE5M0DYxQbSvD8u2W12eiIiIiMiG8oJ64JKpGjI1Q9UHx1rc36LARUS2N4Usja17yGLf5gTMyn8I3/ebvekNp5BFRNaCCQIK586RPn4cr1AgPjKyI0cxGWOovP8+uaNH8YtFAKLDw7QfPEi4s7O1xclNTBDg5nLU5uexIxESw8O0TU4SHx7GiUZbXZ6IiIiIyIar+vXAJV0JyLtQC+pBSyIEIe1vEZFtSCFLY+sesly8ePGmy3zf57333uN/+V/+F95//33+/M//nHvvvbfZm95wCllEZC1VZ2dJHztG8eJFov39O3YMU+B5FN54g8Ibb0AQgGWR/NjHSD300I4Mn7YCv1ymOjdH4LpEe3pITU2R2LWLiMIxEREREdmBjDFUfMjVYL4aUHDBNxBx6iPFHAUuIrJNKGRprOU7Wb785S8zMTHBH/3RH631Ta85hSwistb8apXsm2+SeeMNrFCI2MDAjh3B5OVyZI8epXr5MgB2PE77448T371bd9ybVOB51Obn8fJ5QskkybExknv2EB8YwHKcVpcnIiIiIrLhjDEUvfr+lvTC/hZjIBqCmAO2ntuIyBamkKWxlocsf/zHf8x//V//18zOzq71Ta85hSwish6MMZQuXiR9/DjVuTniIyM7evxS5dIlskeP4ufzAEQGBuh44gnCXV0trkxuxRiDVyhQm5vDsm1ig4OkpqaIj44SisdbXZ6IiIiISEv4pj5OLFczzFcNFQ8sC2IhiGp/i4hsQQpZGmsmNwitRwHnzp2jWq2ux02LiGwJlmWRnJgg0t1N+vhx8mfOEOnqIrJDQ4XYrl1Eh4YovPUWhddfp3btGjP/7/9L8p57SD38MPYODqA2K8uyCKdShFMp/GqV6uwspcuXiXR20jY1RXJsjEh3tx6AiYiIiMiO4lgWHRHoiFgMJgz5GmRqAdkalFxwbEPcgYijx8kiIjvFqjpZXnjhhYaXZzIZXnjhBX7/93+fX/zFX+Tf/Jt/c9cFrjd1sojIegs8j9zbbzN/8iTG84iPjOzY8WEAXqFA7pVXqCzs97JjMdofe4z41JRO2G9yJgiozc/jZjI4iQSJ0VHa9uwhPjSkXTsiIiIisqNV/HrgMl8NyLvg+RB2IB6CkPa3iMgmpk6WxtZ9XJhtN/4LN8bgOA7/3r/37/EHf/AH9PT0NHvTG04hi4hslPKVK8wdO0bl6lXiQ0M4O3zkUuXKFXJHjuBlswCE+/roOHSISG9viyuTO+EVi9Tm5jBBQLS/n/a9e4mPjBBOpVpdmoiIiIhIyxhT39mSdyFdDSi4EBiILgQu2t8iIpuNQpbG1j1kOXz48M03ZFl0dXUxPj6+pcIKhSwispG8YpH5114j9847hNraiO7wQMH4PsW33yb/2msYzwMgsW8f7Y8+ih2Ltbg6uROB61JLp/GKRcLt7SR376ZtYoJob++O7tgSEREREQmMobiwvyVdrYcvUN/fEnO0v0VENgeFLI21fPH9VqKQRUQ2mgkCCmfPkj5xAq9QID46ih1alxVZW4ZfLJI7dozy+fMAWNEo7Y88QmLfPp2o3yJMEODmctTSaexolMTwMG2Tk8SHh3G0c0dEREREdjgvMBRcyNYMmZqh4oFt1btbIrYCFxFpHYUsja17yHLhwgXefPNNvvKVrzT8/F/+5V/ywAMPMDEx0exNbziFLCLSKtXZWeaOHaN08SLR/n6NWQKqV6+SPXIEb34egHBPT32EWH9/iyuTZvjlMtXZWYzvE+npITU5SWJsjEhHR6tLExERERFpuZpvyLuQqQbkalANIGzXA5ew9reIyAZTyNLYuocsX/3qV8nlcvzwhz9s+PkvfvGLdHZ28hd/8RfN3vSGU8giIq3kV6tk33iDzJtvYoVCxAYGdnznhgkCiqdPkz9+HOO6AMSnpmh/7LEdv8dmqwk8j9r8PF4uR7itjcT4OG27d9d/zh2n1eWJiIiIiLRcxasHLnPVgGINPAMRB+IOOApcRGQDKGRprJncYFVn8n72s5/x+c9//paf/1t/62/x4osvruamRUR2FCcapeuxx+j/9Kdx4nGK772HX622uqyWsmybtnvvpf+Xf5n41BQA5bNnmf7udymcOoUJghZXKHfKDoWI9fWR3LMHOx4n9847fPiDH/DhD39I/uxZvHK51SWKiIiIiLRULGTRF7fY32FzT5fNWJtFxIa8C+mKoeQZgp096V9EZNNb1RKA+fl5UrcZa9PW1sbc3NyqixIR2Uksy6Jt924i3d2kjx2jcP48ka4uIp2drS6tpZx4nK5PfpLkvn1kjxzBnZsjd/QopXffpeOJJ4gODra6RLlDlmURbm8n3N6OX61SnZmhdPkykY4OUnv3kti1i2hPT6vLFBERERFpGcuySIYhGbYYSNT3t+RqhnTVkK0CliHuQNTR/hYRkc1mVZ0sY2Nj/PSnP73l51988UVGR0dXXZSIyE4U6eig/2/8DXoOHcIvlylduqSuDSDS30/vl79Mx8c/jhWN4mUyzH3/+8wfPoxfLLa6PGmSE40SHx4mOT6OMYa5V17hyl/9FdMvvEDp0iUCz2t1iSIiIiIiLWVbFu0Ri9E2m/u6bPZ22vTFLHwD81XIVg01X90tIiKbxapClr/zd/4O/9f/9X/x+7//+wQrTgD6vs///D//z3z729/m7/7dv7tmRYqI7BR2OEzXAw8w8NnPEunupnDhAr5GKmHZNsn9+xn4pV8isX8/AOULF5j+3vfIv/EGxvdbXKE0y7Jtoj09tO3ZQ7i9ncK5c/VRYt//PrnTp/EKhVaXKCIiIiLSciHboitqsbvd5t4um8kOm44IVH2YqxhyNYMXKHAREWmlVS2+r1arfPnLX+a5556jr6+P/QsnvE6fPs3MzAyf+cxn+Ku/+iui0eiaF7zWtPheRDYrr1hk/sQJcqdPE2prI9rb2+qSNo3a3BzZl1/GnZkBINTeTvsTTxAbHm5xZXI3AtelOjeHXywS7uwktWcPifFxor29GokgIiIiIrLAGEPFh1wN5qsBBRd8AxEH4iFw9NhZRJqgxfeNNZMbrCpkAQiCgD//8z/nu9/9LufOnQNgcnKSr371qzz11FPY9qqaZDacQhYR2cxMEJA/c4b5EyfwSiXiIyPYoVWt09p2jDGUz50j9+qrBJUKALHxcdoff5xQW1uLq5O7YYIAN5vFzWSwIxHiIyO07dlDfHgYZwu8gENEREREZKMYYyh6y/tbyh4EBmIhiDn10WMiIrejkKWxDQlZtguFLCKyFVRmZkgfO0bp4kVig4MKEVYIajXyJ05QfOcdMAbLcWh78EHaPvYxLAVSW55XKlGbm8N4HtHeXtqmpkiOjRHWfbaIiIiIyHV8Yyi49Z0tmZqh4oFl1QOXqI1OnopIQwpZGlv3kCWdTnP58mUefPDBhp9/4403GB0dpaurq9mb3nAKWURkq/CrVeZPniR36hRWOExsYEB3fiu48/NkX36Z2rVrADipFB0HDxLbtavFlclaCDyPWjqNl88TTqVITkyQnJio/z/YIt2zIiIiIiIbxQ0M+RpkagHZGtR8CNn17paIo+eRIrJMIUtj6x6yfP3rX+f06dO8/PLLDT//iU98gnvvvZf/4//4P5q96Q2nkEVEthJjDMX33iN97Bi1+XkSo6PYkUiry9o0jDFULlwg++qrBKUSANHRUToOHiSk3/HbgjEGL5+nNjeHFQoRGxoiNTVFYmQEJxZrdXkiIiIiIptOxa8HLvPVgLwLbrCwv8WBkK0TqiI7nUKWxprJDVY1R+W5557jP/6P/+Nbfv4rX/kKf/Inf7KamxYRkduwLIu23buJdHWRPnaMwvnzRLq7iXR2trq0TcGyLOJ79hDdtYvCyZMUTp2ievky01eu0Hb//bQ9+KB22mxxlmURbm8n3N6OX61SnZ6m/P77hLu7SU1OkhgbI9rd3eoyRUREREQ2jZhjEYtDb8ym7EHOhXQloODWX8QUcSAe0v4WEZHVWtWZppmZGXp7e2/5+Z6eHqanp1ddlIiI3F6ks5P+T32KaG8vmddfp1QoEB8e1tikBXY4TPuBA8SnpsgdPUr1yhUKr79O+dw52h9/nNj4uF6dsQ040Sjx4WGM71PLZJg7epTsW2+R2LWLtj17iA0OKlQTEREREVlgWRaJMCTC0B+3KbqQqxnSVUOuCgZDLFQfKabnSyIid25VZx6GhoY4ceLELT9/7Ngx+vr6Vl2UiIh8NDscpuuhh4j29pJ+9VWKFy4Q18ik64Q7O+n+/OepvP8+uaNH8YtF5p9/nsjQEB2HDhFWB9C2YDkO0Z4eoj09eIUC+XPnyJ89S2xgoD5KbHSUUDLZ6jJFRERERDYN27JIRSAVsRhIGAouZGuGTM0wXwXbMsRDELEVuIiIfJRVhSy/+Iu/yB/90R/x8z//8/zCL/zCdZ975pln+Ff/6l/ddpyYiIisncTICJGODtInTpA/fZpQezvRnp5Wl7VpWJZFfHyc6MgIhTfeoPDGG9Q+/JCZZ54hed99pB5+GDscbnWZskZCbW2E2toIXJfq7CzTL7xAuKNjeZRYb6+eJIrIdfxqFTeXw81mqabTVK9dwwDhZBInmSQUj2NHo9iRCHY0irPw3o5EsCMR/U4REZEtL2RbdEahM2ox5Bvy7sL+lhoUXAjb9cAlrP0tIiINrWrxfTab5ZOf/CSnTp3ioYce4v777wfgzTff5LXXXuO+++7jJz/5CZ1b4BXCWnwvItuF8X3yZ88yf/w4XqVCfHhYo5Ia8HI5sq+8QvXSJQDseJz2xx8nvnu3TpRtQyYIcLNZ3Pl57GiU+MgIqcnJ+v+PSKTV5YnIBjPG4BUKuNkstUyGyvQ0tbk5vFKJwHWxbBsnHgfLwrgugeeB77P4hMmyLKxwGDsUwgqFcCIRnHi8HsYkEjix2HIQc0MYo/tkERHZaiqeWdrfUnTBM9T3tzjgKHAR2Ta0+L6xZnKDVYUsAMVikX/+z/853/3udzl37hwAk5OTfPWrX+W3f/u3qVardHV1reamN5RCFhHZbirT06SPHaN06RKxwUGNSbqFyqVLZI8exc/nAYgMDNRHiGlp+rbllUrU5uYwvk+0p4fUvn0kRkcJ6/5fZNsKajVq2exSl0rl2jW8fB6/XMYYgxON4iQShBKJOwpeTRBgfJ/AdTGed937wPOwVjy1shwHKxTCDofr76NRdceIiMiWZIyh5C3vbyl5YAxEF/a32LrfEtnSFLI0tiEhSyOVSoW//Mu/5Omnn+b73/8+lUplrW563ShkEZHtyK9UmD95kuypUzjRKNH+ft1RNmA8j8KpUxROnsT4PlgWyXvuqY8Qi0ZbXZ6sk8DzqKXTePk84fZ2khMTJMfHiQ0MYNl2q8sTkVVa2aXiZrNUpqepzs7e1KUSSiZx4vF1//8eeB5m4W0xhFn8mIX7HGNMvTtmZRgTCtVrXAh/nHh8KXxxVgQz6o4REZFWCMzy/pb5qqHigWXVw5aoo/0tIluRQpbGNjRkMcbwox/9iKeffprvfe975PN5ent7+fKXv8yf/umf3s1NbwiFLCKyXRljKF64QPrYMWrZLInRUe0euQWvUCD3yitULl4EwI7FaH/sMeJTU3qAsY0ZY/ByOWrpNFYoRGxoiNTUFImREZxYrNXlichHWNmlUpufp3z16nVdKnYkQiiRIJRMburxgLfrjjHewkuFqf/OWhxTZodC9bFl0Wj9e2xrU3eMiIhsOC+o72/JVA3ZmqHqg2PXx4lFHN3viGwVClka25CQ5dixYzz99NP8xV/8BVevXsWyLH71V3+V3/iN3+CJJ57YMv8gCllEZLurzc+TPnaMwvnzRHt7CXd0tLqkTat65QrZI0fwslkAwr29dDzxBJHe3hZXJuvNr1Sozs1hqlUiPT20TU2R3LWLyBYYfSqyE9yyS6VcJqjVNrxLpVXUHSMiIptV1a8HLvOVgLwLtQDCNiRCENL+FpFNTSFLY+sWspw/f56nn36ap59+mjNnzjAyMsLXvvY1Dh48yNe+9jW+853v8Mu//Mt3/Q1sJIUsIrITBLUa2VOnyLz+OgaIDw1t2xNQd8v4PsW33yb/2mv1VxADiX37SD36qLobdgDj+9Tm53FzOULJJIldu2jbs4fYwIBOPIpsoKBWw83lqGWz1NLpLdul0ip33B0DWLaNHQ6rO0ZERNaEMYaKD7kapKsBRRd8AxEH4iFwdN8hsukoZGmsmdzgjs8WfPzjH+fo0aP09vbyt//23+Z//9//dz75yU8CLC2+FxGRzcmOROh6+GGivb2kX32V4oULxDUSqSHLcWi7/37ie/aQe/VVyufPU3r3XcoXL9L+yCMk9u1TQLWNWY5DtLeXaG8vbj5P/swZ8mfPEuvvp33vXuKjo4QSiVaXKbKt3LZLpVqtd6ksnPSP9vXpd/AdsGx7KTz5KMb36x0xC50xXrGIm80udcxgWfVQZrE7ZjGMCYXq3UNtbfXumFjsugDGWfGxxpWKiOwclmURD9UDlf64TdGDXM2QrhrytfpOl3iovsNFJ3NFZLu445DlyJEj7N69m9/7vd/jy1/+MqF1fDXnH/3RH/GNb3yDq1ev8tBDD/EHf/AHHDx4sOF1/+zP/oy///f//nWXRaNRKpXKutUnIrJVJUZHCXd0MH/iBLl33yXc3k60p6fVZW1KTiJB16c+RWLfvvoIsfl5si+/TOndd+sjxPr7W12irLNwKkU4lSKo1ajOzXHt8GHCnZ2k9uwhOT5OpKdHTwxFVmFll4o7P0/5ww9xG3SpRHt7caLRVpe77VmOg+M48BF/1426Y/z5eSrT07fvjgmFsGOxenfMYvfRrbpjwmGFaCIi24hlWbSFoS1sMZAwFFzIVg3zNUOmCpZVD1witgIXEdna7jgp+cM//EO+9a1v8Uu/9Et0d3fz1a9+lV/91V/lM5/5zJoW9O1vf5vf+q3f4k/+5E84dOgQ3/zmN3nyySc5ffo0/bc4odXe3s7p06eX/qxfzCIitxZOpej7uZ8j2tvL/GuvUXr/fWLDwxqFdAvRwUH6vvIViqdPkz9+HDedZvbf/Tvik5O0HziAE4+3ukRZZ3YkQnxoCBMEuNks6ePHyZ46RXx0lNSePcSHhjSuSOQWbtelYmo1sCx1qWwR6o4REZG74VgWHRHoiFgMBfWulkwtIFuDogshux64hLW/RUS2oKYX31+4cIGnn36ab33rW7zzzjsMDg7yN//m3+Qv/uIv+M53vsMv/dIv3VVBhw4d4vHHH+cP//APAQiCgF27dvGbv/mb/JN/8k9uuv6f/dmf8V/8F/8FmUzmjm6/Wq1SrVaX/pzL5di1a5d2sojIjlS5do25Y8coX7pEbGiIUDLZ6pI2Nb9cJn/8OKUzZwCwwmFSjzxC8p57dGJwh/FKJWpzcxjfJ9rTQ2r//nqnWCrV6tJEWqpRl4qXz9dDlRVdKk4ioS4VwRjTcGfMYkBzU3dMKFTvdgmF6j9LC2FMw+6YxQ4ZdceIiGxqFb8euMxXA/I1cBf3tzgQUuAisiG0k6WxdVt8f6Njx47x9NNP8+1vf5sPP/yQgYEBvvKVr/ALv/ALfO5znyPW5Kz/Wq1GIpHgO9/5Dr/4i7+4dPnXv/51MpkMzzzzzE1f82d/9mf8g3/wDxgZGSEIAh599FH+x//xf+RjH/tYw2P8t//tf8vv/M7v3HS5QhYR2am8cpnMyZNkT53CicWI9vfrTvUj1GZmyL78Mu7cHAChzk46Dh0iOjTU4spkowWeR21uDq9QINzeTnL3bpLj48T6+3VST7a9pS6VXA43k6l3qczN4ZVK13epJJM48bj+T8hdubE7ZjGQubE7xsD1o8rCYZx4HCeRINzWVu+OWTmibGWHjLpjRERaxhhDecX+luLCJMqIU9/vYus5qsi6UcjS2IaFLIuCIOC5557j//w//0++973vkc/nSSQSFAqFpm7nypUrjIyM8NJLL/Hxj3986fLf/u3f5vDhwxw5cuSmr/nZz37GmTNnePDBB8lms/yLf/EveOGFF3jrrbcYHR296frqZBERuZkxhsL586SPH8fNZkmMjupEw0cwQUDpzBlyx49jFu5X4rt310eIqSNoxzHG4OVyVNNp7HCY+NAQqakp4iMjerW+bBs3dalcvYqXy6lLRTYVdceIiGx9gTEU3eXApeLVf2/HQhBztCZAZK0pZGlsw0OWlSqVCs888wzf+ta3Gnae3M5qQpYbua7Lvffey9/5O3+H//6//+8/8vrN/GWJiGx31XSa+ePHKZw/T7Svj7B+L36koFIhd+IEpYXdYFYoRNtDD9F2331YjtPi6qQV/EqF6uwsxnWJdHfTtncvydFRIl1drS5N5I5d16WycpfKjV0qC6GKTjjLVrTUHdMglDG+f10gc10Yo+4YEZEN4wWGggvZqmG+Zqj59ebFeAgitgIXkbWgkKWxZnKDNd9yHIvF+NrXvsbXvva1pr+2t7cXx3G4du3adZdfu3aNwcHBO7qNcDjMI488wtmzZ5s+vojIThft7qb/U58i0tND5o038AoFYoODOnl2G3YsRufHP05i3776CLGZGfLHjlE6c4aOQ4eIjYy0ukTZYE4sRmJ0FOP71ObnmXv5ZbLJJImxMdp27yY+OKgATjadj+xSCYcJJZNEe3vVpSLbhuU4OI4DH/EzfVN3jOfhz88TzMxc3x1jDJbj1AOZUAgrHK4HLgthTCiZvHUYE4no8ZaISAMh26IzCp1RiyHfkHeX97cUXAjbhngIwtrfIiIttOYhy92IRCI89thj/OhHP1rayRIEAT/60Y/4jd/4jTu6Dd/3eeONN/jSl760jpWKiGxfdiRC9yOPEOvtJX3sGMULF+ojj5rcs7XTRHp66P3SlyifO0fu1VfxcznSP/whsfFx2h9/nFBbW6tLlA1mOQ7R3l6ivb24+Tz5d98lf+YMsYEB2qemiI+OEkokWl2m7EB33KWSTBLp69OJX9nxLMuqByZ30JVyY3eMX6ng5vOUP/jguu4YLKseyCx2x4RC9VF7N3bHrAhl1B0jIjtdxLHocaAn5lD26oFLuhJQdCFvTH1/iwOOAhcR2WCbKmQB+K3f+i2+/vWvc+DAAQ4ePMg3v/lNisUif//v/30AnnrqKUZGRvjd3/1dAP67/+6/44knnmBqaopMJsM3vvENLl68yD/4B/+gld+GiMiWl9i1i3BnJ/MnTpA7fZpwZyfR7u5Wl7WpWZZFYmqK2NgY+ddeo/j221QuXqRy+TKpBx+k7WMfwwpturte2QDhVIpwKoVfrVJLp7l2+DCRzk7aJidJjo0R6elRW7asm8B1cbPZ5S6Va9fwsll1qYisg2a7YxbDmOu6YzwPgmD5you7Y+6wOybc3q7/yyKy7cVDFvEQ9MVsSl59f8tctR68GGOILuxvsfUYW0Q2wKY70/O1r32NmZkZ/tk/+2dcvXqVhx9+mO9///sMDAwA8P7772OveDXd/Pw8//Af/kOuXr1KV1cXjz32GC+99BL33Xdfq74FEZFtI5xK0fdzP0e0t5f5116j9P77xEdGNOroI9iRCB0HD5LYu5fsyy9Tu3aN/IkTlM6epePgQWK7drW6RGkRJxolPjSECQJqmQzpY8fInjpFYnSUtj17iA8N6RXKcldu6lKZmaE6M4NXKhFUq/UTwPG4ulREWmyxO4aF/S63c9vuGM9beaNYjkNoYURlYmSEaF+fAhcR2dYsyyIZhmTYoj9hKLqQrRnmq4ZMFWzLEHMg6mh/i+wMxhgMEJj6Xjljlj++8f3i5wIDKT0NvStrvvh+q9HiexGRO1O+epX0sWOUP/iA2NCQxhzdIWMMlQsXyL76KkGpBEB0dJSOgwcJ6X5HAK9YpJZOQxAQ6e0ltXcvidFRwqlUq0uTLWCxS8XN5agt7lJp0KXiJBI60SqyzS12x3iFAm42C0Ckq4vk+DixoSFifX0K8kVkx/CCeldLpmrI1gwVH0J2fZxYxFHYIpvPjeFIYOohyO3CEYv6n6H+8eIHFmADllV/s1dc5tjgWPV9R44FIas+Yi9iQ3dM/zdWaiY3UMiikEVE5I555TKZ114je+oUTiJBtK9Prwa6Q4HrUjh5ksKpU/URILZN2/330/bAAzrhIUD9Z6SWTuMVCoQ7OkhOTNA2MVH/f6ZuA+EjulRqNSzLWupScRIJ/dyI7HCB5y2FsJZtE+nuJjk+TnxwkGhfH7ZGmIrIDlH164HLfCUg70ItgIgN8VD9RLPI3bhVOBJwc0iyGI6stBiUWHcQjiwGIivDEduqf962bnhrdJnO3zRFIUsTFLKIiDTHBAGF8+dJHz+Ol8sRHx1VSNAEL5sle+QI1StXAHCSSdoff5zY+LgCKwHqD9LdbJba/Dx2JEJiaIi2qSniw8PqRNhhGnap5HL1BfXqUhGRJiz+PvHyeaxQiEhnJ8k9e4gPDBDt7dUoWBHZEYwxlH3I1yBdDSi64Jv6KLFYCBw9H9tRjDE3ByErwpGVn2sUjiy6q3DkjgMS/Wy2gkKWJihkERFZnercHOljxyi+9x7Rvj7C+h16x4wxVN5/n9zRo/jFIgCRoSE6Dh0i3NnZ2uJkU/ErFaqzswSuS7S7uz5KbNcuIvo52XaMMfjFIrVcDjeTuX2XSjyuE6IismpBrUYtk8ErFLAjESLd3bRNTBAbHCTa06MuOBHZEQJjKHqQrxnSVUPJq59Ij4cgpv0tm1oz4cji5xq5MRyxreXLHJbHajm2RchevOwjwpGbLtfP0VamkKUJCllERFbPr1bJvvUWmTffxLIsYoODemLehMDzKLzxBoU33qiPELMskvfdR+rhh9UdJNcJPA83k8HN5QglkyTHxpZegayT7VvT7bpUMAZLXSoisgH8ahU3k8ErFrGjUaK9vfXAZWCASFeXHteJyI7gB4aCV9/fkqkZKl79BHk8VB8rpsBlbawMR64bn3XD+8WPWXHGeuXJ68UJb4thhrUyHLEWgxEIWQvhyELYcafhiGPp31zqFLI0QSGLiMjdMcZQunSJ9PHjVKeniY+O6oRgk7x8nuzRo1QvXQLAjsdpe+ABIr29hLq6FLjIksWdHLW5OSzbJjY4SGpqivjoKKF4vNXlyS1c16WSzVKdnqbSoEvFSSQIJRIKzkSkJfxKhVomg18q4cRiRPv7aRsfJzYwQLizUyecRGRHcANDvgbz1YCcC1Ufwgv7W8I7dH+LMabx4nUahyPGLC9hNyx/bN0iHFn8c8ha7B6phyOhhbBjMfhYGsFlrQxDFkZyLXWi7Mx/I1kfClmaoJBFRGRtuPk86WPHKJw5Q7iri0hXV6tL2nIqly6RPXoUP5+/7nKnvZ1wd/fyW1cXdiKhB5A7nF+tUpubw69UiHR20jY1RXLXLiI9PfrZaLHAdZeW09fm5ylfu4aXzapLRUS2DK9Uws1m64FLIkF8YIDk+DjRgQEiHR2tLk9EZENUPEPerQcu+Rq4BiIOxB0IbYHAJTDmpsXrNy5nvzEwafRdNQpHVgYetwpHFoOPxeuu/PON3SN6/iKbkUKWJihkERFZO4HnkXvnHTInTxK4LvHhYb0iu0nG8yiePk31yhXcdJqgXG54PTsaJbQyeOnuJtTRobEeO5AJAmrz87iZDE4iQWJ0lLY9e4gPDakLagM06lKpzs7iFYv46lIRkW3AKxbrgUulQiiZJLYQuMQGBginUq0uT0Rk3RlT39mSqxnmq/VdLoGBqFPvcFnrvRt3Go6s7CqxuL5rBJZHaC2GIdYNgcfKsVrOLcKRj1rMrnBEtjOFLE1QyCIisvbKH35I+tgxyh9+SGxwkFAi0eqStiy/XMZNp3HTabz5+fr7bLbx9j7bJtzZeX340tWFrVfK7xhesUhtbg4TBET7+2nfu5f4yIhOgq0hdamIyE61FCpnMgS1GuG2NmJDQyTHxoj19xNqa2t1iSIi6y4whqIL2YXApezVL4+F6qFLw8Xr3DocWbRyvJa9inDkup0jd7B7ROGIyEdTyNIEhSwiIuvDK5XInDxJ7u23seNxon19eiC3RsziEvR0Gi+dxl0IX4zrNry+k0zWO11WhC9OW5v+PbaxwHWppdN4xSLh9naSu3fTNjFBtLdX3U5NuKlLZWaG6sxMvUulWsWybXWpiMiOZIKg3uGSyWA8j1AqRXxkhMTICLGBAb3ARkR2BC8wFFzIVg3zNYMbLIQjS0HGrcORkF3/2EbhiMhmpZClCQpZRETWjwkCCufOkT5+HK9QID4yovFF68QYg18oLHe9LLz3i8WG17fCYcJdXdeHL52dWKHQBlcu68kEAW4uR21+HjsSITE8TNvkJPHhYXVZNLDUpZLLUUunG3apOIlEvVNFf38iIsBC4JLP42azBJ5HuKOD5Ogo8YXAxYnFWl2iiMi6q/mGanDr0VoKR0S2HoUsTVDIIiKy/qpzc6RffZXixYtE+/s1umgDBdXqUqfLUviSyUAQ3HxlyyLU0VEPXhYCmHB3N048vuF1y9rzy2Wqc3MYzyPS00NqcpLE2NiOXWBsjMEvlahlszd3qWiXiojIqiyG++7CaNNwezuJsTESw8NE+/sVUIuIiMiWoZClCQpZREQ2hl+tkn3zTTJvvonlOMQGBjS2qEVMEOBls0vBy2L4ElSrDa9vx+NLXS+LnS+h9nb9+21RgedRm5/Hy+cJJ5Mkxsdp2727/n9yGwcJDbtUcjm8YvH6LpVEQq+6FhFZA8b3lwMXINzZSdv4OLHhYWK9vdiRSIsrFBEREbk1hSxNUMgiIrJxjDGU3n+f9LFjVOfmiI+M6BWNm4QxhqBUuq7rxU2n8XO5hte3HGe526Wra2nkmMbBbR3GGLx8nlo6XQ8+BwdJTU0RHxkhtMW7l27qUpmdpTo9rS4VEZEWCTwPN5vFy+XAtol0dZEcHyc+NES0t1ePH0RERGTTUcjSBIUsIiIbz83lSB8/TuHMGcJdXUS6ulpdktxC4Lp4i8HLwntvfh7jeQ2v76RSSx0vi2PHnGRSM4g3Ob9apTY3h1+tEunoILV3L4ldu4h0d2+Jf7vFk3eL+2fKV6+qS0VEZJMKXHfpd7YdCtUDl4mJpcBFwbeIiIhsBgpZmqCQRUSkNQLPI/f228yfPInxPOLDw3pSvUWYIMDP52/qeglKpYbXtyKR64KXcFcXoc5O/XtvQiYIqM3P42azOPE4ybGx+iixwcFN8yrjxS4VN5ulpi4VEZEtLajVqGWzePk8djhMpKeHtokJYoODRHt6NJpUREREWkYhSxMUsoiItFb5yhXSx45R/vBDYkNDhBKJVpckq+RXKniLocti10smA40eatg2oY6Om8IXW10Gm4ZXLFKbm8MEAbH+flL79pEYGSHU1rahddyuS8UEAXY4jJNMEkoksKPRLdF5IyIiN/OrVdxMBq9YxI5Gifb01IP+/v56Z6UCFxEREdlAClmaoJBFRKT1vFKJ+RMnyL3zDk4ySayvr9UlyRoxvo+XyVzX8eLOz2NqtYbXtxOJ64OX7m6cVEonzlsocF2qc3P4xSLhjg5Sk5MkxsaI9vWty7+LVywud6nMzVG9dq1hl4oTj2OHQmt+fBERaT2/UqGWyeCXSjixGNG+PtomJoj29xPp6tLjAhEREVl3ClmaoJBFRGRzMEFA4exZ0idO4BUKxEdHdQJ1mzLG4BeLN3W9+Pl8w+tboRChrq6bdr3o52NjmSCod5RkMliRCInhYdomJ4kPD+NEo6u6zdt2qRiDHQqpS0VEZIfzy2VqmQxBuYwdjxPr6yM5MUFsYIBwR4fuG0RERGRdKGRpgkIWEZHNpTo7y9yxY5QuXiTa3084lWp1SbJBgloNd35+OXxJp3EzGfD9m69sWYRSKUI3dL3Y8bhOtmwAv1ymOjuL8f36OJepKZJjY4Q/4rHUYpeKm8tRmZ1Vl4qIiDRl8X7Er1QIJZPEBgZIjo0RGxzUY0YRERFZUwpZmqCQRURk8/GrVbJvvEHmzTexQiFiAwOaw71DmSDAy+Xq+11WhC9BpdLw+nYsttTpstT10tGhn591EngetXQaL58nnEqRnJggOT5ObHCw3vmSy9VHf92qSyWRIJRMqktFRESastgVW8tkCGo1wskkseFhErt2ER8Y2PD9YSIiIrL9KGRpgkIWEZHNyRhD6eJF5o4dw02niY2MrHokkWw/fqm0NGZsMXzxcjlo9LDGtgkvhC6h7u6lj+1IZOML36aMMXj5PLV0GstxiPb1EVSreMUiQbUKUO9QUZeKiIisMWMMXqGAm8kQeB7htjbiIyMkRkeJDQwQSiRaXaKIiIhsQQpZmqCQRURkc6tls6SPH6dw9iyR7m4inZ2tLkk2qcDz8DKZpW4Xb2Hfi3Hdhtd32tpu6npx2trUUXGX/Gq1vrclFFKXioiIbCgTBEuBi/F9QqkUidHRpcDFicVaXaKIiIhsEQpZmqCQRURk8wtcl+w775A5eRJ8n9jwsMY/yR0xxuDn8/XgZUXni18sNry+FQ5ft+Ml1NVFuLMTS50XIiIiW8rKsZUEAeGODhK7dpEYGSHa368OaREREbkthSxNUMgiIrJ1lK5cIX3sGJWrV4kPDeHE460uSbaooFpd6nhZCl8yGQiCm69sWYQ6OpaDl4WRY/r5ExER2RqM7y8HLkC4o4Pk+Djx4WFifX0aISoiIiI3UcjSBIUsIiJbi1csMn/iBLnTpwm1tRHt7W11SbJNGN/Hy2avC17cdBqzsFPkRnY8flPXS6i9XV1WIiIim1jgebjZbH2Xm2UR6eoiOTFBfHCQaF8fdjjc6hJFRERkE1DI0gSFLCIiW48JAvJnzjB/4gReqUR8ZESLtGVdGGMISqXlrpeFAMbP5Rpe33Kc63a8LIYvOmEjIiKy+QSui5vN4ubz2I6zFLjEBgeJ9vbq8aWIiMgOppClCQpZRES2rursLHPHjlF67z1ig4OE2tpaXZLsEIHr4q3odnHTabz5eYzvN7y+k0pdF7yEu7uxEwkthBcREdkkAtellsng5/NY4TCR7m6Su3cTHxgg2tOD5TitLlFEREQ2kEKWJihkERHZ2vxqlfmTJ8mdOoUVDhMbGNCJa2kJEwT4+fxNXS9BqdTw+lY0Wg9cVnS+hDo6dBJHRESkxfxqtT5SrFDAjkaJ9vTQNjFBbGCASHe3RoOKiIjsAApZmqCQRURk6zPGUHzvPdLHj1NLp0mMjmqBqWwafqWCtzJ4Safxsllo9BDMtgl1dl4XvIS7u7Gj0Y0vXERERPArlXrgUiziRKNE+/rqI8UGBoh0denFPSIiItuUQpYmKGQREdk+apkM6WPHKJw/T6S7m0hnZ6tLEmnILC7dvSF8Ma7b8PpOMkloMXRZCGCcVEondkRERDaQXy7XR4qVSjiJBLEVgUu4o0P3yyIiItuIQpYmKGQREdleAtcle+oUmddfxwQB8eFhjXSQLcEYg18oLO13WQxe/EKh4fWtUKg+YmzlrpfOTiwt6RUREVl3XqmEm8ngl8uEkkliAwMkx8frgYvOLYiIiGx5ClmaoJBFRGR7Kn3wAelXX6Vy7RrxkRGcWKzVJYmsSlCr4S6ELt6KXS8Ewc1XtixC7e3L4cti10sisfGFi4iI7ADGGPxSidr8PEGtVg9choZIjo0R6+8nnEq1ukQRERFZBYUsTVDIIiKyfXmFAukTJ8ifPk2ovZ1oT0+rSxJZEyYI8LLZpcBlMXwJKpWG17djsaVul8XOl1B7u7q8RERE1pAxBq9QwM1kCFyXcCpFfHiYxK5dxPr7CSWTrS5RRERE7pBCliYoZBER2d6M75M/e5b548fxKhXiw8PYGqck25AxhqBcvm7Hizc/j5fNNv4CxyHc2Xl9+NLVhR2JbGzhIiIi25AJArxCgVomA55HqL2d+MgIydFRogMDhOLxMWQZtwAAYXNJREFUVpcoIiIit6GQpQkKWUREdobKzAzpV1+ldOkSscFBvZJQdozA867b8bLY+WI8r+H1nVRqaczYYteLk0xqma+IiMgqmSDAzeXwcjlMEBBqbye5axfx4WFiAwM40WirSxQREZEbKGRpgkIWEZGdw69UmD95ktzbb2NHIkT7+3XiWHYkYwx+Pn9d14ubThOUSg2vb0UiS8HLUudLZyeW42xw5SIiIlub8X3cXA43lwNjCLe3kxgfJzE8TKy/Xx2lIiIim4RCliYoZBER2VmMMRTfe4/0sWPUMhkSIyN6MiuyIKhUcFd2vaTTeJkMNHq4aFmEOjuvC19C3d04sdiG1y0iIrIVBZ5X73DJZsGyiHR1kRwfJzY0RKyvDzscbnWJIiIiO5ZCliYoZBER2Zlq8/Okjx2jcP480d5ewh0drS5JZFMyvo+Xzd7U9WJqtYbXtxMJwp2dOMkkdiKBk0wuvyUSCjVFREQaCDwPN5vFzeWwbJtodzeJ8XHiQ0NEe3u1U1BERGSDKWRpgkIWEZGdK6jVyJ46Reb11zHGEB8exrLtVpclsukZYwhKpZuCFz+f/8ivtcLhpcBlZQCzMpDRK3dFRGQnC1wXN5vFy+WwwuF6h8vu3cQHB4n29Ghcp4iIyAZQyNIEhSwiIlK6fJn0q69SmZkhPjyscUciqxS4bj1syeXwSyX8YnH5rVS6ZffLjZaCmBvCGHvFnxXEiIjITuBXq/XApVCo7xTs6SG50OES6e7WC4RERETWiUKWJihkERERADefZ/6118i/+y6hVIpoT0+rSxLZdgLXXQpcghXhy8owxrjuHd2WFYnc1A2zFMAoiBERkW3Ir1ZxMxm8YhEnGiXS20vb7t3E+vvrgYtltbpEERGRbUMhSxMUsoiIyCLj++TPnGH++HH8apXY8LDmX4tssKUgplgkaNAN03QQc2NHzA2dMfo/LiIiW5FfqVCbn8cvl3HicaJ9fbRNTBDr7yfc2anARURE5C4pZGmCQhYREblR5do15o4do3zpErGhIULJZKtLEpEVglrtug6Y68KYtQhiVvxZQYyIiGx2XqmEm8ngl8uEkkliAwMkx8aIDQ4S1nkOERGRVVHI0gSFLCIi0ohfqTB/8iTZU6dwolGi/f16RaDIFhLUajeNI7uxM8Z43h3dlhWNXh/ANAhjLAUxIiLSYsYY/FKJWiZDUK3WA5fBwXrgMjBAOJVqdYkiIiJbhkKWJihkERGRWzHGUDh/nvTx47jZLInRUe14ENlGloKY24QxdxrE2NEo9i0CGAUxIiKy0YwxeIUCbiZD4LqE29qIj4yQGB0lNjCgTm0REZGPoJClCQpZRETko1TTaeaPH6dw/jzRvj6NXRDZIYwxmJWjyW7ohAkWLmsmiFncBdNwT4yCGBERWQcmCPAKBWqZDHgeofb2euAyMkJscJBQPN7qEkVERDYdhSxNUMgiIiJ3IqjVyLz1Fpk33gAgPjSEZdstrkpEWu2mIOaGzpimg5hYbCl0uVVnjOU46/xdiYjIdmWCAC+fx81mCXyfcEcHydFR4iMjxAYGcKLRVpcoIiKyKShkaYJCFhERaUbp0iXSx45RmZ4mPjKCE4u1uiQR2eSWgpgG3TArwxjj+3d0e3YsthS43NQVoyBGRETukAkC3FwON5sFYwi3t5MYGyMxMkK0r0+Bi4iI7GgKWZqgkEVERJrl5vPMnzhB7t13CXd0EO3ubnVJIrLFXRfE3LgnZkUwQ7NBzI1hzGIgoyBGRERWCDxvqcMFINLVRXJ8nNjQELG+Pu0lFBGRHUchSxMUsoiIyGoY3yd3+jTzr71GUK0SGx7G1i4FEVlHxhhMtXrLAGbxz6sKYhbe7Bv2xGgsoojIzhN4Hm42i5vLYdk2ke5ukuPjxAcHifb16TGviIjsCApZmqCQRURE7kb56lXSx49Tvny5vjg0mWx1SSKygxljCKrVpV0wN3XFLHbEBMEd3Z4djzccR7ZyTJmCGBGR7StwXdxsFi+fxwqFiHR2ktyzh/jAANHeXnVFiojItqWQpQkKWURE5G555TKZkyfJvvUWTiJBtK8Py7JaXZaISEPXBTG32RPTdBBzQxizsitGQYyIyNYX1GrUMhm8QgE7EiHS3U3bxASxwUGiPT36XS8iItuKQpYmKGQREZG1YIKAwvnzpE+cwMtmiY+Oana1iGxZi0HMYvByUyDTTBBjWfUg5oZumOvGlP3/27vz+MiqOv//73trubVl35NOJ91NL2zS0E2j7ILaIqjoIOBXRNsNBwEVUJZhRGAQkBFkEEX9OjIijuKCy1dcRga/X/TH6AiD9kZvWbqh6YU0qSRVSW33/P6opJLqJN2dtbK8no9HPZKce2/dU+Fwu3Lfdc4nGOTmHADMIplEQqnOTqVjMdmOI6eyMhu41NTIX1bGNR0AMOsRsowBIQsAYDIlOjp04PnnFWttlVNVJR//tgCYo4wxcvv6cqHLiDNj4vHxBzEHBTIEMQAwM2X6+pTs7FQmHpcnEJBTXa1IU5MCNTXylZYywxsAMCsRsowBIQsAYLK5yaQ6N2xQ54YNsixLgdpabgwCmJfygpjRwpixBjEjzYYhiAGAGSEdjysVjWYDl1BIwZoahZua5NTUyF9SUujuAQBwxAhZxoCQBQAwFYwxiu/apQPPP6/Evn0KLlggj+MUulsAMOMYY+T29g6bAeMeVCdGR/Jni2XJEwoN1oMZIYwhiAGA6ZGOxbKBS1+fvOGwAv2BS6CmRr6iokJ3DwCAQyJkGQNCFgDAVEp1d+vA88+re+tW+cvK5C8rK3SXgBEZ180+MhlpyPcD7Rr685B2q/+t5MAbSkvZm+aWxyOnslLecLhgrwlzx4hBTCwm9+ClycYSxIwyG8ZTVCRPIDD1LwoA5gljjDKxmJKdnXKTSfkiEQXq6hReuFCB6mp5I5FCdxEAgGEIWcaAkAUAMNXcdFpdW7ao869/lZtMKlhfL8vjKXS3MMtNZigiYyTbzo5L25Zl27JtW/J4ZPW3Wx6PbL8//+Hzyfb5ZHm9sj0eyeOR7fHIGKNYe7viu3bJ7euTr7xcvpIS1mTHlDKuO2xpsmEzY44wiPFXVyvQ3KxgU5M8BIUAMGmM62ZnuHR2yqTT8hYVKdjQoFBDgwI1NfKGQoXuIgAAkghZxoSQBQAwXXr37NGB555T7+7dCtTW8kfkPHPIUCSTkYw58lBEkixr7KGI3y/b6x0Wilheb/aYga8jtY8xIDHGKNnRoe6WFsVaWpSKRuUtKZFTXk7IiIIZFsQcFMYMzIwZKhe4NDfLw3UbACaNcV2lu7uVikblZjLyFRcrUFkpX0mJvOGwPIGAPMFgdqZhICDb5yt0lwEA8wghyxgQsgAAplM6HlfnX/+q6KZN8oRCcqqq+HT/DHW4UCQ3W2SyQhGvNzszpEChyFRKdXcr1t6u7q1blezokB0IyKmslO33F7prwDCZWEy97e3qa2tTct++vG3+6moFFi3KznAhcAGASWNcV6muruzMw2QyO+vQmOx7IMeR7fPJEw7LX1IiX1FRNnwJBgeDGOptAQAmGSHLGBCyAACmm3Fd9ezYoQP/8z9Kd3UpuGABn8ybBIcMPw4Rihy8dNDBoYhl29JoocjAklljDEVsrzf7PDM0FJkqmURC8V271LV1q/r27JFlWfJXVjKrCzPWIQOXmhoFm5sVIHABgCnjptNyk8m8h0mlctstv18en0+248gbicg3NIQZEsDYfv+8eK8FAJg8hCxjQMgCACiUREeHDjz3nGJtbXKqq+UrKip0l6bVhEMRY7JByMATHi4U6a8f4vH5ZI0nFOmfMTKfQpGp4qbT6tuzR93btyu+c6cyiYT81G3BDJeJxdTb1qbe9nalCFwAoOCMMTKplNxkUplEIhfCKJORLEuyrOwsGL9fHsfJBjDFxdmlyA6aCWN7vYV+OQCAGYaQZQwIWQAAhZRJJBTdsEGdGzbIsm0Famtn7FIHEw1FLGWX0BpLKOIZCEHGG4oMnTHCzfsZxxijxKuvqqe1NVu3patLvpIS+cvKqNuCGS0XuLS1KbV/f942f02NgosWKbBwIYELABSQcd1hs2DcZFKmfymyobORveGwfMXF8hUXD1+KLBCYse/PAQBTh5BlDAhZAACFZoxRfOdOHXjuOSU6OhRsaJDHcSb+vIUKRQZmigz84UoogiOQ6urK1m3Ztk2JAwfkcRzqtmBWOGTgUls7OMMlGCxQDwEAI3H7Z8HkPdLp7Htfy8q9t/UEAvJGIvKXlsoTDuctQ+YJBCblfTsAYOYhZBkDQhYAwEyR6urSgeefV8+2bfKWlMgTCIwcigwJRI40FLE8nmxoMcZQxBqpdgihCKZQpq9P8ZdeytZteeUVWbZN3RbMGumeHvW1t6u3tVWpV18d3GBZ+UuKEbgAwIxmXHfEEMa4riTJsu3s+2bHkScQkL+kRN7iYvlCoWEzYZidCwCzEyHLGBCyAABmEjedVtfmzYpu2iS5rmTbYw9FDq4dQiiCWchNp9X3yivq2r5dvbt2KZNIyKmokLe4mLGLWSHd06O+gRkuBC4AMKeYTCYXvGSSSbmJhEw6Pfjhp/46gLbjyBuJZGvBFBXlAhhv/1fbcXhfAwAzFCHLGBCyAABmonQsJkmEIpj3cnVbWlqydVt6euQrLqZuC2aVdHd3dobLSIHL0CXFAoHCdRIAMCmMMTLp9PClyFKp7Exzy8p+WMpx5HGcbC2YkhJ5D16KLBiU7fMV+uUAwLxFyDIGhCwAAACzQ17dlo4OeYLBbN0WbkBgFiFwAYD5LbcUWSKRF8LkZsF4PNnZ6n6/PKGQfCUl8hcXD1uGzBMMZmslAgCmBCHLGBCyAAAAzC6Zvj7Fd+3K1m3Zs4e6LZi1coFLa6tSHR2DGwhcAGDeckeYBWNSqexGyxpciszvl7eoSL6SEvkikbwZMJ5gULbfz0x4AJgAQpYxIGQBAACYndx0Wr27d6t7xw7Fd+2Sm0zKKS+nbgtmpXR3t3rb2tTX1jYscHHq6hRoblZg4UICFwCYx4wxMqnUYC2Y/nowymQky5IsS7bjZGfBOE42gCkuHr4UWSDATGAAOAxCljEgZAEAAJjdjDFK7N+vntbW/Lot5eUso4FZ6UgCl+DChbIJXAAAQxjXHV4LJpnMbbP7Z8AMLEXm7w9hhi1FFgjwHgrAvEfIMgaELAAAAHNHMhpVbOdOdW/dquSBA9RtwayX7uoaDFwOHBjcQOACABgjN50eVgvGTadlSYNLkfn9sh1H3khE/tJSeSORYbNgPI5T6JcCAFOOkGUMCFkAAADmnnRvr3p37VLXtm1K7N0r2bacykp5gsFCdw0Yt4HApbetTekRApfgokUKLFwom5tfAIAxMq4rt38psrx6MK4rSbJsOzsLxnHkCQTkKy6Wr6RE3iF1YAa+tzyeAr8aAJg4QpYxIGQBAACYu3J1W7ZtU/zll7N1Wyoq5C0qom4LZrVDBi719Qr213AhcAEATAaTyeSCl4F6MCaVyoUw9kGzYHzFxfIWFY28FBnvwQDMAoQsY0DIAgAAMPcZY5TYt2+wbkssJl9JifxlZaw5jlkvHY0OBi6vvTa4gcAFADBNRpoF46bTkiTLsrL1YBxHHseRt6gouxRZODxsKTLb7y/wKwGALEKWMSBkAQAAmF+SnZ2Ktbere9s2JV97jbotmFNGDVxsOxu4NDURuAAAplXeUmRDasKo/5ak5fFklyLz++UJBuUrLZWvqCi7/FgolBfE8OEYANOFkGUMCFkAAADmp1zdlq1b1bd3ryyPh7otmFMOG7g0NyvQ2EjgAgAoKDedHl4LJpXKhjCWJcvvl8fnk+33y1tUJF9JiXyRyOAyZKGQPMGgbL+fpciAQzDGSK4r0/+QMdmvrivL55OH94R5CFnGgJAFAABgfnNTqWzdlu3bFX/5ZZlkUn7qtmCOSXV2qq+9Xb2trUp3dg5uIHABAMxgxhiZ/lkwmSEhjDKZ7A6WlZ0F078Uma+4WL6SkpGXImPWMqbYsPBiSIhhhn4/ZFuuTRrcdgT7S9mAUq4rN5ORSaez2zOZ/IfryqTTw/o0cD71By++8nLVrV3L3z9DELKMASELAAAApOwfRX379inW2qqe1lalqduCOSrV2am+gRkuIwUuixZlAxfWxQcAzHDGdYfXgkkm+zcaWV5vNoTx+eQJh+UvKZGvqCg3+yUXxAQCvN+b4YwxRx5ajBJyjDaLw4wWiqTTcjMZqT+scNNpKZPJtvVvzwUbQ89jTO7rSG25bUPPa4wG4g0jZb+3rOzxljVsm1G23pEsa3Ds2nauTZaVv/3gNsuS+o9L9/TIGwxqwbvexf8HQxCyjAEhCwAAAA6W7OxUrK1tsG5LOCynooJPQGLOOWTg0tAwOMOFwAUAMAvlLUU2UA8mnc7dwLZ8Pnn6Z8J4I5H8pciGzIKZD8sojSeEyO0/5PuD9x8tEBkIL/JmYbjuYIgxMENjSMgx4iyMg8OLg7ab/lkfxnVzszRyIcYAy8qFHLkQYyCIkEYOKUZr63++ge15ocdIbQcfWwCJAwdk2zYhy0EIWcaAkAUAAACjScfjivfXbUns25et21JVJU8gUOiuAZMu9dpr6m1rU19bm9LR6OAG21agoUEBAhcAwBxijBl5Fkz/TXrLtgeXIgsEBpciOziACQZle72HP98YQ4hhS0llMoMhwpEsJZVK5dpGXUpqyJJSeTMupLylpEx//0ebhdH/C80LL/JmXIz0+zh4VsUowcVI2480uBi2HSMiZBnZWHKDw18BAAAAgHnKGwqpePlyRRYvVu/LLw/WbUml5K+slK+oqNBdBCaNr6xMvrIyFZ944rDApW/XLvXt2kXgAgCYMyzLkqe/lstITCaTC17SsZiSr70mk0pp4PPq9sBSZH6/vP2zX4YuJeWm09lZGP3hxojLRR28lNTQWRjKDzaGLSUlZZ/DtnNBx6hLSR1BcDF0CSl7oE0aW7ABzFOELAAAAMBh2D6fws3NCi1cqL59+9SzY4di7e1K7NsnX2kpdVsw5wwELkUrVyrd2XnowGWghgvL6QEA5hDL48nNWBnpXzg3lcqFMMkDB7LLkB3BUlKWxzNsBsdMXkoKwOERsgAAAABHyLJtBWtrFaytVckxxyjW3q7ubdsUa22VNxKRv7ycG82YUyzLGjlwaW1VuqsrP3BZsGBwhgv/HwAA5jjb58v+excOF7orAAqMkAUAAAAYB39ZmfxlZSpatixbt2XLFvW+/DJ1WzBnDQtc+pcU621rU6arS307d6pv507J41GgoUHB5mY5BC4AAACY4whZAAAAgAkYsW7LSy/JZDLyV1RQtwVzkmVZ8pWXy1derqITTzx04LJgQTZwWbCAwAUAAABzDiELAAAAMAny6rbs3Zut27JzpxL792frtpSWsp425qRRA5fWVmW6u9XX3q6+9vbsLC8CFwAAAMwxhCwAAADAJLJsW8G6OgXr6lR84EC2bsv27YN1WyoqZHt5G465aVjgcuDA4AwXAhcAAADMQfx1BwAAAEwRp7xcTnm5ipctU/yll7J1W3btkuXzyamspG4L5jTLsuSrqJCvokJFJ5106MClsTEbuDQ0ELgAAABgViFkAQAAAKaYNxzO1m1ZtEjxl19W97Zt6t29m7otmDcODlxSBw6ob2jg0tamvrY2WV5v/gwXZn0BAABghuMdKwAAADBNbL9fkUWLFG5qUt+ePepuaVG8vV2JffvkLy+Xr6SEui2Y8yzLkr+iQv6BwKWjYzBw6ekhcAEAAMCswrtUAAAAYJpZtq1gfb2C9fVKHHOMYm1t6t6xQ7G2NnnDYeq2YN6wLEv+ykr5KytVtGoVgQsAAABmHd6ZAgAAAAWUq9uyfLniu3ap68UX1fvSS9mbylVV8jhOobsITIuRApfetjb1tbYqE4vlBS6BxkYFmpsVaGiQReACAACAAuLdKAAAADADeMNhFa9Yocjixdm6LVu3qveVV2QyGTmVlfJGIoXuIjBthgYuxQOBS2ur+tralInF1Nvaqt7WVgIXAAAAFBzvQAEAAIAZZFjdlh07FGtvV9++ffKXlVG3BfNOXuCyerVSr76aneFC4AIAAIAZgHedAAAAwAw0rG5Le7u6t29XrLVV3qIi+cvLqUuBeceyLPmrquSvqjp04OLzDQYu9fUELgAAAJgyvNMEAAAAZjinokJORYWKly1TbNcudW/ZoviuXbJ9Puq2YN4aFrjs36/e9vbBwKWlRb0tLbnAJdjcLIfABQAAAJOMd5cAAADALOGNRFRy9NGKLF6s3t271bV1q/p275YxRk5FBXVbMG9ZliV/dbX81dWDgUtbm3rb2uTG4yMHLg0NsjyeQncdAAAAsxwhCwAAADDLeBwnV7eld88e9QzUbdm7V/7ycuq2YF7LC1xOPvnQgcvChYMzXAhcAAAAMA6ELAAAAMAsZdm2QvX1Cg3UbWlry9ZtaWmRt7iYui2Y90YMXFpb1dveng1cduxQ744dBC4AAAAYN/7iAgAAAOaAgbotRcuWKf7SS9m6LTt3ynYcOZWV1G3BvJcXuKxZo+S+feprayNwAQAAwIQQsgAAAABziK+oaLBuy8svq2vbtsG6LZWV8obDhe4iUHCWZcmpqZFTU5MfuLS1ye3tHQxc/P5sDZdFi+TU1RG4AAAAYBhCFgAAAGAO8jiOIosXZ+u27N2rnu3bFdu5M79ui2UVuptAwY0pcBmY4ULgAgAAgH6ELAAAAMAcZnk8CtXXK1hXp5KODsXa2wfrthQVUbcFGCIvcDn55PwlxXp71bt9u3q3bydwAQAAQA5/TQEAAADzgGVZcior5VRWqmjZMsV27lT3tm3q3bVLtuPIX1FB3RZgCMu25dTWyqmtzc1w6W1rU19bm9y+vrzAJdjUpEBTU7aGi20XuusAAACYRoQsAAAAwDzjKypS6bHHquiooxR/6SV1b92q3j17JOq2ACMaGriYEQKX+LZtim/bJstxFFy4UIGBGS4ELgAAAHMeIQsAAAAwT3kcR0VLlijS3KzePXvUvX274jt3KrF3r3zUbQFGNCxw2bs3G7i0txO4AAAAzEOELAAAAMA8Z3k8CjU0KFhfr2RHh3paW9XT0pKt21JcLKe8nJoTwAgs25ZTVyenrk7mlFNGDVxsx1Fg4UIFFi2SU1tL4AIAADCHELIAAAAAkJRft6V4xQrF2tvVvW2b4u3tsgMBOZWVsv3+QncTmJHGFLg0NSnY3Cw/gQsAAMCsZxljTKE7UUhdXV0qKSlRNBpVcXFxobsDAAAAzCiZRGKwbssrr8iyLPkrKqjbAhwh47pK7tkzGLgkErltBC4AAKDQEgcOyLZtLXjXu3gvMsRYcgNCFkIWAAAA4LBMJqPeV17J1m3ZtUtuIiFfWRl1W4AxIHABAAAzDSHLyMaSG7BcGAAAAIDDsjwehRYsULChQYlXX1VPa6ti1G0BxsSybTn19XLq62Ve//phgUt861bFt26VHQgMBi41NdzwAAAAmMGYycJMFgAAAGBcUt3dirW1qXvbNiUOHJDHcajbAoyDcV0l9uxRX2ur+nbuzJ/hQuACAACmEDNZRsZyYWNAyAIAAABMTCaRUHzXLnVt3aq+PXuydVsqK+UNhQrdNWDWMa6rxCuvqK+tTb07d8oQuAAAgClEyDIyQpYxIGQBAAAAJoebTqvvlVfUvWOH4jt3KpNIyKmokLe4mLotwDjkBS7t7TLJZG6bHQgo0NycDVyqq7kpAgAAxoWQZWSELGNAyAIAAABMLmNMtm5LS4tira1KdXfLV1wsf1kZdVuAcTKuq8Tu3eprbx8euASDCjQ1KdDYyHJ9mNVsv1+W42S/cqMPAKYFIcvICFnGgJAFAAAAmDqpri7F2tsH67YEAtm6LT5fobsGzFomk1HilVfU29amvp078wIXYK6w/H7ZgYBsxxn5McI2y+stdLcBYNYhZBnZWHID/vUBAAAAMGV8xcUqPf54FS1dmq3bsm2bel9+WZZtU7cFGCfL41FgwQIFFizIC1ySe/dK8/tzlJjNjJGbTMqkUtkfk0llkkllxvAUlseTnQkzSggzUkhj+f0saQkAmBBCFgAAAABTzhMIqGjpUoUXLVLv7t3q3rFDvbt2qW/vXjnl5dRtAcZpaOACzAUmk5GbSIz6MImE3L6+Ye0yRiaTkYnH5cbjR35CyxpcpuwwM2XywhmWvwQA9JuRIctDDz2ke++9V3v27NEJJ5ygBx98UGvWrDnscd///vf13ve+V+985zv105/+dOo7CgAAAGBMbK9X4YULFWpsVGL/fvW0tirWX7vFV1wsf3k5yxQAwDxmeTzyhELyjGGmozFGJpUaDF1GCGHM0J/7t5t0OjuDJpGQEomxzZrxegeXKTvC2TPMmgGAuWnGhSw/+MEPdO211+rhhx/WKaecoi9/+ctau3attmzZourq6lGPa2tr0/XXX68zzjhjGnsLAAAAYDwsy1KgulqB6moVr1ih2M6d6t66VbG2NnmCQeq2AACOmGVZ2Roufr9UVHTEx+XNmhkhmMkLaQa2J5PZWTPptDLptDKx2Fg6Ojx4OYLZM8yaAYCZbcYVvj/llFN08skn6ytf+YokyXVdNTY26uqrr9aNN9444jGZTEZnnnmmPvShD+mZZ55RZ2fnEc9kofA9AAAAMDOke3vV21+3JbF3r2Tbcior5QkGC901AAAk9c+aSSaHBzGjhDQDM2hMOj3uc+ZmzRwUwliHCmZ8PmbNADgiFL4f2awtfJ9MJvXcc8/ppptuyrXZtq03velNevbZZ0c97vbbb1d1dbU+/OEP65lnnjnkORKJhBKJRO7nrq6uiXccAAAAwIR5g0EVLVum8OLF2bot27Yp/vLLcpNJORUV8hYVccMIAFBQlmXlZp+MhUmnDzlT5uCQZiCcGTh2zLNmbFu23z9iCHOo2TPcYAWAsZtRIcurr76qTCajmpqavPaamhq9+OKLIx7zhz/8Qd/61rf0wgsvHNE57rrrLt12220T7SoAAACAKZJXt2XfvsG6Lfv3y1daKn9ZGTeBAACziuX1yuP1yhMOH/ExebNmDrOc2dDtymQk18229fWNrZ8+X34oM9LsmYO2W14vH4IAMK/NqJBlrLq7u/X+979f3/zmN1VZWXlEx9x000269tprcz93dXWpsbFxqroIAAAAYJwsy1KgpkaBmhoVH320Yu3t6t62TbHWVnlCIeq2AADmtLxZM2NY4t5Np7MzYcYQzJhkUpJkUillUillenqOvKO2fchgZlhAEwjI9vv5wASAOWNGhSyVlZXyeDzau3dvXvvevXtVW1s7bP8dO3aora1Nb3/723NtrutKkrxer7Zs2aIlS5bkHeM4jpwxTukEAAAAUFj+khL5X/c6FS1dmq3bsnWr+nbvpm4LAAAHsb1eaayzZlxXbjKZW6bsSGfPyHWzs2Z6e+X29o6pn5bfP2IYc6glzpg1A2AmmlEhi9/v16pVq/TUU0/pwgsvlJQNTZ566ildddVVw/ZfsWKF1q9fn9d2yy23qLu7Ww888AAzVAAAAIA5Jle3ZdGibN2W7dup2wIAwARZti1PICAFAkd8jDEmV2vGHGamTF69mYFZM8mkMsmkMt3dR95R2x51psyoM2iYNQNgis2okEWSrr32Wn3gAx/Q6tWrtWbNGn35y19WLBbTunXrJEmXX365GhoadNdddykQCOi4447LO760tFSShrUDAAAAmDtsn0/hpqZs3Zb9+9XT0qKe1lYlXn1VvpIS6rYAADDFLMvK1nDx+aRI5IiPG5g1k7dc2RHMnsnNmonH5cbjY+vrSKHM4WbPeGfcbVMAM9SMu1pccskl2r9/vz73uc9pz549WrlypX7961+rpqZGkrRz507Z/LEEAAAAQNlP3g6r27J1q2Jtbdm6LRUV1G0BAGAGGZg14xnPrJmDQphhM2gO3p5KZY9PJJRJJJQZSz89nvw6MocJaSyvN/vweCTbZmYtMI9YxhhT6E4UUldXl0pKShSNRlU8hiJiAAAAAGamdDyueH/dlsS+fbI8HjlVVWO6mQMAAGY/47qjhjCHWuJME71dalnZkGZI8DLi14FQZoS2I/rq9TJzFxOWOHBAtm1rwbvexXgaYiy5wYybyQIAAAAAE+ENhVS8fLkiixdn67Zs26b4yy/LpFLyV1bKV1RU6C4CAIBpYNm2PMGgPMHgER9jjJFJpUZetqyvb+TZM8mkTDo9GM70z7wx6fQUvbIhLGvE4OZQX3WofQ/Vxg14YESELAAAAADmpKF1W/r27VPPjh2KtbcrsX8/dVsAAMCILMuS5ffL9vulMXwwwxgjuW42XMlk8r+O1Dba14PaNMrxQ04sk0rllkabUrZ9ZLNrDtGmIz2e92iYRQhZAAAAAMxplm0rWFurYG2tSo49VrG2NnVv26ZYa6u8kYj85eXUbQEAABNiWVY2QPB4pvxceYHOOIKbwx2n0QId15Vx3ekPdMYa6hw8c+dQxxHoYBIQsgAAAACYN/ylpfKvXKmiZctydVt6X36Zui0AAGDWyAt0HGdKz2WMyYYuEwxujmjGTiYzeOLpDnQmMDtnpOXY7NGWZbOsqX89mHaELAAAAADmnby6LS+/rO7t27N1W9JpOVVV8obDhe4iAABAwVmWlZ0J4vVOX6AzmbNzRnkOHRzoJJMyU/rq+g0EOuOclXO44CdvOTYCnWlDyAIAAABg3rJ9PoWbmxVauFB9e/eqZ8cOdbe0KNnRoUBtbXY9dgAAAEy5vEBnihljhi+PNsmzcwba5LqDJx4IdJLJKX+NA7OdDhfSuOm0PMHg1PdnDiNkAQAAADDvWbatYF2dArW1Ci9erOiGDYrv2iU7EFCgupq1ugEAAOYQy7Jy9VqmmnHdbOgyNHjJZOSOUP9mwvV0hgY6A+c8gkDHDoWm8Dcw9xGyAAAAAEA/y7IUqq9XoLpasbY2RTdsUKylRf6KCvnLygrdPQAAAMwylm1nP7Dj8035uUYKdIYFMQe1pbq7ZU9D3+YyQhYAAAAAOIjt9aroqKMUrK9X99at6tq8WbGWFjm1tfLyST8AAADMQOMJdBIHDshm1vaEELIAAAAAwCi8oZDKVq5UaOFCdW3apO4dOwbrtfCJPwAAAGDeI2QBAAAAgMNwystVedppCi9apM7+ei3eUEhOVRX1WgAAAIB5jJAFAAAAAI6AZVkKNTTk6rV0btyYrddSWSl/aWmhuwcAAACgAPjIFQAAAACMge3zqWjpUtW95S0qX7NGJpFQT0uL0vF4obsGAAAAYJoxkwUAAAAAxsEbCqn8xBMVXrhQ0U2b1EO9FgAAAGDeIWQBAAAAgAlwKipUdfrpiixapM6NG9W7c6c8kYicykrqtQAAAABzHCELAAAAAEyQZVkKLVigQE2NYq2t6tywQbHWVvkrKqjXAgAAAMxhfKwKAAAAACaJ7fOpaNky1a1dq/LVq+X212vJ9PYWumsAAAAApgAzWQAAAABgknnDYZWfdNJgvZaWFsmyFKipoV4LAAAAMIcQsgAAAADAFHEqK1V1+ukKNzcrunGj4rt2yUu9FgAAAGDOIGQBAAAAgClk2bbCCxcqWFurnoF6LW1tcioq5CspKXT3AAAAAEwAIQsAAAAATAPb71fx8uUKNTSoa8sWdW3ZouSBAwrU1ckTCBS6ewAAAADGgZAFAAAAAKaRNxJR+apVCjc1qXPjRvW0tMiybQVqa2V7+RMNAAAAmE14Bw8AAAAABeBUVqr6jDMUaW5W58aNiu/cKW9RkZyKCuq1AAAAALMEIQsAAAAAFIhl2wo3NSlQW6vY0HotlZXyFRcXunsAAAAADoOQBQAAAAAKzOM4Kl6xQsGGBnVv2aLoiy9m67XU1lKvBQAAAJjBCFkAAAAAYIbwFRWpfPVqhZqaFB2o1+L1KlBTQ70WAAAAYAbiXToAAAAAzDCBqio5Z545WK+lvV2+khL5KypkWVahuwcAAACgHyELAAAAAMxAlm0r3NysQF2denbsUOfGjYq1tMiprpavqKjQ3QMAAAAgQhYAAAAAmNE8jqOSY45RqLFR0U2b1L1tm5IdHQrU1cnjOIXuHgAAADCvEbIAAAAAwCzgKypS5SmnDC4h1tYmy+eTU11NvRYAAACgQHgnDgAAAACzSKCmRjWVlYotWqTohg3Zei2lpfKXl1OvBQAAAJhmhCwAAAAAMMtYHo8iixYpWF+v7m3bFN20iXotAAAAQAEQsgAAAADALOVxHJUed5zCCxcO1ms5cECB2lrqtQAAAADTgJAFAAAAAGY5X3GxKl//eoWbmxXdsEGx9nbZjqNAdbUsj6fQ3QMAAADmLEIWAAAAAJgjgrW1ClRVKbZzpzrXr1esrY16LQAAAMAUImQBAAAAgDkkV6+lrm6wXktrqwI1NfKGw4XuHgAAADCnELIAAAAAwBzkCQRUevzxCi1cqK6Bei0dHXJqaqjXAgAAAEwSQhYAAAAAmMP8JSWqGKjXsnEj9VoAAACASUTIAgAAAABznGVZCtbVyamqUqy9XdGBei1lZfKXlVGvBQAAABgnQhYAAAAAmCdsr1dFS5Yo1NCgrm3b1EW9FgAAAGBCCFkAAAAAYJ7xBAIqO/54hRsbFd24Ud07dijZ0aFAba1sv7/Q3QMAAABmDUIWAAAAAJin/KWlqjz1VIUXLVJ0wwbFd+2SHQhk67XYdqG7BwAAAMx4hCwAAAAAMI9ZlqVQfb0C1dWKtbUpumGDYi0t8ldUyF9WVujuAQAAADMaIQsAAAAAIFuv5aijFGxoUPfWreravFmxlhY5tbXyhkKF7h4AAAAwIxGyAAAAAAByvMGgyk44QeGFC4fXa/H5Ct09AAAAYEYhZAEAAAAADOMvK1PlaacpvGiROvvrtXhDITlVVdRrATBpjOsq1dWlVDQq47qyJBkp91VDv7csWZbV39j/ff/PuetSf9vQ/Q6179D2vJ8H9h3y86H2zZ0PADDvELIAAAAAAEZkWZZCDQ25ei2dGzcq1tqarddSWlro7gGYpYzrKt3drVQ0KjeTka+kRCVHHy1/eXluu4yRjBn8XpKbyUiuK9P/GPq9cV0pk5EZOObgbf3PM/B8xhjJdeVKuXMNfZj+djNC20B/hvbNGKPRYpaB0Gjo9wRJADB3ELIAAAAAAA7J9vlUtHTpYL2WTZvU09KiAPVaABwh47pK9/RkZ6ykUvIWFyuydGk2yK2tlTcYnJ5+DA1NhgYuGhKauO7wtoP3H2gb2F8aDHJGe47DPK80xiDJGJlM5rBBkjnodRMkESQBmFyELAAAAACAI+INhVS2cqVCjY2KbtqkHuq1ADgEY0wuWHFTKfnCYUUWLVKosVGBmhp5w+Fp71PeTXqPZ9rPPx1mZJDUv02au0GSJcnyemV5vbJ9Ptk+X+57y+tlqU1gDiNkAQAAAACMiVNRoarTT1dk0SJ1btyo3p075YlE5FRWchMJmOeMMcrE40p2dspNJOQNhxVqbFR44UIFamrkKyoqdBfnPIKkCQZJQ4891HMc3JbJKB2LKdXTo0wspkwqJdPXJzedlkmlcs9zcBgz7Cv/jgKzDiELAAAAAGDMLMtSaMECBWpqFGttVeeGDdRrAeaxdDyuVGenMr292WClrk7hpiYFamvlKy4udPcwx8z0IMkYI5NKKZNIyE0m5SYSed+nY7Hcw00mle7pyYUxA7NtLEnyePICGMIYYGYiZAEAAAAAjJvt86lo2TIFGxrUtWWLul58UT2trQrW1sozTTUWABRGpq9PyddeU6a3V55gUE51tSLNzQpUV8tXWkp9C8xblmXJ8vtl+/2H3ddNpYaFMAPfp+NxpXt6smFMIqFMfxjj9ocxUv9SZbadDV58PtkDIUz/9zMxhALmGkIWAAAAAMCEecNhlZ90ksILF2brtbS0SBL1WoA5JpNIKNXZqXQsJo/jyF9ZqciiRQpUV8tfXk6wAozRwAwVbyRyyP3cVEpuMpkNYA4KZNLxuDKxmFIDYUw8nt0/nR6sY2NZg2HMQUuU2T4fYQwwAYQsAAAAAIBJ41RWDtZr2bBBvbt2Ua8FmOXcZFLJzk6le3pk+/1yKipUevzxCtbVZYMV/t8GplwujAmHD7mfm07nQpihgUwujOmfHZPp65Pb16d0d7fcVErGdWUpu9SZddAyZXlfvdxOBg7G/xUAAAAAgEll2bZCjY0K1NSoZ6BeS1ubnIoK+UpKCt09AEfATaWUikaV7uqS5fPJX1amkmOPVbC2Vk5FBZ96B2YoeyAIOZIwpn82zLBAprdXqZ4epeNxub292TCmp0cmlZLJZAafxLIGlyXrD4EIYzAfMdoBAAAAAFPC9vtVvHy5QgP1WrZsUfLAAQXq6uQJBArdPQAHcdNppaJRpbq6ZNm2/OXlKlu9WsG6OjmVldw0BeaQXBgTCh1yP5PJKDMQxhwUyGT6+rJhTCyWDWMSiWwYk05nH1J2doxlDasVM/C95fGwzCBmPf51BAAAAABMKW8kovJVqxRualLnxo3qaWmRZdvZei3ctAUKyk2nlerqUrqrS5LkLytT+YknKlBXp0BVFTWVgHnO8njkDQalYPCQ+xnXzYYvQwKZgXAm09ur9MAyZb29cpNJpWOxvDAme7IhYcwIXwljMFPxbhYAAAAAMC2cykpVn3FGrl5LfOdOeYuKsksPUdMBmDbGdXMzVmSMfMXFKjn+eIXq6+VUVcnjOIXuIoBZxrLtIw5jcrNhBkKYIcuUpeNxZWKx7OyYVEomHs9+zWQkY7KzYyxr5HoxhDEoEEIWAAAAAMC0sWxb4YULFaytVU9Ly2C9lspK+YqLC909YM4yrqt0d7dS0aiM68pbXKySY45RsL5egZoaghUA08KybXkCgcMuG2pcV24qlRfCDHyfSSRyQUwmHlcmmZTp7c2GMem0ZPrnxlhWdjmygXoxQ2rHWB4PH/DApCFkAQAAAABMO9vvV/GKFQo2NKh7aL2W2lrqtQCTxLiu0j09SnZ2Sum0vMXFiixdqvCCBXJqarKfOgeAGciybXkcRx7H0aEWLTTGZAOYgRBm6HJl/TVicmFMKiXT1yc3nZZJpbJhTP+sF8vjyc2GGTYzhjAGh0HIAgAAAAAoGF9RkcpXr1aoqUnRgXotXq8CNTXUawHGwRijdE+PUp2dclMp+YqKVLRkiUKNjQpUV8sbDhe6iwAwaSzLyoUxKioadb9Rw5j+r+lYTKmeHmX6lynLDAljjDHZJciMyYYuoy1VRhgzb/GOFQAAAABQcIGqKjlnnqlIc7M6N25UvL1dvpIS+SsqWFsdOAxjjDLxuJKdnXITCXnDYYWamhReuFCB6mr5DnHjEQDmg7GEMSaVGrFmzEAYM/Bwk0llenqUGTIzxkiyJMnjyQtgCGPmNkIWAAAAAMCMYNm2ws3NCtTVqWfHDkU3blSspUUON4mBEaXjcaU6O5Xp7c0GK/X1Cjc1KVBTQ40jABgHy7Jk+f2y/f7D7jtazRg3mVQ6Hs8tVeYmEsr09MhNp+UOLFMmZQMZ284GL/01Y4Z+b3k8U/xqMVkIWQAAAAAAM4rHcVRyzDEKNTYqunmzurduVbKjQ4G6OopzY97L9PYq2dmpTDwuTyikQHV1NpysqZGvpISZXwAwTQZmqHgjkUPu56ZS2Vkv/bVihgYy6d5eZXp6lBoIY+Lx7P7ptOS62dkxljUYxhy0RJnt8xHGzACELAAAAACAGclXVKTKNWtyS4jFWlpk+/1yqqup14J5JZNIKNXZqXQsJo/jyF9ZqciqVQrU1MhfVkawAgAzWC6MOUxNLDedzoUwQwOZTCKhdDyuTP8yZZm+Prl9fUp3d8tNpWRcV7l/BUYJYyyvl/dOU4jfLAAAAABgRgtUV6umslKx5mZFN2zI1mspLZW/vJyby5izMomEUtGo0j09sh1HTnm5yk44IRuslJezpj8AzDH2QBByJGFM/2yYoYFMJpGQ29enVE+P0vG43N7ebBjT0yOTSslkMoNPYlnZZcl8PrmJhGyWZZ0QQhYAAAAAwIxn2bYiixYpWF+v7u3bFd20SbHWVjlVVdRrwZzhplLZpcC6u2X5fPKXl6vkuOMUrKmRU1HBkjAAgMEwJhQ65H4mk1FmIIw5uHbMQBgTi8nt7ZW3uFjigyvjRsgCAAAAAJg1PI6j0mOPVXhovZYDBxSoraVeC2YlN51WKhpVqqtLlm3LKS9XyYoVCtTWyqmsZHkXAMC4WB6PvMGgFAwecj/TX/uF2cHjx7/UAAAAAIBZx1dcrMpTTlG4qUnRjRsVb2+X5fMpUFPDp/0x47nptFJdXUpHo5JlyV9WpvITT1Swrk5OVZVsn6/QXQQAzBMsPzlxhCwAAAAAgFkrWFurQFWVYjt3qnP9esXa2qjXghnJZDJKdXUpFY1KknwlJSp53esUamhQoKpKtt9f4B4CAIDxIGQBAAAAAMxqlsczWK9l69ZcvZZAdbW8kUihu4d5zLjuYLBijLzFxSo59liFGhrkVFezxB0AAHMAIQsAAAAAYE7wOI5Kjz9eoYUL1bVpk7q3bVPiwAEFamq4mY1pY1xX6Z4epaJRmXRa3qIiFS9fng1Wamqy6+MDAIA5g5AFAAAAADCn+EtKVPH61yvc3Kzoxo2KtbfLdhwFqqup14IpYYzJBiudnXLTafkiEUWWLFFowQIFamrkDYUK3UUAADBFCFkAAAAAAHOOZVkK1tUpUF2tWHu7Ov/2t2y9lrIy+cvKqNeCCTPGKBOPK/naa3ITCfkiEYWbmxVqbFSwpoal6gAAmCcIWQAAAAAAc5bl8SiyeLGC9fXq2rZNXQP1Wmpq5A2HC909zELpeFypzk5lenvljUQUWrBA4YULFaitla+oqNDdAwAA04yQBQAAAAAw53kCAZUdf7zCjY2Kbtqk7u3blezoUKC2VrbfX+juYYbL9PYq2dmpTDwuTyikQHW1ws3NCtTUyFdSwswoAADmMUIWAAAAAMC84S8tVeUb3qBIc7M6N2xQfNcu2YFAtl6LbRe6e5hBMn19SkWjSsdi8jiOnKoqRVavllNdzZJzAAAgh5AFAAAAADCvWJalYH29nP56LdH16xVraZG/okK+0lJuns9jmUQiG6z09Mh2HDkVFSpbuVKB6mr5y8sJ4gAAwDCELAAAAACAecn2elW0ZImC9fXq3rpVXZs3K97aKod6LfOKm0op2dmpdHe3bJ9P/ooKlRx3nIK1tXIqKghWAADAIRGyAAAAAADmNW8wqLITTlB44UJFN25U944dSh44kK3X4vMVunuYAm4qpVQ0qlRXl2yvV/6yMpWsWKFgXZ2cykpZHk+huwgAAGYJQhYAAAAAACT5y8pUedppCi9erM716xXftUveUEhOVRWzGeYAN53OLgXW1SXZtvylpSpftSoXrBCoAQCA8SBkAQAAAACgn2VZCtXXK1BVpVhbmzo3blSstVX+igr5S0sL3T2MkclklOrqUioalWVZ8hYXZ2us1NcrUFkp2+8vdBcBAMAsR8gCAAAAAMBBbJ9PRUuXKtjQkK3XsmmTelpaFKitlTcUKnT3cAjGdXPBilxXvpISlRx3nEL19XKqq+VxnEJ3EQAAzCGELAAAAAAAjMIbCqls5UqF+uu19OzYoWRHB/VaZhjjukr39CjV2Sk3nZavpETFy5crtGCBAjU18gQChe4iAACYowhZAAAAAAA4DKe8XFWnn67IokXq3LhRvbt2yUO9loIyxuQHK0VFihx1VC5YYcYRAACYDoQsAAAAAAAcAcuycjfwY62t6tywgXot08wYo0wspmRnp9xkUr5wWOHmZoUXLlSgulreSKTQXQQAAPMMIQsAAAAAAGNg+3wqWrZMwYYGdW3dqq7Nm9XT2qpgba08wWChuzcnpWMxpaJRZfr65A2HFVqwQOGmJgVqauQrKip09wAAwDxGyAIAAAAAwDh4w2GVn3iiwgP1WlpaJIl6LZMkHY8rFY3K7e2VHQwqWFurcFOTnJoa+UtKCt09AAAASYQsAAAAAABMiFNRMVivZcOGbL2WSEROZSX1WsYo09enZGenMvG4PIGAnOpqRQZmrJSWyrKsQncRAAAgDyELAAAAAAATZNm2Qo2NCtTUqGegXktbm5yKCvmYdXFImURCqc5OpWMx2Y4jp7JSkRNPVKCmRv6yMoIqAAAwoxGyAAAAAAAwSWy/X8XLlyvU0KCuLVvUtWWLEgcOUK/lIG4yqeRAsOLzyV9ertLjj1egtlZORQXBCgAAmDUIWQAAAAAAmGTeSETlq1Yp3NSkzv56LZZtZ+u1eOfnn+JuKqVUNKp0d7csr1f+0lKVHHusgjU12aXVPJ5CdxEAAGDM5uc7OwAAAAAApoFTWanqM87I1WuJ79wpb1HRvJmt4abTSkWjSnV1ybJt+cvKVLZqlYK1tXKqquZt4AQAAOYO3s0AAAAAADCFLNtWeOFCBWtr1dPSkq3X0toqp6pKvuLiQndv0plMRqmuLqWiUUmSv6xM5SeeqEBdnQJVVbJ9vgL3EAAAYPIQsgAAAAAAMA1sv1/FK1Yo2NCg7v56LcmODgXq6uQJBArdvQkxrjsYrBgjX3GxSo47TqGGBjlVVfI4TqG7CAAAMCUIWQAAAAAAmEa+oiKVr16tUFOTogP1WrxeBWpqZtXyWcZ1le7uVioalZvJyFdSopIVKxRcsECB6upZHxwBAAAcidnz7g0AAAAAgDkkUFUl58wzB+u1tLfLV1Iif0WFLMsqdPdGZFxX6Z4epaJRmXRa3qIiRZYuVaihQYGaGnlDoUJ3EQAAYFoRsgAAAAAAUCCWbSvc1KRAf72W6NB6LUVFhe6eJMkYkwtW3GRSvkhE4eZmhRcuzAYr4XChuwgAAFAwhCwAAAAAABSYx3FUcvTRCi1YoOjmzereujVbr6W2tiDLbhljlInHlezslJtIyBsOK9TYmAtWZkoABAAAUGiELAAAAAAAzBC+oiJVrlmjSHOzOjduVKylRbbfL6e6elrqtaTjcaU6O5Xp7c0GK3V1Cjc1yampkb+kZMrPDwAAMNsQsgAAAAAAMMMEqqtVU1mpWHOzogP1WkpL5S8vn/R6LZm+PiVfe02Z3l55gkE51dWKNDcrUF0tX2npjK0PAwAAMBMQsgAAAAAAMANZtq3IokUK1tere/t2RTdtmrR6LZlEQqnOTqVjMXkcR/7KSkUWLVKgunpKghwAAIC5ipAFAAAAAIAZzOM4Kj32WIUbGwfrtRw4kK3X4jhH/DxuMqlkZ6fSPT3ZJcgqKlR6/PEK1tVlgxXbnsJXAQAAMDcRsgAAAAAAMAv4iotVecopCjc1Kbpxo+Lt7bJ8PgVqamR5PCMe46ZSSkWjSnd3y/J65S8rU8mxxypYWyunomLU4wAAAHBkCFkAAAAAAJhFgrW1ClRVKbZzpzo3bFCsrS2vXoubTisVjSrV1SXLtuUvL1fZsmUK1tXJqayU7eVWAAAAwGThnRUAAAAAALOM5fEM1mvZtk3RjRsVa2nJzUzxl5Wp/MQTFairU6CqSrbPV+AeAwAAzE2ELAAAAAAAzFIex1Hpcccp1Nio7i1bZCSF6uvlVFWNqV4LAAAAxoeQBQAAAACAWc5fUqKKNWsK3Q0AAIB5xy50BwAAAAAAAAAAAGYjQhYAAAAAAAAAAIBxIGQBAAAAAAAAAAAYB0IWAAAAAAAAAACAcSBkAQAAAAAAAAAAGAdCFgAAAAAAAAAAgHEgZAEAAAAAAAAAABgHQhYAAAAAAAAAAIBxIGQBAAAAAAAAAAAYB0IWAAAAAAAAAACAcSBkAQAAAAAAAAAAGAdCFgAAAAAAAAAAgHGYkSHLQw89pObmZgUCAZ1yyin685//POq+P/nJT7R69WqVlpYqHA5r5cqVevTRR6extwAAAAAAAAAAYD6acSHLD37wA1177bW69dZb9fzzz+uEE07Q2rVrtW/fvhH3Ly8v1z/8wz/o2Wef1d/+9jetW7dO69at029+85tp7jkAAAAAAAAAAJhPLGOMKXQnhjrllFN08skn6ytf+YokyXVdNTY26uqrr9aNN954RM9x0kkn6fzzz9cdd9xx2H27urpUUlKiaDSq4uLiCfUdAAAAAAAAAADMbmPJDWbUTJZkMqnnnntOb3rTm3Jttm3rTW96k5599tnDHm+M0VNPPaUtW7bozDPPHHGfRCKhrq6uvAcAAAAAAAAAAMBYzaiQ5dVXX1Umk1FNTU1ee01Njfbs2TPqcdFoVJFIRH6/X+eff74efPBBvfnNbx5x37vuukslJSW5R2Nj46S+BgAAAAAAAAAAMD/MqJBlvIqKivTCCy/ov//7v3XnnXfq2muv1e9///sR973pppsUjUZzj127dk1vZwEAAAAAAAAAwJzgLXQHhqqsrJTH49HevXvz2vfu3ava2tpRj7NtW0cddZQkaeXKldq8ebPuuusunX322cP2dRxHjuNMar8BAAAAAAAAAMD8M6Nmsvj9fq1atUpPPfVUrs11XT311FN6wxvecMTP47quEonEVHQRAAAAAAAAAABA0gybySJJ1157rT7wgQ9o9erVWrNmjb785S8rFotp3bp1kqTLL79cDQ0NuuuuuyRla6ysXr1aS5YsUSKR0JNPPqlHH31UX/va1wr5MgAAAAAAAAAAwBw340KWSy65RPv379fnPvc57dmzRytXrtSvf/1r1dTUSJJ27twp2x6cgBOLxXTllVfqpZdeUjAY1IoVK/Td735Xl1xySaFeAgAAAAAAAAAAmAcsY4wpdCcKqaurSyUlJYpGoyouLi50dwAAAAAAAAAAQAGNJTeYUTVZAAAAAAAAAAAAZgtCFgAAAAAAAAAAgHGYcTVZptvAamldXV0F7gkAAAAAAAAAACi0gbzgSKqtzPuQpbu7W5LU2NhY4J4AAAAAAAAAAICZoru7WyUlJYfcZ94XvnddV7t371ZRUZEsyyp0d2aUrq4uNTY2ateuXYct7gPMNIxfzGaMX8xmjF/MZoxfzGaMX8x2jGHMZoxfzGaM35EZY9Td3a36+nrZ9qGrrsz7mSy2bWvBggWF7saMVlxczP9gmLUYv5jNGL+YzRi/mM0Yv5jNGL+Y7RjDmM0Yv5jNGL/DHW4GywAK3wMAAAAAAAAAAIwDIQsAAAAAAAAAAMA4ELJgVI7j6NZbb5XjOIXuCjBmjF/MZoxfzGaMX8xmjF/MZoxfzHaMYcxmjF/MZozfiZv3he8BAAAAAAAAAADGg5ksAAAAAAAAAAAA40DIAgAAAAAAAAAAMA6ELAAAAAAAAAAAAONAyAIAAAAAAAAAADAOhCxzWCKR0A033KD6+noFg0Gdcsop+o//+I8jOvbll1/WxRdfrNLSUhUXF+ud73ynWlpaRtz3W9/6lo4++mgFAgEtXbpUDz744GS+DMxj0zGGLcsa8XH33XdP9svBPDPe8btlyxZ9+tOf1qmnnqpAICDLstTW1jbq/j//+c910kknKRAIaOHChbr11luVTqcn8ZVgPpqO8dvc3Dzi9ffjH//4JL8azDfjHb8/+clPdMkll2jx4sUKhUJavny5rrvuOnV2do64P9dfTIXpGL9cfzFVxjt+n3jiCa1du1b19fVyHEcLFizQRRddpA0bNoy4P9dfTIXpGL9cfzGVJnIPbag3v/nNsixLV1111YjbuQ88Mm+hO4Cp88EPflA/+tGP9KlPfUpLly7VI488ore97W16+umndfrpp496XE9Pj974xjcqGo3q5ptvls/n0/3336+zzjpLL7zwgioqKnL7fv3rX9fHP/5x/d3f/Z2uvfZaPfPMM7rmmmsUj8d1ww03TMfLxBw2HWNYyv4Dcvnll+e1nXjiiVPymjB/jHf8Pvvss/qXf/kXHXPMMTr66KP1wgsvjLrvr371K1144YU6++yz9eCDD2r9+vX6p3/6J+3bt09f+9rXpuBVYb6YjvErSStXrtR1112X17Zs2bLJeAmYx8Y7fj/2sY+pvr5el112mRYuXKj169frK1/5ip588kk9//zzCgaDuX25/mKqTMf4lbj+YmqMd/yuX79eZWVl+uQnP6nKykrt2bNH//qv/6o1a9bo2Wef1QknnJDbl+svpsp0jF+J6y+mznjH8FA/+clP9Oyzz466nfvAh2AwJ/3pT38yksy9996ba+vt7TVLliwxb3jDGw557D333GMkmT//+c+5ts2bNxuPx2NuuummXFs8HjcVFRXm/PPPzzv+fe97nwmHw+bAgQOT9GowH03HGDbGGEnmE5/4xOR2HvPeRMZvR0eH6erqMsYYc++99xpJprW1dcR9jznmGHPCCSeYVCqVa/uHf/gHY1mW2bx588RfCOal6Rq/TU1Nw95DABM1kfH79NNPD2v7t3/7NyPJfPOb38xr5/qLqTBd45frL6bCRMbvSPbs2WO8Xq+54oor8tq5/mIqTNf45fqLqTIZY7i3t9c0Nzeb22+/fcR7ZdwHPjSWC5ujfvSjH8nj8ehjH/tYri0QCOjDH/6wnn32We3ateuQx5588sk6+eSTc20rVqzQueeeq8cffzzX9vTTT6ujo0NXXnll3vGf+MQnFIvF9Mtf/nISXxHmm+kYw0P19vaqr69v8l4A5rWJjN/y8nIVFRUd9hybNm3Spk2b9LGPfUxe7+DE1CuvvFLGGP3oRz+a2IvAvDUd43eoZDKpWCw27v4CQ01k/J599tnD2t71rndJkjZv3pxr4/qLqTId43corr+YTBMZvyOprq5WKBTKW/KO6y+mynSM36G4/mKyTcYY/uIXvyjXdXX99dePuJ37wIdGyDJH/c///I+WLVum4uLivPY1a9ZI0qjLd7iuq7/97W9avXr1sG1r1qzRjh071N3dnTuHpGH7rlq1SrZt57YD4zEdY3jAI488onA4rGAwqGOOOUbf+973JudFYN4a7/gd6zmk4dfg+vp6LViwgGswxm06xu+A//zP/1QoFFIkElFzc7MeeOCBSXtuzE+TPX737NkjSaqsrMw7h8T1F5NvOsbvAK6/mGyTMX47Ozu1f/9+rV+/Xh/5yEfU1dWlc889N+8cEtdfTL7pGL8DuP5iKkx0DO/cuVN333237rnnnmFLjA49h8R94NFQk2WOeuWVV1RXVzesfaBt9+7dIx534MABJRKJwx67fPlyvfLKK/J4PKqurs7bz+/3q6KiYtRzAEdiOsawJJ166qm6+OKLtWjRIu3evVsPPfSQ3ve+9ykajerv//7vJ+vlYJ4Z7/gd6zmGPufB5+EajPGajvErSa973et0+umna/ny5ero6NAjjzyiT33qU9q9e7fuueeeSTkH5p/JHr/33HOPPB6PLrroorxzDH3Og8/D9RfjNR3jV+L6i6kxGeP39a9/vbZs2SJJikQiuuWWW/ThD3847xxDn/Pg83D9xXhNx/iVuP5i6kx0DF933XU68cQTdemllx7yHNwHHh0hyxzV29srx3GGtQcCgdz20Y6TdETH9vb2yu/3j/g8gUBg1HMAR2I6xrAk/fGPf8zb50Mf+pBWrVqlm2++WR/84AdHTfCBQxnv+B3rOaTRx3pXV9eEz4H5aTrGryT9/Oc/z/t53bp1Ou+883Tffffp6quv1oIFCyblPJhfJnP8fu9739O3vvUtffazn9XSpUvzziFx/cXkm47xK3H9xdSYjPH77W9/W11dXWppadG3v/1t9fb2KpPJyLbtvOfg+ovJNh3jV+L6i6kzkTH89NNP68c//rH+9Kc/HfYc3AceHcuFzVHBYFCJRGJY+0DNidFuHA+0H8mxwWBQyWRyxOfp6+vj5jQmZDrG8Ej8fr+uuuoqdXZ26rnnnhtzvwFp/ON3rOeQRh/rXIMxXtMxfkdiWZY+/elPK51O6/e///2UnANz32SN32eeeUYf/vCHtXbtWt15553DziFx/cXkm47xOxKuv5gMkzF+3/CGN2jt2rX6+7//e/3mN7/Rd7/7Xd10001555C4/mLyTcf4HQnXX0yW8Y7hdDqta665Ru9///vz6hqPdg7uA4+OkGWOqqury02lHWqgrb6+fsTjysvL5TjOER1bV1enTCajffv25e2XTCbV0dEx6jmAIzEdY3g0jY2NkrJLjwHjMd7xO9ZzDH3Og8/DNRjjNR3jdzRcfzFRkzF+//rXv+od73iHjjvuOP3oRz/KK648cI6hz3nwebj+YrymY/yOhusvJmqy3z+UlZXpnHPO0WOPPZZ3jqHPefB5uP5ivKZj/I6G6y8mw3jH8He+8x1t2bJFV1xxhdra2nIPSeru7lZbW5vi8XjuHNwHHh0hyxy1cuVKbd26ddh02YGpXytXrhzxONu2dfzxx+svf/nLsG1/+tOftHjxYhUVFeU9x8H7/uUvf5HruqOeAzgS0zGGR9PS0iJJqqqqGkfPgfGP37GeQxp+Dd69e7deeuklrsEYt+kYv6Ph+ouJmuj43bFjh9761requrpaTz75pCKRyIjnkLj+YvJNx/gdDddfTNRUvH/o7e1VNBrNO4fE9ReTbzrG72i4/mIyjHcM79y5U6lUSqeddpoWLVqUe0jZAGbRokX67W9/m/cc3AcehcGc9F//9V9Gkrn33ntzbX19feaoo44yp5xySq6tvb3dbN68Oe/Yu+++20gy//3f/51re/HFF43H4zE33HBDri0ej5vy8nJzwQUX5B1/2WWXmVAoZDo6Oib7ZWEemY4xvG/fvmHn7erqMkuWLDGVlZUmkUhM5kvCPDKR8TvUvffeaySZ1tbWEbevWLHCnHDCCSadTufabrnlFmNZltm0adPEXwjmpekYvx0dHXnj1hhjksmkOe2004zf7zevvPLKxF8I5qWJjN9XXnnFLF682NTX14963R3A9RdTYTrGL9dfTJWJjN+9e/cOe77W1lZTVFRkzjjjjLx2rr+YCtMxfrn+YiqNdwxv3rzZPPHEE8Mekszb3vY288QTT5jdu3cbY7gPfDiELHPYe97zHuP1es1nPvMZ8/Wvf92ceuqpxuv1mv/7f/9vbp+zzjrLHJy1Ddxkrq6uNl/84hfN/fffbxobG019ff2wm9IPPfSQkWQuuugi881vftNcfvnlRpK58847p+U1Ym6b6jF86623mhNOOMHccsst5hvf+Ia57bbbTFNTk7Esy3z3u9+dtteJuWm847ezs9Pccccd5o477jBvfetbjSRz3XXXmTvuuMM8+OCDefv+4he/MJZlmXPOOcd84xvfMNdcc42xbdt89KMfnZbXiLlrqsfvt7/9bbNkyRJzww03mIcffth84QtfMMcdd5yRZL7whS9M2+vE3DTe8XvCCScYSeazn/2sefTRR/Mev/3tb/P25fqLqTLV45frL6bSeMdvdXW1ee9732vuuece841vfMN85jOfMeXl5SYQCJg//vGPefty/cVUmerxy/UXU228Y3gkkswnPvGJYe3cBx4dIcsc1tvba66//npTW1trHMcxJ598svn1r3+dt89o/3Pt2rXLXHTRRaa4uNhEIhFzwQUXmG3bto14nm984xtm+fLlxu/3myVLlpj777/fuK47Ja8J88tUj+Hf/va35s1vfrOpra01Pp/PlJaWmre85S3mqaeemtLXhflhvOO3tbXVSBrx0dTUNOw8TzzxhFm5cqVxHMcsWLDA3HLLLSaZTE7lS8M8MNXj9y9/+Yt5+9vfbhoaGozf7zeRSMScfvrp5vHHH5+Ol4c5brzjd7SxK8mcddZZw87D9RdTYarHL9dfTKXxjt9bb73VrF692pSVlRmv12vq6+vNpZdeav72t7+NeB6uv5gKUz1+uf5iqk3kHtrBRgtZjOE+8GgsY4yZwGpjAAAAAAAAAAAA8xKF7wEAAAAAAAAAAMaBkAUAAAAAAAAAAGAcCFkAAAAAAAAAAADGgZAFAAAAAAAAAABgHAhZAAAAAAAAAAAAxoGQBQAAAAAAAAAAYBwIWQAAAAAAAAAAAMaBkAUAAAAAAAAAAGAcCFkAAAAAAAAAAADGgZAFAAAAADCp2traZFmWHnnkkUJ3BQAAAJhShCwAAADALPbII4/IsqzcIxAIaNmyZbrqqqu0d+/eQndvwjZt2qTPf/7zamtrK3RXDuuDH/xg3n8Lx3G0bNkyfe5zn1NfX1+huwcAAABgCngL3QEAAAAAE3f77bdr0aJF6uvr0x/+8Ad97Wtf05NPPqkNGzYoFAoVunvjtmnTJt122206++yz1dzcXOjuHJbjOPrf//t/S5Ki0ah+9rOf6Y477tCOHTv02GOPFbh3AAAAACYbIQsAAAAwB5x33nlavXq1JOkjH/mIKioqdN999+lnP/uZ3vve907ouePx+KwOaqaT1+vVZZddlvv5yiuv1Kmnnqp///d/13333aeampoC9g4AAADAZGO5MAAAAGAOOueccyRJra2tubbvfve7WrVqlYLBoMrLy3XppZdq165decedffbZOu644/Tcc8/pzDPPVCgU0s033yxJ6uvr0+c//3ktW7ZMgUBAdXV1eve7360dO3bkjnddV1/+8pd17LHHKhAIqKamRldccYVee+21vPM0Nzfrggsu0B/+8AetWbNGgUBAixcv1ne+853cPo888oje8573SJLe+MY35pbh+v3vfy9J+tnPfqbzzz9f9fX1chxHS5Ys0R133KFMJjPs9/HQQw9p8eLFCgaDWrNmjZ555hmdffbZOvvss/P2SyQSuvXWW3XUUUfJcRw1Njbqs5/9rBKJxBj/C2RZlqXTTz9dxhi1tLTkbfvVr36lM844Q+FwWEVFRTr//PO1cePGvH0++MEPKhKJaOfOnbrgggsUiUTU0NCghx56SJK0fv16nXPOOQqHw2pqatL3vve9YX1oaWnRe97zHpWXlysUCun1r3+9fvnLX+a27927V16vV7fddtuwY7ds2SLLsvSVr3xFknTgwAFdf/31Ov744xWJRFRcXKzzzjtPf/3rX8f1+wEAAABmO0IWAAAAYA4aCD4qKiokSXfeeacuv/xyLV26VPfdd58+9alP6amnntKZZ56pzs7OvGM7Ojp03nnnaeXKlfryl7+sN77xjcpkMrrgggt02223adWqVfrSl76kT37yk4pGo9qwYUPu2CuuuEKf+cxndNppp+mBBx7QunXr9Nhjj2nt2rVKpVJ559m+fbsuuugivfnNb9aXvvQllZWV6YMf/GAuaDjzzDN1zTXXSJJuvvlmPfroo3r00Ud19NFHS8qGMJFIRNdee60eeOABrVq1Sp/73Od044035p3na1/7mq666iotWLBAX/ziF3XGGWfowgsv1EsvvZS3n+u6esc73qF//ud/1tvf/nY9+OCDuvDCC3X//ffrkksuGfd/i4F6MmVlZbm2Rx99VOeff74ikYjuuece/eM//qM2bdqk008/fVj9mUwmo/POO0+NjY364he/qObmZl111VV65JFH9Na3vlWrV6/WPffco6KiIl1++eV5wdrevXt16qmn6je/+Y2uvPJK3Xnnnerr69M73vEOPfHEE5KkmpoanXXWWXr88ceH9f0HP/iBPB5PLuxqaWnRT3/6U11wwQW677779JnPfEbr16/XWWedpd27d4/7dwQAAADMWgYAAADArPXtb3/bSDK/+93vzP79+82uXbvM97//fVNRUWGCwaB56aWXTFtbm/F4PObOO+/MO3b9+vXG6/XmtZ911llGknn44Yfz9v3Xf/1XI8ncd999w/rguq4xxphnnnnGSDKPPfZY3vZf//rXw9qbmpqMJPP//t//y7Xt27fPOI5jrrvuulzbD3/4QyPJPP3008POG4/Hh7VdccUVJhQKmb6+PmOMMYlEwlRUVJiTTz7ZpFKp3H6PPPKIkWTOOuusXNujjz5qbNs2zzzzTN5zPvzww0aS+eMf/zjsfEN94AMfMOFw2Ozfv9/s37/fbN++3fzzP/+zsSzLHHfccbnfU3d3tyktLTUf/ehH847fs2ePKSkpyWv/wAc+YCSZL3zhC7m21157zQSDQWNZlvn+97+fa3/xxReNJHPrrbfm2j71qU8ZSXmvqbu72yxatMg0NzebTCZjjDHm61//upFk1q9fn9enY445xpxzzjm5n/v6+nLHDGhtbTWO45jbb789r02S+fa3v33I3xkAAAAw2zGTBQAAAJgD3vSmN6mqqkqNjY269NJLFYlE9MQTT6ihoUE/+clP5LquLr74Yr366qu5R21trZYuXaqnn34677kcx9G6devy2n784x+rsrJSV1999bBzW5YlSfrhD3+okpISvfnNb847z6pVqxSJRIad55hjjtEZZ5yR+7mqqkrLly8ftqzWaILBYO777u5uvfrqqzrjjDMUj8f14osvSpL+8pe/qKOjQx/96Efl9Q6WpHzf+96XN7NkoP9HH320VqxYkdf/gaXXDu7/SGKxmKqqqlRVVaWjjjpK119/vU477TT97Gc/y/2e/uM//kOdnZ1673vfm3cej8ejU045ZcTzfOQjH8l9X1paquXLlyscDuviiy/OtS9fvlylpaV5v78nn3xSa9as0emnn55ri0Qi+tjHPqa2tjZt2rRJkvTud79bXq9XP/jBD3L7bdiwQZs2bcqbxeM4jmw7+2dkJpNRR0eHIpGIli9frueff/6wvx8AAABgrqHwPQAAADAHPPTQQ1q2bJm8Xq9qamq0fPny3M3wbdu2yRijpUuXjnisz+fL+7mhoUF+vz+vbceOHVq+fHleUHGwbdu2KRqNqrq6esTt+/bty/t54cKFw/YpKysbVr9lNBs3btQtt9yi//zP/1RXV1fetmg0Kklqb2+XJB111FF5271er5qbm4f1f/Pmzaqqqjqi/o8kEAjoF7/4hSTppZde0he/+EXt27cvLxDatm2bpMG6OQcrLi4e9pwH96mkpEQLFizIBTdD24f+/trb23XKKacMO8fAkmvt7e067rjjVFlZqXPPPVePP/647rjjDknZpcK8Xq/e/e53545zXVcPPPCAvvrVr6q1tTWv/s3A0nQAAADAfELIAgAAAMwBa9as0erVq0fc5rquLMvSr371K3k8nmHbI5FI3s9DA4GxcF1X1dXVeuyxx0bcfnBQMFJfJMkYc9hzdXZ26qyzzlJxcbFuv/12LVmyRIFAQM8//7xuuOEGua47rv4ff/zxuu+++0bc3tjYeNjn8Hg8etOb3pT7ee3atVqxYoWuuOIK/fznP8+dR8rWZamtrR32HAcHWaP9niby+xvJpZdeqnXr1umFF17QypUr9fjjj+vcc89VZWVlbp8vfOEL+sd//Ed96EMf0h133KHy8nLZtq1PfepT4/qdAwAAALMdIQsAAAAwxy1ZskTGGC1atEjLli0b93P86U9/UiqVGjbzZeg+v/vd73TaaaeNO6g52MEzNQb8/ve/V0dHh37yk5/ozDPPzLUPLfouSU1NTZKk7du3641vfGOuPZ1Oq62tTa973evy+v/Xv/5V55577qjnHau6ujp9+tOf1m233ab/+q//0utf/3otWbJEklRdXZ0XyEyFpqYmbdmyZVj7wHJqA78fSbrwwgt1xRVX5JYM27p1q2666aa84370ox/pjW98o771rW/ltXd2duaFMQAAAMB8QU0WAAAAYI5797vfLY/Ho9tuu23YLAdjjDo6Og77HH/3d3+nV199VV/5yleGbRt4zosvvliZTCa33NRQ6XRanZ2dY+57OByWpGHHDsziGPp6ksmkvvrVr+btt3r1alVUVOib3/ym0ul0rv2xxx4btizZxRdfrJdfflnf/OY3h/Wjt7dXsVhszP2XpKuvvlqhUEh33323pOzsluLiYn3hC19QKpUatv/+/fvHdZ6RvO1tb9Of//xnPfvss7m2WCymb3zjG2pubtYxxxyTay8tLdXatWv1+OOP6/vf/778fr8uvPDCvOfzeDzDxtAPf/hDvfzyy5PWZwAAAGA2YSYLAAAAMMctWbJE//RP/6SbbrpJbW1tuvDCC1VUVKTW1lY98cQT+tjHPqbrr7/+kM9x+eWX6zvf+Y6uvfZa/fnPf9YZZ5yhWCym3/3ud7ryyiv1zne+U2eddZauuOIK3XXXXXrhhRf0lre8RT6fT9u2bdMPf/hDPfDAA7rooovG1PeVK1fK4/HonnvuUTQaleM4Ouecc3TqqaeqrKxMH/jAB3TNNdfIsiw9+uijwwIAv9+vz3/+87r66qt1zjnn6OKLL1ZbW5seeeQRLVmyJG/Gyvvf/349/vjj+vjHP66nn35ap512mjKZjF588UU9/vjj+s1vfjPqkmyHUlFRoXXr1umrX/2qNm/erKOPPlpf+9rX9P73v18nnXSSLr30UlVVVWnnzp365S9/qdNOO23EMGs8brzxRv37v/+7zjvvPF1zzTUqLy/Xv/3bv6m1tVU//vGPc3V7BlxyySW67LLL9NWvflVr165VaWlp3vYLLrhAt99+u9atW6dTTz1V69ev12OPPabFixdPSn8BAACA2YaQBQAAAJgHbrzxRi1btkz333+/brvtNknZGiNvectb9I53vOOwx3s8Hj355JO688479b3vfU8//vGPVVFRodNPP13HH398br+HH35Yq1at0te//nXdfPPNuQLzl112mU477bQx97u2tlYPP/yw7rrrLn34wx9WJpPR008/rbPPPlv/5//8H1133XW65ZZbVFZWpssuu0znnnuu1q5dm/ccV111lYwx+tKXvqTrr79eJ5xwgn7+85/rmmuuUSAQyO1n27Z++tOf6v7779d3vvMdPfHEEwqFQlq8eLE++clPjnupNUm69tpr9fDDD+uee+7RI488ov/1v/6X6uvrdffdd+vee+9VIpFQQ0ODzjjjDK1bt27c5zlYTU2N/r//7//TDTfcoAcffFB9fX163etep1/84hc6//zzh+3/jne8Q8FgUN3d3brkkkuGbb/55psVi8X0ve99Tz/4wQ900kkn6Ze//KVuvPHGSeszAAAAMJtYZrxVEQEAAABglnJdV1VVVXr3u9894vJgAAAAAHAkqMkCAAAAYE7r6+sbtozYd77zHR04cEBnn312YToFAAAAYE5gJgsAAACAOe33v/+9Pv3pT+s973mPKioq9Pzzz+tb3/qWjj76aD333HPy+/2F7iIAAACAWYqaLAAAAADmtObmZjU2Nupf/uVfdODAAZWXl+vyyy/X3XffTcACAAAAYEKYyQIAAAAAAAAAADAO1GQBAAAAAAAAAAAYB0IWAAAAAAAAAACAcSBkAQAAAAAAAAAAGAdCFgAAAAAAAAAAgHEgZAEAAAAAAAAAABgHQhYAAAAAAAAAAIBxIGQBAAAAAAAAAAAYB0IWAAAAAAAAAACAcfj/AUwPPXJrutJKAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ + "plt.legend()\n", "plt.show()" ] }, @@ -661,12 +645,25 @@ }, { "cell_type": "code", - "execution_count": 23, - "id": "1c17b61a", + "execution_count": 24, + "id": "b2d69593", "metadata": { - "nbsphinx": "hidden" + "tags": [ + "hide-input" + ] }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABmIAAALGCAYAAABWAo6cAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeXwU5f0H8M8ce+8mmztAAkFAELSiIh5QD7yrKKIWxSreUqVqtbYeVdRqqdVarNZ6VbD1+FmtCtYDFfFWxKPW+yJAAsmSc3PsOTPP74/JTnazG0hCYJPweb9evEJmZmefvTfzme/3kYQQAkRERERERERERERERNTv5GwPgIiIiIiIiIiIiIiIaKhiEENERERERERERERERLSdMIghIiIiIiIiIiIiIiLaThjEEBERERERERERERERbScMYoiIiIiIiIiIiIiIiLYTBjFERERERERERERERETbCYMYIiIiIiIiIiIiIiKi7YRBDBERERERERERERER0XbCIIaIiIiIiIiIiIiIiGg7YRBDRERERH0Wj8excOFCjBs3Dg6HA5Ik4dlnn832sPrkkEMOgSRJ2R7GNvvuu+9w4oknorS0FJIkwe/3Z3tINEg9/vjj2GuvveDz+SBJEi677LJsD2mnUlFRgYqKimwPY9Bat24dJEnCWWedle2hDChnnXUWJEnCunXrsj0UIiKinQqDGCIiIsItt9wCSZIgSRK++eabbA+HBpE//elPuOmmmzB8+HD86le/wsKFCzFhwoRsDyujneHgk67rmDVrFl544QUcd9xxWLhwIa666qpsD2tQkiQJhxxySLaHkTXvvfceTj/9dLS2tuLnP/85Fi5ciKOPPjrbw6IhaiC/P7/++uuQJAk33HBDtocyoCxduhSSJGHp0qXZHgoREdGgoGZ7AERERJRdQgg8+OCDkCQJQgg88MADuP3227M9LBok/vOf/8Dr9eKVV16B3W7P9nC2yT/+8Q+EQqFsD2ObVFZW4ssvv8T555+P+++/P9vDoUHs+eefhxAC//jHP3DggQdmezhE1E8WLVqEq666CiNGjMj2UIiIiHYqrIghIiLayb388stYt24d5s2bh9LSUjz88MOIxWLZHhYNEps2bUJBQcGgD2EAYOTIkQO2mqenNm3aBAAYPnx4lkdCgx2fS0RD07BhwzBhwgTYbLZsD4WIiGinwiCGiIhoJ/fAAw8AAM4//3ycfvrpqK+vxzPPPNPt9tXV1bjkkkswbtw4uFwu5OfnY+rUqfjd737X52231AIoU7uS5L7v3377LebMmYPi4mLIsozXX38dAPDRRx/h0ksvxZ577on8/Hw4nU6MGzcOV1xxBZqamrq9fU888QQOO+ww6zIVFRU47bTT8OGHHwIA7rvvPkiShBtvvDHj5Wtra2Gz2bDHHnt0ex3Jli5dipNOOgm77LILXC4XcnJyMG3aNDzyyCMZt1+7di0uuOACjB071rpP99hjD8yfPx8NDQ09us5nn30WP/vZz7DrrrvC4/HA4/Fgn332wV/+8hcYhtGjfSQel8rKSqxfv95qbZeYz2BrrVwyzX2Q3OZk1apVOOSQQ+Dz+ZCTk4Njjz0WX331VcZ9hUIh3HrrrZgyZQp8Ph+8Xi922203XHLJJQgEAgDM59jDDz8MABg9enTaeIHu54gxDAP33nsv9t13X3i9Xng8Huy7777429/+lvH+Sjyf6+vrccEFF2DYsGFwOByYNGkSlixZspV7Nt1HH32Ek046CcXFxXA4HBg1ahQuuugi1NTUpF3vwQcfDAC48cYbrdu4tXY6ya+nr7/+GrNmzUJ+fj48Hg+mT5+Ol19+udvLPv744zj00EPh9/vhdDqx22674eabb0Y0Gu32fqmtrcV5552HESNGQFGUlLY2H3zwAebMmYMRI0bA4XBg2LBhOPLII/Gvf/0rbX+rV6/GySefjNLSUtjtdpSXl+PCCy+0AoRkicdW0zT8/ve/t+Y0Ki8vx29+85uU8DnxPASAN954w7ofu96XvX3tAsCaNWtw5JFHWs/rww8/HO+99x5uuOEGSJJkvX8l+/rrr3HWWWehvLwcdrsdJSUlmDt3bq/bSPb0eZy4/YnnavLrZWtto5Jvx2OPPYb99tsPXq835XUWCoWwaNEiTJ48GR6PB16vFwcccAAef/zxtP0lv498+OGHOProo5Gbm4u8vDycdNJJqKqqAmC+L5566qkoKiqCy+XCoYceik8//TTjGGtqanDxxRejoqICdrsdRUVFmD17Nj766KOU7f7whz9AkiTceeedGfezadMmqKqKKVOmpCzXNA333HMP9t9/f+Tk5MDtdmOvvfbC3XffnfH9QgiBu+++G5MmTYLT6cSIESOwYMECBIPBLd7XXQ0fPjxjhcOoUaMgSVLa5+6LL74ISZJw/fXXpyzv6f0DpL5nv/TSSzjkkEOQm5ub8j761ltvYebMmSgrK4PD4UBpaSn233//lM/Qnrw/b0lraysuv/xylJWVwel0YsKECbjjjju6/Tz79ttvcdVVV2HKlCkoKiqy3lcvuOACVFdXp2x71lln4dBDDwWQ+r6a/HoNBoO47bbbMGPGDJSVlVn32/HHH4/33nuvR7ch+fokScLatWtxxx13YMKECXA6nSgrK8Mvf/lLtLS0ZLxcTz8nkq+ju+9V69atw6mnnorCwkI4nU5MmTIF//nPf1L2ccghh+Dss88GAJx99tkp90tiv62trfjd736H3XffHTk5OfD5fBgzZgzmzJmT8flEREQ01LE1GRER0U4sEAhg+fLl2HXXXXHggQciJycHf/rTn3D//fdjzpw5adt/+OGHOOqoo9DY2IiDDjoIs2fPRigUwpdffokbbrgB1113XZ+27asffvgB++23H3bddVecfvrpCIfDyMnJAWAGTM888wwOPvhgHH744TAMAx999BHuuOMOvPjii1i9ejV8Pp+1LyEEzj77bDz88MMoLCzE7NmzUVRUhOrqaqxatQrjx4/HlClTcPrpp+PXv/41/v73v+O3v/0tFEVJGdNDDz0ETdNw4YUX9ug2/PznP8ekSZNw0EEHYdiwYWhoaMALL7yAM844A998803KwbOamhrsu+++aGlpwU9+8hOcdNJJiEQiqKysxD//+U8sWLAABQUFW73Oq666CrIsY7/99sOIESMQDAbx2muv4dJLL8WaNWvwz3/+c6v7mDVrFioqKrB48WIAsCbx7o+J4f/zn/9g2bJlOOaYYzB//nx8+eWXeOGFF7BmzRp8+eWXKCwstLZtamqyDrqOHz8e55xzDux2O3744QcsWbIEs2fPRklJCRYuXIhnn30Wn376KS699FJrnD0Z7xlnnIHHHnsM5eXlOO+88yBJEp555hlcdNFFePvtt/Hoo4+mXaa5uRnTpk2D3W7HySefjGg0iieffBLnnHMOZFnGvHnzenxfnHTSSRBC4OSTT8aoUaPw0Ucf4W9/+xuWLVuGt99+G6NHjwYALFy4EOvWrcPDDz+Mgw8+2Ao3ezrPSWVlJQ444ADsscceuPDCC1FTU4MnnngCxxxzDB577LG094RzzjkHS5YsQVlZGU466ST4/X68//77uO6667By5Uq88sorUNXUPzcaGxux//77w+v1Yvbs2ZBlGSUlJQDM1+zPf/5zKIqC448/HuPGjcPmzZvx4Ycf4p577sFPf/pTaz8PPfQQLrjgAjgcDhx//PEoLy/Hd999hwcffBDPPfcc3n//fYwcOTLtNs6dOxdvvfUWjjnmGOTk5OCFF17AH//4R2zevNkKHiZPnoyFCxfixhtvxKhRo1Im+k6+L3vz2gWAN998E0ceeSR0Xcfs2bMxZswYfPbZZzj00EMxY8aMjI/JSy+9hNmzZyMej2PmzJkYO3Ysqqur8fTTT+P555/HqlWrsPfee2/9wUXPn8eJ29/X1wtgzh31yiuvYObMmTj00EOtUKG5uRkzZszAJ598gr333hvnnHMODMPAihUrMHfuXHzxxRe4+eab0/a3Zs0a3HrrrTj44INx/vnn47PPPsPTTz+Nzz//HMuWLcP06dMxYcIEnHnmmVi/fj2efvppHHHEEVi7di28Xq+1n8rKSkyfPh2bNm3CjBkzcNppp6GqqgpPPvkknn/+efz73//GcccdZ91f1157Lf7xj3/g0ksvTRvTI488Al3XU54ficdpxYoVGD9+PObOnQun04lVq1bhF7/4BVavXp32/nrZZZfhL3/5C4YNG4YLLrgANpsNy5Ytw+rVqxGLxXpcbThjxgw8+uij+Prrr63Kvu+//x4bNmwAAKxcuTLlc3flypUAgMMOO6xP90+yp556Ci+99JL1nr1+/XoA5vP32GOPRU5ODo4//niMGDECjY2N+Oqrr3DPPfdg4cKFALBNz7doNIrDDjsMa9aswZ577onTTz8dzc3N+N3vfoc33ngj42Wefvpp3HvvvTj00ENx4IEHwm6344svvrDePz788EMr1Jo1axYApL2vArCCoq+++grXXnstDjroIBx77LHIy8vDhg0bsHz5crz44ot47rnnej2/0i9/+Uu8+eab+OlPf4oTTjgBK1aswOLFi/HWW2/h7bffhtPptLbtzefE1qxfvx5Tp07FLrvsgjPOOAONjY144okncMIJJ+DVV1+1QqmzzjoLfr8fy5YtwwknnIDJkydb+/D7/RBC4Oijj8a7776LAw44AOeddx5UVbW+U/34xz/GPvvs06v7hIiIaNATREREtNNatGiRACB+//vfW8v22WcfIUmS+O6771K2jUajoqKiQgAQjz76aNq+qqqq+rStEEIAEAcffHDGMc6bN08AEJWVldayyspKAUAAEFdffXXGy61bt05ompa2/MEHHxQAxB/+8IeU5ffdd58AIPbdd1/R3Nycsk7TNLFp0ybr94svvlgAEM8991zKdoZhiNGjRwu32522j+58//33acui0aiYMWOGUFVVVFdXW8v/8pe/CABi8eLFaZdpa2sToVCoz9ep67o488wzBQDx/vvv92g/QggxatQoMWrUqLTlq1atEgDEwoULe3y5JUuWCABCURTx6quvpqy76qqrBABx6623piw/7bTTBAAxf/58oet6yrrW1taUxyHTcynZwQcfLLp+PX7ssccEALHXXnuJ1tZWa3lbW5vYZ599Mj7HE8/Nc889N+U5+MUXXwhFUcRuu+2W8fq7am1tFfn5+UKWZfHmm2+mrPvDH/4gAIgjjjgiZfnW7vdMkl9Pv/rVr1LWrVmzRqiqKvx+vwgGg9byxGN14oknpj3vFi5cmPF5mriOM844Q8Tj8ZR1X3zxhVBVVeTl5YnPP/88bYzJ7xnffPONsNlsYsyYMSmvDyGEePXVV4Usy2LWrFkpyxOP7d577y0aGhqs5W1tbWLMmDFClmVRU1OTNt7u3peE6N1rV9d1MXbsWAFAvPDCCymX+dvf/mbdN6tWrbKWNzY2Cr/fLwoKCsQXX3yRcpnPPvtMeDwesddee3U7vmR9eR5v7fWSSeKxd7vd4uOPP05bn9hn19dxOBwWRx11lJAkSXzyySfW8sTzGYB45JFHUi5zzjnnCAAiLy9P3HzzzSnrbrrppozPwSOPPFIASNv+nXfeEYqiiPz8/JT7J7H9Z599lnZbJk6cKOx2u6ivr0+7/QsWLEh57WuaZo332WefTbleAGLMmDEpz8twOCz2339/ASDj+2smf//73wUAcffdd1vL7r33Xut9wm63i/b2dmvd5MmThcvlEtFotM/3T+J9QJIk8eKLL6aNafbs2QKA+O9//5u2rq6uLuX3vjzfhBDilltuEQDE7NmzUz4D1q5dK/Ly8gQAMW/evJTLVFdXi0gkkravFStWCFmWxfz581OWb+19tbm5Oe32CGG+bw0bNkxMmDChx7cncT8UFBSIdevWWct1Xbfuz5tuusla3pfPia19r7rhhhtStn/ppZcEAHHMMcekLE88/kuWLEm7Hf/73/8EgLT34sRtaWxs3Op9QURENNQwiCEiItpJGYZhHYBMPmB41113CQDi17/+dcr2Tz31lAAgjj/++K3uuzfbCtH3IKakpCTjwZQtMQxD5OTkiEMPPTRl+e677y4AZDx42NXnn38uAIjjjjsuZXniYMXZZ5/dqzFl8u9//1sAEA8//LC1LBHE3Hfffdu8/0w++ugjAUDceOONPb7M9ghiTj/99LTt165dKwCIk046yVoWCASELMti2LBhoq2tbatj7UsQc/jhhwsAYsWKFWnbv/rqqwJA2nMpcSA6ObhIOOiggwSAlIOZ3XnkkUcEAHHaaaelrYvH41bYuX79emv5tgQxubm5oqWlJW194n5bunSptWzy5MlCVVXR1NSUtr2maaKgoEDsu+++KcsBCLvdLgKBQNplFixYIACIO+64Y6vjveyyywQA8Z///Cfj+lmzZglFUVJuS+KxfeWVV9K2v/766zMGq1sLYrqT6bX71ltvZXyuCGEelNx1113TgpjFixenHVhPlrgfuoY0mfTlebwtQcxll12Wtq6+vl4oiiKmTJmS8bL//e9/BQBx5ZVXWssSz+fp06enbf/GG28IAKKioiItdF+3bp0AIM466yxrWVVVlQAgRo4cKWKxWNr+fvazn6U9bo8++mi3AWUiiEzQdV3k5+eL0tLStKBRCCGampqEJEnilFNOsZadd955AoB46KGH0rZP3PaeBjGJ25w8plNOOUWUlJSI5557LuXxr6+vF5IkpRyg78v9k3jPznSwXYjOIOabb77Z6vj7GsSMHTtWyLKcMRhNPB+7BjFbsscee4jRo0enLOvL+2rCL37xi7T36S1J3A/JYUvCDz/8IGRZFhUVFdayvnxObOl71ahRozKexDJy5EhRUFCQsqwnQUymcREREe2s2JqMiIhoJ/Xaa6/hhx9+wFFHHZXSV37u3Lm44oorsHTpUtx8883WZK7vv/8+AOCYY47Z6r57s+222HPPPeFwODKui8fjuO+++/B///d/+PLLLxEMBlP6xW/cuNH6f3t7Oz7//HOUlJRgr7322ur1JtoRvfjii6iqqkJ5eTkA4P777wcAzJ8/v8e3YcOGDbj11luxcuVKbNiwAeFwOGV98jiPP/54XHPNNbj44ouxYsUKHHXUUZg2bRomTpyYcW6T7jQ0NOC2227DCy+8gLVr16K9vb3b68yGrnMuALDu4+T5fdasWQPDMHDQQQfB4/Fsl7F8/PHHkGU5Y3uvgw8+GIqi4JNPPklbN27cOKtNXrLk25HcMqm76waQsW2Vqqo46KCDsG7dOnzyyScZ23D11t57753Sri/hkEMOwcMPP4xPPvkE8+bNQygUwqefforCwkKrNV1XDocj45w+FRUVKC4uTlvem/eMxJwLb7zxBtasWZO2fvPmzdB1Hd9++21a65uePrd6ojev3cRzZPr06Wn7kWUZBx54IL799tuU5Ynb+emnn2ac5yex/VdffYWJEyducax9fR731dSpU9OWrVmzBrqudztvUTweB4CMz5tMj9vw4cMBmK3UuraITHymJc/3kbh9P/7xjzNOUj5jxgw88sgj+OSTT3DmmWcCAE488UTk5ubi0UcfxR/+8AfrehLzmSS3Jfv222/R2NiIcePGZWyvBgAulyvl9iVe44m5nZJNnz497XZtyahRo7DLLrvg9ddfh2EY1hwmhx9+OA4++GCoqoqVK1fiyCOPxKpVqyCESHlv6cv9k5Dp8QaA008/HU8//TT2228/zJkzB4ceeiimTZuGsrKyHt+uLWltbcX333+P8vJyjBkzJm39IYccknE+NyEEHn30USxduhSffvopmpqaoOu6tb6n7eCSvfPOO7jzzjvx3nvvYfPmzSnzTgHm+0Fv3qczPSd22WUXlJeXY926dWhubobf7+/3z4lMryfAfJ/szXw3EydOxOTJk/H4449j/fr1OOGEEzB9+nRMmTKlT/cvERHRUMAghoiIaCeVCA2SDyQBQH5+PmbOnIl///vfWLZsGU4++WQAZm9/ABknA+6qN9tui9LS0m7XzZkzB8888wx22WUXnHDCCSgtLbVCm8WLF6dMJt6X8V500UV488038eCDD+LGG29EbW0tli9fjsmTJ3d7UKqrtWvXYurUqWhqasKPf/xjHHnkkcjNzYWiKNZcH8njHDVqFD744APccMMNeOmll/D0008DMA+Q/OpXv8Ill1yy1etsbm7Gvvvui8rKSkydOhVnnnkm8vPzoaoqmpubceedd2acaH1HyjQvQGKukeSDZTvieRYMBpGfn5/xwJGqqigsLMTmzZvT1nU3t0Gm27Gl6waAYcOGZVyfWJ64H7ZVYq6WrhKvs8R4mpqaIIRAXV1dxoOcW9Lda7Y3j2VDQwMA4Lbbbtvidm1tbWnLevrc2prevnYT911393Gm5Ynb+cADD2xxLJluZ1d9fR73VabHOXF71qxZkzFAS8h0e3Jzc9OWJR63La1LhDtA315PLpcLP/3pT/HAAw/g5ZdfxjHHHINYLIbHH38cRUVFKcFh4vZ99913W3xdJN++LT0vEo9Lbxx22GF44IEH8PHHH8Nms6Gurg6HHXYYfD4f9t13X2temEzzw2zL+013r+vZs2fjP//5D/70pz/hoYcewn333QcA2GeffbBo0SIcccQRvbp9XW3tddXduC6//HIsXrwYw4YNs05GcblcAIClS5dac9z01DPPPIOTTz4ZTqcTRxxxBMaMGQOPxwNZlvH666/jjTfe6PXn6pZu0/r16xEMBuH3+/v9c2JLn13JJ7NsjaIoeO2113DTTTfhqaeewm9+8xsAgM/nw7x587Bo0aKtnoxAREQ01DCIISIi2gnV1dXh2WefBQCcdtppOO200zJud//991tBTOKP855US/RmWwCQJAmapmVct6WDB91VgXz44Yd45plncPjhh+PFF19MmTDcMAz88Y9/3KbxArAmgf/73/+O66+/Hg899BA0TcOFF17Y433ccccdaGhowJIlS9ICsccff9w66zrZbrvthieeeAKapuHTTz/Fq6++irvuuguXXnopPB4Pzj333C1e54MPPojKykosXLgw7az09957D3feeWePx78lsiwDwBYf155O/N2dvjxuvZWbm4vGxkbE4/G0s8Q1TUN9fX3Gypf+um4AqK2tzbi+pqYmZbttFQgEMi5PXH/iehI/99prL+ts7J7q7jWb/FgmJhrvTuL6g8Hgdrvvt6a3r93EOLu7jzMtT9zOTz/9FD/60Y+2abw7+nmc6XFO3J5f/vKXuOOOO/rtunqqr6+nefPm4YEHHsDDDz+MY445Bs8//zwaGhpw6aWXptyXicudeOKJVkje0zEFAgHssssuKesSj0tvqkdmzJiBBx54AK+++qoVuiXClhkzZmDRokVobGzEypUrkZubi7333jttLH15v9lSReaxxx6LY489Fu3t7Vi9ejX+85//4G9/+xuOO+44fPLJJ1ut5tqS5Psvk0y3ZfPmzfjLX/6C3XffHe+++25aFeDjjz/e63Fcd911sNvt+PDDD7HbbrulrLvwwgvxxhtv9HqfgUAA48ePT1ve3fvxjvqc6I28vDz8+c9/xp///Gd8//33eOONN3Dffffh7rvvRnNzM/75z3/u8DERERFlk5ztARAREdGO9/DDDyMWi2GfffbBueeem/FfUVERXn31VVRWVgIA9t9/fwDAiy++uNX992ZbwPxjvaqqKm25ruv473//28Nb1en7778HYLbySg5hAOCDDz5IayHk8Xiw++67IxAI9Lg9j81mw3nnnYeNGzfiueeew4MPPgiv14vTTz+91+M86aST0tZt7cCNqqrYZ5998Jvf/MY6cJQI17bXdfZGXl4eAGR8XL///nvrLN5tMXXqVMiyjDfffDOtvVomiXYrval82GuvvWAYBt588820dW+++SZ0XU85mNmfEm3yXn/99bR1mqbhrbfeAoB+u/6PP/4Yra2tacsT158Yj9frxaRJk/DFF1+gsbGxX667L+8vidu/vciy3O1zpbevo8R99/bbb6etMwwD7777btry/ryd2XweJyRer9v7cetO8mOQKSBetWoVgPTX07Rp0zBu3DgsW7YMwWDQCtnmzZuXst2ECRPg9/vx/vvvp1TibEniujI9Z95+++1evVcBZtgiSRJWrlyJ1157DbvssgsqKioAmIGMYRj4xz/+ge+++w6HHHJISguqvt4/PeXxeDBjxgzccccduOaaaxCLxVJe7315f/b5fBg7diw2btyIH374IW19pvfOtWvXwjAMHHnkkWkhTHV1NdauXZt2ma2N7fvvv8fEiRPTQhjDMDK+5nsi03Ni7dq1qKqqQkVFhRVe7+jPiWS9eczGjh2Lc889F2+88Qa8Xi+WLVvW7+MhIiIa6BjEEBER7YQSrW7uuecePPjggxn/XXjhhRBC4MEHHwQAzJw5ExUVFVi+fHnGM0aTe/H3ZlvAPEC3YcMGvPzyyynLb7755l63CAFgHXjqemBi8+bNuPjiizNeJtHW68ILL0wLCQzDsM4qTXbBBRdAURQsWLAAlZWVmDt3bsY5Nno7zhUrVlj3e7KPPvooY4CROBvY7Xb3+To/+eQTLFq0aOuD7qEJEyYgJycHy5YtS2l5FA6He9RCrSeKiopw6qmnoqamBr/61a/S2qa0tbWl3F8FBQUAzLk9euqcc84BAFx99dUIhULW8lAohKuuugoAtlqF1FezZs1Cfn4+Hn/8cWsOlYTFixejsrIShx9+eL/MDwOYFSY33XRTyrIPP/wQjz76KHJzc3HiiSdayy+//HLEYjGcc845GavWmpqaelUt8/Of/xyqquJ3v/sdvvzyy7T1ye8ZCxYsgM1mwy9/+cu0eVUAIBaL9cvB/oKCgoxBItD71+60adMwZswYrFq1Ki1suv/++zPejrPPPht+vx833ngjPvjgg7T1hmFkPPiaSTafxwnFxcU4/fTT8eGHH+J3v/tdxoO3P/zwgxX+97eysjIcccQRWLduXdrcRqtXr8Zjjz2GvLy8lOd5wrx58xCJRHDPPffghRdewI9+9KO0+cRUVcUvfvEL1NTU4JJLLkkL/AGzOiH5+Z2oprrllltSQs1IJIKrr76617exuLgYkyZNwjvvvIM333wzpfXYgQceCKfTab3Pd51TZFvun+68+eabGUOdTJ9ZfXl/BszXiWEY+M1vfpPyGVBZWYm//OUvadsnXrtdg662tjacf/75Gce7tbFVVFTgu+++w6ZNm6xlQgjccMMNGd/PeuLOO+9M+f5jGAauvPJKGIaBs88+21q+oz8nkm3pfqmsrMwYajU1NSEajVqt4IiIiHYmbE1GRES0k3n99dfx7bffYo899tjiXCbnnnsubrnlFixZsgQ33ngj7HY7nnzySRx55JGYO3cu7rvvPuy///6IRCL46quvsHLlSusARm+2BYBf/epXWLFiBU444QTMmTMH+fn5ePfdd1FZWYlDDjmkxwcbE/bdd19MmzYNTz/9NA488EBMnz4dgUAAL774IsaPH29N8pzsvPPOw1tvvYV//vOfGDduHE444QQUFRVh06ZNeO2113DOOeektfIaOXIkjj32WCxfvhwAetWWDDDnmVmyZAlOOeUUnHzyyRg+fDg+//xzvPTSS/jpT3+KJ554ImX7f/7zn7jvvvswffp0jBkzBnl5efjhhx/w3HPPweFw4LLLLtvqdZ555pm47bbbcNlll2HVqlUYN24cvvvuO/znP//B7Nmz066zr2w2Gy699FL87ne/w1577YUTTzwRmqbhlVdewfDhwzM+Bn1x99134/PPP8e9996L119/HUcddRTsdjsqKyuxYsUKLF++3Jqg/LDDDsNtt92G888/HyeddBJ8Ph/8fj8WLFjQ7f7nzp2LZcuW4V//+hcmTZqEWbNmQZIkPPvss6isrMScOXN6VQXVG16vFw899BBOOeUUHHzwwTjllFMwcuRIfPTRR3j55ZdRWlpqzbnQHw466CA8+OCDWL16NaZNm4aamho88cQTMAwD9913X0rrqnPOOQcfffQR7rnnHowZMwZHHXUURo4cicbGRlRWVuLNN9/E2WefjXvvvbdH1z1x4kTcc889mD9/Pvbaay+ccMIJGDduHBoaGrBmzRrk5ORYZ+RPmDABDz30EM455xxMmjQJRx99NHbddVfE43Fs2LABb731FoqKivD1119v0/1x2GGH4f/+7/8wc+ZM7L333rDZbDjooINw0EEH9fq1K8syHnzwQRx99NE4/vjjcdJJJ2HMmDH43//+h1deeQXHHHMMXnzxRaulH2Ae5Hzqqadw4oknYv/998dhhx2GSZMmQZIkVFVV4b333kNDQwMikchWb0s2n8fJ7r77bnz33Xe4/vrr8c9//hPTp09HSUkJNm3ahK+++gpr1qzB448/jtGjR2+X67/33nsxbdo0XHnllXj55ZcxZcoUVFVV4cknn4Qsy1iyZEnGMP2MM87A9ddfj4ULFyIej6dVwyRcd911+PTTT3Hvvffiueeew4wZMzBixAhs3rwZ3333Hd555x3ccsstVjuuadOm4Re/+AXuuusu7L777jj55JNhs9mwbNky5OXldTvvx5Ycdthh+Pzzz63/JzgcDkybNi3j/DDbev9055JLLsHGjRsxbdo0VFRUwG6346OPPsJrr72GUaNG4dRTT00Zd2/fnwHgiiuuwLPPPot///vf2HvvvXHUUUehubkZ//rXv3DQQQdZn88JpaWlOPXUU/F///d/mDx5Mo488kgEg0G88sorcDqdmDx5clol7vjx4zFixAj83//9H2w2G0aNGgVJknDGGWdg1KhR+OUvf2m9d5100kmw2Wx455138OWXX2LmzJl47rnnenyfJUybNg2TJ0/GnDlzkJubixUrVuDTTz/FPvvsg1//+tfWdjv6cyLZAQccALfbjcWLF6OhocGak+cXv/gFPv30U8yePRv77rsvdtttNwwfPhx1dXVYtmwZ4vG4NWcMERHRTkUQERHRTmXu3LkCgLjzzju3uu0RRxwhAIinn37aWrZ+/Xrx85//XFRUVAibzSby8/PF1KlTxS233JJ2+d5su2zZMrHPPvsIh8Mh8vPzxZw5c8S6devEvHnzBABRWVlpbVtZWSkAiHnz5nU79oaGBvHzn/9cjBo1SjgcDrHLLruIq6++WrS3t4tRo0aJUaNGZbzcI488Ig466CCRk5MjHA6HqKioEHPnzhUfffRRxu2fffZZAUBMmTKl27FsyTvvvCMOPfRQ4ff7hdfrFdOmTRPPPPOMWLVqlQAgFi5caG37/vvvi/nz54sf/ehHIi8vTzidTjFmzBhx1llnic8++6zH1/nFF1+ImTNniqKiIuF2u8Xee+8tHnjggR7dr11t6b40DEMsWrRI7LLLLsJms4ny8nJx5ZVXdvsYLFmyRAAQS5Ysybg/AOLggw9OW97W1iZuvvlmscceewiXyyW8Xq/YbbfdxKWXXioCgUDKtn/605/EhAkThN1uFwBSxnDwwQeLTF+PdV0Xf/3rX8U+++wjXC6XcLlcYu+99xZ333230HW9x+MUQmR8Pm/NBx98IGbNmiUKCwut+3H+/Pli48aNadtmet5sTfLj/uWXX4rjjz9e+P1+4XK5xIEHHiheeumlbi/73HPPiWOPPVYUFRUJm80mSkpKxL777iuuvfZa8dVXX6Vsu6X7JeHdd98Vs2fPtvY3bNgwcdRRR4knn3wybdv//e9/Yt68eWLkyJHCbreLvLw8MWnSJHHBBReIlStXpmzb3WMrRPfPu0AgIE477TRRXFwsZFlOu19789pNeP/998Xhhx8uvF6v8Hq94rDDDhPvvvuuuPjiiwUA8cknn6RdprKyUlx88cVi7NixwuFwCJ/PJ8aPHy9+9rOfiWeeeWaL92ey3j6P+/JcXbhwoQAgVq1a1e020WhU3HXXXeKAAw4QOTk5wm63i/LycjFjxgzx5z//WdTX11vbbum+3Nr7VXfPt+rqajF//nwxcuRIYbPZREFBgTjhhBPEBx98sMXbdthhhwkAQlVVUVtb2+12hmGIf/zjH2LGjBkiLy9P2Gw2MXz4cDFt2jRxyy23iA0bNqRtf9ddd1nvS8OGDRMXXXSRaG5u3uL7a3eWL18uAAhJktLe/37/+98LAKKkpKTby/fm/tnae/YTTzwhTj31VDF27Fjh8XiEz+cTkyZNEtdcc43YvHlz2vZben/ekmAwKH75y1+K4cOHC4fDIcaPHy9uv/128cMPP2R8jrS3t4trrrlGjBkzRjgcDlFWViYuuugiUV9f3+17xQcffCBmzJghcnJyhCRJac/zJUuWiD333FO43W5RUFAgZs2aJf73v//16DWRLPG6++GHH8Ttt98uxo8fLxwOhxg+fLi49NJLRTAYzHi53nxO9OV7VXf3y4svvij2339/4fF4BABrv1VVVeLqq68WBx54oCgpKRF2u12MGDFCHH300eKFF17o0X1BREQ01EhCCLHdUh4iIiKiIe6GG27AjTfeiAcffHC7t/Yh2h7WrVuH0aNHY968eVi6dGm2h7NTmjZtGlavXo1gMAiPx5Pt4RBRlpx11ll4+OGHUVlZabVRIyIioqGBc8QQERER9VFrayvuvfde5Ofn47TTTsv2cIhoAAuFQhnn01m6dCneffddHHnkkQxhiIiIiIiGKM4RQ0RERNRLzz//PD7++GM899xzCAQCuP3221MmHSYi6mrDhg3Ya6+9cMQRR2Ds2LHQNA2ffPIJ3n77bfj9fvzpT3/K9hCJiIiIiGg7YRBDRERE1EtPPvkkHn74YZSUlODqq6/GL3/5y2wPiYgGuJKSEpx++ul44403sGrVKkSjUZSWluLss8/GtddeizFjxmR7iEREREREtJ1wjhgiIiIiIiIiIiIiIqLthHPEEBERERERERERERERbScMYoiIiIiIiIiIiIiIiLYTzhHTA4ZhYNOmTfD5fJAkKdvDISIiIiIiIiIiIiKiLBJCoLW1FcOHD4csb7nmhUFMD2zatAnl5eXZHgYREREREREREREREQ0gVVVVKCsr2+I2DGJ6wOfzATDv0JycnCyPhoiIiIiIiIiIiIiIsqmlpQXl5eVWfrAlDGJ6INGOLCcnh0EMEREREREREREREREBQI+mM9ly4zIiIiIiIiIiIiIiIiLqMwYxRERERERERERERERE2wmDGCIiIiIiIiIiIiIiou2EQQwREREREREREREREdF2omZ7AERERERERERERERE/UUIAV3XoWlatodCg5CqqlAUBZIk9d8++21PRERERERERERERERZIoRAc3Mz6urqoOt6todDg5iiKCguLkZubm6/BDIMYoiIiIiIiIiIiIho0KutrUVzczNycnKQk5MDVVX7taqBhj4hBDRNQ0tLC2pqahAOhzFs2LBt3i+DGCIiIiIiIiIiIiIa1HRdRzAYRFFREQoLC7M9HBrkfD4fHA4H6uvrUVxcDEVRtml/cj+Ni4iIiIiIiIiIiIgoK+LxOIQQ8Hg82R4KDREejwdCCMTj8W3eF4MYIiIiIiIiIiIiIhoS2IqM+kt/PpcYxBAREREREREREREREW0nDGKIiIiIiIiIiIiIiIi2EwYxRERERERERERERETUK2eddRYqKiqyPYxBgUEMEREREREREREREdEAtnTpUkiSZP1TVRUjRozAWWedhY0bN2Z7eLQVarYHQEREREREREREREREW3fTTTdh9OjRiEQieP/997F06VK8/fbb+Pzzz+F0OrM9POoGgxgiIiIiIiIiIiIiokHgmGOOwZQpUwAA5513HgoLC3Hrrbdi+fLl+OlPf5rl0VF32JqMiIiIiIiIiIiIiGgQ+vGPfwwA+OGHHwAAsVgM119/PfbZZx/k5ubC4/Hgxz/+MVatWpVyuXXr1kGSJNx+++24//77MWbMGDgcDuy7775Ys2ZN2vU8++yz2H333eF0OrH77rvjmWeeyTie9vZ2XHHFFSgvL4fD4cD48eNx++23QwiRsp0kSViwYAGefPJJTJw4ES6XCwcccAA+++wzAMB9992HsWPHwul04pBDDsG6deu29a7KKlbEEBERERERERERERENQomAIi8vDwDQ0tKCBx98EKeddhrOP/98tLa24u9//zuOOuoofPDBB5g8eXLK5R977DG0trbiwgsvhCRJ+OMf/4jZs2dj7dq1sNlsAICXX34ZJ510EiZOnIhFixahoaEBZ599NsrKylL2JYTA8ccfj1WrVuHcc8/F5MmTsWLFClx55ZXYuHEj/vznP6ds/9Zbb2H58uW4+OKLAQCLFi3Ccccdh1//+te45557cNFFF6GpqQl//OMfcc455+C1117bDvfgjsEghoiIiIiIiIiIiIiGJCGAsJbtUXRyqYAk9f3ywWAQ9fX1iEQiWL16NW688UY4HA4cd9xxAMxAZt26dbDb7dZlzj//fEyYMAF33XUX/v73v6fsb8OGDfjuu++sIGf8+PE44YQTsGLFCmufv/nNb1BSUoK3334bubm5AICDDz4YRx55JEaNGmXta/ny5Xjttddw880349prrwUAXHzxxTjllFNw5513YsGCBRgzZoy1/TfffIOvv/4aFRUV1tgvvPBC3Hzzzfj222/h8/kAALquY9GiRVi3bp217WDDIIaIiIiIiIiIiIiIhqSwBux2T7ZH0emriwC3re+XP/zww1N+r6iowCOPPGJVpyiKAkVRAACGYaC5uRmGYWDKlCn4+OOP0/Y3Z84cK4QBOludrV27FgBQU1OD//73v7jqqqusEAYAjjjiCEycOBHt7e3WshdeeAGKouCSSy5JuY4rrrgCTz31FF588UUsWLDAWn7YYYelBCv77bcfAOCkk06yQpjk5WvXrh20QQzniCEiIiIiIiIiIiIiGgT++te/4pVXXsFTTz2Fn/zkJ6ivr4fD4UjZ5uGHH8aPfvQjOJ1OFBQUoKioCM8//zyCwWDa/kaOHJnyeyKUaWpqAgCsX78eADBu3Li0y44fPz7l9/Xr12P48OEpIQoA7Lbbbin76u66E0FPeXl5xuWJMQ1GrIghIiIiIiIiIiIioiHJpZpVKAOFaxuPyE+dOhVTpkwBAMyaNQvTp0/H3Llz8c0338Dr9eKRRx7BWWedhVmzZuHKK69EcXExFEXBokWL8MMPP6TtL1E905UQYtsG2gPdXXc2x7S9MIghIiIiIiIiIiIioiFJkratFdhAlghYDj30UNx999246qqr8NRTT2GXXXbB008/DSlpMpqFCxf26ToSc8B89913aeu++eabtG1fffVVtLa2plTFfP311yn72hmxNRkRERERERERERER0SB0yCGHYOrUqVi8eDEikYhVTZJcPbJ69Wq89957fdr/sGHDMHnyZDz88MMprc1eeeUVfPnllynb/uQnP4Gu67j77rtTlv/5z3+GJEk45phj+jSGoYAVMURERERERERERET9yNA0GLEYjGgURiwGPRoFAMiqCslmg2yzdf5fVSF104qJqCeuvPJKnHLKKVi6dCmOO+44PP300zjxxBNx7LHHorKyEvfeey8mTpyItra2Pu1/0aJFOPbYYzF9+nScc845aGxsxF133YVJkyal7HPmzJk49NBDce2112LdunXYc8898fLLL2PZsmW47LLLMGbMmP66yYMOgxgiIiIiIiIiIiKiHjBiMStY6Rq0aOEw9LY2aKEQ9EgEQtNgxOPmT00DJAmSJEFSlM5/qgq546fidEJ2OKC4XOZPm81cn/TT+j9DHEoye/ZsjBkzBrfffju++eYb1NbW4r777sOKFSswceJEPPLII3jyySfx+uuv92n/Rx99NJ588kn89re/xdVXX40xY8ZgyZIlWLZsWco+ZVnG8uXLcf311+OJJ57AkiVLUFFRgdtuuw1XXHFF/9zYQUoSg3mGmx2kpaUFubm5CAaDyMnJyfZwiIiIiIiIiIiIqJ8IIayAxYhGoScFLEY0Cq29HfG2NuihEIxYDCIeh65pEPE40HFoVQCQZDklNEn5qZrnwwvDgND1rf4zdB2SEOZ+E/tPhDiqClmWgeQQJxHeJMKcxPXa7WZY02UsiaocSR46M1dEIhFUVlZi9OjRcDqd2R4ODQFbe071JjdgRQwRERERERERERENOcIwMlauGLEY9EgEWns79PZ26OEw9FgspYIlEbAgOfzoCDIUrxdq4vdeBhmSLJuXsfV+9vjuQhyj47YIXYehaRC63hneICnE6aie2VKIozidkBO3LVFxkylYGmIhDtH2xiCGiIiIiIiIiIiIBg1D09KCFSMaNf8fiSDe3g6tvR1GOGxu2xGuCE1DojVQIphICRZcLut3SZKyehsz2REhDgwDSKrEMa+4S4hjs0GWZUh2OxSHwwpxVJcrvW1ad6EOQxzayTCIISIiIiIiIiIioqwSQpgtv7oGK4n2YOEw9PZ2xNvbYUSjEPF4Z8hiGJ2hQVJ7MElVITscUD0eSDabWdkyAAOWHWF7hDh6ezviLS3W74kQJ/WKtyHE6fqTIQ4NYgxiiIiIiIiIiIiIaLsQhgEjHk8NVpKCFq2tzWwRFgqZ23UELIn5V6wKFkVJOSivuN1QOVn9DtGvIY6mwdB1iK4hjq6bIU5yUJYc4iiK2U4tKcRJtFRTnU5IqgpNkmBomjnHT+I5IUlm+Nbxb2cN4ij7GMQQERERERERERFRrwhdTw9WEj/DYWihUGfA0hGsGPG4edA9qWpCSqp0kG02qA5HZ0ULKx8GvX4LcTrmvkkLcRLt1ADoDgf08eOhtbUhFouZVVKJ4CU5kJFl8/+Jn92FNQxxqB8xiCEiIiIiIiIiIiIAMCtSusy9kghZ9HAYWmL+lUgkpXpF6Hrn5PCS1Dnh+yCZf4UGnt6GOHFZRsxmg2y3Q7bbzcAvEfoJAZH4XdfNVngdy9OvWNq2ECfx/8Q+GOIQGMQQERERERERERENaUKIjJUr1vwrHdUrWlsbjFgsZf6VxMFsIUmQkuZfkW02yE4n1MTvKg8z0sCRHIKkLOsBkRTeJH4KIczKm96EOB3X3TXEkWQ5c3DDEGdI4zskERERERERERHRICQMI716peN3PRqF3lG9oodC0ONxK2AR8TiEEOYBXiEARUkJWBSvFyonRqedVHJrMmtZDy/bNcQR/RTiSLKcUoXDEGfwYRBDREREREREREQ0gBialhasWNUskYjVHkwPh60J7oWmmfNlAGaLMEmCpCjm5PaJSe2dTvMn518h2i66hji9iUFSQpyOwCYR4iTmVup1iJOhldoWQ5yu7dio3zCIISIiIiIiIiIi2gGMeNwMUzJUsGjhcGcFSyQC0dEaTGgaDE1LPUCaCFY65sNQPR5r0nsePCUanPoa4qSEM11DHE2z1ncX4qRc7xZCHMlmg2K39+m2EYMYIiIiIiIiIiKiPtvq/Cvt7Yi3tUEPhaz5V/SO9mBW+yIg8/wrPh/nXyGiLbIqYZJ+9nuIYxhQ3G4GMduA7+JERERERERERERdCMPIWLlixGJWezC9oz2YHoulVLBAiM4DoopihSuSqnL+FSIaMHoa4hix2I4a0pDFIIaIiIiIiIiIiHYahqZlnHvFiMWgh8OId7QHM8Jhc9uk+VcSTX0kSUoJV2SbDZLLZf5UFAYsRESUgkEMERERERER0U5Cj0YhDCOtD31XKXNMdPP/Xm9DtB0JIcyWX91UsGihEPT2dsTb22FEoxDxeGfIYhidZ4DLcmrA4nCY868kAhY+p4koS/7x6KM476KL8N6qVdhn772zPRzLl19+iX/9618466yzUFFR0ePL/fe//8Xtt9+ON954A5s3b4bH48Hee++N008/HWeeeSYURdl+g84CBjFEREREREREQ5DQdcRbWhAPBhFraUGkthaxYBAwjPSNuwtSMu24y4HojAemM+wvbbvuJgfusqzr8owhUtdtJSm13QoAJCoUulwusb/uKhik5Mt1c7u6HVOXfXd7EL+/wq4M+9/qPrp7PHsT0m3pObG1xyv1glvdn6FpKUFLvLXVbBEWCsGIx81/SfOvWBUsitI5ub2qQnG7O9uDDbGDfUREO9KXX36JG2+8EYccckiPg5gHH3wQ8+fPR0lJCc444wyMGzcOra2tWLlyJc4991zU1NTgmmuu2b4D38EYxBARERERERENckII82z/lhbEW1oQqa9HtK7OPEAdDgMAFJcLissFyWbreuFMO0zZd0/Xp2yb6XLdLO/r5VIu29fLdbdNP1yf6GZ5dzUVmfa4tW3T1neEFqIH19fddWfafmvrtzimTPvYWmVJN2GMMIzU+1JVUypYVK+383e2ByMiGnDef/99zJ8/HwcccABeeOEF+Hw+a91ll12GDz/8EJ9//vk2X49hGIjFYnA6ndu8r/7AIIaIiIiIiIhokDFiMcRbWhALBhFvbka4thZaSwu0UAjCMCDbbFDcbtj9fsilpWynRANSr0Ktjv+zPRgR0ZZt3LQJN9xyC15csQLNwSDG7LILfrlgAc464wxrm1gsht/fdhteXLECP1RWQtM07LXnnlh4zTU45KCDUvb3xFNP4Y4778R3a9dCkiSMGjUK5513Hi699FIsXboUZ599NgDg0EMPtS6zatUqHHLIIRnHd+ONN0KSJDz66KMpIUzClClTMGXKFOv39vZ2XH/99fjXv/6FzZs3o6KiAueffz6uuOKKlM8DSZJw8cUX44ADDsDvf/97fPvtt3jyyScxa9YsbNy4Eddddx2ef/55NDc3Y+zYsbjiiitwzjnn9Ok+7gsGMUREREREREQDmDAMxFtbEQ8GzWqXQACxxkZo4TBELAZIklnt4nbDXVDANks0aGytDVrKttt5LEQ0dAkhzM/LAUKy27dboBzYvBk/PvxwSJKEn19wAYoKCvDSq6/iggUL0NLaiksuuggA0NLaiiX/+AfmnHwyzp03D61tbVjyz3/i2Nmz8c5rr2Hyj34EAHj1tddwxrnn4tCDDsLvb7oJisOBr776Cu+88w4uvfRSHHTQQbjkkkvwl7/8Bddccw122203ALB+dhUKhbBy5UocdNBBGDly5FZvjxACxx9/PFatWoVzzz0XkydPxooVK3DllVdi48aN+POf/5yy/WuvvYZ//etfWLBgAQoLC1FRUYFAIID9998fkiRhwYIFKCoqwosvvohzzz0XLS0tuOyyy7bhHu85BjFEREREREREA4gWCnXO7dLQgMjmzZ0txoSA7HRCcbvhKCyE4nBke7hEREQDmojF8MXll2d7GJZJd9wBaTt9fl9/003QdR0fv/ceCvLzAQAXnHsufnbOOfjdH/6A888+Gy6XC3l+P7777DPY7XbrsufOm4c99t0X99x3H+7/618BAC++/DJycnLwn3/9CzaPBzavN+X6dtllF/z4xz/GX/7yFxxxxBHdVsEkfP/994jH49hjjz16dHuWL1+O1157DTfffDOuvfZaAMDFF1+MU045BXfeeScWLFiAMWPGWNt/8803+OyzzzBx4kRr2XnnnQdd1/HZZ5+hoKAAADB//nycdtppuOGGG3DhhRfC5XL1aDzbgs0yiYiIiIiIiLLEiMcRbWhAW2UlGj/5BJteegkbn3sOm154AXVvvongN99Aj0ah5uTAPWoUPLvsAtfw4bD7/QxhiIiIyCKEwDPLl+PYo4+GEAL1DQ3WvyMPOwzBYBCffPopAEBRFCuEMQwDjY2N0HQd++y1l7UNAOTm5qK9vR0rX3+9X8bY0tICABlbkmXywgsvQFEUXHLJJSnLr7jiCggh8OKLL6YsP/jgg1NCGCEE/v3vf2PmzJnmfVJfb/076qijEAwG8fHHH2/jreoZVsQQERERERER7QBCCGhtbVa1S6SuDtG6OuihEPRYDBIA2eWC6nbD5fdDVvknOxER0baS7HZMuuOObA/DIiVVofSnuvp6NAeDeHDpUjy4dGnGbTbX1Vn//8djj2Hx3Xfjm2+/RTwet5aPHjXK+v/8887DU888g+NPPRUjhg/HkUcdhZ/+9Kc4+uij+zTGnJwcAEBra2uPtl+/fj2GDx+eFtwkWp+tX78+Zfno0aNTfq+rq0NzczPuv/9+3H///RmvY/PmzT0ay7YacN/q/vrXv+K2225DbW0t9txzT9x1112YOnVqt9svXrwYf/vb37BhwwYUFhbi5JNPxqJFi+B0OgEAN9xwA2688caUy4wfPx5ff/31dr0dREREREREtHPTo1FzXpdgENHGRrPFWGsr9HAYQgjINhtUjwf2ggLIDgcnICciItoOJEnabq3ABhLDMAAAc+fMwRmnnZZxmz123x0A8OgTT+C8n/8cxx93HC6/5BIUFxZCURT88Y47sHbdOmv74qIifPj221ixYgVefv11rHj1VSxZsgRnnnkmHn744V6PcezYsVBVFZ999lnvb2APdG0xlrhPfvazn2HevHkZL/OjjvlwtrcBFcQ88cQTuPzyy3Hvvfdiv/32w+LFi3HUUUfhm2++QXFxcdr2jz32GK666io89NBDOPDAA/Htt9/irLPOgiRJuCMp5Zw0aRJeffVV63eVZxURERERERFRPxK63jmvS0sLIrW1iDU3Qw+FYGgaZEWB7HRC9XrhKCqCJLNTOBEREfWfosJC+Hw+6LqOww49dIvbPr1sGXapqMCTjzySciLITYsWpW1rt9tx7FFHYeYJJ0Bxu3HRRRfhvvvuw3XXXYexY8f26kQSt9uNGTNm4LXXXkNVVRXKy8u3uP2oUaPw6quvorW1NaUqJlFkMSqpeieToqIi6z45/PDDezzO7WFAffO74447cP755+Pss8/GxIkTce+998LtduOhhx7KuP27776LadOmYe7cuaioqMCRRx6J0047DR988EHKdqqqorS01PpXWFi4I24OERERERERDUFCCGjt7Qhv2oSWr7/G5rffRvXy5dj4/POoeeUVNHzwASKbN0NWVThLS+EdPRrukSPhLC6G6vEwhCEiIqJ+pygKTjz+eDyzfDk+//LLtPV19fWd23Z8FxFCWMs++PBDvN/luHpDY2PK77IsWxUk0WgUAODxeAAAzc3NPRrnwoULIYTAGWecgba2trT1H330kVVt85Of/AS6ruPuu+9O2ebPf/4zJEnCMcccs8XrUhQFJ510Ev7973/j888/T1tfl9SqbXsbMKUhsVgMH330Ea6++mprmSzLOPzww/Hee+9lvMyBBx6IRx55BB988AGmTp2KtWvX4oUXXsAZZ5yRst13332H4cOHw+l04oADDsCiRYswcuTIbscSjUatJxLQOYkQERERERER7XyMWAzxlhbEgkHEm5sRDgSgBYPQQiGzxZiqQnG7Yff7IZeWssUYERERbTdLH3kEK1auTFv+i/nzccsNN+CNt97C9MMOw7nz5mG38ePR2NSETz79FK+9/joCHXOqHHv00Xj2uedw8umn4ydHHonK9evxwEMPYbcJE9De3m7t88Jf/AJNTU04eNo0lI8ciepAAHfddRcmT55szdMyefJkKIqCW2+9FcFgEA6HAzNmzMjY4Qowj+n/9a9/xUUXXYQJEybgjDPOwLhx49Da2orXX38dy5cvx8033wwAmDlzJg499FBce+21WLduHfbcc0+8/PLLWLZsGS677DKMGTNmq/fXH/7wB6xatQr77bcfzj//fEycOBGNjY34+OOP8eqrr6KxS9i0vQyYIKa+vh66rqOkpCRleUlJSbfzucydOxf19fWYPn26eUaSpmH+/Pm45pprrG32228/LF26FOPHj0dNTQ1uvPFG/PjHP8bnn3+eNslPwqJFi9LmlSEiIiIiIqKhTxgG4q2t0DqCl0gggFhjI7RwGCIWAyQJissFxe2Gu6AAkqJke8hERES0E7nv73/PuPzMuXNRNmIE3nntNdxy66149rnncO+DD6IgPx8TJ0zA75OOd595+umoDQTw4NKleGXlSuw2fjyWPvAA/v3ss3jz7bet7eb+9Kf4+9KluH/JEjQHgygtLcWcOXNwww03QO6oqiktLcW9996LRYsW4dxzz4Wu61i1alW3QQwAXHjhhdh3333xpz/9Cf/4xz9QV1cHr9eLvffeG0uWLMHPfvYzAGahxvLly3H99dfjiSeewJIlS1BRUYHbbrsNV1xxRY/ur5KSEnzwwQe46aab8PTTT+Oee+5BQUEBJk2ahFtvvbVH++gPkkiuP8qiTZs2YcSIEXj33XdxwAEHWMt//etf44033sDq1avTLvP666/j1FNPxc0334z99tsP33//PS699FKcf/75uO666zJeT3NzM0aNGoU77rgD5557bsZtMlXElJeXIxgMIicnZxtvKREREREREQ0UWjiMeDBozu3S2IhIIACtvR16OAwIAdnptIIXZSeY6JeIiGiwissygn4/RpWXw2m3Z3s4Q4oRi0F2OmHzerM9lB0qEomgsrISo0ePhtPpTFvf0tKC3NzcHuUGA6YiprCwEIqiIBAIpCwPBAIoLS3NeJnrrrsOZ5xxBs477zwAwB577IH29nZccMEFuPbaa61ULpnf78euu+6K77//vtuxOBwOOPgFm4iIiIiIaEgx4nHEW1rMNmPNzYgEAogHg9Da2wFdBxQFqscDNScHjuJizuVCRERERP1iwAQxdrsd++yzD1auXIlZs2YBAAzDwMqVK7FgwYKMlwmFQmlhi9JRFt5doU9bWxt++OGHtHlkiIiIiIiIaOgQQkBrazODl2AQkbo6xOrrzWqXWAwSANnlgup2w+X3Q1YHzJ/HRERERDTEDKhvmpdffjnmzZuHKVOmYOrUqVi8eDHa29tx9tlnAwDOPPNMjBgxAosWLQJgTtZzxx13YK+99rJak1133XWYOXOmFcj86le/wsyZMzFq1Chs2rQJCxcuhKIoOO2007J2O4mIiIiIiKh/6dGo1WIs2tRkthhrbYUeDkMIAdlmg+J2w15QANnhgCRJ2R4yEREREe0kBlQQM2fOHNTV1eH6669HbW0tJk+ejJdeegklJSUAgA0bNqRUwPz2t7+FJEn47W9/i40bN6KoqAgzZ87ELbfcYm1TXV2N0047DQ0NDSgqKsL06dPx/vvvo6ioaIffPiIiIiIiItp2Qtc7W4wFg4jU1iIWDEJvb4ehaZBkGYrLBdXrhaOoiC3GiIiIiCirJNFdDy+y9GbSHSIiIiIiIuo/QgjooZBZ7dLSgkh9PaJ1dWaLsXAYkCQoTidUtxuK2w3ZZsv2kImIiCgL4rKMoN+PUeXlcNrt2R7OkGLEYpCdTti83mwPZYeKRCKorKzE6NGj4XQ609b3JjcYUBUxREREREREtHMzYjGr0iXe3IxwIAAtGIQWCpktxlTVbDHm90MuLWWLMSIiIkrFugPqJ/1Zw8IghoiIiIiIiLJCGAbira3QEi3GAgHEGhuhhcMwolGrxZjidsOVnw9Z5Z+wRERElJkshPndQteRXrtA1HvxeBwArPnotwW/xRIREREREdEOoYXDZouxYBCxpiZEams7W4wJAdnphOJywVFYCMXhyPZwiYiIaBBRhIASj6OlrQ1el4tVs7RNhBAIBoNwOByw9UPrWwYxRERERERE1O+MeBzxlhazzVhzMyKBAOLBIPRQCELTAEWB6vFAzcmBo7gYkixne8hEREQ0yLmjUbQFg9gEIMfrhU1RAAYy20zE45AkCfpOUJ0shEA8HkcwGERbWxtGjBjRL/sd+vccERERERERbVdCCGhtbWbwEgwiUleHWH29We0Si0ECILtcUN1u2Px+thgjIiKi7cKpaUBbG0LxOFqDQZ7o0U+EpkGy2XaqimWHw4ERI0YgJyenX/bHb79ERERERETUK3o0arYYa2lBtLERkUAAWmsr9HAYQgjINhsUtxv2ggLIDgdbgxAREdEO49Q0ODUNuiTB4HeQfhGprYV39GjkTZiQ7aHsEIqi9Es7smQMYoiIiIiIiKhbQtcRb20153UJBhGprUUsGITe3g4jHoekKFBcLqheLxxFRTzzlIiIiAYERQgoQmR7GENCPBqFDYDT6cz2UAYtBjFEREREREQEwGwxpodCVrVLpL4e0bo6s8VYJAIAUJxOKC4XnKWlkPv5TEEiIiIioqGIQQwREREREdFOyojFzHldWloQa2pCOBCA1tICrb3dbDGmqmaLMb8fstPJFmNERERERH3AIIaIiIiIiGgnIAwDWlub1WIsWleHaH09tHAYRjQKSZahuFxQ3G648vIgq/xzkYiIiIioP/CbNRERERER0RCkhcOIB4PQWloQbWxEpLa2s8WYYUDuaDHmKCyE4nBke7hEREREREMWgxgiIiIiIqJBzojHO1uMNTcjEgggHgxCD4UgNA1QFKgeD9ScHDiKiyHJcraHTERERES002AQQ0RERERENIgIIcwWYy0tiAeDiNbXI1pXB629HUYsBgCQXS6objdsfj9bjBERERERZRm/kRMREREREQ1gejSKeDCIeKLFWCAArbUVejgMYRiQ7XYobjfsBQWQHQ5IkpTtIRMRERERURIGMURERERERAOE0HXEW1sRDwYRCwYRqa1FLBiE3t4OIx6HpChQXC6oXi8cRUVsMUZERERENAgwiCEiIiIiIsoCIQT0UKiz2qWhAZHNm6G1t0OPRAAAisMBxe2Gs7QUss2W5RHTYCOEgN7ailhdHeL19YjV1cGIxWDLzYWalweb3w81Lw9qbi5DPSIiIqLtiEEMERERERHRDmDEYua8Li0tiDU1IRwIQGtpgdbebrYYs9nMFmN+P2Snky3GqNeMaBSx+nordInX1cGIRtO201tagKqqzgWyDDUnB7a8vJSARvF6+TwkIiIi6gcMYoiIiIiIiPqZMAxobW1Wi7FoXR2i9fXQwmEY0SgkWYbickFxu+HKy4Os8k8z6h1hGNCamhCrq7MqXrRgMH1DWYYtPx/2oiLYioqgOJ2IB4PQmpoQb26G1tQEEY9Da26G1twMVFZaF5VUFarfbwY0ST9ll4sBDREREVEv8Ns+ERERERHRNtLCYfPgdksLoo2NiNTWQguFoIfDgGFAcjigut1wFBZCcTiyPVwahPT29pTQJV5fD6HradspPp8ZuhQWmj/z8yEpSso2juHDrf8LIaC3t0Nrbka8qakzoGluhtA067qSyQ5HSuWMFdDY7dvnxhMRERENcgxiiIiIBilhGOznTkS0gwkhzIPTra1mtUtzMyKbNyPe3Aw9FILQNEBRoHo8UL1eOIqK+F5NvWbE44g3NKTO7RIKpW0n2WxWpYu9sNCqeOkNSZKger1QvV44y8qs5cIwzNZ5iYCm46fe2mq2QKutRay2NmVfisfTWTmTCGpycyGx4ouIiIh2cvw2RERENEgIXUesqQnRhgaEa2oQa2gAZBmSLEOy2SArCiRFgaSqkBTFbHOjKJA71lnbKorZTkRRzN87/qFjeWIbSJK5bWJ98mWT/09EtIMJw4AwDKDjpzAMszJACAhd7369YZhBSuL/XS5rxOMwdB1C08z96DqMeNz8f9IyoevQO1qMQZIgO51QPR7Y/H62GKNeE0JACwYR76h2idXVmS3ChEjdUJKg5uXBnhS6qLm52+2zWJJl2Px+2Px+uCoqOseraeZ4k1qbxZuaYIRC0Nvbobe3I7pxY+q4fT6oSe3NbHl5UHw+hpRERES00+BfCURERAOY1taGaEMDonV1CFVXI9bSAhGNQrLbobjdQOLAYyhk/jSMjD8hBATMs15TDuwkfpckCCGsIAaJsCXp90zLEwGO3DX8UVVIqmr9TAlzkgKhHoU93VyWB2+IskcIkRpkGAag61bIkRaCJH7fSkhiGAagaVYYYmiaFYAYHT+RCEOEsMZhBSyJ976k8VnvhZKE5MPVArB+t94fgZT3uy39tBcUQHY4GEhTr+mRSEroEq+vh4jH07aT3W4zdOmoeLHl50O22bIw4lSSqsJWUABbQUHKciMa7Qxmkn6KaNSsrGlpAdav77xAR9DTNaCR3W6+roiIiGjIYRBDREQ0gBjxOGKNjYg2NiJcXW1O7NzRikT1erf73AIi6cBlxmAn6eCmoeuApnUb/iRfRuoS9iSCIaDjQGimA6CJMEaWzW0SwU1im/6oBuoIglgNRINRWiXIlqpCkkKSXleFJH7vUhViXWfXMCTxPpEchgApIbAVgiS9H0gARPJrPFMQ3GWZLMuAzdb52kz+2fXyRFkgdN1sMVZfb4Uveltb2nZWuNERvNgLC6F4PFkYcd/JDgccJSVwlJRYy4QQMMLhlMoZLXn+mcZGxBsbU/Yj2WxWWzNbUkgj97LlGhEREdFAwiCGiIgoi4QQiLe0INbYiEgggPCmTYi3tMCIx6E4nVB9PrgLC3fYQUQreMgC0V34k+GnEMI8e7gv1UAZfva6GigpwGE10M5rQFSFGIYZavalKiTx3E/cHiRVhWwt1EgKROUeVI9Y4SrRECaEgN7amhK6xBsbzddnF2pubkrooublDcn3dkmSoLjdZhXv8OHWciEE9LY2M5hJmn9GCwYh4nHEN29GfPPmlH3JLldK5Yzq90P1+wdElRARERHR1jCIISIi2sH0aBSxhgZEGxrMdmNNTdBCIUiybE6UW1IC2W7P9jB3uJSDvVnQk8qexIFuI3HAPVPok3zge3tVAyVCnO1cDWT9fwBXA21TVcgW5hmxqkLicXN5N1UhXZ8fPaoK6VIFkvK7JFk/e9IeC7IMWZK6rwrpGqQQUb8xOj7PrdClrs6cN6gL2eHoDF2KimArLNwpP+eTSYl5Y3w+YORIa7nQdbONWZf2ZnprK4xwGLFwGLGampR9KV6vGcwkVc+oOTnmZxoRERHRAMEghoiIaDsThoFYczNijY0I19YiUlODeGsrhGFAcblg8/ngKC4eUAe3d0aJg9TZOHDT62ogXQfi8b5XA1k3uvtqoMSB+22qBkpsm6kaSJZ7VhWSXAnSD1UhKQFI4v5Pvo867hcA3YcaXcMNVoUQDXnCMKA1NZnzunRUvGjBYPqGsgxbfr41r4u9qAiK18vXfg9JimJVvLiSlhvxuNXSLJ7U4swIh6G3tZnt3qqqknYkmVVHicqZjlZnis/Hx4KIiIiygkEMERHRdqCFw4g1NCBSV4dwdTViwSD0cNjsAe/zwTVihHnwmggDsBqoa0urXlQDJQdG3VUDpYUeXatE+lIVkinw6C5AISLaCr293Qxd6uoQr69HvKEBQtPStlN8PqvKxV5UBFt+PisxtgPZZrMqipLpkUhqa7OOnyIpuEkmqarV0ixRRWPz+yG7XPx8ICIiou2KR4CIiIj6gdB1xJqaEG1oQLimBpFAAFpbG4QQUD0e2P1+yKWl/COfBqRsVgMREWWbEY8j3tBghS6xujoYoVDadlJHGGCFLkVFUDiBfFYpTieUYcPgGDbMWiaEgBEKpVTOJFqcCU0zg7X6eoST9iM7HCmVM1ZA43Ds+BtFREREQxKDGCIioj6Kt7Yi1tiIaF2dOddLSwtENArJbofN54O7vJwHtomIiAYQIQS0YNCa1yVWV2dWTSS3bQTM1lZ5ebAnhS5qbi5PqBgEJEmC4vFA8XjgLCuzlgvDgN7amlI5ozU1QWttNef7CQQQCwRS9iW73SmVM2peHmy5uZBY1UxERES9xG8PREREPWTE42bw0tiIcHU1ovX10DrOmFW9XjgKC6HwzEkiIqIBQ49EUkKXeH09RDyetp3sdlutr2yFhbAVFEC22bIwYtpeJFmGmpsLNTc3ZbnQNDOcS6qc0ZqaoLe3wwiFEA2FEN24MWlHEhSfz5p/xpqHJicnay1GiYiIaOBjEENERNQNIQTiLS2INTYiEgggvGkT4i0tMOJxKE4nVJ8P7sJC/tFNREQ0AAhdR7yx0Qxc6uoQq6+H3tqatp2kqrAVFMBWVGRVvCgeTxZGTAOB9XwoKEhZbsRiKZUziYDGiEaht7RAb2kB1q/vvIAsm8FMonKmI6BRPB5WUhER0YAgDAMiHofQNOufkfh/l+Vd12mtrZA0DYX775/tmzFoMYghIiJKokejiDU0INLQgHB1NWJNTdBCIfMsSq8XztJSniFLRESUZUII6K2tiNXXWxUv8cZGwDDStlVzc83QpSN4UfPyeBIFbZVst8NeXAx7cbG1TAgBIxzuDGiSfgpNg9bYCK2xMWU/ks3WWTmT1OKM8wsREVEmQtc7g5AM4UhKUJJpfdIyo8u6TN+TeiOWn99Pt3LnxCCGiIh2asIwEGtuRqyxEeHaWkRqahBvbYUwDCguF2w+HxzFxTyTkYiIKIuMWCw1dKmrgxGNpm0nOxxW6GIrKoK9oIATrlO/kSQJitsNxe2GY/hwa7kQAnpbW0rlTLypCVowCBGPI97xnE0mO52pc890VNDwhB8iooFNCAF0hCVdg46uYYjRTUCSMSjpWJ82b932IEmQVLXzn80GOfn3pOWJ/2utrfCMH7/9xzaEMYghIqKdjhYKme3G6uoQqq5GPBiEHg5Dttmger1wjRgBmZOwEhERZYUwDGhNTea8Lh3hixYMpm8oy7Dl53eGLkVFULxenjxBO5wkSVB9Pqg+H5wjR1rLha5Da2lJDWiam6G3tsKIRBCrqUGspiZlX4rXmx7Q5ORAUpQdfbOIiAatRFiSFpRkasu1haqT7tbvkLBEllNCEbmbgCRlm26Wd10HWe7196VQVRWcZWXb6cbuHHiUiYiIhjxD0xBvbka0oQHhmhpEAgFobW0QQkD1eGD3+yGXlvLADRERURbo7e0poUu8ocE8yNGF4vPBXljYWfGSn8+D0zSgSYoCW0eY4kpabsTj0ILBtAoaIxyG3tYGva0N0aqqpB1JUHNzO1ucdfxUfD5+fyWiQUsI0dmGq5sWW91WnHS3PrEfXd/hYYncXUDSsSxjxcmW1vM7zpDDIIaIiIakeGsrYo2NiHZUvcRaWiCiUUh2O2w+H9zl5fxiQ0REtIMZ8TjiDQ2I19eb4UtdHYxQKG07yWaDrbDQnNelqAi2wkIoLleGPRINPrLNBnthIeyFhSnLjUgkpXImEdCIeBxaczO05mZE1q2ztpdU1Qxoklqb2fLyILtcDGiIqF8IIXo1B0m367upOtkhZDlz660uoUmP1ncNWjjnHPUCgxgiIhoSjHjcDF4aGszgpaEB8fZ2s1WE1wtHYSEU9ognIiLaYYQQ0IJBa16XWH09tKam9DNUJQmq398ZuhQVQc3N5YFk2unITiccpaVwlJZay4QQMEIhc86Z5ubOn83NEJpmBpsNDQgn7UdyODpbmyX95HxJREOTMAyzsqSHc5BsdbL3LIQlkqJsve3WltZ3N8cJwxIaQBjEEBHRoCSEQLylxZzrJRBAeNMmxFtaYMTjUJxOqD4fPIWF/NJFRES0g+iRiBW6JCpeRDyetp3sdltVLvaiItgKCjhBOVE3JEmC4vFA8XiApN78wjCgt7amVM5ozc3QOqrAY4EAYoFAyr5ktzulckb1+2Hz+835AohouxKGkXkOku6CkEyTvXdTcQJd3yG3obu5R7Y4P0nSsm4ng1cU/t1OOwV+2hIR0aChR6OINTQg0tCAUFWV+YdnKARZUaB4PHCWlvJADhER0Q4gdB3xxkYzdOmodtFbW9O2kxQFtsLClDZjiseThRETDS2SLJttyXJzgVGjrOVC08xKtC4tzvT2dhihEKKhEKIbN6bsS8nJ6ayc6Qho1JwcHhilnY4wjMyTuW9tsvcttN5KTPYOw9ght6G7OUi21narR5PBs1KVaJswiCEiogFLGAZizc2INTQgHAggUlODeEsLhBBQXC7YfD44iov5hZCIiGg7EkJAb2vrDF3q6hBvbMx4UEnNzYWtqMic/6KoCGpeHg/mEu1AkqrCVlAAW0FBynIjFkttbdbUBK2pCUY0Cr2lBXpLC7BhQ+cFOoKelAqavDwoHg+/e1NWWZO79yAI2WrbrS6Tve/wsKQnc5D0ZH1imaLw9Uk0gDGIISKiAUULhcx2Y3V1CFVXIx4MQg+HIdtsUL1euMrKILN9AhER0XZjxGKI1dentBkzIpG07WSHwwxdOuZ1sRcUcA4KogFKttthLy6GvbjYWiaEgBGJpFTOJIIaoWnQOsKaZJLNltraLBHQOJ07+ibRACWEAJLacGUMQ7bUdmsrk72nzTO2PUhS7+Yg6W5dhqAFDEuIdlo8kkVERFllaBrizc2INjQgXFODSCAAra0NQgioHg/sfj/k0lJ+WSUiItoOhGFAa2pCrGNOl3hdHbRgMH1DWYYtP78zdCkshOLz8fOZaBCTJAmKywXF5YJj+HBreaIKLq2CJhiEiMcR73ivSCY7nWZrs0SLs46fbBs8MAkhAF3fatutrU32bnRzmR0almSag6Qvk70nzXECWebnGxH1OwYxRES0w8VbWxFrbES0o+ol1jGpqGS3w+bzwV1eDklRsj1MIiKiIUdvb08JXeINDeZBsy4UrzcldLHl53NCb6KdhCRJUH0+qD4fnOXl1nJhGNBaWlIqZ+JNTdBbW2FEIojV1CBWU5OyL8XrTa+gyc3ld/0eEEJ0tuHaQout7sKQrm23shKWyHKP225tbbL3tIoTPoeIaJDhN2kiItrujHjcDF4aGszgpaEB8fZ28488rxeOwkIobGVCRETUr4x4HPGGBsQ7gpdYXR2MUChtO8lmg61jThd7URFshYVQXK4sjJiIBjJJlmHz+2Hz++EaPdpabsTj0ILB1BZnzc0wQiHobW3Q29oQra5O2pEENSfHrJxJCmgUr3fQzSklhOjx/CNbnew9w/odQpa33Harh5O9Z1w/yB5PIqLtiUEMERH1OyEE4i0tiDU0ILJ5M8KbNiHe0gIjHofidEL1+eApLOQXcyIion4ihIAWDFrzusTq6825Hbqe8SxJUP3+ztClqMg8O50tWIioj2SbDfbCQtgLC1OWG9FoamuzjoBGxGJmcBMMIrJunbW9pChQ/f6UuWdsfj9kt3ub3qOssKSXbbd6OuH7DqEoPQ9CejvZO/8mIyLaIRjEEBFRv9CjUTN4aWhAqKrKPBsuFIKsKFA8HjhLS9kjmmiI6/HkrLoOADyTkmgb6JGIFbokKl5EPJ62nex2m63FEsFLQQE/j4loh5AdDjhKS+EoLbWWCSFghEKdlTOJoKa5GULXzSq+hgaEk/Yj2e1W5Yzq85ntunox2Xvie8f2tqWWW9223dpS663EOkXh9yEioiGAQQwREfWJMAzEmpsRa2hAOBBApKYG8ZYWCCGguFyw+XxwFBfzDFuiASYxOWtPzgIdEJOzsrc4kXlwsrExJXTRW1vTtpMUBbbCwpQ2Y4rHk4URExFlJkkSFI/HfG8aMcJaLgwDeltbWgWN1tICEYshFgggFghs+/X3NAjJ8H1ia+v5dw8REW0JgxgiIuoxLRQyq17q6xGqrkY8GIQeDkO22aB6vXCVlUHmRL5E22yoTc6aKURBR5uQrQY6hgERi0HEYjD6e4ySlHYwZWttPba0PjkEgizzgAz1iRACelubGbokKl4aGwEj/RWg5uamhC5qXh7PmiaiQUmSZXPemJwcYNQoa7nQdbPtYkdAo7e3967tVvIyReFnMxERZQ2PlhERUbcMTUO8uRnRhgaEa2oQCQSgtbVBCAHV44Hd74cybFi2h0mUFVucnLW7MGSQTs66tbNA+7ulWI9bnPWgJUmmqh4r5BHCXJahndM2S4Q8Xe6XbtuObKklSZf7GjyQNKQYsZhV5ZKoeDEikbTtZIejs71Yx1wMssORhRETEe04kqLAlp8PW35+todCRES0TRjEEBFRinhrK2INDYh2VL3EWlogolGzN7PPB3d5Odv50KCRMSzZwgH6bltzdbN+h8g0OWsvqzi6PUt0gJ45L0mSGTYoCuBwoL/fcaxqox48zluboLdr4GZVLWzvkEdRum+b0tvnAc8W3mGEYUBrakKsI3iJ19VBCwbTN5Rl2PLzO0OXoiIoPh8fGyIiIiKiQYpBDBHRTs6IxRBrakK0ocEMXhoaEG9vhyRJUL1eOAoLofCMW9qORFLlQ4/abm3tIHk2JmdVlC23s9rKvCYZKyU4Oet2IyWFPP3Nej4nPQ+3pTIq+bWQEvJsxzCwV8/R7lq3dfd62MmCBL29HbH6+s4WYw0NGR83xetNCV1s+flmizuifmDE49Da26GHw9AjEUgABABbTg5sublsK0tERES0A/AbFxHRTkYIgXhLiznXy+bNCG/ciHhrK4x4HIrTCdXng6ewkAd/KUVaWLKlOUi6axnVzWTw2FFhSW9aQm2p9RYPLtMWSLIMyW4H7PZ+33evQ8setm/rGlru8JBna6FlpuqvTOuz/Do0NA3xhgYrdInV1cEIhdK2k2y2lHldbIWFUFyuLIyYhiJhGNDDYSt4EYYBWVWheDxwlZTAUVICm8+HWGMj2tevR7i6GhDCnG8oJ4ehDBEREdF2wm9ZREQ7AT0aRbShwax6qapCvLkZWigEWVGgeDxwlpZCttmyPUzaRsIwuj/TvpsQZIttuZLnK8kwSfT2sMUghO2WaCe33UMeXd/ye0Vf27clhTrbta1fchu/7qrTtra+u/eZLicnCCHMyaPr6qyKl3hTU+f8QwmSBNXvTwld1NxcnuxA/UIIASMahRYKQQ+FYMTjZkWzywXV54N3zBg48vOtypeUCufRo5G7++6I1tUhtGkTQhs2mKEMAFtHKMNWtERERET9h0EMEdEQJAwDseZmxBoaEA4EEKmpQbylBTAMyG43bD4fHMXFPDA9yAghoDU1IVJVheimTeaZrpnmptieejMBeS9aGnECcqLskmTZDAe2Qyifca6mrVXs9KJ9m0XXYeg6EI32+22ALKe8l+mhUMb5f2SXywxcEsFLQQFPdKB+Y2ga9FAIWigEIxwGAMh2O1SPB67Ro+EoLLRCFNXr3epnquJwwF1WBndZGfQ990QkEEB40yaEqqoQ2rDBnKsoEcowPCQiIiLaJgxiiIiGCC0UMtuN1dcjVF2NeHMz9EgEss0G1euFq6yM7SYGIaHriAYCiFZVIbJhA/T29q1fKBGW9LSdT0/OEu/4ybCEiHpLkiRINtv2C3l0fYvVfVtr39Zt6zZN66xwMQyIaBR6UsgjKQpsBQVW6GIvKoLsdvM9kvqFMAzokYgZvLS3A7oOSVWhuN1wFBbCWVwMu99vVrvk5Gxz4Kc4HPCMHAnPyJHQ9twT0UAAoY0bzX/r15vP99xcqD4fQxkiIiKiPuAROSKiQcrQNMSbm812Yxs3IlpXB62tDUIIqB4P7Hl57Dk/SBmRCCIbN5qVLxs3pp51rShwDBsGZ3m52d4mUzsdthIhop2E1BE8Q1UBp7Nf9y2EADpCnq7t2WS7HWpeHg9IU7/Ro1HooRD0cBhGJALIMhSXC6rbDc+oUXDk50PtaDGmbufvd6rLBbWiAp6KCmihECKBAELV1Wa1zPr1kFQVNr8fqsfD1wARERFRDzGIISIaROKtrYg1NCDaUfUSa2mBiEYh2e2w5eTAXV7Og/CDlBYMIlJVhUhVFWKbN6fMMyC7XHCWlcFZXg778OGsbCIi2gEkSQISYXe2B0NDiqFp0MNhK3gRQpjhnssF14gRZrVLbq4Zuni9WQ07VLcb3tGj4R09GlpbG8KBAEJVVYjU1KC9rg6y3d45TlaDEREREXWLR3KIiAYwIxZDtLERscZGM3hpaEC8vd2ciNXrhaOwMHXiVRo0hGEgtnmzFb7oLS0p69W8PDjLy+EsL4etsJAHN4iIiAYhIQSMSARaKAQ9FIKhaeb3OI8HNr8fOePHw+b3m8FLTg5kuz3bQ+6W6vXC5/XCN2YM4q2tiAQCaF+/HpFAANG6OsgOB+x+PxS26CMiIiJKwyCGiGgAEUIg3tJizvWyeTPCGzci3toKoWmQHQ6oPh88hYVsAzFIGbEYops2IbJhAyIbN0IkTygty3CUlsJZXg5HeTlUrzd7AyUiIqI+MeJxc16XUAh6JAIAUJxOqB4PXGPHwllYaM7rkps7qAMLm88Hm88H39ixiAWDiAYCaN+wAZFAAJFAAIrTabYvc7uzPVQiIiKiAYFBDBFRlunRKKINDeZcL1VViDc1QQuHISsKFI8HztLSbZ6AlbJHa21FpLoa0aoqRGtrAcOw1kkOh9VyzDF8+IA+C5aIiIhSCcOAHg5Da283W4zpOmSbDYrHA1dJCRwlJVaLMZvPN2Tbx9pzc2HPzYV33DjEm5sR2bwZbevWIVpXh0hNDRS326yU4dyFREREtBNjEENEtIMJw0CsqQmxxkaEa2sRqa1FvKUFMAzIbjdsPh8cJSWD9gzJnZ0QAvH6eqvlmNbUlLJezcmBY+RIc76XoiJWNxEREQ0CQggY0Whni7F4HJIkQXG5oPp88I4ZA0denhm65ObulK1jJUmCPS8P9rw8+HbdFbHGRkQ2b0Z7RyijR6NmS7bcXChOZ7aHS0RERLRDMYghItoBtFDIbDdWX49QdTXizc3QIxHINhtUrxeusjJOwD6IGZqG2KZNVvhidLQiAQBIEuzFxdZ8L2pubvYGSkRERD1iaJrVYswIhwEAst1uthirqICjqMgMXXJyOFF9BpIkwVFQAEdBAXLGjzdDmUDArJRpaICRCGX8/p0ytCIiIqKdD4/6ERFtB4amWVUvoY0bEa2rg9bWBiEEVI8H9rw8tmcY5PRQyApeojU1gK5b6ySbDY4RI8zwZcQIyDzrk4iIaMAShgE9EjGDl/Z2QNchqSoUtxuOggI4S0pg9/vNuV1yctgytpckWYajsBCOwkLk7LYbog0NCNfWWpUyRjxufj/2+9mmlYiIiIYsBjFERP0k3tpqVr3U1SG8cSNiLS0Q0Sgkux22nBy4y8uHbG/wnYEQAlpjIyLV1Yhs2IB4Q0PKesXrtape7CUlfKyJiIgGKD0ahR4KQQ+HzSpWWYbidEL1eOAZNQr2pBZjKk+c6VeSLMNZVARnURH8EyciWl9vhjKVlYgEAhCaBtXngy03l4EXERERDSkMYoiI+siIxRBtbDSrXqqqEGtoQDwUgiRJUL1eOAoL2WphkBO6jmhtrVn1UlUFvb09Zb2tsBDOjvleVL+fbUmIiIgGGKHr1rwuejgMCAHJbofqcsE1YgScxcWw5+ZCzcmBzefj3G07kKQocJaUwFlSgtxJkxCtq7MqZcI1NRC6blYh5eayhS8RERENevw2Q0TUQ0IIxINBq8d1eNMmxFtbITQNssMB1eeDh5OvD3p6JIJodbUZvmzcCKFp1jpJUeAYPhyO8nI4y8qguN1ZHCkRERElE0LAiESs4MXQNPMEmY4J4nPGj4fN74e9Y24XtsEaOGRVhWvYMLiGDYN/990RqatDpKYG7evXI1xdDQgBNfG4MZQhIiKiQWjAfYP561//ittuuw21tbXYc889cdddd2Hq1Kndbr948WL87W9/w4YNG1BYWIiTTz4ZixYtgjOpH39v90lElKBHo4g2NCDa0IBQVRXiTU3QwmHIimK2oiotZduEQU4IAS0YtKpeYnV1gBDWetnlslqOOYYNg8Q//omIiAYEIx4353UJhaBHIgBgtRhzjR0LZ2GhVVGhuN2sXB0kZJsN7uHD4R4+HLm7745oXR1CmzYhtGGDGcpIkjVfD1vBEhER0WAxoI4mPfHEE7j88stx7733Yr/99sPixYtx1FFH4ZtvvkFxcXHa9o899hiuuuoqPPTQQzjwwAPx7bff4qyzzoIkSbjjjjv6tE8i2rkJw0CsqQmxxkaEa2sRqa1FvKUFMAzIbjdsPh8cJSX8Q36QE4aBWCCASFUVIlVV0FtbU9ar+flW+GIrKODjTbQNhGHAiMdhxGLmv3gcIh6HoWmQbTbzn91u/ZRUlZWFRJRGGAb0cBhaezv0cBjCMCCrKhSPB87iYjhLS61KFx6gHzoUhwPusjK4y8qg77mnVZUeqqpCaMMGQJbN+XxycvjZQURERAOaJETSab9Ztt9++2HffffF3XffDQAwDAPl5eX4xS9+gauuuipt+wULFuCrr77CypUrrWVXXHEFVq9ejbfffrtP+wSAaDSKaDRq/d7S0oLy8nIEg0Hk5OT02+0looFBC4UQa2hApK4OoY0bEW9uhh6NQlZVqD4fVK+XLRCGACMaRXTjRkSqqxGproaIxTpXyjIcw4aZVS9lZVC93uwNlGiQMeLxzqAlEbLEYkh8xZQkqTNssduher2w+XyQnU7ooRBiwSD0UAgiFoOuaRDxOIQQkABAllNCGtlmg2Sz8T2ZaIgTQsCIRjtbjMXjkCQJissF1eeDs7gYjvx88wB8bi7n5NsJaeEwooEAQhs3IrRxI7SWFkiKAltuLlTO9UNERNTvQlVVyJkwAYX775/toQwoLS0tyM3N7VFuMGD+io3FYvjoo49w9dVXW8tkWcbhhx+O9957L+NlDjzwQDzyyCP44IMPMHXqVKxduxYvvPACzjjjjD7vEwAWLVqEG2+8sZ9uGRENVKGNG9HyzTeI1tVBa2uDEAKqxwN7Xh4Ulyvbw6N+oLW2WlUvsdra1JZjDgccZWVwjhwJx/DhbDFHlEFKNUtyyKJpgBAQQEpIono8sPl8sPl8UNxuKE4nFIcDstMJxeWC4nBkPDhmaBqMaBR6JGL9MyIRxNvbobW2QmtthR6LQWtvhxGLAboOdOxHUtWMYQ0r2YgGD0PTrBZjRjgMAGZw6/HAVVEBR1GRVfWger18fRNUlwtqRQU8FRXQQiFEAgGEqqvNapn16yGpKmx+P1SPh6EMERERDQgDJoipr6+HrusoKSlJWV5SUoKvv/4642Xmzp2L+vp6TJ8+3ezxr2mYP38+rrnmmj7vEwCuvvpqXH755dbviYoYIhoahBBo++47NKxZAz0ahT0vD+7ycrawGAKEYSBeX2+FL1pzc8p6NTfXrHopL4e9qIh/mNNOz9A0M1jpWtViGGZFSnI1i80GtaDAqmhRnM7OgCURuPRx4mtZVc0qRI8n43ohBIxYzAxpwmEYkQj0aBRaOAyttRXx1lbooRD0tjbEOgIjYV4QkqJY1TgpYQ3f84myQhiG+VoOhaC1twO6DklVobjdcBQUwFlSArvfb7UY44kStDWq2w3v6NHwjh4Nra0Nkc2b0b5hAyI1NWivq4Nst5uVMgzxiIiIKIsGTBDTF6+//jp+//vf45577sF+++2H77//Hpdeeil+97vf4brrruvzfh0OBxwsbycakoSuo/mzz9D03/9CcbngKS3N9pBoGxnxOKKbNiFSVYVodTWMjsl6AQCSBHtJiTXfi8r2krQTSVSzpIQsHdUsQggzZFFVM5Sw26E4nXAWFcGWk9NZzZIIWzqClmyFF5IkQXE4zPZDubkZtzE0zQxoOkKaRGijtbcj3tICvb3dDG8SVTWGkdi52e4s01w1PGBHtM30aNQMSjtCVCRajHk88JSXw15QYLUYU1mRTNtI9Xrh9Xrh3WUXxFtbEQkE0L5+PSKBAKJ1dZAdDtj9fihuN9/jiYiIaIcaMEFMYWEhFEVBIBBIWR4IBFDazYHS6667DmeccQbOO+88AMAee+yB9vZ2XHDBBbj22mv7tE8iGrr0aBRNH3+M5s8/h6OwEDYelB+09PZ2q+olWlPTeUAVgGSzwVlWBkd5OZwjRkBmsE5DlNExn0pyyGLE44CuQ0gSpI6AQekIFux5eeYZ5snVLImwpaOaZTAflJJVFbLX2+0cT4k5J6z2Z+GwOQdFOIx4S4vZ/iwchtbWZgZYmgYYBgQ62p8lzXNjhTWsqiNKIXTdmtdFD4fNqjS7HarLBdeIEXAWF5vvQ7m5sHEeD9rOEq0yfWPHIhYMIhoImJUygQAigQAUp9NsX+Z2Z3uoREREtBMYMEGM3W7HPvvsg5UrV2LWrFkAAMMwsHLlSixYsCDjZUKhEOQuX96VjjM1hRB92icRDU1aWxvq16xB23ffwTlsGP/gGmSEEIg3NiKyYQOi1dWINzSkrFd8PqvqxV5SwgM7NOgJITKGLImWWxIASVHMSg67HYrDAUdhIVSfDzaPB4rLZQYtDocVtuzsrbgkSbLui+4Y8bg5P02X+Wq0tjYzrGlrM8Ob1lazukgISABEooVbl7CGVTU0lAkhYEQiVvBiaBokSYLqdsOWm4uc8eNh8/th75g8XeGJEZRF9txc2HNz4R03DvHmZrN92bp1iNTVIVJTA8XtNitlWJVFRERE28mACWIA4PLLL8e8efMwZcoUTJ06FYsXL0Z7ezvOPvtsAMCZZ56JESNGYNGiRQCAmTNn4o477sBee+1ltSa77rrrMHPmTCuQ2do+iWjoizY2omH1aoSqquAuL+/zHAa0YwlNQ7S21qp8MUKhlPW24mI4y8rgHDkSam4uD3bSoCJ0PS1kSbTLEkBnNYuqQrLbYUvMl9BRzdK1bdhgr2YZKBJhCny+jOuFYUCPRjtboHWENlp7O+Idc9UYkUhnUKNp5uVgVuxImcIaBsc0SBjxuDmvSygEPRIBhLBajLnGjoWzo9rYlpMDxePhexINSJIkwZ6XB3teHny77opYY6MVykTr6qBHo1A9Hthyc7cY3BMRERH11oAKYubMmYO6ujpcf/31qK2txeTJk/HSSy+hpKQEALBhw4aUCpjf/va3kCQJv/3tb7Fx40YUFRVh5syZuOWWW3q8TyIa2sI1NahfvRqx+nq4R42CrA6otz3qQg+HEa2uNluObdpkHcQEzNZAjuHD4Swvh6OsjGcs0oAlhIDQtLSQxXo+CwHIsnUgXnE44CgogJqTA5vHkzInSyJs4XvXwCDJsjmHxRbef4xYzJqjxuhaVdPaalbVRCLQWlrMVnJCWOGbbLenhzV87CkLhGFYcyzp4TCEYUBWVSgeD5zFxXCWlsLe0WJM9fn4PKVBSZIkOAoK4CgoQM748WYoEwigbd06RBsaYCRCGb+fFV1ERES0zSQhhMj2IAa6lpYW5ObmIhgMIodzShANGm1r16Lhgw9gRKNwDh/Os44HICEEtOZmq+olXleXsl52u62WY47SUkg80EMDQEo1S9JPoetInP+dfDBdcbth8/mg+nxQXS4oDkdn2OJysZplJyMMo7OaJhKxQhs9FEK8pQXx1lbo0ShE4vkVj5vPK0ky56rpGtawqoa2kTV/UkfwYsTjZis/lwuqzwdncTEc+fnmvC65uTwgTUOeMAxEGxoQrq1F+7p1iDU2wojHoXo8sPv9rK4nIqKdUqiqCjkTJqBw//2zPZQBpTe5AY9oEdGQIwwDwS+/ROPHH0NWVbjKyrI9JEoiDAOxQACRDRsQqa6G3tqast5WUGCFL2p+Pg9Q0w6VUs2SHLJkqFxIzM1iz8uDLScHqseT2jYsUdFis2X7ZtEAIskyVLd7i3OVWVU14XBKZU2ioiZTVQ0As9IqOaBJ/J8hNiUxNM1qMWaEwxAAFLsdqscDT0UFnEVFZujS8b7GoI92NpIsw1lUBGdREfwTJyJaX2+GMpWViAQCEJpmzsmWm8vPeCIiIuox/lVGREOKEY+j6b//RfP//gdbbi7seXnZHhIBMKJRRDZuRLSqCpHqavOgdoIsmy3HysrgLC+H4vFkb6A05AnDyBiyGJrWWc3SUXUg22xWJYvN54PqdpvhisvVGbbY7TxISf0uEfTZupurRtc7g5rkOWuSq2piMYhw2Hyed7TFk5KqalLCGlbVDFlWBVZH8AJNg6SqUNxuOAoK4CwpgT0xB1VODg8qE3UhKQqcJSVwlpQgd9IkROvqzFBm/XqEa2ogdN18/eTmMvQmIiKiLeI3BSIaMrRwGI1r1qDl66/hLC2FygP6WaW1tFgtx2KBQOcZ2wBkp9Oa68UxfDgP/FC/SbRySg5Z9FjMev4lV7PINpt5ANLng+r1doYryVUtfG7SACQpyharaoQQ5msg0fYsErGqa7S2NsRbWqCHQua/jteJEAKSEICiWK+PlLCGBxgHBSugC4VgRCJAosWYxwNPeTnsBQWd1S5bqMoionSyqsI1bBhcw4bBv/vuiNTVIVJTY4Yy1dWAEFA7Xl98zyQiIqKu+O2AiIaEWDCIhtWr0b5+PVxlZexfngXCMBCrqzOrXqqqoAWDKetVv99qOWYrKmLLMeo1YRjplSwdZ/tLQqTMoSHbbOYEux3VLIrbndo2zOmE4nCwCoCGJEmSoDgcUBwO2LrpUyx0vTOk6Th4b0QiiLe3Q2tthdZRVaO1t5tBjaZBSBIkpM6BlBzW8H19xxK6Di0RqIXDgBCQ7HaoLhdcw4fDWVJinalv8/n4fkfUj2SbDe7hw+EePhy5u++OaF0dQps2IbRhgxnKSJJVaSYpSraHS0RERAMAgxgiGvQimzej/r33ENm8Ge6RI3kG2g5kxOOIbtyISFUVotXVMKLRzpWSBHtpaed8L9202CFKMDrmZklUsSSCFiGENVl58ln6akEBVK/XDFoSE98nwhaHg5PpEm2BpChQPZ5uq0cTVTXJc9TokQi0cDi1qqatDTFN66yqAcy5apJCGius4cHIPhNCmPMCdQQvhqZBkiSobjdsubnIGT8eNr8f9txcqD4fT0gh2oEUhwPusjK4y8qg77knIoEAwps2IVRVhdCGDYAsW5VoDESJiIh2XjxaSUSDWvuGDahfvRp6Wxs8FRX842YH0NvbzZZjGzYgWlsLGIa1TrLbrbleHCNG8EA4WRLVLCK5dVgsBtExd4WA2fJDttmsM7ptHWdzW9UsDkdK2zC+3om2n+SqGuTmZtzG0LTOkCbRBi0chtbebgY17e3Qo1Fo7e0wYjHz86Kjaia5ei0R2kiqyqqaDkY8bs3rokcikGC29VQ9HrjGjoWzsNA6217xeHi/EQ0QisMBz8iR8IwcCW3PPRENBBDauNH8t349JEWBrSMw5fcYIiKinQuDGCIalIQQaP32WzSsWQMAcJWX8yDEdiKEQLyhwZrvRWtsTFmv+HxwjhwJZ1kZ7CUl/KNyJ2V0nBGfaBuW+GkFdZIEyWaD0nHQ1Z6f39k2rOu8LImDv0Q0oMmqCtnrher1ZlwvhEiZp8boCGy0cBhaa6sZ1nRU2CSCWsAMZiVFSWt/JtvtQ/IzRhiGFWAZkQgMXYesqlA8HjiLi+EsKYE9N9c6eMvKX6LBQXW5oFZUwFNRAS0UQiQQQKi62qyWWb8ekqrC5vdD9XiG5HsbERERpeK3eCIadAxNQ/Nnn6Hpv/+F6vHAUVCQ7SENOULTEK2pscIXIxzuXClJsBcVwZFoOZabyxBsiBOGAaFpKZUsRmLOiI5WRJKimPNGOBxQnE44i4pSqlkSc7JY1SxsUUQ05EmSZL3mu2PE42ZIkxTY6JGIWVUTDJrtz6JRaK2taa0KU+aqSQQ1A7yqxgqnEsFLPG7eTy4XVJ8Pzl12gSM/32xjlJvLUJpoiFDdbnhHj4Z39GhobW2IbN6M9g0bEKmpQXtdHWS73Qxbvd4B/R5GREREfccghogGFT0aReOHH6Llyy9hLyqCjfOO9Bs9FEKkuhrRqipEN22C0HVrnaSqcIwYYbYcKyvb4kE1GnyErqdVsiTaCAmYB1OTq1mseQi8Xusga3JVi2y38yACEfWI3BGmoJvPc2EY5lw14XBnZU00Ci0UQry1FVpLixnctLVlbHeYMazZgWeeG5pmtRgzwmEIAIrdDsXthqeiwgytO+aO4FnxRDsH1euF1+uFd5ddEG9tRSQQQPv69YgEAojW1UF2OGD3+6G43fw+RUREWZFyslQ0ChGLwdB1q80w9Q2DGCIaNOKtrWhYvRptP/wA14gRUFyubA9pUBNCQGtuRmTDBkSqqhCvr09Zr3g8VtWLo7SUFQyDlBDCrGZJqmRJPlgJIVIm1lYcDjgKC6H6fLB5PCktwxJtw9gWh4h2FEmWe1xVY7U/S1TVtLWZYU1bmxnetLSY1XxCdOxcgmK3p4c1NlufxioMw7zujuAFmgYoilW96ywuhj0vz5rbpa/XQ0RDR6JNq2/sWMSCQUQDAbNSJhBAJBCA4nSa7cvc7mwPlYiIhhhhGFbQkqhOF4Zhdryw2ayOFs6SEtjz8qC63XAUF2d72IMaj6QQ0aAQbWhA/fvvI7xxI9yjRvHgRR8JXUc0EEC0qgqRDRugt7enrLcVFsKZaDmWl8ez8AYBoetplSxGPG5VNFnVLKoKqaPthc3ng+rzQXW5oDgcnWGLy8VqFiIadBLhSXdVssIwzD8wk0KaRGASb21FvLUVRiTS2f5M08yQWpIgqar5vtglrJFkGXpHizE9FIIRiZjBjssF1eOBp7wc9oKCzmoXHkQloq2w5+bCnpsL77hxiAeDZqXMunWI1NUhUlMDxe02K2V4MhoREfWCEYt1hi0d1S2JzheJ+Vnt+fnWCUOq2w3F7TZ/ulys2O5HDGKIaMALbdqEhvffR6ypCZ6KClZm9JIRiSCycSMiVVWIbtxoTYYMAFAUOIYNg3PkSDjLyqDwQNGAZ2iaNcm1MAxIiWqWjjNWrC9PHo8VriTOZJGdTlazENFOR5JlqC4XsIWDl4k/UPVIBHo4bIU2iYoara3NDGs6qmpgGJAcDqguF1zDh8NZUmJWunSE3fyDlYj6SpIk2P1+2P1++HbdFbHGRnNOmXXrEK2rgx6NQvV4zHmk2C6YiIjQWZmdXOECw4AQwup8oTidcJaWwu73Q/V4zKCl4ydPdt4xeDSGiAYsIQTafvgBjR98AD0eh3vUKJ6p30NaMIhIVRUiVVWIbd5sntnbQXY6raoX+/DhPDA/CBiahngwCK21FQBgy8lB7sSJcJaUmEFLUtswvkaIiHov0Z5xi1U1Se3PjFgMqtcL1eeD4nDs4NES0c5CkiQ4CgrgKChAzvjxZigTCKBt3TpEGxpgJEIZv5/vRUREQ5wQAiIeT20lFo+nVbc4Cwth8/ut6hbV44GSqG7h8YKs4tE3IhqQhGGg+Ysv0PTRR5AdDrjLyrI9pAFNGAZimzdb4Yve0pKyXs3Ls8IXW2EhP3wHASMeRzwYRLy1FZIkwZabi9w99oB72DA4iov5xzYR0Q4kybL5hywrR4koSyRZhqOwEI7CQuTsthuiDQ2I1NaaoUxdHYx4HKrHA7vfD9luz/ZwiYioj4Sup7QSs6pbYJ48pNjtUFwuVrcMQgxiiGjAMWIxNH7yCYKffQZbXh7sfn+2hzQgGbEYops2IbJhAyIbN0JEo50rZRmO0lI4y8vhKC+H6vVmb6DUY0YshlhH5YukKLD7/cjfay84S0vhKCxk+EJEREREkGQZzqIiOIuKkDtxIqL19QjX1qK9shKRQABC06D6fLDl5vKAHBHRACSEMOd3jcWs6hajo428JElWxwtnYaF5XCwnp3PeFla3DFoMYohoQNFCITSsWYPWb76Bs7QUqseT7SENKFpbG6IdVS/R2lrAMKx1ksMBZ1mZGb4MH84z4QYJPRpFPBiE3tYGyWaD3e9Hzq67wllaCmdhIR9HIiIiIuqWpChwlpTAWVKC3EmTEK2rM0OZ9esRrqmB0HVrDiu2JCYi2rFSqls62tumVLd0zN3iGjYMdr/fqmpRPR4oLhfD9CGGn8JENGDEmptRv3o1Qhs2wFVWxrP/YZ4lEa+vt1qOaU1NKevVnBw4ysvhHDkS9qIiTg48SOiRiDnnS3s7ZJsN9rw85O62G5wlJXAUFvLLFhERERH1mqyqcA0bBtewYfDvvjsidXWI1NSYoUx1NSAE1Nxc2HJyGMoQEfUTq7olqZWYVd0iy1AcDrO6pbgY9rw82Hy+zuoWjweK08nqlp0EP3mJaECIBAKof+89ROrr4R45cqf+w8DQNMQ2bTLDl+pqGOFw50pJgr242JrvRc3Nzd5AqVf0cBixYBB6KATZ4TDDlz32gKu4GPaCgp36OU9ERERE/Uu22eAePhzu4cORu/vuiNbVIbRpE0IbNpihjCSZlTI5OZAUJdvDJSIa8NKqW6JRCCEgAZA6qltUlwv2ESNgz81ldQul4VEfIsq69nXrUL96NfRQCJ5Ro3bKqg49FEKkuhqRDRsQrakBdN1aJ9lscIwYYYYvI0ZAdjqzOFLqDS0UMtuOhcNQHA7YCwrgnTwZjuJiOPLz+UcvEREREW13isMBd1kZ3GVl0PfcE5FAAOFNmxCqqkJowwZAlmHrqJTZGf8WIyJKyFjdEouZFSuyDMXp/H/2/jy+7vOu8/5f1/fs5+joHEm2JNuSJdtxdsdZ7dgu3KUU2tI7kE6AFtomdBjWUrhp+ZVlbsqUe+buPTC0odBpC6QQZlKSttNOgZaypLQ0jrc4cRInsZM4XuNVy9kkne37vX5/XEe2HMuJLWs5kt7Px8OJfZbvuWRLZ/m+r8/nQ6hR3RJrbyecThNKJFTdIpdEQYyIzBkbBBT272foiSfA80iuXDnXS5o11lrqw8NnW47VBgbOuz7U0nK26iXa1aUT9vOEtRa/Eb4E5TJeIkGso4NUfz/xpUuJtrfrw62IiIiIzJlQLEZq5UpSK1dSX7+eyqlTjL76qvt1+DAmFCKSzRJuadH7VhFZsIJ6/WzIctHqlmSSaE8P0UzGVbWMtxNLJtXRQqZE3zUiMieCep3c008zvGePm3PS3j7XS5px1vepnDxJ+ehRKkeP4o+MnHd9ZMkS4itXupZj2ax2UcwT1lr8kRGqjfAlnEoR7+wk1ddHbOlSom1t+hArIiIiIk0nnEgQ7u8n1d9PfXSU8qlTjB475qplDh/GhMMulEml9H5WROad86pbGmFLUK9j4KLVLeNBSziVwovFdF5GppWCGBGZdX65zOATT1DYt4/YkiVE0um5XtKM8ctlKseOufDl1Vex9frZ60woRGz5cmK9vcR7egglk3O4UrkcNgioj4y4ypdqlXAq5Xpw9/YS7+wkoiBNREREROaRcDJJy6pVtKxaRb1Uonz6NCNHjlA+cYKRM2fwolEimYyrlNH7XBFpIuPVLWdbiVUq2CDAeB5eJIIXixFuaSHa23t+dcv47BZVt8gs0XeaiMyqWrHI4I4dlA4cINHTQ2iBzTux1lLP589WvVTPnAFrz17vJRJnW47Fli3D6AV/3rBBQL1UcuFLrUYklSLZ20uqt5dYZ6frqa0PpSIiIiIyz4VbWmhpaaFl9WpqxSLlU6cYOXyY8qlTVM6cwYvFiGazhJJJvf8VkVkxaXVLrQbG4IVCeLGYm8va1eWqW1paVN0iTUdnAEVk1lQGBhjYto2xkydJ9vXhRSJzvaRpYYOA6qlTlI8do3zkCH6xeN714fb2s+FLpKNDL/7ziA0C6sUi1VwOfJ9wOk2qv/9c5csCruYSEREREYmk00TSadJXXUU1n6dy6pSrlDl1ivKpU4Ticde+TNX9IjIN3rC6JR4n0tJCdOVKV6XXqGoJp1KEk0nN15WmpiBGRGbF6LFjDGzfTq1QINXfP+97DAfVKpVXX6V89CjlY8ew1eq5Kz2P2LJlruqlp4dwS8vcLVQum/V9asUi9UKBwPfdB8+1a0muWEG8s1P/niIiIiKyKEUzGaKZDC1r11LL512lzKFDlM+coXziBKFk0lXKJBJzvVQRaWI2CM5Vt4yHLfU6Fs6rbol1dxNta3PVLeOBS0sLoVhsrr8EkSlRECMiM8paS+mllxh84gms75NcuXLeVoTUi0UXvBw9SvXkyfNbjsVixHp6iK9cSWz58gVT7bNYBPU69WKRWqEAQUA4kyF99dUkli934UsqNddLFBERERFpCsYYotks0WyW9NVXUx0ePhvKVM6cwa9UCKdSRDKZBdeKWkQu3dnqlvFWYtWqO49izLnqlnT6vOqWs+3EVN0iC5CCGBGZMdb3ye3dy/BTTxFKJIh3dc31ki6LDQJqAwNnw5d6Lnfe9eFMxlW99PYSXbp03lf5LDZBvU4tn6feaCUXaW0lc/31JJYtI9bZSVg7+UREREREXpcxhlh7O7H2dlqvuYbq0BDlU6coHTpEZXCQYDyUyWa1i11kAZq0uqVWwxqDFw7jRaOuumX5cqLZ7LnqlsbsFj0vyGKiIEZEZoRfqTD85JPknnuOWHs7kUxmrpd0SYJajcrx45SPHqVy7BhBuXzuSmOIdnWdnfcSbm2du4XKlAS1GrVCgVqhgDGGSCZDZt06ko3wRW8CRURERESmxngesSVLiC1ZQut111EZHKR88qQLZc6cIajVCKdSRLNZvGh0rpcrIpchqNUIqtXzq1uCADwPLxp11S2trWer5carWlTdInKOghgRmXb1kREGd+2i+OKLxJcta/rBjf7IyNlZL5Xjx92biQYTiRDv6SHW20t8xQo8naifd4JajVo+78KXUIhoNkv7LbcQ7+4mtmSJwhcRERERkWlmPI/40qXEly4lc/31VAYGGDt5kpGDBymfOoWt1wmn00QyGbV1FmkS51W3lMsE1ep51S2hRuAS6+gg2tZGpKWF0IR2YvpsLfL6FMSIyLSqDg8zsH07o0ePkuztbdqdTkGlwsi+fZSPHKE2OHjedaGWFlf1snIl0a4utRybh/xKhVo+j18qYSIR17/6ttuId3cTX7Kkab8vRUREREQWGhMKEe/qIt7VReaGG6icOeNCmcOHGTtxAuv7RFpbXSgT1mkqkZkW1GrntRKbtLolkyHW1uZmPTXaiI0HLjpHIjI1eoUTkWkzduIEAzt2UBkYINnX17RvoscOHya/fTvB2NjZyyJLl55rOZbNYoyZwxXKVPjlspv5MjKCF4kQbWsjc911xLu6iC1Zop12IiIiIiJzzAuHSSxbRmLZMrI33kj5zBnKJ064UObYMQDCra1EWlub9vOkyHwwXt0y3krMr1TA9wEw49UtiQTxJUuIZLOqbhGZBXpVE5FpUTp4kMEdO/DLZVJ9fU25Q8IfGyO/YwflQ4cACLW2kl63jlhPDyENZp+X/LExqvk8/ugoXizmwpd160h0dhLt6NCHNxERERGRJuVFIiSXLye5fDmZG2+kcuYMo8ePM3rkiAtljHGVMq2tmi8hchGvW90SixGKxYhks7SMV7ckEqpuEZkjOkMlIlfEBgH5F15gaPduvHCYZG/vXC/pAtZaxg4cIL9zJ7ZaBWNoufFG0uvXY3Sift6pj466tmNjY4RiMaIdHbTcfDOxzk5i7e36kCYiIiIiMs+EYjGSPT0ke3rw16+nfOoUY8ePM3r0KKNHj7pQJpNxoYxOHMsiY4PgvLDFr1Swvo+xFhOJEIrFCCUSxJcuJdLWRiSVctUtiYSqW0SaiM5AisiUBbUauaefZvjpp4lkMkTb2uZ6SReol0rkH3+cyvHjAITb22nbsoVIR8ccr0wulbUWvxG+BOUyXiJBrKODVH8/8aVLiba368OYiIiIiMgCEYrFSK1cSWrlSvybb6Z86hSjx44x+uqrjB45AtZiwbWTthbG20pb6/7XOM7EZtMWwBh32cQ21Maca0s91csb/7/U27/u/V9z3ynf/mJrkKYW1GqulVi1+vrVLe3tRFpbXVXLeHVLIqHPxSJNTkGMiExJfWyMoV27KOzbR7yri3BLy1wv6TzWWkb37aOweze2XgfPI33zzbTceKPenMwD1lr8kRGqjfAlnEoR7+wk1ddHbOlSom1t+ncUEREREVngQvE4qb4+Un191EdHqZw+TVCtYq09dyNr3Z8bv85eN34Z7vOFDQJ3UrtxXRAE524zfj2u+sC+9rrx6yfethEIEQTuMcevbzzeax//7H1pBEMTruc1a57w1V38a5pw/WuPYydedvZm9mw4ZbkwqLrguvGga/yyCcHXa4/FJMebseDrMi+/WJB19rorDMomO87rBV8XVLeUy9ggwNCY3XKx6pZkknAyiReNXvTYItLcFMSIyGWrFQoMbN/OyKFDJFasIBSPz/WSzlPL5cg//jjV06cBiHZ2kt2yhXAmM8crk9djg4D6yIirfKlWCadSrmd0by/xzk4i2ax2comIiIiILFLhZJJwf/9cL+OS2dcEJJOGRZNcd16Y8trrJ7v9a2476fUTrpss2LngsS52+9f7WuYi+Hq9v4/XC75e+/Wd/w83s8GXMWerW6JtbUTb24mk06puEVkEFMSIyGUpnznDwLZtVE6dItnX11TD0G0QUNq7l+KePRAEmHCY1ttvJ3nNNTqB36RsEFAvlVz4UqsRSaVI9vaS6u0l1tnpekDr305EREREROaZ11ZQ6FPNzGqK4Gv89hOue22wYyIRVbeILFLNcwZVRJreyJEjDOzYQb1UItnf31Q7NKqDg+S2bqU+NARAbMUKMps2NV3LNGmEL8Ui1VwOfJ9wOk2qv/9c5Us6PddLFBERERERkXlEwZeINDsFMSLyhqy1FF98kcFduwBI9vY2TZWCrdcpPv00pb173e6SWIzMhg0kVq9umjUKWN+nVixSLxQIfJ9IOk167VqSK1YQ7+xUYCYiIiIiIiIiIguWghgReV1BvU7u2WcZ3rOHcCpFrKNjrpd0VuXUKXJbt+IXCgDE+/vJbNxIKJGY45UJuO+derFIrVCAICCcyZC++moSy5e78CWVmuslioiIiIiIiIiIzDgFMSJyUX6lwtDu3RSee47okiVEWlvnekkABNUqhSefZHTfPgC8RILMnXeS6Oub45VJUK9Ty+epF4sARFpbyVx/PYlly4h1dhJWSCYiIiIiIiIiIouMghgRmVStWGRw505KL79MYsWKpqkyKR87Rn7bNvyREQCSa9fSevvteLHYHK9s8QpqNWqFAvVCAYwhksmQWbeOZCN8CenfRkREREREREREFjEFMSJygcrgIAM7djB27BjJvj68SGSul4RfLlPYuZOxV14BINTSQnbzZmLLl8/xyhanoFajls9TKxYxnkc0m6XtlluId3cTW7JE4YuIiIiIiIiIiEiDghgROc/o8eMMbt9OdXiYVH8/JhSa0/VYaykfOkR+xw6CchmMIXX99aRvvrkpAqLFxK9UqOXz+KUSJhIhms2SXruWeHc38SVL8KLRuV6iiIiIiIiIiIhI01EQIyKACzxKr7zC0I4d+LUayb4+jDFzuiZ/dJT8tm2Ujx4FIJzNkt2yhejSpXO6rsXEr1So5XLUR0bwIhGibW1krruOeFcXsSVLFIaJiIiIiIiIiIi8AQUxIoINAvLPPcfQk0/iRaMke3rmdj3WMvrSSxR27cLWauB5tKxbR/qmm+a8Qmcx8Mtlqrkc/ugoXizmwpd160h0dhLt6MAL66VDRERERERERETkUulsmsgiF1SrDD31FPm9e4lks0Sz2TldT71QILdtG9UTJwCILFlCdssWIm1tc7quha4+Ourajo2NEYrFiHZ00HLzzcQ6O4m1tysAExERERERERERmSIFMSKLWH10lMFduyju30+8u5twKjVna7FBwMgLL1B88kms72NCIdK33krquuswnjdn61qorLX4jfAlKJfxEgliHR2k+vuJL11KtL1df+8iIiIiIiIiIiLTQEGMyCJVzeUY2LGD0cOHSfT0EIrF5mwtteFhclu3UhsYACDa3U1282bCra1ztqaFyFqLPzJCtRG+hJJJ4p2dpPr6iC1dSrStTeGLiIiIiIiIiIjINFMQI7IIlU+dYmDbNspnzpDs65uzmR/W9yk+8wylZ5+FIMBEIrTecQfJtWsxxszJmhYaGwTUR0Zc5Uu1SjiVIrl8OcneXuKdnUSyWf1di4iIiIiIiIiIzCAFMSKLzMihQwzs3Ik/MkKqv3/OKiCqZ86Q27qVei4HQLy3l8yddxKaw/ZoC4UNAuqlkgtfajUiqRTJ3l5Svb3EOjuJtLYqfBEREREREREREZklCmJEFglrLcX9+xnctQuMIbly5ZysI6jVKO7Zw8jzz4O1ePE4mY0biff3Kxy4AjYIqBeLVPN5qNcJp9Ok+vvPVb6k03O9RBERERERERERkUVJQYzIIhDU6+SefprhPXsIp9PEOjrmZB2VEyfIPf44frEIQGL1ajIbNuDF43OynvnO+j61YpF6oUDg+0TSadJXXUVyxQrinZ2EW1rmeokiIiIiIiIiIiKLnoIYkQXOr1QY2rWL/AsvEFu6dE4qI4JKhcITTzD60ksAhFIpMps2Ee/pmfW1zHdBvU69WKRWKEAQEM5kSF99NYnly134otZuIiIiIiIiIiIiTUVBjMgCVisWGdyxg9KBAyR6egjNQeXJ2JEj5LdtIxgbAyB57bW03norXjQ662uZr4J6nVo+T71RSRRpbSVz/fUkli0j1tlJOJGY4xWKiIiIiIiIiIjIxSiIEVmgKgMDDGzfztjx4yT7+vAikVl9fH9sjPyOHZQPHQIg1NpKdvNmYt3ds7qO+Sqo1agVCtQLBTCGSCZDZt06ko3wJRSLzfUSRURERERERERE5BIoiBFZgEaPHWNgxw5quRypVaswnjdrj22tZeyVV8jv3ImtVMAYWm68kfT69ZiwnnJeT1CrUcvnqRWLGM8jms3SdsstxLu7iS1ZovBFRERERERERERkHtJZUZEFxFpL6eWXGdy1i6BeJ9nXhzFm1h6/XiqR37aNyquvAhBubye7ZQvRjo5ZW8N841cq1PJ5/FIJEw4TbWsjvXYt8e5u4kuWqIWbiIiIiIiIiIjIPKcgRmSBsL5Pbu9ehp96Ci8eJ7lixew9trWM7t9P4YknsPU6eB7pm2+m5cYbZ7UaZ77wKxVquRz1kRG8SIRoWxuZ664j3tVFbMmSWW8jJyIiIiIiIiIiIjNHQYzIAuBXKgw/9RS5vXuJtbcTyWRm7bHr+Ty5rVupnj4NQKSzk+zmzUSy2Vlbw3zgl8tUczn80VG8WMyFL+vWkejsJNrRgae2bSIiIiIiIiIiIguSzvyJzHP1kREGd+2i+OKLxJctI5xMzsrj2iCgtHcvxT17IAgw4TCtt91G8tprZ7UdWjOrj466tmNjY4RiMaIdHaTWr3eVL+3tmFBorpcoIiIiIiIiIiIiM0xBjMg8Vh0eZmDHDkaOHCHZ0zNrw9xrg4Pktm6lNjQEQGz5cjKbNxNuaZmVx29W1lr8RvgSlMt4iQSxjg5S/f3Ely4l2t6uVm0iIiIiIiIiIiKLjIIYkXlq7ORJBrZvpzIwQKqvb1ZaW9l6neLTT1PauxesxUSjZDZsILFmzaKtgrHW4o+MUG2EL6FkknhnJ6m+PmJLlxJta1P4IiIiIiIiIiIisogpiBGZh0oHDzK4cyf+2Bipvr5ZOdFfOXWK/Nat1AsFAOJ9fWTuvJNQIjHjj91srLXUSyVX+VKtEk6lSC5bRnLlSuKdnUSy2UUbTImIiIiIiIiIiMj5FMSIzCM2CMi/8AJDu3fjhcMke3tn/DGDWo3C7t2M7tsHgJdIkLnzThJ9fTP+2M3EBsG58KVWI5JKkeztJdXbS6yzk0hrq8IXERERERERERERuUBT9sv5zGc+Q39/P/F4nI0bN7Jz586L3vbNb34zxpgLfr3zne88e5uf+ZmfueD6t7/97bPxpYhMm6BWY/jJJxnasYNwMkm8q2vGH7N87Bhn/vf/PhvCJNeupfPuuxdNCGODgFo+z8iRI4wePkxQqZDq76frLW9h+V130f2Wt5Beu5ZoJqMQRkRERERERERERCbVdBUxjzzyCB/+8If53Oc+x8aNG7n//vt529vexv79++ns7Lzg9l/96lepVqtn/zw4OMj69ev5iZ/4ifNu9/a3v52//Mu/PPvn2CwNNReZDn65zOCuXRT27SPe2Um4pWVGHy8ol8nv2sXYgQMAhFpayG7eTGz58hl93GZgfZ9asUi9UCCo14m0tpK+6iqSK1bMyt+9iIiIiIiIiIiILCxNF8R88pOf5Od+7uf4wAc+AMDnPvc5vvGNb/CFL3yB3/qt37rg9u3t7ef9+eGHHyaZTF4QxMRiMbq7u2du4SIzpFYoMLB9OyOHDpFYsYJQPD5jj2WtpXz4MPnt2wnKZQBS119P+pZb8CKRGXvcuRbU69SLRWqFAgQB4UyG9NVXk1i+3IUvqdRcL1FERERERERERETmqaYKYqrVKrt37+a3f/u3z17meR5vfetb2bZt2yUd44EHHuA973kPqdecOP3Od75DZ2cnbW1tvOUtb+E//+f/TEdHx6THqFQqVCqVs38uNIaTi8y28pkzDGzfTuXkSZIrV85oGOKPjpLfvp3ykSMAhLNZsps3E52kEm0hsEFArVCglssBEGltJXP99SSWLSPW2Uk4kZjbBYqIiIiIiIiIiMiC0FRBzMDAAL7v0/Wa2RddXV3sa8yoeD07d+5k7969PPDAA+dd/va3v51/9+/+HatWreLAgQP8zu/8Du94xzvYtm0boVDoguN84hOf4OMf//iVfTEiV2jkyBEGd+ygViqR7O/HeDMz0slay+hLL1HYtQtbq4ExtNx0E+mbbsJM8vMx3wX1OtXBQeqlEpFMhsyNN5JcvpxYZychtSwUERERERERERGRadZUQcyVeuCBB1i3bh0bNmw47/L3vOc9Z3+/bt06brrpJtasWcN3vvMdfvAHf/CC4/z2b/82H/7wh8/+uVAo0NvbO3MLF5nAWkvxxRcZ3LULrCXZ2ztjg+DrxSK5xx+neuIEAJGODrJbthB5Tcu/hcAfG6MyMID1fWIdHbTdcgvJnh4i6fRcL01EREREREREREQWsKYKYpYsWUIoFOLUqVPnXX7q1Kk3nO8yMjLCww8/zO///u+/4eOsXr2aJUuW8PLLL08axMRiMWLaGS9zwPo+uWefZeippwgnk8SWLJmZxwkCRl54geJTT2HrdQiFaL3lFlLXXz9jlTdzwVpLvVCgMjSEF42S7OmhZc0akitW4EWjc708ERERERERERERWQSaKoiJRqPcdtttPProo9x9990ABEHAo48+yq/8yq+87n2//OUvU6lUeN/73veGj3Ps2DEGBwdZtmzZdCxbZFr4lQpDu3eTf+45YkuWEGltnZHHqQ0Pk9u6ldrAAADR7m6ymzcTnqHHmwtBvU51aIh6sUiktZXsunW09PcTW7p0QQVNIiIiIiIiIiIi0vyaKogB+PCHP8x9993H7bffzoYNG7j//vsZGRnhAx/4AAD33nsvK1as4BOf+MR593vggQe4++676ejoOO/yUqnExz/+ce655x66u7s5cOAAH/3oR7nqqqt429veNmtfl8jrqZdKDOzcSenll4kvW0Y4mZz2x7C+T+nZZyk+8wwEASYSofX220leffWMtT6bbX65TGVggKBWI7ZkCdl160itXDljoZaIiIiIiIiIiIjIG2m6IObd7343Z86c4WMf+xgnT57k5ptv5lvf+hZdXV0AHDlyBO81O9r379/PY489xj/90z9dcLxQKMQzzzzDgw8+SC6XY/ny5fzwD/8w/8//8/+o/Zg0hcrgIAM7djB27BjJlSvxIpFpf4zqwAC5xx6jnssBEOvpIbtpE6FUatofa7ZZa6kXi1QHBzHhMIlly0hffTWJ5csJ6WdcRERERERERERE5pix1tq5XkSzKxQKZDIZ8vk8rdpZL9No7PhxBrZvpzo0RHLlSkwoNK3HD+p1ik89xcjzz4O1eLEYmY0bia9aNe+rYKzvUx0eppbPE2lpIdnXR8vq1cS7utR+TERERERERERERGbU5eQGTVcRI7JYFA8cYGjnTvxqlWRf37SHB5UTJ8g9/jh+sQhAYvVqWjdsIBSPT+vjzDa/UqE6OEhQLhPt6KBj0yZSvb1Es9m5XpqIiIiIiIiIiIjIBRTEiMwyGwTkn3uOoaeewotESPb0TOvxg2qVwhNPMPriiwB4ySTZTZuI9/ZO6+PMtlqxSHVoCGMM8e5u0mvXkuzpmffBkoiIiIiIiIiIiCxsCmJEZlFQqzH01FPkn32WSDY77VUc5aNHyW3bRjA6CkDymmtove02vGh0Wh9nttggONt+LJxMkl67lpY1a0h0dU17GzcRERERERERERGRmaAgRmSW1EdHGXriCQr79hHv7iacSk3bsf2xMQo7dzJ28CAAoXSa7JYtxLq7p+0xZlNQrVIZHMQfHSXa1kbHHXeQXLmSWHv7XC9NRERERERERERE5LIoiBGZBdV8noHt2xk9fJhETw+hWGxajmutZeyVVyjs3ElQqYAxtNxwA+mbb8aE59+Pd31khOrgINZa4l1dtG7YQKK3l3AiMddLExEREREREREREZmS+XemVmSeKZ8+zcDjj1M+c4ZkXx/eNAUk/sgIuW3bqBw7BkC4rY3sli1ElyyZluPPFhsE1PJ5qsPDhBIJUqtXk16zhnh397T9XYmIiIiIiIiIiIjMFZ3lFJlBI4cPM7BjB/7ICKn+foznXfExrbWM7t9PYfdubK0Gnkd6/Xpa1q2bluPPlqBWO9t+LJLN0n7bbaRWriTa0YExZq6XJyIiIiIiIiIiIjItFMSIzABrLcX9+xl84gkAEr290xIu1PN5co8/TvXUKQAiS5eS3bKFSDZ7xceeLfXRUaqDgxAERJcupeP220n29EzrzBwRERERERERERGRZqEgRmSaBfU6uWeeYXjPHsItLcQ6Oq74mDYIKD33HMU9e8D3MeEw6dtuI3XNNfOiCsYGAbVCgdrwMF40SrKvj/SaNSSWLcOLROZ6eSIiIiIiIiIiIiIzRkGMyDTyKxWGdu2i8MILRJcuJZJOX/Exa0ND5LZupTY4CEBs+XIymzYRnoZjz7SgXqc6OEi9WCSSzZK56SZaVq0itmSJ2o+JiIiIiIiIiIjIoqAgRmSa1IpFBnfsoPTKKySWLyeUSFzR8Wy9TvGZZyg9+yxYi4lGydxxB4mrrmr6EMMfG6MyMID1fWIdHbTdcgvJnp5pCaZERERERERERERE5hMFMSLToDIwwMCOHYy9+irJlSuvuN1W9fRpclu3Us/nAYj39ZHZuJFQMjkdy50R1lrqhQKVoSHXfqynh5Y1a0iuWIEXjc718kRERERERERERETmhIIYkSs0+uqrDGzfTi2XI9XfjwmFpnysoFaj+OSTjLzwAgBePE7mzjtJ9PdP02qnX1CvUx0epl4oEGltJbtuHS39/cSWLp0X82tEREREREREREREZpKCGJEpstZSOnCAwZ07Cep1kn19V9QyrPzqq+Qffxx/ZASAxFVXkbnjDrxYbLqWPK38cpnKwABBrUZsyRKyN95IauVKIq2tc700ERERERERERERkaahIEZkCqzvk3v+eYZ378aLx0muWDHlYwWVCvmdOxk7cACAUEsLmU2biF/BMWeKtZZ6sUh1aAgTCpFYtoz02rUkVqwg1KSBkYiIiIiIiIiIiMhcUhAjcpmCapWhJ58k/9xzRNvaiGQyUz7W2KFD5LdvJyiXAUhddx3pW2+94hkz0836PtXhYWqFAuFUitZrr6Vl9WriXV1qPyYiIiIiIiIiIiLyOhTEiFyG+ugogzt3UnzxReLLlhFOJqd0HH90lPyOHZQPHwYgnMmQ3bKFaGfndC73ivmVCtXBQfxKhVh7Ox133kmqt5doNjvXSxMRERERERERERGZFxTEiFyiai7HwPbtjB49SqKnZ0qtuKy1jL38Mvldu7DVKhhDy7p1pNevx4RCM7DqqamNtx8zhnh3N+m1a0n29BCKx+d6aSIiIiIiIiIiIiLzioIYkUswdvIkg9u3Uz5zhuTKlXjhy//RqReL5B5/nOqJEwBEOjrIbtlCpL19upc7JTYIXPuxfJ5wMkl67Vpa1qwh0dXVVCGRiIiIiIiIiIiIyHyiIEbkDZQOHmRw5078sTFS/f2XPRPFBgEj+/ZRfPJJbL0OoRCtt9xC6vrrm2K+SlCrURkYwB8bI5rN0nHHHSRXriTWJAGRiIiIiIiIiIiIyHymIEbkImwQUNi3j6EnnsCEwyR7ey/7GLVcjtzWrdTOnAEg2tVFdssWwq2t073cy1YfGaE6OIi1lnhXF60bNpDo6Zny3BsRERERERERERERuZCCGJFJBLUauWeeIff004RbW4m2tV3W/a3vU9q7l+LTT0MQYCIRWm+/neTVV2OMmaFVX8K6goBaPk91eJhQIkFq1SrSa9YQX7ZsSu3WREREREREREREROT16cyryGv45TKDu3ZR2LePeGcn4ZaWy7p/dWCA3Nat1IeHAYj19JDdtIlQKjUTy70kQa1GdWiIeqlEpK2N9ltvJdXXR7SjY06DIREREREREREREZGFTkGMyAS1YpGB7dsZOXiQxIoVhOLxS75vUK9T3LOHkeeeA2vxYjFaN24ksWrVnIUd9dFRqoODEAREly6l/bbbSPb0EJ7DUEhERERERERERERkMVEQI9JQGRjgzLZtlE+eJLlyJV4kcun3PXGC3OOP4xeLACRWraJ148bLCnKmi7XWtR8bGiIUi5FcuZL0mjUkli+/rK9JRERERERERERERK6cghgRYPToUQZ27KBWKJDq78d43iXdL6hWKTzxBKMvvgiAl0yS3bSJeG/vTC538rXU6679WKFAJJslu349LatWEVuyRO3HREREREREREREROaIghhZ1Ky1lF56icFdu7BBQHLlyksOLcpHj5Lbto1gdBSA5NVX03r77XjR6Ewu+QL+2BiVgQFsvU5syRLabr6ZZE8PkXR6VtchIiIiIiLNzQ8sxdq5P3sGjAEPMLjfn/3zhP+767S5S0RERGSqFMTIomV9n9yzzzK8Zw+hRIL4kiWXdD+/XKawYwdjBw8CEEqnyW7eTGzZsplc7nmstdQLBSpDQ3jRKMmeHlrWrCG5YsWsB0EiIiIiItLcynVLrmIZqFhGa2Bx4QqNkAVc6II59/+zwUzjtp6Z8AsIeeBhCHnu+pBxYc34bcfv60041sRg57zLL7iNQh8RERFZWBTEyKLkVyoMP/kkub17iS1ZQqS19Q3vY61l7OBBCjt2EFQqYAypG24gffPNeOHZ+VEK6nWqw8Ou/Vg6TfbGG0n19xPv7LzkdmoiIiIiIrLwBdZSqsFQ2TJctVR8iIUgEwOvEXRYa7G4YMbac//nNZcFgB+85nYT7s/Z+9mzAc/4cQzngp/xfMXwmqDHnB/6XBD8GAgZM+H37muYeAxv4v8nCX88Jr9c1T4iIiIyGxTEyKJTL5UY2LmT0ssvE1+2jHAy+Yb38UdGyG3bRuXYMQDCbW1kt2wheolVNFfKr1Rc+7FqleiSJWRvuIFUX98lBUgiIiIiIrJ4VH1LoQoD5YBiDQILyTCkYhcGDuMVLO4PM7su20hmLgxzLgx9rJ0sGLLnXWY4d7zx5Z+t9GlcMDHYGQ9dmBDYjN/v/MDHhTznqn7A88BwfrXPxYKdCy6/oAJIoY+IiMhipCBGFpXK0BAD27cz9uqrJHt737CNl7WW0RdfpPDEE9haDTyP9Pr1tNx4IyYUmtG1Wmupl0pUBwcxoRDxZctoXbuWxIoVhGKxGX1sERERERGZP6y1jNYhV7EMVixjdQh70BKBsNccJ/7HAwhz9j8z62y1z2ShD+4/F6/2sRcEQePVPhODn8Zhzqv2Ge9TcF6Vz2tCofGAZzyoGa/2CZnzW7xN2s7tUlq+nf19c/zbi4iIiIIYWUTGjh9nYPt2qkNDpPr63jBIqRcK5LZupXrqFACRpUvJbtlCJJud0XVa36c6PEytUCCcStF67bW0rFpFvLtb7cdEREREROQsP7AUajBYDshXoG4hHoa2SapfFpuz1T6zGPq4379xtU/Nf021z4QWceP/GQ94Jvv/xGqe17Z4Y8L1HhMqeCZU+4RwVT4Tq30urNx5ncBnsvAHfc+JiIi8HgUxsiiUXnmFwZ07CSoVkn19rxto2CBg5PnnKTz1FPg+JhwmfeutpK69dkaDEL9SoTo4iF+pEG1ro2PjRlIrVxKd4eBHRERERETml3LdkqtYBiqW0Zo7IZ4MQzSkE+FzYTZbvMEbV/uMBzw+UL+Eap83avN2XrWPOff/11b7nG3x1vh9aELI83rVPhcLfya9vFFBJCIiMt8oiJEFzQYB+eefZ+jJJ/EiERI9Pa97+9rQELmtW6kNDgIQXbaM7ObNhNPpGVtjvVSiMjgIxpDo7ia9di3Jnh5C8fiMPaaIiIiIiMwvgbWUajBctgxVLRUfYiHIxNSCarGZi2qfie3cLlbt89oWb6+9//hsn4nVPRO/jDeq9hn/fSoMbTGPlojCRxERmT8UxMiCFdRqDO/ZQ+6ZZ4hkMkTb2i56W+v7FJ9+mtKzz4K1mGiUzB13kLjqqhkpr7ZB4NqP5fOEk0nSa9fSsno1ie7uGZ89IyIiIiIi80ctsOQrMFAOKNYgsK76JaX2YzILmrHaZ6jx8xAPQzZqyERNU81DEhERmYyCGFmQ6mNjDO3aRWHfPuLd3YRTqYvetnr6NLmtW6nn8wDEV64kc+edhJLJaV9XUKtRGRjAHxsjms3SfvvtpFauJNbRMe2PJSIiIiIi85O1ltE65CqWwYplrA5hD51slgXvUqp9EmH3M1L24dSo5dSoJRGG9pgh3QhlVCUmIjI9xt+TFKqWeNjQFtPz61QpiJEFp5rPM7B9O6NHjpDo6SEUi016u6BWo/jkk4y88AIAXjxO5s47SfT3T/ua6iMjVAcHsUFAvLub1g0bSPT0EJ6BsEdEREREROYnP7AUajBYDshXoG4hHoY2Vb+InMcYQyLsQpnAurDy1RGLGbWN1mWG1qghGdbPjojI5bKN59ViDYYqAaM1KPvQ04KCmCugIEYWlPLp0wxs20b59GmSK1fihSf/Fi8fP07+8cfxSyUAEmvWkNmwAe8ioc1U2CCgls9THR4mlEiQWrWK9Jo1xJctu+i6RERERERk8SnXLfkqnCm7kx3GuPZjmn8h8sY8Y0hFIBWBemAZ8+FIyRI2llQU2mMe6Qgkwvp5EhG5mPFKw/HwZaQK9QAiIUhE3CwwuTI6GywLxsjhwwzs3IlfKpHq78d43gW3CSoV8rt2MfbyywCEUikymzcTX7Fi2tYR1GpUh4aol0pEslnab72VVF8f0Y4O7cQRERERERHA7eIv1WC4YhmqWCo+xEKQiamtkshUhT1D2gMibr7SSA1ylYCYB+kotDVCGYWcIiJOuW4p1mC4ElCqQTWAiOfCl8h57VDtnK1xoVAQI/OetZbiiy8yuGsXAIne3kkDj7HDh8lv304wNgZA6rrrSN96K14kMi3rqI+OuvZjvk+ss5P2W28l2dNDuKVlWo4vIiIiIiLzXy2w5BvDxos1N3w8EYaU2o+JTKuIZ4hE3TmDagDDFdf2LxaCbNSQiRnSmrskIotQ2XebQXKN9yKVwM2iS4TcPDq9H5kZCmJkXgvqdXLPPMPwnj2EW1omHXrvj46S37GD8uHDAIQzGTKbNxPr6rrix7fWuvZjQ0OEYjGSvb2kr7qKxPLl0xbwiIiIiIjI/DY+6DZXsQxWXN/1sOdOdugksMjMMsYQC7mKM2td9dnpsuX0mG3MYHLzZFoiENLJRxFZoCrj4UsloFCDig9h42bRpRS+zAoFMTJv+ZUKQ7t2UXjhBaJLlxJJp8+73lrL2Msvk9+1C1utgjG0rFtH+qabMFc4oyWo1137sWKRSCZDdv16Wvr7iS1dqicuEREREREBwA8shZrbhZ9v9Fp3J351wkNkLhhjiIfdz2HQmIdwYsRyctSSCEN7I5RJhfUzKiLzX7URvuSrlnzVBdHeePii57lZpyBG5qVascjgjh2UDhwgsWIFoUTivOvrxSL5bduoHD8OQKSjg+zmzUQmqZi5HH65TOXMGdd+rKODtvXrSfb2XhACiYiIiIjI4lWuW/JVOFMOGK2BMZAMQzSqEx4izcIzhmTY/Wz6gWXMh6MlS9hYUhE3T6Y1CvGQTlaKyPxRDxrhS8WSq1kqdfc+JB7SRpC5piBG5p3K4CAD27czdvw4yb6+81qA2SBgZP9+irt3Y+t18DzSt9xCyw03YDxvSo9nraVeKFAZGsKLREj29NCyZg3JFSvwotHp+rJERERERGQes3Z82K1lqOJ2ncZCkIm5E74i0rxCnqHFAyJujtNIHXLVgKgH6UYok45CLKSfZRFpPuPhS6FqyVUt5bq7PB6GrMKXpqEgRuaV0VdfZWD7dmq5HKm+PkwodPa6Wi5H7vHHqZ0+DUC0q4vs5s2EM5kpPVZQr1MdHqZeKBBJp8neeCOp/n7inZ1TDnVERERERGRhqQWWfAUGKgHFKlgLiTCkdOJDZF6KeIZIY89l1bfkazBUCYiFoDXqQpmWiLudiMhc8e2E8KUxf87iwhdtAmlOCmJkXrDWUjpwgMGdOwlqNZJ9fWc/1NggoPTssxSffhqCABMO03r77SSvuWZKH3z8SoXKwAC2WiXa0UF20yaSK1cSnWKgIyIiIiIiC4u1ltE65CqWwcbJj7AHLREI6+SsyIIRDRmiIfczX/FhsAwDY4HbZR41ZGKGlgiEdMJTRGZB0AhfilVXfVv23QaQmMKXeUFBjDQ9GwTknnuO4d278eJxkj09Z6+rDgyQ27qV+vAwALEVK8hs2kS4peWyH6dWLFIdHMSEQsSXLaN17Vo3fyYWm7avRURERERE5i/fWgpVGCwH5KtQD9zOU/VcF1nYjDHEw+7nPbDu5OfJUcupMUsiDO0xQzpqSIV1IlREpldgXbvE8fBlrO7Cl2gI0lEFwfOJghhpakG1ytBTT5F/9lkibW1Es1kAbL1Occ8eSs89B9bixWK0bthAYvXqy/oAZIOA6tAQtUKBcCpF6zXX0LJ6NfHubrUfExERmSG+tVQbsxN0skJE5oNy3ZKvwplywGjNDb1NhiEa1XOYyGLjGUMy7J4DfOtmMRwtWULGkopAe8wjHXEtChXQishU2Anhy3DFVeH64+FLxM21kvlHQYw0rfroKIM7d1J88UXi3d2EUykAKidPknv8cfxCAYDEqlW0bthAKJG45GP7lQrVwUH8SoVoWxsdGzaQ6us7G/SIiIjI9KoFlpEaFGuuh3EtgHgIMlFDS2MHqdr5iEgzsdZSrMFwxe1ArfjuBEhrTLtPRcQJGUMqAqmIG5Y9VodDlYBw42RpWyOUiYf1nCEir89a9xxSbMylGq1B3UIk5J5j9Flp/lMQI02pmssxsGMHo0eOkOjpIRSLEVSrFHbvZnT/fgC8ZJLsnXcSX7nyko9bL5WoDA6CMSS6u0mvXUuyp4dQPD5TX4qIiMiiVa67nVyFqqVQs1QaAyRjIferEsCxEYsZtcRDkI4YWhuhTCykXaQiMjdqgat+GSgHFKuu/UciDCm1HxOR1xH2DOmo+33VHw9yAxfgNkKZloibOyMiAi58KfvnwpeRRtvTSAgSEYgofFlQFMRI0xk7eZLB7dspDwyQXLkSLxymfPQouW3bCEZHAUhefTWtt9+OF42+4fFsEFAdHqaWzxNOJkmvXUvL6tUkursxodBMfzkiIiKLxvgurlIdcpWAkRpUA/CMC1ZeO0AyGgIiru9xxYczZcvpMUvUg2QEslGPVMS1/lALMxGZSda6th+5imWw0X897EGLdqCKyBREQ4ZoyD23VAMYqrhwNx6GbNS4imA9v4gsWuX6ubC21PjMFPEUvix0CmKkqZQOHmRw5078sTFSfX0E1SrDjz/O2CuvABBKp8lu3kxs2bI3PFZQq1EZGMAfGyOazdJ+++2kVq4k1tEx01+GiIjIouFby2gNSjVLrup+X7Pug0SsUUb/RjvIPWNIhN2Oc2td27JSzYU5nnGXZ6OGlojrya6dpCIyXXxrKVRhqByQq0ItcM85bap+EZFpYIw5Wwk8vvP91Kjl1KglEYb2mCHdCGW06URkYSv7llINhssufKk0wpd4CNKaObcoKIiRpmCDgMK+fQw98QSEQiR6eigfPEh+xw6CSgWMIXX99aRvuQUv/PrftvWREaqDg9ggIN7dTfqOO0j29hJOJmfpqxEREVnYXjvvpexDYM/t4mq9gl1cxrgdpNFG0Wo9cNUyr45YDNYNqIxCJuKqZeJqYSYiU1D2LfnGDvWRGhjjqu9adSJERGaImbDxJGhUEb/aaNGaCkNbzLVoTYb13kZkoag0wpdcJaBQg4oPYQPx8KVtWJOFRUGMzLmgViP3zDMM79lDuLWVcCzG0Le/TeXoUQDC2SzZLVuILl160WPYIKCWz1MdHiaUSJBatYr0mjXEly17w+BGRERE3ljZd+HLZPNe0hEIzVAJfdgzhD33QSWwlqoPQ2UYGAtc8POaapmZWoeIzH/WjrcBsQw3QuRoCFpjbuC2iMhs8YwhFXHvb+qBZcyHIyVL2FhSUWiPeaQjkAjruUlkvqk2wpd81ZKvus8vplHln1LQuqjpDLXMKb9cZnDXLgr79xPt6KB24gRDTzyBrdXA80jfdBMt69ZddJZLUKtRHRqiXioRyWZpv/VWUn19RDs69MQmIiJyBSbOe8lXAkp1qPoXn/cyGzxjiIfdDrLxFmZjdRcOecYSD7nd7OO7SWNqYSYiuCq+fNVVvxSrYC2NlkA6GSIicy/sGdIeEDlXdZyrBMQ8VwXc1ghl1JpVpHnVAhe+FCqWXGPTmjGuej+r9xvSoCBG5kytWGRwxw5KBw4QyWQoPP441ZMnAYgsWUJ2yxYibW2T3rc+Ouraj/k+saVLab/1VpI9PYRbWmbzSxAREVlQLjbvJdzoXdxMO7he28LMDyyV4Fzf9WhjvZmYRyqM2nyILDLWWkbrkKtYBisuWA57aDi2iDS1iGeIRN1zWDWA4QoMlgNiIVcBnIkZ0noeE2kK9fHwpeo+O5XrgMIXeR0KYmROVAYGGNi2jdETJ2BkhMFt28D3MeEw6VtuIXXddRjPO+8+1lrXfmxoiFAsRrK3l/RVV5FYvhwvEpmjr0RERGR+G995OR6+jNWnb97LbAp5hqTnApfxkxf5GgxWAiKNVgDZmCEVMaTCOoEhslD51lKsuhOXuSrUAvfz36YTIiIyjxhjiIVcFbK1bl7e6bLl9JglPmGeTEtErRVFZpMfWEqNivxcY6OHxVXsz0XHAJlfphTE7Nixg40bN073WmSRGD12jIHt2ykfP07llVeoDQ4CEF22jOzmzYTT6fNuH9Trrv1YsUgkkyF70020rFpFbOlSfZgSERGZgspr5r2U6+7y6AzPe5ktE09egAubKj4cLVnMeAuziCEddaFMLKQTtCLzXdm35Bs7x0dqgHHBbGtUP9siMr+ZCa1ZA+vmW50YsZwctY02iy6UaabKZZGFJLCu8qVYtQw1ZsxZCzGFL3KZphTEbNq0iauuuor3v//9vPe972X16tXTvS5ZgKy1lF56iYEdOxh7+WXKBw+CtZhIhNY77iC5du15bxr8cpnKwAC2XifW0UHb+vUke3uJvCaoERERkddnrRsCO95zvBnmvcymiGeINHqvB41dpWfKllNjlqjnBuVmoh6piDtxu5D/LkQWEmstxRoMVyzDjRMj0RCkY9ohLiILk2fcHLxk2O3MH2tsNAkbSyri5sm0Rl1rJIUyIlMXWMtI/Vz4Mt41IBZys5v0PkOmwlhr7eXe6Ytf/CIPPfQQ//zP/4zv+9x55528//3v5yd/8idpb2+fiXXOqUKhQCaTIZ/P09raOtfLmZes75N79lnOfPe7jO3bh18qARDv7SWzaROhZNLdzlrqxSKVwUG8SITk8uW0NNqPhWKxufwSRERE5pXxDw/j4ctI3bXoGZ/3EvX0AX28hVnFh3oAIeN2m2ajhpaIIRVxIY6INJdaYMlXYaAcUKy6XakJVbeJyCJWC9yJ4lrg3uOlG6FMOgqxkJ4XRS6FnRC+DFfc7wPrNnkkQvO/a8CVylUsnQlDX9p74xsvIpeTG0wpiBk3MDDAww8/zBe/+EW2b99ONBrl7W9/O+973/v40R/9UaLR6FQP3VQUxFwZv1JhcMcOTn/zm1RffRUALx4nc+edxPv6MMZgfZ/KePuxlhZS/f2kVq0i3tl5wawYERERmdz4wMjJ5r3EwwoV3kg9cDvqa777cyzsTmS0Rj1SYe0uFZlL1rrntOGK25k6WnfBclIzn0REzlP1XaWMH7iAujXqQpkWbTARuYC17j1FqQZDlYDRGtQtRBrhi95jnKMgZnKzFsRMdODAgbOVMi+99BKZTIYf//Ef59577+VNb3rTdDzEnFEQM3X1kRFe/drXGPrud7HlMgCJNWvI3HEHXjyOX6m49mPVKtH2dtJr15JcuZJoJjPHKxcREZkfxue9FKuW/GvmvcT04WHKxluYVfxzYVYyDNmYC2WSGo4rMit8aylW3eyXfBWqgQtFk5qFICLyumzjvcz4PIvxqt9MzNCi9zGyiNnGrKViI3wZqbrq+EhIm9dej4KYyV1ObjClGTGTSSQSJJNJ4vE41lqMMXz961/ngQce4NZbb+XBBx/k+uuvn66Hk3lg9NgxDv/5nzP2yisAhFIpMps2Ee/poVYsMnbyJCYUIr5sGemrriLZ06P2YyIiIm9g/INDqQb5xryXyiKa9zJbPGNIhF27I2sttQBG65CvBnjGnQjOxhotzMIQVdsPkWlV9i35igtgRmqAceFLOqqfNRGRS2GMIR52J5aDxvvHk6NuRl4iDO0xQzrq3sfovaMsBuX6+Gy5gFLNbe6IeJBQtZjMkiuqiCkWi3zlK1/hoYce4rvf/S6e5/GOd7yDe++9l7vuugvP8/ja177GRz7yEbq7u9mxY8d0rn3WqCLm8p3653/mxJe+RNCogkldey0tt9xCvVikVigQTqVIrVxJy+rVxLu71X5MRETkdQQTSuZzlYDRuvvgEDaufVZM815mld9oYVZttDCLhqAlDJlGtUxCO/VFpsTa8RMkrjd72Xc/X8mwdm6LiEwX37oK6orv5uOlItAe80hH9B5GFp6ybylVz4UvlUb4Eg9pI9XlUkXM5Ga8IubrX/86Dz30EH//939PuVzmjjvu4P777+c973kPHR0d5932x3/8xxkeHuaDH/zgVB5K5plaPs/Bz36W0nPPARBqbaV1wwbwPMaOHyfa1kbHhg2kVq4k2tY2x6sVERFpXvXADYgsVS3DVfeB2bduJkI8BC0RfVCeKyHPkPLciQtrLZUAcjUYrASEjWtblom6ahnNrxB5Y7XAUqjCQDmgUHUtdNxubT3PiYhMt5AxpCLufUw9cPO3DlUCwiE3G6+tEcrEw3r+lfmp4tuzG9gKNRc6ho2rDkvpM5TMoSkFMe9617vo7e3l13/917n33nu55pprXvf269ev573vfe8lH/8zn/kMf/iHf8jJkydZv349f/Inf8KGDRsmve2b3/xmvvvd715w+Y/8yI/wjW98A3AfkH/v936PP//zPyeXy7FlyxY++9nPsnbt2ktek7w+ay2D3/sex/7H/3BVMMaQvPpqwl1dBEFAfOlSWteuJdHTQziRmOvlioiINKWz815qlnzVnu3pHQ25Dw06od98jDHEQy4cA3dCecyHQsniGevaxUVc649kBOLaeScCuM8PY3XIVS2DZVf1F/JcyKznOhGR2RH2DOmo+33VP9e2KRqC1kYo0xJR5YA0v+p4+FJ1mzrGWzcnwpBSpZc0iSkFMd/+9rd585vffMm337Bhw0WDlNd65JFH+PCHP8znPvc5Nm7cyP3338/b3vY29u/fT2dn5wW3/+pXv0q1Wj3758HBQdavX89P/MRPnL3sD/7gD/j0pz/Ngw8+yKpVq/jd3/1d3va2t/H8888Tj8cv+euQyVUGBjjywAMU9+4FwEulSFx9NdHOTtd+bM0aEt3dmFBojlcqIiLSXCbOeylUA4qNHVtmfN5LVD2755uIZ4h4QORcP/bTZcvJMesCtTBkoh6piGu3pH9fWWx8aylW3eyXfBVqgXu+y2q+lYjInIqGDNGQe39aDWCo4ioV42HIRk2j2ldhuTSPWmAbczMt+ZrrIDA+y7FNVbXShK5oRsxM2LhxI3fccQd/+qd/CkAQBPT29vKhD32I3/qt33rD+99///187GMf48SJE6RSKay1LF++nI985CP8xm/8BgD5fJ6uri7+6q/+ive85z1veEzNiJncaCVg65ceZel3HyGoVMAYor29pG+6ifTVV5NauZLYa1rViYiILHbj815GGjsOR+vuROT4h4ZYSB8aFqLxkxoVH+qB68keD0Nb1JCKuBYhGhIqC1nFt+QqLoAZqQHGhZHaZS0i0rzGNw2V6+7Prm2kq/RtiShAl9lXHw9fqo0OAnWg8Tkqrs9RM0ozYiY34zNi/u//+//m7//+79mzZ8+k199yyy3cfffd/N7v/d5lHbdarbJ7925++7d/++xlnufx1re+lW3btl3SMR544AHe8573kEqlADh48CAnT57krW9969nbZDIZNm7cyLZt2yYNYiqVCpVK5eyfC4XCZX0di8V3/suf0n1wFwHgZzro3LyBtttuI9nbSziZnOvliYiINI2J815yVdeOR/NeFhdjDLFG0Abue6Lsw6sjFrDEwtAaMbRG3VwZfZCUhcBad7JkqGIZrrjv+WgI0jE3o0BERJqbMYZE2AUwQaOl5KsjFjNqSYWhLXbuvYvet8hM8QNLqQ6FqiVXcd+HALEwZFRRK/PIlIKYr3zlK7zrXe+66PU/8iM/wiOPPHLZQczAwAC+79PV1XXe5V1dXezbt+8N779z50727t3LAw88cPaykydPnj3Ga485ft1rfeITn+DjH//4Za19MSrfeCdjh5/lr3vezXe63swvrzL84hqPsAa6iYiIUPVd+FJo7Naq+BBo3os0hD1Dy4QWZhUfBsqWU2OWqOcqBbKxcy3MdNJa5pNaYClUXUubQtXNuoqHoV1tQkRE5i3PuAreVMRtKBnz4UjJEjaWVBTaYx7pCCR0TkimgW8bszOrlqHKudmZCl9kPptSEHPkyBHWrFlz0etXrVrF4cOHp7yoqXrggQdYt27dJc+juZjf/u3f5sMf/vDZPxcKBXp7e690eQvOu37iDg5uuoaB7a2Ujxs+uRP+7oDlY/9HwG3d2hEhIiKLy3jrhpEa5BvzXqq+uy4WhlbNe5GL8CbsNrXWUgtgpO6+j8Zb1mVjhnTEqJWTNC3b2Cmdq1oGy64FY8hD8wRERBagsGdINzaU1AJ3wjxXCYh5kI5CWyOU0XsWuRyBdRvZxsOXsbrbyBYLue8rbUyS+W5KQUxLS8vrBi0HDx4kHo9f9nGXLFlCKBTi1KlT511+6tQpuru7X/e+IyMjPPzww/z+7//+eZeP3+/UqVMsW7bsvGPefPPNkx4rFosRi8Uue/2LjTGG1b0ZvrzC8hd7Aj613fDSoOFnvgb33GD5mZst3Sm9+IqIyMJ13ryXasBo7fx5L1nt/pbLZIwblBtttDDzGy3Mjo+3MAtBOgKtUVctk1ALM5ljvrUUq272S77qngNjjec/hc8iIgtfxDNEoufm4Q1XYKgcEA1BNmrIxoxCebkoOyF8Ga643493EUhHIKTvG1lApjRd581vfjOf//znefXVVy+47ujRo/zZn/0ZP/ADP3DZx41Go9x22208+uijZy8LgoBHH32UTZs2ve59v/zlL1OpVHjf+9533uWrVq2iu7v7vGMWCgV27NjxhseUS+N5hp+7xfC/fhI29Fh8a/jSXo+f/zuPbx4IeCEXcLQUUKhaAmvnerkiIiJXpB64VmPHRwL2Dbtfh4pu+HQsBG0xV70QDxudIJcrFvIMqYihPW5oi0HIuBMcBwoBLwwH7MsFHB9x77Pqgd5nyeyp+JZTo5b9wwEv5gKGKu45sD3uvmcVwoiILC5uHp4LXlwYD6fLlhdzAc8Pnzsv5Ou80KJnrWWk5t5H7MsF7B8OOFKylANXSdseN7REjEIYWXCMtZf/DLh//342bNiAMYaf/dmf5YYbbgBg7969fOELX8Bay/bt27nuuusue0GPPPII9913H5///OfZsGED999/P1/60pfYt28fXV1d3HvvvaxYsYJPfOIT593v+77v+1ixYgUPP/zwBcf8r//1v/L//X//Hw8++CCrVq3id3/3d3nmmWd4/vnnL6lyp1AokMlkyOfztLa2XvbXtJgMjlkefiHg87s88mWDwfKj11p+/EZLItJ4Qo15ZKIQV99QERGZJyab92ItREKu8kU7/GQu1BrVMjXfneyIhSATdS3MUhGIqSJZppm1llINhipu12rZx800iqhdiIiITC5otO+t1MEY14q1PWZojRpSamm/aFjr5gqVaq5iaqQG9cB9nkqE9XlqPshVLJ0JQ196SnUdC9bl5AZTak12zTXX8L3vfY8PfehDfOpTnzrvuu///u/n05/+9JRCGIB3v/vdnDlzho997GOcPHmSm2++mW9961t0dXUBbj6N553/D75//34ee+wx/umf/mnSY370ox9lZGSEn//5nyeXy/GmN72Jb33rW1NqnyavryNheN+NHjd1B/z5LsN3D3l8fZ9hxzHLr20KuHYpHKy6vqGZ2Lm+oXrCFRGRZmIbw9NLjTkdxSpUfDC4eS/qUSzNIOIZIo3+7H7je/bUmOXkqCUaglQYsjGPVGP+jCoUZKpqgaUwof2YtRAPQ7vaL4qIyBvwjJtxlwy7lqtjPhwtWcLGkoq480KtUbe5Sa8pC8v4DM1SDYYrAaUaVAOIeJCIuPeyIovJlCpiJhoYGOCVV14BYPXq1SxZsmRaFtZMVBFz+Uo1y6FiwNYj8BdPeJwecU+u71hr+fnbA6JhGKu7D3GJMHTEDZmoe3HWC6+IiMyFoDFoulRz4ctIDSqBawUVD7lqA71GyXww3qO94rt5HZHG7tNM1NDS2H2qTTDyRmzjOTFXtQyW3TyskIe+f0REZFrUAvc6UwtcdWU6Am1xt1lXVb3zW9m3lKrnwpdKI3yJhzRDej5TRczkLic3uOIgZjFQEDM1o3XL4WLAqRH46nOGv91nsBg6EpZfvdOype/cSa+KD2Hjdhi3xz1aI3pyFhGRmecHruVYqWbJVdxrUt1CuPFBIeIpfJH5r95oYVadUNXVGjnXEkQho0zkW0txQvVLLXDfI6qqEhGRmVL1XaWM33jNaY26SpkWVU3MGxXftS/NVQIKtcZ5vvHwRZ+pFgQFMZObtSDm2LFjPPXUU+TzeYIguOD6e++9d6qHbioKYqau7LswZrgCx4bh/m0eRwvuyff7+y0f2mhpS7jb1gK3084PXKuDtqgb8tYS0Yc+ERGZPuPzXoqNeS9lHwILUc17kUUgaLQwKzfmHEUbrSHaoh6piGsbovddi1PFt+QqLoAp1c718deuZBERmS32Ne9T4mHIRg2ZxrkhtQZuLtXx8KUaUGi0cvYa7x8Uviw8CmImN+NBTLlc5r777uN//a//RRAEGGMYP8zEHzLf9y/30E1JQcyVqfqWI6WAgTIkQvDwsx4PPwuBNaSjll/aYPmhNe7DHpzrIVluDHJLhaEj7nqGJsJ6EhcRkcsz/oFupDHvpfCaeS+xkD7UyeJkraUWuJMd9eDcB+dM1JCOuJaxqlBe2Kx1J1CGKpbhinsPHvVcIBdSKC0iInMoaJwbqtTPbQ5ojxnSjYpebRyZG7XAvXfIVyz5mqVcd+8h1cp54VMQM7nLyQ3CU3mA3/md3+GrX/0q/+W//Bc2bdrEm9/8Zh588EGWLVvG/fffz/Hjx/nrv/7rKS1eFp5oyNCf9vBMwOkxeN/6gO/vM/y3rfDykOEPHjN8+xXLr2+2dLW4J+1EY6is36iSOVgMiHmQibny1HREO5ZFROTirHWvHyN1Vx4/0hgM6Rn3ASEb04c3EWMM0ZCrBgPXwqziw/ERi8ESDbm2sZmIq5bREN2FoxZYCo32Y4WqqwqMh6E9pn9jERFpDp5xm0KSYdc2s1yHoyVLyFhSEWhvnBtKaNbwjKuPhy+NjgJjjXAsHoI2vXcQuWRTqohZuXIlb3/72/mzP/szBgcHWbp0Kf/yL//CW97yFgDe8pa3cM011/DZz3522hc8F1QRMz18a3m1ZDk5akk2Skq/8hw8+JShFhgSYct/uM1y17XuRNlE40Nnx+quPHV8J0Qm5nZC6ElfRER8axmpnT/vpWbdnJeYehOLXJbAWqqN1iB+4+co2WgPkoq491+qmJh/RmuWXNUyWHZhdajx76r++yIiMl/Ug8b7fB/CIUhHzm3YjauLyrTxA0upDoWqq5qt1MHiNm7EQtrUthipImZyM14Rc/r0aTZs2ABAIuEGfIyMjJy9/p577uH3f//3F0wQI9MjZAw9LRAy8OqoJR6yvGedYctKyx9thb2nDX+yw/Dtg5aPbLaszJ67rzGGWKPMMbDuRffYiAt10lG3E6I1qvYZIiKLTS1w4UuxEb6Mz3uJhNzci1adXBSZEs8Y4mH3YdtaS926DTGFqsUzlngIWqOG1qjbrao5Is3Lt5ZiFYYqAbkK1AJVBoqIyPwV9gzpqPt91bcUazBcCYiGIBOFbNSjJaLzQ1MxvrGtWLUMNT5bWevaObfqfYPIFZtSENPV1cXg4CAAyWSStrY29u/fz1133QW4JKhcLk/fKmXB8IxhecqFMcdGLIG19GYMn3yH5e/2W/7iCcNzpw2/8Lfw/pstP3kjhL0Lj5GKQCriTsAVa+6DpSuJNGRjhnRELxAiIgvRxHkvhaqlUDu3OyvW2BGnXfoi08sYQ8RApHHSww8slQBOjbpNMdEQtIQhE/NINVqIqPps7lV8S74KA2MBpdq5/vrpqP5tRERkYYiGXJvV8S4qg2U4MxYQb1TxZqKGFrW2f12BPbexbajRVSCwjc9WUc3SFJlOUwpiNm7cyGOPPcZv/uZvAnDXXXfxh3/4hyxbtowgCPjUpz7FnXfeOa0LlYXDGEN3yhD2LEdKAYWqpTVq+LFr4c4eyx9vg52vGr7wpOG7hyy/scWytmPyY0U8QyTqXnTLvjshcHrMkgpDR9xVySRUmioiMq+90byXjHZnicyqkGdINlpajZ/4yNdgsBIQaZzsz8bOtTDTyY/ZY63r4T5cObeTNepBa1QhtYiILFwTu6hMPD90atSebW2fboQy+tzg/o5G6q7yZbjifh9YNzdQG9tEZs6UZsQ89thjfPnLX+YP/uAPiMViHD16lLe+9a289NJLAKxZs4a///u/55prrpn2Bc8FzYiZOcMVy+FiQC1wJaTGGKyFR1+Bz+w0FCsGz7jKmPevt8QuITr0A8uoD1UfYo0Pnu1x1y9UJwJEROYH31pGx+e9VN3vNe9FpPnVAle1VvXPDXFtjbiTH6lGT3H97E6/WmApVGGwHFCourk+ibD7+9fft4iILFbjre3H35ekwq6Tynhr1cX0Gjm+uW28ldtIrTEHMASJkM6XyRvTjJjJXU5uMKUgZjJBEPDss88SCoW49tprCYenVGzTlBTEzKxC1YUxYz5ko+deCIfH4DM7DN855P7c02r5yBbLuq5LO+74Ds2xuutpOb4LIhNzJwIW0wuuiMh8cNF5L56bU6Fh0iLzS9BoJVhp/CxHPddaNhP1SEVcRY12pV6Z0bp7vhwsu5MroUalkp4vRUREzlcPLGM+1HwIG0g15g2nIwu3k4q17msu1WCo7MKXeuPzVUJVy3KZFMRMbkaDmNHRUd73vvdxzz338N73vveKFjpfKIiZeSM1y6Gi61/92sGhW4/Ap7cZBsfcZT96reU/3GZJRi79+OO7ICqNF9yWxgtua1TDZUVE5lLZd+HLZPNe4iGVxYssFOMbZCo+1AM3L3C8f3tLxM3/U3hwaXxrKVbdjMRcBWqBe85MKNgSERG5JLXAnSOqBa6TSjoKbY1QJjrPzxGNt2YrNSpfSo22zuPhi95vyVQpiJnc5eQGl122kkwm+Zd/+Rfe8Y53THmBIq+VihhWt3ocLroPlJmYPTsQbMtKWN9l+bPd8M0XDX+7z7DtKPz6JsuGnks7vmfcB/xUxL3gjr8gxUOuLDUbc71CNYRMRGRm2UYwXqpDvhJQarQK0LwXkYVtYu92cLtSKz4cH7GAaz+bjkBr1COlllqTqviWfBUGxtxzp8GdUElH9fckIiJyOSbOG64GMFxxFSPRkNskMn6OaD5VjJR9S6l6LnypNMKXeEjvFUSaxZRak/3Ij/wI3d3dfOELX5iJNTUdVcTMnopvOVIMGCpDa+zCF72nTsAnHzecKLrL37ra8ksbLJn45T/W+C6Bcv1cr9D2uEcmunDLUkVE5sLF5r2EGx8MNO9FZHF7bQuzSKO9VqZRLZNcxJtlrB3fQGQZarRsjDb+flQxKCIiMn3OniPyAesqd9tihkzUbextxvciFd+9T8hVAgq1RhcYfcaSGaKKmMnN+IyYV155hbe97W28+93v5hd/8Rfp6bnEsoR5SkHM7KoFLow5U4bW6IVlk2M1eHCP4avPQ2AN2bjlVzZa/o9+F6hMhR9YRn2o1d2gskyjLLU1Or92QIiINIvxeS+lmmVY815E5BJZa6k1WpjVAlctFw+5UCbdGKy7GNrK1gNX/TJYDihU3TDdhCqFREREZkXQCGUqjY274zOHW6NzP3O4Oh6+VN17hEqju0AirPBFZpaCmMnNeBCTTqep1+tUq1UAwuEwsVjs/AMbQz6fv9xDNyUFMbOvHliOlSwnxywtkck/cL9wBv5oq+FQzl23udfyq5ssS5JX9tgV37XNsfbci20mNvcvtiIiza4yYd5LvjHvBSCqeS8iMkV+YKkEnPd80hKGTMy1MEsssPdno3VLrmIZLFtG6xBqVL8ovBYREZkbfuAG3lcbM4dTkXMbd2drg8R4i/18xX3OKtfPbVaJaZOGzBIFMZOb0RkxAPfcc49+yGVGhT3DyrT78HlixGKtJf6admHXLYXP3mX5m2ctX3zG8PhRw9Mn4RfusLxj7dSrY2Ih18N8fAfEsRHLiVFLSxQ6Gi+2i2EnpojIG7HWfSgZaZTDa96LiEy3kGdINsIIa10ok6vBQCUg0tj9mY0ZUhG3aWY+VjL71lKswlDFzUqsBe45NKvnUBERkTkX8gwtHtCYOTxSd9UoUc/Nt2uLe6QvsoH4StTHw5eqJV91G4ZNI3xpiyl8EZmPplQRs9ioImbuWOtCkFdHLNEQJC8yu+XgsKuO2Tfgrr9lmeXXN1mWT9M/Vy1wL3r1xgfjtti54W3N2CdURGSmBNZ9+Cg1PhCM1N1JQ/UiFpHZVgvcppm6705MxEKQiTRamEUg3uQbZyq+az82MOaCbGDRtF4TERGZ76q+25TmN84TtTZa3LdEpl7J6geWUt11GBiuuA4DFtfaORbSBg2ZW6qImdyMtyZbbBTEzC1rLWfKcLQY4HnQEpn8hccP4GsvwF8+aaj4hljI8oFbLe+6zlXWTNdaKj5ndyIkJ7QuS6gcVEQWqPHdWKWaJdfYjaV5LyLSTMYrmauNeVRRz7UOyUQ9UhH3nq0ZTl5Y606wDJctQ435WdFGxY/aN4qIiMw/4+eJyr5rcR8PQzbqzhNdyuZd37r2zsXqufcG1kKsMRuuGd6/iICCmIuZ8SDmr//6ry/pdvfee+/lHropKYhpDoNly5FiQIAr/7xY6HG8AJ/aZnjqhLv+2iWWj2yxrGqb3vWc7RNah0hj90N7zCMd1UlJEZn/Js57KTT6EIObzxALzc/2PyKyOFhrqQZueG3ddxty4mFoizZamF3BTtWpqgeu+mWw7Abr+o1ZhLPVW15ERERm3vjGkEpj8+743OF01LVQHQ9VgvHwpebCl/GNbrGQe8+izivSjBTETG7GgxjPu/hf+MQPEr7vX+6hm5KCmOaRq1gOlwKqPmSiF//gai38w0vwuV2G0Zoh7Fl+ah389E2WSGj611X13UDV8d0P41UyLQtsgKyILFwT573kG/NeKhPmvagUXkTmq3qjhVmt8dEkFnabelqjHqkZDkNG65ZcxTJYdu8VQ43qF23aERERWdh86wKWqg8h4yp122MegXVtx0Ya4Us0BImQKmOl+SmImdyMBzGHDx++4DLf9zl06BD//b//d44cOcKDDz7Iddddd7mHbkoKYppLserCmJHaGw8oGxiBP95u2HbU3aY/a/mNLZZrl87M2ibufvAMtESgI+7RGlW/bxFpPoF1JwZLNchVAkbrUA0gbNyJypjmvYjIAhM02odUfFeVMt4WLBs718LsSnehBtZSqMJQJSBXcc+r8ZDbFatAW0REZPGpN+YO1wL352jIvTdQlwGZTxTETG7OZ8S8853vpL+/n8985jPTfeg5oSCm+YzWLIeKAcUaZGOv/6HWWvjuIfjTHYZc2eAZy7+7Hu672ZKIzNwa64E7wVlvDG7LRg3ZmCEdVZmpiMydeuB2X5WqluGqaznmWwh77sNAROGLiCwS1lpqgevpXg/cJpp4CLIxQ0vEtRCJXsZGmorv2o8NjLmqQnDBjjbjiIiIiMh8pyBmcnMexHz2s5/ld3/3dxkYGJjuQ88JBTHNqVx3lTG5imtT9kZlnPkyfHaX4V8OuNstS1s+vNlyy7KZXef44LaxOmDcB/KOmCETNSTUukxEZsH4vJdizZKvnhsAqZ1YIiLn+I0WZlUfLG4jzdkWZhHXNuS179ustZTqnG0/VvbPVdmoxYiIiIiILBQKYiZ3OblBeCYWcODAASqVykwcWuSseNiwKu1xmIDBCmSi9nVPJmbi8FvfZ3nLKsunthlOFA3/v380vGOt5Rdut7TEZmadxhjiYTc7ZrxH6OGSJepZ0o3WZemoeoWLyPSxjTaJpRoUqq56sOK7gZGxkAuv1R5HROR8Ic+Q8lwP9/GNNMMVOFMOiBhIRiATddUysZB7jh0sBxSqrrLQDeTVJhsREREREbnQlIKYf/u3f5v08lwux7/927/x6U9/mrvvvvtK1iVySaIhw6pWj1Ap4PQopKP2DVtIbOiBB+62PLAbvr7P8A8vGXYeg1/dZNmycmbXGzKGloibHVP1LblG/3D3wd00PtzrA7yIXL7xeS8jNRhuzHupBW4wZCwMbarAExG5ZBM30gDUAsuYD4WSxTOWiOcC7lAjoNGGGhEREREReT1Tak3med6kJ3OstYRCIX7iJ36CP/mTP6Gjo2NaFjnX1Jqs+fnWcqxkOTlqSUUuvRf3s6fgj7YajhXc7f+PfsuvbLS0JWZytecLGjvXy3XXmzwdgfa4R2sU4uopLiKvQ/NeRERmn9+YLRP1VF0oIiIiIouDWpNNbsZnxHz3u9+98EDG0NbWRl9f34ILKxTEzA+BtZwYsRwfscTCkAhf2gfjah3++mnDl/ZCYA3pmOWXN1jeutq18ZlN9cCe3cUeC0Fb1JCNGdIR9RkXWez8Rpuc8V8j9YCRRsuxQPNeRERERERERGSGKIiZ3IwHMYuNgpj5w1rLqVHL0RHXMiIVufQTki8Nwn/bajgw5O6zYYXl1zZZulpmarUXN96XfMwHrGt50dFoXZZQeyGRBa8enAtdyr5ltGYZ9aHmu4oXAM9zFS/xkHZki4iIiIiIiMjMURAzuRkPYg4ePMjevXu56667Jr3+7/7u71i3bh39/f2Xe+impCBmfrHWMlCGI6UAA6Sjl36Csh7Al/bC/9hjqAWGRNjyH2633HWNaxs2F3xrGatD1XfthlontC5TP3KR+a82MXSpW0bqbg7BeOhigFAjdIl4bh6BwlgRERERERERmS0KYiY340HMPffcQ6FQ4J//+Z8nvf7tb3872WyWhx9++HIP3ZQUxMxPwxXL4WJA3brw4nJOXB7JwR89bnjutLvPjZ2Wj2yx9GZmaLGXqOq7UMa3kAhDW8yQjRpSEe2IF2l2tjFTYGKlS6nmZkTVAtdeDFzgOh66qM2YiIiIiIiIiMw1BTGTu5zcYEp/c9u2beOHfuiHLnr9D/7gD/K9731vKocWmTZtMcOqVo+oB/mqOwl6qVZm4VPvsHxoY0AibNl72vDzXzf8zTOuamauREOGTMzQFgMLHB+x7MsF7M8FnB6zlOvqNCjSDFx7QUuhajkzZjlSDNiXC3h+2P3/QCHg+IibCRUykI5Ae9zQHje0Rg2JsFEIIyIiIiIiIiKyQISncqfh4WHS6fRFr29paWFwcHDKixKZLpmoYXWrx6FiQK4CmZi95MoRz8CPXQd39lo+9Tg8cdzwwJOG7x5y1TFrO2Z48a/DGEMyDMmwmyUxWod8ISAWgmzU0BYzpCMQ0olckRk3PtOp0qh2GatZSnVLNXDBbWDBmHNVLomwKthERERERERERBaTKVXErFy5kq1bt170+u9973v09PRMeVEi06klYljT6pGOQq4CwWV24+tqgU/8kOWjbwpIxywvDxk++PeGB3YbqvUZWvRlCHtuB317zLU0OlO2vJQLeCEXcHwkYKRmL6saSEQuLrCWsbolV7GcGrUcLAQ8NxTwwnDA/uGAQ4WA02UXwkQ9aI26Spe2mKElYoiFjEIYEREREREREZFFZkpBzE/91E/xN3/zN3z6058mCM71afJ9nz/+4z/mkUce4ad/+qenbZEiVyoRdpUxbTEYLrsqksthDPzwVfCFuy3f328JrOFvnjX8wt8anj01Q4u+TMYY4iF3wrc15mZOHC1Z9g0HvJwPGCxbqr4CGZFL5VvLaN0yXLGcHLW8nPfZOx665AIOF93PVd1CNATZGLTFDdlG6BJV6CIiIiIiIiIiIoCxU9gqX6lUeOc738m3v/1tli5dyjXXXAPA/v37OXPmDG9+85v5h3/4B2Kx2LQveC5cztAdaW61wM1qOFN2O9UjU2zd9dhh+PR2w9CYu/+PXWv52dssych0rnZ6VH3LmA9BALEwtMcMmaihJaL2SCLj6kGjvZgPZd8yUnM/NzUf6hYM4Hnn2ouFjQs/RUREREREREQWulzF0pkw9KWnVNexYF1ObjClIAYgCAIefPBBvvrVr3LgwAEA1qxZwz333MO9996L5y2cfxQFMQtLPbAcK1lOjVlaIhANTe1karECf/aE4R9ecvfvTFn+r02WDU3alc9aS9mHct1V+LREoCPu0RqBeFgnlGXxqE0MXepunku5Ebr4jdAlNCF0CSl0EREREREREZFFTEHM5GYliFlMFMQsPL61HB9xv5LhKwsinjwOn3zccLLkjvFDayy/eIclE5+u1U6/emAZq0M1gFgIMlFoj3m0RNzMGZGFwFpLLeBs6DLWqHQp+65133iHwvDEShd9/4uIiIiIiIiInEdBzORmPIgZGhri2LFj3HTTTZNe/+yzz9LT00NbW9vlHropKYhZmKy1nBi1vDpiiYYgeQVhzFgN/uopw1efB4shG7d86E7L9/e56pNmZa0bKj5WB2shEYaOuGtdlgyrCkDmj/Hv5fHQZbTu5rtUJoQuhvNDl5BCFxERERERERGRN6QgZnIzHsTcd9997N+/n+3bt096/ebNm7nuuut44IEHLvfQTUlBzMJlreX0mOVoyRLyoCVyZSdmnz8Nf/S44XDOHWfLShfILElOx2pnVmBdlUzFd/MvWqPQHvdIX0H7NpGZYG2jtVgjeBmrufZi1cY8l8C6ADQyIXTRPCQRERERERERkalREDO5y8kNwlN5gG9/+9v80i/90kWvv+uuu/jc5z43lUOLzCpjDF1JQ9izHCkGFKqW1ujUT9he3wmfvcvyN8/AF5+BrUcMe07AL95hefva5q6O8YwhFYFUxM3QyNdgqBIQD0Nb1JCNGVoiOqEtsyuw5+a5jFe6lGqu5Vg9AAt4jdAlGoKkQhcREREREREREWkyUwpizpw5w5IlSy56fUdHB6dPn57yokRmW0fcEDIeh0sB+YqlNTr1tlzRENx3i+X7+uG/PQYvDhr+6HHDtw9afn2zZXl6etc+EyKeIRN1lQdlH06OWk6NWVoibpZMJnplc3VEJuO/JnQp1QJG65wNXQBCxrUXi4WgJaL2eSIiIiIiIiIi0vymFMQsW7aMp5566qLX7969m6VLl055USJzIRtzYcyhYkCuAtmYvaKTvKvb4E/eafnq85a/esrw1AnDz38dfuYWy7uug9A8qOQzxpAIu9kx9cC1LjtYDYh5kIlBW8y1LtOAc7lc9eBc6FL2XZVL2Ydao72YAbxGW7FE2LXLU+giIiIiIiIiIiLz0ZROBd9999088MAD/O3f/u0F133961/nL//yL3nXu951xYsTmW3pqGF1q0dLBIYrri3SlQh58BM3wp/9mGV9t6VcN3xul8evfdNwaHiaFj1Lwp4hHTW0xyASgsEyvJQLeGE44PhIwEjNMoWRU7II1AIXtAyWLa+WAvbnfJ4bdt87L+UDjpUsxZq7bTICbTFoixsyUUMybIh4RiGMiIiIiIiIiIjMW8ZO4cxpPp/nTW96E88//zzr16/nxhtvBGDv3r3s2bOH66+/nscee4xsNjvd650TlzN0RxaGct1yqNSojIlCaBoqPqyFb74En99lGK25uTTvvcnynnUu2JiPAuuqZCq+q1hIR6E97tEagWhIJ84XG2vd7JbxSpcx3zIyXukSQNB4tQl7EPXc/1VNJSIiIiIiIiLS3HIVS2fC0JeeBy1+ZtHl5AZTCmIARkZG+IM/+AO++tWvcuDAAQDWrFnDPffcw0c/+lEqlQptbW1TOXTTURCzOFV8y5FiwGAFMtHpO2E8MAJ/vN2w7ag7Xn/W8htvslx78bFL80ItsIzWwQ8gHoZs1JCNGdIRDU9fiKy1VCeELqN1F7pUg3OhiwHCIddeLGKmJ9AUEREREREREZHZpSBmcrMSxEymXC7zd3/3dzz00EN861vfolwuT9eh55SCmMWrFliOlgJOj0JrzA2xnw7WwncOwWd2GHJlg2cs91wP991iiU9pclPzsNZVQJTrYAykwtAR92iNQiKsE/HzUWAtVR8qjeBlrGYp1i01H2rWfT8b0whcGr8UvomIiIiIiIiILAwKYiZ3ObnBFZ/ytdby6KOP8tBDD/G1r32NYrHIkiVL+Omf/ukrPbTInIt4hr4Wj5CxnBy1pCKW2DS03DIGfmAV3LrM8t93wqOvGL78HDx2BD6y2XLzsmlY/BwxxpAIuwHrfqNK5mAxIOZBJgZtMY90RC2pmlVg7dkql4oPI41Kl1oA9QAs4DVCl2gIkgpdREREREREREREXteUK2J2797NQw89xMMPP8zJkycxxvCe97yHX/mVX+HOO+9cUIOVVREjgbUcH3G/4uHpr+zYfhT+eJvhzKg77juvtvzc7ZaW6LQ+zJwZb2M1Vnctq5JhaI8ZMjFDKsyCer6YT/ygEbo0Kl1KtYDROmdDF4CQcbNcxitd9G8lIiIiIiIiIrK4qCJmcjNWEfPKK6/w0EMP8dBDD/HSSy+xYsUK3vve97Jhwwbe/e53c88997Bp06YrWrxIM/KMYUXKnZQ+NmIJrCUVmb4T0nf2wrouy1/shr/bb/jGi4btx+DX7rRsXjltDzNnjDHEQhALuVBrrO7+Hk+OWtJRaI+51mXRaag2ksnVg3OVLmXfUqq5FnI1H+qNOD7UCFsSYQgbhS4iIiIiIiIiIiLT4ZKDmE2bNrFz506WLFnCj//4j/MXf/EXvOlNbwLgwIEDM7ZAkWZhjKE76VpqHSkGFKuWdHT6TlSnovBrmyw/sMryR48bXi0YPvZtw5v7LR/caGlLTNtDzSnPGFIRSEXcDJ5iDYYqAfEQtMUM2ZghHVG7qytRmxi61C2l+rnQxbdgOBe6JCMuYFToIiIiIiIiIiIiMjMuOYjZsWMHq1at4pOf/CTvfOc7CYfn+URxkSkwxrA0ASHjcbgUkK9aWiPTexL7pm74sx+1/PUe+PJz8J1DhidPwAc3WN6y2s2XWSginiESda3Lyj6cHLWcHrOkwtARd1Uy090GbiGx1s1uGQ9dxhqVLhXftRcLJoQuUQ9aIhDSbB4REREREREREZFZdclN3f70T/+UZcuW8a53vYvu7m5+4Rd+gX/9139liiNmROa19rhhdatH1IN8lWn/OYiF4edut/zpOy1r2iyFiuET3/P4j48aTo9M60M1BWMMibChPe6qYcoBHCwG7BsOOJD3GSpb6sHifq6x1lLxLYWq5cyY5XAx4IXhgOeGA/blAg4UAk6MWsZ8F7ykI+77tC1uaI0a4mGjEEZERERERERERGQOGHuZZ5APHjzIQw89xBe/+EX27dtHd3c3P/ADP8DDDz/MV77yFd71rnfN1FrnzOUM3ZHFpVSzHCoGjNYgE5uZdlr1AL60F/7HHkMtMCQjlv9wm+X/vAYW8nl1ay3VAMbqYK2bW9IeM2RihlR4YbfSCqyl6kMlgHIdRuuWkbql5kPNur8PY1xrsfFfauUmIiIiIiIiIiIzIVexdCYMfelLrutYFC4nN7jsIGai3bt389BDD/HII49w4sQJurq6uOuuu/jRH/1R3vrWtxKPx6d66KaiIEZez2jdVScUqpCdoTAG4HAOPvm44bnT7vjruiwf2WzpyczIwzWVwFrG6q79VthASxTaY651WSw0vwOIwE6Y5+LDaD1gpOZai9UDsLjAbTxwCSt0ERERERERERGRWaQgZnKzFsSMC4KAb3/72/zP//k/+drXvkaxWCSZTFIqla700E1BQYy8kbLvwpjhCmSjMzeHI7Dw9X3wwG5DuW6IeJb7brH8xA2uHdViUAtcKFMLIB6CtpghGzNu/kmTBxR+0AhdGnNdSrWA0fq50AUgZFzYMh68LOTKHxERERERERERaX4KYiY360HMROVyma9//et88Ytf5Otf//p0HnrOKIiRS1H1LUdKAQNlaI26QfQz5WQRPrXNsPu4e4y1Ha465qqOGXvIpmOtpey71l3GQGpC67JEeO7Di3owsdLFUqq59dZ8qDeedcPeudAlbBS6iIiIiIiIiIhI81EQM7k5DWIWIgUxcqnqgeVoyXJqzJKOQHQG22ZZC/98AD6701CsGjxjec86eN9Nlmh4xh62KfmBZdSHWh0iIchEoa3Ruiw8C4N0ahNDl7qlVD8XuvgWDK5iabzKJaTQRURERERERERE5gkFMZO7nNxgkZ2uFZlZYc+wMu1OtJ8ctQRY4jMUxhgDP3wV3L7c8qc74N8OG774DDx2GD682XJj14w8bFMKeYa0B0RcZdJQBQbLAYkJVTKp8JWHH9Zaao22YhUfxhqVLhXftRcLGqHLeJVLS2Tm2tSJiIiIiIiIiIjI/KCKmEugihi5XIG1nBixvDpqiYeYlVZZ3zsMf7LdMDRmMFh+7Dr42VsticiMP3RTCia0LgsZaIlCR6NKJnYJ4Zi1lmoAZR+qPozWLSM1S6UxzyWwLgwLn1fpotBFREREREREREQWFlXETE4VMSJzzDOG5SkXABwbsfjW0hKZ2ZP039cHN3dbPrcL/vFlw/9+AbYdgf9rs+WOFTP60E3JM4ZkGJJh1zpspAb5SkAsBG1RVyWTjrrwJLCWqu9Cl8p46FK31HyoWdcGzphzgUsy7I4vIiIiIiIiIiIi8kZUEXMJVBEjV2KgbDlSDLBAa3R2Tt7vPg6fetxwsuQe74fXWH5xg6U1NisP37SsdW3ExuouWEmE3a/RmmstVg/AAt6E0CXsKXQREREREREREZHFSxUxk7uc3EB/cyIzbEncsKrVI2QgX7HMRvZ523L48x+z/LvrLAbLPx0w/PuvGf7t0Iw/dFMzxhAPG9rihnTEhS/DFQiAWAiyMWiPG7IxQypiiIaMQhgRERERERERERG5IgpiRGZBW8ywutUjFoJchVkJYxIR+OWNlj/+EcvKjCVXNvz+dzz+07cNg6Mz/vBNL+QZWiKGTNSQDLvQxSh0ERERERERERERkWmmIEZklrRGXRjTEmlUYcxSV8DrO+FzP2p533pLyFgeO2L42f9t+NZLbvaJiIiIiIiIiIiIiMwcBTEisygVcW3KMlEXxvizlIREQ/Azt1g+e5fl6g5LqWr4b1s9fvOfDCeKs7IEERERERERERERkUWp6YKYz3zmM/T39xOPx9m4cSM7d+583dvncjk++MEPsmzZMmKxGFdffTXf/OY3z17/n/7Tf8IYc96va6+9dqa/DJGLSoRdGNMRg1wZ6sHslaWsboc/eafl528PiIYsT54w/NzXDV99Hvxg1pYhIiIiIiIiIiIismiE53oBEz3yyCN8+MMf5nOf+xwbN27k/vvv521vexv79++ns7PzgttXq1V+6Id+iM7OTr7yla+wYsUKDh8+TDabPe92N9xwA//yL/9y9s/hcFN92bIIxUKG/laPkAk4XYbWqCXizc58kpAHP3kjbFlp+aOt8Mwpw3/fafjXg5bf2GLpy87KMkREREREREREREQWhaZKJD75yU/ycz/3c3zgAx8A4HOf+xzf+MY3+MIXvsBv/dZvXXD7L3zhCwwNDfH4448TiUQA6O/vv+B24XCY7u7uGV27yOWKeIa+tEfIs5wYtbRELLHQ7A2LX9EK/+3tlm++aPmzJwwvnDH84t/Ce9db3n0jREKzthQREVlkrAUzey95IiIiIiIiInOqaVqTVatVdu/ezVvf+tazl3mex1vf+la2bds26X3+9m//lk2bNvHBD36Qrq4ubrzxRv7f//f/xff982730ksvsXz5clavXs173/tejhw58rprqVQqFAqF836JzISQZ+htMaxIGUZrUK7PXpsyAM/A/3kNPHC3ZWOPpRYY/uopj1/+e8O+gVldioiILEDWwpkR2HkMvrQX/uv3DL/0d4b/838afv7rhn875G4jIiIiIiIispA1TUXMwMAAvu/T1dV13uVdXV3s27dv0vu88sorfPvb3+a9730v3/zmN3n55Zf55V/+ZWq1Gr/3e78HwMaNG/mrv/orrrnmGk6cOMHHP/5xvu/7vo+9e/eSTqcnPe4nPvEJPv7xj0/vFyhyEZ4x9KQgbODYiCXAkgzP7jbhpSn4zz9o+deDls/sMBwcNvzqN+Ce6+G+WyzxpnmmEBGRZlWowKFhODgMB3OGQ8NwKAel6uSvaa8Mw+9/x7C2w/KBWyx3rFCVjIiIiIiIiCxMxtrm2Id4/PhxVqxYweOPP86mTZvOXv7Rj36U7373u+zYseOC+1x99dWUy2UOHjxIKOT6KH3yk5/kD//wDzlx4sSkj5PL5ejr6+OTn/wkP/uzPzvpbSqVCpVK5eyfC4UCvb295PN5Wltbr+TLFLkoay1nynC0GGA8SEfm5mxUrgz/fafh26+4x1+etnx4s+XmZXOyHBERaTJjNTicpxG0GA4Ou98Pjk3+uuUZS08rrGqDVW2W/qxrj/ndQ4b/9RyM1d39bui0/PtbLevVTVZERERERKSp5CqWzoQbsyDnFAoFMpnMJeUGTbPPfcmSJYRCIU6dOnXe5adOnbrofJdly5YRiUTOhjAA1113HSdPnqRarRKNRi+4Tzab5eqrr+bll1++6FpisRixWGyKX4nI1Bhj6ExA2HgcLgYUqpZ0xF0+m7Jx+J3vt7xlleX+bYbjRcNv/KPhnVdbfu52S8uFP1YiIrIA1QM4loeDOTg03AhccnCiCJbJX5u6W1zQ0t8IXVZloScD0Unmjq1qs9x9HTzyLHx9Hzx32vCRbxluW+4qZK5dOoNfnIiIiIiIiMgsapogJhqNctttt/Hoo49y9913AxAEAY8++ii/8iu/Mul9tmzZwhe/+EWCIMDzXBr34osvsmzZsklDGIBSqcSBAwd4//vfPyNfh8iVao8bPONxuBSQr0Imamc9jAG4sxf+osvyF7vh7/cbvvGiYccx+LVNlk29s74cERGZIYGFUyUXshwchoPDhkM5OJqHejD56082blnVBv3Zc1UufVlIXWZYn43DL9xhued6eOgZ+OaLsPu4Yfdxw+Zey8/cYlndfmVfn4iIiIiIiMhca5rWZACPPPII9913H5///OfZsGED999/P1/60pfYt28fXV1d3HvvvaxYsYJPfOITABw9epQbbriB++67jw996EO89NJL/Pt//+/51V/9Vf7jf/yPAPzGb/wGd911F319fRw/fpzf+73fY8+ePTz//PMsXXppWy0vp8RIZLoUa5bDxYCRGrTFZr8yZqKnT8IntxpeLbo1/MAqywc3WrLxOVuSiIhcJmtd+8mDjTku423FDufOtQd7rUTYNqpbYFXW/b4/C22JmVnjiSL8jz2Gf3kFAmswWN68Cu672dKTmZnHFBERERERkden1mSTm5etyQDe/e53c+bMGT72sY9x8uRJbr75Zr71rW/R1dUFwJEjR85WvgD09vbyj//4j/z6r/86N910EytWrODXfu3X+M3f/M2ztzl27Bg/9VM/xeDgIEuXLuVNb3oT27dvv+QQRmSupCOG1WmPQ8WA4QpkYxZvjsKY9d3w+R+z/PUe+Mpz8K8HDbuPwwc3Wt6ySsOVRUSazUj1XIXLxDku+crkT9gRz7IyQyNosY15LtCZmt3n+GVp+Oj3Wd69Dv56j5sj868H4buH4Ievgvevt3S1zN56RERERERERKZDU1XENCtVxMhcKtcth0sBuQpkohDy5jb12D8A/22r4eCwW8fGHsuvbbJ0puZ0WSIii1K1Dkfy46GLacxzgdMjk79WGCzLW2FV1gUt/Y22YitaIdyEG5teHoS/esqw/Zj7esKe5Z1Xw0/fZOlIzvHiREREREREFglVxEzucnIDBTGXQEGMzLWq79qUDTbCmPAchzE1Hx7ZCw89bagFhmTE8nO3Wd55Dczx0kREFiQ/cG27DuYaVS6NOS7HCq6F12SWJG1jhsu5OS4rsxBvqnroS/P8afjLpwxPnXBfayxk+bHr4N03WjJqkykiIiIiIjKjFMRMTkHMNFMQI82gHliOlAJOj0I6CtHQ3Cceh3PwR1sNz59xa7mpy/LhLZYe/ZiIiEyJtTAw2pjjknOBy8FhV/VS9Sd/3k9HbaO65Vxbsf4spGOzuvRZ8dQJ+MKThhcarzvJiOWe6+HHb7CkonO8OBERERERkQVKQczkFMRMMwUx0ix8a3m1ZDkxaklFINYEYYwfwN/ugweeNJTrhmjIct/Nlh+/AUJ6bhYRuah82bUUOzQMByfMcRmpTf7cHgtZ+rLnV7j0t0FHYnHN6rIWdhxzFTIHhtwXno5Z3nOjq5KZjxU/IiIiIiIizUxBzOQUxEwzBTHSTAJrOTFiOT5iiYUhEW6Os28ninD/NsPu4249V3dYPrLFsqZ9jhcmIjLHxmpwOH9+S7FDwzA4Nvnzt2csvRk3x6W/zTb+D90tCrgnCix87zA8+JThSN79XbYnLD99k+VHroZoaI4XKCIiIiIiskAoiJmcgphppiBGmo21llOjlqMjlogHqUhzhDHWwj+9DJ/dZShVDSFjec86eO96qxNiIrLg1QM4lh9vK2YalS5wsgiWyZ+nu1vOtRLrb3O/72lViHA5/AAefQX+eo/hZMn9PXemLO9fb/nhqxReiYiIiIiIXCkFMZNTEDPNFMRIM7LWMlCGo6UAgHS0OcIYgMFR+JMdhscOuzWtzLjqmBs653hhIiLTILBwsuSqWg7l4GBjjsuxAtSDyZ+L2+KW/jZX5bKqzf2+LwvJyGyufGGr+fAPL8FDzxgGR92/w4pW1y7zzavAa56XSRERERERkXlFQczkFMRMMwUx0syGK5bDxYB6AK1RME00KODfDsGfbDcMlw0Gy93Xwb+/1ZLQiUcRmQesheExV9VyaEKVy6EclOuTP9cmI252y6q289uKZeOzuPBFrlJ3s8seftaQr7h/p1Vtlp+5xbK5d3HN0xEREREREZkOCmImpyBmmimIkWZXqLowZsyHbJOFMYUKfH6X4R9fdmvqSll+fbPl9hVzvDARkQlKVTica7QVa8xxOTgMhcrkz6cRz7Iycy5wGQ9fOlM60d8sRmvw1efhy3sNIzX3j3LNEssHbrHctlz/TiIiIiIiIpdKQczkFMRMMwUxMh+UapZDxYDRGmRi4DXZGaYnXoVPIscK2AAAbtNJREFUPW44NeLW9barLL9wh6U1NscLE5FFpVqHw3lX1XKo0VLsYA7OjEz+nOkZy/I057cVy8KKVs0emS8KFRfGfO2Fc5VMN3VZPnCrZV3XHC9ORERERERkHlAQMzkFMdNMQYzMF2N1VxmTr7owJtRkYcxYDb7wpOF/v+AGV7fFLR+60/L9/XO9MhFZaPwAjhddVcv4HJdDw/BqEQI7+XPj0mRjjksb9Gctq9pgZQZi4dldu8yM4TH4m2cMf7cfao1ZPnescBUyVy+Z48WJiIiIiIg0MQUxk1MQM80UxMh8UvFdGDNUdmFMuAmnEz93Gv5oq+FI3q3t+/osH9poaU/O8cJEZN6xFs6MNma4TJjjcjh37mT7a6VjtlHd4gKX8WqXFlXoLQqnR+B/Pm341kvnQrk39Vl+5mb3vSAiIiIiIiLnUxAzOQUx00xBjMw3tcBypBhwpgytUYg0YRhTrcP/fMbwyLPgW0NL1PJLd1h++Cr17ReRyeXL5ypcDg0bDuZcADM+/+O14mFLX5bG/BbbCF6gPaHnGYFXC/A/9hgefcVVaRosP7ga7r3Zslxv90RERERERM5SEDM5BTHTTEGMzEf1wHKsZDk1ZmmJQDTUnGcdXx6EP3rc8NKgW99tyy2/vsnSnZ7jhYnInBmruYoWF7SYs+HL0Njkz2MhY+nNnAtcxitcutPQhDm0NJlDw/BXewyPHXbfLJ6xvH0tvG+9pTM1x4sTERERERFpAgpiJqcgZpopiJH5KrCWV0csx0csyTDEw815RtIP4CvPwYN7DFXfEA9bfvZWy49eq2HYIgtZzYdjhUZbsdy5wOVE8eLPVd0trrJl4hyXnlaIhGZv3bIwvTgAf/mUYder7vsv4lnuugZ+6iZLW2KOFyciIiIiIjKHFMRMTkHMNFMQI/OZtZYToy6QiYYg2aRhDMCxPHzyccMzp9war19q+cgW11pIROavwMLJUqOt2DAcaoQuR/OuNeFk2hOW/iyN6hYXuPRlIRGZ1aXLIvTsKfjLJ8+9FsXDlnddBz95oyWtOUIiIiIiIrIIKYiZnIKYaaYgRuY7ay1nynC0GOB50BJp3jAmsPCN/fDnuw2jNUPEs7x3veU96yCs53qRpmYt/P/bu/P4uOp6/+Pv75k1e9ImbdM13ReWtpRFKAiCWlCu8lMEVCxUBa4IiIAiXJULXEVAAUUU5CcUEK4gwkV/InpFvNeriFfaQqELS/c2adM0+zLJzPn+/jgzk5lk0iWdLJO8no9HmuTMmZkz6cmZyXnP5/PZ1+5VtWxOCVy2Nkgd0czHnfxA9+yW6WXd4UtpeBA3HOjBWmlVtfTQKqONe719tyBg9YkjrT62QMonEAQAAAAwihDEZEYQk2UEMRgp6jqstjW7ciUVBSQzjKdV72mV7nnZ6O87vG2cUWZ13VKrOeVDvGEAJEktES9w8UKX7rZiTZHMx5WAYzW11GspNr00PselTKrIl4bxoQijnLXSX7dLK1cbba73dtSSkNUnj/baloX8Q7yBAAAAADAICGIyI4jJMoIYjCQNEautLa66YlJxcHiHMdZKf9ws3feKUVPEyDFWnzhCWr7IcvILGCSRqLStsbvCZUu993VtW+Zjh2OsJhV5VS2JKpfpZdLEImY+IXe5VvrTZm+W2c4mb98fm2/16aOtzprNjCIAAAAAIxtBTGYEMVlGEIORprnTakuzq/aoVBoa3mGMJDV0eGHMS5u97ZxUZHXNUquFE4Z4w4ARJOZKO5u6K1wS7cV2NUtuH3NcKgqsppfG57jE24pNLaFKACNXzJV+/4702GtGe1q934sJhVbLF1mdMYOwEQAAAMDIRBCTGUFMlhHEYCRq6/LCmOYuL4xxhnkYI0l/3SZ9/29GdfF34p891+qSJVYFwSHeMCCHWOu1/tvSoHh1i9HmBmlbg9TlZj4OFIW8wGV6Wfocl0J+9zBKdcak59+SHn/NqL7D+72ZWmJ10WKrU6ZJzvB/SgUAAACAg0YQkxlBTJYRxGCk6ohabWlx1RiRSoKSLwfOHLV0Sg/+w+g3b3nbWpFv9aUTrd4zZYg3DBiGGju8qpbNDdKWlCqXtq7Mv+thf3fIUlVq4/NcpLI85rgAmXREpefWSz9/w6g5Ph9p5hirFYutTpjM7w0AAACAkYEgJjOCmCwjiMFI1hmz2trsqi4exvhzIIyRpDXV0l1/NdrV7G3v6TOsLj/eqjQ8xBsGDIH2LmlrQyJ06Z7jkninfk8+YzWlxKtwSQQuVWXShELeyQ/0R0un9Ms3jX65rjvoXFBhteIYq8WVQ7xxAAAAAHCYCGIyI4jJMoIYjHRdrtX2Fld72qSioBT05caZ2I6o9Mhq78SXa41KQlZfPMHqfdN5FzJyT1fM26d7frR39bXcaEeTF7jUtPS9w1cWeVUuXnWLVVWZNLmY4eLAQGjskJ58w+i59VIk5v1eLq70KmQWjBvijQMAAACAfiKIyYwgJssIYjAaxFyrHa1WNW1WBQEplCNhjCRt2Ct97y9Gm+u9bX7PZK9dWUXBEG8YRhRrpS43JQzJEJCkhybGWxbd/3US14vZw/udG5MXr2wplarKvK+nlUh5gew8fgAHr65NeuJ1o9+8JUXd7uemixdbzRo7xBsHAAAAAIeIICYzgpgsI4jBaOFaq12tVtWtViG/lOfPnTCmKyY9+Yb0s9eMoq5RfsDq0mOtPjSHVkujibXevpAafrTvJwBJhCWpl7dnCE0Sy9zDDEsOhs9Yhf1SOCDvc8pHXsryPL80vrA7fCmhLR8w7OxukR57zej373QfP06tsrpokdXU0qHdNgAAAAA4WAQxmRHEZBlBDEYTa72qmB2tVgFHKgjkVoqxpV767l+MNuz1tnvhBKtrTrKaxK/usGGtFIn1XSGSGoS0p4YlB6gq6RjEsMTv2O5gpI/QJO0j0GN9v1epkmldWoYBI8+ORumRNUYvbfaOT46x+sBM6cKFVpVFQ7xxAAAAAHAABDGZEcRkGUEMRhtrrfZ2SNuaXRkjFQVzK4yJudJ/rJceXm3UETUK+rx2MB9fIPl4vjgorpUiB11VEg9Lunq04epjvkkkKlkN/D4VcGxa9UjmgCRxue21rFclSsrlfvYjAP2waZ/33PTydu8Y6HeszpotfXqhVXn+EG8cAAAAAPSBICYzgpgsI4jBaLWvw2pri6uYlYoDkjG5Fcjsapbu/qvR6mpvu+eMtbpuqdWMMUO8YVni2swVIj3DkMTl7amVJQeoKumIDs7/ddBnMwYkmapF8gKZ100NSFIDE0I3AMPVhlovkHl1l3esDfqsPjpPuuAoS5tBAAAAAMMOQUxmBDFZRhCD0ayx02prs6tITCoJ5l4YY630wjvS/X83au0y8hmrTx4tfepoq+AgtICKub1DjkxVIt2Xmf0GJKnX7YwNzv9FyGf7bKPVu4LEpleR9FWREpBCPsISAKPbazXSQ6uM3tzjHc/z/FYfP0I69wirwuAQbxwAAAAAxBHEZEYQk2UEMRjtWrqstjS7auuSSkKSk2NhjCTtbZPu/ZvRX7Z52z61xKuOWTBOirp9DGvvcy6J2W+rrtQZJ13u4PysUgOQ/VeVZF63d6su73PILzm5998NADnDWul/d3oVMm/XeQfcoqDVeUdanTPfO24DAAAAwFAiiMmMICbLCGIAqT3qhTFNnVJpjoYx1kp/3ir94G9GDR3d/fmjgxCWGPWeQdJz7kh6KGL3e3lqtUnIJ+XgfwcAIEXiOeqRNUZbG7yDemnY6lNHW509Rwr6h3gDAQAYIDFXaopI9R1SQ7vU0JH4MKqPf5/4HLPSERXSokqrxZXSxCL+FgKAwUAQkxlBTJYRxACejpjVtmZX+zq8MMaXo6USjR3SA/9r9Pt307ffMfYgApIebbgCmdtu9VwWJCwBAByEmCu9tNkLZKqbvSeOinyrCxdZLZsl+fm7BwAwzFnrdQlIhCr1HalhiukRtnh/n1n174+lcQVeILO40mpRpVSen+UHAwCQRBDTF4KYLCOIAbp1xqy2tbja2yEVB6VAjoYxkrSvTepyuytMAoQlAIBhIupKL7wt/ew1o71t3pPTxCKrixZZnTadGVsAgMEVdb3AJLU6xfvapIUqicsOdZ6lkVVJWCpN/cjzqkNLw1JZnlQW9v5+e61GWl1ttL5WvbobTC3xApnFlVYLJ0jFoWz+FABg9CKIyYwgJssIYoB0UddqR4vV7narwoAU9JFeAAAwEDqj0q83Sv++trutZlWp1cWLrZZO5Q0EAID+sVZq7UyvWOmuVDHpYUuH1Bw59CecsN8mQ5WyvNTPNi1sKQt7gcmhvsmgvUt6Y4+0ptpodbX0dl16ZY2R1ayx0qIJXjBz1HhmrwFAfxHEZEYQk2UEMUBvMWu1q9WqutV6A+AJYwAAGDDtXdKz66Wn3jBq6fSec+eM9QKZ4yYRyAAApM5Y76oVb+5KetVKInDpOsRZmY6xKgl1hyeleYnqFZv2fVlYKgkPfujRHJFer5FWVRutqVFy5lqCz1jNq5COqfRmzMyv8FpIAwAOjCAmM4KYLCOIATJzrVVNm9XOVqugT8r3cxYIAICB1BKRfvGm0S/XSR1R73n3yHFWnz3G6ugJQ7xxAICscq3U0pneCqwhPmelvkfg0tAutXYd+t9j+QHbI1RJVKrEl6dUsxSFpFzqTF3XJq2JtzFbvUva3Zq+8SGf1ZHju+fLzB5D608A6AtBTGYEMVlGEAP0zVqrPe1W21usfI5UGMihV+YAAOSohg7p52uNnlvf/Y7mJROtVhxjNa98iDcOANCnSDS1UqWPWSspy2P20P6+8hmbFqokQpayRDuwHoFLyD9AD3QYqm6WVld7wcyaaqm+I/1nWxDw5sosrrRaXClNK6XiFAASCGIyI4jJMoIY4MD2dlhta3ZlJRUHebUKAMBg2Nsq/ex1o9++1X2ybulUq4sWW80oG+KNA4BRIOZKzZ3d4Ul3SzDTK1Spb5fao4f+t1JhsPeslZ5VK4nLCoOEBwfDWmlrQ3cw81pN74qisrBXKZMIZiqLhmZbAWA4IIjJjCAmywhigIPTELHa0uwq6krFQcnwFwAAAIOiull6bI3RHzZJrjUysjptunTRYqvJvHwFgEPS3tW7YqUhPmulZ0uwpoh33D0UAcd2z1lJGVqfGGJf1mPWSoA5JgMu5kpv75PWxIOZN3ZLkVj6/+uEwu5gZtEEaWz+EG0sAAwBgpjMCGKyjCAGOHhNnVZbm121R6XSEGEMAACDaWuD9Mgao//e4j3/OsZq2SzpwoVW4wuHdtsAYKjE3JQh9intvzJVrTR0dM/gOhTFIZsWqpSFpbI822Puive5IEDVynDXGZPW10prqo1WVUsbanu3iZtW6gUyx1R6c9qKQkO0sQAwCAhiMiOIyTKCGODQtHZ5YUxzlxfGOPyVAQDAoHq7Tlq52uiVHd5zcMCx+vBc6VNHWY3hHbwAcpy1UltXesuvjLNW4pc1RySrQ/ubJOizKfNVUmerpA+3LwtLxWHJz3mpEa29S1q7Oz5fpkZ6py59nzKymj1WWlwpLaq0OnKclBcYwg0GgCwjiMmMICbLCGKAQ9cR9dqUNXRKpUHJ5xDGAAAw2N7cIz28ymhNjfc8HPJZnTNfOu9Iq5LwEG8cAKToinlVK/Ud6jG03vSYveIt73IP7e8Lx1gVhzLMWQn3aBMW/zrsp2oFfWvskF5PBDPV0rbG9J3F71jNr+ieLzOvnBZzAHIbQUxmBDFZRhAD9E8kZrWt2VVdh1QSkvyEMQAADIlVu6SHVhlt2Os9F+cHrM49wurjC6SC4BBvHIARyVqppbN31UrPipVEW7DmzkP/WyHPb1MqVbpDlrL4rJXUy4pDko9zRxgge9u658usrpb2tKbvz2G/VyWTCGZmjmF/BJBbCGIyI4jJMoIYoP+6XKvtza72dEjFQSlAGAMAwJCwVnplh1ch826993xcHLI6/yirj87z3v0NAPvTGZUaIon5KqmzVUza9/UdXsVAtB9VK6mBSl9VK2V53hB7jlsYjqyVqpulVdXejJk1Nd7vSKqioNXCCV4bs8WV0tQSKrAADG8EMZkRxGQZQQxweGKu1Y5Wq5o2q4KAFPLxChMAgKHiWum/t0iPrDba3uQ9J4/Js/r00VZnzZGCtE4BRg3XevNTes5Zaegw3WFLR3fw0tZ16K/j8wM2Gaqktv8qDdseYYs37Jz3bWGkca20paG7Yua1mt6/S2PyrBZVxitmJkgTioZmWwGgLwQxmRHEZBlBDHD4XGu1q9X7CPulPD9/YQEAMJRirvSHd6XHXjOqafGel8cXWF24yOqDM2mZAowU1ko7m6T1e6UNtUbbG5XWGsy1h/a63O/YtPCke5i97Q5aEmFLSApStQKkibnSW3XS6ngw8+YeqTOW/ntYWWS1aIJ0TKUX0JTlDdHGAhi1OmPSjkZpc4O0ud7o7Trp1GlWXzqePxJSEcRkGUEMkB3WelUxO1qtgj4pnzAGAIAh1xWTnn9beuI1o7p277l5crHVRYusTp3Ou9OBXNMUkTbUShv2SutrjTbslZoj+/9FLgraHqFKvB1YjzZhZWFvrhQtlIDs6YxK62q9UGZNjbS+tndAWlXqtTBbVGm1cLxUGBqijQUw4sRcqaZF2lzvVe9trjfa0uCFMLEex6LTp1s9/BFeBKQiiMkyghgge6y1qu2Qtje7Mo5UFOAADgDAcBCJSr/aIP37WqOm+EnbGWVWFy+2OnEKJ16B4SjqSpv2eSdu1+812lAr7Wjq/csacKxmj5XmV0gzx1iNyeuuWikJSQFaEgLDRluXtHa3F8ysrpbe3Zf+O+0Y7/d5cbyV2RHjmJcE4MCsleravAqXLfXSlgajzfXS1gYpEsv8Qr8waFVVKk0vk8YXWR0/UVo2nYqYVAQxWUYQA2Tfvg6rrS2uYlYqDkiGszsAAAwLbV3SM+ukp94wyR7288qtVhxjdUwlgQwwVKyV9rR6ocuGvUbra6W363q3NJKkScVW88uleRVW8yukGWWELUCuauyQXqvpDmZ6hq0Bx/s9P2ai185sXoXk5zwpMKo1RxLVLd0VLlvqpebOzC/kgz4vcKkqlarKvK9nlElj87tf+zMjJjOCmCwjiAEGRmOn1dZmV5GYVBIkjAEAYDhpinhhzH+slzqi3nP00eOtPnuM1ZHjh3jjgFGgrUt6a2+82iXeYmxfe+/Xy0VBq7nlXrXL/Arv65LwEGwwgEFR2+rNl1kTD2Zq29KPC2G/1dHjvTZmiyulmWNoMwqMVB1RaVtDoq2YSbYX29uW+ZfeMVaTi6WqMml6qdX0Mu/rysIDz4ckiMmMICbLCGKAgdPSZbWl2VVrl1QWIowBAGC42dcm/Xyt0a83Sl2u9zx9/CSvQmb22CHeOGCEiLnStkZvtsu6eOiytaH3nAifsZoxxgtd5pV774KfVMxJVmC0slba2SytqZZWVRu9Vi019pgJVRTyKmUWVVotniBNKaG6Fcg1UVfa2dQduGyp977e1SxZZf6FHl9gvcAlHrpUlUlTiqVgP1sZEsRkRhCTZQQxwMBqi3qVMU2dUmlIcnhVCADAsLOnVfrZa0YvvN19cviUad4MmWmlQ7ttQK7Z1yat3yttiIcuG/cq2Qow1bgCq3kV0vx46DJ7rBRiFgSAPrjWOzm7utprZfZ6jdQeTT+2jM33ApnFlVaLKqXxhUO0sQB6ca20pyWlrVg8dNne2P2GqJ5Kw/HKllKvrdj0UmlaqVQQzO62EcRkRhCTZQQxwMDriHlhTH1EKg1KPt7WBwDAsLSzSXp0jdEfN3nvwHOM1ekzpOWLrCYWDfXWAcNPZ1R6e19Ki7FaaXdr79e6YX9Ki7FyL4AZmz8EGwxgxIi6XovD1dXSmhqjN3b3Ppk7qcgLZBLBTCmtDYFBUd+eeY5Lz/A0Ic/vVbVUlUrTy7rDl7K8wdlegpjMCGKyjCAGGBydMattLa72dngzY/yEMQAADFub66VHVhv9zzbv+dpnrM6aLX16oVVFwRBvHDBEEm2CNsRDl/W10qZ6KdrjxKeRV0k2v0KaV2E1v9x79+qB+rMDwOGIRKV1tV61zOpqrxqvZwvEGWXdwczR47P/rnpgtGnt9NqNbm6QttR3z3Fp6Mh8zsvvWE0t6THHpVQaVzi0rUgJYjIjiMkyghhg8ERdL4zZ0y4VBaSgjzAGAIDhbONe6eFVRv/Y5T1nBxyrf5onffIoO2jv0AOGSlPEC102xNuMrd8rNUd6v34tDXutxeZXeJ/njOXkJoCh19oprd3dHcxsqk8/fjnGas5Y6ZiJ0qIJVkeMoz0i0JfOmNdCbEu8pdjmeu/rTFWwkvemjIlF3gwXr9LFC10mFUv+YZh1EMRkRhCTZQQxwOCKWaudLVY1bVb5ASlEGAMAwLC3drcXyLy+23veDvutPrZA+sQRVkWhId44IAuirrRpX/dsl/W10o6m3q9TA47V7LHyZrvEq13GFzIcG8Dw19AhramW1sSDmZ3N6QeugOOFMYsqrY6plOaUD88TxsBAirlSdUs8cEmZ47KjqXeFWUJ5vo23FOsOXKaWSuEcCjYJYjIjiMkyghhg8LnWqrrVamebVdgn5fn5yxUAgOHOWunVXdJDq4zeqvOeuwuDVp84wgtl8gJDvIHAQbJW2tPaXemyrlZ6u07qjPV+TTqpyCZbjM2rkGaWSQHfEGw0AGTZ7hbptRppVTyYqWtLPwbm+a2OnuC1MVtc6Z1kpsM4Rgprpbo2r8WoN7/FaHOD12Ys0+sByXvdm2gllpjjMq1UKh4Bb0oiiMmMICbLCGKAoWGt1e42qx2tVn5HKgjwig4AgFxgrfTXbdLDq422NHjP36VhqwuOsvqnubQ1wfDT3uW12VtfK23Ya7ShVqpr7/3aszBoNa+8e7bLvHKphMHWAEYBa713/K+u9lqZranp3YqxOGS1KCWYmVRMNSByQ1Mk0VIsfY5LS2fmHTjk82a9JSpcqsq8r8fmjdx9niAmM4KYLCOIAYbW3nZvboyVVBwcoc9oAACMQDFX+tMW6dHVJtnepDzf6tNHW505m6oBDI2Y6/VwX18rrY+HLlsaercT8RmrGWMUD168qpdJxbzbGwAkybVeu8bV1dLqGqO1NVJ7NP0AWZFvtaiyO5ipKBiijQXiOqJeRUvaHJeG3tVeCY6xmlLSXeGSaC82oVDyjbI8giAmM4KYLCOIAYZefcRqa7OrLlcqCUpmpL7FAACAESjqSv/5jvToa0a18YGlEwqtli+yOmPG6PtDFoOrvr270mV9rVf50tbV+7VkRYEXtswv91qMzR6bW73bAWAoRV3v+JqomFm3R+py04+1k4q9QGZxpVc5Q0UhBkrUlXY2xduK1RttafDmuVQ3S1aZzydNKPSCFq+6xWp6qTS5RAryxiFJBDF9IYjJMoIYYHho6vTCmPaYVEoYAwBAzumMSb95S3riNaP6Du95fGqJ1cWLrU6eRqUBDl9nVHpnX7zapdZow16ppqX3jhX2W80t7652mVchlecPwQYDwAjVEZXe3COtic+Xeauud+XhzDKrxROlRRO8WTP5zJLDIXKtN8soEbRsiVe5bG+Uom7mF5alYW92y/RSqaqsO3xh/9s/gpjMCGKyjCAGGD5au6y2NLtq6ZJKQ5JDGAMAQM5p75Ke2yA9udaoOd57e9YYqxXHWB0/aeT21kZ2WSvtak4PXd7d1/vEi5HXx31eRbzFWLk3OJdKLAAYPC2d0us1XjCzqlrJGXIJjvHmbiUqZhZUSEGqEhFnrdTQ4YUtqYHL1obeLfES8gMpFS7xOS5VpVJZ3mBu+chBEJMZQUyWEcQAw0t71KuMaeyUSkKSj7M1AADkpJZO6ZdvGj39Zvcf0UeMs1qx2OspD6Rqjkgb9kobUoKXpkjv14Gl4XiLsQrvpN7ccqkgOAQbDADoU327tKbGa2O2plra1Zx+PA/6rI4Y1z1fZs5YAvTRorXTC1g2xQOXLfHwpTHDc74kBRyrqSWKBy3xapcyaVwBb+7JJoKYzAhisowgBhh+IjGrbc2u9nVIxSHJTy8TAAByVmOH9OQbRs+tlyIx7zl9caXVZ4/xTqhj9Im63kmXZLVLrbS9qffrvYBjNXtsvNql3Ntfxhdy4gUAcs3ulu75Mmuqpbr29AN5fsBq4QSvjdniSu+kO6cBcltnVNrWmGgrZrS5QdpSL+1pzfwfa2Q1sdhrKTa9rLut2ORiQrrBQBCTGUFMlhHEAMNTl+uFMbUdUnFQCvAqDACAnFbXJj3xutFv3upuL3XiFG+GzMwxQ7xxGDDWSrVt3ZUu62ult+u6Q7lUk4psssXYvAppZpkUYIguAIwo1nozPlZXS6trjF6rVrKVaUJp2AtmEhUzE4sI4YermCtVN0ubG+JtxeqNtjRIO5p6zw1KKM/3KluqSqXpZd7XU0qkMO3qhgxBTGY5HcTcd999uvPOO1VTU6OFCxfq3nvv1fHHH9/n+g0NDfqXf/kXPfPMM9q3b5+mTZume+65Rx/60If6fZs9EcQAw1fUtdrRalXTZlUYkEI+XnkBAJDrapqlx14z+s93u/9AP63K6qLFVlNKhnjjcNjau6SNexNtxrzgpec7nyWpMGg1t1xaUCHNi7cZKwkPwQYDAIZUzPXaVK2q9mbMrN0tdfSYCzKuwCbnyyyqlMrzh2hjRzFrpb1t8TkuDd2By9YGqTPDmyskqSgYD1xS2opVlUpFoUHccBwUgpjMcjaIefLJJ7V8+XLdf//9OuGEE3TPPffoF7/4hTZu3Khx48b1Wr+zs1NLly7VuHHjdOONN2rSpEnaunWrSktLtXDhwn7dZiYEMcDw5lqrna1W1a1WeX4p7CeMAQBgJNjeKD2y2uhPW7zndsdYfWCm9JmFVhOKhnjjcFBcK21rkNbv7W4xtqWh9ztgHeNVPc0r96pd5ldIk4ppOwMA6K0r5oX5a+KtzNbVdlfSJkwt8QKZRRO8z8Wc2M+qxg7v+XxLvbS5wcQrXaTWrsxP3CGf1bRSxee3eC3FqsqksXlUMuUKgpjMcjaIOeGEE3Tcccfphz/8oSTJdV1NmTJFV155pb72ta/1Wv/+++/XnXfeqQ0bNigQCGTlNjMhiAGGP2utqtu8QCbok/IJYwAAGDHe3SetXG308nbv+d3vWH1ojvSpoy3veB1m6tu9k2OJFmMb90ptGU7KVBRYzS/3Kl3mV0izx9JuBADQPx1R6Y3dXiizulp6Z1964G/khf2Jipmjxkt5mU8joof2LmlrYzxwiVe4bKnPXMkqeW+smFLizXGpKrPJeS7jC5njkusIYjLLySCms7NT+fn5evrpp3XOOeckl1900UVqaGjQc8891+s6H/rQhzRmzBjl5+frueeeU0VFhT71qU/p+uuvl8/n69dtSlIkElEkEkl+39TUpClTphDEAMOctVa1HdL2ZleOIxUGCGMAABhJ1tdKD68yWlXtPccHfVYfnSddcJSlZdUQ6Ix6J7vW10ob9nrBS01L79dfYb/VnLHS/JTZLgRoAICB0hyRXo8HM2uqpS0N6c9NPuM9FyWCmfkVUnCUzxuLutKOxkRbMaMt9V7FS3WzZJX53MqEwvQ5LlVl0uRifpYjFUFMZocSxAyb9xzt3btXsVhM48ePT1s+fvx4bdiwIeN1Nm3apD/+8Y/69Kc/reeff17vvPOOLr/8cnV1demmm27q121K0m233aabb7758B8UgEFljNG4PMlnHG1rdtXUaVUU8JYDAIDcN79CumOZ1Zpqq4dXG725x+gXb0q/eUv6+ALp40dYFQaHeitHJmulXc3ShlppfTx0eXdf71YwRlZTS73/q3nl3smtqlLeBQsAGDxFIWnpVGnpVO+95/varNbUdFfM1LQYvblHenOP9LPXjEI+qyPHe23MFk+UZo8Zuc9brpVqWpQMWjbXe23FdjT1fk5PKAt7IYtX3eJ9Pa1UyqeqCDgkwyaI6Q/XdTVu3Dj95Cc/kc/n05IlS7Rz507deeeduummm/p9uzfccIOuueaa5PeJihgAuWFs2MhnHG1tcdXYKZUELWEMAAAjyKJK6Z4JVn/fafXwKqN39hk99pr0H+ul84/yqmRoOXJ4WiKJFmNe8LKhVmqK9H49VRq2aaHLnHIRhgEAhpUx+dLpM6TTZ3jBTHWz9ebL1HgVM/vajV7dJb26y0irpIKA1dETpGMqvfkyVaW5N8fEWq9d6OaG7jkuifClI5r5weQHbLy6pbutWFWZVErVMZAVwyaIKS8vl8/n0+7du9OW7969WxMmTMh4ncrKSgUCAfl83TVv8+fPV01NjTo7O/t1m5IUCoUUCjHFC8hlpaHuMKY+IpWFCGMAABhJjJFOmCwdN8nqf7ZarVxttK3R6P++avTLN60+dbTVh+fSHuNgxFxpU328xVh8tsv2pt6vmwKO1axEi7Fyr63LhMLcOzkFABjdKou8j7PmWFkrbWu0WlUtrak2eq1Gauk0enm7krPpSsM22cZsUaU0sWiIH0APLZ3S1oZ4W7H4HJfN9ZnfQCF5z+dTS1PmuMTbi40r4DkdGEjDJogJBoNasmSJXnzxxeQ8F9d19eKLL+qKK67IeJ2lS5fqiSeekOu6chyvZvCtt95SZWWlgkHvbViHepsARo6ioNGMIkdbmr0wpjRk5fCqAgCAEcUx0nurvPYjf9xs9egao+pmo/v+bvTUm1afWWj1wVmSf4S2GOmP2tZ4pUs8dHm7TorEer9GmlgUr3ap8D7PLJMCBFsAgBHEGK/N1rRS6f/Mt4q50jv7vIqZVdVGb+yWGjqMXtosvbTZe66cUOgFMosneJ/HDtLcs86otLXRq2rZUm+0ucELXGpbM5/ncIzVxCKltxUrlSYVj9zWa8BwZqy1dqg3IuHJJ5/URRddpAceeEDHH3+87rnnHj311FPasGGDxo8fr+XLl2vSpEm67bbbJEnbt2/XEUccoYsuukhXXnml3n77bX32s5/VVVddpX/5l385qNs8GIcydAfA8NMRtdra4qohIpUEJZ9DGAMAwEgVdaUX3vZ6vu9t857zJxVZLV9s9b7pXnAzmrR3SW/VxWe71Bqt3yvVtfX+IRQGreaWx6tdKqzmlUsltCIBAIxynTHvOXR1tdGaGu+NDD1nqUwt6a6YWTjBm1FzOGKuN5dtc8ocly310s5mybWZX8hU5MfnuJRJVaVelcvUEik0bN6Cj1zXELEal2c0rYgUL9Wh5AbD6tfx/PPPV21trb75zW+qpqZGixYt0gsvvJAMTLZt25asfJGkKVOm6He/+52+/OUv6+ijj9akSZP0pS99Sddff/1B3yaAkS/sN5pe5GirXNVFvJkx/tF2FgYAgFHC70hnz5U+ONPqVxutfr7WaGez0W3/bfTvr1utWGx10tSR2XrDtdL2RmldvMXYhlqvN3zPkzaOsZpRJs2rkBbEQ5fJJaMvpAIA4ECCPunoCdLRE6wukvcGhzf2WC+YqfaqSrc1Gm1rlJ7bYGRkNXusN89ucaXVkeP6nltnrVTbFp/hkjLHZWuD1OVmflIuCtl4dUt34FJVKhUyYQEY9oZVRcxwRUUMMDJEXattLa72tElFQSno42wDAAAjXXuX9Mw66ak3jFq7vOf+OWOtVhxjdezE3A5k6tulDXu9SpcNtd7XbV29H1BFfnqLsdljpfCwekseAAC5qSkivV7jVcysrvZCmVR+x3vuXTRBmltuVdPS3VZsS72Sr016CvutppV6Icv0lDkuY/Jy+7ULchcVMZkdSm5AEHMQCGKAkSPmWu1otappsyoISCHCGAAARoXmiPSLN42eWSd1RL3n/6PGW332GKujcqBYvjMmvVPXHbysr5VqWnq/jgn7reaMTWkxViGVD1LvegAARru6NmlNtbS6xmj1Lml3H/NbEnzGakpJd+CSmOcyoYhKVQwvBDGZEcRkGUEMMLK41qq61WpXq5Xf57Uw8Rnvw+GtJQAAjGj17dLP1xr9akN3249jJ3oVMnPLh3jj4qyVqpul9SnVLu/s692T3shqaqk0r9wLXeZXeCdyGMALAMDQs1aqbokHM9VGm+ulyqL0tmKTi6WAb6i3FDgwgpjMCGKyjCAGGHmstdrTblXbbhW1Xk/1WPxzgjHdAY0X0nR/NgQ2AADktNpW6fHXjH77thSLz1A5earVRYu9EyODqSXiVbqkthlrjPR+rVEajrcYK/cqXeaWS4XBwd1WAAAAjD4EMZkRxGQZQQwwcllrFbNS1JWiic/xryMxq86YVWf8e9ftDmsSB07TI6RJ/ZqwBgCA4W9Xs/TYGqMXN3lD7Y2s3jdDumiR1aQBeOkfc6VN9dKG2njosrd3P3lJCjhWs8ZK88u7W4xNKKQvPAAAAAYfQUxmBDFZRhADIOba7qAmJbDpcq06YlZdrtSVCGpcKSavDFmSjLxwxnF6V9jQCg0AgOFha4P0yGqj/97qPTc7xmrZLOnChVbjC/t/u7Wt0vqU0OXtuu4ZNakmFnlhy/wKq/nl0owxUpBWJQAAABgGCGIyI4jJMoIYAAfDtTatoibxuSteVROJBzYx670b1lV6KzSnR2WNz2FuDQAAg+3tOunh1UZ/3+E9/wYcq7PnSp862qosb//Xbe/yrr++Vlq/12sxtret9/N4QSARunS3GSsND8SjAQAAAA4fQUxmBDFZRhADIFustb1aoHmfrTqjUsS16ox5FTUxt++5NWmBDXNrAADIujf3SA+tMnqtxnt+DfutzpkvnXekVXHIe37e3uiFLhtqjdbXSpsbvPZmqRxjNaNMXvBS7s14mVziPXcDAAAAuYAgJjOCmCwjiAEwmDLOrbHdrdAiMatIrLuypufcGqm7mqZnaENYAwDAwbNWWl3tBTIb9nrPofkBqzljpbfqpLau3s+rFfkpLcYqpNljpbB/sLccAAAAyB6CmMwOJTfgTwIAGGaMMfIbyZ/xua37hE8sUyu0eFjT6XphTWJ2TSQ5t8bKyAttkiGNkx7Y0AoNAACPMdIxE6XFlVZ/22H18CqjTfVGa2q8y8N+L5SZXyHNi892KS8Y2m0GAAAAMPwQxABAjvIZI59PCvUa5NsdpCTn1vRqh+YFNZ3x+TXRlMoaN14oaeSdgOo5t8YxkiOqawAAo4cx0olTpBMmW72yw2pfuzSvXKoq9Z4bAQAAAGB/CGIAYARzjFHQJwV7XdIdoqTNrYm3O+uKBzNeG7TuuTVd0dS5NV51jZhbAwAYJZx4IAMAAAAAh4IgBgBGOWOMAkYK7KcVWnJuTUplTcwmWp91hzVRKy+0Sc6tSWmF5vQOa5hbAwAAAAAAgJGOIAYAcEDJuTWStJ9WaIm5NTFX6kqprom6VhHXq7Dpigc5EVdy5YU8Nn59p0cLtO7qGsIaAAAAAAAA5CaCGABA1iTm1uwvrEnMrYlZ9Zhf482tibjxVmiJMMf2DmucHi3QaIUG5BabmEXF7ywAAAAAYBQgiAEADKrE3Jrees+tibnp7dCi8bk1nTGrzsRl8ZZoNj63xsobqtxzbo1DKzRgvxKBp5X3+2STy9OX2YNYJinZljD16+Rn460X8lkVBPidBAAAAACMbAQxAIBh52Dm1khSzLXJFmipgU2Xa9URb4PW5UqdruTGq3CSYY0kJ8PcGodWaBhmkgHJwQYh6g5DMi1LDUhSvzfyAhJJcuIXJD4nLjPxyxK/O90VaUa+xHJJPse7ISdxndTP8a87YtLOVlcNEaviIL93AAAAAICRiyAGAJCzfI538vdgWqGltUGzUlfMm1vTmWFujWu7T1Ontj5LzK9hbg0yVY+khh7KYvVIPNPwwhB1BxnGpIcjJjFfSakhiekOR+IVYamBiJNye07K7Topt+/0XKbsVJYVS8r3O9re4qq+QyoKWgV9/F4BAAAAAEYeghgAwIiWaIXWux1a71ZovQMbq86o1OFadcWkmKSuqFdZkxrWJFqhZWqHRiu0wZOYO3KobbT6CkekvgMSaf/VI4nwJFklYlI/uqtHEqFezwAkNRTpVVGSYR3verm3rxUGjGaVONrVarWnzarTtSqkVRkAAAAAYIQhiAEAjHp9t0JLD2titndlTaIVWiRmFYl5IU1nLBHWJBqhdZ84zxTY5OIJ9EOx39Za6jsUUYbLe1aLqMfXGatHMrTWMokQJH4dr5LEdFeUOJKRyRiAZKoo6bOyZIT/32ZDwDGaWijl+412trqq77AqCfGzAwAAAACMHAQxAAAcBGOM/EbyH8Tcmp5BTSKs6XS9sCYxuybielU2iUqOxEn8RDCQGthk+6R0tqtHUsOQ1O9N/JtkMKL0YETqDi66Z/T0aK3VI7TaX/VIr2Ckz4oSTvIPJ8YYVeTFW5W1uqqPSEUBWpUBAAAAAEYGghgAALIoMbcmdDBza3q1Q/OCms6YVWd8eaKypufcmsRHX4PZE6lIX9UjqUHIgapHerbW8hkTH8i+/+oRJ0MQkrF6JIdbayG7CgJGs4q9VmW7260irlWhn30DAAAAAJDbCGIAABhkybk1vS5Jb4WWWlkTi1fRxKzibdC8VmmJ1lpmP9UjmQaz91U9MlCD2YGD5XeMphR6ocyOVlcNEak4ZOVjPwQAAAAA5CiCGAAAhqG+59ZIqYENMBIZYzQ2LOX5HO1odbUvIhUGrEK0KgMAAAAA5KCMp3cAAACAoZYfMJpR7GhSgVF7VGrqtMn5RgAAAAAA5AqCGAAAAAxbfsdocoHRzGJHQUeqj0gxlzAGAAAAAJA7aE0GAACAYc0YozFhKc/vaEeLq7oOqSBgFfbTqgwAAAAAMPxREQMAAICckOf3WpVNKTSKxGhVBgAAAADIDQQxAAAAyBk+x2hSoaNZJd2tyqK0KgMAAAAADGO0JgMAAEDOKQ0ZhX2OdrR6rcry/FZ5tCoDAAAAAAxDVMQAAAAgJ4X9RtPjrcq6YlIjrcoAAAAAAMMQQQwAAAByls8YTSxwNLPEUdgn7aNVGQAAAABgmKE1GQAAAHJeacgoz+9oZ4urWlqVAQAAAACGESpiAAAAMCKEfEZVxY6mFhpFXakxQqsyAAAAAMDQI4gBAADAiOEYo8oCR7NKHOX7pfqI1EWrMgAAAADAECKIAQAAwIhTHDSaWeKoIk9q7pTaooQxAAAAAIChQRADAACAESnkM6oqclRV5Mh1pYaIlUurMgAAAADAICOIAQAAwIjlGKPx+UazShwVBqT6DlqVAQAAAAAGF0EMAAAARryioNHMYkcT8o1aOqXWLsIYAAAAAMDgIIgBAADAqBD0GU0rMppe7L0Eru+gVRkAAAAAYOARxAAAAGDUMMaoIs9rVVYclOojUmeMMAYAAAAAMHAIYgAAADDqFAaMZpY4qsw3aotKLV1WluoYAAAAAMAAIIgBAADAqBRwjKYWeq3KHONVx9CqDAAAAACQbf6h3gAAAABgqBhjVB6W8nyOdrS6qo9IhQGrkM8M9aYBAAAAAEYIKmIAAAAw6hUEjGYWO5pUYNQelZo7aVUGAAAAAMgOghgAAABAkt8xmlzgBTJ+R2qISDGXMAYAAAAAcHgIYgAAAIA4Y4zGhI1mlTgqC3lhTCRGGAMAAAAA6D+CGAAAAKCHfL/R9GJHkwuNOqJSE63KAAAAAAD9RBADAAAAZOB3jCYVGM0scRR0pHpalQEAAAAA+sE/1BsAAAAADFfGGJWFpLDP0Y4WV/siUr7fKuw3Q71pAAAAAIAcQUUMAAAAcAB5fqMZJY6mFBp1xmhVBgAAAAA4eAQxAAAAwEHwGaOJBY5mljgK+bxWZVFalQEAAAAADoDWZAAAAMAhKA0Zhf2Odra42tsh5fmt8mhVBgAAAADoAxUxAAAAwCEK+4ymFzuaWmjU5UqNEVqVAQAAAAAyI4gBAAAA+sExRpUFjmaVOMrz06oMAAAAAJAZQQwAAABwGEqCRrNKHFXkSc2dUluUMAYAAAAA0I0gBgAAADhMIZ9RVZHXqsx1pYaIlUurMgAAAACACGIAAACArHCM0YQCRzNLHBXEW5V10aoMAAAAAEY9ghgAAAAgi4rjrcom5Bm1dEqtXYQxAAAAADCaEcQAAAAAWRb0GU0rMqoqdmRFqzIAAAAAGM0IYgAAAIABYIzRuDyj2SWOCgNSfYfUGSOMAQAAAIDRhiAGAAAAGECFAa9VWWWBUVuX1EKrMgAAAAAYVQhiAAAAgAEWcIymFnqtyoyk+g5alQEAAADAaEEQAwAAAAwCY4wq4q3KikNSfYRWZQAAAAAwGhDEAAAAAIOoIGA0s9jRxHyjtqjU3GVlqY4BAAAAgBGLIAYAAAAYZAHHaEqh0YxiRz4jNUSkGGEMAAAAAIxIwzKIue+++1RVVaVwOKwTTjhBf//73/tcd+XKlTLGpH2Ew+G0dS6++OJe65x55pkD/TAAAACAPhljNDZsNLvYUWnIC2MitCoDAAAAgBHHP9Qb0NOTTz6pa665Rvfff79OOOEE3XPPPVq2bJk2btyocePGZbxOcXGxNm7cmPzeGNNrnTPPPFMPP/xw8vtQKJT9jQcAAAAOUX7Aq4zJa7OqabOKxKyKAplf0wIAAAAAcs+wq4i56667dMkll2jFihVasGCB7r//fuXn5+uhhx7q8zrGGE2YMCH5MX78+F7rhEKhtHXKysoG8mEAAAAAB83vGE0u8GbHBB2pPiLFXKpjAAAAAGAkGFZBTGdnp1599VW9//3vTy5zHEfvf//79fLLL/d5vZaWFk2bNk1TpkzRRz/6Ub355pu91vnTn/6kcePGae7cufrCF76gurq6Pm8vEomoqakp7QMAAAAYSMYYjQkbzSpxNCbeqqwjShgDAAAAALluWAUxe/fuVSwW61XRMn78eNXU1GS8zty5c/XQQw/pueee089+9jO5rquTTjpJO3bsSK5z5pln6tFHH9WLL76o22+/Xf/1X/+ls846S7FYLONt3nbbbSopKUl+TJkyJXsPEgAAANiPPL/XqmxKoVEkJjV1WllLIAMAAAAAucrYYfRX3a5duzRp0iT99a9/1Yknnphc/tWvflX/9V//pVdeeeWAt9HV1aX58+frk5/8pG699daM62zatEkzZ87UH/7wB51xxhm9Lo9EIopEIsnvm5qaNGXKFDU2Nqq4uLgfjwwAAAA4NNZaNXZK21tctUWl4qDXwgwAAAAABlNDxGpcntG0omFV1zHkmpqaVFJSclC5wbD6yZWXl8vn82n37t1py3fv3q0JEyYc1G0EAgEtXrxY77zzTp/rzJgxQ+Xl5X2uEwqFVFxcnPYBAAAADCZjjEpDRrNLHI0NS02dUjutygAAAAAg5wyrICYYDGrJkiV68cUXk8tc19WLL76YViGzP7FYTGvXrlVlZWWf6+zYsUN1dXX7XQcAAAAYDsJ+o+nxVmVdMamRVmUAAAAAkFOGVRAjSddcc40efPBBPfLII1q/fr2+8IUvqLW1VStWrJAkLV++XDfccENy/VtuuUW///3vtWnTJq1atUoXXnihtm7dqs9//vOSpJaWFn3lK1/R3/72N23ZskUvvviiPvrRj2rWrFlatmzZkDxGAAAA4FD4jNHEAkczSxyFfdK+iBR1CWMAAAAAIBf4h3oDejr//PNVW1urb37zm6qpqdGiRYv0wgsvaPz48ZKkbdu2yXG686P6+npdcsklqqmpUVlZmZYsWaK//vWvWrBggSTJ5/Pp9ddf1yOPPKKGhgZNnDhRH/zgB3XrrbcqFAoNyWMEAAAA+qM0ZJTnd7SzxVVth5Tnt8rzMzcGAAAAAIYzY+lrcECHMnQHAAAAGGiutdrdZlXdZuVaqTjozZQBAAAAgGxriFiNyzOaVjTsGmwNqUPJDfjJAQAAADnGMUaVBY5mlTjK90v1EamLVmUAAAAAMCwRxAAAAAA5qjhoNLPEUUWe1NwptUUJYwAAAABguCGIAQAAAHJYyGdUVeSoqsiR63ptA1y6DwMAAADAsEEQAwAAAOQ4xxiNzzeaVeKoMCDVd9CqDAAAAACGC4IYAAAAYIQoChrNLHY0Id+opVNq7SKMAQAAAIChRhADAAAAjCBBn9G0IqPpxd5L/foOWpUBAAAAwFAiiAEAAABGGGOMKvK8VmXFQak+InXGCGMAAAAAYCgQxAAAAAAjVGHAaGaJo8p8o7ao1NJlZamOAQAAAIBBRRADAAAAjGABx2hqodeqzDFedQytygAAAABg8PiHegMAAAAADCxjjMrDUp7P0Y5WV/URqTBgFfKZod40AAAAABjxqIgBAAAARomCgNHMYkeTCozao1JzJ63KAAAAAGCgEcQAAAAAo4jfMZpc4AUyfkdqiEgxlzAGAAAAAAYKQQwAAAAwyhhjNCZsNKvEUVnIC2MiMcIYAAAAABgIBDEAAADAKJXvN5pe7GhyoVFHVGqiVRkAAAAAZB1BDAAAADCK+R2jSQVGM0scBR2pnlZlAAAAAJBV/qHeAAAAAABDyxijspAU9jna0eJqX0TK91uF/WaoNw0AAAAAch4VMQAAAAAkSXl+oxkljqYUGnXGaFUGAAAAANlAEAMAAAAgyWeMJhY4mlniKOTzWpVFaVUGAAAAAP1GazIAAAAAvZSGjMJ+RztbXO3tkPL8Vnm0KgMAAACAQ0ZFDAAAAICMwj6j6cWOphYadblSY4RWZQAAAABwqAhiAAAAAPTJMUaVBY5mlTjK89OqDAAAAAAOFUEMAAAAgAMqCRrNKnFUkSc1d0ptUcIYAAAAADgYBDEAAAAADkrIZ1RV5LUqc12pIWLl0qoMAAAAAPaLIAYAAADAQXOM0YQCRzNLHBXEW5V10aoMAAAAAPpEEAMAAADgkBXHW5VNyDNq6ZRauwhjAAAAACATghgAAAAA/RL0GU0rMqoqdmRFqzIAAAAAyIQgBgAAAEC/GWM0Ls9odomjwoBU3yF1xghjAAAAACCBIAYAAADAYSsMeK3KKguM2rqkFlqVAQAAAIAkghgAAAAAWRJwjKYWeq3KjKT6DlqVAQCyx7VWlucVAEAO8g/1BgAAAAAYOYwxqsiT8v2Otre6qo9IRQGroM8M9aYBAHKItVZdrtTpSl2u5FrJZyRrJSsrI8nnSH5HCjiS33jPQQAADEcEMQAAAACyriBgNLPYUXWr1e52q4hrVejnJBkAoDdrraLWC1w6Y17oYuQFLEGfNCZklO83CvkkK2+dSMyqLWrVEZM6olLUereTGtD4jffZ4bkHADDECGIAAAAADIiAYzSl0AtldrS6aohIxSErHyfEAGBUi7petUuXK8Vcb1misqU87IUuYb8U9klBp68Q31vmWqvOmFc5kwho2qNW7THv+7aokm0y/QQ0AIAhQhADAAAAYMAYYzQ2LOX5HO1odbUvIhUGrEK0KgOAUSFmrbriQUk0EboYKeCTSgJSYdBR2CeF4h+HGo44Jh7aJJekBDSukvedqKBpj3rfJwIaI8lJCWf8jnjDAAAg6whiAAAAAAy4/IDRjGJHeW1WNW1WnTGrwgCtygBgJHFtd6VLl+vNc3GM116sMCAV+o3y4i3Gwj7J5wzcc4BjjMLx+/F492XjAU2igqbLldqirtqi3tftqQGN8dqcJWbQDOT2AgBGNoIYAAAAAIPC7xhNLpAK/EY7W13VR6SSoOXEFgDkINsjdHHjoYvf8cKP8rBRns+rVgn5vHaVw4ExJll9o0BiqS/5eBIBTacrtUe9KpouV+pwveoeqftxJtqc+QxvLAAA7B9BDAAAAIBBY4zRmLCU53e0o8VVXYdUELAK+zmBBQDDlbVWMeuFE4m5LkZeEBH0SSVBo4KASbYY63uuy/BljFHQ5z2e7oDGpAVOiZAmEdAkKmtiVrKy3RU0JtHiLPd+DgCAgUEQAwAAAGDQ5fm9VmX5fqvqNqtO16qIVmUAMCzEXJsWulh1z3UpC0kFfifZ9ivkG9nH7tSApqB7qay1itru9maRmNQR6w5o2rqkqJWMrGTSZ9D4CWgAYNQhiAEAAAAwJHyO0cQCqSBgtL3Fa1VWHLTyD5P2NQAwGrgpLbmiMS908cVDl6KAVBgwCqe0GGOQvccYo4Dx5sekLJUkReNBVqLFWSRm1dpl4+3OEuGWlYm3NQsQ0ADAiEcQAwAAAGDIGGNUGpLCPkc7Wr1WZXl+qzxalQFA1qXOQelyJRuf6xJwpDyfVBQ2yvN7M1TCPhGM95PfMfI7Un7yrJv3c0xUGiVCmkQFTSQmdUSlaCKgkdfiLBHO+B3JIaABgJxGEAMAAABgyIX9RtMTrcpavVZlxbQqA4B+S7TO6nKlrpg3x8TIC12CPmlMyCjf3z3XJZCDc11yjc8xynOkvOSSeEBjrbpiUiRRRROzao1adcS8lmdtUa9ySUpvb0ZAAwC5gyAGAAAAwLDgM0YTC4zy/VY7Wl3ti0gltCoDgIMSdbuHykddJasqgo40Jhyf6xJvLxYidBlWfMbI55fCySXe/41rbbK9WacrRaJW7TGr9qgX2CQCGiPJSQlnAgQ0ADDsEMQAAAAAGFZKQ0Z5fkc7W1zV0qoMAHpJVFAkghfJmzUS9EklAakw6CTbi4V8nJTPVY7xZvNkCmi6esygaY9ZtXd5+0N7SgWNz6RX0fh4cwMADAmCGAAAAADDTshnVFXsKM9vVd1m1RixKg7yDm4Ao0/ipHui0sVNmeuS75eKAkbheIuxsI8T7aOBY7w5PiFfYon3f26tTc7/SYQ0bVGr9qi3D7W73jpW3j6UCGgCBDQAMOAIYgAAAAAMS44xqiwwKghY7WhxVR+RioJWAU4WARihEnNdOuPVLq6VTDx0CTlSedgoz2cU8nuhC8dDpDKpAU0guVQ2UUGTEtC0xwOaTtebTROLV9AkA5r4Z5/hTRAAkA0EMQAAAACGteKg0cwSRztbXdW2S2G/VT6tygDkOGutYlbJCoZYvMVYID7XpSRsVBAwyRZjQea6oJ+MMQr6vNZ1PQOaRPCXCGk6olZtMS+gaeuSolaSrExKQBMgoAGAQ0YQAwAAAGDYC/mMqoocFfitdrVaNcRblTH3AECuiLndVQmxlLkuAZ9UGpQKA06yvViQuS4YBMYYBeLBSkH3UklS1LXdAU1KBU0kHtDErGQTAU2POTQENADQG0EMAAAAgJzgGKPx+Ub5fqsdra7qO6TiEK3KAAw/bkorqGhMyZkcQZ9UFJAKA0ZhnzfXJeSXfJy4xjDjd4z8jpSfXJIS0KS0OIvErNqiVpGY1B71QkYrKyPJl5hBQ0ADAAQxAAAAAHJLUdBops/RrlarPe1WQZ9VQYCTOwCGRmL+RuLDtV7oEnCkPJ9UGDbK85tktYuf8Bg5LBnQJM8oevtzLBHQxEOaREDTEZM6ol6LM2vTA5pEJQ3VXwBGA4IYAAAAADkn6DOaViQVBIx2trqq77AqCXEyB8DASszU6HKlrpjXnsnIC10CPqksaJSfMtclwFwXjBI+xyjPkfKSS+IBjbXqimUOaDpjUlvUqyCTvFDGFw8xCWgAjDQEMQAAAABykjFGFXlSnt/RjhZX9RGpKGAV9HHiBkB2RN3uapdofK6LP95ibExYKvA7Xujil0KELkAvPmPk80vh5BLvd8S13S3OulJanLVHvdAmEdAYSY6TPoeGVn4AchFBDAAAAICcVhgwmlnS3aqs07Uq8HNCFMChSZwY7oqfGJa8d+enznVJtBgL+Xi3PnA4HNPdrs/j/T5Zm97irNO1ao9atUW938v21IDGeG3OEjNofLT9AzCMEcQAAAAAyHkBx2hqYUqrsohUGrKcKAWQUWKuS2e82sWmzHXJ90tFAaNwSujCXBdgcBjjtfYL+SQFpNSApistoFE8oPGWd7heGzTJ+132p8yh8RnenAFg6BHEAAAAABgRjDEqD0t5Pkc74mFMYcAqRKsyYFRLzHVJtEByE3NdfF47sTEho/x46BL2e8EugOHFGKOgz6tQ8wIaSTLJgCYR0kRiUkc8oOl0pUj8d97KdlfQmO55NAQ0AAYLQQwAAACAEaUgYDSz2FF1m1VNm1VnzKowwMkWYLTINNclEG9fVBI2Kgh477gP+6Qgc12AnJYa0BR0L+0VwEZiUkesO6Bp65KiVjLykll/jyoajgsAso0gBgAAAMCI43eMJhdI+X6vVVlDRCoOWvrHAyNMzO1uV5QIXfzGq3YpCUqFASfZXoy5LsDoYYxRIN5uMGWpJC+sTW1xFolZtXZ5y9q7pFi8gsbE25oFCGgAZAFBDAAAAIARyRijsWEpz+9oZ4urug6pMEirMiBXuSktiLpikpU3CyLokwoDUqHfKC8x18Uv+ThhCiADv2Pkj8+D8njHilgioImHNIkKGq/dmRf2WlkZeS3OEuGM3yHkBXBgBDEAAAAARrR8v9H0Ykd5fq9VWSRmVUSrMmBYS537kJjrkhjAHfZJ5eGU0MXHXBcAh8/nGOU5Ul5ySTygsTZZPdMZkzpjVq1Rq46Y1/KsLeoFxVJ6ezMCGgCpCGIAAAAAjHh+x2hSgTc/ZkeLq/qIVEKrMmBYSMxySIQuMdc7/RlwvBZjZUGjvIAXuoR93nKCVACDxWeM8vy9Axo3NaBxpUjUqj1m1R71AptEQGMkOfFw5mBedthD3D57CFc45Ns+xBs51Nvv123YjF9m57Z7rn+AK5iDuM2e/+Wp65sMN9Dz9vZ3/YO5/FDs77bcw7hdeAhiAAAAAIwKxhiVhaSwz9GOFld1EanAbxX2c0IXGEyJ9j9dGea6lIWkQr+jUDx0CfkIXQAMT44xCvulcHJJd0DT1WMGTXvMqr3r4E5mmz6+7nPdPlbKdOg0Pb45qNvva1vMfr/tff2DOJQ7PTfwEG6/1/cZrrC/IOygbt/0fVnPheaAP92D24a+7v9Qr9trnYP4/+t5eR5JwmHhxwcAAABgVMnzG80ocVTQZlXdatXp0qoMGCipJyS9+Qrx4dc+qSggFQa8FmOJ4IU2PgBynWO8Y1rIl1jiHdestWlBzP6Odgd1Up3jJZBTCGIAAAAAjDo+YzSxwCjfb7Wj1WtVVhy08tOqDOi3xFyXRLWLjc91CcSHYidCl0SlC79vAEYTY4x8B14NwAhFEAMAAABg1CoNGYV9jna2utrbIeX5rfJoVQYcUOpcl86Y5NruuS5BnzQmZJSfEroEffxeAQCA0YsgBgAAAMCoFvYbTS92lO+32tVm1RmxKg7S8gNIFXW9apcuV4ol5ro4XvBSHo6HLn6vvVjQ4fcHAAAgFUEMAAAAgFHPMUaVBUb5AasdLbQqw+gWs1ZdMSWDF0nyx+e6lASkwqCTrHQJMdcFAADggAhiAAAAACCuJGgULom3KmuXQn6rfFqVYQRzbXelS8+5LgUBqdDvzXUJ+bxqFx/hJAAAwCEjiAEAAACAFCGfUVWRo3yfVXWbVUO8VRnv+sdwY631Pqcui//Ta5m8kEXqDl3ceOjid7yQpTxslOfzWoyFfFKA0AUAACArhmUQc9999+nOO+9UTU2NFi5cqHvvvVfHH398xnVXrlypFStWpC0LhULq6OhIfm+t1U033aQHH3xQDQ0NWrp0qX784x9r9uzZA/o4AAAAAOQmxxhNyNCqjBPTw0vGICL+zf6CiLRlKd/YHpdlur1M66vHZX3djokvS/2sHssSeq6jHusmVup5uenxOXUdE/8n4HjVXwUBk2wxxlwXAACAgTPsgpgnn3xS11xzje6//36dcMIJuueee7Rs2TJt3LhR48aNy3id4uJibdy4Mfl9zxePd9xxh37wgx/okUce0fTp0/WNb3xDy5Yt07p16xQOhwf08QAAAADIXcVBo1kljna1Wu1ptwr6rAoCw+NktU1JFYZDEGFTvtjf7Uj9CyIyBRj9CiIyXM/0/D7lQyZ+uem93IlfV/IqSyTjLUtcnnodk3J78XtLbleGsMT0uLzn+qnb2fMxZlqW+j2hCwAAwOAyNvXV+zBwwgkn6LjjjtMPf/hDSZLrupoyZYquvPJKfe1rX+u1/sqVK3X11VeroaEh4+1ZazVx4kRde+21uu666yRJjY2NGj9+vFauXKkLLrjggNvU1NSkkpISNTY2qri4uP8PDgAAAEBOcq3V3g5pZ6urrpjXykkauUFEYt20oGAEBREHf7+EFQAAAMjsUHKDYVUR09nZqVdffVU33HBDcpnjOHr/+9+vl19+uc/rtbS0aNq0aXJdV8ccc4y+/e1v64gjjpAkbd68WTU1NXr/+9+fXL+kpEQnnHCCXn755YxBTCQSUSQSSX7f1NSUjYcHAAAAIEc5xmhcnpTvd1TT6ioWT0MIIgAAAAAcyLAKYvbu3atYLKbx48enLR8/frw2bNiQ8Tpz587VQw89pKOPPlqNjY367ne/q5NOOklvvvmmJk+erJqamuRt9LzNxGU93Xbbbbr55puz8IgAAAAAjCSFAaNZpb6h3gwAAAAAOcQZ6g04XCeeeKKWL1+uRYsW6dRTT9UzzzyjiooKPfDAA/2+zRtuuEGNjY3Jj+3bt2dxiwEAAAAAAAAAwGgxrIKY8vJy+Xw+7d69O2357t27NWHChIO6jUAgoMWLF+udd96RpOT1DuU2Q6GQiouL0z4AAAAAAAAAAAAO1bAKYoLBoJYsWaIXX3wxucx1Xb344os68cQTD+o2YrGY1q5dq8rKSknS9OnTNWHChLTbbGpq0iuvvHLQtwkAAAAAAAAAANAfw2pGjCRdc801uuiii3Tsscfq+OOP1z333KPW1latWLFCkrR8+XJNmjRJt912myTplltu0Xve8x7NmjVLDQ0NuvPOO7V161Z9/vOfl+QNl7z66qv1b//2b5o9e7amT5+ub3zjG5o4caLOOeecoXqYAAAAAAAAAABgFBh2Qcz555+v2tpaffOb31RNTY0WLVqkF154QePHj5ckbdu2TY7TXchTX1+vSy65RDU1NSorK9OSJUv017/+VQsWLEiu89WvflWtra269NJL1dDQoJNPPlkvvPCCwuHwoD8+AAAAAAAAAAAwehhrrR3qjRjumpqaVFJSosbGRubFAAAAAAAAAAAwyh1KbjCsZsQAAAAAAAAAAACMJAQxAAAAAAAAAAAAA4QgBgAAAAAAAAAAYIAQxAAAAAAAAAAAAAwQghgAAAAAAAAAAIABQhADAAAAAAAAAAAwQAhiAAAAAAAAAAAABghBDAAAAAAAAAAAwAAhiAEAAAAAAAAAABggBDEAAAAAAAAAAAADhCAGAAAAAAAAAABggBDEAAAAAAAAAAAADBCCGAAAAAAAAAAAgAFCEAMAAAAAAAAAADBACGIAAAAAAAAAAAAGCEEMAAAAAAAAAADAACGIAQAAAAAAAAAAGCAEMQAAAAAAAAAAAAOEIAYAAAAAAAAAAGCA+Id6A3KBtVaS1NTUNMRbAgAAAAAAAAAAhloiL0jkB/tDEHMQmpubJUlTpkwZ4i0BAAAAAAAAAADDRXNzs0pKSva7jrEHE9eMcq7rateuXSoqKpIxZqg3Z9hoamrSlClTtH37dhUXFw/15gCHjH0YuYz9F7mM/Re5jP0XuYz9F7mM/Re5jP0XuY59ODNrrZqbmzVx4kQ5zv6nwFARcxAcx9HkyZOHejOGreLiYn4BkdPYh5HL2H+Ry9h/kcvYf5HL2H+Ry9h/kcvYf5Hr2Id7O1AlTML+YxoAAAAAAAAAAAD0G0EMAAAAAAAAAADAACGIQb+FQiHddNNNCoVCQ70pQL+wDyOXsf8il7H/Ipex/yKXsf8il7H/Ipex/yLXsQ8fPmOttUO9EQAAAAAAAAAAACMRFTEAAAAAAAAAAAADhCAGAAAAAAAAAABggBDEAAAAAAAAAAAADBCCGAAAAAAAAAAAgAFCEDPKRSIRXX/99Zo4caLy8vJ0wgkn6D//8z8P6ro7d+7Ueeedp9LSUhUXF+ujH/2oNm3alHHdn/70p5o/f77C4bBmz56te++9N5sPA6PUYOy/xpiMH9/5zney/XAwyvR3/924caO+/OUv66STTlI4HJYxRlu2bOlz/V/96lc65phjFA6HNXXqVN10002KRqNZfCQYrQZjH66qqsp4DP7nf/7nLD8ajDb93X+feeYZnX/++ZoxY4by8/M1d+5cXXvttWpoaMi4PsdgDITB2H85/mKg9Hf/ffbZZ7Vs2TJNnDhRoVBIkydP1rnnnqs33ngj4/ocfzEQBmP/5fiLgXI459BSfeADH5AxRldccUXGyzkH3Df/UG8AhtbFF1+sp59+WldffbVmz56tlStX6kMf+pBeeuklnXzyyX1er6WlRe973/vU2NioG2+8UYFAQHfffbdOPfVUrVmzRmPHjk2u+8ADD+if//mf9fGPf1zXXHON/vznP+uqq65SW1ubrr/++sF4mBihBmP/lbwnmeXLl6ctW7x48YA8Jowe/d1/X375Zf3gBz/QggULNH/+fK1Zs6bPdX/729/qnHPO0WmnnaZ7771Xa9eu1b/9279pz549+vGPfzwAjwqjyWDsw5K0aNEiXXvttWnL5syZk42HgFGsv/vvpZdeqokTJ+rCCy/U1KlTtXbtWv3whz/U888/r1WrVikvLy+5LsdgDJTB2H8ljr8YGP3df9euXauysjJ96UtfUnl5uWpqavTQQw/p+OOP18svv6yFCxcm1+X4i4EyGPuvxPEXA6O/+2+qZ555Ri+//HKfl3MO+AAsRq1XXnnFSrJ33nlncll7e7udOXOmPfHEE/d73dtvv91Ksn//+9+Ty9avX299Pp+94YYbksva2trs2LFj7Yc//OG063/605+2BQUFdt++fVl6NBhtBmP/tdZaSfaLX/xidjceo97h7L91dXW2qanJWmvtnXfeaSXZzZs3Z1x3wYIFduHChbarqyu57F/+5V+sMcauX7/+8B8IRq3B2oenTZvW6zUEcLgOZ/996aWXei175JFHrCT74IMPpi3nGIyBMFj7L8dfDITD2X8zqampsX6/31522WVpyzn+YiAM1v7L8RcDIRv7b3t7u62qqrK33HJLxnNlnAM+MFqTjWJPP/20fD6fLr300uSycDisz33uc3r55Ze1ffv2/V73uOOO03HHHZdcNm/ePJ1xxhl66qmnksteeukl1dXV6fLLL0+7/he/+EW1trbqN7/5TRYfEUaTwdh/U7W3t6ujoyN7DwCj2uHsv2PGjFFRUdEB72PdunVat26dLr30Uvn93QWwl19+uay1evrppw/vQWBUG4x9OFVnZ6daW1v7vb1AqsPZf0877bRey/7P//k/kqT169cnl3EMxkAZjP03FcdfZNPh7L+ZjBs3Tvn5+Wnt9Tj+YqAMxv6biuMvsikb++8dd9wh13V13XXXZbycc8AHRhAziq1evVpz5sxRcXFx2vLjjz9ekvpsFeK6rl5//XUde+yxvS47/vjj9e6776q5uTl5H5J6rbtkyRI5jpO8HDhUg7H/JqxcuVIFBQXKy8vTggUL9MQTT2TnQWDU6u/+e6j3IfU+/k6cOFGTJ0/m+IvDMhj7cMIf//hH5efnq7CwUFVVVfr+97+ftdvG6JTt/bempkaSVF5ennYfEsdgZN9g7L8JHH+RbdnYfxsaGlRbW6u1a9fq85//vJqamnTGGWek3YfE8RfZNxj7bwLHX2Tb4e6/27Zt03e+8x3dfvvtvVqZpt6HxDng/WFGzChWXV2tysrKXssTy3bt2pXxevv27VMkEjngdefOnavq6mr5fD6NGzcubb1gMKixY8f2eR/AgQzG/itJJ510ks477zxNnz5du3bt0n333adPf/rTamxs1Be+8IVsPRyMMv3dfw/1PlJvs+f9cPzF4RiMfViSjj76aJ188smaO3eu6urqtHLlSl199dXatWuXbr/99qzcB0afbO+/t99+u3w+n84999y0+0i9zZ73wzEY/TUY+6/E8RcDIxv773ve8x5t3LhRklRYWKivf/3r+tznPpd2H6m32fN+OP6ivwZj/5U4/mJgHO7+e+2112rx4sW64IIL9nsfnAPeP4KYUay9vV2hUKjX8nA4nLy8r+tJOqjrtre3KxgMZrydcDjc530ABzIY+68k/eUvf0lb57Of/ayWLFmiG2+8URdffHGf7wQA9qe/+++h3ofU977e1NR02PeB0Wsw9mFJ+tWvfpX2/YoVK3TWWWfprrvu0pVXXqnJkydn5X4wumRz/33iiSf005/+VF/96lc1e/bstPuQOAYj+wZj/5U4/mJgZGP/ffjhh9XU1KRNmzbp4YcfVnt7u2KxmBzHSbsNjr/ItsHYfyWOvxgYh7P/vvTSS/rlL3+pV1555YD3wTng/aM12SiWl5enSCTSa3liDkZfJ5gTyw/munl5eers7Mx4Ox0dHZzERr8Nxv6bSTAY1BVXXKGGhga9+uqrh7zdgNT//fdQ70Pqe1/n+IvDMRj7cCbGGH35y19WNBrVn/70pwG5D4x82dp///znP+tzn/ucli1bpm9961u97kPiGIzsG4z9NxOOv8iGbOy/J554opYtW6YvfOEL+t3vfqef/exnuuGGG9LuQ+L4i+wbjP03E46/yIb+7r/RaFRXXXWVPvOZz6TNWe7rPjgHvH8EMaNYZWVlsmw3VWLZxIkTM15vzJgxCoVCB3XdyspKxWIx7dmzJ229zs5O1dXV9XkfwIEMxv7blylTpkjy2pwB/dHf/fdQ7yP1NnveD8dfHI7B2If7wjEYhysb++9rr72mj3zkIzryyCP19NNPpw2ETtxH6m32vB+Oweivwdh/+8LxF4cr268fysrKdPrpp+vxxx9Pu4/U2+x5Pxx/0V+Dsf/2heMvDld/999HH31UGzdu1GWXXaYtW7YkPySpublZW7ZsUVtbW/I+OAe8fwQxo9iiRYv01ltv9SrNTZSaLVq0KOP1HMfRUUcdpX/84x+9LnvllVc0Y8YMFRUVpd1Gz3X/8Y9/yHXdPu8DOJDB2H/7smnTJklSRUVFP7Yc6P/+e6j3IfU+/u7atUs7duzg+IvDMhj7cF84BuNwHe7+++677+rMM8/UuHHj9Pzzz6uwsDDjfUgcg5F9g7H/9oXjLw7XQLx+aG9vV2NjY9p9SBx/kX2Dsf/2heMvDld/999t27apq6tLS5cu1fTp05MfkhfSTJ8+Xb///e/TboNzwPthMWr97W9/s5LsnXfemVzW0dFhZ82aZU844YTksq1bt9r169enXfc73/mOlWT/93//N7lsw4YN1ufz2euvvz65rK2tzY4ZM8aeffbZade/8MILbX5+vq2rq8v2w8IoMRj77549e3rdb1NTk505c6YtLy+3kUgkmw8Jo8jh7L+p7rzzTivJbt68OePl8+bNswsXLrTRaDS57Otf/7o1xth169Yd/gPBqDUY+3BdXV3avmuttZ2dnXbp0qU2GAza6urqw38gGJUOZ/+trq62M2bMsBMnTuzz2JvAMRgDYTD2X46/GCiHs//u3r271+1t3rzZFhUV2VNOOSVtOcdfDITB2H85/mKg9Hf/Xb9+vX322Wd7fUiyH/rQh+yzzz5rd+3aZa3lHPDBIIgZ5T7xiU9Yv99vv/KVr9gHHnjAnnTSSdbv99v/+q//Sq5z6qmn2p6ZXeJk9Lhx4+wdd9xh7777bjtlyhQ7ceLEXiev77vvPivJnnvuufbBBx+0y5cvt5Lst771rUF5jBi5Bnr/vemmm+zChQvt17/+dfuTn/zE3nzzzXbatGnWGGN/9rOfDdrjxMjU3/23oaHB3nrrrfbWW2+1Z555ppVkr732Wnvrrbfae++9N23dX//619YYY08//XT7k5/8xF511VXWcRx7ySWXDMpjxMg20Pvwww8/bGfOnGmvv/56e//999tvf/vb9sgjj7SS7Le//e1Be5wYmfq7/y5cuNBKsl/96lftY489lvbx+9//Pm1djsEYKAO9/3L8xUDq7/47btw4+8lPftLefvvt9ic/+Yn9yle+YseMGWPD4bD9y1/+krYux18MlIHefzn+YiD1d//NRJL94he/2Gs554D3jyBmlGtvb7fXXXednTBhgg2FQva4446zL7zwQto6ff0Sbt++3Z577rm2uLjYFhYW2rPPPtu+/fbbGe/nJz/5iZ07d64NBoN25syZ9u6777au6w7IY8LoMdD77+9//3v7gQ98wE6YMMEGAgFbWlpqP/jBD9oXX3xxQB8XRof+7r+bN2+2kjJ+TJs2rdf9PPvss3bRokU2FArZyZMn269//eu2s7NzIB8aRomB3of/8Y9/2H/6p3+ykyZNssFg0BYWFtqTTz7ZPvXUU4Px8DDC9Xf/7WvflWRPPfXUXvfDMRgDYaD3X46/GEj93X9vuukme+yxx9qysjLr9/vtxIkT7QUXXGBff/31jPfD8RcDYaD3X46/GEiHcw6tp76CGGs5B7w/xlprD6OzGQAAAAAAAAAAAPrgDPUGAAAAAAAAAAAAjFQEMQAAAAAAAAAAAAOEIAYAAAAAAAAAAGCAEMQAAAAAAAAAAAAMEIIYAAAAAAAAAACAAUIQAwAAAAAAAAAAMEAIYgAAAAAAAAAAAAYIQQwAAAAAAAAAAMAAIYgBAAAAAAAAAAAYIAQxAAAAAIBBt2XLFhljtHLlyqHeFAAAAGBAEcQAAAAAI9zKlStljEl+hMNhzZkzR1dccYV279491Jt32NatW6d//dd/1ZYtW4Z6Uw7o4osvTvu/CIVCmjNnjr75zW+qo6NjqDcPAAAAwADwD/UGAAAAABgct9xyi6ZPn66Ojg79z//8j3784x/r+eef1xtvvKH8/Pyh3rx+W7dunW6++WaddtppqqqqGurNOaBQKKT/+3//rySpsbFRzz33nG699Va9++67evzxx4d46wAAAABkG0EMAAAAMEqcddZZOvbYYyVJn//85zV27Fjdddddeu655/TJT37ysG67ra0tp8OcweT3+3XhhRcmv7/88st10kkn6d///d911113afz48UO4dQAAAACyjdZkAAAAwCh1+umnS5I2b96cXPazn/1MS5YsUV5ensaMGaMLLrhA27dvT7veaaedpiOPPFKvvvqq3vve9yo/P1833nijJKmjo0P/+q//qjlz5igcDquyslIf+9jH9O677yav77qu7rnnHh1xxBEKh8MaP368LrvsMtXX16fdT1VVlc4++2z9z//8j44//niFw2HNmDFDjz76aHKdlStX6hOf+IQk6X3ve1+y5def/vQnSdJzzz2nD3/4w5o4caJCoZBmzpypW2+9VbFYrNfP47777tOMGTOUl5en448/Xn/+85912mmn6bTTTktbLxKJ6KabbtKsWbMUCoU0ZcoUffWrX1UkEjnE/wGPMUYnn3yyrLXatGlT2mW//e1vdcopp6igoEBFRUX68Ic/rDfffDNtnYsvvliFhYXatm2bzj77bBUWFmrSpEm67777JElr167V6aefroKCAk2bNk1PPPFEr23YtGmTPvGJT2jMmDHKz8/Xe97zHv3mN79JXr579275/X7dfPPNva67ceNGGWP0wx/+UJK0b98+XXfddTrqqKNUWFio4uJinXXWWXrttdf69fMBAAAAch1BDAAAADBKJcKRsWPHSpK+9a1vafny5Zo9e7buuusuXX311XrxxRf13ve+Vw0NDWnXraur01lnnaVFixbpnnvu0fve9z7FYjGdffbZuvnmm7VkyRJ973vf05e+9CU1NjbqjTfeSF73sssu01e+8hUtXbpU3//+97VixQo9/vjjWrZsmbq6utLu55133tG5556rD3zgA/re976nsrIyXXzxxckw4r3vfa+uuuoqSdKNN96oxx57TI899pjmz58vyQtqCgsLdc011+j73/++lixZom9+85v62te+lnY/P/7xj3XFFVdo8uTJuuOOO3TKKafonHPO0Y4dO9LWc11XH/nIR/Td735X//RP/6R7771X55xzju6++26df/75/f6/SMy3KSsrSy577LHH9OEPf1iFhYW6/fbb9Y1vfEPr1q3TySef3GseTiwW01lnnaUpU6bojjvuUFVVla644gqtXLlSZ555po499ljdfvvtKioq0vLly9PCt927d+ukk07S7373O11++eX61re+pY6ODn3kIx/Rs88+K0kaP368Tj31VD311FO9tv3JJ5+Uz+dLBmKbNm3Sf/zHf+jss8/WXXfdpa985Stau3atTj31VO3atavfPyMAAAAgZ1kAAAAAI9rDDz9sJdk//OEPtra21m7fvt3+/Oc/t2PHjrV5eXl2x44ddsuWLdbn89lvfetbadddu3at9fv9actPPfVUK8nef//9aes+9NBDVpK96667em2D67rWWmv//Oc/W0n28ccfT7v8hRde6LV82rRpVpL97//+7+SyPXv22FAoZK+99trksl/84hdWkn3ppZd63W9bW1uvZZdddpnNz8+3HR0d1lprI5GIHTt2rD3uuONsV1dXcr2VK1daSfbUU09NLnvssces4zj2z3/+c9pt3n///VaS/ctf/tLr/lJddNFFtqCgwNbW1tra2lr7zjvv2O9+97vWGGOPPPLI5M+pubnZlpaW2ksuuSTt+jU1NbakpCRt+UUXXWQl2W9/+9vJZfX19TYvL88aY+zPf/7z5PINGzZYSfamm25KLrv66qutpLTH1NzcbKdPn26rqqpsLBaz1lr7wAMPWEl27dq1adu0YMECe/rppye/7+joSF4nYfPmzTYUCtlbbrklbZkk+/DDD+/3ZwYAAADkOipiAAAAgFHi/e9/vyoqKjRlyhRdcMEFKiws1LPPPqtJkybpmWeekeu6Ou+887R3797kx4QJEzR79my99NJLabcVCoW0YsWKtGW//OUvVV5eriuvvLLXfRtjJEm/+MUvVFJSog984ANp97NkyRIVFhb2up8FCxbolFNOSX5fUVGhuXPn9mrh1Ze8vLzk183Nzdq7d69OOeUUtbW1acOGDZKkf/zjH6qrq9Mll1wiv797jOanP/3ptAqVxPbPnz9f8+bNS9v+RJu3ntufSWtrqyoqKlRRUaFZs2bpuuuu09KlS/Xcc88lf07/+Z//qYaGBn3yk59Mux+fz6cTTjgh4/18/vOfT35dWlqquXPnqqCgQOedd15y+dy5c1VaWpr283v++ed1/PHH6+STT04uKyws1KWXXqotW7Zo3bp1kqSPfexj8vv9evLJJ5PrvfHGG1q3bl1aNVAoFJLjeH9qxmIx1dXVqbCwUHPnztWqVasO+PMBAAAARhr/gVcBAAAAMBLcd999mjNnjvx+v8aPH6+5c+cmT5i//fbbstZq9uzZGa8bCATSvp80aZKCwWDasnfffVdz585NCzN6evvtt9XY2Khx48ZlvHzPnj1p30+dOrXXOmVlZb3myfTlzTff1Ne//nX98Y9/VFNTU9pljY2NkqStW7dKkmbNmpV2ud/vV1VVVa/tX79+vSoqKg5q+zMJh8P69a9/LUnasWOH7rjjDu3ZsyctNHr77bcldc/x6am4uLjXbfbcppKSEk2ePDkZ7qQuT/35bd26VSeccEKv+0i0d9u6dauOPPJIlZeX64wzztBTTz2lW2+9VZLXlszv9+tjH/tY8nqu6+r73/++fvSjH2nz5s1p83gSbfAAAACA0YQgBgAAABgljj/+eB177LEZL3NdV8YY/fa3v5XP5+t1eWFhYdr3qaHBoXBdV+PGjdPjjz+e8fKeYUKmbZEka+0B76uhoUGnnnqqiouLdcstt2jmzJkKh8NatWqVrr/+ermu26/tP+qoo3TXXXdlvHzKlCkHvA2fz6f3v//9ye+XLVumefPm6bLLLtOvfvWr5P1I3pyYCRMm9LqNnmFXXz+nw/n5ZXLBBRdoxYoVWrNmjRYtWqSnnnpKZ5xxhsrLy5PrfPvb39Y3vvENffazn9Wtt96qMWPGyHEcXX311f36mQMAAAC5jiAGAAAAgGbOnClrraZPn645c+b0+zZeeeUVdXV19aqgSV3nD3/4g5YuXdrvMKennhUfCX/6059UV1enZ555Ru9973uTy1MH1UvStGnTJEnvvPOO3ve+9yWXR6NRbdmyRUcffXTa9r/22ms644wz+rzfQ1VZWakvf/nLuvnmm/W3v/1N73nPezRz5kxJ0rhx49JCm4Ewbdo0bdy4sdfyROu2xM9Hks455xxddtllyfZkb731lm644Ya06z399NN63/vep5/+9KdpyxsaGtICGwAAAGC0YEYMAAAAAH3sYx+Tz+fTzTff3Ktawlqrurq6A97Gxz/+ce3du1c//OEPe12WuM3zzjtPsVgs2doqVTQaVUNDwyFve0FBgST1um6iGiT18XR2dupHP/pR2nrHHnusxo4dqwcffFDRaDS5/PHHH+/VAu28887Tzp079eCDD/bajvb2drW2th7y9kvSlVdeqfz8fH3nO9+R5FXJFBcX69vf/ra6urp6rV9bW9uv+8nkQx/6kP7+97/r5ZdfTi5rbW3VT37yE1VVVWnBggXJ5aWlpVq2bJmeeuop/fznP1cwGNQ555yTdns+n6/XPvSLX/xCO3fuzNo2AwAAALmEihgAAAAAmjlzpv7t3/5NN9xwg7Zs2aJzzjlHRUVF2rx5s5599lldeumluu666/Z7G8uXL9ejjz6qa665Rn//+991yimnqLW1VX/4wx90+eWX66Mf/ahOPfVUXXbZZbrtttu0Zs0affCDH1QgENDbb7+tX/ziF/r+97+vc88995C2fdGiRfL5fLr99tvV2NioUCik008/XSeddJLKysp00UUX6aqrrpIxRo899livkCAYDOpf//VfdeWVV+r000/Xeeedpy1btmjlypWaOXNmWuXLZz7zGT311FP653/+Z7300ktaunSpYrGYNmzYoKeeekq/+93v+mz/tj9jx47VihUr9KMf/Ujr16/X/Pnz9eMf/1if+cxndMwxx+iCCy5QRUWFtm3bpt/85jdaunRpxsCrP772ta/p3//933XWWWfpqquu0pgxY/TII49o8+bN+uUvf5mcI5Rw/vnn68ILL9SPfvQjLVu2TKWlpWmXn3322brlllu0YsUKnXTSSVq7dq0ef/xxzZgxIyvbCwAAAOQaghgAAAAAkrwT8nPmzNHdd9+tm2++WZI38+SDH/ygPvKRjxzw+j6fT88//7y+9a1v6YknntAvf/lLjR07VieffLKOOuqo5Hr333+/lixZogceeEA33nij/H6/qqqqdOGFF2rp0qWHvN0TJkzQ/fffr9tuu02f+9znFIvF9NJLL+m0007T//t//0/XXnutvv71r6usrEwXXnihzjjjDC1btiztNq644gpZa/W9731P1113nRYuXKhf/epXuuqqqxQOh5PrOY6j//iP/9Ddd9+tRx99VM8++6zy8/M1Y8YMfelLX+p3WzdJuuaaa3T//ffr9ttv18qVK/WpT31KEydO1He+8x3deeedikQimjRpkk455RStWLGi3/fT0/jx4/XXv/5V119/ve699151dHTo6KOP1q9//Wt9+MMf7rX+Rz7yEeXl5am5uVnnn39+r8tvvPFGtba26oknntCTTz6pY445Rr/5zW/0ta99LWvbDAAAAOQSY/s7pREAAAAARjDXdVVRUaGPfexjGVuRAQAAAMDBYEYMAAAAgFGvo6OjV8uyRx99VPv27dNpp502NBsFAAAAYESgIgYAAADAqPenP/1JX/7yl/WJT3xCY8eO1apVq/TTn/5U8+fP16uvvqpgMDjUmwgAAAAgRzEjBgAAAMCoV1VVpSlTpugHP/iB9u3bpzFjxmj58uX6zne+QwgDAAAA4LBQEQMAAAAAAAAAADBAmBEDAAAAAAAAAAAwQAhiAAAAAAAAAAAABghBDAAAAAAAAAAAwAAhiAEAAAAAAAAAABggBDEAAAAAAAAAAAADhCAGAAAAAAAAAABggBDEAAAAAAAAAAAADBCCGAAAAAAAAAAAgAHy/wEaEui/dD/1EAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots()\n", "\n", @@ -684,27 +681,7 @@ " title=\"Accuracy as a function of percentage of removed worst data points\",\n", " ax=ax,\n", " )\n", - "_ = plt.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "b2d69593", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ + "plt.legend()\n", "plt.show()" ] }, @@ -734,7 +711,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.8.16" } }, "nbformat": 4, diff --git a/notebooks/shapley_basic_spotify.ipynb b/notebooks/shapley_basic_spotify.ipynb index ae1c73aca..3d4c5402f 100644 --- a/notebooks/shapley_basic_spotify.ipynb +++ b/notebooks/shapley_basic_spotify.ipynb @@ -34,7 +34,7 @@ "\n", "
\n", "\n", - "If you are reading this in the documentation, some boilerplate has been omitted for convenience.\n", + "If you are reading this in the documentation, some boilerplate (including most plotting code) has been omitted for convenience.\n", "\n", "
" ] @@ -43,7 +43,9 @@ "cell_type": "code", "execution_count": 1, "metadata": { - "nbsphinx": "hidden" + "tags": [ + "hide" + ] }, "outputs": [], "source": [ @@ -54,7 +56,9 @@ "cell_type": "code", "execution_count": 2, "metadata": { - "nbsphinx": "hidden" + "tags": [ + "hide" + ] }, "outputs": [], "source": [ @@ -124,7 +128,9 @@ "cell_type": "code", "execution_count": 5, "metadata": { - "nbsphinx": "hidden" + "tags": [ + "hide" + ] }, "outputs": [], "source": [ @@ -513,26 +519,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": { - "nbsphinx": "hidden" + "tags": [ + "hide-input" + ] }, - "outputs": [], - "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=\"Shapley value\",\n", - ");" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, "outputs": [ { "data": { @@ -548,6 +540,14 @@ } ], "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=\"Shapley value\",\n", + ")\n", "plt.show()" ] }, @@ -637,26 +637,12 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": { - "nbsphinx": "hidden" + "tags": [ + "hide-input" + ] }, - "outputs": [], - "source": [ - "high_dvl = df.iloc[-30:]\n", - "ax = plot_shapley(\n", - " high_dvl,\n", - " title=\"Artists with high values\",\n", - " xlabel=\"Artist\",\n", - " ylabel=\"Shapley value\",\n", - ")\n", - "ax.get_xticklabels()[high_dvl.index.get_loc(\"Rihanna\")].set_color(\"red\");" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, "outputs": [ { "data": { @@ -672,6 +658,14 @@ } ], "source": [ + "high_dvl = df.iloc[-30:]\n", + "ax = plot_shapley(\n", + " high_dvl,\n", + " title=\"Artists with high values\",\n", + " xlabel=\"Artist\",\n", + " ylabel=\"Shapley value\",\n", + ")\n", + "ax.get_xticklabels()[high_dvl.index.get_loc(\"Rihanna\")].set_color(\"red\")\n", "plt.show()" ] }, @@ -721,26 +715,12 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": { - "nbsphinx": "hidden" + "tags": [ + "hide-input" + ] }, - "outputs": [], - "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(\"Rihanna\")].set_color(\"red\");" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, "outputs": [ { "data": { @@ -756,6 +736,14 @@ } ], "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(\"Rihanna\")].set_color(\"red\")\n", "plt.show()" ] }, @@ -788,7 +776,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.8.16" }, "vscode": { "interpreter": { diff --git a/notebooks/shapley_knn_flowers.ipynb b/notebooks/shapley_knn_flowers.ipynb index 3d909d3a5..9195ccba0 100644 --- a/notebooks/shapley_knn_flowers.ipynb +++ b/notebooks/shapley_knn_flowers.ipynb @@ -33,17 +33,19 @@ "\n", "
\n", "\n", - "If you are reading this in the documentation, some boilerplate has been omitted for convenience.\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, + "execution_count": null, "id": "c3a76161", "metadata": { - "nbsphinx": "hidden" + "tags": [ + "hide" + ] }, "outputs": [], "source": [ @@ -55,7 +57,9 @@ "execution_count": 2, "id": "57174af3", "metadata": { - "nbsphinx": "hidden" + "tags": [ + "hide" + ] }, "outputs": [], "source": [ @@ -177,7 +181,7 @@ "id": "467f635a", "metadata": { "tags": [ - "remove-input" + "hide-input" ] }, "outputs": [ @@ -216,7 +220,11 @@ "cell_type": "code", "execution_count": 7, "id": "a2715c13", - "metadata": {}, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "data": { @@ -355,9 +363,9 @@ "execution_count": 10, "id": "686ded22", "metadata": { - "jupyter": { - "source_hidden": true - } + "tags": [ + "hide" + ] }, "outputs": [ { @@ -386,6 +394,7 @@ } ], "metadata": { + "celltoolbar": "Edit Metadata", "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", @@ -401,7 +410,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.8.16" }, "vscode": { "interpreter": { diff --git a/notebooks/shapley_utility_learning.ipynb b/notebooks/shapley_utility_learning.ipynb index 8e930730e..4eee9e011 100644 --- a/notebooks/shapley_utility_learning.ipynb +++ b/notebooks/shapley_utility_learning.ipynb @@ -16,7 +16,7 @@ "The idea is to employ a model to learn the performance of the learning algorithm of interest on unseen data combinations (i.e. subsets of the dataset). The method was originally described in *Wang, Tianhao, Yu Yang, and Ruoxi Jia. [Improving Cooperative Game Theory-Based Data Valuation via Data Utility Learning](https://doi.org/10.48550/arXiv.2107.06336). arXiv, 2022*.\n", "\n", "
\n", - "**Warning:** Work on Data Utility Learning is preliminary. It remains to be seen when or whether it can be put effectively into application. For this further testing and benchmarking are required.\n", + "

Warning: Work on Data Utility Learning is preliminary. It remains to be seen when or whether it can be put effectively into application. For this further testing and benchmarking are required.

\n", "
" ] }, @@ -34,17 +34,17 @@ "\n", "where $N$ is the set of all indices in the training set and $u$ is the utility.\n", "\n", - "In Data Utility Learning, to avoid the exponential cost of computing this sum, one learns a surrogate model for $u$. We start by sampling so-called **utility samples** to form a training set $S_\\operatorname{train}$ for our utility model. Each utility sample is a tuple consisting of a subset of indices $S_j$ in the dataset and its utility $u(S_j)$:\n", + "In Data Utility Learning, to avoid the exponential cost of computing this sum, one learns a surrogate model for $u$. We start by sampling so-called **utility samples** to form a training set $S_\\mathrm{train}$ for our utility model. Each utility sample is a tuple consisting of a subset of indices $S_j$ in the dataset and its utility $u(S_j)$:\n", "\n", - "$$\\mathcal{S}_\\operatorname{train} = \\{(S_j, u(S_j): j = 1 , ..., m_\\operatorname{train}\\}$$\n", + "$$\\mathcal{S}_\\mathrm{train} = \\{(S_j, u(S_j): j = 1 , ..., m_\\mathrm{train}\\}$$\n", "\n", - "where $m_\\operatorname{train}$ denotes the *training budget* for the learned utility function.\n", + "where $m_\\mathrm{train}$ denotes the *training budget* for the learned utility function.\n", "\n", "The subsets are then transformed into boolean vectors $\\phi$ in which a $1$ at index $k$ means that the $k$-th sample of the dataset is present in the subset:\n", "\n", "$$S_j \\mapsto \\phi_j \\in \\{ 0, 1 \\}^{N}$$\n", "\n", - "We fit a regression model $\\tilde{u}$, called **data utility model**, on the transformed utility samples $\\phi (\\mathcal{S}_\\operatorname{train}) := \\{(\\phi(S_j), u(S_j): j = 1 , ..., m_\\operatorname{train}\\}$ and use it to predict instead of computing the utility for any $S_j \\notin \\mathcal{S}_\\operatorname{train}$. We abuse notation and identify $\\tilde{u}$ with the composition $\\tilde{u} \\circ \\phi : N \\rightarrow \\mathbb{R}$.\n", + "We fit a regression model $\\tilde{u}$, called **data utility model**, on the transformed utility samples $\\phi (\\mathcal{S}_\\mathrm{train}) := \\{(\\phi(S_j), u(S_j): j = 1 , ..., m_\\mathrm{train}\\}$ and use it to predict instead of computing the utility for any $S_j \\notin \\mathcal{S}_\\mathrm{train}$. We abuse notation and identify $\\tilde{u}$ with the composition $\\tilde{u} \\circ \\phi : N \\rightarrow \\mathbb{R}$.\n", "\n", "The main assumption is that it is much faster to fit and use $\\tilde{u}$ than it is to compute $u$ and that for most $i$, $v_\\tilde{u}(i) \\approx v_u(i)$ in some sense." ] @@ -66,9 +66,11 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { - "nbsphinx": "hidden" + "tags": [ + "hide" + ] }, "outputs": [], "source": [ @@ -79,7 +81,9 @@ "cell_type": "code", "execution_count": 2, "metadata": { - "nbsphinx": "hidden" + "tags": [ + "hide" + ] }, "outputs": [], "source": [ @@ -368,11 +372,26 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": { - "nbsphinx": "hidden" + "tags": [ + "hide-input" + ] }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots()\n", "shaded_mean_std(\n", @@ -402,28 +421,7 @@ "ax2.set_ylabel(\"Computation Time\", color=\"indianred\")\n", "ax2.tick_params(axis=\"y\", labelcolor=\"indianred\")\n", "ax.set_title(\"$l_2$ Error and computation time with respect to $m_{train}$\")\n", - "fig.tight_layout();" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ + "fig.tight_layout()\n", "plt.show()" ] }, @@ -434,26 +432,14 @@ "Let us next look at how well the ranking of values resulting from using the surrogate $\\tilde{u}$ matches the ranking by the exact values. For this we fix $k=3$ and consider the $k$ samples with the highest value according to $\\tilde{u}$ and $u$:" ] }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "shaded_mean_std(\n", - " accuracies.transpose(),\n", - " abscissa=training_budget_values,\n", - " mean_color=\"dodgerblue\",\n", - " shade_color=\"lightblue\",\n", - " xlabel=\"$m_\\\\operatorname{train}$\",\n", - " ylabel=f\"Average Top-{top_k} Accuracy\",\n", - ");" - ] - }, { "cell_type": "code", "execution_count": 14, - "metadata": {}, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "data": { @@ -469,6 +455,14 @@ } ], "source": [ + "shaded_mean_std(\n", + " accuracies.transpose(),\n", + " abscissa=training_budget_values,\n", + " mean_color=\"dodgerblue\",\n", + " shade_color=\"lightblue\",\n", + " xlabel=\"$m_\\\\operatorname{train}$\",\n", + " ylabel=f\"Average Top-{top_k} Accuracy\",\n", + ")\n", "plt.show()" ] }, @@ -481,11 +475,26 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": { - "nbsphinx": "hidden" + "tags": [ + "hide-input" + ] }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots(figsize=(18, 12))\n", "distances = 100 * df.loc[:, df.columns != \"exact\"].sub(df.exact, axis=\"index\").div(\n", @@ -505,28 +514,7 @@ "ax.set_xlabel(\"Index\")\n", "ax.set_ylabel(\"% deviation from the exact value\")\n", "ax.set_title(\"Relative deviation of estimated from exact values across runs\")\n", - "ax.grid(False)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ + "ax.grid(False)\n", "plt.show()" ] }, @@ -638,25 +626,12 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": { - "nbsphinx": "hidden" + "tags": [ + "hide-input" + ] }, - "outputs": [], - "source": [ - "fig, ax = plt.subplots()\n", - "df_corrupted.sort_values(by=\"exact\", ascending=False, axis=0).plot(\n", - " y=[\"exact\", \"estimated\"], kind=\"bar\", ax=ax, color=[\"dodgerblue\", \"indianred\"]\n", - ")\n", - "ax.set_xlabel(\"Index\")\n", - "ax.set_ylabel(\"Data Shapley value\")\n", - "plt.legend([\"Exact\", \"Estimated\"]);" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, "outputs": [ { "data": { @@ -672,7 +647,14 @@ } ], "source": [ - "plt.show()" + "fig, ax = plt.subplots()\n", + "df_corrupted.sort_values(by=\"exact\", ascending=False, axis=0).plot(\n", + " y=[\"exact\", \"estimated\"], kind=\"bar\", ax=ax, color=[\"dodgerblue\", \"indianred\"]\n", + ")\n", + "ax.set_xlabel(\"Index\")\n", + "ax.set_ylabel(\"Data Shapley value\")\n", + "plt.legend([\"Exact\", \"Estimated\"])\n", + "plt.show();" ] }, { @@ -702,7 +684,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.8.16" } }, "nbformat": 4, From 220bec9b043a1494e215121c849e7ec81b014b4e Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 29 Jun 2023 16:09:48 +0200 Subject: [PATCH 134/436] Remove unused css file --- docs/css/bootstrap.css | 33 --------------------------------- 1 file changed, 33 deletions(-) delete mode 100644 docs/css/bootstrap.css diff --git a/docs/css/bootstrap.css b/docs/css/bootstrap.css deleted file mode 100644 index 489c9cedc..000000000 --- a/docs/css/bootstrap.css +++ /dev/null @@ -1,33 +0,0 @@ - - - -.alert { - --bs-alert-bg: transparent; - --bs-alert-padding-x: 1rem; - --bs-alert-padding-y: 1rem; - --bs-alert-margin-bottom: 1rem; - --bs-alert-color: inherit; - --bs-alert-border-color: transparent; - --bs-alert-border: 1px solid var(--md-accent-fg-color); - --bs-alert-border-radius: 2px; - --bs-alert-link-color: inherit; - position: relative; - padding: var(--bs-alert-padding-y) var(--bs-alert-padding-x); - margin-bottom: var(--bs-alert-margin-bottom); - color: black; - background-color: var(--bs-alert-bg); - border: var(--bs-alert-border); - border-radius: var(--bs-alert-border-radius); -} - -.alert-info { - --bs-alert-bg: var(--md-accent-bg-color); - --bs-alert-border-color: var(--md-accent-fg-color); - --bs-alert-link-color: var(--md-accent-fg-color); -} - -.alert-warning { - --bs-alert-bg: var(--md-accent-bg-color); - --bs-alert-border-color: var(--md-accent-fg-color); - --bs-alert-link-color: var(--md-accent-fg-color); -} \ No newline at end of file From 2560a20a0465b640285106f45f9d3895f7f84142 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 29 Jun 2023 22:17:34 +0200 Subject: [PATCH 135/436] More math fixes --- docs/40-influence.rst | 73 ++++++++++++++++++++++--------------------- 1 file changed, 38 insertions(+), 35 deletions(-) diff --git a/docs/40-influence.rst b/docs/40-influence.rst index 2fce6e89a..441b1c839 100644 --- a/docs/40-influence.rst +++ b/docs/40-influence.rst @@ -16,8 +16,8 @@ Computing influence values - Explain how the methods differ - Add example for ``TwiceDifferentiable`` -The influence function is a method to quantify the effect (influence) that each -training point has on the parameters of a model, and by extension on any +The influence function (IF) is a method to quantify the effect (influence) that +each training point has on the parameters of a model, and by extension on any function thereof. In particular, it is possible to estimate how much each training sample affects the error on a test point, making the IF really useful for understanding and debugging models. It is in a sense similar to, and @@ -31,23 +31,20 @@ The Influence Function ----------------------- First introduced in the context of robust statistics in -:footcite:t:`hampel1974influence` the IF was popularized in machine learning -with the work :footcite:t:`koh_understanding_2017`. +:footcite:t:`hampel1974influence`, the IF was popularized in the context of +machine learning in :footcite:t:`koh_understanding_2017`. Following their +formulation, consider an input space $\mathcal{X}$ (e.g. images) and an output +space $\mathcal{Y}$ (e.g. labels). Let's take $z_i = (x_i, y_i)$, for $i \in +\{1,...,n\}$ to be the $i$-th training point, and $\theta$ to be the +(potentially highly) multi-dimensional parameters of a model (e.g. $\theta$ is a +big array with all of a neural network's parameters, including biases, batch +normalizations and/or dropout rates). We will denote with $L(z, \theta)$ the +loss of the model for point $z$ when the parameters are $\theta.$ -Following the formulation of :footcite:t:`koh_understanding_2017`, consider an -input space $\mathcal{X}$ (e.g. images) and an output space $\mathcal{Y}$ (e.g. -labels). Let's take $z_i = (x_i, y_i)$, for $i \in \{1,...,n\}$ to be the $i$-th -training point, and $\theta$ to be the (potentially highly) multi-dimensional -parameters of a model (e.g. $\theta$ is a big array with all of a neural network's -parameters, including biases, batch normalizations and/or dropout rates). -We will indicate with $L(z, \theta)$ the loss of the model for point $z$ when -the parameters are $\theta$. +To train a model, we typically minimize the loss over all $z_i$, i.e. +the optimal parameters are -Upon training the model, we typically minimize the loss over all $z_i$, i.e. -the optimal parameters are calculated with (stochastic) gradient descent on the -following expression: - -$$ \hat{\theta} = \arg \min_\theta \frac{1}{n}\sum_{i=1}^n L(z_i, \theta). $$ +$$\hat{\theta} = \arg \min_\theta \sum_{i=1}^n L(z_i, \theta).$$ In practice, lack of convexity means that one doesn't really obtain the minimizer of the loss, and the training is stopped when the validation loss @@ -55,7 +52,9 @@ stops decreasing. For notational convenience, let's define -$$ \hat{\theta}_{-z} = \arg \min_\theta \frac{1}{n}\sum_{z_i \ne z} L(z_i, \theta)\ , $$ +$$ +\hat{\theta}_{-z} = \arg \min_\theta \sum_{z_i \ne z} L(z_i, \theta), +$$ i.e. $\hat{\theta}_{-z}$ are the model parameters that minimize the total loss when $z$ is not in the training dataset. @@ -73,7 +72,8 @@ Approximating the influence of a point Let's define -$$\hat{\theta}_{\epsilon, z} = \arg \min_\theta +$$ +\hat{\theta}_{\epsilon, z} = \arg \min_\theta \frac{1}{n}\sum_{i=1}^n L(z_i, \theta) + \epsilon L(z, \theta), $$ @@ -101,8 +101,8 @@ We will define the influence of training point $z$ on test point $z_{\text{test}}$ as $$ -\mathcal{I}(z, z\_{\text{test}}) = L(z\_{\text{test}}, \hat{\theta}_{-z}) - -L(z\_{\text{test}}, \hat{\theta}). +\mathcal{I}(z, z_{\text{test}}) = L(z_{\text{test}}, \hat{\theta}_{-z}) - +L(z_{\text{test}}, \hat{\theta}). $$ Notice that $\mathcal{I}$ is higher for points $z$ which positively impact the @@ -110,16 +110,16 @@ model score, since the loss is higher when they are excluded from training. In practice, one needs to rely on the following infinitesimal approximation: $$ -\mathcal{I}_{up}(z, z\_{\text{test}}) = - \frac{d L(z\_{\text{test}}, +\mathcal{I}_{up}(z, z_{\text{test}}) = - \frac{d L(z_{\text{test}}, \hat{\theta}_{\epsilon, z})}{d \epsilon} \Big|_{\epsilon=0} $$ Using the chain rule and the results calculated above, we thus have: $$ -\mathcal{I}_{up}(z, z\_{\text{test}}) = - \nabla_\theta L(z\_{\text{test}}, +\mathcal{I}_{up}(z, z_{\text{test}}) = - \nabla_\theta L(z_{\text{test}}, \hat{\theta})^\top \ \frac{d \hat{\theta}_{\epsilon, z}}{d \epsilon} -\Big|_{\epsilon=0} = \nabla_\theta L(z\_{\text{test}}, \hat{\theta})^\top \ +\Big|_{\epsilon=0} = \nabla_\theta L(z_{\text{test}}, \hat{\theta})^\top \ H_{\hat{\theta}}^{-1} \ \nabla_\theta L(z, \hat{\theta}) $$ @@ -137,23 +137,23 @@ order to approximate the effect of modifying a single feature of a single point on the model score we can define $$ -\hat{\theta}_{\epsilon, z\_{\delta} ,-z} = \arg \min_\theta -\frac{1}{n}\sum_{i=1}^n L(z\_i, \theta) + \epsilon L(z\_{\delta}, \theta) - \epsilon L(z, \theta), +\hat{\theta}_{\epsilon, z_{\delta} ,-z} = \arg \min_\theta +\frac{1}{n}\sum_{i=1}^n L(z_{i}, \theta) + \epsilon L(z_{\delta}, \theta) - \epsilon L(z, \theta), $$ -Similarly to what was done above, we up-weigh point $z\_{\delta}$, but +Similarly to what was done above, we up-weigh point $z_{\delta}$, but then we also remove the up-weighing for all the features that are not modified by $\delta$. From the calculations in ???, it is then easy to see that $$ -\frac{d \ \hat{\theta}_{\epsilon, z\_{\delta} ,-z}}{d \epsilon} \Big|_{\epsilon=0} -= -H_{\hat{\theta}}^{-1} \nabla_\theta \Big( L(z\_\delta, \hat{\theta}) - L(z, \hat{\theta}) \Big) +\frac{d \ \hat{\theta}_{\epsilon, z_{\delta} ,-z}}{d \epsilon} \Big|_{\epsilon=0} += -H_{\hat{\theta}}^{-1} \nabla_\theta \Big( L(z_{\delta}, \hat{\theta}) - L(z, \hat{\theta}) \Big) $$ and if the feature space is continuous and as $\delta \to 0$ we can write $$ -\frac{d \ \hat{\theta}_{\epsilon, z\_{\delta} ,-z}}{d \epsilon} \Big|_{\epsilon=0} +\frac{d \ \hat{\theta}_{\epsilon, z_{\delta} ,-z}}{d \epsilon} \Big|_{\epsilon=0} = -H_{\hat{\theta}}^{-1} \ \nabla_x \nabla_\theta L(z, \hat{\theta}) \delta + \mathcal{o}(\delta) $$ @@ -161,16 +161,16 @@ The influence of each feature of $z$ on the loss of the model can therefore be estimated through the following quantity: $$ -\mathcal{I}_{pert}(z, z\_{\text{test}}) = - \lim_{\delta \to 0} \ \frac{1}{\delta} \frac{d L(z\_{\text{test}}, -\hat{\theta}_{\epsilon, \ z\_{\delta}, \ -z})}{d \epsilon} \Big|_{\epsilon=0} +\mathcal{I}_{pert}(z, z_{\text{test}}) = - \lim_{\delta \to 0} \ \frac{1}{\delta} \frac{d L(z_{\text{test}}, +\hat{\theta}_{\epsilon, \ z_{\delta}, \ -z})}{d \epsilon} \Big|_{\epsilon=0} $$ which, using the chain rule and the results calculated above, is equal to $$ -\mathcal{I}_{pert}(z, z\_{\text{test}}) = - \nabla_\theta L(z\_{\text{test}}, -\hat{\theta})^\top \ \frac{d \hat{\theta}_{\epsilon, z\_{\delta} ,-z}}{d \epsilon} -\Big|_{\epsilon=0} = \nabla_\theta L(z\_{\text{test}}, \hat{\theta})^\top \ +\mathcal{I}_{pert}(z, z_{\text{test}}) = - \nabla_\theta L(z_{\text{test}}, +\hat{\theta})^\top \ \frac{d \hat{\theta}_{\epsilon, z_{\delta} ,-z}}{d \epsilon} +\Big|_{\epsilon=0} = \nabla_\theta L(z_{\text{test}}, \hat{\theta})^\top \ H_{\hat{\theta}}^{-1} \ \nabla_x \nabla_\theta L(z, \hat{\theta}) $$ @@ -264,3 +264,6 @@ As mentioned, the method of empirical influence computation can be selected in ... y_test, ... influence_type="perturbation" ... ) + + +.. footbibliography:: From a506eda870e44445c1fa85cd69497ce3d1804944 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 29 Jun 2023 22:17:39 +0200 Subject: [PATCH 136/436] Remove duplicate header --- docs/30-data-valuation.rst | 2 -- 1 file changed, 2 deletions(-) diff --git a/docs/30-data-valuation.rst b/docs/30-data-valuation.rst index b2ca10224..b3fd5018e 100644 --- a/docs/30-data-valuation.rst +++ b/docs/30-data-valuation.rst @@ -730,7 +730,5 @@ nature of every (non-trivial) ML problem can have an effect: facilities in pyDVL for cross-validating the utility (note that this would require cross-validating the whole value computation). -References -========== .. footbibliography:: From b45d74d995f42dcc66d102f8902e286a2bb90510 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 29 Jun 2023 22:26:58 +0200 Subject: [PATCH 137/436] Fix links and examples --- docs/40-influence.rst | 48 +++++++++++++++++++------------------------ 1 file changed, 21 insertions(+), 27 deletions(-) diff --git a/docs/40-influence.rst b/docs/40-influence.rst index 441b1c839..759ae44bb 100644 --- a/docs/40-influence.rst +++ b/docs/40-influence.rst @@ -202,47 +202,42 @@ this regularization not to corrupt the outcome too much, the parameter $\lambda$ should be as small as possible while still allowing a reliable inversion of $H_{\hat{\theta}} + \lambda \mathbb{I}$. -Exact influences using the `TwiceDifferentiable` protocol ---------------------------------------------------------- +Computing influences +-------------------- The main entry point of the library is -:func:`~pydvl.influence.compute_influences` - -More generally, influences can be computed for any model which implements the -:class:`TwiceDifferentiable` protocol, i.e. which is capable of calculating -second derivative matrix vector products and gradients of the loss evaluated on -training and test samples. +:func:`~pydvl.influence.general.compute_influences`. Influences can be computed +for any model which implements the +:class:`~pydvl.influence.frameworks.twice_differentiable.TwiceDifferentiable` +protocol, i.e. which is capable of calculating second derivative matrix vector +products and gradients of the loss evaluated on training and test samples. .. code-block:: python >>> from pydvl.influence import influences >>> compute_influences( ... model, - ... x_train, - ... y_train, - ... x_test, - ... y_test,, + ... training_data_loader, + ... test_data_loader ... ) Approximate matrix inversion ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -Most often it is not possible to construct the complete Hessian in memory. In -that case one can use conjugate gradient as a space-efficient approximation to -inverting the full matrix. In pyDVL this can be done with the parameter -`inversion_method` of :func:`~pydvl.influence.compute_influences`: - +In almost every practical application it is not possible to construct, even less +invert the complete Hessian in memory. pyDVL offers several approximate +algorithms to invert it by setting the parameter `inversion_method` of +:func:`~pydvl.influence.general.compute_influences`. See the documentation for +allowed values. .. code-block:: python >>> from pydvl.influence import compute_influences >>> compute_influences( ... model, - ... x_train, - ... y_train, - ... x_test, - ... y_test, + ... training_data_loader, + ... test_data_loader, ... inversion_method="cg" ... ) @@ -251,18 +246,17 @@ Perturbation influences ----------------------- As mentioned, the method of empirical influence computation can be selected in -:func:`~pydvl.influence.compute_influences` with `influence_type`: +:func:`~pydvl.influence.general.compute_influences` with `influence_type`: .. code-block:: python >>> from pydvl.influence import compute_influences >>> compute_influences( ... model, - ... x_train, - ... y_train, - ... x_test, - ... y_test, - ... influence_type="perturbation" + ... training_data_loader, + ... test_data_loader, + ... influence_type="perturbation", + ... inversion_method="lissa" ... ) From f52437b01d6c8440f70d477623b5591b00b2fb3a Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 29 Jun 2023 22:34:27 +0200 Subject: [PATCH 138/436] Update changelog --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 49036e99d..fb6bfaf3a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,8 @@ [PR #370](https://github.com/appliedAI-Initiative/pyDVL/pull/370) - Fixed bugs in conjugate gradient and `linear_solve` [PR #358](https://github.com/appliedAI-Initiative/pyDVL/pull/358) +- Improvements to IF documentation + [PR #371](https://github.com/appliedAI-Initiative/pyDVL/pull/371) - Major changes to IF interface and functionality [PR #278](https://github.com/appliedAI-Initiative/pyDVL/pull/278) From bf0b1f207ddaff31ee24c0d4f67db5998b839717 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 29 Jun 2023 22:40:11 +0200 Subject: [PATCH 139/436] Restructuring text and fixing typos --- docs/40-influence.rst | 72 +++++++++++++++++++++++++------------------ 1 file changed, 42 insertions(+), 30 deletions(-) diff --git a/docs/40-influence.rst b/docs/40-influence.rst index 759ae44bb..8793dd098 100644 --- a/docs/40-influence.rst +++ b/docs/40-influence.rst @@ -13,7 +13,7 @@ Computing influence values .. todo:: This section needs rewriting: - - Explain how the methods differ + - Document each approximation method and explain how they differ - Add example for ``TwiceDifferentiable`` The influence function (IF) is a method to quantify the effect (influence) that @@ -59,14 +59,15 @@ $$ i.e. $\hat{\theta}_{-z}$ are the model parameters that minimize the total loss when $z$ is not in the training dataset. -In order to compute the impact of each training point on the model, we would need -to calculate $\hat{\theta}_{-z}$ for each $z$ in the training dataset, thus +In order to compute the impact of each training point on the model, we would +need to calculate $\hat{\theta}_{-z}$ for each $z$ in the training dataset, thus re-training the model at least ~$n$ times (more if model training is stochastic). This is computationally very expensive, especially for big neural networks. To circumvent this problem, we can just calculate a first order approximation of $\hat{\theta}$. This can be done through single backpropagation and without re-training the full model. + Approximating the influence of a point ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -77,7 +78,7 @@ $$ \frac{1}{n}\sum_{i=1}^n L(z_i, \theta) + \epsilon L(z, \theta), $$ -which is the optimal $\hat{\theta}$ if we were to up-weigh $z$ by an amount +which is the optimal $\hat{\theta}$ if we were to up-weight $z$ by an amount $\epsilon \gt 0$. From a classical result (a simple derivation is available in Appendix A of @@ -129,8 +130,8 @@ backpropagation passes. Perturbation definition of the influence score ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -How would the loss of the model change if, instead of up-weighing an individual -point $z$, we were to up-weigh only a single feature of that point? Given $z = +How would the loss of the model change if, instead of up-weighting an individual +point $z$, we were to up-weight only a single feature of that point? Given $z = (x, y)$, we can define $z_{\delta} = (x+\delta, y)$, where $\delta$ is a vector of zeros except for a 1 in the position of the feature we want to up-weigh. In order to approximate the effect of modifying a single feature of a single point @@ -138,11 +139,12 @@ on the model score we can define $$ \hat{\theta}_{\epsilon, z_{\delta} ,-z} = \arg \min_\theta -\frac{1}{n}\sum_{i=1}^n L(z_{i}, \theta) + \epsilon L(z_{\delta}, \theta) - \epsilon L(z, \theta), +\frac{1}{n}\sum_{i=1}^n L(z_{i}, \theta) + \epsilon L(z_{\delta}, \theta) - +\epsilon L(z, \theta), $$ -Similarly to what was done above, we up-weigh point $z_{\delta}$, but -then we also remove the up-weighing for all the features that are not modified +Similarly to what was done above, we up-weight point $z_{\delta}$, but +then we also remove the up-weighting for all the features that are not modified by $\delta$. From the calculations in ???, it is then easy to see that $$ @@ -184,24 +186,6 @@ nonetheless be used to build training-set attacks, as done in :footcite:t:`koh_understanding_2017`. -Inverting the Hessian: direct and approximate methods -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -As discussed in `The Influence Function`_, in -machine learning training rarely converges to a global minimum of the loss. -Despite good apparent convergence, $\hat{\theta}$ might be located in a region -with flat curvature or close to a saddle point. In particular, the Hessian might -have vanishing eigenvalues making its direct inversion impossible. - -To circumvent this problem, many approximate methods are available. The simplest -adds a small *hessian perturbation term*, i.e. we invert -$H_{\hat{\theta}} + \lambda \mathbb{I}$, with $\mathbb{I}$ being the identity -matrix. This standard trick ensures that the eigenvalues of $H_{\hat{\theta}}$ -are bounded away from zero and therefore the matrix is invertible. In order for -this regularization not to corrupt the outcome too much, the parameter $\lambda$ -should be as small as possible while still allowing a reliable inversion of -$H_{\hat{\theta}} + \lambda \mathbb{I}$. - Computing influences -------------------- @@ -242,11 +226,39 @@ allowed values. ... ) +Additionally, and as discussed in `The Influence Function`_, in +machine learning training rarely converges to a global minimum of the loss. +Despite good apparent convergence, $\hat{\theta}$ might be located in a region +with flat curvature or close to a saddle point. In particular, the Hessian might +have vanishing eigenvalues making its direct inversion impossible. + +To circumvent this problem, many approximate methods are available. The simplest +adds a small *hessian perturbation term*, i.e. we invert +$H_{\hat{\theta}} + \lambda \mathbb{I}$, with $\mathbb{I}$ being the identity +matrix. This standard trick ensures that the eigenvalues of $H_{\hat{\theta}}$ +are bounded away from zero and therefore the matrix is invertible. In order for +this regularization not to corrupt the outcome too much, the parameter $\lambda$ +should be as small as possible while still allowing a reliable inversion of +$H_{\hat{\theta}} + \lambda \mathbb{I}$. + +.. code-block:: python + + >>> from pydvl.influence import compute_influences + >>> compute_influences( + ... model, + ... training_data_loader, + ... test_data_loader, + ... inversion_method="cg", + ... hessian_regularization=1e-4 + ... ) + + Perturbation influences ------------------------ +^^^^^^^^^^^^^^^^^^^^^^^ -As mentioned, the method of empirical influence computation can be selected in -:func:`~pydvl.influence.general.compute_influences` with `influence_type`: +The method of empirical influence computation can be selected in +:func:`~pydvl.influence.general.compute_influences` with the parameter +`influence_type`: .. code-block:: python From 3574bfe1bf04f4737feefbb0524522f98c332e1c Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 30 Jun 2023 16:30:57 +0200 Subject: [PATCH 140/436] Add mike as a docs requirement --- requirements-docs.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements-docs.txt b/requirements-docs.txt index 6df4ff835..a5c87d432 100644 --- a/requirements-docs.txt +++ b/requirements-docs.txt @@ -1,3 +1,4 @@ +mike mkdocs==1.4.2 mkdocs-material mkdocstrings[python]>=0.18 From b13c4d91a58d9342e63d6676b5bea1ef4b783eb6 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 30 Jun 2023 16:31:23 +0200 Subject: [PATCH 141/436] Add docs-deploy tox environment --- tox.ini | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/tox.ini b/tox.ini index ab7711de3..8352c6651 100644 --- a/tox.ini +++ b/tox.ini @@ -85,11 +85,6 @@ commands = mypy {posargs:src/} [testenv:docs] -; NOTE: we don't use pytest for running the doctest, even though with pytest no -; imports have to be written in them. The reason is that we want to be running -; doctest during the docs build (which might happen on a remote machine, like -; read_the_docs does) with possibly fewer external dependencies and use sphinx' -; ability to automock the missing ones. commands = mkdocs build deps = @@ -106,6 +101,18 @@ deps = extras = influence + +[testenv:docs-deploy] +passenv = + CURRENT_VERSION + ALIAS +commands = + mike deploy --push $CURRENT_VERSION $ALIAS +deps = + {[testenv:docs]deps} +extras = + influence + [testenv:publish-test-package] description = Publish package to TestPyPI skip_install = true From 2e10fc254cd08cdc51e6c9d1f048362e56443e89 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 30 Jun 2023 16:31:42 +0200 Subject: [PATCH 142/436] Add mike to the mkdocs plugings configuration --- mkdocs.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/mkdocs.yml b/mkdocs.yml index 29a4752fd..a3f6b58a1 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -11,6 +11,7 @@ hooks: - build_scripts/copy_notebooks.py plugins: + - mike - autorefs - search - section-index @@ -103,6 +104,9 @@ extra_javascript: - https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js extra: + version: + provider: mike + default: stable social: - icon: fontawesome/brands/github link: https://github.com/appliedAI-Initiative/pyDVL From bdc41bfcb4ceaf6e70adcb0ce3efb8f0ba0dede8 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 30 Jun 2023 16:40:30 +0200 Subject: [PATCH 143/436] Update CI workflows to deploy different versions of docs --- .github/workflows/publish.yaml | 17 +++++++++++++++++ .github/workflows/tox.yaml | 28 ++++++++++------------------ 2 files changed, 27 insertions(+), 18 deletions(-) diff --git a/.github/workflows/publish.yaml b/.github/workflows/publish.yaml index 2ea899fa3..b276dbe7c 100644 --- a/.github/workflows/publish.yaml +++ b/.github/workflows/publish.yaml @@ -63,6 +63,23 @@ jobs: cache: 'pip' - name: Install Dev Requirements run: pip install -r requirements-dev.txt + - name: Cache Tox Directory + uses: actions/cache@v3 + with: + key: tox-${{ github.ref }}-${{ runner.os }}-${{ hashFiles('tox.ini') }} + path: .tox + - name: Configure Git + if: ${{ github.ref == 'refs/heads/develop' }} + run: | + git fetch origin gh-pages --depth=1 + git config --local user.email ${{ env.GITHUB_BOT_EMAIL }} + git config --local user.name ${{ env.GITHUB_BOT_USERNAME }} + - name: Deploy Docs + if: ${{ github.ref == 'refs/heads/develop' }} + run: | + export CURRENT_VERSION=$(python setup.py --version --quiet | awk -F. '{print $1"."$2}') + export ALIAS=stable + tox -e docs-deploy - name: Build and publish to PyPI env: TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index d45c1f86b..b970e252e 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -64,12 +64,6 @@ jobs: path: .tox - name: Build Docs run: tox -e docs - - name: Save built docs - uses: actions/upload-artifact@v3 - with: - name: docs - path: ./docs/_build - retention-days: 1 base-tests: strategy: matrix: @@ -122,19 +116,18 @@ jobs: with: key: tox-${{ github.ref }}-${{ runner.os }}-${{ hashFiles('tox.ini') }} path: .tox - - name: Download built docs - uses: actions/download-artifact@v3 - with: - name: docs - path: ./docs_build + - name: Configure Git + if: ${{ github.ref == 'refs/heads/develop' }} + run: | + git fetch origin gh-pages --depth=1 + git config --local user.email ${{ env.GITHUB_BOT_EMAIL }} + git config --local user.name ${{ env.GITHUB_BOT_USERNAME }} - name: Deploy Docs - uses: peaceiris/actions-gh-pages@v3 if: ${{ github.ref == 'refs/heads/develop' }} - with: - github_token: ${{ secrets.GITHUB_TOKEN }} - publish_dir: ./docs_build/ - user_name: ${{ env.GITHUB_BOT_USERNAME }} - user_email: ${{ env.GITHUB_BOT_EMAIL }} + run: | + export CURRENT_VERSION=$(python setup.py --version --quiet | awk -F. '{print $1"."$2}') + export ALIAS=latest + tox -e docs-deploy - name: Build and publish to TestPyPI if: ${{ github.ref == 'refs/heads/develop' }} env: @@ -142,7 +135,6 @@ jobs: TWINE_PASSWORD: ${{ secrets.TEST_PYPI_PASSWORD }} run: | set -x - export CURRENT_VERSION=$(python setup.py --version) export BUILD_NUMBER=$GITHUB_RUN_NUMBER tox -e bump-dev-version tox -e publish-test-package From bd035eea72bd28df4d20ddfc5a4080c87dbb74ba Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 30 Jun 2023 16:41:05 +0200 Subject: [PATCH 144/436] Update constributing docs --- CONTRIBUTING.md | 45 ++++++++++++++++++++++----------------------- 1 file changed, 22 insertions(+), 23 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index f233acfe2..4ce14e453 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -147,15 +147,28 @@ all examples of boilerplate code irrelevant to a reader interested in pyDVL's functionality. For this reason we choose to isolate this code into separate cells which are then hidden in the documentation. -In order to do this, cells are marked with metadata understood by the sphinx -plugin `nbpshinx`, namely adding the following to the relevant cells: +In order to do this, cells are marked with tags understood by the mkdocs +plugin [`mkdocs-jupyter`](https://github.com/danielfrg/mkdocs-jupyter#readme), +namely adding the following to the relevant cells: ```yaml -metadata: { - "nbphinx": "hidden" -} +"tags": [ + "hide" +] +``` + +To hide the cell's input and output. + +Or: + +```yaml +"tags": [ + "hide-input" +] ``` +To only hide the input + It is important to leave a warning at the top of the document to avoid confusion. Examples for hidden imports and plots are available in the notebooks, e.g. in [Shapley for data valuation](https://appliedai-initiative.github.io/pyDVL/examples/shapley_basic_spotify.ipynb). @@ -164,25 +177,11 @@ Examples for hidden imports and plots are available in the notebooks, e.g. in ## Documentation API documentation and examples from notebooks are built with -[mkdocs](https://) by tox. Doctests are run during this step. -In order to construct the API documentation, tox calls a helper script that -builds `.md` files from docstrings and templates. It can be invoked manually -with: +[mkdocs](https://www.mkdocs.org/) by tox. -```bash -python build_scripts/generate_api_docs.py -``` - -See the documentation inside the script for more details. Notebooks are an -integral part of the documentation as well, please read +Notebooks are an integral part of the documentation as well, please read [the section on notebooks](#notebooks) above. -It is important to note that sphinx does not listen to changes in the source -directory. If you want live updating of the auto-generated documentation (i.e. -any rst files which are not manually created), you can use a file watcher. -This is not part of the development setup of pyDVL (yet! PRs welcome), but -modern IDEs provide functionality for this. - Use the **docs** tox environment to build the documentation the same way it is done in CI: @@ -197,8 +196,8 @@ documentation on changes to the `docs` folder: tox -e docs-dev ``` -**Again:** this only rebuilds on changes to `.rst` files and notebooks inside -`docs`. +This will rebuild the documentation on changes to `.md` files inside `docs`, +notebooks and python files. ### Using bibliography From 7686b55462dfc777933b966cf79106e114020ed2 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 30 Jun 2023 16:56:27 +0200 Subject: [PATCH 145/436] Add changelog to built docs --- build_scripts/copy_changelog.py | 38 +++++++++++++++++++++++++++++++++ mkdocs.yml | 1 + 2 files changed, 39 insertions(+) create mode 100644 build_scripts/copy_changelog.py diff --git a/build_scripts/copy_changelog.py b/build_scripts/copy_changelog.py new file mode 100644 index 000000000..b2ef8cbf5 --- /dev/null +++ b/build_scripts/copy_changelog.py @@ -0,0 +1,38 @@ +import logging +import os +import shutil +from pathlib import Path + +import mkdocs.plugins + +logger = logging.getLogger(__name__) + +root_dir = Path(__file__).parent.parent +docs_dir = root_dir / "docs" +changelog_file = root_dir / "CHANGELOG.md" +changelog_docs_file = docs_dir / changelog_file.name + + +@mkdocs.plugins.event_priority(100) +def on_pre_build(config): + logger.info("Temporarily copying changelog to docs directory") + try: + if os.path.getmtime(changelog_file) <= os.path.getmtime(changelog_docs_file): + logger.info( + f"Changelog '{os.fspath(changelog_file)}' hasn't been updated, skipping." + ) + return + except FileNotFoundError: + pass + logger.info( + f"Copying '{os.fspath(changelog_file)}' to '{os.fspath(changelog_docs_file)}'" + ) + shutil.copy2(src=changelog_file, dst=changelog_docs_file) + + logger.info("Finished copying changelog to docs directory") + + +@mkdocs.plugins.event_priority(-100) +def on_shutdown(): + logger.info("Removing temporary changelog in docs directory") + changelog_docs_file.unlink() diff --git a/mkdocs.yml b/mkdocs.yml index a3f6b58a1..3f6ebaf28 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -9,6 +9,7 @@ watch: hooks: - build_scripts/copy_notebooks.py + - build_scripts/copy_changelog.py plugins: - mike From d341cd2d19b9d4e05efa68eb51336ae57c6d85d8 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 30 Jun 2023 17:02:36 +0200 Subject: [PATCH 146/436] Add patch version to publish docs version --- .github/workflows/publish.yaml | 2 +- .github/workflows/tox.yaml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/publish.yaml b/.github/workflows/publish.yaml index b276dbe7c..c15f2813d 100644 --- a/.github/workflows/publish.yaml +++ b/.github/workflows/publish.yaml @@ -77,7 +77,7 @@ jobs: - name: Deploy Docs if: ${{ github.ref == 'refs/heads/develop' }} run: | - export CURRENT_VERSION=$(python setup.py --version --quiet | awk -F. '{print $1"."$2}') + export CURRENT_VERSION=$(python setup.py --version --quiet | awk -F. '{print $1"."$2"."$3}') export ALIAS=stable tox -e docs-deploy - name: Build and publish to PyPI diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index b970e252e..40da7c704 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -125,7 +125,7 @@ jobs: - name: Deploy Docs if: ${{ github.ref == 'refs/heads/develop' }} run: | - export CURRENT_VERSION=$(python setup.py --version --quiet | awk -F. '{print $1"."$2}') + export CURRENT_VERSION=$(python setup.py --version --quiet | awk -F. '{print $1"."$2"."$3}') export ALIAS=latest tox -e docs-deploy - name: Build and publish to TestPyPI From 839a22c83a36b6e19fd0a5c7f3eb68472662accf Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 30 Jun 2023 18:01:01 +0200 Subject: [PATCH 147/436] Add missing paper to readme --- README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/README.md b/README.md index 2201e8c9e..d9efb4923 100644 --- a/README.md +++ b/README.md @@ -74,6 +74,9 @@ model. We implement methods from the following papers: Influence Functions](http://proceedings.mlr.press/v70/koh17a.html). In Proceedings of the 34th International Conference on Machine Learning, 70:1885–94. Sydney, Australia: PMLR, 2017. +- Naman Agarwal, Brian Bullins, and Elad Hazan, [Second-Order Stochastic Optimization + for Machine Learning in Linear Time](https://www.jmlr.org/papers/v18/16-491.html), + Journal of Machine Learning Research 18 (2017): 1-40. # Installation From 27a73ac4ce68e491a47a4025bae7f225a8fb5c5d Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 2 Jul 2023 13:28:18 +0200 Subject: [PATCH 148/436] Move tmcs into permutation_montecarlo_shapley --- src/pydvl/value/shapley/common.py | 23 ++--- src/pydvl/value/shapley/montecarlo.py | 125 +++++++++++++++++++---- src/pydvl/value/shapley/truncated.py | 141 +++++--------------------- src/pydvl/value/shapley/types.py | 2 +- 4 files changed, 138 insertions(+), 153 deletions(-) diff --git a/src/pydvl/value/shapley/common.py b/src/pydvl/value/shapley/common.py index 751185cbd..f6d698bd8 100644 --- a/src/pydvl/value/shapley/common.py +++ b/src/pydvl/value/shapley/common.py @@ -46,12 +46,9 @@ def compute_shapley_values( Shapley. Computation is **not parallelized**. Implemented in :func:`~pydvl.value.shapley.naive.permutation_exact_shapley`. - ``permutation_montecarlo``: uses the approximate Monte Carlo - implementation of permutation data Shapley. Implemented in + implementation of permutation data Shapley. Accepts a + :class:`TruncationPolicy` to stop computing marginals. Implemented in :func:`~pydvl.value.shapley.montecarlo.permutation_montecarlo_shapley`. - - ``truncated_montecarlo``: default option, same as ``permutation_montecarlo`` - but stops the computation whenever a certain accuracy is reached. - Implemented in - :func:`~pydvl.value.shapley.montecarlo.truncated_montecarlo_shapley`. - ``owen_sampling``: Uses the Owen continuous extension of the utility function to the unit cube. Implemented in :func:`~pydvl.value.shapley.montecarlo.owen_sampling_shapley`. This @@ -98,7 +95,11 @@ def compute_shapley_values( if mode not in list(ShapleyMode): raise ValueError(f"Invalid value encountered in {mode=}") - if mode == ShapleyMode.TruncatedMontecarlo: + if mode in ( + ShapleyMode.PermutationMontecarlo, + ShapleyMode.ApproShapley, + ShapleyMode.TruncatedMontecarlo, + ): truncation = kwargs.pop("truncation", NoTruncation()) return truncated_montecarlo_shapley( # type: ignore u=u, done=done, n_jobs=n_jobs, truncation=truncation, **kwargs @@ -107,16 +108,6 @@ def compute_shapley_values( return combinatorial_montecarlo_shapley( u, done=done, n_jobs=n_jobs, progress=progress ) - elif mode in (ShapleyMode.PermutationMontecarlo, ShapleyMode.ApproShapley): - truncation = kwargs.pop("truncation", NoTruncation()) - return permutation_montecarlo_shapley( - u, - done=done, - n_jobs=n_jobs, - progress=progress, - truncation=truncation, - **kwargs, - ) elif mode == ShapleyMode.CombinatorialExact: return combinatorial_exact_shapley(u, n_jobs=n_jobs, progress=progress) elif mode == ShapleyMode.PermutationExact: diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index ad43edad1..5b33e38be 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -33,21 +33,24 @@ import logging import math import operator +from concurrent.futures import FIRST_COMPLETED, wait from functools import reduce from itertools import cycle, takewhile from typing import Sequence import numpy as np +from deprecate import deprecated from numpy.typing import NDArray from tqdm import tqdm +from pydvl.utils import effective_n_jobs, init_executor, init_parallel_backend from pydvl.utils.config import ParallelConfig from pydvl.utils.numeric import random_powerset from pydvl.utils.parallel import MapReduceJob from pydvl.utils.utility import Utility from pydvl.value.result import ValuationResult from pydvl.value.shapley.truncated import NoTruncation, TruncationPolicy -from pydvl.value.stopping import StoppingCriterion +from pydvl.value.stopping import MaxChecks, StoppingCriterion logger = logging.getLogger(__name__) @@ -104,6 +107,36 @@ def _permutation_montecarlo_shapley( return result +def _permutation_montecarlo_one_step( + u: Utility, + truncation: TruncationPolicy, + algorithm: str, +) -> ValuationResult: + + result = _permutation_montecarlo_shapley( + u, + done=MaxChecks(1), + truncation=truncation, + algorithm_name=algorithm, + ) + nans = np.isnan(result.values).sum() + if nans > 0: + logger.warning( + f"{nans} NaN values in current permutation, ignoring. " + "Consider setting a default value for the Scorer" + ) + result = ValuationResult.empty(algorithm="truncated_montecarlo_shapley") + return result + + +@deprecated( + target=True, + deprecated_in="0.6.2", + remove_in="0.7.0", + args_mapping=dict( + coordinator_update_period=None, worker_update_period=None, progress=None + ), +) def permutation_montecarlo_shapley( u: Utility, done: StoppingCriterion, @@ -111,18 +144,37 @@ def permutation_montecarlo_shapley( truncation: TruncationPolicy = NoTruncation(), n_jobs: int = 1, config: ParallelConfig = ParallelConfig(), - progress: bool = False, ) -> ValuationResult: - r"""Computes an approximate Shapley value by sampling independent index - permutations to approximate the sum: + r"""Computes an approximate Shapley value by sampling independent + permutations of the index set, approximating the sum: $$ v_u(x_i) = \frac{1}{n!} \sum_{\sigma \in \Pi(n)} \tilde{w}( | \sigma_{:i} | )[u(\sigma_{:i} \cup \{i\}) − u(\sigma_{:i})], $$ - where $\sigma_{:i}$ denotes the set of indices in permutation sigma before the - position where $i$ appears (see :ref:`data valuation` for details). + where $\sigma_{:i}$ denotes the set of indices in permutation sigma before + the position where $i$ appears (see :ref:`data valuation` for details). + + This implements the method described in :footcite:t:`ghorbani_data_2019` + with a double stopping criterion. + + .. todo:: + Think of how to add Robin-Gelman or some other more principled stopping + criterion. + + Instead of naively implementing the expectation, we sequentially add points + to coalitions from a permutation and incrementally compute marginal utilities. + We stop computing marginals for a given permutation based on a + :class:`TruncationPolicy`. :footcite:t:`ghorbani_data_2019` mention two + policies: one that stops after a certain fraction of marginals are computed, + implemented in :class:`FixedTruncation`, and one that stops if the last + computed utility ("score") is close to the total utility using the standard + deviation of the utility as a measure of proximity, implemented in + :class:`BootstrapTruncation`. + + We keep sampling permutations and updating all shapley values + until the :class:`StoppingCriterion` returns ``True``. :param u: Utility object with model, data, and scoring function. :param done: function checking whether computation must stop. @@ -135,21 +187,52 @@ def permutation_montecarlo_shapley( :param progress: Whether to display progress bars for each job. :return: Object with the data values. """ - - map_reduce_job: MapReduceJob[Utility, ValuationResult] = MapReduceJob( - u, - map_func=_permutation_montecarlo_shapley, - reduce_func=lambda results: reduce(operator.add, results), - map_kwargs=dict( - algorithm_name="permutation_montecarlo_shapley", - done=done, - truncation=truncation, - progress=progress, - ), - config=config, - n_jobs=n_jobs, - ) - return map_reduce_job() + algorithm = "permutation_montecarlo_shapley" + + parallel_backend = init_parallel_backend(config) + u = parallel_backend.put(u) + # This represents the number of jobs that are running + n_jobs = effective_n_jobs(n_jobs, config) + # This determines the total number of submitted jobs + # including the ones that are running + n_submitted_jobs = 2 * n_jobs + + accumulated_result = ValuationResult.zeros(algorithm=algorithm) + + with init_executor(max_workers=n_jobs, config=config) as executor: + futures = set() + # Initial batch of computations + for _ in range(n_submitted_jobs): + future = executor.submit( + _permutation_montecarlo_one_step, + u, + truncation, + algorithm, + ) + futures.add(future) + while futures: + # Wait for the next futures to complete. + completed_futures, futures = wait( + futures, timeout=60, return_when=FIRST_COMPLETED + ) + for future in completed_futures: + accumulated_result += future.result() + if done(accumulated_result): + break + if done(accumulated_result): + break + # Submit more computations + # The goal is to always have `n_jobs` + # computations running + for _ in range(n_submitted_jobs - len(futures)): + future = executor.submit( + _permutation_montecarlo_one_step, + u, + truncation, + algorithm, + ) + futures.add(future) + return accumulated_result def _combinatorial_montecarlo_shapley( diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 23b871699..05dfbcfea 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -1,15 +1,12 @@ import abc import logging -from concurrent.futures import FIRST_COMPLETED, wait import numpy as np from deprecate import deprecated from pydvl.utils import ParallelConfig, Utility, running_moments -from pydvl.utils.parallel.backend import effective_n_jobs, init_parallel_backend -from pydvl.utils.parallel.futures import init_executor from pydvl.value import ValuationResult -from pydvl.value.stopping import MaxChecks, StoppingCriterion +from pydvl.value.stopping import StoppingCriterion __all__ = [ "TruncationPolicy", @@ -160,35 +157,10 @@ def reset(self): self.variance = self.mean = 0 -def _permutation_montecarlo_one_step( - u: Utility, - truncation: TruncationPolicy, - algorithm: str, -) -> ValuationResult: - # Avoid circular imports - from .montecarlo import _permutation_montecarlo_shapley - - result = _permutation_montecarlo_shapley( - u, - done=MaxChecks(1), - truncation=truncation, - algorithm_name=algorithm, - ) - nans = np.isnan(result.values).sum() - if nans > 0: - logger.warning( - f"{nans} NaN values in current permutation, ignoring. " - "Consider setting a default value for the Scorer" - ) - result = ValuationResult.empty(algorithm="truncated_montecarlo_shapley") - return result - - @deprecated( target=True, - deprecated_in="0.6.1", + deprecated_in="0.6.2", remove_in="0.7.0", - args_mapping=dict(coordinator_update_period=None, worker_update_period=None), ) def truncated_montecarlo_shapley( u: Utility, @@ -200,89 +172,28 @@ def truncated_montecarlo_shapley( coordinator_update_period: int = 10, worker_update_period: int = 5, ) -> ValuationResult: - """Monte Carlo approximation to the Shapley value of data points. - - This implements the permutation-based method described in - :footcite:t:`ghorbani_data_2019`. It is a Monte Carlo estimate of the sum - over all possible permutations of the index set, with a double stopping - criterion. - - .. todo:: - Think of how to add Robin-Gelman or some other more principled stopping - criterion. - - Instead of naively implementing the expectation, we sequentially add points - to a dataset from a permutation and incrementally compute marginal utilities. - We stop computing marginals for a given permutation based on a - :class:`TruncationPolicy`. :footcite:t:`ghorbani_data_2019` mention two - policies: one that stops after a certain fraction of marginals are computed, - implemented in :class:`FixedTruncation`, and one that stops if the last - computed utility ("score") is close to the total utility using the standard - deviation of the utility as a measure of proximity, implemented in - :class:`BootstrapTruncation`. - - We keep sampling permutations and updating all shapley values - until the :class:`StoppingCriterion` returns ``True``. - - :param u: Utility object with model, data, and scoring function - :param done: Check on the results which decides when to stop - sampling permutations. - :param truncation: callable that decides whether to stop computing - marginals for a given permutation. - :param config: Object configuring parallel computation, with cluster - address, number of cpus, etc. - :param n_jobs: Number of permutation monte carlo jobs - to run concurrently. - :param coordinator_update_period: in seconds. How often to check the - accumulated results from the workers for convergence. - :param worker_update_period: interval in seconds between different - updates to and from the coordinator - :return: Object with the data values. - """ - algorithm = "truncated_montecarlo_shapley" - - parallel_backend = init_parallel_backend(config) - u = parallel_backend.put(u) - # This represents the number of jobs that are running - n_jobs = effective_n_jobs(n_jobs, config) - # This determines the total number of submitted jobs - # including the ones that are running - n_submitted_jobs = 2 * n_jobs - - accumulated_result = ValuationResult.zeros(algorithm=algorithm) - - with init_executor(max_workers=n_jobs, config=config) as executor: - futures = set() - # Initial batch of computations - for _ in range(n_submitted_jobs): - future = executor.submit( - _permutation_montecarlo_one_step, - u, - truncation, - algorithm, - ) - futures.add(future) - while futures: - # Wait for the next futures to complete. - completed_futures, futures = wait( - futures, timeout=60, return_when=FIRST_COMPLETED - ) - for future in completed_futures: - accumulated_result += future.result() - if done(accumulated_result): - break - if done(accumulated_result): - break - # Submit more computations - # The goal is to always have `n_jobs` - # computations running - for _ in range(n_submitted_jobs - len(futures)): - future = executor.submit( - _permutation_montecarlo_one_step, - u, - truncation, - algorithm, - ) - futures.add(future) - return accumulated_result + .. warning:: + This method is deprecated and only a wrapper for + :func:`~pydvl.value.shapley.montecarlo.permutation_montecarlo_shapley`. + + :param u: + :param done: + :param truncation: + :param config: + :param n_jobs: + :param coordinator_update_period: + :param worker_update_period: + :return: + """ + from pydvl.value.shapley.montecarlo import permutation_montecarlo_shapley + + return permutation_montecarlo_shapley( + u, + done=done, + truncation=truncation, + config=config, + n_jobs=n_jobs, + coordinator_update_period=coordinator_update_period, + worker_update_period=worker_update_period, + ) diff --git a/src/pydvl/value/shapley/types.py b/src/pydvl/value/shapley/types.py index 3b0d80d3d..04da0f8f4 100644 --- a/src/pydvl/value/shapley/types.py +++ b/src/pydvl/value/shapley/types.py @@ -17,4 +17,4 @@ class ShapleyMode(str, Enum): OwenAntithetic = "owen_antithetic" PermutationExact = "permutation_exact" PermutationMontecarlo = "permutation_montecarlo" - TruncatedMontecarlo = "truncated_montecarlo" + TruncatedMontecarlo = "truncated_montecarlo" # Alias for PermutationMontecarlo From 6474a8d670d17eeb95c1d6b8755941a366d97026 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 2 Jul 2023 13:42:23 +0200 Subject: [PATCH 149/436] Update valuation doc --- docs/30-data-valuation.rst | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-) diff --git a/docs/30-data-valuation.rst b/docs/30-data-valuation.rst index b3fd5018e..a42f483aa 100644 --- a/docs/30-data-valuation.rst +++ b/docs/30-data-valuation.rst @@ -300,7 +300,7 @@ v_u(i) = \int_0^1 \mathbb{E}_{S \sim P_q(D_{\backslash \{ i \}})} Using Owen sampling follows the same pattern as every other method for Shapley values in pyDVL. First construct the dataset and utility, then call -:func:`~pydvl.value.shapley.compute_shapley_values`: +:func:`~pydvl.value.shapley.common.compute_shapley_values`: .. code-block:: python @@ -326,7 +326,7 @@ integration. Permutation Shapley ^^^^^^^^^^^^^^^^^^^ -An equivalent way of computing Shapley values (``ApproShapley``) appeared in +An equivalent way of computing Shapley values (**ApproShapley**) appeared in :footcite:t:`castro_polynomial_2009` and is the basis for the method most often used in practice. It uses permutations over indices instead of subsets: @@ -343,9 +343,17 @@ combinatorial approach above is that the approximations always fulfill the efficiency axiom of Shapley, namely $\sum_{i=1}^n \hat{v}_i = u(D)$ (see :footcite:t:`castro_polynomial_2009`, Proposition 3.2). -By adding early stopping, the result is the so-called **Truncated Monte Carlo -Shapley** (:footcite:t:`ghorbani_data_2019`), which is efficient enough to be -useful in applications. +By adding early stopping within single permutations, the result is the so-called +**Truncated Monte Carlo Shapley** (:footcite:t:`ghorbani_data_2019`), which is +efficient enough to be useful in applications. + +The method names ``appro_shapley``, ``permutation_montecarlo`` and +``truncated_montecarlo`` are all synonyms. The +:class:`~pydvl.value.shapley.truncated.TruncationPolicy` for the iteration over +a single permutation is configured with the argument ``truncation`` of +:func:`~pydvl.value.shapley.common.compute_shapley_values`. See all derived classes for +available options. + .. code-block:: python @@ -356,7 +364,10 @@ useful in applications. data = Dataset(...) utility = Utility(model, data) values = compute_shapley_values( - u=utility, mode="truncated_montecarlo", done=MaxUpdates(1000) + u=utility, + mode="permutation_montecarlo", + done=MaxUpdates(1000), + truncation= ) @@ -679,8 +690,8 @@ nature of every (non-trivial) ML problem can have an effect: inaccurate values. pyDVL offers a dedicated :func:`function composition - ` for scorer functions which can be used to - squash a score. The following is defined in module :mod:`~pydvl.utils.scorer`: + ` for scorer functions which can be used to + squash a score. The following is defined in module :mod:`~pydvl.utils.score`: .. code-block:: python From 5ff30de7d7770eb3d19a7ad1a36d311633b8b4e5 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 2 Jul 2023 14:00:31 +0200 Subject: [PATCH 150/436] More doc improvements --- docs/30-data-valuation.rst | 13 ++++++++----- src/pydvl/value/shapley/truncated.py | 8 ++++++++ 2 files changed, 16 insertions(+), 5 deletions(-) diff --git a/docs/30-data-valuation.rst b/docs/30-data-valuation.rst index a42f483aa..471096ef1 100644 --- a/docs/30-data-valuation.rst +++ b/docs/30-data-valuation.rst @@ -351,23 +351,26 @@ The method names ``appro_shapley``, ``permutation_montecarlo`` and ``truncated_montecarlo`` are all synonyms. The :class:`~pydvl.value.shapley.truncated.TruncationPolicy` for the iteration over a single permutation is configured with the argument ``truncation`` of -:func:`~pydvl.value.shapley.common.compute_shapley_values`. See all derived classes for -available options. +:func:`~pydvl.value.shapley.common.compute_shapley_values`. The implementation +of the methods described in the original paper are in +:class:`~pydvl.value.shapley.truncated.RelativeTruncation` and +:class:`~` .. code-block:: python from pydvl.utils import Dataset, Utility - from pydvl.value import compute_shapley_values + from pydvl.value import * model = ... data = Dataset(...) utility = Utility(model, data) + # Truncated Monte Carlo Shapley, configured as in the paper values = compute_shapley_values( u=utility, mode="permutation_montecarlo", - done=MaxUpdates(1000), - truncation= + done=MaxUpdates(1000) | HistoryDeviation(n_steps=100, rtol=0.05), + truncation=RelativeTruncation(u, rtol=0.01) ) diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 05dfbcfea..d6cd975ad 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -75,6 +75,14 @@ def reset(self): class FixedTruncation(TruncationPolicy): """Break a permutation after computing a fixed number of marginals. + The experiments in Appendix B of :footcite:t:`ghorbani_data_2019` show + that when the training set size is large enough, one can simply truncate the + iteration over permutations after a fixed number of steps. This happens + because beyond a certain number of samples in a training set, the model + becomes insensitive to new ones. Alas, this strongly depends on the data + distribution and the model and there is no automatic way of estimating this + number. + :param u: Utility object with model, data, and scoring function :param fraction: Fraction of marginals in a permutation to compute before stopping (e.g. 0.5 to compute half of the marginals). From c75e08a8a3f8ad9fbcd6bbc09aab7ff5a7cad04f Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 2 Jul 2023 14:26:27 +0200 Subject: [PATCH 151/436] Fix in deprecation --- src/pydvl/value/shapley/truncated.py | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index d6cd975ad..5b0112102 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -169,6 +169,7 @@ def reset(self): target=True, deprecated_in="0.6.2", remove_in="0.7.0", + args_mapping=dict(coordinator_update_period=None, worker_update_period=None), ) def truncated_montecarlo_shapley( u: Utility, @@ -197,11 +198,5 @@ def truncated_montecarlo_shapley( from pydvl.value.shapley.montecarlo import permutation_montecarlo_shapley return permutation_montecarlo_shapley( - u, - done=done, - truncation=truncation, - config=config, - n_jobs=n_jobs, - coordinator_update_period=coordinator_update_period, - worker_update_period=worker_update_period, - ) + u, done=done, truncation=truncation, config=config, n_jobs=n_jobs + ) # type: ignore From bc0508a65d70ce22900670253a14952a115b5641 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 11 Jul 2023 15:31:30 +0200 Subject: [PATCH 152/436] Update contributing docs --- CONTRIBUTING.md | 8 +++++--- tox.ini | 2 +- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 4ce14e453..168c8ac85 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -62,7 +62,7 @@ sudo apt-get update -yq && apt-get install -yq pandoc ``` Remember to mark all autogenerated directories as excluded in your IDE. In -particular `docs/_build` and `.tox` should be marked as excluded to avoid +particular `docs_build` and `.tox` should be marked as excluded to avoid slowdowns when searching or refactoring code. If you use remote execution, don't forget to exclude data paths from deployment @@ -131,8 +131,10 @@ if os.environ.get('CI'): training_data = training_data[:10] ``` -This switching should happen in a function, not in the notebook: we want to -avoid as much clutter and boilerplate as possible in the notebooks themselves. +This switching should happen in a separate notebook cell tagged with +`hide` to hide the cell's input and output when rendering it as part of +the documents. We want to avoid as much clutter and boilerplate +as possible in the notebooks themselves. Because we want documentation to include the full dataset, we commit notebooks with their outputs running with full datasets to the repo. The notebooks are diff --git a/tox.ini b/tox.ini index 8352c6651..030022715 100644 --- a/tox.ini +++ b/tox.ini @@ -1,5 +1,5 @@ [tox] -envlist = base, report +envlist = base, report, docs wheel = true [testenv] From 158843df6fb6ce8ee33dcbb85ebbcda6402795a4 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 12 Jul 2023 08:10:57 +0200 Subject: [PATCH 153/436] Do not pin loky dependency to single version --- requirements.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/requirements.txt b/requirements.txt index 0df829a93..ab192ce70 100644 --- a/requirements.txt +++ b/requirements.txt @@ -6,8 +6,8 @@ scipy>=1.7.0 cvxpy>=1.3.0 ray>=0.8 joblib +loky>=3.0.0 pymemcache cloudpickle tqdm -matplotlib -loky==3.0.0 \ No newline at end of file +matplotlib \ No newline at end of file From f79426c8a63b197b5818a5b32b2ab7f3db8fd844 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Wed, 12 Jul 2023 09:50:38 +0200 Subject: [PATCH 154/436] [skip ci] Rename low rank method to Arnoldi, as discussed in review --- src/pydvl/influence/frameworks/torch_differentiable.py | 2 +- src/pydvl/influence/inversion.py | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 14de297d3..b25f9c2d7 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -431,7 +431,7 @@ def hessian( ) -def solve_low_rank( +def solve_arnoldi( model: TorchTwiceDifferentiable, training_data: DataLoader, b: torch.Tensor, diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index c64345387..7b27b2b80 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -17,7 +17,7 @@ __all__ = ["solve_hvp"] -from .frameworks.torch_differentiable import solve_low_rank +from .frameworks.torch_differentiable import solve_arnoldi logger = logging.getLogger(__name__) @@ -30,7 +30,7 @@ class InversionMethod(str, Enum): Direct = "direct" Cg = "cg" Lissa = "lissa" - LowRank = "low_rank" + Arnoldi = "arnoldi" def solve_hvp( @@ -90,8 +90,8 @@ def solve_hvp( hessian_perturbation=hessian_perturbation, progress=progress, ) - elif inversion_method == InversionMethod.LowRank: - return solve_low_rank( + elif inversion_method == InversionMethod.Arnoldi: + return solve_arnoldi( model, # type: ignore # TODO the interface TwiceDifferentiable is not used properly anyhow training_data, b, From 5afbdd8fe5483cf440d2c68a594bef21cbdc8144 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Wed, 12 Jul 2023 12:06:07 +0200 Subject: [PATCH 155/436] [skip ci] Fix broken tests, due to renaming --- tests/influence/test_influences.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index e53f12e6e..dcaa19428 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -97,7 +97,7 @@ def analytical_linear_influences( [InversionMethod.Cg, {}, 1e-1], [InversionMethod.Lissa, {"maxiter": 6000, "scale": 100}, 0.3], ], - ids=[inv.value for inv in InversionMethod if inv is not InversionMethod.LowRank], + ids=[inv.value for inv in InversionMethod if inv is not InversionMethod.Arnoldi], ) def test_influence_linear_model( influence_type: InfluenceType, @@ -367,7 +367,7 @@ def closure(): test_cases.values(), ids=test_cases.keys(), ) -def test_influences_nn_low_rank( +def test_influences_arnoldi( nn_architecture: nn.Module, input_dim: Tuple[int], output_dim: int, @@ -411,7 +411,7 @@ def test_influences_nn_low_rank( test_data=test_data_loader, progress=True, influence_type=influence_type, - inversion_method=InversionMethod.LowRank, + inversion_method=InversionMethod.Arnoldi, hessian_regularization=hessian_reg, # as the hessian of the small shallow networks is in general not low rank, so for these test cases, we choose # the rank estimate as high as possible From d6898d62c21a8689ae4d0aa1f983975dd691b3b8 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 12 Jul 2023 14:20:42 +0200 Subject: [PATCH 156/436] Implement JoblibParallelBackend class --- src/pydvl/utils/parallel/backend.py | 65 ++++++++++ src/pydvl/utils/parallel/map_reduce.py | 162 ++++--------------------- tests/utils/test_parallel.py | 59 +-------- 3 files changed, 93 insertions(+), 193 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index f9840d77d..0e1a9bc37 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -14,7 +14,9 @@ Union, ) +import joblib import ray +from joblib import Parallel, delayed from ray import ObjectRef from ..config import ParallelConfig @@ -122,6 +124,69 @@ def _effective_n_jobs(self, n_jobs: int) -> int: return 1 +class JoblibParallelBackend(BaseParallelBackend, backend_name="joblib"): + """Class used to wrap joblib to make it transparent to algorithms. + + It shouldn't be initialized directly. You should instead call + :func:`~pydvl.utils.parallel.backend.init_parallel_backend`. + + :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with + cluster address, number of cpus, etc. + """ + + def __init__(self, config: ParallelConfig): + config_dict = asdict(config) + config_dict.pop("backend") + n_cpus_local = config_dict.pop("n_cpus_local") + config_dict["n_jobs"] = n_cpus_local + self.config = config_dict + # In joblib the levels are reversed. + # 0 means no logging and 50 means log everything to stdout + verbose = 50 - config_dict["logging_level"] + self.parallel = Parallel(n_jobs=config_dict["n_jobs"], verbose=verbose) + # Needed to reuse the pool of workers + self.parallel._managed_backend = True + self.parallel._calling = False + self.parallel._initialize_backend() + + def get( + self, + v: T, + *args, + **kwargs, + ) -> T: + return v + + def put(self, v: T, *args, **kwargs) -> Union[T]: + return v + + def wrap(self, fun: Callable, **kwargs) -> Callable: + """Wraps a function as a joblib delayed. + + :param fun: the function to wrap + + :return: The delayed function. + """ + return delayed(fun) # type: ignore + + def wait( + self, + v: List[T], + *args, + **kwargs, + ) -> Tuple[List[T], List[T]]: + return v, [] + + def _effective_n_jobs(self, n_jobs: int) -> int: + if n_jobs < 0: + if (eff_n_jobs := self.config["n_jobs"]) is not None: + return eff_n_jobs + else: + return joblib.effective_n_jobs(n_jobs) + else: + return n_jobs + + class RayParallelBackend(BaseParallelBackend, backend_name="ray"): """Class used to wrap ray to make it transparent to algorithms. diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index c7fd3ff6a..06708c545 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -1,22 +1,9 @@ -import inspect -from functools import singledispatch, update_wrapper from itertools import accumulate, repeat -from typing import ( - Any, - Callable, - Dict, - Generic, - List, - Optional, - Sequence, - TypeVar, - Union, -) - -import numpy as np -import ray +from typing import Callable, Dict, Generic, List, Optional, Sequence, TypeVar, Union + +from joblib import Parallel, delayed from numpy.typing import NDArray -from ray import ObjectRef +from ray.util.joblib import register_ray from ..config import ParallelConfig from ..types import maybe_add_argument @@ -30,49 +17,9 @@ MapFunction = Callable[..., R] ReduceFunction = Callable[[List[R]], R] -ChunkifyInputType = Union[NDArray[T], Sequence[T], T] - - -def _wrap_func_with_remote_args(func: Callable, *, timeout: Optional[float] = None): - def wrapper(*args, **kwargs): - args = list(args) - for i, v in enumerate(args[:]): - args[i] = _get_value(v, timeout=timeout) - for k, v in kwargs.items(): - kwargs[k] = _get_value(v, timeout=timeout) - return func(*args, **kwargs) - - try: - inspect.signature(func) - wrapper = update_wrapper(wrapper, func) - except ValueError: - # Doing it manually here because using update_wrapper from functools - # on numpy functions doesn't work with ray for some unknown reason. - wrapper.__name__ = func.__name__ - wrapper.__qualname__ = func.__qualname__ - wrapper.__doc__ = func.__doc__ - return wrapper - - -@singledispatch -def _get_value(v: Any, *, timeout: Optional[float] = None) -> Any: - return v -@_get_value.register -def _(v: ObjectRef, *, timeout: Optional[float] = None) -> Any: - return ray.get(v, timeout=timeout) - - -@_get_value.register -def _(v: np.ndarray, *, timeout: Optional[float] = None) -> NDArray: - return v - - -# Careful to use list as hint. The dispatch does not work with typing generics -@_get_value.register -def _(v: list, *, timeout: Optional[float] = None) -> List[Any]: - return [_get_value(x, timeout=timeout) for x in v] +register_ray() class MapReduceJob(Generic[T, R]): @@ -182,83 +129,22 @@ def __init__( def __call__( self, ) -> R: - map_results = self.map(self.inputs_) - reduce_results = self.reduce(map_results) - return reduce_results - - def map(self, inputs: Union[Sequence[T], T]) -> List["ObjectRef[R]"]: - """Splits the input data into chunks and calls a wrapped :func:`map_func` on them.""" - map_results: List["ObjectRef[R]"] = [] - - map_func = self._wrap_function(self._map_func) - - total_n_jobs = 0 - total_n_finished = 0 - - chunks = self._chunkify(inputs, n_chunks=self.n_jobs) - - for j, next_chunk in enumerate(chunks): - result = map_func(next_chunk, job_id=j, **self.map_kwargs) - map_results.append(result) - total_n_jobs += 1 - - total_n_finished = self._backpressure( - map_results, - n_dispatched=total_n_jobs, - n_finished=total_n_finished, - ) - return map_results - - def reduce(self, chunks: List["ObjectRef[R]"]) -> R: - """Reduces the resulting chunks from a call to :meth:`~pydvl.utils.parallel.map_reduce.MapReduceJob.map` - by passing them to a wrapped :func:`reduce_func`.""" - reduce_func = self._wrap_function(self._reduce_func) - - reduce_result = reduce_func(chunks, **self.reduce_kwargs) - result = self.parallel_backend.get(reduce_result, timeout=self.timeout) - return result # type: ignore - - def _wrap_function(self, func: Callable, **kwargs) -> Callable: - """Wraps a function with a timeout and remote arguments and puts it on - the remote backend. - - :param func: Function to wrap - :param kwargs: Additional keyword arguments to pass to the backend - wrapper. These are *not* arguments for the wrapped function. - :return: Remote function that can be called with the same arguments as - the wrapped function. Depending on the backend, this may simply be - the function itself. - """ - return self.parallel_backend.wrap( - _wrap_func_with_remote_args(func, timeout=self.timeout), **kwargs - ) - - def _backpressure( - self, jobs: List[ObjectRef], n_dispatched: int, n_finished: int - ) -> int: - """This is used to limit the number of concurrent tasks. - If :attr:`~pydvl.utils.parallel.map_reduce.MapReduceJob.max_parallel_tasks` is None then this function - is a no-op that simply returns 0. - - See https://docs.ray.io/en/latest/ray-core/patterns/limit-pending-tasks.html - :param jobs: - :param n_dispatched: - :param n_finished: - :return: - """ - if self.max_parallel_tasks is None: - return 0 - while (n_in_flight := n_dispatched - n_finished) > self.max_parallel_tasks: - wait_for_num_jobs = n_in_flight - self.max_parallel_tasks - finished_jobs, _ = self.parallel_backend.wait( - jobs, - num_returns=wait_for_num_jobs, - timeout=10, # FIXME make parameter? + if self.config.backend == "joblib": + backend = "loky" + else: + backend = self.config.backend + with Parallel(backend=backend, n_jobs=self.n_jobs) as parallel: + chunks = self._chunkify(self.inputs_, n_chunks=self.n_jobs) + map_results: List[R] = parallel( + delayed(self._map_func)(next_chunk, job_id=j, **self.map_kwargs) + for j, next_chunk in enumerate(chunks) ) - n_finished += len(finished_jobs) - return n_finished + reduce_results: R = self._reduce_func(map_results, **self.reduce_kwargs) + return reduce_results - def _chunkify(self, data: ChunkifyInputType, n_chunks: int) -> List["ObjectRef[T]"]: + def _chunkify( + self, data: Union[NDArray[T], Sequence[T], T], n_chunks: int + ) -> List[Union[NDArray[T], Sequence[T], T]]: """If data is a Sequence, it splits it into Sequences of size `n_chunks` for each job that we call chunks. If instead data is an `ObjectRef` instance, then it yields it repeatedly `n_chunks` number of times. """ @@ -266,16 +152,14 @@ def _chunkify(self, data: ChunkifyInputType, n_chunks: int) -> List["ObjectRef[T raise ValueError("Number of chunks should be greater than 0") if n_chunks == 1: - data_id = self.parallel_backend.put(data) - return [data_id] + return [data] try: # This is used as a check to determine whether data is iterable or not # if it's the former, then the value will be used to determine the chunk indices. n = len(data) except TypeError: - data_id = self.parallel_backend.put(data) - return list(repeat(data_id, times=n_chunks)) + return list(repeat(data, times=n_chunks)) else: # This is very much inspired by numpy's array_split function # The difference is that it only uses built-in functions @@ -294,8 +178,8 @@ def _chunkify(self, data: ChunkifyInputType, n_chunks: int) -> List["ObjectRef[T for start_index, end_index in zip(chunk_indices[:-1], chunk_indices[1:]): if start_index >= end_index: break - chunk_id = self.parallel_backend.put(data[start_index:end_index]) - chunks.append(chunk_id) + chunk = data[start_index:end_index] + chunks.append(chunk) return chunks diff --git a/tests/utils/test_parallel.py b/tests/utils/test_parallel.py index 2d0037abd..6d691e746 100644 --- a/tests/utils/test_parallel.py +++ b/tests/utils/test_parallel.py @@ -9,7 +9,6 @@ from pydvl.utils.parallel import MapReduceJob, init_parallel_backend from pydvl.utils.parallel.backend import available_cpus, effective_n_jobs from pydvl.utils.parallel.futures import init_executor -from pydvl.utils.parallel.map_reduce import _get_value def test_effective_n_jobs(parallel_config, num_workers): @@ -121,10 +120,9 @@ def test_map_reduce_job(map_reduce_job_and_parameters, indices, expected): (np.arange(10), 4, np.array_split(np.arange(10), 4)), ], ) -def test_chunkification(data, n_chunks, expected_chunks): - map_reduce_job = MapReduceJob([], map_func=lambda x: x) +def test_chunkification(parallel_config, data, n_chunks, expected_chunks): + map_reduce_job = MapReduceJob([], map_func=lambda x: x, config=parallel_config) chunks = list(map_reduce_job._chunkify(data, n_chunks)) - chunks = map_reduce_job.parallel_backend.get(chunks) for x, y in zip(chunks, expected_chunks): if not isinstance(x, np.ndarray): assert x == y @@ -132,41 +130,6 @@ def test_chunkification(data, n_chunks, expected_chunks): assert (x == y).all() -@pytest.mark.parametrize( - "max_parallel_tasks, n_finished, n_dispatched, expected_n_finished", - [ - (1, 3, 6, 5), - (3, 3, 3, 3), - (10, 1, 15, 5), - (20, 1, 3, 1), - ], -) -def test_backpressure( - max_parallel_tasks, n_finished, n_dispatched, expected_n_finished -): - def map_func(x): - import time - - time.sleep(1) - return x - - inputs_ = list(range(n_dispatched)) - - map_reduce_job = MapReduceJob( - inputs_, - map_func=map_func, - max_parallel_tasks=max_parallel_tasks, - timeout=10, - ) - - map_func = map_reduce_job._wrap_function(map_func) - jobs = [map_func(x) for x in inputs_] - n_finished = map_reduce_job._backpressure( - jobs, n_finished=n_finished, n_dispatched=n_dispatched - ) - assert n_finished == expected_n_finished - - def test_map_reduce_job_partial_map_and_reduce_func(parallel_config): def map_func(x, y): return x + y @@ -187,22 +150,10 @@ def reduce_func(x, y): assert result == 150 -@pytest.mark.parametrize( - "x, expected_x", - [ - (None, None), - ([0, 1], [0, 1]), - (np.arange(3), np.arange(3)), - ], -) -def test_map_reduce_get_value(x, expected_x, parallel_config): - assert np.all(_get_value(x) == expected_x) - parallel_backend = init_parallel_backend(parallel_config) - x_id = parallel_backend.put(x) - assert np.all(_get_value(x_id) == expected_x) - - def test_wrap_function(parallel_config, num_workers): + if parallel_config.backend == "joblib": + pytest.skip() + def fun(x, **kwargs): return dict(x=x * x, **kwargs) From 4ae66f2334bd8add8b661c8750d6106cddd49f1c Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 12 Jul 2023 14:26:49 +0200 Subject: [PATCH 157/436] Remove unused arguments from MapReduceJob, register ray joblib backend in RayParallelBackend --- src/pydvl/utils/parallel/backend.py | 3 +++ src/pydvl/utils/parallel/map_reduce.py | 34 +++++++++++--------------- 2 files changed, 17 insertions(+), 20 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index 0e1a9bc37..cb432bab3 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -18,6 +18,7 @@ import ray from joblib import Parallel, delayed from ray import ObjectRef +from ray.util.joblib import register_ray from ..config import ParallelConfig @@ -206,6 +207,8 @@ def __init__(self, config: ParallelConfig): self.config = config_dict if not ray.is_initialized(): ray.init(**self.config) + # Register ray joblib backend + register_ray() def get( self, diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index 06708c545..ed57209ce 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -1,9 +1,18 @@ from itertools import accumulate, repeat -from typing import Callable, Dict, Generic, List, Optional, Sequence, TypeVar, Union +from typing import ( + Any, + Callable, + Dict, + Generic, + List, + Optional, + Sequence, + TypeVar, + Union, +) from joblib import Parallel, delayed from numpy.typing import NDArray -from ray.util.joblib import register_ray from ..config import ParallelConfig from ..types import maybe_add_argument @@ -13,13 +22,13 @@ T = TypeVar("T") R = TypeVar("R") -Identity = lambda x, *args, **kwargs: x MapFunction = Callable[..., R] ReduceFunction = Callable[[List[R]], R] -register_ray() +def identity(x: T, *args: Any, **kwargs: Any) -> T: + return x class MapReduceJob(Generic[T, R]): @@ -41,14 +50,6 @@ class MapReduceJob(Generic[T, R]): :param config: Instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. :param n_jobs: Number of parallel jobs to run. Does not accept 0 - :param timeout: Amount of time in seconds to wait for remote results before - ... TODO - :param max_parallel_tasks: Maximum number of jobs to start in parallel. Any - tasks above this number won't be submitted to the backend before some - are done. This is to avoid swamping the work queue. Note that tasks have - a low memory footprint, so this is probably not a big concern, except - in the case of an infinite stream (not the case for MapReduceJob). See - https://docs.ray.io/en/latest/ray-core/patterns/limit-pending-tasks.html :Examples: @@ -83,14 +84,13 @@ def __init__( self, inputs: Union[Sequence[T], T], map_func: MapFunction[R], - reduce_func: Optional[ReduceFunction[R]] = None, + reduce_func: ReduceFunction[R] = identity, map_kwargs: Optional[Dict] = None, reduce_kwargs: Optional[Dict] = None, config: ParallelConfig = ParallelConfig(), *, n_jobs: int = -1, timeout: Optional[float] = None, - max_parallel_tasks: Optional[int] = None, ): self.config = config parallel_backend = init_parallel_backend(self.config) @@ -98,17 +98,11 @@ def __init__( self.timeout = timeout - self._n_jobs = 1 # This uses the setter defined below self.n_jobs = n_jobs - self.max_parallel_tasks = max_parallel_tasks - self.inputs_ = inputs - if reduce_func is None: - reduce_func = Identity - if map_kwargs is None: self.map_kwargs = dict() else: From ec8ae3ec389f5ab24a754ad63e2d09e53f823075 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 12 Jul 2023 14:27:01 +0200 Subject: [PATCH 158/436] Set joblib as default backend --- src/pydvl/utils/config.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pydvl/utils/config.py b/src/pydvl/utils/config.py index e7c7f7d91..0b24c1572 100644 --- a/src/pydvl/utils/config.py +++ b/src/pydvl/utils/config.py @@ -21,7 +21,7 @@ class ParallelConfig: :param logging_level: Logging level for the parallel backend's worker. """ - backend: Literal["sequential", "joblib", "ray"] = "ray" + backend: Literal["sequential", "joblib", "ray"] = "joblib" address: Optional[Union[str, Tuple[str, int]]] = None n_cpus_local: Optional[int] = None logging_level: int = logging.WARNING From 367c216488c5673560e296b4df04fbc3e5375606 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 12 Jul 2023 14:27:10 +0200 Subject: [PATCH 159/436] Remove unused import --- tests/utils/test_parallel.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/utils/test_parallel.py b/tests/utils/test_parallel.py index 6d691e746..0764aabee 100644 --- a/tests/utils/test_parallel.py +++ b/tests/utils/test_parallel.py @@ -7,7 +7,7 @@ import pytest from pydvl.utils.parallel import MapReduceJob, init_parallel_backend -from pydvl.utils.parallel.backend import available_cpus, effective_n_jobs +from pydvl.utils.parallel.backend import effective_n_jobs from pydvl.utils.parallel.futures import init_executor From bd1b1af5f77c42742d371c4377009a2f17b83d95 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 12 Jul 2023 14:36:09 +0200 Subject: [PATCH 160/436] better inversion method info and remove concatenation from general --- src/pydvl/influence/frameworks/__init__.py | 4 + .../frameworks/torch_differentiable.py | 60 +++++++++++---- src/pydvl/influence/general.py | 75 +++++++++++-------- src/pydvl/influence/inversion.py | 7 +- tests/influence/test_torch_differentiable.py | 8 +- 5 files changed, 105 insertions(+), 49 deletions(-) diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index a918ab1d9..af717ffaa 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -25,6 +25,8 @@ solve_linear, solve_lissa, stack, + transpose_tensor, + zero_tensor, ) TensorType = torch.Tensor @@ -41,6 +43,8 @@ "as_tensor", "stack", "cat", + "zero_tensor", + "transpose_tensor", "einsum", "mvp", ] diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index fd182926e..9e620c94f 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -5,7 +5,7 @@ influence of a training point on the model. """ import logging -from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple +from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union import numpy as np import torch @@ -25,11 +25,15 @@ "as_tensor", "stack", "cat", + "zero_tensor", + "transpose_tensor", "einsum", "mvp", ] logger = logging.getLogger(__name__) +TORCH_DTYPES = {"float32": torch.float32, "float64": torch.float64} + def flatten_all(grad: torch.Tensor) -> torch.Tensor: """ @@ -45,7 +49,7 @@ def solve_linear( *, hessian_perturbation: float = 0.0, progress: bool = False, -) -> torch.Tensor: +) -> Tuple[torch.Tensor, Dict[str, Any]]: """Given a model and training data, it finds x s.t. $Hx = b$, with $H$ being the model hessian. @@ -56,7 +60,8 @@ def solve_linear( :param progress: If True, display progress bars. :return: An array that solves the inverse problem, - i.e. it returns $x$ such that $Hx = b$ + i.e. it returns $x$ such that $Hx = b$, and a dictionary containing + information about the solution. """ all_x, all_y = [], [] for x, y in training_data: @@ -67,7 +72,8 @@ def solve_linear( matrix = model.hessian( all_x, all_y, progress=progress ) + hessian_perturbation * identity_tensor(model.num_params, device=model.device) - return torch.linalg.solve(matrix, b.T).T + info = {"hessian": matrix} + return torch.linalg.solve(matrix, b.T).T, info def solve_batch_cg( @@ -81,7 +87,7 @@ def solve_batch_cg( atol: float = 1e-7, maxiter: Optional[int] = None, progress: bool = False, -) -> torch.Tensor: +) -> Tuple[torch.Tensor, Dict[int, Dict[str, Any]]]: """ Given a model and training data, it uses conjugate gradient to calculate the inverse of the Hessian Vector Product. More precisely, it finds x s.t. $Hx = @@ -98,7 +104,9 @@ def solve_batch_cg( :param maxiter: maximum number of iterations. If None, defaults to 10*len(b) :param progress: If True, display progress bars. - :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$. + :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$, + and a dictionary containing information about the convergence of CG, one + entry for each line of the matrix. """ total_grad_xy = 0 total_points = 0 @@ -111,10 +119,14 @@ def solve_batch_cg( total_grad_xy / total_points, v, backprop_on ) + hessian_perturbation * v.type(torch.float64) batch_cg = torch.zeros_like(b) + info = {} for idx, bi in enumerate(maybe_progress(b, progress, desc="Conjugate gradient")): - bi_cg, _ = solve_cg(reg_hvp, bi, x0=x0, rtol=rtol, atol=atol, maxiter=maxiter) + bi_cg, bi_info = solve_cg( + reg_hvp, bi, x0=x0, rtol=rtol, atol=atol, maxiter=maxiter + ) batch_cg[idx] = bi_cg - return batch_cg + info[idx] = bi_info + return batch_cg, info def solve_cg( @@ -134,6 +146,9 @@ def solve_cg( :param rtol: maximum relative tolerance of result :param atol: absolute tolerance of result :param maxiter: maximum number of iterations. If None, defaults to 10*len(b) + + :return: A vector x, solution of $Ax=b$, and a dictionary containing + information about the convergence of CG. """ if x0 is None: x0 = torch.clone(b) @@ -161,7 +176,7 @@ def solve_cg( gamma = gamma_ p = r + beta * p - info = {"niter": k, "optimal": optimal} + info = {"niter": k, "optimal": optimal, "gamma": gamma} return x, info @@ -177,7 +192,7 @@ def solve_lissa( h0: Optional[torch.Tensor] = None, rtol: float = 1e-4, progress: bool = False, -) -> torch.Tensor: +) -> Tuple[torch.Tensor, Dict[str, Any]]: r""" Uses LISSA, Linear time Stochastic Second-Order Algorithm, to iteratively approximate the inverse Hessian. More precisely, it finds x s.t. $Hx = b$, @@ -200,7 +215,8 @@ def solve_lissa( :param scale: scaling factor, defaults to 10 :param h0: initial guess for hvp - :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$. + :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$, + and a dictionary containing information about the accuracy of the solution. """ if h0 is None: h_estimate = torch.clone(b) @@ -233,11 +249,16 @@ def lissa_step( max_residual = torch.max(torch.abs(residual / h_estimate)) if max_residual < rtol: break + mean_residual = torch.mean(torch.abs(residual / h_estimate)) logger.info( f"Terminated Lissa with {max_residual*100:.2f} % max residual." - f" Mean residual: {torch.mean(torch.abs(residual/h_estimate))*100:.5f} %" + f" Mean residual: {mean_residual*100:.5f} %" ) - return h_estimate / scale + info = { + "max_perc_residual": max_residual * 100, + "mean_perc_residual": mean_residual * 100, + } + return h_estimate / scale, info def as_tensor(a: Any, warn=True, **kwargs) -> torch.Tensor: @@ -261,6 +282,19 @@ def cat(a: Sequence[torch.Tensor], **kwargs) -> torch.Tensor: return torch.cat(a, **kwargs) +def zero_tensor( + shape: Sequence[int], dtype: Union[np.dtype, torch.dtype], **kwargs +) -> torch.Tensor: + """Returns a tensor of shape :attr:`shape` filled with zeros.""" + if isinstance(dtype, np.dtype): + dtype = TORCH_DTYPES[str(dtype)] + return torch.zeros(shape, dtype=dtype, **kwargs) + + +def transpose_tensor(a: torch.Tensor, dim0: int, dim1: int) -> torch.Tensor: + return torch.transpose(a, dim0, dim1) + + def einsum(equation, *operands) -> torch.Tensor: """Sums the product of the elements of the input :attr:`operands` along dimensions specified using a notation based on the Einstein summation convention. diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 40c95f41e..195ad4816 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -4,18 +4,17 @@ """ from copy import deepcopy from enum import Enum -from typing import Any, Dict, Optional +from typing import Any, Dict, Optional, Tuple from ..utils import maybe_progress from .frameworks import ( DataLoaderType, - ModelType, TensorType, TwiceDifferentiable, - cat, einsum, mvp, - stack, + transpose_tensor, + zero_tensor, ) from .inversion import InversionMethod, solve_hvp @@ -40,7 +39,7 @@ def compute_influence_factors( hessian_perturbation: float = 0.0, progress: bool = False, **kwargs: Any, -) -> TensorType: +) -> Tuple[TensorType, Dict]: r""" Calculates influence factors of a model for training and test data. Given a test point $z_test = (x_{test}, y_{test})$, a loss @@ -64,12 +63,17 @@ def compute_influence_factors( :returns: An array of size (N, D) containing the influence factors for each dimension (D) and test sample (N). """ - test_grads = [] - for x_test, y_test in maybe_progress( - test_data, progress, desc="Batch Test Gradients" + test_grads = zero_tensor( + shape=(len(test_data.dataset), model.num_params), + dtype=test_data.dataset[0][0].dtype, + ) + for batch_idx, (x_test, y_test) in enumerate( + maybe_progress(test_data, progress, desc="Batch Test Gradients") ): - test_grads.append(model.split_grad(x_test, y_test, progress=False)) - test_grads = cat(test_grads) + idx = batch_idx * test_data.batch_size + test_grads[idx : idx + test_data.batch_size] = model.split_grad( + x_test, y_test, progress=False + ) return solve_hvp( inversion_method, model, @@ -102,16 +106,21 @@ def compute_influences_up( influence of. :param influence_factors: array containing influence factors :param progress: If True, display progress bars. - :returns: An array of size [NxM], where N is number of test points and M - number of train points. + :returns: An array of size [NxM], where N is number of influence factors, M + number of input points. """ - train_grads = [] - for x, y in maybe_progress( - input_data, progress, desc="Batch Split Input Gradients" + grads = zero_tensor( + shape=(len(input_data.dataset), model.num_params), + dtype=input_data.dataset[0][0].dtype, + ) + for batch_idx, (x, y) in enumerate( + maybe_progress(input_data, progress, desc="Batch Split Input Gradients") ): - train_grads.append(model.split_grad(x, y, progress=False)) - train_grads = cat(train_grads) - return einsum("ta,va->tv", influence_factors, train_grads) + idx = batch_idx * input_data.batch_size + grads[idx : idx + input_data.batch_size] = model.split_grad( + x, y, progress=False + ) + return einsum("ta,va->tv", influence_factors, grads) def compute_influences_pert( @@ -135,14 +144,20 @@ def compute_influences_pert( influence of. :param influence_factors: array containing influence factors :param progress: If True, display progress bars. - :returns: An array of size [NxMxP], where N is number of test points, M - number of train points, and P the number of features. + :returns: An array of size [NxMxP], where N is the number of influence factors, M + the number of input data, and P the number of features. """ - all_pert_influences = [] - for x, y in maybe_progress( - input_data, - progress, - desc="Batch Influence Perturbation", + input_x = input_data.dataset[0][0] + all_pert_influences = zero_tensor( + shape=(len(input_data.dataset), len(influence_factors), *input_x.shape), + dtype=input_x.dtype, + ) + for batch_idx, (x, y) in enumerate( + maybe_progress( + input_data, + progress, + desc="Batch Influence Perturbation", + ) ): for i in range(len(x)): grad_xy, tensor_x = model.grad(x[i : i + 1], y[i], x_requires_grad=True) @@ -151,11 +166,11 @@ def compute_influences_pert( influence_factors, backprop_on=tensor_x, ) - all_pert_influences.append( - perturbation_influences.reshape((-1, *x[i].shape)) - ) + all_pert_influences[ + batch_idx * input_data.batch_size + i + ] = perturbation_influences.reshape((-1, *x[i].shape)) - return stack(all_pert_influences, axis=1) + return transpose_tensor(all_pert_influences, 0, 1) influence_type_registry = { @@ -207,7 +222,7 @@ def compute_influences( if test_data is None: test_data = deepcopy(training_data) - influence_factors = compute_influence_factors( + influence_factors, _ = compute_influence_factors( differentiable_model, training_data, test_data, diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index ae5ec2c03..99ad193cb 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -3,7 +3,7 @@ """ import logging from enum import Enum -from typing import Any, Dict +from typing import Any, Dict, Tuple from .frameworks import ( DataLoaderType, @@ -39,7 +39,7 @@ def solve_hvp( hessian_perturbation: float = 0.0, progress: bool = False, **kwargs: Any, -) -> TensorType: +) -> Tuple[TensorType, Dict]: """ Finds $x$ such that $Ax = b$, where $A$ is the hessian of model, and $b$ a vector. @@ -58,7 +58,8 @@ def solve_hvp( :param progress: If True, display progress bars. :return: An array that solves the inverse problem, - i.e. it returns $x$ such that $Ax = b$ + i.e. it returns $x$ such that $Ax = b$, and a dictionary containing + information about the inversion process. """ if inversion_method == InversionMethod.Direct: return solve_linear( diff --git a/tests/influence/test_torch_differentiable.py b/tests/influence/test_torch_differentiable.py index 3c952ddab..ae0ab52de 100644 --- a/tests/influence/test_torch_differentiable.py +++ b/tests/influence/test_torch_differentiable.py @@ -177,9 +177,11 @@ def test_inversion_methods( train_data_loader = DataLoader(list(zip(train_x, train_y)), batch_size=128) b = torch.rand(size=(10, mvp_model.num_params), dtype=torch.float64) - linear_inverse = solve_linear(mvp_model, train_data_loader, b) - linear_cg = solve_batch_cg(mvp_model, train_data_loader, b) - linear_lissa = solve_lissa(mvp_model, train_data_loader, b, maxiter=5000, scale=5) + linear_inverse, _ = solve_linear(mvp_model, train_data_loader, b) + linear_cg, _ = solve_batch_cg(mvp_model, train_data_loader, b) + linear_lissa, _ = solve_lissa( + mvp_model, train_data_loader, b, maxiter=5000, scale=5 + ) assert np.allclose(linear_inverse, linear_cg, rtol=1e-1) assert np.allclose(linear_inverse, linear_lissa, rtol=1e-1) From 33be4b1ac625aae9d691206dd4b746f1cf4e004c Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 12 Jul 2023 15:01:46 +0200 Subject: [PATCH 161/436] Remove sequential parallel backend --- src/pydvl/utils/config.py | 4 +-- src/pydvl/utils/parallel/backend.py | 39 ++++------------------------- tests/utils/conftest.py | 8 ++---- tests/utils/test_parallel.py | 34 +++++++++++-------------- 4 files changed, 23 insertions(+), 62 deletions(-) diff --git a/src/pydvl/utils/config.py b/src/pydvl/utils/config.py index 0b24c1572..36b9ab647 100644 --- a/src/pydvl/utils/config.py +++ b/src/pydvl/utils/config.py @@ -14,14 +14,14 @@ class ParallelConfig: """Configuration for parallel computation backend. :param backend: Type of backend to use. - Defaults to 'ray' + Defaults to 'joblib' :param address: Address of existing remote or local cluster to use. :param n_cpus_local: Number of CPUs to use when creating a local ray cluster. This has no effect when using an existing ray cluster. :param logging_level: Logging level for the parallel backend's worker. """ - backend: Literal["sequential", "joblib", "ray"] = "joblib" + backend: Literal["joblib", "ray"] = "joblib" address: Optional[Union[str, Tuple[str, int]]] = None n_cpus_local: Optional[int] = None logging_level: int = logging.WARNING diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index cb432bab3..66cb55529 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -1,5 +1,7 @@ +import atexit import os from abc import ABCMeta, abstractmethod +from contextlib import ExitStack from dataclasses import asdict from typing import ( Any, @@ -94,37 +96,6 @@ def __repr__(self) -> str: return f"<{self.__class__.__name__}: {self.config}>" -class SequentialParallelBackend(BaseParallelBackend, backend_name="sequential"): - """Class used to run jobs sequentially and locally. - - It shouldn't be initialized directly. You should instead call - :func:`~pydvl.utils.parallel.backend.init_parallel_backend`. - - :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with number of cpus - """ - - def __init__(self, config: ParallelConfig): - self.config = {} - - def get(self, v: Any, *args, **kwargs): - return v - - def put(self, v: Any, *args, **kwargs) -> Any: - return v - - def wrap(self, fun: Callable, **kwargs) -> Callable: - """Wraps a function for sequential execution. - - This is a noop and kwargs are ignored.""" - return fun - - def wait(self, v: Any, *args, **kwargs) -> Tuple[list, list]: - return v, [] - - def _effective_n_jobs(self, n_jobs: int) -> int: - return 1 - - class JoblibParallelBackend(BaseParallelBackend, backend_name="joblib"): """Class used to wrap joblib to make it transparent to algorithms. @@ -146,9 +117,9 @@ def __init__(self, config: ParallelConfig): verbose = 50 - config_dict["logging_level"] self.parallel = Parallel(n_jobs=config_dict["n_jobs"], verbose=verbose) # Needed to reuse the pool of workers - self.parallel._managed_backend = True - self.parallel._calling = False - self.parallel._initialize_backend() + exit_stack = ExitStack() + exit_stack.enter_context(self.parallel) + atexit.register(exit_stack.close) def get( self, diff --git a/tests/utils/conftest.py b/tests/utils/conftest.py index 0b68783c2..f64330777 100644 --- a/tests/utils/conftest.py +++ b/tests/utils/conftest.py @@ -5,13 +5,9 @@ from pydvl.utils.config import ParallelConfig -@pytest.fixture( - scope="module", params=["sequential", "joblib", "ray-local", "ray-external"] -) +@pytest.fixture(scope="module", params=["joblib", "ray-local", "ray-external"]) def parallel_config(request, num_workers): - if request.param == "sequential": - yield ParallelConfig(backend=request.param) - elif request.param == "joblib": + if request.param == "joblib": yield ParallelConfig(backend="joblib", n_cpus_local=num_workers) elif request.param == "ray-local": yield ParallelConfig(backend="ray", n_cpus_local=num_workers) diff --git a/tests/utils/test_parallel.py b/tests/utils/test_parallel.py index 0764aabee..343205e8c 100644 --- a/tests/utils/test_parallel.py +++ b/tests/utils/test_parallel.py @@ -13,17 +13,12 @@ def test_effective_n_jobs(parallel_config, num_workers): parallel_backend = init_parallel_backend(parallel_config) - if parallel_config.backend == "sequential": - assert parallel_backend.effective_n_jobs(1) == 1 - assert parallel_backend.effective_n_jobs(4) == 1 - assert parallel_backend.effective_n_jobs(-1) == 1 + assert parallel_backend.effective_n_jobs(1) == 1 + assert parallel_backend.effective_n_jobs(4) == 4 + if parallel_config.address is None: + assert parallel_backend.effective_n_jobs(-1) == num_workers else: - assert parallel_backend.effective_n_jobs(1) == 1 - assert parallel_backend.effective_n_jobs(4) == 4 - if parallel_config.address is None: - assert parallel_backend.effective_n_jobs(-1) == num_workers - else: - assert parallel_backend.effective_n_jobs(-1) == num_workers + assert parallel_backend.effective_n_jobs(-1) == num_workers for n_jobs in [-1, 1, 2]: assert parallel_backend.effective_n_jobs(n_jobs) == effective_n_jobs( @@ -151,8 +146,8 @@ def reduce_func(x, y): def test_wrap_function(parallel_config, num_workers): - if parallel_config.backend == "joblib": - pytest.skip() + if parallel_config.backend != "ray": + pytest.skip("Only makes sense for ray") def fun(x, **kwargs): return dict(x=x * x, **kwargs) @@ -166,15 +161,14 @@ def fun(x, **kwargs): assert ret["x"] == 4 assert len(ret) == 1 # Ensure that kwargs are not passed to the function - if parallel_config.backend != "sequential": - # Test that the function is executed in different processes - def get_pid(): - time.sleep(2) # FIXME: waiting less means fewer processes are used?! - return os.getpid() + # Test that the function is executed in different processes + def get_pid(): + time.sleep(2) # FIXME: waiting less means fewer processes are used?! + return os.getpid() - wrapped_func = parallel_backend.wrap(get_pid, num_cpus=1) - pids = parallel_backend.get([wrapped_func() for _ in range(num_workers)]) - assert len(set(pids)) == num_workers + wrapped_func = parallel_backend.wrap(get_pid, num_cpus=1) + pids = parallel_backend.get([wrapped_func() for _ in range(num_workers)]) + assert len(set(pids)) == num_workers def test_futures_executor_submit(parallel_config): From 0c2db7f4d1217c2e64e28d593d63a4c2dfe19ce4 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 12 Jul 2023 16:35:55 +0200 Subject: [PATCH 162/436] move shapley convenience functions to notebook support --- notebooks/influence_synthetic.ipynb | 50 +++++--- notebooks/influence_wine.ipynb | 2 +- notebooks/shapley_basic_spotify.ipynb | 3 +- notebooks/support/shapley.py | 159 ++++++++++++++++++++++++++ src/pydvl/utils/dataset.py | 153 +------------------------ 5 files changed, 196 insertions(+), 171 deletions(-) create mode 100644 notebooks/support/shapley.py diff --git a/notebooks/influence_synthetic.ipynb b/notebooks/influence_synthetic.ipynb index 39a4dfb58..309ab0c24 100644 --- a/notebooks/influence_synthetic.ipynb +++ b/notebooks/influence_synthetic.ipynb @@ -54,10 +54,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "23cb0e79", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/fabio/miniconda3/envs/pydvl_env/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], "source": [ "%autoreload\n", "%matplotlib inline\n", @@ -70,7 +79,7 @@ "import torch.nn.functional as F\n", "import matplotlib.pyplot as plt\n", "from pydvl.influence import compute_influences, TorchTwiceDifferentiable\n", - "from pydvl.utils.dataset import (\n", + "from support.shapley import (\n", " synthetic_classification_dataset,\n", " decision_boundary_fixed_variance_2d,\n", ")\n", @@ -268,7 +277,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "Model fitting: 100%|██████████| 50/50 [00:02<00:00, 24.12it/s]\n" + "Model fitting: 0%| | 0/50 [00:00" ] @@ -353,7 +369,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAycAAAKvCAYAAABwPbCoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABFg0lEQVR4nO3deZhcZZk3/m91ts7WnRCykkDCpiAgAhIjiKIZIkFfHBDeOEGDMsBPAUEGFZVFUUFREUFM3F5ARZ1xARRZDMg6xCCbyo6yBUMWlqQhkK2rfn/EtLQJmEq6qk93fz7Xda6hzzlVz109Jum7v89znlKlUqkEAACgkzV0dgEAAACJ5gQAACgIzQkAAFAImhMAAKAQNCcAAEAhaE4AAIBC0JwAAACFoDkBAAAKoXdnF9CRyuVy5s+fn8GDB6dUKnV2OQAAPV6lUsnzzz+fMWPGpKGhZ/1efPny5Vm5cmWnjN23b980NjZ2ytibols1J/Pnz8+4ceM6uwwAAP7JvHnzMnbs2M4uo26WL1+eCVsNyoJFrZ0y/qhRo/Loo492uQalWzUngwcPTpL8+faRGTyoZ3XmQPdz+Gv37OwSADbZ6qzKLbmy7ee0nmLlypVZsKg1j98xPk2D6/tzacvz5Wy1+2NZuXKl5qQzrZ3KNXhQQ93/RwDQ0XqX+nR2CQCbrrLm//TUKfeDBpcyaHB9P3s5Xfd77Sd4AACgEDQnAABAIXSraV0AAFAkrZVyWiv1H7OrkpwAAACFIDkBAIAaKaeScuobndR7vI4kOQEAAApBcgIAADVSTjn1XgFS/xE7juQEAAAoBM0JAABQCKZ1AQBAjbRWKmmt1HeBer3H60iSEwAAoBAkJwAAUCMeJVwdyQkAAFAImhMAAKAQTOsCAIAaKaeSVtO6NpjkBAAAKATJCQAA1IgF8dWRnAAAAIUgOQEAgBqxCWN1JCcAAEAhaE4AAIBCMK0LAABqpPz3o95jdlWSEwAAoBAkJwAAUCOtnbAJY73H60iSEwAAoBA0JwAAQCGY1gUAADXSWllz1HvMrkpyAgAAFILkBAAAasSjhKsjOQEAAApBcgIAADVSTimtKdV9zK5KcgIAABSC5gQAACgE07oAAKBGypU1R73H7KokJwAAQCFITgAAoEZaO2FBfL3H60iSEwAAoBA0JwAAQCGY1gUAADViWld1JCcAAEAhSE4AAKBGypVSypU67xBf5/E6kuQEAAAoBMkJAADUiDUn1ZGcAAAAhaA5AQAACsG0LgAAqJHWNKS1znlAa11H61iSEwAAoBAkJwAAUCOVTniUcMWjhAEAADaN5gQAACgE07oAAKBG7HNSHckJAABQCJITAACokdZKQ1ordX6UcKWuw3UoyQkAAFAIkhMAAKiRckop1zkPKKfrRieSEwAAoBA0JwAAQCGY1gUAADXiUcLVkZwAAACFIDkBAIAa6ZxHCVsQDwAAsEk0JwAAQCGY1gUAADWyZp+T+i5Qr/d4HUlyAgAAFILkBAAAaqSchrTaIX6DSU4AAIBC0JwAAACFYFoXAADUiH1OqiM5AQAACkFyAgAANVJOQ8oWxG8wyQkAAFAIkhMAAKiR1koprZX6bopY7/E6kuQEAAAoBM0JAABQCKZ1AQBAjbR2wg7xrRbEAwAAbBrJCQAA1Ei50pBynTdhLNuEEQAAYNNoTgAAgEIwrQsAAGrEgvjqSE4AAIBCkJwAAECNlFP/HdvLdR2tY0lOAACAQpCcAABAjZTTkHKd84B6j9eRum7lAABAt6I5AQAACsG0LgAAqJHWSkNa67xDfL3H60hdt3IAAKBbkZwAAECNlFNKOfV+lHB9x+tIkhMAAKAQNCcAAEAhmNYFAAA1YkF8dbpu5QAAQLciOQEAgBppTUNa65wH1Hu8jtR1KwcAALoVyQkAANRIuVJKuVLnRwnXebyOJDkBAAAKQXMCAAAUgmldAABQI+VOWBBf7sL5Q9etHAAA2GStra059dRTM2HChPTv3z/bbLNNPv/5z6dSqbTdU6lUctppp2X06NHp379/Jk+enIcffrjd+zz77LOZPn16mpqaMmTIkBxxxBF54YUXqqpFcwIAADVSrjR0ylGNL3/5y5k5c2a++c1v5v7778+Xv/zlnH322Tn//PPb7jn77LNz3nnnZdasWZk7d24GDhyYKVOmZPny5W33TJ8+Pffee29mz56dK664IjfddFOOOuqoqmoxrQsAAHqwW2+9NQceeGAOOOCAJMn48ePzk5/8JLfddluSNanJueeem1NOOSUHHnhgkuQHP/hBRo4cmcsuuyzTpk3L/fffn6uvvjp/+MMfssceeyRJzj///EydOjVf/epXM2bMmA2qRXICAAA92Jvf/OZcd911eeihh5Ikf/zjH3PLLbdk//33T5I8+uijWbBgQSZPntz2mubm5kycODFz5sxJksyZMydDhgxpa0ySZPLkyWloaMjcuXM3uBbJCQAA1EhrSmlNffcdWTteS0tLu/P9+vVLv3791rn/5JNPTktLS1772temV69eaW1tzRe/+MVMnz49SbJgwYIkyciRI9u9buTIkW3XFixYkBEjRrS73rt372y22WZt92wIyQkAAHRD48aNS3Nzc9tx1llnrfe+//mf/8kll1ySH//4x7nzzjtz8cUX56tf/WouvvjiOlcsOQEAgJrZmAXqHTFmksybNy9NTU1t59eXmiTJxz/+8Zx88smZNm1akmTnnXfO448/nrPOOiszZszIqFGjkiQLFy7M6NGj2163cOHC7LrrrkmSUaNGZdGiRe3ed/Xq1Xn22WfbXr8hJCcAANANNTU1tTteqTl58cUX09DQvi3o1atXyuVykmTChAkZNWpUrrvuurbrLS0tmTt3biZNmpQkmTRpUpYsWZI77rij7Z7f/e53KZfLmThx4gbXLDkBAIAaaU06Yc1Jdd797nfni1/8Yrbccsu87nWvy1133ZVzzjknH/rQh5IkpVIpJ5xwQr7whS9ku+22y4QJE3LqqadmzJgxec973pMk2WGHHfLOd74zRx55ZGbNmpVVq1bl2GOPzbRp0zb4SV2J5gQAAHq0888/P6eeemo+8pGPZNGiRRkzZkyOPvronHbaaW33fOITn8iyZcty1FFHZcmSJdl7771z9dVXp7Gxse2eSy65JMcee2ze8Y53pKGhIQcffHDOO++8qmopVV6+9WMX19LSkubm5jz2wOg0DTZjDejaDh07qbNLANhkqyurckMuz9KlS9utf+ju1v5cetrcyWkc1KeuYy9/YVXOmHhtl/yeS04AAKBGOnNBfFfUdSsHAAC6FckJAADUSGulIa11TjLqPV5H6rqVAwAA3YrmBAAAKATTugAAoEYqKaVc531OKnUeryNJTgAAgEKQnAAAQI1YEF+drls5AADQrUhOAACgRsqVUsqV+q4Bqfd4HUlyAgAAFILmBAAAKATTugAAoEZa05DWOucB9R6vI3XdygEAgG5FcgIAADViQXx1JCcAAEAhaE4AAIBCMK0LAABqpJyGlOucB9R7vI7UdSsHAAC6FckJAADUSGullNY6L1Cv93gdSXICAAAUguQEAABqxKOEqyM5AQAACkFzAgAAFIJpXQAAUCOVSkPKlfrmAZU6j9eRum7lAABAtyI5AQCAGmlNKa2p86OE6zxeR5KcAAAAhaA5AQAACsG0LgAAqJFypf77jpQrdR2uQ0lOAACAQpCcAABAjZQ74VHC9R6vI3XdygEAgG5FckKP9sifBuYnX94yD90xKJVKKdvv/nwO+8zjGf+6F9vd98vzt8gdvx2aBY83ZvmyXhk2ekV2e8eSHPTRJ9M0bHXbfYvm9cuxk3Zb71jHX/BQ9jrwmZp+HoCX22XSC/nKL/663mvHv2vbPHDnwCTJ2T//S17/5mXr3HP79YPzmelb17RGgJfTnNBjPfLngTn133fK5mNW5L0fezKVcinX/GBkTn/v63LWFX/OmG2W/+PePw3MVq9bljcf+HT6Dyznyb/0z3U/HpE7rxuSs3/7pzQOKLd7770OfDpvePtz7c5tv/vzdflcAP/s0u9tnofuHtDu3PzH+rX7evH8Pvl/Z45ud+6ZhX5MgE1VTinlOu87Uu/xOpK/deix/vsr49K3sZwv/OqeDB66Jv14y0GLc/w+b8iPv7RlTvruQ233vvy/19p+t+dzztGvyR2zh66TiEzY+YXsc/DTtf0AABvonrkDc8tvhrzqPctaeuV3vxxan4IAXkEh15xccMEFGT9+fBobGzNx4sTcdtttnV0S3dADtw3Ozm9Z0taYJMnQkauy45tacud1Q7N82av/8RgxbkWSZFnL+nv85S82ZPXKrvubC6B76T+wNQ29Xv35og29Kmkc0FqniqBnaK2UOuXoqgqXnPz3f/93TjzxxMyaNSsTJ07MueeemylTpuTBBx/MiBEjOrs8upFVKxvSt7G8zvm+/VuzemVDnnhgQLbf/YW285VK8vxzvVNeXcpTjzbmx2dtmYZelbxu0tJ13uPnXx+XH31hfEqlSrbeZVmmfeKJvP6t694HUA//9fV5GTConNbVa1KU735+TB7+U/tpXltsvSKX/+XP6duvkmcX9c5Vl2yWS74+Kq2ru+4POUDXU7jm5JxzzsmRRx6ZD37wg0mSWbNm5Te/+U3+3//7fzn55JM7uTq6kzFbv5SH7xyccmvS0GvNudUrS/nLXYOTJM8u6Nvu/qWL++So3fZo+3rY6BX56Dcfzhbb/mNtSkNDJa9/65K88Z3PZrNRK7Po8X654rtjcub7d8gnL3wgu71jSc0/F8Baq1eVcvMVzbntd4PT8mzvbLn98rz3/1ucr136l3zswG3z13vWNChPPd4vf7x1UB67vzGNA8p5y7uWZvrHFmXsNity5v83vnM/BHRxHiVcnUI1JytXrswdd9yRT33qU23nGhoaMnny5MyZM6cTK6M72m/GwnzvU1tn5knb5MAPz0+5nPzyvLF5blGfJMnK5e3/YA8asjqn/OS+rFpRyqP3DMxtVw1bZ+rX5luszGcuub/duX0Ofjofe/vr84Mzxme3d9xd088E8HL33T4w990+sO3r3/+2ObdcMSQzr3swH/rUgrYncX39v8a1e911v9gsx589L1MPeza//M6ytqd6AdRaoZqTp59+Oq2trRk5cmS78yNHjswDDzywzv0rVqzIihUr2r5uaWmpeY10H/u9f2Gemd83v5o1Jjf+bM2UwW1e/0IO/PD8/PK8sWkc2H7ede++lezyljVTs3afvCQ77700p75n5zRvviq7T17yiuMMGro6+x66OJddsEWemd83w8asrNlnAvhX5j/WL3Ouac5e+y9NQ0Ml5fL6p2394tvDM/WwZ/OGt7ygOQHqplDNSbXOOuusfO5zn+vsMujC3vfJeXn30fPz5EMDMmBwa7bc4cX8+EtrfoM4Zuvlr/ra1+zxQoaOXJmbLx3+qs1Jkgwbs6aJfmFJb80J0OkWz++Tvv0qaRxQzosv9HqFe9ZMbR08ZPV6rwMbppxSynVeoN6VHyVcqAlpm2++eXr16pWFCxe2O79w4cKMGjVqnfs/9alPZenSpW3HvHnz6lUq3cigIa157Z7PZ8sd1my8+Oebh2TY6BUZs+1L//K1K5c35KWW9f/D/nILn2hMkjQNW7VpxQJ0gNFbrsyKl0p56VWeSjhqyzW/VFn6TJf+PSbQxRSqOenbt2923333XHfddW3nyuVyrrvuukyaNGmd+/v165empqZ2B2yKW381LH/946BM/c+n0vD3Px3LX2zIipfW/aPy+99slmVLe2frXf6xq3LLev4Rf/apvrn+pyOy1Q7LMnSk5gSon+bN1k09tt7xpbxpv5bcedPgVCqlDBjUmj59//nJhZX8xwmLkiR33Di4DpVC91X5+yaM9TwqXTg5KdyvQ0488cTMmDEje+yxR/bcc8+ce+65WbZsWdvTu6Cj3Pf7wfnFuWOzyz5LM3jo6jx056Dc8D8jsuvbnsvUI55qu2/Bo435/LQdM+n/PJMttnkppYZKHvnToNz8y80zfNzyTP3Pf9z7oy9ulYWPN2anvZZm6MiVWfxkv1z7o5FZ8VJDDv/cY53wKYGe7NOzHs+K5aXcf/vALHl6zdO6ph72bFa8VMr3v7hmN/htd34pJ3/r8dxw2ZDMf6xf+jWW8+b9l2anPV/Mb364Wf7y5wH/YhSAjlO45uT//t//m8WLF+e0007LggULsuuuu+bqq69eZ5E8bKrNRq1MQ6/kV7PGZPmyXhkxbnmmffyJvOuop9LrZX8yNhu9MhOnPpt7/7cpN/5seFpXlzJ8ixWZcviCHPTRv7XbxHGXfZZk9g9H5ZqLR2XZ0l4Z0NSaHSa25KDj/5atd162nioAaufWa5ry9n9fkoOOWpwBg1uz9JneueXK5lxyzsjMf6xfkmThk31y79yB2Wv/lgwdviqVSilPPNwv3/jE2Fz5o806+RMAPU2pUqm8+naxXUhLS0uam5vz2AOj0zS4UDPWAKp26Nh1p7MCdDWrK6tyQy7P0qVLe9QU/LU/lx587Yz0Gdj3X7+gA61atjK/mHxxl/ye+wkeAAAohMJN6wIAgO7CDvHV6bqVAwAA3YrkBAAAaqRc6YRNGOs8XkeSnAAAAIWgOQEAAArBtC4AAKiRtbu213vMrkpyAgAAFILkBAAAasSC+OpITgAAgELQnAAAAIVgWhcAANSIaV3VkZwAAACFIDkBAIAakZxUR3ICAAAUguQEAABqRHJSHckJAABQCJoTAACgEEzrAgCAGqkkKae+06wqdR2tY0lOAACAQpCcAABAjVgQXx3JCQAAUAiaEwAAoBBM6wIAgBoxras6khMAAKAQJCcAAFAjkpPqSE4AAIBCkJwAAECNSE6qIzkBAAAKQXMCAAAUgmldAABQI5VKKZU6T7Oq93gdSXICAAAUguQEAABqpJxSyqnzgvg6j9eRJCcAAEAhaE4AAIBCMK0LAABqxD4n1ZGcAAAAhSA5AQCAGvEo4epITgAAgEKQnAAAQI1Yc1IdyQkAAFAImhMAAKAQTOsCAIAasSC+OpITAACgECQnAABQI5VOWBAvOQEAANhEmhMAAKAQTOsCAIAaqSSpVOo/ZlclOQEAAApBcgIAADVSTiml1HmH+DqP15EkJwAAQCFITgAAoEZswlgdyQkAAFAImhMAAKAQTOsCAIAaKVdKKdV5mlW9d6TvSJITAACgECQnAABQI5VKJ2zC2IV3YZScAAAAhaA5AQAACsG0LgAAqBH7nFRHcgIAABSC5AQAAGpEclIdyQkAAFAImhMAAKAQTOsCAIAasUN8dSQnAABAIUhOAACgRuwQXx3JCQAAUAiSEwAAqJE1yUm9HyVc1+E6lOQEAAAoBM0JAABQCKZ1AQBAjdghvjqSEwAAoBAkJwAAUCOVvx/1HrOrkpwAAACFoDkBAAAKwbQuAACoEQviqyM5AQAACkFyAgAAtWJFfFUkJwAA0MP97W9/y2GHHZZhw4alf//+2XnnnXP77be3Xa9UKjnttNMyevTo9O/fP5MnT87DDz/c7j2effbZTJ8+PU1NTRkyZEiOOOKIvPDCC1XVoTkBAIBa+fuak3oeqXLNyXPPPZe99torffr0yVVXXZX77rsvX/va1zJ06NC2e84+++ycd955mTVrVubOnZuBAwdmypQpWb58eds906dPz7333pvZs2fniiuuyE033ZSjjjqqqlpM6wIAgB7sy1/+csaNG5cLL7yw7dyECRPa/rtSqeTcc8/NKaeckgMPPDBJ8oMf/CAjR47MZZddlmnTpuX+++/P1VdfnT/84Q/ZY489kiTnn39+pk6dmq9+9asZM2bMBtUiOQEAgG6opaWl3bFixYr13verX/0qe+yxRw455JCMGDEib3jDG/Ld73637fqjjz6aBQsWZPLkyW3nmpubM3HixMyZMydJMmfOnAwZMqStMUmSyZMnp6GhIXPnzt3gmjUnAABQI5VK5xxJMm7cuDQ3N7cdZ5111nprfOSRRzJz5sxst912ueaaa/LhD384H/3oR3PxxRcnSRYsWJAkGTlyZLvXjRw5su3aggULMmLEiHbXe/func0226ztng1hWhcAAHRD8+bNS1NTU9vX/fr1W+995XI5e+yxR84888wkyRve8Ibcc889mTVrVmbMmFGXWteSnAAAQI3UezH8yzd9bGpqane8UnMyevTo7Ljjju3O7bDDDnniiSeSJKNGjUqSLFy4sN09CxcubLs2atSoLFq0qN311atX59lnn227Z0NoTgAAoAfba6+98uCDD7Y799BDD2WrrbZKsmZx/KhRo3Lddde1XW9pacncuXMzadKkJMmkSZOyZMmS3HHHHW33/O53v0u5XM7EiRM3uBbTugAAoAf72Mc+lje/+c0588wzc+ihh+a2227Ld77znXznO99JkpRKpZxwwgn5whe+kO222y4TJkzIqaeemjFjxuQ973lPkjVJyzvf+c4ceeSRmTVrVlatWpVjjz0206ZN2+AndSWaEwAAqJ2N2HekQ8aswhvf+MZceuml+dSnPpUzzjgjEyZMyLnnnpvp06e33fOJT3wiy5Yty1FHHZUlS5Zk7733ztVXX53Gxsa2ey655JIce+yxecc73pGGhoYcfPDBOe+886qqpVSprF3P3/W1tLSkubk5jz0wOk2DzVgDurZDx07q7BIANtnqyqrckMuzdOnSdouzu7u1P5eO//6paRjQ+K9f0IHKLy7PY0d8vkt+zyUnAABQIy9/tG89x+yqxAsAAEAhSE4AAKBWKn8/6j1mFyU5AQAACkFzAgAAFIJpXQAAUCMv37G9nmN2VZITAACgECQnAABQS114gXq9SU4AAIBC0JwAAACFYFoXAADUiAXx1ZGcAAAAhSA5AQCAWrFDfFUkJwAAQCFITgAAoGZKfz/qPWbXJDkBAAAKQXMCAAAUgmldAABQKxbEV0VyAgAAFMIGJSc33XTTRr35Pvvss1GvAwCAbkFyUpUNak7e9ra3pVTa8FX/lUolpVIpra2tG10YAADQs2xQc3L99dfXug4AAKCH26Dm5K1vfWut6wAAgO6nUlpz1HvMLmqTF8Q/9dRT+eMf/5hly5Z1RD0AAEAPtdHNyeWXX57Xvva1GTt2bHbbbbfMnTs3SfL000/nDW94Qy677LKOqhEAALqkSqVzjq5qo5qTX//61znooIOy+eab5/TTT0/lZd+BzTffPFtssUUuvPDCDisSAADo/jaqOTnjjDOyzz775JZbbskxxxyzzvVJkyblrrvu2uTiAACgS6t00tFFbVRzcs899+TQQw99xesjR47MokWLNrooAACg59mo5mTAgAGvugD+kUceybBhwza6KAAAoOfZqOZk3333zcUXX5zVq1evc23BggX57ne/m/3222+TiwMAgC5t7aOE6310URvVnHzxi1/Mk08+mTe+8Y359re/nVKplGuuuSannHJKdt5551QqlZx++ukdXSsAANCNbVRz8prXvCa33HJLhg0bllNPPTWVSiVf+cpXcuaZZ2bnnXfOzTffnPHjx3dwqQAA0LWUKp1zdFUbtEP8+rzuda/Ltddem+eeey5/+ctfUi6Xs/XWW2f48OEdWR8AANBDbHRzstbQoUPzxje+sSNqAQAAerCN3iF+8eLFOemkk7LjjjtmwIABGTBgQHbcccecdNJJWbhwYUfWCAAAXZN9TqqyUc3Jvffem5133jnnnHNOmpubc8ghh+SQQw5Jc3NzzjnnnOyyyy655557OrpWAACgG9uoaV3HHHNMWltbM3fu3HWmdN12222ZOnVqjjvuuFx//fUdUiQAAHRJnfFo3572KOHbbrstxx9//HrXmuy55545/vjjM3fu3E0uDgAA6Dk2KjkZMWJEGhsbX/F6Y2NjRowYsdFFAQBAt9AZa0B62pqTE044ITNnzsyCBQvWuTZ//vzMnDkzJ5xwwqbWBgAA9CAblJycc84565wbNGhQtt122/z7v/97tt122yTJww8/nMsuuyzbbrttKpUu3LIBAAB1V6psQBfR0FB9wFIqldLa2rpRRW2slpaWNDc357EHRqdp8EY/JRmgEA4dO6mzSwDYZKsrq3JDLs/SpUvT1NTU2eXUzdqfS8d97fNp6P/KyyFqofzS8sz7r1O75Pd8g5KTRx99tNZ1AAAAPdwGNSdbbbVVresAAIDux4L4qpj7BAAAFMJGPUo4Sf70pz/l/PPPz5133pmlS5emXC63u14qlfLXv/51kwsEAAB6ho1KTm644YbsueeeueKKKzJmzJg88sgj2XrrrTNmzJg8/vjjGTRoUPbZZ5+OrhUAALqWtTvE1/voojaqOTnttNOy9dZb58EHH8yFF16YJPn0pz+dW265JbfeemuefPLJHHrooR1aKAAA0L1tVHNy55135ogjjkhTU1N69eqVJG2PDZ44cWKOPvronHrqqR1XJQAAdEGlSuccXdVGNSe9e/fO4MGDkyRDhgxJnz59smjRorbrW2+9de67776OqRAAAOgRNqo52XbbbfPwww8nWbPw/bWvfW0uvfTStuu/+c1vMmrUqI6pEAAA6BE2qjmZOnVqfvKTn2T16tVJkhNPPDG//OUvs91222W77bbLr371qxx99NEdWigAAHQ5lU46uqiNepTwqaeemuOPP75tvcmMGTPSq1ev/OIXv0ivXr3ymc98JocffnhH1gkAAHRzG9Wc9OnTJ8OGDWt37rDDDsthhx3WIUUBAAA9jx3iAQCAQtig5OTtb3971W9cKpVy3XXXVf06AADoLkqp/6N9u+4WjBvYnJTL5ZRK1X3MSqULr8QBAADqboOakxtuuKHGZXSsw1+7Z3qX+nR2GQCb5Jr5d3d2CQCbrOX5coZu39lV0FVs1IJ4AABgA1RKa456j9lFWRAPAAAUguQEAABqpTM2RezCS78lJwAAQCFoTgAAgEIwrQsAAGrFtK6qbFJz8re//S033XRTFi1alIMPPjhjx45Na2trli5dmubm5vTq1auj6gQAALq5jZrWValUcuKJJ2bChAmZPn16TjzxxDz00ENJkhdeeCHjx4/P+eef36GFAgBAV1OqdM7RVW1Uc/KVr3wl3/jGN3LSSSdl9uzZ7XaDb25uzkEHHZRf/OIXHVYkAADQ/W3UtK7vfve7+cAHPpAzzzwzzzzzzDrXd9lll1x11VWbXBwAAHRp1pxUZaOSk3nz5uXNb37zK14fOHBgWlpaNrooAACg59mo5mTEiBGZN2/eK16/4447suWWW250UQAAQM+zUc3JQQcdlFmzZuWRRx5pO1cqlZIkv/3tb3PRRRflkEMO6ZgKAQCgq6p00tFFbVRz8rnPfS6jR4/Orrvumg984AMplUr58pe/nL333jv7779/dtlll3z605/u6FoBAIBubKOak+bm5vz+97/PJz7xifztb39LY2NjbrzxxixZsiSnn356br755gwYMKCjawUAgC7Fo4Srs9GbMPbv3z+nnHJKTjnllI6sBwAA6KE2KjkBAADoaBuVnHzoQx/6l/eUSqV8//vf35i3BwCA7qFSWnPUe8wuaqOak9/97ndtT+daq7W1NU899VRaW1szfPjwDBw4sEMKBAAAeoaNak4ee+yx9Z5ftWpVvv3tb+fcc8/N7NmzN6UuAADo+uwQX5UOXXPSp0+fHHvssdlvv/1y7LHHduRbAwAA3VxNFsS//vWvz0033VSLtwYAgC7Do4SrU5PmZPbs2fY5AQAAqrJRa07OOOOM9Z5fsmRJbrrpptx55505+eSTN6kwAACgZ9mo5uSzn/3ses8PHTo022yzTWbNmpUjjzxyU+oCAICuz4L4qmxUc1Iulzu6DgAAoIeres3JSy+9lBNPPDG//vWva1EPAAB0H52xGL4LJydVNyf9+/fPt7/97SxcuLAW9QAAAD3URj2ta/fdd88999zT0bUAAAA92EY1J+eee25++tOf5nvf+15Wr17d0TUBAED3UOmko4va4AXxN910U3bYYYcMHz48M2bMSENDQ44++uh89KMfzRZbbJH+/fu3u79UKuWPf/xjhxcMAAB0TxvcnOy777750Y9+lPe9730ZNmxYNt9887zmNa+pZW0AANC1eZRwVTa4OalUKqlU1nzSG264oVb1AAAAPdRG7XMCAAD8a22P963zmF1VVQviS6VSreoAAAB6uKqak8MOOyy9evXaoKN3b6EMAACw4arqICZPnpztt9++VrUAAAA9WFXNyYwZM/If//EftaoFAADowcy9AgCAWvEo4aps1A7xAAAAHU1zAgAAFMIGT+sql8u1rAMAALod+5xUR3ICAAAUggXxAABQS104yag3yQkAAFAIkhMAAKgVjxKuiuQEAAAoBM0JAABQCKZ1AQBAjXiUcHUkJwAAQCFITgAAoFYsiK+K5AQAACgEzQkAAFAIpnUBAECNWBBfHckJAABQCJITAACoFQviqyI5AQAACkFyAgAAtSI5qYrkBAAAKATNCQAAUAimdQEAQI14lHB1JCcAAEAhSE4AAKBWLIiviuQEAAAoBM0JAABQCKZ1AQBArZjWVRXJCQAAUAiaEwAAqJG1jxKu97GxvvSlL6VUKuWEE05oO7d8+fIcc8wxGTZsWAYNGpSDDz44CxcubPe6J554IgcccEAGDBiQESNG5OMf/3hWr15d9fiaEwAAIH/4wx/y7W9/O7vssku78x/72Mfy61//Oj/72c9y4403Zv78+TnooIParre2tuaAAw7IypUrc+utt+biiy/ORRddlNNOO63qGjQnAADQw73wwguZPn16vvvd72bo0KFt55cuXZrvf//7Oeecc/L2t789u+++ey688MLceuut+f3vf58k+e1vf5v77rsvP/rRj7Lrrrtm//33z+c///lccMEFWblyZVV1aE4AAKBWKp10JGlpaWl3rFix4hXLPOaYY3LAAQdk8uTJ7c7fcccdWbVqVbvzr33ta7Pllltmzpw5SZI5c+Zk5513zsiRI9vumTJlSlpaWnLvvfdW9e3SnAAAQDc0bty4NDc3tx1nnXXWeu/76U9/mjvvvHO91xcsWJC+fftmyJAh7c6PHDkyCxYsaLvn5Y3J2utrr1XDo4QBAKBGNnWB+saOmSTz5s1LU1NT2/l+/fqtc++8efNy/PHHZ/bs2WlsbKxXia9IcgIAAN1QU1NTu2N9zckdd9yRRYsWZbfddkvv3r3Tu3fv3HjjjTnvvPPSu3fvjBw5MitXrsySJUvavW7hwoUZNWpUkmTUqFHrPL1r7ddr79lQmhMAAKiVTlxzsiHe8Y535M9//nPuvvvutmOPPfbI9OnT2/67T58+ue6669pe8+CDD+aJJ57IpEmTkiSTJk3Kn//85yxatKjtntmzZ6epqSk77rhjNd8t07oAAKCnGjx4cHbaaad25wYOHJhhw4a1nT/iiCNy4oknZrPNNktTU1OOO+64TJo0KW9605uSJPvtt1923HHHvP/978/ZZ5+dBQsW5JRTTskxxxyz3rTm1WhOAACAV/T1r389DQ0NOfjgg7NixYpMmTIl3/rWt9qu9+rVK1dccUU+/OEPZ9KkSRk4cGBmzJiRM844o+qxNCcAAFArVU6z6rAxN8ENN9zQ7uvGxsZccMEFueCCC17xNVtttVWuvPLKTRs41pwAAAAFITkBAIAaKf39qPeYXZXkBAAAKATNCQAAUAimdQEAQK10wQXxnUlyAgAAFILkBAAAaqRUWXPUe8yuSnICAAAUguQEAABqxZqTqkhOAACAQtCcAAAAhWBaFwAA1FIXnmZVb5ITAACgECQnAABQIx4lXB3JCQAAUAiaEwAAoBBM6wIAgFqxz0lVJCcAAEAhSE4AAKBGLIivjuQEAAAoBMkJAADUijUnVZGcAAAAhaA5AQAACsG0LgAAqBEL4qsjOQEAAApBcgIAALViQXxVJCcAAEAhaE4AAIBCMK0LAABqxbSuqkhOAACAQpCcAABAjXiUcHUkJwAAQCFITgAAoFasOamK5AQAACgEzQkAAFAIpnUBAECNlCqVlCr1nWdV7/E6kuQEAAAoBMkJAADUigXxVZGcAAAAhaA5AQAACsG0LgAAqBE7xFdHcgIAABSC5AQAAGrFgviqSE4AAIBCkJwAAECNWHNSHckJAABQCJoTAACgEEzrAgCAWrEgviqSEwAAoBAkJwAAUCMWxFdHcgIAABSC5gQAACgE07oAAKBWLIiviuQEAAAoBMkJAADUUFdeoF5vkhMAAKAQJCcAAFArlcqao95jdlGSEwAAoBA0JwAAQCGY1gUAADVih/jqSE4AAIBCkJwAAECt2ISxKpITAACgEDQnAABAIZjWBQAANVIqrznqPWZXJTkBAAAKQXICAAC1YkF8VSQnAABAIUhO4J/sMumFfOUXf13vtePftW0euHNgkmTacQvzpv1aMnr8igwYWM7i+X1y23VN+ck3Rmbps/5oAfX18J/658Ivjc79tw9MpZLssPuy/OcpT2WbnV5qd9/HD942f5ozaJ3X7/62lpz540favv7qCVtm9v9s9orjXXLHvdl89KqO+wAA0ZzAK7r0e5vnobsHtDs3/7F+bf+93S4v5ZF7++fGy4fkxWUN2XK7Fdn/P57Jnu9oyYf/bfuseKlXvUsGeqiH/9Q/J75nuwwfszLTT1yQSjn59cWb56SDt815v3ko47Zd0e7+zUevzIc+/VS7c8NGtm80ph72dN7wlufbnatUkvM+OTYjx63UmMAGskN8dTQn8ArumTswt/xmyCte//yR49c5d//tA3Lq9x7Pm/ZryY2XD61dcQAv84OvjErfxnLO/dXDadqsNUny9oOfyxF775ALvzQ6p33vsXb3D2xqzTsOfu5V33PHPV7Mjnu82O7cPXMHZsVLvfL2g179tQAbq1BrTm666aa8+93vzpgxY1IqlXLZZZd1dkn0cP0Htqah14b/+mHBvL5JkkFNrbUqCWAd98wdlDe85fm2xiRJho1cnZ0nvZDbrm3KS8vW/ee+dXXWe/7VXH/Z0JRKlez770s2tWToOSqVzjm6qEIlJ8uWLcvrX//6fOhDH8pBBx3U2eXQw/3X1+dlwKByWlev+W3hdz8/Jg//acA/3VVJ02at6dWrki0mrMiHPvNUWldnvfO5AWpl1cpS+jWu+8NIv/7lrFrZkMceaMwOu/8jBfnbI/1y4La7ZNXKhgwdvir7T38m0z+2IL37vPIYq1clN/1qSHbcY1lGjVtZi48BUKzmZP/998/+++/f2WXQw61eVcrNVzTntt8NTsuzvbPl9svz3v9vcb526V/ysQO3zV/v+UeDMnT46vz0j/e1fb14fp986ZitMu8vjZ1ROtBDjd1mRR64Y0BaW5Nef1/utmplKQ/+/QEeTy/4R9cxeqsVef2bn8/4HZZn+YsNufmKIfnxuaPy5F/75TPffvwVx7j9hqa0PNc7+5rSBVWx5qQ6hWpOoAjuu31g7rt9YNvXv/9tc265YkhmXvdgPvSpBfnM9K3brj2/pFdO/r9bp2+/SrbZ6aXsNXVJGgea0gXU17tmPJ3zTx6Xr//XljnkIwtTKZfy43NH5tlFa/6ZX7n8H9O3TjxnXrvXTn7vczn342Nz1SWb56CjFrdLWF7u+kuHpnefct767iU1+xwAXbo5WbFiRVas+McTSFpaWjqxGrqz+Y/1y5xrmrPX/kvT0FBJuVxKkqxe1ZC7bh6cJJl7bVPuvmVQvv6rv2Tp030y99qmziwZ6EHe9YFnsnh+n/x85oi2x/9u//oXc8hHFuUn3xiV/gPKr/r6g49enKsu2Tx33Tx4vc3JS8saMueapuz+1vbrWgA6WqEWxFfrrLPOSnNzc9sxbty4zi6Jbmzx/D7p26+Sxlf5R/6+2wfmmQWmPQD198GTF+Snf7w3X7v04cy67oGcf9VDbb9I2WKb5a/62uFj1qwheX7J+h+BfuvVzZ7SBRur0klHF9Wlm5NPfepTWbp0adsxb968f/0i2Eijt1yZFS+V/uXTbfr2q2TgYL9ZBOpv8JDW7DRxWSbssKYZuevmQdl89Mp19jn5ZwueWLOHU/Ow1eu9/rtfDk3/ga15035LO7ZggH/Spad19evXL/369fvXN0IVmjdbvc4O71vv+FLetF9Lbr9+cCqVUvr1b01SyoqX2jcqe09dksFDW9fzVC+A+rrh8iF56O6BOfK0v6Xh739VLXu+IX36VtK33z9+rVqpJD8+d2SSZPe3Pr/O+yx5plfuunlw3vae59I4oAv/OhY6iQXx1SlUc/LCCy/kL3/5S9vXjz76aO6+++5sttlm2XLLLTuxMnqST896PCuWl3L/7QOz5Ok1T+uaetizWfFSKd//4ugkyRZbr8yX/vuvufFXQzLvL/1SKZey/etfzNsPei4LnuibS7+3eSd/CqAn+fPvB+ZH54xasyZk6Orcf+fA/Pa/N8se+7bk3/9zcdt9f/nzgHzpI1vlbe95LmPGr8iK5Q259arm3PuHQZl62NPZbpeX1nnvGy8fmtbVJVO6gLooVHNy++23Z9999237+sQTT0ySzJgxIxdddFEnVUVPc+s1TXn7vy/JQUctzoDBrVn6TO/ccmVzLjlnZOY/tiape/qpPrnlN83Zda8X8m+HPJdevStZ9GSf/OrCzfOT80bm+ecK9UcL6OaGjVqVXr0q+fnMEXlxWUNGjVuZwz/xVA46enF6veyvo5FjV+Z1E1/I/17VnOcW90mpVMmW263IR788L1MPe2a97339pUMzZPNVecNb1k1VADpaqVLpwltI/pOWlpY0NzfnbTkwvUuvspMUQBdwzfy7O7sEgE3W8nw5Q7d/JEuXLk1TU895kuXan0vfNPWM9O5T3/3PVq9ant9feVqX/J536QXxAABA92HuCQAA1IgF8dWRnAAAAIUgOQEAgFrpjE0RJScAAACbRnMCAAAUgmldAABQIxbEV0dyAgAAFILkBAAAaqVcWXPUe8wuSnICAAAUguYEAAAoBNO6AACgVuxzUhXJCQAAUAiSEwAAqJFSOuFRwvUdrkNJTgAAgEKQnAAAQK1UKmuOeo/ZRUlOAACAQtCcAAAAhWBaFwAA1Eip0gkL4rvurC7JCQAAUAySEwAAqBWbMFZFcgIAABSC5gQAACgE07oAAKBGSpVKSnXed6Te43UkyQkAAFAIkhMAAKiV8t+Peo/ZRUlOAACAQpCcAABAjVhzUh3JCQAAUAiaEwAAoBBM6wIAgFqxQ3xVJCcAAEAhSE4AAKBWKpU1R73H7KIkJwAAQCFoTgAAgEIwrQsAAGqkVFlz1HvMrkpyAgAAFILkBAAAasWC+KpITgAAgEKQnAAAQI2UymuOeo/ZVUlOAACAQtCcAAAAhWBaFwAA1IoF8VWRnAAAQA921lln5Y1vfGMGDx6cESNG5D3veU8efPDBdvcsX748xxxzTIYNG5ZBgwbl4IMPzsKFC9vd88QTT+SAAw7IgAEDMmLEiHz84x/P6tWrq6pFcwIAALVS6aSjCjfeeGOOOeaY/P73v8/s2bOzatWq7Lffflm2bFnbPR/72Mfy61//Oj/72c9y4403Zv78+TnooIParre2tuaAAw7IypUrc+utt+biiy/ORRddlNNOO62qWkqVShfOff5JS0tLmpub87YcmN6lPp1dDsAmuWb+3Z1dAsAma3m+nKHbP5KlS5emqamps8upm7afS9/4mfTu3VjXsVevXp4b/vDFjf6eL168OCNGjMiNN96YffbZJ0uXLs3w4cPz4x//OO9973uTJA888EB22GGHzJkzJ29605ty1VVX5V3velfmz5+fkSNHJklmzZqVT37yk1m8eHH69u27QWNLTgAAgDZLly5Nkmy22WZJkjvuuCOrVq3K5MmT2+557Wtfmy233DJz5sxJksyZMyc777xzW2OSJFOmTElLS0vuvffeDR7bgngAAKiRUqWSUp0nKq0dr6Wlpd35fv36pV+/fq/62nK5nBNOOCF77bVXdtpppyTJggUL0rdv3wwZMqTdvSNHjsyCBQva7nl5Y7L2+tprG0pyAgAA3dC4cePS3Nzcdpx11ln/8jXHHHNM7rnnnvz0pz+tQ4XrkpwAAECtdOKjhOfNm9duzcm/Sk2OPfbYXHHFFbnpppsyduzYtvOjRo3KypUrs2TJknbpycKFCzNq1Ki2e2677bZ277f2aV5r79kQkhMAAOiGmpqa2h2v1JxUKpUce+yxufTSS/O73/0uEyZMaHd99913T58+fXLddde1nXvwwQfzxBNPZNKkSUmSSZMm5c9//nMWLVrUds/s2bPT1NSUHXfccYNrlpwAAECtVJKUO2HMKhxzzDH58Y9/nMsvvzyDBw9uWyPS3Nyc/v37p7m5OUcccUROPPHEbLbZZmlqaspxxx2XSZMm5U1velOSZL/99suOO+6Y97///Tn77LOzYMGCnHLKKTnmmGP+ZWLzcpoTAADowWbOnJkkedvb3tbu/IUXXpjDDz88SfL1r389DQ0NOfjgg7NixYpMmTIl3/rWt9ru7dWrV6644op8+MMfzqRJkzJw4MDMmDEjZ5xxRlW1aE4AAKAH25BtDxsbG3PBBRfkggsueMV7ttpqq1x55ZWbVIvmBAAAaqQzHyXcFVkQDwAAFILkBAAAaqWSTniUcH2H60iSEwAAoBA0JwAAQCGY1gUAALXSiTvEd0WSEwAAoBAkJwAAUCvlJKVOGLOLkpwAAACFoDkBAAAKwbQuAACoETvEV0dyAgAAFILkBAAAasWjhKsiOQEAAApBcgIAALUiOamK5AQAACgEzQkAAFAIpnUBAECtmNZVFckJAABQCJITAAColXKSUieM2UVJTgAAgELQnAAAAIVgWhcAANRIqVJJqc4L1Os9XkeSnAAAAIUgOQEAgFrxKOGqSE4AAIBCkJwAAECtlCtJqc5JRllyAgAAsEk0JwAAQCGY1gUAALViQXxVJCcAAEAhSE4AAKBmOiE5ieQEAABgk2hOAACAQjCtCwAAasWC+KpITgAAgEKQnAAAQK2UK6n7AnU7xAMAAGwayQkAANRKpbzmqPeYXZTkBAAAKATNCQAAUAimdQEAQK14lHBVJCcAAEAhSE4AAKBWPEq4KpITAACgEDQnAABAIZjWBQAAtWJBfFUkJwAAQCFITgAAoFYq6YTkpL7DdSTJCQAAUAiSEwAAqBVrTqoiOQEAAApBcwIAABSCaV0AAFAr5XKScieM2TVJTgAAgEKQnAAAQK1YEF8VyQkAAFAImhMAAKAQTOsCAIBaMa2rKpITAACgECQnAABQK+VKkjonGWXJCQAAwCaRnAAAQI1UKuVUKvXdFLHe43UkyQkAAFAImhMAAKAQTOsCAIBaqVTqv0Ddo4QBAAA2jeQEAABqpdIJjxKWnAAAAGwazQkAAFAIpnUBAECtlMtJqc77jtjnBAAAYNNITgAAoFYsiK+K5AQAACgEyQkAANRIpVxOpc5rTirWnAAAAGwazQkAAFAIpnUBAECtWBBfFckJAABQCJITAAColXIlKUlONpTkBAAAKATNCQAAUAimdQEAQK1UKknqvO+IaV0AAACbRnICAAA1UilXUqnzgviK5AQAAGDTaE4AAIBCMK0LAABqpVJO/RfE13m8DiQ5AQAACkFyAgAANWJBfHUkJwAAQCFITgAAoFasOamK5AQAACiEbpWcrJ1ftzqrkq471Q4gSdLyfNf9zRfAWi0vrPm7rCuvg9gUnfFz6eqsqu+AHahbNSfPP/98kuSWXNnJlQBsuqHbd3YFAB3n+eefT3Nzc2eXUTd9+/bNqFGjcsuCzvm5dNSoUenbt2+njL0pSpVu1MaWy+XMnz8/gwcPTqlU6uxy6KZaWloybty4zJs3L01NTZ1dDsBG8/cZ9VCpVPL8889nzJgxaWjoWSsKli9fnpUrV3bK2H379k1jY2OnjL0pulVy0tDQkLFjx3Z2GfQQTU1N/jEHugV/n1FrPSkxebnGxsYu2SB0pp7VvgIAAIWlOQEAAApBcwJV6tevX04//fT069evs0sB2CT+PgOKplstiAcAALouyQkAAFAImhMAAKAQNCcAAEAhaE4AAIBC0JzABlqxYkU++clPZsyYMenfv38mTpyY2bNnd3ZZAFV74YUXcvrpp+ed73xnNttss5RKpVx00UWdXRaA5gQ21OGHH55zzjkn06dPzze+8Y306tUrU6dOzS233NLZpQFU5emnn84ZZ5yR+++/P69//es7uxyANh4lDBvgtttuy8SJE/OVr3wlJ510UpJk+fLl2WmnnTJixIjceuutnVwhwIZbsWJFnnvuuYwaNSq333573vjGN+bCCy/M4Ycf3tmlAT2c5AQ2wM9//vP06tUrRx11VNu5xsbGHHHEEZkzZ07mzZvXidUBVKdfv34ZNWpUZ5cBsA7NCWyAu+66K9tvv32amprand9zzz2TJHfffXcnVAUA0L1oTmADPPXUUxk9evQ659eemz9/fr1LAgDodjQnsAFeeuml9OvXb53zjY2NbdcBANg0mhPYAP3798+KFSvWOb98+fK26wAAbBrNCWyA0aNH56mnnlrn/NpzY8aMqXdJAADdjuYENsCuu+6ahx56KC0tLe3Oz507t+06AACbRnMCG+C9731vWltb853vfKft3IoVK3LhhRdm4sSJGTduXCdWBwDQPfTu7AKgK5g4cWIOOeSQfOpTn8qiRYuy7bbb5uKLL85jjz2W73//+51dHkDVvvnNb2bJkiVtTxv89a9/nSeffDJJctxxx6W5ubkzywN6KDvEwwZavnx5Tj311PzoRz/Kc889l1122SWf//znM2XKlM4uDaBq48ePz+OPP77ea48++mjGjx9f34IAojkBAAAKwpoTAACgEDQnAABAIWhOAACAQtCcAAAAhaA5AQAACkFzAgAAFILmBAAAKATNCQAAUAiaE4ANNH78+Bx++OFtX99www0plUq54YYbOq2mf/bPNb6SUqmUz372s1W//0UXXZRSqZTbb7+9+uJewWc/+9mUSqUOez8Aui7NCdAlrP2heO3R2NiY7bffPscee2wWLlzY2eVV5corr9yoxgAAurvenV0AQDXOOOOMTJgwIcuXL88tt9ySmTNn5sorr8w999yTAQMG1LWWffbZJy+99FL69u1b1euuvPLKXHDBBRoUAPgnmhOgS9l///2zxx57JEn+8z//M8OGDcs555yTyy+/PO973/vW+5ply5Zl4MCBHV5LQ0NDGhsbO/x9AaCnMq0L6NLe/va3J0keffTRJMnhhx+eQYMG5a9//WumTp2awYMHZ/r06UmScrmcc889N6973evS2NiYkSNH5uijj85zzz3X7j0rlUq+8IUvZOzYsRkwYED23Xff3HvvveuM/UprTubOnZupU6dm6NChGThwYHbZZZd84xvfaKvvggsuSJJ209TW6ugaN9Tjjz+ej3zkI3nNa16T/v37Z9iwYTnkkEPy2GOPrff+F198MUcffXSGDRuWpqamfOADH1inxiS56qqr8pa3vCUDBw7M4MGDc8ABB2xSnQB0b5IToEv761//miQZNmxY27nVq1dnypQp2XvvvfPVr361bbrX0UcfnYsuuigf/OAH89GPfjSPPvpovvnNb+auu+7K//7v/6ZPnz5JktNOOy1f+MIXMnXq1EydOjV33nln9ttvv6xcufJf1jN79uy8613vyujRo3P88cdn1KhRuf/++3PFFVfk+OOPz9FHH5358+dn9uzZ+eEPf7jO6+tR4/r84Q9/yK233ppp06Zl7NixeeyxxzJz5sy87W1vy3333bfOlLljjz02Q4YMyWc/+9k8+OCDmTlzZh5//PG2hi1JfvjDH2bGjBmZMmVKvvzlL+fFF1/MzJkzs/fee+euu+7K+PHjN6pWALqxCkAXcOGFF1aSVK699trK4sWLK/Pmzav89Kc/rQwbNqzSv3//ypNPPlmpVCqVGTNmVJJUTj755Havv/nmmytJKpdcckm781dffXW784sWLar07du3csABB1TK5XLbfZ/+9KcrSSozZsxoO3f99ddXklSuv/76SqVSqaxevboyYcKEylZbbVV57rnn2o3z8vc65phjKuv767cWNb6SJJXTTz+97esXX3xxnXvmzJlTSVL5wQ9+0HZu7f8fdt9998rKlSvbzp999tmVJJXLL7+8UqlUKs8//3xlyJAhlSOPPLLdey5YsKDS3Nzc7vzpp5++3u8HAD2PaV1AlzJ58uQMHz4848aNy7Rp0zJo0KBceuml2WKLLdrd9+EPf7jd1z/72c/S3Nycf/u3f8vTTz/dduy+++4ZNGhQrr/++iTJtddem5UrV+a4445rN93qhBNO+Je13XXXXXn00UdzwgknZMiQIe2ubcijcutR4yvp379/23+vWrUqzzzzTLbddtsMGTIkd9555zr3H3XUUW0pTrLm+927d+9ceeWVSdYkSEuWLMn73ve+dp+lV69emThxYttnAYCXM60L6FIuuOCCbL/99undu3dGjhyZ17zmNWloaP97lt69e2fs2LHtzj388MNZunRpRowYsd73XbRoUZI1ay+SZLvttmt3ffjw4Rk6dOir1rZ2itlOO+204R+ozjW+kpdeeilnnXVWLrzwwvztb39LpVJpu7Z06dJ17v/nsQcNGpTRo0e3rVF5+OGHk/xjTdA/a2pq2qg6AejeNCdAl7Lnnnu2Pa3rlfTr12+dhqVcLmfEiBG55JJL1vua4cOHd1iNG6szazzuuONy4YUX5oQTTsikSZPS3NycUqmUadOmpVwuV/1+a1/zwx/+MKNGjVrneu/e/vkBYF3+dQB6hG222SbXXntt9tprr3ZTmP7ZVlttlWTNb/633nrrtvOLFy9e79Oo/nmMJLnnnnsyefLkV7zvlaZ41aPGV/Lzn/88M2bMyNe+9rW2c8uXL8+SJUvWe//DDz+cfffdt+3rF154IU899VSmTp3a9lmSZMSIEa/6vQCAl7PmBOgRDj300LS2tubzn//8OtdWr17d9kP45MmT06dPn5x//vntpjade+65/3KM3XbbLRMmTMi55567zg/1L3+vtXuu/PM99ajxlfTq1avdeyXJ+eefn9bW1vXe/53vfCerVq1q+3rmzJlZvXp19t9//yTJlClT0tTUlDPPPLPdfWstXrx4o2sFoPuSnAA9wlvf+tYcffTROeuss3L33Xdnv/32S58+ffLwww/nZz/7Wb7xjW/kve99b4YPH56TTjopZ511Vt71rndl6tSpueuuu3LVVVdl8803f9UxGhoaMnPmzLz73e/Orrvumg9+8IMZPXp0Hnjggdx777255pprkiS77757kuSjH/1opkyZkl69emXatGl1qfGVvOtd78oPf/jDNDc3Z8cdd8ycOXNy7bXXtntE88utXLky73jHO3LooYfmwQcfzLe+9a3svffe+T//5/8kWbOmZObMmXn/+9+f3XbbLdOmTcvw4cPzxBNP5De/+U322muvfPOb39yoWgHovjQnQI8xa9as7L777vn2t7+dT3/60+ndu3fGjx+fww47LHvttVfbfV/4whfS2NiYWbNm5frrr8/EiRPz29/+NgcccMC/HGPKlCm5/vrr87nPfS5f+9rXUi6Xs8022+TII49su+eggw7Kcccdl5/+9Kf50Y9+lEqlkmnTptWtxvX5xje+kV69euWSSy7J8uXLs9dee+Xaa6/NlClT1nv/N7/5zVxyySU57bTTsmrVqrzvfe/Leeed127K2n/8x39kzJgx+dKXvpSvfOUrWbFiRbbYYou85S1vyQc/+MGNqhOA7q1U+eccHwAAoBNYcwIAABSC5gQAACgEzQkAAFAImhMAAKAQNCcAAEAhaE4AAIBC0JwAAACFoDkBAAAKQXMCAAAUguYEAAAoBM0JAABQCJoTAACgEDQnAABAIfz/jshTKo+d8dMAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -490,7 +506,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -565,8 +581,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average mislabelled data influence: -0.7792411677556543\n", - "Average correct data influence: 0.0076227822067402706\n" + "Average mislabelled data influence: -0.8225848370029777\n", + "Average correct data influence: 0.011277048916970962\n" ] } ], @@ -583,7 +599,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -645,18 +661,18 @@ "name": "stderr", "output_type": "stream", "text": [ - "Batch Test Gradients: 100%|██████████| 8/8 [00:00<00:00, 15.16it/s]\n", - "Batch Train Gradients: 100%|██████████| 1/1 [00:00<00:00, 331.12it/s]\n", - "Conjugate gradient: 100%|██████████| 2000/2000 [00:16<00:00, 120.33it/s]\n", - "Batch Split Input Gradients: 100%|██████████| 1/1 [00:00<00:00, 50.28it/s]" + "Batch Test Gradients: 100%|██████████| 8/8 [00:00<00:00, 17.89it/s]\n", + "Batch Train Gradients: 100%|██████████| 1/1 [00:00<00:00, 308.47it/s]\n", + "Conjugate gradient: 100%|██████████| 2000/2000 [00:16<00:00, 118.24it/s]\n", + "Batch Split Input Gradients: 100%|██████████| 1/1 [00:00<00:00, 44.89it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Average mislabelled data influence: -0.7791245506277523\n", - "Average correct data influence: 0.007621630929965999\n" + "Average mislabelled data influence: -0.82248804123547\n", + "Average correct data influence: 0.01127580743952819\n" ] }, { @@ -699,7 +715,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index 25c797653..3f061cefa 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -61,7 +61,7 @@ "from support.common import plot_losses\n", "from support.torch import TorchMLP, fit_torch_model\n", "from pydvl.influence import compute_influences, TorchTwiceDifferentiable\n", - "from pydvl.utils.dataset import load_wine_dataset\n", + "from support.shapley import load_wine_dataset\n", "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, f1_score\n", "from torch.optim import Adam, lr_scheduler\n", "from torch.utils.data import DataLoader, TensorDataset" diff --git a/notebooks/shapley_basic_spotify.ipynb b/notebooks/shapley_basic_spotify.ipynb index ae1c73aca..4bd95ba65 100644 --- a/notebooks/shapley_basic_spotify.ipynb +++ b/notebooks/shapley_basic_spotify.ipynb @@ -96,7 +96,8 @@ "source": [ "%autoreload\n", "from pydvl.reporting.plots import plot_shapley\n", - "from pydvl.utils.dataset import GroupedDataset, load_spotify_dataset\n", + "from pydvl.utils.dataset import GroupedDataset\n", + "from support.shapley import load_spotify_dataset\n", "from pydvl.value import *" ] }, diff --git a/notebooks/support/shapley.py b/notebooks/support/shapley.py new file mode 100644 index 000000000..5c6c88112 --- /dev/null +++ b/notebooks/support/shapley.py @@ -0,0 +1,159 @@ +from pathlib import Path +from typing import Any, Callable, Optional, Tuple + +import numpy as np +import pandas as pd +from sklearn.datasets import load_wine +from sklearn.model_selection import train_test_split +from sklearn.preprocessing import MinMaxScaler + + +def load_spotify_dataset( + val_size: float, + test_size: float, + min_year: int = 2014, + target_column: str = "popularity", + random_state: int = 24, +): + """Loads (and downloads if not already cached) the spotify music dataset. + More info on the dataset can be found at + https://www.kaggle.com/datasets/mrmorj/dataset-of-songs-in-spotify. + + If this method is called within the CI pipeline, it will load a reduced + version of the dataset for testing purposes. + + :param val_size: size of the validation set + :param test_size: size of the test set + :param min_year: minimum year of the returned data + :param target_column: column to be returned as y (labels) + :param random_state: fixes sklearn random seed + :return: Tuple with 3 elements, each being a list sith [input_data, related_labels] + """ + root_dir_path = Path(__file__).parent.parent.parent.parent + file_path = root_dir_path / "data/top_hits_spotify_dataset.csv" + if file_path.exists(): + data = pd.read_csv(file_path) + else: + url = "https://raw.githubusercontent.com/appliedAI-Initiative/pyDVL/develop/data/top_hits_spotify_dataset.csv" + data = pd.read_csv(url) + data.to_csv(file_path, index=False) + + data = data[data["year"] > min_year] + data["genre"] = data["genre"].astype("category").cat.codes + y = data[target_column] + X = data.drop(target_column, axis=1) + X, X_test, y, y_test = train_test_split( + X, y, test_size=test_size, random_state=random_state + ) + X_train, X_val, y_train, y_val = train_test_split( + X, y, test_size=val_size, random_state=random_state + ) + return [X_train, y_train], [X_val, y_val], [X_test, y_test] + + +def load_wine_dataset( + train_size: float, test_size: float, random_state: Optional[int] = None +): + """Loads the sklearn wine dataset. More info can be found at + https://scikit-learn.org/stable/datasets/toy_dataset.html#wine-recognition-dataset. + + :param train_size: fraction of points used for training dataset + :param test_size: fraction of points used for test dataset + :param random_state: fix random seed. If None, no random seed is set. + :return: A tuple of four elements with the first three being input and + target values in the form of matrices of shape (N,D) the first + and (N,) the second. The fourth element is a list containing names of + features of the model. (FIXME doc) + """ + try: + import torch + except ImportError as e: + raise RuntimeError( + "PyTorch is required in order to load the Wine Dataset" + ) from e + + wine_bunch = load_wine(as_frame=True) + x, x_test, y, y_test = train_test_split( + wine_bunch.data, + wine_bunch.target, + train_size=1 - test_size, + random_state=random_state, + ) + x_train, x_val, y_train, y_val = train_test_split( + x, y, train_size=train_size / (1 - test_size), random_state=random_state + ) + x_transformer = MinMaxScaler() + + transformed_x_train = x_transformer.fit_transform(x_train) + transformed_x_test = x_transformer.transform(x_test) + + transformed_x_train = torch.tensor(transformed_x_train, dtype=torch.float) + transformed_y_train = torch.tensor(y_train.to_numpy(), dtype=torch.long) + + transformed_x_test = torch.tensor(transformed_x_test, dtype=torch.float) + transformed_y_test = torch.tensor(y_test.to_numpy(), dtype=torch.long) + + transformed_x_val = x_transformer.transform(x_val) + transformed_x_val = torch.tensor(transformed_x_val, dtype=torch.float) + transformed_y_val = torch.tensor(y_val.to_numpy(), dtype=torch.long) + return ( + (transformed_x_train, transformed_y_train), + (transformed_x_val, transformed_y_val), + (transformed_x_test, transformed_y_test), + wine_bunch.feature_names, + ) + + +def synthetic_classification_dataset( + mus: np.ndarray, + sigma: float, + num_samples: int, + train_size: float, + test_size: float, + random_seed=None, +) -> Tuple[Tuple[Any, Any], Tuple[Any, Any], Tuple[Any, Any]]: + """Sample from a uniform Gaussian mixture model. + + :param mus: 2d-matrix [CxD] with the means of the components in the rows. + :param sigma: Standard deviation of each dimension of each component. + :param num_samples: The number of samples to generate. + :param train_size: fraction of points used for training dataset + :param test_size: fraction of points used for test dataset + :param random_seed: fix random seed. If None, no random seed is set. + :returns: A tuple of matrix x of shape [NxD] and target vector y of shape [N]. + """ + num_features = mus.shape[1] + num_classes = mus.shape[0] + gaussian_cov = sigma * np.eye(num_features) + gaussian_chol = np.linalg.cholesky(gaussian_cov) + y = np.random.randint(num_classes, size=num_samples) + x = ( + np.einsum( + "ij,kj->ki", + gaussian_chol, + np.random.normal(size=[num_samples, num_features]), + ) + + mus[y] + ) + x, x_test, y, y_test = train_test_split( + x, y, train_size=1 - test_size, random_state=random_seed + ) + x_train, x_val, y_train, y_val = train_test_split( + x, y, train_size=train_size / (1 - test_size), random_state=random_seed + ) + return (x_train, y_train), (x_val, y_val), (x_test, y_test) + + +def decision_boundary_fixed_variance_2d( + mu_1: np.ndarray, mu_2: np.ndarray +) -> Callable[[np.ndarray], np.ndarray]: + """ + Closed-form solution for decision boundary dot(a, b) + b = 0 with fixed variance. + :param mu_1: First mean. + :param mu_2: Second mean. + :returns: A callable which converts a continuous line (-infty, infty) to the decision boundary in feature space. + """ + a = np.asarray([[0, 1], [-1, 0]]) @ (mu_2 - mu_1) + b = (mu_1 + mu_2) / 2 + a = a.reshape([1, -1]) + return lambda z: z.reshape([-1, 1]) * a + b # type: ignore diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index d3c6eadf7..f77659295 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -30,7 +30,7 @@ from sklearn.preprocessing import MinMaxScaler from sklearn.utils import Bunch, check_X_y -__all__ = ["Dataset", "GroupedDataset", "load_spotify_dataset", "load_wine_dataset"] +__all__ = ["Dataset", "GroupedDataset"] logger = logging.getLogger(__name__) @@ -574,154 +574,3 @@ def from_dataset( target_names=dataset.target_names, description=dataset.description, ) - - -def load_spotify_dataset( - val_size: float, - test_size: float, - min_year: int = 2014, - target_column: str = "popularity", - random_state: int = 24, -): - """Loads (and downloads if not already cached) the spotify music dataset. - More info on the dataset can be found at - https://www.kaggle.com/datasets/mrmorj/dataset-of-songs-in-spotify. - - If this method is called within the CI pipeline, it will load a reduced - version of the dataset for testing purposes. - - :param val_size: size of the validation set - :param test_size: size of the test set - :param min_year: minimum year of the returned data - :param target_column: column to be returned as y (labels) - :param random_state: fixes sklearn random seed - :return: Tuple with 3 elements, each being a list sith [input_data, related_labels] - """ - root_dir_path = Path(__file__).parent.parent.parent.parent - file_path = root_dir_path / "data/top_hits_spotify_dataset.csv" - if file_path.exists(): - data = pd.read_csv(file_path) - else: - url = "https://raw.githubusercontent.com/appliedAI-Initiative/pyDVL/develop/data/top_hits_spotify_dataset.csv" - data = pd.read_csv(url) - data.to_csv(file_path, index=False) - - data = data[data["year"] > min_year] - data["genre"] = data["genre"].astype("category").cat.codes - y = data[target_column] - X = data.drop(target_column, axis=1) - X, X_test, y, y_test = train_test_split( - X, y, test_size=test_size, random_state=random_state - ) - X_train, X_val, y_train, y_val = train_test_split( - X, y, test_size=val_size, random_state=random_state - ) - return [X_train, y_train], [X_val, y_val], [X_test, y_test] - - -def load_wine_dataset( - train_size: float, test_size: float, random_state: Optional[int] = None -): - """Loads the sklearn wine dataset. More info can be found at - https://scikit-learn.org/stable/datasets/toy_dataset.html#wine-recognition-dataset. - - :param train_size: fraction of points used for training dataset - :param test_size: fraction of points used for test dataset - :param random_state: fix random seed. If None, no random seed is set. - :return: A tuple of four elements with the first three being input and - target values in the form of matrices of shape (N,D) the first - and (N,) the second. The fourth element is a list containing names of - features of the model. (FIXME doc) - """ - try: - import torch - except ImportError as e: - raise RuntimeError( - "PyTorch is required in order to load the Wine Dataset" - ) from e - - wine_bunch = load_wine(as_frame=True) - x, x_test, y, y_test = train_test_split( - wine_bunch.data, - wine_bunch.target, - train_size=1 - test_size, - random_state=random_state, - ) - x_train, x_val, y_train, y_val = train_test_split( - x, y, train_size=train_size / (1 - test_size), random_state=random_state - ) - x_transformer = MinMaxScaler() - - transformed_x_train = x_transformer.fit_transform(x_train) - transformed_x_test = x_transformer.transform(x_test) - - transformed_x_train = torch.tensor(transformed_x_train, dtype=torch.float) - transformed_y_train = torch.tensor(y_train.to_numpy(), dtype=torch.long) - - transformed_x_test = torch.tensor(transformed_x_test, dtype=torch.float) - transformed_y_test = torch.tensor(y_test.to_numpy(), dtype=torch.long) - - transformed_x_val = x_transformer.transform(x_val) - transformed_x_val = torch.tensor(transformed_x_val, dtype=torch.float) - transformed_y_val = torch.tensor(y_val.to_numpy(), dtype=torch.long) - return ( - (transformed_x_train, transformed_y_train), - (transformed_x_val, transformed_y_val), - (transformed_x_test, transformed_y_test), - wine_bunch.feature_names, - ) - - -def synthetic_classification_dataset( - mus: np.ndarray, - sigma: float, - num_samples: int, - train_size: float, - test_size: float, - random_seed=None, -) -> Tuple[Tuple[Any, Any], Tuple[Any, Any], Tuple[Any, Any]]: - """Sample from a uniform Gaussian mixture model. - - :param mus: 2d-matrix [CxD] with the means of the components in the rows. - :param sigma: Standard deviation of each dimension of each component. - :param num_samples: The number of samples to generate. - :param train_size: fraction of points used for training dataset - :param test_size: fraction of points used for test dataset - :param random_seed: fix random seed. If None, no random seed is set. - :returns: A tuple of matrix x of shape [NxD] and target vector y of shape [N]. - """ - num_features = mus.shape[1] - num_classes = mus.shape[0] - gaussian_cov = sigma * np.eye(num_features) - gaussian_chol = np.linalg.cholesky(gaussian_cov) - y = np.random.randint(num_classes, size=num_samples) - x = ( - np.einsum( - "ij,kj->ki", - gaussian_chol, - np.random.normal(size=[num_samples, num_features]), - ) - + mus[y] - ) - x, x_test, y, y_test = train_test_split( - x, y, train_size=1 - test_size, random_state=random_seed - ) - x_train, x_val, y_train, y_val = train_test_split( - x, y, train_size=train_size / (1 - test_size), random_state=random_seed - ) - return (x_train, y_train), (x_val, y_val), (x_test, y_test) - - -def decision_boundary_fixed_variance_2d( - mu_1: np.ndarray, mu_2: np.ndarray -) -> Callable[[np.ndarray], np.ndarray]: - """ - Closed-form solution for decision boundary dot(a, b) + b = 0 with fixed variance. - :param mu_1: First mean. - :param mu_2: Second mean. - :returns: A callable which converts a continuous line (-infty, infty) to the decision boundary in feature space. - """ - a = np.asarray([[0, 1], [-1, 0]]) @ (mu_2 - mu_1) - b = (mu_1 + mu_2) / 2 - a = a.reshape([1, -1]) - return lambda z: z.reshape([-1, 1]) * a + b # type: ignore From 04fe1903f4266595818bdd24a94f2a2b154c9c8b Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 12 Jul 2023 16:53:25 +0200 Subject: [PATCH 163/436] fix reference to method --- notebooks/shapley_basic_spotify.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks/shapley_basic_spotify.ipynb b/notebooks/shapley_basic_spotify.ipynb index 4bd95ba65..c6f2f0fae 100644 --- a/notebooks/shapley_basic_spotify.ipynb +++ b/notebooks/shapley_basic_spotify.ipynb @@ -107,7 +107,7 @@ "source": [ "## Loading and grouping the dataset\n", "\n", - "pyDVL provides a convenience function [load_spotify_dataset()](../pydvl/utils/dataset.rst#pydvl.utils.dataset.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]`." + "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]`." ] }, { From e2d306a67766f336d5f7ab12ed04adc8ef2d1ce0 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 12 Jul 2023 20:45:12 +0200 Subject: [PATCH 164/436] Remove sequential future executor, fix computing effectice n_jobs, fix bug in joblib parallel backend --- src/pydvl/utils/parallel/backend.py | 23 +++++++------------- src/pydvl/utils/parallel/futures/__init__.py | 7 ++---- tests/conftest.py | 6 ++++- tests/value/conftest.py | 4 ++-- 4 files changed, 17 insertions(+), 23 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index 66cb55529..b5a9fa39a 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -1,7 +1,5 @@ -import atexit import os from abc import ABCMeta, abstractmethod -from contextlib import ExitStack from dataclasses import asdict from typing import ( Any, @@ -18,7 +16,7 @@ import joblib import ray -from joblib import Parallel, delayed +from joblib import delayed from ray import ObjectRef from ray.util.joblib import register_ray @@ -115,11 +113,6 @@ def __init__(self, config: ParallelConfig): # In joblib the levels are reversed. # 0 means no logging and 50 means log everything to stdout verbose = 50 - config_dict["logging_level"] - self.parallel = Parallel(n_jobs=config_dict["n_jobs"], verbose=verbose) - # Needed to reuse the pool of workers - exit_stack = ExitStack() - exit_stack.enter_context(self.parallel) - atexit.register(exit_stack.close) def get( self, @@ -151,12 +144,12 @@ def wait( def _effective_n_jobs(self, n_jobs: int) -> int: if n_jobs < 0: - if (eff_n_jobs := self.config["n_jobs"]) is not None: - return eff_n_jobs - else: - return joblib.effective_n_jobs(n_jobs) + eff_n_jobs = self.config["n_jobs"] + if eff_n_jobs is None: + eff_n_jobs = joblib.effective_n_jobs(n_jobs) else: - return n_jobs + eff_n_jobs = min(n_jobs, joblib.effective_n_jobs(n_jobs)) + return eff_n_jobs class RayParallelBackend(BaseParallelBackend, backend_name="ray"): @@ -228,11 +221,11 @@ def wait( ) def _effective_n_jobs(self, n_jobs: int) -> int: + ray_cpus = int(ray._private.state.cluster_resources()["CPU"]) # type: ignore if n_jobs < 0: - ray_cpus = int(ray._private.state.cluster_resources()["CPU"]) # type: ignore eff_n_jobs = ray_cpus else: - eff_n_jobs = n_jobs + eff_n_jobs = min(n_jobs, ray_cpus) return eff_n_jobs diff --git a/src/pydvl/utils/parallel/futures/__init__.py b/src/pydvl/utils/parallel/futures/__init__.py index f28d6459a..a54953db2 100644 --- a/src/pydvl/utils/parallel/futures/__init__.py +++ b/src/pydvl/utils/parallel/futures/__init__.py @@ -1,4 +1,4 @@ -from concurrent.futures import Executor, ThreadPoolExecutor +from concurrent.futures import Executor from contextlib import contextmanager from typing import Generator, Optional @@ -50,10 +50,7 @@ def init_executor( with RayExecutor(max_workers, config=config, **kwargs) as executor: yield executor elif config.backend == "joblib": - with get_reusable_executor(max_workers=max_workers, timeout=10800) as executor: - yield executor - elif config.backend == "sequential": - with ThreadPoolExecutor(1) as executor: + with get_reusable_executor(max_workers=max_workers, **kwargs) as executor: yield executor else: raise NotImplementedError(f"Unexpected parallel type {config.backend}") diff --git a/tests/conftest.py b/tests/conftest.py index a1e7f2f59..3d332c1ec 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -28,7 +28,6 @@ def ray_shutdown(): def is_memcache_responsive(hostname, port): - try: client = Client(server=(hostname, port)) client.flush_all() @@ -77,6 +76,11 @@ def pytorch_seed(seed): pass +@pytest.fixture(scope="session") +def docker_compose_command(): + return "docker compose" + + @pytest.fixture(scope="session") def do_not_start_memcache(request): return request.config.getoption("--do-not-start-memcache") diff --git a/tests/value/conftest.py b/tests/value/conftest.py index 2073415a2..f806b3bb6 100644 --- a/tests/value/conftest.py +++ b/tests/value/conftest.py @@ -123,9 +123,9 @@ def linear_shapley(linear_dataset, scorer, n_jobs): return u, exact_values -@pytest.fixture(scope="module", params=["sequential", "ray-local", "ray-external"]) +@pytest.fixture(scope="module", params=["joblib", "ray-local", "ray-external"]) def parallel_config(request): - if request.param == "sequential": + if "ray" not in request.param: yield ParallelConfig(backend=request.param) elif request.param == "ray-local": yield ParallelConfig(backend="ray") From 5f424b900863a1f034ea8a4039ac99833599bfd7 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 12 Jul 2023 20:47:54 +0200 Subject: [PATCH 165/436] Update changelog --- CHANGELOG.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index fb6bfaf3a..19aa53906 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,9 @@ [PR #371](https://github.com/appliedAI-Initiative/pyDVL/pull/371) - Major changes to IF interface and functionality [PR #278](https://github.com/appliedAI-Initiative/pyDVL/pull/278) +- **Breaking Changes** Add new joblib backend and set it as default + instead of the ray backend. Simplify the MapReduceJob class. + [PR #355](https://github.com/appliedAI-Initiative/pyDVL/pull/355) ## 0.6.1 - 🏗 Bug fixes and small improvement From c7929934fdc664ab24c287e335108a495e8ec0e4 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 12 Jul 2023 20:49:22 +0200 Subject: [PATCH 166/436] Fix type hint --- src/pydvl/utils/parallel/backend.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index b5a9fa39a..30f3ccac2 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -122,7 +122,7 @@ def get( ) -> T: return v - def put(self, v: T, *args, **kwargs) -> Union[T]: + def put(self, v: T, *args, **kwargs) -> T: return v def wrap(self, fun: Callable, **kwargs) -> Callable: From c291c5039a547327e7e230094e542685e4f9ff0a Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 13 Jul 2023 11:19:08 +0200 Subject: [PATCH 167/436] Force using python3.8 for the type-checking environment --- tox.ini | 1 + 1 file changed, 1 insertion(+) diff --git a/tox.ini b/tox.ini index 3433fe113..46e7c094e 100644 --- a/tox.ini +++ b/tox.ini @@ -71,6 +71,7 @@ whitelist_externals = bash [testenv:type-checking] +basepython = python3.8 skip_install = true setenv = MYPY_FORCE_COLOR=1 From 2df8c4ef72599155c8b88576146572e3c6ca0197 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 13 Jul 2023 11:19:25 +0200 Subject: [PATCH 168/436] Fix MapReduceJob type hints --- src/pydvl/utils/parallel/backend.py | 7 ++++--- src/pydvl/utils/parallel/map_reduce.py | 29 +++++++------------------- src/pydvl/utils/types.py | 16 ++++++++++++-- src/pydvl/value/shapley/naive.py | 4 ++-- 4 files changed, 28 insertions(+), 28 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index 30f3ccac2..2eb8224cc 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -144,9 +144,10 @@ def wait( def _effective_n_jobs(self, n_jobs: int) -> int: if n_jobs < 0: - eff_n_jobs = self.config["n_jobs"] - if eff_n_jobs is None: - eff_n_jobs = joblib.effective_n_jobs(n_jobs) + if self.config["n_jobs"] is None: + eff_n_jobs: int = joblib.effective_n_jobs(n_jobs) + else: + eff_n_jobs = self.config["n_jobs"] else: eff_n_jobs = min(n_jobs, joblib.effective_n_jobs(n_jobs)) return eff_n_jobs diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index ed57209ce..112beb2f4 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -1,21 +1,11 @@ from itertools import accumulate, repeat -from typing import ( - Any, - Callable, - Dict, - Generic, - List, - Optional, - Sequence, - TypeVar, - Union, -) +from typing import Any, Collection, Dict, Generic, List, Optional, TypeVar, Union from joblib import Parallel, delayed from numpy.typing import NDArray from ..config import ParallelConfig -from ..types import maybe_add_argument +from ..types import MapFunction, ReduceFunction, maybe_add_argument from .backend import init_parallel_backend __all__ = ["MapReduceJob"] @@ -23,11 +13,8 @@ T = TypeVar("T") R = TypeVar("R") -MapFunction = Callable[..., R] -ReduceFunction = Callable[[List[R]], R] - -def identity(x: T, *args: Any, **kwargs: Any) -> T: +def identity(x: Any, *args: Any, **kwargs: Any) -> Any: return x @@ -82,7 +69,7 @@ class MapReduceJob(Generic[T, R]): def __init__( self, - inputs: Union[Sequence[T], T], + inputs: Union[Collection[T], T], map_func: MapFunction[R], reduce_func: ReduceFunction[R] = identity, map_kwargs: Optional[Dict] = None, @@ -137,8 +124,8 @@ def __call__( return reduce_results def _chunkify( - self, data: Union[NDArray[T], Sequence[T], T], n_chunks: int - ) -> List[Union[NDArray[T], Sequence[T], T]]: + self, data: Union[NDArray, Collection[T], T], n_chunks: int + ) -> List[Union[NDArray, Collection[T], T]]: """If data is a Sequence, it splits it into Sequences of size `n_chunks` for each job that we call chunks. If instead data is an `ObjectRef` instance, then it yields it repeatedly `n_chunks` number of times. """ @@ -151,7 +138,7 @@ def _chunkify( try: # This is used as a check to determine whether data is iterable or not # if it's the former, then the value will be used to determine the chunk indices. - n = len(data) + n = len(data) # type: ignore except TypeError: return list(repeat(data, times=n_chunks)) else: @@ -172,7 +159,7 @@ def _chunkify( for start_index, end_index in zip(chunk_indices[:-1], chunk_indices[1:]): if start_index >= end_index: break - chunk = data[start_index:end_index] + chunk = data[start_index:end_index] # type: ignore chunks.append(chunk) return chunks diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index 05f9f724e..2184ab47a 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -2,11 +2,23 @@ transformations. Some of it probably belongs elsewhere. """ import inspect -from typing import Callable, Protocol, Type +from typing import Any, Callable, Protocol, TypeVar from numpy.typing import NDArray -__all__ = ["SupervisedModel"] +__all__ = ["SupervisedModel", "MapFunction", "ReduceFunction"] + +R = TypeVar("R", covariant=True) + + +class MapFunction(Protocol[R]): + def __call__(self, *args: Any, **kwargs: Any) -> R: + ... + + +class ReduceFunction(Protocol[R]): + def __call__(self, *args: Any, **kwargs: Any) -> R: + ... class SupervisedModel(Protocol): diff --git a/src/pydvl/value/shapley/naive.py b/src/pydvl/value/shapley/naive.py index d903ff80b..455c3de44 100644 --- a/src/pydvl/value/shapley/naive.py +++ b/src/pydvl/value/shapley/naive.py @@ -1,7 +1,7 @@ import math import warnings from itertools import permutations -from typing import List, Sequence +from typing import Collection, List import numpy as np from numpy.typing import NDArray @@ -59,7 +59,7 @@ def permutation_exact_shapley(u: Utility, *, progress: bool = True) -> Valuation def _combinatorial_exact_shapley( - indices: Sequence[int], u: Utility, progress: bool + indices: NDArray, u: Utility, progress: bool ) -> NDArray: """Helper function for :func:`combinatorial_exact_shapley`. From 7a140684947c2e2538164abb5c9bc249d964ca78 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 13 Jul 2023 16:05:32 +0200 Subject: [PATCH 169/436] Remove loky as a requirement --- requirements.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index ab192ce70..235b21620 100644 --- a/requirements.txt +++ b/requirements.txt @@ -6,7 +6,6 @@ scipy>=1.7.0 cvxpy>=1.3.0 ray>=0.8 joblib -loky>=3.0.0 pymemcache cloudpickle tqdm From 58bc33fdaaef6f47671c1bb818cae6838dfa9251 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 13 Jul 2023 16:05:48 +0200 Subject: [PATCH 170/436] Do not call parallel_backend.put on map and reduce kwargs --- src/pydvl/utils/parallel/map_reduce.py | 15 ++------------- 1 file changed, 2 insertions(+), 13 deletions(-) diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index 112beb2f4..0f3df2b3c 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -90,19 +90,8 @@ def __init__( self.inputs_ = inputs - if map_kwargs is None: - self.map_kwargs = dict() - else: - self.map_kwargs = { - k: self.parallel_backend.put(v) for k, v in map_kwargs.items() - } - - if reduce_kwargs is None: - self.reduce_kwargs = dict() - else: - self.reduce_kwargs = { - k: self.parallel_backend.put(v) for k, v in reduce_kwargs.items() - } + self.map_kwargs = map_kwargs if map_kwargs is not None else dict() + self.reduce_kwargs = reduce_kwargs if reduce_kwargs is not None else dict() self._map_func = maybe_add_argument(map_func, "job_id") self._reduce_func = reduce_func From 93251636d5a40b53a1816f97d5cf7d3361c63d96 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 13 Jul 2023 18:41:18 +0200 Subject: [PATCH 171/436] Fix computing effective n jobs for joblib backend --- src/pydvl/utils/parallel/backend.py | 10 ++++------ tests/utils/test_parallel.py | 2 +- 2 files changed, 5 insertions(+), 7 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index 2eb8224cc..cac16afb5 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -143,13 +143,11 @@ def wait( return v, [] def _effective_n_jobs(self, n_jobs: int) -> int: - if n_jobs < 0: - if self.config["n_jobs"] is None: - eff_n_jobs: int = joblib.effective_n_jobs(n_jobs) - else: - eff_n_jobs = self.config["n_jobs"] + if self.config["n_jobs"] is None: + maximum_n_jobs = joblib.effective_n_jobs() else: - eff_n_jobs = min(n_jobs, joblib.effective_n_jobs(n_jobs)) + maximum_n_jobs = self.config["n_jobs"] + eff_n_jobs: int = min(joblib.effective_n_jobs(n_jobs), maximum_n_jobs) return eff_n_jobs diff --git a/tests/utils/test_parallel.py b/tests/utils/test_parallel.py index 343205e8c..af3ddf99d 100644 --- a/tests/utils/test_parallel.py +++ b/tests/utils/test_parallel.py @@ -14,7 +14,7 @@ def test_effective_n_jobs(parallel_config, num_workers): parallel_backend = init_parallel_backend(parallel_config) assert parallel_backend.effective_n_jobs(1) == 1 - assert parallel_backend.effective_n_jobs(4) == 4 + assert parallel_backend.effective_n_jobs(4) == min(4, num_workers) if parallel_config.address is None: assert parallel_backend.effective_n_jobs(-1) == num_workers else: From 7477a0c5e581e6abe23881976094ac7ea1ef98ee Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 13 Jul 2023 19:43:57 +0200 Subject: [PATCH 172/436] Change MapReduceJob docstring example to work in CI --- src/pydvl/utils/parallel/map_reduce.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index 0f3df2b3c..079a1118f 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -61,10 +61,10 @@ class MapReduceJob(Generic[T, R]): ... 5, ... map_func=lambda x: np.array([x]), ... reduce_func=np.sum, - ... n_jobs=4, + ... n_jobs=2, ... ) >>> map_reduce_job() - 20 + 10 """ def __init__( From 3471cd568727289f69dd53789d874ceeaeca7d0d Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 13 Jul 2023 21:20:10 +0200 Subject: [PATCH 173/436] use namedtuple of ihvp results, include device in zero tensor --- src/pydvl/influence/frameworks/__init__.py | 4 +-- .../frameworks/torch_differentiable.py | 26 +++++++++---------- .../frameworks/twice_differentiable.py | 2 ++ src/pydvl/influence/general.py | 11 +++++--- src/pydvl/influence/inversion.py | 6 ++--- 5 files changed, 27 insertions(+), 22 deletions(-) diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index af717ffaa..0ed2da702 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -4,9 +4,9 @@ import logging -from .twice_differentiable import TwiceDifferentiable +from .twice_differentiable import TwiceDifferentiable, iHVPResult -__all__ = ["TwiceDifferentiable"] +__all__ = ["TwiceDifferentiable", "iHVPResult"] logger = logging.getLogger("frameworks") try: diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 9e620c94f..5fbbabac2 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -5,7 +5,7 @@ influence of a training point on the model. """ import logging -from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union +from typing import Any, Callable, List, Optional, Sequence, Tuple, Union import numpy as np import torch @@ -15,7 +15,7 @@ from torch.utils.data import DataLoader from ...utils import maybe_progress -from .twice_differentiable import TwiceDifferentiable +from .twice_differentiable import TwiceDifferentiable, iHVPResult __all__ = [ "TorchTwiceDifferentiable", @@ -49,7 +49,7 @@ def solve_linear( *, hessian_perturbation: float = 0.0, progress: bool = False, -) -> Tuple[torch.Tensor, Dict[str, Any]]: +) -> iHVPResult: """Given a model and training data, it finds x s.t. $Hx = b$, with $H$ being the model hessian. @@ -73,7 +73,7 @@ def solve_linear( all_x, all_y, progress=progress ) + hessian_perturbation * identity_tensor(model.num_params, device=model.device) info = {"hessian": matrix} - return torch.linalg.solve(matrix, b.T).T, info + return iHVPResult(x=torch.linalg.solve(matrix, b.T).T, info=info) def solve_batch_cg( @@ -87,7 +87,7 @@ def solve_batch_cg( atol: float = 1e-7, maxiter: Optional[int] = None, progress: bool = False, -) -> Tuple[torch.Tensor, Dict[int, Dict[str, Any]]]: +) -> iHVPResult: """ Given a model and training data, it uses conjugate gradient to calculate the inverse of the Hessian Vector Product. More precisely, it finds x s.t. $Hx = @@ -121,12 +121,12 @@ def solve_batch_cg( batch_cg = torch.zeros_like(b) info = {} for idx, bi in enumerate(maybe_progress(b, progress, desc="Conjugate gradient")): - bi_cg, bi_info = solve_cg( + batch_result = solve_cg( reg_hvp, bi, x0=x0, rtol=rtol, atol=atol, maxiter=maxiter ) - batch_cg[idx] = bi_cg - info[idx] = bi_info - return batch_cg, info + batch_cg[idx] = batch_result.x + info[idx] = batch_result.info + return iHVPResult(x=batch_cg, info=info) def solve_cg( @@ -137,7 +137,7 @@ def solve_cg( rtol: float = 1e-7, atol: float = 1e-7, maxiter: Optional[int] = None, -) -> Tuple[torch.Tensor, Dict[str, Any]]: +) -> iHVPResult: """Conjugate gradient solver for the Hessian vector product :param hvp: a Callable Hvp, operating with tensors of size N @@ -177,7 +177,7 @@ def solve_cg( p = r + beta * p info = {"niter": k, "optimal": optimal, "gamma": gamma} - return x, info + return iHVPResult(x=x, info=info) def solve_lissa( @@ -192,7 +192,7 @@ def solve_lissa( h0: Optional[torch.Tensor] = None, rtol: float = 1e-4, progress: bool = False, -) -> Tuple[torch.Tensor, Dict[str, Any]]: +) -> iHVPResult: r""" Uses LISSA, Linear time Stochastic Second-Order Algorithm, to iteratively approximate the inverse Hessian. More precisely, it finds x s.t. $Hx = b$, @@ -258,7 +258,7 @@ def lissa_step( "max_perc_residual": max_residual * 100, "mean_perc_residual": mean_residual * 100, } - return h_estimate / scale, info + return iHVPResult(x=h_estimate / scale, info=info) def as_tensor(a: Any, warn=True, **kwargs) -> torch.Tensor: diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index 3a767f87f..c0a42f9b7 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -1,9 +1,11 @@ from abc import ABC +from collections import namedtuple from typing import Callable, Generic, List, Sequence, Tuple, TypeVar TensorType = TypeVar("TensorType", bound=Sequence) ModelType = TypeVar("ModelType") DeviceType = TypeVar("DeviceType") +iHVPResult = namedtuple("iHVPResult", ["x", "info"]) class TwiceDifferentiable(ABC, Generic[TensorType, ModelType, DeviceType]): diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 195ad4816..aa59fec44 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -16,7 +16,7 @@ transpose_tensor, zero_tensor, ) -from .inversion import InversionMethod, solve_hvp +from .inversion import InversionMethod, iHVPResult, solve_hvp __all__ = ["compute_influences", "InfluenceType", "compute_influence_factors"] @@ -39,7 +39,7 @@ def compute_influence_factors( hessian_perturbation: float = 0.0, progress: bool = False, **kwargs: Any, -) -> Tuple[TensorType, Dict]: +) -> iHVPResult: r""" Calculates influence factors of a model for training and test data. Given a test point $z_test = (x_{test}, y_{test})$, a loss @@ -66,6 +66,7 @@ def compute_influence_factors( test_grads = zero_tensor( shape=(len(test_data.dataset), model.num_params), dtype=test_data.dataset[0][0].dtype, + device=model.device, ) for batch_idx, (x_test, y_test) in enumerate( maybe_progress(test_data, progress, desc="Batch Test Gradients") @@ -112,6 +113,7 @@ def compute_influences_up( grads = zero_tensor( shape=(len(input_data.dataset), model.num_params), dtype=input_data.dataset[0][0].dtype, + device=model.device, ) for batch_idx, (x, y) in enumerate( maybe_progress(input_data, progress, desc="Batch Split Input Gradients") @@ -151,6 +153,7 @@ def compute_influences_pert( all_pert_influences = zero_tensor( shape=(len(input_data.dataset), len(influence_factors), *input_x.shape), dtype=input_x.dtype, + device=model.device, ) for batch_idx, (x, y) in enumerate( maybe_progress( @@ -222,7 +225,7 @@ def compute_influences( if test_data is None: test_data = deepcopy(training_data) - influence_factors, _ = compute_influence_factors( + influence_factors = compute_influence_factors( differentiable_model, training_data, test_data, @@ -230,7 +233,7 @@ def compute_influences( hessian_perturbation=hessian_regularization, progress=progress, **kwargs, - ) + ).x compute_influence_type = influence_type_registry[influence_type] return compute_influence_type( diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 99ad193cb..3c5c5877c 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -3,13 +3,13 @@ """ import logging from enum import Enum -from typing import Any, Dict, Tuple +from typing import Any from .frameworks import ( DataLoaderType, - ModelType, TensorType, TwiceDifferentiable, + iHVPResult, solve_batch_cg, solve_linear, solve_lissa, @@ -39,7 +39,7 @@ def solve_hvp( hessian_perturbation: float = 0.0, progress: bool = False, **kwargs: Any, -) -> Tuple[TensorType, Dict]: +) -> iHVPResult: """ Finds $x$ such that $Ax = b$, where $A$ is the hessian of model, and $b$ a vector. From b52ef72ce7f5b0fc8da12100f211886f563add4d Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 13 Jul 2023 21:23:52 +0200 Subject: [PATCH 174/436] return hessian in info --- src/pydvl/influence/frameworks/torch_differentiable.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 5fbbabac2..196f2e0a1 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -69,10 +69,11 @@ def solve_linear( all_y.append(y) all_x = cat(all_x) all_y = cat(all_y) - matrix = model.hessian( - all_x, all_y, progress=progress - ) + hessian_perturbation * identity_tensor(model.num_params, device=model.device) - info = {"hessian": matrix} + hessian = model.hessian(all_x, all_y, progress=progress) + matrix = hessian + hessian_perturbation * identity_tensor( + model.num_params, device=model.device + ) + info = {"hessian": hessian} return iHVPResult(x=torch.linalg.solve(matrix, b.T).T, info=info) From 6c7f113a153d5baf6154105c36821f3485d2da82 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Fri, 14 Jul 2023 10:18:05 +0200 Subject: [PATCH 175/436] Functional implementation of hvp using torch.func --- requirements-notebooks.txt | 2 +- .../frameworks/torch_differentiable.py | 13 +- src/pydvl/influence/frameworks/util.py | 317 +++++++++++++----- tests/influence/test_influences.py | 6 +- tests/influence/test_util.py | 55 +-- 5 files changed, 273 insertions(+), 120 deletions(-) diff --git a/requirements-notebooks.txt b/requirements-notebooks.txt index cd8463e63..684a88876 100644 --- a/requirements-notebooks.txt +++ b/requirements-notebooks.txt @@ -1,4 +1,4 @@ -torch==1.13.1 +torch==2.0.1 torchvision==0.14.1 datasets==2.6.1 pillow==9.3.0 diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index b25f9c2d7..438ada7e7 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -19,7 +19,7 @@ from .util import ( LowRankProductRepresentation, get_hvp_function, - lanzcos_low_rank_hessian_approx, + lanzcos_low_rank_hessian_approx, flatten_tensors_to_vector, align_structure, ) __all__ = [ @@ -482,9 +482,14 @@ def solve_arnoldi( """ if low_rank_representation is None: - hessian_vector_product = get_hvp_function( - model.model, model.loss, training_data - ) + + raw_hvp = get_hvp_function(model.model, model.loss, training_data, use_hessian_avg=True) + params = dict(model.model.named_parameters()) + + def hessian_vector_product(x: torch.Tensor) -> torch.Tensor: + output = raw_hvp(align_structure(params, x)) + return flatten_tensors_to_vector(output.values()) + low_rank_representation = lanzcos_low_rank_hessian_approx( hessian_vp=hessian_vector_product, matrix_shape=(model.num_params, model.num_params), diff --git a/src/pydvl/influence/frameworks/util.py b/src/pydvl/influence/frameworks/util.py index 6eef8ae6b..8e7273063 100644 --- a/src/pydvl/influence/frameworks/util.py +++ b/src/pydvl/influence/frameworks/util.py @@ -1,14 +1,19 @@ import logging +import copy from dataclasses import dataclass -from functools import partial, reduce -from typing import Callable, Generator, Iterable, Optional, Tuple +from functools import partial +from typing import Callable, Generator, Iterable, Optional, Tuple, Union, Dict +import math import torch +from torch.func import vjp, grad, jvp, functional_call from numpy.typing import NDArray from torch.utils.data import DataLoader logger = logging.getLogger(__name__) +Input_type = Union[torch.Tensor, Tuple[torch.Tensor], Dict[str, torch.Tensor]] + def to_model_device(x: torch.Tensor, model: torch.nn.Module) -> torch.Tensor: """ @@ -22,43 +27,107 @@ def to_model_device(x: torch.Tensor, model: torch.nn.Module) -> torch.Tensor: return x +def flatten_tensors_to_vector(tensors: Iterable[torch.Tensor]): + """ + Flatten multiple tensors into a single 1D tensor (vector). + + The function takes an iterable of tensors and reshapes each of them into a 1D tensor. + These reshaped tensors are then concatenated together into a single 1D tensor in the order they were given. + + Parameters: + tensors (Iterable[torch.Tensor]): An iterable of tensors to be reshaped and concatenated. + + Returns: + torch.Tensor: A 1D tensor that is the concatenation of all the reshaped input tensors. + """ + + return torch.cat([t.contiguous().view(-1) for t in tensors]) + + +def reshape_vector_to_tensors(input_vector: torch.Tensor, target_shapes: Iterable[Tuple[int, ...]]): + """ + Reshape a 1D tensor into multiple tensors with specified shapes. + + The function takes a 1D tensor (input_vector) and reshapes it into a series of tensors with shapes given by 'target_shapes'. + The reshaped tensors are returned as a tuple in the same order as their corresponding shapes. + + Note: The total number of elements in 'input_vector' must be equal to the sum of the products of the shapes in 'target_shapes'. + + Parameters: + input_vector (Tensor): The 1D tensor to be reshaped. Must be 1D. + target_shapes (Iterable[Tuple[int, ...]]): An iterable of tuples. Each tuple defines the shape of a tensor to be + reshaped from the 'input_vector'. + + Returns: + tuple[torch.Tensor]: A tuple of reshaped tensors. + + Raises: + ValueError: If 'input_vector' is not a 1D tensor or if the total number of elements in 'input_vector' does not match + the sum of the products of the shapes in 'target_shapes'. + """ + + if input_vector.dim() != 1: + raise ValueError("Input vector must be a 1D tensor") + + total_elements = sum(math.prod(shape) for shape in target_shapes) + + if total_elements != input_vector.shape[0]: + raise ValueError(f"The total elements in shapes {total_elements} does not match the vector length {input_vector.shape[0]}") + + tensors = [] + start = 0 + for shape in target_shapes: + size = math.prod(shape) # compute the total size of the tensor with this shape + tensors.append(input_vector[start:start+size].view(shape)) # slice the vector and reshape it + start += size + return tuple(tensors) + + def hvp( - model: torch.nn.Module, - loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], - x: torch.Tensor, - y: torch.Tensor, - vec: torch.Tensor, -) -> torch.Tensor: + func: Callable[[Input_type], torch.Tensor], + params: Input_type, + vec: Input_type, + reverse_only: bool = True +) -> Input_type: """ - Returns H*vec where H is the Hessian of the loss with respect to - the model parameters. - - :param model: A torch.nn.Module, whose parameters are used for backpropagation. - :param loss: A loss function, which is a callable that takes the model's - output and target as input and returns a scalar loss. - :param x: Input tensor to the model. - :param y: Target output tensor. - :param vec: The vector with which the Hessian of the loss function is to be multiplied. - :return: A tensor of the same shape as vec, representing the product of the Hessian of the loss function - with respect to the model parameters and the input vector. + Computes the Hessian-vector product (HVP) for a given function at given parameters. + This function can operate in two modes, either reverse-mode autodiff only or both + forward- and reverse-mode autodiff. + + + Args: + func (Callable[[Input_type], torch.Tensor]): The function for which the HVP is computed. + params (Input_type): The parameters at which the HVP is computed. + vec (Input_type): The vector with which the Hessian is multiplied. + reverse_only (bool, optional): Whether to use only reverse-mode autodiff + (True, default) or both forward- and reverse-mode autodiff (False). + + Returns: + Input_type: The HVP of the function at the given parameters with the given vector. + + Examples: + >>> def f(z): return torch.sum(z**2) + >>> u = torch.ones(10, requires_grad=True) + >>> v = torch.ones(10) + >>> hvp_vec = hvp(f, u, v) + >>> assert torch.allclose(hvp_vec, torch.full((10, ), 2.0)) """ - outputs = model(to_model_device(x, model)) - loss_value = loss(outputs, to_model_device(y, model)) - params = [p for p in model.parameters() if p.requires_grad] - grads = torch.autograd.grad(loss_value, params, create_graph=True) + if reverse_only: + _, vjp_fn = vjp(grad(func), params) + output = vjp_fn(vec)[0] + else: + output = jvp(grad(func), (params, ), (vec,))[1] + + return output - flat_grads = torch.cat([g.contiguous().view(-1) for g in grads]) - grad_vec_product = torch.dot(flat_grads, vec) - hessian_vec_prod = torch.autograd.grad(grad_vec_product, params) - hessian_vec_prod = torch.cat([g.contiguous().view(-1) for g in hessian_vec_prod]) - return hessian_vec_prod def batch_hvp_gen( model: torch.nn.Module, loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], data_loader: DataLoader, + reverse_only: bool = True ) -> Generator[Callable[[torch.Tensor], torch.Tensor], None, None]: """ Generates a sequence of batch Hessian-vector product (HVP) computations for the provided model, loss function, @@ -69,50 +138,14 @@ def batch_hvp_gen( :param model: The PyTorch model for which the HVP is calculated. :param loss: The loss function used to calculate the gradient and HVP. :param data_loader: PyTorch DataLoader object containing the dataset for which the HVP is calculated. + :param reverse_only: :yield: A partial function H(vec)=hvp(model, loss, inputs, targets, vec) that when called, will compute the Hessian-vector product H(vec) for the given model, loss, inputs and targets. """ for inputs, targets in iter(data_loader): - yield partial(hvp, model, loss, inputs, targets) - - -def avg_gradient( - model: torch.nn.Module, - loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], - data_loader: DataLoader, -) -> torch.Tensor: - """ - Returns the average gradient of the loss function with respect to the model parameters - :param model: A torch.nn.Module, whose parameters are used for backpropagation. - :param loss: A loss function, which is a callable that takes the model's output and target as input - and returns a scalar loss. - :param data_loader: an instance of :class:`torch.utils.data.DataLoader` - :return: average of batch gradients - """ - params = [p for p in model.parameters() if p.requires_grad] - total_grad_xy = None - total_points = 0 - num_batches = len(data_loader) - - for k, (x, y) in enumerate(data_loader): - logger.debug(f"Computing the gradient for batch {k+1}/{num_batches}") - outputs = model(to_model_device(x, model)) - loss_value = loss(outputs, to_model_device(y, model)) - grads = torch.autograd.grad(loss_value, params, create_graph=True) - flat_grads = torch.cat([g.contiguous().view(-1) for g in grads]) - - num_points_in_batch = len(x) - if total_grad_xy is None: - total_grad_xy = flat_grads * num_points_in_batch - else: - total_grad_xy += flat_grads * num_points_in_batch - total_points += num_points_in_batch - - if total_grad_xy is None: - raise ValueError("DataLoader is empty") - - return total_grad_xy / total_points + batch_loss = batch_loss_function(model, loss, inputs, targets) + yield partial(hvp, batch_loss, dict(model.named_parameters()), reverse_only=reverse_only) def get_hvp_function( @@ -120,7 +153,8 @@ def get_hvp_function( loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], data_loader: DataLoader, use_hessian_avg: bool = True, -) -> Callable[[torch.Tensor], torch.Tensor]: + reverse_only: bool = True +) -> Callable[[Dict[str, torch.Tensor]], Dict[str, torch.Tensor]]: """ Returns a function that calculates the approximate Hessian-vector product for a given vector. If you want to compute the exact hessian, i.e. pulling all data into memory and compute a full gradient computation, use @@ -139,23 +173,27 @@ def get_hvp_function( `loss` function with respect to the `model`'s parameters and the input vector. """ + params = dict(model.named_parameters()) - def hvp_function(vec: torch.Tensor) -> torch.Tensor: - params = [p for p in model.parameters() if p.requires_grad] - avg_grad = avg_gradient(model, loss, data_loader) + def hvp_function(vec: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]: + v = align_structure(params, vec) + empirical_loss = empirical_loss_function(model, loss, data_loader) + return hvp(empirical_loss, params, v, reverse_only=reverse_only) - grad_vec_product = torch.dot(avg_grad, vec) - hessian_vec_prod = torch.autograd.grad(grad_vec_product, params) - hessian_vec_prod = torch.cat( - [g.contiguous().view(-1) for g in hessian_vec_prod] + def avg_hvp_function(vec: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]: + v = align_structure(params, vec) + batch_hessians: Iterable[Dict[str, torch.Tensor]] = map( + lambda x: x(v), batch_hvp_gen(model, loss, data_loader, reverse_only) ) - return hessian_vec_prod - def avg_hvp_function(vec: torch.Tensor) -> torch.Tensor: - batch_hessians: Iterable[torch.Tensor] = map( - lambda x: x(vec), batch_hvp_gen(model, loss, data_loader) - ) - return reduce(lambda x, y: x + y, batch_hessians) / len(data_loader) + result_dict = {key: to_model_device(torch.zeros_like(p), model) for key, p in params.items()} + num_batches = len(data_loader) + + for batch_dict in batch_hessians: + for key, value in batch_dict.items(): + result_dict[key] += value + + return {key: value/num_batches for key, value in result_dict.items()} return avg_hvp_function if use_hessian_avg else hvp_function @@ -249,13 +287,12 @@ def mv_cupy(x): else: from scipy.sparse.linalg import ArpackNoConvergence, LinearOperator, eigsh + torch_default_dtype = torch.get_default_dtype() def mv_scipy(x: NDArray) -> NDArray: - x_torch = torch.from_numpy(x) - if device is not None: - x_torch = x_torch.to(device) + x_torch = torch.as_tensor(x, device=device, dtype=torch_default_dtype) y: NDArray = ( - (hessian_vp(x_torch) + hessian_perturbation * x_torch).cpu().numpy() + (hessian_vp(x_torch) + hessian_perturbation * x_torch).detach().cpu().numpy() ) return y @@ -276,9 +313,115 @@ def mv_scipy(x: NDArray) -> NDArray: f"modify parameters.\n Original error: {e}" ) return LowRankProductRepresentation( - torch.from_numpy(e.eigenvalues), torch.from_numpy(e.eigenvectors) + torch.as_tensor(e.eigenvalues, dtype=torch_default_dtype), + torch.as_tensor(e.eigenvectors, dtype=torch_default_dtype) ) return LowRankProductRepresentation( - torch.from_numpy(eigen_vals), torch.from_numpy(eigen_vecs) + torch.as_tensor(eigen_vals, dtype=torch_default_dtype), + torch.as_tensor(eigen_vecs, dtype=torch_default_dtype) ) + + +def empirical_loss_function(model: torch.nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + data_loader: DataLoader) -> Callable[[Dict[str, torch.Tensor]], torch.Tensor]: + """ + Creates a function to compute the empirical loss of a given model on a given dataset. + If we denote the model parameters with $\theta$, the resulting function approximates + + .. math:: + + f(\theta) = \frac{1}{N}\sum_{i=1}^N \operatorname{loss}(y_i, \operatorname{model}(\theta, x_i))) + + Args: + model (torch.nn.Module): The model for which the loss should be computed. + loss (Callable[[torch.Tensor, torch.Tensor], torch.Tensor]): The loss function to be used. + data_loader (torch.utils.data.DataLoader): The data loader for iterating over the dataset. + + Returns: + Callable[[torch.nn.parameter.Parameter], torch.Tensor]: A function that computes the empirical loss + of the model on the dataset for given model parameters. + + """ + def empirical_loss(params: Dict[str, torch.Tensor]): + total_loss = to_model_device(torch.zeros((), requires_grad=True), model) + total_samples = to_model_device(torch.zeros(()), model) + + for x, y in iter(data_loader): + output = functional_call(model, params, (to_model_device(x, model),), strict=True) + loss_value = loss(output, to_model_device(y, model)) + total_loss = total_loss + loss_value * x.size(0) + total_samples += x.size(0) + + return total_loss / total_samples + + return empirical_loss + + +def batch_loss_function(model: torch.nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + x: torch.Tensor, + y: torch.Tensor) -> Callable[[Dict[str, torch.Tensor]], torch.Tensor]: + """ + Creates a function to compute the loss of a given model on a given batch of data. + + Args: + model (torch.nn.Module): The model for which the loss should be computed. + loss (Callable[[torch.Tensor, torch.Tensor], torch.Tensor]): The loss function to be used. + x (torch.Tensor): The input data for the batch. + y (torch.Tensor): The true labels for the batch. + + Returns: + Callable[[Dict[str, torch.Tensor]], torch.Tensor]: A function that computes the loss + of the model on the batch for given model parameters. + """ + def batch_loss(params: Dict[str, torch.Tensor]): + outputs = functional_call(model, params, (to_model_device(x, model),), strict=True) + return loss(outputs, y) + + return batch_loss + + +Input_type = Union[torch.Tensor, Tuple[torch.Tensor], Dict[str, torch.Tensor]] + + +def align_structure(source: Dict[str, torch.Tensor], target: Input_type): + """ + This function transforms `target` to have the same structure as `source`, i.e., + it should be a dictionary with the same keys as `source` and each corresponding + value in `target` should have the same shape as the value in `source`. + + Args: + source (dict): The reference dictionary containing PyTorch tensors. + target (Input_type): The input to be harmonized. It can be a dictionary, tuple, or tensor. + + Returns: + dict: The harmonized version of `target`. + + Raises: + ValueError: If `target` cannot be harmonized to match `source`. + """ + + tangent = copy.copy(target) + + if isinstance(tangent, dict): + if list(tangent.keys()) != list(source.keys()): + raise ValueError("The keys in 'target' do not match the keys in 'source'.") + if list(map(lambda v: v.shape, tangent.values())) != list(map(lambda v: v.shape, source.values())): + raise ValueError("The shapes of the values in 'target' do not match the shapes of the values in 'source'.") + elif isinstance(tangent, tuple) or isinstance(tangent, list): + if list(map(lambda v: v.shape, tangent)) != list(map(lambda v: v.shape, source.values())): + raise ValueError("'target' is a tuple/list but its elements' shapes do not match the shapes " + "of the values in 'source'.") + tangent = dict(zip(source.keys(), tangent)) + elif isinstance(tangent, torch.Tensor): + try: + tangent = reshape_vector_to_tensors(tangent, list(map(lambda p: p.shape, source.values()))) + tangent = dict(zip(source.keys(), tangent)) + except Exception as e: + raise ValueError(f"'target' is a tensor but cannot be reshaped to match 'source'. Original error: {e}") + else: + raise ValueError(f"'target' is of type {type(tangent)} which is not supported.") + + return tangent diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index dcaa19428..77eaf01db 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -22,8 +22,6 @@ linear_model, ) -torch.set_default_dtype(torch.float64) - def analytical_linear_influences( linear_model: Tuple[NDArray[np.float_], NDArray[np.float_]], @@ -111,8 +109,6 @@ def test_influence_linear_model( condition_number: float = 2, ): - torch.set_default_dtype(torch.float64) - A, b = linear_model(problem_dimension, condition_number) train_data, test_data = add_noise_to_linear_model( (A, b), train_set_size, test_set_size @@ -418,4 +414,4 @@ def test_influences_arnoldi( rank_estimate=num_parameters - 1, ) - assert np.allclose(direct_influence, low_rank_influence, rtol=1e-2) + assert np.allclose(direct_influence, low_rank_influence, rtol=1e-1) diff --git a/tests/influence/test_util.py b/tests/influence/test_util.py index 35dc3ef98..b86c4b7fa 100644 --- a/tests/influence/test_util.py +++ b/tests/influence/test_util.py @@ -1,19 +1,18 @@ from dataclasses import astuple, dataclass from typing import Tuple -import numpy as np import pytest torch = pytest.importorskip("torch") -import torch import torch.nn +from torch.nn.functional import mse_loss from numpy.typing import NDArray from torch.utils.data import DataLoader, TensorDataset from pydvl.influence.frameworks.util import ( get_hvp_function, hvp, - lanzcos_low_rank_hessian_approx, + lanzcos_low_rank_hessian_approx, batch_loss_function, align_structure, flatten_tensors_to_vector, ) from tests.influence.conftest import linear_hessian_analytical, linear_model @@ -80,9 +79,9 @@ def linear_torch_model_from_numpy(A: NDArray, b: NDArray) -> torch.nn.Module: """ output_dimension, input_dimension = tuple(A.shape) model = torch.nn.Linear(input_dimension, output_dimension) - model.eval() - model.weight.data = torch.as_tensor(A) - model.bias.data = torch.as_tensor(b) + #model.eval() + #model.weight.data = torch.as_tensor(A) + #model.bias.data = torch.as_tensor(b) return model @@ -90,34 +89,38 @@ def linear_torch_model_from_numpy(A: NDArray, b: NDArray) -> torch.nn.Module: def model_data(request): dimension, condition_number, train_size = request.param A, b = linear_model(dimension, condition_number) - x = np.random.uniform(size=[train_size, dimension[-1]]) - y = np.random.uniform(size=[train_size, dimension[0]]) + x = torch.rand(train_size, dimension[-1]) + y = torch.rand(train_size, dimension[0]) torch_model = linear_torch_model_from_numpy(A, b) - num_params = sum(p.numel() for p in torch_model.parameters() if p.requires_grad) - vec = np.random.uniform(size=(num_params,)) - H_analytical = linear_hessian_analytical((A, b), x) - x = torch.as_tensor(x) - y = torch.as_tensor(y) - vec = torch.as_tensor(vec) + vec = {name: torch.rand(*p.shape) for name, p in torch_model.named_parameters() if p.requires_grad} + H_analytical = linear_hessian_analytical((A, b), x.numpy()) H_analytical = torch.as_tensor(H_analytical) - return torch_model, x, y, vec, H_analytical + return torch_model, x, y, vec, H_analytical.to(torch.float32) @pytest.mark.torch @pytest.mark.parametrize( "model_data, tol", - [(astuple(tp.model_params), 1e-12) for tp in test_parameters], + [(astuple(tp.model_params), 1e-5) for tp in test_parameters], indirect=["model_data"], ) def test_hvp(model_data, tol: float): torch_model, x, y, vec, H_analytical = model_data - Hvp_autograd = hvp(torch_model, torch.nn.functional.mse_loss, x, y, vec) - assert torch.allclose(Hvp_autograd, H_analytical @ vec, rtol=tol) + vec_flat = flatten_tensors_to_vector(vec.values()) + + params = dict(torch_model.named_parameters()) + + f = batch_loss_function(torch_model, torch.nn.functional.mse_loss, x, y) + + Hvp_autograd = hvp(f, params, align_structure(params, vec)) + + flat_Hvp_autograd = flatten_tensors_to_vector(Hvp_autograd.values()) + assert torch.allclose(flat_Hvp_autograd, H_analytical @ vec_flat, rtol=tol) @pytest.mark.torch @pytest.mark.parametrize( - "use_avg, tol", [(True, 1e-3), (False, 1e-6)], ids=["avg", "full"] + "use_avg, tol", [(True, 1e-5), (False, 1e-5)], ids=["avg", "full"] ) @pytest.mark.parametrize( "model_data, batch_size", @@ -127,10 +130,14 @@ def test_hvp(model_data, tol: float): def test_get_hvp_function(model_data, tol: float, use_avg: bool, batch_size: int): torch_model, x, y, vec, H_analytical = model_data data_loader = DataLoader(TensorDataset(x, y), batch_size=batch_size) + Hvp_autograd = get_hvp_function( - torch_model, torch.nn.functional.mse_loss, data_loader, use_hessian_avg=use_avg + torch_model, mse_loss, data_loader, use_hessian_avg=use_avg )(vec) - assert torch.allclose(Hvp_autograd, H_analytical @ vec, rtol=tol) + vec_flat = flatten_tensors_to_vector(vec.values()) + flat_Hvp_autograd = flatten_tensors_to_vector(Hvp_autograd.values()) + + assert torch.allclose(flat_Hvp_autograd, H_analytical @ vec_flat, rtol=tol) @pytest.mark.torch @@ -144,6 +151,8 @@ def test_lanzcos_low_rank_hessian_approx( ): _, _, _, vec, H_analytical = model_data + vec_flat = flatten_tensors_to_vector(vec.values()) + reg_H_analytical = H_analytical + regularization * torch.eye(H_analytical.shape[0]) low_rank_approx = lanzcos_low_rank_hessian_approx( lambda z: reg_H_analytical @ z, @@ -152,9 +161,9 @@ def test_lanzcos_low_rank_hessian_approx( ) approx_result = low_rank_approx.projections @ ( torch.diag_embed(low_rank_approx.eigen_vals) - @ (low_rank_approx.projections.t() @ vec.t()) + @ (low_rank_approx.projections.t() @ vec_flat.t()) ) - assert torch.allclose(approx_result, reg_H_analytical @ vec, rtol=1e-1) + assert torch.allclose(approx_result, reg_H_analytical @ vec_flat, rtol=1e-1) @pytest.mark.torch From 81e6bc2c7b8c22a819d1bd1db7e4fd5843808635 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 14 Jul 2023 15:43:43 +0200 Subject: [PATCH 176/436] minor changes to docs --- docs/40-influence.rst | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/docs/40-influence.rst b/docs/40-influence.rst index 8793dd098..e1e37cd08 100644 --- a/docs/40-influence.rst +++ b/docs/40-influence.rst @@ -19,10 +19,8 @@ Computing influence values The influence function (IF) is a method to quantify the effect (influence) that each training point has on the parameters of a model, and by extension on any function thereof. In particular, it is possible to estimate how much each -training sample affects the error on a test point, making the IF really useful -for understanding and debugging models. It is in a sense similar to, and -sometimes used with together with valuation functions, but have are more solid -theoretical foundation. +training sample affects the error on a test point, making the IF useful +for understanding and debugging models. pyDVL implements several methods for the efficient computation of the IF for machine learning. @@ -133,7 +131,7 @@ Perturbation definition of the influence score How would the loss of the model change if, instead of up-weighting an individual point $z$, we were to up-weight only a single feature of that point? Given $z = (x, y)$, we can define $z_{\delta} = (x+\delta, y)$, where $\delta$ is a vector -of zeros except for a 1 in the position of the feature we want to up-weigh. In +of zeros except for a 1 in the position of the feature we want to up-weight. In order to approximate the effect of modifying a single feature of a single point on the model score we can define From 8f1c316e436b9b946a9e0886e2fea05f6cd2508a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Fri, 14 Jul 2023 15:47:49 +0200 Subject: [PATCH 177/436] [skip ci] Refactor functional implementation of hvp computation --- src/pydvl/influence/frameworks/functional.py | 201 ++++++++++ .../frameworks/torch_differentiable.py | 142 ++++++- src/pydvl/influence/frameworks/util.py | 350 ++---------------- tests/influence/test_util.py | 22 +- 4 files changed, 382 insertions(+), 333 deletions(-) create mode 100644 src/pydvl/influence/frameworks/functional.py diff --git a/src/pydvl/influence/frameworks/functional.py b/src/pydvl/influence/frameworks/functional.py new file mode 100644 index 000000000..faa5aa71b --- /dev/null +++ b/src/pydvl/influence/frameworks/functional.py @@ -0,0 +1,201 @@ +from functools import partial +from typing import Callable, Dict, Generator, Iterable + +import torch +from torch.func import functional_call, grad, jvp, vjp +from torch.utils.data import DataLoader + +from .util import Input_type, align_structure, to_model_device + + +def hvp( + func: Callable[[Input_type], torch.Tensor], + params: Input_type, + vec: Input_type, + reverse_only: bool = True, +) -> Input_type: + """ + Computes the Hessian-vector product (HVP) for a given function at given parameters. + This function can operate in two modes, either reverse-mode autodiff only or both + forward- and reverse-mode autodiff. + + + Args: + func (Callable[[Input_type], torch.Tensor]): The function for which the HVP is computed. + params (Input_type): The parameters at which the HVP is computed. + vec (Input_type): The vector with which the Hessian is multiplied. + reverse_only (bool, optional): Whether to use only reverse-mode autodiff + (True, default) or both forward- and reverse-mode autodiff (False). + + Returns: + Input_type: The HVP of the function at the given parameters with the given vector. + + Examples: + >>> def f(z): return torch.sum(z**2) + >>> u = torch.ones(10, requires_grad=True) + >>> v = torch.ones(10) + >>> hvp_vec = hvp(f, u, v) + >>> assert torch.allclose(hvp_vec, torch.full((10, ), 2.0)) + """ + + if reverse_only: + _, vjp_fn = vjp(grad(func), params) + output = vjp_fn(vec)[0] + else: + output = jvp(grad(func), (params,), (vec,))[1] + + return output + + +def batch_hvp_gen( + model: torch.nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + data_loader: DataLoader, + reverse_only: bool = True, +) -> Generator[ + Callable[[Dict[str, torch.Tensor]], Dict[str, torch.Tensor]], None, None +]: + """ + Generates a sequence of batch Hessian-vector product (HVP) computations for the provided model, loss function, + and data loader. + + The generator iterates over the data_loader, creating partial function calls for calculating HVPs. + + :param model: The PyTorch model for which the HVP is calculated. + :param loss: The loss function used to calculate the gradient and HVP. + :param data_loader: PyTorch DataLoader object containing the dataset for which the HVP is calculated. + :param reverse_only: + :yield: A partial function H(vec)=hvp(model, loss, inputs, targets, vec) that when called, + will compute the Hessian-vector product H(vec) for the given model, loss, inputs and targets. + """ + + for inputs, targets in iter(data_loader): + batch_loss = batch_loss_function(model, loss, inputs, targets) + yield partial( + hvp, batch_loss, dict(model.named_parameters()), reverse_only=reverse_only + ) + + +def empirical_loss_function( + model: torch.nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + data_loader: DataLoader, +) -> Callable[[Dict[str, torch.Tensor]], torch.Tensor]: + """ + Creates a function to compute the empirical loss of a given model on a given dataset. + If we denote the model parameters with $\theta$, the resulting function approximates + + .. math:: + + f(\theta) = \frac{1}{N}\sum_{i=1}^N \operatorname{loss}(y_i, \operatorname{model}(\theta, x_i))) + + Args: + model (torch.nn.Module): The model for which the loss should be computed. + loss (Callable[[torch.Tensor, torch.Tensor], torch.Tensor]): The loss function to be used. + data_loader (torch.utils.data.DataLoader): The data loader for iterating over the dataset. + + Returns: + Callable[[torch.nn.parameter.Parameter], torch.Tensor]: A function that computes the empirical loss + of the model on the dataset for given model parameters. + + """ + + def empirical_loss(params: Dict[str, torch.Tensor]): + total_loss = to_model_device(torch.zeros((), requires_grad=True), model) + total_samples = to_model_device(torch.zeros(()), model) + + for x, y in iter(data_loader): + output = functional_call( + model, params, (to_model_device(x, model),), strict=True + ) + loss_value = loss(output, to_model_device(y, model)) + total_loss = total_loss + loss_value * x.size(0) + total_samples += x.size(0) + + return total_loss / total_samples + + return empirical_loss + + +def batch_loss_function( + model: torch.nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + x: torch.Tensor, + y: torch.Tensor, +) -> Callable[[Dict[str, torch.Tensor]], torch.Tensor]: + """ + Creates a function to compute the loss of a given model on a given batch of data. + + Args: + model (torch.nn.Module): The model for which the loss should be computed. + loss (Callable[[torch.Tensor, torch.Tensor], torch.Tensor]): The loss function to be used. + x (torch.Tensor): The input data for the batch. + y (torch.Tensor): The true labels for the batch. + + Returns: + Callable[[Dict[str, torch.Tensor]], torch.Tensor]: A function that computes the loss + of the model on the batch for given model parameters. + """ + + def batch_loss(params: Dict[str, torch.Tensor]): + outputs = functional_call( + model, params, (to_model_device(x, model),), strict=True + ) + return loss(outputs, y) + + return batch_loss + + +def get_hvp_function( + model: torch.nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + data_loader: DataLoader, + use_hessian_avg: bool = True, + reverse_only: bool = True, +) -> Callable[[Dict[str, torch.Tensor]], Dict[str, torch.Tensor]]: + """ + Returns a function that calculates the approximate Hessian-vector product for a given vector. If you want to + compute the exact hessian, i.e. pulling all data into memory and compute a full gradient computation, use + the function :func:`hvp`. + + :param model: A PyTorch module representing the model whose loss function's Hessian is to be computed. + :param loss: A callable that takes the model's output and target as input and returns the scalar loss. + :param data_loader: A DataLoader instance that provides batches of data for calculating the Hessian-vector product. + Each batch from the DataLoader is assumed to return a tuple where the first element + is the model's input and the second element is the target output. + :param use_hessian_avg: If True, it will use batch-wise Hessian computation. If False, the function averages + the batch gradients and perform backpropagation on the full (averaged) gradient, + which is more accurate than averaging the batch hessians, + but probably has a way higher memory usage. + :param reverse_only: Whether to use only reverse-mode autodiff + (True, default) or both forward- and reverse-mode autodiff (False) + :return: A function that takes a single argument, a vector, and returns the product of the Hessian of the + `loss` function with respect to the `model`'s parameters and the input vector. + + """ + params = dict(model.named_parameters()) + + def hvp_function(vec: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]: + v = align_structure(params, vec) + empirical_loss = empirical_loss_function(model, loss, data_loader) + return hvp(empirical_loss, params, v, reverse_only=reverse_only) + + def avg_hvp_function(vec: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]: + v = align_structure(params, vec) + batch_hessians: Iterable[Dict[str, torch.Tensor]] = map( + lambda x: x(v), batch_hvp_gen(model, loss, data_loader, reverse_only) + ) + + result_dict = { + key: to_model_device(torch.zeros_like(p), model) + for key, p in params.items() + } + num_batches = len(data_loader) + + for batch_dict in batch_hessians: + for key, value in batch_dict.items(): + result_dict[key] += value + + return {key: value / num_batches for key, value in result_dict.items()} + + return avg_hvp_function if use_hessian_avg else hvp_function diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 438ada7e7..2aa80d53f 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -5,22 +5,21 @@ influence of a training point on the model. """ import logging +from dataclasses import dataclass from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple import numpy as np import torch import torch.nn as nn +from numpy._typing import NDArray from torch import autograd from torch.autograd import Variable from torch.utils.data import DataLoader from ...utils import maybe_progress +from .functional import get_hvp_function from .twice_differentiable import TwiceDifferentiable -from .util import ( - LowRankProductRepresentation, - get_hvp_function, - lanzcos_low_rank_hessian_approx, flatten_tensors_to_vector, align_structure, -) +from .util import align_structure, flatten_tensors_to_vector __all__ = [ "TorchTwiceDifferentiable", @@ -431,6 +430,19 @@ def hessian( ) +@dataclass +class LowRankProductRepresentation: + """ + Representation of a low rank product of the form $H = V D V^T$, where D is a diagonal matrix and + V is orthogonal + :param eigen_vals: diagonal of D + :param projections: the matrix V + """ + + eigen_vals: torch.Tensor + projections: torch.Tensor + + def solve_arnoldi( model: TorchTwiceDifferentiable, training_data: DataLoader, @@ -483,7 +495,9 @@ def solve_arnoldi( if low_rank_representation is None: - raw_hvp = get_hvp_function(model.model, model.loss, training_data, use_hessian_avg=True) + raw_hvp = get_hvp_function( + model.model, model.loss, training_data, use_hessian_avg=True + ) params = dict(model.model.named_parameters()) def hessian_vector_product(x: torch.Tensor) -> torch.Tensor: @@ -510,3 +524,119 @@ def hessian_vector_product(x: torch.Tensor) -> torch.Tensor: @ (low_rank_representation.projections.t() @ b.t()) ) return result.t() + + +def lanzcos_low_rank_hessian_approx( + hessian_vp: Callable[[torch.Tensor], torch.Tensor], + matrix_shape: Tuple[int, int], + hessian_perturbation: float = 0.0, + rank_estimate: int = 10, + krylov_dimension: Optional[int] = None, + x0: Optional[torch.Tensor] = None, + tol: float = 1e-6, + max_iter: Optional[int] = None, + device: Optional[torch.device] = None, + eigen_computation_on_gpu: bool = False, +) -> LowRankProductRepresentation: + """ + Calculates a low-rank approximation of the Hessian matrix of the model's loss function using the implicitly + restarted Lanczos algorithm. + + + :param hessian_vp: A function that takes a vector and returns the product of the Hessian of the loss function + :param matrix_shape: The shape of the matrix, represented by hessian vector product. + :param hessian_perturbation: Optional regularization parameter added to the Hessian-vector product + for numerical stability. + :param rank_estimate: The number of eigenvalues and corresponding eigenvectors to compute. + Represents the desired rank of the Hessian approximation. + :param krylov_dimension: The number of Krylov vectors to use for the Lanczos method. + If not provided, it defaults to $min(model.num_parameters, max(2*rank_estimate + 1, 20))$. + :param x0: An optional initial vector to use in the Lanczos algorithm. + If not provided, a random initial vector is used. + :param tol: The stopping criteria for the Lanczos algorithm, which stops when the difference + in the approximated eigenvalue is less than `tol`. Defaults to 1e-6. + :param max_iter: The maximum number of iterations for the Lanczos method. If not provided, it defaults to + $10*model.num_parameters$ + :param device: The device to use for executing the hessian vector product. + :param eigen_computation_on_gpu: If True, tries to execute the eigen pair approximation on the provided + device via cupy implementation. + Make sure, that either your model is small enough or you use a + small rank_estimate to fit your device's memory. + If False, the eigen pair approximation is executed on the CPU by scipy wrapper to + ARPACK. + :return: A `LowRankProductRepresentation` instance that contains the top (up until rank_estimate) eigenvalues + and corresponding eigenvectors of the Hessian. + """ + + if eigen_computation_on_gpu: + try: + import cupy as cp + from cupyx.scipy.sparse.linalg import LinearOperator, eigsh + from torch.utils.dlpack import from_dlpack, to_dlpack + except ImportError as e: + raise ImportError( + f"Try to install missing dependencies or set eigen_computation_on_gpu to False: {e}" + ) + + if device is None: + raise ValueError( + "Without setting an explicit device, cupy is not supported" + ) + + def mv_cupy(x): + x = from_dlpack(x.toDlpack()) + y = hessian_vp(x) + hessian_perturbation * x + return cp.from_dlpack(to_dlpack(y)) + + eigen_vals, eigen_vecs = eigsh( + LinearOperator(matrix_shape, matvec=mv_cupy), + k=rank_estimate, + maxiter=max_iter, + tol=tol, + ncv=krylov_dimension, + return_eigenvectors=True, + ) + return LowRankProductRepresentation( + from_dlpack(eigen_vals.toDlpack()), from_dlpack(eigen_vecs.toDlpack()) + ) + + else: + from scipy.sparse.linalg import ArpackNoConvergence, LinearOperator, eigsh + + torch_default_dtype = torch.get_default_dtype() + + def mv_scipy(x: NDArray) -> NDArray: + x_torch = torch.as_tensor(x, device=device, dtype=torch_default_dtype) + y: NDArray = ( + (hessian_vp(x_torch) + hessian_perturbation * x_torch) + .detach() + .cpu() + .numpy() + ) + return y + + try: + eigen_vals, eigen_vecs = eigsh( + A=LinearOperator(matrix_shape, matvec=mv_scipy), + k=rank_estimate, + maxiter=max_iter, + tol=tol, + ncv=krylov_dimension, + return_eigenvectors=True, + v0=x0.cpu().numpy() if x0 is not None else None, + ) + except ArpackNoConvergence as e: + logger.warning( + f"ARPACK did not converge for parameters {max_iter=}, {tol=}, {krylov_dimension=}, " + f"{rank_estimate=}. \n Returning the best approximation found so far. Use those with care or " + f"modify parameters.\n Original error: {e}" + ) + return LowRankProductRepresentation( + torch.as_tensor(e.eigenvalues, dtype=torch_default_dtype), + torch.as_tensor(e.eigenvectors, dtype=torch_default_dtype), + ) + + return LowRankProductRepresentation( + torch.as_tensor(eigen_vals, dtype=torch_default_dtype), + torch.as_tensor(eigen_vecs, dtype=torch_default_dtype), + ) diff --git a/src/pydvl/influence/frameworks/util.py b/src/pydvl/influence/frameworks/util.py index 8e7273063..303163c25 100644 --- a/src/pydvl/influence/frameworks/util.py +++ b/src/pydvl/influence/frameworks/util.py @@ -1,14 +1,9 @@ -import logging import copy -from dataclasses import dataclass -from functools import partial -from typing import Callable, Generator, Iterable, Optional, Tuple, Union, Dict +import logging import math +from typing import Dict, Iterable, Tuple, Union import torch -from torch.func import vjp, grad, jvp, functional_call -from numpy.typing import NDArray -from torch.utils.data import DataLoader logger = logging.getLogger(__name__) @@ -44,7 +39,9 @@ def flatten_tensors_to_vector(tensors: Iterable[torch.Tensor]): return torch.cat([t.contiguous().view(-1) for t in tensors]) -def reshape_vector_to_tensors(input_vector: torch.Tensor, target_shapes: Iterable[Tuple[int, ...]]): +def reshape_vector_to_tensors( + input_vector: torch.Tensor, target_shapes: Iterable[Tuple[int, ...]] +): """ Reshape a 1D tensor into multiple tensors with specified shapes. @@ -72,320 +69,21 @@ def reshape_vector_to_tensors(input_vector: torch.Tensor, target_shapes: Iterabl total_elements = sum(math.prod(shape) for shape in target_shapes) if total_elements != input_vector.shape[0]: - raise ValueError(f"The total elements in shapes {total_elements} does not match the vector length {input_vector.shape[0]}") + raise ValueError( + f"The total elements in shapes {total_elements} does not match the vector length {input_vector.shape[0]}" + ) tensors = [] start = 0 for shape in target_shapes: size = math.prod(shape) # compute the total size of the tensor with this shape - tensors.append(input_vector[start:start+size].view(shape)) # slice the vector and reshape it + tensors.append( + input_vector[start : start + size].view(shape) + ) # slice the vector and reshape it start += size return tuple(tensors) -def hvp( - func: Callable[[Input_type], torch.Tensor], - params: Input_type, - vec: Input_type, - reverse_only: bool = True -) -> Input_type: - """ - Computes the Hessian-vector product (HVP) for a given function at given parameters. - This function can operate in two modes, either reverse-mode autodiff only or both - forward- and reverse-mode autodiff. - - - Args: - func (Callable[[Input_type], torch.Tensor]): The function for which the HVP is computed. - params (Input_type): The parameters at which the HVP is computed. - vec (Input_type): The vector with which the Hessian is multiplied. - reverse_only (bool, optional): Whether to use only reverse-mode autodiff - (True, default) or both forward- and reverse-mode autodiff (False). - - Returns: - Input_type: The HVP of the function at the given parameters with the given vector. - - Examples: - >>> def f(z): return torch.sum(z**2) - >>> u = torch.ones(10, requires_grad=True) - >>> v = torch.ones(10) - >>> hvp_vec = hvp(f, u, v) - >>> assert torch.allclose(hvp_vec, torch.full((10, ), 2.0)) - """ - - if reverse_only: - _, vjp_fn = vjp(grad(func), params) - output = vjp_fn(vec)[0] - else: - output = jvp(grad(func), (params, ), (vec,))[1] - - return output - - - -def batch_hvp_gen( - model: torch.nn.Module, - loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], - data_loader: DataLoader, - reverse_only: bool = True -) -> Generator[Callable[[torch.Tensor], torch.Tensor], None, None]: - """ - Generates a sequence of batch Hessian-vector product (HVP) computations for the provided model, loss function, - and data loader. - - The generator iterates over the data_loader, creating partial function calls for calculating HVPs. - - :param model: The PyTorch model for which the HVP is calculated. - :param loss: The loss function used to calculate the gradient and HVP. - :param data_loader: PyTorch DataLoader object containing the dataset for which the HVP is calculated. - :param reverse_only: - :yield: A partial function H(vec)=hvp(model, loss, inputs, targets, vec) that when called, - will compute the Hessian-vector product H(vec) for the given model, loss, inputs and targets. - """ - - for inputs, targets in iter(data_loader): - batch_loss = batch_loss_function(model, loss, inputs, targets) - yield partial(hvp, batch_loss, dict(model.named_parameters()), reverse_only=reverse_only) - - -def get_hvp_function( - model: torch.nn.Module, - loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], - data_loader: DataLoader, - use_hessian_avg: bool = True, - reverse_only: bool = True -) -> Callable[[Dict[str, torch.Tensor]], Dict[str, torch.Tensor]]: - """ - Returns a function that calculates the approximate Hessian-vector product for a given vector. If you want to - compute the exact hessian, i.e. pulling all data into memory and compute a full gradient computation, use - the function :func:`hvp`. - - :param model: A PyTorch module representing the model whose loss function's Hessian is to be computed. - :param loss: A callable that takes the model's output and target as input and returns the scalar loss. - :param data_loader: A DataLoader instance that provides batches of data for calculating the Hessian-vector product. - Each batch from the DataLoader is assumed to return a tuple where the first element - is the model's input and the second element is the target output. - :param use_hessian_avg: If True, it will use batch-wise Hessian computation. If False, the function averages - the batch gradients and perform backpropagation on the full (averaged) gradient, - which is more accurate than averaging the batch hessians, - but probably has a way higher memory usage. - :return: A function that takes a single argument, a vector, and returns the product of the Hessian of the - `loss` function with respect to the `model`'s parameters and the input vector. - - """ - params = dict(model.named_parameters()) - - def hvp_function(vec: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]: - v = align_structure(params, vec) - empirical_loss = empirical_loss_function(model, loss, data_loader) - return hvp(empirical_loss, params, v, reverse_only=reverse_only) - - def avg_hvp_function(vec: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]: - v = align_structure(params, vec) - batch_hessians: Iterable[Dict[str, torch.Tensor]] = map( - lambda x: x(v), batch_hvp_gen(model, loss, data_loader, reverse_only) - ) - - result_dict = {key: to_model_device(torch.zeros_like(p), model) for key, p in params.items()} - num_batches = len(data_loader) - - for batch_dict in batch_hessians: - for key, value in batch_dict.items(): - result_dict[key] += value - - return {key: value/num_batches for key, value in result_dict.items()} - - return avg_hvp_function if use_hessian_avg else hvp_function - - -@dataclass -class LowRankProductRepresentation: - """ - Representation of a low rank product of the form $H = V D V^T$, where D is a diagonal matrix and - V is orthogonal - :param eigen_vals: diagonal of D - :param projections: the matrix V - """ - - eigen_vals: torch.Tensor - projections: torch.Tensor - - -def lanzcos_low_rank_hessian_approx( - hessian_vp: Callable[[torch.Tensor], torch.Tensor], - matrix_shape: Tuple[int, int], - hessian_perturbation: float = 0.0, - rank_estimate: int = 10, - krylov_dimension: Optional[int] = None, - x0: Optional[torch.Tensor] = None, - tol: float = 1e-6, - max_iter: Optional[int] = None, - device: Optional[torch.device] = None, - eigen_computation_on_gpu: bool = False, -) -> LowRankProductRepresentation: - """ - Calculates a low-rank approximation of the Hessian matrix of the model's loss function using the implicitly - restarted Lanczos algorithm. - - - :param hessian_vp: A function that takes a vector and returns the product of the Hessian of the loss function - :param matrix_shape: The shape of the matrix, represented by hessian vector product. - :param hessian_perturbation: Optional regularization parameter added to the Hessian-vector product - for numerical stability. - :param rank_estimate: The number of eigenvalues and corresponding eigenvectors to compute. - Represents the desired rank of the Hessian approximation. - :param krylov_dimension: The number of Krylov vectors to use for the Lanczos method. - If not provided, it defaults to $min(model.num_parameters, max(2*rank_estimate + 1, 20))$. - :param x0: An optional initial vector to use in the Lanczos algorithm. - If not provided, a random initial vector is used. - :param tol: The stopping criteria for the Lanczos algorithm, which stops when the difference - in the approximated eigenvalue is less than `tol`. Defaults to 1e-6. - :param max_iter: The maximum number of iterations for the Lanczos method. If not provided, it defaults to - $10*model.num_parameters$ - :param device: The device to use for executing the hessian vector product. - :param eigen_computation_on_gpu: If True, tries to execute the eigen pair approximation on the provided - device via cupy implementation. - Make sure, that either your model is small enough or you use a - small rank_estimate to fit your device's memory. - If False, the eigen pair approximation is executed on the CPU by scipy wrapper to - ARPACK. - :return: A `LowRankProductRepresentation` instance that contains the top (up until rank_estimate) eigenvalues - and corresponding eigenvectors of the Hessian. - """ - - if eigen_computation_on_gpu: - try: - import cupy as cp - from cupyx.scipy.sparse.linalg import LinearOperator, eigsh - from torch.utils.dlpack import from_dlpack, to_dlpack - except ImportError as e: - raise ImportError( - f"Try to install missing dependencies or set eigen_computation_on_gpu to False: {e}" - ) - - if device is None: - raise ValueError( - "Without setting an explicit device, cupy is not supported" - ) - - def mv_cupy(x): - x = from_dlpack(x.toDlpack()) - y = hessian_vp(x) + hessian_perturbation * x - return cp.from_dlpack(to_dlpack(y)) - - eigen_vals, eigen_vecs = eigsh( - LinearOperator(matrix_shape, matvec=mv_cupy), - k=rank_estimate, - maxiter=max_iter, - tol=tol, - ncv=krylov_dimension, - return_eigenvectors=True, - ) - return LowRankProductRepresentation( - from_dlpack(eigen_vals.toDlpack()), from_dlpack(eigen_vecs.toDlpack()) - ) - - else: - from scipy.sparse.linalg import ArpackNoConvergence, LinearOperator, eigsh - torch_default_dtype = torch.get_default_dtype() - - def mv_scipy(x: NDArray) -> NDArray: - x_torch = torch.as_tensor(x, device=device, dtype=torch_default_dtype) - y: NDArray = ( - (hessian_vp(x_torch) + hessian_perturbation * x_torch).detach().cpu().numpy() - ) - return y - - try: - eigen_vals, eigen_vecs = eigsh( - A=LinearOperator(matrix_shape, matvec=mv_scipy), - k=rank_estimate, - maxiter=max_iter, - tol=tol, - ncv=krylov_dimension, - return_eigenvectors=True, - v0=x0.cpu().numpy() if x0 is not None else None, - ) - except ArpackNoConvergence as e: - logger.warning( - f"ARPACK did not converge for parameters {max_iter=}, {tol=}, {krylov_dimension=}, " - f"{rank_estimate=}. \n Returning the best approximation found so far. Use those with care or " - f"modify parameters.\n Original error: {e}" - ) - return LowRankProductRepresentation( - torch.as_tensor(e.eigenvalues, dtype=torch_default_dtype), - torch.as_tensor(e.eigenvectors, dtype=torch_default_dtype) - ) - - return LowRankProductRepresentation( - torch.as_tensor(eigen_vals, dtype=torch_default_dtype), - torch.as_tensor(eigen_vecs, dtype=torch_default_dtype) - ) - - -def empirical_loss_function(model: torch.nn.Module, - loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], - data_loader: DataLoader) -> Callable[[Dict[str, torch.Tensor]], torch.Tensor]: - """ - Creates a function to compute the empirical loss of a given model on a given dataset. - If we denote the model parameters with $\theta$, the resulting function approximates - - .. math:: - - f(\theta) = \frac{1}{N}\sum_{i=1}^N \operatorname{loss}(y_i, \operatorname{model}(\theta, x_i))) - - Args: - model (torch.nn.Module): The model for which the loss should be computed. - loss (Callable[[torch.Tensor, torch.Tensor], torch.Tensor]): The loss function to be used. - data_loader (torch.utils.data.DataLoader): The data loader for iterating over the dataset. - - Returns: - Callable[[torch.nn.parameter.Parameter], torch.Tensor]: A function that computes the empirical loss - of the model on the dataset for given model parameters. - - """ - def empirical_loss(params: Dict[str, torch.Tensor]): - total_loss = to_model_device(torch.zeros((), requires_grad=True), model) - total_samples = to_model_device(torch.zeros(()), model) - - for x, y in iter(data_loader): - output = functional_call(model, params, (to_model_device(x, model),), strict=True) - loss_value = loss(output, to_model_device(y, model)) - total_loss = total_loss + loss_value * x.size(0) - total_samples += x.size(0) - - return total_loss / total_samples - - return empirical_loss - - -def batch_loss_function(model: torch.nn.Module, - loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], - x: torch.Tensor, - y: torch.Tensor) -> Callable[[Dict[str, torch.Tensor]], torch.Tensor]: - """ - Creates a function to compute the loss of a given model on a given batch of data. - - Args: - model (torch.nn.Module): The model for which the loss should be computed. - loss (Callable[[torch.Tensor, torch.Tensor], torch.Tensor]): The loss function to be used. - x (torch.Tensor): The input data for the batch. - y (torch.Tensor): The true labels for the batch. - - Returns: - Callable[[Dict[str, torch.Tensor]], torch.Tensor]: A function that computes the loss - of the model on the batch for given model parameters. - """ - def batch_loss(params: Dict[str, torch.Tensor]): - outputs = functional_call(model, params, (to_model_device(x, model),), strict=True) - return loss(outputs, y) - - return batch_loss - - -Input_type = Union[torch.Tensor, Tuple[torch.Tensor], Dict[str, torch.Tensor]] - - def align_structure(source: Dict[str, torch.Tensor], target: Input_type): """ This function transforms `target` to have the same structure as `source`, i.e., @@ -408,19 +106,31 @@ def align_structure(source: Dict[str, torch.Tensor], target: Input_type): if isinstance(tangent, dict): if list(tangent.keys()) != list(source.keys()): raise ValueError("The keys in 'target' do not match the keys in 'source'.") - if list(map(lambda v: v.shape, tangent.values())) != list(map(lambda v: v.shape, source.values())): - raise ValueError("The shapes of the values in 'target' do not match the shapes of the values in 'source'.") + if list(map(lambda v: v.shape, tangent.values())) != list( + map(lambda v: v.shape, source.values()) + ): + raise ValueError( + "The shapes of the values in 'target' do not match the shapes of the values in 'source'." + ) elif isinstance(tangent, tuple) or isinstance(tangent, list): - if list(map(lambda v: v.shape, tangent)) != list(map(lambda v: v.shape, source.values())): - raise ValueError("'target' is a tuple/list but its elements' shapes do not match the shapes " - "of the values in 'source'.") + if list(map(lambda v: v.shape, tangent)) != list( + map(lambda v: v.shape, source.values()) + ): + raise ValueError( + "'target' is a tuple/list but its elements' shapes do not match the shapes " + "of the values in 'source'." + ) tangent = dict(zip(source.keys(), tangent)) elif isinstance(tangent, torch.Tensor): try: - tangent = reshape_vector_to_tensors(tangent, list(map(lambda p: p.shape, source.values()))) + tangent = reshape_vector_to_tensors( + tangent, list(map(lambda p: p.shape, source.values())) + ) tangent = dict(zip(source.keys(), tangent)) except Exception as e: - raise ValueError(f"'target' is a tensor but cannot be reshaped to match 'source'. Original error: {e}") + raise ValueError( + f"'target' is a tensor but cannot be reshaped to match 'source'. Original error: {e}" + ) else: raise ValueError(f"'target' is of type {type(tangent)} which is not supported.") diff --git a/tests/influence/test_util.py b/tests/influence/test_util.py index b86c4b7fa..8651341d6 100644 --- a/tests/influence/test_util.py +++ b/tests/influence/test_util.py @@ -5,15 +5,19 @@ torch = pytest.importorskip("torch") import torch.nn -from torch.nn.functional import mse_loss from numpy.typing import NDArray +from torch.nn.functional import mse_loss from torch.utils.data import DataLoader, TensorDataset -from pydvl.influence.frameworks.util import ( +from pydvl.influence.frameworks.functional import ( + batch_loss_function, get_hvp_function, hvp, - lanzcos_low_rank_hessian_approx, batch_loss_function, align_structure, flatten_tensors_to_vector, ) +from pydvl.influence.frameworks.torch_differentiable import ( + lanzcos_low_rank_hessian_approx, +) +from pydvl.influence.frameworks.util import align_structure, flatten_tensors_to_vector from tests.influence.conftest import linear_hessian_analytical, linear_model @@ -79,9 +83,9 @@ def linear_torch_model_from_numpy(A: NDArray, b: NDArray) -> torch.nn.Module: """ output_dimension, input_dimension = tuple(A.shape) model = torch.nn.Linear(input_dimension, output_dimension) - #model.eval() - #model.weight.data = torch.as_tensor(A) - #model.bias.data = torch.as_tensor(b) + model.eval() + model.weight.data = torch.as_tensor(A, dtype=torch.get_default_dtype()) + model.bias.data = torch.as_tensor(b, dtype=torch.get_default_dtype()) return model @@ -92,7 +96,11 @@ def model_data(request): x = torch.rand(train_size, dimension[-1]) y = torch.rand(train_size, dimension[0]) torch_model = linear_torch_model_from_numpy(A, b) - vec = {name: torch.rand(*p.shape) for name, p in torch_model.named_parameters() if p.requires_grad} + vec = { + name: torch.rand(*p.shape) + for name, p in torch_model.named_parameters() + if p.requires_grad + } H_analytical = linear_hessian_analytical((A, b), x.numpy()) H_analytical = torch.as_tensor(H_analytical) return torch_model, x, y, vec, H_analytical.to(torch.float32) From 6f7787bd94bba57d7909123c2aae164fa925384b Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Mon, 24 Jul 2023 15:19:11 +0200 Subject: [PATCH 178/436] addressing MR comments and update changelog --- CHANGELOG.md | 3 +++ .../frameworks/torch_differentiable.py | 4 +--- .../frameworks/twice_differentiable.py | 20 ++++++++++++++++--- src/pydvl/influence/inversion.py | 2 +- 4 files changed, 22 insertions(+), 7 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index fb6bfaf3a..b5ebe4246 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,9 @@ ## Unreleased +- Optimises memory usage in IF calculation and returns infor about hessian + inversion to compute_influence_factors + [PR #375](https://github.com/appliedAI-Initiative/pyDVL/pull/375) - Fix adding valuation results with overlapping indices and different lengths [PR #370](https://github.com/appliedAI-Initiative/pyDVL/pull/370) - Fixed bugs in conjugate gradient and `linear_solve` diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 196f2e0a1..7dbeda79c 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -32,8 +32,6 @@ ] logger = logging.getLogger(__name__) -TORCH_DTYPES = {"float32": torch.float32, "float64": torch.float64} - def flatten_all(grad: torch.Tensor) -> torch.Tensor: """ @@ -288,7 +286,7 @@ def zero_tensor( ) -> torch.Tensor: """Returns a tensor of shape :attr:`shape` filled with zeros.""" if isinstance(dtype, np.dtype): - dtype = TORCH_DTYPES[str(dtype)] + dtype = getattr(torch, dtype.name) return torch.zeros(shape, dtype=dtype, **kwargs) diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index c0a42f9b7..a28bc1ebc 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -1,11 +1,25 @@ from abc import ABC -from collections import namedtuple -from typing import Callable, Generic, List, Sequence, Tuple, TypeVar +from typing import ( + Any, + Callable, + Dict, + Generic, + List, + NamedTuple, + Sequence, + Tuple, + TypeVar, + Union, +) TensorType = TypeVar("TensorType", bound=Sequence) ModelType = TypeVar("ModelType") DeviceType = TypeVar("DeviceType") -iHVPResult = namedtuple("iHVPResult", ["x", "info"]) + + +class iHVPResult(NamedTuple): + x: TensorType + info: Dict[str, Union[Any, TensorType]] class TwiceDifferentiable(ABC, Generic[TensorType, ModelType, DeviceType]): diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 3c5c5877c..936e40e46 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -57,7 +57,7 @@ def solve_hvp( :param hessian_perturbation: regularization of the hessian :param progress: If True, display progress bars. - :return: An array that solves the inverse problem, + :return: An object that containes an array that solves the inverse problem, i.e. it returns $x$ such that $Ax = b$, and a dictionary containing information about the inversion process. """ From 034a5f89d82d25bad0116038293e5d48ea9141c4 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Mon, 24 Jul 2023 15:45:19 +0200 Subject: [PATCH 179/436] change damn type --- src/pydvl/influence/frameworks/twice_differentiable.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index a28bc1ebc..f6804d79a 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -19,7 +19,7 @@ class iHVPResult(NamedTuple): x: TensorType - info: Dict[str, Union[Any, TensorType]] + info: Dict[str, Any] class TwiceDifferentiable(ABC, Generic[TensorType, ModelType, DeviceType]): From c203ea96eb133d38b4c04a47ed6038aced9fe1aa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Mon, 24 Jul 2023 16:11:42 +0200 Subject: [PATCH 180/436] Fix a testing issue, due to a different exception type being raised on Mac OS --- tests/utils/test_caching.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/utils/test_caching.py b/tests/utils/test_caching.py index 17230ca83..ca6f1732f 100644 --- a/tests/utils/test_caching.py +++ b/tests/utils/test_caching.py @@ -14,7 +14,7 @@ def test_failed_connection(): from pydvl.utils import MemcachedClientConfig client_config = MemcachedClientConfig(server=("localhost", 0), connect_timeout=0.1) - with pytest.raises(ConnectionRefusedError): + with pytest.raises((ConnectionRefusedError, OSError)): memcached(client_config)(lambda x: x) From 3cac3cec3e2f809731943b684219ec1e1a19d7cd Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Mon, 24 Jul 2023 17:30:25 +0200 Subject: [PATCH 181/436] use string as info key in batch cg --- src/pydvl/influence/frameworks/torch_differentiable.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 7dbeda79c..6847d999a 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -124,7 +124,7 @@ def solve_batch_cg( reg_hvp, bi, x0=x0, rtol=rtol, atol=atol, maxiter=maxiter ) batch_cg[idx] = batch_result.x - info[idx] = batch_result.info + info[f"batch_{idx}"] = batch_result.info return iHVPResult(x=batch_cg, info=info) From 668163d28b4339a165406da259cb283df0e7483b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Mon, 24 Jul 2023 17:46:17 +0200 Subject: [PATCH 182/436] Remove upper bound from numpy dependency again --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 5e3e53a00..e6c31a00b 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,5 @@ pyDeprecate>=0.3.2 -numpy>=1.20,<1.25 +numpy>=1.20 pandas>=1.3 scikit-learn scipy>=1.7.0 From 9a94c773320b61de329fb574a48b45a4172ddab2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Mon, 24 Jul 2023 17:46:54 +0200 Subject: [PATCH 183/436] Fix type-check and linting issues --- src/pydvl/influence/frameworks/functional.py | 17 +++-- src/pydvl/influence/frameworks/util.py | 67 +++++++++++++------- 2 files changed, 52 insertions(+), 32 deletions(-) diff --git a/src/pydvl/influence/frameworks/functional.py b/src/pydvl/influence/frameworks/functional.py index faa5aa71b..b8eae6864 100644 --- a/src/pydvl/influence/frameworks/functional.py +++ b/src/pydvl/influence/frameworks/functional.py @@ -5,15 +5,15 @@ from torch.func import functional_call, grad, jvp, vjp from torch.utils.data import DataLoader -from .util import Input_type, align_structure, to_model_device +from .util import TensorContainerType, align_structure, to_model_device def hvp( - func: Callable[[Input_type], torch.Tensor], - params: Input_type, - vec: Input_type, + func: Callable[[TensorContainerType], TensorContainerType], + params: TensorContainerType, + vec: TensorContainerType, reverse_only: bool = True, -) -> Input_type: +) -> TensorContainerType: """ Computes the Hessian-vector product (HVP) for a given function at given parameters. This function can operate in two modes, either reverse-mode autodiff only or both @@ -37,6 +37,7 @@ def hvp( >>> hvp_vec = hvp(f, u, v) >>> assert torch.allclose(hvp_vec, torch.full((10, ), 2.0)) """ + output: TensorContainerType if reverse_only: _, vjp_fn = vjp(grad(func), params) @@ -71,16 +72,14 @@ def batch_hvp_gen( for inputs, targets in iter(data_loader): batch_loss = batch_loss_function(model, loss, inputs, targets) - yield partial( - hvp, batch_loss, dict(model.named_parameters()), reverse_only=reverse_only - ) + yield partial(hvp, batch_loss, dict(model.named_parameters()), reverse_only=reverse_only) # type: ignore def empirical_loss_function( model: torch.nn.Module, loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], data_loader: DataLoader, -) -> Callable[[Dict[str, torch.Tensor]], torch.Tensor]: +) -> Callable[[Dict[str, torch.Tensor]], Dict[str, torch.Tensor]]: """ Creates a function to compute the empirical loss of a given model on a given dataset. If we denote the model parameters with $\theta$, the resulting function approximates diff --git a/src/pydvl/influence/frameworks/util.py b/src/pydvl/influence/frameworks/util.py index 303163c25..9bf6f135d 100644 --- a/src/pydvl/influence/frameworks/util.py +++ b/src/pydvl/influence/frameworks/util.py @@ -1,14 +1,12 @@ import copy import logging import math -from typing import Dict, Iterable, Tuple, Union +from typing import Dict, Iterable, Tuple, TypeVar, Union import torch logger = logging.getLogger(__name__) -Input_type = Union[torch.Tensor, Tuple[torch.Tensor], Dict[str, torch.Tensor]] - def to_model_device(x: torch.Tensor, model: torch.nn.Module) -> torch.Tensor: """ @@ -22,7 +20,7 @@ def to_model_device(x: torch.Tensor, model: torch.nn.Module) -> torch.Tensor: return x -def flatten_tensors_to_vector(tensors: Iterable[torch.Tensor]): +def flatten_tensors_to_vector(tensors: Iterable[torch.Tensor]) -> torch.Tensor: """ Flatten multiple tensors into a single 1D tensor (vector). @@ -41,7 +39,7 @@ def flatten_tensors_to_vector(tensors: Iterable[torch.Tensor]): def reshape_vector_to_tensors( input_vector: torch.Tensor, target_shapes: Iterable[Tuple[int, ...]] -): +) -> Tuple[torch.Tensor, ...]: """ Reshape a 1D tensor into multiple tensors with specified shapes. @@ -84,7 +82,18 @@ def reshape_vector_to_tensors( return tuple(tensors) -def align_structure(source: Dict[str, torch.Tensor], target: Input_type): +TensorContainerType = TypeVar( + "TensorContainerType", + torch.Tensor, + Tuple[torch.Tensor, ...], + Dict[str, torch.Tensor], +) + + +def align_structure( + source: Dict[str, torch.Tensor], + target: TensorContainerType, +) -> Dict[str, torch.Tensor]: """ This function transforms `target` to have the same structure as `source`, i.e., it should be a dictionary with the same keys as `source` and each corresponding @@ -101,37 +110,49 @@ def align_structure(source: Dict[str, torch.Tensor], target: Input_type): ValueError: If `target` cannot be harmonized to match `source`. """ - tangent = copy.copy(target) + tangent_dict: Dict[str, torch.Tensor] + + if isinstance(target, dict): - if isinstance(tangent, dict): - if list(tangent.keys()) != list(source.keys()): + if list(target.keys()) != list(source.keys()): raise ValueError("The keys in 'target' do not match the keys in 'source'.") - if list(map(lambda v: v.shape, tangent.values())) != list( - map(lambda v: v.shape, source.values()) - ): + + if [v.shape for v in target.values()] != [v.shape for v in source.values()]: + raise ValueError( "The shapes of the values in 'target' do not match the shapes of the values in 'source'." ) - elif isinstance(tangent, tuple) or isinstance(tangent, list): - if list(map(lambda v: v.shape, tangent)) != list( - map(lambda v: v.shape, source.values()) - ): + + tangent_dict = target + + elif isinstance(target, tuple) or isinstance(target, list): + + if [v.shape for v in target] != [v.shape for v in source.values()]: + raise ValueError( "'target' is a tuple/list but its elements' shapes do not match the shapes " "of the values in 'source'." ) - tangent = dict(zip(source.keys(), tangent)) - elif isinstance(tangent, torch.Tensor): + + tangent_dict = dict(zip(source.keys(), target)) + + elif isinstance(target, torch.Tensor): + try: - tangent = reshape_vector_to_tensors( - tangent, list(map(lambda p: p.shape, source.values())) + tangent_dict = dict( + zip( + source.keys(), + reshape_vector_to_tensors( + target, [p.shape for p in source.values()] + ), + ) ) - tangent = dict(zip(source.keys(), tangent)) except Exception as e: raise ValueError( f"'target' is a tensor but cannot be reshaped to match 'source'. Original error: {e}" ) + else: - raise ValueError(f"'target' is of type {type(tangent)} which is not supported.") + raise ValueError(f"'target' is of type {type(target)} which is not supported.") - return tangent + return tangent_dict From 577e024d86f240592ff6e21cc6e07449ab7a1e06 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Mon, 24 Jul 2023 18:11:45 +0200 Subject: [PATCH 184/436] fix generic in iHVPResult --- src/pydvl/influence/frameworks/__init__.py | 5 +++-- src/pydvl/influence/frameworks/twice_differentiable.py | 3 +-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index 0ed2da702..e4bc95689 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -6,7 +6,7 @@ from .twice_differentiable import TwiceDifferentiable, iHVPResult -__all__ = ["TwiceDifferentiable", "iHVPResult"] +__all__ = ["TwiceDifferentiable"] logger = logging.getLogger("frameworks") try: @@ -32,12 +32,13 @@ TensorType = torch.Tensor DataLoaderType = torch.utils.data.DataLoader ModelType = torch.nn.Module + iHVPResult = iHVPResult[torch.Tensor] __all__.extend( [ "TensorType", "ModelType", - "solve_linear", + "iHVPResult" "solve_linear", "solve_batch_cg", "solve_lissa", "as_tensor", diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index f6804d79a..918f2941c 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -9,7 +9,6 @@ Sequence, Tuple, TypeVar, - Union, ) TensorType = TypeVar("TensorType", bound=Sequence) @@ -17,7 +16,7 @@ DeviceType = TypeVar("DeviceType") -class iHVPResult(NamedTuple): +class iHVPResult(NamedTuple, Generic[TensorType]): x: TensorType info: Dict[str, Any] From fd74797322d3a9bb5a382f2e6d8a3ba52ef9d437 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Mon, 24 Jul 2023 18:24:55 +0200 Subject: [PATCH 185/436] small fix --- src/pydvl/influence/frameworks/__init__.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index e4bc95689..fdf2612f5 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -32,13 +32,13 @@ TensorType = torch.Tensor DataLoaderType = torch.utils.data.DataLoader ModelType = torch.nn.Module - iHVPResult = iHVPResult[torch.Tensor] __all__.extend( [ "TensorType", "ModelType", - "iHVPResult" "solve_linear", + "iHVPResult", + "solve_linear", "solve_batch_cg", "solve_lissa", "as_tensor", From 25027d9e23fe449165972e55a574a0d6e435e14a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Tue, 25 Jul 2023 11:01:00 +0200 Subject: [PATCH 186/436] Add minimal versions to extras_requires in setup.py, extend install instructions --- docs/20-install.rst | 11 ++++++++++- setup.py | 2 +- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/docs/20-install.rst b/docs/20-install.rst index e803487aa..22fca7560 100644 --- a/docs/20-install.rst +++ b/docs/20-install.rst @@ -16,9 +16,18 @@ To use all features of influence functions use instead: pip install pyDVL[influence] -This includes a dependency on `PyTorch `_ and thus is left +This includes a dependency on `PyTorch `_ (Version 2.0 and above) and thus is left out by default. +In the case you use Cuda v11.2 ~ 11.8, you can enable eigen computations (for low-rank approximations) +with `CuPy `_ on GPU: + +.. code-block:: shell + + pip install pyDVL[cupy] + +If you use a different version of Cuda, please install CuPy `manually `_. + In order to check the installation you can use: .. code-block:: shell diff --git a/setup.py b/setup.py index 2a8bcd635..6c5e9276e 100644 --- a/setup.py +++ b/setup.py @@ -21,7 +21,7 @@ ], setup_requires=["wheel"], tests_require=["pytest"], - extras_require={"influence": ["torch"]}, + extras_require={"influence": ["torch>=2.0.0"], "cupy": ["cupy-cuda11x>=12.1.0"]}, author="appliedAI Institute gGmbH", long_description=long_description, long_description_content_type="text/markdown", From 0d993c2f816301da58046be3b0f5847a780866e6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Tue, 25 Jul 2023 11:06:18 +0200 Subject: [PATCH 187/436] Add an __all__ variable to pydvl.indfluence.frameworks.functional --- src/pydvl/influence/frameworks/functional.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/pydvl/influence/frameworks/functional.py b/src/pydvl/influence/frameworks/functional.py index b8eae6864..5a4dcd931 100644 --- a/src/pydvl/influence/frameworks/functional.py +++ b/src/pydvl/influence/frameworks/functional.py @@ -8,6 +8,11 @@ from .util import TensorContainerType, align_structure, to_model_device +__all__ = [ + "get_hvp_function", +] + + def hvp( func: Callable[[TensorContainerType], TensorContainerType], params: TensorContainerType, From 671b69010dcc06d602fe7a826940637242667570 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Tue, 25 Jul 2023 11:17:54 +0200 Subject: [PATCH 188/436] Change docstring format --- src/pydvl/influence/frameworks/functional.py | 70 +++++++++----------- 1 file changed, 32 insertions(+), 38 deletions(-) diff --git a/src/pydvl/influence/frameworks/functional.py b/src/pydvl/influence/frameworks/functional.py index 5a4dcd931..1c6648851 100644 --- a/src/pydvl/influence/frameworks/functional.py +++ b/src/pydvl/influence/frameworks/functional.py @@ -7,7 +7,6 @@ from .util import TensorContainerType, align_structure, to_model_device - __all__ = [ "get_hvp_function", ] @@ -20,27 +19,26 @@ def hvp( reverse_only: bool = True, ) -> TensorContainerType: """ - Computes the Hessian-vector product (HVP) for a given function at given parameters. - This function can operate in two modes, either reverse-mode autodiff only or both - forward- and reverse-mode autodiff. - - - Args: - func (Callable[[Input_type], torch.Tensor]): The function for which the HVP is computed. - params (Input_type): The parameters at which the HVP is computed. - vec (Input_type): The vector with which the Hessian is multiplied. - reverse_only (bool, optional): Whether to use only reverse-mode autodiff - (True, default) or both forward- and reverse-mode autodiff (False). - - Returns: - Input_type: The HVP of the function at the given parameters with the given vector. - - Examples: - >>> def f(z): return torch.sum(z**2) - >>> u = torch.ones(10, requires_grad=True) - >>> v = torch.ones(10) - >>> hvp_vec = hvp(f, u, v) - >>> assert torch.allclose(hvp_vec, torch.full((10, ), 2.0)) + Computes the Hessian-vector product (HVP) for a given function at given parameters. + This function can operate in two modes, either reverse-mode autodiff only or both + forward- and reverse-mode autodiff. + + + :param func: The function for which the HVP is computed. + :param params: The parameters at which the HVP is computed. + :param vec: The vector with which the Hessian is multiplied. + :param reverse_only: Whether to use only reverse-mode autodiff + (True, default) or both forward- and reverse-mode autodiff (False). + + :return: Input_type: The HVP of the function at the given parameters with the given vector. + + :Example: + + >>> def f(z): return torch.sum(z**2) + >>> u = torch.ones(10, requires_grad=True) + >>> v = torch.ones(10) + >>> hvp_vec = hvp(f, u, v) + >>> assert torch.allclose(hvp_vec, torch.full((10, ), 2.0)) """ output: TensorContainerType @@ -93,14 +91,12 @@ def empirical_loss_function( f(\theta) = \frac{1}{N}\sum_{i=1}^N \operatorname{loss}(y_i, \operatorname{model}(\theta, x_i))) - Args: - model (torch.nn.Module): The model for which the loss should be computed. - loss (Callable[[torch.Tensor, torch.Tensor], torch.Tensor]): The loss function to be used. - data_loader (torch.utils.data.DataLoader): The data loader for iterating over the dataset. + :param model: The model for which the loss should be computed. + :param loss: The loss function to be used. + :param data_loader: The data loader for iterating over the dataset. - Returns: - Callable[[torch.nn.parameter.Parameter], torch.Tensor]: A function that computes the empirical loss - of the model on the dataset for given model parameters. + :return: A function that computes the empirical loss + of the model on the dataset for given model parameters. """ @@ -128,17 +124,15 @@ def batch_loss_function( y: torch.Tensor, ) -> Callable[[Dict[str, torch.Tensor]], torch.Tensor]: """ - Creates a function to compute the loss of a given model on a given batch of data. + Creates a function to compute the loss of a given model on a given batch of data. - Args: - model (torch.nn.Module): The model for which the loss should be computed. - loss (Callable[[torch.Tensor, torch.Tensor], torch.Tensor]): The loss function to be used. - x (torch.Tensor): The input data for the batch. - y (torch.Tensor): The true labels for the batch. + :param model: The model for which the loss should be computed. + :param loss: The loss function to be used. + :param x: The input data for the batch. + :param y: The true labels for the batch. - Returns: - Callable[[Dict[str, torch.Tensor]], torch.Tensor]: A function that computes the loss - of the model on the batch for given model parameters. + :return: A function that computes the loss + of the model on the batch for given model parameters. """ def batch_loss(params: Dict[str, torch.Tensor]): From 04cfa407d052c7c87d693a6c1388fc8ea925900e Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 25 Jul 2023 12:00:34 +0200 Subject: [PATCH 189/436] Bump pytest-docker to 2.0.0 --- requirements-dev.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements-dev.txt b/requirements-dev.txt index 68667f451..676f1cc28 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -8,7 +8,7 @@ bump2version pre-commit==3.1.1 pytest==7.2.2 pytest-cov -pytest-docker==0.12.0 +pytest-docker==2.0.0 pytest-mock pytest-timeout ray[default] >= 0.8 From d1ec15b2ad6e5cc83dd6f0e80d18f27858f14d91 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 25 Jul 2023 12:00:57 +0200 Subject: [PATCH 190/436] Remove docker_compose_command fixture It is no longer needed --- tests/conftest.py | 5 ----- 1 file changed, 5 deletions(-) diff --git a/tests/conftest.py b/tests/conftest.py index 3d332c1ec..edb497555 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -76,11 +76,6 @@ def pytorch_seed(seed): pass -@pytest.fixture(scope="session") -def docker_compose_command(): - return "docker compose" - - @pytest.fixture(scope="session") def do_not_start_memcache(request): return request.config.getoption("--do-not-start-memcache") From 73bfa405e99bf455ed7fab4ca4d88304e420c717 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 25 Jul 2023 12:32:16 +0200 Subject: [PATCH 191/436] Pin pytest-docker to 2.0.0 inside tox file --- tox.ini | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tox.ini b/tox.ini index 46e7c094e..fada915c9 100644 --- a/tox.ini +++ b/tox.ini @@ -9,7 +9,7 @@ deps = pytest-lazy-fixture pytest-timeout pytest-mock - pytest-docker==0.12.0 + pytest-docker==2.0.0 -r requirements.txt setenv = COVERAGE_FILE = {env:COVERAGE_FILE:{toxinidir}/.coverage.{envname}} From 23885c9f3be1332ca15c391bd1de23ae3be80f92 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 25 Jul 2023 12:58:10 +0200 Subject: [PATCH 192/436] Add missing docker_compose_command argument to get_docker_services --- tests/conftest.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/conftest.py b/tests/conftest.py index edb497555..97b44ec92 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -83,6 +83,7 @@ def do_not_start_memcache(request): @pytest.fixture(scope="session") def docker_services( + docker_compose_command, docker_compose_file, docker_compose_project_name, docker_setup, @@ -97,6 +98,7 @@ def docker_services( yield else: with get_docker_services( + docker_compose_command, docker_compose_file, docker_compose_project_name, docker_setup, From bbe209c896422eef2c62d8abe4b647ef1d1fca40 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 25 Jul 2023 15:51:15 +0200 Subject: [PATCH 193/436] Update changelog --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 19aa53906..507684eb9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,6 +13,8 @@ - **Breaking Changes** Add new joblib backend and set it as default instead of the ray backend. Simplify the MapReduceJob class. [PR #355](https://github.com/appliedAI-Initiative/pyDVL/pull/355) +- **Bug fix** Fix installation of dev requirements for Python3.10 + [PR #382](https://github.com/appliedAI-Initiative/pyDVL/pull/382) ## 0.6.1 - 🏗 Bug fixes and small improvement From 0cd12892e95df3311d2c66de062dbc8dcc329f40 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 25 Jul 2023 17:19:18 +0200 Subject: [PATCH 194/436] change NamedTuple to dataclass --- .../influence/frameworks/twice_differentiable.py | 4 +++- tests/influence/test_torch_differentiable.py | 12 +++++------- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index 918f2941c..c44a86abd 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -1,4 +1,5 @@ from abc import ABC +from dataclasses import dataclass from typing import ( Any, Callable, @@ -16,7 +17,8 @@ DeviceType = TypeVar("DeviceType") -class iHVPResult(NamedTuple, Generic[TensorType]): +@dataclass +class iHVPResult(Generic[TensorType]): x: TensorType info: Dict[str, Any] diff --git a/tests/influence/test_torch_differentiable.py b/tests/influence/test_torch_differentiable.py index ae0ab52de..875671bbf 100644 --- a/tests/influence/test_torch_differentiable.py +++ b/tests/influence/test_torch_differentiable.py @@ -177,11 +177,9 @@ def test_inversion_methods( train_data_loader = DataLoader(list(zip(train_x, train_y)), batch_size=128) b = torch.rand(size=(10, mvp_model.num_params), dtype=torch.float64) - linear_inverse, _ = solve_linear(mvp_model, train_data_loader, b) - linear_cg, _ = solve_batch_cg(mvp_model, train_data_loader, b) - linear_lissa, _ = solve_lissa( - mvp_model, train_data_loader, b, maxiter=5000, scale=5 - ) + linear_inverse = solve_linear(mvp_model, train_data_loader, b) + linear_cg = solve_batch_cg(mvp_model, train_data_loader, b) + linear_lissa = solve_lissa(mvp_model, train_data_loader, b, maxiter=5000, scale=5) - assert np.allclose(linear_inverse, linear_cg, rtol=1e-1) - assert np.allclose(linear_inverse, linear_lissa, rtol=1e-1) + assert np.allclose(linear_inverse.x, linear_cg.x, rtol=1e-1) + assert np.allclose(linear_inverse.x, linear_lissa.x, rtol=1e-1) From 7f4940f9841eb34e45d123fdaa37685b4839d3dd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Tue, 25 Jul 2023 17:51:44 +0200 Subject: [PATCH 195/436] Refactor and simplify low rank approximation function: * remove parameter x0 * simplify if/else condition --- .../frameworks/torch_differentiable.py | 93 +++++++++---------- 1 file changed, 43 insertions(+), 50 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 2aa80d53f..daee0529c 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -6,12 +6,13 @@ """ import logging from dataclasses import dataclass +from functools import partial from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple import numpy as np import torch import torch.nn as nn -from numpy._typing import NDArray +from numpy.typing import NDArray from torch import autograd from torch.autograd import Variable from torch.utils.data import DataLoader @@ -31,7 +32,9 @@ "cat", "einsum", "mvp", + "lanzcos_low_rank_hessian_approx", ] + logger = logging.getLogger(__name__) @@ -452,7 +455,6 @@ def solve_arnoldi( rank_estimate: int = 10, krylov_dimension: Optional[int] = None, low_rank_representation: Optional[LowRankProductRepresentation] = None, - x0: Optional[torch.Tensor] = None, tol: float = 1e-6, max_iter: Optional[int] = None, eigen_computation_on_gpu: bool = False, @@ -477,8 +479,6 @@ def solve_arnoldi( low-rank representation of the Hessian. If not provided, a new low-rank representation will be computed, using provided parameters. - :param x0: An optional initial vector to use in the Lanczos algorithm. - If `low_rank_representation` is provided, this parameter is ignored. :param tol: The stopping criteria for the Lanczos algorithm. If `low_rank_representation` is provided, this parameter is ignored. :param max_iter: The maximum number of iterations for the Lanczos method. @@ -509,7 +509,6 @@ def hessian_vector_product(x: torch.Tensor) -> torch.Tensor: matrix_shape=(model.num_params, model.num_params), hessian_perturbation=hessian_perturbation, rank_estimate=rank_estimate, - x0=x0, krylov_dimension=krylov_dimension, tol=tol, max_iter=max_iter, @@ -532,11 +531,11 @@ def lanzcos_low_rank_hessian_approx( hessian_perturbation: float = 0.0, rank_estimate: int = 10, krylov_dimension: Optional[int] = None, - x0: Optional[torch.Tensor] = None, tol: float = 1e-6, max_iter: Optional[int] = None, device: Optional[torch.device] = None, eigen_computation_on_gpu: bool = False, + torch_dtype: torch.dtype = None, ) -> LowRankProductRepresentation: """ Calculates a low-rank approximation of the Hessian matrix of the model's loss function using the implicitly @@ -551,8 +550,6 @@ def lanzcos_low_rank_hessian_approx( Represents the desired rank of the Hessian approximation. :param krylov_dimension: The number of Krylov vectors to use for the Lanczos method. If not provided, it defaults to $min(model.num_parameters, max(2*rank_estimate + 1, 20))$. - :param x0: An optional initial vector to use in the Lanczos algorithm. - If not provided, a random initial vector is used. :param tol: The stopping criteria for the Lanczos algorithm, which stops when the difference in the approximated eigenvalue is less than `tol`. Defaults to 1e-6. :param max_iter: The maximum number of iterations for the Lanczos method. If not provided, it defaults to @@ -564,10 +561,13 @@ def lanzcos_low_rank_hessian_approx( small rank_estimate to fit your device's memory. If False, the eigen pair approximation is executed on the CPU by scipy wrapper to ARPACK. + :param torch_dtype: if not provided, current torch default dtype is used for conversion to torch :return: A `LowRankProductRepresentation` instance that contains the top (up until rank_estimate) eigenvalues and corresponding eigenvectors of the Hessian. """ + torch_dtype = torch.get_default_dtype() if torch_dtype is None else torch_dtype + if eigen_computation_on_gpu: try: import cupy as cp @@ -583,30 +583,19 @@ def lanzcos_low_rank_hessian_approx( "Without setting an explicit device, cupy is not supported" ) - def mv_cupy(x): - x = from_dlpack(x.toDlpack()) + def to_torch_conversion_function(x): + return from_dlpack(x.toDlpack()).to(torch_dtype) + + def mv(x): + x = to_torch_conversion_function(x) y = hessian_vp(x) + hessian_perturbation * x return cp.from_dlpack(to_dlpack(y)) - eigen_vals, eigen_vecs = eigsh( - LinearOperator(matrix_shape, matvec=mv_cupy), - k=rank_estimate, - maxiter=max_iter, - tol=tol, - ncv=krylov_dimension, - return_eigenvectors=True, - ) - return LowRankProductRepresentation( - from_dlpack(eigen_vals.toDlpack()), from_dlpack(eigen_vecs.toDlpack()) - ) - else: - from scipy.sparse.linalg import ArpackNoConvergence, LinearOperator, eigsh - - torch_default_dtype = torch.get_default_dtype() + from scipy.sparse.linalg import LinearOperator, eigsh - def mv_scipy(x: NDArray) -> NDArray: - x_torch = torch.as_tensor(x, device=device, dtype=torch_default_dtype) + def mv(x): + x_torch = torch.as_tensor(x, device=device, dtype=torch_dtype) y: NDArray = ( (hessian_vp(x_torch) + hessian_perturbation * x_torch) .detach() @@ -615,28 +604,32 @@ def mv_scipy(x: NDArray) -> NDArray: ) return y - try: - eigen_vals, eigen_vecs = eigsh( - A=LinearOperator(matrix_shape, matvec=mv_scipy), - k=rank_estimate, - maxiter=max_iter, - tol=tol, - ncv=krylov_dimension, - return_eigenvectors=True, - v0=x0.cpu().numpy() if x0 is not None else None, - ) - except ArpackNoConvergence as e: - logger.warning( - f"ARPACK did not converge for parameters {max_iter=}, {tol=}, {krylov_dimension=}, " - f"{rank_estimate=}. \n Returning the best approximation found so far. Use those with care or " - f"modify parameters.\n Original error: {e}" - ) - return LowRankProductRepresentation( - torch.as_tensor(e.eigenvalues, dtype=torch_default_dtype), - torch.as_tensor(e.eigenvectors, dtype=torch_default_dtype), - ) + to_torch_conversion_function = partial(torch.as_tensor, dtype=torch_dtype) + + from scipy.sparse.linalg import ArpackNoConvergence + + try: + + eigen_vals, eigen_vecs = eigsh( + LinearOperator(matrix_shape, matvec=mv), + k=rank_estimate, + maxiter=max_iter, + tol=tol, + ncv=krylov_dimension, + return_eigenvectors=True, + ) - return LowRankProductRepresentation( - torch.as_tensor(eigen_vals, dtype=torch_default_dtype), - torch.as_tensor(eigen_vecs, dtype=torch_default_dtype), + except ArpackNoConvergence as e: + logger.warning( + f"ARPACK did not converge for parameters {max_iter=}, {tol=}, {krylov_dimension=}, " + f"{rank_estimate=}. \n Returning the best approximation found so far. Use those with care or " + f"modify parameters.\n Original error: {e}" ) + + eigen_vals, eigen_vecs = e.eigenvalues, e.eigenvectors + + eigen_vals, eigen_vecs = to_torch_conversion_function( + eigen_vals + ), to_torch_conversion_function(eigen_vecs) + + return LowRankProductRepresentation(eigen_vals, eigen_vecs) From 699dbf0357d048adf00f5053c385005ebb37ffe4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Tue, 25 Jul 2023 18:00:46 +0200 Subject: [PATCH 196/436] Bump version of torchvision, to be compatible with pinned torch version --- requirements-notebooks.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements-notebooks.txt b/requirements-notebooks.txt index 684a88876..29d63506f 100644 --- a/requirements-notebooks.txt +++ b/requirements-notebooks.txt @@ -1,4 +1,4 @@ torch==2.0.1 -torchvision==0.14.1 +torchvision==0.15.2 datasets==2.6.1 pillow==9.3.0 From 654327a294497bbfdef57b5e1a01b7d6f044886b Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 26 Jul 2023 00:26:34 +0200 Subject: [PATCH 197/436] small changes to docs --- docs/40-influence.rst | 169 ++++++++++++++++++++---------------------- 1 file changed, 80 insertions(+), 89 deletions(-) diff --git a/docs/40-influence.rst b/docs/40-influence.rst index e1e37cd08..2aef89819 100644 --- a/docs/40-influence.rst +++ b/docs/40-influence.rst @@ -18,9 +18,9 @@ Computing influence values The influence function (IF) is a method to quantify the effect (influence) that each training point has on the parameters of a model, and by extension on any -function thereof. In particular, it is possible to estimate how much each -training sample affects the error on a test point, making the IF useful -for understanding and debugging models. +function thereof. In particular, it allows to estimate how much each training +sample affects the error on a test point, making the IF useful for understanding +and debugging models. pyDVL implements several methods for the efficient computation of the IF for machine learning. @@ -35,12 +35,12 @@ formulation, consider an input space $\mathcal{X}$ (e.g. images) and an output space $\mathcal{Y}$ (e.g. labels). Let's take $z_i = (x_i, y_i)$, for $i \in \{1,...,n\}$ to be the $i$-th training point, and $\theta$ to be the (potentially highly) multi-dimensional parameters of a model (e.g. $\theta$ is a -big array with all of a neural network's parameters, including biases, batch -normalizations and/or dropout rates). We will denote with $L(z, \theta)$ the -loss of the model for point $z$ when the parameters are $\theta.$ +big array with all of a neural network's parameters, including biases and/or +dropout rates). We will denote with $L(z, \theta)$ the loss of the model for +point $z$ when the parameters are $\theta.$ -To train a model, we typically minimize the loss over all $z_i$, i.e. -the optimal parameters are +To train a model, we typically minimize the loss over all $z_i$, i.e. the +optimal parameters are $$\hat{\theta} = \arg \min_\theta \sum_{i=1}^n L(z_i, \theta).$$ @@ -50,9 +50,7 @@ stops decreasing. For notational convenience, let's define -$$ -\hat{\theta}_{-z} = \arg \min_\theta \sum_{z_i \ne z} L(z_i, \theta), -$$ +$$\hat{\theta}_{-z} = \arg \min_\theta \sum_{z_i \ne z} L(z_i, \theta), $$ i.e. $\hat{\theta}_{-z}$ are the model parameters that minimize the total loss when $z$ is not in the training dataset. @@ -66,65 +64,61 @@ approximation of $\hat{\theta}$. This can be done through single backpropagation and without re-training the full model. +.. _approximating_influence_of_a_point: + Approximating the influence of a point ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Let's define -$$ -\hat{\theta}_{\epsilon, z} = \arg \min_\theta -\frac{1}{n}\sum_{i=1}^n L(z_i, \theta) + \epsilon L(z, \theta), -$$ +$$\hat{\theta}_{\epsilon, z} = \arg \min_\theta \frac{1}{n}\sum_{i=1}^n L(z_i, +\theta) + \epsilon L(z, \theta), $$ -which is the optimal $\hat{\theta}$ if we were to up-weight $z$ by an amount -$\epsilon \gt 0$. +which is the optimal $\hat{\theta}$ when we up-weight $z$ by an amount $\epsilon +\gt 0$. From a classical result (a simple derivation is available in Appendix A of :footcite:t:`koh_understanding_2017`), we know that: -$$ -\frac{d \ \hat{\theta}_{\epsilon, z}}{d \epsilon} \Big|_{\epsilon=0} -= -H_{\hat{\theta}}^{-1} \nabla_\theta L(z, \hat{\theta}), -$$ +$$\frac{d \ \hat{\theta}_{\epsilon, z}}{d \epsilon} \Big|_{\epsilon=0} = +-H_{\hat{\theta}}^{-1} \nabla_\theta L(z, \hat{\theta}), $$ where $H_{\hat{\theta}} = \frac{1}{n} \sum_{i=1}^n \nabla_\theta^2 L(z_i, -\hat{\theta})$ is the Hessian of $L$. Importantly, notice that this expression -is only valid when $\hat{\theta}$ is a minimum of $L$, or otherwise -$H_{\hat{\theta}}$ cannot be inverted! At the same time, in machine learning -full convergence is rarely achieved, so direct Hessian inversion is not -possible. Approximations need to be developed that circumvent the problem of -inverting the Hessian of the model in all those (frequent) cases where it is not -positive definite. - -We will define the influence of training point $z$ on test point -$z_{\text{test}}$ as - -$$ -\mathcal{I}(z, z_{\text{test}}) = L(z_{\text{test}}, \hat{\theta}_{-z}) - -L(z_{\text{test}}, \hat{\theta}). -$$ +\hat{\theta})$ is the Hessian of $L$. These quantities are also knows as **influence +factors**. + +Importantly, notice that this expression is only valid when $\hat{\theta}$ is a +minimum of $L$, or otherwise $H_{\hat{\theta}}$ cannot be inverted! At the same +time, in machine learning full convergence is rarely achieved, so direct Hessian +inversion is not possible. Approximations need to be developed that circumvent +the problem of inverting the Hessian of the model in all those (frequent) cases +where it is not positive definite. + +The influence of training point $z$ on test point $z_{\text{test}}$ is defined +as: + +$$\mathcal{I}(z, z_{\text{test}}) = L(z_{\text{test}}, \hat{\theta}_{-z}) - +L(z_{\text{test}}, \hat{\theta}). $$ Notice that $\mathcal{I}$ is higher for points $z$ which positively impact the model score, since the loss is higher when they are excluded from training. In practice, one needs to rely on the following infinitesimal approximation: -$$ -\mathcal{I}_{up}(z, z_{\text{test}}) = - \frac{d L(z_{\text{test}}, -\hat{\theta}_{\epsilon, z})}{d \epsilon} \Big|_{\epsilon=0} -$$ +$$\mathcal{I}_{up}(z, z_{\text{test}}) = - \frac{d L(z_{\text{test}}, +\hat{\theta}_{\epsilon, z})}{d \epsilon} \Big|_{\epsilon=0} $$ -Using the chain rule and the results calculated above, we thus have: +Using the chain rule and the results calculated above, we get: -$$ -\mathcal{I}_{up}(z, z_{\text{test}}) = - \nabla_\theta L(z_{\text{test}}, +$$\mathcal{I}_{up}(z, z_{\text{test}}) = - \nabla_\theta L(z_{\text{test}}, \hat{\theta})^\top \ \frac{d \hat{\theta}_{\epsilon, z}}{d \epsilon} \Big|_{\epsilon=0} = \nabla_\theta L(z_{\text{test}}, \hat{\theta})^\top \ -H_{\hat{\theta}}^{-1} \ \nabla_\theta L(z, \hat{\theta}) -$$ +H_{\hat{\theta}}^{-1} \ \nabla_\theta L(z, \hat{\theta}) $$ -All the factors in this expression are gradients of the loss wrt. the model -parameters $\hat{\theta}$. This can be easily done through one or more -backpropagation passes. +All the resulting factors are gradients of the loss wrt. the model parameters +$\hat{\theta}$. This can be easily computed through one or more backpropagation +passes. + +.. _perturbation_definition_of_the_influence_score: Perturbation definition of the influence score ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -135,53 +129,50 @@ of zeros except for a 1 in the position of the feature we want to up-weight. In order to approximate the effect of modifying a single feature of a single point on the model score we can define -$$ -\hat{\theta}_{\epsilon, z_{\delta} ,-z} = \arg \min_\theta +$$\hat{\theta}_{\epsilon, z_{\delta} ,-z} = \arg \min_\theta \frac{1}{n}\sum_{i=1}^n L(z_{i}, \theta) + \epsilon L(z_{\delta}, \theta) - -\epsilon L(z, \theta), -$$ +\epsilon L(z, \theta), $$ -Similarly to what was done above, we up-weight point $z_{\delta}$, but -then we also remove the up-weighting for all the features that are not modified -by $\delta$. From the calculations in ???, it is then easy to see that +Similarly to what was done above, we up-weight point $z_{\delta}$, but then we +also remove the up-weighting for all the features that are not modified by +$\delta$. From the calculations in :ref:`the previous section +`, it is then easy to see that -$$ -\frac{d \ \hat{\theta}_{\epsilon, z_{\delta} ,-z}}{d \epsilon} \Big|_{\epsilon=0} -= -H_{\hat{\theta}}^{-1} \nabla_\theta \Big( L(z_{\delta}, \hat{\theta}) - L(z, \hat{\theta}) \Big) -$$ +$$\frac{d \ \hat{\theta}_{\epsilon, z_{\delta} ,-z}}{d \epsilon} +\Big|_{\epsilon=0} = -H_{\hat{\theta}}^{-1} \nabla_\theta \Big( L(z_{\delta}, +\hat{\theta}) - L(z, \hat{\theta}) \Big) $$ and if the feature space is continuous and as $\delta \to 0$ we can write -$$ -\frac{d \ \hat{\theta}_{\epsilon, z_{\delta} ,-z}}{d \epsilon} \Big|_{\epsilon=0} -= -H_{\hat{\theta}}^{-1} \ \nabla_x \nabla_\theta L(z, \hat{\theta}) \delta + \mathcal{o}(\delta) -$$ +$$\frac{d \ \hat{\theta}_{\epsilon, z_{\delta} ,-z}}{d \epsilon} +\Big|_{\epsilon=0} = -H_{\hat{\theta}}^{-1} \ \nabla_x \nabla_\theta L(z, +\hat{\theta}) \delta + \mathcal{o}(\delta) $$ The influence of each feature of $z$ on the loss of the model can therefore be estimated through the following quantity: -$$ -\mathcal{I}_{pert}(z, z_{\text{test}}) = - \lim_{\delta \to 0} \ \frac{1}{\delta} \frac{d L(z_{\text{test}}, -\hat{\theta}_{\epsilon, \ z_{\delta}, \ -z})}{d \epsilon} \Big|_{\epsilon=0} -$$ +$$\mathcal{I}_{pert}(z, z_{\text{test}}) = - \lim_{\delta \to 0} \ +\frac{1}{\delta} \frac{d L(z_{\text{test}}, \hat{\theta}_{\epsilon, \ +z_{\delta}, \ -z})}{d \epsilon} \Big|_{\epsilon=0} $$ which, using the chain rule and the results calculated above, is equal to -$$ -\mathcal{I}_{pert}(z, z_{\text{test}}) = - \nabla_\theta L(z_{\text{test}}, -\hat{\theta})^\top \ \frac{d \hat{\theta}_{\epsilon, z_{\delta} ,-z}}{d \epsilon} -\Big|_{\epsilon=0} = \nabla_\theta L(z_{\text{test}}, \hat{\theta})^\top \ -H_{\hat{\theta}}^{-1} \ \nabla_x \nabla_\theta L(z, \hat{\theta}) -$$ +$$\mathcal{I}_{pert}(z, z_{\text{test}}) = - \nabla_\theta L(z_{\text{test}}, +\hat{\theta})^\top \ \frac{d \hat{\theta}_{\epsilon, z_{\delta} ,-z}}{d +\epsilon} \Big|_{\epsilon=0} = \nabla_\theta L(z_{\text{test}}, +\hat{\theta})^\top \ H_{\hat{\theta}}^{-1} \ \nabla_x \nabla_\theta L(z, +\hat{\theta}) $$ The perturbation definition of the influence score is not straightforward to understand, but it has a simple interpretation: it tells how much the loss of the model changes when a certain feature of point z is up-weighted. A positive perturbation influence score indicates that the feature might have a positive -effect on the accuracy of the model. It is worth noting that this is just a very -rough estimate and it is subject to large approximation errors. It can -nonetheless be used to build training-set attacks, as done in -:footcite:t:`koh_understanding_2017`. +effect on the accuracy of the model. + +It is worth noting that the perturbation influence score is a very rough +estimate of the impact of a point on the models loss and it is subject to large +approximation errors. It can nonetheless be used to build training-set attacks, +as done in :footcite:t:`koh_understanding_2017`. Computing influences @@ -224,20 +215,20 @@ allowed values. ... ) -Additionally, and as discussed in `The Influence Function`_, in -machine learning training rarely converges to a global minimum of the loss. -Despite good apparent convergence, $\hat{\theta}$ might be located in a region -with flat curvature or close to a saddle point. In particular, the Hessian might -have vanishing eigenvalues making its direct inversion impossible. +Additionally, and as discussed in `The Influence Function`_, in machine learning +training rarely converges to a global minimum of the loss. Despite good apparent +convergence, $\hat{\theta}$ might be located in a region with flat curvature or +close to a saddle point. In particular, the Hessian might have vanishing +eigenvalues making its direct inversion impossible. To circumvent this problem, many approximate methods are available. The simplest -adds a small *hessian perturbation term*, i.e. we invert -$H_{\hat{\theta}} + \lambda \mathbb{I}$, with $\mathbb{I}$ being the identity -matrix. This standard trick ensures that the eigenvalues of $H_{\hat{\theta}}$ -are bounded away from zero and therefore the matrix is invertible. In order for -this regularization not to corrupt the outcome too much, the parameter $\lambda$ -should be as small as possible while still allowing a reliable inversion of -$H_{\hat{\theta}} + \lambda \mathbb{I}$. +adds a small *hessian perturbation term*, i.e. we invert $H_{\hat{\theta}} + +\lambda \mathbb{I}$, with $\mathbb{I}$ being the identity matrix. This standard +trick ensures that the eigenvalues of $H_{\hat{\theta}}$ are bounded away from +zero and therefore the matrix is invertible. In order for this regularization +not to corrupt the outcome too much, the parameter $\lambda$ should be as small +as possible while still allowing a reliable inversion of $H_{\hat{\theta}} + +\lambda \mathbb{I}$. .. code-block:: python From 7e20ed90511a73822e9773af390887130277c9c0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Wed, 26 Jul 2023 12:58:19 +0200 Subject: [PATCH 198/436] Rename TensorContainerType to TorchTensorContainerType Avoid confusion with TensorType defined in influence.frameworks.twice_differentiable, which serves a different purpose --- src/pydvl/influence/frameworks/functional.py | 12 ++++++------ src/pydvl/influence/frameworks/util.py | 6 +++--- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/pydvl/influence/frameworks/functional.py b/src/pydvl/influence/frameworks/functional.py index 1c6648851..07f905015 100644 --- a/src/pydvl/influence/frameworks/functional.py +++ b/src/pydvl/influence/frameworks/functional.py @@ -5,7 +5,7 @@ from torch.func import functional_call, grad, jvp, vjp from torch.utils.data import DataLoader -from .util import TensorContainerType, align_structure, to_model_device +from .util import TorchTensorContainerType, align_structure, to_model_device __all__ = [ "get_hvp_function", @@ -13,11 +13,11 @@ def hvp( - func: Callable[[TensorContainerType], TensorContainerType], - params: TensorContainerType, - vec: TensorContainerType, + func: Callable[[TorchTensorContainerType], TorchTensorContainerType], + params: TorchTensorContainerType, + vec: TorchTensorContainerType, reverse_only: bool = True, -) -> TensorContainerType: +) -> TorchTensorContainerType: """ Computes the Hessian-vector product (HVP) for a given function at given parameters. This function can operate in two modes, either reverse-mode autodiff only or both @@ -40,7 +40,7 @@ def hvp( >>> hvp_vec = hvp(f, u, v) >>> assert torch.allclose(hvp_vec, torch.full((10, ), 2.0)) """ - output: TensorContainerType + output: TorchTensorContainerType if reverse_only: _, vjp_fn = vjp(grad(func), params) diff --git a/src/pydvl/influence/frameworks/util.py b/src/pydvl/influence/frameworks/util.py index 9bf6f135d..b6e82914a 100644 --- a/src/pydvl/influence/frameworks/util.py +++ b/src/pydvl/influence/frameworks/util.py @@ -82,8 +82,8 @@ def reshape_vector_to_tensors( return tuple(tensors) -TensorContainerType = TypeVar( - "TensorContainerType", +TorchTensorContainerType = TypeVar( + "TorchTensorContainerType", torch.Tensor, Tuple[torch.Tensor, ...], Dict[str, torch.Tensor], @@ -92,7 +92,7 @@ def reshape_vector_to_tensors( def align_structure( source: Dict[str, torch.Tensor], - target: TensorContainerType, + target: TorchTensorContainerType, ) -> Dict[str, torch.Tensor]: """ This function transforms `target` to have the same structure as `source`, i.e., From 65e3f6f0dca6526b7cb6b3652e89efd79b4b2372 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Wed, 26 Jul 2023 13:31:17 +0200 Subject: [PATCH 199/436] Apply changes suggested in review * harmonize docstring format * add unit test for align_structure * move import to toplevel * simplify path existence check --- .../frameworks/torch_differentiable.py | 9 ++-- src/pydvl/influence/frameworks/util.py | 42 +++++---------- src/pydvl/utils/dataset.py | 4 +- tests/influence/test_influences.py | 34 ++++++------ tests/influence/test_util.py | 53 ++++++++++++++++++- 5 files changed, 86 insertions(+), 56 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index daee0529c..14adc84b1 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -13,6 +13,7 @@ import torch import torch.nn as nn from numpy.typing import NDArray +from scipy.sparse.linalg import ArpackNoConvergence from torch import autograd from torch.autograd import Variable from torch.utils.data import DataLoader @@ -65,6 +66,7 @@ def solve_linear( :return: An array that solves the inverse problem, i.e. it returns $x$ such that $Hx = b$ """ + all_x, all_y = [], [] for x, y in training_data: all_x.append(x) @@ -606,8 +608,6 @@ def mv(x): to_torch_conversion_function = partial(torch.as_tensor, dtype=torch_dtype) - from scipy.sparse.linalg import ArpackNoConvergence - try: eigen_vals, eigen_vecs = eigsh( @@ -628,8 +628,7 @@ def mv(x): eigen_vals, eigen_vecs = e.eigenvalues, e.eigenvectors - eigen_vals, eigen_vecs = to_torch_conversion_function( - eigen_vals - ), to_torch_conversion_function(eigen_vecs) + eigen_vals = to_torch_conversion_function(eigen_vals) + eigen_vecs = to_torch_conversion_function(eigen_vecs) return LowRankProductRepresentation(eigen_vals, eigen_vecs) diff --git a/src/pydvl/influence/frameworks/util.py b/src/pydvl/influence/frameworks/util.py index b6e82914a..540df53bc 100644 --- a/src/pydvl/influence/frameworks/util.py +++ b/src/pydvl/influence/frameworks/util.py @@ -1,7 +1,6 @@ -import copy import logging import math -from typing import Dict, Iterable, Tuple, TypeVar, Union +from typing import Dict, Iterable, Tuple, TypeVar import torch @@ -11,9 +10,6 @@ def to_model_device(x: torch.Tensor, model: torch.nn.Module) -> torch.Tensor: """ Returns the tensor `x` moved to the device of the `model`, if device of model is set - :param x: - :param model: - :return: """ if hasattr(model, "device"): return x.to(model.device) @@ -27,11 +23,8 @@ def flatten_tensors_to_vector(tensors: Iterable[torch.Tensor]) -> torch.Tensor: The function takes an iterable of tensors and reshapes each of them into a 1D tensor. These reshaped tensors are then concatenated together into a single 1D tensor in the order they were given. - Parameters: - tensors (Iterable[torch.Tensor]): An iterable of tensors to be reshaped and concatenated. - - Returns: - torch.Tensor: A 1D tensor that is the concatenation of all the reshaped input tensors. + :param tensors: An iterable of tensors to be reshaped and concatenated. + :return: A 1D tensor that is the concatenation of all the reshaped input tensors. """ return torch.cat([t.contiguous().view(-1) for t in tensors]) @@ -48,17 +41,13 @@ def reshape_vector_to_tensors( Note: The total number of elements in 'input_vector' must be equal to the sum of the products of the shapes in 'target_shapes'. - Parameters: - input_vector (Tensor): The 1D tensor to be reshaped. Must be 1D. - target_shapes (Iterable[Tuple[int, ...]]): An iterable of tuples. Each tuple defines the shape of a tensor to be - reshaped from the 'input_vector'. - - Returns: - tuple[torch.Tensor]: A tuple of reshaped tensors. - - Raises: - ValueError: If 'input_vector' is not a 1D tensor or if the total number of elements in 'input_vector' does not match - the sum of the products of the shapes in 'target_shapes'. + :param input_vector: The 1D tensor to be reshaped. Must be 1D. + :param target_shapes: An iterable of tuples. Each tuple defines the shape of a tensor to be + reshaped from the 'input_vector'. + :return: A tuple of reshaped tensors. + :raises: + ValueError: If 'input_vector' is not a 1D tensor or if the total number of elements + in 'input_vector' does not match the sum of the products of the shapes in 'target_shapes'. """ if input_vector.dim() != 1: @@ -99,15 +88,12 @@ def align_structure( it should be a dictionary with the same keys as `source` and each corresponding value in `target` should have the same shape as the value in `source`. - Args: - source (dict): The reference dictionary containing PyTorch tensors. - target (Input_type): The input to be harmonized. It can be a dictionary, tuple, or tensor. + :param source: The reference dictionary containing PyTorch tensors. + :param target: The input to be harmonized. It can be a dictionary, tuple, or tensor. - Returns: - dict: The harmonized version of `target`. + :return: The harmonized version of `target`. - Raises: - ValueError: If `target` cannot be harmonized to match `source`. + :raises ValueError: If `target` cannot be harmonized to match `source`. """ tangent_dict: Dict[str, torch.Tensor] diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index 232af83fa..595a6cfa0 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -17,7 +17,6 @@ """ import logging -import os from collections import OrderedDict from pathlib import Path from typing import Any, Callable, Iterable, List, Optional, Sequence, Tuple, Union @@ -604,8 +603,7 @@ def load_spotify_dataset( else: url = "https://raw.githubusercontent.com/appliedAI-Initiative/pyDVL/develop/data/top_hits_spotify_dataset.csv" data = pd.read_csv(url) - if not os.path.exists(root_dir_path): - os.makedirs(root_dir_path) + root_dir_path.mkdir(exist_ok=True) data.to_csv(file_path, index=False) data = data[data["year"] > min_year] diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 77eaf01db..d9653d097 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -223,17 +223,16 @@ def create_random_data_loader( batch_size: int = 1, random_seed: int = 31, ) -> DataLoader: - """Creates DataLoader instances with random data for testing purposes. + """ + Creates DataLoader instances with random data for testing purposes. - Args: - input_dim (Tuple[int]): The dimensions of the input data. - output_dim (int): The dimension of the output data. - data_len (int): The length of the training dataset to be generated. - batch_size (int): The size of the batches to be used in the DataLoader. - random_seed (int, optional): The seed for the random number generator. Defaults to 31. + :param input_dim: The dimensions of the input data. + :param output_dim: The dimension of the output data. + :param data_len: The length of the training dataset to be generated. + :param batch_size: The size of the batches to be used in the DataLoader. + :param random_seed: The seed for the random number generator. Defaults to 31. - Returns: - DataLoader: DataLoader instances for data. + :return: DataLoader instances for data. """ torch.manual_seed(random_seed) x = torch.rand((data_len, *input_dim)) @@ -326,17 +325,16 @@ def minimal_training( lr=0.01, epochs=50, ): - """Trains a PyTorch model using L-BFGS optimizer. + """ + Trains a PyTorch model using L-BFGS optimizer. - Args: - model (Module): The PyTorch model to be trained. - dataloader (DataLoader): DataLoader providing the training data. - loss_function (Module): The loss function to be used for training. - lr (float, optional): The learning rate for the L-BFGS optimizer. Defaults to 0.01. - epochs (int, optional): The number of training epochs. Defaults to 50. + :param model: The PyTorch model to be trained. + :param dataloader: DataLoader providing the training data. + :param loss_function: The loss function to be used for training. + :param lr: The learning rate for the L-BFGS optimizer. Defaults to 0.01. + :param epochs: The number of training epochs. Defaults to 50. - Returns: - Module: The trained model. + :return: The trained model. """ model = model.train() optimizer = LBFGS(model.parameters(), lr=lr) diff --git a/tests/influence/test_util.py b/tests/influence/test_util.py index 8651341d6..7828c470a 100644 --- a/tests/influence/test_util.py +++ b/tests/influence/test_util.py @@ -1,5 +1,5 @@ from dataclasses import astuple, dataclass -from typing import Tuple +from typing import Any, Dict, Tuple import pytest @@ -17,7 +17,11 @@ from pydvl.influence.frameworks.torch_differentiable import ( lanzcos_low_rank_hessian_approx, ) -from pydvl.influence.frameworks.util import align_structure, flatten_tensors_to_vector +from pydvl.influence.frameworks.util import ( + TorchTensorContainerType, + align_structure, + flatten_tensors_to_vector, +) from tests.influence.conftest import linear_hessian_analytical, linear_model @@ -184,3 +188,48 @@ def test_lanzcos_low_rank_hessian_approx_exception(): lanzcos_low_rank_hessian_approx( lambda x: x, (3, 3), eigen_computation_on_gpu=True ) + + +@pytest.mark.parametrize( + "source,target", + [ + ( + {"a": torch.randn(5, 5), "b": torch.randn(5, 5)}, + {"a": torch.randn(5, 5), "b": torch.randn(5, 5)}, + ), + ( + {"a": torch.randn(5, 5), "b": torch.randn(5, 5)}, + (torch.randn(5, 5), torch.randn(5, 5)), + ), + ({"a": torch.randn(5, 5), "b": torch.randn(5, 5)}, torch.randn(50)), + ], +) +def test_align_structure_success( + source: Dict[str, torch.Tensor], target: TorchTensorContainerType +): + result = align_structure(source, target) + assert isinstance(result, dict) + assert list(result.keys()) == list(source.keys()) + assert all([result[k].shape == source[k].shape for k in source.keys()]) + + +@pytest.mark.parametrize( + "source,target", + [ + ( + {"a": torch.randn(5, 5), "b": torch.randn(5, 5)}, + {"a": torch.randn(5, 5), "b": torch.randn(3, 3)}, + ), + ( + {"a": torch.randn(5, 5), "b": torch.randn(5, 5)}, + {"c": torch.randn(5, 5), "d": torch.randn(5, 5)}, + ), + ( + {"a": torch.randn(5, 5), "b": torch.randn(5, 5)}, + "unsupported", + ), + ], +) +def test_align_structure_error(source: Dict[str, torch.Tensor], target: Any): + with pytest.raises(ValueError): + align_structure(source, target) From a3cb4e5ba2f5151f92230a8e62a6ad91d05eb994 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 26 Jul 2023 14:52:06 +0200 Subject: [PATCH 200/436] Only pass used arguments from ParallelConfig to ray.init --- src/pydvl/utils/parallel/backend.py | 23 +++++++++-------------- src/pydvl/utils/parallel/map_reduce.py | 5 ++++- 2 files changed, 13 insertions(+), 15 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index cac16afb5..31c56d238 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -105,14 +105,10 @@ class JoblibParallelBackend(BaseParallelBackend, backend_name="joblib"): """ def __init__(self, config: ParallelConfig): - config_dict = asdict(config) - config_dict.pop("backend") - n_cpus_local = config_dict.pop("n_cpus_local") - config_dict["n_jobs"] = n_cpus_local - self.config = config_dict - # In joblib the levels are reversed. - # 0 means no logging and 50 means log everything to stdout - verbose = 50 - config_dict["logging_level"] + self.config = { + "n_jobs": config.n_cpus_local, + "logging_level": config.logging_level, + } def get( self, @@ -162,12 +158,11 @@ class RayParallelBackend(BaseParallelBackend, backend_name="ray"): """ def __init__(self, config: ParallelConfig): - config_dict = asdict(config) - config_dict.pop("backend") - n_cpus_local = config_dict.pop("n_cpus_local") - if config_dict.get("address", None) is None: - config_dict["num_cpus"] = n_cpus_local - self.config = config_dict + self.config = {"logging_level": config.logging_level} + if config.address is None: + self.config["num_cpus"] = config.n_cpus_local + else: + self.config["address"] = config.address if not ray.is_initialized(): ray.init(**self.config) # Register ray joblib backend diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index 079a1118f..d40d3f1a6 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -103,7 +103,10 @@ def __call__( backend = "loky" else: backend = self.config.backend - with Parallel(backend=backend, n_jobs=self.n_jobs) as parallel: + # In joblib the levels are reversed. + # 0 means no logging and 50 means log everything to stdout + verbose = 50 - self.config.logging_level + with Parallel(backend=backend, n_jobs=self.n_jobs, verbose=verbose) as parallel: chunks = self._chunkify(self.inputs_, n_chunks=self.n_jobs) map_results: List[R] = parallel( delayed(self._map_func)(next_chunk, job_id=j, **self.map_kwargs) From 2c65bd3ed008cd6148f7e55e6a5617a13532b276 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 26 Jul 2023 14:54:50 +0200 Subject: [PATCH 201/436] Update changelog --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 507684eb9..b32a2119e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,8 @@ [PR #355](https://github.com/appliedAI-Initiative/pyDVL/pull/355) - **Bug fix** Fix installation of dev requirements for Python3.10 [PR #382](https://github.com/appliedAI-Initiative/pyDVL/pull/382) +- Decouple ray.init from ParallelConfig + [PR #373](https://github.com/appliedAI-Initiative/pyDVL/pull/383) ## 0.6.1 - 🏗 Bug fixes and small improvement From fa91bb6bfbca451215fc9e72dab04d9348bec713 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 27 Jul 2023 10:27:52 +0200 Subject: [PATCH 202/436] Fix init_parallel_backend's doctests --- src/pydvl/utils/parallel/backend.py | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index 31c56d238..9fc549b70 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -106,8 +106,8 @@ class JoblibParallelBackend(BaseParallelBackend, backend_name="joblib"): def __init__(self, config: ParallelConfig): self.config = { - "n_jobs": config.n_cpus_local, "logging_level": config.logging_level, + "n_jobs": config.n_cpus_local, } def get( @@ -158,11 +158,9 @@ class RayParallelBackend(BaseParallelBackend, backend_name="ray"): """ def __init__(self, config: ParallelConfig): - self.config = {"logging_level": config.logging_level} - if config.address is None: + self.config = {"address": config.address, "logging_level": config.logging_level} + if self.config["address"] is None: self.config["num_cpus"] = config.n_cpus_local - else: - self.config["address"] = config.address if not ray.is_initialized(): ray.init(**self.config) # Register ray joblib backend @@ -233,6 +231,13 @@ def init_parallel_backend( :Example: + >>> from pydvl.utils.parallel.backend import init_parallel_backend + >>> from pydvl.utils.config import ParallelConfig + >>> config = ParallelConfig() + >>> parallel_backend = init_parallel_backend(config) + >>> parallel_backend + + >>> from pydvl.utils.parallel.backend import init_parallel_backend >>> from pydvl.utils.config import ParallelConfig >>> config = ParallelConfig(backend="ray") From edbe9aac04f8fab925cf1f4fa98e4423220a42f0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 27 Jul 2023 10:44:44 +0200 Subject: [PATCH 203/436] [skip ci] Add boolean flag: tracking gradients of result of hessian vector products --- src/pydvl/influence/frameworks/functional.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/src/pydvl/influence/frameworks/functional.py b/src/pydvl/influence/frameworks/functional.py index 07f905015..4951ac224 100644 --- a/src/pydvl/influence/frameworks/functional.py +++ b/src/pydvl/influence/frameworks/functional.py @@ -150,6 +150,7 @@ def get_hvp_function( data_loader: DataLoader, use_hessian_avg: bool = True, reverse_only: bool = True, + track_gradients: bool = False, ) -> Callable[[Dict[str, torch.Tensor]], Dict[str, torch.Tensor]]: """ Returns a function that calculates the approximate Hessian-vector product for a given vector. If you want to @@ -167,11 +168,17 @@ def get_hvp_function( but probably has a way higher memory usage. :param reverse_only: Whether to use only reverse-mode autodiff (True, default) or both forward- and reverse-mode autodiff (False) + :param track_gradients: Whether to track gradients for the resulting tensor of the hessian vector products are + (False, default). + :return: A function that takes a single argument, a vector, and returns the product of the Hessian of the `loss` function with respect to the `model`'s parameters and the input vector. """ - params = dict(model.named_parameters()) + + params = { + k: p if track_gradients else p.detach() for k, p in model.named_parameters() + } def hvp_function(vec: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]: v = align_structure(params, vec) From 905ac0ab939087ecbabffec40b1f435f50f85e8c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 27 Jul 2023 17:17:00 +0200 Subject: [PATCH 204/436] Revert "[skip ci] Explicitly reference tests directory in tox base and torch environment, in order to not invoke tests from other directories like /notebooks" This reverts commit 5a28716ce86378bfede15b155f52ed163e39977c. --- tox.ini | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tox.ini b/tox.ini index 5b7686bbc..3ef32048a 100644 --- a/tox.ini +++ b/tox.ini @@ -17,12 +17,12 @@ setenv = [testenv:base] description = Tests base modules commands = - pytest tests/ --cov "{envsitepackagesdir}/pydvl" -m "not torch" {posargs} + pytest --cov "{envsitepackagesdir}/pydvl" -m "not torch" {posargs} [testenv:torch] description = Tests modules that rely on pytorch commands = - pytest tests/ --cov "{envsitepackagesdir}/pydvl" -m torch {posargs} + pytest --cov "{envsitepackagesdir}/pydvl" -m torch {posargs} extras = influence From 35ba2534269836a7a198b3faeaf2ac5f366bba55 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Fri, 28 Jul 2023 11:14:55 +0200 Subject: [PATCH 205/436] Add dependency change to CHANGELOG.md --- CHANGELOG.md | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index f919d39c2..3e2938e2f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,9 +12,11 @@ [PR #278](https://github.com/appliedAI-Initiative/pyDVL/pull/278) - **New Method**: Implements solving the hessian equation via spectral low-rank approximation [PR #365](https://github.com/appliedAI-Initiative/pyDVL/pull/365) -- **Breaking Changes** Add new joblib backend and set it as default - instead of the ray backend. Simplify the MapReduceJob class. - [PR #355](https://github.com/appliedAI-Initiative/pyDVL/pull/355) +- **Breaking Changes**: + - Add new joblib backend and set it as default + instead of the ray backend. Simplify the MapReduceJob class. + [PR #355](https://github.com/appliedAI-Initiative/pyDVL/pull/355) + - Bump torch dependency for influence package to 2.0 [PR #365](https://github.com/appliedAI-Initiative/pyDVL/pull/365) - **Bug fix** Fix installation of dev requirements for Python3.10 [PR #382](https://github.com/appliedAI-Initiative/pyDVL/pull/382) From 65626738f2356dae937a6c02d98a53ff7f467063 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Sun, 30 Jul 2023 15:24:02 +0200 Subject: [PATCH 206/436] WIP documentation --- docs/40-influence.rst | 99 ++++++++++++++++++++++++++++++++++--------- 1 file changed, 80 insertions(+), 19 deletions(-) diff --git a/docs/40-influence.rst b/docs/40-influence.rst index 2aef89819..caad00016 100644 --- a/docs/40-influence.rst +++ b/docs/40-influence.rst @@ -25,6 +25,8 @@ and debugging models. pyDVL implements several methods for the efficient computation of the IF for machine learning. +.. _the_influence_function: + The Influence Function ----------------------- @@ -84,8 +86,8 @@ $$\frac{d \ \hat{\theta}_{\epsilon, z}}{d \epsilon} \Big|_{\epsilon=0} = -H_{\hat{\theta}}^{-1} \nabla_\theta L(z, \hat{\theta}), $$ where $H_{\hat{\theta}} = \frac{1}{n} \sum_{i=1}^n \nabla_\theta^2 L(z_i, -\hat{\theta})$ is the Hessian of $L$. These quantities are also knows as **influence -factors**. +\hat{\theta})$ is the Hessian of $L$. These quantities are also knows as +**influence factors**. Importantly, notice that this expression is only valid when $\hat{\theta}$ is a minimum of $L$, or otherwise $H_{\hat{\theta}}$ cannot be inverted! At the same @@ -178,12 +180,20 @@ as done in :footcite:t:`koh_understanding_2017`. Computing influences -------------------- -The main entry point of the library is -:func:`~pydvl.influence.general.compute_influences`. Influences can be computed -for any model which implements the -:class:`~pydvl.influence.frameworks.twice_differentiable.TwiceDifferentiable` -protocol, i.e. which is capable of calculating second derivative matrix vector -products and gradients of the loss evaluated on training and test samples. +The main entry point of the library for influence calculation is +:func:`~pydvl.influence.general.compute_influences`. Given a pre-trained pytorch +model with a loss, first an instance of +:func:`~pydvl.influence.general.TorchTwiceDifferentiable` needs to be created. + +.. code-block:: python + + >>> from pydvl.influence import TorchTwiceDifferentiable + >>> model = TorchTwiceDifferentiable(model, loss, device) + +The device specifies where influence calculation will be run. + +Given training and test data loaders, the influence of each training point on +each test point can be calculated via: .. code-block:: python @@ -194,6 +204,13 @@ products and gradients of the loss evaluated on training and test samples. ... test_data_loader ... ) +The result is a tensor with one row per test point and one column per training +point. Thus, each entry $(i, j)$ represents the influence of training point $j$ +on test point $i$. A large positive influence indicates that training point $j$ +tends to improve the performance of the model on test point $i$, and vice versa, +a large negative influence indicates that training point $j$ tends to worsen the +performance of the model on test point $i$. + Approximate matrix inversion ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -214,20 +231,41 @@ allowed values. ... inversion_method="cg" ... ) +Each method has its own set of parameters that can be tuned to improve the final +result. These parameters can be passed directly to +:func:`~pydvl.influence.general.compute_influences` as keyword arguments. For +example, the following code sets the maximum number of iterations for conjugate +gradient to $100$ and the miximum relative error to $0.01$: + +.. code-block:: python + + >>> from pydvl.influence import compute_influences + >>> compute_influences( + ... model, + ... training_data_loader, + ... test_data_loader, + ... inversion_method="cg", + ... hessian_regularization=1e-4, + ... maxiter=100, + ... rtol=0.01 + ... ) -Additionally, and as discussed in `The Influence Function`_, in machine learning -training rarely converges to a global minimum of the loss. Despite good apparent -convergence, $\hat{\theta}$ might be located in a region with flat curvature or -close to a saddle point. In particular, the Hessian might have vanishing -eigenvalues making its direct inversion impossible. +Hessian regularization +^^^^^^^^^^^^^^^^^^^^^^ +Additionally, and as discussed in :ref:`the introduction +`, in machine learning training rarely converges to a +global minimum of the loss. Despite good apparent convergence, $\hat{\theta}$ +might be located in a region with flat curvature or close to a saddle point. In +particular, the Hessian might have vanishing eigenvalues making its direct +inversion impossible. To circumvent this problem, many approximate methods are available. The simplest -adds a small *hessian perturbation term*, i.e. we invert $H_{\hat{\theta}} + -\lambda \mathbb{I}$, with $\mathbb{I}$ being the identity matrix. This standard -trick ensures that the eigenvalues of $H_{\hat{\theta}}$ are bounded away from -zero and therefore the matrix is invertible. In order for this regularization -not to corrupt the outcome too much, the parameter $\lambda$ should be as small -as possible while still allowing a reliable inversion of $H_{\hat{\theta}} + +adds a small *hessian perturbation term*, i.e. $H_{\hat{\theta}} + \lambda +\mathbb{I}$, with $\mathbb{I}$ being the identity matrix. This standard trick +ensures that the eigenvalues of $H_{\hat{\theta}}$ are bounded away from zero +and therefore the matrix is invertible. In order for this regularization not to +corrupt the outcome too much, the parameter $\lambda$ should be as small as +possible while still allowing a reliable inversion of $H_{\hat{\theta}} + \lambda \mathbb{I}$. .. code-block:: python @@ -241,6 +279,29 @@ as possible while still allowing a reliable inversion of $H_{\hat{\theta}} + ... hessian_regularization=1e-4 ... ) +Influence factors +^^^^^^^^^^^^^^^^^ +The :func:`~pydvl.influence.general.compute_influences` method offers a fast way +to obtain the influence scores given a model and a dataset. Nevertheless, it is +often more convenient to inspect and save some of the intermediate results of +influence calculation for later use. + +The influence factors(refer to :ref:`the previous paragraph +` for a definition) are typically the most +computationally demanding part of influence calculation. They can be obtained +via the :func:`~pydvl.influence.general.compute_influence_factors` method, +saved, and later used for influence calculation on different subsets of the +training dataset. + +.. code-block:: python + + >>> from pydvl.influence import compute_influence_factors + >>> compute_influence_factors( + ... model, + ... training_data_loader, + ... test_data_loader, + ... inversion_method="cg" + ... ) Perturbation influences ^^^^^^^^^^^^^^^^^^^^^^^ From 5cabf4b1159e31d2523ef0efa071966cb839a7e4 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Sun, 30 Jul 2023 15:48:38 +0200 Subject: [PATCH 207/436] fix typing --- src/pydvl/influence/frameworks/torch_differentiable.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index f8224f69c..175166702 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -493,7 +493,7 @@ def solve_arnoldi( tol: float = 1e-6, max_iter: Optional[int] = None, eigen_computation_on_gpu: bool = False, -) -> torch.Tensor: +) -> iHVPResult: """ Solves the linear system Hx = b, where H is the Hessian of the model's loss function and b is the given right-hand From a4f22e710bf27115e60d3064b9d8600bb0ab25dc Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Sun, 30 Jul 2023 16:12:19 +0200 Subject: [PATCH 208/436] fix path in notebook support --- notebooks/support/shapley.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks/support/shapley.py b/notebooks/support/shapley.py index 5c6c88112..f471e70e2 100644 --- a/notebooks/support/shapley.py +++ b/notebooks/support/shapley.py @@ -29,7 +29,7 @@ def load_spotify_dataset( :param random_state: fixes sklearn random seed :return: Tuple with 3 elements, each being a list sith [input_data, related_labels] """ - root_dir_path = Path(__file__).parent.parent.parent.parent + root_dir_path = Path(__file__).parent.parent.parent file_path = root_dir_path / "data/top_hits_spotify_dataset.csv" if file_path.exists(): data = pd.read_csv(file_path) From d3b3b35aad96bc7793f35e6a17ad6f5032a27130 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Sun, 30 Jul 2023 18:10:36 +0200 Subject: [PATCH 209/436] WIP docs --- docs/40-influence.rst | 65 +++++++++++++++++++++++++++++-------------- 1 file changed, 44 insertions(+), 21 deletions(-) diff --git a/docs/40-influence.rst b/docs/40-influence.rst index caad00016..be190ce67 100644 --- a/docs/40-influence.rst +++ b/docs/40-influence.rst @@ -211,6 +211,29 @@ tends to improve the performance of the model on test point $i$, and vice versa, a large negative influence indicates that training point $j$ tends to worsen the performance of the model on test point $i$. +Perturbation influences +^^^^^^^^^^^^^^^^^^^^^^^ + +The method of empirical influence computation can be selected in +:func:`~pydvl.influence.general.compute_influences` with the parameter +`influence_type`: + +.. code-block:: python + + >>> from pydvl.influence import compute_influences + >>> compute_influences( + ... model, + ... training_data_loader, + ... test_data_loader, + ... influence_type="perturbation", + ... ) + +The result is a tensor with at least three dimensions. The first two dimensions +are the same as in the case of `influence_type=up` case, i.e. one row per test +point and one column per training point. The remaining dimensions are the same +as the number of input features in the data. Therefore, each entry in the tensor +represents the influence of each feature of each training point on each test +point. Approximate matrix inversion ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -218,8 +241,7 @@ Approximate matrix inversion In almost every practical application it is not possible to construct, even less invert the complete Hessian in memory. pyDVL offers several approximate algorithms to invert it by setting the parameter `inversion_method` of -:func:`~pydvl.influence.general.compute_influences`. See the documentation for -allowed values. +:func:`~pydvl.influence.general.compute_influences`. .. code-block:: python @@ -231,8 +253,8 @@ allowed values. ... inversion_method="cg" ... ) -Each method has its own set of parameters that can be tuned to improve the final -result. These parameters can be passed directly to +Each inversion method has its own set of parameters that can be tuned to improve +the final result. These parameters can be passed directly to :func:`~pydvl.influence.general.compute_influences` as keyword arguments. For example, the following code sets the maximum number of iterations for conjugate gradient to $100$ and the miximum relative error to $0.01$: @@ -257,9 +279,10 @@ Additionally, and as discussed in :ref:`the introduction global minimum of the loss. Despite good apparent convergence, $\hat{\theta}$ might be located in a region with flat curvature or close to a saddle point. In particular, the Hessian might have vanishing eigenvalues making its direct -inversion impossible. +inversion impossible. Certain methods, such as the :ref:`Arnoldi method +` are robust against these problems, but most are not. -To circumvent this problem, many approximate methods are available. The simplest +To circumvent this problem, many approximate methods can be implemented. The simplest adds a small *hessian perturbation term*, i.e. $H_{\hat{\theta}} + \lambda \mathbb{I}$, with $\mathbb{I}$ being the identity matrix. This standard trick ensures that the eigenvalues of $H_{\hat{\theta}}$ are bounded away from zero @@ -296,30 +319,30 @@ training dataset. .. code-block:: python >>> from pydvl.influence import compute_influence_factors - >>> compute_influence_factors( + >>> influence_factors = compute_influence_factors( ... model, ... training_data_loader, ... test_data_loader, ... inversion_method="cg" ... ) -Perturbation influences -^^^^^^^^^^^^^^^^^^^^^^^ +The result is an object of type :class:`~pydvl.influence.framework.iHVPResult`, +which holds the calculated influence factors (`influence_factors.x`) and a +dictionary with the info on the inversion process (`influence_factors.info`). -The method of empirical influence computation can be selected in -:func:`~pydvl.influence.general.compute_influences` with the parameter -`influence_type`: +.. _methods_for_inverse_hessian_vector_product_calculation: -.. code-block:: python +Methods for inverse Hessian-vector product calculation +------------------------------------------------------ - >>> from pydvl.influence import compute_influences - >>> compute_influences( - ... model, - ... training_data_loader, - ... test_data_loader, - ... influence_type="perturbation", - ... inversion_method="lissa" - ... ) +Something about iHVP methods. + +.. _arnoldi_solver: +Arnoldi solver +^^^^^^^^^^^^^^ +The Arnoldi method is a Krylov subspace method for approximating the action of a +matrix on a vector. It is a generalization of the power method for finding +eigenvectors of a matrix. .. footbibliography:: From f6c5b157c422b5c5fba08e242b2a6589b3e2d688 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Mon, 31 Jul 2023 02:13:06 +0200 Subject: [PATCH 210/436] first draft of IF docs --- docs/40-influence.rst | 75 +++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 72 insertions(+), 3 deletions(-) diff --git a/docs/40-influence.rst b/docs/40-influence.rst index be190ce67..892dd5c33 100644 --- a/docs/40-influence.rst +++ b/docs/40-influence.rst @@ -332,10 +332,79 @@ dictionary with the info on the inversion process (`influence_factors.info`). .. _methods_for_inverse_hessian_vector_product_calculation: -Methods for inverse Hessian-vector product calculation ------------------------------------------------------- +Methods for inverse HVP calculation +----------------------------------- -Something about iHVP methods. +In order to calculate influence values, pydvl implements several methods for the +calculation of the inverse Hessian vector product (iHVP). More precisely, given +a model, training data and a tensor $b$, the function +:func:`~pydvl.influence.inversion.solve_hvp` will find $x$ such that $H x = b$, +with $H$ is the hessian of model. + +Many different inversion methods can be selected selected via the parameter +`inversion_method` of :func:`~pydvl.influence.general.compute_influences`. +The following paragraphs will offer more detailed exaple of each method. + + +.. _direct_inversion: + +Direct inversion +^^^^^^^^^^^^^^^^ + +With `inversion_method = "direct"` pyDVL will calculate the inverse Hessian +using the direct matrix inversion. This means that the Hessian will first be +explicitly created and then inverted. This method is the most accurate, but also +the most computationally demanding. It is therefore not recommended for large +datasets or models with many parameters. + +.. code-block:: python + + >>> from pydvl.influence.inversion import solve_hvp + >>> solve_hvp( + ... inversion_method="direct", + ... model, + ... training_data_loader, + ... b, + ... ) + +The result, an object of type :class:`~pydvl.influence.framework.iHVPResult`, +which holds two objects: `influence_factors.x` and `influence_factors.info`. The +first one is the inverse Hessian vector product, while the second one is a +dictionary with the info on the inversion process. For this method, the info +consists of the Hessian matrix itself. + +.. _conjugate_gradient: + +Conjugate Gradient +^^^^^^^^^^^^^^^^^^ + +A classical method for solving linear systems of equations is the conjugate +gradient method. It is an iterative method that does not require the explicit +inversion of the Hessian matrix. Instead, it only requires the calculation of +the Hessian vector product. This makes it a good choice for large datasets or +models with many parameters. It is Nevertheless much slower than the direct +inversion method and not as accurate. More info on the theory of conjugate +gradient can be found +`here `_ + +In pyDVL, you can select conjugate gradient with `inversion_method = "cg"`, like +this: + +.. code-block:: python + + >>> from pydvl.influence.inversion import solve_hvp + >>> solve_hvp( + ... inversion_method="cg", + ... model, + ... training_data_loader, + ... b, + ... ) + +The resulting :class:`~pydvl.influence.framework.iHVPResult` holds the solution +of the iHVP, `influence_factors.x`, and some info on the inversion process +`influence_factors.info`. More specifically, for each batch the infos will +report the number of iterations, a boolean indicating if the inversion +converged, and the residual of the inversion. .. _arnoldi_solver: From 3929e8465c09d4e01610ccb2590b47a518d8809a Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Mon, 31 Jul 2023 09:32:13 +0200 Subject: [PATCH 211/436] add typing and lissa --- docs/40-influence.rst | 114 +++++++++++++----- docs/pydvl.bib | 11 ++ .../frameworks/torch_differentiable.py | 3 +- 3 files changed, 99 insertions(+), 29 deletions(-) diff --git a/docs/40-influence.rst b/docs/40-influence.rst index 892dd5c33..c0f8bc0f7 100644 --- a/docs/40-influence.rst +++ b/docs/40-influence.rst @@ -198,10 +198,11 @@ each test point can be calculated via: .. code-block:: python >>> from pydvl.influence import influences + >>> from torch.utils.data import DataLoader >>> compute_influences( - ... model, - ... training_data_loader, - ... test_data_loader + ... model: TorchTwiceDifferentiable, + ... training_data_loader: DataLoader, + ... test_data_loader: DataLoader, ... ) The result is a tensor with one row per test point and one column per training @@ -222,9 +223,9 @@ The method of empirical influence computation can be selected in >>> from pydvl.influence import compute_influences >>> compute_influences( - ... model, - ... training_data_loader, - ... test_data_loader, + ... model: TorchTwiceDifferentiable, + ... training_data_loader: DataLoader, + ... test_data_loader: DataLoader, ... influence_type="perturbation", ... ) @@ -247,9 +248,9 @@ algorithms to invert it by setting the parameter `inversion_method` of >>> from pydvl.influence import compute_influences >>> compute_influences( - ... model, - ... training_data_loader, - ... test_data_loader, + ... model: TorchTwiceDifferentiable, + ... training_data_loader: DataLoader, + ... test_data_loader: DataLoader, ... inversion_method="cg" ... ) @@ -263,9 +264,9 @@ gradient to $100$ and the miximum relative error to $0.01$: >>> from pydvl.influence import compute_influences >>> compute_influences( - ... model, - ... training_data_loader, - ... test_data_loader, + ... model: TorchTwiceDifferentiable, + ... training_data_loader: DataLoader, + ... test_data_loader: DataLoader, ... inversion_method="cg", ... hessian_regularization=1e-4, ... maxiter=100, @@ -295,9 +296,9 @@ possible while still allowing a reliable inversion of $H_{\hat{\theta}} + >>> from pydvl.influence import compute_influences >>> compute_influences( - ... model, - ... training_data_loader, - ... test_data_loader, + ... model: TorchTwiceDifferentiable, + ... training_data_loader: DataLoader, + ... test_data_loader: DataLoader, ... inversion_method="cg", ... hessian_regularization=1e-4 ... ) @@ -320,9 +321,9 @@ training dataset. >>> from pydvl.influence import compute_influence_factors >>> influence_factors = compute_influence_factors( - ... model, - ... training_data_loader, - ... test_data_loader, + ... model: TorchTwiceDifferentiable, + ... training_data_loader: DataLoader, + ... test_data_loader: DataLoader, ... inversion_method="cg" ... ) @@ -362,9 +363,9 @@ datasets or models with many parameters. >>> from pydvl.influence.inversion import solve_hvp >>> solve_hvp( ... inversion_method="direct", - ... model, - ... training_data_loader, - ... b, + ... model: TorchTwiceDifferentiable, + ... training_data_loader: DataLoader, + ... b: torch.Tensor, ... ) The result, an object of type :class:`~pydvl.influence.framework.iHVPResult`, @@ -395,16 +396,73 @@ this: >>> from pydvl.influence.inversion import solve_hvp >>> solve_hvp( ... inversion_method="cg", - ... model, - ... training_data_loader, - ... b, + ... mode: TorchTwiceDifferentiable, + ... training_data_loader: DataLoader, + ... b: torch.Tensor, + ... x0: Optional[torch.Tensor] = None, + ... rtol: float = 1e-7, + ... atol: float = 1e-7, + ... maxiter: Optional[int] = None, ... ) +The addinal optional parameters `x0`, `rtol`, `atol`, and `maxiter` are passed +to the :func:`~pydvl.influence.frameworks.torch_differentiable.solve_batch_cg` +function, and are respecively the initial guess for the solution, the relative +tolerance, the absolute tolerance, and the maximum number of iterations. + +The resulting :class:`~pydvl.influence.framework.iHVPResult` +holds the solution of the iHVP, `influence_factors.x`, and some info on the +inversion process `influence_factors.info`. More specifically, for each batch +the infos will report the number of iterations, a boolean indicating if the +inversion converged, and the residual of the inversion. + +.. _lissa_solver: + +Linear time Stochastic Second-Order Approximation (LiSSA) +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +The LiSSA method is a stochastic approximation of the inverse Hessian vector +product. Compared to :ref:`conjugate gradient +` it is faster but less accurate and typically suffers from +instability. + +In order to find the solution of the HVP, LiSSA iteratively approximates the +inverse of the Hessian matrix with the following update: + +$$H^{-1}_{j+1} b = b + (I - d) \ H - \frac{H^{-1}_j b}{s},$$ + +where $d$ and $s$ are a dampening and a scaling factor, which are essential +for the convergence of the method and they need to be chosen carefully, and I +is the identity matrix. More info on the theory of LiSSA can be found in the +original paper :footcite:t:`agarwal_2017_second`. + +In pyDVL, you can select LiSSA with `inversion_method = "lissa"`, like this: + +.. code-block:: python + + >>> from pydvl.influence.inversion import solve_hvp + >>> solve_hvp( + ... inversion_method="lissa", + ... model: TorchTwiceDifferentiable, + ... training_data_loader: DataLoader, + ... b: torch.Tensor, + ... maxiter: int = 1000, + ... dampen: float = 0.0, + ... scale: float = 10.0, + ... h0: Optional[torch.Tensor] = None, + ... rtol: float = 1e-4, + ... ) + +with the additional optional parameters `maxiter`, `dampen`, `scale`, `h0`, and +`rtol`, which are passed to the +:func:`~pydvl.influence.frameworks.torch_differentiable.solve_lissa` function, +being the maximum number of iterations, the dampening factor, the scaling +factor, the initial guess for the solution and the relative tolerance, +respectively. + The resulting :class:`~pydvl.influence.framework.iHVPResult` holds the solution -of the iHVP, `influence_factors.x`, and some info on the inversion process -`influence_factors.info`. More specifically, for each batch the infos will -report the number of iterations, a boolean indicating if the inversion -converged, and the residual of the inversion. +of the iHVP, `influence_factors.x`, and, within `influence_factors.info`, the +maximum percentage error and the mean percentage error of the approximation. + .. _arnoldi_solver: diff --git a/docs/pydvl.bib b/docs/pydvl.bib index 45b6a8911..1d2c6d210 100644 --- a/docs/pydvl.bib +++ b/docs/pydvl.bib @@ -218,3 +218,14 @@ @inproceedings{yan_if_2021 langid = {english}, keywords = {notion} } + +@article{agarwal_2017_second, + title={Second-order stochastic optimization for machine learning in linear time}, + author={Agarwal, Naman and Bullins, Brian and Hazan, Elad}, + journal={The Journal of Machine Learning Research}, + volume={18}, + number={1}, + pages={4148--4187}, + year={2017}, + publisher={JMLR. org} +} diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 175166702..8ae7e711d 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -211,7 +211,8 @@ def solve_lissa( where $I$ is the identity matrix, $d$ is a dampening term and $s$ a scaling factor that are applied to help convergence. For details, see - :footcite:t:`koh_understanding_2017`. + :footcite:t:`koh_understanding_2017` and the original paper + :footcite:t:`agarwal_2017_second`. :param model: A model wrapped in the TwiceDifferentiable interface. :param training_data: A DataLoader containing the training data. From f26e7353cde30e851e6f3581d1b9a3c0285c5efd Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 1 Aug 2023 08:44:20 +0200 Subject: [PATCH 212/436] update changelog --- CHANGELOG.md | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9448b3e14..1051a392a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,9 +2,12 @@ ## Unreleased -- Optimises memory usage in IF calculation and returns infor about hessian - inversion to compute_influence_factors - [PR #375](https://github.com/appliedAI-Initiative/pyDVL/pull/375) +- Optimises memory usage in IF calculation + [PR #375](https://github.com/appliedAI-Initiative/pyDVL/pull/376) +- **Breaking Changes** + Returns information about hessian inversion to compute_influence_factors, + thus changing signature + [PR #375](https://github.com/appliedAI-Initiative/pyDVL/pull/376) - Fix adding valuation results with overlapping indices and different lengths [PR #370](https://github.com/appliedAI-Initiative/pyDVL/pull/370) - Fixed bugs in conjugate gradient and `linear_solve` From ea766c4df913d22ffcf241efb9da0ba307113bc0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Tue, 1 Aug 2023 11:19:41 +0200 Subject: [PATCH 213/436] Refactor tests_influences: * use dataclasses for test case definition * make test deterministic --- tests/influence/test_influences.py | 248 +++++++++++++++++++---------- 1 file changed, 161 insertions(+), 87 deletions(-) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index d9653d097..26cb67584 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -1,4 +1,5 @@ -from typing import Dict, Tuple +from dataclasses import dataclass +from typing import Callable, Dict, Tuple import numpy as np import pytest @@ -157,63 +158,122 @@ def test_influence_linear_model( ) -conv3d_nn = nn.Sequential( - nn.Conv3d(in_channels=5, out_channels=3, kernel_size=2), - nn.Flatten(), - nn.Linear(24, 3), -) -conv2d_nn = nn.Sequential( - nn.Conv2d(in_channels=5, out_channels=3, kernel_size=3), - nn.Flatten(), - nn.Linear(27, 3), -) -conv1d_nn = nn.Sequential( - nn.Conv1d(in_channels=5, out_channels=3, kernel_size=2), - nn.Flatten(), - nn.Linear(6, 3), -) -simple_nn_regr = nn.Sequential(nn.Linear(10, 10), nn.Linear(10, 3), nn.Linear(3, 1)) - -test_cases = { - "conv3d_nn_up": [ - conv3d_nn, - (5, 3, 3, 3), - 3, - nn.MSELoss(), - InfluenceType.Up, - ], - "conv3d_nn_pert": [ - conv3d_nn, - (5, 3, 3, 3), - 3, - nn.SmoothL1Loss(), - InfluenceType.Perturbation, - ], - "conv_2d_nn_up": [conv2d_nn, (5, 5, 5), 3, nn.MSELoss(), InfluenceType.Up], - "conv_2d_nn_pert": [ - conv2d_nn, - (5, 5, 5), - 3, - nn.SmoothL1Loss(), - InfluenceType.Perturbation, - ], - "conv_1d_nn_up": [conv1d_nn, (5, 3), 3, nn.MSELoss(), InfluenceType.Up], - "conv_1d_pert": [ - conv1d_nn, - (5, 3), - 3, - nn.SmoothL1Loss(), - InfluenceType.Perturbation, - ], - "simple_nn_up": [simple_nn_regr, (10,), 1, nn.MSELoss(), InfluenceType.Up], - "simple_nn_pert": [ - simple_nn_regr, - (10,), - 1, - nn.SmoothL1Loss(), - InfluenceType.Perturbation, - ], -} +@pytest.fixture(scope="function") +def deterministic_seed(): + torch.manual_seed(31) + np.random.seed(31) + torch.use_deterministic_algorithms(True) + + +def create_conv3d_nn(): + return nn.Sequential( + nn.Conv3d(in_channels=5, out_channels=3, kernel_size=2), + nn.Flatten(), + nn.Linear(24, 3), + ) + + +def create_conv2d_nn(): + return nn.Sequential( + nn.Conv2d(in_channels=5, out_channels=3, kernel_size=3), + nn.Flatten(), + nn.Linear(27, 3), + ) + + +def create_conv1d_nn(): + return nn.Sequential( + nn.Conv1d(in_channels=5, out_channels=3, kernel_size=2), + nn.Flatten(), + nn.Linear(6, 3), + ) + + +def create_simple_nn_regr(): + return nn.Sequential(nn.Linear(10, 10), nn.Linear(10, 3), nn.Linear(3, 1)) + + +@dataclass +class TestCase: + case_id: str + module_factory: Callable[[], nn.Module] + input_dim: Tuple[int, ...] + output_dim: int + loss: nn.modules.loss._Loss + influence_type: InfluenceType + + +@pytest.fixture +def test_case(request): + return request.param + + +test_cases = [ + TestCase( + case_id="conv3d_nn_up", + module_factory=create_conv3d_nn, + input_dim=(5, 3, 3, 3), + output_dim=3, + loss=nn.MSELoss(), + influence_type=InfluenceType.Up, + ), + TestCase( + case_id="conv3d_nn_pert", + module_factory=create_conv3d_nn, + input_dim=(5, 3, 3, 3), + output_dim=3, + loss=nn.SmoothL1Loss(), + influence_type=InfluenceType.Perturbation, + ), + TestCase( + case_id="conv2d_nn_up", + module_factory=create_conv2d_nn, + input_dim=(5, 5, 5), + output_dim=3, + loss=nn.MSELoss(), + influence_type=InfluenceType.Up, + ), + TestCase( + case_id="conv2d_nn_pert", + module_factory=create_conv2d_nn, + input_dim=(5, 5, 5), + output_dim=3, + loss=nn.SmoothL1Loss(), + influence_type=InfluenceType.Perturbation, + ), + TestCase( + case_id="conv1d_nn_up", + module_factory=create_conv1d_nn, + input_dim=(5, 3), + output_dim=3, + loss=nn.MSELoss(), + influence_type=InfluenceType.Up, + ), + TestCase( + case_id="conv1d_nn_pert", + module_factory=create_conv1d_nn, + input_dim=(5, 3), + output_dim=3, + loss=nn.SmoothL1Loss(), + influence_type=InfluenceType.Perturbation, + ), + TestCase( + case_id="simple_nn_up", + module_factory=create_simple_nn_regr, + input_dim=(10,), + output_dim=1, + loss=nn.MSELoss(), + influence_type=InfluenceType.Up, + ), + TestCase( + case_id="simple_nn_pert", + module_factory=create_simple_nn_regr, + input_dim=(10,), + output_dim=1, + loss=nn.SmoothL1Loss(), + influence_type=InfluenceType.Perturbation, + ), +] def create_random_data_loader( @@ -221,7 +281,6 @@ def create_random_data_loader( output_dim: int, data_len: int, batch_size: int = 1, - random_seed: int = 31, ) -> DataLoader: """ Creates DataLoader instances with random data for testing purposes. @@ -230,11 +289,9 @@ def create_random_data_loader( :param output_dim: The dimension of the output data. :param data_len: The length of the training dataset to be generated. :param batch_size: The size of the batches to be used in the DataLoader. - :param random_seed: The seed for the random number generator. Defaults to 31. :return: DataLoader instances for data. """ - torch.manual_seed(random_seed) x = torch.rand((data_len, *input_dim)) y = torch.rand((data_len, output_dim)) @@ -256,33 +313,37 @@ def create_random_data_loader( ], ) @pytest.mark.parametrize( - "nn_architecture, input_dim, output_dim, loss, influence_type", - test_cases.values(), - ids=test_cases.keys(), + "test_case", + test_cases, + ids=[case.case_id for case in test_cases], + indirect=["test_case"], ) def test_influences_nn( - nn_architecture: nn.Module, - input_dim: Tuple[int], - output_dim: int, - loss: nn.modules.loss._Loss, - influence_type: InfluenceType, + test_case: TestCase, inversion_method: InversionMethod, inversion_method_kwargs: Dict, + deterministic_seed, data_len: int = 20, hessian_reg: float = 1e3, test_data_len: int = 10, batch_size: int = 10, ): + module_factory = test_case.module_factory + input_dim = test_case.input_dim + output_dim = test_case.output_dim + loss = test_case.loss + influence_type = test_case.influence_type train_data_loader = create_random_data_loader( - input_dim, output_dim, data_len, batch_size, random_seed=18 + input_dim, output_dim, data_len, batch_size ) test_data_loader = create_random_data_loader( - input_dim, output_dim, test_data_len, batch_size, random_seed=19 + input_dim, output_dim, test_data_len, batch_size ) - nn_architecture.eval() - model = TorchTwiceDifferentiable(nn_architecture, loss, device=torch.device("cpu")) + model = module_factory() + model.eval() + model = TorchTwiceDifferentiable(model, loss, device=torch.device("cpu")) direct_influence = compute_influences( model, @@ -357,27 +418,28 @@ def closure(): @pytest.mark.torch @pytest.mark.parametrize( - "nn_architecture, input_dim, output_dim, loss, influence_type", - test_cases.values(), - ids=test_cases.keys(), + "test_case", + test_cases, + ids=[case.case_id for case in test_cases], + indirect=["test_case"], ) def test_influences_arnoldi( - nn_architecture: nn.Module, - input_dim: Tuple[int], - output_dim: int, - loss: nn.modules.loss._Loss, - influence_type: InfluenceType, + test_case: TestCase, + deterministic_seed, data_len: int = 20, hessian_reg: float = 20.0, test_data_len: int = 10, ): - train_data_loader = create_random_data_loader( - input_dim, output_dim, data_len, random_seed=31 - ) - test_data_loader = create_random_data_loader( - input_dim, output_dim, test_data_len, random_seed=42 - ) + module_factory = test_case.module_factory + input_dim = test_case.input_dim + output_dim = test_case.output_dim + loss = test_case.loss + influence_type = test_case.influence_type + train_data_loader = create_random_data_loader(input_dim, output_dim, data_len) + test_data_loader = create_random_data_loader(input_dim, output_dim, test_data_len) + + nn_architecture = module_factory() nn_architecture = minimal_training( nn_architecture, train_data_loader, loss, lr=0.3, epochs=100 ) @@ -413,3 +475,15 @@ def test_influences_arnoldi( ) assert np.allclose(direct_influence, low_rank_influence, rtol=1e-1) + + +@pytest.mark.torch +@pytest.mark.parametrize("run", [1, 2]) +def test_deterministic_seed(deterministic_seed, run): + x = torch.rand((5, 5)) + if run == 1: + test_deterministic_seed.x1 = x.clone() # store the result from the first run + else: + assert torch.allclose( + test_deterministic_seed.x1, x + ) # compare with the result from the first run From f9d2d32e61c5e85c557407e296abce89fde3c6a1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Tue, 1 Aug 2023 11:31:38 +0200 Subject: [PATCH 214/436] Make test_influence_linear_model deterministic --- tests/influence/test_influences.py | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 26cb67584..ada79b817 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -78,6 +78,13 @@ def analytical_linear_influences( return result +@pytest.fixture(scope="function") +def deterministic_seed(): + torch.manual_seed(31) + np.random.seed(31) + torch.use_deterministic_algorithms(True) + + @pytest.mark.torch @pytest.mark.parametrize( "influence_type", @@ -104,6 +111,7 @@ def test_influence_linear_model( inversion_method_kwargs: Dict, rtol: float, train_set_size: int, + deterministic_seed, hessian_reg: float = 0.1, test_set_size: int = 20, problem_dimension: Tuple[int, int] = (4, 20), @@ -158,13 +166,6 @@ def test_influence_linear_model( ) -@pytest.fixture(scope="function") -def deterministic_seed(): - torch.manual_seed(31) - np.random.seed(31) - torch.use_deterministic_algorithms(True) - - def create_conv3d_nn(): return nn.Sequential( nn.Conv3d(in_channels=5, out_channels=3, kernel_size=2), From 8a556642ded8d6665d7c953c8b37e4148926ab26 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Tue, 1 Aug 2023 14:16:14 +0200 Subject: [PATCH 215/436] Refactor testing: * Remove deterministic_seed in favour of existing pytorch_seed o * add torch.use_automatic_algorithsm to pytorch_seed * remove obsolete test related to torch functionality --- tests/conftest.py | 1 + tests/influence/test_influences.py | 22 ---------------------- 2 files changed, 1 insertion(+), 22 deletions(-) diff --git a/tests/conftest.py b/tests/conftest.py index 97b44ec92..855e112dd 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -72,6 +72,7 @@ def pytorch_seed(seed): import torch torch.manual_seed(seed) + torch.use_deterministic_algorithms(True, warn_only=True) except ImportError: pass diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index ada79b817..9ffca5eca 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -78,13 +78,6 @@ def analytical_linear_influences( return result -@pytest.fixture(scope="function") -def deterministic_seed(): - torch.manual_seed(31) - np.random.seed(31) - torch.use_deterministic_algorithms(True) - - @pytest.mark.torch @pytest.mark.parametrize( "influence_type", @@ -111,7 +104,6 @@ def test_influence_linear_model( inversion_method_kwargs: Dict, rtol: float, train_set_size: int, - deterministic_seed, hessian_reg: float = 0.1, test_set_size: int = 20, problem_dimension: Tuple[int, int] = (4, 20), @@ -323,7 +315,6 @@ def test_influences_nn( test_case: TestCase, inversion_method: InversionMethod, inversion_method_kwargs: Dict, - deterministic_seed, data_len: int = 20, hessian_reg: float = 1e3, test_data_len: int = 10, @@ -426,7 +417,6 @@ def closure(): ) def test_influences_arnoldi( test_case: TestCase, - deterministic_seed, data_len: int = 20, hessian_reg: float = 20.0, test_data_len: int = 10, @@ -476,15 +466,3 @@ def test_influences_arnoldi( ) assert np.allclose(direct_influence, low_rank_influence, rtol=1e-1) - - -@pytest.mark.torch -@pytest.mark.parametrize("run", [1, 2]) -def test_deterministic_seed(deterministic_seed, run): - x = torch.rand((5, 5)) - if run == 1: - test_deterministic_seed.x1 = x.clone() # store the result from the first run - else: - assert torch.allclose( - test_deterministic_seed.x1, x - ) # compare with the result from the first run From 2d97bccd03f67fb66eae853217d78389a2b75fdf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Tue, 1 Aug 2023 14:53:44 +0200 Subject: [PATCH 216/436] [skip ci] Add TODO for splitting up a fixture --- tests/conftest.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/conftest.py b/tests/conftest.py index 855e112dd..41244d275 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -72,6 +72,7 @@ def pytorch_seed(seed): import torch torch.manual_seed(seed) + # TODO if necessary extract this into a separate fixture torch.use_deterministic_algorithms(True, warn_only=True) except ImportError: pass From df3fcb16c555d869b77e09897b8e28c539aee1d4 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 4 Aug 2023 11:55:41 +0200 Subject: [PATCH 217/436] changing name of ihvp result, adding iter unpacking, freezing dataclass --- docs/40-influence.rst | 8 +++--- src/pydvl/influence/frameworks/__init__.py | 4 +-- .../frameworks/torch_differentiable.py | 28 +++++++++---------- .../frameworks/twice_differentiable.py | 19 ++++--------- src/pydvl/influence/general.py | 8 +++--- src/pydvl/influence/inversion.py | 4 +-- tests/influence/test_torch_differentiable.py | 12 ++++---- 7 files changed, 39 insertions(+), 44 deletions(-) diff --git a/docs/40-influence.rst b/docs/40-influence.rst index c0f8bc0f7..f68491352 100644 --- a/docs/40-influence.rst +++ b/docs/40-influence.rst @@ -327,7 +327,7 @@ training dataset. ... inversion_method="cg" ... ) -The result is an object of type :class:`~pydvl.influence.framework.iHVPResult`, +The result is an object of type :class:`~pydvl.influence.framework.IhvpResult`, which holds the calculated influence factors (`influence_factors.x`) and a dictionary with the info on the inversion process (`influence_factors.info`). @@ -368,7 +368,7 @@ datasets or models with many parameters. ... b: torch.Tensor, ... ) -The result, an object of type :class:`~pydvl.influence.framework.iHVPResult`, +The result, an object of type :class:`~pydvl.influence.framework.IhvpResult`, which holds two objects: `influence_factors.x` and `influence_factors.info`. The first one is the inverse Hessian vector product, while the second one is a dictionary with the info on the inversion process. For this method, the info @@ -410,7 +410,7 @@ to the :func:`~pydvl.influence.frameworks.torch_differentiable.solve_batch_cg` function, and are respecively the initial guess for the solution, the relative tolerance, the absolute tolerance, and the maximum number of iterations. -The resulting :class:`~pydvl.influence.framework.iHVPResult` +The resulting :class:`~pydvl.influence.framework.IhvpResult` holds the solution of the iHVP, `influence_factors.x`, and some info on the inversion process `influence_factors.info`. More specifically, for each batch the infos will report the number of iterations, a boolean indicating if the @@ -459,7 +459,7 @@ being the maximum number of iterations, the dampening factor, the scaling factor, the initial guess for the solution and the relative tolerance, respectively. -The resulting :class:`~pydvl.influence.framework.iHVPResult` holds the solution +The resulting :class:`~pydvl.influence.framework.IhvpResult` holds the solution of the iHVP, `influence_factors.x`, and, within `influence_factors.info`, the maximum percentage error and the mean percentage error of the approximation. diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index fdf2612f5..ef2eb0d0f 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -4,7 +4,7 @@ import logging -from .twice_differentiable import TwiceDifferentiable, iHVPResult +from .twice_differentiable import IhvpResult, TwiceDifferentiable __all__ = ["TwiceDifferentiable"] logger = logging.getLogger("frameworks") @@ -37,7 +37,7 @@ [ "TensorType", "ModelType", - "iHVPResult", + "IhvpResult", "solve_linear", "solve_batch_cg", "solve_lissa", diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 8ae7e711d..d5389b080 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -20,7 +20,7 @@ from ...utils import maybe_progress from .functional import get_hvp_function -from .twice_differentiable import TwiceDifferentiable, iHVPResult +from .twice_differentiable import IhvpResult, TwiceDifferentiable from .util import align_structure, flatten_tensors_to_vector __all__ = [ @@ -55,7 +55,7 @@ def solve_linear( *, hessian_perturbation: float = 0.0, progress: bool = False, -) -> iHVPResult: +) -> IhvpResult: """Given a model and training data, it finds x s.t. $Hx = b$, with $H$ being the model hessian. @@ -81,7 +81,7 @@ def solve_linear( model.num_params, device=model.device ) info = {"hessian": hessian} - return iHVPResult(x=torch.linalg.solve(matrix, b.T).T, info=info) + return IhvpResult(x=torch.linalg.solve(matrix, b.T).T, info=info) def solve_batch_cg( @@ -95,7 +95,7 @@ def solve_batch_cg( atol: float = 1e-7, maxiter: Optional[int] = None, progress: bool = False, -) -> iHVPResult: +) -> IhvpResult: """ Given a model and training data, it uses conjugate gradient to calculate the inverse of the Hessian Vector Product. More precisely, it finds x s.t. $Hx = @@ -129,12 +129,12 @@ def solve_batch_cg( batch_cg = torch.zeros_like(b) info = {} for idx, bi in enumerate(maybe_progress(b, progress, desc="Conjugate gradient")): - batch_result = solve_cg( + batch_result, batch_info = solve_cg( reg_hvp, bi, x0=x0, rtol=rtol, atol=atol, maxiter=maxiter ) - batch_cg[idx] = batch_result.x - info[f"batch_{idx}"] = batch_result.info - return iHVPResult(x=batch_cg, info=info) + batch_cg[idx] = batch_result + info[f"batch_{idx}"] = batch_info + return IhvpResult(x=batch_cg, info=info) def solve_cg( @@ -145,7 +145,7 @@ def solve_cg( rtol: float = 1e-7, atol: float = 1e-7, maxiter: Optional[int] = None, -) -> iHVPResult: +) -> IhvpResult: """Conjugate gradient solver for the Hessian vector product :param hvp: a Callable Hvp, operating with tensors of size N @@ -185,7 +185,7 @@ def solve_cg( p = r + beta * p info = {"niter": k, "optimal": optimal, "gamma": gamma} - return iHVPResult(x=x, info=info) + return IhvpResult(x=x, info=info) def solve_lissa( @@ -200,7 +200,7 @@ def solve_lissa( h0: Optional[torch.Tensor] = None, rtol: float = 1e-4, progress: bool = False, -) -> iHVPResult: +) -> IhvpResult: r""" Uses LISSA, Linear time Stochastic Second-Order Algorithm, to iteratively approximate the inverse Hessian. More precisely, it finds x s.t. $Hx = b$, @@ -267,7 +267,7 @@ def lissa_step( "max_perc_residual": max_residual * 100, "mean_perc_residual": mean_residual * 100, } - return iHVPResult(x=h_estimate / scale, info=info) + return IhvpResult(x=h_estimate / scale, info=info) def as_tensor(a: Any, warn=True, **kwargs) -> torch.Tensor: @@ -494,7 +494,7 @@ def solve_arnoldi( tol: float = 1e-6, max_iter: Optional[int] = None, eigen_computation_on_gpu: bool = False, -) -> iHVPResult: +) -> IhvpResult: """ Solves the linear system Hx = b, where H is the Hessian of the model's loss function and b is the given right-hand @@ -558,7 +558,7 @@ def hessian_vector_product(x: torch.Tensor) -> torch.Tensor: torch.diag_embed(1.0 / low_rank_representation.eigen_vals) @ (low_rank_representation.projections.t() @ b.t()) ) - return iHVPResult( + return IhvpResult( x=result.t(), info={ "eigenvalues": low_rank_representation.eigen_vals, diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index c44a86abd..aa73dc36b 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -1,27 +1,20 @@ from abc import ABC from dataclasses import dataclass -from typing import ( - Any, - Callable, - Dict, - Generic, - List, - NamedTuple, - Sequence, - Tuple, - TypeVar, -) +from typing import Any, Callable, Dict, Generic, List, Sequence, Tuple, TypeVar TensorType = TypeVar("TensorType", bound=Sequence) ModelType = TypeVar("ModelType") DeviceType = TypeVar("DeviceType") -@dataclass -class iHVPResult(Generic[TensorType]): +@dataclass(frozen=True) +class IhvpResult(Generic[TensorType]): x: TensorType info: Dict[str, Any] + def __iter__(self): + return iter((self.x, self.info)) + class TwiceDifferentiable(ABC, Generic[TensorType, ModelType, DeviceType]): """ diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index aa59fec44..6d3192c8e 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -16,7 +16,7 @@ transpose_tensor, zero_tensor, ) -from .inversion import InversionMethod, iHVPResult, solve_hvp +from .inversion import IhvpResult, InversionMethod, solve_hvp __all__ = ["compute_influences", "InfluenceType", "compute_influence_factors"] @@ -39,7 +39,7 @@ def compute_influence_factors( hessian_perturbation: float = 0.0, progress: bool = False, **kwargs: Any, -) -> iHVPResult: +) -> IhvpResult: r""" Calculates influence factors of a model for training and test data. Given a test point $z_test = (x_{test}, y_{test})$, a loss @@ -225,7 +225,7 @@ def compute_influences( if test_data is None: test_data = deepcopy(training_data) - influence_factors = compute_influence_factors( + influence_factors, _ = compute_influence_factors( differentiable_model, training_data, test_data, @@ -233,7 +233,7 @@ def compute_influences( hessian_perturbation=hessian_regularization, progress=progress, **kwargs, - ).x + ) compute_influence_type = influence_type_registry[influence_type] return compute_influence_type( diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 55e943f95..2bd1f5c72 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -7,9 +7,9 @@ from .frameworks import ( DataLoaderType, + IhvpResult, TensorType, TwiceDifferentiable, - iHVPResult, solve_batch_cg, solve_linear, solve_lissa, @@ -42,7 +42,7 @@ def solve_hvp( hessian_perturbation: float = 0.0, progress: bool = False, **kwargs: Any, -) -> iHVPResult: +) -> IhvpResult: """ Finds $x$ such that $Ax = b$, where $A$ is the hessian of model, and $b$ a vector. diff --git a/tests/influence/test_torch_differentiable.py b/tests/influence/test_torch_differentiable.py index a60f25ae4..a949eda40 100644 --- a/tests/influence/test_torch_differentiable.py +++ b/tests/influence/test_torch_differentiable.py @@ -177,9 +177,11 @@ def test_inversion_methods( train_data_loader = DataLoader(list(zip(train_x, train_y)), batch_size=128) b = torch.rand(size=(10, mvp_model.num_params), dtype=torch.float64) - linear_inverse = solve_linear(mvp_model, train_data_loader, b) - linear_cg = solve_batch_cg(mvp_model, train_data_loader, b) - linear_lissa = solve_lissa(mvp_model, train_data_loader, b, maxiter=5000, scale=5) + linear_inverse, _ = solve_linear(mvp_model, train_data_loader, b) + linear_cg, _ = solve_batch_cg(mvp_model, train_data_loader, b) + linear_lissa, _ = solve_lissa( + mvp_model, train_data_loader, b, maxiter=5000, scale=5 + ) - assert np.allclose(linear_inverse.x, linear_cg.x, rtol=1e-1) - assert np.allclose(linear_inverse.x, linear_lissa.x, rtol=1e-1) + assert np.allclose(linear_inverse, linear_cg, rtol=1e-1) + assert np.allclose(linear_inverse, linear_lissa, rtol=1e-1) From d4f4034f99f933385fd6245f6bf2983655e6af8f Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 4 Aug 2023 13:50:35 +0200 Subject: [PATCH 218/436] change name to InverseHvpResult --- docs/40-influence.rst | 8 +++---- src/pydvl/influence/frameworks/__init__.py | 4 ++-- .../frameworks/torch_differentiable.py | 22 +++++++++---------- .../frameworks/twice_differentiable.py | 2 +- src/pydvl/influence/general.py | 4 ++-- src/pydvl/influence/inversion.py | 4 ++-- 6 files changed, 22 insertions(+), 22 deletions(-) diff --git a/docs/40-influence.rst b/docs/40-influence.rst index f68491352..91e25ffa3 100644 --- a/docs/40-influence.rst +++ b/docs/40-influence.rst @@ -327,7 +327,7 @@ training dataset. ... inversion_method="cg" ... ) -The result is an object of type :class:`~pydvl.influence.framework.IhvpResult`, +The result is an object of type :class:`~pydvl.influence.framework.InverseHvpResult`, which holds the calculated influence factors (`influence_factors.x`) and a dictionary with the info on the inversion process (`influence_factors.info`). @@ -368,7 +368,7 @@ datasets or models with many parameters. ... b: torch.Tensor, ... ) -The result, an object of type :class:`~pydvl.influence.framework.IhvpResult`, +The result, an object of type :class:`~pydvl.influence.framework.InverseHvpResult`, which holds two objects: `influence_factors.x` and `influence_factors.info`. The first one is the inverse Hessian vector product, while the second one is a dictionary with the info on the inversion process. For this method, the info @@ -410,7 +410,7 @@ to the :func:`~pydvl.influence.frameworks.torch_differentiable.solve_batch_cg` function, and are respecively the initial guess for the solution, the relative tolerance, the absolute tolerance, and the maximum number of iterations. -The resulting :class:`~pydvl.influence.framework.IhvpResult` +The resulting :class:`~pydvl.influence.framework.InverseHvpResult` holds the solution of the iHVP, `influence_factors.x`, and some info on the inversion process `influence_factors.info`. More specifically, for each batch the infos will report the number of iterations, a boolean indicating if the @@ -459,7 +459,7 @@ being the maximum number of iterations, the dampening factor, the scaling factor, the initial guess for the solution and the relative tolerance, respectively. -The resulting :class:`~pydvl.influence.framework.IhvpResult` holds the solution +The resulting :class:`~pydvl.influence.framework.InverseHvpResult` holds the solution of the iHVP, `influence_factors.x`, and, within `influence_factors.info`, the maximum percentage error and the mean percentage error of the approximation. diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index ef2eb0d0f..298dd4f41 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -4,7 +4,7 @@ import logging -from .twice_differentiable import IhvpResult, TwiceDifferentiable +from .twice_differentiable import InverseHvpResult, TwiceDifferentiable __all__ = ["TwiceDifferentiable"] logger = logging.getLogger("frameworks") @@ -37,7 +37,7 @@ [ "TensorType", "ModelType", - "IhvpResult", + "InverseHvpResult", "solve_linear", "solve_batch_cg", "solve_lissa", diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index d5389b080..0113d7203 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -20,7 +20,7 @@ from ...utils import maybe_progress from .functional import get_hvp_function -from .twice_differentiable import IhvpResult, TwiceDifferentiable +from .twice_differentiable import InverseHvpResult, TwiceDifferentiable from .util import align_structure, flatten_tensors_to_vector __all__ = [ @@ -55,7 +55,7 @@ def solve_linear( *, hessian_perturbation: float = 0.0, progress: bool = False, -) -> IhvpResult: +) -> InverseHvpResult: """Given a model and training data, it finds x s.t. $Hx = b$, with $H$ being the model hessian. @@ -81,7 +81,7 @@ def solve_linear( model.num_params, device=model.device ) info = {"hessian": hessian} - return IhvpResult(x=torch.linalg.solve(matrix, b.T).T, info=info) + return InverseHvpResult(x=torch.linalg.solve(matrix, b.T).T, info=info) def solve_batch_cg( @@ -95,7 +95,7 @@ def solve_batch_cg( atol: float = 1e-7, maxiter: Optional[int] = None, progress: bool = False, -) -> IhvpResult: +) -> InverseHvpResult: """ Given a model and training data, it uses conjugate gradient to calculate the inverse of the Hessian Vector Product. More precisely, it finds x s.t. $Hx = @@ -134,7 +134,7 @@ def solve_batch_cg( ) batch_cg[idx] = batch_result info[f"batch_{idx}"] = batch_info - return IhvpResult(x=batch_cg, info=info) + return InverseHvpResult(x=batch_cg, info=info) def solve_cg( @@ -145,7 +145,7 @@ def solve_cg( rtol: float = 1e-7, atol: float = 1e-7, maxiter: Optional[int] = None, -) -> IhvpResult: +) -> InverseHvpResult: """Conjugate gradient solver for the Hessian vector product :param hvp: a Callable Hvp, operating with tensors of size N @@ -185,7 +185,7 @@ def solve_cg( p = r + beta * p info = {"niter": k, "optimal": optimal, "gamma": gamma} - return IhvpResult(x=x, info=info) + return InverseHvpResult(x=x, info=info) def solve_lissa( @@ -200,7 +200,7 @@ def solve_lissa( h0: Optional[torch.Tensor] = None, rtol: float = 1e-4, progress: bool = False, -) -> IhvpResult: +) -> InverseHvpResult: r""" Uses LISSA, Linear time Stochastic Second-Order Algorithm, to iteratively approximate the inverse Hessian. More precisely, it finds x s.t. $Hx = b$, @@ -267,7 +267,7 @@ def lissa_step( "max_perc_residual": max_residual * 100, "mean_perc_residual": mean_residual * 100, } - return IhvpResult(x=h_estimate / scale, info=info) + return InverseHvpResult(x=h_estimate / scale, info=info) def as_tensor(a: Any, warn=True, **kwargs) -> torch.Tensor: @@ -494,7 +494,7 @@ def solve_arnoldi( tol: float = 1e-6, max_iter: Optional[int] = None, eigen_computation_on_gpu: bool = False, -) -> IhvpResult: +) -> InverseHvpResult: """ Solves the linear system Hx = b, where H is the Hessian of the model's loss function and b is the given right-hand @@ -558,7 +558,7 @@ def hessian_vector_product(x: torch.Tensor) -> torch.Tensor: torch.diag_embed(1.0 / low_rank_representation.eigen_vals) @ (low_rank_representation.projections.t() @ b.t()) ) - return IhvpResult( + return InverseHvpResult( x=result.t(), info={ "eigenvalues": low_rank_representation.eigen_vals, diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index aa73dc36b..26e9e430d 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -8,7 +8,7 @@ @dataclass(frozen=True) -class IhvpResult(Generic[TensorType]): +class InverseHvpResult(Generic[TensorType]): x: TensorType info: Dict[str, Any] diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 6d3192c8e..304910f5c 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -16,7 +16,7 @@ transpose_tensor, zero_tensor, ) -from .inversion import IhvpResult, InversionMethod, solve_hvp +from .inversion import InverseHvpResult, InversionMethod, solve_hvp __all__ = ["compute_influences", "InfluenceType", "compute_influence_factors"] @@ -39,7 +39,7 @@ def compute_influence_factors( hessian_perturbation: float = 0.0, progress: bool = False, **kwargs: Any, -) -> IhvpResult: +) -> InverseHvpResult: r""" Calculates influence factors of a model for training and test data. Given a test point $z_test = (x_{test}, y_{test})$, a loss diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 2bd1f5c72..4580e3b71 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -7,7 +7,7 @@ from .frameworks import ( DataLoaderType, - IhvpResult, + InverseHvpResult, TensorType, TwiceDifferentiable, solve_batch_cg, @@ -42,7 +42,7 @@ def solve_hvp( hessian_perturbation: float = 0.0, progress: bool = False, **kwargs: Any, -) -> IhvpResult: +) -> InverseHvpResult: """ Finds $x$ such that $Ax = b$, where $A$ is the hessian of model, and $b$ a vector. From 807c41430b797f181653d006bd4ec0517358a3a5 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Mon, 7 Aug 2023 15:30:17 +0200 Subject: [PATCH 219/436] setting device to lanzcos_low_rank_hessian_approx --- .../influence/frameworks/torch_differentiable.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 14adc84b1..b7021238a 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -596,6 +596,14 @@ def mv(x): else: from scipy.sparse.linalg import LinearOperator, eigsh + if device.type == "cuda": + logger.warning( + "Device is cuda, but eigen_computation_on_gpu is False, so eigen computation will be on CPU." + "To enable GPU computation, set eigen_computation_on_gpu to True." + ) + else: + device = torch.device("cpu") + def mv(x): x_torch = torch.as_tensor(x, device=device, dtype=torch_dtype) y: NDArray = ( @@ -628,7 +636,7 @@ def mv(x): eigen_vals, eigen_vecs = e.eigenvalues, e.eigenvectors - eigen_vals = to_torch_conversion_function(eigen_vals) - eigen_vecs = to_torch_conversion_function(eigen_vecs) + eigen_vals = to_torch_conversion_function(eigen_vals).to(device) + eigen_vecs = to_torch_conversion_function(eigen_vecs).to(device) return LowRankProductRepresentation(eigen_vals, eigen_vecs) From 69e254528a2708c23f652e7cf14262bd60abcfd2 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Mon, 7 Aug 2023 15:42:58 +0200 Subject: [PATCH 220/436] fix None device case --- src/pydvl/influence/frameworks/torch_differentiable.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index b7021238a..0edc76028 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -596,7 +596,7 @@ def mv(x): else: from scipy.sparse.linalg import LinearOperator, eigsh - if device.type == "cuda": + if device is not None and device.type == "cuda": logger.warning( "Device is cuda, but eigen_computation_on_gpu is False, so eigen computation will be on CPU." "To enable GPU computation, set eigen_computation_on_gpu to True." From b6f081aeb9e3bd291a7e0598808d0aca4a61b8e4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Fri, 28 Jul 2023 13:28:14 +0200 Subject: [PATCH 221/436] Refactor TorchTwiceDifferantiable * simplify grad method, do not return tuple, simplify input signature * simplify split_grad to call self.grad * change default argument of self.grad * extract split_grad method to simplify class --- .../frameworks/torch_differentiable.py | 64 ++++++----------- .../frameworks/twice_differentiable.py | 21 +----- src/pydvl/influence/general.py | 68 +++++++------------ tests/influence/test_torch_differentiable.py | 14 ++-- 4 files changed, 59 insertions(+), 108 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 0113d7203..8d47aab7f 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -41,7 +41,7 @@ logger = logging.getLogger(__name__) -def flatten_all(grad: torch.Tensor) -> torch.Tensor: +def flatten_all(grad: Iterable[torch.Tensor]) -> torch.Tensor: """ Simple function to flatten a pyTorch gradient for use in subsequent calculation """ @@ -119,7 +119,7 @@ def solve_batch_cg( total_grad_xy = 0 total_points = 0 for x, y in maybe_progress(training_data, progress, desc="Batch Train Gradients"): - grad_xy, _ = model.grad(x, y) + grad_xy = model.grad(x, y, create_graph=True) total_grad_xy += grad_xy * len(x) total_points += len(x) backprop_on = model.parameters @@ -249,7 +249,7 @@ def lissa_step( for _ in maybe_progress(range(maxiter), progress, desc="Lissa"): x, y = next(iter(shuffled_training_data)) - grad_xy, _ = model.grad(x, y) + grad_xy = model.grad(x, y, create_graph=True) reg_hvp = lambda v: mvp(grad_xy, v, model.parameters) + hessian_perturbation * v residual = lissa_step(h_estimate, reg_hvp) - h_estimate h_estimate += residual @@ -315,6 +315,17 @@ def identity_tensor(dim: int, **kwargs) -> torch.Tensor: return torch.eye(dim, dim, **kwargs) +def unsqueeze(x: torch.Tensor, dim: int) -> torch.Tensor: + """ + Add a singleton dimension at a specified position in a tensor. + + :param x: A PyTorch tensor. + :param dim: The position at which to add the singleton dimension. Zero-based indexing. + :return: A new tensor with an additional singleton dimension. + """ + return x.unsqueeze(dim) + + def mvp( grad_xy: torch.Tensor, v: torch.Tensor, @@ -397,57 +408,24 @@ def num_params(self) -> int: """ return sum([np.prod(p.size()) for p in self.parameters]) - def split_grad( - self, x: torch.Tensor, y: torch.Tensor, *, progress: bool = False - ) -> torch.Tensor: - """ - Calculates gradient of model parameters wrt each $x[i]$ and $y[i]$ and then - returns a array of size [N, P] with N number of points (length of x and y) and P - number of parameters of the model. - - :param x: An array [NxD] representing the features $x_i$. - :param y: An array [NxK] representing the predicted target values $y_i$. - :param progress: True, iff progress shall be printed. - :returns: An array [NxP] representing the gradients with respect to - all parameters of the model. - """ - x = as_tensor(x, warn=False).to(self.device).unsqueeze(1) - y = as_tensor(y, warn=False).to(self.device) - - grads = [] - for i in maybe_progress(range(len(x)), progress, desc="Split Gradient"): - grads.append( - flatten_all( - autograd.grad( - self.loss(torch.squeeze(self.model(x[i])), torch.squeeze(y[i])), - self.parameters, - ) - ).detach() - ) - - return torch.stack(grads, axis=0) - def grad( - self, x: torch.Tensor, y: torch.Tensor, *, x_requires_grad: bool = False - ) -> Tuple[torch.Tensor, torch.Tensor]: + self, x: torch.Tensor, y: torch.Tensor, create_graph: bool = False + ) -> torch.Tensor: """ Calculates gradient of model parameters wrt the model parameters. :param x: A matrix [NxD] representing the features $x_i$. :param y: A matrix [NxK] representing the target values $y_i$. - :param x_requires_grad: If True, the input $x$ is marked as requiring - gradients. This is important for further differentiation on input - parameters. :returns: A tuple where the first element is an array [P] with the gradients of the model and second element is the input to the model as a grad parameters. This can be used for further differentiation. """ - x = as_tensor(x, warn=False).to(self.device).requires_grad_(x_requires_grad) - y = as_tensor(y, warn=False).to(self.device) + x = x.to(self.device) + y = y.to(self.device) loss_value = self.loss(torch.squeeze(self.model(x)), torch.squeeze(y)) - grad_f = torch.autograd.grad(loss_value, self.parameters, create_graph=True) - return flatten_all(grad_f), x + grad_f = torch.autograd.grad(loss_value, self.parameters, create_graph=create_graph) + return flatten_all(grad_f) def hessian( self, x: torch.Tensor, y: torch.Tensor, *, progress: bool = False @@ -460,7 +438,7 @@ def hessian( """ x = x.to(self.device) y = y.to(self.device) - grad_xy, _ = self.grad(x, y) + grad_xy = self.grad(x, y, create_graph=True) return mvp( grad_xy, torch.eye(self.num_params, self.num_params, device=self.device), diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index 26e9e430d..68588bf8b 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -41,31 +41,14 @@ def parameters(self) -> List[TensorType]: """Returns all the model parameters that require differentiation""" pass - def split_grad( - self, x: TensorType, y: TensorType, *, progress: bool = False - ) -> TensorType: - """ - Calculate the gradient of the model wrt each input x and labels y. - The output is therefore of size [Nxp], with N the amount of points (the - length of x and y) and P the number of parameters. - - :param x: An array representing the features $x_i$. - :param y: An array representing the predicted target values $y_i$. - :param progress: ``True`` to display progress. - :return: An array representing the gradients wrt. the parameters of the - model. - """ - pass - def grad( - self, x: TensorType, y: TensorType, *, x_requires_grad: bool = False - ) -> Tuple[TensorType, TensorType]: + self, x: TensorType, y: TensorType, create_graph: bool = True + ) -> TensorType: """ Calculates gradient of model parameters wrt. the model parameters. :param x: A matrix representing the features $x_i$. :param y: A matrix representing the target values $y_i$. - :param x_requires_grad: If True, the input $x$ is marked as requiring gradients. This is important for further differentiation on input parameters. :return: A tuple where: the first element is an array with the diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 304910f5c..e934333a3 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -6,11 +6,13 @@ from enum import Enum from typing import Any, Dict, Optional, Tuple +from .frameworks.torch_differentiable import unsqueeze from ..utils import maybe_progress from .frameworks import ( DataLoaderType, TensorType, TwiceDifferentiable, + cat, einsum, mvp, transpose_tensor, @@ -63,18 +65,11 @@ def compute_influence_factors( :returns: An array of size (N, D) containing the influence factors for each dimension (D) and test sample (N). """ - test_grads = zero_tensor( - shape=(len(test_data.dataset), model.num_params), - dtype=test_data.dataset[0][0].dtype, - device=model.device, - ) - for batch_idx, (x_test, y_test) in enumerate( - maybe_progress(test_data, progress, desc="Batch Test Gradients") - ): - idx = batch_idx * test_data.batch_size - test_grads[idx : idx + test_data.batch_size] = model.split_grad( - x_test, y_test, progress=False - ) + test_grads = [] + for x_test, y_test in maybe_progress(test_data, progress, desc="Batch Test Gradients"): + test_grad = stack([model.grad(inpt, target) for inpt, target in zip(unsqueeze(x_test, 1), y_test)]) + test_grads.append(test_grad) + test_grads = cat(test_grads) return solve_hvp( inversion_method, model, @@ -110,19 +105,13 @@ def compute_influences_up( :returns: An array of size [NxM], where N is number of influence factors, M number of input points. """ - grads = zero_tensor( - shape=(len(input_data.dataset), model.num_params), - dtype=input_data.dataset[0][0].dtype, - device=model.device, - ) - for batch_idx, (x, y) in enumerate( - maybe_progress(input_data, progress, desc="Batch Split Input Gradients") - ): - idx = batch_idx * input_data.batch_size - grads[idx : idx + input_data.batch_size] = model.split_grad( - x, y, progress=False - ) - return einsum("ta,va->tv", influence_factors, grads) + train_grads = [] + for x, y in maybe_progress(input_data, progress, desc="Batch Split Input Gradients"): + train_grad = stack([model.grad(inpt, target) for inpt, target in zip(unsqueeze(x, 1), y)]) + train_grads.append(train_grad) + + train_grads = cat(train_grads) + return einsum("ta,va->tv", influence_factors, train_grads) def compute_influences_pert( @@ -149,31 +138,26 @@ def compute_influences_pert( :returns: An array of size [NxMxP], where N is the number of influence factors, M the number of input data, and P the number of features. """ - input_x = input_data.dataset[0][0] - all_pert_influences = zero_tensor( - shape=(len(input_data.dataset), len(influence_factors), *input_x.shape), - dtype=input_x.dtype, - device=model.device, - ) - for batch_idx, (x, y) in enumerate( - maybe_progress( - input_data, - progress, - desc="Batch Influence Perturbation", - ) + all_pert_influences = [] + for x, y in maybe_progress( + input_data, + progress, + desc="Batch Influence Perturbation", ): for i in range(len(x)): - grad_xy, tensor_x = model.grad(x[i : i + 1], y[i], x_requires_grad=True) + tensor_x = x[i : i + 1] + tensor_x = tensor_x.requires_grad_(True) + grad_xy = model.grad(tensor_x, y[i], create_graph=True) perturbation_influences = mvp( grad_xy, influence_factors, backprop_on=tensor_x, ) - all_pert_influences[ - batch_idx * input_data.batch_size + i - ] = perturbation_influences.reshape((-1, *x[i].shape)) + all_pert_influences.append( + perturbation_influences.reshape((-1, *x[i].shape)) + ) - return transpose_tensor(all_pert_influences, 0, 1) + return stack(all_pert_influences, axis=1) influence_type_registry = { diff --git a/tests/influence/test_torch_differentiable.py b/tests/influence/test_torch_differentiable.py index a949eda40..31d1c4829 100644 --- a/tests/influence/test_torch_differentiable.py +++ b/tests/influence/test_torch_differentiable.py @@ -74,7 +74,11 @@ def test_linear_grad( mvp_model = linear_mvp_model(A, b) train_grads_analytical = linear_derivative_analytical((A, b), train_x, train_y) - train_grads_autograd = mvp_model.split_grad(train_x, train_y) + train_x = torch.as_tensor(train_x).unsqueeze(1) + train_y = torch.as_tensor(train_y) + + train_grads_autograd = torch.stack([mvp_model.grad(inpt, target) for inpt, target in zip(train_x, train_y)]) + assert np.allclose(train_grads_analytical, train_grads_autograd, rtol=1e-5) @@ -100,10 +104,10 @@ def test_linear_hessian( mvp_model = linear_mvp_model(A, b) test_hessian_analytical = linear_hessian_analytical((A, b), train_x) - grad_xy, _ = mvp_model.grad(train_x, train_y) + grad_xy = mvp_model.grad(torch.as_tensor(train_x), torch.as_tensor(train_y), create_graph=True) estimated_hessian = mvp( grad_xy, - np.eye((input_dimension + 1) * output_dimension), + torch.as_tensor(np.eye((input_dimension + 1) * output_dimension)), mvp_model.parameters, ) assert np.allclose(test_hessian_analytical, estimated_hessian, rtol=1e-5) @@ -138,7 +142,9 @@ def test_linear_mixed_derivative( ) model_mvp = [] for i in range(len(train_x)): - grad_xy, tensor_x = mvp_model.grad(train_x[i], train_y[i], x_requires_grad=True) + tensor_x = torch.as_tensor(train_x[i]).requires_grad_(True) + tensor_y = torch.as_tensor(train_y[i]) + grad_xy = mvp_model.grad(tensor_x, tensor_y, create_graph=True) model_mvp.append( mvp( grad_xy, From d0a33caac2611af434b6589ae16139fafab7075b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Mon, 31 Jul 2023 11:29:53 +0200 Subject: [PATCH 222/436] Simplify TwiceDifferentiable interface --- .../frameworks/torch_differentiable.py | 88 ++++++++++++------- .../frameworks/twice_differentiable.py | 26 ++---- src/pydvl/influence/general.py | 26 ++++-- src/pydvl/influence/inversion.py | 7 +- tests/influence/test_influences.py | 6 +- tests/influence/test_torch_differentiable.py | 10 ++- 6 files changed, 93 insertions(+), 70 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 8d47aab7f..094fc3209 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -7,7 +7,7 @@ import logging from dataclasses import dataclass from functools import partial -from typing import Any, Callable, List, Optional, Sequence, Tuple, Union +from typing import Any, Callable, Iterable, List, Optional, Sequence, Tuple, Union import numpy as np import torch @@ -49,12 +49,11 @@ def flatten_all(grad: Iterable[torch.Tensor]) -> torch.Tensor: def solve_linear( - model: TwiceDifferentiable, + model: "TorchTwiceDifferentiable", training_data: DataLoader, b: torch.Tensor, *, hessian_perturbation: float = 0.0, - progress: bool = False, ) -> InverseHvpResult: """Given a model and training data, it finds x s.t. $Hx = b$, with $H$ being the model hessian. @@ -63,7 +62,6 @@ def solve_linear( :param training_data: A DataLoader containing the training data. :param b: a vector or matrix, the right hand side of the equation $Hx = b$. :param hessian_perturbation: regularization of the hessian - :param progress: If True, display progress bars. :return: An array that solves the inverse problem, i.e. it returns $x$ such that $Hx = b$, and a dictionary containing @@ -76,7 +74,7 @@ def solve_linear( all_y.append(y) all_x = cat(all_x) all_y = cat(all_y) - hessian = model.hessian(all_x, all_y, progress=progress) + hessian = model.hessian(all_x, all_y) matrix = hessian + hessian_perturbation * identity_tensor( model.num_params, device=model.device ) @@ -85,7 +83,7 @@ def solve_linear( def solve_batch_cg( - model: TwiceDifferentiable, + model: "TorchTwiceDifferentiable", training_data: DataLoader, b: torch.Tensor, *, @@ -189,7 +187,7 @@ def solve_cg( def solve_lissa( - model: TwiceDifferentiable, + model: "TorchTwiceDifferentiable", training_data: DataLoader, b: torch.Tensor, *, @@ -365,23 +363,16 @@ def mvp( return mvp.detach() # type: ignore -class TorchTwiceDifferentiable( - TwiceDifferentiable[torch.Tensor, nn.Module, torch.device] -): +class TorchTwiceDifferentiable(TwiceDifferentiable[torch.Tensor]): def __init__( self, model: nn.Module, loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], - *, - device: torch.device = torch.device( - "cuda" if torch.cuda.is_available() else "cpu" - ), ): r""" :param model: A (differentiable) function. :param loss: :param loss: A differentiable scalar loss $L(\hat{y}, y)$, mapping a prediction and a target to a real value. - :param device: device to use for computations. Defaults to cuda if available. """ if model.training: logger.warning( @@ -389,16 +380,14 @@ def __init__( "computation, e.g. due to batch normalization. Please call model.eval() before " "computing influences." ) - self.model = model.to(device) self.loss = loss - self.device = device + self.model = model + self.device = model.device if hasattr(model, "device") else torch.device("cpu") @property def parameters(self) -> List[torch.Tensor]: """Returns all the model parameters that require differentiating""" - return [ - param for param in self.model.parameters() if param.requires_grad == True - ] + return [param for param in self.model.parameters() if param.requires_grad] @property def num_params(self) -> int: @@ -406,7 +395,7 @@ def num_params(self) -> int: Get number of parameters of model f. :returns: Number of parameters as integer. """ - return sum([np.prod(p.size()) for p in self.parameters]) + return sum([p.numel() for p in self.parameters]) def grad( self, x: torch.Tensor, y: torch.Tensor, create_graph: bool = False @@ -416,6 +405,7 @@ def grad( :param x: A matrix [NxD] representing the features $x_i$. :param y: A matrix [NxK] representing the target values $y_i$. + :param create_graph: :returns: A tuple where the first element is an array [P] with the gradients of the model and second element is the input to the model as a grad parameters. This can be used for further differentiation. @@ -424,27 +414,57 @@ def grad( y = y.to(self.device) loss_value = self.loss(torch.squeeze(self.model(x)), torch.squeeze(y)) - grad_f = torch.autograd.grad(loss_value, self.parameters, create_graph=create_graph) + grad_f = torch.autograd.grad( + loss_value, self.parameters, create_graph=create_graph + ) return flatten_all(grad_f) - def hessian( - self, x: torch.Tensor, y: torch.Tensor, *, progress: bool = False - ) -> torch.Tensor: + def hessian(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: """Calculates the explicit hessian of model parameters given data ($x$ and $y$). :param x: A matrix [NxD] representing the features $x_i$. :param y: A matrix [NxK] representing the target values $y_i$. - :param progress: ``True`` to display progress. :returns: the hessian of the model, i.e. the second derivative wrt. the model parameters. """ - x = x.to(self.device) - y = y.to(self.device) - grad_xy = self.grad(x, y, create_graph=True) - return mvp( - grad_xy, - torch.eye(self.num_params, self.num_params, device=self.device), - self.parameters, - progress=progress, + + def model_func(param): + outputs = torch.func.functional_call( + self.model, + align_structure( + {k: p for k, p in self.model.named_parameters() if p.requires_grad}, + param, + ), + (x.to(self.device),), + strict=True, + ) + return self.loss(outputs, y.to(self.device)) + + params = flatten_tensors_to_vector( + p.detach() for p in self.model.parameters() if p.requires_grad ) + return torch.func.hessian(model_func)(params) + + +def hessian_from_dict(hessian_dict): + param_names = list(hessian_dict.keys()) + + hessian_rows = [] + + for row_name in param_names: + row = [] + + for col_name in param_names: + block = hessian_dict[row_name][col_name] + + # Flatten the block and add it to the row + row.append(block.contiguous().view(-1)) + + # Concatenate the row blocks and add them to the Hessian + hessian_rows.append(torch.cat(row)) + + # Concatenate all rows to form the Hessian + hessian = torch.stack(hessian_rows) + + return hessian @dataclass diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index 68588bf8b..a12463461 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -1,10 +1,9 @@ -from abc import ABC +from abc import ABC, abstractmethod from dataclasses import dataclass from typing import Any, Callable, Dict, Generic, List, Sequence, Tuple, TypeVar TensorType = TypeVar("TensorType", bound=Sequence) ModelType = TypeVar("ModelType") -DeviceType = TypeVar("DeviceType") @dataclass(frozen=True) @@ -16,27 +15,20 @@ def __iter__(self): return iter((self.x, self.info)) -class TwiceDifferentiable(ABC, Generic[TensorType, ModelType, DeviceType]): +class TwiceDifferentiable(ABC, Generic[TensorType]): """ - Wraps a differentiable model and loss and provides methods to compute the - second derivative of the loss wrt. the model parameters. + Wraps a differentiable model and loss and provides methods to compute gradients and + second derivative of the loss wrt. the model parameters """ - def __init__( - self, - model: ModelType, - loss: Callable[[TensorType, TensorType], TensorType], - device: DeviceType, - ): - self.device = device - pass - @property + @abstractmethod def num_params(self) -> int: """Returns the number of parameters of the model""" pass @property + @abstractmethod def parameters(self) -> List[TensorType]: """Returns all the model parameters that require differentiation""" pass @@ -51,6 +43,7 @@ def grad( :param y: A matrix representing the target values $y_i$. gradients. This is important for further differentiation on input parameters. + :param create_graph: :return: A tuple where: the first element is an array with the gradients of the model, and the second element is the input to the model as a grad parameters. This can be used for further @@ -58,15 +51,12 @@ def grad( """ pass - def hessian( - self, x: TensorType, y: TensorType, *, progress: bool = False - ) -> TensorType: + def hessian(self, x: TensorType, y: TensorType) -> TensorType: """Calculates the full Hessian of $L(f(x),y)$ with respect to the model parameters given data ($x$ and $y$). :param x: An array representing the features $x_i$. :param y: An array representing the target values $y_i$. - :param progress: ``True`` to display progress. :return: The hessian of the model, i.e. the second derivative wrt. the model parameters. """ diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index e934333a3..c54a75837 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -4,9 +4,8 @@ """ from copy import deepcopy from enum import Enum -from typing import Any, Dict, Optional, Tuple +from typing import Any, Optional -from .frameworks.torch_differentiable import unsqueeze from ..utils import maybe_progress from .frameworks import ( DataLoaderType, @@ -15,9 +14,9 @@ cat, einsum, mvp, - transpose_tensor, - zero_tensor, + stack, ) +from .frameworks.torch_differentiable import unsqueeze from .inversion import InverseHvpResult, InversionMethod, solve_hvp __all__ = ["compute_influences", "InfluenceType", "compute_influence_factors"] @@ -66,8 +65,15 @@ def compute_influence_factors( dimension (D) and test sample (N). """ test_grads = [] - for x_test, y_test in maybe_progress(test_data, progress, desc="Batch Test Gradients"): - test_grad = stack([model.grad(inpt, target) for inpt, target in zip(unsqueeze(x_test, 1), y_test)]) + for x_test, y_test in maybe_progress( + test_data, progress, desc="Batch Test Gradients" + ): + test_grad = stack( + [ + model.grad(inpt, target) + for inpt, target in zip(unsqueeze(x_test, 1), y_test) + ] + ) test_grads.append(test_grad) test_grads = cat(test_grads) return solve_hvp( @@ -106,8 +112,12 @@ def compute_influences_up( number of input points. """ train_grads = [] - for x, y in maybe_progress(input_data, progress, desc="Batch Split Input Gradients"): - train_grad = stack([model.grad(inpt, target) for inpt, target in zip(unsqueeze(x, 1), y)]) + for x, y in maybe_progress( + input_data, progress, desc="Batch Split Input Gradients" + ): + train_grad = stack( + [model.grad(inpt, target) for inpt, target in zip(unsqueeze(x, 1), y)] + ) train_grads.append(train_grad) train_grads = cat(train_grads) diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 4580e3b71..f3fcad42a 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -66,16 +66,15 @@ def solve_hvp( """ if inversion_method == InversionMethod.Direct: return solve_linear( - model, + model, # type: ignore training_data, b, **kwargs, hessian_perturbation=hessian_perturbation, - progress=progress, ) elif inversion_method == InversionMethod.Cg: return solve_batch_cg( - model, + model, # type: ignore training_data, b, **kwargs, @@ -84,7 +83,7 @@ def solve_hvp( ) elif inversion_method == InversionMethod.Lissa: return solve_lissa( - model, + model, # type: ignore training_data, b, **kwargs, diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 9ffca5eca..2383304d3 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -137,7 +137,7 @@ def test_influence_linear_model( ) influence_values = compute_influences( - TorchTwiceDifferentiable(linear_layer, loss, device=torch.device("cpu")), + TorchTwiceDifferentiable(linear_layer, loss), training_data=train_data_loader, test_data=test_data_loader, input_data=input_data, @@ -335,7 +335,7 @@ def test_influences_nn( model = module_factory() model.eval() - model = TorchTwiceDifferentiable(model, loss, device=torch.device("cpu")) + model = TorchTwiceDifferentiable(model, loss) direct_influence = compute_influences( model, @@ -436,7 +436,7 @@ def test_influences_arnoldi( ) nn_architecture = nn_architecture.eval() - model = TorchTwiceDifferentiable(nn_architecture, loss, device=torch.device("cpu")) + model = TorchTwiceDifferentiable(nn_architecture, loss) direct_influence = compute_influences( model, diff --git a/tests/influence/test_torch_differentiable.py b/tests/influence/test_torch_differentiable.py index 31d1c4829..f8d80b819 100644 --- a/tests/influence/test_torch_differentiable.py +++ b/tests/influence/test_torch_differentiable.py @@ -48,7 +48,7 @@ def linear_mvp_model(A, b): model.weight.data = torch.as_tensor(A) model.bias.data = torch.as_tensor(b) loss = F.mse_loss - return TorchTwiceDifferentiable(model=model, loss=loss, device=torch.device("cpu")) + return TorchTwiceDifferentiable(model=model, loss=loss) @pytest.mark.torch @@ -77,7 +77,9 @@ def test_linear_grad( train_x = torch.as_tensor(train_x).unsqueeze(1) train_y = torch.as_tensor(train_y) - train_grads_autograd = torch.stack([mvp_model.grad(inpt, target) for inpt, target in zip(train_x, train_y)]) + train_grads_autograd = torch.stack( + [mvp_model.grad(inpt, target) for inpt, target in zip(train_x, train_y)] + ) assert np.allclose(train_grads_analytical, train_grads_autograd, rtol=1e-5) @@ -104,7 +106,9 @@ def test_linear_hessian( mvp_model = linear_mvp_model(A, b) test_hessian_analytical = linear_hessian_analytical((A, b), train_x) - grad_xy = mvp_model.grad(torch.as_tensor(train_x), torch.as_tensor(train_y), create_graph=True) + grad_xy = mvp_model.grad( + torch.as_tensor(train_x), torch.as_tensor(train_y), create_graph=True + ) estimated_hessian = mvp( grad_xy, torch.as_tensor(np.eye((input_dimension + 1) * output_dimension)), From 305f699464a63750341970bdd750297e4ae5673c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Mon, 7 Aug 2023 08:54:42 +0200 Subject: [PATCH 223/436] Move util function from torch_differentiable to util --- .../frameworks/torch_differentiable.py | 23 ------------------- src/pydvl/influence/frameworks/util.py | 23 +++++++++++++++++++ 2 files changed, 23 insertions(+), 23 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 094fc3209..0cee9f016 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -444,29 +444,6 @@ def model_func(param): return torch.func.hessian(model_func)(params) -def hessian_from_dict(hessian_dict): - param_names = list(hessian_dict.keys()) - - hessian_rows = [] - - for row_name in param_names: - row = [] - - for col_name in param_names: - block = hessian_dict[row_name][col_name] - - # Flatten the block and add it to the row - row.append(block.contiguous().view(-1)) - - # Concatenate the row blocks and add them to the Hessian - hessian_rows.append(torch.cat(row)) - - # Concatenate all rows to form the Hessian - hessian = torch.stack(hessian_rows) - - return hessian - - @dataclass class LowRankProductRepresentation: """ diff --git a/src/pydvl/influence/frameworks/util.py b/src/pydvl/influence/frameworks/util.py index 540df53bc..e63c77729 100644 --- a/src/pydvl/influence/frameworks/util.py +++ b/src/pydvl/influence/frameworks/util.py @@ -142,3 +142,26 @@ def align_structure( raise ValueError(f"'target' is of type {type(target)} which is not supported.") return tangent_dict + + +def hessian_from_dict(hessian_dict): + param_names = list(hessian_dict.keys()) + + hessian_rows = [] + + for row_name in param_names: + row = [] + + for col_name in param_names: + block = hessian_dict[row_name][col_name] + + # Flatten the block and add it to the row + row.append(block.contiguous().view(-1)) + + # Concatenate the row blocks and add them to the Hessian + hessian_rows.append(torch.cat(row)) + + # Concatenate all rows to form the Hessian + hessian = torch.stack(hessian_rows) + + return hessian From 3f14844ea2089dde26d2411b97a4f6392d27e0a6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Mon, 7 Aug 2023 09:05:44 +0200 Subject: [PATCH 224/436] Make mvp a static method of TwiceDifferentiable --- src/pydvl/influence/frameworks/__init__.py | 1 - .../frameworks/torch_differentiable.py | 88 ++++++++++--------- .../frameworks/twice_differentiable.py | 30 ++++++- src/pydvl/influence/general.py | 3 +- src/pydvl/influence/inversion.py | 5 +- tests/influence/test_torch_differentiable.py | 5 +- 6 files changed, 81 insertions(+), 51 deletions(-) diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index 298dd4f41..449df6779 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -20,7 +20,6 @@ as_tensor, cat, einsum, - mvp, solve_batch_cg, solve_linear, solve_lissa, diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 0cee9f016..4bcd99a1f 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -34,7 +34,6 @@ "zero_tensor", "transpose_tensor", "einsum", - "mvp", "lanzcos_low_rank_hessian_approx", ] @@ -121,7 +120,7 @@ def solve_batch_cg( total_grad_xy += grad_xy * len(x) total_points += len(x) backprop_on = model.parameters - reg_hvp = lambda v: mvp( + reg_hvp = lambda v: model.mvp( total_grad_xy / total_points, v, backprop_on ) + hessian_perturbation * v.type(torch.float64) batch_cg = torch.zeros_like(b) @@ -248,7 +247,9 @@ def lissa_step( for _ in maybe_progress(range(maxiter), progress, desc="Lissa"): x, y = next(iter(shuffled_training_data)) grad_xy = model.grad(x, y, create_graph=True) - reg_hvp = lambda v: mvp(grad_xy, v, model.parameters) + hessian_perturbation * v + reg_hvp = ( + lambda v: model.mvp(grad_xy, v, model.parameters) + hessian_perturbation * v + ) residual = lissa_step(h_estimate, reg_hvp) - h_estimate h_estimate += residual if torch.isnan(h_estimate).any(): @@ -324,45 +325,6 @@ def unsqueeze(x: torch.Tensor, dim: int) -> torch.Tensor: return x.unsqueeze(dim) -def mvp( - grad_xy: torch.Tensor, - v: torch.Tensor, - backprop_on: torch.Tensor, - *, - progress: bool = False, -) -> torch.Tensor: - """ - Calculates second order derivative of the model along directions v. - This second order derivative can be selected through the backprop_on argument. - - :param grad_xy: an array [P] holding the gradients of the model - parameters wrt input $x$ and labels $y$, where P is the number of - parameters of the model. It is typically obtained through - self.grad. - :param v: An array ([DxP] or even one dimensional [D]) which - multiplies the matrix, where D is the number of directions. - :param progress: True, iff progress shall be printed. - :param backprop_on: tensor used in the second backpropagation (the first - one is along $x$ and $y$ as defined via grad_xy). - :returns: A matrix representing the implicit matrix vector product - of the model along the given directions. Output shape is [DxP] if - backprop_on is None, otherwise [DxM], with M the number of elements - of backprop_on. - """ - device = grad_xy.device - v = as_tensor(v, warn=False).to(device) - if v.ndim == 1: - v = v.unsqueeze(0) - - z = (grad_xy * Variable(v)).sum(dim=1) - - mvp = [] - for i in maybe_progress(range(len(z)), progress, desc="MVP"): - mvp.append(flatten_all(autograd.grad(z[i], backprop_on, retain_graph=True))) - mvp = torch.stack([grad.contiguous().view(-1) for grad in mvp]) - return mvp.detach() # type: ignore - - class TorchTwiceDifferentiable(TwiceDifferentiable[torch.Tensor]): def __init__( self, @@ -443,6 +405,48 @@ def model_func(param): ) return torch.func.hessian(model_func)(params) + @staticmethod + def mvp( + grad_xy: torch.Tensor, + v: torch.Tensor, + backprop_on: torch.Tensor, + *, + progress: bool = False, + ) -> torch.Tensor: + """ + Calculates second order derivative of the model along directions v. + This second order derivative can be selected through the backprop_on argument. + + :param grad_xy: an array [P] holding the gradients of the model + parameters wrt input $x$ and labels $y$, where P is the number of + parameters of the model. It is typically obtained through + self.grad. + :param v: An array ([DxP] or even one dimensional [D]) which + multiplies the matrix, where D is the number of directions. + :param progress: True, iff progress shall be printed. + :param backprop_on: tensor used in the second backpropagation (the first + one is along $x$ and $y$ as defined via grad_xy). + :returns: A matrix representing the implicit matrix vector product + of the model along the given directions. Output shape is [DxP] if + backprop_on is None, otherwise [DxM], with M the number of elements + of backprop_on. + """ + device = grad_xy.device + v = as_tensor(v, warn=False).to(device) + if v.ndim == 1: + v = v.unsqueeze(0) + + z = (grad_xy * Variable(v)).sum(dim=1) + + mvp = [] + for i in maybe_progress(range(len(z)), progress, desc="MVP"): + mvp.append( + flatten_tensors_to_vector( + autograd.grad(z[i], backprop_on, retain_graph=True) + ) + ) + return torch.stack([grad.contiguous().view(-1) for grad in mvp]).detach() + @dataclass class LowRankProductRepresentation: diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index a12463461..1d38d6c62 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -34,7 +34,7 @@ def parameters(self) -> List[TensorType]: pass def grad( - self, x: TensorType, y: TensorType, create_graph: bool = True + self, x: TensorType, y: TensorType, create_graph: bool = False ) -> TensorType: """ Calculates gradient of model parameters wrt. the model parameters. @@ -61,3 +61,31 @@ def hessian(self, x: TensorType, y: TensorType) -> TensorType: model parameters. """ pass + + @staticmethod + @abstractmethod + def mvp( + grad_xy: TensorType, + v: TensorType, + backprop_on: TensorType, + *, + progress: bool = False, + ) -> TensorType: + """ + Calculates second order derivative of the model along directions v. + This second order derivative can be selected through the backprop_on argument. + + :param grad_xy: an array [P] holding the gradients of the model + parameters wrt input $x$ and labels $y$, where P is the number of + parameters of the model. It is typically obtained through + self.grad. + :param v: An array ([DxP] or even one dimensional [D]) which + multiplies the matrix, where D is the number of directions. + :param progress: True, iff progress shall be printed. + :param backprop_on: tensor used in the second backpropagation (the first + one is along $x$ and $y$ as defined via grad_xy). + :returns: A matrix representing the implicit matrix vector product + of the model along the given directions. Output shape is [DxP] if + backprop_on is None, otherwise [DxM], with M the number of elements + of backprop_on. + """ diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index c54a75837..488ec7e2d 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -13,7 +13,6 @@ TwiceDifferentiable, cat, einsum, - mvp, stack, ) from .frameworks.torch_differentiable import unsqueeze @@ -158,7 +157,7 @@ def compute_influences_pert( tensor_x = x[i : i + 1] tensor_x = tensor_x.requires_grad_(True) grad_xy = model.grad(tensor_x, y[i], create_graph=True) - perturbation_influences = mvp( + perturbation_influences = model.mvp( grad_xy, influence_factors, backprop_on=tensor_x, diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index f3fcad42a..7ecad0ffd 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -3,10 +3,9 @@ """ import logging from enum import Enum -from typing import Any +from typing import Any, Iterable, TypeVar from .frameworks import ( - DataLoaderType, InverseHvpResult, TensorType, TwiceDifferentiable, @@ -21,6 +20,8 @@ logger = logging.getLogger(__name__) +DataLoaderType = TypeVar("DataLoaderType", bound=Iterable) + class InversionMethod(str, Enum): """ diff --git a/tests/influence/test_torch_differentiable.py b/tests/influence/test_torch_differentiable.py index f8d80b819..490013bbe 100644 --- a/tests/influence/test_torch_differentiable.py +++ b/tests/influence/test_torch_differentiable.py @@ -25,7 +25,6 @@ from pydvl.influence.frameworks.torch_differentiable import ( TorchTwiceDifferentiable, - mvp, solve_batch_cg, solve_linear, solve_lissa, @@ -109,7 +108,7 @@ def test_linear_hessian( grad_xy = mvp_model.grad( torch.as_tensor(train_x), torch.as_tensor(train_y), create_graph=True ) - estimated_hessian = mvp( + estimated_hessian = mvp_model.mvp( grad_xy, torch.as_tensor(np.eye((input_dimension + 1) * output_dimension)), mvp_model.parameters, @@ -150,7 +149,7 @@ def test_linear_mixed_derivative( tensor_y = torch.as_tensor(train_y[i]) grad_xy = mvp_model.grad(tensor_x, tensor_y, create_graph=True) model_mvp.append( - mvp( + mvp_model.mvp( grad_xy, np.eye((input_dimension + 1) * output_dimension), backprop_on=tensor_x, From 2ec9f4fde53e625248fc43c50f16ec32befa9298 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Mon, 7 Aug 2023 09:08:22 +0200 Subject: [PATCH 225/436] Remove obsolete function --- src/pydvl/influence/frameworks/torch_differentiable.py | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 4bcd99a1f..320c27aa8 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -40,13 +40,6 @@ logger = logging.getLogger(__name__) -def flatten_all(grad: Iterable[torch.Tensor]) -> torch.Tensor: - """ - Simple function to flatten a pyTorch gradient for use in subsequent calculation - """ - return torch.cat([el.reshape(-1) for el in grad]) - - def solve_linear( model: "TorchTwiceDifferentiable", training_data: DataLoader, @@ -379,7 +372,7 @@ def grad( grad_f = torch.autograd.grad( loss_value, self.parameters, create_graph=create_graph ) - return flatten_all(grad_f) + return flatten_tensors_to_vector(grad_f) def hessian(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: """Calculates the explicit hessian of model parameters given data ($x$ and $y$). From 833b8f1cf6986c01bffbdffb4f346616e306b20a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Mon, 7 Aug 2023 12:36:16 +0200 Subject: [PATCH 226/436] Abstract tensor operations: adding abstract base class TensorUtilities, add torch implementation --- src/pydvl/influence/frameworks/__init__.py | 16 +-- .../frameworks/torch_differentiable.py | 114 +++++++----------- .../frameworks/twice_differentiable.py | 70 ++++++++++- src/pydvl/influence/frameworks/util.py | 13 +- src/pydvl/influence/general.py | 32 +++-- src/pydvl/influence/inversion.py | 14 +-- 6 files changed, 154 insertions(+), 105 deletions(-) diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index 449df6779..f40861ed0 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -16,21 +16,7 @@ __all__.append("TorchTwiceDifferentiable") - from .torch_differentiable import ( - as_tensor, - cat, - einsum, - solve_batch_cg, - solve_linear, - solve_lissa, - stack, - transpose_tensor, - zero_tensor, - ) - - TensorType = torch.Tensor - DataLoaderType = torch.utils.data.DataLoader - ModelType = torch.nn.Module + from .torch_differentiable import solve_batch_cg, solve_linear, solve_lissa __all__.extend( [ diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 320c27aa8..8e9c953bf 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -7,9 +7,8 @@ import logging from dataclasses import dataclass from functools import partial -from typing import Any, Callable, Iterable, List, Optional, Sequence, Tuple, Union +from typing import Callable, List, Optional, Sequence, Tuple -import numpy as np import torch import torch.nn as nn from numpy.typing import NDArray @@ -20,20 +19,14 @@ from ...utils import maybe_progress from .functional import get_hvp_function -from .twice_differentiable import InverseHvpResult, TwiceDifferentiable -from .util import align_structure, flatten_tensors_to_vector +from .twice_differentiable import InverseHvpResult, TensorUtilities, TwiceDifferentiable +from .util import align_structure, as_tensor, flatten_tensors_to_vector __all__ = [ "TorchTwiceDifferentiable", "solve_linear", "solve_batch_cg", "solve_lissa", - "as_tensor", - "stack", - "cat", - "zero_tensor", - "transpose_tensor", - "einsum", "lanzcos_low_rank_hessian_approx", ] @@ -59,6 +52,9 @@ def solve_linear( i.e. it returns $x$ such that $Hx = b$, and a dictionary containing information about the solution. """ + tensor_util = TensorUtilities.from_twice_differentiable(model) + cat = tensor_util.cat + eye = tensor_util.eye all_x, all_y = [], [] for x, y in training_data: @@ -67,9 +63,7 @@ def solve_linear( all_x = cat(all_x) all_y = cat(all_y) hessian = model.hessian(all_x, all_y) - matrix = hessian + hessian_perturbation * identity_tensor( - model.num_params, device=model.device - ) + matrix = hessian + hessian_perturbation * eye(model.num_params, device=model.device) info = {"hessian": hessian} return InverseHvpResult(x=torch.linalg.solve(matrix, b.T).T, info=info) @@ -262,62 +256,6 @@ def lissa_step( return InverseHvpResult(x=h_estimate / scale, info=info) -def as_tensor(a: Any, warn=True, **kwargs) -> torch.Tensor: - """Converts an array into a torch tensor - - :param a: array to convert to tensor - :param warn: if True, warns that a will be converted - """ - if warn and not isinstance(a, torch.Tensor): - logger.warning("Converting tensor to type torch.Tensor.") - return torch.as_tensor(a, **kwargs) - - -def stack(a: Sequence[torch.Tensor], **kwargs) -> torch.Tensor: - """Stacks a sequence of tensors into a single torch tensor""" - return torch.stack(a, **kwargs) - - -def cat(a: Sequence[torch.Tensor], **kwargs) -> torch.Tensor: - """Concatenates a sequence of tensors into a single torch tensor""" - return torch.cat(a, **kwargs) - - -def zero_tensor( - shape: Sequence[int], dtype: Union[np.dtype, torch.dtype], **kwargs -) -> torch.Tensor: - """Returns a tensor of shape :attr:`shape` filled with zeros.""" - if isinstance(dtype, np.dtype): - dtype = getattr(torch, dtype.name) - return torch.zeros(shape, dtype=dtype, **kwargs) - - -def transpose_tensor(a: torch.Tensor, dim0: int, dim1: int) -> torch.Tensor: - return torch.transpose(a, dim0, dim1) - - -def einsum(equation, *operands) -> torch.Tensor: - """Sums the product of the elements of the input :attr:`operands` along dimensions specified using a notation - based on the Einstein summation convention. - """ - return torch.einsum(equation, *operands) - - -def identity_tensor(dim: int, **kwargs) -> torch.Tensor: - return torch.eye(dim, dim, **kwargs) - - -def unsqueeze(x: torch.Tensor, dim: int) -> torch.Tensor: - """ - Add a singleton dimension at a specified position in a tensor. - - :param x: A PyTorch tensor. - :param dim: The position at which to add the singleton dimension. Zero-based indexing. - :return: A new tensor with an additional singleton dimension. - """ - return x.unsqueeze(dim) - - class TorchTwiceDifferentiable(TwiceDifferentiable[torch.Tensor]): def __init__( self, @@ -644,3 +582,41 @@ def mv(x): eigen_vecs = to_torch_conversion_function(eigen_vecs) return LowRankProductRepresentation(eigen_vals, eigen_vecs) + + +class TorchTensorUtilities(TensorUtilities[torch.Tensor]): + + twice_differentiable_type = TorchTwiceDifferentiable + + @staticmethod + def einsum(equation, *operands) -> torch.Tensor: + """Sums the product of the elements of the input :attr:`operands` along dimensions specified using a notation + based on the Einstein summation convention. + """ + return torch.einsum(equation, *operands) + + @staticmethod + def cat(a: Sequence[torch.Tensor], **kwargs) -> torch.Tensor: + """Concatenates a sequence of tensors into a single torch tensor""" + return torch.cat(a, **kwargs) + + @staticmethod + def stack(a: Sequence[torch.Tensor], **kwargs) -> torch.Tensor: + """Stacks a sequence of tensors into a single torch tensor""" + return torch.stack(a, **kwargs) + + @staticmethod + def unsqueeze(x: torch.Tensor, dim: int) -> torch.Tensor: + """ + Add a singleton dimension at a specified position in a tensor. + + :param x: A PyTorch tensor. + :param dim: The position at which to add the singleton dimension. Zero-based indexing. + :return: A new tensor with an additional singleton dimension. + """ + return x.unsqueeze(dim) + + @staticmethod + def eye(dim: int, **kwargs) -> torch.Tensor: + """Identity tensor of dimension dim""" + return torch.eye(dim, dim, **kwargs) diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index 1d38d6c62..f447d42b3 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -1,6 +1,6 @@ from abc import ABC, abstractmethod from dataclasses import dataclass -from typing import Any, Callable, Dict, Generic, List, Sequence, Tuple, TypeVar +from typing import Any, Dict, Generic, List, Sequence, Type, TypeVar TensorType = TypeVar("TensorType", bound=Sequence) ModelType = TypeVar("ModelType") @@ -89,3 +89,71 @@ def mvp( backprop_on is None, otherwise [DxM], with M the number of elements of backprop_on. """ + + +class TensorUtilities(Generic[TensorType], ABC): + + twice_differentiable_type: Type[TwiceDifferentiable] + registry: Dict[Type[TwiceDifferentiable], Type["TensorUtilities"]] = {} + + def __init_subclass__(cls, abstract: bool = False, **kwargs): + """ + Automatically registers non-abstract subclasses in the registry. + + Checks if `twice_differentiable_type` is defined in the subclass and + is of correct type. Raises `TypeError` if either attribute is missing or incorrect. + + :param abstract: If True, the subclass won't be registered. Default is False. + :param kwargs: Additional keyword arguments. + :raise TypeError: If the subclass does not define `twice_differentiable_type`, + or if it is not of correct type. + """ + if not abstract: + if not hasattr(cls, "twice_differentiable_type") or not isinstance( + cls.twice_differentiable_type, type + ): + raise TypeError( + f"'twice_differentiable_type' must be a Type[TwiceDifferentiable]" + ) + + cls.registry[cls.twice_differentiable_type] = cls + + super().__init_subclass__(**kwargs) + + @staticmethod + @abstractmethod + def einsum(equation, *operands) -> TensorType: + """Sums the product of the elements of the input :attr:`operands` along dimensions specified using a notation + based on the Einstein summation convention. + """ + + @staticmethod + @abstractmethod + def cat(a: Sequence[TensorType], **kwargs) -> TensorType: + """Concatenates a sequence of tensors into a single torch tensor""" + + @staticmethod + @abstractmethod + def stack(a: Sequence[TensorType], **kwargs) -> TensorType: + """Stacks a sequence of tensors into a single torch tensor""" + + @staticmethod + @abstractmethod + def unsqueeze(x: TensorType, dim: int) -> TensorType: + """Add a singleton dimension at a specified position in a tensor""" + + @staticmethod + @abstractmethod + def eye(dim: int, **kwargs) -> TensorType: + """Identity tensor of dimension dim""" + + @staticmethod + def from_twice_differentiable( + twice_diff: TwiceDifferentiable, + ) -> Type["TensorUtilities"]: + tu = TensorUtilities.registry.get(type(twice_diff), None) + + if tu is None: + raise KeyError() + + return tu diff --git a/src/pydvl/influence/frameworks/util.py b/src/pydvl/influence/frameworks/util.py index e63c77729..b2e2987cb 100644 --- a/src/pydvl/influence/frameworks/util.py +++ b/src/pydvl/influence/frameworks/util.py @@ -1,6 +1,6 @@ import logging import math -from typing import Dict, Iterable, Tuple, TypeVar +from typing import Any, Dict, Iterable, Tuple, TypeVar import torch @@ -165,3 +165,14 @@ def hessian_from_dict(hessian_dict): hessian = torch.stack(hessian_rows) return hessian + + +def as_tensor(a: Any, warn=True, **kwargs) -> torch.Tensor: + """Converts an array into a torch tensor + + :param a: array to convert to tensor + :param warn: if True, warns that a will be converted + """ + if warn and not isinstance(a, torch.Tensor): + logger.warning("Converting tensor to type torch.Tensor.") + return torch.as_tensor(a, **kwargs) diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 488ec7e2d..9eb40a530 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -7,16 +7,12 @@ from typing import Any, Optional from ..utils import maybe_progress -from .frameworks import ( - DataLoaderType, +from .frameworks.twice_differentiable import ( TensorType, + TensorUtilities, TwiceDifferentiable, - cat, - einsum, - stack, ) -from .frameworks.torch_differentiable import unsqueeze -from .inversion import InverseHvpResult, InversionMethod, solve_hvp +from .inversion import DataLoaderType, InverseHvpResult, InversionMethod, solve_hvp __all__ = ["compute_influences", "InfluenceType", "compute_influence_factors"] @@ -63,6 +59,11 @@ def compute_influence_factors( :returns: An array of size (N, D) containing the influence factors for each dimension (D) and test sample (N). """ + tensor_util = TensorUtilities.from_twice_differentiable(model) + stack = tensor_util.stack + unsqueeze = tensor_util.unsqueeze + cat = tensor_util.cat + test_grads = [] for x_test, y_test in maybe_progress( test_data, progress, desc="Batch Test Gradients" @@ -74,12 +75,11 @@ def compute_influence_factors( ] ) test_grads.append(test_grad) - test_grads = cat(test_grads) return solve_hvp( inversion_method, model, training_data, - test_grads, + cat(test_grads), hessian_perturbation=hessian_perturbation, progress=progress, **kwargs, @@ -110,6 +110,13 @@ def compute_influences_up( :returns: An array of size [NxM], where N is number of influence factors, M number of input points. """ + + tensor_util = TensorUtilities.from_twice_differentiable(model) + stack = tensor_util.stack + unsqueeze = tensor_util.unsqueeze + cat = tensor_util.cat + einsum = tensor_util.einsum + train_grads = [] for x, y in maybe_progress( input_data, progress, desc="Batch Split Input Gradients" @@ -119,8 +126,7 @@ def compute_influences_up( ) train_grads.append(train_grad) - train_grads = cat(train_grads) - return einsum("ta,va->tv", influence_factors, train_grads) + return einsum("ta,va->tv", influence_factors, cat(train_grads)) def compute_influences_pert( @@ -147,6 +153,10 @@ def compute_influences_pert( :returns: An array of size [NxMxP], where N is the number of influence factors, M the number of input data, and P the number of features. """ + + tensor_util = TensorUtilities.from_twice_differentiable(model) + stack = tensor_util.stack + all_pert_influences = [] for x, y in maybe_progress( input_data, diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 7ecad0ffd..b8badb01c 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -5,18 +5,16 @@ from enum import Enum from typing import Any, Iterable, TypeVar -from .frameworks import ( - InverseHvpResult, - TensorType, - TwiceDifferentiable, - solve_batch_cg, - solve_linear, - solve_lissa, -) +from .frameworks import solve_batch_cg, solve_linear, solve_lissa __all__ = ["solve_hvp"] from .frameworks.torch_differentiable import solve_arnoldi +from .frameworks.twice_differentiable import ( + InverseHvpResult, + TensorType, + TwiceDifferentiable, +) logger = logging.getLogger(__name__) From e93dabc4c2498bce57d0e91406e582f37b60c4c6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Mon, 7 Aug 2023 20:13:13 +0200 Subject: [PATCH 227/436] Refactor usage of torch framework: * introduce a dynamic registry for inversion methods * make top level modules independent of the torch implementation --- src/pydvl/influence/__init__.py | 4 +- src/pydvl/influence/frameworks/__init__.py | 49 +- .../frameworks/torch_differentiable.py | 657 +++++++++--------- .../frameworks/twice_differentiable.py | 11 +- src/pydvl/influence/general.py | 26 +- src/pydvl/influence/inversion.py | 179 +++-- tests/influence/test_influences.py | 4 +- tests/influence/test_torch_differentiable.py | 2 +- 8 files changed, 498 insertions(+), 434 deletions(-) diff --git a/src/pydvl/influence/__init__.py b/src/pydvl/influence/__init__.py index 570c4056a..41d5dc993 100644 --- a/src/pydvl/influence/__init__.py +++ b/src/pydvl/influence/__init__.py @@ -7,5 +7,5 @@ probably change. """ -from .frameworks import TorchTwiceDifferentiable, TwiceDifferentiable -from .general import compute_influence_factors, compute_influences +from .general import InfluenceType, compute_influence_factors, compute_influences +from .inversion import InversionMethod diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index f40861ed0..d041e5930 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -1,42 +1,7 @@ -# FIXME the following code was part of an attempt to accommodate different -# frameworks. In its current form it is ugly and thus it will likely be changed -# in the future. - -import logging - -from .twice_differentiable import InverseHvpResult, TwiceDifferentiable - -__all__ = ["TwiceDifferentiable"] -logger = logging.getLogger("frameworks") - -try: - import torch - - from .torch_differentiable import TorchTwiceDifferentiable - - __all__.append("TorchTwiceDifferentiable") - - from .torch_differentiable import solve_batch_cg, solve_linear, solve_lissa - - __all__.extend( - [ - "TensorType", - "ModelType", - "InverseHvpResult", - "solve_linear", - "solve_batch_cg", - "solve_lissa", - "as_tensor", - "stack", - "cat", - "zero_tensor", - "transpose_tensor", - "einsum", - "mvp", - ] - ) - -except ImportError: - logger.info( - "No compatible framework found. Influence function computation disabled." - ) +from .torch_differentiable import ( + TorchTwiceDifferentiable, + solve_arnoldi, + solve_batch_cg, + solve_linear, + solve_lissa, +) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 8e9c953bf..bdb1b1028 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -18,6 +18,7 @@ from torch.utils.data import DataLoader from ...utils import maybe_progress +from ..inversion import InversionMethod, InversionRegistry from .functional import get_hvp_function from .twice_differentiable import InverseHvpResult, TensorUtilities, TwiceDifferentiable from .util import align_structure, as_tensor, flatten_tensors_to_vector @@ -27,235 +28,13 @@ "solve_linear", "solve_batch_cg", "solve_lissa", + "solve_arnoldi", "lanzcos_low_rank_hessian_approx", ] logger = logging.getLogger(__name__) -def solve_linear( - model: "TorchTwiceDifferentiable", - training_data: DataLoader, - b: torch.Tensor, - *, - hessian_perturbation: float = 0.0, -) -> InverseHvpResult: - """Given a model and training data, it finds x s.t. $Hx = b$, with $H$ being - the model hessian. - - :param model: A model wrapped in the TwiceDifferentiable interface. - :param training_data: A DataLoader containing the training data. - :param b: a vector or matrix, the right hand side of the equation $Hx = b$. - :param hessian_perturbation: regularization of the hessian - - :return: An array that solves the inverse problem, - i.e. it returns $x$ such that $Hx = b$, and a dictionary containing - information about the solution. - """ - tensor_util = TensorUtilities.from_twice_differentiable(model) - cat = tensor_util.cat - eye = tensor_util.eye - - all_x, all_y = [], [] - for x, y in training_data: - all_x.append(x) - all_y.append(y) - all_x = cat(all_x) - all_y = cat(all_y) - hessian = model.hessian(all_x, all_y) - matrix = hessian + hessian_perturbation * eye(model.num_params, device=model.device) - info = {"hessian": hessian} - return InverseHvpResult(x=torch.linalg.solve(matrix, b.T).T, info=info) - - -def solve_batch_cg( - model: "TorchTwiceDifferentiable", - training_data: DataLoader, - b: torch.Tensor, - *, - hessian_perturbation: float = 0.0, - x0: Optional[torch.Tensor] = None, - rtol: float = 1e-7, - atol: float = 1e-7, - maxiter: Optional[int] = None, - progress: bool = False, -) -> InverseHvpResult: - """ - Given a model and training data, it uses conjugate gradient to calculate the - inverse of the Hessian Vector Product. More precisely, it finds x s.t. $Hx = - b$, with $H$ being the model hessian. For more info, see - `Wikipedia `_ - - :param model: A model wrapped in the TwiceDifferentiable interface. - :param training_data: A DataLoader containing the training data. - :param b: a vector or matrix, the right hand side of the equation $Hx = b$. - :param hessian_perturbation: regularization of the hessian - :param x0: initial guess for hvp. If None, defaults to b - :param rtol: maximum relative tolerance of result - :param atol: absolute tolerance of result - :param maxiter: maximum number of iterations. If None, defaults to 10*len(b) - :param progress: If True, display progress bars. - - :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$, - and a dictionary containing information about the convergence of CG, one - entry for each line of the matrix. - """ - total_grad_xy = 0 - total_points = 0 - for x, y in maybe_progress(training_data, progress, desc="Batch Train Gradients"): - grad_xy = model.grad(x, y, create_graph=True) - total_grad_xy += grad_xy * len(x) - total_points += len(x) - backprop_on = model.parameters - reg_hvp = lambda v: model.mvp( - total_grad_xy / total_points, v, backprop_on - ) + hessian_perturbation * v.type(torch.float64) - batch_cg = torch.zeros_like(b) - info = {} - for idx, bi in enumerate(maybe_progress(b, progress, desc="Conjugate gradient")): - batch_result, batch_info = solve_cg( - reg_hvp, bi, x0=x0, rtol=rtol, atol=atol, maxiter=maxiter - ) - batch_cg[idx] = batch_result - info[f"batch_{idx}"] = batch_info - return InverseHvpResult(x=batch_cg, info=info) - - -def solve_cg( - hvp: Callable[[torch.Tensor], torch.Tensor], - b: torch.Tensor, - *, - x0: Optional[torch.Tensor] = None, - rtol: float = 1e-7, - atol: float = 1e-7, - maxiter: Optional[int] = None, -) -> InverseHvpResult: - """Conjugate gradient solver for the Hessian vector product - - :param hvp: a Callable Hvp, operating with tensors of size N - :param b: a vector or matrix, the right hand side of the equation $Hx = b$. - :param x0: initial guess for hvp - :param rtol: maximum relative tolerance of result - :param atol: absolute tolerance of result - :param maxiter: maximum number of iterations. If None, defaults to 10*len(b) - - :return: A vector x, solution of $Ax=b$, and a dictionary containing - information about the convergence of CG. - """ - if x0 is None: - x0 = torch.clone(b) - if maxiter is None: - maxiter = len(b) * 10 - - y_norm = torch.sum(torch.matmul(b, b)).item() - stopping_val = max([rtol**2 * y_norm, atol**2]) - - x = x0 - p = r = (b - hvp(x)).squeeze().type(torch.float64) - gamma = torch.sum(torch.matmul(r, r)).item() - optimal = False - - for k in range(maxiter): - if gamma < stopping_val: - optimal = True - break - Ap = hvp(p).squeeze() - alpha = gamma / torch.sum(torch.matmul(p, Ap)).item() - x += alpha * p - r -= alpha * Ap - gamma_ = torch.sum(torch.matmul(r, r)).item() - beta = gamma_ / gamma - gamma = gamma_ - p = r + beta * p - - info = {"niter": k, "optimal": optimal, "gamma": gamma} - return InverseHvpResult(x=x, info=info) - - -def solve_lissa( - model: "TorchTwiceDifferentiable", - training_data: DataLoader, - b: torch.Tensor, - *, - hessian_perturbation: float = 0.0, - maxiter: int = 1000, - dampen: float = 0.0, - scale: float = 10.0, - h0: Optional[torch.Tensor] = None, - rtol: float = 1e-4, - progress: bool = False, -) -> InverseHvpResult: - r""" - Uses LISSA, Linear time Stochastic Second-Order Algorithm, to iteratively - approximate the inverse Hessian. More precisely, it finds x s.t. $Hx = b$, - with $H$ being the model's second derivative wrt. the parameters. - This is done with the update - - $$H^{-1}_{j+1} b = b + (I - d) \ H - \frac{H^{-1}_j b}{s},$$ - - where $I$ is the identity matrix, $d$ is a dampening term and $s$ a scaling - factor that are applied to help convergence. For details, see - :footcite:t:`koh_understanding_2017` and the original paper - :footcite:t:`agarwal_2017_second`. - - :param model: A model wrapped in the TwiceDifferentiable interface. - :param training_data: A DataLoader containing the training data. - :param b: a vector or matrix, the right hand side of the equation $Hx = b$. - :param hessian_perturbation: regularization of the hessian - :param progress: If True, display progress bars. - :param maxiter: maximum number of iterations, - :param dampen: dampening factor, defaults to 0 for no dampening - :param scale: scaling factor, defaults to 10 - :param h0: initial guess for hvp - - :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$, - and a dictionary containing information about the accuracy of the solution. - """ - if h0 is None: - h_estimate = torch.clone(b) - else: - h_estimate = h0 - shuffled_training_data = DataLoader( - training_data.dataset, training_data.batch_size, shuffle=True - ) - - def lissa_step( - h: torch.Tensor, reg_hvp: Callable[[torch.Tensor], torch.Tensor] - ) -> torch.Tensor: - """Given an estimate of the hessian inverse and the regularised hessian - vector product, it computes the next estimate. - - :param h: an estimate of the hessian inverse - :param reg_hvp: regularised hessian vector product - :return: the next estimate of the hessian inverse - """ - return b + (1 - dampen) * h - reg_hvp(h) / scale - - for _ in maybe_progress(range(maxiter), progress, desc="Lissa"): - x, y = next(iter(shuffled_training_data)) - grad_xy = model.grad(x, y, create_graph=True) - reg_hvp = ( - lambda v: model.mvp(grad_xy, v, model.parameters) + hessian_perturbation * v - ) - residual = lissa_step(h_estimate, reg_hvp) - h_estimate - h_estimate += residual - if torch.isnan(h_estimate).any(): - raise RuntimeError("NaNs in h_estimate. Increase scale or dampening.") - max_residual = torch.max(torch.abs(residual / h_estimate)) - if max_residual < rtol: - break - mean_residual = torch.mean(torch.abs(residual / h_estimate)) - logger.info( - f"Terminated Lissa with {max_residual*100:.2f} % max residual." - f" Mean residual: {mean_residual*100:.5f} %" - ) - info = { - "max_perc_residual": max_residual * 100, - "mean_perc_residual": mean_residual * 100, - } - return InverseHvpResult(x=h_estimate / scale, info=info) - - class TorchTwiceDifferentiable(TwiceDifferentiable[torch.Tensor]): def __init__( self, @@ -277,6 +56,10 @@ def __init__( self.model = model self.device = model.device if hasattr(model, "device") else torch.device("cpu") + @classmethod + def tensor_type(cls): + return torch.Tensor + @property def parameters(self) -> List[torch.Tensor]: """Returns all the model parameters that require differentiating""" @@ -389,125 +172,41 @@ class LowRankProductRepresentation: """ eigen_vals: torch.Tensor + projections: torch.Tensor -def solve_arnoldi( - model: TorchTwiceDifferentiable, - training_data: DataLoader, - b: torch.Tensor, - *, +def lanzcos_low_rank_hessian_approx( + hessian_vp: Callable[[torch.Tensor], torch.Tensor], + matrix_shape: Tuple[int, int], hessian_perturbation: float = 0.0, rank_estimate: int = 10, krylov_dimension: Optional[int] = None, - low_rank_representation: Optional[LowRankProductRepresentation] = None, tol: float = 1e-6, max_iter: Optional[int] = None, + device: Optional[torch.device] = None, eigen_computation_on_gpu: bool = False, -) -> InverseHvpResult: - + torch_dtype: torch.dtype = None, +) -> LowRankProductRepresentation: """ - Solves the linear system Hx = b, where H is the Hessian of the model's loss function and b is the given right-hand - side vector. The Hessian is approximated using a low-rank representation. + Calculates a low-rank approximation of the Hessian matrix of the model's loss function using the implicitly + restarted Lanczos algorithm. - :param model: A PyTorch model instance that is twice differentiable, wrapped into :class:`TorchTwiceDifferential`. - The Hessian will be calculated with respect to this model's parameters. - :param training_data: A DataLoader instance that provides the model's training data. - Used in calculating the Hessian-vector products. - :param b: The right-hand side vector in the system Hx = b. + + :param hessian_vp: A function that takes a vector and returns the product of the Hessian of the loss function + :param matrix_shape: The shape of the matrix, represented by hessian vector product. :param hessian_perturbation: Optional regularization parameter added to the Hessian-vector product for numerical stability. :param rank_estimate: The number of eigenvalues and corresponding eigenvectors to compute. Represents the desired rank of the Hessian approximation. :param krylov_dimension: The number of Krylov vectors to use for the Lanczos method. If not provided, it defaults to $min(model.num_parameters, max(2*rank_estimate + 1, 20))$. - :param low_rank_representation: A LowRankProductRepresentation instance containing a previously computed - low-rank representation of the Hessian. - If not provided, a new low-rank representation will be computed, - using provided parameters. - :param tol: The stopping criteria for the Lanczos algorithm. - If `low_rank_representation` is provided, this parameter is ignored. - :param max_iter: The maximum number of iterations for the Lanczos method. - If `low_rank_representation` is provided, this parameter is ignored. - :param eigen_computation_on_gpu: If True, tries to execute the eigen pair approximation on the model's - device via cupy implementation. - Make sure, that either your model is small enough or you use a - small rank_estimate to fit your device's memory. - If False, the eigen pair approximation is executed on the CPU by scipy wrapper to - ARPACK. - :return: Returns the solution vector x that satisfies the system Hx = b, - where H is a low-rank approximation of the Hessian of the model's loss function. - """ - - if low_rank_representation is None: - - raw_hvp = get_hvp_function( - model.model, model.loss, training_data, use_hessian_avg=True - ) - params = dict(model.model.named_parameters()) - - def hessian_vector_product(x: torch.Tensor) -> torch.Tensor: - output = raw_hvp(align_structure(params, x)) - return flatten_tensors_to_vector(output.values()) - - low_rank_representation = lanzcos_low_rank_hessian_approx( - hessian_vp=hessian_vector_product, - matrix_shape=(model.num_params, model.num_params), - hessian_perturbation=hessian_perturbation, - rank_estimate=rank_estimate, - krylov_dimension=krylov_dimension, - tol=tol, - max_iter=max_iter, - device=model.device if hasattr(model, "device") else None, - eigen_computation_on_gpu=eigen_computation_on_gpu, - ) - else: - logger.info("Using provided low rank representation, ignoring other parameters") - - result = low_rank_representation.projections @ ( - torch.diag_embed(1.0 / low_rank_representation.eigen_vals) - @ (low_rank_representation.projections.t() @ b.t()) - ) - return InverseHvpResult( - x=result.t(), - info={ - "eigenvalues": low_rank_representation.eigen_vals, - "eigenvectors": low_rank_representation.projections, - }, - ) - - -def lanzcos_low_rank_hessian_approx( - hessian_vp: Callable[[torch.Tensor], torch.Tensor], - matrix_shape: Tuple[int, int], - hessian_perturbation: float = 0.0, - rank_estimate: int = 10, - krylov_dimension: Optional[int] = None, - tol: float = 1e-6, - max_iter: Optional[int] = None, - device: Optional[torch.device] = None, - eigen_computation_on_gpu: bool = False, - torch_dtype: torch.dtype = None, -) -> LowRankProductRepresentation: - """ - Calculates a low-rank approximation of the Hessian matrix of the model's loss function using the implicitly - restarted Lanczos algorithm. - - - :param hessian_vp: A function that takes a vector and returns the product of the Hessian of the loss function - :param matrix_shape: The shape of the matrix, represented by hessian vector product. - :param hessian_perturbation: Optional regularization parameter added to the Hessian-vector product - for numerical stability. - :param rank_estimate: The number of eigenvalues and corresponding eigenvectors to compute. - Represents the desired rank of the Hessian approximation. - :param krylov_dimension: The number of Krylov vectors to use for the Lanczos method. - If not provided, it defaults to $min(model.num_parameters, max(2*rank_estimate + 1, 20))$. - :param tol: The stopping criteria for the Lanczos algorithm, which stops when the difference - in the approximated eigenvalue is less than `tol`. Defaults to 1e-6. - :param max_iter: The maximum number of iterations for the Lanczos method. If not provided, it defaults to - $10*model.num_parameters$ - :param device: The device to use for executing the hessian vector product. - :param eigen_computation_on_gpu: If True, tries to execute the eigen pair approximation on the provided + :param tol: The stopping criteria for the Lanczos algorithm, which stops when the difference + in the approximated eigenvalue is less than `tol`. Defaults to 1e-6. + :param max_iter: The maximum number of iterations for the Lanczos method. If not provided, it defaults to + $10*model.num_parameters$ + :param device: The device to use for executing the hessian vector product. + :param eigen_computation_on_gpu: If True, tries to execute the eigen pair approximation on the provided device via cupy implementation. Make sure, that either your model is small enough or you use a small rank_estimate to fit your device's memory. @@ -620,3 +319,311 @@ def unsqueeze(x: torch.Tensor, dim: int) -> torch.Tensor: def eye(dim: int, **kwargs) -> torch.Tensor: """Identity tensor of dimension dim""" return torch.eye(dim, dim, **kwargs) + + +@InversionRegistry.register(TorchTwiceDifferentiable, InversionMethod.Direct) +def solve_linear( + model: TorchTwiceDifferentiable, + training_data: DataLoader, + b: torch.Tensor, + hessian_perturbation: float = 0.0, +) -> InverseHvpResult: + """Given a model and training data, it finds x s.t. $Hx = b$, with $H$ being + the model hessian. + + :param model: A model wrapped in the TwiceDifferentiable interface. + :param training_data: A DataLoader containing the training data. + :param b: a vector or matrix, the right hand side of the equation $Hx = b$. + :param hessian_perturbation: regularization of the hessian + + :return: An array that solves the inverse problem, + i.e. it returns $x$ such that $Hx = b$, and a dictionary containing + information about the solution. + """ + + all_x, all_y = [], [] + for x, y in training_data: + all_x.append(x) + all_y.append(y) + hessian = model.hessian(torch.cat(all_x), torch.cat(all_y)) + matrix = hessian + hessian_perturbation * torch.eye( + model.num_params, device=model.device + ) + info = {"hessian": hessian} + return InverseHvpResult(x=torch.linalg.solve(matrix, b.T).T, info=info) + + +@InversionRegistry.register(TorchTwiceDifferentiable, InversionMethod.Cg) +def solve_batch_cg( + model: TorchTwiceDifferentiable, + training_data: DataLoader, + b: torch.Tensor, + hessian_perturbation: float = 0.0, + *, + x0: Optional[torch.Tensor] = None, + rtol: float = 1e-7, + atol: float = 1e-7, + maxiter: Optional[int] = None, + progress: bool = False, +) -> InverseHvpResult: + """ + Given a model and training data, it uses conjugate gradient to calculate the + inverse of the Hessian Vector Product. More precisely, it finds x s.t. $Hx = + b$, with $H$ being the model hessian. For more info, see + `Wikipedia `_ + + :param model: A model wrapped in the TwiceDifferentiable interface. + :param training_data: A DataLoader containing the training data. + :param b: a vector or matrix, the right hand side of the equation $Hx = b$. + :param hessian_perturbation: regularization of the hessian + :param x0: initial guess for hvp. If None, defaults to b + :param rtol: maximum relative tolerance of result + :param atol: absolute tolerance of result + :param maxiter: maximum number of iterations. If None, defaults to 10*len(b) + :param progress: If True, display progress bars. + + :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$, + and a dictionary containing information about the convergence of CG, one + entry for each line of the matrix. + """ + total_grad_xy = 0 + total_points = 0 + for x, y in maybe_progress(training_data, progress, desc="Batch Train Gradients"): + grad_xy = model.grad(x, y, create_graph=True) + total_grad_xy += grad_xy * len(x) + total_points += len(x) + backprop_on = model.parameters + reg_hvp = lambda v: model.mvp( + total_grad_xy / total_points, v, backprop_on + ) + hessian_perturbation * v.type(torch.float64) + batch_cg = torch.zeros_like(b) + info = {} + for idx, bi in enumerate(maybe_progress(b, progress, desc="Conjugate gradient")): + batch_result, batch_info = solve_cg( + reg_hvp, bi, x0=x0, rtol=rtol, atol=atol, maxiter=maxiter + ) + batch_cg[idx] = batch_result + info[f"batch_{idx}"] = batch_info + return InverseHvpResult(x=batch_cg, info=info) + + +def solve_cg( + hvp: Callable[[torch.Tensor], torch.Tensor], + b: torch.Tensor, + *, + x0: Optional[torch.Tensor] = None, + rtol: float = 1e-7, + atol: float = 1e-7, + maxiter: Optional[int] = None, +) -> InverseHvpResult: + """Conjugate gradient solver for the Hessian vector product + + :param hvp: a Callable Hvp, operating with tensors of size N + :param b: a vector or matrix, the right hand side of the equation $Hx = b$. + :param x0: initial guess for hvp + :param rtol: maximum relative tolerance of result + :param atol: absolute tolerance of result + :param maxiter: maximum number of iterations. If None, defaults to 10*len(b) + + :return: A vector x, solution of $Ax=b$, and a dictionary containing + information about the convergence of CG. + """ + if x0 is None: + x0 = torch.clone(b) + if maxiter is None: + maxiter = len(b) * 10 + + y_norm = torch.sum(torch.matmul(b, b)).item() + stopping_val = max([rtol**2 * y_norm, atol**2]) + + x = x0 + p = r = (b - hvp(x)).squeeze().type(torch.float64) + gamma = torch.sum(torch.matmul(r, r)).item() + optimal = False + + for k in range(maxiter): + if gamma < stopping_val: + optimal = True + break + Ap = hvp(p).squeeze() + alpha = gamma / torch.sum(torch.matmul(p, Ap)).item() + x += alpha * p + r -= alpha * Ap + gamma_ = torch.sum(torch.matmul(r, r)).item() + beta = gamma_ / gamma + gamma = gamma_ + p = r + beta * p + + info = {"niter": k, "optimal": optimal, "gamma": gamma} + return InverseHvpResult(x=x, info=info) + + +@InversionRegistry.register(TorchTwiceDifferentiable, InversionMethod.Lissa) +def solve_lissa( + model: TorchTwiceDifferentiable, + training_data: DataLoader, + b: torch.Tensor, + hessian_perturbation: float = 0.0, + *, + maxiter: int = 1000, + dampen: float = 0.0, + scale: float = 10.0, + h0: Optional[torch.Tensor] = None, + rtol: float = 1e-4, + progress: bool = False, +) -> InverseHvpResult: + r""" + Uses LISSA, Linear time Stochastic Second-Order Algorithm, to iteratively + approximate the inverse Hessian. More precisely, it finds x s.t. $Hx = b$, + with $H$ being the model's second derivative wrt. the parameters. + This is done with the update + + $$H^{-1}_{j+1} b = b + (I - d) \ H - \frac{H^{-1}_j b}{s},$$ + + where $I$ is the identity matrix, $d$ is a dampening term and $s$ a scaling + factor that are applied to help convergence. For details, see + :footcite:t:`koh_understanding_2017` and the original paper + :footcite:t:`agarwal_2017_second`. + + :param model: A model wrapped in the TwiceDifferentiable interface. + :param training_data: A DataLoader containing the training data. + :param b: a vector or matrix, the right hand side of the equation $Hx = b$. + :param hessian_perturbation: regularization of the hessian + :param progress: If True, display progress bars. + :param maxiter: maximum number of iterations, + :param dampen: dampening factor, defaults to 0 for no dampening + :param scale: scaling factor, defaults to 10 + :param h0: initial guess for hvp + + :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$, + and a dictionary containing information about the accuracy of the solution. + """ + if h0 is None: + h_estimate = torch.clone(b) + else: + h_estimate = h0 + shuffled_training_data = DataLoader( + training_data.dataset, training_data.batch_size, shuffle=True + ) + + def lissa_step( + h: torch.Tensor, reg_hvp: Callable[[torch.Tensor], torch.Tensor] + ) -> torch.Tensor: + """Given an estimate of the hessian inverse and the regularised hessian + vector product, it computes the next estimate. + + :param h: an estimate of the hessian inverse + :param reg_hvp: regularised hessian vector product + :return: the next estimate of the hessian inverse + """ + return b + (1 - dampen) * h - reg_hvp(h) / scale + + for _ in maybe_progress(range(maxiter), progress, desc="Lissa"): + x, y = next(iter(shuffled_training_data)) + grad_xy = model.grad(x, y, create_graph=True) + reg_hvp = ( + lambda v: model.mvp(grad_xy, v, model.parameters) + hessian_perturbation * v + ) + residual = lissa_step(h_estimate, reg_hvp) - h_estimate + h_estimate += residual + if torch.isnan(h_estimate).any(): + raise RuntimeError("NaNs in h_estimate. Increase scale or dampening.") + max_residual = torch.max(torch.abs(residual / h_estimate)) + if max_residual < rtol: + break + mean_residual = torch.mean(torch.abs(residual / h_estimate)) + logger.info( + f"Terminated Lissa with {max_residual*100:.2f} % max residual." + f" Mean residual: {mean_residual*100:.5f} %" + ) + info = { + "max_perc_residual": max_residual * 100, + "mean_perc_residual": mean_residual * 100, + } + return InverseHvpResult(x=h_estimate / scale, info=info) + + +@InversionRegistry.register(TorchTwiceDifferentiable, InversionMethod.Arnoldi) +def solve_arnoldi( + model: TorchTwiceDifferentiable, + training_data: DataLoader, + b: torch.Tensor, + hessian_perturbation: float = 0.0, + *, + rank_estimate: int = 10, + krylov_dimension: Optional[int] = None, + low_rank_representation: Optional[LowRankProductRepresentation] = None, + tol: float = 1e-6, + max_iter: Optional[int] = None, + eigen_computation_on_gpu: bool = False, +) -> InverseHvpResult: + + """ + Solves the linear system Hx = b, where H is the Hessian of the model's loss function and b is the given right-hand + side vector. The Hessian is approximated using a low-rank representation. + + :param model: A PyTorch model instance that is twice differentiable, wrapped into :class:`TorchTwiceDifferential`. + The Hessian will be calculated with respect to this model's parameters. + :param training_data: A DataLoader instance that provides the model's training data. + Used in calculating the Hessian-vector products. + :param b: The right-hand side vector in the system Hx = b. + :param hessian_perturbation: Optional regularization parameter added to the Hessian-vector product + for numerical stability. + :param rank_estimate: The number of eigenvalues and corresponding eigenvectors to compute. + Represents the desired rank of the Hessian approximation. + :param krylov_dimension: The number of Krylov vectors to use for the Lanczos method. + If not provided, it defaults to $min(model.num_parameters, max(2*rank_estimate + 1, 20))$. + :param low_rank_representation: A LowRankProductRepresentation instance containing a previously computed + low-rank representation of the Hessian. + If not provided, a new low-rank representation will be computed, + using provided parameters. + :param tol: The stopping criteria for the Lanczos algorithm. + If `low_rank_representation` is provided, this parameter is ignored. + :param max_iter: The maximum number of iterations for the Lanczos method. + If `low_rank_representation` is provided, this parameter is ignored. + :param eigen_computation_on_gpu: If True, tries to execute the eigen pair approximation on the model's + device via cupy implementation. + Make sure, that either your model is small enough or you use a + small rank_estimate to fit your device's memory. + If False, the eigen pair approximation is executed on the CPU by scipy wrapper to + ARPACK. + :return: Returns the solution vector x that satisfies the system Hx = b, + where H is a low-rank approximation of the Hessian of the model's loss function. + """ + + if low_rank_representation is None: + + raw_hvp = get_hvp_function( + model.model, model.loss, training_data, use_hessian_avg=True + ) + params = dict(model.model.named_parameters()) + + def hessian_vector_product(x: torch.Tensor) -> torch.Tensor: + output = raw_hvp(align_structure(params, x)) + return flatten_tensors_to_vector(output.values()) + + low_rank_representation = lanzcos_low_rank_hessian_approx( + hessian_vp=hessian_vector_product, + matrix_shape=(model.num_params, model.num_params), + hessian_perturbation=hessian_perturbation, + rank_estimate=rank_estimate, + krylov_dimension=krylov_dimension, + tol=tol, + max_iter=max_iter, + device=model.device if hasattr(model, "device") else None, + eigen_computation_on_gpu=eigen_computation_on_gpu, + ) + else: + logger.info("Using provided low rank representation, ignoring other parameters") + + result = low_rank_representation.projections @ ( + torch.diag_embed(1.0 / low_rank_representation.eigen_vals) + @ (low_rank_representation.projections.t() @ b.t()) + ) + return InverseHvpResult( + x=result.t(), + info={ + "eigenvalues": low_rank_representation.eigen_vals, + "eigenvectors": low_rank_representation.projections, + }, + ) diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py index f447d42b3..cc67051bd 100644 --- a/src/pydvl/influence/frameworks/twice_differentiable.py +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -3,7 +3,6 @@ from typing import Any, Dict, Generic, List, Sequence, Type, TypeVar TensorType = TypeVar("TensorType", bound=Sequence) -ModelType = TypeVar("ModelType") @dataclass(frozen=True) @@ -21,6 +20,11 @@ class TwiceDifferentiable(ABC, Generic[TensorType]): second derivative of the loss wrt. the model parameters """ + @classmethod + @abstractmethod + def tensor_type(cls): + pass + @property @abstractmethod def num_params(self) -> int: @@ -147,11 +151,12 @@ def unsqueeze(x: TensorType, dim: int) -> TensorType: def eye(dim: int, **kwargs) -> TensorType: """Identity tensor of dimension dim""" - @staticmethod + @classmethod def from_twice_differentiable( + cls, twice_diff: TwiceDifferentiable, ) -> Type["TensorUtilities"]: - tu = TensorUtilities.registry.get(type(twice_diff), None) + tu = cls.registry.get(type(twice_diff), None) if tu is None: raise KeyError() diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 9eb40a530..fecc330f7 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -4,7 +4,7 @@ """ from copy import deepcopy from enum import Enum -from typing import Any, Optional +from typing import Any, Callable, Dict, Optional, Type from ..utils import maybe_progress from .frameworks.twice_differentiable import ( @@ -59,7 +59,9 @@ def compute_influence_factors( :returns: An array of size (N, D) containing the influence factors for each dimension (D) and test sample (N). """ - tensor_util = TensorUtilities.from_twice_differentiable(model) + tensor_util: Type[TensorUtilities] = TensorUtilities.from_twice_differentiable( + model + ) stack = tensor_util.stack unsqueeze = tensor_util.unsqueeze cat = tensor_util.cat @@ -81,7 +83,6 @@ def compute_influence_factors( training_data, cat(test_grads), hessian_perturbation=hessian_perturbation, - progress=progress, **kwargs, ) @@ -111,7 +112,9 @@ def compute_influences_up( number of input points. """ - tensor_util = TensorUtilities.from_twice_differentiable(model) + tensor_util: Type[TensorUtilities] = TensorUtilities.from_twice_differentiable( + model + ) stack = tensor_util.stack unsqueeze = tensor_util.unsqueeze cat = tensor_util.cat @@ -126,7 +129,7 @@ def compute_influences_up( ) train_grads.append(train_grad) - return einsum("ta,va->tv", influence_factors, cat(train_grads)) + return einsum("ta,va->tv", influence_factors, cat(train_grads)) # type: ignore # ToDO fix typing def compute_influences_pert( @@ -154,7 +157,9 @@ def compute_influences_pert( the number of input data, and P the number of features. """ - tensor_util = TensorUtilities.from_twice_differentiable(model) + tensor_util: Type[TensorUtilities] = TensorUtilities.from_twice_differentiable( + model + ) stack = tensor_util.stack all_pert_influences = [] @@ -176,10 +181,10 @@ def compute_influences_pert( perturbation_influences.reshape((-1, *x[i].shape)) ) - return stack(all_pert_influences, axis=1) + return stack(all_pert_influences, axis=1) # type: ignore # ToDO fix typing -influence_type_registry = { +influence_type_registry: Dict[InfluenceType, Callable[..., TensorType]] = { InfluenceType.Up: compute_influences_up, InfluenceType.Perturbation: compute_influences_pert, } @@ -196,7 +201,7 @@ def compute_influences( hessian_regularization: float = 0.0, progress: bool = False, **kwargs: Any, -) -> TensorType: +) -> TensorType: # type: ignore # ToDO fix typing r""" Calculates the influence of the input_data point j on the test points i. First it calculates the influence factors of all test points with respect @@ -237,9 +242,8 @@ def compute_influences( progress=progress, **kwargs, ) - compute_influence_type = influence_type_registry[influence_type] - return compute_influence_type( + return influence_type_registry[influence_type]( differentiable_model, input_data, influence_factors, diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index b8badb01c..802b275dc 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -1,15 +1,14 @@ +"""Contains methods to invert the hessian vector product. """ -Contains methods to invert the hessian vector product. -""" +import functools +import inspect import logging +import warnings from enum import Enum -from typing import Any, Iterable, TypeVar - -from .frameworks import solve_batch_cg, solve_linear, solve_lissa +from typing import Any, Callable, Dict, Iterable, Tuple, Type, TypeVar -__all__ = ["solve_hvp"] +__all__ = ["solve_hvp", "InversionMethod", "InversionRegistry"] -from .frameworks.torch_differentiable import solve_arnoldi from .frameworks.twice_differentiable import ( InverseHvpResult, TensorType, @@ -39,7 +38,6 @@ def solve_hvp( b: TensorType, *, hessian_perturbation: float = 0.0, - progress: bool = False, **kwargs: Any, ) -> InverseHvpResult: """ @@ -52,50 +50,135 @@ def solve_hvp( :param inversion_method: :param model: A model wrapped in the TwiceDifferentiable interface. - :param x: An array containing the features of the input data points. - :param y: labels for x + :param training_data: :param b: Array as the right hand side of the equation $Ax = b$ - :param kwargs: kwargs to pass to the inversion method :param hessian_perturbation: regularization of the hessian - :param progress: If True, display progress bars. + :param kwargs: kwargs to pass to the inversion method - :return: An object that containes an array that solves the inverse problem, + :return: An object that contains an array that solves the inverse problem, i.e. it returns $x$ such that $Ax = b$, and a dictionary containing information about the inversion process. """ - if inversion_method == InversionMethod.Direct: - return solve_linear( - model, # type: ignore - training_data, - b, - **kwargs, - hessian_perturbation=hessian_perturbation, - ) - elif inversion_method == InversionMethod.Cg: - return solve_batch_cg( - model, # type: ignore - training_data, - b, - **kwargs, - hessian_perturbation=hessian_perturbation, - progress=progress, - ) - elif inversion_method == InversionMethod.Lissa: - return solve_lissa( - model, # type: ignore - training_data, - b, - **kwargs, - hessian_perturbation=hessian_perturbation, - progress=progress, - ) - elif inversion_method == InversionMethod.Arnoldi: - return solve_arnoldi( - model, # type: ignore # TODO the interface TwiceDifferentiable is not used properly anyhow - training_data, - b, - **kwargs, - hessian_perturbation=hessian_perturbation, + return InversionRegistry.call_registered( + inversion_method, + model, + training_data, + b, + hessian_perturbation=hessian_perturbation, + **kwargs, + ) + + +class InversionRegistry: + """ + A registry to hold inversion methods for different models. + """ + + registry: Dict[Tuple[Type[TwiceDifferentiable], InversionMethod], Callable] = {} + + @classmethod + def register( + cls, + model_type: Type[TwiceDifferentiable], + inversion_method: InversionMethod, + overwrite: bool = False, + ): + """ + Register a function for a specific model type and inversion method. + + The function to be registered must conform to the following signature: + `(model: TwiceDifferentiable, training_data: DataLoaderType, b: TensorType, hessian_perturbation: float = 0.0, ...)`. + + :param model_type: The type of the model the function should be registered for. + :param inversion_method: The inversion method the function should be registered for. + :param overwrite: If True, allows overwriting of an existing registered function for the same model type and inversion method. + If False, logs a warning when attempting to register a function for an already registered model type and inversion method. + + + :raises TypeError: If the provided model_type or inversion_method are of the wrong type. + :raises ValueError: If the function to be registered does not match the required signature. + :return: A decorator for registering a function. + """ + + if not isinstance(model_type, type): + raise TypeError(f"'model_type' must be a Type[TwiceDifferentiable]") + + if not isinstance(inversion_method, InversionMethod): + raise TypeError(f"'inversion_method' must be an InversionMethod") + + key = (model_type, inversion_method) + + def decorator(func): + if not overwrite and key in cls.registry: + warnings.warn( + f"There is already a function registered for model type {model_type} and inversion method {inversion_method}. " + f"To overwrite the existing function {cls.registry.get(key)} with {func}, set overwrite to True." + ) + sig = inspect.signature(func) + params = list(sig.parameters.values()) + + expected_args = [ + ("model", model_type), + ("training_data", DataLoaderType.__bound__), + ("b", model_type.tensor_type()), + ("hessian_perturbation", float), + ] + + for (name, typ), param in zip(expected_args, params): + if not ( + isinstance(param.annotation, typ) + or issubclass(param.annotation, typ) + ): + raise ValueError( + f'Parameter "{name}" must be of type "{typ.__name__}"' + ) + + @functools.wraps(func) + def wrapper(*args, **kwargs): + return func(*args, **kwargs) + + cls.registry[key] = wrapper + return wrapper + + return decorator + + @classmethod + def get_registered( + cls, model_type: Type[TwiceDifferentiable], inversion_method: InversionMethod + ) -> Callable[ + [TwiceDifferentiable, DataLoaderType, TensorType, float], InverseHvpResult + ]: + key = (model_type, inversion_method) + method = cls.registry.get(key, None) + if method is None: + raise ValueError(f"No function registered for {key}") + return method + + @classmethod + def call_registered( + cls, + inversion_method: InversionMethod, + model: TwiceDifferentiable, + training_data: DataLoaderType, + b: TensorType, + hessian_perturbation, + **kwargs, + ) -> InverseHvpResult: + """ + Call a registered function with the provided parameters. + + :param inversion_method: The inversion method to use. + :param model: A model wrapped in the TwiceDifferentiable interface. + :param training_data: The training data to use. + :param b: Array as the right hand side of the equation $Ax = b$. + :param hessian_perturbation: Regularization of the hessian. + :param kwargs: Additional keyword arguments to pass to the inversion method. + + :return: An object that contains an array that solves the inverse problem, + i.e. it returns $x$ such that $Ax = b$, and a dictionary containing + information about the inversion process. + """ + + return cls.get_registered(type(model), inversion_method)( + model, training_data, b, hessian_perturbation, **kwargs ) - else: - raise ValueError(f"Unknown inversion method: {inversion_method}") diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 2383304d3..a45d685b5 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -12,8 +12,8 @@ from torch.optim import LBFGS from torch.utils.data import DataLoader, TensorDataset -from pydvl.influence import TorchTwiceDifferentiable, compute_influences -from pydvl.influence.general import InfluenceType, InversionMethod +from pydvl.influence import InfluenceType, InversionMethod, compute_influences +from pydvl.influence.frameworks import TorchTwiceDifferentiable from .conftest import ( add_noise_to_linear_model, diff --git a/tests/influence/test_torch_differentiable.py b/tests/influence/test_torch_differentiable.py index 490013bbe..7ddf70f44 100644 --- a/tests/influence/test_torch_differentiable.py +++ b/tests/influence/test_torch_differentiable.py @@ -23,7 +23,7 @@ from torch import nn from torch.utils.data import DataLoader -from pydvl.influence.frameworks.torch_differentiable import ( +from pydvl.influence.frameworks import ( TorchTwiceDifferentiable, solve_batch_cg, solve_linear, From ea086a563b804e3d2ca48b8d06ef51d771a11c20 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 10 Aug 2023 16:45:21 +0200 Subject: [PATCH 228/436] Get influence subpackage from develop branch --- src/pydvl/influence/__init__.py | 11 +- src/pydvl/influence/conjugate_gradient.py | 236 ------ src/pydvl/influence/frameworks/__init__.py | 60 +- src/pydvl/influence/frameworks/functional.py | 206 +++++ .../frameworks/torch_differentiable.py | 767 ++++++++++++++---- .../frameworks/twice_differentiable.py | 90 ++ src/pydvl/influence/frameworks/util.py | 144 ++++ src/pydvl/influence/general.py | 388 ++++----- src/pydvl/influence/inversion.py | 103 +++ src/pydvl/influence/linear.py | 161 ---- .../influence/model_wrappers/__init__.py | 7 - .../model_wrappers/torch_wrappers.py | 296 ------- src/pydvl/influence/types.py | 48 -- 13 files changed, 1431 insertions(+), 1086 deletions(-) delete mode 100644 src/pydvl/influence/conjugate_gradient.py create mode 100644 src/pydvl/influence/frameworks/functional.py create mode 100644 src/pydvl/influence/frameworks/twice_differentiable.py create mode 100644 src/pydvl/influence/frameworks/util.py create mode 100644 src/pydvl/influence/inversion.py delete mode 100644 src/pydvl/influence/linear.py delete mode 100644 src/pydvl/influence/model_wrappers/__init__.py delete mode 100644 src/pydvl/influence/model_wrappers/torch_wrappers.py delete mode 100644 src/pydvl/influence/types.py diff --git a/src/pydvl/influence/__init__.py b/src/pydvl/influence/__init__.py index a31a74086..570c4056a 100644 --- a/src/pydvl/influence/__init__.py +++ b/src/pydvl/influence/__init__.py @@ -1,10 +1,11 @@ """ This package contains algorithms for the computation of the influence function. -!!! Warning - Much of the code in this package is experimental or untested and is subject - to modification. In particular, the package structure and basic API will - probably change. +.. warning:: + Much of the code in this package is experimental or untested and is subject + to modification. In particular, the package structure and basic API will + probably change. """ -from .general import * +from .frameworks import TorchTwiceDifferentiable, TwiceDifferentiable +from .general import compute_influence_factors, compute_influences diff --git a/src/pydvl/influence/conjugate_gradient.py b/src/pydvl/influence/conjugate_gradient.py deleted file mode 100644 index 7c3bf6a63..000000000 --- a/src/pydvl/influence/conjugate_gradient.py +++ /dev/null @@ -1,236 +0,0 @@ -""" -- batched conjugate gradient. -- error bound for conjugate gradient. -""" -import logging -import warnings -from typing import TYPE_CHECKING, Callable, Optional, Tuple, Union - -import numpy as np -from scipy.sparse.linalg import cg - -from ..utils import maybe_progress -from .types import MatrixVectorProduct - -if TYPE_CHECKING: - from numpy.typing import NDArray - -__all__ = ["conjugate_gradient", "batched_preconditioned_conjugate_gradient"] - -logger = logging.getLogger(__name__) - - -def conjugate_gradient( - A: "NDArray[np.float_]", batch_y: "NDArray[np.float_]", progress: bool = False -) -> "NDArray[np.float_]": - """ - Given a matrix and a batch of vectors, it uses conjugate gradient to calculate the solution - to Ax = y for each y in batch_y. - - Args: - A: a real, symmetric and positive-definite matrix of shape [NxN] - batch_y: a matrix of shape [NxP], with P the size of the batch. - progress: True, iff progress shall be printed. - - Returns: - A NDArray of shape [NxP] representing x, the solution of Ax=b. - """ - batch_cg = [] - for y in maybe_progress(batch_y, progress, desc="Conjugate gradient"): - y_cg, _ = cg(A, y) - batch_cg.append(y_cg) - return np.asarray(batch_cg) - - -def batched_preconditioned_conjugate_gradient( - A: Union["NDArray", Callable[["NDArray"], "NDArray"]], - b: "NDArray", - x0: Optional["NDArray"] = None, - rtol: float = 1e-3, - max_iterations: int = 100, - max_step_size: Optional[float] = None, -) -> Tuple["NDArray", int]: - """ - Implementation of a batched conjugate gradient algorithm. It uses vector matrix products for efficient calculation. - On top of that, it constrains the maximum step size. - - See [1]_ for more details on the algorithm. - - See also [2]_ and [3]_. - - !!! Warning - This function is experimental and unstable. Prefer using inversion_method='cg' - - Args: - A: A linear function f : R[k] -> R[k] representing a matrix vector product - from dimension K to K or a matrix. It has to be positive-definite v.T @ f(v) >= 0. - b: An array of shape [K] representing the result of the matrix - multiplication Ax. - x0: - rtol: Relative tolerance of the residual with respect to the 2-norm of b. - max_iterations: Maximum number of iterations to use in conjugate gradient. Default is 10 times K. - max_step_size: Maximum step size along a gradient direction. Might be necessary for numerical stability. \ - See also max_iterations. Default is 10.0. - - Returns: - An of shape [K] representing the solution of Ax=b. - - !!! References: - .. [1] [Conjugate Gradient Method - Wikipedia](https://en.wikipedia.org/wiki/Conjugate_gradient_method). - .. [2] [SciPy's implementation of Conjugate Gradient](https://github.com/scipy/scipy/blob/v1.8.1/scipy/sparse/linalg/_isolve/iterative.py#L282-L351). - .. [3] [Prof. Mert Pilanci., "Conjugate Gradient Method", Stanford University, 2022](https://web.stanford.edu/class/ee364b/lectures/conj_grad_slides.pdf). - """ - warnings.warn( - "This function is experimental and unstable. Prefer using inversion_method='cg'", - UserWarning, - ) - # wrap A into a function. - if not callable(A): - new_A = np.copy(A) - A = lambda v: v @ new_A.T # type: ignore - M = hvp_to_inv_diag_conditioner(A, d=b.shape[1]) - - k = A(b).shape[0] - if A(b).size == 0: - return b, 0 - - if b.ndim == 1: - b = b.reshape([1, -1]) - - if max_iterations is None: - max_iterations = 10 * k - - # start with residual - if x0 is not None: - x = np.copy(x0) - elif M is not None: - x = M(b) - else: - x = np.copy(b) - - r = b - A(x) - u = np.copy(r) - - if M is not None: - u = M(u) - - p = np.copy(b) - - if x.ndim == 1: - x = x.reshape([1, -1]) - - iteration = 0 - batch_dim = b.shape[0] - converged = np.zeros(batch_dim, dtype=bool) - atol = np.linalg.norm(b, axis=1) * rtol - - while iteration < max_iterations: - # remaining fields - iteration += 1 - not_yet_converged_indices = np.argwhere(np.logical_not(converged))[:, 0] - mvp = A(p)[not_yet_converged_indices] - p_dot_mvp = np.einsum("ia,ia->i", p[not_yet_converged_indices], mvp) - r_dot_u = np.einsum( - "ia,ia->i", r[not_yet_converged_indices], u[not_yet_converged_indices] - ) - alpha = r_dot_u / p_dot_mvp - if max_step_size is not None: - alpha = np.minimum(max_step_size, alpha) - - # update x and r - reshaped_alpha = alpha.reshape([-1, 1]) - x[not_yet_converged_indices] += reshaped_alpha * p[not_yet_converged_indices] - r[not_yet_converged_indices] -= reshaped_alpha * mvp - - # calculate next conjugate gradient - new_u = r - if M is not None: - new_u = M(new_u) - - new_u = new_u[not_yet_converged_indices] - new_r_dot_u = np.einsum("ia,ia->i", r[not_yet_converged_indices], new_u) - - if rtol is not None: - residual = np.linalg.norm( - A(x)[not_yet_converged_indices] - b[not_yet_converged_indices], - axis=1, - ) - converged[not_yet_converged_indices] = ( - residual <= atol[not_yet_converged_indices] - ) - - if np.all(converged): - break - - beta = new_r_dot_u / r_dot_u - p[not_yet_converged_indices] = ( - beta.reshape([-1, 1]) * p[not_yet_converged_indices] + new_u - ) - u[not_yet_converged_indices] = new_u - - if not np.all(converged): - percentage_converged = int(converged.sum() / len(converged)) * 100 - msg = ( - f"Converged vectors are only {percentage_converged}%. " - "Please increase max_iterations, decrease max_step_size " - "and make sure that A is positive definite" - " (e.g. through regularization)." - ) - warnings.warn(msg, RuntimeWarning) - return x, iteration - - -def conjugate_gradient_condition_number_based_error_bound( - A: "NDArray", n: int, x0: "NDArray", xt: "NDArray" -) -> float: - """ - Error bound for conjugate gradient based on the condition number of the weight matrix A. Used for testing purposes. - See also https://math.stackexchange.com/questions/382958/error-for-conjugate-gradient-method. Explicit of the weight - matrix is required. - Args: - A: Weight matrix of the matrix to be inverted. - n: Maximum number for executed iterations X in conjugate gradient. - x0: Initialization solution x0 of conjugate gradient. - xt: Final solution xt of conjugate gradient after X iterations. - Returns: - Upper bound for ||x0 - xt||_A. - """ - eigvals = np.linalg.eigvals(A) - eigvals = np.sort(eigvals) - eig_val_max = np.max(eigvals) - eig_val_min = np.min(eigvals) - kappa = np.abs(eig_val_max / eig_val_min) - norm_A = lambda v: np.sqrt(np.einsum("ia,ab,ib->i", v, A, v)) - error_init: float = norm_A(xt - x0) - - sqrt_kappa = np.sqrt(kappa) - div = (sqrt_kappa + 1) / (sqrt_kappa - 1) - div_n = div**n - return (2 * error_init) / (div_n + 1 / div_n) # type: ignore - - -def hvp_to_inv_diag_conditioner( - hvp: MatrixVectorProduct, d: int -) -> MatrixVectorProduct: - """ - This method uses the hvp function to construct a simple pre-conditioner 1/diag(H). It does so while requiring - only O(d) space in RAM for construction and later execution. - - Args: - hvp: The callable calculating the Hessian vector product Hv. - d: The number of dimensions of the hvp callable. - - Returns: - A MatrixVectorProduct for the conditioner. - """ - diags = np.empty(d) - - for i in range(d): - inp = np.zeros(d) - inp[i] = 1 - diags[i] = hvp(np.reshape(inp, [1, -1]))[0, i] - - def _inv_diag_conditioner(v: "NDArray"): - return v / diags - - return _inv_diag_conditioner diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/frameworks/__init__.py index b3059de2b..298dd4f41 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/frameworks/__init__.py @@ -1,5 +1,57 @@ -from .torch_differentiable import * +# FIXME the following code was part of an attempt to accommodate different +# frameworks. In its current form it is ugly and thus it will likely be changed +# in the future. -__all__ = [ - "TorchTwiceDifferentiable", -] +import logging + +from .twice_differentiable import InverseHvpResult, TwiceDifferentiable + +__all__ = ["TwiceDifferentiable"] +logger = logging.getLogger("frameworks") + +try: + import torch + + from .torch_differentiable import TorchTwiceDifferentiable + + __all__.append("TorchTwiceDifferentiable") + + from .torch_differentiable import ( + as_tensor, + cat, + einsum, + mvp, + solve_batch_cg, + solve_linear, + solve_lissa, + stack, + transpose_tensor, + zero_tensor, + ) + + TensorType = torch.Tensor + DataLoaderType = torch.utils.data.DataLoader + ModelType = torch.nn.Module + + __all__.extend( + [ + "TensorType", + "ModelType", + "InverseHvpResult", + "solve_linear", + "solve_batch_cg", + "solve_lissa", + "as_tensor", + "stack", + "cat", + "zero_tensor", + "transpose_tensor", + "einsum", + "mvp", + ] + ) + +except ImportError: + logger.info( + "No compatible framework found. Influence function computation disabled." + ) diff --git a/src/pydvl/influence/frameworks/functional.py b/src/pydvl/influence/frameworks/functional.py new file mode 100644 index 000000000..4951ac224 --- /dev/null +++ b/src/pydvl/influence/frameworks/functional.py @@ -0,0 +1,206 @@ +from functools import partial +from typing import Callable, Dict, Generator, Iterable + +import torch +from torch.func import functional_call, grad, jvp, vjp +from torch.utils.data import DataLoader + +from .util import TorchTensorContainerType, align_structure, to_model_device + +__all__ = [ + "get_hvp_function", +] + + +def hvp( + func: Callable[[TorchTensorContainerType], TorchTensorContainerType], + params: TorchTensorContainerType, + vec: TorchTensorContainerType, + reverse_only: bool = True, +) -> TorchTensorContainerType: + """ + Computes the Hessian-vector product (HVP) for a given function at given parameters. + This function can operate in two modes, either reverse-mode autodiff only or both + forward- and reverse-mode autodiff. + + + :param func: The function for which the HVP is computed. + :param params: The parameters at which the HVP is computed. + :param vec: The vector with which the Hessian is multiplied. + :param reverse_only: Whether to use only reverse-mode autodiff + (True, default) or both forward- and reverse-mode autodiff (False). + + :return: Input_type: The HVP of the function at the given parameters with the given vector. + + :Example: + + >>> def f(z): return torch.sum(z**2) + >>> u = torch.ones(10, requires_grad=True) + >>> v = torch.ones(10) + >>> hvp_vec = hvp(f, u, v) + >>> assert torch.allclose(hvp_vec, torch.full((10, ), 2.0)) + """ + output: TorchTensorContainerType + + if reverse_only: + _, vjp_fn = vjp(grad(func), params) + output = vjp_fn(vec)[0] + else: + output = jvp(grad(func), (params,), (vec,))[1] + + return output + + +def batch_hvp_gen( + model: torch.nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + data_loader: DataLoader, + reverse_only: bool = True, +) -> Generator[ + Callable[[Dict[str, torch.Tensor]], Dict[str, torch.Tensor]], None, None +]: + """ + Generates a sequence of batch Hessian-vector product (HVP) computations for the provided model, loss function, + and data loader. + + The generator iterates over the data_loader, creating partial function calls for calculating HVPs. + + :param model: The PyTorch model for which the HVP is calculated. + :param loss: The loss function used to calculate the gradient and HVP. + :param data_loader: PyTorch DataLoader object containing the dataset for which the HVP is calculated. + :param reverse_only: + :yield: A partial function H(vec)=hvp(model, loss, inputs, targets, vec) that when called, + will compute the Hessian-vector product H(vec) for the given model, loss, inputs and targets. + """ + + for inputs, targets in iter(data_loader): + batch_loss = batch_loss_function(model, loss, inputs, targets) + yield partial(hvp, batch_loss, dict(model.named_parameters()), reverse_only=reverse_only) # type: ignore + + +def empirical_loss_function( + model: torch.nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + data_loader: DataLoader, +) -> Callable[[Dict[str, torch.Tensor]], Dict[str, torch.Tensor]]: + """ + Creates a function to compute the empirical loss of a given model on a given dataset. + If we denote the model parameters with $\theta$, the resulting function approximates + + .. math:: + + f(\theta) = \frac{1}{N}\sum_{i=1}^N \operatorname{loss}(y_i, \operatorname{model}(\theta, x_i))) + + :param model: The model for which the loss should be computed. + :param loss: The loss function to be used. + :param data_loader: The data loader for iterating over the dataset. + + :return: A function that computes the empirical loss + of the model on the dataset for given model parameters. + + """ + + def empirical_loss(params: Dict[str, torch.Tensor]): + total_loss = to_model_device(torch.zeros((), requires_grad=True), model) + total_samples = to_model_device(torch.zeros(()), model) + + for x, y in iter(data_loader): + output = functional_call( + model, params, (to_model_device(x, model),), strict=True + ) + loss_value = loss(output, to_model_device(y, model)) + total_loss = total_loss + loss_value * x.size(0) + total_samples += x.size(0) + + return total_loss / total_samples + + return empirical_loss + + +def batch_loss_function( + model: torch.nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + x: torch.Tensor, + y: torch.Tensor, +) -> Callable[[Dict[str, torch.Tensor]], torch.Tensor]: + """ + Creates a function to compute the loss of a given model on a given batch of data. + + :param model: The model for which the loss should be computed. + :param loss: The loss function to be used. + :param x: The input data for the batch. + :param y: The true labels for the batch. + + :return: A function that computes the loss + of the model on the batch for given model parameters. + """ + + def batch_loss(params: Dict[str, torch.Tensor]): + outputs = functional_call( + model, params, (to_model_device(x, model),), strict=True + ) + return loss(outputs, y) + + return batch_loss + + +def get_hvp_function( + model: torch.nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + data_loader: DataLoader, + use_hessian_avg: bool = True, + reverse_only: bool = True, + track_gradients: bool = False, +) -> Callable[[Dict[str, torch.Tensor]], Dict[str, torch.Tensor]]: + """ + Returns a function that calculates the approximate Hessian-vector product for a given vector. If you want to + compute the exact hessian, i.e. pulling all data into memory and compute a full gradient computation, use + the function :func:`hvp`. + + :param model: A PyTorch module representing the model whose loss function's Hessian is to be computed. + :param loss: A callable that takes the model's output and target as input and returns the scalar loss. + :param data_loader: A DataLoader instance that provides batches of data for calculating the Hessian-vector product. + Each batch from the DataLoader is assumed to return a tuple where the first element + is the model's input and the second element is the target output. + :param use_hessian_avg: If True, it will use batch-wise Hessian computation. If False, the function averages + the batch gradients and perform backpropagation on the full (averaged) gradient, + which is more accurate than averaging the batch hessians, + but probably has a way higher memory usage. + :param reverse_only: Whether to use only reverse-mode autodiff + (True, default) or both forward- and reverse-mode autodiff (False) + :param track_gradients: Whether to track gradients for the resulting tensor of the hessian vector products are + (False, default). + + :return: A function that takes a single argument, a vector, and returns the product of the Hessian of the + `loss` function with respect to the `model`'s parameters and the input vector. + + """ + + params = { + k: p if track_gradients else p.detach() for k, p in model.named_parameters() + } + + def hvp_function(vec: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]: + v = align_structure(params, vec) + empirical_loss = empirical_loss_function(model, loss, data_loader) + return hvp(empirical_loss, params, v, reverse_only=reverse_only) + + def avg_hvp_function(vec: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]: + v = align_structure(params, vec) + batch_hessians: Iterable[Dict[str, torch.Tensor]] = map( + lambda x: x(v), batch_hvp_gen(model, loss, data_loader, reverse_only) + ) + + result_dict = { + key: to_model_device(torch.zeros_like(p), model) + for key, p in params.items() + } + num_batches = len(data_loader) + + for batch_dict in batch_hessians: + for key, value in batch_dict.items(): + result_dict[key] += value + + return {key: value / num_batches for key, value in result_dict.items()} + + return avg_hvp_function if use_hessian_avg else hvp_function diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 05652fe2f..0113d7203 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -1,185 +1,674 @@ """ -Contains all parts of pyTorch based machine learning model. +Contains methods for differentiating a pyTorch model. Most of the methods focus +on ways to calculate matrix vector products. Moreover, it contains several +methods to invert the Hessian vector product. These are used to calculate the +influence of a training point on the model. """ -from typing import TYPE_CHECKING, Callable, Optional, Tuple, Union +import logging +from dataclasses import dataclass +from functools import partial +from typing import Any, Callable, List, Optional, Sequence, Tuple, Union import numpy as np +import torch +import torch.nn as nn +from numpy.typing import NDArray +from scipy.sparse.linalg import ArpackNoConvergence +from torch import autograd +from torch.autograd import Variable +from torch.utils.data import DataLoader from ...utils import maybe_progress -from ..types import TwiceDifferentiable - -try: - import torch - import torch.nn as nn - from torch import autograd - from torch.autograd import Variable - - _TORCH_INSTALLED = True -except ImportError: - _TORCH_INSTALLED = False - -if TYPE_CHECKING: - from numpy.typing import NDArray +from .functional import get_hvp_function +from .twice_differentiable import InverseHvpResult, TwiceDifferentiable +from .util import align_structure, flatten_tensors_to_vector __all__ = [ "TorchTwiceDifferentiable", + "solve_linear", + "solve_batch_cg", + "solve_lissa", + "as_tensor", + "stack", + "cat", + "zero_tensor", + "transpose_tensor", + "einsum", + "mvp", + "lanzcos_low_rank_hessian_approx", ] +logger = logging.getLogger(__name__) + -def flatten_gradient(grad): +def flatten_all(grad: torch.Tensor) -> torch.Tensor: """ Simple function to flatten a pyTorch gradient for use in subsequent calculation """ return torch.cat([el.reshape(-1) for el in grad]) -class TorchTwiceDifferentiable(TwiceDifferentiable): +def solve_linear( + model: TwiceDifferentiable, + training_data: DataLoader, + b: torch.Tensor, + *, + hessian_perturbation: float = 0.0, + progress: bool = False, +) -> InverseHvpResult: + """Given a model and training data, it finds x s.t. $Hx = b$, with $H$ being + the model hessian. + + :param model: A model wrapped in the TwiceDifferentiable interface. + :param training_data: A DataLoader containing the training data. + :param b: a vector or matrix, the right hand side of the equation $Hx = b$. + :param hessian_perturbation: regularization of the hessian + :param progress: If True, display progress bars. + + :return: An array that solves the inverse problem, + i.e. it returns $x$ such that $Hx = b$, and a dictionary containing + information about the solution. + """ + + all_x, all_y = [], [] + for x, y in training_data: + all_x.append(x) + all_y.append(y) + all_x = cat(all_x) + all_y = cat(all_y) + hessian = model.hessian(all_x, all_y, progress=progress) + matrix = hessian + hessian_perturbation * identity_tensor( + model.num_params, device=model.device + ) + info = {"hessian": hessian} + return InverseHvpResult(x=torch.linalg.solve(matrix, b.T).T, info=info) + + +def solve_batch_cg( + model: TwiceDifferentiable, + training_data: DataLoader, + b: torch.Tensor, + *, + hessian_perturbation: float = 0.0, + x0: Optional[torch.Tensor] = None, + rtol: float = 1e-7, + atol: float = 1e-7, + maxiter: Optional[int] = None, + progress: bool = False, +) -> InverseHvpResult: + """ + Given a model and training data, it uses conjugate gradient to calculate the + inverse of the Hessian Vector Product. More precisely, it finds x s.t. $Hx = + b$, with $H$ being the model hessian. For more info, see + `Wikipedia `_ + + :param model: A model wrapped in the TwiceDifferentiable interface. + :param training_data: A DataLoader containing the training data. + :param b: a vector or matrix, the right hand side of the equation $Hx = b$. + :param hessian_perturbation: regularization of the hessian + :param x0: initial guess for hvp. If None, defaults to b + :param rtol: maximum relative tolerance of result + :param atol: absolute tolerance of result + :param maxiter: maximum number of iterations. If None, defaults to 10*len(b) + :param progress: If True, display progress bars. + + :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$, + and a dictionary containing information about the convergence of CG, one + entry for each line of the matrix. + """ + total_grad_xy = 0 + total_points = 0 + for x, y in maybe_progress(training_data, progress, desc="Batch Train Gradients"): + grad_xy, _ = model.grad(x, y) + total_grad_xy += grad_xy * len(x) + total_points += len(x) + backprop_on = model.parameters + reg_hvp = lambda v: mvp( + total_grad_xy / total_points, v, backprop_on + ) + hessian_perturbation * v.type(torch.float64) + batch_cg = torch.zeros_like(b) + info = {} + for idx, bi in enumerate(maybe_progress(b, progress, desc="Conjugate gradient")): + batch_result, batch_info = solve_cg( + reg_hvp, bi, x0=x0, rtol=rtol, atol=atol, maxiter=maxiter + ) + batch_cg[idx] = batch_result + info[f"batch_{idx}"] = batch_info + return InverseHvpResult(x=batch_cg, info=info) + + +def solve_cg( + hvp: Callable[[torch.Tensor], torch.Tensor], + b: torch.Tensor, + *, + x0: Optional[torch.Tensor] = None, + rtol: float = 1e-7, + atol: float = 1e-7, + maxiter: Optional[int] = None, +) -> InverseHvpResult: + """Conjugate gradient solver for the Hessian vector product + + :param hvp: a Callable Hvp, operating with tensors of size N + :param b: a vector or matrix, the right hand side of the equation $Hx = b$. + :param x0: initial guess for hvp + :param rtol: maximum relative tolerance of result + :param atol: absolute tolerance of result + :param maxiter: maximum number of iterations. If None, defaults to 10*len(b) + + :return: A vector x, solution of $Ax=b$, and a dictionary containing + information about the convergence of CG. + """ + if x0 is None: + x0 = torch.clone(b) + if maxiter is None: + maxiter = len(b) * 10 + + y_norm = torch.sum(torch.matmul(b, b)).item() + stopping_val = max([rtol**2 * y_norm, atol**2]) + + x = x0 + p = r = (b - hvp(x)).squeeze().type(torch.float64) + gamma = torch.sum(torch.matmul(r, r)).item() + optimal = False + + for k in range(maxiter): + if gamma < stopping_val: + optimal = True + break + Ap = hvp(p).squeeze() + alpha = gamma / torch.sum(torch.matmul(p, Ap)).item() + x += alpha * p + r -= alpha * Ap + gamma_ = torch.sum(torch.matmul(r, r)).item() + beta = gamma_ / gamma + gamma = gamma_ + p = r + beta * p + + info = {"niter": k, "optimal": optimal, "gamma": gamma} + return InverseHvpResult(x=x, info=info) + + +def solve_lissa( + model: TwiceDifferentiable, + training_data: DataLoader, + b: torch.Tensor, + *, + hessian_perturbation: float = 0.0, + maxiter: int = 1000, + dampen: float = 0.0, + scale: float = 10.0, + h0: Optional[torch.Tensor] = None, + rtol: float = 1e-4, + progress: bool = False, +) -> InverseHvpResult: + r""" + Uses LISSA, Linear time Stochastic Second-Order Algorithm, to iteratively + approximate the inverse Hessian. More precisely, it finds x s.t. $Hx = b$, + with $H$ being the model's second derivative wrt. the parameters. + This is done with the update + + $$H^{-1}_{j+1} b = b + (I - d) \ H - \frac{H^{-1}_j b}{s},$$ + + where $I$ is the identity matrix, $d$ is a dampening term and $s$ a scaling + factor that are applied to help convergence. For details, see + :footcite:t:`koh_understanding_2017` and the original paper + :footcite:t:`agarwal_2017_second`. + + :param model: A model wrapped in the TwiceDifferentiable interface. + :param training_data: A DataLoader containing the training data. + :param b: a vector or matrix, the right hand side of the equation $Hx = b$. + :param hessian_perturbation: regularization of the hessian + :param progress: If True, display progress bars. + :param maxiter: maximum number of iterations, + :param dampen: dampening factor, defaults to 0 for no dampening + :param scale: scaling factor, defaults to 10 + :param h0: initial guess for hvp + + :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$, + and a dictionary containing information about the accuracy of the solution. + """ + if h0 is None: + h_estimate = torch.clone(b) + else: + h_estimate = h0 + shuffled_training_data = DataLoader( + training_data.dataset, training_data.batch_size, shuffle=True + ) + + def lissa_step( + h: torch.Tensor, reg_hvp: Callable[[torch.Tensor], torch.Tensor] + ) -> torch.Tensor: + """Given an estimate of the hessian inverse and the regularised hessian + vector product, it computes the next estimate. + + :param h: an estimate of the hessian inverse + :param reg_hvp: regularised hessian vector product + :return: the next estimate of the hessian inverse + """ + return b + (1 - dampen) * h - reg_hvp(h) / scale + + for _ in maybe_progress(range(maxiter), progress, desc="Lissa"): + x, y = next(iter(shuffled_training_data)) + grad_xy, _ = model.grad(x, y) + reg_hvp = lambda v: mvp(grad_xy, v, model.parameters) + hessian_perturbation * v + residual = lissa_step(h_estimate, reg_hvp) - h_estimate + h_estimate += residual + if torch.isnan(h_estimate).any(): + raise RuntimeError("NaNs in h_estimate. Increase scale or dampening.") + max_residual = torch.max(torch.abs(residual / h_estimate)) + if max_residual < rtol: + break + mean_residual = torch.mean(torch.abs(residual / h_estimate)) + logger.info( + f"Terminated Lissa with {max_residual*100:.2f} % max residual." + f" Mean residual: {mean_residual*100:.5f} %" + ) + info = { + "max_perc_residual": max_residual * 100, + "mean_perc_residual": mean_residual * 100, + } + return InverseHvpResult(x=h_estimate / scale, info=info) + + +def as_tensor(a: Any, warn=True, **kwargs) -> torch.Tensor: + """Converts an array into a torch tensor + + :param a: array to convert to tensor + :param warn: if True, warns that a will be converted + """ + if warn and not isinstance(a, torch.Tensor): + logger.warning("Converting tensor to type torch.Tensor.") + return torch.as_tensor(a, **kwargs) + + +def stack(a: Sequence[torch.Tensor], **kwargs) -> torch.Tensor: + """Stacks a sequence of tensors into a single torch tensor""" + return torch.stack(a, **kwargs) + + +def cat(a: Sequence[torch.Tensor], **kwargs) -> torch.Tensor: + """Concatenates a sequence of tensors into a single torch tensor""" + return torch.cat(a, **kwargs) + + +def zero_tensor( + shape: Sequence[int], dtype: Union[np.dtype, torch.dtype], **kwargs +) -> torch.Tensor: + """Returns a tensor of shape :attr:`shape` filled with zeros.""" + if isinstance(dtype, np.dtype): + dtype = getattr(torch, dtype.name) + return torch.zeros(shape, dtype=dtype, **kwargs) + + +def transpose_tensor(a: torch.Tensor, dim0: int, dim1: int) -> torch.Tensor: + return torch.transpose(a, dim0, dim1) + + +def einsum(equation, *operands) -> torch.Tensor: + """Sums the product of the elements of the input :attr:`operands` along dimensions specified using a notation + based on the Einstein summation convention. """ - Calculates second-derivative matrix vector products (Mvp) of a pytorch torch.nn.Module + return torch.einsum(equation, *operands) + + +def identity_tensor(dim: int, **kwargs) -> torch.Tensor: + return torch.eye(dim, dim, **kwargs) + + +def mvp( + grad_xy: torch.Tensor, + v: torch.Tensor, + backprop_on: torch.Tensor, + *, + progress: bool = False, +) -> torch.Tensor: """ + Calculates second order derivative of the model along directions v. + This second order derivative can be selected through the backprop_on argument. + :param grad_xy: an array [P] holding the gradients of the model + parameters wrt input $x$ and labels $y$, where P is the number of + parameters of the model. It is typically obtained through + self.grad. + :param v: An array ([DxP] or even one dimensional [D]) which + multiplies the matrix, where D is the number of directions. + :param progress: True, iff progress shall be printed. + :param backprop_on: tensor used in the second backpropagation (the first + one is along $x$ and $y$ as defined via grad_xy). + :returns: A matrix representing the implicit matrix vector product + of the model along the given directions. Output shape is [DxP] if + backprop_on is None, otherwise [DxM], with M the number of elements + of backprop_on. + """ + device = grad_xy.device + v = as_tensor(v, warn=False).to(device) + if v.ndim == 1: + v = v.unsqueeze(0) + + z = (grad_xy * Variable(v)).sum(dim=1) + + mvp = [] + for i in maybe_progress(range(len(z)), progress, desc="MVP"): + mvp.append(flatten_all(autograd.grad(z[i], backprop_on, retain_graph=True))) + mvp = torch.stack([grad.contiguous().view(-1) for grad in mvp]) + return mvp.detach() # type: ignore + + +class TorchTwiceDifferentiable( + TwiceDifferentiable[torch.Tensor, nn.Module, torch.device] +): def __init__( self, - model: "nn.Module", - loss: Callable[["torch.Tensor", "torch.Tensor"], "torch.Tensor"], + model: nn.Module, + loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + *, + device: torch.device = torch.device( + "cuda" if torch.cuda.is_available() else "cpu" + ), ): + r""" + :param model: A (differentiable) function. + :param loss: :param loss: A differentiable scalar loss $L(\hat{y}, y)$, + mapping a prediction and a target to a real value. + :param device: device to use for computations. Defaults to cuda if available. """ - Args: - model: A torch.nn.Module representing a (differentiable) function f(x). - loss: Loss function L(f(x), y) maps a prediction and a target to a single value. - """ - if not _TORCH_INSTALLED: - raise RuntimeWarning("This function requires PyTorch.") - - self.model = model + if model.training: + logger.warning( + "Passed model not in evaluation mode. This can create several issues in influence " + "computation, e.g. due to batch normalization. Please call model.eval() before " + "computing influences." + ) + self.model = model.to(device) self.loss = loss + self.device = device + @property + def parameters(self) -> List[torch.Tensor]: + """Returns all the model parameters that require differentiating""" + return [ + param for param in self.model.parameters() if param.requires_grad == True + ] + + @property def num_params(self) -> int: - """Returns the number of parameters of the model""" - model_parameters = filter(lambda p: p.requires_grad, self.model.parameters()) - return sum([np.prod(p.size()) for p in model_parameters]) + """ + Get number of parameters of model f. + :returns: Number of parameters as integer. + """ + return sum([np.prod(p.size()) for p in self.parameters]) def split_grad( - self, - x: Union["NDArray", "torch.Tensor"], - y: Union["NDArray", "torch.Tensor"], - progress: bool = False, - ) -> "NDArray": + self, x: torch.Tensor, y: torch.Tensor, *, progress: bool = False + ) -> torch.Tensor: """ - Calculates gradient of model parameters wrt each x[i] and y[i] and then - returns an array of size [N, P] with N number of points (length of x and y) and P + Calculates gradient of model parameters wrt each $x[i]$ and $y[i]$ and then + returns a array of size [N, P] with N number of points (length of x and y) and P number of parameters of the model. - Args: - x: A np.ndarray [NxD] representing the features x_i. - y: A np.ndarray [NxK] representing the predicted target values y_i. - progress: True, iff progress shall be printed. - - Returns: - An array [NxP] representing the gradients with respect to all parameters - of the model. - """ - x = torch.as_tensor(x).unsqueeze(1) - y = torch.as_tensor(y) - params = [ - param for param in self.model.parameters() if param.requires_grad == True - ] + :param x: An array [NxD] representing the features $x_i$. + :param y: An array [NxK] representing the predicted target values $y_i$. + :param progress: True, iff progress shall be printed. + :returns: An array [NxP] representing the gradients with respect to + all parameters of the model. + """ + x = as_tensor(x, warn=False).to(self.device).unsqueeze(1) + y = as_tensor(y, warn=False).to(self.device) - grads = [ - flatten_gradient( - autograd.grad( - self.loss( - torch.squeeze(self.model(x[i])), - torch.squeeze(y[i]), - ), - params, - ) + grads = [] + for i in maybe_progress(range(len(x)), progress, desc="Split Gradient"): + grads.append( + flatten_all( + autograd.grad( + self.loss(torch.squeeze(self.model(x[i])), torch.squeeze(y[i])), + self.parameters, + ) + ).detach() ) - .detach() - .numpy() - for i in maybe_progress( - range(len(x)), - progress, - desc="Split Gradient", - ) - ] - return np.stack(grads, axis=0) + + return torch.stack(grads, axis=0) def grad( - self, - x: Union["NDArray", "torch.Tensor"], - y: Union["NDArray", "torch.Tensor"], - ) -> Tuple["NDArray", "torch.Tensor"]: - """ - Calculates gradient of model parameters wrt x and y. - Args: - x: A np.ndarray [NxD] representing the features x_i. - y: A np.ndarray [NxK] representing the predicted target values y_i. - progress: True, iff progress shall be printed. - Returns: - A tuple where: - - first element is a np.ndarray [P] with the gradients of the model. - - second element is the input to the model as a grad parameters. - This can be used for further differentiation. + self, x: torch.Tensor, y: torch.Tensor, *, x_requires_grad: bool = False + ) -> Tuple[torch.Tensor, torch.Tensor]: """ - x = torch.as_tensor(x).requires_grad_(True) - y = torch.as_tensor(y) + Calculates gradient of model parameters wrt the model parameters. - params = [ - param for param in self.model.parameters() if param.requires_grad == True - ] + :param x: A matrix [NxD] representing the features $x_i$. + :param y: A matrix [NxK] representing the target values $y_i$. + :param x_requires_grad: If True, the input $x$ is marked as requiring + gradients. This is important for further differentiation on input + parameters. + :returns: A tuple where the first element is an array [P] with the + gradients of the model and second element is the input to the model + as a grad parameters. This can be used for further differentiation. + """ + x = as_tensor(x, warn=False).to(self.device).requires_grad_(x_requires_grad) + y = as_tensor(y, warn=False).to(self.device) loss_value = self.loss(torch.squeeze(self.model(x)), torch.squeeze(y)) - grad_f = torch.autograd.grad(loss_value, params, create_graph=True) - return flatten_gradient(grad_f), x + grad_f = torch.autograd.grad(loss_value, self.parameters, create_graph=True) + return flatten_all(grad_f), x - def mvp( - self, - grad_xy: Union["NDArray", "torch.Tensor"], - v: Union["NDArray", "torch.Tensor"], - progress: bool = False, - backprop_on: Optional["torch.Tensor"] = None, - ) -> "NDArray": + def hessian( + self, x: torch.Tensor, y: torch.Tensor, *, progress: bool = False + ) -> torch.Tensor: + """Calculates the explicit hessian of model parameters given data ($x$ and $y$). + :param x: A matrix [NxD] representing the features $x_i$. + :param y: A matrix [NxK] representing the target values $y_i$. + :param progress: ``True`` to display progress. + :returns: the hessian of the model, i.e. the second derivative wrt. the model parameters. """ - Calculates second order derivative of the model along directions v. - This second order derivative can be on the model parameters or on another input parameter, - selected via the backprop_on argument. - - Args: - grad_xy: an array [P] holding the gradients of the model parameters wrt input x and labels y, \ - where P is the number of parameters of the model. It is typically obtained through self.grad. - v: A np.ndarray [DxP] or a one dimensional np.array [D] which multiplies the Hessian, \ - where D is the number of directions. - progress: True, iff progress shall be printed. - backprop_on: tensor used in the second backpropagation (the first one is along x and y as defined \ - via grad_xy). If None, the model parameters are used. - - Returns: - An array representing the implicit matrix vector product of the model - along the given directions. Output shape is [DxP] if backprop_on is None, - otherwise [DxM], with M the number of elements of backprop_on. - """ - v = torch.as_tensor(v) - if v.ndim == 1: - v = v.unsqueeze(0) + x = x.to(self.device) + y = y.to(self.device) + grad_xy, _ = self.grad(x, y) + return mvp( + grad_xy, + torch.eye(self.num_params, self.num_params, device=self.device), + self.parameters, + progress=progress, + ) - z = (grad_xy * Variable(v)).sum(dim=1) - params = [ - param for param in self.model.parameters() if param.requires_grad == True - ] - all_flattened_grads = [ - flatten_gradient( - autograd.grad( - z[i], - params if backprop_on is None else backprop_on, - retain_graph=True, - ) + +@dataclass +class LowRankProductRepresentation: + """ + Representation of a low rank product of the form $H = V D V^T$, where D is a diagonal matrix and + V is orthogonal + :param eigen_vals: diagonal of D + :param projections: the matrix V + """ + + eigen_vals: torch.Tensor + projections: torch.Tensor + + +def solve_arnoldi( + model: TorchTwiceDifferentiable, + training_data: DataLoader, + b: torch.Tensor, + *, + hessian_perturbation: float = 0.0, + rank_estimate: int = 10, + krylov_dimension: Optional[int] = None, + low_rank_representation: Optional[LowRankProductRepresentation] = None, + tol: float = 1e-6, + max_iter: Optional[int] = None, + eigen_computation_on_gpu: bool = False, +) -> InverseHvpResult: + + """ + Solves the linear system Hx = b, where H is the Hessian of the model's loss function and b is the given right-hand + side vector. The Hessian is approximated using a low-rank representation. + + :param model: A PyTorch model instance that is twice differentiable, wrapped into :class:`TorchTwiceDifferential`. + The Hessian will be calculated with respect to this model's parameters. + :param training_data: A DataLoader instance that provides the model's training data. + Used in calculating the Hessian-vector products. + :param b: The right-hand side vector in the system Hx = b. + :param hessian_perturbation: Optional regularization parameter added to the Hessian-vector product + for numerical stability. + :param rank_estimate: The number of eigenvalues and corresponding eigenvectors to compute. + Represents the desired rank of the Hessian approximation. + :param krylov_dimension: The number of Krylov vectors to use for the Lanczos method. + If not provided, it defaults to $min(model.num_parameters, max(2*rank_estimate + 1, 20))$. + :param low_rank_representation: A LowRankProductRepresentation instance containing a previously computed + low-rank representation of the Hessian. + If not provided, a new low-rank representation will be computed, + using provided parameters. + :param tol: The stopping criteria for the Lanczos algorithm. + If `low_rank_representation` is provided, this parameter is ignored. + :param max_iter: The maximum number of iterations for the Lanczos method. + If `low_rank_representation` is provided, this parameter is ignored. + :param eigen_computation_on_gpu: If True, tries to execute the eigen pair approximation on the model's + device via cupy implementation. + Make sure, that either your model is small enough or you use a + small rank_estimate to fit your device's memory. + If False, the eigen pair approximation is executed on the CPU by scipy wrapper to + ARPACK. + :return: Returns the solution vector x that satisfies the system Hx = b, + where H is a low-rank approximation of the Hessian of the model's loss function. + """ + + if low_rank_representation is None: + + raw_hvp = get_hvp_function( + model.model, model.loss, training_data, use_hessian_avg=True + ) + params = dict(model.model.named_parameters()) + + def hessian_vector_product(x: torch.Tensor) -> torch.Tensor: + output = raw_hvp(align_structure(params, x)) + return flatten_tensors_to_vector(output.values()) + + low_rank_representation = lanzcos_low_rank_hessian_approx( + hessian_vp=hessian_vector_product, + matrix_shape=(model.num_params, model.num_params), + hessian_perturbation=hessian_perturbation, + rank_estimate=rank_estimate, + krylov_dimension=krylov_dimension, + tol=tol, + max_iter=max_iter, + device=model.device if hasattr(model, "device") else None, + eigen_computation_on_gpu=eigen_computation_on_gpu, + ) + else: + logger.info("Using provided low rank representation, ignoring other parameters") + + result = low_rank_representation.projections @ ( + torch.diag_embed(1.0 / low_rank_representation.eigen_vals) + @ (low_rank_representation.projections.t() @ b.t()) + ) + return InverseHvpResult( + x=result.t(), + info={ + "eigenvalues": low_rank_representation.eigen_vals, + "eigenvectors": low_rank_representation.projections, + }, + ) + + +def lanzcos_low_rank_hessian_approx( + hessian_vp: Callable[[torch.Tensor], torch.Tensor], + matrix_shape: Tuple[int, int], + hessian_perturbation: float = 0.0, + rank_estimate: int = 10, + krylov_dimension: Optional[int] = None, + tol: float = 1e-6, + max_iter: Optional[int] = None, + device: Optional[torch.device] = None, + eigen_computation_on_gpu: bool = False, + torch_dtype: torch.dtype = None, +) -> LowRankProductRepresentation: + """ + Calculates a low-rank approximation of the Hessian matrix of the model's loss function using the implicitly + restarted Lanczos algorithm. + + + :param hessian_vp: A function that takes a vector and returns the product of the Hessian of the loss function + :param matrix_shape: The shape of the matrix, represented by hessian vector product. + :param hessian_perturbation: Optional regularization parameter added to the Hessian-vector product + for numerical stability. + :param rank_estimate: The number of eigenvalues and corresponding eigenvectors to compute. + Represents the desired rank of the Hessian approximation. + :param krylov_dimension: The number of Krylov vectors to use for the Lanczos method. + If not provided, it defaults to $min(model.num_parameters, max(2*rank_estimate + 1, 20))$. + :param tol: The stopping criteria for the Lanczos algorithm, which stops when the difference + in the approximated eigenvalue is less than `tol`. Defaults to 1e-6. + :param max_iter: The maximum number of iterations for the Lanczos method. If not provided, it defaults to + $10*model.num_parameters$ + :param device: The device to use for executing the hessian vector product. + :param eigen_computation_on_gpu: If True, tries to execute the eigen pair approximation on the provided + device via cupy implementation. + Make sure, that either your model is small enough or you use a + small rank_estimate to fit your device's memory. + If False, the eigen pair approximation is executed on the CPU by scipy wrapper to + ARPACK. + :param torch_dtype: if not provided, current torch default dtype is used for conversion to torch + :return: A `LowRankProductRepresentation` instance that contains the top (up until rank_estimate) eigenvalues + and corresponding eigenvectors of the Hessian. + """ + + torch_dtype = torch.get_default_dtype() if torch_dtype is None else torch_dtype + + if eigen_computation_on_gpu: + try: + import cupy as cp + from cupyx.scipy.sparse.linalg import LinearOperator, eigsh + from torch.utils.dlpack import from_dlpack, to_dlpack + except ImportError as e: + raise ImportError( + f"Try to install missing dependencies or set eigen_computation_on_gpu to False: {e}" ) - for i in maybe_progress( - range(len(z)), - progress, - desc="MVP", + + if device is None: + raise ValueError( + "Without setting an explicit device, cupy is not supported" ) - ] - hvp = torch.stack([grad.contiguous().view(-1) for grad in all_flattened_grads]) - return hvp.detach().numpy() # type: ignore + + def to_torch_conversion_function(x): + return from_dlpack(x.toDlpack()).to(torch_dtype) + + def mv(x): + x = to_torch_conversion_function(x) + y = hessian_vp(x) + hessian_perturbation * x + return cp.from_dlpack(to_dlpack(y)) + + else: + from scipy.sparse.linalg import LinearOperator, eigsh + + def mv(x): + x_torch = torch.as_tensor(x, device=device, dtype=torch_dtype) + y: NDArray = ( + (hessian_vp(x_torch) + hessian_perturbation * x_torch) + .detach() + .cpu() + .numpy() + ) + return y + + to_torch_conversion_function = partial(torch.as_tensor, dtype=torch_dtype) + + try: + + eigen_vals, eigen_vecs = eigsh( + LinearOperator(matrix_shape, matvec=mv), + k=rank_estimate, + maxiter=max_iter, + tol=tol, + ncv=krylov_dimension, + return_eigenvectors=True, + ) + + except ArpackNoConvergence as e: + logger.warning( + f"ARPACK did not converge for parameters {max_iter=}, {tol=}, {krylov_dimension=}, " + f"{rank_estimate=}. \n Returning the best approximation found so far. Use those with care or " + f"modify parameters.\n Original error: {e}" + ) + + eigen_vals, eigen_vecs = e.eigenvalues, e.eigenvectors + + eigen_vals = to_torch_conversion_function(eigen_vals) + eigen_vecs = to_torch_conversion_function(eigen_vecs) + + return LowRankProductRepresentation(eigen_vals, eigen_vecs) diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/frameworks/twice_differentiable.py new file mode 100644 index 000000000..26e9e430d --- /dev/null +++ b/src/pydvl/influence/frameworks/twice_differentiable.py @@ -0,0 +1,90 @@ +from abc import ABC +from dataclasses import dataclass +from typing import Any, Callable, Dict, Generic, List, Sequence, Tuple, TypeVar + +TensorType = TypeVar("TensorType", bound=Sequence) +ModelType = TypeVar("ModelType") +DeviceType = TypeVar("DeviceType") + + +@dataclass(frozen=True) +class InverseHvpResult(Generic[TensorType]): + x: TensorType + info: Dict[str, Any] + + def __iter__(self): + return iter((self.x, self.info)) + + +class TwiceDifferentiable(ABC, Generic[TensorType, ModelType, DeviceType]): + """ + Wraps a differentiable model and loss and provides methods to compute the + second derivative of the loss wrt. the model parameters. + """ + + def __init__( + self, + model: ModelType, + loss: Callable[[TensorType, TensorType], TensorType], + device: DeviceType, + ): + self.device = device + pass + + @property + def num_params(self) -> int: + """Returns the number of parameters of the model""" + pass + + @property + def parameters(self) -> List[TensorType]: + """Returns all the model parameters that require differentiation""" + pass + + def split_grad( + self, x: TensorType, y: TensorType, *, progress: bool = False + ) -> TensorType: + """ + Calculate the gradient of the model wrt each input x and labels y. + The output is therefore of size [Nxp], with N the amount of points (the + length of x and y) and P the number of parameters. + + :param x: An array representing the features $x_i$. + :param y: An array representing the predicted target values $y_i$. + :param progress: ``True`` to display progress. + :return: An array representing the gradients wrt. the parameters of the + model. + """ + pass + + def grad( + self, x: TensorType, y: TensorType, *, x_requires_grad: bool = False + ) -> Tuple[TensorType, TensorType]: + """ + Calculates gradient of model parameters wrt. the model parameters. + + :param x: A matrix representing the features $x_i$. + :param y: A matrix representing the target values $y_i$. + :param x_requires_grad: If True, the input $x$ is marked as requiring + gradients. This is important for further differentiation on input + parameters. + :return: A tuple where: the first element is an array with the + gradients of the model, and the second element is the input to the + model as a grad parameters. This can be used for further + differentiation. + """ + pass + + def hessian( + self, x: TensorType, y: TensorType, *, progress: bool = False + ) -> TensorType: + """Calculates the full Hessian of $L(f(x),y)$ with respect to the model + parameters given data ($x$ and $y$). + + :param x: An array representing the features $x_i$. + :param y: An array representing the target values $y_i$. + :param progress: ``True`` to display progress. + :return: The hessian of the model, i.e. the second derivative wrt. the + model parameters. + """ + pass diff --git a/src/pydvl/influence/frameworks/util.py b/src/pydvl/influence/frameworks/util.py new file mode 100644 index 000000000..540df53bc --- /dev/null +++ b/src/pydvl/influence/frameworks/util.py @@ -0,0 +1,144 @@ +import logging +import math +from typing import Dict, Iterable, Tuple, TypeVar + +import torch + +logger = logging.getLogger(__name__) + + +def to_model_device(x: torch.Tensor, model: torch.nn.Module) -> torch.Tensor: + """ + Returns the tensor `x` moved to the device of the `model`, if device of model is set + """ + if hasattr(model, "device"): + return x.to(model.device) + return x + + +def flatten_tensors_to_vector(tensors: Iterable[torch.Tensor]) -> torch.Tensor: + """ + Flatten multiple tensors into a single 1D tensor (vector). + + The function takes an iterable of tensors and reshapes each of them into a 1D tensor. + These reshaped tensors are then concatenated together into a single 1D tensor in the order they were given. + + :param tensors: An iterable of tensors to be reshaped and concatenated. + :return: A 1D tensor that is the concatenation of all the reshaped input tensors. + """ + + return torch.cat([t.contiguous().view(-1) for t in tensors]) + + +def reshape_vector_to_tensors( + input_vector: torch.Tensor, target_shapes: Iterable[Tuple[int, ...]] +) -> Tuple[torch.Tensor, ...]: + """ + Reshape a 1D tensor into multiple tensors with specified shapes. + + The function takes a 1D tensor (input_vector) and reshapes it into a series of tensors with shapes given by 'target_shapes'. + The reshaped tensors are returned as a tuple in the same order as their corresponding shapes. + + Note: The total number of elements in 'input_vector' must be equal to the sum of the products of the shapes in 'target_shapes'. + + :param input_vector: The 1D tensor to be reshaped. Must be 1D. + :param target_shapes: An iterable of tuples. Each tuple defines the shape of a tensor to be + reshaped from the 'input_vector'. + :return: A tuple of reshaped tensors. + :raises: + ValueError: If 'input_vector' is not a 1D tensor or if the total number of elements + in 'input_vector' does not match the sum of the products of the shapes in 'target_shapes'. + """ + + if input_vector.dim() != 1: + raise ValueError("Input vector must be a 1D tensor") + + total_elements = sum(math.prod(shape) for shape in target_shapes) + + if total_elements != input_vector.shape[0]: + raise ValueError( + f"The total elements in shapes {total_elements} does not match the vector length {input_vector.shape[0]}" + ) + + tensors = [] + start = 0 + for shape in target_shapes: + size = math.prod(shape) # compute the total size of the tensor with this shape + tensors.append( + input_vector[start : start + size].view(shape) + ) # slice the vector and reshape it + start += size + return tuple(tensors) + + +TorchTensorContainerType = TypeVar( + "TorchTensorContainerType", + torch.Tensor, + Tuple[torch.Tensor, ...], + Dict[str, torch.Tensor], +) + + +def align_structure( + source: Dict[str, torch.Tensor], + target: TorchTensorContainerType, +) -> Dict[str, torch.Tensor]: + """ + This function transforms `target` to have the same structure as `source`, i.e., + it should be a dictionary with the same keys as `source` and each corresponding + value in `target` should have the same shape as the value in `source`. + + :param source: The reference dictionary containing PyTorch tensors. + :param target: The input to be harmonized. It can be a dictionary, tuple, or tensor. + + :return: The harmonized version of `target`. + + :raises ValueError: If `target` cannot be harmonized to match `source`. + """ + + tangent_dict: Dict[str, torch.Tensor] + + if isinstance(target, dict): + + if list(target.keys()) != list(source.keys()): + raise ValueError("The keys in 'target' do not match the keys in 'source'.") + + if [v.shape for v in target.values()] != [v.shape for v in source.values()]: + + raise ValueError( + "The shapes of the values in 'target' do not match the shapes of the values in 'source'." + ) + + tangent_dict = target + + elif isinstance(target, tuple) or isinstance(target, list): + + if [v.shape for v in target] != [v.shape for v in source.values()]: + + raise ValueError( + "'target' is a tuple/list but its elements' shapes do not match the shapes " + "of the values in 'source'." + ) + + tangent_dict = dict(zip(source.keys(), target)) + + elif isinstance(target, torch.Tensor): + + try: + tangent_dict = dict( + zip( + source.keys(), + reshape_vector_to_tensors( + target, [p.shape for p in source.values()] + ), + ) + ) + except Exception as e: + raise ValueError( + f"'target' is a tensor but cannot be reshaped to match 'source'. Original error: {e}" + ) + + else: + raise ValueError(f"'target' is of type {type(target)} which is not supported.") + + return tangent_dict diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index ca1f32723..304910f5c 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -1,33 +1,24 @@ """ -Contains parallelized influence calculation functions for general models. +This module contains parallelized influence calculation functions for general +models, as introduced in :footcite:t:`koh_understanding_2017`. """ +from copy import deepcopy from enum import Enum -from typing import TYPE_CHECKING, Callable, Dict, Optional - -import numpy as np -from scipy.sparse.linalg import LinearOperator +from typing import Any, Dict, Optional, Tuple from ..utils import maybe_progress -from .conjugate_gradient import ( - batched_preconditioned_conjugate_gradient, - conjugate_gradient, +from .frameworks import ( + DataLoaderType, + TensorType, + TwiceDifferentiable, + einsum, + mvp, + transpose_tensor, + zero_tensor, ) -from .frameworks import TorchTwiceDifferentiable -from .types import MatrixVectorProductInversionAlgorithm, TwiceDifferentiable - -try: - import torch - import torch.nn as nn - - _TORCH_INSTALLED = True -except ImportError: - _TORCH_INSTALLED = False - -if TYPE_CHECKING: - from numpy.typing import NDArray +from .inversion import InverseHvpResult, InversionMethod, solve_hvp - -__all__ = ["compute_influences", "InfluenceType", "InversionMethod"] +__all__ = ["compute_influences", "InfluenceType", "compute_influence_factors"] class InfluenceType(str, Enum): @@ -39,198 +30,215 @@ class InfluenceType(str, Enum): Perturbation = "perturbation" -class InversionMethod(str, Enum): - """ - Different inversion methods types. - """ - - Direct = "direct" - Cg = "cg" - BatchedCg = "batched_cg" - - -def calculate_influence_factors( +def compute_influence_factors( model: TwiceDifferentiable, - x: "NDArray", - y: "NDArray", - x_test: "NDArray", - y_test: "NDArray", - inversion_func: MatrixVectorProductInversionAlgorithm, - lam: float = 0, + training_data: DataLoaderType, + test_data: DataLoaderType, + inversion_method: InversionMethod, + *, + hessian_perturbation: float = 0.0, progress: bool = False, -) -> "NDArray": + **kwargs: Any, +) -> InverseHvpResult: + r""" + Calculates influence factors of a model for training and test + data. Given a test point $z_test = (x_{test}, y_{test})$, a loss + $L(z_{test}, \theta)$ ($\theta$ being the parameters of the model) and the + Hessian of the model $H_{\theta}$, influence factors are defined as + $$s_{test} = H_{\theta}^{-1} \grad_{\theta} L(z_{test}, \theta).$$. They are + used for efficient influence calculation. This method first + (implicitly) calculates the Hessian and then (explicitly) finds the + influence factors for the model using the given inversion method. The + parameter ``hessian_perturbation`` is used to regularize the inversion of + the Hessian. For more info, refer to :footcite:t:`koh_understanding_2017`, + paragraph 3. + + :param model: A model wrapped in the TwiceDifferentiable interface. + :param training_data: A DataLoader containing the training data. + :param test_data: A DataLoader containing the test data. + :param inversion_func: function to use to invert the product of hvp (hessian + vector product) and the gradient of the loss (s_test in the paper). + :param hessian_perturbation: regularization of the hessian + :param progress: If True, display progress bars. + :returns: An array of size (N, D) containing the influence factors for each + dimension (D) and test sample (N). """ - Calculates the influence factors. For more info, see https://arxiv.org/pdf/1703.04730.pdf, paragraph 3. - - Args: - model: A model which has to implement the TwiceDifferentiable interface. - x_train: A np.ndarray of shape [MxK] containing the features of the input data points. - y_train: A np.ndarray of shape [MxL] containing the targets of the input data points. - x_test: A np.ndarray of shape [NxK] containing the features of the test set of data points. - y_test: A np.ndarray of shape [NxL] containing the targets of the test set of data points. - inversion_func: function to use to invert the product of hvp (hessian vector product) and the gradient - of the loss (s_test in the paper). - lam: regularization of the hessian - progress: If True, display progress bars. - - Returns: - A np.ndarray of size (N, D) containing the influence factors for each dimension (D) and test sample (N). - """ - if not _TORCH_INSTALLED: - raise RuntimeWarning("This function requires PyTorch.") - grad_xy, _ = model.grad(x, y) - hvp = lambda v: model.mvp(grad_xy, v) + lam * v - test_grads = model.split_grad(x_test, y_test, progress) - return inversion_func(hvp, test_grads) + test_grads = zero_tensor( + shape=(len(test_data.dataset), model.num_params), + dtype=test_data.dataset[0][0].dtype, + device=model.device, + ) + for batch_idx, (x_test, y_test) in enumerate( + maybe_progress(test_data, progress, desc="Batch Test Gradients") + ): + idx = batch_idx * test_data.batch_size + test_grads[idx : idx + test_data.batch_size] = model.split_grad( + x_test, y_test, progress=False + ) + return solve_hvp( + inversion_method, + model, + training_data, + test_grads, + hessian_perturbation=hessian_perturbation, + progress=progress, + **kwargs, + ) -def _calculate_influences_up( +def compute_influences_up( model: TwiceDifferentiable, - x: "NDArray", - y: "NDArray", - influence_factors: "NDArray", + input_data: DataLoaderType, + influence_factors: TensorType, + *, progress: bool = False, -) -> "NDArray": +) -> TensorType: + r""" + Given the model, the training points and the influence factors, calculates the + influences using the upweighting method. More precisely, first it calculates + the gradients of the model wrt. each training sample ($\grad_{\theta} L$, + with $L$ the loss of a single point and $\theta$ the parameters of the + model) and then multiplies each with the influence factors. For more + details, refer to section 2.1 of :footcite:t:`koh_understanding_2017`. + + :param model: A model which has to implement the TwiceDifferentiable + interface. + :param input_data: Data loader containing the samples to calculate the + influence of. + :param influence_factors: array containing influence factors + :param progress: If True, display progress bars. + :returns: An array of size [NxM], where N is number of influence factors, M + number of input points. """ - Calculates the influence from the influence factors and the scores of the training points. - Uses the upweighting method, as described in section 2.1 of https://arxiv.org/pdf/1703.04730.pdf - - Args: - model: A model which has to implement the TwiceDifferentiable interface. - x_train: A np.ndarray of shape [MxK] containing the features of the input data points. - y_train: A np.ndarray of shape [MxL] containing the targets of the input data points. - influence_factors: np.ndarray containing influence factors - progress: If True, display progress bars. - - Returns: - A np.ndarray of size [NxM], where N is number of test points and M number of train points. - """ - train_grads = model.split_grad(x, y, progress) - return np.einsum("ta,va->tv", influence_factors, train_grads) # type: ignore + grads = zero_tensor( + shape=(len(input_data.dataset), model.num_params), + dtype=input_data.dataset[0][0].dtype, + device=model.device, + ) + for batch_idx, (x, y) in enumerate( + maybe_progress(input_data, progress, desc="Batch Split Input Gradients") + ): + idx = batch_idx * input_data.batch_size + grads[idx : idx + input_data.batch_size] = model.split_grad( + x, y, progress=False + ) + return einsum("ta,va->tv", influence_factors, grads) -def _calculate_influences_pert( +def compute_influences_pert( model: TwiceDifferentiable, - x: "NDArray", - y: "NDArray", - influence_factors: "NDArray", + input_data: DataLoaderType, + influence_factors: TensorType, + *, progress: bool = False, -) -> "NDArray": +) -> TensorType: + r""" + Calculates the influence values from the influence factors and the training + points using the perturbation method. More precisely, for each training sample it + calculates $\grad_{\theta} L$ (with L the loss of the model over the single + point and $\theta$ the parameters of the model) and then uses the method + TwiceDifferentiable.mvp to efficiently calculate the product of the + influence factors and $\grad_x \grad_{\theta} L$. For more details, refer + to section 2.2 of :footcite:t:`koh_understanding_2017`. + + :param model: A model which has to implement the TwiceDifferentiable interface. + :param input_data: Data loader containing the samples to calculate the + influence of. + :param influence_factors: array containing influence factors + :param progress: If True, display progress bars. + :returns: An array of size [NxMxP], where N is the number of influence factors, M + the number of input data, and P the number of features. """ - Calculates the influence from the influence factors and the scores of the training points. - Uses the perturbation method, as described in section 2.2 of https://arxiv.org/pdf/1703.04730.pdf - - Args: - model: A model which has to implement the TwiceDifferentiable interface. - x_train: A np.ndarray of shape [MxK] containing the features of the input data points. - y_train: A np.ndarray of shape [MxL] containing the targets of the input data points. - influence_factors: np.ndarray containing influence factors - progress: If True, display progress bars. - - Returns: - A np.ndarray of size [NxMxP], where N is number of test points, M number of train points, and P the number of features. - """ - all_pert_influences = [] - for i in maybe_progress( - len(x), - progress, - desc="Influence Perturbation", - ): - grad_xy, tensor_x = model.grad(x[i : i + 1], y[i]) - perturbation_influences = model.mvp( - grad_xy, - influence_factors, - backprop_on=tensor_x, + input_x = input_data.dataset[0][0] + all_pert_influences = zero_tensor( + shape=(len(input_data.dataset), len(influence_factors), *input_x.shape), + dtype=input_x.dtype, + device=model.device, + ) + for batch_idx, (x, y) in enumerate( + maybe_progress( + input_data, + progress, + desc="Batch Influence Perturbation", ) - all_pert_influences.append(perturbation_influences.reshape((-1, *x[i].shape))) - - return np.stack(all_pert_influences, axis=1) - - -influence_type_function_dict = { - "up": _calculate_influences_up, - "perturbation": _calculate_influences_pert, + ): + for i in range(len(x)): + grad_xy, tensor_x = model.grad(x[i : i + 1], y[i], x_requires_grad=True) + perturbation_influences = mvp( + grad_xy, + influence_factors, + backprop_on=tensor_x, + ) + all_pert_influences[ + batch_idx * input_data.batch_size + i + ] = perturbation_influences.reshape((-1, *x[i].shape)) + + return transpose_tensor(all_pert_influences, 0, 1) + + +influence_type_registry = { + InfluenceType.Up: compute_influences_up, + InfluenceType.Perturbation: compute_influences_pert, } def compute_influences( - model: "nn.Module", - loss: Callable[["torch.Tensor", "torch.Tensor"], "torch.Tensor"], - x: "NDArray", - y: "NDArray", - x_test: "NDArray", - y_test: "NDArray", - progress: bool = False, + differentiable_model: TwiceDifferentiable, + training_data: DataLoaderType, + *, + test_data: Optional[DataLoaderType] = None, + input_data: Optional[DataLoaderType] = None, inversion_method: InversionMethod = InversionMethod.Direct, influence_type: InfluenceType = InfluenceType.Up, - inversion_method_kwargs: Optional[Dict] = None, - hessian_regularization: float = 0, -) -> "NDArray": - """ - Calculates the influence of the training points j on the test points i. First it calculates - the influence factors for all test points with respect to the training points, and then uses them to - get the influences over the complete training set. Points with low influence values are (on average) - less important for model training than points with high influences. - - Args: - model: A supervised model from a supported framework. Currently, only pytorch nn.Module is supported. - loss: loss of the model, a callable that, given prediction of the model and real labels, returns a - tensor with the loss value. - x: model input for training - y: input labels - x_test: model input for testing - y_test: test labels - progress: whether to display progress bars. - inversion_method: Set the inversion method to a specific one, can be 'direct' for direct inversion - (and explicit construction of the Hessian) or 'cg' for conjugate gradient. - influence_type: Which algorithm to use to calculate influences. - Currently supported options: 'up' or 'perturbation'. For details refer to https://arxiv.org/pdf/1703.04730.pdf - inversion_method_kwargs: kwargs for the inversion method selected. - If using the direct method no kwargs are needed. If inversion_method='cg', the following kwargs can be passed: - - rtol: relative tolerance to be achieved before terminating computation - - max_iterations: maximum conjugate gradient iterations - - max_step_size: step size of conjugate gradient - - verify_assumptions: True to run tests on convexity of the model. - hessian_regularization: lambda to use in Hessian regularization, i.e. H_reg = H + lambda * 1, with 1 the identity matrix \ - and H the (simple and regularized) Hessian. Typically used with more complex models to make sure the Hessian \ - is positive definite. - - Returns: - An array specifying the influences. Shape is [NxM] if influence_type is'up', where N is number of test points and M number of train points. If instead influence_type is 'perturbation', output shape is [NxMxP], with P the number of input features. + hessian_regularization: float = 0.0, + progress: bool = False, + **kwargs: Any, +) -> TensorType: + r""" + Calculates the influence of the input_data point j on the test points i. + First it calculates the influence factors of all test points with respect + to the model and the training points, and then uses them to get the + influences over the complete input_data set. + + :param differentiable_model: A model wrapped with its loss in TwiceDifferentiable. + :param training_data: data loader with the training data, used to calculate + the hessian of the model loss. + :param test_data: data loader with the test samples. If None, the samples in + training_data are used. + :param input_data: data loader with the samples to calculate the influences + of. If None, the samples in training_data are used. + :param progress: whether to display progress bars. + :param influence_type: Which algorithm to use to calculate influences. + Currently supported options: 'up' or 'perturbation'. For details refer + to :footcite:t:`koh_understanding_2017` + :param hessian_regularization: lambda to use in Hessian regularization, i.e. + H_reg = H + lambda * 1, with 1 the identity matrix and H the (simple and + regularized) Hessian. Typically used with more complex models to make + sure the Hessian is positive definite. + :returns: An array specifying the influences. Shape is [NxM] if + influence_type is'up', where N is number of test points and M number of + train points. If instead influence_type is 'perturbation', output shape + is [NxMxP], with P the number of input features. """ - if not _TORCH_INSTALLED: - raise RuntimeWarning("This function requires PyTorch.") - - if inversion_method_kwargs is None: - inversion_method_kwargs = dict() - differentiable_model = TorchTwiceDifferentiable(model, loss) - n_params = differentiable_model.num_params() - dict_fact_algos: Dict[Optional[str], MatrixVectorProductInversionAlgorithm] = { - "direct": lambda hvp, x: np.linalg.solve(hvp(np.eye(n_params)), x.T).T, # type: ignore - "cg": lambda hvp, x: conjugate_gradient(LinearOperator((n_params, n_params), matvec=hvp), x, progress), # type: ignore - "batched_cg": lambda hvp, x: batched_preconditioned_conjugate_gradient( # type: ignore - hvp, x, **inversion_method_kwargs - )[ - 0 - ], - } - - influence_factors = calculate_influence_factors( + if input_data is None: + input_data = deepcopy(training_data) + if test_data is None: + test_data = deepcopy(training_data) + + influence_factors, _ = compute_influence_factors( differentiable_model, - x, - y, - x_test, - y_test, - dict_fact_algos[inversion_method], - lam=hessian_regularization, + training_data, + test_data, + inversion_method, + hessian_perturbation=hessian_regularization, progress=progress, + **kwargs, ) - influence_function = influence_type_function_dict[influence_type] + compute_influence_type = influence_type_registry[influence_type] - return influence_function( + return compute_influence_type( differentiable_model, - x, - y, + input_data, influence_factors, - progress, + progress=progress, ) diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py new file mode 100644 index 000000000..4580e3b71 --- /dev/null +++ b/src/pydvl/influence/inversion.py @@ -0,0 +1,103 @@ +""" +Contains methods to invert the hessian vector product. +""" +import logging +from enum import Enum +from typing import Any + +from .frameworks import ( + DataLoaderType, + InverseHvpResult, + TensorType, + TwiceDifferentiable, + solve_batch_cg, + solve_linear, + solve_lissa, +) + +__all__ = ["solve_hvp"] + +from .frameworks.torch_differentiable import solve_arnoldi + +logger = logging.getLogger(__name__) + + +class InversionMethod(str, Enum): + """ + Different inversion methods types. + """ + + Direct = "direct" + Cg = "cg" + Lissa = "lissa" + Arnoldi = "arnoldi" + + +def solve_hvp( + inversion_method: InversionMethod, + model: TwiceDifferentiable, + training_data: DataLoaderType, + b: TensorType, + *, + hessian_perturbation: float = 0.0, + progress: bool = False, + **kwargs: Any, +) -> InverseHvpResult: + """ + Finds $x$ such that $Ax = b$, where $A$ is the hessian of model, + and $b$ a vector. + Depending on the inversion method, the hessian is either calculated directly + and then inverted, or implicitly and then inverted through matrix vector + product. The method also allows to add a small regularization term (hessian_perturbation) + to facilitate inversion of non fully trained models. + + :param inversion_method: + :param model: A model wrapped in the TwiceDifferentiable interface. + :param x: An array containing the features of the input data points. + :param y: labels for x + :param b: Array as the right hand side of the equation $Ax = b$ + :param kwargs: kwargs to pass to the inversion method + :param hessian_perturbation: regularization of the hessian + :param progress: If True, display progress bars. + + :return: An object that containes an array that solves the inverse problem, + i.e. it returns $x$ such that $Ax = b$, and a dictionary containing + information about the inversion process. + """ + if inversion_method == InversionMethod.Direct: + return solve_linear( + model, + training_data, + b, + **kwargs, + hessian_perturbation=hessian_perturbation, + progress=progress, + ) + elif inversion_method == InversionMethod.Cg: + return solve_batch_cg( + model, + training_data, + b, + **kwargs, + hessian_perturbation=hessian_perturbation, + progress=progress, + ) + elif inversion_method == InversionMethod.Lissa: + return solve_lissa( + model, + training_data, + b, + **kwargs, + hessian_perturbation=hessian_perturbation, + progress=progress, + ) + elif inversion_method == InversionMethod.Arnoldi: + return solve_arnoldi( + model, # type: ignore # TODO the interface TwiceDifferentiable is not used properly anyhow + training_data, + b, + **kwargs, + hessian_perturbation=hessian_perturbation, + ) + else: + raise ValueError(f"Unknown inversion method: {inversion_method}") diff --git a/src/pydvl/influence/linear.py b/src/pydvl/influence/linear.py deleted file mode 100644 index 9010e4061..000000000 --- a/src/pydvl/influence/linear.py +++ /dev/null @@ -1,161 +0,0 @@ -""" -This module contains all functions for the closed form computation of influences -for standard linear regression. -""" -from typing import TYPE_CHECKING, Tuple - -import numpy as np -from sklearn.linear_model import LinearRegression - -from ..utils.numeric import ( - linear_regression_analytical_derivative_d2_theta, - linear_regression_analytical_derivative_d_theta, - linear_regression_analytical_derivative_d_x_d_theta, -) -from .general import InfluenceType - -if TYPE_CHECKING: - from numpy.typing import NDArray - -__all__ = ["compute_linear_influences"] - - -def compute_linear_influences( - x: "NDArray", - y: "NDArray", - x_test: "NDArray", - y_test: "NDArray", - influence_type: InfluenceType = InfluenceType.Up, -): - """Calculate the influence each training sample on the loss computed over a - validation set for an ordinary least squares model ($y = A x + b$ with - quadratic loss). - - Args: - x: An array of shape (M, K) containing the features of training data. - y: An array of shape (M, L) containing the targets of training data. - x_test: An array of shape (N, K) containing the features of the - test set. - y_test: An array of shape (N, L) containing the targets of the test - set. - influence_type: Which algorithm to use to calculate influences. - Currently supported options: 'up' or 'perturbation'. - - Returns: - An array of shape (B, C) with the influences of the training points on the test data. - """ - - lr = LinearRegression() - lr.fit(x, y) - A = lr.coef_ - b = lr.intercept_ - - if influence_type not in list(InfluenceType): - raise NotImplementedError( - f"Only up-weighting and perturbation influences are supported, but got {influence_type=}" - ) - - if influence_type == InfluenceType.Up: - return influences_up_linear_regression_analytical( - (A, b), - x, - y, - x_test, - y_test, - ) - elif influence_type == InfluenceType.Perturbation: - return influences_perturbation_linear_regression_analytical( - (A, b), - x, - y, - x_test, - y_test, - ) - - -def influences_up_linear_regression_analytical( - linear_model: Tuple["NDArray", "NDArray"], - x: "NDArray", - y: "NDArray", - x_test: "NDArray", - y_test: "NDArray", -): - """Calculate the influence each training sample on the loss computed over a - validation set for an ordinary least squares model (Ax+b=y with quadratic - loss). - - Args: - linear_model: A tuple of arrays of shapes (N, M) and N representing A and b respectively. - x: An array of shape (M, K) containing the features of the training set. - y: An array of shape (M, L) containing the targets of the training set. - x_test: An array of shape (N, K) containing the features of the test set. - y_test: An array of shape (N, L) containing the targets of the test set. - - Returns: - An array of shape (B, C) with the influences of the training points on the test points. - """ - - test_grads_analytical = linear_regression_analytical_derivative_d_theta( - linear_model, - x_test, - y_test, - ) - train_grads_analytical = linear_regression_analytical_derivative_d_theta( - linear_model, - x, - y, - ) - hessian_analytical = linear_regression_analytical_derivative_d2_theta( - linear_model, - x, - y, - ) - s_test_analytical = np.linalg.solve(hessian_analytical, test_grads_analytical.T).T - result: "NDArray" = np.einsum( - "ia,ja->ij", s_test_analytical, train_grads_analytical - ) - return result - - -def influences_perturbation_linear_regression_analytical( - linear_model: Tuple["NDArray", "NDArray"], - x: "NDArray", - y: "NDArray", - x_test: "NDArray", - y_test: "NDArray", -): - """Calculate the influences of each training sample onto the - validation set for a linear model Ax+b=y. - - Args: - linear_model: A tuple of np.ndarray' of shape (N, M) and (N) representing A and b respectively. - x: An array of shape (M, K) containing the features of the input data. - y: An array of shape (M, L) containing the targets of the input data. - x_test: An array of shape (N, K) containing the features of the test set. - y_test: An array of shape (N, L) containing the targets of the test set. - - Returns: - An array of shape (B, C, M) with the influences of the training points on the test points for each feature. - """ - - test_grads_analytical = linear_regression_analytical_derivative_d_theta( - linear_model, - x_test, - y_test, - ) - train_second_deriv_analytical = linear_regression_analytical_derivative_d_x_d_theta( - linear_model, - x, - y, - ) - - hessian_analytical = linear_regression_analytical_derivative_d2_theta( - linear_model, - x, - y, - ) - s_test_analytical = np.linalg.solve(hessian_analytical, test_grads_analytical.T).T - result: "NDArray" = np.einsum( - "ia,jab->ijb", s_test_analytical, train_second_deriv_analytical - ) - return result diff --git a/src/pydvl/influence/model_wrappers/__init__.py b/src/pydvl/influence/model_wrappers/__init__.py deleted file mode 100644 index 4397c4664..000000000 --- a/src/pydvl/influence/model_wrappers/__init__.py +++ /dev/null @@ -1,7 +0,0 @@ -from .torch_wrappers import * - -__all__ = [ - "TorchLinearRegression", - "TorchBinaryLogisticRegression", - "TorchMLP", -] diff --git a/src/pydvl/influence/model_wrappers/torch_wrappers.py b/src/pydvl/influence/model_wrappers/torch_wrappers.py deleted file mode 100644 index b368b5da3..000000000 --- a/src/pydvl/influence/model_wrappers/torch_wrappers.py +++ /dev/null @@ -1,296 +0,0 @@ -import logging -from abc import ABC, abstractmethod -from typing import TYPE_CHECKING, Any, Callable, List, Optional, Tuple, Union - -import numpy as np - -from ...utils import maybe_progress - -try: - import torch - import torch.nn as nn - from torch.nn import Softmax, Tanh - from torch.optim import Optimizer - from torch.optim.lr_scheduler import _LRScheduler - from torch.utils.data import DataLoader, TensorDataset - - _TORCH_INSTALLED = True -except ImportError: - _TORCH_INSTALLED = False - -if TYPE_CHECKING: - from numpy.typing import NDArray - -__all__ = [ - "TorchLinearRegression", - "TorchBinaryLogisticRegression", - "TorchMLP", - "TorchModel", -] - -logger = logging.getLogger(__name__) - - -class TorchModelBase(ABC): - def __init__(self): - if not _TORCH_INSTALLED: - raise RuntimeWarning("This function requires PyTorch.") - - @abstractmethod - def forward(self, x: torch.Tensor) -> torch.Tensor: - pass - - def fit( - self, - x_train: Union["NDArray[np.float_]", torch.tensor], - y_train: Union["NDArray[np.float_]", torch.tensor], - x_val: Union["NDArray[np.float_]", torch.tensor], - y_val: Union["NDArray[np.float_]", torch.tensor], - loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], - optimizer: Optimizer, - scheduler: Optional[_LRScheduler] = None, - num_epochs: int = 1, - batch_size: int = 64, - progress: bool = True, - ) -> Tuple["NDArray[np.float_]", "NDArray[np.float_]"]: - """ - Wrapper of pytorch fit method. It fits the model to the supplied data. - It represents a simple machine learning loop, iterating over a number of - epochs, sampling data with a certain batch size, calculating gradients and updating the parameters through a - loss function. - x: Matrix of shape [NxD] representing the features x_i. - y: Matrix of shape [NxK] representing the prediction targets y_i. - optimizer: Select either ADAM or ADAM_W. - scheduler: A pytorch scheduler. If None, no scheduler is used. - num_epochs: Number of epochs to repeat training. - batch_size: Batch size to use in training. - progress: True, iff progress shall be printed. - tensor_type: accuracy of tensors. Typically 'float' or 'long' - """ - x_train = torch.as_tensor(x_train).clone() - y_train = torch.as_tensor(y_train).clone() - x_val = torch.as_tensor(x_val).clone() - y_val = torch.as_tensor(y_val).clone() - - dataset = TensorDataset(x_train, y_train) - dataloader = DataLoader(dataset, batch_size=batch_size) - train_loss = [] - val_loss = [] - - for epoch in maybe_progress(range(num_epochs), progress, desc="Model fitting"): - batch_loss = [] - for train_batch in dataloader: - batch_x, batch_y = train_batch - pred_y = self.forward(batch_x) - loss_value = loss(torch.squeeze(pred_y), torch.squeeze(batch_y)) - batch_loss.append(loss_value.item()) - - logger.debug(f"Epoch: {epoch} ---> Training loss: {loss_value.item()}") - loss_value.backward() - optimizer.step() - optimizer.zero_grad() - - if scheduler: - scheduler.step() - pred_val = self.forward(x_val) - epoch_val_loss = loss(torch.squeeze(pred_val), torch.squeeze(y_val)).item() - mean_epoch_train_loss = np.mean(batch_loss) - val_loss.append(epoch_val_loss) - train_loss.append(mean_epoch_train_loss) - logger.info( - f"Epoch: {epoch} ---> Training loss: {mean_epoch_train_loss}, Validation loss: {epoch_val_loss}" - ) - return np.array(train_loss), np.array(val_loss) - - def predict(self, x: torch.Tensor) -> "NDArray[np.float_]": - """ - Use internal model to deliver prediction in numpy. - Args: - x: A np.ndarray [NxD] representing the features x_i. - - Returns: - A np.ndarray [NxK] representing the predicted values. - """ - return self.forward(x).detach().numpy() # type: ignore - - def score( - self, - x: torch.Tensor, - y: torch.Tensor, - score: Callable[[torch.Tensor, torch.Tensor, Any], torch.Tensor], - ) -> float: - """ - Use internal model to measure how good is prediction through a loss function. - Args: - x: A np.ndarray [NxD] representing the features x_i. - y: A np.ndarray [NxK] representing the predicted target values y_i. - - Returns: - The aggregated value over all samples N. - """ - return score(self.forward(x), y).detach().numpy() # type: ignore - - -class TorchModel(TorchModelBase): - def __init__(self, model: nn.Module): - self.model = model - - def forward(self, x: torch.Tensor) -> torch.Tensor: - return self.model(x) - - def __call__(self, *args, **kwargs): - return self.model(*args, **kwargs) - - -class TorchLinearRegression(nn.Module, TorchModelBase): - """ - A simple linear regression model (with bias) f(x)=Ax+b. - """ - - def __init__( - self, - n_input: int, - n_output: int, - init: Tuple["NDArray[np.float_]", "NDArray[np.float_]"] = None, - ): - """ - n_input: input to the model. - n_output: output of the model - :param init A tuple with two matrices, namely A of shape [K, D] and b of shape [K]. If set to None Xavier - uniform initialization is used. - """ - super().__init__() - self.n_input = n_input - self.n_output = n_output - if init is None: - r = np.sqrt(6 / (n_input + n_output)) - init_A = np.random.uniform(-r, r, size=[n_output, n_input]) - init_b = np.zeros(n_output) - init = (init_A, init_b) - - self.A = nn.Parameter( - torch.tensor(init[0], dtype=torch.float64), requires_grad=True - ) - self.b = nn.Parameter( - torch.tensor(init[1], dtype=torch.float64), requires_grad=True - ) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """ - Calculate A @ x + b using RAM-optimized calculation layout. - Args: - x: Tensor [NxD] representing the features x_i. - Returns: - A tensor [NxK] representing the outputs y_i. - """ - return x @ self.A.T + self.b - - -class TorchBinaryLogisticRegression(nn.Module, TorchModelBase): - """ - A simple binary logistic regression model p(y)=sigmoid(dot(a, x) + b). - """ - - def __init__( - self, - n_input: int, - init: Tuple["NDArray[np.float_]", "NDArray[np.float_]"] = None, - ): - """ - Args: - n_input: Number of feature inputs to the BinaryLogisticRegressionModel. - init: A tuple representing the initialization for the weight matrix A and the bias b. If set to None - sample the values uniformly using the Xavier rule. - """ - super().__init__() - self.n_input = n_input - if init is None: - init_A = np.random.normal(0, 0.02, size=(1, n_input)) - init_b = np.random.normal(0, 0.02, size=(1)) - init = (init_A, init_b) - - self.A = nn.Parameter(torch.tensor(init[0]), requires_grad=True) - self.b = nn.Parameter(torch.tensor(init[1]), requires_grad=True) - - def forward(self, x: Union["NDArray[np.float_]", torch.Tensor]) -> torch.Tensor: - """ - Calculate sigmoid(dot(a, x) + b) using RAM-optimized calculation layout. - Args: - x: Tensor [NxD] representing the features x_i. - - Returns: - A tensor [N] representing the probabilities for p(y_i). - """ - x = torch.as_tensor(x) - return torch.sigmoid(x @ self.A.T + self.b) - - -class TorchMLP(nn.Module, TorchModelBase): - """ - A simple fully-connected neural network f(x) model defined by y = v_K, v_i = o(A v_(i-1) + b), v_1 = x. It contains - K layers and K - 2 hidden layers. It holds that K >= 2, because every network contains a input and output. - """ - - def __init__( - self, - n_input: int, - n_output: int, - n_neurons_per_layer: List[int], - output_probabilities: bool = True, - init: List[Tuple["NDArray[np.float_]", "NDArray[np.float_]"]] = None, - ): - """ - Args: - n_input: Number of feature in input. - n_output: Output length. - n_neurons_per_layer: Each integer represents the size of a hidden layer. Overall this list has K - 2 - output_probabilities: True, if the model should output probabilities. In the case of n_output 2 the - number of outputs reduce to 1. - init: A list of tuple of np.ndarray representing the internal weights. - """ - super().__init__() - self.n_input = n_input - self.n_output = 1 if output_probabilities and n_output == 2 else n_output - - self.n_hidden_layers = n_neurons_per_layer - self.output_probabilities = output_probabilities - - all_dimensions = [self.n_input] + self.n_hidden_layers + [self.n_output] - layers = [] - num_layers = len(all_dimensions) - 1 - for num_layer, (in_features, out_features) in enumerate( - zip(all_dimensions[:-1], all_dimensions[1:]) - ): - linear_layer = nn.Linear( - in_features, out_features, bias=num_layer < len(all_dimensions) - 2 - ) - - if init is None: - torch.nn.init.xavier_uniform_(linear_layer.weight) - if num_layer < len(all_dimensions) - 2: - linear_layer.bias.data.fill_(0.01) - - else: - A, b = init[num_layer] - linear_layer.weight.data = A - if num_layer < len(all_dimensions) - 2: - linear_layer.bias.data = b - - layers.append(linear_layer) - if num_layer < num_layers - 1: - layers.append(Tanh()) - elif self.output_probabilities: - layers.append(Softmax(dim=-1)) - - self.layers = nn.Sequential(*layers) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """ - Perform forward-pass through the network. - Args: - x: Tensor input of shape [NxD]. - - Returns: - Tensor output of shape[NxK]. - """ - return self.layers(x) diff --git a/src/pydvl/influence/types.py b/src/pydvl/influence/types.py deleted file mode 100644 index 866214044..000000000 --- a/src/pydvl/influence/types.py +++ /dev/null @@ -1,48 +0,0 @@ -from abc import ABC -from typing import Callable, Iterable, Optional, Tuple - -from numpy import ndarray - -__all__ = [ - "TwiceDifferentiable", - "MatrixVectorProduct", - "MatrixVectorProductInversionAlgorithm", -] - - -class TwiceDifferentiable(ABC): - def num_params(self) -> int: - pass - - def split_grad(self, x: ndarray, y: ndarray, progress: bool = False) -> ndarray: - """ - Calculate the gradient of the model wrt each input x and labels y. - The output is therefore of size [Nxp], with N the amout of points (the length of x and y) and - P the number of parameters. - """ - pass - - def grad(self, x: ndarray, y: ndarray) -> Tuple[ndarray, ndarray]: - """ - It calculates the gradient of model parameters with respect to input x and labels y. - """ - pass - - def mvp( - self, - grad_xy: ndarray, - v: ndarray, - progress: bool = False, - backprop_on: Optional[Iterable] = None, - ) -> ndarray: - """ - Calculate the hessian vector product over the loss with all input parameters x and y with the vector v. - """ - pass - - -MatrixVectorProduct = Callable[[ndarray], ndarray] - -MatrixVectorProductInversionAlgorithm = Callable[ - [MatrixVectorProduct, ndarray], ndarray -] From c76ddbc853c786084474d2ba6550ddf6460d5760 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 10 Aug 2023 16:45:51 +0200 Subject: [PATCH 229/436] Add macros mkdocs plugin to handle transferlab links --- docs/10-getting-started.md | 4 ++-- docs/20-install.md | 6 +++--- mkdocs.yml | 4 ++++ requirements-docs.txt | 1 + 4 files changed, 10 insertions(+), 5 deletions(-) diff --git a/docs/10-getting-started.md b/docs/10-getting-started.md index d232ece22..e8c13db3f 100644 --- a/docs/10-getting-started.md +++ b/docs/10-getting-started.md @@ -22,7 +22,7 @@ algorithms for data valuation and influence functions. You can read: We only briefly introduce key concepts in the documentation. For a thorough introduction and survey of the field, we refer to **the upcoming review** at the -[TransferLab website](https://transferlab.appliedai.de/reviews/data-valuation). +[TransferLab website]({{ transferlab.data_valuation_review }}). # Running the examples @@ -30,7 +30,7 @@ If you are somewhat familiar with the concepts of data valuation, you can start by browsing our worked-out examples illustrating pyDVL's capabilities either: - [[examples]]. -- Using [binder](https://mybinder.org/>) notebooks, deployed from each +- Using [binder](https://mybinder.org/) notebooks, deployed from each example's page. - Locally, by starting a jupyter server at the root of the project. You will have to install jupyter first manually since it's not a dependency of the diff --git a/docs/20-install.md b/docs/20-install.md index df6c6967d..01f126ac9 100644 --- a/docs/20-install.md +++ b/docs/20-install.md @@ -62,9 +62,9 @@ the instructions in their documentation for installation. memcached is an in-memory key-value store accessible over the network. pyDVL uses it to cache certain results and speed-up the computations. You can either install it as a package or run it inside a docker container (the simplest). For -installation instructions, refer to the [Getting started](https://github.com/ -memcached/memcached/wiki#getting-started) section -in memcached's wiki. Then you can run it with: +installation instructions, refer to the +[Getting started](https://github.com/memcached/memcached/wiki#getting-started) +section in memcached's wiki. Then you can run it with: ```shell memcached -u user diff --git a/mkdocs.yml b/mkdocs.yml index 3f6ebaf28..371fe8fbc 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -15,6 +15,7 @@ plugins: - mike - autorefs - search + - macros - section-index - alias: use_relative_link: true @@ -105,6 +106,9 @@ extra_javascript: - https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js extra: + transferlab: + website: https://transferlab.appliedai.de + data_valuation_review: https://transferlab.appliedai.de/reviews/data-valuation version: provider: mike default: stable diff --git a/requirements-docs.txt b/requirements-docs.txt index a5c87d432..e41baf78a 100644 --- a/requirements-docs.txt +++ b/requirements-docs.txt @@ -9,6 +9,7 @@ mkdocs-gen-files mkdocs-literate-nav mkdocs-section-index mkdocs-bibtex +mkdocs-macros-plugin neoteroi-mkdocs # Needed for card grid on home page mkdocs-git-revision-date-localized-plugin pypandoc_binary \ No newline at end of file From 7ebb4836a3253be80b62f03b20ec6900714b34ac Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 10 Aug 2023 17:04:43 +0200 Subject: [PATCH 230/436] Fix links inside data valuation document --- docs/30-data-valuation.md | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/docs/30-data-valuation.md b/docs/30-data-valuation.md index b2d7918d9..2e478b04a 100644 --- a/docs/30-data-valuation.md +++ b/docs/30-data-valuation.md @@ -66,7 +66,7 @@ necessary to group samples to valuate them together. [Dataset][pydvl.utils.dataset.Dataset] with the same interface which allows this. You can see an example in action in the -:doc:`Spotify notebook `, but here's a simple +[Spotify notebook](../examples/shapley_basic_spotify), but here's a simple example grouping a pre-existing `Dataset`. First we construct an array mapping each index in the dataset to a group, then use [from_dataset][pydvl.utils.dataset.GroupedDataset.from_dataset]: @@ -175,9 +175,7 @@ As you can see, all that is required is a model to learn the utility itself and the fitting and using of the learned model happens behind the scenes. There is a longer example with an investigation of the results achieved by DUL -in :doc:`a dedicated notebook `. - -.. _LOO: +in [a dedicated notebook](../examples/shapley_utility_learning). ## Leave-One-Out values @@ -224,7 +222,7 @@ The supported methods are enumerated in The first algorithm is just a verbatim implementation of the definition. As such it returns as exact a value as the utility function allows (see what this means -in :ref:`problems of data values`). +in Problems of Data Values][problems-of-data-values]). The value $v$ of the $i$-th sample in dataset $D$ wrt. utility $u$ is computed as a weighted sum of its marginal utility wrt. every possible coalition of @@ -464,7 +462,7 @@ $$ This first algorithm is just a verbatim implementation of the definition. As such it returns as exact a value as the utility function allows -(see what this means in :ref:`problems of data values`). +(see what this means in Problems of Data Values][problems-of-data-values]). ```python from pydvl.value import compute_least_core_values @@ -658,11 +656,11 @@ nature of every (non-trivial) ML problem can have an effect: approximations can converge slowly. Massive datasets are thus impractical, at least with current techniques. A workaround is to group samples and investigate their value together. In pyDVL you can do this using - [GroupedDataset][pydvl.utils.dataset.GroupedDataset]. There is a fully worked-out - :doc:`example here `. Some algorithms also - provide different sampling strategies to reduce the variance, but due to a - no-free-lunch-type theorem, no single strategy can be optimal for all - utilities. + [GroupedDataset][pydvl.utils.dataset.GroupedDataset]. + There is a fully worked-out [example here](../examples/shapley_basic_spotify). + Some algorithms also provide different sampling strategies to reduce + the variance, but due to a no-free-lunch-type theorem, + no single strategy can be optimal for all utilities. * **Model size**: Since every evaluation of the utility entails retraining the whole model on a subset of the data, large models require great amounts of From 53e7a1a4812f7eb88debb0bbf127f5573190d191 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 12 Aug 2023 20:04:22 +0200 Subject: [PATCH 231/436] Add cancellation policy to ray executor --- src/pydvl/utils/parallel/futures/ray.py | 88 ++++++++++++++++++------- 1 file changed, 66 insertions(+), 22 deletions(-) diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 62ad8d26b..deee0c519 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -1,5 +1,4 @@ import logging -import math import queue import sys import threading @@ -7,20 +6,40 @@ import types from concurrent.futures import Executor, Future from dataclasses import asdict +from enum import Enum from typing import Any, Callable, Optional, TypeVar from weakref import WeakSet, ref import ray +from deprecate import deprecated from pydvl.utils import ParallelConfig -__all__ = ["RayExecutor"] +__all__ = ["CancellationPolicy", "RayExecutor"] T = TypeVar("T") logger = logging.getLogger(__name__) +class CancellationPolicy(Enum): + """Policy to use when cancelling futures after exiting an Executor. + + :cvar NONE: Do not cancel any futures. + :cvar PENDING: Cancel all pending futures, but not running ones. + :cvar RUNNING: Cancel all running futures, but not pending ones. + :cvar ALL: Cancel all pending and running futures. + """ + + NONE = 0 + PENDING = 1 + RUNNING = 2 + ALL = 3 + + def __and__(self, other: "CancellationPolicy") -> bool: + return int(self.value) & int(other.value) > 0 + + class RayExecutor(Executor): """Asynchronous executor using Ray that implements the concurrent.futures API. @@ -35,29 +54,36 @@ class RayExecutor(Executor): in the ray cluster. :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. - :param cancel_futures_on_exit: If ``True``, all futures will be cancelled - when exiting the context created by using this class instance as a - context manager. It will be ignored when calling :meth:`shutdown` - directly. + :param cancel_futures: Select which futures will be cancelled + when exiting this context manager. Pending is the default, which + will cancel all pending futures, but not running ones, as done by + :class:`concurrent.futures.ProcessPoolExecutor`. Additionally, `All` + cancels all pending and running futures, and `None` doesn't cancel any. """ + @deprecated( + target=True, + deprecated_in="0.6.2", + remove_in="0.7", + args_mapping={"cancel_futures_on_exit": "cancel_futures"}, + ) def __init__( self, max_workers: Optional[int] = None, *, config: ParallelConfig = ParallelConfig(), - cancel_futures_on_exit: bool = True, + cancel_futures: CancellationPolicy = CancellationPolicy.ALL, ): if config.backend != "ray": raise ValueError( - f"Parallel backend must be set to 'ray' and not {config.backend}" + f"Parallel backend must be set to 'ray' and not '{config.backend}'" ) if max_workers is not None: if max_workers <= 0: raise ValueError("max_workers must be greater than 0") max_workers = max_workers - self.cancel_futures_on_exit = cancel_futures_on_exit + self._cancel_futures = cancel_futures config_dict = asdict(config) config_dict.pop("backend") @@ -66,6 +92,7 @@ def __init__( config_dict["num_cpus"] = n_cpus_local self.config = config_dict if not ray.is_initialized(): + # FIXME: this couples ParallelConfig to ray's init() parameters ray.init(**self.config) self._max_workers = max_workers @@ -73,7 +100,6 @@ def __init__( self._max_workers = int(ray._private.state.cluster_resources()["CPU"]) self._shutdown = False - self._cancel_pending_futures = False self._shutdown_lock = threading.Lock() self._queue_lock = threading.Lock() self._work_queue: "queue.Queue[Optional[_WorkItem]]" = queue.Queue( @@ -120,12 +146,29 @@ def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": self._start_work_item_manager_thread() return future - def shutdown(self, wait: bool = True, *, cancel_futures: bool = False) -> None: + def shutdown(self, wait: bool = True, *, cancel_futures: bool = None) -> None: + """Clean up the resources associated with the Executor. + + This method tries to mimic the behaviour of :meth:`Executor.shutdown` + while allowing one more value for ``cancel_futures`` which instructs it + to use the :class:`CancellationPolicy` defined upon construction. + + :param wait: Whether to wait for pending futures to finish. + :param cancel_futures: Overrides the executor's default policy for + cancelling futures on exit. If ``True``, all pending futures are + cancelled, and if ``False``, no futures are cancelled. If ``None`` + (default), the executor's policy set at initialization is used. + :return: + """ logger.debug("executor shutting down") with self._shutdown_lock: logger.debug("executor acquired shutdown lock") self._shutdown = True - self._cancel_pending_futures = cancel_futures + self._cancel_futures = { + None: self._cancel_futures, + True: CancellationPolicy.PENDING, + False: CancellationPolicy.NONE, + }[cancel_futures] if wait: logger.debug("executor waiting for futures to finish") @@ -157,13 +200,8 @@ def _start_work_item_manager_thread(self) -> None: self._work_item_manager_thread.start() def __exit__(self, exc_type, exc_val, exc_tb): - """Exit the runtime context related to the RayExecutor object. - - This explicitly sets cancel_futures to be equal to cancel_futures_on_exit - attribute set at instantiation time in the call to the `shutdown()` method - which is different from the base Executor class' __exit__ method. - """ - self.shutdown(cancel_futures=self.cancel_futures_on_exit) + """Exit the runtime context related to the RayExecutor object.""" + self.shutdown() return False @@ -323,13 +361,18 @@ def flag_executor_shutting_down(self): logger.debug("work item manager thread acquired shutdown lock") if executor is not None: executor._shutdown = True - # Cancel pending work items if requested. - if executor._cancel_pending_futures: + if executor._cancel_futures & CancellationPolicy.RUNNING: logger.debug("forcefully cancelling running futures") # We cancel the future's object references # We cannot cancel a running future object. for future in self.submitted_futures: ray.cancel(future.object_ref) + # FIXME: huh? why is this here? + # Make sure we do this only once to not waste time looping + # on running processes over and over. + executor._cancel_futures = CancellationPolicy.NONE + + if executor._cancel_futures & CancellationPolicy.PENDING: # Drain all work items from the queues, # and then cancel their associated futures. # We empty the pending queue first. @@ -352,6 +395,7 @@ def flag_executor_shutting_down(self): if work_item is not None: work_item.future.cancel() del work_item + # FIXME: huh? why is this here? # Make sure we do this only once to not waste time looping # on running processes over and over. - executor._cancel_pending_futures = False + executor._cancel_futures = CancellationPolicy.NONE From a678b5081482f82c8c0d49e18bb108fec860383a Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 12 Aug 2023 20:05:09 +0200 Subject: [PATCH 232/436] Move backend registry and executor factory into parallel backends --- src/pydvl/utils/parallel/backend.py | 73 ++++++++++++-------- src/pydvl/utils/parallel/futures/__init__.py | 27 ++++---- 2 files changed, 59 insertions(+), 41 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index 98fcabf75..d4a93e77b 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -1,6 +1,8 @@ +from __future__ import annotations + import os from abc import ABCMeta, abstractmethod -from dataclasses import asdict +from concurrent.futures import Executor from typing import ( Any, Callable, @@ -12,11 +14,13 @@ Type, TypeVar, Union, + cast, ) import joblib import ray from joblib import delayed +from joblib.externals.loky import get_reusable_executor from ray import ObjectRef from ray.util.joblib import register_ray @@ -26,8 +30,6 @@ T = TypeVar("T") -_PARALLEL_BACKENDS: Dict[str, "Type[BaseParallelBackend]"] = {} - class NoPublicConstructor(ABCMeta): """Metaclass that ensures a private constructor @@ -47,10 +49,10 @@ class SomeClass(metaclass=NoPublicConstructor): def __call__(cls, *args, **kwargs): raise TypeError( f"{cls.__module__}.{cls.__qualname__} cannot be initialized directly. " - "Use init_parallel_backend() instead." + "Use the proper factory instead." ) - def _create(cls, *args: Any, **kwargs: Any): + def create(cls, *args: Any, **kwargs: Any): return super().__call__(*args, **kwargs) @@ -58,11 +60,21 @@ class BaseParallelBackend(metaclass=NoPublicConstructor): """Abstract base class for all parallel backends""" config: Dict[str, Any] = {} + BACKENDS: Dict[str, "Type[BaseParallelBackend]"] = {} def __init_subclass__(cls, *, backend_name: str, **kwargs): - global _PARALLEL_BACKENDS - _PARALLEL_BACKENDS[backend_name] = cls super().__init_subclass__(**kwargs) + BaseParallelBackend.BACKENDS[backend_name] = cls + + @classmethod + @abstractmethod + def executor( + cls, + max_workers: int | None = None, + config: ParallelConfig = ParallelConfig(), + **kwargs, + ) -> Executor: + ... @abstractmethod def get(self, v: Any, *args, **kwargs): @@ -110,12 +122,16 @@ def __init__(self, config: ParallelConfig): "n_jobs": config.n_cpus_local, } - def get( - self, - v: T, - *args, + @classmethod + def executor( + cls, + max_workers: int | None = None, + config: ParallelConfig = ParallelConfig(), **kwargs, - ) -> T: + ) -> Executor: + return cast(Executor, get_reusable_executor(max_workers=max_workers, **kwargs)) + + def get(self, v: T, *args, **kwargs) -> T: return v def put(self, v: T, *args, **kwargs) -> T: @@ -130,12 +146,7 @@ def wrap(self, fun: Callable, **kwargs) -> Callable: """ return delayed(fun) # type: ignore - def wait( - self, - v: List[T], - *args, - **kwargs, - ) -> Tuple[List[T], List[T]]: + def wait(self, v: List[T], *args, **kwargs) -> Tuple[List[T], List[T]]: return v, [] def _effective_n_jobs(self, n_jobs: int) -> int: @@ -166,11 +177,19 @@ def __init__(self, config: ParallelConfig): # Register ray joblib backend register_ray() - def get( - self, - v: Union[ObjectRef, Iterable[ObjectRef], T], - *args, + @classmethod + def executor( + cls, + max_workers: int | None = None, + config: ParallelConfig = ParallelConfig(), **kwargs, + ) -> Executor: + from pydvl.utils.parallel.futures import RayExecutor + + return RayExecutor(max_workers, config=config, **kwargs) # type: ignore + + def get( + self, v: Union[ObjectRef, Iterable[ObjectRef], T], *args, **kwargs ) -> Union[T, Any]: timeout: Optional[float] = kwargs.get("timeout", None) if isinstance(v, ObjectRef): @@ -199,10 +218,7 @@ def wrap(self, fun: Callable, **kwargs) -> Callable: return ray.remote(fun).remote # type: ignore def wait( - self, - v: List["ObjectRef"], - *args, - **kwargs, + self, v: List["ObjectRef"], *args, **kwargs ) -> Tuple[List[ObjectRef], List[ObjectRef]]: num_returns: int = kwargs.get("num_returns", 1) timeout: Optional[float] = kwargs.get("timeout", None) @@ -247,11 +263,10 @@ def init_parallel_backend( """ try: - parallel_backend_cls = _PARALLEL_BACKENDS[config.backend] + parallel_backend_cls = BaseParallelBackend.BACKENDS[config.backend] except KeyError: raise NotImplementedError(f"Unexpected parallel backend {config.backend}") - parallel_backend = parallel_backend_cls._create(config) - return parallel_backend # type: ignore + return parallel_backend_cls.create(config) # type: ignore def available_cpus() -> int: diff --git a/src/pydvl/utils/parallel/futures/__init__.py b/src/pydvl/utils/parallel/futures/__init__.py index a54953db2..d9ce59439 100644 --- a/src/pydvl/utils/parallel/futures/__init__.py +++ b/src/pydvl/utils/parallel/futures/__init__.py @@ -1,14 +1,16 @@ +import logging from concurrent.futures import Executor from contextlib import contextmanager from typing import Generator, Optional -from joblib.externals.loky import get_reusable_executor - from pydvl.utils.config import ParallelConfig +from pydvl.utils.parallel.backend import BaseParallelBackend from pydvl.utils.parallel.futures.ray import RayExecutor __all__ = ["init_executor"] +logger = logging.getLogger(__name__) + @contextmanager def init_executor( @@ -19,8 +21,11 @@ def init_executor( """Initializes a futures executor based on the passed parallel configuration object. :param max_workers: Maximum number of concurrent tasks. - :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with cluster address, number of cpus, etc. - :param kwargs: Other optional parameter that will be passed to the executor. + :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with + cluster address, number of cpus, etc. + :param kwargs: Optional parameters that will be passed to the executor, + e.g. ``cancel_futures`` for executors that support it, like + :class:`~pydvl.utils.parallel.futures.ray.RayExecutor`. :Example: @@ -46,11 +51,9 @@ def init_executor( [1, 2, 3, 4, 5] """ - if config.backend == "ray": - with RayExecutor(max_workers, config=config, **kwargs) as executor: - yield executor - elif config.backend == "joblib": - with get_reusable_executor(max_workers=max_workers, **kwargs) as executor: - yield executor - else: - raise NotImplementedError(f"Unexpected parallel type {config.backend}") + try: + cls = BaseParallelBackend.BACKENDS[config.backend] + with cls.executor(max_workers=max_workers, config=config, **kwargs) as e: + yield e + except KeyError: + raise NotImplementedError(f"Unexpected parallel backend {config.backend}") From f98cdaeefede78270abfc753afba550e1b5ac3a5 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 12 Aug 2023 20:05:53 +0200 Subject: [PATCH 233/436] Cleanup and additional variable in parallel config --- src/pydvl/utils/config.py | 1 + src/pydvl/value/shapley/montecarlo.py | 45 +++++++++++---------------- 2 files changed, 19 insertions(+), 27 deletions(-) diff --git a/src/pydvl/utils/config.py b/src/pydvl/utils/config.py index 36b9ab647..25c08c36d 100644 --- a/src/pydvl/utils/config.py +++ b/src/pydvl/utils/config.py @@ -25,6 +25,7 @@ class ParallelConfig: address: Optional[Union[str, Tuple[str, int]]] = None n_cpus_local: Optional[int] = None logging_level: int = logging.WARNING + wait_timeout: float = 5.0 def __post_init__(self) -> None: if self.address is not None and self.n_cpus_local is not None: diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index 5b33e38be..b07a03f5d 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -30,10 +30,12 @@ the algorithms mentioned above, including Group Testing, can work to valuate groups of samples as units. """ +from __future__ import annotations + import logging import math import operator -from concurrent.futures import FIRST_COMPLETED, wait +from concurrent.futures import FIRST_COMPLETED, Future, wait from functools import reduce from itertools import cycle, takewhile from typing import Sequence @@ -47,6 +49,7 @@ from pydvl.utils.config import ParallelConfig from pydvl.utils.numeric import random_powerset from pydvl.utils.parallel import MapReduceJob +from pydvl.utils.parallel.futures.ray import CancellationPolicy from pydvl.utils.utility import Utility from pydvl.value.result import ValuationResult from pydvl.value.shapley.truncated import NoTruncation, TruncationPolicy @@ -191,39 +194,28 @@ def permutation_montecarlo_shapley( parallel_backend = init_parallel_backend(config) u = parallel_backend.put(u) - # This represents the number of jobs that are running - n_jobs = effective_n_jobs(n_jobs, config) - # This determines the total number of submitted jobs - # including the ones that are running - n_submitted_jobs = 2 * n_jobs + max_workers = effective_n_jobs(n_jobs, config) + n_submitted_jobs = 2 * max_workers # number of jobs in the executor's queue accumulated_result = ValuationResult.zeros(algorithm=algorithm) - with init_executor(max_workers=n_jobs, config=config) as executor: - futures = set() - # Initial batch of computations - for _ in range(n_submitted_jobs): - future = executor.submit( - _permutation_montecarlo_one_step, - u, - truncation, - algorithm, - ) - futures.add(future) - while futures: - # Wait for the next futures to complete. + with init_executor( + max_workers=max_workers, config=config, cancel_futures=CancellationPolicy.ALL + ) as executor: + futures: set[Future] = set() + while True: completed_futures, futures = wait( - futures, timeout=60, return_when=FIRST_COMPLETED + futures, timeout=config.wait_timeout, return_when=FIRST_COMPLETED ) + for future in completed_futures: accumulated_result += future.result() + # we could check outside the loop, but that means more + # submissions if the stopping criterion is unstable if done(accumulated_result): - break - if done(accumulated_result): - break - # Submit more computations - # The goal is to always have `n_jobs` - # computations running + return accumulated_result + + # Ensure that we always have n_submitted_jobs in the queue or running for _ in range(n_submitted_jobs - len(futures)): future = executor.submit( _permutation_montecarlo_one_step, @@ -232,7 +224,6 @@ def permutation_montecarlo_shapley( algorithm, ) futures.add(future) - return accumulated_result def _combinatorial_montecarlo_shapley( From 8508a44c482846d083d40c32c1142ba1613b925d Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 12 Aug 2023 20:06:08 +0200 Subject: [PATCH 234/436] Fix return type --- src/pydvl/value/shapley/truncated.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 5b0112102..9c2e89c1b 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -1,5 +1,6 @@ import abc import logging +from typing import cast import numpy as np from deprecate import deprecated @@ -197,6 +198,9 @@ def truncated_montecarlo_shapley( """ from pydvl.value.shapley.montecarlo import permutation_montecarlo_shapley - return permutation_montecarlo_shapley( - u, done=done, truncation=truncation, config=config, n_jobs=n_jobs - ) # type: ignore + return cast( + ValuationResult, + permutation_montecarlo_shapley( + u, done=done, truncation=truncation, config=config, n_jobs=n_jobs + ), + ) From 4f04a978fb5b1327d785283ce18f48395b5360ed Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 12 Aug 2023 20:06:39 +0200 Subject: [PATCH 235/436] Doc improvements --- docs/40-influence.rst | 2 +- docs/pydvl.bib | 40 +++++++++++++++++++++++++++++--------- src/pydvl/value/sampler.py | 18 ++++++++++++----- 3 files changed, 45 insertions(+), 15 deletions(-) diff --git a/docs/40-influence.rst b/docs/40-influence.rst index 91e25ffa3..72e8edc61 100644 --- a/docs/40-influence.rst +++ b/docs/40-influence.rst @@ -31,7 +31,7 @@ The Influence Function ----------------------- First introduced in the context of robust statistics in -:footcite:t:`hampel1974influence`, the IF was popularized in the context of +:footcite:t:`hampel_influence_1974`, the IF was popularized in the context of machine learning in :footcite:t:`koh_understanding_2017`. Following their formulation, consider an input space $\mathcal{X}$ (e.g. images) and an output space $\mathcal{Y}$ (e.g. labels). Let's take $z_i = (x_i, y_i)$, for $i \in diff --git a/docs/pydvl.bib b/docs/pydvl.bib index 1d2c6d210..b63198364 100644 --- a/docs/pydvl.bib +++ b/docs/pydvl.bib @@ -35,15 +35,37 @@ @inproceedings{ghorbani_data_2019 keywords = {notion} } -@article{hampel1974influence, - title={The influence curve and its role in robust estimation}, - author={Hampel, Frank R}, - journal={Journal of the american statistical association}, - volume={69}, - number={346}, - pages={383--393}, - year={1974}, - publisher={Taylor \& Francis} +@article{hampel_influence_1974, + title = {The {{Influence Curve}} and {{Its Role}} in {{Robust Estimation}}}, + author = {Hampel, Frank R.}, + year = {1974}, + journal = {Journal of the American Statistical Association}, + volume = {69}, + number = {346}, + eprint = {2285666}, + eprinttype = {jstor}, + pages = {383--393}, + publisher = {{[American Statistical Association, Taylor \& Francis, Ltd.]}}, + issn = {0162-1459}, + url = {https://www.jstor.org/stable/2285666}, + urldate = {2022-05-09}, + abstract = {This paper treats essentially the first derivative of an estimator viewed as functional and the ways in which it can be used to study local robustness properties. A theory of robust estimation "near" strict parametric models is briefly sketched and applied to some classical situations. Relations between von Mises functionals, the jackknife and U-statistics are indicated. A number of classical and new estimators are discussed, including trimmed and Winsorized means, Huber-estimators, and more generally maximum likelihood and M-estimators. Finally, a table with some numerical robustness properties is given.} +} + +@misc{hataya_nystrom_2023, + title = {Nystrom {{Method}} for {{Accurate}} and {{Scalable Implicit Differentiation}}}, + author = {Hataya, Ryuichiro and Yamada, Makoto}, + year = {2023}, + month = feb, + number = {arXiv:2302.09726}, + eprint = {2302.09726}, + primaryclass = {cs}, + publisher = {{arXiv}}, + url = {http://arxiv.org/abs/2302.09726}, + urldate = {2023-05-01}, + abstract = {The essential difficulty of gradient-based bilevel optimization using implicit differentiation is to estimate the inverse Hessian vector product with respect to neural network parameters. This paper proposes to tackle this problem by the Nystrom method and the Woodbury matrix identity, exploiting the low-rankness of the Hessian. Compared to existing methods using iterative approximation, such as conjugate gradient and the Neumann series approximation, the proposed method avoids numerical instability and can be efficiently computed in matrix operations without iterations. As a result, the proposed method works stably in various tasks and is faster than iterative approximations. Throughout experiments including large-scale hyperparameter optimization and meta learning, we demonstrate that the Nystrom method consistently achieves comparable or even superior performance to other approaches. The source code is available from https://github.com/moskomule/hypergrad.}, + archiveprefix = {arxiv}, + keywords = {notion} } @inproceedings{jia_efficient_2019, diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 86c29ec3d..04e805c54 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -58,9 +58,9 @@ class PowersetSampler(abc.ABC, Iterable[SampleType], Generic[T]): """Samplers iterate over subsets of indices. - This is done in nested loops, where the outer loop iterates over the set of - indices, and the inner loop iterates over subsets of the complement of the - current index. The outer iteration can be either sequential or at random. + This is done in two nested loops, where the outer loop iterates over the set + of indices, and the inner loop iterates over subsets of the complement of + the current index. The outer iteration can be either sequential or at random. :Example: @@ -245,8 +245,16 @@ def weight(self, subset: NDArray[T]) -> float: class PermutationSampler(PowersetSampler[T]): - """Sample permutations of indices and iterate through each returning sets, - as required for the permutation definition of semi-values. + """Sample permutations of indices and iterate through each returning + increasing subsets, as required for the permutation definition of + semi-values. + + This sampler does not implement the two loops described in + :class:`~pydvl.value.sampler.PowersetSampler`. Instead, for a permutation + ``(3,1,4,2)``, it returns in sequence the tuples of index and sets: + ``(3, {})``, ``(1, {3})``, ``(4, {3,1})`` and ``(2, {3,1,4})``. + + Note that the full set is never returned. .. warning:: This sampler requires caching to be enabled or computation From 8b8450a375b3b79f0e4d6bd65c777635dc7d429c Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 12 Aug 2023 20:09:16 +0200 Subject: [PATCH 236/436] Test future cancellation for ray --- tests/utils/test_parallel.py | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/tests/utils/test_parallel.py b/tests/utils/test_parallel.py index af3ddf99d..3efde364b 100644 --- a/tests/utils/test_parallel.py +++ b/tests/utils/test_parallel.py @@ -200,3 +200,32 @@ def func(_): total_time = end_time - start_time # We expect the time difference to be > 3 / num_workers, but has to be at least 1 assert total_time > max(1.0, 3 / num_workers) + + +def test_future_cancellation(parallel_config): + if parallel_config.backend != "ray": + pytest.skip("Currently this test only works with Ray") + + from pydvl.utils.parallel.futures.ray import CancellationPolicy + + with init_executor( + config=parallel_config, cancel_futures=CancellationPolicy.NONE + ) as executor: + future = executor.submit(lambda x: x + 1, 1) + + assert future.result() == 2 + + from ray.exceptions import TaskCancelledError + + with init_executor( + config=parallel_config, cancel_futures=CancellationPolicy.ALL + ) as executor: + start = time.monotonic() + future = executor.submit(lambda t: time.sleep(t), 5) + + assert future._state == "FINISHED" + + with pytest.raises(TaskCancelledError): + future.result() + + assert time.monotonic() - start < 1 From ebc9ed2c72adf6e83f19c5d314b0479b2b60a092 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 12 Aug 2023 20:09:56 +0200 Subject: [PATCH 237/436] Hacky stopgap for parallel semivalue computation with permutation samplers --- src/pydvl/value/semivalues.py | 77 ++++++++++++++++++++++++++++------- 1 file changed, 63 insertions(+), 14 deletions(-) diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 6dfb94116..d0ac6c4b6 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -42,18 +42,19 @@ Instead, we subsume this factor into the coefficient $w(k)$. """ +from __future__ import annotations import math -import operator +from concurrent.futures import Future from enum import Enum -from functools import reduce +from functools import partial from itertools import takewhile -from typing import Protocol, Type, cast +from typing import Any, Iterator, Protocol, Type, cast import scipy as sp from tqdm import tqdm -from pydvl.utils import MapReduceJob, ParallelConfig, Utility +from pydvl.utils import ParallelConfig, Utility from pydvl.value import ValuationResult from pydvl.value.sampler import PermutationSampler, PowersetSampler from pydvl.value.stopping import MaxUpdates, StoppingCriterion @@ -63,6 +64,7 @@ "beta_coefficient", "shapley_coefficient", "semivalues", + "compute_semivalues", "SemiValueMode", ] @@ -89,6 +91,7 @@ def _semivalues( *, progress: bool = False, job_id: int = 1, + interrupt_flag: Any = None, # TO DO ) -> ValuationResult: r"""Serial computation of semi-values. This is a helper function for :func:`semivalues`. @@ -99,6 +102,7 @@ def _semivalues( :param done: Stopping criterion. :param progress: Whether to display progress bars for each job. :param job_id: id to use for reporting progress. + :param interrupt_flag: Flag to check for interrupt. :return: Object with the results. """ n = len(u.data.indices) @@ -131,8 +135,7 @@ def semivalues( config: ParallelConfig = ParallelConfig(), progress: bool = False, ) -> ValuationResult: - """ - Computes semi-values for a given utility function and subset sampler. + """Computes semi-values for a given utility function and subset sampler. :param sampler: The subset sampler to use for utility computations. :param u: Utility object with model, data, and scoring function. @@ -145,15 +148,61 @@ def semivalues( :return: Object with the results. """ - map_reduce_job: MapReduceJob[PowersetSampler, ValuationResult] = MapReduceJob( - sampler, - map_func=_semivalues, - reduce_func=lambda results: reduce(operator.add, results), - map_kwargs=dict(u=u, coefficient=coefficient, done=done, progress=progress), - config=config, - n_jobs=n_jobs, + from concurrent.futures import FIRST_COMPLETED, wait + + from pydvl.utils import effective_n_jobs, init_executor, init_parallel_backend + + parallel_backend = init_parallel_backend(config) + u = parallel_backend.put(u) + coefficient = parallel_backend.put(coefficient) + + max_workers = effective_n_jobs(n_jobs, config) + n_submitted_jobs = 2 * max_workers # number of jobs in the queue + + accumulated_result = ValuationResult.zeros( + algorithm=f"semivalue-{str(sampler)}-{coefficient.__name__}" ) - return map_reduce_job() + + if isinstance(sampler, PermutationSampler): + # TODO: add attribute to allow configuration of multiple updates per job + # (e.g. permutations) + updates_per_job = getattr(sampler, "max_samples_parallel", 1) + + with init_executor( + max_workers=max_workers, config=config, cancel_futures=True + ) as executor: + futures: set[Future] = set() + while True: + completed_futures, futures = wait( + futures, timeout=60, return_when=FIRST_COMPLETED + ) + for future in completed_futures: + accumulated_result += future.result() + if done(accumulated_result): + return accumulated_result + + # Ensure that we always have n_submitted_jobs running + for _ in range(n_submitted_jobs - len(futures)): + future = executor.submit( + _semivalues, + sampler=sampler[:], + u=u, + coefficient=coefficient, + done=MaxUpdates(updates_per_job), + ) + futures.add(future) + else: + with init_executor( + max_workers=max_workers, config=config, cancel_futures=False + ) as executor: + results: Iterator[ValuationResult] = executor.map( + partial(_semivalues, u=u, coefficient=coefficient, done=done), + sampler, + chunksize=sampler.n_samples // max_workers, + ) + for r in results: + accumulated_result += r + return accumulated_result def shapley_coefficient(n: int, k: int) -> float: From 73c8d76b35438c9cd8f67faf920b6bc8ba2351d5 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 12 Aug 2023 22:57:39 +0200 Subject: [PATCH 238/436] Some cleanup --- src/pydvl/utils/config.py | 1 + src/pydvl/utils/parallel/backend.py | 86 +++++++++-------------------- src/pydvl/utils/types.py | 30 +++++++++- 3 files changed, 57 insertions(+), 60 deletions(-) diff --git a/src/pydvl/utils/config.py b/src/pydvl/utils/config.py index 25c08c36d..0e93c087a 100644 --- a/src/pydvl/utils/config.py +++ b/src/pydvl/utils/config.py @@ -28,6 +28,7 @@ class ParallelConfig: wait_timeout: float = 5.0 def __post_init__(self) -> None: + # FIXME: this is specific to ray if self.address is not None and self.n_cpus_local is not None: raise ValueError("When `address` is set, `n_cpus_local` should be None.") diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index d4a93e77b..ab0e895aa 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -1,21 +1,10 @@ from __future__ import annotations +import logging import os -from abc import ABCMeta, abstractmethod +from abc import abstractmethod from concurrent.futures import Executor -from typing import ( - Any, - Callable, - Dict, - Iterable, - List, - Optional, - Tuple, - Type, - TypeVar, - Union, - cast, -) +from typing import Any, Callable, Iterable, Type, TypeVar, cast import joblib import ray @@ -25,42 +14,22 @@ from ray.util.joblib import register_ray from ..config import ParallelConfig +from ..types import NoPublicConstructor +from .futures.ray import CancellationPolicy __all__ = ["init_parallel_backend", "effective_n_jobs", "available_cpus"] -T = TypeVar("T") - - -class NoPublicConstructor(ABCMeta): - """Metaclass that ensures a private constructor - - If a class uses this metaclass like this: - - class SomeClass(metaclass=NoPublicConstructor): - pass - If you try to instantiate your class (`SomeClass()`), - a `TypeError` will be thrown. - - Taken almost verbatim from: - https://stackoverflow.com/a/64682734 - """ - - def __call__(cls, *args, **kwargs): - raise TypeError( - f"{cls.__module__}.{cls.__qualname__} cannot be initialized directly. " - "Use the proper factory instead." - ) +T = TypeVar("T") - def create(cls, *args: Any, **kwargs: Any): - return super().__call__(*args, **kwargs) +log = logging.getLogger(__name__) class BaseParallelBackend(metaclass=NoPublicConstructor): - """Abstract base class for all parallel backends""" + """Abstract base class for all parallel backends.""" - config: Dict[str, Any] = {} - BACKENDS: Dict[str, "Type[BaseParallelBackend]"] = {} + config: dict[str, Any] = {} + BACKENDS: dict[str, "Type[BaseParallelBackend]"] = {} def __init_subclass__(cls, *, backend_name: str, **kwargs): super().__init_subclass__(**kwargs) @@ -72,8 +41,9 @@ def executor( cls, max_workers: int | None = None, config: ParallelConfig = ParallelConfig(), - **kwargs, + cancel_futures: CancellationPolicy = CancellationPolicy.PENDING, ) -> Executor: + """Returns an executor for the parallel backend.""" ... @abstractmethod @@ -127,9 +97,11 @@ def executor( cls, max_workers: int | None = None, config: ParallelConfig = ParallelConfig(), - **kwargs, + cancel_futures: CancellationPolicy = CancellationPolicy.NONE, ) -> Executor: - return cast(Executor, get_reusable_executor(max_workers=max_workers, **kwargs)) + if cancel_futures is not CancellationPolicy.NONE: + log.warning("CancellationPolicy is not supported by the joblib backend") + return cast(Executor, get_reusable_executor(max_workers=max_workers)) def get(self, v: T, *args, **kwargs) -> T: return v @@ -146,7 +118,7 @@ def wrap(self, fun: Callable, **kwargs) -> Callable: """ return delayed(fun) # type: ignore - def wait(self, v: List[T], *args, **kwargs) -> Tuple[List[T], List[T]]: + def wait(self, v: list[T], *args, **kwargs) -> tuple[list[T], list[T]]: return v, [] def _effective_n_jobs(self, n_jobs: int) -> int: @@ -182,16 +154,14 @@ def executor( cls, max_workers: int | None = None, config: ParallelConfig = ParallelConfig(), - **kwargs, + cancel_futures: CancellationPolicy = CancellationPolicy.PENDING, ) -> Executor: - from pydvl.utils.parallel.futures import RayExecutor + from pydvl.utils.parallel.futures.ray import RayExecutor - return RayExecutor(max_workers, config=config, **kwargs) # type: ignore + return RayExecutor(max_workers, config=config, cancel_futures=cancel_futures) # type: ignore - def get( - self, v: Union[ObjectRef, Iterable[ObjectRef], T], *args, **kwargs - ) -> Union[T, Any]: - timeout: Optional[float] = kwargs.get("timeout", None) + def get(self, v: ObjectRef | Iterable[ObjectRef] | T, *args, **kwargs) -> T | Any: + timeout: float | None = kwargs.get("timeout", None) if isinstance(v, ObjectRef): return ray.get(v, timeout=timeout) elif isinstance(v, Iterable): @@ -199,7 +169,7 @@ def get( else: return v - def put(self, v: T, *args, **kwargs) -> Union["ObjectRef[T]", T]: + def put(self, v: T, *args, **kwargs) -> "ObjectRef[T]" | T: try: return ray.put(v, **kwargs) # type: ignore except TypeError: @@ -218,10 +188,10 @@ def wrap(self, fun: Callable, **kwargs) -> Callable: return ray.remote(fun).remote # type: ignore def wait( - self, v: List["ObjectRef"], *args, **kwargs - ) -> Tuple[List[ObjectRef], List[ObjectRef]]: + self, v: list[ObjectRef], *args, **kwargs + ) -> tuple[list[ObjectRef], list[ObjectRef]]: num_returns: int = kwargs.get("num_returns", 1) - timeout: Optional[float] = kwargs.get("timeout", None) + timeout: float | None = kwargs.get("timeout", None) return ray.wait( # type: ignore v, num_returns=num_returns, @@ -237,9 +207,7 @@ def _effective_n_jobs(self, n_jobs: int) -> int: return eff_n_jobs -def init_parallel_backend( - config: ParallelConfig, -) -> BaseParallelBackend: +def init_parallel_backend(config: ParallelConfig) -> BaseParallelBackend: """Initializes the parallel backend and returns an instance of it. :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index 2184ab47a..9c51d629e 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -1,12 +1,15 @@ """ This module contains types, protocols, decorators and generic function transformations. Some of it probably belongs elsewhere. """ +from __future__ import annotations + import inspect +from abc import ABCMeta from typing import Any, Callable, Protocol, TypeVar from numpy.typing import NDArray -__all__ = ["SupervisedModel", "MapFunction", "ReduceFunction"] +__all__ = ["SupervisedModel", "MapFunction", "ReduceFunction", "NoPublicConstructor"] R = TypeVar("R", covariant=True) @@ -64,3 +67,28 @@ def wrapper(*args, **kwargs): return fun(*args, **kwargs) return wrapper + + +class NoPublicConstructor(ABCMeta): + """Metaclass that ensures a private constructor + + If a class uses this metaclass like this: + + class SomeClass(metaclass=NoPublicConstructor): + pass + + If you try to instantiate your class (`SomeClass()`), + a `TypeError` will be thrown. + + Taken almost verbatim from: + https://stackoverflow.com/a/64682734 + """ + + def __call__(cls, *args, **kwargs): + raise TypeError( + f"{cls.__module__}.{cls.__qualname__} cannot be initialized directly. " + "Use the proper factory instead." + ) + + def create(cls, *args: Any, **kwargs: Any): + return super().__call__(*args, **kwargs) From cad5495a1cacc01f22122e652549457dab779eb4 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 13 Aug 2023 14:26:20 +0200 Subject: [PATCH 239/436] Fix sampler semantics for repeated slicing --- src/pydvl/value/sampler.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 04e805c54..23025edf3 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -150,7 +150,7 @@ def __getitem__(self, key: slice | list[int]) -> "PowersetSampler[T]": return self.__class__( self._indices, index_iteration=self._index_iteration, - outer_indices=self._indices[key], + outer_indices=self._outer_indices[key], ) raise TypeError("Indices must be an iterable or a slice") @@ -162,7 +162,7 @@ def __str__(self): return f"{self.__class__.__name__}" def __repr__(self): - return f"{self.__class__.__name__}({self._indices})" + return f"{self.__class__.__name__}({self._indices}, {self._outer_indices})" @abc.abstractmethod def __iter__(self) -> Iterator[SampleType]: From 89aaab908965bf4bd180c78f029a385969e50cea Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Mon, 14 Aug 2023 10:59:27 +0200 Subject: [PATCH 240/436] Better sampler docs --- src/pydvl/value/sampler.py | 94 +++++++++++++++++++++++++++++++------- 1 file changed, 77 insertions(+), 17 deletions(-) diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 23025edf3..488fa38b5 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -1,12 +1,15 @@ """ Samplers iterate over subsets of indices. -The classes in this module are used to iterate over indices and subsets of their -complement in the whole set, as required for the computation of marginal utility -for semi-values. The elements returned when iterating over any subclass of -:class:`PowersetSampler` are tuples of the form ``(idx, subset)``, where ``idx`` -is the index of the element being added to the subset, and ``subset`` is the -subset of the complement of ``idx``. +The classes in this module are used to iterate over an index set $I$ as required +for the computation of marginal utility for semi-values. The elements returned +when iterating over any subclass of :class:`PowersetSampler` are tuples of the +form $(i, S)$, where $i$ is an index of interest, and $S \subset I \setminus \{i\}$ +is a subset of the complement of $i$. + +The iteration happens in two nested loops. An outer loop iterates over $I$, and +an inner loop iterates over the powerset of $I \setminus \{i\}$. The outer +iteration can be either sequential or at random. .. note:: This is the natural mode of iteration for the combinatorial definition of @@ -56,17 +59,30 @@ class PowersetSampler(abc.ABC, Iterable[SampleType], Generic[T]): - """Samplers iterate over subsets of indices. + """Samplers are custom iterables over subsets of indices. + + Calling ``iter()`` on a sampler returns an iterator over tuples of the form + $(i, S)$, where $i$ is an index of interest, and $S \subset I \setminus \{i\}$ + is a subset of the complement of $i$. This is done in two nested loops, where the outer loop iterates over the set of indices, and the inner loop iterates over subsets of the complement of the current index. The outer iteration can be either sequential or at random. + .. note:: + Samplers are **not** iterators themselves, so that each call to ``iter()`` + e.g. in a for loop creates a new iterator. + :Example: - >>>for idx, s in DeterministicCombinatorialSampler([1,2]): - >>> print(s, end="") - ()(2,)()(1,) + .. code-block:: python + + for idx, s in DeterministicCombinatorialSampler(np.arange(2)): + print(s, end="") + + Produces the output:: + + [][2,][][1,] .. rubric:: Methods required in subclasses @@ -138,14 +154,14 @@ def iterindices(self) -> Iterator[T]: yield np.random.choice(self._outer_indices, size=1).item() @overload - def __getitem__(self, key: slice) -> "PowersetSampler[T]": + def __getitem__(self, key: slice) -> PowersetSampler[T]: ... @overload - def __getitem__(self, key: list[int]) -> "PowersetSampler[T]": + def __getitem__(self, key: list[int]) -> PowersetSampler[T]: ... - def __getitem__(self, key: slice | list[int]) -> "PowersetSampler[T]": + def __getitem__(self, key: slice | list[int]) -> PowersetSampler[T]: if isinstance(key, slice) or isinstance(key, Iterable): return self.__class__( self._indices, @@ -189,10 +205,25 @@ def weight(self, subset: NDArray[T]) -> float: class DeterministicCombinatorialSampler(PowersetSampler[T]): def __init__(self, indices: NDArray[T], *args, **kwargs): - """Uniform deterministic sampling of subsets. + """An iterator to perform uniform deterministic sampling of subsets. + + For every index $i$, each subset of the complement `indices - {i}` is + returned. + + .. note:: + Indices are always iterated over sequentially, irrespective of + the value of ``index_iteration`` upon construction. + + :Example: + + .. code-block:: python + + for idx, s in DeterministicCombinatorialSampler(np.arange(2)): + print(f"{idx} - {s}", end=", ") + + Produces the output:: - For every index $i$, each subset of `indices - {i}` has equal - probability $2^{n-1}$. + 1 - [], 1 - [2], 2 - [], 2 - [1], :param indices: The set of items (indices) to sample from. """ @@ -211,6 +242,27 @@ def weight(self, subset: NDArray[T]) -> float: class UniformSampler(PowersetSampler[T]): + """An iterator to perform uniform random sampling of subsets. + + Iterating over every index $i$, either in sequence or at random depending on + the value of ``index_iteration``, one subset of the complement + ``indices - {i}`` is sampled with equal probability $2^{n-1}$. The + iterator never ends. + + :Example: + + .. code-block:: python + + for idx, s in UniformSampler(np.arange(3)): + print(f"{idx} - {s}", end=", ") + + Produces the output:: + + 0 - [1 4], 1 - [2 3], 2 - [0 1 3], 3 - [], 4 - [2], 0 - [1 3 4], 1 - [0 2] + (...) + + """ + def __iter__(self) -> Iterator[SampleType]: while True: for idx in self.iterindices(): @@ -229,6 +281,14 @@ def weight(self, subset: NDArray[T]) -> float: class AntitheticSampler(PowersetSampler[T]): + """An iterator to perform uniform random sampling of subsets, and their + complements. + + Works as :class:`~pydvl.value.sampler.UniformSampler`, but for every tuple + $(i,S)$, it subsequently returns $(i,S^c)$, where $S^c$ is the complement of + the set $S$, including the index $i$ itself. + """ + def __iter__(self) -> Iterator[SampleType]: while True: for idx in self.iterindices(): @@ -254,7 +314,7 @@ class PermutationSampler(PowersetSampler[T]): ``(3,1,4,2)``, it returns in sequence the tuples of index and sets: ``(3, {})``, ``(1, {3})``, ``(4, {3,1})`` and ``(2, {3,1,4})``. - Note that the full set is never returned. + Note that the full index set is never returned. .. warning:: This sampler requires caching to be enabled or computation From 3965e32e4714d6fdf821c64612e79aef779fa37a Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Mon, 14 Aug 2023 10:59:41 +0200 Subject: [PATCH 241/436] Bugfix --- 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 d0ac6c4b6..89868fc33 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -198,7 +198,7 @@ def semivalues( results: Iterator[ValuationResult] = executor.map( partial(_semivalues, u=u, coefficient=coefficient, done=done), sampler, - chunksize=sampler.n_samples // max_workers, + chunksize=max(1, sampler.n_samples // max_workers), ) for r in results: accumulated_result += r From c14575e2e2dd66b862fe2d73ab800e005234f428 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Mon, 14 Aug 2023 11:00:39 +0200 Subject: [PATCH 242/436] [skip ci] Refactor CancellationPolicy --- src/pydvl/utils/parallel/backend.py | 25 +++++++++++++++++++++++-- src/pydvl/utils/parallel/futures/ray.py | 23 +++-------------------- 2 files changed, 26 insertions(+), 22 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index ab0e895aa..961adc621 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -4,6 +4,7 @@ import os from abc import abstractmethod from concurrent.futures import Executor +from enum import Enum from typing import Any, Callable, Iterable, Type, TypeVar, cast import joblib @@ -15,7 +16,6 @@ from ..config import ParallelConfig from ..types import NoPublicConstructor -from .futures.ray import CancellationPolicy __all__ = ["init_parallel_backend", "effective_n_jobs", "available_cpus"] @@ -25,6 +25,27 @@ log = logging.getLogger(__name__) +class CancellationPolicy(Enum): + """Policy to use when cancelling futures after exiting an Executor. + + .. note: + Not all backends support all policies. + + :cvar NONE: Do not cancel any futures. + :cvar PENDING: Cancel all pending futures, but not running ones. + :cvar RUNNING: Cancel all running futures, but not pending ones. + :cvar ALL: Cancel all pending and running futures. + """ + + NONE = 0 + PENDING = 1 + RUNNING = 2 + ALL = 3 + + def __and__(self, other: CancellationPolicy) -> bool: + return int(self.value) & int(other.value) > 0 + + class BaseParallelBackend(metaclass=NoPublicConstructor): """Abstract base class for all parallel backends.""" @@ -169,7 +190,7 @@ def get(self, v: ObjectRef | Iterable[ObjectRef] | T, *args, **kwargs) -> T | An else: return v - def put(self, v: T, *args, **kwargs) -> "ObjectRef[T]" | T: + def put(self, v: T, *args, **kwargs) -> ObjectRef[T] | T: try: return ray.put(v, **kwargs) # type: ignore except TypeError: diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index deee0c519..c90837543 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -6,7 +6,6 @@ import types from concurrent.futures import Executor, Future from dataclasses import asdict -from enum import Enum from typing import Any, Callable, Optional, TypeVar from weakref import WeakSet, ref @@ -15,31 +14,15 @@ from pydvl.utils import ParallelConfig -__all__ = ["CancellationPolicy", "RayExecutor"] +__all__ = ["RayExecutor"] + +from pydvl.utils.parallel.backend import CancellationPolicy T = TypeVar("T") logger = logging.getLogger(__name__) -class CancellationPolicy(Enum): - """Policy to use when cancelling futures after exiting an Executor. - - :cvar NONE: Do not cancel any futures. - :cvar PENDING: Cancel all pending futures, but not running ones. - :cvar RUNNING: Cancel all running futures, but not pending ones. - :cvar ALL: Cancel all pending and running futures. - """ - - NONE = 0 - PENDING = 1 - RUNNING = 2 - ALL = 3 - - def __and__(self, other: "CancellationPolicy") -> bool: - return int(self.value) & int(other.value) > 0 - - class RayExecutor(Executor): """Asynchronous executor using Ray that implements the concurrent.futures API. From 603065e2ab52ad3435be3d2525b93d7a6f242d8d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 17 Aug 2023 13:43:55 +0200 Subject: [PATCH 243/436] Move module twice_differentiable to top level of influence package --- .../influence/frameworks/torch_differentiable.py | 6 +++++- src/pydvl/influence/general.py | 6 +----- src/pydvl/influence/inversion.py | 16 +++++++++------- .../{frameworks => }/twice_differentiable.py | 0 4 files changed, 15 insertions(+), 13 deletions(-) rename src/pydvl/influence/{frameworks => }/twice_differentiable.py (100%) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index bdb1b1028..95142bc1e 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -19,8 +19,12 @@ from ...utils import maybe_progress from ..inversion import InversionMethod, InversionRegistry +from ..twice_differentiable import ( + InverseHvpResult, + TensorUtilities, + TwiceDifferentiable, +) from .functional import get_hvp_function -from .twice_differentiable import InverseHvpResult, TensorUtilities, TwiceDifferentiable from .util import align_structure, as_tensor, flatten_tensors_to_vector __all__ = [ diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index fecc330f7..558bfb855 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -7,12 +7,8 @@ from typing import Any, Callable, Dict, Optional, Type from ..utils import maybe_progress -from .frameworks.twice_differentiable import ( - TensorType, - TensorUtilities, - TwiceDifferentiable, -) from .inversion import DataLoaderType, InverseHvpResult, InversionMethod, solve_hvp +from .twice_differentiable import TensorType, TensorUtilities, TwiceDifferentiable __all__ = ["compute_influences", "InfluenceType", "compute_influence_factors"] diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 802b275dc..9ac928944 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -7,13 +7,15 @@ from enum import Enum from typing import Any, Callable, Dict, Iterable, Tuple, Type, TypeVar -__all__ = ["solve_hvp", "InversionMethod", "InversionRegistry"] - -from .frameworks.twice_differentiable import ( - InverseHvpResult, - TensorType, - TwiceDifferentiable, -) +__all__ = [ + "solve_hvp", + "InversionMethod", + "InversionRegistry", + "DataLoaderType", + "InverseHvpResult", +] + +from .twice_differentiable import InverseHvpResult, TensorType, TwiceDifferentiable logger = logging.getLogger(__name__) diff --git a/src/pydvl/influence/frameworks/twice_differentiable.py b/src/pydvl/influence/twice_differentiable.py similarity index 100% rename from src/pydvl/influence/frameworks/twice_differentiable.py rename to src/pydvl/influence/twice_differentiable.py From 2b057f6f1828ff294017de610ea2a90d66885610 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 17 Aug 2023 14:06:45 +0200 Subject: [PATCH 244/436] Rename framework subpackage to torch --- notebooks/support/torch.py | 2 +- .../influence/{frameworks => torch}/__init__.py | 1 + .../influence/{frameworks => torch}/functional.py | 0 .../{frameworks => torch}/torch_differentiable.py | 1 + src/pydvl/influence/{frameworks => torch}/util.py | 0 tests/influence/test_influences.py | 2 +- tests/influence/test_torch_differentiable.py | 2 +- tests/influence/test_util.py | 12 +++--------- 8 files changed, 8 insertions(+), 12 deletions(-) rename src/pydvl/influence/{frameworks => torch}/__init__.py (90%) rename src/pydvl/influence/{frameworks => torch}/functional.py (100%) rename src/pydvl/influence/{frameworks => torch}/torch_differentiable.py (99%) rename src/pydvl/influence/{frameworks => torch}/util.py (100%) diff --git a/notebooks/support/torch.py b/notebooks/support/torch.py index b9779c5b0..68faad12f 100644 --- a/notebooks/support/torch.py +++ b/notebooks/support/torch.py @@ -13,7 +13,7 @@ from torch.utils.data import DataLoader from torchvision.models import ResNet18_Weights, resnet18 -from pydvl.influence.frameworks import as_tensor +from pydvl.influence.torch import as_tensor from pydvl.utils import maybe_progress from .types import Losses diff --git a/src/pydvl/influence/frameworks/__init__.py b/src/pydvl/influence/torch/__init__.py similarity index 90% rename from src/pydvl/influence/frameworks/__init__.py rename to src/pydvl/influence/torch/__init__.py index d041e5930..40e3dfc24 100644 --- a/src/pydvl/influence/frameworks/__init__.py +++ b/src/pydvl/influence/torch/__init__.py @@ -1,5 +1,6 @@ from .torch_differentiable import ( TorchTwiceDifferentiable, + as_tensor, solve_arnoldi, solve_batch_cg, solve_linear, diff --git a/src/pydvl/influence/frameworks/functional.py b/src/pydvl/influence/torch/functional.py similarity index 100% rename from src/pydvl/influence/frameworks/functional.py rename to src/pydvl/influence/torch/functional.py diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/torch/torch_differentiable.py similarity index 99% rename from src/pydvl/influence/frameworks/torch_differentiable.py rename to src/pydvl/influence/torch/torch_differentiable.py index 95142bc1e..e487469b7 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/torch/torch_differentiable.py @@ -34,6 +34,7 @@ "solve_lissa", "solve_arnoldi", "lanzcos_low_rank_hessian_approx", + "as_tensor", ] logger = logging.getLogger(__name__) diff --git a/src/pydvl/influence/frameworks/util.py b/src/pydvl/influence/torch/util.py similarity index 100% rename from src/pydvl/influence/frameworks/util.py rename to src/pydvl/influence/torch/util.py diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index a45d685b5..76bf1c72b 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -13,7 +13,7 @@ from torch.utils.data import DataLoader, TensorDataset from pydvl.influence import InfluenceType, InversionMethod, compute_influences -from pydvl.influence.frameworks import TorchTwiceDifferentiable +from pydvl.influence.torch import TorchTwiceDifferentiable from .conftest import ( add_noise_to_linear_model, diff --git a/tests/influence/test_torch_differentiable.py b/tests/influence/test_torch_differentiable.py index 7ddf70f44..621288d6f 100644 --- a/tests/influence/test_torch_differentiable.py +++ b/tests/influence/test_torch_differentiable.py @@ -23,7 +23,7 @@ from torch import nn from torch.utils.data import DataLoader -from pydvl.influence.frameworks import ( +from pydvl.influence.torch import ( TorchTwiceDifferentiable, solve_batch_cg, solve_linear, diff --git a/tests/influence/test_util.py b/tests/influence/test_util.py index 7828c470a..6baebd8f2 100644 --- a/tests/influence/test_util.py +++ b/tests/influence/test_util.py @@ -9,15 +9,9 @@ from torch.nn.functional import mse_loss from torch.utils.data import DataLoader, TensorDataset -from pydvl.influence.frameworks.functional import ( - batch_loss_function, - get_hvp_function, - hvp, -) -from pydvl.influence.frameworks.torch_differentiable import ( - lanzcos_low_rank_hessian_approx, -) -from pydvl.influence.frameworks.util import ( +from pydvl.influence.torch.functional import batch_loss_function, get_hvp_function, hvp +from pydvl.influence.torch.torch_differentiable import lanzcos_low_rank_hessian_approx +from pydvl.influence.torch.util import ( TorchTensorContainerType, align_structure, flatten_tensors_to_vector, From 1c374624020362599335a4691d7b2458ade92aa6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 17 Aug 2023 17:38:33 +0200 Subject: [PATCH 245/436] Remove obsolete function --- src/pydvl/influence/torch/util.py | 23 ----------------------- 1 file changed, 23 deletions(-) diff --git a/src/pydvl/influence/torch/util.py b/src/pydvl/influence/torch/util.py index b2e2987cb..b758458a3 100644 --- a/src/pydvl/influence/torch/util.py +++ b/src/pydvl/influence/torch/util.py @@ -144,29 +144,6 @@ def align_structure( return tangent_dict -def hessian_from_dict(hessian_dict): - param_names = list(hessian_dict.keys()) - - hessian_rows = [] - - for row_name in param_names: - row = [] - - for col_name in param_names: - block = hessian_dict[row_name][col_name] - - # Flatten the block and add it to the row - row.append(block.contiguous().view(-1)) - - # Concatenate the row blocks and add them to the Hessian - hessian_rows.append(torch.cat(row)) - - # Concatenate all rows to form the Hessian - hessian = torch.stack(hessian_rows) - - return hessian - - def as_tensor(a: Any, warn=True, **kwargs) -> torch.Tensor: """Converts an array into a torch tensor From de8c633944e2341eb5bbf8f3a066eea91daceffb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 17 Aug 2023 19:07:47 +0200 Subject: [PATCH 246/436] Simplify hessian vector product interface (no need to provide dict aligned with model named parameters), improve documentation --- src/pydvl/influence/general.py | 3 +- src/pydvl/influence/torch/functional.py | 56 +++++++++++-------- .../influence/torch/torch_differentiable.py | 16 ++---- tests/influence/test_util.py | 25 ++++----- 4 files changed, 50 insertions(+), 50 deletions(-) diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 558bfb855..58b8552ee 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -48,8 +48,7 @@ def compute_influence_factors( :param model: A model wrapped in the TwiceDifferentiable interface. :param training_data: A DataLoader containing the training data. :param test_data: A DataLoader containing the test data. - :param inversion_func: function to use to invert the product of hvp (hessian - vector product) and the gradient of the loss (s_test in the paper). + :param inversion_method: name of method for computing inverse hessian vector products :param hessian_perturbation: regularization of the hessian :param progress: If True, display progress bars. :returns: An array of size (N, D) containing the influence factors for each diff --git a/src/pydvl/influence/torch/functional.py b/src/pydvl/influence/torch/functional.py index 4951ac224..f8643485f 100644 --- a/src/pydvl/influence/torch/functional.py +++ b/src/pydvl/influence/torch/functional.py @@ -1,11 +1,15 @@ -from functools import partial from typing import Callable, Dict, Generator, Iterable import torch from torch.func import functional_call, grad, jvp, vjp from torch.utils.data import DataLoader -from .util import TorchTensorContainerType, align_structure, to_model_device +from .util import ( + TorchTensorContainerType, + align_structure, + flatten_tensors_to_vector, + to_model_device, +) __all__ = [ "get_hvp_function", @@ -13,7 +17,7 @@ def hvp( - func: Callable[[TorchTensorContainerType], TorchTensorContainerType], + func: Callable[[TorchTensorContainerType], torch.Tensor], params: TorchTensorContainerType, vec: TorchTensorContainerType, reverse_only: bool = True, @@ -24,7 +28,7 @@ def hvp( forward- and reverse-mode autodiff. - :param func: The function for which the HVP is computed. + :param func: The scalar-valued function for which the HVP is computed. :param params: The parameters at which the HVP is computed. :param vec: The vector with which the Hessian is multiplied. :param reverse_only: Whether to use only reverse-mode autodiff @@ -56,9 +60,7 @@ def batch_hvp_gen( loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], data_loader: DataLoader, reverse_only: bool = True, -) -> Generator[ - Callable[[Dict[str, torch.Tensor]], Dict[str, torch.Tensor]], None, None -]: +) -> Generator[Callable[[torch.Tensor], torch.Tensor], None, None]: """ Generates a sequence of batch Hessian-vector product (HVP) computations for the provided model, loss function, and data loader. @@ -75,14 +77,26 @@ def batch_hvp_gen( for inputs, targets in iter(data_loader): batch_loss = batch_loss_function(model, loss, inputs, targets) - yield partial(hvp, batch_loss, dict(model.named_parameters()), reverse_only=reverse_only) # type: ignore + + def batch_hvp(vec: torch.Tensor): + model_params = dict(model.named_parameters()) + return flatten_tensors_to_vector( + hvp( + batch_loss, + model_params, + align_structure(model_params, vec), + reverse_only=reverse_only, + ).values() + ) + + yield batch_hvp def empirical_loss_function( model: torch.nn.Module, loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], data_loader: DataLoader, -) -> Callable[[Dict[str, torch.Tensor]], Dict[str, torch.Tensor]]: +) -> Callable[[Dict[str, torch.Tensor]], torch.Tensor]: """ Creates a function to compute the empirical loss of a given model on a given dataset. If we denote the model parameters with $\theta$, the resulting function approximates @@ -151,7 +165,7 @@ def get_hvp_function( use_hessian_avg: bool = True, reverse_only: bool = True, track_gradients: bool = False, -) -> Callable[[Dict[str, torch.Tensor]], Dict[str, torch.Tensor]]: +) -> Callable[[torch.Tensor], torch.Tensor]: """ Returns a function that calculates the approximate Hessian-vector product for a given vector. If you want to compute the exact hessian, i.e. pulling all data into memory and compute a full gradient computation, use @@ -180,27 +194,25 @@ def get_hvp_function( k: p if track_gradients else p.detach() for k, p in model.named_parameters() } - def hvp_function(vec: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]: + def hvp_function(vec: torch.Tensor) -> torch.Tensor: v = align_structure(params, vec) empirical_loss = empirical_loss_function(model, loss, data_loader) - return hvp(empirical_loss, params, v, reverse_only=reverse_only) + return flatten_tensors_to_vector( + hvp(empirical_loss, params, v, reverse_only=reverse_only).values() + ) - def avg_hvp_function(vec: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]: + def avg_hvp_function(vec: torch.Tensor) -> torch.Tensor: v = align_structure(params, vec) - batch_hessians: Iterable[Dict[str, torch.Tensor]] = map( + batch_hessians_vector_products: Iterable[torch.Tensor] = map( lambda x: x(v), batch_hvp_gen(model, loss, data_loader, reverse_only) ) - result_dict = { - key: to_model_device(torch.zeros_like(p), model) - for key, p in params.items() - } num_batches = len(data_loader) + avg_hessian = to_model_device(torch.zeros_like(vec), model) - for batch_dict in batch_hessians: - for key, value in batch_dict.items(): - result_dict[key] += value + for batch_hvp in batch_hessians_vector_products: + avg_hessian += batch_hvp - return {key: value / num_batches for key, value in result_dict.items()} + return avg_hessian / float(num_batches) return avg_hvp_function if use_hessian_avg else hvp_function diff --git a/src/pydvl/influence/torch/torch_differentiable.py b/src/pydvl/influence/torch/torch_differentiable.py index e487469b7..332a6ee19 100644 --- a/src/pydvl/influence/torch/torch_differentiable.py +++ b/src/pydvl/influence/torch/torch_differentiable.py @@ -86,10 +86,8 @@ def grad( :param x: A matrix [NxD] representing the features $x_i$. :param y: A matrix [NxK] representing the target values $y_i$. - :param create_graph: - :returns: A tuple where the first element is an array [P] with the - gradients of the model and second element is the input to the model - as a grad parameters. This can be used for further differentiation. + :param create_graph: If True, the resulting gradient tensor, can be used for further differentiation + :returns: An array [P] with the gradients of the model. """ x = x.to(self.device) y = y.to(self.device) @@ -104,7 +102,7 @@ def hessian(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: """Calculates the explicit hessian of model parameters given data ($x$ and $y$). :param x: A matrix [NxD] representing the features $x_i$. :param y: A matrix [NxK] representing the target values $y_i$. - :returns: the hessian of the model, i.e. the second derivative wrt. the model parameters. + :returns: A tensor representing the hessian of the model, i.e. the second derivative wrt. the model parameters. """ def model_func(param): @@ -177,7 +175,6 @@ class LowRankProductRepresentation: """ eigen_vals: torch.Tensor - projections: torch.Tensor @@ -601,14 +598,9 @@ def solve_arnoldi( raw_hvp = get_hvp_function( model.model, model.loss, training_data, use_hessian_avg=True ) - params = dict(model.model.named_parameters()) - - def hessian_vector_product(x: torch.Tensor) -> torch.Tensor: - output = raw_hvp(align_structure(params, x)) - return flatten_tensors_to_vector(output.values()) low_rank_representation = lanzcos_low_rank_hessian_approx( - hessian_vp=hessian_vector_product, + hessian_vp=raw_hvp, matrix_shape=(model.num_params, model.num_params), hessian_perturbation=hessian_perturbation, rank_estimate=rank_estimate, diff --git a/tests/influence/test_util.py b/tests/influence/test_util.py index 6baebd8f2..b381426a9 100644 --- a/tests/influence/test_util.py +++ b/tests/influence/test_util.py @@ -94,11 +94,13 @@ def model_data(request): x = torch.rand(train_size, dimension[-1]) y = torch.rand(train_size, dimension[0]) torch_model = linear_torch_model_from_numpy(A, b) - vec = { - name: torch.rand(*p.shape) - for name, p in torch_model.named_parameters() - if p.requires_grad - } + vec = flatten_tensors_to_vector( + tuple( + torch.rand(*p.shape) + for name, p in torch_model.named_parameters() + if p.requires_grad + ) + ) H_analytical = linear_hessian_analytical((A, b), x.numpy()) H_analytical = torch.as_tensor(H_analytical) return torch_model, x, y, vec, H_analytical.to(torch.float32) @@ -112,7 +114,6 @@ def model_data(request): ) def test_hvp(model_data, tol: float): torch_model, x, y, vec, H_analytical = model_data - vec_flat = flatten_tensors_to_vector(vec.values()) params = dict(torch_model.named_parameters()) @@ -121,7 +122,7 @@ def test_hvp(model_data, tol: float): Hvp_autograd = hvp(f, params, align_structure(params, vec)) flat_Hvp_autograd = flatten_tensors_to_vector(Hvp_autograd.values()) - assert torch.allclose(flat_Hvp_autograd, H_analytical @ vec_flat, rtol=tol) + assert torch.allclose(flat_Hvp_autograd, H_analytical @ vec, rtol=tol) @pytest.mark.torch @@ -140,10 +141,8 @@ def test_get_hvp_function(model_data, tol: float, use_avg: bool, batch_size: int Hvp_autograd = get_hvp_function( torch_model, mse_loss, data_loader, use_hessian_avg=use_avg )(vec) - vec_flat = flatten_tensors_to_vector(vec.values()) - flat_Hvp_autograd = flatten_tensors_to_vector(Hvp_autograd.values()) - assert torch.allclose(flat_Hvp_autograd, H_analytical @ vec_flat, rtol=tol) + assert torch.allclose(Hvp_autograd, H_analytical @ vec, rtol=tol) @pytest.mark.torch @@ -157,8 +156,6 @@ def test_lanzcos_low_rank_hessian_approx( ): _, _, _, vec, H_analytical = model_data - vec_flat = flatten_tensors_to_vector(vec.values()) - reg_H_analytical = H_analytical + regularization * torch.eye(H_analytical.shape[0]) low_rank_approx = lanzcos_low_rank_hessian_approx( lambda z: reg_H_analytical @ z, @@ -167,9 +164,9 @@ def test_lanzcos_low_rank_hessian_approx( ) approx_result = low_rank_approx.projections @ ( torch.diag_embed(low_rank_approx.eigen_vals) - @ (low_rank_approx.projections.t() @ vec_flat.t()) + @ (low_rank_approx.projections.t() @ vec.t()) ) - assert torch.allclose(approx_result, reg_H_analytical @ vec_flat, rtol=1e-1) + assert torch.allclose(approx_result, reg_H_analytical @ vec, rtol=1e-1) @pytest.mark.torch From 3feeb9189ac10f8dc3578d5143179a6b97da001a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 17 Aug 2023 19:13:39 +0200 Subject: [PATCH 247/436] Mention PR in changelog --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 14aca878a..d7cdc690a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,7 +15,7 @@ - Improvements to IF documentation [PR #371](https://github.com/appliedAI-Initiative/pyDVL/pull/371) - Major changes to IF interface and functionality - [PR #278](https://github.com/appliedAI-Initiative/pyDVL/pull/278) + [PR #278](https://github.com/appliedAI-Initiative/pyDVL/pull/278) [PR #394](https://github.com/appliedAI-Initiative/pyDVL/pull/394) - **New Method**: Implements solving the hessian equation via spectral low-rank approximation [PR #365](https://github.com/appliedAI-Initiative/pyDVL/pull/365) - **Breaking Changes**: From f1699bdc154c7696bed1701476c60218eb8b791f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 17 Aug 2023 20:01:47 +0200 Subject: [PATCH 248/436] Add a small example for influence computation to README.md --- README.md | 49 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/README.md b/README.md index d9efb4923..d7968d9f7 100644 --- a/README.md +++ b/README.md @@ -99,6 +99,55 @@ documentation. # Usage +### Influence Functions + +For influence computation, follow these steps: + +1. Wrap your model and loss in a `TorchTwiceDifferential` object +2. Compute influence factors by providing training data and inversion method + +Using the conjugate gradient algorithm, this would look like: +```python +import torch +from torch import nn +from torch.utils.data import DataLoader, TensorDataset + +from pydvl.influence import TorchTwiceDifferentiable, compute_influences +from pydvl.influence.inversion import InversionMethod + +nn_architecture = nn.Sequential( + nn.Conv2d(in_channels=5, out_channels=3, kernel_size=3), + nn.Flatten(), + nn.Linear(27, 3), +) +loss = nn.MSELoss() +influence_model = TorchTwiceDifferentiable(nn_architecture, loss) + +input_dim = (5, 5, 5) +output_dim = 3 + +train_data_loader = DataLoader( + TensorDataset(torch.rand((10, *input_dim)), torch.rand((10, output_dim))), + batch_size=2, +) +test_data_loader = DataLoader( + TensorDataset(torch.rand((5, *input_dim)), torch.rand((5, output_dim))), + batch_size=1, +) + +influences = compute_influences( + influence_model, + training_data=train_data_loader, + test_data=test_data_loader, + progress=True, + inversion_method=InversionMethod.Cg, + hessian_regularization=1e-1, + maxiter=200, +) +``` + + +### Shapley Values The steps required to compute values for your samples are: 1. Create a `Dataset` object with your train and test splits. From c5389659bcbcc037260db52e40202d5e738e6c23 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 17 Aug 2023 21:35:20 +0200 Subject: [PATCH 249/436] Move exception raise to solve_arnoldi level: * raise exception messages with info how to resolve * add functionality to LowRankRepresentation * provide function to precompute low rank approximations --- .../frameworks/torch_differentiable.py | 134 ++++++++++++++---- 1 file changed, 109 insertions(+), 25 deletions(-) diff --git a/src/pydvl/influence/frameworks/torch_differentiable.py b/src/pydvl/influence/frameworks/torch_differentiable.py index 02df5ae1e..41688f465 100644 --- a/src/pydvl/influence/frameworks/torch_differentiable.py +++ b/src/pydvl/influence/frameworks/torch_differentiable.py @@ -481,6 +481,26 @@ class LowRankProductRepresentation: eigen_vals: torch.Tensor projections: torch.Tensor + @property + def device(self) -> torch.device: + return ( + self.eigen_vals.device + if hasattr(self.eigen_vals, "device") + else torch.device("cpu") + ) + + def to(self, device: torch.device): + """ + Move the representing tensors to a device + """ + return LowRankProductRepresentation( + self.eigen_vals.to(device), self.projections.to(device) + ) + + def __post_init__(self): + if self.eigen_vals.device != self.projections.device: + raise ValueError("eigen_vals and projections must be on the same device.") + def solve_arnoldi( model: TorchTwiceDifferentiable, @@ -512,8 +532,8 @@ def solve_arnoldi( :param krylov_dimension: The number of Krylov vectors to use for the Lanczos method. If not provided, it defaults to $min(model.num_parameters, max(2*rank_estimate + 1, 20))$. :param low_rank_representation: A LowRankProductRepresentation instance containing a previously computed - low-rank representation of the Hessian. - If not provided, a new low-rank representation will be computed, + low-rank representation of the Hessian. I provided, all other parameters + are ignored, if not, a new low-rank representation will be computed, using provided parameters. :param tol: The stopping criteria for the Lanczos algorithm. If `low_rank_representation` is provided, this parameter is ignored. @@ -529,29 +549,42 @@ def solve_arnoldi( where H is a low-rank approximation of the Hessian of the model's loss function. """ - if low_rank_representation is None: + b_device = b.device if hasattr(b, "device") else torch.device("cpu") - raw_hvp = get_hvp_function( - model.model, model.loss, training_data, use_hessian_avg=True - ) - params = dict(model.model.named_parameters()) + if low_rank_representation is None: - def hessian_vector_product(x: torch.Tensor) -> torch.Tensor: - output = raw_hvp(align_structure(params, x)) - return flatten_tensors_to_vector(output.values()) + if b_device.type == "cuda" and not eigen_computation_on_gpu: + raise ValueError( + "Using 'eigen_computation_on_gpu=False' while 'b' is on a 'cuda' device is not supported. " + "To address this, consider the following options:\n" + " - Set eigen_computation_on_gpu=True if your model and data are small enough " + "and if 'cupy' is available in your environment.\n" + " - Move 'b' to the CPU with b.to('cpu').\n" + " - Precompute a low rank representation and move it to the 'b' device using:\n" + " low_rank_representation = model_hessian_low_rank(model, training_data, ..., " + "eigen_computation_on_gpu=False).to(b.device)" + ) - low_rank_representation = lanzcos_low_rank_hessian_approx( - hessian_vp=hessian_vector_product, - matrix_shape=(model.num_params, model.num_params), + low_rank_representation = model_hessian_low_rank( + model, + training_data, hessian_perturbation=hessian_perturbation, rank_estimate=rank_estimate, krylov_dimension=krylov_dimension, tol=tol, max_iter=max_iter, - device=model.device if hasattr(model, "device") else None, eigen_computation_on_gpu=eigen_computation_on_gpu, ) else: + if b_device.type != low_rank_representation.device.type: + raise RuntimeError( + f"The devices for 'b' and 'low_rank_representation' do not match.\n" + f" - 'b' is on device: {b_device}\n" + f" - 'low_rank_representation' is on device: {low_rank_representation.device}\n" + f"\nTo resolve this, consider moving 'low_rank_representation' to '{b_device}' by using:\n" + f"low_rank_representation = low_rank_representation.to(b.device)" + ) + logger.info("Using provided low rank representation, ignoring other parameters") result = low_rank_representation.projections @ ( @@ -580,7 +613,7 @@ def lanzcos_low_rank_hessian_approx( torch_dtype: torch.dtype = None, ) -> LowRankProductRepresentation: """ - Calculates a low-rank approximation of the Hessian matrix of the model's loss function using the implicitly + Calculates a low-rank approximation of the Hessian matrix of a scalar-valued function using the implicitly restarted Lanczos algorithm. @@ -636,14 +669,6 @@ def mv(x): else: from scipy.sparse.linalg import LinearOperator, eigsh - if device is not None and device.type == "cuda": - logger.warning( - "Device is cuda, but eigen_computation_on_gpu is False, so eigen computation will be on CPU." - "To enable GPU computation, set eigen_computation_on_gpu to True." - ) - else: - device = torch.device("cpu") - def mv(x): x_torch = torch.as_tensor(x, device=device, dtype=torch_dtype) y: NDArray = ( @@ -676,7 +701,66 @@ def mv(x): eigen_vals, eigen_vecs = e.eigenvalues, e.eigenvectors - eigen_vals = to_torch_conversion_function(eigen_vals).to(device) - eigen_vecs = to_torch_conversion_function(eigen_vecs).to(device) + eigen_vals = to_torch_conversion_function(eigen_vals) + eigen_vecs = to_torch_conversion_function(eigen_vecs) return LowRankProductRepresentation(eigen_vals, eigen_vecs) + + +def model_hessian_low_rank( + model: TorchTwiceDifferentiable, + training_data: DataLoader, + hessian_perturbation: float = 0.0, + rank_estimate: int = 10, + krylov_dimension: Optional[int] = None, + tol: float = 1e-6, + max_iter: Optional[int] = None, + eigen_computation_on_gpu: bool = False, +) -> LowRankProductRepresentation: + """ + Calculates a low-rank approximation of the Hessian matrix of the model's loss function using the implicitly + restarted Lanczos algorithm. + + :param model: A PyTorch model instance that is twice differentiable, wrapped into :class:`TorchTwiceDifferential`. + The Hessian will be calculated with respect to this model's parameters. + :param training_data: A DataLoader instance that provides the model's training data. + Used in calculating the Hessian-vector products. + :param hessian_perturbation: Optional regularization parameter added to the Hessian-vector product + for numerical stability. + :param rank_estimate: The number of eigenvalues and corresponding eigenvectors to compute. + Represents the desired rank of the Hessian approximation. + :param krylov_dimension: The number of Krylov vectors to use for the Lanczos method. + If not provided, it defaults to $min(model.num_parameters, max(2*rank_estimate + 1, 20))$. + :param tol: The stopping criteria for the Lanczos algorithm, which stops when the difference + in the approximated eigenvalue is less than `tol`. Defaults to 1e-6. + :param max_iter: The maximum number of iterations for the Lanczos method. If not provided, it defaults to + $10*model.num_parameters$ + :param eigen_computation_on_gpu: If True, tries to execute the eigen pair approximation on the provided + device via cupy implementation. + Make sure, that either your model is small enough or you use a + small rank_estimate to fit your device's memory. + If False, the eigen pair approximation is executed on the CPU by scipy wrapper to + ARPACK. + :return: A `LowRankProductRepresentation` instance that contains the top (up until rank_estimate) eigenvalues + and corresponding eigenvectors of the Hessian. + """ + raw_hvp = get_hvp_function( + model.model, model.loss, training_data, use_hessian_avg=True + ) + params = dict(model.model.named_parameters()) + + def hessian_vector_product(x: torch.Tensor) -> torch.Tensor: + output = raw_hvp(align_structure(params, x)) + return flatten_tensors_to_vector(output.values()) + + return lanzcos_low_rank_hessian_approx( + hessian_vp=hessian_vector_product, + matrix_shape=(model.num_params, model.num_params), + hessian_perturbation=hessian_perturbation, + rank_estimate=rank_estimate, + krylov_dimension=krylov_dimension, + tol=tol, + max_iter=max_iter, + device=model.device if hasattr(model, "device") else None, + eigen_computation_on_gpu=eigen_computation_on_gpu, + ) From d9209f4a1783799818a2de4a4d8aeea04062c50c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 17 Aug 2023 22:09:21 +0200 Subject: [PATCH 250/436] Extend arnoldi influence test to include pre-computing of low rank representation --- tests/influence/test_influences.py | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 9ffca5eca..c3dc9c00c 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -4,6 +4,8 @@ import numpy as np import pytest +from pydvl.influence.frameworks.torch_differentiable import model_hessian_low_rank + torch = pytest.importorskip("torch") import torch import torch.nn.functional as F @@ -466,3 +468,22 @@ def test_influences_arnoldi( ) assert np.allclose(direct_influence, low_rank_influence, rtol=1e-1) + + precomputed_low_rank = model_hessian_low_rank( + model, + training_data=train_data_loader, + hessian_perturbation=hessian_reg, + rank_estimate=num_parameters - 1, + ) + + precomputed_low_rank_influence = compute_influences( + model, + training_data=train_data_loader, + test_data=test_data_loader, + progress=True, + influence_type=influence_type, + inversion_method=InversionMethod.Arnoldi, + low_rank_representation=precomputed_low_rank, + ) + + assert np.allclose(direct_influence, precomputed_low_rank_influence, rtol=1e-1) From 8a52381c4933091dbee500057906fbfae918fde8 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 18 Aug 2023 11:53:30 +0200 Subject: [PATCH 251/436] fix tests --- tests/influence/test_influences.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index c3dc9c00c..af4da85ee 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -373,6 +373,7 @@ def test_influences_nn( assert not np.all(approx_influences == approx_influences.item(0)) +@pytest.mark.torch def minimal_training( model: torch.nn.Module, dataloader: DataLoader, From 26272f616cff39730fc8344221d305c8960fc483 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 18 Aug 2023 11:56:33 +0200 Subject: [PATCH 252/436] fix tests --- tests/influence/test_influences.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index af4da85ee..5e42f9547 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -4,8 +4,6 @@ import numpy as np import pytest -from pydvl.influence.frameworks.torch_differentiable import model_hessian_low_rank - torch = pytest.importorskip("torch") import torch import torch.nn.functional as F @@ -15,6 +13,7 @@ from torch.utils.data import DataLoader, TensorDataset from pydvl.influence import TorchTwiceDifferentiable, compute_influences +from pydvl.influence.frameworks.torch_differentiable import model_hessian_low_rank from pydvl.influence.general import InfluenceType, InversionMethod from .conftest import ( @@ -373,7 +372,6 @@ def test_influences_nn( assert not np.all(approx_influences == approx_influences.item(0)) -@pytest.mark.torch def minimal_training( model: torch.nn.Module, dataloader: DataLoader, From c3960efd8735915b8ea0089686988588d3ba016e Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 18 Aug 2023 21:51:33 +0200 Subject: [PATCH 253/436] Send single samples to workers, only process stopping in main process --- src/pydvl/value/sampler.py | 63 +++++++++------- src/pydvl/value/semivalues.py | 138 +++++++++++++--------------------- 2 files changed, 88 insertions(+), 113 deletions(-) diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 488fa38b5..b096308c9 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -54,11 +54,11 @@ ] T = TypeVar("T", bound=np.generic) -SampleType = Tuple[T, NDArray[T]] +SampleT = Tuple[T, NDArray[T]] Sequence.register(np.ndarray) -class PowersetSampler(abc.ABC, Iterable[SampleType], Generic[T]): +class PowersetSampler(abc.ABC, Iterable[SampleT], Generic[T]): """Samplers are custom iterables over subsets of indices. Calling ``iter()`` on a sampler returns an iterator over tuples of the form @@ -181,17 +181,18 @@ def __repr__(self): return f"{self.__class__.__name__}({self._indices}, {self._outer_indices})" @abc.abstractmethod - def __iter__(self) -> Iterator[SampleType]: + def __iter__(self) -> Iterator[SampleT]: ... + @classmethod @abc.abstractmethod - def weight(self, subset: NDArray[T]) -> float: + def weight(cls, n: int, subset_len: int) -> float: r"""Factor by which to multiply Monte Carlo samples, so that the mean converges to the desired expression. By the Law of Large Numbers, the sample mean of $\delta_i(S_j)$ - converges - to the expectation under the distribution from which $S_j$ is sampled. + converges to the expectation under the distribution from which $S_j$ is + sampled. $$ \frac{1}{m} \sum_{j = 1}^m \delta_i (S_j) c (S_j) \longrightarrow \underset{S \sim \mathcal{D}_{- i}}{\mathbb{E}} [\delta_i (S) c ( @@ -231,14 +232,15 @@ def __init__(self, indices: NDArray[T], *args, **kwargs): kwargs.update({"index_iteration": PowersetSampler.IndexIteration.Sequential}) super().__init__(indices, *args, **kwargs) - def __iter__(self) -> Iterator[SampleType]: + def __iter__(self) -> Iterator[SampleT]: for idx in self.iterindices(): for subset in powerset(self.complement([idx])): yield idx, np.array(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 UniformSampler(PowersetSampler[T]): @@ -263,7 +265,7 @@ class UniformSampler(PowersetSampler[T]): """ - def __iter__(self) -> Iterator[SampleType]: + def __iter__(self) -> Iterator[SampleT]: while True: for idx in self.iterindices(): subset = random_subset(self.complement([idx])) @@ -272,12 +274,12 @@ def __iter__(self) -> Iterator[SampleType]: if self._n_samples == 0: # Empty index set break - def weight(self, subset: NDArray[T]) -> float: + @classmethod + def weight(cls, n: int, subset_len: int) -> float: """Correction coming from Monte Carlo integration so that the mean of the marginals converges to the value: the uniform distribution over the - powerset of a set with n-1 elements has mass 2^{n-1} over each subset. - The factor 1 / n corresponds to the one in the Shapley definition.""" - return float(2 ** (self._n - 1)) if self._n > 0 else 1.0 + powerset of a set with n-1 elements has mass 2^{n-1} over each subset.""" + return float(2 ** (n - 1)) if n > 0 else 1.0 class AntitheticSampler(PowersetSampler[T]): @@ -289,7 +291,7 @@ class AntitheticSampler(PowersetSampler[T]): the set $S$, including the index $i$ itself. """ - def __iter__(self) -> Iterator[SampleType]: + def __iter__(self) -> Iterator[SampleT]: while True: for idx in self.iterindices(): subset = random_subset(self.complement([idx])) @@ -300,8 +302,9 @@ def __iter__(self) -> Iterator[SampleType]: if self._n_samples == 0: # Empty index set break - 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 PermutationSampler(PowersetSampler[T]): @@ -321,9 +324,10 @@ class PermutationSampler(PowersetSampler[T]): will be doubled wrt. a "direct" implementation of permutation MC """ - def __iter__(self) -> Iterator[SampleType]: + def __iter__(self) -> Iterator[SampleT]: + rng = np.random.default_rng() # FIXME: waiting for better rng handling while True: - permutation = np.random.permutation(self._indices) + permutation = rng.permutation(self._indices) for i, idx in enumerate(permutation): yield idx, permutation[:i] self._n_samples += 1 @@ -335,8 +339,9 @@ def __getitem__(self, key: slice | list[int]) -> "PowersetSampler[T]": a copy of the full sampler.""" return super().__getitem__(slice(None)) - def weight(self, subset: NDArray[T]) -> float: - return self._n * math.comb(self._n - 1, len(subset)) if self._n > 0 else 1.0 + @classmethod + def weight(cls, n: int, subset_len: int) -> float: + return n * math.comb(n - 1, subset_len) if n > 0 else 1.0 class DeterministicPermutationSampler(PermutationSampler[T]): @@ -347,15 +352,18 @@ class DeterministicPermutationSampler(PermutationSampler[T]): .. warning:: This sampler requires caching to be enabled or computation will be doubled wrt. a "direct" implementation of permutation MC + + .. warning:: + This sampler is not parallelizable, as it always iterates over the whole + set of permutations in the same order. Different processes would always + return the same values for all indices. """ - def __iter__(self) -> Iterator[SampleType]: + def __iter__(self) -> Iterator[SampleT]: for permutation in permutations(self._indices): for i, idx in enumerate(permutation): yield idx, np.array(permutation[:i], dtype=self._indices.dtype) self._n_samples += 1 - if self._n_samples == 0: # Empty index set - break class RandomHierarchicalSampler(PowersetSampler[T]): @@ -365,7 +373,7 @@ class RandomHierarchicalSampler(PowersetSampler[T]): This is unnecessary, but a step towards proper stratified sampling. """ - def __iter__(self) -> Iterator[SampleType]: + def __iter__(self) -> Iterator[SampleT]: while True: for idx in self.iterindices(): k = np.random.choice(np.arange(len(self._indices)), size=1).item() @@ -375,5 +383,6 @@ def __iter__(self) -> Iterator[SampleType]: if self._n_samples == 0: # Empty index set break - 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 diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 89868fc33..0d4c49aa4 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -45,18 +45,17 @@ from __future__ import annotations import math -from concurrent.futures import Future from enum import Enum from functools import partial -from itertools import takewhile -from typing import Any, Iterator, Protocol, Type, cast +from typing import Protocol, Tuple, Type, TypeVar, cast +import numpy as np import scipy as sp from tqdm import tqdm from pydvl.utils import ParallelConfig, Utility from pydvl.value import ValuationResult -from pydvl.value.sampler import PermutationSampler, PowersetSampler +from pydvl.value.sampler import PermutationSampler, PowersetSampler, SampleT from pydvl.value.stopping import MaxUpdates, StoppingCriterion __all__ = [ @@ -83,46 +82,23 @@ def __call__(self, n: int, k: int) -> float: ... -def _semivalues( - sampler: PowersetSampler, - u: Utility, - coefficient: SVCoefficient, - done: StoppingCriterion, - *, - progress: bool = False, - job_id: int = 1, - interrupt_flag: Any = None, # TO DO -) -> ValuationResult: - r"""Serial computation of semi-values. This is a helper function for +IndexT = TypeVar("IndexT", bound=np.generic) +MarginalT = Tuple[IndexT, float] + + +def _marginal(u: Utility, coefficient: SVCoefficient, sample: SampleT) -> MarginalT: + """Computation of marginal utility. This is a helper function for :func:`semivalues`. - :param sampler: The subset sampler to use for utility computations. :param u: Utility object with model, data, and scoring function. - :param coefficient: The semivalue coefficient - :param done: Stopping criterion. - :param progress: Whether to display progress bars for each job. - :param job_id: id to use for reporting progress. - :param interrupt_flag: Flag to check for interrupt. - :return: Object with the results. + :param coefficient: The semi-value coefficient and sampler weight + :param sample: A tuple of idx, subset from the sampler to compute its + marginal utility. """ - n = len(u.data.indices) - result = ValuationResult.zeros( - algorithm=f"semivalue-{str(sampler)}-{coefficient.__name__}", - 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 idx, s in samples: - pbar.n = 100 * done.completion() - pbar.refresh() - marginal = ( - (u({idx}.union(s)) - u(s)) * coefficient(n, len(s)) * sampler.weight(s) - ) - result.update(idx, marginal) - - return result + n = len(u.data) + idx, s = sample + marginal = (u({idx}.union(s)) - u(s)) * coefficient(n, len(s)) + return idx, marginal def semivalues( @@ -148,61 +124,51 @@ def semivalues( :return: Object with the results. """ - from concurrent.futures import FIRST_COMPLETED, wait + from concurrent.futures import FIRST_COMPLETED, Future, wait from pydvl.utils import effective_n_jobs, init_executor, init_parallel_backend + result = ValuationResult.zeros( + algorithm=f"semivalue-{str(sampler)}-{coefficient.__name__}", + indices=u.data.indices, + data_names=u.data.data_names, + ) + parallel_backend = init_parallel_backend(config) u = parallel_backend.put(u) - coefficient = parallel_backend.put(coefficient) + correction = parallel_backend.put( + lambda n, k: coefficient(n, k) * sampler.weight(n, k) + ) max_workers = effective_n_jobs(n_jobs, config) n_submitted_jobs = 2 * max_workers # number of jobs in the queue - accumulated_result = ValuationResult.zeros( - algorithm=f"semivalue-{str(sampler)}-{coefficient.__name__}" - ) - - if isinstance(sampler, PermutationSampler): - # TODO: add attribute to allow configuration of multiple updates per job - # (e.g. permutations) - updates_per_job = getattr(sampler, "max_samples_parallel", 1) - - with init_executor( - max_workers=max_workers, config=config, cancel_futures=True - ) as executor: - futures: set[Future] = set() - while True: - completed_futures, futures = wait( - futures, timeout=60, return_when=FIRST_COMPLETED - ) - for future in completed_futures: - accumulated_result += future.result() - if done(accumulated_result): - return accumulated_result - - # Ensure that we always have n_submitted_jobs running - for _ in range(n_submitted_jobs - len(futures)): - future = executor.submit( - _semivalues, - sampler=sampler[:], - u=u, - coefficient=coefficient, - done=MaxUpdates(updates_per_job), - ) - futures.add(future) - else: - with init_executor( - max_workers=max_workers, config=config, cancel_futures=False - ) as executor: - results: Iterator[ValuationResult] = executor.map( - partial(_semivalues, u=u, coefficient=coefficient, done=done), - sampler, - chunksize=max(1, sampler.n_samples // max_workers), - ) - for r in results: - accumulated_result += r - return accumulated_result + sampler_it = iter(sampler) + job = partial(_marginal, u=u, coefficient=correction) + pbar = tqdm(disable=not progress, total=100, unit="%") + + with init_executor( + max_workers=max_workers, config=config, cancel_futures=True + ) as executor: + pending: set[Future] = set() + while True: + pbar.n = 100 * done.completion() + pbar.refresh() + + completed, pending = wait(pending, timeout=1, return_when=FIRST_COMPLETED) + for future in completed: + idx, marginal = future.result() + result.update(idx, marginal) + if done(result): + return result + + # Ensure that we always have n_submitted_jobs running + try: + for _ in range(n_submitted_jobs - len(pending)): + pending.add(executor.submit(job, sample=next(sampler_it))) + except StopIteration: + if len(pending) == 0: + return result def shapley_coefficient(n: int, k: int) -> float: From 78ae405c93252cbc5c3151a66502c9feb15e980e Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 18 Aug 2023 21:51:51 +0200 Subject: [PATCH 254/436] Cosmetic --- src/pydvl/utils/parallel/backend.py | 6 +----- src/pydvl/value/stopping.py | 10 +++++++--- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index 961adc621..ee5246e4b 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -213,11 +213,7 @@ def wait( ) -> tuple[list[ObjectRef], list[ObjectRef]]: num_returns: int = kwargs.get("num_returns", 1) timeout: float | None = kwargs.get("timeout", None) - return ray.wait( # type: ignore - v, - num_returns=num_returns, - timeout=timeout, - ) + return ray.wait(v, num_returns=num_returns, timeout=timeout) # type: ignore def _effective_n_jobs(self, n_jobs: int) -> int: ray_cpus = int(ray._private.state.cluster_resources()["CPU"]) # type: ignore diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index 09ba84475..2eb9b8e10 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -220,9 +220,9 @@ def completion(self) -> float: class AbsoluteStandardError(StoppingCriterion): r"""Determine convergence based on the standard error of the values. - If $s_i$ is the standard error for datum $i$ and $v_i$ its value, then this - criterion returns :attr:`~pydvl.utils.status.Status.Converged` if - $s_i < \epsilon$ for all $i$ and a threshold value $\epsilon \gt 0$. + If $s_i$ is the standard error for datum $i$, then this criterion returns + :attr:`~pydvl.utils.status.Status.Converged` if $s_i < \epsilon$ for all $i$ + and a threshold value $\epsilon \gt 0$. :param threshold: A value is considered to have converged if the standard error is below this value. A way of choosing it is to pick some @@ -302,6 +302,10 @@ class MaxUpdates(StoppingCriterion): """Terminate if any number of value updates exceeds or equals the given threshold. + .. note:: + If you want to ensure that **all** values have been updated, you probably + want :class:`MinUpdates` instead. + This checks the ``counts`` field of a :class:`~pydvl.value.result.ValuationResult`, i.e. the number of times that each index has been updated. For powerset samplers, the maximum of this From da1ce7aae63fb5c2c151bfd839e6cc8a0bb1e71d Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 18 Aug 2023 21:53:20 +0200 Subject: [PATCH 255/436] Tests for new semi-value computation, test all parallel configs --- tests/value/test_semivalues.py | 53 +++++++++++++++------------------- 1 file changed, 24 insertions(+), 29 deletions(-) diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index 17063c6c7..3445216d1 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -4,7 +4,7 @@ import numpy as np import pytest -from pydvl.utils import Utility +from pydvl.utils import ParallelConfig, Utility from pydvl.value.sampler import ( AntitheticSampler, DeterministicCombinatorialSampler, @@ -16,14 +16,13 @@ from pydvl.value.semivalues import ( SemiValueMode, SVCoefficient, - _semivalues, banzhaf_coefficient, beta_coefficient, compute_semivalues, semivalues, shapley_coefficient, ) -from pydvl.value.stopping import AbsoluteStandardError, MaxUpdates, StoppingCriterion +from pydvl.value.stopping import AbsoluteStandardError, MaxUpdates from . import check_values @@ -39,30 +38,25 @@ AntitheticSampler, ], ) -@pytest.mark.parametrize( - "coefficient, criterion", - [ - (shapley_coefficient, AbsoluteStandardError(0.02, 1.0) | MaxUpdates(2**10)), - ( - beta_coefficient(1, 1), - AbsoluteStandardError(0.02, 1.0) | MaxUpdates(2**10), - ), - ], -) -@pytest.mark.parametrize("method", [_semivalues, semivalues]) +@pytest.mark.parametrize("coefficient", [shapley_coefficient, beta_coefficient(1, 1)]) def test_shapley( num_samples: int, analytic_shapley, sampler: Type[PowersetSampler], coefficient: SVCoefficient, - criterion: StoppingCriterion, - method, + n_jobs: int, + parallel_config: ParallelConfig, ): u, exact_values = analytic_shapley - kwargs = dict() - if method == semivalues: - kwargs.update(dict(n_jobs=2)) - values = method(sampler(u.data.indices), u, coefficient, criterion, **kwargs) + criterion = AbsoluteStandardError(0.02, 1.0) | MaxUpdates(2 ** (num_samples * 2)) + values = semivalues( + sampler(u.data.indices), + u, + coefficient, + criterion, + n_jobs=n_jobs, + config=parallel_config, + ) check_values(values, exact_values, rtol=0.15) @@ -77,20 +71,21 @@ def test_shapley( AntitheticSampler, ], ) -@pytest.mark.parametrize("method", [_semivalues, semivalues]) def test_banzhaf( - num_samples: int, analytic_banzhaf, sampler: Type[PowersetSampler], method + num_samples: int, + analytic_banzhaf, + sampler: Type[PowersetSampler], + n_jobs: int, + parallel_config: ParallelConfig, ): u, exact_values = analytic_banzhaf - kwargs = dict() - if method == semivalues: - kwargs.update(dict(n_jobs=2)) - values = method( + values = semivalues( sampler(u.data.indices), u, banzhaf_coefficient, - AbsoluteStandardError(0.02, 1.0) | MaxUpdates(300), - **kwargs, + AbsoluteStandardError(0.02, 1.0) | MaxUpdates(2**10), + n_jobs=n_jobs, + config=parallel_config, ) check_values(values, exact_values, rtol=0.15) @@ -138,5 +133,5 @@ def test_dispatch_compute_semi_values( mode=semi_value_mode, done=MaxUpdates(1), **semi_value_mode_kwargs, - progress=True, + n_jobs=1, ) From 709d1b00591dcc1c266f075358321f85161e8396 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 18 Aug 2023 22:43:59 +0200 Subject: [PATCH 256/436] Rename and deprecate inconsistently named sampler --- src/pydvl/value/sampler.py | 13 +++++++++++-- tests/value/test_sampler.py | 6 +++--- tests/value/test_semivalues.py | 6 +++--- 3 files changed, 17 insertions(+), 8 deletions(-) diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index b096308c9..2d8398c92 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -39,13 +39,14 @@ from typing import Generic, Iterable, Iterator, Sequence, Tuple, TypeVar, overload import numpy as np +from deprecate import deprecated, void from numpy.typing import NDArray from pydvl.utils.numeric import powerset, random_subset, random_subset_of_size __all__ = [ "AntitheticSampler", - "DeterministicCombinatorialSampler", + "DeterministicUniformSampler", "DeterministicPermutationSampler", "PermutationSampler", "PowersetSampler", @@ -204,7 +205,7 @@ def weight(cls, n: int, subset_len: int) -> float: ... -class DeterministicCombinatorialSampler(PowersetSampler[T]): +class DeterministicUniformSampler(PowersetSampler[T]): def __init__(self, indices: NDArray[T], *args, **kwargs): """An iterator to perform uniform deterministic sampling of subsets. @@ -282,6 +283,14 @@ def weight(cls, n: int, subset_len: int) -> float: return float(2 ** (n - 1)) if n > 0 else 1.0 +class DeterministicCombinatorialSampler(DeterministicUniformSampler[T]): + @deprecated( + target=DeterministicUniformSampler, deprecated_in="0.6.0", remove_in="0.8.0" + ) + def __init__(self, indices: NDArray[T], *args, **kwargs): + void(indices, args, kwargs) + + class AntitheticSampler(PowersetSampler[T]): """An iterator to perform uniform random sampling of subsets, and their complements. diff --git a/tests/value/test_sampler.py b/tests/value/test_sampler.py index 8affc108f..3cbfffa18 100644 --- a/tests/value/test_sampler.py +++ b/tests/value/test_sampler.py @@ -6,7 +6,7 @@ from pydvl.utils import powerset from pydvl.value.sampler import ( AntitheticSampler, - DeterministicCombinatorialSampler, + DeterministicUniformSampler, DeterministicPermutationSampler, PermutationSampler, RandomHierarchicalSampler, @@ -17,7 +17,7 @@ @pytest.mark.parametrize( "sampler_class", [ - DeterministicCombinatorialSampler, + DeterministicUniformSampler, UniformSampler, PermutationSampler, AntitheticSampler, @@ -38,7 +38,7 @@ def test_proper(sampler_class, indices): @pytest.mark.parametrize( "sampler_class", [ - DeterministicCombinatorialSampler, + DeterministicUniformSampler, UniformSampler, # PermutationSampler, AntitheticSampler, diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index 3445216d1..e32861176 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -7,7 +7,7 @@ from pydvl.utils import ParallelConfig, Utility from pydvl.value.sampler import ( AntitheticSampler, - DeterministicCombinatorialSampler, + DeterministicUniformSampler, DeterministicPermutationSampler, PermutationSampler, PowersetSampler, @@ -31,7 +31,7 @@ @pytest.mark.parametrize( "sampler", [ - DeterministicCombinatorialSampler, + DeterministicUniformSampler, DeterministicPermutationSampler, UniformSampler, PermutationSampler, @@ -64,7 +64,7 @@ def test_shapley( @pytest.mark.parametrize( "sampler", [ - DeterministicCombinatorialSampler, + DeterministicUniformSampler, DeterministicPermutationSampler, UniformSampler, PermutationSampler, From 49b5436125982ccb489d8219557c69ef92f0979f Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 18 Aug 2023 22:50:39 +0200 Subject: [PATCH 257/436] [skip ci] Un-fluff --- tests/value/test_sampler.py | 2 +- tests/value/test_semivalues.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/value/test_sampler.py b/tests/value/test_sampler.py index 3cbfffa18..570d11ed9 100644 --- a/tests/value/test_sampler.py +++ b/tests/value/test_sampler.py @@ -6,8 +6,8 @@ from pydvl.utils import powerset from pydvl.value.sampler import ( AntitheticSampler, - DeterministicUniformSampler, DeterministicPermutationSampler, + DeterministicUniformSampler, PermutationSampler, RandomHierarchicalSampler, UniformSampler, diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index e32861176..0efefdc51 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -7,8 +7,8 @@ from pydvl.utils import ParallelConfig, Utility from pydvl.value.sampler import ( AntitheticSampler, - DeterministicUniformSampler, DeterministicPermutationSampler, + DeterministicUniformSampler, PermutationSampler, PowersetSampler, UniformSampler, From ac11f8e47a462ac1e35e9ba8f40cbd8a9681d446 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 18 Aug 2023 22:53:58 +0200 Subject: [PATCH 258/436] [skip ci] Update changelog --- CHANGELOG.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 14aca878a..db26e14cc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,10 +2,13 @@ ## Unreleased +- Fixes to parallel computation of generic semi-values: properly handle all + samplers and stopping criteria, irrespective of parallel backend + [PR #372](https://github.com/appliedAI-Initiative/pyDVL/pull/372) - Optimises memory usage in IF calculation [PR #375](https://github.com/appliedAI-Initiative/pyDVL/pull/376) - **Breaking Changes** - Returns information about hessian inversion to compute_influence_factors, + Return information about hessian inversion from compute_influence_factors, thus changing signature [PR #375](https://github.com/appliedAI-Initiative/pyDVL/pull/376) - Fix adding valuation results with overlapping indices and different lengths From 03730c44b4bc57a90fbaf32af3b39695ad4e20ce Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 18 Aug 2023 22:56:40 +0200 Subject: [PATCH 259/436] [skip ci] Change deprecation versions --- src/pydvl/value/shapley/montecarlo.py | 19 +++++-------------- src/pydvl/value/shapley/truncated.py | 4 ++-- 2 files changed, 7 insertions(+), 16 deletions(-) diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index b07a03f5d..b2e757068 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -111,16 +111,10 @@ def _permutation_montecarlo_shapley( def _permutation_montecarlo_one_step( - u: Utility, - truncation: TruncationPolicy, - algorithm: str, + u: Utility, truncation: TruncationPolicy, algorithm: str ) -> ValuationResult: - result = _permutation_montecarlo_shapley( - u, - done=MaxChecks(1), - truncation=truncation, - algorithm_name=algorithm, + u, done=MaxChecks(1), truncation=truncation, algorithm_name=algorithm ) nans = np.isnan(result.values).sum() if nans > 0: @@ -134,8 +128,8 @@ def _permutation_montecarlo_one_step( @deprecated( target=True, - deprecated_in="0.6.2", - remove_in="0.7.0", + deprecated_in="0.7.0", + remove_in="0.8.0", args_mapping=dict( coordinator_update_period=None, worker_update_period=None, progress=None ), @@ -218,10 +212,7 @@ def permutation_montecarlo_shapley( # Ensure that we always have n_submitted_jobs in the queue or running for _ in range(n_submitted_jobs - len(futures)): future = executor.submit( - _permutation_montecarlo_one_step, - u, - truncation, - algorithm, + _permutation_montecarlo_one_step, u, truncation, algorithm ) futures.add(future) diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 9c2e89c1b..4f8f45b12 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -168,8 +168,8 @@ def reset(self): @deprecated( target=True, - deprecated_in="0.6.2", - remove_in="0.7.0", + deprecated_in="0.7.0", + remove_in="0.8.0", args_mapping=dict(coordinator_update_period=None, worker_update_period=None), ) def truncated_montecarlo_shapley( From dc781d57cbc222152a87e6b41c695c20df9c73a0 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 18 Aug 2023 23:05:31 +0200 Subject: [PATCH 260/436] [skip ci] Change more deprecation versions --- src/pydvl/utils/parallel/futures/ray.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index c90837543..216e88344 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -46,8 +46,8 @@ class RayExecutor(Executor): @deprecated( target=True, - deprecated_in="0.6.2", - remove_in="0.7", + deprecated_in="0.7.0", + remove_in="0.8.0", args_mapping={"cancel_futures_on_exit": "cancel_futures"}, ) def __init__( From e8f2aef273a5d7242e91da0864112427f30ebf09 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Sat, 19 Aug 2023 09:51:53 +0200 Subject: [PATCH 261/436] Fix import issue for tests --- src/pydvl/influence/torch/__init__.py | 1 + src/pydvl/influence/torch/torch_differentiable.py | 1 + tests/influence/test_influences.py | 4 +--- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/pydvl/influence/torch/__init__.py b/src/pydvl/influence/torch/__init__.py index 40e3dfc24..1f431d57b 100644 --- a/src/pydvl/influence/torch/__init__.py +++ b/src/pydvl/influence/torch/__init__.py @@ -1,6 +1,7 @@ from .torch_differentiable import ( TorchTwiceDifferentiable, as_tensor, + model_hessian_low_rank, solve_arnoldi, solve_batch_cg, solve_linear, diff --git a/src/pydvl/influence/torch/torch_differentiable.py b/src/pydvl/influence/torch/torch_differentiable.py index 755e39cda..5045c8909 100644 --- a/src/pydvl/influence/torch/torch_differentiable.py +++ b/src/pydvl/influence/torch/torch_differentiable.py @@ -35,6 +35,7 @@ "solve_arnoldi", "lanzcos_low_rank_hessian_approx", "as_tensor", + "model_hessian_low_rank", ] logger = logging.getLogger(__name__) diff --git a/tests/influence/test_influences.py b/tests/influence/test_influences.py index 290c7f0a5..ca953f43e 100644 --- a/tests/influence/test_influences.py +++ b/tests/influence/test_influences.py @@ -4,8 +4,6 @@ import numpy as np import pytest -from pydvl.influence.torch.torch_differentiable import model_hessian_low_rank - torch = pytest.importorskip("torch") import torch import torch.nn.functional as F @@ -15,7 +13,7 @@ from torch.utils.data import DataLoader, TensorDataset from pydvl.influence import InfluenceType, InversionMethod, compute_influences -from pydvl.influence.torch import TorchTwiceDifferentiable +from pydvl.influence.torch import TorchTwiceDifferentiable, model_hessian_low_rank from .conftest import ( add_noise_to_linear_model, From b33162a14aa938c5b08cf83fe4e4c5fe4b2a3f74 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 19 Aug 2023 11:56:46 +0200 Subject: [PATCH 262/436] Fix handling of boolean CancellationPolicy --- src/pydvl/utils/parallel/futures/ray.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 216e88344..bcfd5d0cb 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -66,7 +66,14 @@ def __init__( raise ValueError("max_workers must be greater than 0") max_workers = max_workers - self._cancel_futures = cancel_futures + if isinstance(cancel_futures, CancellationPolicy): + self._cancel_futures = cancel_futures + else: + self._cancel_futures = ( + CancellationPolicy.PENDING + if cancel_futures + else CancellationPolicy.NONE + ) config_dict = asdict(config) config_dict.pop("backend") From 86cd9b7fc3f00b6a7967abd62d02af602c42aa0f Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 19 Aug 2023 11:57:36 +0200 Subject: [PATCH 263/436] functools partial cannot be made into a ray remote --- src/pydvl/value/semivalues.py | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 0d4c49aa4..77ba6336c 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -46,7 +46,6 @@ import math from enum import Enum -from functools import partial from typing import Protocol, Tuple, Type, TypeVar, cast import numpy as np @@ -144,7 +143,6 @@ def semivalues( n_submitted_jobs = 2 * max_workers # number of jobs in the queue sampler_it = iter(sampler) - job = partial(_marginal, u=u, coefficient=correction) pbar = tqdm(disable=not progress, total=100, unit="%") with init_executor( @@ -165,7 +163,14 @@ def semivalues( # Ensure that we always have n_submitted_jobs running try: for _ in range(n_submitted_jobs - len(pending)): - pending.add(executor.submit(job, sample=next(sampler_it))) + pending.add( + executor.submit( + _marginal, + u=u, + coefficient=correction, + sample=next(sampler_it), + ) + ) except StopIteration: if len(pending) == 0: return result From ab71dc78586f506b075b213baa92c91dc9c03d88 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 19 Aug 2023 12:09:50 +0200 Subject: [PATCH 264/436] Incrase tolerances to speed up tests --- tests/value/test_semivalues.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index 0efefdc51..ed2456fa0 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -48,7 +48,7 @@ def test_shapley( parallel_config: ParallelConfig, ): u, exact_values = analytic_shapley - criterion = AbsoluteStandardError(0.02, 1.0) | MaxUpdates(2 ** (num_samples * 2)) + criterion = AbsoluteStandardError(0.05, 1.0) | MaxUpdates(2 ** (num_samples * 2)) values = semivalues( sampler(u.data.indices), u, @@ -57,7 +57,7 @@ def test_shapley( n_jobs=n_jobs, config=parallel_config, ) - check_values(values, exact_values, rtol=0.15) + check_values(values, exact_values, rtol=0.2) @pytest.mark.parametrize("num_samples", [5]) @@ -83,11 +83,11 @@ def test_banzhaf( sampler(u.data.indices), u, banzhaf_coefficient, - AbsoluteStandardError(0.02, 1.0) | MaxUpdates(2**10), + AbsoluteStandardError(0.05, 1.0) | MaxUpdates(2**10), n_jobs=n_jobs, config=parallel_config, ) - check_values(values, exact_values, rtol=0.15) + check_values(values, exact_values, rtol=0.2) @pytest.mark.parametrize("n", [10, 100]) From 96dcbe68dd3c31d6aa5410e834d4db143e20978d Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 19 Aug 2023 13:35:45 +0200 Subject: [PATCH 265/436] More tweaking of test tolerances --- tests/value/test_semivalues.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index ed2456fa0..d1c956b00 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -48,7 +48,7 @@ def test_shapley( parallel_config: ParallelConfig, ): u, exact_values = analytic_shapley - criterion = AbsoluteStandardError(0.05, 1.0) | MaxUpdates(2 ** (num_samples * 2)) + criterion = AbsoluteStandardError(0.03, 1.0) | MaxUpdates(2 ** (num_samples * 2)) values = semivalues( sampler(u.data.indices), u, @@ -83,7 +83,7 @@ def test_banzhaf( sampler(u.data.indices), u, banzhaf_coefficient, - AbsoluteStandardError(0.05, 1.0) | MaxUpdates(2**10), + AbsoluteStandardError(0.03, 1.0) | MaxUpdates(2**10), n_jobs=n_jobs, config=parallel_config, ) From 2292c8a2eec4516482e22bcda892a07cf5b24ddf Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 19 Aug 2023 13:36:00 +0200 Subject: [PATCH 266/436] Reduce number of local cpus in tests to 4 --- tests/conftest.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/conftest.py b/tests/conftest.py index 41244d275..96ce88c19 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -200,7 +200,7 @@ def num_workers(): if os.getenv("CI"): return 2 # And a maximum of 8 CPUs locally (most tests don't really benefit from more) - return max(1, min(available_cpus() - 1, 8)) + return max(1, min(available_cpus() - 1, 4)) @pytest.fixture From c2d83f67f8f65bb9dae2514988d1471999024aa0 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 19 Aug 2023 13:44:02 +0200 Subject: [PATCH 267/436] Decrease timeout waiting for futures for faster tests --- src/pydvl/utils/config.py | 3 ++- tests/value/conftest.py | 6 +++--- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/src/pydvl/utils/config.py b/src/pydvl/utils/config.py index 0e93c087a..487431403 100644 --- a/src/pydvl/utils/config.py +++ b/src/pydvl/utils/config.py @@ -19,13 +19,14 @@ class ParallelConfig: :param n_cpus_local: Number of CPUs to use when creating a local ray cluster. This has no effect when using an existing ray cluster. :param logging_level: Logging level for the parallel backend's worker. + :param wait_timeout: Timeout in seconds for waiting on futures. """ backend: Literal["joblib", "ray"] = "joblib" address: Optional[Union[str, Tuple[str, int]]] = None n_cpus_local: Optional[int] = None logging_level: int = logging.WARNING - wait_timeout: float = 5.0 + wait_timeout: float = 1.0 def __post_init__(self) -> None: # FIXME: this is specific to ray diff --git a/tests/value/conftest.py b/tests/value/conftest.py index f806b3bb6..f64a0f80a 100644 --- a/tests/value/conftest.py +++ b/tests/value/conftest.py @@ -126,13 +126,13 @@ def linear_shapley(linear_dataset, scorer, n_jobs): @pytest.fixture(scope="module", params=["joblib", "ray-local", "ray-external"]) def parallel_config(request): if "ray" not in request.param: - yield ParallelConfig(backend=request.param) + yield ParallelConfig(backend=request.param, wait_timeout=0.1) elif request.param == "ray-local": - yield ParallelConfig(backend="ray") + yield ParallelConfig(backend="ray", wait_timeout=0.1) ray.shutdown() elif request.param == "ray-external": # Starts a head-node for the cluster. cluster = Cluster(initialize_head=True, head_node_args={"num_cpus": 4}) - yield ParallelConfig(backend="ray", address=cluster.address) + yield ParallelConfig(backend="ray", address=cluster.address, wait_timeout=0.1) ray.shutdown() cluster.shutdown() From 5f9caa35b70d8e6136e6c975f5b637d3b1d7edf7 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 19 Aug 2023 13:44:55 +0200 Subject: [PATCH 268/436] Yet another tolerance tweak --- tests/value/test_semivalues.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index d1c956b00..19a6c2845 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -48,7 +48,7 @@ def test_shapley( parallel_config: ParallelConfig, ): u, exact_values = analytic_shapley - criterion = AbsoluteStandardError(0.03, 1.0) | MaxUpdates(2 ** (num_samples * 2)) + criterion = AbsoluteStandardError(0.04, 1.0) | MaxUpdates(2 ** (num_samples * 2)) values = semivalues( sampler(u.data.indices), u, @@ -83,7 +83,7 @@ def test_banzhaf( sampler(u.data.indices), u, banzhaf_coefficient, - AbsoluteStandardError(0.03, 1.0) | MaxUpdates(2**10), + AbsoluteStandardError(0.04, 1.0) | MaxUpdates(2 ** (num_samples * 2)), n_jobs=n_jobs, config=parallel_config, ) From 8c346bd81c4f4d7abbd1d91b5bb66635f6393210 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 19 Aug 2023 14:16:09 +0200 Subject: [PATCH 269/436] =?UTF-8?q?Yet=20more=20tweaks=20for=20test=20spee?= =?UTF-8?q?d=20=F0=9F=90=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tests/utils/test_caching.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/utils/test_caching.py b/tests/utils/test_caching.py index ca6f1732f..aae0dd416 100644 --- a/tests/utils/test_caching.py +++ b/tests/utils/test_caching.py @@ -139,9 +139,9 @@ def foo_no_cache(indices: NDArray[np.int_]) -> float: assert fast_time < slow_time -@pytest.mark.parametrize("n, atol", [(10, 4), (20, 10)]) +@pytest.mark.parametrize("n, atol", [(10, 5), (20, 10)]) @pytest.mark.parametrize("n_jobs", [1, 2]) -@pytest.mark.parametrize("n_runs", [100]) +@pytest.mark.parametrize("n_runs", [20]) def test_memcached_parallel_repeated_training( memcached_client, n, atol, n_jobs, n_runs, parallel_config, seed=42 ): From 8d2a7a99ee51e7b28e0ae2be39e6117eefa6501e Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 19 Aug 2023 14:20:47 +0200 Subject: [PATCH 270/436] Fix parsing of new parallel config for ray --- src/pydvl/utils/parallel/futures/ray.py | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index bcfd5d0cb..195c5ab87 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -5,7 +5,6 @@ import time import types from concurrent.futures import Executor, Future -from dataclasses import asdict from typing import Any, Callable, Optional, TypeVar from weakref import WeakSet, ref @@ -75,14 +74,11 @@ def __init__( else CancellationPolicy.NONE ) - config_dict = asdict(config) - config_dict.pop("backend") - n_cpus_local = config_dict.pop("n_cpus_local") - if config_dict.get("address", None) is None: - config_dict["num_cpus"] = n_cpus_local - self.config = config_dict + self.config = {"address": config.address, "logging_level": config.logging_level} + if config.address is None: + self.config["num_cpus"] = config.n_cpus_local + if not ray.is_initialized(): - # FIXME: this couples ParallelConfig to ray's init() parameters ray.init(**self.config) self._max_workers = max_workers From 97bfb4c6fce7fc03cbfbc8c51d2f7d23f6d96225 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 19 Aug 2023 14:23:17 +0200 Subject: [PATCH 271/436] Cosmetic --- src/pydvl/utils/parallel/backend.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index ee5246e4b..34c7a0c89 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -120,8 +120,10 @@ def executor( config: ParallelConfig = ParallelConfig(), cancel_futures: CancellationPolicy = CancellationPolicy.NONE, ) -> Executor: - if cancel_futures is not CancellationPolicy.NONE: - log.warning("CancellationPolicy is not supported by the joblib backend") + if cancel_futures not in (CancellationPolicy.NONE, False): + log.warning( + "Cancellation of futures is not supported by the joblib backend" + ) return cast(Executor, get_reusable_executor(max_workers=max_workers)) def get(self, v: T, *args, **kwargs) -> T: From 548b4158a1ee2fbfbe6db5017b6b6fa1e13c3314 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 19 Aug 2023 14:48:20 +0200 Subject: [PATCH 272/436] =?UTF-8?q?Need=20for=20speed=20=F0=9F=90=8C?= =?UTF-8?q?=F0=9F=8F=81:=20Only=20test=20valuation=20methods=20with=20jobl?= =?UTF-8?q?ib?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tests/value/conftest.py | 16 +++------------- 1 file changed, 3 insertions(+), 13 deletions(-) diff --git a/tests/value/conftest.py b/tests/value/conftest.py index f64a0f80a..f60085518 100644 --- a/tests/value/conftest.py +++ b/tests/value/conftest.py @@ -123,16 +123,6 @@ def linear_shapley(linear_dataset, scorer, n_jobs): return u, exact_values -@pytest.fixture(scope="module", params=["joblib", "ray-local", "ray-external"]) -def parallel_config(request): - if "ray" not in request.param: - yield ParallelConfig(backend=request.param, wait_timeout=0.1) - elif request.param == "ray-local": - yield ParallelConfig(backend="ray", wait_timeout=0.1) - ray.shutdown() - elif request.param == "ray-external": - # Starts a head-node for the cluster. - cluster = Cluster(initialize_head=True, head_node_args={"num_cpus": 4}) - yield ParallelConfig(backend="ray", address=cluster.address, wait_timeout=0.1) - ray.shutdown() - cluster.shutdown() +@pytest.fixture(scope="module") +def parallel_config(num_workers): + yield ParallelConfig(backend="joblib", n_cpus_local=num_workers, wait_timeout=0.1) From e2373c6c7f4157f2e06cb95c54cfcca78db1610c Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 19 Aug 2023 14:48:45 +0200 Subject: [PATCH 273/436] Warn of caching requirement for permutation sampler --- src/pydvl/value/semivalues.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 77ba6336c..15edc1811 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -44,6 +44,7 @@ """ from __future__ import annotations +import logging import math from enum import Enum from typing import Protocol, Tuple, Type, TypeVar, cast @@ -66,6 +67,8 @@ "SemiValueMode", ] +log = logging.getLogger(__name__) + class SVCoefficient(Protocol): """A coefficient for the computation of semi-values.""" @@ -127,6 +130,12 @@ def semivalues( from pydvl.utils import effective_n_jobs, init_executor, init_parallel_backend + if isinstance(sampler, PermutationSampler) and not u.enable_cache: + log.warning( + "PermutationSampler requires caching to be enabled or computation " + "will be doubled wrt. a 'direct' implementation of permutation MC" + ) + result = ValuationResult.zeros( algorithm=f"semivalue-{str(sampler)}-{coefficient.__name__}", indices=u.data.indices, From ba29e0b8f57b5a928159f1311b888d01bf63a55b Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 19 Aug 2023 17:20:09 +0200 Subject: [PATCH 274/436] =?UTF-8?q?Increase=20computation=20time=20in=20te?= =?UTF-8?q?sts=20again=20=F0=9F=A4=A6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tests/value/test_semivalues.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index 19a6c2845..95a0c5777 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -48,7 +48,7 @@ def test_shapley( parallel_config: ParallelConfig, ): u, exact_values = analytic_shapley - criterion = AbsoluteStandardError(0.04, 1.0) | MaxUpdates(2 ** (num_samples * 2)) + criterion = AbsoluteStandardError(0.03, 1.0) | MaxUpdates(2 ** (num_samples * 2)) values = semivalues( sampler(u.data.indices), u, @@ -83,7 +83,7 @@ def test_banzhaf( sampler(u.data.indices), u, banzhaf_coefficient, - AbsoluteStandardError(0.04, 1.0) | MaxUpdates(2 ** (num_samples * 2)), + AbsoluteStandardError(0.03, 1.0) | MaxUpdates(2 ** (num_samples * 2)), n_jobs=n_jobs, config=parallel_config, ) From fc2bf30df5f4916c1cdd084a35c381ae03d440ad Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 19 Aug 2023 20:55:28 +0200 Subject: [PATCH 275/436] Some cleanup and another test tweak --- src/pydvl/value/shapley/common.py | 4 ++-- tests/conftest.py | 3 +-- tests/value/test_semivalues.py | 4 ++-- 3 files changed, 5 insertions(+), 6 deletions(-) diff --git a/src/pydvl/value/shapley/common.py b/src/pydvl/value/shapley/common.py index f6d698bd8..fe43274d5 100644 --- a/src/pydvl/value/shapley/common.py +++ b/src/pydvl/value/shapley/common.py @@ -101,8 +101,8 @@ def compute_shapley_values( ShapleyMode.TruncatedMontecarlo, ): truncation = kwargs.pop("truncation", NoTruncation()) - return truncated_montecarlo_shapley( # type: ignore - u=u, done=done, n_jobs=n_jobs, truncation=truncation, **kwargs + return permutation_montecarlo_shapley( # type: ignore + u=u, done=done, truncation=truncation, n_jobs=n_jobs, **kwargs ) elif mode == ShapleyMode.CombinatorialMontecarlo: return combinatorial_montecarlo_shapley( diff --git a/tests/conftest.py b/tests/conftest.py index 96ce88c19..70f42586e 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -132,7 +132,6 @@ def memcached_service(docker_ip, docker_services, do_not_start_memcache): @pytest.fixture(scope="function") def memcache_client_config(memcached_service) -> MemcachedClientConfig: - client_config = MemcachedClientConfig( server=memcached_service, connect_timeout=1.0, timeout=1, no_delay=True ) @@ -199,7 +198,7 @@ def num_workers(): # Run with 2 CPUs inside GitHub actions if os.getenv("CI"): return 2 - # And a maximum of 8 CPUs locally (most tests don't really benefit from more) + # And a maximum of 4 CPUs locally (most tests don't really benefit from more) return max(1, min(available_cpus() - 1, 4)) diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index 95a0c5777..fe136ec97 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -48,7 +48,7 @@ def test_shapley( parallel_config: ParallelConfig, ): u, exact_values = analytic_shapley - criterion = AbsoluteStandardError(0.03, 1.0) | MaxUpdates(2 ** (num_samples * 2)) + criterion = AbsoluteStandardError(0.02, 1.0) | MaxUpdates(2 ** (num_samples * 2)) values = semivalues( sampler(u.data.indices), u, @@ -83,7 +83,7 @@ def test_banzhaf( sampler(u.data.indices), u, banzhaf_coefficient, - AbsoluteStandardError(0.03, 1.0) | MaxUpdates(2 ** (num_samples * 2)), + AbsoluteStandardError(0.04, 1.0) | MaxUpdates(2 ** (num_samples * 2)), n_jobs=n_jobs, config=parallel_config, ) From dc034599c7a88a30075b4af8472434895fcc2f03 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 19 Aug 2023 21:49:41 +0200 Subject: [PATCH 276/436] Explicit wrapper functions for main semi-values instead of umbrella function and kwargs --- docs/30-data-valuation.rst | 10 +- src/pydvl/value/semivalues.py | 162 ++++++++++++++++++++++++++++++--- tests/value/test_semivalues.py | 24 ----- 3 files changed, 153 insertions(+), 43 deletions(-) diff --git a/docs/30-data-valuation.rst b/docs/30-data-valuation.rst index 471096ef1..0922d6da8 100644 --- a/docs/30-data-valuation.rst +++ b/docs/30-data-valuation.rst @@ -629,13 +629,13 @@ of weights which is reported to work better. .. code-block:: python from pydvl.utils import Dataset, Utility - from pydvl.value import compute_semivalues + from pydvl.value import compute_beta_shapley_semivalues model = ... data = Dataset(...) utility = Utility(model, data) - values = compute_semivalues( - u=utility, mode="beta_shapley", done=MaxUpdates(500), alpha=1, beta=16 + values = compute_beta_shapley_semivalues( + u=utility, alpha=1, beta=16, done=MaxUpdates(500) ) .. _banzhaf indices: @@ -666,12 +666,12 @@ robust to variance in the utility function than Shapley and Beta Shapley values. .. code-block:: python from pydvl.utils import Dataset, Utility - from pydvl.value import compute_semivalues + from pydvl.value import compute_banzhaf_semivalues model = ... data = Dataset(...) utility = Utility(model, data) - values = compute_semivalues( u=utility, mode="banzhaf", done=MaxUpdates(500)) + values = compute_banzhaf_semivalues(u=utility, done=MaxUpdates(500)) .. _problems of data values: diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 15edc1811..6fed44ce4 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -9,13 +9,18 @@ $$\sum_{k=1}^n w(k) = 1.$$ +.. note:: + For implementation consistency, we slightly depart from the common definition + of semi-values, which includes a factor $1/n$ in the sum over subsets. + Instead, we subsume this factor into the coefficient $w(k)$. + As such, the computation of a semi-value requires two components: 1. A **subset sampler** that generates subsets of the set $D$ of interest. 2. A **coefficient** $w(k)$ that assigns a weight to each subset size $k$. Samplers can be found in :mod:`pydvl.value.sampler`, and can be classified into -two categories: powerset samplers and (one) permutation sampler. Powerset +two categories: powerset samplers and permutation samplers. Powerset samplers generate subsets of $D_{-i}$, while the permutation sampler generates permutations of $D$. The former conform to the above definition of semi-values, while the latter reformulates it as: @@ -30,16 +35,18 @@ $\tilde{w}(k) = n \choose{n-1}{k} w(k)$ is the weight correction due to the reformulation. +.. warning:: + :class:`~pydvl.value.sampler.PermutationSampler` and + :class:`~pydvl.value.sampler.DeterministicPermutationSampler` + require caching to be enabled or computation will be doubled wrt. a 'direct' + implementation of permutation MC. There are several pre-defined coefficients, including the Shapley value of :footcite:t:`ghorbani_data_2019`, the Banzhaf index of :footcite:t:`wang_data_2022`, and the Beta coefficient of -:footcite:t:`kwon_beta_2022`. - -.. note:: - For implementation consistency, we slightly depart from the common definition - of semi-values, which includes a factor $1/n$ in the sum over subsets. - Instead, we subsume this factor into the coefficient $w(k)$. +:footcite:t:`kwon_beta_2022`. For each of these methods, there is a convenience +wrapper function. Respectively, these are: :func:`compute_shapley_semivalues`, +:func:`compute_banzhaf_semivalues`, and :func:`compute_beta_shapley_semivalues`. """ from __future__ import annotations @@ -51,6 +58,7 @@ import numpy as np import scipy as sp +from deprecate import deprecated from tqdm import tqdm from pydvl.utils import ParallelConfig, Utility @@ -59,8 +67,11 @@ from pydvl.value.stopping import MaxUpdates, StoppingCriterion __all__ = [ - "banzhaf_coefficient", + "compute_banzhaf_semivalues", + "compute_beta_shapley_semivalues", + "compute_shapley_semivalues", "beta_coefficient", + "banzhaf_coefficient", "shapley_coefficient", "semivalues", "compute_semivalues", @@ -103,6 +114,11 @@ def _marginal(u: Utility, coefficient: SVCoefficient, sample: SampleT) -> Margin return idx, marginal +# @deprecated( +# target=compute_semivalues, # TODO: rename this to compute_semivalues +# deprecated_in="0.8.0", +# remove_in="0.9.0", +# ) def semivalues( sampler: PowersetSampler, u: Utility, @@ -215,12 +231,126 @@ def beta_coefficient_w(n: int, k: int) -> float: return cast(SVCoefficient, beta_coefficient_w) +def compute_shapley_semivalues( + u: Utility, + *, + done: StoppingCriterion = MaxUpdates(100), + sampler_t: Type[PowersetSampler] = PermutationSampler, + n_jobs: int = 1, + config: ParallelConfig = ParallelConfig(), + progress: bool = False, +) -> ValuationResult: + """Computes Shapley values for a given utility function. + + This is a convenience wrapper for :func:`semivalues` with the Shapley + coefficient. Use :func:`~pydvl.value.shapley.common.compute_shapley_values` + for a more flexible interface and additional methods, including Truncated + Monte Carlo. + + :param u: Utility object with model, data, and scoring function. + :param done: Stopping criterion. + :param sampler_t: The sampler type to use. See :mod:`pydvl.value.sampler` + for a list. + :param n_jobs: Number of parallel jobs to use. + :param config: Object configuring parallel computation, with cluster + address, number of cpus, etc. + :param progress: Whether to display a progress bar. + """ + return semivalues( + sampler_t(u.data.indices), + u, + shapley_coefficient, + done, + n_jobs=n_jobs, + config=config, + progress=progress, + ) + + +def compute_banzhaf_semivalues( + u: Utility, + *, + done: StoppingCriterion = MaxUpdates(100), + sampler_t: Type[PowersetSampler] = PermutationSampler, + n_jobs: int = 1, + config: ParallelConfig = ParallelConfig(), + progress: bool = False, +) -> ValuationResult: + """Computes Banzhaf values for a given utility function. + + This is a convenience wrapper for :func:`semivalues` with the Banzhaf + coefficient. + + :param u: Utility object with model, data, and scoring function. + :param done: Stopping criterion. + :param sampler_t: The sampler type to use. See :mod:`pydvl.value.sampler` + for a list. + :param n_jobs: Number of parallel jobs to use. + :param config: Object configuring parallel computation, with cluster + address, number of cpus, etc. + :param progress: Whether to display a progress bar. + """ + return semivalues( + sampler_t(u.data.indices), + u, + banzhaf_coefficient, + done, + n_jobs=n_jobs, + config=config, + progress=progress, + ) + + +def compute_beta_shapley_semivalues( + u: Utility, + *, + alpha: float = 1, + beta: float = 1, + done: StoppingCriterion = MaxUpdates(100), + sampler_t: Type[PowersetSampler] = PermutationSampler, + n_jobs: int = 1, + config: ParallelConfig = ParallelConfig(), + progress: bool = False, +) -> ValuationResult: + """Computes Beta Shapley values for a given utility function. + + This is a convenience wrapper for :func:`semivalues` with the Beta Shapley + coefficient. + + :param u: Utility object with model, data, and scoring function. + :param alpha: Alpha parameter of the Beta distribution. + :param beta: Beta parameter of the Beta distribution. + :param done: Stopping criterion. + :param sampler_t: The sampler type to use. See :mod:`pydvl.value.sampler` + for a list. + :param n_jobs: Number of parallel jobs to use. + :param config: Object configuring parallel computation, with cluster + address, number of cpus, etc. + :param progress: Whether to display a progress bar. + """ + return semivalues( + sampler_t(u.data.indices), + u, + beta_coefficient(alpha, beta), + done, + n_jobs=n_jobs, + config=config, + progress=progress, + ) + + +@deprecated( + target=True, + deprecated_in="0.7.0", + remove_in="0.8.0", +) class SemiValueMode(str, Enum): Shapley = "shapley" BetaShapley = "beta_shapley" Banzhaf = "banzhaf" +@deprecated(target=True, deprecated_in="0.7.0", remove_in="0.8.0") def compute_semivalues( u: Utility, *, @@ -230,14 +360,16 @@ def compute_semivalues( n_jobs: int = 1, **kwargs, ) -> ValuationResult: - """Entry point for most common semi-value computations. All are implemented - with permutation sampling. + """Convenience entry point for most common semi-value computations. - For any other sampling method, use :func:`parallel_semivalues` directly. + .. warning:: + This method is deprecated and will be removed in 0.8.0. Use + :func:`~pydvl.value.semivalues.compute_shapley_semivalues`, + :func:`~pydvl.value.semivalues.compute_banzhaf_semivalues`, or + :func:`~pydvl.value.semivalues.compute_beta_shapley_semivalues`instead - See :ref:`data valuation` for an overview of valuation. - - The modes supported are: + The modes supported with this interface are the following. For greater + flexibility use :func:`~pydvl.value.semivalues.semivalues` directly. - :attr:`SemiValueMode.Shapley`: Shapley values. - :attr:`SemiValueMode.BetaShapley`: Implements the Beta Shapley semi-value @@ -247,6 +379,8 @@ def compute_semivalues( - :attr:`SemiValueMode.Banzhaf`: Implements the Banzhaf semi-value as introduced in :footcite:t:`wang_data_2022`. + See :ref:`data valuation` for an overview of data valuation. + :param u: Utility object with model, data, and scoring function. :param done: Stopping criterion. :param mode: The semi-value mode to use. See :class:`SemiValueMode` for a diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index fe136ec97..8ee802fed 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -111,27 +111,3 @@ def test_coefficients(n: int, coefficient: SVCoefficient): """ s = [math.comb(n - 1, j - 1) * coefficient(n, j - 1) for j in range(1, n + 1)] assert np.isclose(1, np.sum(s)) - - -@pytest.mark.parametrize("num_samples", [5]) -@pytest.mark.parametrize( - "semi_value_mode,semi_value_mode_kwargs", - [ - (SemiValueMode.Shapley, dict()), - (SemiValueMode.BetaShapley, {"alpha": 1, "beta": 16}), - (SemiValueMode.Banzhaf, dict()), - ], - ids=["shapley", "beta-shapley", "banzhaf"], -) -def test_dispatch_compute_semi_values( - dummy_utility: Utility, - semi_value_mode: SemiValueMode, - semi_value_mode_kwargs: Dict[str, int], -): - values = compute_semivalues( - u=dummy_utility, - mode=semi_value_mode, - done=MaxUpdates(1), - **semi_value_mode_kwargs, - n_jobs=1, - ) From 50b8a66c060c7ecdd9d12bfd877eb160d4bba799 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 19 Aug 2023 22:05:11 +0200 Subject: [PATCH 277/436] Docstrings --- src/pydvl/value/semivalues.py | 32 +++++++++++++++++++++----------- 1 file changed, 21 insertions(+), 11 deletions(-) diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 6fed44ce4..f3f9db683 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -36,7 +36,7 @@ reformulation. .. warning:: - :class:`~pydvl.value.sampler.PermutationSampler` and + Both :class:`~pydvl.value.sampler.PermutationSampler` and :class:`~pydvl.value.sampler.DeterministicPermutationSampler` require caching to be enabled or computation will be doubled wrt. a 'direct' implementation of permutation MC. @@ -105,8 +105,10 @@ def _marginal(u: Utility, coefficient: SVCoefficient, sample: SampleT) -> Margin :param u: Utility object with model, data, and scoring function. :param coefficient: The semi-value coefficient and sampler weight - :param sample: A tuple of idx, subset from the sampler to compute its - marginal utility. + :param sample: A tuple of index and subset of indices to compute a marginal + utility. + + :return: tuple with index and its marginal utility. """ n = len(u.data) idx, s = sample @@ -138,9 +140,9 @@ def semivalues( :param n_jobs: Number of parallel jobs to use. :param config: Object configuring parallel computation, with cluster address, number of cpus, etc. - :param progress: Whether to display progress bars for each job. - :return: Object with the results. + :param progress: Whether to display a progress bar. + :return: Object with the results. """ from concurrent.futures import FIRST_COMPLETED, Future, wait @@ -255,6 +257,8 @@ def compute_shapley_semivalues( :param config: Object configuring parallel computation, with cluster address, number of cpus, etc. :param progress: Whether to display a progress bar. + + :return: Object with the results. """ return semivalues( sampler_t(u.data.indices), @@ -281,7 +285,7 @@ def compute_banzhaf_semivalues( This is a convenience wrapper for :func:`semivalues` with the Banzhaf coefficient. - :param u: Utility object with model, data, and scoring function. + :param u: Utility object with model, data, and scoring function. :param done: Stopping criterion. :param sampler_t: The sampler type to use. See :mod:`pydvl.value.sampler` for a list. @@ -289,6 +293,8 @@ def compute_banzhaf_semivalues( :param config: Object configuring parallel computation, with cluster address, number of cpus, etc. :param progress: Whether to display a progress bar. + + :return: Object with the results. """ return semivalues( sampler_t(u.data.indices), @@ -327,6 +333,8 @@ def compute_beta_shapley_semivalues( :param config: Object configuring parallel computation, with cluster address, number of cpus, etc. :param progress: Whether to display a progress bar. + + :return: Object with the results. """ return semivalues( sampler_t(u.data.indices), @@ -366,18 +374,18 @@ def compute_semivalues( This method is deprecated and will be removed in 0.8.0. Use :func:`~pydvl.value.semivalues.compute_shapley_semivalues`, :func:`~pydvl.value.semivalues.compute_banzhaf_semivalues`, or - :func:`~pydvl.value.semivalues.compute_beta_shapley_semivalues`instead + :func:`~pydvl.value.semivalues.compute_beta_shapley_semivalues` instead The modes supported with this interface are the following. For greater flexibility use :func:`~pydvl.value.semivalues.semivalues` directly. - :attr:`SemiValueMode.Shapley`: Shapley values. - :attr:`SemiValueMode.BetaShapley`: Implements the Beta Shapley semi-value - as introduced in :footcite:t:`kwon_beta_2022`. Pass additional keyword - arguments ``alpha`` and ``beta`` to set the parameters of the Beta - distribution (both default to 1). + as introduced in :footcite:t:`kwon_beta_2022`. Pass additional keyword + arguments ``alpha`` and ``beta`` to set the parameters of the Beta + distribution (both default to 1). - :attr:`SemiValueMode.Banzhaf`: Implements the Banzhaf semi-value as - introduced in :footcite:t:`wang_data_2022`. + introduced in :footcite:t:`wang_data_2022`. See :ref:`data valuation` for an overview of data valuation. @@ -390,6 +398,8 @@ def compute_semivalues( :param n_jobs: Number of parallel jobs to use. :param kwargs: Additional keyword arguments passed to :func:`~pydvl.value.semivalues.semivalues`. + + :return: Object with the results. """ sampler_instance = sampler_t(u.data.indices) if mode == SemiValueMode.Shapley: From 690ce5a27d92e5a07ec5f11d6e8966f32bb01439 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 19 Aug 2023 22:07:57 +0200 Subject: [PATCH 278/436] Type fix --- src/pydvl/value/semivalues.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index f3f9db683..52dd88e13 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -84,8 +84,6 @@ class SVCoefficient(Protocol): """A coefficient for the computation of semi-values.""" - __name__: str - def __call__(self, n: int, k: int) -> float: """Computes the coefficient for a given subset size. @@ -155,7 +153,7 @@ def semivalues( ) result = ValuationResult.zeros( - algorithm=f"semivalue-{str(sampler)}-{coefficient.__name__}", + algorithm=f"semivalue-{str(sampler)}-{coefficient.__name__}", # type: ignore indices=u.data.indices, data_names=u.data.data_names, ) From f23aa3e2659a2d721cebe94c75bc05e5b1519f9f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Mon, 21 Aug 2023 08:31:55 +0200 Subject: [PATCH 279/436] Changes due to review suggestions: * improve import statement * improve name of variable --- README.md | 7 +++---- src/pydvl/influence/__init__.py | 1 + src/pydvl/influence/inversion.py | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index d7968d9f7..c2460147d 100644 --- a/README.md +++ b/README.md @@ -112,8 +112,7 @@ import torch from torch import nn from torch.utils.data import DataLoader, TensorDataset -from pydvl.influence import TorchTwiceDifferentiable, compute_influences -from pydvl.influence.inversion import InversionMethod +from pydvl.influence import TorchTwiceDifferentiable, compute_influences, InversionMethod nn_architecture = nn.Sequential( nn.Conv2d(in_channels=5, out_channels=3, kernel_size=3), @@ -121,7 +120,7 @@ nn_architecture = nn.Sequential( nn.Linear(27, 3), ) loss = nn.MSELoss() -influence_model = TorchTwiceDifferentiable(nn_architecture, loss) +model = TorchTwiceDifferentiable(nn_architecture, loss) input_dim = (5, 5, 5) output_dim = 3 @@ -136,7 +135,7 @@ test_data_loader = DataLoader( ) influences = compute_influences( - influence_model, + model, training_data=train_data_loader, test_data=test_data_loader, progress=True, diff --git a/src/pydvl/influence/__init__.py b/src/pydvl/influence/__init__.py index 570c4056a..a0d8f48da 100644 --- a/src/pydvl/influence/__init__.py +++ b/src/pydvl/influence/__init__.py @@ -9,3 +9,4 @@ """ from .frameworks import TorchTwiceDifferentiable, TwiceDifferentiable from .general import compute_influence_factors, compute_influences +from .inversion import InversionMethod diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 4580e3b71..b87e415c9 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -15,7 +15,7 @@ solve_lissa, ) -__all__ = ["solve_hvp"] +__all__ = ["solve_hvp", "InversionMethod"] from .frameworks.torch_differentiable import solve_arnoldi From 6404523f97d0fc099f3a99f6d75588a91ec802f6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Mon, 21 Aug 2023 09:00:05 +0200 Subject: [PATCH 280/436] Incorporate review suggestions: * improve format * improve naming --- CHANGELOG.md | 3 +- src/pydvl/influence/general.py | 3 +- src/pydvl/influence/inversion.py | 30 ++++++---- src/pydvl/influence/torch/functional.py | 2 +- .../influence/torch/torch_differentiable.py | 60 ++++++++++--------- 5 files changed, 56 insertions(+), 42 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d7cdc690a..2b9e9e454 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,7 +15,8 @@ - Improvements to IF documentation [PR #371](https://github.com/appliedAI-Initiative/pyDVL/pull/371) - Major changes to IF interface and functionality - [PR #278](https://github.com/appliedAI-Initiative/pyDVL/pull/278) [PR #394](https://github.com/appliedAI-Initiative/pyDVL/pull/394) + [PR #278](https://github.com/appliedAI-Initiative/pyDVL/pull/278) + [PR #394](https://github.com/appliedAI-Initiative/pyDVL/pull/394) - **New Method**: Implements solving the hessian equation via spectral low-rank approximation [PR #365](https://github.com/appliedAI-Initiative/pyDVL/pull/365) - **Breaking Changes**: diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 58b8552ee..9b52e81cd 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -48,7 +48,8 @@ def compute_influence_factors( :param model: A model wrapped in the TwiceDifferentiable interface. :param training_data: A DataLoader containing the training data. :param test_data: A DataLoader containing the test data. - :param inversion_method: name of method for computing inverse hessian vector products + :param inversion_method: name of method for computing inverse hessian vector + products. :param hessian_perturbation: regularization of the hessian :param progress: If True, display progress bars. :returns: An array of size (N, D) containing the influence factors for each diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 9ac928944..870ded24d 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -61,7 +61,7 @@ def solve_hvp( i.e. it returns $x$ such that $Ax = b$, and a dictionary containing information about the inversion process. """ - return InversionRegistry.call_registered( + return InversionRegistry.call( inversion_method, model, training_data, @@ -89,13 +89,16 @@ def register( Register a function for a specific model type and inversion method. The function to be registered must conform to the following signature: - `(model: TwiceDifferentiable, training_data: DataLoaderType, b: TensorType, hessian_perturbation: float = 0.0, ...)`. + `(model: TwiceDifferentiable, training_data: DataLoaderType, b: TensorType, + hessian_perturbation: float = 0.0, ...)`. :param model_type: The type of the model the function should be registered for. - :param inversion_method: The inversion method the function should be registered for. - :param overwrite: If True, allows overwriting of an existing registered function for the same model type and inversion method. - If False, logs a warning when attempting to register a function for an already registered model type and inversion method. - + :param inversion_method: The inversion method the function should be + registered for. + :param overwrite: If ``True``, allows overwriting of an existing registered + function for the same model type and inversion method. If ``False``, + logs a warning when attempting to register a function for an already + registered model type and inversion method. :raises TypeError: If the provided model_type or inversion_method are of the wrong type. :raises ValueError: If the function to be registered does not match the required signature. @@ -103,10 +106,15 @@ def register( """ if not isinstance(model_type, type): - raise TypeError(f"'model_type' must be a Type[TwiceDifferentiable]") + raise TypeError( + f"'model_type' is of type {type(model_type)} but should be a Type[TwiceDifferentiable]" + ) if not isinstance(inversion_method, InversionMethod): - raise TypeError(f"'inversion_method' must be an InversionMethod") + raise TypeError( + f"'inversion_method' must be an 'InversionMethod' " + f"but has type {type(inversion_method)} instead." + ) key = (model_type, inversion_method) @@ -145,7 +153,7 @@ def wrapper(*args, **kwargs): return decorator @classmethod - def get_registered( + def get( cls, model_type: Type[TwiceDifferentiable], inversion_method: InversionMethod ) -> Callable[ [TwiceDifferentiable, DataLoaderType, TensorType, float], InverseHvpResult @@ -157,7 +165,7 @@ def get_registered( return method @classmethod - def call_registered( + def call( cls, inversion_method: InversionMethod, model: TwiceDifferentiable, @@ -181,6 +189,6 @@ def call_registered( information about the inversion process. """ - return cls.get_registered(type(model), inversion_method)( + return cls.get(type(model), inversion_method)( model, training_data, b, hessian_perturbation, **kwargs ) diff --git a/src/pydvl/influence/torch/functional.py b/src/pydvl/influence/torch/functional.py index f8643485f..f1b042032 100644 --- a/src/pydvl/influence/torch/functional.py +++ b/src/pydvl/influence/torch/functional.py @@ -77,9 +77,9 @@ def batch_hvp_gen( for inputs, targets in iter(data_loader): batch_loss = batch_loss_function(model, loss, inputs, targets) + model_params = dict(model.named_parameters()) def batch_hvp(vec: torch.Tensor): - model_params = dict(model.named_parameters()) return flatten_tensors_to_vector( hvp( batch_loss, diff --git a/src/pydvl/influence/torch/torch_differentiable.py b/src/pydvl/influence/torch/torch_differentiable.py index 5045c8909..a140c75d9 100644 --- a/src/pydvl/influence/torch/torch_differentiable.py +++ b/src/pydvl/influence/torch/torch_differentiable.py @@ -103,7 +103,7 @@ def hessian(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: """Calculates the explicit hessian of model parameters given data ($x$ and $y$). :param x: A matrix [NxD] representing the features $x_i$. :param y: A matrix [NxK] representing the target values $y_i$. - :returns: A tensor representing the hessian of the model, i.e. the second derivative wrt. the model parameters. + :returns: A tensor representing the hessian of the loss wrt. the model parameters. """ def model_func(param): @@ -212,33 +212,37 @@ def lanzcos_low_rank_hessian_approx( torch_dtype: torch.dtype = None, ) -> LowRankProductRepresentation: """ - Calculates a low-rank approximation of the Hessian matrix of a scalar-valued function using the implicitly - restarted Lanczos algorithm. - - - - :param hessian_vp: A function that takes a vector and returns the product of the Hessian of the loss function - :param matrix_shape: The shape of the matrix, represented by hessian vector product. - :param hessian_perturbation: Optional regularization parameter added to the Hessian-vector product - for numerical stability. - :param rank_estimate: The number of eigenvalues and corresponding eigenvectors to compute. - Represents the desired rank of the Hessian approximation. - :param krylov_dimension: The number of Krylov vectors to use for the Lanczos method. - If not provided, it defaults to $min(model.num_parameters, max(2*rank_estimate + 1, 20))$. - :param tol: The stopping criteria for the Lanczos algorithm, which stops when the difference - in the approximated eigenvalue is less than `tol`. Defaults to 1e-6. - :param max_iter: The maximum number of iterations for the Lanczos method. If not provided, it defaults to - $10*model.num_parameters$ + Calculates a low-rank approximation of the Hessian matrix of a scalar-valued + function using the implicitly restarted Lanczos algorithm. + + :param hessian_vp: A function that takes a vector and returns the product of + the Hessian of the loss function. + :param matrix_shape: The shape of the matrix, represented by hessian vector + product. + :param hessian_perturbation: Optional regularization parameter added to the + Hessian-vector product for numerical stability. + :param rank_estimate: The number of eigenvalues and corresponding eigenvectors + to compute. Represents the desired rank of the Hessian approximation. + :param krylov_dimension: The number of Krylov vectors to use for the Lanczos + method. If not provided, it defaults to + $min(model.num_parameters, max(2*rank_estimate + 1, 20))$. + :param tol: The stopping criteria for the Lanczos algorithm, which stops when + the difference in the approximated eigenvalue is less than ``tol``. + Defaults to 1e-6. + :param max_iter: The maximum number of iterations for the Lanczos method. If + not provided, it defaults to ``10 * model.num_parameters``. :param device: The device to use for executing the hessian vector product. - :param eigen_computation_on_gpu: If True, tries to execute the eigen pair approximation on the provided - device via cupy implementation. - Make sure, that either your model is small enough or you use a - small rank_estimate to fit your device's memory. - If False, the eigen pair approximation is executed on the CPU by scipy wrapper to - ARPACK. - :param torch_dtype: if not provided, current torch default dtype is used for conversion to torch - :return: A `LowRankProductRepresentation` instance that contains the top (up until rank_estimate) eigenvalues - and corresponding eigenvectors of the Hessian. + :param eigen_computation_on_gpu: If ``True``, tries to execute the eigen pair + approximation on the provided device via `cupy `_ + implementation. Make sure that either your model is small enough, or you + use a small rank_estimate to fit your device's memory. If ``False``, the + eigen pair approximation is executed on the CPU with scipy's wrapper to + ARPACK. + :param torch_dtype: if not provided, current torch default dtype is used for + conversion to torch. + + :return: An object that contains the top- ``rank_estimate`` eigenvalues and + corresponding eigenvectors of the Hessian. """ torch_dtype = torch.get_default_dtype() if torch_dtype is None else torch_dtype @@ -366,7 +370,7 @@ class TorchTensorUtilities(TensorUtilities[torch.Tensor]): twice_differentiable_type = TorchTwiceDifferentiable @staticmethod - def einsum(equation, *operands) -> torch.Tensor: + def einsum(equation: str, *operands) -> torch.Tensor: """Sums the product of the elements of the input :attr:`operands` along dimensions specified using a notation based on the Einstein summation convention. """ From 57e9e274b8f117f30be99ff64a853168598920f1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Tue, 22 Aug 2023 10:14:34 +0200 Subject: [PATCH 281/436] Refactor TensorUtilities: * add missing methods to interface, remove obsolete ones, make cat preallocate tensor * add DataLoaderUtilities concept --- src/pydvl/influence/general.py | 88 +++++++---- src/pydvl/influence/inversion.py | 12 +- .../influence/torch/torch_differentiable.py | 81 +++++++--- src/pydvl/influence/twice_differentiable.py | 139 +++++++++++++++--- 4 files changed, 247 insertions(+), 73 deletions(-) diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 9b52e81cd..1e90d7ba5 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -4,11 +4,18 @@ """ from copy import deepcopy from enum import Enum -from typing import Any, Callable, Dict, Optional, Type +from typing import Any, Callable, Dict, Generator, Optional, Type from ..utils import maybe_progress -from .inversion import DataLoaderType, InverseHvpResult, InversionMethod, solve_hvp -from .twice_differentiable import TensorType, TensorUtilities, TwiceDifferentiable +from .inversion import InverseHvpResult, InversionMethod, solve_hvp +from .twice_differentiable import ( + DataLoaderType, + DataLoaderUtilities, + ModelType, + TensorType, + TensorUtilities, + TwiceDifferentiable, +) __all__ = ["compute_influences", "InfluenceType", "compute_influence_factors"] @@ -58,26 +65,36 @@ def compute_influence_factors( tensor_util: Type[TensorUtilities] = TensorUtilities.from_twice_differentiable( model ) + data_loader_util: Type[DataLoaderUtilities] = DataLoaderUtilities.from_data_loader( + test_data + ) + stack = tensor_util.stack unsqueeze = tensor_util.unsqueeze - cat = tensor_util.cat + cat_gen = tensor_util.cat_gen + len_data = data_loader_util.len_data + + def test_grads() -> Generator[TensorType, None, None]: + for x_test, y_test in maybe_progress( + test_data, progress, desc="Batch Test Gradients" + ): + yield stack( + [ + model.grad(inpt, target) + for inpt, target in zip(unsqueeze(x_test, 1), y_test) + ] + ) # type:ignore + + resulting_shape = (len_data(test_data), model.num_params) # type:ignore + rhs = cat_gen( + test_grads(), resulting_shape, model # type:ignore + ) # type:ignore - test_grads = [] - for x_test, y_test in maybe_progress( - test_data, progress, desc="Batch Test Gradients" - ): - test_grad = stack( - [ - model.grad(inpt, target) - for inpt, target in zip(unsqueeze(x_test, 1), y_test) - ] - ) - test_grads.append(test_grad) return solve_hvp( inversion_method, model, training_data, - cat(test_grads), + rhs, hessian_perturbation=hessian_perturbation, **kwargs, ) @@ -111,21 +128,27 @@ def compute_influences_up( tensor_util: Type[TensorUtilities] = TensorUtilities.from_twice_differentiable( model ) + data_loader_util: Type[DataLoaderUtilities] = DataLoaderUtilities.from_data_loader( + input_data + ) + stack = tensor_util.stack unsqueeze = tensor_util.unsqueeze - cat = tensor_util.cat + cat_gen = tensor_util.cat_gen einsum = tensor_util.einsum + len_data = data_loader_util.len_data - train_grads = [] - for x, y in maybe_progress( - input_data, progress, desc="Batch Split Input Gradients" - ): - train_grad = stack( - [model.grad(inpt, target) for inpt, target in zip(unsqueeze(x, 1), y)] - ) - train_grads.append(train_grad) + def train_grads() -> Generator[TensorType, None, None]: + for x, y in maybe_progress( + input_data, progress, desc="Batch Split Input Gradients" + ): + yield stack( + [model.grad(inpt, target) for inpt, target in zip(unsqueeze(x, 1), y)] + ) # type:ignore - return einsum("ta,va->tv", influence_factors, cat(train_grads)) # type: ignore # ToDO fix typing + resulting_shape = (len_data(input_data), model.num_params) # type:ignore + train_grad_tensor = cat_gen(train_grads(), resulting_shape, model) # type:ignore + return einsum("ta,va->tv", influence_factors, train_grad_tensor) # type:ignore def compute_influences_pert( @@ -157,6 +180,10 @@ def compute_influences_pert( model ) stack = tensor_util.stack + tu_slice = tensor_util.slice + reshape = tensor_util.reshape + get_element = tensor_util.get_element + shape = tensor_util.shape all_pert_influences = [] for x, y in maybe_progress( @@ -165,19 +192,18 @@ def compute_influences_pert( desc="Batch Influence Perturbation", ): for i in range(len(x)): - tensor_x = x[i : i + 1] - tensor_x = tensor_x.requires_grad_(True) - grad_xy = model.grad(tensor_x, y[i], create_graph=True) + tensor_x = tu_slice(x, i, i + 1) + grad_xy = model.grad(tensor_x, get_element(y, i), create_graph=True) perturbation_influences = model.mvp( grad_xy, influence_factors, backprop_on=tensor_x, ) all_pert_influences.append( - perturbation_influences.reshape((-1, *x[i].shape)) + reshape(perturbation_influences, (-1, *shape(get_element(x, i)))) ) - return stack(all_pert_influences, axis=1) # type: ignore # ToDO fix typing + return stack(all_pert_influences, axis=1) # type:ignore influence_type_registry: Dict[InfluenceType, Callable[..., TensorType]] = { diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 5ec868c1c..27cf7ff60 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -5,22 +5,24 @@ import logging import warnings from enum import Enum -from typing import Any, Callable, Dict, Iterable, Tuple, Type, TypeVar +from typing import Any, Callable, Dict, Tuple, Type __all__ = [ "solve_hvp", "InversionMethod", "InversionRegistry", - "DataLoaderType", "InverseHvpResult", ] -from .twice_differentiable import InverseHvpResult, TensorType, TwiceDifferentiable +from .twice_differentiable import ( + DataLoaderType, + InverseHvpResult, + TensorType, + TwiceDifferentiable, +) logger = logging.getLogger(__name__) -DataLoaderType = TypeVar("DataLoaderType", bound=Iterable) - class InversionMethod(str, Enum): """ diff --git a/src/pydvl/influence/torch/torch_differentiable.py b/src/pydvl/influence/torch/torch_differentiable.py index a140c75d9..c6b03c0f8 100644 --- a/src/pydvl/influence/torch/torch_differentiable.py +++ b/src/pydvl/influence/torch/torch_differentiable.py @@ -7,7 +7,7 @@ import logging from dataclasses import dataclass from functools import partial -from typing import Callable, List, Optional, Sequence, Tuple +from typing import Callable, Generator, List, Optional, Sequence, Tuple import torch import torch.nn as nn @@ -18,9 +18,12 @@ from torch.utils.data import DataLoader from ...utils import maybe_progress -from ..inversion import InversionMethod, InversionRegistry +from ..inversion import DataLoaderType, InversionMethod, InversionRegistry from ..twice_differentiable import ( + DataLoaderUtilities, InverseHvpResult, + ModelType, + TensorType, TensorUtilities, TwiceDifferentiable, ) @@ -49,7 +52,7 @@ def __init__( ): r""" :param model: A (differentiable) function. - :param loss: :param loss: A differentiable scalar loss $L(\hat{y}, y)$, + :param loss: A differentiable scalar loss $L(\hat{y}, y)$, mapping a prediction and a target to a real value. """ if model.training: @@ -60,7 +63,9 @@ def __init__( ) self.loss = loss self.model = model - self.device = model.device if hasattr(model, "device") else torch.device("cpu") + first_param = next(model.parameters()) + self.device = first_param.device + self.dtype = first_param.dtype @classmethod def tensor_type(cls): @@ -93,6 +98,9 @@ def grad( x = x.to(self.device) y = y.to(self.device) + if create_graph and not x.requires_grad: + x = x.requires_grad_(True) + loss_value = self.loss(torch.squeeze(self.model(x)), torch.squeeze(y)) grad_f = torch.autograd.grad( loss_value, self.parameters, create_graph=create_graph @@ -286,7 +294,6 @@ def mv(x): to_torch_conversion_function = partial(torch.as_tensor, dtype=torch_dtype) try: - eigen_vals, eigen_vecs = eigsh( LinearOperator(matrix_shape, matvec=mv), k=rank_estimate, @@ -365,8 +372,7 @@ def model_hessian_low_rank( ) -class TorchTensorUtilities(TensorUtilities[torch.Tensor]): - +class TorchTensorUtilities(TensorUtilities[torch.Tensor, TorchTwiceDifferentiable]): twice_differentiable_type = TorchTwiceDifferentiable @staticmethod @@ -376,11 +382,6 @@ def einsum(equation: str, *operands) -> torch.Tensor: """ return torch.einsum(equation, *operands) - @staticmethod - def cat(a: Sequence[torch.Tensor], **kwargs) -> torch.Tensor: - """Concatenates a sequence of tensors into a single torch tensor""" - return torch.cat(a, **kwargs) - @staticmethod def stack(a: Sequence[torch.Tensor], **kwargs) -> torch.Tensor: """Stacks a sequence of tensors into a single torch tensor""" @@ -398,9 +399,57 @@ def unsqueeze(x: torch.Tensor, dim: int) -> torch.Tensor: return x.unsqueeze(dim) @staticmethod - def eye(dim: int, **kwargs) -> torch.Tensor: - """Identity tensor of dimension dim""" - return torch.eye(dim, dim, **kwargs) + def get_element(x: torch.Tensor, idx: int) -> torch.Tensor: + return x[idx] + + @staticmethod + def slice(x: torch.Tensor, start: int, stop: int, axis: int = 0) -> torch.Tensor: + slicer = [slice(None) for _ in x.shape] + slicer[axis] = slice(start, stop) + return x[tuple(slicer)] + + @staticmethod + def shape(x: torch.Tensor) -> Tuple[int, ...]: + return x.shape # type:ignore + + @staticmethod + def reshape(x: torch.Tensor, shape: Tuple[int, ...]) -> torch.Tensor: + return x.reshape(shape) + + @staticmethod + def cat_gen( + a: Generator[torch.Tensor, None, None], + resulting_shape: Tuple[int, ...], + model: TorchTwiceDifferentiable, + axis: int = 0, + ) -> torch.Tensor: + result = torch.empty(resulting_shape, dtype=model.dtype, device=model.device) + + start_idx = 0 + for x in a: + stop_idx = start_idx + x.shape[axis] + + slicer = [slice(None) for _ in resulting_shape] + slicer[axis] = slice(start_idx, stop_idx) + + result[tuple(slicer)] = x + + start_idx = stop_idx + + return result + + +class TorchDataLoaderUtilities(DataLoaderUtilities[DataLoader]): + + data_loader_type = DataLoader + + @staticmethod + def len_data(data: DataLoader) -> int: + return len(data.dataset) + + @staticmethod + def batch_size(data: DataLoader) -> int: + return data.batch_size # type:ignore @InversionRegistry.register(TorchTwiceDifferentiable, InversionMethod.Direct) @@ -639,7 +688,6 @@ def solve_arnoldi( max_iter: Optional[int] = None, eigen_computation_on_gpu: bool = False, ) -> InverseHvpResult: - """ Solves the linear system Hx = b, where H is the Hessian of the model's loss function and b is the given right-hand side vector. The Hessian is approximated using a low-rank representation. @@ -676,7 +724,6 @@ def solve_arnoldi( b_device = b.device if hasattr(b, "device") else torch.device("cpu") if low_rank_representation is None: - if b_device.type == "cuda" and not eigen_computation_on_gpu: raise ValueError( "Using 'eigen_computation_on_gpu=False' while 'b' is on a 'cuda' device is not supported. " diff --git a/src/pydvl/influence/twice_differentiable.py b/src/pydvl/influence/twice_differentiable.py index 907a2630e..e68859672 100644 --- a/src/pydvl/influence/twice_differentiable.py +++ b/src/pydvl/influence/twice_differentiable.py @@ -1,8 +1,21 @@ from abc import ABC, abstractmethod from dataclasses import dataclass -from typing import Any, Dict, Generic, List, Sequence, Type, TypeVar +from typing import ( + Any, + Dict, + Generator, + Generic, + Iterable, + List, + Sequence, + Tuple, + Type, + TypeVar, +) TensorType = TypeVar("TensorType", bound=Sequence) +ModelType = TypeVar("ModelType", bound="TwiceDifferentiable") +DataLoaderType = TypeVar("DataLoaderType", bound=Iterable) @dataclass(frozen=True) @@ -95,31 +108,29 @@ def mvp( """ -class TensorUtilities(Generic[TensorType], ABC): +class TensorUtilities(Generic[TensorType, ModelType], ABC): twice_differentiable_type: Type[TwiceDifferentiable] registry: Dict[Type[TwiceDifferentiable], Type["TensorUtilities"]] = {} - def __init_subclass__(cls, abstract: bool = False, **kwargs): + def __init_subclass__(cls, **kwargs): """ Automatically registers non-abstract subclasses in the registry. Checks if `twice_differentiable_type` is defined in the subclass and is of correct type. Raises `TypeError` if either attribute is missing or incorrect. - :param abstract: If True, the subclass won't be registered. Default is False. :param kwargs: Additional keyword arguments. :raise TypeError: If the subclass does not define `twice_differentiable_type`, or if it is not of correct type. """ - if not abstract: - if not hasattr(cls, "twice_differentiable_type") or not isinstance( - cls.twice_differentiable_type, type - ): - raise TypeError( - f"'twice_differentiable_type' must be a Type[TwiceDifferentiable]" - ) + if not hasattr(cls, "twice_differentiable_type") or not isinstance( + cls.twice_differentiable_type, type + ): + raise TypeError( + f"'twice_differentiable_type' must be a Type[TwiceDifferentiable]" + ) - cls.registry[cls.twice_differentiable_type] = cls + cls.registry[cls.twice_differentiable_type] = cls super().__init_subclass__(**kwargs) @@ -130,11 +141,6 @@ def einsum(equation, *operands) -> TensorType: based on the Einstein summation convention. """ - @staticmethod - @abstractmethod - def cat(a: Sequence[TensorType], **kwargs) -> TensorType: - """Concatenates a sequence of tensors into a single torch tensor""" - @staticmethod @abstractmethod def stack(a: Sequence[TensorType], **kwargs) -> TensorType: @@ -147,17 +153,110 @@ def unsqueeze(x: TensorType, dim: int) -> TensorType: @staticmethod @abstractmethod - def eye(dim: int, **kwargs) -> TensorType: - """Identity tensor of dimension dim""" + def get_element(x: TensorType, idx: int) -> TensorType: + """Get the tensor element x[i] from the first non-singular dimension""" + + @staticmethod + @abstractmethod + def slice(x: TensorType, start: int, stop: int, axis: int = 0) -> TensorType: + """Slice a tensor in the provided axis""" + + @staticmethod + @abstractmethod + def shape(x: TensorType) -> Tuple[int, ...]: + """Slice a tensor in the provided axis""" + + @staticmethod + @abstractmethod + def reshape(x: TensorType, shape: Tuple[int, ...]) -> TensorType: + """Reshape a tensor to the provided shape""" + + @staticmethod + @abstractmethod + def cat_gen( + a: Generator[TensorType, None, None], + resulting_shape: Tuple[int, ...], + model: ModelType, + ) -> TensorType: + """Concatenate tensors from a generator. Resulting tensor is of shape resulting_shape + and compatible to model + """ @classmethod def from_twice_differentiable( cls, twice_diff: TwiceDifferentiable, ) -> Type["TensorUtilities"]: + """ + Factory method to create an instance of `TensorUtilities` from an instance of `TwiceDifferentiable`. + + :param twice_diff: An instance of `TwiceDifferentiable` + for which a corresponding `TensorUtilities` object is required. + :return: An instance of `TensorUtilities` corresponding to the provided `TwiceDifferentiable` object. + :raises KeyError: If there's no registered `TensorUtilities` for the provided `TwiceDifferentiable` type. + """ tu = cls.registry.get(type(twice_diff), None) if tu is None: - raise KeyError() + raise KeyError( + f"No registered TensorUtilities for the type {type(twice_diff).__name__}" + ) return tu + + +class DataLoaderUtilities(Generic[DataLoaderType], ABC): + + data_loader_type: Type[DataLoaderType] + registry: Dict[Type[DataLoaderType], Type["DataLoaderUtilities"]] = {} + + def __init_subclass__(cls, **kwargs): + """ + Automatically registers subclasses in the registry. + + Checks if `data_loader_type` is defined in the subclass and + is of correct type. Raises `TypeError` if either attribute is missing or incorrect. + :param kwargs: Additional keyword arguments. + :raise TypeError: If the subclass does not define `twice_differentiable_type`, + or if it is not of correct type. + """ + if not hasattr(cls, "data_loader_type") or not isinstance( + cls.data_loader_type, type + ): + raise TypeError(f"'data_loader_type' must be a type object") + + cls.registry[cls.data_loader_type] = cls + + super().__init_subclass__(**kwargs) + + @staticmethod + @abstractmethod + def len_data(data: DataLoaderType) -> int: + """Get the number of data points""" + + @staticmethod + @abstractmethod + def batch_size(data: DataLoaderType) -> int: + """Get the number of batches for data""" + + @classmethod + def from_data_loader( + cls, + data_loader: DataLoaderType, + ) -> Type["DataLoaderUtilities"]: + """ + Factory method to create an instance of `DataLoaderUtilities` from a given data loader. + + :param data_loader: An instance of data loader for which a corresponding + `DataLoaderUtilities` object is required. + :return: An instance of `DataLoaderUtilities` corresponding to the provided data loader. + :raises KeyError: If there's no registered `DataLoaderUtilities` for the provided data loader type. + """ + dl_u = cls.registry.get(type(data_loader), None) + + if dl_u is None: + raise KeyError( + f"No registered DataLoaderUtilities for the type {type(data_loader).__name__}" + ) + + return dl_u From cf7dc6c194f48827df275a190baa1234607b49ac Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Wed, 23 Aug 2023 10:01:32 +0200 Subject: [PATCH 282/436] [skip ci] Docstring fixes --- src/pydvl/value/sampler.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 2d8398c92..069d50574 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -25,7 +25,7 @@ The samplers can be sliced for parallel computation. For those which are embarrassingly parallel, this is done by slicing the set of "outer" indices and returning new samplers over those slices. This includes all truly powerset-based -samplers, such as :class:`DeterministicCombinatorialSampler` and +samplers, such as :class:`DeterministicUniformSampler` and :class:`UniformSampler`. In contrast, slicing a :class:`PermutationSampler` creates a new sampler which iterates over the same indices. """ @@ -78,7 +78,7 @@ class PowersetSampler(abc.ABC, Iterable[SampleT], Generic[T]): .. code-block:: python - for idx, s in DeterministicCombinatorialSampler(np.arange(2)): + for idx, s in DeterministicUniformSampler(np.arange(2)): print(s, end="") Produces the output:: @@ -220,7 +220,7 @@ def __init__(self, indices: NDArray[T], *args, **kwargs): .. code-block:: python - for idx, s in DeterministicCombinatorialSampler(np.arange(2)): + for idx, s in DeterministicUniformSampler(np.arange(2)): print(f"{idx} - {s}", end=", ") Produces the output:: From 09bbb350767bfc94cade274b10b0befde7240c64 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Wed, 23 Aug 2023 17:02:15 +0200 Subject: [PATCH 283/436] Refactor influence.general: * remove DataLoaderUtilities * try to call len on dataloader for pre-allocating result tensor, fallback to ordinary cat --- src/pydvl/influence/general.py | 46 +++++++++----- .../influence/torch/torch_differentiable.py | 23 ++----- src/pydvl/influence/twice_differentiable.py | 62 ++----------------- 3 files changed, 41 insertions(+), 90 deletions(-) diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 1e90d7ba5..b581514ee 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -2,6 +2,7 @@ This module contains parallelized influence calculation functions for general models, as introduced in :footcite:t:`koh_understanding_2017`. """ +import logging from copy import deepcopy from enum import Enum from typing import Any, Callable, Dict, Generator, Optional, Type @@ -10,8 +11,6 @@ from .inversion import InverseHvpResult, InversionMethod, solve_hvp from .twice_differentiable import ( DataLoaderType, - DataLoaderUtilities, - ModelType, TensorType, TensorUtilities, TwiceDifferentiable, @@ -19,6 +18,8 @@ __all__ = ["compute_influences", "InfluenceType", "compute_influence_factors"] +logger = logging.getLogger(__name__) + class InfluenceType(str, Enum): """ @@ -65,14 +66,11 @@ def compute_influence_factors( tensor_util: Type[TensorUtilities] = TensorUtilities.from_twice_differentiable( model ) - data_loader_util: Type[DataLoaderUtilities] = DataLoaderUtilities.from_data_loader( - test_data - ) stack = tensor_util.stack unsqueeze = tensor_util.unsqueeze cat_gen = tensor_util.cat_gen - len_data = data_loader_util.len_data + cat = tensor_util.cat def test_grads() -> Generator[TensorType, None, None]: for x_test, y_test in maybe_progress( @@ -85,10 +83,18 @@ def test_grads() -> Generator[TensorType, None, None]: ] ) # type:ignore - resulting_shape = (len_data(test_data), model.num_params) # type:ignore - rhs = cat_gen( - test_grads(), resulting_shape, model # type:ignore - ) # type:ignore + try: + # if provided input_data implements __len__, pre-allocate the result tensor to reduce memory consumption + resulting_shape = (len(test_data), model.num_params) # type:ignore + rhs = cat_gen( + test_grads(), resulting_shape, model # type:ignore + ) # type:ignore + except Exception as e: + logger.warning( + f"Failed to pre-allocate result tensor: {e}\n" + f"Evaluate all resulting tensor and concatenate" + ) + rhs = cat(list(test_grads())) return solve_hvp( inversion_method, @@ -128,15 +134,12 @@ def compute_influences_up( tensor_util: Type[TensorUtilities] = TensorUtilities.from_twice_differentiable( model ) - data_loader_util: Type[DataLoaderUtilities] = DataLoaderUtilities.from_data_loader( - input_data - ) stack = tensor_util.stack unsqueeze = tensor_util.unsqueeze cat_gen = tensor_util.cat_gen + cat = tensor_util.cat einsum = tensor_util.einsum - len_data = data_loader_util.len_data def train_grads() -> Generator[TensorType, None, None]: for x, y in maybe_progress( @@ -146,8 +149,19 @@ def train_grads() -> Generator[TensorType, None, None]: [model.grad(inpt, target) for inpt, target in zip(unsqueeze(x, 1), y)] ) # type:ignore - resulting_shape = (len_data(input_data), model.num_params) # type:ignore - train_grad_tensor = cat_gen(train_grads(), resulting_shape, model) # type:ignore + try: + # if provided input_data implements __len__, pre-allocate the result tensor to reduce memory consumption + resulting_shape = (len(input_data), model.num_params) # type:ignore + train_grad_tensor = cat_gen( + train_grads(), resulting_shape, model # type:ignore + ) # type:ignore + except Exception as e: + logger.warning( + f"Failed to pre-allocate result tensor: {e}\n" + f"Evaluate all resulting tensor and concatenate" + ) + train_grad_tensor = cat([x for x in train_grads()]) # type:ignore + return einsum("ta,va->tv", influence_factors, train_grad_tensor) # type:ignore diff --git a/src/pydvl/influence/torch/torch_differentiable.py b/src/pydvl/influence/torch/torch_differentiable.py index c6b03c0f8..1515f3f96 100644 --- a/src/pydvl/influence/torch/torch_differentiable.py +++ b/src/pydvl/influence/torch/torch_differentiable.py @@ -18,12 +18,9 @@ from torch.utils.data import DataLoader from ...utils import maybe_progress -from ..inversion import DataLoaderType, InversionMethod, InversionRegistry +from ..inversion import InversionMethod, InversionRegistry from ..twice_differentiable import ( - DataLoaderUtilities, InverseHvpResult, - ModelType, - TensorType, TensorUtilities, TwiceDifferentiable, ) @@ -382,6 +379,11 @@ def einsum(equation: str, *operands) -> torch.Tensor: """ return torch.einsum(equation, *operands) + @staticmethod + def cat(a: Sequence[torch.Tensor], **kwargs) -> torch.Tensor: + """Concatenates a sequence of tensors into a single torch tensor""" + return torch.cat(a, **kwargs) + @staticmethod def stack(a: Sequence[torch.Tensor], **kwargs) -> torch.Tensor: """Stacks a sequence of tensors into a single torch tensor""" @@ -439,19 +441,6 @@ def cat_gen( return result -class TorchDataLoaderUtilities(DataLoaderUtilities[DataLoader]): - - data_loader_type = DataLoader - - @staticmethod - def len_data(data: DataLoader) -> int: - return len(data.dataset) - - @staticmethod - def batch_size(data: DataLoader) -> int: - return data.batch_size # type:ignore - - @InversionRegistry.register(TorchTwiceDifferentiable, InversionMethod.Direct) def solve_linear( model: TorchTwiceDifferentiable, diff --git a/src/pydvl/influence/twice_differentiable.py b/src/pydvl/influence/twice_differentiable.py index e68859672..37e67e9c6 100644 --- a/src/pydvl/influence/twice_differentiable.py +++ b/src/pydvl/influence/twice_differentiable.py @@ -141,6 +141,11 @@ def einsum(equation, *operands) -> TensorType: based on the Einstein summation convention. """ + @staticmethod + @abstractmethod + def cat(a: Sequence[TensorType], **kwargs) -> TensorType: + """Concatenates a sequence of tensors into a single torch tensor""" + @staticmethod @abstractmethod def stack(a: Sequence[TensorType], **kwargs) -> TensorType: @@ -203,60 +208,3 @@ def from_twice_differentiable( ) return tu - - -class DataLoaderUtilities(Generic[DataLoaderType], ABC): - - data_loader_type: Type[DataLoaderType] - registry: Dict[Type[DataLoaderType], Type["DataLoaderUtilities"]] = {} - - def __init_subclass__(cls, **kwargs): - """ - Automatically registers subclasses in the registry. - - Checks if `data_loader_type` is defined in the subclass and - is of correct type. Raises `TypeError` if either attribute is missing or incorrect. - :param kwargs: Additional keyword arguments. - :raise TypeError: If the subclass does not define `twice_differentiable_type`, - or if it is not of correct type. - """ - if not hasattr(cls, "data_loader_type") or not isinstance( - cls.data_loader_type, type - ): - raise TypeError(f"'data_loader_type' must be a type object") - - cls.registry[cls.data_loader_type] = cls - - super().__init_subclass__(**kwargs) - - @staticmethod - @abstractmethod - def len_data(data: DataLoaderType) -> int: - """Get the number of data points""" - - @staticmethod - @abstractmethod - def batch_size(data: DataLoaderType) -> int: - """Get the number of batches for data""" - - @classmethod - def from_data_loader( - cls, - data_loader: DataLoaderType, - ) -> Type["DataLoaderUtilities"]: - """ - Factory method to create an instance of `DataLoaderUtilities` from a given data loader. - - :param data_loader: An instance of data loader for which a corresponding - `DataLoaderUtilities` object is required. - :return: An instance of `DataLoaderUtilities` corresponding to the provided data loader. - :raises KeyError: If there's no registered `DataLoaderUtilities` for the provided data loader type. - """ - dl_u = cls.registry.get(type(data_loader), None) - - if dl_u is None: - raise KeyError( - f"No registered DataLoaderUtilities for the type {type(data_loader).__name__}" - ) - - return dl_u From 485382849b0d300bfc4dac07ba2911097224571c Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 24 Aug 2023 10:36:18 +0200 Subject: [PATCH 284/436] Add all dev requirements to requirements-dev.txt --- requirements-dev.txt | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/requirements-dev.txt b/requirements-dev.txt index 676f1cc28..d4d2bf620 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -1,18 +1,25 @@ +tox<4.0.0 +tox-wheel +pre-commit==3.1.1 black[jupyter] == 23.1.0 isort == 5.12.0 -jupyter +pylint==2.12.0 +pylint-json2html +anybadge mypy == 0.982 +types-tqdm +pandas-stubs +bump2version +jupyter nbconvert>=7.2.9 nbstripout == 0.6.1 -bump2version -pre-commit==3.1.1 pytest==7.2.2 pytest-cov pytest-docker==2.0.0 pytest-mock pytest-timeout +pytest-lazy-fixture ray[default] >= 0.8 -tox<4.0.0 -tox-wheel -types-tqdm +wheel twine==4.0.2 +bump2version From aa14035269d662f93d842eb82e0223dc5d75ccee Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 24 Aug 2023 10:37:43 +0200 Subject: [PATCH 285/436] Add new composite actions, only use tox for running tests - Composite actions allow to reduce step duplication - Using tox for all steps slows down CI because it has to create and recreate environments --- .github/actions/deploy-docs/action.yml | 36 ++++++++++ .github/actions/python/action.yml | 20 ++++++ .github/workflows/publish.yaml | 41 +++++------ .github/workflows/run-tests-workflow.yaml | 9 +-- .github/workflows/tox.yaml | 85 +++++++++-------------- 5 files changed, 109 insertions(+), 82 deletions(-) create mode 100644 .github/actions/deploy-docs/action.yml create mode 100644 .github/actions/python/action.yml diff --git a/.github/actions/deploy-docs/action.yml b/.github/actions/deploy-docs/action.yml new file mode 100644 index 000000000..7fe82bab3 --- /dev/null +++ b/.github/actions/deploy-docs/action.yml @@ -0,0 +1,36 @@ +name: Deploy Docs +description: Deploy documentation from develop or master branch +inputs: + version: + description: Version number to use + required: true + alias: + description: Alias to use (latest or stable) + required: true + title: + description: Alternative title to use + required: true + email: + description: Email to use for git config + required: true + username: + description: Username to use for git config + required: true + set-default: + description: Set alias as the default version + required: false + default: 'false' +runs: + using: "composite" + steps: + - run: | + # https://github.com/jimporter/mike#deploying-via-ci + git fetch origin gh-pages --depth=1 + git config --local user.email ${{ inputs.email }} + git config --local user.name ${{ inputs.username }} + mike deploy ${{ inputs.version }} ${{ inputs.alias }} --title=${{ inputs.title }} --push --update-aliases + shell: bash + - if: ${{ inputs.set-default == 'true' }} + run: mike set-default ${{ inputs.alias }} + shell: bash + diff --git a/.github/actions/python/action.yml b/.github/actions/python/action.yml new file mode 100644 index 000000000..ee9d66e3e --- /dev/null +++ b/.github/actions/python/action.yml @@ -0,0 +1,20 @@ +name: Setup Python +description: Setup Python on GitHub Actions and install dev and docs requirements. +inputs: + python_version: + description: Python version to use + required: true +runs: + using: "composite" + steps: + - name: Set up Python ${{ inputs.python_version }} + uses: actions/setup-python@v4 + with: + python-version: ${{ inputs.python_version }} + cache: 'pip' + cache-dependency-path: | + requirements-dev.txt + requirements-docs.txt + - name: Install Dev & Docs Requirements + run: pip install -r requirements-dev.txt -r requirements-docs.txt + shell: bash diff --git a/.github/workflows/publish.yaml b/.github/workflows/publish.yaml index 78b67363a..d6b69bc78 100644 --- a/.github/workflows/publish.yaml +++ b/.github/workflows/publish.yaml @@ -58,32 +58,29 @@ jobs: run: | echo "Running action locally. Failing" exit -1 - - name: Set up Python 3.8 - uses: actions/setup-python@v4 + - name: Setup Python 3.8 + uses: ./.github/actions/python with: - python-version: 3.8 - cache: 'pip' - - name: Install Dev Requirements - run: pip install -r requirements-dev.txt - - name: Cache Tox Directory - uses: actions/cache@v3 - with: - key: tox-${{ github.ref }}-${{ runner.os }}-${{ hashFiles('tox.ini') }} - path: .tox - - name: Configure Git - if: ${{ github.ref == 'refs/heads/develop' }} - run: | - git fetch origin gh-pages --depth=1 - git config --local user.email ${{ env.GITHUB_BOT_EMAIL }} - git config --local user.name ${{ env.GITHUB_BOT_USERNAME }} - - name: Deploy Docs - if: ${{ github.ref == 'refs/heads/develop' }} + python_version: 3.8 + - name: Get Current Version run: | export CURRENT_VERSION=$(python setup.py --version --quiet | awk -F. '{print $1"."$2"."$3}') - export ALIAS=stable - tox -e docs-deploy + # Make the version available as env variable for next steps + echo CURRENT_VERSION=$CURRENT_VERSION >> $GITHUB_ENV + shell: bash + - name: Deploy Docs + uses: ./.github/actions/deploy-docs + with: + version: ${{ env.CURRENT_VERSION }} + alias: stable + title: Stable + email: ${{ env.GITHUB_BOT_EMAIL }} + username: ${{ env.GITHUB_BOT_USERNAME }} + set-default: 'true' - name: Build and publish to PyPI env: TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} - run: tox -e publish-release-package + run: | + python setup.py sdist bdist_wheel + twine upload --verbose --non-interactive dist/* diff --git a/.github/workflows/run-tests-workflow.yaml b/.github/workflows/run-tests-workflow.yaml index 6d92cd92a..b4a8fc0ca 100644 --- a/.github/workflows/run-tests-workflow.yaml +++ b/.github/workflows/run-tests-workflow.yaml @@ -22,13 +22,10 @@ jobs: - uses: actions/checkout@v3 with: fetch-depth: 0 - - name: Set up Python ${{ inputs.python_version }} - uses: actions/setup-python@v4 + - name: Setup Python ${{ inputs.python_version }} + uses: ./.github/actions/python with: - python-version: ${{ inputs.python_version }} - cache: 'pip' - - name: Install Dev Requirements - run: pip install -r requirements-dev.txt + python_version: ${{ inputs.python_version }} - name: Cache Tox Directory for Tests uses: actions/cache@v3 with: diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index 40da7c704..bd53e6985 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -16,31 +16,27 @@ env: GITHUB_BOT_USERNAME: github-actions[bot] GITHUB_BOT_EMAIL: 41898282+github-actions[bot]@users.noreply.github.com PY_COLORS: 1 + MYPY_FORCE_COLOR: 1 jobs: - lint: + code-quality: name: Lint code and check type hints runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 with: fetch-depth: 0 - - name: Set up Python 3.8 - uses: actions/setup-python@v4 + - name: Setup Python 3.8 + uses: ./.github/actions/python with: - python-version: 3.8 - cache: 'pip' - - name: Install Dev Requirements - run: pip install -r requirements-dev.txt - - name: Cache Tox Directory for Linting - uses: actions/cache@v3 - with: - key: tox-${{ github.ref }}-${{ runner.os }}-${{ hashFiles('tox.ini') }} - path: .tox + python_version: 3.8 - name: Lint Code - run: tox -e linting + run: | + pre-commit run --all --show-diff-on-failure + python build_scripts/run_pylint.py >>> (pylint-json2html -f jsonextended -o pylint.html) + shell: bash - name: Check Type Hints - run: tox -e type-checking + run: mypy src/ docs: name: Build Docs runs-on: ubuntu-latest @@ -48,22 +44,14 @@ jobs: - uses: actions/checkout@v3 with: fetch-depth: 0 - - name: Set up Python 3.8 - uses: actions/setup-python@v4 + - name: Setup Python 3.8 + uses: ./.github/actions/python with: - python-version: 3.8 - cache: 'pip' - - name: Install Dev Requirements - run: pip install -r requirements-dev.txt + python_version: 3.8 - name: Install Pandoc run: sudo apt-get install --no-install-recommends --yes pandoc - - name: Cache Tox Directory for Docs - uses: actions/cache@v3 - with: - key: tox-${{ github.ref }}-${{ runner.os }}-${{ hashFiles('tox.ini') }} - path: .tox - name: Build Docs - run: tox -e docs + run: mike build base-tests: strategy: matrix: @@ -73,7 +61,7 @@ jobs: with: tests_to_run: base python_version: ${{ matrix.python_version }} - needs: [lint] + needs: [code-quality] torch-tests: strategy: matrix: @@ -83,7 +71,7 @@ jobs: with: tests_to_run: torch python_version: ${{ matrix.python_version }} - needs: [lint] + needs: [code-quality] notebook-tests: strategy: matrix: @@ -93,41 +81,29 @@ jobs: with: tests_to_run: notebooks python_version: ${{ matrix.python_version }} - needs: [lint] + needs: [code-quality] push-docs-and-release-testpypi: name: Push Docs and maybe release Package to TestPyPI runs-on: ubuntu-latest needs: [docs, base-tests, torch-tests, notebook-tests] concurrency: - group: push-docs-and-release-testpypi + group: publish steps: - uses: actions/checkout@v3 with: fetch-depth: 0 - - name: Set up Python 3.8 - uses: actions/setup-python@v4 + - name: Setup Python 3.8 + uses: ./.github/actions/python with: - python-version: 3.8 - cache: 'pip' - - name: Install Dev Requirements - run: pip install -r requirements-dev.txt - - name: Cache Tox Directory - uses: actions/cache@v3 - with: - key: tox-${{ github.ref }}-${{ runner.os }}-${{ hashFiles('tox.ini') }} - path: .tox - - name: Configure Git - if: ${{ github.ref == 'refs/heads/develop' }} - run: | - git fetch origin gh-pages --depth=1 - git config --local user.email ${{ env.GITHUB_BOT_EMAIL }} - git config --local user.name ${{ env.GITHUB_BOT_USERNAME }} + python_version: 3.8 - name: Deploy Docs - if: ${{ github.ref == 'refs/heads/develop' }} - run: | - export CURRENT_VERSION=$(python setup.py --version --quiet | awk -F. '{print $1"."$2"."$3}') - export ALIAS=latest - tox -e docs-deploy + uses: ./.github/actions/deploy-docs + with: + version: devel + alias: latest + title: Latest + email: ${{ env.GITHUB_BOT_EMAIL }} + username: ${{ env.GITHUB_BOT_USERNAME }} - name: Build and publish to TestPyPI if: ${{ github.ref == 'refs/heads/develop' }} env: @@ -136,5 +112,6 @@ jobs: run: | set -x export BUILD_NUMBER=$GITHUB_RUN_NUMBER - tox -e bump-dev-version - tox -e publish-test-package + bump2version --no-tag --no-commit --verbose --serialize '\{major\}.\{minor\}.\{patch\}.\{release\}\{$BUILD_NUMBER\}' boguspart + python setup.py sdist bdist_wheel + twine upload -r testpypi --verbose --non-interactive dist/* From 5763a82dfc49e31eec43e09bbab1b0f08c8feac5 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 24 Aug 2023 10:37:58 +0200 Subject: [PATCH 286/436] Remove docs tox environments --- tox.ini | 36 +----------------------------------- 1 file changed, 1 insertion(+), 35 deletions(-) diff --git a/tox.ini b/tox.ini index 2328b80d0..ff5e7c38e 100644 --- a/tox.ini +++ b/tox.ini @@ -4,12 +4,7 @@ wheel = true [testenv] deps = - pytest - pytest-cov - pytest-lazy-fixture - pytest-timeout - pytest-mock - pytest-docker==2.0.0 + -r requirements-dev.txt -r requirements.txt setenv = COVERAGE_FILE = {env:COVERAGE_FILE:{toxinidir}/.coverage.{envname}} @@ -88,35 +83,6 @@ deps = commands = mypy {posargs:src/} -[testenv:docs] -commands = - mkdocs build -deps = - -r requirements-docs.txt -extras = - influence - -[testenv:docs-dev] -description = This is a development environment for the docs that supports hot-reloading of the docs -commands = - mkdocs serve -deps = - {[testenv:docs]deps} -extras = - influence - - -[testenv:docs-deploy] -passenv = - CURRENT_VERSION - ALIAS -commands = - mike deploy --push $CURRENT_VERSION $ALIAS -deps = - {[testenv:docs]deps} -extras = - influence - [testenv:publish-test-package] description = Publish package to TestPyPI skip_install = true From 643bd5f835702132cef13f07a57b29e17423eea6 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 24 Aug 2023 10:38:12 +0200 Subject: [PATCH 287/436] Update contributing guide --- CONTRIBUTING.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 5f3a17ffe..cdaf7617b 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -179,23 +179,23 @@ Examples for hidden imports and plots are available in the notebooks, e.g. in ## Documentation API documentation and examples from notebooks are built with -[mkdocs](https://www.mkdocs.org/) by tox. +[mkdocs](https://www.mkdocs.org/). Notebooks are an integral part of the documentation as well, please read [the section on notebooks](#notebooks) above. -Use the **docs** tox environment to build the documentation the same way it is +Use the following command to build the documentation the same way it is done in CI: ```bash -tox -e docs +mkdocs build ``` -Locally, you can use the **docs-dev** tox environment to continuously rebuild -documentation on changes to the `docs` folder: +Locally, you can use this command instead to continuously rebuild +documentation on changes to the `docs` and `src` folder: ```bash -tox -e docs-dev +mkdocs serve ``` This will rebuild the documentation on changes to `.md` files inside `docs`, From 46a52ebaecf5b906a8681b62b98488e7960de1c6 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 24 Aug 2023 10:39:54 +0200 Subject: [PATCH 288/436] Remove bump and release tox environments --- CONTRIBUTING.md | 11 +++++------ tox.ini | 34 ---------------------------------- 2 files changed, 5 insertions(+), 40 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index cdaf7617b..7fcf28ffa 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -471,10 +471,9 @@ a GitHub release. #### Publish to TestPyPI We use [bump2version](https://pypi.org/project/bump2version/) to bump -the build part of the version number and publish a package to TestPyPI from CI. +the build part of the version number without commiting or tagging the change +and then publish a package to TestPyPI from CI using Twine. -To do that, we use 2 different tox environments: - -- **bump-dev-version**: Uses bump2version to bump the dev version, - without committing the new version or creating a corresponding git tag. -- **publish-test-package**: Builds and publishes a package to TestPyPI +For more details refer to the +[.github/workflows/publish.yaml](.github/workflows/publish.yaml) and +[.github/workflows/tox.yaml](.github/workflows/tox.yaml) files. diff --git a/tox.ini b/tox.ini index ff5e7c38e..9bc820d68 100644 --- a/tox.ini +++ b/tox.ini @@ -82,37 +82,3 @@ deps = -r requirements.txt commands = mypy {posargs:src/} - -[testenv:publish-test-package] -description = Publish package to TestPyPI -skip_install = true -passenv = - TWINE_* -deps = - wheel - twine -commands = - python setup.py sdist bdist_wheel - twine upload -r testpypi --verbose --non-interactive dist/* - -[testenv:publish-release-package] -description = Publish package to PyPI -skip_install = true -passenv = - TWINE_* -deps = - {[testenv:publish-test-package]deps} -commands = - python setup.py sdist bdist_wheel - twine upload --verbose --non-interactive dist/* - - -[testenv:bump-dev-version] -description = Bumps the build part of the version using the given number -skip_install = true -passenv = - BUILD_NUMBER -deps = - bump2version -commands = - bump2version --no-tag --no-commit --verbose --serialize '\{major\}.\{minor\}.\{patch\}.\{release\}\{$BUILD_NUMBER\}' boguspart From 90b1346c8231e7f641080232560156c822b24542 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 24 Aug 2023 10:40:23 +0200 Subject: [PATCH 289/436] Remove ray from dev requirements --- requirements-dev.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/requirements-dev.txt b/requirements-dev.txt index d4d2bf620..34cdda5a7 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -19,7 +19,6 @@ pytest-docker==2.0.0 pytest-mock pytest-timeout pytest-lazy-fixture -ray[default] >= 0.8 wheel twine==4.0.2 bump2version From 4a5ffdc3f6793bbc3b75002be3351d2ecc31e018 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 24 Aug 2023 10:43:19 +0200 Subject: [PATCH 290/436] Update pull request template --- .github/PULL_REQUEST_TEMPLATE.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md index bca771635..865ca954e 100644 --- a/.github/PULL_REQUEST_TEMPLATE.md +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -17,4 +17,4 @@ This PR closes #XXX - [ ] Wrote Unit tests (if necessary) - [ ] Updated Documentation (if necessary) - [ ] Updated Changelog -- [ ] If notebooks were added/changed, added boilerplate cells are tagged with `"nbsphinx":"hidden"` +- [ ] If notebooks were added/changed, added boilerplate cells are tagged with `"tags": ["hide"]` or `"tags": ["hide-input"]` From d6923d3bc91cc48a2c0e9507d24f8f0aab2376c0 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 24 Aug 2023 10:53:26 +0200 Subject: [PATCH 291/436] Rename tox.yaml to main.yaml, fix syntax error --- .github/workflows/{tox.yaml => main.yaml} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename .github/workflows/{tox.yaml => main.yaml} (97%) diff --git a/.github/workflows/tox.yaml b/.github/workflows/main.yaml similarity index 97% rename from .github/workflows/tox.yaml rename to .github/workflows/main.yaml index bd53e6985..383314973 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/main.yaml @@ -33,7 +33,7 @@ jobs: - name: Lint Code run: | pre-commit run --all --show-diff-on-failure - python build_scripts/run_pylint.py >>> (pylint-json2html -f jsonextended -o pylint.html) + python build_scripts/run_pylint.py | (pylint-json2html -f jsonextended -o pylint.html) shell: bash - name: Check Type Hints run: mypy src/ From 57e6b9f7977c2b66e77c4555e72facae9718aec6 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 24 Aug 2023 10:54:48 +0200 Subject: [PATCH 292/436] Revert "Rename tox.yaml to main.yaml, fix syntax error" This reverts commit d6923d3bc91cc48a2c0e9507d24f8f0aab2376c0. --- .github/workflows/{main.yaml => tox.yaml} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename .github/workflows/{main.yaml => tox.yaml} (97%) diff --git a/.github/workflows/main.yaml b/.github/workflows/tox.yaml similarity index 97% rename from .github/workflows/main.yaml rename to .github/workflows/tox.yaml index 383314973..bd53e6985 100644 --- a/.github/workflows/main.yaml +++ b/.github/workflows/tox.yaml @@ -33,7 +33,7 @@ jobs: - name: Lint Code run: | pre-commit run --all --show-diff-on-failure - python build_scripts/run_pylint.py | (pylint-json2html -f jsonextended -o pylint.html) + python build_scripts/run_pylint.py >>> (pylint-json2html -f jsonextended -o pylint.html) shell: bash - name: Check Type Hints run: mypy src/ From d650356cc3c15c9ce884fe7639b15674e6319ca8 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 24 Aug 2023 10:59:17 +0200 Subject: [PATCH 293/436] Fix syntax error in CI file --- .github/workflows/tox.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index bd53e6985..383314973 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -33,7 +33,7 @@ jobs: - name: Lint Code run: | pre-commit run --all --show-diff-on-failure - python build_scripts/run_pylint.py >>> (pylint-json2html -f jsonextended -o pylint.html) + python build_scripts/run_pylint.py | (pylint-json2html -f jsonextended -o pylint.html) shell: bash - name: Check Type Hints run: mypy src/ From d7c143a295114ae8bd4397458631f41178dadfb9 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 24 Aug 2023 11:02:12 +0200 Subject: [PATCH 294/436] Cache pre-commit configuration --- .github/workflows/tox.yaml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index 383314973..fbf34dd58 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -30,6 +30,10 @@ jobs: uses: ./.github/actions/python with: python_version: 3.8 + - uses: actions/cache@v3 + with: + path: ~/.cache/pre-commit + key: pre-commit-${{ env.pythonLocation }}-${{ hashFiles('.pre-commit-config.yaml') }} - name: Lint Code run: | pre-commit run --all --show-diff-on-failure From a56a7932dcc11a73e405a8e1d5cc80ec9ae100e0 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 24 Aug 2023 11:02:33 +0200 Subject: [PATCH 295/436] Use mkdocs build instead of mike build --- .github/workflows/tox.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index fbf34dd58..3464bcdc6 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -55,7 +55,7 @@ jobs: - name: Install Pandoc run: sudo apt-get install --no-install-recommends --yes pandoc - name: Build Docs - run: mike build + run: mkdocs build base-tests: strategy: matrix: From 311ea75b79e619db138451f50cbef8df3dac0557 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 24 Aug 2023 11:12:58 +0200 Subject: [PATCH 296/436] Create symlinks instead of copying notebooks and changelog into docs This allows mkdocs-git-revision-date-localized-plugin to set proper creation and modification dates --- build_scripts/copy_changelog.py | 11 ++++++----- build_scripts/copy_notebooks.py | 5 +++-- 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/build_scripts/copy_changelog.py b/build_scripts/copy_changelog.py index b2ef8cbf5..2f570295e 100644 --- a/build_scripts/copy_changelog.py +++ b/build_scripts/copy_changelog.py @@ -10,14 +10,14 @@ root_dir = Path(__file__).parent.parent docs_dir = root_dir / "docs" changelog_file = root_dir / "CHANGELOG.md" -changelog_docs_file = docs_dir / changelog_file.name +target_filepath = docs_dir / changelog_file.name @mkdocs.plugins.event_priority(100) def on_pre_build(config): logger.info("Temporarily copying changelog to docs directory") try: - if os.path.getmtime(changelog_file) <= os.path.getmtime(changelog_docs_file): + if os.path.getmtime(changelog_file) <= os.path.getmtime(target_filepath): logger.info( f"Changelog '{os.fspath(changelog_file)}' hasn't been updated, skipping." ) @@ -25,9 +25,10 @@ def on_pre_build(config): except FileNotFoundError: pass logger.info( - f"Copying '{os.fspath(changelog_file)}' to '{os.fspath(changelog_docs_file)}'" + f"Creating symbolic link for '{os.fspath(changelog_file)}' " + f"at '{os.fspath(target_filepath)}'" ) - shutil.copy2(src=changelog_file, dst=changelog_docs_file) + target_filepath.symlink_to(changelog_file) logger.info("Finished copying changelog to docs directory") @@ -35,4 +36,4 @@ def on_pre_build(config): @mkdocs.plugins.event_priority(-100) def on_shutdown(): logger.info("Removing temporary changelog in docs directory") - changelog_docs_file.unlink() + target_filepath.unlink() diff --git a/build_scripts/copy_notebooks.py b/build_scripts/copy_notebooks.py index c8d6fdb64..0d0edbfd3 100644 --- a/build_scripts/copy_notebooks.py +++ b/build_scripts/copy_notebooks.py @@ -30,9 +30,10 @@ def on_pre_build(config): except FileNotFoundError: pass logger.info( - f"Copying '{os.fspath(notebook)}' to '{os.fspath(target_filepath)}'" + f"Creating symbolic link for '{os.fspath(notebook)}' " + f"at '{os.fspath(target_filepath)}'" ) - shutil.copy2(src=notebook, dst=target_filepath) + target_filepath.symlink_to(notebook) logger.info("Finished copying notebooks to examples directory") From 1fcd71fd46cf621bb99cdb4f183768fedaf28507 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 24 Aug 2023 11:13:40 +0200 Subject: [PATCH 297/436] Temporarily allow failures of type checking on CI --- .github/workflows/tox.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index 3464bcdc6..86bdc8caf 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -41,6 +41,7 @@ jobs: shell: bash - name: Check Type Hints run: mypy src/ + continue-on-error: true docs: name: Build Docs runs-on: ubuntu-latest From 239979de41e30400a7848be40908a775e59ea4ac Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 24 Aug 2023 11:16:55 +0200 Subject: [PATCH 298/436] Apply suggestions from code review Co-authored-by: Anes Benmerzoug --- src/pydvl/utils/parallel/futures/ray.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 195c5ab87..b85a2dad0 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -132,7 +132,7 @@ def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": self._start_work_item_manager_thread() return future - def shutdown(self, wait: bool = True, *, cancel_futures: bool = None) -> None: + def shutdown(self, wait: bool = True, *, cancel_futures: Optional[bool] = None) -> None: """Clean up the resources associated with the Executor. This method tries to mimic the behaviour of :meth:`Executor.shutdown` @@ -353,7 +353,6 @@ def flag_executor_shutting_down(self): # We cannot cancel a running future object. for future in self.submitted_futures: ray.cancel(future.object_ref) - # FIXME: huh? why is this here? # Make sure we do this only once to not waste time looping # on running processes over and over. executor._cancel_futures = CancellationPolicy.NONE From d2b4f2dda3374d7f23e824d93f6d02339244d75e Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 24 Aug 2023 11:17:46 +0200 Subject: [PATCH 299/436] Revert "Temporarily allow failures of type checking on CI" This reverts commit 1fcd71fd46cf621bb99cdb4f183768fedaf28507. --- .github/workflows/tox.yaml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index 86bdc8caf..3464bcdc6 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -41,7 +41,6 @@ jobs: shell: bash - name: Check Type Hints run: mypy src/ - continue-on-error: true docs: name: Build Docs runs-on: ubuntu-latest From cbc7bfe0d7e6473d9c59cd778658c849fb34a396 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 24 Aug 2023 12:07:48 +0200 Subject: [PATCH 300/436] Remove version constraint on nbconvert inside tox file --- tox.ini | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tox.ini b/tox.ini index 9bc820d68..b01f1dfb5 100644 --- a/tox.ini +++ b/tox.ini @@ -30,7 +30,7 @@ commands = deps = {[testenv]deps} jupyter==1.0.0 - nbconvert==6.4.5 + nbconvert datasets==2.6.1 torchvision==0.14.1 extras = From 297bfbca3806cf7a4bc93ac0f5d8dca65aeb2490 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 24 Aug 2023 12:08:03 +0200 Subject: [PATCH 301/436] Make docs title optional --- .github/actions/deploy-docs/action.yml | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/.github/actions/deploy-docs/action.yml b/.github/actions/deploy-docs/action.yml index 7fe82bab3..ff2c48756 100644 --- a/.github/actions/deploy-docs/action.yml +++ b/.github/actions/deploy-docs/action.yml @@ -9,7 +9,8 @@ inputs: required: true title: description: Alternative title to use - required: true + required: false + default: '' email: description: Email to use for git config required: true @@ -28,9 +29,15 @@ runs: git fetch origin gh-pages --depth=1 git config --local user.email ${{ inputs.email }} git config --local user.name ${{ inputs.username }} - mike deploy ${{ inputs.version }} ${{ inputs.alias }} --title=${{ inputs.title }} --push --update-aliases + shell: bash + - run: | + if [ -z "${{ inputs.title }}" ] + then + mike deploy ${{ inputs.version }} ${{ inputs.alias }} --push --update-aliases + else + mike deploy ${{ inputs.version }} ${{ inputs.alias }} --title=${{ inputs.title }} --push --update-aliases + fi shell: bash - if: ${{ inputs.set-default == 'true' }} run: mike set-default ${{ inputs.alias }} shell: bash - From a77d266fc9797f0473992a9e365a201e54222edb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 24 Aug 2023 15:52:53 +0200 Subject: [PATCH 302/436] Improve documentation of influence package: * add more information * change to google style format --- src/pydvl/influence/__init__.py | 6 +- src/pydvl/influence/general.py | 186 +++++--- src/pydvl/influence/inversion.py | 94 ++-- src/pydvl/influence/torch/functional.py | 152 +++--- .../influence/torch/torch_differentiable.py | 449 ++++++++++-------- src/pydvl/influence/torch/util.py | 51 +- src/pydvl/influence/twice_differentiable.py | 131 +++-- 7 files changed, 620 insertions(+), 449 deletions(-) diff --git a/src/pydvl/influence/__init__.py b/src/pydvl/influence/__init__.py index 41d5dc993..b7604fd74 100644 --- a/src/pydvl/influence/__init__.py +++ b/src/pydvl/influence/__init__.py @@ -1,10 +1,8 @@ """ This package contains algorithms for the computation of the influence function. -.. warning:: - Much of the code in this package is experimental or untested and is subject - to modification. In particular, the package structure and basic API will - probably change. +> **Warning:** Much of the code in this package is experimental or untested and is subject to modification. +In particular, the package structure and basic API will probably change. """ from .general import InfluenceType, compute_influence_factors, compute_influences diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index b581514ee..35c17020f 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -1,6 +1,6 @@ """ This module contains parallelized influence calculation functions for general -models, as introduced in :footcite:t:`koh_understanding_2017`. +models, as introduced in [@koh_understanding_2017]. """ import logging from copy import deepcopy @@ -8,9 +8,10 @@ from typing import Any, Callable, Dict, Generator, Optional, Type from ..utils import maybe_progress -from .inversion import InverseHvpResult, InversionMethod, solve_hvp +from .inversion import InversionMethod, solve_hvp from .twice_differentiable import ( DataLoaderType, + InverseHvpResult, TensorType, TensorUtilities, TwiceDifferentiable, @@ -22,8 +23,13 @@ class InfluenceType(str, Enum): - """ - Different influence types. + r""" + Enum representation for the types of influence. + + Attributes: + - Up: Up-weighting a training point, see section 2.1 of [@koh_understanding_2017] + - Perturbation: Perturb a training point, see section 2.2 of [@koh_understanding_2017] + """ Up = "up" @@ -41,28 +47,34 @@ def compute_influence_factors( **kwargs: Any, ) -> InverseHvpResult: r""" - Calculates influence factors of a model for training and test - data. Given a test point $z_test = (x_{test}, y_{test})$, a loss - $L(z_{test}, \theta)$ ($\theta$ being the parameters of the model) and the - Hessian of the model $H_{\theta}$, influence factors are defined as - $$s_{test} = H_{\theta}^{-1} \grad_{\theta} L(z_{test}, \theta).$$. They are - used for efficient influence calculation. This method first - (implicitly) calculates the Hessian and then (explicitly) finds the - influence factors for the model using the given inversion method. The - parameter ``hessian_perturbation`` is used to regularize the inversion of - the Hessian. For more info, refer to :footcite:t:`koh_understanding_2017`, - paragraph 3. - - :param model: A model wrapped in the TwiceDifferentiable interface. - :param training_data: A DataLoader containing the training data. - :param test_data: A DataLoader containing the test data. - :param inversion_method: name of method for computing inverse hessian vector - products. - :param hessian_perturbation: regularization of the hessian - :param progress: If True, display progress bars. - :returns: An array of size (N, D) containing the influence factors for each - dimension (D) and test sample (N). + Calculates influence factors of a model for training and test data. + + Given a test point \(z_{test} = (x_{test}, y_{test})\), a loss \(L(z_{test}, \theta)\) + (\(\theta\) being the parameters of the model) and the Hessian of the model \(H_{\theta}\), + influence factors are defined as: + + \[ + s_{test} = H_{\theta}^{-1} \operatorname{grad}_{\theta} L(z_{test}, \theta). + \] + + They are used for efficient influence calculation. This method first (implicitly) calculates + the Hessian and then (explicitly) finds the influence factors for the model using the given + inversion method. The parameter `hessian_perturbation` is used to regularize the inversion of + the Hessian. For more info, refer to [@koh_understanding_2017], paragraph 3. + + Args: + model: A model wrapped in the TwiceDifferentiable interface. + training_data: DataLoader containing the training data. + test_data: DataLoader containing the test data. + inversion_method: Name of method for computing inverse hessian vector products. + hessian_perturbation: Regularization of the hessian. + progress: If True, display progress bars. + + Returns: + array: An array of size (N, D) containing the influence factors for each dimension (D) and test sample (N). + """ + tensor_util: Type[TensorUtilities] = TensorUtilities.from_twice_differentiable( model ) @@ -114,21 +126,25 @@ def compute_influences_up( progress: bool = False, ) -> TensorType: r""" - Given the model, the training points and the influence factors, calculates the - influences using the upweighting method. More precisely, first it calculates - the gradients of the model wrt. each training sample ($\grad_{\theta} L$, - with $L$ the loss of a single point and $\theta$ the parameters of the - model) and then multiplies each with the influence factors. For more - details, refer to section 2.1 of :footcite:t:`koh_understanding_2017`. - - :param model: A model which has to implement the TwiceDifferentiable - interface. - :param input_data: Data loader containing the samples to calculate the - influence of. - :param influence_factors: array containing influence factors - :param progress: If True, display progress bars. - :returns: An array of size [NxM], where N is number of influence factors, M - number of input points. + Given the model, the training points, and the influence factors, this function calculates the + influences using the up-weighting method. + + The procedure involves two main steps: + 1. Calculating the gradients of the model with respect to each training sample + (\(\operatorname{grad}_{\theta} L\), where \(L\) is the loss of a single point and \(\theta\) are the + parameters of the model). + 2. Multiplying each gradient with the influence factors. + + For a detailed description of the methodology, see section 2.1 of [@koh_understanding_2017]. + + Args: + model: A model that implements the TwiceDifferentiable interface. + input_data: DataLoader containing the samples for which the influence will be calculated. + influence_factors: Array containing pre-computed influence factors. + progress: If set to True, progress bars will be displayed during computation. + + Returns: + An array of shape [NxM], where N is the number of influence factors, and M is the number of input samples. """ tensor_util: Type[TensorUtilities] = TensorUtilities.from_twice_differentiable( @@ -173,21 +189,26 @@ def compute_influences_pert( progress: bool = False, ) -> TensorType: r""" - Calculates the influence values from the influence factors and the training - points using the perturbation method. More precisely, for each training sample it - calculates $\grad_{\theta} L$ (with L the loss of the model over the single - point and $\theta$ the parameters of the model) and then uses the method - TwiceDifferentiable.mvp to efficiently calculate the product of the - influence factors and $\grad_x \grad_{\theta} L$. For more details, refer - to section 2.2 of :footcite:t:`koh_understanding_2017`. - - :param model: A model which has to implement the TwiceDifferentiable interface. - :param input_data: Data loader containing the samples to calculate the - influence of. - :param influence_factors: array containing influence factors - :param progress: If True, display progress bars. - :returns: An array of size [NxMxP], where N is the number of influence factors, M - the number of input data, and P the number of features. + Calculates the influence values based on the influence factors and training samples using the perturbation method. + + The process involves two main steps: + 1. Calculating the gradient of the model with respect to each training sample + (\(\operatorname{grad}_{\theta} L\), where \(L\) is the loss of the model for a single data point and \(\theta\) + are the parameters of the model). + 2. Using the method `TwiceDifferentiable.mvp` to efficiently compute the product of the + influence factors and \(\operatorname{grad}_x \operatorname{grad}_{\theta} L\). + + For a detailed methodology, see section 2.2 of [@koh_understanding_2017]. + + Args: + model: A model that implements the TwiceDifferentiable interface. + input_data: DataLoader containing the samples for which the influence will be calculated. + influence_factors: Array containing pre-computed influence factors. + progress: If set to True, progress bars will be displayed during computation. + + Returns: + A 3D array with shape [NxMxP], where N is the number of influence factors, + M is the number of input samples, and P is the number of features. """ tensor_util: Type[TensorUtilities] = TensorUtilities.from_twice_differentiable( @@ -239,31 +260,38 @@ def compute_influences( **kwargs: Any, ) -> TensorType: # type: ignore # ToDO fix typing r""" - Calculates the influence of the input_data point j on the test points i. - First it calculates the influence factors of all test points with respect - to the model and the training points, and then uses them to get the - influences over the complete input_data set. - - :param differentiable_model: A model wrapped with its loss in TwiceDifferentiable. - :param training_data: data loader with the training data, used to calculate - the hessian of the model loss. - :param test_data: data loader with the test samples. If None, the samples in - training_data are used. - :param input_data: data loader with the samples to calculate the influences - of. If None, the samples in training_data are used. - :param progress: whether to display progress bars. - :param influence_type: Which algorithm to use to calculate influences. - Currently supported options: 'up' or 'perturbation'. For details refer - to :footcite:t:`koh_understanding_2017` - :param hessian_regularization: lambda to use in Hessian regularization, i.e. - H_reg = H + lambda * 1, with 1 the identity matrix and H the (simple and - regularized) Hessian. Typically used with more complex models to make - sure the Hessian is positive definite. - :returns: An array specifying the influences. Shape is [NxM] if - influence_type is'up', where N is number of test points and M number of - train points. If instead influence_type is 'perturbation', output shape - is [NxMxP], with P the number of input features. + Calculates the influence of each input data point on the specified test points. + + This method operates in two primary stages: + 1. Computes the influence factors for all test points concerning the model and its training data. + 2. Uses these factors to derive the influences over the complete set of input data. + + The influence calculation relies on the twice-differentiable nature of the provided model. + + Args: + differentiable_model: A model bundled with its corresponding loss in the `TwiceDifferentiable` wrapper. + training_data: DataLoader instance supplying the training data. This data is pivotal in computing the + Hessian matrix for the model's loss. + test_data: DataLoader instance with the test samples. Defaults to `training_data` if None. + input_data: DataLoader instance holding samples whose influences need to be computed. Defaults to + `training_data` if None. + inversion_method: An enumeration value determining the approach for inverting matrices + or computing inverse operations, see [.inversion.InversionMethod] + progress: A boolean indicating whether progress bars should be displayed during computation. + influence_type: Determines the methodology for computing influences. + Valid choices include 'up' (for up-weighting) and 'perturbation'. + For an in-depth understanding, see [@koh_understanding_2017]. + hessian_regularization: A lambda value used in Hessian regularization. The regularized Hessian, \( H_{reg} \), + is computed as \( H + \lambda \times I \), where \( I \) is the identity matrix and \( H \) + is the simple, unmodified Hessian. This regularization is typically utilized for more + sophisticated models to ensure that the Hessian remains positive definite. + + Returns: + The shape of this array varies based on the `influence_type`. If 'up', the shape is [NxM], where + N denotes the number of test points and M denotes the number of training points. Conversely, if the + influence_type is 'perturbation', the shape is [NxMxP], with P representing the number of input features. """ + if input_data is None: input_data = deepcopy(training_data) if test_data is None: diff --git a/src/pydvl/influence/inversion.py b/src/pydvl/influence/inversion.py index 27cf7ff60..1eb26e957 100644 --- a/src/pydvl/influence/inversion.py +++ b/src/pydvl/influence/inversion.py @@ -11,7 +11,6 @@ "solve_hvp", "InversionMethod", "InversionRegistry", - "InverseHvpResult", ] from .twice_differentiable import ( @@ -44,25 +43,27 @@ def solve_hvp( hessian_perturbation: float = 0.0, **kwargs: Any, ) -> InverseHvpResult: + r""" + Finds \( x \) such that \( Ax = b \), where \( A \) is the hessian of the model, + and \( b \) a vector. Depending on the inversion method, the hessian is either + calculated directly and then inverted, or implicitly and then inverted through + matrix vector product. The method also allows to add a small regularization term + (hessian_perturbation) to facilitate inversion of non fully trained models. + + Args: + inversion_method: + model: A model wrapped in the TwiceDifferentiable interface. + training_data: + b: Array as the right hand side of the equation \( Ax = b \) + hessian_perturbation: regularization of the hessian. + kwargs: kwargs to pass to the inversion method. + + Returns: + Instance of [InverseHvpResult][pydvl.influence.twice_differentiable.InverseHvpResult], with + an array that solves the inverse problem, i.e., it returns \( x \) such that \( Ax = b \) + and a dictionary containing information about the inversion process. """ - Finds $x$ such that $Ax = b$, where $A$ is the hessian of model, - and $b$ a vector. - Depending on the inversion method, the hessian is either calculated directly - and then inverted, or implicitly and then inverted through matrix vector - product. The method also allows to add a small regularization term (hessian_perturbation) - to facilitate inversion of non fully trained models. - - :param inversion_method: - :param model: A model wrapped in the TwiceDifferentiable interface. - :param training_data: - :param b: Array as the right hand side of the equation $Ax = b$ - :param hessian_perturbation: regularization of the hessian - :param kwargs: kwargs to pass to the inversion method - - :return: An object that contains an array that solves the inverse problem, - i.e. it returns $x$ such that $Ax = b$, and a dictionary containing - information about the inversion process. - """ + return InversionRegistry.call( inversion_method, model, @@ -94,17 +95,21 @@ def register( `(model: TwiceDifferentiable, training_data: DataLoaderType, b: TensorType, hessian_perturbation: float = 0.0, ...)`. - :param model_type: The type of the model the function should be registered for. - :param inversion_method: The inversion method the function should be - registered for. - :param overwrite: If ``True``, allows overwriting of an existing registered - function for the same model type and inversion method. If ``False``, - logs a warning when attempting to register a function for an already - registered model type and inversion method. - - :raises TypeError: If the provided model_type or inversion_method are of the wrong type. - :raises ValueError: If the function to be registered does not match the required signature. - :return: A decorator for registering a function. + Args: + model_type: The type of the model the function should be registered for. + inversion_method: The inversion method the function should be + registered for. + overwrite: If ``True``, allows overwriting of an existing registered + function for the same model type and inversion method. If ``False``, + logs a warning when attempting to register a function for an already + registered model type and inversion method. + + Raises: + TypeError: If the provided model_type or inversion_method are of the wrong type. + ValueError: If the function to be registered does not match the required signature. + + Returns: + A decorator for registering a function. """ if not isinstance(model_type, type): @@ -177,19 +182,22 @@ def call( hessian_perturbation, **kwargs, ) -> InverseHvpResult: - """ - Call a registered function with the provided parameters. - - :param inversion_method: The inversion method to use. - :param model: A model wrapped in the TwiceDifferentiable interface. - :param training_data: The training data to use. - :param b: Array as the right hand side of the equation $Ax = b$. - :param hessian_perturbation: Regularization of the hessian. - :param kwargs: Additional keyword arguments to pass to the inversion method. - - :return: An object that contains an array that solves the inverse problem, - i.e. it returns $x$ such that $Ax = b$, and a dictionary containing - information about the inversion process. + r""" + Call a registered function with the provided parameters. + + Args: + inversion_method: The inversion method to use. + model: A model wrapped in the TwiceDifferentiable interface. + training_data: The training data to use. + b: Array as the right hand side of the equation \(Ax = b\). + hessian_perturbation: Regularization of the hessian. + kwargs: Additional keyword arguments to pass to the inversion method. + + Returns: + An instance of [InverseHvpResult][pydvl.influence.twice_differentiable.InverseHvpResult], + that contains an array, which solves the inverse problem, + i.e. it returns \(x\) such that \(Ax = b\), and a dictionary containing information + about the inversion process. """ return cls.get(type(model), inversion_method)( diff --git a/src/pydvl/influence/torch/functional.py b/src/pydvl/influence/torch/functional.py index f1b042032..1be128b4b 100644 --- a/src/pydvl/influence/torch/functional.py +++ b/src/pydvl/influence/torch/functional.py @@ -22,28 +22,34 @@ def hvp( vec: TorchTensorContainerType, reverse_only: bool = True, ) -> TorchTensorContainerType: + r""" + Computes the Hessian-vector product (HVP) for a given function at given parameters, i.e. + + \[\nabla_{\theta} \nabla_{\theta} f (\theta)\cdot v\] + + This function can operate in two modes, either reverse-mode autodiff only or both + forward- and reverse-mode autodiff. + + Args: + func: The scalar-valued function for which the HVP is computed. + params: The parameters at which the HVP is computed. + vec: The vector with which the Hessian is multiplied. + reverse_only: Whether to use only reverse-mode autodiff + (True, default) or both forward- and reverse-mode autodiff (False). + + Returns: + The HVP of the function at the given parameters with the given vector. + + Example: + ```python + >>> def f(z): return torch.sum(z**2) + >>> u = torch.ones(10, requires_grad=True) + >>> v = torch.ones(10) + >>> hvp_vec = hvp(f, u, v) + >>> assert torch.allclose(hvp_vec, torch.full((10, ), 2.0)) + ``` """ - Computes the Hessian-vector product (HVP) for a given function at given parameters. - This function can operate in two modes, either reverse-mode autodiff only or both - forward- and reverse-mode autodiff. - - :param func: The scalar-valued function for which the HVP is computed. - :param params: The parameters at which the HVP is computed. - :param vec: The vector with which the Hessian is multiplied. - :param reverse_only: Whether to use only reverse-mode autodiff - (True, default) or both forward- and reverse-mode autodiff (False). - - :return: Input_type: The HVP of the function at the given parameters with the given vector. - - :Example: - - >>> def f(z): return torch.sum(z**2) - >>> u = torch.ones(10, requires_grad=True) - >>> v = torch.ones(10) - >>> hvp_vec = hvp(f, u, v) - >>> assert torch.allclose(hvp_vec, torch.full((10, ), 2.0)) - """ output: TorchTensorContainerType if reverse_only: @@ -61,18 +67,26 @@ def batch_hvp_gen( data_loader: DataLoader, reverse_only: bool = True, ) -> Generator[Callable[[torch.Tensor], torch.Tensor], None, None]: - """ + r""" Generates a sequence of batch Hessian-vector product (HVP) computations for the provided model, loss function, - and data loader. + and data loader. If \(f_i\) is the model's loss on the \(i\)-th batch and \(\theta\) the model parameters, + this is the sequence of the callable matrix vector products for the matrices + + \[\nabla_{\theta}\nabla_{\theta}f_i(\theta), \quad i=1,\dots, \text{num_batches} \] - The generator iterates over the data_loader, creating partial function calls for calculating HVPs. + i.e. iterating over the data_loader, yielding partial function calls for calculating HVPs. - :param model: The PyTorch model for which the HVP is calculated. - :param loss: The loss function used to calculate the gradient and HVP. - :param data_loader: PyTorch DataLoader object containing the dataset for which the HVP is calculated. - :param reverse_only: - :yield: A partial function H(vec)=hvp(model, loss, inputs, targets, vec) that when called, - will compute the Hessian-vector product H(vec) for the given model, loss, inputs and targets. + Args: + model: The PyTorch model for which the HVP is calculated. + loss: The loss function used to calculate the gradient and HVP. + data_loader: PyTorch DataLoader object containing the dataset for which the HVP is calculated. + reverse_only: Whether to use only reverse-mode autodiff + (True, default) or both forward- and reverse-mode autodiff (False). + + Yields: + Partial functions `H_{batch}(vec)=hvp(model, loss, inputs, targets, vec)` that when called, + will compute the Hessian-vector product H(vec) for the given model and loss in a batch-wise manner, where + (inputs, targets) coming from one batch. """ for inputs, targets in iter(data_loader): @@ -97,20 +111,19 @@ def empirical_loss_function( loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], data_loader: DataLoader, ) -> Callable[[Dict[str, torch.Tensor]], torch.Tensor]: - """ + r""" Creates a function to compute the empirical loss of a given model on a given dataset. - If we denote the model parameters with $\theta$, the resulting function approximates - - .. math:: + If we denote the model parameters with \( \theta \), the resulting function approximates: - f(\theta) = \frac{1}{N}\sum_{i=1}^N \operatorname{loss}(y_i, \operatorname{model}(\theta, x_i))) + \[f(\theta) = \frac{1}{N}\sum_{i=1}^N \operatorname{loss}(y_i, \operatorname{model}(\theta, x_i))\] - :param model: The model for which the loss should be computed. - :param loss: The loss function to be used. - :param data_loader: The data loader for iterating over the dataset. + Args: + - model: The model for which the loss should be computed. + - loss: The loss function to be used. + - data_loader: The data loader for iterating over the dataset. - :return: A function that computes the empirical loss - of the model on the dataset for given model parameters. + Returns: + A function that computes the empirical loss of the model on the dataset for given model parameters. """ @@ -137,16 +150,19 @@ def batch_loss_function( x: torch.Tensor, y: torch.Tensor, ) -> Callable[[Dict[str, torch.Tensor]], torch.Tensor]: - """ - Creates a function to compute the loss of a given model on a given batch of data. + r""" + Creates a function to compute the loss of a given model on a given batch of data, i.e. for the $i$-th batch $B_i$ + + \[\frac{1}{|B_i|}\sum_{x,y \in B_i} \operatorname{loss}(y, \operatorname{model}(\theta, x))\] - :param model: The model for which the loss should be computed. - :param loss: The loss function to be used. - :param x: The input data for the batch. - :param y: The true labels for the batch. + Args: + model: The model for which the loss should be computed. + loss: The loss function to be used. + x: The input data for the batch. + y: The true labels for the batch. - :return: A function that computes the loss - of the model on the batch for given model parameters. + Returns: + A function that computes the loss of the model on the batch for given model parameters. """ def batch_loss(params: Dict[str, torch.Tensor]): @@ -168,26 +184,28 @@ def get_hvp_function( ) -> Callable[[torch.Tensor], torch.Tensor]: """ Returns a function that calculates the approximate Hessian-vector product for a given vector. If you want to - compute the exact hessian, i.e. pulling all data into memory and compute a full gradient computation, use - the function :func:`hvp`. - - :param model: A PyTorch module representing the model whose loss function's Hessian is to be computed. - :param loss: A callable that takes the model's output and target as input and returns the scalar loss. - :param data_loader: A DataLoader instance that provides batches of data for calculating the Hessian-vector product. - Each batch from the DataLoader is assumed to return a tuple where the first element - is the model's input and the second element is the target output. - :param use_hessian_avg: If True, it will use batch-wise Hessian computation. If False, the function averages - the batch gradients and perform backpropagation on the full (averaged) gradient, - which is more accurate than averaging the batch hessians, - but probably has a way higher memory usage. - :param reverse_only: Whether to use only reverse-mode autodiff - (True, default) or both forward- and reverse-mode autodiff (False) - :param track_gradients: Whether to track gradients for the resulting tensor of the hessian vector products are - (False, default). - - :return: A function that takes a single argument, a vector, and returns the product of the Hessian of the - `loss` function with respect to the `model`'s parameters and the input vector. - + compute the exact hessian, i.e., pulling all data into memory and compute a full gradient computation, use + the function `hvp`. + + Args: + model: A PyTorch module representing the model whose loss function's Hessian is to be computed. + loss: A callable that takes the model's output and target as input and returns the scalar loss. + data_loader: A DataLoader instance that provides batches of data for calculating the Hessian-vector product. + Each batch from the DataLoader is assumed to return a tuple where the first element + is the model's input and the second element is the target output. + use_hessian_avg: If True, the returned function uses batch-wise Hessian computation via + [batch_loss_function][pydvl.influence.torch.functional.batch_loss_function] and averages the results. + If False, the function uses backpropagation on the full + [empirical_loss_function][pydvl.influence.torch.functional.empirical_loss_function], + which is more accurate than averaging the batch hessians, but probably has a way higher memory usage. + reverse_only: Whether to use only reverse-mode autodiff (True, default) or + both forward- and reverse-mode autodiff (False). + track_gradients: Whether to track gradients for the resulting tensor of the hessian vector + products are (False, default). + + Returns: + A function that takes a single argument, a vector, and returns the product of the Hessian of the `loss` + function with respect to the `model`'s parameters and the input vector. """ params = { diff --git a/src/pydvl/influence/torch/torch_differentiable.py b/src/pydvl/influence/torch/torch_differentiable.py index 1515f3f96..b17a99180 100644 --- a/src/pydvl/influence/torch/torch_differentiable.py +++ b/src/pydvl/influence/torch/torch_differentiable.py @@ -34,7 +34,6 @@ "solve_lissa", "solve_arnoldi", "lanzcos_low_rank_hessian_approx", - "as_tensor", "model_hessian_low_rank", ] @@ -42,16 +41,23 @@ class TorchTwiceDifferentiable(TwiceDifferentiable[torch.Tensor]): + r""" + Wraps a [torch.nn.Module](https://pytorch.org/docs/stable/generated/torch.nn.Module.html) + and a loss function and provides methods to compute gradients and + second derivative of the loss wrt. the model parameters + + Args: + model: A (differentiable) function. + loss: A differentiable scalar loss \( L(\hat{y}, y) \), + mapping a prediction and a target to a real value. + """ + def __init__( self, model: nn.Module, loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], ): - r""" - :param model: A (differentiable) function. - :param loss: A differentiable scalar loss $L(\hat{y}, y)$, - mapping a prediction and a target to a real value. - """ + if model.training: logger.warning( "Passed model not in evaluation mode. This can create several issues in influence " @@ -70,28 +76,38 @@ def tensor_type(cls): @property def parameters(self) -> List[torch.Tensor]: - """Returns all the model parameters that require differentiating""" + """ + Returns: + All model parameters that require differentiating. + """ + return [param for param in self.model.parameters() if param.requires_grad] @property def num_params(self) -> int: """ - Get number of parameters of model f. - :returns: Number of parameters as integer. + Get the number of parameters of model f. + + Returns: + int: Number of parameters. """ return sum([p.numel() for p in self.parameters]) def grad( self, x: torch.Tensor, y: torch.Tensor, create_graph: bool = False ) -> torch.Tensor: - """ - Calculates gradient of model parameters wrt the model parameters. + r""" + Calculates gradient of model parameters with respect to the model parameters. + + Args: + x: A matrix [NxD] representing the features \( x_i \). + y: A matrix [NxK] representing the target values \( y_i \). + create_graph (bool): If True, the resulting gradient tensor can be used for further differentiation. - :param x: A matrix [NxD] representing the features $x_i$. - :param y: A matrix [NxK] representing the target values $y_i$. - :param create_graph: If True, the resulting gradient tensor, can be used for further differentiation - :returns: An array [P] with the gradients of the model. + Returns: + An array [P] with the gradients of the model. """ + x = x.to(self.device) y = y.to(self.device) @@ -105,10 +121,15 @@ def grad( return flatten_tensors_to_vector(grad_f) def hessian(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: - """Calculates the explicit hessian of model parameters given data ($x$ and $y$). - :param x: A matrix [NxD] representing the features $x_i$. - :param y: A matrix [NxK] representing the target values $y_i$. - :returns: A tensor representing the hessian of the loss wrt. the model parameters. + r""" + Calculates the explicit hessian of model parameters given data \(x\) and \(y\). + + Args: + x: A matrix [NxD] representing the features \(x_i\). + y: A matrix [NxK] representing the target values \(y_i\). + + Returns: + A tensor representing the hessian of the loss with respect to the model parameters. """ def model_func(param): @@ -136,24 +157,25 @@ def mvp( *, progress: bool = False, ) -> torch.Tensor: + r""" + Calculates the second-order derivative of the model along directions v. + This second-order derivative can be selected through the `backprop_on` argument. + + Args: + grad_xy: An array [P] holding the gradients of the model parameters with respect to input + \(x\) and labels \(y\), where P is the number of parameters of the model. + It is typically obtained through `self.grad`. + v: An array ([DxP] or even one-dimensional [D]) which multiplies the matrix, + where D is the number of directions. + progress: If True, progress will be printed. + backprop_on: Tensor used in the second backpropagation + (the first one is defined via grad_xy). + + Returns: + A matrix representing the implicit matrix-vector product of the model along the given directions. + The output shape is [DxM], with M being the number of elements of `backprop_on`. """ - Calculates second order derivative of the model along directions v. - This second order derivative can be selected through the backprop_on argument. - - :param grad_xy: an array [P] holding the gradients of the model - parameters wrt input $x$ and labels $y$, where P is the number of - parameters of the model. It is typically obtained through - self.grad. - :param v: An array ([DxP] or even one dimensional [D]) which - multiplies the matrix, where D is the number of directions. - :param progress: True, iff progress shall be printed. - :param backprop_on: tensor used in the second backpropagation (the first - one is along $x$ and $y$ as defined via grad_xy). - :returns: A matrix representing the implicit matrix vector product - of the model along the given directions. Output shape is [DxP] if - backprop_on is None, otherwise [DxM], with M the number of elements - of backprop_on. - """ + device = grad_xy.device v = as_tensor(v, warn=False).to(device) if v.ndim == 1: @@ -173,11 +195,12 @@ def mvp( @dataclass class LowRankProductRepresentation: - """ - Representation of a low rank product of the form $H = V D V^T$, where D is a diagonal matrix and - V is orthogonal - :param eigen_vals: diagonal of D - :param projections: the matrix V + r""" + Representation of a low rank product of the form \(H = V D V^T\), where D is a diagonal matrix and V is orthogonal. + + Args: + eigen_vals (tensor or array): Diagonal of D. + projections (tensor or matrix): The matrix V. """ eigen_vals: torch.Tensor @@ -216,38 +239,46 @@ def lanzcos_low_rank_hessian_approx( eigen_computation_on_gpu: bool = False, torch_dtype: torch.dtype = None, ) -> LowRankProductRepresentation: - """ + r""" Calculates a low-rank approximation of the Hessian matrix of a scalar-valued - function using the implicitly restarted Lanczos algorithm. - - :param hessian_vp: A function that takes a vector and returns the product of - the Hessian of the loss function. - :param matrix_shape: The shape of the matrix, represented by hessian vector - product. - :param hessian_perturbation: Optional regularization parameter added to the - Hessian-vector product for numerical stability. - :param rank_estimate: The number of eigenvalues and corresponding eigenvectors - to compute. Represents the desired rank of the Hessian approximation. - :param krylov_dimension: The number of Krylov vectors to use for the Lanczos - method. If not provided, it defaults to - $min(model.num_parameters, max(2*rank_estimate + 1, 20))$. - :param tol: The stopping criteria for the Lanczos algorithm, which stops when - the difference in the approximated eigenvalue is less than ``tol``. - Defaults to 1e-6. - :param max_iter: The maximum number of iterations for the Lanczos method. If - not provided, it defaults to ``10 * model.num_parameters``. - :param device: The device to use for executing the hessian vector product. - :param eigen_computation_on_gpu: If ``True``, tries to execute the eigen pair - approximation on the provided device via `cupy `_ - implementation. Make sure that either your model is small enough, or you - use a small rank_estimate to fit your device's memory. If ``False``, the - eigen pair approximation is executed on the CPU with scipy's wrapper to - ARPACK. - :param torch_dtype: if not provided, current torch default dtype is used for - conversion to torch. - - :return: An object that contains the top- ``rank_estimate`` eigenvalues and - corresponding eigenvectors of the Hessian. + function using the implicitly restarted Lanczos algorithm, i.e.: + + \[ H_{\text{approx}} = V D V^T\] + + where \(D\) is a diagonal matrix with the top (in absolute value) `rank_estimate` eigenvalues of the Hessian + and \(V\) contains the corresponding eigenvectors. + + Args: + hessian_vp: A function that takes a vector and returns the product of + the Hessian of the loss function. + matrix_shape: The shape of the matrix, represented by the hessian vector + product. + hessian_perturbation: Regularization parameter added to the + Hessian-vector product for numerical stability. + rank_estimate: The number of eigenvalues and corresponding eigenvectors + to compute. Represents the desired rank of the Hessian approximation. + krylov_dimension: The number of Krylov vectors to use for the Lanczos + method. If not provided, it defaults to + \( \min(\text{model.num_parameters}, \max(2 \times \text{rank_estimate} + 1, 20)) \). + tol: The stopping criteria for the Lanczos algorithm, which stops when + the difference in the approximated eigenvalue is less than `tol`. + Defaults to 1e-6. + max_iter: The maximum number of iterations for the Lanczos method. If + not provided, it defaults to \( 10 \cdot \text{model.num_parameters}\). + device: The device to use for executing the hessian vector product. + eigen_computation_on_gpu: If True, tries to execute the eigen pair + approximation on the provided device via `cupy `_ + implementation. Ensure that either your model is small enough, or you + use a small rank_estimate to fit your device's memory. If False, the + eigen pair approximation is executed on the CPU with scipy's wrapper to + ARPACK. + torch_dtype: If not provided, the current torch default dtype is used for + conversion to torch. + + Returns: + A [LowRankProductRepresentation][pydvl.influence.torch.torch_differentiable.LowRankProductRepresentation] + instance that contains the top (up until rank_estimate) eigenvalues + and corresponding eigenvectors of the Hessian. """ torch_dtype = torch.get_default_dtype() if torch_dtype is None else torch_dtype @@ -325,32 +356,42 @@ def model_hessian_low_rank( max_iter: Optional[int] = None, eigen_computation_on_gpu: bool = False, ) -> LowRankProductRepresentation: - """ + r""" Calculates a low-rank approximation of the Hessian matrix of the model's loss function using the implicitly - restarted Lanczos algorithm. - - :param model: A PyTorch model instance that is twice differentiable, wrapped into :class:`TorchTwiceDifferential`. - The Hessian will be calculated with respect to this model's parameters. - :param training_data: A DataLoader instance that provides the model's training data. - Used in calculating the Hessian-vector products. - :param hessian_perturbation: Optional regularization parameter added to the Hessian-vector product - for numerical stability. - :param rank_estimate: The number of eigenvalues and corresponding eigenvectors to compute. - Represents the desired rank of the Hessian approximation. - :param krylov_dimension: The number of Krylov vectors to use for the Lanczos method. - If not provided, it defaults to $min(model.num_parameters, max(2*rank_estimate + 1, 20))$. - :param tol: The stopping criteria for the Lanczos algorithm, which stops when the difference - in the approximated eigenvalue is less than `tol`. Defaults to 1e-6. - :param max_iter: The maximum number of iterations for the Lanczos method. If not provided, it defaults to - $10*model.num_parameters$ - :param eigen_computation_on_gpu: If True, tries to execute the eigen pair approximation on the provided - device via cupy implementation. - Make sure, that either your model is small enough or you use a - small rank_estimate to fit your device's memory. - If False, the eigen pair approximation is executed on the CPU by scipy wrapper to - ARPACK. - :return: A `LowRankProductRepresentation` instance that contains the top (up until rank_estimate) eigenvalues - and corresponding eigenvectors of the Hessian. + restarted Lanczos algorithm, i.e. + + \[ H_{\text{approx}} = V D V^T\] + + where \(D\) is a diagonal matrix with the top (in absolute value) `rank_estimate` eigenvalues of the Hessian + and \(V\) contains the corresponding eigenvectors. + + + Args: + model: A PyTorch model instance that is twice differentiable, wrapped into `TorchTwiceDifferential`. + The Hessian will be calculated with respect to this model's parameters. + training_data: A DataLoader instance that provides the model's training data. + Used in calculating the Hessian-vector products. + hessian_perturbation: Optional regularization parameter added to the Hessian-vector product + for numerical stability. + rank_estimate: The number of eigenvalues and corresponding eigenvectors to compute. + Represents the desired rank of the Hessian approximation. + krylov_dimension: The number of Krylov vectors to use for the Lanczos method. + If not provided, it defaults to min(model.num_parameters, max(2*rank_estimate + 1, 20)). + tol: The stopping criteria for the Lanczos algorithm, which stops when the difference + in the approximated eigenvalue is less than `tol`. Defaults to 1e-6. + max_iter: The maximum number of iterations for the Lanczos method. If not provided, it defaults to + 10*model.num_parameters. + eigen_computation_on_gpu: If True, tries to execute the eigen pair approximation on the provided + device via cupy implementation. + Make sure, that either your model is small enough or you use a + small rank_estimate to fit your device's memory. + If False, the eigen pair approximation is executed on the CPU by scipy wrapper to + ARPACK. + + Returns: + A [LowRankProductRepresentation][pydvl.influence.torch.torch_differentiable.LowRankProductRepresentation] + instance that contains the top (up until rank_estimate) eigenvalues + and corresponding eigenvectors of the Hessian. """ raw_hvp = get_hvp_function( model.model, model.loss, training_data, use_hessian_avg=True @@ -394,10 +435,14 @@ def unsqueeze(x: torch.Tensor, dim: int) -> torch.Tensor: """ Add a singleton dimension at a specified position in a tensor. - :param x: A PyTorch tensor. - :param dim: The position at which to add the singleton dimension. Zero-based indexing. - :return: A new tensor with an additional singleton dimension. + Args: + x: A PyTorch tensor. + dim: The position at which to add the singleton dimension. Zero-based indexing. + + Returns: + A new tensor with an additional singleton dimension. """ + return x.unsqueeze(dim) @staticmethod @@ -448,17 +493,18 @@ def solve_linear( b: torch.Tensor, hessian_perturbation: float = 0.0, ) -> InverseHvpResult: - """Given a model and training data, it finds x s.t. $Hx = b$, with $H$ being - the model hessian. + r""" + Given a model and training data, it finds x such that \(Hx = b\), with \(H\) being the model hessian. - :param model: A model wrapped in the TwiceDifferentiable interface. - :param training_data: A DataLoader containing the training data. - :param b: a vector or matrix, the right hand side of the equation $Hx = b$. - :param hessian_perturbation: regularization of the hessian + Args: + model: A model wrapped in the TwiceDifferentiable interface. + training_data: A DataLoader containing the training data. + b: A vector or matrix, the right hand side of the equation \(Hx = b\). + hessian_perturbation: Regularization of the hessian. - :return: An array that solves the inverse problem, - i.e. it returns $x$ such that $Hx = b$, and a dictionary containing - information about the solution. + Returns: + Instance of [InverseHvpResult], having an array that solves the inverse problem, + i.e. it returns \(x\) such that \(Hx = b\), and a dictionary containing information about the solution. """ all_x, all_y = [], [] @@ -486,26 +532,29 @@ def solve_batch_cg( maxiter: Optional[int] = None, progress: bool = False, ) -> InverseHvpResult: - """ + r""" Given a model and training data, it uses conjugate gradient to calculate the - inverse of the Hessian Vector Product. More precisely, it finds x s.t. $Hx = - b$, with $H$ being the model hessian. For more info, see - `Wikipedia `_ - - :param model: A model wrapped in the TwiceDifferentiable interface. - :param training_data: A DataLoader containing the training data. - :param b: a vector or matrix, the right hand side of the equation $Hx = b$. - :param hessian_perturbation: regularization of the hessian - :param x0: initial guess for hvp. If None, defaults to b - :param rtol: maximum relative tolerance of result - :param atol: absolute tolerance of result - :param maxiter: maximum number of iterations. If None, defaults to 10*len(b) - :param progress: If True, display progress bars. - - :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$, - and a dictionary containing information about the convergence of CG, one - entry for each line of the matrix. + inverse of the Hessian Vector Product. More precisely, it finds x such that \(Hx = + b\), with \(H\) being the model hessian. For more info, see + [Wikipedia](https://en.wikipedia.org/wiki/Conjugate_gradient_method). + + Args: + model: A model wrapped in the TwiceDifferentiable interface. + training_data: A DataLoader containing the training data. + b: A vector or matrix, the right hand side of the equation \(Hx = b\). + hessian_perturbation: Regularization of the hessian. + x0: Initial guess for hvp. If None, defaults to b. + rtol: Maximum relative tolerance of result. + atol: Absolute tolerance of result. + maxiter: Maximum number of iterations. If None, defaults to 10*len(b). + progress: If True, display progress bars. + + Returns: + Instance of [InverseHvpResult], having a matrix of shape [NxP] with each line being a solution of \(Ax=b\), + and a dictionary containing information about the convergence of CG, + one entry for each line of the matrix. """ + total_grad_xy = 0 total_points = 0 for x, y in maybe_progress(training_data, progress, desc="Batch Train Gradients"): @@ -536,18 +585,22 @@ def solve_cg( atol: float = 1e-7, maxiter: Optional[int] = None, ) -> InverseHvpResult: - """Conjugate gradient solver for the Hessian vector product - - :param hvp: a Callable Hvp, operating with tensors of size N - :param b: a vector or matrix, the right hand side of the equation $Hx = b$. - :param x0: initial guess for hvp - :param rtol: maximum relative tolerance of result - :param atol: absolute tolerance of result - :param maxiter: maximum number of iterations. If None, defaults to 10*len(b) - - :return: A vector x, solution of $Ax=b$, and a dictionary containing + r""" + Conjugate gradient solver for the Hessian vector product. + + Args: + hvp: A callable Hvp, operating with tensors of size N. + b: A vector or matrix, the right hand side of the equation \(Hx = b\). + x0: Initial guess for hvp. + rtol: Maximum relative tolerance of result. + atol: Absolute tolerance of result. + maxiter: Maximum number of iterations. If None, defaults to 10*len(b). + + Returns: + Instance of [InverseHvpResult], with a vector x, solution of \(Ax=b\), and a dictionary containing information about the convergence of CG. """ + if x0 is None: x0 = torch.clone(b) if maxiter is None: @@ -594,30 +647,33 @@ def solve_lissa( ) -> InverseHvpResult: r""" Uses LISSA, Linear time Stochastic Second-Order Algorithm, to iteratively - approximate the inverse Hessian. More precisely, it finds x s.t. $Hx = b$, - with $H$ being the model's second derivative wrt. the parameters. + approximate the inverse Hessian. More precisely, it finds x s.t. \(Hx = b\), + with \(H\) being the model's second derivative wrt. the parameters. This is done with the update - $$H^{-1}_{j+1} b = b + (I - d) \ H - \frac{H^{-1}_j b}{s},$$ + \[H^{-1}_{j+1} b = b + (I - d) \ H - \frac{H^{-1}_j b}{s},\] - where $I$ is the identity matrix, $d$ is a dampening term and $s$ a scaling + where \(I\) is the identity matrix, \(d\) is a dampening term and \(s\) a scaling factor that are applied to help convergence. For details, see - :footcite:t:`koh_understanding_2017` and the original paper - :footcite:t:`agarwal_2017_second`. - - :param model: A model wrapped in the TwiceDifferentiable interface. - :param training_data: A DataLoader containing the training data. - :param b: a vector or matrix, the right hand side of the equation $Hx = b$. - :param hessian_perturbation: regularization of the hessian - :param progress: If True, display progress bars. - :param maxiter: maximum number of iterations, - :param dampen: dampening factor, defaults to 0 for no dampening - :param scale: scaling factor, defaults to 10 - :param h0: initial guess for hvp - - :return: A matrix of shape [NxP] with each line being a solution of $Ax=b$, + [@koh_understanding_2017] and the original paper [@agarwal_2017_second]. + + Args: + model: A model wrapped in the TwiceDifferentiable interface. + training_data: A DataLoader containing the training data. + b: A vector or matrix, the right hand side of the equation \(Hx = b\). + hessian_perturbation: Regularization of the hessian. + maxiter: Maximum number of iterations. + dampen: Dampening factor, defaults to 0 for no dampening. + scale: Scaling factor, defaults to 10. + h0: Initial guess for hvp. + rtol: tolerance to use for early stopping + progress: If True, display progress bars. + + Returns: + Instance of [InverseHvpResult], with a matrix of shape [NxP] with each line being a solution of \(Ax=b\), and a dictionary containing information about the accuracy of the solution. """ + if h0 is None: h_estimate = torch.clone(b) else: @@ -632,9 +688,12 @@ def lissa_step( """Given an estimate of the hessian inverse and the regularised hessian vector product, it computes the next estimate. - :param h: an estimate of the hessian inverse - :param reg_hvp: regularised hessian vector product - :return: the next estimate of the hessian inverse + Args: + h: An estimate of the hessian inverse. + reg_hvp: Regularised hessian vector product. + + Returns: + The next estimate of the hessian inverse. """ return b + (1 - dampen) * h - reg_hvp(h) / scale @@ -677,37 +736,49 @@ def solve_arnoldi( max_iter: Optional[int] = None, eigen_computation_on_gpu: bool = False, ) -> InverseHvpResult: - """ - Solves the linear system Hx = b, where H is the Hessian of the model's loss function and b is the given right-hand - side vector. The Hessian is approximated using a low-rank representation. - - :param model: A PyTorch model instance that is twice differentiable, wrapped into :class:`TorchTwiceDifferential`. - The Hessian will be calculated with respect to this model's parameters. - :param training_data: A DataLoader instance that provides the model's training data. - Used in calculating the Hessian-vector products. - :param b: The right-hand side vector in the system Hx = b. - :param hessian_perturbation: Optional regularization parameter added to the Hessian-vector product - for numerical stability. - :param rank_estimate: The number of eigenvalues and corresponding eigenvectors to compute. - Represents the desired rank of the Hessian approximation. - :param krylov_dimension: The number of Krylov vectors to use for the Lanczos method. - If not provided, it defaults to $min(model.num_parameters, max(2*rank_estimate + 1, 20))$. - :param low_rank_representation: A LowRankProductRepresentation instance containing a previously computed - low-rank representation of the Hessian. I provided, all other parameters - are ignored, if not, a new low-rank representation will be computed, - using provided parameters. - :param tol: The stopping criteria for the Lanczos algorithm. - If `low_rank_representation` is provided, this parameter is ignored. - :param max_iter: The maximum number of iterations for the Lanczos method. - If `low_rank_representation` is provided, this parameter is ignored. - :param eigen_computation_on_gpu: If True, tries to execute the eigen pair approximation on the model's - device via cupy implementation. - Make sure, that either your model is small enough or you use a - small rank_estimate to fit your device's memory. - If False, the eigen pair approximation is executed on the CPU by scipy wrapper to - ARPACK. - :return: Returns the solution vector x that satisfies the system Hx = b, - where H is a low-rank approximation of the Hessian of the model's loss function. + r""" + Solves the linear system Hx = b, where H is the Hessian of the model's loss function and b is the given + right-hand side vector. + It employs the [implicitly restarted Arnoldi method](https://en.wikipedia.org/wiki/Arnoldi_iteration) for + computing a partial eigen decomposition, which is used fo the inversion i.e. + + \[x = V D^{-1} V^T b\] + + where \(D\) is a diagonal matrix with the top (in absolute value) `rank_estimate` eigenvalues of the Hessian + and \(V\) contains the corresponding eigenvectors. + + Args: + model: A PyTorch model instance that is twice differentiable, wrapped into + [TorchTwiceDifferential][pydvl.influence.torch.torch_differentiable.TorchTwiceDifferentiable]. + The Hessian will be calculated with respect to this model's parameters. + training_data: A DataLoader instance that provides the model's training data. + Used in calculating the Hessian-vector products. + b: The right-hand side vector in the system Hx = b. + hessian_perturbation: Optional regularization parameter added to the Hessian-vector + product for numerical stability. + rank_estimate: The number of eigenvalues and corresponding eigenvectors to compute. + Represents the desired rank of the Hessian approximation. + krylov_dimension: The number of Krylov vectors to use for the Lanczos method. + Defaults to min(model's number of parameters, max(2 times rank_estimate + 1, 20)). + low_rank_representation: An instance of + [LowRankProductRepresentation][pydvl.influence.torch.torch_differentiable.LowRankProductRepresentation] + containing a previously computed low-rank representation of the Hessian. If provided, all other parameters + are ignored; otherwise, a new low-rank representation is computed + using provided parameters. + tol: The stopping criteria for the Lanczos algorithm. + Ignored if `low_rank_representation` is provided. + max_iter: The maximum number of iterations for the Lanczos method. + Ignored if `low_rank_representation` is provided. + eigen_computation_on_gpu: If True, tries to execute the eigen pair approximation on the model's device + via a cupy implementation. Ensure the model size or rank_estimate is appropriate for device memory. + If False, the eigen pair approximation is executed on the CPU by the scipy wrapper to ARPACK. + + Returns: + Instance of [InverseHvpResult][pydvl.influence.torch.torch_differentiable.InverseHvpResult], + having the solution vector x that satisfies the system \(Ax = b\), + where \(A\) is a low-rank approximation of the Hessian \(H\) of the model's loss function, and an instance + of [LowRankProductRepresentation][pydvl.influence.torch.torch_differentiable.LowRankProductRepresentation], + which represents the approximation of H. """ b_device = b.device if hasattr(b, "device") else torch.device("cpu") diff --git a/src/pydvl/influence/torch/util.py b/src/pydvl/influence/torch/util.py index b758458a3..b7e0460ec 100644 --- a/src/pydvl/influence/torch/util.py +++ b/src/pydvl/influence/torch/util.py @@ -20,13 +20,15 @@ def flatten_tensors_to_vector(tensors: Iterable[torch.Tensor]) -> torch.Tensor: """ Flatten multiple tensors into a single 1D tensor (vector). - The function takes an iterable of tensors and reshapes each of them into a 1D tensor. + This function takes an iterable of tensors and reshapes each of them into a 1D tensor. These reshaped tensors are then concatenated together into a single 1D tensor in the order they were given. - :param tensors: An iterable of tensors to be reshaped and concatenated. - :return: A 1D tensor that is the concatenation of all the reshaped input tensors. - """ + Args: + tensors: An iterable of tensors to be reshaped and concatenated. + Returns: + A 1D tensor that is the concatenation of all the reshaped input tensors. + """ return torch.cat([t.contiguous().view(-1) for t in tensors]) @@ -36,18 +38,20 @@ def reshape_vector_to_tensors( """ Reshape a 1D tensor into multiple tensors with specified shapes. - The function takes a 1D tensor (input_vector) and reshapes it into a series of tensors with shapes given by 'target_shapes'. + This function takes a 1D tensor (input_vector) and reshapes it into a series of tensors with shapes given by 'target_shapes'. The reshaped tensors are returned as a tuple in the same order as their corresponding shapes. Note: The total number of elements in 'input_vector' must be equal to the sum of the products of the shapes in 'target_shapes'. - :param input_vector: The 1D tensor to be reshaped. Must be 1D. - :param target_shapes: An iterable of tuples. Each tuple defines the shape of a tensor to be - reshaped from the 'input_vector'. - :return: A tuple of reshaped tensors. - :raises: - ValueError: If 'input_vector' is not a 1D tensor or if the total number of elements - in 'input_vector' does not match the sum of the products of the shapes in 'target_shapes'. + Args: + input_vector: The 1D tensor to be reshaped. Must be 1D. + target_shapes: An iterable of tuples. Each tuple defines the shape of a tensor to be reshaped from the 'input_vector'. + + Returns: + A tuple of reshaped tensors. + + Raises: + ValueError: If 'input_vector' is not a 1D tensor or if the total number of elements in 'input_vector' does not match the sum of the products of the shapes in 'target_shapes'. """ if input_vector.dim() != 1: @@ -88,12 +92,15 @@ def align_structure( it should be a dictionary with the same keys as `source` and each corresponding value in `target` should have the same shape as the value in `source`. - :param source: The reference dictionary containing PyTorch tensors. - :param target: The input to be harmonized. It can be a dictionary, tuple, or tensor. + Args: + source: The reference dictionary containing PyTorch tensors. + target: The input to be harmonized. It can be a dictionary, tuple, or tensor. - :return: The harmonized version of `target`. + Returns: + The harmonized version of `target`. - :raises ValueError: If `target` cannot be harmonized to match `source`. + Raises: + ValueError: If `target` cannot be harmonized to match `source`. """ tangent_dict: Dict[str, torch.Tensor] @@ -145,11 +152,17 @@ def align_structure( def as_tensor(a: Any, warn=True, **kwargs) -> torch.Tensor: - """Converts an array into a torch tensor + """ + Converts an array into a torch tensor. + + Args: + a: Array to convert to tensor. + warn: If True, warns that `a` will be converted. - :param a: array to convert to tensor - :param warn: if True, warns that a will be converted + Returns: + A torch tensor converted from the input array. """ + if warn and not isinstance(a, torch.Tensor): logger.warning("Converting tensor to type torch.Tensor.") return torch.as_tensor(a, **kwargs) diff --git a/src/pydvl/influence/twice_differentiable.py b/src/pydvl/influence/twice_differentiable.py index 37e67e9c6..b7a2b8c1f 100644 --- a/src/pydvl/influence/twice_differentiable.py +++ b/src/pydvl/influence/twice_differentiable.py @@ -13,6 +13,15 @@ TypeVar, ) +__all__ = [ + "DataLoaderType", + "ModelType", + "TensorType", + "InverseHvpResult", + "TwiceDifferentiable", + "TensorUtilities", +] + TensorType = TypeVar("TensorType", bound=Sequence) ModelType = TypeVar("ModelType", bound="TwiceDifferentiable") DataLoaderType = TypeVar("DataLoaderType", bound=Iterable) @@ -20,6 +29,13 @@ @dataclass(frozen=True) class InverseHvpResult(Generic[TensorType]): + r""" + Container class for results of solving a problem \(Ax=b\) + + Args: + x: solution of a problem \(Ax=b\) + info: additional information, to couple with the solution itself + """ x: TensorType info: Dict[str, Any] @@ -29,8 +45,9 @@ def __iter__(self): class TwiceDifferentiable(ABC, Generic[TensorType]): """ - Wraps a differentiable model and loss and provides methods to compute gradients and - second derivative of the loss wrt. the model parameters + Abstract base class for wrappers of differentiable models and losses. Meant to be subclassed for each + supported framework. + Provides methods to compute gradients and second derivative of the loss wrt. the model parameters """ @classmethod @@ -53,30 +70,33 @@ def parameters(self) -> List[TensorType]: def grad( self, x: TensorType, y: TensorType, create_graph: bool = False ) -> TensorType: + r""" + Calculates gradient of model parameters with respect to the model parameters. + + Args: + x: A matrix representing the features \(x_i\). + y: A matrix representing the target values \(y_i\). + create_graph: Used for further differentiation on input parameters. + + Returns: + An array with the gradients of the model. """ - Calculates gradient of model parameters wrt. the model parameters. - - :param x: A matrix representing the features $x_i$. - :param y: A matrix representing the target values $y_i$. - gradients. This is important for further differentiation on input - parameters. - :param create_graph: - :return: A tuple where: the first element is an array with the - gradients of the model, and the second element is the input to the - model as a grad parameters. This can be used for further - differentiation. - """ + pass def hessian(self, x: TensorType, y: TensorType) -> TensorType: - """Calculates the full Hessian of $L(f(x),y)$ with respect to the model - parameters given data ($x$ and $y$). + r""" + Calculates the full Hessian of \(L(f(x),y)\) with respect to the model parameters given data \(x\) and \(y\). - :param x: An array representing the features $x_i$. - :param y: An array representing the target values $y_i$. - :return: The hessian of the model, i.e. the second derivative wrt. the - model parameters. + Args: + x: An array representing the features \(x_i\). + y: An array representing the target values \(y_i\). + + Returns: + A tensor representing the Hessian of the model, i.e. the second derivative + with respect to the model parameters. """ + pass @staticmethod @@ -88,23 +108,22 @@ def mvp( *, progress: bool = False, ) -> TensorType: - """ - Calculates second order derivative of the model along directions v. - This second order derivative can be selected through the backprop_on argument. - - :param grad_xy: an array [P] holding the gradients of the model - parameters wrt input $x$ and labels $y$, where P is the number of - parameters of the model. It is typically obtained through - self.grad. - :param v: An array ([DxP] or even one dimensional [D]) which - multiplies the matrix, where D is the number of directions. - :param progress: True, iff progress shall be printed. - :param backprop_on: tensor used in the second backpropagation (the first - one is along $x$ and $y$ as defined via grad_xy). - :returns: A matrix representing the implicit matrix vector product - of the model along the given directions. Output shape is [DxP] if - backprop_on is None, otherwise [DxM], with M the number of elements - of backprop_on. + r""" + Calculates the second order derivative of the model along directions \(v\). + The second order derivative can be selected through the `backprop_on` argument. + + Args: + grad_xy: An array [P] holding the gradients of the model parameters with respect to input \(x\) and + labels \(y\). \(P\) is the number of parameters of the model. Typically obtained through `self.grad`. + v: An array ([DxP] or even one-dimensional [D]) which multiplies the matrix. + \(D\) is the number of directions. + progress: If `True`, progress is displayed. + backprop_on: Tensor used in the second backpropagation. The first one is along \(x\) and \(y\) + as defined via `grad_xy`. + + Returns: + A matrix representing the implicit matrix-vector product of the model along the given directions. + Output shape is [DxM], where \(M\) is the number of elements of `backprop_on`. """ @@ -116,13 +135,16 @@ def __init_subclass__(cls, **kwargs): """ Automatically registers non-abstract subclasses in the registry. - Checks if `twice_differentiable_type` is defined in the subclass and - is of correct type. Raises `TypeError` if either attribute is missing or incorrect. + This method checks if `twice_differentiable_type` is defined in the subclass and if it is of the correct type. + If either attribute is missing or incorrect, a `TypeError` is raised. + + Args: + kwargs: Additional keyword arguments. - :param kwargs: Additional keyword arguments. - :raise TypeError: If the subclass does not define `twice_differentiable_type`, - or if it is not of correct type. + Raises: + TypeError: If the subclass does not define `twice_differentiable_type`, or if it is not of the correct type. """ + if not hasattr(cls, "twice_differentiable_type") or not isinstance( cls.twice_differentiable_type, type ): @@ -193,13 +215,26 @@ def from_twice_differentiable( twice_diff: TwiceDifferentiable, ) -> Type["TensorUtilities"]: """ - Factory method to create an instance of `TensorUtilities` from an instance of `TwiceDifferentiable`. - - :param twice_diff: An instance of `TwiceDifferentiable` - for which a corresponding `TensorUtilities` object is required. - :return: An instance of `TensorUtilities` corresponding to the provided `TwiceDifferentiable` object. - :raises KeyError: If there's no registered `TensorUtilities` for the provided `TwiceDifferentiable` type. + Factory method to create an instance of a subclass + [TensorUtilities][pydvl.influence.twice_differentiable.TensorUtilities] from an instance of a subclass of + [TwiceDifferentiable][pydvl.influence.twice_differentiable.TwiceDifferentiable]. + + Args: + twice_diff: An instance of a subclass of + [TwiceDifferentiable][pydvl.influence.twice_differentiable.TwiceDifferentiable] + for which a corresponding [TensorUtilities][pydvl.influence.twice_differentiable.TensorUtilities] + object is required. + + Returns: + An subclass of [TensorUtilities][pydvl.influence.twice_differentiable.TensorUtilities] + registered to the provided subclass instance of + [TwiceDifferentiable][pydvl.influence.twice_differentiable.TwiceDifferentiable] object. + + Raises: + KeyError: If there's no registered [TensorUtilities][pydvl.influence.twice_differentiable.TensorUtilities] + for the provided [TwiceDifferentiable][pydvl.influence.twice_differentiable.TwiceDifferentiable] type. """ + tu = cls.registry.get(type(twice_diff), None) if tu is None: From 2439c2d2bc1270a334da4be2187c7e8c60037f4b Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 24 Aug 2023 22:17:04 +0200 Subject: [PATCH 303/436] Rearrange requirements (no additions) --- requirements-docs.txt | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/requirements-docs.txt b/requirements-docs.txt index e41baf78a..e04c3064c 100644 --- a/requirements-docs.txt +++ b/requirements-docs.txt @@ -1,15 +1,15 @@ mike -mkdocs==1.4.2 -mkdocs-material +mkdocs==1.5.2 mkdocstrings[python]>=0.18 -mkdocs-jupyter mkdocs-alias-plugin>=0.6.0 mkdocs-autorefs +mkdocs-bibtex mkdocs-gen-files +mkdocs-git-revision-date-localized-plugin +mkdocs-jupyter mkdocs-literate-nav +mkdocs-material mkdocs-section-index -mkdocs-bibtex mkdocs-macros-plugin neoteroi-mkdocs # Needed for card grid on home page -mkdocs-git-revision-date-localized-plugin -pypandoc_binary \ No newline at end of file +pypandoc_binary From 36fb44357f6a419a01536d4f38bd6197df87fcb2 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 24 Aug 2023 22:30:13 +0200 Subject: [PATCH 304/436] Add link to institute, twitter and linkedin --- docs/overrides/partials/copyright.html | 19 +++++++++++++++++++ mkdocs.yml | 5 +++++ 2 files changed, 24 insertions(+) create mode 100644 docs/overrides/partials/copyright.html diff --git a/docs/overrides/partials/copyright.html b/docs/overrides/partials/copyright.html new file mode 100644 index 000000000..942387ae9 --- /dev/null +++ b/docs/overrides/partials/copyright.html @@ -0,0 +1,19 @@ +
+ {% if config.copyright %} +
+ {% if config.extra.copyright_link %} + + {{ config.copyright }} + + {% else %} + {{ config.copyright }} + {% endif %} +
+ {% endif %} + {% if not config.extra.generator == false %} + Made with + + Material for MkDocs + + {% endif %} +
diff --git a/mkdocs.yml b/mkdocs.yml index 371fe8fbc..78fec2bd4 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -109,6 +109,7 @@ extra: transferlab: website: https://transferlab.appliedai.de data_valuation_review: https://transferlab.appliedai.de/reviews/data-valuation + copyright_link: https://appliedai-institute.de version: provider: mike default: stable @@ -117,6 +118,10 @@ extra: link: https://github.com/appliedAI-Initiative/pyDVL - icon: fontawesome/brands/python link: https://pypi.org/project/pyDVL/ + - icon: fontawesome/brands/twitter + link: https://twitter.com/aai_transferlab + - icon: fontawesome/brands/linkedin + link: https://de.linkedin.com/company/appliedai-institute-for-europe-ggmbh markdown_extensions: - admonition From c00550eb8b6e996893e7e80612b2b7b0158e3808 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 24 Aug 2023 22:31:05 +0200 Subject: [PATCH 305/436] Update bib --- docs/assets/pydvl.bib | 191 ++++++++++++++++++++++++------------------ 1 file changed, 108 insertions(+), 83 deletions(-) diff --git a/docs/assets/pydvl.bib b/docs/assets/pydvl.bib index 1d2c6d210..22da65ba7 100644 --- a/docs/assets/pydvl.bib +++ b/docs/assets/pydvl.bib @@ -1,9 +1,9 @@ @article{castro_polynomial_2009, title = {Polynomial Calculation of the {{Shapley}} Value Based on Sampling}, - author = {Castro, Javier and G{\'o}mez, Daniel and Tejada, Juan}, - year = {2009}, - month = may, - journal = {Computers \& Operations Research}, + author = {Castro, Javier and Gómez, Daniel and Tejada, Juan}, + date = {2009-05-01}, + journaltitle = {Computers \& Operations Research}, + shortjournal = {Computers \& Operations Research}, series = {Selected Papers Presented at the {{Tenth International Symposium}} on {{Locational Decisions}} ({{ISOLDE X}})}, volume = {36}, number = {5}, @@ -21,43 +21,65 @@ @inproceedings{ghorbani_data_2019 shorttitle = {Data {{Shapley}}}, booktitle = {Proceedings of the 36th {{International Conference}} on {{Machine Learning}}, {{PMLR}}}, author = {Ghorbani, Amirata and Zou, James}, - year = {2019}, - month = may, + date = {2019-05-24}, eprint = {1904.02868}, + eprinttype = {arxiv}, pages = {2242--2251}, publisher = {{PMLR}}, issn = {2640-3498}, url = {http://proceedings.mlr.press/v97/ghorbani19c.html}, urldate = {2020-11-01}, abstract = {As data becomes the fuel driving technological and economic growth, a fundamental challenge is how to quantify the value of data in algorithmic predictions and decisions. For example, in healthcare and consumer markets, it has been suggested that individuals should be compensated for the data that they generate, but it is not clear what is an equitable valuation for individual data. In this work, we develop a principled framework to address data valuation in the context of supervised machine learning. Given a learning algorithm trained on n data points to produce a predictor, we propose data Shapley as a metric to quantify the value of each training datum to the predictor performance. Data Shapley uniquely satisfies several natural properties of equitable data valuation. We develop Monte Carlo and gradient-based methods to efficiently estimate data Shapley values in practical settings where complex learning algorithms, including neural networks, are trained on large datasets. In addition to being equitable, extensive experiments across biomedical, image and synthetic data demonstrate that data Shapley has several other benefits: 1) it is more powerful than the popular leave-one-out or leverage score in providing insight on what data is more valuable for a given learning task; 2) low Shapley value data effectively capture outliers and corruptions; 3) high Shapley value data inform what type of new data to acquire to improve the predictor.}, - archiveprefix = {arxiv}, + eventtitle = {International {{Conference}} on {{Machine Learning}} ({{ICML}} 2019)}, langid = {english}, keywords = {notion} } -@article{hampel1974influence, - title={The influence curve and its role in robust estimation}, - author={Hampel, Frank R}, - journal={Journal of the american statistical association}, - volume={69}, - number={346}, - pages={383--393}, - year={1974}, - publisher={Taylor \& Francis} +@article{hampel_influence_1974, + title = {The {{Influence Curve}} and {{Its Role}} in {{Robust Estimation}}}, + author = {Hampel, Frank R.}, + date = {1974}, + journaltitle = {Journal of the American Statistical Association}, + shortjournal = {J. Am. Stat. Assoc.}, + volume = {69}, + number = {346}, + eprint = {2285666}, + eprinttype = {jstor}, + pages = {383--393}, + publisher = {{[American Statistical Association, Taylor \& Francis, Ltd.]}}, + issn = {0162-1459}, + doi = {10.2307/2285666}, + url = {https://www.jstor.org/stable/2285666}, + urldate = {2022-05-09}, + abstract = {This paper treats essentially the first derivative of an estimator viewed as functional and the ways in which it can be used to study local robustness properties. A theory of robust estimation "near" strict parametric models is briefly sketched and applied to some classical situations. Relations between von Mises functionals, the jackknife and U-statistics are indicated. A number of classical and new estimators are discussed, including trimmed and Winsorized means, Huber-estimators, and more generally maximum likelihood and M-estimators. Finally, a table with some numerical robustness properties is given.} +} + +@online{hataya_nystrom_2023, + title = {Nystrom {{Method}} for {{Accurate}} and {{Scalable Implicit Differentiation}}}, + author = {Hataya, Ryuichiro and Yamada, Makoto}, + date = {2023-02-19}, + eprint = {2302.09726}, + eprinttype = {arxiv}, + eprintclass = {cs}, + url = {http://arxiv.org/abs/2302.09726}, + urldate = {2023-05-01}, + abstract = {The essential difficulty of gradient-based bilevel optimization using implicit differentiation is to estimate the inverse Hessian vector product with respect to neural network parameters. This paper proposes to tackle this problem by the Nystrom method and the Woodbury matrix identity, exploiting the low-rankness of the Hessian. Compared to existing methods using iterative approximation, such as conjugate gradient and the Neumann series approximation, the proposed method avoids numerical instability and can be efficiently computed in matrix operations without iterations. As a result, the proposed method works stably in various tasks and is faster than iterative approximations. Throughout experiments including large-scale hyperparameter optimization and meta learning, we demonstrate that the Nystrom method consistently achieves comparable or even superior performance to other approaches. The source code is available from https://github.com/moskomule/hypergrad.}, + pubstate = {preprint}, + keywords = {notion} } @inproceedings{jia_efficient_2019, title = {Towards {{Efficient Data Valuation Based}} on the {{Shapley Value}}}, booktitle = {Proceedings of the 22nd {{International Conference}} on {{Artificial Intelligence}} and {{Statistics}}}, - author = {Jia, Ruoxi and Dao, David and Wang, Boxin and Hubis, Frances Ann and Hynes, Nick and G{\"u}rel, Nezihe Merve and Li, Bo and Zhang, Ce and Song, Dawn and Spanos, Costas J.}, - year = {2019}, - month = apr, + author = {Jia, Ruoxi and Dao, David and Wang, Boxin and Hubis, Frances Ann and Hynes, Nick and Gürel, Nezihe Merve and Li, Bo and Zhang, Ce and Song, Dawn and Spanos, Costas J.}, + date = {2019-04-11}, pages = {1167--1176}, publisher = {{PMLR}}, issn = {2640-3498}, url = {http://proceedings.mlr.press/v89/jia19a.html}, urldate = {2021-02-12}, - abstract = {``How much is my data worth?'' is an increasingly common question posed by organizations and individuals alike. An answer to this question could allow, for instance, fairly distributing profits...}, + abstract = {“How much is my data worth?” is an increasingly common question posed by organizations and individuals alike. An answer to this question could allow, for instance, fairly distributing profits...}, + eventtitle = {International {{Conference}} on {{Artificial Intelligence}} and {{Statistics}} ({{AISTATS}})}, langid = {english}, keywords = {notion} } @@ -66,9 +88,9 @@ @article{jia_efficient_2019a title = {Efficient Task-Specific Data Valuation for Nearest Neighbor Algorithms}, shorttitle = {{{VLDB}} 2019}, author = {Jia, Ruoxi and Dao, David and Wang, Boxin and Hubis, Frances Ann and Gurel, Nezihe Merve and Li, Bo and Zhang, Ce and Spanos, Costas and Song, Dawn}, - year = {2019}, - month = jul, - journal = {Proceedings of the VLDB Endowment}, + date = {2019-07-01}, + journaltitle = {Proceedings of the VLDB Endowment}, + shortjournal = {Proc. VLDB Endow.}, volume = {12}, number = {11}, pages = {1610--1623}, @@ -76,7 +98,7 @@ @article{jia_efficient_2019a doi = {10.14778/3342263.3342637}, url = {https://doi.org/10.14778/3342263.3342637}, urldate = {2021-02-12}, - abstract = {Given a data set D containing millions of data points and a data consumer who is willing to pay for \$X to train a machine learning (ML) model over D, how should we distribute this \$X to each data point to reflect its "value"? In this paper, we define the "relative value of data" via the Shapley value, as it uniquely possesses properties with appealing real-world interpretations, such as fairness, rationality and decentralizability. For general, bounded utility functions, the Shapley value is known to be challenging to compute: to get Shapley values for all N data points, it requires O(2N) model evaluations for exact computation and O(N log N) for ({$\epsilon$}, {$\delta$})-approximation. In this paper, we focus on one popular family of ML models relying on K-nearest neighbors (KNN). The most surprising result is that for unweighted KNN classifiers and regressors, the Shapley value of all N data points can be computed, exactly, in O(N log N) time - an exponential improvement on computational complexity! Moreover, for ({$\epsilon$}, {$\delta$})-approximation, we are able to develop an algorithm based on Locality Sensitive Hashing (LSH) with only sublinear complexity O(Nh({$\epsilon$}, K) log N) when {$\epsilon$} is not too small and K is not too large. We empirically evaluate our algorithms on up to 10 million data points and even our exact algorithm is up to three orders of magnitude faster than the baseline approximation algorithm. The LSH-based approximation algorithm can accelerate the value calculation process even further. We then extend our algorithm to other scenarios such as (1) weighed KNN classifiers, (2) different data points are clustered by different data curators, and (3) there are data analysts providing computation who also requires proper valuation. Some of these extensions, although also being improved exponentially, are less practical for exact computation (e.g., O(NK) complexity for weigthed KNN). We thus propose an Monte Carlo approximation algorithm, which is O(N(log N)2/(log K)2) times more efficient than the baseline approximation algorithm.}, + abstract = {Given a data set D containing millions of data points and a data consumer who is willing to pay for \$X to train a machine learning (ML) model over D, how should we distribute this \$X to each data point to reflect its "value"? In this paper, we define the "relative value of data" via the Shapley value, as it uniquely possesses properties with appealing real-world interpretations, such as fairness, rationality and decentralizability. For general, bounded utility functions, the Shapley value is known to be challenging to compute: to get Shapley values for all N data points, it requires O(2N) model evaluations for exact computation and O(N log N) for (ϵ, δ)-approximation. In this paper, we focus on one popular family of ML models relying on K-nearest neighbors (KNN). The most surprising result is that for unweighted KNN classifiers and regressors, the Shapley value of all N data points can be computed, exactly, in O(N log N) time - an exponential improvement on computational complexity! Moreover, for (ϵ, δ)-approximation, we are able to develop an algorithm based on Locality Sensitive Hashing (LSH) with only sublinear complexity O(Nh(ϵ, K) log N) when ϵ is not too small and K is not too large. We empirically evaluate our algorithms on up to 10 million data points and even our exact algorithm is up to three orders of magnitude faster than the baseline approximation algorithm. The LSH-based approximation algorithm can accelerate the value calculation process even further. We then extend our algorithm to other scenarios such as (1) weighed KNN classifiers, (2) different data points are clustered by different data curators, and (3) there are data analysts providing computation who also requires proper valuation. Some of these extensions, although also being improved exponentially, are less practical for exact computation (e.g., O(NK) complexity for weigthed KNN). We thus propose an Monte Carlo approximation algorithm, which is O(N(log N)2/(log K)2) times more efficient than the baseline approximation algorithm.}, langid = {english}, keywords = {notion} } @@ -85,15 +107,15 @@ @inproceedings{koh_understanding_2017 title = {Understanding {{Black-box Predictions}} via {{Influence Functions}}}, booktitle = {Proceedings of the 34th {{International Conference}} on {{Machine Learning}}}, author = {Koh, Pang Wei and Liang, Percy}, - year = {2017}, - month = jul, + date = {2017-07-17}, eprint = {1703.04730}, + eprinttype = {arxiv}, pages = {1885--1894}, publisher = {{PMLR}}, url = {https://proceedings.mlr.press/v70/koh17a.html}, urldate = {2022-05-09}, - abstract = {How can we explain the predictions of a black-box model? In this paper, we use influence functions \textemdash{} a classic technique from robust statistics \textemdash{} to trace a model's prediction through the learning algorithm and back to its training data, thereby identifying training points most responsible for a given prediction. To scale up influence functions to modern machine learning settings, we develop a simple, efficient implementation that requires only oracle access to gradients and Hessian-vector products. We show that even on non-convex and non-differentiable models where the theory breaks down, approximations to influence functions can still provide valuable information. On linear models and convolutional neural networks, we demonstrate that influence functions are useful for multiple purposes: understanding model behavior, debugging models, detecting dataset errors, and even creating visually-indistinguishable training-set attacks.}, - archiveprefix = {arxiv}, + abstract = {How can we explain the predictions of a black-box model? In this paper, we use influence functions — a classic technique from robust statistics — to trace a model’s prediction through the learning algorithm and back to its training data, thereby identifying training points most responsible for a given prediction. To scale up influence functions to modern machine learning settings, we develop a simple, efficient implementation that requires only oracle access to gradients and Hessian-vector products. We show that even on non-convex and non-differentiable models where the theory breaks down, approximations to influence functions can still provide valuable information. On linear models and convolutional neural networks, we demonstrate that influence functions are useful for multiple purposes: understanding model behavior, debugging models, detecting dataset errors, and even creating visually-indistinguishable training-set attacks.}, + eventtitle = {International {{Conference}} on {{Machine Learning}}}, langid = {english}, keywords = {notion} } @@ -103,129 +125,132 @@ @inproceedings{kwon_beta_2022 shorttitle = {Beta {{Shapley}}}, booktitle = {Proceedings of the 25th {{International Conference}} on {{Artificial Intelligence}} and {{Statistics}} ({{AISTATS}}) 2022,}, author = {Kwon, Yongchan and Zou, James}, - year = {2022}, - month = jan, + date = {2022-01-18}, volume = {151}, eprint = {2110.14049}, + eprinttype = {arxiv}, publisher = {{PMLR}}, - address = {{Valencia, Spain}}, + location = {{Valencia, Spain}}, url = {http://arxiv.org/abs/2110.14049}, urldate = {2022-04-06}, abstract = {Data Shapley has recently been proposed as a principled framework to quantify the contribution of individual datum in machine learning. It can effectively identify helpful or harmful data points for a learning algorithm. In this paper, we propose Beta Shapley, which is a substantial generalization of Data Shapley. Beta Shapley arises naturally by relaxing the efficiency axiom of the Shapley value, which is not critical for machine learning settings. Beta Shapley unifies several popular data valuation methods and includes data Shapley as a special case. Moreover, we prove that Beta Shapley has several desirable statistical properties and propose efficient algorithms to estimate it. We demonstrate that Beta Shapley outperforms state-of-the-art data valuation methods on several downstream ML tasks such as: 1) detecting mislabeled training data; 2) learning with subsamples; and 3) identifying points whose addition or removal have the largest positive or negative impact on the model.}, - archiveprefix = {arxiv}, + eventtitle = {{{AISTATS}} 2022}, langid = {english}, keywords = {notion} } +@inproceedings{kwon_efficient_2021, + title = {Efficient {{Computation}} and {{Analysis}} of {{Distributional Shapley Values}}}, + booktitle = {Proceedings of the 24th {{International Conference}} on {{Artificial Intelligence}} and {{Statistics}}}, + author = {Kwon, Yongchan and Rivas, Manuel A. and Zou, James}, + date = {2021-03-18}, + eprint = {2007.01357}, + eprinttype = {arxiv}, + pages = {793--801}, + publisher = {{PMLR}}, + issn = {2640-3498}, + url = {http://proceedings.mlr.press/v130/kwon21a.html}, + urldate = {2021-04-23}, + abstract = {Distributional data Shapley value (DShapley) has recently been proposed as a principled framework to quantify the contribution of individual datum in machine learning. DShapley develops the founda...}, + eventtitle = {International {{Conference}} on {{Artificial Intelligence}} and {{Statistics}}}, + langid = {english} +} + @inproceedings{okhrati_multilinear_2021, title = {A {{Multilinear Sampling Algorithm}} to {{Estimate Shapley Values}}}, booktitle = {2020 25th {{International Conference}} on {{Pattern Recognition}} ({{ICPR}})}, author = {Okhrati, Ramin and Lipani, Aldo}, - year = {2021}, - month = jan, + date = {2021-01}, eprint = {2010.12082}, + eprinttype = {arxiv}, pages = {7992--7999}, publisher = {{IEEE}}, issn = {1051-4651}, doi = {10.1109/ICPR48806.2021.9412511}, url = {https://ieeexplore.ieee.org/abstract/document/9412511}, abstract = {Shapley values are great analytical tools in game theory to measure the importance of a player in a game. Due to their axiomatic and desirable properties such as efficiency, they have become popular for feature importance analysis in data science and machine learning. However, the time complexity to compute Shapley values based on the original formula is exponential, and as the number of features increases, this becomes infeasible. Castro et al. [1] developed a sampling algorithm, to estimate Shapley values. In this work, we propose a new sampling method based on a multilinear extension technique as applied in game theory. The aim is to provide a more efficient (sampling) method for estimating Shapley values. Our method is applicable to any machine learning model, in particular for either multiclass classifications or regression problems. We apply the method to estimate Shapley values for multilayer perceptrons (MLPs) and through experimentation on two datasets, we demonstrate that our method provides more accurate estimations of the Shapley values by reducing the variance of the sampling statistics.}, - archiveprefix = {arxiv}, + eventtitle = {2020 25th {{International Conference}} on {{Pattern Recognition}} ({{ICPR}})}, langid = {english}, keywords = {notion} } -@misc{schioppa_scaling_2021, - title = {Scaling {{Up Influence Functions}}}, - author = {Schioppa, Andrea and Zablotskaia, Polina and Vilar, David and Sokolov, Artem}, - year = {2021}, - month = dec, - number = {arXiv:2112.03052}, - eprint = {arXiv:2112.03052}, - publisher = {{arXiv}}, - doi = {10.48550/arXiv.2112.03052}, - url = {http://arxiv.org/abs/2112.03052}, - urldate = {2023-03-10}, - abstract = {We address efficient calculation of influence functions for tracking predictions back to the training data. We propose and analyze a new approach to speeding up the inverse Hessian calculation based on Arnoldi iteration. With this improvement, we achieve, to the best of our knowledge, the first successful implementation of influence functions that scales to full-size (language and vision) Transformer models with several hundreds of millions of parameters. We evaluate our approach on image classification and sequence-to-sequence tasks with tens to a hundred of millions of training examples. Our code will be available at https://github.com/google-research/jax-influence.}, - archiveprefix = {arxiv}, - keywords = {notion} -} - @inproceedings{schoch_csshapley_2022, title = {{{CS-Shapley}}: {{Class-wise Shapley Values}} for {{Data Valuation}} in {{Classification}}}, shorttitle = {{{CS-Shapley}}}, booktitle = {Proc. of the Thirty-Sixth {{Conference}} on {{Neural Information Processing Systems}} ({{NeurIPS}})}, author = {Schoch, Stephanie and Xu, Haifeng and Ji, Yangfeng}, - year = {2022}, - month = oct, - address = {{New Orleans, Louisiana, USA}}, + date = {2022-10-31}, + location = {{New Orleans, Louisiana, USA}}, url = {https://openreview.net/forum?id=KTOcrOR5mQ9}, urldate = {2022-11-23}, - abstract = {Data valuation, or the valuation of individual datum contributions, has seen growing interest in machine learning due to its demonstrable efficacy for tasks such as noisy label detection. In particular, due to the desirable axiomatic properties, several Shapley value approximations have been proposed. In these methods, the value function is usually defined as the predictive accuracy over the entire development set. However, this limits the ability to differentiate between training instances that are helpful or harmful to their own classes. Intuitively, instances that harm their own classes may be noisy or mislabeled and should receive a lower valuation than helpful instances. In this work, we propose CS-Shapley, a Shapley value with a new value function that discriminates between training instances' in-class and out-of-class contributions. Our theoretical analysis shows the proposed value function is (essentially) the unique function that satisfies two desirable properties for evaluating data values in classification. Further, our experiments on two benchmark evaluation tasks (data removal and noisy label detection) and four classifiers demonstrate the effectiveness of CS-Shapley over existing methods. Lastly, we evaluate the ``transferability'' of data values estimated from one classifier to others, and our results suggest Shapley-based data valuation is transferable for application across different models.}, + abstract = {Data valuation, or the valuation of individual datum contributions, has seen growing interest in machine learning due to its demonstrable efficacy for tasks such as noisy label detection. In particular, due to the desirable axiomatic properties, several Shapley value approximations have been proposed. In these methods, the value function is usually defined as the predictive accuracy over the entire development set. However, this limits the ability to differentiate between training instances that are helpful or harmful to their own classes. Intuitively, instances that harm their own classes may be noisy or mislabeled and should receive a lower valuation than helpful instances. In this work, we propose CS-Shapley, a Shapley value with a new value function that discriminates between training instances’ in-class and out-of-class contributions. Our theoretical analysis shows the proposed value function is (essentially) the unique function that satisfies two desirable properties for evaluating data values in classification. Further, our experiments on two benchmark evaluation tasks (data removal and noisy label detection) and four classifiers demonstrate the effectiveness of CS-Shapley over existing methods. Lastly, we evaluate the “transferability” of data values estimated from one classifier to others, and our results suggest Shapley-based data valuation is transferable for application across different models.}, + eventtitle = {Advances in {{Neural Information Processing Systems}} ({{NeurIPS}} 2022)}, langid = {english}, keywords = {notion} } -@misc{wang_data_2022, +@online{wang_data_2022, title = {Data {{Banzhaf}}: {{A Robust Data Valuation Framework}} for {{Machine Learning}}}, shorttitle = {Data {{Banzhaf}}}, author = {Wang, Jiachen T. and Jia, Ruoxi}, - year = {2022}, - month = oct, - number = {arXiv:2205.15466}, - eprint = {arXiv:2205.15466}, - publisher = {{arXiv}}, + date = {2022-10-22}, + eprint = {2205.15466}, + eprinttype = {arxiv}, + eprintclass = {cs, stat}, doi = {10.48550/arXiv.2205.15466}, url = {http://arxiv.org/abs/2205.15466}, urldate = {2022-10-28}, abstract = {This paper studies the robustness of data valuation to noisy model performance scores. Particularly, we find that the inherent randomness of the widely used stochastic gradient descent can cause existing data value notions (e.g., the Shapley value and the Leave-one-out error) to produce inconsistent data value rankings across different runs. To address this challenge, we first pose a formal framework within which one can measure the robustness of a data value notion. We show that the Banzhaf value, a value notion originated from cooperative game theory literature, achieves the maximal robustness among all semivalues -- a class of value notions that satisfy crucial properties entailed by ML applications. We propose an algorithm to efficiently estimate the Banzhaf value based on the Maximum Sample Reuse (MSR) principle. We derive the lower bound sample complexity for Banzhaf value estimation, and we show that our MSR algorithm's sample complexity is close to the lower bound. Our evaluation demonstrates that the Banzhaf value outperforms the existing semivalue-based data value notions on several downstream ML tasks such as learning with weighted samples and noisy label detection. Overall, our study suggests that when the underlying ML algorithm is stochastic, the Banzhaf value is a promising alternative to the semivalue-based data value schemes given its computational advantage and ability to robustly differentiate data quality.}, - archiveprefix = {arxiv}, + pubstate = {preprint}, keywords = {notion} } @inproceedings{wang_improving_2022, title = {Improving {{Cooperative Game Theory-based Data Valuation}} via {{Data Utility Learning}}}, - booktitle = {International {{Conference}} on {{Learning Representations}} ({{ICLR}} 2022). {{Workshop}} on {{Socially Responsible Machine Learning}}}, author = {Wang, Tianhao and Yang, Yu and Jia, Ruoxi}, - year = {2022}, - month = apr, + date = {2022-04-07}, eprint = {2107.06336v2}, + eprinttype = {arxiv}, publisher = {{arXiv}}, doi = {10.48550/arXiv.2107.06336}, url = {http://arxiv.org/abs/2107.06336v2}, urldate = {2022-05-19}, abstract = {The Shapley value (SV) and Least core (LC) are classic methods in cooperative game theory for cost/profit sharing problems. Both methods have recently been proposed as a principled solution for data valuation tasks, i.e., quantifying the contribution of individual datum in machine learning. However, both SV and LC suffer computational challenges due to the need for retraining models on combinatorially many data subsets. In this work, we propose to boost the efficiency in computing Shapley value or Least core by learning to estimate the performance of a learning algorithm on unseen data combinations. Theoretically, we derive bounds relating the error in the predicted learning performance to the approximation error in SV and LC. Empirically, we show that the proposed method can significantly improve the accuracy of SV and LC estimation.}, - archiveprefix = {arxiv}, + eventtitle = {International {{Conference}} on {{Learning Representations}} ({{ICLR}} 2022). {{Workshop}} on {{Socially Responsible Machine Learning}}}, + langid = {english}, + keywords = {notion} +} + +@inproceedings{wu_davinz_2022, + title = {{{DAVINZ}}: {{Data Valuation}} Using {{Deep Neural Networks}} at {{Initialization}}}, + shorttitle = {{{DAVINZ}}}, + booktitle = {Proceedings of the 39th {{International Conference}} on {{Machine Learning}}}, + author = {Wu, Zhaoxuan and Shu, Yao and Low, Bryan Kian Hsiang}, + date = {2022-06-28}, + pages = {24150--24176}, + publisher = {{PMLR}}, + url = {https://proceedings.mlr.press/v162/wu22j.html}, + urldate = {2022-10-29}, + abstract = {Recent years have witnessed a surge of interest in developing trustworthy methods to evaluate the value of data in many real-world applications (e.g., collaborative machine learning, data marketplaces). Existing data valuation methods typically valuate data using the generalization performance of converged machine learning models after their long-term model training, hence making data valuation on large complex deep neural networks (DNNs) unaffordable. To this end, we theoretically derive a domain-aware generalization bound to estimate the generalization performance of DNNs without model training. We then exploit this theoretically derived generalization bound to develop a novel training-free data valuation method named data valuation at initialization (DAVINZ) on DNNs, which consistently achieves remarkable effectiveness and efficiency in practice. Moreover, our training-free DAVINZ, surprisingly, can even theoretically and empirically enjoy the desirable properties that training-based data valuation methods usually attain, thus making it more trustworthy in practice.}, + eventtitle = {International {{Conference}} on {{Machine Learning}}}, langid = {english}, keywords = {notion} } @inproceedings{yan_if_2021, - title = {If {{You Like Shapley Then You}}'ll {{Love}} the {{Core}}}, + title = {If {{You Like Shapley Then You}}’ll {{Love}} the {{Core}}}, booktitle = {Proceedings of the 35th {{AAAI Conference}} on {{Artificial Intelligence}}, 2021}, author = {Yan, Tom and Procaccia, Ariel D.}, - year = {2021}, - month = may, + date = {2021-05-18}, volume = {6}, pages = {5751--5759}, publisher = {{Association for the Advancement of Artificial Intelligence}}, - address = {{Virtual conference}}, + location = {{Virtual conference}}, doi = {10.1609/aaai.v35i6.16721}, url = {https://ojs.aaai.org/index.php/AAAI/article/view/16721}, urldate = {2021-04-23}, - abstract = {The prevalent approach to problems of credit assignment in machine learning \textemdash{} such as feature and data valuation\textemdash{} is to model the problem at hand as a cooperative game and apply the Shapley value. But cooperative game theory offers a rich menu of alternative solution concepts, which famously includes the core and its variants. Our goal is to challenge the machine learning community's current consensus around the Shapley value, and make a case for the core as a viable alternative. To that end, we prove that arbitrarily good approximations to the least core \textemdash{} a core relaxation that is always feasible \textemdash{} can be computed efficiently (but prove an impossibility for a more refined solution concept, the nucleolus). We also perform experiments that corroborate these theoretical results and shed light on settings where the least core may be preferable to the Shapley value.}, - copyright = {Copyright (c) 2021, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved.}, + abstract = {The prevalent approach to problems of credit assignment in machine learning — such as feature and data valuation— is to model the problem at hand as a cooperative game and apply the Shapley value. But cooperative game theory offers a rich menu of alternative solution concepts, which famously includes the core and its variants. Our goal is to challenge the machine learning community’s current consensus around the Shapley value, and make a case for the core as a viable alternative. To that end, we prove that arbitrarily good approximations to the least core — a core relaxation that is always feasible — can be computed efficiently (but prove an impossibility for a more refined solution concept, the nucleolus). We also perform experiments that corroborate these theoretical results and shed light on settings where the least core may be preferable to the Shapley value.}, + eventtitle = {{{AAAI Conference}} on {{Artificial Intelligence}}}, langid = {english}, keywords = {notion} } - -@article{agarwal_2017_second, - title={Second-order stochastic optimization for machine learning in linear time}, - author={Agarwal, Naman and Bullins, Brian and Hazan, Elad}, - journal={The Journal of Machine Learning Research}, - volume={18}, - number={1}, - pages={4148--4187}, - year={2017}, - publisher={JMLR. org} -} From 5b783868ead7e4a839a2bb274cad97cd4e93af97 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 24 Aug 2023 22:31:21 +0200 Subject: [PATCH 306/436] Fix --- src/pydvl/utils/parallel/backend.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index ccc76ec3d..aa2ff7de8 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -292,8 +292,8 @@ def effective_n_jobs(n_jobs: int, config: ParallelConfig = ParallelConfig()) -> The effective number of jobs, guaranteed to be >= 1. Raises: - RuntimeError if the effective number of jobs returned by the backend - is < 1. + RuntimeError: if the effective number of jobs returned by the backend + is < 1. """ parallel_backend = init_parallel_backend(config) if (eff_n_jobs := parallel_backend.effective_n_jobs(n_jobs)) < 1: From 5da11b374abd49264bbee93f574eab0bdcd30a97 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 24 Aug 2023 22:31:40 +0200 Subject: [PATCH 307/436] Update CONTRIBUTING.md --- CONTRIBUTING.md | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 5f3a17ffe..d9985499b 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -120,7 +120,7 @@ python setup.py sdist bdist_wheel ## Notebooks We use notebooks both as documentation (copied over to `docs/examples`) and as -integration tests. All notebooks in the `notebooks` directory are be executed +integration tests. All notebooks in the `notebooks` directory are executed during the test run. Because run times are typically too long for large datasets, you must check for the `CI` environment variable to work with smaller ones. For example, you can select a subset of the data: @@ -201,6 +201,16 @@ tox -e docs-dev This will rebuild the documentation on changes to `.md` files inside `docs`, notebooks and python files. + +### Adding new pages + +Navigation is configured in `mkdocs.yaml` using the nav section. We use the +plugin [mkdoc-literate-nav](https://oprypin.github.io/mkdocs-literate-nav/) +which allows fine-grained control of the navigation structure. However, most +pages are explicitly listed and manually arranged in the `nav` section of the +configuration. + + ### Using bibliography Bibliographic citations are managed with the plugins From b5b5348f996cefd798428dd108cc0fe488e72414 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 24 Aug 2023 22:32:15 +0200 Subject: [PATCH 308/436] New navigation structure. Split data val docs --- docs/30-data-valuation.md | 672 ------------------ docs/examples/index.md | 10 - .../getting-started.md} | 16 +- .../installation.md} | 10 +- docs/index.md | 6 +- docs/{40-influence.md => influence/index.md} | 45 +- docs/value/index.md | 350 +++++++++ docs/value/semi-values.md | 86 +++ docs/value/shapley.md | 208 ++++++ docs/value/the-core.md | 115 +++ mkdocs.yml | 46 +- 11 files changed, 836 insertions(+), 728 deletions(-) delete mode 100644 docs/30-data-valuation.md delete mode 100644 docs/examples/index.md rename docs/{10-getting-started.md => getting-started/getting-started.md} (70%) rename docs/{20-install.md => getting-started/installation.md} (94%) rename docs/{40-influence.md => influence/index.md} (92%) create mode 100644 docs/value/index.md create mode 100644 docs/value/semi-values.md create mode 100644 docs/value/shapley.md create mode 100644 docs/value/the-core.md diff --git a/docs/30-data-valuation.md b/docs/30-data-valuation.md deleted file mode 100644 index 2e478b04a..000000000 --- a/docs/30-data-valuation.md +++ /dev/null @@ -1,672 +0,0 @@ ---- -title: Computing Data Values -alias: - name: data-valuation - text: Computing Data Values ---- - -# Computing Data Values - -**Data valuation** is the task of assigning a number to each element of a -training set which reflects its contribution to the final performance of a -model trained on it. This value is not an intrinsic property of the element of -interest, but a function of three factors: - -1. The dataset $D$, or more generally, the distribution it was sampled - from (with this we mean that *value* would ideally be the (expected) - contribution of a data point to any random set $D$ sampled from the same - distribution). - -2. The algorithm $\mathcal{A}$ mapping the data $D$ to some estimator $f$ - in a model class $\mathcal{F}$. E.g. MSE minimization to find the parameters - of a linear model. - -3. The performance metric of interest $u$ for the problem. E.g. the $R^2$ - score or the negative MSE over a test set. - -pyDVL collects algorithms for the computation of data values in this sense, -mostly those derived from cooperative game theory. The methods can be found in -the package [pydvl.value][pydvl.value] , with support from modules -[pydvl.utils.dataset][pydvl.utils.dataset] -and [pydvl.utils.utility][pydvl.utils.utility], as detailed below. - -!!! Warning - Be sure to read the section on - [the difficulties using data values][problems-of-data-values]. - -## Creating a Dataset - -The first item in the tuple $(D, \mathcal{A}, u)$ characterising data value is -the dataset. The class [Dataset][pydvl.utils.dataset.Dataset] is a simple -convenience wrapper for the train and test splits that is used throughout pyDVL. -The test set will be used to evaluate a scoring function for the model. - -It can be used as follows: - -```python -import numpy as np -from pydvl.utils import Dataset -from sklearn.model_selection import train_test_split -X, y = np.arange(100).reshape((50, 2)), np.arange(50) -X_train, X_test, y_train, y_test = train_test_split( - X, y, test_size=0.5, random_state=16 -) -dataset = Dataset(X_train, X_test, y_train, y_test) -``` - -It is also possible to construct Datasets from sklearn toy datasets for -illustrative purposes using [from_sklearn][pydvl.utils.dataset.Dataset.from_sklearn]. - -### Grouping data - -Be it because data valuation methods are computationally very expensive, or -because we are interested in the groups themselves, it can be often useful or -necessary to group samples to valuate them together. -[GroupedDataset][pydvl.utils.dataset.GroupedDataset] provides an alternative to -[Dataset][pydvl.utils.dataset.Dataset] with the same interface which allows this. - -You can see an example in action in the -[Spotify notebook](../examples/shapley_basic_spotify), but here's a simple -example grouping a pre-existing `Dataset`. First we construct an array mapping -each index in the dataset to a group, then use -[from_dataset][pydvl.utils.dataset.GroupedDataset.from_dataset]: - -```python -import numpy as np -from pydvl.utils import GroupedDataset - -# Randomly assign elements to any one of num_groups: -data_groups = np.random.randint(0, num_groups, len(dataset)) -grouped_dataset = GroupedDataset.from_dataset(dataset, data_groups) -``` - -## Creating a Utility - -In pyDVL we have slightly overloaded the name "utility" and use it to refer to -an object that keeps track of all three items in $(D, \mathcal{A}, u)$. This -will be an instance of [Utility][pydvl.utils.utility.Utility] which, as mentioned, -is a convenient wrapper for the dataset, model and scoring function used for -valuation methods. - -Here's a minimal example: - -```python -import sklearn as sk -from pydvl.utils import Dataset, Utility - -dataset = Dataset.from_sklearn(sk.datasets.load_iris()) -model = sk.svm.SVC() -utility = Utility(model, dataset) -``` - -The object `utility` is a callable that data valuation methods will execute -with different subsets of training data. Each call will retrain the model on a -subset and evaluate it on the test data using a scoring function. By default, -[Utility][pydvl.utils.utility.Utility] will use `model.score()`, but it is -possible to use any scoring function (greater values must be better). In -particular, the constructor accepts the same types as argument as sklearn's -[cross_validate](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.cross_validate.html>): -a string, a scorer callable or [None][] for the default. - -```python -utility = Utility(model, dataset, "explained_variance") -``` - -`Utility` will wrap the `fit()` method of the model to cache its results. This -greatly reduces computation times of Monte Carlo methods. Because of how caching -is implemented, it is important not to reuse `Utility` objects for different -datasets. You can read more about [setting up the cache][setting-up-the-cache] -in the installation guide and the documentation -of the [caching][pydvl.utils.caching] module. - -### Using custom scorers - -The `scoring` argument of [Utility][pydvl.utils.utility.Utility] can be used to -specify a custom [Scorer][pydvl.utils.utility.Scorer] object. This is a simple -wrapper for a callable that takes a model, and test data and returns a score. - -More importantly, the object provides information about the range of the score, -which is used by some methods by estimate the number of samples necessary, and -about what default value to use when the model fails to train. - -!!! Note - The most important property of a `Scorer` is its default value. Because many - models will fail to fit on small subsets of the data, it is important to - provide a sensible default value for the score. - -It is possible to skip the construction of the [Scorer][pydvl.utils.utility.Scorer] -when constructing the `Utility` object. The two following calls are equivalent: - -```python -utility = Utility( - model, dataset, "explained_variance", score_range=(-np.inf, 1), default_score=0.0 -) -utility = Utility( - model, dataset, Scorer("explained_variance", range=(-np.inf, 1), default=0.0) -) -``` - -### Learning the utility - -Because each evaluation of the utility entails a full retrain of the model with -a new subset of the training set, it is natural to try to learn this mapping -from subsets to scores. This is the idea behind **Data Utility Learning (DUL)** -[@wang_improving_2022] and in pyDVL it's as simple as wrapping the -`Utility` inside [DataUtilityLearning][pydvl.utils.utility.DataUtilityLearning]: - -```python -from pydvl.utils import Utility, DataUtilityLearning, Dataset -from sklearn.linear_model import LinearRegression, LogisticRegression -from sklearn.datasets import load_iris - -dataset = Dataset.from_sklearn(load_iris()) -u = Utility(LogisticRegression(), dataset, enable_cache=False) -training_budget = 3 -wrapped_u = DataUtilityLearning(u, training_budget, LinearRegression()) - -# First 3 calls will be computed normally -for i in range(training_budget): - _ = wrapped_u((i,)) -# Subsequent calls will be computed using the fit model for DUL -wrapped_u((1, 2, 3)) -``` - -As you can see, all that is required is a model to learn the utility itself and -the fitting and using of the learned model happens behind the scenes. - -There is a longer example with an investigation of the results achieved by DUL -in [a dedicated notebook](../examples/shapley_utility_learning). - -## Leave-One-Out values - -The Leave-One-Out method is a simple approach that assigns each sample its -*marginal utility* as value: - -$$v_u(x_i) = u(D) − u(D \setminus \{x_i\}).$$ - -For the purposes of data valuation, this is rarely useful beyond serving as a -baseline for benchmarking. One particular weakness is that it does not -necessarily correlate with an intrinsic value of a sample: since it is a -marginal utility, it is affected by the "law" of diminishing returns. Often, the -training set is large enough for a single sample not to have any significant -effect on training performance, despite any qualities it may possess. Whether -this is indicative of low value or not depends on each one's goals and -definitions, but other methods are typically preferable. - -```python -from pydvl.value.loo.naive import naive_loo - -values = naive_loo(utility) -``` - -The return value of all valuation functions is an object of type -[ValuationResult][pydvl.value.result.ValuationResult]. This can be iterated over, -indexed with integers, slices and Iterables, as well as converted to a -[pandas.DataFrame][]. - -## Shapley values - -The Shapley method is an approach to compute data values originating in -cooperative game theory. Shapley values are a common way of assigning payoffs to -each participant in a cooperative game (i.e. one in which players can form -coalitions) in a way that ensures that certain axioms are fulfilled. - -pyDVL implements several methods for the computation and approximation of -Shapley values. They can all be accessed via the facade function -[compute_shapley_values][pydvl.value.shapley.compute_shapley_values]. -The supported methods are enumerated in -[ShapleyMode][pydvl.value.shapley.ShapleyMode]. - - -### Combinatorial Shapley - -The first algorithm is just a verbatim implementation of the definition. As such -it returns as exact a value as the utility function allows (see what this means -in Problems of Data Values][problems-of-data-values]). - -The value $v$ of the $i$-th sample in dataset $D$ wrt. utility $u$ is computed -as a weighted sum of its marginal utility wrt. every possible coalition of -training samples within the training set: - -$$ -v_u(x_i) = \frac{1}{n} \sum_{S \subseteq D \setminus \{x_i\}} -\binom{n-1}{ | S | }^{-1} [u(S \cup \{x_i\}) − u(S)] -,$$ - -```python -from pydvl.value import compute_shapley_values - -values = compute_shapley_values(utility, mode="combinatorial_exact") -df = values.to_dataframe(column='value') -``` - -We can convert the return value to a -[pandas.DataFrame][]. -and name the column with the results as `value`. Please refer to the -documentation in [shapley][pydvl.value.shapley] and -[ValuationResult][pydvl.value.result.ValuationResult] for more information. - -### Monte Carlo Combinatorial Shapley - -Because the number of subsets $S \subseteq D \setminus \{x_i\}$ is -$2^{ | D | - 1 }$, one typically must resort to approximations. The simplest -one is done via Monte Carlo sampling of the powerset $\mathcal{P}(D)$. In pyDVL -this simple technique is called "Monte Carlo Combinatorial". The method has very -poor converge rate and others are preferred, but if desired, usage follows the -same pattern: - -```python -from pydvl.value import compute_shapley_values, MaxUpdates - -values = compute_shapley_values( - utility, mode="combinatorial_montecarlo", done=MaxUpdates(1000) -) -df = values.to_dataframe(column='cmc') -``` - -The DataFrames returned by most Monte Carlo methods will contain approximate -standard errors as an additional column, in this case named `cmc_stderr`. - -Note the usage of the object [MaxUpdates][pydvl.value.stopping.MaxUpdates] as the -stop condition. This is an instance of a -[StoppingCriterion][pydvl.value.stopping.StoppingCriterion]. Other examples are -[MaxTime][pydvl.value.stopping.MaxTime] and -[AbsoluteStandardError][pydvl.value.stopping.AbsoluteStandardError]. - - -### Owen sampling - -**Owen Sampling** [@okhrati_multilinear_2021] is a practical -algorithm based on the combinatorial definition. It uses a continuous extension -of the utility from $\{0,1\}^n$, where a 1 in position $i$ means that sample -$x_i$ is used to train the model, to $[0,1]^n$. The ensuing expression for -Shapley value uses integration instead of discrete weights: - -$$ -v_u(i) = \int_0^1 \mathbb{E}_{S \sim P_q(D_{\backslash \{ i \}})} -[u(S \cup {i}) - u(S)] -.$$ - -Using Owen sampling follows the same pattern as every other method for Shapley -values in pyDVL. First construct the dataset and utility, then call -[compute_shapley_values][pydvl.value.shapley.compute_shapley_values]: - -```python -from pydvl.value import compute_shapley_values - -values = compute_shapley_values( - u=utility, mode="owen", n_iterations=4, max_q=200 -) -``` - -There are more details on Owen sampling, and its variant *Antithetic Owen -Sampling* in the documentation for the function doing the work behind the scenes: -[owen_sampling_shapley][pydvl.value.shapley.owen.owen_sampling_shapley]. - -Note that in this case we do not pass a -[StoppingCriterion][pydvl.value.stopping.StoppingCriterion] to the function, but instead -the number of iterations and the maximum number of samples to use in the -integration. - -### Permutation Shapley - -An equivalent way of computing Shapley values (`ApproShapley`) appeared in -[@castro_polynomial_2009] and is the basis for the method most often -used in practice. It uses permutations over indices instead of subsets: - -$$ -v_u(x_i) = \frac{1}{n!} \sum_{\sigma \in \Pi(n)} -[u(\sigma_{:i} \cup \{i\}) − u(\sigma_{:i})] -,$$ - -where $\sigma_{:i}$ denotes the set of indices in permutation sigma before the -position where $i$ appears. To approximate this sum (which has $\mathcal{O}(n!)$ -terms!) one uses Monte Carlo sampling of permutations, something which has -surprisingly low sample complexity. One notable difference wrt. the -combinatorial approach above is that the approximations always fulfill the -efficiency axiom of Shapley, namely $\sum_{i=1}^n \hat{v}_i = u(D)$ (see -[@castro_polynomial_2009], Proposition 3.2). - -By adding early stopping, the result is the so-called **Truncated Monte Carlo -Shapley** [@ghorbani_data_2019], which is efficient enough to be -useful in applications. - -```python -from pydvl.value import compute_shapley_values, MaxUpdates - -values = compute_shapley_values( - u=utility, mode="truncated_montecarlo", done=MaxUpdates(1000) -) -``` - - -### Exact Shapley for KNN - -It is possible to exploit the local structure of K-Nearest Neighbours to reduce -the amount of subsets to consider: because no sample besides the K closest -affects the score, most are irrelevant and it is possible to compute a value in -linear time. This method was introduced by [@jia_efficient_2019a], -and can be used in pyDVL with: - -```python -from pydvl.utils import Dataset, Utility -from pydvl.value import compute_shapley_values -from sklearn.neighbors import KNeighborsClassifier - -model = KNeighborsClassifier(n_neighbors=5) -data = Dataset(...) -utility = Utility(model, data) -values = compute_shapley_values(u=utility, mode="knn") -``` - -### Group testing - -An alternative approach introduced in [@jia_efficient_2019a] -first approximates the differences of values with a Monte Carlo sum. With - -$$\hat{\Delta}_{i j} \approx v_i - v_j,$$ - -one then solves the following linear constraint satisfaction problem (CSP) to -infer the final values: - -$$ -\begin{array}{lll} -\sum_{i = 1}^N v_i & = & U (D)\\ -| v_i - v_j - \hat{\Delta}_{i j} | & \leqslant & -\frac{\varepsilon}{2 \sqrt{N}} -\end{array} -$$ - -!!! Warning - We have reproduced this method in pyDVL for completeness and benchmarking, - but we don't advocate its use because of the speed and memory cost. Despite - our best efforts, the number of samples required in practice for convergence - can be several orders of magnitude worse than with e.g. Truncated Monte Carlo. - Additionally, the CSP can sometimes turn out to be infeasible. - -Usage follows the same pattern as every other Shapley method, but with the -addition of an `epsilon` parameter required for the solution of the CSP. It -should be the same value used to compute the minimum number of samples required. -This can be done with [num_samples_eps_delta][pydvl.value.shapley.gt.num_samples_eps_delta], but -note that the number returned will be huge! In practice, fewer samples can be -enough, but the actual number will strongly depend on the utility, in particular -its variance. - -```python -from pydvl.utils import Dataset, Utility -from pydvl.value import compute_shapley_values - -model = ... -data = Dataset(...) -utility = Utility(model, data, score_range=(_min, _max)) -min_iterations = num_samples_eps_delta(epsilon, delta, n, utility.score_range) -values = compute_shapley_values( - u=utility, mode="group_testing", n_iterations=min_iterations, eps=eps -) -``` - -## Core values - -The Shapley values define a fair way to distribute payoffs amongst all -participants when they form a grand coalition. But they do not consider -the question of stability: under which conditions do all participants -form the grand coalition? Would the participants be willing to form -the grand coalition given how the payoffs are assigned, -or would some of them prefer to form smaller coalitions? - -The Core is another approach to computing data values originating -in cooperative game theory that attempts to ensure this stability. -It is the set of feasible payoffs that cannot be improved upon -by a coalition of the participants. - -It satisfies the following 2 properties: - -- **Efficiency**: - The payoffs are distributed such that it is not possible - to make any participant better off - without making another one worse off. - $$\sum_{x_i\in D} v_u(x_i) = u(D)\,$$ - -- **Coalitional rationality**: - The sum of payoffs to the agents in any coalition S is at - least as large as the amount that these agents could earn by - forming a coalition on their own. - $$\sum_{x_i\in S} v_u(x_i) \geq u(S), \forall S \subset D\,$$ - -The second property states that the sum of payoffs to the agents -in any subcoalition $S$ is at least as large as the amount that -these agents could earn by forming a coalition on their own. - -### Least Core values - -Unfortunately, for many cooperative games the Core may be empty. -By relaxing the coalitional rationality property by a subsidy $e \gt 0$, -we are then able to find approximate payoffs: - -$$ -\sum_{x_i\in S} v_u(x_i) + e \geq u(S), \forall S \subset D, S \neq \emptyset \ -,$$ - -The least core value $v$ of the $i$-th sample in dataset $D$ wrt. -utility $u$ is computed by solving the following Linear Program: - -$$ -\begin{array}{lll} -\text{minimize} & e & \\ -\text{subject to} & \sum_{x_i\in D} v_u(x_i) = u(D) & \\ -& \sum_{x_i\in S} v_u(x_i) + e \geq u(S) &, \forall S \subset D, S \neq \emptyset \\ -\end{array} -$$ - -### Exact Least Core - -This first algorithm is just a verbatim implementation of the definition. -As such it returns as exact a value as the utility function allows -(see what this means in Problems of Data Values][problems-of-data-values]). - -```python -from pydvl.value import compute_least_core_values - -values = compute_least_core_values(utility, mode="exact") -``` - -### Monte Carlo Least Core - -Because the number of subsets $S \subseteq D \setminus \{x_i\}$ is -$2^{ | D | - 1 }$, one typically must resort to approximations. - -The simplest approximation consists in using a fraction of all subsets for the -constraints. [@yan_if_2021] show that a quantity of order -$\mathcal{O}((n - \log \Delta ) / \delta^2)$ is enough to obtain a so-called -$\delta$-*approximate least core* with high probability. I.e. the following -property holds with probability $1-\Delta$ over the choice of subsets: - -$$ -\mathbb{P}_{S\sim D}\left[\sum_{x_i\in S} v_u(x_i) + e^{*} \geq u(S)\right] -\geq 1 - \delta, -$$ - -where $e^{*}$ is the optimal least core subsidy. - -```python -from pydvl.value import compute_least_core_values - -values = compute_least_core_values( - utility, mode="montecarlo", n_iterations=n_iterations -) -``` - -!!! Note - Although any number is supported, it is best to choose `n_iterations` to be - at least equal to the number of data points. - -Because computing the Least Core values requires the solution of a linear and a -quadratic problem *after* computing all the utility values, we offer the -possibility of splitting the latter from the former. This is useful when running -multiple experiments: use -[mclc_prepare_problem][pydvl.value.least_core.montecarlo.mclc_prepare_problem] to prepare a -list of problems to solve, then solve them in parallel with -[lc_solve_problems][pydvl.value.least_core.common.lc_solve_problems]. - -```python -from pydvl.value.least_core import mclc_prepare_problem, lc_solve_problems - -n_experiments = 10 -problems = [mclc_prepare_problem(utility, n_iterations=n_iterations) - for _ in range(n_experiments)] -values = lc_solve_problems(problems) -``` - - -## Semi-values - -Shapley values are a particular case of a more general concept called semi-value, -which is a generalization to different weighting schemes. A **semi-value** is -any valuation function with the form: - -$$ -v\_\text{semi}(i) = \sum_{i=1}^n w(k) -\sum_{S \subset D\_{-i}^{(k)}} [U(S\_{+i})-U(S)], -$$ - -where the coefficients $w(k)$ satisfy the property: - -$$\sum_{k=1}^n w(k) = 1.$$ - -Two instances of this are **Banzhaf indices** [@wang_data_2022], -and **Beta Shapley** [@kwon_beta_2022], with better numerical and -rank stability in certain situations. - -!!! Note - Shapley values are a particular case of semi-values and can therefore also be - computed with the methods described here. However, as of version 0.6.0, we - recommend using [compute_shapley_values][pydvl.value.shapley.compute_shapley_values] instead, - in particular because it implements truncated Monte Carlo sampling for faster - computation. - - -### Beta Shapley - -For some machine learning applications, where the utility is typically the -performance when trained on a set $S \subset D$, diminishing returns are often -observed when computing the marginal utility of adding a new data point. - -Beta Shapley is a weighting scheme that uses the Beta function to place more -weight on subsets deemed to be more informative. The weights are defined as: - -$$ -w(k) := \frac{B(k+\beta, n-k+1+\alpha)}{B(\alpha, \beta)}, -$$ - -where $B$ is the [Beta function](https://en.wikipedia.org/wiki/Beta_function), -and $\alpha$ and $\beta$ are parameters that control the weighting of the -subsets. Setting both to 1 recovers Shapley values, and setting $\alpha = 1$, and -$\beta = 16$ is reported in [@kwon_beta_2022] to be a good choice for -some applications. See however the [Banzhaf indices][banzhaf-indices] section -for an alternative choice of weights which is reported to work better. - -```python -from pydvl.value import compute_semivalues - -values = compute_semivalues( - u=utility, mode="beta_shapley", done=MaxUpdates(500), alpha=1, beta=16 -) -``` - -### Banzhaf indices - -As noted below in the [Problems of Data Values][problems-of-data-values] section, -the Shapley value can be very sensitive to variance in the utility function. -For machine learning applications, where the utility is typically the performance -when trained on a set $S \subset D$, this variance is often largest -for smaller subsets $S$. It is therefore reasonable to try reducing -the relative contribution of these subsets with adequate weights. - -One such choice of weights is the Banzhaf index, which is defined as the -constant: - -$$w(k) := 2^{n-1},$$ - -for all set sizes $k$. The intuition for picking a constant weight is that for -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 variance in the utility function than Shapley and Beta Shapley values. - -```python -from pydvl.value import compute_semivalues, MaxUpdates - -values = compute_semivalues( u=utility, mode="banzhaf", done=MaxUpdates(500)) -``` - -## Problems of data values - -There are a number of factors that affect how useful values can be for your -project. In particular, regression can be especially tricky, but the particular -nature of every (non-trivial) ML problem can have an effect: - -* **Unbounded utility**: Choosing a scorer for a classifier is simple: accuracy - or some F-score provides a bounded number with a clear interpretation. However, - in regression problems most scores, like $R^2$, are not bounded because - regressors can be arbitrarily bad. This leads to great variability in the - utility for low sample sizes, and hence unreliable Monte Carlo approximations - to the values. Nevertheless, in practice it is only the ranking of samples - that matters, and this tends to be accurate (wrt. to the true ranking) despite - inaccurate values. - - pyDVL offers a dedicated [function composition][pydvl.utils.score.compose_score] - for scorer functions which can be used to squash a score. - The following is defined in module [score][pydvl.utils.score]: - - ```python - import numpy as np - from pydvl.utils.types import compose_score - - def sigmoid(x: float) -> float: - return float(1 / (1 + np.exp(-x))) - - squashed_r2 = compose_score("r2", sigmoid, "squashed r2") - - squashed_variance = compose_score( - "explained_variance", sigmoid, "squashed explained variance" - ) - ``` - - These squashed scores can prove useful in regression problems, but they can - also introduce issues in the low-value regime. - -* **High variance utility**: Classical applications of game theoretic value - concepts operate with deterministic utilities, but in ML we use an evaluation - of the model on a validation set as a proxy for the true risk. Even if the - utility *is* bounded, if it has high variance then values will also have high - variance, as will their Monte Carlo estimates. One workaround in pyDVL is to - configure the caching system to allow multiple evaluations of the utility for - every index set. A moving average is computed and returned once the standard - error is small, see [MemcachedConfig][pydvl.utils.config.MemcachedConfig]. - - [@wang_data_2022] prove that by relaxing one of the Shapley axioms - and considering the general class of semi-values, of which Shapley is an - instance, one can prove that a choice of constant weights is the best one can - do in a utility-agnostic setting. So-called *Data Banzhaf* is on our to-do - list! - -* **Data set size**: Computing exact Shapley values is NP-hard, and Monte Carlo - approximations can converge slowly. Massive datasets are thus impractical, at - least with current techniques. A workaround is to group samples and investigate - their value together. In pyDVL you can do this using - [GroupedDataset][pydvl.utils.dataset.GroupedDataset]. - There is a fully worked-out [example here](../examples/shapley_basic_spotify). - Some algorithms also provide different sampling strategies to reduce - the variance, but due to a no-free-lunch-type theorem, - no single strategy can be optimal for all utilities. - -* **Model size**: Since every evaluation of the utility entails retraining the - whole model on a subset of the data, large models require great amounts of - computation. But also, they will effortlessly interpolate small to medium - datasets, leading to great variance in the evaluation of performance on the - dedicated validation set. One mitigation for this problem is cross-validation, - but this would incur massive computational cost. As of v.0.3.0 there are no - facilities in pyDVL for cross-validating the utility (note that this would - require cross-validating the whole value computation). diff --git a/docs/examples/index.md b/docs/examples/index.md deleted file mode 100644 index a0f01159e..000000000 --- a/docs/examples/index.md +++ /dev/null @@ -1,10 +0,0 @@ ---- -title: Examples -alias: - name: examples - text: Examples ---- - -This section contains worked-out examples illustrating pyDVL's capabilities. - -Use the navigation bar on the left to go through them. diff --git a/docs/10-getting-started.md b/docs/getting-started/getting-started.md similarity index 70% rename from docs/10-getting-started.md rename to docs/getting-started/getting-started.md index e8c13db3f..d984a6de9 100644 --- a/docs/10-getting-started.md +++ b/docs/getting-started/getting-started.md @@ -10,21 +10,21 @@ alias: !!! Warning Make sure you have read [[installation]] before using the library. In particular read about how caching and parallelization work, - since they require additional setup. + since they might require additional setup. + +## Main concepts pyDVL aims to be a repository of production-ready, reference implementations of -algorithms for data valuation and influence functions. You can read: +algorithms for data valuation and influence functions. Even though we only +briefly introduce key concepts in the documentation, the following sections +should be enough to get you started. * [[data-valuation]] for key objects and usage patterns for Shapley value computation and related methods. -* [[influence-values]] for instructions on how to compute influence functions (still - in a pre-alpha state) +* [[influence-values]] for instructions on how to compute influence functions. -We only briefly introduce key concepts in the documentation. For a thorough -introduction and survey of the field, we refer to **the upcoming review** at the -[TransferLab website]({{ transferlab.data_valuation_review }}). -# Running the examples +## Running the examples If you are somewhat familiar with the concepts of data valuation, you can start by browsing our worked-out examples illustrating pyDVL's capabilities either: diff --git a/docs/20-install.md b/docs/getting-started/installation.md similarity index 94% rename from docs/20-install.md rename to docs/getting-started/installation.md index 01f126ac9..a81be900d 100644 --- a/docs/20-install.md +++ b/docs/getting-started/installation.md @@ -47,7 +47,7 @@ You can also install the latest development version from pip install pyDVL --index-url https://test.pypi.org/simple/ ``` -# Dependencies +## Dependencies pyDVL requires Python >= 3.8, [Memcached](https://memcached.org/) for caching and [Ray](https://ray.io) for parallelization. Additionally, @@ -57,7 +57,7 @@ the [Influence functions][pydvl.influence] module requires PyTorch (see ray is used to distribute workloads both locally and across nodes. Please follow the instructions in their documentation for installation. -# Setting up the cache +## Setting up the cache memcached is an in-memory key-value store accessible over the network. pyDVL uses it to cache certain results and speed-up the computations. You can either @@ -80,9 +80,3 @@ docker container run -d --rm -p 11211:11211 memcached:latest To read more about caching and how it might affect your usage, in particular about cache reuse and its pitfalls, please read the documentation for the [caching module][pydvl.utils.caching]. - -# What's next - -- Read on [[data-valuation]] -- Read on [[influence-values]] -- Browse the [[examples]] diff --git a/docs/index.md b/docs/index.md index a8e832ab3..ae3a475c0 100644 --- a/docs/index.md +++ b/docs/index.md @@ -1,5 +1,5 @@ --- -title: pyDVL documentation +title: Home --- # The python library for data valuation @@ -15,7 +15,7 @@ If you're a first time user of pyDVL, we recommend you to go through the - title: To the installation guide image: ./assets/material-toolbox.svg - url: 20-install + url: getting-started/installation - title: To the code image: ./assets/material-code.svg @@ -23,7 +23,7 @@ If you're a first time user of pyDVL, we recommend you to go through the - title: Browse the API image: ./assets/material-description.svg - url: code-reference/pydvl + url: api - title: To the examples image: ./assets/material-computer.svg diff --git a/docs/40-influence.md b/docs/influence/index.md similarity index 92% rename from docs/40-influence.md rename to docs/influence/index.md index 48d0abdff..e05a5a807 100644 --- a/docs/40-influence.md +++ b/docs/influence/index.md @@ -1,16 +1,15 @@ --- -title: Computing Influence Values -alias: +title: The influence function +alias: name: influence-values text: Computing Influence Values --- -# Computing influence values +# The influence function !!! Warning - Much of the code in the package [pydvl.influence][pydvl.influence] - is experimental or untested. Package structure and basic API are bound - to change before v1.0.0 + The code in the package [pydvl.influence][pydvl.influence] is experimental. + Package structure and basic API are bound to change before v1.0.0 The influence function (IF) is a method to quantify the effect (influence) that each training point has on the parameters of a model, and by extension on any @@ -18,23 +17,31 @@ function thereof. In particular, it allows to estimate how much each training sample affects the error on a test point, making the IF useful for understanding and debugging models. +Alas, the influence function relies on some assumptions that can make their +application difficult. Yet another drawback is that they require the computation +of the inverse of the Hessian of the model wrt. its parameters, which is +intractable for large models like deep neural networks. Much of the recent +research tackles this issue using approximations, like a Neuman series +[@agarwal_secondorder_2017], with the most successful solution using a low-rank +approximation that iteratively finds increasing eigenspaces of the Hessian +[@schioppa_scaling_2021]. + pyDVL implements several methods for the efficient computation of the IF for -machine learning. +machine learning. In the examples we document some of the difficulties that can +arise when using the IF. # The Influence Function -First introduced in the context of robust statistics in -[@hampel1974influence], the IF was popularized in the context of -machine learning in [@koh_understanding_2017]. - -Following their formulation, consider an input space $\mathcal{X}$ -(e.g. images) and an output space $\mathcal{Y}$ (e.g. labels). -Let's take $z_i = (x_i, y_i)$, for $i \in \{1,...,n\}$ to be -the $i$-th training point, and $\theta$ to be the -(potentially highly) multi-dimensional parameters of a model -(e.g. $\theta$ is a big array with all of a neural network's parameters, -including biases and/or dropout rates). -We will denote with $L(z, \theta)$ the loss of the model for +First introduced in the context of robust statistics in [@hampel1974influence], +the IF was popularized in the context of machine learning in +[@koh_understanding_2017]. + +Following their formulation, consider an input space $\mathcal{X}$ (e.g. images) +and an output space $\mathcal{Y}$ (e.g. labels). Let's take $z_i = (x_i, y_i)$, +for $i \in \{1,...,n\}$ to be the $i$-th training point, and $\theta$ to be the +(potentially highly) multi-dimensional parameters of a model (e.g. $\theta$ is a +big array with all of a neural network's parameters, including biases and/or +dropout rates). We will denote with $L(z, \theta)$ the loss of the model for point $z$ when the parameters are $\theta.$ To train a model, we typically minimize the loss over all $z_i$, i.e. the diff --git a/docs/value/index.md b/docs/value/index.md new file mode 100644 index 000000000..edaf053d9 --- /dev/null +++ b/docs/value/index.md @@ -0,0 +1,350 @@ +--- +title: Data valuation +alias: + name: data-valuation + text: Basics of data valuation +--- + +# Data valuation + +!!! Note + If you want to jump right into the steps to compute values, skip ahead + to [Computing data values](#computing-data-values). + +**Data valuation** is the task of assigning a number to each element of a +training set which reflects its contribution to the final performance of some +model trained on it. Some methods attempt to be model-agnostic, but in most +cases the model is an integral part of the method. In these cases, this number +not an intrinsic property of the element of interest, but typically a function +of three factors: + +1. The dataset $D$, or more generally, the distribution it was sampled + from (with this we mean that *value* would ideally be the (expected) + contribution of a data point to any random set $D$ sampled from the same + distribution). + +2. The algorithm $\mathcal{A}$ mapping the data $D$ to some estimator $f$ + in a model class $\mathcal{F}$. E.g. MSE minimization to find the parameters + of a linear model. + +3. The performance metric of interest $u$ for the problem. When value depends on + a model, it must be measured in some way which uses it. E.g. the $R^2$ score or + the negative MSE over a test set. + +pyDVL collects algorithms for the computation of data values in this sense, +mostly those derived from cooperative game theory. The methods can be found in +the package [pydvl.value][pydvl.value] , with support from modules +[pydvl.utils.dataset][pydvl.utils.dataset] +and [pydvl.utils.utility][pydvl.utils.utility], as detailed below. + +!!! Warning + Be sure to read the section on + [the difficulties using data values][problems-of-data-values]. + +There are three main families of methods for data valuation: game-theoretic, +influence-based and intrinsic. As of v0.7.0 pyDVL supports the first two. Here, +we focus on game-theoretic concepts and refer to the main documentation on the +[influence funtion][computing-influence-values] for the second. + +## Game theoretical methods + +The main contenders in game-theoretic approaches are [Shapley +values](shapley.md]) [@ghorbani_data_2019], [@kwon_efficient_2021], +[@schoch_csshapley_2022], their generalization to so-called +[semi-values](semi-values.md) by [@kwon_beta_2022] and [@wang_data_2022], +and [the Core](the-core.md) [@yan_if_2021]. All of these are implemented +in pyDVL. + +In these methods, data points are considered players in a cooperative game +whose outcome is the performance of the model when trained on subsets +(*coalitions*) of the data, measured on a held-out **valuation set**. This +outcome, or **utility**, must typically be computed for *every* subset of +the training set, so that an exact computation is $\mathcal{O} (2^n)$ in the +number of samples $n$, with each iteration requiring a full re-fitting of the +model using a coalition as training set. Consequently, most methods involve +Monte Carlo approximations, and sometimes approximate utilities which are +faster to compute, e.g. proxy models [@wang_improving_2022] or constant-cost +approximations like Neural Tangent Kernels [@wu_davinz_2022]. + +The reasoning behind using game theory is that, in order to be useful, an +assignment of value, dubbed **valuation function**, is usually required to +fulfil certain requirements of consistency and "fairness". For instance, in some +applications value should not depend on the order in which data are considered, +or it should be equal for samples that contribute equally to any subset of the +data (of equal size). When considering aggregated value for (sub-)sets of data +there are additional desiderata, like having a value function that does not +increase with repeated samples. Game-theoretic methods are all rooted in axioms +that by construction ensure different desiderata, but despite their practical +usefulness, none of them are either necessary or sufficient for all +applications. For instance, Shapley values try to equitably distribute all value +among all samples, failing to identify repeated ones as unnecessary, with e.g. a +zero value. + + +## Applications of data valuation + +Many applications are touted for data valuation, but the results can be +inconsistent. Values have a strong dependency on the training procedure and the +performance metric used. For instance, accuracy is a poor metric for imbalanced +sets and this has a stark effect on data values. Some models exhibit great +variance in some regimes and this again has a detrimental effect on values. + +Nevertheless, some of the most promising applications are: Cleaning of corrupted +data, pruning unnecessary or irrelevant data, repairing mislabeled data, guiding +data acquisition and annotation (active learning), anomaly detection and model +debugging and interpretation. + +## Computing data values + +Using pyDVL to compute data values is a simple process that can be broken down +into three steps: + +1. Creating a [Dataset][pydvl.utils.dataset.Dataset] object from your data. +2. Creating a [Utility][pydvl.utils.utility.Utility] which ties your model to + the dataset and a [scoring function][pydvl.utils.utility.Scorer]. +3. Computing values with a method of your choice, e.g. via + [compute_shapley_values][pydvl.value.shapley.common.compute_shapley_values]. + +### Creating a Dataset + +The first item in the tuple $(D, \mathcal{A}, u)$ characterising data value is +the dataset. The class [Dataset][pydvl.utils.dataset.Dataset] is a simple +convenience wrapper for the train and test splits that is used throughout pyDVL. +The test set will be used to evaluate a scoring function for the model. + +It can be used as follows: + +```python +import numpy as np +from pydvl.utils import Dataset +from sklearn.model_selection import train_test_split +X, y = np.arange(100).reshape((50, 2)), np.arange(50) +X_train, X_test, y_train, y_test = train_test_split( + X, y, test_size=0.5, random_state=16 +) +dataset = Dataset(X_train, X_test, y_train, y_test) +``` + +It is also possible to construct Datasets from sklearn toy datasets for +illustrative purposes using [from_sklearn][pydvl.utils.dataset.Dataset.from_sklearn]. + +#### Grouping data + +Be it because data valuation methods are computationally very expensive, or +because we are interested in the groups themselves, it can be often useful or +necessary to group samples to valuate them together. +[GroupedDataset][pydvl.utils.dataset.GroupedDataset] provides an alternative to +[Dataset][pydvl.utils.dataset.Dataset] with the same interface which allows this. + +You can see an example in action in the +[Spotify notebook](../examples/shapley_basic_spotify), but here's a simple +example grouping a pre-existing `Dataset`. First we construct an array mapping +each index in the dataset to a group, then use +[from_dataset][pydvl.utils.dataset.GroupedDataset.from_dataset]: + +```python +import numpy as np +from pydvl.utils import GroupedDataset + +# Randomly assign elements to any one of num_groups: +data_groups = np.random.randint(0, num_groups, len(dataset)) +grouped_dataset = GroupedDataset.from_dataset(dataset, data_groups) +``` + +### Creating a Utility + +In pyDVL we have slightly overloaded the name "utility" and use it to refer to +an object that keeps track of all three items in $(D, \mathcal{A}, u)$. This +will be an instance of [Utility][pydvl.utils.utility.Utility] which, as mentioned, +is a convenient wrapper for the dataset, model and scoring function used for +valuation methods. + +Here's a minimal example: + +```python +import sklearn as sk +from pydvl.utils import Dataset, Utility + +dataset = Dataset.from_sklearn(sk.datasets.load_iris()) +model = sk.svm.SVC() +utility = Utility(model, dataset) +``` + +The object `utility` is a callable that data valuation methods will execute +with different subsets of training data. Each call will retrain the model on a +subset and evaluate it on the test data using a scoring function. By default, +[Utility][pydvl.utils.utility.Utility] will use `model.score()`, but it is +possible to use any scoring function (greater values must be better). In +particular, the constructor accepts the same types as argument as sklearn's +[cross_validate](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.cross_validate.html>): +a string, a scorer callable or [None][] for the default. + +```python +utility = Utility(model, dataset, "explained_variance") +``` + +`Utility` will wrap the `fit()` method of the model to cache its results. This +greatly reduces computation times of Monte Carlo methods. Because of how caching +is implemented, it is important not to reuse `Utility` objects for different +datasets. You can read more about [setting up the cache][setting-up-the-cache] +in the installation guide and the documentation +of the [caching][pydvl.utils.caching] module. + +#### Using custom scorers + +The `scoring` argument of [Utility][pydvl.utils.utility.Utility] can be used to +specify a custom [Scorer][pydvl.utils.utility.Scorer] object. This is a simple +wrapper for a callable that takes a model, and test data and returns a score. + +More importantly, the object provides information about the range of the score, +which is used by some methods by estimate the number of samples necessary, and +about what default value to use when the model fails to train. + +!!! Note + The most important property of a `Scorer` is its default value. Because many + models will fail to fit on small subsets of the data, it is important to + provide a sensible default value for the score. + +It is possible to skip the construction of the [Scorer][pydvl.utils.utility.Scorer] +when constructing the `Utility` object. The two following calls are equivalent: + +```python +from pydvl.utils import Utility, Scorer + +utility = Utility( + model, dataset, "explained_variance", score_range=(-np.inf, 1), default_score=0.0 +) +utility = Utility( + model, dataset, Scorer("explained_variance", range=(-np.inf, 1), default=0.0) +) +``` + +#### Learning the utility + +Because each evaluation of the utility entails a full retrain of the model with +a new subset of the training set, it is natural to try to learn this mapping +from subsets to scores. This is the idea behind **Data Utility Learning (DUL)** +[@wang_improving_2022] and in pyDVL it's as simple as wrapping the +`Utility` inside [DataUtilityLearning][pydvl.utils.utility.DataUtilityLearning]: + +```python +from pydvl.utils import Utility, DataUtilityLearning, Dataset +from sklearn.linear_model import LinearRegression, LogisticRegression +from sklearn.datasets import load_iris + +dataset = Dataset.from_sklearn(load_iris()) +u = Utility(LogisticRegression(), dataset, enable_cache=False) +training_budget = 3 +wrapped_u = DataUtilityLearning(u, training_budget, LinearRegression()) + +# First 3 calls will be computed normally +for i in range(training_budget): + _ = wrapped_u((i,)) +# Subsequent calls will be computed using the fit model for DUL +wrapped_u((1, 2, 3)) +``` + +As you can see, all that is required is a model to learn the utility itself and +the fitting and using of the learned model happens behind the scenes. + +There is a longer example with an investigation of the results achieved by DUL +in [a dedicated notebook](../examples/shapley_utility_learning). + +### Leave-One-Out values + +The Leave-One-Out method is the simplest approach to valuation. It assigns to +each sample its *marginal utility* as value: + +$$v_u(x_i) = u(D) − u(D \setminus \{x_i\}).$$ + +For the purposes of data valuation, this is rarely useful beyond serving as a +baseline for benchmarking. Although in some benchmarks it can perform +astonishingly well on occasion. One particular weakness is that it does not +necessarily correlate with an intrinsic value of a sample: since it is a +marginal utility, it is affected by diminishing returns. Often, the training set +is large enough for a single sample not to have any significant effect on +training performance, despite any qualities it may possess. Whether this is +indicative of low value or not depends on each one's goals and definitions, but +other methods are typically preferable. + +```python +from pydvl.value.loo.naive import naive_loo + +values = naive_loo(utility) +``` + +The return value of all valuation functions is an object of type +[ValuationResult][pydvl.value.result.ValuationResult]. This can be iterated over, +indexed with integers, slices and Iterables, as well as converted to a +[pandas.DataFrame][https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html]. + + +## Problems of data values + +There are a number of factors that affect how useful values can be for your +project. In particular, regression can be especially tricky, but the particular +nature of every (non-trivial) ML problem can have an effect: + +* **Unbounded utility**: Choosing a scorer for a classifier is simple: accuracy + or some F-score provides a bounded number with a clear interpretation. However, + in regression problems most scores, like $R^2$, are not bounded because + regressors can be arbitrarily bad. This leads to great variability in the + utility for low sample sizes, and hence unreliable Monte Carlo approximations + to the values. Nevertheless, in practice it is only the ranking of samples + that matters, and this tends to be accurate (wrt. to the true ranking) despite + inaccurate values. + + pyDVL offers a dedicated [function composition][pydvl.utils.score.compose_score] + for scorer functions which can be used to squash a score. + The following is defined in module [score][pydvl.utils.score]: + + ```python + import numpy as np + from pydvl.utils import compose_score + + def sigmoid(x: float) -> float: + return float(1 / (1 + np.exp(-x))) + + squashed_r2 = compose_score("r2", sigmoid, "squashed r2") + + squashed_variance = compose_score( + "explained_variance", sigmoid, "squashed explained variance" + ) + ``` + + These squashed scores can prove useful in regression problems, but they can + also introduce issues in the low-value regime. + +* **High variance utility**: Classical applications of game theoretic value + concepts operate with deterministic utilities, but in ML we use an evaluation + of the model on a validation set as a proxy for the true risk. Even if the + utility *is* bounded, if it has high variance then values will also have high + variance, as will their Monte Carlo estimates. One workaround in pyDVL is to + configure the caching system to allow multiple evaluations of the utility for + every index set. A moving average is computed and returned once the standard + error is small, see [MemcachedConfig][pydvl.utils.config.MemcachedConfig]. + + [@wang_data_2022] prove that by relaxing one of the Shapley axioms + and considering the general class of semi-values, of which Shapley is an + instance, one can prove that a choice of constant weights is the best one can + do in a utility-agnostic setting. So-called *Data Banzhaf* is on our to-do + list! + +* **Data set size**: Computing exact Shapley values is NP-hard, and Monte Carlo + approximations can converge slowly. Massive datasets are thus impractical, at + least with current techniques. A workaround is to group samples and investigate + their value together. In pyDVL you can do this using + [GroupedDataset][pydvl.utils.dataset.GroupedDataset]. + There is a fully worked-out [example here](../examples/shapley_basic_spotify). + Some algorithms also provide different sampling strategies to reduce + the variance, but due to a no-free-lunch-type theorem, + no single strategy can be optimal for all utilities. + +* **Model size**: Since every evaluation of the utility entails retraining the + whole model on a subset of the data, large models require great amounts of + computation. But also, they will effortlessly interpolate small to medium + datasets, leading to great variance in the evaluation of performance on the + dedicated validation set. One mitigation for this problem is cross-validation, + but this would incur massive computational cost. As of v.0.3.0 there are no + facilities in pyDVL for cross-validating the utility (note that this would + require cross-validating the whole value computation). diff --git a/docs/value/semi-values.md b/docs/value/semi-values.md new file mode 100644 index 000000000..8d4e7ebe3 --- /dev/null +++ b/docs/value/semi-values.md @@ -0,0 +1,86 @@ +--- +title: Semi-values +--- + +# Semi-values + +Shapley values are a particular case of a more general concept called semi-value, +which is a generalization to different weighting schemes. A **semi-value** is +any valuation function with the form: + +$$ +v\_\text{semi}(i) = \sum_{i=1}^n w(k) +\sum_{S \subset D\_{-i}^{(k)}} [U(S\_{+i})-U(S)], +$$ + +where the coefficients $w(k)$ satisfy the property: + +$$\sum_{k=1}^n w(k) = 1.$$ + +Two instances of this are **Banzhaf indices** [@wang_data_2022], +and **Beta Shapley** [@kwon_beta_2022], with better numerical and +rank stability in certain situations. + +!!! Note + Shapley values are a particular case of semi-values and can therefore also be + computed with the methods described here. However, as of version 0.6.0, we + recommend using [compute_shapley_values][pydvl.value.shapley.compute_shapley_values] instead, + in particular because it implements truncated Monte Carlo sampling for faster + computation. + + +## Beta Shapley + +For some machine learning applications, where the utility is typically the +performance when trained on a set $S \subset D$, diminishing returns are often +observed when computing the marginal utility of adding a new data point. + +Beta Shapley is a weighting scheme that uses the Beta function to place more +weight on subsets deemed to be more informative. The weights are defined as: + +$$ +w(k) := \frac{B(k+\beta, n-k+1+\alpha)}{B(\alpha, \beta)}, +$$ + +where $B$ is the [Beta function](https://en.wikipedia.org/wiki/Beta_function), +and $\alpha$ and $\beta$ are parameters that control the weighting of the +subsets. Setting both to 1 recovers Shapley values, and setting $\alpha = 1$, and +$\beta = 16$ is reported in [@kwon_beta_2022] to be a good choice for +some applications. See however the [Banzhaf indices][banzhaf-indices] section +for an alternative choice of weights which is reported to work better. + +```python +from pydvl.value import compute_semivalues + +values = compute_semivalues( + u=utility, mode="beta_shapley", done=MaxUpdates(500), alpha=1, beta=16 +) +``` + +## Banzhaf indices + +As noted in the section [Problems of Data Values][problems-of-data-values], +the Shapley value can be very sensitive to variance in the utility function. +For machine learning applications, where the utility is typically the performance +when trained on a set $S \subset D$, this variance is often largest +for smaller subsets $S$. It is therefore reasonable to try reducing +the relative contribution of these subsets with adequate weights. + +One such choice of weights is the Banzhaf index, which is defined as the +constant: + +$$w(k) := 2^{n-1},$$ + +for all set sizes $k$. The intuition for picking a constant weight is that for +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 variance in the utility function than Shapley and Beta Shapley values. + +```python +from pydvl.value import compute_semivalues, MaxUpdates + +values = compute_semivalues( u=utility, mode="banzhaf", done=MaxUpdates(500)) +``` diff --git a/docs/value/shapley.md b/docs/value/shapley.md new file mode 100644 index 000000000..1e74beb98 --- /dev/null +++ b/docs/value/shapley.md @@ -0,0 +1,208 @@ +--- +title: Shapley value +--- + +## Shapley value + +The Shapley method is an approach to compute data values originating in +cooperative game theory. Shapley values are a common way of assigning payoffs to +each participant in a cooperative game (i.e. one in which players can form +coalitions) in a way that ensures that certain axioms are fulfilled. + +pyDVL implements several methods for the computation and approximation of +Shapley values. They can all be accessed via the facade function +[compute_shapley_values][pydvl.value.shapley.compute_shapley_values]. +The supported methods are enumerated in +[ShapleyMode][pydvl.value.shapley.ShapleyMode]. + +Empirically, the most useful method is the so-called *Truncated Monte Carlo +Shapley* [@ghorbani_data_2019], which is a Monte Carlo approximation of the +[permutation Shapley value][permutation-shapley]. + + +### Combinatorial Shapley + +The first algorithm is just a verbatim implementation of the definition. As such +it returns as exact a value as the utility function allows (see what this means +in Problems of Data Values][problems-of-data-values]). + +The value $v$ of the $i$-th sample in dataset $D$ wrt. utility $u$ is computed +as a weighted sum of its marginal utility wrt. every possible coalition of +training samples within the training set: + +$$ +v_u(x_i) = \frac{1}{n} \sum_{S \subseteq D \setminus \{x_i\}} +\binom{n-1}{ | S | }^{-1} [u(S \cup \{x_i\}) − u(S)] +,$$ + +```python +from pydvl.value import compute_shapley_values + +values = compute_shapley_values(utility, mode="combinatorial_exact") +df = values.to_dataframe(column='value') +``` + +We can convert the return value to a +[pandas.DataFrame][]. +and name the column with the results as `value`. Please refer to the +documentation in [shapley][pydvl.value.shapley] and +[ValuationResult][pydvl.value.result.ValuationResult] for more information. + +### Monte Carlo Combinatorial Shapley + +Because the number of subsets $S \subseteq D \setminus \{x_i\}$ is +$2^{ | D | - 1 }$, one typically must resort to approximations. The simplest +one is done via Monte Carlo sampling of the powerset $\mathcal{P}(D)$. In pyDVL +this simple technique is called "Monte Carlo Combinatorial". The method has very +poor converge rate and others are preferred, but if desired, usage follows the +same pattern: + +```python +from pydvl.value import compute_shapley_values, MaxUpdates + +values = compute_shapley_values( + utility, mode="combinatorial_montecarlo", done=MaxUpdates(1000) +) +df = values.to_dataframe(column='cmc') +``` + +The DataFrames returned by most Monte Carlo methods will contain approximate +standard errors as an additional column, in this case named `cmc_stderr`. + +Note the usage of the object [MaxUpdates][pydvl.value.stopping.MaxUpdates] as the +stop condition. This is an instance of a +[StoppingCriterion][pydvl.value.stopping.StoppingCriterion]. Other examples are +[MaxTime][pydvl.value.stopping.MaxTime] and +[AbsoluteStandardError][pydvl.value.stopping.AbsoluteStandardError]. + + +### Owen sampling + +**Owen Sampling** [@okhrati_multilinear_2021] is a practical +algorithm based on the combinatorial definition. It uses a continuous extension +of the utility from $\{0,1\}^n$, where a 1 in position $i$ means that sample +$x_i$ is used to train the model, to $[0,1]^n$. The ensuing expression for +Shapley value uses integration instead of discrete weights: + +$$ +v_u(i) = \int_0^1 \mathbb{E}_{S \sim P_q(D_{\backslash \{ i \}})} +[u(S \cup {i}) - u(S)] +.$$ + +Using Owen sampling follows the same pattern as every other method for Shapley +values in pyDVL. First construct the dataset and utility, then call +[compute_shapley_values][pydvl.value.shapley.compute_shapley_values]: + +```python +from pydvl.value import compute_shapley_values + +values = compute_shapley_values( + u=utility, mode="owen", n_iterations=4, max_q=200 +) +``` + +There are more details on Owen sampling, and its variant *Antithetic Owen +Sampling* in the documentation for the function doing the work behind the scenes: +[owen_sampling_shapley][pydvl.value.shapley.owen.owen_sampling_shapley]. + +Note that in this case we do not pass a +[StoppingCriterion][pydvl.value.stopping.StoppingCriterion] to the function, but instead +the number of iterations and the maximum number of samples to use in the +integration. + +### Permutation Shapley + +An equivalent way of computing Shapley values (`ApproShapley`) appeared in +[@castro_polynomial_2009] and is the basis for the method most often +used in practice. It uses permutations over indices instead of subsets: + +$$ +v_u(x_i) = \frac{1}{n!} \sum_{\sigma \in \Pi(n)} +[u(\sigma_{:i} \cup \{i\}) − u(\sigma_{:i})] +,$$ + +where $\sigma_{:i}$ denotes the set of indices in permutation sigma before the +position where $i$ appears. To approximate this sum (which has $\mathcal{O}(n!)$ +terms!) one uses Monte Carlo sampling of permutations, something which has +surprisingly low sample complexity. One notable difference wrt. the +combinatorial approach above is that the approximations always fulfill the +efficiency axiom of Shapley, namely $\sum_{i=1}^n \hat{v}_i = u(D)$ (see +[@castro_polynomial_2009], Proposition 3.2). + +By adding early stopping, the result is the so-called **Truncated Monte Carlo +Shapley** [@ghorbani_data_2019], which is efficient enough to be +useful in applications. + +```python +from pydvl.value import compute_shapley_values, MaxUpdates + +values = compute_shapley_values( + u=utility, mode="truncated_montecarlo", done=MaxUpdates(1000) +) +``` + + +### Exact Shapley for KNN + +It is possible to exploit the local structure of K-Nearest Neighbours to reduce +the amount of subsets to consider: because no sample besides the K closest +affects the score, most are irrelevant and it is possible to compute a value in +linear time. This method was introduced by [@jia_efficient_2019a], +and can be used in pyDVL with: + +```python +from pydvl.utils import Dataset, Utility +from pydvl.value import compute_shapley_values +from sklearn.neighbors import KNeighborsClassifier + +model = KNeighborsClassifier(n_neighbors=5) +data = Dataset(...) +utility = Utility(model, data) +values = compute_shapley_values(u=utility, mode="knn") +``` + +### Group testing + +An alternative approach introduced in [@jia_efficient_2019a] +first approximates the differences of values with a Monte Carlo sum. With + +$$\hat{\Delta}_{i j} \approx v_i - v_j,$$ + +one then solves the following linear constraint satisfaction problem (CSP) to +infer the final values: + +$$ +\begin{array}{lll} +\sum_{i = 1}^N v_i & = & U (D)\\ +| v_i - v_j - \hat{\Delta}_{i j} | & \leqslant & +\frac{\varepsilon}{2 \sqrt{N}} +\end{array} +$$ + +!!! Warning + We have reproduced this method in pyDVL for completeness and benchmarking, + but we don't advocate its use because of the speed and memory cost. Despite + our best efforts, the number of samples required in practice for convergence + can be several orders of magnitude worse than with e.g. Truncated Monte Carlo. + Additionally, the CSP can sometimes turn out to be infeasible. + +Usage follows the same pattern as every other Shapley method, but with the +addition of an `epsilon` parameter required for the solution of the CSP. It +should be the same value used to compute the minimum number of samples required. +This can be done with [num_samples_eps_delta][pydvl.value.shapley.gt.num_samples_eps_delta], but +note that the number returned will be huge! In practice, fewer samples can be +enough, but the actual number will strongly depend on the utility, in particular +its variance. + +```python +from pydvl.utils import Dataset, Utility +from pydvl.value import compute_shapley_values + +model = ... +data = Dataset(...) +utility = Utility(model, data, score_range=(_min, _max)) +min_iterations = num_samples_eps_delta(epsilon, delta, n, utility.score_range) +values = compute_shapley_values( + u=utility, mode="group_testing", n_iterations=min_iterations, eps=eps +) +``` diff --git a/docs/value/the-core.md b/docs/value/the-core.md new file mode 100644 index 000000000..f4de5ba38 --- /dev/null +++ b/docs/value/the-core.md @@ -0,0 +1,115 @@ +--- +title: The Least Core for Data Valuation +--- + +# Core values + +The Shapley values define a fair way to distribute payoffs amongst all +participants when they form a grand coalition. But they do not consider +the question of stability: under which conditions do all participants +form the grand coalition? Would the participants be willing to form +the grand coalition given how the payoffs are assigned, +or would some of them prefer to form smaller coalitions? + +The Core is another approach to computing data values originating +in cooperative game theory that attempts to ensure this stability. +It is the set of feasible payoffs that cannot be improved upon +by a coalition of the participants. + +It satisfies the following 2 properties: + +- **Efficiency**: + The payoffs are distributed such that it is not possible + to make any participant better off + without making another one worse off. + $$\sum_{x_i\in D} v_u(x_i) = u(D)\,$$ + +- **Coalitional rationality**: + The sum of payoffs to the agents in any coalition S is at + least as large as the amount that these agents could earn by + forming a coalition on their own. + $$\sum_{x_i\in S} v_u(x_i) \geq u(S), \forall S \subset D\,$$ + +The second property states that the sum of payoffs to the agents +in any subcoalition $S$ is at least as large as the amount that +these agents could earn by forming a coalition on their own. + +## Least Core values + +Unfortunately, for many cooperative games the Core may be empty. +By relaxing the coalitional rationality property by a subsidy $e \gt 0$, +we are then able to find approximate payoffs: + +$$ +\sum_{x_i\in S} v_u(x_i) + e \geq u(S), \forall S \subset D, S \neq \emptyset \ +,$$ + +The least core value $v$ of the $i$-th sample in dataset $D$ wrt. +utility $u$ is computed by solving the following Linear Program: + +$$ +\begin{array}{lll} +\text{minimize} & e & \\ +\text{subject to} & \sum_{x_i\in D} v_u(x_i) = u(D) & \\ +& \sum_{x_i\in S} v_u(x_i) + e \geq u(S) &, \forall S \subset D, S \neq \emptyset \\ +\end{array} +$$ + +## Exact Least Core + +This first algorithm is just a verbatim implementation of the definition. +As such it returns as exact a value as the utility function allows +(see what this means in Problems of Data Values][problems-of-data-values]). + +```python +from pydvl.value import compute_least_core_values + +values = compute_least_core_values(utility, mode="exact") +``` + +## Monte Carlo Least Core + +Because the number of subsets $S \subseteq D \setminus \{x_i\}$ is +$2^{ | D | - 1 }$, one typically must resort to approximations. + +The simplest approximation consists in using a fraction of all subsets for the +constraints. [@yan_if_2021] show that a quantity of order +$\mathcal{O}((n - \log \Delta ) / \delta^2)$ is enough to obtain a so-called +$\delta$-*approximate least core* with high probability. I.e. the following +property holds with probability $1-\Delta$ over the choice of subsets: + +$$ +\mathbb{P}_{S\sim D}\left[\sum_{x_i\in S} v_u(x_i) + e^{*} \geq u(S)\right] +\geq 1 - \delta, +$$ + +where $e^{*}$ is the optimal least core subsidy. + +```python +from pydvl.value import compute_least_core_values + +values = compute_least_core_values( + utility, mode="montecarlo", n_iterations=n_iterations +) +``` + +!!! Note + Although any number is supported, it is best to choose `n_iterations` to be + at least equal to the number of data points. + +Because computing the Least Core values requires the solution of a linear and a +quadratic problem *after* computing all the utility values, we offer the +possibility of splitting the latter from the former. This is useful when running +multiple experiments: use +[mclc_prepare_problem][pydvl.value.least_core.montecarlo.mclc_prepare_problem] to prepare a +list of problems to solve, then solve them in parallel with +[lc_solve_problems][pydvl.value.least_core.common.lc_solve_problems]. + +```python +from pydvl.value.least_core import mclc_prepare_problem, lc_solve_problems + +n_experiments = 10 +problems = [mclc_prepare_problem(utility, n_iterations=n_iterations) + for _ in range(n_experiments)] +values = lc_solve_problems(problems) +``` diff --git a/mkdocs.yml b/mkdocs.yml index 78fec2bd4..fa0939223 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -25,6 +25,8 @@ plugins: - build_scripts/generate_api_docs.py - literate-nav: nav_file: SUMMARY.md + implicit_index: false + tab_length: 2 - mkdocs-jupyter: include: ["docs/examples/*.ipynb"] remove_tag_config: @@ -70,17 +72,19 @@ theme: icon: repo: fontawesome/brands/github features: - - search.suggest - - search.highlight - - toc.follow - - navigation.top + - content.code.annotate + - content.code.copy + - navigation.footer +# - navigation.indexes - navigation.instant - - navigation.sections - navigation.path +# - navigation.sections +# - navigation.tabs + - navigation.top - navigation.tracking - - navigation.footer - - content.code.copy - - content.code.annotate + - search.suggest + - search.highlight + - toc.follow palette: # Palette toggle for light mode - media: "(prefers-color-scheme: light)" scheme: default @@ -146,3 +150,29 @@ markdown_extensions: - pymdownx.snippets - pymdownx.superfences - pymdownx.details + +nav: + - Home: index.md + - Getting Started: + - Installation: getting-started/installation.md + - First steps: getting-started/getting-started.md + - Data Valuation: + - Introduction: value/index.md + - Shapley Values: value/shapley.md + - Semi-values: value/semi-values.md + - The core: value/the-core.md + - Examples: + - Shapley values: examples/shapley_basic_spotify.ipynb + - KNN Shapley: examples/shapley_knn_flowers.ipynb + - Data utility learning: examples/shapley_utility_learning.ipynb + - Least Core: examples/least_core_basic.ipynb + - The Influence Function: + - Introduction: influence/index.md + - Examples: + - For CNNs: examples/influence_imagenet.ipynb + - For mislabeled data: examples/influence_synthetic.ipynb + - For outlier detection: examples/influence_wine.ipynb +# - Examples: examples/ + - Code: + - Changelog: CHANGELOG.md + - API: api/pydvl/ From 1947314f12714a942a28365d6d9124af0ef7377b Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 24 Aug 2023 22:32:33 +0200 Subject: [PATCH 309/436] Move api docs --- build_scripts/generate_api_docs.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/build_scripts/generate_api_docs.py b/build_scripts/generate_api_docs.py index ef3949c2f..99751aaa8 100644 --- a/build_scripts/generate_api_docs.py +++ b/build_scripts/generate_api_docs.py @@ -4,11 +4,11 @@ import mkdocs_gen_files nav = mkdocs_gen_files.Nav() - -for path in sorted(Path("src").rglob("*.py")): - module_path = path.relative_to("src").with_suffix("") - doc_path = path.relative_to("src").with_suffix(".md") - full_doc_path = Path("code-reference") / doc_path +root = Path("src") # / Path("pydvl") +for path in sorted(root.rglob("*.py")): + module_path = path.relative_to(root).with_suffix("") + doc_path = path.relative_to(root).with_suffix(".md") + full_doc_path = Path("api") / doc_path parts = tuple(module_path.parts) if parts[-1] == "__init__": @@ -26,5 +26,5 @@ mkdocs_gen_files.set_edit_path(full_doc_path, path) -with mkdocs_gen_files.open("code-reference/SUMMARY.md", "w") as nav_file: - nav_file.writelines(nav.build_literate_nav()) +# with mkdocs_gen_files.open("api/SUMMARY.md", "w") as nav_file: +# nav_file.writelines(nav.build_literate_nav()) From 5a84a4c9e990934b95a8d43509f2fa41f5f4d463 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 24 Aug 2023 22:32:43 +0200 Subject: [PATCH 310/436] Typo in CHANGELOG.md --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2b9e9e454..66fb955f3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -29,7 +29,7 @@ - Decouple ray.init from ParallelConfig [PR #373](https://github.com/appliedAI-Initiative/pyDVL/pull/383) -## 0.6.1 - 🏗 Bug fixes and small improvement +## 0.6.1 - 🏗 Bug fixes and small improvements - Fix parsing keyword arguments of `compute_semivalues` dispatch function [PR #333](https://github.com/appliedAI-Initiative/pyDVL/pull/333) From 96a375bd5285822ab351e361b717da5bc450d8e1 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 24 Aug 2023 23:24:50 +0200 Subject: [PATCH 311/436] Close #308: fix math notation --- docs/value/shapley.md | 10 +++++----- docs/value/the-core.md | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/value/shapley.md b/docs/value/shapley.md index 1e74beb98..9e76336cd 100644 --- a/docs/value/shapley.md +++ b/docs/value/shapley.md @@ -85,9 +85,9 @@ $x_i$ is used to train the model, to $[0,1]^n$. The ensuing expression for Shapley value uses integration instead of discrete weights: $$ -v_u(i) = \int_0^1 \mathbb{E}_{S \sim P_q(D_{\backslash \{ i \}})} -[u(S \cup {i}) - u(S)] -.$$ +v_u(x_i) = \int_0^1 \mathbb{E}_{S \sim P_q(D \backslash \{ x_i \})} +[u(S \cup \{x_i\}) - u(S)]. +$$ Using Owen sampling follows the same pattern as every other method for Shapley values in pyDVL. First construct the dataset and utility, then call @@ -118,8 +118,8 @@ used in practice. It uses permutations over indices instead of subsets: $$ v_u(x_i) = \frac{1}{n!} \sum_{\sigma \in \Pi(n)} -[u(\sigma_{:i} \cup \{i\}) − u(\sigma_{:i})] -,$$ +[u(\sigma_{:i} \cup \{x_i\}) − u(\sigma_{:i})], +$$ where $\sigma_{:i}$ denotes the set of indices in permutation sigma before the position where $i$ appears. To approximate this sum (which has $\mathcal{O}(n!)$ diff --git a/docs/value/the-core.md b/docs/value/the-core.md index f4de5ba38..ceddf0a13 100644 --- a/docs/value/the-core.md +++ b/docs/value/the-core.md @@ -28,7 +28,7 @@ It satisfies the following 2 properties: The sum of payoffs to the agents in any coalition S is at least as large as the amount that these agents could earn by forming a coalition on their own. - $$\sum_{x_i\in S} v_u(x_i) \geq u(S), \forall S \subset D\,$$ + $$\sum_{x_i \in S} v_u(x_i) \geq u(S), \forall S \subset D\,$$ The second property states that the sum of payoffs to the agents in any subcoalition $S$ is at least as large as the amount that From 7f4021eab0d34e0a03e1e616cb787a920e77ef11 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 24 Aug 2023 23:35:27 +0200 Subject: [PATCH 312/436] Fix shapley intro, improve tmcs --- docs/value/shapley.md | 42 ++++++++++++++++++++++++++---------------- 1 file changed, 26 insertions(+), 16 deletions(-) diff --git a/docs/value/shapley.md b/docs/value/shapley.md index 9e76336cd..1746658a1 100644 --- a/docs/value/shapley.md +++ b/docs/value/shapley.md @@ -24,7 +24,7 @@ Shapley* [@ghorbani_data_2019], which is a Monte Carlo approximation of the The first algorithm is just a verbatim implementation of the definition. As such it returns as exact a value as the utility function allows (see what this means -in Problems of Data Values][problems-of-data-values]). +in [Problems of Data Values][problems-of-data-values]). The value $v$ of the $i$-th sample in dataset $D$ wrt. utility $u$ is computed as a weighted sum of its marginal utility wrt. every possible coalition of @@ -43,7 +43,7 @@ df = values.to_dataframe(column='value') ``` We can convert the return value to a -[pandas.DataFrame][]. +[pandas.DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html). and name the column with the results as `value`. Please refer to the documentation in [shapley][pydvl.value.shapley] and [ValuationResult][pydvl.value.result.ValuationResult] for more information. @@ -78,11 +78,11 @@ stop condition. This is an instance of a ### Owen sampling -**Owen Sampling** [@okhrati_multilinear_2021] is a practical -algorithm based on the combinatorial definition. It uses a continuous extension -of the utility from $\{0,1\}^n$, where a 1 in position $i$ means that sample -$x_i$ is used to train the model, to $[0,1]^n$. The ensuing expression for -Shapley value uses integration instead of discrete weights: +**Owen Sampling** [@okhrati_multilinear_2021] is a practical algorithm based on +the combinatorial definition. It uses a continuous extension of the utility from +$\{0,1\}^n$, where a 1 in position $i$ means that sample $x_i$ is used to train +the model, to $[0,1]^n$. The ensuing expression for Shapley value uses +integration instead of discrete weights: $$ v_u(x_i) = \int_0^1 \mathbb{E}_{S \sim P_q(D \backslash \{ x_i \})} @@ -106,15 +106,15 @@ Sampling* in the documentation for the function doing the work behind the scenes [owen_sampling_shapley][pydvl.value.shapley.owen.owen_sampling_shapley]. Note that in this case we do not pass a -[StoppingCriterion][pydvl.value.stopping.StoppingCriterion] to the function, but instead -the number of iterations and the maximum number of samples to use in the +[StoppingCriterion][pydvl.value.stopping.StoppingCriterion] to the function, but +instead the number of iterations and the maximum number of samples to use in the integration. ### Permutation Shapley An equivalent way of computing Shapley values (`ApproShapley`) appeared in -[@castro_polynomial_2009] and is the basis for the method most often -used in practice. It uses permutations over indices instead of subsets: +[@castro_polynomial_2009] and is the basis for the method most often used in +practice. It uses permutations over indices instead of subsets: $$ v_u(x_i) = \frac{1}{n!} \sum_{\sigma \in \Pi(n)} @@ -129,18 +129,28 @@ combinatorial approach above is that the approximations always fulfill the efficiency axiom of Shapley, namely $\sum_{i=1}^n \hat{v}_i = u(D)$ (see [@castro_polynomial_2009], Proposition 3.2). -By adding early stopping, the result is the so-called **Truncated Monte Carlo -Shapley** [@ghorbani_data_2019], which is efficient enough to be -useful in applications. +By adding two types of early stopping, the result is the so-called **Truncated +Monte Carlo Shapley** [@ghorbani_data_2019], which is efficient enough to be +useful in applications. The first is simply a convergence criterion, of which +there are [several to choose from][pydvl.value.stopping]. The second is a +criterion to truncate the iteration over single permutations. +[RelativeTruncation][pydvl.value.shapley.truncated.RelativeTruncation] chooses +to stop iterating over samples in a permutation when the marginal utility +becomes too small. ```python -from pydvl.value import compute_shapley_values, MaxUpdates +from pydvl.value import compute_shapley_values, MaxUpdates, RelativeTruncation values = compute_shapley_values( - u=utility, mode="truncated_montecarlo", done=MaxUpdates(1000) + u=utility, + mode="permutation_montecarlo", + done=MaxUpdates(1000), + truncation=RelativeTruncation(utility, rtol=0.01) ) ``` +You can see this method in action in +[this example](../../examples/shapley_basic_spotify/) using the Spotify dataset. ### Exact Shapley for KNN From 7170312a70452664ce6dfed2f98ca3b0ae1d2d0d Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 24 Aug 2023 23:35:36 +0200 Subject: [PATCH 313/436] Fix all links to api docs within notebooks --- notebooks/shapley_basic_spotify.ipynb | 15 ++++++++------- notebooks/shapley_knn_flowers.ipynb | 8 ++++---- notebooks/shapley_utility_learning.ipynb | 4 ++-- 3 files changed, 14 insertions(+), 13 deletions(-) diff --git a/notebooks/shapley_basic_spotify.ipynb b/notebooks/shapley_basic_spotify.ipynb index 1ed6ece21..4cadcc93e 100644 --- a/notebooks/shapley_basic_spotify.ipynb +++ b/notebooks/shapley_basic_spotify.ipynb @@ -21,7 +21,7 @@ "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](../30-data-valuation.rst)." + "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/)." ] }, { @@ -89,7 +89,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We will be using the following functions from pyDVL. The main entry point is the function [compute_shapley_values()](../pydvl/value/shapley/common.rst#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](../pydvl/utils/dataset.rst#pydvl.utils.dataset.Dataset), [Utility](../pydvl/utils/utility.rst#pydvl.utils.utility.Utility) and [Scorer](../pydvl/utils/score.rst#pydvl.utils.score.Scorer)." + "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)." ] }, { @@ -349,7 +349,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Input and label data are then used to instantiate a [Dataset](../pydvl/utils/dataset.rst#pydvl.utils.dataset.Dataset) object:" + "Input and label data are then used to instantiate a [Dataset](../../api/pydvl/utils/dataset/#pydvl.utils.dataset.Dataset) object:" ] }, { @@ -365,7 +365,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The calculation of exact Shapley values 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](../pydvl/value/shapley/montecarlo.rst), [surrogate models](../pydvl/utils/utility.rst#pydvl.utils.utility.DataUtilityLearning) or [caching](../pydvl/utils/caching.rst) of intermediate results and grouping of data to calculate group Shapley values instead of single data points.\n", + "The calculation of exact Shapley values 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:" ] @@ -387,11 +387,11 @@ "\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](../pydvl/utils/types.rst#pydvl.utils.types.SupervisedModel), which is just the standard sklearn interface of `fit()`,`predict()` and `score()` can be used to construct the utility.\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](../pydvl/utils/utility.rst#pydvl.utils.utility.Utility)." + "We group dataset, model and scoring function into an instance of [Utility](../../api/pydvl/utils/utility/#pydvl.utils.utility.Utility)." ] }, { @@ -411,6 +411,7 @@ " # 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", + " truncation=RelativeTruncation(utility, rtol=0.01),\n", " n_jobs=-1,\n", ")\n", "values.sort(key=\"value\")\n", @@ -421,7 +422,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The function [compute_shapley_values()](../pydvl/value/shapley/common.rst#pydvl.value.shapley.common.compute_shapley_values) serves as a common access point to all Shapley methods. For several of them, we choose a `StoppingCriterion` with the argument `done=`. In this case we choose to stop when the ratio of standard error to value is below 0.3 for at least 90% of the training points, or if the number of updates of any index exceeds 200. The `mode` argument specifies the Shapley method to use. In this case, we use the [Truncated Monte Carlo approximation](../pydvl/value/shapley/truncated.rst#pydvl.value.shapley.truncated.truncated_montecarlo_shapley), which is the fastest of the Monte Carlo methods.\n", + "The function [compute_shapley_values()](../../api/pydvl/value/shapley/common/#pydvl.value.shapley.common.compute_shapley_values) serves as a common access point to all Shapley methods. For most of them, we must choose a `StoppingCriterion` with the argument `done=`. In this case we choose to stop when the ratio of standard error to value is below 0.2 for at least 90% of the training points, or if the number of updates of any index exceeds 1000. The `mode` argument specifies the Shapley method to use. In this case, we use the [Truncated Monte Carlo approximation](../../api/pydvl/value/shapley/truncated/#pydvl.value.shapley.truncated.truncated_montecarlo_shapley), which is the fastest of the Monte Carlo methods, owing both to using the permutation definition of Shapley values and the ability to truncate the iteration over a given permutation. We configure this to happen when the contribution of the remaining elements is below 1% of the total utility with the parameter `truncation=` and the policy [RelativeTruncation](../../api/pydvl/value/shapley/truncated/#pydvl.value.shapley.truncated.RelativeTruncation).\n", "\n", "Let's take a look at the returned dataframe:" ] diff --git a/notebooks/shapley_knn_flowers.ipynb b/notebooks/shapley_knn_flowers.ipynb index 3a073375f..d2894fb17 100644 --- a/notebooks/shapley_knn_flowers.ipynb +++ b/notebooks/shapley_knn_flowers.ipynb @@ -99,7 +99,7 @@ "id": "75abb359", "metadata": {}, "source": [ - "The main entry point is the function [compute_shapley_values()](../pydvl/value/shapley/common.rst#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](../pydvl/utils/dataset.rst#pydvl.utils.dataset.Dataset), [Utility](../pydvl/utils/utility.rst#pydvl.utils.utility.Utility) and [Scorer](../pydvl/utils/score.rst#pydvl.utils.score.Scorer), all of which can be imported from `pydvl.value`:" + "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), all of which can be imported from `pydvl.value`:" ] }, { @@ -119,9 +119,9 @@ "source": [ "## Building a Dataset and a Utility\n", "\n", - "We use [the sklearn iris dataset](https://scikit-learn.org/stable/auto_examples/datasets/plot_iris_dataset.html) and wrap it into a [pydvl.utils.dataset.Dataset](../pydvl/utils/dataset.rst#pydvl.utils.dataset.Dataset) calling the factory [pydvl.utils.dataset.Dataset.from_sklearn()](../pydvl/utils/dataset.rst#pydvl.utils.dataset.Dataset.from_sklearn). This automatically creates a train/test split for us which will be used to compute the utility.\n", + "We use [the sklearn iris dataset](https://scikit-learn.org/stable/auto_examples/datasets/plot_iris_dataset.html) and wrap it into a [pydvl.utils.dataset.Dataset](../../api/pydvl/utils/dataset/#pydvl.utils.dataset.Dataset) calling the factory [pydvl.utils.dataset.Dataset.from_sklearn()](../../api/pydvl/utils/dataset/#pydvl.utils.dataset.Dataset.from_sklearn). This automatically creates a train/test split for us which will be used to compute the utility.\n", "\n", - "We then create a model and instantiate a [Utility](../pydvl/utils/utility.rst#pydvl.utils.utility.Utility) using data and model. The model needs to implement the protocol [pydvl.utils.types.SupervisedModel](../pydvl/utils/types.rst#pydvl.utils.types.SupervisedModel), which is just the standard sklearn interface of `fit()`,`predict()` and `score()`. In constructing the `Utility` one can also choose a scoring function, but we pick the default which is just the model's `knn.score()`." + "We then create a model and instantiate a [Utility](../../api/pydvl/utils/utility/#pydvl.utils.utility.Utility) using data and model. The model needs to implement 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()`. In constructing the `Utility` one can also choose a scoring function, but we pick the default which is just the model's `knn.score()`." ] }, { @@ -144,7 +144,7 @@ "source": [ "## Computing values\n", "\n", - "Calculating the Shapley values is straightforward. We just call [compute_shapley_values()](../pydvl/value/shapley/common.rst#pydvl.value.shapley.common.compute_shapley_values) with the utility object we created above. The function returns a [ValuationResult](../pydvl/value/result.rst#pydvl.value.result.ValuationResult). This object contains the values themselves, data indices and labels." + "Calculating the Shapley values is straightforward. We just call [compute_shapley_values()](../../api/pydvl/value/shapley/common/#pydvl.value.shapley.common.compute_shapley_values) with the utility object we created above. The function returns a [ValuationResult](../../api/pydvl/value/result/#pydvl.value.result.ValuationResult). This object contains the values themselves, data indices and labels." ] }, { diff --git a/notebooks/shapley_utility_learning.ipynb b/notebooks/shapley_utility_learning.ipynb index 4eee9e011..978583975 100644 --- a/notebooks/shapley_utility_learning.ipynb +++ b/notebooks/shapley_utility_learning.ipynb @@ -141,7 +141,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "As is the case with all other Shapley methods, the main entry point is the function [compute_shapley_values()](../pydvl/value/shapley/common.rst#pydvl.value.shapley.common.compute_shapley_values), which provides a facade to all algorithms in this family. We use it with the usual classes [Dataset](../pydvl/utils/dataset.rst#pydvl.utils.dataset.Dataset) and [Utility](../pydvl/utils/utility.rst#pydvl.utils.utility.Utility). In addition, we must import the core class for learning a utility, [DataUtilityLearning](../pydvl/utils/utility.rst#pydvl.utils.utility.DataUtilityLearning)." + "As is the case with all other Shapley methods, 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 algorithms in this family. We use it with the usual classes [Dataset](../../api/pydvl/utils/dataset/#pydvl.utils.dataset.Dataset) and [Utility](../../api/pydvl/utils/utility/#pydvl.utils.utility.Utility). In addition, we must import the core class for learning a utility, [DataUtilityLearning](../../api/pydvl/utils/utility/#pydvl.utils.utility.DataUtilityLearning)." ] }, { @@ -254,7 +254,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We now estimate the Data Shapley values using the [DataUtilityLearning](../pydvl/utils/utility.rst#pydvl.utils.utility.DataUtilityLearning) wrapper. This class wraps a [Utility](../pydvl/utils/utility.rst#pydvl.utils.utility.Utility) and delegates calls to it, up until a given budget. Every call yields a utility sample which is saved under the hood for training of the given utility model. Once the budget is exhausted, `DataUtilityLearning` fits the model to the utility samples and all subsequent calls use the learned model to predict the wrapped utility instead of delegating to it.\n", + "We now estimate the Data Shapley values using the [DataUtilityLearning](../../api/pydvl/utils/utility/#pydvl.utils.utility.DataUtilityLearning) wrapper. This class wraps a [Utility](../../api/pydvl/utils/utility/#pydvl.utils.utility.Utility) and delegates calls to it, up until a given budget. Every call yields a utility sample which is saved under the hood for training of the given utility model. Once the budget is exhausted, `DataUtilityLearning` fits the model to the utility samples and all subsequent calls use the learned model to predict the wrapped utility instead of delegating to it.\n", "\n", "For the utility model we follow the paper and use a fully connected neural network. To train it we use a total of `training_budget` utility samples. We repeat this multiple times for each training budget.\n", "\n", From 726f1cc7fdcbe50003e9ed8d1a353cc0ef22d918 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 24 Aug 2023 23:35:44 +0200 Subject: [PATCH 314/436] Cleanup --- mkdocs.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mkdocs.yml b/mkdocs.yml index fa0939223..e07c244c1 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -6,6 +6,7 @@ copyright: "Copyright © AppliedAI Institute gGmbH" watch: - src/pydvl + - notebooks hooks: - build_scripts/copy_notebooks.py @@ -172,7 +173,6 @@ nav: - For CNNs: examples/influence_imagenet.ipynb - For mislabeled data: examples/influence_synthetic.ipynb - For outlier detection: examples/influence_wine.ipynb -# - Examples: examples/ - Code: - Changelog: CHANGELOG.md - API: api/pydvl/ From 5305f9a606bb79b1ad428104bdb86f34ea532b29 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 24 Aug 2023 23:50:31 +0200 Subject: [PATCH 315/436] Fix text and code block --- docs/getting-started/installation.md | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/docs/getting-started/installation.md b/docs/getting-started/installation.md index a81be900d..9647faef7 100644 --- a/docs/getting-started/installation.md +++ b/docs/getting-started/installation.md @@ -19,20 +19,19 @@ To use all features of influence functions use instead: pip install pyDVL[influence] ``` -This includes a dependency on [PyTorch](https://pytorch.org/) (Version 2.0 and above) -and thus is left out by default. +This includes a dependency on [PyTorch](https://pytorch.org/) (Version 2.0 and +above) and thus is left out by default. -In the case you use Cuda v11.2 ~ 11.8, you can enable eigen computations -(for low-rank approximations) -with [CuPy](https://docs.cupy.dev/en/stable/index.html) on GPU: +In case that you have a supported version of CUDA installed (v11.2 to 11.8 as of +this writing), you can enable eigenvalue computations for low-rank approximations +with [CuPy](https://docs.cupy.dev/en/stable/index.html) on the GPU by using: ```shell pip install pyDVL[cupy] -```` - -If you use a different version of Cuda, -please install CuPy [manually](https://docs.cupy.dev/en/stable/install.html). +``` +If you use a different version of CUDA, please install CuPy +[manually](https://docs.cupy.dev/en/stable/install.html). In order to check the installation you can use: From 25b9d3addee5031723129ede626a6d2b5390ab17 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 25 Aug 2023 00:11:41 +0200 Subject: [PATCH 316/436] Use doc inventories --- docs/value/index.md | 8 ++++---- docs/value/shapley.md | 2 +- mkdocs.yml | 1 + src/pydvl/utils/dataset.py | 2 +- 4 files changed, 7 insertions(+), 6 deletions(-) diff --git a/docs/value/index.md b/docs/value/index.md index edaf053d9..b5afa89c1 100644 --- a/docs/value/index.md +++ b/docs/value/index.md @@ -175,9 +175,9 @@ with different subsets of training data. Each call will retrain the model on a subset and evaluate it on the test data using a scoring function. By default, [Utility][pydvl.utils.utility.Utility] will use `model.score()`, but it is possible to use any scoring function (greater values must be better). In -particular, the constructor accepts the same types as argument as sklearn's -[cross_validate](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.cross_validate.html>): -a string, a scorer callable or [None][] for the default. +particular, the constructor accepts the same types as argument as +[sklearn.model_selection.cross_validate][]: a string, a scorer callable or +[None][] for the default. ```python utility = Utility(model, dataset, "explained_variance") @@ -276,7 +276,7 @@ values = naive_loo(utility) The return value of all valuation functions is an object of type [ValuationResult][pydvl.value.result.ValuationResult]. This can be iterated over, indexed with integers, slices and Iterables, as well as converted to a -[pandas.DataFrame][https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html]. +[pandas.DataFrame][]. ## Problems of data values diff --git a/docs/value/shapley.md b/docs/value/shapley.md index 1746658a1..f5790aa93 100644 --- a/docs/value/shapley.md +++ b/docs/value/shapley.md @@ -43,7 +43,7 @@ df = values.to_dataframe(column='value') ``` We can convert the return value to a -[pandas.DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html). +[pandas.DataFrame][]. and name the column with the results as `value`. Please refer to the documentation in [shapley][pydvl.value.shapley] and [ValuationResult][pydvl.value.result.ValuationResult] for more information. diff --git a/mkdocs.yml b/mkdocs.yml index e07c244c1..44b65d9c4 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -43,6 +43,7 @@ plugins: - https://docs.python.org/3/objects.inv - https://numpy.org/doc/stable/objects.inv - https://pandas.pydata.org/docs/objects.inv + - https://scikit-learn.org/stable/objects.inv paths: [ src ] # search packages in the src folder options: docstring_style: google diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index a9f3d1552..8529b319a 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -255,7 +255,7 @@ def from_sklearn( **kwargs: dict, ) -> "Dataset": """Constructs a [Dataset][pydvl.utils.Dataset] object from a - [Bunch][sklearn.utils.Bunch], as returned by the `load_*` functions in + [sklearn.utils.Bunch][], as returned by the `load_*` functions in [sklearn toy datasets](https://scikit-learn.org/stable/datasets/toy_dataset.html). Args: From dd35fc7ed1efdc5f55b4916085e527578170c8d7 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 25 Aug 2023 00:11:57 +0200 Subject: [PATCH 317/436] Tweaks and fixes --- docs/getting-started/getting-started.md | 2 +- docs/getting-started/installation.md | 27 +++++++++++++++---------- docs/value/index.md | 6 +++--- 3 files changed, 20 insertions(+), 15 deletions(-) diff --git a/docs/getting-started/getting-started.md b/docs/getting-started/getting-started.md index d984a6de9..1bcf9e871 100644 --- a/docs/getting-started/getting-started.md +++ b/docs/getting-started/getting-started.md @@ -29,7 +29,7 @@ should be enough to get you started. If you are somewhat familiar with the concepts of data valuation, you can start by browsing our worked-out examples illustrating pyDVL's capabilities either: -- [[examples]]. +- In the examples under [[data-valuation]] and [[influence-values]]. - Using [binder](https://mybinder.org/) notebooks, deployed from each example's page. - Locally, by starting a jupyter server at the root of the project. You will diff --git a/docs/getting-started/installation.md b/docs/getting-started/installation.md index 9647faef7..a247cb45c 100644 --- a/docs/getting-started/installation.md +++ b/docs/getting-started/installation.md @@ -49,21 +49,26 @@ pip install pyDVL --index-url https://test.pypi.org/simple/ ## Dependencies pyDVL requires Python >= 3.8, [Memcached](https://memcached.org/) for caching -and [Ray](https://ray.io) for parallelization. Additionally, -the [Influence functions][pydvl.influence] module requires PyTorch (see - [[installation]]). +and [Ray](https://ray.io) for parallelization in a cluster (locally it uses joblib). +Additionally, the [Influence functions][pydvl.influence] module requires PyTorch +(see [[installation]]). -ray is used to distribute workloads both locally and across nodes. Please follow -the instructions in their documentation for installation. +ray is used to distribute workloads across nodes in a cluster (it can be used +locally as well, but for this we recommend joblib instead). Please follow the +instructions in their documentation to set up the cluster. ## Setting up the cache -memcached is an in-memory key-value store accessible over the network. pyDVL -uses it to cache certain results and speed-up the computations. You can either -install it as a package or run it inside a docker container (the simplest). For -installation instructions, refer to the -[Getting started](https://github.com/memcached/memcached/wiki#getting-started) -section in memcached's wiki. Then you can run it with: +[memcached](https://memcached.org/) is an in-memory key-value store accessible +over the network. pyDVL uses it to cache the computation of the utility function +and speed-up some computations (in particular, semi-value computations with the +[PermutationSampler][pydvl.value.sampler.PermutationSampler] but other methods +may benefit as well). + +You can either install it as a package or run it inside a docker container (the +simplest). For installation instructions, refer to the [Getting +started](https://github.com/memcached/memcached/wiki#getting-started) section in +memcached's wiki. Then you can run it with: ```shell memcached -u user diff --git a/docs/value/index.md b/docs/value/index.md index b5afa89c1..837d6b7ab 100644 --- a/docs/value/index.md +++ b/docs/value/index.md @@ -170,9 +170,9 @@ model = sk.svm.SVC() utility = Utility(model, dataset) ``` -The object `utility` is a callable that data valuation methods will execute -with different subsets of training data. Each call will retrain the model on a -subset and evaluate it on the test data using a scoring function. By default, +The object `utility` is a callable that data valuation methods will execute with +different subsets of training data. Each call will retrain the model on a subset +and evaluate it on the test data using a scoring function. By default, [Utility][pydvl.utils.utility.Utility] will use `model.score()`, but it is possible to use any scoring function (greater values must be better). In particular, the constructor accepts the same types as argument as From 3c192a8174c035f974e3d917af98ff25977a422a Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 25 Aug 2023 15:57:41 +0200 Subject: [PATCH 318/436] Update CONTRIBUTING.md Co-authored-by: Miguel de Benito Delgado --- CONTRIBUTING.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 7fcf28ffa..534cdd5a1 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -472,7 +472,8 @@ a GitHub release. We use [bump2version](https://pypi.org/project/bump2version/) to bump the build part of the version number without commiting or tagging the change -and then publish a package to TestPyPI from CI using Twine. +and then publish a package to TestPyPI from CI using Twine. The version +has the github run number appended. For more details refer to the [.github/workflows/publish.yaml](.github/workflows/publish.yaml) and From 8fbda1e4cf892adc13fa475b69545eae1feca3bb Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 25 Aug 2023 15:58:54 +0200 Subject: [PATCH 319/436] Switch order of queue cancellation, fix deactivation of flag --- src/pydvl/utils/parallel/futures/ray.py | 83 +++++++++++++------------ 1 file changed, 43 insertions(+), 40 deletions(-) diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index b85a2dad0..6a73a3763 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -132,7 +132,9 @@ def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": self._start_work_item_manager_thread() return future - def shutdown(self, wait: bool = True, *, cancel_futures: Optional[bool] = None) -> None: + def shutdown( + self, wait: bool = True, *, cancel_futures: Optional[bool] = None + ) -> None: """Clean up the resources associated with the Executor. This method tries to mimic the behaviour of :meth:`Executor.shutdown` @@ -345,42 +347,43 @@ def flag_executor_shutting_down(self): executor = self.executor_reference() with self.shutdown_lock: logger.debug("work item manager thread acquired shutdown lock") - if executor is not None: - executor._shutdown = True - if executor._cancel_futures & CancellationPolicy.RUNNING: - logger.debug("forcefully cancelling running futures") - # We cancel the future's object references - # We cannot cancel a running future object. - for future in self.submitted_futures: - ray.cancel(future.object_ref) - # Make sure we do this only once to not waste time looping - # on running processes over and over. - executor._cancel_futures = CancellationPolicy.NONE - - if executor._cancel_futures & CancellationPolicy.PENDING: - # Drain all work items from the queues, - # and then cancel their associated futures. - # We empty the pending queue first. - logger.debug("cancelling pending work items") - while True: - with self.queue_lock: - try: - work_item = self.pending_queue.get_nowait() - except queue.Empty: - break - if work_item is not None: - work_item.future.cancel() - del work_item - while True: - with self.queue_lock: - try: - work_item = self.work_queue.get_nowait() - except queue.Empty: - break - if work_item is not None: - work_item.future.cancel() - del work_item - # FIXME: huh? why is this here? - # Make sure we do this only once to not waste time looping - # on running processes over and over. - executor._cancel_futures = CancellationPolicy.NONE + if executor is None: + return + executor._shutdown = True + + if executor._cancel_futures & CancellationPolicy.PENDING: + # Drain all work items from the queues, + # and then cancel their associated futures. + # We empty the pending queue first. + logger.debug("cancelling pending work items") + while True: + with self.queue_lock: + try: + work_item = self.pending_queue.get_nowait() + except queue.Empty: + break + if work_item is not None: + work_item.future.cancel() + del work_item + while True: + with self.queue_lock: + try: + work_item = self.work_queue.get_nowait() + except queue.Empty: + break + if work_item is not None: + work_item.future.cancel() + del work_item + # Make sure we do this only once to not waste time looping + # on running processes over and over. + executor._cancel_futures &= ~int(CancellationPolicy.PENDING) + + if executor._cancel_futures & CancellationPolicy.RUNNING: + logger.debug("forcefully cancelling running futures") + # We cancel the future's object references + # We cannot cancel a running future object. + for future in self.submitted_futures: + ray.cancel(future.object_ref) + # Make sure we do this only once to not waste time looping + # on running processes over and over. + executor._cancel_futures &= ~int(CancellationPolicy.RUNNING) From c5181895c9122e8981b1a65e72a5f534e4fe0ff7 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 25 Aug 2023 17:25:43 +0200 Subject: [PATCH 320/436] Remove useless kwargs' type annotations to fix issues with mypy and python 3.10 (maybe) --- src/pydvl/utils/dataset.py | 10 +++++----- src/pydvl/utils/parallel/futures/__init__.py | 2 +- src/pydvl/utils/parallel/futures/ray.py | 2 +- src/pydvl/utils/progress.py | 2 +- src/pydvl/value/least_core/__init__.py | 2 +- src/pydvl/value/result.py | 4 ++-- src/pydvl/value/semivalues.py | 2 +- src/pydvl/value/shapley/common.py | 2 +- src/pydvl/value/shapley/gt.py | 2 +- 9 files changed, 14 insertions(+), 14 deletions(-) diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index a9f3d1552..bd8a0c907 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -252,7 +252,7 @@ def from_sklearn( train_size: float = 0.8, random_state: Optional[int] = None, stratify_by_target: bool = False, - **kwargs: dict, + **kwargs, ) -> "Dataset": """Constructs a [Dataset][pydvl.utils.Dataset] object from a [Bunch][sklearn.utils.Bunch], as returned by the `load_*` functions in @@ -305,7 +305,7 @@ def from_arrays( train_size: float = 0.8, random_state: Optional[int] = None, stratify_by_target: bool = False, - **kwargs: dict, + **kwargs, ) -> "Dataset": """Constructs a [Dataset][pydvl.utils.Dataset] object from X and y numpy arrays as returned by the `make_*` functions in [sklearn generated datasets](https://scikit-learn.org/stable/datasets/sample_generators.html). @@ -352,7 +352,7 @@ def __init__( target_names: Optional[Sequence[str]] = None, group_names: Optional[Sequence[str]] = None, description: Optional[str] = None, - **kwargs: dict, + **kwargs, ): """Class for grouping datasets. @@ -451,7 +451,7 @@ def from_sklearn( random_state: Optional[int] = None, stratify_by_target: bool = False, data_groups: Optional[Sequence] = None, - **kwargs: dict, + **kwargs, ) -> "GroupedDataset": """Constructs a [GroupedDataset][pydvl.utils.GroupedDataset] object from a scikit-learn bunch as returned by the `load_*` functions in `sklearn toy datasets @@ -507,7 +507,7 @@ def from_arrays( random_state: Optional[int] = None, stratify_by_target: bool = False, data_groups: Optional[Sequence] = None, - **kwargs: dict, + **kwargs, ) -> "Dataset": """Constructs a [GroupedDataset][pydvl.utils.GroupedDataset] object from X and y numpy arrays as returned by the `make_*` functions in `sklearn generated datasets diff --git a/src/pydvl/utils/parallel/futures/__init__.py b/src/pydvl/utils/parallel/futures/__init__.py index d27b9bb0f..e63e75cff 100644 --- a/src/pydvl/utils/parallel/futures/__init__.py +++ b/src/pydvl/utils/parallel/futures/__init__.py @@ -13,7 +13,7 @@ def init_executor( max_workers: Optional[int] = None, config: ParallelConfig = ParallelConfig(), - **kwargs: dict, + **kwargs, ) -> Generator[Executor, None, None]: """Initializes a futures executor for the given parallel configuration. diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index ddae6bb00..4fb88ccf8 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -98,7 +98,7 @@ def __init__( # Work Item Manager Thread self._work_item_manager_thread: Optional[_WorkItemManagerThread] = None - def submit(self, fn: Callable[..., T], *args: list, **kwargs: dict) -> "Future[T]": + def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": r"""Submits a callable to be executed with the given arguments. Schedules the callable to be executed as fn(\*args, \**kwargs) diff --git a/src/pydvl/utils/progress.py b/src/pydvl/utils/progress.py index 24aa2ace8..a96aeecca 100644 --- a/src/pydvl/utils/progress.py +++ b/src/pydvl/utils/progress.py @@ -52,7 +52,7 @@ def __setattr__(self, key, value): def maybe_progress( - it: Union[int, Iterable, Iterator], display: bool = False, **kwargs: dict + it: Union[int, Iterable, Iterator], display: bool = False, **kwargs ) -> Union[tqdm, MockProgress]: """Returns either a tqdm progress bar or a mock object which wraps the iterator as well, but ignores any accesses to methods or properties. diff --git a/src/pydvl/value/least_core/__init__.py b/src/pydvl/value/least_core/__init__.py index bac5c14bc..8451dd4f0 100644 --- a/src/pydvl/value/least_core/__init__.py +++ b/src/pydvl/value/least_core/__init__.py @@ -47,7 +47,7 @@ def compute_least_core_values( mode: LeastCoreMode = LeastCoreMode.MonteCarlo, non_negative_subsidy: bool = False, solver_options: Optional[dict] = None, - **kwargs: dict, + **kwargs, ) -> ValuationResult: """Umbrella method to compute Least Core values with any of the available algorithms. diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index 3f16fce6e..7873fa33d 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -232,7 +232,7 @@ def __init__( algorithm: str = "", status: Status = Status.Pending, sort: bool = False, - **extra_values: dict, + **extra_values, ): if variances is not None and len(variances) != len(values): raise ValueError("Lengths of values and variances do not match") @@ -678,7 +678,7 @@ def to_dataframe( @classmethod def from_random( - cls, size: int, total: Optional[float] = None, **kwargs: dict + cls, size: int, total: Optional[float] = None, **kwargs ) -> "ValuationResult": """Creates a [ValuationResult][pydvl.value.result.ValuationResult] object and fills it with an array of random values from a uniform distribution in [-1,1]. The values can diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index b6d0ecc5d..38185df99 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -370,7 +370,7 @@ def compute_semivalues( mode: SemiValueMode = SemiValueMode.Shapley, sampler_t: Type[PowersetSampler] = PermutationSampler, n_jobs: int = 1, - **kwargs: dict, + **kwargs, ) -> ValuationResult: """Convenience entry point for most common semi-value computations. diff --git a/src/pydvl/value/shapley/common.py b/src/pydvl/value/shapley/common.py index 7522f4573..b55e018c8 100644 --- a/src/pydvl/value/shapley/common.py +++ b/src/pydvl/value/shapley/common.py @@ -24,7 +24,7 @@ def compute_shapley_values( done: StoppingCriterion = MaxUpdates(100), mode: ShapleyMode = ShapleyMode.TruncatedMontecarlo, n_jobs: int = 1, - **kwargs: dict, + **kwargs, ) -> ValuationResult: """Umbrella method to compute Shapley values with any of the available algorithms. diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index 690297556..1d668e2c4 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -159,7 +159,7 @@ def group_testing_shapley( n_jobs: int = 1, config: ParallelConfig = ParallelConfig(), progress: bool = False, - **options: dict, + **options, ) -> ValuationResult: """Implements group testing for approximation of Shapley values as described in [@jia_efficient_2019]. From 881f3ac011701a4b1af53170a077e1d4970861c3 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 25 Aug 2023 23:07:30 +0200 Subject: [PATCH 321/436] Make code examples collapsible and formatted --- src/pydvl/utils/caching.py | 2 +- src/pydvl/utils/dataset.py | 5 ++- src/pydvl/utils/numeric.py | 11 +++-- src/pydvl/utils/parallel/backend.py | 9 ++-- src/pydvl/utils/parallel/futures/__init__.py | 46 ++++++++++---------- src/pydvl/utils/parallel/map_reduce.py | 7 ++- src/pydvl/utils/utility.py | 8 +++- src/pydvl/value/sampler.py | 17 ++++---- 8 files changed, 60 insertions(+), 45 deletions(-) diff --git a/src/pydvl/utils/caching.py b/src/pydvl/utils/caching.py index 5bcd1d8e2..1d68f4d67 100644 --- a/src/pydvl/utils/caching.py +++ b/src/pydvl/utils/caching.py @@ -162,7 +162,7 @@ def memcached( !!! Warning Do not cache functions with state! See :ref:`cache reuse` - !!! example + ??? Example ```python cached_fun = memcached(**asdict(cache_options))(heavy_computation) ``` diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index 8529b319a..2f14c9ad7 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -182,8 +182,8 @@ def get_test_data( mapping the training data indices into test data indices inside [get_test_data()][pydvl.utils.dataset.Dataset.get_test_data]: - Examples: - + ??? Example + ```pycon >>> from pydvl.utils import Dataset >>> import numpy as np >>> class DatasetWithTestDataIndices(Dataset): @@ -201,6 +201,7 @@ def get_test_data( >>> indices = np.random.choice(dataset.indices, 30, replace=False) >>> _ = dataset.get_training_data(indices) >>> _ = dataset.get_test_data(indices) + ``` Args: indices: Optional indices into the test data. This argument is diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index d01718a4b..3aea14c77 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -31,10 +31,13 @@ def powerset(s: NDArray[T]) -> Iterator[Collection[T]]: [random_powerset()][pydvl.utils.numeric.random_powerset] for random sampling. - >>> import numpy as np - >>> from pydvl.utils.numeric import powerset - >>> list(powerset(np.array((1,2)))) - [(), (1,), (2,), (1, 2)] + ??? Example + ``` pycon + >>> import numpy as np + >>> from pydvl.utils.numeric import powerset + >>> list(powerset(np.array((1,2)))) + [(), (1,), (2,), (1, 2)] + ``` Args: s: The set to use diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index a87db1666..8e9b3718a 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -239,22 +239,23 @@ def init_parallel_backend(config: ParallelConfig) -> BaseParallelBackend: config: instance of [ParallelConfig][pydvl.utils.config.ParallelConfig] with cluster address, number of cpus, etc. - Example: - + ??? Example + ```pycon >>> from pydvl.utils.parallel.backend import init_parallel_backend >>> from pydvl.utils.config import ParallelConfig >>> config = ParallelConfig() >>> parallel_backend = init_parallel_backend(config) >>> parallel_backend - + ``` + ``` pycon >>> from pydvl.utils.parallel.backend import init_parallel_backend >>> from pydvl.utils.config import ParallelConfig >>> config = ParallelConfig(backend="ray") >>> parallel_backend = init_parallel_backend(config) >>> parallel_backend - + ``` """ try: parallel_backend_cls = BaseParallelBackend.BACKENDS[config.backend] diff --git a/src/pydvl/utils/parallel/futures/__init__.py b/src/pydvl/utils/parallel/futures/__init__.py index d27b9bb0f..8ac6c4838 100644 --- a/src/pydvl/utils/parallel/futures/__init__.py +++ b/src/pydvl/utils/parallel/futures/__init__.py @@ -23,29 +23,31 @@ def init_executor( with cluster address, number of cpus, etc. kwargs: Other optional parameter that will be passed to the executor. - Examples: - - >>> from pydvl.utils.parallel.futures import init_executor - >>> from pydvl.utils.config import ParallelConfig - >>> config = ParallelConfig(backend="ray") - >>> with init_executor(max_workers=3, config=config) as executor: - ... pass - - >>> from pydvl.utils.parallel.futures import init_executor - >>> with init_executor() as executor: - ... future = executor.submit(lambda x: x + 1, 1) - ... result = future.result() - ... - >>> print(result) - 2 - - >>> from pydvl.utils.parallel.futures import init_executor - >>> with init_executor() as executor: - ... results = list(executor.map(lambda x: x + 1, range(5))) - ... - >>> print(results) - [1, 2, 3, 4, 5] + ??? Example + ``` pycon + >>> from pydvl.utils.parallel.futures import init_executor + >>> from pydvl.utils.config import ParallelConfig + >>> config = ParallelConfig(backend="ray") + >>> with init_executor(max_workers=3, config=config) as executor: + ... pass + + >>> from pydvl.utils.parallel.futures import init_executor + >>> with init_executor() as executor: + ... future = executor.submit(lambda x: x + 1, 1) + ... result = future.result() + ... + >>> print(result) + 2 + ``` + ``` pycon + >>> from pydvl.utils.parallel.futures import init_executor + >>> with init_executor() as executor: + ... results = list(executor.map(lambda x: x + 1, range(5))) + ... + >>> print(results) + [1, 2, 3, 4, 5] + ``` """ try: cls = BaseParallelBackend.BACKENDS[config.backend] diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index 4cc165c89..2788dafaa 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -41,8 +41,10 @@ class MapReduceJob(Generic[T, R]): with cluster address, number of cpus, etc. n_jobs: Number of parallel jobs to run. Does not accept 0 - Examples: + ??? Example A simple usage example with 2 jobs: + + ``` pycon >>> from pydvl.utils.parallel import MapReduceJob >>> import numpy as np >>> map_reduce_job: MapReduceJob[np.ndarray, np.ndarray] = MapReduceJob( @@ -53,8 +55,10 @@ class MapReduceJob(Generic[T, R]): ... ) >>> map_reduce_job() 10 + ``` When passed a single object as input, it will be repeated for each job: + ``` pycon >>> from pydvl.utils.parallel import MapReduceJob >>> import numpy as np >>> map_reduce_job: MapReduceJob[int, np.ndarray] = MapReduceJob( @@ -65,6 +69,7 @@ class MapReduceJob(Generic[T, R]): ... ) >>> map_reduce_job() 10 + ``` """ def __init__( diff --git a/src/pydvl/utils/utility.py b/src/pydvl/utils/utility.py index e81f0e6b0..68f0392d5 100644 --- a/src/pydvl/utils/utility.py +++ b/src/pydvl/utils/utility.py @@ -92,7 +92,8 @@ class Utility: clone_before_fit: If `True`, the model will be cloned before calling `fit()`. - Examples: + ??? Example + ``` pycon >>> from pydvl.utils import Utility, DataUtilityLearning, Dataset >>> from sklearn.linear_model import LinearRegression, LogisticRegression >>> from sklearn.datasets import load_iris @@ -100,6 +101,7 @@ class Utility: >>> u = Utility(LogisticRegression(random_state=16), dataset) >>> u(dataset.indices) 0.9 + ``` """ @@ -269,7 +271,8 @@ class DataUtilityLearning: the given model. model: A supervised regression model - Examples: + ??? Example + ``` pycon >>> from pydvl.utils import Utility, DataUtilityLearning, Dataset >>> from sklearn.linear_model import LinearRegression, LogisticRegression >>> from sklearn.datasets import load_iris @@ -281,6 +284,7 @@ class DataUtilityLearning: ... _ = wrapped_u((i,)) >>> wrapped_u((1, 2, 3)) # Subsequent calls will be computed using the fit model for DUL 0.0 + ``` """ diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index cd4a72268..a637c0265 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -82,10 +82,12 @@ class PowersetSampler(abc.ABC, Iterable[SampleT], Generic[T]): Samplers are **not** iterators themselves, so that each call to ``iter()`` e.g. in a for loop creates a new iterator. - !!! Example + ??? Example + ``` pycon >>>for idx, s in DeterministicUniformSampler(np.arange(2)): >>> print(s, end="") [][2,][][1,] + ``` # Methods required in subclasses @@ -219,13 +221,10 @@ def __init__(self, indices: NDArray[T], *args, **kwargs): Indices are always iterated over sequentially, irrespective of the value of `index_iteration` upon construction. - !!! Example - ```python - for idx, s in DeterministicUniformSampler(np.arange(2)): - print(f"{idx} - {s}", end=", ") - ``` - Produces the output: - ``` + ??? Example + ``` pycon + >>> for idx, s in DeterministicUniformSampler(np.arange(2)): + >>> print(f"{idx} - {s}", end=", ") 1 - [], 1 - [2], 2 - [], 2 - [1], ``` @@ -255,7 +254,7 @@ class UniformSampler(PowersetSampler[T]): ``indices - {i}`` is sampled with equal probability $2^{n-1}$. The iterator never ends. - !!! Example + ??? Example The code ```python for idx, s in UniformSampler(np.arange(3)): From 8a6514e0067445d6103ff2eb24cf9ed128f1f61b Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 25 Aug 2023 23:52:02 +0200 Subject: [PATCH 322/436] FIx some cross-references --- src/pydvl/utils/parallel/map_reduce.py | 6 +-- src/pydvl/value/result.py | 4 +- src/pydvl/value/semivalues.py | 66 ++++++++++++++------------ src/pydvl/value/shapley/montecarlo.py | 6 +-- src/pydvl/value/shapley/owen.py | 4 +- src/pydvl/value/shapley/truncated.py | 6 +-- src/pydvl/value/stopping.py | 64 ++++++++++++++----------- 7 files changed, 82 insertions(+), 74 deletions(-) diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index 2788dafaa..fc917f7c3 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -32,11 +32,9 @@ class MapReduceJob(Generic[T, R]): reduce_func: Function that will be applied to the results of `map_func` to reduce them. map_kwargs: Keyword arguments that will be passed to `map_func` in - each job. Alternatively, one can use - [itertools.partial][itertools.partial]. + each job. Alternatively, one can use [functools.partial][]. reduce_kwargs: Keyword arguments that will be passed to `reduce_func` - in each job. Alternatively, one can use - [itertools.partial][itertools.partial]. + in each job. Alternatively, one can use [functools.partial][]. config: Instance of [ParallelConfig][pydvl.utils.config.ParallelConfig] with cluster address, number of cpus, etc. n_jobs: Number of parallel jobs to run. Does not accept 0 diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index 3f16fce6e..9bba20286 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -28,7 +28,7 @@ Indexing and slicing of results is supported and [ValueItem][pydvl.value.result.ValueItem] objects are returned. These objects can be compared with the usual operators, which take only the -[ValueItem.value][pydvl.value.result.ValueItem.value] into account. +[ValueItem.value][pydvl.value.result.ValueItem] into account. # Creating result objects @@ -293,7 +293,7 @@ def sort( Args: reverse: Whether to sort in descending order by value. key: The key to sort by. Defaults to - [ValueItem.value][pydvl.value.result.ValueItem.value]. + [ValueItem.value][pydvl.value.result.ValueItem]. """ keymap = { "index": "_indices", diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index b6d0ecc5d..75799b6c3 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -48,7 +48,7 @@ [compute_shapley_semivalues][pydvl.value.semivalues.compute_shapley_semivalues], [compute_banzhaf_semivalues][pydvl.value.semivalues.compute_banzhaf_semivalues], and [compute_beta_shapley_semivalues][pydvl.value.semivalues.compute_beta_shapley_semivalues]. - instead. +instead. """ from __future__ import annotations @@ -253,16 +253,18 @@ def compute_shapley_semivalues( for a more flexible interface and additional methods, including Truncated Monte Carlo. - :param u: Utility object with model, data, and scoring function. - :param done: Stopping criterion. - :param sampler_t: The sampler type to use. See :mod:`pydvl.value.sampler` - for a list. - :param n_jobs: Number of parallel jobs to use. - :param config: Object configuring parallel computation, with cluster - address, number of cpus, etc. - :param progress: Whether to display a progress bar. + Args: + u: Utility object with model, data, and scoring function. + done: Stopping criterion. + sampler_t: The sampler type to use. See :mod:`pydvl.value.sampler` + for a list. + n_jobs: Number of parallel jobs to use. + config: Object configuring parallel computation, with cluster + address, number of cpus, etc. + progress: Whether to display a progress bar. - :return: Object with the results. + Returns: + Object with the results. """ return semivalues( sampler_t(u.data.indices), @@ -289,16 +291,18 @@ def compute_banzhaf_semivalues( This is a convenience wrapper for :func:`semivalues` with the Banzhaf coefficient. - :param u: Utility object with model, data, and scoring function. - :param done: Stopping criterion. - :param sampler_t: The sampler type to use. See :mod:`pydvl.value.sampler` - for a list. - :param n_jobs: Number of parallel jobs to use. - :param config: Object configuring parallel computation, with cluster - address, number of cpus, etc. - :param progress: Whether to display a progress bar. + Args: + u: Utility object with model, data, and scoring function. + done: Stopping criterion. + sampler_t: The sampler type to use. See :mod:`pydvl.value.sampler` for a + list. + n_jobs: Number of parallel jobs to use. + config: Object configuring parallel computation, with cluster address, + number of cpus, etc. + progress: Whether to display a progress bar. - :return: Object with the results. + Returns: + Object with the results. """ return semivalues( sampler_t(u.data.indices), @@ -327,18 +331,18 @@ def compute_beta_shapley_semivalues( This is a convenience wrapper for :func:`semivalues` with the Beta Shapley coefficient. - :param u: Utility object with model, data, and scoring function. - :param alpha: Alpha parameter of the Beta distribution. - :param beta: Beta parameter of the Beta distribution. - :param done: Stopping criterion. - :param sampler_t: The sampler type to use. See :mod:`pydvl.value.sampler` - for a list. - :param n_jobs: Number of parallel jobs to use. - :param config: Object configuring parallel computation, with cluster - address, number of cpus, etc. - :param progress: Whether to display a progress bar. - - :return: Object with the results. + Args: + u: Utility object with model, data, and scoring function. + alpha: Alpha parameter of the Beta distribution. + beta: Beta parameter of the Beta distribution. + done: Stopping criterion. + sampler_t: The sampler type to use. See :mod:`pydvl.value.sampler` for a list. + n_jobs: Number of parallel jobs to use. + config: Object configuring parallel computation, with cluster address, number of cpus, etc. + progress: Whether to display a progress bar. + + Returns: + Object with the results. """ return semivalues( sampler_t(u.data.indices), diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index 0b2949aee..a8e125635 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -75,8 +75,8 @@ def _permutation_montecarlo_shapley( """Helper function for [permutation_montecarlo_shapley()][pydvl.value.shapley.montecarlo.permutation_montecarlo_shapley]. Computes marginal utilities of each training sample in - [Utility.data][pydvl.utils.utility.Utility.data] by iterating through - randomly sampled permutations. + [u.data][pydvl.utils.utility.Utility] by iterating through randomly + sampled permutations. Args: u: Utility object with model, data, and scoring function @@ -295,7 +295,7 @@ def combinatorial_montecarlo_shapley( \binom{n-1}{ | S | }^{-1} [u(S \cup \{i\}) − u(S)]$$ This consists of randomly sampling subsets of the power set of the training - indices in [data][pydvl.utils.utility.Utility.data], and computing their + indices in [u.data][pydvl.utils.utility.Utility], and computing their marginal utilities. See [Data valuation][computing-data-values] for details. Note that because sampling is done with replacement, the approximation is diff --git a/src/pydvl/value/shapley/owen.py b/src/pydvl/value/shapley/owen.py index ff5831e93..ad3715d56 100644 --- a/src/pydvl/value/shapley/owen.py +++ b/src/pydvl/value/shapley/owen.py @@ -42,8 +42,8 @@ def _owen_sampling_shapley( Args: indices: Indices to compute the value for u: Utility object with model, data, and scoring function - method: Either [Full][pydvl.value.shapley.owen.OwenAlgorithm.Full] for - q ∈ [0, 1] or [Halved][pydvl.value.shapley.owen.OwenAlgorithm.Halved] + method: Either [OwenAlgorithm.Full][pydvl.value.shapley.owen.OwenAlgorithm] + for q ∈ [0, 1] or [OwenAlgorithm.Halved][pydvl.value.shapley.owen.OwenAlgorithm] for q ∈ [0, 0.5] and correlated samples n_samples: Number of subsets to sample to estimate the integrand max_q: number of subdivisions for the integration over $q$ diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 9688323a2..fe8e74ac8 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -26,10 +26,8 @@ class TruncationPolicy(abc.ABC): """A policy for deciding whether to stop computing marginals in a permutation. - Statistics are kept on the number of calls and truncations as - [n_calls][pydvl.value.shapley.truncated.TruncationPolicy.n_calls] and - [n_truncations][pydvl.value.shapley.truncated.TruncationPolicy.n_truncations] - respectively. + Statistics are kept on the number of calls and truncations as `n_calls` and + `n_truncations` respectively. Attributes: n_calls: Number of calls to the policy. diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index fd8fcf090..ade396fe4 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -18,8 +18,8 @@ Alternatively, and in particular if reporting of completion is required, one can inherit from this class and implement the abstract methods -[_check()][pydvl.value.stopping.StoppingCriterion._check] and -[completion()][pydvl.value.stopping.StoppingCriterion.completion]. +[_check][pydvl.value.stopping.StoppingCriterion._check] and +[completion][pydvl.value.stopping.StoppingCriterion.completion]. # Composing stopping criteria @@ -34,7 +34,7 @@ import abc import logging from time import time -from typing import Callable, Optional, Type +from typing import Callable, Optional, Protocol, Type import numpy as np from deprecate import deprecated, void @@ -57,9 +57,12 @@ logger = logging.getLogger(__name__) -StoppingCriterionCallable = Callable[ - [ValuationResult], Status -] #: Signature for a stopping criterion + +class StoppingCriterionCallable(Protocol): + """Signature for a stopping criterion""" + + def __call__(self, result: ValuationResult) -> Status: + ... class StoppingCriterion(abc.ABC): @@ -69,8 +72,10 @@ class StoppingCriterion(abc.ABC): A `StoppingCriterion` is a callable taking a [ValuationResult][pydvl.value.result.ValuationResult] and returning a [Status][pydvl.value.result.Status]. It also keeps track of individual - convergence of values with [converged()][pydvl.value.stopping.StoppingCriterion.converged], and reports the overall - completion of the computation with [completion()][pydvl.value.stopping.StoppingCriterion.completion]. + convergence of values with + [converged][pydvl.value.stopping.StoppingCriterion.converged], and reports + the overall completion of the computation with + [completion][pydvl.value.stopping.StoppingCriterion.completion]. Instances of `StoppingCriterion` can be composed with the binary operators `&` (*and*), and `|` (*or*), following the truth tables of @@ -78,27 +83,30 @@ class StoppingCriterion(abc.ABC): also supported. These boolean operations act according to the following rules: - - The results of [_check()][pydvl.value.stopping.StoppingCriterion._check] are combined with the operator. See - [Status][pydvl.utils.status.Status] for the truth tables. - - The results of [converged()][pydvl.value.stopping.StoppingCriterion.converged] are combined with the operator (returning - another boolean array). - - The [completion()][pydvl.value.stopping.StoppingCriterion.completion] method returns the min, max, or the complement to 1 - of the completions of the operands, for AND, OR and NOT respectively. This - is required for cases where one of the criteria does not keep track of the - convergence of single values, e.g. [MaxUpdates][pydvl.value.stopping.MaxUpdates], because - [completion()][pydvl.value.stopping.StoppingCriterion.completion] by default returns the mean of the boolean convergence - array. + - The results of [_check][pydvl.value.stopping.StoppingCriterion._check] are + combined with the operator. See [Status][pydvl.utils.status.Status] for + the truth tables. + - The results of + [converged][pydvl.value.stopping.StoppingCriterion.converged] are combined + with the operator (returning another boolean array). + - The [completion][pydvl.value.stopping.StoppingCriterion.completion] + method returns the min, max, or the complement to 1 of the completions of + the operands, for AND, OR and NOT respectively. This is required for cases + where one of the criteria does not keep track of the convergence of single + values, e.g. [MaxUpdates][pydvl.value.stopping.MaxUpdates], because + [completion][pydvl.value.stopping.StoppingCriterion.completion] by + default returns the mean of the boolean convergence array. # Subclassing Subclassing this class requires implementing a - [_check()][pydvl.value.stopping.StoppingCriterion._check] method that + [_check][pydvl.value.stopping.StoppingCriterion._check] method that returns a [Status][pydvl.utils.status.Status] object based on a given [ValuationResult][pydvl.value.result.ValuationResult]. This method should update the attribute [_converged][pydvl.value.stopping.StoppingCriterion._converged], which is a boolean array indicating whether the value for each index has converged. When this does not make sense for a particular stopping criterion, - [completion()][pydvl.value.stopping.StoppingCriterion.completion] should be + [completion][pydvl.value.stopping.StoppingCriterion.completion] should be overridden to provide an overall completion value, since its default implementation attempts to compute the mean of [_converged][pydvl.value.stopping.StoppingCriterion._converged]. @@ -136,7 +144,7 @@ def converged(self) -> NDArray[np.bool_]: for each data point. Inheriting classes must set the `_converged` attribute in their - [_check()][pydvl.value.stopping.StoppingCriterion._check]. + [_check][pydvl.value.stopping.StoppingCriterion._check]. Returns: A boolean array indicating whether the values have converged for @@ -149,7 +157,7 @@ def name(self): return type(self).__name__ def __call__(self, result: ValuationResult) -> Status: - """Calls [_check()][pydvl.value.stopping.StoppingCriterion._check], maybe updating the result.""" + """Calls [_check][pydvl.value.stopping.StoppingCriterion._check], maybe updating the result.""" if len(result) == 0: logger.warning( "At least one iteration finished but no results where generated. " @@ -238,18 +246,18 @@ class AbsoluteStandardError(StoppingCriterion): r"""Determine convergence based on the standard error of the values. If $s_i$ is the standard error for datum $i$ and $v_i$ its value, then this - criterion returns [Converged][pydvl.utils.status.Status.Converged] if + criterion returns [Converged][pydvl.utils.status.Status] if $s_i < \epsilon$ for all $i$ and a threshold value $\epsilon \gt 0$. Args: threshold: A value is considered to have converged if the standard error is below this value. A way of choosing it is to pick some - percentage of the range of the values. For Shapley values this is the - difference between the maximum and minimum of the utility function (to - see this substitute the maximum and minimum values of the utility into - the marginal contribution formula). + percentage of the range of the values. For Shapley values this is + the difference between the maximum and minimum of the utility + function (to see this substitute the maximum and minimum values of + the utility into the marginal contribution formula). fraction: The fraction of values that must have converged for the - criterion to return [Converged][pydvl.utils.status.Status.Converged]. + criterion to return [Converged][pydvl.utils.status.Status]. burn_in: The number of iterations to ignore before checking for convergence. This is required because computations typically start with zero variance, as a result of using From 40123e2223e0b11fd91a0b095039ca1fc0bfb02f Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 25 Aug 2023 23:52:25 +0200 Subject: [PATCH 323/436] Add missing class attributes to docstring --- src/pydvl/utils/utility.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/pydvl/utils/utility.py b/src/pydvl/utils/utility.py index 68f0392d5..7f8f71a77 100644 --- a/src/pydvl/utils/utility.py +++ b/src/pydvl/utils/utility.py @@ -63,6 +63,14 @@ class Utility: and across nodes, but must always be enabled for your project first, see [Setting up the cache][setting-up-the-cache]. + Attributes: + model: The supervised model. + data: An object containing the split data. + scorer: A scoring function. If None, the `score()` method of the model + will be used. See [score][pydvl.utils.score] for ways to create + and compose scorers, in particular how to set default values and + ranges. + Args: model: Any supervised model. Typical choices can be found at https://scikit-learn.org/stable/supervised_learning.html From 55981a68a585b9c2e6d1f99e61d9fd2d7cf95bfb Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 25 Aug 2023 23:56:55 +0200 Subject: [PATCH 324/436] Add deprecation notice --- src/pydvl/utils/progress.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/pydvl/utils/progress.py b/src/pydvl/utils/progress.py index 24aa2ace8..15ea7da13 100644 --- a/src/pydvl/utils/progress.py +++ b/src/pydvl/utils/progress.py @@ -1,3 +1,10 @@ +""" +!!! Warning + This module is deprecated and will be removed in a future release. + It implements a wrapper for the [tqdm](https://tqdm.github.io/) progress bar + iterator for easy toggling, but this functionality is already provided by + the `disable` argument of `tqdm`. +""" import collections.abc from typing import Iterable, Iterator, Union From d3327d266c16be168c5562b0deb52b5ebb7bb062 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 25 Aug 2023 23:57:05 +0200 Subject: [PATCH 325/436] Fix another cross-reference --- docs/value/index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/value/index.md b/docs/value/index.md index 837d6b7ab..a22babc24 100644 --- a/docs/value/index.md +++ b/docs/value/index.md @@ -44,7 +44,7 @@ and [pydvl.utils.utility][pydvl.utils.utility], as detailed below. There are three main families of methods for data valuation: game-theoretic, influence-based and intrinsic. As of v0.7.0 pyDVL supports the first two. Here, we focus on game-theoretic concepts and refer to the main documentation on the -[influence funtion][computing-influence-values] for the second. +[influence funtion][influence] for the second. ## Game theoretical methods From 6ce1b8a228edafc23319bd25b87b0803930d3ccf Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 25 Aug 2023 23:58:22 +0200 Subject: [PATCH 326/436] =?UTF-8?q?Now=20fix=20=F0=9F=98=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/value/index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/value/index.md b/docs/value/index.md index a22babc24..2d041ee7c 100644 --- a/docs/value/index.md +++ b/docs/value/index.md @@ -44,7 +44,7 @@ and [pydvl.utils.utility][pydvl.utils.utility], as detailed below. There are three main families of methods for data valuation: game-theoretic, influence-based and intrinsic. As of v0.7.0 pyDVL supports the first two. Here, we focus on game-theoretic concepts and refer to the main documentation on the -[influence funtion][influence] for the second. +[influence funtion][the-influence-function] for the second. ## Game theoretical methods From 1bba4cf1a3406157b7a8ffe5a1106480a4b6bc29 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 26 Aug 2023 00:15:02 +0200 Subject: [PATCH 327/436] More cross-references --- src/pydvl/utils/utility.py | 8 +++++--- src/pydvl/value/result.py | 2 +- src/pydvl/value/shapley/__init__.py | 9 ++++++--- src/pydvl/value/shapley/owen.py | 5 +++-- 4 files changed, 15 insertions(+), 9 deletions(-) diff --git a/src/pydvl/utils/utility.py b/src/pydvl/utils/utility.py index 7f8f71a77..f263200af 100644 --- a/src/pydvl/utils/utility.py +++ b/src/pydvl/utils/utility.py @@ -42,9 +42,11 @@ class Utility: function. An instance of `Utility` holds the triple of model, dataset and scoring - function which determines the value of data points. This is mosly used for - the computation of [Shapley Values][shapley-values] and - [Core Values][core-values]. + function which determines the value of data points. This is used for the + computation of + [all game-theoretic values][game-theoretical-methods] + like [Shapley values][pydvl.value.shapley] and + [the Least Core][pydvl.value.least_core]. The Utility expect the model to fulfill the [SupervisedModel][pydvl.utils.types.SupervisedModel] interface i.e. diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index 9bba20286..0d15a9955 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -693,7 +693,7 @@ def from_random( Returns: A valuation result with its status set to - [Status.Converged][Status.Converged] by default. + [Status.Converged][pydvl.utils.status.Status] by default. :raises ValueError: If `size` is less than 1. diff --git a/src/pydvl/value/shapley/__init__.py b/src/pydvl/value/shapley/__init__.py index 39ab64e7a..d4730237e 100644 --- a/src/pydvl/value/shapley/__init__.py +++ b/src/pydvl/value/shapley/__init__.py @@ -1,9 +1,12 @@ """ This package holds all routines for the computation of Shapley Data value. Users -will want to use [compute_shapley_values()][pydvl.value.shapley.common.compute_shapley_values] as a -single interface to all methods defined in the modules. +will want to use +[compute_shapley_values][pydvl.value.shapley.common.compute_shapley_values] or +[compute_semivalues][pydvl.value.semivalues.compute_semivalues] as interfaces to +most methods defined in the modules. -Please refer to [Data valuation][computing-data-values] for an overview of Shapley Data value. +Please refer to [the guide on data valuation][data-valuation] for an overview of +all methods. """ from ..result import * diff --git a/src/pydvl/value/shapley/owen.py b/src/pydvl/value/shapley/owen.py index ad3715d56..834678b94 100644 --- a/src/pydvl/value/shapley/owen.py +++ b/src/pydvl/value/shapley/owen.py @@ -136,8 +136,9 @@ def owen_sampling_shapley( max_q: Number of subdivisions for q ∈ [0,1] (the element sampling probability) used to approximate the outer integral. method: Selects the algorithm to use, see the description. Either - [Full][pydvl.value.shapley.owen.OwenAlgorithm.Full] for $q \in [0,1]$ - or [Halved][pydvl.value.shapley.owen.OwenAlgorithm.Halved] for + [OwenAlgorithm.Full][pydvl.value.shapley.owen.OwenAlgorithm] for + $q \in [0,1]$ or + [OwenAlgorithm.Halved][pydvl.value.shapley.owen.OwenAlgorithm] for $q \in [0,0.5]$ and correlated samples n_jobs: Number of parallel jobs to use. Each worker receives a chunk of the total of `max_q` values for q. From 5b67c7e49b6f227c4bc5779734d22d345c95399e Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 26 Aug 2023 11:03:32 +0200 Subject: [PATCH 328/436] Use Flag instead of Enum for bitwise ops --- src/pydvl/utils/parallel/backend.py | 13 +++++-------- src/pydvl/utils/parallel/futures/ray.py | 4 ++-- 2 files changed, 7 insertions(+), 10 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index 34c7a0c89..40bcb374d 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -4,7 +4,7 @@ import os from abc import abstractmethod from concurrent.futures import Executor -from enum import Enum +from enum import Flag, auto from typing import Any, Callable, Iterable, Type, TypeVar, cast import joblib @@ -25,7 +25,7 @@ log = logging.getLogger(__name__) -class CancellationPolicy(Enum): +class CancellationPolicy(Flag): """Policy to use when cancelling futures after exiting an Executor. .. note: @@ -38,12 +38,9 @@ class CancellationPolicy(Enum): """ NONE = 0 - PENDING = 1 - RUNNING = 2 - ALL = 3 - - def __and__(self, other: CancellationPolicy) -> bool: - return int(self.value) & int(other.value) > 0 + PENDING = auto() + RUNNING = auto() + ALL = PENDING | RUNNING class BaseParallelBackend(metaclass=NoPublicConstructor): diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 6a73a3763..cc5234201 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -376,7 +376,7 @@ def flag_executor_shutting_down(self): del work_item # Make sure we do this only once to not waste time looping # on running processes over and over. - executor._cancel_futures &= ~int(CancellationPolicy.PENDING) + executor._cancel_futures &= ~CancellationPolicy.PENDING if executor._cancel_futures & CancellationPolicy.RUNNING: logger.debug("forcefully cancelling running futures") @@ -386,4 +386,4 @@ def flag_executor_shutting_down(self): ray.cancel(future.object_ref) # Make sure we do this only once to not waste time looping # on running processes over and over. - executor._cancel_futures &= ~int(CancellationPolicy.RUNNING) + executor._cancel_futures &= ~CancellationPolicy.RUNNING From 3cc68c947e90e3116909512cd0d7afcb8f11ee9e Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 26 Aug 2023 12:14:31 +0200 Subject: [PATCH 329/436] Add glossary with abbreviations to docs --- docs_includes/abbreviations.md | 10 ++++++++++ mkdocs.yml | 7 ++++++- 2 files changed, 16 insertions(+), 1 deletion(-) create mode 100644 docs_includes/abbreviations.md diff --git a/docs_includes/abbreviations.md b/docs_includes/abbreviations.md new file mode 100644 index 000000000..64b0b4528 --- /dev/null +++ b/docs_includes/abbreviations.md @@ -0,0 +1,10 @@ +*[CSP]: Constraint Satisfaction Problem +*[GT]: Group Testing +*[LC]: Least Core +*[LOO]: Leave-One-Out +*[MCLC]: Monte Carlo Least Core +*[MCS]: Monte Carlo Shapley +*[ML]: Machine Learning +*[MSE]: Mean Squared Error +*[SV]: Shapley Value +*[TMCS]: Truncated Monte Carlo Shapley diff --git a/mkdocs.yml b/mkdocs.yml index 44b65d9c4..c630b7ffb 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -77,6 +77,7 @@ theme: - content.code.annotate - content.code.copy - navigation.footer +# - content.tooltips # insiders only # - navigation.indexes - navigation.instant - navigation.path @@ -130,6 +131,7 @@ extra: link: https://de.linkedin.com/company/appliedai-institute-for-europe-ggmbh markdown_extensions: + - abbr - admonition - attr_list - footnotes @@ -149,7 +151,9 @@ markdown_extensions: - pymdownx.arithmatex: generic: true - pymdownx.inlinehilite - - pymdownx.snippets + - pymdownx.snippets: + auto_append: + - docs_includes/abbreviations.md - pymdownx.superfences - pymdownx.details @@ -160,6 +164,7 @@ nav: - First steps: getting-started/getting-started.md - Data Valuation: - Introduction: value/index.md + - Notation: value/notation.md - Shapley Values: value/shapley.md - Semi-values: value/semi-values.md - The core: value/the-core.md From b384ba62e1fe121b63fbfea0f3abf825dace0619 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 26 Aug 2023 12:15:35 +0200 Subject: [PATCH 330/436] Add notation page, change everywhere --- docs/value/index.md | 13 +++++++++---- docs/value/notation.md | 24 ++++++++++++++++++++++++ docs/value/semi-values.md | 22 +++++++++++++--------- docs/value/shapley.md | 12 +++++++----- docs/value/the-core.md | 14 +++++++------- 5 files changed, 60 insertions(+), 25 deletions(-) create mode 100644 docs/value/notation.md diff --git a/docs/value/index.md b/docs/value/index.md index 2d041ee7c..fed2633b3 100644 --- a/docs/value/index.md +++ b/docs/value/index.md @@ -76,7 +76,7 @@ there are additional desiderata, like having a value function that does not increase with repeated samples. Game-theoretic methods are all rooted in axioms that by construction ensure different desiderata, but despite their practical usefulness, none of them are either necessary or sufficient for all -applications. For instance, Shapley values try to equitably distribute all value +applications. For instance, *[SV]s try to equitably distribute all value among all samples, failing to identify repeated ones as unnecessary, with e.g. a zero value. @@ -252,10 +252,15 @@ in [a dedicated notebook](../examples/shapley_utility_learning). ### Leave-One-Out values -The Leave-One-Out method is the simplest approach to valuation. It assigns to -each sample its *marginal utility* as value: +LOO is the simplest approach to valuation. It assigns to each sample its +*marginal utility* as value: -$$v_u(x_i) = u(D) − u(D \setminus \{x_i\}).$$ +$$v_u(i) = u(D) − u(D_{-i}).$$ + +For notational simplicity, we consider the valuation function as defined over +the indices of the dataset $D$, and $i \in D$ is the index of the sample, +$D_{-i}$ is the training set without the sample $x_i$, and $u$ is the utility +function. For the purposes of data valuation, this is rarely useful beyond serving as a baseline for benchmarking. Although in some benchmarks it can perform diff --git a/docs/value/notation.md b/docs/value/notation.md new file mode 100644 index 000000000..f14ce6466 --- /dev/null +++ b/docs/value/notation.md @@ -0,0 +1,24 @@ +--- +title: Notation for valuation +--- + +# Notation for valuation + +The following notation is used throughout the documentation: + +Let $D = \{x_1, \ldots, x_n\}$ be a training set of $n$ samples. + +The utility function $u:\mathcal{D} \rightarrow \mathbb{R}$ maps subsets of $D$ +to real numbers. + +The value $v$ of the $i$-th sample in dataset $D$ wrt. utility $u$ is +denoted as $v_u(x_i)$ or simply $v(i)$. + +For any $S \subseteq D$, we donote by $S_{-i}$ the set of samples in $D$ +excluding $x_i$, and $S_{+i}$ denotes the set $S$ with $x_i$ added. + +The marginal utility of adding sample $x_i$ to a subset $S$ is denoted as +$\delta(i) := u(S_{+i}) - u(S)$. + +The set $D_{-i}^{(k)}$ contains all subsets of $D$ of size $k$ that do not +include sample $x_i$. diff --git a/docs/value/semi-values.md b/docs/value/semi-values.md index 8d4e7ebe3..ba5f31090 100644 --- a/docs/value/semi-values.md +++ b/docs/value/semi-values.md @@ -4,29 +4,33 @@ title: Semi-values # Semi-values -Shapley values are a particular case of a more general concept called semi-value, +SV is a particular case of a more general concept called semi-value, which is a generalization to different weighting schemes. A **semi-value** is any valuation function with the form: $$ -v\_\text{semi}(i) = \sum_{i=1}^n w(k) -\sum_{S \subset D\_{-i}^{(k)}} [U(S\_{+i})-U(S)], +v_\text{semi}(i) = \sum_{i=1}^n w(k) +\sum_{S \subset D_{-i}^{(k)}} [u(S_{+i}) - u(S)], $$ where the coefficients $w(k)$ satisfy the property: -$$\sum_{k=1}^n w(k) = 1.$$ +$$\sum_{k=1}^n w(k) = 1,$$ + +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], and **Beta Shapley** [@kwon_beta_2022], with better numerical and rank stability in certain situations. !!! Note - Shapley values are a particular case of semi-values and can therefore also be - computed with the methods described here. However, as of version 0.6.0, we - recommend using [compute_shapley_values][pydvl.value.shapley.compute_shapley_values] instead, - in particular because it implements truncated Monte Carlo sampling for faster - computation. + Shapley values are a particular case of semi-values and can therefore also + be computed with the methods described here. However, as of version 0.6.0, + we recommend using + [compute_shapley_values][pydvl.value.shapley.compute_shapley_values] + instead, in particular because it implements truncation policies for TMCS. ## Beta Shapley diff --git a/docs/value/shapley.md b/docs/value/shapley.md index f5790aa93..3051dde5e 100644 --- a/docs/value/shapley.md +++ b/docs/value/shapley.md @@ -31,10 +31,13 @@ as a weighted sum of its marginal utility wrt. every possible coalition of training samples within the training set: $$ -v_u(x_i) = \frac{1}{n} \sum_{S \subseteq D \setminus \{x_i\}} -\binom{n-1}{ | S | }^{-1} [u(S \cup \{x_i\}) − u(S)] +v(i) = \frac{1}{n} \sum_{S \subseteq D_{-i}} +\binom{n-1}{ | S | }^{-1} [u(S_{+i}) − u(S)] ,$$ +where $D_{-i}$ denotes the set of samples in $D$ excluding $x_i$, and $S_{+i}$ +denotes the set $S$ with $x_i$ added. + ```python from pydvl.value import compute_shapley_values @@ -50,7 +53,7 @@ documentation in [shapley][pydvl.value.shapley] and ### Monte Carlo Combinatorial Shapley -Because the number of subsets $S \subseteq D \setminus \{x_i\}$ is +Because the number of subsets $S \subseteq D_{-i}$ is $2^{ | D | - 1 }$, one typically must resort to approximations. The simplest one is done via Monte Carlo sampling of the powerset $\mathcal{P}(D)$. In pyDVL this simple technique is called "Monte Carlo Combinatorial". The method has very @@ -85,8 +88,7 @@ the model, to $[0,1]^n$. The ensuing expression for Shapley value uses integration instead of discrete weights: $$ -v_u(x_i) = \int_0^1 \mathbb{E}_{S \sim P_q(D \backslash \{ x_i \})} -[u(S \cup \{x_i\}) - u(S)]. +v_u(i) = \int_0^1 \mathbb{E}_{S \sim P_q(D_{-i})} [u(S_{+i}) - u(S)]. $$ Using Owen sampling follows the same pattern as every other method for Shapley diff --git a/docs/value/the-core.md b/docs/value/the-core.md index ceddf0a13..382881ed0 100644 --- a/docs/value/the-core.md +++ b/docs/value/the-core.md @@ -22,13 +22,13 @@ It satisfies the following 2 properties: The payoffs are distributed such that it is not possible to make any participant better off without making another one worse off. - $$\sum_{x_i\in D} v_u(x_i) = u(D)\,$$ + $$\sum_{i\in D} v(i) = u(D)\,$$ - **Coalitional rationality**: The sum of payoffs to the agents in any coalition S is at least as large as the amount that these agents could earn by forming a coalition on their own. - $$\sum_{x_i \in S} v_u(x_i) \geq u(S), \forall S \subset D\,$$ + $$\sum_{i \in S} v(i) \geq u(S), \forall S \subset D\,$$ The second property states that the sum of payoffs to the agents in any subcoalition $S$ is at least as large as the amount that @@ -41,7 +41,7 @@ By relaxing the coalitional rationality property by a subsidy $e \gt 0$, we are then able to find approximate payoffs: $$ -\sum_{x_i\in S} v_u(x_i) + e \geq u(S), \forall S \subset D, S \neq \emptyset \ +\sum_{i\in S} v(i) + e \geq u(S), \forall S \subset D, S \neq \emptyset \ ,$$ The least core value $v$ of the $i$-th sample in dataset $D$ wrt. @@ -50,8 +50,8 @@ utility $u$ is computed by solving the following Linear Program: $$ \begin{array}{lll} \text{minimize} & e & \\ -\text{subject to} & \sum_{x_i\in D} v_u(x_i) = u(D) & \\ -& \sum_{x_i\in S} v_u(x_i) + e \geq u(S) &, \forall S \subset D, S \neq \emptyset \\ +\text{subject to} & \sum_{i\in D} v(i) = u(D) & \\ +& \sum_{i\in S} v(i) + e \geq u(S) &, \forall S \subset D, S \neq \emptyset \\ \end{array} $$ @@ -69,7 +69,7 @@ values = compute_least_core_values(utility, mode="exact") ## Monte Carlo Least Core -Because the number of subsets $S \subseteq D \setminus \{x_i\}$ is +Because the number of subsets $S \subseteq D \setminus \{i\}$ is $2^{ | D | - 1 }$, one typically must resort to approximations. The simplest approximation consists in using a fraction of all subsets for the @@ -79,7 +79,7 @@ $\delta$-*approximate least core* with high probability. I.e. the following property holds with probability $1-\Delta$ over the choice of subsets: $$ -\mathbb{P}_{S\sim D}\left[\sum_{x_i\in S} v_u(x_i) + e^{*} \geq u(S)\right] +\mathbb{P}_{S\sim D}\left[\sum_{i\in S} v(i) + e^{*} \geq u(S)\right] \geq 1 - \delta, $$ From fb75ce97349ba707dd36ab1d333147497c61ff4a Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 26 Aug 2023 12:15:51 +0200 Subject: [PATCH 331/436] Fixes --- docs/index.md | 15 ++++++++------- src/pydvl/value/sampler.py | 2 +- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/docs/index.md b/docs/index.md index ae3a475c0..1b207f687 100644 --- a/docs/index.md +++ b/docs/index.md @@ -15,18 +15,19 @@ If you're a first time user of pyDVL, we recommend you to go through the - title: To the installation guide image: ./assets/material-toolbox.svg - url: getting-started/installation + url: getting-started/installation.md -- title: To the code +- title: Data valuation image: ./assets/material-code.svg - url: https://github.com/appliedAI-Initiative/pyDVL + url: value/ +- +- title: Influence Function + image: ./assets/material-computer.svg + url: influence/ - title: Browse the API image: ./assets/material-description.svg - url: api + url: api/pydvl/ -- title: To the examples - image: ./assets/material-computer.svg - url: examples ::/cards:: diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index a637c0265..6776a19db 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -1,4 +1,4 @@ -""" +r""" Samplers iterate over subsets of indices. The classes in this module are used to iterate over indices and subsets of their From c6d692380bd097ceca7da9f1370a924abc8c4c62 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 26 Aug 2023 17:25:20 +0200 Subject: [PATCH 332/436] Implement parallel computation for LOO --- CHANGELOG.md | 2 + docs/30-data-valuation.rst | 4 +- src/pydvl/value/loo/__init__.py | 1 + src/pydvl/value/loo/loo.py | 74 +++++++++++++++++++++++++++++++++ src/pydvl/value/loo/naive.py | 39 ++++------------- tests/value/loo/test_loo.py | 6 +-- 6 files changed, 91 insertions(+), 35 deletions(-) create mode 100644 src/pydvl/value/loo/loo.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 933be55a9..515cc1fcb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,8 @@ ## Unreleased +- Enabled parallel computation for Leave-One-Out values + [PR #...]() - Fixes to parallel computation of generic semi-values: properly handle all samplers and stopping criteria, irrespective of parallel backend [PR #372](https://github.com/appliedAI-Initiative/pyDVL/pull/372) diff --git a/docs/30-data-valuation.rst b/docs/30-data-valuation.rst index 0922d6da8..664890e9e 100644 --- a/docs/30-data-valuation.rst +++ b/docs/30-data-valuation.rst @@ -197,9 +197,9 @@ definitions, but other methods are typically preferable. .. code-block:: python - from pydvl.value.loo.naive import naive_loo + from pydvl.value.loo import loo utility = Utility(...) - values = naive_loo(utility) + values = loo(utility) The return value of all valuation functions is an object of type :class:`~pydvl.value.result.ValuationResult`. This can be iterated over, diff --git a/src/pydvl/value/loo/__init__.py b/src/pydvl/value/loo/__init__.py index e300848c4..6b9e972fc 100644 --- a/src/pydvl/value/loo/__init__.py +++ b/src/pydvl/value/loo/__init__.py @@ -1 +1,2 @@ +from .loo import * from .naive import * diff --git a/src/pydvl/value/loo/loo.py b/src/pydvl/value/loo/loo.py new file mode 100644 index 000000000..b2a36fd67 --- /dev/null +++ b/src/pydvl/value/loo/loo.py @@ -0,0 +1,74 @@ +from concurrent.futures import FIRST_COMPLETED, Future, wait +from tqdm import tqdm + +from pydvl.utils import ParallelConfig, Utility, effective_n_jobs, init_executor +from pydvl.value.result import ValuationResult + +__all__ = ["loo"] + + +def loo( + u: Utility, + *, + n_jobs: int = 1, + config: ParallelConfig = ParallelConfig(), + progress: bool = True +) -> ValuationResult: + r"""Computes leave one out value: + + $$v(i) = u(D) - u(D \setminus \{i\}) $$ + + :param u: Utility object with model, data, and scoring function + :param n_jobs: Number of parallel jobs to use + :param config: Object configuring parallel computation, with cluster + address, number of cpus, etc. + :param progress: If True, display a progress bar + :return: Object with the data values. + + .. versionchanged:: 0.7.0 + Renamed from `naive_loo` and added parallel computation. + """ + + if len(u.data) < 3: + raise ValueError("Dataset must have at least 2 elements") + + result = ValuationResult.zeros( + algorithm="loo", + indices=u.data.indices, + data_names=u.data.data_names, + ) + + all_indices = set(u.data.indices) + total_utility = u(u.data.indices) + + def fun(idx: int) -> tuple[int, float]: + return idx, total_utility - u(all_indices.difference({idx})) + + max_workers = effective_n_jobs(n_jobs, config) + n_submitted_jobs = 2 * max_workers # number of jobs in the queue + + # NOTE: this could be done with a simple executor.map(), but we want to + # display a progress bar + + with init_executor( + max_workers=max_workers, config=config, cancel_futures=True + ) as executor: + pending: set[Future] = set() + index_it = iter(u.data.indices) + + pbar = tqdm(disable=not progress, total=100, unit="%") + while True: + pbar.n = 100 * sum(result.counts) / len(u.data) + pbar.refresh() + completed, pending = wait(pending, timeout=0.1, return_when=FIRST_COMPLETED) + for future in completed: + idx, marginal = future.result() + result.update(idx, marginal) + + # Ensure that we always have n_submitted_jobs running + try: + for _ in range(n_submitted_jobs - len(pending)): + pending.add(executor.submit(fun, next(index_it))) + except StopIteration: + if len(pending) == 0: + return result diff --git a/src/pydvl/value/loo/naive.py b/src/pydvl/value/loo/naive.py index c990bf6a3..aac14456a 100644 --- a/src/pydvl/value/loo/naive.py +++ b/src/pydvl/value/loo/naive.py @@ -1,36 +1,15 @@ -import numpy as np -from numpy.typing import NDArray +from deprecate import deprecated -from pydvl.utils import Utility, maybe_progress -from pydvl.utils.status import Status +from pydvl.utils import Utility from pydvl.value.result import ValuationResult +from .loo import loo __all__ = ["naive_loo"] -def naive_loo(u: Utility, *, progress: bool = True) -> ValuationResult: - r"""Computes leave one out value: - - $$v(i) = u(D) - u(D \setminus \{i\}) $$ - - :param u: Utility object with model, data, and scoring function - :param progress: If True, display a progress bar - :return: Object with the data values. - """ - - if len(u.data) < 3: - raise ValueError("Dataset must have at least 2 elements") - - values: NDArray[np.float_] = np.zeros_like(u.data.indices, dtype=np.float_) - all_indices = set(u.data.indices) - total_utility = u(u.data.indices) - for i in maybe_progress(u.data.indices, progress): # type: ignore - subset = all_indices.difference({i}) - values[i] = total_utility - u(subset) - - return ValuationResult( - algorithm="naive_loo", - status=Status.Converged, - values=values, - data_names=u.data.data_names, - ) +@deprecated( + target=loo, deprecated_in="0.7.0", remove_in="0.8.0", args_extra=dict(n_jobs=1) +) +def naive_loo(u: Utility, *, progress: bool = True, **kwargs) -> ValuationResult: + """Deprecated. Use :func:`~pydvl.value.loo.loo` instead.""" + pass diff --git a/tests/value/loo/test_loo.py b/tests/value/loo/test_loo.py index 2a5b74afd..e254ade3f 100644 --- a/tests/value/loo/test_loo.py +++ b/tests/value/loo/test_loo.py @@ -1,14 +1,14 @@ import pytest -from pydvl.value.loo import naive_loo +from pydvl.value.loo import loo from .. import check_total_value, check_values @pytest.mark.parametrize("num_samples", [10, 100]) -def test_naive_loo(num_samples, analytic_loo): +def test_loo(num_samples: int, n_jobs: int, parallel_config, analytic_loo): """Compares the naive loo with analytic values in a dummy model""" u, exact_values = analytic_loo - values = naive_loo(u, progress=False) + values = loo(u, n_jobs=n_jobs, config=parallel_config, progress=False) check_total_value(u, values, rtol=0.1) check_values(values, exact_values, rtol=0.1) From ab76d18e6ca8fd059409b8ec4fb169577baf2dfe Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 26 Aug 2023 17:27:13 +0200 Subject: [PATCH 333/436] Update CHANGELOG and some cleanup --- CHANGELOG.md | 2 +- tests/value/test_semivalues.py | 2 -- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 515cc1fcb..baaf99e6f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,7 +3,7 @@ ## Unreleased - Enabled parallel computation for Leave-One-Out values - [PR #...]() + [PR #406](https://github.com/appliedAI-Initiative/pyDVL/pull/406) - Fixes to parallel computation of generic semi-values: properly handle all samplers and stopping criteria, irrespective of parallel backend [PR #372](https://github.com/appliedAI-Initiative/pyDVL/pull/372) diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index 8ee802fed..bc39deb39 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -14,11 +14,9 @@ UniformSampler, ) from pydvl.value.semivalues import ( - SemiValueMode, SVCoefficient, banzhaf_coefficient, beta_coefficient, - compute_semivalues, semivalues, shapley_coefficient, ) From d2dc0f006db79ba49cb9f39ad4c1798e136243bd Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 26 Aug 2023 17:32:58 +0200 Subject: [PATCH 334/436] =?UTF-8?q?Duh=20=F0=9F=A4=A6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/pydvl/value/loo/loo.py | 5 ++++- src/pydvl/value/loo/naive.py | 1 + 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/src/pydvl/value/loo/loo.py b/src/pydvl/value/loo/loo.py index b2a36fd67..5725b8798 100644 --- a/src/pydvl/value/loo/loo.py +++ b/src/pydvl/value/loo/loo.py @@ -1,4 +1,7 @@ +from __future__ import annotations + from concurrent.futures import FIRST_COMPLETED, Future, wait + from tqdm import tqdm from pydvl.utils import ParallelConfig, Utility, effective_n_jobs, init_executor @@ -12,7 +15,7 @@ def loo( *, n_jobs: int = 1, config: ParallelConfig = ParallelConfig(), - progress: bool = True + progress: bool = True, ) -> ValuationResult: r"""Computes leave one out value: diff --git a/src/pydvl/value/loo/naive.py b/src/pydvl/value/loo/naive.py index aac14456a..c5242f1e9 100644 --- a/src/pydvl/value/loo/naive.py +++ b/src/pydvl/value/loo/naive.py @@ -2,6 +2,7 @@ from pydvl.utils import Utility from pydvl.value.result import ValuationResult + from .loo import loo __all__ = ["naive_loo"] From c0bf7cc21dadccf1b3c0db546b2e8a21d12b9be5 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 26 Aug 2023 17:34:11 +0200 Subject: [PATCH 335/436] [skip ci] docstring fix --- src/pydvl/value/loo/loo.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pydvl/value/loo/loo.py b/src/pydvl/value/loo/loo.py index 5725b8798..9180cb709 100644 --- a/src/pydvl/value/loo/loo.py +++ b/src/pydvl/value/loo/loo.py @@ -28,7 +28,7 @@ def loo( :param progress: If True, display a progress bar :return: Object with the data values. - .. versionchanged:: 0.7.0 + .. versionadded:: 0.7.0 Renamed from `naive_loo` and added parallel computation. """ From 74a74b7581e8e5d34f7a8542e40fa8d3b574cb9d Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 26 Aug 2023 18:15:52 +0200 Subject: [PATCH 336/436] Some details about parallelization and caching --- docs/getting-started/getting-started.md | 46 +++++++++++++++++++++++++ docs/getting-started/installation.md | 9 +++-- src/pydvl/utils/caching.py | 24 ++++++------- 3 files changed, 62 insertions(+), 17 deletions(-) diff --git a/docs/getting-started/getting-started.md b/docs/getting-started/getting-started.md index 1bcf9e871..67e2cd5f1 100644 --- a/docs/getting-started/getting-started.md +++ b/docs/getting-started/getting-started.md @@ -35,3 +35,49 @@ by browsing our worked-out examples illustrating pyDVL's capabilities either: - Locally, by starting a jupyter server at the root of the project. You will have to install jupyter first manually since it's not a dependency of the library. + +# Advanced usage + +Besides the do's and don'ts of data valuation itself, which are the subject of +the examples and the documentation of each method, there are two main things to +keep in mind when using pyDVL. + +## Caching + +pyDVL uses [memcached](https://memcached.org/) to cache the computation of the +utility function and speed up some computations. + +Caching of the utility function is disabled by default. When it is enabled it +takes into account the data indices passed as argument and the utility function +wrapped into the [Utility][pydvl.value.utility.Utility] object. This means that +care must be taken when reusing the same utility function with different data, +see the documentation for the [caching module][pydvl.utils.caching] for more +information. + +In general, caching won't play a major role in the computation of Shapley values +because the probability of sampling the same subset twice, and hence needing +the same utility function computation, is very low. However, it can be very +useful when comparing methods that use the same utility function, or when +running multiple experiments with the same data. + +!!! tip "When is the cache really necessary?" + Crucially, semi-value computations with the + [PermutationSampler][pydvl.value.sampler.PermutationSampler] require caching + to be enabled, or they will take twice as long as the direct implementation + in [compute_shapley_values][pydvl.value.shapley.compute_shapley_values]. + +## Parallelization + +pyDVL supports [joblib](https://joblib.readthedocs.io/en/latest/) for local +parallelization (within one machine) and [ray](https://ray.io) for distributed +parallelization (across multiple machines). + +The former works out of the box but for the latter you will need to provide a +running cluster (or run ray in local mode). + +As of v0.7.0 pyDVL does not allow requesting resources per task sent to the +cluster, so you will need to make sure that each worker has enough resources to +handle the tasks it receives. A data valuation task using game-theoretic methods +will typically make a copy of the whole model and dataset to each worker, even +if the re-training only happens on a subset of the data. This means that you +should make sure that each worker has enough memory to handle the whole dataset. diff --git a/docs/getting-started/installation.md b/docs/getting-started/installation.md index a247cb45c..2fff75bbb 100644 --- a/docs/getting-started/installation.md +++ b/docs/getting-started/installation.md @@ -61,7 +61,7 @@ instructions in their documentation to set up the cluster. [memcached](https://memcached.org/) is an in-memory key-value store accessible over the network. pyDVL uses it to cache the computation of the utility function -and speed-up some computations (in particular, semi-value computations with the +and speed up some computations (in particular, semi-value computations with the [PermutationSampler][pydvl.value.sampler.PermutationSampler] but other methods may benefit as well). @@ -80,7 +80,6 @@ To run memcached inside a container in daemon mode instead, do: docker container run -d --rm -p 11211:11211 memcached:latest ``` -!!! Warning - To read more about caching and how it might affect your usage, in particular - about cache reuse and its pitfalls, please read the documentation for the - [caching module][pydvl.utils.caching]. +!!! tip "Using the cache" + Continue reading about the cache in the [First Steps](getting-started.md#caching) + and the documentation for the [caching module][pydvl.utils.caching]. diff --git a/src/pydvl/utils/caching.py b/src/pydvl/utils/caching.py index 1d68f4d67..ba6629ce4 100644 --- a/src/pydvl/utils/caching.py +++ b/src/pydvl/utils/caching.py @@ -37,25 +37,25 @@ # Usage with stochastic functions -In addition to standard memoization, the decorator [memcached()][pydvl.utils.caching.memcached] can compute -running average and standard error of repeated evaluations for the same input. -This can be useful for stochastic functions with high variance (e.g. model -training for small sample sizes), but drastically reduces the speed benefits of -memoization. +In addition to standard memoization, the decorator +[memcached()][pydvl.utils.caching.memcached] can compute running average and +standard error of repeated evaluations for the same input. This can be useful +for stochastic functions with high variance (e.g. model training for small +sample sizes), but drastically reduces the speed benefits of memoization. This behaviour can be activated with the argument `allow_repeated_evaluations` to [memcached()][pydvl.utils.caching.memcached]. # Cache reuse -When working directly with [memcached()][pydvl.utils.caching.memcached], it is essential to only cache pure -functions. If they have any kind of state, either internal or external (e.g. a -closure over some data that may change), then the cache will fail to notice this -and the same value will be returned. +When working directly with [memcached()][pydvl.utils.caching.memcached], it is +essential to only cache pure functions. If they have any kind of state, either +internal or external (e.g. a closure over some data that may change), then the +cache will fail to notice this and the same value will be returned. -When a function is wrapped with [memcached()][pydvl.utils.caching.memcached] for memoization, its signature -(input and output names) and code are used as a key for the cache. Alternatively -you can pass a custom value to be used as key with +When a function is wrapped with [memcached()][pydvl.utils.caching.memcached] for +memoization, its signature (input and output names) and code are used as a key +for the cache. Alternatively you can pass a custom value to be used as key with ```python cached_fun = memcached(**asdict(cache_options))(fun, signature=custom_signature) From 1d041795bdc2937ab3ee3b6e9baa9089b2890674 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 26 Aug 2023 19:21:17 +0200 Subject: [PATCH 337/436] Make ray an optional dependency --- requirements.txt | 3 +- setup.py | 6 +- src/pydvl/utils/parallel/__init__.py | 4 + src/pydvl/utils/parallel/backend.py | 146 +----------------- src/pydvl/utils/parallel/backends/__init__.py | 9 ++ src/pydvl/utils/parallel/backends/joblib.py | 67 ++++++++ src/pydvl/utils/parallel/backends/ray.py | 84 ++++++++++ src/pydvl/utils/parallel/futures/__init__.py | 6 +- src/pydvl/utils/parallel/futures/ray.py | 2 +- src/pydvl/value/shapley/montecarlo.py | 3 +- tests/conftest.py | 7 - tests/utils/conftest.py | 11 +- tests/utils/test_parallel.py | 2 +- 13 files changed, 195 insertions(+), 155 deletions(-) create mode 100644 src/pydvl/utils/parallel/backends/__init__.py create mode 100644 src/pydvl/utils/parallel/backends/joblib.py create mode 100644 src/pydvl/utils/parallel/backends/ray.py diff --git a/requirements.txt b/requirements.txt index 235b21620..471ba7475 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,9 +4,8 @@ pandas>=1.3 scikit-learn scipy>=1.7.0 cvxpy>=1.3.0 -ray>=0.8 joblib pymemcache cloudpickle tqdm -matplotlib \ No newline at end of file +matplotlib diff --git a/setup.py b/setup.py index 6c5e9276e..da33620c2 100644 --- a/setup.py +++ b/setup.py @@ -21,7 +21,11 @@ ], setup_requires=["wheel"], tests_require=["pytest"], - extras_require={"influence": ["torch>=2.0.0"], "cupy": ["cupy-cuda11x>=12.1.0"]}, + extras_require={ + "cupy": ["cupy-cuda11x>=12.1.0"], + "influence": ["torch>=2.0.0"], + "ray": ["ray>=0.8"], + }, author="appliedAI Institute gGmbH", long_description=long_description, long_description_content_type="text/markdown", diff --git a/src/pydvl/utils/parallel/__init__.py b/src/pydvl/utils/parallel/__init__.py index be9f612f2..fa08cfb38 100644 --- a/src/pydvl/utils/parallel/__init__.py +++ b/src/pydvl/utils/parallel/__init__.py @@ -1,3 +1,7 @@ from .backend import * +from .backends import * from .futures import * from .map_reduce import * + +if len(BaseParallelBackend.BACKENDS) == 0: + raise ImportError("No parallel backend found. Please install ray or joblib.") diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index 40bcb374d..e1550afdf 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -5,19 +5,18 @@ from abc import abstractmethod from concurrent.futures import Executor from enum import Flag, auto -from typing import Any, Callable, Iterable, Type, TypeVar, cast - -import joblib -import ray -from joblib import delayed -from joblib.externals.loky import get_reusable_executor -from ray import ObjectRef -from ray.util.joblib import register_ray +from typing import Any, Callable, Type, TypeVar from ..config import ParallelConfig from ..types import NoPublicConstructor -__all__ = ["init_parallel_backend", "effective_n_jobs", "available_cpus"] +__all__ = [ + "init_parallel_backend", + "effective_n_jobs", + "available_cpus", + "BaseParallelBackend", + "CancellationPolicy", +] T = TypeVar("T") @@ -94,135 +93,6 @@ def __repr__(self) -> str: return f"<{self.__class__.__name__}: {self.config}>" -class JoblibParallelBackend(BaseParallelBackend, backend_name="joblib"): - """Class used to wrap joblib to make it transparent to algorithms. - - It shouldn't be initialized directly. You should instead call - :func:`~pydvl.utils.parallel.backend.init_parallel_backend`. - - :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with - cluster address, number of cpus, etc. - """ - - def __init__(self, config: ParallelConfig): - self.config = { - "logging_level": config.logging_level, - "n_jobs": config.n_cpus_local, - } - - @classmethod - def executor( - cls, - max_workers: int | None = None, - config: ParallelConfig = ParallelConfig(), - cancel_futures: CancellationPolicy = CancellationPolicy.NONE, - ) -> Executor: - if cancel_futures not in (CancellationPolicy.NONE, False): - log.warning( - "Cancellation of futures is not supported by the joblib backend" - ) - return cast(Executor, get_reusable_executor(max_workers=max_workers)) - - def get(self, v: T, *args, **kwargs) -> T: - return v - - def put(self, v: T, *args, **kwargs) -> T: - return v - - def wrap(self, fun: Callable, **kwargs) -> Callable: - """Wraps a function as a joblib delayed. - - :param fun: the function to wrap - - :return: The delayed function. - """ - return delayed(fun) # type: ignore - - def wait(self, v: list[T], *args, **kwargs) -> tuple[list[T], list[T]]: - return v, [] - - def _effective_n_jobs(self, n_jobs: int) -> int: - if self.config["n_jobs"] is None: - maximum_n_jobs = joblib.effective_n_jobs() - else: - maximum_n_jobs = self.config["n_jobs"] - eff_n_jobs: int = min(joblib.effective_n_jobs(n_jobs), maximum_n_jobs) - return eff_n_jobs - - -class RayParallelBackend(BaseParallelBackend, backend_name="ray"): - """Class used to wrap ray to make it transparent to algorithms. - - It shouldn't be initialized directly. You should instead call - :func:`~pydvl.utils.parallel.backend.init_parallel_backend`. - - :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with - cluster address, number of cpus, etc. - """ - - def __init__(self, config: ParallelConfig): - self.config = {"address": config.address, "logging_level": config.logging_level} - if self.config["address"] is None: - self.config["num_cpus"] = config.n_cpus_local - if not ray.is_initialized(): - ray.init(**self.config) - # Register ray joblib backend - register_ray() - - @classmethod - def executor( - cls, - max_workers: int | None = None, - config: ParallelConfig = ParallelConfig(), - cancel_futures: CancellationPolicy = CancellationPolicy.PENDING, - ) -> Executor: - from pydvl.utils.parallel.futures.ray import RayExecutor - - return RayExecutor(max_workers, config=config, cancel_futures=cancel_futures) # type: ignore - - def get(self, v: ObjectRef | Iterable[ObjectRef] | T, *args, **kwargs) -> T | Any: - timeout: float | None = kwargs.get("timeout", None) - if isinstance(v, ObjectRef): - return ray.get(v, timeout=timeout) - elif isinstance(v, Iterable): - return [self.get(x, timeout=timeout) for x in v] - else: - return v - - def put(self, v: T, *args, **kwargs) -> ObjectRef[T] | T: - try: - return ray.put(v, **kwargs) # type: ignore - except TypeError: - return v # type: ignore - - def wrap(self, fun: Callable, **kwargs) -> Callable: - """Wraps a function as a ray remote. - - :param fun: the function to wrap - :param kwargs: keyword arguments to pass to @ray.remote - - :return: The `.remote` method of the ray `RemoteFunction`. - """ - if len(kwargs) > 0: - return ray.remote(**kwargs)(fun).remote # type: ignore - return ray.remote(fun).remote # type: ignore - - def wait( - self, v: list[ObjectRef], *args, **kwargs - ) -> tuple[list[ObjectRef], list[ObjectRef]]: - num_returns: int = kwargs.get("num_returns", 1) - timeout: float | None = kwargs.get("timeout", None) - return ray.wait(v, num_returns=num_returns, timeout=timeout) # type: ignore - - def _effective_n_jobs(self, n_jobs: int) -> int: - ray_cpus = int(ray._private.state.cluster_resources()["CPU"]) # type: ignore - if n_jobs < 0: - eff_n_jobs = ray_cpus - else: - eff_n_jobs = min(n_jobs, ray_cpus) - return eff_n_jobs - - def init_parallel_backend(config: ParallelConfig) -> BaseParallelBackend: """Initializes the parallel backend and returns an instance of it. diff --git a/src/pydvl/utils/parallel/backends/__init__.py b/src/pydvl/utils/parallel/backends/__init__.py new file mode 100644 index 000000000..187c3202a --- /dev/null +++ b/src/pydvl/utils/parallel/backends/__init__.py @@ -0,0 +1,9 @@ +try: + from .joblib import * +except ImportError: + pass + +try: + from .ray import * +except ImportError: + pass diff --git a/src/pydvl/utils/parallel/backends/joblib.py b/src/pydvl/utils/parallel/backends/joblib.py new file mode 100644 index 000000000..2976db2fc --- /dev/null +++ b/src/pydvl/utils/parallel/backends/joblib.py @@ -0,0 +1,67 @@ +from __future__ import annotations + +from concurrent.futures import Executor +from typing import Callable, cast + +import joblib +from joblib import delayed +from joblib.externals.loky import get_reusable_executor + +from pydvl.utils import ParallelConfig +from pydvl.utils.parallel.backend import BaseParallelBackend, CancellationPolicy, T, log + + +class JoblibParallelBackend(BaseParallelBackend, backend_name="joblib"): + """Class used to wrap joblib to make it transparent to algorithms. + + It shouldn't be initialized directly. You should instead call + :func:`~pydvl.utils.parallel.backend.init_parallel_backend`. + + :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with + cluster address, number of cpus, etc. + """ + + def __init__(self, config: ParallelConfig): + self.config = { + "logging_level": config.logging_level, + "n_jobs": config.n_cpus_local, + } + + @classmethod + def executor( + cls, + max_workers: int | None = None, + config: ParallelConfig = ParallelConfig(), + cancel_futures: CancellationPolicy = CancellationPolicy.NONE, + ) -> Executor: + if cancel_futures not in (CancellationPolicy.NONE, False): + log.warning( + "Cancellation of futures is not supported by the joblib backend" + ) + return cast(Executor, get_reusable_executor(max_workers=max_workers)) + + def get(self, v: T, *args, **kwargs) -> T: + return v + + def put(self, v: T, *args, **kwargs) -> T: + return v + + def wrap(self, fun: Callable, **kwargs) -> Callable: + """Wraps a function as a joblib delayed. + + :param fun: the function to wrap + + :return: The delayed function. + """ + return delayed(fun) # type: ignore + + def wait(self, v: list[T], *args, **kwargs) -> tuple[list[T], list[T]]: + return v, [] + + def _effective_n_jobs(self, n_jobs: int) -> int: + if self.config["n_jobs"] is None: + maximum_n_jobs = joblib.effective_n_jobs() + else: + maximum_n_jobs = self.config["n_jobs"] + eff_n_jobs: int = min(joblib.effective_n_jobs(n_jobs), maximum_n_jobs) + return eff_n_jobs diff --git a/src/pydvl/utils/parallel/backends/ray.py b/src/pydvl/utils/parallel/backends/ray.py new file mode 100644 index 000000000..09f7f8b0f --- /dev/null +++ b/src/pydvl/utils/parallel/backends/ray.py @@ -0,0 +1,84 @@ +from __future__ import annotations + +from concurrent.futures import Executor +from typing import Any, Callable, Iterable + +import ray +from ray import ObjectRef +from ray.util.joblib import register_ray + +from pydvl.utils import ParallelConfig +from pydvl.utils.parallel.backend import BaseParallelBackend, CancellationPolicy, T + + +class RayParallelBackend(BaseParallelBackend, backend_name="ray"): + """Class used to wrap ray to make it transparent to algorithms. + + It shouldn't be initialized directly. You should instead call + :func:`~pydvl.utils.parallel.backend.init_parallel_backend`. + + :param config: instance of :class:`~pydvl.utils.config.ParallelConfig` with + cluster address, number of cpus, etc. + """ + + def __init__(self, config: ParallelConfig): + self.config = {"address": config.address, "logging_level": config.logging_level} + if self.config["address"] is None: + self.config["num_cpus"] = config.n_cpus_local + if not ray.is_initialized(): + ray.init(**self.config) + # Register ray joblib backend + register_ray() + + @classmethod + def executor( + cls, + max_workers: int | None = None, + config: ParallelConfig = ParallelConfig(), + cancel_futures: CancellationPolicy = CancellationPolicy.PENDING, + ) -> Executor: + from pydvl.utils.parallel.futures.ray import RayExecutor + + return RayExecutor(max_workers, config=config, cancel_futures=cancel_futures) # type: ignore + + def get(self, v: ObjectRef | Iterable[ObjectRef] | T, *args, **kwargs) -> T | Any: + timeout: float | None = kwargs.get("timeout", None) + if isinstance(v, ObjectRef): + return ray.get(v, timeout=timeout) + elif isinstance(v, Iterable): + return [self.get(x, timeout=timeout) for x in v] + else: + return v + + def put(self, v: T, *args, **kwargs) -> ObjectRef[T] | T: + try: + return ray.put(v, **kwargs) # type: ignore + except TypeError: + return v # type: ignore + + def wrap(self, fun: Callable, **kwargs) -> Callable: + """Wraps a function as a ray remote. + + :param fun: the function to wrap + :param kwargs: keyword arguments to pass to @ray.remote + + :return: The `.remote` method of the ray `RemoteFunction`. + """ + if len(kwargs) > 0: + return ray.remote(**kwargs)(fun).remote # type: ignore + return ray.remote(fun).remote # type: ignore + + def wait( + self, v: list[ObjectRef], *args, **kwargs + ) -> tuple[list[ObjectRef], list[ObjectRef]]: + num_returns: int = kwargs.get("num_returns", 1) + timeout: float | None = kwargs.get("timeout", None) + return ray.wait(v, num_returns=num_returns, timeout=timeout) # type: ignore + + def _effective_n_jobs(self, n_jobs: int) -> int: + ray_cpus = int(ray._private.state.cluster_resources()["CPU"]) # type: ignore + if n_jobs < 0: + eff_n_jobs = ray_cpus + else: + eff_n_jobs = min(n_jobs, ray_cpus) + return eff_n_jobs diff --git a/src/pydvl/utils/parallel/futures/__init__.py b/src/pydvl/utils/parallel/futures/__init__.py index d9ce59439..02b370642 100644 --- a/src/pydvl/utils/parallel/futures/__init__.py +++ b/src/pydvl/utils/parallel/futures/__init__.py @@ -5,7 +5,11 @@ from pydvl.utils.config import ParallelConfig from pydvl.utils.parallel.backend import BaseParallelBackend -from pydvl.utils.parallel.futures.ray import RayExecutor + +try: + from pydvl.utils.parallel.futures.ray import RayExecutor +except ImportError: + pass __all__ = ["init_executor"] diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index cc5234201..a17693e6e 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -15,7 +15,7 @@ __all__ = ["RayExecutor"] -from pydvl.utils.parallel.backend import CancellationPolicy +from pydvl.utils.parallel import CancellationPolicy T = TypeVar("T") diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index b2e757068..ce6758e57 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -48,8 +48,7 @@ from pydvl.utils import effective_n_jobs, init_executor, init_parallel_backend from pydvl.utils.config import ParallelConfig from pydvl.utils.numeric import random_powerset -from pydvl.utils.parallel import MapReduceJob -from pydvl.utils.parallel.futures.ray import CancellationPolicy +from pydvl.utils.parallel import CancellationPolicy, MapReduceJob from pydvl.utils.utility import Utility from pydvl.value.result import ValuationResult from pydvl.value.shapley.truncated import NoTruncation, TruncationPolicy diff --git a/tests/conftest.py b/tests/conftest.py index 70f42586e..9d82da504 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -6,7 +6,6 @@ import numpy as np import pytest -import ray from pymemcache.client import Client from sklearn import datasets from sklearn.utils import Bunch @@ -21,12 +20,6 @@ EXCEPTIONS_TYPE = Optional[Sequence[Type[BaseException]]] -@pytest.fixture(scope="session", autouse=True) -def ray_shutdown(): - yield - ray.shutdown() - - def is_memcache_responsive(hostname, port): try: client = Client(server=(hostname, port)) diff --git a/tests/utils/conftest.py b/tests/utils/conftest.py index f64330777..923d391fb 100644 --- a/tests/utils/conftest.py +++ b/tests/utils/conftest.py @@ -1,6 +1,4 @@ import pytest -import ray -from ray.cluster_utils import Cluster from pydvl.utils.config import ParallelConfig @@ -10,9 +8,18 @@ def parallel_config(request, num_workers): if request.param == "joblib": yield ParallelConfig(backend="joblib", n_cpus_local=num_workers) elif request.param == "ray-local": + try: + import ray + except ImportError: + pytest.skip("Ray not installed.") yield ParallelConfig(backend="ray", n_cpus_local=num_workers) ray.shutdown() elif request.param == "ray-external": + try: + import ray + from ray.cluster_utils import Cluster + except ImportError: + pytest.skip("Ray not installed.") # Starts a head-node for the cluster. cluster = Cluster( initialize_head=True, diff --git a/tests/utils/test_parallel.py b/tests/utils/test_parallel.py index 3efde364b..e3b3fa0fc 100644 --- a/tests/utils/test_parallel.py +++ b/tests/utils/test_parallel.py @@ -206,7 +206,7 @@ def test_future_cancellation(parallel_config): if parallel_config.backend != "ray": pytest.skip("Currently this test only works with Ray") - from pydvl.utils.parallel.futures.ray import CancellationPolicy + from pydvl.utils.parallel import CancellationPolicy with init_executor( config=parallel_config, cancel_futures=CancellationPolicy.NONE From 4911322def7d676db5c5191e1578b7e5f7d35826 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 26 Aug 2023 19:26:29 +0200 Subject: [PATCH 338/436] [skip ci] Update CHANGELOG.md --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 933be55a9..f579a850f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,8 @@ ## Unreleased +- Made ray an optional dependency, relying on joblib as default parallel backend + [PR #408](https://github.com/appliedAI-Initiative/pyDVL/pull/408) - Fixes to parallel computation of generic semi-values: properly handle all samplers and stopping criteria, irrespective of parallel backend [PR #372](https://github.com/appliedAI-Initiative/pyDVL/pull/372) From 27bc638623d1f1145b4859c07aebf01aa1108aa2 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 27 Aug 2023 11:30:00 +0200 Subject: [PATCH 339/436] Fix imports after refactor --- src/pydvl/utils/parallel/backend.py | 2 -- src/pydvl/utils/parallel/backends/joblib.py | 8 ++++++-- src/pydvl/utils/parallel/backends/ray.py | 9 +++++++-- 3 files changed, 13 insertions(+), 6 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index e1550afdf..297552262 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -19,8 +19,6 @@ ] -T = TypeVar("T") - log = logging.getLogger(__name__) diff --git a/src/pydvl/utils/parallel/backends/joblib.py b/src/pydvl/utils/parallel/backends/joblib.py index 2976db2fc..51ebe8c4e 100644 --- a/src/pydvl/utils/parallel/backends/joblib.py +++ b/src/pydvl/utils/parallel/backends/joblib.py @@ -1,14 +1,18 @@ from __future__ import annotations from concurrent.futures import Executor -from typing import Callable, cast +from typing import Callable, TypeVar, cast import joblib from joblib import delayed from joblib.externals.loky import get_reusable_executor from pydvl.utils import ParallelConfig -from pydvl.utils.parallel.backend import BaseParallelBackend, CancellationPolicy, T, log +from pydvl.utils.parallel.backend import BaseParallelBackend, CancellationPolicy, log + +__all__ = ["JoblibParallelBackend"] + +T = TypeVar("T") class JoblibParallelBackend(BaseParallelBackend, backend_name="joblib"): diff --git a/src/pydvl/utils/parallel/backends/ray.py b/src/pydvl/utils/parallel/backends/ray.py index 09f7f8b0f..6bcb47357 100644 --- a/src/pydvl/utils/parallel/backends/ray.py +++ b/src/pydvl/utils/parallel/backends/ray.py @@ -1,14 +1,19 @@ from __future__ import annotations from concurrent.futures import Executor -from typing import Any, Callable, Iterable +from typing import Any, Callable, Iterable, TypeVar import ray from ray import ObjectRef from ray.util.joblib import register_ray from pydvl.utils import ParallelConfig -from pydvl.utils.parallel.backend import BaseParallelBackend, CancellationPolicy, T +from pydvl.utils.parallel.backend import BaseParallelBackend, CancellationPolicy + +__all__ = ["RayParallelBackend"] + + +T = TypeVar("T") class RayParallelBackend(BaseParallelBackend, backend_name="ray"): From a9ba4080fe7079539725f1b89859bcf94c3d7729 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 27 Aug 2023 19:11:22 +0200 Subject: [PATCH 340/436] Rename and fix --- README.md | 4 ++-- docs/getting-started/{getting-started.md => first-steps.md} | 5 +++-- docs/getting-started/installation.md | 2 +- 3 files changed, 6 insertions(+), 5 deletions(-) rename docs/getting-started/{getting-started.md => first-steps.md} (94%) diff --git a/README.md b/README.md index c2460147d..13aa6003a 100644 --- a/README.md +++ b/README.md @@ -193,8 +193,8 @@ You can run it either locally or, using docker container run --rm -p 11211:11211 --name pydvl-cache -d memcached:latest ``` -You can read more in the [caching module's -documentation](https://appliedAI-Initiative.github.io/pyDVL/pydvl/utils/caching.html). +You can read more in the +[documentation](https://appliedAI-Initiative.github.io/pyDVL/getting-started/first-steps/#caching). # Contributing diff --git a/docs/getting-started/getting-started.md b/docs/getting-started/first-steps.md similarity index 94% rename from docs/getting-started/getting-started.md rename to docs/getting-started/first-steps.md index 67e2cd5f1..a86cf6307 100644 --- a/docs/getting-started/getting-started.md +++ b/docs/getting-started/first-steps.md @@ -45,11 +45,12 @@ keep in mind when using pyDVL. ## Caching pyDVL uses [memcached](https://memcached.org/) to cache the computation of the -utility function and speed up some computations. +utility function and speed up some computations (see the [installation +guide](installation.md/#setting-up-the-cache)). Caching of the utility function is disabled by default. When it is enabled it takes into account the data indices passed as argument and the utility function -wrapped into the [Utility][pydvl.value.utility.Utility] object. This means that +wrapped into the [Utility][pydvl.utils.utility.Utility] object. This means that care must be taken when reusing the same utility function with different data, see the documentation for the [caching module][pydvl.utils.caching] for more information. diff --git a/docs/getting-started/installation.md b/docs/getting-started/installation.md index 2fff75bbb..ea6ef4f02 100644 --- a/docs/getting-started/installation.md +++ b/docs/getting-started/installation.md @@ -81,5 +81,5 @@ docker container run -d --rm -p 11211:11211 memcached:latest ``` !!! tip "Using the cache" - Continue reading about the cache in the [First Steps](getting-started.md#caching) + Continue reading about the cache in the [First Steps](first-steps.md#caching) and the documentation for the [caching module][pydvl.utils.caching]. From 2bd0d9ed6bf41bc8b7cbb30592dda1b32dab210a Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 27 Aug 2023 19:11:53 +0200 Subject: [PATCH 341/436] Added images to MCLC docs, image plugins and reference to mlrc22 paper --- docs/assets/pydvl.bib | 14 +++++++++++ docs/css/extra.css | 10 +++++++- .../img/mclc-best-removal-10k-natural.svg | 1 + .../img/mclc-worst-removal-10k-natural.svg | 1 + docs/value/the-core.md | 23 +++++++++++++++++++ docs_includes/abbreviations.md | 1 + mkdocs.yml | 21 ++++++++++++++--- requirements-docs.txt | 2 ++ 8 files changed, 69 insertions(+), 4 deletions(-) create mode 100644 docs/value/img/mclc-best-removal-10k-natural.svg create mode 100644 docs/value/img/mclc-worst-removal-10k-natural.svg diff --git a/docs/assets/pydvl.bib b/docs/assets/pydvl.bib index 22da65ba7..0ea2ccfb2 100644 --- a/docs/assets/pydvl.bib +++ b/docs/assets/pydvl.bib @@ -1,3 +1,17 @@ +@article{benmerzoug_re_2023, + title = {[{{Re}}] {{If}} You like {{Shapley}}, Then You'll Love the Core}, + author = {Benmerzoug, Anes and Delgado, Miguel de Benito}, + date = {2023-07-31}, + journaltitle = {ReScience C}, + volume = {9}, + number = {2}, + pages = {\#32}, + doi = {10.5281/zenodo.8173733}, + url = {https://zenodo.org/record/8173733}, + urldate = {2023-08-27}, + abstract = {Replication} +} + @article{castro_polynomial_2009, title = {Polynomial Calculation of the {{Shapley}} Value Based on Sampling}, author = {Castro, Javier and Gómez, Daniel and Tejada, Juan}, diff --git a/docs/css/extra.css b/docs/css/extra.css index 093a06280..1cafcbe11 100644 --- a/docs/css/extra.css +++ b/docs/css/extra.css @@ -100,4 +100,12 @@ a.autorefs-external:hover::after { background: var(--md-warning-bg-color); border: 0.1rem solid var(--md-primary-fg-color); color: black; -} \ No newline at end of file +} + + +body[data-md-color-scheme="default"] .invertible img { +} + +body[data-md-color-scheme="slate"] .invertible img { + filter: invert(100%) hue-rotate(180deg); +} diff --git a/docs/value/img/mclc-best-removal-10k-natural.svg b/docs/value/img/mclc-best-removal-10k-natural.svg new file mode 100644 index 000000000..360e932f9 --- /dev/null +++ b/docs/value/img/mclc-best-removal-10k-natural.svg @@ -0,0 +1 @@ +0.000.050.100.150.200.250.300.35Percentage Removal0.9700.9750.9800.9850.9900.995AccuracyTMC ShapleyGroup Testing ShapleyLeast CoreLeave One OutRandom \ No newline at end of file diff --git a/docs/value/img/mclc-worst-removal-10k-natural.svg b/docs/value/img/mclc-worst-removal-10k-natural.svg new file mode 100644 index 000000000..da04f1caa --- /dev/null +++ b/docs/value/img/mclc-worst-removal-10k-natural.svg @@ -0,0 +1 @@ +0.000.050.100.150.200.250.300.35Percentage Removal0.9900.9920.9940.9960.998AccuracyTMC ShapleyGroup Testing ShapleyLeast CoreLeave One OutRandom \ No newline at end of file diff --git a/docs/value/the-core.md b/docs/value/the-core.md index 382881ed0..9c4e4bb3b 100644 --- a/docs/value/the-core.md +++ b/docs/value/the-core.md @@ -113,3 +113,26 @@ problems = [mclc_prepare_problem(utility, n_iterations=n_iterations) for _ in range(n_experiments)] values = lc_solve_problems(problems) ``` + +## Method comparison + +The TransferLab team reproduced the results of the original paper in a +publication for the 2022 MLRC [@benmerzoug_re_2023]. + +![Best sample removal on binary image +classification](img/mclc-best-removal-10k-natural.svg){ align=left width=50% class=invertible} + +Roughly speaking, MCLC performs better in identifying **high value** points, as +measured by best-sample removal tasks. In all other aspects, it performs worse +or similarly to TMCS at comparable sample budgets. But using an equal number of +subsets is more computationally expensive because of the need to solve large +linear and quadratic optimization problems. + + +![Worst sample removal on binary image +classification](img/mclc-worst-removal-10k-natural.svg){ align=right width=50% class=invertible} + +For these reasons we recommend some variation of SV like TMCS for outlier +detection, data cleaning and pruning, and perhaps MCLC for the selection of +interesting points to be inspected for the improvement of data collection or +model design. diff --git a/docs_includes/abbreviations.md b/docs_includes/abbreviations.md index 64b0b4528..cc2990534 100644 --- a/docs_includes/abbreviations.md +++ b/docs_includes/abbreviations.md @@ -5,6 +5,7 @@ *[MCLC]: Monte Carlo Least Core *[MCS]: Monte Carlo Shapley *[ML]: Machine Learning +*[MLRC]: Machine Learning Reproducibility Challenge *[MSE]: Mean Squared Error *[SV]: Shapley Value *[TMCS]: Truncated Monte Carlo Shapley diff --git a/mkdocs.yml b/mkdocs.yml index c630b7ffb..e038feb72 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -13,10 +13,23 @@ hooks: - build_scripts/copy_changelog.py plugins: - - mike - autorefs - - search + - glightbox: + touchNavigation: true + loop: false + effect: zoom + slide_effect: slide + width: 100% + height: auto + zoomable: true + draggable: true + skip_classes: + - custom-skip-class-name + auto_caption: true + caption_position: bottom - macros + - mike + - search - section-index - alias: use_relative_link: true @@ -135,6 +148,8 @@ markdown_extensions: - admonition - attr_list - footnotes + - markdown_captions + - md_in_html - neoteroi.cards - toc: permalink: True @@ -161,7 +176,7 @@ nav: - Home: index.md - Getting Started: - Installation: getting-started/installation.md - - First steps: getting-started/getting-started.md + - First steps: getting-started/first-steps.md - Data Valuation: - Introduction: value/index.md - Notation: value/notation.md diff --git a/requirements-docs.txt b/requirements-docs.txt index e04c3064c..4a2484a1e 100644 --- a/requirements-docs.txt +++ b/requirements-docs.txt @@ -1,4 +1,5 @@ mike +markdown-captions mkdocs==1.5.2 mkdocstrings[python]>=0.18 mkdocs-alias-plugin>=0.6.0 @@ -6,6 +7,7 @@ mkdocs-autorefs mkdocs-bibtex mkdocs-gen-files mkdocs-git-revision-date-localized-plugin +mkdocs-glightbox mkdocs-jupyter mkdocs-literate-nav mkdocs-material From ff2ba69d7d63715943a392359e5d7c69d9d404fd Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 27 Aug 2023 19:14:56 +0200 Subject: [PATCH 342/436] Remove leftover imports --- tests/value/conftest.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/tests/value/conftest.py b/tests/value/conftest.py index f60085518..d19256beb 100644 --- a/tests/value/conftest.py +++ b/tests/value/conftest.py @@ -1,8 +1,6 @@ import numpy as np import pytest -import ray from numpy.typing import NDArray -from ray.cluster_utils import Cluster from sklearn.linear_model import LinearRegression from sklearn.pipeline import make_pipeline from sklearn.preprocessing import PolynomialFeatures From 7381454574f522af38f0dc979e11a466a6fe6dd1 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 27 Aug 2023 19:48:20 +0200 Subject: [PATCH 343/436] Cosmetic --- docs/value/shapley.md | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/docs/value/shapley.md b/docs/value/shapley.md index 3051dde5e..77af2ae2b 100644 --- a/docs/value/shapley.md +++ b/docs/value/shapley.md @@ -159,8 +159,8 @@ You can see this method in action in It is possible to exploit the local structure of K-Nearest Neighbours to reduce the amount of subsets to consider: because no sample besides the K closest affects the score, most are irrelevant and it is possible to compute a value in -linear time. This method was introduced by [@jia_efficient_2019a], -and can be used in pyDVL with: +linear time. This method was introduced by [@jia_efficient_2019a], and can be +used in pyDVL with: ```python from pydvl.utils import Dataset, Utility @@ -175,8 +175,8 @@ values = compute_shapley_values(u=utility, mode="knn") ### Group testing -An alternative approach introduced in [@jia_efficient_2019a] -first approximates the differences of values with a Monte Carlo sum. With +An alternative approach introduced in [@jia_efficient_2019a] first approximates +the differences of values with a Monte Carlo sum. With $$\hat{\Delta}_{i j} \approx v_i - v_j,$$ @@ -195,13 +195,14 @@ $$ We have reproduced this method in pyDVL for completeness and benchmarking, but we don't advocate its use because of the speed and memory cost. Despite our best efforts, the number of samples required in practice for convergence - can be several orders of magnitude worse than with e.g. Truncated Monte Carlo. - Additionally, the CSP can sometimes turn out to be infeasible. + can be several orders of magnitude worse than with e.g. TMCS. Additionally, + the CSP can sometimes turn out to be infeasible. Usage follows the same pattern as every other Shapley method, but with the addition of an `epsilon` parameter required for the solution of the CSP. It should be the same value used to compute the minimum number of samples required. -This can be done with [num_samples_eps_delta][pydvl.value.shapley.gt.num_samples_eps_delta], but +This can be done with +[num_samples_eps_delta][pydvl.value.shapley.gt.num_samples_eps_delta], but note that the number returned will be huge! In practice, fewer samples can be enough, but the actual number will strongly depend on the utility, in particular its variance. From f1a3c79bc05ef784e47b19c771e7c40e4b57bb1e Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 27 Aug 2023 20:13:17 +0200 Subject: [PATCH 344/436] =?UTF-8?q?Add=20ray=20to=20autodoc=5Fmock=5Fimpor?= =?UTF-8?q?ts.=20Why=20does=20this=20work=20without=20torch=20there=20too?= =?UTF-8?q?=3F!=3F=20=F0=9F=A5=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/conf.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/conf.py b/docs/conf.py index b9e13dd9c..2c380c809 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -177,7 +177,7 @@ def lineno_from_object_name(source_file, object_name): # this is useful for keeping the docs build environment small. Add heavy requirements here # and all other requirements to docs/requirements.txt -autodoc_mock_imports = [] +autodoc_mock_imports = ["ray"] autodoc_default_options = { "exclude-members": "log", From 0b382b68d12c5cce8469e3c66a59d65de570a9da Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 27 Aug 2023 21:23:46 +0200 Subject: [PATCH 345/436] Apply suggestion Co-authored-by: Anes Benmerzoug --- docs/index.md | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/index.md b/docs/index.md index 1b207f687..32c6880b6 100644 --- a/docs/index.md +++ b/docs/index.md @@ -20,7 +20,6 @@ If you're a first time user of pyDVL, we recommend you to go through the - title: Data valuation image: ./assets/material-code.svg url: value/ -- - title: Influence Function image: ./assets/material-computer.svg url: influence/ From 3456cfd643718794cbd247189b07c926b4387524 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 27 Aug 2023 21:41:21 +0200 Subject: [PATCH 346/436] Remove doctests (cannot run without ray) --- src/pydvl/utils/parallel/backend.py | 29 +++++++------- src/pydvl/utils/parallel/futures/__init__.py | 40 +++++++++----------- 2 files changed, 34 insertions(+), 35 deletions(-) diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index 297552262..8cd668b3d 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -99,19 +99,22 @@ def init_parallel_backend(config: ParallelConfig) -> BaseParallelBackend: :Example: - >>> from pydvl.utils.parallel.backend import init_parallel_backend - >>> from pydvl.utils.config import ParallelConfig - >>> config = ParallelConfig() - >>> parallel_backend = init_parallel_backend(config) - >>> parallel_backend - - - >>> from pydvl.utils.parallel.backend import init_parallel_backend - >>> from pydvl.utils.config import ParallelConfig - >>> config = ParallelConfig(backend="ray") - >>> parallel_backend = init_parallel_backend(config) - >>> parallel_backend - + ``` python + config = ParallelConfig() + parallel_backend = init_parallel_backend(config) + ``` + + Creates a parallel backend instance with the default configuration, which + is a local joblib backend. + + To create a parallel backend instance with a different backend, e.g. ray, + you can pass the backend name as a string to the constructor of + :class:`~pydvl.utils.config.ParallelConfig`: + + .. code-block:: python + + config = ParallelConfig(backend="ray") + parallel_backend = init_parallel_backend(config) """ try: diff --git a/src/pydvl/utils/parallel/futures/__init__.py b/src/pydvl/utils/parallel/futures/__init__.py index 02b370642..9892ab848 100644 --- a/src/pydvl/utils/parallel/futures/__init__.py +++ b/src/pydvl/utils/parallel/futures/__init__.py @@ -31,28 +31,24 @@ def init_executor( e.g. ``cancel_futures`` for executors that support it, like :class:`~pydvl.utils.parallel.futures.ray.RayExecutor`. - :Example: - - >>> from pydvl.utils.parallel.futures import init_executor - >>> from pydvl.utils.config import ParallelConfig - >>> config = ParallelConfig(backend="ray") - >>> with init_executor(max_workers=3, config=config) as executor: - ... pass - - >>> from pydvl.utils.parallel.futures import init_executor - >>> with init_executor() as executor: - ... future = executor.submit(lambda x: x + 1, 1) - ... result = future.result() - ... - >>> print(result) - 2 - - >>> from pydvl.utils.parallel.futures import init_executor - >>> with init_executor() as executor: - ... results = list(executor.map(lambda x: x + 1, range(5))) - ... - >>> print(results) - [1, 2, 3, 4, 5] + :Examples: + + .. code-block:: python + + from pydvl.utils.parallel.futures import init_executor + from pydvl.utils.config import ParallelConfig + config = ParallelConfig(backend="ray") + with init_executor(max_workers=1, config=config) as executor: + future = executor.submit(lambda x: x + 1, 1) + result = future.result() + assert result == 2 + + .. code-block:: python + + from pydvl.utils.parallel.futures import init_executor + with init_executor() as executor: + results = list(executor.map(lambda x: x + 1, range(5))) + assert results == [1, 2, 3, 4, 5] """ try: From 65e2b6101c87249cedfb5c48ae99a2665bbd0d09 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 27 Aug 2023 21:42:08 +0200 Subject: [PATCH 347/436] Don't pass on missing joblib import --- src/pydvl/utils/parallel/backends/__init__.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/pydvl/utils/parallel/backends/__init__.py b/src/pydvl/utils/parallel/backends/__init__.py index 187c3202a..758d8dab7 100644 --- a/src/pydvl/utils/parallel/backends/__init__.py +++ b/src/pydvl/utils/parallel/backends/__init__.py @@ -1,7 +1,4 @@ -try: - from .joblib import * -except ImportError: - pass +from .joblib import * try: from .ray import * From 418b44ef3a8878dc3c464753bde86516be582aab Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 27 Aug 2023 22:01:30 +0200 Subject: [PATCH 348/436] Fix PMCS: follow the pattern of semivalues, check criterion on aggregated result --- src/pydvl/value/shapley/montecarlo.py | 84 +++++++++++---------------- 1 file changed, 35 insertions(+), 49 deletions(-) diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index b2e757068..c17ca4b80 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -60,14 +60,8 @@ __all__ = ["permutation_montecarlo_shapley", "combinatorial_montecarlo_shapley"] -def _permutation_montecarlo_shapley( - u: Utility, - *, - done: StoppingCriterion, - truncation: TruncationPolicy, - algorithm_name: str = "permutation_montecarlo_shapley", - progress: bool = False, - job_id: int = 1, +def _permutation_montecarlo_one_step( + u: Utility, truncation: TruncationPolicy, algorithm_name: str ) -> ValuationResult: """Helper function for :func:`permutation_montecarlo_shapley`. @@ -76,53 +70,39 @@ def _permutation_montecarlo_shapley( sampled permutations. :param u: Utility object with model, data, and scoring function - :param done: Check on the results which decides when to stop :param truncation: A callable which decides whether to interrupt processing a permutation and set all subsequent marginals to zero. :param algorithm_name: For the results object. Used internally by different variants of Shapley using this subroutine - :param progress: Whether to display progress bars for each job. - :param job_id: id to use for reporting progress (e.g. to place progres bars) + :return: An object with the results """ + result = ValuationResult.zeros( algorithm=algorithm_name, indices=u.data.indices, data_names=u.data.data_names ) - pbar = tqdm(disable=not progress, position=job_id, total=100, unit="%") - while not done(result): - pbar.n = 100 * done.completion() - pbar.refresh() - prev_score = 0.0 - permutation = np.random.permutation(u.data.indices) - permutation_done = False - truncation.reset() - for i, idx in enumerate(permutation): - if permutation_done: - score = prev_score - else: - score = u(permutation[: i + 1]) - marginal = score - prev_score - result.update(idx, marginal) - prev_score = score - if not permutation_done and truncation(i, score): - permutation_done = True - return result - - -def _permutation_montecarlo_one_step( - u: Utility, truncation: TruncationPolicy, algorithm: str -) -> ValuationResult: - result = _permutation_montecarlo_shapley( - u, done=MaxChecks(1), truncation=truncation, algorithm_name=algorithm - ) + prev_score = 0.0 + permutation = np.random.permutation(u.data.indices) + permutation_done = False + truncation.reset() + for i, idx in enumerate(permutation): + if permutation_done: + score = prev_score + else: + score = u(permutation[: i + 1]) + marginal = score - prev_score + result.update(idx, marginal) + prev_score = score + if not permutation_done and truncation(i, score): + permutation_done = True nans = np.isnan(result.values).sum() if nans > 0: logger.warning( f"{nans} NaN values in current permutation, ignoring. " "Consider setting a default value for the Scorer" ) - result = ValuationResult.empty(algorithm="truncated_montecarlo_shapley") + result = ValuationResult.empty(algorithm=algorithm_name) return result @@ -141,6 +121,7 @@ def permutation_montecarlo_shapley( truncation: TruncationPolicy = NoTruncation(), n_jobs: int = 1, config: ParallelConfig = ParallelConfig(), + progress: bool = False, ) -> ValuationResult: r"""Computes an approximate Shapley value by sampling independent permutations of the index set, approximating the sum: @@ -191,30 +172,35 @@ def permutation_montecarlo_shapley( max_workers = effective_n_jobs(n_jobs, config) n_submitted_jobs = 2 * max_workers # number of jobs in the executor's queue - accumulated_result = ValuationResult.zeros(algorithm=algorithm) + result = ValuationResult.zeros(algorithm=algorithm) + + pbar = tqdm(disable=not progress, total=100, unit="%") with init_executor( max_workers=max_workers, config=config, cancel_futures=CancellationPolicy.ALL ) as executor: - futures: set[Future] = set() + pending: set[Future] = set() while True: - completed_futures, futures = wait( - futures, timeout=config.wait_timeout, return_when=FIRST_COMPLETED + pbar.n = 100 * done.completion() + pbar.refresh() + + completed, pending = wait( + pending, timeout=config.wait_timeout, return_when=FIRST_COMPLETED ) - for future in completed_futures: - accumulated_result += future.result() + for future in completed: + result += future.result() # we could check outside the loop, but that means more # submissions if the stopping criterion is unstable - if done(accumulated_result): - return accumulated_result + if done(result): + return result # Ensure that we always have n_submitted_jobs in the queue or running - for _ in range(n_submitted_jobs - len(futures)): + for _ in range(n_submitted_jobs - len(pending)): future = executor.submit( _permutation_montecarlo_one_step, u, truncation, algorithm ) - futures.add(future) + pending.add(future) def _combinatorial_montecarlo_shapley( From 69ab3e7f1233ccda713bc4215f589a87390ffa43 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 27 Aug 2023 23:26:42 +0200 Subject: [PATCH 349/436] More spontaneous typing errors --- src/pydvl/reporting/plots.py | 2 +- src/pydvl/utils/parallel/backend.py | 4 ++-- src/pydvl/value/stopping.py | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/pydvl/reporting/plots.py b/src/pydvl/reporting/plots.py index 03364d9d8..89c198499 100644 --- a/src/pydvl/reporting/plots.py +++ b/src/pydvl/reporting/plots.py @@ -19,7 +19,7 @@ def shaded_mean_std( xlabel: Optional[str] = None, ylabel: Optional[str] = None, ax: Optional[Axes] = None, - **kwargs: dict, + **kwargs, ) -> Axes: """The usual mean +- std deviation plot to aggregate runs of experiments. diff --git a/src/pydvl/utils/parallel/backend.py b/src/pydvl/utils/parallel/backend.py index 6d74be3ef..71515c61c 100644 --- a/src/pydvl/utils/parallel/backend.py +++ b/src/pydvl/utils/parallel/backend.py @@ -199,7 +199,7 @@ def put(self, v: T, *args, **kwargs) -> ObjectRef[T] | T: except TypeError: return v # type: ignore - def wrap(self, fun: Callable, **kwargs: dict) -> Callable: + def wrap(self, fun: Callable, **kwargs) -> Callable: """Wraps a function as a ray remote. Args: @@ -214,7 +214,7 @@ def wrap(self, fun: Callable, **kwargs: dict) -> Callable: return ray.remote(fun).remote # type: ignore def wait( - self, v: list[ObjectRef], *args, **kwargs: dict + self, v: list[ObjectRef], *args, **kwargs ) -> tuple[list[ObjectRef], list[ObjectRef]]: num_returns: int = kwargs.get("num_returns", 1) timeout: float | None = kwargs.get("timeout", None) diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index ade396fe4..ed2818462 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -219,7 +219,7 @@ def make_criterion( class WrappedCriterion(StoppingCriterion): def __init__(self, modify_result: bool = True): super().__init__(modify_result=modify_result) - self._name = name or fun.__name__ + self._name = name or getattr(fun, "__name__", "WrappedCriterion") def _check(self, result: ValuationResult) -> Status: return fun(result) From f3f39e6f348f6cba44f569cdf8a1f8eb903ad96a Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 27 Aug 2023 23:47:30 +0200 Subject: [PATCH 350/436] Fix name-clashing of function with its module breaking docs build --- docs/value/index.md | 4 ++-- src/pydvl/value/loo/loo.py | 4 ++-- src/pydvl/value/loo/naive.py | 9 ++++++--- tests/value/loo/test_loo.py | 6 +++--- 4 files changed, 13 insertions(+), 10 deletions(-) diff --git a/docs/value/index.md b/docs/value/index.md index fed2633b3..82aa72252 100644 --- a/docs/value/index.md +++ b/docs/value/index.md @@ -273,9 +273,9 @@ indicative of low value or not depends on each one's goals and definitions, but other methods are typically preferable. ```python -from pydvl.value.loo.naive import naive_loo +from pydvl.value.loo import compute_loo -values = naive_loo(utility) +values = compute_loo(utility, n_jobs=-1) ``` The return value of all valuation functions is an object of type diff --git a/src/pydvl/value/loo/loo.py b/src/pydvl/value/loo/loo.py index 0d4077957..0ef951a89 100644 --- a/src/pydvl/value/loo/loo.py +++ b/src/pydvl/value/loo/loo.py @@ -7,10 +7,10 @@ from pydvl.utils import ParallelConfig, Utility, effective_n_jobs, init_executor from pydvl.value.result import ValuationResult -__all__ = ["loo"] +__all__ = ["compute_loo"] -def loo( +def compute_loo( u: Utility, *, n_jobs: int = 1, diff --git a/src/pydvl/value/loo/naive.py b/src/pydvl/value/loo/naive.py index c5242f1e9..56e58cdbc 100644 --- a/src/pydvl/value/loo/naive.py +++ b/src/pydvl/value/loo/naive.py @@ -3,14 +3,17 @@ from pydvl.utils import Utility from pydvl.value.result import ValuationResult -from .loo import loo +from .loo import compute_loo __all__ = ["naive_loo"] @deprecated( - target=loo, deprecated_in="0.7.0", remove_in="0.8.0", args_extra=dict(n_jobs=1) + target=compute_loo, + deprecated_in="0.7.0", + remove_in="0.8.0", + args_extra=dict(n_jobs=1), ) def naive_loo(u: Utility, *, progress: bool = True, **kwargs) -> ValuationResult: - """Deprecated. Use :func:`~pydvl.value.loo.loo` instead.""" + """Deprecated. Use [compute_loo][pydvl.value.loo.compute_loo] instead.""" pass diff --git a/tests/value/loo/test_loo.py b/tests/value/loo/test_loo.py index e254ade3f..04922a7a0 100644 --- a/tests/value/loo/test_loo.py +++ b/tests/value/loo/test_loo.py @@ -1,14 +1,14 @@ import pytest -from pydvl.value.loo import loo +from pydvl.value.loo import compute_loo from .. import check_total_value, check_values @pytest.mark.parametrize("num_samples", [10, 100]) def test_loo(num_samples: int, n_jobs: int, parallel_config, analytic_loo): - """Compares the naive loo with analytic values in a dummy model""" + """Compares LOO with analytic values in a dummy model""" u, exact_values = analytic_loo - values = loo(u, n_jobs=n_jobs, config=parallel_config, progress=False) + values = compute_loo(u, n_jobs=n_jobs, config=parallel_config, progress=False) check_total_value(u, values, rtol=0.1) check_values(values, exact_values, rtol=0.1) From 7d5d7a7e62443c41517100b4008b6031110a3aaf Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Mon, 28 Aug 2023 10:35:11 +0200 Subject: [PATCH 351/436] Fix docs for Status --- src/pydvl/utils/status.py | 39 +++++++++++++++++---------------------- 1 file changed, 17 insertions(+), 22 deletions(-) diff --git a/src/pydvl/utils/status.py b/src/pydvl/utils/status.py index c369e0bec..7e109111d 100644 --- a/src/pydvl/utils/status.py +++ b/src/pydvl/utils/status.py @@ -10,60 +10,55 @@ class Status(Enum): combined status is `Status.Converged | Status.Failed == Status.Converged`, but `Status.Converged & Status.Failed == Status.Failed`. - - :OR: + ## OR The result of bitwise or-ing two valuation statuses with `|` is given by the following table: - +---+---+---+---+ | | P | C | F | - +===+===+===+===+ + |---|---|---|---| | P | P | C | P | - +---+---+---+---+ | C | C | C | C | - +---+---+---+---+ | F | P | C | F | - +---+---+---+---+ where P = Pending, C = Converged, F = Failed. - :AND: + ## AND The result of bitwise and-ing two valuation statuses with `&` is given by the following table: - +---+---+---+---+ | | P | C | F | - +===+===+===+===+ + |---|---|---|---| | P | P | P | F | - +---+---+---+---+ | C | P | C | F | - +---+---+---+---+ | F | F | F | F | - +---+---+---+---+ where P = Pending, C = Converged, F = Failed. - :NOT: + ## NOT The result of bitwise negation of a Status with `~` is `Failed` if the status is `Converged`, or `Converged` otherwise: - ~P == C, ~C == F, ~F == C + ``` + ~P == C, ~C == F, ~F == C + ``` - :Boolean casting: + ## Boolean casting A Status evaluates to `True` iff it's `Converged` or `Failed`: - bool(Status.Pending) == False - bool(Status.Converged) == True - bool(Status.Failed) == True + ```python + bool(Status.Pending) == False + bool(Status.Converged) == True + bool(Status.Failed) == True + ``` !!! Warning - These truth values are **inconsistent** with the usual boolean operations. - In particular the XOR of two instances of `Status` is not the same as - the XOR of their boolean values. + These truth values are **inconsistent** with the usual boolean + operations. In particular the XOR of two instances of `Status` is not + the same as the XOR of their boolean values. """ Pending = "pending" From 34b9830eeb2f570e604cd8aa56c8da5665611ad0 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Mon, 28 Aug 2023 10:35:50 +0200 Subject: [PATCH 352/436] Explicit cast for mypy's benefit --- src/pydvl/value/stopping.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index ed2818462..4e2ec98dc 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -136,7 +136,7 @@ def completion(self) -> float: """ if self.converged.size == 0: return 0.0 - return np.mean(self.converged).item() + return float(np.mean(self.converged).item()) @property def converged(self) -> NDArray[np.bool_]: From 501e5a6fc32c448dfc63d2cecb77a8c7b5d8f87a Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Mon, 28 Aug 2023 10:55:19 +0200 Subject: [PATCH 353/436] Some docs for the parallel module --- src/pydvl/utils/parallel/__init__.py | 34 ++++++++++++++++++++++++++ src/pydvl/utils/parallel/map_reduce.py | 8 ++++++ 2 files changed, 42 insertions(+) diff --git a/src/pydvl/utils/parallel/__init__.py b/src/pydvl/utils/parallel/__init__.py index fa08cfb38..eeb56fcde 100644 --- a/src/pydvl/utils/parallel/__init__.py +++ b/src/pydvl/utils/parallel/__init__.py @@ -1,3 +1,37 @@ +""" +This module provides a common interface to parallelization backends. The list of +supported backends is [here][pydvl.utils.parallel.backends]. + +We use [executors][concurrent.futures.Executor] to submit tasks in parallel. The +basic high-level pattern is + +```python +from pydvl.utils.parallel import init_executo +from pydvl.utils.config import ParallelConfig + +config = ParallelConfig(backend="ray") +with init_executor(max_workers=1, config=config) as executor: + future = executor.submit(lambda x: x + 1, 1) + result = future.result() +assert result == 2 +``` + +Running a map-reduce job is also easy: + +```python +from pydvl.utils.parallel import init_executor +from pydvl.utils.config import ParallelConfig + +config = ParallelConfig(backend="joblib") +with init_executor() as executor: + results = list(executor.map(lambda x: x + 1, range(5))) +assert results == [1, 2, 3, 4, 5] +``` + +There is an alternative map-reduce implementation +[MapReduceJob][pydvl.utils.parallel.map_reduce.MapReduceJob] which internally +uses joblib's higher level API with `Parallel()` +""" from .backend import * from .backends import * from .futures import * diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index fc917f7c3..f7dec6179 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -1,3 +1,11 @@ +""" +This module contains a wrapper around joblib's `Parallel()` class that makes it +easy to run map-reduce jobs. + +!!! Deprecation notice + This interface might be deprecated or changed in a future release before 1.0 + +""" from itertools import accumulate, repeat from typing import Any, Collection, Dict, Generic, List, Optional, TypeVar, Union From 0d760bf9e0015eda3b1c56619d872b8f33d9b6ff Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 30 Aug 2023 17:05:37 +0200 Subject: [PATCH 354/436] Use mknotebooks instead of mkdocs-jupyter --- build_scripts/modify_binder_link.py | 57 +++++++++++++++++++++++++++++ docs/css/extra.css | 15 ++++++++ mkdocs.yml | 13 +++++-- requirements-docs.txt | 4 +- 4 files changed, 85 insertions(+), 4 deletions(-) create mode 100644 build_scripts/modify_binder_link.py diff --git a/build_scripts/modify_binder_link.py b/build_scripts/modify_binder_link.py new file mode 100644 index 000000000..ebb446763 --- /dev/null +++ b/build_scripts/modify_binder_link.py @@ -0,0 +1,57 @@ +""" +This mkdocs hook replaces the binder link in the rendered notebooks +with links to the actual notebooks in the repository. +This is needed because for the docs we create symlinks to the notebooks +inside the docs directory. +""" + +import logging +import os +import re +from pathlib import Path +from typing import TYPE_CHECKING, Literal, Optional + +from git import Repo +from mkdocs.plugins import Config, event_priority + +if TYPE_CHECKING: + from mkdocs.plugins import Files, Page + +logger = logging.getLogger("mkdocs") + +BINDER_BASE_URL = "https://mybinder.org/v2" +BINDER_URL_PATTERN = re.compile(r"\(" + re.escape(BINDER_BASE_URL) + r".*\)") + +branch_name: Optional[str] = None + + +@event_priority(-50) +def on_startup(command: Literal["build", "gh-deploy", "serve"], dirty: bool) -> None: + global branch_name + try: + branch_name = Repo().active_branch.name + logger.info(f"Found branch name using git: {branch_name}") + except TypeError: + branch_name = os.getenv("GITHUB_REF", "develop").split("/")[-1] + logger.info(f"Found branch name from environment variable: {branch_name}") + + +@event_priority(-50) +def on_page_markdown( + markdown: str, page: "Page", config: Config, files: "Files" +) -> Optional[str]: + if "examples" not in page.url: + return + logger.info( + f"Replacing binder link with link to notebook in repository for notebooks in {page.url}" + ) + repo_name = config["repo_name"] + root_dir = Path(config["docs_dir"]).parent + notebooks_dir = root_dir / "notebooks" + notebook_filename = Path(page.file.src_path).name + file_path = (notebooks_dir / notebook_filename).relative_to(root_dir) + url_path = f"%2Ftree%2F{file_path}" + binder_url = f"({BINDER_BASE_URL}/gh/{repo_name}/{branch_name}?urlpath={url_path})" + logger.debug(f"New binder url: {binder_url}") + markdown = re.sub(BINDER_URL_PATTERN, binder_url, markdown) + return markdown diff --git a/docs/css/extra.css b/docs/css/extra.css index 1cafcbe11..2ac25647f 100644 --- a/docs/css/extra.css +++ b/docs/css/extra.css @@ -109,3 +109,18 @@ body[data-md-color-scheme="default"] .invertible img { body[data-md-color-scheme="slate"] .invertible img { filter: invert(100%) hue-rotate(180deg); } + +/* Rendered dataframe from jupyter */ +div.rendered_html { + width: 100% !important; + overflow-x: scroll; +} + +table.dataframe { + display: block; + max-width: -moz-fit-content; + max-width: fit-content; + margin: 0 auto; + overflow-x: auto; + white-space: nowrap; +} diff --git a/mkdocs.yml b/mkdocs.yml index e038feb72..52b789a12 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -1,6 +1,7 @@ site_name: "pyDVL" site_dir: "docs_build" site_url: "https://appliedai-initiative.github.io/pyDVL/" +repo_name: "appliedAI-Initiative/pyDVL" repo_url: "https://github.com/appliedAI-Initiative/pyDVL" copyright: "Copyright © AppliedAI Institute gGmbH" @@ -11,6 +12,7 @@ watch: hooks: - build_scripts/copy_notebooks.py - build_scripts/copy_changelog.py + - build_scripts/modify_binder_link.py plugins: - autorefs @@ -41,13 +43,17 @@ plugins: nav_file: SUMMARY.md implicit_index: false tab_length: 2 - - mkdocs-jupyter: - include: ["docs/examples/*.ipynb"] - remove_tag_config: + - mknotebooks: + execute: false + enable_default_jupyter_cell_styling: false + tag_remove_configs: remove_cell_tags: - hide remove_input_tags: - hide-input + binder: true + binder_service_name: "gh" + binder_branch: "develop" - mkdocstrings: enable_inventory: true handlers: @@ -151,6 +157,7 @@ markdown_extensions: - markdown_captions - md_in_html - neoteroi.cards + - codehilite - toc: permalink: True toc_depth: 3 diff --git a/requirements-docs.txt b/requirements-docs.txt index 4a2484a1e..a8d52f124 100644 --- a/requirements-docs.txt +++ b/requirements-docs.txt @@ -8,10 +8,12 @@ mkdocs-bibtex mkdocs-gen-files mkdocs-git-revision-date-localized-plugin mkdocs-glightbox -mkdocs-jupyter +mknotebooks>=0.8.0 +pygments mkdocs-literate-nav mkdocs-material mkdocs-section-index mkdocs-macros-plugin neoteroi-mkdocs # Needed for card grid on home page pypandoc_binary +GitPython From 1e3f1dfb381f11a13b3ac3e815c5e72768181406 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 30 Aug 2023 18:34:14 +0200 Subject: [PATCH 355/436] Remove extra css for rendered_html class --- docs/css/extra.css | 5 ----- 1 file changed, 5 deletions(-) diff --git a/docs/css/extra.css b/docs/css/extra.css index 2ac25647f..159879bef 100644 --- a/docs/css/extra.css +++ b/docs/css/extra.css @@ -111,11 +111,6 @@ body[data-md-color-scheme="slate"] .invertible img { } /* Rendered dataframe from jupyter */ -div.rendered_html { - width: 100% !important; - overflow-x: scroll; -} - table.dataframe { display: block; max-width: -moz-fit-content; From 5b57a2d2afb0ffc26787eeab0cec47d7550411e3 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 30 Aug 2023 19:09:01 +0200 Subject: [PATCH 356/436] Remove binder link caption --- build_scripts/modify_binder_link.py | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/build_scripts/modify_binder_link.py b/build_scripts/modify_binder_link.py index ebb446763..a01da10b5 100644 --- a/build_scripts/modify_binder_link.py +++ b/build_scripts/modify_binder_link.py @@ -3,6 +3,8 @@ with links to the actual notebooks in the repository. This is needed because for the docs we create symlinks to the notebooks inside the docs directory. +This is heavily inspired from: +https://github.com/greenape/mknotebooks/blob/master/mknotebooks/plugin.py#L322 """ import logging @@ -20,7 +22,11 @@ logger = logging.getLogger("mkdocs") BINDER_BASE_URL = "https://mybinder.org/v2" -BINDER_URL_PATTERN = re.compile(r"\(" + re.escape(BINDER_BASE_URL) + r".*\)") +BINDER_LOGO_WITH_CAPTION = "[![Binder](https://mybinder.org/badge_logo.svg)]" +BINDER_LOGO_WITHOUT_CAPTION = "[![](https://mybinder.org/badge_logo.svg)]" +BINDER_LINK_PATTERN = re.compile( + re.escape(BINDER_LOGO_WITH_CAPTION) + r"\(" + re.escape(BINDER_BASE_URL) + r".*\)" +) branch_name: Optional[str] = None @@ -51,7 +57,9 @@ def on_page_markdown( notebook_filename = Path(page.file.src_path).name file_path = (notebooks_dir / notebook_filename).relative_to(root_dir) url_path = f"%2Ftree%2F{file_path}" - binder_url = f"({BINDER_BASE_URL}/gh/{repo_name}/{branch_name}?urlpath={url_path})" - logger.debug(f"New binder url: {binder_url}") - markdown = re.sub(BINDER_URL_PATTERN, binder_url, markdown) + binder_url = f"{BINDER_BASE_URL}/gh/{repo_name}/{branch_name}?urlpath={url_path}" + binder_link = f"{BINDER_LOGO_WITHOUT_CAPTION}({binder_url})" + logger.info(f"New binder url: {binder_url}") + logger.info(f"Using regex: {BINDER_LINK_PATTERN}") + markdown = re.sub(BINDER_LINK_PATTERN, binder_link, markdown) return markdown From f80ec8f23c267cfde8d3783b311a09fa51074b5a Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Wed, 30 Aug 2023 19:22:58 +0200 Subject: [PATCH 357/436] Doc on generic semi-values --- docs/value/semi-values.md | 58 +++++++++++++++++++++++++++++++++++---- 1 file changed, 53 insertions(+), 5 deletions(-) diff --git a/docs/value/semi-values.md b/docs/value/semi-values.md index ba5f31090..cb1d61fb9 100644 --- a/docs/value/semi-values.md +++ b/docs/value/semi-values.md @@ -54,10 +54,11 @@ some applications. See however the [Banzhaf indices][banzhaf-indices] section for an alternative choice of weights which is reported to work better. ```python -from pydvl.value import compute_semivalues +from pydvl.value import * -values = compute_semivalues( - u=utility, mode="beta_shapley", done=MaxUpdates(500), alpha=1, beta=16 +utility = Utility(model, data) +values = compute_beta_shapley_semivalues( + u=utility, done=AbsoluteStandardError(threshold=1e-4), alpha=1, beta=16 ) ``` @@ -84,7 +85,54 @@ The authors of [@wang_data_2022] show that Banzhaf indices are more robust to variance in the utility function than Shapley and Beta Shapley values. ```python -from pydvl.value import compute_semivalues, MaxUpdates +from pydvl.value import * -values = compute_semivalues( u=utility, mode="banzhaf", done=MaxUpdates(500)) +utility = Utility(model, data) +values = compute_banzhaf_semivalues( + u=utility, done=AbsoluteStandardError(threshold=1e-4), alpha=1, beta=16 +) ``` + +## General semi-values + +As explained above, both Beta Shapley and Banzhaf indices are special cases of +semi-values. In pyDVL we provide a general method for computing these with any +combination of the three ingredients that define a semi-value: + +- A utility function $u$. +- A sampling method +- A weighting scheme $w$. + +The utility function is the same as for Shapley values, and the sampling method +can be any of the types defined in [the samplers module][pydvl.value.sampler]. +For instance, the following snippet is equivalent to the above: + +```python +from pydvl.value import * + +data = Dataset(...) +utility = Utility(model, data) +values = semivalues( + sampler=PermutationSampler(data.indices), + u=utility, + coefficient=beta_coefficient(alpha=1, beta=16), + done=AbsoluteStandardError(threshold=1e-4), + ) +``` + +!!! warning "Careful with permutation sampling" + This generic implementation of semi-values allowing for any combination of + sampling and weighting schemes is very flexible and, in principle, it + recovers the original Shapley value, so that + [compute_shapley_values][pydvl.value.shapley.common.compute_shapley_values] + is no longer necessary. However, it loses the optimization in permutation + sampling that reuses the utility computation from the last iteration when + iterating over a permutation. This doubles the computation requirements (and + slightly increases variance) when using permutation sampling, unless [the + cache](getting-started/installation.md#setting-up-the-cache) is enabled. + In addition, + [truncation policies][pydvl.value.shapley.truncated.TruncationPolicy] are + not supported for in this generic implementation (as of v0.7.0). For these + reasons it is preferable to use + [compute_shapley_values][pydvl.value.shapley.common.compute_shapley_values] + whenever not computing other semi-values. From 1ebac10de7a9727aee9fb7ddc53609868b160b40 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Wed, 30 Aug 2023 19:24:29 +0200 Subject: [PATCH 358/436] Fix some types --- src/pydvl/reporting/plots.py | 8 ++++---- src/pydvl/value/loo/naive.py | 2 +- src/pydvl/value/sampler.py | 2 +- src/pydvl/value/stopping.py | 8 +++++--- 4 files changed, 11 insertions(+), 9 deletions(-) diff --git a/src/pydvl/reporting/plots.py b/src/pydvl/reporting/plots.py index 89c198499..56abcb367 100644 --- a/src/pydvl/reporting/plots.py +++ b/src/pydvl/reporting/plots.py @@ -102,10 +102,10 @@ def plot_shapley( df: pd.DataFrame, *, level: float = 0.05, - ax: plt.Axes = None, - title: str = None, - xlabel: str = None, - ylabel: str = None, + ax: Optional[plt.Axes] = None, + title: Optional[str] = None, + xlabel: Optional[str] = None, + ylabel: Optional[str] = None, ) -> plt.Axes: """Plots the shapley values, as returned from [compute_shapley_values()][pydvl.value.shapley.common.compute_shapley_values], with error bars diff --git a/src/pydvl/value/loo/naive.py b/src/pydvl/value/loo/naive.py index 56e58cdbc..c50a30f5a 100644 --- a/src/pydvl/value/loo/naive.py +++ b/src/pydvl/value/loo/naive.py @@ -16,4 +16,4 @@ ) def naive_loo(u: Utility, *, progress: bool = True, **kwargs) -> ValuationResult: """Deprecated. Use [compute_loo][pydvl.value.loo.compute_loo] instead.""" - pass + pass # type: ignore diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 6776a19db..c190c08e9 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -110,7 +110,7 @@ def __init__( self, indices: NDArray[T], index_iteration: IndexIteration = IndexIteration.Sequential, - outer_indices: NDArray[T] = None, + outer_indices: NDArray[T] | None = None, ): """ Args: diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index 4e2ec98dc..3d44e4694 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -31,6 +31,8 @@ these operations affect the behavior of the stopping criteria. """ +from __future__ import annotations + import abc import logging from time import time @@ -195,9 +197,9 @@ def __invert__(self) -> "StoppingCriterion": def make_criterion( fun: StoppingCriterionCallable, - converged: Callable[[], NDArray[np.bool_]] = None, - completion: Callable[[], float] = None, - name: str = None, + converged: Callable[[], NDArray[np.bool_]] | None = None, + completion: Callable[[], float] | None = None, + name: str | None = None, ) -> Type[StoppingCriterion]: """Create a new [StoppingCriterion][pydvl.value.stopping.StoppingCriterion] from a function. Use this to enable simpler functions to be composed with bitwise operators From 54d9f40dd29412d0e1f0de589e759b3c5418c177 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Wed, 30 Aug 2023 19:44:15 +0200 Subject: [PATCH 359/436] object_ref is not in Future --- src/pydvl/utils/parallel/futures/ray.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 21f8fd325..cf7d35004 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -386,7 +386,7 @@ def flag_executor_shutting_down(self): # We cancel the future's object references # We cannot cancel a running future object. for future in self.submitted_futures: - ray.cancel(future.object_ref) + ray.cancel(future.object_ref) # type: ignore # Make sure we do this only once to not waste time looping # on running processes over and over. executor._cancel_futures &= ~CancellationPolicy.RUNNING From d0fd659acacedd04f7d3760eed6ce1b5f7a41d8b Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Wed, 30 Aug 2023 22:43:21 +0200 Subject: [PATCH 360/436] Minor --- docs/value/semi-values.md | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/docs/value/semi-values.md b/docs/value/semi-values.md index cb1d61fb9..7b31d84b8 100644 --- a/docs/value/semi-values.md +++ b/docs/value/semi-values.md @@ -4,9 +4,9 @@ title: Semi-values # Semi-values -SV is a particular case of a more general concept called semi-value, -which is a generalization to different weighting schemes. A **semi-value** is -any valuation function with the form: +SV is a particular case of a more general concept called semi-value, which is a +generalization to different weighting schemes. A **semi-value** is any valuation +function with the form: $$ v_\text{semi}(i) = \sum_{i=1}^n w(k) @@ -27,7 +27,7 @@ rank stability in certain situations. !!! Note Shapley values are a particular case of semi-values and can therefore also - be computed with the methods described here. However, as of version 0.6.0, + be computed with the methods described here. However, as of version 0.7.0, we recommend using [compute_shapley_values][pydvl.value.shapley.compute_shapley_values] instead, in particular because it implements truncation policies for TMCS. @@ -64,12 +64,12 @@ values = compute_beta_shapley_semivalues( ## Banzhaf indices -As noted in the section [Problems of Data Values][problems-of-data-values], -the Shapley value can be very sensitive to variance in the utility function. -For machine learning applications, where the utility is typically the performance -when trained on a set $S \subset D$, this variance is often largest -for smaller subsets $S$. It is therefore reasonable to try reducing -the relative contribution of these subsets with adequate weights. +As noted in the section [Problems of Data Values][problems-of-data-values], the +Shapley value can be very sensitive to variance in the utility function. For +machine learning applications, where the utility is typically the performance +when trained on a set $S \subset D$, this variance is often largest for smaller +subsets $S$. It is therefore reasonable to try reducing the relative +contribution of these subsets with adequate weights. One such choice of weights is the Banzhaf index, which is defined as the constant: @@ -130,9 +130,9 @@ values = semivalues( iterating over a permutation. This doubles the computation requirements (and slightly increases variance) when using permutation sampling, unless [the cache](getting-started/installation.md#setting-up-the-cache) is enabled. - In addition, + In addition, as mentioned above, [truncation policies][pydvl.value.shapley.truncated.TruncationPolicy] are - not supported for in this generic implementation (as of v0.7.0). For these + not supported by this generic implementation (as of v0.7.0). For these reasons it is preferable to use [compute_shapley_values][pydvl.value.shapley.common.compute_shapley_values] whenever not computing other semi-values. From 4ea3e5f5f4dd22e583fbd71118818e497bb171e3 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Wed, 30 Aug 2023 22:58:51 +0200 Subject: [PATCH 361/436] Comment --- docs/value/semi-values.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/docs/value/semi-values.md b/docs/value/semi-values.md index 7b31d84b8..651aa84bd 100644 --- a/docs/value/semi-values.md +++ b/docs/value/semi-values.md @@ -120,6 +120,12 @@ values = 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]. + + !!! warning "Careful with permutation sampling" This generic implementation of semi-values allowing for any combination of sampling and weighting schemes is very flexible and, in principle, it From fc3b3b92d8e8d325b73f82a20ec450378ca10aa0 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Wed, 30 Aug 2023 23:20:13 +0200 Subject: [PATCH 362/436] Rename --- CHANGELOG.md | 2 ++ docs/value/semi-values.md | 10 ++++---- src/pydvl/value/semivalues.py | 44 ++++++++++++++++++++-------------- tests/value/test_semivalues.py | 6 ++--- 4 files changed, 36 insertions(+), 26 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 57fefa481..a9b51d606 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -28,6 +28,8 @@ approximation [PR #365](https://github.com/appliedAI-Initiative/pyDVL/pull/365) - **Breaking Changes**: + - Renamed `semivalues` to `compute_generic_semivalues` + [PR #...]() - Add new joblib backend and set it as default instead of the ray backend. Simplify the MapReduceJob class. [PR #355](https://github.com/appliedAI-Initiative/pyDVL/pull/355) diff --git a/docs/value/semi-values.md b/docs/value/semi-values.md index 651aa84bd..86513a6a1 100644 --- a/docs/value/semi-values.md +++ b/docs/value/semi-values.md @@ -112,11 +112,11 @@ from pydvl.value import * data = Dataset(...) utility = Utility(model, data) -values = semivalues( - sampler=PermutationSampler(data.indices), - u=utility, - coefficient=beta_coefficient(alpha=1, beta=16), - done=AbsoluteStandardError(threshold=1e-4), +values = compute_generic_semivalues( + sampler=PermutationSampler(data.indices), + u=utility, + coefficient=beta_coefficient(alpha=1, beta=16), + done=AbsoluteStandardError(threshold=1e-4), ) ``` diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 7a14ce286..bd25ef856 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -74,7 +74,7 @@ "beta_coefficient", "banzhaf_coefficient", "shapley_coefficient", - "semivalues", + "compute_generic_semivalues", "compute_semivalues", "SemiValueMode", ] @@ -101,7 +101,7 @@ def __call__(self, n: int, k: int) -> float: def _marginal(u: Utility, coefficient: SVCoefficient, sample: SampleT) -> MarginalT: """Computation of marginal utility. This is a helper function for - [semivalues()][pydvl.value.semivalues.semivalues]. + [compute_generic_semivalues][pydvl.value.semivalues.compute_generic_semivalues]. Args: u: Utility object with model, data, and scoring function. @@ -123,7 +123,7 @@ def _marginal(u: Utility, coefficient: SVCoefficient, sample: SampleT) -> Margin # deprecated_in="0.8.0", # remove_in="0.9.0", # ) -def semivalues( +def compute_generic_semivalues( sampler: PowersetSampler, u: Utility, coefficient: SVCoefficient, @@ -248,10 +248,11 @@ def compute_shapley_semivalues( ) -> ValuationResult: """Computes Shapley values for a given utility function. - This is a convenience wrapper for :func:`semivalues` with the Shapley - coefficient. Use :func:`~pydvl.value.shapley.common.compute_shapley_values` - for a more flexible interface and additional methods, including Truncated - Monte Carlo. + This is a convenience wrapper for + [compute_generic_semivalues][pydvl.value.semivalues.compute_generic_semivalues] + with the Shapley coefficient. Use + [compute_shapley_values][pydvl.value.shapley.common.compute_shapley_values] + for a more flexible interface and additional methods, including TMCS. Args: u: Utility object with model, data, and scoring function. @@ -266,7 +267,7 @@ def compute_shapley_semivalues( Returns: Object with the results. """ - return semivalues( + return compute_generic_semivalues( sampler_t(u.data.indices), u, shapley_coefficient, @@ -288,8 +289,9 @@ def compute_banzhaf_semivalues( ) -> ValuationResult: """Computes Banzhaf values for a given utility function. - This is a convenience wrapper for :func:`semivalues` with the Banzhaf - coefficient. + This is a convenience wrapper for + [compute_generic_semivalues][pydvl.value.semivalues.compute_generic_semivalues] + with the Banzhaf coefficient. Args: u: Utility object with model, data, and scoring function. @@ -304,7 +306,7 @@ def compute_banzhaf_semivalues( Returns: Object with the results. """ - return semivalues( + return compute_generic_semivalues( sampler_t(u.data.indices), u, banzhaf_coefficient, @@ -328,8 +330,9 @@ def compute_beta_shapley_semivalues( ) -> ValuationResult: """Computes Beta Shapley values for a given utility function. - This is a convenience wrapper for :func:`semivalues` with the Beta Shapley - coefficient. + This is a convenience wrapper for + [compute_generic_semivalues][pydvl.value.semivalues.compute_generic_semivalues] + with the Beta Shapley coefficient. Args: u: Utility object with model, data, and scoring function. @@ -344,7 +347,7 @@ def compute_beta_shapley_semivalues( Returns: Object with the results. """ - return semivalues( + return compute_generic_semivalues( sampler_t(u.data.indices), u, beta_coefficient(alpha, beta), @@ -380,7 +383,8 @@ def compute_semivalues( !!! Warning This method is deprecated and will be replaced in 0.8.0 by the more - general implementation of [semivalues][pydvl.value.semivalues.semivalues]. + general implementation of + [compute_generic_semivalues][pydvl.value.semivalues.compute_generic_semivalues]. Use [compute_shapley_semivalues][pydvl.value.semivalues.compute_shapley_semivalues], [compute_banzhaf_semivalues][pydvl.value.semivalues.compute_banzhaf_semivalues], or @@ -388,7 +392,9 @@ def compute_semivalues( instead. The modes supported with this interface are the following. For greater - flexibility use [semivalues][pydvl.value.semivalues.semivalues] directly. + flexibility use + [compute_generic_semivalues][pydvl.value.semivalues.compute_generic_semivalues] + directly. - [SemiValueMode.Shapley][pydvl.value.semivalues.SemiValueMode.Shapley]: Shapley values. @@ -410,7 +416,7 @@ def compute_semivalues( for a list. n_jobs: Number of parallel jobs to use. kwargs: Additional keyword arguments passed to - [semivalues()][pydvl.value.semivalues.semivalues]. + [compute_generic_semivalues][pydvl.value.semivalues.compute_generic_semivalues]. Returns: Object with the results. @@ -427,4 +433,6 @@ def compute_semivalues( else: raise ValueError(f"Unknown mode {mode}") coefficient = cast(SVCoefficient, coefficient) - return semivalues(sampler_instance, u, coefficient, done, n_jobs=n_jobs, **kwargs) + return compute_generic_semivalues( + sampler_instance, u, coefficient, done, n_jobs=n_jobs, **kwargs + ) diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index bc39deb39..23fca06eb 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -17,7 +17,7 @@ SVCoefficient, banzhaf_coefficient, beta_coefficient, - semivalues, + compute_generic_semivalues, shapley_coefficient, ) from pydvl.value.stopping import AbsoluteStandardError, MaxUpdates @@ -47,7 +47,7 @@ def test_shapley( ): u, exact_values = analytic_shapley criterion = AbsoluteStandardError(0.02, 1.0) | MaxUpdates(2 ** (num_samples * 2)) - values = semivalues( + values = compute_generic_semivalues( sampler(u.data.indices), u, coefficient, @@ -77,7 +77,7 @@ def test_banzhaf( parallel_config: ParallelConfig, ): u, exact_values = analytic_banzhaf - values = semivalues( + values = compute_generic_semivalues( sampler(u.data.indices), u, banzhaf_coefficient, From e6ef5abe965168e4af0769ea324f881f80f4b017 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Wed, 30 Aug 2023 23:31:23 +0200 Subject: [PATCH 363/436] Fix doc --- src/pydvl/value/semivalues.py | 49 +++++++++++++++++++++-------------- 1 file changed, 29 insertions(+), 20 deletions(-) diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index bd25ef856..61a2cd228 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -26,14 +26,17 @@ while the latter reformulates it as: $$ -v_u(x_i) = \frac{1}{n!} \sum_{\sigma \in \Pi(n)} -\tilde{w}( | \sigma_{:i} | )[u(\sigma_{:i} \cup \{i\}) − u(\sigma_{:i})], +v(i) = \frac{1}{n!} \sum_{\sigma \in \Pi(n)} +\tilde{w}( | \sigma_{:i} | )[U(\sigma_{:i} \cup \{i\}) − U(\sigma_{:i})], $$ where $\sigma_{:i}$ denotes the set of indices in permutation sigma before the -position where $i$ appears (see [Data valuation][computing-data-values] for details), and -$\tilde{w}(k) = n \choose{n-1}{k} w(k)$ is the weight correction due to the -reformulation. +position where $i$ appears (see [Data valuation][computing-data-values] for +details), and + +$$ \tilde{w} (k) = n \binom{n - 1}{k} w (k) $$ + +is the weight correction due to the reformulation. !!! Warning Both [PermutationSampler][pydvl.value.sampler.PermutationSampler] and @@ -364,6 +367,13 @@ def compute_beta_shapley_semivalues( remove_in="0.8.0", ) class SemiValueMode(str, Enum): + """Enumeration of semi-value modes. + + !!! warning "Deprecation notice" + This enum and the associated methods are deprecated and will be removed + in 0.8.0. + """ + Shapley = "shapley" BetaShapley = "beta_shapley" Banzhaf = "banzhaf" @@ -381,31 +391,30 @@ def compute_semivalues( ) -> ValuationResult: """Convenience entry point for most common semi-value computations. - !!! Warning - This method is deprecated and will be replaced in 0.8.0 by the more - general implementation of - [compute_generic_semivalues][pydvl.value.semivalues.compute_generic_semivalues]. - Use - [compute_shapley_semivalues][pydvl.value.semivalues.compute_shapley_semivalues], - [compute_banzhaf_semivalues][pydvl.value.semivalues.compute_banzhaf_semivalues], or - [compute_beta_shapley_semivalues][pydvl.value.semivalues.compute_beta_shapley_semivalues] - instead. + !!! warning "Deprecation warning" + This method is deprecated and will be replaced in 0.8.0 by the more + general implementation of + [compute_generic_semivalues][pydvl.value.semivalues.compute_generic_semivalues]. + Use + [compute_shapley_semivalues][pydvl.value.semivalues.compute_shapley_semivalues], + [compute_banzhaf_semivalues][pydvl.value.semivalues.compute_banzhaf_semivalues], + or + [compute_beta_shapley_semivalues][pydvl.value.semivalues.compute_beta_shapley_semivalues] + instead. The modes supported with this interface are the following. For greater flexibility use [compute_generic_semivalues][pydvl.value.semivalues.compute_generic_semivalues] directly. - - [SemiValueMode.Shapley][pydvl.value.semivalues.SemiValueMode.Shapley]: + - [SemiValueMode.Shapley][pydvl.value.semivalues.SemiValueMode]: Shapley values. - - [SemiValueMode.BetaShapley][pydvl.value.semivalues.SemiValueMode.BetaShapley]: + - [SemiValueMode.BetaShapley][pydvl.value.semivalues.SemiValueMode]: Implements the Beta Shapley semi-value as introduced in [@kwon_beta_2022]. Pass additional keyword arguments `alpha` and `beta` to set the parameters of the Beta distribution (both default to 1). - - [SemiValueMode.Banzhaf][SemiValueMode.Banzhaf]: Implements the Banzhaf - semi-value as introduced in [@wang_data_2022]. - - See [[data-valuation]] for an overview of valuation. + - [SemiValueMode.Banzhaf][pydvl.value.semivalues.SemiValueMode]: Implements + the Banzhaf semi-value as introduced in [@wang_data_2022]. Args: u: Utility object with model, data, and scoring function. From 425b4354561a3d88c1dbe3e91c140a8f863b5d58 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Wed, 30 Aug 2023 23:33:40 +0200 Subject: [PATCH 364/436] Update CHANGELOG.md --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index a9b51d606..c70322428 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -29,7 +29,7 @@ [PR #365](https://github.com/appliedAI-Initiative/pyDVL/pull/365) - **Breaking Changes**: - Renamed `semivalues` to `compute_generic_semivalues` - [PR #...]() + [PR #413](https://github.com/appliedAI-Initiative/pyDVL/pull/413) - Add new joblib backend and set it as default instead of the ray backend. Simplify the MapReduceJob class. [PR #355](https://github.com/appliedAI-Initiative/pyDVL/pull/355) From 00727bc4aa5991f3165e2c2288158175c5309a11 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Wed, 30 Aug 2023 23:37:13 +0200 Subject: [PATCH 365/436] Two hacks for mypy --- src/pydvl/value/sampler.py | 3 ++- src/pydvl/value/shapley/truncated.py | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index c190c08e9..341532e9b 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -237,7 +237,8 @@ def __init__(self, indices: NDArray[T], *args, **kwargs): def __iter__(self) -> Iterator[SampleT]: for idx in self.iterindices(): - for subset in powerset(self.complement([idx])): + # FIXME: type ignore just necessary for CI ?? + for subset in powerset(self.complement([idx])): # type: ignore yield idx, np.array(subset) self._n_samples += 1 diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index fe8e74ac8..cd1249328 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -128,7 +128,8 @@ def __init__(self, u: Utility, rtol: float): self.total_utility = u(u.data.indices) def _check(self, idx: int, score: float) -> bool: - return np.allclose(score, self.total_utility, rtol=self.rtol) + # Explicit cast for the benefit of mypy 🤷 + return bool(np.allclose(score, self.total_utility, rtol=self.rtol)) def reset(self): pass From 6b7d6f1ef79a0ea14f310fd86feafecbf702b5f0 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Thu, 31 Aug 2023 11:47:09 +0200 Subject: [PATCH 366/436] Freeze dataclasses --- src/pydvl/utils/config.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/pydvl/utils/config.py b/src/pydvl/utils/config.py index 487431403..8bf9b1b41 100644 --- a/src/pydvl/utils/config.py +++ b/src/pydvl/utils/config.py @@ -9,7 +9,7 @@ __all__ = ["ParallelConfig", "MemcachedClientConfig", "MemcachedConfig"] -@dataclass +@dataclass(frozen=True) class ParallelConfig: """Configuration for parallel computation backend. @@ -34,7 +34,7 @@ def __post_init__(self) -> None: raise ValueError("When `address` is set, `n_cpus_local` should be None.") -@dataclass +@dataclass(frozen=True) class MemcachedClientConfig: """Configuration of the memcached client. From 6843ecae1a3dac429e01a1dcd22fcb62030ea6dd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 31 Aug 2023 12:28:19 +0200 Subject: [PATCH 367/436] Update bib file with export from Zotero --- docs/assets/pydvl.bib | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/docs/assets/pydvl.bib b/docs/assets/pydvl.bib index 0ea2ccfb2..008bc1bf0 100644 --- a/docs/assets/pydvl.bib +++ b/docs/assets/pydvl.bib @@ -1,3 +1,18 @@ +@article{agarwal_secondorder_2017, + title = {Second-{{Order Stochastic Optimization}} for {{Machine Learning}} in {{Linear Time}}}, + author = {Agarwal, Naman and Bullins, Brian and Hazan, Elad}, + date = {2017}, + journaltitle = {Journal of Machine Learning Research}, + shortjournal = {JMLR}, + volume = {18}, + eprint = {1602.03943}, + eprinttype = {arxiv}, + pages = {1--40}, + url = {https://www.jmlr.org/papers/v18/16-491.html}, + abstract = {First-order stochastic methods are the state-of-the-art in large-scale machine learning optimization owing to efficient per-iteration complexity. Second-order methods, while able to provide faster convergence, have been much less explored due to the high cost of computing the second-order information. In this paper we develop second-order stochastic methods for optimization problems in machine learning that match the per-iteration cost of gradient based methods, and in certain settings improve upon the overall running time over popular first-order methods. Furthermore, our algorithm has the desirable property of being implementable in time linear in the sparsity of the input data.}, + langid = {english} +} + @article{benmerzoug_re_2023, title = {[{{Re}}] {{If}} You like {{Shapley}}, Then You'll Love the Core}, author = {Benmerzoug, Anes and Delgado, Miguel de Benito}, @@ -188,6 +203,22 @@ @inproceedings{okhrati_multilinear_2021 keywords = {notion} } +@inproceedings{schioppa_scaling_2021, + title = {Scaling {{Up Influence Functions}}}, + author = {Schioppa, Andrea and Zablotskaia, Polina and Vilar, David and Sokolov, Artem}, + date = {2021-12-06}, + eprint = {2112.03052}, + eprinttype = {arxiv}, + eprintclass = {cs}, + publisher = {{arXiv}}, + doi = {10.48550/arXiv.2112.03052}, + url = {http://arxiv.org/abs/2112.03052}, + urldate = {2023-03-10}, + abstract = {We address efficient calculation of influence functions for tracking predictions back to the training data. We propose and analyze a new approach to speeding up the inverse Hessian calculation based on Arnoldi iteration. With this improvement, we achieve, to the best of our knowledge, the first successful implementation of influence functions that scales to full-size (language and vision) Transformer models with several hundreds of millions of parameters. We evaluate our approach on image classification and sequence-to-sequence tasks with tens to a hundred of millions of training examples. Our code will be available at https://github.com/google-research/jax-influence.}, + eventtitle = {{{AAAI-22}}}, + keywords = {notion} +} + @inproceedings{schoch_csshapley_2022, title = {{{CS-Shapley}}: {{Class-wise Shapley Values}} for {{Data Valuation}} in {{Classification}}}, shorttitle = {{{CS-Shapley}}}, From 8004a7440524dfe348e3e7f8adbad2b6b9782bb6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 31 Aug 2023 12:29:59 +0200 Subject: [PATCH 368/436] Update top level influence documentation --- docs/influence/index.md | 64 +++++++++++++++++++++++++++-------------- 1 file changed, 42 insertions(+), 22 deletions(-) diff --git a/docs/influence/index.md b/docs/influence/index.md index e05a5a807..aa4fc97ac 100644 --- a/docs/influence/index.md +++ b/docs/influence/index.md @@ -32,7 +32,7 @@ arise when using the IF. # The Influence Function -First introduced in the context of robust statistics in [@hampel1974influence], +First introduced in the context of robust statistics in [@hampel_influence_1974], the IF was popularized in the context of machine learning in [@koh_understanding_2017]. @@ -69,17 +69,10 @@ approximation of $\hat{\theta}$. This can be done through single backpropagation and without re-training the full model. - -There are two ways to compute influences. For linear regression, the influences -can be computed analytically. For more general models or loss functions, one can -implement the [TwiceDifferentiable][pydvl.influence.frameworks.torch_differentiable.TwiceDifferentiable] -protocol, which provides the required methods for computing the influences. - pyDVL supports two ways of computing the empirical influence function, namely -up-weighting of samples and perturbation influences. The choice is done by a -parameter in the call to the main entry points, -[compute_linear_influences][pydvl.influence.linear.compute_linear_influences] -and [compute_influences][pydvl.influence.compute_influences]. +up-weighting of samples and perturbation influences. The choice is done by the +parameter `influence_type` in the main entry point +[compute_influences][pydvl.influence.general.compute_influences]. ## Approximating the influence of a point @@ -192,7 +185,7 @@ as done in [@koh_understanding_2017]. The main entry point of the library for influence calculation is [compute_influences][pydvl.influence.general.compute_influences]. Given a pre-trained pytorch model with a loss, first an instance of -[TorchTwiceDifferentiable][pydvl.influence.general.TorchTwiceDifferentiable] +[TorchTwiceDifferentiable][pydvl.influence.torch.torch_differentiable.TorchTwiceDifferentiable] needs to be created: ```python @@ -343,7 +336,7 @@ influence_factors = compute_influence_factors( ``` The result is an object of type -[InverseHvpResult][pydvl.influence.framework.InverseHvpResult], +[InverseHvpResult][pydvl.influence.twice_differentiable.InverseHvpResult], which holds the calculated influence factors (`influence_factors.x`) and a dictionary with the info on the inversion process (`influence_factors.info`). @@ -383,7 +376,7 @@ solve_hvp( ``` The result, an object of type -[InverseHvpResult][pydvl.influence.framework.InverseHvpResult], +[InverseHvpResult][pydvl.influence.twice_differentiable.InverseHvpResult], which holds two objects: `influence_factors.x` and `influence_factors.info`. The first one is the inverse Hessian vector product, while the second one is a dictionary with the info on the inversion process. For this method, the info @@ -418,11 +411,11 @@ solve_hvp( ``` The additional optional parameters `x0`, `rtol`, `atol`, and `maxiter` are passed -to the [solve_batch_cg][pydvl.influence.frameworks.torch_differentiable.solve_batch_cg] +to the [solve_batch_cg][pydvl.influence.torch.torch_differentiable.solve_batch_cg] function, and are respecively the initial guess for the solution, the relative tolerance, the absolute tolerance, and the maximum number of iterations. -The resulting [InverseHvpResult][pydvl.influence.framework.InverseHvpResult] +The resulting [InverseHvpResult][pydvl.influence.twice_differentiable.InverseHvpResult] holds the solution of the iHVP, `influence_factors.x`, and some info on the inversion process `influence_factors.info`. More specifically, for each batch the infos will report the number of iterations, a boolean indicating if the @@ -443,7 +436,7 @@ $$H^{-1}_{j+1} b = b + (I - d) \ H - \frac{H^{-1}_j b}{s},$$ where $d$ and $s$ are a dampening and a scaling factor, which are essential for the convergence of the method and they need to be chosen carefully, and I is the identity matrix. More info on the theory of LiSSA can be found in the -original paper [@agarwal_2017_second]. +original paper [@agarwal_secondorder_2017]. In pyDVL, you can select LiSSA with `inversion_method = "lissa"`, like this: @@ -464,18 +457,45 @@ solve_hvp( with the additional optional parameters `maxiter`, `dampen`, `scale`, `h0`, and `rtol`, which are passed to the -[solve_lissa][pydvl.influence.frameworks.torch_differentiable.solve_lissa] function, +[solve_lissa][pydvl.influence.torch.torch_differentiable.solve_lissa] function, being the maximum number of iterations, the dampening factor, the scaling factor, the initial guess for the solution and the relative tolerance, respectively. -The resulting [InverseHvpResult][pydvl.influence.framework.InverseHvpResult] +The resulting [InverseHvpResult][pydvl.influence.twice_differentiable.InverseHvpResult] holds the solution of the iHVP, `influence_factors.x`, and, within `influence_factors.info`, the maximum percentage error and the mean percentage error of the approximation. ## Arnoldi solver -The Arnoldi method is a Krylov subspace method for approximating the action of a -matrix on a vector. It is a generalization of the power method for finding -eigenvectors of a matrix. +The [Arnoldi method](https://en.wikipedia.org/wiki/Arnoldi_iteration) +is a Krylov subspace method for approximating dominating eigenvalues and eigenvectors. Under a low rank +assumption on the Hessian at a minimizer (which is typically observed for deep neural networks), this approximation +captures the essential action of the Hessian. More concrete, for $Hx=b$ the solution is approximated by + +\[x \approx V D^{-1} V^T b\] + +where \(D\) is a diagonal matrix with the top (in absolute value) eigenvalues of the Hessian +and \(V\) contains the corresponding eigenvectors, see also [@schioppa_scaling_2021]. + + +In pyDVL, you can select Arnoldi with `inversion_method = "arnoldi"`, like this: + +```python +from pydvl.influence.inversion import solve_hvp +solve_hvp( + "arnoldi", + wrapped_model, + training_data_loader, + b, + hessian_perturbation=0.0, + rank_estimate=10, + tol=1e-6, + eigen_computation_on_gpu=False +) +``` +For the parameters, check [solve_arnoldi][pydvl.influence.torch.torch_differentiable.solve_arnoldi]. +The resulting [InverseHvpResult][pydvl.influence.twice_differentiable.InverseHvpResult] +holds the solution of the iHVP, `influence_factors.x`, and, +within `influence_factors.info`, the computed eigenvalues and eigenvectors. From fd4fa6b33e01312e6e64926e3600ecc27c728b4a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 31 Aug 2023 12:31:40 +0200 Subject: [PATCH 369/436] Add references to influence package for API documentation via mkdocstrings --- mkdocs.yml | 1 + src/pydvl/influence/general.py | 30 +++++++++++------ .../influence/torch/torch_differentiable.py | 32 +++++++++++++------ 3 files changed, 43 insertions(+), 20 deletions(-) diff --git a/mkdocs.yml b/mkdocs.yml index e038feb72..75bf95d27 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -57,6 +57,7 @@ plugins: - https://numpy.org/doc/stable/objects.inv - https://pandas.pydata.org/docs/objects.inv - https://scikit-learn.org/stable/objects.inv + - https://pytorch.org/docs/stable/objects.inv paths: [ src ] # search packages in the src folder options: docstring_style: google diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 35c17020f..73c754a4a 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -1,6 +1,12 @@ """ -This module contains parallelized influence calculation functions for general -models, as introduced in [@koh_understanding_2017]. +This module contains influence calculation functions for general +models, as introduced in (Koh and Liang, 2017)[^1]. + +## References: + +[^1]: Koh, P.W., Liang, P., 2017. + [Understanding Black-box Predictions via Influence Functions](https://proceedings.mlr.press/v70/koh17a.html). + In: Proceedings of the 34th International Conference on Machine Learning, pp. 1885–1894. PMLR. """ import logging from copy import deepcopy @@ -27,8 +33,10 @@ class InfluenceType(str, Enum): Enum representation for the types of influence. Attributes: - - Up: Up-weighting a training point, see section 2.1 of [@koh_understanding_2017] - - Perturbation: Perturb a training point, see section 2.2 of [@koh_understanding_2017] + Up: Up-weighting a training point, see section 2.1 of + (Koh and Liang, 2017)1 + Perturbation: Perturb a training point, see section 2.2 of + (Koh and Liang, 2017)1 """ @@ -60,7 +68,7 @@ def compute_influence_factors( They are used for efficient influence calculation. This method first (implicitly) calculates the Hessian and then (explicitly) finds the influence factors for the model using the given inversion method. The parameter `hessian_perturbation` is used to regularize the inversion of - the Hessian. For more info, refer to [@koh_understanding_2017], paragraph 3. + the Hessian. For more info, refer to (Koh and Liang, 2017)1, paragraph 3. Args: model: A model wrapped in the TwiceDifferentiable interface. @@ -135,7 +143,7 @@ def compute_influences_up( parameters of the model). 2. Multiplying each gradient with the influence factors. - For a detailed description of the methodology, see section 2.1 of [@koh_understanding_2017]. + For a detailed description of the methodology, see section 2.1 of (Koh and Liang, 2017)1. Args: model: A model that implements the TwiceDifferentiable interface. @@ -159,7 +167,7 @@ def compute_influences_up( def train_grads() -> Generator[TensorType, None, None]: for x, y in maybe_progress( - input_data, progress, desc="Batch Split Input Gradients" + input_data, progress, desc="Batch Split Input Gradients" ): yield stack( [model.grad(inpt, target) for inpt, target in zip(unsqueeze(x, 1), y)] @@ -195,10 +203,11 @@ def compute_influences_pert( 1. Calculating the gradient of the model with respect to each training sample (\(\operatorname{grad}_{\theta} L\), where \(L\) is the loss of the model for a single data point and \(\theta\) are the parameters of the model). - 2. Using the method `TwiceDifferentiable.mvp` to efficiently compute the product of the + 2. Using the method [TwiceDifferentiable.mvp][pydvl.influence.twice_differentiable.TwiceDifferentiable.mvp] + to efficiently compute the product of the influence factors and \(\operatorname{grad}_x \operatorname{grad}_{\theta} L\). - For a detailed methodology, see section 2.2 of [@koh_understanding_2017]. + For a detailed methodology, see section 2.2 of (Koh and Liang, 2017)1. Args: model: A model that implements the TwiceDifferentiable interface. @@ -280,7 +289,7 @@ def compute_influences( progress: A boolean indicating whether progress bars should be displayed during computation. influence_type: Determines the methodology for computing influences. Valid choices include 'up' (for up-weighting) and 'perturbation'. - For an in-depth understanding, see [@koh_understanding_2017]. + For an in-depth understanding, see (Koh and Liang, 2017)1. hessian_regularization: A lambda value used in Hessian regularization. The regularized Hessian, \( H_{reg} \), is computed as \( H + \lambda \times I \), where \( I \) is the identity matrix and \( H \) is the simple, unmodified Hessian. This regularization is typically utilized for more @@ -313,3 +322,4 @@ def compute_influences( influence_factors, progress=progress, ) + diff --git a/src/pydvl/influence/torch/torch_differentiable.py b/src/pydvl/influence/torch/torch_differentiable.py index b17a99180..4992ddfcb 100644 --- a/src/pydvl/influence/torch/torch_differentiable.py +++ b/src/pydvl/influence/torch/torch_differentiable.py @@ -3,6 +3,15 @@ on ways to calculate matrix vector products. Moreover, it contains several methods to invert the Hessian vector product. These are used to calculate the influence of a training point on the model. + +## References: + +[^1]: Koh, P.W., Liang, P., 2017. + [Understanding Black-box Predictions via Influence Functions](https://proceedings.mlr.press/v70/koh17a.html). + In: Proceedings of the 34th International Conference on Machine Learning, pp. 1885–1894. PMLR. +[^2]: Agarwal, N., Bullins, B., Hazan, E., 2017. + [Second-Order Stochastic Optimization for Machine Learning in Linear Time](https://www.jmlr.org/papers/v18/16-491.html). + In: Journal of Machine Learning Research, Vol. 18, pp. 1–40. JMLR. """ import logging from dataclasses import dataclass @@ -42,7 +51,7 @@ class TorchTwiceDifferentiable(TwiceDifferentiable[torch.Tensor]): r""" - Wraps a [torch.nn.Module](https://pytorch.org/docs/stable/generated/torch.nn.Module.html) + Wraps a [torch.nn.Module][torch.nn.Module] and a loss function and provides methods to compute gradients and second derivative of the loss wrt. the model parameters @@ -503,8 +512,9 @@ def solve_linear( hessian_perturbation: Regularization of the hessian. Returns: - Instance of [InverseHvpResult], having an array that solves the inverse problem, - i.e. it returns \(x\) such that \(Hx = b\), and a dictionary containing information about the solution. + Instance of [InverseHvpResult][pydvl.influence.twice_differentiable.InverseHvpResult], + having an array that solves the inverse problem, i.e. it returns \(x\) such that \(Hx = b\), + and a dictionary containing information about the solution. """ all_x, all_y = [], [] @@ -550,9 +560,10 @@ def solve_batch_cg( progress: If True, display progress bars. Returns: - Instance of [InverseHvpResult], having a matrix of shape [NxP] with each line being a solution of \(Ax=b\), - and a dictionary containing information about the convergence of CG, - one entry for each line of the matrix. + Instance of [InverseHvpResult][pydvl.influence.twice_differentiable.InverseHvpResult], + having a matrix of shape [NxP] with each line being a solution of \(Ax=b\), + and a dictionary containing information about the convergence of CG, + one entry for each line of the matrix. """ total_grad_xy = 0 @@ -598,7 +609,7 @@ def solve_cg( Returns: Instance of [InverseHvpResult], with a vector x, solution of \(Ax=b\), and a dictionary containing - information about the convergence of CG. + information about the convergence of CG. """ if x0 is None: @@ -655,7 +666,8 @@ def solve_lissa( where \(I\) is the identity matrix, \(d\) is a dampening term and \(s\) a scaling factor that are applied to help convergence. For details, see - [@koh_understanding_2017] and the original paper [@agarwal_2017_second]. + (Koh and Liang, 2017)1 and the original paper + (Agarwal et. al.)2. Args: model: A model wrapped in the TwiceDifferentiable interface. @@ -670,8 +682,8 @@ def solve_lissa( progress: If True, display progress bars. Returns: - Instance of [InverseHvpResult], with a matrix of shape [NxP] with each line being a solution of \(Ax=b\), - and a dictionary containing information about the accuracy of the solution. + Instance of [InverseHvpResult][pydvl.influence.twice_differentiable.InverseHvpResult], with a matrix of shape [NxP] with each line being a solution of \(Ax=b\), + and a dictionary containing information about the accuracy of the solution. """ if h0 is None: From aacbe710672809ec63a122839261996acb57bb64 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 31 Aug 2023 12:32:46 +0200 Subject: [PATCH 370/436] Use only python bindings pypandoc for pandoc, as pypandoc_binary (includes binaries for pandoc) are not available for every OS --- requirements-docs.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements-docs.txt b/requirements-docs.txt index 4a2484a1e..63d04d803 100644 --- a/requirements-docs.txt +++ b/requirements-docs.txt @@ -14,4 +14,4 @@ mkdocs-material mkdocs-section-index mkdocs-macros-plugin neoteroi-mkdocs # Needed for card grid on home page -pypandoc_binary +pypandoc From 85325b8ccc57025737fb66439a2632587412ef52 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 31 Aug 2023 12:43:45 +0200 Subject: [PATCH 371/436] Add references to and fix documentation issues for reporting module and utils package --- src/pydvl/reporting/plots.py | 5 +++-- src/pydvl/utils/caching.py | 15 ++++++++------- src/pydvl/utils/config.py | 1 + src/pydvl/utils/dataset.py | 14 +++++++------- src/pydvl/utils/numeric.py | 22 +++++++++++++--------- src/pydvl/utils/parallel/futures/ray.py | 1 + src/pydvl/utils/types.py | 3 ++- 7 files changed, 35 insertions(+), 26 deletions(-) diff --git a/src/pydvl/reporting/plots.py b/src/pydvl/reporting/plots.py index 56abcb367..d0fee5377 100644 --- a/src/pydvl/reporting/plots.py +++ b/src/pydvl/reporting/plots.py @@ -107,8 +107,8 @@ def plot_shapley( xlabel: Optional[str] = None, ylabel: Optional[str] = None, ) -> plt.Axes: - """Plots the shapley values, as returned from - [compute_shapley_values()][pydvl.value.shapley.common.compute_shapley_values], with error bars + r"""Plots the shapley values, as returned from + [compute_shapley_values][pydvl.value.shapley.common.compute_shapley_values], with error bars corresponding to an $\alpha$-level confidence interval. Args: @@ -141,6 +141,7 @@ def plot_influence_distribution_by_label( """Plots the histogram of the influence that all samples in the training set have over a single sample index, separated by labels. + Args: influences: array of influences (training samples x test samples) labels: labels for the training set. title_extra: diff --git a/src/pydvl/utils/caching.py b/src/pydvl/utils/caching.py index ba6629ce4..233dec86e 100644 --- a/src/pydvl/utils/caching.py +++ b/src/pydvl/utils/caching.py @@ -3,23 +3,24 @@ pyDVL uses [memcached](https://memcached.org) to cache utility values, through [pymemcache](https://pypi.org/project/pymemcache). This allows sharing evaluations across processes and nodes in a cluster. You can run memcached as a -service, locally or remotely, see :ref:`caching setup`. +service, locally or remotely, see [Setting up the cache](#setting-up-the-cache) !!! Warning Function evaluations are cached with a key based on the function's signature - and code. This can lead to undesired cache hits, see :ref:`cache reuse`. + and code. This can lead to undesired cache hits, see [Cache reuse](#cache-reuse). Remember **not to reuse utility objects for different datasets**. # Configuration -Memoization is disabled by default but can be enabled easily, see :ref:`caching setup`. +Memoization is disabled by default but can be enabled easily, +see [Setting up the cache](#setting-up-the-cache). When enabled, it will be added to any callable used to construct a [Utility][pydvl.utils.utility.Utility] (done with the decorator [@memcached][pydvl.utils.caching.memcached]). Depending on the nature of the utility you might want to enable the computation of a running average of function values, see -:ref:`caching stochastic functions`. You can see all configuration options under -[MemcachedConfig][pydvl.utils.config.MemcachedConfig]. +[Usage with stochastic functions](#usaage-with-stochastic-functions). +You can see all configuration options under [MemcachedConfig][pydvl.utils.config.MemcachedConfig]. ## Default configuration @@ -153,14 +154,14 @@ def memcached( If the function is deterministic, i.e. same input corresponds to the same exact output, set `allow_repeated_evaluations` to `False`. If instead the function is stochastic (like the training of a model depending on random - initializations), memcached allows to set a minimum number of evaluations + initializations), memcached() allows to set a minimum number of evaluations to compute a running average, and a tolerance after which the function will not be called anymore. In other words, the function will be recomputed until the value has stabilized with a standard error smaller than `rtol_stderr * running average`. !!! Warning - Do not cache functions with state! See :ref:`cache reuse` + Do not cache functions with state! See [Cache reuse](cache-reuse) ??? Example ```python diff --git a/src/pydvl/utils/config.py b/src/pydvl/utils/config.py index 7f4cd36a8..79d26be7b 100644 --- a/src/pydvl/utils/config.py +++ b/src/pydvl/utils/config.py @@ -12,6 +12,7 @@ @dataclass class ParallelConfig: """Configuration for parallel computation backend. + Args: backend: Type of backend to use. Defaults to 'joblib' address: Address of existing remote or local cluster to use. diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index 1babcee60..607e52ac3 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -256,8 +256,8 @@ def from_sklearn( **kwargs, ) -> "Dataset": """Constructs a [Dataset][pydvl.utils.Dataset] object from a - [sklearn.utils.Bunch][], as returned by the `load_*` functions in - [sklearn toy datasets](https://scikit-learn.org/stable/datasets/toy_dataset.html). + [sklearn.utils.Bunch][sklearn.utils.Bunch], as returned by the `load_*` + functions in [sklearn toy datasets](https://scikit-learn.org/stable/datasets/toy_dataset.html). Args: data: sklearn dataset. The following attributes are supported @@ -454,9 +454,9 @@ def from_sklearn( data_groups: Optional[Sequence] = None, **kwargs, ) -> "GroupedDataset": - """Constructs a [GroupedDataset][pydvl.utils.GroupedDataset] object from a scikit-learn bunch - as returned by the `load_*` functions in `sklearn toy datasets - `_ and groups + """Constructs a [GroupedDataset][pydvl.utils.GroupedDataset] object from a + [sklearn.utils.Bunch][sklearn.utils.Bunch] as returned by the `load_*` functions in + [sklearn toy datasets](https://scikit-learn.org/stable/datasets/toy_dataset.html) and groups it. Args: @@ -511,8 +511,8 @@ def from_arrays( **kwargs, ) -> "Dataset": """Constructs a [GroupedDataset][pydvl.utils.GroupedDataset] object from X and y numpy arrays - as returned by the `make_*` functions in `sklearn generated datasets - `_. + as returned by the `make_*` functions in + [sklearn generated datasets](https://scikit-learn.org/stable/datasets/sample_generators.html). Args: X: array of shape (n_samples, n_features) diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index 3aea14c77..d78f8d5be 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -90,12 +90,12 @@ def random_powerset( """Samples subsets from the power set of the argument, without pre-generating all subsets and in no order. - See `powerset()` if you wish to deterministically generate all subsets. + See [powerset][pydvl.utils.numeric.powerset] if you wish to deterministically generate all subsets. To generate subsets, `len(s)` Bernoulli draws with probability `q` are drawn. The default value of `q = 0.5` provides a uniform distribution over the power set of `s`. Other choices can be used e.g. to implement - :func:`Owen sampling `. + [owen_sampling_shapley][pydvl.value.shapley.owen.owen_sampling_shapley]. Args: s: set to sample from @@ -107,7 +107,8 @@ def random_powerset( Returns: Samples from the power set of `s`. - :raises: ValueError: if the element sampling probability is not in [0,1] + Raises: + ValueError: if the element sampling probability is not in [0,1] """ if q < 0 or q > 1: @@ -132,7 +133,8 @@ def random_subset_of_size(s: NDArray[T], size: int) -> NDArray[T]: Returns: The subset - :raises ValueError: If size > len(s) + Raises + ValueError: If size > len(s) """ if size > len(s): raise ValueError("Cannot sample subset larger than set") @@ -144,10 +146,12 @@ def random_matrix_with_condition_number(n: int, condition_number: float) -> NDAr """Constructs a square matrix with a given condition number. Taken from: - https://gist.github.com/bstellato/23322fe5d87bb71da922fbc41d658079#file-random_mat_condition_number-py + [https://gist.github.com/bstellato/23322fe5d87bb71da922fbc41d658079#file-random_mat_condition_number-py]( + https://gist.github.com/bstellato/23322fe5d87bb71da922fbc41d658079#file-random_mat_condition_number-py) Also see: - https://math.stackexchange.com/questions/1351616/condition-number-of-ata. + [https://math.stackexchange.com/questions/1351616/condition-number-of-ata]( + https://math.stackexchange.com/questions/1351616/condition-number-of-ata). Args: n: size of the matrix @@ -207,11 +211,11 @@ def running_moments( See [Welford's algorithm in wikipedia](https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm) !!! Warning - This is not really using Welford's correction for numerical stability - for the variance. (FIXME) + This is not really using Welford's correction for numerical stability + for the variance. (FIXME) !!! Todo - This could be generalised to arbitrary moments. See [this paper](https://www.osti.gov/biblio/1028931) + This could be generalised to arbitrary moments. See [this paper](https://www.osti.gov/biblio/1028931) Args: previous_avg: average value at previous step diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index cf7d35004..77db40a10 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -28,6 +28,7 @@ class RayExecutor(Executor): It shouldn't be initialized directly. You should instead call [init_executor()][pydvl.utils.parallel.futures.init_executor]. + Args: max_workers: Maximum number of concurrent tasks. Each task can request itself any number of vCPUs. You must ensure the product of this value and the n_cpus_per_job parameter passed to submit() does not diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index 32c400eb5..0de94cf73 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -50,6 +50,7 @@ def maybe_add_argument(fun: Callable, new_arg: str) -> Callable: returned as is. Otherwise, a wrapper is returned which merely ignores the argument. + Args: fun: The function to wrap new_arg: The name of the argument that the new function will accept (and ignore). @@ -83,7 +84,7 @@ class SomeClass(metaclass=NoPublicConstructor): a `TypeError` will be thrown. Taken almost verbatim from: - https://stackoverflow.com/a/64682734 + [https://stackoverflow.com/a/64682734](https://stackoverflow.com/a/64682734) """ def __call__(cls, *args, **kwargs): From 8ccc0cbc8705c867890b3831d57e6ad34adeb24e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 31 Aug 2023 12:45:22 +0200 Subject: [PATCH 372/436] Add references to and fix documentation issues in value package --- src/pydvl/value/result.py | 6 +++--- src/pydvl/value/semivalues.py | 28 +++++++++++++++++++++++---- src/pydvl/value/shapley/gt.py | 11 ++++++++--- src/pydvl/value/shapley/knn.py | 14 +++++++++++--- src/pydvl/value/shapley/montecarlo.py | 12 ++++++++++-- src/pydvl/value/shapley/owen.py | 10 +++++++++- src/pydvl/value/shapley/truncated.py | 14 +++++++++++--- src/pydvl/value/stopping.py | 13 ++++++++++--- 8 files changed, 86 insertions(+), 22 deletions(-) diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index cc446afd8..e5cc9ec23 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -4,8 +4,7 @@ The most important class is [ValuationResult][pydvl.value.result.ValuationResult], which provides access to raw values, as well as convenient behaviour as a `Sequence` with extended -indexing and updating abilities, and conversion to `pandas DataFrames -`_. +indexing and updating abilities, and conversion to [pandas DataFrames][pandas.DataFrame]. # Operating on results @@ -148,7 +147,8 @@ class ValuationResult( ## Indexing Indexing can be position-based, when accessing any of the attributes - [values][pydvl.value.result.ValuationResult.values], [variances][pydvl.value.result.ValuationResult.variances], [counts][pydvl.value.result.ValuationResult.counts] and [indices][pydvl.value.result.ValuationResult.indices], as + [values][pydvl.value.result.ValuationResult.values], [variances][pydvl.value.result.ValuationResult.variances], + [counts][pydvl.value.result.ValuationResult.counts] and [indices][pydvl.value.result.ValuationResult.indices], as well as when iterating over the object, or using the item access operator, both getter and setter. The "position" is either the original sequence in which the data was passed to the constructor, or the sequence in which the diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 61a2cd228..62ec04c3a 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -45,13 +45,28 @@ implementation of permutation MC. There are several pre-defined coefficients, including the Shapley value of -[@ghorbani_data_2019], the Banzhaf index of [@wang_data_2022], and the Beta -coefficient of [@kwon_beta_2022]. For each of these methods, there is a +(Ghorbani and Zou, 2019)[^1], the Banzhaf index of (Wang and Jia)[^3], and the Beta +coefficient of (Kwon and Zou, 2022)[^2]. For each of these methods, there is a convenience wrapper function. Respectively, these are: [compute_shapley_semivalues][pydvl.value.semivalues.compute_shapley_semivalues], [compute_banzhaf_semivalues][pydvl.value.semivalues.compute_banzhaf_semivalues], and [compute_beta_shapley_semivalues][pydvl.value.semivalues.compute_beta_shapley_semivalues]. instead. + + +# References: + +[^1]: Ghorbani, A., Zou, J., 2019. + [Data Shapley: Equitable Valuation of Data for Machine Learning](http://proceedings.mlr.press/v97/ghorbani19c.html). + In: Proceedings of the 36th International Conference on Machine Learning, PMLR, pp. 2242–2251. + +[^2]: Kwon, Y. and Zou, J., 2022. + [Beta Shapley: A Unified and Noise-reduced Data Valuation Framework for Machine Learning](http://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](http://arxiv.org/abs/2205.15466). + ArXiv preprint arXiv:2205.15466. """ from __future__ import annotations @@ -409,10 +424,15 @@ def compute_semivalues( - [SemiValueMode.Shapley][pydvl.value.semivalues.SemiValueMode]: Shapley values. - - [SemiValueMode.BetaShapley][pydvl.value.semivalues.SemiValueMode]: - Implements the Beta Shapley semi-value as introduced in [@kwon_beta_2022]. + - [SemiValueMode.BetaShapley][pydvl.value.semivalues.SemiValueMode.BetaShapley]: + Implements the Beta Shapley semi-value as introduced in + (Kwon and Zou, 2022)1. Pass additional keyword arguments `alpha` and `beta` to set the parameters of the Beta distribution (both default to 1). + - [SemiValueMode.Banzhaf][SemiValueMode.Banzhaf]: Implements the Banzhaf + semi-value as introduced in (Wang and Jia, 2022)1. + + See [[data-valuation]] for an overview of valuation. - [SemiValueMode.Banzhaf][pydvl.value.semivalues.SemiValueMode]: Implements the Banzhaf semi-value as introduced in [@wang_data_2022]. diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index 1d668e2c4..1ab20a07c 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -1,6 +1,6 @@ """ This module implements Group Testing for the approximation of Shapley values, as -introduced in [@jia_efficient_2019]. The sampling of index subsets is +introduced in (Jia, R. et al., 2019)[^1]. The sampling of index subsets is done in such a way that an approximation to the true Shapley values can be computed with guarantees. @@ -14,6 +14,11 @@ !!! tip "New in version 0.4.0" +# References: + +[^1]: Jia, R. et al., 2019. + [Towards Efficient Data Valuation Based on the Shapley Value](http://proceedings.mlr.press/v89/jia19a.html). + In: Proceedings of the 22nd International Conference on Artificial Intelligence and Statistics, pp. 1167–1176. PMLR. """ import logging from collections import namedtuple @@ -94,7 +99,7 @@ def h(u: T) -> T: def num_samples_eps_delta( eps: float, delta: float, n: int, utility_range: float ) -> int: - r"""Implements the formula in Theorem 3 of [@jia_efficient_2019] + r"""Implements the formula in Theorem 3 of (Jia, R. et al., 2019)1 which gives a lower bound on the number of samples required to obtain an (ε/√n,δ/(N(N-1))-approximation to all pair-wise differences of Shapley values, wrt. $\ell_2$ norm. @@ -162,7 +167,7 @@ def group_testing_shapley( **options, ) -> ValuationResult: """Implements group testing for approximation of Shapley values as described - in [@jia_efficient_2019]. + in (Jia, R. et al., 2019)1. !!! Warning This method is very inefficient. It requires several orders of magnitude diff --git a/src/pydvl/value/shapley/knn.py b/src/pydvl/value/shapley/knn.py index be6d02766..f3e2970e5 100644 --- a/src/pydvl/value/shapley/knn.py +++ b/src/pydvl/value/shapley/knn.py @@ -3,6 +3,14 @@ !!! Todo Implement approximate KNN computation for sublinear complexity) + + +# References: + +[^Y]: Jia, R. et al., 2019. + [Efficient Task-Specific Data Valuation for Nearest Neighbor Algorithms](https://doi.org/10.14778/3342263.3342637). + In: Proceedings of the VLDB Endowment, Vol. 12, No. 11, pp. 1610–1623. + """ from typing import Dict, Union @@ -21,15 +29,15 @@ def knn_shapley(u: Utility, *, progress: bool = True) -> ValuationResult: """Computes exact Shapley values for a KNN classifier. - This implements the method described in [@jia_efficient_2019a]. + This implements the method described in (Jia, R. et al., 2019)1. It exploits the local structure of K-Nearest Neighbours to reduce the number of calls to the utility function to a constant number per index, thus reducing computation time to $O(n)$. Args: u: Utility with a KNN model to extract parameters from. The object - will not be modified nor used other than to call `get_params() - `_ + will not be modified nor used other than to call [get_params()]( + ) progress: Whether to display a progress bar. Returns: diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index 2363747cd..e9d59445a 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -32,6 +32,13 @@ implemented in [group_testing_shapley()][pydvl.value.shapley.gt.group_testing_shapley]: any of the algorithms mentioned above, including Group Testing, can work to valuate groups of samples as units. + +# References: + +[^1]: Ghorbani, A., Zou, J., 2019. + [Data Shapley: Equitable Valuation of Data for Machine Learning](http://proceedings.mlr.press/v97/ghorbani19c.html). + In: Proceedings of the 36th International Conference on Machine Learning, PMLR, pp. 2242–2251. + """ from __future__ import annotations @@ -136,7 +143,7 @@ def permutation_montecarlo_shapley( where $\sigma_{:i}$ denotes the set of indices in permutation sigma before the position where $i$ appears (see [[data-valuation]] for details). - This implements the method described in [@ghorbani_data_2019] + This implements the method described in (Ghorbani and Zou, 2019)1 with a double stopping criterion. .. todo:: @@ -147,7 +154,8 @@ def permutation_montecarlo_shapley( to coalitions from a permutation and incrementally compute marginal utilities. We stop computing marginals for a given permutation based on a [TruncationPolicy][pydvl.value.shapley.truncated.TruncationPolicy]. - [@ghorbani_data_2019] mention two policies: one that stops after a certain + (Ghorbani and Zou, 2019)1 + mention two policies: one that stops after a certain fraction of marginals are computed, implemented in [FixedTruncation][pydvl.value.shapley.truncated.FixedTruncation], and one that stops if the last computed utility ("score") is close to the diff --git a/src/pydvl/value/shapley/owen.py b/src/pydvl/value/shapley/owen.py index 834678b94..86cfcf47f 100644 --- a/src/pydvl/value/shapley/owen.py +++ b/src/pydvl/value/shapley/owen.py @@ -1,3 +1,11 @@ +""" +# References: + +[^1]: Okhrati, R., Lipani, A., 2021. + [A Multilinear Sampling Algorithm to Estimate Shapley Values](https://ieeexplore.ieee.org/abstract/document/9412511). + In: 2020 25th International Conference on Pattern Recognition (ICPR), pp. 7992–7999. IEEE. +""" + import operator from enum import Enum from functools import reduce @@ -99,7 +107,7 @@ def owen_sampling_shapley( progress: bool = False, ) -> ValuationResult: r"""Owen sampling of Shapley values as described in - [@okhrati_multilinear_2021]. + (Okhrati and Lipani, 2021)1. This function computes a Monte Carlo approximation to diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index cd1249328..a49c58bf0 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -1,3 +1,11 @@ +""" +# References: + +[^1]: Ghorbani, A., Zou, J., 2019. + [Data Shapley: Equitable Valuation of Data for Machine Learning](http://proceedings.mlr.press/v97/ghorbani19c.html). + In: Proceedings of the 36th International Conference on Machine Learning, PMLR, pp. 2242–2251. + +""" import abc import logging from typing import cast @@ -82,8 +90,8 @@ def reset(self): class FixedTruncation(TruncationPolicy): """Break a permutation after computing a fixed number of marginals. - The experiments in Appendix B of [@ghorbani_data_2019] show that when the - training set size is large enough, one can simply truncate the iteration + The experiments in Appendix B of (Ghorbani and Zou, 2019)1 + show that when the training set size is large enough, one can simply truncate the iteration over permutations after a fixed number of steps. This happens because beyond a certain number of samples in a training set, the model becomes insensitive to new ones. Alas, this strongly depends on the data distribution and the @@ -113,7 +121,7 @@ def reset(self): class RelativeTruncation(TruncationPolicy): """Break a permutation if the marginal utility is too low. - This is called "performance tolerance" in [@ghorbani_data_2019]. + This is called "performance tolerance" in (Ghorbani and Zou, 2019)1. Args: u: Utility object with model, data, and scoring function diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index 3d44e4694..7ddaf1722 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -2,8 +2,9 @@ Stopping criteria for value computations. This module provides a basic set of stopping criteria, like [MaxUpdates][pydvl.value.stopping.MaxUpdates], -[MaxTime][pydvl.value.stopping.MaxTime], or [HistoryDeviation][pydvl.value.stopping.HistoryDeviation] among others. These can behave in -different ways depending on the context. For example, [MaxUpdates][pydvl.value.stopping.MaxUpdates] limits +[MaxTime][pydvl.value.stopping.MaxTime], or [HistoryDeviation][pydvl.value.stopping.HistoryDeviation] among others. +These can behave in different ways depending on the context. +For example, [MaxUpdates][pydvl.value.stopping.MaxUpdates] limits the number of updates to values, which depending on the algorithm may mean a different number of utility evaluations or imply other computations like solving a linear or quadratic program. @@ -29,6 +30,12 @@ (*not*) is also supported. See [StoppingCriterion][pydvl.value.stopping.StoppingCriterion] for details on how these operations affect the behavior of the stopping criteria. + +# References: + +[^1]: Ghorbani, A., Zou, J., 2019. + [Data Shapley: Equitable Valuation of Data for Machine Learning](http://proceedings.mlr.press/v97/ghorbani19c.html). + In: Proceedings of the 36th International Conference on Machine Learning, PMLR, pp. 2242–2251. """ from __future__ import annotations @@ -445,7 +452,7 @@ class HistoryDeviation(StoppingCriterion): r"""A simple check for relative distance to a previous step in the computation. - The method used by [@ghorbani_data_2019] computes the relative + The method used by (Ghorbani and Zou, 2019)1 computes the relative distances between the current values $v_i^t$ and the values at the previous checkpoint $v_i^{t-\tau}$. If the sum is below a given threshold, the computation is terminated. From 7a410b3f80237690ad1e3e144361fb9cabe80ab9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 31 Aug 2023 12:46:28 +0200 Subject: [PATCH 373/436] Fix linting issues in influence package --- src/pydvl/influence/general.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index 73c754a4a..e1fc32493 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -167,7 +167,7 @@ def compute_influences_up( def train_grads() -> Generator[TensorType, None, None]: for x, y in maybe_progress( - input_data, progress, desc="Batch Split Input Gradients" + input_data, progress, desc="Batch Split Input Gradients" ): yield stack( [model.grad(inpt, target) for inpt, target in zip(unsqueeze(x, 1), y)] @@ -322,4 +322,3 @@ def compute_influences( influence_factors, progress=progress, ) - From 8b4ca5bd5a24928674acd3e249ac9576b15e4a25 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 31 Aug 2023 13:55:58 +0200 Subject: [PATCH 374/436] Fix links and references in torch_differentiable.py --- src/pydvl/influence/torch/torch_differentiable.py | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/src/pydvl/influence/torch/torch_differentiable.py b/src/pydvl/influence/torch/torch_differentiable.py index 4992ddfcb..023a125e9 100644 --- a/src/pydvl/influence/torch/torch_differentiable.py +++ b/src/pydvl/influence/torch/torch_differentiable.py @@ -205,11 +205,12 @@ def mvp( @dataclass class LowRankProductRepresentation: r""" - Representation of a low rank product of the form \(H = V D V^T\), where D is a diagonal matrix and V is orthogonal. + Representation of a low rank product of the form \(H = V D V^T\), + where D is a diagonal matrix and V is orthogonal. Args: - eigen_vals (tensor or array): Diagonal of D. - projections (tensor or matrix): The matrix V. + eigen_vals: Diagonal of D. + projections: The matrix V. """ eigen_vals: torch.Tensor @@ -276,7 +277,7 @@ def lanzcos_low_rank_hessian_approx( not provided, it defaults to \( 10 \cdot \text{model.num_parameters}\). device: The device to use for executing the hessian vector product. eigen_computation_on_gpu: If True, tries to execute the eigen pair - approximation on the provided device via `cupy `_ + approximation on the provided device via [cupy](https://cupy.dev/) implementation. Ensure that either your model is small enough, or you use a small rank_estimate to fit your device's memory. If False, the eigen pair approximation is executed on the CPU with scipy's wrapper to @@ -608,7 +609,8 @@ def solve_cg( maxiter: Maximum number of iterations. If None, defaults to 10*len(b). Returns: - Instance of [InverseHvpResult], with a vector x, solution of \(Ax=b\), and a dictionary containing + Instance of [InverseHvpResult][pydvl.influence.twice_differentiable.InverseHvpResult], + with a vector x, solution of \(Ax=b\), and a dictionary containing information about the convergence of CG. """ From f967227c1c07e1470b7d4e4944eb2bcd811fa6c6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 31 Aug 2023 14:17:25 +0200 Subject: [PATCH 375/436] Update package list before installing pandoc --- .github/workflows/tox.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index 3464bcdc6..a92be0965 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -53,7 +53,7 @@ jobs: with: python_version: 3.8 - name: Install Pandoc - run: sudo apt-get install --no-install-recommends --yes pandoc + run: sudo apt-get update && sudo apt-get install --no-install-recommends --yes pandoc - name: Build Docs run: mkdocs build base-tests: From fbd8409c41f561135babba00319b357a39e1fbbf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 31 Aug 2023 14:25:01 +0200 Subject: [PATCH 376/436] Install pandoc-citeproc explicitly --- .github/workflows/tox.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index a92be0965..d7a0870d4 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -53,7 +53,7 @@ jobs: with: python_version: 3.8 - name: Install Pandoc - run: sudo apt-get update && sudo apt-get install --no-install-recommends --yes pandoc + run: sudo apt-get update && sudo apt-get install --no-install-recommends --yes pandoc-citeproc pandoc - name: Build Docs run: mkdocs build base-tests: From 7fcabf333b8040343c4f1d5e6114e0f5ba1f91ba Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 31 Aug 2023 14:26:54 +0200 Subject: [PATCH 377/436] Document type variables in twice differentiable module, small docstring fixes --- src/pydvl/influence/torch/util.py | 17 +++++++++++++++++ src/pydvl/influence/twice_differentiable.py | 11 ++++++++--- 2 files changed, 25 insertions(+), 3 deletions(-) diff --git a/src/pydvl/influence/torch/util.py b/src/pydvl/influence/torch/util.py index b7e0460ec..8347927f7 100644 --- a/src/pydvl/influence/torch/util.py +++ b/src/pydvl/influence/torch/util.py @@ -6,10 +6,26 @@ logger = logging.getLogger(__name__) +__all__ = [ + "to_model_device", + "flatten_tensors_to_vector", + "reshape_vector_to_tensors", + "TorchTensorContainerType", + "align_structure", + "as_tensor", +] + def to_model_device(x: torch.Tensor, model: torch.nn.Module) -> torch.Tensor: """ Returns the tensor `x` moved to the device of the `model`, if device of model is set + + Args: + x: The tensor to be moved to the device of the model. + model: The model whose device will be used to move the tensor. + + Returns: + The tensor `x` moved to the device of the `model`, if device of model is set. """ if hasattr(model, "device"): return x.to(model.device) @@ -81,6 +97,7 @@ def reshape_vector_to_tensors( Tuple[torch.Tensor, ...], Dict[str, torch.Tensor], ) +"""Type variable for a PyTorch tensor or a container thereof.""" def align_structure( diff --git a/src/pydvl/influence/twice_differentiable.py b/src/pydvl/influence/twice_differentiable.py index b7a2b8c1f..51700e89a 100644 --- a/src/pydvl/influence/twice_differentiable.py +++ b/src/pydvl/influence/twice_differentiable.py @@ -23,8 +23,13 @@ ] TensorType = TypeVar("TensorType", bound=Sequence) +"""Type variable for tensors, i.e. sequences of numbers""" + ModelType = TypeVar("ModelType", bound="TwiceDifferentiable") +"""Type variable for twice differentiable models""" + DataLoaderType = TypeVar("DataLoaderType", bound=Iterable) +"""Type variable for data loaders""" @dataclass(frozen=True) @@ -94,7 +99,7 @@ def hessian(self, x: TensorType, y: TensorType) -> TensorType: Returns: A tensor representing the Hessian of the model, i.e. the second derivative - with respect to the model parameters. + with respect to the model parameters. """ pass @@ -123,7 +128,7 @@ def mvp( Returns: A matrix representing the implicit matrix-vector product of the model along the given directions. - Output shape is [DxM], where \(M\) is the number of elements of `backprop_on`. + Output shape is [DxM], where \(M\) is the number of elements of `backprop_on`. """ @@ -159,7 +164,7 @@ def __init_subclass__(cls, **kwargs): @staticmethod @abstractmethod def einsum(equation, *operands) -> TensorType: - """Sums the product of the elements of the input :attr:`operands` along dimensions specified using a notation + """Sums the product of the elements of the input `operands` along dimensions specified using a notation based on the Einstein summation convention. """ From 2f6715c5c40555618c138db5716b3ae927169686 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 31 Aug 2023 14:36:17 +0200 Subject: [PATCH 378/436] Small docstring fix for + or - symbol --- src/pydvl/reporting/plots.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/pydvl/reporting/plots.py b/src/pydvl/reporting/plots.py index d0fee5377..3d1090b14 100644 --- a/src/pydvl/reporting/plots.py +++ b/src/pydvl/reporting/plots.py @@ -21,12 +21,12 @@ def shaded_mean_std( ax: Optional[Axes] = None, **kwargs, ) -> Axes: - """The usual mean +- std deviation plot to aggregate runs of experiments. + """The usual mean \(\pm\) std deviation plot to aggregate runs of experiments. Args: data: axis 0 is to be aggregated on (e.g. runs) and axis 1 is the data for each run. - abscissa: values for the x axis. Leave empty to use increasing integers. + abscissa: values for the x-axis. Leave empty to use increasing integers. num_std: number of standard deviations to shade around the mean. mean_color: color for the mean shade_color: color for the shaded region From d4e008e4290a62ae6a46ce6044f13a67dc68f1d0 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 31 Aug 2023 14:48:11 +0200 Subject: [PATCH 379/436] Add pymemcache inventory --- mkdocs.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/mkdocs.yml b/mkdocs.yml index 2fad8c380..d7b27fbbd 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -64,6 +64,7 @@ plugins: - https://pandas.pydata.org/docs/objects.inv - https://scikit-learn.org/stable/objects.inv - https://pytorch.org/docs/stable/objects.inv + - https://pymemcache.readthedocs.io/en/latest/objects.inv paths: [ src ] # search packages in the src folder options: docstring_style: google From 7e8db8c96dcd4174ed1296c71611c3de86f7e374 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 31 Aug 2023 14:48:25 +0200 Subject: [PATCH 380/436] Small docstring fixes for cache module --- src/pydvl/utils/caching.py | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/src/pydvl/utils/caching.py b/src/pydvl/utils/caching.py index 233dec86e..8be6dda32 100644 --- a/src/pydvl/utils/caching.py +++ b/src/pydvl/utils/caching.py @@ -34,7 +34,6 @@ serde=serde.PickleSerde(pickle_version=PICKLE_VERSION) ) ``` -.. _caching stochastic functions: # Usage with stochastic functions @@ -129,7 +128,13 @@ class CacheStats: def serialize(x: Any) -> bytes: - """Serialize an object to bytes.""" + """Serialize an object to bytes. + Args: + x: object to serialize. + + Returns: + serialized object. + """ pickled_output = BytesIO() pickler = Pickler(pickled_output, PICKLE_VERSION) pickler.dump(x) @@ -169,8 +174,8 @@ def memcached( ``` Args: - client_config: configuration for `pymemcache's Client() - `_. + client_config: configuration for pymemcache's + [Client][pymemcache.client.base.Client]. Will be merged on top of the default configuration (see below). time_threshold: computations taking less time than this many seconds are not cached. @@ -188,7 +193,7 @@ def memcached( ignore_args: Do not take these keyword arguments into account when hashing the wrapped function for usage as key in memcached. This allows sharing the cache among different jobs for the same experiment run if - the callable happens to have "nuisance" parameters like "job_id" which + the callable happens to have "nuisance" parameters like `job_id` which do not affect the result of the computation. Returns: From bcf1657643c77b29524c195fc271f37d26d77395 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 31 Aug 2023 15:03:47 +0200 Subject: [PATCH 381/436] Add examples to dataset constructor class methods --- src/pydvl/utils/dataset.py | 83 +++++++++++++++++++++++++++++++------- 1 file changed, 68 insertions(+), 15 deletions(-) diff --git a/src/pydvl/utils/dataset.py b/src/pydvl/utils/dataset.py index 607e52ac3..12a123806 100644 --- a/src/pydvl/utils/dataset.py +++ b/src/pydvl/utils/dataset.py @@ -257,15 +257,23 @@ def from_sklearn( ) -> "Dataset": """Constructs a [Dataset][pydvl.utils.Dataset] object from a [sklearn.utils.Bunch][sklearn.utils.Bunch], as returned by the `load_*` - functions in [sklearn toy datasets](https://scikit-learn.org/stable/datasets/toy_dataset.html). + functions in [scikit-learn toy datasets](https://scikit-learn.org/stable/datasets/toy_dataset.html). + + ??? Example + ```pycon + >>> from pydvl.utils import Dataset + >>> from sklearn.datasets import load_boston + >>> dataset = Dataset.from_sklearn(load_boston()) + ``` Args: - data: sklearn dataset. The following attributes are supported - - `data`: covariates [required] - - `target`: target variables (labels) [required] - - `feature_names`: the feature names - - `target_names`: the target names - - `DESCR`: a description + data: scikit-learn Bunch object. The following attributes are supported: + + - `data`: covariates. + - `target`: target variables (labels). + - `feature_names` (**optional**): the feature names. + - `target_names` (**optional**): the target names. + - `DESCR` (**optional**): a description. train_size: size of the training dataset. Used in `train_test_split` random_state: seed for train / test split stratify_by_target: If `True`, data is split in a stratified @@ -311,6 +319,14 @@ def from_arrays( """Constructs a [Dataset][pydvl.utils.Dataset] object from X and y numpy arrays as returned by the `make_*` functions in [sklearn generated datasets](https://scikit-learn.org/stable/datasets/sample_generators.html). + ??? Example + ```pycon + >>> from pydvl.utils import Dataset + >>> from sklearn.datasets import make_regression + >>> X, y = make_regression() + >>> dataset = Dataset.from_arrays(X, y) + ``` + Args: X: numpy array of shape (n_samples, n_features) y: numpy array of shape (n_samples,) @@ -456,16 +472,26 @@ def from_sklearn( ) -> "GroupedDataset": """Constructs a [GroupedDataset][pydvl.utils.GroupedDataset] object from a [sklearn.utils.Bunch][sklearn.utils.Bunch] as returned by the `load_*` functions in - [sklearn toy datasets](https://scikit-learn.org/stable/datasets/toy_dataset.html) and groups + [scikit-learn toy datasets](https://scikit-learn.org/stable/datasets/toy_dataset.html) and groups it. + ??? Example + ```pycon + >>> from sklearn.datasets import load_iris + >>> from pydvl.utils import GroupedDataset + >>> iris = load_iris() + >>> data_groups = iris.data[:, 0] // 0.5 + >>> dataset = GroupedDataset.from_sklearn(iris, data_groups=data_groups) + ``` + Args: - data: sklearn dataset. The following attributes are supported - - `data`: covariates [required] - - `target`: target variables (labels) [required] - - `feature_names`: the feature names - - `target_names`: the target names - - `DESCR`: a description + data: scikit-learn Bunch object. The following attributes are supported: + + - `data`: covariates. + - `target`: target variables (labels). + - `feature_names` (**optional**): the feature names. + - `target_names` (**optional**): the target names. + - `DESCR` (**optional**): a description. train_size: size of the training dataset. Used in `train_test_split`. random_state: seed for train / test split. stratify_by_target: If `True`, data is split in a stratified @@ -512,7 +538,23 @@ def from_arrays( ) -> "Dataset": """Constructs a [GroupedDataset][pydvl.utils.GroupedDataset] object from X and y numpy arrays as returned by the `make_*` functions in - [sklearn generated datasets](https://scikit-learn.org/stable/datasets/sample_generators.html). + [scikit-learn generated datasets](https://scikit-learn.org/stable/datasets/sample_generators.html). + + ??? Example + ```pycon + >>> from sklearn.datasets import make_classification + >>> from pydvl.utils import GroupedDataset + >>> X, y = make_classification( + ... n_samples=100, + ... n_features=4, + ... n_informative=2, + ... n_redundant=0, + ... random_state=0, + ... shuffle=False + ... ) + >>> data_groups = X[:, 0] // 0.5 + >>> dataset = GroupedDataset.from_arrays(X, y, data_groups=data_groups) + ``` Args: X: array of shape (n_samples, n_features) @@ -561,6 +603,17 @@ def from_dataset( """Creates a [GroupedDataset][pydvl.utils.GroupedDataset] object from the data a [Dataset][pydvl.utils.Dataset] object and a mapping of data groups. + ??? Example + ```pycon + >>> import numpy as np + >>> from pydvl.utils import Dataset, GroupedDataset + >>> dataset = Dataset.from_arrays( + ... X=np.asarray([[1, 2], [3, 4], [5, 6], [7, 8]]), + ... y=np.asarray([0, 1, 0, 1]), + ... ) + >>> dataset = GroupedDataset.from_dataset(dataset, data_groups=[0, 0, 1, 1]) + ``` + Args: dataset: The original data. data_groups: An array holding the group index or name for each data From 0eede1cfc02429147edf73c9a095d42b3b247765 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 31 Aug 2023 15:13:37 +0200 Subject: [PATCH 382/436] Fix Data Utility Learning reference --- src/pydvl/utils/utility.py | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/src/pydvl/utils/utility.py b/src/pydvl/utils/utility.py index f263200af..c35bec98e 100644 --- a/src/pydvl/utils/utility.py +++ b/src/pydvl/utils/utility.py @@ -15,6 +15,12 @@ This module also contains Utility classes for toy games that are used for testing and for demonstration purposes. +## References: + +[^1]: Wang, T., Yang, Y. and Jia, R., 2021. + [Improving cooperative game theory-based data valuation via data utility learning](https://arxiv.org/abs/2107.06336). + arXiv preprint arXiv:2107.06336. + """ import logging import warnings @@ -74,9 +80,10 @@ class Utility: ranges. Args: - model: Any supervised model. Typical choices can be found at - https://scikit-learn.org/stable/supervised_learning.html - data: Dataset or GroupedDataset instance. + model: Any supervised model. Typical choices can be found in the + [sci-kit learn documentation][https://scikit-learn.org/stable/supervised_learning.html]. + data: [Dataset][pydvl.utils.dataset.Dataset] + or [GroupedDataset][pydvl.utils.dataset.GroupedDataset] instance. scorer: A scoring object. If None, the `score()` method of the model will be used. See [score][pydvl.utils.score] for ways to create and compose scorers, in particular how to set default values and ranges. @@ -266,7 +273,8 @@ def __setstate__(self, state): class DataUtilityLearning: - """Implementation of Data Utility Learning [@wang_improving_2022]. + """Implementation of Data Utility Learning + (Wang et al., 2022)1. This object wraps a [Utility][pydvl.utils.utility.Utility] and delegates calls to it, up until a given budget (number of iterations). Every tuple From 925f81083f4b8f6664fc36b09581dfbe5f00fe67 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 31 Aug 2023 15:18:13 +0200 Subject: [PATCH 383/436] Fix RayExecutor docstrings --- src/pydvl/utils/parallel/futures/ray.py | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/src/pydvl/utils/parallel/futures/ray.py b/src/pydvl/utils/parallel/futures/ray.py index 77db40a10..677320396 100644 --- a/src/pydvl/utils/parallel/futures/ray.py +++ b/src/pydvl/utils/parallel/futures/ray.py @@ -114,7 +114,8 @@ def submit(self, fn: Callable[..., T], *args, **kwargs) -> "Future[T]": Returns: A Future representing the given call. - :raises RuntimeError: If a task is submitted after the executor has been shut down. + Raises: + RuntimeError: If a task is submitted after the executor has been shut down. """ with self._shutdown_lock: logger.debug("executor acquired shutdown lock") @@ -141,16 +142,18 @@ def shutdown( ) -> None: """Clean up the resources associated with the Executor. - This method tries to mimic the behaviour of :meth:`Executor.shutdown` + This method tries to mimic the behaviour of + [Executor.shutdown][concurrent.futures.Executor.shutdown] while allowing one more value for ``cancel_futures`` which instructs it - to use the :class:`CancellationPolicy` defined upon construction. - - :param wait: Whether to wait for pending futures to finish. - :param cancel_futures: Overrides the executor's default policy for - cancelling futures on exit. If ``True``, all pending futures are - cancelled, and if ``False``, no futures are cancelled. If ``None`` - (default), the executor's policy set at initialization is used. - :return: + to use the [CancellationPolicy][pydvl.utils.parallel.backend.CancellationPolicy] + defined upon construction. + + Args: + wait: Whether to wait for pending futures to finish. + cancel_futures: Overrides the executor's default policy for + cancelling futures on exit. If ``True``, all pending futures are + cancelled, and if ``False``, no futures are cancelled. If ``None`` + (default), the executor's policy set at initialization is used. """ logger.debug("executor shutting down") with self._shutdown_lock: @@ -198,7 +201,7 @@ def __exit__(self, exc_type, exc_val, exc_tb): class _WorkItem: - """Inspired by code from: concurrent.futures.thread""" + """Inspired by code from: [concurrent.futures.thread][]""" def __init__( self, From 200adaf0f666aa00a3e4f6b5294dbfe639b81e36 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 31 Aug 2023 15:52:04 +0200 Subject: [PATCH 384/436] Install pandoc manually --- .github/workflows/tox.yaml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index d7a0870d4..1830a2001 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -53,7 +53,9 @@ jobs: with: python_version: 3.8 - name: Install Pandoc - run: sudo apt-get update && sudo apt-get install --no-install-recommends --yes pandoc-citeproc pandoc + run: | + wget https://github.com/jgm/pandoc/releases/download/3.1.6.2/pandoc-3.1.6.2-1-amd64.deb -O pandoc.deb + sudo dpkg -i pandoc.deb - name: Build Docs run: mkdocs build base-tests: From 6e9a1208f6715930658a1a06b2ef0201d958dcad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 31 Aug 2023 16:03:35 +0200 Subject: [PATCH 385/436] Use github action instead of manual install --- .github/workflows/tox.yaml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index 1830a2001..e99106a37 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -53,9 +53,9 @@ jobs: with: python_version: 3.8 - name: Install Pandoc - run: | - wget https://github.com/jgm/pandoc/releases/download/3.1.6.2/pandoc-3.1.6.2-1-amd64.deb -O pandoc.deb - sudo dpkg -i pandoc.deb + uses: r-lib/actions/setup-pandoc@v2 + with: + pandoc-version: '3.1.6.2' - name: Build Docs run: mkdocs build base-tests: From 18b4268ba623fc7e386678bb5e8ef70e028c5788 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 31 Aug 2023 19:21:59 +0200 Subject: [PATCH 386/436] Put branch condition on entire push-docs-and-release-testpypi CI job --- .github/workflows/tox.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index e99106a37..3f81f495c 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -92,6 +92,7 @@ jobs: name: Push Docs and maybe release Package to TestPyPI runs-on: ubuntu-latest needs: [docs, base-tests, torch-tests, notebook-tests] + if: ${{ github.ref == 'refs/heads/develop' }} concurrency: group: publish steps: @@ -111,7 +112,6 @@ jobs: email: ${{ env.GITHUB_BOT_EMAIL }} username: ${{ env.GITHUB_BOT_USERNAME }} - name: Build and publish to TestPyPI - if: ${{ github.ref == 'refs/heads/develop' }} env: TWINE_USERNAME: __token__ TWINE_PASSWORD: ${{ secrets.TEST_PYPI_PASSWORD }} From 2a5cb2f7863f276cbb3ab4e1fd0900bd2f8eb88f Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 31 Aug 2023 19:23:13 +0200 Subject: [PATCH 387/436] Install pandoc before Deploy Docs step on CI --- .github/workflows/tox.yaml | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index 3f81f495c..76c4195d7 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -17,6 +17,7 @@ env: GITHUB_BOT_EMAIL: 41898282+github-actions[bot]@users.noreply.github.com PY_COLORS: 1 MYPY_FORCE_COLOR: 1 + PANDOC_VERSION: '3.1.6.2' jobs: code-quality: @@ -55,7 +56,7 @@ jobs: - name: Install Pandoc uses: r-lib/actions/setup-pandoc@v2 with: - pandoc-version: '3.1.6.2' + pandoc-version: ${{ env.PANDOC_VERSION }} - name: Build Docs run: mkdocs build base-tests: @@ -103,6 +104,10 @@ jobs: uses: ./.github/actions/python with: python_version: 3.8 + - name: Install Pandoc + uses: r-lib/actions/setup-pandoc@v2 + with: + pandoc-version: ${{ env.PANDOC_VERSION }} - name: Deploy Docs uses: ./.github/actions/deploy-docs with: From 40971adc64b1518c9b4876f2961fca7b803c6f41 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Tue, 29 Aug 2023 23:42:43 +0200 Subject: [PATCH 388/436] Add Seed type to `pydvl.utils.types`. --- src/pydvl/utils/types.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index 9c51d629e..d19b5cae3 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -5,8 +5,9 @@ import inspect from abc import ABCMeta -from typing import Any, Callable, Protocol, TypeVar +from typing import Any, Callable, Optional, Protocol, TypeVar, Union +from numpy.random import Generator, SeedSequence from numpy.typing import NDArray __all__ = ["SupervisedModel", "MapFunction", "ReduceFunction", "NoPublicConstructor"] @@ -92,3 +93,6 @@ def __call__(cls, *args, **kwargs): def create(cls, *args: Any, **kwargs: Any): return super().__call__(*args, **kwargs) + + +Seed = Union[int, Generator] From a798b391d01bfa323a7c9e3faa6435e01e1c0f0a Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Tue, 29 Aug 2023 23:46:41 +0200 Subject: [PATCH 389/436] Add seed parameter to :func:`pydvl.utils.numeric.random_subset`, :func:`pydvl.utils.numeric.random_powerset` and :func:`pydvl.utils.numeric.random_subset_of_size`. Add test case for checking reproduce-ability. --- src/pydvl/utils/numeric.py | 40 ++++++++++++++++++----- tests/conftest.py | 10 ++++++ tests/utils/test_numeric.py | 63 +++++++++++++++++++++++++++++++++++++ 3 files changed, 106 insertions(+), 7 deletions(-) diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index c639da82b..c9ade3d59 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -10,6 +10,8 @@ import numpy as np from numpy.typing import NDArray +from pydvl.utils.types import Seed + __all__ = [ "running_moments", "num_samples_permutation_hoeffding", @@ -19,6 +21,7 @@ "random_powerset", "random_subset_of_size", "top_k_value_accuracy", + "sets_are_equal", ] T = TypeVar("T", bound=np.generic) @@ -59,21 +62,29 @@ def num_samples_permutation_hoeffding(eps: float, delta: float, u_range: float) return int(np.ceil(np.log(2 / delta) * 2 * u_range**2 / eps**2)) -def random_subset(s: NDArray[T], q: float = 0.5) -> NDArray[T]: +def random_subset( + s: NDArray[T], + q: float = 0.5, + seed: Optional[Seed] = None, +) -> NDArray[T]: """Returns one subset at random from ``s``. :param s: set to sample from :param q: Sampling probability for elements. The default 0.5 yields a uniform distribution over the power set of s. + :param seed: Either an instance of a numpy random number generator or a seed for it. :return: the subset """ - rng = np.random.default_rng() + rng = np.random.default_rng(seed) selection = rng.uniform(size=len(s)) > q return s[selection] def random_powerset( - s: NDArray[T], n_samples: Optional[int] = None, q: float = 0.5 + s: NDArray[T], + n_samples: Optional[int] = None, + q: float = 0.5, + seed: Optional[Seed] = None, ) -> Generator[NDArray[T], None, None]: """Samples subsets from the power set of the argument, without pre-generating all subsets and in no order. @@ -91,6 +102,7 @@ def random_powerset( Defaults to `np.iinfo(np.int32).max` :param q: Sampling probability for elements. The default 0.5 yields a uniform distribution over the power set of s. + :param seed: Either an instance of a numpy random number generator or a seed for it. :return: Samples from the power set of s :raises: TypeError: if the data `s` is not a NumPy array @@ -102,30 +114,40 @@ def random_powerset( if q < 0 or q > 1: raise ValueError("Element sampling probability must be in [0,1]") + rng = np.random.default_rng(seed) total = 1 if n_samples is None: n_samples = np.iinfo(np.int32).max while total <= n_samples: - yield random_subset(s, q) + yield random_subset(s, q, seed=rng) total += 1 -def random_subset_of_size(s: NDArray[T], size: int) -> NDArray[T]: +def random_subset_of_size( + s: NDArray[T], + size: int, + seed: Optional[Seed] = None, +) -> NDArray[T]: """Samples a random subset of given size uniformly from the powerset of ``s``. :param s: Set to sample from :param size: Size of the subset to generate + :param seed: Either an instance of a numpy random number generator or a seed for it. :return: The subset :raises ValueError: If size > len(s) """ if size > len(s): raise ValueError("Cannot sample subset larger than set") - rng = np.random.default_rng() + rng = np.random.default_rng(seed) return rng.choice(s, size=size, replace=False) -def random_matrix_with_condition_number(n: int, condition_number: float) -> NDArray: +def random_matrix_with_condition_number( + n: int, + condition_number: float, + # TODO Add seed parameter +) -> NDArray: """Constructs a square matrix with a given condition number. Taken from: @@ -227,3 +249,7 @@ def top_k_value_accuracy( top_k_pred_values = np.argsort(y_pred)[-k:] top_k_accuracy = len(np.intersect1d(top_k_exact_values, top_k_pred_values)) / k return top_k_accuracy + + +def sets_are_equal(subset_1: NDArray[np.int_], subset_2: NDArray[np.int_]): + return list(subset_1) == list(subset_2) diff --git a/tests/conftest.py b/tests/conftest.py index 9d82da504..2cf9de4f8 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -59,6 +59,16 @@ def seed(request): return 24 +@pytest.fixture() +def seed_alt(request): + return 42 + + +@pytest.fixture() +def collision_tol(request): + return 0.01 + + @pytest.fixture(autouse=True) def pytorch_seed(seed): try: diff --git a/tests/utils/test_numeric.py b/tests/utils/test_numeric.py index e6101defb..12168455d 100644 --- a/tests/utils/test_numeric.py +++ b/tests/utils/test_numeric.py @@ -1,5 +1,6 @@ import numpy as np import pytest +from numpy._typing import NDArray from pydvl.utils.numeric import ( powerset, @@ -7,6 +8,7 @@ random_powerset, random_subset_of_size, running_moments, + sets_are_equal, ) @@ -68,6 +70,37 @@ def test_random_powerset(n, max_subsets): ) +@pytest.mark.parametrize("n, max_subsets", [(10, 2**10)]) +def test_random_powerset_reproducible(n, max_subsets, seed): + """ + Test that the same seeds produce the same results, and different seeds produce + different results for method :func:`random_powerset`. + """ + s = np.arange(n) + parallel_subset_generators = zip( + random_powerset(s, n_samples=max_subsets, seed=seed), + random_powerset(s, n_samples=max_subsets, seed=seed), + ) + + n_collisions = sum(map(lambda t: sets_are_equal(*t), parallel_subset_generators)) + assert n_collisions == max_subsets + + +@pytest.mark.parametrize("n, max_subsets", [(10, 2**10)]) +def test_random_powerset_stochastic(n, max_subsets, seed, seed_alt, collision_tol): + """ + Test that the same seeds produce the same results, and different seeds produce + different results for method :func:`random_powerset`. + """ + s = np.arange(n) + parallel_subset_generators = zip( + random_powerset(s, n_samples=max_subsets, seed=seed), + random_powerset(s, n_samples=max_subsets, seed=seed_alt), + ) + n_collisions = sum(map(lambda t: sets_are_equal(*t), parallel_subset_generators)) + assert n_collisions / max_subsets < collision_tol + + @pytest.mark.parametrize( "n, size, exception", [(0, 0, None), (0, 1, ValueError), (10, 0, None), (10, 3, None), (1000, 40, None)], @@ -83,6 +116,36 @@ def test_random_subset_of_size(n, size, exception): assert np.all([x in s for x in ss]) +@pytest.mark.parametrize( + "n, size", + [(10, 3), (1000, 40)], +) +def test_random_subset_of_size_stochastic(n, size, seed, seed_alt): + """ + Test that the same seeds produce the same results, and different seeds produce + different results for method :func:`random_subset_of_size`. + """ + s = np.arange(n) + subset_1 = random_subset_of_size(s, size=size, seed=seed) + subset_2 = random_subset_of_size(s, size=size, seed=seed_alt) + assert not sets_are_equal(subset_1, subset_2) + + +@pytest.mark.parametrize( + "n, size", + [(10, 3), (1000, 40)], +) +def test_random_subset_of_size_stochastic(n, size, seed): + """ + Test that the same seeds produce the same results, and different seeds produce + different results for method :func:`random_subset_of_size`. + """ + s = np.arange(n) + subset_1 = random_subset_of_size(s, size=size, seed=seed) + subset_2 = random_subset_of_size(s, size=size, seed=seed) + assert sets_are_equal(subset_1, subset_2) + + @pytest.mark.parametrize( "n, cond, exception", [ From 4e68acf0efa9acb752c624d54548548cad11903f Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Wed, 30 Aug 2023 00:49:34 +0200 Subject: [PATCH 390/436] Add seed parameter to :func:`pydvl.utils.parallel.map_reduce.MapReduceJob.__call__`. Create function :func:`pydvl.utils.parallel.check_fn_accepts_parameter` and :func:`pydvl.utils.types.ensure_seedsequence`. And add test case for testing the reproduce-ability. --- src/pydvl/utils/parallel/check.py | 47 +++++++++++++++++++++++++ src/pydvl/utils/parallel/map_reduce.py | 37 ++++++++++++++++++-- src/pydvl/utils/types.py | 22 ++++++++++++ tests/utils/test_parallel.py | 48 ++++++++++++++++++++++++++ 4 files changed, 151 insertions(+), 3 deletions(-) create mode 100644 src/pydvl/utils/parallel/check.py diff --git a/src/pydvl/utils/parallel/check.py b/src/pydvl/utils/parallel/check.py new file mode 100644 index 000000000..bd95a6fe1 --- /dev/null +++ b/src/pydvl/utils/parallel/check.py @@ -0,0 +1,47 @@ +import inspect +from functools import partial +from typing import Callable + + +def check_fn_accepts_parameter(fn: Callable, param_name: str) -> bool: + """ + Checks whether the given function accepts the given parameter or not. + + :param fn: The function to check. + :param param_name: The name of the parameter to check. + + :return: True if the function accepts the parameter, False otherwise. + """ + args_set_by_partial = set() + + # Recursive function to go through nested functools.partial objects + def check_partial(g: Callable): + nonlocal args_set_by_partial + + # If the function is a functools.partial, get the original function + if isinstance(g, partial): + args_set_by_partial.update(g.keywords.keys()) + args_set_by_partial.update(g.args) + return check_partial(g.func) + else: + return g + + # Get the original function from functools.partial if needed + original_function = check_partial(fn) + + sig = inspect.signature(original_function) + params = sig.parameters + + # Check if the parameter was set by functools.partial + if param_name in args_set_by_partial: + return False + + # Check if the function accepts the specific parameter + if param_name in params: + return True + + # Check if the function accepts **kwargs + if any(p.kind == p.VAR_KEYWORD for p in params.values()): + return True + + return False diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index d40d3f1a6..45f79f3e1 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -1,12 +1,21 @@ from itertools import accumulate, repeat from typing import Any, Collection, Dict, Generic, List, Optional, TypeVar, Union +import numpy as np from joblib import Parallel, delayed +from numpy.random import SeedSequence from numpy.typing import NDArray from ..config import ParallelConfig -from ..types import MapFunction, ReduceFunction, maybe_add_argument +from ..types import ( + MapFunction, + ReduceFunction, + Seed, + ensure_seed_sequence, + maybe_add_argument, +) from .backend import init_parallel_backend +from .check import check_fn_accepts_parameter __all__ = ["MapReduceJob"] @@ -98,19 +107,41 @@ def __init__( def __call__( self, + seed: Optional[Seed] = None, ) -> R: + """ + Runs the map-reduce job. + + :param seed: Either an instance of a numpy random number generator or a seed + for it. + + :return: The result of the reduce function. + """ if self.config.backend == "joblib": backend = "loky" else: backend = self.config.backend + # In joblib the levels are reversed. # 0 means no logging and 50 means log everything to stdout verbose = 50 - self.config.logging_level + seed_seq = ensure_seed_sequence(seed) with Parallel(backend=backend, n_jobs=self.n_jobs, verbose=verbose) as parallel: chunks = self._chunkify(self.inputs_, n_chunks=self.n_jobs) + + # Allow functions which don't accept or need a seed parameter. + lst_add_kwargs: List[Dict[str, Union[int, SeedSequence]]] = [ + {"job_id": j} for j in range(len(chunks)) + ] + if check_fn_accepts_parameter(self._map_func, "seed"): + lst_add_kwargs = [ + {**d, **{"seed": seed.entropy}} + for d, seed in zip(lst_add_kwargs, seed_seq.spawn(len(chunks))) + ] + map_results: List[R] = parallel( - delayed(self._map_func)(next_chunk, job_id=j, **self.map_kwargs) - for j, next_chunk in enumerate(chunks) + delayed(self._map_func)(next_chunk, **add_kwargs, **self.map_kwargs) + for next_chunk, add_kwargs in zip(chunks, lst_add_kwargs) ) reduce_results: R = self._reduce_func(map_results, **self.reduce_kwargs) return reduce_results diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index d19b5cae3..aa877a196 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -3,6 +3,7 @@ """ from __future__ import annotations +import functools import inspect from abc import ABCMeta from typing import Any, Callable, Optional, Protocol, TypeVar, Union @@ -60,6 +61,7 @@ def maybe_add_argument(fun: Callable, new_arg: str): if new_arg in params.keys(): return fun + @functools.wraps(fun) def wrapper(*args, **kwargs): try: del kwargs[new_arg] @@ -96,3 +98,23 @@ def create(cls, *args: Any, **kwargs: Any): Seed = Union[int, Generator] + + +def ensure_seed_sequence( + seed: Optional[Union[Seed, SeedSequence]] = None +) -> SeedSequence: + """ + If the passed seed is a SeedSequence object then it is returned as is. If it is + a Generator the internal protected seed sequence from the generator gets extracted. + Otherwise, a new SeedSequence object is created from the passed (optional) seed. + + :param seed: Either an int, a Generator object a SeedSequence object or None. + + :returns: A SeedSequence object. + """ + if isinstance(seed, SeedSequence): + return seed + elif isinstance(seed, Generator): + return seed.bit_generator._seed_seq # noqa + else: + return SeedSequence(seed) diff --git a/tests/utils/test_parallel.py b/tests/utils/test_parallel.py index e3b3fa0fc..29f57eacb 100644 --- a/tests/utils/test_parallel.py +++ b/tests/utils/test_parallel.py @@ -2,6 +2,7 @@ import os import time from functools import partial, reduce +from typing import List, Optional import numpy as np import pytest @@ -9,6 +10,7 @@ from pydvl.utils.parallel import MapReduceJob, init_parallel_backend from pydvl.utils.parallel.backend import effective_n_jobs from pydvl.utils.parallel.futures import init_executor +from pydvl.utils.types import Seed def test_effective_n_jobs(parallel_config, num_workers): @@ -145,6 +147,40 @@ def reduce_func(x, y): assert result == 150 +def test_map_reduce_reproducible(parallel_config, seed, seed_alt): + """ + Test that the same result is obtained when using the same seed. And that different + results are obtained when using different seeds. + """ + + map_reduce_job = MapReduceJob( + None, + map_func=_sum_of_random_integers, + reduce_func=_mean_func, + config=parallel_config, + ) + result_1 = map_reduce_job(seed=seed) + result_2 = map_reduce_job(seed=seed) + assert result_1 == result_2 + + +def test_map_reduce_stochastic(parallel_config, seed, seed_alt): + """ + Test that the same result is obtained when using the same seed. And that different + results are obtained when using different seeds. + """ + + map_reduce_job = MapReduceJob( + None, + map_func=_sum_of_random_integers, + reduce_func=_mean_func, + config=parallel_config, + ) + result_1 = map_reduce_job(seed=seed) + result_2 = map_reduce_job(seed=seed_alt) + assert result_1 != result_2 + + def test_wrap_function(parallel_config, num_workers): if parallel_config.backend != "ray": pytest.skip("Only makes sense for ray") @@ -229,3 +265,15 @@ def test_future_cancellation(parallel_config): future.result() assert time.monotonic() - start < 1 + + +# Helper functions for tests :func:`test_map_reduce_reproducible` and +# :func:`test_map_reduce_stochastic`. +def _sum_of_random_integers(x: None, seed: Optional[Seed] = None): + rng = np.random.default_rng(seed) + values = rng.integers(0, rng.integers(100), 10) + return np.sum(values) + + +def _mean_func(means): + return np.mean(means) From b78dc1418d9506b7b667b11fdb7ed3b2d5ebd178 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Wed, 30 Aug 2023 00:55:39 +0200 Subject: [PATCH 391/436] Add seed parameter to :func:`pydvl.value.result.ValuationResult`. --- src/pydvl/value/result.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index 219b8ea90..c91b16a26 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -66,6 +66,7 @@ from pydvl.utils.dataset import Dataset from pydvl.utils.numeric import running_moments from pydvl.utils.status import Status +from pydvl.utils.types import Seed try: import pandas # Try to import here for the benefit of mypy @@ -657,7 +658,11 @@ def to_dataframe( @classmethod def from_random( - cls, size: int, total: Optional[float] = None, **kwargs + cls, + size: int, + total: Optional[float] = None, + seed: Optional[Seed] = None, + **kwargs, ) -> "ValuationResult": """Creates a :class:`ValuationResult` object and fills it with an array of random values from a uniform distribution in [-1,1]. The values can @@ -668,6 +673,9 @@ def from_random( ("efficiency" property of Shapley values). :param kwargs: Additional options to pass to the constructor of :class:`ValuationResult`. Use to override status, names, etc. + :param seed: Either an instance of a numpy random number generator or a seed for + it. + :return: A valuation result with its status set to :attr:`Status.Converged` by default. :raises ValueError: If ``size`` is less than 1. @@ -678,7 +686,8 @@ def from_random( if size < 1: raise ValueError("Size must be a positive integer") - values = np.random.uniform(low=-1, high=1, size=size) + rng = np.random.default_rng(seed) + values = rng.uniform(low=-1, high=1, size=size) if total is not None: values *= total / np.sum(values) From 743618990993405c0722677a4a058f624e43c549 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Wed, 30 Aug 2023 06:17:44 +0200 Subject: [PATCH 392/436] Add class `pydvl.value.sampler.StochasticSampler` with seed property. Derive stochastic samplers from `pydvl.value.sampler.StochasticSampler`. Add test cases for reproducibility and stochasticity. --- src/pydvl/value/sampler.py | 52 +++++++++++++++++++++----------- src/pydvl/value/semivalues.py | 30 +++++++++++++----- tests/value/test_sampler.py | 57 ++++++++++++++++++++++++++++++++++- 3 files changed, 113 insertions(+), 26 deletions(-) diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 069d50574..3d01ba7fd 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -54,6 +54,8 @@ "UniformSampler", ] +from pydvl.utils.types import Seed, ensure_seed_seq + T = TypeVar("T", bound=np.generic) SampleT = Tuple[T, NDArray[T]] Sequence.register(np.ndarray) @@ -142,17 +144,10 @@ def complement(self, exclude: Sequence[T]) -> NDArray[T]: return np.setxor1d(self._indices, exclude) def iterindices(self) -> Iterator[T]: - """Iterates over indices in the order specified at construction. - - FIXME: this is probably not very useful, but I couldn't decide - which method is better - """ + """Iterates over indices in the order specified at construction.""" if self._index_iteration is PowersetSampler.IndexIteration.Sequential: for idx in self._outer_indices: yield idx - elif self._index_iteration is PowersetSampler.IndexIteration.Random: - while True: - yield np.random.choice(self._outer_indices, size=1).item() @overload def __getitem__(self, key: slice) -> PowersetSampler[T]: @@ -205,6 +200,24 @@ def weight(cls, n: int, subset_len: int) -> float: ... +class StochasticSampler(PowersetSampler[T], abc.ABC): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self._rng = np.random.default_rng() + + @property + def seed(self) -> int: + return ensure_seed_seq(self._rng).entropy + + @seed.setter + def seed(self, seed: Seed): + """ + :param seed: Either an instance of a numpy random number generator or a seed + for it. + """ + self._rng = np.random.default_rng(seed) + + class DeterministicUniformSampler(PowersetSampler[T]): def __init__(self, indices: NDArray[T], *args, **kwargs): """An iterator to perform uniform deterministic sampling of subsets. @@ -244,7 +257,7 @@ def weight(cls, n: int, subset_len: int) -> float: return float(2 ** (n - 1)) if n > 0 else 1.0 -class UniformSampler(PowersetSampler[T]): +class UniformSampler(StochasticSampler[T]): """An iterator to perform uniform random sampling of subsets. Iterating over every index $i$, either in sequence or at random depending on @@ -269,7 +282,7 @@ class UniformSampler(PowersetSampler[T]): def __iter__(self) -> Iterator[SampleT]: while True: for idx in self.iterindices(): - subset = random_subset(self.complement([idx])) + subset = random_subset(self.complement([idx]), seed=self._rng) yield idx, subset self._n_samples += 1 if self._n_samples == 0: # Empty index set @@ -291,7 +304,7 @@ def __init__(self, indices: NDArray[T], *args, **kwargs): void(indices, args, kwargs) -class AntitheticSampler(PowersetSampler[T]): +class AntitheticSampler(StochasticSampler[T]): """An iterator to perform uniform random sampling of subsets, and their complements. @@ -303,7 +316,7 @@ class AntitheticSampler(PowersetSampler[T]): def __iter__(self) -> Iterator[SampleT]: while True: for idx in self.iterindices(): - subset = random_subset(self.complement([idx])) + subset = random_subset(self.complement([idx]), seed=self._rng) yield idx, subset self._n_samples += 1 yield idx, self.complement(np.concatenate((subset, np.array([idx])))) @@ -316,7 +329,7 @@ def weight(cls, n: int, subset_len: int) -> float: return float(2 ** (n - 1)) if n > 0 else 1.0 -class PermutationSampler(PowersetSampler[T]): +class PermutationSampler(StochasticSampler[T]): """Sample permutations of indices and iterate through each returning increasing subsets, as required for the permutation definition of semi-values. @@ -334,10 +347,11 @@ class PermutationSampler(PowersetSampler[T]): """ def __iter__(self) -> Iterator[SampleT]: - rng = np.random.default_rng() # FIXME: waiting for better rng handling while True: - permutation = rng.permutation(self._indices) + permutation = self._rng.permutation(self._indices) for i, idx in enumerate(permutation): + if not i: + continue yield idx, permutation[:i] self._n_samples += 1 if self._n_samples == 0: # Empty index set @@ -375,7 +389,7 @@ def __iter__(self) -> Iterator[SampleT]: self._n_samples += 1 -class RandomHierarchicalSampler(PowersetSampler[T]): +class RandomHierarchicalSampler(StochasticSampler[T]): """For every index, sample a set size, then a set of that size. .. todo:: @@ -385,8 +399,10 @@ class RandomHierarchicalSampler(PowersetSampler[T]): def __iter__(self) -> Iterator[SampleT]: while True: for idx in self.iterindices(): - k = np.random.choice(np.arange(len(self._indices)), size=1).item() - subset = random_subset_of_size(self.complement([idx]), size=k) + k = self._rng.choice(np.arange(len(self._indices)), size=1).item() + subset = random_subset_of_size( + self.complement([idx]), size=k, seed=self._rng + ) yield idx, subset self._n_samples += 1 if self._n_samples == 0: # Empty index set diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 52dd88e13..b38e2fff6 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -54,7 +54,7 @@ import logging import math from enum import Enum -from typing import Protocol, Tuple, Type, TypeVar, cast +from typing import Optional, Protocol, Tuple, Type, TypeVar, cast import numpy as np import scipy as sp @@ -62,6 +62,7 @@ from tqdm import tqdm from pydvl.utils import ParallelConfig, Utility +from pydvl.utils.types import Seed, ensure_seed_seq from pydvl.value import ValuationResult from pydvl.value.sampler import PermutationSampler, PowersetSampler, SampleT from pydvl.value.stopping import MaxUpdates, StoppingCriterion @@ -186,8 +187,9 @@ def semivalues( return result # Ensure that we always have n_submitted_jobs running + n_remaining_slots = n_submitted_jobs - len(pending) try: - for _ in range(n_submitted_jobs - len(pending)): + for i in range(n_remaining_slots): pending.add( executor.submit( _marginal, @@ -197,8 +199,7 @@ def semivalues( ) ) except StopIteration: - if len(pending) == 0: - return result + return result def shapley_coefficient(n: int, k: int) -> float: @@ -239,6 +240,7 @@ def compute_shapley_semivalues( n_jobs: int = 1, config: ParallelConfig = ParallelConfig(), progress: bool = False, + seed: Optional[Seed] = None, ) -> ValuationResult: """Computes Shapley values for a given utility function. @@ -252,14 +254,17 @@ def compute_shapley_semivalues( :param sampler_t: The sampler type to use. See :mod:`pydvl.value.sampler` for a list. :param n_jobs: Number of parallel jobs to use. + :param seed: Either an instance of a numpy random number generator or a seed for it. :param config: Object configuring parallel computation, with cluster address, number of cpus, etc. :param progress: Whether to display a progress bar. :return: Object with the results. """ + sampler_instance = sampler_t(u.data.indices) + sampler_instance.seed = seed return semivalues( - sampler_t(u.data.indices), + sampler_instance, u, shapley_coefficient, done, @@ -277,6 +282,7 @@ def compute_banzhaf_semivalues( n_jobs: int = 1, config: ParallelConfig = ParallelConfig(), progress: bool = False, + seed: Optional[Seed] = None, ) -> ValuationResult: """Computes Banzhaf values for a given utility function. @@ -288,14 +294,17 @@ def compute_banzhaf_semivalues( :param sampler_t: The sampler type to use. See :mod:`pydvl.value.sampler` for a list. :param n_jobs: Number of parallel jobs to use. + :param seed: Either an instance of a numpy random number generator or a seed for it. :param config: Object configuring parallel computation, with cluster address, number of cpus, etc. :param progress: Whether to display a progress bar. :return: Object with the results. """ + sampler_instance = sampler_t(u.data.indices) + sampler_instance.seed = seed return semivalues( - sampler_t(u.data.indices), + sampler_instance, u, banzhaf_coefficient, done, @@ -315,6 +324,7 @@ def compute_beta_shapley_semivalues( n_jobs: int = 1, config: ParallelConfig = ParallelConfig(), progress: bool = False, + seed: Optional[Seed] = None, ) -> ValuationResult: """Computes Beta Shapley values for a given utility function. @@ -328,14 +338,17 @@ def compute_beta_shapley_semivalues( :param sampler_t: The sampler type to use. See :mod:`pydvl.value.sampler` for a list. :param n_jobs: Number of parallel jobs to use. + :param seed: Either an instance of a numpy random number generator or a seed for it. :param config: Object configuring parallel computation, with cluster address, number of cpus, etc. :param progress: Whether to display a progress bar. :return: Object with the results. """ + sampler_instance = sampler_t(u.data.indices) + sampler_instance.seed = seed return semivalues( - sampler_t(u.data.indices), + sampler_instance, u, beta_coefficient(alpha, beta), done, @@ -364,6 +377,7 @@ def compute_semivalues( mode: SemiValueMode = SemiValueMode.Shapley, sampler_t: Type[PowersetSampler] = PermutationSampler, n_jobs: int = 1, + seed: Optional[Seed] = None, **kwargs, ) -> ValuationResult: """Convenience entry point for most common semi-value computations. @@ -394,12 +408,14 @@ def compute_semivalues( :param sampler_t: The sampler type to use. See :mod:`pydvl.value.sampler` for a list. :param n_jobs: Number of parallel jobs to use. + :param seed: Either an instance of a numpy random number generator or a seed for it. :param kwargs: Additional keyword arguments passed to :func:`~pydvl.value.semivalues.semivalues`. :return: Object with the results. """ sampler_instance = sampler_t(u.data.indices) + sampler_instance.seed = seed if mode == SemiValueMode.Shapley: coefficient = shapley_coefficient elif mode == SemiValueMode.BetaShapley: diff --git a/tests/value/test_sampler.py b/tests/value/test_sampler.py index 570d11ed9..3aa2eef3d 100644 --- a/tests/value/test_sampler.py +++ b/tests/value/test_sampler.py @@ -1,14 +1,18 @@ from itertools import takewhile +from typing import Iterator, List, Type import numpy as np import pytest +from numpy._typing import NDArray -from pydvl.utils import powerset +from pydvl.utils import powerset, sets_are_equal +from pydvl.utils.types import Seed from pydvl.value.sampler import ( AntitheticSampler, DeterministicPermutationSampler, DeterministicUniformSampler, PermutationSampler, + PowersetSampler, RandomHierarchicalSampler, UniformSampler, ) @@ -19,6 +23,7 @@ [ DeterministicUniformSampler, UniformSampler, + DeterministicPermutationSampler, PermutationSampler, AntitheticSampler, RandomHierarchicalSampler, @@ -35,6 +40,44 @@ def test_proper(sampler_class, indices): assert set(subset) in subsets +@pytest.mark.parametrize( + "sampler_class", + [ + UniformSampler, + PermutationSampler, + AntitheticSampler, + RandomHierarchicalSampler, + ], +) +@pytest.mark.parametrize("indices", [(), (list(range(100)))]) +def test_proper_reproducible(sampler_class, indices, seed): + """Test that the sampler is reproducible.""" + samples_1 = _create_seeded_sample_iter(sampler_class, indices, seed) + samples_2 = _create_seeded_sample_iter(sampler_class, indices, seed) + + for (_, subset_1), (_, subset_2) in zip(samples_1, samples_2): + assert sets_are_equal(subset_1, subset_2) + + +@pytest.mark.parametrize( + "sampler_class", + [ + UniformSampler, + PermutationSampler, + AntitheticSampler, + RandomHierarchicalSampler, + ], +) +@pytest.mark.parametrize("indices", [(), (list(range(100)))]) +def test_proper_stochastic(sampler_class, indices, seed, seed_alt): + """Test that the sampler is reproducible.""" + samples_1 = _create_seeded_sample_iter(sampler_class, indices, seed) + samples_2 = _create_seeded_sample_iter(sampler_class, indices, seed_alt) + + for (_, subset_1), (_, subset_2) in zip(samples_1, samples_2): + assert not sets_are_equal(subset_1, subset_2) + + @pytest.mark.parametrize( "sampler_class", [ @@ -70,3 +113,15 @@ def test_chunkify_permutation(sampler_class): # Missing tests for: # - Correct distribution of subsets for random samplers + + +def _create_seeded_sample_iter( + sampler_class: Type[PowersetSampler], + indices: List, + seed: Seed, +) -> Iterator: + max_iterations = len(indices) + sampler = sampler_class(np.array(indices)) + sampler.seed = seed + sample_stream = takewhile(lambda _: sampler.n_samples < max_iterations, sampler) + return sample_stream From 1be1bb02f288acb077d7c80867e28b02821113e8 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Wed, 30 Aug 2023 22:25:22 +0200 Subject: [PATCH 393/436] Merge function fn_accepts_param_name into maybe_add_argument and adapt `map_reduce.py` accordingly. --- .../{parallel/check.py => functional.py} | 52 ++++++++++++------- src/pydvl/utils/parallel/map_reduce.py | 27 ++++------ src/pydvl/utils/types.py | 11 ++-- 3 files changed, 47 insertions(+), 43 deletions(-) rename src/pydvl/utils/{parallel/check.py => functional.py} (51%) diff --git a/src/pydvl/utils/parallel/check.py b/src/pydvl/utils/functional.py similarity index 51% rename from src/pydvl/utils/parallel/check.py rename to src/pydvl/utils/functional.py index bd95a6fe1..186f1167d 100644 --- a/src/pydvl/utils/parallel/check.py +++ b/src/pydvl/utils/functional.py @@ -1,35 +1,24 @@ +from __future__ import annotations + import inspect from functools import partial -from typing import Callable +from typing import Callable, Set, Tuple + +__all__ = ["fn_accepts_param_name"] -def check_fn_accepts_parameter(fn: Callable, param_name: str) -> bool: +def fn_accepts_param_name(fn: Callable, param_name: str) -> bool: """ - Checks whether the given function accepts the given parameter or not. + Checks if a function accepts a given parameter, even if it is set by partial. :param fn: The function to check. :param param_name: The name of the parameter to check. - :return: True if the function accepts the parameter, False otherwise. """ - args_set_by_partial = set() - - # Recursive function to go through nested functools.partial objects - def check_partial(g: Callable): - nonlocal args_set_by_partial - - # If the function is a functools.partial, get the original function - if isinstance(g, partial): - args_set_by_partial.update(g.keywords.keys()) - args_set_by_partial.update(g.args) - return check_partial(g.func) - else: - return g - # Get the original function from functools.partial if needed - original_function = check_partial(fn) + wrapped_fn, args_set_by_partial = _unroll_partial_fn(fn) - sig = inspect.signature(original_function) + sig = inspect.signature(wrapped_fn) params = sig.parameters # Check if the parameter was set by functools.partial @@ -45,3 +34,26 @@ def check_partial(g: Callable): return True return False + + +def _unroll_partial_fn(fn: Callable) -> Tuple[Callable, Set[str]]: + """ + Unroll a function that was set by functools.partial. + + :param fn: Either or a function to unroll. + :return: A tuple of the unrolled function and a set of the parameters that were set + by functools.partial. + """ + args_set_by_partial = set() + + def _rec_unroll_partial_function(g: Callable): + nonlocal args_set_by_partial + + if isinstance(g, partial): + args_set_by_partial.update(g.keywords.keys()) + args_set_by_partial.update(g.args) + return _rec_unroll_partial_function(g.func) + else: + return g + + return _rec_unroll_partial_function(fn), args_set_by_partial diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index 45f79f3e1..0da912b6a 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -1,3 +1,4 @@ +from functools import reduce from itertools import accumulate, repeat from typing import Any, Collection, Dict, Generic, List, Optional, TypeVar, Union @@ -11,11 +12,10 @@ MapFunction, ReduceFunction, Seed, - ensure_seed_sequence, + ensure_seed_seq, maybe_add_argument, ) from .backend import init_parallel_backend -from .check import check_fn_accepts_parameter __all__ = ["MapReduceJob"] @@ -102,7 +102,7 @@ def __init__( self.map_kwargs = map_kwargs if map_kwargs is not None else dict() self.reduce_kwargs = reduce_kwargs if reduce_kwargs is not None else dict() - self._map_func = maybe_add_argument(map_func, "job_id") + self._map_func = reduce(maybe_add_argument, ["job_id", "seed"], map_func) self._reduce_func = reduce_func def __call__( @@ -125,23 +125,16 @@ def __call__( # In joblib the levels are reversed. # 0 means no logging and 50 means log everything to stdout verbose = 50 - self.config.logging_level - seed_seq = ensure_seed_sequence(seed) + seed_seq = ensure_seed_seq(seed) with Parallel(backend=backend, n_jobs=self.n_jobs, verbose=verbose) as parallel: chunks = self._chunkify(self.inputs_, n_chunks=self.n_jobs) - - # Allow functions which don't accept or need a seed parameter. - lst_add_kwargs: List[Dict[str, Union[int, SeedSequence]]] = [ - {"job_id": j} for j in range(len(chunks)) - ] - if check_fn_accepts_parameter(self._map_func, "seed"): - lst_add_kwargs = [ - {**d, **{"seed": seed.entropy}} - for d, seed in zip(lst_add_kwargs, seed_seq.spawn(len(chunks))) - ] - map_results: List[R] = parallel( - delayed(self._map_func)(next_chunk, **add_kwargs, **self.map_kwargs) - for next_chunk, add_kwargs in zip(chunks, lst_add_kwargs) + delayed(self._map_func)( + next_chunk, job_id=j, seed=seed.entropy, **self.map_kwargs + ) + for j, (next_chunk, seed) in enumerate( + zip(chunks, seed_seq.spawn(len(chunks))) + ) ) reduce_results: R = self._reduce_func(map_results, **self.reduce_kwargs) return reduce_results diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index aa877a196..1cf831827 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -4,15 +4,17 @@ from __future__ import annotations import functools -import inspect from abc import ABCMeta from typing import Any, Callable, Optional, Protocol, TypeVar, Union from numpy.random import Generator, SeedSequence from numpy.typing import NDArray +from pydvl.utils.functional import fn_accepts_param_name + __all__ = ["SupervisedModel", "MapFunction", "ReduceFunction", "NoPublicConstructor"] + R = TypeVar("R", covariant=True) @@ -57,8 +59,7 @@ def maybe_add_argument(fun: Callable, new_arg: str): (and ignore). :return: A new function accepting one more keyword argument. """ - params = inspect.signature(fun).parameters - if new_arg in params.keys(): + if fn_accepts_param_name(fun, new_arg): return fun @functools.wraps(fun) @@ -100,9 +101,7 @@ def create(cls, *args: Any, **kwargs: Any): Seed = Union[int, Generator] -def ensure_seed_sequence( - seed: Optional[Union[Seed, SeedSequence]] = None -) -> SeedSequence: +def ensure_seed_seq(seed: Optional[Union[Seed, SeedSequence]] = None) -> SeedSequence: """ If the passed seed is a SeedSequence object then it is returned as is. If it is a Generator the internal protected seed sequence from the generator gets extracted. From 7b9c07dc7e055f46fdc7779bc0b74a778d87d6c1 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Wed, 30 Aug 2023 22:26:32 +0200 Subject: [PATCH 394/436] Rename :func:`pydvl.utils.types.ensure_seed_seq` to :func:`pydvl.utils.types.ensure_seed_sequence`. --- src/pydvl/utils/parallel/map_reduce.py | 4 ++-- src/pydvl/utils/types.py | 4 +++- src/pydvl/value/sampler.py | 4 ++-- src/pydvl/value/semivalues.py | 2 +- 4 files changed, 8 insertions(+), 6 deletions(-) diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index 0da912b6a..dfd3de534 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -12,7 +12,7 @@ MapFunction, ReduceFunction, Seed, - ensure_seed_seq, + ensure_seed_sequence, maybe_add_argument, ) from .backend import init_parallel_backend @@ -125,7 +125,7 @@ def __call__( # In joblib the levels are reversed. # 0 means no logging and 50 means log everything to stdout verbose = 50 - self.config.logging_level - seed_seq = ensure_seed_seq(seed) + seed_seq = ensure_seed_sequence(seed) with Parallel(backend=backend, n_jobs=self.n_jobs, verbose=verbose) as parallel: chunks = self._chunkify(self.inputs_, n_chunks=self.n_jobs) map_results: List[R] = parallel( diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index 1cf831827..957ef8f51 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -101,7 +101,9 @@ def create(cls, *args: Any, **kwargs: Any): Seed = Union[int, Generator] -def ensure_seed_seq(seed: Optional[Union[Seed, SeedSequence]] = None) -> SeedSequence: +def ensure_seed_sequence( + seed: Optional[Union[Seed, SeedSequence]] = None +) -> SeedSequence: """ If the passed seed is a SeedSequence object then it is returned as is. If it is a Generator the internal protected seed sequence from the generator gets extracted. diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 3d01ba7fd..4752c2d03 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -54,7 +54,7 @@ "UniformSampler", ] -from pydvl.utils.types import Seed, ensure_seed_seq +from pydvl.utils.types import Seed, ensure_seed_sequence T = TypeVar("T", bound=np.generic) SampleT = Tuple[T, NDArray[T]] @@ -207,7 +207,7 @@ def __init__(self, *args, **kwargs): @property def seed(self) -> int: - return ensure_seed_seq(self._rng).entropy + return ensure_seed_sequence(self._rng).entropy @seed.setter def seed(self, seed: Seed): diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index b38e2fff6..6c254727c 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -62,7 +62,7 @@ from tqdm import tqdm from pydvl.utils import ParallelConfig, Utility -from pydvl.utils.types import Seed, ensure_seed_seq +from pydvl.utils.types import Seed, ensure_seed_sequence from pydvl.value import ValuationResult from pydvl.value.sampler import PermutationSampler, PowersetSampler, SampleT from pydvl.value.stopping import MaxUpdates, StoppingCriterion From fe0383440eba6274c9a96797a157110de5187413 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Wed, 30 Aug 2023 22:35:58 +0200 Subject: [PATCH 395/436] Add StochasticSampler mixin and add back the different typeof index iterations. --- src/pydvl/value/sampler.py | 28 ++++++++++++++++++---------- 1 file changed, 18 insertions(+), 10 deletions(-) diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 4752c2d03..cdd715ba7 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -43,6 +43,7 @@ from numpy.typing import NDArray from pydvl.utils.numeric import powerset, random_subset, random_subset_of_size +from pydvl.utils.types import Seed, ensure_seed_sequence __all__ = [ "AntitheticSampler", @@ -52,9 +53,9 @@ "PowersetSampler", "RandomHierarchicalSampler", "UniformSampler", + "StochasticSamplerMixin", ] -from pydvl.utils.types import Seed, ensure_seed_sequence T = TypeVar("T", bound=np.generic) SampleT = Tuple[T, NDArray[T]] @@ -144,10 +145,17 @@ def complement(self, exclude: Sequence[T]) -> NDArray[T]: return np.setxor1d(self._indices, exclude) def iterindices(self) -> Iterator[T]: - """Iterates over indices in the order specified at construction.""" + """Iterates over indices in the order specified at construction. + + FIXME: this is probably not very useful, but I couldn't decide + which method is better + """ if self._index_iteration is PowersetSampler.IndexIteration.Sequential: for idx in self._outer_indices: yield idx + elif self._index_iteration is PowersetSampler.IndexIteration.Random: + while True: + yield np.random.choice(self._outer_indices, size=1).item() @overload def __getitem__(self, key: slice) -> PowersetSampler[T]: @@ -200,10 +208,10 @@ def weight(cls, n: int, subset_len: int) -> float: ... -class StochasticSampler(PowersetSampler[T], abc.ABC): - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - self._rng = np.random.default_rng() +class StochasticSamplerMixin: + """Mixin class for samplers which use a random number generator.""" + + _rng = np.random.default_rng() @property def seed(self) -> int: @@ -257,7 +265,7 @@ def weight(cls, n: int, subset_len: int) -> float: return float(2 ** (n - 1)) if n > 0 else 1.0 -class UniformSampler(StochasticSampler[T]): +class UniformSampler(PowersetSampler[T], StochasticSamplerMixin): """An iterator to perform uniform random sampling of subsets. Iterating over every index $i$, either in sequence or at random depending on @@ -304,7 +312,7 @@ def __init__(self, indices: NDArray[T], *args, **kwargs): void(indices, args, kwargs) -class AntitheticSampler(StochasticSampler[T]): +class AntitheticSampler(PowersetSampler[T], StochasticSamplerMixin): """An iterator to perform uniform random sampling of subsets, and their complements. @@ -329,7 +337,7 @@ def weight(cls, n: int, subset_len: int) -> float: return float(2 ** (n - 1)) if n > 0 else 1.0 -class PermutationSampler(StochasticSampler[T]): +class PermutationSampler(PowersetSampler[T], StochasticSamplerMixin): """Sample permutations of indices and iterate through each returning increasing subsets, as required for the permutation definition of semi-values. @@ -389,7 +397,7 @@ def __iter__(self) -> Iterator[SampleT]: self._n_samples += 1 -class RandomHierarchicalSampler(StochasticSampler[T]): +class RandomHierarchicalSampler(PowersetSampler[T], StochasticSamplerMixin): """For every index, sample a set size, then a set of that size. .. todo:: From 615fe34e614dc64711f97a094e7c5e10a93f2f17 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Wed, 30 Aug 2023 22:52:07 +0200 Subject: [PATCH 396/436] Remove sets_are_equal function and replace by `set(a) == set(b)`. --- src/pydvl/utils/numeric.py | 5 ----- tests/utils/test_numeric.py | 40 +++++++++++++++++++++++++++---------- tests/value/test_sampler.py | 7 +++---- 3 files changed, 32 insertions(+), 20 deletions(-) diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index c9ade3d59..0cd6d0571 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -21,7 +21,6 @@ "random_powerset", "random_subset_of_size", "top_k_value_accuracy", - "sets_are_equal", ] T = TypeVar("T", bound=np.generic) @@ -249,7 +248,3 @@ def top_k_value_accuracy( top_k_pred_values = np.argsort(y_pred)[-k:] top_k_accuracy = len(np.intersect1d(top_k_exact_values, top_k_pred_values)) / k return top_k_accuracy - - -def sets_are_equal(subset_1: NDArray[np.int_], subset_2: NDArray[np.int_]): - return list(subset_1) == list(subset_2) diff --git a/tests/utils/test_numeric.py b/tests/utils/test_numeric.py index 12168455d..212ff2db6 100644 --- a/tests/utils/test_numeric.py +++ b/tests/utils/test_numeric.py @@ -8,8 +8,8 @@ random_powerset, random_subset_of_size, running_moments, - sets_are_equal, ) +from pydvl.utils.types import Seed def test_powerset(): @@ -76,13 +76,9 @@ def test_random_powerset_reproducible(n, max_subsets, seed): Test that the same seeds produce the same results, and different seeds produce different results for method :func:`random_powerset`. """ - s = np.arange(n) - parallel_subset_generators = zip( - random_powerset(s, n_samples=max_subsets, seed=seed), - random_powerset(s, n_samples=max_subsets, seed=seed), + n_collisions = _count_random_powerset_generator_collisions( + n, max_subsets, seed, seed ) - - n_collisions = sum(map(lambda t: sets_are_equal(*t), parallel_subset_generators)) assert n_collisions == max_subsets @@ -92,13 +88,35 @@ def test_random_powerset_stochastic(n, max_subsets, seed, seed_alt, collision_to Test that the same seeds produce the same results, and different seeds produce different results for method :func:`random_powerset`. """ + n_collisions = _count_random_powerset_generator_collisions( + n, max_subsets, seed, seed_alt + ) + assert n_collisions / max_subsets < collision_tol + + +def _count_random_powerset_generator_collisions( + n: int, max_subsets: int, seed: Seed, seed_alt: Seed +): + """ + Count the number of collisions between two generators of random subsets of a set + with `n` elements, each generating `max_subsets` subsets, using two different seeds. + + :param n: number of elements in the set. + :param max_subsets: number of subsets to generate. + :param seed: Seed for the first generator. + :param seed_alt: Seed for the second generator. + + :return: Number of collisions between the two generators. + """ s = np.arange(n) parallel_subset_generators = zip( random_powerset(s, n_samples=max_subsets, seed=seed), random_powerset(s, n_samples=max_subsets, seed=seed_alt), ) - n_collisions = sum(map(lambda t: sets_are_equal(*t), parallel_subset_generators)) - assert n_collisions / max_subsets < collision_tol + n_collisions = sum( + map(lambda t: set(t[0]) == set(t[1]), parallel_subset_generators) + ) + return n_collisions @pytest.mark.parametrize( @@ -128,7 +146,7 @@ def test_random_subset_of_size_stochastic(n, size, seed, seed_alt): s = np.arange(n) subset_1 = random_subset_of_size(s, size=size, seed=seed) subset_2 = random_subset_of_size(s, size=size, seed=seed_alt) - assert not sets_are_equal(subset_1, subset_2) + assert set(subset_1) != set(subset_2) @pytest.mark.parametrize( @@ -143,7 +161,7 @@ def test_random_subset_of_size_stochastic(n, size, seed): s = np.arange(n) subset_1 = random_subset_of_size(s, size=size, seed=seed) subset_2 = random_subset_of_size(s, size=size, seed=seed) - assert sets_are_equal(subset_1, subset_2) + assert set(subset_1) == set(subset_2) @pytest.mark.parametrize( diff --git a/tests/value/test_sampler.py b/tests/value/test_sampler.py index 3aa2eef3d..7b8b06a25 100644 --- a/tests/value/test_sampler.py +++ b/tests/value/test_sampler.py @@ -3,9 +3,8 @@ import numpy as np import pytest -from numpy._typing import NDArray -from pydvl.utils import powerset, sets_are_equal +from pydvl.utils import powerset from pydvl.utils.types import Seed from pydvl.value.sampler import ( AntitheticSampler, @@ -56,7 +55,7 @@ def test_proper_reproducible(sampler_class, indices, seed): samples_2 = _create_seeded_sample_iter(sampler_class, indices, seed) for (_, subset_1), (_, subset_2) in zip(samples_1, samples_2): - assert sets_are_equal(subset_1, subset_2) + assert set(subset_1) == set(subset_2) @pytest.mark.parametrize( @@ -75,7 +74,7 @@ def test_proper_stochastic(sampler_class, indices, seed, seed_alt): samples_2 = _create_seeded_sample_iter(sampler_class, indices, seed_alt) for (_, subset_1), (_, subset_2) in zip(samples_1, samples_2): - assert not sets_are_equal(subset_1, subset_2) + assert set(subset_1) != set(subset_2) @pytest.mark.parametrize( From df24a53a6eede76dcbb39d70b4d9174ebe248710 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Wed, 30 Aug 2023 23:07:12 +0200 Subject: [PATCH 397/436] Change structure so that seed is set over the constructor for the sampler. Introduced StochasticSampler type. --- src/pydvl/value/sampler.py | 46 +++++++++++++++++++++++++---------- src/pydvl/value/semivalues.py | 41 ++++++++++++++++--------------- tests/value/test_sampler.py | 8 +++--- 3 files changed, 59 insertions(+), 36 deletions(-) diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index cdd715ba7..4f29b1be7 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -36,7 +36,17 @@ import math from enum import Enum from itertools import permutations -from typing import Generic, Iterable, Iterator, Sequence, Tuple, TypeVar, overload +from typing import ( + Generic, + Iterable, + Iterator, + Optional, + Sequence, + Tuple, + TypeVar, + Union, + overload, +) import numpy as np from deprecate import deprecated, void @@ -211,18 +221,7 @@ def weight(cls, n: int, subset_len: int) -> float: class StochasticSamplerMixin: """Mixin class for samplers which use a random number generator.""" - _rng = np.random.default_rng() - - @property - def seed(self) -> int: - return ensure_seed_sequence(self._rng).entropy - - @seed.setter - def seed(self, seed: Seed): - """ - :param seed: Either an instance of a numpy random number generator or a seed - for it. - """ + def __init__(self, seed: Optional[Seed] = None): self._rng = np.random.default_rng(seed) @@ -287,6 +286,10 @@ class UniformSampler(PowersetSampler[T], StochasticSamplerMixin): """ + def __init__(self, *args, seed: Optional[Seed] = None, **kwargs): + super().__init__(*args, **kwargs) + StochasticSamplerMixin.__init__(self, seed=seed) + def __iter__(self) -> Iterator[SampleT]: while True: for idx in self.iterindices(): @@ -321,6 +324,10 @@ class AntitheticSampler(PowersetSampler[T], StochasticSamplerMixin): the set $S$, including the index $i$ itself. """ + def __init__(self, *args, seed: Optional[Seed] = None, **kwargs): + super().__init__(*args, **kwargs) + StochasticSamplerMixin.__init__(self, seed=seed) + def __iter__(self) -> Iterator[SampleT]: while True: for idx in self.iterindices(): @@ -354,6 +361,10 @@ class PermutationSampler(PowersetSampler[T], StochasticSamplerMixin): will be doubled wrt. a "direct" implementation of permutation MC """ + def __init__(self, *args, seed: Optional[Seed] = None, **kwargs): + super().__init__(*args, **kwargs) + StochasticSamplerMixin.__init__(self, seed=seed) + def __iter__(self) -> Iterator[SampleT]: while True: permutation = self._rng.permutation(self._indices) @@ -404,6 +415,10 @@ class RandomHierarchicalSampler(PowersetSampler[T], StochasticSamplerMixin): This is unnecessary, but a step towards proper stratified sampling. """ + def __init__(self, *args, seed: Optional[Seed] = None, **kwargs): + super().__init__(*args, **kwargs) + StochasticSamplerMixin.__init__(self, seed=seed) + def __iter__(self) -> Iterator[SampleT]: while True: for idx in self.iterindices(): @@ -419,3 +434,8 @@ 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 + + +StochasticSampler = Union[ + UniformSampler, PermutationSampler, RandomHierarchicalSampler, AntitheticSampler +] diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 6c254727c..780eaf022 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -64,7 +64,12 @@ from pydvl.utils import ParallelConfig, Utility from pydvl.utils.types import Seed, ensure_seed_sequence from pydvl.value import ValuationResult -from pydvl.value.sampler import PermutationSampler, PowersetSampler, SampleT +from pydvl.value.sampler import ( + PermutationSampler, + PowersetSampler, + SampleT, + StochasticSampler, +) from pydvl.value.stopping import MaxUpdates, StoppingCriterion __all__ = [ @@ -187,9 +192,8 @@ def semivalues( return result # Ensure that we always have n_submitted_jobs running - n_remaining_slots = n_submitted_jobs - len(pending) try: - for i in range(n_remaining_slots): + for _ in range(n_submitted_jobs - len(pending)): pending.add( executor.submit( _marginal, @@ -236,7 +240,7 @@ def compute_shapley_semivalues( u: Utility, *, done: StoppingCriterion = MaxUpdates(100), - sampler_t: Type[PowersetSampler] = PermutationSampler, + sampler_t: Type[StochasticSampler] = PermutationSampler, n_jobs: int = 1, config: ParallelConfig = ParallelConfig(), progress: bool = False, @@ -261,10 +265,8 @@ def compute_shapley_semivalues( :return: Object with the results. """ - sampler_instance = sampler_t(u.data.indices) - sampler_instance.seed = seed return semivalues( - sampler_instance, + sampler_t(u.data.indices, seed=seed), u, shapley_coefficient, done, @@ -278,7 +280,7 @@ def compute_banzhaf_semivalues( u: Utility, *, done: StoppingCriterion = MaxUpdates(100), - sampler_t: Type[PowersetSampler] = PermutationSampler, + sampler_t: Type[StochasticSampler] = PermutationSampler, n_jobs: int = 1, config: ParallelConfig = ParallelConfig(), progress: bool = False, @@ -301,10 +303,8 @@ def compute_banzhaf_semivalues( :return: Object with the results. """ - sampler_instance = sampler_t(u.data.indices) - sampler_instance.seed = seed return semivalues( - sampler_instance, + sampler_t(u.data.indices, seed=seed), u, banzhaf_coefficient, done, @@ -320,7 +320,7 @@ def compute_beta_shapley_semivalues( alpha: float = 1, beta: float = 1, done: StoppingCriterion = MaxUpdates(100), - sampler_t: Type[PowersetSampler] = PermutationSampler, + sampler_t: Type[StochasticSampler] = PermutationSampler, n_jobs: int = 1, config: ParallelConfig = ParallelConfig(), progress: bool = False, @@ -345,10 +345,8 @@ def compute_beta_shapley_semivalues( :return: Object with the results. """ - sampler_instance = sampler_t(u.data.indices) - sampler_instance.seed = seed return semivalues( - sampler_instance, + sampler_t(u.data.indices, seed=seed), u, beta_coefficient(alpha, beta), done, @@ -375,7 +373,7 @@ def compute_semivalues( *, done: StoppingCriterion = MaxUpdates(100), mode: SemiValueMode = SemiValueMode.Shapley, - sampler_t: Type[PowersetSampler] = PermutationSampler, + sampler_t: Type[StochasticSampler] = PermutationSampler, n_jobs: int = 1, seed: Optional[Seed] = None, **kwargs, @@ -414,8 +412,6 @@ def compute_semivalues( :return: Object with the results. """ - sampler_instance = sampler_t(u.data.indices) - sampler_instance.seed = seed if mode == SemiValueMode.Shapley: coefficient = shapley_coefficient elif mode == SemiValueMode.BetaShapley: @@ -427,4 +423,11 @@ def compute_semivalues( else: raise ValueError(f"Unknown mode {mode}") coefficient = cast(SVCoefficient, coefficient) - return semivalues(sampler_instance, u, coefficient, done, n_jobs=n_jobs, **kwargs) + return semivalues( + sampler_t(u.data.indices, seed=seed), + u, + coefficient, + done, + n_jobs=n_jobs, + **kwargs, + ) diff --git a/tests/value/test_sampler.py b/tests/value/test_sampler.py index 7b8b06a25..87d9db31d 100644 --- a/tests/value/test_sampler.py +++ b/tests/value/test_sampler.py @@ -1,5 +1,5 @@ from itertools import takewhile -from typing import Iterator, List, Type +from typing import Iterator, List, Type, Union import numpy as np import pytest @@ -13,6 +13,7 @@ PermutationSampler, PowersetSampler, RandomHierarchicalSampler, + StochasticSampler, UniformSampler, ) @@ -115,12 +116,11 @@ def test_chunkify_permutation(sampler_class): def _create_seeded_sample_iter( - sampler_class: Type[PowersetSampler], + sampler_class: Type[StochasticSampler], indices: List, seed: Seed, ) -> Iterator: max_iterations = len(indices) - sampler = sampler_class(np.array(indices)) - sampler.seed = seed + sampler = sampler_class(np.array(indices), seed=seed) sample_stream = takewhile(lambda _: sampler.n_samples < max_iterations, sampler) return sample_stream From 778a7eb73077825d32cd44ad528318a9bd7cd8a5 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Thu, 31 Aug 2023 06:16:46 +0200 Subject: [PATCH 398/436] Add seed parameter to all methods of `pydvl.value.shapley.common`. Added test cased for reproducibility and stochasticity. --- src/pydvl/value/shapley/common.py | 12 +++- src/pydvl/value/shapley/gt.py | 23 +++++-- src/pydvl/value/shapley/montecarlo.py | 39 +++++++++--- src/pydvl/value/shapley/owen.py | 14 +++- tests/value/__init__.py | 9 ++- tests/value/shapley/test_montecarlo.py | 88 ++++++++++++++++++++++++++ 6 files changed, 164 insertions(+), 21 deletions(-) diff --git a/src/pydvl/value/shapley/common.py b/src/pydvl/value/shapley/common.py index fe43274d5..010ae9121 100644 --- a/src/pydvl/value/shapley/common.py +++ b/src/pydvl/value/shapley/common.py @@ -1,4 +1,7 @@ +from typing import Optional + from pydvl.utils import Utility +from pydvl.utils.types import Seed from pydvl.value.result import ValuationResult from pydvl.value.shapley.gt import group_testing_shapley from pydvl.value.shapley.knn import knn_shapley @@ -24,6 +27,7 @@ def compute_shapley_values( done: StoppingCriterion = MaxUpdates(100), mode: ShapleyMode = ShapleyMode.TruncatedMontecarlo, n_jobs: int = 1, + seed: Optional[Seed] = None, **kwargs, ) -> ValuationResult: """Umbrella method to compute Shapley values with any of the available @@ -83,6 +87,8 @@ def compute_shapley_values( using boolean operators. Some methods ignore this argument, others require specific subtypes. :param n_jobs: Number of parallel jobs (available only to some methods) + :param seed: Either an instance of a numpy random number generator or a seed + for it. :param mode: Choose which shapley algorithm to use. See :class:`~pydvl.value.shapley.ShapleyMode` for a list of allowed value. @@ -102,11 +108,11 @@ def compute_shapley_values( ): truncation = kwargs.pop("truncation", NoTruncation()) return permutation_montecarlo_shapley( # type: ignore - u=u, done=done, truncation=truncation, n_jobs=n_jobs, **kwargs + u=u, done=done, truncation=truncation, n_jobs=n_jobs, seed=seed, **kwargs ) elif mode == ShapleyMode.CombinatorialMontecarlo: return combinatorial_montecarlo_shapley( - u, done=done, n_jobs=n_jobs, progress=progress + u, done=done, n_jobs=n_jobs, seed=seed, progress=progress ) elif mode == ShapleyMode.CombinatorialExact: return combinatorial_exact_shapley(u, n_jobs=n_jobs, progress=progress) @@ -129,6 +135,7 @@ def compute_shapley_values( max_q=int(kwargs.get("max_q", -1)), method=method, n_jobs=n_jobs, + seed=seed, ) elif mode == ShapleyMode.KNN: return knn_shapley(u, progress=progress) @@ -147,6 +154,7 @@ def compute_shapley_values( n_samples=n_samples, n_jobs=n_jobs, progress=progress, + seed=seed, **kwargs, ) else: diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index cc14da315..3c5c75f29 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -17,7 +17,7 @@ """ import logging from collections import namedtuple -from typing import Iterable, Tuple, TypeVar, cast +from typing import Iterable, Optional, Tuple, TypeVar, cast import cvxpy as cp import numpy as np @@ -27,6 +27,7 @@ from pydvl.utils.numeric import random_subset_of_size from pydvl.utils.parallel.backend import effective_n_jobs from pydvl.utils.status import Status +from pydvl.utils.types import Seed, ensure_seed_sequence from pydvl.value import ValuationResult __all__ = ["group_testing_shapley", "num_samples_eps_delta"] @@ -114,7 +115,11 @@ def num_samples_eps_delta( def _group_testing_shapley( - u: Utility, n_samples: int, progress: bool = False, job_id: int = 1 + u: Utility, + n_samples: int, + progress: bool = False, + job_id: int = 1, + seed: Optional[Seed] = None, ): """Helper function for :func:`group_testing_shapley`. @@ -125,9 +130,11 @@ def _group_testing_shapley( :param n_samples: total number of samples (subsets) to use. :param progress: Whether to display progress bars for each job. :param job_id: id to use for reporting progress (e.g. to place progres bars) + :param seed: Either an instance of a numpy random number generator or a seed + for it. :return: """ - rng = np.random.default_rng() + rng = np.random.default_rng(seed) n = len(u.data.indices) const = _constants(n, 1, 1, 1) # don't care about eps,delta,range @@ -138,7 +145,7 @@ def _group_testing_shapley( for t in maybe_progress(n_samples, progress=progress, position=job_id): k = rng.choice(const.kk, size=1, p=const.q).item() - s = random_subset_of_size(u.data.indices, k) + s = random_subset_of_size(u.data.indices, k, seed=rng) uu[t] = u(s) betas[t, s] = 1 return uu, betas @@ -153,6 +160,7 @@ def group_testing_shapley( n_jobs: int = 1, config: ParallelConfig = ParallelConfig(), progress: bool = False, + seed: Optional[Seed] = None, **options, ) -> ValuationResult: """Implements group testing for approximation of Shapley values as described @@ -181,6 +189,8 @@ def group_testing_shapley( :param config: Object configuring parallel computation, with cluster address, number of cpus, etc. :param progress: Whether to display progress bars for each job. + :param seed: Either an instance of a numpy random number generator or a seed + for it. :param options: Additional options to pass to `cvxpy.Problem.solve() `_. E.g. to change the solver (which defaults to `cvxpy.SCS`) pass @@ -219,6 +229,9 @@ def reducer( np.float_ ), np.concatenate(list(x[1] for x in results_it)).astype(np.int_) + seed_sequence = ensure_seed_sequence(seed) + map_reduce_seed_sequence, cvxpy_seed = tuple(seed_sequence.spawn(2)) + map_reduce_job: MapReduceJob[Utility, Tuple[NDArray, NDArray]] = MapReduceJob( u, map_func=_group_testing_shapley, @@ -227,7 +240,7 @@ def reducer( config=config, n_jobs=n_jobs, ) - uu, betas = map_reduce_job() + uu, betas = map_reduce_job(seed=map_reduce_seed_sequence.entropy) # Matrix of estimated differences. See Eqs. (3) and (4) in the paper. C = np.zeros(shape=(n, n)) diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index 9eb5b640d..08c1a0beb 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -38,7 +38,7 @@ from concurrent.futures import FIRST_COMPLETED, Future, wait from functools import reduce from itertools import cycle, takewhile -from typing import Sequence +from typing import Optional, Sequence import numpy as np from deprecate import deprecated @@ -49,6 +49,7 @@ from pydvl.utils.config import ParallelConfig from pydvl.utils.numeric import random_powerset from pydvl.utils.parallel import CancellationPolicy, MapReduceJob +from pydvl.utils.types import Seed, ensure_seed_sequence from pydvl.utils.utility import Utility from pydvl.value.result import ValuationResult from pydvl.value.shapley.truncated import NoTruncation, TruncationPolicy @@ -60,7 +61,10 @@ def _permutation_montecarlo_one_step( - u: Utility, truncation: TruncationPolicy, algorithm_name: str + u: Utility, + truncation: TruncationPolicy, + algorithm_name: str, + seed: Optional[Seed] = None, ) -> ValuationResult: """Helper function for :func:`permutation_montecarlo_shapley`. @@ -73,16 +77,16 @@ def _permutation_montecarlo_one_step( processing a permutation and set all subsequent marginals to zero. :param algorithm_name: For the results object. Used internally by different variants of Shapley using this subroutine - + :param seed: Either an instance of a numpy random number generator or a seed + for it. :return: An object with the results """ result = ValuationResult.zeros( algorithm=algorithm_name, indices=u.data.indices, data_names=u.data.data_names ) - prev_score = 0.0 - permutation = np.random.permutation(u.data.indices) + permutation = np.random.default_rng(seed).permutation(u.data.indices) permutation_done = False truncation.reset() for i, idx in enumerate(permutation): @@ -121,6 +125,7 @@ def permutation_montecarlo_shapley( n_jobs: int = 1, config: ParallelConfig = ParallelConfig(), progress: bool = False, + seed: Seed = None, ) -> ValuationResult: r"""Computes an approximate Shapley value by sampling independent permutations of the index set, approximating the sum: @@ -159,6 +164,8 @@ def permutation_montecarlo_shapley( interrupt processing a permutation and set all subsequent marginals to zero. Typically used to stop computation when the marginal is small. :param n_jobs: number of jobs across which to distribute the computation. + :param seed: Either an instance of a numpy random number generator or a seed + for it. :param config: Object configuring parallel computation, with cluster address, number of cpus, etc. :param progress: Whether to display progress bars for each job. @@ -171,6 +178,7 @@ def permutation_montecarlo_shapley( max_workers = effective_n_jobs(n_jobs, config) n_submitted_jobs = 2 * max_workers # number of jobs in the executor's queue + seed_sequence = ensure_seed_sequence(seed) result = ValuationResult.zeros(algorithm=algorithm) pbar = tqdm(disable=not progress, total=100, unit="%") @@ -195,9 +203,15 @@ def permutation_montecarlo_shapley( return result # Ensure that we always have n_submitted_jobs in the queue or running - for _ in range(n_submitted_jobs - len(pending)): + n_remaining_slots = n_submitted_jobs - len(pending) + seeds = seed_sequence.spawn(n_remaining_slots) + for i in range(n_remaining_slots): future = executor.submit( - _permutation_montecarlo_one_step, u, truncation, algorithm + _permutation_montecarlo_one_step, + u, + truncation, + algorithm, + seed=seeds[i].entropy, ) pending.add(future) @@ -209,6 +223,7 @@ def _combinatorial_montecarlo_shapley( *, progress: bool = False, job_id: int = 1, + seed: Optional[Seed] = None, ) -> ValuationResult: """Helper function for :func:`combinatorial_montecarlo_shapley`. @@ -221,6 +236,8 @@ def _combinatorial_montecarlo_shapley( subsets for an index. :param progress: Whether to display progress bars for each job. :param job_id: id to use for reporting progress + :param seed: Either an instance of a numpy random number generator or a seed + for it. :return: A tuple of ndarrays with estimated values and standard errors """ n = len(u.data) @@ -236,6 +253,7 @@ def _combinatorial_montecarlo_shapley( data_names=[u.data.data_names[i] for i in indices], ) + rng = np.random.default_rng(seed) repeat_indices = takewhile(lambda _: not done(result), cycle(indices)) pbar = tqdm(disable=not progress, position=job_id, total=100, unit="%") for idx in repeat_indices: @@ -243,7 +261,7 @@ def _combinatorial_montecarlo_shapley( pbar.refresh() # Randomly sample subsets of full dataset without idx subset = np.setxor1d(u.data.indices, [idx], assume_unique=True) - s = next(random_powerset(subset, n_samples=1)) + s = next(random_powerset(subset, n_samples=1, seed=rng)) marginal = (u({idx}.union(s)) - u(s)) / math.comb(n - 1, len(s)) result.update(idx, correction * marginal) @@ -257,6 +275,7 @@ def combinatorial_montecarlo_shapley( n_jobs: int = 1, config: ParallelConfig = ParallelConfig(), progress: bool = False, + seed: Optional[Seed] = None, ) -> ValuationResult: r"""Computes an approximate Shapley value using the combinatorial definition: @@ -281,6 +300,8 @@ def combinatorial_montecarlo_shapley( :param n_jobs: number of parallel jobs across which to distribute the computation. Each worker receives a chunk of :attr:`~pydvl.utils.dataset.Dataset.indices` + :param seed: Either an instance of a numpy random number generator or a seed + for it. :param config: Object configuring parallel computation, with cluster address, number of cpus, etc. :param progress: Whether to display progress bars for each job. @@ -295,4 +316,4 @@ def combinatorial_montecarlo_shapley( n_jobs=n_jobs, config=config, ) - return map_reduce_job() + return map_reduce_job(seed=seed) diff --git a/src/pydvl/value/shapley/owen.py b/src/pydvl/value/shapley/owen.py index ec61b4f4d..b5d7f7d14 100644 --- a/src/pydvl/value/shapley/owen.py +++ b/src/pydvl/value/shapley/owen.py @@ -2,13 +2,14 @@ from enum import Enum from functools import reduce from itertools import cycle, takewhile -from typing import Sequence +from typing import Optional, Sequence import numpy as np from numpy.typing import NDArray from tqdm import tqdm from pydvl.utils import MapReduceJob, ParallelConfig, Utility, random_powerset +from pydvl.utils.types import Seed from pydvl.value import ValuationResult from pydvl.value.stopping import MinUpdates @@ -29,6 +30,7 @@ def _owen_sampling_shapley( *, progress: bool = False, job_id: int = 1, + seed: Optional[Seed] = None ) -> ValuationResult: r"""This is the algorithm as detailed in the paper: to compute the outer integral over q ∈ [0,1], use uniformly distributed points for evaluation @@ -47,6 +49,8 @@ def _owen_sampling_shapley( :param max_q: number of subdivisions for the integration over $q$ :param progress: Whether to display progress bars for each job :param job_id: For positioning of the progress bar + :param seed: Either an instance of a numpy random number generator or a seed + for it. :return: Object with the data values, errors. """ q_stop = {OwenAlgorithm.Standard: 1.0, OwenAlgorithm.Antithetic: 0.5} @@ -58,6 +62,7 @@ def _owen_sampling_shapley( data_names=[u.data.data_names[i] for i in indices], ) + rng = np.random.default_rng(seed) done = MinUpdates(1) repeat_indices = takewhile(lambda _: not done(result), cycle(indices)) pbar = tqdm(disable=not progress, position=job_id, total=100, unit="%") @@ -67,7 +72,7 @@ def _owen_sampling_shapley( e = np.zeros(max_q) subset = np.setxor1d(u.data.indices, [idx], assume_unique=True) for j, q in enumerate(q_steps): - for s in random_powerset(subset, n_samples=n_samples, q=q): + for s in random_powerset(subset, n_samples=n_samples, q=q, seed=rng): marginal = u({idx}.union(s)) - u(s) if method == OwenAlgorithm.Antithetic and q != 0.5: s_complement = np.setxor1d(subset, s, assume_unique=True) @@ -93,6 +98,7 @@ def owen_sampling_shapley( n_jobs: int = 1, config: ParallelConfig = ParallelConfig(), progress: bool = False, + seed: Optional[Seed] = None ) -> ValuationResult: r"""Owen sampling of Shapley values as described in :footcite:t:`okhrati_multilinear_2021`. @@ -138,6 +144,8 @@ def owen_sampling_shapley( :param config: Object configuring parallel computation, with cluster address, number of cpus, etc. :param progress: Whether to display progress bars for each job. + :param seed: Either an instance of a numpy random number generator or a seed + for it. :return: Object with the data values. .. versionadded:: 0.3.0 @@ -161,4 +169,4 @@ def owen_sampling_shapley( config=config, ) - return map_reduce_job() + return map_reduce_job(seed=seed) diff --git a/tests/value/__init__.py b/tests/value/__init__.py index ce16e73e4..4eab5ebc6 100644 --- a/tests/value/__init__.py +++ b/tests/value/__init__.py @@ -46,6 +46,7 @@ def check_values( atol: float = 1e-5, *, extra_values_names: Sequence[str] = tuple(), + equal: bool = True, ): """Compares values in dictionaries. @@ -65,13 +66,17 @@ def check_values( have |value - exact_value| < 0.1 for every value. :param extra_values_names: Sequence of names of extra values that should also be compared. + :param equal: True, if it should be checked that the values are equal, False if it + should be checked that they are not equal. """ values.sort() exact_values.sort() - assert np.allclose(values.values, exact_values.values, rtol=rtol, atol=atol) + assert (not equal) ^ np.allclose( + values.values, exact_values.values, rtol=rtol, atol=atol + ) for name in extra_values_names: - assert np.isclose( + assert (not equal) ^ np.isclose( getattr(values, name), getattr(exact_values, name), rtol=rtol, atol=atol ) diff --git a/tests/value/shapley/test_montecarlo.py b/tests/value/shapley/test_montecarlo.py index 0f92cde29..a46d84147 100644 --- a/tests/value/shapley/test_montecarlo.py +++ b/tests/value/shapley/test_montecarlo.py @@ -7,6 +7,7 @@ from pydvl.utils import GroupedDataset, MemcachedConfig, Status, Utility from pydvl.utils.numeric import num_samples_permutation_hoeffding from pydvl.utils.score import Scorer, squashed_r2 +from pydvl.utils.types import Seed from pydvl.value import compute_shapley_values from pydvl.value.shapley import ShapleyMode from pydvl.value.shapley.naive import combinatorial_exact_shapley @@ -62,6 +63,93 @@ def test_analytic_montecarlo_shapley( check_values(values, exact_values, rtol=rtol, atol=atol) +test_cases_montecarlo_shapley_reproducible_stochastic = [ + (12, ShapleyMode.PermutationMontecarlo, {"done": MaxUpdates(10)}), + # FIXME! it should be enough with 2**(len(data)-1) samples + ( + 8, + ShapleyMode.CombinatorialMontecarlo, + {"done": MaxUpdates(2**10)}, + ), + (12, ShapleyMode.Owen, dict(n_samples=4, max_q=200)), + (12, ShapleyMode.OwenAntithetic, dict(n_samples=4, max_q=200)), + ( + 4, + ShapleyMode.GroupTesting, + dict(n_samples=int(21), epsilon=0.2, delta=0.01), + ), +] + + +@pytest.mark.parametrize( + "num_samples, fun, kwargs", test_cases_montecarlo_shapley_reproducible_stochastic +) +def test_analytical_montecarlo_shapley_reproducible( + num_samples, + analytic_shapley, + parallel_config, + n_jobs, + fun: ShapleyMode, + kwargs: dict, + seed: Seed, +): + u, _ = analytic_shapley + values_1 = compute_shapley_values( + u, + mode=fun, + n_jobs=n_jobs, + config=parallel_config, + progress=False, + seed=seed, + **kwargs + ) + values_2 = compute_shapley_values( + u, + mode=fun, + n_jobs=n_jobs, + config=parallel_config, + progress=False, + seed=seed, + **kwargs + ) + check_values(values_1, values_2, rtol=0.0, atol=0.0) + + +@pytest.mark.parametrize( + "num_samples, fun, kwargs", test_cases_montecarlo_shapley_reproducible_stochastic +) +def test_analytical_montecarlo_shapley_stochastic( + num_samples, + analytic_shapley, + parallel_config, + n_jobs, + fun: ShapleyMode, + kwargs: dict, + seed: Seed, + seed_alt: Seed, +): + u, exact_values = analytic_shapley + values_1 = compute_shapley_values( + u, + mode=fun, + n_jobs=n_jobs, + config=parallel_config, + progress=False, + seed=seed, + **kwargs + ) + values_2 = compute_shapley_values( + u, + mode=fun, + n_jobs=n_jobs, + config=parallel_config, + progress=False, + seed=seed_alt, + **kwargs + ) + check_values(values_1, values_2, rtol=0.0, atol=0.0, equal=False) + + @pytest.mark.parametrize("num_samples, delta, eps", [(8, 0.1, 0.1)]) @pytest.mark.parametrize( "fun", [ShapleyMode.PermutationMontecarlo, ShapleyMode.CombinatorialMontecarlo] From 86a22393941cab43de15fe9534da09de825a92d5 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Thu, 31 Aug 2023 06:41:51 +0200 Subject: [PATCH 399/436] Add seed parameter to `pydvl.utils.numeric.random_matrix_with_condition_number`. Added test cases for reproducibility and stochasticity. --- src/pydvl/utils/numeric.py | 10 +++++----- tests/influence/test_torch_differentiable.py | 2 +- tests/utils/test_numeric.py | 19 +++++++++++++++++++ 3 files changed, 25 insertions(+), 6 deletions(-) diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index 0cd6d0571..9c9cac283 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -143,9 +143,7 @@ def random_subset_of_size( def random_matrix_with_condition_number( - n: int, - condition_number: float, - # TODO Add seed parameter + n: int, condition_number: float, seed: Optional[Seed] = None ) -> NDArray: """Constructs a square matrix with a given condition number. @@ -157,6 +155,7 @@ def random_matrix_with_condition_number( :param n: size of the matrix :param condition_number: duh + :param seed: Either an instance of a numpy random number generator or a seed for it. :return: An (n,n) matrix with the requested condition number. """ if n < 2: @@ -165,6 +164,7 @@ def random_matrix_with_condition_number( if condition_number <= 1: raise ValueError("Condition number must be greater than 1") + rng = np.random.default_rng(seed) log_condition_number = np.log(condition_number) exp_vec = np.arange( -log_condition_number / 4.0, @@ -174,8 +174,8 @@ def random_matrix_with_condition_number( exp_vec = exp_vec[:n] s: np.ndarray = np.exp(exp_vec) S = np.diag(s) - U, _ = np.linalg.qr((np.random.rand(n, n) - 5.0) * 200) - V, _ = np.linalg.qr((np.random.rand(n, n) - 5.0) * 200) + U, _ = np.linalg.qr((rng.uniform(size=(n, n)) - 5.0) * 200) + V, _ = np.linalg.qr((rng.uniform(size=(n, n)) - 5.0) * 200) P: np.ndarray = U.dot(S).dot(V.T) P = P.dot(P.T) return P diff --git a/tests/influence/test_torch_differentiable.py b/tests/influence/test_torch_differentiable.py index 621288d6f..2747466a5 100644 --- a/tests/influence/test_torch_differentiable.py +++ b/tests/influence/test_torch_differentiable.py @@ -193,4 +193,4 @@ def test_inversion_methods( ) assert np.allclose(linear_inverse, linear_cg, rtol=1e-1) - assert np.allclose(linear_inverse, linear_lissa, rtol=1e-1) + assert np.allclose(linear_inverse, linear_lissa, rtol=1e-1, atol=2e-1) diff --git a/tests/utils/test_numeric.py b/tests/utils/test_numeric.py index 212ff2db6..77ce63df9 100644 --- a/tests/utils/test_numeric.py +++ b/tests/utils/test_numeric.py @@ -190,6 +190,25 @@ def test_random_matrix_with_condition_number(n, cond, exception): pytest.fail("Matrix is not positive definite") +@pytest.mark.parametrize( + "n, cond", + [ + (2, 10), + (7, 23), + (10, 2), + ], +) +@pytest.mark.parametrize( + "seed,seed_alt", + [(24, 42), (24, 24)], + ids=["different", "same"], +) +def test_random_matrix_with_condition_number_reproducible(n, cond, seed, seed_alt): + mat_1 = random_matrix_with_condition_number(n, cond, seed=seed) + mat_2 = random_matrix_with_condition_number(n, cond, seed=seed_alt) + assert (seed != seed_alt) ^ bool(np.sum(mat_1 != mat_2) == 0) + + def test_running_moments(): """Test that running moments are correct.""" n_samples, n_values = 15, 1000 From 7ff27c0ba10c9c81d6fd42e9a0ff0c00c8fc0804 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Thu, 31 Aug 2023 06:55:00 +0200 Subject: [PATCH 400/436] Fix type hints as noted in https://github.com/appliedAI-Initiative/pyDVL/actions/runs/6033122169/job/16369337328?pr=396. --- src/pydvl/utils/functional.py | 2 +- src/pydvl/utils/types.py | 4 ++-- src/pydvl/value/shapley/gt.py | 2 +- src/pydvl/value/shapley/montecarlo.py | 4 ++-- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/pydvl/utils/functional.py b/src/pydvl/utils/functional.py index 186f1167d..c21c702ae 100644 --- a/src/pydvl/utils/functional.py +++ b/src/pydvl/utils/functional.py @@ -44,7 +44,7 @@ def _unroll_partial_fn(fn: Callable) -> Tuple[Callable, Set[str]]: :return: A tuple of the unrolled function and a set of the parameters that were set by functools.partial. """ - args_set_by_partial = set() + args_set_by_partial: Set[str] = set() def _rec_unroll_partial_function(g: Callable): nonlocal args_set_by_partial diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index 957ef8f51..4fdfff832 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -5,7 +5,7 @@ import functools from abc import ABCMeta -from typing import Any, Callable, Optional, Protocol, TypeVar, Union +from typing import Any, Callable, Optional, Protocol, TypeVar, Union, cast from numpy.random import Generator, SeedSequence from numpy.typing import NDArray @@ -116,6 +116,6 @@ def ensure_seed_sequence( if isinstance(seed, SeedSequence): return seed elif isinstance(seed, Generator): - return seed.bit_generator._seed_seq # noqa + return cast(SeedSequence, seed.bit_generator.seed_seq) # type: ignore else: return SeedSequence(seed) diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index 3c5c75f29..cf24a08d7 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -240,7 +240,7 @@ def reducer( config=config, n_jobs=n_jobs, ) - uu, betas = map_reduce_job(seed=map_reduce_seed_sequence.entropy) + uu, betas = map_reduce_job(seed=cast(int, map_reduce_seed_sequence.entropy)) # Matrix of estimated differences. See Eqs. (3) and (4) in the paper. C = np.zeros(shape=(n, n)) diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index 08c1a0beb..f14a2edb4 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -38,7 +38,7 @@ from concurrent.futures import FIRST_COMPLETED, Future, wait from functools import reduce from itertools import cycle, takewhile -from typing import Optional, Sequence +from typing import Optional, Sequence, cast import numpy as np from deprecate import deprecated @@ -211,7 +211,7 @@ def permutation_montecarlo_shapley( u, truncation, algorithm, - seed=seeds[i].entropy, + seed=cast(int, seeds[i].entropy), ) pending.add(future) From 4455ce98002c5f64825866960ac9b079428bcbcd Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Thu, 31 Aug 2023 07:13:48 +0200 Subject: [PATCH 401/436] Split test cases into reproducible and stochastic to match the other cases. --- tests/utils/test_numeric.py | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/tests/utils/test_numeric.py b/tests/utils/test_numeric.py index 77ce63df9..c8cbcc6be 100644 --- a/tests/utils/test_numeric.py +++ b/tests/utils/test_numeric.py @@ -198,15 +198,24 @@ def test_random_matrix_with_condition_number(n, cond, exception): (10, 2), ], ) +def test_random_matrix_with_condition_number_reproducible(n, cond, seed): + mat_1 = random_matrix_with_condition_number(n, cond, seed=seed) + mat_2 = random_matrix_with_condition_number(n, cond, seed=seed) + assert np.all(mat_1 == mat_2) + + @pytest.mark.parametrize( - "seed,seed_alt", - [(24, 42), (24, 24)], - ids=["different", "same"], + "n, cond", + [ + (2, 10), + (7, 23), + (10, 2), + ], ) -def test_random_matrix_with_condition_number_reproducible(n, cond, seed, seed_alt): +def test_random_matrix_with_condition_number_stochastic(n, cond, seed, seed_alt): mat_1 = random_matrix_with_condition_number(n, cond, seed=seed) mat_2 = random_matrix_with_condition_number(n, cond, seed=seed_alt) - assert (seed != seed_alt) ^ bool(np.sum(mat_1 != mat_2) == 0) + assert np.any(mat_1 != mat_2) def test_running_moments(): From 611cb0d04a131bbc6abfa93f2e447fed91e0e0e8 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Fri, 1 Sep 2023 04:47:00 +0200 Subject: [PATCH 402/436] Remove constructors from samplers by using mixin formalism correctly. --- src/pydvl/value/sampler.py | 32 ++++++++++---------------------- tests/value/test_sampler.py | 4 ++-- 2 files changed, 12 insertions(+), 24 deletions(-) diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 4f29b1be7..7986e9247 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -120,6 +120,7 @@ def __init__( indices: NDArray[T], index_iteration: IndexIteration = IndexIteration.Sequential, outer_indices: NDArray[T] = None, + **kwargs, ): """ :param indices: The set of items (indices) to sample from. @@ -221,7 +222,8 @@ def weight(cls, n: int, subset_len: int) -> float: class StochasticSamplerMixin: """Mixin class for samplers which use a random number generator.""" - def __init__(self, seed: Optional[Seed] = None): + def __init__(self, *args, seed: Optional[Seed] = None, **kwargs): + super().__init__(*args, **kwargs) self._rng = np.random.default_rng(seed) @@ -264,7 +266,7 @@ def weight(cls, n: int, subset_len: int) -> float: return float(2 ** (n - 1)) if n > 0 else 1.0 -class UniformSampler(PowersetSampler[T], StochasticSamplerMixin): +class UniformSampler(StochasticSamplerMixin, PowersetSampler[T]): """An iterator to perform uniform random sampling of subsets. Iterating over every index $i$, either in sequence or at random depending on @@ -286,10 +288,6 @@ class UniformSampler(PowersetSampler[T], StochasticSamplerMixin): """ - def __init__(self, *args, seed: Optional[Seed] = None, **kwargs): - super().__init__(*args, **kwargs) - StochasticSamplerMixin.__init__(self, seed=seed) - def __iter__(self) -> Iterator[SampleT]: while True: for idx in self.iterindices(): @@ -315,7 +313,7 @@ def __init__(self, indices: NDArray[T], *args, **kwargs): void(indices, args, kwargs) -class AntitheticSampler(PowersetSampler[T], StochasticSamplerMixin): +class AntitheticSampler(StochasticSamplerMixin, PowersetSampler[T]): """An iterator to perform uniform random sampling of subsets, and their complements. @@ -324,10 +322,6 @@ class AntitheticSampler(PowersetSampler[T], StochasticSamplerMixin): the set $S$, including the index $i$ itself. """ - def __init__(self, *args, seed: Optional[Seed] = None, **kwargs): - super().__init__(*args, **kwargs) - StochasticSamplerMixin.__init__(self, seed=seed) - def __iter__(self) -> Iterator[SampleT]: while True: for idx in self.iterindices(): @@ -344,7 +338,7 @@ def weight(cls, n: int, subset_len: int) -> float: return float(2 ** (n - 1)) if n > 0 else 1.0 -class PermutationSampler(PowersetSampler[T], StochasticSamplerMixin): +class PermutationSampler(StochasticSamplerMixin, PowersetSampler[T]): """Sample permutations of indices and iterate through each returning increasing subsets, as required for the permutation definition of semi-values. @@ -361,10 +355,6 @@ class PermutationSampler(PowersetSampler[T], StochasticSamplerMixin): will be doubled wrt. a "direct" implementation of permutation MC """ - def __init__(self, *args, seed: Optional[Seed] = None, **kwargs): - super().__init__(*args, **kwargs) - StochasticSamplerMixin.__init__(self, seed=seed) - def __iter__(self) -> Iterator[SampleT]: while True: permutation = self._rng.permutation(self._indices) @@ -408,17 +398,13 @@ def __iter__(self) -> Iterator[SampleT]: self._n_samples += 1 -class RandomHierarchicalSampler(PowersetSampler[T], StochasticSamplerMixin): +class RandomHierarchicalSampler(StochasticSamplerMixin, PowersetSampler[T]): """For every index, sample a set size, then a set of that size. .. todo:: This is unnecessary, but a step towards proper stratified sampling. """ - def __init__(self, *args, seed: Optional[Seed] = None, **kwargs): - super().__init__(*args, **kwargs) - StochasticSamplerMixin.__init__(self, seed=seed) - def __iter__(self) -> Iterator[SampleT]: while True: for idx in self.iterindices(): @@ -436,6 +422,8 @@ def weight(cls, n: int, subset_len: int) -> float: return float(2 ** (n - 1)) if n > 0 else 1.0 +# TODO Replace by Intersection[StochasticSamplerMixin, PowersetSampler[T]] +# See https://github.com/python/typing/issues/213 StochasticSampler = Union[ - UniformSampler, PermutationSampler, RandomHierarchicalSampler, AntitheticSampler + UniformSampler, PermutationSampler, AntitheticSampler, RandomHierarchicalSampler ] diff --git a/tests/value/test_sampler.py b/tests/value/test_sampler.py index 87d9db31d..ed402da1d 100644 --- a/tests/value/test_sampler.py +++ b/tests/value/test_sampler.py @@ -116,11 +116,11 @@ def test_chunkify_permutation(sampler_class): def _create_seeded_sample_iter( - sampler_class: Type[StochasticSampler], + sampler_t: Type[StochasticSampler], indices: List, seed: Seed, ) -> Iterator: max_iterations = len(indices) - sampler = sampler_class(np.array(indices), seed=seed) + sampler = sampler_t(indices=np.array(indices), seed=seed) sample_stream = takewhile(lambda _: sampler.n_samples < max_iterations, sampler) return sample_stream From 12e90abd00430333c33d5cd675b87accf7778a50 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Fri, 1 Sep 2023 04:48:24 +0200 Subject: [PATCH 403/436] Remove comment from functional.py --- src/pydvl/utils/functional.py | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/pydvl/utils/functional.py b/src/pydvl/utils/functional.py index c21c702ae..ee191cb03 100644 --- a/src/pydvl/utils/functional.py +++ b/src/pydvl/utils/functional.py @@ -21,18 +21,12 @@ def fn_accepts_param_name(fn: Callable, param_name: str) -> bool: sig = inspect.signature(wrapped_fn) params = sig.parameters - # Check if the parameter was set by functools.partial if param_name in args_set_by_partial: return False - # Check if the function accepts the specific parameter if param_name in params: return True - # Check if the function accepts **kwargs - if any(p.kind == p.VAR_KEYWORD for p in params.values()): - return True - return False From 9186d4f8e876ee34bea8fdfb17dd380812832db1 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Fri, 1 Sep 2023 04:49:05 +0200 Subject: [PATCH 404/436] Extract separate method `call_fun_remove_arg`. Integrate backlog class for repetition of experiments. Create test case for semivalues reproducibility. Change from linear dataset to housing dataset. --- src/pydvl/utils/parallel/backlog.py | 37 +++++++++++ src/pydvl/utils/parallel/map_reduce.py | 5 +- src/pydvl/utils/types.py | 47 +++++++++++--- src/pydvl/value/sampler.py | 2 +- src/pydvl/value/semivalues.py | 10 ++- src/pydvl/value/shapley/gt.py | 7 ++- src/pydvl/value/shapley/montecarlo.py | 22 ++++--- tests/value/__init__.py | 7 +-- tests/value/shapley/test_montecarlo.py | 82 +++++++++++------------- tests/value/test_semivalues.py | 87 +++++++++++++++++++++++++- 10 files changed, 228 insertions(+), 78 deletions(-) create mode 100644 src/pydvl/utils/parallel/backlog.py diff --git a/src/pydvl/utils/parallel/backlog.py b/src/pydvl/utils/parallel/backlog.py new file mode 100644 index 000000000..3cd3ea1d0 --- /dev/null +++ b/src/pydvl/utils/parallel/backlog.py @@ -0,0 +1,37 @@ +from copy import copy +from functools import partial +from typing import Callable, Generator, Generic, List, Tuple, TypeVar + +T = TypeVar("T") + + +def wrap_index(*args, i: int, fn: Callable, **kwargs): + return i, fn(*args, **kwargs) + + +class Backlog(Generic[T]): + """A backlog is a queue of items added in no particular order. Each item has an + index used to determine the sequence in which the items are processed. A function + call can be modified using the wrap method to include this index in the output. + This modification should be applied before invoking the function.""" + + def __init__(self): + self._backlog: List[Tuple[int, T]] = [] + self._n_delivered = 0 + self._n_registered = 0 + self._n_wrapped = 0 + + def add(self, item: Tuple[int, T]): + self._backlog.append(item) + self._backlog = sorted(self._backlog, key=lambda t: t[0]) + self._n_registered += 1 + + def get(self) -> Generator[T, None, None]: + while len(self._backlog) > 0 and self._backlog[0][0] == self._n_delivered: + self._n_delivered += 1 + yield self._backlog[0][1] + self._backlog = self._backlog[1:] + + def wrap(self, fn: Callable) -> Callable: + self._n_wrapped += 1 + return partial(wrap_index, fn=fn, i=copy(self._n_wrapped - 1)) diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index dfd3de534..1226089a8 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -1,3 +1,4 @@ +import pickle from functools import reduce from itertools import accumulate, repeat from typing import Any, Collection, Dict, Generic, List, Optional, TypeVar, Union @@ -107,7 +108,7 @@ def __init__( def __call__( self, - seed: Optional[Seed] = None, + seed: Optional[Union[Seed, SeedSequence]] = None, ) -> R: """ Runs the map-reduce job. @@ -130,7 +131,7 @@ def __call__( chunks = self._chunkify(self.inputs_, n_chunks=self.n_jobs) map_results: List[R] = parallel( delayed(self._map_func)( - next_chunk, job_id=j, seed=seed.entropy, **self.map_kwargs + next_chunk, job_id=j, seed=seed, **self.map_kwargs ) for j, (next_chunk, seed) in enumerate( zip(chunks, seed_seq.spawn(len(chunks))) diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index 4fdfff832..a998a11ba 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -5,7 +5,8 @@ import functools from abc import ABCMeta -from typing import Any, Callable, Optional, Protocol, TypeVar, Union, cast +from copy import deepcopy +from typing import Any, Callable, Optional, Protocol, Tuple, TypeVar, Union, cast from numpy.random import Generator, SeedSequence from numpy.typing import NDArray @@ -46,6 +47,24 @@ def score(self, x: NDArray, y: NDArray) -> float: pass +def call_fun_remove_arg(*args, fun: Callable, arg: str, **kwargs): + """ + Calls the given function with the given arguments, but removes the given argument. + + :param args: Positional arguments to pass to the function. + :param fun: The function to call. + :param arg: The name of the argument to remove. + :param kwargs: Keyword arguments to pass to the function. + :return: The return value of the function. + """ + try: + del kwargs[arg] + except KeyError: + pass + + return fun(*args, **kwargs) + + def maybe_add_argument(fun: Callable, new_arg: str): """Wraps a function to accept the given keyword parameter if it doesn't already. @@ -62,15 +81,7 @@ def maybe_add_argument(fun: Callable, new_arg: str): if fn_accepts_param_name(fun, new_arg): return fun - @functools.wraps(fun) - def wrapper(*args, **kwargs): - try: - del kwargs[new_arg] - except KeyError: - pass - return fun(*args, **kwargs) - - return wrapper + return functools.partial(call_fun_remove_arg, fun=fun, arg=new_arg) class NoPublicConstructor(ABCMeta): @@ -119,3 +130,19 @@ def ensure_seed_sequence( return cast(SeedSequence, seed.bit_generator.seed_seq) # type: ignore else: return SeedSequence(seed) + + +def call_fn_multiple_seeds( + fn: Callable, *args, seeds: Tuple[Seed, ...], **kwargs +) -> Tuple: + """ + Execute a function multiple times with different seeds. It copies the arguments + and keyword arguments before passing them to the function. + + :param fn: The function to execute. + :param args: The arguments to pass to the function. + :param seeds: The seeds to use. + :param kwargs: The keyword arguments to pass to the function. + :return: A tuple of the results of the function. + """ + return tuple(fn(*deepcopy(args), **deepcopy(kwargs), seed=seed) for seed in seeds) diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index 7986e9247..121568139 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -53,7 +53,7 @@ from numpy.typing import NDArray from pydvl.utils.numeric import powerset, random_subset, random_subset_of_size -from pydvl.utils.types import Seed, ensure_seed_sequence +from pydvl.utils.types import Seed __all__ = [ "AntitheticSampler", diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 780eaf022..98bad0ee6 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -62,7 +62,8 @@ from tqdm import tqdm from pydvl.utils import ParallelConfig, Utility -from pydvl.utils.types import Seed, ensure_seed_sequence +from pydvl.utils.parallel.backlog import Backlog +from pydvl.utils.types import Seed from pydvl.value import ValuationResult from pydvl.value.sampler import ( PermutationSampler, @@ -175,6 +176,7 @@ def semivalues( sampler_it = iter(sampler) pbar = tqdm(disable=not progress, total=100, unit="%") + backlog = Backlog[Tuple[int, float]]() with init_executor( max_workers=max_workers, config=config, cancel_futures=True @@ -186,7 +188,9 @@ def semivalues( completed, pending = wait(pending, timeout=1, return_when=FIRST_COMPLETED) for future in completed: - idx, marginal = future.result() + backlog.add(future.result()) + + for idx, marginal in backlog.get(): result.update(idx, marginal) if done(result): return result @@ -196,7 +200,7 @@ def semivalues( for _ in range(n_submitted_jobs - len(pending)): pending.add( executor.submit( - _marginal, + backlog.wrap(_marginal), u=u, coefficient=correction, sample=next(sampler_it), diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index cf24a08d7..188977ec3 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -17,10 +17,11 @@ """ import logging from collections import namedtuple -from typing import Iterable, Optional, Tuple, TypeVar, cast +from typing import Iterable, Optional, Tuple, TypeVar, Union, cast import cvxpy as cp import numpy as np +from numpy.random import SeedSequence from numpy.typing import NDArray from pydvl.utils import MapReduceJob, ParallelConfig, Utility, maybe_progress @@ -119,7 +120,7 @@ def _group_testing_shapley( n_samples: int, progress: bool = False, job_id: int = 1, - seed: Optional[Seed] = None, + seed: Optional[Union[Seed, SeedSequence]] = None, ): """Helper function for :func:`group_testing_shapley`. @@ -240,7 +241,7 @@ def reducer( config=config, n_jobs=n_jobs, ) - uu, betas = map_reduce_job(seed=cast(int, map_reduce_seed_sequence.entropy)) + uu, betas = map_reduce_job(seed=map_reduce_seed_sequence) # Matrix of estimated differences. See Eqs. (3) and (4) in the paper. C = np.zeros(shape=(n, n)) diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index f14a2edb4..baae5bca7 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -38,10 +38,11 @@ from concurrent.futures import FIRST_COMPLETED, Future, wait from functools import reduce from itertools import cycle, takewhile -from typing import Optional, Sequence, cast +from typing import Optional, Sequence, Union import numpy as np from deprecate import deprecated +from numpy.random import SeedSequence from numpy.typing import NDArray from tqdm import tqdm @@ -49,11 +50,12 @@ from pydvl.utils.config import ParallelConfig from pydvl.utils.numeric import random_powerset from pydvl.utils.parallel import CancellationPolicy, MapReduceJob +from pydvl.utils.parallel.backlog import Backlog from pydvl.utils.types import Seed, ensure_seed_sequence from pydvl.utils.utility import Utility from pydvl.value.result import ValuationResult from pydvl.value.shapley.truncated import NoTruncation, TruncationPolicy -from pydvl.value.stopping import MaxChecks, StoppingCriterion +from pydvl.value.stopping import StoppingCriterion logger = logging.getLogger(__name__) @@ -64,7 +66,7 @@ def _permutation_montecarlo_one_step( u: Utility, truncation: TruncationPolicy, algorithm_name: str, - seed: Optional[Seed] = None, + seed: Optional[Union[Seed, SeedSequence]] = None, ) -> ValuationResult: """Helper function for :func:`permutation_montecarlo_shapley`. @@ -182,6 +184,8 @@ def permutation_montecarlo_shapley( result = ValuationResult.zeros(algorithm=algorithm) pbar = tqdm(disable=not progress, total=100, unit="%") + n_submitted = 0 + backlog = Backlog[ValuationResult]() with init_executor( max_workers=max_workers, config=config, cancel_futures=CancellationPolicy.ALL @@ -194,9 +198,12 @@ def permutation_montecarlo_shapley( completed, pending = wait( pending, timeout=config.wait_timeout, return_when=FIRST_COMPLETED ) - for future in completed: - result += future.result() + backlog.add(future.result()) + + for future_result in backlog.get(): + result += future_result + # we could check outside the loop, but that means more # submissions if the stopping criterion is unstable if done(result): @@ -207,12 +214,13 @@ def permutation_montecarlo_shapley( seeds = seed_sequence.spawn(n_remaining_slots) for i in range(n_remaining_slots): future = executor.submit( - _permutation_montecarlo_one_step, + backlog.wrap(_permutation_montecarlo_one_step), u, truncation, algorithm, - seed=cast(int, seeds[i].entropy), + seed=seeds[i], ) + n_submitted += 1 pending.add(future) diff --git a/tests/value/__init__.py b/tests/value/__init__.py index 4eab5ebc6..795eef798 100644 --- a/tests/value/__init__.py +++ b/tests/value/__init__.py @@ -46,7 +46,6 @@ def check_values( atol: float = 1e-5, *, extra_values_names: Sequence[str] = tuple(), - equal: bool = True, ): """Compares values in dictionaries. @@ -72,11 +71,9 @@ def check_values( values.sort() exact_values.sort() - assert (not equal) ^ np.allclose( - values.values, exact_values.values, rtol=rtol, atol=atol - ) + assert np.allclose(values.values, exact_values.values, rtol=rtol, atol=atol) for name in extra_values_names: - assert (not equal) ^ np.isclose( + assert np.isclose( getattr(values, name), getattr(exact_values, name), rtol=rtol, atol=atol ) diff --git a/tests/value/shapley/test_montecarlo.py b/tests/value/shapley/test_montecarlo.py index a46d84147..4c4032fa9 100644 --- a/tests/value/shapley/test_montecarlo.py +++ b/tests/value/shapley/test_montecarlo.py @@ -1,19 +1,28 @@ import logging +from copy import copy, deepcopy import numpy as np import pytest from sklearn.linear_model import LinearRegression -from pydvl.utils import GroupedDataset, MemcachedConfig, Status, Utility +from pydvl.utils import ( + Dataset, + GroupedDataset, + MemcachedConfig, + ParallelConfig, + Status, + Utility, +) from pydvl.utils.numeric import num_samples_permutation_hoeffding from pydvl.utils.score import Scorer, squashed_r2 -from pydvl.utils.types import Seed +from pydvl.utils.types import Seed, call_fn_multiple_seeds from pydvl.value import compute_shapley_values from pydvl.value.shapley import ShapleyMode from pydvl.value.shapley.naive import combinatorial_exact_shapley from pydvl.value.stopping import MaxChecks, MaxUpdates from .. import check_rank_correlation, check_total_value, check_values +from ..conftest import polynomial_dataset log = logging.getLogger(__name__) @@ -64,12 +73,12 @@ def test_analytic_montecarlo_shapley( test_cases_montecarlo_shapley_reproducible_stochastic = [ - (12, ShapleyMode.PermutationMontecarlo, {"done": MaxUpdates(10)}), + (12, ShapleyMode.PermutationMontecarlo, {"done": MaxChecks(1)}), # FIXME! it should be enough with 2**(len(data)-1) samples ( 8, ShapleyMode.CombinatorialMontecarlo, - {"done": MaxUpdates(2**10)}, + {"done": MaxChecks(1)}, ), (12, ShapleyMode.Owen, dict(n_samples=4, max_q=200)), (12, ShapleyMode.OwenAntithetic, dict(n_samples=4, max_q=200)), @@ -84,70 +93,55 @@ def test_analytic_montecarlo_shapley( @pytest.mark.parametrize( "num_samples, fun, kwargs", test_cases_montecarlo_shapley_reproducible_stochastic ) -def test_analytical_montecarlo_shapley_reproducible( - num_samples, - analytic_shapley, - parallel_config, - n_jobs, +@pytest.mark.parametrize("num_points, num_features", [(12, 3)]) +def test_montecarlo_shapley_housing_dataset_reproducible( + num_samples: int, + housing_dataset: Dataset, + parallel_config: ParallelConfig, + n_jobs: int, fun: ShapleyMode, kwargs: dict, seed: Seed, ): - u, _ = analytic_shapley - values_1 = compute_shapley_values( - u, - mode=fun, - n_jobs=n_jobs, - config=parallel_config, - progress=False, - seed=seed, - **kwargs - ) - values_2 = compute_shapley_values( - u, + values_1, values_2 = call_fn_multiple_seeds( + compute_shapley_values, + Utility(LinearRegression(), data=housing_dataset, scorer="r2"), mode=fun, n_jobs=n_jobs, config=parallel_config, progress=False, - seed=seed, - **kwargs + seeds=(seed, seed), + **deepcopy(kwargs) ) - check_values(values_1, values_2, rtol=0.0, atol=0.0) + np.testing.assert_equal(values_1.values, values_2.values) @pytest.mark.parametrize( "num_samples, fun, kwargs", test_cases_montecarlo_shapley_reproducible_stochastic ) -def test_analytical_montecarlo_shapley_stochastic( - num_samples, - analytic_shapley, - parallel_config, - n_jobs, +@pytest.mark.parametrize("num_points, num_features", [(12, 4)]) +def test_montecarlo_shapley_housing_dataset_stochastic( + num_samples: int, + housing_dataset: Dataset, + parallel_config: ParallelConfig, + n_jobs: int, fun: ShapleyMode, kwargs: dict, seed: Seed, seed_alt: Seed, ): - u, exact_values = analytic_shapley - values_1 = compute_shapley_values( - u, - mode=fun, - n_jobs=n_jobs, - config=parallel_config, - progress=False, - seed=seed, - **kwargs - ) - values_2 = compute_shapley_values( - u, + values_1, values_2 = call_fn_multiple_seeds( + compute_shapley_values, + Utility(LinearRegression(), data=housing_dataset, scorer="r2"), mode=fun, n_jobs=n_jobs, config=parallel_config, progress=False, - seed=seed_alt, - **kwargs + seeds=(seed, seed_alt), + **deepcopy(kwargs) ) - check_values(values_1, values_2, rtol=0.0, atol=0.0, equal=False) + with pytest.raises(AssertionError): + np.testing.assert_equal(values_1.values, values_2.values) @pytest.mark.parametrize("num_samples, delta, eps", [(8, 0.1, 0.1)]) diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index bc39deb39..48c355ee2 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -1,10 +1,13 @@ import math -from typing import Dict, Type +from typing import Type import numpy as np import pytest +from sklearn.linear_model import LinearRegression -from pydvl.utils import ParallelConfig, Utility +from pydvl.utils import Dataset, ParallelConfig, Utility +from pydvl.utils.types import Seed, call_fn_multiple_seeds +from pydvl.value import ValuationResult from pydvl.value.sampler import ( AntitheticSampler, DeterministicPermutationSampler, @@ -20,7 +23,7 @@ semivalues, shapley_coefficient, ) -from pydvl.value.stopping import AbsoluteStandardError, MaxUpdates +from pydvl.value.stopping import AbsoluteStandardError, MaxUpdates, StoppingCriterion from . import check_values @@ -58,6 +61,84 @@ def test_shapley( check_values(values, exact_values, rtol=0.2) +def semivalues_seed_wrapper( + sampler_t: Type[PowersetSampler], u: Utility, *args, seed: Seed, **kwargs +) -> ValuationResult: + """ + Wrapper for semivalues that takes a seed as an argument to be used with + call_fn_multiple_seeds. + """ + sampler = sampler_t(u.data.indices, seed=seed) + return semivalues(sampler, u, *args, **kwargs) + + +@pytest.mark.parametrize("num_samples", [5]) +@pytest.mark.parametrize( + "sampler_t", + [ + UniformSampler, + PermutationSampler, + AntitheticSampler, + ], +) +@pytest.mark.parametrize("coefficient", [shapley_coefficient, beta_coefficient(1, 1)]) +@pytest.mark.parametrize("num_points, num_features", [(12, 3)]) +def test_semivalues_shapley_reproducible( + num_samples: int, + housing_dataset: Dataset, + sampler_t: Type[PowersetSampler], + coefficient: SVCoefficient, + n_jobs: int, + parallel_config: ParallelConfig, + seed: Seed, +): + values_1, values_2 = call_fn_multiple_seeds( + semivalues_seed_wrapper, + sampler_t, + Utility(LinearRegression(), data=housing_dataset, scorer="r2"), + coefficient, + AbsoluteStandardError(0.02, 1.0) | MaxUpdates(2 ** (num_samples * 2)), + n_jobs=n_jobs, + config=parallel_config, + seeds=(seed, seed), + ) + assert np.all(values_1.values == values_2.values) + + +@pytest.mark.parametrize("num_samples", [5]) +@pytest.mark.parametrize( + "sampler_t", + [ + UniformSampler, + PermutationSampler, + AntitheticSampler, + ], +) +@pytest.mark.parametrize("coefficient", [shapley_coefficient, beta_coefficient(1, 1)]) +@pytest.mark.parametrize("num_points, num_features", [(12, 3)]) +def test_semivalues_shapley_stochastic( + num_samples: int, + housing_dataset: Dataset, + sampler_t: Type[PowersetSampler], + coefficient: SVCoefficient, + n_jobs: int, + parallel_config: ParallelConfig, + seed: Seed, + seed_alt: Seed, +): + values_1, values_2 = call_fn_multiple_seeds( + semivalues_seed_wrapper, + sampler_t, + Utility(LinearRegression(), data=housing_dataset, scorer="r2"), + coefficient, + AbsoluteStandardError(0.02, 1.0) | MaxUpdates(2 ** (num_samples * 2)), + n_jobs=n_jobs, + config=parallel_config, + seeds=(seed, seed_alt), + ) + assert np.any(values_1.values != values_2.values) + + @pytest.mark.parametrize("num_samples", [5]) @pytest.mark.parametrize( "sampler", From c67031351afccf607906120834675b68f2f334ff Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 1 Sep 2023 11:20:45 +0200 Subject: [PATCH 405/436] Fix links after repo ownership change --- .github/PULL_REQUEST_TEMPLATE.md | 2 +- CHANGELOG.md | 120 +++++++++++++++---------------- CITATION.cff | 2 +- CONTRIBUTING.md | 8 +-- README.md | 16 ++--- docs/conf.py | 12 ++-- docs/index.rst | 2 +- notebooks/support/shapley.py | 2 +- setup.py | 4 +- 9 files changed, 84 insertions(+), 84 deletions(-) diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md index bca771635..e1088dfc7 100644 --- a/.github/PULL_REQUEST_TEMPLATE.md +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -1,7 +1,7 @@ ### Description diff --git a/CHANGELOG.md b/CHANGELOG.md index c7a0fe0b3..5895965d5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,131 +3,131 @@ ## Unreleased - Made ray an optional dependency, relying on joblib as default parallel backend - [PR #408](https://github.com/appliedAI-Initiative/pyDVL/pull/408) + [PR #408](https://github.com/aai-institute/pyDVL/pull/408) - Enabled parallel computation for Leave-One-Out values - [PR #406](https://github.com/appliedAI-Initiative/pyDVL/pull/406) + [PR #406](https://github.com/aai-institute/pyDVL/pull/406) - Fixes to parallel computation of generic semi-values: properly handle all samplers and stopping criteria, irrespective of parallel backend - [PR #372](https://github.com/appliedAI-Initiative/pyDVL/pull/372) + [PR #372](https://github.com/aai-institute/pyDVL/pull/372) - Optimises memory usage in IF calculation - [PR #375](https://github.com/appliedAI-Initiative/pyDVL/pull/376) + [PR #375](https://github.com/aai-institute/pyDVL/pull/376) - **Breaking Changes** Return information about hessian inversion from compute_influence_factors, thus changing signature - [PR #375](https://github.com/appliedAI-Initiative/pyDVL/pull/376) + [PR #375](https://github.com/aai-institute/pyDVL/pull/376) - Fix adding valuation results with overlapping indices and different lengths - [PR #370](https://github.com/appliedAI-Initiative/pyDVL/pull/370) + [PR #370](https://github.com/aai-institute/pyDVL/pull/370) - Fixed bugs in conjugate gradient and `linear_solve` - [PR #358](https://github.com/appliedAI-Initiative/pyDVL/pull/358) + [PR #358](https://github.com/aai-institute/pyDVL/pull/358) - Improvements to IF documentation - [PR #371](https://github.com/appliedAI-Initiative/pyDVL/pull/371) + [PR #371](https://github.com/aai-institute/pyDVL/pull/371) - Major changes to IF interface and functionality - [PR #278](https://github.com/appliedAI-Initiative/pyDVL/pull/278) - [PR #394](https://github.com/appliedAI-Initiative/pyDVL/pull/394) + [PR #278](https://github.com/aai-institute/pyDVL/pull/278) + [PR #394](https://github.com/aai-institute/pyDVL/pull/394) - **New Method**: Implements solving the hessian equation via spectral low-rank approximation - [PR #365](https://github.com/appliedAI-Initiative/pyDVL/pull/365) + [PR #365](https://github.com/aai-institute/pyDVL/pull/365) - **Breaking Changes**: - Add new joblib backend and set it as default instead of the ray backend. Simplify the MapReduceJob class. - [PR #355](https://github.com/appliedAI-Initiative/pyDVL/pull/355) + [PR #355](https://github.com/aai-institute/pyDVL/pull/355) - Bump torch dependency for influence package to 2.0 - [PR #365](https://github.com/appliedAI-Initiative/pyDVL/pull/365) + [PR #365](https://github.com/aai-institute/pyDVL/pull/365) - **Bug fix** Fix installation of dev requirements for Python3.10 - [PR #382](https://github.com/appliedAI-Initiative/pyDVL/pull/382) + [PR #382](https://github.com/aai-institute/pyDVL/pull/382) - Decouple ray.init from ParallelConfig - [PR #373](https://github.com/appliedAI-Initiative/pyDVL/pull/383) + [PR #373](https://github.com/aai-institute/pyDVL/pull/383) ## 0.6.1 - 🏗 Bug fixes and small improvement - Fix parsing keyword arguments of `compute_semivalues` dispatch function - [PR #333](https://github.com/appliedAI-Initiative/pyDVL/pull/333) + [PR #333](https://github.com/aai-institute/pyDVL/pull/333) - Create new `RayExecutor` class based on the concurrent.futures API, use the new class to fix an issue with Truncated Monte Carlo Shapley (TMCS) starting too many processes and dying, plus other small changes - [PR #329](https://github.com/appliedAI-Initiative/pyDVL/pull/329) + [PR #329](https://github.com/aai-institute/pyDVL/pull/329) - Fix creation of GroupedDataset objects using the `from_arrays` and `from_sklearn` class methods - [PR #324](https://github.com/appliedAI-Initiative/pyDVL/pull/334) + [PR #324](https://github.com/aai-institute/pyDVL/pull/334) - Fix release job not triggering on CI when a new tag is pushed - [PR #331](https://github.com/appliedAI-Initiative/pyDVL/pull/331) + [PR #331](https://github.com/aai-institute/pyDVL/pull/331) - Added alias `ApproShapley` from Castro et al. 2009 for permutation Shapley - [PR #332](https://github.com/appliedAI-Initiative/pyDVL/pull/332) + [PR #332](https://github.com/aai-institute/pyDVL/pull/332) ## 0.6.0 - 🆕 New algorithms, cleanup and bug fixes 🏗 - Fixes in `ValuationResult`: bugs around data names, semantics of `empty()`, new method `zeros()` and normalised random values - [PR #327](https://github.com/appliedAI-Initiative/pyDVL/pull/327) + [PR #327](https://github.com/aai-institute/pyDVL/pull/327) - **New method**: Implements generalised semi-values for data valuation, including Data Banzhaf and Beta Shapley, with configurable sampling strategies - [PR #319](https://github.com/appliedAI-Initiative/pyDVL/pull/319) + [PR #319](https://github.com/aai-institute/pyDVL/pull/319) - Adds kwargs parameter to `from_array` and `from_sklearn` Dataset and GroupedDataset class methods - [PR #316](https://github.com/appliedAI-Initiative/pyDVL/pull/316) + [PR #316](https://github.com/aai-institute/pyDVL/pull/316) - PEP-561 conformance: added `py.typed` - [PR #307](https://github.com/appliedAI-Initiative/pyDVL/pull/307) + [PR #307](https://github.com/aai-institute/pyDVL/pull/307) - Removed default non-negativity constraint on least core subsidy and added instead a `non_negative_subsidy` boolean flag. Renamed `options` to `solver_options` and pass it as dict. Change default least-core solver to SCS with 10000 max_iters. - [PR #304](https://github.com/appliedAI-Initiative/pyDVL/pull/304) + [PR #304](https://github.com/aai-institute/pyDVL/pull/304) - Cleanup: removed unnecessary decorator `@unpackable` - [PR #233](https://github.com/appliedAI-Initiative/pyDVL/pull/233) + [PR #233](https://github.com/aai-institute/pyDVL/pull/233) - Stopping criteria: fixed problem with `StandardError` and enable proper composition of index convergence statuses. Fixed a bug with `n_jobs` in `truncated_montecarlo_shapley`. - [PR #300](https://github.com/appliedAI-Initiative/pyDVL/pull/300) and - [PR #305](https://github.com/appliedAI-Initiative/pyDVL/pull/305) + [PR #300](https://github.com/aai-institute/pyDVL/pull/300) and + [PR #305](https://github.com/aai-institute/pyDVL/pull/305) - Shuffling code around to allow for simpler user imports, some cleanup and documentation fixes. - [PR #284](https://github.com/appliedAI-Initiative/pyDVL/pull/284) + [PR #284](https://github.com/aai-institute/pyDVL/pull/284) - **Bug fix**: Warn instead of raising an error when `n_iterations` is less than the size of the dataset in Monte Carlo Least Core - [PR #281](https://github.com/appliedAI-Initiative/pyDVL/pull/281) + [PR #281](https://github.com/aai-institute/pyDVL/pull/281) ## 0.5.0 - 💥 Fixes, nicer interfaces and... more breaking changes 😒 - Fixed parallel and antithetic Owen sampling for Shapley values. Simplified and extended tests. - [PR #267](https://github.com/appliedAI-Initiative/pyDVL/pull/267) + [PR #267](https://github.com/aai-institute/pyDVL/pull/267) - Added `Scorer` class for a cleaner interface. Fixed minor bugs around Group-Testing Shapley, added more tests and switched to cvxpy for the solver. - [PR #264](https://github.com/appliedAI-Initiative/pyDVL/pull/264) + [PR #264](https://github.com/aai-institute/pyDVL/pull/264) - Generalised stopping criteria for valuation algorithms. Improved classes `ValuationResult` and `Status` with more operations. Some minor issues fixed. - [PR #252](https://github.com/appliedAI-Initiative/pyDVL/pull/250) + [PR #252](https://github.com/aai-institute/pyDVL/pull/250) - Fixed a bug whereby `compute_shapley_values` would only spawn one process when using `n_jobs=-1` and Monte Carlo methods. - [PR #270](https://github.com/appliedAI-Initiative/pyDVL/pull/270) + [PR #270](https://github.com/aai-institute/pyDVL/pull/270) - Bugfix in `RayParallelBackend`: wrong semantics for `kwargs`. - [PR #268](https://github.com/appliedAI-Initiative/pyDVL/pull/268) + [PR #268](https://github.com/aai-institute/pyDVL/pull/268) - Splitting of problem preparation and solution in Least-Core computation. Umbrella function for LC methods. - [PR #257](https://github.com/appliedAI-Initiative/pyDVL/pull/257) + [PR #257](https://github.com/aai-institute/pyDVL/pull/257) - Operations on `ValuationResult` and `Status` and some cleanup - [PR #248](https://github.com/appliedAI-Initiative/pyDVL/pull/248) + [PR #248](https://github.com/aai-institute/pyDVL/pull/248) - **Bug fix and minor improvements**: Fixes bug in TMCS with remote Ray cluster, raises an error for dummy sequential parallel backend with TMCS, clones model inside `Utility` before fitting by default, with flag `clone_before_fit` to disable it, catches all warnings in `Utility` when `show_warnings` is `False`. Adds Miner and Gloves toy games utilities - [PR #247](https://github.com/appliedAI-Initiative/pyDVL/pull/247) + [PR #247](https://github.com/aai-institute/pyDVL/pull/247) ## 0.4.0 - 🏭💥 New algorithms and more breaking changes - GH action to mark issues as stale - [PR #201](https://github.com/appliedAI-Initiative/pyDVL/pull/201) + [PR #201](https://github.com/aai-institute/pyDVL/pull/201) - Disabled caching of Utility values as well as repeated evaluations by default - [PR #211](https://github.com/appliedAI-Initiative/pyDVL/pull/211) + [PR #211](https://github.com/aai-institute/pyDVL/pull/211) - Test and officially support Python version 3.9 and 3.10 - [PR #208](https://github.com/appliedAI-Initiative/pyDVL/pull/208) + [PR #208](https://github.com/aai-institute/pyDVL/pull/208) - **Breaking change:** Introduces a class ValuationResult to gather and inspect results from all valuation algorithms - [PR #214](https://github.com/appliedAI-Initiative/pyDVL/pull/214) + [PR #214](https://github.com/aai-institute/pyDVL/pull/214) - Fixes bug in Influence calculation with multidimensional input and adds new example notebook - [PR #195](https://github.com/appliedAI-Initiative/pyDVL/pull/195) + [PR #195](https://github.com/aai-institute/pyDVL/pull/195) - **Breaking change**: Passes the input to `MapReduceJob` at initialization, removes `chunkify_inputs` argument from `MapReduceJob`, removes `n_runs` argument from `MapReduceJob`, calls the parallel backend's `put()` method for @@ -135,38 +135,38 @@ attribute to `n_local_workers`, fixes a bug in `MapReduceJob`'s chunkification when `n_runs` >= `n_jobs`, and defines a sequential parallel backend to run all jobs in the current thread - [PR #232](https://github.com/appliedAI-Initiative/pyDVL/pull/232) + [PR #232](https://github.com/aai-institute/pyDVL/pull/232) - **New method**: Implements exact and monte carlo Least Core for data valuation, adds `from_arrays()` class method to the `Dataset` and `GroupedDataset` classes, adds `extra_values` argument to `ValuationResult`, adds `compute_removal_score()` and `compute_random_removal_score()` helper functions - [PR #237](https://github.com/appliedAI-Initiative/pyDVL/pull/237) + [PR #237](https://github.com/aai-institute/pyDVL/pull/237) - **New method**: Group Testing Shapley for valuation, from _Jia et al. 2019_ - [PR #240](https://github.com/appliedAI-Initiative/pyDVL/pull/240) + [PR #240](https://github.com/aai-institute/pyDVL/pull/240) - Fixes bug in ray initialization in `RayParallelBackend` class - [PR #239](https://github.com/appliedAI-Initiative/pyDVL/pull/239) + [PR #239](https://github.com/aai-institute/pyDVL/pull/239) - Implements "Egalitarian Least Core", adds [cvxpy](https://www.cvxpy.org/) as a dependency and uses it instead of scipy as optimizer - [PR #243](https://github.com/appliedAI-Initiative/pyDVL/pull/243) + [PR #243](https://github.com/aai-institute/pyDVL/pull/243) ## 0.3.0 - 💥 Breaking changes - Simplified and fixed powerset sampling and testing - [PR #181](https://github.com/appliedAI-Initiative/pyDVL/pull/181) + [PR #181](https://github.com/aai-institute/pyDVL/pull/181) - Simplified and fixed publishing to PyPI from CI - [PR #183](https://github.com/appliedAI-Initiative/pyDVL/pull/183) + [PR #183](https://github.com/aai-institute/pyDVL/pull/183) - Fixed bug in release script and updated contributing docs. - [PR #184](https://github.com/appliedAI-Initiative/pyDVL/pull/184) + [PR #184](https://github.com/aai-institute/pyDVL/pull/184) - Added Pull Request template - [PR #185](https://github.com/appliedAI-Initiative/pyDVL/pull/185) + [PR #185](https://github.com/aai-institute/pyDVL/pull/185) - Modified Pull Request template to automatically link PR to issue - [PR ##186](https://github.com/appliedAI-Initiative/pyDVL/pull/186) + [PR ##186](https://github.com/aai-institute/pyDVL/pull/186) - First implementation of Owen Sampling, squashed scores, better testing - [PR #194](https://github.com/appliedAI-Initiative/pyDVL/pull/194) + [PR #194](https://github.com/aai-institute/pyDVL/pull/194) - Improved documentation on caching, Shapley, caveats of values, bibtex - [PR #194](https://github.com/appliedAI-Initiative/pyDVL/pull/194) + [PR #194](https://github.com/aai-institute/pyDVL/pull/194) - **Breaking change:** Rearranging of modules to accommodate for new methods - [PR #194](https://github.com/appliedAI-Initiative/pyDVL/pull/194) + [PR #194](https://github.com/aai-institute/pyDVL/pull/194) ## 0.2.0 - 📚 Better docs @@ -175,7 +175,7 @@ Mostly API documentation and notebooks, plus some bugfixes. ### Added -In [PR #161](https://github.com/appliedAI-Initiative/pyDVL/pull/161): +In [PR #161](https://github.com/aai-institute/pyDVL/pull/161): - Support for $$ math in sphinx docs. - Usage of sphinx extension for external links (introducing new directives like `:gh:`, `:issue:` and `:tfl:` to construct standardised links to external @@ -187,7 +187,7 @@ In [PR #161](https://github.com/appliedAI-Initiative/pyDVL/pull/161): ### Changed -In [PR #161](https://github.com/appliedAI-Initiative/pyDVL/pull/161): +In [PR #161](https://github.com/aai-institute/pyDVL/pull/161): - Improved main docs and Shapley notebooks. Added or fixed many docstrings, readme and documentation for contributors. Typos, grammar and style in code, documentation and notebooks. @@ -196,9 +196,9 @@ In [PR #161](https://github.com/appliedAI-Initiative/pyDVL/pull/161): ### Fixed - Bug in random matrix generation - [PR #161](https://github.com/appliedAI-Initiative/pyDVL/pull/161). + [PR #161](https://github.com/aai-institute/pyDVL/pull/161). - Bugs in MapReduceJob's `_chunkify` and `_backpressure` methods - [PR #176](https://github.com/appliedAI-Initiative/pyDVL/pull/176). + [PR #176](https://github.com/aai-institute/pyDVL/pull/176). ## 0.1.0 - 🎉 first release diff --git a/CITATION.cff b/CITATION.cff index 503b05b4f..8ce54eb5f 100644 --- a/CITATION.cff +++ b/CITATION.cff @@ -11,7 +11,7 @@ authors: - given-names: TransferLab team email: info+pydvl@appliedai.de affiliation: appliedAI Institute gGmbH -repository-code: 'https://github.com/appliedAI-Initiative/pyDVL' +repository-code: 'https://github.com/aai-institute/pyDVL' abstract: >- pyDVL is a library of stable implementations of algorithms for data valuation and influence function computation diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 34dc3ff80..30259b29d 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -11,7 +11,7 @@ improvements to the currently implemented methods and other ideas. Please open a ticket with yours. If you are interested in setting up a similar project, consider the template -[pymetrius](https://github.com/appliedAI-Initiative/pymetrius). +[pymetrius](https://github.com/aai-institute/pymetrius). ## Local development @@ -137,7 +137,7 @@ avoid as much clutter and boilerplate as possible in the notebooks themselves. Because we want documentation to include the full dataset, we commit notebooks with their outputs running with full datasets to the repo. The notebooks are then added by CI to the section -[Examples](https://appliedAI-Initiative.github.io/pyDVL/examples.html) of the +[Examples](https://aai-institute.github.io/pyDVL/examples.html) of the documentation. ### Hiding cells in notebooks @@ -158,7 +158,7 @@ metadata: { It is important to leave a warning at the top of the document to avoid confusion. Examples for hidden imports and plots are available in the notebooks, e.g. in -[Shapley for data valuation](https://appliedai-initiative.github.io/pyDVL/examples/shapley_basic_spotify.ipynb). +[Shapley for data valuation](https://aai-institute.github.io/pyDVL/examples/shapley_basic_spotify.ipynb). ## Documentation @@ -249,7 +249,7 @@ We use workflows to: * Publish documentation. * Publish packages to testpypi / pypi. * Mark issues as stale after 30 days. We do this only for issues with the label - [`awaiting-reply`](https://github.com/appliedAI-Initiative/pyDVL/labels/awaiting-reply) + [`awaiting-reply`](https://github.com/aai-institute/pyDVL/labels/awaiting-reply) which indicates that we have answered a question / feature request / PR and are waiting for the OP to reply / update his work. diff --git a/README.md b/README.md index c2460147d..f0f9ca73a 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@

- pyDVL Logo + pyDVL Logo

@@ -7,8 +7,8 @@

- - Build Status + + Build Status
@@ -22,7 +22,7 @@

- Docs + Docs

@@ -94,7 +94,7 @@ pip install pyDVL --index-url https://test.pypi.org/simple/ ``` For more instructions and information refer to [Installing pyDVL -](https://appliedAI-Initiative.github.io/pyDVL/20-install.html) in the +](https://aai-institute.github.io/pyDVL/20-install.html) in the documentation. # Usage @@ -176,9 +176,9 @@ values = compute_shapley_values( ``` For more instructions and information refer to [Getting -Started](https://appliedAI-Initiative.github.io/pyDVL/10-getting-started.html) in +Started](https://aai-institute.github.io/pyDVL/10-getting-started.html) in the documentation. We provide several -[examples](https://appliedAI-Initiative.github.io/pyDVL/examples/index.html) +[examples](https://aai-institute.github.io/pyDVL/examples/index.html) with details on the algorithms and their applications. ## Caching @@ -194,7 +194,7 @@ docker container run --rm -p 11211:11211 --name pydvl-cache -d memcached:latest ``` You can read more in the [caching module's -documentation](https://appliedAI-Initiative.github.io/pyDVL/pydvl/utils/caching.html). +documentation](https://aai-institute.github.io/pyDVL/pydvl/utils/caching.html). # Contributing diff --git a/docs/conf.py b/docs/conf.py index 2c380c809..11db1e0c9 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -63,8 +63,8 @@ extlinks_detect_hardcoded_links = True extlinks = { - "gh": ("https://github.com/appliedAI-Initiative/pyDVL/%s", "GitHub %s"), - "issue": ("https://github.com/appliedAI-Initiative/pyDVL/issues/%s", "issue %s"), + "gh": ("https://github.com/aai-institute/pyDVL/%s", "GitHub %s"), + "issue": ("https://github.com/aai-institute/pyDVL/issues/%s", "issue %s"), "tfl": ("https://transferlab.appliedai.de/%s", "%s"), } @@ -82,11 +82,11 @@
This page was generated from - {{ docname|e }} + {{ docname|e }}
Interactive online version: - + Binder badge @@ -117,7 +117,7 @@ # adding links to source files (this works for gitlab and github like hosts and might need to be adjusted for others) # see https://www.sphinx-doc.org/en/master/usage/extensions/linkcode.html#module-sphinx.ext.linkcode def linkcode_resolve(domain, info): - link_prefix = "https://github.com/appliedAI-Initiative/pyDVL/blob/develop" + link_prefix = "https://github.com/aai-institute/pyDVL/blob/develop" if domain != "py": return None if not info["module"]: @@ -267,7 +267,7 @@ def lineno_from_object_name(source_file, object_name): "footer_icons": [ { "name": "GitHub", - "url": "https://github.com/appliedAI-Initiative/pyDVL", + "url": "https://github.com/aai-institute/pyDVL", "html": """ diff --git a/docs/index.rst b/docs/index.rst index 217c08e2b..e3477defc 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -36,7 +36,7 @@ If you're a first time user of pyDVL, we recommend you to go through the :material-regular:`code;12em` - .. button-link:: https://github.com/appliedAI-Initiative/pyDVL + .. button-link:: https://github.com/aai-institute/pyDVL :expand: :color: primary :outline: diff --git a/notebooks/support/shapley.py b/notebooks/support/shapley.py index f471e70e2..98c295ef9 100644 --- a/notebooks/support/shapley.py +++ b/notebooks/support/shapley.py @@ -34,7 +34,7 @@ def load_spotify_dataset( if file_path.exists(): data = pd.read_csv(file_path) else: - url = "https://raw.githubusercontent.com/appliedAI-Initiative/pyDVL/develop/data/top_hits_spotify_dataset.csv" + url = "https://raw.githubusercontent.com/aai-institute/pyDVL/develop/data/top_hits_spotify_dataset.csv" data = pd.read_csv(url) data.to_csv(file_path, index=False) diff --git a/setup.py b/setup.py index da33620c2..51ceb808b 100644 --- a/setup.py +++ b/setup.py @@ -44,8 +44,8 @@ "License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)", ], project_urls={ - "Source": "https://github.com/appliedAI-Initiative/pydvl", - "Documentation": "https://appliedai-initiative.github.io/pyDVL", + "Source": "https://github.com/aai-institute/pydvl", + "Documentation": "https://aai-institute.github.io/pyDVL", "TransferLab": "https://transferlab.appliedai.de", }, zip_safe=False, # Needed for mypy to find py.typed From baa45bdca350ff161db71e2a3bdabc2367d8b674 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 1 Sep 2023 11:31:39 +0200 Subject: [PATCH 406/436] Update CHANGELOG.md --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 18599dfec..4d4c853a7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,8 @@ ## Unreleased +- Replaced sphinx with mkdocs for documentation. Major overhaul of documentation + [PR #352](https://github.com/aai-institute/pyDVL/pull/352) - Made ray an optional dependency, relying on joblib as default parallel backend [PR #408](https://github.com/aai-institute/pyDVL/pull/408) - Enabled parallel computation for Leave-One-Out values From 3ede5cdb48b406ef204b1878e670ace1bd78450d Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 1 Sep 2023 11:43:09 +0200 Subject: [PATCH 407/436] [skip ci] Rearrange CHANGELOG.md for release --- CHANGELOG.md | 60 +++++++++++++++++++++++++++++----------------------- 1 file changed, 34 insertions(+), 26 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4d4c853a7..e8fe06a49 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,46 +1,54 @@ # Changelog -## Unreleased +## 0.7.0 - 📚 Documentation overhaul, new methods and bug fixes 💥 +This is our first β release! We have worked hard to deliver improvements across +the board, with a focus on documentation and usability. + +### Added + +- Implemented solving the Hessian equation via spectral low-rank approximation + [PR #365](https://github.com/aai-institute/pyDVL/pull/365) +- Enabled parallel computation for Leave-One-Out values + [PR #406](https://github.com/aai-institute/pyDVL/pull/406) + +### Changed - Replaced sphinx with mkdocs for documentation. Major overhaul of documentation [PR #352](https://github.com/aai-institute/pyDVL/pull/352) - Made ray an optional dependency, relying on joblib as default parallel backend [PR #408](https://github.com/aai-institute/pyDVL/pull/408) -- Enabled parallel computation for Leave-One-Out values - [PR #406](https://github.com/aai-institute/pyDVL/pull/406) +- Decoupled `ray.init` from `ParallelConfig` + [PR #373](https://github.com/aai-institute/pyDVL/pull/383) +- **Breaking Changes** + - Signature change: return information about Hessian inversion from + `compute_influence_factors` + [PR #375](https://github.com/aai-institute/pyDVL/pull/376) + - Major changes to IF interface and functionality. Foundation for a framework + abstraction for IF computation. + [PR #278](https://github.com/aai-institute/pyDVL/pull/278) + [PR #394](https://github.com/aai-institute/pyDVL/pull/394) + - Renamed `semivalues` to `compute_generic_semivalues` + [PR #413](https://github.com/appliedAI-Initiative/pyDVL/pull/413) + - New `joblib` backend as default instead of ray. Simplify MapReduceJob. + [PR #355](https://github.com/aai-institute/pyDVL/pull/355) + - Bump torch dependency for influence package to 2.0 + [PR #365](https://github.com/aai-institute/pyDVL/pull/365) + +### Fixed + - Fixes to parallel computation of generic semi-values: properly handle all - samplers and stopping criteria, irrespective of parallel backend + samplers and stopping criteria, irrespective of parallel backend. [PR #372](https://github.com/aai-institute/pyDVL/pull/372) - Optimises memory usage in IF calculation [PR #375](https://github.com/aai-institute/pyDVL/pull/376) -- **Breaking Changes** - Return information about hessian inversion from compute_influence_factors, - thus changing signature - [PR #375](https://github.com/aai-institute/pyDVL/pull/376) - Fix adding valuation results with overlapping indices and different lengths [PR #370](https://github.com/aai-institute/pyDVL/pull/370) - Fixed bugs in conjugate gradient and `linear_solve` [PR #358](https://github.com/aai-institute/pyDVL/pull/358) +- Fix installation of dev requirements for Python3.10 + [PR #382](https://github.com/aai-institute/pyDVL/pull/382) - Improvements to IF documentation [PR #371](https://github.com/aai-institute/pyDVL/pull/371) -- Major changes to IF interface and functionality - [PR #278](https://github.com/aai-institute/pyDVL/pull/278) - [PR #394](https://github.com/aai-institute/pyDVL/pull/394) -- **New Method**: Implements solving the hessian equation via spectral low-rank - approximation - [PR #365](https://github.com/aai-institute/pyDVL/pull/365) -- **Breaking Changes**: - - Renamed `semivalues` to `compute_generic_semivalues` - [PR #413](https://github.com/appliedAI-Initiative/pyDVL/pull/413) - - Add new joblib backend and set it as default - instead of the ray backend. Simplify the MapReduceJob class. - [PR #355](https://github.com/aai-institute/pyDVL/pull/355) - - Bump torch dependency for influence package to 2.0 - [PR #365](https://github.com/aai-institute/pyDVL/pull/365) -- **Bug fix** Fix installation of dev requirements for Python3.10 - [PR #382](https://github.com/aai-institute/pyDVL/pull/382) -- Decouple ray.init from ParallelConfig - [PR #373](https://github.com/aai-institute/pyDVL/pull/383) ## 0.6.1 - 🏗 Bug fixes and small improvements From 5c0a4305e2baeff37c567f0c1611ed05b99458e3 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 1 Sep 2023 12:59:02 +0200 Subject: [PATCH 408/436] Tweaks to mike's config --- .github/workflows/publish.yaml | 4 ++-- .github/workflows/tox.yaml | 4 ++-- CONTRIBUTING.md | 15 ++++++++------- mkdocs.yml | 4 +++- 4 files changed, 15 insertions(+), 12 deletions(-) diff --git a/.github/workflows/publish.yaml b/.github/workflows/publish.yaml index d6b69bc78..751298462 100644 --- a/.github/workflows/publish.yaml +++ b/.github/workflows/publish.yaml @@ -72,8 +72,8 @@ jobs: uses: ./.github/actions/deploy-docs with: version: ${{ env.CURRENT_VERSION }} - alias: stable - title: Stable + alias: latest + title: Latest email: ${{ env.GITHUB_BOT_EMAIL }} username: ${{ env.GITHUB_BOT_USERNAME }} set-default: 'true' diff --git a/.github/workflows/tox.yaml b/.github/workflows/tox.yaml index 76c4195d7..f76c044b2 100644 --- a/.github/workflows/tox.yaml +++ b/.github/workflows/tox.yaml @@ -112,8 +112,8 @@ jobs: uses: ./.github/actions/deploy-docs with: version: devel - alias: latest - title: Latest + alias: develop + title: Development email: ${{ env.GITHUB_BOT_EMAIL }} username: ${{ env.GITHUB_BOT_USERNAME }} - name: Build and publish to TestPyPI diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 74503c2aa..6c334b00a 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -179,7 +179,8 @@ Examples for hidden imports and plots are available in the notebooks, e.g. in ## Documentation API documentation and examples from notebooks are built with -[mkdocs](https://www.mkdocs.org/). +[mkdocs](https://www.mkdocs.org/), with versioning handled by +[mike](https://github.com/jimporter/mike). Notebooks are an integral part of the documentation as well, please read [the section on notebooks](#notebooks) above. @@ -191,8 +192,8 @@ done in CI: mkdocs build ``` -Locally, you can use this command instead to continuously rebuild -documentation on changes to the `docs` and `src` folder: +Locally, you can use this command instead to continuously rebuild documentation +on changes to the `docs` and `src` folder: ```bash mkdocs serve @@ -406,11 +407,11 @@ If running in interactive mode (without `-y|--yes`), the script will output a summary of pending changes and ask for confirmation before executing the actions. -Once this is done, a tag will be created on the repository. -You should then create a Github +Once this is done, a tag will be created on the repository. You should then +create a GitHub [release](https://docs.github.com/en/repositories/releasing-projects-on-github/managing-releases-in-a-repository#creating-a-release) -for that tag. That will a trigger a CI pipeline that will -automatically create a package and publish it from CI to PyPI. +for that tag. That will a trigger a CI pipeline that will automatically create a +package and publish it from CI to PyPI. ### Manual release process diff --git a/mkdocs.yml b/mkdocs.yml index d7b27fbbd..52c4f5e9c 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -4,6 +4,7 @@ site_url: "https://appliedai-initiative.github.io/pyDVL/" repo_name: "appliedAI-Initiative/pyDVL" repo_url: "https://github.com/appliedAI-Initiative/pyDVL" copyright: "Copyright © AppliedAI Institute gGmbH" +remote_branch: gh-pages watch: - src/pydvl @@ -30,7 +31,8 @@ plugins: auto_caption: true caption_position: bottom - macros - - mike + - mike: + canonical_version: stable - search - section-index - alias: From 636c41f402f98c7c3b5327e161e2352e0396f279 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 1 Sep 2023 14:11:57 +0200 Subject: [PATCH 409/436] Fix leftovers --- CHANGELOG.md | 2 +- mkdocs.yml | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e8fe06a49..fc7b3f163 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -28,7 +28,7 @@ the board, with a focus on documentation and usability. [PR #278](https://github.com/aai-institute/pyDVL/pull/278) [PR #394](https://github.com/aai-institute/pyDVL/pull/394) - Renamed `semivalues` to `compute_generic_semivalues` - [PR #413](https://github.com/appliedAI-Initiative/pyDVL/pull/413) + [PR #413](https://github.com/aai-institute/pyDVL/pull/413) - New `joblib` backend as default instead of ray. Simplify MapReduceJob. [PR #355](https://github.com/aai-institute/pyDVL/pull/355) - Bump torch dependency for influence package to 2.0 diff --git a/mkdocs.yml b/mkdocs.yml index 52c4f5e9c..f23921775 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -1,8 +1,8 @@ site_name: "pyDVL" site_dir: "docs_build" -site_url: "https://appliedai-initiative.github.io/pyDVL/" -repo_name: "appliedAI-Initiative/pyDVL" -repo_url: "https://github.com/appliedAI-Initiative/pyDVL" +site_url: "https://aai-institute.github.io/pyDVL/" +repo_name: "aai-institute/pyDVL" +repo_url: "https://github.com/aai-institute/pyDVL" copyright: "Copyright © AppliedAI Institute gGmbH" remote_branch: gh-pages From f30292f8a69ae21dced53a4b2e453260f7bf7681 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 1 Sep 2023 14:12:18 +0200 Subject: [PATCH 410/436] Minor doc improvement for parallel --- docs/getting-started/installation.md | 4 +++- src/pydvl/utils/parallel/__init__.py | 7 +++++-- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/docs/getting-started/installation.md b/docs/getting-started/installation.md index ea6ef4f02..2d2164ada 100644 --- a/docs/getting-started/installation.md +++ b/docs/getting-started/installation.md @@ -55,7 +55,9 @@ Additionally, the [Influence functions][pydvl.influence] module requires PyTorch ray is used to distribute workloads across nodes in a cluster (it can be used locally as well, but for this we recommend joblib instead). Please follow the -instructions in their documentation to set up the cluster. +instructions in their documentation to set up the cluster. Once you have a +running cluster, you can use it by passing the address of the head node to +parallel methods via [ParallelConfig][pydvl.utils.parallel]. ## Setting up the cache diff --git a/src/pydvl/utils/parallel/__init__.py b/src/pydvl/utils/parallel/__init__.py index eeb56fcde..76319b197 100644 --- a/src/pydvl/utils/parallel/__init__.py +++ b/src/pydvl/utils/parallel/__init__.py @@ -1,6 +1,9 @@ """ This module provides a common interface to parallelization backends. The list of -supported backends is [here][pydvl.utils.parallel.backends]. +supported backends is [here][pydvl.utils.parallel.backends]. Backends can be +selected with the `backend` argument of an instance of +[ParallelConfig][pydvl.utils.config.ParallelConfig], as seen in the examples +below. We use [executors][concurrent.futures.Executor] to submit tasks in parallel. The basic high-level pattern is @@ -23,7 +26,7 @@ from pydvl.utils.config import ParallelConfig config = ParallelConfig(backend="joblib") -with init_executor() as executor: +with init_executor(config=config) as executor: results = list(executor.map(lambda x: x + 1, range(5))) assert results == [1, 2, 3, 4, 5] ``` From 62295d46e19c89095a676bb2c4a25ea11e375dd3 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 1 Sep 2023 14:26:58 +0200 Subject: [PATCH 411/436] Doc. cards with images don't work with the glightbox plugin --- docs/index.md | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/docs/index.md b/docs/index.md index 32c6880b6..fb6408b9e 100644 --- a/docs/index.md +++ b/docs/index.md @@ -13,20 +13,22 @@ If you're a first time user of pyDVL, we recommend you to go through the ::cards:: cols=2 -- title: To the installation guide - image: ./assets/material-toolbox.svg +- title: Installation + content: Steps to install and requirements url: getting-started/installation.md - title: Data valuation - image: ./assets/material-code.svg + content: > + Basics of data valuation and description of the main algorithms url: value/ + - title: Influence Function - image: ./assets/material-computer.svg + content: > + An introduction to the influence function and its computation with pyDVL url: influence/ - title: Browse the API - image: ./assets/material-description.svg + content: Full documentation of the API url: api/pydvl/ - ::/cards:: From 18858da3e96ee5b931c835ebb4dd840b666c9ea6 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 1 Sep 2023 15:42:09 +0200 Subject: [PATCH 412/436] Add more abbreviations --- docs_includes/abbreviations.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/docs_includes/abbreviations.md b/docs_includes/abbreviations.md index cc2990534..e0fa67a4c 100644 --- a/docs_includes/abbreviations.md +++ b/docs_includes/abbreviations.md @@ -9,3 +9,7 @@ *[MSE]: Mean Squared Error *[SV]: Shapley Value *[TMCS]: Truncated Monte Carlo Shapley +*[IF]: Influence Function +*[iHVP]: inverse Hessian-vector product +*[LiSSA]: Linear-time Stochastic Second-order Algorithm +*[DUL]: Data Utility Learning From 6b947242f30e95150d59997b5487abdc4aa4579c Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 1 Sep 2023 15:42:22 +0200 Subject: [PATCH 413/436] Small docs fixes --- docs/value/index.md | 5 ++--- docs/value/semi-values.md | 2 +- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/docs/value/index.md b/docs/value/index.md index 82aa72252..9877fac80 100644 --- a/docs/value/index.md +++ b/docs/value/index.md @@ -76,7 +76,7 @@ there are additional desiderata, like having a value function that does not increase with repeated samples. Game-theoretic methods are all rooted in axioms that by construction ensure different desiderata, but despite their practical usefulness, none of them are either necessary or sufficient for all -applications. For instance, *[SV]s try to equitably distribute all value +applications. For instance, SV methods try to equitably distribute all value among all samples, failing to identify repeated ones as unnecessary, with e.g. a zero value. @@ -332,8 +332,7 @@ nature of every (non-trivial) ML problem can have an effect: [@wang_data_2022] prove that by relaxing one of the Shapley axioms and considering the general class of semi-values, of which Shapley is an instance, one can prove that a choice of constant weights is the best one can - do in a utility-agnostic setting. So-called *Data Banzhaf* is on our to-do - list! + do in a utility-agnostic setting. So-called *Data Banzhaf*. * **Data set size**: Computing exact Shapley values is NP-hard, and Monte Carlo approximations can converge slowly. Massive datasets are thus impractical, at diff --git a/docs/value/semi-values.md b/docs/value/semi-values.md index 86513a6a1..2f1ea7a9c 100644 --- a/docs/value/semi-values.md +++ b/docs/value/semi-values.md @@ -117,7 +117,7 @@ values = compute_generic_semivalues( u=utility, coefficient=beta_coefficient(alpha=1, beta=16), done=AbsoluteStandardError(threshold=1e-4), - ) +) ``` Allowing any coefficient can help when experimenting with models which are more From 44ca42d5bbfb237b258ca29b13f607e443c40230 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 1 Sep 2023 15:44:57 +0200 Subject: [PATCH 414/436] Update changelog --- CHANGELOG.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index fc7b3f163..92f101eec 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,10 @@ # Changelog +## Unreleased + +- Added more abbreviations to documentation + [PR #415](https://github.com/aai-institute/pyDVL/pull/415) + ## 0.7.0 - 📚 Documentation overhaul, new methods and bug fixes 💥 This is our first β release! We have worked hard to deliver improvements across From 92c0a7f5d98034b9244ba5d557308238512214c5 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 1 Sep 2023 15:53:08 +0200 Subject: [PATCH 415/436] Add section about Abbreviations to contributing docs --- CONTRIBUTING.md | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 6c334b00a..b7d4bf23a 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -250,6 +250,16 @@ def f(x: float) -> float: return 1/(x*x) ``` +### Abbreviations + +We keep the abbreviations used in the documentation inside the +[docs_include/abbreviations.md](docs_includes%2Fabbreviations.md) file. + +The syntax for abbreviations is: + +```markdown +*[ABBR]: Abbreviation +``` ## CI From 26d59bffd31c01726d0b25b0750837ef70a9b1b7 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Fri, 1 Sep 2023 16:45:48 +0200 Subject: [PATCH 416/436] Remove backlog from semivalues.py and montecarlo.py. --- src/pydvl/utils/parallel/backlog.py | 37 --------------------------- src/pydvl/value/semivalues.py | 11 +++----- src/pydvl/value/shapley/montecarlo.py | 12 ++------- 3 files changed, 6 insertions(+), 54 deletions(-) delete mode 100644 src/pydvl/utils/parallel/backlog.py diff --git a/src/pydvl/utils/parallel/backlog.py b/src/pydvl/utils/parallel/backlog.py deleted file mode 100644 index 3cd3ea1d0..000000000 --- a/src/pydvl/utils/parallel/backlog.py +++ /dev/null @@ -1,37 +0,0 @@ -from copy import copy -from functools import partial -from typing import Callable, Generator, Generic, List, Tuple, TypeVar - -T = TypeVar("T") - - -def wrap_index(*args, i: int, fn: Callable, **kwargs): - return i, fn(*args, **kwargs) - - -class Backlog(Generic[T]): - """A backlog is a queue of items added in no particular order. Each item has an - index used to determine the sequence in which the items are processed. A function - call can be modified using the wrap method to include this index in the output. - This modification should be applied before invoking the function.""" - - def __init__(self): - self._backlog: List[Tuple[int, T]] = [] - self._n_delivered = 0 - self._n_registered = 0 - self._n_wrapped = 0 - - def add(self, item: Tuple[int, T]): - self._backlog.append(item) - self._backlog = sorted(self._backlog, key=lambda t: t[0]) - self._n_registered += 1 - - def get(self) -> Generator[T, None, None]: - while len(self._backlog) > 0 and self._backlog[0][0] == self._n_delivered: - self._n_delivered += 1 - yield self._backlog[0][1] - self._backlog = self._backlog[1:] - - def wrap(self, fn: Callable) -> Callable: - self._n_wrapped += 1 - return partial(wrap_index, fn=fn, i=copy(self._n_wrapped - 1)) diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index ecd572a4d..4078ca523 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -81,7 +81,6 @@ from tqdm import tqdm from pydvl.utils import ParallelConfig, Utility -from pydvl.utils.parallel.backlog import Backlog from pydvl.utils.types import Seed from pydvl.value import ValuationResult from pydvl.value.sampler import ( @@ -200,7 +199,6 @@ def compute_generic_semivalues( sampler_it = iter(sampler) pbar = tqdm(disable=not progress, total=100, unit="%") - backlog = Backlog[Tuple[int, float]]() with init_executor( max_workers=max_workers, config=config, cancel_futures=True @@ -212,9 +210,7 @@ def compute_generic_semivalues( completed, pending = wait(pending, timeout=1, return_when=FIRST_COMPLETED) for future in completed: - backlog.add(future.result()) - - for idx, marginal in backlog.get(): + idx, marginal = future.result() result.update(idx, marginal) if done(result): return result @@ -224,14 +220,15 @@ def compute_generic_semivalues( for _ in range(n_submitted_jobs - len(pending)): pending.add( executor.submit( - backlog.wrap(_marginal), + _marginal, u=u, coefficient=correction, sample=next(sampler_it), ) ) except StopIteration: - return result + if len(pending) == 0: + return result def shapley_coefficient(n: int, k: int) -> float: diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index 6ed995feb..eca44139f 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -60,7 +60,6 @@ from pydvl.utils.config import ParallelConfig from pydvl.utils.numeric import random_powerset from pydvl.utils.parallel import CancellationPolicy, MapReduceJob -from pydvl.utils.parallel.backlog import Backlog from pydvl.utils.types import Seed, ensure_seed_sequence from pydvl.utils.utility import Utility from pydvl.value.result import ValuationResult @@ -200,8 +199,6 @@ def permutation_montecarlo_shapley( result = ValuationResult.zeros(algorithm=algorithm) pbar = tqdm(disable=not progress, total=100, unit="%") - n_submitted = 0 - backlog = Backlog[ValuationResult]() with init_executor( max_workers=max_workers, config=config, cancel_futures=CancellationPolicy.ALL @@ -215,11 +212,7 @@ def permutation_montecarlo_shapley( pending, timeout=config.wait_timeout, return_when=FIRST_COMPLETED ) for future in completed: - backlog.add(future.result()) - - for future_result in backlog.get(): - result += future_result - + result += future.result() # we could check outside the loop, but that means more # submissions if the stopping criterion is unstable if done(result): @@ -230,13 +223,12 @@ def permutation_montecarlo_shapley( seeds = seed_sequence.spawn(n_remaining_slots) for i in range(n_remaining_slots): future = executor.submit( - backlog.wrap(_permutation_montecarlo_one_step), + _permutation_montecarlo_one_step, u, truncation, algorithm, seed=seeds[i], ) - n_submitted += 1 pending.add(future) From 4e889f7b6f97656245bb427e511dee6f136da6b1 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Fri, 1 Sep 2023 18:04:34 +0200 Subject: [PATCH 417/436] Remove reproducibility tests from semivalues.py and deactivated affected test cases from test monte carlo. --- src/pydvl/utils/functional.py | 45 +++++--------- src/pydvl/utils/parallel/map_reduce.py | 1 + src/pydvl/utils/types.py | 4 +- tests/utils/test_parallel.py | 2 +- tests/value/shapley/test_montecarlo.py | 15 ++--- tests/value/test_semivalues.py | 85 +------------------------- 6 files changed, 28 insertions(+), 124 deletions(-) diff --git a/src/pydvl/utils/functional.py b/src/pydvl/utils/functional.py index d4f684d9a..55f6a7a2d 100644 --- a/src/pydvl/utils/functional.py +++ b/src/pydvl/utils/functional.py @@ -4,53 +4,36 @@ from functools import partial from typing import Callable, Set, Tuple -__all__ = ["fn_accepts_param_name"] +__all__ = ["unroll_partial_fn_args"] -def fn_accepts_param_name(fn: Callable, param_name: str) -> bool: +def unroll_partial_fn_args(fun: Callable) -> Set[str]: """ - Checks if a function accepts a given parameter, even if it is set by partial. + Unroll a function that was set by functools.partial. Args: - fn: The function to check. - param_name: The name of the parameter to check. + fun: Either or a function to unroll. Returns: - True if the function accepts the parameter, False otherwise. - """ - - wrapped_fn, args_set_by_partial = _unroll_partial_fn(fn) - - sig = inspect.signature(wrapped_fn) - params = sig.parameters - - if param_name in args_set_by_partial: - return False - - if param_name in params: - return True - - return False - - -def _unroll_partial_fn(fn: Callable) -> Tuple[Callable, Set[str]]: - """ - Unroll a function that was set by functools.partial. - - :param fn: Either or a function to unroll. - :return: A tuple of the unrolled function and a set of the parameters that were set - by functools.partial. + A tuple of the unrolled function and a set of the parameters that were set by + functools.partial. """ args_set_by_partial: Set[str] = set() def _rec_unroll_partial_function(g: Callable): + """ + Store arguments and recursively call itself if the function is a partial. In the + end, return the original function. + """ nonlocal args_set_by_partial if isinstance(g, partial): args_set_by_partial.update(g.keywords.keys()) args_set_by_partial.update(g.args) - return _rec_unroll_partial_function(g.func) + return _rec_unroll_partial_function(g.keywords["fun"]) else: return g - return _rec_unroll_partial_function(fn), args_set_by_partial + wrapped_fn = _rec_unroll_partial_function(fun) + sig = inspect.signature(wrapped_fn) + return args_set_by_partial | set(sig.parameters.keys()) diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index f8aa5a4dd..4f0b55af3 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -147,6 +147,7 @@ def __call__( zip(chunks, seed_seq.spawn(len(chunks))) ) ) + reduce_results: R = self._reduce_func(map_results, **self.reduce_kwargs) return reduce_results diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index 7060b21ef..36eb5ce89 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -11,7 +11,7 @@ from numpy.random import Generator, SeedSequence from numpy.typing import NDArray -from pydvl.utils.functional import fn_accepts_param_name +from pydvl.utils.functional import unroll_partial_fn_args __all__ = ["SupervisedModel", "MapFunction", "ReduceFunction", "NoPublicConstructor"] @@ -83,7 +83,7 @@ def maybe_add_argument(fun: Callable, new_arg: str) -> Callable: Returns: A new function accepting one more keyword argument. """ - if fn_accepts_param_name(fun, new_arg): + if new_arg in unroll_partial_fn_args(fun): return fun return functools.partial(call_fun_remove_arg, fun=fun, arg=new_arg) diff --git a/tests/utils/test_parallel.py b/tests/utils/test_parallel.py index 29f57eacb..3316fe7c3 100644 --- a/tests/utils/test_parallel.py +++ b/tests/utils/test_parallel.py @@ -147,7 +147,7 @@ def reduce_func(x, y): assert result == 150 -def test_map_reduce_reproducible(parallel_config, seed, seed_alt): +def test_map_reduce_reproducible(parallel_config, seed): """ Test that the same result is obtained when using the same seed. And that different results are obtained when using different seeds. diff --git a/tests/value/shapley/test_montecarlo.py b/tests/value/shapley/test_montecarlo.py index 4c4032fa9..6ec72a8f3 100644 --- a/tests/value/shapley/test_montecarlo.py +++ b/tests/value/shapley/test_montecarlo.py @@ -73,13 +73,14 @@ def test_analytic_montecarlo_shapley( test_cases_montecarlo_shapley_reproducible_stochastic = [ - (12, ShapleyMode.PermutationMontecarlo, {"done": MaxChecks(1)}), - # FIXME! it should be enough with 2**(len(data)-1) samples - ( - 8, - ShapleyMode.CombinatorialMontecarlo, - {"done": MaxChecks(1)}, - ), + # TODO Add once issue #416 is closed. + # (12, ShapleyMode.PermutationMontecarlo, {"done": MaxChecks(1)}), + # # FIXME! it should be enough with 2**(len(data)-1) samples + # ( + # 8, + # ShapleyMode.CombinatorialMontecarlo, + # {"done": MaxChecks(1)}, + # ), (12, ShapleyMode.Owen, dict(n_samples=4, max_q=200)), (12, ShapleyMode.OwenAntithetic, dict(n_samples=4, max_q=200)), ( diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index d52f21e4a..ec937d028 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -3,11 +3,8 @@ import numpy as np import pytest -from sklearn.linear_model import LinearRegression -from pydvl.utils import Dataset, ParallelConfig, Utility -from pydvl.utils.types import Seed, call_fn_multiple_seeds -from pydvl.value import ValuationResult +from pydvl.utils import ParallelConfig from pydvl.value.sampler import ( AntitheticSampler, DeterministicPermutationSampler, @@ -23,7 +20,7 @@ compute_generic_semivalues, shapley_coefficient, ) -from pydvl.value.stopping import AbsoluteStandardError, MaxUpdates, StoppingCriterion +from pydvl.value.stopping import AbsoluteStandardError, MaxUpdates from . import check_values @@ -61,84 +58,6 @@ def test_shapley( check_values(values, exact_values, rtol=0.2) -def semivalues_seed_wrapper( - sampler_t: Type[PowersetSampler], u: Utility, *args, seed: Seed, **kwargs -) -> ValuationResult: - """ - Wrapper for semivalues that takes a seed as an argument to be used with - call_fn_multiple_seeds. - """ - sampler = sampler_t(u.data.indices, seed=seed) - return semivalues(sampler, u, *args, **kwargs) - - -@pytest.mark.parametrize("num_samples", [5]) -@pytest.mark.parametrize( - "sampler_t", - [ - UniformSampler, - PermutationSampler, - AntitheticSampler, - ], -) -@pytest.mark.parametrize("coefficient", [shapley_coefficient, beta_coefficient(1, 1)]) -@pytest.mark.parametrize("num_points, num_features", [(12, 3)]) -def test_semivalues_shapley_reproducible( - num_samples: int, - housing_dataset: Dataset, - sampler_t: Type[PowersetSampler], - coefficient: SVCoefficient, - n_jobs: int, - parallel_config: ParallelConfig, - seed: Seed, -): - values_1, values_2 = call_fn_multiple_seeds( - semivalues_seed_wrapper, - sampler_t, - Utility(LinearRegression(), data=housing_dataset, scorer="r2"), - coefficient, - AbsoluteStandardError(0.02, 1.0) | MaxUpdates(2 ** (num_samples * 2)), - n_jobs=n_jobs, - config=parallel_config, - seeds=(seed, seed), - ) - assert np.all(values_1.values == values_2.values) - - -@pytest.mark.parametrize("num_samples", [5]) -@pytest.mark.parametrize( - "sampler_t", - [ - UniformSampler, - PermutationSampler, - AntitheticSampler, - ], -) -@pytest.mark.parametrize("coefficient", [shapley_coefficient, beta_coefficient(1, 1)]) -@pytest.mark.parametrize("num_points, num_features", [(12, 3)]) -def test_semivalues_shapley_stochastic( - num_samples: int, - housing_dataset: Dataset, - sampler_t: Type[PowersetSampler], - coefficient: SVCoefficient, - n_jobs: int, - parallel_config: ParallelConfig, - seed: Seed, - seed_alt: Seed, -): - values_1, values_2 = call_fn_multiple_seeds( - semivalues_seed_wrapper, - sampler_t, - Utility(LinearRegression(), data=housing_dataset, scorer="r2"), - coefficient, - AbsoluteStandardError(0.02, 1.0) | MaxUpdates(2 ** (num_samples * 2)), - n_jobs=n_jobs, - config=parallel_config, - seeds=(seed, seed_alt), - ) - assert np.any(values_1.values != values_2.values) - - @pytest.mark.parametrize("num_samples", [5]) @pytest.mark.parametrize( "sampler", From c28ce5e8bbb78b99a01d39897c6590e7fa7cd82a Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Fri, 1 Sep 2023 18:18:14 +0200 Subject: [PATCH 418/436] Deactivate test case and add TODO --- tests/value/shapley/test_montecarlo.py | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-) diff --git a/tests/value/shapley/test_montecarlo.py b/tests/value/shapley/test_montecarlo.py index 6ec72a8f3..da079952f 100644 --- a/tests/value/shapley/test_montecarlo.py +++ b/tests/value/shapley/test_montecarlo.py @@ -75,19 +75,14 @@ def test_analytic_montecarlo_shapley( test_cases_montecarlo_shapley_reproducible_stochastic = [ # TODO Add once issue #416 is closed. # (12, ShapleyMode.PermutationMontecarlo, {"done": MaxChecks(1)}), - # # FIXME! it should be enough with 2**(len(data)-1) samples - # ( - # 8, - # ShapleyMode.CombinatorialMontecarlo, - # {"done": MaxChecks(1)}, - # ), - (12, ShapleyMode.Owen, dict(n_samples=4, max_q=200)), - (12, ShapleyMode.OwenAntithetic, dict(n_samples=4, max_q=200)), ( - 4, - ShapleyMode.GroupTesting, - dict(n_samples=int(21), epsilon=0.2, delta=0.01), + 12, + ShapleyMode.CombinatorialMontecarlo, + {"done": MaxChecks(4)}, ), + (12, ShapleyMode.Owen, dict(n_samples=4, max_q=200)), + (12, ShapleyMode.OwenAntithetic, dict(n_samples=4, max_q=200)), + (4, ShapleyMode.GroupTesting, dict(n_samples=int(21), epsilon=0.2, delta=0.01)), ] From 8fc2a2b4d6527f0ab7da6cbb01e126308b14a4ba Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 1 Sep 2023 18:22:35 +0200 Subject: [PATCH 419/436] Move changelog entry to 0.7.0's section --- CHANGELOG.md | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 92f101eec..42a845cf5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,10 +1,5 @@ # Changelog -## Unreleased - -- Added more abbreviations to documentation - [PR #415](https://github.com/aai-institute/pyDVL/pull/415) - ## 0.7.0 - 📚 Documentation overhaul, new methods and bug fixes 💥 This is our first β release! We have worked hard to deliver improvements across @@ -16,6 +11,8 @@ the board, with a focus on documentation and usability. [PR #365](https://github.com/aai-institute/pyDVL/pull/365) - Enabled parallel computation for Leave-One-Out values [PR #406](https://github.com/aai-institute/pyDVL/pull/406) +- Added more abbreviations to documentation + [PR #415](https://github.com/aai-institute/pyDVL/pull/415) ### Changed - Replaced sphinx with mkdocs for documentation. Major overhaul of documentation From 6dee93d62e39b20c492ee710c2a19b8d393c3788 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Fri, 1 Sep 2023 18:54:47 +0200 Subject: [PATCH 420/436] Fix comments and typos. --- src/pydvl/utils/functional.py | 28 ++++++++++++------- src/pydvl/utils/numeric.py | 2 -- src/pydvl/utils/types.py | 37 +++++++------------------- src/pydvl/value/result.py | 3 +-- src/pydvl/value/shapley/common.py | 2 +- src/pydvl/value/shapley/gt.py | 4 +-- tests/value/shapley/test_montecarlo.py | 3 ++- tests/value/utils.py | 25 +++++++++++++++++ 8 files changed, 58 insertions(+), 46 deletions(-) create mode 100644 tests/value/utils.py diff --git a/src/pydvl/utils/functional.py b/src/pydvl/utils/functional.py index 55f6a7a2d..092f042c3 100644 --- a/src/pydvl/utils/functional.py +++ b/src/pydvl/utils/functional.py @@ -2,35 +2,43 @@ import inspect from functools import partial -from typing import Callable, Set, Tuple +from typing import Callable, Set, Tuple, Union -__all__ = ["unroll_partial_fn_args"] +__all__ = ["get_free_args_fn"] -def unroll_partial_fn_args(fun: Callable) -> Set[str]: +def get_free_args_fn(fun: Union[Callable, partial]) -> Set[str]: """ - Unroll a function that was set by functools.partial. + Accept a function or partial definition and return the set of arguments that are + free. An argument is free if it is not set by the partial and is a parameter of the + function. Args: - fun: Either or a function to unroll. + fun: A partial or a function to unroll. Returns: - A tuple of the unrolled function and a set of the parameters that were set by - functools.partial. + A set of arguments that were set by the partial. """ args_set_by_partial: Set[str] = set() - def _rec_unroll_partial_function(g: Callable): + def _rec_unroll_partial_function(g: Union[Callable, partial]) -> Callable: """ Store arguments and recursively call itself if the function is a partial. In the - end, return the original function. + end, return the initial wrapped function. + + Args: + g: A partial or a function to unroll. + + Returns: + Initial wrapped function. """ nonlocal args_set_by_partial if isinstance(g, partial): args_set_by_partial.update(g.keywords.keys()) args_set_by_partial.update(g.args) - return _rec_unroll_partial_function(g.keywords["fun"]) + inner_fn = g.keywords["fn"] if "fn" in g.keywords else g.func + return _rec_unroll_partial_function(inner_fn) else: return g diff --git a/src/pydvl/utils/numeric.py b/src/pydvl/utils/numeric.py index 08c465661..d8b1ce915 100644 --- a/src/pydvl/utils/numeric.py +++ b/src/pydvl/utils/numeric.py @@ -122,8 +122,6 @@ def random_powerset( ValueError: if the element sampling probability is not in [0,1] """ - if not isinstance(s, np.ndarray): - raise TypeError("Set must be an NDArray") if q < 0 or q > 1: raise ValueError("Element sampling probability must be in [0,1]") diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index 36eb5ce89..59041b9b9 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -5,13 +5,12 @@ import functools from abc import ABCMeta -from copy import deepcopy -from typing import Any, Callable, Optional, Protocol, Tuple, TypeVar, Union, cast +from typing import Any, Callable, Optional, Protocol, TypeVar, Union, cast from numpy.random import Generator, SeedSequence from numpy.typing import NDArray -from pydvl.utils.functional import unroll_partial_fn_args +from pydvl.utils.functional import get_free_args_fn __all__ = ["SupervisedModel", "MapFunction", "ReduceFunction", "NoPublicConstructor"] @@ -46,13 +45,14 @@ def score(self, x: NDArray, y: NDArray) -> float: pass -def call_fun_remove_arg(*args, fun: Callable, arg: str, **kwargs): +def call_fun_remove_arg(*args, fn: Callable, arg: str, **kwargs): """ - Calls the given function with the given arguments, but removes the given argument. + Calls the given function with the given arguments. In the process it removes the + specified keyword argument from the keyword arguments. Args: args: Positional arguments to pass to the function. - fun: The function to call. + fn: The function to call. arg: The name of the argument to remove. kwargs: Keyword arguments to pass to the function. @@ -64,7 +64,7 @@ def call_fun_remove_arg(*args, fun: Callable, arg: str, **kwargs): except KeyError: pass - return fun(*args, **kwargs) + return fn(*args, **kwargs) def maybe_add_argument(fun: Callable, new_arg: str) -> Callable: @@ -83,10 +83,10 @@ def maybe_add_argument(fun: Callable, new_arg: str) -> Callable: Returns: A new function accepting one more keyword argument. """ - if new_arg in unroll_partial_fn_args(fun): + if new_arg in get_free_args_fn(fun): return fun - return functools.partial(call_fun_remove_arg, fun=fun, arg=new_arg) + return functools.partial(call_fun_remove_arg, fn=fun, arg=new_arg) class NoPublicConstructor(ABCMeta): @@ -137,22 +137,3 @@ def ensure_seed_sequence( return cast(SeedSequence, seed.bit_generator.seed_seq) # type: ignore else: return SeedSequence(seed) - - -def call_fn_multiple_seeds( - fn: Callable, *args, seeds: Tuple[Seed, ...], **kwargs -) -> Tuple: - """ - Execute a function multiple times with different seeds. It copies the arguments - and keyword arguments before passing them to the function. - - Args: - fn: The function to execute. - args: The arguments to pass to the function. - seeds: The seeds to use. - kwargs: The keyword arguments to pass to the function. - - Returns: - A tuple of the results of the function. - """ - return tuple(fn(*deepcopy(args), **deepcopy(kwargs), seed=seed) for seed in seeds) diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index 6fc8fff2f..1d12b218e 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -695,8 +695,7 @@ def from_random( ("efficiency" property of Shapley values). kwargs: Additional options to pass to the constructor of [ValuationResult][pydvl.value.result.ValuationResult]. Use to override status, names, etc. - seed: ither an instance of a numpy random number generator or a seed for - it. + Returns: A valuation result with its status set to [Status.Converged][pydvl.utils.status.Status] by default. diff --git a/src/pydvl/value/shapley/common.py b/src/pydvl/value/shapley/common.py index fb69847ce..8f328712c 100644 --- a/src/pydvl/value/shapley/common.py +++ b/src/pydvl/value/shapley/common.py @@ -90,7 +90,7 @@ def compute_shapley_values( others require specific subtypes. n_jobs: Number of parallel jobs (available only to some methods) seed: Either an instance of a numpy random number generator or a seed - for it. + for it. mode: Choose which shapley algorithm to use. See [ShapleyMode][pydvl.value.shapley.ShapleyMode] for a list of allowed value. diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index cc3284421..1b4b2f3e7 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -141,7 +141,7 @@ def _group_testing_shapley( progress: Whether to display progress bars for each job. job_id: id to use for reporting progress (e.g. to place progres bars) seed: Either an instance of a numpy random number generator or a seed - for it. + for it. Returns: """ @@ -203,7 +203,7 @@ def group_testing_shapley( address, number of cpus, etc. progress: Whether to display progress bars for each job. seed: Either an instance of a numpy random number generator or a seed - for it. + for it. options: Additional options to pass to [cvxpy.Problem.solve()](https://www.cvxpy.org/tutorial/advanced/index.html#solve-method-options). E.g. to change the solver (which defaults to `cvxpy.SCS`) pass diff --git a/tests/value/shapley/test_montecarlo.py b/tests/value/shapley/test_montecarlo.py index da079952f..4df932935 100644 --- a/tests/value/shapley/test_montecarlo.py +++ b/tests/value/shapley/test_montecarlo.py @@ -15,7 +15,7 @@ ) from pydvl.utils.numeric import num_samples_permutation_hoeffding from pydvl.utils.score import Scorer, squashed_r2 -from pydvl.utils.types import Seed, call_fn_multiple_seeds +from pydvl.utils.types import Seed from pydvl.value import compute_shapley_values from pydvl.value.shapley import ShapleyMode from pydvl.value.shapley.naive import combinatorial_exact_shapley @@ -23,6 +23,7 @@ from .. import check_rank_correlation, check_total_value, check_values from ..conftest import polynomial_dataset +from ..utils import call_fn_multiple_seeds log = logging.getLogger(__name__) diff --git a/tests/value/utils.py b/tests/value/utils.py new file mode 100644 index 000000000..7c38e344f --- /dev/null +++ b/tests/value/utils.py @@ -0,0 +1,25 @@ +from __future__ import annotations + +from copy import deepcopy +from typing import Callable, Tuple + +from pydvl.utils.types import Seed + + +def call_fn_multiple_seeds( + fn: Callable, *args, seeds: Tuple[Seed, ...], **kwargs +) -> Tuple: + """ + Execute a function multiple times with different seeds. It copies the arguments + and keyword arguments before passing them to the function. + + Args: + fn: The function to execute. + args: The arguments to pass to the function. + seeds: The seeds to use. + kwargs: The keyword arguments to pass to the function. + + Returns: + A tuple of the results of the function. + """ + return tuple(fn(*deepcopy(args), **deepcopy(kwargs), seed=seed) for seed in seeds) From 9238695c4985d209190eddc3eac472a478973118 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 1 Sep 2023 19:33:02 +0200 Subject: [PATCH 421/436] Mention lava, add links to semivalue functions in main doc --- docs/assets/pydvl.bib | 13 +++++++ docs/value/index.md | 82 +++++++++++++++++++++++---------------- docs/value/semi-values.md | 20 ++++++---- 3 files changed, 74 insertions(+), 41 deletions(-) diff --git a/docs/assets/pydvl.bib b/docs/assets/pydvl.bib index 008bc1bf0..aa6a206e6 100644 --- a/docs/assets/pydvl.bib +++ b/docs/assets/pydvl.bib @@ -132,6 +132,19 @@ @article{jia_efficient_2019a keywords = {notion} } +@inproceedings{just_lava_2023, + title = {{{LAVA}}: {{Data Valuation}} without {{Pre-Specified Learning Algorithms}}}, + shorttitle = {{{LAVA}}}, + author = {Just, Hoang Anh and Kang, Feiyang and Wang, Tianhao and Zeng, Yi and Ko, Myeongseob and Jin, Ming and Jia, Ruoxi}, + date = {2023-02-01}, + url = {https://openreview.net/forum?id=JJuP86nBl4q}, + urldate = {2023-04-25}, + abstract = {Traditionally, data valuation is posed as a problem of equitably splitting the validation performance of a learning algorithm among the training data. As a result, the calculated data values depend on many design choices of the underlying learning algorithm. However, this dependence is undesirable for many use cases of data valuation, such as setting priorities over different data sources in a data acquisition process and informing pricing mechanisms in a data marketplace. In these scenarios, data needs to be valued before the actual analysis and the choice of the learning algorithm is still undetermined then. Another side-effect of the dependence is that to assess the value of individual points, one needs to re-run the learning algorithm with and without a point, which incurs a large computation burden. This work leapfrogs over the current limits of data valuation methods by introducing a new framework that can value training data in a way that is oblivious to the downstream learning algorithm. Our main results are as follows. \$\textbackslash textbf\{(1)\}\$ We develop a proxy for the validation performance associated with a training set based on a non-conventional \$\textbackslash textit\{class-wise\}\$ \$\textbackslash textit\{Wasserstein distance\}\$ between the training and the validation set. We show that the distance characterizes the upper bound of the validation performance for any given model under certain Lipschitz conditions. \$\textbackslash textbf\{(2)\}\$ We develop a novel method to value individual data based on the sensitivity analysis of the \$\textbackslash textit\{class-wise\}\$ Wasserstein distance. Importantly, these values can be directly obtained \$\textbackslash textit\{for free\}\$ from the output of off-the-shelf optimization solvers once the Wasserstein distance is computed. \$\textbackslash textbf\{(3) \}\$We evaluate our new data valuation framework over various use cases related to detecting low-quality data and show that, surprisingly, the learning-agnostic feature of our framework enables a \$\textbackslash textit\{significant improvement\}\$ over the state-of-the-art performance while being \$\textbackslash textit\{orders of magnitude faster.\}\$}, + eventtitle = {The {{Eleventh International Conference}} on {{Learning Representations}} ({{ICLR}} 2023)}, + langid = {english}, + keywords = {notion} +} + @inproceedings{koh_understanding_2017, title = {Understanding {{Black-box Predictions}} via {{Influence Functions}}}, booktitle = {Proceedings of the 34th {{International Conference}} on {{Machine Learning}}}, diff --git a/docs/value/index.md b/docs/value/index.md index 9877fac80..e9253a17c 100644 --- a/docs/value/index.md +++ b/docs/value/index.md @@ -89,10 +89,24 @@ performance metric used. For instance, accuracy is a poor metric for imbalanced sets and this has a stark effect on data values. Some models exhibit great variance in some regimes and this again has a detrimental effect on values. -Nevertheless, some of the most promising applications are: Cleaning of corrupted -data, pruning unnecessary or irrelevant data, repairing mislabeled data, guiding -data acquisition and annotation (active learning), anomaly detection and model -debugging and interpretation. +Nevertheless, some of the most promising applications are: + +* Cleaning of corrupted data. +* Pruning unnecessary or irrelevant data. +* Repairing mislabeled data. +* Guiding data acquisition and annotation (active learning). +* Anomaly detection and model debugging and interpretation. + +Additionally, one of the motivating applications for the whole field is that of +data markets: a marketplace where data owners can sell their data to interested +parties. In this setting, data valuation can be key component to determine the +price of data. Algorithm-agnostic methods like LAVA [@just_lava_2023] are +particularly well suited for this, as they use the Wasserstein distance between +a vendor's data and the buyer's to determine the value of the former. + +However, this is a complex problem which can face practical banal problems like +the fact that data owners may not wish to disclose their data for valuation. + ## Computing data values @@ -299,26 +313,26 @@ nature of every (non-trivial) ML problem can have an effect: that matters, and this tends to be accurate (wrt. to the true ranking) despite inaccurate values. - pyDVL offers a dedicated [function composition][pydvl.utils.score.compose_score] - for scorer functions which can be used to squash a score. - The following is defined in module [score][pydvl.utils.score]: - - ```python - import numpy as np - from pydvl.utils import compose_score - - def sigmoid(x: float) -> float: - return float(1 / (1 + np.exp(-x))) - - squashed_r2 = compose_score("r2", sigmoid, "squashed r2") - - squashed_variance = compose_score( - "explained_variance", sigmoid, "squashed explained variance" - ) - ``` - - These squashed scores can prove useful in regression problems, but they can - also introduce issues in the low-value regime. + ??? tip "Squashing scores" + pyDVL offers a dedicated [function + composition][pydvl.utils.score.compose_score] for scorer functions which + can be used to squash a score. The following is defined in module + [score][pydvl.utils.score]: + ```python + import numpy as np + from pydvl.utils import compose_score + + def sigmoid(x: float) -> float: + return float(1 / (1 + np.exp(-x))) + + squashed_r2 = compose_score("r2", sigmoid, "squashed r2") + + squashed_variance = compose_score( + "explained_variance", sigmoid, "squashed explained variance" + ) + ``` + These squashed scores can prove useful in regression problems, but they + can also introduce issues in the low-value regime. * **High variance utility**: Classical applications of game theoretic value concepts operate with deterministic utilities, but in ML we use an evaluation @@ -328,27 +342,27 @@ nature of every (non-trivial) ML problem can have an effect: configure the caching system to allow multiple evaluations of the utility for every index set. A moving average is computed and returned once the standard error is small, see [MemcachedConfig][pydvl.utils.config.MemcachedConfig]. - [@wang_data_2022] prove that by relaxing one of the Shapley axioms and considering the general class of semi-values, of which Shapley is an instance, one can prove that a choice of constant weights is the best one can - do in a utility-agnostic setting. So-called *Data Banzhaf*. + do in a utility-agnostic setting. This method, dubbed *Data Banzhaf*, is + available in pyDVL as + [compute_banzhaf_semivalues][pydvl.value.semivalues.compute_banzhaf_semivalues]. * **Data set size**: Computing exact Shapley values is NP-hard, and Monte Carlo approximations can converge slowly. Massive datasets are thus impractical, at - least with current techniques. A workaround is to group samples and investigate - their value together. In pyDVL you can do this using - [GroupedDataset][pydvl.utils.dataset.GroupedDataset]. - There is a fully worked-out [example here](../examples/shapley_basic_spotify). - Some algorithms also provide different sampling strategies to reduce - the variance, but due to a no-free-lunch-type theorem, - no single strategy can be optimal for all utilities. + least with [game-theoretical methods][game-theoretical-methods]. A workaround + is to group samples and investigate their value together. You can do this using + [GroupedDataset][pydvl.utils.dataset.GroupedDataset]. There is a fully + worked-out [example here](../examples/shapley_basic_spotify). Some algorithms + also provide different sampling strategies to reduce the variance, but due to a + no-free-lunch-type theorem, no single strategy can be optimal for all utilities. * **Model size**: Since every evaluation of the utility entails retraining the whole model on a subset of the data, large models require great amounts of computation. But also, they will effortlessly interpolate small to medium datasets, leading to great variance in the evaluation of performance on the dedicated validation set. One mitigation for this problem is cross-validation, - but this would incur massive computational cost. As of v.0.3.0 there are no + but this would incur massive computational cost. As of v.0.7.0 there are no facilities in pyDVL for cross-validating the utility (note that this would require cross-validating the whole value computation). diff --git a/docs/value/semi-values.md b/docs/value/semi-values.md index 2f1ea7a9c..2aebe0d80 100644 --- a/docs/value/semi-values.md +++ b/docs/value/semi-values.md @@ -48,10 +48,10 @@ $$ where $B$ is the [Beta function](https://en.wikipedia.org/wiki/Beta_function), and $\alpha$ and $\beta$ are parameters that control the weighting of the -subsets. Setting both to 1 recovers Shapley values, and setting $\alpha = 1$, and -$\beta = 16$ is reported in [@kwon_beta_2022] to be a good choice for -some applications. See however the [Banzhaf indices][banzhaf-indices] section -for an alternative choice of weights which is reported to work better. +subsets. Setting both to 1 recovers Shapley values, and setting $\alpha = 1$, +and $\beta = 16$ is reported in [@kwon_beta_2022] to be a good choice for some +applications. Beta Shapley values are available in pyDVL through +[compute_beta_shapley_semivalues][pydvl.value.semivalues.compute_beta_shapley_semivalues]: ```python from pydvl.value import * @@ -62,6 +62,9 @@ values = compute_beta_shapley_semivalues( ) ``` +See however the [Banzhaf indices][banzhaf-indices] section +for an alternative choice of weights which is reported to work better. + ## Banzhaf indices As noted in the section [Problems of Data Values][problems-of-data-values], the @@ -81,8 +84,10 @@ 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 variance in the utility function than Shapley and Beta Shapley values. +The authors of [@wang_data_2022] 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]: ```python from pydvl.value import * @@ -103,6 +108,8 @@ combination of the three ingredients that define a semi-value: - A sampling method - A weighting scheme $w$. +You can construct any combination of these three ingredients with +[compute_generic_semivalues][pydvl.value.semivalues.compute_generic_semivalues]. The utility function is the same as for Shapley values, and the sampling method can be any of the types defined in [the samplers module][pydvl.value.sampler]. For instance, the following snippet is equivalent to the above: @@ -125,7 +132,6 @@ 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]. - !!! warning "Careful with permutation sampling" This generic implementation of semi-values allowing for any combination of sampling and weighting schemes is very flexible and, in principle, it From ec8aac021ebb9777df6cf5396cc24dcaaca23043 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Fri, 1 Sep 2023 20:04:32 +0200 Subject: [PATCH 422/436] Fix url --- mkdocs.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mkdocs.yml b/mkdocs.yml index f23921775..51f24e756 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -145,7 +145,7 @@ extra: default: stable social: - icon: fontawesome/brands/github - link: https://github.com/appliedAI-Initiative/pyDVL + link: https://github.com/aai-institute/pyDVL - icon: fontawesome/brands/python link: https://pypi.org/project/pyDVL/ - icon: fontawesome/brands/twitter From 3a053d37b1e283966a50dd16b8fabdd059c48b2c Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Fri, 1 Sep 2023 19:12:58 +0200 Subject: [PATCH 423/436] Optimized function names and further extended one comment. --- src/pydvl/utils/functional.py | 42 +++++++++++++++++++++++++++++------ src/pydvl/utils/types.py | 26 ++-------------------- 2 files changed, 37 insertions(+), 31 deletions(-) diff --git a/src/pydvl/utils/functional.py b/src/pydvl/utils/functional.py index 092f042c3..37d9a18ea 100644 --- a/src/pydvl/utils/functional.py +++ b/src/pydvl/utils/functional.py @@ -4,7 +4,30 @@ from functools import partial from typing import Callable, Set, Tuple, Union -__all__ = ["get_free_args_fn"] +__all__ = ["get_free_args_fn", "fn_accept_additional_argument"] + + +def fn_accept_additional_argument(*args, fn: Callable, arg: str, **kwargs): + """ + Calls the given function with the given arguments. In the process of calling the + wrapped function, it removes the specified keyword argument from the passed keyword + arguments. This function can be pickled by `pickle` as it is on the . + + Args: + args: Positional arguments to pass to the function. + fn: The function to call. + arg: The name of the argument to remove. + kwargs: Keyword arguments to pass to the function. + + Returns: + The return value of the function. + """ + try: + del kwargs[arg] + except KeyError: + pass + + return fn(*args, **kwargs) def get_free_args_fn(fun: Union[Callable, partial]) -> Set[str]: @@ -21,10 +44,11 @@ def get_free_args_fn(fun: Union[Callable, partial]) -> Set[str]: """ args_set_by_partial: Set[str] = set() - def _rec_unroll_partial_function(g: Union[Callable, partial]) -> Callable: + def _rec_unroll_partial_function_args(g: Union[Callable, partial]) -> Callable: """ Store arguments and recursively call itself if the function is a partial. In the - end, return the initial wrapped function. + end, return the initial wrapped function. Besides partial functions it also + supports `partial(fn_accept_additional_argument, *args, **kwargs)` constructs. Args: g: A partial or a function to unroll. @@ -34,14 +58,18 @@ def _rec_unroll_partial_function(g: Union[Callable, partial]) -> Callable: """ nonlocal args_set_by_partial - if isinstance(g, partial): + if isinstance(g, partial) and g.func == fn_accept_additional_argument: + arg = g.keywords["arg"] + if arg in args_set_by_partial: + args_set_by_partial.remove(arg) + return _rec_unroll_partial_function_args(g.keywords["fn"]) + elif isinstance(g, partial): args_set_by_partial.update(g.keywords.keys()) args_set_by_partial.update(g.args) - inner_fn = g.keywords["fn"] if "fn" in g.keywords else g.func - return _rec_unroll_partial_function(inner_fn) + return _rec_unroll_partial_function_args(g.func) else: return g - wrapped_fn = _rec_unroll_partial_function(fun) + wrapped_fn = _rec_unroll_partial_function_args(fun) sig = inspect.signature(wrapped_fn) return args_set_by_partial | set(sig.parameters.keys()) diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index 59041b9b9..c3acf410c 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -10,7 +10,7 @@ from numpy.random import Generator, SeedSequence from numpy.typing import NDArray -from pydvl.utils.functional import get_free_args_fn +from pydvl.utils.functional import fn_accept_additional_argument, get_free_args_fn __all__ = ["SupervisedModel", "MapFunction", "ReduceFunction", "NoPublicConstructor"] @@ -45,28 +45,6 @@ def score(self, x: NDArray, y: NDArray) -> float: pass -def call_fun_remove_arg(*args, fn: Callable, arg: str, **kwargs): - """ - Calls the given function with the given arguments. In the process it removes the - specified keyword argument from the keyword arguments. - - Args: - args: Positional arguments to pass to the function. - fn: The function to call. - arg: The name of the argument to remove. - kwargs: Keyword arguments to pass to the function. - - Returns: - The return value of the function. - """ - try: - del kwargs[arg] - except KeyError: - pass - - return fn(*args, **kwargs) - - def maybe_add_argument(fun: Callable, new_arg: str) -> Callable: """Wraps a function to accept the given keyword parameter if it doesn't already. @@ -86,7 +64,7 @@ def maybe_add_argument(fun: Callable, new_arg: str) -> Callable: if new_arg in get_free_args_fn(fun): return fun - return functools.partial(call_fun_remove_arg, fn=fun, arg=new_arg) + return functools.partial(fn_accept_additional_argument, fn=fun, arg=new_arg) class NoPublicConstructor(ABCMeta): From d3fb8ac1b33a4cba69b1d7035d557feb62a6e146 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Fri, 1 Sep 2023 21:40:14 +0200 Subject: [PATCH 424/436] Add extended documentation. --- src/pydvl/utils/functional.py | 30 ++++++++++++++++++++++++++---- 1 file changed, 26 insertions(+), 4 deletions(-) diff --git a/src/pydvl/utils/functional.py b/src/pydvl/utils/functional.py index 37d9a18ea..e2293c36f 100644 --- a/src/pydvl/utils/functional.py +++ b/src/pydvl/utils/functional.py @@ -32,12 +32,34 @@ def fn_accept_additional_argument(*args, fn: Callable, arg: str, **kwargs): def get_free_args_fn(fun: Union[Callable, partial]) -> Set[str]: """ - Accept a function or partial definition and return the set of arguments that are - free. An argument is free if it is not set by the partial and is a parameter of the - function. + Accept a function or a partial definition and return the set of arguments that are + free. An argument is considered free if it is not set by the partial and is a + parameter of the function. Formally, this can be described as follows: + + Let phi be the function that returns the set of arguments that are set by a given + function. For functions f and g, one can extend the function phi recursively to psi + as follows: + + a) If `f = partial(g, **kwargs)`, two cases arise: + a) If `g = fn_accept_additional_argument`, then + `psi(f) = psi(kwargs.fn) + {kwargs.arg}` + b) Else, `psi(f) = psi(g) - kwargs.keys()` + b) Else,`psi(g) = phi(g)` (Note that this is the base case.) + + Transforming `fn_accept_additional_argument` into a partial function is done by: + `f(fn, arg) = partial(fn_accept_additional_argument, **{fn: fn, arg: arg})` + This function is the inverse (with respect to phi) to the function + `g(fn, arg, val) = partial(g, {arg: val})` in the sense that + `phi(fn) = phi(f(g(fn, arg, val), arg))` + + Together, these components form an algebraic system for reasoning about function + arguments. Each operation (phi, psi, f, g) transforms a function into a new + function in a way that changes the set of arguments that have been applied, and we + have precise rules for understanding those transformations. Args: - fun: A partial or a function to unroll. + fun: A function composed of raw functions `f` or partial functions as + constructed in the description. Returns: A set of arguments that were set by the partial. From cb546ea0b2b8216b060bbfb46012ed49632164bd Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Fri, 1 Sep 2023 22:24:01 +0200 Subject: [PATCH 425/436] Adapted CHANGELOG.md. --- CHANGELOG.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index fc7b3f163..b53b43c57 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,10 @@ the board, with a focus on documentation and usability. [PR #365](https://github.com/aai-institute/pyDVL/pull/365) - Enabled parallel computation for Leave-One-Out values [PR #406](https://github.com/aai-institute/pyDVL/pull/406) +- Added seed to functions from `pydvl.utils.numeric`, `pydvl.value.shapley` and + `pydvl.value.semivalues`. Introduced new type `Seed` and conversion function + `ensure_seed_sequence`. + [PR #396](https://github.com/aai-institute/pyDVL/pull/396) ### Changed - Replaced sphinx with mkdocs for documentation. Major overhaul of documentation From 688c9d787852b34883b8b3d64ea12f9aa50e6572 Mon Sep 17 00:00:00 2001 From: Markus Semmler Date: Fri, 1 Sep 2023 23:54:14 +0200 Subject: [PATCH 426/436] Fix indent in docstring. --- src/pydvl/value/semivalues.py | 3 ++- src/pydvl/value/shapley/common.py | 3 +-- src/pydvl/value/shapley/gt.py | 6 ++---- src/pydvl/value/shapley/montecarlo.py | 2 +- 4 files changed, 6 insertions(+), 8 deletions(-) diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 4078ca523..5cec32d5c 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -371,7 +371,8 @@ def compute_beta_shapley_semivalues( sampler_t: The sampler type to use. See :mod:`pydvl.value.sampler` for a list. 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. + config: Object configuring parallel computation, with cluster address, number of + cpus, etc. progress: Whether to display a progress bar. Returns: diff --git a/src/pydvl/value/shapley/common.py b/src/pydvl/value/shapley/common.py index 8f328712c..97f4e2945 100644 --- a/src/pydvl/value/shapley/common.py +++ b/src/pydvl/value/shapley/common.py @@ -89,8 +89,7 @@ def compute_shapley_values( criteria using boolean operators. Some methods ignore this argument, others require specific subtypes. n_jobs: Number of parallel jobs (available only to some methods) - seed: Either an instance of a numpy random number generator or a seed - for it. + seed: Either an instance of a numpy random number generator or a seed for it. mode: Choose which shapley algorithm to use. See [ShapleyMode][pydvl.value.shapley.ShapleyMode] for a list of allowed value. diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index 1b4b2f3e7..cc207129f 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -140,8 +140,7 @@ def _group_testing_shapley( n_samples: total number of samples (subsets) to use. progress: Whether to display progress bars for each job. job_id: id to use for reporting progress (e.g. to place progres bars) - seed: Either an instance of a numpy random number generator or a seed - for it. + seed: Either an instance of a numpy random number generator or a seed for it. Returns: """ @@ -202,8 +201,7 @@ def group_testing_shapley( config: Object configuring parallel computation, with cluster address, number of cpus, etc. progress: Whether to display progress bars for each job. - seed: Either an instance of a numpy random number generator or a seed - for it. + seed: Either an instance of a numpy random number generator or a seed for it. options: Additional options to pass to [cvxpy.Problem.solve()](https://www.cvxpy.org/tutorial/advanced/index.html#solve-method-options). E.g. to change the solver (which defaults to `cvxpy.SCS`) pass diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index eca44139f..704eb928e 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -323,7 +323,7 @@ def combinatorial_montecarlo_shapley( number of cpus, etc. progress: Whether to display progress bars for each job. seed: Either an instance of a numpy random number generator or a seed for it. - f + Returns: Object with the data values. """ From b827439e9d42dbebaf2f394fde03299fc9f03ac0 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 2 Sep 2023 12:15:48 +0200 Subject: [PATCH 427/436] Fix corner-case --- tests/utils/test_parallel.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/utils/test_parallel.py b/tests/utils/test_parallel.py index 3316fe7c3..b0588bb07 100644 --- a/tests/utils/test_parallel.py +++ b/tests/utils/test_parallel.py @@ -271,7 +271,7 @@ def test_future_cancellation(parallel_config): # :func:`test_map_reduce_stochastic`. def _sum_of_random_integers(x: None, seed: Optional[Seed] = None): rng = np.random.default_rng(seed) - values = rng.integers(0, rng.integers(100), 10) + values = rng.integers(0, rng.integers(10, 100), 10) return np.sum(values) From 2ba97e7e9fa3cf215af7edbafa914848ffc4205b Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 2 Sep 2023 12:16:17 +0200 Subject: [PATCH 428/436] Remove unnecessary function and merge tests --- tests/utils/test_parallel.py | 45 +++++++++++++----------------------- 1 file changed, 16 insertions(+), 29 deletions(-) diff --git a/tests/utils/test_parallel.py b/tests/utils/test_parallel.py index b0588bb07..8ba145aa8 100644 --- a/tests/utils/test_parallel.py +++ b/tests/utils/test_parallel.py @@ -147,38 +147,29 @@ def reduce_func(x, y): assert result == 150 -def test_map_reduce_reproducible(parallel_config, seed): - """ - Test that the same result is obtained when using the same seed. And that different - results are obtained when using different seeds. - """ - - map_reduce_job = MapReduceJob( - None, - map_func=_sum_of_random_integers, - reduce_func=_mean_func, - config=parallel_config, - ) - result_1 = map_reduce_job(seed=seed) - result_2 = map_reduce_job(seed=seed) - assert result_1 == result_2 - - -def test_map_reduce_stochastic(parallel_config, seed, seed_alt): - """ - Test that the same result is obtained when using the same seed. And that different - results are obtained when using different seeds. +@pytest.mark.parametrize( + "seed_1, seed_2, op", + [ + (None, None, operator.ne), + (None, 42, operator.ne), + (42, None, operator.ne), + (42, 42, operator.eq), + ], +) +def test_map_reduce_seeding(parallel_config, seed_1, seed_2, op): + """Test that the same result is obtained when using the same seed. And that + different results are obtained when using different seeds. """ map_reduce_job = MapReduceJob( None, map_func=_sum_of_random_integers, - reduce_func=_mean_func, + reduce_func=np.mean, config=parallel_config, ) - result_1 = map_reduce_job(seed=seed) - result_2 = map_reduce_job(seed=seed_alt) - assert result_1 != result_2 + result_1 = map_reduce_job(seed=seed_1) + result_2 = map_reduce_job(seed=seed_2) + assert op(result_1, result_2) def test_wrap_function(parallel_config, num_workers): @@ -273,7 +264,3 @@ def _sum_of_random_integers(x: None, seed: Optional[Seed] = None): rng = np.random.default_rng(seed) values = rng.integers(0, rng.integers(10, 100), 10) return np.sum(values) - - -def _mean_func(means): - return np.mean(means) From 087fdbbcd8fea662c578fc4cac79725f1bfad5dc Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 2 Sep 2023 12:17:41 +0200 Subject: [PATCH 429/436] Move maybe_add_argument to functional.py --- src/pydvl/utils/functional.py | 24 ++++++++++++++++++++++- src/pydvl/utils/parallel/map_reduce.py | 2 +- src/pydvl/utils/types.py | 27 +------------------------- 3 files changed, 25 insertions(+), 28 deletions(-) diff --git a/src/pydvl/utils/functional.py b/src/pydvl/utils/functional.py index e2293c36f..197c1448f 100644 --- a/src/pydvl/utils/functional.py +++ b/src/pydvl/utils/functional.py @@ -4,7 +4,7 @@ from functools import partial from typing import Callable, Set, Tuple, Union -__all__ = ["get_free_args_fn", "fn_accept_additional_argument"] +__all__ = ["maybe_add_argument"] def fn_accept_additional_argument(*args, fn: Callable, arg: str, **kwargs): @@ -95,3 +95,25 @@ def _rec_unroll_partial_function_args(g: Union[Callable, partial]) -> Callable: wrapped_fn = _rec_unroll_partial_function_args(fun) sig = inspect.signature(wrapped_fn) return args_set_by_partial | set(sig.parameters.keys()) + + +def maybe_add_argument(fun: Callable, new_arg: str) -> Callable: + """Wraps a function to accept the given keyword parameter if it doesn't + already. + + If `fun` already takes a keyword parameter of name `new_arg`, then it is + returned as is. Otherwise, a wrapper is returned which merely ignores the + argument. + + Args: + fun: The function to wrap + new_arg: The name of the argument that the new function will accept + (and ignore). + + Returns: + A new function accepting one more keyword argument. + """ + if new_arg in free_arguments(fun): + return fun + + return functools.partial(_accept_additional_argument, fun=fun, arg=new_arg) diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index 4f0b55af3..dadeb9478 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -20,8 +20,8 @@ ReduceFunction, Seed, ensure_seed_sequence, - maybe_add_argument, ) +from ..functional import maybe_add_argument from .backend import init_parallel_backend __all__ = ["MapReduceJob"] diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index c3acf410c..81f949f64 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -3,15 +3,12 @@ """ from __future__ import annotations -import functools from abc import ABCMeta -from typing import Any, Callable, Optional, Protocol, TypeVar, Union, cast +from typing import Any, Optional, Protocol, TypeVar, Union, cast from numpy.random import Generator, SeedSequence from numpy.typing import NDArray -from pydvl.utils.functional import fn_accept_additional_argument, get_free_args_fn - __all__ = ["SupervisedModel", "MapFunction", "ReduceFunction", "NoPublicConstructor"] R = TypeVar("R", covariant=True) @@ -45,28 +42,6 @@ def score(self, x: NDArray, y: NDArray) -> float: pass -def maybe_add_argument(fun: Callable, new_arg: str) -> Callable: - """Wraps a function to accept the given keyword parameter if it doesn't - already. - - If `fun` already takes a keyword parameter of name `new_arg`, then it is - returned as is. Otherwise, a wrapper is returned which merely ignores the - argument. - - Args: - fun: The function to wrap - new_arg: The name of the argument that the new function will accept - (and ignore). - - Returns: - A new function accepting one more keyword argument. - """ - if new_arg in get_free_args_fn(fun): - return fun - - return functools.partial(fn_accept_additional_argument, fn=fun, arg=new_arg) - - class NoPublicConstructor(ABCMeta): """Metaclass that ensures a private constructor From 317f8b1fa326d5222765190d416e107313c839c3 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 2 Sep 2023 12:19:11 +0200 Subject: [PATCH 430/436] Renaming and simplifying docstrings --- src/pydvl/utils/functional.py | 70 +++++++++++++---------------------- 1 file changed, 26 insertions(+), 44 deletions(-) diff --git a/src/pydvl/utils/functional.py b/src/pydvl/utils/functional.py index 197c1448f..370f7781a 100644 --- a/src/pydvl/utils/functional.py +++ b/src/pydvl/utils/functional.py @@ -1,21 +1,23 @@ +""" +Supporting utilities for manipulating arguments of functions. +""" + from __future__ import annotations import inspect from functools import partial -from typing import Callable, Set, Tuple, Union +from typing import Callable, Set, Union __all__ = ["maybe_add_argument"] -def fn_accept_additional_argument(*args, fn: Callable, arg: str, **kwargs): - """ - Calls the given function with the given arguments. In the process of calling the - wrapped function, it removes the specified keyword argument from the passed keyword - arguments. This function can be pickled by `pickle` as it is on the . +def _accept_additional_argument(*args, fun: Callable, arg: str, **kwargs): + """Calls the given function with the given positional and keyword arguments, + removing `arg` from the keyword arguments. Args: args: Positional arguments to pass to the function. - fn: The function to call. + fun: The function to call. arg: The name of the argument to remove. kwargs: Keyword arguments to pass to the function. @@ -27,50 +29,30 @@ def fn_accept_additional_argument(*args, fn: Callable, arg: str, **kwargs): except KeyError: pass - return fn(*args, **kwargs) + return fun(*args, **kwargs) -def get_free_args_fn(fun: Union[Callable, partial]) -> Set[str]: - """ - Accept a function or a partial definition and return the set of arguments that are - free. An argument is considered free if it is not set by the partial and is a - parameter of the function. Formally, this can be described as follows: - - Let phi be the function that returns the set of arguments that are set by a given - function. For functions f and g, one can extend the function phi recursively to psi - as follows: - - a) If `f = partial(g, **kwargs)`, two cases arise: - a) If `g = fn_accept_additional_argument`, then - `psi(f) = psi(kwargs.fn) + {kwargs.arg}` - b) Else, `psi(f) = psi(g) - kwargs.keys()` - b) Else,`psi(g) = phi(g)` (Note that this is the base case.) - - Transforming `fn_accept_additional_argument` into a partial function is done by: - `f(fn, arg) = partial(fn_accept_additional_argument, **{fn: fn, arg: arg})` - This function is the inverse (with respect to phi) to the function - `g(fn, arg, val) = partial(g, {arg: val})` in the sense that - `phi(fn) = phi(f(g(fn, arg, val), arg))` - - Together, these components form an algebraic system for reasoning about function - arguments. Each operation (phi, psi, f, g) transforms a function into a new - function in a way that changes the set of arguments that have been applied, and we - have precise rules for understanding those transformations. +def free_arguments(fun: Union[Callable, partial]) -> Set[str]: + """Computes the set of free arguments for a function or [partial object][]. + + All arguments of a function are considered free unless they are set by a + partial. For example, if `f = partial(g, a=1)`, then `a` is not a free + argument of `f`. Args: - fun: A function composed of raw functions `f` or partial functions as - constructed in the description. + fun: A callable or a [partial object][]. Returns: - A set of arguments that were set by the partial. + The set of free arguments of `fun`. """ args_set_by_partial: Set[str] = set() def _rec_unroll_partial_function_args(g: Union[Callable, partial]) -> Callable: - """ - Store arguments and recursively call itself if the function is a partial. In the - end, return the initial wrapped function. Besides partial functions it also - supports `partial(fn_accept_additional_argument, *args, **kwargs)` constructs. + """Stores arguments and recursively call itself if `g` is a partial. In + the end, returns the initially wrapped function. + + This handles the construct `partial(_accept_additional_argument, *args, + **kwargs)` that is used by `maybe_add_argument`. Args: g: A partial or a function to unroll. @@ -80,11 +62,11 @@ def _rec_unroll_partial_function_args(g: Union[Callable, partial]) -> Callable: """ nonlocal args_set_by_partial - if isinstance(g, partial) and g.func == fn_accept_additional_argument: + if isinstance(g, partial) and g.func == _accept_additional_argument: arg = g.keywords["arg"] if arg in args_set_by_partial: args_set_by_partial.remove(arg) - return _rec_unroll_partial_function_args(g.keywords["fn"]) + return _rec_unroll_partial_function_args(g.keywords["fun"]) elif isinstance(g, partial): args_set_by_partial.update(g.keywords.keys()) args_set_by_partial.update(g.args) @@ -116,4 +98,4 @@ def maybe_add_argument(fun: Callable, new_arg: str) -> Callable: if new_arg in free_arguments(fun): return fun - return functools.partial(_accept_additional_argument, fun=fun, arg=new_arg) + return partial(_accept_additional_argument, fun=fun, arg=new_arg) From f007ce8c82fe6cbbab5156ef636bb4d771b7363c Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 2 Sep 2023 12:19:26 +0200 Subject: [PATCH 431/436] Cosmetic --- CHANGELOG.md | 7 +++++-- src/pydvl/utils/functional.py | 13 ++++++++++--- src/pydvl/utils/parallel/map_reduce.py | 7 +------ src/pydvl/utils/types.py | 11 ++++++++++- src/pydvl/value/loo/loo.py | 2 +- src/pydvl/value/shapley/montecarlo.py | 6 ++++-- 6 files changed, 31 insertions(+), 15 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ca0f29452..bc82e515b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,9 +1,11 @@ # Changelog -## 0.7.0 - 📚 Documentation overhaul, new methods and bug fixes 💥 +## 0.7.0 - 📚🆕 Documentation and IF overhaul, new methods and bug fixes 💥🐞 This is our first β release! We have worked hard to deliver improvements across -the board, with a focus on documentation and usability. +the board, with a focus on documentation and usability. We have also reworked +the internals of the `influence` module, improved parallelism and handling of +randomness. ### Added @@ -19,6 +21,7 @@ the board, with a focus on documentation and usability. [PR #396](https://github.com/aai-institute/pyDVL/pull/396) ### Changed + - Replaced sphinx with mkdocs for documentation. Major overhaul of documentation [PR #352](https://github.com/aai-institute/pyDVL/pull/352) - Made ray an optional dependency, relying on joblib as default parallel backend diff --git a/src/pydvl/utils/functional.py b/src/pydvl/utils/functional.py index 370f7781a..879068b9c 100644 --- a/src/pydvl/utils/functional.py +++ b/src/pydvl/utils/functional.py @@ -33,7 +33,8 @@ def _accept_additional_argument(*args, fun: Callable, arg: str, **kwargs): def free_arguments(fun: Union[Callable, partial]) -> Set[str]: - """Computes the set of free arguments for a function or [partial object][]. + """Computes the set of free arguments for a function or + [functools.partial][] object. All arguments of a function are considered free unless they are set by a partial. For example, if `f = partial(g, a=1)`, then `a` is not a free @@ -44,12 +45,15 @@ def free_arguments(fun: Union[Callable, partial]) -> Set[str]: Returns: The set of free arguments of `fun`. + + !!! tip "New in version 0.7.0" """ args_set_by_partial: Set[str] = set() def _rec_unroll_partial_function_args(g: Union[Callable, partial]) -> Callable: - """Stores arguments and recursively call itself if `g` is a partial. In - the end, returns the initially wrapped function. + """Stores arguments and recursively call itself if `g` is a + [functools.partial][] object. In the end, returns the initially wrapped + function. This handles the construct `partial(_accept_additional_argument, *args, **kwargs)` that is used by `maybe_add_argument`. @@ -94,6 +98,9 @@ def maybe_add_argument(fun: Callable, new_arg: str) -> Callable: Returns: A new function accepting one more keyword argument. + + !!! tip "Changed in version 0.7.0" + Ability to work with partials. """ if new_arg in free_arguments(fun): return fun diff --git a/src/pydvl/utils/parallel/map_reduce.py b/src/pydvl/utils/parallel/map_reduce.py index dadeb9478..149cd2752 100644 --- a/src/pydvl/utils/parallel/map_reduce.py +++ b/src/pydvl/utils/parallel/map_reduce.py @@ -15,13 +15,8 @@ from numpy.typing import NDArray from ..config import ParallelConfig -from ..types import ( - MapFunction, - ReduceFunction, - Seed, - ensure_seed_sequence, -) from ..functional import maybe_add_argument +from ..types import MapFunction, ReduceFunction, Seed, ensure_seed_sequence from .backend import init_parallel_backend __all__ = ["MapReduceJob"] diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index 81f949f64..5df91923d 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -9,7 +9,14 @@ from numpy.random import Generator, SeedSequence from numpy.typing import NDArray -__all__ = ["SupervisedModel", "MapFunction", "ReduceFunction", "NoPublicConstructor"] +__all__ = [ + "ensure_seed_sequence", + "MapFunction", + "NoPublicConstructor", + "ReduceFunction", + "Seed", + "SupervisedModel", +] R = TypeVar("R", covariant=True) @@ -83,6 +90,8 @@ def ensure_seed_sequence( Returns: A SeedSequence object. + + !!! tip "New in version 0.7.0" """ if isinstance(seed, SeedSequence): return seed diff --git a/src/pydvl/value/loo/loo.py b/src/pydvl/value/loo/loo.py index 0ef951a89..893594260 100644 --- a/src/pydvl/value/loo/loo.py +++ b/src/pydvl/value/loo/loo.py @@ -32,7 +32,7 @@ def compute_loo( Returns: Object with the data values. - !!! tip "New in version 0.8.0" + !!! tip "New in version 0.7.0" Renamed from `naive_loo` and added parallel computation. """ diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index 704eb928e..06c4e023f 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -241,7 +241,8 @@ def _combinatorial_montecarlo_shapley( job_id: int = 1, seed: Optional[Seed] = None, ) -> ValuationResult: - """Helper function for [combinatorial_montecarlo_shapley()][pydvl.value.shapley.montecarlo.combinatorial_montecarlo_shapley]. + """Helper function for + [combinatorial_montecarlo_shapley][pydvl.value.shapley.montecarlo.combinatorial_montecarlo_shapley]. This is the code that is sent to workers to compute values using the combinatorial definition. @@ -252,7 +253,8 @@ def _combinatorial_montecarlo_shapley( done: Check on the results which decides when to stop sampling subsets for an index. progress: Whether to display progress bars for each job. - seed: Either an instance of a numpy random number generator or a seed for it. + seed: Either an instance of a numpy random number generator or a seed + for it. job_id: id to use for reporting progress Returns: From 1bb75e11d3dc94e99a37578d46e1309df1057aa8 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 2 Sep 2023 12:42:20 +0200 Subject: [PATCH 432/436] Nicer headers in API --- docs/css/extra.css | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/docs/css/extra.css b/docs/css/extra.css index 159879bef..4716fee11 100644 --- a/docs/css/extra.css +++ b/docs/css/extra.css @@ -77,6 +77,12 @@ a.autorefs-external:hover::after { user-select: none; } +/* Nicer style of headers in generated API */ +h2 code { + font-size: large!important; + background-color: inherit!important; +} + /* Remove cell input and output prompt */ .jp-InputArea-prompt, .jp-OutputArea-prompt { display: none !important; From e38e1ff232bae9ebbc08e9df2d0415a0bda98a10 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 2 Sep 2023 12:45:29 +0200 Subject: [PATCH 433/436] Cleanup --- tests/value/__init__.py | 2 -- tests/value/shapley/test_montecarlo.py | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/tests/value/__init__.py b/tests/value/__init__.py index 795eef798..ce16e73e4 100644 --- a/tests/value/__init__.py +++ b/tests/value/__init__.py @@ -65,8 +65,6 @@ def check_values( have |value - exact_value| < 0.1 for every value. :param extra_values_names: Sequence of names of extra values that should also be compared. - :param equal: True, if it should be checked that the values are equal, False if it - should be checked that they are not equal. """ values.sort() exact_values.sort() diff --git a/tests/value/shapley/test_montecarlo.py b/tests/value/shapley/test_montecarlo.py index 4df932935..b7961cdb8 100644 --- a/tests/value/shapley/test_montecarlo.py +++ b/tests/value/shapley/test_montecarlo.py @@ -83,7 +83,7 @@ def test_analytic_montecarlo_shapley( ), (12, ShapleyMode.Owen, dict(n_samples=4, max_q=200)), (12, ShapleyMode.OwenAntithetic, dict(n_samples=4, max_q=200)), - (4, ShapleyMode.GroupTesting, dict(n_samples=int(21), epsilon=0.2, delta=0.01)), + (4, ShapleyMode.GroupTesting, dict(n_samples=21, epsilon=0.2, delta=0.01)), ] From 202c30debaf40a87d58983460acda8b6c207de79 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 2 Sep 2023 13:02:05 +0200 Subject: [PATCH 434/436] Formatting of influence.md --- docs/influence/index.md | 132 ++++++++++++++++++++-------------------- 1 file changed, 66 insertions(+), 66 deletions(-) diff --git a/docs/influence/index.md b/docs/influence/index.md index aa4fc97ac..c23ed0360 100644 --- a/docs/influence/index.md +++ b/docs/influence/index.md @@ -5,7 +5,7 @@ alias: text: Computing Influence Values --- -# The influence function +## The influence function !!! Warning The code in the package [pydvl.influence][pydvl.influence] is experimental. @@ -30,7 +30,7 @@ pyDVL implements several methods for the efficient computation of the IF for machine learning. In the examples we document some of the difficulties that can arise when using the IF. -# The Influence Function +## Construction First introduced in the context of robust statistics in [@hampel_influence_1974], the IF was popularized in the context of machine learning in @@ -74,7 +74,7 @@ up-weighting of samples and perturbation influences. The choice is done by the parameter `influence_type` in the main entry point [compute_influences][pydvl.influence.general.compute_influences]. -## Approximating the influence of a point +### Approximating the influence of a point Let's define @@ -125,7 +125,7 @@ All the resulting factors are gradients of the loss wrt. the model parameters $\hat{\theta}$. This can be easily computed through one or more backpropagation passes. -## Perturbation definition of the influence score +### Perturbation definition of the influence score How would the loss of the model change if, instead of up-weighting an individual point $z$, we were to up-weight only a single feature of that point? Given $z = @@ -180,11 +180,11 @@ estimate of the impact of a point on the models loss and it is subject to large approximation errors. It can nonetheless be used to build training-set attacks, as done in [@koh_understanding_2017]. -# Computing influences +## Computation The main entry point of the library for influence calculation is -[compute_influences][pydvl.influence.general.compute_influences]. -Given a pre-trained pytorch model with a loss, first an instance of +[compute_influences][pydvl.influence.general.compute_influences]. Given a +pre-trained pytorch model with a loss, first an instance of [TorchTwiceDifferentiable][pydvl.influence.torch.torch_differentiable.TorchTwiceDifferentiable] needs to be created: @@ -217,11 +217,11 @@ tends to improve the performance of the model on test point $i$, and vice versa, a large negative influence indicates that training point $j$ tends to worsen the performance of the model on test point $i$. -## Perturbation influences +### Perturbation influences The method of empirical influence computation can be selected in -[compute_influences][pydvl.influence.general.compute_influences] -with the parameter `influence_type`: +[compute_influences][pydvl.influence.general.compute_influences] with the +parameter `influence_type`: ```python from pydvl.influence import compute_influences @@ -240,7 +240,7 @@ as the number of input features in the data. Therefore, each entry in the tensor represents the influence of each feature of each training point on each test point. -## Approximate matrix inversion +### Approximate matrix inversion In almost every practical application it is not possible to construct, even less invert the complete Hessian in memory. pyDVL offers several approximate @@ -259,10 +259,9 @@ compute_influences( Each inversion method has its own set of parameters that can be tuned to improve the final result. These parameters can be passed directly to -[compute_influences][pydvl.influence.general.compute_influences] -as keyword arguments. For example, the following code sets -the maximum number of iterations for conjugate -gradient to $100$ and the minimum relative error to $0.01$: +[compute_influences][pydvl.influence.general.compute_influences] as keyword +arguments. For example, the following code sets the maximum number of iterations +for conjugate gradient to $100$ and the minimum relative error to $0.01$: ```python from pydvl.influence import compute_influences @@ -277,25 +276,23 @@ compute_influences( ) ``` -## Hessian regularization +### Hessian regularization Additionally, and as discussed in [the introduction](#the-influence-function), -in machine learning training rarely converges to a -global minimum of the loss. Despite good apparent convergence, $\hat{\theta}$ -might be located in a region with flat curvature or close to a saddle point. In -particular, the Hessian might have vanishing eigenvalues making its direct -inversion impossible. Certain methods, such as the -[Arnoldi method](#arnoldi-solver) are robust against these problems, -but most are not. - -To circumvent this problem, many approximate methods can be implemented. -The simplest adds a small *hessian perturbation term*, -i.e. $H_{\hat{\theta}} + \lambda \mathbb{I}$, -with $\mathbb{I}$ being the identity matrix. This standard trick -ensures that the eigenvalues of $H_{\hat{\theta}}$ are bounded away from zero -and therefore the matrix is invertible. In order for this regularization not to -corrupt the outcome too much, the parameter $\lambda$ should be as small as -possible while still allowing a reliable inversion of $H_{\hat{\theta}} + +in machine learning training rarely converges to a global minimum of the loss. +Despite good apparent convergence, $\hat{\theta}$ might be located in a region +with flat curvature or close to a saddle point. In particular, the Hessian might +have vanishing eigenvalues making its direct inversion impossible. Certain +methods, such as the [Arnoldi method](#arnoldi-solver) are robust against these +problems, but most are not. + +To circumvent this problem, many approximate methods can be implemented. The +simplest adds a small *hessian perturbation term*, i.e. $H_{\hat{\theta}} + +\lambda \mathbb{I}$, with $\mathbb{I}$ being the identity matrix. This standard +trick ensures that the eigenvalues of $H_{\hat{\theta}}$ are bounded away from +zero and therefore the matrix is invertible. In order for this regularization +not to corrupt the outcome too much, the parameter $\lambda$ should be as small +as possible while still allowing a reliable inversion of $H_{\hat{\theta}} + \lambda \mathbb{I}$. ```python @@ -309,7 +306,7 @@ compute_influences( ) ``` -## Influence factors +### Influence factors The [compute_influences][pydvl.influence.general.compute_influences] method offers a fast way to obtain the influence scores given a model @@ -340,22 +337,21 @@ The result is an object of type which holds the calculated influence factors (`influence_factors.x`) and a dictionary with the info on the inversion process (`influence_factors.info`). -# Methods for inverse HVP calculation +## Methods for inverse HVP calculation In order to calculate influence values, pydvl implements several methods for the calculation of the inverse Hessian vector product (iHVP). More precisely, given a model, training data and a tensor $b$, the function [solve_hvp][pydvl.influence.inversion.solve_hvp] -will find $x$ such that $H x = b$, -with $H$ is the hessian of model. +will find $x$ such that $H x = b$, with $H$ is the hessian of model. -Many different inversion methods can be selected via the parameter +Many different inversion methods can be selected via the parameter `inversion_method` of [compute_influences][pydvl.influence.general.compute_influences]. The following subsections will offer more detailed explanations for each method. -## Direct inversion +### Direct inversion With `inversion_method = "direct"` pyDVL will calculate the inverse Hessian using the direct matrix inversion. This means that the Hessian will first be @@ -382,14 +378,13 @@ The first one is the inverse Hessian vector product, while the second one is a dictionary with the info on the inversion process. For this method, the info consists of the Hessian matrix itself. -## Conjugate Gradient +### Conjugate Gradient -A classical method for solving linear systems of equations is the conjugate -gradient method. It is an iterative method that does not require the explicit -inversion of the Hessian matrix. Instead, it only requires the calculation of -the Hessian vector product. This makes it a good choice for large datasets or -models with many parameters. It is Nevertheless much slower than the direct -inversion method and not as accurate. +This classical procedure for solving linear systems of equations is an iterative +method that does not require the explicit inversion of the Hessian. Instead, it +only requires the calculation of Hessian-vector products, making it a good +choice for large datasets or models with many parameters. It is nevertheless +much slower to converge than the direct inversion method and not as accurate. More info on the theory of conjugate gradient can be found on [Wikipedia](https://en.wikipedia.org/wiki/Conjugate_gradient_method). @@ -415,18 +410,18 @@ to the [solve_batch_cg][pydvl.influence.torch.torch_differentiable.solve_batch_c function, and are respecively the initial guess for the solution, the relative tolerance, the absolute tolerance, and the maximum number of iterations. -The resulting [InverseHvpResult][pydvl.influence.twice_differentiable.InverseHvpResult] -holds the solution of the iHVP, `influence_factors.x`, and some info on the -inversion process `influence_factors.info`. More specifically, for each batch -the infos will report the number of iterations, a boolean indicating if the -inversion converged, and the residual of the inversion. +The resulting +[InverseHvpResult][pydvl.influence.twice_differentiable.InverseHvpResult] holds +the solution of the iHVP, `influence_factors.x`, and some info on the inversion +process `influence_factors.info`. More specifically, for each batch this will +contain the number of iterations, a boolean indicating if the inversion +converged, and the residual of the inversion. -## Linear time Stochastic Second-Order Approximation (LiSSA) +### Linear time Stochastic Second-Order Approximation (LiSSA) The LiSSA method is a stochastic approximation of the inverse Hessian vector product. Compared to [conjugate gradient](#conjugate-gradient) -it is faster but less accurate and typically suffers from -instability. +it is faster but less accurate and typically suffers from instability. In order to find the solution of the HVP, LiSSA iteratively approximates the inverse of the Hessian matrix with the following update: @@ -467,20 +462,22 @@ holds the solution of the iHVP, `influence_factors.x`, and, within `influence_factors.info`, the maximum percentage error and the mean percentage error of the approximation. -## Arnoldi solver +### Arnoldi solver -The [Arnoldi method](https://en.wikipedia.org/wiki/Arnoldi_iteration) -is a Krylov subspace method for approximating dominating eigenvalues and eigenvectors. Under a low rank -assumption on the Hessian at a minimizer (which is typically observed for deep neural networks), this approximation -captures the essential action of the Hessian. More concrete, for $Hx=b$ the solution is approximated by +The [Arnoldi method](https://en.wikipedia.org/wiki/Arnoldi_iteration) is a +Krylov subspace method for approximating dominating eigenvalues and +eigenvectors. Under a low rank assumption on the Hessian at a minimizer (which +is typically observed for deep neural networks), this approximation captures the +essential action of the Hessian. More concretely, for $Hx=b$ the solution is +approximated by \[x \approx V D^{-1} V^T b\] -where \(D\) is a diagonal matrix with the top (in absolute value) eigenvalues of the Hessian -and \(V\) contains the corresponding eigenvectors, see also [@schioppa_scaling_2021]. - +where \(D\) is a diagonal matrix with the top (in absolute value) eigenvalues of +the Hessian and \(V\) contains the corresponding eigenvectors. See also +[@schioppa_scaling_2021]. -In pyDVL, you can select Arnoldi with `inversion_method = "arnoldi"`, like this: +In pyDVL, you can use Arnoldi with `inversion_method = "arnoldi"`, as follows: ```python from pydvl.influence.inversion import solve_hvp @@ -495,7 +492,10 @@ solve_hvp( eigen_computation_on_gpu=False ) ``` -For the parameters, check [solve_arnoldi][pydvl.influence.torch.torch_differentiable.solve_arnoldi]. -The resulting [InverseHvpResult][pydvl.influence.twice_differentiable.InverseHvpResult] -holds the solution of the iHVP, `influence_factors.x`, and, -within `influence_factors.info`, the computed eigenvalues and eigenvectors. + +For the parameters, check +[solve_arnoldi][pydvl.influence.torch.torch_differentiable.solve_arnoldi]. The +resulting +[InverseHvpResult][pydvl.influence.twice_differentiable.InverseHvpResult] holds +the solution of the iHVP, `influence_factors.x`, and, within +`influence_factors.info`, the computed eigenvalues and eigenvectors. From 252e2df7c7ed4f18dfcef51ac1a2f0f6c5252134 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 2 Sep 2023 18:05:54 +0200 Subject: [PATCH 435/436] More docs cleanup --- src/pydvl/influence/general.py | 2 +- .../influence/torch/torch_differentiable.py | 2 +- src/pydvl/utils/utility.py | 2 +- src/pydvl/value/result.py | 16 +++++++++----- src/pydvl/value/semivalues.py | 2 +- src/pydvl/value/shapley/common.py | 19 ++++++++-------- src/pydvl/value/shapley/gt.py | 2 +- src/pydvl/value/shapley/knn.py | 15 ++++++++----- src/pydvl/value/shapley/montecarlo.py | 22 +++++++++---------- src/pydvl/value/shapley/owen.py | 2 +- src/pydvl/value/shapley/truncated.py | 2 +- src/pydvl/value/stopping.py | 2 +- 12 files changed, 49 insertions(+), 39 deletions(-) diff --git a/src/pydvl/influence/general.py b/src/pydvl/influence/general.py index e1fc32493..a200b7f4e 100644 --- a/src/pydvl/influence/general.py +++ b/src/pydvl/influence/general.py @@ -2,7 +2,7 @@ This module contains influence calculation functions for general models, as introduced in (Koh and Liang, 2017)[^1]. -## References: +## References [^1]: Koh, P.W., Liang, P., 2017. [Understanding Black-box Predictions via Influence Functions](https://proceedings.mlr.press/v70/koh17a.html). diff --git a/src/pydvl/influence/torch/torch_differentiable.py b/src/pydvl/influence/torch/torch_differentiable.py index 023a125e9..bb1d444e4 100644 --- a/src/pydvl/influence/torch/torch_differentiable.py +++ b/src/pydvl/influence/torch/torch_differentiable.py @@ -4,7 +4,7 @@ methods to invert the Hessian vector product. These are used to calculate the influence of a training point on the model. -## References: +## References [^1]: Koh, P.W., Liang, P., 2017. [Understanding Black-box Predictions via Influence Functions](https://proceedings.mlr.press/v70/koh17a.html). diff --git a/src/pydvl/utils/utility.py b/src/pydvl/utils/utility.py index c35bec98e..096a31b82 100644 --- a/src/pydvl/utils/utility.py +++ b/src/pydvl/utils/utility.py @@ -15,7 +15,7 @@ This module also contains Utility classes for toy games that are used for testing and for demonstration purposes. -## References: +## References [^1]: Wang, T., Yang, Y. and Jia, R., 2021. [Improving cooperative game theory-based data valuation via data utility learning](https://arxiv.org/abs/2107.06336). diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index 1d12b218e..989d6d92e 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -207,7 +207,8 @@ class ValuationResult( extra_values: Additional values that can be passed as keyword arguments. This can contain, for example, the least core value. - :raise ValueError: If input arrays have mismatching lengths. + Raises: + ValueError: If input arrays have mismatching lengths. """ _indices: NDArray[IndexT] @@ -611,7 +612,8 @@ def update(self, idx: int, new_value: float) -> "ValuationResult": Returns: A reference to the same, modified result. - :raises IndexError: If the index is not found. + Raises: + IndexError: If the index is not found. """ try: pos = self._positions[idx] @@ -632,7 +634,9 @@ def update(self, idx: int, new_value: float) -> "ValuationResult": def get(self, idx: Integral) -> ValueItem: """Retrieves a ValueItem by data index, as opposed to sort index, like the indexing operator. - :raises IndexError: If the index is not found. + + Raises: + IndexError: If the index is not found. """ try: pos = self._positions[idx] @@ -662,7 +666,8 @@ def to_dataframe( A dataframe with two columns, one for the values, with name given as explained in `column`, and another with standard errors for approximate algorithms. The latter will be named `column+'_stderr'`. - :raise ImportError: If pandas is not installed + Raises: + ImportError: If pandas is not installed """ if not pandas: raise ImportError("Pandas required for DataFrame export") @@ -700,7 +705,8 @@ def from_random( A valuation result with its status set to [Status.Converged][pydvl.utils.status.Status] by default. - :raises ValueError: If `size` is less than 1. + Raises: + ValueError: If `size` is less than 1. !!! tip "Changed in version 0.6.0" Added parameter `total`. Check for zero size diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 5cec32d5c..488a25037 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -54,7 +54,7 @@ instead. -# References: +## References [^1]: Ghorbani, A., Zou, J., 2019. [Data Shapley: Equitable Valuation of Data for Machine Learning](http://proceedings.mlr.press/v97/ghorbani19c.html). diff --git a/src/pydvl/value/shapley/common.py b/src/pydvl/value/shapley/common.py index 97f4e2945..383ff589f 100644 --- a/src/pydvl/value/shapley/common.py +++ b/src/pydvl/value/shapley/common.py @@ -82,19 +82,20 @@ def compute_shapley_values( Args: u: [Utility][pydvl.utils.utility.Utility] object with model, data, and scoring function. - done: [StoppingCriterion][pydvl.value.stopping.StoppingCriterion] object, used to - determine when to stop the computation for Monte Carlo methods. The - default is to stop after 100 iterations. See the available criteria - in [stopping][pydvl.value.stopping]. It is possible to combine several - criteria using boolean operators. Some methods ignore this argument, - others require specific subtypes. + done: Object used to determine when to stop the computation for Monte + Carlo methods. The default is to stop after 100 iterations. See the + available criteria in [stopping][pydvl.value.stopping]. It is + possible to combine several of them using boolean operators. Some + methods ignore this argument, others require specific subtypes. n_jobs: Number of parallel jobs (available only to some methods) - seed: Either an instance of a numpy random number generator or a seed for it. + seed: Either an instance of a numpy random number generator or a seed + for it. mode: Choose which shapley algorithm to use. See - [ShapleyMode][pydvl.value.shapley.ShapleyMode] for a list of allowed value. + [ShapleyMode][pydvl.value.shapley.ShapleyMode] for a list of allowed + value. Returns: - A [ValuationResult][pydvl.value.result.ValuationResult] object with the results. + Object with the results. """ progress: bool = kwargs.pop("progress", False) diff --git a/src/pydvl/value/shapley/gt.py b/src/pydvl/value/shapley/gt.py index cc207129f..b78ac346c 100644 --- a/src/pydvl/value/shapley/gt.py +++ b/src/pydvl/value/shapley/gt.py @@ -14,7 +14,7 @@ !!! tip "New in version 0.4.0" -# References: +## References [^1]: Jia, R. et al., 2019. [Towards Efficient Data Valuation Based on the Shapley Value](http://proceedings.mlr.press/v89/jia19a.html). diff --git a/src/pydvl/value/shapley/knn.py b/src/pydvl/value/shapley/knn.py index f3e2970e5..5356ab946 100644 --- a/src/pydvl/value/shapley/knn.py +++ b/src/pydvl/value/shapley/knn.py @@ -2,14 +2,15 @@ This module contains Shapley computations for K-Nearest Neighbours. !!! Todo - Implement approximate KNN computation for sublinear complexity) + Implement approximate KNN computation for sublinear complexity -# References: +## References -[^Y]: Jia, R. et al., 2019. - [Efficient Task-Specific Data Valuation for Nearest Neighbor Algorithms](https://doi.org/10.14778/3342263.3342637). - In: Proceedings of the VLDB Endowment, Vol. 12, No. 11, pp. 1610–1623. +[^1]: Jia, R. et al., 2019. [Efficient + Task-Specific Data Valuation for Nearest Neighbor + Algorithms](https://doi.org/10.14778/3342263.3342637). In: Proceedings of + the VLDB Endowment, Vol. 12, No. 11, pp. 1610–1623. """ @@ -43,7 +44,9 @@ def knn_shapley(u: Utility, *, progress: bool = True) -> ValuationResult: Returns: Object with the data values. - :raises TypeError: If the model in the utility is not a [KNeighborsClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html) + Raises: + TypeError: If the model in the utility is not a + [sklearn.neighbors.KNeighborsClassifier][]. !!! tip "New in version 0.1.0" diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index 06c4e023f..e9aba420b 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -21,19 +21,19 @@ [truncated_montecarlo_shapley()][pydvl.value.shapley.truncated.truncated_montecarlo_shapley]. !!! info "Also see" - It is also possible to use [group_testing_shapley()][pydvl.value.shapley.gt.group_testing_shapley] - to reduce the number of evaluations of the utility. The method is however - typically outperformed by others in this module. + It is also possible to use [group_testing_shapley()][pydvl.value.shapley.gt.group_testing_shapley] + to reduce the number of evaluations of the utility. The method is however + typically outperformed by others in this module. !!! info "Also see" - Additionally, you can consider grouping your data points using - [GroupedDataset][pydvl.utils.dataset.GroupedDataset] and computing the values of the - groups instead. This is not to be confused with "group testing" as - implemented in [group_testing_shapley()][pydvl.value.shapley.gt.group_testing_shapley]: any of - the algorithms mentioned above, including Group Testing, can work to valuate - groups of samples as units. - -# References: + Additionally, you can consider grouping your data points using + [GroupedDataset][pydvl.utils.dataset.GroupedDataset] and computing the values + of the groups instead. This is not to be confused with "group testing" as + implemented in [group_testing_shapley()][pydvl.value.shapley.gt.group_testing_shapley]: any of + the algorithms mentioned above, including Group Testing, can work to valuate + groups of samples as units. + +## References [^1]: Ghorbani, A., Zou, J., 2019. [Data Shapley: Equitable Valuation of Data for Machine Learning](http://proceedings.mlr.press/v97/ghorbani19c.html). diff --git a/src/pydvl/value/shapley/owen.py b/src/pydvl/value/shapley/owen.py index a19682ef3..69b5dda89 100644 --- a/src/pydvl/value/shapley/owen.py +++ b/src/pydvl/value/shapley/owen.py @@ -1,5 +1,5 @@ """ -# References: +## References [^1]: Okhrati, R., Lipani, A., 2021. [A Multilinear Sampling Algorithm to Estimate Shapley Values](https://ieeexplore.ieee.org/abstract/document/9412511). diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index a49c58bf0..9efe87480 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -1,5 +1,5 @@ """ -# References: +## References [^1]: Ghorbani, A., Zou, J., 2019. [Data Shapley: Equitable Valuation of Data for Machine Learning](http://proceedings.mlr.press/v97/ghorbani19c.html). diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index 7ddaf1722..57484a81b 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -31,7 +31,7 @@ [StoppingCriterion][pydvl.value.stopping.StoppingCriterion] for details on how these operations affect the behavior of the stopping criteria. -# References: +## References [^1]: Ghorbani, A., Zou, J., 2019. [Data Shapley: Equitable Valuation of Data for Machine Learning](http://proceedings.mlr.press/v97/ghorbani19c.html). From 058c892e098cd6793321d0192929cf4d75ca4962 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sat, 2 Sep 2023 18:17:35 +0200 Subject: [PATCH 436/436] =?UTF-8?q?Bump=20version:=200.6.2.dev0=20?= =?UTF-8?q?=E2=86=92=200.7.0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .bumpversion.cfg | 2 +- setup.py | 2 +- src/pydvl/__init__.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.bumpversion.cfg b/.bumpversion.cfg index 033a1a3bc..994fd8761 100644 --- a/.bumpversion.cfg +++ b/.bumpversion.cfg @@ -1,5 +1,5 @@ [bumpversion] -current_version = 0.6.2.dev0 +current_version = 0.7.0 commit = False tag = False allow_dirty = False diff --git a/setup.py b/setup.py index 51ceb808b..ac71c80f4 100644 --- a/setup.py +++ b/setup.py @@ -12,7 +12,7 @@ package_data={"pydvl": ["py.typed"]}, packages=find_packages(where="src"), include_package_data=True, - version="0.6.2.dev0", + version="0.7.0", description="The Python Data Valuation Library", install_requires=[ line diff --git a/src/pydvl/__init__.py b/src/pydvl/__init__.py index 2036aa45b..3b96cbea6 100644 --- a/src/pydvl/__init__.py +++ b/src/pydvl/__init__.py @@ -7,4 +7,4 @@ The two main modules you will want to look at are [value][pydvl.value] and [influence][pydvl.influence]. """ -__version__ = "0.6.2.dev0" +__version__ = "0.7.0"