diff --git a/images/regression_ensemble.png b/images/regression_ensemble.png new file mode 100644 index 0000000..8ce1939 Binary files /dev/null and b/images/regression_ensemble.png differ diff --git a/images/triangular_simplex.png b/images/triangular_simplex.png new file mode 100644 index 0000000..76a635e Binary files /dev/null and b/images/triangular_simplex.png differ diff --git a/src/data/__pycache__/toy_loading.cpython-37.pyc b/src/data/__pycache__/toy_loading.cpython-37.pyc new file mode 100644 index 0000000..7079e1b Binary files /dev/null and b/src/data/__pycache__/toy_loading.cpython-37.pyc differ diff --git a/src/data/toy_loading.py b/src/data/toy_loading.py new file mode 100644 index 0000000..fb88502 --- /dev/null +++ b/src/data/toy_loading.py @@ -0,0 +1,136 @@ +import pandas as pd +import numpy as np +import torch +from torch.utils import data as tdata + + +def get_toy_dataset( + target_generator_fn, + noise_generator_fn, + train_limits=(-1.0, 1.0), + test_limits=(-1.5, 1.5), ood_abs_limits=(1.1, 1.3), + train_samples=100, test_samples=200, + ood_samples=40, random_state=0 +): + """Generates one-dimensional regression dataset""" + np.random.seed(random_state) + x_train = np.random.uniform(train_limits[0], train_limits[1], (train_samples,)) + + y_train = target_generator_fn(x_train) + np.random.seed(random_state) + y_noise = noise_generator_fn(x_train) * np.random.randn(y_train.shape[0]) + y_train += y_noise + + np.random.seed(random_state) + x_ood_1 = np.random.uniform(ood_abs_limits[0], ood_abs_limits[1], (ood_samples // 2,)) + np.random.seed(random_state) + x_ood_2 = np.random.uniform(-ood_abs_limits[1], -ood_abs_limits[0], (ood_samples // 2,)) + x_ood = np.concatenate([x_ood_1, x_ood_2], axis=0) + + y_ood = target_generator_fn(x_ood) + np.random.seed(random_state) + y_ood += noise_generator_fn(x_ood) * np.random.randn(y_ood.shape[0]) + + x_test = np.linspace(test_limits[0], test_limits[1], test_samples) + y_test = target_generator_fn(x_test) + + train_data, test_data, ood_data = [ + tdata.TensorDataset( + torch.Tensor(x_c).unsqueeze(1), + torch.Tensor(y_c).unsqueeze(1) + ) for (x_c, y_c) in zip( + [x_train, x_test, x_ood], [y_train, y_test, y_ood] + ) + ] + return train_data, test_data, ood_data, y_noise + +def get_arrays_from_loader(loader): + first_elems = [] + second_elems = [] + for item in loader: + first_elems += [item[0]] + second_elems += [item[1]] + return torch.cat(first_elems, dim=0), torch.cat(second_elems, dim=0) + +def get_table_loaders( + train_data, test_data, batch_size, ood_data=None, ood_test_data=None, + ood_batch_size=None, shuffle=True, normalize_targets=False, target_id=-1, +): + feature_len = train_data.shape[1] - 1 + if target_id == -1: + x_train, y_train = train_data[:, :-1], train_data[:, -1:] + x_test, y_test = test_data[:, :-1], test_data[:, -1:] + elif target_id > -1: + idxs = list(range(train_data.shape[1])) + idxs.pop(target_id) + x_train, y_train = train_data[:, idxs],\ + train_data[:, target_id].reshape(-1,1) + x_test, y_test = test_data[:, idxs],\ + test_data[:, target_id].reshape(-1,1) + else: + raise ValueError("Provide target_id >= -1") + + # Normalize train/test features & targets (if necessary) + x_means, x_stds = x_train.mean(axis=0), x_train.std(axis=0) + if normalize_targets: + y_means, y_stds = y_train.mean(axis=0), y_train.std(axis=0) + else: + y_means, y_stds = 0., 1. + x_train = (x_train - x_means) / x_stds + y_train = (y_train - y_means) / y_stds + x_test = (x_test - x_means) / x_stds + y_test = (y_test - y_means) / y_stds + # Normalize ood features + if ood_data is not None: + if target_id > -1: + idxs = list(range(train_data.shape[1])) + idxs.pop(target_id) + x_ood = ood_data[:, idxs] + x_ood = (x_ood - x_means) / x_stds + else: + x_ood = ood_data[:, :feature_len] + x_ood = (x_ood - x_means) / x_stds + assert not np.isnan(x_ood).any() + if ood_test_data is not None: + if target_id > -1: + idxs = list(range(train_data.shape[1])) + idxs.pop(target_id) + x_ood_test = ood_test_data[:, idxs] + x_ood_test = (x_ood_test - x_means) / x_stds + else: + x_ood_test = ood_test_data[:, :feature_len] + x_ood_test = (x_ood_test - x_means) / x_stds + assert not np.isnan(x_ood_test).any() + + assert not np.isnan(y_test).any() + assert not np.isnan(y_train).any() + assert not np.isnan(x_test).any() + assert not np.isnan(x_train).any() + ood_loader = None + ood_test_loader = None + # Initialize loaders + train_loader = tdata.DataLoader( + tdata.TensorDataset( + torch.Tensor(x_train), torch.Tensor(y_train) + ), + batch_size=batch_size, + shuffle=shuffle + ) + test_loader = tdata.DataLoader( + tdata.TensorDataset( + torch.Tensor(x_test), torch.Tensor(y_test) + ), + batch_size=batch_size, shuffle=False + ) + if ood_data is not None: + ood_loader = tdata.DataLoader( + tdata.TensorDataset(torch.Tensor(x_ood)), + batch_size=ood_batch_size, shuffle=shuffle + ) + if ood_test_data is not None: + ood_test_loader = tdata.DataLoader( + tdata.TensorDataset(torch.Tensor(x_ood_test)), + batch_size=ood_batch_size, shuffle=False + ) + return train_loader, test_loader, ood_loader, ood_test_loader,\ + [torch.FloatTensor([y_means]), torch.FloatTensor([y_stds])] diff --git a/src/distributions/__pycache__/distributions.cpython-37.pyc b/src/distributions/__pycache__/distributions.cpython-37.pyc new file mode 100644 index 0000000..a437025 Binary files /dev/null and b/src/distributions/__pycache__/distributions.cpython-37.pyc differ diff --git a/src/distributions/__pycache__/mixture_distribution.cpython-37.pyc b/src/distributions/__pycache__/mixture_distribution.cpython-37.pyc new file mode 100644 index 0000000..433e137 Binary files /dev/null and b/src/distributions/__pycache__/mixture_distribution.cpython-37.pyc differ diff --git a/src/distributions/__pycache__/prior_distribution.cpython-37.pyc b/src/distributions/__pycache__/prior_distribution.cpython-37.pyc new file mode 100644 index 0000000..8272e92 Binary files /dev/null and b/src/distributions/__pycache__/prior_distribution.cpython-37.pyc differ diff --git a/src/distributions/distributions.py b/src/distributions/distributions.py new file mode 100644 index 0000000..3a7f366 --- /dev/null +++ b/src/distributions/distributions.py @@ -0,0 +1,270 @@ +import math +import torch + +from torch.distributions import constraints, Distribution, Normal +from torch.distributions import register_kl +from torch.distributions.kl import kl_divergence +from torch.distributions.independent import Independent + +from src.utils.func_utils import mvdigamma, rel_error + + +class DiagonalWishart(Distribution): + r""" + Creates a diagonal version of Wishart distribution parameterized + by its scale :attr:`scale_diag` and degrees of freedom :attr:`df`. + + Args: + scale_diag (Tensor) (or L): scale of the distribution with shapes (bs, ..., p), + where p is the dimensionality of a distribution. + df (Tensor) (or \nu): degrees of freedom with shapes (bs, ...). It should have + the same shape as :attr:`scale_diag`, but without last dim. + """ + arg_constraints = {'scale_diag': constraints.positive, 'df': constraints.positive} + support = constraints.positive + has_rsample = False + + def __init__(self, scale_diag, df, validate_args=True): + if scale_diag.dim() < 1 or df.dim() < 1: + raise ValueError("scale_diag or df must be at least one-dimensional.") + if df.size(-1) == 1 and scale_diag.size(-1) != 1: + raise ValueError("df shouldn't end with dimensionality 1 if scale_diag doesn't") + df_ = df.unsqueeze(-1) # add dim on right + self.scale_diag, df_ = torch.broadcast_tensors(scale_diag, df_) + self.df = df_[..., 0] # drop rightmost dim + + batch_shape, event_shape = self.scale_diag.shape[:-1], self.scale_diag.shape[-1:] + self.dimensionality = event_shape.numel() + if (self.df <= (self.dimensionality - 1)).any(): + raise ValueError("df must be greater than dimensionality - 1") + super(DiagonalWishart, self).__init__(batch_shape, event_shape, validate_args=validate_args) + + @property + def mean(self): + return self.df.unsqueeze(-1) * self.scale_diag + + @property + def variance(self): + return 2 * self.df.unsqueeze(-1) * self.scale_diag.pow(2) + + def log_prob(self, value): + if self._validate_args: + self._validate_sample(value) + + tr_term = -0.5 * torch.div(value, self.scale_diag).sum(dim=-1) + norm_term = 0.5 * (self.df - self.dimensionality - 1) * torch.log(value).sum(dim=-1) + + return -self.log_normalizer() + norm_term + tr_term + + def log_normalizer(self): + log_normalizer_1 = 0.5 * self.df * self.dimensionality * math.log(2) + log_normalizer_2 = 0.5 * self.df * self.scale_diag.log().sum(dim=-1) + log_normalizer_3 = torch.mvlgamma(0.5 * self.df, self.dimensionality) + return log_normalizer_1 + log_normalizer_2 + log_normalizer_3 + + def log_expectation(self): + mvdigamma_term = mvdigamma(0.5 * self.df, self.dimensionality) + other_terms = self.dimensionality * math.log(2) + torch.log(self.scale_diag).sum(dim=-1) + return mvdigamma_term + other_terms + + def entropy(self): + return self.log_normalizer() - 0.5 * (self.df - self.dimensionality - 1) * self.log_expectation()\ + + 0.5 * self.df * self.dimensionality + + +class NormalDiagonalWishart(Distribution): + r""" + Creates a diagonal version of Normal-Wishart distribution parameterized + by its mean :attr:`mean`, diagonal precision :attr:`precision_diag`, + degrees of freedom :attr:`df` and belief in mean :attr:`belief` + + Args: + loc (Tensor) (or m): location of the distribution with shapes (bs, ..., p), + where p is dimensionality of the distribution. + precision_diag (Tensor or float) (or L): precision of the distribution with shapes (bs, ..., p), + where p is dimensionality of the distribution. It should have the same shape + as :attr:`mean`. + belief (Tensor or float) (or \kappa): confidence of belief in mean with shapes (bs, ...). + It should have the same shape as :attr:`mean`, but without last dim. + df (Tensor or float) (or \nu): degrees of freedom with shapes (bs, ...). It should have + the same shape as :attr:`mean`, but without last dim. + """ + arg_constraints = { + 'precision_diag': constraints.positive, + 'belief': constraints.positive, + 'df': constraints.positive, + } + support = constraints.real + has_rsample = False + + def __init__(self, loc, precision_diag, belief, df, validate_args=True): + precision_diag, belief, df = self.convert_float_params_to_tensor( + loc, precision_diag, belief, df + ) + if loc.dim() < 1 or precision_diag.dim() < 1 or df.dim() < 1 or belief.dim() < 1: + raise ValueError("loc, precision_diag, df, belief must be at least one-dimensional.") + if belief.size(-1) == 1 and precision_diag.size(-1) != 1: + raise ValueError("belief shouldn't end with dimensionality 1 if precision_diag doesn't") + if df.size(-1) == 1 and precision_diag.size(-1) != 1: + raise ValueError("df shouldn't end with dimensionality 1 if precision_diag doesn't") + df_, belief_ = df.unsqueeze(-1), belief.unsqueeze(-1) # add dim on right + self.loc, self.precision_diag, df_, belief_ = torch.broadcast_tensors(loc, precision_diag, df_, belief_) + self.df, self.belief = df_[..., 0], belief_[..., 0] # drop rightmost dim + + batch_shape, event_shape = self.loc.shape[:-1], self.loc.shape[-1:] + self.dimensionality = event_shape.numel() + if (self.df <= (self.dimensionality + 1)).any(): + raise ValueError("df must be greater than dimensionality + 1 to have expectation") + super(NormalDiagonalWishart, self).__init__( + batch_shape, event_shape, validate_args=validate_args + ) + + def log_prob(self, value_mean, value_precision): + if self._validate_args: + self._validate_sample(value_mean) + self._validate_sample(value_precision) + if (value_precision <= 0).any(): + raise ValueError("desired precision must be greater that 0") + wishart_log_prob = DiagonalWishart( + self.precision_diag, self.df + ).log_prob(value_precision) + normal_log_prob = Independent( + Normal( + self.loc, ( + 1 / (self.belief.unsqueeze(-1) * value_precision) + ).pow(0.5) + ), 1 + ).log_prob(value_mean) + return normal_log_prob + wishart_log_prob + + def expectation_entropy_normal(self): + return 0.5 * ( + self.dimensionality * ( + 1 + math.log(2 * math.pi) + ) - torch.log( + 2 * self.precision_diag * self.belief.unsqueeze(-1) + ).sum(dim=-1) + - mvdigamma(0.5 * self.df, self.dimensionality) + ) + + def entropy(self): + wishart_entropy = DiagonalWishart(self.precision_diag, self.df).entropy() + expectation_entropy_normal = self.expectation_entropy_normal() + return wishart_entropy + expectation_entropy_normal + + def convert_float_params_to_tensor(self, loc, precision_diag, belief, df): + if isinstance(precision_diag, float): + precision_diag = precision_diag * torch.ones_like(loc).to(loc.device) + if isinstance(belief, float): + belief = belief * torch.ones_like(loc).to(loc.device)[..., 0] + if isinstance(df, float): + df = df * torch.ones_like(loc).to(loc.device)[..., 0] + return precision_diag, belief, df + + +@register_kl(DiagonalWishart,DiagonalWishart) +def kl_diag_wishart(p: DiagonalWishart, q: DiagonalWishart): + if p.event_shape != q.event_shape: + raise ValueError("KL-divergence between two Diagonal Wisharts with\ + different event shapes cannot be computed") + log_det_term = -(0.5 * q.df) * torch.div( + p.scale_diag, q.scale_diag + ).log().sum(dim=-1) + tr_term = (0.5 * p.df) * ( + torch.div(p.scale_diag, q.scale_diag).sum(dim=-1) - p.dimensionality + ) + mvlgamma_term = torch.mvlgamma(0.5 * q.df, q.dimensionality) - torch.mvlgamma(0.5 * p.df, p.dimensionality) + digamma_term = 0.5 * (p.df - q.df) * mvdigamma(0.5 * p.df, p.dimensionality) + return log_det_term + tr_term + mvlgamma_term + digamma_term + + +@register_kl(NormalDiagonalWishart, NormalDiagonalWishart) +def kl_normal_diag_wishart(p: NormalDiagonalWishart, q: NormalDiagonalWishart): + if p.event_shape != q.event_shape: + raise ValueError("KL-divergence between two Normal Diagonal Wisharts with\ + different event shapes cannot be computed") + + wishart_KL = kl_divergence( + DiagonalWishart(p.precision_diag, p.df), + DiagonalWishart(q.precision_diag, q.df) + ) + weighted_mse_term = torch.sum( + 0.5 * q.belief.unsqueeze(-1) *\ + (p.loc - q.loc).pow(2) * p.precision_diag * p.df.unsqueeze(-1), + dim=-1 + ) + expected_conditioned_normal_KL = ( + weighted_mse_term + (0.5 * p.dimensionality) * ( + torch.div(q.belief, p.belief) - torch.div(q.belief, p.belief).log() - 1 + ) + ) + + return expected_conditioned_normal_KL + wishart_KL + + +if __name__ == '__main__': + import numpy as np + from scipy.stats import wishart + x = np.linspace(1e-6, 20, 100) + + print("Testing wishart entropy/logprob vs scipy implementation...") + for k in range(1000): + df_val = torch.randn(1).exp() + 2 + scale_val = torch.randn(1).exp() + + scipy_dist = wishart(df=df_val.item(), scale=scale_val.item()) + torch_dist = DiagonalWishart( + scale_val.unsqueeze(-1), + df_val + ) + + torch_ent = torch_dist.entropy()[0] + scipy_ent = torch.FloatTensor([scipy_dist.entropy()]) + if (rel_error(torch_ent, scipy_ent) > 1e-3).any(): + raise ValueError("Entropies of torch and scipy versions doesn't match") + + scipy_w = torch.FloatTensor(scipy_dist.logpdf(x)) + torch_w = torch_dist.log_prob(torch.FloatTensor(x).unsqueeze(-1)) + + if (rel_error(torch_w, scipy_w) > 1e-6).any(): + raise ValueError("Log pdf of torch and scipy versions doesn't match") + + print("Testing wishart KL divergence...") + df1, scale1 = torch.randn(32).exp() + 2, torch.randn(32).exp() + 1e-5 + df2, scale2 = torch.randn(32).exp() + 2, torch.randn(32).exp() + 1e-5 + init_df1, init_scale1 = df1[0].clone(), scale1[0].clone() + dist2 = DiagonalWishart(scale2.unsqueeze(-1), df2) + df1.requires_grad, scale1.requires_grad = True, True + gamma = 0.1 + for k in range(10000): + dist1 = DiagonalWishart(scale1.unsqueeze(-1), df1) + loss = kl_divergence(dist1, dist2).mean() + if k % 1000 == 0: + print(k, loss.item()) + loss.backward() + with torch.no_grad(): + scale1 = scale1 - gamma * scale1.grad + df1 = df1 - gamma * df1.grad + scale1.requires_grad, df1.requires_grad = True, True + print('df1 init', init_df1, init_scale1) + print('df1 final', df1[0], scale1[0]) + print('df2', df2[0], scale2[0]) + + print("All tests passed.") + + print("Testing normal wishart...") + y = np.linspace(5, 20, 100) + torch_dist = NormalDiagonalWishart( + torch.tensor([10]).float().view(1, 1).repeat(100, 1), + torch.tensor([2.57]).float().view(1, 1).repeat(100, 1), + torch.tensor([0.7]).float().repeat(100), + torch.tensor([3.33]).float().repeat(100), + ) + + ex_w = torch_dist.log_prob( + torch.FloatTensor(x).unsqueeze(-1), + torch.FloatTensor(y).unsqueeze(-1) + ) + print(ex_w.shape) + ex_w = torch_dist.entropy()[0] + #print(ex_w) diff --git a/src/distributions/mixture_distribution.py b/src/distributions/mixture_distribution.py new file mode 100644 index 0000000..67efe71 --- /dev/null +++ b/src/distributions/mixture_distribution.py @@ -0,0 +1,78 @@ +import torch +from itertools import combinations +from torch.distributions import Distribution, Normal, kl_divergence + + +class GaussianDiagonalMixture(Distribution): + r""" + Creates a mixture of diagonal Normal distributions parameterized + by their means :attr:`means` and scales :attr:`scales`. + """ + def __init__(self, means, scales): + assert len(means) == len(scales) + assert means[0].size(-1) == 1 and scales[0].size(-1) == 1 + + self.distributions = [] + for i in range(len(means)): + self.distributions.append( + Normal(means[i], scales[i], validate_args=True) + ) + + def expected_mean(self): + return sum([dist.mean for dist in self.distributions]) / len(self.distributions) + + def expected_entropy(self): + return sum([dist.entropy().squeeze() for dist in self.distributions]) / len(self.distributions) + + def expected_pairwise_kl(self): + curr_sum_pairwise_kl = None + num_pairs = 0 + + for dist1, dist2 in combinations(self.distributions, r=2): + num_pairs += 1 + if curr_sum_pairwise_kl is None: + curr_sum_pairwise_kl = kl_divergence(dist1, dist2) + else: + curr_sum_pairwise_kl += kl_divergence(dist1, dist2) + return curr_sum_pairwise_kl.squeeze() / num_pairs + + def variance_of_expected(self): + avg_mean = self.expected_mean() + return sum([(dist.mean.pow(2) - avg_mean.pow(2)).squeeze() for dist in self.distributions]) / len(self.distributions) + + def log_variance_of_expected(self): + return self.variance_of_expected().log() + + def expected_variance(self): + return sum([dist.variance.squeeze() for dist in self.distributions]) / len(self.distributions) + + def log_expected_variance(self): + return self.expected_variance().log() + + def total_variance(self): + return self.variance_of_expected() + self.expected_variance() + + def log_total_variance(self): + return self.total_variance().log() + + def estimated_total_entropy(self): + return self.expected_entropy() + self.expected_pairwise_kl() + + def log_prob(self, value): + mean = self.expected_mean() + var = self.total_variance().unsqueeze(-1) + return Normal(mean, var.pow(0.5)).log_prob(value) + + +if __name__ == "__main__": + ex_means = [torch.ones(32, 1) for _ in range(5)] + ex_vars = [2 * torch.ones(32, 1) for _ in range(5)] + mixture_dis = GaussianDiagonalMixture(ex_means, ex_vars) + print(mixture_dis.expected_mean().shape) + print(mixture_dis.log_prob(torch.zeros(32, 1)).shape) + + print(mixture_dis.expected_entropy().shape) + print(mixture_dis.expected_pairwise_kl().shape) + print(mixture_dis.variance_of_expected().shape) + print(mixture_dis.expected_variance().shape) + print(mixture_dis.total_variance().shape) diff --git a/src/distributions/prior_distribution.py b/src/distributions/prior_distribution.py new file mode 100644 index 0000000..1344aee --- /dev/null +++ b/src/distributions/prior_distribution.py @@ -0,0 +1,122 @@ +import math, torch + +from torch.distributions import StudentT +from .distributions import NormalDiagonalWishart +from src.utils.func_utils import mvdigamma + + +class NormalWishartPrior(NormalDiagonalWishart): + + def forward(self): + self.precision_coeff = (self.belief + 1) / ( + self.belief * (self.df - self.dimensionality + 1) + ) + return StudentT( + (self.df - self.dimensionality + 1).unsqueeze(-1), + loc=self.loc, + scale=(self.precision_coeff.unsqueeze(-1) / self.precision_diag).pow(0.5), + ) + + def predictive_posterior_log_prob(self, value): + return self.forward().log_prob(value) + + def predictive_posterior_variance(self): + variance_res = self.forward().variance + if variance_res.size(-1) != 1: + raise ValueError("Predictive posterior returned entropy with incorrect shapes") + return variance_res[..., 0] + + def log_predictive_posterior_variance(self): + return self.predictive_posterior_variance().log() + + def predictive_posterior_entropy(self): + entropy_res = self.forward().entropy() + if entropy_res.size(-1) != 1: + raise ValueError("Predictive posterior returned entropy with incorrect shapes") + return entropy_res[..., 0] + + def entropy_ub(self): + return self.expected_pairwise_kl() + self.expected_entropy() + + def expected_entropy(self): + mvdigamma_term = mvdigamma(0.5 * self.df, self.dimensionality) + return 0.5 * ( + self.dimensionality * (1 + math.log(2 * math.pi)) + - (2 * self.precision_diag).log().sum(dim=-1) + - mvdigamma_term.squeeze() + ) + + def expected_log_prob(self, value): + neg_mse_term = -torch.sum( + (self.loc - value).pow(2) * self.precision_diag * self.df.unsqueeze(-1), + dim = -1 + ) + mvdigamma_term = mvdigamma(0.5 * self.df, self.dimensionality) + + reg_terms = (2 * self.precision_diag).log().sum(dim=-1) + mvdigamma_term + conf_term = -self.dimensionality * self.belief.pow(-1) + return 0.5 * (neg_mse_term + reg_terms + conf_term) + + def mutual_information(self): + predictive_posterior_entropy = self.predictive_posterior_entropy() + expected_entropy = self.expected_entropy() + return predictive_posterior_entropy - expected_entropy + + def expected_pairwise_kl(self): + term1 = 0.5 * ( + self.df * self.dimensionality / (self.df - self.dimensionality - 1) -\ + self.dimensionality + ) + term2 = 0.5 * ( + self.df * self.dimensionality / (self.df - self.dimensionality - 1) +\ + self.dimensionality + ) / self.belief + return term1 + term2 + + def variance_of_expected(self): + return self.expected_variance() / self.belief + + def log_variance_of_expected(self): + return self.variance_of_expected().log() + + def expected_variance(self): + result = 1 / (self.precision_diag * (self.df.unsqueeze(-1) - self.dimensionality - 1)) + if result.size(-1) != 1: + raise ValueError("Expected variance currently supports only one-dimensional targets") + + return result[..., 0] + + def log_expected_variance(self): + return self.expected_variance().log() + + def total_variance(self): + tv = self.variance_of_expected() + self.expected_variance() + ppv = self.predictive_posterior_variance() + + rel_diff = (tv - ppv).abs() / tv.abs().pow(0.5) / ppv.abs().pow(0.5) + assert (rel_diff < 1e-6).all() + return tv + + def log_total_variance(self): + return self.total_variance().log() + + +if __name__ == '__main__': + ex_mean = torch.zeros(32, 200, 400, 1) + ex_var = torch.ones(32, 200, 400, 1) + ex_belief = torch.ones(32, 200, 400) + ex_df = 10 * torch.ones(32, 200, 400) + + ex_dist = NormalWishartPrior(ex_mean, ex_var, ex_belief, ex_df) + print(ex_dist.predictive_posterior_log_prob(2 * torch.ones(32, 200, 400, 1)).shape) + print(ex_dist.log_prob(2 * torch.ones(32, 200, 400, 1), 2 * torch.ones(32, 200, 400, 1)).shape) + + print(ex_dist.predictive_posterior_entropy().shape) #Total + print(ex_dist.expected_entropy().shape) #Data + print(ex_dist.mutual_information().shape) #Knowledge + print(ex_dist.expected_pairwise_kl().shape) #Knowledge + print(ex_dist.variance_of_expected().shape) #Knowledge + print(ex_dist.expected_variance().shape) #Data + print(ex_dist.total_variance().shape) #Total + print(ex_dist.predictive_posterior_variance().shape) #Total + diff --git a/src/models/__pycache__/simple_model.cpython-37.pyc b/src/models/__pycache__/simple_model.cpython-37.pyc new file mode 100644 index 0000000..aed213d Binary files /dev/null and b/src/models/__pycache__/simple_model.cpython-37.pyc differ diff --git a/src/models/simple_model.py b/src/models/simple_model.py new file mode 100644 index 0000000..6ccb508 --- /dev/null +++ b/src/models/simple_model.py @@ -0,0 +1,81 @@ +import torch +import torch.nn as nn + + +class GaussianNoise(nn.Module): + def __init__(self, mean=0.0, sigma=0.05): + super(GaussianNoise, self).__init__() + self.mean = mean + self.sigma = sigma + + def forward(self, input): + if not self.training: + return input + noise = input.clone().normal_(self.mean, self.sigma) + return input + noise + + +class SimpleModel(nn.Module): + def __init__( + self, input_dim, output_dim, num_units, + num_hidden=1, activation=nn.ReLU, isPrior=False, + drop_rate=0.0, use_bn=False, noise_level=0.05 + ): + super(SimpleModel, self).__init__() + + self.input_dim = input_dim + self.output_dim = output_dim + self.num_hidden = num_hidden + self.isPrior = isPrior + self.use_bn = use_bn + + # dense network with %num_units hidden layers + self.features, curr_dim = [], input_dim + self.features.append(GaussianNoise(sigma=noise_level)) + for _ in range(num_hidden): + self.features.append(nn.Linear(curr_dim, num_units)) + if self.use_bn: + self.features.append(nn.BatchNorm1d(num_units)) + self.features.append(activation()) + if drop_rate > 0.0: + self.features.append(nn.Dropout(drop_rate)) + curr_dim = num_units + self.features = nn.Sequential(*self.features) + + # generate stats of output distribution + self.layer_mean = nn.Linear(num_units, output_dim) + self.layer_std = nn.Sequential( + nn.Linear(num_units, output_dim), + nn.Softplus() + ) + if isPrior: + self.layer_beta = nn.Sequential( + nn.Linear(num_units, 1), + nn.Softplus() + ) + + self._initialize_weights() + + def forward(self, x): + x = x.view(-1, self.input_dim) + x = self.features(x) + + mean = self.layer_mean(x) + std = self.layer_std(x) + 1e-6 + if self.isPrior: + beta = self.layer_beta(x) + 1e-6 + kappa = beta + nu = beta + self.output_dim + 1 + return mean, std, kappa[..., 0], nu[..., 0] + else: + return mean, std + + def _initialize_weights(self): + """Initialize weights as in + `Probabilistic Backpropagation for Scalable Learning of Bayesian Neural Networks` + (https://arxiv.org/pdf/1502.05336.pdf), section 3.5 + """ + for m in self.modules(): + if isinstance(m, nn.Linear): + nn.init.normal_(m.weight, 0, 1.0 / (m.weight.size(1) + 1)) + nn.init.constant_(m.bias, 0) diff --git a/src/training/__pycache__/ood_trainers.cpython-37.pyc b/src/training/__pycache__/ood_trainers.cpython-37.pyc new file mode 100644 index 0000000..f589172 Binary files /dev/null and b/src/training/__pycache__/ood_trainers.cpython-37.pyc differ diff --git a/src/training/__pycache__/trainers.cpython-37.pyc b/src/training/__pycache__/trainers.cpython-37.pyc new file mode 100644 index 0000000..1bca611 Binary files /dev/null and b/src/training/__pycache__/trainers.cpython-37.pyc differ diff --git a/src/training/ood_trainers.py b/src/training/ood_trainers.py new file mode 100644 index 0000000..7c9300d --- /dev/null +++ b/src/training/ood_trainers.py @@ -0,0 +1,292 @@ +from typing import Tuple +from itertools import cycle + +import torch +from torch.distributions import Distribution +import torch.nn as nn +from torch.optim import Adam + +from src.training.trainers import DistributionRKLTrainer +from src.utils.func_utils import reduce_tensor, params_rmse + + +class DistributionRKLTrainerWithOOD(DistributionRKLTrainer): + @property + def uncertainty_methods(self): + return [ + 'predictive_posterior_entropy', 'expected_entropy', + 'mutual_information', 'expected_pairwise_kl', + 'variance_of_expected', 'expected_variance', + 'total_variance' + ] + + def train_step(self, x, y, x_ood): + self.optimizer.zero_grad() + + predicted_params = self.model(x) + prior_params = self.prior_converter(x) + + ordinary_loss = self.loss_function( + predicted_params, + prior_params, + y + ) + + self.switch_bn_updates("eval") + predicted_ood_params = self.model(x_ood) + prior_params = self.prior_converter(x_ood) + + ood_loss = self.loss_function( + predicted_ood_params, + prior_params + ) + self.switch_bn_updates("train") + loss = ordinary_loss + self.loss_params["ood_coeff"] * ood_loss + loss.backward() + torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0) + self.optimizer.step() + return ordinary_loss.item(), self.loss_params["ood_coeff"] * ood_loss.item() + + def loss_function(self, predicted_params, prior_params, targets=None): + if targets is None: + return self.loss_params["inv_real_beta"] * self.rkl_loss( + predicted_params, prior_params, reduction='mean' + ) + else: + predicted_dist = self.distribution(*predicted_params) + inv_beta = self.loss_params["inv_real_beta"] + return -predicted_dist.expected_log_prob(targets).mean() + inv_beta * self.rkl_loss( + predicted_params, prior_params, reduction='mean' + ) + + def eval_step(self, dataloader: torch.utils.data.DataLoader) -> Tuple[float, list]: + self.model.eval() + acc_eval_loss = 0.0 + acc_metrics = [0.0 for m in self.test_metrics] + with torch.no_grad(): + for i, (x, y) in enumerate(dataloader): + x, y = x.to(self.device), y.to(self.device) + predicted_params = self.model(x) + prior_params = self.prior_converter(x) + acc_eval_loss += self.loss_function( + predicted_params, + prior_params, + y + ).item() / len(dataloader) + for i, metric in enumerate(self.test_metrics): + acc_metrics[i] += metric( + predicted_params, + y + ) / len(dataloader) + return acc_eval_loss, acc_metrics + + def train(self, dataloader, oodloader, num_epochs, eval_dataloader=None, log_per=0, verbose=True): + with torch.no_grad(): + self.estimate_avg_mean_var(dataloader) + + trainloss_hist, oodloss_hist, valloss_hist, metrics_hist = [], [], [], [] + + for e in range(num_epochs): + self.model.train() + acc_train_loss = 0.0 + acc_ood_loss = 0.0 + """With only zip() the iterator will be exhausted when the length + is equal to that of the smallest dataset. + But with the use of cycle(), we will repeat the smallest dataset again unless + our iterator looks at all the samples from the largest dataset.""" + for (x, y), (x_ood,) in zip(dataloader, cycle(oodloader)): + x, y, x_ood = x.to(self.device), y.to(self.device), x_ood.to(self.device) + c_losses = self.train_step(x, y, x_ood) + acc_train_loss += c_losses[0] / len(dataloader) + acc_ood_loss += c_losses[1] / len(dataloader) + + trainloss_hist += [acc_train_loss] + oodloss_hist += [acc_ood_loss] + + if eval_dataloader and log_per > 0 and self.test_metrics: + if e % log_per == 0 or e == (num_epochs - 1): + acc_eval_loss, acc_metrics = self.eval_step(eval_dataloader) + + if verbose: + print("Epoch %d train loss %.3f ood loss %.3f eval loss %.3f" % ( + e, acc_train_loss, acc_ood_loss, acc_eval_loss + ), 'eval ' + ','.join(m.__name__ + " %.3f" % acc_metrics[i] for i, m in enumerate(self.test_metrics)), + flush=True + ) + valloss_hist += [acc_eval_loss] + metrics_hist += [acc_metrics] + + if self.scheduler: + self.scheduler.step() + + return trainloss_hist, oodloss_hist, valloss_hist, metrics_hist + + def estimate_avg_mean_var(self, dataloader): + self.avg_mean = None + for _, y in dataloader: + if self.avg_mean is None: + self.avg_mean = y.mean(dim=0) / len(dataloader) + else: + self.avg_mean += y.mean(dim=0) / len(dataloader) + sum_var = torch.zeros_like(self.avg_mean) + num_samples = 0 + for _, y in dataloader: + avg_mean = torch.repeat_interleave(self.avg_mean.unsqueeze(0), repeats=y.size(0), dim=0) + sum_var += (y - avg_mean).pow(2).sum(dim=0) + num_samples += y.size(0) + self.avg_scatter = sum_var / num_samples + + def prior_converter(self, inputs): + avg_mean_r = torch.repeat_interleave( + self.avg_mean.unsqueeze(0), repeats=inputs.size(0), dim=0 + ).to(inputs.device) + prior_kappa, prior_nu = self.loss_params['prior_beta'],\ + self.loss_params['prior_beta'] + self.model.output_dim + 1 + avg_precision_r = torch.repeat_interleave( + (1 / (prior_nu * self.avg_scatter.unsqueeze(0))), repeats=inputs.size(0), dim=0 + ).to(inputs.device) + + all_params = [avg_mean_r, avg_precision_r] + return all_params + [prior_kappa, prior_nu] + + def nll_loss(self, predicted_params, targets, reduction='mean'): + assert reduction in ['mean', 'sum', 'none'] + predicted_dist = self.distribution(*predicted_params) + batched_loss = -predicted_dist.predictive_posterior_log_prob(targets) + assert batched_loss.dim() < 2 or batched_loss.size(-1) == 1 + return reduce_tensor(batched_loss, reduction) + + def switch_bn_updates(self, mode): + if self.model.use_bn: + for m in self.model.modules(): + if isinstance(m, nn.BatchNorm1d) or isinstance(m, nn.BatchNorm2d): + if mode == 'train': + m.train() + elif mode == 'eval': + m.eval() + + def check_loss_params(self, loss_params): + for req_key in ['inv_real_beta', 'ood_coeff', 'prior_beta']: + if req_key not in loss_params.keys(): + raise Exception("Rkl loss params dict should contain key", req_key) + + +class DistributionEnsembleToPriorDistiller(DistributionRKLTrainer): + def __init__( + self, teacher_models: list, *args, **kwargs + ): + super(DistributionEnsembleToPriorDistiller, self).__init__(*args, **kwargs) + self.teacher_models = teacher_models + self.num_steps = 1 + for model in self.teacher_models: + model.eval() + self.loss_params['temperature'] = self.loss_params['max_temperature'] + + @property + def uncertainty_methods(self): + return [ + 'predictive_posterior_entropy', 'expected_entropy', + 'mutual_information', 'expected_pairwise_kl', + 'variance_of_expected', 'expected_variance', + 'total_variance' + ] + + def train_step(self, x, y): + x += torch.empty(x.shape).normal_( + mean=0, std=self.loss_params["noise_level"] + ).to(x.device) + + if "max_steps" in self.loss_params.keys(): + T_0 = self.loss_params["max_temperature"] + first_part = float(0.2 * self.loss_params["max_steps"]) + third_part = float(0.6 * self.loss_params["max_steps"]) + if self.num_steps < first_part: + self.loss_params["temperature"] = T_0 + elif self.num_steps < third_part: + self.loss_params["temperature"] = T_0 - (T_0 - 1) * min( + float(self.num_steps - first_part) / float(0.4 * self.loss_params["max_steps"]), + 1.0 + ) + else: + self.loss_params["temperature"] = 1.0 + + self.optimizer.zero_grad() + + predicted_params = self.model(x) + loss = self.loss_function( + predicted_params, + x + ) + loss.backward() + torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0) + + self.optimizer.step() + self.num_steps += 1 + return loss.item() + + def eval_step(self, dataloader: torch.utils.data.DataLoader) -> Tuple[float, list]: + self.model.eval() + acc_eval_loss = 0.0 + acc_metrics = [0.0 for m in self.test_metrics] + with torch.no_grad(): + for x, y in dataloader: + x, y = x.to(self.device), y.to(self.device) + predicted_params = self.model(x) + acc_eval_loss += self.loss_function( + predicted_params, + x + ).item() / len(dataloader) + for i, metric in enumerate(self.test_metrics): + acc_metrics[i] += metric( + predicted_params, + y + ) / len(dataloader) + return acc_eval_loss, acc_metrics + + def loss_function(self, predicted_params, x): + T = self.loss_params["temperature"] + with torch.no_grad(): + all_teachers_means, all_teachers_vars = [], [] + aggr_teachers_mean = torch.zeros_like(predicted_params[0]).to(self.device) + aggr_teachers_var = torch.zeros_like(predicted_params[1]).to(self.device) + for i, teacher in enumerate(self.teacher_models): + teacher_params = teacher(x) + aggr_teachers_mean += teacher_params[0] / len(self.teacher_models) + aggr_teachers_var += teacher_params[1].pow(2) / len(self.teacher_models) + all_teachers_means.append(teacher_params[0]) + all_teachers_vars.append(teacher_params[1].pow(2)) + for i, _ in enumerate(self.teacher_models): + all_teachers_means[i] = (T - 1) * aggr_teachers_mean / (T + 1) +\ + 2 * all_teachers_means[i] / (T + 1) + all_teachers_vars[i] = (T - 1) * aggr_teachers_var / (T + 1) +\ + 2 * all_teachers_vars[i] / (T + 1) + + new_nu = (predicted_params[-1] - self.model.output_dim - 1) * T +\ + self.model.output_dim + 1 + new_kappa = predicted_params[-2] * T + #new_nu = (predicted_params[-1] - self.model.output_dim - 2) * (1 / T) +\ + # self.model.output_dim + 2 + #new_kappa = predicted_params[-2] * (1 / T) + + predicted_dist = self.distribution(*[ + predicted_params[0], predicted_params[1], new_kappa, new_nu + ]) + all_losses = [] + for i in range(len(self.teacher_models)): + all_losses.append(-predicted_dist.log_prob( + all_teachers_means[i], 1 / all_teachers_vars[i] + ).sum()) + + return sum(all_losses) / len(all_losses) / T + + def nll_loss(self, predicted_params, targets, reduction='mean'): + assert reduction in ['mean', 'sum', 'none'] + predicted_dist = self.distribution(*predicted_params) + batched_loss = -predicted_dist.predictive_posterior_log_prob(targets) + assert batched_loss.dim() < 2 or batched_loss.size(-1) == 1 + return reduce_tensor(batched_loss, reduction) + + def check_loss_params(self, loss_params): + for req_key in ['max_temperature', 'noise_level']: + if req_key not in loss_params.keys(): + raise Exception("NLL loss params dict should contain key", req_key) diff --git a/src/training/trainers.py b/src/training/trainers.py new file mode 100644 index 0000000..bc7db84 --- /dev/null +++ b/src/training/trainers.py @@ -0,0 +1,297 @@ +from typing import Tuple + +import torch +from torch.distributions import Distribution +from torch.distributions.kl import kl_divergence +from torch.utils.data import SequentialSampler + +from sklearn.metrics import mean_squared_error + + +def reduce_tensor(vec: torch.Tensor, reduction: str = 'mean'): + """Global reduction of tensor based on str + + Args: + vec: torch.FloatTensor + reduction: str, one of ['sum', 'mean', 'none'], default 'mean' + """ + assert reduction in ['sum', 'mean', 'none'] + if reduction == 'mean': + return vec.mean() + elif reduction == 'sum': + return vec.sum() + elif reduction == 'none': + return vec + + +def params_rmse(predicted_params, targets): + assert not torch.isnan(predicted_params[0]).any() + return mean_squared_error(predicted_params[0].cpu(), targets.cpu()) ** 0.5 + + + + +class DistributionMLETrainer: + """This class implements MLE training for a model that outputs parameters + of some distribution. Note that both trained model and optimizer instances + are created inside it. + """ + def __init__( + self, model_params: dict, model: torch.nn.Module, + optim_params: dict, distribution=Distribution, + optimizer=torch.optim.Adam, scheduler=None, scheduler_params=None, + test_metrics=[params_rmse], device='cuda:0' + ): + self.model = model(**model_params).to(device) + self.distribution = distribution + self.optimizer = optimizer(self.model.parameters(), **optim_params) + self.scheduler = None + if scheduler is not None: + self.scheduler = scheduler(self.optimizer, **scheduler_params) + self.test_metrics = test_metrics + self.device = device + + @property + def uncertainty_methods(self): + return ['entropy'] + + def train_step(self, x: torch.FloatTensor, y: torch.FloatTensor) -> float: + self.optimizer.zero_grad() + predicted_params = self.model(x) + loss = self.loss_function( + predicted_params, + y + ) + loss.backward() + torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0) + self.optimizer.step() + return loss.item() + + def eval_step(self, dataloader: torch.utils.data.DataLoader) -> Tuple[float, list]: + self.model.eval() + acc_eval_loss = 0.0 + acc_metrics = [0.0 for m in self.test_metrics] + with torch.no_grad(): + for x, y in dataloader: + x, y = x.to(self.device), y.to(self.device) + predicted_params = self.model(x) + acc_eval_loss += self.loss_function( + predicted_params, + y + ).item() / len(dataloader) + for i, metric in enumerate(self.test_metrics): + acc_metrics[i] += metric( + predicted_params, + y + ) / len(dataloader) + return acc_eval_loss, acc_metrics + + def train(self, dataloader: torch.utils.data.DataLoader, + num_epochs: int, eval_dataloader: torch.utils.data.DataLoader = None, + log_per: int = 0, verbose: str =True + ) -> Tuple[list, list, list]: + trainloss_hist, valloss_hist, metrics_hist = [], [], [] + + for e in range(num_epochs): + self.model.train() + acc_train_loss = 0.0 + for x, y in dataloader: + x, y = x.to(self.device), y.to(self.device) + acc_train_loss += self.train_step(x, y) / len(dataloader) + + trainloss_hist += [acc_train_loss] + + if eval_dataloader and log_per > 0 and self.test_metrics: + if e % log_per == 0 or e == (num_epochs - 1): + acc_eval_loss, acc_metrics = self.eval_step(eval_dataloader) + if verbose: + print("Epoch %d train loss %.3f eval loss %.3f" % ( + e, acc_train_loss, acc_eval_loss + ), 'eval ' + ','.join( + m.__name__ + " %.3f" % acc_metrics[i] + for i, m in enumerate(self.test_metrics) + ), flush=True + ) + valloss_hist += [acc_eval_loss] + metrics_hist += [acc_metrics] + + if self.scheduler: + self.scheduler.step() + + return trainloss_hist, valloss_hist, metrics_hist + + def compute_unsupervised_metric_through_data( + self, dataloader: torch.utils.data.DataLoader, metric + ) -> torch.FloatTensor: + metric_scores = [] + self.model.eval() + with torch.no_grad(): + for items in dataloader: + if isinstance(items, tuple) or isinstance(items, list): + predicted_params = self.model(items[0].to(self.device)) + else: + predicted_params = self.model(items.to(self.device)) + metric_scores += metric( + predicted_params + ).cpu().tolist() + return torch.FloatTensor(metric_scores) + + def loss_function(self, predicted_params, targets): + return self.nll_loss(predicted_params, targets, reduction='mean') + + def nll_loss(self, predicted_params, targets, reduction='mean'): + assert reduction in ['mean', 'sum', 'none'] + predicted_dist = self.distribution(*predicted_params) + batched_loss = -predicted_dist.log_prob(targets) + assert batched_loss.dim() < 2 or batched_loss.size(-1) == 1 + return reduce_tensor(batched_loss, reduction) + + def get_predicted_params(self, dataloader: torch.utils.data.DataLoader) -> list: + all_predicted_params = [] + self.model.eval() + with torch.no_grad(): + for items in dataloader: + if isinstance(items, tuple) or isinstance(items, list): + predicted_params = self.model(items[0].to(self.device)) + else: + predicted_params = self.model(items.to(self.device)) + if len(all_predicted_params) == 0: + all_predicted_params = [param.cpu().tolist() for param in predicted_params] + else: + for i in range(len(all_predicted_params)): + all_predicted_params[i] += predicted_params[i].cpu().tolist() + return [torch.FloatTensor(param) for param in all_predicted_params] + + def eval_uncertainty(self, dataloader, method: str = 'entropy'): + some_metric = lambda params: getattr(self.distribution(*params), method)() + return self.compute_unsupervised_metric_through_data(dataloader, some_metric) + + def save_model(self, dir: str): + torch.save(self.model.state_dict(), dir + '.ckpt') + + def load_model(self, dir: str): + self.model.load_state_dict(torch.load(dir + '.ckpt')) + + +class DistributionRKLTrainer(DistributionMLETrainer): + """This class replaces standard MLE loss with Reverse-KL. + """ + def __init__(self, loss_params: dict, *args, **kwargs): + super(DistributionRKLTrainer, self).__init__(*args, **kwargs) + self.check_loss_params(loss_params) + self.loss_params = loss_params + + def loss_function(self, predicted_params, targets): + target_params = self.converter(targets) + return self.rkl_loss(predicted_params, target_params, reduction='mean') + + def rkl_loss(self, predicted_params, target_params, reduction='mean'): + assert reduction in ['mean', 'sum', 'none'] + predicted_dist = self.distribution(*predicted_params) + true_dist = self.distribution(*target_params) + batched_loss = kl_divergence(predicted_dist, true_dist) + assert batched_loss.dim() < 2 or batched_loss.size(-1) == 1 + return reduce_tensor(batched_loss, reduction) + + def converter(self, targets): + """Extend targets with manually specified params to parametrize target distribution""" + return [targets] + self.loss_params["real_params"] + + def check_loss_params(self, loss_params): + for req_key in ['target_lambda', 'target_kappa', 'target_nu']: + if req_key not in loss_params.keys(): + raise Exception("Rkl loss params dict should contain key", req_key) + + +class DistributionEnsembleMLETrainer: + """This class sequentially trains multiple models and combines their outputs in an + ensemble distribution. Besides more accurate predictions, this allows + us to decompose uncertainty measures. + """ + def __init__( + self, n_models: int, mixture_distribution=Distribution, + *args, **kwargs + ): + self.trainers = [ + DistributionMLETrainer(*args, **kwargs) for _ in range(n_models) + ] + self.mixture_distribution = mixture_distribution + + @property + def uncertainty_methods(self): + return [ + 'expected_entropy', 'expected_pairwise_kl', + 'variance_of_expected', 'expected_variance', + 'total_variance' + ] + + def train(self, dataloader: torch.utils.data.DataLoader, + num_epochs: int, eval_dataloader: torch.utils.data.DataLoader = None, + log_per: int = 0, verbose: str =True + ) -> Tuple[list, list, list]: + train_hists, val_hists, metrics_hists = [], [], [] + for i, trainer in enumerate(self.trainers): + if verbose: + print('-'*20, flush=True) + print("Model %d" % i, flush=True) + res = trainer.train(dataloader, num_epochs, eval_dataloader, log_per, verbose) + train_hists.append(res[0]) + val_hists.append(res[1]) + metrics_hists.append(res[2]) + return train_hists, val_hists, metrics_hists + + def nll_loss(self, predicted_params, targets, reduction='mean'): + assert reduction in ['mean', 'sum', 'none'] + predicted_dist = self.mixture_distribution(*predicted_params) + batched_loss = -predicted_dist.log_prob(targets) + assert batched_loss.dim() < 2 or batched_loss.size(-1) == 1 + return reduce_tensor(batched_loss, reduction) + + def get_predicted_params(self, dataloader: torch.utils.data.DataLoader) -> list: + if not isinstance(dataloader.sampler, SequentialSampler): + print(dataloader.batch_sampler) + raise ValueError("To merge predicted params correctly dataloader shouldn't shuffle") + all_means, all_stds = [], [] + for trainer in self.trainers: + cmean, cstd = trainer.get_predicted_params(dataloader) + + all_means.append(cmean) + all_stds.append(cstd) + return all_means, all_stds + + def compute_unsupervised_metric_through_data( + self, dataloader: torch.utils.data.DataLoader, metric + ) -> torch.FloatTensor: + metric_scores = [] + for trainer in self.trainers: + trainer.model.eval() + with torch.no_grad(): + for items in dataloader: + all_means, all_stds = [], [] + if isinstance(items, tuple) or isinstance(items, list): + for trainer in self.trainers: + cmean, cstd = trainer.model(items[0].to(trainer.device)) + all_means.append(cmean) + all_stds.append(cstd) + else: + for trainer in self.trainers: + cmean, cstd = trainer.model(items.to(trainer.device)) + all_means.append(cmean) + all_stds.append(cstd) + if len(all_means[0]) > 1: + metric_scores += metric( + [all_means, all_stds] + ).cpu().tolist() + return torch.FloatTensor(metric_scores) + + def save_model(self, dir: str): + for i, trainer in enumerate(self.trainers): + trainer.save_model(dir + '_' + str(i)) + + def load_model(self, dir: str): + for i, trainer in enumerate(self.trainers): + trainer.load_model(dir + '_' + str(i)) + + def eval_uncertainty(self, dataloader, method: str = 'expected_pairwise_kl'): + some_metric = lambda params: getattr(self.mixture_distribution(*params), method)() + return self.compute_unsupervised_metric_through_data(dataloader, some_metric) diff --git a/src/utils/__pycache__/func_utils.cpython-37.pyc b/src/utils/__pycache__/func_utils.cpython-37.pyc new file mode 100644 index 0000000..7a02b2f Binary files /dev/null and b/src/utils/__pycache__/func_utils.cpython-37.pyc differ diff --git a/src/utils/func_utils.py b/src/utils/func_utils.py new file mode 100644 index 0000000..9a7db93 --- /dev/null +++ b/src/utils/func_utils.py @@ -0,0 +1,100 @@ +from typing import Union +import torch + +from sklearn.metrics import mean_squared_error + + +def percentile(t: torch.tensor, q: float) -> Union[int, float]: + """ + Return the ``q``-th percentile of the flattened input tensor's data. + + CAUTION: + * Needs PyTorch >= 1.1.0, as ``torch.kthvalue()`` is used. + * Values are not interpolated, which corresponds to + ``numpy.percentile(..., interpolation="nearest")``. + + :param t: Input tensor. + :param q: Percentile to compute, which must be between 0 and 100 inclusive. + :return: Resulting value (scalar). + """ + # Note that ``kthvalue()`` works one-based, i.e. the first sorted value + # indeed corresponds to k=1, not k=0! Use float(q) instead of q directly, + # so that ``round()`` returns an integer, even if q is a np.float32. + k = 1 + round(.01 * float(q) * (t.numel() - 1)) + result = t.view(-1).kthvalue(k).values.item() + return result + + +def mvdigamma(vec: torch.FloatTensor, p: int, reduction: str = 'sum'): + """Implements batched Multivariate digamma function over a given float vector + + Args: + vec: torch.FloatTensor of shapes (bs, ...), inp to apply function on + p: int, dimensionality + reduction: str, one of ['sum', 'mean', 'none'], default 'sum' + Returns: + Tensor with same shapes as vec, where the mvdigamma function is + computed for each position independently + """ + assert reduction in ['sum', 'mean'] + + increasing_numbers = torch.arange( + 1, p + 1, dtype=torch.float, requires_grad=False + ) + output = torch.digamma( + vec.unsqueeze(-1) + 0.5 * (1 - increasing_numbers.to(vec.device)) + ) + + if reduction == 'sum': + return output.sum(axis=-1) + elif reduction == 'mean': + return output.mean(axis=-1) + + +def reduce_tensor(vec: torch.Tensor, reduction: str = 'mean'): + """Global reduction of tensor based on str + + Args: + vec: torch.FloatTensor + reduction: str, one of ['sum', 'mean', 'none'], default 'mean' + """ + assert reduction in ['sum', 'mean', 'none'] + if reduction == 'mean': + return vec.mean() + elif reduction == 'sum': + return vec.sum() + elif reduction == 'none': + return vec + + +def params_rmse(predicted_params, targets): + assert not torch.isnan(predicted_params[0]).any() + return mean_squared_error(predicted_params[0].cpu(), targets.cpu()) ** 0.5 + + +def rel_error(value1, value2): + value1_norm = value1.norm(p=2, dim=-1) + value2_norm = value2.norm(p=2, dim=-1) + diff_norm = (value1 - value2).norm(p=2, dim=-1) + return diff_norm / (value1_norm.pow(0.5) * value2_norm.pow(0.5)) + + +if __name__ == '__main__': + from scipy.special import digamma + + for k in range(1000): + rand_nu = torch.randn(512).exp() + 1e-5 + digammas_scipy = torch.zeros(512) + digammas_torch = mvdigamma(rand_nu, 1) + + for k in range(512): + digammas_scipy[k] = digamma(rand_nu[k].item()) + + if (rel_error(digammas_scipy, digammas_torch) > 1e-6).any(): + raise Exception("Digamma functions of torch and scipy doesn't match") + + if ((rand_nu.log() - 1 / (2 * rand_nu) - digammas_torch) < 0.0).any(): + raise Exception("Upper inequality doesn't satisfied") + + if ((rand_nu.log() - 1 / (rand_nu) - digammas_torch) > 0.0).any(): + raise Exception("Lower inequality doesn't satisfied") diff --git a/uncertainty_example.ipynb b/uncertainty_example.ipynb new file mode 100644 index 0000000..1dd7a0c --- /dev/null +++ b/uncertainty_example.ipynb @@ -0,0 +1,1618 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Structure of this notebook:\n", + "#### 1) Uncertainty and deep ensembles for classification\n", + "#### 2) Uncertainty and deep ensembles for regression\n", + "#### 3) Ensemble distribution distillation and Prior networks for regression" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Deep ensembles for classification" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Why ensembles?\n", + "\n", + "#### Assume that we have an ensemble of different probabilistic models that predict $y$ having features $x^*$: \n", + "#### $$ \\{ P(y|x^*, \\theta_m) \\}_{m=1..M}, \\theta_m \\sim P(\\theta|D),$$\n", + "#### where $P(\\theta|D)$ is the probability to train such model, having dataset $D$, some optimization procedure and model architecture.\n", + "#### In deep ensembles with train each model in the ensemble with different random inits.\n", + "#### Each model $P(y|x^*, \\theta_m)$ captures different estimate of data uncertainty, it has it's own view, own local optima in the task.\n", + "\n", + "#### H - entropy, for some discrete distribution with classes probabilities $p_i$:\n", + "$$H(p) = -\\sum_{i=1..N} p_i \\cdot \\log p_i$$\n", + "\n", + "#### Through ensemble we can calculate *Total uncertainty*:\n", + "#### $$H[\\mathbb{E}_{\\theta \\sim P(\\theta|D)} [P(y|x^*, \\theta)]] \\simeq H[\\frac{1}{M} \\sum_{m=1}^M [P(y|x^*, \\theta_m)]]$$\n", + "#### and *Expected data (aleatoric) uncertainty*:\n", + "#### $$\\mathbb{E}_{\\theta \\sim P(\\theta|D)} [H[P(y|x^*, \\theta)]] \\simeq \\frac{1}{M} \\sum_{m=1}^M [H[P(y|x^*, \\theta_m)]]$$\n", + "#### *Knowledge (epistemic) uncertainty* is the difference between *Total uncertainty* and *Expected Data uncertainty*:\n", + "#### $$\\mathcal{I}(y, \\theta| x^*, D) = H[\\mathbb{E}_{\\theta \\sim P(\\theta|D)} [P(y|x^*, \\theta)]] - \\mathbb{E}_{\\theta \\sim P(\\theta|D)} [H[P(y|x^*, \\theta)]]$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**To visualize the behaviour of ensemble in different cases let's consider 3 classes classification, and show it on triangular simplex, each corner in the triangular is some class, each point is the prediction of some model in the ensemble. The closer a point is to a corner, the greater its prediction of the probability of this class**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**There are different ways to generate ensembles, more about them you can find in video about \"Ensemble Generation\".**\n", + "\n", + "**Here we will use the simplest, yet the most effective way to generate ensembles for uncertainty estimation: we will train different models with different random seeds.**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**For simplicity, we will show all concepts on easy tasks, where you can train your model fast and play with it. You can fidn high scale experiments in scientific papers introduced in our track.**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6.0 10.2\n" + ] + } + ], + "source": [ + "import torch\n", + "import torchvision\n", + "import torchvision.transforms as transforms\n", + "import matplotlib.pyplot as plt\n", + "import torch.nn as nn\n", + "import seaborn as sns\n", + "import sklearn\n", + "\n", + "print(torch.__version__, torch.version.cuda)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**MNIST dataset**" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "n_epochs = 3\n", + "batch_size_train = 64\n", + "batch_size_test = 200\n", + "learning_rate = 0.01\n", + "momentum = 0.5\n", + "num_networks = 5 # Ensemble size\n", + "\n", + "random_seed = 1\n", + "torch.manual_seed(random_seed)\n", + "device='cuda:0'" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "train_loader = torch.utils.data.DataLoader(\n", + " torchvision.datasets.MNIST('./data/', train=True, download=True,\n", + " transform=torchvision.transforms.Compose([\n", + " torchvision.transforms.ToTensor(),\n", + " torchvision.transforms.Normalize(\n", + " (0.1307,), (0.3081,))\n", + " ])),\n", + " batch_size=batch_size_train, shuffle=True)\n", + "\n", + "test_loader = torch.utils.data.DataLoader(\n", + " torchvision.datasets.MNIST('./data/', train=False, download=True,\n", + " transform=torchvision.transforms.Compose([\n", + " torchvision.transforms.ToTensor(),\n", + " torchvision.transforms.Normalize(\n", + " (0.1307,), (0.3081,))\n", + " ])),\n", + " batch_size=batch_size_test, shuffle=True)\n", + "\n", + "classes = tuple(str(i) for i in range(10))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 9 3 0 1\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# functions to show an image\n", + "def imshow(img):\n", + " npimg = img.numpy()\n", + " plt.imshow(np.transpose(npimg, (1, 2, 0)))\n", + " plt.show()\n", + "\n", + "\n", + "# get some random training images\n", + "dataiter = iter(train_loader)\n", + "images, labels = dataiter.next()\n", + "\n", + "# show images\n", + "imshow(torchvision.utils.make_grid(images[:4]))\n", + "# print labels\n", + "print(' '.join('%5s' % classes[labels[j]] for j in range(4)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will use simple network with two convolutional layers and two linear layers" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import torch.nn.functional as F\n", + "\n", + "\n", + "class Net(nn.Module):\n", + " def __init__(self):\n", + " super(Net, self).__init__()\n", + " self.conv1 = nn.Conv2d(1, 10, kernel_size=5)\n", + " self.conv2 = nn.Conv2d(10, 20, kernel_size=5)\n", + " self.conv2_drop = nn.Dropout2d()\n", + " self.fc1 = nn.Linear(320, 50)\n", + " self.fc2 = nn.Linear(50, 10)\n", + "\n", + " def forward(self, x):\n", + " x = F.relu(F.max_pool2d(self.conv1(x), 2))\n", + " x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))\n", + " x = x.view(-1, 320)\n", + " x = F.relu(self.fc1(x))\n", + " x = F.dropout(x, training=self.training)\n", + " x = self.fc2(x)\n", + " return F.log_softmax(x, dim=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import torch.optim as optim\n", + "\n", + "criterion = nn.CrossEntropyLoss()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "ensemble = []\n", + "for i in range(num_networks):\n", + " new_net = Net()\n", + " new_net.to(device)\n", + " ensemble.append(new_net)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Network: 0 epoch: 1 step: 299 loss: 0.23045 \n", + "Network: 0 epoch: 1 step: 599 loss: 0.10454 \n", + "Network: 0 epoch: 1 step: 899 loss: 0.07892 \n", + "Network: 0 epoch: 2 step: 299 loss: 0.06506 \n", + "Network: 0 epoch: 2 step: 599 loss: 0.0577 \n", + "Network: 0 epoch: 2 step: 899 loss: 0.05441 \n", + "Network: 0 epoch: 3 step: 299 loss: 0.04942 \n", + "Network: 0 epoch: 3 step: 599 loss: 0.04697 \n", + "Network: 0 epoch: 3 step: 899 loss: 0.04368 \n", + "Network: 1 epoch: 1 step: 299 loss: 0.22487 \n", + "Network: 1 epoch: 1 step: 599 loss: 0.10296 \n", + "Network: 1 epoch: 1 step: 899 loss: 0.08061 \n", + "Network: 1 epoch: 2 step: 299 loss: 0.06297 \n", + "Network: 1 epoch: 2 step: 599 loss: 0.05738 \n", + "Network: 1 epoch: 2 step: 899 loss: 0.05285 \n", + "Network: 1 epoch: 3 step: 299 loss: 0.04823 \n", + "Network: 1 epoch: 3 step: 599 loss: 0.0444 \n", + "Network: 1 epoch: 3 step: 899 loss: 0.04269 \n", + "Network: 2 epoch: 1 step: 299 loss: 0.24886 \n", + "Network: 2 epoch: 1 step: 599 loss: 0.10192 \n", + "Network: 2 epoch: 1 step: 899 loss: 0.07642 \n", + "Network: 2 epoch: 2 step: 299 loss: 0.06149 \n", + "Network: 2 epoch: 2 step: 599 loss: 0.05567 \n", + "Network: 2 epoch: 2 step: 899 loss: 0.05212 \n", + "Network: 2 epoch: 3 step: 299 loss: 0.04732 \n", + "Network: 2 epoch: 3 step: 599 loss: 0.04288 \n", + "Network: 2 epoch: 3 step: 899 loss: 0.0423 \n", + "Network: 3 epoch: 1 step: 299 loss: 0.24683 \n", + "Network: 3 epoch: 1 step: 599 loss: 0.09415 \n", + "Network: 3 epoch: 1 step: 899 loss: 0.07193 \n", + "Network: 3 epoch: 2 step: 299 loss: 0.0601 \n", + "Network: 3 epoch: 2 step: 599 loss: 0.05246 \n", + "Network: 3 epoch: 2 step: 899 loss: 0.04885 \n", + "Network: 3 epoch: 3 step: 299 loss: 0.04606 \n", + "Network: 3 epoch: 3 step: 599 loss: 0.04303 \n", + "Network: 3 epoch: 3 step: 899 loss: 0.03979 \n", + "Network: 4 epoch: 1 step: 299 loss: 0.24504 \n", + "Network: 4 epoch: 1 step: 599 loss: 0.10257 \n", + "Network: 4 epoch: 1 step: 899 loss: 0.07364 \n", + "Network: 4 epoch: 2 step: 299 loss: 0.0606 \n", + "Network: 4 epoch: 2 step: 599 loss: 0.0552 \n", + "Network: 4 epoch: 2 step: 899 loss: 0.04713 \n", + "Network: 4 epoch: 3 step: 299 loss: 0.0453 \n", + "Network: 4 epoch: 3 step: 599 loss: 0.04275 \n", + "Network: 4 epoch: 3 step: 899 loss: 0.04027 \n", + "Finished Training\n", + "CPU times: user 1min 44s, sys: 265 ms, total: 1min 44s\n", + "Wall time: 1min 43s\n" + ] + } + ], + "source": [ + "%%time\n", + "for net_id, net in enumerate(ensemble):\n", + " optimizer = optim.SGD(net.parameters(), lr=learning_rate,\n", + " momentum=momentum)\n", + " for epoch in range(n_epochs): # loop over the dataset multiple times\n", + " running_loss = 0.0\n", + " for i, data in enumerate(train_loader, 0):\n", + " # get the inputs; data is a list of [inputs, labels]\n", + " inputs, labels = data\n", + " inputs, labels = inputs.cuda(), labels.cuda()\n", + " # zero the parameter gradients\n", + " optimizer.zero_grad()\n", + " # forward + backward + optimize\n", + " outputs = net(inputs)\n", + "\n", + " loss = criterion(outputs, labels)\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " # print statistics\n", + " running_loss += loss.item()\n", + " if i % 300 == 299: \n", + " print(f'Network: {net_id} epoch: {epoch + 1} step: {i} loss: {round(running_loss/2000, 5)} ')\n", + " running_loss = 0.0\n", + "\n", + "print('Finished Training')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "for net in ensemble:\n", + " net.eval()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "dataiter = iter(test_loader)\n", + "images, labels = dataiter.next()\n", + "images, labels = images.to(device), labels.to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "predictions = net(images)\n", + "probabilities = predictions.exp()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "def predict_uncertainties(ensemble, images):\n", + " all_probabilities = []\n", + " for net in ensemble:\n", + " net.eval()\n", + " probs = net(images).exp()\n", + " all_probabilities.append(probs)\n", + " # Now probs is a list with num_networks tensors of size (bs x num_classes)\n", + " expected_probability = torch.mean(torch.stack(all_probabilities), dim=0)\n", + " # Total uncertainty\n", + " entropy_of_expected = torch.sum(-expected_probability * torch.log(expected_probability), dim=1) \n", + " # Data uncertainty\n", + " expected_entropy = torch.mean(\n", + " torch.stack(\n", + " [torch.sum(-prob * torch.log(prob), dim=1) for prob in all_probabilities]),\n", + " dim=0)\n", + " return expected_probability, entropy_of_expected, expected_entropy" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "expected_probability, entropy_of_expected, expected_entropy = predict_uncertainties(ensemble, images)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "knowledge_uncertainty = entropy_of_expected - expected_entropy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Predictions of one network" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of the network on the 10000 test images: 96 %\n" + ] + } + ], + "source": [ + "net = ensemble[0]\n", + "correct = 0\n", + "total = 0\n", + "with torch.no_grad():\n", + " for data in test_loader:\n", + " images, labels = data[0].to('cuda'), data[1].to('cuda')\n", + " outputs = net(images)\n", + " _, predicted = torch.max(outputs.data, 1)\n", + " total += labels.size(0)\n", + " correct += (predicted == labels).sum().item()\n", + "\n", + "print('Accuracy of the network on the 10000 test images: %d %%' % (\n", + " 100 * correct / total))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ensemble mean prediction" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of the network on the 10000 test images: 97 %\n" + ] + } + ], + "source": [ + "correct = 0\n", + "total = 0\n", + "with torch.no_grad():\n", + " for data in test_loader:\n", + " images, labels = data[0].to('cuda'), data[1].to('cuda')\n", + " outputs = torch.log(torch.mean(torch.stack([net(images).exp() for net in ensemble]), dim=0))\n", + " _, predicted = torch.max(outputs.data, 1)\n", + " total += labels.size(0)\n", + " correct += (predicted == labels).sum().item()\n", + "\n", + "print('Accuracy of the network on the 10000 test images: %d %%' % (\n", + " 100 * correct / total))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Uncertainties" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "all_expected_probability = []\n", + "all_entropy_of_expected = []\n", + "all_expected_entropy = []\n", + "all_knowledge_uncertainty = []\n", + "all_labels = []\n", + "with torch.no_grad():\n", + " for data in test_loader:\n", + " images, labels = data[0].to('cuda'), data[1].to('cuda')\n", + " expected_probability, entropy_of_expected, expected_entropy = predict_uncertainties(ensemble, images)\n", + " knowledge_uncertainty = entropy_of_expected - expected_entropy\n", + "\n", + " all_expected_probability.append(expected_probability.cpu().numpy())\n", + " all_entropy_of_expected.append(entropy_of_expected.cpu().numpy())\n", + " all_expected_entropy.append(expected_entropy.cpu().numpy())\n", + " all_knowledge_uncertainty.append(knowledge_uncertainty.cpu().numpy())\n", + " all_labels.append(labels.cpu().numpy())" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "all_expected_probability = np.vstack(all_expected_probability)\n", + "all_entropy_of_expected = np.hstack(all_entropy_of_expected)\n", + "all_expected_entropy = np.hstack(all_expected_entropy)\n", + "all_knowledge_uncertainty = np.hstack(all_knowledge_uncertainty)\n", + "all_labels = np.hstack(all_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "all_predictions = np.argmax(all_expected_probability, axis=1)\n", + "\n", + "errors = (all_predictions != all_labels).astype(int)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Total uncertainty" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**We can use total uncertainty to understand if we are certain in our predictions. If we are not certain, we can use some other model, or human evaluation. More about use cases you can find in our video about uncertainty applications.**" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/iv-provilkov/miniconda3/envs/unc1/lib/python3.7/site-packages/seaborn/distributions.py:2551: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n", + " warnings.warn(msg, FutureWarning)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(12,8))\n", + "sns.distplot(all_entropy_of_expected, bins=100)\n", + "plt.title('Distribution of total uncertainty', fontsize=18)\n", + "plt.grid()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "total_uncertainty_order_error_cumsum = np.cumsum(errors[all_entropy_of_expected.argsort()])" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(12,8))\n", + "plt.plot(total_uncertainty_order_error_cumsum)\n", + "plt.xlabel('Example_id', fontsize=18)\n", + "plt.ylabel('Errors sum', fontsize=18)\n", + "plt.title(\"Change of total error if we go from low to high total uncertainty\", fontsize=18)\n", + "plt.grid()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Knowledge uncertainty" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "OOD detection" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([200, 1, 28, 28])" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "images.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "ood_loader = torch.utils.data.DataLoader(\n", + " torchvision.datasets.FashionMNIST('./data/', train=False, \n", + " transform=torchvision.transforms.Compose([\n", + " torchvision.transforms.ToTensor(),\n", + " ]), download=True), \n", + " batch_size=batch_size_test, shuffle=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 9 2 1 1\n" + ] + } + ], + "source": [ + "dataiter = iter(ood_loader)\n", + "images, labels = dataiter.next()\n", + "\n", + "# show images\n", + "imshow(torchvision.utils.make_grid(images[:4]))\n", + "# print labels\n", + "print(' '.join('%5s' % classes[labels[j]] for j in range(4)))" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "f_all_expected_probability = []\n", + "f_all_entropy_of_expected = []\n", + "f_all_expected_entropy = []\n", + "f_all_knowledge_uncertainty = []\n", + "f_all_labels = []\n", + "with torch.no_grad():\n", + " for data in ood_loader:\n", + " images, labels = data[0].to('cuda'), data[1].to('cuda')\n", + " expected_probability, entropy_of_expected, expected_entropy = predict_uncertainties(ensemble, images)\n", + " knowledge_uncertainty = entropy_of_expected - expected_entropy\n", + "\n", + " f_all_expected_probability.append(expected_probability.cpu().numpy())\n", + " f_all_entropy_of_expected.append(entropy_of_expected.cpu().numpy())\n", + " f_all_expected_entropy.append(expected_entropy.cpu().numpy())\n", + " f_all_knowledge_uncertainty.append(knowledge_uncertainty.cpu().numpy())\n", + " f_all_labels.append(labels.cpu().numpy())" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "f_all_expected_probability = np.vstack(f_all_expected_probability)\n", + "f_all_entropy_of_expected = np.hstack(f_all_entropy_of_expected)\n", + "f_all_expected_entropy = np.hstack(f_all_expected_entropy)\n", + "f_all_knowledge_uncertainty = np.hstack(f_all_knowledge_uncertainty)\n", + "f_all_labels = np.hstack(f_all_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "f_all_predictions = np.argmax(f_all_expected_probability, axis=1)\n", + "\n", + "errors = (f_all_predictions != f_all_labels).astype(int)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.0517\n" + ] + } + ], + "source": [ + "print(f'Accuracy: {(1 - errors).sum() / errors.shape[0]}')" + ] + }, + { + "cell_type": "code", + "execution_count": 186, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/iv-provilkov/miniconda3/envs/unc1/lib/python3.7/site-packages/seaborn/distributions.py:2551: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n", + " warnings.warn(msg, FutureWarning)\n", + "/home/iv-provilkov/miniconda3/envs/unc1/lib/python3.7/site-packages/seaborn/distributions.py:2551: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n", + " warnings.warn(msg, FutureWarning)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 186, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(12,8))\n", + "sns.distplot(all_expected_probability.flatten(), label='MNIST', bins=40)\n", + "sns.distplot(f_all_expected_probability.flatten(), label='Fashion MNIST', bins=40)\n", + "plt.title(\"Distributions of mean likelihood in ensemble for all classes in two datasets\", fontsize=18)\n", + "plt.legend(fontsize=18)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/iv-provilkov/miniconda3/envs/unc1/lib/python3.7/site-packages/seaborn/distributions.py:2551: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n", + " warnings.warn(msg, FutureWarning)\n", + "/home/iv-provilkov/miniconda3/envs/unc1/lib/python3.7/site-packages/seaborn/distributions.py:2551: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n", + " warnings.warn(msg, FutureWarning)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(12,8))\n", + "sns.distplot(all_knowledge_uncertainty, label='MNIST', bins=40)\n", + "sns.distplot(f_all_knowledge_uncertainty, label='Fashion MNIST', bins=40)\n", + "plt.title(\"Distributions of knowledge uncertainty for two datasets\", fontsize=18)\n", + "plt.legend(fontsize=18)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### OOD Detection\n", + "\n", + "**We will use fashion-MNIST as OOD data**" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import roc_auc_score" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "y_true = np.zeros(20000)\n", + "y_true[10000:] = 1\n", + "knowledge_scores = np.hstack([all_knowledge_uncertainty, f_all_knowledge_uncertainty])\n", + "data_scores = np.hstack([all_expected_entropy, f_all_expected_entropy])\n", + "total_scores = np.hstack([all_entropy_of_expected, f_all_entropy_of_expected])" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ROC-AUC score with knowledge uncertainty: 0.864588025\n", + "ROC-AUC score with data uncertainty: 0.99998885\n", + "ROC-AUC score with total uncertainty: 0.99997749\n" + ] + } + ], + "source": [ + "print(f'ROC-AUC score with knowledge uncertainty: {roc_auc_score(y_true, knowledge_scores)}')\n", + "print(f'ROC-AUC score with data uncertainty: {roc_auc_score(y_true, data_scores)}')\n", + "print(f'ROC-AUC score with total uncertainty: {roc_auc_score(y_true, total_scores)}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calibration" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**It is usually useful to check the match of the real distribution of classes with the distribution of model probabilities.**" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/iv-provilkov/miniconda3/envs/unc1/lib/python3.7/site-packages/seaborn/distributions.py:2551: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n", + " warnings.warn(msg, FutureWarning)\n", + "No handles with labels found to put in legend.\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Calibration of our model')" + ] + }, + "execution_count": 165, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtcAAAHiCAYAAAAj0eDeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABx80lEQVR4nO3dd3ib1d3/8ffx3tsZ3k7i7BDIYiSBQBIg7LLKKAVKoXQ/3btPS9tfx9PdUigtlL1X2SNAyABC9l6OHc94721L5/eH5GCCEzuJ5Vu2P6/ryhVLuiV9ZcXxR+c+53uMtRYRERERETlxAU4XICIiIiIyXChci4iIiIgMEIVrEREREZEBonAtIiIiIjJAFK5FRERERAaIwrWIiIiIyABRuBYROQpjjDXGTPB+fbcx5iferxcZY4p9/NzXG2Pe8OVzHOF55xtj9hljmowxlw328/uSMeaAMWZJP47L8r73QYNRl4gMHwrXIjLsGWOuM8as94bFg8aYV40xC471cay1t1trf+GjGj8R5qy1j1hrz/XF8/XhDuDv1tooa+3zDjy/iMiQpXAtIsOaMeabwJ+B/weMBjKAfwCXDnIdgYP5fCcoE9jh6yfRqLCIDEcK1yIybBljYvGMwn7ZWvustbbZWttprX3RWvsd7zHzjDHvG2PqvKPafzfGhBzh8e43xvzysOt+aIyp8k43uP6wY+8yxrxijGkGzjbGXGiM2WSMaTDGFBljftbjoVZ6/67zjrCfboy5yRizusdjnmGMWWeMqff+fUaP21YYY35hjFljjGk0xrxhjEk6yvfmVmNMrjGmxhjzgjEmxXv9fmAc8KK3jtBe7jvF+3x1xpgdxphLDqvj8z0uH/4arDHmy8aYfcC+Xh67ewT/Zu/3qNYYc7sxZq4xZqv3Of/e4/gAY8yPjTEFxpgKY8yD3ve9+/YbvLdVG2N+dNhzBRhjvm+M2e+9/UljTMKRvmciIv2hcC0iw9npQBjw3FGOcQHfAJK8xy8GvtTPxx/jvV8qcCNwjzFmUo/brwN+BUQDq4Fm4LNAHHAh8MUec5rP9P4d552O8X7PJ/KGvpeBvwKJwB+Bl40xiYc9383AKCAE+HZvRRtjzgF+DVwNjAUKgMcBrLXjgULgYm8d7YfdNxh4EXjD+zxfBR457HX35TLgVGDqUY45FcgBPo3nzMOPgCXANOBqY8xZ3uNu8v45G8+Hgijg795apwJ3ATcAKXi+b2k9nuOr3lrO8t5eC9x5DK9DROQTFK5FZDhLBKqstV1HOsBau8Fa+4G1tstaewD4J56w1V8/sda2W2vfxRN+r+5x23+ttWustW5rbZu1doW1dpv38lbgsWN4rguBfdbah7y1PgbsBi7uccx/rLV7rbWtwJPAyUd4rOuB+6y1G73h+QfA6caYrH7UcRqeAPsba22HtfZt4CXg2n6+DoBfW2trvHUeyS+837M38HwoecxaW2GtLQFWAaf0eC1/tNbmWWubvK/lGu+UkyuBl6y1K72v8yeAu8dz3A78yFpb7L39Z8CVmq4iIidC/4GIyHBWDSQZY4KOFLCNMRPxjALPASLw/L+4oZ+PX2utbe5xuQDPCGi3osOe61TgN8B0PCPLocBT/XyuFO/j91SAZ9S8W1mPr1vwhOAjPdbG7gvW2iZjTLX3sQ70o44ia23PkHp4HX0p6vsQynt83drL5e7Xdvj3pQDPezi6u9buG6y1zd7X2S0TeM4Y0/O1uLz3FRE5Lhq5FpHh7H2gHc+p/yO5C88IcI61Ngb4IWD6+fjxxpjIHpczgNIel+1hxz8KvACkW2tjgbt7PNfhxx6uFE8Y7CkDKOlnrUd8LO9rSOznY5UC6caYnr8/etbRjOdDSrcxvTxGX6/1WBz+fckAuvCE8YNAevcNxpgIPK+zWxGwzFob1+NPmHd0XETkuChci8iwZa2tB34K3GmMucwYE2GMCTbGLDPG/M57WDTQADQZYyYDXzzGp/m5MSbEGLMQuIijj0RHAzXW2jZjzDw8c6S7VeKZsjDuCPd9BZhoPG0Fg4wxn8YzZ/mlY6wXPNNRbjbGnOxdsPj/gLXeaTF9WYtnVPy73u/lIjxTUx733r4ZuNz7vZ4A3HIc9R2Lx4BvGGOyjTFReF7LE94zFU8DFxljFhjPItU7+PjvvbuBXxljMgGMMcnGmEHtIiMiw4/CtYgMa9baPwDfBH6MJ8AWAV8Bnvce8m08IbcR+BfwxDE8fBmeRXClwCPA7dba3Uc5/kvAHcaYRjyh/8kedbbgWfy4xtsR47TDXkc1nvD+LTzTXb4LXGStrTqGersfazme+cfP4BndHQ9c08/7duAJ08uAKjxtDT/b43X/CejAM3L8AJ7viy/dBzyEp9tKPtCGZ6Ei1todwJfxnDE4iOe96rnxz1/wnEl4w/uefIBnIaWIyHEz1g7k2TkRERERkZFLI9ciIiIiIgNE4VpEREREZIAoXIuIiIiIDBCFaxERERGRAaJwLSIiIiIyQIbNDo1JSUk2KyvL6TJEREREZJjbsGFDlbU2ubfbhk24zsrKYv369U6XISIiIiLDnDGm4Ei3aVqIiIiIiMgAUbgWERERERkgCtciIiIiIgNk2My5FhERERE5Vp2dnRQXF9PW1vaJ28LCwkhLSyM4OLjfj6dwLSIiIiIjVnFxMdHR0WRlZWGMOXS9tZbq6mqKi4vJzs7u9+NpWoiIiIiIjFhtbW0kJiZ+LFgDGGNITEzsdUT7aBSuRURERGREOzxY93X90Shci4iIiIgMEIVrEREREZEBonAtIiIiIiOatfaYrj8ahWsRERERGbHCwsKorq7+RJDu7hYSFhZ2TI+nVnwiIiIiMmKlpaVRXFxMZWXlJ27r7nN9LBSuRURERGTECg4OPqY+1n3RtBARERERkQGicC0iIiIiMkAUrkVEREREBojCtYiIiIjIAFG4FhEREREZIArXIiIiIiIDRK34RI7g0bWFTpdwXK47NcPpEkREREYsjVyLiIiIiAwQhWsRERERkQGicC0iIiIiMkAUrkVEREREBojCtYiIiIjIAFG4FhEREREZIArXIiIiIiIDROFaRERERGSAKFyLiIiIiAwQhWsRERERkQGicC0iIiIiMkAUrkVEREREBojCtYiIiIjIAFG4FhEREREZIArXIiIiIiIDxKfh2hhzvjFmjzEm1xjz/V5uP9MYs9EY02WMubLH9ScbY943xuwwxmw1xnzal3WKiIiIiAwEn4VrY0wgcCewDJgKXGuMmXrYYYXATcCjh13fAnzWWjsNOB/4szEmzle1ioiIiIgMhCAfPvY8INdamwdgjHkcuBTY2X2AtfaA9zZ3zztaa/f2+LrUGFMBJAN1PqxXREREROSE+HJaSCpQ1ONysfe6Y2KMmQeEAPsHqC4REREREZ/w6wWNxpixwEPAzdZady+332aMWW+MWV9ZWTn4BYqIiIiI9ODLcF0CpPe4nOa9rl+MMTHAy8CPrLUf9HaMtfYea+0ca+2c5OTkEypWRERERORE+TJcrwNyjDHZxpgQ4Brghf7c0Xv8c8CD1tqnfVijiIiIiMiA8Vm4ttZ2AV8BXgd2AU9aa3cYY+4wxlwCYIyZa4wpBq4C/mmM2eG9+9XAmcBNxpjN3j8n+6pWEREREZGB4MtuIVhrXwFeOey6n/b4eh2e6SKH3+9h4GFf1iYiIiIiMtD8ekGjiIiIiMhQonAtIiIiIjJAFK5FRERERAaIwrWIiIiIyABRuBYRERERGSAK1yIiIiIiA0ThWkRERERkgChci4iIiIgMEIVrEREREZEBonAtIiIiIjJAfLr9uchw0dLRRUF1C0EBhpCgAGLCgomPDHG6LBEREfEzCtciR2GtZWNhHa9uP0hLh+vQ9QaYPyGJpVNHExyoE0AiIiLioXAtcgQ1zR08s7GY/KpmMhIiWDp1NEEBhg6Xmx0lDazOrWJPWSNXzk4jPSHC6XIPeXRtodMlHLfrTs1wugQREZETonAt0ou6lg7uW5NPS0cXnzo5ldlZ8QQYc+j2nFHRTEuJ4dlNJfxz5X5unp/N+OQoBysWERERf6BwLXKYLpebrz62ifrWTm5dkE1GYmSvx+WMjuZr5+Rw98r9PPZhIV9aNIEEzcMWkT7o7JLI8KbJoiKH+e1ru1m1r4pLZ6YcMVh3Cw8J5LOnZWItPPTBAdo7XUc9XkRERIY3hWuRHv67uYR/rcrnxtMzmZOVcOh643Ix8x+/Zdaf7yC4qeFj90mMCuXaeRlUNrbz5IZi3NYOdtkiIiLiJxSuRbzqWzv5+Ys7mZURx48vmnro+sC2Nhb84HamPfgPJj1xHxd9+hwy33wBeoToCaOiWDZ9LLsONrDhQK0T5YuIiIgfULgW8frrW/uobengF5dNP9ReL6S+jnO+eh1pq95k/bd+zmv/eZGWUWOZ/5OvcvbXbyC6MP/Q/c8Yn0h2UiSv7Sijqb3LqZchIiIiDlK4FgFyK5p44L0DXDM3g2kpsQBElJWw9AtXkLB7G6t/dSd7r7qJ2skzeOPfz7Pu23eQuGMzF3zmPKbf+xcCOtoxxnDpzBQ6uty8uu2gw69IREREnKBuISLAL1/eSXhwIN86d6Lnim3bOPfWTxHU2so7f3mIilmnHTrWBgay78obKVp0PrP+8ktO+tcfyXr9edZ95xcwdwELJyaxYk8lszLj1Z7vGKmLgoiIDHUK1zLivbO7ghV7KvnxhVNIigqFFSvg0kshNII3736K+gmTe71fW9Jo3vvF38i76Crm/t+PWfzV6zlw7qUEfuVHbC0O4b+bS/jaOTkEaQdHERHHDdUP7/rgPvTot76MaNZafvvabrKTIvns6Vnw1FNw3nmQmsob/37uiMG6p7JTz+SVh99g2y1fJ/2dV/nUdUu4o3QlNQ2tvJ9X7fsXISIiIn5D4VpGtBV7K9ld1siXFo0n5B9/h09/GubOhdWraRmd0u/HcYWFse3Wb/LKw69RM3k6F939S1554vuUvfs+LR1a3CgiIjJSKFzLiHb3iv2kRIdw+RN/g69/3TMd5M03ISGh7zv3ojFzPG//7VHe+9mfSW+o4Ol7v07qHT8iqLlpgCsXERERf6RwLSPWxsJaNuaW88DKfxD4+/+DL34Rnn4awsNP7IGN4cD5n+KVJ99h+fxLOG/5E1zw6XNIf/uVj/XGFhERkeFH4VpGrP+8upUHnvslOW88D7/8Jdx5JwQGDtjjd8bEkveL3/PpG39PRWg0C3/4Rc761s1Elg7NRTUiIiLSN4VrGZHyt+/ntv+9hdPyN8O998KPfgTGDPjzxIYHE3nWApZe9wfeuu37jNr8IRdeu5SpD9xJQGfHgD+fiIiIOEvhWkae3FxilixifE0xTU88DZ/7nE+f7sycZMLCQvhlznm8+NhySs84m5Pv+h3LblhG8qa1Pn1uERERGVwK1zKyrFuH6/QzMA0NPPSr/xBz5WU+f8qw4EDOmTKa/KpmNtsoVv/6blb84T4C29tY+sWrOfUX3ya0Vi37REREhgNtIiMjx6uvwpVX0hCdwFU3/Ir7b7l00J56XlYC7+VW8dr2MnJGRVM6fzEvzz6D6f/5G1Me/idpq95k01d+QN5FV0OAPvMORdqgQkREQOFafMxfAkf2S09x6q+/R824yVxywQ9InpDJqn1Vg/b8gQGG86aN4dEPC9lYWMvcrARcYeFs+eJ3OXDeZcz93Y847f99j3EvPcW67/6qX5vXiIiIiP/REJkMb9Yy9f6/c/ovv035rNP5+bf+TmlYHGdOTB70UqalxJCREMHyXeV0dLkPXV8/biLL73qS93/8e2IK9rPsxgs5+e+/JrC1ZdBrFBERkROjkWsZtozLxew//i8Tn3mIA+deyqof/o6338pj4ugoxsaeYC/r46nHGC6YPoa7V+axYk8F504b0/NG8i+6ipKFSzj5779m6sN3k7n8RdZ/8+eUnLl00GsVEemNv5yNFPFnGrmWYSmgvY35P/oSE595iJ3X38Z7P/sz60qbae5wOTJq3S0jMZJT0uNYta+Kisa2T9zeERvPhz/6HW/e/TSdEZGc9d3Ps/C7txJRVuJAtSIiInKsFK5l2AluqOecr99AxorX2PA/P2XzV3+EC8OqfZWkx4eTnRjpaH3LZowlOMjwwuZS7BF2bKw8eS6vPvgKm778A8auXcmF1y5h8iP3YLo6B7laERERORaaFiLDSkR5KYu+cSPRRQdY/Yu/U7j0YgC2l9RT29LJhTPGYnywWcyxiAoN4rxpY/jv5lK2FNdxcnp8r8fZoGB23XA7hYsvZM4f/pdZf/sV2a8+y7rv/YqqGbP7/Xwut2V/ZRObi+o4WN9KgDEEBhiiQ4OYl53IxNFRjn9PREREhguFaxk2YvP2suh/PktwcxPv/PkBKmafAYC1lpX7KkmOCmXy2BiHq/SYm5XAhoJaXt5WxqTRMYSHHHnb9eaUdN79/b2krXyD2X/4X8699XJyL72WzV/6Ph2xcUe8X5fLzcp9Vby/v4rmDhdhwQFkeUft3dZSXNfKrvcPMCo6lIU5yczKiFPIFhEROUEK1zIsJG/+kLO+cwtdoWEsv/tJ6nKmHrptX0UTB+vbuGJWKgF+Eh4DjOGyk1O5851cnt9cwjVz048ebI2h+KzzKJu7gBn//hOTnriPtJVvsOmrPyJ/2eWf2Lo9r7KJ5zeXUtXUzuQx0czJjGfi6GiCAj+aCdbldrOtuJ7VuVU8s7GYA1XNXHpKCkHqsy0iInLcFK5lyEt751Xm/+/XaRqbxjt/fpCWsWkfu/3dvZXEhAUxMz3OmQKPICUunHOnjeH1HWVkJEQwf0JSn/fpiohk09d+TP6yK5j7ux9y+h3fZNxLT7LuO7+kITuHji43L28rZd2BWhIiQ7jpjCwmjo7u9bGCAgI4JSOek9PjeGt3BW/vrqC2tYPr52UedSRdxF+oc4WI+CMNUcmQlvP0Ayz84RepmTSNN+955hPBuqimhfyqZhZMSPLLEdkzc5KYOjaGV7cf5EBVc7/vV5czhTf/+Qxrv/8b4nJ3seyGZYz7y6+5980drD9Qy5k5SXx9cc4Rg3VPxhiWTBnNlbPTKKhq4e6V+2lq7zqRlyUiIjJi+V/aEOkPaznprt8x9/c/pWT+Yt7+26N0xH5yYeC7eysJCw5gblaCA0X2zRjDlbPTiI8I4bEPC2loPYZuIAEB7L/sWl587C02nH4epz12N4/+9VZ+EVbM+dPHEhx4bD/eszLiuWl+FrXNHTy6toAut7vvO4mIiMjHKFzLkGO6Ojn1l99h+gN3knvptaz6zT9xhX1yU5jSulZ2Hmzg9HFJhAb77zSHsOBArj81k7YuF3ev3E9Z/Sf7Xx9JQ2sn9+xp4uozbudbX/wTUVHhfObntzP/R18ivKLsmGsZnxzFFbPSOFDdwn+P0ipQREREeqc51zKkBLU0s+BHXyLl/RVs/fw32H7L1z+xmK/bW7vKCQsOYEE/5jI7bUxsGLcuHMfDHxRw98r9XDM3ncljjtzZxOW2bC6q5ZVtZXS53Vx80lhOGTed16+9kCmP3MO0+/9GyvvvsuUL32bfFTdgg/r/oz4zPY6Kxnbe2VPB6OhQFuQ4t+mOiPiGy20prGmhqKaFotoWWjpcTBodzbSUGBKjQp0uT2RIU7iWISO0popF37qZ+D3bWfv937D/smuPeGxRTQu7yhpZOnX0kFmclxYfwRcXTeChDw7w0PsFhxYbjkuOPNTlpL3TxYbCWlbnVlHX0kl6fDhXzk4nOdrzy9AdEsqOm79KwdJLmPP7nzDnTz9j3CtP8+H3/h81U2f2u5bFU0ZR0djGq9vLSIkLZ1xylE9es4gMvsrGdh5fV8hB71myhMgQQoMCeG1HGa/tKCM1Lpyr53z0/4qIHBuFaxkSIksKOefrNxBeWcaq3/6LkoVLjnr88l3lRIQEcsa4xEGqcGDEhgdz28LxvLr9IJuL6thYWEt0WBCRIUHUt3bS2ukCIDMhgotPSmHSmOhe2ws2pWWy4k8PkP72K8z+088475ZL2XfFDWy5/Tt0RvXd6zvAGK6anc7f6vfx1IZivnZOzpD5kCIivbPWsqmwjhe2lBIUaLhqdhoTR0cTGeqJArUtHewobeDdPRX8Y0Uu18xNZ9JRzqCJSO8UrsXvxe/exqJv3ESAq4u3//5on7sT5lc1s6+iiWXTx/j1XOsjCQkK4NKTU7lgxlh2lzWyvaSeLrclMzGC6LBgxidHktmfLdyNoWjxhRw87Uxm/vMP5Dz9AOnvvMrG//kpBUsuPuJ0mp51fHpuOne/u5//binhmrkZA/QKB0ZFYxs7ShuobGynsrGdTpebiaOjmTI2hoyECAID/KOnuYi/eGXbQdbsryY7KZKr56QTGx78sdvjI0JYMCGJ6SkxPPxBAQ++X8C508ZwZk6SNpgSOQYK1+LXxqxdycIf3E57TDxv/fkBGrImHPV4ay1v7iwnOjSIU7OH1qj14YIDA5iRGsuM1NgTepyuyGg2fPNn5F1wBfN++0Pm/+SrjHvxSdZ/+xc0ZmQf9b5p8RGcM3k0y3eVM3lMHSf7Qa/w1g4Xb+0u54O8atzWM9qfHB1KBIG8n1fN6twqYsKCuHJ2OhNGaTqLCMB7+6tYs7+a08YlctFJY4+6oVZcRAi3nTmeZzcV8/qOMoICTL/68IuIh8K1+K2sV5/ltF9+h/pxE1nxx/tpTR7d5322FNdxoLqZS09OISRIzXB6qp08gzf+/TwTnnuEmXf9jgs+cx41k6bRGRlNV0QknZFRdEZEef6OjKLL+/V14ZGE1zWw7/V8Zpw1hYikBDojInGHhPY5+j3QthZ7Tmm3driYm5XA4imjiA77aPStvdPF3oomlu8q5z9r8jl78ijOmTzKb3bmFHHCroMNvLz1IFPHxvQZrLuFBAVw9Zx0ulyWV7YdJCkqlElj+u6bLyIK1+KPrGXKw//klDt/TdmcM1j1m3/2a55wS0cXL289SHp8uN/2tXaaDQxk35WfpWjReUy/769EFx0gpKGeyLISgpubCGppJrilCXNYC75zur/490fXuYKCPwrlkdF0RkTSdYSA3n1dV2QknRHR3tsjDwV7d3BIn7Wv3lfJK9vLSI8P59L5qaTEfbL9YmhwIDNSY5k4OooXNpfy9u4KDlQ3c8NpmYQGDb0pQiInqqSulcfXFZLiXaR4LB80A4zh6jnp/HPlfh5fV8jtZ41ndEyYD6sVGR4UrsW/uN3M/vMdTHryPxxYegkf/OT3nhHSfnhtexmtnS4uOyVVI5V9aEsazfrv/qr3G91uglpbCG5pJri50RO4mxspOlDO1t1FzE0IYkqUIbi5ieCWJk8o934dWldDZGkRwc2NnttbW/pVjysk1BvCIz8ZyiMi2dsawIQW+GFyPNMmpeHesMcb5CMPBfvO6JhDH8JCgwK5ak462UmRPL+5hEfXFnLD6Zl+uUuniK90utw8/mEhESFB3HB65nGdzQsJCuCG0zL5x4r9PPRBAV9eNEGLm0X6oHAtfiOgvY3T7/gmmW+9zO5rbmHj134M/QxD+VXNrC+oZWFOEmNjPzmiKccgIICuyCi6IqM+NhUneI5l74eF/PdgI7cvGk9qLyPHhzMuF0GtzYcCenBzsyd0HwrtPQK69+/u68KrKohuycdVX09aSzMXdrX3+Xw1k6ZTePYyis5eRmPmeOZ4z2A8u6mEZzeWcOXsNH3wkhHjrV3lVDd3cMuCbGLCgvu+wxHERYTwmdMyuWflfl7YUsKn/Wxxs4i/UbgWvxDcWM+Z372N0Zs+YONXf8Tu62/r933bu1w8v6mEuIhgFk/ue162HB9jDJedkkphzT6eXFfEl8+e0OdImA0MpDPKM6Lcythjfs7Xth9k5b4qFk1K5tycRIJbWw6F8cNHzcMry0ld8zYn3/1/nHz3/1E3biJFi84n7uxlNE4ZxZu7KogOC2LZ9GOvQ2SoKa5tYdW+KuZkxjP+KH3qYw7kkvLeO9ROmEL53PlHXEeRkdBjcfPYOmamxfmocpGhT+FaHBdeUcaib9xITMF+3vvZnzlw/qf6fV+3tTy5vpiqpnZunp+tRYw+FhHi6cJx35p8XttxkEtmpvrsuVbtq2TlvipOG5fA0imjwRg6g2PpjDly95Qdn/saEeWlpL37OunvvMa0+//OjPv+ysLUTN6ZtoD7SmexMfocZmVqTr4MXy635dmNJUf8MBlZUkjm8hfJXP4S8ft2Hrq+PnM8e6+6kfxlV9AV+clAftbEZPaUNfDfzSVkJUZ+opWfiHgYe9jCpaFqzpw5dv369U6XIYd5dG3hUW+Pyd/H2f/zWUIa61n5m3son7fgmB7/9R1lvLu3kotOGssZ49UqarC8vLWUNfurufH0TJ9sMrGhoJZnNhYzIzWWT889tkVYPYXWVJG28g3SV7zGmHVrCHB1cTA6ibLFy6g672KqTpqDDRzZ80evO3XonuLv6/+XkeqdPRW8ubOcG07LZMpYz89neMVBMpe/RObyF0ncuQWAyhmzKFhyCSULl5C8ZR2TnrqfxJ1b6IyIIu+CK9h71Y00Zo7/2GNXN7Xz17f3kZkQyU3zszTNahAM5Z/R4cwYs8FaO6fX2xSuxZeO9ssvaet6zvr253AHhbDiT/dTO2n6MT32psJantpQzLysBC49OUWbHAyiTpebu1bsp7G9i68vziEqdOBOgu062MAjawsYnxw1oIsQgxvqSXj7dXj2WRbkrSe0q5PW+CSKzzqXorOXUT77dGzQyBuJG8q/uBWuP6mioY2/vZPL1LEx3Dw+nPR3XiHzzRcZtWUdANWTZ1C45CIKFl9Ey9i0T9w/ccdmJj79ABnLXyKws4OD8xay96qbKD3j7EMfRD/Mr+H5zSVcPDOF0/1sF1yX29Le5SLAGMKG4CZivRnKP6PDmcK1OOZIv/xSV77B/J98hZZRKbzzlwdpTjm2/zw+zK/hxS2lZCZGcPP8bO3G54Cy+jb+sSKXnFFRfOa0zAH5cJNf1cx/1uQzNjaMzy3I9kn7vD1ljTz17i5ubdzN5flrSXnvbYJbW+iIjqF44VKKFi3j4KkLcYcOfssxt7WDPhI4lH9xK1x/nNtaHn91E7PWv8Nt5etJ2fQBAW43deMnUbD4IgqXXNznxlHdQmuqmPDfx8h59mEiKstoGpvGvituYP/F19AeE8v97x2goLqFry3OISGy71aavuK2ltyKJt7bX0V+VTOdLk+mCTAwPjmKk9JimTo2dkh3OBnKP6PDmWPh2hhzPvAXIBD4t7X2N4fdfibwZ+Ak4Bpr7dM9brsR+LH34i+ttQ8c7bkUrv1Tb7/8Jjz3CHP+78fUTJnJu3+4j/a4/s9/7XK7eXnrQdbm15AzKopr5mYM6f80h7o1uVW8vO0g500bw1kTk0/osUrrWvnXqjxiwoP5wsJxRAzgaPjhuhdKXjcvg5mJoYz5cBXpK14lbdWbhDQ20BkRSenpZ1N09jJKzzibroh+bDd/nDq63GwpqmPtgWpK69oIMBAUEEBseDBnTkzi5PR4n354HMq/uBWuPYKbGkhb+SYx/32Gids+INjtoiE9m4KlF1O45GLqx0087sc2XV2krXydiU89yOhNH9AVGsqBcy9jw8XX8dOCYFLiwrllQbYj00O2l9Tz5s5yKpvaiQ4NYnpaLJEhgYQGBdLY1sW2kjpqWzoJCQrgohljmZ0ZPyTPcA7ln9HhzJFwbYwJBPYCS4FiYB1wrbV2Z49jsoAY4NvAC93h2hiTAKwH5gAW2ADMttbWHun5FK7908d++VnLjH/9kRn3/ZWS+eew+pd34gqP6PdjldS18tLWUgqqW1iYk8R508Zovp/DPAtKi9haXM8Vs9KYnRl/XI9TUtvKf97LJzgwgC+cOY64CN+OhLnclrvf3U9NcwdfW5xzaGFWQGcHozZ+QPo7r5L27huE11bRFRrKwVPPonjR+RQvWHLUBZXHwm0tK/dW8u7eStq73IyJCWPy2Giw0OW25Fc1U1LXSmJkCEunjuYkH3VnGMq/uEdyuA5sbSF19VtkLn+RlPdXENjRTnHsKNbMWkz0jddTN2n6gO+gGrdvFznPPEj2a88R1NZK3qRT+OOkpQRdeQXzJo4Z0Oc6mk6XZ5DlwwM1jIkJY2FOEjPSYj8xhcxaS3FtK6/vLCOvspmpY2P41CmpRPrwg/tAMy4X10Y3wYwZTpcih3EqXJ8O/Mxae5738g8ArLW/7uXY+4GXeoTra4FF1toveC//E1hhrX3sSM+ncO2fun/5ma4u5v72h0x48Qn2X3w1H37v19ig/v0HV1rXytu7K9h5sIGw4AAumZnKyelxPqxajkWX282D7xeQV9nE9ad+tICqv/Krmnnw/QOEhwRyy/xsEqP6t2nQiapqbOdv7xx5YZZxuUjeso70Fa+RtuI1IisO4g4MomzufIoWLaP4zKW0JxzfItqm9i6eXFdEbmUTU8fGsDAniYyEiI+Nqllr2XWwgeW7KihraGPJlFGc44NWkwrXQ0dAexsp768gc/lLpK5eTlBbKy1Joyg850L+MWYOr0Vl8T9LJvr8w2lwQz3jXn6KiU8/SHRJAeVRCRy44jOUXH0DbYmjfPrclY3tPPZhIWUNbZyZk8TSqWP6PLPjtpY1uVW8sbOciJBAbjojy6/3QwhqbmTs2pWkrn6LlPfeIayxHioqIEFdjvyJU+H6SuB8a+3nvZdvAE611n6ll2Pv5+Ph+ttAmLX2l97LPwFarbW/P+x+twG3AWRkZMwuKCjwyWuR4/fo2kICW1tY8OMvk7rmbbbf/FW23vatPkdUmtu72Fpcx6aiOoprWwkLDmD+hCTmj08aNotUhpP2Thf/Xp1PeUMb187L6HfA3n2wgUc/LCQ+IoTPLcge9NZe3QuzLpgxlgUTjhKU3W4Sd24h/Z1XSV/xKtElhbgDAqicOY+is8+naNH5tI7qX//sgupmHv2wkNYOFxfPTGFOH6eq3dbyzIZiNhXVcfakZJZMGT2gp7YVrv1bQGcHY9atJvPNF0l79w2CW5poi0ug6OwLKFh6MZUz57KhuIGnNxZzycwUThvMBYZuNzErlhN97z85a/96XEHBFJ2zjL1X3UTV9FkDPnJeVNPC/e8dwBi4anY6k8ZEH9P9D9a38uD7BXR0ubl5fhZp8f0/c+prkaWFpK56i9TVyxm1aS2BXZ20x8RSevrZZN98DVxyCYT77weCkWjYhuueNHLtn555fTNnfetzJOzawvpv/4Lcyz9zxGM7XW52lzWyqbCWveWNuC2MjQ3j5PQ45mQmaG61n2tq7+I/a/I5WN/GqdkJLJs+9oh9x1s6unh1exkbCmpJiQvjpjOyB7TjSH9Za3n4gwL2VjTxpUXj+zeaZS1xubu8Qfs14vL2AlA17RSKzj6fwrMvoDm198C6r6KRhz8oICYsmOtOzej36JnbWp7fVHJoF9Lzp40ZsICtcO1/TFcXozZ9QOabL5K+4jVCG+roiI6haNH5FCy5mPLZZxw689fY1smfl+9jVEwoty4c58hUuS3Fdax9/QN+cOAdzn7vZUKaG6mZNJ29V91IwZJLcIWd+OLgvMomHvyggMiQQG5ZMO64F1HWNHdw7+o8Wjpc3HRGFpmJvltPcTTG5SJx+0ZSV79F6pq3Dv0/Up85npIFSyhZsJiqGbOxQUFD+md0ONO0EHFGfj4Ni5YQUV7Ce3f8jeKzzuv1MLe1fJBXzVu7KmjtdBETFsTM9DhOSY9nTOzgd2yQ49flcvPGznJW51aRHB3KWTnJjEuOJC4iBLe1VDW2k1fVzFu7ymntdLFgQjLnTB7l6OY/Te1d/O3tfYQEBvDlsycc85mR6IL9h4J24u5tANRMnErxovMpPHsZDdmexWR7yhp4ZG0hydGh3Dz/2D9MuK3lxS2lrM2v4fJTUg9t7X6ihvIv7mEVrt1ukreuJ3P5i6S/9QrhtVV0RkRSvHApBUsvoezUhbiDPxkoH11bwO6yRr56Tg7J0YMzpao3T28oZlNhLV+cM5pF695g4tMPEJe3l7bYePZfcg37Lv9Mr63/+qP7DFdCZAg3zz/xM1z1rZ38e1UejW1d3Dx/8AJ2UHMjYz9YSeoa73SPuhrcgUFUnDKPkvmLKVmwhKb0rE/cbyj/jA5nToXrIDwLGhcDJXgWNF5nrd3Ry7H38/FwnYBnEeMs7yEb8SxorDnS8ylc+6EvfIH2x5/g3f+7l6qZc3s9pKy+jec2FVNU20rOqCgW5CQxPjlKCxWHuH0VjTy7sYT61k4A4iKCaet00dbpBiAtPpxPnZLqN/Me86ua+feqPKanxnLN3PTjHhWOLC0ifcVrpL/zKsnbNgCekahNc8/hj1HTqZ44jZsXZBMRcnyj9G5r+c+afAprWvjSogmMjtGHz8HmtpYdpQ3sOthAS0cXLR0uDDBxdDRTU2IYExPW/38/1pK4cwsZ3t0SIyrL6AoNpXT+YgqWXEzpGeccddR3e0k9j35YyHlTR3PWJN/Ode5Le6eLv7+TS5fb8tVzJhARHMioje8z8akHSFv5BgAlC5ey98rPUj7nyNusH25LUR1PbShibGw4N52RNWCLERvbOrlnZR7NHV3ctnC8zwZyIksKPaPTvUz3KFmwhIOnnUln9NEXSStc+ycnW/FdgKfVXiBwn7X2V8aYO4D11toXjDFzgeeAeKANKLPWTvPe93PAD70P9Str7X+O9lwK136orY0XX1x7xL6qW4vreHJ9EWHBgVx0Ugoz02KHZJsk6Z3bWsob2sirbKagupmIkCDSE8JJi49gVHSo373X7+6p4PWd5QM2bzW8spy0d18n/rUXydqxniDrpmFsOiVnn0/R2cuomnYKHMcGOY1tnfz17VwiQwL58tkTCA50btR/JHFby87SBt7e7VlgGh0aREx4MBEhgbR3uSmqacECSVGhLJs+5sjrDrzTijLffJHM5S8SVVqEKyiYg6cvomDJRZQsWNLr1uOH6/53EBMWxJcWTfCLXv/FtS3889080hMiuHl+1qF/mxFlJeQ89wjj//sYYXU11GdNYO+VN5K/7PKjvta1+dW8sLmUrKRIbjgtc8DX29Q2d/DPlfuxwBfOHD8g/bo/Nt1j9XLi8vcBPaZ7LFxC1fRZh6b1NLV3YeCoHxoUrv2TNpERxxzptO3+yibuX3OAtIRwPnNq5pBqjSTDk9taHnq/gNzKJm5dkE3GAJwq3lRYy9MbipkR1sl32/eQvfJ1xny4msCuTlqSR1N81nkUnr2Mypnz+t09B2BveSP3v3eAeVkJXHZK6gnXKUfX6XLz+IeF7CprJCkqlMWTRzEjLfZjZ9ga2zrZfbCRNfurqGhsZ/KYaC46KeVQYIvJ30fm8pfIWP4isQX7cQcGUjZ3AYVLLqLozPOOqcWj21ruW5NPkR+ewdhSVMcT64uYnhLDNfMyPvY9CmhvI3P5S0x86n4Sd2+jIzKa/AuvZO8VN3xsm3VrLe/ureSNneVMGh3Ndadm+OxDZHlDG/eszCM8JJAvnDmO6LBjn3LSPd0jbfVyxr73DmH1tR9N91iwhJL5iw9N97DWsq2knu2lDRTXtlDX0kmAgaljYzh1XCLjkiI/MfCgcO2fFK7FMb2F6+7NQuIigrlt4XgtVBS/0dLexV3v7h+QU8XrD9Tw3KYSspMi+ezpWYfmlQc3NZC6+i3SVrxGyvsrCGpvoy0uwbM75NnLKJ87v9e5tYd7bXsZK/dVcuPpmUwac2ztD6X/2jpdPPRBAQeqmlk2YyxnjE886rQ1l9vy3v4q3tpVQVptKd+q3cwZ65cTn7sbawwVp5xKwdJLKFp0Pu3xx3eG5O3dFSzfVT6gc+8H0qp9lby6vYzTxydy0YyxnzxLZS2JOzYx8akHyHjrZQK7Ojl46pnsueomCuedyXNby9hUVMdJabFcNTvd56PyRTUt3Ls6n4TIEG5dOK5fv5MiSwpJW72c1FXLSd78oXe6RxylZ5xNyfzFvU73KG9o44UtpeRXNRMbHkxGQgRp8eE0tnWxoaCW1k4XGQkRfG5+9sfWoShc+yeFa3HM4eG6rqWDu1bsJyDAcPtZ4we99ZpIXw6dKrZw25njjrnvtrWW5bsqeGdPBTmjorj+1MwjLtgMbG0h5f0VpK94ldTVbxPc0kRHVAwl88+hcPFFlCxYfMSpI11uN397O5cul5uvL57o6KLQ4aqpvYv71+RT1tDGVbPTmdmP/voR5aVkLH+J1DdfZPTurQDszp5O/SWXU7rkIlqTT6xXeff6gJnpcVw1O83vpld1e3lrKWv2V3NqdgIXzBh7xJHnsOpKxv/3MXKee5iIynJKEsbyn5nLqLjiWk6dnTNor29fRSMPvldAWnw4Nx8WbsEz3SNp20ZSVy8nZc1bH033yJrwUXePHtM9enK5LW/vLufdvZWEBgVy3rQxzMmK/9iHtE6Xmw0Ftby4pZRpqbFc22Pth8K1f1K4FsccHq4fWVvAvvImvrhovF+dyhTpqaKhjXtW5REaFHBMbb86XW6e3VjMluJ6ZmfGc+nJKZ/YNe5IAjraGbNutWd3yJVvEtpQR+2EKWy5/TuUzj+n1wVg+VXN/GtVHmdNTOa8aYO3Q95I0Oly869VeZQ3tHHdvIyjnh0Iq64g4+1XyHjzRUZt9fweqp48g4LFF/F49mk8VRlIUnQo183LOKH/9yob2/n3qjxCggL4ytkTCPXjnv9ua3l9exmrcqsYExPGNXPTGXWE1+5yW9bnlhPw3/9y7YcvMK9oO12hYRw47zL2XnUjdTlTB6XmbSX1PP5hITmjo/jMaZmEtzQd6u7x8ekep1KywNvdIy3zqI/Z2NbJ4+uKyK9qZlZGHMumjz3qNMiVeyt5bUcZS6eO5mzvIlWFa/+kcC2O6Rmuu4PAkimjOWeysyvbRfpSUtvKvWvysBYuPimFUzLijjqKVlTTwgtbSimpa+W8qaM5c2LycY+6ma4uMt56iZP+9UeiiwuonDGLLbd/l4rZp3/i2Kc3FLO5qJavnpOjD6wD6LlNJaw7UMP1p2YwLeWT86FD6mtJf+c1Mpe/wKiNHxDgdlM3fhIFSy6mcPFFH1vIvb+yiSfWFdHe5eLSmanMyow/5nqqGtv51+o83G7L5xeOGzLv9Z6yBp7aUEyny83szHgmjo5mXFIUxng+LJTWtbJyXyVVTR1kJ0Vy8UkpTK7IY+LTD5L12nMEtbdRcfI89l55I0WLzsMG+fZsZ94HW3C9+CIXF27g5LytBLi6Ppru0d3dI6p/07Dyq5p5fF0hbZ0uLjs5lVMy+n7frbU8taGYzUV13HCaZ8dbhWv/pHAtjukO125ruWvFfprau/jGEp3ClqGhtrmDpzYUcaC6hWkpMZwzeRSjY8I+djq3rqWD5bvK2VhYR3RoEBfPTGF6av8Xpx2N6epk3EtPMePevxBRWcbBuQvYevt3qJ528qFjmtu7+OObex3dRGS4WX+ghmc3lfR6RiBx+0amPnQ3qavfIsDVRUN6NgVLL6ZwycXUj5t4xMfsOYI5OzOeC2eM7Xf3i6omz4i1a4gF624NrZ28tO0ge8oa6HRZAo3BbS3d6SM5OpRl08YwaUz0xz6QhtTXMe6lJ5n4zINElRbRkjya3E9dT+6l1w7YNuumq4ukHt09Yg/kArAvMZ21084g+spP0TJ7Hjaw/2cJ3Nbyzp4K3t5VQUJkCNefmnlM6zc6XW7uWZlHdXM73z1vMp9b0HvHLXGWwrU4pjtcbyqs5akNxVw1O61fn95F/IXbWlbvq+LNneW4rCUyJJDs5Cg6u9wcrG+loa2LwADDgglJLJqY7JNT9QHtbeQ8+zDTHriTsLoais46j623fYv68ZOAj8LgFbPSmH0co6LykZLaVv65cj9ZiZHcND/L82HFWsZ8uJqpD97JmA3v0x4Ty/6Lr6Hg3EuonTit3z2b3dby1q4KVuypICo0iHOnjeGUjLgjfiByW8umwjpe234QC3x+4TjGDLFg3VOny82B6mb2VzQRHBjAqJgwkqNDGRUdetQPhcblYuz7K5j49AOkfPAurqBgChdfyN6rbqR62inHvM16cFODZ7rH6uWkvPcOoQ11H033WOjp7rEhKJ5HPywkKjSI6+Zlkhrfv578dS0dPLne84H85PQ4LpmZclwtBItrW/jHiv0smz6Guz4z+5jvL76ncC2OeXRtIR1dbv60fC9RoUF8cdF4jazJkNTQ2kluRRP7K5vIr24mLCiQsbFhjIkNY1pK7ID0yO1LUHMTk5+4l8mP/IvgliYOnHcZ2z7/DRpSM7wjXR18c8lEdeA5Th1dbv729j663JavnD2ByOAA0la+wbQH7iRx11Zakkax+9pbyb3sun71oj6S4toWXtp6kMKaFlLjwpmdGU/OqCgSIkMwxtDa4aK0vpXXd5RRXNtKenw4l89KG3Ij1r4QXbCfic88xLiXniK4pYnqyTPYe9VNFCy5CHfokb8/UcUFpK5e7t3M5UMCXF20xcZz8IyzKV6whLJTF35iukdRTQsPf1BAU3sXc7MTOHfq6CNuANXc3sWqfVV8kFcNBi6dmXLCA0n/WpVHTXMH63+8RP3s/ZDCtTjm0bWFrM6t4pVtB7l14TiykwZnm1mR4SykvpapD93NxKf+Q0CXi/2XXMPyK27ld9saOW18IheflOJ0iUPSK9sOsjq3iltPS+OcTW8z9cF/EHsgl8a0THZ+5ovkX3A57pCB2WLcWsuW4nqW7yqnprkDgJiwIDpdltZOFwDRYUGcP20MM9OPPLo9UgU1N5H96rNMfPoBYg/k0haXwP5Lr2Xfp66nZUzqR9M9VnkCdWzBfgDqsnMoWbCE0vmLqZoxq8/pHm2dLpbvKueDvGrCggOZlhJLRkIE6fHhtHe5qWhso6SujY2FtXR2uZmRFsvSKaOPuctQb/aUNfDA+wX88eqZXD7r+LaOF99RuBbHPPJBAX95ax9hwYHcftb4vu8gIv0WXlnOtPv/xoTnH8MdFMgrZ17BzyZfyPUXzfabreWHioLqZh54axffKX2PT694gqiyYmrHT2bnjV+i8JwLj2mTn2NhraW6uYPciiYOVDcTFhxIYmQICZEhTEiO8uuOIH7BWkavX8PEpx8kddWbAFTOnEfc/t29Tvfoq7vHkRysb2X5rgryq5po63R/7LagAMOUsR+tyRgo1lr+8tY+EiJDePXrC/227eJIpXAtjvntq7u56939fOqUVOb64WYHIsNBZEkhM+79M9mvPktzcBhPnXU1Ed/7Nq5+djUY8errqP6/v3Dd+8+S2FxH5YxZ7LjxK0dsgSj+KeJgMTnPPULqqjepnTzjiNM9ToTbWiob2ympbSU8JJBR0aHER4b47MzChoJantlYzAOfm8dZE5N98hxyfBSuxTFX3f0em4vq+MGyKce1qENE+i82by9pf/41Mz98m+boOPbc9GX2XfFZXGGaq9ub0JoqJj1xH9lPPkBkaxO5p8znwK1fo+KUUxWqxS90ud3c+U4uE0ZF8cjnT3O6HOnhaOHaN+e5RICWji62FtczIzVOwVpkENSPm0jtX+7jrw+9zOdev5f5f/sVkx//N9s/93X2X3y1z3sEDxURZSVMeeQexr/wOIEd7byWczorLr+FmZctcbo0kY8JCgjghtMy+f0beymubSEtPsLpkqQfFK7FZ17dVkZ7l1utwUQGUYAxTLzoHK6PzuRWVwG3vX4f8377Q6Y8fDfbbv0mBUsvOaaevcNJdMF+pj50F9mvPgdA3nmX8ZNJF7A9OoX/WXLkHtUiTrpgxlh+/8Zelu8s56b56nk9FKi3i/jMk+uLSIwMIStRn7RFBlN6QgRzMuO5NyiTh3//CCv+cB9dEVGc8bP/Ydlnl5G68g0YJlMC+yN+9zYW/PCLXHTNYjLffJF9l3+GF55ZyR+v/T7vh4ziopkpal8ofmtcchTjkyN5c1e506VIP2nkWnziQFUza/NrOHfqaK1wFnHAudPGsL20nhe3HWTU/HMoPf1sMt56mZPu+QNnffdWqqaezJYvfofyuQucLtU3rGXUprVMffAfpHzwLh1RMez47JfY8+nP0Z6QRG1LB29+uJfJY6KZnqKFn+Lflk4dw79W5VHf0klshKZ3+TuNXItPPLephACDdmMUcUhUaBBLp44hr7KZzUV1EBBA4dKLefmx5Xzww98SXl3B4q9ezzlfuZbE7Rt9UoO1lvZOF1VN7VQ0tuEejNFya0lZ/RZLb7uCJV/6NPF7drD5S9/jv8+vYesXv0t7QhLWWl7YXIrBcMnMFA0AiN87d9poXG7Pturi/zRyLT7xzp4KTsmIJzZcn7BFnHJqdgJbiup4cWsp2UmRxEWEYIOCyLvkGg6cdxkTnn+M6ff/jfM+/ymKFy5lyxe+Tf2EySf0nF1uN7sPNrK+oIb8qmY6XR8F6rDgADISIhifHMXcrIQBXehsurrIePtlpj54F/G5u2gek8q6b99B3kWf/kS3lE2Fdewpb+Sik8YSF+H7nTVFTtTJaXEkR4fy5s5yLjsl1elypA8K1zLgqpra2Vpcz7eWaoGQiJMCjOHqOen89e19PLWhmFsWZB/qx+sODWPvp28m7+KrmfTEfUx55B4uuOF8CpZewtZbv0lTetYxPZfLbVm9r5LVuVU0d7iIDQ9mTlYCceHBRIUG4baWwpoWCqpbeHV7Ge/urWTRxGROHZd4Qls7B3S0k/3Ks0x9+C6iiwuozxzP+z/9IwfOvaTX7ij1rZ28tK2UrMQIThuXeNzPKzKYAgIMS6aM4oXNpbR3uQgN0hoBf6ZwLQNu1b5KAM6alMz2kgaHqxEZ2RIiQ7j4pLE8s7GE1fuqOPOwjSi6IiLZcfNX2Xf5DUx55J9MeuI+Mt56if0Xf5rtn/saraPG9vkcB+tbeWZjMaV1bUwaHc3p4xOZMCrqExtrzM70bCRVXNvCGzvLeWV7GWv2V3P1nHSykyKP6XUFtTQz4flHmfzYv4ioLKd6ykms/M0/KT7zXAjoPaxba3l+Uwkut+XyWWnaUlyGlKVTR/PYh0W8v7+aRZNGOV2OHIXCtQy4FXsqSYoKYXpKrMK1iB+YlRHP7rJG3txZzrjkyF575XbExrHlS99jz6dvZtp//s6E5x9l3CvPsPeKG9j52S/RHv/JUd4ut5t391SyYk8lYcEBXDsvgxmpsX3WkxYfwefmZ7O/son/bi7h36vyWDxlNIsmJfcZeEPq65j41P1MevI/hDbUUTb7dD748R8om7egz41fNhd5poNcOGMsSVGhfdYp4k/OGJ9EREggb+wsV7j2c1rQKAPK5bas3FvJmTnJBARoVEjEHxhj+NTJqUSHB/HAeweoamw/4rFtiaPY8O07eOnJdziw9BImPXEfl1yxkBn/+iPBTR99WC6ta+WuFft5a3cF01Jj+J8lE/sVrHsanxzFlxdN4KS0WJbvKuf+NQdobu/q9djwynJO+esvufSy0znp33+icuZcXv/3c7x95+OUnbqwz2Bd1dTOC1tKyUiI4PTxmg4iQ09YcCBnTUxm+c5y3O6R00pzKFK4lgG1raSe2pZOzpqU3PfBIjJoIkKD+NwZng0o7luTT11Lx1GPb05JZ+1Pfs8rj7xB6emLmHHvX7jk8oVMevAu3t10gH+syKWprYvPnJrJNXMziAw9vhOhocGBXD0nnctPSeVAdTP/WJFLWX3bodujiguY+5sfcMnlC5j0+L0Un3kuLz/yBiv/799UT5/Vr+fo6HLzyNoCAozh03PTNR1EhqyzJ4+iorGd3Momp0uRo9C0EBlQK/ZUYAwszFG4FvE3SdGh3Dw/m3+tyuM/aw7w+YXZRIcdvaNPQ3YOa371D3besI2Jf/8ts//xG+6IuodTLryZkNs+T1jkiW8SZYxhTlYCo2PCeHhtAXev3M9Xk1q5+NUHyFj+EjYwiLyLrmbnZ75Ac2rGMT22tZbnNhVT0dDOTWdkEa/uIDKEzcvyrFtYd6CGiaOjHa5GjkQj1zKg3t1bycy0OBIi9QtMxB+lxIXz2dOzqG3p4K9v7WNrcR22j/7TjW2dPNyRyJLF3+Omm35PW3oWtz/xB66+4VyyX3kG43INSG3pCRH8PLmB+579BV/9xhWMWbmc3dfeyn+fW8267/3qmIM1wPt51Wwprmfp1NHkKIzIEJeZGEFSVCgbDtQ6XYochUauZcDUNnewuaiOr52T43QpInIU2UmRfOnsCTyzoZjH1xWxraSesyYmMzY2nEDvWgm3tVQ1tvNBfg3rD9TgcltmZ8az8MLLWfOFK8n74F1m3vU7Tr/jm0x56C623vYtihed3+fc515Zy5gPVzHtgTsZvfED2mLieOSCz/G7CUvJyknj8vhkjqdj/tr8al7eepApY6I/0SVFZCgyxjAnM551BTVOlyJHoXAtA2ZVbhXWwiLNtxbxe2Niwrj9rPGszq3irV3l7ChtIDjQkBIXTpfLUtHYRqfLEmgMp2TEcdbEZBJ7dNg4ePoiDp56JukrXuWkf/6BM39wO9VTTmLL7d+hbF7fCwwBcLtJX/EaUx/8B4m7t9GSPIYNX/8J+y+9FsIjOHVvJW/sLKe6uYNPz0n/2PP35d09Fby+s5xJo6O5Zl6G5lnLsDEnK57XdpRR3tDG6Jiwvu8gg07hWgbMmn1VxIYHc1JanNOliEg/BAYYzpqYzKyMOPKrmimsaaG4tpWw4ADmeedATxgVdeRdDAMCKDrnQorPPI+s157jpH//iXO+fgPlp5zGli9+h6qT5vR6N9PVSdZrzzP1obuILdhPY1oWa3/wG/KXXY47xBOgDbBo0ihGRYfx1IYi/vLWPs6ePIqFOUkEHaGPNXgWL76509M/+6S0WK6anX5oNF5kOJjrnXe9/kAtF57Udx96GXwK1zJgNhTWMjszXr/IRIaY6DDPh+Lj/WBsg4LIv+gqCs69hAn/fYxp//k75952BSXzz2HLF75N3cRpAAS2tTL+hceZ8ui/iCwroTZnKqt/8XeKzrkAG9j7jnNTU2L4RvxEXtpayps7y9lcVMfp4xKZMjaG2PCPJot0utx8mF/Dir2VNLd3cdq4BC46KUUj1jLsTE2JITw4kHUHahSu/ZTCtQyI+pZOciuauOzkFKdLERGHuENC2XvVTey/6GomPXU/Ux+6iws+ewEFSy6mflwOE596gLDaaipOmsO67/6S0tPP7tf0kZjwYK47NZPdZQ28ur2MF7aU8sKWUlLjwgkKMDR3dNHQ1kVHl5txyZEsnZJBZuKx7fgoMlQEBwZwcnoc6zXv2m8pXMuA2FjkWbk8KzPe4UpExGmu8Ah2fvZL7PvU9Ux55B4mPXEfmctfpPS0s9hx01eoPHnecT3u5DExTBodTWVjOzsPNrC3vIkAA2Njw5kwKpBpKbGMT44a4Fcj4n/mZsXz93dyaWrvIuo4e8yL7+gdkQGxqaCWAAMzNd9aRLw6o2PZevt32HPNLQQ3NtCUnnXCj2mMYVRMGKNiwrQFtIxYs7MScFvYXFjHgpwkp8uRw6jPtQyIjYV1TB4Tc9y7tInI8NUelzAgwVpEPGZlxBFgPJvJiP9RuJYT5nJbNnkXM4qIiIhvRYcFM3lMDBsKtJmMP1K4lhO2t7yR5g4XszLjnC5FRERkRJiTFc/Gwlq6XG6nS5HDKFzLCdtY6PnkPDsjweFKRERERobZmfG0dLjYW97kdClyGIVrOWEbCmpJigohPSHc6VJERERGhGkpsQDsPNjgcCVyOIVrOWGbCus4JSMeo80aREREBkV2UiRhwQHsLFW49jcK13JCapo7yK9q1mJGERGRQRQYYJg8JoYdpfVOlyKHUbiWE7LRu1J5VobCtYiIyGCalhLDzoMNWGudLkV6ULiWE7KxsJagAMNJabFOlyIiIjKiTE2JobGti+LaVqdLkR4UruWEbCupZ9KYaMKCA50uRUREZETpXtS4Q/Ou/YrCtRw3ay07SxuYlhLjdCkiIiIjzqTR0QQY2Kl5135F4VqOW2VjO9XNHUwZq3AtIiIy2MJDAhmfHKV2fH5G4VqO2w7vD/NUhWsRERFHTE2J0bQQP6NwLcetu7fmFE0LERERccS0lBgO1rdR09zhdCnipXAtx23nwQbSE8KJCQt2uhQREZERaepYz6LGXZoa4jcUruW47TrYoCkhIiIiDprqPXuszWT8h8K1HJeWji7yq5q1mFFERMRBCZEhjI0N0zbofkThWo7L7rJGrNViRhEREadN06JGv6JwLcel+xPyVC1mFBERcdTUsTHsr2yirdPldCmCwrUcp50HG4gJCyI1LtzpUkREREa0qSkxuC3sKWt0uhRB4VqO087SBqaMjcEY43QpIiIiI1rO6GgAciuaHK5EQOFajoPLbdlT1qgpISIiIn4gMyGC4EDDPoVrv6BwLcfsQHUzrZ0uLWYUERHxA0GBAWQnRWrk2k8oXMsx02JGERER/5IzKprcCs259gcK13LMdh5sICjAMGFUlNOliIiICDBhVBSFNS3qGOIHfBqujTHnG2P2GGNyjTHf7+X2UGPME97b1xpjsrzXBxtjHjDGbDPG7DLG/MCXdcqx2X2wgQmjoggNCnS6FBEREcETrt0W8quanS5lxPNZuDbGBAJ3AsuAqcC1xpiphx12C1BrrZ0A/An4rff6q4BQa+0MYDbwhe7gLc7bV9F0aGWyiIiIOC9ntOdsshY1Os+XI9fzgFxrbZ61tgN4HLj0sGMuBR7wfv00sNh4ertZINIYEwSEAx2Ath7yAy0dXRTXtpKjKSEiIiJ+IzspkgCjdnz+wJfhOhUo6nG52Htdr8dYa7uAeiART9BuBg4ChcDvrbU1PqxV+ml/hed0k8K1iIiI/wgNCiQzMVKLGv2Avy5onAe4gBQgG/iWMWbc4QcZY24zxqw3xqyvrKwc7BpHpNxKzw+tFjOKiIj4lwmjothXrpFrp/kyXJcA6T0up3mv6/UY7xSQWKAauA54zVrbaa2tANYAcw5/AmvtPdbaOdbaOcnJyT54CXK4feVNBAUYMhMjnS5FREREesgZFcWB6mY6XW6nSxnRfBmu1wE5xphsY0wIcA3wwmHHvADc6P36SuBta63FMxXkHABjTCRwGrDbh7VKP+VWNJGVFElIkL+e9BARERmZJoyKotNlKahucbqUEc1nCck7h/orwOvALuBJa+0OY8wdxphLvIfdCyQaY3KBbwLd7fruBKKMMTvwhPT/WGu3+qpW6b/ciiYmJGtKiIiIiL/JGeXp5KV5184K8uWDW2tfAV457Lqf9vi6DU/bvcPv19Tb9eKs9i4XB6qbufCksU6XIiIiIocZP8ozZVMdQ5ylc/vSbweqWnBbLWYUERHxRxEhQaTGhavXtcMUrqXf9lWoU4iIiIg/yxmtjiFOU7iWfttX3oQxMF5zrkVERPxSzqgo9lc24XJbp0sZsRSupd9yK5vISIggLDjQ6VJERESkFxNGRdHe5aakttXpUkYshWvpt9zyJu3MKCIi4se6p252b/omg0/hWvqly+Umv6qZ8QrXIiIifivLu8lbfpV6XTtF4Vr6pbCmhQ6X+1APTREREfE/CZEhxIQFcaCq2elSRiyFa+mX7rY+mhYiIiLiv4wxZCdFcqBa4dopCtfSL90N6TUtRERExL9lJ0WSV6lw7RSFa+mX3IomUmLDiAr16aaeIiIicoKykiIprW+lrdPldCkjksK19Mv+yiaNWouIiAwB2UmRWOtZLyWDT+Fa+mStJb+ymXFJkU6XIiIiIn3ITuruGKKpIU5QuJY+VTV10NjedeiHVURERPxXlsK1oxSupU/dP5xZCtciIiJ+LyYsmKSoELXjc4jCtfSp+4dzXJLmXIuIiAwFWYmR5ClcO0LhWvqUV9VMcKAhNT7c6VJERESkH7KSIjVy7RCFa+lTflUTmYmRBAYYp0sRERGRfshOiqSisZ2m9i6nSxlxFK6lT/lVzVrMKCIiMoR0/97W6PXgU7iWo3K5LQeqWxSuRUREhhC143OOwrUcVWldKx1dboVrERGRISQrUSPXTlG4lqM6UO35oVS4FhERGTrCQwIZExNGfrXC9WBTuJajyj/Uhk/hWkREZCjJTorUtBAHKFzLUeVVNhMZEkhydKjTpYiIiMgxUDs+Zyhcy1HlVzWTlRSJMWrDJyIiMpSMS4qktqWTupYOp0sZUfoVro0xzxpjLjTGKIyPMGrDJyIiMjRlqWOII/oblv8BXAfsM8b8xhgzyYc1iZ9o73JRXNui+dYiIiJDUHZSBPBRcwIZHP0K19ba5dba64FZwAFguTHmPWPMzcaYYF8WKM4pqmnBbSE7WeFaRERkqEmL94TrwupWhysZWfo9zcMYkwjcBHwe2AT8BU/YftMnlYnj8qtagI96ZYqIiMjQERbsacdXWNPidCkjSlB/DjLGPAdMAh4CLrbWHvTe9IQxZr2vihNn5Vc1AepxLSIiMlRlJERQWKNpIYOpX+Ea+Je19pWeVxhjQq217dbaOT6oS/xAflUzCZEhxEWEOF2KiIiIHIf0hAhW51Y6XcaI0t9pIb/s5br3B7IQ8T95leoUIiIiMpRlJkZQ3tBOW6fL6VJGjKOOXBtjxgCpQLgx5hSgu9lxDBDh49rEYQXVLZwxIdHpMkREROQ4ZSR44lpRTQs5o6MdrmZk6GtayHl4FjGmAX/scX0j8EMf1SR+oK3TRVlDG5kJGrkWEREZqjISvR1DFK4HzVHDtbX2AeABY8wV1tpnBqkm8QNF3pXFmYk6QSEiIjJUdY9cF1SrY8hg6WtayGestQ8DWcaYbx5+u7X2j73cTYaB7h/CDIVrERGRISsxMoTIkEC14xtEfU0L6Z4TEOXrQsS/FHSPXCcoXIuIiAxVxhjSEyIOnZEW3+trWsg/vX//fHDKEX9RUN1MVGgQCZFqwyciIjKUZSREkFelXteDpV+t+IwxvzPGxBhjgo0xbxljKo0xn/F1ceKcguoWMhIiMMb0fbCIiIj4rcxEz8i1222dLmVE6G+f63OttQ3ARcABYALwHV8VJc4rrGnRYkYREZFhICMhgvYuNxWN7U6XMiL0N1x3Tx+5EHjKWlvvo3rED7jcluLaFi1mFBERGQYyEj1L6LSocXD0N1y/ZIzZDcwG3jLGJANtvitLnFRa10qny6rHtYiIyDDwUTs+zbseDP0K19ba7wNnAHOstZ1AM3CpLwsT53R/ss3SyLWIiMiQlxoXToBBHUMGSV+t+HqajKffdc/7PDjA9YgfUI9rERGR4SMkKICxseGaFjJI+hWujTEPAeOBzYDLe7VF4XpYKqhpJjjQMDY23OlSREREZABkJEQc2sNCfKu/I9dzgKnWWvVwGQEKq1tIj48gMEBt+ERERIaDzMQIlu8qd7qMEaG/Cxq3A2N8WYj4j4JqdQoREREZTtITIqhq6qCpvcvpUoa9/o5cJwE7jTEfAoeaJFprL/FJVeIYay2FNS3MzYp3uhQREREZIN17VxTVtDBlbIzD1Qxv/Q3XP/NlEeI/apo9n2q7e2KKiIjI0Nfdjq9Q4drn+hWurbXvGmMygRxr7XJjTAQQ6NvSxAndix0yEzQtREREZLg4FK6rtajR1/o159oYcyvwNPBP71WpwPM+qkkc1P1Dp63PRUREho+4iBBiwoLUjm8Q9HdB45eB+UADgLV2HzDKV0WJc7p7XKdr5FpERGRYyUhUO77B0N9w3W6t7ei+4N1IRm35hqGCmmbGxIQRFqxZPyIiIsNJZkKkdmkcBP0N1+8aY34IhBtjlgJPAS/6rixxSqHa8ImIiAxL6QkRFNe24HJrfNSX+huuvw9UAtuALwCvAD/2VVHinIKaFi1mFBERGYYyEyPodFkO1rc6Xcqw1t9uIW5jzPPA89baSt+WJE5p6eiisrFdixlFRESGoZ7t+NLi9bveV446cm08fmaMqQL2AHuMMZXGmJ8OTnkymLoXM6rHtYiIyPCjdnyDo69pId/A0yVkrrU2wVqbAJwKzDfGfMPn1cmg6g7XmhYiIiIy/IyNDSMowKgdn4/1Fa5vAK611uZ3X2GtzQM+A3y2rwc3xpxvjNljjMk1xny/l9tDjTFPeG9fa4zJ6nHbScaY940xO4wx24wxYf1+VXJcCmuaAfW4FhERGY6CAgNIjQ9XOz4f6ytcB1trqw6/0jvvOvhodzTGBAJ3AsuAqcC1xpiphx12C1BrrZ0A/An4rfe+QcDDwO3W2mnAIqCzz1cjJ6SguoWYsCDiIkKcLkVERER8ICMhQu34fKyvcN1xnLcBzANyrbV53h7ZjwOXHnbMpcAD3q+fBhYbYwxwLrDVWrsFwFpbba119fF8coIKa1rIStJ8axERkeEqIyFC00J8rK9wPdMY09DLn0ZgRh/3TQWKelwu9l7X6zHW2i6gHkgEJgLWGPO6MWajMea7/X1BcvwKqlsOLXYQERGR4ScjIYK6lk7qWzUhwFeOGq6ttYHW2phe/kRba486LeQEBQELgOu9f3/KGLP48IOMMbcZY9YbY9ZXVqpD4InodLkpqWvVfGsREZFhrPv3vKaG+E5/N5E5HiVAeo/Lad7rej3GO886FqjGM8q90lpbZa1twbNpzazDn8Bae4+1do61dk5ycrIPXsLIUVrXisttyUzQtBAREZHhKt17hrpA7fh8xpfheh2QY4zJNsaEANcALxx2zAvAjd6vrwTettZa4HVghjEmwhu6zwJ2+rDWEe+jHtcauRYRERmuem4kI77Rrx0aj4e1tssY8xU8QTkQuM9au8MYcwew3lr7AnAv8JAxJheowRPAsdbWGmP+iCegW+AVa+3LvqpVONSWR9NCREREhq/osGASIkMUrn3IZ+EawFr7Cp4pHT2v+2mPr9uAq45w34fxtOOTQVBY3UxIUACjo9VOXEREZDjzdAxpdrqMYcuX00JkCOnuFBIQYJwuRURERHxI7fh8S+FaAM/cK217LiIiMvxlJERQWtdGp8vtdCnDksK1YK2lsKZFixlFRERGgIzECFxuS2ldq9OlDEsK10JlUzstHS6NXIuIiIwAGWrH51MK10JhdXenEPW4FhERGe66O4MVaN61Tyhci3pci4iIjCCjo8MICQygWOHaJxSuhYKaFoyBtPhwp0sRERERHwsIMKQlhKtjiI8oXAuF1c2kxIYTGhTodCkiIiIyCDITIjTn2kcUroUD3h7XIiIiMjJkJERQVNOCtdbpUoYdhWvx9LjWfGsREZERIz0hgsb2LupaOp0uZdhRuB7hGts6qWnuUKcQERGREaT7jLXmXQ88hesRruBQGz6NXIuIiIwU3YNqasc38BSuR7juT6yacy0iIjJypCd4OoQVKVwPOIXrEU4j1yIiIiNPREgQSVGhhzaSk4GjcD3CFdY0kxAZQnRYsNOliIiIyCDKUK9rn1C4HuEK1IZPRERkRMpMjFS49gGF6xGuoFpt+EREREai9IQISutb6ehyO13KsKJwPYJ1dLk5WN9KpkauRURERpyMhAishZK6VqdLGVYUrkew4toW3BYy1ONaRERkxFGva99QuB7BuntbalqIiIjIyNP9+1/hemApXI9g3e13NC1ERERk5EmOCiU0KIDC6manSxlWFK5HsILqFsKDA0mODnW6FBERERlkAQGG9IQIjVwPMIXrEaywppnMxAiMMU6XIiIiIg7ISIigsEYLGgeSwvUIdkA9rkVEREa0jIQIimpasNY6XcqwoXA9QrndlsIa9bgWEREZyTISImhq76KmucPpUoYNhesRqryxjY4ut9rwiYiIjGBqxzfwFK5HqAJ1ChERERnxMtSOb8ApXI9Qh9rwaVqIiIjIiJUe78kBRQrXA0bheoQqqGkmMMCQEhfudCkiIiLikPCQQEZFhx46oy0nTuF6hCqobiE1LpzgQP0TEBERGcky1Ot6QClZjVDqFCIiIiLwUTs+GRgK1yNUgXpci4iICJ5FjQcb2mjvcjldyrCgcD0C1bd0Ut/aqZFrERERISMhAmuhuFY7NQ4EhesRqKCmGYBM9bgWEREZ8dTremApXI9ABWrDJyIiIl7dva4173pgKFyPQN2fTDXnWkRERJKjQgkLDji0B4acGIXrEaigupnk6FAiQoKcLkVEREQcZowhIyGCAo1cDwiF6xGooLpF256LiIjIIWrHN3AUrkegguqWQ/OrRERERDISIimsacFa63QpQ57C9QjT1umirKGNzAR1ChERERGPjIRwWjpcVDd3OF3KkKdwPcJ0n/JRpxARERHp1n1Gu0CLGk+YwvUI0/1Do2khIiIi0q27g5jmXZ84hesRpnslsBY0ioiISLe0eG0kM1AUrkeYwupmokKDSIgMcboUERER8RNhwYGMiQlTuB4ACtcjTEFNCxkJERhjnC5FRERE/EhGQoQ2khkACtcjTGF1C1lJmhIiIiIiH5eeEKGR6wGgcD2CuNyWotoWMtSGT0RERA6TmRhBWUMbbZ0up0sZ0hSuR5CD9a10uqza8ImIiMgndHcMKa5tdbiSoU3hegTpnkelTiEiIiJyuHS14xsQCtcjSHcbPvW4FhERkcN1j1wXVDc7XMnQpnA9ghRUtxAcaBgbG+50KSIiIuJnkqJCiAgJPDQYJ8dH4XoEKaxpJj0+gsAAteETERGRjzPGkJkYqS3QT5DC9QhSUN2iKSEiIiJyRNlJERyo0rSQE6FwPUJYaymobtFiRhERETmizMRIimpb6HK5nS5lyFK4HiFqmjtoau8iI1E9rkVERKR32YmRdLospXVtTpcyZClcjxD53lM845IUrkVERKR33Xth5KtjyHFTuB4husN1tsK1iIiIHEF3TlA7vuPn03BtjDnfGLPHGJNrjPl+L7eHGmOe8N6+1hiTddjtGcaYJmPMt31Z50iQX9VMUIAhLV5t+ERERKR3ydGhRIQEHhqUk2Pns3BtjAkE7gSWAVOBa40xUw877Bag1lo7AfgT8NvDbv8j8KqvahxJDlQ3k5EQQVCgTlaIiIhI79SO78T5MmnNA3KttXnW2g7gceDSw465FHjA+/XTwGJjjAEwxlwG5AM7fFjjiJFX2UyWpoSIiIhIH9SO78T4MlynAkU9Lhd7r+v1GGttF1APJBpjooDvAT8/2hMYY24zxqw3xqyvrKwcsMKHG7fbcqC6WfOtRUREpE+ZiZEU1qgd3/Hy1zkCPwP+ZK1tOtpB1tp7rLVzrLVzkpOTB6eyIai8sY22TrfCtYiIiPQpOzGSLrfa8R2vIB8+dgmQ3uNymve63o4pNsYEAbFANXAqcKUx5ndAHOA2xrRZa//uw3qHrfxKdQoRERGR/unZjk87Ox87X4brdUCOMSYbT4i+BrjusGNeAG4E3geuBN621lpgYfcBxpifAU0K1sevu1elwrWIiIj05ePt+DQz4Fj5LFxba7uMMV8BXgcCgfustTuMMXcA6621LwD3Ag8ZY3KBGjwBXAZYfmUzoUEBjIkJc7oUERER8XNqx3difDlyjbX2FeCVw677aY+v24Cr+niMn/mkuBGkezFjQIBxuhQRERHxc93t+NQx5Pj464JGGUB5Vc1kJWpKiIiIiPRPdlKEel0fJ4XrYa7L5aawuoXsZIVrERER6R+14zt+CtfDXEldK11uS7ZGrkVERKSf1I7v+ClcD3N53vlSGrkWERGR/urZjk+OjcL1MNe9GEFzrkVERKS/utvxaVHjsVO4Hubyq5qJDg0iKSrE6VJERERkiFA7vuOncD3M5Vc1k5UUiTFqwyciIiL9Y4whOylS4fo4KFwPc/lVzdqZUURERI7Z+OQo9lc2OV3GkKNwPYy1d7koqWtVuBYREZFjNi45kpK6Vto6XU6XMqQoXA9jB6pasBaFaxERETlm45OjsBZNDTlGCtfDWPepnAmjohyuRERERIaacd42vnmVCtfHQuF6GMut8ITrcepxLSIiIsdoXJJncE7zro+NwvUwtr+yidS4cCJCgpwuRURERIaY8JBAUuPCFa6PkcL1MJZb0cR4TQkRERGR4zQuOVLTQo6RwvUw5XZb9lc2MSFZ4VpERESOz/jkKPIqm7DWOl3KkKFwPUyV1rfS1unWYkYRERE5buOTI2nucFHe0O50KUOGwvUw1b2YcbwWM4qIiMhxGp+sRY3HSuF6mNrvnR+lkWsRERE5XuMUro+ZwvUwlVvRRHxEMIlRoU6XIiIiIkPU6JhQIkMCtajxGChcD1P7K5o0ai0iIiInxBjD+FFRGrk+BgrXw9T+yqZD86REREREjte4JLXjOxYK18NQbXMH1c0dGrkWERGREzY+OYqSulZaOrqcLmVIULgehnK9p260gYyIiIicqO5FjflVGr3uD4XrYWi/tw2fNpARERGREzV+lKet735NDekXhethKLeiibDgAFLjwp0uRURERIa4rMRIjPlo8E6OTuF6GNpf2cS4pCgCAozTpYiIiMgQFxYcSFp8uDqG9JPC9TCUW9mk+dYiIiIyYCaOimZfucJ1fyhcDzNtnS6Ka1s131pEREQGzMQx0eRVNdHpcjtdit9TuB5m9lc2Ya22PRcREZGBM2l0NJ0uywF1DOmTwvUws6esEYBJYxSuRUREZGDkjPbkij3ljQ5X4v8UroeZPWWNhAQFkJUY6XQpIiIiMkyMT44iwMDeMoXrvihcDzO7yhqZkBxFUKDeWhERERkYYcGBZCVFauS6H5TAhpk9ZQ1MHhPtdBkiIiIyzEwaHc1edQzpk8L1MFLX0kF5QzuTFK5FRERkgOWMjqagupm2TpfTpfg1hethZPehxYwK1yIiIjKwJo2Oxm09O0HLkSlcDyPdnUImj4lxuBIREREZbro7ke3VvOujUrgeRnaXNRIbHszomFCnSxEREZFhJjMxkpDAAC1q7IPC9TCyp6yBSWOiMcY4XYqIiIgMM8GBAYxLjtQ26H1QuB4mrLXsLW9SpxARERHxmYmjow9NQ5XeKVwPE8W1rTS1d2kxo4iIiPjMpDHRlNS10tjW6XQpfkvhepj4aDGjwrWIiIj4xsTRnpyxTx1DjkjhepjoXlzQ/Y9eREREZKBNHO3pGLJPixqPSOF6mNhd1khqXDjRYcFOlyIiIiLDVHp8BGHBAewp08j1kShcDxPa9lxERER8LSDAMHF0NLvLGpwuxW8pXA8DHV1u8iqbtZhRREREfG5aSgw7Shuw1jpdil9SuB4G9lc20eW2CtciIiLic1NTYqlv7aSkrtXpUvySwvUwsL2kHvB8khQRERHxpenevLG9RFNDeqNwPQxsL6knIiSQ7KQop0sRERGRYW7K2BgCAww7S+udLsUvKVwPA9tK6pmW4vmHLiIiIuJLYcGBjE+OZHupRq57o3A9xHW53Ow82MD01FinSxEREZERYnpK7KFpqfJxCtdD3P7KZto63cxQuBYREZFBMi01lorGdioa25wuxe8oXA9x27yfGhWuRUREZLB0N1HYoakhn6BwPcR1L2Ycl6zFjCIiIjI4pnrD9U6F609QuB7itpXUM3WsFjOKiIjI4IkJCyYzMULzrnuhcD2EudyWnaVazCgiIiKDb3pKLNvVju8TFK6HsP2VTbR2ujTfWkRERAbdtNQYimpaqW/pdLoUv+LTcG2MOd8Ys8cYk2uM+X4vt4caY57w3r7WGJPlvX6pMWaDMWab9+9zfFnnULWt2LuYMU3hWkRERAbXtBRP/thxUKPXPfksXBtjAoE7gWXAVOBaY8zUww67Bai11k4A/gT81nt9FXCxtXYGcCPwkK/qHMq2ldQTHhzIeC1mFBERkUE2TYsae+XLket5QK61Ns9a2wE8Dlx62DGXAg94v34aWGyMMdbaTdbaUu/1O4BwY0yoD2sdkraX1DNVOzOKiIiIA5KiQhkTE6ZFjYfxZbhOBYp6XC72XtfrMdbaLqAeSDzsmCuAjdbadh/VOSS53JYdpQ2aby0iIiKOmZ4ay9Ziheue/HpBozFmGp6pIl84wu23GWPWG2PWV1ZWDm5xDsvzLmZUpxARERFxyqzMOPKqmqlp7nC6FL/hy3BdAqT3uJzmva7XY4wxQUAsUO29nAY8B3zWWru/tyew1t5jrZ1jrZ2TnJw8wOX7t02FdQDM1GJGERERccjsjHgANhXWOlyJ//BluF4H5Bhjso0xIcA1wAuHHfMCngWLAFcCb1trrTEmDngZ+L61do0Paxyy1hfUEBserMWMIiIi4piT0uIICjBsVLg+xGfh2juH+ivA68Au4Elr7Q5jzB3GmEu8h90LJBpjcoFvAt3t+r4CTAB+aozZ7P0zyle1DkXrC2qZnRlPgBYzioiIiEPCQwKZMjaGDQUK192CfPng1tpXgFcOu+6nPb5uA67q5X6/BH7py9qGsprmDvIqm7liVprTpYiIiMgINzsznifWFdHlchMU6NfL+QaFvgNDUPenw7lZCQ5XIiIiIiPdKRlxtHa62F3W6HQpfkHheghaX1BDcKDhJC1mFBEREYfNzvQsatS8aw+F6yFow4FapqfGEhYc6HQpIiIiMsKlxoUzKjqUjZp3DShcDzltnS62Ftczx/spUURERMRJxhhmZ8azQSPXgML1kLO9pJ4Ol5vZmZpvLSIiIv5hVkY8RTWtVDS2OV2K4xSuh5j13lMuszVyLSIiIn5iVve864I6ZwvxAwrXQ8z6A7VkJUaQHB3qdCkiIiIiAExPjSEkMEA7NaJwPaRYa9lYWKspISIiIuJXQoMCmZ4ac+gM+0imcD2E5FU1U9PcwdwsTQkRERER/zIvO5GtxXU0t3c5XYqjFK6HkA/zawCYo3AtIiIifmbBhCQ6XZYPD9Q4XYqjFK6HkFX7KhkTE8b45CinSxERERH5mDlZ8YQEBbBmX5XTpThK4XqIcLkta3KrWZiThDHG6XJEREREPiYsOJC5WfGszlW4liFgW0k99a2dLJyY7HQpIiIiIr2aPyGJ3WWNVDa2O12KYxSuh4hVeysxxjOfSURERMQfzR/vySnv7R+5o9cK10PEqn1VTE+JJSEyxOlSRERERHo1PTWWmLAg1ozgqSEK10NAY1snGwtrWZijUWsRERHxX4EBhjPGJ7F6XxXWWqfLcYTC9RDwQV4NXW7LAoVrERER8XPzc5IorW/jQHWL06U4QuF6CFi1r5Lw4EBmZ6q/tYiIiPi37vVhI7VriML1ELB6XxWnjUsgNCjQ6VJEREREjiorMYLUuPAR2+9a4drPFdW0kFfVzMIcteATERER/2eMYcGEJNbkVtHR5Xa6nEGncO3n3t1bCaDFjCIiIjJkLJ06msb2Lt7Pq3a6lEGncO3nXttexrikSCaM0pbnIiIiMjQsyEkiIiSQ17aXOV3KoFO49mM1zR28n1fNshljtOW5iIiIDBlhwYGcPXkUb+4sw+UeWS35FK792Bs7PP8gL5gx1ulSRERERI7JsuljqGrqYENBrdOlDCqFaz/28raDZCZGMHVsjNOliIiIiByTRZNGERIUMOKmhihc+6na5g7e21/NsuljNSVEREREhpyo0CDOzEni9R1lI2q3RoVrP/XmznJcbsuFmhIiIiIiQ9R508ZQUtfK9pIGp0sZNArXfurlbQdJiw9neqqmhIiIiMjQtGTKaAIDDK/tOOh0KYNG4doP1bd0sia3igtnaEqIiIiIDF3xkSGcNi6BV7ePnKkhCtd+6PWdZXS5Lcs0JURERESGuItPSiGvsplNRXVOlzIoFK790BPrishOimRmWqzTpYiIiIickItmphAREsjjHxY6XcqgULj2M7sONrChoJbrT83QlBAREREZ8qJCg7hkZgovbjlIY1un0+X4nMK1n3l0bSEhQQFcMSvN6VJEREREBsQ18zJo7XTx382lTpficwrXfqS5vYvnNpVw0UljiY8McbocERERkQExMy2WKWNjeHzd8J8aonDtR17YUkpTexfXn5rpdCkiIiIiA8YYw7Xz0tle0sD2knqny/EphWs/Ya3l4Q8KmDwmmlkZcU6XIyIiIjKgLj05lbDgAB4b5gsbFa79xNbienaUNnD9aZlayCgiIiLDTmx4MBfMGMt/N5dS3zp8FzYqXPuJe1blERkSyGUnpzhdioiIiIhP3LIgm6b2Lu5fc8DpUnxG4doP7DrYwMtbD3Lz/Gyiw4KdLkdERETEJ6alxLJ06mjuXZ1HwzBty6dw7Qf+9OZeosOCuHXhOKdLEREREfGpry/OoaGtiweG6ei1wrXDthXX88bOcj6/YByxERq1FhERkeFtemosS6aM4t+r84flpjIK1w7745t7iIsI5nMLspwuRURERGRQfH3xROpbO3ngvQNOlzLgFK4dtLGwlnf2VHLbmeM011pERERGjBlpsSye7Bm9rmvpcLqcAaVw7ZAul5ufv7CDpKgQbjw9y+lyRERERAbVt8+bRGNbF//vlV1OlzKgFK4dcu/qfLYU1/O/F08jMjTI6XJEREREBtWUsTHcunAcT64v5r39VU6XM2AUrh2wv7KJP7y5l3Onjuaik8Y6XY6IiIiII/5nSQ6ZiRH88NlttHW6nC5nQChcDzK32/K9p7cSFhTALy+brt0YRUREZMQKCw7k15+awYHqFv761j6nyxkQCteD7L41+awvqOUnF01lVEyY0+WIiIiIOOqMCUlcNTuNe1bmsTav2ulyTpjC9SBasaeCX7+6myVTRnPl7DSnyxERERHxCz++aCoZiRF88ZGNFNW0OF3OCVG4HiS7yxr4yqObmDg6mj9fc7Kmg4iIiIh4xYYHc++Nc3G5Lbc8sG5Iby6jcD0IKhra+Nx/1hEZGsh9N80hSt1BRERERD4mOymSu66fxf7KZr722Ca6XG6nSzouCtc+VlzbwnX/Xktdayf33jiXsbHhTpckIiIi4pfOmJDEzy+Zxjt7KvnCQxto7Rh6HUQUrn1oe0k9n/rHe5Q3tHHvjXOZnhrrdEkiIiIifu0zp2Xyi0un8faeCq7/9wfUNg+tHRwVrn3kzZ3lXP3P9wkJDOCZL57B6eMTnS5JREREZEi44fQs/nHdLLaXNHDl3e+xt7zR6ZL6TeF6gNU0d/CNJzZz64PryU6K5NkvncHE0dFOlyUiIiIypCybMZYHb5lHbUsnF/11NXe+kzsk5mErXA+QTpebp9YXsfSP7/LillK+ds4Env3SGYxWL2sRERGR43LauETe+MaZLJ06mv97fQ+X3/Ue7++vxlrrdGlHpLYVJ6i1w8UT6wr516p8SupamZkexyNXzGDymBinSxMREREZ8pKiQrnz+llcsPUgP3txB9f+6wNmZ8bzlbMnsGhSst+1N/bpyLUx5nxjzB5jTK4x5vu93B5qjHnCe/taY0xWj9t+4L1+jzHmPF/Webw6XW6W/PFdfvbiTsbGhnHvjXN47otnKFiLiIiIDLALTxrLqu+ezR2XTqOsvo2b71/Hwx8UOF3WJ/hs5NoYEwjcCSwFioF1xpgXrLU7exx2C1BrrZ1gjLkG+C3waWPMVOAaYBqQAiw3xky01vpVP5bgwAC+tngC45KjmJuV4HQ5IiIiIsNaWHAgnz09i2vmZvD85hLOmzrG6ZI+wZcj1/OAXGttnrW2A3gcuPSwYy4FHvB+/TSw2HjG9i8FHrfWtltr84Fc7+P5nU/PzVCwFhERERlEIUEBXD0nndiIYKdL+QRfhutUoKjH5WLvdb0eY63tAuqBxH7eV0RERETErwzpBY3GmNuA27wXm4wxe5ysR3qVBFQ5XYQckd4f/6X3xr/p/fFvw+b9ud7pAgbecHlvMo90gy/DdQmQ3uNymve63o4pNsYEAbFAdT/vi7X2HuCeAaxZBpgxZr21do7TdUjv9P74L703/k3vj3/T++O/RsJ748tpIeuAHGNMtjEmBM8CxRcOO+YF4Ebv11cCb1tP48IXgGu83USygRzgQx/WKiIiIiJywnw2cm2t7TLGfAV4HQgE7rPW7jDG3AGst9a+ANwLPGSMyQVq8ARwvMc9CewEuoAv+1unEBERERGRw/l0zrW19hXglcOu+2mPr9uAq45w318Bv/JlfTIoNG3Hv+n98V96b/yb3h//pvfHfw3798b48/aRIiIiIiJDiU93aBQRERERGUkUrsVnjDHne7evzzXGfN/pesTDGJNujHnHGLPTGLPDGPN1p2uSTzLGBBpjNhljXnK6FvmIMSbOGPO0MWa3MWaXMeZ0p2uSjxhjvuH9f227MeYxY0yY0zWNZMaY+4wxFcaY7T2uSzDGvGmM2ef9O97JGn1B4Vp8whgTCNwJLAOmAtd6t7UX53UB37LWTgVOA76s98YvfR3Y5XQR8gl/AV6z1k4GZqL3yG8YY1KBrwFzrLXT8TRTuMbZqka8+4HzD7vu+8Bb1toc4C3v5WFF4Vp8ZR6Qa63Ns9Z2AI/j2dZeHGatPWit3ej9uhFPONAOqH7EGJMGXAj82+la5CPGmFjgTDydrrDWdlhr6xwtSg4XBIR7986IAEodrmdEs9auxNMNrqdLgQe8Xz8AXDaYNQ0GhWvxFW1hPwQYY7KAU4C1DpciH/dn4LuA2+E65OOygUrgP94pO/82xkQ6XZR4WGtLgN8DhcBBoN5a+4azVUkvRltrD3q/LgNGO1mMLyhci4xQxpgo4Bngf6y1DU7XIx7GmIuACmvtBqdrkU8IAmYBd1lrTwGaGYantIcq79zdS/F8CEoBIo0xn3G2Kjka78aBw65tncK1+Eq/trAXZxhjgvEE60estc86XY98zHzgEmPMATzTqc4xxjzsbEniVQwUW2u7z/Q8jSdsi39YAuRbayuttZ3As8AZDtckn1RujBkL4P27wuF6BpzCtfjKOiDHGJNtjAnBs6jkBYdrEsAYY/DMGd1lrf2j0/XIx1lrf2CtTbPWZuH5uXnbWqvRNz9grS0Diowxk7xXLcazk7D4h0LgNGNMhPf/ucVowak/egG40fv1jcB/HazFJ3y6Q6OMXNbaLmPMV4DX8azYvs9au8PhssRjPnADsM0Ys9l73Q+9O6qKyNF9FXjEO2iQB9zscD3iZa1da4x5GtiIpyvSJkbAboD+zBjzGLAISDLGFAP/C/wGeNIYcwtQAFztXIW+oR0aRUREREQGiKaFiIiIiIgMEIVrEREREZEBonAtIiIiIjJAFK5FRERERAaIwrWIiIiIyABRuBYRERERGSAK1yIiIiIiA0ThWkRERERkgPx/7Dl8S27jzboAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(12,8))\n", + "sns.distplot(all_labels, bins=10)\n", + "plt.plot(np.arange(0, 10), all_expected_probability.mean(axis=0), color='red')\n", + "plt.legend()\n", + "plt.title(\"Calibration of our model\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Here our calibration is good--model distribution over classes is very similar to the real distribution of classes.**\n", + "\n", + "**In case of bad calibration -- if your model distribution over classes is very different from real distribution, you should try to fix this. For classification tasks it could be fixed with temperature techniques**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Deep ensembles for Regression" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**For regression tasks you should consider other distributions, but in general techniques are the same**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**We still have the same formulas for uncertainties:**\n", + "\n", + "#### Through ensemble we can calculate *Total uncertainty*:\n", + "#### $$H[\\mathbb{E}_{\\theta \\sim P(\\theta|D)} [P(y|x^*, \\theta)]] $$\n", + "#### and *Expected data uncertainty*:\n", + "#### $$\\mathbb{E}_{\\theta \\sim P(\\theta|D)} [H[P(y|x^*, \\theta)]] $$\n", + "#### *Knowledge uncertainty* is the difference between *Total uncertainty* and *Expected Data uncertainty*:\n", + "#### $$\\mathcal{I}(y, \\theta| x^*, D) = H[\\mathbb{E}_{\\theta \\sim P(\\theta|D)} [P(y|x^*, \\theta)]] - \\mathbb{E}_{\\theta \\sim P(\\theta|D)} [H[P(y|x^*, \\theta)]]$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Gaussian ensemble for different uncertainty cases:\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Here we will use simple toy dataset to show concepts.** \n", + "**For ease of understanding, we will import models and functions from source files, that you can find in the repository. You can check them more precisely later. These classes are quite flexible and thoughtful, you can use them with other tasks.**" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "from src.data.toy_loading import get_toy_dataset, get_arrays_from_loader\n", + "from torch.utils import data\n", + "from torch.distributions import Normal\n", + "from torch.optim import SGD, Adam\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "import random" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "targets_fn = lambda x: np.sin(x) + x / 10.0\n", + "noise_fn = lambda x: 1.0 / (1.0 + np.abs(x)) + 0.1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train size: 2048 16\n", + "OOD size: 512 4\n", + "Test size: 512 1\n" + ] + } + ], + "source": [ + "train_data, test_data, ood_full_data, y_noise = get_toy_dataset(\n", + " targets_fn, noise_fn, train_limits=(-10, 10), ood_abs_limits=(20, 25),\n", + " test_limits=(-15, 15),\n", + " train_samples=2048, test_samples=512, ood_samples=512,\n", + " random_state=12\n", + ")\n", + "\n", + "trainloader = data.DataLoader(train_data, batch_size=128, shuffle=True)\n", + "testloader = data.DataLoader(test_data, batch_size=512)\n", + "oodloader = data.DataLoader(\n", + " data.TensorDataset(ood_full_data.tensors[0]),\n", + " batch_size=128, shuffle=True\n", + ")\n", + "\n", + "print(\"Train size:\", len(trainloader) * trainloader.batch_size, len(trainloader))\n", + "print(\"OOD size:\", len(oodloader) * oodloader.batch_size, len(oodloader))\n", + "print(\"Test size:\", len(testloader) * testloader.batch_size, len(testloader))" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "X_train, y_train = get_arrays_from_loader(trainloader)\n", + "X_ood, y_ood = ood_full_data.tensors[0], ood_full_data.tensors[1]\n", + "X_test, y_test = get_arrays_from_loader(testloader)\n", + "test_ord = X_test.argsort(0)\n", + "X_test, y_test = X_test[test_ord].squeeze(), y_test[test_ord].squeeze()\n", + "\n", + "plt.figure(figsize=(10,10))\n", + "plt.title(\"Data\")\n", + "plt.rc('font', size=30)\n", + "plt.plot(\n", + " X_test, y_test,\n", + " color=sns.color_palette()[0],\n", + " linewidth=3, label=\"Test data\"\n", + ")\n", + "plt.fill_between(\n", + " X_test,\n", + " y_test - noise_fn(X_test), \n", + " y_test + noise_fn(X_test), \n", + " color=sns.color_palette()[0], alpha=0.1\n", + ")\n", + "plt.fill_between(\n", + " X_test,\n", + " y_test - 2 * noise_fn(X_test), \n", + " y_test + 2 * noise_fn(X_test), \n", + " color=sns.color_palette()[0], alpha=0.1\n", + ")\n", + "plt.scatter(X_ood, y_ood, color='g',label='ood points')\n", + "plt.grid()\n", + "plt.legend(loc='lower left', fontsize=15)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "from src.models.simple_model import SimpleModel\n", + "from src.training.trainers import DistributionMLETrainer, DistributionEnsembleMLETrainer\n", + "from src.distributions.mixture_distribution import GaussianDiagonalMixture" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0 train loss 1.538 eval loss 1.366 eval params_rmse 1.008\n", + "Epoch 100 train loss 0.806 eval loss 1.282 eval params_rmse 1.057\n", + "Epoch 149 train loss 0.723 eval loss 1.212 eval params_rmse 1.401\n", + "Trained Gaussian, final rmse 1.401\n" + ] + } + ], + "source": [ + "model_params = {\n", + " \"input_dim\": 1, \"output_dim\": 1,\n", + " \"num_units\": 30, \"num_hidden\": 2\n", + "}\n", + "optim_params = {\"lr\": 1e-3, \"weight_decay\": 1e-4}\n", + "NUM_EPOCHS = 150\n", + "LOG_PER = 100\n", + "\n", + "singletrainer = DistributionMLETrainer(\n", + " model_params,\n", + " SimpleModel, optim_params, distribution=Normal,\n", + " optimizer=Adam\n", + ")\n", + "\n", + "strain_hist, stest_hist, smetrics_hist = singletrainer.train(\n", + " trainloader, NUM_EPOCHS, testloader, \n", + " log_per=LOG_PER, verbose=True\n", + ")\n", + "print(\"Trained Gaussian, final rmse %.3f\" % smetrics_hist[-1][0])" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model_preds = singletrainer.get_predicted_params(testloader)\n", + "mean_preds, std_preds = model_preds[0][test_ord].squeeze(), model_preds[1][test_ord].squeeze()\n", + "\n", + "fig=plt.figure(figsize=(12,8))\n", + "plt.plot(X_test, y_test, label=\"Real y\")\n", + "plt.plot(X_test, mean_preds, label=\"Mean prediction\")\n", + "plt.fill_between(X_test, mean_preds - std_preds, mean_preds + std_preds, alpha=0.1)\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "variances = singletrainer.get_predicted_params(testloader)[1]\n", + "\n", + "fig=plt.figure(figsize=(12,8))\n", + "plt.title(\"Predicted Variance for Normal\")\n", + "plt.plot(X_test, variances, color='teal', label='variances')" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "ensembletrainer = DistributionEnsembleMLETrainer(\n", + " 10, GaussianDiagonalMixture,\n", + " model_params,\n", + " SimpleModel, optim_params, distribution=Normal,\n", + " optimizer=Adam\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------\n", + "Model 0\n", + "Epoch 0 train loss 1.588 eval loss 1.442 eval params_rmse 1.038\n", + "Epoch 100 train loss 0.898 eval loss 1.286 eval params_rmse 0.778\n", + "Epoch 149 train loss 0.773 eval loss 1.308 eval params_rmse 1.221\n", + "--------------------\n", + "Model 1\n", + "Epoch 0 train loss 1.584 eval loss 1.404 eval params_rmse 1.042\n", + "Epoch 100 train loss 0.811 eval loss 1.149 eval params_rmse 1.209\n", + "Epoch 149 train loss 0.770 eval loss 1.267 eval params_rmse 1.409\n", + "--------------------\n", + "Model 2\n", + "Epoch 0 train loss 1.479 eval loss 1.245 eval params_rmse 0.866\n", + "Epoch 100 train loss 0.771 eval loss 1.066 eval params_rmse 0.754\n", + "Epoch 149 train loss 0.677 eval loss 1.039 eval params_rmse 0.957\n", + "--------------------\n", + "Model 3\n", + "Epoch 0 train loss 1.511 eval loss 1.260 eval params_rmse 0.849\n", + "Epoch 100 train loss 0.887 eval loss 1.194 eval params_rmse 1.015\n", + "Epoch 149 train loss 0.809 eval loss 1.181 eval params_rmse 1.307\n", + "--------------------\n", + "Model 4\n", + "Epoch 0 train loss 1.550 eval loss 1.413 eval params_rmse 1.045\n", + "Epoch 100 train loss 0.752 eval loss 1.257 eval params_rmse 0.976\n", + "Epoch 149 train loss 0.684 eval loss 1.064 eval params_rmse 1.175\n", + "--------------------\n", + "Model 5\n", + "Epoch 0 train loss 1.479 eval loss 1.256 eval params_rmse 0.884\n", + "Epoch 100 train loss 0.769 eval loss 1.211 eval params_rmse 1.011\n", + "Epoch 149 train loss 0.705 eval loss 1.134 eval params_rmse 1.329\n", + "--------------------\n", + "Model 6\n", + "Epoch 0 train loss 1.491 eval loss 1.273 eval params_rmse 0.882\n", + "Epoch 100 train loss 0.879 eval loss 1.249 eval params_rmse 0.821\n", + "Epoch 149 train loss 0.734 eval loss 1.213 eval params_rmse 1.021\n", + "--------------------\n", + "Model 7\n", + "Epoch 0 train loss 1.539 eval loss 1.331 eval params_rmse 0.952\n", + "Epoch 100 train loss 0.787 eval loss 1.273 eval params_rmse 1.258\n", + "Epoch 149 train loss 0.774 eval loss 1.254 eval params_rmse 1.334\n", + "--------------------\n", + "Model 8\n", + "Epoch 0 train loss 1.563 eval loss 1.382 eval params_rmse 1.001\n", + "Epoch 100 train loss 0.761 eval loss 1.239 eval params_rmse 1.104\n", + "Epoch 149 train loss 0.692 eval loss 1.095 eval params_rmse 1.324\n", + "--------------------\n", + "Model 9\n", + "Epoch 0 train loss 1.584 eval loss 1.484 eval params_rmse 0.999\n", + "Epoch 100 train loss 0.720 eval loss 1.098 eval params_rmse 0.843\n", + "Epoch 149 train loss 0.638 eval loss 0.970 eval params_rmse 0.959\n", + "Trained Ensemble, final rmse 0.959\n" + ] + } + ], + "source": [ + "entrain_hist, enval_hist, enmetrics_hist = ensembletrainer.train(\n", + " trainloader, NUM_EPOCHS, testloader, \n", + " log_per=LOG_PER, verbose=True\n", + ")\n", + "print(\"Trained Ensemble, final rmse %.3f\" % enmetrics_hist[-1][-1][0])" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsYAAAIHCAYAAACc3JqkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAADrRklEQVR4nOydeXgUxdbG35pkshEIJCFBAiSghDUiEDbZghEQEK4om0Z2RUWv4AbfFZVwNVflqsBV2VxIgKigbCogskVFQVYVEAGVJIAgJkAIJiHb+f7o9DBL90zPZCYzkzm/55knk+rqqpqu6pm3T506JYgIDMMwDMMwDOPr6NzdAIZhGIZhGIbxBFgYMwzDMAzDMAxYGDMMwzAMwzAMABbGDMMwDMMwDAOAhTHDMAzDMAzDAGBhzDAMwzAMwzAAWBgzDMNACJEuhKCqV7q72+NNCCHijK4dCSHi3N0mxj3wWGBqAyyMGY9CCJFq9sXqyCvO3Z+DYRiGYRjvg4UxwzDVQgiRbfRQMsHd7WEYxjdhizXjDPzd3QCGscEWB84pdnorGIZhGIap9bAwZjwaIrrD3W1gGEYdIsoGINzdDoZhGGfArhQMwzAMwzAMAxbGDMMwDMMwDAOAhTHjAwghugkhSo0WZLyn8bw1RucUCyFuVsiTZZQntSpNCCGGCCE+FkL8KoQoEkLkCSH2CiGeFUJEOvg5+ggh5gshDgkh/qz6TBeEEPuEEK8IIVo7WG6CEOLfQohvhBCnqz5rsRDijBBiW1WkkI5m5yTJnxtArNGhZWrRQtzx+aoW4/xHCPGjEOKyEKJQCPFLVXi2PvaWp7HOsUafu1QIEWHHuXWq2iif/5hKvkZCiPFCiPeqxtVfVXVdFULkCiE2CSGe0Vq32qIlIUQDIcRjQogdQogcIUSJ+SJLexc8CSGaCyEeEkKsrOrri0KIMiHEFSHEKSHEWiHEVCFEHY1tTxIK40wIUV8I8U8hxC4hxDkhxLWqv5uFEBOFEH5ayjerK1oI8YQQ4nMhxO9VfVVadf13CyEWCCHu0Fq2EKKjEOLlqj78o6qN+UKIn6rK6mJvGzXUqdbX4UKI6UKIb6vaUlI1ljYIIUYJIVzmLiOEuLnqHt9vdu8fEELMFWbfPwrnp1b1/SmzQ6eE8vdRlqs+C1MLICJ+8ctjXgBSAZD8cmK5M4zLBTDGRv6pZvmnquTLMsqTCqABgM/MzjV//QVgmB1tvwnANhtlEoByAAsA+GssNxrAxwAqNZRNAFKNzk3SeI7NvnTh53sYwN82ynwHQBCAdKO09GqOtToACo3Ke8yOc8canXcNQIRCnvcBVGi87lcBPKKh3jiz8+IA9Afwh0q5E6yda6UeLf0sv/IADNfQdpOxaJR2xkb53wOI1NgvegD/0TCe5FeWjfKiIN17Wsr6AECd6oxJDX3dx0pfGz4TgBvsLVvDvbJMw3iuBLAcQKhKOal2jCub/cMv337x4jvGV/gvgNsADKz6f4kQYi8R/W6eUQiRAOB1o6R1RLRQQx1+ADYA6F31/0UAxyDNzLSGJJoBIBLAGiHESCJab61AIUQPSELb2PJXDOBnAAUAwgG0h7SQ1g/A4wBaCiGGEVG5lXITAGwE0NTsUA4kQVEOSTi3rCoXAOob5buI6xFD+kISlwBwBMBZa5+phj7fdADzzJL/BHACQACAdgBCATwAIBjS53UKRPS3EGINgPFVSeMAvKXx9HFG7zcRUb5CnpthOtuXC0nUXIUkNOJx/XrWAbBQCFGfiF7W2AYA6A4gA9K1AoBfIY2LegBa2VGOObcYva+EZOG7AKAIQF1I90m9quMRkO6T+4noA60VCCF6QxqbAZBE0DFIfV8f0rWTx3NXAOuFEH2IqNJKeWGQ7uu+ZofyAfwG6bo3qGp7cNWx+lbKawXgC0giUqYM0pjPh/T5EwAEVh27F0ArIUQSERWqlVsNbgawCtfv4ZOQ7uEGkO49+Xr1BbBdCNGXiP6qbqVCiPqQ+qmr2SG5vxoCaAtpYaeA9NDYRggxgIgumZ3za1VZwZBEvszXUI5S9FN128/UYtytzPnFL+MXXGQxrio7CsA5o/L3AtCb5QmB9AMl58kB0MBKmVlGeS9U/b0I6Uvc3yifHsAkSGJPzn8FQBMrZTeBZF2W8+dC+pEMMMvXAMCrMLX8vmSl3AgA2TC1oCwD0FIhbx0AIwBsBjBPpTzjsibY0R+u+nxdYWqBOgvgLgA6ozzBAJ4EUGLWd4RqWoyryr/N7Pq21nBOjFm771LJ9x2ADwHcAyBMJU8PAF8ZlVUOoJOVuuPM2nul6u86ADcpjIlGVs6Ns1JPNoClAAYBCFE4roP08PqjUXmFABpbKTPJrH55TC2GmYUTQCMAn5vlT7FStgDwqVn+byCJL51ZXv+q9HcA7FEpry6khzO5rHwAj8DMIgzpe+gZSLMGct6V1R2XKv11wehztVe4Xhlm+dfaUba1sfCRWd4NAJqb5WkG4BOzfB87o35+8Uvt5fYG8Itfxi+4UBhXlX87TMXHf82Ov2t0rBxALxvlZZl9ERcBSLSSvxeAUqP8H1rJu9ko308Awm20ZYpR/lIAMSr5lpu1eZLGa6c2jZltVNYEO/rCVZ9vr1G+fCgIfqO8d8HSlSTdCeNMQHqoksv8j4ZzZhrlz4PZQ5utflDI5w9TEZhpJa+5oCBID0tCQz2axYgdba8DYL9RmWlW8iYptH2GlfwBMH343W4l7ySzct8H4FeNe2WRUVmnrV2rqvx3wPT7qosTxqZSX38NINDKOQvN8g+szlgAMMAsX6baWKu6l8zF+ZDqjkV+8Uvt5fYG8Itfxi/Y7ytm/pqvoY7/GOWvBHBHVfpos7Ke11BWltk5qRrOec0ofymAaIU8t5jlsWlxrDpvu9F5/1Y43hyS4JfzLHRCn2UblTdB4zmu+nxdzPrjYQ1lrjQ7J91JYznNqMwctR9+o/xHjPK/6aQ2tDQqsxAqok5BUFyAdhHrEjECycdZLvOYlXxJZvXv0lC28UNWkdJ1gWS9Nrbu/gCVhxWNn6cRrs9QEIBkjee9Z3TOcidcV/P+KgUQb+OcYEgzOvI5n1ZnLEBy45LznAdQz0b9oZBmfuRzttbkWOSXb704KgXji7wAaToaqLJGCCFuhTTFK5MFSdjYQwUky4ot3oT0pQ1ILhbDFPJMMHr/ORH9orENGUbvb1c4PhrXfQbLALyosVxnM8HovTM/391G7wshLaqzxf801m0vy43eNwPQTy2jEKIzJL9nmQy1vPZARCchWc0BSVy01XjqB0R01RltqAa7jd63qvL11YKWe/Aro/fBAFoo5OkK6cFC5iUiKtPYBiXG4Lrf8CEi2q7xPOOxkFyN+tXYQkQnrGUgomJIs2kyg4QQIY5UVnXeAKOkd4joio36rwJYYpR0mxCinlp+hqkOvPiO8XTs3RL6mK0MRFQuhLgPkgWoPiTf429wfUFTHiS/Q9UFOSocJKILGurPEUIchbSwBQC6QfJLNKav0futdrThR6P3nYUQgojIKM243F1EdM6Osp2Jqz5fN6P3WURUYqtAItorhMiDtCjSaRDRcSHE90ZtGgdgh0p240V3PxPRfi11VIWx6glJ8IZD8mE1DxVmHPasCYDDGor+Wkv9jlIV+utWSNemNaT7MBTqIUQFgMaQfPRt8a2GPGfM/q+vkMd4jF6D5GtcHZwx5hsLIRoT0R/VbIsxmzXm2whgTtV7fwCdAOxyoL4uMNUen2k8b4NR/TpIY8ee68gwmmBhzHg05KItoavE6WQAa6qSjH+QJzj4w6NFcBjnlYVxvPGBKtHQ3ijpASHEPzSWG2z0PgDSCndjMdHG6L0m8eVsXPz5jK+lvf2hatGtBstxXRjfI4SYSkRFxhmEEP6QFh0an2MVIcQwAK/AtD+1UF9jPotoLc6gqu8nApgNyYpuD/U15jtvKwNJkUOMk5Ssn8bX9iciKtVYvxrGcdCHCiE6OFhOQ0hRSJyF1vvkKKSZLvnCxcMxYXyT0XuC9ggRP0NyA5N1y01gYcy4ABbGjM9CRGurAr0nGSW/R0QbHSxSKbSWlrwNzI6FwfTe7ORge+SyjIVjuNF7m9ZtF+HKz2d8LR3tD2fyEaSwcQGQLKJ3Q/JpNmYQJLEDSD7v5sdNEEK8BGCWg+0JtJ0FgBSVwqkIIXSQFvSNs5VXBU1tJ6JrDpSttHmFs+8V45CEbWD/Q42MVpcSrWga+0RUIoT4G9I4Biy/t7RifN5VLbM6VfWXCSEKcP06Olo/w1iFfYwZn0UIMQCWsUn7CyEc/cK1x6Jk/ONt/oOvaccvjZjf40FG7zX9ILkAV36+AKP3jvaH0yCii5AiQ8goiULjtO1EpBoHusqybiyKzwL4NyR/6xaQXCn8iUjIL0gL/+zFXjciLfwTpp/1JIB/QQpx1gyS4PIza7s7cfa94qxx7+zfbWd9b2nF+Dx7rfDG9Qep5mKYasAWY8YnEUJEQ5qyNv/xbQbJ33eEA8XWtSOv8cIRc7/Jy2b/301E6xxojxKXIPlUA863PGnlstn/zvx8V3Dd0udofzib5bi+KDDZ2Ee0apODoUZ5bS26e97o/T4A/YnIlt+tPdfBJVRZi581SvocwD3W3BOEEO5u9yWj9864Vy7juh/7k0Q0zwllOgNnfW9p5bKDdZvXf1ktE8NUB7YYMz5HlZ/jCkg7uwHSF/x/jLLcI4R4yIGim9uR13gV/J/GB4job0i7aclEw3kYL7arzg5mDuPiz2d8LR3tD2ezCdKCTkD6zk0xOjYK1y1ohZA21FBECNEQQGejpJm2RLEQIhTafXNdSSdcfyADgMc1+Oya78pY0zj7XjH2fXbmmK8umu4TIUQTSFF0ZP5Uy2sDY7eUgKpytdQfhetuHOblMIzTYGHM+CIzIMVIlZlCRLNgKkrmCSHawT66VFnGrFK12MrYr/aAQrbvjN73sLMd1jAOgdVXmK1AchDjaXet5bnq8xlfy26quYyoCgPmsoeEqhBfHxoljTV6b+xa8In5wjwzzBer7dVQ/a3wjO/5WKP3eUR0SsM5vVzVGI0Y3ytNhRDVfXhy1ZivLpruE4V8St9bWjA/71aN55nnU1o8bO4C5G53HMYL8YQvTIapMYQQ3QC8ZJT0HhGtrno/GVIQe0CKfvCREMIeP7ZGMF3Ip8ZgmC4c+Uohj3EIpeFCiHCFPI7whdH7ZlVtqS5/G70PVs1liqs+n/G1vFkIoSVu72i43q3M2EUiQQjRsUpo9TRKtxWNQm/juBKTHTjHFXhj23dAivUt80g1yzMe872EEG6ZsVFglBDCPMSfEsYzHac1PtxYQES/wzRc3li1vGaMN3r/J4DjCnn+Nvtf6/cRwxhgYcz4DFWWwQ9xXQT9AuBx+TgRXYL05V9RldQeUkQBe/iPtR8ZIYQepsL8dwA7FbK+B+Bi1fu6AN62sx1qfA7gN6P/37Rj4wQ1jKecW6rmMsVVn281TH8cX7WWucrV4HlreZwBER2AFO5KZhxMrcU5UH5AMsY8RFcfa5mFEMkARmpto4sxbnukEMJqRAYhxCRIG2y4DSL6C9JWxTLTqjZicZRPcV3M6QC8U/V94G7iADxsLYMQogek7dNl3qtmncZx2+8UQlgNlSiE6GNW/ztm8ctlLsN0oaTW7yOGMcDCmPElluK6P901AGPMp66JaBekVf4yDwshjHdTs0U3SD94AeYHqqzPKwAkGCX/R+kLnogKYbpYaYwQ4sOqxVpWEUJ0EUIsr9rExLzcCkiuJDLNAWTZmiYWQnQVQqgtSDSeGh2txWfQhZ/vCqSdBWXuFELMVXJxqdo5ax2kTS9qghVG7++FqaVsucoPvQEiyoXpQ81rQogIpbxCiCRIMbo9ZSp5L0wfWBYKIRSteUKI0QAW1UirbPNvXF9kpgfwpRBCacdFA0KIpkKIx8zTqzYMegLXd73sDeALIURjW40QQrQVQrwlhHjGrtZr53UhxBCVutvAdCxdRPX7ZyGAv4z+/1jtoaNqE5tPjJLyYXqPG6j6fvvBKGmqnbN+DANh47vYNLMU89U8vJUaOUQU50CbGB9GCJEKKfi/jL073wHAYiJab1buAzC1UjxORIpfrlUiageuj/VLAG6pEibmebOM8q0HcAekMELHquo7DOkH5WYAD8HUgvElEQ209kGEEIurzpO5CmAVpJ3JzkIKdxQGyS2iIyTfadmfcyIRpauU+zqAJ42SSgF8DClg/mlIVvNoSL7QQyBZzxcQ0XSFshIg7c4ljMo6COmHz+DzR0R31cTnq/ohPAjTOLEHALwPaZZAD2n3rYcgieK/qtovC54MIppgXm51EULEQHLVUTJItCSiXzWU8QhMtzw+V/X/95CuVSyAfwAYDqk/NkHqO9k/We2axQEwnhpvTkTZttpjz7lCiFdh+lD2KySB9QMksXgTJLcWedvjxTC1ZPYjoiyFcpNgNOuiNcybEML4x0+x7Kp8wyHdG8YzQdsh7cR2AkARJNeo9lVtTwJwmIhuUSnv/wC8bJR0DcBaSN85uVXl1QMQA+AWALdB2h0QAOYQUaqWz6eGQn99iOsbzHwC6WHxDKToLv0BTIJpaLQUIvpAY9mq40gIMRTSNZT7qxzSw+MmSAvrGkL6Ph2P6644BCmaibVFqo8CeMso6TKkMXYF1x9KjhDRc2plMD4OEWl+AciCNLC0vLLtKZtf/CIiAEi1Y4ypvaabldkGkrVKPv6phnbEQIokIJ/zDaQYq+b5jO+JVEhWwDINbfwOQF0N7RCQ4tZWOHAdJtgo+wVIwlVrefOtlPW8rfNr8vNV9d+vGsq4CkkQpxulpbtwfH+p0IZv7ThfQBIvWq7PAUgRKbJtXTNI0+nG58bZ0SZN50ISV99qbPtmSDGpjdOSVMpNsjXOVM6zWbZR3sG4Lqy0vH6wUd5EAMUOjPlUJ4xB8/66EdJ2z1rqf9oZY8Eo/2hIDwZa6i4FcJ+Gz+cPaS2FtbKyXHWP88v7X9VxpRhu4zWlGmUzjFOosh5+hOtbvv4B6UfJKiRtsjDJKKkXTC3ZauetgLS18A8qWa4CeBGShapQQ3lERGmQ3C8yIVmTrHEJknC6B4CiVceo7H8DSITkd1xuJWsRpKlU1R3ZiOhFSFPD70Pypb0CDZtEuOrzVfVfZ0hWR7XNO74B0JWIttlqpxNRilNscwtoGSIiSGLiBajvTncJ0nbRPYjosr0NdBUk7XCWDOB/UO+TcwCeATCYqr8Fs9Mgok2QIpe8DSmsnhoVkMZVmo3ylhmVZyse8FVIwnU8gP9qbLI9VECKpf08rvv9m/MLgAFE9JozKyaiVZBm09bCdKGjMeWQLMsdSMVSbVZmOaQHmfsgWb9P4bphhGFs4rArBbl/VyKGcTtmrhQm05xVLga3AGgMyTr0G4AdRFRcjfoCIPkx3wRpswA9pB/Os5B+vI6R5Mtob7l1IQnbZpCmUMshuRj8AuAgObbNrt244vNVLS5MhuRm4Afp4eh7IvrN6okeTtXCwT4A4iGtvv8LknX4K5JCxHksVVFIkiD5uOshxfj9FcB3jozfmqRqwVx3SG5RDSG5xlyG1P79JC3itac8P0guS20hbXccDEnInYc05o86sz+tuTtU3X9JkPolHNKYOkhEB51Vv5V21YP0XdoU0kxHASS3rq/I9iY2DOM0WBgzTDWwJowZhmE8jer4kzOML8BRKRiGYRiGYRgGLIwZhmEYhmEYBkA1hLEQYqMQ4pwQolQIkS+E+EEI8aYQ4hYnto9hGIZhGIZhaoTqWIwHQ9oCVw/JSb8DgMcAHBJCvK8WvJ1hGIZhGIZhPBF/21ksyIe06cIBSKu7BaTYhXcCuLUqz0QAzYQQd1SFTmEYhmEYhmEYj8beqBQ9IIWjUQwdU7VD0Epcjxn7XFWMUqW8U1AV6zg4OLhz06ZN7Wk3Uw0qKyuh07F7eW2G+9g34H72DbiffQPu55rjxIkTeUTUUOmYXcJYC0KI+yAF6gekOITRtmKgJiYm0v79+53aDkadrKwsJCUlubsZjAvhPvYNuJ99A+5n34D7ueYQQhwgokSlY05/NKnameZ41b9hAHo6uw6GYRiGYRiGcTaustlnGb1v7aI6GIZhGIZhGMZpuEoY5xu9r++iOhiGYRiGYRjGabhKGEcYvb/sojoYhmEYhmEYxmm4Shj3NXp/wkV1MAzDMAzDMIzTcCSOsVWEEPfiul9xIYBdzq6D8Q6uXLmCCxcuoKxMMbof40LCwsJw7NgxdzeDcTHcz74B97N70Ov1iIqKQr169dzdFKYG0SyMhRCPA/ieiL63kucuAO8aJb1ORCWON4/xVq5cuYI///wTMTExCA4OhhDC3U3yKQoLC1G3bl13N4NxMdzPvgH3c81DRCguLsbZs2cBgMWxD2GPxfg2AAuEEMcBbAdwFNIiO3nnu6G4vvMdAOwE8LJzmsl4GxcuXEBMTAxCQkJsZ2YYhmEYD0IIgZCQEMTExOCPP/5gYexDOOJK0arqpQYBeAfAE0RU6lCrGK+nrKwMwcHB7m4GwzAMwzhMcHAwuwP6GPYI46cAfA6gO4AOAKIARFaVcRnSIrtdAJYRES+4Y9h9gmEYhvFq+HfM99AsjInoNwC/wdSHmGEYhmEYhmFqBa4K18YwDMMwDMMwXgULY4apRaxevRrp6elOK+/q1asQQji1TEdISkrCiBEj3NoGR3n88ccxceJEq3mOHDkCIQSysrLsKnvZsmVYv369443zUkpLS5GamooffvjBofPj4uLw9NNP11id+/fvR3h4OAoKCuw+l2GYmsXpcYwZhnEfq1evRl5eHu655x53N8WpLFy4EHq93t3NsJvTp0/jnXfewaFDh1xSfnp6Om6++WbcddddLinfUyktLcWcOXMQFxeHW265xe7z161bh4iICNsZnVRnYmIiOnbsiHnz5iE1NdWucxmGqVnYYswwjMdSXFwMAGjbti1atmzp5tbYz+LFi9GpUye0bt3admZGE/KYqA4dO3ZEs2bNnNAa7UycOBGLFy9GeXl5jdbLMIx9sDCuBpmHMxE3Pw66OTrEzY9D5uFMr6yDUeebb75B3759ERISgoiICDz44IMoLCwEAFy+fBlNmjTBuHHjTM4ZNmwY4uPjUVRUBOC6G8DSpUsRFxeH4OBgDBkyxBA4XqakpAQzZsxA06ZNERgYiA4dOmDTpk0WbXrnnXeQkJCAoKAgREdHY8SIESgoKMCECROwZs0afPXVV6hXrx6EECbWqQ0bNiAxMRFBQUFo1KgRZsyYYRGGaM2aNYiPj0dwcDD69OmDX375xeY1at68OZ555hmL9JEjR6JXr14AgL///huPPfYYWrVqhZCQEDRv3hyPPvoorly5YnKOEAJvvPEGpk+fjoYNGyIhIcHkGsr88ssvGDNmDJo2bYqQkBC0a9cO8+fPR2VlpSFPVlaWwT1h5MiRCA0NRYsWLbBw4UKLtn799dfo168fQkNDERYWhqSkJBMrb25uLsaMGYPw8HCEhIRg4MCBOH78uM1rs3z5ckUXkIULF6Jp06aoU6cOhg4dinPnzlnkef3119GlSxeEhYUhOjoaQ4cOxa+//mo4LrcxIyMDQggTl5fly5ejV69eCA8PR4MGDdCvXz/s37/fZnuFEHjrrbdM0lJTUxEZGWn4Pz09HUIIHD58GP3790edOnXQunVrrF271qK8devWoWvXrggODkZERAQGDx6MnJwcw/EjR45gyJAhqFu3LurWrYuRI0fi/PnzhuNyH27ZsgXDhg1DaGgoHnvsMcNmFxMnTjR89uzsbADA//3f/yEhIQGhoaFo0qQJUlJSTMoELF0pJkyYgMTERGzduhU333wz6tSpg169euHo0aOGPGp1du3aFRMmTLD47BMmTEDHjh0N/w8bNgwXL17Eli1bVK8/wzDux6eFcXVEZ+bhTEz5bApyCnJAIOQU5GDKZ1OcKlxroo7aDhFQVib9tZdvv/0Wt99+Oxo1aoRPPvkE8+fPx6ZNmwz+ovXr18d7772HFStWYMOGDQAkn8+NGzciIyPDZHOT3bt3480338Qbb7yB9957Dz/99JPF9PeIESOQnp6OZ599Fp999hm6dOmCYcOGmfg0vvTSS3jooYfQt29frF+/HosWLUJYWBiuXr2K559/Hv369UPHjh2xbds27N69Gw888AAAycXi7rvvRteuXfHpp59i9uzZWLp0Kf71r38Zyj548CBGjx6NDh06YO3atRg6dChGjRpl8zqNGjUKH3/8sUna1atXsXHjRowZMwYAUFRUhIqKCqSlpWHz5s148cUXsWPHDowcOdKivP/+9784d+4cVqxYgf/973+KdZ49exatWrXCwoULsWnTJjz44IOYPXs2Xn31VYu8Dz74IDp06IB169YhKSkJjz76KPbu3Ws4npWVheTkZOj1emRkZGDVqlXo3bu34cHl4sWL6NWrF44fP47Fixdj9erV+Pvvv3H77bdbtV4eP34cZ86cwa233mqSvmHDBjz66KO48847sXbtWiQkJGDSpEkW5585cwaPPfYYNmzYgHfeeQcVFRW49dZbDX6qCxcuRHx8PAYPHozdu3dj9+7dGDJkCAAgOzsb48aNw8cff4wPPvgATZs2Re/evfH777+rttde7rvvPgwbNgzr1q1Dy5YtMWbMGJw5c8ZwfMWKFbj77rtx4403YvXq1Vi2bBni4+Px119/AQB+/fVX9OzZEyUlJVi5ciXS09Nx9OhRDB06FGR2w06ePBkdOnTAp59+ismTJ2PHjh0AgOeee87w2W+44QYA0uZCzz77LDZu3Ij58+fj999/x2233Wby0KREbm4unnnmGcyaNQsffvghLly4gNGjRxvaolbn5MmT8cknn+Dq1auGsq5evYpPPvnEpF/r1auHdu3aYdu2bY5ecobxSrzOwEdEbn917tyZapqVP62kkLQQQioMr5C0EFr500pN58fOizU5V37Fzot1WhtdVcfOnTud0j5r/PzzzxZp06YR9e1bs69bbyXq1Ino0Uft/wy9evWipKQkk7Tt27cTADp8+LAhbcqUKRQVFUUHDx6ksLAwmjFjhsk5ffv2JX9/f8rJyTGk7dq1iwDQ5s2biYho27ZtBICysrJMzu3duzeNGDGCiIguXbpEwcHB9MQTT6i2+Z577qG+ffvSlStXDGmVlZXUrFkzmjBhgkne9957j4KCgigvL4+IiEaOHElt2rShyspKQ56XXnqJANCyZctU6zx48CABoN27dxvSPvjgA/Lz86Pz588rnlNWVma4BsbXBQB17NjRIn/fvn3pnnvuUSyrsrKSysrKKC0tjZo3b25I37lzJwGg559/3pBWWlpKkZGRNHPmTENa9+7dqXPnziaf25jnnnuOwsPDKT8/35B28eJFqlevHr311luK5xARZWZmEgC6evWqSXqXLl3ojjvuMEl74IEHCIDqvVleXk5FRUUUGhpKGRkZhvSOHTvS+PHjVdtARFRRUUFlZWXUqlUrmjNnjtW8AOjNN980SZs9ezZFREQY/l+2bBkBoPfee8+QlpeXR35+frRo0SJDnY0bN6bhw4er1nX//fdTfHw8Xbt2zZB24sQJ0ul09PnnnxPR9T6cPn26ybmFhYU2xyWRdN3OnDlDAOirr74ypMfGxtJTTz1l+H/8+PHk5+dHJ06cMKStW7eOANCxY8es1llQUEAhISH0/vvvG9Lee+89CggIMNxbxvXceuutVtushPH9zNQ8Sr9nzmTlTyspdl4svfbBaxQ7L1azDvEGqqu1XAWA/aSiSX3WYjxr+ywUlRWZpBWVFWHW9lmazs8tyFVMzynIcdrTkFodaumMJbqqEV5RYd95RUVF2L17N0aNGoXy8nLDq1evXtDr9Thw4IAh7+uvv446deqgR48eaNKkCf79739blNepUycTn8aePXsiKirKYLnctm0bGjVqhJ49e5rUl5ycbJgC3717N4qLi21GODDnxIkTyM3Ntfgst912G0pKSnDkyBEAwN69ezFs2DCTgPZ33323zfI7duyI+Ph4rFq1ypC2atUq9O3bF9HR0Ya0FStWoGPHjggNDYVerze4WZw4Ybof0ODBg23WWVJSgtmzZ+Omm25CYGAg9Ho9Zs2ahVOnTln4cA4YMMDwXq/Xo2XLlgbL5t9//43vv/8e48ePVw3kv23bNvTv3x/16tUzXLu6deuic+fOVt0Tzp8/j6CgINSpU8eQVl5ejoMHD+If//iHSV6l67xnzx70798fERER8Pf3R0hICK5evWpxvZQ4duwYhg8fjujoaPj5+UGv1+P48eOaztWK8XWNiIhAVFSU4boeP34cf/zxh9Wxum3bNgwfPhw6nc5wXZs3b464uDiL6ypbwrWwefNm3HrrrQgLC4O/vz+aNGkCwHKcmRMXF2fix962bVsAMLGCK1GvXj3DbI9Meno6hg0bZrHALzIy0sKtg/FtjGeGAdS6mWE1rTV+3XiPtSD7bFSK6orOZmHNDAPZnCmfTQEApCSkONY4G3U0C6vZRSPOYv78mq+ztBT46SfA3nU2ly5dQkVFBaZOnYqpU6daHD99+rThfWhoKO688068+eabmDx5MgIDAy3yR0VFKabJvqV5eXk4f/68YuQFPz8/AEB+fj4AGKaMtZKXlwdAXXDKn+X8+fMW7VRqtxKjR4/G+++/jzfeeAOFhYX44osv8OabbxqOr1u3DuPGjcMjjzyC//znPwgPD8e5c+cwfPhwlJSUmJRlLKbVmDlzJt59913Mnj0bnTp1Qv369bFhwwa89NJLKCkpQWhoqCFv/fr1Tc4NCAgw1Hnp0iUQkdVrmpeXhz179pgIf5nk5GTV80pKSizGQl5eHioqKmxe59zcXAwYMABdu3bFkiVL0LhxYwQEBGDIkCEW18ucwsJCDBgwANHR0XjjjTcQGxuLoKAgPPDAAzbPtQdr11XLWM3Ly8Orr76q6P5ifH8B2sYEAOzbtw/Dhg3D8OHD8X//93+IioqCEALdu3e3+dmVPg8ATdds8uTJSEpKwu+//w4iwjfffKO4PiAwMNCpfcB4P9aMdFo0RObhTMzaPgu5BbloFtYMaclp1dYezkRNU1WQZK2SHwSA6msmZ+Gzwri6ojMtOQ1TPptiMaAB+wa1vXWE6EOQlpzm8TeDp6DXA0JIAtke6tevb1i8piQoGzdubHi/b98+LFq0CB07dsRLL72Ee++9F40aNTLJf+HCBYsyLly4YBAO4eHhiImJsRqTVrY+nTt3zmQxlC3Cw8MBAEuXLjVZDCTTvHlzAECjRo0s2qnUbiVGjx6NF198Ebt27cKpU6dQWVlpYgX9+OOP0a1bN5OFb1999ZViWVq2YP3444/xz3/+EzNmzDCkbdy4UVNbjWnQoAF0Op3i4jeZ8PBwDBs2DM8//7zFMXlBltp5V65cQWVlJXRVUxeRkZHw8/OzeZ2/+OILFBUVYcOGDQaLc3l5OS5evGjzM+3evRtnzpzB1q1bTaJhaImhGxgYiFKzm+XSpUs2zzPHeKyqER4ejuHDhxv84I0xH99at+Vdt24dGjZsiFWrVhnOMV7s5yr69OmDli1bIj09HUSExo0bm1jUZS5fvmy4HxkGqJ6RTrY2yxrBE0WmNSOijLM0k7PwWWFsTXRqQe7A+9fer3jcGe4Och3mAhiAx98MnoIQQGAgYK+Rpk6dOujevTuOHz+OF154QTVfSUkJxo8fj4EDB2L16tXo0KEDpkyZgk8//dQk38GDB5Gbm2twp/j2229x4cIFdO3aFYBkeXz99dcRGhqqGtqrR48eCA4ORkZGBl577TXFPMZWO5lWrVohJiYG2dnZePDBB1U/S5cuXfDpp5/i5ZdfNogKpUgDSrRr1w7t27fHqlWrcOrUKdx+++0m08jFxcUW1tPMTMenz8zLq6iowEcffWR3OXXq1EG3bt2wfPlyPPbYY4oCLDk5GatXr0a7du0QHBysuexWrVqBiJCTk2N4+PD390fHjh2xYcMGPPzww4a85te5uLgYOp0O/v7Xv6JXr15t4Sai1+st+lteEGh8fb777jtkZ2ejc+fOVtvcpEkTHDt2zPB/ZWUltm/fruXjmiCPuYyMDAwdOlQxT3JyMo4ePYrOnTtrFr4yatbc4uJi6PV6k/KqM8601CkzadIkw4PfuHHjDDM9xmRnZyM+Pt4p7WFqB9Ux0lXX2uwqjA134cHhCPALQGmFdeuUJ7mI+qwwVhOd5oPJmmU2JSEFs7bPcqm7Q0pCClISUgztGLt2LHRCZ5iGkPGEm8FTCQy032IMAHPnzkVycjJ0Oh1GjBiBunXrIjc3Fxs3bkRaWhri4+Px3HPP4fz589i+fTtCQkKQnp6OPn36ID093SSEU8OGDTFkyBDMmTMHJSUlmDlzJjp16oQ77rgDANC/f38MHDgQ/fv3x8yZM9GuXTtcuXIFP/zwA0pKSvDyyy+jfv36eP755zFr1iyUlpZi8ODBuHbtGjZu3IjZs2cjJiYGrVu3xoYNG/D555+jZcuWaNy4MRo3bozXX38dY8eOxZUrVzBo0CAEBATg999/x/r16/HJJ58gJCQEM2fORLdu3TBq1ChMnjwZR44cwXvvvaf5eo0ePRoLFixAQUEB3nnnHZNj/fv3x6OPPoq0tDR069YNmzZtckhwGZf39ttv46abbkJ4eDjefvttXLt2zaGyXnnlFdx+++0YNGgQpkyZgjp16mD37t1ITEzEnXfeiSeffBIrV67Ebbfdhn/+85+IiYnBn3/+ia+++gq9evXCvffeq1hu165d4e/vjwMHDhiEMQA8++yzuPvuu/HII49g+PDh+Oqrr/DFF1+YnHvbbbehoqICEydOxOTJk3H06FG89tprFtP98fHx2LFjB7Zs2YKIiAg0b94c3bt3R2hoKB588EHMmDEDZ86cQWpqKmJiYmxei+HDh+Ptt99Gx44d0aJFC7z77rsWIfW0oNPpMHfuXKSkpCAlJQX33nsvhBDYsWMH7r33XiQmJiI1NRVdu3bFkCFDMGnSJERGRuLs2bPYunUrJkyYgKSkJNXyAwIC0Lx5c6xevRrt27dHUFAQbr75ZvTv3x/z58/H9OnTMXToUHz33XdYuXKl3e23p05ZMI8fPx7PPfccysvLVX2r9+/fj5kzZzqlPUztoDpGOk9ch2Ruxc4vltyqdEKHSqqEn/Cz0C+Ah7mIqq3Kq8mXO6JSaEHLasqaWHGpVIfSS6QKTeW5KyqFu8jJITp4kEgl6IBV9uzZQwMHDqS6detSSEgItWnThp544gm6fPky7dq1i3Q6HWVmZpqc8/TTT1NYWBidPn2aiK5HVFi0aBE1bdqUgoKC6I477qDc3FyT80pKSuiFF16gG2+8kfR6PUVHR9PAgQMNK/RlFi9eTG3atKGAgACKjo6mkSNHUkFBARER/fXXX3TXXXdR/fr1CQDNnj3bcN6mTZuoV69eFBISQnXr1qUOHTrQrFmzqKyszJBn9erVdOONN1JgYCD17NmT9u7dq2n1PxHRyZMnCQAFBgbS5cuXTY6Vl5fTU089RQ0bNqS6devS3XffTXv27CEA9NlnnxnyQSEqgvE1lDl//jzdddddVLduXYqKiqJnnnmGli5dSgCosLCQiK5HNDCOIKJUFhFRVlYW9e7dm4KDgyksLIySkpLo0KFDhuNnz56lCRMmUFRUFAUEBFBsbCylpKTQkSNHrF6TIUOG0KRJkyzS33zzTYqJiaHg4GAaNGgQbdmyxSIqxfLly6lFixYUFBRE3bp1oz179lhEU/jxxx8pOTmZ6tWrZ9JPmzdvpnbt2lFQUBAlJCTQxo0brUb2kCksLKRx48ZRgwYNKDo6ml588UV64YUXFKNSyNdZxrxtRERr1qyhTp06UWBgIIWHh9PgwYMpOzvbcPzYsWN0zz33UIMGDSgoKIhuvPFGmjJliuHeUetDIqItW7ZQQkICBQYGEgA6deoUERG9+uqr1KRJEwoJCaHk5GQ6ceKExbhSikph/jt06tQpi/GpVqdMz549qWfPnorX9uDBgySEsDhHCxyVwr14alSKmoiOZS9qbZK10SOfP+IRUSpgJSqFIEcCvDqZxMRE0hJ8vqaJmx+naA2ODYtF9vRsw/+ZhzMxbfM0w5NRRHAEFgxa4DTrrVo7bLVLjaysLKvWGGdw7NgxtGnTxqV1aOXPP4HTp4EOHSSf45omKSkJkZGR+OSTT2qszsLCQqv+r0zNsG7dOjzwwAP4448/FBdlVhfuZ8/h4sWLiImJwVtvvYXJkydbHP/Xv/6Fffv2ORTHmPvZvdTU75m9v83m1llAsjYvHbrUbbPHujk6ENR1ZWxYLNKS09y+RkoIcYCIEpWO+Wy4Ni3YM01RXH490H9+cX61wq2YB8PWIort8Y/2NWQ94og7BcNUh3/84x9o3LgxVqxY4e6mMC6isLAQ33//vWFHPiXXmr///hvvvPMOnnvuOTe0kKmtpCSkYOnQpYgNi4WAQGxYrFtFMWDbJSK3IBcpCSnInp6NytmVyJ6e7XEuoCyMraDWwebp1Y2JbIzSbncCygtT/ISfx9wMnowsjB10QWUYh9HpdHjnnXcUw/AxtYMDBw6ge/fu+O6777B8+XKTHS9lcnNz8cILL7h8po7xPWSRueJu6eF77Nqxbo0NnJachhC95T0g41G+xCr47OI7LWh1inemA7ySyCYQBITJ9IS7p0u8iaq1MW4TxllZWe6pmPEIunfvju7du7u7GYyLSEpKstjC2pw2bdp4jGsZU/vwpLBtcn3G7qUy3jKzzRZjK2idpggPVo5LqZZuDTUxTSCPmi7xJvz8JN9ithgzDMMwtQ1nzlo7g5SEFOTNyMPKu1d6pW5hi7EN5HBpNYVaTEOtC+sYZQIDWRgzDMMwtQ9PDNsG1Lx+chZsMXYCF4uVd6NSS7eGkn+Ot0w/eDIsjBmGYZjaiLX1UOaL+Z0VFMBdPsw1AQtjJ6B1kZ4WnL3K1JcGszXkTT4qK93dEoZhGIZxHmoGtcEtB1ss5nckYpZSUIDqRN7ydFgYOwFnW3mdFcpEbTA7Ysn2djhkG8MwDFMbUTOobTq5ySm+x57mw+xq2MfYCRhvL51TkAM/4WcyaGwJW3m7Z/ncCqowBMGujn+O2mA+W3jW4TK9FeOQbUFB7m0LwzAMwzgTJX/esWvHKua11/fYU32YXQVbjJ1ESkKKwXIs7wOuZbrB2KoLwK5zbaE2aEsrfM9s6u6QbUpkZWVBCIEjR464uyku4d///jdiYmKg0+kwYcIEdzfHaXz55ZeYP3++U8uMjIxEamqqzXwHDhxAgwYNcOXKFQDAN99849FjKD09HUIIXL16tdplvfXWWxBCOaa7r7N06VKsX7/eoXMnTJiAxETFDcBcUmdxcTGioqLwzTff2H0uYx/OcvN0pruoN8DC2Ik4Mt2gdI7Wc22hNmgD/AIcLtNb0esBnc6zhHGnTp2we/du3Hjjje5uitPZv38/Zs+ejcceewzffvstnn/+eXc3yWm4Qhhr5bnnnsPDDz+MevXquaV+xjOpjjB+/vnnkZ6eXmN1BgcH45///Get+k7wVJzl5ulrQQFYGDsRR6YbbE1FaNkOWg21wRxTN8bhMr0VITwnMgURoaSkBPXq1UP37t0RHBzs7iY5nV9++QUA8Oijj6JHjx61UvzXNCdPnsQXX3yBSZMmubspjIdQXFxc7TJuvPFGtG/f3gmt0c6ECRPw9ddf4/DhwzVarzdSnQX0zlrM74lbT7sSnxXGrojW4Mh0g62pCAHhcNvUBrMjG4/UBuwRxunp6QgICMDly5dN0o8ePQohBLZt2wYA2LhxI/r374+oqCiD0P3yyy9NzklNTUVkZCR27dqFLl26ICgoCB9//LGiK8Xrr7+OLl26ICwsDNHR0Rg6dCh+/fVXk/KSkpIwYsQIfPDBB7jppptQr149DBo0CGfOnDHJV1xcjBkzZiA2NhaBgYFo3rw5/vWvf5nkeffdd9GuXTsEBgYiNjYWc+fOtXltKioqkJqaimbNmiEwMBDt2rXDBx98YDg+YcIEjB0r+baFhYVBCGF1978jR45gyJAhqFu3LurWrYuRI0fi/PnzAICysjJ07NjRYnexf/7zn4iMjDTkk6eD169fj9atWyMoKAi9evXCzz//bFJXZWUlXnnlFdx0000IDAxEfHw8MjIyLNq0bt06dO3aFcHBwYiIiMDgwYORk5OD1NRUvP7668jJyYEQAkIIEzeRb775Bn379kVISAgiIiLw4IMPorCw0KTsr7/+Gh06dEBQUBA6d+6M7777zuY1B4CMjAzcfPPNaNmypdV8H330EQIDA7Fo0SIA18ffoUOH0L17d4SEhKBjx44WU9m2+nXnzp0QQuCPP/4wpPXo0QN+fn4m90lCQgJmzVKf6SopKcGMGTPQtGlTBAYGokOHDti0aZNJnmvXruGxxx5D/fr1ER4ejieeeAJlZWUWZf3000+49dZbERQUhHbt2mHTpk1ITEy0cN3R0i/myPeZMeb3bHZ2NoQQWL16NR566CGEhYWhSZMmmD17NirNQuD89NNPGDp0KOrXr4/Q0FB07doVW7duNRy/ePEipkyZgujoaAQFBeHWW2/F999/b1KGEAJvvPEGpk+fjoYNGyIhIQFJSUk4cOAAMjIyDGNStgAvX74cvXr1Qnh4OBo0aIB+/fph//79JmWau1LI7i+HDx9G//79UadOHbRu3Rpr1641uTZKdc6YMQMtWrSw2AlQ/j7966+/AABNmzZFly5dsHz5cqt94Os4IxqEsxbzO6scr4CI3P7q3Lkz1SQrf1pJIWkhhFQYXiFpIbTyp5U1Xq7SOeYvvzl+1W6bMTt37nRaWWr8/PPPLq/DXnJziQ4cIKqstJ330qVLFBAQQO+//75J+vPPP0/R0dFUXl5ORERvvvkmLViwgL744gv68ssv6YknniCdTke7du0ynDN79mwKDg6mFi1a0OLFi2nHjh30yy+/0M6dOwkAHT582JB3+vTplJ6eTjt37qQNGzbQoEGDqGHDhnT58mVDnr59+1KTJk2oR48etH79evrwww8pKiqKBg0aZMhTUFBA/fv3p9DQUHr11Vdp27ZtlJGRQQ888IAhz9y5c8nf35+effZZ+vLLL+nll1+mgIAAevPNN61em2effZb8/f3pxRdfpC+++IIefPBBAkAffPABERH9+uuv9NxzzxEA2rFjB+3evZsKCgoUyzp58iTVq1ePbrvtNlq/fj198skn1KZNG0pMTKTKqo766aefKCAggObNm0dERNu3bychBH300UeGcsaPH0+RkZHUvHlzWrlyJa1Zs4bat29PTZo0oeLiYkO+qVOnUp06dejVV1+lrVu30owZM0in09Fnn31myLN8+XICQGPGjKFPP/2UNmzYQNOmTaN9+/bR6dOn6b777qNGjRrR7t27affu3fTrr78SEdGuXbsoICCARo0aRRs3bqTly5dT48aN6Z577jGUffbsWQoJCaGkpCT67LPPaMmSJRQXF0fBwcE0e/Zsq9e9e/fu9PDDD5ukbdy40WQMvf/++6TX62nZsmWGPPL4S0hIoPfff582bdpE3bp1o8jISPr777819+vff/9Ner3ecN3l/4OCgujzzz8nIqL8/HwSQtDmzZuJiGjZsmUEgAoLCw31DBkyhBo2bEgLFy6kLVu20OTJk8nPz48OHTpkyDN9+nQKDAyk1157jTZt2kTDhw+nmJgYkn6yyFB/o0aN6JZbbqG1a9fSBx98QPHx8dSwYUMaP368IZ+WflGib9++FnnM79lTp04RAIqNjaUnn3ySvvzyS5o5cyYBoFWrVhnOO3bsGIWGhlLnzp3pww8/pC+//JL+85//0HvvvUdERCUlJdSxY0dq3rw5ZWRk0ObNm2nYsGEUGhpK586doytXrhAREQBq1KgRjRo1ijZv3kwbN26ko0ePUuvWrWnw4MGGMXnhwgUiIpozZw4tWbKEtm3bRps2baKxY8dSUFAQ/fbbb4a2jR8/nox/g+U+a9++Pf3vf/+jLVu20J133kl6vZ5Onz5NRKRa57FjxwiAxW9Mnz596O677zZJmz59Ot1yyy1W+8BTqKnfM/PrFjsvVlETxM6LrZH21GYA7CcVTep2UUxuEMauHGwrf1pJsfNiSaQKip0Xq0nQyudYE8fOEO4yviqMz58n2rePqLRUW/5hw4bRwIEDTdLi4+Pp0UcfVcxfUVFBZWVlNGDAAJo4caIhffbs2QSA1q9fb5JfSRgbU15eTkVFRRQaGkoZGRmG9L59+1K9evXo4sWLhrR58+YRACoqKiIiorVr1xIA2rBhg2LZBQUFVKdOHUpNTTVJNxf+5uTn51NISIjFeYMGDaL4+HjD/0qCSIn777+f4uPj6dq1a4a0EydOkE6nM4gtIqL//Oc/FBwcTPv27aPY2FgaNWqUSTnjx48nAPTtt98a0rKzs8nPz48WLVpERJIIF0JQenq6ybljx46lxMREIpL6sHHjxjR8+HDVNj/11FMUGxtrkd6rVy9KSkoySdu+fbtJHz/zzDMUHh5uIkhXrlxJAKwK48rKSgoMDKS33nrLJN1YGC9atIgCAgLoww8/NMkjj7/t27cb0g4dOkQADAJWa792797dMP63b99OkZGRNHr0aJo5cyYREW3YsIF0Op3hQch8HGzbto0AUFZWlkk9vXv3phEjRhARUV5eHgUFBdErr7xiOF5RUUGtWrUyEcZvvfUW6fV6OnPmjCHt+++/JwAmwlhLvyhhjzAeO3asSb4OHTrQ6NGjDf+PGTOGYmJiDPenOe+++y7p9Xo6ceKEIa2srIxatGhBTz/9tIkw7tixo8X5nTt3NvnMSsjfT61ataI5c+YY0tWEsSzaiaQ+Mb6XrNXZs2dPGjdunOH/3377jYQQJg+fcj1+fn4mD66eSk0KY2MNYU0TuBJHdIy3YU0Y+6QrhZpfb05BTrVdKhyZbpDPiQ2LVc1TK2IGTp8OJCW55zV9uiFMm1Z3itGjR2P79u3Iz88HAPzwww84ceIERo8ebchz5swZjB8/HjExMfD394der8eXX36JEydOmJQlhMCgQYNs1rlnzx70798fERER8Pf3R0hICK5evWpRXpcuXdCgQQPD/23btgUAnD0rheL7+uuvER4ejmHDhinWs3v3bvz9998YOXIkysvLDa/bbrsNf/75p4VbhsyRI0dQVFSEkSNHWlyrEydOGKZKtbJt2zYMHz4cOp3O0IbmzZsjLi7OZMp3xowZ6NChA3r16oWSkhIsXLjQoqyoqCjceuuthv9jY2PRuXNn7N27FwCwfft26HQ6DB8+3OQzJycn44cffkBFRQWOHz+OP/74AxMnTrTrcxQVFWH37t0YNWqUSdm9evWCXq/HgQMHAAB79+5F//79ERJy3fd/+PDhNsu/dOkSrl27hsjISMXj//vf/zB9+nSsWrUKY8aMsTgeEBCApKQkw//yeJH7WWu/9unTx+CC8fXXX6NXr17o27evSVqHDh1UFwdu27YNjRo1Qs+ePS36QO7vw4cPo6SkBP/4xz8M5+l0OpP/AWDfvn3o3LkzYmKur5no2rUroqOjDf9r7ZfqMmDAAJP/27Zta3IP7dixA6NHj1ZdT7Bt2zZ07twZzZs3N7QRAPr27Wvh+jB48GDN7Tp27BiGDx+O6Oho+Pn5Qa/X4/jx4xbfJ7Y+U0REBKKiolS/F4yZPHky1qxZY4hEkp6ejujoaNxxxx0m+SIjI1FRUWH3d0Zt5mLxRRPXCTX8hJ/L2pB5OBOTNkwycd+YtGFSrd3MQwmfFMbW/HrduZuL0mI5Y2przMCawt6QbcOGDYNer8eaNWsAAKtWrUKTJk3Qq1cvAJK/6rBhw/Ddd9/h3//+N3bu3Il9+/Zh0KBBKCkpMSmrQYMGCAiwHg0kNzcXAwYMABFhyZIl+Pbbb7Fv3z5ERUVZlFe/fn2zzyaVLee7ePEibrjhBtW68vLyAADt2rWDXq83vPr16wcAOH36tOJ5586dAwAT8WH8/8WL9m0ek5eXh1dffdWkDXq9Hr///rtJG/z8/DBy5Ehcu3YNo0ePRkREhEVZUVFRimlym/Py8lBRUYGwsDCTuiZMmIDy8nKcO3fO8BBk7dopcenSJVRUVGDq1KkmZQcGBqKsrMzwWc6fP2/RzpCQEISGhlotX+7XQDkgtxlr1qzBTTfdhOTkZMXjdevWhU53/evefLxo7dfevXvjyJEjuHz5Mr755hv07t0bvXv3xv79+1FSUmJIUyMvLw/nz5+36O/U1FSTawRY9qf5/+fPn0fDhg0t6jBO09ov1UXpfjS+Z/Pz823ej3v27LG4LsuWLbNoo3kfqVFYWIgBAwbg9OnTeOONN/DNN99g37596NChg8X3iSOfSY1Ro0ZBp9Nh9erVICJkZGRg3Lhx8Pc33TZBHstayvQVzhaeVY1SZYwc1tUVTNs8zSKka2lFKaZtnuayOj0Nn9zgIy05DVM+m6I4AGXLrCsdy+UNPXILctEsrJlhI4+UhBR8m/stFu1fpHie18cMdFOIK5nAqrUwWoVxaGgohgwZglWrVmHKlClYvXo1Ro4caYil+uuvv+LQoUPYvHmziTVEaaW4lvirX3zxBYqKirBhwwbUqVMHAFBeXm632ASA8PBwg9hROw4An3/+ueIPbatWrRTPk3/cL1y4YCJO//zzT5Ny7Wnn8OHD8cADD1gcM7aO5uTkYM6cOejYsSMWL16MBx980GIl/YULFyzKuHDhAtq1a2eoy9/fH99++62JSJSJiooyLMiydu2UqF+/PoQQSE1NVbToNW7cGADQqFEji3YWFRXZjPMrX1fzxaAymZmZeOSRRzBs2DBs3rwZQXbuYqO1X3v27AlAWoS2Z88evPrqq2jXrh1CQ0Oxfft2HDx4EM8884zVzxETE2M1zFejRo0MbTEeT+bXrVGjRjh+/LjF+cYWSK39okRQUBBKzbbKvHTpkmp+a0RERNi8HxMTEw0LJo0xfxjSGst59+7dOHPmDLZu3YrWrVsb0gsKCjS22jHq1KmDMWPGID09HbGxscjNzVWcgZHHsr3fGbUZrXsMWJtdri75xfl2pddGfFIYy6L3/rX3Kx53pWVWXmUqi3J5lalMxo+WK+SB2h0zsKbQ6SSrsT0h28aMGYPRo0fjs88+w++//24yTS0LYOMfrpycHHz77be4+eab7W5fcXExdDqdiWVl9erVhmlVe+jbty/mz5+Pzz//HHfeeafF8R49eiA4OBh//PEHhgwZornc9u3bIyQkBB9//DFeeOEFk3bGx8crWvCskZycjKNHj6Jz586qP/hEhEmTJqFFixbYvXs3br/9dowbNw7ff/899Hq9Id+FCxfw3XffGdwpcnNzcfDgQcOP8m233YaKigoUFBSgf//+inW1atUKMTExyMjIwNChQxXzKFnO6tSpg+7du+P48eMm18WcLl264P3330dRUZHBnWLdunWq+WWCgoLQrFkznDp1SvF4kyZNsH37dvTu3Rv33HMP1q9fb3JtbKG1Xxs0aID27dtj3rx58PPzQ8eOHSGEQK9evTB37lyUl5dbtRgnJyfj9ddfR2hoqIlYMyYhIQFBQUHYsGGDIU9lZSU2bNhgkq9Lly744IMPcPbsWYM7xd69ew1iHtDeL0o0adIEX3/9tUmaecQZrSQnJ2P16tVIS0tTfGhJTk7Gl19+iWbNminOfNiKoKE0JpW+n7777jtkZ2ejc+fOjnwMm3XKTJ48Gd27d0dqaiq6d++u2NfZ2dmIiIhQnP3xVbTsMeAMLaBmnGMkfFIYA5I4lrdhNseVlllbm4AoWbH9hJ9izEAe3PZjrzAePHgwQkJC8NBDD6F58+bo2rWr4Vjr1q3RpEkTPPXUU3jxxRdRWFiI2bNnm/g82oMs3CZOnIjJkyfj6NGjeO211yymNLWWNXDgQNx333144YUX0KlTJ5w7dw5ff/01lixZgvr16yM1NRXTpk1DTk4O+vTpg8rKSpw4cQI7d+5UFWvh4eGYPn06XnrpJfj7+yMxMRFr167Fpk2b8OGHH9rdztTUVHTt2hVDhgzBpEmTEBkZibNnz2Lr1q2YMGECkpKS8Pbbb2PXrl3Yt28fAgMDkZ6ejg4dOiAtLc1kt7jIyEjcf//9eOmllxAcHIzZs2cjKirKELqrVatWePjhhzFmzBjMmDEDiYmJKCkpwdGjR3HixAm8++670Ol0mDt3LlJSUpCSkoJ7770XQgjs2LED9957LxITE9G6dWv8+eefSE9PR/v27REZGYm4uDjMnTsXycnJ0Ol0GDFiBOrWrYvc3Fxs3LgRaWlpiI+Px/Tp0/H222/jzjvvxJNPPok//vgDL7/8sqZY1j179rTqE9uiRQts3boVffv2xf33348PP/xQ0TKuhD392rt3b7z99tsYOHAg/Pz8DGnPPPMMWrZsaXWqv3///hg4cCD69++PmTNnol27drhy5Qp++OEHlJSU4OWXX0ZERASmTJmC2bNnw9/fH+3atcM777xjYVWfOHEiXnrpJdx5552YPXs2iouLMXv2bDRs2NDkc2vpFyWGDx+O9957D0888QSGDBmCnTt34osvvtB0Pc2ZPXs2unTpgj59+uCpp55CREQEDh06hIiICEyaNAnjxo3D4sWLkZSUhKeffhotWrRAfn4+9u7di0aNGinOqBjTunVrbNmyBVu2bEFERASaN2+O7t27IzQ0FA8++CBmzJiBM2fOIDU11eHvJy11yiK3W7duaNeuHXbt2oUlS5Yonr9//36TNQEMEFM3BgJC1b84NizW6u+8Fk1gzTiXkpCCiOAIRetwRHCESRm1WnuorcqryVdNR6WQcVXYNmuorTQVqcLqMS1tD3gxgCJejbC5ktRXo1IQEf3+O9EPP9h3TkpKCgGg//u//7M4tnfvXurSpQsFBQXRTTfdRMuWLbNY5T179myKiIiwOFcpKsXy5cupRYsWFBQURN26daM9e/ZQbGwsPfXUU4Y8WlbLX7lyhYqKiuipp56imJgYCggIoLi4OHr22WdNzluxYgV16tSJgoKCqH79+tS1a1d6/fXXrV6P8vJyeuGFF6hJkyak1+upTZs2tHKl6VjTGpWCSApldc8991CDBg0oKCiIbrzxRpoyZQqdPn2aTp48SSEhIZSWlmZyzltvvUX+/v504MABIrq+sn7NmjXUsmVLCggIoFtvvdUi6kBlZSXNmzeP2rZtSwEBARQZGUl9+vQxifpBRLRmzRrq1KkTBQYGUnh4OA0ePJiys7OJiKi4uJgmTJhADRs2tIiAsGfPHho4cCDVrVuXQkJCqE2bNvTEE0+YhNvbuXMnJSQkUEBAAHXo0IF27dpFERERNsO1ffzxxxQaGmoS2cA8XBsR0cGDByksLIwmTZpElZWVquMPgEloPi39SkT00UcfEQCTPtmzZw8BMInGQqQ8DkpKSuiFF16gG2+8kfR6PUVHR9PAgQNNopCUlJTQI488QvXq1aP69evTY489Rq+//rpJVAoioh9++IF69OhBAQEBFB8fT+vWraOWLVvStGnTTPJp6Rcl/vOf/1CTJk0oNDSUUlJSaMOGDYpRKcwjLph/BxAR/fjjjzRo0CAKDQ2l0NBQ6tq1K23bts1w/PLly/T4448brn9MTAwNHz6cdu3aZRKVQimc4m+//UbJyclUr149AmAI17d582Zq164dBQUFUUJCAm3cuNHi+0MtKoX5vWv+PaRWp8ysWbMoODhYMVRjWVkZRUREWESI8VRqMirFI58/YqEFtOgSrXrGVlSulT+tJP2/9SbH9P/WG8pxh25yBbASlUJIx91LYmIima+8rSlq+sknbn6copVa9hlSO5Y9PVtTOcaE6EMULc1ZWVkmK9RdwbFjx9CmTRuX1uEIf/whvTp1klwraiuFhYWoW7euu5tRY0yYMAFHjhyxWMFfmygtLUWTJk3w9ttvG6JH+Fo/2+LUqVOIj4/H0qVL7Y4s4sl4Yz937doVrVq1wooVKyyObdmyBaNGjcIff/xhWE/hydTU75n82+yILrGmLYz1g26OTtEiLSBQObsSmYczMW3zNIPVOCI4AgsGLTDUr7UeT0cIcYCIEpWO+awrhYy86K2mUFr4Z+wzZO2YMVr8oGtiIaG3IbvbXbsG1MKdmJlaTEBAAJ555hksWLDAIqyar/Lyyy+jcePGhkVeL7/8Mho2bIh77rnH3U3zWfbv348dO3Zg3759ePvttxXzzJs3D0888YRXiGJ34IgusRaGNm5+nEFkhweHK7pKNAtrZuFmAQDF5aaLydXqqU1Rs3xeGNc08mC39jSo5UlRbXCbU5sGqzNgYcx4M4899hiKiopQUFCAsLAwdzfH7QghMGfOHPzxxx8IDAxE79698dprr6nGUWZcT5cuXVC/fn28/PLL6NKli8Xx4uJi9OjRA0888YQbWld7MLcqq2kCAWGw8OYU5ECv0yPAL8AkAoZsgLO2BkrWIc3CmtX42qyaxuddKbyRzMOZmLh+Isoqy2zmVZre8GVXirIy4McfgaZNAY3hQL0Sb5x6ZeyH+9k34H52LzXtSmELJcuuXqeHEMJE8Kot5IsIjkBoQKiFAc6Wm4Va3Wpum54Mu1LUMmZtn6VJFAsIDG6pfZckX8DfH/Dzsy8yBcMwDMN4CkqW3bLKMgvBq7YO6WLxReTNyLNI12IN1jLr7e3U4uVHtRdr7hEC12PBEggZP2b41FaOthBCcqfgzZYYhmEYb0RNA1wsvojs6dmonF2J7OnZqhuB6IQOujk6xM2PM9EHSrvvKq1zSklIMamnNoligIWxV6Lmy+Mn/CymQYxjJDMSgYFsMWYYhmE8h8zDmTh84bCiYDVHTQOYpysJXUDaUppAhhjGcl0pCSlYOnQpYsNiISAQGxbrdS4SzoCFsReiNNgD/AJU90/nBXimBAUBpaVAZaW7W8IwDMP4OrLfbmlFqaJgNccey66x0PUTfhZlFZUVYdrmaYibHwfdHB1mbZ+FtOS0WmsN1gILYy/EfLBHBEfA2iLK2rRa1BkEBgJEkjhmGIZhGHeiFg1i/LrxihZkeyy7xm4PlaRsDcovzkdOQY6JKJ+6capBLNuyYNc2ePGdl2Ic5zBufpxq6DZn7Kte2zAO2RYU5N62MAzDML6N2qyuPAtsvm2z/Ndea661BXnGFJUVYfH+xQbXTKX6azNsMa4FWHOVCPYPxti1Y33uic8ashhmP2OGYRjG3WiZ1XXGeiE1n2MlfHm9EgvjWoDaTSUgkF+cr8lnyZfw95e2g3Z3ZIoRI0a4PJ60LdLT0yGEwNWrV93aDldQWVmJRx99FNHR0RBCIDU11d1NchqrV69Genq608q7evUqhBCayly7di1uuukmVFRI1ixPH0OpqamIjIx0SllPP/004uLinFJWbWPu3LnIyspy6NykpCSMGDGixuo8e/YsQkND8fvvv9t9rivQKljlXewcdW/Q4nNsDV9Zr8TCuBagdFMpBfb2pSc+awghWY3ZYgwMGTIEu3fvRkiINiuCN7F27VosXLgQL7/8Mnbv3o0HHnjA3U1yGs4WxlqprKzECy+8gGeeeQZ+fvb9qDK1m+oIY/k+rak6Y2JiMHr0aPz73/+2+1xXIAvWAL8Aq4JV3sWuOsYuLT7HavjKeiUWxm4g83CmU53alRzxlXavAXznic8Wvh6yraKiAqWlpWjYsCG6d+8Ona72fRX88ssvaNCgASZNmoTu3bujSZMm7m6S17N9+3b89ttvuO+++9zdFMZDKC4urnYZbdu2RcuWLZ3QGu1MnDgRH374IfLzldfn1DQpCSlIiEpA5exKZAzPqBFjl5rQraOvoynqRW2l9v0aejhyWBZHn/rURLV5wG21wN6+8sRnC1kY29oRffXq1UhISEBgYCCaNm2KWbNmoby83CTPDz/8gOTkZISEhKBBgwZISUnBn3/+aZLn9OnTGDx4MIKDgxEXF4d3333XZhtTU1PRqFEjVJrFldu4cSOEEPj1118BAMuXL0evXr0QHh6OBg0aoF+/fjh48KDJORMmTEBiYiLWr1+Pdu3aISgoCN9//73iNPj//d//ISEhAaGhoWjSpAlSUlJw/vx5k/Li4uLw9NNPY968eWjSpAkaNGiAMWPG4PLlyyb58vPz8dBDD+GGG25AUFAQWrVqhfnz5xuOV1ZW4pVXXsFNN92EwMBAxMfHIyMjw+a1KSoqwuOPP45GjRohKCgIXbp0wZdffmk4npSUhOeffx6XLl2CEAJCCGRnZ6uW980336Bv374ICQlBREQEHnzwQRQWFgIALl++jCZNmmDcuHEm5wwbNgzx8fEoKioy1DlixAgsXboUcXFxCA4OxpAhQ3D27FmT80pKSjBjxgw0bdoUgYGB6NChAzZt2mTRpnfeeQcJCQkICgpCdHQ0RowYgYKCAkyYMAFr1qzBV199hXr16lm4iWzYsAGJiYkICgpCo0aNMGPGDJSVme6UuWbNGsTHxyM4OBh9+vTBL7/8YvOaA0BGRgYGDBhgc3vi//73vwgKCsKnn34K4Pr427p1K26++WbUqVMHvXr1wtGjR03Os9Wvy5YtQ506dUw+T+PGjRERcT0yT2VlJerXr4933nlHtX0XL17ElClTEB0djaCgINx66634/vvvTfJcvnwZ9913H0JDQ3HDDTcgLU1ZFGRlZeHmm282tHfv3r2IjIy0cN3R0i/myPeZMeb3bFZWFoQQyMrKwsiRIxEaGooWLVpg4cKFFuV9/fXX6NevH0JDQxEWFoakpCQcOnTIcDw3NxdjxoxBeHg4QkJCMHDgQBw/ftxwPDs7G0IIZGZmYty4cahfvz6GDh2KuLg45OfnY86cOYb7Tbbkvv766+jSpQvCwsIQHR2NoUOHGr67ZMxdKWT3l0OHDqF79+4ICQlBx44d8c0335hcG6U6R40apeiilpqaiujoaMM179mzJ8LDw/HRRx9Z7QN3UFPGLrWwb0uGLtEc9cLZhj6PgIjc/urcuTP5CrHzYgmpsHjFzou1ee7Kn1ZSSFqIyXkhaSG08qeVduXduXOn8z+YGT///LPTylr500qKnRdLIlVQ7LxYxc9rL3/9RbRvH1FJiXqeLVu2EAAaN24cbd68mV599VUKCAighx56yJDnwoULFBYWRt27d6d169bRihUrKCYmhhISEujatWtERFRZWUkdO3akpk2bUmZmJq1Zs4bat29PjRs3pr59+6rW//PPPxMA2rFjh0n62LFjyfiemTNnDi1ZsoS2bdtGmzZtorFjx1JQUBD99ttvhjzjx4+niIgIatmyJa1YsYK2bt1Kp0+fpmXLlhEAKiwsNOSdOHEiffDBB5SVlUUff/wxde/endq0aUMVFRWGPLGxsdS0aVMaMmQIbdy4kZYsWUJ16tShRx55xJCnqKiI2rdvT1FRUfT222/T9u3bacmSJfTMM88Y8kydOpXq1KlDr776Km3dupVmzJhBOp2OPvvsM/WOIaL77ruPQkND6X//+x9t2rSJhg8fTv7+/vTNN98QEdHRo0dp8uTJFBYWRrt376bdu3dTiUpn79q1iwICAmjUqFG0ceNGWr58OTVu3JjuueceQ54vvviCAND69euJiOj9998nnU5H3333nSFP3759qXHjxtS+fXtas2YNZWZmUpMmTSgxMdGkviFDhlDDhg1p4cKFtGXLFpo8eTL5+fnRoUOHDHlefPFFEkLQo48+Sps3b6Y1a9bQpEmT6MyZM/Trr79Sv379qGPHjrRt2zbavXs3nT59moiIVq1aRTqdjh555BHasmULLVy4kMLCwuipp54ylH3gwAHy8/OjESNG0KZNm2ju3LnUvHlzAkDLli2zet1vuOEGeuWVV0zSzMfQnDlzKDg4mLZs2WLIM378eGrYsCF16NCBPvroI9qwYQO1bNmS2rVrR5WVlZr79eTJkwSA9uzZQ0REJ06cID8/P9Lr9XTkyBEiIjp48CABoGPHjhER0ezZsykiIsJQR0lJCXXs2JGaN29OGRkZtHnzZho2bBiFhobSuXPnDPnuuusuql+/Pi1dupQ+/fRT6tOnD8XExFBsbKwhz5kzZyg4OJiSk5Pps88+o3feeYduuukmCgkJodmzZxvyaekXJWJjY+mpp56iK1euqF7vnTt3EgC66aab6MUXX6Qvv/ySJk6cSADo+++/N5y3c+dO8vf3p/79+9Mnn3xCmzdvpueee85wr+Xn51PTpk3plltuoVWrVtFnn31GPXv2pCZNmlBRUREREZ06dYoAUKNGjWjq1Kn05Zdf0vbt2+ngwYMUFhZGkydPNtxvBQUFREQ0ffp0Sk9Pp507d9KGDRto0KBB1LBhQ7p8+bKhbX379jW532bPnk3BwcGUkJBA77//Pm3atIm6detGkZGR9Pfffxv6WanOL774goQQ9PvvvxvKq6yspLi4OHryySdNru9dd91Fd911l9U+IHLu75k1rP02V0c7WMPW76u14/ZoEk8DwH5S0aRuF8XkY8JYpArFwS1Shc1z7b0x1Aa0NwljV914V65Iwtjou9mCbt26UVJSkknaq6++SjqdziBEZs6cSWFhYYYfASKiPXv2EAD64IMPiIho48aNJj/mRETZ2dnk5+dnVRgTEd18880mQrykpITq1atH//3vfxXzV1RUUFlZGbVs2ZLmzJljSB8/fjwBMBFfRJY/suaUl5fTmTNnCAB99dVXhvTY2Fhq0aIFlZWVGdKmTZtG0dHRhv8XL15MQgiLOmVOnjxJQghKT083SR87dqyFmDTm559/tjivoqKC2rVrRwMGDDCkmQsiNXr16mXRz9u3bycAdPjwYUPalClTKCoqyvCDPGPGDJNz+vbtS/7+/pSTk2NI27VrFwGgzZs3ExHRtm3bCABlZWWZnNu7d28aMWIEERFdunSJgoOD6YknnlBt8z333EN9+/Y1EUyVlZXUrFkzmjBhgkne9957j4KCgigvL4+IiEaOHElt2rQxEaQvvfSSTWF89uxZAkCff/65SbrxGPrXv/5FoaGhFp9v/Pjx5OfnRydOnDCkrVu3zkTAau3XG264wTD+33vvPerUqRN1796dFi1aRERECxYsoIYNGxrym4+Dd999l/R6vUlbysrKqEWLFvT0008TEdGRI0cIAH300UeGPIWFhdSgQQMTYfz0009TRESEQTgSSSIYgEEYa+0XJewRxs8//7whT2lpKUVGRtLMmTMNad27d6fOnTub9Lsxzz33HIWHh1N+fr4h7eLFi1SvXj166623iOi6MFYSkxERESYPA0qUl5dTUVERhYaGUkZGhiFdSRgDoO3btxvSDh06ZHIvqdVZUVFBTZs2pRdeeMGQpnQ/y/U0btzYapuJPEMYu0OE2qrTVWK9JrAmjNmVAjU7FaB1K0cl1KZM1NJrw37maoHPq7uI0DiWsRIVFRU4ePAgRo4caZI+evRoVFZWYvfu3QCAvXv3YsCAAahXr54hT7du3RAXF4ddu3YZ8kRHR6Nbt26GPLGxsejcubPNdo4ePRpr1qwxuG9s3rwZhYWFGDVqlCHPsWPHMHz4cERHR8PPzw96vR4nT57EiRMnTMqKiYnBLbfcYrPOzZs349Zbb0VYWBj8/f0Nvrnm5fXr1w/+/tdDobdt2xYXLlwwTFXu2LEDHTt2VK1z+/bt0Ol0GD58OMrLyw2v5ORk/PDDD4aoB+bs27cPRGTSNzqdDiNHjjRcc60UFRVh9+7dGDVqlEkbevXqBb1ejwMHDhjyvv7666hTpw569OiBJk2aKC7c6dSpE5o1u34v9+zZE1FRUdi7dy8AYNu2bWjUqBF69uxp8Zn3798PANi9ezeKi4sxceJEuz7LiRMnkJuba/FZbrvtNpSUlODIkSMApPE4bNgwCCEM59599902y5fdadQiPDz55JNYuHAhvvzyS/Tt29fieFxcnIkfadu2bQEAZ86cAaC9X3v37m2YUv/666/Rp08f9OnTxyStV69eqp9j27Zt6Ny5M5o3b264RgDQt29fQx/s27cPAPCPf/zDcF5oaCj69+9vUta+ffvQv39/BAcHG9KGDRtmkkdrv1SXAQMGGN7r9Xq0bNnScG3//vtvfP/99xg/frxJvxuzbds29O/fH/Xq1TO0sW7duujcubPhusgMGTJEc7v27NmD/v37IyIiAv7+/ggJCcHVq1ctvk/MCQgIMHGJMB8vauh0OkycOBHLly83uNekp6cjMTER7du3N8kbGRmJCxcuWN0gy1Nwx3bNtn5/7dUk3oLPC+Pq+vzai9atHJWojqj2Vlx14+n1Usg2NWGcl5eHsrIyREdHm6TL/1+8eBEAcO7cOYs8cj45z/nz5xEVFWWRRynNnNGjRyMvLw87duwAAKxatQo9evQwiK/CwkIMGDAAp0+fxhtvvIFvvvkG+/btQ0JCAkrM4tEptdOcffv2YdiwYWjSpAlWrFiB3bt3Y8+ePQBgUV79+vVN/g8ICAAR4VrVRc3Pz8cNN9ygWldeXh4qKioQFhYGvV5veE2YMAHl5eU4d+6c4nnnzp1DaGioRSSN6OhoFBUVGerXwqVLl1BRUYGpU6eatCEwMBBlZWU4ffq0IW9oaCjuvPNOXLt2DZMnT0ag/HRlhFo/y58lLy8P58+fN6lLr9cjNTXVUJe8GMjatVMiLy8PADB48GCTsps3bw4AhvKVxqOWsSj3v9LnBiS/5c6dO6NLly6Kx5XGi3G5Wvu1d+/e2LVrF4gI33zzDXr37m0ilnft2oXevXurfo68vDzs2bPHog+WLVtmco3q1q2LILMdgMyv0/nz59GwYUOTtKCgIISGhprUB9jul+qidH3la3vp0iUQkc37cdWqVRbXZefOnRZt1PJdAkg+ywMGDAARYcmSJfj222+xb98+REVFWXyfmFO3bl2TRcHm48UaEydORE5ODnbu3InCwkKsWbMGkyZNssgXGBho8nDk6dS0scvW729t1SQ+v/OdtSciVww6ucxZ22chtyAXzcKaIS05TVNdaclpmPLZFJP21vaVomo79VT3xhNCshqrfcdGRkZCr9fjwoULJunyorrw8HAAkngxzyPnky3CjRo1Usxz4cIFE0uTEjfeeCMSExOxatUq9OrVC5999hn+85//GI7v3r0bZ86cwdatW9G6dWtD+pUrVxQ+s7KlyJh169ahYcOGWLVqlSF/To7tnZKUiIiIsFhkY0x4eDj8/f3x7bffKkbFUBNrN9xwA65evYqioiITEfXnn38iJCREVbgpUb9+fcPitcGDB1scb9y4seH9vn37sGjRInTs2BEvvfQS7r33XjRq1Mgkv1o/y4IkPDwcMTExWL9+vWqbIiIiAEhC0Z74u/KYXLp0KTp27GhxXBZiSuNRqd1q5ZsvsJT5/PPPceedd2LcuHFYuXKl3ZFOtPZr7969cfHiRWzduhWnTp1C79694e/vj7Nnz+LLL7/En3/+aVUYh4eHIzExEYsWLbI4JtfRqFEjFBYWoqSkxEQcm1+nRo0a4a+//jJJKykpMVnMqrVflAgKCkKp2d71ly5dUs2vRoMGDaDT6VQfNuV2Dhs2DM8//7zFMfPFllq+SwDgiy++QFFRETZs2IA6deoAAMrLyw1GA1cRFxeH22+/Henp6Th16hQqKytx7733WuS7fPkyQkNDodfrXdoeb8XW729t1SQ+bzF2x1SAo0997phKcTfVsbDbwlrINj8/P3Tu3Bkff/yxSfrq1auh0+nQo0cPAJLbxJYtWwwRDABJQGVnZxumc7t06YI///zTZNV7bm6uReQINcaMGYN169Zh3bp1KC4uNplqlkMlGYvB7777zmExW1xcDL1eb/LDl5np2OxJcnIyDh06hJ9++knx+G233YaKigoUFBQgMTHR4iVbiMzp0qULhBD45JNPDGlEhE8++cTqFLoSderUQffu3XH8+HHFNsjCuKSkBOPHj8fAgQOxa9cuhIeHY8qUKRblHTx4ELm51787vv32W1y4cAFdu3Y1XJPz588jNDRUsT4A6NGjB4KDg61G5zC2Bsq0atUKMTExyM7OVixbFtxdunTBp59+ajJ9vHbtWpvXKi4uDgEBATh16pTi8YSEBGzevBmff/45Hn74YZvlmaO1XxMSElC/fn2kpaWhdevWaNiwIRo0aID27dsjLS0NoaGhigJUJjk5Gb/++iuaNWtmcY0SEhIMbQGkSBIyV69exdatWy3avHXrVpOQZXIkDhmt/aJEkyZNcOzYMZM04ygdWqlTpw66detm4l5gTnJyMo4ePYp27dpZtLFVq1Y261Aak8XFxdDpdCYuV6tXr3aahVapTpnJkydjzZo1WLhwIe666y4LizogRdmIj493SltqI7Z+f2urJvF5i7GrLJLVJfNwpqJV2ZH90b2Z6ljYbREUBBQUSCHblAwgc+bMwcCBAzFx4kSMGTMGhw8fxvPPP48HH3zQ4Hf75JNPYtGiRRg4cCBmzpyJq1evGsKd3XPPPQCkKdQOHTpg5MiRePXVVxEYGIjZs2drmr4GgFGjRuGZZ57BM888gz59+phMh3bv3h2hoaF48MEHMWPGDJw5cwapqakmlk576N+/P+bPn4/p06dj6NCh+O6777By5UqHyho3bhzefvttDBgwAKmpqWjVqhVOnTqFEydO4JVXXkGrVq3w8MMPY8yYMZgxYwYSExNRUlKCo0eP4sSJE6oh7dq0aYN7770Xjz32GAoLC3HjjTfinXfewS+//KJoBbTF3LlzkZycDJ1OhxEjRqBu3brIzc3Fxo0bkZaWhvj4eDz33HM4f/48tm/fjpCQEKSnp6NPnz5IT0/HhAkTDGU1bNgQQ4YMwZw5c1BSUoKZM2eiU6dOuOOOOwzXd+DAgejfvz9mzpyJdu3a4cqVK/jhhx9QUlKCl19+GfXr18fzzz+PWbNmobS0FIMHD8a1a9ewceNGzJ49GzExMWjdujU2bNiAzz//HC1btkTjxo3RuHFjvP766xg7diyuXLmCQYMGISAgAL///jvWr1+PTz75BCEhIZg5cya6deuGUaNGYfLkyThy5Ajee+89m9cpKCgInTt3xoEDB1T9n7t27YrPPvsMgwYNQr169fDaa69p7get/arT6dCzZ09s3LgRDz30kCG9d+/eePvtt9G/f3+rm4+MGzcOixcvRlJSEp5++mm0aNEC+fn52Lt3Lxo1aoQnnngC7dq1w7Bhw/DII4/gypUruOGGG/Df//7Xws1j+vTpePvttzF06FA88cQTOH/+PF555RWEhIQYLOY6nU5TvygxfPhw/POf/8Rrr72GXr16Yc2aNRYh7rTyyiuv4Pbbb8egQYMwZcoU1KlTB7t370ZiYiLuvPNOPPnkk1i5ciVuu+02/POf/0RMTAz+/PNPfPXVV+jVq5eixdWY1q1bY+PGjbjjjjsQGhqKVq1aGR5+J06ciMmTJ+Po0aN47bXXFEWqIyjVKVu377rrLkydOhUHDx5U3Txk//796Nmzp1PaUhvR8vtbKzWJ2qq8mny5MyqFJ4YbcXWbvCkqhSu5cMF2yLaPPvqI2rdvT3q9nmJiYujZZ581icRAJIUN6tevHwUHB1NYWBjde++9dP78eZM8OTk5NHDgQAoKCqJmzZrR4sWLDZEFtNCzZ08CQIsXL7Y4tnnzZmrXrh0FBQVRQkICbdy4kXr16mWyynv8+PGkdJ8pRaV49dVXqUmTJhQSEkLJycl04sQJAkBvvvmmIY+8Wt5WWXl5efTAAw9Qw4YNKTAwkFq1akULFiwwHK+srKR58+ZR27ZtKSAggCIjI6lPnz4mK9aV+Pvvv+mxxx6jqKgoCggIoM6dO9MXX3xhkkdrVAoiKZLIwIEDqW7duhQSEkJt2rShJ554gi5fvky7du0inU5HmZmZJuc8/fTTFBYWZohQIq+sX7RoETVt2pSCgoLojjvuoNzcXJPzSkpK6IUXXqAbb7yR9Ho9RUdH08CBAy2iPSxevJjatGlDAQEBFB0dTSNHjjREP/nrr78M4cRgFAGBiGjTpk3Uq1cvCgkJobp161KHDh1o1qxZJuN29erVdOONN1JgYCD17NmT9u7dqylc23//+1+68cYbTdKU+n3z5s0UEBBAqampRKQ8/uQIB8ah+bT0KxHRK6+8QgBM+uSjjz4iACbRWIiUx8Hly5fp8ccfpyZNmhju7eHDh9OuXbsMeS5evEijR4+mkJAQioqKojlz5tBTTz1lEpWCiGjHjh2UkJBAAQEB1KFDB/r6668pMDCQ5s2bZ5JPS7+YU1paSk888QRFRUVR/fr16fHHH6clS5YoRqUwj7hgHumBiCgrK4t69+5t+K5KSkoyiRpz9uxZmjBhguH6x8bGUkpKiiEUnlKfyezfv5+6detGISEhBMDwO7N8+XJq0aIFBQUFUbdu3WjPnj0W3x9KUSmU7l3z7yG1OmVSUlKoadOmJqEmZS5cuEB+fn4WEVSU8ISoFFpxRXjTmii7poGVqBSCPGA1ZmJiIpmveq1J1Kyz7iJufpyiFTs2LBbZ07OrXX5WVpZiAHRncuzYMbRp08aldVSXwkLg+HEgPh4wCipRKygsLLS5CQPjXJKSkhAZGWniCuBqarqf//zzTzRr1gy7du1SXWTn68iL/3bs2IF+/fo5pUy+n+2nvLwcsbGxmDRpEl588UWL40uWLMFrr72GEydO2PSZrqnfs+r+NsvBBMx9fp3h3uDKst2BEOIAESUqHfN5H2PA88Ka1dYQKJ6G7JarYZEzwzCQohE88MADWLBggbub4jHMnDkTH330EbKysrBkyRKMGTMGN998s2LIOsb1lJaWYt++fXjmmWcMO2+aQ0RYsGABZs2apXkhoTuwN5Ssq8KburpsT8NpwlgIsUUIQUavCc4q29eorSFQPA29XvIttiO6F8P4PM8//zzatGmjGmfa17h27RqeeeYZDBgwAM8++yx69+6NL774wu6oHIxz+OOPP9C1a1d88MEHWLJkiWE9iDHnz59HSkoKxo4d64YWasORULLWjGrV3a/Blwx2Tll8J4QYD2CAzYyMJmprCBRPQwhpAR4LY8YZZGVlubsJNUKjRo0wa1btsxI5yvz58zF//nx3N4OpIi4uzuaGHTfccIPHj2FHQsmqBRMIDw430RSyyAageYa8OoEKzN1VB7ccjE0nN3mM+6o51X6kFUJEAXij6t+/q1seU3tDoHgi1mIZMwzDMIw7cMRCqxZeDUC13SAcDZ2qZPletH9RjW2q5gjOmOt5E0A4gEMA1jmhPAae5/fsCJ6wsNMWcixjL2gqwzAMU8O463fMEZdKNaPaxWLlDVWsiWxz1wsADhnslCzf5niar3K1XCmEEMMAjAJQCWAKgMec0SjG+9Hr9SguLlaNz+kpBAVJorisDFDZT4JhGIbxUeRNj2oaR10qleIKz9o+yy43CPMIFLJVd+nQpXZHxtLqg+xJvsoOW4yFEPUALKz69y0icl+8NSdTXSd1b6vXFURFReHs2bMoKiryaMsxR6ZgGIZhzCEiFBUV4ezZs5o3Y3ImznSptNcNwpkRKLQGDfCk4ALVsRjPBRAD4AyA55zTHPej9qQEaHdSd2W9nhZzWY16VYGB//jjD5SVlbm5NeqUlwN5eUBlJVCbwoSWlJQgKCjI3c1gXAz3s2/A/ewe9Ho9oqOjDb9nNUl1fuuVzl06dKlFGiDtm2BehzMjUChZvs3xtOACDgljIUQfSK4TAPAYERU6r0nuxZGVoDVVr7tEu6PUq1fPLV8o9lBZCXTpAjz+ODB3rrtb4zyysrLQsWNHdzeDcTHcz74B97NvUZ3feq1uENbqqE4ECnOUtpX29KgUdgtjIUQQgHcACADriGiD01vlRtwVq09LvdM2T3OLaK/N6HRAixbAyZPubgnDMAzDVM9Ap/Vca/nSktMwacMklFaUGo4F+AU4bNVV8nv2ZBzxMZ4NIB5AIYB/Orc57sddm2vYqjfzcCbyi/MV83iS07o3Eh/PwphhGIbxDKpjoFOy9Cql26rDfG2QJ68VcjbCng8rhLgFwD5IlubHiehNs+PpAMZX/TuRiNKtlDUFVe4Y0dHRnT/66CN72u0yLhZfRE5BDiqp0pCmEzrEhsUiPDjcbfUevnDY5OnNmAC/ACREJRjKOVt4FqUVpQjwC0BM3RiLdl+9ehWhoaEu+yzexuLFLbB2bRNs3vw1/Pzc3RrnwH3sG3A/+wbcz76B3M9qv/fGv/VqHDh3QPVY5xs6G95bqwOAw/V7C/369TtARIlKxzS7Uggh/AC8V3XOPgBvV6dRRLQUwFIASExMpKSkpOoU51SUHNfvTrhbU77qTBdYq/e2ObeBoPwQs/LulUhKSLLwGQIkp3bzlaxZWVnwpOvtbk6eBFatAm68MQlxce5ujXPgPvYNuJ99A+5n30Du57OHz6r+liclJFkto9+cfqrH6N7rGkKpjgC/ANQNqKs6Oy0gUDmqUvFYbcIeH+OnAHQCUA7gQSLy6qtjTdRq8YdxxUI4a/WqOcNHBEeYOLezD7L9xMdLf0+eRK0RxgzDMIx3orRgTavhLTYsVlErxIbFWq0jPDgcV65dURXFgGeFVHMlmnyMhRA3AUit+nceEf3oshbVAEpbFNq7JaGWOH/OjEusFodwwaAFhv/dtXDQ25GF8YkT7m0HwzAMwwD2734r642cghwICJNjauHQjOsIDQhFWaX10KqDWw62/4N4IVotxikAggEQgHIhhFrc4puN3g8VQjSpev8lEe11sI1OxxmWVVsi1NkWZVtPkJmHM6ETOlRQhcW5vvKU5yiNGgGhoSyMGYZhGO/DXG8QCAICBEJsWKwma7MWA9qmk5uc0l5PR6swFkZ//6XxnLurXgBwFYDHCGMtotbWFIatOH+ucGtQc7WQbwolUexpgbM9ESEkqzELY4ZhGKammbpxKpYeWIpXW76K2/99O6Z0noKFQxbaPrEKJb0hi2KtWziraRpjfGX22eEtob0Za6HRtLpZ2NpisSbdGpRuCgDwE34ObyHpa7AwZhiGYWqaqRunYtH+RQbDVgVVYNH+RZi6carmMpyhN5Q0jTmujMzlSWgSxkSUSkTC1gtAhtFpE42OzXdJ6x3Emqi15Tss+/GMXTsWwf7BiAiOUNzHXGs85Or4IRv7FClRSZUsijUSHw9kZwPXrrm7JQzDMIyvsPTAUrvSlXDG/gspCSlYOnSpxSI9WzhzLZWn4JMWY+MBYC5qrT15mVuT84vzUVxejBV3r7BwjrdlUQaqtwjQ+Fw12LdYO/Hx0vbQv//u7pYwDMMwvoKSC6S1dCW06A0tyIvxzBfvyVwsvmjyvzMCGXgiPimMAfUVn9aevLREojAuX018y9hTnjlq7hMy7FtsHxyZgmEYhqlp/ITyrlJq6Upo0Rv2oNUC7aiG8XQrs88KYzXUwpEMbjnYbj8eW+FWquMXZC1PdW8KX6RlS+kvC2OGYRimppjSeYpd6WrYG97NGlot0I5oGG+wMrMwNkMtHMmmk5uc4sej5Twt5anlkVehsii2j/r1gagoFsYMwzBMzbFwyEI8kviIwULsJ/zwSOIjdkWlcBQ1y61WC7QjGqY6M+U1hVOFMRFNMFpwl+7MsmsKa09AzvLjkalOec5uCyNZjU+edHcrGIZhGF9i4ZCFKH+hHJ1v6IzyF8prTBRbs9xqsUA7okO8YSMythibYe0JyNl+POblRQRHINg/GGPXjrXqdyPHWS4qKzI8ZbL7RPXhkG0MwzCML+AMy60jmsjZM++uQOsGHz5DWnKayQ4ygOkTkNomG44il6d1pzzzfBVUYWgfi+LqER8PLFsGFBYCdeu6uzUMwzAM4xqcZbm1VxMNbjkYi/cvBoEMaZ42280WYzOcbRXWitanN2/wz/FW5MgU7E7BMAzDeCtaoj64w3KbeTgTGT9mmIhiAYHxHcZ7lGGPhbECtnxrXBFqROvTmzf453grHLKNYRiG8WactXuvK1Dbulot6IG7YGFsJ64KNaL16c0b/HO8lRtvBIRgYcwwDMN4J1pnld0xO+4thj0WxnaiNuimbZ5WrXK1Pr1xNArXERwMNGvGwphhGIbxTuwRnykJKUhLTkOzsGbILcjFrO2zLIx8zpwh9xbDHgtjO1EbdPnF+VajSBgPrKkbp1oMNK1Pb+7ygfYVODIFwzAMU9NkHs7E4QuHqy1A1URmeHC4Yp3WZsCdPUPuLYY9FsZ2YitwtTlKA2vR/kWKA03rzjXO3OGGMUUWxkS28zIMwzBMdZF1QmlFabUFaFpyGvQ6vUV6fnE+xBxhIrptuV04e7G/txj2WBjbib2Bq5UGljkcVcJziI8HCgqAv/5yd0sYhmEYX8CZAjQlIQX1AuupHjcW3bbcLlzhE+wNhj0WxnaSkpCCiOAIxWNK1mStAyinIMepUS4Yx+CQbQzDMExN4kwBmnk4E/nF+VbzyKLbls+vt/gEOxsWxg6wYNACzX4y9gwgZ0a5YByjZUvpL/sZMwzDMDWBPX7B1pBdMrSQU5CDq6VXEeAXYJJurGW8xSfY2bAwdgB7/GSUBpYt2LXCfcTGAno9C2OGYRimZlDzCy4sLVQ0kqlFitDiumlMfnE+iAgRwRGKWsZbfIKdDW8J7SBat0GU88zaPgu5BbloFtYMg1sOxqaTm5BbkGuyA4wxnhbXz1fw95fiGbMwZhiGYWqClIQUxZCvpRWlmLV9lonWkK3CsgCWZ5kBx3RDWWUZQgNCkTcjT7VttV0Im8PCuAawNrDi5schpyDHIr22+/B4MhyyjWEYhqlJLhZfVEw3F7vWFuo1C2umqCdswYY4U9iVws34qg+PJxMfLy2+q6x0d0sYhmEYX0DNGKYTOhN3CmsL9Rxx3ZTr4MX/12Fh7GZc4cPjzJ1qfJH4eODaNeD0aXe3hGEYhvEF0pLToBOWkqyCKkwW5FuLFGGsJwDAT/gBACKCIwzRtASEYh28+P867ErhATjTh8ea/5Gv+Qk5ihyy7cQJaTEewzAMw7iSlIQUrD2zFn7CDxVUYXJMdpWQt3A2/o0HTGeZbemJzMOZhjVPOqGzWpevwhbjWoazd6rxRYyFMcMwDMPUBOHB4agkZR8+2YXCnllm49njyLmRiJwbibFrxwIAVty9wmZdvgpbjGsZrtipxtdo1AgIDWVhzDAMw9QsagvojF0otMwym88eG2/6Ic8khweHK24GYu6uYWxlbhbWzGCdNk+rLVZmthh7EM7wDfbVnWqciRAcmYJhGIapeZy1IN9WTGP5mK26ZIGdU5Bj8EOeuH4iJm2YZJJWm3yTWRh7CEqDz5GBxlEunEOrVsDx4+5uBcMwDONLOGtBvpZZ4ovFFxXrAmAw0o1fN95CYJdVlqG0otQkrTa5bLIw9hCc5RvsqzvVOJvWrYHsbKC42N0tYRiGYXyJlIQUZE/PRuXsSmRPz3bo91vLLLEcycK4LgAmRjrzxXnW0CLGvSFqFgtjD8GZvsHOuKl8ndatASJ2p2AYhmE8Cy3i0lZMY7WZZHu3lTbGlhh31sy4q2Fh7CGwb7Bn0aaN9PeXX9zbDoZhGMa3MY8uocW/13z2WI5lbGsmWYsxTqciHQe3HGz1PG+JmsVRKTwEW7EJmZqlZUtpER4LY4ZhGMZdWIsuIaMWe9iRPRLUomL4CT9UUiWahTVDXlEe/i772yLP6qOrsXDIQtWyvSVqFluMPQT2DfYsgoKA5s1ZGDMMwzDuQ6trg7PEpdoC/ozhGQb3TCVRDCiLdmO8ZWachbETqa5TuTN9g73Bwd3Tad2ahTHDMAzjPrQKXmeJS1ca6bwlaha7UjgJd2zFrBR0OyUhhbeFdhKtWwM7dwKVlYCOHyEZhmGYGkbNtcEYZ4tLWy4YEcERitbhiOAI1XNkvVJUVmTY9jo2LNYjNwbhn3snUdNO5dZWd3qLg7un07q1FK4t17PcnxiGYRgfIPNwJq6WXrVI1+v0mhbSuYoFgxYgwC/AJC3ALwALBi1QzG+sVwCggioMYt7TRDHAwlgRrW4IxvnUnuhyCnIwdeNUp7o1ZB7OVAy6LYtfb3Fw93Rat5b+sjsFwzAMU5PIYtLcMhsRHIFldy1D3ow8t4VkTUlIwfv/eN/E3eL9f7yv2g5vM9axK4UZWt0QzPNZY9H+RYb31XVrkOtVC7otu1XY2mudsY1xyLY77nBvWxiGYRjfQW3RXWhAqEdYWe2JeOFtxjq2GJuh9clm2uZpDgfBrs6Tkq0VqrKvsTc4uHs6kZFARARbjBmGYZiaxRPFpKOL+r0lGoUMC2MztAzGzMOZNsOSOFpPdc4z9tnh0G/OgSNTMAzDMDWNp4nJ6uxa523GOhbGZmgZjNasvX7Cr1r1OHqen/AzEb9K+5/LT3qHLxzm8G0aad0aOHbM3a1gGIZhfAlPE5PV8RP2NmMdC2OYTg9cLb1qsdrSfDBas9pO6TzF6v7kSuXZg7Xg22qDzPxJr7Si1CP3J/dEWrcGLlwALl50d0sYhmEYX8HdYtLcbUItwIDW2W9n7tPganxeGJuLxvzifBCR1VAoalbbiOAILByy0GIwP5L4iNMGtyM3i7etCPUk5MgUx4+7tx0MwzCMb2GPmHTmpl5KbhMCQjGvp/oJVwefj0qhJBrLKssQGhCKvBl5iuekJadZRKQI0YcYYvg5sj+5Pdhbvic68XsLxpEpevRwb1sYhmEYxhxnb+qlpIsIBAEBAhnSPNlPuDr4vMXYEdHo7ikOe/E0J35vIi4OCAjgBXgMwzCMZ+LsWWE1/UMgr9E91cHnLcaOxvx1tVXYmahZuGvjk56z8fMD4uNZGDMMwzCeibNnhdV0UWxYrGExf23G5y3G1Vn56UyfHldibuEO8AuotU96roAjUzAMwzCeipohj0AOaRNPi4hR0/i8MHbULaI6Mf3cgbETf0JUAotiO2jdGvj9d+DaNXe3hGEYhmFMURKyMo5oE29zF3U2Pu9KAdh2i8g8nIlZ22cZtltOS06z6tPjK4PHV2jdGqioAH77DWjb1t2tYRiGYZjryJpj1vZZii4QjmgTb3IXdTY+bzG2hZpluLox/RjvwTgyBcMwDMPUBPa4a8qzwmph1VibaMdnhbHWAadmGVbb4c6eSA/e4qPs68THS39ZGDMMwzA1gaPumt4QhcrTtY9PCmN7BpzaU1YFVVTLOd1aGzx90PgaoaFA06a8AI9hGIapGRwNwTa45WALq7EnLZzzhvVZPimM7Rlwak9ZsjO6o87pam2YtnmaUwYNi2vn0ro1W4wZhmGYmsGREGyZhzOR8WOGySYcAKAT6lKvprWCN+zE65PC2J4BZy1sSUpCCtKS09AsrBlyC3Ixa/sszYNKrQ35xfnVHjTe8ETmbcjCmMh2XoZhGIapDrZcIpQErZLoBICrpVcxdu1YiDnCRPy6Qyt4w068PimM1QacTugsBoS1sCXVGVT2+vvYM2i84YnM22jTBrh6FTh71t0tYRiGYWo71oxy9gYFAGCwIhvrlJrUCrKQN7dmy3iSD7RPCmO1mH8VVKEobI1jAGdPzzYJjeLooFIb9KEBoYr5w4PDbZYp4w1PZN6GHKbt55/d2w6GYRimdiGLxgPnDhgsutaMcvYGBTBH1ik1pRWMhbwSnuQDDfioMJYHnNIgsudpydagsua7ozboA/0CVevT6gvkDatSvQ1ZGB896t52MAzDMLUHc9FobNFVM8rZExRADXlfBiWcrRXUXDwAeOTmIT4pjAFJmFZSpeKxnIIcTU7o1gaVFjcLpUF/sfiiYpn5xfkYu3asJrcNX9/O0RU0bCi92GLMMAzDOAtHZp5tBQWICI6wWa+8WVlNaAU1IS8gTAS/p+Czwhiw/lSUU5CDSRsmIXJupKqF1tqgUhvs49eNtyq4rbXJ3DdH7ebx9e0cXUXbtiyMGYZhGOfhiDuDLUEru2TKs+Jq4duMtYKcX9YVzlyA522z2D4tjK3tLw4ApRWlyC/Ot2rxVROg1qY6rC3QU2qT2k42gPrNU52IGYwysjDmyBQMwzCMM3BENKppDwAmbhmya8XDiQ+rGspkrRCiD0EFVQCApkAC9oR587ZZbH93N8Cd2Npf3Byl/cbV9hNvFtZMtUxr+5Ybt0n2AbK10jRufpzh6U9GduWQrdbyQAeAGMTY/KyMJW3bApcvA+fOAY0bu7s1DMMwjLeTlpxm8lsNaBONStojbn6c4kz1ppObkD09W7Usa+4cSjrFmr7QqmvMNYsn4dMWY+C6n688lWALras1bVmjrZVj7ntsq21KT3ccss35cGQKhmEYxpmYuzNUx/XR0SgT9p7niL5QW0joifi8MJbRatK3FlzbGGuRL4Drll4t7g22RDZgOSjVrMwcss1x2rWT/rIwZhiGYZyFLBo739C5WqLRUV9ee8+r7SFhWRhXkZKQYnMlp63g2kriOGN4hqqoNT7PntBuahiHiVPL56nO7t5AVBQQHs7CmGEYhvE8HPXltfc8b1tMZy8sjI1YMGiB6sI3LcG1lSJOmE+TmFNUVoRpm6cpCu2pG6caxPKs7bOQlpyGytmVqmXJg3LW9lmKu8sICI91dvcGhJDcKTiWMcMwDONpOBqRyt7zvG0xnb349OI7c7Q6iNuKOGFclvw+JSEFujk6RcGaX5xvkVZUVoTF+xdbbOMIAINbDsai/YsszhnccrDV9hEIKQkpyMrKUjzO2KZtW+Djj6XIFELdeM8wDMMwNY5aQABnnudti+nshYWxGVoGh6MRJ2xFmDBHa9ximU0nN1mtR+sCQ0adtm2BS5eACxeA6Gh3t4ZhGIZhah5HBbg3oNmVQkj0FEJMF0JkCiEOCiFOCyGKhRBFQogzQojNQojHhBD1Xdhmt6M14oS53/DgloMVpx+07FJjXLYtx/faPs3hTngBHsMwDONN2BNz2JVleAv2+BgHAtgFYB6A+wB0BNAEQBCAYAAxAO4A8CaAE0KIfzi3qZ6DrYgTaltCZ/yYgfEdxlv48VjzbVYq25bjO+985zrkkG3sZ8wwDMN4OlqDBbi6DG/CEVeKswC+B/ATgBwAhQBCALQGMBJASwANAawRQgwioq1OaqtHIYtMtcDcagv0rAXaNvbXGdxyMDJ+zFAN+m0rIHhtnuZwJzfcAISFscWYYRiG8Xzs3bzDVWV4E/YI41IA7YhIVRIIIV6AZDF+BIAfgP8BaFOtFrqIzMOZ1XYct+aAPnbtWMVzrG3hbF5/z2Y9rbaxtjq+ezJyZAoWxgzDMIyn44yYw2p5cwpykHk4s9ZpD83CmIgqAViVA0RUIYSYBmAUgAgArYUQLYjo9+o107nYu52hNezdEtqeOH/WrL5sEXYf7doBGza4uxUMwzBMbeJi8UXEzY9zqsHLGVrEWuAAR7WTJ+P0OMZEVAbgpFFSI2fXUV1qYrtkXgBXe2nbFvjrL+nFMAzDMNUl83AmcgpynO7H6wwtYi3ggLO1kyfgdGEshNABiDNKOu/sOqpLTWxnyAvgai/yAjx2p2AYhmGcwazts1BJlSZpzhCdztAichlq1JatoGWcGsdYCCEAvITrVuIfPM2NAnDO1IIW2N2hdmIsjPv2dW9bGIZhGO8ntyAXUIiN7wzR6QwtIu/6WxPayd04bDEWQtwhhLir6nVf1cK7QwD+VZUlH8BkZzTS2VibWjCO1Rc5NxKRcyN9Im4fo50mTYC6dTlkG8MwDOMcbIVh9QR8xUW0Oq4U6QDWVb0yAcwB0AFS9IpPAHQhooPVbaArUJtaAGASqy+/OB/5xfkeHbfPl4JuewpCSAvwjhxxd0sYhmGY2kBachp0wlSSeZrotKadapMOEURkO5fSiUKch6LhHz8BWAhgJRH9beX8KQCmAEB0dHTnjz76yKF2OJPDFw6jtKLUap4AvwAkRCW4rA0Xiy/ibOFZlFaUIsAvADF1YxAeHK6aN6cgx8QvSSd0iA2LVT0HAK5evYrQ0FCnt92XeO21eHzzTUOsX/8thPJeLG6F+9g34H72DbiffYPLVy7jdMlpTb//9mKPtrC3XHt0iKvaYS/9+vU7QESJSsccFsaGAiS/4roA2gO4H5LY9QNwFMA/iOg3W2UkJibS/v37q9UOZyDm2FY4AgKVsytt5nME8zBygPTEqOYoHzc/TtHfJzYsVnUTEQDIyspCUlKSM5rss/zvf8C0acAff0ibfnga3Me+Afezb8D97Bu4qp/t1Rb2YI8OcWU77EUIoSqMqx2VgiSuENF3RDQVwBAAFQDaAdgqhKhT3TpqCrUtno1xpb+PvWHkaiK6BqNMQtWkweHD7m0HwzAMw1jDlSFq7dEhNREq1xm4Io7xFkj+xwDQHMA4Z9fhKiqowupxV/v72Ct0vcFZv7bSvr30l/2MGYZhGE+mukY0a2uZ7NEh3mLMc7owruILo/dJLqrD6cSGxVo9Nr7DeMzaPstlDub2Cl1fWSHqiTRsCERHs8WYYRiG8WyqY0ST3R/UNh6xR4d4izHPVcK40Oh9fRfV4XQGtxysmP5I4iNIS05Dxo8ZmnelcSRahL1ClzcRcS8JCWwxZhiGYdyPNc1RHSOaLfcHe3SItxjznLrBhxE3Gb3Pc1EdTmfTyU2q6ZtOblIdHOYDwNzBXBbRgPX9xOVjs7bP0rxXunngbvnmMD7fvMw3Wr2hWh6jnfbtgSVLgIoKwM+2ezrDMAzDOB1bmsMRbSGjxf1BywYimYczDSLbT/ihgioQGxaruR01idOFcdWW0MYbe3zn7DpchdoAUFpxae0ca09YtgZAdXaoUbo5Jq6fCCGEIQydvBd75uFMjxuM3kZCAlBcDPz+O9CypbtbwzAMw/giWjSHo9rCGTsFm2uTCqowWIo9UYdodqUQQkwXQnS3kacugBUAOlYlXQTg/gDFGrHW0QLKodyahTWzmMJQE9KudjBXujnKKsssYjNXUqXHrQL1RuTIFOxOwTAMw7gKW66ZrlzU5gz3B2+JRiFjj49xEoDdQogTQojFQojHhBBjhBAjhRBThRDvAsgGcF9V/nIADxBRvnOb7DqUBoAMgSzEcYg+BINbDrZwTLcmol2JPTeBp60C9UbatpV2weMFeAzDMIwrsLX4DXDtojZnrGXylmgUMo4svmsJ4CEAbwL4EMBqAG9Dcp+Qty/5HcAgIlrnjEa6AqUnMHkAqEEgi8Gh5HusJqJtPWFVd3tne24CT1sF6o3UqQO0aMEWY4ZhGMY1aLG2unpRW0pCCrKnZ6NydiWyp2fb7f7gLdEoZOzxMZ4IoD+APgBuAdACQAQkcV0I4DSAQwA+BfA5EVnfW9mNWHNUB2BwDDdHaSeXsWvHKtYhi2itju6OLtgzJi05zWJXGb1Ob+JjDEjbNXraKlBvJSGBLcYMwzCMa9C6+A1wbHFdTaCkTTwxGoWMZmFMRJcgWYdXu645NYPaE9i0zdNQXF6sKIqtxeVzZFtmrW3SsmBPRu3mME+LDYvF3Ql3a24bo0779sBnnwElJUBQkLtbwzAMw9QmtC5+s7a4To4I4S7R7OnC3RxXhWvzaNSewPKLld2h/YSf1bh8zngScpYPjtrNYZyWlZVlV5mMOgkJUri2X34BbrnF3a1hGIZhahPV1RjOmI12BtWJuFXTuGqDD4/GXr+WSqpU7VBnbbLhbT44jIS8NTS7UzAMwzDOxhGNYbxeafy68aoz5FrWNFV37ZM34pMWY7UnsGD/YEWrsS1x6ownIW/zwWEkWrYEAgJ4AR7DMAzjGuzRGEoxg5XIL8436B01K7KnWJtrGp+0GKs9gS0YtMBt2xXy9s7eiV4PtGnDFmOGYRjG/SitV9KCUlxhb4s/7Cx80mIMWH8Cc5eDuDf54DDXad8e+Oord7eCYRiG8XWqExvY/Fxviz/sLHxWGKvB4pSxl4QEIDMTuHwZqF/f3a1hGIZhfBW1KBZ+wg+VVIlmYc1wtfSqJrdRZ2wH7Y34pCuFK/BFB3VGgreGZhiGYVyNFp2httlHxvAMwwYdWt1GXb1xiKfCwtgJaNmy0Z6yWGB7FxyZgmEYhnElWnWGlvVKWtc0VWftkzdrGXalcALO2JwD8N0VoN5O06ZAvXpsMWYYhmFcgz06Q4tLqFa3UUfcS71dy7DF2Ak4y0F92uZpPrkC1NsRQrIas8WYYRiGcQXetBDO26NZsDB2As7YnCPzcKbqznueOPAZUxISJGFM5O6WMAzDMLUNb9oEzJtEvBIsjJ2AFgd1W/421p6kHB343uzj42106CBFpTh92t0tYRiGYWob3rQQzptEvBIsjJ2ALQd1LU7z1p6kHBn4zlwQyNjm5pulvz/95N52MAzDMLUPWWdEBEcY0oL9g93YInW8ScQrwcLYAZQssSkJKcienm0Ih2LsYK7F30btSSoiOMIhZ3Vv9/HxNuSQbT/+6N52MAzDMLWX4vJiw/v84nyHDF6unk329p18WRiroDZwHLHEavG3UXvCWjBogUPtV6tTKVg3U33q1QOaN2eLMcMwDOManGHwqqnZZGvGQk+HhbEC1gaOIwNTi7+Ns5+w1OoUELhYfNGhMhnrdOjAFmOGYRjGOZgb6NQMW/YsauPZZNuwMDZCHoT3r71fdeBYs8SqTU1o9bdx5hNWWnIaBIRFOoFwtvCsw+Uy6nToAJw8CRQV2c7LMAzDMGooGeiUftMB+xa1eXvEiJqAhXEVxoNQjdyCXKuWWCULs7GV2U/4AQBiw2IxvsN4zNo+y6U+PgTl2GGlFaVOrYuRuPlmoLISOHrU3S1hGIZhvBklyy6BLMSxXqfH1dKrmrWEt0eMqAlYGFehNAjNaRbWTNH6KyAsRGhRWRGmbZ5mIrYrqAIh+hAMbjkYGT9muNzHJzYsVjE9wC/AqfUwEh06SH/ZnYJhGIapDmoWXAIZXC4jgiMghEB+cb5mLVGTESO8NWQsC+MqbE0jyANHyRdYzTKbX5yv6JKx9MBSh3187BloajdATN0Ym/Uw9tO8ORAaygvwGIZhmOqhZsGNDYs1uFyGBoRazADb0hI1FTHCm0PGsjCuwto0gvnAMfcFVrPMqlFBFYrptsS5vQNN7QYIDw63q72MNnQ6KWwbW4wZhmGY6qDFsuuov3BNRIzw5kV+LIyrUBuEK+9eaXPgKJ1rDdnX2BxjcZ55OBORcyMh5giIOQKRcyMxbfM0uweaN4dM8UZuvlkSxrw1NMMwDOMoWiy7aga98OBwl7gwWJuxdkUEDXfBwriK6kwvmJ9rjRB9CKZ0nmL1STDzcCYmrp+I/OJ8w/H84nyT/41RG2je6t/jzXToABQU8NbQDMMwTPWwZdhSMsoF+AXgyrUrJjPLY9eOxdSNUxXr0KoTrM1YuyqChrvwd3cDPImUhBSnWFT9hJ+iu4Sf8DOI7Z7NehrCv8mL+uS6Z22fhbLKMs31KQ00eaDKFmZ5EANADNjH2FUYL8Br5vn3P8MwDOOlGGsGWUtcLb1qYUQjEBbvX4yezXqaaBwlnTB27Vh8m/stFg5ZaFKGLdcItQgaxmuwvGVbaLYYOwHzpyUlURyiD0HG8AxVP2XjwWrPVIPaQPNm/x5vhreGZhiGYWoKcy2htoEXgSx+/9VCwi3ev9jCcmzNn1lLBA1v2haahbETUAv15if8HBoQWqcaBATGdxivWK61jUh45zvXUbcu0KIFR6ZgGIZhah5r+kHWBbL7hJofsLGIlvOqRd9qFtZMUwQNb1rjxMLYCaiJ0EqqdGhApCWnQa/T28xHIGw6uUnxmLWbI6cgh/2NXYi8AI9hGIZhnIktn2C1XW8BSRdo2cwMkHSNrbzyjHVNxkauCVgYOwFn7ySTkpCCZXctQ0RwhM28aqLcWqSMSqpklwoXwltDMwzDMM5GS8jWlIQUPJz4sIU4loWqls3MAEm/WMtrPBNeU7GRawoWxk7AFU9LKQkpyJuRB5pNoNmkKpLVYhLLA1UNbwiZ4q106CCFaztyxN0tYRiGYWoL1tYOGVuSN53chIcTH1YUqlp++2X9opZXQFjMhGsNDesN0bJYGDsBWYQai9dg/2A3tkgiJSFFdfMRbwiZ4q3cfLP0l90pGIZhGGdhbe2QuSU548cMpCWnWQhVtd9+pTVRzp4N95bd8FgYO5Hi8mLD+/zifIsOr86TktqCOVsL6ZSs2Tqh81rfH2+geXNpEd4PP7i7JQzDMExtwZqo1RqFSm2GO2N4hoWIdvZsuLdEy2Jh7CRsdXh1n5QcfXJT8v2JDYv1Wt8fb0CnAzp2BA4edHdLGIZhmNqCmlBVChELKFuY7fEHdrbvsKNbWNc0vMGHk7DV4daEs5ZBlpacZhKIG9D+5Ga+cUlWVpbNc5jq0bEjsHQpUFEB+CnvAM4wDMMwmlHa0ENeUKcUOULNcGbPZmbO2vhMbo897XQXLIydhK0Or+6TktoNwZZfz6RTJ6C4GDh+HGjb1t2tYRiGYWoDakLVUcNZTVIdA19Nwq4UTsKWL44znNi1rvpk3E+nTtJfdqdgGIZhXIm3hEvzlnayxdhJ2LLoesuTEuMcWrcGgoKAQ4eA++93d2sYhmGY2owzXR5ciTe0k4WxE7HW4ewK4Vv4+0th29hizDAMwzDeAwvjGsQbnpQY59GpE/Dhh9JmH0J5h06GYRiGYTwI9jFmGBfRqRNQUACcOuXuljAMwzAMowUWxgzjIjp2lP6yOwXDMAzDeAcsjBnGRbRvL/kaHzrk7pYwDMMwDKMFFsYM4yKCgoB27dhizDAMwzDeAgtjhnEh8tbQRO5uCcMwDMMwtmBhzDAupFMn4MIF4Nw5d7eEYRiGYRhbsDBmGBfCO+AxDMMwjPfAwphhXEiHDlIMYxbGDMMwDOP5sDBmGBcSGgrEx3NkCoZhGIbxBlgYM4yL6dSJLcYMwzAM4w2wMNZA5uFMxM2Pg26ODnHz45B5ONPdTWK8iE6dgNxc4K+/3N0ShmEYpjbB+sT5sDC2QebhTEz5bApyCnJAIOQU5GDKZ1M0DT5HBywP9NpFYqL0d/9+97aDYRiGqT1o0SesJ+yHhbENZm2fhaKyIpO0orIizNo+y+p5UzdOxdi1Y+0W1NUR4oxn0rmztABv3z53t4RhGIapLdjSJ6wnHIOFMaw/UeUW5Cqeo5QulyPmCCzavwgE010dtAhqR4U447nUrQu0bs3CmGEYhnEetvSJu/SEt1upfV4Y23qiCg8OVzzPPN24HGtYE9S6OTrV89VuAMY76NJFEsa8Ax7DMAzjDJqFNbOabo9hTwlHBG5tsFL7tDDOPJyJ8evGW32iulZxTVNZSk9mSpgPZPNBpPU8LXj7U1ttomtX4M8/gTNn3N0ShmEYxluw9juelpyGEH2ISX4BgZyCHMTNj1M17OmEzilunUptqw2z3v7uboC7kDu9gioUj+cW5CLzcCaull5VPJ5fnG+R3xYCAmnJaSZpWgR1iD7E4jxbyJ9PLlse1AAQgxi7ymKqT5cu0t99+4CmTd3bFoZhGMbzsfY7npKQgpSEFACSjsgpyIGAMBjYcgpyoNfpEeAXgNKKUpNyK6jCpBwlrAnclIQU1bap6RlvmvX2WYuxLUGqEzpM2zxN9biAMHlysmXRFRB4OPFhi0Foa7BEBEdg6dClqoNXjdrw1Fab6NAB0OvZz5hhGIbRhpbf8ZSEFGRPz0ZsWKzFrHNZZRnqBtSFn/CzKNuWHnDUf1kNR2a93YXPCmNbgrSCKiyswsYQyGRQqU1pAEBsWCxW3L0CC4cstCjH1mC5cu0Kpm2eZrc7RHV9ixjnEhgI3HwzsHevu1vCMAzDeAP2/I6r5b1YfBGVVGmzHHO3CDU3DFv+y0oE+AXgaulVr3Hr9Flh7IynF3lgGPvVyE9mshim2YTs6dkmFl/jAXi19Cr0Or1qHWWVZcgvzrfbid2WUz5T83TpIsUyrlT+jmIYhmEYA/b8jlvLa6scJX/iwtJCC21i7NapVUvohA6lFaUO6Rh34bPCWMnCay/NwppZRKOooArodXpcLb2KsWvHWjwdmQ/A/OJ8CCEQERyhqU5b0x+y6Jb9jYxxxFeZcR5dugBXrgAnT7q7JQzDMIyno6RT1H7HreVNS06zELl6nd5QjpJbRGlFKcoqy0yMfcZunVo1lJK12tPdOn1WGKckpGDp0KWIDYuFgFD0wQEkH18l0SoPOKUBZW7lHbt2LKZunApAfQCGBoQiNixWU9vVpjDMRTqBTNw5HPFVZpyH8QI8hmEYhrGGsU4BAD/hZxCV5hZXc01j/psvhKmhzPh/a24RFVRh0DvG+sG8bfbiyW6dmoWxECJMCDFKCLFICPG9ECJfCFEmhLgkhPhRCLFQCNHFlY11NrLTeuXsSmQMz1B82lowaAHyZuRh5d0rFQecls4lEBbtX4TIuZFW4xRrfQJTm8JQEt0EQmxYrIU7B1PztGkDhISwMGYYhmG0kZKQYtAGchQtNXcEY01j/Js/a/ssi8gUpRWlBqutLbcINQuvXN/Ku1faPQPvyW6dmoSxEGIGgD8BrALwMICuAMIhhXurD+BmAI8A2CuEWCGEqJ6Pghuw9bSlNuDs6Vxri/nCg8Mt/JQjgiMQ4Bdgks+aOwQvuPNs/P2l7aFZGDMMwzBaqW6UKVvaQItRzpqOUNJP1txDPd2tU6vFOB5AYNX73wEsBTAVwCgADwFYDUAOCHw/gHVCCK9z01ATv9Zwhq8yAFwuuWzipyxbq9//x/uqYt0cNZEeHhxustr0YvHFareXcYwuXYBDh4CyMne3hGEYhvEGqmv0UtMGBELc/DgAsOkWYcsIaK6fFgxaoKiNHA1BW5NoFa8EYCOAJCK6kYgeIqJFRPQxES0lotEA+gGQd8MYAGC8C9rrcZg/KWldRGeO+UYjxoG0tYp1JZGu1+lRWFposto0pyDHo1eE1ma6dAFKSoCjR93dEoZhGMYbqG6UKWsGPONNQ9TcIhyx8CpZkVfevRILBi3ArO2zPDp0m1ZhPIOI7iSir9QyENE3AP5llDShOg3zJozFa96MPDyS+IhFRAhHsNcFQmkg1gusZ+FbVEmVHr0itDbDC/AYhmEYe7AnOoUSthbKGbtl2HIrtQdzwx4Am9tMewKahDERXdJY3sdG7xPsb07tYOGQhVhx9woTK7K1WMVqOOKcLg/EFXevAKDu18x+x+6hRQsgPBz4/nt3t4RhGIbxBpwhVmVtoGa0M9YEjriVasFbduT1d3J5hUbvg51ctldhvI85cH0TkNyCXOiEzsJ1whxHndMzD2di2uZpVhf6AZ69IrQ2IwTQrRuwZ4+7W8IwDMN4KsaaoVlYM6QlpxmsrtWhWVgzxehYNaEJvCVAgLMXyLU3eq8cl8xHMQ8NZ83VwtGpCzmOsS1RrBM6j14RWtvp0QP4+WegoMDdLWEYhmE8DaWd6JzlclBdt4zq4C078jpbGE8xer/RyWV7DOZ7its7WFMSUkAgxWMCwuGpC6VpCnNiw2IRGxbr0StCazs9egBE7E7BMAzDXOdi8UXEzY/D/Wvvd4nLgWyFNg4LW5Obf7lTlNuD04SxEOJWABOr/i0BMM9ZZbsbYyEcOTcSE9dPrPaTnJoTfHWenGxNR8gbfYQHhztcB1N9unaVXCp273Z3SxiGYRhPIPNwpiFqlBo5BTkOG+XMd8ZV29HOnvLsbYszF/a5EkGkbLm0qxAhGgHYDyCmKukZInrNxjlTUGVhjo6O7vzRRx9Vux2u4GLxReQU5Cju921MgF8AEqK0rTe8WHwRp6+cRnlluUm6TugQGxbrsHA9fOGwRQQKGQEBP50fyivL0TSoKfyD/Fkgu5FJkxIRGVmKuXN/ckn5V69eRWhoqEvKZjwH7mffgPu59nP4wmFE+UfhzLUzms8x/l0P8AtATN0Y1d91NX1gj3aRUdJFOqFDRHAECq4VoLSi1GZ73E2/fv0OEFGi0rFqC2MhRB0AOyDthgdILhRDyY6CExMTaf/+/dVqh6uImx9n9QlORkCgcrZ18Qxcf2oznyaJCI7AgkELqvXkpFZ2HX0dlFWWGW6K1+JfwwunXvDIJzVfYcoUYPVq4OJFQOeCrXCysrKQlJTk/IIZj4L72Tfgfq796Obo8N/4/+LpE08rHhcQqi6YMiH6ENXfdd0cner5sWGxyCnIgZ/wQwVVIDYs1qolWU0XmbcxRB+C8R3GY9PJTSaLCD1BdwghVIVxtX6ShRBBAD7FdVH8LYDR9ohiT+X/27vz8Ciq7G/g39tZIOwQBBUIoKKyiQqKjKIIyDq4gINLwOCoiLigjqMzP9zQiTpuIy8KiKhEyKiIuLK4wIDIjANBByNuoCwqqBBkCQlku+8fpzvpdKqqqzvdXdXd38/z9JNOUt19k6qkT9069xzfZQI7QTFgPwXCLA+4SXqTeh8sZgW1WzdqXedM0Y0lUpJJv36y+O7rr50eCREROc0qhujYvGPQoBiwfl83e34FVSu9AkDQFFGztM3AMZaUl2B2wWzX1y0OFHZgrJRKB7AYwEDvl9YBGKG1PhSJgTkpMBcnmFCSx82eM1LlSozqD8ZLiZRk0q+ffGTZNiIiyh2UC4+qHZI1SmuEBaMXYNut2yzbNfsze183WvhmNQsdTpBtxChYdvukXFiBsVIqDdLMY7j3S58BGKa1PhCpgTkpWHWH9JR0ZGZkhpw8nl+Yb1qmLZQDzW7Su287swPfbSVSksmJJwItW3IBHhFRoFtuAd5/3+lRxFZ2z+zqqlFGsYVVW2d/Zu/rRleUg81C+4LswJhjRJcRSE9JD/EnrPu8bhVygw+lVCqAlwFc6P1SIYALQuiO51q+UiZWM8XBcm+sTF0x1fBAVFC2Z5wD84j9+5wHNhQxyjf2N6LLiFCGTxHk8QBnncXAmIjI36ZNwIwZwPHHA0OGOD2a2GqV0cq0iYfv/d3X9KNVRiscLDtYK00y2NXrwMZjwdJFs5pnIb8wH1e/eTXKq8oBSMwx99O5SE9JN13s72M2I+32SbmQZoyVUikAFgAY4/3SlwAGa62tO0rEATvpE75yZ+HmAlvl5dh9TrstFe3UNF66eamt16ToYKMPIqLaFiwAUlKAK65weiTu458quefOPXjhohfqVfrMahbaF2RPWTalOij2Ka8qx6Fy86xZ33gm9ZkUF3WLA9meMVZKeQC8AOAy75e+ATBIa/1rNAYWa8ECyfruzPzCfNNW0HZzhwD7LRXtXKpw++WMROff6CPZZkaIiAJVVQH5+cDQoUCbNk6Pxv0CZ4DDeTyA6ivlRlUpxi0eF9Jz+iYQfc7OOrtOa2s3VKWwYmvGWCmlADwL4Crvl7YAGKi1/jlaA4s1qyCxvkWofbPRRkFxqAG33ZaKdi5VuP1yRqJjow8iohqrVwM//ACMH+/0SGIvvzAfhb8Wht1RN1y+WWh9n0bFvRXQ92nbV8btzAb7z3LnDsrF1BVTY/4zhspuKkUugGu998sBTAdwplLq4iC34JniLmEWJNY3fQIwn41OUSkRufRhdDAGS9SPh8sZia5ZM6B7dwbGREQAMH8+0LQpcOGFwbdNJL7Js7LKspiXNQu2mD8zI9PwcZkZmba62PmeX01TGL94fFyUbrObSvE7v/tpAGbYfFxnANtCGZBTcgfl1lmsFqng0Ww2ukpXhRxwBybgm12aMErUB6RjTXpKOpt7uES/ftLoo6oqOo0+iIjiQWkpsGgRMGYM0ChuptQiw2rtUDTfp+0s5h/bfSxmFcyq89ix3ccGTeUIfH6z0m1ui0X4VuwVzR7edtIfQuk7blSr2Oh5pq6YitxBudWJ+nvu3IOq+6rQs01P1x2IycrX6OOrr5weCRGRc954Azh4MDnTKMwmz7bv3247LrBiFl/YWcxvtkjfzuJ9O0UA3LjWydaMsdZ6QJTH4RhfibZoJoYHm422W4ItGLPnWbtjba2WjE+e9GSkfjSqp3POkY8ffyxpFUREyWjePKBTJyAZO19nNc8yrYjl+3qk4wLA3mL++jQIs7ONG9c6JfWMsX+JNl/Oy7jF49D60dYRz3vJSM2ovu/LzfFPd7BTgi2YKcumGD5PYEvGrfu2YvKSyWH+JBRJJ5wAtG0LfPSR0yMhInLGjh3Ahx8COTnJmVJmt3lHOHGBVXxh52q23QX/QN2ZaV8Kpxm3rnVKwkOwhtk0f1Fpke2kcP/E8tQHUqGmqVqXKnzBd1FpTann0orSWs8RiZbN+YX5tV7Dn1GB7dkFs12Z9J5slALOPRdYs8bpkRAROeOll6R0ZU6O0yNxRnbPbOT0svfDb9+/vTrWSH0gNegkl1V8YWcxv90F/0YTjQfLDiLNk1ZrO1/330imq0ZaUgfGVoGnnTOz/MJ8/PGtP1Zf6vCVY/NfbWlnNjiUMzIzoZ5FamjX9ytPFv37S4mi7ea9ZYiIEpLWkkYxYADQubPTo3FGfmE+8jbm2d7eF2tU6krMKphVHRwb5RJbxRd21lYF28b3muMWj6sT65RVlqFZg2a1Hjt/9PyQSsI5IeSW0InEKq8HCD5jO2XZFNOWiCXlJch5I8ewdjEgwbNnmgdZzbMwossI5G3Mq1dFjHAS2N2Y9J6M+veXj2vWAB3t93ohIop7H38MfPcdcO+9To/EOXYWqVmZs2EOALkS7LtC7Jugy+mVYxlfWFWWCFyDNX/0/FrbTl4yudZrGikqLcLe0r1x09wDSPIZ42B5Pa0yWlmuCDVLXfAxC4p9fJcb8jbmoV/7fkhRKQCkvnFOr5yQDiCzs8LGaY2rL13YfQzFVs+eUtOYecZElGxefFFqF48Z4/RInFPfSapKXWkYoJaUl2DhpoWWa5zMGKVG+KeY5hfmBw2KfdxetzhQUgfGvksEjdMaG37/t9LfYlKMuqS8BCu3rqx1eSRvY15Ir2WWB/TsqGcxqc+kOsGxW5Pek1FKilSnYJ4xESWT4mKp4z52LNDY+G04KZhNUplNahkxC1CLSosM1zgFKxEbLA106oqptoJis8e7WVIHxoAEx60btTb8XhWqan3uS4/wHUhmAXU4zApf22WVBzRz5EzMHz2/+nts8OE+/fsDX38N7N7t9EiIiGJj0SLg0CFgwgSnR+Iss4mtYFUdwlFSXoIpy6ZYzgYD1rWV8wvzw57ljocUzqQPjIHQdlSlrqw+kMqryuEx+BV6lPmv1ZcuYYcvD9luYW+rxh/+32ODD/fx5Rl//LGz4yAiipV584AuXYCzz3Z6JM7yTWylp6TXmtjaW7rX1uNDiSsAmUUOtygAAEx8Z6Jp0K6gsGD0AnRsbrxgxqM89W5YEm0MjBF+rm1ZZRlaZrSsNUu7YPQCvHTJS6aPqdSVdc4MrS6XxFtuDoWnTx+gQQPmGRNRcvj+e2D1apktVvYzBhJWds9s9GzTs9bElt3YxCyuCPWqtv8kodUaLF9QbfSak/pMQnbPbNPH+08uujWuYWAM4wMgPSW9Tv09I3tL99aZpc3umY3MjEzD7X1ngv7B9KQ+k4IW9/Zd/rDbHjKUFtPkvAYNgLPOYp4xESWHF16QZh5XXeX0SNzLbuMPo7hi/uj5eHbUs4YpGmbxiX8g7pvFNrO3dK/ha84cObPW433fN5rVdmvOcVKXa/Px70Dn3xra/2se5TGsMmF2Rje2+9g6KzZ9C96MyqOcnXV29WvZSaK3ag8ZqRbTFFv9+wMPPQQcPCirtImIElF5uQTGw4cD7ds7PRr3CoxNWmW0woEjB1BeVV69jVVc4WMU2/jHCP7PE/j6U5ZNMazA5auDbBVT+H/fM814HtaNOccMjL3MdrB/EWs7B5Jv27yNebUCXAVlWYLN//U7PdXJsr6yj+9sK/A5rVaTMjB2r/79gaoq4D//AYYMcXo0RETR8e67wK5dwMSJTo/E/YyCYwC2awOHEjAbTbIdOHKgzuPSU9JDrmpl1jfCjWVjmUphwT8dYeqKqcjplWPZIcbHKDDV0Fi6eWmd5zVKcxjRZYTtMRqdbUWixTTFXr9+UrqNecZElMjmzAHatQNG2H+rS2iTl0xG6gOp2LBrQ502z4H1hItKi1BaUYr5o+fb7h5nFHNYLdb3mbJsSq3ZaZ+m6U1DnmSz21raDRgYmzAqbp23MQ+5g3KrDyQAhgGuVWAarGg2gOoA2g7f2Zb/gW9WFUNDo9NTnWyvdKXYatoUOO00BsZElLi2bQPeew+49logldesMXnJZMwqmGXa5jlYPeFg7MQcZo8za2JWVFoU8rolO+2n3YKBsYlgB6PVwWbVm9zOQW53Ztd3thU4FquOe9v3b6+uQ0juc/75wCefACXhdwclInKtuXOlCsU11zg9EnfwtXM2+7qdK8BWV6HDDayDfT+cihJ2ZqndgIGxiWAHo9nBlvNGDrbv327aac7OQW4WWGdmZBqebZn1WTerbVilq1y5EpSAgQNlYcratU6PhIgossrLgeeflxSKDh2cHo07mE1k+b5uNdEGBJ8RDnYFOzCg9n0t2Dont1aUiAQGxiaCHYxmB5vvYNbQ1cGxfxAb7HkB81yc6cOnG55tmY2lSleZ1khmvrE7nXOOXF5cudLpkRARRdY77wA//8xFd/7MJrB8Xw+WmxtsRtgs5miV0apOQD1u8ThMeHOCrcX/QOhNyOIFA2MTwQ5GOyspNTQ6Nu9YK4i1k4Aeai6OVbBtJxAn92jSBOjbl4ExESWeOXOkPNvw4U6PxD0m9jY+S/B9PVg8YNW6udNTnTCiywjDmAOA4ZXmiqqKkMZvN285nnorMDA2EexgtFt4OzCf127QG0oujlWwbfQ9j/K4ciUoiYEDgYICYP9+p0dCRBQZW7cC778vucVcdFdj5siZuKHPDdUzxCkqBTf0uaG6UQZgHQ+YtWYGUF00wKiiVqQX4VulVoS7ANApPDwtWNX/C6wtaNYABECd5hrBimKHM07/sRjVJPT/XsfmHTG65+iIvT5F1sCBwIMPSnWKUaOcHg0RUf1x0Z25mSNnYubImVi1ahUqrrA/Y5tfmI+DZQcttykpL8HSzUuROyi3Og6YumIqWmW0Mq06ES6z2et4663AGeN68D+Ly7skz7KvuP+ZVDQuKVidUQZ+z+oMk5zXrx/QsCGwYoXTIyEiqr8jRyQwHjmSi+4iaeqKqSirLAu6nW+G1n/G1qhxhx0dm3dEx+YdDb9nlqIZb70VGBjXg1EDEDO+ZPZYXlKIp5weqtGggSzCY54xESWChQuBX38Fbr7Z6ZEkllACy8AZ2/KqcjROaxzS6yko0xRNq2Yd8bbWiYFxmMwagGRmZJo+ZvKSyfUu1m3X5CWTMX7x+LjJ6aHaBg4ECgvlzYSIKJ7NmAGcdBIweLDTI0ks9Q0sS8pLcEOfG0yrVwXS0NWpoKEUCIinrncAA2NDgTOtk5dMrjPzahbgAjA9yGYXzDYtgxLJSwr5hfmYXTAbGrrO+BK17mCiGThQPq5a5egwiIjq5b//BdavB266SXKMKXLsFgEwk9U8CzNHzsT80fOrg1yz8nGAxDa+ybVQm3VkpGZYfu4mDIwDGM0EzyqYVWfm1SzA3Vu6t05A6qOhTQ+6SF5SmLpiqukY3JrTQ7X17i0toplOQUTx7Omn5X9ZjnmmIYXJN3MbjjRPWvWMrX+QW6WrTB+joetMrgVL2fTFVIEL/YpKi1x7FZuBcQCzLnL+SspLLANcs8R0QBqAmHXF81ef/GCr4NetOT1UW2oqcN55DIyJKH798gvw6qvAhAkSHFPkZffMtow5zKSnpGPqiql1YoxgMUJgK+pga6asYiq3XsVmYBzA7oxqpa40vIRRXFaMEV1GWObsmHXF86nvAj2zA9uXOE/xYeBAYPNm4IcfnB4JEVHo5syRNtA33eT0SBJbOCkVh8oPGcYYwZ7LP76ws2YqWEzlxqvYDIwD2J1R9QW0gYvtikqLMKtgFtJT0i0fb9QVz6e+C/SMDmwFhUl9JrmyZiAZGzRIPrJsGxHFm/JyYPZsYOhQ4MQTnR5NYjNaDHdDnxtCmkn2rytsFNsAda9uW3Xd8wkWU7nxKnZSB8ZG6Qp2z7yKSoswfvF47Du8z/D7RyqPID0l3bJKRai1/eyeWRn9kcwfPb9WJx1yv549gaOPBt57z+mREBGFZvFiYOdOlmiLlcDFcDNHzsS2W7dhwegFtmeTd+zfUV1cYG/pXmRmZCIzI9O08oTV1WnfFW6rmMqtlSmSNjA2S1cAUB1UAuYVJorLiqGhTbvdAUBZZRmapDexXQzbF6ibLZzzKI+tdArfgW3WBY/ig1Iy2/L++0Cl+WFGROQ6M2YAxx8PDB/u9EgSTyhrkIwmyswm7FpltKoVFxWVFqG0ohTzR883vLqdOyjXMEbyX6Tn//oAqtdnBSvx5qSkbQltla7gfwDkF+Yj540cywDYyo79OzB/9HxMfGdirdcLPFPyBepWC/8qdWWd9tKBAp/HP+B34wFI1oYNA/LygIICoG9fp0dDRBTc+vXA2rXAP/4BeJJ2+i0yAie6RnQZgbyNeSG9x/tqD/s/p1FMAtRtBFJSXoKcN3IwfvH4OhNt2T2zMW7xOMPX3L5/O9Q0CZozMzIxffj0uIlBkvaQtZuukN0z27J8STBZzbNsFcO2Uw0DCJ5rHKsGIhQbF1wgM8dMpyCiePHEE0Dz5sA11zg9kvhmdGV7dsFsy/d4O7PJZjHJ3tK9huOo1JWmhQCs6h77FJUW4Y9v/dGVpdmMJG1gbLdFYX5hPjwqvF+T/6ywf/5P7qDcOmVSQlmZabVtvPUkJ2uZmcAZZwDLlzs9EiKi4LZtA157Dbj+epZoqy+jiS6rHgWhVLQyatBhZyFc4ESb3avpZZVlyHkjJ6wStLGWtIGxnRaFvoMsnDSKzIxMwzJsrR9tjXGLx9U5cFtltLL93FYHb7z1JKfghg2T7lG//eb0SIiIrD31lKRPcNFd/YUyoZXVPMvWFWOrGWWznGGrcYVS+cJq5tlNkjYwrm96Q5P0JlBQlrPJRjk9gd1fgJqcnsBAPc2TVqfsW7BVnPHWk5yCGzYMqKoCPvzQ6ZEQEZn77Tdg7lzgiiuA9u2dHk38szuh5XuPD3bFONiMcnbPbNMZabNxhduW2s0pnkkbGAPWvb7zC/NN2z4DQJWuwvzR803zjwMD4GA5xEWlRcjplVMrUH/x4hfxwkUvWAbvRj9TsICf4ssZZwAtWjCdgojcbc4c4NAh4E9/cnokicFO0On/Hh/sirGdGWU7M8D+E21WdY+DcWuKZ9JWpbDiO6uyEurZjlWQ7ZO3Mc8wiA01qA1cgUrxLTVVFuEtXw5oLYvxiIjcpKwMmD5d/lf16uX0aBKD733crPKDgsK2W7dVf547KNeyApadNUi5g3Jx9ZtXo7yq3HDbxmmNDWOU7J7Z1RU0tu/fDo/yBC1c4NYUz6SeMTZjt0LEjv07TM+S/L+eX5hvK28nnEsLodQzpPg1bJgUy9+0yemREBHV9fLLwK5dnC2OtOye2bZ7IQS7YmxnDVJ2z2w0a9DMdDzlVeWmcYbvKry+T6Py3kro+zQWjF5g2Ak4zZPm2hTPpA6MzYJKu9P7Wc2zMH34dKR50mp9Pc2ThunDp1d/PnXFVFt5O6G8NhA8X4gSx9Ch8pHpFETkNlpLibYePYAhQ5weTeIJZe2QVYqo3ecxK9sGSHWJUCbwpq6YirLKsjpfb9agmWuvbCdtYGwVVNqZ3vcdTNk9s/HixS/WyQ323+Ghriz1H6PVbDBrFiePdu3kTYeBMRG5zfvvA4WFwB13MNUrGkJZO2QVN9h9nmAxUGBMY/WaZvGPVfDttKTNMbYKKo3ydNI8aWjWoBn2lu417P5ideaT1TzLMMdYQdWaSfY/c7PTwY41i5PL8OFSCungQdYHJSL3yM2VKhRXXOH0SOJfYKc7X6xhZ+2QnbjBzvMYxUD+AifwrF7TLP5xa34xkMQzxmbB4/b92zF1xVTDChF77txjeHkiGLPLF5P6TDI9c7MzGxwsX4j5x4nl978HystldoaIyA3WrJHbn/8MpNdNJaUQ7C3dW6/0yEhdRbaqNBGYejFl2RTL14zHErJJO2NsdhYDSHBsViEiHP7BbuBZYKD8wnxMWTbFsN4xEHz1qC+h3eosrh3a1ftnotj73e+AVq2At98GxoxxejRERDJbfNRRwLXXOj2S+PfTwZ9Mg0w7sUgkryIHVpowil3yC/ODxiq+bf3jmozUjJDHE0tJGxgHu1QQysFoh93LIFZlUoC6s8QqIKHL97nVmeO8U+eFMHJyi9RUYMQIYOlSoLISSAneop6IKGoKCoD33gMeeQRoFHqPBwpgtEgNkIktNa3mvT5FpWBi74mYOXJmre2ikbZgFbtYzUQHvmZpRWn1/aLSojopHm6StKkU/knoZiKdq2tnMZ1VUAwAxWXF1Y8zWu3pWzFqlSpC8WvUKGDPHuCTT5weCRElu9xcaT50ww1OjyQxGJU1M1KpKzGrYBYmL5lc6+uxTluwipH8XzPeCgUkbWAM1JQ1sVsjsD6ClVYL1mnPx3emlV+Yb3nZxGzsCsrVq0HJ2tChMnP89ttOj4SIktkXXwBvvgnccgvQzLzsLYWgXdN2IbVXnl0wu9bnse58axZneFTt0DLeCgUkdWDsE8mzLLNZYaszJjud9oweZ3VQjugywrCpiIbGTwd/CuEnIjdp3hwYMAB45x2nR0JEyezhh4HGjSUwpsholdEKOb1ybDUEA+T9PPDKs1UdY59ILcw3a1ldpatqTfyZxSqtMlqF9brRxsAYkTvLspoVtjpjsttpz9/2/dsl78jgD6hSVyJvY55pUxGzPCaKD6NGAV99BWzZ4vRIiCgZbdkCvPKKpFBkGjd/pTAt3LTQdkMwwDrP10gkG4P5YqcUVXfBS0l5CaYsm4JOT3UyvRp+4MgBV1bLYmDsZecsKxirWWGr0mpWlxMCL0kEMvsDKikvMTxYAft5TOROo0bJR84aE5ETHn4YSEsDbr/d6ZEklr2le02rPJixih+MZoYjne+b3TMbVbrK8HtFpUWWKaLlVeWuzDNmYGwinEsNVrPCVukaVvnA1/e+PqScI3+VutLwNds1Zbm2eNa5M9C9O/OMiSj2tmwB8vKA668HjjnG6dEklnDSHM3iB7OZYbNAtT75vvVZj+XGPOOkD4yNAuBwLzVYzQpbpWuY5TJraCzdvBRzRs0J62fzvUbga7o1r4fsu+QS4KOPgN27nR4JESWTadOkkcdf/+r0SBJPqGmOVmuhzGaGza4k1ye4Ncs1tsONHfCSOjA2C4CDdXIxE2wRXzjpGr6zO6uyckZ8rxuJFBFynzFjgKoq4K23nB4JESWLr74C8vOBG28Ejj7a6dEklnByba3WQpnNxJpdSQ6l2EDghKJvLP6TcEZd84y4sQNeUgfGZmdUdrrOGQl1EZ/v4Bq3eJzl8/7xrT9iRJcRlmdkTdKbxKxECzmvVy9JqVi82OmREFGyuP9+aeRx551OjyTxhJpr27F5R8v3eLOZWLMryXbjBbMJRQC1JuGmD58edBY5MyPTlXFKUgfGoea22Jny96VG+BbV+cqxBfI/uIIpqyzDwk0LLVMqDpUd4sxwElFKZo0//BDYt8/p0RBRovv8c2DhQmDKFGkBTZEVSjxiZ4bX6gq20ZVku+uq7C7e800Ums0cp3nSMH349GA/qiOSNjDOL8w3rfjQOK1xnTJodi81GJ1NjV88vk6HmlBLtBWVFiG7Z3ZMmpFQfBgzBigvB9591+mREFGiu+8+aeTxpz85PZLEZPc9PDMj09YMr9UV7MAgePKSybbXVYXSrCO7ZzaapDcx3L5Zg2auncBLysDYF7xW6so630tPSUdZZVmtMmgKCjm9cmztRKOAV0NjdsHsWgdZuCsxY93ykdzrzDOBdu2A1193eiRElMgKCqTL3e23A624djsqcgfl1pmsS/OkVc+4+hbNGQWaZrO9ZjPDgUHw7ILZttdVWRUZMBqX2VVxN3fgTcrA2Gy2NkWlIM2ThvKq8lpf91WHsMMs4NXQ1WkVnZ7qFFIBbwDVfxx28pgj1dWG3M3jAUaPBpYvB4qLnR4NESUirSWnuHVr4LbbnB5N4vJdEfZ/b3/x4herc3V9E3mBs7mhVtEym7wzYhTP2Jmcyy/MR+tHW1uun3LzVe5UpwfgBKvVmofKD4X0mEBZzbNMz5B8B6xZCkWjtEbI6ZWDuZ/OrRWcB+biZPfMtlzQ5/8a/onxbr1sQeEbPRqYMQNYtgz4wx+cHg0RJZrly4F//QuYPl1SKSh6WmW0wrZbt9X6WqenOpnO5mb3zLbM+TV6zw/larVR8Op7zqkrpmLH/h3Iap5VnbcM1I1BjCgoV1/lTsoZY7MzFbP6flaPCZQ7KNe0z3mKSjE9WHwzvzNHzsSLF79Y56zRblAb6a425G79+8tCmEWLnB4JESWaykrgrruA444DJk1yejTJKVhObyg5v4B5LBPKuiqrMrB21k9paFdP1CVlYGx2KcAo59j/MXZk98zGpD6TDA8ys+dXULUOrvrUHg71j4TiW0oKcOml0h6a6RREFEkLFgCFhUBurjT1oNgLltMbSs4vYB7/TOozKSIlX+3EGqH2ZYi1kAJjpVSKUqqHUmqCUmqGUuo/SqkSpZT23u6P0jgjyixP12xnhVprb+bImZg/er7t549krk2ofyQU/664AigtZbMPIoqcw4eBe+4BevcGxo51ejTJK1hOb6gL8s3in5kjZ0ak5GuwWCM9Jd3VaRRA6DnGCwGMjsZAYs0sTzcwN6ZRWqOwau2F8vyRPEhyB+VG/TXIXc4+G2jfHnj5ZSDbvVeniCiOzJgB/PADMG+eLPQlZwTL6Q32fbPnjFYqg1EM4pOZkYnpw6e7Oo0CCD0wDkzC3QugCECXyAzHWeEcYG56/li9BrmLxwNcfjnw1FNAURGQaa8TJxGRod27JX1i2DBg4ECnR0PBAtloBrqhSoQYJNTAeB2ArwBsALBBa71VKTUBwIuRHphTon2AxeIAdtMfCcXGlVcCjz8uNY0nTnR6NEQUz+65R9YsPPGE0yOheBTvMUhIgbHW+qFoDYSIwnfqqcBJJ0k6BQNjIgrXxo3Ac88BN90EdOvm9GiIYo+ZQ0QJQClZhLd6NfDTT06PhojikdbArbcCLVpIC2iiZMTAmChBXHGFvLG9+qrTIyGiePTGG8CqVcCDD7L1MyUvBsZECeLEE4EzzgBeesnpkRBRvDl8GLjjDqBHD6ZjUXJjYEyUQCZMkBzBLVuaOD0UIoojjz0GbN0K/OMfQGqoy/KJEggDY6IEcvnl0qFq+fKjnR4KEcWJ776T8mxjxwKDBzs9GiJnOXZeqJSaCGAiALRt2xarVq1yaihJp7i4mL/vBNavXzd88MFR+OCD1UhL004Ph6Lgxx8z0LJlGbTm33IyiOb/bK2Bv/ylJ1JSmuMPf1iHVavKovI6FBzfm93BscBYaz0HwBwA6NOnjx4wYIBTQ0k6q1atAn/fievOO4GRI4FDh87DxRc7PRqKtPvvB6ZNA047DXj8cf4tJ4No/s9etAhYt05SKC699HdReQ2yh+/N7sBUCqIEM2QI0KrVEcyb5/RIKNJ27AAe8laT/+wz4KOPjnJ2QBTXDh6U8mynnip1i4mIgTFRwklNBS644BcsWSKtXSlxLF4MlJcD33wDHHMMsHo1A2MK3333ATt3ArNmccEdkQ8DY6IENGzYz6ioYOm2RPPmm1JO68QT5crAp5+2RGWl06OieLR+PTB9OnDddcBZZzk9GiL3YGBMlIA6dSrB2WcDc+bI4hqKf3v2AGvWoDpv/IILgAMH0lBY6OiwKA6VlQF//CNw9NHAo486PRoid2FgTJSgJk0Cvv1WOllR/HvnHaCqqiYwPu00+bhpk2NDojj10EPAF18Azz4LNG/u9GiI3IWBMSW+igqnR+CISy+Vtq6zZzs9EoqEZcuAdu2A00+Xz084AUhJqcKXXzo7LoovhYVSs/jKK4Hf/97p0RC5DwNjSmxLlwInnwz88ovTI4m5hg2lE97ixUn54ycUrYGPPgIGDACUkq+lpwPt25cyMCbbKiokhaJlS8kvJqK6QlqHqpTqDOCagC+f4nd/oFIq8Dlf11p/Fs7giOrt+OOBH38Ebr4ZWLjQ6dHE3MSJwJNPAi++CPzlL06PhsK1ZYuc3PTvX/vrHTuW4MsvGzszKIo7jz8OFBQAr7wCtG7t9GiI3CnUAi0dAUy1+H5/783fFgAMjMkZJ50E3HsvMHWqLOlPso4XJ50EnH++5BLeeSfg4TWiuLRmjXysGxgfwscfH4XDh+UKAZGZzz6Tf4VjxkjrZyIyxrdJSnx//jPQqxcweTKwb5/To4m5668Htm2THFWKTx99JDN8XbvW/nqnTiWoqpJFlkRmDh8Gxo2TY+jZZ2vScYiorpACY631Kq21CvE2L0pjJ7InLQ14/nm5Fv3nPzs9mpgbPRo49ljmFMazNWuAc86pG9B07HgIAJhnTJb+7//kGHnhBSAz0+nRELkbZ4wpOfTuDdxxBzB3LrBypdOjiam0NGn3+sEHLO0Vj3buBL7/vm4aBQB06FAKj4eBMZlbsQL4xz+AG28Ehg1zejRE7sfAmJLH/fdLjavrrgNKSpweTUxNnCg5qJw1jj9m+cUAkJ5ehRNO4AkPGSsqkso0J53ERh5EdjEwpuSRkQE895xMv913n9OjianMTOCqq4D586WDGsWPjz4CGjeuaegRqHt3BsZUl9YSFP/6K5CfDzRq5PSIiOIDA2NKLgMG1NQw++9/nR5NTE2ZIotw5sxxeiQUin//GzjrLCDVpIZQjx7A5s2yb4l8nnwSePddKdHWu7fToyGKHwyMKfk89hjQvr1MoSZRSkW3bsDQocDTTwNlZU6PhuwoLZXWvWeeab5Njx7SKvrrr2M3LnK3Tz6RuuWXXCLrC4jIPgbGlHyaNZOOF99+K8u1k8jttwO7dgELFjg9ErJj40bpVnbGGebb9OghH7/4IjZjInf77Tfg8svl3P/551majShUDIwpOQ0cKN3wpk8H/vUvp0cTMxdcAJx+OvDII0BlpdOjoWAKCuRjnz7m23TpIpVHmGdMVVVyIeynn6S7XcuWTo+IKP4wMKbk9cgjElVcfTVw4IDTo4kJpWSSfPNm4PXXnR4NBbN+PdC2rcz+mUlLk6oDnDGmadMkr/jJJ4G+fZ0eDVF8YmBMyatRIyAvD/jhB8kxSBKXXAKcfDLw0EOycp3ca/16SaMIdjm8Rw8GxsnuzTeBBx4AcnKYV0xUHwyMKbn16wfceack4y1Z4vRoYsLjAe66S/JXly93ejRk5uBBWVBnlUbh06OHtP0uLo76sMiFvvoKGD9ejpXZs5lXTFQfDIyJ7r8f6NkTuPZaqYifBLKzgawsIDeXs8Zu9emnsm+sFt75dO8uH9kBL/ns2wdcfLFcAFu8WBr5EFH4GBgTNWgAvPSSBMU33uj0aGIiLU1mjdeulVbR5D52Ft75sDJFciorA8aMkZ5Fr70GdOjg9IiI4h8DYyIAOPVU6Yb36qtySwLXXAN07AjcfTdnjd1o/XqZ1W/TJvi2nTtLY0cGxslDa+CGG4CVK4G5c4Fzz3V6RESJgYExkc9dd8lS7kmTZEFegmvQALj3XgnA3n7b6dFQoIICe7PFAJCSIg1cGBgnj7//HXjhBeCee2TBHRFFBgNjIp/UVCA/XzoqjB+fFIV+r7pKKtbdc4/UQCV32LsX+O47e/nFPqecAnz+efTGRO6xcCHw178CV14pJdqIKHIYGBP5O/54YMYMYPVq4PHHnR5N1KWmyhtrYaG82ZI7bNggH+3OGAOSDfTLL8DPP0dlSOQSH34o5+3nnMPOdkTRwMCYKFBODvCHP0jyrS9CSWCXXSaLt+65RxbzkPPWr5ePvXvbf0yvXvLxf/+L+HDIJdatkwoUJ50k6U+sQEEUeQyMiQIpBTz7LHD00XKt8tAhp0cUVR4P8OijwJYtwMyZTo+GAAmMTzghtJa+DIwT25dfAsOHSyfE995ju2eiaGFgTGSkZUtg/nzpnXzrrU6PJuqGDweGDpW0iiQp5exqBQWh5RcDQIsWQKdODIwT0c8/N8SQIUB6upRXPOYYp0dElLgYGBOZGTAA+MtfpBbSyy87PZqoe/xx4MABaStLzvn5Z+DHH0MPjAHJM964MeJDIgdt2wbceuupKCmRmeLjjnN6RESJjYExkZUHHgDOPhuYOBH45hunRxNVPXrIjzlzZsL/qK4WSmOPQKeeKvsuwbN/ksa2bXJ+fuhQCj78UCqPEFF0MTAmspKaCrzyiqxyGTsWKC11ekRRNW2atJa97TY2/XDK+vWS933aaaE/tlcv2W+sZxz/tm0Dzj8f2L8fePzxjTj9dKdHRJQcGBgTBdO+veQbf/45cMstTo8mqtq0kUnyZcuAxYudHk1yKigAunYFmjQJ/bGnniofmWcc3zZvlpniffukPNtJJxU7PSSipMHAmMiOYcOkov7cucCCBU6PJqpuvFFmK2+5BTh40OnRJBetZcY4nPxiQFp8N2/OwDiebdwI9O8v6TAffhhayT4iqj8GxkR2PfAAcO650jL666+dHk3UpKYCs2cDu3ZJbWOKna1bgd27ww+MleICvHi2di1w3nlAWhqwZg2DYiInMDAmsis1VapTNGoEXHppQk+nnnkmcMMN0gTw00+dHk3y+Pe/5ePZZ4f/HKedJjPG5eURGRLFyJIlwAUXSJ3itWuBk092ekREyYmBMVEojj0W+Oc/ga++AiZMSOgVarm5knN89dXsiBcra9cCzZpJhZBw9e0ra0S5AC9+PP00cOGFQLduMlOcleX0iIiSFwNjolANHgw89pisTnvoIadHEzUtWgBz5siawwcfdHo0yWHtWuCss4CUlPCf46yz5OMnn0RmTBQ9lZXAlCnAzTcDo0YBq1fLySgROYeBMVE4brsNyM6WJNx333V6NFEzapRMjD/8sCwKo+jZt09meeuTRgHIAry2bRkYu92BA8DFFwP/7/8Bt98OvP460Lix06MiIgbGROFQCnjuOUnozM5O6I4YTz0lLWhzcoDDh50eTeL65BPJzKlvYKyUzBozMHavTZtkgeWyZcAzzwBPPFG/qwREFDkMjInClZEBvPEG0KABcNFFUok/ATVvDjz/vKRV33GH06NJXB99JOs7+/at/3OddRbw7bfA3r31fy6KrIULZR/v3w+sXAlMnuz0iIjIHwNjovrIygIWLQK++w4YN06SBhPQkCFyufeZZ+SSL0Xee+8B/fqF19gjEPOM3ae8HPjTn4DLLpPWzhs2SPVHInIXBsZE9XXuuZIo+O67wJ13Oj2aqHn4YSnjds01Um+XImf3bimLN2RIZJ6vb1/pYv7BB5F5Pqqf776Tph1PPikNdFatAtq1c3pURGSEgTFRJNxwgywtf/JJ4NlnnR5NVKSnA6+8Ivcvu4wl3CLJF8AOHRqZ58vIkEYRy5ZF5vkoPFoD8+ZJ05VvvpG/n6eflr8lInInBsZEkfLkk8CIETIllKBTdZ07Ay+8IBUqbropocs4x9T77wOtWgGnnx655xw+XIIxzu47Y+9eOYG8+mrpYPf55/I5EbkbA2OiSElNlSmhbt2AP/xBVqsloNGjgb/+VYpyzJzp9GjiX1WV5BdfcEFkKxMMHy4fOWscW1pLHn737rI295FHgBUrgA4dnB4ZEdnBwJgokpo2lVzjhg2BkSOBX35xekRR8be/SY3jKVNkZT2F79//Bn7+WQqbRFKXLsBxxyV0mW3X+eknOXG89FIpcbhuHXDXXSzFFpKDB6U25OrVTo+EkhQDY6JIy8oC3n5bguLhw6WSf4LxeIAFC4CTTpLJ8QQu4xx1ixZJxb+RIyP7vEpJkPbBB7K4j6KnshKYNUsuFi1fDjz6qATFp53m9MjiTEGB5BMtWABs3Oj0aChJMTAmioYzz5SIp7BQpgITsDNGs2YS/6emyqKxnTudHlH8qaqSy+5Dh8rvM9KuugqoqJA4g6Jj9WrJIZ48WT4WFgJ//rP8XZBNlZVAbq7UKzx8GPjXv4BbbnF6VJSkGBgTRcvw4bIkfdUq4MorE7LG8fHHA0uXAkVF8uPu2+f0iOLLunXAjz8CY8ZE5/l79pQyYY8/npDnZo7atg0YOxYYMEAW2r3yiuQSn3CC0yOLM1u3SgmVu++WP4TPP2eBZ3IUA2OiaMrOlp7Kb7whJd0SsIxD797y4331FXDhhcChQ06PKH7Mmyel1S68MHqvcf/9Mpv/3HPRe41k8sMPMpl58smSv33//cDXX0vFCaWcHl0c0Rp46SWgVy+ZZl+wAHj5ZaBlS6dHRkmOgTFRtE2ZAkydKpHJnXcmZHA8eDAwfz6wdq0syispcXpE7ldcDPzzn5Kj3aJF9F7n/PNlAi43N2G7lsfE998DEyfKVZJZs+Qi0NdfA/fdBzRq5PTo4syePXImkZMjRZ43bpRJBJ5ZkAswMCaKhQcflPrGjz8O/OUvCRkcX3aZTACtXs3g2I6FC2UB/sSJ0X0dpYAnngB+/RW4557ovlYi+uYbYMIE4MQTgbw84Nprgc2bpZ53VpbTo4szWsuB360b8OabwEMPST5xp05Oj4yoGpcHEMWCUsCMGbLa6tFHpazDQw8l3AxJdra89111laQHvP02Z9OMaC01oLt2BX73u+i/Xp8+sjjsmWdkkq537+i/ZrwrLJRZ9oULpfrizTcDd9zBVs5h27VLDsI335QDcsUKSYInchnOGBPFilLSD/b666Xq/913J+TM8bhxMrO2cqUU5ODMcV0ffghs2ADcfnvszo1yc4E2bYBJk6RSBRnbsAG45BLglFOAJUsk+2nrVuAf/2BQHBZfX2z/Wnb/+Q+DYnItBsZEseTxyFThddfJjHGCBsfjxwMvviiTQsOGMbc10EMPSZA1fnzsXrN5c2D6dCkV+/DDsXvdeKA1sGaNdHTv00eu7t97r1SeeOQRoG1bp0cYpzZvln8AV18N9OghucSsZUcux6OTKNY8HmD2bLn/0ENS42zGDPl6AsnJkYoL48bJArDly2XGMtn9619Swe/JJ6WxRyyNHQu89RYwbZosmOzXL7av7zZlZcBrr0nhmIICIDNTZtZvvFFOJChMpaVy9vX3v8tBPmOGpFEk2P84SkwMjImc4PEAzz4rpYkefVQKoeblAenpTo8sosaOlcYVo0dLPd0PPkjuBUuVlcCttwIdO0pKgxOeeUauZF9yCfDf/8pYks3OnXJ1/5ln5P5JJ0mlifHjgcaNnR5dnHvnHalnt22blO54/HHpj00UJ3j6RuQUpWRG5e9/l+4AF12UkEWAhw0D3n9fOmSfc05yt49+7jnpX/DYYzKb7oQWLSR39vBhaUOdLGkuZWXSZXDkSKBDB6mg2K2b/C6+/FJOVBgU18P338uK2wsvlIN75UogP59BMcUdBsZETrvzTmDuXIkeBw8Gdu92ekQRd845kj5w5IjMHP/7306PKPa++07SKwcOBC691NmxdO0qQeI33wAXX5y4CyQrKmSh4/XXA8ceK7/3//1PKiZu3ixXMEaM4BX+evntNynX0bWrLCr4+9/ll3z++U6PjCgs/HdA5AbXXAMsWiRvKH37yhRWgjn1VFng1KyZtNGdO9fpEcVOWZlcpk9JkUWJbqjSN2iQZO+sXi3BcaK0jC4pkVngiRNlsvKCC2TicvBgaV++Y4fkEbN1cz2VlclqzhNOkIT57Gzg22/lRD/BUsIouTAwJnKLSy6RKKWkRFZFvf++0yOKuBNPBNavl1nT666TLtmJEpCZ0VrOe/7zH2DOHHflWF95pTSq+OADYMwYmdGPN1pLB7qnngKGDgVatQJ+/3vpKjh4sMyM794t2UrDh8vJCdWD1sDixUD37pIwf/rpwGefyYHEenaUABgYE7nJmWcC69ZJJ6gRI2Q1d4KVc2vZsqY+7OzZMkG+aZPTo4qeu+8GFiyQ5odjxzo9mromTJB1oEuXSiD5xRdOj8haVZUcL7NmAVdcIfnCXbsCt90G/PCDVJR4/33pOvzyy7Lw06l87oSiNbBsmfyPGjNGZoWXLpVfdq9eTo+OKGJYlYLIbbKygI8/ljpnt9wCfPKJTDUm0MqglBRJRTzvPClx2qePFOe48cbEyfesrATuukvaMV97rSz2cquJE4GmTWUB2imnyPqpa6+VhZPRKjmrtaQ1fP21XCRRSvZ948YylmbN5PNffpHMos8/r7kdOCDP0a4dcO65chwNHcrOwlGhtSRq33uv/C/q1Al4/nlpb8l6xJSAeFQTuVHTpsAbb0h3gXvukcL4r78udaUSyIgREuhcfbWcA7z6qpwDdOvm9MjqZ88eOa957z0J9p96yh15xVauuAIYMkTSRefOlXrHLVrIwskePWRWtmtX4OST5fC0Q2ugqEhmcnfskAVvmzZJoPvll0Bxsf3xNW8uQfv48XIide65QOfO7v+9xi2tZcXsfffJ4oAOHeTSwoQJzCGmhMbAmMitPB7g//5PLl1ecYVEA888I5FBAkUDbdtKakVeHvCnP8kivbvukluTJk6PLnRr1sju2rNH4oiJE50ekX2+Bhf33y/7ZMkSqSCyfHntNtItWsh+a9oUSEuTicOUFOnrUFwsVQcPHQIOHqybQ3700XLic/XVkqbatavMDmstaRK+xx04ILPuRx0lwXhWVkId9u5VWSkn5Y8+KgsCjj1W/u9cc03sO9IQOYCBMZHbDR4MfPqprPrOyQHefVeSc1u1cnpkEaOUTESNGAHcfjvwt7/JrOWDD0oAFQ8Lpr79VhoZ5uUBxx8vi+1OO83pUYUnLU0qVVx8sXxeXi7l5r76SlIfdu4Efv5ZgtjycgmaKytlVvfYY+WEpnFj+di+vUw2ZmXJDG9mppM/GZkqLZWuJ088ITv7hBPk/0xODtCwodOjI4oZBsZE8aBDB+kl/Nhjklrx739L3a8LLnB6ZBHVpo0sVLvxRpk9vu46qQj1wAPS/8Rt+cfbtsnk2htvyExxerrUyJ06NT5nu82kpcms7cknOz0SiridOyV/aeZMKd9x5pkyW3zRRfFxRkoUYS57myEiUykpEnX9979yDXvIEJnN2bPH6ZFFXL9+wNq1wMKFMpE1ejTQs6cEzf6X9GPtt98kCL7pJkkB6NxZZrj37ZPZ7R07gIcfTqygmBKQ1nKi/Yc/yFT+Aw9IQLx6tSywGz2aQTElLQbGRPHm9NMltWLqVCnWevLJwPz5CVfWTSl53/76a/kxPR5Jrz7+eGDaNAlCo+nIEaCgQK4mX3ut5D5nZkrMMG+eBMVPPAFs2SILCO++W/JuiVzr119lJWi3blJMfOVKObPbvFlStM49l4nclPRCTqVQSikAYwGMB3AqgKMA7AXwJYCXAczTWjs4p0OUBDIyJBH38ssl3+Cqq2Sl15NPysxPAklNlcVsl10m790zZsjisGnTJJPkyiuloUO4uasVFcD339fkz371ldTy/fxzyZ8F5Ln79JEeLIMGya+YC/MpLpSVyR9OXp7UHa6okAM4L0/OPFnkmaiWkAJjpVRLAIsADAz41tHe20AANyilLtFaR3k+h4jQo4fUPH7hBZmy7NsXyM5Gg1GjnB5ZxHk8Ul/3wgslt3fePEmznjBBrvr27y/fGzBAynoFXgnet6/2AjLfx82bawJgQNoId+smE2l9+sitY0dOpFEcqagAPvoIeO01yUfau1cO7Ntuk/Sr7t2dHiGRa9kOjJVS6QDeAtDf+6UfAMwBsAVAewB/BNAVwOkAliml+mmtD0R2uERUR0qKzBpffrnUPX7iCfRduFDyBf/yF3f1II6QTp1k1vi++4ANG4A335Tb7bfL95s0kR+7cWPJUd6xo6YpBCC/shNOkCyUCy+Uj127Spno5s1j//MQ1VtFheQNL1okifC7dwONGskBnpMj1W3YkIMoqFD+Sm5ATVD8KYDBWuvffN9USj0N4E0AQwF0A3APgD9HZphEFFTTplKE9vrr8fNNN+HYuXOl5tmECcAddwAnnuj0CCNOqZpZ3b/9TQLgNWtkfeJPP0lQnJ4OnH++zPp27iwB8PHHMxXCtQoLZSXjp58Cu3bJWUtOjuTMtG7t9Ojc5eefpcj0smXSmnnfPjkbHDUKuPRSYPhwCY6JyDZbgbFSKhWAr6GpBnCVf1AMAFrrw0qpqwB8D6AxgJuVUo9orYsiOWAiCiIrC9/efjuOfeYZ6bv83HNyGzJE6qCNHJmwK86zsqTcc3a20yOhkP34o7QdnjdPpu2HDJHL/2vXAlOmAHfeKVdFbr4Z6N3b6dE6o7hYfh+rV0sgvGGDfP2YY2RV6O9/L328mTdMFDa7VSkGQhbZAcAKrfUmo4201r8CeMX7aQMAF9VveEQUtg4dgKefBrZvl3JMmzZJbdLjjgP++leZmSNyWnGx5Md36QLk50sB6+++k/7gTz0l3dc+/1w6ry1aJJcH+vWTUiVlZU6PPrp27gTefhvHzZ4t6wdatJDA99FHpelGbi7w2WdyeeT552V1KINionqxGxgP8bu/PMi2/t8fFtpwiCjijj5amoJs3SqLcbp2lUYhp5wii/fuu0/atDlZIJiSz5YtwC23SI5Lbq7MeH7zjRybgV0de/aUtsQ//SQdX4qK5LJAu3Yyg7xuXXyXK6yslFWgb78tJ7EXXigtBNu1Ay66CO1ff72me4wvZeLjj6Vl/KmncmUoUQTZzTHu4Xd/Q5BtC0weR0ROSkuTvMNLL5V6posWyazb3/4mb8YtWkgtsn79pJzT6adLviJRJFRWyszv6tWyUnL1ajkmx4yRVImzzgr+HM2bSzB9000SIL7wgqQJPf20BNgjRsitf3/3raI8dEiS4H237dslGP7qKzkh8M1+KyV51YMHVyfQf3zgAM4dxnkmoliwGxj7r9rZFmTbHwFUAkgB0EUppbSO51N5ogTUpg0webLc9u4FPvxQFvGsWAG8/rps4/FI6YYTTpDVascdJ49r2VJuTZrILF1VlXw8cEBm8oqKZEX8zp0yw7dzp+Q0H3OMzIL5PrZuDTRrJgFM8+ZyPyNDVs6npNSeBauqko4bhw/Lx9JSuQRvdauqko4bxxwjs+ZHHy0FiVNS5GfzeGpeK5a9psvKaurGffNNTRDUtGnNNqWlwJdfSj25xo2lflx6uixGKyyU2f3UVLTau1dm/gNnWKuqJGf3m29k+08/lf1zyikyw9itm+zPhg1rHvPbbzIurWt+P77fUZs28ruz+3sqLpYZ4U2b5FZYKDOc+/bJ908+WRbYXXON7J9QeTySUjBsmDzn66/LbGteHjBrVk1wecYZ8tF3/LZqJSeAjRvL76iiQgLWX36R248/yu/g++9lPzVpIvulaVO537Bh7d+NxyO1/g4fln1WWir39++XjpR79sjfw5498jV/KSkSzHfrJj9H165y69699rEAoGrVqtB/R0QUFruBcQu/+5b9Z7XWFUqpAwBaep+/MYDisEZHRNHXqhUwdqzcAAkQ1q+Xy9NffimBwpo1wMGDoT1vixYSAB97rAQhmzZJAB4YIJhJSZGgrLIyvDQPj0de1w6lJPBs2FBuDRrITamawL+qqvatvFzGVVFRc7+yUn7uo46SkwdfIFleLj+3L2CqrKz9+mlpcgLStKkEUlu32hr7KYDki7dsKePOyJDX2rNHgjSfdu3k5GPp0tqvfdRRUrVg377g+yUlRU40WraU1/H9rioqJIg8ckSOkZ07JTD2SU2V/OFLL5Ui0+edB7RvH/Rns61FCwmwr7lGxvDxx5IatG6dzCq/9FJoz5eSIqs4GzWSn+PgQbn5F7s249sHzZrJiV9mpuzX1q3lxKxjR3nurCz5u2D5NCLXUXYmc5VSZQDSvJ+mBetsp5T6CcCx3k+P1VrvMthmIoCJANC2bdver7zySuAmFCXFxcVo0qSJ08OgKIr4PtYaaQcOIHX/fqQVFyP14EGklJZCKyXBo1KobNQI5c2aobx5c5Q3a4Yq/9lIP57Dh9GgqAipBw4g9dAhpBw6hFTvzVNWBlVZCVVVJR8rKqA9HlSlp0OnpaEqPR1VaWmobNAAlRkZpreqBg2qx5xeVIT0vXuRvncv0g4eBLSueX5vkKsqK+EpL4enrKz6o/IPhDwe+Vl9H5WCTk1FVWoqdEpK9Q1KIbW4GGn79iHVPzj0eFDRpAkqGjdGWcuWKO3QASVZWShp1w5NtmxB5rp1aLhzJ1JLSlDetClK27XDoeOPx6FOnZB68CAydu2CKitDWatWKOnUCZUNG8JTUQH93Xc4essWpO/dC09ZGVKOHEFVaioqmjVDSfv2KO3QAYc6dkR5y5YyjLIyNNq6FY127EDGzp1oUFQEz5EjqGjcGEfatEFJ+/bQKSlQ3hMBpTVUeTnS9++X32FRkeynI0fkd1VWJj97aqrsl4YNUda6NY5kZuJw27Yo6dxZnjMtDU5JKSlBw1270PDnn5F68CBSi4uRcviw7C+PB5Xp6Shv1QplLVviSOvWONK2rXwvgCorg6eiovr3gqoqqKoq+dkbNEBVWlrUcn35Pzs5cD/Hzvnnn79Ba93H6HuOBcb++vTpowsKCqw2oQhatWoVBgwY4PQwKIq4j5MD93Ny4H5ODtzPsaOUMg2M7SbW+adCGE8D1eZfLybE669ERERERLFnNzDe53ffsvWQtxlIM++n5QAOhT4sIiIiIqLYshsYf+t3v1OQbdtDKlIAwBZWpCAiIiKieGA3MP7C736wXpz+ORtfmG5FREREROQidgPj9/zuDw2yrX8V8mBd8oiIiIiIXMFuYPwvALu99wcrpbobbaSUagPgcu+nhwG8Vb/hERERERHFhq3A2FueLdf7qQLwklKqpf82SqmGAPIgDT0A4GmtdVGkBkpEREREFE2htN2ZBWAMgP4ATgewUSn1LIAtkAV31wDo6t32SwB/i+A4iYiIiIiiynZgrLUuU0pdBGARgIEAOsA4+P0UwCVaa5t9X4mIiIiInGc3xxgAoLX+DcBgSB7xEgA7AZQB+AXASkiL575a6x0RHicRERERUVSFkkoBAPDWJX7VeyMiIiIiSgghzRgTERERESUqBsZERERERGBgTEREREQEgIExEREREREABsZERERERAAYGBMRERERAWBgTEREREQEAFBSltjhQSi1G8B2p8eRRFoD2OP0ICiquI+TA/dzcuB+Tg7cz7HTUWt9lNE3XBEYU2wppQq01n2cHgdFD/dxcuB+Tg7cz8mB+9kdmEpBRERERAQGxkREREREABgYJ6s5Tg+Aoo77ODlwPycH7ufkwP3sAswxJiIiIiICZ4yJiIiIiAAwMCYiIiIiAsDAOOEppTKUUqOUUv9QSn2slPpVKVWmlDqglPpKKfWiUmpQGM/bTyn1glLqO6VUiVJqr1Jqg1LqbqVU62j8LGROiROVUlcqpZ5QSq3y7mPtvc0L83m5n13Eu58vU0q9q5T6USl1RCm1Sym1Qil1rVIq1ekxUl1KqRSlVA+l1ASl1Ayl1H+8f0++v8/7w3jOYUqpV5VS25VSh73/29cqpW5TSjWOwo9BQSilmiulxiqlZiml/quUKlJKlSulflNKbVRKzVRKnRHic3I/xxhzjBOYUiobwGwATWxsvhzAVVrr3UGeUwF4AsCtAJTJZr8AuFJrvdL+aKk+lFJPALjdYpM8rfWEEJ6P+9lllFItASwCMNBis08BXKK13hGbUZEdSqnXAYy22GSa1vp+m8/VAMA8AJdbbPYdgNFa68/tjpHqRyl1J4AHADSwsfkCANdrrUssno/72SGcXUhsnVETFO8C8AGA9QB+BdAYQH8AVwBoCGAYgA+VUv2s/lgBPAzgNu/9QwCeB7DO+zpjAFwAoC2At5RS/bXW/4vkD0SmUgI+PwjgBwDdwnw+7mcXUUqlA3gL8jcLyL6dA2ALgPYA/gigK4DTASzz/h0fcGKsZCjw73MvgCIAXcJ4rjwAl3nvF0GOg0JI17RxAM4EcDyA5UqpvlrrH8IaMYXqRNQExd8D+BDA/yCd7FoCGAT535kC2U9tlFLDtdZVJs/H/ewUrTVvCXoDcDeAjwH8HkCKyTbdAOwEoL23aRbPdxqAKu92+wCcYrDN/X7PtQ7eqxK8RX1fTwTwJIArAZwEmeUd4Lcv5oXwXNzPLrsBmOL3+94AoGXA9xtCrvr4tnnM6THzVmv//B/kZPNSAJ29X5vgt7/ut/k8F/k9ZjuArIDvewC84LfNa07/7MlyA/AcgHcBnGexTX/IpIVv/1zN/ey+m+MD4C2KOzfgzdNiu9/7/xFabPeG33aTTbZRAP7rt91Ip38PyXqrR2DM/eyiG+TK3q/e33MVgO4m27UBUOzd7jCATKfHzpvlfg0nMP7M7zEjTLbJ8AZTvu16OP2zJsMthPfbm/z2zWruZ/fduPgugWmtf7O56TLI5XIAyFJKNQvcQCnVFMBw76cHILlPRq+pAczw+9JlRtuRO3E/u9JAAEd576/QWm8y2khr/SuAV7yfNoDMOlGCUEp1AXCq99PNWuulRttprUshs5c+Y6M8NEJI77ev+d3vGfhN7mfnMTAmaK0rAfjnFWcYbHYeavKnPtLWecjv+d0fVs/hUWxxP7vPEL/7y4Ns6/997pPEMtTv/numWwkeB+510O++0Xst97PDGBgTlFJtUDMjVQLAqDJFD7/7G6yeT0tli+3eT4/yPj/FB+5n97G9TwAUmDyO4l8ox8H/AFR673fzVpkhd/Dfj9uDfJ/72QEMjAmQhVs+y7XxKtkT/e5vs/Gc/n/wJ5puRW7D/ew+oeyTH1HzRtmFb5QJxfZxoLWuAPCT99PGANpFaUwUOv/32yUG3+d+dhgD4ySnlDoOwF+9n2oAj5hs2sLv/h4bT11k8lhytxZ+97mf3aGF333LfeJ9o/SVaUuFvFlSYmjhd59/m3FIKfU7AFd7Pz0M4B8Gm7Xwu8/97AAGxknM2zXnDQCNvF+aqbVeb7K5f5OQwzaevtTvftMwhkfO4H52H+4TAngcxDWl1NEAFqIm7rpHa/2jwabczw5jgw+HKaWuhRTorzdts3OS93VTAPwTwCneL30K4I5IjIPqcmo/ExGRs7yTUG+hJtVhCaSzKLkQA2PnXQugb4Se6347GymlPJAyXBd6v/QNgOFaa6uz02K/+w1tvIz/atuDplslj5jv5zBxP7tPMaRzFiD7pNhiW4D7JFHxbzMOKaUaAngb0qkOANYCuMxb8tII97PDmEqRZLyLcZ6FtJQEpNf6IG8NVCv7/O63tvFSmSaPJXfb53ef+9kd9vndt9wnSqlUAL465OWoqU9O8W+f333+bcYBbyv3xZBa5IB0CR2htbb6u9znd5/72QEMjB2mtT5La60icbP5kk9DZi8BqSgwUGv9k8X2Pt/63e9kY/uOJo9NSg7s53BxP7tPKPukPYAU7/0tFrNSFH9sHwfeEyTfZftDqKlcQDGilEqDNPPwNUz6DMAwrfUB80cB4H52HAPjJKKUegrAZO+nP0KC4h02H/6F3/3eQV7nKNQETLttzEaTe3A/u4/tfQKgj8njKP6FchycipoTpC95ghRb3oD1ZdSkKxYCuMBmdzzuZ4cxME4SSqnHAEzxfroLEhR/H8JTrAJwxHv/XKWUUcceH//OPcE6dZG7rAL3s9v4d78aarqV8O9+xX2SWHgcxAHvwvYFAMZ4v/QlgMFa6yLzR9XC/ewwBsZJQCn1N9RUnPgFEhRvDuU5tNbFAHw925sBmGDyWgrATX5fejWkwZKjuJ9d6V+o6UY5WCnV3Wgjb+fBy72fHoasgqcE4f2f/Zn30y5KqeFG23kXe13n96WF0R4bCe/C9hcAXOb90jewt4anGvez8xgYJzil1N0Apno/3Q35I/06zKd7ENIEBAAeVkqdYrDNvaipvrBea23U2YfcjfvZRbxNO3K9nyoALymlWvpv432TzENNQ4+nQ5ihovgxze/+LKVUlv83vYHZMwB8X1+ktWZKTQz4LWy/yvulLZBJqJ/DeDruZwcppqQkLqXURMgfqs99AD638dCPtdaGHXeUUo8AuMv76SEAcyErbZtALh0N8X6vGEB/rfX/Qh85hUop1QJ161B3RE31kc8BvBPw/ZVa65Umz8f97CLe1e0fAujv/dIPkL/tLZAFd9cA6Or93pcAfqe13h/rcZIxpVRnyD7ydwqAUd77awB8FPD917XWnwV8DUqpV1AzI1kEOQ4KIdUJrkJNWbBdAPpqrX+o9w9AQSmlHkJNF9lyALdD1vIE877WusTg+bifHcLAOIEppeYByAnjoedrrVeZPKcC8CQkX9msQsKvAK4wC7oo8pRSnQBsDfFh08yahXA/u493lngRako/GfkUwCUhLKqlGFBKDYCkxITiaq31PIPnagCpQ3954Pf8fAdgtNbazkQIRYBSahWA88J4aGet9TaD5+N+dghTKSgkWtwG4GzIH+33kHzGfZA35XsBdGewFN+4n93Hu6J9MOSNcgmAnQDKIOsGVgKYCJk5YlCcwLTWR7TWV0DKgL0GuXpwBMAeAP+BzFT2YrAU37ifncMZYyIiIiIicMaYiIiIiAgAA2MiIiIiIgAMjImIiIiIADAwJiIiIiICwMCYiIiIiAgAA2MiIiIiIgAMjImIiIiIADAwJiIiIiICwMCYiIiIiAgAA2MiIiIiIgAMjImIiIiIADAwJiIiIiICAPx/bPzbRSLW7rwAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ev_scores = ensembletrainer.eval_uncertainty(\n", + " testloader, \"expected_variance\"\n", + ")[test_ord].squeeze()\n", + "\n", + "fig = plt.figure(figsize=(12,8))\n", + "plt.title(\"Expected variance plot\")\n", + "plt.plot(X_test, ev_scores, color='b', label='expected variance (data uncertainty)')\n", + "#%%\n", + "# Show estimated knowledge uncertainty\n", + "voe_scores = ensembletrainer.eval_uncertainty(\n", + " testloader, \"variance_of_expected\"\n", + ")[test_ord].squeeze()\n", + "\n", + "ood_voe_scores = ensembletrainer.eval_uncertainty(\n", + " oodloader, \"variance_of_expected\")\n", + "plt.plot(X_test, voe_scores, label='variance of expected (knowledge uncertainty)', color='r')\n", + "plt.scatter(X_ood, ood_voe_scores, label='ood variance of expected (knowledge uncertainty)', color='g')\n", + "plt.grid()\n", + "plt.legend(fontsize=15)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ensemble distribution distillation into Prior Network\n", + "\n", + "**We can distill an ensemble into one model, to reduce computational time during inference, while saving predictions quality.**\n", + "\n", + "**If we use usual knowledge distillation: ensemble of normal models into another normal model, then we lose possibility to calculate uncertainty measures. Ensemble distribution distillation is to solve this problem. It allows us to distill an ensemble into Prior Network, saving possibility to calculate uncertainty measures.**\n", + "\n", + "**Prior Network is the distribution over distributions. For example we can use Normal-Wishart distribution in Prior Network for an ensemble of Normal distributions, as you can sample parameters of Normal distribution from Normal-Wishart distribution.**" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "from src.training.ood_trainers import DistributionEnsembleToPriorDistiller\n", + "from src.distributions.prior_distribution import NormalWishartPrior" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0 train loss 608.501 eval loss 2305.013 eval params_rmse 1.077\n", + "Epoch 100 train loss 156.554 eval loss 788.144 eval params_rmse 1.065\n", + "Epoch 149 train loss 135.326 eval loss 676.144 eval params_rmse 1.055\n", + "Distilled NWPrior, final rmse 1.055\n" + ] + } + ], + "source": [ + "loss_params = {\n", + " \"max_temperature\": 1.0,\n", + " \"noise_level\": 3.0\n", + "}\n", + "model_params[\"isPrior\"] = True\n", + "prior_distiller = DistributionEnsembleToPriorDistiller(\n", + " [ensembletrainer.trainers[i].model for i in range(10)],\n", + " loss_params, model_params, SimpleModel,\n", + " optim_params, distribution=NormalWishartPrior, optimizer=Adam\n", + ")\n", + "ptrain_hist, pval_hist, pmetrics_hist = prior_distiller.train(\n", + " trainloader, NUM_EPOCHS, testloader, \n", + " log_per=LOG_PER, verbose=True\n", + ")\n", + "print(\"Distilled NWPrior, final rmse %.3f\" % pmetrics_hist[-1][0])" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model_preds = prior_distiller.get_predicted_params(testloader)\n", + "mean_preds, std_preds = model_preds[0][test_ord].squeeze(), model_preds[1][test_ord].squeeze()\n", + "\n", + "fig = plt.figure(figsize=(12,8))\n", + "plt.plot(X_test, y_test, label=\"real answers\")\n", + "plt.plot(X_test, mean_preds, label='predictions')\n", + "plt.fill_between(X_test, mean_preds - std_preds, mean_preds + std_preds, alpha=0.1)\n", + "plt.grid()\n", + "plt.legend(fontsize=15)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Show data uncertainty\n", + "ev_scores = prior_distiller.eval_uncertainty(\n", + " testloader, \"expected_variance\"\n", + ")[test_ord].squeeze()\n", + "\n", + "fig = plt.figure(figsize=(12,8))\n", + "plt.title(\"Expected variance plot\")\n", + "plt.plot(X_test, ev_scores, color='teal', label='expected variance (data uncertainty)')\n", + "plt.plot(X_test, noise_fn(X_test).pow(2), color='navy', label='noise')\n", + "plt.xlim(-15, 15)\n", + "plt.ylim(0, 1.2)\n", + "plt.grid()\n", + "plt.legend(fontsize=15)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#%%\n", + "# Show knowledge uncertainty\n", + "\n", + "fig = plt.figure(figsize=(12,8))\n", + "voe_scores = prior_distiller.eval_uncertainty(\n", + " testloader, \"variance_of_expected\"\n", + ")[test_ord].squeeze()\n", + "ood_voe_scores = prior_distiller.eval_uncertainty(\n", + " oodloader, \"variance_of_expected\"\n", + ")[test_ord].squeeze()\n", + "plt.plot(X_test, voe_scores, label=\"knowledge uncertainty test\")\n", + "plt.scatter(X_ood, ood_voe_scores, label=\"knowledge uncertainty ood\")\n", + "plt.scatter(X_ood, y_ood, color='g',label='ood points')\n", + "#plt.ylim(0, 2.0)\n", + "plt.grid()\n", + "plt.legend(fontsize=15)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**This notebook:https://github.com/VProv/uncertainty_example**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Find more interesting videos:https://ods.ai/tracks/uncertainty-estimation-in-ml-df2020**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Regression Prior Networks: https://github.com/JanRocketMan/regression-prior-networks**" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}