From af9bf9a7872b9da7630afd59c3c83f31ba93b97b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Rozet?= Date: Tue, 19 Apr 2022 03:03:54 +0200 Subject: [PATCH] =?UTF-8?q?=F0=9F=93=9D=20Create=20Sphinx=20documentation?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CONTRIBUTING.md | 3 + README.md | 24 +- lampe/__init__.py | 11 +- lampe/data.py | 254 ++++++++++------- lampe/masks.py | 139 ++++----- lampe/mcmc.py | 206 -------------- lampe/nn/__init__.py | 513 +++++++++++++++++++++++++++++++++- lampe/nn/flows.py | 40 ++- lampe/nn/losses.py | 298 +++++++------------- lampe/nn/modules.py | 507 --------------------------------- lampe/nn/pipes.py | 147 ---------- lampe/patch.py | 72 +++++ lampe/plots.py | 230 +++++++++++---- lampe/priors.py | 240 +++++++++++----- lampe/simulators/__init__.py | 5 +- lampe/simulators/ees.py | 82 ++---- lampe/simulators/gw.py | 131 +++++---- lampe/simulators/hh.py | 57 ++-- lampe/simulators/slcp.py | 72 ++--- lampe/train.py | 122 -------- lampe/utils.py | 436 ++++++++++++++++++++++++++--- notebooks/01_npe.ipynb | 378 +++++++++++++++++++++++++ notebooks/02_nre.ipynb | 273 ++++++++++++++++++ notebooks/slcp-npe.ipynb | 395 -------------------------- notebooks/slcp-nre.ipynb | 270 ------------------ requirements.txt | 1 + setup.py | 8 +- sphinx/api/data.rst | 4 + sphinx/api/index.rst | 10 + sphinx/api/masks.rst | 4 + sphinx/api/nn/flows.rst | 4 + sphinx/api/nn/index.rst | 11 + sphinx/api/nn/losses.rst | 4 + sphinx/api/plots.rst | 4 + sphinx/api/priors.rst | 4 + sphinx/api/utils.rst | 4 + sphinx/build.sh | 24 ++ sphinx/conf.py | 115 ++++++++ sphinx/docutils.conf | 2 + sphinx/index.rst | 82 ++++++ sphinx/static/banner.svg | 58 ++++ sphinx/static/banner_dark.svg | 58 ++++ sphinx/static/custom.css | 140 ++++++++++ sphinx/static/logo.svg | 7 + sphinx/static/logo_dark.svg | 7 + sphinx/tutorials.rst | 7 + 46 files changed, 3081 insertions(+), 2382 deletions(-) create mode 100644 CONTRIBUTING.md delete mode 100644 lampe/mcmc.py delete mode 100644 lampe/nn/modules.py delete mode 100644 lampe/nn/pipes.py create mode 100644 lampe/patch.py delete mode 100644 lampe/train.py create mode 100644 notebooks/01_npe.ipynb create mode 100644 notebooks/02_nre.ipynb delete mode 100644 notebooks/slcp-npe.ipynb delete mode 100644 notebooks/slcp-nre.ipynb create mode 100644 sphinx/api/data.rst create mode 100644 sphinx/api/index.rst create mode 100644 sphinx/api/masks.rst create mode 100644 sphinx/api/nn/flows.rst create mode 100644 sphinx/api/nn/index.rst create mode 100644 sphinx/api/nn/losses.rst create mode 100644 sphinx/api/plots.rst create mode 100644 sphinx/api/priors.rst create mode 100644 sphinx/api/utils.rst create mode 100644 sphinx/build.sh create mode 100644 sphinx/conf.py create mode 100644 sphinx/docutils.conf create mode 100644 sphinx/index.rst create mode 100644 sphinx/static/banner.svg create mode 100644 sphinx/static/banner_dark.svg create mode 100644 sphinx/static/custom.css create mode 100644 sphinx/static/logo.svg create mode 100644 sphinx/static/logo_dark.svg create mode 100644 sphinx/tutorials.rst diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..4393b7e --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,3 @@ +# Contributing guidelines + +TODO diff --git a/README.md b/README.md index 9c9bff4..50a878b 100644 --- a/README.md +++ b/README.md @@ -1 +1,23 @@ -# Likelihood-free AMortized Posterior Estimation +

+ +# LAMPE + +`lampe` is a simulation-based inference (SBI) package that focuses on amortized estimation of posterior distributions, without relying on explicit likelihood functions; hence the name *Likelihood-free AMortized Posterior Estimation* (LAMPE). The package provides [PyTorch](https://pytorch.org) implementations of modern amortized simulation-based inference algorithms like neural ratio estimation (NRE), neural posterior estimation (NPE) and more. Similar to PyTorch, the philosophy of LAMPE is to avoid obfuscation and expose all components, from network architecture to optimizer, to the user such that they are free to modify or replace anything they like. + +## Installation + +The `lampe` package is available on [PyPI](https://pypi.org/project/lampe), which means it is installable via `pip`. + +``` +pip install lampe +``` + +Alternatively, if you need the latest features, you can install it from the repository. + +``` +pip install git+https://github.com/francois-rozet/lampe +``` + +## Documentation + +The documentation is made with [Sphinx](https://www.sphinx-doc.org) and [Furo](https://github.com/pradyunsg/furo) and is hosted at [francois-rozet.github.io/lampe](https://francois-rozet.github.io/lampe). diff --git a/lampe/__init__.py b/lampe/__init__.py index e367557..e1c2fc9 100644 --- a/lampe/__init__.py +++ b/lampe/__init__.py @@ -1,6 +1,7 @@ -r"""Likelihood-free AMortized Posterior Estimation""" +r"""Likelihood-free AMortized Posterior Estimation (LAMPE)""" -from .data import SimulatorLoader, H5Loader, h5save -from .mcmc import MetropolisHastings, InferenceSampler -from .nn import NRE, NPE, NREPipe, NPEPipe -from .priors import JointNormal, JointUniform +from . import patch +from .data import JointLoader, H5Dataset +from .nn import NRE, NPE +from .nn.losses import NRELoss, NPELoss +from .priors import BoxUniform, DiagNormal diff --git a/lampe/data.py b/lampe/data.py index 37fd395..79475c9 100644 --- a/lampe/data.py +++ b/lampe/data.py @@ -1,21 +1,25 @@ -r"""Datasets and data loaders""" +r"""Datasets and data loaders.""" import h5py import numpy as np import random import torch -import torch.utils.data as data -from numpy.typing import ArrayLike +from bisect import bisect +from numpy import ndarray as Array from pathlib import Path from torch import Tensor from torch.distributions import Distribution +from torch.utils.data import DataLoader, Dataset, IterableDataset from tqdm import tqdm from typing import * -class IterableSimulatorDataset(data.IterableDataset): - r"""Iterable dataset of (theta, x) batches""" +__all__ = ['JointLoader', 'H5Dataset'] + + +class IterableJointDataset(IterableDataset): + r"""Creates an iterable dataset of batched pairs :math:`(\theta, x)`.""" def __init__( self, @@ -44,47 +48,91 @@ def __iter__(self) -> Iterator[Tuple[Tensor, Tensor]]: yield theta, x -class SimulatorLoader(data.DataLoader): - r"""Iterable data loader of (theta, x) batches""" - - def __init__( - self, - prior: Distribution, - simulator: Callable, - batch_size: int = 2**10, # 1024 - batched: bool = False, - numpy: bool = False, - rng: torch.Generator = None, - **kwargs, - ): - dataset = IterableSimulatorDataset( +def JointLoader( + prior: Distribution, + simulator: Callable, + batch_size: int = 2**10, # 1024 + batched: bool = False, + numpy: bool = False, + **kwargs, +) -> DataLoader: + r"""Creates a data loader of batched pairs :math:`(\theta, x)` generated by + a prior distribution :math:`p(\theta)` and a simulator. + + The simlator is a stochastic function taking a set of parameters :math:`\theta` + as input and returning an observation :math:`x` as output, which (implicitely) + defines a likelihood function :math:`p(x | \theta)`. Together with the prior, + they form a joint distribution :math:`p(\theta, x) = p(\theta) p(x | \theta)` + from which the pairs :math:`(\theta, x)` are independently drawn. + + Arguments: + prior: A prior distribution :math:`p(\theta)`. + simulator: A callable simulator. + batch_size: The batch size of the generated pairs. + batched: Whether the simulator accepts batched inputs or not. + numpy: Whether the simulator requires NumPy or PyTorch inputs. + kwargs: Keyword arguments passed to :class:`torch.utils.data.DataLoader`. + + Returns: + An infinite data loader of batched pairs :math:`(\theta, x)`. + + Example: + >>> loader = joint_loader(prior, simulator, numpy=True, num_workers=4) + >>> for theta, x in loader: + ... theta, x = theta.cuda(), x.cuda() + ... something(theta, x) + """ + + return DataLoader( + IterableJointDataset( prior, simulator, batch_shape=(batch_size,) if batched else (), numpy=numpy, - ) - - super().__init__( - dataset, - batch_size=None if batched else batch_size, - worker_init_fn=self.worker_init, - generator=rng, - **kwargs, - ) - - @staticmethod - def worker_init(*args) -> None: - seed = torch.initial_seed() % 2**32 - np.random.seed(seed) - random.seed(seed) - - -class H5Loader(data.Dataset): - r"""Data loader of (theta, x) pairs saved in HDF5 files""" + ), + batch_size=None if batched else batch_size, + **kwargs, + ) + + +class H5Dataset(object): + r"""Creates a dataset of pairs :math:`(\theta, x)` from HDF5 files. + + As a :class:`torch.utils.data.Dataset`, :class:`H5Dataset` implements the methods + :meth:`__len__` and :meth:`__getitem__`. However, as it can be slow to load pairs + from disk one by one when iterating over the dataset, it also implements a custom + :meth:`__iter__` method. This method loads several contiguous chunks of pairs at + once, concatenates them, shuffles the result and, finally, splits it into batches. + This "weak shuffling" procedure greatly improves loading performances, but the + resulting batch elements are not perfectly independent from each others. + + Important: + To take advantage of the custom :meth:`__iter__` method, :class:`H5Dataset` + instances should not be wrapped inside a :class:`torch.utils.data.DataLoader` + when iterating over the dataset. + + Arguments: + files: HDF5 files containing pairs :math:`(\theta, x)`. + batch_size: The size of the batches. + chunk_size: The size of the contiguous chunks. + group_size: The number of chunks loaded at once. + pin_memory: Whether the batches reside in CUDA pinned memory or not. + shuffle: Whether the pairs are shuffled when iterating. + seed: A seed to initialize the internal RNG used for shuffling. + + Example: + >>> dataset = H5Dataset('data.h5', batch_size=256, shuffle=True) + >>> theta, x = dataset[0] + >>> theta + tensor([-0.1215, -1.3641, 0.7233, -1.2150, -1.9263]) + >>> for theta, x in dataset: + ... theta, x = theta.cuda(), x.cuda() + ... something(theta, x) + """ def __init__( self, - *filenames, + *files: Union[str, Path], batch_size: int = 2**10, # 1024 chunk_size: int = 2**12, # 4096 group_size: str = 2**4, # 16 @@ -94,7 +142,8 @@ def __init__( ): super().__init__() - self.fs = list(map(h5py.File, filenames)) + self.files = list(map(h5py.File, files)) + self.stops = np.cumsum([len(f['x']) for f in self.files]) self.batch_size = batch_size self.chunk_size = chunk_size @@ -106,33 +155,33 @@ def __init__( self.rng = np.random.default_rng(seed) def __del__(self) -> None: - for f in self.fs: + for f in self.files: f.close() def __len__(self) -> int: - return sum(len(f['x']) for f in self.fs) + return self.stops[-1] - def __getitem__(self, idx: int) -> Tuple[Tensor, Tensor]: - idx = idx % len(self) + def __getitem__(self, i: int) -> Tuple[Tensor, Tensor]: + i = i % len(self) + j = bisect(self.stops, i) + if j > 0: + i = i - self.stops[j - 1] - for f in self.fs: - if idx < len(f['x']): - break - idx = idx - len(f['x']) + f = self.files[j] if 'theta' in f: - theta = torch.from_numpy(f['theta'][idx]) + theta = torch.from_numpy(f['theta'][i]) else: theta = None - x = torch.from_numpy(f['x'][idx]) + x = torch.from_numpy(f['x'][i]) return theta, x def __iter__(self) -> Iterator[Tuple[Tensor, Tensor]]: chunks = [ (i, j, j + self.chunk_size) - for i, f in enumerate(self.fs) + for i, f in enumerate(self.files) for j in range(0, len(f['x']), self.chunk_size) ] @@ -143,8 +192,8 @@ def __iter__(self) -> Iterator[Tuple[Tensor, Tensor]]: slices = sorted(chunks[l:l+self.group_size]) # Load - theta = np.concatenate([self.fs[i]['theta'][j:k] for i, j, k in slices]) - x = np.concatenate([self.fs[i]['x'][j:k] for i, j, k in slices]) + theta = np.concatenate([self.files[i]['theta'][j:k] for i, j, k in slices]) + x = np.concatenate([self.files[i]['x'][j:k] for i, j, k in slices]) # Shuffle if self.shuffle: @@ -163,45 +212,60 @@ def __iter__(self) -> Iterator[Tuple[Tensor, Tensor]]: x.split(self.batch_size), ) - -def h5save( - iterable: Iterable[Tuple[ArrayLike, ArrayLike]], - filename: str, - size: int, - dtype: type = np.float32, - **kwargs, -) -> None: - r"""Saves (theta, x) batches to an HDF5 file""" - - # File - filename = Path(filename) - filename.parent.mkdir(parents=True, exist_ok=True) - - with h5py.File(filename, 'w') as f: - ## Attributes - for k, v in kwargs.items(): - f.attrs[k] = v - - ## Datasets - theta, x = map(np.asarray, next(iter(iterable))) - theta, x = theta[0], x[0] - - f.create_dataset('theta', (size,) + theta.shape, dtype=dtype) - f.create_dataset('x', (size,) + x.shape, dtype=dtype) - - ## Samples - with tqdm(total=size, unit='sample') as tq: - i = 0 - - for theta, x in iterable: - j = min(i + theta.shape[0], size) - - f['theta'][i:j] = np.asarray(theta)[:j-i] - f['x'][i:j] = np.asarray(x)[:j-i] - - tq.update(j - i) - - if j < size: - i = j - else: - break + @staticmethod + def store( + pairs: Iterable[Tuple[Array, Array]], + file: Union[str, Path], + size: int, + dtype: np.dtype = np.float32, + **meta, + ) -> None: + r"""Creates an HDF5 file containing pairs :math:`(\theta, x)`. + + The sets of parameters :math:`\theta` are stored in a collection named + :py:`'theta'` and the observations in a collection named :py:`'x'`. + + Arguments: + pairs: An iterable over batched pairs :math:`(\theta, x)`. + file: An HDF5 filename to store pairs in. + size: The number of pairs to store. + dtype: The data type to store pairs in. + meta: Metadata to store in the file. + + Example: + >>> loader = JointLoader(prior, simulator, batch_size=16) + >>> H5Dataset.store(loader, 'sim.h5', 4096) + 100%|██████████| 4096/4096 [01:35<00:00, 42.69sample/s] + """ + + # File + file = Path(file) + file.parent.mkdir(parents=True, exist_ok=True) + + with h5py.File(file, 'w-') as f: + ## Attributes + f.attrs.update(meta) + + ## Datasets + theta, x = map(np.asarray, next(iter(pairs))) + theta, x = theta[0], x[0] + + f.create_dataset('theta', (size,) + theta.shape, dtype=dtype) + f.create_dataset('x', (size,) + x.shape, dtype=dtype) + + ## Store + with tqdm(total=size, unit='sample') as tq: + i = 0 + + for theta, x in pairs: + j = min(i + theta.shape[0], size) + + f['theta'][i:j] = np.asarray(theta)[:j-i] + f['x'][i:j] = np.asarray(x)[:j-i] + + tq.update(j - i) + + if j < size: + i = j + else: + break diff --git a/lampe/masks.py b/lampe/masks.py index 245765f..d2c35d4 100644 --- a/lampe/masks.py +++ b/lampe/masks.py @@ -1,96 +1,105 @@ -r"""Masking helpers""" +r"""Masking helpers.""" import numpy as np import torch import torch.nn as nn -from torch import Tensor, BoolTensor, LongTensor -from torch.distributions import Distribution +from torch import Tensor, BoolTensor +from torch.distributions import * from typing import * -class MaskDistribution(Distribution): - r"""Abstract mask distribution""" +def mask2str(b: BoolTensor) -> str: + r"""Represents a binary mask as a string. - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) + Arguments: + b: A binary mask :math:`b`, with shape :math:`(D,)`. - self.dummy = torch.tensor(0.) + Example: + >>> b = torch.tensor([True, True, False, True, False]) + >>> mask2str(b) + '11010' + """ - @property - def device(self) -> torch.device: - return self.dummy.device + return ''.join('1' if bit else '0' for bit in b) -class SelectionMask(Distribution): - r"""Samples uniformly from a selection of masks""" - - def __init__(self, selection: BoolTensor): - super().__init__(event_shape=selection.shape[-1:]) - - self.selection = selection - - def rsample(self, shape: torch.Size = ()) -> BoolTensor: - r""" a ~ p(a) """ - - indices = torch.randint(len(self.selection), shape, device=self.device) - return self.selection[indices] - - -class UniformMask(MaskDistribution): - r"""Samples uniformly among all masks of size `size`""" - - def __init__(self, size: int): - super().__init__(event_shape=(size,)) - - self.size = size - - def rsample(self, shape: torch.Size = ()) -> BoolTensor: - r""" a ~ p(a) """ +def str2mask(string: str) -> BoolTensor: + r"""Parses the string representation of a binary mask into a tensor. - integers = torch.randint(1, 2 ** self.size, shape, device=self.device) - return bit_repr(integers, self.size) + Arguments: + string: A binary mask string representation. + Example: + >>> str2mask('11010') + tensor([True, True, False, True, False]) + """ -class PoissonMask(MaskDistribution): - r"""Samples among all masks of size `size`, - with the number of positive bits following a Poisson distribution""" + return torch.tensor([char == '1' for char in string]) - def __init__(self, size: int, lmbda: float = 1.): - super().__init__(event_shape=(size,)) - self.size = size - self.lmbda = lmbda +class BernoulliMask(Independent): + r"""Creates a distribution :math:`P(b)` over all binary masks :math:`b` in the + hypercube :math:`\{0, 1\}^D` such that each bit :math:`b_i` has a probability + :math:`p` of being positive. - self.rng = np.random.default_rng() + .. math:: P(b) = \prod^D_{i = 1} p^{b_i} (1 - p)^{1 - b_i} - def rsample(self, shape: torch.Size = ()) -> BoolTensor: - r""" a ~ p(a) """ + Arguments: + dim: The hypercube dimensionality :math:`D`. + p: The probability :math:`p` of a bit to be positive. - k = self.rng.poisson(self.lmbda, shape) - k = torch.from_numpy(k).to(self.device) + Example: + >>> d = BernoulliMask(5, 0.5) + >>> d.sample() + tensor([True, True, False, True, False]) + """ - mask = torch.arange(self.size, device=self.device) - mask = mask <= k[..., None] + has_rsample = False - order = torch.rand(mask.shape, device=self.device) - order = torch.argsort(order, dim=-1) + def __init__(self, dim: int, p: float = 0.5): + super().__init__(Bernoulli(torch.ones(dim) * p), 1) - return torch.gather(mask, dim=-1, index=order) + def log_prob(b: BoolTensor) -> Tensor: + return super().log_prob(b.float()) + def sample(self, shape: torch.Size = ()) -> BoolTensor: + return super().sample(shape).bool() -def str2mask(string: str) -> BoolTensor: - return torch.tensor([char == '1' for char in string]) +class SelectionMask(Distribution): + r"""Creates a mask distribution :math:`P(b)`, uniform over a selection of + binary masks :math:`\mathcal{B} \subseteq \{0, 1\}^D`. + + .. math:: P(b) = \begin{cases} + \frac{1}{|\mathcal{B}|} & \text{if } b \in \mathcal{B} \\ + 0 & \text{otherwise} + \end{cases} + + Arguments: + selection: A binary mask selection :math:`\mathcal{B}`. + + Example: + >>> selection = torch.tensor([ + ... [True, False, False], + ... [False, True, False], + ... [False, False, True], + ... ]) + >>> d = SelectionMask(selection) + >>> d.sample() + tensor([False, True, False]) + """ -def mask2str(mask: BoolTensor) -> str: - return ''.join('1' if bit else '0' for bit in mask) - + def __init__(self, selection: BoolTensor): + super().__init__(event_shape=selection.shape[-1:]) -def bit_repr(integers: LongTensor, bits: int) -> BoolTensor: - r"""Bit representation of integers""" + self.selection = selection - powers = 2 ** torch.arange(bits).to(integers) - bits = integers[..., None].bitwise_and(powers) != 0 + def log_prob(b: BoolTensor) -> Tensor: + match = torch.all(b[..., None, :] == self.selection, dim=-1) + prob = match.float().mean(dim=-1) + return prob.log() - return bits + def sample(self, shape: torch.Size = ()) -> BoolTensor: + index = torch.randint(len(self.selection), shape, device=self.device) + return self.selection[index] diff --git a/lampe/mcmc.py b/lampe/mcmc.py deleted file mode 100644 index 3470457..0000000 --- a/lampe/mcmc.py +++ /dev/null @@ -1,206 +0,0 @@ -r"""Markov chain Monte Carlo (MCMC) samplers""" - -import torch -import torch.nn as nn -import torch.nn.functional as F - -from abc import ABC, abstractmethod -from itertools import islice -from torch import Tensor -from typing import * - -from .priors import Distribution, JointNormal - - -class MCMC(ABC): - r"""Abstract Markov chain Monte Carlo (MCMC) algorithm""" - - def __init__( - self, - x_0: Tensor, # x_0 - f: Callable = None, # f(x) - log_f: Callable = None, # log f(x) - ): - super().__init__() - - self.x_0 = x_0 - - assert f is not None or log_f is not None, \ - "either 'f' or 'log_f' must be provided" - - if f is None: - self.f = lambda x: log_f(x).exp() - self.log_f = log_f - else: - self.f = f - self.log_f = lambda x: f(x).log() - - @abstractmethod - def __iter__(self) -> Iterator[Tensor]: - r""" x_i ~ p(x) ∝ f(x) """ - pass - - @torch.no_grad() - def __call__( - self, - n: int, - burn: int = 0, - step: int = 1, - groupby: int = 1, - ) -> Iterator[Tensor]: - r""" (x_1, ..., x_n) ~ p(x) """ - - seq = islice(self, burn, burn + n * step, step) - - if groupby > 1: - buff = [] - - for x in seq: - buff.append(x) - - if len(buff) == groupby: - yield torch.cat(buff) - buff.clear() - - if buff: - yield torch.cat(buff) - else: - yield from seq - - @torch.no_grad() - def grid( - self, - bins: Union[int, List[int]], - bounds: Tuple[Tensor, Tensor], - ) -> Tensor: - r"""Evaluates f(x) for all x in grid""" - - x = self.x_0 - - # Shape - D = x.shape[-1] - B = x.numel() // D - - if type(bins) is int: - bins = [bins] * D - - # Create grid - domains = [] - - for l, u, b in zip(bounds[0], bounds[1], bins): - step = (u - l) / b - dom = torch.linspace(l, u - step, b).to(step) + step / 2. - domains.append(dom) - - grid = torch.stack(torch.meshgrid(*domains, indexing='ij'), dim=-1) - grid = grid.view(-1, D).to(x) - - # Evaluate f(x) on grid - f = [] - - for x in grid.split(B): - b = len(x) - - if b < B: - x = F.pad(x, (0, 0, 0, B - b)) - y = self.f(x)[:b] - else: - y = self.f(x) - - f.append(y) - - return torch.cat(f).view(bins) - - -class MetropolisHastings(MCMC): - r"""Metropolis-Hastings algorithm - - Wikipedia: - https://en.wikipedia.org/wiki/Metropolis%E2%80%93Hastings_algorithm - """ - - def __init__(self, *args, sigma: Tensor = 1., **kwargs): - super().__init__(*args, **kwargs) - - self.sigma = sigma - - def q(self, x: Tensor) -> Distribution: - r"""Gaussian transition centered around x""" - - return JointNormal(x, torch.ones_like(x) * self.sigma) - - @property - def symmetric(self) -> bool: - r"""Whether q(x | y) is equal to q(y | x)""" - - return True - - def __iter__(self) -> Iterator[Tensor]: - r""" x_i ~ p(x) ∝ f(x) """ - - x = self.x_0 - - # log f(x) - log_f_x = self.log_f(x) - - while True: - # y ~ q(y | x) - y = self.q(x).sample() - - # log f(y) - log_f_y = self.log_f(y) - - # f(y) q(x | y) - # a = ---- * -------- - # f(x) q(y | x) - log_a = log_f_y - log_f_x - - if not self.symmetric: - log_a = log_a + self.q(y).log_prob(x) - self.q(x).log_prob(y) - - a = log_a.exp() - - # u in [0; 1] - u = torch.rand(a.shape).to(a) - - # if u < a, x <- y - # else x <- x - mask = u < a - - x = torch.where(mask.unsqueeze(-1), y, x) - log_f_x = torch.where(mask, log_f_y, log_f_x) - - yield x - - -class InferenceSampler(MetropolisHastings): - r"""Inference MCMC sampler""" - - def __init__( - self, - x: Tensor, # x - prior: Distribution, # p(theta) - likelihood: Callable = None, # log p(x | theta) - posterior: Callable = None, # log p(theta | x) - ratio: Callable = None, # log p(theta | x) - log p(theta) - batch_size: int = 2**10, # 1024 - **kwargs, - ): - theta_0 = prior.sample((batch_size,)) - x = x.expand((batch_size,) + x.shape) - - assert likelihood is not None or posterior is not None or ratio is not None, \ - "either 'likelihood', 'posterior' or 'ratio' must be provided" - - if likelihood is not None: - log_f = lambda theta: likelihood(theta, x) + prior.log_prob(theta) - elif posterior is not None: - log_f = lambda theta: posterior(theta, x) - elif ratio is not None: - log_f = lambda theta: ratio(theta, x) + prior.log_prob(theta) - - super().__init__( - x_0=theta_0, - log_f=log_f, - **kwargs, - ) diff --git a/lampe/nn/__init__.py b/lampe/nn/__init__.py index 51e2d09..ae30aa9 100644 --- a/lampe/nn/__init__.py +++ b/lampe/nn/__init__.py @@ -1,6 +1,511 @@ -r"""Neural Network (NN) architectures""" +r"""Neural networks, layers and modules. + +.. admonition:: TODO + + * Finish documentation (NPE, AMNPE). + * Find references. +""" + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from torch import Tensor, BoolTensor +from torch.distributions import Distribution +from typing import * from .flows import MAF -from .losses import MSELoss, NLLLoss, BCEWithLogitsLoss -from .modules import MLP, ResMLP, NRE, AMNRE, NPE, AMNPE -from .pipes import NREPipe, AMNREPipe, NPEPipe, AMNPEPipe +from ..utils import broadcast + + +__all__ = [ + 'MLP', 'ResBlock', 'ResMLP', + 'NRE', 'AMNRE', 'NPE', 'AMNPE', +] + + +class Affine(nn.Module): + r"""Creates an element-wise affine layer. + + Arguments: + shift: The shift term. + scale: The scale factor. + """ + + def __init__(self, shift: Tensor, scale: Tensor): + super().__init__() + + self.register_buffer('shift', shift) + self.register_buffer('scale', scale) + + def forward(self, x: Tensor) -> Tensor: + return x * self.scale + self.shift + + def extra_repr(self) -> str: + return '\n'.join([ + f'(shift): {self.shift.cpu()}', + f'(scale): {self.scale.cpu()}', + ]) + + +class BatchNorm0d(nn.BatchNorm1d): + r"""Creates a batch normalization (BatchNorm) layer for scalars. + + References: + Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift + (Ioffe et al., 2015) + https://arxiv.org/abs/1502.03167 + + Arguments: + args: Positional arguments passed to :class:`torch.nn.BatchNorm1d`. + kwargs: Keyword arguments passed to :class:`torch.nn.BatchNorm1d`. + """ + + def forward(self, x: Tensor) -> Tensor: + shape = x.shape + + x = x.reshape(-1, shape[-1]) + x = super().forward(x) + x = x.reshape(shape) + + return x + + +class MLP(nn.Sequential): + r"""Creates a multi-layer perceptron (MLP). + + Also known as fully connected feedforward network, an MLP is a sequence of + non-linear parametric transformations + + .. math:: h_{i + 1} = a_{i + 1}(W_{i + 1}^T h_i + b_{i + 1}), + + over feature vectors :math:`h_i`, with the input and ouput feature vectors + :math:`x = h_0` and :math:`y = h_L`, respectively. The non-linear functions + :math:`a_i` are called activation functions. The trainable parameters of an MLP + are its weights and biases :math:`\phi = \{W_i, b_i | i = 1, \dots, L\}`. + + Wikipedia: + https://en.wikipedia.org/wiki/Feedforward_neural_network + + Arguments: + in_features: The number of input features. + out_features: The number of output features. + hidden_features: The numbers of hidden features. + activation: The activation layer type. + batchnorm: Whether to use batch normalization or not. + dropout: The dropout rate. + kwargs: Keyword arguments passed to :class:`torch.nn.Linear`. + + Example: + >>> net = MLP(64, 1, [32, 16], activation='ELU') + >>> net + MLP( + (0): Linear(in_features=64, out_features=32, bias=True) + (1): ELU(alpha=1.0) + (2): Linear(in_features=32, out_features=16, bias=True) + (3): ELU(alpha=1.0) + (4): Linear(in_features=16, out_features=1, bias=True) + ) + """ + + def __init__( + self, + in_features: int, + out_features: int, + hidden_features: List[int] = [64, 64], + activation: str = 'ReLU', + batchnorm: bool = False, + dropout: float = 0., + **kwargs, + ): + activation = { + 'ReLU': nn.ReLU, + 'ELU': nn.ELU, + 'CELU': nn.CELU, + 'SELU': nn.SELU, + 'GELU': nn.GELU, + }.get(activation, nn.ReLU) + + batchnorm = BatchNorm0d if batchnorm else lambda _: None + dropout = nn.Dropout(dropout) if dropout > 0 else None + + layers = [] + + for before, after in zip( + [in_features] + hidden_features, + hidden_features + [out_features], + ): + layers.extend([ + nn.Linear(before, after, **kwargs), + batchnorm(after), + activation(), + dropout, + ]) + + layers = layers[:-3] + layers = filter(lambda l: l is not None, layers) + + super().__init__(*layers) + + self.in_features = in_features + self.out_features = out_features + + +class ResBlock(MLP): + r"""Creates a residual block. + + A residual block is a function of the type + + .. math:: y = x + f(x), + + where :math:`f` is a non-linear parametric transformation. An MLP with a + constant number of features in hidden layers is commonly used as :math:`f`. + + Arguments: + features: The input, output and hidden features. + hidden_layers: The number of hidden layers. + kwargs: Keyword arguments passed to :class:`MLP`. + + Example: + >>> net = ResBlock(32, hidden_layers=3, activation='ELU') + >>> net + ResBlock( + (0): Linear(in_features=32, out_features=32, bias=True) + (1): ELU(alpha=1.0) + (2): Linear(in_features=32, out_features=32, bias=True) + (3): ELU(alpha=1.0) + (4): Linear(in_features=32, out_features=32, bias=True) + (5): ELU(alpha=1.0) + (6): Linear(in_features=32, out_features=32, bias=True) + ) + """ + + def __init__(self, features: int, hidden_layers: int = 2, **kwargs): + super().__init__( + features, + features, + [features] * hidden_layers, + **kwargs, + ) + + def forward(self, x: Tensor) -> Tensor: + return x + super().forward(x) + + +class ResMLP(nn.Sequential): + r"""Creates a residual multi-layer perceptron (ResMLP). + + Like the regular MLP, the ResMLP is a sequence of non-linear parametric + transformations. However, it uses residual blocks as transformations, which + reduces the vanishing of gradients and allows for deeper networks. + + Arguments: + in_features: The number of input features. + out_features: The number of output features. + hidden_features: The numbers of hidden features. + kwargs: Keyword arguments passed to :class:`ResBlock`. + + Example: + >>> net = ResMLP(64, 1, [32, 16], activation='ELU') + >>> net + ResMLP( + (0): Linear(in_features=64, out_features=32, bias=True) + (1): ResBlock( + (0): Linear(in_features=32, out_features=32, bias=True) + (1): ELU(alpha=1.0) + (2): Linear(in_features=32, out_features=32, bias=True) + (3): ELU(alpha=1.0) + (4): Linear(in_features=32, out_features=32, bias=True) + ) + (2): Linear(in_features=32, out_features=16, bias=True) + (3): ResBlock( + (0): Linear(in_features=16, out_features=16, bias=True) + (1): ELU(alpha=1.0) + (2): Linear(in_features=16, out_features=16, bias=True) + (3): ELU(alpha=1.0) + (4): Linear(in_features=16, out_features=16, bias=True) + ) + (4): Linear(in_features=16, out_features=1, bias=True) + ) + """ + + def __init__( + self, + in_features: int, + out_features: int, + hidden_features: List[int] = [64, 64], + **kwargs, + ): + blocks = [] + + for before, after in zip( + [in_features] + hidden_features, + hidden_features + [out_features], + ): + if after != before: + blocks.append(nn.Linear(before, after)) + + blocks.append(ResBlock(after, **kwargs)) + + blocks = blocks[:-1] + + super().__init__(*blocks) + + self.in_features = in_features + self.out_features = out_features + + +class NRE(nn.Module): + r"""Creates a neural ratio estimation (NRE) classifier network. + + The principle of neural ratio estimation is to train a classifier network + :math:`d_\phi(\theta, x)` to discriminate between pairs :math:`(\theta, x)` + equally sampled from the joint distribution :math:`p(\theta, x)` and the + product of the marginals :math:`p(\theta)p(x)`. Formally, the optimization + problem is + + .. math:: \arg \min_\phi + \mathbb{E}_{p(\theta, x)} \big[ \ell(d_\phi(\theta, x)) \big] + + \mathbb{E}_{p(\theta)p(x)} \big[ \ell(1 - d_\phi(\theta, x)) \big] + + where :math:`\ell(p) = - \log p` is the negative log-likelihood. + For this task, the decision function modeling the Bayes optimal classifier is + + .. math:: d(\theta, x) + = \frac{p(\theta, x)}{p(\theta, x) + p(\theta) p(x)} + + thereby defining the likelihood-to-evidence (LTE) ratio + + .. math:: r(\theta, x) + = \frac{d(\theta, x)}{1 - d(\theta, x)} + = \frac{p(\theta, x)}{p(\theta) p(x)} + = \frac{p(x | \theta)}{p(x)} + = \frac{p(\theta | x)}{p(\theta)} . + + To prevent numerical stability issues when :math:`d_\phi(\theta, x) \to 0`, + the neural network returns the logit of the class prediction + :math:`\text{logit}(d_\phi(\theta, x)) = \log r_\phi(\theta, x)`. + + References: + Approximating Likelihood Ratios with Calibrated Discriminative Classifiers + (Cranmer et al., 2015) + https://arxiv.org/abs/1506.02169 + + Likelihood-free MCMC with Amortized Approximate Ratio Estimators + (Hermans et al., 2019) + https://arxiv.org/abs/1903.04057 + + Arguments: + theta_dim: The dimensionality :math:`D` of the parameter space. + x_dim: The dimensionality :math:`L` of the observation space. + moments: The parameters moments :math:`\mu` and :math:`\sigma` for standardization. + const: The network constructor (e.g. :class:`MLP` or :class:`ResMLP`). + kwargs: Keyword arguments passed to the constructor. + """ + + def __init__( + self, + theta_dim: int, + x_dim: int, + moments: Tuple[Tensor, Tensor] = None, + const: Callable[[int, int], nn.Module] = MLP, + **kwargs, + ): + super().__init__() + + if moments is not None: + mu, sigma = moments + + self.standardize = nn.Identity() if moments is None else Affine(-mu / sigma, 1 / sigma) + + self.net = const(theta_dim + x_dim, 1, **kwargs) + + def forward(self, theta: Tensor, x: Tensor) -> Tensor: + r""" + Arguments: + theta: The parameters :math:`\theta`, with shape :math:`(*, D)`. + x: The observation :math:`x`, with shape :math:`(*, L)`. + + Returns: + The log-ratio :math:`\log r_\phi(\theta, x)`, with shape :math:`(*,)`. + """ + + theta = self.standardize(theta) + theta, x = broadcast(theta, x, ignore=1) + + return self.net(torch.cat((theta, x), dim=-1)).squeeze(-1) + + +class AMNRE(NRE): + r"""Creates an arbitrary marginal neural ratio estimation (AMNRE) classifier + network. + + The principle of AMNRE is to introduce, as input to the classifier, a binary mask + :math:`b \in \{0, 1\}^D` indicating a subset of parameters :math:`\theta_b = + (\theta_i: b_i = 1)` of interest. Intuitively, this allows the classifier to + distinguish subspaces and to learn a different ratio for each of them. Formally, + the classifer network takes the form :math:`d_\phi(\theta_b, x, b)` and the + optimization problem becomes + + .. math:: \arg \min_\phi + \mathbb{E}_{p(\theta, x) P(b)} \big[ \ell(d_\phi(\theta_b, x, b)) \big] + + \mathbb{E}_{p(\theta)p(x) P(b)} \big[ \ell(1 - d_\phi(\theta_b, x, b)) \big], + + where :math:`P(b)` is a binary mask distribution. In this context, the Bayes + optimal classifier is + + .. math:: d(\theta_b, x, b) + = \frac{p(\theta_b, x)}{p(\theta_b, x) + p(\theta_b) p(x)} + = \frac{r(\theta_b, x)}{1 + r(\theta_b, x)} . + + Therefore, a classifier network trained for AMNRE gives access to an estimator + :math:`\log r_\phi(\theta_b, x, b)` of all marginal LTE log-ratios + :math:`\log r(\theta_b, x)`. + + References: + Arbitrary Marginal Neural Ratio Estimation for Simulation-based Inference + (Rozet et al., 2021) + https://arxiv.org/abs/2110.00449 + + Arguments: + theta_dim: The dimensionality :math:`D` of the parameter space. + args: Positional arguments passed to :class:`NRE`. + kwargs: Keyword arguments passed to :class:`NRE`. + """ + + def __init__( + self, + theta_dim: int, + *args, + **kwargs, + ): + super().__init__(theta_dim * 2, *args, **kwargs) + + def forward(self, theta: Tensor, x: Tensor, b: BoolTensor) -> Tensor: + r""" + Arguments: + theta: The parameters :math:`\theta`, with shape :math:`(*, D)`, or + a subset :math:`\theta_b`, with shape :math:`(*, |b|)`. + x: The observation :math:`x`, with shape :math:`(*, L)`. + b: A binary mask :math:`b`, with shape :math:`(*, D)`. + + Returns: + The log-ratio :math:`\log r_\phi(\theta_b, x, b)`, with shape :math:`(*,)`. + """ + + zeros = theta.new_zeros(theta.shape[:-1] + b.shape[-1:]) + + if b.dim() == 1 and theta.shape[-1] < b.numel(): + theta = zeros.masked_scatter(b, theta) + else: + theta = torch.where(b, theta, zeros) + + theta = self.standardize(theta) * b + theta, x, b = broadcast(theta, x, b * 2. - 1., ignore=1) + + return self.net(torch.cat((theta, x, b), dim=-1)).squeeze(-1) + + +class NPE(nn.Module): + r"""Creates a neural posterior estimation (NPE) normalizing flow. + + TODO + + Arguments: + theta_dim: The dimensionality :math:`D` of the parameter space. + x_dim: The dimensionality :math:`L` of the observation space. + moments: The parameters moments :math:`\mu` and :math:`\sigma` for standardization. + kwargs: Keyword arguments passed to :class:`flows.MAF`. + """ + + def __init__( + self, + theta_dim: int, + x_dim: int, + moments: Tuple[Tensor, Tensor] = None, + **kwargs, + ): + super().__init__() + + self.flow = MAF(theta_dim, x_dim, moments=moments, **kwargs) + + def forward(self, theta: Tensor, x: Tensor) -> Tensor: + r""" + Arguments: + theta: The parameters :math:`\theta`, with shape :math:`(*, D)`. + x: The observation :math:`x`, with shape :math:`(*, L)`. + + Returns: + The log-density :math:`\log p_\phi(\theta | x)`, with shape :math:`(*,)`. + """ + + theta, x = broadcast(theta, x, ignore=1) + + return self.flow.log_prob(theta, x) + + def sample(self, x: Tensor, shape: torch.Size = ()) -> Tensor: + r""" + Arguments: + x: The observation :math:`x`, with shape :math:`(*, L)`. + shape: TODO + + Returns: + The samples :math:`\theta \sim p_\phi(\theta | x)`, + with shape :math:`(*, S, D)`. + """ + + return self.flow.sample(x, shape) + + +class AMNPE(NPE): + r"""Creates an arbitrary marginal neural posterior estimation (AMNPE) + normalizing flow. + + TODO + + Arguments: + theta_dim: The dimensionality :math:`D` of the parameter space. + x_dim: The dimensionality :math:`L` of the observation space. + args: Positional arguments passed to :class:`NPE`. + kwargs: Keyword arguments passed to :class:`NPE`. + """ + + def __init__( + self, + theta_dim: int, + x_dim: int, + *args, + **kwargs, + ): + super().__init__(theta_dim, x_dim + theta_dim, *args, **kwargs) + + def forward(self, theta: Tensor, x: Tensor, b: BoolTensor) -> Tensor: + r""" + Arguments: + theta: The parameters :math:`\theta`, with shape :math:`(*, D)`. + x: The observation :math:`x`, with shape :math:`(*, L)`. + b: A binary mask :math:`b`, with shape :math:`(*, D)`. + + Returns: + The log-density :math:`\log p_\phi(\theta | x, b)`, with shape :math:`(*,)`. + """ + + theta, x, b = broadcast(theta, x, b * 2. - 1., ignore=1) + + return self.flow.log_prob(theta, torch.cat((x, b), dim=-1)) + + def sample(self, x: Tensor, b: BoolTensor, shape: torch.Size = ()) -> Tensor: + r""" + Arguments: + x: The observation :math:`x`, with shape :math:`(*, L)`. + b: A binary mask :math:`b`, with shape :math:`(D,)`. + shape: TODO + + Returns: + The samples :math:`\theta_b \sim p_\phi(\theta_b | x, b)`, + with shape :math:`(*, S, D)`. + """ + + x, b = broadcast(x, b * 2. - 1., ignore=1) + + return self.flow.sample(torch.cat((x, b), dim=-1), shape)[..., b] diff --git a/lampe/nn/flows.py b/lampe/nn/flows.py index 8f617f4..985d76e 100644 --- a/lampe/nn/flows.py +++ b/lampe/nn/flows.py @@ -1,4 +1,11 @@ -r"""Flows and parametric distributions""" +r"""Flows and parametric distributions. + +.. admonition:: TODO + + * Finish documentation. + * Drop :mod:`nflows`. + * Find references. +""" import nflows.distributions as D import nflows.transforms as T @@ -12,13 +19,13 @@ class NormalizingFlow(Flow): - r"""Normalizing Flow + r"""Creates a normalizing flow :math:`p_\phi(x | y)`. - (x, y) -> log p(x | y) + TODO - Args: - base: The base distribution. - transforms: A list of (learnable) conditional transforms. + Arguments: + base: A base distribution. + transforms: A list of parametric conditional transforms. """ def __init__(self, base: D.Distribution, transforms: List[T.Transform]): @@ -28,7 +35,7 @@ def __init__(self, base: D.Distribution, transforms: List[T.Transform]): ) def log_prob(self, x: Tensor, y: Tensor) -> Tensor: - r""" log p(x | y) """ + r"""Returns the log-density :math:`\log p_\phi(x | y)`.""" return super().log_prob( x.reshape(-1, x.shape[-1]), @@ -40,7 +47,7 @@ def sample(self, y: Tensor, shape: torch.Size = ()) -> Tensor: return self.rsample(y, shape) def rsample(self, y: Tensor, shape: torch.Size = ()) -> Tensor: - r""" x ~ p(x | y) """ + r"""Samples from the conditional distribution :math:`p_\phi(x | y)`.""" size = torch.Size(shape).numel() @@ -51,19 +58,22 @@ def rsample(self, y: Tensor, shape: torch.Size = ()) -> Tensor: class MAF(NormalizingFlow): - r"""Masked Autoregressive Flow (MAF) + r"""Creates a masked autoregressive flow (MAF). + + TODO - Args: + References: + Masked Autoregressive Flow for Density Estimation + (Papamakarios et al., 2017) + https://arxiv.org/abs/1705.07057 + + Arguments: x_size: The input size. y_size: The context size. arch: The flow architecture. num_transforms: The number of transforms. moments: The input moments (mu, sigma) for standardization. - - References: - [1] Masked Autoregressive Flow for Density Estimation - (Papamakarios et al., 2017) - https://arxiv.org/abs/1705.07057 + kwargs: Keyword arguments passed to the transform. """ def __init__( diff --git a/lampe/nn/losses.py b/lampe/nn/losses.py index d9fa91b..9e9ccc9 100644 --- a/lampe/nn/losses.py +++ b/lampe/nn/losses.py @@ -1,251 +1,169 @@ -r"""Losses and criteria""" +r"""Training losses and routines.""" import torch import torch.nn as nn import torch.nn.functional as F -from torch import Tensor, BoolTensor +from torch import Tensor +from torch.distributions import Distribution from typing import * -def reduce(x: Tensor, reduction: str) -> Tensor: - if reduction == 'sum': - x = x.sum() - elif reduction == 'mean': - x = x.mean() - elif reduction == 'batchmean': - x = x.sum() / x.size(0) +class NRELoss(nn.Module): + r"""Creates a module that calculates the loss :math:`l` of a NRE classifier + :math:`d_\phi`. Given a batch of :math:`N` pairs :math:`\{ (\theta_i, x_i) \}`, + the module returns - return x + .. math:: l = \frac{1}{N} \sum_{i = 1}^N + \ell(d_\phi(\theta_i, x_i)) + \ell(1 - d_\phi(\theta_{i+1}, x_i)) + where :math:`\ell(p) = - \log p` is the negative log-likelihood. -class MSELoss(nn.Module): - r"""Mean Squared Error (MSE) loss""" + Arguments: + estimator: A classifier network :math:`d_\phi(\theta, x)`. + """ - def __init__(self, reduction: str = 'batchmean'): + def __init__(self, estimator: nn.Module): super().__init__() - self.reduction = reduction - - def forward( - self, - input: Tensor, - target: Tensor, - weight: Tensor = None, - ) -> Tensor: - error = F.mse_loss(input, target.detach(), reduction='none') + self.estimator = estimator - if weight is not None: - error = error * weight + def forward(self, theta: Tensor, x: Tensor) -> Tensor: + r""" + Arguments: + theta: The parameters :math:`\theta`, with shape :math:`(N, D)`. + x: The observation :math:`x`, with shape :math:`(N, L)`. - return reduce(error, self.reduction) + Returns: + The scalar loss :math:`l`. + """ + theta_prime = torch.roll(theta, 1, dims=0) -class RRLoss(MSELoss): - r"""Ratio Regression (RR) loss + log_r, log_r_prime = self.estimator( + torch.stack((theta, theta_prime)), + torch.stack((x, x)), + ) - (r - r*)^2 - """ + l1 = -F.logsigmoid(log_r).mean() + l0 = -F.logsigmoid(-log_r_prime).mean() - def forward( - self, - ratio: Tensor, # log r - target: Tensor, # log r* - weight: Tensor = None, - ) -> Tensor: - ratio, target = ratio.exp(), target.exp() + return l1 + l0 - return super().forward(ratio, target, weight) +class AMNRELoss(nn.Module): + r"""Creates a module that calculates the loss :math:`l` of a AMNRE classifier + :math:`d_\phi`. Given a batch of :math:`N` pairs :math:`\{ (\theta_i, x_i) \}`, + the module returns -class SRLoss(MSELoss): - r"""Score Regression (SR) loss + .. math:: l = \frac{1}{N} \sum_{i = 1}^N + \ell(d_\phi(\theta_i \odot b_i, x_i, b_i)) + + \ell(1 - d_\phi(\theta_{i+1} \odot b_i, x_i, b_i)) - ||grad log r - grad log r*||^2 - """ + where the binary masks :math:`b_i` are sampled from a distribution :math:`P(b)`. - @staticmethod - def score( - theta: Tensor, # theta - ratio: Tensor, # log r - ) -> Tensor: - return torch.autograd.grad( # grad log r - ratio, theta, - torch.ones_like(ratio), - create_graph=True, - )[0] - - def forward( - self, - theta: Tensor, # theta - ratio: Tensor, # log r - target: torch.Tensor, # log r* - weight: Tensor = None, - ) -> torch.Tensor: - score = self.score(theta, ratio) - target = self.score(theta, target) - - return super().forward(score, target, weight) - - -class NLLLoss(nn.Module): - r"""Negative Log-Likelihood (NLL) loss - - - log x + Arguments: + estimator: A classifier network :math:`d_\phi(\theta, x, b)`. + mask_dist: A binary mask distribution :math:`P(b)`. """ - def __init__(self, reduction: str = 'batchmean'): + def __init__(self, estimator: nn.Module, mask_dist: Distribution): super().__init__() - self.reduction = reduction + self.estimator = estimator + self.mask_dist = mask_dist - def forward( - self, - log_prob: Tensor, # log p - weight: Tensor = None, - ) -> Tensor: - nll = -log_prob + def forward(self, theta: Tensor, x: Tensor) -> Tensor: + r""" + Arguments: + theta: The parameters :math:`\theta`, with shape :math:`(N, D)`. + x: The observation :math:`x`, with shape :math:`(N, L)`. - if weight is not None: - nll = nll * weight + Returns: + The scalar loss :math:`l`. + """ - return reduce(nll, self.reduction) + b = self.mask_dist.sample(theta.shape[:-1]) + theta_prime = torch.roll(theta, 1, dims=0) + log_r, log_r_prime = self.estimator( + torch.stack((theta, theta_prime)), + torch.stack((x, x)), + b, + ) -class NLLWithLogitsLoss(nn.Module): - r"""Negative Log-Likelihood (NLL) with logits - - - log d(x) - """ - - def forward(self, logit: Tensor) -> Tensor: - ld = F.logsigmoid(logit) # log d(x) - return -ld + l1 = -F.logsigmoid(log_r).mean() + l0 = -F.logsigmoid(-log_r_prime).mean() + return l1 + l0 -class FocalWithLogitsLoss(nn.Module): - r"""Focal Loss (FL) with logits - - (1 - d(x))^gamma log d(x) +class NPELoss(nn.Module): + r"""Creates a module that calculates the loss :math:`l` of a NPE normalizing flow + :math:`p_\phi`. Given a batch of :math:`N` pairs :math:`\{ (\theta_i, x_i) \}`, + the module returns - References: - [1] Focal Loss for Dense Object Detection - (Lin et al., 2017) - https://arxiv.org/abs/1708.02002 + .. math:: l = \frac{1}{N} \sum_{i = 1}^N -\log p_\phi(\theta_i | x_i) . - [2] Calibrating Deep Neural Networks using Focal Loss - (Mukhoti et al., 2020) - https://arxiv.org/abs/2002.09437 + Arguments: + estimator: A normalizing flow :math:`p_\phi(\theta | x)`. """ - def __init__(self, gamma: float = 2.): + def __init__(self, estimator: nn.Module): super().__init__() - self.gamma = gamma - - def forward(self, logit: Tensor) -> Tensor: - ld = F.logsigmoid(logit) # log d(x) - return -(1 - ld.exp()) ** self.gamma * ld - - -class PeripheralWithLogitsLoss(FocalWithLogitsLoss): - r"""Peripheral Loss (PL) with logits - - - (1 - d(x)^gamma) log d(x) - - References: - [1] Arbitrary Marginal Neural Ratio Estimation for Likelihood-free Inference - (Rozet et al., 2021) - https://matheo.uliege.be/handle/2268.2/12993 - """ - - def forward(self, logit: Tensor) -> Tensor: - ld = F.logsigmoid(logit) # log d(x) - return -(1 - (ld * self.gamma).exp()) * ld - + self.estimator = estimator -class QSWithLogitsLoss(nn.Module): - r"""Quadratic Score (QS) with logits + def forward(self, theta: Tensor, x: Tensor) -> Tensor: + r""" + Arguments: + theta: The parameters :math:`\theta`, with shape :math:`(N, D)`. + x: The observation :math:`x`, with shape :math:`(N, L)`. - (1 - d(x))^2 - - References: - https://en.wikipedia.org/wiki/Scoring_rule - """ + Returns: + The scalar loss :math:`l`. + """ - def forward(self, logit: Tensor, weight: Tensor = None) -> Tensor: - d = F.sigmoid(logit) # d(x) - return (1 - d) ** 2 + log_p = self.estimator(theta, x) + return -log_p.mean() -SCORES = { - 'NLL': NLLWithLogitsLoss, - 'FL': FocalWithLogitsLoss, - 'PL': PeripheralWithLogitsLoss, - 'QS': QSWithLogitsLoss, -} +class AMNPELoss(nn.Module): + r"""Creates a module that calculates the loss :math:`l` of an AMNPE normalizing flow + :math:`p_\phi`. Given a batch of :math:`N` pairs :math:`\{ (\theta_i, x_i) \}`, + the module returns -class BCEWithLogitsLoss(nn.Module): - r"""Binary Cross-Entropy (BCE) loss with logits + .. math:: l = \frac{1}{N} \sum_{i = 1}^N + -\log p_\phi(\theta_i \odot b_i + \theta_{i + 1} \odot (1 - b_i) | x_i, b_i) - E_p [-log d(x)] + E_q [-log (1 - d(x))] + where the binary masks :math:`b_i` are sampled from a distribution :math:`P(b)`. - Supports several scoring rules (NLL, PL, QS, ...). - - Wikipedia: - https://en.wikipedia.org/wiki/Scoring_rule + Arguments: + estimator: A normalizing flow :math:`p_\phi(\theta | x, b)`. + mask_dist: A binary mask distribution :math:`P(b)`. """ - def __init__( - self, - positive: str = 'NLL', # in ['NLL', 'FL', 'PL', 'QS'] - negative: str = 'NLL', # in ['NLL', 'FL', 'PL', 'QS'] - reduction: str = 'batchmean', - ): + def __init__(self, estimator: nn.Module, mask_dist: Distribution): super().__init__() - self.l1 = SCORES[positive]() - self.l0 = SCORES[negative]() - - self.reduction = reduction - - def forward( - self, - logit: Tensor, - target: Tensor, - weight: Tensor = None, - ) -> Tensor: - pos = target > 0.5 + self.estimator = estimator + self.mask_dist = mask_dist - l1 = self.l1(logit[pos]) # -log d(x) - l0 = self.l0(-logit[~pos]) # -log (1 - d(x)) + def forward(self, theta: Tensor, x: Tensor) -> Tensor: + r""" + Arguments: + theta: The parameters :math:`\theta`, with shape :math:`(N, D)`. + x: The observation :math:`x`, with shape :math:`(N, L)`. - if weight is not None: - l1 = l1 * weight[pos] - l0 = l0 * weight[~pos] - - cross = torch.cat((l1, l0)) - - return reduce(cross, self.reduction) - - -class BalancingWithLogitsLoss(nn.Module): - r"""Balancing loss - - (E_p [d(x)] + E_q [d(x)] - 1) ** 2 - """ + Returns: + The scalar loss :math:`l`. + """ - def forward( - self, - logit: Tensor, - weight: Tensor = None, - ) -> Tensor: - d = torch.sigmoid(logit) # d(x) + b = self.mask_dist.sample(theta.shape[:-1]) + theta_prime = torch.roll(theta, 1, dims=0) + theta = torch.where(b, theta, theta_prime) - if weight is None: - d = d.mean() - else: - d = (weight * d).sum() / weight.sum() + log_prob = self.estimator(theta, x, b) - return (2 * d - 1) ** 2 + return -log_prob.mean() diff --git a/lampe/nn/modules.py b/lampe/nn/modules.py deleted file mode 100644 index e9864c9..0000000 --- a/lampe/nn/modules.py +++ /dev/null @@ -1,507 +0,0 @@ -r"""Modules and layers""" - -import torch -import torch.nn as nn -import torch.nn.functional as F - -from torch import Tensor, BoolTensor -from torch.distributions import Distribution -from typing import * - -from .flows import MAF - - -ACTIVATIONS = { - 'ReLU': nn.ReLU, - 'PReLU': nn.PReLU, - 'ELU': nn.ELU, - 'CELU': nn.CELU, - 'SELU': nn.SELU, - 'GELU': nn.GELU, -} - - -class Broadcast(nn.Module): - r"""Broadcast layer - - Args: - keep: The number of dimensions to not broadcast - """ - - def __init__(self, keep: int = 0): - super().__init__() - - self.keep = keep - - def split(self, shape: torch.Size) -> Tuple[torch.Size, torch.Size]: - index = len(shape) - self.keep - return shape[:index], shape[index:] - - def forward(self, *xs: Tensor) -> List[Tensor]: - splits = [self.split(x.shape) for x in xs] - - before, after = zip(*splits) - before = torch.broadcast_shapes(*before) - - return [ - torch.broadcast_to(x, before + a) - for x, a in zip(xs, after) - ] - - def extra_repr(self) -> str: - return f'keep={self.keep}' - - -class Affine(nn.Module): - r"""Element-wise affine layer - - Args: - shift: The shift term - scale: The scale factor - """ - - def __init__(self, shift: Tensor, scale: Tensor): - super().__init__() - - self.register_buffer('shift', shift) - self.register_buffer('scale', scale) - - def forward(self, input: Tensor) -> Tensor: - return input * self.scale + self.shift - - def extra_repr(self) -> str: - return '\n'.join([ - f'(shift): {self.shift.cpu()}', - f'(scale): {self.scale.cpu()}', - ]) - - -class BatchNorm0d(nn.BatchNorm1d): - r"""Batch Normalization (BatchNorm) layer for scalars - - References: - [1] Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift - (Ioffe et al., 2015) - https://arxiv.org/abs/1502.03167 - """ - - def forward(self, x: Tensor) -> Tensor: - shape = x.shape - - x = x.reshape(-1, shape[-1]) - x = super().forward(x) - x = x.reshape(shape) - - return x - - -class MLP(nn.Sequential): - r"""Multi-Layer Perceptron (MLP) - - Args: - in_features: The number of input features. - out_features: The number of output features. - hidden_features: The numbers of hidden features. - activation: The activation layer type. - batchnorm: Whether to use batch normalization or not. - dropout: The dropout rate. - - **kwargs are passed to `nn.Linear`. - """ - - def __init__( - self, - in_features: int, - out_features: int, - hidden_features: List[int] = [64, 64], - activation: str = 'ReLU', - batchnorm: bool = False, - dropout: float = 0., - **kwargs, - ): - activation = ACTIVATIONS[activation] - batchnorm = BatchNorm0d if batchnorm else lambda _: None - dropout = nn.Dropout(dropout) if dropout > 0 else None - - layers = [] - - for before, after in zip( - [in_features] + hidden_features, - hidden_features + [out_features], - ): - layers.extend([ - nn.Linear(before, after, **kwargs), - batchnorm(after), - activation(), - dropout, - ]) - - layers = layers[:-3] - layers = filter(lambda l: l is not None, layers) - - super().__init__(*layers) - - self.in_features = in_features - self.out_features = out_features - - -class ResBlock(MLP): - r"""Residual Block (ResBlock) - - Args: - features: The input, output and hidden features. - block_layers: The number of block layers. - - **kwargs are passed to `MLP`. - """ - - def __init__(self, features: int, block_layers: int = 2, **kwargs): - super().__init__(features, features, [features] * block_layers, **kwargs) - - def forward(self, input: Tensor) -> Tensor: - return input + super().forward(input) - - -class ResMLP(nn.Sequential): - r"""Residual Multi-Layer Perceptron (ResMLP) - - Args: - in_features: The number of input features. - out_features: The number of output features. - hidden_features: The numbers of hidden features. - - **kwargs are passed to `ResBlock`. - """ - - def __init__( - self, - in_features: int, - out_features: int, - hidden_features: List[int] = [64, 64], - **kwargs, - ): - blocks = [nn.Linear(in_features, in_features)] - - for before, after in zip( - [in_features] + hidden_features, - hidden_features + [out_features], - ): - blocks.append(ResBlock(before, **kwargs)) - - if before != after: - blocks.append(nn.Linear(before, after)) - - super().__init__(*blocks) - - self.in_features = in_features - self.out_features = out_features - - -class NRE(nn.Module): - r"""Neural Ratio Estimator (NRE) - - (theta, x) ---> log r(theta, x) - - Args: - theta_size: The size of the parameters. - x_size: The size of the observations. - moments: The parameters moments (mu, sigma) for standardization. - arch: The network architecture (`MLP` or `ResMLP`). - - **kwargs are passed to `MLP` or `ResMLP`. - - References: - [1] Likelihood-free MCMC with Amortized Approximate Ratio Estimators - (Hermans et al., 2019) - https://arxiv.org/abs/1903.04057 - """ - - def __init__( - self, - theta_size: int, - x_size: int, - moments: Tuple[Tensor, Tensor] = None, - arch: str = 'MLP', - **kwargs, - ): - super().__init__() - - if moments is not None: - mu, sigma = moments - - self.standardize = nn.Identity() if moments is None else Affine(-mu / sigma, 1 / sigma) - self.broadcast = Broadcast(keep=1) - - if arch == 'ResMLP': - arch = ResMLP - else: # arch == 'MLP' - arch = MLP - - self.net = arch(theta_size + x_size, 1, **kwargs) - - def forward(self, theta: Tensor, x: Tensor) -> Tensor: - theta = self.standardize(theta) - theta, x = self.broadcast(theta, x) - - return self.net(torch.cat((theta, x), dim=-1)).squeeze(-1) - - -class MNRE(nn.Module): - r"""Marginal Neural Ratio Estimator (MNRE) - - ---> log r(theta_a, x) - / - (theta, x) ----> log r(theta_b, x) - \ - ---> log r(theta_c, x) - - Args: - masks: The masks of the considered parameter subspaces. - x_size: The size of the observations. - moments: The parameters moments (mu, sigma) for standardization. - - **kwargs are passed to `NRE`. - """ - - BASE = NRE - - def __init__( - self, - masks: BoolTensor, - x_size: int, - moments: Tuple[Tensor, Tensor] = None, - **kwargs, - ): - super().__init__() - - self.register_buffer('masks', masks) - - if moments is not None: - mu, sigma = moments - - self.estimators = nn.ModuleList([ - self.BASE( - m.sum().item(), - x_size, - moments=None if moments is None else (mu[m], sigma[m]), - **kwargs, - ) for m in self.masks - ]) - - def __getitem__(self, mask: BoolTensor) -> nn.Module: - r"""Select estimator r(theta_a, x)""" - - mask = mask.to(self.masks) - select = torch.all(mask == self.masks, dim=-1) - indices = torch.nonzero(select).squeeze(-1).tolist() - - for i in indices: - return self.estimators[i] - - return None - - def filter(self, masks: Tensor): - r"""Filter estimators within subspace""" - - estimators = [] - - for m in masks: - estimators.append(self[m]) - - self.masks = masks - self.estimators = nn.ModuleList(estimators) - - def forward( - self, - theta: Tensor, # (N, D) - x: Tensor, # (N, L) - ) -> Tensor: - preds = [] - - for mask, estimator in zip(self.masks, self.estimators): - preds.append(estimator(theta[..., mask], x)) - - return torch.stack(preds, dim=-1) - - -class AMNRE(NRE): - r"""Arbitrary Marginal Neural Ratio Estimator (AMNRE) - - (theta, x, mask_a) ---> log r(theta_a, x) - - Args: - theta_size: The size of the parameters. - - *args and **kwargs are passed to `NRE`. - - References: - [1] Arbitrary Marginal Neural Ratio Estimation for Simulation-based Inference - (Rozet et al., 2019) - https://arxiv.org/abs/2110.00449 - """ - - def __init__( - self, - theta_size: int, - *args, - **kwargs, - ): - super().__init__(theta_size * 2, *args, **kwargs) - - self.register_buffer('default', torch.ones(theta_size).bool()) - - def __getitem__(self, mask: BoolTensor) -> nn.Module: - r"""Select estimator r(theta_a, x)""" - - self.default = mask.to(self.default) - - return self - - def forward( - self, - theta: Tensor, # (N, D) - x: Tensor, # (N, L) - mask: BoolTensor = None, # (D,) or (N, D) - ) -> Tensor: - if mask is None: - mask = self.default - - zeros = theta.new_zeros(theta.shape[:-1] + mask.shape[-1:]) - - if mask.dim() == 1 and theta.shape[-1] < mask.numel(): - theta = zeros.masked_scatter(mask, theta) - else: - theta = torch.where(mask, theta, zeros) - - theta = self.standardize(theta) * mask - theta = torch.cat(self.broadcast(theta, mask * 2. - 1.), dim=-1) - theta, x = self.broadcast(theta, x) - - return self.net(torch.cat((theta, x), dim=-1)).squeeze(-1) - - -class NPE(nn.Module): - r"""Neural Posterior Estimator (NPE) - - (theta, x) ---> log p(theta | x) - - Args: - theta_size: The size of the parameters. - x_size: The size of the observations. - moments: The parameters moments (mu, sigma) for standardization. - - **kwargs are passed to `MAF`. - """ - - def __init__( - self, - theta_size: int, - x_size: int, - moments: Tuple[Tensor, Tensor] = None, - **kwargs, - ): - super().__init__() - - self.broadcast = Broadcast(keep=1) - self.flow = MAF(theta_size, x_size, moments=moments, **kwargs) - - def forward(self, theta: Tensor, x: Tensor) -> Tensor: - r""" log p(theta | x) """ - - theta, x = self.broadcast(theta, x) - - return self.flow.log_prob(theta, x) - - def sample(self, x: Tensor, shape: torch.Size = ()) -> Tensor: - r""" theta ~ p(theta | x) """ - - return self.flow.sample(x, shape) - - -class MNPE(MNRE): - r"""Marginal Neural Posterior Estimator (MNPE) - - ---> log p(theta_a | x) - / - (theta, x) ----> log p(theta_b | x) - \ - ---> log p(theta_c | x) - - Args: - masks: The masks of the considered parameter subspaces. - x_size: The size of the observations. - moments: The parameters moments (mu, sigma) for standardization. - - **kwargs are passed to `NPE`. - """ - - BASE = NPE - - -class AMNPE(NPE): - r"""Arbitrary Marginal Neural Posterior Estimator (AMNPE) - - (theta, x, mask_a) ---> log p(theta_a | x) / p(theta_a) - - Args: - theta_size: The size of the parameters. - x_size: The size of the observations. - prior: The prior distributions p(theta). - - *args and **kwargs are passed to `NPE`. - """ - - def __init__( - self, - theta_size: int, - x_size: int, - prior: Distribution, - *args, - **kwargs, - ): - super().__init__(theta_size, x_size + theta_size, *args, **kwargs) - - self.prior = prior - - self.register_buffer('default', torch.ones(theta_size).bool()) - - def __getitem__(self, mask: BoolTensor) -> nn.Module: - r"""Select estimator p(theta_a | x)""" - - self.default = mask.to(self.default) - - return self - - def forward( - self, - theta: Tensor, # (N, D) - x: Tensor, # (N, L) - mask: BoolTensor = None, # (D,) or (N, D) - ) -> Tensor: - if mask is None: - mask = self.default - - theta_prime = self.prior.sample(theta.shape[:-1]) - - if mask.dim() == 1 and theta.shape[-1] < mask.numel(): - theta = theta_prime.masked_scatter(mask, theta) - else: - theta = torch.where(mask, theta, theta_prime) - - x = torch.cat(self.broadcast(x, mask * 2. - 1.), dim=-1) - theta, x = self.broadcast(theta, x) - - return self.flow.log_prob(theta, x) - self.prior.log_prob(theta) - - def sample( - self, - x: Tensor, # (N, L) - shape: torch.Size = (), - mask: BoolTensor = None, # (D,) - ) -> Tensor: - if mask is None: - mask = self.default - - x = torch.cat(self.broadcast(x, mask * 2. - 1.), dim=-1) - - return self.flow.sample(x, shape)[..., mask] diff --git a/lampe/nn/pipes.py b/lampe/nn/pipes.py deleted file mode 100644 index 74cd86d..0000000 --- a/lampe/nn/pipes.py +++ /dev/null @@ -1,147 +0,0 @@ -r"""Pipelines""" - -import torch -import torch.nn as nn - -from torch import Tensor, BoolTensor -from torch.distributions import Distribution -from typing import * - - -class Pipe(nn.Module): - r"""Abstract pipeline class""" - - def __init__( - self, - embedding: nn.Module = nn.Identity(), - hook: Callable = None, - device: torch.device = None, - ): - super().__init__() - - self.embedding = embedding - self.hook = hook - - self.register_buffer('dummy', torch.tensor(0., device=device)) - - @property - def device(self) -> torch.device: - return self.dummy.device - - def process(self, theta: Tensor, x: Tensor) -> Tensor: - theta, x = theta.to(self.device), x.to(self.device) - - if self.hook is not None: - theta, x = self.hook(theta, x) - - x = self.embedding(x) - - return theta, x - - -class NREPipe(Pipe): - r"""NRE training pipeline""" - - def __init__( - self, - estimator: nn.Module, - criterion: nn.Module = nn.BCEWithLogitsLoss(), - **kwargs, - ): - super().__init__(**kwargs) - - self.estimator = estimator - self.criterion = criterion - - def forward(self, theta: Tensor, x: Tensor) -> Tensor: - theta, x = self.process(theta, x) - - theta_prime = torch.roll(theta, 1, dims=0) - - ratio, ratio_prime = self.estimator( - torch.stack((theta, theta_prime)), - torch.stack((x, x)), - ) - - l1 = self.criterion(ratio, torch.ones_like(ratio)) - l0 = self.criterion(ratio_prime, torch.zeros_like(ratio)) - - return (l1 + l0) / 2 - - -class AMNREPipe(Pipe): - r"""AMNRE training pipeline""" - - def __init__( - self, - estimator: nn.Module, - mask_dist: Distribution, - criterion: nn.Module = nn.BCEWithLogitsLoss(), - **kwargs, - ): - super().__init__(**kwargs) - - self.estimator = estimator - self.mask_dist = mask_dist - self.criterion = criterion - - def forward(self, theta: Tensor, x: Tensor) -> Tensor: - theta, x = self.process(theta, x) - - theta_prime = torch.roll(theta, 1, dims=0) - mask = self.mask_dist.sample(theta.shape[:-1]) - - ratio, ratio_prime = self.estimator( - torch.stack((theta, theta_prime)), - torch.stack((x, x)), - mask, - ) - - l1 = self.criterion(ratio, torch.ones_like(ratio)) - l0 = self.criterion(ratio_prime, torch.zeros_like(ratio)) - - return (l1 + l0) / 2 - - -class NPEPipe(Pipe): - r"""NPE training pipeline""" - - def __init__( - self, - estimator: nn.Module, - **kwargs, - ): - super().__init__(**kwargs) - - self.estimator = estimator - - def forward(self, theta: Tensor, x: Tensor) -> Tensor: - theta, x = self.process(theta, x) - - log_prob = self.estimator(theta, x) - - return -log_prob.mean() - - -class AMNPEPipe(Pipe): - r"""AMNPE training pipeline""" - - def __init__( - self, - estimator: nn.Module, - mask_dist: Distribution, - **kwargs, - ): - super().__init__(**kwargs) - - self.estimator = estimator - self.mask_dist = mask_dist - - def forward(self, theta: Tensor, x: Tensor) -> Tensor: - theta, x = self.process(theta, x) - - mask = self.mask_dist.sample(theta.shape[:-1]) - - log_prob = self.estimator(theta, x, mask) - - return -log_prob.mean() diff --git a/lampe/patch.py b/lampe/patch.py new file mode 100644 index 0000000..fa7970e --- /dev/null +++ b/lampe/patch.py @@ -0,0 +1,72 @@ +r"""PyTorch monkey patches.""" + +import torch +import torch.nn as nn + +from torch import Tensor +from torch.distributions import Distribution +from torch.optim import Optimizer +from typing import * + + +################ +# Distribution # +################ + +def new_init(self, *args, **kwargs): + r"""Initializes :py:`self` with the features of a :class:`torch.nn.Module` instance.""" + + old_init(self, *args, **kwargs) + + self.__class__ = type( + self.__class__.__name__, + (self.__class__, nn.Module), + {}, + ) + + nn.Module.__init__(self) + +def deepapply(obj: Any, f: Callable) -> Any: + r"""Applies :py:`f` to all tensors referenced in :py:`obj`.""" + + if torch.is_tensor(obj): + obj = f(obj) + elif isinstance(obj, dict): + for key, value in obj.items(): + obj[key] = deepapply(value, f) + elif isinstance(obj, list): + for i, value in enumerate(obj): + obj[i] = deepapply(value, f) + elif isinstance(obj, tuple): + obj = tuple( + deepapply(value, f) + for value in obj + ) + elif hasattr(obj, '__dict__'): + deepapply(obj.__dict__, f) + + return obj + +old_init = Distribution.__init__ +Distribution.__init__ = new_init +Distribution._apply = deepapply +Distribution._validate_args = False +Distribution.arg_constraints = {} + + +############# +# Optimizer # +############# + +def lrs(self) -> Iterable[float]: + r"""Yields the learning rates of the parameter groups.""" + + return (group['lr'] for group in self.param_groups) + +def parameters(self) -> Iterable[Tensor]: + r"""Yields the parameter tensors of the parameter groups.""" + + return (p for group in self.param_groups for p in group['params']) + +Optimizer.lrs = lrs +Optimizer.parameters = parameters diff --git a/lampe/plots.py b/lampe/plots.py index e26946f..6ed543d 100644 --- a/lampe/plots.py +++ b/lampe/plots.py @@ -1,51 +1,82 @@ -r"""Plotting routines""" +r"""Plotting helpers. + +.. admonition:: TODO + + * Generate plots. +""" import matplotlib as mpl import matplotlib.pyplot as plt import numpy as np -import scipy.ndimage as si from numpy import ndarray as Array -from numpy.typing import ArrayLike from typing import * -plt.rcParams.update({ - 'axes.axisbelow': True, - 'axes.linewidth': .8, - 'figure.autolayout': True, - 'figure.dpi': 150, - 'figure.figsize': (6.4, 4.8), - 'font.size': 12., - 'legend.fontsize': 'x-small', - 'lines.linewidth': 1., - 'lines.markersize': 3., - 'savefig.bbox': 'tight', - 'savefig.transparent': True, - 'xtick.labelsize': 'x-small', - 'xtick.major.width': .8, - 'ytick.labelsize': 'x-small', - 'ytick.major.width': .8, -}) - -if mpl.checkdep_usetex(True): - plt.rcParams.update({ - 'font.family': ['serif'], - 'font.serif': ['Computer Modern'], - 'text.usetex': True, - }) +__all__ = ['nice_rc', 'corner', 'rank_ecdf'] + + +def nice_rc(latex: bool = True) -> Dict[str, Any]: + r"""Returns a dictionary of runtime configuration (rc) settings for nicer + :mod:`matplotlib` plots. The settings include 12pt font size, higher DPI, + tight layout, transparent background, etc. + + Arguments: + latex: Whether to use LaTeX typesetting or not. + + Example: + >>> plt.rcParams.update(nice_rc()) + >>> x = np.arange(5) + >>> plt.plot(x, np.sqrt(x)) + >>> plt.xlabel(r'$x$') + >>> plt.ylabel(r'$f(x)$') + TODO + """ + + rc = { + 'axes.axisbelow': True, + 'axes.linewidth': .8, + 'figure.autolayout': True, + 'figure.dpi': 150, + 'figure.figsize': (6.4, 4.8), + 'font.size': 12., + 'legend.fontsize': 'x-small', + 'lines.linewidth': 1., + 'lines.markersize': 3., + 'savefig.bbox': 'tight', + 'savefig.transparent': True, + 'xtick.labelsize': 'x-small', + 'xtick.major.width': .8, + 'ytick.labelsize': 'x-small', + 'ytick.major.width': .8, + } + + if mpl.checkdep_usetex(latex): + rc.update({ + 'font.family': ['serif'], + 'font.serif': ['Computer Modern'], + 'text.usetex': True, + }) + + return rc class LinearAlphaColormap(mpl.colors.LinearSegmentedColormap): - r"""Linear transparency colormap segmented between levels""" + r"""Linear segmented transparency colormap. + + Arguments: + color: A color. + levels: A sequence of levels dividing the domain into segments. + alpha: The transparancy range. + name: A name for the colormap. + """ def __new__( self, color: Union[str, tuple], - levels: ArrayLike = None, + levels: Array = None, alpha: Tuple[float, float] = (0., 1.), name: str = None, - **kwargs, ): if name is None: if type(color) is str: @@ -73,31 +104,91 @@ def __new__( ) -def credible_levels(hist: Array, quantiles: Array) -> Array: - r"""Retrieve credible region boundary levels from an histogram""" +def gaussian_blur(img: Array, sigma: float = 1.) -> Array: + r"""Applies a Gaussian blur to an image. + + Arguments: + img: An image array. + sigma: The standard deviation of the Gaussian kernel. + + Returns: + The blurred image. + + Example: + >>> img = np.random.rand(128, 128) + >>> gaussian_blur(img, sigma=2.) + array([...]) + """ + + size = 2 * int(3 * sigma) + 1 + + k = np.arange(size) - size / 2 + k = np.exp(-k ** 2 / (2 * sigma ** 2)) + k = k / np.sum(k) + + smooth = lambda x: np.convolve(x, k, mode='same') + + for i in range(len(img.shape)): + img = np.apply_along_axis(smooth, i, img) + + return img + + +def credible_levels(hist: Array, creds: Array) -> Array: + r"""Returns the levels of credibility region contours. + + Arguments: + hist: An histogram. + creds: The region credibilities. + """ x = np.sort(hist, axis=None)[::-1] cdf = np.cumsum(x) - idx = np.searchsorted(cdf, quantiles * cdf[-1]) + idx = np.searchsorted(cdf, creds * cdf[-1]) return x[idx] def corner( - data: ArrayLike, # table or matrix of 1d/2d histograms + data: Array, bins: Union[int, List[int]] = 100, - bounds: Tuple[ArrayLike, ArrayLike] = None, - quantiles: ArrayLike = [.6827, .9545, .9973], + bounds: Tuple[Array, Array] = None, + creds: Array = [.6827, .9545, .9973], color: Union[str, tuple] = None, - alpha: float = .5, + alpha: Tuple[float, float] = (0., .5), legend: str = None, labels: List[str] = None, - markers: List[ArrayLike] = [], + markers: List[Array] = [], smooth: float = 0, figure: mpl.figure.Figure = None, **kwargs, ) -> mpl.figure.Figure: - r"""Corner plot""" + r"""Displays each 1 or 2-d projection of multi-dimensional data, as a triangular + matrix of histograms, known as corner plot. For 2-d histograms, highest density + credibility regions are delimited. + + Arguments: + data: Multi-dimensional data, either as a table or as a matrix of histograms. + bins: The number(s) of bins per dimension. + bounds: A tuple of lower and upper domain bounds. If :py:`None`, inferred from data. + creds: The region credibilities (in :math:`[0, 1]`) to delimit. + color: A color for histograms. + alpha: A transparency range. + legend: A legend. + labels: The dimension labels. + markers: A list of points to mark on the histograms. + smooth: The standard deviation of the smoothing kernels. + figure: A corner plot over which to draw the new one. + kwargs: Keyword arguments passed to :func:`matplotlib.pyplot.subplots`. + + Returns: + The figure instance for the corner plot. + + Example: + >>> data = np.random.randn(2**16, 4) + >>> corner(data, bins=42) + TODO + """ # Histograms data = np.asarray(data) @@ -177,17 +268,17 @@ def corner( handles, texts = axes[0, -1].get_legend_handles_labels() ## Quantiles - quantiles = np.sort(np.asarray(quantiles))[::-1] - quantiles = np.append(quantiles, 0) + creds = np.sort(np.asarray(creds))[::-1] + creds = np.append(creds, 0) - cmap = LinearAlphaColormap('black', levels=quantiles, alpha=(0, alpha)) + cmap = LinearAlphaColormap('black', levels=creds, alpha=alpha) - levels = (quantiles[1:] + quantiles[:-1]) / 2 - levels = (levels - quantiles.min()) / (quantiles.max() - quantiles.min()) + levels = (creds - creds.min()) / (creds.max() - creds.min()) + levels = (levels[:-1] + levels[1:]) / 2 - for q, l in zip(quantiles[:-1], levels): + for c, l in zip(creds[:-1], levels): handles.append(mpl.patches.Patch(color=cmap(l), linewidth=0)) - texts.append(r'{:.1f}\,\%'.format(q * 100)) + texts.append(r'{:.1f}\,\%'.format(c * 100)) ## Update if not new: @@ -209,7 +300,7 @@ def corner( continue if smooth > 0: - hist = si.gaussian_filter(hist, smooth) + hist = gaussian_blur(hist, smooth) ## Draw x, y = bins[j], bins[i] @@ -226,12 +317,12 @@ def corner( ax.set_xlim(left=bins[i][0], right=bins[i][-1]) ax.set_ylim(bottom=bottom, top=top) else: - levels = np.unique(credible_levels(hist, quantiles)) + levels = np.unique(credible_levels(hist, creds)) cf = ax.contourf( x, y, hist, levels=levels, - cmap=LinearAlphaColormap(color, levels, alpha=(0, alpha)), + cmap=LinearAlphaColormap(color, levels, alpha=alpha), ) ax.contour(cf, colors=color) @@ -298,14 +389,31 @@ def corner( return figure -def pp( - p: ArrayLike, +def rank_ecdf( + ranks: Array, color: Union[str, tuple] = None, - label: str = None, + legend: str = None, figure: mpl.figure.Figure = None, **kwargs, ) -> mpl.figure.Figure: - r"""P-P plot""" + r"""Draws the empirical cumulative distribution function (ECDF) of a rank + statistic :math:`r \in [0, 1]`. + + Arguments: + ranks: Samples of the rank statistic. + color: A color. + legend: A legend. + figure: A ECDF plot over which to draw the new one. + kwargs: Keyword arguments passed to :func:`matplotlib.pyplot.subplots`. + + Returns: + The figure instance for the ECDF plot. + + Example: + >>> ranks = np.random.rand(2**12)**2 + >>> rank_ecdf(ranks) + TODO + """ # Figure if figure is None: @@ -317,22 +425,22 @@ def pp( ax = figure.axes.squeeze() new = False - # CDF - p = np.sort(np.asarray(p)) - p = np.hstack([0, p, 1]) - cdf = np.linspace(0, 1, len(p)) + # ECDF + ranks = np.sort(np.asarray(ranks)) + ranks = np.hstack([0, ranks, 1]) + ecdf = np.linspace(0, 1, len(ranks)) # Plot if new: ax.plot([0, 1], [0, 1], color='k', linestyle='--') - ax.plot(p, cdf, color=color, label=label) + ax.plot(p, cdf, color=color, label=legend) ax.grid() - ax.set_xlabel(r'$p$') - ax.set_ylabel(r'CDF$(p)$') + ax.set_xlabel(r'$r$') + ax.set_ylabel(r'$\text{ECDF}(r)$') - if label is not None: + if legend is not None: ax.legend(loc='upper left') return figure diff --git a/lampe/priors.py b/lampe/priors.py index 5c9092b..1e016c4 100644 --- a/lampe/priors.py +++ b/lampe/priors.py @@ -1,8 +1,7 @@ -r"""Priors and distributions""" +r"""Priors and distributions.""" import math import torch -import torch.nn as nn from textwrap import indent from torch import Tensor @@ -11,30 +10,75 @@ from torch.distributions.utils import broadcast_all from typing import * -from .utils import deepapply +class BoxUniform(Independent): + r"""Creates a distribution for a multivariate random variable :math:`X` + distributed uniformly over an hypercube domain. Formally, -__init__ = Distribution.__init__ + .. math:: l_i \leq X_i < u_i , -def init(self, *args, **kwargs): - __init__(self, *args, **kwargs) + where :math:`l_i` and :math:`u_i` are respectively the lower and upper bounds + of the domain in the :math:`i`-th dimension. - self.__class__ = type( - self.__class__.__name__, - (self.__class__, nn.Module), - {}, - ) + Arguments: + lower: The lower bounds (inclusive). + upper: The upper bounds (exclusive). + ndims: The number of batch dimensions to interpret as event dimensions. - nn.Module.__init__(self) + Example: + >>> d = BoxUniform(-torch.ones(3), torch.ones(3)) + >>> d.event_shape + torch.Size([3]) + >>> d.sample() + tensor([ 0.1859, -0.9698, 0.0665]) + """ -Distribution.__init__ = init -Distribution._apply = deepapply -Distribution._validate_args = False -Distribution.arg_constraints = {} + def __init__(self, lower: Tensor, upper: Tensor, ndims: int = 1): + super().__init__(Uniform(lower, upper), ndims) + + def __repr__(self) -> str: + return f'Box{self.base_dist}' + + +class DiagNormal(Independent): + r"""Creates a multivariate normal distribution parametrized by the variables + mean :math:`\mu` and standard deviation :math:`\sigma`, but assumes no + correlation between the variables. + + Arguments: + loc: The mean :math:`\mu` of the variables. + scale: The standard deviation :math:`\sigma` of the variables. + ndims: The number of batch dimensions to interpret as event dimensions. + + Example: + >>> d = DiagNormal(torch.zeros(3), torch.ones(3)) + >>> d.event_shape + torch.Size([3]) + >>> d.sample() + tensor([0.7304, -0.1976, -1.7591]) + """ + + def __init__(self, loc: Tensor, scale: Tensor, ndims: int = 1): + super().__init__(Normal(loc, scale), ndims) + + def __repr__(self) -> str: + return f'Diag{self.base_dist}' class Joint(Distribution): - r"""Joint distribution of independent random variables""" + r"""Joins independent random variables into a single distribution. + + Arguments: + marginals: A list of independent distributions. The distributions + should not be batched. + + Example: + >>> d = Joint([Uniform(0, 1), Normal(0, 1)]) + >>> d.event_shape + torch.Size([2]) + >>> d.sample() + tensor([ 0.8969, -2.6717]) + """ def __init__(self, marginals: List[Distribution]): super().__init__() @@ -57,7 +101,7 @@ def rsample(self, shape: torch.Size = ()): for dist in self.marginals: y = dist.rsample(shape) - y = y.view(shape + (-1,)) + y = y.reshape(shape + (-1,)) x.append(y) return torch.cat(x, dim=-1) @@ -68,7 +112,7 @@ def log_prob(self, x: Tensor) -> Tensor: for dist in self.marginals: j = i + dist.event_shape.numel() - y = x[..., i:j].view(shape + dist.event_shape) + y = x[..., i:j].reshape(shape + dist.event_shape) lp = lp + dist.log_prob(y) i = j @@ -83,28 +127,28 @@ def __repr__(self) -> str: return f'{self.__class__.__name__}(\n' + ',\n'.join(lines) + '\n)' -class JointNormal(Independent): - r"""Joint distribution of independent normal random variables""" - - def __init__(self, loc: Tensor, scale: Tensor, ndims: int = 1): - super().__init__(Normal(loc, scale), ndims) - - def __repr__(self) -> str: - return f'Joint{self.base_dist}' - - -class JointUniform(Independent): - r"""Joint distribution of independent uniform random variables""" - - def __init__(self, low: Tensor, high: Tensor, ndims: int = 1): - super().__init__(Uniform(low, high), ndims) - - def __repr__(self) -> str: - return f'Joint{self.base_dist}' - - class Sort(Distribution): - r"""Sort of independent scalar random variables""" + r"""Creates a distribution for a :math:`n`-d random variable :math:`X`, whose elements + :math:`X_i` are :math:`n` draws from a base distribution :math:`p(Y)`, ordered + such that :math:`X_i \leq X_{i + 1}`. + + .. math:: p(X = x) = \begin{cases} + n! \, \prod_{i = 1}^n p(Y = x_i) & \text{if $x$ is ordered} \\ + 0 & \text{otherwise} + \end{cases} + + Arguments: + base: A base distribution :math:`p(Y)`. + n: The number of draws :math:`n`. + descending: Whether the elements are sorted in descending order or not. + + Example: + >>> d = Sort(Normal(0, 1), 3) + >>> d.event_shape + torch.Size([3]) + >>> d.sample() + tensor([-1.4434, -0.3861, 0.2439]) + """ def __init__( self, @@ -157,7 +201,29 @@ def log_prob(self, value: Tensor) -> Tensor: class TopK(Sort): - r"""Top k of independent scalar random variables""" + r"""Creates a distribution for a :math:`k`-d random variable :math:`X`, whose elements + :math:`X_i` are the top :math:`k` among :math:`n` draws from a base distribution + :math:`p(Y)`, ordered such that :math:`X_i \leq X_{i + 1}`. + + .. math:: p(X = x) = \begin{cases} + \frac{n!}{(n - k)!} \, \prod_{i = 1}^k p(Y = x_i) + \, P(Y \geq x_k)^{n - k} & \text{if $x$ is ordered} \\ + 0 & \text{otherwise} + \end{cases} + + Arguments: + base: A base distribution :math:`p(Y)`. + k: The number of selected elements :math:`k`. + n: The number of draws :math:`n`. + kwargs: Keyword arguments passed to :class:`Sort`. + + Example: + >>> d = TopK(Normal(0, 1), 2, 3) + >>> d.event_shape + torch.Size([2]) + >>> d.sample() + tensor([-0.2167, 0.6739]) + """ def __init__( self, @@ -196,13 +262,28 @@ def log_prob(self, value: Tensor) -> Tensor: ) -class Maximum(TopK): - r"""Maximum of independent scalar random variables""" +class Minimum(TopK): + r"""Creates a distribution for a scalar random variable :math:`X`, which is the + minimum among :math:`n` draws from a base distribution :math:`p(Y)`. + + .. math:: p(X = x) = n \, p(Y = x) \, P(Y \geq x)^{n - 1} + + Arguments: + base: A base distribution :math:`p(Y)`. + n: The number of draws :math:`n`. + + Example: + >>> d = Minimum(Normal(0, 1), 3) + >>> d.event_shape + torch.Size([]) + >>> d.sample() + tensor(-1.7552) + """ def __init__(self, base: Distribution, n: int = 2): super().__init__(base, 1, n) - self.descending = True + self.descending = False def __repr__(self) -> str: return Sort.__repr__(self) @@ -218,48 +299,57 @@ def log_prob(self, value: Tensor) -> Tensor: return super().log_prob(value.unsqueeze(dim=-1)) -class Minimum(Maximum): - r"""Minimum of independent scalar random variables""" +class Maximum(Minimum): + r"""Creates a distribution for a scalar random variable :math:`X`, which is the + maximum among :math:`n` draws from a base distribution :math:`p(Y)`. - def __init__(self, base: Distribution, n: int = 2): - super().__init__(base, n) + .. math:: p(X = x) = n \, p(Y = x) \, P(Y \leq x)^{n - 1} - self.descending = False - - -class TransformedUniform(TransformedDistribution): - r"""T-uniform distribution""" - - arg_constraints = Uniform.arg_constraints + Arguments: + base: A base distribution :math:`p(Y)`. + n: The number of draws :math:`n`. - def __init__(self, low: Tensor, high: Tensor, t: Transform): - self.low, self.high = broadcast_all(low, high) - super().__init__(Uniform(t(self.low), t(self.high)), [t.inv]) + Example: + >>> d = Maximum(Normal(0, 1), 3) + >>> d.event_shape + torch.Size([]) + >>> d.sample() + tensor(1.1644) + """ + def __init__(self, base: Distribution, n: int = 2): + super().__init__(base, n) -class PowerUniform(TransformedUniform): - r"""Power-uniform distribution""" - - def __init__(self, low: Tensor, high: Tensor, exponent: float): - super().__init__(low, high, PowerTransform(exponent)) + self.descending = True -class CosineUniform(TransformedUniform): - r"""Cosine-uniform distribution""" +class TransformedUniform(TransformedDistribution): + r"""Creates a distribution for a random variable :math:`X`, whose + transformation :math:`f(X)` is uniformly distributed over the interval + :math:`[f(l), f(u)]`. - def __init__(self, low: Tensor, high: Tensor): - super().__init__(low, high, CosineTransform()) + .. math:: p(X = x) = f'(x) \frac{1}{f(u) - f(l)} + Arguments: + lower: A lower bound :math:`l` (inclusive). + upper: An upper bound :math:`u` (exclusive). + f: A transformation :math:`f`, monotonically increasing over + :math:`[l, u]`. -class SineUniform(TransformedUniform): - r"""Sine-uniform distribution""" + Example: + >>> d = TransformedUniform(-1, 1, ExpTransform()) + >>> d.event_shape + torch.Size([]) + >>> d.sample() + tensor(0.5594) + """ - def __init__(self, low: Tensor, high: Tensor): - super().__init__(low, high, SineTransform()) + def __init__(self, lower: Tensor, upper: Tensor, f: Transform): + super().__init__(Uniform(f(lower), f(upper)), [f.inv]) -class CosineTransform(Transform): - r"""Transform via the mapping y = -cos(x)""" +class CosTransform(Transform): + r"""Transform via the mapping :math:`y = -\cos(x)`.""" domain = interval(0, math.pi) codomain = interval(-1, 1) @@ -275,8 +365,8 @@ def log_abs_det_jacobian(self, x, y): return x.sin().abs().log() -class SineTransform(Transform): - r"""Transform via the mapping y = sin(x)""" +class SinTransform(Transform): + r"""Transform via the mapping :math:`y = \sin(x)`.""" domain = interval(-math.pi / 2, math.pi / 2) codomain = interval(-1, 1) diff --git a/lampe/simulators/__init__.py b/lampe/simulators/__init__.py index 0cd3d2a..27804c4 100644 --- a/lampe/simulators/__init__.py +++ b/lampe/simulators/__init__.py @@ -1,4 +1,4 @@ -r"""Simulators""" +r"""Simulators and benchmarks.""" from abc import ABC, abstractmethod from numpy import ndarray as Array @@ -7,9 +7,8 @@ class Simulator(ABC): - r"""Abstract simulator class""" + r"""Abstract simulator class.""" @abstractmethod def __call__(self, theta: Union[Array, Tensor]) -> Union[Array, Tensor]: - r""" x ~ p(x | theta) """ pass diff --git a/lampe/simulators/ees.py b/lampe/simulators/ees.py index 553bc0f..86fb8ec 100644 --- a/lampe/simulators/ees.py +++ b/lampe/simulators/ees.py @@ -1,16 +1,16 @@ -r"""Exoplanet Emission Spectrum (EES) +r"""Exoplanet emission spectrum (EES) benchmark. -EES computes an emission spectrum based on disequilibrium carbon chemistry, +The simulator computes an emission spectrum based on disequilibrium carbon chemistry, equilibrium clouds and a spline temperature-pressure profile of the exoplanet atmosphere. References: - [1] Retrieving scattering clouds and disequilibrium chemistry in the atmosphere of HR 8799e + Retrieving scattering clouds and disequilibrium chemistry in the atmosphere of HR 8799e (Mollière et al., 2020) https://arxiv.org/abs/2006.09394 Shapes: - theta: (16,) - x: (947,) + theta: :math:`(16,)`. + x: :math:`(947,)`. """ import numpy as np @@ -33,11 +33,10 @@ from typing import * from . import Simulator -from ..priors import Distribution, JointUniform from ..utils import cache, vectorize -labels = [ +LABELS = [ f'${l}$' for l in [ r'{\rm C/O}', r'\left[{\rm Fe/H}\right]', r'\log P_{\rm quench}', r'\log X_{\rm Fe}', r'\log X_{\rm MgSiO_3}', @@ -47,8 +46,7 @@ ] ] - -bounds = torch.tensor([ +LOWER, UPPER = torch.tensor([ [0.1, 1.6], # C/O [-1.5, 1.5], # [Fe/H] [-6., 3.], # log P_quench @@ -65,22 +63,17 @@ [0., 1.], # ∝ T_1 / T_2 [1., 2.], # alpha [0., 1.], # ∝ log delta / alpha -]) - -lower, upper = bounds[:, 0], bounds[:, 1] - - -def ees_prior(mask: BoolTensor = None) -> Distribution: - r""" p(theta) """ - - if mask is None: - mask = ... - - return JointUniform(lower[mask], upper[mask]) +]).t() class EES(Simulator): - r"""Exoplanet Emission Spectrum (EES) simulator""" + r"""Creates an exoplanet emission spectrum (EES) simulator. + + Arguments: + noisy: Whether noise is added to spectra or not. + seed: A random number generator seed. + kwargs: Simulator settings and constants (e.g. planet distance, pressures, ...). + """ def __init__(self, noisy: bool = True, seed: int = None, **kwargs): super().__init__() @@ -100,7 +93,7 @@ def __init__(self, noisy: bool = True, seed: int = None, **kwargs): } self.scale = self.constants.pop('scale') - self.atmosphere = cache(prt.Radtrans, disk=True)( + self.atmosphere = cache(prt.Radtrans, persist=True)( line_species=[ 'H2O_HITEMP', 'CO_all_iso_HITEMP', @@ -135,19 +128,7 @@ def __init__(self, noisy: bool = True, seed: int = None, **kwargs): self.rng = np.random.default_rng(seed) def __call__(self, theta: Array) -> Array: - r""" x ~ p(x | theta) """ - - theta = { - key: theta[..., i] - for i, key in enumerate([ - 'CO', 'FeH', 'log_pquench', 'log_X_Fe', 'log_X_MgSiO3', 'fsed', 'log_kzz', - 'sigma_lnorm', 'log_g', 'R_pl', 'T_int', 'T3', 'T2', 'T1', 'alpha', 'log_delta', - ]) - } - theta['R_pl'] = theta['R_pl'] * prt.nat_cst.r_jup_mean - - x = emission_spectrum(self.atmosphere, **theta, **self.constants) - x = np.stack(x) + x = emission_spectrum(self.atmosphere, theta, **self.constants) x = self.process(x) if self.noisy: @@ -156,32 +137,30 @@ def __call__(self, theta: Array) -> Array: return x def process(self, x: Array) -> Array: - r"""Processes spectra into network-friendly inputs""" + r"""Processes spectra into network-friendly inputs.""" return x * self.scale -@vectorize(otypes=[Array]) def emission_spectrum( - atmosphere: prt.Radtrans, - CO: float, - FeH: float, - log_X_Fe: float, - log_X_MgSiO3: float, + atmosphere, #: prt.Radtrans + theta: Array, **kwargs, ) -> Array: - r"""Simulates emission spectrum + r"""Simulates the emission spectrum of an exoplanet. References: https://gitlab.com/mauricemolli/petitRADTRANS/-/blob/master/petitRADTRANS/retrieval/models.py#L41 """ - kwargs.update({ - 'C/O': CO, - 'Fe/H': FeH, - 'log_X_cb_Fe(c)': log_X_Fe, - 'log_X_cb_MgSiO3(c)': log_X_MgSiO3, - }) + names = [ + 'C/O', 'Fe/H', 'log_pquench', 'log_X_cb_Fe(c)', 'log_X_cb_MgSiO3(c)', + 'fsed', 'log_kzz', 'sigma_lnorm', 'log_g', 'R_pl', + 'T_int', 'T3', 'T2', 'T1', 'alpha', 'log_delta', + ] + + kwargs.update(dict(zip(names, theta))) + kwargs['R_pl'] = kwargs['R_pl'] * prt.nat_cst.r_jup_mean parameters = { k: prm.Parameter(name=k, value=v, is_free_parameter=False) @@ -189,12 +168,13 @@ def emission_spectrum( } _, spectrum = models.emission_model_diseq(atmosphere, parameters, AMR=True) + return spectrum @vectorize(signature='(m),(n)->(n)') def pt_profile(theta: Array, pressures: Array) -> Array: - r"""Calculates the pressure-temperature profile + r"""Returns the pressure-temperature profile. References: https://gitlab.com/mauricemolli/petitRADTRANS/-/blob/master/petitRADTRANS/retrieval/models.py#L639 diff --git a/lampe/simulators/gw.py b/lampe/simulators/gw.py index 3e3137d..bfd5e77 100644 --- a/lampe/simulators/gw.py +++ b/lampe/simulators/gw.py @@ -1,27 +1,24 @@ -r"""Gravitational Waves (GW) +r"""Gravitational waves (GW) benchmark. -GW computes the gravitational waves emitted by precessing quasi-circular +The GW simulator computes the gravitational waves emitted by precessing quasi-circular binary black hole (BBH) systems, and project them onto LIGO detectors (H1 and L1). - -The simulator assumes stationary Gaussian noise with respect to the -noise spectral density (NSD) estimated from 1024 seconds of detector data -prior to GW150914 [1]. - -Following [2], the waveforms are compressed to a reduced-order basis corresponding -to the first 128 components of a singular value decomposition (SVD). +It assumes stationary Gaussian noise with respect to the detectors' noise spectral +densities, estimated from 1024 seconds of detector data prior to GW150914. The +waveforms are compressed to a reduced-order basis corresponding to the first 128 +components of a singular value decomposition (SVD). References: - [1] Observation of Gravitational Waves from a Binary Black Hole Merger + Observation of Gravitational Waves from a Binary Black Hole Merger (Abbott et al., 2016) https://arxiv.org/abs/1602.03837 - [2] Complete parameter inference for GW150914 using deep learning + Complete parameter inference for GW150914 using deep learning (Green et al., 2021) https://arxiv.org/abs/2008.03312 Shapes: - theta: (15,) - x: (2, 256) + theta: :math:`(15,)`. + x: :math:`(2, 256)`. """ import numpy as np @@ -52,16 +49,17 @@ Distribution, Joint, Uniform, - CosineUniform, - SineUniform, Sort, Maximum, Minimum, + TransformedUniform, + CosTransform, + SinTransform, ) from ..utils import cache, vectorize -labels = [ +LABELS = [ f'${l}$' for l in [ 'm_1', 'm_2', r'\phi_c', 't_c', 'd_L', 'a_1', 'a_2', r'\theta_1', r'\theta_2', r'\phi_{12}', r'\phi_{JL}', @@ -69,8 +67,7 @@ ] ] - -bounds = torch.tensor([ +LOWER, UPPER = torch.tensor([ [10., 80.], # primary mass [solar masses] [10., 80.], # secondary mass [solar masses] [0., 2 * np.pi], # coalesence phase [rad] @@ -86,49 +83,56 @@ [0., np.pi], # polarization [rad] [0., 2 * np.pi], # right ascension [rad] [-np.pi / 2, np.pi / 2], # declination [rad] -]) +]).t() -lower, upper = bounds[:, 0], bounds[:, 1] +def build_prior(b: BoolTensor = None) -> Distribution: + r"""Returns a prior distribution :math:`p(\theta)` for BBH systems. -def gw_prior(mask: BoolTensor = None) -> Distribution: - r""" p(theta) """ + Arguments: + b: An optional binary mask :math:`b`, with shape :math:`(D,)`. + """ - if mask is None: - mask = [True] * 15 + if b is None: + b = [True] * 15 marginals = [] - if mask[0] or mask[1]: - base = Uniform(lower[0], upper[0]) + if b[0] or b[1]: + base = Uniform(LOWER[0], UPPER[0]) - if mask[0] and mask[1]: + if b[0] and b[1]: law = Sort(base, n=2, descending=True) - elif mask[0]: + elif b[0]: law = Maximum(base, n=2) - elif mask[1]: + elif b[1]: law = Minimum(base, n=2) marginals.append(law) - for i, b in enumerate(mask[2:], start=2): - if not b: - continue - - if i in [7, 8, 11]: # [tilt_1, tilt_2, theta_jn] - m = CosineUniform(lower[i], upper[i]) - elif i == 14: # declination - m = SineUniform(lower[i], upper[i]) - else: - m = Uniform(lower[i], upper[i]) + for i in range(2, len(b)): + if b[i]: + if i in [7, 8, 11]: # [tilt_1, tilt_2, theta_jn] + m = TransformedUniform(LOWER[i], UPPER[i], CosTransform()) + elif i == 14: # declination + m = TransformedUniform(LOWER[i], UPPER[i], SinTransform()) + else: + m = Uniform(LOWER[i], UPPER[i]) - marginals.append(m) + marginals.append(m) return Joint(marginals) class GW(Simulator): - r"""Gravitational Waves (GW) simulator""" + r"""Creates a gravitational waves (GW) simulator. + + Arguments: + reduced_basis: Whether waveform are compressed to a reduced basis or not. + noisy: Whether noise is added to waveforms or not. + seed: A random number generator seed. + kwargs: Simulator settings and constants (e.g. event, approximant, ...). + """ def __init__( self, @@ -171,8 +175,6 @@ def __init__( self.rng = np.random.default_rng(seed) def __call__(self, theta: Array) -> Array: - r""" x ~ p(x | theta) """ - x = gravitational_waveform(theta, **self.constants) x = self.process(x) @@ -182,7 +184,7 @@ def __call__(self, theta: Array) -> Array: return x def process(self, x: Array) -> Array: - r"""Processes waveforms into network-friendly inputs""" + r"""Processes waveforms into network-friendly inputs.""" x = crop_dft(x, **self.constants) x = x / self.nsd @@ -195,14 +197,14 @@ def process(self, x: Array) -> Array: @cache def ligo_detector(name: str): - r"""Fetches LIGO detector""" + r"""Fetches LIGO detector.""" return Detector(name) @cache def event_gps(event: str = 'GW150914') -> float: - r"""Fetches event's GPS time""" + r"""Fetches event's GPS time.""" return Merger(event).data['GPS'] @@ -213,7 +215,7 @@ def tukey_window( sample_rate: float, # Hz roll_off: float = 0.4, # s ) -> Array: - r"""Tukey window function + r"""Returns a tukey window. References: https://en.wikipedia.org/wiki/Window_function @@ -227,7 +229,7 @@ def tukey_window( return tukey(length, alpha) -@cache(disk=True) +@cache(persist=True) def event_nsd( event: str, detectors: Tuple[str, ...], @@ -235,7 +237,7 @@ def event_nsd( segment: float, # s **absorb, ) -> Array: - r"""Fetches event's Noise Spectral Density (NSD) + r"""Fetches event's noise spectral density (NSD). Wikipedia: https://en.wikipedia.org/wiki/Noise_spectral_density @@ -261,7 +263,7 @@ def event_nsd( return np.stack(nsds) -@cache(disk=True) +@cache(persist=True) def event_dft( event: str, detectors: Tuple[str, ...], @@ -269,7 +271,7 @@ def event_dft( buffer: float, # s **absorb, ) -> Array: - r"""Fetches event's Discrete Fourier Transform (DFT)""" + r"""Fetches event's discrete fourier transform (DFT).""" time = event_gps(event) + buffer @@ -288,16 +290,14 @@ def event_dft( @vectorize(otypes=[float] * 7) def lal_spins(*args) -> Tuple[float, ...]: - r"""Converts LALInference geometric parameters to LALSimulation spins""" + r"""Converts LALInference geometric parameters to LALSimulation spins.""" return tuple(SimInspiralTransformPrecessingNewInitialConditions(*args)) @vectorize(otypes=[Array, Array]) def plus_cross(**kwargs) -> Tuple[Array, Array]: - r"""Simulates frequency-domain plus and cross polarizations - of gravitational wave - """ + r"""Simulates frequency-domain plus and cross polarizations of gravitational wave.""" hp, hc = get_fd_waveform(**kwargs) return hp.numpy(), hc.numpy() @@ -314,13 +314,16 @@ def gravitational_waveform( f_lower: float, # Hz **absorb, ) -> Array: - r"""Simulates a frequency-domain gravitational wave projected onto LIGO detectors + r"""Simulates a frequency-domain gravitational wave projected onto LIGO detectors. References: http://pycbc.org/pycbc/latest/html/waveform.html http://pycbc.org/pycbc/latest/html/detector.html """ + shape = theta.shape[:-1] + theta = theta.reshape(-1, theta.shape[-1]) + # Parameters m_1, m_2, phi_c, t_c, d_L, a_1, a_2, tilt_1, tilt_2, phi_12, phi_jl, theta_jn, psi, alpha, delta = [ theta[..., i] for i in range(15) @@ -357,7 +360,8 @@ def gravitational_waveform( # Projection on detectors time = event_gps(event) - angular_speeds = -1j * 2 * np.pi * np.arange(hp.shape[-1]) / duration + length = int(duration * sample_rate / 2) + 1 + angular_speeds = -1j * 2 * np.pi * np.arange(length) / duration strains = [] @@ -374,7 +378,10 @@ def gravitational_waveform( strains.append(s) - return np.stack(strains, axis=-2) + strains = np.stack(strains, axis=-2) + strains = strains.reshape(shape + strains.shape[1:]) + + return strains def crop_dft( @@ -384,12 +391,12 @@ def crop_dft( f_lower: float, # Hz **absorb, ) -> Array: - r"""Crops low and high frequencies of Discrete Fourier Transform (DFT)""" + r"""Crops low and high frequencies of discrete fourier transform (DFT).""" return dft[..., int(duration * f_lower):int(duration * sample_rate / 2) + 1] -@cache(disk=True) +@cache(persist=True) def svd_basis( n_components: int = 2**7, # 128 n_samples: int = 2**15, # 32768 @@ -397,7 +404,7 @@ def svd_basis( seed: int = 0, **kwargs, ) -> Array: - r"""Builds Singular Value Decompostition (SVD) basis""" + r"""Builds Singular Value Decompostition (SVD) basis.""" prior = gw_prior() simulator = GW(reduced_basis=False, noisy=False, **kwargs) @@ -408,7 +415,7 @@ def svd_basis( for _ in tqdm(range(n_samples // batch_size), unit='sample', unit_scale=batch_size): theta = prior.sample((batch_size,)) - theta[..., 4] = lower[4] # fixed luminosity distance + theta[..., 4] = LOWER[4] # fixed luminosity distance theta = theta.numpy().astype(np.float64) xs.append(simulator(theta)) diff --git a/lampe/simulators/hh.py b/lampe/simulators/hh.py index 722cb8a..150236a 100644 --- a/lampe/simulators/hh.py +++ b/lampe/simulators/hh.py @@ -1,23 +1,22 @@ -r"""Hodgkin-Huxley (HH) +r"""Hodgkin-Huxley (HH) benchmark. -HH [1] is a widespread non-linear mechanistic model of neural dynamics. +HH is a widespread non-linear mechanistic model of neural dynamics. References: - [1] A quantitative description of membrane current and its application to conduction and excitation in nerve + A quantitative description of membrane current and its application to conduction and excitation in nerve (Hodgkin et al., 1952) https://link.springer.com/article/10.1007/BF02459568 - [2] Training deep neural density estimators to identify mechanistic models of neural dynamics + Training deep neural density estimators to identify mechanistic models of neural dynamics (Gonçalves et al., 2020) https://elifesciences.org/articles/56261 Shapes: - theta: (8,) - x: (7,) + theta: :math:`(8,)`. + x: :math:`(7,)`. """ import numpy as np -import scipy.stats as ss import torch from numpy import ndarray as Array @@ -25,18 +24,16 @@ from typing import * from . import Simulator -from ..priors import Distribution, JointUniform -labels = [ +LABELS = [ f'${l}$' for l in [ r'g_{\mathrm{Na}}', r'g_{\mathrm{K}}', r'g_{\mathrm{M}}', 'g_l', r'\tau_{\max}', 'V_t', r'\sigma', 'E_l', ] ] - -bounds = torch.tensor([ +LOWER, UPPER = torch.tensor([ [0.5, 80.], # g_Na [mS/cm^2] [1e-4, 15.], # g_K [mS/cm^2] [1e-4, .6], # g_M [mS/cm^2] @@ -45,22 +42,17 @@ [-90., -40.], # V_t [mV] [1e-4, .15], # sigma [uA/cm^2] [-100., -35.], # E_l [mV] -]) - -lower, upper = bounds[:, 0], bounds[:, 1] - - -def hh_prior(mask: BoolTensor = None) -> Distribution: - r""" p(theta) """ - - if mask is None: - mask = ... - - return JointUniform(lower[mask], upper[mask]) +]).t() class HH(Simulator): - r"""Hodgkin-Huxley (HH) simulator""" + r"""Creates an Hodgkin-Huxley (HH) simulator. + + Arguments: + summary: Whether voltage traces are converted to summary statistics or not. + seed: A random number generator seed. + kwargs: Simulator settings and constants (e.g. duration, inital voltage, ...). + """ def __init__(self, summary: bool = True, seed: int = None, **kwargs): super().__init__() @@ -86,8 +78,6 @@ def __init__(self, summary: bool = True, seed: int = None, **kwargs): self.rng = np.random.default_rng(seed) def __call__(self, theta: Array) -> Array: - r""" x ~ p(x | theta) """ - x = voltage_trace(theta, self.constants, self.rng) if self.summary: @@ -101,7 +91,7 @@ def voltage_trace( constants: Dict[str, float], rng: np.random.Generator, ) -> Array: - r"""Simulates Hodgkin-Huxley voltage trace + r"""Simulates an Hodgkin-Huxley voltage trace. References: https://github.com/mackelab/sbi/blob/main/examples/HH_helper_functions.py @@ -192,7 +182,7 @@ def voltage_trace( def summarize(x: Array, constants: Dict[str, float]) -> Array: - r"""Computes voltage trace summary statistics""" + r"""Returns summary statistics of a voltage trace.""" # Constants T = constants['duration'] @@ -214,12 +204,15 @@ def summarize(x: Array, constants: Dict[str, float]) -> Array: # Moments x = x[..., (pad <= t) * (t < T - pad)] x_mean = np.mean(x, axis=-1) - x_var = np.var(x, axis=-1) - x_skew = ss.skew(x, axis=-1) - x_kurtosis = ss.kurtosis(x, axis=-1) + x_std = np.std(x, axis=-1) + + z = (x - x_mean[..., None]) / x_std[..., None] + + x_skew = np.mean(z**3, axis=-1) + x_kurtosis = np.mean(z**4, axis=-1) return np.stack([ spikes, rest_mean, rest_std, - x_mean, x_var, x_skew, x_kurtosis, + x_mean, x_std, x_skew, x_kurtosis, ], axis=-1) diff --git a/lampe/simulators/slcp.py b/lampe/simulators/slcp.py index 425aa0c..737f44c 100644 --- a/lampe/simulators/slcp.py +++ b/lampe/simulators/slcp.py @@ -1,52 +1,52 @@ -r"""Simple Likelihood Complex Posterior (SLCP) +r"""Simple likelihood complex posterior (SLCP) benchmark. -SLCP [1] is a toy simulator where theta parametrizes a 2-d multivariate Gaussian -from which 4 points are independently drawn and stacked as a single observation x. - -It is a non-trivial parameter inference benchmark that allows to retrieve -the ground-truth posterior through MCMC sampling of its tractable likelihood. +SLCP is a toy simulator where :math:`\theta` parametrizes a 2-d multivariate Gaussian +from which 4 points are independently drawn and stacked as a single observation :math:`x`. +It is a non-trivial parameter inference benchmark that allows to retrieve the +ground-truth posterior through MCMC sampling of its tractable likelihood. References: - [1] Sequential Neural Likelihood: Fast Likelihood-free Inference with Autoregressive Flows + Sequential Neural Likelihood: Fast Likelihood-free Inference with Autoregressive Flows (Papamakarios et al., 2019) https://arxiv.org/abs/1805.07226 Shapes: - theta: (5,) - x: (4, 2) + theta: :math:`(5,)`. + x: :math:`(8,)`. """ import torch -import torch.nn as nn from torch import Tensor, BoolTensor from typing import * from . import Simulator -from ..priors import Distribution, JointUniform, MultivariateNormal - - -labels = [f'$\\theta_{{{i + 1}}}$' for i in range(5)] - - -lower = torch.full((5,), -3.) -upper = torch.full((5,), 3.) +from ..priors import ( + Distribution, + Independent, + MultivariateNormal, + ReshapeTransform, + TransformedDistribution, +) +from ..utils import broadcast -def slcp_prior(mask: BoolTensor = None) -> Distribution: - r""" p(theta) """ +LABELS = [f'$\\theta_{{{i + 1}}}$' for i in range(5)] - if mask is None: - mask = ... - - return JointUniform(lower[mask], upper[mask]) +LOWER, UPPER = torch.tensor([ + [-3., 3.], # theta_1 + [-3., 3.], # theta_2 + [-3., 3.], # theta_3 + [-3., 3.], # theta_4 + [-3., 3.], # theta_5 +]).t() class SLCP(Simulator): - r"""Simple Likelihood Complex Posterior (SLCP) simulator""" + r"""Creates a simple likelihood complex posterior (SLCP) simulator.""" def likelihood(self, theta: Tensor, eps: float = 1e-8) -> Distribution: - r""" p(x | theta) """ + r"""Returns the likelihood distribution :math:`p(x | \theta)`.""" # Mean mu = theta[..., :2] @@ -59,23 +59,23 @@ def likelihood(self, theta: Tensor, eps: float = 1e-8) -> Distribution: cov = torch.stack([ s1 ** 2, rho * s1 * s2, rho * s1 * s2, s2 ** 2, - ], dim=-1) - - cov = cov.view(cov.shape[:-1] + (2, 2)) + ], dim=-1).reshape(theta.shape[:-1] + (2, 2)) # Repeat 4 times mu = mu.unsqueeze(-2).repeat_interleave(4, -2) cov = cov.unsqueeze(-3).repeat_interleave(4, -3) - # Normal - return MultivariateNormal(mu, cov) + # Normal distribution + normal = MultivariateNormal(mu, cov) - def __call__(self, theta: Tensor) -> Tensor: - r""" x ~ p(x | theta) """ + return TransformedDistribution( + Independent(normal, 1), + ReshapeTransform((4, 2), (8,)), + ) + def __call__(self, theta: Tensor) -> Tensor: return self.likelihood(theta).sample() def log_prob(self, theta: Tensor, x: Tensor) -> Tensor: - r""" log p(x | theta) """ - - return self.likelihood(theta).log_prob(x).sum(dim=-1) + theta, x = broadcast(theta, x, ignore=1) + return self.likelihood(theta).log_prob(x) diff --git a/lampe/train.py b/lampe/train.py deleted file mode 100644 index 6768402..0000000 --- a/lampe/train.py +++ /dev/null @@ -1,122 +0,0 @@ -r"""Training helpers""" - -import torch -import torch.nn as nn - -from torch import Tensor -from torch.optim import Optimizer -from tqdm import tqdm -from typing import * - - -def lrs(self) -> Iterator[float]: - yield from (group['lr'] for group in self.param_groups) - -setattr(Optimizer, 'lrs', lrs) - - -def parameters(self) -> Iterator[Tensor]: - yield from (p for group in self.param_groups for p in group['params']) - -setattr(Optimizer, 'parameters', parameters) - - -def collect( - pipe: Callable, # embedding, estimator, criterion, ... - loader: Iterable, - optimizer: Optimizer = None, - grad_clip: float = None, -) -> Tensor: - r"""Sends loader's data through a pipe and collects the results. - Optionally performs gradient descent steps.""" - - results = [] - - for data in loader: - result = pipe(*data) if type(data) is tuple else pipe(data) - results.append(result.detach()) - - if optimizer is None: - continue - - loss = result.mean() - if not loss.isfinite(): - continue - - optimizer.zero_grad() - loss.backward() - - if grad_clip is not None: - norm = nn.utils.clip_grad_norm_(optimizer.parameters(), grad_clip) - if not norm.isfinite(): - continue - - optimizer.step() - - return torch.stack(results) - - -def trainbar( - epochs: int, - pipe: Callable, - loader: Iterable, - optimizer: Optimizer, - **kwargs, -) -> Iterator[int]: - r"""Iterator over training epochs with a progress bar""" - - with tqdm(range(epochs), unit='epoch') as tq: - for epoch in tq: - losses = collect( - pipe, - loader, - optimizer, - **kwargs, - ) - - tq.set_postfix( - loss=torch.nanmean(losses).item(), - lr=max(optimizer.lrs()), - ) - - yield epoch - - -class PlateauDetector(object): - r"""Sequence abstraction to detect plateau""" - - def __init__( - self, - threshold: float = 1e-2, - patience: int = 16, - mode: str = 'min', # 'max' - ): - self.threshold = threshold - self.patience = patience - self.mode = mode - - self.sequence = [float('+inf' if mode == 'min' else '-inf')] - self.best_time = 0 - - @property - def time(self) -> int: - return len(self.sequence) - 1 - - @property - def best(self) -> float: - return self.sequence[self.best_time] - - def step(self, value: float) -> None: - self.sequence.append(value) - - if self.mode == 'min': - better = value < self.best * (1 - self.threshold) - else: - better = value > self.best * (1 + self.threshold) - - if better: - self.best_time = self.time - - @property - def plateau(self) -> bool: - return self.time > self.best_time + self.patience diff --git a/lampe/utils.py b/lampe/utils.py index b70eb0f..2196a79 100644 --- a/lampe/utils.py +++ b/lampe/utils.py @@ -1,66 +1,424 @@ -r"""Miscellaneous tools and general purpose helpers""" +r"""General purpose helpers.""" import numpy as np import os import torch +import torch.nn as nn -from functools import lru_cache, partial, wraps +from functools import lru_cache, partial +from itertools import islice, starmap +from torch import Tensor +from torch.optim import Optimizer from typing import * +from .priors import DiagNormal -def decorator(decoration: Callable) -> Callable: - r"""Wraps a decoration inside a decorator""" - @wraps(decoration) - def decorate(f: Callable = None, /, **kwargs) -> Callable: - if f is None: - return decoration(**kwargs) - else: - return decoration(**kwargs)(f) +def cache(f: Callable = None, /, persist: bool = False) -> Callable: + r"""Unbounded function cache decorator. + + Wraps a function with a memoizing callable that saves call results, which + can save time when an expensive function is called several times with the + same arguments. - return decorate + The positional and keyword arguments of :py:`f` must be hashable. + Arguments: + f: The function to decorate. + persist: Whether the cached values persist to disk or not. -@decorator -def cache(disk: bool = False, maxsize: int = None, **kwargs) -> Callable: - r"""Caching decorator""" + Example: + >>> @cache + ... def fib(n): + ... return n if n < 2 else fib(n-2) + fib(n-1) + ... + >>> fib(42) + 267914296 + """ - if disk: + if persist: try: from joblib import Memory except ImportError as e: print(f"ImportWarning: {e}. Fallback to regular cache.") else: memory = Memory(os.path.expanduser('~/.cache'), mmap_mode='c', verbose=0) - return partial(memory.cache, **kwargs) - return lru_cache(maxsize=maxsize, **kwargs) + if f is None: + return memory.cache + else: + return memory.cache(f) + + d = lru_cache(maxsize=None) + + return d if f is None else d(f) + + +def vectorize(f: Callable = None, /, **kwargs): + r"""Convenience vectorization decorator. + + Defines a vectorized function which takes a sequence of objects or NumPy arrays + as inputs and returns a tuple of NumPy arrays. The vectorized function evaluates + :py:`f` over successive tuples of the input arrays like the :func:`map` function, + except it uses the broadcasting rules of NumPy. + + Arguments: + f: The function to decorate. + kwargs: Keyword arguments passed to :class:`numpy.vectorize`. + + Example: + >>> @vectorize(otypes=[float]) + ... def abs(x): + ... return x if x > 0 else -x + ... + >>> abs(range(-3, 4)) + array([3., 2., 1., 0., 1., 2., 3.]) + """ + + if f is None: + return partial(vectorize, **kwargs) + else: + class vectorize(np.vectorize): + def _vectorize_call(self, func: Callable, args: List) -> Any: + if self.signature is not None: + return self._vectorize_call_with_signature(func, args) + elif not args: + return func() + else: + ufunc, otypes = self._get_ufunc_and_otypes(func=func, args=args) + + outputs = ufunc(*args) + + if ufunc.nout == 1: + if otypes[0] == 'O': + return outputs + else: + return np.asanyarray(outputs, dtype=otypes[0]) + else: + return tuple( + x if t == 'O' else np.asanyarray(x, dtype=t) + for x, t in zip(outputs, otypes) + ) + + return vectorize(f, **kwargs) + + +def broadcast(*tensors: Tensor, ignore: Union[int, List[int]] = None) -> List[Tensor]: + r"""Broadcasts tensors together. + + The term broadcasting describes how PyTorch treats tensors with different shapes + during arithmetic operations. In short, if possible, dimensions that have + different sizes are expanded (without making copies) to be compatible. + + Arguments: + ignore: The number(s) of dimensions not to broadcast. + + Example: + >>> x = torch.rand(3, 1, 2) + >>> y = torch.rand(4, 5) + >>> x, y = broadcast(x, y, ignore=1) + >>> x.shape + torch.Size([3, 4, 2]) + >>> y.shape + torch.Size([3, 4, 5]) + """ + + if type(ignore) is int: + ignore = [ignore] * len(tensors) + dims = [t.dim() - i for t, i in zip(tensors, ignore)] + + common = torch.broadcast_shapes(*( + t.shape[:i] + for t, i in zip(tensors, dims) + )) + + return [ + torch.broadcast_to(t, common + t.shape[i:]) + for t, i in zip(tensors, dims) + ] + + +def starcompose(*fs: Callable) -> Callable: + r"""Returns the composition :math:`g` of a sequence of functions + :math:`(f_1, f_2, \dots, f_n)`. + + .. math:: g = f_n \circ \dots \circ f_2 \circ f_1 + + If the output :math:`x_i` of the intermediate function :math:`f_i` is a tuple, + its elements are used as separate arguments for the next function :math:`f_{i+1}`. + + Arguments: + fs: A sequence of functions :math:`(f_1, f_2, \dots, f_n)`. + + Returns: + The composition :math:`g`. + + Example: + >>> g = starcompose(lambda x: x**2, lambda x: x/2) + >>> g(5) + 12.5 + """ + + def g(*x: Any) -> Any: + for f in fs: + x = f(*x) if isinstance(x, tuple) else f(x) + + return x + + return g + + +class GDStep(object): + r"""Creates a callable that performs gradient descent (GD) optimization steps + for parameters :math:`\phi` with respect to differentiable loss values. + + The callable takes a scalar loss :math:`l` as input, performs a step + + .. math:: \phi \gets \text{GD}(\phi, \nabla_{\!\phi} \, l) + + and returns the loss, detached from the computational graph. To prevent invalid + parameters, steps are skipped if not-a-number (NaN) or infinite values are found + in the gradient. This feature requires CPU-GPU synchronization, which could be a + bottleneck for some applications. + + Arguments: + optimizer: An optimizer instance (e.g. :class:`torch.optim.SGD`). + clip: The norm at which the gradients are clipped. If :py:`None`, + gradients are not clipped. + """ + + def __init__(self, optimizer: Optimizer, clip: float = None): + + self.optimizer = optimizer + self.parameters = [ + p + for group in optimizer.param_groups + for p in group['params'] + ] + self.clip = clip + + def __call__(self, loss: Tensor) -> Tensor: + if loss.isfinite(): + self.optimizer.zero_grad() + loss.backward() + + if self.clip is None: + self.optimizer.step() + else: + norm = nn.utils.clip_grad_norm_(self.parameters, self.clip) + if norm.isfinite(): + self.optimizer.step() + + return loss.detach() + + +class PlateauDetector(object): + r"""Creates a plateau detector for online sequences. + + Each time a new value :math:`x_t` is provided, it is compared with the current + best value :math:`x_b` to determine whether :math:`t` is the new best time step. + In the minimization mode, :math:`x_t` is considered better if it satisfies + + .. math:: x_t < x_b \, (1 - \tau) , + + where :math:`\tau \in [0, 1]` is a significance threshold. If it is the case, + :math:`b` becomes :math:`t`. The sequence is currently at a plateau if :math:`b` + has not changed for more than :math:`\lambda` patience steps, i.e. if + + .. math:: t - b > \lambda . + + Arguments: + threshold: The significance threshold :math:`\tau`. + patience: The patience :math:`\lambda`. + mode: The improvement mode, either :py:`'min'` or :py:`'max'`. + """ + + def __init__( + self, + threshold: float = 1e-2, + patience: int = 8, + mode: str = 'min', # 'max' + ): + self.threshold = threshold + self.patience = patience + self.mode = mode + + self.sequence = [float('+inf' if mode == 'min' else '-inf')] + self.best_time = 0 + + @property + def time(self) -> int: + return len(self.sequence) - 1 + + @property + def best(self) -> float: + return self.sequence[self.best_time] + + def step(self, value: float) -> None: + self.sequence.append(value) + + if self.mode == 'min': + better = value < self.best * (1 - self.threshold) + else: + better = value > self.best * (1 + self.threshold) + + if better: + self.best_time = self.time + + @property + def plateau(self) -> bool: + return self.time - self.best_time > self.patience + + +class MetropolisHastings(object): + r"""Creates a batched Metropolis-Hastings sampler. + + Metropolis-Hastings is a Markov chain Monte Carlo (MCMC) sampling algorithm used to + sample from intractable distributions :math:`p(x)` whose density is proportial to a + tracatble function :math:`f(x)`, with :math:`x \in \mathcal{X}`. The algorithm + consists in repeating the following routine for :math:`t = 1` to :math:`T`, where + :math:`x_0` is the initial sample and :math:`q(x' | x)` is a pre-defined transition + distribution. + + 1. sample :math:`x' \sim q(x' | x_{t-1})` + 2. :math:`\displaystyle \alpha \gets \frac{f(x')}{f(x_{t-1})} \frac{q(x_{t-1} | x')}{q(x' | x_{t-1})}` + 3. sample :math:`u \sim \mathcal{U}(0, 1)` + 4. :math:`x_t \gets \begin{cases} x' & \text{if } u \leq \alpha \\ x_{t-1} & \text{otherwise} \end{cases}` + + Asymptotically, i.e. when :math:`T \to \infty`, the distribution of samples + :math:`x_t` is guaranteed to converge towards :math:`p(x)`. In this implementation, + a Gaussian transition :math:`q(x' | x) = \mathcal{N}(x'; x, \Sigma)` is used, which + can be modified by subclassing :class:`MetropolisHastings`. + + Wikipedia: + https://en.wikipedia.org/wiki/Metropolis%E2%80%93Hastings_algorithm + + Arguments: + x_0: A batch of initial points :math:`x_0`, with shape :math:`(*, L)`. + f: A function :math:`f(x)` proportional to a density function :math:`p(x)`. + log_f: The logarithm :math:`\log f(x)` of a function proportional + to :math:`p(x)`. + sigma: The standard deviation of the Gaussian transition. + Either a scalar or a vector. + + Example: + >>> x_0 = torch.rand(128, 7) + >>> log_f = lambda x: -(x**2).sum(dim=-1) / 2 + >>> sampler = MetropolisHastings(x_0, log_f=log_f, sigma=0.5) + >>> samples = [x for x in sampler(2**8, burn=2**7, step=2**2)] + >>> samples = torch.stack(samples) + >>> samples.shape + torch.Size([32, 128, 7]) + """ + + def __init__( + self, + x_0: Tensor, + f: Callable = None, + log_f: Callable = None, + sigma: Union[float, Tensor] = 1., + ): + super().__init__() + + self.x_0 = x_0 + + assert f is not None or log_f is not None, \ + "Either 'f' or 'log_f' must be provided." + + if f is None: + self.f = lambda x: log_f(x).exp() + self.log_f = log_f + else: + self.f = f + self.log_f = lambda x: f(x).log() + + self.q = lambda x: DiagNormal(x, torch.ones_like(x) * sigma) + self.symmetric = True # q(x | y) is equal to q(y | x) + + def __iter__(self) -> Iterator[Tensor]: + x = self.x_0 + + # log f(x) + log_f_x = self.log_f(x) + + while True: + # y ~ q(y | x) + y = self.q(x).sample() + + # log f(y) + log_f_y = self.log_f(y) + + # f(y) q(x | y) + # a = ---- * -------- + # f(x) q(y | x) + log_a = log_f_y - log_f_x + + if not self.symmetric: + log_a = log_a + self.q(y).log_prob(x) - self.q(x).log_prob(y) + + a = log_a.exp() + + # u in [0; 1] + u = torch.rand(a.shape).to(a) + + # if u < a, x <- y + # else x <- x + mask = u < a + + x = torch.where(mask.unsqueeze(-1), y, x) + log_f_x = torch.where(mask, log_f_y, log_f_x) + + yield x + + def __call__(self, stop: int, burn: int = 0, step: int = 1) -> Iterable[Tensor]: + return islice(self, burn, stop, step) + + +def gridapply( + self, + f: Callable, + bins: Union[int, List[int]], + bounds: Tuple[Tensor, Tensor], + batch_size: int = 2**12, # 4096 +) -> Tensor: + r"""Evaluates a function :math:`f(x)` over a multi-dimensional domain split + into grid cells. Instead of evaluating the function cell by cell, batches are + given to the function. + + Arguments: + f: A function :math:`f(x)`. + bins: The number(s) of bins per dimension. + bounds: A tuple of lower and upper domain bounds. + batch_size: The size of the batches given to the function. + + Example: + >>> f = lambda x: -(x**2).sum(dim=-1) / 2 + >>> lower, upper = torch.zeros(3), torch.ones(3) + >>> y = gridapply(f, 50, bounds=(lower, upper)) + >>> y.shape + torch.Size([50, 50, 50]) + """ + + lower, upper = bounds + # Shape + dims = len(lower) -@decorator -def vectorize(**kwargs) -> Callable: - r"""Vectorization decorator""" + if type(bins) is int: + bins = [bins] * dims - return partial(np.vectorize, **kwargs) + # Create grid + domains = [] + for l, u, b in zip(lower, upper, bins): + step = (u - l) / b + dom = torch.linspace(l, u - step, b).to(step) + step / 2. + domains.append(dom) -def deepapply(obj: Any, fn: Callable) -> Any: - r"""Applies `fn` to all tensors referenced in `obj`""" + grid = torch.stack(torch.meshgrid(*domains, indexing='ij'), dim=-1) + grid = grid.reshape(-1, dims) - if torch.is_tensor(obj): - obj = fn(obj) - elif isinstance(obj, dict): - for key, value in obj.items(): - obj[key] = deepapply(value, fn) - elif isinstance(obj, list): - for i, value in enumerate(obj): - obj[i] = deepapply(value, fn) - elif isinstance(obj, tuple): - obj = tuple( - deepapply(value, fn) - for value in obj - ) - elif hasattr(obj, '__dict__'): - deepapply(obj.__dict__, fn) + # Evaluate f(x) on grid + y = [f(x) for x in grid.split(batch_size)] - return obj + return torch.cat(y).reshape(*bins, *y.shape[1:]) diff --git a/notebooks/01_npe.ipynb b/notebooks/01_npe.ipynb new file mode 100644 index 0000000..9112f6b --- /dev/null +++ b/notebooks/01_npe.ipynb @@ -0,0 +1,378 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Neural posterior estimation\n", + "\n", + "This tutorial demonstrates how to perform neural posterior estimation (NPE) with `lampe`." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "\n", + "from itertools import islice\n", + "from tqdm import tqdm\n", + "\n", + "from lampe.data import JointLoader\n", + "from lampe.nn import NPE\n", + "from lampe.plots import nice_rc, corner\n", + "from lampe.priors import BoxUniform\n", + "from lampe.simulators.slcp import SLCP, LOWER, UPPER, LABELS\n", + "from lampe.utils import GDStep" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simulator\n", + "\n", + "In `lampe`, a simulator can be any Python callable that takes a set of parameters $\\theta$ as input and returns a stochastic observation $x$ as output. The simulator we use for this tutorial is SLCP, a toy simulator which has a simple likelihood $p(x | \\theta)$ but a complex (multimodal) posterior $p(\\theta | x)$. Its five parameters are dimensionless and observations lie in $\\mathbb{R}^8$.\n", + "\n", + "To define a joint distribution $p(\\theta, x)$, we couple our simulator with a prior $p(\\theta)$, which we choose uniform over the hypercube $[-3, 3]^5$. The `lampe.priors` module provides helpers to build priors as [PyTorch distributions](https://pytorch.org/docs/stable/distributions.html). Notably, the `BoxUniform` class creates a multivariate uniform distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([-1.7524, 0.6464, -1.1893, -2.7652, -2.8696]),\n", + " tensor([ -0.5205, -6.0700, -2.3533, 2.6847, 0.2399, -10.8107, -4.5250,\n", + " 16.2529]))" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prior = BoxUniform(LOWER, UPPER)\n", + "sim = SLCP()\n", + "\n", + "theta = prior.sample()\n", + "x = sim(theta)\n", + "\n", + "theta, x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To perform neural posterior estimation, we need to get pairs $(\\theta, x) \\sim p(\\theta, x)$. If the simulator is fast and/or inexpensive, a solution is to generate pairs while training. The `lampe.data` module provides `JointLoader` to create an iterable [DataLoader](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader) of batched pairs $(\\theta, x) \\sim p(\\theta, x)$, given a prior $p(\\theta)$ and a simulator.\n", + "\n", + "The prior must be a `torch` distribution and the simulator must take and return NumPy arrays or PyTorch tensors. In our case, the simulator is compatible with PyTorch and also supports \"batching\", that is a batch of simulations can be carried through at once." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "loader = JointLoader(prior, sim, numpy=False, batched=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training\n", + "\n", + "Similar to PyTorch, `lampe` provides building blocks, such as network architecture and loss functions, that should be put together by the user to perform inference. In the case of neural posterior estimation (NPE), we have to train a conditional normalizing flow $p_\\phi(\\theta | x)$ at approximating the posterior distribution $p(\\theta | x)$.\n", + "\n", + "First, we use the `NPE` class provided by `lampe.nn` to create a normalizing flow adapted to the simulator's input and output sizes." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "NPE(\n", + " (flow): MAF(\n", + " (_transform): CompositeTransform(\n", + " (_transforms): ModuleList(\n", + " (0): MaskedAffineAutoregressiveTransform(\n", + " (autoregressive_net): MADE(\n", + " (initial_layer): MaskedLinear(in_features=5, out_features=128, bias=True)\n", + " (context_layer): Linear(in_features=8, out_features=128, bias=True)\n", + " (blocks): ModuleList(\n", + " (0): MaskedFeedforwardBlock(\n", + " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (1): MaskedFeedforwardBlock(\n", + " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (2): MaskedFeedforwardBlock(\n", + " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (final_layer): MaskedLinear(in_features=128, out_features=10, bias=True)\n", + " )\n", + " )\n", + " (1): RandomPermutation()\n", + " (2): MaskedAffineAutoregressiveTransform(\n", + " (autoregressive_net): MADE(\n", + " (initial_layer): MaskedLinear(in_features=5, out_features=128, bias=True)\n", + " (context_layer): Linear(in_features=8, out_features=128, bias=True)\n", + " (blocks): ModuleList(\n", + " (0): MaskedFeedforwardBlock(\n", + " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (1): MaskedFeedforwardBlock(\n", + " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (2): MaskedFeedforwardBlock(\n", + " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (final_layer): MaskedLinear(in_features=128, out_features=10, bias=True)\n", + " )\n", + " )\n", + " (3): RandomPermutation()\n", + " (4): MaskedAffineAutoregressiveTransform(\n", + " (autoregressive_net): MADE(\n", + " (initial_layer): MaskedLinear(in_features=5, out_features=128, bias=True)\n", + " (context_layer): Linear(in_features=8, out_features=128, bias=True)\n", + " (blocks): ModuleList(\n", + " (0): MaskedFeedforwardBlock(\n", + " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (1): MaskedFeedforwardBlock(\n", + " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (2): MaskedFeedforwardBlock(\n", + " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (final_layer): MaskedLinear(in_features=128, out_features=10, bias=True)\n", + " )\n", + " )\n", + " (5): RandomPermutation()\n", + " (6): MaskedAffineAutoregressiveTransform(\n", + " (autoregressive_net): MADE(\n", + " (initial_layer): MaskedLinear(in_features=5, out_features=128, bias=True)\n", + " (context_layer): Linear(in_features=8, out_features=128, bias=True)\n", + " (blocks): ModuleList(\n", + " (0): MaskedFeedforwardBlock(\n", + " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (1): MaskedFeedforwardBlock(\n", + " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (2): MaskedFeedforwardBlock(\n", + " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (final_layer): MaskedLinear(in_features=128, out_features=10, bias=True)\n", + " )\n", + " )\n", + " (7): RandomPermutation()\n", + " (8): MaskedAffineAutoregressiveTransform(\n", + " (autoregressive_net): MADE(\n", + " (initial_layer): MaskedLinear(in_features=5, out_features=128, bias=True)\n", + " (context_layer): Linear(in_features=8, out_features=128, bias=True)\n", + " (blocks): ModuleList(\n", + " (0): MaskedFeedforwardBlock(\n", + " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (1): MaskedFeedforwardBlock(\n", + " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (2): MaskedFeedforwardBlock(\n", + " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", + " (dropout): Dropout(p=0.0, inplace=False)\n", + " )\n", + " )\n", + " (final_layer): MaskedLinear(in_features=128, out_features=10, bias=True)\n", + " )\n", + " )\n", + " (9): RandomPermutation()\n", + " )\n", + " )\n", + " (_distribution): StandardNormal()\n", + " (_embedding_net): Identity()\n", + " )\n", + ")" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "estimator = NPE(5, 8, hidden_features=128, num_blocks=3, num_transforms=5)\n", + "estimator.cuda()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, we define the loss function to minimize. In our case, the loss is simply the negative log-likelihood $- \\log p_\\phi(\\theta | x)$ of the data." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def loss(theta, x):\n", + " log_p = estimator(theta, x) # log p(theta | x)\n", + " return -log_p.mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, similar to most neural networks, we implement the training routine as a series of stochastic gradient descent (SGD) epochs over the training set. Because `lampe` is based on PyTorch, any `torch` optimizer can be used (e.g. [SGD](https://pytorch.org/docs/stable/generated/torch.optim.SGD), [Adam](https://pytorch.org/docs/stable/generated/torch.optim.Adam), ...) and features such as gradient clipping can be easily implemented." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 64/64 [35:03<00:00, 32.86s/epoch, loss=2.6] \n" + ] + } + ], + "source": [ + "optimizer = optim.AdamW(estimator.parameters(), lr=1e-3, weight_decay=1e-3)\n", + "step = GDStep(optimizer, clip=1.) # gradient descent step with gradient clipping\n", + "\n", + "estimator.train()\n", + "\n", + "with tqdm(range(64), unit='epoch') as tq:\n", + " for epoch in tq:\n", + " losses = torch.stack([\n", + " step(loss(theta.cuda(), x.cuda()))\n", + " for theta, x in islice(loader, 2**10) # 1024 batches per epoch\n", + " ])\n", + "\n", + " tq.set_postfix(loss=losses.mean().item())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Inference\n", + "\n", + "Now that the posterior estimator is trained, we can use it to perform inference. For instance, we can inspect the posterior of an observation $x^*$. Since normalizing flows are proper distributions, we can sample directly from $p_\\phi(\\theta | x^*)$ and visualize the distribution with the `corner` function provided by `lampe.plots`. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "theta_star = torch.tensor([0.3517, -0.0883, -1.4778, 1.6406, -1.9085])\n", + "x_star = sim(theta_star).cuda()\n", + "\n", + "estimator.eval()\n", + "\n", + "with torch.no_grad():\n", + " samples = torch.cat([\n", + " estimator.sample(x_star, (2**16,)).cpu() # sample 65536 points at once\n", + " for _ in range(2**4) # repeat 16 times\n", + " ])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6gAAAOoCAYAAADcQdkoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAABcSAAAXEgFnn9JSAAEAAElEQVR4nOzdd3iV5f3H8fd9VvYgk01IgEDYEMAtCO6t4F6tCq22aluV+uuywyp0t46i1Vo7HLi3ggIqDqaMhB32Sghk75zn98c5iREJJOScPCfJ53Vd5yI55xnfxAPmk/u+v7exLAsRERERERERuznsLkBEREREREQEFFBFREREREQkRCigioiIiIiISEhQQBUREREREZGQoIAqIiIiIiIiIUEBVUREREREREKCAqqIiIiIiIiEBAVUERERERERCQkKqCIiIiIiIhISFFBFREREREQkJCigioiIiIiISEhQQBUREREREZGQoIAqIiIiIiIiIcFldwGdiTFmHxAJ7LS7FpHD9AEqLMvqbnchIiIiIiLNMZZl2V1Dp2GMKQkLC4vJyMiwu5Quwev1sn79egAGDx6Mw6EJAc3ZsmUL1dXVpZZlxdpdi4iIiIhIczSCGlg7MzIysnJycuyuo0uora3lv//9LwDXXnstbrfb5opC19ChQ8nNzdXIvoiIiIiENAVU6bDcbjc33XST3WWIiIiIiEiAaE6kiIiIiIiIhASNoEqHVVdXx3vvvQfA2Wefjcult7OIiIiISEemn+ilw6quruaCCy4AoKysTAFVRERERKSD0xRfERERERERCQkKqCIiIiIiIhISNCdS5Dh5vRa7iyo5WF5DQpSHPgmRdpckIiIiItKhKaCKtFJ5dR1Pf7qN55fuZMfBisbn05OjuPXUdK4a1wdjjI0VioiIiIh0TAqoIq3wRV4h97y4ujGYepwOEqI8FJRVk1dQzn0vr+Hdtfv461WjiYt021ytiIiIiEjHooAq0kLPL93B/72ylnqvRc+4cH54VibnD+9BhMdJSVUtzy3Zwe/f38iijQXc/K+l/PvmCUR4nHaXLSIiIiLSYahJknRYHo+Hhx9+mIcffhiPxxPUez22cAszX1pDvdfi4lE9ee8HpzF1bO/GABob7mb6aRm8cttJxIa7WLb9EN9/dgVerxXUukRERESk4zHGxBtjZh3HeXODUU+T688yxsQH8x7HooAqHZbb7eb222/n9ttvx+0O3nTafy7eyqx31wNw+6QM/nzlKGLCj3y/oT3jeOqmcYS5HMxfl8//luwIWl0iIiIi0mE9ATx4pBeMMfcaY+YYY+YaY8Yc9nJ6W298jAD6IBDUEHwsCqgiR/Hal7v55Ru5ANw5eSD3nD34mA2QstMS+PG5gwF48O117C6qDHqdIiIiItIx+EdOn7csq6iZ17AsawYwE/gggPdtCLdzD/u8kb+mWcaYOYG6b2spoEqHVV9fz8KFC1m4cCH19fUBv/6KHYe458XVANx0Uhp3TRnY4nNvPDGN7H7dKK+p5/7XcwJem4iIiIh0PP7Ry6mWZb14hNem+1+bDWBZVh4Qf6QgeZz3neEPwEX+P2cc6VjLsuYD2YG47/FQQJUOq6qqikmTJjFp0iSqqqoCeu39JVVMf2Y5NXVepgxJ5WcXZLVq6xiHw/DQ5cNxGJiXu58vdxYFtD4RERER6ZCmA98Ip36z8I2aAl8b4YwP4P0Lm1yv8CjHzaGZABtsCqgih6mt9/K9/63gQFk1g7vH8OerRuF0tH5f0wEpMVwyuhcAf5y3MdBlioiIiEiQGGOm+9eBzjHGpPubB93rXxca34ZLXwk8f6T7AfGHjaw2rD/Na0GtDbVN8T8a1rGmQ+PU3TlNRmdnAvOPctn5wNQWf1UBpG1mRA7z+/c2sHTbIWLCXDx23Viiw47/r8mdkwfy2pd7+GhjAcu3H2Rsv4QAVioiIiISGtJ+/JYBIu2u4zAV2x46v9VbKjQJoDOBQ9C4JrRhjegTwLRmzr23IQQ2YwxHDpwz8E29bbr2MxsoOtJa1Sb3mwoctCzrcX9DpQ+ABy3Lmm2M2QIsBx73fw0N953m/3xFc9e1LCvPH8zjj3b/YFBAFWliwYZ85nzk+7v7u2kj6J8U1abr9UuM4vIxvXhh2S6eWrxNAVVEREQ6q0igzO4iDhMNlB/HeVOAF/AFRGgy7RbYgm+abnMSm3vhsNHMw40BZjYNt8aY5cCyY9Q6zj8aCpCAb/ru4/7P5+D7Or6mFYEzD1/X4GaDbDBoiq+IX35JFXe/sAqAG0/sxznDegTkujed1B+A99buI78ksGtlRURERCSwLMt60R/ixgArDgt0Y4GDRzrPH0CXHuXS8UDR4U82WWu6oslz8f77H3Wv1CbhFOBMIK+hXsuyZgdg9LPdR1c0gioCeL0WP3xhFYXlNQzpEct95w0J2LWzesaS3a8by7Yf4n9LdnDXlEEBu7aIiIhIiKjAN2IZSiraeP6ZfHOd5hQOG1H0T7NN9x+/whhzJjCryZTaBkXN3Cfe/2fT46fjC5tHWyd6uCk034DpeNgy9U8BVQR4/OM8Ptl8gHC3g79dPYpwtzOg17/+xH6+gPrFDm6fNAC3U5MXREREpPPwr/U8num0oWwKTUYw/SOdDUG04bm5+PY0nW2MSbQsa6Z/9HM5kNH0Yv51nfFHuE9ew+tNnruPZta5NtWw5rXJiOuDTV6bddgIa2vFc4wGTcGgn5Klw3K73cyePZvZs2fjdruP+zordhzi9+9tAOAXFw5lQEpMoEpsdO6wHiRGecgvreaTzQcCfn0RERERCZxmtniZi2+daJ7/mKngmxLc9NyGabXN7CNadPjz/uPzGp73N2J68Fijp/7Ov/f5w+l0fGGy4d5T8K2XPS4NQfoIo8BBpxFU6bA8Hg/33HNPm65RVFHD9/+3kjqvxfnDe3DVuD4Bqu7rPC4HF4zowb8+285rK3czKTMlKPcRERERkYCYgr9JkDHmXnyjoQ8eFkbPBOZBY6Db0uTjhGbC3Qv+az9+2PPTgJnGmCKg8BidgJteayxfhdMzgVn+br5FlmUdfo/WmMLRt6EJGgVU6bLqvRY/eP5LdhdVkpYYyYOXD8eY1u932lIXj+7Fvz7bzns5+ymvriOqDdvXiIiIiEhQnYmvQdLRguI8vprum81XHXfn0vz03Dn4pg1/LTz6t3yZ0ZoC/SOvh59zzGnBLXQlvlrbnab4SodVX1/P0qVLWbp0KfX19a0+/w/vb2DBhgLCXA4evmYMseHHP024JUb3iadfYiSVtfXMy90f1HuJiIiISJuMwT862hz/aOpy/96lM4Ep/um5M5qbntuw92gz039Dgn8EOP3wqcvtRQFVOqyqqirGjx/P+PHjqapq3fYtr6/aw6MLfdPyZ10+gmG94oJR4tcYY7h4ZE8AXvtyd9DvJyIiIiKt1xDQOPYepFiW9bhlWTPwj7ZaljWzBes2Z2DT6GQLzSJwI7GtpoAqXc7SbQe5e65vv9Ppp6Vzyehe7XbvC/0BdfHmQkqratvtviIiIiJybP6Rzbn+T+8LxkinP8DO9I+2hhR/46V5djRHaqBFcNKl5BWUMf2ZZdTUeTl7aCozzxncrvcfkBJNenIUeQXlLNhQwEX+wCoiIiIi9vMHszOPeWAT/hHXpa28zwp/Q6TWCvbI5nw7wyloBFW6kANl1dz0z6UcqqhlZO84/nzlaJyO4DVFOhJjDOcM7Q7Ae2v3teu9RURERCTwLMsqOp71mscTBIMdHu0Op6CAKl1EVW09tz6zjB0HK+iTEME/bhxHhMdpSy1n+wPqgg35VNW2vrmTiIiIiEhnpYAqnZ5lWdz38hpW7igiLsLN098aT3JMmG31jOgdR4+4cCpq6vlk0wHb6hARERERCTUKqNLpPfnJVl5ZuRunw/DotWPISI62tR5jTOMo6vx12m5GRERERKSBmiRJh+V2u/nFL37R+PGRrNhxiIfeWQ/Azy/I4uQBSe1W39FMHpLC059u44P1+Xi9Fo52XgsrIiIiIhKKFFClw/J4PNx///3Nvl5cWcv3/7eSOq/F+SN6cMOJ/dqvuGMY3z+BKI+TgtJq1uwuZmSfeLtLEhERERGxnab4Sqf1mzdz2V1USd+ESB66bDjGhM4oZZjLyWmDkgH4QNN8RUREREQABVTpwLxeLzk5OeTk5OD1er/22ofr9zN3+S6MgT9eMZKY8CNPAbbT5CGpAMxfl29zJSIiIiIioUFTfKXDqqysZNiwYQCUlZURFRUFQElVLfe9vAaAW07pT3Zagm01Hs2kzGSMgdy9JewtrqRHXITdJYmIiIhICDLGzGry6YOWZRUd4ZjpQIZlWTPbrbAgUECVTmf2u+vZX1JNWmIkPzor0+5ympUYHcboPvGs2FHEgvUFXDOhr90liYiIiLSJMSbR7hoALMsqbMv5xpgpwDRgC5ABzLUsa35rjznCde8FxgFLgaLDXj5oWdaLRzhnOhBvWdYMY0w8sNwfWOdblpVnjEkHZgDTgf6t/VpDjQKqdCrLth3kP5/vAOC3lw0n3O20uaKjm5SZwoodRXy4Pl8BVURERCQEGGOmArMsy8po8txyY8zMhgDakmOaMQ6Y6n8crrmRzxnAgwCWZRUZY160LOtxY8xUfx15wBjg1iONrHY0WoMqnUZNnbdxau8V2b05KSM0tpQ5mkmDUwBYvPkA1XX1NlcjIiIiIsATwJzDnnsemNXKY5rTzbIs0/AAugGPW5Y1u5njx+ALoQ0KASzLerHJOXlHGn3tiBRQpdOYs2gLm/LLSIr28H/nDbG7nBYZ2jOW1NgwKmvr+SLvoN3liIiIiHRp/umy8Xxz+m0eMMYYE9+SY45yi+ePMMo5i+ZHTxuu27SpSuM0av+97rMsa8ZRzu9QFFClU9h2oJy/LdgMwM8uyCI+0mNzRS1jjGFSpm8U9cP16uYrIiIiEqKK/H+mt+WYw0c5/etL5xxjau78w64Z3+TjucCtRzm3w1FAlU7h/tdzqKnzctqgZC4a2dPuclqlYZrvgg35WJZlczUiIiIiXZdlWXn4gmb8YS+N8f+Z3pJjWnIv/+jnWMuyVhzj0FnANP/o7XR8obSh4dK8FpzfoSigSofldru5++67ufC6GSzZUUy428EDlwzDGGN3aa1y8oAk3E7D9sIKth4ot7scERERka5uJr7GRE2NO45jjmUW/rB5NP5APA24AlhmWdZ8Y8wY4MyGNagN4dXfNKlDUxdf6bA8Hg//d/8DnPGHhZiKWn4wZRB9EiLtLqvVosNcTOifyCebD7BgQwHpydF2lyQiIiLSZfk75B40xszBt4VMIjAPX+fdFS095mj8o6fTaVlTJfxTgB9v8tQT+EJrw7U+ACYD6caYe4/ScCnkaQRVOrTZ763nUEUtg7vH8O1TOu62TxMzkwFYoHWoIiIiIrbzd8idYVnWbMuyZuJviuQfzWzxMUcxxX+Nlhz7Nf5Q/GCTcxv2RC3yT/cNib1oj5cCqnRYy7cV8u95y6gr3s8vL8rC7ey4b+eGdahfbC2kvLrO5mpEREREui5jzBxjzOFTb6+kSafdlhxzDK2dDtxw36lAwmHNlrLxjeI2WOqfAtwhddyf6KVL83otfv7ySnb//WZ2//1mhqVG2F1Sm6QnRdEvMZLaeotPNh+wuxwRERGRriwB33RdoLEZUZ5lWY+35hhjTLoxZnkzYTGdb25Tc1RNtpSZdthLh+9VmNDaa4cSBVTpkF5ftYc1u4rtLiNgmm43s3CDpvmKiIiI2OhW4ExjzCxjzCyAI4TClhwTjy+IJvBNB4FlrayruS1l5gBnNvl87PFMHQ4VapIkHU5VbT2z3l1vdxkBN2lwCk9/uo0F6wuwLKvDdSMWERERsSyr0O4a2srfkOjwsHk8x6wAujXz2uEdgI/KGDOFZraUsSzrRf9obUPDpRY1XgpVCqjS4fzr023sLa6iZ3w4O+0uJoAm9E8g3O1gX0kV6/eVMqRHrN0liYiIiEgIsCxrPjD/KK932K69h9MUX+lQSqtqeWyRbw347ZMG2FxNYIW7nZyckQTAh+rmKyIiIiJdkAKqdCj/+HgrRRW1pCdHcdHInnaXE3AN3Xy1DlVEREREuiIFVOkwiitqeeqTrQD86MxMXB14W5nmNOyHunz7IYoqamyuRkRERESkfWkNqnQYTy3eSml1HYO7x3DusO7U1tZw2223AeBydY63cu9ukQxKjWbj/jI+3nSACzvhKLGIiIiISHM6x0/10umVVNXy1GLf6On3zxiIw2EICwvjkUcesbmywJuUmcLG/WUs2JCvgCoiIiIiXUrnmyMpndK/Fm+jtKqOgSnRnDusu93lBNVE/36oizYU4PVaNlcjIiIiItJ+FFAl5JVX1/Gkf/T0e2cMwOHw7Q9qWRYFBQUUFPj2De0sstO6ER3morC8hjW7i+0uR0RERESk3SigSsj77xfbKaqopX9SFBeM+GrKa0VFBSkpKaSkpFBRUWFjhYHldjo4ZYBvu5kF6uYrIiIiIl2IAqqEtKraeh7/yDd6etvEDJz+0dPObtJgXzffBRsKbK5ERERERKT9qEmShLTnluzgQFk1veIjuGR0L7vLaTenD/KtQ129q4jCsmoSo8NsrkhERERE7GKMmdXk0wctyyo6wjHTgQzLsma2W2FBoIAqIau6rp6/L8oD4LsTM3B3wn1Pm9M9LpzB3WNYv6+Ujzcd6FLhXERERDouY8zpdtcAYFnWoracb4yZAkwDtgAZwFzLsuY3eT0dmAs8CMwH0oEZwDzLsl48ynVbfZ4/eMZbljXDGBMPLPcH1vmWZeX5rzkDmA70b8vXHQq6zk/80uG8uHwX+0qq6B4bzrTs3naX0+4auvku1DpUERERkXZjjJkKzLEsa4ZlWbMty5oBzPKH1qbG4Aubh4DlAEcLp204bwYwz39cEfCiZVmPA2OMMff6rzcGuPVII6sdjUZQJSTV1Hl5bOEWAGacnk6Yy2lzRe1vUmYyf1+0hY82HcDrtRq7F4uIiIhIUD2Bb4SzqeeBWcDYJs89jj9g4h/NbOH1W3veGKDpMYXwVaj1B+q8FobjkKeAKiHp5RW72HWokuSYMK4e39fucmwxpl83YsJcHCyvYfXuYkb1ibe7JBEREZFOzT9dNh4oOuylPHwjlvFNRimX+0cyW6u15+UBCU0+T2z4wD/l9z7LssYeflJHpYAqIaemzsvDCzYD8J3TMwh3H3n01OVyceONNzZ+3Nm4nQ5OGZjEO2v3sXBDvgKqiIiIiH2K/H+mAysanjTGjAGy8Y1gzj/CeUfUyvMa1qo2iG/y8Vzg1pbetyPQGlQJOU1HT6+d0PzoaVhYGE8//TRPP/00YWGds8vtxEzfdjOLNmq7GREREZFg80+3LeLrIRB802zh60FxBpDQMBpqjNniH4E9ltaeNwuYZoyJ9zdMmus/7158zZVWHOXcDkcBVUJKTZ2Xv33oGz2dcVp6s6OnXcVpg3wB9cudRRwqr7G5GhEREZEuYSa+ENnUuKaf+IPs5IbRT/+f8/GHx+Ycz3n+c6YBVwDLLMua7x+BPdOyrNngm+prjJnuX4/aoSmgSkh5cfkudhf5Rk+vO6HfUY+1LIvy8nLKy8uxLKudKmxfPeIiGNw9BsuCjzcfsLscERERkU7PP7I50xgzxxhzr39Ll3n+l1c0Oa7osFOX41+neozrt/o8y7KKLMt6vMlo6RP4Q7T/vA+AF4A8/8hqh6WAKiGjuq6ehz/cBMBtE5tfe9qgoqKC6OhooqOjqaioaI8SbXG6fxRV282IiIiItA/Lsl5sss3MTPyNkxo67vqn5U5v5vSEZp4/7vMOu8Yc4MEm3X8b9kQt8gfYxObPDn0KqBIyXli2iz3FVaTGdt3OvUdyun8d6kcbfdvNiIiIiEjw+EdOD59yeyW+qb9NHb49TAZNQuxRHO95DVvKJBy2pUw2sKXJ50v9U4A7JAVUCQlVtfU84l97evukAV1+7WlT2f0SiPI4OVBWTe7eErvLEREREensEvhqSm9DM6K8w7aGmUOToOmfZjudJh11jTHpxpjlh4XFY57XnCZbykw77KWDR6i/6FjXC1Wdb28O6ZCeX7qTfSVV9IgL58pxfewuJ6R4XA5OGpDEvNz9LNpYwLBecXaXJCIiItKZ3Qo8YYzJ8H9eeHgotCxrtn99aga+MJgOTDtsy5h4//MJrTyvOc1tKTMH3whvQ4Aee5z7s4YEBVSxXVVtPY8s+Gr0NMyl0dPDnT4omXm5+1m4IZ/bJw2wuxwRERGRI7Isa5HdNbSVv4nR4aOURzpu9jFeXwF0a+15R2KMmUIzW8pYlvWif7R2lv+pWYcf05EooIrt/vP5dvJLq+kVH8EV2Ro9PZKGRkkrdhRRXFlLXITb5opEREREpL002Y6muddbHXpDldagiq3Kq+t4bKFvTfcdkwfgcekteSR9EiLJSI6i3mvxqbabEREREZFOSiOoYqt/fbaNwvIa+iVGctmY3q061+l0MnXq1MaPO7uJmSlsKdjKwg0FnDu8h93liIiIiIgEnAKq2Ka4spY5i3xNzO6cPBC3s3Wjp+Hh4cyde3gH8M7r9EHJPPnJVhZuzMeyLIwxdpckIiIiIhJQmk8ptnniozyKK2sZlBrNxaN62V1OyBvfP4EIt5P9JdWs31dqdzkiIiIiIgGngCq2KCit5qnFWwH40VmZOB0aDTyWcLeTkzISAViwId/makREREREAk8BVWzxtw83UVFTz8jecZyVlXpc1ygvL8cYgzGG8vLyAFcYmiYOTgFg4foCmysREREREQk8BVRpd1sPlPO/L3YA8ONzh2gtZStM9G83s3zHIYora22uRkREREQksBRQpd39/r0N1HktJmUmc6J/yqq0TJ+ESAakRFPvtfh4k0ZRRURERKRzUUCVdrV8+yHeWrMXY2DmuYPtLqdDmpTpG0VduEEBVUREREQ6FwVUaTeWZfHrN3MBuGJsHwZ3j7W5oo5pUqZ/HeqGArxey+ZqREREREQCR/ugSrt5Y/VevtxZRKTHyY/OGmR3OR1WdloCUR4nB8qqydlTwvDecXaXJCIiIgKAMeY2u2sAsCzrUbtrCCRjzKwmnz5oWVbREY6ZDmRYljWz3QoLAgVUaReVNfU89PY6AL5zegYpseE2V9RxeVwOThmYxHs5+1mwIV8BVURERCQIjDFTgXFAof+pFZZlzW/y+hRgjP/TRKDQsqzZLbjuvU0+HQfkHS1U+oNnvGVZM4wx8cByf2Cdb1lWnjEmHZgBTAf6t/gLDFEKqNIu5ny0hT3FVfSKj2D6aekBuabT6eS8885r/LgrmZSZ0hhQ75g80O5yRERERDoVY8wcoKghOPoD4Rwgw//5FCC9aSA1xkw3xsw6Rtic5T9vWpPnDhljvvbcYWYADwJYllVkjHnRsqzHjTFT/SE6D19QvvVII6sdjQKqBN3uokr+vmgLAP933hDC3YEJk+Hh4bz11lsBuVZHM9G/DvXLnUUUllWTGB1mc0UiIiIinYM/fF5hWVa3Jk8/Dyxt8nljaGzgD43LW3CLw0drDh7huabG4AuhDQr993vRX+9UfKOwL7bg3iFPTZIk6B54K5eqWi/j+ydw3vDudpfTKXSPC2dw9xgsCz7ZfMDuckREREQ6k1nAC02fsCxrxREC4BP+KbdAY7DN4ygsy5ppWdbYJufE4wunzx/ltDwgocnnjfs0+s+/z7KsGUe7b0eigCpBtXjzAd5esw+HgV9eNBRjjN0ldRoTm3TzFREREZGAGQNsMcbca4yZZYyZc9i6UfCNno4BDvmPm4JvVPXWlt7EHy6fAF48xtrV+Xx9hDW+ycdzW3PPjkBTfCVoauu93P96DgA3nJjGkB6B3VamvLyclBRfSMvPzycqKiqg1w91pw9K5u+LtvDRRt92Mw6Hwr+IiIhIW/gbDgFcCUxuWNNpjJlnjElsWF9qWdYKY0wGsBzfiCv4OugWtfA+9+Jbz5rOYVOFj2AWMMcY8wJwBb5Q2nCNeZZlrWjhl9chaARVguafi7eyKb+MxCgPPzgzONvKVFRUUFFREZRrh7qx/boR5XFSWF5Dzp4Su8sRERER6UyWHRY25wD3Nkzp9f85B5jpf4Bv1HV6Sy5uWdZs/7TcyfimCs86yrF5wDR84XSZZVnzjTFjgDMbRl6NMfH+Jk1TW/E1hiQFVAmKvcWV/Hn+JgB+fO5g4iLcNlfU+XhcDk4ekATAoo35NlcjIiIi0ikc9P+55bDni/x/Zvv//ACYaVnW4/6Q2A3fVNw5TdelHos/BD+OL/w22yjJsqwi/70aRkufwDeluCEsf4Bv3WzeEaYjdygKqBIUv3lzHRU19Yzt143Lx/S2u5xO6/TMZEDrUEVEREQCoSVTdP1BMr7p1Fp/gDwTX0OjKUc5d/kRRjkb9lkdc/jxzVxjDvCgf2QVfFOA5/trWEGTJkodkQKqBNyijQW8tWYvDgO/unio1kYG0WkDfQH1y51FlFXX2VyNiIiISKfwODDusOfi/X8u46tR1iNZQTOdfP3Bdgxf78gLXwXKY64l9YfbhMM6Cmfz9RHfpf4pwB2SAqoEVFVtPT9/bS0AN53Un6E942yuqHPrkxBJn4QI6rwWS7ce7d9KEREREWmhWcCUw6bqzsA3pbfIP8qad/h604Ypug0jq8aYdP+I6Rj/83n4wu/8w+43HXi8yYjoETXZUmbaYS8d/kNgAl9NSe5w1MVXAurRBZvZXlhBamwYPzwrOI2R5OtOSk/i+YM7+XTLASYNTrG7HBEREZEOzbKsPGPMWHzNi/Lwddqda1nW402OOdO/vcwcvgqDhYeFx3j/uQlNzpvhPy/Df146/rWsLSituS1l5uDrOtxwjbEtvF5IUkCVgNmcX8Zji3yzC35x4VCiw4L79nI4HJx++umNH3dVJw1I5PllO1m8ufDYB4uIiIgEkWVZj9pdQyA06Zx7tGOOtndpw0hqt9aedyT+fVaPuKWMZVkv+kdrGzoBN9sRuCNQQJWAsCyLn766htp6i0mZyZw7rHvQ7xkREcHChQuDfp9Qd1KGr5Nv7t4SDpXX0C3KY3NFIiIiIhJIlmXN55tTg5u+3urQG6q67rCTBNTcZbv4PO8g4W4Hv7p4GMaoMVJ7SY4JY1BqNACf5WkUVUREREQ6LgVUabOC0moeeHsdAD88cxB9EiJtrqjraRhF/VwBVUREREQ6MAVUabNfvpFDcWUtw3rF8u2T+7fbfcvLy0lOTiY5OZny8vJ2u28oyk7zLW9Yvv2QzZWIiIiIiBw/rUGVNnk/Zx9vrt6L02F46LIRuJzt+zuPAwcOtOv9QlV2P19zuHV7Syirrgt6gyoRERERkWDQCKoct5KqWn7m3/P01lPTGdZLe57apXtcOL3iI/BasGpnkd3liIiIiIgcFwVUOW6/fWsd+0uq6Z8UxV1TBtpdTpc3tp9vmu+ybZrmKyIiIiIdkwKqHJfFmw/w3NKdADx02XDC3U6bK5KGdajLth+0uRIRERERkeOjgCqtVlFTx49fXg3A9Sf0Y0J6os0VCcCYvr6A+uWOIuq9ls3ViIiIiIi0ngKqtNrsdzew82AlPePCufecTLvLEb/B3WOI8jgpra5jU36p3eWIiIiIiLSaAqq0ytJtB/nXZ9sAePDyEcSEu22rxeFwkJ2dTXZ2Ng6H3soup6OxUdWaXcU2VyMiIiIi0nr6qV5arLKmnntfXI1lwRXZvTl9ULKt9URERLB06VKWLl1KRESErbWEioaAmrOnxOZKRERERERaTwFVWmz2e+vZeqCc7rHh/OT8LLvLkSMY3jCCulsjqCIiIiLS8SigSot8nlfIPxdvA+Chy4cTF2Hf1F5p3rBesQDk7ilRoyQRERER6XAUUOWYSqtq+dELqwC4MrsPEzNTbK7Ip6KigrS0NNLS0qioqLC7nJDQPymaSI+Tytp68grK7C5HRERERKRVFFDlmH75Ri67iyrpkxDBzy4Mnam9lmWxfft2tm/fjmVptBDA6TBk9fCNoq7do2m+IiIiItKxKKDKUb21ei8vLt+Fw8CfrhhFdJjL7pLkGL7q5KtGSSIiIiLSsSigSrN2F1Vy38urAfjuxAyy0xJsrkhaoiGgagRVRERERDoaBVQ5orp6L3c9t5KSqjpG9YnnrimD7C5JWqihUdK6PSWa+iwiIiIiHYoCqhzRH+dtZOm2Q0SHufjLVaNwO/VW6SjSk6JxOQyl1XXsLa6yuxwRERERkRZT6pBvWLAhn0cXbgF8W8r0S4yyuSJpDY/LQXqy77/Zhn2lNlcjIiIiItJyCqjyNTsPVnDXc18CcN0JfblgRE97CzoKYwxZWVlkZWVhjLG7nJCS2d03zXfDfgVUEREREek41JJVGlXW1POd/yynuLKWkX3i+dkFobOlzJFERkaSk5NjdxkhKTM1mjfQCKqIiIiIdCwaQRXAt6fovS+tJmdPCQlRHh67dgxhLqfdZclxahxBVUAVERERkQ5EAVUAeGTBZt5YtQeXw/DYtWPoGR9hd0nSBpmpMQBsLiijrt5rczUiIiIiIi2jgCq89uVufv/+RgB+dfEwJqQn2lxRy1RUVDB06FCGDh1KRUWF3eWElN7dIoj0OKmp87KtUN8bEREREekYtAa1i1uy9SD3zF0NwC2n9OeaCX1trqjlLMsiNze38WP5isNhGJgaw6qdRZrmKyIiIiIdhkZQu7AN+0q55V9Lqan3clZWKvedN8TukiSAMlOjAdiwr8TmSkREREREWkYBtYvadaiCG59aQklVHWP7deMvV43G6dBWLZ3JoCbrUEVEREREOgIF1C7oQFk1Nzy5hH0lVQxIiebJG7OJ8Khjb2cz0B9QN+1XQBURERGRjkEBtYspqarlxqeWkHegnF7xEfz75vHER3rsLkuCYECKb4rv1gPlaIWuiIiIiHQECqhdSEVNHd/+51Jy9pSQGOXh3zePp0ectpPprHrGhRPlcVLntajVVjMiIiIi0gGoi28XUVVbz63PLGPZ9kPEhrv4980TSE+OtrusNjHG0K9fv8aP5euMMQxIiWbVrmJq6hRQRURERCT0KaB2AdV19Xz3P8tZvLmQKI+Tp789nqyesXaX1WaRkZFs27bN7jJC2oCUGAVUEREREekwNMW3k6uqrec7/17Ogg0FhLsdPHXTOMb07WZ3WdJOBvq3mlFAFREREZGOQCOonVhlTT3f+c9yFm30h9MbxzEhPdHusqQdDfQ3SqrRGlQRERER6QA0gtpJlVbVctM/l7BoYwERbidP3TSOkwYk2V1WQFVWVjJu3DjGjRtHZWWl3eWEpIEpvq1mNIIqIiIiIh2BRlA7ofzSKr7l79YbE+biqW+NY1xagt1lBZzX62XZsmWNH8s39eoWQZjLgaV9ZkRERESkA1BA7WQ255fyraeXsvNgJYlRHp7+1niG946zuyyxidNhyEiOZqvdhYiIiIiItICm+HYiCzbkc+kjn7LzYCV9EyJ56bsnKZwKf7tmNOnJUXaXISIiIiJyTBpB7QTqvRZ/nr+RhxdsxrJgfFoCj103hsToMLtLkxCQkRyN06F9YkVEREQk9CmgdnDbDpTzo7mrWL79EADXTujLzy/MIszltLkyERERERGR1lFA7aDq6r08tXgrf5q3icraemLCXPzm0mFcPKqX3aWJiIiIiIgcFwXUDmjptoP8/LUc1u0tAeCkjER+N20kveIjbK6s/SUlda6tc0REREREujIF1A5kR2EFs99bz5ur9wIQF+HmJ+cPYdrY3hjT9dYYRkVFUVBQYHcZIiIiIiISIAqoHcC2A+X8fdEWXly+izqvhTFwZXYf7j1nMAlRHrvLExERERERCQgF1BBVWlXLh+vzeXnFbhZt/GqU8NSBSdx37hCyesbaWJ2IiIiIiEjgKaCGgPLqOrYXVrCloIy1e4pZvu0Qq3YVUVtvNR4zMTOZ700aQHZago2VhpbKykrOPfdcAN555x0iIrreGlwRERERkc5EAbUd1NV7mb9uP0u2HmLrgTIOVdRSXl1HRU09RRU1lNfUH/G89KQozhveg2nZvemXGNXOVYc+r9fLokWLGj8WEREREZGOTQE1yObl7uf+13PYXVR51OO6RbpJS4oiq0csI3rHcWJ6En0SIrpk8yMREREREemaFFCD6IWlO/nxy6vxWpAQ5eGikT0ZlBpDUrSH6DAXUWEuYiPcJMeEER2m/xQiIiIiItK1KRUFybzc/dz70mrA13H3lxcPJdzttLkqERERERGR0KWAGgRFFTXc9/IaAK6d0JffXDJMU3VFRERERESOwWF3AZ3Rr97M5UBZNRnJUfzsgiyFUxERERERkRbQCGqAVdV6eXnFboyB300bqWm9QRYZGWl3CSIiIiIiEiAKqAFWWF5NPHDZ6N6M6dvN7nI6taioKMrLy+0uQ0REREREAkRTfAOsoroet9Nw15SBdpciIiIiIiLSoSigBsHV4/vSJ0FTT0VERERERFpDATXAwt0OvjdpgN1ldAlVVVWcf/75nH/++VRVVdldjoiIiIiItJHWoAZYn4RIUmLD7S6jS6ivr+ftt99u/FhERERERDo2jaCKiIiIiIhISFBAFRERERERkZCggCoiIiIiIiIhQQFVREREREREQoICqoiIiIiIiIQEY1mW3TV0GsYYL2DCwsLsLqVLsCyLmpoaADweD8YYmysKXdXV1Q0f5tpZh0gz+gAVlmV1t7sQERERsZcCagAZY7wej8fEpfahrLqO5JgwnI6OFZqKKmopq6oDwO00RHicRHlcRHichFr+syyL4uJiAOLi4gIaUL1e2FZYjmX59raNCnMRFeYizNUxJx3k5uYSFhZGRkaG3aV0SMF8rwls2bKF6urqUsuyYu2uRUREROylfVADa133PmlZZuofiQRum5jBaYOS7a6pVd7L2ceC9flsP1hB099dGLeTUwclcVZWKqcMTCbC7bSvyHawOb+Mn766hnV7SxufqwN6JERw6aheTMvuQ5+ESPsKbKXw8HAyMjLIycmxuxSRbxg6dCi5ubk77a5DRERE7KcR1AAyxuTE9uif1e2Gv3HOsO7cdFKa3SUdt4qaOnL3lPDlziJW7CjiYHlN42sel4NJmSmcNTSVUwcmEebqvGF1f0kVizYW8MmmA3yRV0hVnbfxtXFp3bhgRE/OGJwS8mFVAVVCmT+g5lqWNdTuWkRERMReCqgBZIzJcSf2zep5y6P85apRpMaG211SQFiWRd6Bcj7fUsjnWw9SUNq4npHYcBcXjOjJFeP60D8pql3rqqur44N57wMw+cyzcLmCOyGgoqaORRsLeHXlHr7IK6Tp35wRveM4f3gPLhvTm+SY0FuDrIDaNnV1dbz33nsAnH322UF/r3U1CqgiIiLSQAE1gBoC6vh7/snvp420u5ygaAirn20p5NMthV8bWT1tUBIzTstgWK+4dqmlvLycXsndANhdcIioqPYLyPuKq3g/1zcd+sudRXj9f43CXQ6uO6EfPzxrEJGe0AkxCqhtU15eTnR0NABlZWXt+l7rChRQRUREpEHo/ATdifTuFmF3CUFjjCEjOZqM5GiuGd+X1buLmZe7nxXbD/HRxgN8tPEAF43qyV2TB5IYHXojiYHSPS6cG05M44YT0ygsr+aDdfm8unI3OXtK+McnW1m+4xBP3TiOblEeu0sVEREREekwOmZL0hCX0EVCicNhGNUnnnvOzuQPV4zk1IFJALz+5R4uengxn2wqsLnC9pEYFcYV2X347y0T+OvVo4kNd7FyRxHT5nxGcWWt3eWJiIiIiHQYCqhBEB3W9Qame8ZHcPukAfz6kqH0TYikrLqO2/+3kic+yqOrTCM3xnD6oGSe/vZ4UmLC2Jxfxq/f1LajIiIiIiIt1fWSVDvozF1tj2VgSgwPXDqMf3+2nfdz9/Pwgs3kHSjn/ouyusz3JSM5mtlTR/Ctfy7lxeW7uGpcH7LTEuwuq8sor65j9a5iNheUUVBSRU29RWyEi97dIhneK460xEjtYyoiIiISohRQg8Dl7No//LqdDr59Sn/6JETyz8VbeXvNXnYfquBPV47q1OtSmxrdtxsXjuzJ66v28NKK3QqoQeT1Wny5q4iF6/NZtOkAa3cXU+9tftQ+KdrDSRlJTMxM5ozBKcRHdo0p+SIiIiIdgQJqEHTtePqVM7NS6REXzh/nbWTVrmKunPM5D14+nHFdJKxdMKIHr6/aw9tr9vKbS4bhdOidEUg5e4p5ecVu3ly9h/0l1V97rVd8BJndY+gZH47H6aSoooatheXk7CnhQFkNr6/aw+ur9uB0GM7KSuVbJ/dnfP+u8b4UERERCWUKqBJUw3rF8ZtLhvHHeRvZdaiSW59Zxi2n9GfG6Rm4nW1bAu3xePjdH//S+HGoGZvWjZhwF8WVtazaVcSYvt3sLqnDq/davL1mL08t3srKHUWNz0eHuTg9M5mJg5I5aUASveKP3Em7uq6eL3cU8dGmAj5Yl8/6faW8s3Yf76zdx9lDU/nZBVn07hb5jfM8Hg8PP/xw48ciIiIiEhzaBzWAGvZBve+ptzh3WA+7ywkpVbX1PL14Gws3+jr7DkqN5teXDGNw91ibKwuue19czXs5+7gyuw+zpo6wrY6Ovg+qZVm8tWYvf5y3kbyCcgDcTsNZWd25dHQvTh2UdFxrnNfvK+HpxduYu3wX9V6L6DAXD1w6jItH9Qr0lyBHoX1QRUREpIG6+AaB12t3BaEn3O3kOxMz+MGUgUSHudi4v4xrHv+Chz/cTHVdvd3lBc01E/oC8PLKXWzcX2pzNR3Thn2lTP37Z3zvfyvJKygnLsLNnZMHsvjHZ/DItWOYkpV63A24BneP5aHLR/D2HaeS3a8bZdV13Pncl/z4pdVU1Xbe96WIiIhIqFJADYKjNWjp6iakJ/KHK0YyPi2BesviiY/zuOLvn7Fk68FWX6u+vp6PP1rExx8tor4+NMPEqD7xnDowidp6ix+9sIraev32oqW8XotHFmzmgr99zPLth4hwO7lrii+Y/uDMQaTEhAfsXpndY3hu+gncccYAjIHnlu7kskc/ZUtBGeB7ry1cuJCFCxeG7HtNREREpDPQFN8Aapji+4O/v8GlYzRF8Ggsy2LJ1oP8c/E2iiprAV9ToXvOzmxxV9Xy8nJ6JfvWde4uOERUVFTQ6m2LgtJqLn10MaVVddx8Sn9+dkFWu9fQ0ab4FlfUctfzK1mwwTcl/MysVH598TC6xwUulDbn400F3PnclxwsryHc7eAn5w3hkmFJxMbGAFBWVhay77WOSlN8RUREpIFGUIOgTnN8j8kY0ziaemZWKgZ4c/VeLnv0U+av2293eQGVHBPG/Rf5fu5+8pOtvLh8l80VhbadByu47LHFLNhQQJjLwe+mjuDx68e2SzgFOHVgMm/fcSqnDEiiqtbLz17L4bonv2iXe4uIiIh0dQqoQaApvi0XFebi5lP686tLhtIrPoLC8hp+9MIqZr60mkMVNXaXFzBThqQy/bR0AP7v5TWs2VVsc0Whad3eEi577FO2FJTTIy6cl757EtOy+2BM+27R0z0unGe+PZ77L8wiyuP8WsdgTdMWERERCR4F1CCoVUBttYEpMTx42XAuHtUTY+Ddtfu44K+f8MaqPXSWaejfnZjBaYOSqKn3csNTX5BfWmV3SSFl+fZDXDnnMwpKqxncPYaXbzuJYb3ibKvH4TDcdHJ/5v3wdCZmJjc+f8OTX7DrUIVtdYmIiIh0ZgqoQVBbpxGW4+FxObh6fF9+c/Ew+nSLoKy6jp++upZbn1nGtsJyu8trM4cxPHDpcAamRHOoopYfv7Sm04Tvtvp4UwHX/eMLSqrqyO7XjednnEiPuCPvZdreesZH8Oi1Yxo//3JnMRc9vJhVO4vsK0pERESkk1JADYKKGnX5bIuMlGgevHw4V4/vg8fpYOm2Q1z+6Kc88VFeh59eGRvu5qHLR+BxOvhwfT45e0rsLsl276zZy81PL6Oytp5TBybxzM3jiYtw213W1zSdYpzVM4aD5TVc/cTnLN58wMaqRERERDqfLhtQjTHTjTFz/I95xpjpgbp2WXVdoC7VZbkcDi4e1YvfTxvByN5x1HktHl6wmZv+uYS9xZV2l9cmA1KiGdHbN3V1U37X3hv12SU7uP1/K6ip93Le8O48eeM4Ij0uu8s6qn99ewKnDEiioqaeW59Zxsodh+wuSURERKTTCO2fBIPEGDMLeN6yrMf9n8cDW40xYy3LmtHW6x8s7zzNfeyWEhvOj88dzCebD/DPxdtYu7uEqY99xiPXjiErNZJfPfAgAG53aI24HUt0uO+vXmlV1/1lxhMf5fHA2+sAuGpcHx64dDhOR/s2Q2opt9vN7NmzAegWHcGTN2Vz89PL+GTzAb719FJeue1k+idp6xkRERGRtuqSARWYDmwBVgBYllVkjHkcuBdoc0DNL63Csqx27zzaWRljOHVgMpndY/jj+xvZVljBzU8v5cHLhnPHD35kd3nHJb+kGiBk1lm2t79+sIk/ztsIwHdOz2DmOZkh/ffF4/Fwzz33fO25OdeP5ZonPmfVrmJufWYZr9x2EjHhHesXJSIiIiKhpqtO8T0IxB/2XCGAMSa9TVc2UFXrpaCsuk2XkW9KiQnn/ouGMrZfN+q8Fve+uJr/fL69QzYa2lPkm6bcu1vXC6hzFm1pDKd3nzWIH587OKTDaXOiwlw8cUM2qbFhbM4v44cvrMKrDt4iIiIibdIlA6plWRmWZc0+7Olx/tfy2nJtj9P3Lc0r6PhdZ0NRuNvJj84cxNlDU/F66/nN029wx99epKa240yVra33UlRZC0BqbLjN1bSv55fu4MF31gNw7zmZfO+MgTZX1DL19fUsXbqUpUuXUl//VRO0lNhw5lyfjcflYF7ufh7/uE3/fIiIiIh0eV11iu/X+NegTgVmtvD4nGZeygh3+wLqxv2lnJCeGJD65OscDsNNJ6UR66rn99dczL+B+riF/P7q8SHfYAfA7XQQHeairLqOrQfKSYjy2F1Su1i+/SA/fXUt4NsT9raJA2yuqOWqqqoYP348AGVlZURFfbXedFSfeH5xYRY/eWUtv3tvA6P7xDNBf/dFREREjkvo/zTfPuYCLx5hVLXVwt1OADbs69rdWYPNGMN5w3vwe//nH288wK3PLONvV4/pEIFvUGo0K3YUceNTS7jl1P6kJUZRVl3H/pIqdhdVUlRRS1VtPZEeF0nRHtKSosjqEctJGYm4nB1v4kN+aRXf/c8KaustzhvenXvPzrS7pIC6Znxflm49yKtf7uH7z67kzTtOISWma42Oi4iIiARClw+o/o6+RZZlTWvpOZZlDW3mWjnhbmdWHbDtQAVVtfWNgVWCKyrMydrdJVz/5Bf85arRDEiJtruko/rlxcO47+XVrN1dwp/nb2rxeVOGpPDEDdkdas2mZVn89JW15JdWMyg1mt9NHdmh6m8JYwy/vWw4OXtK2JRfxh3PruQ/N0/okL9MEBEREbFTlw6oxpipQHpDODXGxFuWVdSWa7qdhqTYcPaVVLFpfxnD/ftdSnD97IIs/rxwB7sOVXLNE58z6/IRTBqcYndZzeqbEMkz357Ayyt2sXz7IQ6UVRMV5iIlJozucREkRHkIczmoqKmnoLSKLQXlzMvdz/x1+bz65W4uHd3b7i+hxd5Zu4/3c/fjchj+ctVoosI65z87kR4Xj103losf/oTP8w7y0Dvr+ekFWXaXJSIiItKhdM6fFFvAGDMGOPOwkdPpxpjH2xpSs9O68ebqveTuLekUAbWmzsuuQxXsK67C4TBEhbno3S2C+Ah3yIyE9YgL5zeXDuPP8zaRu7eEu57/kivH9eGHZw4K2VFsp8MwLbsP07L7tOj42e+u579f7ODZL3Z2mIBaVl3Hz1/zLdm+bWIGQ3rE2lxRcA1Iieb300by3f+u4B+fbGVIj1guH9sx/luJiIiIhIIuGVD9W8nMBWYZY6b7n44HrgzEOtTRfX0BdeP+jr8OdcnWgzz84WZq6r3feC0xysPIPvGM75/A8F5xOB32htXYcDf/d/5gnv1iJ2+t2cvzS3eydNtBfnPJMIb27Ni/KPBaFp/lFQJwemayzdW03JMfb+VAWTVpiZHcfkbHaYrUFucO78EdZwzgrx9u5r6X19A3MZJxaQl2lyUiIiLSIXTJgAosxxdI5xz2/IpAXHxkH18Y2pxfRp3Xi8vRMdehrdtbwp/nb8RrQYTbSUpMGMZAaVUdB8trKCyv4cP1+Xy4Pp+4CDeTh6QwZUiqrU2KXA4H15/YjxG943hs4RbyCsq57h9f8N2JA7j5lP62h+jj9fGmA+QVlBMd5uL6E/vZXU6LHCyv4Qn/tit3n51JmCs0R7KD4a4pg9i4v4x3c/Yx49/LeeW2k+iXGHXsE0VERES6uC4ZUC3L6hbM62ckRxMX4aa4spYt+eVkdo8J5u2C5p+Lt+G1IKtHDFdk9/lauKup87K9sJwN+8tYs7uY4spaXl6xm1dX7uaMwSlcMroXSdFhQa3P5XJz8x33NH7c1Mg+8cyeNoKnPtnK53kHeWTBZpZvP8jsqSOJi3Af6XIh7YWlOwG4dkJfYsM7Rv1/X7SFsuo6hvaM5bxhPewup03cbje/+MUvGj8+FofD8KcrR7F7zmes2V3Mrc8s4+XbTia6k66/FREREQmUjjm0F+IcxjChv29K38odh2yu5vjUey12HaoA4LzhPb4x8uhxORiYGsMFI3pw79mZXJndm74JkXgtmL8unzufXcl/Pt9ORU1d0Gp0ezzccudMbrlzJm7PN0dtY8Pd3Dl5ILdNzMDjcvB53kGu+8cX7DxYEbSagmWn/79FKDd+aqq4spb/fr4dgLvPysTRQUeuG3g8Hu6//37uv/9+PEd4rx1JhMfJP27MJiUmjI37y7j7hVVYlhXkSkVEREQ6NgXUIDnDHyTmr8vnUEWNzdW0XmlVLV7/z9Ix4Ucf9XE6DMN6xXHrqf359slppCVGUm/Bm6v38oPnV7FwQ75tP5gbYzhtUDK/vngoSdEedhys4OZ/LWVHBwupdfW+719xZa3NlbTMc0t2UF5TT2ZqDBM70JrZQEuNDefv14/F43Twbs4+nvxkq90liYiIiIQ0BdQgmZKVyuDuMZRV1/HYwi3U1H2zyVAoa9r5tiEctUT/pCi+fXIa103oS1K0h+LKWv6+KI9fv7mucUQ2ULxeL3kb15O3cT1e79G/v/0So/jNJcPoFR/B/pJqbvnX0oDXE0yTh/h+4fHIgs3UHaFhVSiprffy9KfbALj51P4h0+m5LbxeLzk5OeTk5BzzvXa4MX278bMLfdvNzH53A+v3lQSjRBEREZFOQQE1SNxOBw9cOhyXw7B6VzF3PLuSpz/dxpur9/DBuv18svkAa3YXk19aFZLT/sJcDsJcvrdHUStHgI0xZHaP4fZJGZydlYrTYcjdW8I9L67m2SU7qK6rD0iN1VWVXHvuKVx77ilUV1Ue8/j4SA8/u2AIPePD2V9Szc1PL+swIfXGk9KIcDtZvauYn7+eE5LvmQbvrN3H3uIqkmPCuHhUT7vLCYjKykqGDRvGsGHDqKw89nvtcNdN6MvkwSnU1Hu567kvO9wvrERERETaiwJqEA1IieYPV4wkOSaMospa3l27j/98voMnPt7Kwx9u5oG31nHHs1/yvf+t5B8f57FhX2nIBA9jDH0TIwHYW1x1XNdwORycMjCJOycPYHD3GCwLXvtyDz96YRVf5BXa8rX6QmoWPePC2VdSxc1PL2NbYXm719FaSdFhPHjZcAzwvy928OySnXaX1Kz/feFbe3rN+L5dqnPv0RhjmDV1BAlRHtbvK+Ufn+TZXZKIiIhISFJADbKJmSm8c+epPHT5cK4/oR/nDe/OxMxkxqV1Iz0pCqfDUFhew/x1+fzi9RxmvrSGjzYW4PXaH1QHpkQDsLWNAa5bpIdrJ/TlmvF9iItwc6Cshj/N38TsdzeQX3J84bet9fzswq9C6vX/+IJNHWDP2kmDU7hzykAAHnpnHYVl1TZX9E15BWV8nncQh4Erx/Wxu5yQkhQdxk/PHwLAXz/Y1CGbdYmIiIgEmwJqO3A7HZw7rAd3n53Jg5eN4C9XjeYfN47jldtPZvGPz+DRa8dw0cieeFwOdhys4NGFW7jvlTWs2V1sa93De/n2c920vwxvAEY7h/SI5Y4zBnD6oCQcBlbuLOKHL6zinbV7A3L91ugW6eEXFw0lLTGSkqo6vvX0UvIKytq1huNx/Yn9GJASTUlVHa+s3G13Od/wnH87nEmZKfSMj7C5mtBz6ehenJieSFWtl1++kWN3OSIiIiIhRwHVZhFuJycPSOLXlwxj/g9P5/tnDCDC7WR7YQUPvLWOP87b2Oo1oIEytGccEW4nJVV17DzY+nV3R+JxOZgyJJXvTRpAWmIkdV6Lf326nQfeWseBdh4RjItw89MLskhLjKS0qo7pzyxnT1Fgvs5gcTkcTPE3TNoYYqO+NXVeXly+C4Crx/e1uZrQZIzh15cMw+UwzF+Xz6KNBXaXJCIiIhJSFFBDSFyEm1tOTefdu07lqnF9cBhYsvUgd89dzZKtB9u9Ho/Lwbi0bgCsCPB+rskxYXzr5DQuHNEDl8OQs6eEHzz/JZ9uPhDQ+xxLdJiLn5w/hD7dIigoq+bO51YGde/WQEiNDQegoDS0pvgu2JDPwfIaUmLCuvTWMscyICWaG09KA+DXb+ZSG+JdmUVERETakwJqCIqP9HDfeUN4fsaJZKb6tqr547yNPL90Z7s3Fpo8JBWAVbuKAx7cHMYwvn8C35uUQZ9uEdTWW/z1w808smBzu4bEmHA3M88dTFyEm437y/i/V9a2+5Tj1mhYnlxeE5huyIHyygrflONLRvfC5dQ/LUdzx+SBJER52Jxfxr8/2253OSIiIiIhQz9FhrBBqTH855YJ3HhiPwBeWbmbh9t5H8xBqdH0S4yk3muxZGtgR1EbJEaHcfMp/Zk4KBkDfLzpAPe+uJoN+44+hdXlcnPNLbdzzS2343K521RDUnQYd589CJfDsGB9Pk99srVN1wumkb3jGkfXH3pnPf/7Ygf//WI7r6/aY9vob1FFDR+s3w/41ll2Nm63m7vvvpu7774bt7tt7zXwzZa4+6xMAP48f2NINrwSERERsYMJlW1NOgNjTM7gIUOyPl++KuDXfu3L3fzy9VzqLYuxfbtx15kDcbfTKNUnmw7w8ILNRHqc/GDKQMLdwds6ZMfBCl5cvotDFbUY4KJRPZk2tne7jch9uD6fxz/KwwB/vmoUEzNT2uW+rfXwh5t44uNvhuh+iZH8YdpIstMSvvZ8eHg4GRkZ5OQEpzHPfz7fzk9fXcuQHrG8c+epQblHZ1Pvtbjwb5+Qu7eEayf05YFLh9tdkm2GDh1Kbm5urmVZQ+2uRUREROylEdQO4uJRvfjbNaNxOw3Ldxxi9rsbqKptnymeJ2Yk0jMunIqaehZvLgzqvfomRHLbxAxG9YnDwrdv6s9fz2m35kVnDE5hypAULOCeF1eTu6ekXe7bWjNOz+BbJ6dxQnoCEzOTmZSZTEpMGNsLK7jq8c9ZtbOoXet51d9R+LJOOHoaLE6H4RcXZgHw7JIdrLW5a7eIiIhIKFBA7UBOHpDEI9eOIczlYM3uYh54ax2lVbVBv6/TYRr3tPxk8wFKKoN7z3C3k8vH9OaqcX3wuBzkFZRz74ur+eiwjqder5e9u3awd9cOvN7ATXu+6eQ0hveKo6bOy63PLAvJPVLdTgd3TRnEnOuz+ctVo/nzVaN5+baTOCkjkTqvxV3Pf0l5dftM991bXMmy7b7p3xeO7Nku92xvXq+Xbdu2sW3btoC+1yakJ3LRyJ54LfjJq2tDYv9jERERETspoHYwE/on8o8bs4n0ONmUX8bPX8shv6Qq6Pcd3z+BzO4x1Hkt3svdH/T7AQzt6ds3tX9SFHVei0cXbuHRBZsbR46rqyq57PQxXHb6GKqrAjfC6nI4+MGZA0lPiqKsuo6b/rmUdXtDcyS1qZhwNw9dPoLU2DC2HijnV2/ktst9316zD4Bxad3oHhfeLvdsb5WVlfTv35/+/ftTWRnY0fyfnj+E6DAXq3YW8ezSHQG9toiIiEhHo4DaAY3oHc9/b5lAj7hw9hZX8fPXctheWB7UexpjGps1rd5VzNYDwb1fg7gINzed1I8zBvsaKH206QA/eWUtu4M85TfS4+L/zh9CenJDSF1iy1Y/rRUX4ea3/rWMzy/bSc6e4E8bfWv1HgDOH94j6PfqjFJiw/nRWYMAeOid9e3yCycRERGRUKWA2kGlJ0fzzM3jGZgSTVFlLfe/nnvMrreBuOeZWb5tZ95cvZf6dpqO6DCGSZkpfPvkNGLCXewuqmTmi6v5PC+462Gjw1z89PwhDOkRQ1Wtl+/+ZzmL23mf1uORnZbAucO6AzDr3Q1BvdfuokpW7CjCGDhXAfW4XX9CP0b0jqO0qo773whOIysRERGRjkABtQNLiQnnqW+NY0zfeCpr6/nt2+uCPhX1yuw+hLsc5JdWs3hL+4a1tKQobjs9o3HK72ML84J+z0iPi/vOHcLYft2o81rc8exKPt5UcOwTbXb7pAG4HIaPNhYENVS/u9Y/vbdfAqmxnXN6b3twOR08dNkInA7D22v2NX5fRURERLoaBdQOLjbczWPXjeWE9ESq67w8+M76oI6kRoe7+PYp/QH4cH1Bu+/fGB3u4qaT+nHKgMSvPV9ZE7yOxh6Xb03qhP4J1Hktfvj8KlbvKgra/QKhT0IkU8f2Bgjqnq7zcn1B6mz/iK0cv6yescw4LR2An722luKK4DdAExEREQk1CqidQLjbyV+uGsVJGYnU1HmZ9e76oK5JPXVgEsN7xVHvtXh91V687byXrsMYzh7anUubbGnywNvrOBDEsOxyOPj+5AGM7hNPTb2X7/xnOdvaaR3u8bp6fF8AFmzIJxj7HRdV1LB0m69775lDUgN+/a7ojskDSU+OoqC0mgfebp8mVyIiIiKhRAG1kwh3O/njlaMY1Seeipp6HnpnPQfLa4JyL2MMN5/SH6fDkHegnKU2NQ8a3iu28eOdByv52atrgxrMXQ4Hd04ZSEZyFOXV9dz23xXtPoLcGmlJUWT1iMVrQTCWCy/YkE+91yIzNYa+iZGBv0EXFO52MvvyERgDLyzbxacdYM2ziIiISCApoHYiEW4nf7t6NOnJURyqqOUP72+gpi5wezY21T0unOtP8HX1fTdnPwWl7R/UHE4nky+7jlMuuobkuAgOVdTy01fXkrsneOtww91OZp4zmNTYMHYXVfKd/ywP+r6wbXFihm8qdDBGUOfn5gM0Ns7qzFwuF7fddhu33XYbLpcrqPfKTkto/Lt13ytrGrdVEhEREekKFFA7mdgIN3+7ejRRYU62FJTz1CdbgxJOAM4amsqwXrHUeS1eXL6LuvrghOHmuD1h3Hj3r5n+4weYMTGTtMRIaustHngrl2XbgjeqGxvh5sfnDiYuws3G/WXc8dxKKkM0RAzpEQNAoN8BNXVeFm30NYua0gUCalhYGI888giPPPIIYWFhQb/fPWdn0j02nO2FFfz1g01Bv5+IiIhIqFBA7YR6d4vkT1eMwhhYuLGAD9bnB+U+DmO4beIAwlwO9hRX8X7u/qDcpyUiPE5uOLEfg7vHUG/BH+Zt5LMtwduGpkdcBD85fwgRbicrdxRxz9xV1HnbN6C3RFpiFACB/h3Fsm0HKauuIyk6jBG94gJ7cSEm3M39Fw0F4ImP89icX2ZzRSIiIiLtQwG1k5qQnsj3zxgIwNOLt7Fpf3A6+yZEebhziu8+n+UdDPo2N01ZlkXJoUJKDhViWRZup4OrxvVhRO84LAv++sEmPtkUvDV8fRMi+fG5g/E4HXy86QB/en9j0O51vBKiPUDgR1AX+bfaOW1QEg6HCfDVQ49lWRQUFFBQUBC0GQmHO3toKmcMTqG23uL+13Pa7b4iIiIidlJA7cS+fXIak4ekUOe1+MP7G4PW0GdM326c699m5MUVuylupzWZNVWVfO/8bL53fjY1VZUAOB2Gy8f0YmzfeCzgkQWb+Whj8PYtzewew/fOGADAf77YwTtr9wbtXscjLsIdlOsu2uD7np4+KDko1w81FRUVpKSkkJKSQkVFRbvc0xjDLy7MwuNy8MnmA7yjvVFFRESkC1BA7cSMMfzmkmEMSImmqLKWh95ZT1lVXVDude2EvqQnR1FT5+XlFbvbfeuZphzGcNGonmT364YFPLpwS1BD6vj+CVw8qicAv3w9l73FlUG7V2u5HA4i3M6AXnN/SRXr95ViDJw6sGsEVLv0S4ziO6dnAPDbt9epYZKIiIh0egqonVykx8Vfrx5NcnQYOw9V8uA766ioCXxIdTkdfG/SAFz+rWc+3Ry89Z8t4TCGC0f2YFxaNyD4IfWK7D4MTI2msraen7+WY2tAP1x8pJtATsJt+D6O6BVHQpQngFeWI/nO6el0jw1n16FKnvxkq93liIiIiASVAmoX0Cs+gr9fP7axs+9v3lpHaVXgp+H2jI/g26f0B2Deuv3sK64K+D1aw2EMF4xon5DqdBhum5iBx+VgydaDPPvFjqDc53i8c+epuJ2Bi6gf+df1ntZFpvfaLdLj4sfnDgbg0QWbyS+19++ViIiISDApoHYRA1KieeqmcUSHucgrKOeXb+RysLwm4PeZlJnM2L7d8Fowd/kuatt565nDHSmkfrwpOCG1R1wE103oC8Cf5m8kryA0Oq8aE7hwalkWn272BVRN720/F43syag+8ZTX1POneaHXjEtEREQkUBRQu5DB3WP5983jSYkJY9ehSn7xek7ARzmNMdx6Wn/iItzkl1bzXo59W880+EZIXbAlaN19z8xKZUTvOGrrLe57eQ01daG39UxbbNxfRmF5DeFuB6P6xNtdTpfhcBh+ev4QAJ5fupMN+4LTlVtERETEbgqoXUx6cjRPf3s8fRMiKSit5pdvBD6kxkd6uG2ir7HLF1sPkrOn/baeaU5DSG1onPTIgs18sjnwIdUYw3dOzyA6zMX6faX8/v0NAb+HnT7b4vuejUtLwOPSPx/tKTstgXOHdcdrwQNvr7O7HBEREZGg0E+YXVCv+Aie/tY4MpKjOFRRy6/ezKWgNLBb0IzsE8+FI3oA8PKKXUGZTuxwOjnlvMs55bzLcTiP3am2oXHS2H7+LWg+3MxnWwLfzCkhysPtk3wB/fmlO3lrdWhtPdMWn/q/XydmJNpcSftyuVzceOON3HjjjbhcLtvqmHnOYNxOw0cbC1gUxKZfIiIiInZRQO2iEqPDeOKGbNKTojhYXsOsd9dTXh3Y7r5Xju/DoNRoauotnl+6k7oAr0d1e8KY/tPfM/2nv8ftCWvROQ5juGhkT8b490n964ebWL79UEDrAhjdtxuXju4FwM9fW8vKHYG/R3ur91p8sfUgACemd62AGhYWxtNPP83TTz9NWFjL3mvBkJYUxQ0npgHw27fWUe8NnW7RIiIiIoGggNqFJUaH8ffrx5LsX5P61w83BXR7FJfDwR2TBxLmcrCnuIp3Q2A9KvhC6sWjejKidxyWBX94fwM5e4oDfp9pY3uT3a8bdV6L7/1vJdsLywN+j/a0bm8JxZW1RIe5GN4rzu5yuqw7zhhIfKSbDftLeX7pTrvLEREREQkoBdQuLjU2nL9dPRqP08GqncUBn46aFB3GXVMGAr71qGsDGAQty6K6soLqygqsVgZrhzFcNroXQ3rE4LXgoXfWBzxAOhyG708eQEZyFGXVdXznP8s79BYhn+f5pveO75+Ay9m1/umwLIvy8nLKy8tb/V4LtLhIN3dO9v2d+sP7GyiuDPyWUSIiIiJ26Vo/ZcoRDekR27jP4vNLd7K/JLAhanTfblw0sicAL6/YHbD1rjVVldw6eSi3Th5KTVVlq893OgzTxvYmLTGS2nqLh95Zz4GywK7FDXM5uefsTFJjw9hTVMUPnv+S6rr6gN6jvTRM753QP8HmStpfRUUF0dHRREdHU1FRYXc5XHdCPwakRFNYXsPfPthkdzkiIiIiAaOAKgBcNqYXJ6QnUOe1eOaz7QG//hXjejOkRwy19RbPLtlJdW1ohDS308E14/uSHBPGoYpaZr0T+LW48ZEe7jtvCJEeJ2t3l/DLN3JtH4VrLa/XYtk2X0Ad1wUDaqhxOx387IIsAJ7+dBub87XtjIiIiHQOCqgBVlxRyxdbA98ZNtiMMcw8ZzAOA8u3H2JLQVlAr+9yOLhz8kC6RbopKKvmxRW7A7retS0iPE5uOKEvMWEudh6q5Pfvbwj4/qXdY8P54ZmDcBh4a/VeXvtyT0CvH2ybC8o4VFFLuNvBsJ5afxoKTh+UzJQhqdR5LX7xek6H+6WHiIiIyJEooAbYgbIa3l69z+4yjkt6cjTnDvdtDfPS8l0Bv358pIcfnjUIp4H1+0pZuCF0tsmIj/Rw/Yl9cTsN6/aW8vCHmwPeIXVYrzimje0DwG/eymXj/o4z6rXEP713TN9u2v80hPziwizCXA4Wby7krTWdZzsjERER6bra7SdNY8wZxpj3jDGbjDHPGWNimrz2kDHmeWPMb9urnmDadcj+NWrH69ZT03EYWLGjiDW7At/ZdmBKDLeelg7Agg0F5O4tCfg9jlePuAium9APh4El2w7y5CdbAz4qdfGonozsE0dtvcU9c1cFfDpxsCxtmN6bpum9oaRPQiTfnejbc/dXb+RSWqWGSSIiItKxtUtANcZMBuYDicBW4CxgmzGmH4BlWT8GlgMz26OeYMsPUBMgO/RPiuLKcX0BeHLx1qA09JmYmcI5Q7sD8OLyXRQGuDFRW6QnR3Fldh8M8OH6fJ4L8DYeDofh9kkDSIjysK2wgp+/tjZkpjo3x7KsxhHUrtggKdR95/QM0hIjyS+t5g/vb7S7HBEREZE2aa8R1JnAmZZlZVuWdZZlWQnAfcD8JiOpW9qplqCrqOkYo2LNuW1SBskxYewrrgraPovXndiXzO7+pklLdwZ8zWdbZPWM5aKRvqnOr325h7cDPHUyNtzNXVMG4nIY5q/L5/GP8gJ6/UDbXVTJ3uIqXA7DqL7xdpcjhwl3O/n1JcMAeOazbazeVWRvQSIiIiJt0F4BNc+yrA+aPmFZ1uPAd4EX26mGrzHGTDHGzDHGzPL/OT1Q166sCY0OtccrNtzNLy70dQh9e82+oEz1bWiaFO52sL+k+rjWzxmHk3GTzmXcpHMxDmdA68tOS2DKkBQAnvlsO59sPhDQ6w9KjeHmU/oD8PeFW/hkU+isxz3csm2HABjaK45Ij8vmauzhdDqZOnUqU6dOxekM7HstEE4dmMzFo3riteC+l9dQVx86v/ARERERaY32CqhHnMNoWdZ84D5jzGPtVAcAxpgxwCzLsmZYljXTsqwZwDRjzNRAXL86hEYDj9epA5OZNrY3AI8t2hKUUeGEKA/3nJ2Jwbfmdfn2Q6063xMWxvcfeJTvP/AonrCwgNd32sAkTkj3TWl9ZMHmgAf1SYNTmDIkBQu458XV7C1u/V6u7WHZdt/03ux+3WyuxD7h4eHMnTuXuXPnEh4ebnc5R/TT87OIi3CTs6eEJz/Zanc5IiIiIsel3UZQjTFp/kZJtzR9wbKsFcBsfFN+28ss4PnDnpvjf77N6rxWSE1ZPV4/OjuTvgmRHCyv4b+f7wjKPYb2jGNati8Iv75qD7sPhU5IM8Zw7rDuDOsVi2XB7PfWs72wPKD3uPGkNDKSo6ioqefHL62hNgRHvhpGULtyQO0IkmPC+Mn5QwD40/yNbDsQ2PeqiIiISHtol4BqWdbvgO8Aj3OERkiWZW0FrgACP5f0yKYAhy/8ywPS/aOrx8/4/ugM3TQj3M7Gqb4frM8nL8B7oza4ZHQvxvbrhteCZ5fupKyq+dFay7Korqw46iOQnXcdxnD56F6kJUZSW2/xu/c2UFwZuP+2bqeDOyYPJMLt5MudRTz84eaAXTsQSqpq2eDfDmdsmgJqqJs2tjcnD0ikqtbLvS+txhvgrZJEREREgq3dtpmxLOvHlmUNsCxrYDOv5/mbJwVVkwBadNhLDZ+nt+X6TuNLqIXlNW25TMjITkvgPP/eqP/9YkfAt10BXwi8fVIGPePCKa6s5bllO5vdg7SmqpJbJw896qOmKrCjsC6ng2vG9yUxysOBshr+NG8jdd7AjXSmxoY3bhXy9KfbWLghP2DXbquVO4qwLOiXGElKTGhObW0P5eXlGGMwxlBeHrojk8YYHrpsBBFuJ0u2HuQ/X2y3uyQRERGRVglIQPVP3X3eGFNojKn3Pwr9+54+aIwZFYj7BEhzIfjgMV5vZIzJOdIDyHA5fQE1v6QqMNWGgO+dMQCXw5Czp6TV60RbKtLj4u6zM3E7DdsLK3gvZ19Q7nO8IjxOrp3QF7fTsH5fKc9+EdjuxuP7J3DOMN/WOzNfWs2WII1Wt9Zy//6nYzW9t8PokxDJzHMyAXjw7fWa6isiIiIdSptbchpj7gHOBFYAD+Hb6zQDmOx/fgpwrzFmOfCgZVmvtPWeQRKQ0VsnFt6aKrbtO8jonpFff83p/FqDlaONxDgcDiIiIo7r2IqK5qe5GmOIjIxs1bG94iO46aQ0Hl+wnn99tIFBicNwO7/5u42IyKjGj6uqKrGOMsrY9Njq6iq89fV088CMk3rx1w82s3j9HlLCYXjvOMIivqq3prrle6bW1lTjrW++o7InPALjH/E+1rHusHCSY8KYOqY3//s8jzeWb6V/vPOIwS0sPAKHw+G/bg11dc1PCfaEhTd2hb1ydHe27DnAhn1l3P6vT3n8+mwSo79q/hQe/tWxtbW11NQ0P0ofFhaGy+VqPPZ4LdvesP5U+592JDecmMa7Ofv4PO8gP3zhS+Z+5yScDmN3WSIiIiLHZllWmx74Qmdzr8UDy4C/4xuh9AKFwKVtvW8b6h2Dr6vw1JY838pr5/ivccTHWWefaxVV1DQ+IiMjmz325FNP+9qxiUlJzR47eszYrx3bp2+/Zo8dPGTI144dPGRIs8f26duv8bjdhyqsyF6Dmj02PiHR+mzLgcbH6AknNXtseETk1449aeKUZo8FrGc+3dr4GHPamUc9FrCe+CDHeubTrdYp511+1OMefmtZ43UnX3bdUY/9w0sfNx475Kxrjnrsf9/5pPFru/mOe4567JOvvN947O0zf3HUY994d17jf4/f/fEvRz32+ZdebTz2kTn/sAArKyvLao3aunpryM/esfrNfNPasK+kVed2NmVlZY3f27KyMrvLaZGdB8utYT9/1+o3803rbx9stLuco8rKyrKAHMum/y/ooYceeuihhx6h8wjEFN9mfy1vWVYRUGhZ1ncs3/rSbOBD4CVjzHMBuPfxOLw5UoOGIaIV7VVIRxIV5iLVpjWI1bWhta9sv8SoYx/UCazbW0pFTT2x4S4GJEfbXY60Uu9ukdx/0VAA/jR/Eyt3BGd6voiIiEggGctqW9MbY8ytQLplWUfcJsYY855lWWcf9lw6vlFV6/DX2oMxZh4wz7Ks2U2emwo8YVnWcS+2M8bk9EobkOW49CHG9Ivn0WvHfu31jjrFt7GGigqm/2spq3cVM7ZfPN8/Y0DjFFlo+xTfpkoq6/j562s5VF7L8LQUrszujTGG0qJD3H7e0RstP/FBDmERkQGf4tswbbeutoaDpZX8fVEe1XVeTs9M5tsnpzUee7xTfJseu6eoilnvrqeoopaUWA9/uWo0Q3onHfcU317J3RgwYAA5OTnNnnO4pxdv5f43cpmYmczT3xrf4vM6o/LycqKjfSG9rKyMqKiO8UsKy7K447kveWPVHvomRPLWHacQE+62u6xvGDp0KLm5ubmWZQ21uxYRERGxV5vXoFqW9YQxZq4xZilwi2VZq1pwTh5wljHmHmPM3ZZl/b6tdbTSLHz7ns5u8twMjrAFTmt53E68nnAO1TiO+UNsa37Ibc2xTUNlII+Niozk/svGcOWcz1m5t4rPd1ZwxuCUIx4bHh5xxOePJCzsmyOzEZHwo/NGcP/rOeTsKWHxlkJOGZCEJyzsCFc4MrcnOMe63B5SEjxcc/JA/vXZdj7eWkpmrzKmZKUe4boe3B5PC2v46tiMyCh+e0U2v317HXuKqpjxbA5P3JBNVs9Y37FuN253y4JGS487XMP607F91SCpozLG8JtLhrFi+yF2HKzgp6+u5c9XjvraL5ZEREREQklAuvhaljUN39TYlcaYJcaYS1t43u+ApEDU0BqWZc0HZhpj5hhj7jXGzAHmWpb1eFuv3dCIpLCsc2wzc7iBqTHcMXkAAP9cvJVN+aVBu9eg1BhuOikNgPdz9rOtMLS6kQ5IiWbKEF9Af2rxVjbuD+z3Iik6jF9eNJSM5CjKquv49tNL2Zzfft19VzQEVO1/itPp5LzzzuO8885rHMXuKOIi3Pz16lE4HYbXvtzDi8t32V2SiIiISLPaPMX3axczZgq+kcn++BqKzMe3r+gUy7KOuCGfMebB5qYHdzTGmJzBQ4ZkVV70OwA+/fEZRIW1eZA65HgtizueXcnHmw4QHebi15cMpUdcy0dMW8OyLB5ZsIVPNh8gJszFdyem47GO3pW26dTdYLMsi+eW7iJ3bwndIt389rLhdIts2YhpS1XW1PPQO+vZsL+U3t0i+O8tE4hv5T1S4qNbNcV3T1ElJz30IU6HYc39ZxHp6Xzv467mkQWb+d17G4j0OHnrjlPpnxQ605Q1xVdEREQaBGQEtYFlWfMty8oAzgJexrfNTAaQ12Rf1Mf8e6M+aIx5D19X307DYQzdIn1TKkNtxC9QHMYwe+oIhvSIoay6jt+8uS5o+74aY7jl1P70io+gtLqOV7/cgyc8grCIyGYf7Tl90RjDZaN7khwTxqGKWv76wSbqvYH7pQ/49mD90dmDSIkJY9ehSn766tpm1w0HSsN+t1k9YhVOO4nvnJ7BiemJVNTUc+dzK6mpa36NuIiIiIhdAhpQG/iD6jSgG751nS8Bh/AF1hn+x1hgtg3rT4NuZJ94AFZsL7K1jmCK9Lh4+JoxpCVGUlhew6/ezCW/NDghNdzt5K4pA3EY2Li/rDE8hYowt5NrxvfB7TSs21vKc0t2BPweseFufnTWIFwOw8ebDvDfLwJ/j6YavsdH2udVOianw/DHK0cSF+Fm9a5i/vrBJrtLEhEREfmGoATUBpZlFVuW9TvLsq6wLGuAZVkO/yPBsqyzLMv6IJj3t8spA3zLat9eszfoI112SooO44kbs+mbEMmBshp+8+Y6Csuqg3KvPgmRXD2+LwBvrdlHYVk11ZUV3HJGFreckUV1ZUVQ7ttSSdFhXD6mNwBvrN4blC09+iVGccOJ/QD447yNrN5VFPB7NFi2/SCggNqgvLycqKgooqKijtpRO9T1iIvgocuGA/Dows3aekZERERCTlADald12ZjeeJwOcveWsGTrQbvLCaqUmHCevCmbPt0iyC+t5jdvraOsui4o9zp/RA+yesRS57V4cflu6rxeaqoqqamqDMr9Wmtoz1jG+xsK/WX+JooqAt8o68ysVE5IT6Dea/HDF1axPwhTq8uq68jdUwJAthokNaqoqKCiwt5fhATCucN7cMmonngt+NHcVVSF2D7DIiIi0rUpoAZBQpSHq8b3AeCeF1c3dkPtrFJiwnnixmx6xIWzt7gqKOswwbf29bZJGXhcDnYVVfLBuvyA36OtzhnWne6x4VTVeZmzKC/gI+jGGGaclkHvbhEUlFZz13NfUhnggPHljiK8FvSKjwha8yux1y8vGkZqbBh5BeX8RVN9RUREJIQooAbJj87KZGTvOIora5n+72U8+PY6Vu0soqTq6B1oO6oecRH85arReFwOVu8q5s3Ve4Jyn6ToMO6cPBCAL7aGXvB3Ox1MHdsLp4GVO4t4P3d/wO8R4XFy79mZRIe5yN1bwgNv5QY0CGt6b+cXF+nm1xcPA+Dxj/LI2VNsc0UiIiIiPgqoQRIX4ea56SdyVlYqtfUWzy3dyQ1PLeHUWQs45aEPueLvn/Hg2+v4PK+w06xTzewew8/OHwLAi8t3Ba1p0th+3bhkVM+gXDsQUmPDOXtodwCe+Ww7uw4FflpoSmw4PzhzIMbAG6v28srK3QG7dkODJE3v7dzOGtqd84Z3p95r8eOX1gRl1oOIiIhIaymgBlGEx8mc68fy75vHc87Q7iTHhAFQWl3Hhv2lPLd0JzP+vZxrnviCz/M6x247F47sSXZaN2rrLV5aHrjQdLgrxvVhdN/4xs+LK0NrZHpCegIDUqKp91o8/OFmausDv6XH0J5xXDXON5V81rvrA7Ietd5rsXJHEaAR1K7g/guHEhPuYs3uYv7z+RG3qhYRERFpVwqoQWaM4dSByfz9+rEs/ckU1v7ybOb/8DQeu3YMV4/vQ7jb10xpxr+X88vXcygPUoOh9mKM4a4pgwD4aFMB+4qDM4rqMIYZp6U3fv78sp0hta+jwxguHdWTcJeDbYUV/C9I28JcOLInA1Oiqar18of3N7b5euv3lVBWXUd0mIvB3WMDUKGEspTYcO49OxOA37+3IWj7GYuIiIi0lAJqO4sOczEgJYZzh/fgwctGsHjmGY1bh7y8cjdXzPksqNuHtIfhveI4dWASlkXQ1qICRIa7GTb2BCL6DmdfSQ0vr9wdUtOlYyPcTB3r23rmnbX7WBWE/64OY7jl1P4YA+/l7GvztiHLtvnOH903HqfDBKLETsHhcHD66adz+umn43B0rn82r5nQj5G94yitruNXb+baXY6IiIh0cZ3rJ60OKDE6jF9dPIznpp9Ar/gIdh2q5ManlnD33FU89clW/jRvI9/9z3JuePILfvbqWubl7sMbQiGsOd86OQ2AhRsKOFge+O1WAMLDI3jihTd59NnXcHnCyNlTwkebDgTlXscrs3tM49Yzjy7YEpQmWf0So5iUmQLA3xfltelay/zrT8elJbS5rs4kIiKChQsXsnDhQiIiOldnY6fD8MClw3EYeHP1Xj7aWGB3SSIiItKFKaCGiBPSE3nnrlO5cKRvf8J5ufv5ywebePrTbXy6pZBVu4p5fdUe7p67mmue+Jw1u0O76+aYvt0Y3TeeOq/Fa18Gby0qwODusXz7lP4AzF+Xz+b8sqDer7XOGeZbf1xcWcs/PtoalFHeS0b1xBj4PK+QjftLj/s6y7b5Ovhma/1plzKsVxw3npQGwM9eW6u9UUVERMQ2CqghJDbczd+uHs27d53KjSf24/IxvbnppDQeuHQYD18zmhmnpxPlcbJubyk3PbWEf3ycR503dNZdNmWM4bsTMwCYn5vPnqLKoN5vypBUzhjsG0V8bulOiiqCM2p7PNxOB1PH9MJhYMm2gyzeHPiGWCmx4Y2jnm+sOr5p1buLKtlbXIXTYRjVpAGVdA0/PHMQqbFhbC+s4K/aG1VERERsooAaggZ3j+WXFw/jD1eM5P6LhnLthH5cMKIn9507hI9nnsH5I3pQ57X424ebueHJJWxqw4hZME3on8ipA5Ootyye/GRrwKcmV1aUc+64TM4dl0llRTk3nZRGelIU1XVenl+2K6TCe8/4iMZpuI9/nEdJELoOnzIgCfCNvh/PKG3D6OmwnrFEelwBra2jKy8vJzk5meTkZMrLy+0uJyhiwt38yr836hztjSoiIiI2UUDtYBKiPDx89Wh+P20kMWEucvaUcMWcz7j/9RwOhdCoYYN7zxmMx+UgZ08Jr38Z+IZJRQcLKTroG5H0uBzcdeZAPE4Huw5VMi83P+D3a4tTBybRPS6cmjovzy4JfFffUX18jY32Flex+zhGrJf6A+rYflp/eiQHDhzgwIHQWuMcaGc32Rt15kurg7I9koiIiMjRKKB2QMYYpo7tzbwfns65w7rjteCVlbuZ+tinLN4cWj9A902I5P/OGwL4toJpGKULlpSYcL4/eQAAn25p23rMQHM6DBcM7wHAgg0FbMoPbG0el4O0xEgAcvaUtPr8hg6+2Wlaf9qV3X/RUOIi3KzdXcKjC7bYXY6IiIh0MQqoHVj3uHAeu24sL333RAamRHOgrIbb/ruCxz9qWyfXQLtkVE8uH9Mby4K/fLAp6KFxXFoC5wztDsArK/dQFkJ7y/ZLjGR0n3gAnl68LeDTnvslRgG0ulFUcWUtG/z/XRRQu7aUmHB+dfFQAP724SbWhnhDNhEREelcFFA7gbH9Enjj+6c07qf6yILNfLoldEZSjTH83/mDOW1QErX1FrPf3cC+kqqg3vOaCX3p3S2Csuo6Xlq+K6S25jkzKwW307CloDzgW3r07ubbAqW165JX7jiEZfkCdEpMeEBrko7nopE9OWdod+q8Fj984Ut19RUREZF2o4DaSYS7nfzq4mGNIfX+13NCKpS5HA5mXT6CIT1iKKuuY/a764P6Q6/H5eDOyQNxOgybC8r5dEvgO+cer5hwN2f4Gyb994sdAR3h7eef4rtxf+tGUJf79z8dq+1lBN8vlR64dBhJ0R427i/jD+9vsLskERER6SIUUDuZ+84dQpjLwf6SanYUVthdztdEelz87eoxpMSEsaeoiv9+EfhGQU31SYjkW/69Hd/P2c/2wtDpvnpiRiLJMWGUVtUxd9nOgF23X4Jviu/uospWdQpuXH+qBknilxgdxqzLRwDwj0+2htSsDBEREem8FFA7mQiPk6yesQCs29f6RjnBlhwTxm8u8W1lMS93f5vWtxmHgyHDRzFk+CiM48hv5clDUjhlQBIW8PyyXSGzHtXXMMm3Tvb9nP3kFbRuxLM50eEuUmLCgJY3Sqqt97Jypy+gjtP60yNyOBxkZ2eTnZ2No5n3Wmc0eUgqV4/vi2XB3S+soqQq8NsjiYiIiDTVdX7S6kIyU2MA2JIfOiOGTU1IT+SK7N6Ab2Smpu74trIID4/gqVfn89Sr8wkPjzjiMcYYbjm1P73iIyitquOFZbuo94bG1Of05GiG94rDAh7/KC9gdQ1MjQZg1c6iFh2fu6eEqlovcRFuMpKjA1JDZxMREcHSpUtZunQpERFHfq91Vj89fwj9EiPZU1zFL17LsbscERER6eQUUDuhYb3iAHg/d1/IhLHD3TllEEnRHvYVV/HKyt1BvVe428kPzxyEy2HYeqCcD9aHzv6o5w3vTpjLwbbCCubl7g/INRt+QbFix6EWHb+syfpTh8MEpAbpPKLCXPzxipE4jG87q3fX7rO7JBEREenEFFA7oUtG9yIm3MX2wgpe+zK44e94RYe5uO9c3/6or3+5p9XborRWr24R3D7Jtz/qx5sOkLs3NKY/R4e5OCsrFYD/frGdg+U1bb5mwxTvVTuLWjQ63RBk1SBJmjO2XwIzTs8A4CevrKGwrNrmikRERKSzUkDthKLDXI1h7K8fbArZdWNTslI5a2gq9ZbFn+dvpKyqdetDqyoruPS00Vx62miqKo/dEOrEjETOHeZb9/ni8l0h80N2dlo3esVHUFtv8cxn29p8vV7xEcRFuKmq8/JlC6b5frnDd8zovvFtvndnVVFRQVpaGmlpaVRUhFbzsfZy15SBZKbGUFhew09fXWt3OSIiItJJKaB2Ujef0p+M5CgOVdTy1/mb7C6nWT+/IIs+3SI4UFbDXz7YhLcVU5Ity2Lf7p3s270Tq4Vb6lx7Ql8yU2Oorbd4btkuauuPb/1rIDmM4aKRPTDA53kHWdnCqbnNMcYwordvmvfizUfvvLq/pIrdRZU4DIzsHd+m+3ZmlmWxfft2tm/f3uL3WmcT5nLyhytG4nIY3lm7j7dW77W7JBEREemEFFA7KbfTwa/93XLnLt/V4oY57S0m3M0frxyFx+Vgze5inl0a3K1nXA4Hd0weQLjLwb7iKt5eExrr6XrGR3BiRiLga5jU1m7DI/vEAxxza5CGMJzZPZaoMFeb7imd37Becdzmn53xs9fWhswsBBEREek8FFA7sZMykpg21tct9/fvbwjZkZ9BqTGNW8+8sWovn+cVBvV+idFh/OisTMDXIGhNG7a6CaTJg1NIjPJwqKKW/36+vU3XGtE7DgNs3F9GQWnzIWKFf3rvGE3vlRb63qQBDO4ew8HyGn75Rq7d5YiIiEgno4Dayd19diYRbierdxXzfoC6xAbD2UO7c+OJ/QB4bOEWdhdVBvV+w3vHcenoXoCvM2kojAR5XA4uHd0TgAUbCli+/fin+saGu0lPjgLgs6OMojaMoI7uqwZJ0jIel4PZU0fgMPD6qj3MD+F/V0RERKTjUUDt5FJjw5lxejrga5hUUdO2qaPBdMeUgWSndaO6zssf399IZU19UO83dWxvBnf3rUedu3wXdV7716P2S4zixPQEwDfVt7jy+BtcjfCvKf2smRHp2novq3f5Ro81giqtMaJ3PLee5vt35aevrg3ZRmwiIiLS8SigdgG3nJpOz7hwdh2q5Fdv5IbsVF+Xw8Hsy0eQHBPG7qJKHlu4Jai1Oh2G758xgDCXg91FVby3NjRGgs7MSiUlJoziylqe+CjvuL8Hw/374X6ed/CIr2/YV0p1nZe4CDf9k6KOu17pmn4wZRD9k6LYV1LFQ++st7scERER6SQUULuA6DAXf75qdGP3zf97ZS17gjyF9nglRofxh2kjcToMS7Yd5NWVe5o91hhD/4GZ9B+YiTHmuO93x+SBAHy+9SBr99i/HtXtdDB1bC8cxrdG9oN1+cd1nYGp0bidhoPlNRwp4jaMno7oHXfc37+uwhhDVlYWWVlZ+l75hbudPHjZcAD+98WOoK8dFxERka5BAbWLGN8/gV9cNBSAt9fs5dy/fMzE3y3gxqeWcP/rOS3aL7O9jOwTz0/OGwLAC8t2sqKZbVfCIyL537uL+d+7iwmPiDzu+43t140LR/YA4KXlu8k/SlOh9tIjLoKzslIBePrTbcf1CwW308Gg1BgAjjQI29Acaph/pFWaFxkZSU5ODjk5OURGHv97rbM5IT2Rayb0BWDmS6uDPi1fREREOj8F1C7k+hP68dJ3T+LEdN92JocqavlyZxGvrNzNjU8t4cmPj386aaBdPrY308b2xgL+9sFm9hYHd8T3ynF9GNIjhjqvxXNLd1JdZ/8P2idmJJKeFEWd1+KvH2yipq71a2QHd/cFVO8R/ruu2V0EwAgFVGmDH587mB5x4WwvrOB3722wuxwRERHp4BRQu5ix/brx7PQTWPvLs3nz+6fwt6tHN3az/euHm/lg/fFNJw2GmecOZlSfeCpr6/nj+xuDGhpdDgd3Th5It0g3BaXVvLpyj+1h3WEMl4/pRbjLwbbCCv5zHFvPDO4eC3xzBLW6rp4N+0oBjaBK28SGuxun+v7z060s3XbkNc8iIiIiLaGA2kVFh7kY1iuOC0f25E9XjuLWU/sD8PCHm6n3hsYoqtvp4HfTRpAY5WHnoUqe+mTb10JjVWUF15xzMtecczJVlRVtvl98pIe7pgzCYWDtnpJmu9+2p9gIN9OyfXvZvp+7n082Nb9lzJEMSInGcYQlkxv2lVJbbxEf6aZ3t4hAlNqpVVRUMHToUIYOHUpFRdvfa53NxMwUrsjujWXBj15YRXl16HYLFxERkdCmgCoA3DF5ILHhLrYeKOe9nH12l9MoJSachy4fgTGwaGMBCzYUNL5mWRZbN21g66YNARvtzOweww0npgHwbs5+dhy0P4wMSo3htIFJADy2aAtbCspafG6Ex8lvLx2Oy/n1lNqw/nR4LzVIagnLssjNzSU3N3S7YNvtZxdk0Ss+gh0HK3jg7XV2lyMiIiIdlAKqABAT7ubWU337Gj784eaQWIPZYHz/BL43aQAA/1y8lW0HyoN6v7OHpnJieiKWBc8t2UlZlf2jQZOHpJCZGk291+IP72/kUEVNi89NO8IWMmt2fRVQRQIhJtzN76aNAHxdfefnhsa2TSIiItKxKKBKo5tP7U9qrG8P0kcXbLG7nK/59in9OXVgErX1Fn+ct5GSqtqg3csYw4zT0+ndLYLS6jrmLt9l+7RnhzFMHdubpGgPB8tr+MP7G6mtb33TpAZNR1BFAuWkjKTG5QL3vrSa/NIqmysSERGRjkYBVRpFelz84kLfVjRPf7qN/3y+/YjdX+3gMIbfXjqc3t0iyC+t5i/zN1HnPf6Adizhbic/mDIIl8OQd6Cc+evsHw0Kdzu5bkJfPC4Hm/PLeOI4uy7X1nvZtN83TXhoTwVUCay7z85kSI9YDpbX8KMXVuENkTXtIiIi0jEooMrXnDe8B7dNzADgd+9t4Lp/fMGLy3dxsLzlU0qDJTbCzZ+vGkWYy0HOnhKe+WxHUO/Xq1sE3zvDN7X4k82F5OwpCer9WiIxOoyrx/XBAB9tPMB7Oa0PzlsKyqip9xId5lKDJAm4MJeTv141inC3g483HeDJT7baXZKIiIh0IAqo8g33nJ3Jzy/IItLjJGdPCb9+M5cz/7iIO59byVr/1FC7DEyJYfZUf9OkJg2TguWE9ETOH94DgBeX7yK/xP4piwNSojlnWCoA//psG+v2ti44r9/r215mcPcYHEdq8SvSRgNTY/jZBVkAzH5vfeOaZxEREZFjUUCVbzDG8O1T+rPg7once04mw3vFUee1WLihgBueXMLDH24O6vTaY5mYmcL/nTsEDDhjU4hL7hnUTrTXTOjL0J6x1Hktnl26k+pa+xtInZieyIjecVgW/PWDTRS1omlSQ6Ad0iM2WOV1OsYY+vXrR79+/dT1uIWuGd+Xc4Z2p7be4s7nVlJRY3+zMREREQl9XS6gGmOmG2Pm+B/zjDHT7a4pVKXGhnPbxAG88f1TmPeD07hwZE/qLYsnPs7j7rmrqbIxqF0xrg/fO3Movb/7FPHffpwPNgVvhMbpMNwxeSDdIt0cKKvhlS/32L7ViDGGi0f2JDkmjEMVtTyyYEuL1wvnKqC2WmRkJNu2bWPbtm1ERkbaXU6HYIzhocuH0z02nLwD5fz6zVy7SxIREZEOoEsFVGPMLGCZZVkzLMuaAUwDZhlj5thcWsgbmBrD364ezV+uGoXbaViwPp9bn1nWqu1OAm36aelMP823Nc6/P9/OSyt2BS04xkW4+cGZg3AYyNlTwud5B4Nyn9bwuBxcNa4PTodhze5i3lq9t0XnrfNP8R3SIyaY5YkQH+nhj1eOxBh4dslOFmzIt7skERERCXFdKqAC04Hshk8syyoCHvc/Ly1w8ahe/PeWE4gNd7F6VzE3PbWEXYcqbKnFGMPtkwY0NnWau2wXzy7ZGbSQOig1hhtOTAPg3Zx97Dhoz9fdVEpMGBcM7w7As0t2HPO/RUFpNQfKqjEGMrsroErwnZSRxLdO8m09838vrwnqFlEiIiLS8XW1gHoQiD/suUIAY0x6u1fTQY3vn8DLt51Er/gIthVWcO0TX7BqZ1G711FZWcmkU07kuZ9cx50T+wHw+qo9PPPZ9qCF1LOHpnJCegJeC15Ytisk1tWN7deNzNRovBbM+SjvqFN9G9af9k+MItLjaq8SO7zKykrGjRvHuHHjqKystLucDueeszPplxjJ3uIqZr+73u5yREREJIR1qYBqWVaGZVmzD3t6nP+1PBtK6rAGpMTw0ndPYkTvOIoqa/nuf5azfHv7Tnv1er2sXLGclSuWc2V2b356/hAM8M7afUELqcYYZpyWQffYcIora3lx+W7b94o1xnDhyJ64HIZN+8uO2t1YDZKOj9frZdmyZSxbtgyvjQ3COqoIj5OHLhsBwP++2MGm/aU2VyQiIiKhqksF1MMZY+KBqcDMVp6Xc6QHkBGMOkNV97hwnp9+IiemJ1JeU893/7PC1h88p2X34ecX+ra2eGftPv7zxY6ghNQIj5MfnDkQp8OwKb+Mhe2w3c2xxEW4mTIkBYD/LdlBefWRR3a/Cqia3ivt68SMRM4emorXggff0SiqiIiIHFmXDqjAXODFI4yqSgtFeJz881vjOGVAEtV1Xn722lpbt6C5bIxvJBXgrdV7+ffnwRlJ7ZcYxQx/g6YFGwrYsM/+EaET0hNJjgmjtKqOV1buPuIx6/c1NEjSCKq0v5nnDMblMHy4Pp/P8wrtLkdERERCUIcMqMaYKcaY5S183NvMNWYBRZZlTWvt/S3LGnqkB7ClrV9bRxTudvLHK0YSE+5i3d5SPtl0wNZ6pmX34Sf+kPr2mn08/lEe9d7Ah9TTBiVzVlYqAM8v20lBaXXA79EaTofhnKG+et5es5fCsq/XYwGb88sAGKyAKjZIT47mynF9APjHx1ttrkZERERCUYcMqJZlzbcsa2wLH98YHTXGTAXSG8Kpf6qvtEFKbDiXju4FYHtABbgiuw/3XzQUY3wjnLPfWx+UhkY3nNiPwd1jqK23+N+SHbbuDQswMCWatMRIvBbfGEWtqfNS57WIDXfRMy7cpgqlq/v2Kb6Ovh+s38+OQvs7YYuIiEho6ZABtS2MMWOAMw8bOZ2ukNp2Jw9IAmDVriJ7C/G7dHQv/nTFKDxOB6t2FvOTV9YGfEscl9PBXVMGkhDl4UBZDXOX77K1aZIxhjMG+9aiLlifT0nlV1t6VNf5pl4P7hGLMcaW+kQykqM5fVAylgX/+myb3eWIiIhIiOlSAdW/lcxcYLkxZrr/cS9wpX9PVGmDLP+00a0Hyqmtb591qIlJSSQmJTX7+qTBKTz97XF0jw1nb3EV//fKWhZuyA/outT4SA93nzUIp8OwcX8ZC2xumpSWGEmv+HDqLfhwfX7j8zV1vtHdLE3vPS5JSUkkHeW9Ji33rZPTAHhh6U4qa+yddSAiIiKhpUsFVGA5kA7MafKYZWtFnUiv+AiSosOorbdYsf1Q0O8XFRXFlh172LJjD1FRUc0eN7RnHM9OP4EJ/ROoqfPy90V5PLxgc0Cn/KYnRzc2TVq4oaCxGZEdjDGMS0sA4ONNBxrDeHWtfwS1uzr4tlZUVBQFBQUUFBQc9b0mLXPawGR6d4ugtLqOBRvyj32CiIiIdBldKqBaltXNsixzhMdYu2vrDBwOw6TMZACeXRKcLV6OV0KUh8euG8v3Jg3AYWDx5kJmvrQmoN13TxuUzDlDuwPwwrKdHCizr2nS0J6xOA3sLqpk16FK4KspvurgK3ZzOAwXjOgJwBur9thcjYiIiISSLhVQJfi+fUp/XA7Dgg0FPPXJVlvXYx7O6TDcelo6T39rPL3iIygoreaXb+TwyordAavzuhP6kpna0DRpp21Nk8LdTvonRwOwelcxAPVeC4eBQakaQRX7XTTSF1A/WJ8fUv9OiIiIiL0UUCWghvSI5UdnZQLw1w83c/2TX7ByR3Cm+1ZWVnL+2VM4/+wpVFZWtvi8kX3ieeE7J3Le8B54Ld8WMb9/b0NApvy6nA5+cOZAukW6KSittrVpUkaybypq01HitKQoIjxOW+rpyCorK5k4cSITJ05s1XtNmjekRwwZyVHU1Hkpq9Y6VBEREfFRQJWA+87p6dx/YRaRHidrd5dw0z+Xcsu/lvJFXmFA7+P1eln88Ucs/vgjvN7WNWWKDnPx4GXD+eVFQ3E5DCt2FPHTV9eSX1rV5rp8TZMyG5smvbV6ry3TnRu2ktlWWA5A/+Qo/nrV6HavozPwer0sWrSIRYsWtfq9JkdmjOFC/yhqWVXtMY4WERGRrkIBVQLOGMNNJ/dn4T0TuXp8H5zGsHTbIab/ezm3PrOMTfvtayB0uEtG9+KZm8eTGhvGnqIqfv5qDlsPlLf5uhkp0Xz/jAEALNl2iPdy9rd7SE2MDgNoXAvrchiG9Ypr1xpEjuaCET3plxhJmFuj+iIiIuKjgCpBkxITzoOXjeCjmZO46aQ03E7Dkq0Huerxz/nL/E1U14XGtL6hPeP4980TGJQaTVFlLb98I4fVAdjL9YT0RG49tT8Ai7cU8ubqve063Tc6zIUBvBagJX4SggakRLPw7okkRnnsLkVERERChAKqBF2v+Ajuv2goH/5oImcPTaXOa/HU4q1c8ffPWL+vxO7yAEiNDeepm8YxLq0bVbVeZr2zgY82tn0/08lDUrn5FF9IXbLtEM8t3UlNXftMEXU6DC6nAZRPJXQZY+wuQUREREKIAqq0mz4Jkcy5PpsnbsgmJSaMbYUVXP+PJby8YldIbEkTE+7m0WvHcs6w7tRbFo8u3MLzS3e2ubYzs1K5a8pAHAbW7S3lyU+2UlKpNXciIiIiIodTQJV2d2ZWKu//4DTOGJxCTb2XX76Ryy9ez7FtS5amPC4HD142vHHU85WVu3lkwRZq69s26nlCeiI/vzCLMJeDPcVV/H1RHrsOVQSi5GZ5LYvael+41hiViIiIiHQECqhii/hID/+4IZt7z8nEYeC1L/dww1NLWt1AKTIyksjIyIDW5jCGOyYP5P6LhuIw8MnmAzz0znoqa9oWoAd3j2X21BH07hZBaXUd//h4K8u3B2cLHoCyKt+2OQ6DEmoABOO9JiIiIiJfp4AqtnE4DLdNHMC/b55At0g3G/aVctXjn/Pn+RtbNAU2KiqKPQeK2HOgiKioqIDXd+noXjxy7RjCXA5y9pTw67dy2zw1NzU2nF9fPIyx/bpRb8GrX+7hlZW7g9IwqrC8BoAkfzdfOX5RUVGUl5dTXl4elPeaiIiIiPgooIrtTh6QxHt3ncZZWb4GSv9cvI3z/vIxjy7YTFFFja21nZSRxFM3jSM6zEVeQTn3v55DQWl1m64Z4XHyo7MGceW4PhhgxY4iHluYx86DgZ3y23C9/kkKVCIiIiLSMSigSkhIiQ1nzvVj+ccN2QzuHkNpdR1zPsrj7D9/xG/fWseOAIe31hjWK47/3jKB7rHh7Cmu4mevrm3zXqkOY7h0dC9+esEQEqI8FJbX8PjHW3lrzd6ArMW1LItVu4oByOoZ2+briYiIiIi0BwVUCRnGGKZkpfL2HafyyDVjGNozlqpaL88v28nFD3/CXc9/yfLtBxu76lZVVXHFpRdzxaUXU1VVFdTa0pKieObm8QxI8e2V+ovXc/g8r7DN1x3aM47ZU0dw2sAkAD7PO8if52/isy2FbdqOZv2+UvJLq3E5DKf6ry3Hr6qqivPPP5/zzz8/6O81ERERka7MhML2Hp2FMSYnKysrKycnx+5SOgXLsvgsr5DHP8pj4Yav9iTN6hHL9Sf246R+0aR1TwRgd8GhdlkbWFpVy91zVzeG04tH9eSK7D44HW3vQrRqZxFPf7qNvcW+ABThdjKmbzzDesXRMz4cRwv3iyworeapxdsoq67jwpE9uHZCP04b0pOBAwag9+bxKS8vJzo6GoCysjKtQw2woUOHkpubm2tZ1lC7axERERF7uewuQKQ5xvw/e/8dH9lZ3v3j73Om91HvZaXVFm+xvet179gYMDWYQELoAZKQPGkEHpL8npCQbxIggZCQEGpIQo0NITQDLtjYxmXX6+19teplpBlNr2fO+f1xzoy0u9KqjUYj6X6/PJ525px7Z27NnM99Xdfnkri5u5abu2s5F4jx5af7+O7BIU6MRvnId49SbV1e65el4LFb+Je3Xss/PnKW/3qun/89NMKp0Ri/e/dm6jzLMyO6us3PJ9+0mydOTfD9wyMEYhmeOR/kmfNBnFYTHTVOWvwO6jw2ql1WPDYzDqsJCUhk80zEMpwYjbL/Qoi8Bq1VDt60t600/3CBQCAQCAQCgaAMCIEqWBNsrvfwt7+yiz+5bytfe66f/3y2n0AoUnz+7V9+npdf3cFd2+rpqXcjLTDauBTMsswH79vKjhYvH/3+cU6Px/jQQ0d4y/Vt3LO9YVnRVLMsc89VDdy9rZ6DA1M8fW6SlwbCJLN5To7GODm6sDY8V7f6+K07u7GaRRa/QCAQCAQCgWDtIFJ8S4hI8S0fWUXlBwcu8MBNmwFo+8OHkK12AJp9du7aVs892xu4pt2/4NTYpTA0leRPv3u0aEjU6LXzK3tauGVzbUnSfgEUVeV8IMHZQIwLkwlGI2kC0QzxjFLcRgL8Tgu7Wnzc1F3DNW3+i0S6SPFdHiLFd2URKb4CgUAgEAgKCIFaQoRALS8zRcN/PHmKJ3ujPH1ukswMc6E6j42Xbavn3qt0sWqWSx9RVFSV77w4xOeeOM9UUu+TWuOycs9VDdyxpY5ql7XkxwRQ8iqpXB5NA6fVhNk0979NCNTlIQTqyiIEqkAgEAgEggJCoJYQIVDLy2yiIZXN89TZCX5yfIxHjo8TmxFl9NrN3NRdyx/e20OTz1Hy8SSzCt96YZD/fLavKFQlCXa3+HjXLZto9NlLfsyFIgTq8hACdWURAlUgEAgEAkEBIVBLiCRJKiDZbMszyxEsDE3TyGazAFit1svqTjVAUzVUTUPV9PsAVtPKpfwWUDWKxwWwyJKeh7tK5Iz3SczNpTHfXBMsj0wmU7h5YjXHIRDMQhuQ1DStcbUHIhAIBBsFYZJUYmw2G41tnbisptUeyrKZiGXIqxoWk4TZJGOWp68XW1+ZVzVyqoaSV8nlC9cqDquJKufSUmBVVeXUqVMAdHV1Ia9A+u564cSJE1itVto7u7CUQaCvN8RcW1lOnDiBzWaju7v7qtUey1zMnAPbtm0Tc2CDcP78+ZkLKAKBQCAoA0KglpaTTW2dV/HGf+DV17XyJ/dtXdORltd+9hmGw6mLHlOMiyxBldNKlcuKz2HBYzdjN5swmyRUTSORyRNJ5ZiIZZiIZcjm9bpQCbAaF4Dbemr5xzdfs6Tx5XI5Hvr2NwF44M2/hsViWdJ+lksqlyeWypHI5kll88UaWItJwmk14bFb8DrM2Myrt2jRXOPFU99K9dv/mS+8bS8tVaVPcV7PVMpcW6+01Pro7u6u6BT0XC7H17/+dQDe+ta3ijmwQTDSzwdXexwCgUCwkRACtcSMR9PUw0VGPWuVP7y3h8FQkpFwmvGofpmIZ5lKZFE1CCayBBPZBe1LAmo9Nhq8Npp8Dhq9dpp8dnrq3Usen8Vi4dd+4+1Lfv1iUDWNgVCS48NRzgRi9E4kGA6nGI+mSecW9lm7rCaqXVZq3DbqPDbq3Fb92mOn3mOj1m2l1m3DaTUteGEjr2pEUzkUVcMsS/idljlfW+O2cWtPrWg9swTKOdcElYnFYuGd73znag9DIBAIBIJ1jxCoJUbJa/gcFv745VvWdPQU4K6t9bM+rqgqU4kc4VSOcDJLLK0QTyuklTyqpiFLEg6LCbfdTK3LEF4eG5YruMxWEqlcnoFgkv5ggnOBOCdGYxwbiRBLK3O+RpbAYTVhN5v0f6eku+xmcirxrIKmQSKbJ5FNMTiVmnM/ADazTPWMyHTBoVcCcnmVuBGdnoxniCRzzKwi9zksXNPm4923bGJni++i/UrAR165belvzBLIKqoeRY9nCMYzRNMKyaxCLq/XBuvjkij8qaiahqbpwrtQHy9JErIEsiRN3zbSzK0mGbtFxmk147aZ8Tks+J36ZTUj1gKBQCAQCASCpSEE6gpwz/Z6nNb1+9aaZdmI/K2u4Y6iKDz+6CMA3H3PvZjN87/nmqaRzatEUwrhZJbxWIaRcIqBUJK+ySR9Qb3P6GxYTBKbal1sqnXRVu2k0Wun1m3D6zDjsMwd9VQ1jWQ2TzSVI5LKMZXMEk7mmEpkCSWzTCVyhJJZwsks6ZxKRlEZjaTnHMdsyJJuzBRJ5XjyzCS/ODPJO2/u5AN3da/YQkk6l2dwKsXwVJJALMNkLMNkPMtkPMNkPEMglim6Ga8GTqO+2e+04LVbcNvNOC0m7BYZs0nGYtRTW0wSVrPJELqmGUJXj2i7bSby+fyi55pgfaEoCj/96U8BuO+++8QcEAgEAoFghRC/sCWmpcrB227sWO1hrEsySp6xSFoXPoks46EIf/imNwDwu1/9JTnZSiqnkMqqZBS9FjSjqKRzxu1cnnROJb8A52q3zUyL30Gz386mWhc9DR7aqh1L6qMqSxJumx7ha/ZfufYzncsTTuWIpXPE0wrJbJ5ULm9EFMFs1LW6bWb8TiteuxmP3YJJlsgqKoOhJD85PsZTZyf591/2Ueex8eZ9bYse86VomkZ/KMkLF0IcG45wYjRGXzDBQkzALSapKBRdVjMOqwmzLCEbwnnmLiSmI6bTwtpwYdYKEVb9fl7TzbYyikoqmyeZzRPP6NH8vLEokMymLqujXixOq4lau8ZTf6bPtT/4r2ep9ntxWk04LCYchc/DYaHGbaXBa8duEdHb9UYmk+HVr341oLcaEgJVIBAIBIKVQfzClhibWaat2rnawygSSysMTSUZjaQJJbJEUzlyeRVJknDbzdS5bbRVO+iscVXMSXUyq9A7keDMeJxzE3EuTCToDyYYj13spKhmpyOM/3t4BNm68D6jkqSL0BqjJrTRp9fEtvgdtFQ58NpXxwDFbjHRaDHR6F18z1SrWaa73s0H6jfTXu3k688P8OlHz3BTd82SxqJqGseGIzx6MsATpydmFXoum4l6j50al26Y5Tcij36npfiYx2Yua7q7VohYp3PE0grRdI5kJk8yq5DOqWQNB+m8qpFXNRRVI6voj6dzhtAtvM4Qvn3x6bn2nYPDyNbgFcdQ67bSUe2krdpJa5WTJp+dOo8Nv9OCx2bGYdVTtxfrhi0QCAQCgUCw3hECdR2hahqnx2I82xvkyFCEE6NRgvEFmhhJ0F7lZHuTlx3NXq5q9rKlwb2iqcrRVI4Lkwl6JxP69USC3on4ZUJ0JjazTI3Lis9pwSE5KFgrvuHaFrweN3aLjM1swmqWjdRNWb+Y9Gub2YTNLOOwmooRvPXIq3c3cWQowtHhCP/y83OLeu3J0Sg/PjrKIycDTMz4LMyyxNZGD9saPXTXuemsdS25RdBKIkkSLpsZl81Mk2/+7a9ERskTimcZngzzfz6tP/aa3U3kZOt0ZF5RSWYVYmmFKSNNW091zvLiQPiK+3dYTHjsZrwOSzEa7rbp4tVuMWE16bW2kiQVa3YBTLKExSQXt3Na9TmvR/g1lLxG2sgeSOfyZBUVxegJbJL019qNOnG/w6Kbdxl/V+v570IgEAgEAkHlIwTqGkfTNM6Mx/nJ8TF+enyM8ejl4s7nsFDrtlLtsuK2mbGYZFRNI55RCCayjIXTxDIK/aEk/UaKaIEWv4PWKgeNPr3e0u/QT6DdhnmPy2rGadNTHQs1fRoYaZcK0bRe6xlK6KY+Q1MphqaSDISSV6xP9DkstFc7aa9x0lbloMWvj8E9IxqXSib4H2P711/bjMPpKuVbu6aRJIm339TBnzx0hMdOBZgvE1fVNJ44PcHXnuvn8FCk+LjdIrO3o5obOqvZ1eqrmCh7ubCZTTT5Hfit007Nb9zbOudc04wWS+OxNCPhFOPRDONRPXthyjAUS2XzxTTzVE5P4Q5cYVGmnMgSeB16lLcgfgsCuNqlpy+3VTnoafDQXu0UEWCBQCAQCAQlRwjUNcrQVJKfHR/n4WNj9E4mio/bzDI7W3zsaPayud5Na5Vj3iiopmlEUjn6gknOT8TpDSTonYwzlcwxHF5+Dd+VqHZZiyJYvzhp8Ttw28XUXC5t1U6uafNzaDCMqs4tUZ86O8lnHjvLBWMemWSJ6zuruWVzLbtbfWvGfbkSKKTOu+1uuutmb6GkaRq5vEZa0fvmJjIKiWye+IyU4rSiRz0Lbse6o7Hudqxp02Zf2Rk11rm8HiWVjRpei0nGZmQNWMz64pGEXvOby6ukc9OR30gqRzyjoGoQTuYIL8DcymU1cU27n32d1dy6uZbOGueadC4PJ7N86pEzjITTfOKB3VS7Ki8rQCAQCASCjYRQAWuI0UiaR0+O88iJcY6PRIuPm2WJPe1V3LK5hmvbqxbd51KSJPxOK9c4rVzT5i8+Hk3lir0+g4kskaR+EpvM6ifWqZxe16cbEOknyAUZZDFJ2MwmXDbdQMbrsFDltFJn1HsWaj43WkSu3LxiZ6MuUGfRp4mMwl/98ASPngwAerrpy3c0cN+OxopM3V0vSJKE1aynn69WrfNsKKpKLK0L1mRWIZMzBLAhpCPpHJOxDKORNAOhJIlsnmfOBXnmXJB/fPQsLX4Ht/XUcltPLXs7qtbEwsbRoQjv+uoLTBqlEL//rZf46ruuF5FhgUAgEAhWESFQK5xULs/Pjo/xwyOjHJxRzyZJsKPZy62ba9nXWY3LVvqP0uuw4HVY2N7kXdD2mqatyQjKemZ3q4/XXt3M5y454Q5E0/z+tw9xZjyOLMGrdjXxhmtb1nV7JMGVMcsyVU7rghYnVFV3dT4xEuXIUJgTo1GGwym+tX+Qb+0fxGUzcWt3LXdtq+fWzbU4rJW5EPU3Pz7JZDxLV52L0XC6mE3wR/duWe2hCQQCgUCwYRFnoxWKpml8//AIn/35eUIJfXVfArY1ebixq4YbNlXjr7AoV7nFqcVi5Y8/+vHi7dVC1TRCiSyBqN7/M5TIEk7pbWIK9YYSukOvx26mxm2lyae7BTd57cgrGK2RJYlfv6Gdf5txiFQuz29//SB9wSQeu5kP3beVzfWeFRvDesBisfLHf7H6c61SkOXpnsD3724inctzdDjCSwNTHBwIE0nl+OmJcX56YhyrSebeq+p5455Wrp6RobHanBiJ8mxvEJMs8bX33MDzF4L84bcP86WnevmdO7svy+6wWq189rOfLd4WlIfjIxG+9twAHruZD79im4huCwQCwQZACNQKZDKe4c+/d4z9fVOA3rLinu0N3NZTS43btsqjqxzMFgsPvO09ZT1mPK3QH0rQN5mkP5hgIJRkJJwmm1fnf/EsWE0yHTVOuuvcdNfr/VYbPLYVFfufefQsfcEkVU4LH33NDuqX0NKm3Ch5lbRRZwl6WrvDYsJcpjRSs8XCG8s819YSdouJfZ3V7OusRtU0zgfi7O8L8fyFEIFYhh8dHeNHR8e4ZXMNf3zvFjpqVt/Q7CvPXADglTsbafY7eP01Lfzdw6cYj2Z4/kKIO7bUXbS9xWLhAx/4wGoMdcPyxV/08v/9+GTxvsdm5vde1rOKIxIIBAJBORACtcKIpXN84BsvcS4Qx2KS+NXr2njlrkajfYSgHCiqykQsw3g0w1gkzVhUd2QdmkoVo9mXIkvo/T8dFnwOC267GZdVb2kjyxKaBllFJZ7RDWkm41kmYhmyeZWzgThnA3E4ru/L77CwrcnD7lY/17b7S1oPenwkwoMvDgHwW3d0r7g4jaZzDIWSjMcyTCWyJLJ5Mrk8qqahakxfGz1Jc0aP0oyiGjXOuolQRpl9AcBukfHYLHgdF7docVhN2Mwm7Ba56ELrsuqtZwrPOywm3ThIpKWXFFmS6Gnw0NPg4deub+dcIM5jpwI8dXaCZ84FOdj/An//pt3c2LW0/rylIBjP8P1DIwC8+9ZNgJ4Bcve2Br75wgCPnxy/TKAKyks6l+efHz8LwHUdVRzon+LTj55h36bqVZ07AoFAIFh5hECtIDRN48PfOcq5QBy/w8L/e81VNPsdqz2siiWfz3N4/7MAXL3vJkymy+vcCpG3rKKSzasoRedTXQDF0jmmkjmC8QwTcV2UBqLpWU2FCvidFpq8dpr8dhq9duo9NvxO66JTz1RNIxjPMhJJMTylC+DhcIpwKsdzvSGe6w0BsLXRw8u21XNjV82iDbAu5ctP9wFwW08tu1v9y9rXpaiaxmAoycnRGKfHo5wLxIvmM6Wi8A4XPp50TiWd0z+7pWCSJGyGiHXbzLhtZnwOCz6nxajHtOB3WvFaZQZOHsRhNXHtHHNNcDnSDLH6umua+fyTvZwej/F733yJf3zzNdyyuXZVxvXz0xNk8ypXNXnZ015VfPxl2+r55gsDPHYqwEdfe3FNfT6f56mnngLgtttuE3NghXn42CjRtEKL38G3338TH3roCN85OMTf/Pgk3//dW1d7eAKBQCBYQYRArSB+fnqC5y+EsJpk/u8rtwlxOg/ReIIPvPX1APzh154lqpgIJrJMJbJE0wqxdI5cfr4OoLNjMUlUu6xUO61Uu3X34Vq3jQavrWTOw7IkUeexUeexcbUhFnN5leGpFL2TCc4G4gxNpTg9FuP0WIyvPz/A669t5p7tDUtySM2rGr84OwHA665uKcm/IZ5WeHEgxKHBMMeGo8QzymXbVDkt1Lht+OxmHFa9X65J1lumyEbrFFmSMMn6xWySsJpkrGZdODoseiTUZjYVFwHyqkam0KbFiLImDWfpTE53ns0pKpm87jCdMdqxpHJ50rl8cV7kNa3Y2mWu6DiAmk0z+OkHANj95/9Lrd9LjctGrdtqfIb6QkWN2yqMpuagyefgz+7fzueePM+z54P81Q9P8NBv3YRnFZyMnzL+Du7eVn/R47dsrsVmlhmaSnE2EGdLw3Rtdjqd5q677gIgHo/jcq1+mvJ65pvPDwLw5n1tmGSJP33VNr53aJgjQxHOBeJsrp+9jZNAIBAI1j7iTKpC0DSNz/+iF4D7dzfRWStOfmYSSmTpnYhzYTJBXzDJQCjJeDBSfP6hF4eRrXOnq8qS7lJqNkmYZb3Fh82sp37OjJpVO63UuK147GbkVUj9tJhkOmtddNa6uHtbPZFUjkODYfb3TRFJ5fiPX/bzs+PjvP+OLrY1LsxduUA8o2DToKfeTUvV0hc/NE3j+EiUnx4f4+DA1EXRZqtJpr3aQUeNi/ZqBy1+B7YVaCVkkiWcVjNOq5mlJPvl1ek+olllWsAmsgqJjFJstxJLK3padnS6L+hUIkckl+D8RGLWfdstMn6HFZ9jOvXY57Dgd1qodlmpN8TsRmyxZDHJ/Nbt3VyYSDAWTfPPj5/jT1+1vaxjUFWNp89OAnomwUwcVhM3d9fw89MTPHYycJFAFZSPc4E4L/SFkCV403WtANS4bdyxpY7HTwX430PD/PHLt67yKAUCgUCwUgiBWiEcNlaFrSaZ+3c3rfZwVpVCquiJ0Sinx2KcGY9fMboFsKvFS12VD98ltYh2iwmrWV6zzo8+h4U7ttRx6+ZaDg5M8fipCUYjaT76/RO89urmYnRhISSzeWzA9ZuqlzyeY8MRvrV/4CJx1uC1sb3RS0+Dmxa/Y0281yZZwiHr0dmFkEklee8n9Nu/eWsnKSxEUznCyRxTyaxxnTMitCpjOb12+UpUu6w0eu00ePXovN+pL4y4bHr9stumz+XlpnVXGlazzHtv28THfnSS/3lpmPff3lXW458YjRJMZHFZTVw7I723wC2ba/n56QkOD4bLOi7BNE+c1nsz39pTR5NvejHtddc08/ipAN87NMwf3btF1I8LBALBOkUI1AqhYNhxc3cN7hXoaVrJaJrGcDjFidEox4ejnBiJErskVVQC6r02WvwOmnx2Grx2/JY8v/9p/fk3XNuCzeEs/+DLhEmW2NdZzc4WHz85NsbBgTDfPzzC0FSSP7hny4JETDqXByimEy+GcDLLfz7bz7O9QUB30d3T7uf6TdU0rAEX4FLS7HfMOdcySp54WiGa1iOxhfTjQlQ2kpoWsqFEllAiy4nRKx/PZTNR67bR6LXT7Nej0s3G38FajcJe1exjc72bc4E4j5wcL+uxnz6nR0/nquku9H0+ORYt67gE0xwe0rNjru+8eAHh3qsacFpNDIZSHByYYm/H0hfbBAKBQFC5bCwlVKFklDyPntJP0m5f586RmqYRTGTpM1J1zwfinJuIE0tfLEitJpn2Gicd1U46apy0+B2XnUxmUslyDr0icFhMvOHaFjbXu/nOwWEODoT5xE9P8X9fsW3eliteh4V7ttfTusj03oP9U/zT42fJKCoSegT2zi11uO3i6+NSbGYTNrdp3nZQyaxCMJ4laIjUaCpHLKP3zU1m86SVPOmsSl7TSGTyJDJJ+oOXz3e/w0K910adW6+DbfDaiiLWVeELXdd3VnMuEOfps8GyHrdQf3ppem+BbY16Wm9/MEkio1T8+7geOTIUBrisb67Tauae7Q18//AIPz81IQSqQCAQrFPEL28F8My5IIlMnmqXlW1N66PmSdU0xqNp3Zl2KsVIWHeoHQmnSRmRvJlYTBKtVU66al1sqnXRWrU2UkVXi10tPrx2M1/9ZT/HhqP813P9vOuWTVd8jcdm5j23LjydUtM0Hjo4xHcPDgPQ5LPz+muahXlXCXBazTirzbRVzx311zSNtKISTU07TU/GswRiGSbjGZLZPOFUjnAqx5nx+GWvr3Pb6Kpz0V3npqfeTVedu6LSha9u8/ONFwY4VMZUWiWv8mK/3l96LgfhGreNeo+NQCzDqbEYezsuTwMWrBxTiWxxMWZ3i/+y52/dXMv3D4/wXG95FzYEAoFAUD42rECVJOl9wF7jbhfwoKZpX1iNsTx6Qo+e3tRdsyrGPKVAVTXOBuIcH4lwcjTG+Yk4yezlQhR0w6I6j40mn50WI9rT5LeLXq+LpKPGxVv2tfG15wf46fFxbuyqKaYnLhdN0/jy0xd47JReC3bjpmru29kgPqMyIkkSDsPFWE+jvnjxKplVmEroNbBTRi1sKKH3142mFSaM1knPX9DbFZkk2NroZWeLj2va/HTWOFe1hq/V78Bmlknl8mja0ty2F8uZ8TjpnIrHZqa7bm4X2O1NXgKxCU6ORoVALTNHhvX03s4aJz7n5Q7PhR6oh4fCpLJ5HNa1meYuEAgEgrnZkAJVkqSPA98uCFJJkvzABUmS9mqa9v5yjkVRVX5prARf37n20pXOB+I8dirA/r7QZWm6Zlmi3mijUusuXOsuuaUQOiazmTd/4P8Wb29EtjZ62Nvh58X+MP97aKRkAvWhg0M8diqAhG5MstFP0itxrhVcjGdzZE5l84xG0gyHUwxOJRkMpYhnFE6MRjkxGuW/DwxS57Zxy+Za7t/VtCrp2rIs0Vrl4PxEgjLpUw4bqaO7Wn3IV8jQ2Nbk4ckzE5yaUYdqsVj4xCc+UbwtWBmOGBH1S9N7C7RV6/XXo5E0BwemVq2XrkAgEAhWjso40yo/7wPOAwcBNE0LS5L0BeBDQFkF6umxGLG0gstqWlN93fqDCb75wuBF6Xl2s0x3vZtNtS7aq53Ue2wrmqZrtli5/61l/bgqktt76jjYH+bQYJhgPDNv/eN8nAvEi2m9r726acOLU1h7c81hNdFV56KrTm9XpWkak/EsF4z+uucCcSbiGb53aJjHT43zrls2FSNT5aTeY9cFapmOV6ht3D2PUdhVBaOk0VjxMavVyp/8yZ+s1NAEBgWDpLk+I0mSuLGrhv95aZjne4NCoAoEAsE6ZKMK1BDgv+SxIIAkSV2apvWWayCnx/Tasa4695qouVQ1jW+9MMj3D+uuwxKwu9XHte1+Omtca+LfsN6odllp8tkZiaQ5NRbjls3LE6hfe64fgGvafFy3BqP6gsuRJIk6I5vh+k3VZBWV0+Mxfn56golYhs88dpaJWIbXXN1c1nF5jMhtuQTq4UFd/FzT5rvidoVMhNNjMVRVu2K0VVBaigZJrXN/Rjd2VfM/Lw3zXG+oTKMSCAQCQTnZkAJV07TuWR7eZzxXNnEKMBxOAdCyBoxnVE3j3544zy+MJvc7m73cs71+2RG7JY8nn6fv9DEAOrfuRDZt3FqklioHI0ZK53IYj6Y5PR5DluDe7Q0lGt3aZ73NNatZZleLj+1NHh47GeDpc0G++cIAV7f5ab+CcVOpKbbJKUOObyqb5/S4HhGdL4K6qdaF1SQTzygMTaVor3GSz+c5ePAgAHv27MG0xudAJRKMZwjEMkgS7GieW6DesEmP9h8aDJPO5ddsuyWBQCAQzM6GFKiXYtSgPgB8eIHbH5/jqdmE7xVJZvW6zbVg9PDDw6P84uwkEvDGPS1z1giVi1w2w0d/8/UAfPGx4+u6D+p82Ax31vQsDsmL4fiIXnPXXu3E6xB1dgXW61wzyzL37Wg0+rHGeOjFQf7o3q2rPawV4cRohLyqUevWDdquhMUk01Xn4tRYjHMTMdprnKTTaa6//noA4vE4LperHMPeUPQZ7r3NPscVfxM7apzUuq1MxrOcHI1ybbsoQxAIBIL1hLDk1HkQeEjTtE+U+8AWo3dlLq+W+9CLQtM0Hj2puw3fv7tp1cWp4GIyij5/bOblLXSEk1kAalcpKi5YHW7YpKdyD4aWF4FfLMWWU2VwE56Z3rsQ9+KOGn0RotzvyUamP5gApt/7uZAkiZ0teoT1mOH6KxAIBIL1w4aPoBqOvmFN09600NdomrZjjn0dB65azPFr3VYAJuOZxbys7EwYqVcA1wpxWnFMxnVhWedZnrBUy2WnKqgoCgtliawyz5alJZLKAXot+0pzbEQXMgVhMx+FVOeBUHLFxiS4mEIEtaNm/uj0rhYfT5ye4KgQqAKBQLDu2NARVEmSHgC6CuLUSPUtK4U6m+MjUfJq5YqDKqeVgk9ILJ1b3cEILiKj5IuRh62Nnnm2vjKNPr0WurAYIdgYFFK7tzYsb/4sllGjZrocAvX0mF5/uq1xYa2YhEAtP4Xvsc55IqjAjAhqdJ4tBQKBQLDW2LACVZKkPcC9l0RO31dukbq71UeV00IsrfDIifFyHnpRWExy8cTukZOBVR6NYCaHBsKoGjR67TTPU1s3H91GW5LBqaRYiNggnA3E+eV5vRfzrT3la9mRzuWLpl4rneGr5FXOBnTH9G0LXMRpqy6k+AqBWi4WE0EtCNQz47Fl194LBAKBoLLYkAJVkqQu9LrTFyVJep9x+RDwZk3TwuUci8Uk81t36N5K39o/wJnx2DyvWD1+48Z2JEmPtjxzbnK1hyNAP8kvuCq/alfjgmrrrkSTz8HWBg+aRlG0CNYnmqZxaDDMN54fQANu76nl+jK2FTo5GkXVdAfz5c7b+egPJckqKg6LacEuxTMjqJpIfS8LxQhq7fyfUbPPTrXLiqJqxei4QCAQCNYHG1KgAi8CXcDnZ1w+vlqDecO1LVzd6iOdU/no94/zzRcGmDLMaiqJrjo3b9nXBsBPjo/zxOkJceK2imiaxvcOjRBNK9R5bNy5tb4k+3311U0APHMuyMgy29YIKpN4RuHBF4f5zsFhFFVjV4uP37yta8WF4kwKCyA3d9es+LEKAmZLg3vBPU1bqhxIEiSzeYKJyvs+Xm+Ek1nCST1rYyGLCBcZJY2IOlSBQCBYT2xIkyRN0yrKk94kS3zmLdfy8Z+c4uFjY/zvoRG+f3iEnc0+btlcw/WbqnFaK+Ojeu3VzeTyGg+9OMRjpwIMhJK84dpmPPbytyQxmc28/t2/X7y9kVA1jR8dGeX4SBRZgv/zss1YzaVZb7quo5obNlXz/IUQ33hhkN+8tRO/01qSfa9V1stcyyh5fnk+yC/OTKKoGhLwwN5WXn9Ny4KFWymYiKV5/oIuUO/f1cQ/r/DxThkCdTE12jaziUavndFImoFQkp2NLv7iL/4CAItFtGAqNYX03gavbcG/dzubvfzizIRw8hUIBIJ1xto901pneOxm/vr1O7lrax1ff36Aw0MRjg7rly8/fYHrOqq5ZXMN17T5MZtWL/AtSRIP7G3FbTPzX8/2cTYQ5zOPneNl2+rZ21FVMpG0EMwWK7/ym39QtuNVCplcnv85NFI0tnnf7V301JfW3OY9t25icCrJSDjNv/+yn7fd2L6hW8+s9bmWyuV5sX+KX54LEsvoTr2bal286+ZOespsjKSqGl946gK5vMaedj87WxZmWrQcTo8ZJlALNEgq0FbtZDSSZjCUZE97FR/96EdXYHQCmNliZuH9ZQsR1MJ3oUAgEAjWB0KgVhgv297Ay7Y3MBhK8rMT4/z46Ch9wSTP9gZ5tjeIw2Li6jYfO5t9bG/y0uS3I5cxLa/AK3Y2sqPZy78+cZ4Lkwl+fGyMn5+e4PpNVVzfWY3XISIMK8HQVJIHXxwmlMgiS/CBuzZzy+aFGduEUzn+5KHDfOx1O7Fbrtwv1WO38Gevuoq//MFxArEM//rEed5wbQu7FtiiQ1AZBKJpnr8Q4uBAGMVwCa/32HjLvjZu7Kopa0ovQFZR+fLTvRwbjmAxSfz5/dvLMoZCiu9iXYrbq528cCHEQFAYJa00fZP6e7xpEQK1EBE/Ox5HVbWyZgEIBAKBYOUQArVCaat28p5bN/HuWzo5MRrlp8fH+enxMSbjWZ7rDfFcbwgAm1mmo8bJploXm2pddNe5afE7yvJD3Vbt5GOv38ETpyb4wZERxqMZnjwzyS/OTLKp1sXOFi9XNXlx2VZmmqmqykjfOQCaOzcjy+u3pDqj5Pn56Ql+eS6IBtS4rPzeyzYvuGUG6IZKQ1Mp9veFuK2nbt7tq11WPvraHfzTY2c5NRbjvw8McWgwzL3bG2hcplvwWmOtzLW8qjE0leJsIMapsRjj0el2QW3VTl65o5Fbe2qLfU/LhaZpvGQYMg2HU0jAX71u56KiZUsllc3TbzjxLrYN00yjJFVVOXnyJADbt2+v2DmwVilGUBdgkFSgo9qJ1SSTMhyh2xZogCUQCASCykYI1ApHkiR2NPvY0ezjD+7pKTroHhwIc2w4QkZROTMe58x4vPgam1mms9ZFV62LrjpdtDb6VibSapZl7rmqgbu31fNCX4ifHBvj1FiM3skEvZMJfnB4lO46FztafGxtcJe0VjWXSfOnv3EfAF987Dg2x/o7OVE1jWPDUX56fIxoWk/NvLm7hnffugn3IoW/x65v/4Mjo9y6uXZBkasqp5U/v/8qHnpxiP89PFyca1sa3FzfWc3mejemDRC1qNS5llHyDE/pNZL9oSQDwSTZvFp8XgL2dlTxip2NXNXkLXvEVFU1DvRP8f3Dw5yf0AVIjcvKx163gxu6Vt4cCeBsIIam6cet8ywuTb0gUAenkqRSKXbu3AlAPB7H5Vp5cb2RGJzSFxHaqhb+t2U2yXTXuzk5GuX0WEwIVIFAIFgnCIG6hpAliV0tvmKaZV7V6AsmOD2mR0tOjEQ5NRYjlctzeix2kfW+02qiu87N5no3PQ1ueupLKxZlWeLGrhpu7KohEE3zXG+IZ3uDXJhMcG5Cv4DeGmBzvZvuOjdt1Y6yR3LWCqqmcWosxs9PTTAWTQNQ57Hxrls62dO+NI8vn8OCZJYZDCV5+tzkgqKooJt4vXlfG7f11PLgi4M83xsqClWn1cT2Rg9bGz1017nLWoO8EYmnFfpDSfqDCfqDSUYjaS710XbbzOxs8bKnvYpr2vyrYmAWS+d4+twkPz0+VoziWkwSv3Z9O++4qaOsplvnjP6nPQ3uRb+2IHhEiu/KMxrRv+ea/Y5FvW5Lgy5QzwRi3HNVw0oMTSAQCARlRgjUNYxJluiu08Xeq3bprUHyqkZ/MMHJ0RjHR6PFleVkNl80XSrQ7LdzVZOXq9v87Gj2lswpuN5r57XXNPPaa5oZjaR47nyIA/0hzk8kGImkGYmk+cXZSUySfgLYXu2ktcpBi9+Bx24ue5Snksjk8hwZjvBcb4hAbPrE/g3XtvDq3c3LEoCyJPGuWzr53JO9/PszfWxp8NDgXXiqbrPfwe+/bAuj16V45MQ4z5ybJJpWeHEgzIsDYWQJOmtcdNY66ah20ux3zFvrKpgdTdOIpRUCsQxjkTQjkRTD4TShWdqd1Lis9DS42drgZXuTh7Zq56rUpU8lsxweDLO/b4rDQ2HyRs2r127mTXtbecv17VS7yu8GfX5CF6jddYsXqC2GWBqPZYr/HkHpUVWNcWMhrmmR5QNbjLriM6IXqkAgEKwbhEBdZ5hkia46N111bu7frYvWXF7l/EScY8NRjg5HODYcoS+oO7SOhNM8ejKALOn1Wbtb/Oxu9bGpzlWSk9wmn4M37GnhDXtaCCezHBmKcGQowvGRCFPJHH3BZLG9AIDLaqLea6fObaXWbaPGbaXGZcXntGBepzVfiqrSO5Ew3pdo0czGYpJ41a4mXrO7Gbd96X+qM3uZvuPmTp4+F+TocIS/e/gUf37/dmoW6c7b5HPw9ps6eesNHZwcjbK/L8RLA2Em4plianeBKqeFOo+NGpcVv9OK127GYzfjtplx2szYzfKGXpBI5fKE4lmCiSzBRIbJeJZgXL/OKOqsr2mrcrC10cu2Rg/bGj2L/vxKQUbJMxBM0hdMcH4iwZnxWDECVmBro0dfWNnVhMO6egsVvUb2xlIEap3HhkmWyKsak/HM/C8QLIlgIksuryFLLDoNu6de/1xnlrkIBAKBYG0jBOoGwGKS2dboZVujlwf2tgJ6U/RDg2GevxDi2fNBBqdSnByNcXI0xrcPDOJ3WNjTUWW0gfCVJBLmd1q5fUsdt2+pQ9M0RiNpTo3FODMe43wgztBUikQ2z4XJBBdmiBzQa+k8djN+pxWfw4LfYcEp5YrPJzIKVru2JsSOpmmEEtnp9OdA/CIx0uyz87LtDdy5tW7ZBlO/ODPB5544X4z+WEwyn3xgN+/66n5GI2n+9HvH+MCd3exu9S963yZZYmeLj50tPt55s8ZIJM3x4QinxmOcHY8xGc8ylcwxlcxdcR8uqwm3TReuHrsFr8OM127B67Dgseli1mE1VXytq6ZppBWVZEYhkc2TzOZJZfOkcnnSOf06mc2TyCjE0gqRVG5OEQogS9Dos9NW5aSjxkV3nYuuOveia4+XQy6vEohmjAhuisFQkv5gkpFICu2SgKIEbGvycMeWOu7eVr8kQbgSFCOo9Ysfj0mWqHPbGIumCUTT879AsCTGItNlDIst+ygYX52biJNXtYr/nhAIBALB/AiBukHxO63cubWeO7fWAzAYSupitTfI/gshwqkcj58K8PipACZZoqfezfYmL7tbfWxp8Cz7JECSJJr9Dpr9Du7epo8hq6gMTiUZnkoxNJViNJJiPJphPJomo6hE00rRKAhAzU6fMP7DI2ex2vUUYa/dgntGpM5jM+OymXHZTDitZuwWGbvFVJY0yKyiEkpmmYxnjBP9NMNTKeIZ5aLtfA4LN2yq5pbNtWxpcC9baGuaxlNnJ/m3J8+joYuHAnUeG198217+8L8PczYQ528fPsXejirefF3bkk1GJEmixa+nab98RyOg1yEOhpIMh9MEYmkmYhnCyRxTyWxRnOVVbfpzjVxh/4DdYsJp1S8Oqwm7xYTdLGMzmzCbJCwmGbMsYTZJmCQJk0nCLMvIkp7eLEmgano6YV7TUPIaiqqi5DWyeZVcXkVRNfKqhqpqF9V25tLTUejvHBxCM9vJKioZRSU9Q4AuJQvU57DQ6LXT6LPT5LPT5HPQ7LfT4LWveI22klcZj2UYj6QZj6UJxrOEkllCcX3OhpLZy4RogRqXVY/iNnnZ2eLlmlZ/xbWXUvJqsX1JV+3STI0afXbGomnGIiKCulKMRvS/r0bf4upPQTdVsltk0jmV/mCCrgpZGBEIBALB0hECVQDotaBt1U4e2NtKLq9yoG+Kp85O8PS5IMPhFKcMI6b/eWkYh8XE1kYPWxrcbKp10VHjosppWbaosprlYk3tTDRNFzGBWJrJmH7iHIxnGQ+FGZyxnaJq80bsLjqeScZqNi4muShcnVYTLqsuaB1WEw6LCatZxmKSkQANvdZXyatk8iqZnFqMjiUzCrGMQtyIkCWy+VmPLUvQ0+Bhd4uP3W0+uuvcJRPMg6EkD704xPMX9FZE9+9q5EuXLCg0+R38+7v28dnHz/HfBwZ5sX+KF/unuK6jinuvamBni2/Z4/HYLVzV7OOq5tl7p2YVlWg6RySVI2II16lklmBcvw4lc0SSWWJpBQ09HTaVyxNMzLq7FWXmYsjxkRiyde45ZrfI+iKJzYzbbiyOGPNJjxRbqHJaqHHpKezlqNNNZfOMRdOMRlLFBaChqSRj0fS8otppNdFerbey6qpz0VOvpxYvNhVzNRiaSpHNq9jMcrGedLE0GnXagZiIoK4UBSO4pkXUxBeQZYnN9W6ODUc5Mx4XAlUgEAjWAUKgCi7DYpK5qbuGm7pr+BC64DnQP8X+Pr3/aiSV49BgmEOD4eJrnFYTrVUOumrdbKpz0VnjpKXKUZK6UUmS8Dks+BwWeuqnH89lszh/8wMAvOc9NxJXYCqRI5TQBU44mSOcyhJN6WIxls4RSyvFtMpsXtVbcqxwYMRlNRVTNdtrnHTX6cK+lI638YzCgb4QT52d5PhIFNBF8Ptu7+Ldt2ziS7O8xmEx8Sf3beWBva187onzPHYqwIH+KQ70T1HtsnJLdw03b66lo9q5IqnTVrNMrdtG7Tw1lHlVI55RiKVzRNMKibRCPKOQyCp6+mw2T0bRP0slrxUjoTnjfl6bjojKkp62aZL1iKvFJGMzFigKixAWk/584d8sAXklx9OveQeSBPfc3IXDbsNm0RcvHFbTjDRly6o4GadzeSbjGT1SH8swEdOvA9E0k/HsZRH7mTgsJtqqHbRVOWn02anz2Gjw2mny2mn226l2WddE6vxsFNJ7u+rcS+4NXej5G0gofPCDHwTAYqmsSPFap1C/vNT+ylvqPRwbjnIuEAMaSzgygUAgEKwGQqCuYVRNo29Sr2HsCyYZi6QJJrIkMgppJU8uP32SnsurxVRPh8WE226m1m2l0WunrVqvceupd88aFSlEV99wbQt5VePMeIyXBsMcH45yaizKQChJMpu/rB+rWZZoMdx5W/wOGnx2Gjw2Gn32krS+sFit/N5H/rJ43wnUe+Y/wVHyKkkj4pnJ5UkbEdBUNk/ciH5G0zmi6VzxfkbRU0BVTX8PzbKE1Ugvddr0iKvbZsbrMOs1sk4r1S4rdW4bLpup5Cf4mqYxNJXi0GCYlwbCnBqLFiNhkgR3b63n3bd2sq3RO+++NtW6+MQDu+mdiPPQi0P8+NgYoUSWHxwZ5QdHRqn32Njd6mdns5eeBk/ZnVhN8vQCxWrypuv/YVWOq2kakVSOYCJLKKFHmAtidCKmX89MfZ8Lv9NCx4xIaFetm646F/Ue25oVoPMx7eC79J6lBdEUTKl8+pOfLMm4BBdTqEFdrINvgUJ9ccEQSyAQCARrGyFQ1xgTsQzP9gZ5rjfICxdCC05nXSgtfgfXtPnZ2eJle5OXnnr3RSmIJllie5P+XIGsotIfSnJ2PMbJ0SgnR2OcCcRIZPL0B3VTlUvxOSzF1jLNfgeNPjv1Hj2attIRKLNJxmvS0zDXEqqqcWEywf6+EC9cCDFyiWtqd52L+3Y08qqdjTQtIZ2xq87Nh16xjT+4ZwtPn5vkx0dHefrcJIFYhkdPjvPoyXEA6j02tjR46Khx0lblNKJsNmFOsgSyilqMDE8ls0wVRGjhYgjRXH7+4la3zUyTz27UduvXrVUOmrx2mvyOsporVQrnA0t38C1QEE1jEZHiu1IUnMaXGkEt1BefnxQCVSAQCNYDG++MZQ0SSmT53qFhHj0Z4PQlvd4cFhPbmjz01LtprXJS77HhsVtwWPV0RatJxmKWscgykgSaptfyRVI5ArE0g6EUFybjnJ9I0DsRZzisu3X+6OgooKdEtlc72Vyv14buavFxdZvvop6pVrNMT72bnvrpfqyapjESTnNuIs6FyQT9wUSx9m08ltHrDlO5YjrqTFw2UzFi5rFbjNYkFqpcFuqMlNAqlxWHWSIwOgxAQ3Mr8jprQxNN5+idSHA+EOf8RJzT47roL2CWJW7YVM3Nm2u4pbt2yQZHl2I1y9y9rZ67t9WTzCoc6Jviud4ghwbDnBmP66mjsQxPn5t+jSRBldNKlVP/zDx2ve6yYGjkNG7bLXrUuVD3W0iptZhl7GYTFpNUkdE8VVUZHxkCLp9rmqaRy+tpyNF0Tk8tN1LM4xkjHTmj6K6+RqQ+mcuTyioLEp6g/x3Wum1G+q2NRu+0mVLhuhRZCeuN5Tj4Fij0Ch4NJ+nr6wOgvb193X3frCaFGtTmJdYJF+pOeyfiaNracHMXCAQCwdwIgVrBpLJ5/vPZPv7ruQFSOV2YSMCuVh93bKnj1s21XNteVbKIYyyd40D/FC/1T/HSYJgTI1GCiWyxV+mjJwOAfrJcaHvRWuWkyWen3muj3mOj3mPH77QgS0Z6b5WDO7bUXXScREbhwmSC3okEfcEEfcEkQ1NJRiNpow2HfhkJXzliYcpn6P37NwLwqn/4GVVer9GqxFwUST6HBa/dgsdhxm01L7kObSVQVJWpRE7vfxnLGnWDacaien/aSOry6LjLZuLGrhru2lrPbT2180bFEhmlGPnUgI989yhvv6njogj4lXBazcXWQACxtMLRYb2P7dlxffFhcCpJLq+3zgklsot7Ey7BJEnFlGmXzYTLZghbswmbxYTVJM2oFZUxG069hbpSCYoLMRrTjr15w51XyWvkVBVlhmPvTDffvKqhaNNOvqpxO5NK8tMP3QfArX/9I/ImG1lFJZ3TXXyVpdj3Fv7NsqSbJrkLf0N6DWiD16gF9ZXH0Xc9UqxBXaKDL0xHUEeDUTZt2gRAPB7H5Vr6PgXTFFqOwbQh1WLpqHEiSfr302Q8uyYMvAQCgUAwN0KgVii9E3H++MEjDIT09NjdrT5+/fp27rmqYV5TmaXisVu4a2s9dxmtZzRNIxDL6L1Kx2KcGI3ywoUQw+HUrL1KC1hMErVuGy1+Bz0NeuS1s8ZFW7WDGpcVl81c7J85E03To1CT8azRkqTQR1OPRgViacYiacaiegR2ZvTp6FAU2XplcSTBRS1KbEYNqcUsYZGnHX3thvmN03DwtVtM2CzTbr9mWUI2xJCm6bXAygzxk1NUckbrkqzRhiSVyxNN6Q7DoUSW8Ax32ivRUe3kqmYvO5q97Gz2sb3ZsyDjqUA0zf+8NMx/vzhEOJlD1SCayvGzE+M8dirAW/a18d7bNi066uaxm7m5u4abu2uKj6maprsqR/Ua6KlE1jClUgxzoxlRRMPUKJ3Lk8nr71VGUYsCL69pxNL6ayqJmS6+/cEUsvXyT84kSficFmpcVmrcev2x32kt9nUtuvoa4ns60lz6GmUBhjO0vsizaRkCtRBBLSwSCkrLVDJH1jCua1iiQLVbdJO+wVCK3om4EKgCgUCwxhECtQI5MRLld75xkFhaocln58/vv4pX7Wos+0msJElGJMd+URQ0EE1zfDRK74SeujsSTjMWTTEWyRBM6PVyo5E0o5E0B/qnLtqnzSzT4LUbUSJb0cW12qWbCvmdFmrdNjprruwcm87lGQxMcdOn9ft/+sptpLAQSRnplakcU4lsse9m1BCDiWx+ztYvq4HFJFHv0XtgNhv1g23VTtqrHWyqdV2USj0XwXhGT9GejHMukODIUJjzM8xCumpdjEh63e9dOxt5+NgYX39+gO8fHuEVOxq5Z3s9V7f5lxyhkyWJOo9tWSeFiqpHIxMZvSdq3Gg/U0iRTWZ0UZs2BG1WyZNVdPOvmf1L86pGYdoUep8WHHvNslRMKzYbkVizLGM1SZhnRGP1a/0iS3pf1Vw6xXuNufb3b9qNz+PGZtHdex1WPWrvtJant65gYVww+hHVe2y4llF/a7eYqHJaCGZFDepKUOiBulz/ga5aty5QJxPc0FUz/wsEAoFAULEIgVphDISS/O43XyKWVtjT7udL79hXdtfU+aj32qn32rlr6+XP5fIqgViGsUiK3okEp8ZinA3EOR+IMxpJkVFUBkLJYmR4Llw2Ey1+B02+aQOleo8uZGtcVvxOK/UzBNGrdjddMeUul1eJpnQzmnhGIWXUA2ZyRosSRe9pms7q7r6JrB7xS2TzJDP6tulcvtjKRFH1FX8JPbXULOt1lDbzjNYlxn2nVU9V9Tv0NM6Zwnyx/WNzeZULkwlOjkY5MhThpcHwrCZUAPs6q3jbTZ28amcj7j/Xx/mvb93Dk2cm+OsfneRcIM6DLw7x4ItD+J0Wbu+p5cauGnY0e2nxO8q6IGKWZdw2GbfNTMPCso/LSiIxLfhv7KoR6Z1rgAuTenpv5zKipwUavHaC4dj8GwoWzXIdfAt01bl48swE5wPx+TcWCAQCQUUjBGoFEUsr/MG3DhFJ5bi61cd/vueGNee8aTHJxbYyezuqL3ouq6iMRdIMh1PFiGsgliYQyzAZyxT7lwbjWRKZy9vWXMrMtMt3fuUFfF5PsQbVbdMvfqeVRp9ex1fnsdFe7axIt1lV04gkc0wmskzGptuHhI2IcCCW0aPS4TR57eL0Ugn9JLy7zs22Rg87mr1cv6mamllSwSVJ4s6t9dzWU8cvz0/yPy8N8+TpCYKJLN8/PMr3D+vmWA6LifYaJ83Ge9fsd+hGWA2eVW/3sh7JG31bU9k8kXSOSePzHo+miaYVoqkcSWPxJGO0kFJUPZVcyavkjRRpWZZwWk147XqqcZ3XRnetm+s3VW+4tMcLk/rCzXLqTws0+eycWPZeBLNRqD9danpvgaJRknDyFQgEgjXP2lI/6xhN0/jLHxynP5Sk2WfnS+/Yt+bE6XxYzTLtNU7aa67sNpvO5RkMJRmcSjIcTjMSTjEeSTMeSzMZ03tATiWzqDNec24igRyZP3VXNlJdvXYLTptJd5Q1nGRnpnhaTdM1qTaz7j5rL9SjGs+ZTXoKqCzphjyFetSiX46mXfR4RtEFSCydI5TMEYxniuJ8MpEtioz58NjNbG/ysqe9ir0dVVzfWY3PuTjRaJIlbuup47aeOpS8ynO9IZ44HWB/X4iTozFSuTynx2KXuUYD1ListFc7i6Lf57DgsplxXFKra7vEzEiWpo2MwDAxMsS2hL64UagBtlvkBdXargbpXJ50PEPS6JurG3spRQGZNKLvBWEZMdKVYymFeFYhndUj8Xl1xlwpA1sb3Ny5tZ57r2pYVk3mWqHPECqliKAutf2JYH4mYhkA6r3LW0Ap9LrtnRARVIFAIFjrrC8FtIb55guD/Pz0BGZZ4nO/sXfDRTtmYreY6Gnw0NPgmXMbVdUYC0ZoMeoCv/j2veRkKzFDFMTSesuPyXiGEUPkTsYzqBqG8VJp+8eWimqXnrpc59FbiVS7rFS5rDR4bTT5HHTWuGjw2kqafms2ydzaU8utPbWAHukenErSN5lgaCpVNMU6NRZlMJQq9uh8abBkQ5gVmyFWC0K3UBuqp1RPp1DbLdNCWAIUdXoxIJFVSOf0iGNWUQ0HXz36qKqgGTZVxXpVSW9zI0t6tFkzFhxy6VRxXPd86hfI1pUTLG6bmXqPjSa/nVa/E79ruuWS02Iq/rsvdjLWx6/kNZLZPFNJ3WhsJJzi4ECYo8MRTo/HOT0e5/O/6GV7k4cPv2Ibuy4xKltP9Bk1qJ01pUnxFawME3FDoC7zN6/Q63ZwKkVWUVe8n7ZAIBAIVg4hUCuAk6NRPvPYWQD+/P7tXN3mX90BrQFkWaLG6+B3fud3ALhzexM225VPcJS8SsgQV9FUjkRWIZPTTXcKRju66Y4uZrKKSkYp1J+qpLIK6Zz+WMF5Nm+0ItHbm0iYJAn0/y4y6zHJEjazjMNqxms3U+OyUltsJ2Iv1qVWQisRq1mmu85dPOGbSTyj0Gv0th0OpwjGddfeeEaZrtMtGBnlVTI5tRgtVPJqsf1LQV5LhhBUNd0FOa3kKWQwZ4z9VAKaouG+9n4AJNkEgMtq0l15jXRyp9VUTC132czFXr5VTt38qyAyHVZddOuicloYW8wyDotpRVLQg/EMj58K8PCxMZ48M8HJ0Rjv+eoB3nVLJ++8uROH1VTyY64mmqYVXcZLES2u99iRZBPb736Au7bVYzaLn85SUYigLndRtt5jw2U1kcjmGQgl2byM3rcCgUAgWF3Er+wqk87l+bPvHUNRNV5+VQPvuLlztYe0ZrDZbPzLv/zLgrc3m+SiwZNgabhtZna3+tnd6l+R/WszUqHjGYWMkjcWBfRFhLxaaOmjGgI2Tyqru/oqqoamUXTo1du5zEg9NlKILSYJk6wLxAKF1GxV0/ufzkw/LiwwWP/05dgsMk6rGafFVFE9deejxm3jTde18abr2piMZ/jYD0/wv4dG+NLTF3jk5DhffNveWWuWV5qnzk5yoD9UfK9LRSiRLbYq6pinpGAh1HlsSGYLPb/yB/zLB25Z9v4E0xQF6jLnnyRJdNS4ODEapT+YEAJVIBAI1jBCoK4y//T4OfqDSeo9Nj7+xt2iH6JgQyNJUrHWt6rC3KvXC7VuG595y7Xce1UDf/WDE/QHk7zrqwf4/716O/s6q+ffQQk5PBjma88NoJa4GLeQ3tvss2O3LD86XIjuTRpiSlA6ShVBBT1afmI0OmePboFAIBCsDVY/n3AD89LAFN/erxfyffJNV4sT8kWiaRoTExNMTEyglTgCIxDMZD3OtVfvbubb77+JZp+d4XCK3//WIc6Ol7eVSjChi5NSL8wVHHxLYZAEunjSNI3RsQCBQGDdzIHVRtO0kgrUQrR8rtZbAoFAIFgbCIG6SuRVjb99+BQAb9nXxh1b6lZ5RGuPZDJJfX099fX1JJPihESwcqzXubap1sXP/ugObuupJaOo/Nn3ji3YTboUFNJwS00pHXwBat1WtFyGC5/5NRoaGtbVHFhNoimFbF6vMy+FQC183oUIukAgEAjWJkKgrhI/Px3g/EQCr93M/33lttUejkAg2KC4bWb+8c3X4LSaOD+R4EwZo6jR1Mq4aRcEyqYSOPgC2Mwm0f93BZiI6z1QfQ4LNvPyU7ELhlgixVcgEAjWNkKgrhLffEFP7X3HzZ34nSK1VyAQrB41bhtXG8ZX5wLl6yM5Gc8C047XpaKQ4lkKg6QCtW7xPV1qAtHSpffC9Oc9Ek6RUebviy0QCASCykQI1FVgPJrm0GAYCXjrDR2rPRyBQCCg0ae7W4dXKKp5Kbm8ylBY7y9bSn2qadp0D9QSpfiCbi4lKC2FHqjLdfAtUOfWW82oGgyGUvO/QCAQCAQViRCoq8Avzk4CsLejqnhSKBAIBKtJoRdqIrMydaGXcmEyQV7V8NjMJTVJCidzxdrW9upSRlCFQC01pTRIgulWMwD9og5VIBAI1ixCoK4CB/unALitRxgjCQSCyqDTSI8sV/3ewQH9e/DajqqS7rcQPW30lqbFTIFaj0jxLTUFgVpfIoEKog5VIBAI1gNCoK4Cx4YjAFzXWdoTM4FAIFgqO5t9ALzYP4Wiqit+vAN9ukC9YVNpe68W6k/bS1h/CiKCuhKUOoIKotWMQCAQrAfMqz2AjUYokWUkkkYCdrX6Vns4axqz2cw73vGO4m2BYKXYCHNt36Zqql1WQoksL1yY4ubumhU7lqKq7DcE6i2ba0u674Iw6SyxQG3wOXHtfBkNXtu6nQPlJrACAlW0mhEIBIK1j/iVLTOHBsMA9DS48dpF24LlYLPZ+OpXv7rawxBsADbCXLOYZF69u4n/fLafb70wsKIC9UDfFPGMQrXLyq6W0i7UFWoPO0rUYqZAc42X2vv/kJ5GDzabiKaWgpWIoHbWCIEqEAgEax2R4ltmDvQX0tpW7uRPIBAIlsJ7bt2ELMEz54PFWvmV4InTEwDct6MRk1zaHjP9odK3mIFpETVpOM8Klk/RxbekAlX/3IenUmSVlU9VFwgEAkHpEQK1zDzXGwRKn9a2EdE0jUQiQSKRQNO01R6OYB2zUeZaR42Lt1zfDsDfPHyKdG5leknu7wsBcOfW0hvFFSKonSWOoNa6rajZNBNTUXKix+ayyeVVQgm9D269p3Ru9nUeGw6L3mpmOCxazQgEAsFaRAjUMjIWSdMfTCJLcPNmEUFdLslkErfbjdvtJpkUhhiClWMjzbUP3beVWreNC5MJPv6TUyUX5Klcnj6jTnRfZ2kNkuIZhcm4LnpKbZJkQ2Hw0w8w8KkHGJoIl3TfG5Gg8TmZZAm/o3TlLnqrmYJRkkjzFQgEgrWIEKglZjCU5DsvDs363IF+PWqwq9Uv6k8FAkFF4nda+cxbrkGW4PuHR/n2gcGS7n/EiGp57WaqXaVt3VIQJNUua8m/Y2emIk+INN9lU0iVrnFZkUuc5l3ofyucfAUCgWBtIgRqicnlNcZjs5+8HBnS28uUuq2CQCAQlJJbNtfyoVdsA+AffnaGJ89MlGzfhbpAl630Hn3FFjPVpY2eXsrkHN/xgoVTEPkr0b6n4OQrBKpAIBCsTYRAXQGiqdysj58aiwGwW7SXEQgEFc77b+/iLfvaUDX4yHePctTo37xc7BYTALG0gqqWNn14pVrMXErQqJ0ULJ1Cim+Nu7RRdJgZQRUpvgKBQLAWKZtAlSTpVyRJ+qAkSZ3GfZ8kST+VJCkvSdIZSZLuKtdYVprZBKqmafRN6j+WWxs85R6SQCAQLApJkvjY63dy19Y6MorKH/33YUYj6WXvt7XKgd0iE88onAnESjDSaQZC+ndse4kNki6lIK4ES6eQ4lu3EhFU4/MvODoLBAKBYG1RFoEqSdJ7gYeATwDnJUm6Bvgi0A08BkSBR9eLSA3PIlCDiSyJbB5ZKr15h0AgEKwEFpPMZ399D9ubvIQSWT700JFlO/taTDJ72qsA+N9DI6UYZpG+SaPFzAqn+AYTIsV3uRTSpGtL2GKmQMEkaSCULHmUXiAQCAQrT7kiqPeii9Eq4M3oQjWoadpmTdNermnadUAP8FtlGs+KMlv619CUbgzS7HdgM5vKPSSBQCBYEi6bmS+8bS8+h4UTo1H+8gcnUJfp7PuGa1sA+OYLAyXtVTmwQj1QLyUkIqjLZrJYg1r6FN8mnx2zLJFVVMaiy4/6CwQCgaC8lN6lYnb2a5p2wbj9kCRJm4AHZ26gaVqvJEkHyjQeJEm6B3gTEAb8wIuapn2hFPsOzuLwODRVHvOOjYTJZOKBBx4o3hYIVoqNPtfaqp18/m17+Y0vPc/PToxT5bTwwfu2IktLc1+9Y0sdVU4LU8kcBwemSjLGjJJnJKIvBHasQIqvyWTippfdz+GhMKGUUvL9bzQK7YBqXKWPoJpNMm3VTi5MJugLJmj2O0p+DIFAIBCsHOUSqJcutx8EQrNsVxZ7W0mS9gAf1zRt74zHHpEkKaRp2kPL3f9UMkcur2IxTQeoR8L6Kq4QqKXDbrfz4IMPzr+hQLBMxFyDG7tq+Ls37uaDDx7m2weGUFSNj7xyG9ISRKpJlrixq4aHj43x7PlgScY3NJVC08BpNa1IVM5ut/N3//rvvP0rLzAlMnyXTTGCugIpvqD/1l6YTNAfTHJz94ocQiAQCAQrRLlSfCXDIOmnAJqmPaZpWtR44m7DQMkLlLYZ2tx8HPj2JY993nh8eRj/gkuNkgJGvU2jz77sQwgEAsFq8MDeVj71q1cjAd85OMynHz275H1ta9TN4s4F4iUZ28CMFjNLEc0LodASZVL0QV02hQjqSiwmwLSTs2g1IxAIBGuPsghUTdM+CWwGLszy9P9FN1D6IvA35RgPcA/Qe8ljvUCXEV1dMoV+47HMxSlgIaMutW6FVosFAoGgHPzKnlb+/k1XA/CN5we4MLm0Vh6FxbpArDQ1gn1GS5HOFXTwLYipUCJLXpjvLJm8qhFKrJyLL0w7ORecnQUCgUCwdihbmxlN035L07TZTJDeBHRrmvbmQlR1JZkhQMOXPFW437Ws/Rsh1Fz+4pOXWFqPqHrtluXsXjCDRCKBJElIkkQiIU5CBCuHmGsX88a9rdy3owEN+Npz/UvaR6ljnIVI2UoZJCUSCRp8Dvo//mqUTJqppDBKWipTySwFfV/tWtkIasHZWSAQCARrh5LUoEqSdDfwfvTIpN94OAwcQK83/bamaYdme62maRGgNB3gF8Zcda6heZ4vIknS8TmemrPSJZnVWzO47eUq+xUIBIKV4zVXN/PT4+NF59zFEk6WdtGuMI5ytfGajGeKKb+CxVHoI1vltGA2rcw6+cxWM5qmrVjat0AgEAhKz7J/GSRJ+hP0NN0LwN8BnwS+i75Afi/wIeBFSZJekCTpDcs93gpSEoMmzfCDMl3yW5gxWinYRYsZgUCwDihki6RzS2sTMxLRU3tbqkrjsNpvpPh2VK9ciu9MJmMigrpUplvMrJzAb61yIkkQzyiztn4TCAQCQeVSinBetaZpL5/tCUmS/MCj6JHUXwW+I0nSFPCbmqb9TwmOvRQKkVL/JY/7L3l+TjRN2zHb45IkHdc0rgIucvAFir3+rOayZVULBALBivHM+UkArmr2Lun1hZrRTbXLF5SqqjE4VWgxU54IajAhjJKWSjkEqt1ioslrZySSpj+YFNFugUAgWEOUQi3NmTejaVoYCBr1p9XAdcDj6EL1WyU49lK41BypQCGCerAUB7lUiCqqLlDNskgzEggEa5vRSIrvHhwC4M4tdUvax6CRklsKgToaTZNVVCwmqWw9LydiQqAulcJ7t1ItZgoU+uEWousCgUAgWBuUQqCelyTpbxeyoaZpBzVNexO6o291oe1MOTFE86NcbobkB8Kaps0lYBe4f/360ghqoRPsUhvbCwQCQSWQzuX5yHePks6pXNPm58aupVVHjBkpvq1Vy4949htOwm3VTkxlWgQstEkRLJ5Cym3NChkkFegQrWYEAoFgTbJsgapp2heBzZIk7Zck6eoFvqbXSAt+VJKkDy53DEvg4+imTjN5P/DhUh3gsnMk436hRlUgEAjWGomMwru/up8nTk9gMUl88OVblmQ+k1VUEoZxXCn6YPYZAmQlW8xciuiFunQmjQjqSrddExFUgUAgWJuUxFJW07Q3SZL0eeAlSZIOAH+7kBpTTdM+KUnS35ViDItB07RHJUn6sDHm8+juuw9qmvaFkh3jkvsm4yRO9M4rHSaTiVe96lXF2wLBSiHmGuTyKr/99YP88nwQp9XEp371arY3La3+tNAX2ixLJXHxLRokrWD9aWEOjEZSBGWZoBCoS2a6BrVMEdQlOk0LBAKBYHUoWc8TTdPeL0nSg8Dn0WtMNYxUWkmSOjRNm6tZ3qooNk3THgIeKvV+C8GEgilSgULamaoJgVoq7HY7P/rRj1Z7GIINgJhr8Dc/PskvzkxgM8v866/vYVerb8n7KgiUOo8NuQQpuQXDpZWMoBbmwGMnx3nPfxwQKb7LoPDerbRxkUjxFQgEgrVJSZtyapr2KNAtSdI96CmzbzSe6pUkKYzu5tuL3iMVYA/wSCnHsNoUBGqh72mBwkmYkhcCVSAQrC00TePBA7op0l++dseyxClMt5hp9NmXPTaYFiDl6IFaEFUixXfplMPFF6ZTfEOJLNF0rmQ9dwUCgUCwspRUoBYwhOqjkiT5gPcB+9DF6L3GJmF0sfpxTdMeW4kxrBYFE6RkVpn1cZHhKxAI1hqxjEI8o3+n3bq5dtn7uzARB6Cn3r3sfWmaVpYIaoGC8+xkPIOmaUuqwd3IaJo2LVBXuAbVbTNT67YyGc/SP5lc9sKKQCAQCMrDijbl1DQtomnaJzVN+1VN0zZrmiYbl2pN016+3sQpzEzxvViJFlJ8RQ1q6UgkErhcLlwuF4mEMMEQrBwbfa7ZzSbcNn0981wgvuz99Rquuz31nmXvKxDLkM6pmGSJlhVsMVOYA1taalGzaXJ5jWhKmf+FgouIpHLkjEyilXbxhelFiz5hlCQQCARrhhUVqBsZ7ZJaU4tJF6gZJT/b5oIlkkwmSSZFfZFg5dnIc81qlrlrWz0A3zs0vOz9DRimNZtLEEHtM8Rui99xWf/pUlOYAx67LtYnRJrvoilET712M3bLyhuOFdJ8C/NEIBAIBJWPEKglphAgddou/uEtRB9iabHiLhAI1h7vvLkDgB8cHmVwma6oiYy+UOd3lsLBVx/LSjr4XkrBfXYiJgTqYpmIGQZJK5zeW2BTrT4v+oRRkkAgEKwZhEAtMaqhUP2Oi1OXqpz6fWGsIRAI1iJ7O6q5Y0sdeU3jwReHlrUvs1HyEC3Bgl05608L1AijpCVTLoOkAp21IsVXIBAI1hpCoJYYTdNPvi5tQN5s1EYNiH5sAoFgjfLWG9oBePLMxLL2s7NF75/6y/OTyx7TqkRQXUKgLpVii6FyCVRj4aJfCFSBQCBYMwiBugK0+B1FU6QC3XX6j+TR4chqDEkgEAiWTbdRMxpJ5Za1n9u31AHwjecHSOeWV5dfMFzqqitfBLXWI1J8l0rhPSukSa80hQjqZDxLLL28eSsQCASC8iAE6gowWy++3Ya9/dGhCFHxIykQCNYYyazCV56+AIBjmeY2d2+rp8FjI5ZWeObc0qOomqYVzW/KmuLrEiUbS6UYQS1TDareakY/Vt+kyGASCASCtcCK9EHd6LRVXd7qoMXvYFOtiwuTCR45Ps4b97auwsjWF7Isc8cddxRvCwQrxUaca5FkjoePjXJoMMyZ8RhnxuPFXqivv6Z5WfuWJYk7ttbx3weG+MmxsSXvZzyaIZXLY5Il2qpXNsV35hyo8+jf8ZPx7Ioecz1SeM/KVYMK0FnjZDKeoS+YEL1QBQKBYA0gBGqJ8djN7O2ouuxxSZK4b0cD//ZkL998YUAI1BLgcDh44oknVnsYgg3ARppr8YzCp352hm++MEDqkvTbFr+DP7inh7u21i37OHdtree/Dwwtq561d1Lvydpe7cRiWtmFg5lz4LGT44BI8V0K5TZJAj3N90D/lGg1IxAIBGsEIVBLTJ3Hxp1b62d97vXXtPDFpy5woH+KY8MRdraIlVyBQFA5TMQyvPVLz3FmXBd+3XUubuupY2ujh84aJ111LswliiDvbvVhMUkEYpnL+kYvlAvF9N7yGSTBtLgSKb6Lp1iDWqYUX4BNRSdfkeIrEAgEawEhUMtIncfGvdsb+MnxMb7y9AU+9eZrVntIAoFAAEBGyfOur77AmfE4dR4b/+/V27mpqwZJkuZ/8RKwW0xsqnVxZjzOEvUpFyZ0gbqp1l3Ckc1PQVxNxnVxvVLv0XpD0zSCRopvuWpQYdrhWbSaEQgEgrXBxiimqiAKbRq+f3iEQCy9yqNZ2yQSCerq6qirqyORECcegpVjI8y1/31phGPDUXwOC198215u7q5dceFV77EDsER9WhQcm8rg4DtzDjgk3egul9eW7Wi8kYimFLJ5FZg2mioHhQhq70S8bMcUCAQCwdIRArXMXNXsZXerD0XV+PYLg6s9nDXP5OQkk5PL76UoEMzHep9rPzmumxX92vVtK244VMBqXp4ALraYqS2Pg29hDtjMJrx2PQFJpPkunAnjvfLYzdiX6QS9GAoCdSqZYyohjK0EAoGg0hECdRV4YI9ukPSt/YOo6lJjBwKBQFA6Dg+GAbi5u6Zsx1zO15+SVxkwago7yyRQZ1JI852ICcGzUIotZspokATgtJpp9unR+oKxlkAgEAgqFyFQV4GXba/HbTMzHE7x9DJ6AAoEAkEpSOfyBI3IUrP/8jZZK4WSX7pCHQ6nUFQNm1mmyWsv4agWRsEoaUJEUBdM0SCpzAIVoKtOr1M+P7E+U/QFAoFgPSFMklYBu8XE/bsa+faBIb72XD+3b1l+ywaBYLVJZBQm4xmmkjmiqRypXJ6cUW9mkiQsJhmLWcYiS2Bkdqoq5DUNVdVQDaec2QxzZFnvnWkxyZhkCdmojcyrGnlVI5vPk1VUMopKVlHJ5TXyqkreCNFJkoQsS1hNxjhMMhaTvh+TrD9nliXMsozVLGO3yDgsJhxWE3aziXw2f/mg1hE/PjoKQL3Hht9hKdtxHdalp3n2Fh18Xchy+U2KCiY/k6LVzIIptpjxlK/+tEBXnYunz01yXtShCgQCQcUjBOoq8cDeVr59YIhHT47TOxEvru4KykMhYjSVyBJKZJlK6tfhZI5ISr/E0gqpnEImp5LLqyiqdpF4KvjHaJpu8qJpulhSNa34GIAsURQ+VrOMzbg4rCZcVjMeu4Uqp4U6j40Gr522agetVc6y1mjNh6ZpBBNZ+iYT9AWTDISSDIWSDIdTjEXTTMQyJNexiFOz04Zm1/7Vz3A4XdjMMk6rCY/dgt9podZto95ro9Frp8Frp95jo8Zto8ppwWO3YFoFETUXqqrRH0qyvy/EE6cDPHxUrz+9a2tdWR1p69y6UNGWYJN0PqALjc31q/PdWSdazSya8aj+XhXMscpJt/Eb2ysiqAKBQFDxCIG6SnTVubmtp5anzk7y9z87zb++de9qD2lN0zsRJz2R0cVmIstUMkc4lSWaUoildbGZyCiEElkCsQzxjLLaQ74iEtBe46StynmZ6Kn12KhxWan32nHbSvsnnM7lOTYc4fR4jAsTCYbDKUYiaS5MxImm53/PbGYZv9OC127BYTXp0VIgr6GL/EuEvixLmCT9Wp5FGEmSsQCgQV7VX5tXpxcAZAnMJhmrEREtLAKYZRmzESGVANVYPFBUjawyvR9FVY19X/x8RsmTyuVJ56ajsNPvkUp2Cc6tTqsJt82Mx27GbTNjM5uwW004LSacNhNeuwWfQxe7NW4btW4r9R4b1S49qjlblFDJ69FiRVWRjH+rJOm1nZlcnqlkjkAszVAoxeCUvrAwEk5xcjR22d/ArZtree9tXYv+dy2H117dzF1b63nNPy6+2uScIVC7V0ugGhHUgIigLpiCc33DKqRkd9UJJ1+BQCBYKwiBuop84M5unjk3yY+PjvHzUwHu2la/2kOqKFLZPMFEhoFQkoFgkn7j5HoskmYiniEYjmFt7AHg/n9+BtmyuLomi0nC77TqosAQBoXbbrsFt82Ew2rGZtbFjlmWAF0ETEsWrfiYJDGdMipJRXGlalpRmBVSULOKSlrJE88oxDMK4WSOYDzLeDTNSDhFIpunP5ikf57G8h67mc4aF9saPVzbXsWtm2tpq3YsKgoWzyj88PAIPzo6ynO9QXJz1AVKQKPPTluVk5YqB81+O00+Bw0eG3UeGzVuK07r+vtKUVSVSDTBAz+/Fk2DL//2zZisNjI5lWQ2b3x+egR+Ip4hEMswEcsQjGcJJ7MkjMhyMpsnmc0vSdBIEjgsJqxmGc0Q+xnlcvG8GGxmma2NHvZ1VHH39nq2NXqXvK+l0tPgWfJrz5U5girLMtddd13xthCoiydgRFAbvKtXgzoQSqLkVcwmYcEhEAgElcr6O5tcQ/Q0ePi169v5+vMDfPg7R/jB7926KivL5UZVNUajaS5MJBicSjI8paeJBmIZJmOZYrptRlHn2ZNM0zs+DYDLZsLvsFLlsuB3WItisxCxclnNuO1mvHYztR4btW4bLquprOmMC0XTNEKJLBcmE4xHDcET19+byXiGoJGWnMzmiaUVjg5HODoc4cEXhwBo9Nq5a1sdr726hRu7qmf9N2qaxv6+Kf79mQs8fipw0Xtd47KyrclDZ42LZr+deo+dtmon7dUObObKSTsuF2ZZpsbv4edPPbuk1+fyqr4QkVZIZBUSmTyJjELGiNQms3lShtCNpHKEU7li6nkwkSWWVtC0aYG7GDx2M9UuK00+Oy1+B81+B80+O521LrrqXJjltXmSrmka54xI2OYylUc4HA72799fvF/4rg5ERT/rhTJuvFerkeLb5LVjt8ikcyqDU6li6xmBQCAQVB5CoK4yv31nN8+eD9I7meB9//Ui337fjRVVe7hYNE0jllGYjOnptoX6zolYht6JBGcCMc4F4qRz84lPHbMs0eSz016tR+2afLpgqnFbqXbp0U+fw4JlAavhqqYRSytEUzn6g4li2m8ikyeRVYoCIZrKEU0rxNIKyaxCMqsb8GTzajG9FPSolh45lS6+jZ6yapH1lNNCranPYaHKZaXGuFS5rNS59ehjncdWrFGUJIkat16/eCWSWYXRSJr+YJJTo1FeGgxzeCjCWDTNN18Y5JsvDHJNm5+PvHLbRa87NhzhYz88wfMXQsXHOmqcvGZ3M3dvq6O92lmRwn2tYjHJVDmtVDmXZgyTy6szTKc0Y58SVpOMzWLCYpKKc0dV9XpOSZKwmeVZ06bXA0GjXlySplM3y00hCjguBOqCKUSbVyOCKssSm2rdnByNcj4QFwJVIBAIKhghUFcZh8XEp371at7+lRc4PBjm/f/1Ip9/296KF6lZReXkaJQjwxHOjse4MJlgaCrFaCS1IPFpliVaqhy0VTlp9Nlp8OpRzWqXlepC2q3TgvMKUc5cXmUqkeX8RJxQIkc4qYvhcDJHOJmbvp3Sn4ukcsvqu7iSmCSJRkOIb6p10l3n5qpm7xWjXE6rme46N911bu420sPTuTwvDYR57FSAHx8d5dBgmDd/4bmisP5//3uM/3y2H9BTPO/f1cQDe1vZ0uBeMVGqaRq5vEY6p9d16pFAPaIYy+gLAfGMQiqrP5+asSCQMxYF9M9tuva0YESVV/X06ZyqkcsX3Hu1afdewCRLWEwSFrOMrSjqdKOqmaZVdovJuMjYzSZsFhmr2YTVJGE1m4xtCu6+ZlxWvXZ0paOQFpM872LFRqOQ3tu2imZiDUYUcCqZI6PkN2R2wWJI5/JEjNrt+lXKFOqqc3FyNGr0Qm1YlTEIBAKBYH6EQK0A2qqd/P2brub/fOslnjwzwbu/up/P/voeql3lt+Kfi0A0zQt9IY4ORTg2EuFgf5hUbu50Q5fVhN+pp9r6nRaqnVbaq5101rrornPRUuWY88Q+l1eZjGU4PxFnMp5lMp4pXheismPRNJNTUYa/9DsANP/mvyJbFnbSYzPLuG1mXDYzDqsJhyFKnNZpAxuXzYzTOt1mRDfekQwzH30/BfMeVbu4IlXTdEGlqCo5RSOt5ElmZqRwJrNE09O3pxI58prGcDjFcDjFs73B4v4cFhM7W7xsb/JyVZOX3a2+K6aB2y0mbuqu4abuGn77ji4+/4tefnhkFEmCYCJTFKev3NnIB+7aTJNv6SeKBWff/qDh5hvR3XxDxsLAlLEoEE8rKJW6MrBA1FyakTnmmsNiwms343NainPHPfNiN+MxUs29RsS/2qVnACwk8i+4nHLXnwIkk0muuuoqAE6cOIHf6cBqlskqKoFohrZqZ9nGshYp1J/azDJe++qcehTSwc+OC6MkgUAgqGSEQK0Q9nZU8c9vuZb/861D/PJ8kFd+5hf8w5uu4dae2lUZT17VODQ4xc9OjPP4yQBnA5f/oPscFnY0e+lpcNNZrYvOgsusY56ohqppjEXSnJuIc3Y8Tl8wwaDRtiQYzy6o6YSmQT4aAKCtyoHf68Frt+B1mPHaLUbNqX7fbdPFgdtmrjhRoKoaU0ndXXg0kmZoSjdH6p1IkMrl2d83xf6+qeL2jV4717b7ua6jihs2VdPkd8y63xq3jT991Xbef3sXuz6pf15bWry8//Yubu5e/LzKKHmODEU42D/F4aEIp8ZixYjIQjFJEjaL3p7FYTHhtF68UFCIZur9UqedeGWJYoRXMv5XMKTSe6zqt82FPqnGNtMmVdMR1kJkVskbPVOLzr1q0cG3YGSVU1WUvEYqJTFozDW31UxWkoqiO2VEhseXYJbjc1io99ho9Nlp9tlprXbSUe2ko8ZJg9decXO1UlgNgappGv39/cXbkiTR4LUxGEoRiKWFQJ2HmQ6+q1VCsMUw5Tozy++ZQCAQCCoHIVAriD0dVXzlndfxke8epS+Y5De+/Dx3b6vnvbd1zWl2UyqyisrhoTDPng+yvy/Ewf6povso6KJgS4Ob3a1+tjV62NHsZXP9/GmhEaPes89wpB0IJegPJhmaSl3RBMkkS1Q5LVQZUdgqpxWfU3fY9Tn0NhxOSeH1ukcSf/36nTica7OmSJana063N007qaqaxmAoyfmJBL0Tcc4F4gyEkoxF0zx8bIyHj+m9Kxu9dvZ1VnHL5lpu7am9bHGgkB4qSxJffee+Rc2j3ok4T5yZ4NnzQY4MRS6LhEqS3g+y0WunxkjR9jkseO3m4gKB06qnzupuyGtTcKWSCV725/rtz/76tTicLpS8SjKnR8cTRspyMltIY9ZTlpNZ/bmCCVIiY6Q1pxTymlbsuTvbApCE3sqk0WenyWun0W+n0as7Jzf77TT7HDisGzOt9HyZDZLmosFjZzCUKvb3FMzN+Co6+BbY2liIoMZQVW3W1k0CgUAgWH2EQK0wtjR4+Np7buCfHj/LQy8O8fipAI+fCtBV5+K1Vzdzc3ctO1u8y2rnkcgo9AV1oXh6LMbBgSkO9E1dlrLrtpm5dXMtd2yp5cauGrwOy5z7jGcUzgXiXJhMcN6IivZOJgglsnO+Rpag2e+gvdpJa5VDr0X12Kn12PDYzfMavKSS67vhuixJdNS46KhxXVRjejYQ5+RolKPDEc4H4oxF0/zgyCg/ODKK22bm/l2NvPWGDlqqLo+sLkSchhJZHj42yvcPjxYjVQX8RtR8a6OX7joXrVVOrOa1KTqXi9kk4zXJeO1z/13MhappJDIKU8kcoYSewh6IphmPZhiJpBiPpsnlNQIx3cX5CJFZ91Prthp1y7orb2uVk/ZqJ02+9R19Xe0eqAUK6fbCKGl+ig6+q+hU31HjwmKSSGbzDIdTIuotEAgEFYoQqBWIw2riw6/Yxlv2tfG15wZ4+NgYvRMJ/vHRs/zjo2eRJeisdbHdEAkdNdPptVVOK1azjJLXiKZzDIdT9E0mODMe52wgxtlxXdDMRpXTwnWd1exp93NNm5/uOnfRHfRShqaSvHBhioMDUxwfiTIQmrtfZ7XLWoz4NPrsNPsdNHrt1HqsZW9zoeRVw6E3Z0S08kWn3kRGKbbySGXzJHN65KuQ+pnLq0WTJQmM3qh6Gqp1htGO02rCY7Pgc1qocVmp99po9jmuKPAXit1iYleLj10tPn71ujbSuTxnxmMcHorwwoUQE7EM3z4wxIMvDvGGa1v4g3t6FryYcXI0yteeG+CRk+NFkyGTLLG7xce17X52Nvto9K1eet56QpYkPHYLHruF9llOkguO05NGe6EJow47GJ9uOZTI5o3a7CwHB8IXvd4kS7RVOeisddFR46Sz2lVsFVTtsq7pzzCSyjEa0b/DypniOxv1RSdfEUGdj4KDb71n9SKoFpNMV62b0+MxzgZiQqAKBAJBhSIEagXTUePiz+7fzv95WQ9Pngnw5JkJjg1HCRgtW3onlh5B9DsttBnRlp0tXva0V9Fd55rzxDWVzfP8hSAvXAjx3IUQ/cHLBWm1y0prlYMWv4OOGidt1U5a/I6SumxqmkY6pR87lZweQyKRIJZSmEplSeRNRmQqW7wOJbJMJbLEMkrJxrJYfA5LMdK1pcHDlgb3siLhoAvW3a1+drf6eesN7RwfjvKDIyMcGYrwnYPDvHAhxKd+9eor7qN3Is4/P36OX5ydLD7WXefiji113NRdi9tW3q8JVdUXV8JGy5+Cy28ioxRdftO5vNFHVL3I8bdQa6qoGpqmoUGxhtUk6/Wseksg/bqAJOn1sbrjr4zFJGOWwazmsJplpPy0APnu8+fxeNw4rCb8HjcuuwXPDHOkUkSUZUkqtlDqniONNZ5RGI+mGQmnig7aY9EM45E02bxKXzBJ3yx/p26bmY4aPWuhvdpJV62LzfVu2muca6Iv6umxGAAtfge+Eiz6LAfRC3XhFN6j1e713dOgC9Qz43Hu3iacfAUCgaASEQJ1DeCxm3n17mZevbsZgIlYhrOBGL0Tem3n8FSKkUiKUCJLckbdqNUk0+C10ex30F3noqvOTXedi84a14Kiebm8ylNnJ/nR0VGeOTdZ7MEIenru1kYPVzV52dLgobvOjXsFnRmVvMpkPMtgIMT/ecXuy55/zY1XFW+3/eFDyNa5T4JkiaIpj8NoLWIz2ofYzMa1xYTdrLcksZp00WIyXHzBMN9RNRRVQzGMdLKG6U7aaKUSzyiEDYEcNmoNDw2GOTQYBvQobFedi10tPq5u87OlwTNnxHohyJLErlYfu1p9HB+J8K8/P8/gVIrf+vrBWU2nMkqezz3Ry9ef70fVdJF2c3ctr9rZSFeJa/tUVSu+B4WWP9FUjojRl1a/nSOS1K+1CjD9VbNpBj/9wGWP/8t77y7enm2uWU0ybrsuWD02M16HGb/DSpVTr52u89io99jwOSzLimS6bWbcRpuhi8ataYQSWUbCKUbCaUYjKUYiacYiugFZPKNwfCTK8ZHoRa+zmWV6Gtxsa/SyrdHD1gYPm2pdFVfnempMH/e2Rs8qj2RGL9SYEKjzMV40SVrdlkm6UdIoZ8ZjqzoOgUAgEMyNEKhrkDqPfpI7mxNrobWJ2RBVi0XVNA70TfHwsVF+fnqCWHo64ljvsXFNm58dzV52tfqWHf2bjWg6R38wyWAoyUg4xWgkzVgkTSiZ1UVhdv4TwQavjSqf+yJHX6/R4sNjN2O3mOatby01WUXVo10zXHqnkjnOTyQ4P5Hge4dG8NjM7DXMjnY0eZdl4LGj2cffvXEXH/vhSQZCyWLKboFgPMMfPXiYY8P6yf51HVX82vXtNM/hCLxQUtm8YYpV6IubJhBLE0xkFyU6JcBlM+OymXBZZ7j8Wqb7lhYinXq0U7oo5boQNQWjHRAaeZViVFW7rDWQPvcLPVQVVSOZSPAv84yzpcpOFmsxsqsB2bxajNpfCZtZpslnp8XvoLXKSWu13he4zmNb1vyUJYlat95XeHfrxc8V5uFoJG1c69HXwakk6ZzKseFocU4UqPfYLmoR1VPvZkuDB1eZI+sFTo7qwmJbU3kFqiRJxTYzhYWFQi9UkeI7P4X3qN6zuhHULQ2i1YxAIBBUOkKglhhVVUkkZk+9NZlM2O3TP85zbQcgyzIOh2PR25plmaySJJvTmO30WJIknM7puptkMommaQxNJfnZ8TF+dHRs+mRLghqfh1sNd9gGpzR9Yq9kSCkXn5TNdNFNp1No6twuvQ6nyzhuisP9E5wZjXBuIs5k7PJRFyJUFpOEyy4xOOdedd5/exc2h5NcNoOan2n8pEI+S8ELymp3FE80L9/2Yiw2O7KR/qjksuSVuVOF59q23gH1DjvXNNqBaiKpHINRhfOTKc4F4kSTKR4/Gufxo4PUuC3ctbWeu7bVF1NsrTY7JpPJ2G+OXG5uAWSx2vDYLfzpq7bxjV9e4JvS9NyMpXL89jcO0jeZxGk18d7buti7qQabbXpuXsmASpZlbHZ9vqmqxqELYxwajHByLMJgMHVxtFaSkC0FF2FwyAouqwm31YzTEJ+FnrNuu5kqrweP3YzTakbJpplT1UpScQwA2Ux6xnzTjMs0Nodzjm0v2ulF22ZS82cZvOeWTcXt0+k0mWyu2Ham6OKb0eubE6qJaFqPqodjSVLZPL3JJL2jF+/TZpZpq/fTUaObHjW5TbR4bXgcs39d2+yO4nzLZbMoytytf2x2B23Vevr9zG1VTSMQzdAXStA/maQ/mGA4phDL6kZN4+E4L5y92NV7U63TSC/3cV13A63VeolALpcjm517btpsNsxm/d9S2FZbxOrFdATVO8+WpcXpdHL8+PGLHqsXJkkLZjrFtxIiqHA2IJx8BQKBoFIRArXEnD1zmo7Gmlmfu+flr+Bb3/le8f72rjaSydnNhW6+9Ta+//Ajxft7dmwlGJycddtr9uzl0SefKd6/Zd81DA4MzLrt1m3beWb/SwCMhFPce8v1jA+cm3XbmsYWvvXUoeIP+Ltffw8njx6adVt/dQ0P7z9dvP9H734zLz3/y1m3tdgcPPDPj3N8JEoklSPw4EdJ9R6YdVuAv/7hcaqdVlw2E5/5yPvn3O5S/v0Tf8bTP/7OnM9/9kcH8Fbpn9U3/umveey7X5tz23/4zlPUNenhqAc///c8/I0vzrnt33ztp7R2bQHg+//xr3zvK5+Zc9uPful7/Op1V5NXNb7xxc/yyH98CoBB4BDw6Rnb/svXv8eeG28F4Hvf+k/+4aMfnnO/f/+lb3DLXS/H77TSET6IksvNOTc/+HG46c57+Icvfav42P03bC/W+l7KtdffzMe++BA/OzHGL85McOTv3oSais66bUPXVfzePz2I36H3pf3gG29jcmx41m1bNvXwt1//WfH+n7/ndQxfODvrtrWNLXzqu08X7/9/v/1mLpw6Muu2Hn81//LjF4v3//6P3smpl56fdVur3cGXHj8x63Pz8cWP/RH7f/7w3M8/drwoZj//V3/MMz/57pzbpn/v6/RO+gAI/uxzxF/60ZzbfueJgzS1tuv7/dT/xze+NHfc92s/fpquLdsA+I/PfZqv/PMn59z2S9/9GW1bdjEWSfOtL/8LD3/l7y96fgB40rjd8Gt/Q+fO69nXWUXy0I/4yif/35z7/caD/8PLX/FKAB769jf5vd9+35zbXoqqasUa1O1ljqDORkFsxdIKyayyIlkl64FUNk/UyMZZTRdf0L0drGaZdE5lcCpJR83abE8mEAgE6xnxa7rByOZVvvLMBZ44PcHxkegV0xAtJnlFVpcVVeWX54MAmGUJh9VE6grbz+Zyut4wyRLVbusVtzk8FOFaTVt1B9bRSJrf++bBaUfjKwzHaTVviM9vsUjz/F297uom4rKL8WiaAxaZKyUjPnV2kpdXN+J3Xnn+LIWC03BX3ZVP4iUotjuKHRop+TgKDE4lSWbzWM0ynRUgLNxG9D+ZzROIZuisFT+ps1FwjndYTHhWKTW8gEmW2NLg5thwlBMjUSFQBQKBoAKRFpNaJbgykiQd79my9apHfzF75LAcKb4wnbYLuhg8Mhjh6XMTPH0uyEgkjWyxG+OFrTVWrt9UxXUd1XguMTmSJAn7jNTIhaTtAoSTWZ46OcKBviCnxmIXZWlKErRW2elprqOrzkVblQNVyaGpc6fXzkzPjIWn+MCr9sy5LUxHquZL2y13iu+s21ptyMW03Yu3VTWNE6Mxfn46wFQih2S2sKutit+8tYtap2neFN9CGqWSy3H3rg46N22i/u2fYiCY4vXXNPP6a1uK28sm0xVTfDVN46lzk3zt2QGyqoZssdFZ4+TGrho6vTLmOeqdJVnGOmO/mXRqwWm7i9l27rRdnYWl+F68bSaV5L0v2zHndnBxVDSbyVxxHi9mvl26bSqTJRDLMDKVZjCcZCCYIm44UksWK5Iks7XBw3VtHq5t9VDtml2sLiYdeGZK+XzbqrKF85NJvd3R+QCB8PT8ubWnht++o7soBGZL8e1pb2Lz5s2XpdBeyk+OjfFbX3uRnS1efvh7t11x21KTTCbZt28fAPv37y+WStz1909wYTLBt953Izd2zZ49s9F5+uwkv/Hl59lc7+bRP7pjtYfDhx86wrcPDPK7d23mg/dtveK2O3bs4MSJEyc0Tbvyl4FAIBAISoZY7i0xsizjci1sRXah2y1mW03TGE2oHOib4oW+EPv7QiQyM5x9bQ52tfjY21HFdZ1Vi4q62O1XNtC5MJngR0dGeeb8ZFFXSBY7dW4rm+vd9NS76ah2Yru07Yxp4TVJVtvCt7VYV2Zbs8WK2bKw92252+7tdnH1pnp+eS7I46f1NkN//OBh3nZjB/ftaFhQNNVssYAEaUVjKKbhdrt43b4uHFdIR5xZT5zK5vn8k+d5oS8EJist1XZetbORztrFRx5s88yhpW47UwSXctvFsJJz02K14fV42KwbeaNpem3o6fEYJ0djDE2lOD0e4/R4jK8fgJ0tPu7cUse+zuo5295YrFYs1oXNzYVsu7vVyu5WP79xQzunx2P87Pg4z/UG+WV/guf+6wjvurmT997eddFihsViwWJZuJvxatWfgv6enzhxoni7QKPXzoXJBKORK+WBbGyGw3q5QMsyTdhKxY4WLxyA4yOR1R6KQCAQCGZBCNQ1jqKqnB2Pc3BgipcGwrw0GCacvDjS4bGZubbDz3Ud1exu9ZW0LynAmfEYD704xJGh6R/7Fr+DXS1etjd554zmCBaGWZa5fUsdO1t8fP/wCOcnEnz1l328NDDFb9/ZveBFhngmhxe4c0vdgmvlJuMZPvHT0wyGksgS3Lu9gZs315TdBVlwMZIk0eC10+C1c3tPHZFUjhMjUY6NRBkIJTk2HOHYcASn1cRNXTXcva2+5K2DrjQ2vVWNlzfubeUbzw9wcGCKLz/Tx7O9If7mDTtpW2Lad6E1TiW0mCnQWqWLrqGQEKhzMTSlvzctVRUiUJv1BY5LWy0JBAKBoDIQAnUNMpXI8sSZCZ45N8kLl0RIQe/DuKXRzc5mvSfmplrXigiKqWSWbzw/wFNndfMmCT1yc8vmmhVbKbfaHXzxMT0NMJNK8ruv1lPuPvvD/cVUS+siIm9riWqXlXfc1MHzF0L85Pg4h4ci/Pn3jvGRV21f0PudzOTxwoLTECfjGf7yB8eZjGdx28z8+vVtSxYWa5G1NNd8Dgs3dddwU3cNoUSWQ4NhXhoIE07leOxUgMdOBdje5OH+Xc1c2+4v2wJDi9/Bn9y3led6g3zxqV5OjEZ5z38e4PO/sZdNS4jAHxkKA7C71V/agS6D1ip9LgyHhUCdi2FDoLZWiEDd1uhFkiAQyzARy1DnWV1nYYFAIBBcjBCoawRFVXni9ATfPTjMC32hi0rznFYTWxs8bGvysK3RS3eda86awFKgaRqPnQrw1Wf6UAynnD3tfu7cUkfVCkdLJUm6qJ6wgM3hnPXx9YYkSdzYVUNXrYtvvDDIZDzLn373KH/1uh3zmn247WZu7q6hu37+SFokleOvf3SCyXiWGpeVd97csSImPJXMWp1r1S4rd2+r586tdfRNJnlxYIqjwxFOjsY4OXqaJp+dX7u+nes6qspmuHVjVw099W4+8dPTDISSvPur+/nae25YVERtPJpmPJpBlmBnS/lTfOeiGEGdEgJ1LoYM8V4pKb4um5lNtS56JxIcH4lw59b61R6SQCAQCGYgBGqFk87l+c7BIb7+/MBFzeA7a5zs21TNNa1+PUJapl5uubzKvz/Tx+OnAoB+cnb/rsZiFEFQHuq9dt572ya+9twAQ+EUn/zpaf7ujbuLPVNnw2u38Ht398y7b1XT+NwT5xiPZqhyWnjXLZ34HPP3BBVUFrIk0VXnoqvOxcuvauC53iAvXAgxGknzqUfOsKfdzztv7qTOU562HzVuG392/3b+5kcn6Q8l+fhPTvGZt1yzYJF8eDAMQE+9p6LaubQUBersbZkElRdBBdjR7DMEalQIVIFAIKgwVi7MJlg2B/uneODfnuVTj5xlPJrBazfzhmtb+Me3XMPfvXE3b9zTSne9u2ziVFU1/v5np4vi9N7t9bz3tk1CnK4SLpuZt9/cQbXLymQ8y38+21eS/f78dIDDQxFMssRbb2gX4nQd4HNYuG9HIx+6byu399QiS3BwIMwf/ffhYtpsOfDaLfz+y3owyxLPnA/y9Lnggl9bqHHf3epbqeEtiYLoGg6nUFXhin8pSl4ttplp8VfOb0WhDvWEqEMVCASCimPDCVRJkt4nSdLnjcsjkiQtvEt8mdA0jS8/fYH3fe1FRiNpalxWfvO2TXz21/fw5n1tNK5So/P/PjDI4cEIZlni7Td1cPuWutU1y5EkahtbqG1suXIzznWMw2LijXv0djFPnZksngguFVXV+L7Rx/Le7fU0rNJcqzjWyVyzWUzce1UDH7hrM+3VThRV4+M/OcXzvQsXisulye/gvh2NAHz9+f4Fv+6wIaSvbvOvwKjmR5IkOjo66OjouCjq2+i1Y5IlcnndWVlwMeOxDHlVw2KSqK+gWs+dzfpCx5Hh8OoORCAQCASXUTl5UmVAkqSPA9/WNO0Lxn0/cEGSpL2apr1/VQdnoGoaH//JaR56cQiA27fU8q6bN+GwltZ5d7GMR9N8zxAub7i2hZ4F1DGuNDa7g0999+nVHsaq017tpKfezdlAnMdPBvj1G9qXvK8To1ECsQwOi4l9ndUlHOXaZr3NtXqPjXfd3MFDB4c5PhLlnx8/S2etq2wLEq/Y2ciPj42yv2+KwAIWVTRN4+iwHkG9epUMkpxOJ319fZc9bjbJNPnsDE2lGJpK0ugTizozKaT3NvkcZcv2WQi723xIEgyGUsIoSSAQCCqMjRZBfR9wXeGOpmlh4AvG46uONkOcMfKeEwABAABJREFUSsBv3rqJ37lz86qLU4Anz0wA0F3nqrgUO8G0aczp8diy9tM7EQf0z3mu/pmC9YHZJPOr17XSVesir8HXnlt4NHO51LptbDJMvQ70T827/UAoSTiZw2qS2VpBLWYKCKOkuam0HqgFvHYLW+r1uXRwYP45KBAIBILysdHOQEOA/5LHggCSJHWVfTSX8F/P9eviVILfvrObe65qWO0hFemdSACV1X9QME2TTz/5G1lmq4tgIgsgetduEGRJ4lW79HTbFwemyOXVsh278F1ybDgyz5bw0kAYgO3N3opcOBGtZuZmuMJ6oM5kT0cVoPs9CAQCgaByqLxf+hVE07RuTdM+ccnD+4zneldhSEUO9IX4p8fOAfCOmzq5fUvdag7nMqxG2xolXzkmINlMmr949+v4i3e/jmxmebWXax27cdKeyS1PYBRO/hVh9nIR63mu1XtsWEwSmgYTZayhbK/RRd15Y/HrSjx/Qa+Rvb6zakXHdCVSqRT79u1j3759pFIXC9FW4eQ7J8MV1mJmJnva/YCIoAoEAkGlsaFqUC/FqEF9APjwIl93fI6nupcyjqyi8jc/PoUG3Lm1jvt2VE7ktEB3vYsX+kI83xfihq5qLCvYZ3WhaKrKhVNHirc3MmlF//fbLMv7XOqNliNjkfUlwpbLep5r49EMubyGLOlpj+WioTDXFlCD+vyFEAA3bKpZ0TFdCVVVOXDgQPH2TAriS6T4Xs5QBUdQ9xoR1MNDEbKKWpHReYFAINiIbPRv4weBh2aJqpaVHx0dpT+UxO+w8PabOhbcF7Cc3LejkWqXlXAyx9eeGyCVza/2kAQzCBmpuXXu5Rl9XGW0XugLJkhklGWPS1DZJDIK3zs0DMCe9irc9vKtWfqcuhgOxrNX3C4QS9M7kUCSqFjjrkKKrxCol3NhUo+Qd1RXTouZAptqXVQ5LWQVleMj86eaCwQCgaA8rEmBKknSPZIkvbjAy4fm2MfHgbCmaW9a7PE1Tdsx2wU4v5R/zw8O6+64r9rVVFEN6Gdit5j43bs2Y5YleicTfO7J85wYiaJqIhW0EugP6ieBXXWuZe2n2WdnU60LVZuOWgnWH5qmcWosxr892ctwOI3NLPPmfW1lHYPDopu/pXNXXux6wZiH2xq9RVFbabRVT6f4KmWs4610Utl8McV3cwU4v1+KJEnsadejqC+KOlSBQCCoGCpTDc2DpmmPAnuX+npJkh4AugriVJIkv+HoW3ZiaaXYgP6WzauXvrYQrmr28tev38mnHjlDIJbhm/sHqXJauLrVz7ZGD01+++r2Rd2gqJrGcaPZ/M6W5TksS5LE/bua+OzPz/HU2Un2tPvxO4Vh0nohl1c5Nhzll73BYhp3g9fGB1++tRgFLBeFliPzLXE931tI763M6ClAs8+Bw2IilcszEErSVVd5Ymw1OD8RR9OgymmhZpnZHSvFvk3VPHYqwC/PB/nN21bdK1EgEAgErFGBuhwkSdoD3HtJ5PR9kiR9YTVE6snRKBpQ67ZW7A/4TDprXfztr+ziB4dHePRkgKlkjifOTPDEmQmsJpkmv50Wv4PWKgdtVQ58DktFpiyvJ06NxYimFdw2czEasBxu6q7h0ZPjnBqL8dDBYd55UwfmCqg5FiweTdOYjGfpCyY4F4hzLpAga0T4zLLEq3Y18dqrm3HZyv9TkDeMuOb7digYJFWyQJVlic31bo4ORzgzHhcC1eC80baqEqOnBW7dXAvAc71BUYcqEAgEFcKGEqhGK5kHgY9LklTofeoH3rxadagF18f2CqzPmQuXzcxbrm/nDXtaeL43xIH+KY4ORUjl8vQHk/QHp50svXYzbdVO2qsdNHodNHhtOK0mIVpLRF7VeOxkAICXba8vycmVLEm877YuPvzdI/QHk3zn4DBvuq5VRMcrHE3TiKRyjEbSjITTDIVTDE+lSF2SQlvrtvKybQ28bHs9njKaIl1KoY79SuI4EE1zZlwXOddXsEAF6DEE6tnxGK/Y2bjaw6kIzgUqX6Be1eSlxmUlmMjy0sAUN3RVdiaTQCAQbAQ2lEAFXkQXpJ+/5PGD5R+KTsBo67AW+07azCZu31LH7VvqUFWNkUiK3gkjUjMR58Jkgmha4fhItJiCCmC3yFQ7rVS7rNS4rdR77DR6bdR6bIsWQR5/ZZ+0rjSPnBwnEMtgM8u89urmK26bzasc6Atx3QKMZpr8Dj503zb+9uGTHBuJknlugDdd11qsG9yIVMpcy6u6EA0lskzGM0zEMgRiGcajmcvEKIDFJNFT72F7k5dr2/1sqnVVxGJDNJUDwH+FutInTk8AsLvVVxEZJrW1tXM+19Og93U9a4gywbRA7a7giLIsS9yyuZbvHx7h6XOTQqAKBAJBBbChBKqmaavXRG8OCul2az2tSJYlWquctFY5iz1cM0qec4E4Z8fjnAvEGQglCcQypHMqI5E0I5e0MrGaZJr9dtqqnLTX6FHXK5lG2RxO/uXHL67ov6uSeb43yDPn9PTH99/RNW+aZiCa4R8eOcMX334d7gWkdO5s8fEHL9vCZx4/y9lAnM89cZ7XXN1MTwVHQ1aKcs61XF4lksoRSeYIp3L67VSOcDLHVDJLJJVjrja1kgRtVU46a5x017vprnPTUePELFfe98t4TP/7b/bN3X7k8VN6dsBdW+vLMqYr4XK5mJiYmPP5wt/FmfFYuYZU8ayFCCrArT26QH3q7CR//PKtqz0cgUAg2PBsKIFaiRROHLPK+nN+tJlN7Gj2saN52rgno+QZj2YYj6YZj+qpiINTSQaCSTKKSl8wSV8wCef07es9NjpqnHRUO+mocYqaVkDJq/z42Bj7+3TXyTfuaeHm7rkjOwUsJv19OzMWY0/HwtZq9m2q5mOv28mnHjnNZDzLfz7bT1eti9u31NJV69rwn8VS0TSNWFphMq5HPwtR0GAiSyw9f3sfi0mi3mOnyadfWo1FnRa/oyJ6FC+EAaMUoLN29vKGrKLy9LlJAO7etvoCdT62GBHU3okESl7d8HXbSl6lz3AXr3SBeluP/v15ZChMOJkVxnACgUCwygiBuso0evVm9RPxzCqPpDzYzCbaq52X1dyqqsZwOMW5QJwz4zFOj8UYiaQJGCfuBTHmsZlprXLQ6LNT77VR67Lhd1qwb4DU04Jb76MnA8W+p2+6rpVfubZlQa+3W/X36OhIZMECFfRegR9/426+8+IQDx8fo3cyQe9kgmqXld0tPrY3eWjy2YVYNdA0jbSiEkvliKUVPQKazhFN6bfDqRzhZJZcfm7/WrtFpsZlo8ZtpdZto8Zlpc5jo85to85jo8plrYg03eVwxoiu7ZrDefpAX4h4RqHWbZ1zm0qitcqB3SKTzqnCyRfoDyXJ5TUcFtMVo+SVQJPPwZYGN2fG4zx+KsCv7Gld7SEJBALBhkYI1FWmp0E/iTkXiKOqWrH1wkZDliXaqp20VTu5y4iWRFM5To/HODUa49RYlN7JBLGMwsmxGCfHYqi5DIEH/wKAtl/7GD6PC5fNjMtqwmExYbOYsJgkLCYZi0nGapaxm2VcNjMeuxmfw7Imok3hZJZjI1FeuBBiKmnU7Tks/Nad3VzT5l/wfpyGiN9/IcTbbuxYlMBxWs287aZOXrGziR8eGeHxU7pILjg4u21mNtW6aK/WHZwbvPY18d7OhaZp5FWNbF4lq6gkEkm+8GfvQ9U03vCRz6JIFpLZPMmsQiKbJ5nRrxPGdX6uHNwZSBI0eOy0VDmKztdNPt1IzG0zr2vBPxnPcN4QqHM5TxfSe+/YUl8R34upVIpXvvKVADz88MM4HBeLroKT77HhqHDyZUb9ab2rIj6/+XjFzibOjJ/lx0fHhEAVCASCVUYI1FVme5MHt81MPKNwejzG9ibvag+pYvA6LOzrrGafYeqTUfL0TiS4MJmgL5hgcHyKwcFj+nO5PJPxLJPx7KKO4baZqXJa8Dst+Bz6xWtc+x2WVXEcVvIqA6EU5yfinA3EGZ1Rq+uymXjFjkZec3XzoqPGTpsZs9VEMJHl5Gj0otTrhVLnsfGuWzbxa9e3s78vxP6+EEeGIsQzCkeHIxwd1nv6SujGX3UePQpY7bTid1rw2C147GacVlPZI4CappHLa6RzeVK5PPGMUoxqFi6xtEI8o5DKXSwy1WyawWP7AfjOi0PIVvu8x3NaTVQ5rdQYZmDVLmsxKlqIhm7UNNAfHB5BA/Z1VtHou/y91DSNh4+NAbo7dSWgqipPPvlk8fZsbKn3cGw4yrlADNjYTr6nRvVa3J56zyqPZGHcv6uJf3rsLL84O0EsnVtVh2uBQCDY6AiBusqYZZm7ttbxgyOj/OLMhBCoV8BmNrG9yVt8j1LJBE/8qf7c375xF2nNXBQZyUyeZE4hk1OLUbB0Lk8imydqOKBmFJV4Rhckg1OpWY9pNclFt+Fat7WYYlnrtpXM2CqTyzMcTtMfStA3mWQglES5JAK3vcnDLZtruXVz7ZLTmSXgFTsb+c7BYX5weGRJArWA3WLitp46buupI5dXORuIc2IkytlAjD7DvTmYyBJMzL5gIBn7cFhNOCwydosJu8WEzSxjM8uYZZmCr4+qgqKqKKpGVtGvFVVDVTVUTUPV/v/snXd4HNXV/z+zvWi16r3LluTeC8YGjOmEEkoSAgGSUN6E9ISQ9v7elPdNQkglpJNGQgihJhRTTbHBvTf13rW7KtvbzO+P2V1LtrpVrfk8zz5a7d6ZvTtzd+aee875Hjn8WRRlr2f0/VBYjP0f/TseNCoBrf7UMS9JjyMhXl5YijfKBne8QUu8UYPFEFnkMGhnvfDZZNHa4+WNkx0AfOL8wkHbHGjsoaXHi1mnnhX5p1GiSr4n2vpGaHnus6/BAcCKvITp7cgoKUmPoyjVTG2Xm23lnVy3fHSpEwoKCgoKE49ioM4Arl2WxQtH2thRbeOj6/KUldtxkGU1YDSZR91ekiRc/lBMnMbm8mN3BeSH24/DHaDbEyQQFmnv89He5ztjH4kmrewJs8g5ggkmHXF62TuoVQuoBQEE2cAKhkX8IRF3QPbaOdwBulx+2nt9dDn9nG46JRi1LM62sjTHyrLcBKzGiRkTH1ufz3MHWzjc3Mv+hm5WjSEXdSi0ahULM+NZGFk4kCSJbk+Qlkgdzo4+H10uPzann25vkD5vEAnwRjyZU40gyJ7zeIOWRJOW5DjZq5ls1pNk1mE1amPn0aBVo1YJeD1utvxQ3v4bVy0Y01hTOEWfL8jP3qhElGRhmqFqm75wuBWAyxZlzKr88pURY2xPXTeSJJ3TYdrDERYlDjb2AEzINWYqEASBq5dk8stt1bx0pE0xUBUUFBSmEcVAnQGsyEuICTS8dqKDG5X8l0lHEIRIuKl2yFyxQEjE5vLT3uejrcdHS4+X1ojR5fSH6PYE6fYEqew4+7qHyWYdpRkWyjIsLMyKJzvBOCmT29wkEx9bn89fdzbwl/frKEmPm/AFEUEQSDLLIa2DiduERQmnLxjzXnv8YdyBEJ5AGG9ANlpDYTHm8VSr5DxivUbOI9aqVWjUAhqVgFqlQiWAWhBQqeTXojnHmmj+sUpAq1GhUQkYtGp0GtWsFxiajbT1evnZG1U0d3tJteh54IqyQduFRYkXj7QBcM2yzKns4lmzLDcBnUaFzeWn1uae0fU/J5Py9j5c/hBxeg1lGbMnKujqpbKB+lZFJ3aXf0bU3lVQUFCYiygG6gxAEATu3FDAN547xouH27h8Ucao6lQqTC46jYqsBCNZCUbIG/herzdIc7eHlm4vrT0+Opw+bE4/fZEcxtNFcgRBzkmM02tIMOlIj9eTaTWSn2yiINlMknnqyhrcvamIN0520tLj5cFXyvnmVQsx6qbOS6VWCSSYdEophzmCLxjm1ePtPHOgmWBYIjlOx29uXUnmILmnADtr7NhcfhJMWjbOS53i3p4dBq2a5bkJ7KlzsKfOMWcN1H0R1fWV+YmoZ4FAUpSyjHiW5Vg53NzLMweaueeC4unukoKCgsKcRLGCZgiXLkznjzvqqOly84/djdxzQdF0d0lhGGRBJeuQeZwhUUQUQUJCrZLDfWdKuJ9Rp+ZnH17Gx/+8l5ouN9976QSf3TyPzISZXQpCYXbhcAfYVt7Bayc6YrVd1xUm8d8fWDikcQrwxJ5GAD6wNHNW5vGuL0xiT52D3bV2blmbN/IG5yD7GmQDdfUsCe/tzy1r8zjcfJQn9jRx9yblPqygoKAwHcy+u/85ikoQ+OrlpQjI5RXeruic7i6NCkmSxWj8oTD+UJhASESSxidGMx4MRhMGo2nkhlOMRiWHo+o1ajQq1bQZpyFR5OdvVCKedk6KU+P47W2rMOnU1NncPPDsEZ490Iw3MPU5obOFmTrWZhK+YJjddXZ++noFn33iAM8caMHpC5GdYOQ71y7kVx9dMaxx2tnn49XjsnrvR9fmT1W3R43JZMJkGn4MrCtKBmB3nWNKr4UzBUmS2FsnCyStLph9Buo1y7IwR66LO2vt090dBQUFhTmJ4kGdQawuSOLj5xfwp/fq+e07tdjdAT64PHtaa8iFwiJN3V4a7G6aur109PqwueRQVrc/hD80eLkFg1aFSac5Q+HUotfE6pBaDBoSTXLJjfEIoRhNZt461ni2X/GcZl99N7tqHQxWFWNhVjxP3Xse33nhBHvqHTy1v5mXj7VxfnEKG4pTmJ8WNyvqF04FRpOZbUeVsdYfbyBMp9NHa4+XRoeXyg4nlR3OAWrJy3KsfGRNLhcvSEOjGnk99F/7mgiJEivzEliYNbNyF81mM263e8R2K/IS0KgE2np9NHd7yU2aW4satTY37X0+1CphTHWaZwpmvYbrVmTzj92N/GlH/XR3R0FBQWFOohioM4xPXVSMPyTy+O5GntrXzN46B5ctyuC8ouRJzxMMiSLtvT7q7R7qutxUd7qotbkIhsfuBfAFRXzBAI4hyoycTppFT0GKmeJUM0UpcRSmmIkzKMPzbJAkia1HZW/UUHZmhtXAr25dwWvHO/jdu7U0Ojy8dkIOy7QatazMS2RlXgKLsqxTmqc6V5AkSVZ39odwB8LyX38IZ+SvNxDGFwwTCIuERWIeOUEQUKvkyAv5wQCRKJ1mYOkerVoWlBKQ26kE2cuvjQpJqeX9SEAoLOENyn1x+uQ6sT3eAD2eIN3uAN3eIA63H7d/cG97TqKRi8vSuHpJJvPSRp+DKQFP7GkC4Lb1M897OlpMOg3LcxPY19DNq8fbuWuOhYk+d6AFkFWaTbrZeQ2/a2MhT+xp5I2THWiGWIRVUFBQUJg8Zufd4xxGJQh86dIS5qXF8eAr5dTbPfz+3Voe3V5LTqKJ5DgdBo0aCbn+IxJo1AJ6jYr4SP1Fq0nbr9yJCrVKQECuFRkIi3gDYVw+WYXW5vLT5ZSVatt7fYPWiow3aChJt1CcFkdBsolMq5GUOB0WgwajVo1Oo0YdcY6ERQiEwngCYZy+ED3eAN3uIN0eeYLb6w3S6wvGapF2RYSFOiPlXvZEQsMAksw6shOMZFoNpMcbyLAaSLPIJUGMWvWMyemcqRxv7aOiw4lGJQzrCVUJAlcszuDShensrnOw9Wgb26tt9HqDvFXRyVsVnahVAvPT4liUFc/iLCvz0uLQqOdmhkAwLBuUvkiN3WCk3mpYlAhGau5GDTyXP4wnolDs9keUioOnXvP4w4RncRio1aglL8lEUaqZxVnxrMhLpCDZNK7fptMbxNPjJdms46ols0u993SuW5HNvoZu/rm3iU9uLJwz1ypRlHjuoGygzmY1+qLUOD6wNIsXDreOepFVQUFBQWHiUAzUGcq1y7K4YH4Kzx1s5YUjrTTYPTQ65MdkYtKpmZcWR1mGRTZGsq3kJ411wqkheQytuz0BqjpclLf3cby1j/J2J83dXhxu2QN7tKX3jG20agGzWqLxqe+hFgTW3v2/mIxG9Bo1Bq2c+6nTqNBFvElajSA/V5/KDTVGVHUtBtmYP5cmkX2+IL99pwaAG1dm8/NRbKNWCWwoTmZDcTLBsMi++m62V3Wxo9pOS4+X8nYn5e1OnjnQgk6tojDFTH6yiQyrgWSzngSTNhbSPRuPpyTJnsNuTxCb009XZPHG5vLT2e1k3x+/RUiUSL7u6wiaiVUgVqsELAYNVoMWi1GDNbLYFKfXYNKr0UdK5wiCgISEJBEzikVJIixFDWSJQEjEF5QXiXyRWrOBkFy2R4y2FyVCorxg5Q+eMrJVgoBGLWDUqbEatFiNWrlGbJyelDgdKWY9KRYdaRZ50cgygVEODk+AVOCeC4pmZO1Tn8/HjTfeCMAzzzyDwTB0Lu11y7P4/ksnqe50sb+hm9UFg9d7PdfYVStfKywGDZcuTJ/u7pwV920u5oXDrbj8oenuioKCgsKcQzFQZzAJJh0fP7+AOzfk0+X0U97hxOEK4AmG5ZC+iDJsMCTiDoTo8QRjRp1cZ1IODQyF5RClaD1Js15DvEFDSpyetHg9WVYjuUkmCpNNpFsNU14jMtGkY21hEmsLT03inL4QtV0u6mxuGiPlXJocHtp6ffT5QgTDEg6vj+7y3QAcbepBpfONuw86tYrkOB0Z8QZyEo3kJJnIiZSYmY7Q1mBY9sJFPeQGrXrU58XhDvDwm1XYXAFyE43814XFozJQ+6NVqzivOJnzipP5KtDk8LC3vpt99Q721Dvo9gSp6HBS0eEcdHu1SiDRpI3lGKfE6Uky64g3aDDpNOg1smdfFfHuR+nvS5Qk2esfrYkaCkcMsn6toltLyMZXKGakhfEGRbwRT6UvGMYXkr2bwbAY2a+8v0D4lMdzqHB2MeCjt3IPAEmiiIC8mGPQqtGqhVi4rEatwqhVY9KpiTfKOdcWoyZmbFoMcg529HmcXn7PoJ0+Ia2ZQjAkkWTW8bHzZmZ4bzgc5uWXX449H454g5YPLM3kqf3N/GNP45wxUJ/cJ4doX7Msa0YuMoyFsox4LluYzuMqgeB0d0ZBQUFhjqEYqLMAQRBIizeQFj/0iv25hsWgYVluAssGEdnwBsPYXX467L1c/jP5tW9dXYaoMcRy9mKPiFEiqwzL3iJfKCyHOUdy7DwB2ZBv6/XR1uvjYFPPgM9LNGnlEON42WuUHq8n3Sr/bx5jvVp/SPbQ9XrksOfogkL0EQ2FPl18ShDAatCSYpE9WakWPclmPfFGOcw6LEr0+UJUdTjZUW0jGJbQa1T85EPLiDdqx9THwchNMpGbZOKGldmIkkSD3cOJ1j5qbW6aHB66XH5sTj893iCeQJiwKGFzBbC5AlR1us7686cSs15NRrwhVgM302rAqgnzichY2/q5jaQlW6d8IWcucPemolmbt3g6H1mbx1P7m3nxcBv3XlBMaYZlurs0qeyutfPvQ60AfHh17jT3ZmL44Y1Lee9BMydmh6i+goKCwjnDuTETUJhTGLVqchJNJOpOebuuWJyJ2Wwe1/58wXAsD7fB7qG2y0V1l5s6mztiNAbp9gQpbz/TW2iJeKKtRjmsVa0SkCRZcCpqDEfzD12RvMXxIEnQ4w3S4w1SPYrJ0rIcK1+9opTi1NGL1IwWlSBQmGKmMGXw4+0PhXG45TDZ9j5Z5bWjz0eXy0+vJ0ifLxTzZA6VfykgIAigUQmoVYIcpq1WoVHJUQMCp7ytkiSHpkZFgvQaFfqIF9OsU2MxaDHr1Ri1GgxaFZrIfjQRz6dRKwsKxRu0JJq1gxpI/dVbLUatYpxOAlajhttnqPd0PKzMS+DisjS2lXfyhScP8fx9G9BrZrdXcSi8gTAPPHMEgFvW5g66sDgbSTJPbCi/goKCgsLoUAzUCSYkSpxs62NB5swqkXC2uPwhWrq92Fx+er1BvIEw/rBIKCzntImSnBcnSdKAME21SsCoVWM1yl7IrAQj6fH6GTXBN2jVMQ/hmtNC8Zy+II0OD00OL03dHpq7vTR3y8/trgBOn+yFHQt6jYqUuFOe0DSLnrR4A+kWPakWAylxOhJMWow6NWpBIBAW6fOGsLn8tPZ4Y57eLpefHncAdyCMRi1g1mkoy7CwpiCJ9UVJ0xYyqteoybSqybQaWIJ1WvqgMPtIG0dEwkxGEAR+eOMSrvj5dk629fGlJw/z4E1LiTuHviNAp9PHfY8foN7uISPewNevWjDdXVJQUFBQmOWcW3fKGUCTw8Pn/nmI339s1ZAepplMSBSpt3kiNQ1dVHY4qelyYXNNnJKhQasiP2IQZicYSYvXk2TWk2DUkmCKKBEbZ0ZensWgZVGWlUVZZxpabn+I5m7ZO9jjCeLyhwiJEoIg57TqNSpM/fIN5e+nI04/NgEhvUZNqkVNqkV/VgsfoiTxuScO8unNxZRlnFsLKAoKM5E0i4GHblrKPX/bz0tH2zjS0sOt6/K5sCSVwhTzrMzT9IfC2F0BqjtdvF3RxbMHm+nxBLHoNfz8I8uJN5x9SoGCgoKCwtxGMVAnGJ1GhcMd4CtPHeap/zpvRnkKR+KX26r5x+5GAuHBw1CTzDrS4w0kRcIg9ZGwy2gdRrVKDsuMGl9SRIjGEwzT7Q7Q0uOlpduLLyhS0eGiomP43ESdWkWCScuCzHh++qFlE/59zxazXkNphmXW5Jb1eIK8V2On3u7h+fs2zKqxqaAwW9myIJ0n71nP5/95iCaHlx9uLeeHW8sBZBEtgwajTo1eo0avPRXKru4Xzi4Icpi/xKlauIMhCMKA9+VtotEtDChPFn0eVYOWlZ1PlUwKSxKiKC9ahsIRxedITv/plKTH8dvbVlE0CSkFCgoKCgpzD2G4m53C2BAEQQQElUYbM9pmE+HIZCU6IZL/CgOeny0SQDQcmIEhwdGhePqIVEVyEQcjEJA9uzqdkis0HNHjNFvH5kxAGWuTR/TY6vX6ae7J0EiSNGAMjPV6KEmyQSj2u/7NZgSIqckPV2d5tuP3+6NPT0xnPxQUhiAX8EiSlDHdHVFQmEgUD+oEo9PpKCwqnu5ujJtojUQxmk8qgUi/55I0YKIlSpyqrRjdVgS9VkWqZXInm6Io0lBTBUBmbj4qlWpSP2820e0OoFWrSDTrEICK8pNjHpvBsIgvKBIIy16TaLkXQYCsBOPkdX4GMtPGWiAk0tnnH/J9rUYgfQjV75Zub2wxSIiVq4oaGqAWhJjRoRIi/0cEqNQqWVhqop3v0fGZnVeAJxDGOAWhr55gmFBYJDlOz2i+jiiKVFVWAJBfUBgbA8GwRJ83QKrFMOHH5Vyi1xuM1aE+G/p8QfxBEesEqJMPRzAsF7RqqatCr9dTXFy8cFI/UGHGIooi5eVy1ENZWdm0X//7U1NT038RRUHhnEExUCeWk4VFxQvf23twuvsxKJIk0d7np87mpt7ujgnudPT56HL6cbgDcvhXPwRgPFPFohQz379hyUR0e0hCwSCv/vtpAC6/7iY0WiX3CeSJ4H2PHyAkSiwvTOLBG5dQmp1MYVExw41Ntz/Ejmob71ba2FvvwO4OoAW0QP9sakGAxz65Fs0MuklPNjNtrJ1o7eN7L54Y0gs31O9PkiQ+9sc9hE7/oY+ScOSRaNKSnWgkP8lEYUoci7PjWZJtHXdOZXaKlYLCItZ85c9sr7Lx4TW5XLs8e1z7Gg3+UJjPPXGQPl8o9huxjJA7GQwGefrJJwC46cO3oNVqESWJ2/64h4p2JxsWpPOb21aiVc+d38VoefNkB5/86z6MOjX/uvc8MqxjL5kWDIs8+EoFzx1sQS/AD29YSm6SaRJ6SyxNxx8Ko/3pDRQXF3P8+PFJ+SyFmU8wGOTxxx8H4NZbb0U7g+YaixYt4sSJE03T3Q8FhYlGCfGdQARBOF5atmDGGKidfT4ONfdyrKWXk219VHa4cPlHVpzVa1SYIjlROo284h1d+TZESnKYdGqMWjUmnZw/ZdKpsRg0WCICRxa95pwO+5rp7Kq18+u3agiERc4vTubpz1w4pIFab3fz1/frefV4x4D6q1q1XE6mKCWOnCS5HmhqnJ4ksw6NMgmfdqTTohaiXlCNWhg2v1iSJIJhCV8ojC8g1wr2BsJ4AnJNYHcghMcvl0ZyB8I4fUH6vCF6vXLt3tNr9EbRqASW5yawviiZ9UVJlGZYRp3nnJ1iJTuvgPANP0ElwEM3LZt0L/3eegePbKsmEBaZnxbHL29ZMa6ojz11Dr7w5CH8IZH7Ly/lvs3zJqG3sxdvIMymH72FzeXn5lU5fO3KsnHt4/6nj7Cz1o6AXGP2mqWZkyqi97M3KtlT56DpJx+krGS+YqAqzEgiBuoJSZIWTXdfFBQmEsWDeo5Rb3fz4uE23qropN7uOeN9tSCQYTWQlWAgI95AikVPSsTosBq1xBs0ivExBGFRoscToNcbxOkL4Q2G8YdEgiE59DWaTasSBLRqFUatGrNeLrGTaNJhMWimTJV4fVEyqRY93/7Pcd6rsRMeZB0qGBZ5+M0q/rm3KeY5z7AaWFOQyPLcBErSLYo3aAYjCAIaQWCsEZOCIKDTyLVlx6q4KkkS7kAYm9NPR5+P1l4fDXY3Fe1Ouj1B9jV0s6+hm0feAqtRy/nFyVy1JJN1RUkjGqueQBg9sDAzfkzGqSRJ1Ns9VLQ7cfqCmPUa8pJMlGYMP37XFCTxnesW8eDWcqo6XXzyr/v43cdWkTlG797awiS+cVUZ//OfEzz8ZhU3rMwm0zq3QuCH42+76rG5/GRZDXzp0pIxb+/2h/jsEwc53NyLTq3iC5fMZ0Ve4iT0dCBXL8lkT50DZQ1fQUFBYepRDNRzgJAo8k5FF//c28SBxp7Y64IA+UkmStItFKWaKUwxk51gPGcM0FAoxO7t2wBYt+liNJrxD2dfMIzN5cfuDtDjCdLjCdDtCdLtDuBwB7C7A3R7Amc1WdFrVJFasAZyk0wUJJspTjWTYJoc0Z3i1Dju3FDAH7bXIZ4W0ukJhPjq00fZWWsHYEVeAtctz6I03TLtpX1mIhM51mYzgiAQFymdVNCvjJYkSbT1+jja0suR5l5OtPbR6w3y8rF2Xj7WTmGKmU+cX8CVizOGHF+BkIgexqSKbXf5+e07NRxr7TvjPYNWxUWlaXxgSSbJcYN7RguSzXz72kV8/+WTtPR4+a+/7+fR21cP6kkNhUJse+N1AC6+5NIBY+DqJZk8e6CFw829PLG7kS9dVjrq73AuEwyL/HFHHQB3bSocc/6pPxTmy08d5nBzLyadmgeuKKMkffjxYXf5eauii4r2Plp6vGhUKtLi9WwuTWNdYdKo739FqWbUgjDrxawUzp5QKMSrr74KwOWXXz5nr/8KClOJ8iubxYREkZePtPPojjpaeryArKq4PDeBjfNTWJaTcE4Vvj+dYMDPV+76KADbjjaMeNPwBcPY3QE6+3y09cqPlm4vbb1euj3BUX2mSgCzToNJr8agUaPVyCUhogIzQKw0QyAk4g2GcfnlkEl/SKTR4aHR4WFXrSO2z1SLnpL0OErSLZSmW8hLMk1YePTFZWkIgsC3f3Zqf6Ik8ZWnjrC7zoFOreJzW+axuiBpQj7vXGWsY22uIQgCWQlGshKMXL4og7AoUdnhZGeNnXeruqizufnvfx/nncouvnvdIvSaM3NVxcjqz2i9uj2eAF95+jC+oIhaJVCUYibRpMUdCNNg9+Dyh3jlWDuvH2/n+hXZXLsse1ADKT3ewP/7wEK+++IJmru9fPrxAzx6x+ozRHj8fj8fvfmDADS02weMAUEQ+NDqXA439/LswRa+eGmJstADbD3WTkefn+Q4HVcuzhzTtmFR4lvPH2NvfTd6jYpvXLWA4mHK2HQ5/Tyxt5FdNfYzjMoul5/jrX28WW7hW1ctHNX1VaNSYdTNvjq1ChOP3+/nAx/4AAAul0u5/isoTAHKr2wWIkkSrxzv4Lfv1NDcLRumFoOGSxakc+nCdJLMc68MhihJcshhj5eOPj9dLj92l59ebzDiEQ3iDYaH3YdBoyLeqI3k0mqw6OXn8UY5r9Zq1GDWa8ZVPzQUFun1BrG7A3Q5/bT1yuGRXU5/7PFetezNNOnUlGVYWJxtZWVe4rgERaIIgsDFZWl8u99r/9zTxO46B3qNim9dvYD5I3gkzhZRknD6QvR4Ajh9cp6jLxjGFwrLRnwgHMt9dPvCuAIhvIEw/lCYUFiKGS5qlYBGfSofWh/Jje6fcylJkbqNokQwfKqmY0yBuv+xiRwfjVrAoDmVR51g0pFg0pJk1pEYea4RB8+7VBgctUpgQWY8CzLj+cjaXF451s4zB1p442QnIVHixzctHdKAG62A02snOvAFRZLNOm5dlzfA6ylJEjVdbt6p7KLe7uGZAy3srLXzhS0lgwrrJMfp+eZVC/jOiyeotbn54pOH+NWtK8ekJnxhaSpatUBzt5cGu2eAh3mu8q+9snbLDSsGXxwYCkmS+NGrFWwr70KjErj/8tIhjVNRknj5aBv/3NtEODJ2ClNMLMm2kmk1IEpQ3eni3SobJ9ucvHS0jWuWZY2qH+FxiokpKCgoKJwdioE6y2jr9fG9F0+wu072wFkMGq5dlsWlC9PHraA525AkieZuL8cbu2Kv3fvYAULqkQ1znVpFolk2PlLi9KTG6Um16Eg26yd1tVyjVpEcpyc5Tj8gRM0XDNPS45U9q3YPTd1ePIEwBxp7ONDYw2M7G8hJNHJeUTLnz0s5K2MVoKPPx8Pb5HIpH1ufP6HGqSRJdDr91HbJKtHN3V7aerx0ufwEB0uCnUWIAV/s+Xf+c5z4eAsmnZo4vbyAkWjSkWrRk2E1kBanVwTC+mHSabhhZQ4l6RZ+uLWctyu6eONkJ5cuTB/QTh05Zt2ewKj2u7NGXtDZsiDtjJBcQRCYlxZHcaqZ4219vHykndYeH19/9gh3bSriotK0M/aXFm/ga1eU8e0XjnO4uZf/+c9xfnjDklEvSBm1ahZlWTnU1MOeOsecN1Dbe328V20D4JqlozMIozy2s4Gn9zcjAJ/ZPI9FWdZB2/V4AvxyWzUn2uQQ74JkE1cuzjgjhzkvyYTVqOX5Q608e7CZq5dkjvgb9QRCIy5qKigoKChMDoqBOos40NDNF548hDsQRqsW+OCKbK5akjknDFOXL8Sh5h4ONnZzrEXOb+tvNATCIjqtQJJZR3Kc7PmyGmVV4WjOnMWgQa9RzajQO4NWTXFqXMw7EBYl2vt81NncVHW4qIsYek/tb+ap/c0syLRw9ZJMVuUnjut7/Pm9eoJhidJ0C1sWnDlJHys2l59DTT0RpWgnvd7BQ6UFwKRXY9JqMGhl76dWo0KrVmHQqNBr1Bh0srCUUSeHT+s0KtSRGp1wqkZvMCx7R4NhSfaWhiOeUUlCEORanf3VbNWRep5Rj2l/REkiJEoEQiK+YBh3IIzLF6LPJwthOX0h3KcpX9faPKj6hvao6tQqcpKMFCSbKUgxkZ9kJi/JNOfDBRdnW7lueRbPHGjhd+/WsmVB2gDjL+phq7O5R7U/d0A+L2nDKO8KgsDiLCsFyWaePdBCVaeL371bS3O3l4+uzTvDSMlNMvGVy0r5v5dP8ubJTn77dg2fHoMq77Jc2UDdW+/gQ2tyR73duciLR1qRgGU5VrITRy8a9fqJDh7eVg3AbevzWVeUPGi72i4XP329Ers7gEYlcNWSDFYPc11ckZfAC0fa8AVF7G4/qZbhF/tqu+RxOJV3C1GUsLn9pJiVRS4FBYW5jWKgzhL21Dn43D8PEgxLFKWY+eyWeee8UmSn08e++m721Xdzsq1vQHimVi2QmWIkWvzr0xcVkZmSMK7w25mEWiWQnWAkO8HIxnkpeINhytucHGnuoabLzck2JyfbnBQkm7h1fT5Lsgf3LAyGKEn853ArADevzhm3od7e5+P9ahu7ah00OgYqRasEyLQayUowkG7Rk2LRk2TSEW/Uxjxksw1RkujpdfKFn8n/f3hNDqJaL4cmB+VyLH2+UExQKxAWqe1yxya4UVLidOQmmshJNJKdKJ/jDKuBOP3UqTtPN1cvzeSlo23U2dwcae5leW5C7D2DVo0IVHY48YfCg+ap9ic6noYqe9OfOL2G29bn8VZFF29XdPHS0Ta6XH7uu2jeGaGnCzLjuWdTEb95p4Y/vldPWWY8F5eNbjFnTX4Sf32/gbcqugiL0qwd8xPBMwdaALhyyehzT0+29fHf/z4GwOWLMrhqiG0PNHTz0zcqCYsSKXFyiHfKEEJYUVSCgEGrwu0P4/KHSR0heORwcw8AU/HTDIVFvv7sUV4+2oY7EOaGldn85OZlc+a6oKCgoHA6ioE6CzjW0hszTlfkJfDFS0rGrIY4W3D5Q7xfY2N7pY2qTteA99IsekozLJSkxZGTaCQc8LE98l5KnH7WG6eDYdSqWZGXwIq8BHq9QXbXOdhZY6fe7uH/XjrJZQvTuWNDwagmwm5/GG1IJCPewKKs+DH3pc7m5ul9zexv7I69JgC5SUbmpcVRlGImK8F4zpWmUQnCALGx0nQLeuOZeYwgG7Pd7kBMhKut10d7nw+nL4TNFcDmCnCwqWfANgatipQ4fSzfNcGkJdmsJ9WiJ9Mql4M6V7wpJp2GFbmJ7Ky1s7feMcBA1alVWOP1dPTJgjYrRyglUpRi5kBjD40OD3mD5JWejkoQ2FKWRppFz9P7m9lT56DPe5L7Ly/FpBt4K7ygJJUGu5uXj7XzreeP8Y+715E6iuj61QWJxBs02Fx+9tY7WD+E9+9cp7rTxcm2PjQqgUtHGanR7Q7wpX8dJhiWWJZj5fb1+YO221beyaPba5GA+Wlx3Lw6Z1S5wv5gGLdfDtkdqd5tSBRj4clTcV/57Ts1PLW/Ofb/swdaWJ2fxEfX5U36ZysoKCjMRBQDdYbTYHfzmX8cjN20v3RpyTlnAID8Pbcea2d7lS0mTCEA+ckmFmbGU5ZhIfE08ae5lh1kNWq5bGE6G+cls628i911Dl470UG3J8Dnt8wfsXyCJxDCCpw/L3lMK/MuX4jHdtbzbpUt9tq8VDNLsq2UZVrOmNzPZVSCEMs1XtzPu+0JhOjs89PplB9dTj82l58+XwhfUKS52xsTPDsdvUZFUaqZhZnxLMmxMj/NMqs9cwUpJnbW2mkcpE7zRSWpPLmvmXcru0Y0UJfmJHCgsYdDTT1snJcy6s9fkm0lTq/hb7saKG938v2XT/K1KxYQZxg4jj+6Lp96u4cTbX1849mjPHLzwhH3rVWruLAklReOtPHa8Y45a6C+UynrA6zKTxxVGa2QKPKN547R6ZTrpX5uy/xBF2VePNLK47sbAViZl8C1y7JG/Vuo6pIXPNMseuJGULffUWWj2xMk2ayjbZJ/aifb+vjFm7IuwPc/uIQeb4AfvVLBt184ztrCJOalDa1crDCzcbgDONx+5qVNrhChgsK5iDKznME43AE++8QhnP4QBckmvnDJuWWchkWJ/Q3dvHq8neP96himWfSsyk9gSbYVyzAlJ9RaLbd/+Tux53MFk07DB5ZmUpxq5sm9Teyt7+bvuxq58/yCYbfzBsNYgWX9vFYjUW9z85PXK+ly+gFYmmPlopLUET0Q5xpnO9ZMOg0FKZozhHOCYZEeT5A+X5A+bwinX8597fMGcXiC2F1+/CExFtr9zIEWzDo1i7OtLMm2sjArnkyrYVaFAqZGQjE7+nxnvHf9imye3NfM3noH7b2+YUXBzp+XwmM76+no84/aixqlMMXMJzcW8uf36qnpcvN/L5/gm1cvHGC4qFUC922ex9eeOUJFh4vfv9fIgz/5OQA63dBG10WlsoH6xskO/t81Ixu15yK7I/WV1xaOrnzVn3bUs6deVhb/wiUlgy56PXugOeZl3DQvhUsXpo1p3B+M1AgfqU8hUeTfh+RUiFvX5fH1UX/C+PjeiycIhiUuXZjOLWtzkSR4r9rGe9V2ntrfxNevXDDJPVAYCZ1OxyOPPBJ7PhIuf4gfbj3JU/ua8YdEHriijE9dVDzZ3VRQOKdQDNQZissf4jNPHKSlx0uaRc/Xr1pwzois2Fx+3irv5O2KLuxuWbFTABZlxbO+KJm8JOOoJh4ajZZLbrx9kns7c1mQGc8ta/P4++5GXjnezoZ5ycMWsVcJAlq1XC9yNJS39/G/L54kJEokmrTcvCpn0BIdc4HJGmtatYpUi35Ig1+UJGxO2QCrsbmp6XTjDoTZXeeIKXnHGzSUZcSzNMfK8ryEEXPxppvodcwdODMGoiTdwobiZN6vsfPkvkY+v6VkyP3E6TVcMD+Vtyu7eKuiizvOGzwkdCiyE4zcvamQR3fUUW/38P2XT/KtqxcMMI6SzDo+vXkeD75SzlMH2/nNrR8a0cBZXZCEWhBodHho6fGSnXBuawUMxpHmXkAWSBq5bQ9/2F4LwN2biga9xjy9vymW07qlLI0LS1LGZJy29Xqp7HAhwIj5xNtOdtLe5yPRpOWmVTmTaqA22N28X2NHEOB/rlmIEBGF++jafN6rtrP1aDtfu6JsVi1AnYtotVruu+++Ubf/v5dO8MSeptj/D75SjjcQ4kuXlU5G9xQUzknOHXfcOURYlPjmc8eoaHdiMWj42pVlZxSNn22ERYm99Q5+sPUkn/nHQZ450ILdHcCkU7NpfgpfvqyED6/JJT/ZpNyMx0BphoUVEY9odNV/KDKsBv54x5oRQ4EBWnu8fP/lckKiRGGKmU9dWDxnjdPpRCUIpMUbWF2QxIdX5/K1K0u5e1MhF5elUpBsQqMS6POF2FPv4NEddXzmHwf55nNHeelIGz2jLNcy1UTHXzA8uLjRZy+ehwDsqnVwrKV32H1dvyIbQZBzHsvbnWPuS3q8gbs2FqLXqKizuXno1Qr8oYGG8/LcBLZEjJr/95/jI5bBidNrKM2QF4r21NnH3KfZTkefnHctQOw4DIXTF+Qbzx1DlGSP+PmDhGo/e6A5ZpxevjCdi0pTx3yPePNkJwDri5OHFRd0uAM8sVcOIb7ngqIBueeTwVP7Ih7h+ankJJ66vl5UmopBq6LR4YmV0FGYHTQ5PLHz+ptbV/LNq2QP+C/fqqa2yzXcpgoKCv1QDNQZyF/er2dHtQ2tWuBrV5SdUdNtNuH2h3jhcCuf/+dBfvJaJYeb5AlnYYqZm1Zl85XLSrhsYfq4DHAxHObkgV2cPLALMTzXMlJPsWm+PKk70NCNwz385Hk04lphUeIXb1YRCInkJhr52Pq8c8Z7P15mylhTCQJ5SSY2l6bxyY2FfPOqMu7aWMiWsjTykkwIQE2Xm7/tauBTjx/gkW3VNNhHV7ZlqojmmGuGyB0sSbdw06ocAP64ow7fMLUo0+MNfCCi9Lr1WDuBUSj6DraPT24sQKcWKG938vM3qgiJA/dz2/p8Mi1amo7v5XM/fZzwCGNgTYGcP7ujau4ZqFFxodHkpz/0agVtvT7SLHo+MUiKwktH2mJhvZcvSmfj/NHnGkep6XRREfGe3rQyZ8h2kiRFxpvI4ux4bhym7UQQFiWejny3D60e+FlmvYaLSuRFka1H2ye1HwojEw6Hefvtt3n77bdH/O3/+u0aQqLE+fOSuXJJJndfUMSWsjQkCX7zds0U9VhBYfajGKgzjJZubyzc6a5NRRTPUoEEhzvAYzvrufdv+3l8dyM2l+wt3TgvmS9smccnzi9gWU7CWeXUBgN+fvCZW/jBZ24hGPBPYO9nF6kWPTkJRiQY0eM0Gt6p7KLB7kGnUXHL2txzKu95vMzUsaZRq8hPNnFRaSp3byrkq5eX8oGlmeQkGpEk2FFt44FnjvLQKxUzxlD1ROqXDuedum/zPNItetr7fPzl/fph93f9imwSTVoc7gBvnOwYV58yrUZuP09Wwz7U1MOj2+uQpFOFrQxaNXefn0fHE99g64Of4vWjTcPsDVbmywZqtFTJXGJnTST/tGD4UOjtVTZeOtqOgHy+Tzdm36ns5O+7GwC4uCx1TEJYUYJhkX9HSmtdujB92MXeV4+3c6CxG41K4FtXLZh0IbLtVV2xUOJLF6af8f6VSzIAePlY26T2Q2FkfD4fmzdvZvPmzfh8Z+bOR+l0+nh6v3xt6J+ecN/Fci3l5w620NIzuBiegoLCQJSZ5wzj0R21BMMSi7LiuWAcq8XTjcsf4m+7GvjsEwd5+Wg7IVEizaLn+uVZfOWyEi5flEHyDM+Rm43kp8jhYaeX5hkrkiTx/MForlfqsCJVCjOPOIOGdYVJ3HtBEf91QRGLs+MRgP2N3XztmaM8ta/pDO/gVNPrDQKQOIy6q8Wg4XvXL0ZAXjB5q7xzyLYmnYZ7LigCYGetg5pxhtHlJ5v4yJrc2GdGw0qjFCSfCsH8yeuVMUN7MEojueA1na5hPcDnInvq5dzoVflDqzD7Q2F+uLUckOuknp47f7Cxm9+9Iy/Unj8vmYtKUsfVl7cruuj2BEky6/jImqFLttTZ3DF14C9dWsL8YXL5J4rXT8iLKVcvzRy05u/FZWmoVQK1XW7aehWjZjbwTkUXwbDE4uz4AbnqK/MSOa8omZAo8ecdddPYQwWF2YNioM4gnL4gW4/J4TwfWp0763Ixd9bY+eKTh3jpSBthUSIvycTt6/P4zOZiVuUnKp64SSQqjGNznp13r87mptPpR6MSWJ0/OgVOhZlJdqKRD6/O5XNb5rEw04IEPHOghf/593Fc/qGNq8mmvVf2QOQkDp+6sCo/kXsvlA3PP71XR1XH0Dmmy3MTuSRSb/PZAy3DGo/DUZZh4ZplcsjwMwea2VFtG7SdzRngjzvqh9xPSpwOi0GDBNTPEM/1VGBz+WmwexCQywANxZN7m2nv85Fk1p0R3lpvd/PT1yuRgOW5Vi5fmD6ue2GTw8P2SGmsO84rGDJNwRMI8cttVYREiQtLUs7oz2QgSVKsFM9Qok0Wg5b5kQiqo81nHxmjMPlEx1s0PLs/H4+EsL90tA1RlM54X0FBYSCKxTCD2F5lIxiWyE4wUpI+e0J7w6LE33Y18Is3q3D6QqRa9Ny+Po+7NhYwP90y6wzt2Uh8pIZjT8Q7NV4qO2TvU3GqeVT5qgozn5Q4PbeszeNDq3PQaVTUdLl5ZFv1tE2Sarpkg60odWQ16U9ulAWhQqLEQ69V0OUcOrzu1nX5ZMQb6POFeHp/C6I0vu+3piCJjfPk+qW/fbua6s7BDeO/7WqgeoiIBSGSKwxQ1zV3DNQjkZDm/GQTFsPgIdztvT5++46ci3fzqpwB3sMeT4Afv1pBSJQoSjFz3fKscd0/AiGRZw60IAHnFycPqbwsSRK/e7eWtl4f6fF6/ueaRVNyv6q1uWnu9qJTq4atlbs0ooJ8dAJSNxQmF1GUYgtaFwzi8b+gJBWzTk1br49DczD0X0FhrCgz0BlENHdndUHirDHqRFHi4TereOmInCdzwfwU7ruoWDFMp5iod3o8IjH9aY/UppxrdU7nAkuyrXzy/FN5lq+dGF++5tng9AVjIbhrRshRBFkU6jvXLqI0PQ6nL8SDr1TgHsL7a9Cq+cIl81GrBKo6XbxXPX6BoksXplOWYSEsyeG8pysir8hLICxK/O9LJwfkqvYnZqDOIQ/qsRZZcXZhZvyQbX76eiX+kEhJetyAiXxIFPn5G1XY3QFS4nR8ZG0uGtX4piivHm/H7g6QZNbx8fMLh2z34pE29tQ5UKsEHrxx6ZSp5b9dIXtP1xYmDSsktSTihT6ieFBnPCfa+nC4A5h1albkJZzxvkGrZssCOdd461Elr1hBYSQUA3UGcaw1cnPPGvrmPpOQJIm/7qxnd50DlQAfXp3DpQvTJ11cQuFMot6wsz32oUjpDyUc+9wkK8EYK5myr8Ex5Z+/u86BJEFJehzp8YZRbWPSafjZh5eTatHT0uPlp69Xxsbp6eQnm7lzQwEg5/jVjDMnWyUI3LQym1SLnh5PkIe3DVT2vX19ATq1iqMtvbwdCdU8nbnoQY16+hYMYaCebOvjzfJOBOCTG4tQ9VvEfHx3IxUdTnRqgVvX5WHUjk85/GhLL3vquwG4Z9PQpWIONHbzxB457/Qrl5WwJHvkmq0TRTS898IRcmuXZp/yoA61EKIwM3i3Sj6n5xWnDHn/vCoqfHW0XTmfCgojMGdnoYIg3CMIwu8ij9cFQbhnOvvjDYZpdHgAKEweOfRtJnCkuZdXj8temJtW5bB4Cm/wCgPxRIRYxjupi2KIbO8NzC1hl7lEcSS0djoMp2iO1uWLMsa0XXq8gV98eDl6jYoTbX385p2aIUN4t5SlcVFJKhLwxN6mEeuWDoVeq+aWNblo1QIn25z8++Apr0eiWRubbP7s9apBhZAKUuTjfLbCZbMFfyjMrlrZaz2YsSdKEg+9WgHAhnkpMQMeYG+dg1ci+gs3rcqJ5dSPlc4+H89FRN6uX57NskiN6NOps7l5+M0qJODGldncvGry806j+IJhdkeO00WlwxuoZZkWtGoBhzugqL/OcLZXRsN7hxa3vLAkDaNWTUuPNxZtoKCgMDiTW4V6hiIIwoPAk5Ik/T7yfwJQJwjCKkmS7p2OPtldsriNXqMaMndnpvH0AbmG23lFSVO6+hxFrdHw4fu+Fns+l+mKiCNlWkfnlRqKgsjiSFO356z7dC5xLo01p08OkU00D62iOxm0dHupaHeiEuCqxWMzUAFKMyz85OZlfO6fB3m/xk6cXsOdGwrOSCUQBIGPn19Ig8NDnc3NP3Y3cfemwnHlVKda9NywIpsn9zXz4vEObvrUA6THG9BotFy3PJt3q2y09Hj50446Pr153oBtowI35e19+ILh2OLPucq7lTacvhBpFj2Lss/0oL50pI3Dzb3oNSpuWZMbe93u8vPI29UAbJyXPKT3dSR8wTD/2NNEMCyxINPCjauyB23X5fTxo1fL8YdEVucncv/lpVOajnK4qQd/SCTNomfeCGXk9Bo1pRkWjrX0cbS5l5xE07DtFSYHrVbLj370o9jz0xFFKVZSaricYqNOzab5Kbx2ooN3q7pYkqMs6isoDMVc9aDeA6yO/iNJUg/w+8jr04Lbf8oDNhtyN33BMFURQZ3x1KebCDRaHVffei9X33ovGu3UTrZnGtFzMZzwjNMX4pnIosJQRMPLW3p8dPQNLUgz1ziXxtq+Bjn8sTh1aoXY/n1Y9mxdUJJK2ijDe0/nvOJkvnfdYgBeO9HBE3saBw2V02lUfPnSEgxaFe19Pp492DLukLrF2VZW5ScgqLVUZ1zMNbf9F1qdDoNWzR3nFQDw2K6G2CJRlPxkE+kWPb6gOO76rLOJrZF6nVsWpA0I3QXZu/rbSNmYD67IjpUaC4sSv9xWTSAkkp1gYMuCwRVtRyIsSjy5twm7O0CyWccXtpQMmr/a4wnw/ZfL6fEEKU418+Obl015OkP09zdarYkl2QkAHFGEkqYNnU7H/fffz/33349Od+b1v97uxhMIY9CqRryunh+ZL71fM7hCuIKCgsxcNVAdQMJpr9kBBEEomvLeAHqtfCr8ZylyM1X07+dQOT4KU0N7r4/mHi8CDKlWCdDrCfLUvuZhw3eTzLrYPqJCHgrnDsdb+yhvdyIA1y7PmrLPbXJ42BEJ7/14JEd0vFyxOIOvX1kGwAtH2vjXvqZBjc/kOD0PXFGGSpC/97by8Y/nqxZnkhqnp9sT5Pfba2Oft6YgkZL0OIJhiZ+/UTVgG5Ug8IFl8jGO5jqeq4TCItsitWovLj3TyPzr+w2xsjJXLs6Mvf78oRYqOpxo1QIfWj1+UaStx9qp7nKjUQl8+bJS4gcRO3L5Q/xwazntfT6yrAYeuWXFtEQr7Y8YqKtGWcYrGp10vFUJCZ2pnGiTz01pRvyIOhDnRxTC99V3z7kayQoKY2FOGqiSJBVLkvSj015eE3mvdhq6RLrFgEqQc1E7Z4HnyqxTY47UlauzTY8IiBgOU3viMLUnDiOG5+aFXpIkXjku526tK0oiwTS0d0+tlm+cDY7hz9cNK7IRkEW7ytuHrj05lzgXxlqdzc1T+5oAuHJJBtkJw9chnSjCosRv36lBlGBzaeqE5KrftCqHr1xWAsDzh1r5177mQY3Usox47toorzm+XdnFgcbucX2eTqPiphWZBNsreX/Xbt4plz2igiBw54ZCBOCV4+0cO83LdV3EQH2/2k5b77mbQ3ikpZceTxCLQcPS3IHn1+by85f36wG4bV1eLNS6zuaORXRctzyLpHGGnO+qtbO7Thb8+tzF8ylMOTOKxBsI8+Ar5TQ4PMQbNPzq1pXj9uKfDaIoxQzU1fmJo9omGgZcZ5sbucwzkXA4zN69e9m7dy/hQa7/0cWD4dSroxSnxpFm0eMPiRxoGN/1SEFhLjAnDdTTieSg3gQ8MMr2xwd7AMXj7YNRp46tlL41CzxXGrUqFqry+omOIVU1J5NgwM+377qeb991PcGAf+QNzkF21tqp6XKjEuCWtXnDttVHJoaV7cNPdApSzHxgqezleGZ/87hFZs4lZvNYkySJnTV2/vJ+PWFJ9vrdui5/yj77L+/XU9PlxqhV89XLSyds37eszePLl0aN1Bb+uXdwT+rmsjSuj3iLnz/Yysm28Xmiko0CrX/9Eu2PfYk/vlNJb6TmcGGKmY3z5WvhI29VD+hDdqKRFbkJSBAT7zkXeT7y3dYWJp3hBf3Tjjr8IZHiVHMsPy8sSvzunRokCRZmWmJqtWPleGsfLx+VF+huWZvHmkEiSHxB2Tit7nRh1qn5w+2rBwg0TSU1XS56vUGMWvWo1fqjBndztxd/aHYujs12fD4fa9euZe3atfh8ZzoQTkQM1EWjOKeCIMTmTu8pYb4KCkOiGKgyTwFPD+JVnVI+uk42MP5zuHXcK/1TybXLs9BpVLT2+njhSNuQqpoKk8Oxll62HpM9Obeuyx+xbEdU4fdg08hj6+bVuRSlmPGFRB7f3aio+s5S7C4/f9/dyMvH2hElWFuQxGcvnj9lpaCeP9TK6yc6EIDvXrdowr1WH12Xx5cjntT/HG7lb7saBjVSb16dy6b5KUjAk3ubqD1LBeNAWOSf/cJ2b16Vi1olsLe++4wFxmuWyYs9j26vixm15xJNDg//2C0fi5tWDlTDrep08dR+2Uv64TV5sZzLN0520ODwoNOouHZZ1rh0F2q75IgACVm5+ZqlmWe08QXDPPRqBRUdToxaNb+9bdWIwkSTSTT/dFmuddS5rylxOix6DZIEjXZFvG4mEg3xHe2iw4ZieaHmbGo1Kyic68x5AzWi6NsjSdLNo91GkqRFgz2AmrPpy5ayNLYsSCMsSvzolQp+905NTN13JpISp+fzW+YDcKCxh8d2NuAJhKa5V+c+kiSxvcrGk/vkid8lC9JiJS+GI5orXN7mHFEASadR8eXLSrAatXT0ySF6ipE6e/AGwmw91s7D26qp7HChEuCODfl88dL541KzHQ/PHWzhyb1ySPGXLi3h4rLxCeCMxEfX5vHAFbJnduuxdn73bi1hcaCRqhIE7r2gmNX5iYQlWdTobFMT3q7sorJDDoFPtehjBtKv3x5YAueqJZkUpphxuAP8+b26s/rMmcij22sJiRJrC5LOyIH/zdvVsYWRaIRQjyfAP3Y3AHD5wvRxaRg02D38bVcDYUkOlf3E+YVnGLneQJgfbi3nRFsfBq2K39y2ctprjO+rj4b3ji7/FGSPW2FE/K52mtJpFIam0+mjy+lHEKAswzKqbTZEPKhHW3qVOZOCwhDMaQNVEISbgKKocRoJ9Z3O/vC96xbx4YgE/1sVXXz2iYP85LUK9jd0nzHpmgmsyk/k81vmo1EJ1HS5+eW2GnbV2qcl5Hcu4AmEeHJfM6+dkD2nlyxI4+ODTM4GQ6MSOK8oGQnYGgmLG47kOD3fvHoBhoiX/NEddTjcSrjvTMbpC/LaiQ5+/FoF79fYESXZW/PgjUu5cnHmlCiEi5LE47sbYsbppy4sikWHTBYfWp3Lt69ZiEqAdyq7+MlrFWcIkKhVAp+9eD7LcqyERYnHdjaM25O6LFIe4i/v18c8ttcsy8KkU1Nnc/NWRDAIQKtWce8Fch7so9vr6POdO17Ujj4f/4oslN2xYWDYeEW7k3cqbQgCsXsawL/2NREIS2RZDawuGF0eZn8aHR7+urOekCixNNvKZy+ej+q0iACnL8j3t5485Tm9ddW0lEI7nUNNUYGksX3vaPmv6dJ7UBiaaHhvUYoZk250iy3ZCUYyrQbCosThJkWdWUFhMOasgSoIwkrg0tM8p/dMt5Gq18h5Wn+8YzWr8hIQJdhb381Dr1bw2ScO8vT+ZmwzzKt6XnEy379hCZlWAy5/iJeOtvPTN6rYUWXDeQ5Nxqab8nYnv9xWw/HWPgQB7txQwCc3Fo4pXPNj62VD4bUT7bSOovB7XpKJ712/GKtRS6fTz6/eqondkBVmBqIkUW938/T+Zn78WiXbq2wEwhI5iUa+flUZX79yAblTlHPnCYT4+etVvHBYLjny2Yvncdem0Qmj9/mC/Csi4jQerlmWFSkbInCwqYfvvHD8jAUVnUbFly4tZWm2lZAo8diuBqo6xi4EtmVBGhqVQJ3NzeFmeYJp0mm4fJEcyfC7d2sJieKA9kUpZlz+ED94uXzc33EmIYoSX3zyEN5gmIWZ8azr5z2VJImfvVEJyHUhsyKCXF1OX0wd/OqlmWeUoxmJOpubP79XTzAssTAzni9dVnJGRIDd5ec7L5zol3O6atz1JsdbmmgwXP5QzAM61v5E81DrFQN1xnEqvHds53RlnrxIMRvSuRQUpoM5aaBGSsk8BewXBOGeyOOrwIcjNVGnneW5Cfz+9tU8ec96bl2Xh9WoxeEO8PT+Zj77j4N8/+WT7KiyzZiwy7wkEw/dtJRPbCwgyazD6Qvx6okOfvRqJX/cUcf7NXbF+zZOonmEj+9uxOUPkZVg4P+uX8wVizPG7BFbV5TM+fOSESX4/SChkIORm2TiBzcsYX5aHIGwyBN7m/j77kY6nTNroWQuIUoSDXY3Lx1t48evVfLHHfUcbu5FlKA03cKXLyvhRzctZVlOwpT0R5Ik9tY7+MpTR9hT70CjkqNB7hxDSRmbM8DP36gat4gRwIUlqfzhY6ux6DXU2z186/mj1HYNFAWTw9dLWZmXSFiU+PvuRo40j82LEafXxMJZXzjcGnv9qsWZmHVqarrcvHb8VO1TlSBw/+WlCMglZ7ZXzXwhvJF4fE8j79fYMWhVfO/6RQOuRTtrHeyt70arFvjI6lPe0/8cbkUCilPNYxYqqmh38tedDYREicXZVr56RSl6jXpAm9ouF9/69zFaerykW/T89RNrWTAKZdXBqO1yccsfdjNRNuqJ1j4kCTKtBlIidWBHS5ES4jtjqemUz0nJGHObV+QlAHBQMVAVFAZlrhaw3I9cB/V3p71+YOq7Mjzz0uL40qUlfGbzPLaVd/LsgWb2N/ZwpLmXI829aNUCy3ISWJ6bwNIc67RI50fRqFVctjCDzaVp7Kiysa28k6pOF/V2D/V2D1uPtZMap6c41UxhipmCFNOoQ2KiSJJEwCd7/vzeU4IR/Z/rDMYpCWWcbHq9QXZU2dhT70CUQBDgA0syuXl17lnlEd5/WSn7G3ZR3u7k0e213H1B0YiejCSzjv93zUKe3t/Mfw63UtHupLLdyeJsK2sLE8lPMp0Tx7w/M22s+UNh6mweKjuclLc5cfpP5S4ZtWrWFCZy2cKMKRWBEUWJfQ3dvHC4lapO2RDMSTTyvesWsXSMxrFZr8YfEvnyvw7z+9tXkZM4Pq/vkhwrf79rLV948jB1NjfffuE4d28qYtP81FgbnUbFFy+dz6/frmFnjZ2n9jfT5wtyfnHygPM53BhYlWXkvZM+jrdKNDo85CWZiDNouHppFv/a18QTe5q4askp4Z61hUl8aE0uT+5t4pvPHeM/nzl/2LJQM5ljLb3874snANlLHg1BjRKt+7plQXrsntTnC8YEpC4sSWUsHGzs4bmDLUjAyrwEPr/lTM/pzhobv3mnhmBYojjVzC8+soJM6/juh73eIF95+ggNdg/hCbJQj0ZKEI2nzFLUg6qE+M48ouV/onnCoyUa5n2gsQdJks65+6eCwtkyJw1USZLGnvgyzeg0Kq5YnMEVizNo7vbw0pE2XjneQaPDw76G7pg6YHq8nkVZVhZmxVOWYRnzSu1EoFWr2FyWxuayNLqcfvbWO9jf0M2Jtj66XH66XH52RerWpcfrKUiWV9PzkoxYjdphL9QBn5e7tyw64/XPfGBN7Pkf3jyO3jg9ZQTOFkmSaO72sqvOwbEW2SMGch7h7esLyE48+9qVuUkm/u/6xXzlqSO8VdFFWJK4Z1MRmhFUJbVqFbeszWPT/BSe3NvE3vpujrb0crSll0STlkWRMZeTaJoyldjJZLrHmjcYpqXbS4PdQ53dTZPDQ3+Ht1GrZnVBIusKk1iWmzBqVdCJoMnhYUe1jR1VNuyRyAitWuBj6/P5xPmFGHXqEfZwJhlWA1mpZmq63Nz12H4euWXFuI3tnEQTf75zDd98/ijvVdv59ds1VHe6uG19fuw4aVQqPrN5HglGLVuPtfPq8Q5sTj8fWJYZK5UymjGQ+8Wn2V1rj3kEtyxI49kDzZxo66Oyw0lJ+inhlE9dWMw7FV00Ojzc89h+HvvkWgzasR+r6aTXG+RTj+/HHxLZUJzMzatyB7xfb3ezs0ZWJ71i0Snxtt21DsKiRKbVQEHy6H4zkiTxVkVXzLDdND+Fey4oGlDKJhQW+ceeRrYek/PqzytK5gc3LMFiGN/0psnh4fNPHqLB7iEj3kDbBF3Ljjb3AIwrF7YgYqB2Of04fUEsBu2E9ElhdGi1Wv7nf/4n9rw/9RFl5dMXaUZiUZYVnUaFwx2g3u4ZtH6vgsJcZk4aqLOdnEQT915YzD0XFFHZ4WJ7VRfv19g52tJLR5+fjr5OtkVEOlLidJRlxFOSEUdZRjw5icYx5/2cDakWPVctyeSqJZm4/SGOtvRyorWPE219NHd7I/31xwqtG7VqMqx60iwG0ix60uL1pFn0Y/a0zibCokRLj5eKdifHW/tiE36ABZkWbliRM+4cquj+T+ei0jS+e90i/t9/jvNupY22Hh+fv2T+qBY0chJNfPmyUupsbl4/0cG7lV10e4LsqLazo9qOTq0iN8lITqKRrAQj6RY9iWbdlI672YQkSfR6g7T3+Wnv9dHW66Ot10u358z87TSLnuW5CazIS2Bx9uhLVZwtIVGkutPFwcYe9tV309Ivf9lq1HLDimw+vCaXVMv4F8RUgsATd6/ntj/uprLDxe1/2sP9l5dy/fLxlSGxGDT87EPL+f27tTy6o47XTnRQ2eHksxfPj+VEqgTZqE6J0/P3XQ3sb+yhyxXgI2tyxmQEHGnp5eZIKGu8Qcuq/ER21zn4+64Gvnvd4gF9+sVHlvOJv+5lT72DT/19P498dOW4lGynA6cvyCf+spcmh5csq5xqcPpi1B+310U8nYkDSl9Fc+0WZ8WP6nwGwyLPH2qNhV9fszSTj6zNG3Ad6ejz8cttVdRExK7uOC+f+zbPG/cC2WsnOvjh1nJ6vUGyrAb+8om1LP3uBBmoEQ/qeAzUeIOWlDgdNleAepvnrO4HCmNHp9Px7W9/+4zXez3BWOrSWA1MnUbFkmwr+xu6OdDQrRioCgqnMTvuirMIURRxuwcPw1Gr1RgMp27YQ7UDUKlUGI3GEdvmWFTcujqTuzYV4fKHONDYzc6KVg419lDR4aTT4aPT0ce7cjQWJr2a0uwU5qdbKEmPI9eixqAdfJIrCAKGft4hn8+LJA6tzms0mYdtqwKWZRhYlmHAaCqkxxOgvN3JsQYbVR291Ns9uANQ43YPqNej0hkw69SkWvRYGFnYJ0ow4EcMD52j2z88c6S2Wr0BVWTVPhQMEA4NLQ0/UltfMExrr5fmbh+tzhBNPX78IREpHEQKh1GrBNYXJXHJwnSKIjctr8eNTm9ArVZH9hskGBw6p1er06PRaGjv9fHdfx9BFKUzxuaFRfE8eG0J//38cSpbHXzlqcPcti6fixekDQhnPB1BpcJgMFKYYuaeC4q4eVkKh5t6OdjUzbHmPpzeEFUtHqpaAEFApdWjFgQSTFri1GHi9GriDBrMOvlh1Kkw6dSYdBoS4i3otSpUgoDf52XIBDBBQG849fsI+H3Djs3+Xs6xtB0LAb8fSRx8DEmSREilo9cXotsTwNbjpqvPg93tp7MvgD80sD+CVo8gCKRZ9BQn6SlJM7Igy0panC42ZkN+LyFAbzDGxlswECAUGlqYbLRtAyGRxt4g5R1uKjtcVLQ68PlPtdWoBNYVJXHZogw2FidjtZhjYzMYDBIIDD029Xp5bPZvK0ny+DSrw/zp1qXc//Rh3qu2893nDvLC/jq+cGkpS/NPhYWO9tqpVgncviaD+clavvOfE9S2OfjqP/fwodW5XLIgDbVajd5g5KolmWQlGPjJy0eob/fxyGt93LAyi0zTyMaJGPTR0tWN13OqT5eVygbqayc6uP/yUjRSCDEy5jLNAv971Xy++swR3jzaxI2/7OFPd22KGc1erzfWdjDM5v7XWR/hYa5bY2lrMp0K0/f7/YROu27ZXH4+/fgBjjb3Em8x85MPLSPeqB3Q1uUL8sqhBkRR4qoFiXg97tiYa7C7kcJBsuOEIa8v0WtnjyfAP3bW0eJwISArBF9UmjJguz2NTv6yqxFfUMSoFvnvq0rZOC8F3yD7NhgMw47P9l4vv3yrmncqbAgaLcvzkvjD7atJNKonRCipv0DSeEJ8QTaAbK4AtTaXYqDOEOrs8jlNs+jHtci0Mi+B/Q3d7G/s5sZVOSNvoKAwl5AkSXlM0AM4DkhDPS657ArJ5vTFHiaTaci2GzZuGtA2OTllyLbLV64a0DY3L2/IttrkPCn/gRdjD23K0G0zsnOlnTW22GPBkuVDtk1ISh7QdsW6DUO2NRhNA9puuOiSIdsCA/prnL9+2LaA9MGfvyF94s97pAUXXDNsu0de2ic99n6d9Nj7ddKWG24btu1Pntkea3vlR+8etu33//6q9Nj7ddKfttdIl91237BtM27/qZT/wIvSwv+3VVp2w/Btf/X487Fj9uVvPzhs2x8/+g9p28kO6YIfbZOSr/rCiMcsbeH62DG+9KdvS3qDcci2K9ZtGHD+EpKSh2xrySmV5n3jpdi+1fFpI47Nwq+9KC38762SIS1/yLbW1CzpBy+dkH72Wrn067eqpIKyJUP3ISEpdu4ee79OKluxbsi2OoMx1u4Pbx4f8bh977l90rf/fUx64OnD0ry1W4Ztm/vFp2PHwbx4+LY/+c8e6bXjbdLOGpt0w22fGLbts+8ciJ2Lj941/Bh6fOuOWNtPfu7+UY3N/AdelBIu+viwbZ9/+dXY9efBn/x82Lb/eOq5WNtf/ub3Ix5jQDIWrZa+8M+DUkVb74ReO0sWL5Per7bFHqmZOaPqz0iPjOxcaeOD26T8B16U/ryjVlq+ctWQbVXGeGnpt1+VXjnWJkmSJF144YVDtjWZTFJ/rrrqqmH70Z+bbrpp2LYulyvW9o477hi27Qu7TsSO7yfuvnfYts+8fUB6p6JTyn/gRSl+7Q3Dtv3+31+VvvHsEankmy9L1vNvGdX4vP6RHdKXvvndCRufn/ze7yR/MCxJkiT9+c9/lgBp4cKF0tmwu9Yu5T/worTu/94Y9z6++ORBKf+BF6VfvVV1Vn1RGDvhcFg6duyYdOzYMSkcDsdef/ZAk5T/wIvSh377/rj2++LhVin/gRela365fdx9W7hwoQQcl2bAHFh5KI+JfCge1DlGdqKRr15RyuGmXg4399AqDd02EBLxBELTHl77l4+vobXHS0uPl9+9aRzgXR2MfQ09qHQ+bI6hvYAAf36vnriEPgxa9Yj1EGu7XDgEJ6IkjVjm56l9zYSqJJy+EN2R0OWhuHppJls2LSE/2cQ//rCLw8O2Hj193iDfe+kEDXYPcXoN9hHaL81J4NpLS3jkrWoqO1wEJqiObU6ikUc/vhaHJ0BHn4/7/6yhewiR1mjkniiBOxAmHB56cLr8IX77bm3s/7Ye35BtPYEQ//fySQQEBEGuozgUwbDID18pBwnCgaH3GeX379aj0slREV29I7dPNGlJjtOjsuipG6bdgoz4Scsz8wRC1NncVLQPX14l0aTjgkUZLM9L4Bh5/OrtSenOqHnuYAtbj7XxsfX5DHPZGhPN3V6qO53MS5PzRCcyd3plXgJNDs+IZSTUKoFeb5B7/7afj6zJJTQD612fzvw0y8iN+qFRCehHIez2yvF2GkTZU59o0jGctrIA3LOpkLs2FfHrh98dU3+G44Mrss9KhG4wjp2FQFKU7IiHfTTlwRQmFq/Xy+LFcqi+y+WKRSbU2eR7yXjDc6Ph3uVtTgIhccLHnYLCbEaQpJl/M5wtCIJwfH5J6cI33n1/0PcnI8R3sLYej4ehzqsgCJhMp0IYGzocHG7q4UhLL0eaeqjudJ+a/Amg1hkoSjFTlhlPYYKWomQTiebBJ84jhfgO1dbv9w0bXtu/bU+3gytXlwzZFuC+v7yPS1Rj73XT4/bS6w3h9IXOyMWMhlECSKHgkOGZclsdgiDfPKKhuKNpqxPCZFi0ZFnlnMy8JBMFyWYsRtno7x+2O1J45mhCfH3BMNvKO3npuA1PSFZGfeRDS7liZSH5BYWMNDY7+nz84s0qth5siL23LNfK5tI0luZYUauEWIhvlP6hjWcci9Pa+rzDj021zoDTF8LlD9HV3UefNyD/7wvR5w/h9AZx+UO4/GG8kgZPIIQvKCIG/TDMtSxqRAKjbisGfDT97KYh2wEs/sa/ibfEEafXYFCFMOlUWHRazAY18QYN8QYt8UYtCSYdGUnxaCNlMQJ+P+Hw0GHiBuOpcMuR2g4VtitKEnZXgJYeL83dHpocXhp6Q3Q45XHTfxwLQH6KicWZVpbkxLM8N4GijMRYKG4gECAYHHpsjhRCOaC/g4T4zs/LpKioiH379g26zcHmXh56o47DTT0ApBklPn3RPDaXpp6Rzziaa+fJtl7+37+P09YXQKs38OHVuVy9JJOA3xsbn3vqHPxtRyUnHvrwkN8FIPszf2ft/Ew+s3le7DVBEDje6efHr1UwPy2OP39s2ZBhu6GwyF/2tvPYTvk3l6iT+MplJVw3RO7tVIT49ro8/PHdav6wvRa3X97m+uVZfGbzPAw69ZDhwHc/to+TbU4+fVFxrAxPdHx+6/mjVLf3UJpq5OZVObHtO11+Djf1sLeum7Bai0pQcdWSTG5Ylo4gnerv3noHf36vHk8gjFmn5vs3r+SC0nRg9OPTHwrzwsEm/vZ+DY122dArSDHxxS0lXLooHUEQzhifcXFxzJs3j+PHjw+5/5G4/6nDPLW/mc9vmc8XLx3+/jUUT+xp5OvPHuXisjT+dOeakTdQmDDcbjdxcbJgW38D9bNPHOSFw618/coy7r2weMz7lSSJ5d99nV5vkBc/u3FcCxiLFi3ixIkTJyRJOlPNTUFhFqN4UCcYlUo1YFIwHKNtN9a2/Q3QkchPTyI/PYlrV8v/O31BDjT2sKvWzu5aBw0ODzVd7pgIBcjCR9FSMTmJJrITjGeIo/Q3SkZCrx99KQC9fmQRlhtXZQ8wakG+EfhDIi5/CG8gjCcQxhMI4Q2Gcfvl525/GLdffs0bDBMIiQTD4gDDViUIqFUCWrUKnUaFXqPCoFVj1KmJ02mwGDVYjVqSTDqS43QjqhL3R6vTodWNruyERqtFE1ETFEWJqk4XO2vtbK/swh2pjVuWYeHBG5fEynWoVCpUOgPGYVRD0+MNfP+DS/j4hgL+sL2ObeWdHO3wc7SjiQRjO5vmp7C+KJlCvRQTKzn9WA+HYRT5nUlmHUlm3ajrJIqSRCAkEgiLhMISoiQhilIkxhEkJPmvJLcVJSlmn/Y3UwVOeXEFQc6Tu/1nw3/2w7csH9P3j6LT64HRCQqN1FYUJdp7fbT0eOVIg24vzRGj1Bcc3CjKtBpYmJXG4qx4FmVZKc2wEDdMDpVOp0M3yrGp1WrPULocqa0gCMNeOzeWmjm/JJOXj7bzfy+doLXXx7e31vDCCQffvKqM/GEUNAfb5+p5Zv71mTS+++IJ3jzZyT/2NHKoqYf7Ns8jySx/zwsXmVmSbeUDDw3/HUwmE3deUIbRNPAcZVjlwdTa4x1gMA/G57dY2DQvhe9vLafO5uabL1bxr0OdPHBFGRvmpQy5Xf8Fz5EYTdtgWOSfe5v41bZq2vt8gJYFuYl88dIS1hQkDbqNXq9Hr9cTDIvU9oRQ6QyU5aZiNA38vDs3FPI//zlGpSPEr95rISVOT7c7cEoUTqNnXqqZT24sGuCRCoRE/rargTdOdgBalhYm8+ANS8noV0JmpPHpD4V5dn8zj26vxeaSPy/RKtcLvmVt3pBiY9GxebacbJfDRhZkjs3z3J8sxYM646iP5BUXjNODKggCi7Pjea9aFrk8Gw+7gsK5hmKgKgzAYtByYUlqrE5de6+P/Q3dHG7u4XBzLzVdLrqcfrqcfnbVngpfVQsCqRY96fF60uINpMbpyUwwkBFvINWin/ZSCoIgYNCqp70fE4EkSbT2+jjS3BNTRI56OUAOBbtrUyFXLckYUI4hEBa5/lfv8aVLS7i8X/mHwZifbuFHNy2lwe7m2YMtvHSkjW5PkBeOtPHCkTasRi2l6Rbmp8dRlGomP8lM3DjLOpwtqkk6t17PzIou8YfCtPb4aHJ4aOnxymq/kb9DhYVq1QJ5SSbmpcUxP81CaYaFBRkWEs2zr/6mIAhcvTSTi8vS+O07Nfzu3Rr2N3Rz8293ce3yLO69oGhMKsJxeg0P3rCE/xxu5cFXKjjR1sdXnz7M3RcUsa4wGWBU5XIeuKJs0M+1RAx+dyCMJI1c53BlfiJP3L2Ox3c38uj2Og439/LRR3dz+aJ07r+8bFLr2wbDIi8fbePnb1TFam2mW/Tct3keVy7JGJUCt8sfIhgJyx/seMxLi+OuTUX84d1aejxBeiIq1SpBTjG4dGE6K3ITBhynJoeHX26roqlbNsru2JDPpy4sHrV6tS8Y5ok9TTyxpzFmCGdaDXxyYyEfWZs37KLMRBEKi1R2yLUyyzLix72f7ATZIG9RDNQZgSRJMQO16CwUeBdnW2MG6i0T1TkFhXMAxUBVGJYMq4Grl2Zy9VK54LzbH+J4ax/HW/uo7nRR0+Wi0eHBHxJp7/NFVt3PzByK02tINMmhjrG/Zi2JJtlblmjSkWDSjjjxMBhNbDsqh8J5PR6uXrcAgJd2n8QY8RyPxks3m5AkiY4+P5UdTk609XG0uXdAKRqAeIOGDcUpXL00k/VFSYNOKF2+EKIrwDeeO0Z1p4t7Liga8XjnJ5v54iUlfGbzPHZU29h6tJ2dtXZ6vUH21DvYU39qkcJq1JIWryc1Tk9ynHxO441azBGFXoNWFfM866J/NaoZW35mKsdaKCzi9Ifo9QTp9gRwuOVHl0teDOro88fKGQyGXqMiP9lEfrKZwmQThalxFKfK9YWnsj7qVGDUqfnipSXcuDKHb79wnG3lnTx3sIXXTrTz6YuKuXFlzqi/syAIXLc8m2W5CXzzuWOUtzv5+RtVXLHIya3r8jAYTbx55NQY+MB6eQz85Y1DJFktmPWaIceA2C+MXJRAPYphrlWruHNDAdcszeSPO+p4en8Lrx7v4NXjHVxclsbHzy9g47yUCfHqAVR3Onl6fwvPHmim0ynn1ieZddy1sXDsuZj91khCYQmd5sw+bi5NY01+EjVdLuzuAKkWPfnJJuIHybd+r9rG796tIRiWSDbr+Pa1C9lQPLQ3eUBXJIn3a+w89GpFzLjNshq498JiPrI2F71m6hYq62xuAiERk0496qiQwYh6UJ2+EH2+4KDHTGHqsLkCOP0hBEGuLT5eonmo0TxlBQUFGcVAVRgTZr2GtYVJsfwikCdinX1+mro9tHTLYYbNPV4aHR6au72xnEKXPxSbLAyFUavGYtBg1muI02uIN8p5fFajloSIYZsQea7rF0ZsNJnGFWo5k5AkuR5mWyRcs9nhpc7upsnhwRMYmDumUQmsyk9kTUESqwsSWZBpGeAtHYxUi56bNxTwl/fr+dN79eyotvE/1ywc1aq+Vq1ic2kam0vTCIREjrf2crj5VE3btl4fvd4gvd4gVRFvwWjRa1QYtWpMOjlU2mLQEm/QYDFG/hq08pjQaWJtjBGPqVYtTNhk/XQEQRh0TA011iRJIhAW8QbkEHFPICyPe18odmy6PQF6vUGcvhCeQBhfpO3pZWaGwmrUxsLrC5LNFKSYyE8yk5lgmLGG/mSRl2ziT3euYV+9g++9dJLDTT089Golf9/VyJcuLeHisrRR76sg2cxfPr6G37xdw193NvDK8XaOtvRy3+Z5gwqg5KYljni9aY5c67ITjGMWX0qO0/PVK8q4cVUOv3qrmncrbWwrl+tbF6WY2bIgjTUFSSzPSyDNMrowX0mSaO72cqiph0NNPbxfY+dk2ynFsmSzjptX5/DRtXnjKpmRYNKSbNZhdweo7XJRljn4dSXOoGFZbsKQ+/EEQvxpRx3v1cjSbuuLkvjedYtjodcj0dzt4fsvl8dqa6fH6/nq5WVcuzxrWhZrTkbEyEozLKjOQoTLpJMXebs9QVp7vMRnKAbqdNLokL2nWVbjWUXvLM1OABShJAWF01EMVIWzRiUIZFgNZFgNrCk4832nL0RHn48upx+by4/NFcDm8tPl8mNz+umMvB4MS7H8T5zDK+WCLGIT5bsvnCA+XhariT4sBi1xBg0WvWzwmnTq2N+pnqj4Q2H6vLKR3tfPWLFHj0XkOAxlqOjUKkozLKzMS2B1QSIr8hKHzSUdim9fu4i1hUl8/dmjVHa4uP1Pe7llbS4fW59PStwocyI1KlbkyX2I4vaHYgsSbb0+Op0+7C7ZC+j0BXFHDbGgiD8UjoUCysdGxB8S6fEOLXIyFIIgG7hRj6xGrUKrEtCoVWhUAiqVgEqQx6ggEFPyVQkCakFApZJVVFVC9DH45wT9pxZWHn6zirBajy8YjuUzR8ft2WjOCcjeq+Q4HWkWA+nxejLiDWQmGMlOMJCbZCJhDDnNc4XVBUk8+6kNPLGnkYffrKKt18f9Tx9hy4I07r+sdNRhv1q1is9tmc+y3AS+9+IJWnq8fOv5o1y2KIMbVmSP+WYp50zC4uzxh3UWp8bx0w8tp8Hu5sl9zbxwuJVam5va7XX8YbusA51s1lGcFkduoonkOB1xeg1qlUAoLOEOhOjs89Hc7aWyw0mfb6DYllolsKE4mWuXZbFpfspZXRcFQWBlfiKvn+hgW3nnkAbqUIiSxM4aO//c24jNFUAQ4BPnF3LvBUWjMvCDYZFnD7Twy23VeINhtGqBOzcU8Nkt86fV21jeFs0/Hf84iJKVYIwZqGcTLqxw9sQWoBJHr7cxGLlJRqxGLb3eIJUdTiUPVUEhgmKgKkw6FoMGiyFu2BwqSZLLsjg8Afq8Qfp8crijwxOQQx5dgZhha3cH6HYHENRq4tfeAECtw4fQO7RC5emoI2UPooaNQSt75Ux6dcxTZ9Cq0WlUsnItsshOSJRFk8KiRKjf31BYJBiWCIZlsZ7+xovLHxq1h0xAzpHKTzZTlGqmNN1CSXocBSnmCTOqr1qSyZqCJP7nP8d4+Wg7f9/VyFP7mvnwmlxuW5dH8igN1f6Y9RoWZMaPehIWFqVYGaOoUJXbH8LpD9HjCdDtCeJwB+RcNe8pr6PLF8IdUe4F+Zz4guKQYkAThRQOxsbagWYngnrokjICYNKp5UUSo+z9T44IP6XE6Uk260gwa7HoNZh0kQUVgwaLQTPnvKAThVolcNv6fG5alcPDb1bxu3dqefNkJ7tq7Hzr6gVcNkLOdX8uLEll+ac28L8vnWBbeRevHGvnnYoublyWzkc+8WlUKgGNZniDZ3tVF7vrHAgCfPz8wrP9euQnm/nq5aXcd1ExO6pt7K3v5khzD7VdbuzuAPY6B3tGKGkFcuRFSbqFxdnxLMm2sqE4mQTTxOUj374+n9dPdLCj2saGeSksH8ZT2p86m5s/v1dHVaccfZFllcXaluSMbrJeb3fzjWePUhGJ3lhbmMRDNy0dVjxrqoh6qRdkjF8gKUpWgpHjrX20DFNWS2Hi0Wq1fOUrX4k9h1MGak7C2RmogiCwKCue92vsnGjtUwxUBYUIioGqMCMQBIF4o1ySYzSERJE+b4juT2+KeST7vHJuTjScstcrC3E4fUF6IuVJomJCYVGSlXwZvVF7tujUKuKNmljebUqcLCqVHm8gK8FAdoKRTKtxSkJ8Ui16fn3rKt4q7+ThbVUcbOzhsZ0NPLGnkQ3FyVyyIJ3NpWmjEokZD2qVIIfqjnP/YTHibQ+E8QXD+EIigVCYQEheJAiGRUKi/FwUJUSJiKqvrOAbjij9hkSp36IDEFH8le3E08qXXP4D1CoBnbqfcrNeg1kve+bNOvm5QatWDM1pwqBV89UryrhqSSbfev4Yh5p6+Ppzx3ivxs4DV5SOuqaz1ajloZuWsavWzs/fqKKq08Xf97USl3Mt64uSONbuZkmO5oyw+pZuL88ebOb9SHjqR9bkMn8CxY3Meg2XL8qIiZx5A2FqbS4aHV7aerz0+oK4/WFESUItCJj0apLNOtLj5XJh+cnmSb2+LMyK5wNLM3nxSBs/erWcqxZncv3y7EEF1Fz+ELvr7LxfLYcaS8jREHdtLOSWdXmjihCRJIkn9jbxyLZq/CERq1HLVy4r4dZ1+WcVTjuRlEdCfMfqUR4MpRbq9KDT6XjooYFy3lGxqpyz9KCC7F1/v8bOiX4h9woKcx3FQFWYlWhUqlg5krEgG6ahWFhmICR7Oz2BiAcvki8r5wjKns9QJBxVEIiVmNGoBbQq+a/mtLIzeo1svJh1auIMmkj+rA6zTj3jwjM3l6VxUWkq28o7eXhbNYebenin0sY7lTZMunLWRfKNF2bGU5wWN66w4slArRJiodwKCqezONvK0/91Hg+/WcUjb1Xz4pE2arpc/PKWFSSOwWO4viiZx+9K4vmDLfxhRx1dTj9vnOzkjZOd6NSyMFW8URsTMotOWlURz+m9FxRN1lcEZMGoRVlWFmXNHK/Lt65egAC8cKSNl4628crxdpZkW8mwGtBrVHgCYZocHqo7XQPUpy9fmM4XLy0ZkxLzb9+p5dEdcqjzpvkpPHTTsgHlZ6abHk+Atl7Z21k6IR5U+bspBur00zJBIb5wKvy7vF0xUBUUoiizu1mKNxim0S6Xm+jo82FzyWGQbn+IQFhEgDNqdWrUAppIHU+NWn7dYtCQaNaRbjGQlWDEMk2lQsaDKIo0NzUCkJObh2oEkSCQDRtZdEcRmIgiCAJbFqRzcVkalR0uXjrSyr8Pt9Jg9/BWRRdvVXTF2qbH68lLMlGaYaEoRVaJzYg3kBynP6fFHcYz1hSmF41axZcuK2Xj/FTu+ds+TrY5ueuv+/jD7avHtLClVgncuCqHa5dl8uL7R9lTZ2dPl4oeXzgWkhpFJcDGeSl8cmPhnA3V06pVfPvaRWxZkM6v366mssPFoaYeaDqz7by0OK5YlMEVi9LJHGOo5FP7m2PG6TeuKuPuTUUzbgGwIuI9zU4wTkgerFILdXoQRZHGRvn6n5cnX/+ji1HZCWev5B6tj3uyzTmqklQKCnOB2WONzHF8wTA7qm3sqnVwsLGbRoeHIUofnhXJcTrmpcZRlmFhQWZ8bOV7JuL1elm5uAyAhnY7ZvP05xvNNLzBMG+Vd46qrSAIlGZYKM0o5YuXlnC4uZftlV3sqXdworUPuztAR59c8mRvffcZ25v1ahKMupjycrxRS1xElEqvkUvMRAWJ1CrZC65Ry95nvUYV8TqfErOK02tGVXpoKlDG2uxlbWEST//XBj72x93U2z1887ljPPLRFWNW1g34fdx99XoA6tps2P0ClR0uXL4QIJFhNVKWYRlzVMe5yqb5KWyan0JVp4uDjd209foIhkWMWrncyqKseApTzOOajHc5/fzijSoAvnhJCfdcUDzR3Z8QKiMLGCXpExPmfcpAVXJQpxKv10thoZxL7nK5MJlME+pBnZcWh0YlxFT8s84yr1VB4VxAMVBnAVuPtfOzNyqxuwbWQUw0aclPNpOdaCTNoifJpCPOoIl5sgIRdVRvIIwvFCYUlsV8wpJEKKKY2+cNYnMFaO3xymIbrgB2lyMm0Q+wMDOeSxaksb4omXlpcWOe2ClMD3vrHXzvxZO09HjHrC4rCALLcxMGiJw43AHqbC6qOlycbOujpstNo8NDW6+XYFiKCB15aemZ0K8RM1STzDqSzTrS4g1kRPJ2M60G0uMNJJp0yrhUGJJ5aXE89om1XPPIDvbUO/j7rgbu2FAw7v2pBEEu8zMDRHhmOvPT4iY0DxfgD9tr8QbDLM9N4HNb5k3ovieSqg7Zg1qSfvbhvXAqB7W9z0coLKKZAYt3c5FuT1CuNoAsani26DVqilPjqOhwcrKtTzFQFRRQDNQZjScQ4gcvl/PysXZAVja8ckkmG4qTWZJjHXX9u9Hi9AWp6XJzsq2Poy29HGnu4WSrkxNtcq3Lh7dVo9eoyE0ykRKnw2rUYop4vEw6NVajloJkMwsyLROqDKkwNk629fH7d2t5t8oGyOOmdQJsNznnN4lV+UkDXpckiT5vCLvbT7cnSK83QLdbFqfqi6ju+oOyunFUmKi/QJGcBywr+kbrhroj6sdhUYrV0G0epoauWhBIipMN2FSLXJ6lIMXEpnmpE7LCrTD7mZ9u4bvXLuarzxzhjzvquHZ51pjyURVmBt5AmK2Re+JXryid0eGQ0RDfiTJQU+P0aFQCIVHC5grM2Oimc52o9zTVoj+rGqj9WZBpiRmoWxakT8g+FRRmM4qBOkMJhkXuf/oIu2odqAWBz22Zz39dVIReM3kiNRaDNuY1uyXymt3l5+Wjbbxd0cXOWjueQJjqThfVI0SNZsQbKEmPIy/ZRKbVEPPuGjRq1Coh9jDrNSSMQb1XYWjaen08vruBf+1tJhxR8bx1fR5fvrSU9O9M3iROEASsJi1W08SeQ1GU6PXKpYYc7gB2lxxe3Nbro7XHS1O3h9YeL51OP2FJossp15ONqmYC/PjVSjbNT+HODQUsG2XJi5mIJxDiSHMvx1p6qexw0drrxe4K4A2GEUUJjVqF1aglJU5HbpKJwhS5RFFphgWr8tuKcdOqHP66s57jrX08s7+ZuzZNroiRwsTzTmUXnkCY/GQT5xUlT3d3hqUqFuI7MQaqSiWQatHT1uujo8+nGKjTREuPBzjl0Z4IFmTG8/yhVk72u38pKMxlFAN1BiJJEg+9WsGuWgcGrYq/fnwt66bpRpwcp+dj5xXwsfMKCIsSzd0eam1ubE6/7B3zh2IKuDaXbBzU2dy09/lo7/NB1eg+x2rUsiDTwsc3FLC6IGnkDRSQJIn2Pj/76h38+1ArR5p7CUdiea9emskXL5nPvLSJmRhNByqVQKJZR6JZR3Hq0O2CYRG7K0Cn00eX0097n4+Wbi8HG3vYWWvn3Sob71bZuHpJJt++duGsKAHj9IUob+/jYGMPO6ptlLc5Y+d2cML0eoM0OjwcaOwZ8E52gpFFWXI++dIcK6UZlhmR1xtFGmv8+VmgUgncuaGA+58+wtZj7XxyY+GUeeB6PAGaur1oIkZGyjjqDc8kJEkiGJYQBLm+6lQdx7crZdG2q5dkzmjvqc3lx+EOIAgMWwN8rKTFG2IGqsL00DyB+adRokq+J5VSMwoKgGKgzkheONLGMwdaEICHP7Ji2ozT01GrBPKTzSMWP+/zBTnZ2kdFh5N6myeiMuzH5Q/hDYYJi3IObP/wzV5vkF21DnbVOrhgfgr3X16q5GGcRnuvj/drbBxv7aO6y0Wj3UOfLzSgzYbiZO69sJgLS4ax6M4xtGoVGVbDoN6Emi4Xv3+nlif3NfHS0TZW5iVw/YrsaejlmTQ5PBxv7aPW5qa910uXM4Dd7Y8pcp9OdoKR1QWJLM6yUphiJi1ej1mvQS0I+EMiPZ4A7X0+arvcVHY4Od7aR6NDVvpu6fHy2okOAAxaFctyElhdkMjagiQWZMZPS/6uJxDih1srmD9BAjKj5YrFGXzjuaPU2z00dXvJSzp7Fc6h6HL6+c/hVl493k5Nl3vAe5lWA2sLktg4P4XzipNnTAmn4Wh0eHi7oovddXYq2p10e+RxmmDSsiAjng3FyWwuTR2zIu9ocflDvBsxUK9YnDEpnzFRVEbyT/OSTBNaTzo9Uoanw+mfsH0qjI2ogZozgeO8LKLkW2dz4wuGJyx0WEFhtqIYqDOMqk4XP3qlAoAvX1bCZYtm9k14MOINWtYVJY/asPYGwtR0ufjXviYe393Iu1U29jd089gn1yoiJMjH58evVfDvQ62c7mtSCwILsixctjCDD67IJncSJ9uzkeLUOB68aSmFqWZ+uLWcP71XP60Galuvj61H5fqQ9XbPsG0zrQZW5SeyaX4K589LISdx7Oe21xPkaEsvh5q6OdjYw/7Gbno8QXbXyUJov6IGi0HDitwEVuYnsjwngdIMy6SVDJIkieZuL6+f6OCp/c10Ov3oT6qm1ItqMWhZlZ/IrloHe+ock2ag/udwKz94uZxAWIy9lmk1IEoSnZFQ9X8flks6WQwarl2Wxc2rcmbkb/hoSy9/3FHH9khe++n0eILsrLWzs9bOT1+v5GPn5fOpC4snfBy9ebIDf0ikONXMkhlexqeqQw7vnT/BUSzp8fJCXKfiQZ02YiVmJtCDmhqnJ9GkpdsTpLrTNWfLVCkoRFEM1BmE0xfkS08ewhsMc/68ZD510cxVJ5xIjDo1i7OtLM62cvt5+XzuiUOcaOvjG88d4y93rhlykqPRaPjE3ffGnp+L1Nnc3P/0EepssvdlVX4i64tkr1dxahwFyeYJXZ0/V7l0YTo/3FqOzTU+r8PZjLW2Hi/bq228cbKT/Q2nyvNoVEIs5DYvyUx6vD4W+pmbZCJOf/Zj2mrSsnF+ChvnpwByXm9Vp4tdtXbeq7axs9aO0xeKhUFH+1WYYqYgxUxGvIF4gwaDVo1KBZLEgEUSlQBqlQqNSpAfkVJCAEgSvqBIny9Il8tPo91DRYeTjr5T5yDTauDnH17OhT+eWg/ueUUp7Kp1cKCxm5tW5Yxqm9GOAVGS+PkbVTy+W66buCIvgY+uzWPLgvRYCRqXP8SBhm7eruji1ePttPR4eXx3I4/vbmRdYRI3rszmotK0aVWmliSJnbV2/vJ+Q2zcqgQ4f14KF5elsTIvMbaA2OBws7e+m9eOt7O7zsFjOxvYWWPnwRuXjBhxMxaeP9QKwI2rcmZ0eC9ARUzBd2IjBNLjIx5UxUCdMjQaDZ/+9Kdjz2MlZibQgyoIAvPTLeypc1DZ4VQMVIU5z7k5q5+F+ENhvvLUEVp7feQlmfjVR1fOybIZ89Is/OnONVz+83epaHfyr31N3LY+f9C2er2eH/30F1Pcw6kjJIp8NWKcpsfr+cVHVrB+hoR7zzaiE4rxqraOZax1ewK8V21jT103Bxu7ae0dOJFcV5jETatyuHxxBvGGqRUwUqmitW4t3LGhgFBY5HhrH7vr7Oypc3CgsQeHO0BVpysm8DLRqFUCq/IT+ciaXK5akjktoWxrChIBONTYgyRJozJ2RjsG/razIWacfn7LfD6/ZT6q067lcXoNF5SkckFJKt+6egFvV3by2M4G3qnoinm3sxOM8jhZlB7zmk0FTl+Ityo6efZAC0dbegH5nF2/PJv7NhdTlHqmwbXUlMDSnAQ+ubGQ10908NWnD1PV6eLuv+3nz3esmRBPU4PdzZHmXtSCMOpFhelkokvMREmLjIX+Cz0Kk4ter+dXv/pV7P+2Xvl+MtFpSKUxA3Vyrr0KCrMJxUCdAQTDIt96/hj7Grox6dT8+taVc7pMS4bVwNeuLOPrzx7lsV0NbC5Nm5OlQl460katzY3VqOWFz2yMTUwUxs6/I56XDcWTY+CHRdnb9NzBFrZX2QiLp/yMKgFW5ydx8YI0rlmWNaGr7meLRq1iWW4Cy3ITuOeC4lgIbnm7U65x2+PF6QvhCYYRJQkBeaVfQPakipJEOCyXCwr2+wsgACadmjiDlnSL7BUuSbewNMeKeQK8w2fD8rwENCqBDqef5m7vhIXVnmzr41dv1wDwvesW8bHzCkbcRqUSuLgsnYvL0mlyeHhiTyP/2NNIS4+XX7xZxS/erGJxdjyXL8pgS1nahBurvd4gx1t72dfQzd66bsrb+4gOX71GxW3r8/nkxsJRT8YvXZjOq1+8gNv/uIfydief/edB/vrxtVgMZ3fO34nknm6YlzzhJdYmGkmSYgs8E51jnR4zUBUP6nTgC4ZjudcTUQO1P1FvezR/WUFhLqMYqNNMrzfIN547yq5aBxqVwKO3r1ZCO4APrsjmF29U0d7n40O/38llC9PJSTSRatGTbtGTnWgkPV5Pr8MBQHJKSswLIkoS3kAYlSDM6vDXN07KtXzuuaBIMU7PArvLz4tHZAP16qWZ49qHJEnUNLVR3u7EqzLhD4moBAFPIERTt5ddtXZsrkCs/YLMeDaXpnJecTIr8hInJFx3KhAEgdwk04zMg5xITDoNK/IS2Fvfza46x6i+ryRJ2G1yGHT/601/fvFmFWFR4srFGUNGfgxHbpKJr15Rxmcvns/zh1p47kALe+sdHGvp41hLHz95rZKyDAvrCpNYnpvAwqz4UasB+0NhmhxeGuxuarrcVHU6qWh3xfLp+lOUaubGlTncvCpnXNeeNIuBv35iLR/81Xs02D387PVK/t81C8e8n/4cjKhTzwYBOLs7QI8niCDIefATSTTEt1MRSZoyJEnCFvntuwV5ocagVU14Ca+ot10xUBUUFAN1wpELaPtHnDSERYm3Kzr58WuVdDr9GLQqfnvbKjbMS5mins5sDFo1/7xnPQ88c4TddQ7+c7jtjDZCyE/9T24E4OqfvE5A0GJ3B3C4ArE8OatRy+r8RG5bn8fSnISp+wITQE2XvAK/rlApu3M2/OX9evwhkYWZ8SzLGfvij93l52dbj/LbT2wEIPeLT6PSnTlptxq13Lgyhw+vyaU0Y/aW95krbC5LY299N+9WdnHzKEJGPR4PZUW5ADS02zGbB+ZWHmzsYW99NxqVwDevXnBWOZJGnZpb1uZxy9o8Ovt8bD3Wzn8Ot3KgoZvydifl7U7+urMBkGtOz0uLI9Wix6hVoVIJBMMS3oCskO5wB+ns89HW6ztDZC1KQbKJVflJbChOZsO8ZDKtZ+/lT4838ItbVvCh3+7k34dbuXJJBmvOooRYtL7xbKhnXB3xnuYkGic8hD094j12uAP4Q+FJrY2uIOPxeEhLSwPgraPy7y7TapzwPOiogdrc7cXtD017pImCwnSijP4Jptsd4OqHd3BecTKLs+IpybCQm2hCp1bR6w1SZ3NzrLWXHVW2WG5aUYqZh29ZoXhOT6MgxcwTd6/nzfJOTrT20dQtl6xp7fHS3O3FGzg13TrS3Duo0dDrDfJmeSdvlndy86ocvnpF6ayogwnEQiWVm9T46fEE+NOOOgDu3JA/5glFZYeTLzx5iDZbb+y1zWVpJMTHIUpg1qlJidNzXnEyqwsSlcniLOKyhRn86JUKdtc56PUGz9ob8rdd9QDcvDpnXIrLQ5EWb+CODQXcsaGATqdPFreqsXOoqYeqDtepmtOjwKLXUJhqZn6ahbIMC4uy4lmUZcVqmpxc6DUFSdy6Po+/72rksZ0N4zZQXf5QzGM4GxZ/ogbqvAn2noJc0kenVhEIi3Q5/RM61hRGJlreJ+rJnkgSzTpS4vTYXH6qOl0snwWLMQoKk4Uy851gwqJESJTYXmUbUpI/SoJJy23r8rlv87xZHYo6mahUApcuTOfShekDXhdFibp2O/N+Jv//8w8vJzkxnmSzjrR4PRa9lqAoUtfl5vHdDTy1r5mn9jeTk2gcV+jddBCn1+BwB3CeVutUYfT89f0G3IEwJelxbC5LG9O27b0+/uvvB+j1BilMMdEUef3Xt648w3umMPuYlxZHWYaF8nYnb57s5IaV4y8/1OTw8G6lfL2/a1PRRHXxDNIsBj64IocPrpA9vk6fXEaowe6hs8+PN5IrrFOrMOrUWAwaks160uL1FCSbSYnTTbn67T2bivnH7kber7HT1usbV95eVOQs2aybcmGx8RAzUNMm3kAVBIG0eD3N3V46+hQDdarpiDgWJiLKYDBKM+KwVfup7HAqBqrCnEYxUCeY7EQjT31uE+/X2Dja0ktlh4tmh4ewJGHSaShMMbEkO4FV+YlsWZCmFGMeJyqVQEa/G8TlizPOMBqMqGMCMEuyrfz3v4/z67druLAkdVbk2Jn18thw+YPT3JPZiS8Y5rGd9QDccV7BmDznkiTxvZdO0OsNsjg7nt/fsoTsb05SRxWmjetXZPPDreW8dLTtrAzUJ/c1IQGbS1MnPOdwOCwGLRuKU9hQPGUfOWbykk2szEtkX0M3O2vs4zrOrRHV1JxZcN2GU+kZk2Ggghw+3dztVWqhTgPRaIXJUtaen2bhvWo7le1KHqrC3EYxUCeBhVnxLMyKn+5uKPTjtvX5vHq8gx3VNv6wvZbvXrd4urs0LJIk4XDLojsa1cQWu58rvHSkDbs7QKbVwCULx+Y9ff1kJ7tqHeg1Kn7xkRVYjbMjLFxhbFy/PJsfvVLOoaYeqjtd4zIo+rzBmEr0necXTnQXzwnOK05mX0M3x1p6x2WgtkW8VtkJs0MsbjI9qKDUQp1OouV9JlrBN0o0D3WyynwpKMwWlJmvwpxAEAQeuKIMgK3H2ilv75vW/tTb3fxxRx0Pv1nF796p4ZVj7Zxo7aPL6ae2y8X/vnSSjj4/Zp2atYpI0rj45165FuUNK7LHZOQHwyK/fLMKgE9fNG9KPWIKU0uG1cDlizIAeGJP47j28fSBZjyBMGUZFi6Yr4jcDUbUUGtweMa1fVtEaXg2hLO6/KGYQT0vdXLyZaNldjoUJd8pp2OSPajR30q1YqAqzHEUD6rCnGFJjpWrlmTw8tF2vvSvwzx441KWTLEwVTAs8pu3a/j77sYBtTKH4s7zC5Qw8HHQ3utjb303AnDNsqwxbfvmyU5ae32kxOm498LJyydUmBl8cmMhW4+189LRNu65oGhME89gWOTJvXJ28t2biqY8v3O2kBcJzW3vHZ/Hr94uG7b5yTPfQK2JGBYpcfpJE59SaqFOH/IxFybNgxo1UFt6vHgDYUWfRGHOohioCrMWjUbDHXfcEXs+Gv73+iWcbHNSZ3Nz55/3sjBTDsdOMmlJjzdQnBrHgizLpIXV/mF7Xaw8xKb5KZSkW3D6gtR2uWl0eOhy+YnTayhJt/Dly0rYUKx4ZMbDm+UdACzNsZJqGZva4lP7mwG4/bxTiwPjGWsKs4PVBUmsK0xid52Dv+1q4CuXlQ7aTqPR8JGP3hZ7DvBWRRc2V4D0eP2YF0LmElGDyubyI0rSmPPBKyL5eGWzScE3bfKE1JQQ36klev0XJYkdnjCoNGRMkoGaZNaRaNLS7QlS0+VSqjsozFmUmZbCrEWv1/OXv/xlTNskmXU8f9/5fOc/x3n2YAsn2vo40TYw3DfTauAT5xdy3fIs1KrBJ1J1Njfbq2yUt/fhCYTRqVWkWPQszopnXWESyYPUwW10ePjr+/UA/OCGJdyyNu+MNpIkKV6YCWBXrQOA9UXJY9quy+nnUFMPAB9anRt7fTxjTWH28OnN89hdt4d/H2rl3guKsAyiFKvX63nkd48OeO2Nk/JCyA0rc9BplIyZoUiz6FEJcp1wuyswpkWjqk4XdncAo1Y9Kybr1ZMskATEjp/NGZi0z1A4RfT6397rY/0P3kStEkasdX82zEuLY299t2KgKsxpFANVYc5hNWr56YeXc/8Vpeypc1DZ4aTbE6TJ4eFIcy9tvT7+7+WTPH+ohS9fWsLSHCuCIOALhnm3sot/7m3icHPvoPt+EtCpVfzwxiVcWJI64L3ddQ5CosTq/EQ+siZ30O0V43RiONDQDTBmmf7DzT0ALM6On7QVcoWZxwXzUyhONVPT5WZHtZ0rF2eMarujkevAljGWMJpraNQqMq1GWnq8tPR4x2SgvnZcXgQ4f17yrKgzXBsxUCczdz16/LpcSg7qVBJT8LXoh1y8nghiBqqSh6owh1EMVIVZiyRJeDxybpLJZBqzcZdpNXLd8oGKkr5gmMd3N/LT1ys43trHJ/66j0VZ8WRaDexr6KbHI5d80agENs5PYV1hMokmLf6QSJPDw/YqGxUdTv7738d4+XObiNOf+olF/SsJJq1iiE4i3e4ALRFRlQWZY1PTjoqbFKYMnFye7VhTmNkIgsDFZWnUdNVxoKF7UAP19DEgSnLIKjArylZNN4UpZlp6vDTY3aNeOAqLEi8ebQNkL/VsoKbLDUyygRrx3jncAYJhEa1a8d5PJtHffn2bHUmSSJ/kxcvo2Il64xUU5iKKgaowa/F4PMTFyRdyl8t1Rh3U8WDQqvnkxkI+sDSTh16t4IXDrRxv7eN4qxwGnGU1cNOqHG5bn0/aIGIq26u6+Ngf9yBJnLHCGp3EHmjsISxKk7oCO5ep6JDz1bKsBiyGsV3ipIhulfq0UzMZY01hZhEN2fMFw4O+7/F4yM+QQ8Yb2u0YowsVkjQqwbO5TmGKmR3VNpoc3lFvs7+hmy6nH6tRy5YFM99LHQyLNNgjBuokhvgmmnSoVQLhSMi0Eu0xufS//ud+8elJE0iKUqwo+SooKAaqgsJgpMcb+PHNy3jgijJeOtKKhJybumVB+pCr1ZIk8eu3agD4wNJMjKep767IS8Bq1OJwB9hW3smlC9Mn+2vMSaI39cLUsRuRSWY591AJnZt7RBc2Rht+qhIE0ix62np9tPV6yUowTmb3Zj1RBd5odMNoeLuyC4CrlmTMivDeJoeHYFjCqFWTOUllSABUKoGUOB0dfX66nH7FQJ1iJqvETJR5EQ9qvc1DKCyiUTzkCnMQZdQrKAxDqkXPnecX8vHzC7liceawoVRvV3axs9aOTq3i9vX5Z7yvVau4foWs9PnIW9WT1ue5TtSDkTeOsMvoNjWd7gntk8LMpsvp58XDcijp6bnjwxEdL4qnY2Sihr/DPXphn3qb/DtckZc4KX2aaGoj4b2FKWZUkxwhcyoPVVHynWoyJtlAzU4wYtCqCIRFmrpHv6CjoHAuMSMMVEEQCvr/VVCYaYiihMsfGrbN796RvacfWpND5hDelNvW5aNVCxxu6uFgY/eE91OBWAhhTuLYPVqFKbLXtb3Ph3uE861w7vDgK+UEwiJLc6wsG4OwVtQrOJaw1bmK1ShHJ/T5gqPeptcrt02dRMXUiaQmKpA0ieG9UaLHpMupRHtMNZPtQVWpBIpSlDBfhbnNjDBQgXsjfx+Y1l4oKJxGKCzym7dr2PSjt1j2ndd46NVy/KEzc9SqO53sqnWgFgRuWXNm+ZgoSWYdly+SBVj+tqth0vo9l2ntlY2FTOvYDVSLQRsTtmrrVYyOuUBNl4tnIrVvv3RJyZi2jY4V5xiMrrmKLhJ9EgqPPl/XrJPDekdaHJwpxAzUcaQXjJWYB1UxUKectPjJXzCJLnLUKkJJCnOUKclBFQThh8Bwd6VLIqqYl0xFfxQURsvD26p5+M2q2P+/equGHVU2nrz3PAz9ckz/tU+e4J4/L3nEfKDLFqbz4pE2TrT2DdtOYXxEi9enjaGURX9MOjUufwhfUJzIbinMUJ7Y3YiEXGpmSc7Yag5GvexGnSLnMBJRHamxhL4mmnXAqd/0TGcqFHyjKAbq9JFmmfyc32g0T51NSTdRmJtM1V11H/B7YC8w2N2pGEgECqeoPwiCcAlwM9ADJAD7JUn6/VR9vsLMR5Ik/h7xcn5m8zzS4/X86NUKDjf38uTeJu7YUACAJxDiqX1NAFy/Inuo3cUwRbwCNkWIZ8KRJFnVEmSly/EQCMuGqeZ0KV+Fc5KXImVMPjiK3+7p1EYmj9FQX4Whiaoj6zWjD9zKSZSPa/MsycOLeruKpsKDGgnxtblGn9OrMDGkT4UHNTKGonnNCgpzjSkxUCVJeloQhDeArwG/lSSpvv/7giD8UJKkrwmC8Nup6I8gCCuBByVJWtXvtdcFQXBIkvT0VPRB4exRq9XcdNNNsecTTbcnGBP0uGVtLgatGoc7wM/eqOKlI20xA/Wfe5ro9gTJTjCycV7KsPuUJIl/7pWN2XVFyRPe57mOPyQSirhqzPqxX95CokhvpNZtkvmUgTvZY01henD6grHatyMJ8ajVaq69/obYc28gzKGmHgDWFCRNaj/PBdwB2dscXaAbDQmmSN6qd+aHUDvcAboj146ilKnwoMpePMWDOvmo1WquvOZ63qnswtQvDWQyiY6hWsWDqjBHmbK4JEmSeoCvCYJwtyAIkiRJj/Z/O/L3qSnqzoPAk6e99rvI64qBOkswGAw89dTkDZnoir9aEGJ1DmWjsoqT7XJ47ktH2njwlXIAbj8vf9japk5fiO++eJxt5XLphLs2TlnAwJzBHzoVljsWT02UbncQCVAJkGw+tUo+2WNNYXqILkDpNaoRa+YaDAb+9Ld/xP7fVt5JMCyRm2SckpzD2U40j9Q0hnDoaN5q/9/1TCXqPc1OMGIcgxE+Xk6p+CoG6mRjMBj4n58/yod/v4vMJDORlLRJpSBFjh6wufz0+YLEG7ST/pkKCjOJKRdJkiTpD8CbgiD88HTVXkmS3pyiblwC1J72Wi1QFPGuKiiQlWCkMMVMWJL41ds12Fz+2CREq1bxvy+e4L5/HMAfErmoNHXYEMHdtXZu+cMutpV3oVEJ/OCGJbOmdMJsZTxzCLtbnuwlx+mHXWxQODeIKsv6QyKBMRpBW4/JocFXLc6ckgnrbMcbkBf8Tq8PPew2kUVCwxi2mS6ioZhTEd4LSg7qVNMROc7j1TYYKxaDNvZZSpivwlxkWpQdJEmqQ/am3i8IwpTW2uhngPac9lb0/yLgwFT1R2Fmc9OqHB56tYIn9zbxZCQ0F2RxlEd31AHw0bW5fOGSkkENGkmSeHhbNY/tlHNZc5OM/PKWlSwfQykLhdGj6XcOQqLEWOe1Hr88IR7Jm6ZwbmA1akk0aen2BClv72NpTsKotguERHbWOAC4ZlnWJPbw3CEYUe/VaUZvzHsiXtfZ8HussUXyT1Om1kB1+UN4AqExeaYVxk5nRKhrskvM9Kco1Uyn00+dzaXMGRTmHNN6RZMk6SFBEFYAdVP4sUMlCzlGeD+GIAjHh3ireFw9UhgXbrebuDg5T8PlcmE2T/zE4FMXFpMap+cP22up6nQRp9cQliS8gTB5SSa+fFnJsHmnf3qvPmac3nFePl+9omxcuZEKo6N/WK8/GB6TtwaI5a+qT/OITcVYU5h6BEFgXWEyrxxv5/0a+7AGqtvtJj9Dzhv/z94avMEwKXF6FmXFT1Fvzw3E0VeZwTmLDNRTHtTJzz8FuQSPQavCFxSxOQPkJc/8YzRbcbvd3H2BPL1LfHrvlH1uYUocu2odigdVYU4yISG+giBcLAjCk4Ig2AVBCEcedkEQXhUE4QeCICwfaltJkg5OYWjvcCgqFwpnoFIJfGhNLq998QJOfPdyfnXrSryBMBaDhr9/cu2wxuneege/ebsGgO9dt4jvXLdYMU4nGY1ahS5ipEZDCsdC1KD1jGNbhdnJFYvlusQvH21HkkZnPTU6PP+fvfMOj+uq9vZ7plf1XixZxb3XON3pvTcIhMAXEggEQr+X3i69Q7iXQAgQICGkkx4ncRLHvduSLcnqvU/vM+f748yMJVvd6trv88zj8ejMzJ4z+5w5a6+1fj8AluQkiPLeEWLRK8fWaI7L2HE4E7KDk6ngC8riysk+1JlhwzMbmAyLmRhxJV8hlCSYg5xxgCpJ0pdQ1HlrgR8BPwWeQbGTuRT4MrBPkqTdkiTdeKbvNw7EMqVJpzyedMrfB0WW5aUD3YDq8RumYDohSRImnYaXDyt9Z1cuyxo22Pzztjpk4LZ1eXx4U+HED1IAgDX6vbjGEGQmGJXn2meAaqhgfLhsaSYmnZpmm5ejzSPzJo71KucM43ksOElS1PZpNPZasR7U0Sj/TgWhcCS+aDFZGVQ4aTUj+lAnj7RJ6kGFk16oIoMqmIuMx7JkiizLlw30B0mSkoAtKD6otwFPR3tO75Fl+dlxeO+xcKo4UoxYBlX0nwoGRJZltlZ2AHDBgvQht23s8bC7rgcJ+MzFpZMwOkGMRKOWbncA5xiCzDTLyb4utz8kMt5zAJNOw0WLMnjxcCtbKztZnpc47HNiOVORPB05sYvt+h4PsiyPKPMcy7ZO9+OwqddLMCxj0KrInsQexVgGtUMEqJPGZIkkwcnFjtouF5GIjEoI9wnmEONR4jvoERO1lumWZfkTsiynAOuAt1AC1SfG4b1HTXRMW1DEkPqSBNhkWR4sgBXMcbZWdNLu8GPUqlk9L2nIbd+tUqxkNhWnxs3mBZNDctS/tNczegN7s14T72Ptdo3++YKZyYULMwA40DAyzT5r1PKhS8yREVOSYUGjkrB5gjT1ekf0HFvUVzSmtjxdqYkKJBWmmic1iIgFqF0iQJ1Q+pb+T2aJb36yEY1KwheM0O4UZdyCucV4BKjVkiT9cCQbyrK8X5blW4ESIEWSpNfG4f3Hwo+B+0557D7gK1MwFsEM4a876gBF2VevGbrk7L2qLgAuWpQx0cMSnEK87G2M/oBJJuVieCwBrmBmElPIPN7mJDKCPtTc6KJTregNGzGGPgt7e+qG7aQBTpYDp09i1mosxEowiyexvBcg3aIES8ILdWKJefjC5M5FjVpFfoo41wjmJmccoEZ9TUskSdojSdLKET6nJloWvEWSpC+e6RhGiyzLW4CvSJL0B0mSvixJ0h+Af8uy/PBkj0UwM5BlmYONNgAuX5o55LZV7U721SuZmMuWZE300ASnkJtsBKDVPrYV59jiQzA8Ol9MwcylMNWEWiXhD0VGlDmPi5d0usYkxjVXOa9UaY2ILeANhTcYjpeuzkuZ3lUo1ZPsgRpDeKFODh2Ok/t3ssvNC1OVuV/X5ZnU9xUIpppxOdJkWb41GuQdkCRpL/DDkfSYRm1mfjQeYxgtsiw/BTw1Fe8tGB/UajVXXXVV/P5EEgzLOH3KKupgP1CyLLOnrpevP3eUiAyXLM5gXur0vrCajcQuZhu6x/aDHo76YPRtkZvMuSaYfDRqFekWPW0OH51O/4BZErVazSWXXQFARoIx7p9a2e5kpfAoHBEXL87gF29Usqeul1AkgkY1+Bp5U1R0KOZVO52ZbAXfGCJAnRy6vUGMResw6tSTfv4vSDUDndR1iwyqYG4xbktBsizfJ0nSv4E/oPSYykR7PSVJKpBluX6wp47XGARzC4PBwEsvvTQp76XTqFhbkMzu2h6e3NvIZy4qpccdoLLDSUWbk8p2J0ebHfEV/8XZCfzklhEVFAjGmQWZVuBkVmO0xBR8E426+GOTOdcEU0OiUUubw4fTN7C4lsFg4Imnn4v/vyTDwp66XhGgjoLFWQkkGrXYvUEq2pwszRlckKo+roprnvZWPrHyy/lpk1ziKwLUScHmh4xbv83ZxakYDJOr3B0TFxMlvoK5xrjWKkRLZ4slSboEpafz5uifaiRJsqGo+dYAtujja4A3xnMMAsFEcePqXHbX9vD47kae2N044MqKSafmmhXZ/PeVi+NiPYLJZUl2AgDNNi897gApo/geej2BeL9RtrAQmVMYolYm/tDISrtzEo1AL+0OIV4yUlQqiUVZVnbV9tDY4x0yQI0FXcp+nr44fcH4wuRUZVC7XIERKyMLRk97tMQ3cxIVmmMURgPUOhGgCuYYE1JMHw1Ut0iSlAjcC6xHCUYvjW5iQwlWfyzL8psTMQaBYLy5bV0+FW1OXjjUQo87gEYlUZxuYWlOAkuitzXzkjFoRQnoVJJo0lKaYaGqw8XBRtuohKqq2pVSvfwU47S3thCML9qo+mooMrKinoSosqzwzB0dMSunnmFEyGItFQnTXME31huYZtGTYJjcsaZZlMW3QDiCwxsicZqXQs9UYotQGQmTL9Y1P/WkPZOwmhHMJSb0CkyWZTvw04l8D8Hcxe12k5GhBB8dHR2YzRO7eq2S4Krl2dyxPp8kk45ks3ZYNV/B1HB2cSpVHS521nSPKkCN2Yyszk/u9/hkzzXB5BOIimLpNAP3RbrdbhYX5QNwrKaRcETZXj1EH6XgdELR/aZTD73fNOrogsE0FyuLWcwUpU3+OUGvUcdLpjtdPhGgThDNHTYafnEz3/61is90dU7q+T8nyYBWLREIRWixe4VtnWDOIH5ZBTMaj8eDxzPx6nb76nu48tfvcdsfdnDt77ZR0+USwek0JqYWuqO6u5+H3XDsb7ABsLEo5bS/TdZcE0wNMVshs27wddu+cyBWCm7Ri/PAaIh5xw6XGY1lI7vd09vuKWYxM38KAlQ4WebbIfpQJ4wOpw856CfgG5l/73jS12qmfozCfwLBTEQEqALBMHQ4fdz32H6OtzkBRdH3nr/uZWtFxxSPTDAYZ5ekolOraLH7ONHhGtFzwhGZoy12ANYXnh6gCmYvvmCY5l7l4jMveWQ9jzEbo+xp3iM5nYhEZCqj59HhMo6xgK+y3Tnh4zoTYuI1k91/GiNW5iuEkiaODtfU9pnHynyFUJJgLiECVIFgCAKhCPf/fT9dLj/zUky89MC5bJyfgicQ5pN/3095i2OqhygYAJNOw/kL0gB4u6JzRM/pcQfwBSOoJChOn1w1TsHUsr26i4gMGVZ9/IJ/OJqiAa2wkho5R5rtOP0hzDo1BcPstwWZVlSSsp9bbJOfuRopsRLfqcugKsI9IkCdGGRZpsMxtVl8IZQkmIuIAFUgGIRQOMJnnzjA3vpeLHoNv7p9JVmJBn59xyo2FKbgDYb52F/2xPsWBdOLy5dmAfD2CDPdsZJNs06DWghRzCme2d8MwIUL00ekhBoKR2iLZlCHC7QEJ3m3Ulks2liUgnaYHlSrQRNX+d06wkWmyUaWZWo7pzaDmh4Vnep0iQB1IrB7gwRGqOw9UcQDVOGFKphDiABVIBgApy/Ig/86yCtH29CqJX588/KoYTZo1Sp+dPNyClJNtDl83Pj77Xz00d089PYJXi9ro6bTdVrfozcQ5oVDLfzX04e5+jfv8cV/H6Je/NhMKBcvzkQlQWW7K16OORSZCXokwOkP0SUu9uYMHU4frxxtA+D6VTkjeo7LH4rbTKWYhJ3USHknGqBuKkod0fbnlypVEK+WtU3YmM6ETqcfdyCMSoJ5KVPbgyoyqBNDzGJmKilMFT2ogrmH8FEQCPrgCYR44WALv9xSSbvDj1qS+NFNyznrlAuqRKOWP921jl+/WcWLh1t5u6KzXylpbpKR9YXJpFn01HS52VXTjTsQjv+9rMXBsweaefjDa7l4ceakfb65RIpZx7qCFHbX9fD28Q4+uHHekNubdBqK0s1Ud7p5Zn8T955fPEkjFUwl/9rdSDgisyIvkUVZCSN6TsyKRiWBSnhPjghvIMyBRhvAaefTwbh4cQYPba3m/RNd9LoD085bujqaPc1PMQ2q/jzRiAB1YpkOPscFKcJqRjD3EAGqYMaiUqm44IIL4vfPlP0NvXzisX1xNcT8ZCNfv3ox6wYRzEkx6/jOdUv50FkF7Kzp5lirg/puDzWdbpptXpoP9u+bykk0cMmSTNItet6t6mRPXS+ff/IQ276yGesk++fNFa5ansXuuh5ePtrKBzbkD1u++aGNBXznxXJ+taWKy5ZkxUurxnuuCaYH4YjM47sbALh1bd6Q26pUKs4+9zwAks1KUBCRFT/PmLenYHCOttgJR2TSrXqyEw0jek5BqpkFmRYq2128VtbGHRuGXmSabGKiNVPVfwoiQJ1o2h0+kCQyF65hUZZ1Ss7/OUkGNCrFaqbN4SMnSQizCWY/IkCdQOzeIF0uP95AGIteQ0aCHtMQFgaC0WE0Gtm6deu4vNZbx9v55N/34w9FyE40cNu6PG5bl49BO7yFRGmGhdKMk6I63kCYPfU91Ha66XYHyE40sDw3kSU5CfFsy63r8rj9Dzup7/Hw/MEWPnRWwbh8DkF/rlmZww9fOc6xVie7a3vYOEzm5pqV2bxwqIUDjTbue2wfz9x/Nma9ZlznmmD6sLOmmxa7D6tBw8WLh/bLNRqNvPDKG/H/5yQaaLH7qGxzklYiAtThiJXZz0sxjajPN8alSzKpbHfx4uHWaRigTq1AEpzsQRVtCRNDh9OPSqvnw9/7Mz+9deWUjCFmNVPb5aau2y0CVMGcQERL40woLPPtF8rYWtFB3Sn9AioJSjOsXLY0kzs3FpA1wlVkwcTzlaeP4A9FOKcklR/ftAKjbuzehkadmvNL0zk/6sU5EFq1ihtW5/DrN0/wenm7CFAniDSLng9smMdfttfxm7dO8LfClCEFkFSSxA9vWs6dj+yiot3J1549wq/uWD2JIxZMJi8faQXg0sWZo/Y1XpqbSIvdx/6GXs4uSZuI4c0qvAFFhEw/ylLYy5Zk8tDb1Wyv7qLL5Z9W2eq4xcw0yKB2uwOEwhE0w4hPCUZHrMQ3M2Fqr9cKUpUAtaHbw9mi+0QwBxAB6jjT0OvhL9vr4v+36DUYtCrc/jDeYJiKdicV7U5+v7WauzYV8JmLSqddX81cJCfRQKfTz8WLMs4oOB0NsQti0wiytIKx86nNJTy9v4njbU7+ur2Oj507f8jt0616fnLzCu792z6eO9jC5kUZXL8qd5JGK5hM9tT1AIpv7mhZkZvIG+XtHGy0j/ewRoTLH6Ky3Uldl5uGHg8tNi+dTj8dTj9dLj9OX4hgOIJWrcKi15CdaCAzwUB+iomidDMLM60szk7ArJ+cy4DcJEXoJeY3O1Lykk0szrZyrNXJq0fbptViXk28xHfqbKlSzDpUklJu3u0OTHkgNduIqXVnJkztwkhBinL8nJr4EAhmKyJAHWcSDVo2FKbwgQ35rMpPIsF4srew0+lnf0Mv/97bxIFGG4++X8cz+5v5zQdWc8GCwbNtgoFxu90UFhYCUFdXh9k89lXs8xekc6jJzk9fqyQ3yTho3+l4sqtWuTgunMLV97lAulXPN65ewpefPsxDW6vJTTbGLWgGY1V+EvecN58/vFvDj185znnzrSwsUZatz3SuCaYHoXCEqg6lRHNZ1M5kKNxuN2uWLgRgf1kFi7KsABxrnRwv5Fa7l3crO9lV08P+ht4RX6gGw2E8gXC0t75/MC0BJRkWVs9LYn1hCmcVpZKXbBxVCe5IWZyt7K/6Hg8dDh8ZowikLl2cybFWJy8faZ02AWooHKEh+h3MnyKLGQC1SiLdqqfd4afD4RcB6jjT7vQTCfh44Oq1fF6tmrLzf8xFQKj/C+YKIkAdZ5JMWv73Q2sG/Fu6Vc/lS7O4fGkWO2u6+eWWKk50uLj7z7v59nVL+cjZhZM72FlAV1fXuLzO/ReWcLDRxntVXTzw+EEe+cg6luSMTNFzLPS4A7xXpaj+nlcqygMnmlvX5XGszcGj79fxzefLsOg1nDNMWeZHzi7g2QPNtNh9PL6rYdzmmmB6YPcGiblBJZtHJlLW3X1yDhRH+86bbV6cvuC4C535gmG2VXWx5Vg7O2q6B7SYSLPoKEw1k5dsJCvRQLpFT6pFT5pFh0WvQatWEYpEcPpCtDt8tDv8NNu81Ha5qepw0en0U9XhoqrDxZN7mwAlI7cqP4lzS9K4bGkmecnj4/OaatGzriCZvfW9vFXRwR3rR95PesniTH7z1gl21nRPmzLfZpuXUERGr1GRPcVBYYbVQLvDT7vDx3KGX2wRjJyOaImvvbdnSsdRmCasZgRzCxGgThFnFaXyt48l8dPXKnn2QDPfeqGMYDjCPecVTfXQ5iRGnZo/3rWOT/x9H1srOvn680f5xz0bMU5Q+a1WrSLFrKPLFeDOP+0iw6pn/fwULlmcwRVLsyetzHiuIEkS37h6CR1OPy8dbuVLTx3mV7evYsP8wTPleo2aT1xQxHdfPMZDb1dP4minH7Is0+UK0Gr30u7w0+3yY/MGcftDBMKKib1WpUKvUWHUqTHq1Jh1GhKMGhKNOjKsejIS9KPu85xI+vbqhcIyo3UJSTRqyUxQMldlLY4RW6cMR2W7kyd2N/LUvkYcvlD8cZUEy3IT2VCYwsr8RBZnJ5A8Cg/WxdmnL7h1ufyUtzg41GTnQEMvR1sc9LgDvHW8g7eOd/D9l8q5aFEmHz9vPhvmp5xxZnXzogz21vdyoME2qgA1N9kYL/N9o7ydD0wDsaSaPgq+U237kZmg50gztDun3hJlNhGOyHFV/6km5rNb3+1GluUJqXIQCKYTIkCdQvQaNV+7ahEpJi2PvF/H9186RlaigWtWjMwsXjC+GLRqPnxWAVsrOqnv9rCjupuLFg2t7DlWrAYNf7l7PV955ghlLY544PTS4VZ+YD3Og5eU8sEN88SP0DiiUkn86vZV+IMRthxr5wv/PsSjd6+nJGPw/rFrVuTwr71NHGvoHHSb2YAnEKLT6afLFaDT6afV7qWp10t9t4f6bjeNvR58wcgZvYcE5CQZWZabwLqCFK5ZmU124tSpUSYYFH0AXzBCu8MXL6EbDctyEml3dPDq0bYzClB9wTD/OdTC33fWc6jpZBluZoKeCxdmcHZxKqvyk7CMc79omkXP+QvSOT/aYuIPhalqd7G/wca2qk72NdjYcqydLcfaWZKdwGcvKeWyJZljPi9ZDcr4Y+JCo+GihRkca3WyZZoEqLVRD9TCMcyb8SZWLt3umB7B1Gyh0+knHJGHFNabLPJTjEgSuANhulyBuDiWQDBbEQHqFCNJEvdvLsEXivCPXQ184clD5CebWJmfNNVDm5X0ugOUtzpos/uwe4P4QmG8gTB2b5BWu4+tFR2AYh2zriB5QseSnWTkrx9dj90bpK7bw7uVnbxW1k6bw8fXnj3Krpoe7tw4j/WFKVO+Qj9b0KpVPHTnaj7y593srOnhc/86yD/u2divV7wvapXEt65Zwv1/205j9LFvPHeEy1cVsnF+CkmjyGBNFyIRmQONvbx5rIO99b1UtjuxeYLDPk8C0qx6Mqx6kk06Eo1aTDo1umjqMRSR8QfD+IIRvMEwnkAIlz+E3ROkyxUgEI4o/sA2L6+VtfPDV45x+dIsvnP90gn+xIN8HkliQaaVw012KttdYwpQb1ydy5vHO/jr9jrmpZi4dV3eiEt9ZVnmSLOdFw+38vS+JrrdAUCZc+eWpHHL2lzOKkqNW1NNBnqNmmW5iSzLTeSuTQXUdrn5564GXjrSSnmrg/se28ey3AQ+sqmQq5Znj0hgKRCKcKzVwb76Xn61pRJgTMH8puJUHtpaze66nmkRNMQ9UKew/zRGplUJUDtFBnVcabUrgl7pVh11UzsU9Bo1OYlGmm1eGnrcIkAVzHpEgDpN+OzFpTT0eHivqovP/esgLzxw7rivls81ZFnGHQhzvNXB1opO3ihvp6LdOezzLliQzvdvWDopnrWSJJFk0rHKpPR9ffLCYv6yvY7/e6eGFw618MKhFjITlN7lK5ZmsaYgeUTerILB0WvU/O+da7nuoW009nh5en8zHz2ncNDtF2ZZ+cvd61n9PeX/T+1r5pkj3UgoJZfnlaZx5bJsluYkTOuFBJsnwL/3NvGPXfUDCuzoNSpSzTpSLDoyrQayEg3kJRvJTzbFexy1Y7SwkGWZHneAum4PZS0O3qvqZH+DjVeOtrGnrgc51gw6ySyMBqh1YxQe2VScyoUL09la0cl3Xyznh68cY1NxGueWpLK+MIWSDAsWvSaecfQGwhxstPHmsXZeLWujqY+ibWaCntvW5XPdyhxSpomy+/w0M1+7ejGfvqiEf+xq4J+7Gjja7OBLTx3m688dZfPCDM4pTWNRlpVEoxZPIEy7w0dNp5vKdifH25yc6HASDJ/8ftOtej4+hlaW0kwLJp0apy/EiQ4XC6MiVVNFbZ8S36kmpjArMqjjS0zBN2uaCE8VpJpotnmp6/KwtmDihRwFgqlEREDTBLVK4rvXLeX2h3dS0+Xmy08d4qEPrhElnqfg9AXZW9/LwQYblU0nBUsu/vlWQio9oUiEcEQmFJbxh8JEBrjuzU82kptsJNGgRa9VYdCqseo1pFh0zE81j0uv1VjRqlV8/Lwi1sxL5j+HWni7opN2h5+/7ajnbzvqAeVipCjNwuLsBJbnJbB2Xkq0/EfMlZGSbNbxsXPm853/lPOvvY3cfXbBkPsvxXxytfqmNbkcbPVS1+3hSLOdI812fr+1mgSDhlXzkjmrKIVzS9JYmpM45VkeWZYpa3Hwrz2N/HtfY7xM16xTc25pGmcVpbIg00JesgmzTj1hc0iSJFKjAj5rC5K5a1MBle1OvvF8GUuyrRydormbFs1C9Eazl2Phf25YxlP7mnj2QHO8EuLdypMl4ZKk2I2FwjLeYLjfcw1aFeeVpnP50kzOK01Do5qeHpaJRi33X1jMB9bn8+zBZv5zqJWGHg+vlrXxalnbiJ6/PDeR1fOSuHp5drzUdzRoVCoWZ1nZ12DjUKNt2gSoU+mBGiMjHqCKDOp40hoPUKeuFaEvBakmtld3U98jhJIEsx8RoE4jEoxafnTTcu59bB8vH2njj+/VcO/5s9+RORhWSgKDISW4DMty/GLO6VPKA+u63Lxb1cnOGqW8CyAS9KPLKgWgxe5HNUhlXaJRy8b5KZxXmsbZxakzoixzbUEyawuS+Woows7abrYe7+Sdqk5snmBUrdHPjpru+PZZCQbOLk5lw/wUijMsLMiwkmgaX1XR2USvO8D7J5T9N5JKBZVKxao1awH44uWLMBqNdDr97K7t4Z2qTrZVdeHwheLByU+oINGoZX1hMivzkshLMZJm0ZNq1pNq0ZFk0vYTDJJlmUA4gscfxhddWNGoJEw6db8M3HBEIjLNNi9Hm+2KWurxjn79fgsyLdy6Np8rlmVOSoXAUCzItPLXj65HluHhKRpDe/QCdLAS7770nQOqPoGkQavmQ2cVcOfGedR1e9h2oov99b0cabbj8IYIyzLOPmJHqRYdGwpTuGhRBpuKUydMiG0iiC3sfPTsQo63OaOf1UaL3YvTF8KkU5Ns0jEvxURhmonSDAsLM61kJRrGZfFjaW4i+xpsHGyycdv6/HH4RGPDFwzTEi3/nA4Z1Ayr6EGdCNqiAX9WkpF169YB/Y/9ySYmlNQgrGYEcwARoE4zVuYn8flLF/CT1yr4wcvH6XIF+PLlC/spTs5EguEIZS0ODjb0Ut7qoLbLTYvNR7fbP2rxlbxkIyvzEinJsJB1+xaSjFrMejVatQqtWoVKUlbbdRrFoN6gVc3Y7KJOo+L80nTOL01HlmXs3iCNvV5qO91UtDspa3FwrNVBm8PHMweaeeZAc/y5RWlmzl+QzofOmnpBkfEgGA3g3IEQnkAYXzCMPxQmGJaJyDISEmqVhFoFKkkiIsv4QxFcvlBcgbamy82xVgc1nSd/4L98+cJh54fRaGTLO+/3eyzdqufqFdlcvSKbYDjCiQ4Xh5ps7K7tYW9dL3ZvkC3HOthyrGPA19SqJfQaNXJ0nKGB0v0o1RVJRi3JZh0pJh2JJqX3U6tWEYkoCzl2b5A2h48Wm/e040mrlti8MIMbV+eyvjB5Wh0LU1mu7vKHeDdq9bQiL2nY7QeaA32RJIn5aWbmp5n5cNSr0xsM4/QGcQfC6NQqLAYNiSMIhqc7kiSxODtBUQY+b/Led1nU+mtnTfeUKpnWd3uQZUX0aTqUY8e8T7vdfoLhyJhL8QX9iWVQ52UksWfPnikejZJBBUQGVTAnEAHqNOS2dXn0uAP8aVstD79bw7aqLj5xYTEXL8oYkSjFRCLLMq12H802L90uPw5fCH8ockr2M4InEMblD9HtDtDh8HGk2T6iQFQCNGol0DBoFauKJJOWrASD4s1Xmsa8lPHx5ZtpxPpVk0w6luee9LrzBcMcbrKzq7aH420O6ro8tDl81HS5qely87cddfGs80ThC4bpdPrpdgfocfvpdQdx+pQLc38wTCgix8utZWRkmWgpdoRgRCYQisRv/lAYfyiCO6Bc3Dt8QRy+EIHQmanInkpxupkPbpg3pNXMSNGqVfEL9jvWzyMUiXCs1cmRJjvHWh10uQJ0u/30eoLYPUHCskwwLBMMh057LY1KQiVJhCIRItH91O0OxEV0hh+LRFGamWW5iawvTGFTcaroZx+An79eQZcrQF6ykfWFEyOIZtSqZ1SGdLqzYX4qOrWKmk43R5sdLM+bGs/Pvv2n02HBJ9WsQ62SCEdkulz+KVXHnk20RbPkWYnTowc1du3TKAJUwRxAXLVMQyRJ4pMXFlOcYeGHLx+jvNXBZx4/gF6j4uzi1LgtQNEk/DhGIjInOl28dbyD96o6Odxk71euNhoSDBpW5CWxMMtKcbqZnEQjKWYdVoMGg1aNRi1NqmLlbMGgVbNhfkq/QMvhVXp1XzzcyruVnZzpbpVlmV5PkLIWOxVtTqo73TT1emi1+2i3+3D6xzYnxoJWrSxeGLRq9BpVPKCTUeZrWJaJRGRUKgmtWoVZr5Qdplv05KeYKEo3szRndB6So0WjUrE8N7HfQkKMiCzj8ilZ4EA4goSSKTdF/UNjfYixzKrTF8LmCdDrCWLzBnFG1acDIUXJVK9RYTVoSLPoyU40kJ1kmLa9jNMBWZb51ZYqHn2/DoDPX7pAZJxmCFaDhgsXpvN6eTvf+U8Z/7pv05T0ecdEtaaDxQwoFloZVj2tdh8dDhGgjhexDGr2dAlQoxnULlcAlz8kFh4Fsxoxu6cxly3JZH1BMk/saeSVo20027y8XdHJ2xVKWVqSKSo8kZ/E6oJk1sxLHnP5mD8Upr7bQ02ni+pONzWdbk50ujjR7sQd6C/soVZJZCUYSLXosOo16LUqtCoVqmigoFFLGLVqzDo1SSYdKWYdCzItFKaZxzUA9Xg8nLN+FQDv7zmIyTQ3M6sDkWDUctGiDC5alEF9t5tNvxzd811+pZ9yd20PR5rtVLU7cQyzMKFVS6SYdXELkgSjFpNWsSE5dfFBJUnRUmwJjVopx9apVWg1KvTR/xu0KhIMWqwGDWa9couVtk424znXVJJEQnT/DIUknQzEhaXA+NBi8/Ld/5THhX0+vbmEC6IeoMMhzjdnRigSiZfhnwkPXFTC+ye62Fvfy9efO8r3b1g26UFqXTSDWjgN+k9jxAJUIZQ0PkQicnxfJmplCgsLASgvL5+yYz/BoCXZpKXXE6Sh28OSaMm7QDAbEQHqNCfZrOOTFxbziQuKONHpZkd1F9uruznYaMPmCfJeVRfvVZ1Usy3NsLA8N5HiDAtpFh0GrXJBLwERWblI8AXDuPxhWmxe6qJloPXd7gEVbwF0ahXrCpM5pySV1fnJFKWbp0XGQZZlGhsa4vcFAzNSf8dgOMKO6m7+taeRLcfa8Q9QUpufbGRBppXCNDN5SYr1SLpVT5pFNyoxn5mGmGszm0Aowj921fOTVyvwBsOoJPjcJQv44MaR92f3nQN7arqptrdzpMlOlyuAPxQmzaJnYZaVCxaksyIvcc5Xg3iDYV4+3MrbFZ2Utdhx+EKoJOU3bVlOglL1UZgy6jLZnCQj/3XlIr75fBmP727AHwzzg5uWT2o/88kS3+mzSJGRYADstDuFUNJ40O0OEAzLSBKkWXTU1ysq+lN9/p+XaqbXY6Ohxy0CVMGsRgSoMwRJkijNsFCaYeGuTYUEQhGqO10cbXFwpMnO4SYbjb1eqjpcVHW4xvQeZr2awlQzBSkm5qWaKIoKfuSnmKZFQDqVhCIRnN4QLn8IX6znNvpDFcsC6jUqDBpVPOulVUszImDrcvn56/Y6ntjTSGefi5t5KSY2FaWwPC+JknQzeSkm0U8nmHG8Ud7Ot18oo9mm9JOtzEvkv69cRGnmyG1KZFlmX11v/P8PPnkIla5/2V91p5tdtT38bUc9q/OT+Na1S8ifo/3ybx3v4OevV8ZVUGNEZOh2BXinsot3KpWF1dwkIzevyeWmNblYDSOrALpqeTZatYqvPXeUZw40c7DRxg9uWs5ZRanj/lkGYrqV+MJJL9QOkUEdF2IeqOkW/bS6/ilIMXGo0UaD6EMVzHJEgDpD0WlOirLcujYPgG6Xn/JWJ8fbHDT2eLF7gwRCEYLhCDKglkCtUqHXqjBq1WQk6MlLNlGQYmJ+mpk0i25GBFQjwRcM4/Aq4jpOnxJYxm5u/0kV2Nj+CUW9U4MRJfj0hyK4/CHs3iA2TxDXGHos1ZKEMWoTYjUoYk8JBi1JJi2pZh1pFj3pVj0ZCXoyrQaSTNpJ3f9tdh9/fr+Wx3bUx/0Zk0xaLlmcyY2rc1iYaZ0280GOiwqd/L7CEaXXNJb5lySl/FxRc5biZcPT5TMIJpdmm5f/eamcl48o5bxpFh33nFfEzWtyR5zdlGWZ96u7+ev2OvaeOOn3mWzWsigvhYVZVjKsBrRqiW53gLJmO3vqejnQaOP2h3fy2w+sZm3BxAgwxXD5QxxrdVDV4aLd4cPuCQLKb0SSUUuqRTnH5CQq/s8T3bf25N5GfvxqBaCI91y6JJOV+UmkmHSEZZkup5/yVgdHm+1UtDtptnn5zVsneGxnPR86q4Db1uWNyALp0iWZGHVqvvdiOTVdbu54eCc3rMrh/51bNKHiSZ5AKG7nMh0sZmJkxq1mRIA6HrRGBZKmS/9pjLiSb7cIUAWzGxGgziJSLXrOK9VzXmnaVA9l3AhFIrj9io1GjztAjzuAzaMou3b12uPbffaJA7gjGuxRIZmBylPHA300Q6pRSaiifU/haLAUU6GNZVbDshwPitscw7+2Tq0iK9FAdqKBvGQjBakm5qdZKEk3k27Vj1ug5QmE+MXrlfx1Rx3BsDLWJdkJ3LWpgAsXpo/banFElnH7lYUAb1BR8/WFIvF/PYEwbr+ygODwBrF7g9h9isqt0xfE6QvhjtvJjP37jH1nBk2011Wj2BGpVRKSBLKs3MKxOwDRHlmVpPTMyYGTF31fefowZrM5/rpGnaI2bdFHbwYNCQYN1j79s1PVOzsXiURkHtlWy89er8AfiqCWJD60aR4fP69oVBUAJzpc/PS1CvbWK5lTrfrk8feLW1diMltOe87mhRl0OHz87zvVHG9z8q0Xyvj3fZsw6sav8iAYjnCw0cbOmh52R5W7RyPSnZmgZ1FWAstzE1lXkMySnIRx6+Fsd/j4xRuVAFyxLIs71uf38/sFSDbpKM20cv2qXPyhMNtPdPPikRZabD5++9YJ/rm7gU9dWMx1K3OGPeedW5LGU584m9++VcXT+5t57mALzx1s4bzSND536QLWzBv/xYG6LiUwSDJpp5Wndsxqpk14oY4LcQ/UaRagxqoyRAZVMNsRAapg0vEGFJPzFpsi6NDh9NPt8tPrUYJPpy+E0x/C5QvFM3sDEekTNOyrt51WcqeSwKzTYNKrMemUICGmlGrQKAqwOo0KjUoV9c9UbkoAowg9KcGGFotBg1mnGdGFXCisZGD9IaXf1xsIK58n+pmcPiUra/ME6fEoQbfdGyQQjtDQ46Ghx8Ou2v6vadarKU63sCjLyrKcRFblJ5GTZBh10Lqrppsv/PsQTb3K6vDq/CQ+cnYh55akjvq1ZFmmw+lXfEW73DT2eGix+eh0+el1B3D6QkxUt46EolyplqS4QnFEluO2LH2JfRf2019mxPSda++f6EalG71Rul6jItGoZNCTTTpSzTpSLXrSrToyrAayEg3kJRknPZM+m9he3cWPXznOoSbl216dn8SXLl/IwqyRl/PaPAH+8G4NT+1rIiIrJfyXLc1ic3ECt/1M2Wao7ycjwcBXrljEl546RKvdx2M767n3/KIz+lyyLHO8zclLR1p59WgbvdEsaYy8ZCNLshOYl2Ii2axDJUl4g2FsngAdDj+tDh9NPR663QHaHX7aHZ28U6mI7aVadFy7IocbVuWccUnyI9tqCYZlFmVZueusgmHnsV6jZvOiDM5bkMb7J7p49kAz7Q4/333xGM8dbOGLly1gac7Q2VCrQcNXr1rM9aty+OeuRt4ob49rM5xVlMIDF5VyTsn4LdpOx/JegMxoINVuFxnU8eCkgu/0UkQuSBEZVMHcQASognHHGwzT5fTT6fTT4fTTavfR2OOhvsdDY/QiabTEFF0TjUpWymLQoJeD/Cn6909cUERKUgJWgwZrNItl1Kqn5EJfo1ahUaswj0J4NRSO0OMO0OUK0OH00e7w02Lz0tjroc3uw+1XvE4PN9l5kiYAshIMrC9MZsP8FNYWJMdX0AfD4Q3ywT/tIhyRyUzQ87WrFo/6ws3uDbKrppvt1d3sru0ZkSCHJIFBo+6TvZSUBYJoqblJdzLz2Pdfsy5qJaNVSnVjiwl9s9cDIcsyoYhSDhwIRQiEIwRDMv5QmGBYJhCOEAorHqOyLCNFg1xVn2AX+WTAG5FlPG43/xVVQv7oOQVIWiPB8MlFCF8wrGSEAyE8/v7/xrLU/lCEjugxMRQWvYb5aWaK0s2UZFjITzaRm2QgO9E4rpm42YIsy+xvsPGbN6viQZdRq+bzl5Zy4+rcUZ0D3j/RxXdfLKfLpZyj1hYk85FNBaRbDXg9I1+UMGjV3LQmj4ffrWFnTfeYA1RvIMyzB5p57mAz1Z0n3z/FrOOCBemcV5rGpuLUEV9E2z1BKtqdHG6ysbu2h5013XS7Avxlex1/2V7H2nlJ3LFhHpsXpo/p3LmjuhuAa0eQ/eyLRqXiggUZnFOcxitH2/j3vkYON9m5+9E9fPy8Ij56TuGwFQhLcxL5nxsTuf/CYh7ZVst/Drews6aHnTW7OLckjf++atGwwe5I6OuBOp3ITVLO/y3RXmvBmdHcO11LfJV512zzEgxPTKWYQDAdEAGqYEz4gmGqOlxUtDmp7XLHA6kOp39EPqkmnTqq/qonxawjyaQlMZqptEQtRYzRjKdJq0YzwMWJz+vhzdKFAJxdkobBOHMFSTRqFRkJBjISDCyhvzJfMByhze6jocdDTaebynYnNV1u2hw+/nO4lf8cbgWUldULFqZz2ZJMFmcPoO4nKeWPly3J5JvXLBlxsBMMR3ijvJ2Xj7Sxq7a7XzmhSoK8ZBPzUkxkJxnItBpINmtJMuowRzPXky0WJUkSWrXSizpeFXg+r4H50bm2eVHmqOZaKBLBF4jgDpzMotujJc29ngC9bqV8vdPlp8et+NsdabZzpPn0nG+iUUtWooHcJAO5SSYKU03RYNaC1TC3TufBcITnDjTzl+11lLUoNfRqlcTNa3K559z5pFpGvkLU7vDx89crefN4BwA5SQY+ds78fgGNJEnML1kYvz8cJelKCfCJMYjWBcMRntnfzCPbauMLejq1ikuXZnLzmlzOL00f8Jw4HIkmbdwz+Z7zigiEIrx5rJ0n9jTybmUn+xps7GuwsSw3gS9etnBAH9/B6HUHaIlmnRZnDa4uGqu86PUE4uf/WE+wRq3i2pU5nFOSxt931rOjpps/vFvD6+Xt/PeVi0bUz5ubbOSb1y7h3vOL+NvOep7e18S2E11c/ZttXLokky9fvnBUAlmnEreYmWYZ1JwkZZHCGdVOGKvlnEChsVfJUOanmJAkiSVLlgAjO/YnkgyrHr1GhT8UodUmsuWC2cvcuqIRjJlWu4/DTTaONts50uygvNVxWillX3RqFclmLSlmHalmfby3MivRQGaCYVyEOgxGE/989f0zfp3pjlatIj/FRH6KKZ7x9AXDVLQ5OdJsp7zVQW2Xm/oeD3/bUc/fdtSzdl4Sn7ywmNV9erDMOg3/d/d6luUmjOhH1uYJ8NS+Jp7c10S362TWOy/ZyMr8JFbmJbIg0zqp9g5TxZnMNY1KhcWgwmLQkDnMtoFQhHaHj6ZeJXve2OOJVyJ4AuF4YFvR5jztuTmJBkqjfsNFaWaK05X7s0152e4J8tT+Jh59vzZeqq7XqLhsSSb/79z5oypTjcgyzx1o4edvVOALRlBJcMWybG5fl49OczIA9AXD7Gp0s/6Lj1Ld6eLex49gNWhZmZfIzWvyBgyGTdEFoFgGfaS8XdHBL16vjAd781JMfPz8Iq5bkUOiaXyDDp1GxZXLs7lyeTYtNi+P727gT+/VcrTZwd2P7uGm1bl8/rIFI5pDoejvgSQx6OLX7toeHtlW089TOdGoZeP8FM5fkE5xNKhPMet44KIS1hYk87cdddR2ubn3sX18cEM+919YMqLFtaxEA1++fCEf3JDP79+u5o1j7bxR3s6bx9q5YXUu95xbNCabjniJ7zSymAEw6TRxj8wWm1cEqGdIY49ybslPNmEymSgrK5viESmoVBLzUkxUdbio7xl9q4lAMFMQAapgQNrsPnbX9bC3rod99bbT7AJAubAoTDORn2yK+2GmmnUkm3SYdFNTXjsUoXAkquKrlF66/SF8QaVEM9CnHNQffcwTUPpH3YFQXPE3dhEW61XVa1QYdep4qaopKphj0qux6jUkGJUgPc2i73fBe6YYtGolSMxPAhTho8NNdnbWKKW3+xpsfPxv+7j77ELuu+BkeeFI1C0d3iB/2VHHP3c1xC+uk01aLl6cybklaZMiGiHLMv5QRBFKiqkuh8L4g5G4km9YlolElCCjj7YRKklCpVIWSbTR0uDYfbVKipcIx2bnyecoPa0qFf36kjVRZeDxEpIZCp3m5GLEJvpbZngCITqdfrpcATqdftocPlpsXpp6vfREs1ctdl/cvgOUXt3cZCPF6RaK0xXbqNIMCwWp5nGdj5NBY4+HP75Xw7/2NMZFs1LNOj6wYR43rs4ZtWBNh8PHt14oZ3ddD6B4SN9zXhHz+gS4vmCYFw+38FpZ+2lK3j3uAG9XdHK8zcl3r1922qJbbIx9xZWGG8/P+mRx0616PnNxKXesz58Uga2cJCNfuGwhHz6rgJ+8VsFT+5p45kAzR5rt/PSWFcMG/rGAXJaVc0jCKQFSfbeb37xVRTgio1ZJWA0anF4l2/d6eTuvl7ezLCeBO88qoDBV8UY9pySNlflJPL67gbeOd/DP3Y28f6KbH9y0jEVDZGn7kpds4gc3LefjXUU89PYJ3q7o5Jn9zTyzv5lLFmfyuUtLR1X6WxsVSZpuJb6gfIexAHXAKhrBiPAFw3S5lFaM/JTp1YMKipJvVYdL9KEKZjUiQBUQkWWqO90cbLRxoKGXQ4320wJSlQSF0Yvb4nRL1F5h/JRlx0ogFMERVX61RUsmFQGiAL0eJdvk8CrCS0MJLk0G6VY985JNSm9hpuJpOxI7hZFg0mk4qyiVs4pS6Xb5+ffeJrZWdvLo9rq4/+NweINhHt/dwJ+31cX3VWGqiWtW5HBWUcqYSgpPJRSJ4PCG+n0/vZ4Adk+f786rfJ+BadZfo5aURYl46XnUQsgSVeyNKfcqJerqeKm6KbqAcabHikmnoSBVE+9B6ovLF6K+x01jjzcetDb2enD6QjT1Kv+P9WeCcjznp5goybCwOCuB5bkJLMtNnJbZ8L11PfzpvVreKG+PK2SXZFi4dW0eV6/IHnWGOCLLPH+whV+8UYknEEanVnH7+nwuX5rVbxFiZ003j+2spydaYpti1rEiN5HidDMJRi3d7gDPHWim1e7jr9vr+NTmkn7vE/MUHsmCzitH2/jhK8dw+8OoVRL3nV/EAxeVTknPcUaCgZ/dupKbVufy6ccPUNXh4s5HdvGjm1ZwdvHgPqNmvYbCVBN13R5qulysyu9fjvv7rdWEIzIlGRY+uEEJusMRmepOF4ea7BxpsnO0xcFXnznC5UuzuGODogBs0Wv4+HlFrC9M5o/v1VLf4+Ejf97DvecXcdemghEH7/PTzPzs1pWUtdj5+84Gthxrj9+uWp7Fly9fROEwQafTF4wHLsNtOxXkJhkpa3GM+JwvGJimaHmvRa+ZlplooeQrmAuIAHUO4vaHON7m5GiznYONNg422vqVXIGSVSpOt7AsJ4GlOYmUZlqm5OJVlmXs3iCNvV6ae7202X20O310Of102R1UP/xZALI+8gtU2uEvBCWIi/MYtSeFezQqVbxvMZZxM2hV6KP2JHqNInwUu4CNyIpvqqIQq2T2fKFwPCMbF82JWuQEwhE6o8JR+xp64+MpSDWxKMvK4uwEluQkkDBCo/qhSLXo+cSFxazMT+J3b5/g9T4X9oPx1vEOfvZ6RdzfLz/ZyB0b5rFmXtKoAytfMExtl5uGHg8tNi+dTj/d7gC97sBp82w41CpFTdmgVb4DbVSASqM6aQMj9RE3kqPCR+GITDjqnRoKRwhG5LgwUjgiI0ezrrG9IvcRRIpEn9+3gj0S9NHy188DI59rfdGoJBKMWpJNWlLNejIT9OQkGZkXzZaeaTbTYtCwNCfxtEyQ3RuksccTDVI9NPYogasnEKa+20N9t4c3jykZO7VKYllOAusKU1iZl8jSnIQptdHodPr5/kvlPH+wJf7Yxvkp3H12IesLk8cU8LfZfXzrhbK4dUxRmplPby4hO+lklsQTCPHnbbW8HxX8STJquWxpJiUpWr57zw1sAb79yPOkZFi4eU0uj26v5/AA/cIjEdNx+0P88JXjvHJU8VhdmZ/ED29cPqbS0/Hm7JI0Xv7MeXz6n/vZW9/Lg08c5IuXL+C2dfmDPmdhllUJUDvd/QJUbyAcv5i+cVVOPKhUqyQWZFpZkGnl0sUZvFrWTlmLg1fL2jjcbOPTm0vj+29VfjI/usnCw+/WsLe+l99vrebtig6+f8OyUfWDLs1J5Ic3Lee+7iIefqeG16L99VvKO3jgohI+cWHxoEFvLGOVataNy7l6vIn1oYoA9cyIlffmJRuRJAmPx8P69esB2LNnDybT1JZ3n1TyFSW+gtmLCFBnOd0uP8fanFS2Oalod1LZ7hpw1U2vUbEg08rCLCsLM62THpDKsky3OxC3Kmm2KQFps817WmldjEggTLC7AYAEvYYEq0FR8Y36T8Y8KC36kxYzBq06LsgxWciyjCcQpsPpp83uo8nmpbHHQ68nGA8SXitrB6Ao3cy6gmTOKkqNX2yMlU3FqXgCIf74Xi2DxadOX4gfvnIs/v5pFh23r8/nnOK0IZVyT/18dd0e9tb1cLDRRk2ne0h7GZWkZFtiasvWPllIi1753mJZSJ1aNWVZermPbY3b7eKzv1Dm2j3nFiKr9XiDEbwBxau1bzm4N6D4vvqCEbzBMOGIoioc8/Htq8YKymJQQTSbGbvlJBpHvP+HItGoJTE3kWV9xG5kWabXE6SpV5l71Z2K2FmvJ8ihJnvcogWUvtbFOQksy0lkbUESC7OsaFQTX266r76XT/59Hx1OPxJw3cocPrhxHiUZp3uPjpRXjrbx/ZfK8QUj6NQqbl2Xx5XLsvtlTSvbnfzurRN0upT3PX9BGhcsULyB/V4PzbVVyobRAyo3WTlGHd4gbn8Ic58y37IWZT/GyvBPxeEN8ql/HqC81YFKgs9cXMqnN5eMS6XCeJGVaOAfH9/IV585ytP7m/jxqxU09Xp58JLSAc+jq/KTeK2snaMtdm5akxd/3OlTbHFipb0DkWTSccf6fE50uHjmQDMtNh/feO4IHz1nPhctykCSJKwGLZ+/dAHbTnTxl+11HGt18oGHd/GVKxZyw+rcUX22wlQzP7hpOR89dz6/fKOSXbU9/PyNSl4ta+MXt60a0JootugwHbOnoGRQAVqEeM4Z0dRHIAmUc2Z5eXn8/lQTq6IRJb6C2YwIUGcRsixT2+Vmf4ON/Q29HG6yx728TiXVrKM43cKCLAuLshIoTDNNyoVnjEAoQkW7k+OtDirandR2unEHBi7BlYBks44Mq540iy6q+qvDQICvRa0/HrykFP00VfGVJAmzXsP8qH1IDKdPCVDruj3UdrnpcPqp6XRT0+nmyb1NlGZauGJpFmcVpY65//HixZksyLRy5y9Pf359t5sHHj9Is82LSlKsIW5ak4teM7KFCU8gxNvHO3nzWHtc0CVGgkFDdpKR9Oj3pdgDKWWwRt3kLxKMBUmSUEvKRbXcpxQ7J9E44rkmR7O4nkAIlz8c98DtcQeUBQuHD08gTF10HmyJZjMNWhXz08yUpJ8MWkejSjvc50oxK9/Liryk+DjbnX7KWxwcb3VQ2eGiLdrT2mL3xbOsSSYtFyxI57qVOazMS5yQxYM3j7Vz32P7CEVkitLMfOe6pWeUUfSHwvz89Uqe3t8MKL2mn7ywuJ81iyzLvFHezl921CHLSs/1LWvz+vWjDkQg2mcqSfRb0OtxByhrVZSFzy893crJ6QvyyX/s53ibkySTlkc+so61BSlj/owTiV6j5me3rqAo3cxPX6vgH7sasHmCfOOaxadlGs8rSePHVHC81Um3yx+fs7FMfDgi4w6EhxTJK8mw8OnNxTyzv5mKdhd/2lZLbZebu88pRKNSFqzOK01naU4i/7v1BEdbHHzvpWMcbrbzlSsWjvj8FaM0w8JDH1zNq2Xt/PS1CspaHFz/0DZ++4E1XLqkv6zZdFXwjRFbMBFWM2dGY+/JDOp0ZF7qyRLf6f9LKhCMDRGgzmACoQgVbU4ONtmi/aM27N7+Bu4SkJ1kYH6amcJUM/NSTcxPNZ8mYDHRyLJMY6+XQ402DjfZKW+xc6q4pUpSylMzrHrSLXrSrXrSrYrA0EAlV37vzF49tBq0LOuT3XJ4g1R2uChvcXCiw0VVu4uq9hP8a08jt6zN49ySkWc1+zKQuEl9t6KK2eUKkGHV88BFJSO2XvAFw7x8pJXnDjQTCJ8UjVqYaWFhppWidPOUloZOJyRJQqeR0Gl0JJkA+l/wxErYm20+mnqVUtxmmxdfMMKxVifHWk+q9aZZdCzKSmB5XiIr8xLHdR9LkkRWgoGsBAMXLcoAlPLTmi43NZ0uKttdHGt1YPMEef5gC88fbGFhpoWPnjOfixdnjNuCQ02ni888foBQRGbzwnS+c93SflnJ0dJq9/Hlpw5T3upAAm5cncvNa/L6HUehSIQ/b6vj7QolCF+Wk8D1q3JGVEHSFi2JT7fo+y0ivVbWhiwrGcW85P7HnyzLfPfFco63OUk2aXni3k0DZuumE5Ik8anNJeQkGfjik4d56UgrIPOd65b2W6TITjKyZl4S+xtsvHK0jQ+dVQAo4l+ZCXraHX6aer0sGubzmnQaPrhxHtuqunjjWAdvHu+gw+nnwUtK4337KWYd/33VYl442MKT+xp5/mALdV1ufnbrSlLMozs2JEniymVZrC9M5pvPl7Grtof7HtvLL25b1W+72u5Y2fb0XAyNl/j2igD1TGiMVpnlJ0/P71kpPQZPIIxhCDcFgWAmIwLUGYIsy7TZfZS3OihrcShBXqsjrhQZQ6dWUZppYXF2AguzrBSnm8dNiGcsY67tckfN0rvpiIqGxLAaNNHA2URukpEMq35albdNNglGLesKkllXkIzTF2RvfS87a3rocPr5/dZqXj7SysfPL4pbMYwVtz/EA48fpMsVID/ZyNevWTJiIYgDDb388b3auHBMmkXH2cWprMhNRD8NBXamO5IkkWRSKgKWRrOE4YhMp8tPS69XKQfv9dJu99HlCrDtRBfbTigqvYuzrZxdnMZZRSlYJ6AfzqzXsDw3Me6FGY7IlLc6eL+qi/eru6hod/FfzxyhON3MfecXsXnRmQWqMnD/P/bjDoRZnZ/ED29afkbqtQcabHzuXwdx+kOYdWoeuKj0tHJbTyDEL7dUcbTZjgRcuiSTc0tSR5wZrmpXFhCW9snwhiKRuCDVh86ad9pzHt/dyFvHO9GoJP76sQ3TPjjty42r87Dqtdz32D5eOtJGXrKJe88v6rfNR88pZH/DQd4ob+fmNXlxoacVeUm8Ud7O8TbHsAEqKP3l5y9IJ92q58m9TRxptvO9F8v5rysXx89XKknihtW5FKWb+fWbVRxqsnP3o3v4zQdWjSnLmWbR85sPrOJ/XjrGC4da+cKTh4j0Kemsm+YlvjlJSm98u9NHMByZFPXn2UjMvmo0llWTiV6jJifRSLPNS3CaiQkKBOOFCFCnMfXdbt6u6ORAg42jLXZsnuBp21gNGhZkKL2ji7KtFKWZpzzI63b52XKsg+3VXXHRHVCybEUxJeAMC+kW3ZSrAE9XrAYtmxdmcE5xGjtru3mnopO6bg9ff/YoVy3P5vb1+WMW1vnd2ydotnlJs+hGHJwGwxEe21HP6+VKr2qyScslizNZlpswI8p1ZxJq1cls5poCRWjGHwrT1OOlpsvNiQ4XLXZfPMP65/drWZWXxNklqWycnzph9jFqlRQPWD90VgGvHG3l5SNtVHe6+fLTR1iYZeWBzSVsGkLpdShsniCeaMnrj24+s+D0xcMtfPfFY4QjMgWpJr5w6QLSrf2FrXo9AX70ynEaejxoVBJ3rM8fVbAYCEU42Kj0ma7rU567r74XuzdIilnHuSX9y3urO138aovSx/q1qxfHS6xnEpcsyeS7Nyzla88e5Q/v1rAqP4kN809+/k1FqRSkmqjv9rC9uouLFytlshvnp/BGeTuHGu1cvjRrxOrLi7MTuOe8+fxlex113R6+858yvnbV4n4l7yvykvje9cv4yWvHabZ5uevPu/ndB1aPaf9qVCq+cc0SAiGZV8va+vl9x3r+pmuJb5pZsTMLhCK02X3TNsCa7jRGe1Cna4kvKP7IzTZvvIpJIJhtiAB1mhGRZbZWdPL3nfX9xEpAuUDMTzZSlG5hQaaFBZlWshMN0ybIc/lCPHugmVeOtsYVUDUqiYVZVpblJLAg0zrjvBenGp1Gxfml6azJT+blo20cabbz0pFWjjTbefCS0lELKVV1uHhybxMA911QPKLg1OUP8bPXKjjepmSLNhWlcMniTPFdTiJ6jZri6MLOpUsysXkCHI1WUrTafRxotHGg0cZfttdxfmk6Fy/OOK20dDyxGDTcui6fK5dn8/KRVl4+0kpFm5NPP36Ac0pS+fylC0Z9Ed/j9pMFPLC5hLQz6Lf92446fv3mCUAJij5xQfFp5bqdTh/ff+kYHU4/Fr2GD581b9TH0oGGXrzBMBlWPauimdmILPOfQ4rqcF+1WlAWeb734jHCssylSzK5++zCMX/GqebOjQWUtzj4x64GfvjKcR7/+Mb4PpYkiZvX5PKLN6p46UgrFyxMR6NSsSQ7gfxkI429XnbWdLN5YcaI3y83ycgnzi/i0e31tNp9fPfFcr5xzZJ+8yQnych3rlvGT187TnWnm/se288vb1/JWUWjXzBRSRJfv2YxuclGvh/t33f4gnRHK0emawZVpZLISTRQ1+2h2eYVAeoYiOkEwPTNoILiALCjpltkUAWzljkXoEqSdC+wNvrfIuDfsiw/PIVDilPT6eJrzx2lst0FKMIbK/ISWZmXxIJMK/PGwY5iothV083vt1bHS44LUk1sKExhUdYEBqWSRFpWbvz+bMZi0HDbujxW5iXy1P4mGno8fOXpwzx4yQLWFiQP/wJR/rq9DoCzilLipZtDYfcG+d6L5TT1etGqlSzTghH2qs4qptlcSzIp2blzS9LodPo50mznQIMNmzfIK0fbeOVoG0uyE7h1XR6LsyfOssSi13DbunyuWJbFcweaea2snfdPdLOrZiefvqiEOzfOG3GGPRJRApHrVuWMaSyyLPO/W6t55P06AK5Zkc0HNpz+/u0OH997sZxud4Bkk5a7zy4cWc9inzkQlmFb1IbmquXZ8Z7WXTU9VHe60WtU3La+vx3LI9tqOdJsx2rQ8K1rl0ybhcWx8uUrFvFGeTsNPR7++F4tD1x00gf2+lW5PPp+Ha1Rga3Ll2YhSRLXr8rld2+fYEd1D2cXpY6qLSDVoueecwt5dHs9HU4/33uxnG9es6RfJjXRqOXrVy/hV1sqOdRk57NPHOQnt6zgggXpo/58Rq2a+y8s5vvR/8fKe9Ot+iFFnqaanCQjdd0eIZQ0RmLlvckmbfx7liSJgoKC+P3pQEwoSQSogtnK9Ix2JghJkn4M7JVl+T5Zlu8DbgV+LEnSH6Z4aGyv7uJDj+ymst2FQavihlU5/P7ONfz3lYu5ank2JRmWaRmcytGMwS+3VOEPRciw6rlrUwH/75xCVuQlTuiY9QYjv3hmG794Zht6w/QtxRlPFmZZ+cxFJRSmmgiGZX72WgXbq7tG9NxIVKkU4NoVwwcB/lCYn7x6nKZeL1a9hnvPL5qbwSnTe66lW/VctCiDz11ayofPmseiLCsSUN7q4Dv/Kefnr1fQap/Yi9UEg5a7NhXy01tWsDIvkVBE5ldbqvjSU4fxBEbmfZto1PCRTQVjKhk/NTj9wPp87tx4+mvFvFW73QHSLDruOXf+iAV1+s6BAy0ebJ4gCUZtPBMoyzIvHlayp3dtKuiX3XP6gvxjl2JT9IMbl09odnuySDRq+f4NywB4fHdD3EoGlIWL+y4oBpRy61iZ7KaiVHISDXiDYd6O9umOhiSTjo+doywodDj9/OCVY6cJAxq0ar542UI2zk8hFJH58lOHR3yOHIq4r+00Le+NERP2ERYkYyO2ENFXwdtkMlFXV0ddXd2Ue6DGKEhR5qEIUAWzlekX8Uws9wLrYv+RZdkGPBx9fMo40NDLg/86hD8UYUl2Ar++YzV3bJhH8gxQQn3uYEv8wuus+Sncf2ExpRmWabPKOBuxGpSsz6r8RGTgt2+e4EBD77DP8wTChCIy2YkGitKHv8h6ZFttPBv00XMKyUowDPscwdShkiTFUmjjPL5w2QLWFSQjAXvqevnCk4d4+UjrhHv45SQZ+a8rF3HPufPRqCS2VnRy32P7TwsiBiLVoufmtXnDbjcQf9pWGw9OP7KpkOtWne6JafcG+Z+Xy+lyBUg1K4HOWNTMnb4gbx5XFH/v6NMLfrTFQU2XG61a4vZ1/bOnT+5twhMIszDTyjUrskf9ntOVS5dkUpphwR+K8EZ5R7+/XbsimySTli5XgF21SrZZpZK4M6rsu726m3bH6P06E41aPnp2AYlGLS02Hz965RjeUyzKNGoVD1xUGg9SP//kIfbXD3+OHIq6rmj/6TRV8I0xP3pujwXUgtFxokOpYCs+A8/lyeCcklRefODcuPetQDDbmGsBag+QdMpj3QCSJBWdtvUkYPME+OqzRwlHZDYUpvDVqxeNWFF1qjnW6uDJPY0AXL40k6tXZI/Zr1MwOtQqiRtX57I6PwkZ+PWWKmyewJDP8QaVi7i1BcnDLiAcbLTxbmUXEnDnxnmkW8fHg1MwOSQatVy/KodPbS6mJMNCRIa/7ajnR68eH3aenCmSJHHJkky+ee0SLHoN5a0OPvXP/f0ybOPJv/Y08n/v1ADw4bMKuGJZ1mnbeANhfvzqcdodfpJNWj52TuGYlY9fK2snGJYpybDES0cjEZnHdtQBcNOaPJL7ZGV73QH+Gv3bJy8snlWLd5IkcUt0UeG5g839/mbQqrkjWub8+O4G/CHl/LNmnqJULsvwn0NjWzRJMum4++wCDFoVdd0efvVmJaFTMklqlcSnLyphzbxkgmGZzzxxMK66PBZqupTApegMVdQnmpjXdmy8gtFRFQ1QSzOmd7VQkknHstxEIVIomLXMqQBVluViWZZ/csrD66N/q5mCIfGnbbV0OP3kJBq4f3MxGtXM+EpkWebP22qRgZV5iaepVU4GAb+Pb33ser71sesJ+Ee/Ej/TUUkS163MJjNBjy8UiYsfDYY/GqAOZ/EQkWX+Fr2gPqsoJX7BM5eZqXMtM8HAXWfN4+rlWahVEoca7Xz9uaM09Ex8+d+CTCvfigapx1qdfOmpw+NejvZ6WRs/ea0CgJvX5HLV8tOzk5GIzG/fqqK2S6kGuGtTwZgypwG/j6/cdQ2v/s/HiAT93H12YfzicFdtD429Xkw6NfedYrvyn8MtuP1hluYkcN3KsfXXTmduWZuHVi1R1uKg8pQA8ENnFZCVYKDLFeDNYyczrB85uxCNSqK+x8Pu2p4xvW+aRc9HNhWgUUkcbrLz6Pa604JdjUrFZy8uZWGmFW8wzANPHKTVPrbjt7ozGqBO8/NhcSyD2ume8IqJ2Ugsg1rSJ4Pq9XpZv34969evx+sVvb0CwWQwM6KhCUKSpCTgFuAro3xe2UA3oHg0r+P0BXlmv7Lq/JFzCkdkDD9daOjx0NjrRS3B1QNcFE4GciRC7fHD1B4/jByZm30YGrUqftG7taIj7k86EDE5+oJheqgONtposfnQqiUuWjRypc3ZzEyea5IkcVZRKvdfWEyqWUeXK8BXnznC0Wb78E8+Q/JTTHz96sXoNSr21PXyy6jFyniwt66HbzxfBsBlSzK5ec3A5cGP7aznQKMNtUri7rMLxqwQ7PEHaT1RRqCtiosXpcf9iGVZ5oVDynn8QxvnnVYBs7dOKS29aU1eXExpNpFq0XPpEsVK5pWjbf3+ZtSq+X/nzgfgpSOt8SxnmkXPBzcqHrGvlLXTeYpH9kjJSzbFs7RvHe/g5SNtp22j06j44uULyUs20un085nHD4wpm1/doZTMTvfSz3kpZtQqCXcgfJr3uGBoIhE5nnnuG6BGIhH27t3L3r17icyw879AMFOZ0wEq8G/gqQGyqpPCnrpe/KEIOYkGVoxAUXU6EetvmZdqjhuxC6aGeSkmClJMRGSGFgORQauWSLUM3dv8/gnlNdYXpsyoRRPB0GRY9dx7/nzmp5kJRWR+8loFHWPoARwthWnmuMLrv/Y08m7V6MVxTqWm08WD/zpEKNoa8ZFNhQOWzr5T2cGrZUrQcsua3DGLE8l97GMAblt3MhjeXt1NXbcHvUbF7aco90ZkmYNNNkCxvJmtXLxICVDLBlj0uHpFFmkWHT3uQL8A9vKlWSzPTSQckXlyb9OYs+sLs6xcuUx5/3/squdwdH/3xaLX8F9XLCLZpKWmy81Xnj4yqvcLRWS8wTAaldRPPGc6otOoyI/6d8ayvoKR0Wzz4gtG0KlP7kOBQDA1zMgAVZKkSyRJ2jfC25cHeY0fAzZZlm8d7fvLsrx0oBtQPZrXiQV5xTNQVEivUQKXU/t+BFPD0hzFSuRQ4+BZsdxkI7++Y/WQPSuyLHMk6r+7eJhSYMHMw6TTcNdZ88hLMhIIRfjd2ycm5X3XFabEKy1+8PLx00RtRkOXy89nnziINxhmQaaFT20uGTAzWd3p4o/vKp0bmxems+wMFgF31/VyvO3kxX7s/KcEV0of/v87dz5Jpwjb1XW5cfvDGLXqYUvrZzKlmUq2qW4A5Vi9Rs2nNisLFM8caMLlU1SdVZLEJy4oRq9R0ebw8VpZ+5jff1NRKmvmKf34v3ijkk7n6QsvqRY9X7p8EXqNil21Pfzk1YoRv36gj31aX2/b6Uq8D7VTCCWNhlh57/w0M5oZ8D0LBLOZGXkEyrK8RZbltSO8nZYdlSTpFqAoFpxGS30nHYNW2f1u/8hsGKYTBVEPrsZeL90uUUY01cQMxYfqLZQkhrXUcPlDOKIXkLliBXlWolGruH19HpIEle2uSfNLvH19PhlWPZ1OP//YVT+m1/AEQjz4r4O02H1kJRj4wmULB7SycvqC/GpLJWFZ6bm+cOHofTBjtDl8vHKkdcC/ba/uosPpJ8mk5YMb5p3295jgyuJs66y+4I21DXS7AwMuPlyzIpsFmRZ8wQivlJ3clylmHQ9esgBQ+njLWx1jen9JkrhmRTY5iQb8oQi/3FIVDyr7Mj/NzGcuKkUCnjnQHF9cGI7YaxVPc4GkGDEhJ6HkOzoG6j8VCARTw+z9xRwESZLWAJeekjm9dyqC1NX5yQAcabbPOFPtnCQjq+clAfD8oRZCoi9jSomV7dq9wbha5liweZTeLKNWPSMyBYKxkWTSxUsVj40xKBgtOo0q3i/46PY6XKNcmAtHZL7+XBnHWp1Y9Bq+csUiEgZQ4o3IMr/fWk2XK0CKWcfNa3LHrHTpC4b5155GwjKsyOufgQ2GIzy9XxEm+9DGggFbHWKeitNdEfRMSTRqsRo0ALQM4LmrkiQ+do7Si/rykdZ+tkOr8pPi1jtP72se84KnVq3iAxvy0WtU1Ha5B10EWVOQHJ+HP32tgn0jsJ8JRCuFpruCb4yYjViNKPEdFTPFYkYgmAvMqSvQqJXMv4F9kiTdG719Gbg96ok6qSzOtrK2QJHA/9WWqgmzYZgoPrhhHlq1RG2Xh+cOnDRjF0w++j5ZpIEyByNFo1Yu5CNC/XHWE1P4NE5in/FZxankJhmVTNrR0wVthuK3b53gncpONCqJL12+kKzEgX15nzvQzMGoKNId6/PH3EcdkWWePdAcD3Q/fm5/dd43yttpd/hJs+j69aT2pSWqGDsvdXr3LY4HMT/GwbxNL16cwcIsK75ghKf29Vccv31dPqUZFgLhCI/vaRzzIluSScft0e/i9fJ29tQNrBB87coczilJIyLDF548NKyybzCeQZ3eCr4xitKUAKtGZFBHxYlOkUEVCKYLcypABfYBRcAf+tx+PFWDkSSJ71+/lFSLjoYeD9/5T/mEexSOJ/kpJj5/6QIk4FCTnT+/X4fDO7lBtjUpBWvS7BUfGSl9FwfOpJ85lpHyhyIzsvR8IplNc62hx0NDj5LpmsxSbpUkxcttt1Z0DLP1SV452sZjO5WM2CcuKGZB5sAZyRMdznjwc/3KHLIHCWJHwtaKTspbnagk+NwlpViNGpKSU0lKTsUTCMV9Pz9xQTFmvWbA14hVxuTNgXL5WIDaahs42FNJEp+/pBSAtys6+in3atQqHrxkAYlGLe0OP0/tax7zIllpppVzSlIBxcYt1vPaF0mS+Ph58ylMNeH0h/ivZ4a2QIplUGdKZi2WQW3s8ZxRRc1cIhKR4zZJpQN8z2lpaaSlTb6dnkAwV5lTAaosy8myLEsD3NZO1ZgyEgz8351rSLfqaer18pNXK84oAzbZrJ6XzBcvX4hWLdHQ4+GhrdXsq++dlAyc3mjioZf38dDL+9AbZ3+GYihiJXN6jQrzGagqm/WaeOnnCVEeFmc2zbXGHk/cM/fckrRhbYfGmzXzlNaGvXW9+ILDXzwfa3Xw7RcUO5nropmvgfAFw/z6zSpkYHluYrwFYSwcabbzdoWiNnzPuUWUZFgxmsy8vKeCl/dUsKXKgdMXoiDVxLUrB7fZao4HqDN7zoyEWB988wAlvjHWFaawoTCFcETmqX39+z9TzDo+f+kC1BIcb3PyytG2Mft4XrIog3SLHoc3yF+21w64jV6j5nOXLMCkU3O02cEv36gc9PVCUYuu4rSZEaBmWPVYDRoiMlS1i/P4SKjpcuH0hTBoVadlUM1mM52dnXR2dmI2z4wsukAw05lTAep0pSjdwh8/vBaLXkNNl5tH3x/4B3W6srYgmZ/espKCVBOeQJjnDrbwh3dqqGx3ilLRSaKp92Sm5kwVodcWKAHEzuoeYfQ+i3B4g7x0uJWH36vF7g2SlWDg7nMKJ30cOUkGkoxaQhGZY63OIbd1eIN85ekjhCIyq/OTuH1d/qDbPrm3kS5XgCSTluuGCBqHo77bzdPRLOxVy7PZfIoXcKfTx4uHFcuZT28uQaMa+GfUFwzT4VCyhAVzoMQ39hnrB1Dy7cunNit24e9WdXGio//3vyDTGlf83VnTw3tVQ9hmDYFGreKmNTlIwPvV3RxstA24XUaCgU9dGLVA2tvEa2WDl52nWfQkmk7veZ6OSJLEyrwkAA43Tbzf8Wxgf4MNgBV5SUJ/QSCYBoijcJqQn2LiJzcvRwLeruhkV033VA9pVGQlGvifG5fx4bMK0KolWuw+HtvZwG/ePMF7VV0zqnR5JlLWogjdLM0Z3EojEpFpHSK7EeOKZVmoVRJNNi+HB/A1FMwcQuEIZS0O/r6rgZ+9XsnOWqUn77zSNL5/wzIsg5SmTiSSJMUzFEMJNMmyzPdeKqfZ5iXdouf+Cwe2kwHFUibW03rdiuwx9522OXz8bUcDYRnWFyZz5wDKvI/vbiQUkVlfmMzmIdSB2x0+ZMCkU5M6jHr2bCAmBDWctcmy3ESujYoi/WV7HZFTtAs2FafxoY0FALxxrIPdtQP3kQ5HXrKJs4qUkvy/7agbVMhvTUEyN6zKAeC7L5bT3Hv6OTLJpOWmNbljGsdUsTJf+S04NEhwLujPgQZFLOtMKi8EAsH4IQLUacTGolTuPrsQgD+/X9dP6XAmoFGpuHpFNg99cA1XLc9Cq5bodgd4vbydn79RxcPv1vBeVRdd42RLE/D7+MGn7uAHn7qDgH9okYvZTLvDx/E2JRNxwYLBL5hbbD6+8tSRYbOiiUYtN65WLsZeONgibISYWXPNFwxT1uLg2QPN/Pi1Cp7Y00hFmxMZWJhl5atXLeJTm0uwGCY/OI0RKwet6x48mPnPoVbeOt6JWiXx4CWlg443Iss8sk2pOlmRl0jpIP2pw9HjDvC3HfUEwhEWRjN5fQNiv8/L3bdczbPf/zhyyM/nLlkwZLVCW1R4JyfpzKsaZgKLs5X93tDjGVah+VObSzBoVVR3unnz+On+p1evyOb6aND4n8Ot7G8YXml3IC5elIFJp6bV7uP1IXxWb1mbz8JMRcDpv589clowm27V89WrFo9pDFNFLIN6qMk2peOYKRyIZlBjLQh98Xq9XHjhhVx44YV4vTPLcUEgmKlM3RWKYEDuPb+Id6s6qe508/PXK/j61UsG9PmbziQYtdy1qZDb1uXz/okutp3o4lirk8ZeL429Xl4vbyfDqmdpTgLLchPJsOrH9D5yJMLxA7vi9+ciEVnmhUOKr+CGwpRhBW8C4QhOf2hAe46+3LA6h0NNNqraXfxlRz3/75xCkkyzPws0GNN5rjm8weix5aG+20Nzr5e+SxDJJi3nlaZzwYL0aeNtm5mgHPPNg9hrtdp9/Pi14wDctjZvSHuPXTXd1Ha50aklrlyaNabx2L1BHn2/DqcvRH6ykS9evhC9pn8WNhgKU3lQmQM3rcphYdbQgXCs7D5/muzziSbVoic3yUizzcvxVgfrCgcXFEu36nngohJ++lol/9jVwNqClNM8mm9fl483EOb18naePdCChDTq7JZeq+bSxRk8f6iV5w42c9GijAGz62qVxKcvKuErTx+mrMXBk3ubBvS1nUmsyk8CoLLdidsfGlTIS6D4JldEBZJWR/dbXyKRCO+88078vkAgmHjEGWuaodOo+MktK/jwI7upbHfxyy2VPHhJ6WkXSzMBg1bNxYszuXhxJj3uAHvrethT18vRFjsdTj8dFZ28XdFJVoKBVfmJrMhLxDpM4CQ4SUSW+c+hVhp6PGhUEh/eVDDk9uqohUyHwz9sgKpRqfjCpQv49n/KabP7+ON7tdyxPj+e+RJMPhFZptcdoN3pp83uo9Xuo7nXi3OAbFVWooE185JYW5DM4qyEQUtjp4oEozL/Yr67p/LjV4/jC0ZYkGnhmhU5g75OJCKfFHwqTRtTVtjmCfDo9nps0b7cr161eMDS5y3HTmbgPn7e/GFftzaaHS6eId6Z48HCLCvNNi913Z4hA1SAW9fm8+rRdo402/nz+7V84dL+GWlJkrj77EJkFEufZw40E4pEWD/M657K6nnJvFvVRa8nyNaKTq5YNvAiRppFzwc2zOORbbU89PYJLluSSZplbIun04GMBAPZiQZa7T6ONtvZWJQ61UOathxusiPLihJ1RsLYlb8FAsH4IQLUaUhhqplf3raSTz9+gAMNNn748nG+fMVCTLqZ+3WlmHVctjSLy5Zm4fKH2F/fy86abg402mhz+Hi1zMdrZe0syLSwal4SizKtaIRQwaAEQhGeO9jMkWalh+9Tm0tIHyYTrY0GqE29nhH5vCWZdHzj6sX8z8vHaLEpQep5pWlcsCB9xmX1ZwoRWcbuDdLjDvS7dbmUf0MDeA1LKD6bpRkWFmRaWZKTMO0vrGMiJANZexxpsvNeVRcqCe49v3jI4HpffS9tDh8mnZqzi0d/Ad7rDvDn7XXYPEEyrHq+fvXiASsF2h2+ft6dlhEspMXUUwezxJmNzE9TFE7rhyjdjqFWSXztqkXc+chu9tX38tbxDi5enNlvm1iQKqH4mr5wqJVgOMLZxSO3+1CrJM4uTuWlI21srejg8qWZg5ZcX7Qwg60VHVR3uvnje7X895WLRvw+05GVeUm02ts41GQTAeoQ7K9XSsjXFJxe3isQCKaGmRvxzHLWFabwv3eu5dOP7+d4m5Pv/Kec/75y0awos7ToNZy/IJ3zF6Tj9AXZWdPDu5WdVHW4qGhXbgatiqU5CazITaQg1Yx6mmWAppKGHg/P7G+m2x1AkuCBi0rYNIKLc300KKgbRmWzL6kWPd+/YRl/fLeWHTXdvFvVxd76XjbOT2H1vCSSZ8F8nAoiskyPO0C7w0+7w0e7w0+n00+PJ9DP0/ZUtGqJ3CQjBalmClJNFKdbKEwzzbgKi5i690CBwh+31QBwfml63FtzMN6OeqmuLUge9T5od/j46/Z6nP4QWQkGvn71YlIHCOwjsszD79YQDI9c0VqWT3oqLslJGNW4ZjKxbPFIzzGlmVYeuKiEX22p4m876lmcnUDOKd+5Khqk6jQqXjzcyitH23H5w1y6OGPEvb0r8hJ5tayd+h4P9T0eCgexVlKpJD64sYDvvVjOM/ubuOfc4TPl05mV+Um8WtY2qIqxQCF2HllfKAJUgWC6IALUaczqeUn86a51fPaJg9R3e/juf8r52iAXUTMVq0HLpUsyuXRJJs02L+9WdvJeVRc97gD76m3sq7dh1qlZlG1lUVYC82fgxfh4YfMEeLuiMy6Hn2zS8umLSoZU7u2LPtp7Vd4yuHLqQJh0Gj57SSmbalP5+856Opx+3o6WZ+cmGShKs5CXYiQn0UCiUTsnBGGGIiLLePxh7L4gTl8Ipy+IwxfC5Qth9wbp9QTo9QQHDUQ1KokMq56MBAOZCXqyEg1kJRjISTKSbtFPu3LdseCICsAln2Lb0dTrYfsJRcH8ulWDl/aCUkUQU69ekTeyYyBGbZebv+9qIBCKkJ9s5L+uXHxaD2SMN491UN7qQDeKio7GXi8OXwidRjVsr+psojRTCVCHU/Lty50b57H9RDe763r4zVtVfO/6ZafZfEiSxAc3zMOi1/DEnsaoMnyQG1fnjMgSxKTTUJxuprLdRXmLY9AAFWBJdgKlGRaqOly8fKR1xJ9jOhKzDHv/RDfBcETYpwxAi83L/gYbkgSXj7GHXSAQjD8iQJ3mLM5O4JGPrOO+v++jxe7jm8+X8d9XLZqVxu+5SUY+sGEet6/L51ibg/dPdLO7tgeXPxQPVlUSzEsxUZhqJss0Nzw62x0+dtR0c6DBRiymuXBhOh/aWDCqnjujVk0IJQPb4fSRYR1dr82G+SmsLUhmV003bx7voKzFQbPNR7PtpKqtTq0i3aojzaInzaIn3aon1awj2aydNQsLXS4/AbeMwxfE5Qvh8IVweJUg1OEL4vSGCI/AP1anVpGXYmReson8FBO5yUZykgykmWdHEDoU7VF/0MxT+r22HOtARrEiyU4cOnvaYvcSCEcwatVkjkJo7UCDjecONhORoTTDwpcvXzTocdTc6+WxnXUAfOLCIr70s5G9R8zaY3lu4pwKCkqjrQNtDt+IhXlUksR3r1/KLf+3g/puD0/sbuDDmwpP206SJK5flUuCQcsft9VwpNmOzRPgtnV5I6osyk0yUtnuoql3+OzuhQszqOo4aV00U1lbkEyqWUe3O8CO6m7OH0Llfa7yavQ7XleQfNr5SCAQTB0iQJ0B5KeYeOSudXzq8QPUd3v45vNl3Ht+EWfN0p4SlUpiaU4iS3MS+di5hRxrcbKvvpd9Db10Ov3UdXuo6/YQCfiQtMqF6eN7GslLTyIrwUCGVU+KRYdGNXMvDB3eIOWtDg412eNqoABLcxK4bV3+mLIyapXEyoJk9tb3sq2qi5vW5I3pNc4uSePskjR6PQGONNk51uqgtstNY48SMJwatMYwaFSY9BoMGhUatQqNSkKlklCrJDQqCa1aQq9RY9CqMOnUmHUaLAYNFr1yM+rUqMY5OxuOyPhDYbyBMJ5AGJc/dPLmC+H0h3D7Q9gcrvhc+/3WGlS6oS9kJBTvxGSTTrmZtSSZdKSYdaRb9GQmKgH8eH+emUJNp9Kfeeo83lGtZE/XjaAXLJaFTTBqRpS1D0UivHykjT11Sr/Zxvkp3H9hyaD91P5QmN++VUUwLLNxfgq3rM3jW6aRLQweiAao6+ZYyWCSSUeGVU+H009Nl5vluSPLbKdblVaCB/91kJePtrE0N3FAuw+AzYsyyEjQ85NXj9PY6+V3b1dz69q8Yc+Jse85EBpehXVDYQqPbKuhqsPFTF4GVaskLluaxeO7G3jlaJsIUAcgliW/cln2kNuZRnjsCwSC8UEEqDOE7CQjf/7IOj7/5CEONdn51ZYqzi7u4cObCmZ1H6BGpWJ5XiLL8xL5yNkFtNp9lLc6ON7qpLrTherzTwNQ3Ruiurcr/jyVpFwsJZu0JBq1WGOBjkFDguHkY9MlQIjIMi02Hyc6XFS2K5Y8MSSU7OWVy7NYlHVm/WzXrcxhb30vrxxt46rl2QNaLoyUZJMu3ksMSgDQbvfTbPPSbPPSGv1XyaaE8YUi+EKBMxq/XqNCp1ahUUuoJOUmSSg3JGVnAcjKPpWj/yq36P2ITCgiEwrLI8p0KqiZF51rRq2aJJOWJJOWFLMSgPb9N9WiI8mkndELJBNJMByhvFUpzV0V9WqMcaxNeXzRCBZgYnPX5Q8hy/KQQWqzzcuzB5rjmdub1+Ry05q8QY9/WZb547s11Pd4sOo1fOe6pVgtehrae4YdF8DRZjsA6wpGpzg7G1iYZaXD6ae6wzXiABXgvNI07lifzxN7GvndWyf44U3LB81oLc1J5Ce3rOTXb1bFy7VX5Sdy+ZKsQbPhLdFFs5G0yFgMGorSLZzocDHiU8Q05cplSoD6Rnkb379hmdBz6EOb3cfeqEDSlcsHL+81m8243SMvWxcIBGeOCFBnEEkmHX/48Fr++F4tj75fy/bqbvbU9XDlsmyuWZk9rHXITEeSJHKSjOQkGbkkqvboCYSo7/ZEb24ae7009XrwBSNxBdTBUKskkk3aaDmqktlKtyq3MwncRoI/FKbV7qOpx0tdjzJ2X7D/yn5ppoVNRamcXZw6buJYly/L5I/v1dDY6+Xp/U3cuXFoa5rRoFGpyE02Dui16QmE6HUHcflDeAIhgmGZYDhCOBosBkIRguEInkAYTyCEM9qvafcGsXmU5wH4QxH8I8iAjBa9RoXVoCHRqCxeJJmUIDPRqCXJqCXRFH3MqJ3wuTHbOdBgwxeMkG7Vsyj7ZCAaDMv4/OG4ENRwFKaaUUng9oc50uwYsA/V5QvxdkUHe+p6kQGDVsVnLipl9SDZuRjPH2rh/epuVBL8/LaVwypk98UXDMdFgpbOIYGkGAsyrbxX1UVVh2vUz33wklLKWx0cbrLz09cq+M51SwctE85MMPDta5fyxB4lO3iw0c7RZgfnlaaxtiCZxKiVkSzLHG62U9aiLBqsHaFSa0GKKRqgzuwIdVNxKolGLV2uALtre0YkqARPL20AANBzSURBVDdX+L93qgElYz5cS4FAIJhcRIA6w9CqVdx/YTEXLEjjp69VcqTZzguHWnitrI1Ll2RyxbKsaW8xMZ6YdBoWZyewOPvkhaAsy/R6grTZfXS6/PS4A/S6A9g8QXq9yv0et6KW2uVSLDxOJcGgIdWi75eBNek0mHRqjDo1Rq0aXTSbd+qKdERWAi5vMIzbr5SNOqLiON2uAB1OP90DBM5GrZpluQmsyk9i9bzkQUVbzgSNSsXnLl3A5588xIuHWynNsLJh/sRneZR9N/bTTSgSwe0P4/aH8EeD2XBEjmdJZaLKsDLxLKqSYVX+1aiUbKtadfKm16iUkmKdSmQ7Jwm3P8S/9zYCcPXy7H4ZzHBEWXhIMetGZDGl06i4ZkUOLxxq4ZkDzdg8AUoyLKgkiXaHj+PtTspbHPG+7U1Fqdx9TuGwC3nvn+jiX3uUMX7p8oUjDmhilLc4CEdkMqx6shPnXk/bkui5+Hibc9TP1apV/Pim5Xzk0T0027z84o1KvnLFokHLsHUaFXdtKuSsolT+sr2O2i53XMAt3aqcv22eIB1OJXO+Mi8x3ic7HBNx/p0KtGoVVyzN4l97G/njezUiQI3S0O3hH7vqAWVhRCAQTC9EgDpDWZqTyKN3r+Pdqi7+8G4NFW1OXjzcyktHWlk7L5lLlmSyIjdxVout+P0+vnr/3QD84Pd/Qa9XLgYlSSLFrBvyAiMckel2+Wlz+Gi1+2ju9dJi99LU48UWF7wJUTuCcagk4kFqRGZIm5C+JJu0lGZYKc20sDg7gflp42+nI8syO2q6+z12wYJ0bliVw3MHW/jllko+tLGAK5dlTeu5olGpSDSq4lmRyWawuSYYOZXtTv74rpK9txo0fGjjvH5/j8igglFlqG9fl099t5tDTXbeONbBG8c6TtumNMPCHRvmxQOnodhb18Pvt54AFHXZ29blx//m8/m4+847APjLP57AYBh4Dmw7obQabJifMicVrWOZ7GOtDkKRyKgXfzISDPzq9lV89C97KG918MstlXz+0gVDik0tyLTy/RuWsbOmmy3H2jnW6qTTqVg3gdICcPOaPK5flTPi7yS2SDKz86cKn7iwmKf3N/HW8Q62V3eNykd2NiLLMj957TjBsMx5pYqmwlD4fD5uvvlmAJ5++ulBj32BQDB+iAB1BiNJEhcsSOf80jTeO9HFP3c1sKeul731ys1q0LAyL4lV85JYkZtIwhRd3E8UkXCY7Vu3xO+PBrVKIiPBQEaCgRWnaAW5/CFabV5a7T66XH66XQElaPXGSlSVrGgsEI3IEBnAI1GrlrAatHGxnAyrnswEAzlJBualmCbF03ZXbQ+/efMEoVPG999XKQb0zx1s4bGd9bxd0cEVy7I4qygVywiUN+caZzLX5iKBUITaLjc1XS6qO9xUtjvjWaw0i47ffmA1yacsIMXWR9zRcu6RoFJJfP7Shbxb1cmO6m6abV4ispK9XJiVwLklacxPG9xSpC87a7p56O0TRGS4alnWaVmVcDjMltdfjd8fiGA4wqtliiro1cuHFl2ZrRSnWzDr1LgDYWq7PCPOWPZlYZaV39yxik8/foCDjTZ+8upxHrxkwZCqwCpJ4uziNM4uVgTc6rs9dLn8JBq0zE83j7qyyOlTRLhmwxLD/DQzd26cx1931PODl4/x7P3nzCl16VP5v3dqePFwK5IEX7li0bDbh8NhXn755fh9gUAw8Ygr0VmAJEmcX5rO+aXp1HS6eHp/M68cbcPuDbLtRBfbTnQhAQWpJhZnJ1CSYSEv2UiaRY9Jp56Tq/xDYdFrKM20Upo5tFBLMBzBFwwTCCnlpjJK4KtVqzBq1WjV0pTu206nn4ffrQFOXvzH0KhUfP3qxSzMsvLbt07Q1OvlT+/V8udttZRmWFmcrXz+4nTzpATSgpmLLMt0uvzUdXmoandyvN1JTaf7tEoCjUri6hXZ3Hd+0YDiN1qNiiDQ5Qpg8wRGPO90GhWXLM6M96WPZfwvHWnln7sakIFLFmfwreuWjElA7bWyNtodflLNOjYvyhjTeGY6KpXEmoJk3qvqYltV15gCVIB1hSn85o7VPPivgxxtcfDN54/yuUsXjMhiLaaefSbE/KJny+/jZy4u5Zn9zRxtdvCZxw/wmw+snnNBaigc4X+3VvPzNyoB+NpVi1k2CiEvgUAweYgAdZZRlG7hS5cv5MFLSjncZGfbiS52VHdT1eGK27P0RauWsOg16LVq9BoVWrUKrVpCo1Kh06jQa1QYtErPpUkftf6IWn4YtWr0WqUPU69Rtjfq1OjUqlnzoz4Uyr6anj/wFW1OfvlGJZ5AmKU5CbQOUL4rSRK3rcvnymVZPHugmZeOtHGiw0VFu5OK9pP9YylmHcXpZuanmSlMMzMvxUSqWTcnvuO5jCwrKseBqDCVJxDGERWu6nT6abP7aLJ5aerx4A6cnlVIMetYlqP0hy/LTWR5biLWIXx71ZJEUZaVijYn71R2cv2q3In8eIBiVfPH92riSp63rcvji5ctHFOpvT8U5pFtdQB87Nz5c1pM66rl2bxX1cWzB5r54Mb8MXsgb5ifwqN3r+dz/zpIi93HV589wm3r8rliWdaE9o1Xtjup6XIjcfri3kwl1aLnNx9czX1/28crR9v40J928a1rl7JkDgh5RSIybx3v4NdvVnEkqrD9yQuLuee8oikemUAgGAwRoM5StGoVawuSWVuQzGcvLqXL5Wd/fS/7GmxUtTup6/Zg9wYJhhVBIQiO43v3L21NjiqgJhgVi5eYv6VZr8aq12LQzo2AdqIJhiMcb3Xy5vF2dtX0IAPF6WZ+fPMK1n5p8OdZDVru2lTIXZsKae71sruuh8NNNo42K/6mMTXkmH8kKGqomQkG0qJCUlaD9qRwlObk4kZMSErXxx5Gq1bFBYskibglTEQmrpipUkmoJWVbrUa5P95zJBaAxa1oIkr/cDCiiDCFokrDobDcz2Kgqt2FwaQI+kRkWVEiDstRheEw/lAkHtTF1IlDEWW7vrdgWPmbPxQhEH2fUHTbuHCopPRlqlSScrEc/VeGfhY6p752X70oleqkWFTs+URfIxIZ2IIn/joj3JcalURxupnF2QmsnpfEqvwkcpOMo/7O7lifz3f+U84z+5tZX5hCzgjUfMdCOCLzdkUHT+xuwB0Io1ZJfO6SUu5Ynz/mefaHd2po6PGQYdXz4U3jp449E7l2ZQ6/2lJJs83LI+/Vcv/mkjG/1sIsK3+/ZyPffL6MHTXd/GNXA+9VdfHRswtZNIK+4tHi8Ab5362Kuus1K7J5eNzfYerYvDCD//vwGj759/3squ3h6t++x8b5KVyzIocLF6aPKDs9U4hEZI622HmtrI0XDrXQ2KNYt1kNGr55zRJuWTt6H3CBQDB5iAB1jpBm0XPZ0iwuW3rS68sbDGNzB7D7gngD0XLVsHJRHbvA9gUV2w9PIBwVDgri9IZw+oN4AmF8gai/ZTAct/8IhuU+Fi/De4dp1VLcmzQhqphrNWiw6rWYDUoQq/iXakg262a9nc5geANh7N4gnkAoqgwcoscdoMPpo7HHS123u58Fy1XLsvjvqxaNSj03N9nIjcm53LhayV65/SGOtzk51urgeJuTyujihi8Yidv7TAYqSVl0iQW5atVJH1QAmWiQdUrAJUeD3oh8uh/qaNwjIgFf/P73XzqGSje3RDIkFG/IRKOWVLOO7EQjuUkGCtPMlGRYmJ9mHpdqgmtXZPPioRb2Ndj4xvNHuf/CklGr6A5FOCKzq7abp/c10WJXvtMFmRa+de2SM/IYfnpfE3/doSiCfvf6ZXP2HBXDotfwtauX8JnHD/DI+3VYDFruOoOgPcWs47cfWMXzB1v4xRuVNPR4+M6L5ZxVlMINq3IpSB1Zn/FwnOhw8ru3T9Du8JOZoOfzly6YVQEqwEWLMtny+Qv48avHefFwKztrethZo/j7zksxsb4whRV5iSzKslKQaibdqp/W3qnhiIzDG6Q9+jtY2e7kcJONvXW9/dTyrQYNH9wwj/937nwyBvHXFQgE0wcRoM5hjFo1xiQj2YxPliIiy/EywB53gG53IK6k2O1W+spsniAOn6KSa/cECYQjBMMy3dHth2NTUSqfnaOS8C8cauHZA81DbpNq0XF+aTq3r8sbtod2JJj1mngmPkYwHKGp10tTr5d2h49Opx+nL4jLH8YXCuMPnswk+oJhfH3+HwxHCIaiGbpTIkQlS6rcl2X6/T0iT5wH6qlIcDITHC3jlsLQGP17brIBtc6ILBO3rNGpJQxa9cmbRoVBp+6XRdaoJDRRWyKNSkIXLamPZZ5jJfYalRRXVI4F2LFMbyyrGbtc7Gubo7y+Up6vkpQSblk+ua/DESVLDEpAHwvwVSpl36tiryUp49RGs9366Ngmo8pBkiR+eNNyPv/vQxxtdvDq0dZxDVDdgRD/9041wbBMkknLPefO59Z1eWdULhqOyHFhpE9tLuaKZVnDPGNucO2KbE60O/nNWyd4tayND27MP6P9LEkSN6zO5YKF6fzv1mqe2d/MzpoevIEw/3Xl4nEZ8wsHW2h3+MlJNPCbD6yedcKCMfJTTPzug2v4rys9/OdQK28ea+dAo42GHg8NPR6e3t8U31YlKT29FoNGaeuJnqdilRkSEjInqzaQ+ywYyn0fl+OVH/HtT1kklCTlppJOqfSQZcIRxYrqZLWK8vviDoQGXWy06DWcW5LG1SuyuWRxJkbd3C27FwhmGtJMN6GeTkiSFAEkvX7u+JCeKXL0F+3kD1v08eh/5H7bgUpF/CJHlmUCASWo1elmf09krOwyhiRFA5Xoj3ksKBkIv19RUJ1pczM2P/o9NsLnjm42KFsPNoXm2lybbE6dnzLKxehElHaHIvKwx8tADDUHYuXW0znTNFWEI/Ko9/VIiJWkq1TSmAStBiK2oKO0HyivOVPPnaNFjgaQsVYLWR75uXY6IHHyN1GKLnZKfQLdM2E6n/9j8xMon8pxCAQDkA94ZFke06qtCFDHEUmSInq9XiouLp7qocwJZFnGblcEDxITE6fVj8Z0o7y8HL1ej5ibY0PMtYllJsxPMQfmJjNhbgomlul87E/F/JzO+0Mwfaiursbv9ztlWR5T/4wo8R1fjhUXFy8pKyub6nEIBP0wGAwUFxcj5qZgOiLmp2C6IuamYDoj5qdgurJ06VLKy8sbh99yYKanR4ZAIBAIBAKBQCAQCOYcIoMqmLGEQiFee+01AC6//HI0GjGdBRODmGsCMQcEgrmJOPb7I/aHYDIQs0owY/H7/VxzzTUAuFwucZIUTBhirgnEHBAI5ibi2O+P2B+CyUCU+AoEAoFAIBAIBAKBYFogAlSBQCAQCAQCgUAgEEwLRIAqEAgEAoFAIBAIBIJpgQhQBQKBQCAQCASCOUSvO8CTexqp63JP9VAEgtMQnc0CgUAgEAgEAsEcIRiOcPdf9nCo0QbAhQvT+b8PrcWgVU/twASCKCKDKhAIBAKBQCAQzBF+82YVhxpt6DUqVBJsrejksR31Uz0sgSCOyKAKZiw6nY7f/e538fsCwUQh5ppAzAGBYG4y2479420OHnr7BAA/v20lbn+Irzx9hIe2nuD2DfkkGLRDPn+27Q/B9EQEqIIZi1ar5VOf+tRUD0MwBxBzTSDmgEAwN5ltx/6Lh1qJyHDxogyuWZFDKBzh4XdrqO508/A7NXzx8oVDPn+27Q/B9ESU+AoEAoFAIBAIBHOALcfaAbh6RTYAGrWKL1ymBKVP7GkgHJGnbGwCQQwRoApmLOFwmK1bt7J161bC4fBUD0cwixFzTSDmgEAwN5lNx35Tr4fjbU5UEmxemBF//JLFmSQYNHS5Auxv6B3yNWbT/hBMX0SJr2DG4vP52Lx5MwAulwuz2TzFIxLMVsRcE4g5IBDMTWbTsf/msQ4A1hWkkGw+2T+q06i4eHEmzx5o5tWjbawvTBn0NWbT/hBMX0QGVSAQCAQCgUAgmOXEynsvXpxx2t8uX5oFwGtlbciyKPMVTC0iQBUIBAKBQCAQCGYxgVCEXTU9wMAB6gUL0jFoVTT1eilvdUz28ASCfogAVSAQCAQCgUAgmMWc6HARCEdIMGgoTrec9nejTs35pekAbCnvmOzhCQT9EAGqQCAQCAQCgUAwiylrsQOwJCcBSZIG3Oa8BUqAuruue9LGJRAMhAhQBQKBQCAQCASCWUysbHdJduKg22ycr4gj7avvJRCKTMq4BIKBEAGqQCAQCAQCgUAwiylviQaoOQmDblOSbiHZpMUXjHA0mnEVCKaCOWszI0nSvcDa6H+LgH/LsvzwFA5JMEq0Wi0/+clP4vcFgolCzDWBmAMCwdxkNhz7sizHM6hLhwhQVSqJ9YUpvF7ezu7aHtbMSz5tm9mwPwTTnzkZoEqS9GPgX7GAVJKkJKBWkqS1sizfN6WDE4wYnU7Hl770pakehmAOIOaaQMwBgWBuMhuO/aZeL05fCJ1aNaBAUl82zD8ZoH7iguLT/j4b9odg+jNXS3zvBdbF/iPLsg14OPq4QCAQCAQCgUAwKyiLlveWZlrQaYa+9N84PxWAPXU9hCPCD1UwNczVALUHSDrlsW4ASZKKJn00gjERDofZs2cPe/bsIRwOT/VwBLMYMdcEYg4IBHOT2XDsl8cUfLMHL++NsTjbikWvwekLUdnuPO3vs2F/CKY/c7LEV5bl02sWYH30bzWTPBzBGPH5fGzYsAEAl8uF2Wye4hEJZitirgnEHBAI5iaz4diviAaai0cQoGrUKpbnJrKjpptDjbbTnjMb9odg+jNXM6j9iPag3gJ8ZYTblw10AwYKfAUCgUAgEAgEgimhvtsDwPy0kQWTK/OTADjUJJR8BVODCFAV/g08JcvyT6Z6IAKBQCAQCAQCwXggyzINPUqAWpBqGtFzVuYpXqmHm2wTNSyBYEjmZIlvX6KKvjZZlm8d6XNkWV46yGuVAUvGa2wCgUAgEAgEAsFY6XT58QTCqCTISx5hgBrNoB5vc+ILhjFo1RM4QoHgdOZ0BlWSpFuAolhwGi31FQgEAoFAIBAIZjyx8t7sROOwCr4xshMNpFn0hCNyXAFYIJhM5myAKknSGuDSUzKn94ogVSAQCAQCgUAwG4gFqIVpI8ueAkiSFC/zPdRom4hhCQRDMicD1KiVzL+BfZIk3Ru9fRm4PeqJKhAIBAKBQCAQzGgaut0AzEsZndpurMxX9KEKpoK52oO6D8UH9Q+nPL5/8ociGCtarZZvfetb8fsCwUQh5ppAzAGBYG4y04/9+lEKJMVYERdK6q/kO9P3h2BmMCcDVFmWk6d6DIIzR6fT8e1vf3uqhyGYA4i5JhBzQCCYm8z0Y78uVuI7ygB1Wa4SoNZ2u3H5Q1j0Ssgw0/eHYGYwJ0t8BQKBQCAQCASC2c5YS3zTLHqyEgzIMhxrFUJJgslFBKiCGUskEqGsrIyysjIikchUD0cwixFzTSDmgEAwN5nJx77dG6TXEwRg3igzqADLchMAONp8ssx3Ju8PwcxhTpb4CmYHXq+XZcuWAeByuTCbR7c6KBCMFDHXBGIOCARzk5l87DdEy3vTLPp4ie5oWJKTyJZjHf2sZmby/hDMHEQGVSAQCAQCgUAgmGU0RAWS5qUYx/T8ZTmnZ1AFgslABKgCgUAgEAgEAsEso9XuBSA3efTlvXBSKOlEhwtfMDxu4xIIhkMEqAKBQCAQCAQCwSyj1e4DIDvRMKbnZycaSDZpCUVkKtud4zk0gWBIRIAqEAgEAoFAIBDMMmIZ1LEGqJIkxbOoR5uFkq9g8hABqkAgEAgEAoFAMMs40wwqwJJoH2p5q+hDFUweIkAVCAQCgUAgEAhmGa22WIA6NpEkgCXZSoDaV8lXIJhohM2MYMai1Wr54he/GL8vEEwUYq4JxBwQCOYmM/XYD4UjdDjPPIO6NEcp8T3e6iQckWfs/hDMLESAKpix6HQ6fvrTn071MARzADHXBGIOCARzk5l67Hc4/URk0Kgk0iz6Mb/O/DQzRq0abzBMXbeb4nTLjNwfgpmFKPEVCAQCgUAgEAhmEbH+08wEAyqVNObXUaskFmVbAVHmK5g8RIAqmLFEIhHq6uqoq6sjEolM9XAEsxgx1wRiDggEc5OZeuzHFHxzksZe3hsj1oda3uKYsftDMLMQJb6CGYvX62X+/PkAuFwuzGbzFI9IMFsRc00g5oBAMDeZqcd+WzSDmnUGAkkxYkq+ZS32Gbs/BDMLkUEVCAQCgUAgEAhmES1RBd+cMxBIihETSipvcSDL8hm/nkAwHCJAFQgEAoFAIBAIZhFtDqXEN2scAtSFmVZUEnS7A3Q4/Wf8egLBcIgAVSAQCAQCgUAgmEW02M7cYiaGUaemKN0CwPFWIZQkmHhEgCoQCAQCgUAgEMwiYiJJ2ePQgwqwNNqHekwEqIJJQASoAoFAIBAIBALBLCEUjtAZLcUdjwwq9A1QnePyegLBUAgVX4FAIBAIBJOO2x/i1aNtvF7ehkWvZVGWldvW5ZNo0k710ASCGU2PO0BEBpUEqRb9uLzmkmxFKOl4u8igCiYeEaAKZiwajYb7778/fl8gGI7DTTYq2pycU5JGTtLIy57EXJs7+IJhTnS4cPiC+EOKx59aklDLIT728fswaNViDowDe+p6+MRj++h2B/o9/tu3qvjsJQv4yKYCNGpR5CWYembi+T8mZJRq0aNWSePymrEMamNvgHvu+wQ6tWrG7A/BzEPMLMGMRa/X89BDD031MAQzgEAowo9eOc6f36+NP3bpkky+f8MyMhOGL38Sc21202b38cKhZl452saRJjuhyCA2CinXkp9i5PkjHdyyJg/VOF34zTWe3tfEV54+TCgik51o4Orl2eg1Kl4ta6O60833Xizn2QNN3H9hCRctysCgVU/1kEdEp9PPO5Wd7KrppscdQJIk1hcmc+mSzLjAjGDmMRPP/7Hy3vRxyp4CJJt15CQaaLHDPV/+PhuLUsfttQWCUxEBqkAgmPX8cktlPDgtSbdwotPFG+Xt7Kju5oc3LefalTlTPELBVNBq9/KrN6p4en9Tv6A02aQl2axDr1EyeOGIjMsfotXmo7HHy5efOsxzB5p55CPrMepmRvA0XXj1aBtfeuoQERkuX5rJt69dGt+HHzt3Ps8eaObXb1ZxtNnB/f/Yj0WvYVV+EivzE1mWk8jawmQyrOPTU3em2DwBDjbaONBgY9uJLvbX93Lq0saWY+386JXjXLcqhwcvWcD8NPOUjFUwt+hwKgq+GQnjF6ACLMlJpMXuo6zFIQJUwYQiAlTBjEWWZbq6ugBIS0tDkkQ2Q3A6XS4/f9teB8A3r1nCDatzqWp38t0XyylrcfDA4wd4t7KTb1y7hATDwL1vYq7NLmRZ5rGd9fz4leO4A2EAVuUnccWyLM4rTSMn0XDadyzLMg0tbbx4qJW/H+ple3U3n/7nfh6+a924ldDNdg432fjM4weIyHDj6ly+ec3ifvtZrZK4ZW0emxem849dDbx0pJV2h59tJ7rYdqIrvl1xupkrlmVx4+pcSjKsk/oZetwBntjTwFP7mqjpdJ/290VZVs4pTiUnyYg7EGJ7dTc7a3p4/mALLx5q5ZIlGdy4Oo8LF6bPmMzwXGcmnv8nIoMKsCQngTfK29hbUce1Cy0zZn8IZh4iQBXMWDweDxkZGQC4XC7MZrEyLTidH7x8DHcgzKIsK9evUjKlpZlWHv3oev737Wr+sr2Of+9rYmdtN7+6fTVrC5JPew0x12YPLn+IL/37EK8cbQNgRW4in79sAavyk4Z8nsfjYdWCQgBe3l/Dg08f583jHTz09gk+c3HpBI965hMMR/jyU4cJhCNcsCCNr129aNAL21SLns9cXMqnLyqhss3JkWY75a1OylrsVLa7qO5089Db1Tz0djWXLM7g0xeVDvv9jQdHm+38v7/uod3hjz+Wn2xkRV4iK/KSOK807bSWgTs3FnC8zcHvt1bz/oluXitr57WydoxaNZuKUzmnJI2zilJYnJUgSsanKRNx/nf4grx4qJXXytpod/gIR2QWZFrjc2l+mpkMq37McyLWgzreGdSlOQnIQT//e8+1/C/i91AwcYgAVSAQzFq2VXXxzP5mJOCrV/XP1mhUKh64uJTzFqTz9eeO0Njj5bb/28GDl5Ry/+YSkRWbhdR2ubnnr3uo7nSjUUl8/tIF3LEhH9UoMwAr8pL4xjWL+fpzZfzurRPcuDqX/BTTBI16dvDYjnqOtzlJMmr59nVL0aiGF0BSSRKLshNYlJ0Qf8zuDbKjuptXjrbybmUXW451sOVYBxctyuBzlyxgeV7ihIy/tsvNnX/ahd0bpCDVxN2bCrlwYToJxuEVhxdlJfCbO1ZT1eHipcOtvF7WRrvTz1vHO3jreAcAaRY9ly7J4OY1eawtSBZZqVmKNxDmz+/X8vu3T8SrN2JUdbh46Uhr/P8alUSSSUeGVc+8FBMXLkzn2pU5mPXDX7pPVAZ1We7EHF8CwamIAFUgEMxKfMEw33zhKAC3rc8f9Id1VX4Sj3/8LH70ynFeOdrGz9+oZNuJLn5260oRdMwi3qns5IF/7sfhC5Fh1fPTW1aw8gyyblcvz+Y/h1rZVdvD/7x0jP/78NrxG+wsw+0P8bu3TwDw6YtKSDbpxvxaiUYtVyzL4oplWdR3u/nTtlpeOtwaD/YuWJDO1cuzObd0dErdw/HN549i9wZZmpPAQx9cg9Uw+sun0gwLD15SymcvLqGqw8WO6m721vdyoMFGl8vP47sbeXx3I4uzE3jgohKuXJYlAtVZQiQi8/LRVn70ynGaer0AzE8zc+2KbEozrYBMVbuLw812qtpdtNl9hCIyXS4/XS4/5a0OXi1r4/svHeOnt6zgyuXZQ75fZzyDOr792jmJBpJMWhrH9VUFgtMRAapAIJh1yLLMfz19mJpON6lmHfdfWDzk9laDlu/fsIxNRan88JXj7Krt4dJfvsO95xdz3/lFkzRqwUQQCEX42esVPPxuDQDLcxP5xW0rSbeeWWZBkiS+dPlCbvvDDl4ta2NXTbcQDRmEf+yqp8cdID/FyA2rx0+QrCDVzPeuX8Y9587nj+/V8vKRVt6p7OSdyk4AcpOMXLQog2tWZLNhfsqYg71AKMJ7VV2oVRI/uHHZmILTvkiSxIJMKwsyrXzk7EKC4Qj763t55Wgbbxxr51irIhB1bkkaP7xpuVgom8HIssw7lZ389LUKyloU/9DMBD0PXFTK5Usz+1VvnF2cFr8fikTodgWweYJ0OP1UtTt54VALjb1ePvmP/Xzp8oV8anPJoO8bK/E90/PcqUiSxNKcBI6M66sKBKcjAlSBQDDr+PuuBp472IJakvjhTcuxDiJ+1BdJkrhmZQ4r8pP43ovl7Kvv5TdvVvHX7XVcuyRlEkYtGG+2VXXxvRfLqWh3AnD7+nw+f2kpes34iNOUZFi4aU0uT+1r5jdvVfEPEaCehtsfii8O/H/2zjq+revu/+8rBjMzUxxmbKgpM6/d2m7d1nbr4Nkz6PYb4zPq1m3ttq7d1m1dKeWmkKZpkoYZ7YCZWZZtMd3fH1dSnMRsyZYTvV8vv+paR7on0tG550uf72dX5I4otXe0ZMfr+dnNM/j8ZblsLGtj25kOTrX00WS08p89dfxnTx3L8uP5wQ2llKREDf+C59Frc6IFVhQkkBEbeGNRKZexOC+exXnxfO2KIp7fW89/9tSxo7KTq//wMY/dMZurZwwdMQsTWlgdbt4+2sxze+s41tgDgF4l51NLsvnUkix0qqGP3wqZjOQoDclRGopTIrmsMIH7lmXzhw8reH5fA7/ZeJq8QRShRVEMWoovwLTU0X+HwoQZLWEDNUyYUWB3uRFFRqy+6PGIIxI5EEWRxm4rp1ulQ5XR4sQjikRrlaRGa5iWGkV2vC6c7jUCtp5u50dvlgHwxTX5LMgZnXGZFafjb/fOZ/PJdv60pYIGg5V/767zP/7fPXVcOTs7/HmEKKIosqfawBNbKthZ2QVAjFbJD28sZU1xUsCv98DyXN443MzOyi6ONhjHlTZ8MfLUtio6TQ4yY7VcN0xa4njJjtfz4Mo8HlyZh8Xh4kBtNx+daued4y3squripid28svbZnLL3IxRva7F4UYLrJsW+PVzPtFaJV9Ync91s1L50VtlHG3s4eHnDvHImny+fkVxWEgphBFFkZMtfbx2qJGXDzTQa3MBoJLLuGNBBp9ZnjOu9HaFTMbXryxGKZfxr911fOvVY4jihT2bTXYXVqdU3xroCCpAadhADTMBhA3UMGGGob3PxnN76vmgrJWKNhNuUSRKo2BmRjQLsuPIS9SjVynosTqp6jBxps1EdaeJ9l47JrsLhUwgUqMgPVZLZqyOzDgdMTolckGQUnfaTRxvNNJtcQ45jzi9ilVFiVxZmsyaKdS8fiLZX2vg4ecO4hZFbpiVyqeX5YzpdQRBYJ33fd5T3cWLuyp43vvYz945yS821RCrU1KaFsWMtGhWFSWyMDcOpTzw0aEwI6PH4mT9wQae31fvb/+hlAvcsSCTh1bmET0CMZuxkBaj5eoZKWw41sKft1by1L0LgnKdqUhLj5W/bZeip19dVzih3w+dSsHKokRWFiXy+ZV5/OLdk+ys7OJrLx2l2WgbMj3yfOwuDwDzsi5U+A4WWXE6nrp3Pk9uqeI/e+p4cksVZc29/P7OOcTqx27khAksHX129tUY2FnVybbTHTQZrf7H0mO03DYvnRvnpI3LMD2fL6zO50BdN1aHmzODzAmkiO1IBJVGy/S0swaq0+0J+OuHCQNhAzXMFEahUHD//ff7fw8koihyoqmX/+6t49VDjTjd53ope20udlZ2+SM0Q+HyiHRbnHRbnJxo6h10nEImkJeoJyNWR6xOiUwQMFqdNButVLSZMJgdvH64idcPN6FTybmyNJm105JZU5w4ohTWi53NJ9v4yguHsTk9LM2P53vXl447wimXCSwvSGBBZiTWrffQZLSSlBXHqQ4r3Ranfw089XE1KVEaHlmTz50LMwOWQhpmeDr67Pzt4yr+u7cei1cVU6eSc+3MFD6zPJf0AAnlKBQK7v7kvf7f+/PA8hw2HGthY1kble19E96bM1T51XunsDk9zMmM4fKS4EcfByM9Rsuf7p7LEx9V8o+dtfxm42k8HpEvj7A9UEqUhi+tKSAlOrCCM8OhlMv4n3WF5Cfq+b/3TrH1dAc3PLGDP3xiDvOzw2UH/THZXRgtDtJjtAHPbOl/1pDL5eyrMfDu8RY+rui4oBeuWiFjSV48t85LZ1l+/KgVwkeCUi7jsTtmE6lRkP+9C1+/PUgCST5yk6KImb0Op1uktsvGnKjwfhcm8IQN1DCTjscj0mS0UtluoqrDRHufnR6LE7lcQKuUE6dXEaVRoFMpUClkqBUy9GoFiZFqnnjqGSLG6CHsszlp67XR0eeg1+bEaHHQaXJQ1W5iX63Br7QHMCsjmk8szGR+dixalZwWo40jDUbKW3qp77Jgd3uIVCvIitORn6gnJ0FParSGCLUCl0ek1+qk2Wij0WilyWjFZHPh8nhIiFCTGatlWmoURcmRqBQDRxicbg9HG4x8fKaTTSfbaOmx8caRZt440oxCJrC6OInb52ewbloSios0iudye3B5RNQKmf8A4vGInGrt4587a1h/sBGAhTlx/PaO2QGN1qjVap75xz/9/+9weahs7+NMu4nD9UZ2VHTQ2mvj+2+W8cyOGv7ftdO4sjQ5nAIcROwuN3/fUcMTH1X6DdPCpAjuWpjJNTNSAh45UKvV/Plvzwz4WF5iBGuKE9lyuoO/bqvmt3fMDui1pyInmnp440gzAvCtq4on/bsgEwS+cnkhEWoFf/yoksc2nSEjTjuidF+dSs5nlucEf5KDcMPsNEpSo/jG+qM0dlu5/S+7+czyXL5xVdGwtYwXMx6PyOuHm3hySyXVnZKhmJ+o557F2Xx6WU7AWoWp1WqeffZZdld1ccfTBzje1ON/TADykyJYmBPLopw4FubGoZ2A7KahUneDWX8KoNFouOqLP2FPtYEzXTbm5AblMmEucS7dnS1MUBBFEZdHRCETzjmQiKJkhJ5q6eNMex/1XRaajFaajVYau63+FKqxEKdXkROvIzchgux4HRmxWhIi1ERqFAiCgMXuosNkp8FgoabTQlWHidouM8ZhUmo1ChmrihP5xMIs5mbFnPNYVIqS4pSRew2TozReKfmxoZTLWJATx4KcOL52RSFHG3vYerqDrafbqe2y8OHJNj482UZ2vI4vry3ktnnpk34gHA6PR6Sl10ZVu/R5tPbYMFqdWB1ubE43ZoebbrODLpOdTrMDR781olHK0CjlXkP/bHT77kVZfPXywkEN/UChUsgoTYumNC2am+ek43B5eO1wI//YUUNdl4WH/nOQ3AQ9V01PYW5WDAVJEWTG6oI+r0sBURTZerqDn75T7o9eTE+L4uFVeawoSJi0df/A8ly2nO7gjcNN/O8VRQFtcTIV+f0mKfnw6hkplKaFTs3aAytyMdld/GNnLY++cpxpqVFjEk6aaAqTInjus4t47IMzvH2shX/srGHDsWYeXJnH3YuygpLKGco0Ga187aUj7Ksx+P8mE6Cqw8xPN5Sz5VQ7T94zj2jd+LOLPB6Rxz88wx8/klolqRUyrp6eworCBBZkx46oF+5E4lfwjQqOgQowIy2aPdUGTjT1cOeCzKBdJ8yly6W1o4UJOKIosr2ikzeONLG32kBzj9UrIiQjXq9Gr5bjcou09douaErdH6VcIDteT16CnpQoDZFaBaIoKUAarU5MNhdmhwuXW8Th8mByuOjotdHTZ6bTYaPLZOdQvXHU84/UKIjXq4jSKInSKonRKcmO11GcHDlhntDRIggCczJjmJMZw/+sK6Sy3cSGYy28eaSJui4L31h/lE3lrfzmjtlETXDqr8PloabTTHWHiS6zgx6vwWlxuLE4XPTanHSbnbT12Wgah2PC5vRgc0rPlSLIidy9KIu5QaoRE0URi8UCgE53oTiSSiHjEwuzuGFWGv/YWcOL+xqo6TTz121V/jFymUB2nI7StCgW58axrCCBvAR9yDsSQgVRFNlV1cXvN53hQF03APF6FV+7opBrZ6YGJZXu/OsPtQakmvRYDtR188z2Gn5wQ2lQ5xPKVLb3sflUOwLw8KrQa9P0pbUFnGkzsaOyk6+/fJQ3H1k+JTJPIjVKfnTjdK6cnsz/vXuK5h4bP3vnJH/cXMHdi7O4a0EmeYkRY359i8NFXZeF1h4bHlGkOCUyKCmzA9Fnc/KzDSfZU9PFjLRobpidOqBysSiKvHW0me+/cYJemwutUs7nLsvl5jlpyGUy3jvRwh83V7KjspN1v9/GN68qZnlBAqlRGtxeQSGZIIw4uup0e/jm+qO8tk+qpb51Ud64e/kGm2BHUEVRpDBeicdh42iDMSjXCBMmbKCGGTO7q7r42Tvl/t5e/bE5PeeIBYBkSOQm6ClIiiAnXkdKtJa0aA0p0RrSYrSjTscxm81kJEl1OM9uO0mbRfKqthhtGCwOzHZJQU+rkhOrVZIWqyUrVkdOgp6sOB2ZcdqLIj2qwNv8/aGVeTy/r56/bK1iY1kbTcY9rH9oGVpVcI1sX0Trpf0NbK/oGNIRcT4KmUBmnI7sOB3J0RpidUo0Srn/J0arJE6vIk6vQq9WIJcJOFwebE4pyqpXK4jTq4IuvmKxWMhKltZafZsBvX5geX+9WsGX1xbywPJctp7u4FB9N2XNPdQbLNicHqo7zVR3mtlwrAWQ+uHNyoihODmSlGgNcXoV0Vol8REqUqI0xITwIWgi2V9r4Cdvl/tT69QKGXctzOTzl+VOWP21xWLx7zeN7QOvgQeW53Cgrpvn99bxxTX5JATpgBjq/HdvPQCrihPJjh/4uzKZyASBH99Yyi1/3kVZcy/P7qrlc5eFniE9GMvyE3jti8t4+2gL/9lTR73BwlPbqnlqWzUz06O5dmYqKwoSmJYaiUIuQxQlHYQGw9nMpQ6THYPJgdHqpNNkp8Voo7XXdsG1luTF8cQ984K+lv+6rYqXDjQAUNdl4Z3jLTx2x2xumy+lYIuiyP7abn6/6Qy7qyXth+lpUfz85hnn9Im9c0EmczJjePTV49QbLHzrlWMDXi8hQkVugp7FufGsKUlkbmbsBQrJDQbJ4bv7dDMNv78dgP9t7UIf4vtyR5B6oPqwWCx8YlkRAKpvvobD5QlnB4UJOFP/dB5mwunos/N/753ktUNNAGiVcm6em8bKwkQKkiJQKWT02SRRIIvdhVwmkBChJj1WGzRDYt205EGNhksFrUrOZ1fksjg3ji+/cJgTTb18+7VjPH7XnKBdc3dVF798/9Q5XtQItYKceB2JkWoiNEp0KjlapfQTqVUQrVGSGKkmxeucGHVfxClw5terFVw3K5XrZkkRAFEU6TTZqeowc7yxhwN13RxtMNLWa2dTeRubytsGfJ1YnZKSlCiKUyKZnhbFnMwY8hMjLplWEx6PyI/eLvO3+dEoZNw8N50HVuSQFDmxgjUjYWl+PKVpUZQ39/KvXbV8/criyZ7ShOPxiLx3vBWAW+akT/JsBic+Qs3Xrijix2+X8/tNZ7hxdlrQRGWCgVIu49Z56dw8N43tFZ28eqiRPVUGjjf1cLyph195x+lVcmwuD27Phe1IBiJaqyQlSo1bhJpOM3uqDdz0xE6e+9xicgfpuxkIfEZVaWoUeYl6Nhxr4evrj2J2uHC6RV7e3+DvZ6xWyPjM8hw+vSxnwDNFUXIkLz24hP/uree9Ey3Udlku+Pd3miTNif213TyxpZLkKDWXFSYyLTUKlVygrLmXt442Sy2GQjCTaig6TMGNoPbH4fJwpq2PGenRQb9WmEuLsIEaZsTYXW7+s7uOxz+swGR3IQC3z8/gkTX5F0R6orVKMiZOkT9MP2akR/Ob22fx8HOHePNIM6uLEwN+jdpOM7949yQfeA0rjULGbfMzuGZGCiWpUUFPt5xqCIJAYqSGxEgNS/Li+Txgdbopb+7lZEsvDd0WOnrtGK1Oeq1ODBYHRq/y8+7qLn/EACBKo2BRbjwrixK4ojSZ1OiLs9ZRFEV+sqHcb5zeOi+dL60pIC6EW2wIgsBnluXwzVeO8fzeer68Nvj10KHGofpuWntt6FVylubHT/Z0huSmOWm8dqiJ4009fP/NE/z1U/OnXMq9TBBYVZTIqqJEus0OPjrVzraKDo40GDHb3edktCRGqqWspSgN8REqYnVSxkasXkVipJqMWO05qas1nWa+9tIRGrqtfOn5Q7z+xeVBW8++cpQ+m5PlBQm09Ng4WNfND7w9rUHqJ3r9rFQ+szxn2BpvldeI/czyHJxuDya7C7kgIAjgdIu099k41dLHvhoDOyo7aeu184pXaK8/szOi+fa6HJb9OrD/3mDS5TVQEyInZq881tgTNlDDBJywgRpmSOwuN4frjWwqb+Pto83+4vtpqZH8v2umMTMjvCmFIgty4nhoZR5Pbq3i1++fZmS+86HpsTjZeqadt440s+1MBy6PiEyA2+Zl8ODKPOIv0XTGsaJVypmfHcv87IE9OVaHm7ouM6fb+qhsN3GypZfyll56bS6/KNYP3ixjQXYsdy7M5PpZqRdFyrqPlw808OyuWgD+79YZXDNAPVoosro4kcQIFR0mBxvLWrlhdtpkT2lCeftoMwBrSpJC3jiXCQLfvW4an3pmLxvL2njlYCN3TGHBl1i9itvmZ3Db/AzcHpEeqxOT3YVGISNapxx1+6vcBD1P37eAu/62h7LmXp7YUsn/XlEUlLk/vDqf90600tBt5TuvHff/Xa2QkRaj5a6FmaybljSm2k+lXHbB8+L0KkpSorh5riRyd6Cum4N13TQZrTjdHtJjtCzJi2Nxbjw2q2Xc/76JpMvkACBePzH35GONRu5ZnDUh1wpz6TBppxlBEOYAvwLygGrgW6IoHp2s+VzqiKJIR5+dynYT1Z1mKttNHG/q4URTzzlCNomRah5elcfNc9IDJuEeJjjctyyblw400NJjwzPC9K7+9NqcHKg1sL+2m301Bo7UG/0iEwDL8uP52roi8pPGLsoRZnC0KjklqVGUpJ7bFP1MWx97qyWv/5EGIwfqujlQ183P3znJJxdn8ckl2QHr/TlZeDwif94qCUw9sjp/yhinIB2Gb5mXwd8+rua5PXWXlIEqiiIby6SsiitLkyd5NiOjJCWSh1fl88SWSn7wZplXdXvq93WUywR//f54SIxU8+1rSvjOa8d5alsVt81LD0pdcUKEmvUPL+XZXbW8f6KVeoNkFJakRPL3+xcENbKtUshYlh/PshCP+I8EURTpMkuBhPiIiYughgkTaCbEQBUE4SXgUVEUa73/fzmwHjgAbEYyUg8JgjDvYjNS23ttvHW0mSajlUiNkqunpzAtNTIk0oh6bU62nu7go5Nt7Kk2DCiQAJKncWlePOtKk1hRkBB0QZowgUGtkHPngkz+vLUKjzgyA9Xp9vDmkWbeONzE7qqucwxSkDzql5ckcfWMlHGpRYYZG0q5jOlp0UxPi+aBFbl09NnYcKyF1w830dht5c9bq/jrtipWFSWyujiJGelRpMfoiNOrQj6a1Z8Ddd3UdVmIUCv41JLsyZ7OqLltXjp/317D3hoD1R2mS+a7cryph9ZeG1qlnMV5cZM9nRHzmeU57K3pYn9tN1/87yHefGRF0MXlphJXTEvitZxY9td28+1Xj/P85xcH5QyTFqPl/107je9cU8K+GgP3/n0fRxt72F7ZycrCwJeqXIz02qSaXWDCRNpOt/Vhc7rRTLFa3TChzURFUGuQoqV3ef//QSBXFEW/20UQhBjgqX5jpjynWnu57+/7/GmxAH/cXMGinDh+eGMp09OClx7r8YgcrO/mSL2ROoMZh8uDgIBMJmCyu6jpNFHe3Ev/wJpMgIxYHdnxOnLj9RSnRFKaFkVO/IUtFcJMDa6ZkeI1UIcf+/6JFv7vvVPUdZ1NZ8qK0zEnM4a5WTEszIm75Hs7hhqJkRo+szyX+5bm8PGZDl7YX8+B2m62nO5gy+mOc8bG6JSkx2jJiNWSFqMlN0FPboKewqRIkqPUIfUd31cj1dwuy4+fkoZCcpSGJXlx7Kzq4u2jLXx1XeFkT2lC2FgmiSMtL4gfdTrpZCKXCfzy1pnc9bc9nGkz8dN3yvnFLTMne1ohgyAI/OD6Um77y252V3ex+WQ764IYIRcEgcV58XxmRQ5PbavmN++fZmF23JTcCyYaX/1phFoxIQZjfISKbodIWXMP87OnjlMqTOgzUQZqF/D5fv9/oL9xCiCKolEQhJoJmg+CIKwD7gCMQAxwUBTFvwXq9ZuNVu55ei8Gs4P0GC3rpiXR0G1lR0Un+2oN3PCnHXxpTQFfXVcU0FRZURR540gTT3xUSZW3if1Q5MTrWFOcxNL8eGZmRE8ptTq5XM5Nt9zq/z3MhWTG6fjK2gIe/d3ga6zH6uR7b5zw147F6VXcvSiLK0uTz5Hvv5SRy+XceHPorjW5TGBNSRJrSpKo6TSz9XQ7+2sN1HZJ4ktuUcRocWK0OAdsCxWpVpCXFEF+op78xAjyEyMoTI4gO043Kf0hD3r7nM7OjJnwaw/GaPebK6ensLOqi/dOXBoGqt3l5tWDkrL72pKkSZ7N6ImPUPOLW2by4H8O8vzeem6blx4+cPcjLUbL3Ysz+deuOn6yoZzStKigOyy/sraQt48009xj44X99TywPDeo1xuMUN//+9Nl9tafBjG9Vy6Xc/vtUtsdfWYcW6uMHK43hr8vYQLKRBmo8UhGoI/B4jmB0HIZFkEQ5gG/EkVxfr+/bRIEwSCK4iuBuMafPqrEYHZQlBzBM/ctIEorKdS19tj43aYzfFDexh8/qmRPtYHf3TWbjNjxGwIut4evrz/Km0ckQyNCrWBRbhz5iXo0SjmiCC6Phwi1gsRINXMyY0ieQrL656PRaHj2uRcmexohzwMrcvnOIPZpg8HCp/+5j6oOM3JB4L5l2XxuRV7YU30eGo2Gf06RtSZFRnP5jPcw5xElsZTOPjvNPTZae2w0G600GCzUdplpMFjps7s42mC8oOm6Si4jL1FPYXIkufE6MuN0ZMXpKEmJIloXnP6jHo/IYe88ZoeQCNto95vVxYkoZAKnWvsob+6lNC1q+CdNYV492ERrr43ESDWXT5t6BirAotw4bp6TxhtHmvnhW2W89ciKyZ5SSHHvkmzeOdZCvcHCzU/u5NvXlHD1jJSgibPp1Qq+cVUx//vyUV7c18C9S7InpcRIo9Hwj/88P+HXHQu+CGp8ENXONRoN69evB+DJLZWSgXrevSNMmPEyUQbqOqBHEIS1gAAkCIJwqyiKrwmCkAPME0XxNe9jE8GvgJfO+9tT3r+P20BtMFhY7204/Z1rSvzGKUBKtIZf3z6L1cdb+Nk7J9lXa+Dqx7fz81tmcOPstDGn2Xk8Io++epw3jzSjkAk8tCqPuxdlEaG+eFQ9wwSWJqOVW/68k06Tg6RINb+9Y3ZYKv4iRCYIxOqklhKFyReKvzjdHhoMFqo7zNR2manplH5qO83YXB5OtfZxqrXvgucVJEVw67x0bp+fEdCepIcbjBgtTiLUCopTpq5YTbRWyaqiRDafaufNI00XtYEqiiL/3CklQN23NHtKpfeez1cuL+TDk+2caOplw/GWyZ5OSBGrU/HsZxbx1RcPU9Vh5n9fPsqP3y7n+c8vDlrJ0g2z0/j5OyfpMjs4VNfN4rypL2QUTDp9Cr4TVH86NysGgCP1xgm5XphLh4myXj5/3v+/hJRaC/Aw8C1BEH4liuK3J2g+65AM0v5UA3leoaZD43nxxz+swOURWZwbx9ysgVtIXDszlVkZ0XzntRMcb+rhqy8e4eUDDTx6dQmzMmJGdT27y8031h/j7aOScfrr22dNyRSrMBOHy+3hKy8cptPkID9Rz5P3zJtSTerDBA6lXEZeYsQFQj4eUaTZaKWqQzJW6w0Wmo1W6g0WWnpsVLab+PX7p/nj5gq+vLaQz12WGxDD5IN+dYxTXZDt2pkpbD7VzrsnWvjOtdMmezpB41C9kYp2ExqljJvmTG3V4ji9ivuWZvPnrVX8xaskHeYsqdEa/n7/Qp7fW8cbR6TWc//vteO8+aXgRJuVchnrpiXz0oEG9tQYwgbqMPhazCRMkILvrIwYZILk8G7rtU3prLwwocWEGKiiKB4e4rFvAxNlmPrSe+Gsgcx5/58HjNlAdXlEXj8sNXv+0tqCIcdmxOr4x6cX8M+dtfx9Rw07K7u48YmdLMuP57Z5GVwxPdnfvHogPB6RnVWd/Or9U5xo6kUhE/jpzdMvGePUbDaTkSTVPDS2G9DrAy99f7Hy1MfVHKzrRq+S8/hdc8PG6TCYzWaykqW1Vt92aaw1mSCQEasjI1bHqqJzFTSNFgfbznSw/kAj5S29/Gbjad493sIfPjGXgnG0HXJ7pBp6gKump4xr/oFmLPvN0vx4FDKBBoOUUn2x1nS/uK8ekGpPh7pnTRXuWpjJP3bWcLKld8QK6JcSkRoFD63K57b5GVz3xx0cbewJahq7r9bVbHcF5fWHw2w2k50iGcZ1rV0hvf/7W8wEsQeq2WwmIkLa500mE0XJkZxq7eNwvZGrZ4TWvh1m6hIQA9WbuvsQUmQyxvtnI1IbmUPAS6IoHgnEtQLAYFXchmEe9yMIQtkgD+X3WJ1oRJifHcvMEaRLKuUyHlyZx7UzU/jrtmreO97KrqoudlV1oXhVYElePMsLEpifHUt6rBaX20O9wcLOyi7eOd5Mg8EKSOlkv7ptJkvC3sUww9DaY+OPmysAePTqEtJjw8q8YUZHjE7FTXPSuXF2Gu8eb+WxTacpa+7l+j9u50trC/jcZXljUpDcU91FW6+dKI2CFQUJQZj5xKJTKShNjeJYUw+H6rsvSgPV4nDxlldg7a4FmZM8m8AQrVVy4+w0Xj7QiHsMPaQvFRIi1CzLj+fjik52VXUGzUA1OyTDVBHuvT4sXabgiySdz9ysWMlAbegOG6hhAsa4DVRBEL4JXIFkiP4SSRApH7jc+/d1SCm8B4H/E0Xx9fFeM0gERH6s1+pEA9w+P31Uz8uI1fGzm2fwhdX5bDjazMayNqo7zeyo7GRHZeegz4tQK7hhdiqfWZ4T0DqwMBcvf/qoArvLw+yMaK6blTrZ0wkzhREEgetmpbIoN5YfvFnG3hoDv/3gDH/dVs3crBhSozXoVApUChl6lYK4CBXzsmIoTY0asN7+La/A2xWlyVOqb+tQFKdEcqyph5Mtfdw0Z7JnE3h2VHRid3lIi9EwK4RErcaLz0ANB1CHJiteBxWS4zNY+OobS1Iu3jruQNHpE0maoBpUkOpQX9hXz+E644RdM8zFTyAiqHGiKF450APe3qYfIkVS7wReFQShG/jcJBqqvkhpzHl/jznv8UERRXH6QH8XBKHM5RZLozQKLi8ZW4+w9BgtD63K56FV+dR1mdle0cmB2m4q2k209dpQymUkRKiYnRnD8oJ4VhcnTanWMGEml8ZuCy/tlwS8vrS2MKR6X4aZuiRGavjzJ+exsayVxz+soL3PzvaKwR1rGbFafnHLTFb2Sx0WgY3lUv3p1SGW3jseipKlVLgTTT3DjJyaHPIaD8vy4y+q/WR6WhRfWJXH94Zo0RUGdN7zh83lDsrrG8wOf9spnyBPmMHxtZlJCKKK7/nM82qtHG004nB5LhrnYpjJJRAG6qC7t7e3aZcoig8DD3vrP7+DZKi+LIriJwJw/dFSPcjffRHUcQkkKeQCV01PCcgXNDteT3a8nk8tyQYkpcSL6QAQZuL528fVuDwii3LjmJ89sIBXmDBjQRAErp6RyhWlKVS2mzjR3IPR4sTicOHyiJjtLlp7bByq66ax28qn/7mPH94wnfuX5QBgdbixWJzE6pTMu4jWpk8o70CdAbvLPaUVbgeirFkyvC+26JYgCDy0Kp8fhG+5Q+LypkArZMExSt493oJbFClOjrgoU+QDTdckRFDzE/XE6pR0W5wcb+oJny3CBIRAGKhVgiD8nyiK3xluoFcd9w5BEPKAvwqCsFEUxasCMIcR4zWaP0QSQ+pPDGAURXEwA3ZEZMXpgtaUPWychhkPbo/Iy97o6WQ1PA9z8SOXCRSnRA7aIsbicPHr90/z1lGp1+TszBhAEkDRAauKEpFfRLVm+Yl64vUquryRoGX5U7+2tj8VbSYACschjhVm6uJ0SwaqUh7476zHI/Lv3bWA1PkgzNC43B66LU5gYmtQBUFgQU4cm8rbOFBrCBuoYQLCuF1eoig+DRQIgrBfEITZI3xOtTct+ENBEL4x3jmMgV8hiTr15yHg0fG+sCAQ7j0aJiTptbmwuTwUJ0eyMCd8AwkzOehUCn54QynXeMU0/u/dk8BZhc5VxYmDPncqIgiCX7xuxxBpz1MRk91Fa69Ue5ibELrKpmGChy9w6gqCmNQrBxs502YiQq2Y8u2LJgKDRUrvFQSpZ+1EsihHSkLcXztslVyYMCMiIJaUKIp3CILwFHBYEIQDjFAMSRTF3wiC8MtAzGE0iKL4oSAIj3rnXIUk6rReFMW/TfRcwowduVzOFVdd7f89zND0Wp0kALfNzwhH40dJeK0FFkEQ+NLaAj482cbeGgMeUcTjFlHKBRbnBkSvLuCMZw0szovjneMt7KzqCsbUJo1jDUYAkiLVRGmnfnuZMKMn0ZtK2mIMrEhSj8XJrzeeAuDBlblETmL7IrlczrorQ3//9yn4xulUQc1CkcvlXHvttf7fARbm+gzUbjweEdlFlAUTZnIIWKhPFMWHBEFYDzyFVGMqIgkk5QmCkC2KYt1gTw3UHEaDKIqvAK9MxrXDBAaNRsPLr7052dOYMuhUcnLidWEZ+DGg0Wh48dXwWgskqdFa7liQSVW7CZ83c1Z6NDpVaGagjGe/WeBNeStr6sHmdI+pBU8osrtaMrgXBCgjw+0RMZgd2F1ulHIZsTpVWHAlxMlPlFK7D9YH1jD5w+YKOk0OcuJ13DnJ7Yuk/f+NSZ3DSJioFjMajYZ33nnnnL9NT4tCq5TTY3VS0W4atMQjTJiREtCTgCiKHwL5giCsQ0qZvc37ULUgCEYkNd9qpB6pAPOATYGcQ5gwYQYmTq/i1S8sC0dPw4QM/7OuEIVMxptfFRAFmJM1+annoihid3kAqU91ICIRqdEafx1qWXMP87NDM0o8WvbVSOl846k5M1ocrD/QyMcVnZQ39+I+r69LYqSa4uRIZmdGs7IwkaLkiPAeFkLMyYxBr5bT0WfncIMxIPWHRouD/+ypBeAbVxajlIedFCOhyywJJMVNoIKvD6VcxtysGHZVdbG/1hA2UMOMm6C4qr2G6oeCIEQDDwILkYzRK7xDjEjG6q9EUdwcjDmECRPmQsIHuzChRH/lz9wEPQ8sz5nQ69d1mdlV1UVZcy81nWaajVZ6rE585XQC0mGvICmCRblx3DA7dUz9pgVBYGZGNFtPd7DlVMdFYaC63B6ONUoKvnO8QlejQRRFnt/XwBMfVWJ1nm1RIgigkstwuj14ROjos9PRZ2dHZSdPbqmiICmCTy3J4vpZqUFTjg0zclQKGcvzE/igvI0tp9oDYqBuLGvF6RYpTIpgaX58AGZ5aXA2gjpxCr79WZQbx66qLvZUd/m7T4QJM1aCmkslimIP8JtgXiPMpYvZbKYoJwOAM7WN6PVhkY4wwcFsNlOSK621UzXhtRYMBAH0EyAw53B5ePd4C8/traey3TTkWBGpr2BXjYHdp5v55vWzUchknKqpJy56dG1VrpmRwtbTHbx+uIn/vaJoytdonWkzYXW60avkoxZIcro9/PjtcjYcawEgO17HVdNTmJEeRYJejUwmIIoifTYXLT02ajrNHG/q4Xijkcp2Ez96q5yXDzTyw+tLL4pIjdnuoqrDRJPRRqfJjsPl8TtHsuJ0TE+PCun2RPOyY/mgvI2TLb0Beb19NVLf09UhIphmNpuZlielGZ+sbgjZ/d/g7YEaH+QIqtlsJikpCYD29nb/+7E0L57HqWB3VVe4LWKYcROaxT5hwowQi8UyonGiKNJpctDSY8VoceIWRdQKOUmRalKiNUMqL3tEkW6zg06Tgx6rE5Pdhc3r8ZfLBCLUCuL0KpKjNMTqlOFN+SJlpGstTOiyr8bATzeU09BtBUAuQGlaNMUpkWTF6fxiP1qlHEEAm9ONwezgTJuJj8sbaHDacQJfe/EIf7p/KVGjEG5ZVZSIXiWnyWjlYH03C3OmdhT1aKMRgOlp0chGseeJosh3XjvOhyfbkQlw39IcrixNvsBgFwSBKK2SKK2S4pRIrp6RgtnuYvPJdl4/3ER5cy+ffGYvv759FmtLkgL5Tws6Vqeb3VVd7Kjo5EijkbquofcWhUxgVXEidy/M9PfVDSVEb1q2IkCtZtr7JMGl9BhtQF4vEEyF/X8iU3wHej/mZsWiUcro8u6ZF4PzKMzkETZQw1xUWB1uGrotNHZbqe00U9NlprrDTE2nGYvDPejzYnVKUqI1xOpUKGQCLo+I0eqky2Sns89xQV3UYGiUMjJjdWTH6yhIiqAoOZLpaVEkR40+LTBMmDCBwSOK/GlzJf/cVQtI3/frZqWypjhpyKitRiknRqciLzGClbkRbPF2+z7c0MND/znIPz+9cMSCRxqlnMunJfPW0WZeO9Q05Q1UX/3prIzoUT3vub31fHiyHblM4BtXFo3K4NKrFdw4J43LihL427ZqDjcY+cb6o/zs5hlTok9mR5+d5/bW8crBRmxOzzmPxeiUpHrvQWqFHI8o0mN1UtNppsfqZPPJdjafbGfdtCQevbpkUuoMB2O3V53aJ5g0XtweX2/VqZHC7fJ4qGgzUdFuoq3XhsXhRhRBr5YTp1ORHqslPzGCxMjgpt76U3wnaW2oFDIW5sSxvaKTnZWdYQM1zLgIG6hhpiROt4dT/dKJvvT8IRpNIh199kGfIwjSxh2lUSKXCdhdHgxmBya7i26L09/gesDnAlFaJRFqBTqVHJVChkwQcHk8WBxueq1OjBYnNqeHinbpRvXhyXb/81OjNSzJi2N5QQJL8+InJJUxjHRwaDRYae+zY7Q4cHlEPKKIXBCQyQQUMgGFXIZOJR0kUqI14c/mIsPp9vD9N07wflkbAFeUJnP3osxRqwX3z4yI1Cg42dLH4x9W8O1rSkb8GtfNTOGto828eaSJR9bkkxGrG9UcxorT7cFsd6FSyAKiknys0cg73vTcxXkjN7Qr2vp4fNMZAO5bmj3maGCsTsU3rirmbx9Xs+1MB99/4wSp0ZqQjC6CtA89v7eBv26r8gtwJUSoWJQTx/T0aAqSIgaNxouiSJ3BwgdlbWw7086HJ9vZW23gT/fMZWb66JwDwWBnZSc7KqX+vrfNzwjIa/oymnptg9+TQ4HTrX28fKCBTeVtmIdwgPtIjlSzojCBq6anMC8rJuDZVr4U3zj95NSgAiwvSGB7RSe7qrp4YEXupM0jzNQnfBILE/I4XB6qO0ycbjNxqrWXsuZeTrX0YbOeTTE5WGdEppKilHq1nJQoDSnRGtJitKTHaMmI1ZISpUExgEfW4nDR3mvHYHHQZ3Ph8YjIZQJ6tYIorYI4nYqYEfQVc7k9dJjstPbYaDJaqTdYqO200NBtoaXHxuuHm3n9cDMKmcDivDguK0xkRUH8hB1SL3bsLjd1XRbOtPZxsrWPsuYeTrf2+Q+EIyU5Sk1RciQlKVGUpkVJ8vnhrO0pidsj8t3XT/BBeRtymcBDK/NYWTT+uraHVubxu631vLi/gZVFiSwboZDLgpw4StOiKG/u5cF/H+S1Ly4bVcsZX6lCdYcJuUwgPkJNTrxuwIOuw+XhP3vqeO1QI+UtvYii5GjLTdSztjiJz6zIvSCF0u0R2VPdxdFGI91mBzE6SSCqICmC1GgNLo/I3moD3339OA63h1VFCf4WOiPhD5srcYuS6u+Vpckjft5AyGUCD63Kw+5ys6fawFdePMIrDy8NuWyVHquTb71yjAN1Ul1lQVIEt85NZ3ZmzIhSowVBICdez4Mr87iiNJm/bKuiwWDh8/8+wG/vmM2KgoRg/xMG5XC9kW+9egyPCHfMzwhYBNV3T2z0puKHGl0mO09uqeLNo83+v+lUcvIS9CRGqv1OIIvDjdHioK3PRkuPjbY+O68eauLVQ03MSI/ikdUFLApg3+ezBurkRdd9e+He6i5cbs+AZ64wYUZC2EANE3J0miTFxiP1Rsqae6nuMOEeIMNWrz57sPv8ylxyUuJIjdISoRndstapFOQkKMhhfMIHCrmM1GgtqdHaczz5Voeb0219HG0wcrjeSGuvjZ2VXeyslNKisuJ0LM2PZ1FOLPOyY4nVhU7q1mQhiiIWh5suk50Ok6Ti2WlyYLQ46bM7MdvdWB1uLA4XvTYnXSYHHX32AZsqqxUyEiLURGoUKOQyBKSUT1GUDuQujwer002PVXrdtl47bb12tld0+l8jUXv2lbtM9pAVyQhzFlEU+eV7p/zG6WjTSYdiZkY0V01PZmNZG7/deJr1Dy8dUTsauUzgsTtmcc/Teylv6eXbrx7jV7fPGlYAx+Z0s/5AA//cVUt1h/mcxxIj1awtTuLWeekszIlDBD6u6ODn75y8QARKBKo7zFR31PDPnbWsLk5kdUkSWqWcQ/XdbCpvGzILpT+5CXp+fsvMEUeBzrT1saOyE5kA9y7JDkj0SCYIPLwqn5YeG3VdFr65/hh///SCkEkN7TY7eOi5g1R1mFErZNy/LIdVRYmjqtntT26Cnp/cOJ3HPzzD0cYevrH+KE/ft2BSIqnHm3r48guHsTk9XFaYwC9unRmw1y5Mlgzd4UTMJoPjjUa+/XYFfTYXAEvy4riyNIXilMghP1eb082p1j72Vnexs6qTE029fOG/h7h5Thpfu6JoSB2MkdJlnpg+qEMxPS2aaK2SHquTY009zAvRrIYwoU/YQA0TEpjsLt4/0crbR5s51thzgaGhV8vJjtOTk6AjN0FPYVIkUQoXl/9SenxFQQJaXWgaDVqVnDmZMczJjOG+pSKN3VYO1XdzpMHImdY+6g0W6g0WXtrfAEjCENNSI5mWGsWczBhmpkdfdM3qRVGk3mDhUH03VR1mGgwWDGaH10h00Wdz4fKMrO63PzqVnMxYHbmJevIS9BQkRZAcpRnxgdBkc9FktFLTaaam00R1p5mmbittPWcP7Tc+sZMZ2UlcVpjAkvx4pqdFhdtdhCAv7Gtg/cFGBODLawsCnv5518JMtld0Ut1p5v0TrVw3a2Q1kKnRWn5843S++uIR3jjSTJ3Bwq9vm0Vh8oX1Wh6PyFtHm/ntB6f90SQBSIvRIghnW7C8dKCBlw40oFfJkcsEer2H5zi9ii+skqLGcXoVfTYXRxqMvLivgX21BjafamfzqfZzrhmtVbIsP56ECBUGs5OqDhN1XRZ/K5ikSDVrS5L4zPKcUR2qX9hXD0itKFKiAxfl1CjlfP2KIr792nGONfXw642n+e610wL2+mPF6nTz1ZeOUNVhJlan5NGrS8iOH/89SqOU842rinnsgzMcaTDy5ecP8/znF5M2gYJCLT02vvriEaxON8sL4nnq3vkBdQr46ppPNPfgEcUxG/TB4EsvHEFUqMmM1fK5y/IoGuB7OxAa5dlzwF0LM3ntcBObytt444h05vnDJ+aM6zN0uj30WKWU6MmMoMplAssL4nn3eCvbTneEDdQwYyZsoIaZVGo7zby4v4HXDzedk4qZn6hnRno0hUkR5CToiderLvC422xW5i5eBoAwRQwEQRDIjNORGafjpjnpWBwuypt7OdbYQ3lLL43dVpqM0o+vhlWjlHF5STK3zksPSt3KRCGKIidbevmgvI0PT7bRbLQN+xy1QkasTkWsXkmMTqof1qvkaL11wFqlHJ1KQYxOSbxeRbR2fCrKERoFxSmR54g7WBwuTjZ28cv352O2u0AQKG/ppbyll6c+rkanklOcEklJSiT5iRHkeg3jyFEovIYJLEcajDz2wWkAPrUkmyV54++lKMhk5+w3WpWCG2an8dL+Bv61u5ZrZ6aMeO2tLErkT3fP5TuvH+dwvZGrHv+Ym+ekc/PcdIqSI3F5POypNvD0x9WcbusDJMPwM8tzuGF2mt8wdLg8HK7v5v2yNjaVt2GyS4ZplEbBdbNSeXhVPtHas+swTq9ibUkSa0uSqO4w8e7xVs60SWnwWXE6VhUlsjgv7gJjw5fRIBMENErZqL9jZruLd463AnD1jJRRPXckJEVpeGRNgRTNPtBIaWoUt8xND/h1Roooivzk7XLKmnvRq+R899pS0mMDZ0AqZDK+enkhP367jNouCz94s4yn7p0/oih+IHhmezU9Vicz06P5270LAlLX3J/i5Eh0Kjlmu5vqDjMFSYFJHR4rMpmM6fOXUNUuZXMtyY3jC6vyR5We358YnYoHlueyJC+eJz6qoLrTzD3P7OXpe+cP6KgaCd0WKXoqCAQ9C0smk7Fq1Sr/7+ezuiiJd4+3svVMB1+7oiiocwlz8SKII1QnDTM8giCUlUybVrr7wJHJnkpII4oiu6q6+O/eenZ51f8A0mI0rC1JYll+QkgpFE4kJrtLUh/uNFPVYeJkS5/fKwpS7db/XF7IzFEqZybHRpKbl8+uCV6bbo/IsUYjW06389Gp9nOMUoVMoDA5gtyECFKiNMTqlUSqlehUcnQqOXq1YswHgGDSbXFwpMHIkQYj5c29fqPgfHLidczNimVZfjxL8+MDfoi7mEiLjyI3L49A7J1mu4vb/7qblh4by/Lj+fLagqA5dUw2F488fwi7y8PT980ftTJvU7eVxzad4aPzopj9iVAr+PSyHD65JAvtEN8Ht0ektstMe6+duVkxIfXd2XCsme+9UUZqtIbf3Tk7aJ/Ha4caeflAIwqZwD8/vXDU++RA+PbOnfsPj/g5Lx9o4Ffvn0YuE/jetdMoSR1dz9yR0t5r41uvHsPu8vA/6wq5d0l2UK7TH5fHw5rfbsPicPPSg0tYHADnz0Dc8/QedlV18d1rS7h1XmDEl8bKyZZePv3P/bg8IssLEvji6vyARXW7THZ+s/E0dQYLkRoF/35gEVlxI9elSE+IJj8/n1c37+bqx7cTp1dx6PtXBGRuY6Wt18biX2xGEODAd9cRHzF5ok1hJo/p06dTXl5eLori9LE8P3xiCjNhWB1u3jnewvP76v11VAIwNyuGa2akMiM9aspGBwNFhFrBjPRoZnhrikRRpLLDxNZTHWw708HBum7u+8c+PrUkiy+tLQjJ5u0eUeRgXTcflLWy5XSHX7gBQCWXMTcrhqX58czJjAnJ+Q9HrE7FmuIk1hQn4RFFmrqtVHeaqTdYaOy20NRtpcvsoLbLQm2XhdcPN6GUC6woSGBNcRKXFSWeE9UKE1h+t+kMLT02EiPVfP6yvKDuKREaBSsKEth8qp03jzSP2kBNj9Xyuztnc7yxhzePNrGjootOkx1RhJLUSC4rTOCeRVlEjWC9yGUC+YkRAROqCSTvn5AUlJcXJAT187h5bjo1nWb213bzzVeO8dJDSyb8u3aypZfffiApFd+zKCtoxilIkeP7lubw9PZqntxSyeUlSUFP9a3rsmBxuNGp5EFtlTQ3K4ZdVV2caOrl1nlBu8yw9NmcPPrqcVwekbmZMXxhVeCMU4D4CDXfv76Un75TTl2XhS89f5j/fHbRqNetwTT5Akk+kqM0TEuN4mRLLx9XdHDL3Ml1MISZmoQN1DBBp7LdxKuHGnn7aIs/2qRRylhTnMTVM1JCTnUxlBAEgcKkSAqTIrl1Xjov7m9ge0Un/9lTz77abn57+ywyR+FtDSYOl4c3jzTx/N566gxnFZb1Kjlzs2JZlBPHrMzoKWmUDoasX8p2f/psTiraTBxv7uFwfTdtvXa2nO5gy+kOZILU0Hx5QQJLcuMoTI6csNS8i5091V28eqgJgIdX5aFVBX+trSpOZPMpKUPA7nKPaX3PzIj2R/tEUcTlEUNG6Ge89Nqc7K6SBMeWjlDteKzIBIEvri7gO68fp7XHxs/fOcmvbhu5kNN4sTrcfPf1E7g9IgtzYrkmCOnM57OmOJGdlZ2Ut/Ty+OYKfn3brKBer967txckRSAL4r7lq1080mAM2jVGwm8/OEOT0UpSpJpH1hQEZa/WqxV8++oSfvhWGU1G65jWbVcIKPj2Z01xIidbetl6OmyghhkbYQM1TFDoNNl593gL751o5WRLn//vSZFqrpqewpqSxHGnPFotZm5dJblWX9t2KGRFkgJFfIR0g1yaH8+ft1RxurWPO5/aw+/unB30g99QeESR94638uetlbT0SCm8GqWMpXnxLMmLp/QiEBGyWszc5l1rr45grUVqlMzLllSZ71uSTZ3Bwv4aA/vrumkwWDhY183Bum7+iCTsND0tmpnp0czNimFuVkw4HXgMmOwufvx2OQBXliYzPS2wyqaD7TeFSRHE6VUYzA72VBlYVTy+NjaCIKCUXzwOi52VnbhFqYTj/LY2wUCrkvPlNQV8/02pvdDakqSg1L0OxO8/PEOdwUKcXsWDl+VPiGEsCAKfXpbDo68dY/PJdg7WdTN/FK1/RovJK8AVE+Q6xwU5ccgEqDNYaDFaSZ1AESgfB2oNbDjWguiwceq393HHY8KI9v+xEKNT8dXLC/nBW2VsPtXOW0ebuWnOyOuofZlK8RNgoJrNZnJycgCora0dUNV+dXESf95axbYzHeF2M2HGRPgUFCagnGjq4dldtWw51e5vDSMXYH52HJdPS2JmRnRA02OMhq7hB11kzMuK5de3z+LxD89wps3EI88f4vvXl06KKMi+GgN/3FxBeUsvADE6JTfNTmNVUdKERK8mEmP32Naar49hTryeOxZk0tFn41C9kWONRspberE43OyvNbC/1gA7QSbAvOxYVhQksCQ3noLkiJBSsQxVHvtASu1NilRzz+KsoFxjoP1GEAQWZMfyQXkbu6q7xm2gXmx8fEaKngbTaDqf/KQIbpmbzquHmvj1xtMsy48fUZr0eNhfa/BH77+wKn/U7c7GQ2acjstLkvnwZBt/2FzBvz6zMGjGcV8/Ia5gEq1Vsig3jj3VBl7Y38D/TrDYjkcUeXxzBQCrS5L4t9EQ9GvmJUZw54JMXthXz28/OMPKwkRiR2hwTnQEtbOzc8jH52XFEKtT0m1xsq/WwLL8yevXG2ZqEjZQwwSEmk4zv914mp39RI8KkyK4rCiBJXnxRIUVTQNKnF7F968v5W8fV7O9opMfv12OWiHj2pkja3UxXg7WGfjrtmoOepvPa5QybpqdzjUzUy6qFN5gkBip4arpKVw1PQWPR6TRaKWivY+KNhPlzb10mOwcqO3mQG03UEGMVsmCnFgW5cazLD9+QttJTBU+PtPB64ebEIAvrB67uuZYmZkRzQflbeytvvQcZkPh8njYWTnxBipI9ah7qg00Ga08ubWK71xTErRrOd0efvneKQDWTUv2awhMJLfNS+fjMx2UNfeyo7KLywqDYxAYvYZQjC749/SHV+Wzp9rAKwcbuXlOGnkTWF/90al2Trb0oVHKuGVOOv+eoOteNzOVXZWd1BksPLGlku9fXzqi5xnMUiu0iYigjgSFXMa6acmsP9jIB2VtYQM1zKgJG6hhxoXN6eZvH1fzr121uEUp+rOiIIHrZqUGpOdbmMFRymV8cXU+epWC98ta+f4bJ0iMULMwN3jCFUcbjfxlaxX7aiRvskImsLYkiVvnZYSFf8aATCaQFacjyxsBAWjtsXGkoZujjT2cbOnFaHXy4cl2f9uhgqQIVhUlsro4kWmpUZd8dLXb4vCn9l47M5VpQRSlGYxpKVEIQG2XhU6TnYSwaiUAxxt76bW50KvlFCWNrX3GWFHKZTywIoefbjjJ+gMN3LkgI2gCUi8faKC2y0KURsEnFmYG5RrDEaNTceX0ZDYca+Ffu2qDZqBWegUOJ0KMa1VRIquKEtl2poP/e+8UT907f0L2O1EUeWZ7DSDtKVHaiTsqy2UCn1mey4/eLuPNo83cvShrRG12DCFWgwpw5fQUr4Hayg9vKL3kRTDDjI6wgRpmzByu7+ZHb0vKcwDzs2K5d2l2QJuwhxkaQRC4b1k2PVYnu6u7+MFbZbzy8FL06sB+tTtNdn6/6QzvnZB6Gcq9hulNs9PCEvIBJiVaw9XRqVw9IxWXx0N1h5njTT0cb+zhTHsfle0mKttN/H1HDYmRalYWSlkKszJiSIi4sF/wxc5vNp6my+wgI1bLXZNkHERoFGTF66jrsnCo3siVpcmTMo9QY1+NFFGemR4dVEGdwZieFs2C7FgO1HXz+IcV/OnuuQG/hsnu4u87agG4c2FmwPfe0XDNjFTePd7C4QYjle2mgPcPdbo9ftGiiYgSC4LAz2+ZwbrfbeNQvZH1Bxon5Du+t8ZARbsJtULGNdNTwWMP+jX7U5wSyaKcOPbVGnhySyW/v2vOsM/p8qn4htD9+LLCBHQqOc09No439TArI2aypxRmChE2UMOMGoPZwV+2VvHKwUZEIFan5IEVuUGVnA8zODJB4KFVeVR2mGjpsfGnjyr5dgDT2T4sb+NHb5dhcbgRBFhVmMit8zJIjAydG+HFikImoyg5kqLkSG6bl0GfzcmRBiMH67o52miko8/Oq4ea/LVvsTolOQl68hMjKEmJZHZGDHmJ+ovWaN1T3cW7x1sRBKnuT6WYPCGOouRI6rosHG8MG6g+DnuNmcmIavu4Z3EWh+u72V7Ryb4aA4sCnGHy0v4GeqxO0qI1rClKCuhrj5Y4vYp5WZJB/tbR5oDXbR6o7abH6iRer2JuZkxAX3swMmJ1fPvqEn70djl//KiCy6clBT1D4eUDjYAUwY3QKLBaJtZABbhrYSYH6gx8XNHJ0QYjs4d5vydSJGmkaJRyVhUl8t6JVt4/0Ro2UMOMirCsVpgR09YrGT/X/GE7673G6eqiRH5zx+ywcTrJaJRyHrwsD4CXDjRQ2W4a92s63R5+9k4533r1GBaHm9wEPT+9aQYPrcoPG6eTRKRGyWWFifzPuiL+du8CvnVVMVdPTyEjVosAdFucHK438srBRn72zknueGo3Vz3+MT948wQbT7TSbXEMe42pgkcU+d0mqd/klaXJ5Ac4WjRa8hOlkob+quWXMqIo+t+LouSJTe/tT1qMlnVeh8HjmyvwiGLAXtvh8vDS/gYAbpmXMSlR4vPxiXRtKm8L6L8V4M2jzYCU9jqRqqz3Lc1hTmYMNqeH5/bUB/VaXSY72ys6ALiydGLUnwciLUbLqiLps/zb9uphx4diii/ANV5djA3HWhADvB7DXNyEI6hhhkQURQ7VG3lhXz0fnWrH491f8hL0fHJJVsBbOYwGQSZj2sw5/t8vdWZmRPvTgp7ZXs0vx9EPr9vi4OsvH+VIgxEBuGlOOrfNT5/y7WLGikwmo8S71mQh8h4o5TLmZsUy19sv0O5y09htpaXHRoPBQlWHiYo2E50mBxuOtbDhWAsCMD09mrUlSVw3M3VKOxo2lrVyps2EVinn9vnB77M33H6T4625P93WhyiKF23UeqS099npsTqRC5ARO7nCXrfOy2Dr6Q7Km3vZVN7GVdMDY3h8UN5Kl9lBnF7FkrzQcNLOSo9Bq5TT3menvLk3YKm4XSY7W05JdfB3LwqOSvZgyGQCX728kM88u59XDjby2RW5RAZJRXjDsRY8olTrn+5dt5O1/980J51tZzrYU23gZEvvkJkIPufjRERQZTIZCxYs8P8+FOumJaFVyqk3WDja2MOcCYq8h5n6hA3UMIOyu6qLpz6uPqdRdklKJNfOTGVBTuyki7NoNFr+8caHkzqHUOO2+ensqzWwsayNh1aZyU0YvVBVS4+VR/57iNouCxqljK9eXsiczIlV4Aw11Bot/3g9tNeaWiEnPzHiHPESp9vDmbY+jjQYOdbYQ73BwommHk409fDklkquLE3m85flkTOGdTKZuD0iT22Togo3zE4lcgJUwofbb9JjtcgE6LO5aO+zkxx1adfiV3vFdFKitSgnuQditFbJjXPSWH+gkSe3VLG2JCkgc3rloJRaf8W05JBx3qkUMmakR7G/tpt9NYaAGaivH27C5RGZmxVDadrEp2yvLk6kMCmCinYT751o4c4Fga9FFUWRN49IUeK1xWfTtSdr/0+O0rA0P4GdlZ38Z3cdv7h15oDj3B7RHzwYaVua8aDVatm/f/+IxupUCtaVJvP20WbePtocNlDDjJjQ2FHDhBQVbX08/NxBvvDfQxxpMKKQCayblsSvb5/Fj26czqLcuEk3TsMMTHa8ngXZsYjA0yNICzqfpm4rn332ALVdFhIiVPzsppmXvHE6lVHKZUxPi+aTi7P51W2zePKeeTywPJei5AjcHpH3TrRy+1938dMN5XSaJr7OaqxsOd1ObZcFvVrO1TMmLw2vP0q5jNRoKeJSFYAU+6lOTadkoKbFhIahft3MVKI0CuoNFt72pqqOh4q2Po439SATJOMplJjhzWw6WN8dsNf0CeTdtzQ7YK85GgRB8Edu3/fOJdCUNfdSZ7CgVshYkhcflGuMlutnSSmym062DbpHu73WaaxOOenOoIG4YZYvzbfZP9cwYYYj9FZymEnDYHbw83dOcuff9rCn2oBcJnD1jBT+ePdcPndZHllxusmeYpgRcJs33XHjiVba+2wjfl5rj42HnjtAa6+NtGgNP7phuj/FKczFQZxexRWlyfz4xhn8/OYZzMuKxSNK0ZEb/rSDP22uoCvEDVVRFPn37jpAqhHTqUInESjd26O22mucXcpUtEv1pxmxoXHf0Cjl3DQnHYC/bqvG7nKP6/VePyxFTxfmxBGjC626v0Jvze+Jpt6A1KGa7S5qvWr9Kwsnzxi/yuuMOt7UE5R6+k0n2wCpZ69WFRr9vHPi9RQlR+AR8Ud3z8flNfpCVVF/VXEiURoFbb129taEe0WHGRlhAzUMTreH/+6t57o/7pDEj0RYnBvH7+6czaeX5YRc0b0Pm9XCLSvncsvKudislsmeTsiQm6CnOCUStwivelPQhqPH6uSL/z1Es9FGSpSG711fGrI3u8nAZrVw66q53Lrq4llreYkRfPOqYn50w3QKkiKwuzz8c1ctV/9hO1998TBvHG6iqds62dO8gIN13Rxr7EEhE7hy+sSp5Y5kv/FFC32tty5lKtqkKHIoOTavKE0mTq+ivc/Oa4dGtjcOhM3p5l1vFG9tyeQq9w5EVpwOtUKGye6iqmP8zhKfwyUxUj2p94X0GC3T06LwiPj7QgcKURTZckoSRzpf6Xmy939fj+zXDzcNGIH0/W2iFHwtFgs5OTnk5ORgsQz/fqgVcq7zRlFfOdgY7OmFuUgIG6iXOIfrjdzz9F5+s/E0VqebnHgdP7yhlK9dURTyNVSiKNLa1EBrU0NYHe48rvKqVr42yA2tP063h2+sP0ptl5k4vYrvXjeN2BCLCEw2F/NaK06J5Mc3TufrVxRRkCSl/m6v6OQnG8q54Ykd3PrnnfxpcwWtPSOPxgeTZ3bUALCmJGlC1+lI1kCG1xg703ZpK/mKoug3ajLjQicLQ6WQcctcKYr69x012Jxji6JuO9NBn81FQoRqQvqBjha5TKDYG0XdX2sY9+v5UtaLkidXKRvwf34v72/A5fEE7HVPNPfSZLSiVsiYfV47lMne/5fkxaNXy2npsbG7+sIIpO8enzBBoneiKFJXV0ddXd2I34/b50s1w+8db8VkdwVzemEuEsIG6iVKj9XJj98u4zPP7qei3USEWs7nLsvlF7fMnNSedWECw6LcOCLUCjr67OyrGfqA8vtNZzhY141GKePRq0uC3mMuTOghEwQW5MTx05tm8JvbZ3HbvAyKkiOQCVDbZeGfu2q5/k/b+dFbZTQbJy+qerKllz3VBmSCJI4UamR7DdTKdtNF58gYDe19diwON3JBICU6tByda4oTSYhQ0Wly8MK+sbUs2XCsBYDLChNDVo/BJ2R0qG78dainvQ6X0hA4G9wxP5NorZLqTjNvHWkJ2OtuKj+b3qtRhkZ6rw+VQsYqb2r1+gMXRiD9BmqIZrsBzMuSenJbnW7ePR64zy3MxUvYQL3EEEWRd461cPOTO3n9sFetriSJ3981h3XTkkOij1uY8aOQy1iaL4k8+OpqBmJ3VRcvevv4fXltYUil44WZHDJiddw+P4Mf3ziDp+9bwFfWFlCaKqXVvXW0mZue3MnvNp2mz+ac8Lk9s12Kni7LTyApMrQMH4DUGA1ymYDZ4aYlRCLOk0GtLyU0Sh0y6rY+FHIZd3gVYJ/eXjPqddxlsvujWJcVJgR8foHC52g+0mAct7PkeFMPQEhEi6N1Sr5yeSEAf95aiTFAtajbzkjpvYtzQ0Mc6XzWTZOyonZWdtJgODet1hdJDuWyHEEQ/O3AXhnAyA4T5nxC684RJqjUdZl5+LlDfPeNE3RbnGTEavnxjdN5cGXehLRpCDOxzM+W1Hd3VHQO+LjZ7uLHb5cBcGVpMvOywmq9Yc5Fp1KwND+B719fyk9unM70tCjcHpHn9tRz0xM7eXZnDRbHxKRrVbT1sflUu7cvb9qEXHO0KGQyUrylEbWXcB1qg7d2OTVEy0QuK0ggLUaDxeHmv3tHF0X9oLwN0dsn06faHIrkxOuRywS6LU6axpH10GN1cqpFiqCGirLtvUuyKUqOoNvi5LcfnBn36zV2W2jstiITYEb65EeJByI1RsuczBhE4OUDDec85o+ghrCBCnDr3AxkAuyrNVAZVjoPMwxhA/USwOZ089dtVdz2l93srTGglAvctTCTX946k+KUyMmeXpggUZoahVwm0N5nZyD/+fN76739GtXcs3hiG6+HmXoUJkfyvetKefTqYtJiNBitTv74USU3PrGT/+6tG3M930j5+85aABbnxZEZwpF+X0rr+VGOSwlf9DhxgmriRotMJnCHtybuX7tqRxWF+8CbCrosPzSMtcFQKWT+lPNTrWOvid5Z2YmIVH8aKroUKoWMX902C5kgtb8Zb8334XojIDkdQkkV/Hyumn5WW8Lcr47TL5IUEbopviDtjZd7I8HPj9IxFObSI3S/iWHGjShKfQ7/uLmS1l7pwDArI5oHVuT6vfxhwO5y095rp8vswGhx0GN10mdz0WdzYba7MDtc2F0enC4PIlK9nlIuoFMp0KvlRGuVxOhUJESoSIrUkBKtIUqjQJjk2iSVQkZegp6KdhPnZ3j12Zw8u6sWgDsXZKJWhFbNTZjQZU5mLDPTY9hZ2clrhxtp67Xz2Adn+OfOWj61OIvbF2QSoQ7sraWuy8zGMkk19WZvq5Bg4nB5UMiEMZU8JEdJRlkoKiBPFD5BrdFEdNwekeNNPRypN9JndxKlUTItNYq5WTFB6e24OC+OnCM6qcZ6Zy1fu6Jo2Od09Nk51iilu4ZqKmh/suP1VHeaOdNm8qeIjpYD3hrWtSUTp5g9EuZmxXLtzFQ2HGvhlYON/L9rp435tXyfaVFyaDvsZ2XEkBatobnHxoZjLdy1UHKynI2ghraBCnDP4iw2lbfxysEGvnV1ccjV+4YJHcIG6kXK/loDf9xc6a8dider+OSSLJbmxU+64RQoBEEgt7DY//tQuDweOvrstPbYaOu109Zro7nHSlO3lU5T4PupRWoU5MTrKUyOoDQ1iuKUyElpoJ2fFOE1UM+1UNcfaMTqdJMeow2ZtK1QRhAEcgtGttYuBeQygZVFiSwriGfbmQ7eONxEp8nBHz+q5JkdNdy7JJt7FmcFrHTgL1urEEWYmxVDToI+IK/ZH5fHw9GGHnZWdlLRbqKjT+oFG6tTsqwggatKk4lSjmy/8RllLb2Xbg2q7/0baYsyg9nBYx+cvqAlynsnWtGr5dwwK42rZ6QE9DArEwTuXJjJr98/zQv7G7h/BC3VfHWKhUkRQW2/5nB5qO4w0dprQwSSItUUJkWiUozuHuLry1vXNfZWM752QbMyJr/+9HzuWZTFhmMtfFDextevLBqzo/VQvWSED5ZRFir7v0wQuHJ6Cs/uquWVg43cuUCq6fT3QdVPTMaCIAiUlpb6fx8NKwsTyYjV0thtZcOxFn9dapgw5xM2UC8yTrf28fiHFX4RB7VCxs1z0rluVuqob26hjkar4/n3dw74mMXh4kRTL8cajVS2m2jotg7ZbkWjkBGtUxKlUaJXy9GpFOhUcnQqORqlHJVchkImIAjgEaUbgt3pxuJwY7JL0Vaj1Um32YHRG4E93tTD8aYeXqMJtULGnMwYlubHMz87dsKM1VzvYb7/v9ztEXnJW8Ny05y0kFWhDCU0Wh3/HWStXcooZDIuL0lmVVEiuyq7ePNoE81GG099XM2/d9fx4Mo87lmcNa71fqatj/fLpLTKu7ziNoFCFEW/UFi716jqT7fFyTvHWvigrJVvX1My6H7TH5+B2nYJiyR1maX3Mlo7vIOivc/GT94up9PkQCkXmJ0RQ3yEih6Lk/KWXnptLl7c38DGslY+uyKXBTlxw77mSJmbGUNeghRl/M/uOr66rnDI8R9XSAaqr74/0NR0mnnnWDN7awx+o8NHjE7JTbPTubJ05GKGqdHj68vr9ohUdUgGakkIlgMtyYsnJUpDa6+NfTXdYxKt6rM5/fXixYNEUIfb/03e+31LjxVBEIjXqyhKjiQ5Sh1wg/aywgSe31tPdafZH/n1+Z8nqs2MTqejrKxsTM+VywTuXpTFbzae5t+7a7ltXnrY6RtmQMIG6kVCs9HKn7dW8c6xFkSkTeDykiRunZdOzCXS09LqcLO/1sDuqi6ONho53x5VygXi9CridCri9CriI1QkRqpJjFCjU8kDtkk6XFK0tslopd5goarDjMnuYm+Ngb01BiLUClYVJ3L19JSg12j5VHn7B1D31xro6LMToVZcEtFTh8tDr81Jj9WJ2e7CZJdSt31p3L02JyabC6vTjUcUkQkCerWCSI2CeL13rejVxEVIv0eqJz99O9RQyGSsLEpkRUECe2sMvHa4kcZuK3/YXMG7x1v41W2zxhz5/PPWKgCW5MUFNHraabLz1LZqf5aJXiVndmYMxd6DpQg0dlvZdqaDxm4rP3/nJI9eU3JBj8TzidVJRlmH6UKD91LBaJGUcaO0Qx8xRFHk6Y9r6DQ5iNeruG9p9jmRyWtmpnCssYePTrX7BXFWFCTwwIqcgNQKCoLArfPS+e0HZ/jvvnruPe/6/bE53f6WXYEWlGvtsfHc3joO9msJE6lWkOQ1cNp6bBgtTv61u5bK9j6+uLpgREZqmjeCWm+w+Pe20dDYbcHu8qBRysiOD3zmwniRyQTWlSbx3J56tld0jMlA9Yn1xOtVo874sDndvOR1ngzk/s6K07GmOJG1JckBCxDoVAqW5MXxcUUnbx5t9v9drZChV02NdNlPLMzkD5srONbYw8G67oA6ncJcPIQN1CmO1eHm7ztqeHZXrd/juiQvjrsXZYWMoEEwEUWRyg4Tm0+2s6Oi8xyvc7xeRWFyBDnxetKiNUTrlBMSLVQpZKTHakmP1bIoNw5RFGk22jjR3MPRxh76bC7eOdbCu8daWFOSxG3z0oMmD58Wo0Hg3Aiqr9/b4ty4SUk7Hg92l9S+o63XRpfJ4Tc6HW4PLreIy+PB7vJgc7ol49PqxOwIrHiPSi4jIVKqN06P0ZIZpyUrTk9mrBbFFHs/A41MJrA0P57FeXF8fKaD5/bWUdFu4p5n9vDLW2exsihxVK93uN7I1tMdCAL+1iCB4HB9N7/fdAaHW0QuE1hVlMDy/IQLDpElKZHkJ+p55WAj5S19PLWtmsfumI12iIOgL2poMDsQRfGSc2aIokiPVTJQ9cPUIh+s6+Z4Uw9ygQuMU5BSGudkxjA9LYqPTrWzs7KLHZWdnGnr42tXFPkzRMbD/OxY8hL1VHeY+e/eer68tmDAcYfqjTjdInF6FRmxgVHvdXtE3jzSxKuHGvGIICCl0i7OjSMjVutfOy6PhwO13bx7opWdVV3o1AoeWJ477OsnRqoRBLC7PBjMjlGrvPpSrguTIpGHaAu6ZfkJPLenfsxCUA0GqVbcZ8yPlLZeGz9/56TfEZUUqZY+MyTnVGO35KD+1+463j7Wwl0LMrmsMCEg+8GqokQ+rujko1Pt/nt7QkTgo7XBIj5CzS1z0nnpQAP/3FkbNlDDDEjYQA0ybo/IzspOdlZJKbfXz0xlRnpUQDaS3VVd/GRDuV8xcXpaFPcsyiI/KWLcrx3quNwetpQ18suHb8HpEkm5/3fIlBri9SpmZ0YzPTXKe3Oe/A1bEAS/wXpFaTIVbSZ2VXVR3Wnmo1PtbDvTwR3zM7h+VmrADRy1Qs7Nc9P5k/dt8IgiW063A6HTMmAwfHVYFe0mqjpM1HVZ/GJfo0UuCOjUUsq2Vin96Lyp3HqV9F+1QoZcJuD2iFidZ1O3e6xODD19HHvyi3g8kHL/72h2e2g22jjSYPRfQyETyE3QU5wSybSUKEpSI0NaETKYyASB1cVJzMmM4fEPKzjd1sfXXj7Cj2+czvWzRt4i5oktlQCsKU7y19ONB1EUefNIs7/3b0asltvmpQ95cFfKZdw+P4M/vH+CE3/4HLc/peDVjVvRaAdWEo7yGqh2lweLwz2skXaxYXN5/I5C/RDr3yOKfiXP5QUJQ9Z0KuUyrpqewrTUKNYfbKS9z8733jjBF1bns6JgfL1IBUHglrnpPPbBGf67t477l2b7P8P+7PGWzcxKjw7IfaXJaOXJLZXUeHvGFiRFcO2MgbNqFDIZS/Li0akUrD/YyKbyNuZlxTInM2bIa8hlAjFaJd0WJ+299lEbqBVeddxQVvvPjpe+h81jbKXT0iM9b6hsJpvVwmdvuQKAv7++CQdKfvneKTpMdmK0Sm6ak0bBeecuq8PNsUYj2yu7MJgd/GVbFTsqO3lwZd6428GUpEQRo1VitDr9+hITKZBksVhYuHAhAPv370enG72q+mdW5PDSgQbeO9FCY7eFjNjQVWYPMzlcWnfOSeAnG8p588jZNIyX9jewIDuWR68upnCMinFmu4vff3iGVw42AdLGdP+yHBZkx4aEQRZMLA4XW0518O7xFjq6e7G01QEwMy2KpcXpZMVpQ/o9kAkCxSmRFKdEUtdlYVN5G3UGCy/ub2BXVRdfXJ0fcBGYuxZm8qTX+13e3IvR4kSrlFOSGjqHDofLQ0O3hfouC7VdZqo6TNR0mi9I0wbQqeTE61VEa5VEahT+GmG5TEAuE1DKZai86U46lZwIjQKtcnwp3Harhc//SDpMf2l1PhZRQZfJQUefnbY+G609dqxONxXtkkG94VgLAlINcGFyJDnxOrLj9aTHaC+6WvChiNGp+N5103hmRw3bznTwwzfLcHtEbhqBEu/+WgMH67pRyARumzd+5V6Xx8M/dtTy0SnJQbMwJ5ZrZ6agkA3/eSjlMtaVJnGsqx4DYDQ7SBnEQFUrZCjlAk63FEm81AzUPpsUPRUE0CgHf29PNPXQ3GNDo5SNODUzK07HF1fns/5AIxXtJp74qBKDycENs1PH9f2enx1LVpyOeoOF/+6t5wur8y8Y4zdQh0nxHgkfn+ng6e3VuDwiKoWMG2alMjtjeMN3VkY0TUYru6q6+M/uWmakzxp2/UZ5DVSjdfRigKe9Bmppamj2BgX8hk23xYnV4R4yu2EgfCKJsUOUQomiSE3laQDcHg+//+gMrb02YnRKHrwsd8DUYK1KzuK8eOZlx7Krqostp9o53tTDN9Yf5StrC5k3jjpmmUxgQU4sm0+2I3oj78HKwhoIURQpLy/3/z4WSlKiWF4Qz87KLv6+o4Yf3jA9kFMMcxFwad05J5ijDUa/cbq6OBGXW2RPdRcH6rq58297uH1eBl9YnT8qNcB9NQZ+/Ha5v/H21dNT+MSizIteqrut18b7J1r58GQbTre0IfZvZXHL3HTUgxwYQ5XseB2fXZHD0cYe3jneQr3BwndeP84nFmZyw+zgiBf5Dlkz06NHdDAPBr7IaKXXCK3rstBstA5YwxOhVpAZpyUjVkt6tJaUaM2kH/jj9CpStTry+2WriqKIweygodtKXZeF6k4zBrOD6k4z1Z1nFTQFIDVGQ268npLUKGalR5N0kafiK+QyHlyZh1oh44PyNn66oZyMWN2wQjNPf1wDwNqSpHEfvuwuN49vquBwgxEBuG5WKotzR5dWVtLPobirupNbE2IGHCcIAhFqBd0WJ71W56hTB6c6vvrTiGFqtXdUdAJSRHI09y+tUs6nlmTxQVkbO6u6eH5fPT02J59anDVmI1XmjaL+YXMFL+yr5/5l2edkP7g8IlUdZgSkvXOsON0e/rWrls1eJ0lugp475qePqvZxTXEiRxuMNPfY2Hq6Y9j2MZHe/dL3uYwUURQ53tQLwMwQVPD14XNU9tlcNPdYyU8cXQZZl9nhfZ2R3Ve2V3RyqrUPhUzgviXZw352SrmMVUWJTE+L4pWDjTQZbfzmg9PcPCeNO+ZnjqmVFUjttm6bl8Etjwt4kEqaphoPr8pnZ2UXL+5r4MtrC4OqjB1m6hE2UIPIHzdXAJJx+vAqySN718JM/rOnjn01BtYfbOTNI01cNyuNW+elMyNt8NTfM219/H1HDRu9apYJESq+sDqf6Wmhe+MYL063VHez9XQ7R71qdQCJEWqW5scxLUHFF385iRMMAIK3xqogKYK3jzZT3tLHC/saON7UwyNrCob06o6Fw96U1NK0ifOIe0SRynYTB+u6KW/pparjwr6sIEVGU6I0pEZrSI3RkBWrI0anDOmIuA9BEIiPUBMfofan3fVYndR2mWnqttLaezbK2my00Wy0+dP+s+N1LM2LZ3lBwrhTv0IVmSDw6WU59Nlc7K7u4msvHeHVLywlMXJg4/x4Uw/7ag3IBbhh9shTggfC4nDxq/dPc7q1D7lM4BMLM8ekSNp/He6u6uLWRQPXKoIUPem2OOmzu8Y056lMt//AP/jB3eHysL9WEgQaS0RSJghcPSOFSI2C98vaeOdYC263yH3Lssfs2FucG+dXhH39cDOfXJzlf8zmdKMAchL0RGjGdmwyWhz8btMZKryiPGtLEllVlDjq+WqUclYVJfLuiVY2HGtmbUnSkK+h8xqoplGuRZ+TTauUDysMNtlkxekoa+6lqXv0BqqvXjpqhE6C5/fWg0zFFaXJoxI5TIhQ87kVuXxQ3sbuagNvHGmmutPMl9cWjqlv9PlOu4lS8A0kKwoSmJEexYmmXp7dWcP/Xlk82VMKE0KEDdQgcaq1j4P1RuQygTv7iXskRqr53yuKONnSy3N76qjqMPP64SZeP9xEZpyWFQUJzMqIJk6nwu7yUGewsOVUO4fqjYAUgbmiNJlPLMq8aOvbmoxWNp9s4+MznefcVAsS9SwrSKAgUY8gCNitY5POD0Ui1Ao+sTCTQ/VG3j7WwommXr796nG+vLaAGePw2J/PiaaJa0jea3Wy+VQ7m0+2+b3UPnyR0fQYLWnRGlKiNcNGXKYa0VolszNi/Ic7URQx2V209Nho7LZS3WmmvstCnffnxf0NlKREsjQ/nrmZsUFXeJ5oBEHgoVV5NBut1BksPLO9hu9cO23AsS95a0SXFySM632wOFz837unqGg3oZIL3Lc0x1+zNh7quqx09NkHnZvWGxG02AMr0DUVMFik73rkEIbcieYerE43URppHxgrywsSUCtkvHm0hffLWhER+fSynDHtIzKZwHWzUvn7jhpe2FfPJxZm+oWBbE43EcC0MdZi1naZ+c3G0xjMDlRyGZ9YmDHmEh+QUpI3nWyjrdfOyZbeIR3VvrU4WgO1vNkbPU2PDvmyhJx4PWXNvdQbRn8m8KWk60ZoJNpdHpLj1aPOwAApm+Tamamkx2p5/XAzxxp7+N4bx/nGlcXjrsGcihFUQRD44uoCvvjfQzy7q5bPrcwbsaMgzMXPxWnhhAD7aqToyJzMmAHTFqalRvGzm2dwqrWPTeVtHKg10GCw8sK+Bl7Y13DBeEGQPLy3zE0PSbn38eLxiBys7+bd4y2cbDmrxhelUTA3K4Z5WbEXffqHIAj+WqiXDjTQ1mvn5++c5P5lOVw1PXncxpvT7cFmc6GSy8Z1KByOXquTN480sbG8zd97Vq2QUZwSSUFiBDkJOmK0UyMyGkgEQSBSoyRSo6QoOZK1SPXkJ1t6OdrYQ22XhVOtfZxq7eOf1JIarWFWRgyzM6KZnhb6h8SRoFbIuW9ZDj/dUM5rh5v4/ACCIT1WJ++faAXgqukpY76Wzen2G6dqhYwHlucENN32cEM3V5YOPD9fyqrZcelFUP0tZoY4aB7ytlMpSYkcdynDgpw4ZDKB1w83s7GsDZkgcN/S7DHtL5cVJvDi/noau63srOz0q07bnB4igOKU0WeeHG0w8tsPTuPyiCRGqPnk4sxxp6yrvH2199d2s+10x4gM1NE6S8q8BmogHaTBIj9ROhP1L6cYKT7DXTuKNPO1JYnjUjWenRFDUqSG5/fW09Zr5/+9fpyvrC0cl5rtVM2+uWp6CoVJEVS0m/j79hq+dkXRZE8pTIgQNlCDRGW7tFHmDSF4IwgC01KjmJYahc3p5kiDkRNNPTQZrfR5DYkYnZIZ6dEsyo2bshvQUNicbj6u6ODd4620etWIBSTVwIU5sRQkRZxzgBFFEYdNqr/tH0Ht/7tKE9pCScORGKnmoZV5vHmkmaONPTy7q5a2Xhv3Lh17+hpI6ppKpLqnYNSfOt0eNpa1sv5AAw5vnXBatIal+fFMT4uaci1tJmKt6dUKFuTEsSAnjh6rkxNNPZS39NFgsNDSY6Olp5WNZa3IZQJzM2NYkBPL3KzYKe1lLk2N8h9IXjnY6C9/8LGxrBWXRyQrTjdmRXKHy8NjH5zxG6efXZFDavTojdPB1oDHaeNYTRuX5USi0eouWAM+A9XqvPQiqL6UySEjqN7axkBlcszLisXjEXnzaAvvnWhFo5Rz18LRtyXSKOWsLkrineMtvHqo0W+gOlwe73xHtx53V3Xxpy0ViKK0794TQL0In4F6oK4bh8szqANL7RWqGu1a3F8r9XxdNIZI4URT6jXQT7b0jvq5Nqf02arPe/9EUcTm/c5bLWe/+3qZi7xoBXarZVz7f2q0hodX5fHSgQZqOi08tukM9yzK4vpZoxf8yozXjakHbCgglwn8z7oiHnn+EP/YUcOnl+UQe5EHI8KMjLCBGiQqO6Q6k/QR9kvTKOUsyYsP+dYfgaK9z8amsjY+Ot2O2evZ1SrlLMyJZVFu3KD1Sw6blc9ffqHa25euX+j//enNZVNOMOl8lHIZt81LJyVKw8byNt470YrN6ebzK/PGbKQ6nGcN1EAiiiL7agw8v6+e9j6pJ1xKtIYrpyVRkBQxZZ0FE73WorVKlhcksLwgAavTTU2HmcoOE2faTPRYnRyokw6jAlJLqSV58SzOjR9zTdxkcvWMFCo+quS1Q4187rJz+zn6oqcri8Z24PKIIk9uqeR4Uw8KmcCnl2WPyTiFwddA0xOf4lXgVeCj43Voded+p1ReZ4zv8Hsp0WuTIlKDiZkZLQ5/u6hApFv7WJATh0eEt4+18PrhJvRq+ahaGvlYWyIZqNsrOjF605UTIlR87rJcYkahCbC9ooO/bK1CRFLfvWVuWkAdgxmxWqK1SnqsTo41GVmQPbAheXYtjtxAbeq2UttlQSZIfdVDnblZMQBUtpvoNjtGZeA43dJ39HwD32a1cPms7AvGn3rsEzz8mPT7ePd/vVrB/UtzeO9EK3u999C2XhsPLM8dlXiSRiGbUBVfQRDIzs72/z5erpkhtZA62dLLXz+u4jvXDFz6EebSYuqdbMaJIAgPAvO9/5sHrBdF8W+BvIYoitR6U00yw72d/Hg8IkcajWwqb+Owt6YWIFanZGlePPOyY1ArLm414tEgCAIrChPQqxW8friJLac7kAkCn7ssd0w3BbvLjZ7AGqgNBgvP7qql3Ou5jtQoWFeSxJysmKCoEF8qaJVyStOiKE2LQhRFWnpsnGrt42RrH609Nk4093KiuZd/7KxhXlYsq4oSmZMVM2nKzKNlUW4cEWoFnSYHx/oJoHWZ7P69YazOuv/srmNvjQGZAPcuyZqU/noKubT2fYffSwmzN2VSN0i7j0qvSFBSpDrg6vOLcuOwOd1sOtnOc3vqSYhQj3odpcdqyY7XUddlYcvpDkByIF9eMrRabn/21xr8xun87BhuDIIqu0wQKEmJZG+NgaMNQxioXsPLFwUeCb5e2Ytz40dllE8WyVEapqdFUdbcy47KzlEJq/nKUCbrfiWXCVw3M4V4vYr3TrSy+VQ7JruLR9YUhGzWkU6no7a2NmCvJ5MJfOPKIj77rwP8c2ct9y7JDvdFDXNpGaiCIPwKeMlnkAqCEAPUCIIwXxTFhwJxDY/Hw5mmTkwmMwqZQJTShdUiGasyuRy1+qxqpe/vA85VJkOj0Y5prM1qGbQ3lSAI5zSYH9VYmxXRM/hNrn8Uof9Yu8vN9opOPiiTRB0AZCoN+Yl6FufGkRurQhA94LRjH0AJv7+H0mG3D3r983E67Hjcg3uN+6fnDDdWqdYg8x7+XU4HbtfgtWWjGqtSI5PLhxxbmqjCPT2eN463s/lUOxEaBXfMTcXpHLyvnVKlRqFQeF/XCSLYXS48DhvJugvX02jWpkwmQ6ZU88rBRt4+1ozbbkMuE1hWEM/yvHhUChlOb1qkIJOh6ve6dpuVASV8AQQBdb91PJqxDrttyLV57hoa+djR4LDbET2BWW/9x7qcDuLVIsuzI1ieHYHB7KC8tZeypl7aeu3sr5VaV8XolKzKj+Wy/MHrtdUarX9tOh0OXK7BW0+o1Brk3rU5mrEup3NEa3NuZgwfn27lg6O1iKKIx+Nha3kjboeN7HgtepkLq0X6Pox0fX54so13DjcgU6q5bV4GeYkRQ4qpDbc+RyLE1j/9z4folPYp3+HXarXiGWLN6fVn987RjLXZbLiHWEejGavTnU1VttvtuIbYt4Yaa+ztw+OwIXPbsVrMF6y5M42d0j6kVV/w/gZi71ycqcfYq2VvTTd/eP8EEddNY1pG/KjW56LcOOq6LHxUJrWJ83g8g66589fm0epWfv/+KdwizMmM5qqimMH3w3GsTYDMSIHdDhvH69phRZ7/7/3v6x6HDY/DhsVqwWw2IwgCOt3ZPW6g9fbekVo8Dhtr8s+tuQ3ltbk0S8/x2nb2VHf5DdTh1rFWq/W/pU6nw7/fwMDf6/MZ7PMbyX39/LFL8+PRK2H9vlp2n27GajHzpTUFKPoZqeff151Ox5j7kIYaa0uSWJoXz+7qLn6z8TR/+MTcyZ5SmMlGFMVL5gfoBh4872+/kt6GgLx+GSAO9rNs9Tpxd1Wn/0ej1Q06du7iZeeMjYmLH3TstJlzzhmbkp456NjcwuJzxuYWFg86NiU985yx02bOGXRsTFz8OWPnLl426Fi5SiM+tvGU+O9dNeK/d9WIs5euGXQs4B/371014ryVVww5FhCf3lwm/ntXjbji2tuGHPfEOwf8r3v5rZ8acuxjr273j73mns8POfYXz230j735ga8OOfZHz7zhH3vXI98ecuyt33tKzH50g5j96Abxuoe/O+TY3z7zvP+z+N6v/jTse7Z09TpxV2Wn/2eotTl9/hJx1a8/8s9FqY8efL2VzDrn80tISR90bHpu4Tlj03MLBx2bkJJ+ztjcklmDjo2MiTtnbMncxYOOVWm0/nFPby4b8Vr7964aceGaa0Y8NpBr86b/e00s/cF7YvajG8SoRbcOOfa5d3f4P+MHvvzNIcc+89oH/rGPPPrDoef73Bv+sV//4a+GHPubp58Xd1V2io9vOiPGX/s/w77HMLq9U505Q/zcs/v8719kTFxA1udofiLiU8XsRzeIv3y3XOw228W58+YPOjY+IUHsNtv9P8svWznoWJ1Od87YK666esh59B970y1Dr43GdoN/7N2fvHfIsRW1jf6xn33woSHHvrbtkP9zu+dzjww5Nlh752/++ap/Dl//0dDr87fPPC++uK9OzH50g5h0/fDrs//e+fqhRlFQqgcdWzJ38TnrLVBrUxmfJb53vMU/j9yCwe/rmVlZYmefzf8zZ4i1GRefIPZn1apVQ67N/lx77bVDvm/9uf3224ccazKZ/GPvv//+IceWfvMlscVoETv7bOIDnx96bR46cUos+u67YvajG8Sb7x167Gh+RrM2v/PEC/6x9339x0OvY+/euauyU/xuv/t6aWmpeDFwvNEo5nxbOlccrDNM9nTCjJPS0lIRKBPHaFOFZv5A8DAAMef9rQtAEIS8C0aHGRMWh4uOvsEjnXKZcNG10JgIilOiWFsiiXbs9vbQnAyqO8zUdllQK2TcHUDRjzBjY2VRIt+4sog7F2SMuNl8KDArI5pgZLBFqBWTLxjizRZ0eSOok4XR4mDL6Xb+vLWKU/3U0S813jjSNKpIU1acpDQ+mgxti8PFbzaeHsPsAkOVV/cikIxDqHbS6LW52FNtGPF4Xzr+pZeMP3asVisLFy5k4cKFWK3WgL3ujPRobp+XAcD3Xj+B6xIskQhzFmE0m/bFiCAI64HbRVEc91YsCEJZUXFxae5n/0h5Sx8PrcplWf7Zg9LFnuIrKDVsLGvl1UNN2KxSOlJChIrLChMpTY08R5b9/LTdoVIj+4/tM3bzyLXzBh0LZ4ULLpYU3/5jBZmM1w83c6i2E5Xg4ee3zBjQ2D8/FWjtzGzSMrP5xxsfDvjaI1mbh+uNPPFRBW4EspJiuHthJlFa5bjT1M4ODq0UX7vVMqBATn/6i2QEK8V3tGuzxWjmUF03h+uNOL1qyjIBFubGcfWsLKalRSMIwqSn+AL89v0y9ld10Pynu8nNy8Nx/c8RRfjDJ+YQozsrlDbU+nR5PPzfu6eobDeTFqPm08vz0PdLYRxvim9/UayBeGfvSbS6c9PCX9jXwAdnjNy/NJuvXVE0oSm+TUYLOyq62Hamg+NtNnw2suhy+Ne9gCR+c/+yHGZnxgCBS/H9/L8PcKKply+vLWBBTuw5Kb52m51P/30PblHkK2vzL6hvDPTe2dpr4+/ba/DIlTy4qoDLpyWPeH0+/uEZdle00/T4HWRk5Qy5d6pUav6wuYK9NQYiZC4+uyKHyAGUtgOd4guS8X2sqZc7Fhdw+3zpcN//vv7xmQ7+sbOWZfnx/Pr2WcOm+P5sw0neL2vlvqXZfOfaaVMq/fwX75bz3IE21k1L5te3zxpRiu+632+nx+rkFzeWkBJ59jOzWixcv2RosZ4nNuwfsCRkLCm+AC6XE7dT2mePN/Xw+mEpxfzhVXksyYsfMMX3mgWFFBQUUFZWNuRcA4nZbCYiQlK0NplM53yW46XLZGftY9vosTr54Q2lfGZ57vBPChOSTJ8+nfLy8nJRFIc+SA3C1HG3BwFvDertwKOjfN5gO0G+IMio7HYhU2mYmZ2MVqcZZCgXKD8OxWjGakZRQzeqsZqBlTBdHg9bTnXwysFT/hYDSbGRrClOYkZ61LDiAyr1yKOpoxmrVAVnrEKpQqEcmXBEMMbeODuV9j47TUYrf97RyE9umjFkj0yFUgmCVDs60nV0/rj9NQae3NGAqNRQmhLJHfMz/NccTc2mepA1NN6x/Q9ygRw7GkJlbWYmqshMjOWaOR6ONfWwv8ZAc4+N/Y0W9jeeIitOx7UzU1leEI9WNbK1qVSpUI5wrEKplNbcCLh6ZgYlabH89kkBl0dycsVolaQmxAz5vP7rc/2BBqqNbtRaLfcsK0B/ntETrPXpQ6PVXvB9kQxWIw5vBECrHfnrjnRst8VBbaeNui4po6G6w8TJ1r4LslcKkiKYlyX1XbQ53Rxv6mFvjYG9jRb2vlzO9bNS+caVRecIr6nVatQjXM8XjFVqkKkc6PT6C96XXieISjVKQSAxLnrIe0Mg9s5srY6r53p470Qb/9xZy1xvP+2RrM/cBD17qhWIDL93bipvY2+NAUGAu5cXkjBCgZdArM3MpFhOtDuoN5x12vS/r6u1ZmQqDXK1ZkBDov96s7vc7Ko3IVNpuHFB3gXjR7OONZqR77OjGTvU2rz3smL+e7CdrWc66LY4iNUNv46V3ggqcuWozlkgfX7DfYajWscKJQqFtDYXFOjodsj4uKKTv+9toTgjkTTd2SO7b5+dqir5gxEfoeZbVxfz3ddP8NuNp7lyegrpAexfHWbqcEkbqMB64BVRFH8dqBd0uD14PCJapfySSGM93tTDv3bV0tgtpXnE6pSsLUliVsbQh48wY0chl1Jrn9hSSW2XhRf21XP/spygXe9AnYHfbz6DKMLM9Chum5cxriblYSYGlULGguxYFmTH0my0sr+2myMNRuoNFv66rYrXDzdyx/xMluXHT9ohZ0Z6NDPSo3lMEHB4+/RmxY380F7XZea1w00A3DwnfVL655lsbs4/1/rUN13u8Wco2ZxuTrb0cbKll8oOk5Ri32nGaB04oi0XBBbkxHJFaTJXTU8hc4D3s7bTzF+3VfHygQY2HGthZ2UnX11XyA2z0sb/3RbPRu3Pp8ssGc9RWsWE3R+W5MVzoqmXhm4rL+yr55E1BSN63khVRDv67Px7dy0AV5Umj2r9BoKkSMm4azIOnGrpW4ECw7/fW093YLK7SI3WsCA7NlBTnDBKUqIoSYnkVGsfe6sNXD0jZdjn+NrwuIeIDE8Wl09LosloparDzF+2VfGjG6ZfEvfeuxdm8dqhJg7WdfPtV4/x7wcWXXSGeJjhmZIGqiAI65DEjUbCSwMZoF5FX6MoineM9vqDhasFQShzusVSOZAao7mov1B9Nif/2V3HxxWdgNRSYE1xIgtyYoPa6kKl0fL0ZimA3T/9rn+qjWoMUZCpRrRWyR3zM/jPnnreO9HK3KwYZmXEBPw6J5p6+P0myTidlRHNbfPSLxnHw8W01tJitNw0R8uVpcnsrzWwq7qLtl47T2yp5MOTbTywPHdAQ2YicbolAzU1emTRFFEU+efOWkQRpqVEMjM9avgnjZKh1sCfdzTRZ3fR65KRdN7zFLLxtZkRRZHNp9rZcLSFXVVd/kjs+aTHaMlL1JOXoCcvMUJqTZQaNWgPUh85CXp+edss7liQyXdeO8aZNhM/equcf+2q47MrcrhqekpQWlx0myWjOmqA9NdgIRMErp2ZylMfV7O9QmpBMhIjMsnrYB6uCuq5PXW4PCI58TqW5k98H/OECMkp09Zrx+MRL+yf6Z3/SLbt97w9iG+fnzGqPpyhxKqiRE619rG9onNkBuogbXg0Wh2bj9Xxh80VHKxqpemJTwETu//LBIFb5qbzx80VVLab2FjWyrUzU4N6zVBAJhP49e2zuOYP29le0clL+xv4xKKsyZ5WmAlmShqooih+yNlepqNGEITbgTyfcSoIQowoisZAzM3t8SAH4ifBkz9RHKg18PT2Gn867+LcOC4vSUI7SN+7QCIIwoApNSNJtbnYKEqOZFFOLPtqu3lqWzWP3Tk7oIJFDQYLv954Co8IpamR3Dr30jFO4eJca1qVnJVFiSzOi2N3lYFtZzo41drHt187xm3zMrh5TvqkHUx9gkLJUSMzUI80GDnV2if1EZyVGhSH4FBrICY6ArPRNmAk0/c9GYtIUnWHiR+9XX5Of9iECBVzMmOYlhpFQVIE+YnSz3j33PnZsWz48mU8u6uGP2+toqbTzPfeKOPJLVU8uDKP62eljtpQ9f3bB/qn99mk90qnnlhhtYxYrb9P5huHm/jK5YXDPscXjR/qE6xsN7Gv1oAAXD8rdVL2xyitEpkgtTQyWp0XtJjyMHhEuz99Nhd7qiXxvdH0EQ01rpyezFMfV/NxRQc2p3vYe6LaZ6Cel+0gCAJanR6DQ4ZMeXZPmuj9P1qr5JqZqbx5pJmX9tezojBhQh08k0V+YgTfuLKIX7x7ip9sKGdxXnxAe7iHCX0uNRVfBEGYB1xxXuT0QW896rjx9b2L1l58G4jD5eEfO2r47Qdn6LE6SYxU8+BluVw/K3VCjNMwF3LV9BRidEq6zA5ePdQYsNc12108tuk0TrcUGbhjfjit92JCrZCzujiRr15eQHFKJB4R1h9s5KfvlNNlGnmv4UDiU2wcrIfr+Ww41gJIDrLJ2G99Ucpe24UCKGO1U442GLn/n/s51tiDVinnC6vzef9/LmP/d9fxzP0L+fqVxdw0J50Z6dEB23NVChkPrsxn+7fW8M2rikmIUNHSY+PHb5dz6192sflk26gUcH0G7UDRY7NdEsLRTcL9YqVX2Xl3dRdGy+AiST70KvmwRt3bRyURmzmZMSN2rAQamSAQ4V2L3QP8u3yZq8MZzxvLWnG6RQqTIihKjgz4PCeKuZmxpMdosTjcfFDeNux4nwF7fgTVR7d5+LUSbOZlxZASrcHhFnnveOtkT2fC+OyKPBbnxmFxuPnqi4cH/YzCXJxcUgaqt5XMeuCgIAgPen++BdwVqAiq7z4ejPSoycRgdvCDN0/4N/zl+fF8cVXepKcFRsbEERkTN6lzmExUChnXe1N+NhxrocEwfHPxkfCPnTW09dqJ0Sq5e1HmOc3CL1UuxrUWo1PxyUWZ3Do3HYVM4FRrH19ff5QTTT3DPznAuMWRO/eajFbKmnsRgKV5E/eZ9F8DWu/B1my/0ED1+OswR26p7qrs5KHnDtJnczEvK4at31zNo1eXUJISNSHlIpEaJY+sKWDHo2v53nXTSIhQ0WCw8vX1x/jCfw/R2D2yvWWoA7/NJRmoqknYT9JitGTEahFF2FHZOex4QRD8n/FAdJns7K+V2pksL5j41N7+6FSSgdo3gLPE5zQfag8XRZH1ByUH51RPpZTJBO5dmg3AS/sbhh3vW69214Uqwh5R9H+/I6JjJ23/lwkCa4qkFnPvHm/G6hhc8XiiSEhIICEhuO285DKB3981h2itkmONPfz6/VNBvV6Y0OJSO3UeBPKAp/r9jLSW9ZKlrsvM9944QW2XBY1Sxn1Ls7l6RsqkGy1qrY4n3z3Ik+8enLIpl4GgOCWSkpRIRFGqhxovh+u72VXVhQDctTDDf/i5lLmY15ogCMzNiuFLa/JJj9Fgd3n4xbsnef9Ey4TOw+M9SEdqhl9v+2okw6AwOeKCViXB4vw14EsNtA9giLn8RsHIDMsPytv4yotHsDk9rCpK5LnPLZ60iJxGKedzl+Wx9Ztr+MraAtQKGXuqDdz+191sPd0+7PN90VGr88JDtC+qOlnZGHMyooGz62c4hlJH31NtQASy43ST9ln5UPnX4oXvucsbQlUO8Z4fqjdS2W5Cq5T7+1BOZe5ckIlKLuNUax/Hh3G2+darzXnh99jhkhKkZSoNj799YFL3/5LUSOL1Khxu0Z+KPVno9Xo6Ojro6OgIaIuZgUiL0fLr22cB8MyOGt47PrH3pTCTxyVloIqiGCuKojDAz5jrWc/H5+i+WFIRmrqt/ODNMgxmB4kRar64Kp/CpIjJnlaY87hmRgoyAY429owr+uVye3h2Vy0Ay/LjR6xkGWbqEx+h5rMrcpmdEY0I/Gt3HS8faBhVeud48JWAjSR19Ui9EYCSlMlLRZQPIYTk2//VQxg4IEVo/vZxNd965Rguj8h1s1J5+r4FIeEUilAr+N8ri9n4PytZnBuHzenh6y8fGzZt0udgsNgHj/KMRFE2GExLlYS0zrSZ/PWwQzFUBNwXPZ0RBHGu0eLzFXsGKPz1r8UhosEfnpQ+0+tnpRKtm/rlSXF6lb+O1qewPBi+VH2r48Loc/8a8skucZEJAvOyYgDYVTV8BsDFxFXTU3hwZR4A33zlGGfa+iZ5RmEmgkvKQJ0I5N4bmmmAtK+phsHs4OfvnsTu8pAeo+Xzl+VOShuHMMMTp1exMEdKP3phX/2YjYqtZzpo77MToVawtuR8bdIwFztKuYzb5qVzxTTps3/9cBMvHxg+TS4geJesRjG0gep0e6juNAGQF6KiGTZv9DBiCDVdURT56YaT/HlrFQD3Lc3mj5+YO2TUbjLISdDz3OcWc+vcdNyiyA/fLKNziDplX4p2n/1CA9DffmeSWnpEaZV+1dvKdtOw4wfbRS0Ol/+QPJlOEh++dkYDKej7Itn6QYSp3B6RzSelyPi1sy4ehdiHVuUhE+CjUx1DOm19DhXzAGmz8n4OCs8EOeqGYnqa5Awpb+kNiTTfieSbVxWzODcOk93F5/51ICRqg8MEl9C6E14E+Lxsg/WomyqIosjT26sxmB0kRKi4d0lWyAkhOew2fvHIJ/jFI5/AYbdN9nQmndVFiShkAlUd5nMUQEeKKIr+9JmVhQkhd1CeTC6ltSYIAiuLErnW26LhjSPNI6rZCxRKxdCRisZuK0631Gt6pIJKgeD8NeALrgwUZfOJAQ1loP5nTx2vH25CJsCvb5vFT26aMelRmsFQymX85o7ZzM6Ixup089ye+kHH+j6TngHugb6azoHSKSeK9BipNUht5/A1tQNFJEEybkWkvt8TlWI+FHZ/lPTCPXu4tXig1kCX2UGMTsmKguDWFE4kRcmR3DwnHcBfXzsQPkXcgep3fXuRx2nnl1+6e9L3//gINbE6JR6RSY0iWq1WVq9ezerVq7FaB+6/G2iUchl/+dR8MmK11BssPPSfg35HYJiLk/AJNMDIvR7MyVLCDBR7awwcrjciE+DuhZnD9tWbDESPh1OH93Lq8F7EEGyyPdFEaBQszJGaq787hjqN0619NPfYUMjOphKFkbgU19rS/HhWFUkH1r9uq6K1Z2IOZvJhBIGajdKBKClSPaG9ps9fA77USc0ARkGvN310MAP6cH03v99UAcD3rivlzoWZQZp14JDLBL68VmrPsv5Ag//feD5JUVL/UMMAEY4ob3TVPEA65UQR7+8bOvx6dg7yXa/pNAOQHhsafZB9Qj4DCYz5HAVxgxjS75dJqrDXzhx9S6FQ55NLJMGnD0+2DShmBme/owOtZ4VMJjlVRJGKo/tCYv/3ld1UdQyfARAsPB4P27ZtY9u2bXgm8P2I06v4+/0LiVQr2Fdr4H9fPuIXAQtz8XFx7UYhgNIritFtdk7pL46vJuWywgSSJlkAIszIWZInqUkebeyho290TpIDdd2AVFM1VL1SmEuHtSVJ5CXocXtEXjoweNQskAy3a/oMn5hJrpXzp04OUC/a6zUKBpvj8/saEIGb56TxmeU5wZpiwFlbkkRxciRmh5vXDjUNOCY1WjLaBtp//Om/A0SrJgpfxGygCO/5uNwDr0afkyQ5cvLvjQ6Xx5+eGq9XX/C4wSx9DomRFz4GsKPS2/t01tTtfToY87JiyU/UY3N6eGcQp21S5OAOFZj8feZ8UqKl+TZPkMMw1ChOieSp++ajlAu8e7yV775+fNBMhzBTm7CBGmDkMgGlXMAtilM2imp1uDnR1AvA/KzYSZ5NmNEQp1f5m1mPNi3TV6czlXvghQksMkHgGm+q755qAx19wT8UDefY80U6JqOXZn98RtZAB1ifBkGM9sKolcHs8Kvhfn5l3oRGgceLTCb4o1K7KgdWEvWl0HaZHRccHH1GUrfFMWHiW+fjaytiGUEN32AGaof33j6RKeaDYfD2PtWr5EScp4AtiqLfUZAWc2G0t9vi8BtmczJjgjvRSUAQBO5dIrWceflA44BrLiVacjIM5tBNGsSwnyxivZHwidiLQ5Vl+Qk8ftdcZAK8uL+B7795ImykXoSEDdQAIwiQHS8ZCE3GicnNDzQ+qXoBwqJIU5CZXlXJQ96I6EhweTw0etdrZoikrYUJDVKiNf41cbIl+HVPA6ni9mcoQZiJpNtrGJwfmRJFkW6LZEQnRF64f751tBmnW2RWRjTT06KDP9EAsyzfl6VhHLCtSZxehUImIIpn3yMfKVEaBKQa1MmKovrcAeIwsXqPKPp7856PyVvXOdlOEsCfej9QT/JuixOzw41MgKwBHvf1zU6L1oScxkSguG1+BmqFjJpOsz81uz+Z3pRZk901YJrvZPd6Px+9ytd/+dKuv7xuViqP3TkbQYD/7q3nG+uPDnvvCDO1CBuoQaAgUTJQ67pG1tg81FApZAhIqXbto0wTDTP5+NoAVXWYRrxhG0wO3B4RhUwYsI4pzKWNL1I0lHrrePEFEocT0PGJEnmGTQYOHiabyx+BO78HZo9VKu+QCZAQcaHx+uohSbDlnkVZEzPZAJOfGEFylBq7yzNgP1G5TPC/J+ffP1QKmb9uc7IcuP4etcM4OIbaO53e+uOR9rkNJj4jM2cARet6g2SQ5cTrBxS9851RfE71i5FIjdIfHR5IPFCrkvuj/vUDnNnyEkKrrZ6vTngg59Clxi1zM/j9nXOQywReO9zE5/51YNDa+DBTj7CBGgR8XvGKEcjYhyI6lYIFXrGdzSfbQkJePczIidYq0ShkeMSztVLDYevXt3EqpRyGCT4uj8dvTARTFMYnYGsdRpkxwt+3cPIOaE090vuREav1p4z6aPFGtFKiNReIzjR0W2kwWFHJZf4+jVMNQRC4arqU9r2pvH3AMTnxUtRpICO02FtCUDtJDlyfWE6Udmjhv6F6mSu9xt5gKcAThSiKVHVIRqivBUl/mo3SWsxNHNgA9UUUC5NDywgLNHO9pUrHBmk3U+p97wYSHpoeAn1u++M7j012BkmocPPcdP5273w0ShnbznRw6593jaiFVJjQJ7zCg8C87BhAqukb6iYXytwwOw0BKG/p462jzSEr+KTSaFFpwimp/REEwd/6wGgZmTdR4bUOXCH6OYcCl+Jac3tENhxtodPkQCkXmJYSvMOazLsGTcOkfvpUWAcTNQkmvjVQ4zUKBqrXbuiWDK/cAaJS5c1Sbf+0tKiQVEYfKTd6jesPylsHjFjke7M4BsoimpkhOXBPtvROSh2qLwtgMNEgHz5HyUDuumhvredkij2B5AzpMjuQC1CaeuF3s94bXR2sX3B5i7QeS4L4vQ4FFmRLBupgZS9FXgPd9371J0qjpCg5AkGpRqGafFEsX3r5+fXGE41Op0OnC43058unJbP+oWWkRGmobDdx4xM7eOXgwDXHYaYOYQM1CJSmRvlToA7UXZgCNRUoSo7kS2sLEICDdUb+sq0q5CLCaq2OZz4q55mPylFrQ2OjDBV86VzDRaN8+IQX7C4PlklsARGqXGprzSOKnGjq4c9bqzhYbwTgq5cX+duEBANfe5nh1FV9tXStPbYJdZz51sDfNpdR0S19R+YO0I6p2mu8FqdcaLwe90ZwZmdMvdrT/szPPquOuqf6wnvcjHTp3zdQr8Y5mTEoZALdFueABkGwaeyWorrDpbUOVeOX4lUqHkmrmmBy0GtwLcyNQzeAmrQvIlgywFq0u86KIfqc6hcri/LikAlSBkNT94VRfd/74/vuns8Vs7LJ+t9XmfadN5BPspE6UgdLMNHr9ZjNZsxmM3p9aKSHz8yI5q0vL2dZfjwWh5tvrD/K5/99kPZJ/o6GGTthAzUICILATd4G0a8caJyyzYSXFyTw1XWFqBQy2nrt/Ht3Hc9sr+FAXTd94Tz/kMZXnzJSEQ+tSk6GN32zsn3gm3SYixuXx0Ndl4UPT7bxh82VvHSgkfY+O2qFjC+tKWB+dnAVvRXedNjh6lwz43To1XJsLs+k1DFWd5jpsTrRq+TMzoi54HFflHQg49XXymlhTlwwpxh0BEHgssJE4KyR1J8F2bEISBHU8yPdGqWcywql/rq7BzBug4nR4vC355gxQEpsf3zzHqjiwWfQnJlEp22fzel/76+YlnzB40aLw2+Mzx5AoXdvtQGr001KlIaipItbuT1Ko2RRrvSd++j0hWnpM9OjEQRo7bUNmJmxJC+eOL2KXpvL/x2eLGp9adlJF3da9lhIitTwn88u5ptXFaOUC3x4so3LH9vGsztrcIUFlKYcYQM1SHxqcRYJESqae2z8cXNFyKbIDseSvHievGcu185MQSZAneH/t3fn0XHd9d3H37+Z0Yx2a5fl3bLx7jixE7LHhISEJKWBLKUNWxdISqF9+vSBUHh6nlJamiYtPQFKaYAupxQoSSBAS8BkX2iwYzt24k1eJFu2JVn7Ppr19/xxr/aRLdmS5o78eZ0zR9YdS7pX89Gd+72/rZ8f72ngkW2H+dqLx/jZviYONnar1c1D4snk0JvsVJZBGCxAflXbpq4xc1w0nqShM8yek538fF8T//xqHX/99CG+9WodLx1upb0vSn4owN2bF/IP923m2pVlM75Pg2tIn2vctN9nhgrDPSc7Z3ivxnvliLN807Ury8ZNPHOqo5/mngh+n2HzmCW6GrvC1DT1YBherziTXe3O5vvKkZZx54uSvCAb3VbU7XXjl6N5t7t00f6Gbk51zF4r6o46p7hYV1U4NAxiIo1dE+dw0+IifMZZmiRd492efquJhHW6p65N0b339ePOsa6ZXzDUQ2akF2taAOe1GOxeP5fdvrEKgJfc4x6pIDtraAzvzuPjb5oEAz7ee+lgt/Yzk1pDdyZ0hWMccwvUSxYWpWUfvM7vM3zixpX85JPXsWnRPHoicT7/Xwe44yuv8sqR8a+9eFfmDoLxuMKcLL507yY++u872V3fyRf++wD3X189o5OMzJSC7Cw+fPUyfu2SBbx0uIWdx9s51tJHU9cATV0D/M8x5wKkLD/IouIcFhXnsqgoh8rC0FCryEyIRiJ89XMfB+AP//rrBEPeWq8sXWqaeoklLPNyslKufTeRW9fP56dvNnKyI8zu+s4ZbzHLJJmUNWstkbizjEdXOEZXOEZHf5SO/hid/VHa+2JD63SOVZAdYMOCeVy2pIgrlpWMmwBoJgUDzs+qTbEUxFg3r63kf461sbu+k62rymdl5uloJMLffOpjnO4IU3HX51JOcjQ4q+21K0rHjTHdtv8M4HTHTGf3vOlyw9vKycny09A5wN5TXePW0bx1w3zePN3F9tp2bttQNeq5paV53PC2Ml4+0sqP9zZy//XLx00oNd26wjFeq3Xeq+64pOoc/5uhwjPVpHH5oQC3rp/Pz/Y18fP9TTxQWj3j+z/SzhMd7GvoxgC/fc3ylPv48pHhAjSVwe7m183CzScvGFwe6VBTD4mkxT+mKL913Xz2ne7m5SMt3LJ+9O8sEhngZ1/6Y3qbe8m7/UH+8/WT/PY1SwkFZndpnhdqmrHWucGSzmvJgYEB7r77bgB+8IMfkJ2d/rG5Y62tKuSHf3At391Rz5d+UUPNmR4+9M87uG5lGZ+6dfWcXPd3rlGBOoM2LS7i7+7ZxIM/eJOaph4+9cRetiwt5h2ry9mwcN6sXvxNh5K8IO+7bCHvu2whnf1RDjR0s7+hm4ON3TR0DdDaG6W1N8qek84bn98YygtCVBaGqCzMpiw/SElekOLcYMop76fKJhPsfe2FoX+L0+3rR3tOA7B1VfnQkhyTUZwb5K7Ni3h850l+vLeB3KA/5Z35i1G6szZYdIajCfqiCfqjcXoH4vREhj/2DMTpjcTpGYgRm8TsovmhAIuKc1hSksuy0jxWVuSzsDhnSpmZTtlZPmI43UI7+6NnbeFaW1XAqsp8Dp/p5ak3TvPhq5fO+H539Q1wdNcrANyypiJlkTnYanXDqvJxzz1/0Ola+OsZOnvvWDlBP3dcUsWTu07xne314y74blxdzt9uq6GmqYfW3si4JXfuu3IJ2+vaaeoa4Kk3TnPvlkUzNoN4Iml5fOdJ4knLyop8Nqfofj1SNJ5kr/s+NlHj4nsvXcjzh5o50x3heztO8ptXLJ6W97Vz2Xuqkx/vaQDgrs0LWZ5iAqRTHf0cbe7FZ+D2FAVqY9cAta19+AxsvkhuRC4vy6cgFKAnEudIc8+4iaFuXV/Jl587wrGWPo619LKifLgLbTKR4FcvPQtA0R3OOObvbD/JB96+mNAsXcdtr2tn14lOAN532cJZ+ZkTSSQSPP3000P/9iq/z/Chq5bynkuq+PJzR/iPX53g1aOtvHq0la2ryvn9rSu4qrpEKxd4lArUGbZ1dTlP/cE1PLKthhdrWth5ooOdJzrw+wwrK/JZv6CQ9QsKWVVZMKt3YC9UUW6Qa1aWcY1797U7HONoSy9Hm51HXUsfPZE4Td0DNHUPAKOnd88L+pmXk0VhThbzcrIoyA5QEAqQnx0gLxggN+QnJ8uvZU8mKZ5Msqe+k+cOtTAQS7K0NJd7tiya8ve589IFnO4M88ujrXx3x0muXF7CTWsryMmwmynTIRpPEo4lGIgl6Okd7ob41qkuCEaIJ5LEE5Z40pK0zmNkT0djnNYX4/7bWmfyoUTSEk9YYokk0YQlnkySSNqhR9K6zyct0XiSSDxBJDb1VT9zsvyU5gcpzQtSXpBNeUGIiqFHdtpngQQ40NBFjju5S8BnWFlVwMHGHnYcb+eWdalbfsD5vT6wdQUPPvkmx1r6+OHu07zvsoXjWkWmS1c4xre3nxj6/K4t44vME2191LX2YQy8c03FqOfC0QQHm5yxqXOpxer3rlvOk7tO8cKhZnoGYhRkD7dkLyjKYcvSYnad6GDbviY+cNXSUV9blBvkwXev5q9+epC3Tndj7SnuvHTBtN+4DccSfP/1k9S3h8nyG/7wnSvP+Z7yy6OthGMJquZl0zjB/ynMyeIz717DF58+yJHmXr7+0jHevX6+M+PrDLxnReNJfnHgDNvdVvqb1lRw9+bU5/ht+5sAJ2ul+eNvpDxzwHl+85LiKQ0DyWR+n2HLsmJerGlhe237uAK1ND/ETWsr2Lb/DD/b18Qnb1yZ8vv86W1rePi5Oupa+/jHl2q567IFM7qObH80zjMHmofGvr7/isVDk5DJ5BTlBvnz96znd69dzqPPHuFHe07z0uEWXjrcwvoFhXzgyqW8Z1PVqPOXpF/6r1AuAguKcnj0/ZdS29LLk7tP81JNC6c7nfFINU09/HD3aUIBH2uqClhTWcjKynyWl+UNrfeXCQpzsti8pHho3JW1lpbeCPVt/dS393OqI0xT1wCNXQOEY04rUF80MTRhxUQMztqcQfcR8Pnw+ww+A8nY8Bihb75SiwnmYFMUCT5j8BlDwGcI+A3BgI+cLD+5QT+F2U6RXJKXRUlucNbuhl4oay1d4Rj17WGOt/VxoKGbPnddyPnzsvljd3KrUV8DvFHfwaWLiya8gPIZw8e3riDo9/FCTTPb69p563QXVy4v4ZJF88a1gmQiay390cRQ99fBR2c4RnfYaYHsjcRHtUImo8M5fWpPA740zeQY9PvIzw5QmB2gMCeLopwsinKdXgnFuc7NnqLcIEW5WZ7vodHWG+Erzx+lNxIfWtvvjo1VHGzs4em3mrhpTeVZC86FRTl88saVfOW5I+w91UVnf4w7L10wrd1nrbXsb+jmR3saCI9YsilV177HXz8FwC3rKsdd9L9W20YsYVlcksPS0rkzC/TaqkJWVuRztLmXlw+3jus6+5Grl7LrRAc/29fEu9ZVUlE4+u9m/YJ5fOIdK/nai0fZ19DN6c4wt6yvZF1V4QW3iFtrOXyml6f3NdHeFyXgM3zqltVUFp79bzcaT/LDN5xeKO+/YjG7z/J/11YV8me3r+XLzx+htTfKf2yvZ3FxDpctKWJ1ZcG0zHrd2R9l76kuXqttG5pZ+LYN8/ngVUtTnsdPdfTz/CGntf4DVy4Z93wskeR7O04CcO/lU7+JmcluXlvJizUtbNvfxEeuWTbu+Q9dtZRt+8/wy6Ot3L5hPtXl4yciqi7P48/fs55Hnz1Ma2+Ub716nNXzC7hyeQkryvOmpSdHImk53Rlmf0M3u+s7GIg5E/zcvrGKO+dID4x0WFySy5d+YxN/dNNKvvFyLT/YfYr9Dd187qm3+Iv/2s/N6yq5bcN8tq4qV7HqAZlTAc0B1eX5PHjraj59yypOdYTZeaKDHXXt7Khrp60vyt6TXUPdigAqCkIsK8tjeWkey8pyWV6Wd86JHbzCGENFQTYVBdlcPmbGyt5InLbeCC09Edr7o3T0xWjvi9IZjtLVH6N7YLibogUG4kkGUqwnO7JoaOyK4Ate+BtDfihAWX6QsvzQqI9FucEZa505m1gi6Y4hdH5Hrb0RmrsjNHUP0B8d3bVmXk4Wd166gFvWVaYc+9vUNcAj22q4/4ZqblxdMe75QX6f4f4bqrlmRSn/9j/HOd0Z5oWaFl6oaaE0L0h1eR6LinKoKAxRmhciOyt9rdyJpNMS6TyGWxwHYkn63a6wPZH4UOHZPRCnOxyb9HqvfmPIDfkJhoKcdLetqyogNy+fLL8h6PcR8Ds3Tfw+p7UUA7itpRZIjvhZfp8h4PcR9BtCAf+IGy/Odr9xvk+WeyMlFPCTE3RupuQFA7PShXCmJa3l1SOtfHdHPV3hGCvL8znlrjZ51+aFfPOVOpq6Bvj+6ye5L8UF9khXryglGPDx6LOHOdHez1efP8raqkLevqyYZWV55/032x+Nc6Cxh1/VtnGm25lVeFlZ7lAGxnqjvoNd9R34DHx864pxz/+nWxDcsm7+nOsRcsdGp/vcd7af4PaNo4/v+reV8fZlJew43s63Xq3js7etGXf8172tjMrCEF9+zinyvv/6KXeSJadn0YJ52ZOeyyBpLWe6Ixxp7mFPfRct7ozQJXlBPn3r6pTdYUey1vLYy8do6YlQlh/k/Vcs5jPn+Jlrqgr523s28ZM9p3n6LWcM/8mOMNBIeX6IRcU5zJ/nDHEpcnsNpeoZlEha+iLOuPGW3giNXQOcaOunccRN3IqCEL933XIuSTF7NEA8keQfXzxG0sLWVWXj3nsBXjrcQnNPhPKCEO9Nc1fR2Xb7xio+/5P91JzpZc/JznHd0tdWFXLbBmds8ddePMoX37sx5Y2+FeX5/M1dl/Cd7fW8WNM81NiQF/SzvDyPJcW5VBSGKM4NUpgdmDC/sUSSvkiczv4Y7f1RWnqc1/10R3jUNc/Cohx+77rlGnIzTZaW5vHF923kU7es5ge7T/G9HfUca+njp2828tM3Gwm4k9xdtaKUty8rYdPieSpY08Bots7pY4zZv2bt2nWv7dwzpa+z1nK0uZcdxzvYe7KT/e6d5FQKswMsKs5l/rxsKgtDlOWHKHULqeI0FVEzJRpP0heNE4463SwHYkliSadbZdJaIuF+Pv1rlwLw90/vJSc3z1lL0QzVCEMtqvGkJZ5IEoknGYgn6Isk6HYnj2npidDcEznrout+YyjOy6I0P0RJrtNKVZgdoCA7QG4wQG7QT3aWf1K//6S1DMScfeiLDI8f7BmIjRhH6DzOto6pMbCsNI818wvYuGgelyyaR8CX+o3whrULKKlaQvZvPkp2lo8/u2PdqDE2E4knk2yvbeflIy3sO91Fqrou4DNDx5/l9xHwm6FCy2ntNvh8zu/QZ4zb9RXccm6oe2wiOdwFdmR316HP7XDX2FjCEk0kL2h27Hk5WZTmOX87JflByvKcv6VitwWyIDtATpYfYwzh/j5uusTpovjcmyfIyfXG2m+ZIhJPcORML/saunjtWBvNPU7hUF2Wx1fvu4wt1ZUsr67mtZ17+MWBMzz45JsAfPjqpdy24dxFXVP3AN9+7cSoJU9ysvwsLslhYVEOZfkh5uVkkR9yMur3GSzOBf1ALElvJD50LqhvD9PQGR7qUh3wGX790gXcuqqId1+2HIDn3xrOQGd/lD/70T5ae6N8+Kql/Mktq0bt2+t17Xzs27vI8hte/PSNLJzCxGWZoK03wvWPvEB/NMHDd2/k1jETzBxv7ePex14jlrD81tsXDy3BNlZ/NM5P32zkJ3sbRvVe8PvM0M3CwuwA2VnOjR2Dc14fiCXoGXBevzPdESIjLuwDPsNtG+fz3ksXjpu0aqx4Ism//vI4zx1qxm/gnz64hSuWl1BZXMDCJcv5zs9/ec7fRWd/lJePtLKjro1jE6ypCc641lDAeb+w1hkmEElxE3bQ2qoC3rGqgmtWlk54jk9ayz+/Wsfzh5rJC/p58vevHtdiDfAnj+/lpcMtPLC1ms/etvacxzTXfPqJvTyx6xR3blrA/3vPunHPd/RF+a1vbaelJ8LlS4v5Xze9jVgkPOH5v6EzzM/3N/HasbYJJ58L+n2EAj78foO1zs2IaDxJ9CxLn+SF/FyysIjrVpZx6eKiCWdavnH9QlasWMH+/fun8mu4IH19feTnO9cPvb29nlkL9XxZa9l3upv/frOBZw6cGTdRnzGwvCyPtVWFrKksYGVFPsvK8lhWmkfOJJfyuxitX7+eAwcOHLDWrj+fr1eBOo3Ot0BNpSsc41BjN4eaejjo3p073tp31nFoPuOMoyjPD1FW4Lyhr60qHJruf64J9/fxzo3Om8bIC8bz1R+N09g5QENXmIbOARq7wjR2DdDYOXDWN5KRAj4zqkgbvK5OWqfYi8XtpL/XoFDA50w2VZDN/KJsFhfnsLg4l8UluZNuUbth7QKqq1ew5pPfZM/JTvw+w8euX87WVRO3pI7VH42z/3Q3h5t7qG3p43RnOG3T7Y9ljHsRkOUnN8tpdSwIOTcQ5uVkUexOzlWa50zUVZIXnNIM0ypQp6a1N8KLNc2c7gxzsj1MQ1d4VNf77Cwf919fzX1XLiUY8LGgtHCoQAX4ynNH+JdfHgfgquoSPnHjykmN0T/Z3s+2/U1sr2s/6w2nyVhamss1K0q5aU0l+dmBlOeb7oEYf/XfB6lv72dxcQ7ff+AqcoOjC6EHvr2L7XXtfPjqpXzhzg0XtE9e9eizh3n02SMsLsnhqT+4ZlwR9b0d9Tz88xqAsxap4IzX3eX2LjrU1E33FF/HUMDH2qpCLl9WzDUrSse9Hql09Ef5+18c5khzLwb48/esG2pdrCwuYMGS5dz70OPctmH+pLvO9wzEOHyml9rWXk51OO8l7b2RoaEYqfiMM1ld1bxsFhXnDi0hc66eU/Fkkq8+f5Qdde0Y4Eu/sYmtKSbqeqO+g4/++y4M8PM/voHV8+f2+qepbK9t4/3f+BVBv4+ffPLalEMC3qjv5Pf/YxfxpGV1ZQGfuG4Rd77d6Rkx0fk/nkhytLmXA43dHG/r41RHmNbeyDknrAv4DKX5QcrzQywociatqy7PZ2lJ7qSW/1GBOv3q2/p55WgLO+ra2Xm846zrbZflB1lYnMvComwqC51eg2X5QUrzg8zLcRoy8rMD5GYFyAn650QvqMlSgeohxpjuYDBYUL1ifBev6ZC0TqviyC6NcbdFMZEcPfZyUF7IT/EcnQQhmUxy4tgRAJaueBu+Ce4sX6jBO54jf9fxMS185/NnZAyjWhn9PoPfgM83+O/h57jAhvG6IzUEg0GWLq+mpSdCXyRBcV4WeZO4eDsbC0O/h6R1W6zdJyzD/x764G4fyzDc8j34cdQ2hltdR370meFlIGay70AymeRErZu16pnL2lwRTSRpdrvGDvL7zdDY77xggJGNojWHDhIMBhk8d1rr3KRr64uSneWjLC80pRfYWqf7XMQ9X8YTTgt8Mjk6k4Ot+YN/a4Pdr4MBPwH/6B+Y6nxjrVOMxxOWBUXZ48d9W+jsj9E1EGNJce647zlXJK0zSVReKEBJXnDczLfWOkVgR1/MOe9Mdn4Ft/dLLJEc1ati6HzrzjEwsmt8wO/jHA3u43+MhTPdAySSlsrCbPJCw0XooYMH8QWyKKhYRHFu8ILPM4PnzMEePs45z5lXwWfMeX1/i/P77Y8mqCgITTh/RTSepLU3Qijgp6Iw8+cTOF+nOsL4fca5UTlBERiOJmjqHiDL76M0L4v68zj/D77GSXfIx0g+9zU35/maD6o7WkMoFGLFDF13ppJMJjl06BAAa9asmfPvhwm3h0MknnDeU9zW7+TU2hocBny4r/uY3mSjLvXGbHc3DX8bM3bLmM/MBNtHbbvwa8uJvj9Ae2M9iXisx1p7Xn3TVaBOI2NME5ALEw5Vmk6DZ6Njs/Cz0kHHN70G+3IdnKWfp9cvs83lfOq1y2xzOZug1y/TzeV86rXLbLN9fIuBfmvtxFPyn4UK1AxljNkPcL5N516n48tsOr7MNpePby4fG+j4Mp2OL7PN5eOby8cGOj6vmdvt8iIiIiIiIpIxVKCKiIiIiIiIJ6hAFREREREREU9QgSoiIiIiIiKeoAJVREREREREPEGz+IqIiIiIiIgnqAVVREREREREPEEFqoiIiIiIiHiCClQRERERERHxBBWoIiIiIiIi4gkqUEVERERERMQTVKCKiIiIiIiIJ6hAFREREREREU9QgSoiIiIiIiKeoAJVPMcY40/3Psy0i+EY56qL4bW7GI5xLroYXreL4RjnqovhtbsYjnEuuhhet0w7RmOtTfc+yBQYY7KAAiBorW1K9/5MN2PMauB3gADQC3zJWtuT3r2aPsaYTcBHgeuBGuCjc+z4lM8MNpfzqWxmtrmcTVA+M91czqeymdkyNZtqQc0gxpgtwL8Bh4Edxpj3pXePppcxZhVwH/AvQD1wM7DPGPNrmXbnJxVjzBrgD4HHgb3AO4HXjDF5ad2xaaJ8Zra5nE9lM7PN5WyC8pnWnZsGczmfymZmy+hsWmv1yIAHsBb4MlACfAx4GkgAv57ufZum4ysF/g7wu5/7gIXANqDLPeZAuvfzAo6v2j2+QvfzHOBDQBL4h3Tv3zQcn/KpfHryoWwqm15+KJ/Kp1cfyqaymdb9T/cO6DGJF8n5g3kYyB+x7XKcuyG7gDzc7tqZ+gCuAf4lxXY/zp2fXuDDmXqcOHetlo7ZVgg8DzyX7v27wGNTPpVPTz6UTWXTyw/lU/n06kPZVDbT/VAX38wwD/iutbZ3cIO1difOH1A1kLBu8jLYCaDSGLN5cIMxxmetTQAfAV7FOVlWp2n/LtRlwJ8YY94xuMFa2w08BJQYY7IyuDuJ8ql8epWyqWx6mfKpfHqVsqlsppUK1MywAfiyMeaTxph5I7Z/DWjG6X6RcTN0jREBFgGfM8bMB7DWJo0xxlobBj4OnAaeSuM+XoincQapf2rMaxgG4tbaGJBtjLnVGJOflj08f8qn8ulVyqay6WXKp/LpVcqmsplWKlAzgLX2caAf+ASQO+KpmLs9aIwJAncYY65Kwy5eMGttK/C7wJ3AXxhjKtzt1v1YB/w20G+MuTxd+3m+rLUHgS3A/7XWdo14qtF9YK3tAy4B/mn29/D8KZ/Kp1cpm8qmlymfyqdXKZvKZrqpQPW4wbtT1trbgTustY3u9gBggVNAj7U2CgwAjxljrkjX/l4Ia+0u4H/jnDD+0hizZPA5947WPqABCKZpFy+ItfaQtXavMcaM2NwBxIwxPmNMOc4g9vuMMSvSs5dTo3w6lE/vUTYdyqY3KZ8O5dN7lE2HsplegXTvgJydtTZhjPFbaxPW2lr3D8Zaa+NA3BhzAggYY0qBTcBGIJ7Wnb4w38A5ETwEFBtj/tRaWztirEM9UJu2vZsGY8ZtxHG6kFTgdMX4PHCrtfZYGnZtypRP5dOrlE1l08uUT+XTq5RNZdMLVKBmAOsM2B7899hB6W3AauAG4AvAu621b8zi7k0ra23UGPMVnDtW/wpEjDE7ga/jjAf4up1DC0Vba7uNMb3APQyfJJ5J715NjfKpfHqVsqlsepnyqXx6lbKpbKabGZ878RrjzCqWnOC5/wMsBh7AWZvKcyE7X8aYDcC9wNXAHuDb1tq30rpTM8AY8wxwE3CbtXZbuvdnqpRP5dOrlE1l08uUT+XTq5RNZTPd1ILqcSNPEsaYDwI7rbWHRvyXPOCPgFustc+mYx9ninX6/u8DZ0zEyDt6c8FgtxmcbhaevIN1Lsqn8ulVyqay6WXKp/LpVcqmsukFKlA9bMxJ4m9x1mL67pj/VoIziH1OnSTGmmsnCRjVbeZaO2KtsUyhfA5TPr1F2RymbHqP8jlM+fQWZXOYsple6uLrUWNOEg8Ba4B7rbXxEXdARNJC+RSvUjbFy5RP8SplU7xEy8x4UIqTxDqGTxL+wZOEMaOmjRaZFcqneJWyKV6mfIpXKZviNWpB9ZgJThJ3jzhJzLkuB5I5lE/xKmVTvEz5FK9SNsWL1ILqITpJiJcpn+JVyqZ4mfIpXqVsilepBdWDjDF/DaxHJwnxIOVTvErZFC9TPsWrlE3xGs3i6zHGmL8EtuDMkKaThHiK8ilepWyKlymf4lXKpniRuvh6iDEmCOxFJwnxIOVTvErZFC9TPsWrlE3xKnXx9SidJMTLlE/xKmVTvEz5FK9SNsVLVKCKiIiIiIiIJ6iLr4iIiIiIiHiCClQRERERERHxBBWoIiIiIiIi4gkqUEVERERERMQTVKCKiIiIiIiIJ6hAFREREREREU9QgSoiIiIiIiKeoAJVREREREREPEEFqoiIiIiIiHiCClQRERERERHxBBWoIiIiIiIi4gkqUEVERERERMQTVKCKiIiIiIiIJwTSvQMig4wx9wMr3E/brLWPpHN/REZSPsWrlE3xMuVTvErZ9C4VqOIJxpgngFpr7Wfcz58xxuy21j6b5l0TUT7Fs5RN8TLlU7xK2fQ2dfGVtDPGPAZUD54kXLuBB9K0SyJDlE/xKmVTvEz5FK9SNr1PLaiSVsaYm4H7gS1jnmpzt4ukjfIpXqVsipcpn+JVymZmUAuqpNtjwG5r7e4x20uBotnfHZFRlE/xKmVTvEz5FK9SNjOAWlAlbdy7WNXAvSmerp7l3REZRfkUr1I2xcuUT/EqZTNzGGttuvdBLlLuAPV7rLUmxXMdANba4lnfMRGUT/EuZVO8TPkUr1I2M4e6+EpaGGOKgHuAcbOluc8VATtndadEXMqneJWyKV6mfIpXKZuZRV18JV0GB6JXG2OeGfNciftx7PgAkdmifIpXKZviZcqneJWymUFUoEq6XOF+fJe1tnbkE+7035uB74/YVgTcDDyc6mtEptlU8/kgw4t9VwMPay01mSHnk82RX/uMtfYbM76XcrGaUj7HPH8PcMWYpT9Epsuks2mM2Qx8E6e1tQ1nAqVqa22qsasyAzQGVdLCGHMMKEnV198dB1Brrd3ifr4ZpzitBZ4AtqSYfU1k2kwxnw8Djw2+4bmTMDyD8yaoIlWm1RSz+RhwzFr7iPt5NXAMuNda++Qs7rZcJKaSzzHPFQF1wDdUoMpMOI/rzudwuv124hSqn1HjyOzRGFRJl2pS9PV3TwpFwEOD26y1u90LLF3sy2yZdD5xxrQMzf7nFqW7AV1kyUyYSjYB3jXi3+0jvofITJhqPgd9NtXXiUyjqWbzXmutsdYWW2vvVXE6u1SgSjql+mP/LNCpu/viAVPJ59gL/vYU20Smy6Syaa19wFo7skC92f2o86vMpCm9txtj7sdZm1Jkpum6M0NoDKqkS6f7GOJ2P7uH1OtTicymTiaZT2vtCsa7HLX4y8zoZIrnTrfb+Wac1tQtagmQGdTJFPLpPoe1ttaYcSt/iEynTqZ27nyX27oKzvjVxzRsZ/aoQJV0SdWV5zHgSd3FEg8473y6rQEAH5v2vRI5v2zuxGk5WAF81hjzMWtt5wztn1zcpprPBzTmVGbJVLLZCbw+uH1wjLQx5ibNgTI71MVX0uVhnDv6wPBMk5ohTTzivPLptlR9BqeVqnMmd1AuWlPOprW201pba619wP3aJ2Z8L+ViNel8us+pa6/Mlkln0z1fjhwu0YlT4D4887spoBZUSRNr7bPGmM3uDKgAbWPGSomkzfnk0+0KpOJUZtRks+ne8X+C8Use1TI8FlVkWk0hn5txxv2pu7nMiqm8r4+dnd+lc+cs0jIzkjHcC64OtMyMeIw7juUzbgvV4LaH1XVN0mWiJWWMMbuAognGTovMCre3ydji4H6cIuBZxhcHIrPGGGMZf+58BkCNKbNDLaiSSUrSvQMiY7mFwBPAQ+5C8+DM4KtZfCVt3ElnnmTEZF1uVgcnSxJJG7dVf9SEM+7581nd2BMPeGRMcVqE03o6bg1fmRlqQRXPG2ydwrngvxlnjcmdOHdY1ZIqaeUu8F2U4qlHdKEl6eReVH3W/bQNzUQpHuS2pt7L6BbUh9WCKuk0oiswONefD+mac/aoQBURERERERFP0Cy+IiIiIiIi4gkqUEVERERERMQTVKCKiIiIiIiIJ6hAFREREREREU9QgSoiIiIiIiKeoAJVREREREREPEEFqoiIiIiIiHiCClQRERERERHxBBWoIiIiIiIi4gkqUEVERERERMQTVKCKiIiIiIiIJ6hAFREREREREU9QgSoiIiIiIiKeoAJVREREREREPEEFqoiIiIiIiHjC/we6tgoIO9tqDwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.rcParams.update(nice_rc()) # nicer plot settings\n", + "\n", + "fig = corner(\n", + " samples,\n", + " smooth=2.,\n", + " bounds=(LOWER, UPPER),\n", + " labels=LABELS,\n", + " legend=r'$p_\\phi(\\theta | x^*)$',\n", + " markers=[theta_star],\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:lampe]", + "language": "python", + "name": "conda-env-lampe-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/02_nre.ipynb b/notebooks/02_nre.ipynb new file mode 100644 index 0000000..ee43353 --- /dev/null +++ b/notebooks/02_nre.ipynb @@ -0,0 +1,273 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Neural ratio estimation\n", + "\n", + "This tutorial demonstrates how to perform neural ratio estimation (NRE) with `lampe`." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import os\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "\n", + "from tqdm import tqdm\n", + "\n", + "from lampe.data import JointLoader, H5Dataset\n", + "from lampe.nn import NRE\n", + "from lampe.nn.losses import NRELoss\n", + "from lampe.plots import nice_rc, corner\n", + "from lampe.priors import BoxUniform\n", + "from lampe.simulators.slcp import SLCP, LOWER, UPPER, LABELS\n", + "from lampe.utils import GDStep, MetropolisHastings" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simulator\n", + "\n", + "We use the same prior and simulator as in the [previous tutorial](01_npe.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "prior = BoxUniform(LOWER, UPPER)\n", + "sim = SLCP()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data\n", + "\n", + "Often, the simulator is slow or expensive and the pairs $(\\theta, x) \\sim p(\\theta, x)$ have to be generated and stored on disk ahead of training. For this purpose, it is common to use the [HDF5](https://en.wikipedia.org/wiki/Hierarchical_Data_Format) file format, as it was specifically designed for large amounts of numerical data. The `lampe.data` module provides the `H5Dataset` class to help load and store pairs $(\\theta, x)$ in HDF5 files. The `H5Dataset.store` function takes an iterable of batched pairs $(\\theta, x)$ (e.g. a `JointLoader`) as input and stores them into an HDF5 file. The `H5Dataset` creates an iterable [Dataset](https://pytorch.org/docs/stable/data.html#torch.utils.data.Dataset) of pairs $(\\theta, x)$ that are dynamically loaded from HDF5 files.\n", + "\n", + "Importantly, `H5Dataset` possesses a custom `__iter__` method, which means it should not be wrapped inside a `DataLoader` when iterating over the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(tensor([ 2.8735, 2.0794, 0.8703, -2.5437, -2.9376]),\n", + " tensor([ 3.6897, -5.5541, 3.2966, -1.3505, 2.9531, 0.8708, 2.4981, 3.1952]))" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "if not os.path.exists('train.h5'):\n", + " loader = JointLoader(prior, sim, batched=True)\n", + " H5Dataset.store(loader, 'train.h5', size=2**20) # store 1048576 pairs on disk\n", + "\n", + "dataset = H5Dataset('train.h5', batch_size=2**10, pin_memory=True)\n", + "dataset[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training\n", + "\n", + "The concept of neural ratio estimation (NRE) is to train a classifier network $d_\\phi(\\theta, x)$ to distinguish between pairs $(\\theta, x)$ sampled from the joint distribution $p(\\theta, x)$ or from the product of the marginals $p(\\theta) p(x)$. Like for the [previous tutorial](01_npe.ipynb), we define our training components individually. First, we use the `NRE` class provided by `lampe.nn` to create a classifier network adapted to the simulator's input and output sizes. For numerical stability reasons, the created network returns the logit of the class prediction $\\text{logit}(d_\\phi(\\theta, x)) = \\log r_\\phi(\\theta, x)$." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "NRE(\n", + " (standardize): Identity()\n", + " (net): MLP(\n", + " (0): Linear(in_features=13, out_features=256, bias=True)\n", + " (1): ELU(alpha=1.0)\n", + " (2): Linear(in_features=256, out_features=256, bias=True)\n", + " (3): ELU(alpha=1.0)\n", + " (4): Linear(in_features=256, out_features=256, bias=True)\n", + " (5): ELU(alpha=1.0)\n", + " (6): Linear(in_features=256, out_features=256, bias=True)\n", + " (7): ELU(alpha=1.0)\n", + " (8): Linear(in_features=256, out_features=256, bias=True)\n", + " (9): ELU(alpha=1.0)\n", + " (10): Linear(in_features=256, out_features=1, bias=True)\n", + " )\n", + ")" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "estimator = NRE(5, 8, hidden_features=[256] * 5, activation='ELU')\n", + "estimator.cuda()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then, instead of re-writing NRE's loss ourselves, we use the one provided by `lampe.nn.losses`. Other losses are implemented such as `NPELoss`, `AMNRELoss`, ..." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "loss = NRELoss(estimator)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we train our classifier using a standard neural network training routine." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 64/64 [05:16<00:00, 4.94s/epoch, loss=0.091] \n" + ] + } + ], + "source": [ + "optimizer = optim.AdamW(estimator.parameters(), lr=1e-3, weight_decay=1e-3)\n", + "step = GDStep(optimizer, clip=1.) # gradient descent step with gradient clipping\n", + "\n", + "estimator.train()\n", + "\n", + "with tqdm(range(64), unit='epoch') as tq:\n", + " for epoch in tq:\n", + " losses = torch.stack([\n", + " step(loss(theta.cuda(), x.cuda()))\n", + " for theta, x in dataset\n", + " ])\n", + "\n", + " tq.set_postfix(loss=losses.mean().item())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Inference\n", + "\n", + "Now that we have an estimator of the likelihood-to-evidence (LTE) ratio $r(\\theta, x) = \\frac{p(\\theta | x)}{p(\\theta)}$, we can sample from the posterior distribution of an observation $x^*$ through MCMC or nested sampling. In our case, we use the `MetropolisHastings` sampler provided by `lampe.utils`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "theta_star = torch.tensor([0.3517, -0.0883, -1.4778, 1.6406, -1.9085])\n", + "x_star = sim(theta_star).cuda()\n", + "\n", + "estimator.eval()\n", + "prior.cuda()\n", + "\n", + "with torch.no_grad():\n", + " theta_0 = prior.sample((2**12,)) # 4096 concurrent Markov chains\n", + " log_p = lambda theta: estimator(theta, x_star) + prior.log_prob(theta) # p(theta | x) = r(theta, x) p(theta)\n", + "\n", + " sampler = MetropolisHastings(theta_0, log_f=log_p, sigma=0.5)\n", + " samples = torch.cat([\n", + " theta.cpu()\n", + " for theta in sampler(2**8 + 2**6, burn=2**6, step=2**2)\n", + " ])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.rcParams.update(nice_rc()) # nicer plot settings\n", + "\n", + "fig = corner(\n", + " samples,\n", + " smooth=2.,\n", + " bounds=(LOWER, UPPER),\n", + " labels=LABELS,\n", + " legend=r'$p_\\phi(\\theta | x^*)$',\n", + " markers=[theta_star],\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:lampe]", + "language": "python", + "name": "conda-env-lampe-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/slcp-npe.ipynb b/notebooks/slcp-npe.ipynb deleted file mode 100644 index d8735dd..0000000 --- a/notebooks/slcp-npe.ipynb +++ /dev/null @@ -1,395 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# SLCP with NPE" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "import torch.nn.functional as F\n", - "import torch.optim as optim\n", - "\n", - "from tqdm import tqdm\n", - "\n", - "from lampe.data import SimulatorLoader, H5Loader, h5save\n", - "from lampe.nn import NPE, NPEPipe\n", - "from lampe.mcmc import InferenceSampler\n", - "from lampe.plots import corner\n", - "from lampe.simulators.slcp import SLCP, slcp_prior, lower, upper, labels\n", - "from lampe.train import collect" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Data" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(tensor([-0.1215, -1.3641, 0.7233, -1.2150, -1.9263]),\n", - " tensor([[-0.0157, -1.5407],\n", - " [ 0.3852, -2.7057],\n", - " [-0.6751, 0.2144],\n", - " [-0.5687, 0.1209]]))" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sim = SLCP()\n", - "prior = slcp_prior()\n", - "\n", - "theta = prior.sample()\n", - "x = sim(theta)\n", - "\n", - "theta, x" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 1048576/1048576 [00:06<00:00, 170190.12sample/s]\n", - "100%|██████████| 262144/262144 [00:01<00:00, 173735.76sample/s]\n" - ] - } - ], - "source": [ - "loader = SimulatorLoader(prior, sim, batched=True)\n", - "\n", - "h5save(loader, 'train.h5', 2**20)\n", - "h5save(loader, 'valid.h5', 2**18)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Network" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "NPE(\n", - " (broadcast): Broadcast(keep=1)\n", - " (flow): MAF(\n", - " (_transform): CompositeTransform(\n", - " (_transforms): ModuleList(\n", - " (0): MaskedAffineAutoregressiveTransform(\n", - " (autoregressive_net): MADE(\n", - " (initial_layer): MaskedLinear(in_features=5, out_features=128, bias=True)\n", - " (context_layer): Linear(in_features=8, out_features=128, bias=True)\n", - " (blocks): ModuleList(\n", - " (0): MaskedFeedforwardBlock(\n", - " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (1): MaskedFeedforwardBlock(\n", - " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (2): MaskedFeedforwardBlock(\n", - " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " )\n", - " (final_layer): MaskedLinear(in_features=128, out_features=10, bias=True)\n", - " )\n", - " )\n", - " (1): RandomPermutation()\n", - " (2): MaskedAffineAutoregressiveTransform(\n", - " (autoregressive_net): MADE(\n", - " (initial_layer): MaskedLinear(in_features=5, out_features=128, bias=True)\n", - " (context_layer): Linear(in_features=8, out_features=128, bias=True)\n", - " (blocks): ModuleList(\n", - " (0): MaskedFeedforwardBlock(\n", - " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (1): MaskedFeedforwardBlock(\n", - " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (2): MaskedFeedforwardBlock(\n", - " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " )\n", - " (final_layer): MaskedLinear(in_features=128, out_features=10, bias=True)\n", - " )\n", - " )\n", - " (3): RandomPermutation()\n", - " (4): MaskedAffineAutoregressiveTransform(\n", - " (autoregressive_net): MADE(\n", - " (initial_layer): MaskedLinear(in_features=5, out_features=128, bias=True)\n", - " (context_layer): Linear(in_features=8, out_features=128, bias=True)\n", - " (blocks): ModuleList(\n", - " (0): MaskedFeedforwardBlock(\n", - " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (1): MaskedFeedforwardBlock(\n", - " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (2): MaskedFeedforwardBlock(\n", - " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " )\n", - " (final_layer): MaskedLinear(in_features=128, out_features=10, bias=True)\n", - " )\n", - " )\n", - " (5): RandomPermutation()\n", - " (6): MaskedAffineAutoregressiveTransform(\n", - " (autoregressive_net): MADE(\n", - " (initial_layer): MaskedLinear(in_features=5, out_features=128, bias=True)\n", - " (context_layer): Linear(in_features=8, out_features=128, bias=True)\n", - " (blocks): ModuleList(\n", - " (0): MaskedFeedforwardBlock(\n", - " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (1): MaskedFeedforwardBlock(\n", - " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (2): MaskedFeedforwardBlock(\n", - " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " )\n", - " (final_layer): MaskedLinear(in_features=128, out_features=10, bias=True)\n", - " )\n", - " )\n", - " (7): RandomPermutation()\n", - " (8): MaskedAffineAutoregressiveTransform(\n", - " (autoregressive_net): MADE(\n", - " (initial_layer): MaskedLinear(in_features=5, out_features=128, bias=True)\n", - " (context_layer): Linear(in_features=8, out_features=128, bias=True)\n", - " (blocks): ModuleList(\n", - " (0): MaskedFeedforwardBlock(\n", - " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (1): MaskedFeedforwardBlock(\n", - " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " (2): MaskedFeedforwardBlock(\n", - " (linear): MaskedLinear(in_features=128, out_features=128, bias=True)\n", - " (dropout): Dropout(p=0.0, inplace=False)\n", - " )\n", - " )\n", - " (final_layer): MaskedLinear(in_features=128, out_features=10, bias=True)\n", - " )\n", - " )\n", - " (9): RandomPermutation()\n", - " )\n", - " )\n", - " (_distribution): StandardNormal()\n", - " (_embedding_net): Identity()\n", - " )\n", - ")" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "embedding = nn.Flatten(-2)\n", - "estimator = NPE(5, 8, num_transforms=5, hidden_features=128, num_blocks=3)\n", - "\n", - "embedding.cuda()\n", - "estimator.cuda()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Training" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "train_loader = H5Loader('train.h5', batch_size=2**10, pin_memory=True)\n", - "valid_loader = H5Loader('valid.h5', batch_size=2**10, pin_memory=True, shuffle=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "pipe = NPEPipe(estimator, embedding=embedding).cuda()\n", - "optimizer = optim.AdamW(pipe.parameters(), lr=1e-3, weight_decay=1e-3)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 64/64 [28:59<00:00, 27.18s/epoch, train_loss=2.43, valid_loss=2.41]\n" - ] - } - ], - "source": [ - "pipe.train()\n", - "\n", - "with tqdm(range(64), unit='epoch') as tq:\n", - " for epoch in tq:\n", - " train_losses = collect(\n", - " pipe,\n", - " train_loader,\n", - " optimizer,\n", - " grad_clip=1.,\n", - " )\n", - " \n", - " with torch.no_grad():\n", - " valid_losses = collect(pipe, valid_loader)\n", - "\n", - " tq.set_postfix(\n", - " train_loss=train_losses.mean().item(),\n", - " valid_loss=valid_losses.mean().item(),\n", - " )\n", - "\n", - "_ = pipe.eval()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Evaluation" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "theta = torch.tensor([0.3517, -0.0883, -1.4778, 1.6406, -1.9085])\n", - "x = sim(theta)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "sampler = InferenceSampler(x, prior, likelihood=sim.log_prob, batch_size=2**12, sigma=5e-1)\n", - "samples = torch.cat([t for t in sampler(2**8, burn=2**6, step=2**2)])\n", - "\n", - "with torch.no_grad():\n", - " y = embedding(x.cuda())\n", - " npe_samples = torch.cat([\n", - " estimator.sample(y, (2**16,)).cpu() for _ in range(2**4)\n", - " ])" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig = corner(\n", - " samples,\n", - " smooth=2.,\n", - " bounds=(lower, upper),\n", - " labels=labels,\n", - " legend='Likelihood (MCMC)',\n", - " markers=[theta],\n", - ")\n", - "\n", - "fig = corner(\n", - " npe_samples,\n", - " smooth=2.,\n", - " bounds=(lower, upper),\n", - " legend='NPE',\n", - " figure=fig,\n", - ")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:lampe]", - "language": "python", - "name": "conda-env-lampe-py" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/notebooks/slcp-nre.ipynb b/notebooks/slcp-nre.ipynb deleted file mode 100644 index dd18556..0000000 --- a/notebooks/slcp-nre.ipynb +++ /dev/null @@ -1,270 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# SLCP with NRE" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "import torch.nn.functional as F\n", - "import torch.optim as optim\n", - "\n", - "from tqdm import tqdm\n", - "\n", - "from lampe.data import SimulatorLoader, H5Loader, h5save\n", - "from lampe.nn import NRE, NREPipe\n", - "from lampe.mcmc import InferenceSampler\n", - "from lampe.plots import corner\n", - "from lampe.simulators.slcp import SLCP, slcp_prior, lower, upper, labels\n", - "from lampe.train import collect" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Data" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(tensor([ 0.3000, 1.8476, -1.2630, 0.8762, 2.7738]),\n", - " tensor([[-0.2955, 1.6379],\n", - " [ 0.9420, 2.1774],\n", - " [ 1.2021, 2.4567],\n", - " [-0.7462, 1.1522]]))" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sim = SLCP()\n", - "prior = slcp_prior()\n", - "\n", - "theta = prior.sample()\n", - "x = sim(theta)\n", - "\n", - "theta, x" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Network" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "NRE(\n", - " (standardize): Identity()\n", - " (broadcast): Broadcast(keep=1)\n", - " (net): MLP(\n", - " (0): Linear(in_features=13, out_features=256, bias=True)\n", - " (1): ELU(alpha=1.0)\n", - " (2): Linear(in_features=256, out_features=256, bias=True)\n", - " (3): ELU(alpha=1.0)\n", - " (4): Linear(in_features=256, out_features=256, bias=True)\n", - " (5): ELU(alpha=1.0)\n", - " (6): Linear(in_features=256, out_features=256, bias=True)\n", - " (7): ELU(alpha=1.0)\n", - " (8): Linear(in_features=256, out_features=256, bias=True)\n", - " (9): ELU(alpha=1.0)\n", - " (10): Linear(in_features=256, out_features=1, bias=True)\n", - " )\n", - ")" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "embedding = nn.Flatten(-2)\n", - "estimator = NRE(5, 8, hidden_features=[256] * 5, activation='ELU')\n", - "\n", - "embedding.cuda()\n", - "estimator.cuda()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Training" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "train_loader = H5Loader('train.h5', batch_size=2**10, pin_memory=True)\n", - "valid_loader = H5Loader('valid.h5', batch_size=2**10, pin_memory=True, shuffle=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "pipe = NREPipe(estimator, embedding=embedding).cuda()\n", - "optimizer = optim.AdamW(pipe.parameters(), lr=1e-3, weight_decay=1e-3)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 64/64 [11:07<00:00, 10.43s/epoch, train_loss=0.0454, valid_loss=0.0567]\n" - ] - } - ], - "source": [ - "pipe.train()\n", - "\n", - "with tqdm(range(64), unit='epoch') as tq:\n", - " for epoch in tq:\n", - " train_losses = collect(\n", - " pipe,\n", - " train_loader,\n", - " optimizer,\n", - " grad_clip=1.,\n", - " )\n", - "\n", - " with torch.no_grad():\n", - " valid_losses = collect(pipe, valid_loader)\n", - "\n", - " tq.set_postfix(\n", - " train_loss=train_losses.mean().item(),\n", - " valid_loss=valid_losses.mean().item(),\n", - " )\n", - "\n", - "_ = pipe.eval()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Evaluation" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "theta = torch.tensor([0.3517, -0.0883, -1.4778, 1.6406, -1.9085])\n", - "x = sim(theta)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "sampler = InferenceSampler(x, prior.cpu(), likelihood=sim.log_prob, batch_size=2**12, sigma=5e-1)\n", - "samples = torch.cat([t for t in sampler(2**8, burn=2**6, step=2**2)])\n", - "\n", - "with torch.no_grad():\n", - " y = embedding(x.cuda())\n", - "\n", - " sampler = InferenceSampler(y, prior.cuda(), ratio=estimator, batch_size=2**12, sigma=5e-1)\n", - " nre_samples = torch.cat([t.cpu() for t in sampler(2**8, 2**6, step=2**2)])" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig = corner(\n", - " samples,\n", - " smooth=2.,\n", - " bounds=(lower, upper),\n", - " labels=labels,\n", - " legend='Likelihood (MCMC)',\n", - " markers=[theta],\n", - ")\n", - "\n", - "fig = corner(\n", - " nre_samples,\n", - " smooth=2.,\n", - " bounds=(lower, upper),\n", - " legend='NRE (MCMC)',\n", - " figure=fig,\n", - ")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:lampe]", - "language": "python", - "name": "conda-env-lampe-py" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/requirements.txt b/requirements.txt index 2501028..9c8a963 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,5 @@ h5py>=3.0.0 +matplotlib>=3.4.0 nflows>=0.14 numpy>=1.20.0 torch>=1.8.0 diff --git a/setup.py b/setup.py index b364282..f7adb4f 100644 --- a/setup.py +++ b/setup.py @@ -10,7 +10,7 @@ setuptools.setup( name='lampe', - version='0.2.18', + version='0.3.0', packages=setuptools.find_packages(), description='Likelihood-free AMortized Posterior Estimation with PyTorch', keywords='parameter inference bayes posterior amortized likelihood ratio mcmc torch', @@ -34,5 +34,11 @@ 'Programming Language :: Python :: 3', ], install_requires=required, + extras_require={ + 'docs': [ + 'furo', + 'sphinx', + ] + }, python_requires='>=3.8', ) diff --git a/sphinx/api/data.rst b/sphinx/api/data.rst new file mode 100644 index 0000000..43ed6ae --- /dev/null +++ b/sphinx/api/data.rst @@ -0,0 +1,4 @@ +lampe.data +========== + +.. automodule:: lampe.data diff --git a/sphinx/api/index.rst b/sphinx/api/index.rst new file mode 100644 index 0000000..9f4b886 --- /dev/null +++ b/sphinx/api/index.rst @@ -0,0 +1,10 @@ +API +=== + +.. toctree:: + :glob: + :includehidden: + :maxdepth: 2 + + nn/index.rst + * diff --git a/sphinx/api/masks.rst b/sphinx/api/masks.rst new file mode 100644 index 0000000..6054257 --- /dev/null +++ b/sphinx/api/masks.rst @@ -0,0 +1,4 @@ +lampe.masks +=========== + +.. automodule:: lampe.masks diff --git a/sphinx/api/nn/flows.rst b/sphinx/api/nn/flows.rst new file mode 100644 index 0000000..16c22f0 --- /dev/null +++ b/sphinx/api/nn/flows.rst @@ -0,0 +1,4 @@ +lampe.nn.flows +============== + +.. automodule:: lampe.nn.flows diff --git a/sphinx/api/nn/index.rst b/sphinx/api/nn/index.rst new file mode 100644 index 0000000..84a2e81 --- /dev/null +++ b/sphinx/api/nn/index.rst @@ -0,0 +1,11 @@ +lampe.nn +======== + +.. automodule:: lampe.nn + +.. toctree:: + :glob: + :hidden: + :maxdepth: 1 + + * diff --git a/sphinx/api/nn/losses.rst b/sphinx/api/nn/losses.rst new file mode 100644 index 0000000..deb59e5 --- /dev/null +++ b/sphinx/api/nn/losses.rst @@ -0,0 +1,4 @@ +lampe.nn.losses +=============== + +.. automodule:: lampe.nn.losses diff --git a/sphinx/api/plots.rst b/sphinx/api/plots.rst new file mode 100644 index 0000000..9b63a25 --- /dev/null +++ b/sphinx/api/plots.rst @@ -0,0 +1,4 @@ +lampe.plots +=========== + +.. automodule:: lampe.plots diff --git a/sphinx/api/priors.rst b/sphinx/api/priors.rst new file mode 100644 index 0000000..4f303c9 --- /dev/null +++ b/sphinx/api/priors.rst @@ -0,0 +1,4 @@ +lampe.priors +============ + +.. automodule:: lampe.priors diff --git a/sphinx/api/utils.rst b/sphinx/api/utils.rst new file mode 100644 index 0000000..89be20d --- /dev/null +++ b/sphinx/api/utils.rst @@ -0,0 +1,4 @@ +lampe.utils +=========== + +.. automodule:: lampe.utils diff --git a/sphinx/build.sh b/sphinx/build.sh new file mode 100644 index 0000000..34d6ad8 --- /dev/null +++ b/sphinx/build.sh @@ -0,0 +1,24 @@ +#!/usr/bin/bash + +set -e +shopt -s globstar + +# Merge +git checkout docs +git merge master -m "🔀 Merge master into docs" + +# Generate HTML +sphinx-build -b html . ../docs + +# Disable Jekyll +cd ../docs +touch .nojekyll + +# Edit HTML +sed "s|\[source\]||g" -i **/*.html +sed "s|\(\)\(\)|\2\1|g" -i **/*.html +sed "s|@pradyunsg's||g" -i **/*.html + +# Push +git add . +git commit -m "📝 Update Sphinx documentation" diff --git a/sphinx/conf.py b/sphinx/conf.py new file mode 100644 index 0000000..f7522b5 --- /dev/null +++ b/sphinx/conf.py @@ -0,0 +1,115 @@ +# Configuration file for the Sphinx documentation builder + +import os +import sys +import inspect +import importlib + +sys.path.insert(0, os.path.abspath('..')) + +## Project + +package = 'lampe' +project = 'LAMPE' +copyright = '2021-2022, François Rozet' +repository = 'https://github.com/francois-rozet/lampe' + +## Extensions + +extensions = [ + 'sphinx.ext.autodoc', + 'sphinx.ext.intersphinx', + 'sphinx.ext.linkcode', + 'sphinx.ext.napoleon', +] + +autodoc_default_options = { + 'members': True, + 'member-order': 'bysource', +} +autodoc_inherit_docstrings = False +autodoc_typehints = 'description' +autodoc_typehints_description_target = 'documented' +autodoc_typehints_format = 'short' + +intersphinx_mapping = { + 'matplotlib': ('https://matplotlib.org/stable', None), + 'numpy': ('https://numpy.org/doc/stable', None), + 'python': ('https://docs.python.org/3', None), + 'torch': ('https://pytorch.org/docs/stable', None), +} + +def linkcode_resolve(domain: str, info: dict) -> str: + module = info.get('module', '') + fullname = info.get('fullname', '') + + if not module or not fullname: + return None + + objct = importlib.import_module(module) + for name in fullname.split('.'): + objct = getattr(objct, name) + + try: + file = inspect.getsourcefile(objct) + file = file[file.rindex(package):] + + lines, start = inspect.getsourcelines(objct) + end = start + len(lines) - 1 + except Exception as e: + return None + else: + return f'{repository}/tree/docs/{file}#L{start}-L{end}' + +napoleon_custom_sections = [ + ('Shapes', 'params_style'), + 'Wikipedia', +] + +## Settings + +add_function_parentheses = False +default_role = 'literal' +exclude_patterns = ['templates'] +html_copy_source = False +html_css_files = [ + 'custom.css', + 'https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css', +] +html_favicon = 'static/logo_dark.svg' +html_show_sourcelink = False +html_sourcelink_suffix = '' +html_static_path = ['static'] +html_theme = 'furo' +html_theme_options = { + 'footer_icons': [ + { + 'name': 'GitHub', + 'url': repository, + 'html': '', + 'class': '', + }, + ], + 'light_css_variables': { + 'color-api-keyword': '#007020', + 'color-api-name': '#0e84b5', + 'color-api-pre-name': '#0e84b5', + }, + 'light_logo': 'logo.svg', + 'dark_css_variables': { + 'color-api-keyword': '#66d9ef', + 'color-api-name': '#a6e22e', + 'color-api-pre-name': '#a6e22e', + }, + 'dark_logo': 'logo_dark.svg', + 'sidebar_hide_name': True, +} +html_title = project +pygments_style = 'sphinx' +pygments_dark_style = 'monokai' +rst_prolog = """ +.. role:: py(code) + :class: highlight + :language: python +""" +templates_path = ['templates'] diff --git a/sphinx/docutils.conf b/sphinx/docutils.conf new file mode 100644 index 0000000..1bf4d83 --- /dev/null +++ b/sphinx/docutils.conf @@ -0,0 +1,2 @@ +[restructuredtext parser] +syntax_highlight = short diff --git a/sphinx/index.rst b/sphinx/index.rst new file mode 100644 index 0000000..036ab18 --- /dev/null +++ b/sphinx/index.rst @@ -0,0 +1,82 @@ +.. image:: static/banner.svg + :class: only-light + +.. image:: static/banner_dark.svg + :class: only-dark + +LAMPE +===== + +:mod:`lampe` is a simulation-based inference (SBI) package that focuses on amortized estimation of posterior distributions, without relying on explicit likelihood functions; hence the name *Likelihood-free AMortized Posterior Estimation* (LAMPE). The package provides `PyTorch `_ implementations of modern amortized simulation-based inference algorithms like neural ratio estimation (NRE), neural posterior estimation (NPE) and more. Similar to PyTorch, the philosophy of LAMPE is to avoid obfuscation and expose all components, from network architecture to optimizer, to the user such that they are free to modify or replace anything they like. + +Installation +------------ + +The :mod:`lampe` package is available on `PyPI `_, which means it is installable via `pip`. + +.. code-block:: console + + pip install lampe + +Alternatively, if you need the latest features, you can install it from the repository. + +.. code-block:: console + + pip install git+https://github.com/francois-rozet/lampe + +Simulation-based inference +-------------------------- + +In many areas of science, computer simulators are used to describe complex phenomena such as high energy particle interactions, gravitational waves or neuronal ion-channel dynamics. These simulators are stochastic models/programs that generate synthetic observations according to input parameters. A common task for scientists is to use such models to perform statistical inference of the parameters given one or more observations. Unfortunately, simulators often feature high-dimensional parameter spaces and intractable likelihoods, making inference challenging. + +Formally, a stochastic model takes a set of parameters :math:`\theta \in \Theta` as input, samples internally a series :math:`z \in \mathcal{Z}` of latent variables and, finally, produces an observation :math:`x \in \mathcal{X} \sim p(x | \theta, z)` as output, thereby defining an implicit likelihood :math:`p(x | \theta)`. This likelihood is typically *intractable* as it corresponds to the integral of the joint likelihood :math:`p(x, z | \theta)` over *all* possible trajectories through the latent space :math:`\mathcal{Z}`. Moreover, in Bayesian inference, we are interested in the posterior + +.. math:: p(\theta | x) + = \frac{p(x | \theta) p(\theta)}{p(x)} + = \frac{p(x | \theta) p(\theta)}{\int_\Theta p(x | \theta') p(\theta') \operatorname{d}\!\theta'} + +for some observation :math:`x` and a prior distribution :math:`p(\theta)`, which not only involves the intractable likelihood :math:`p(x | \theta)` but also an intractable integral over the parameter space :math:`\Theta`. The omnipresence of this problem gave rise to a rapidly expanding field of research referred to as simulation-based inference (SBI). Pushed by the advances in machine learning, modern SBI approaches are to train a parametric surrogate :math:`p_\phi(\theta | x)` of the posterior and, then, proceed as if the latter was tractable. + +References +---------- + +The frontier of simulation-based inference +(Cranmer et al., 2020) +https://www.pnas.org/doi/10.1073/pnas.1912789117 + +Approximating Likelihood Ratios with Calibrated Discriminative Classifiers +(Cranmer et al., 2015) +https://arxiv.org/abs/1506.02169 + +Likelihood-free MCMC with Amortized Approximate Ratio Estimators +(Hermans et al., 2019) +https://arxiv.org/abs/1903.04057 + +Fast Likelihood-free Inference with Autoregressive Flows +(Papamakarios et al., 2018) +https://arxiv.org/abs/1805.07226 + +Automatic Posterior Transformation for Likelihood-Free Inference +(Greenberg et al., 2019) +https://arxiv.org/abs/1905.07488 + +Arbitrary Marginal Neural Ratio Estimation for Simulation-based Inference +(Rozet et al., 2021) +https://arxiv.org/abs/2110.00449 + +.. toctree:: + :caption: lampe + :hidden: + :maxdepth: 2 + + tutorials.rst + api/index.rst + +.. toctree:: + :caption: Development + :hidden: + :maxdepth: 1 + + Contributing + Changelog + License diff --git a/sphinx/static/banner.svg b/sphinx/static/banner.svg new file mode 100644 index 0000000..f679a0a --- /dev/null +++ b/sphinx/static/banner.svg @@ -0,0 +1,58 @@ + + diff --git a/sphinx/static/banner_dark.svg b/sphinx/static/banner_dark.svg new file mode 100644 index 0000000..99cd37f --- /dev/null +++ b/sphinx/static/banner_dark.svg @@ -0,0 +1,58 @@ + + diff --git a/sphinx/static/custom.css b/sphinx/static/custom.css new file mode 100644 index 0000000..214065c --- /dev/null +++ b/sphinx/static/custom.css @@ -0,0 +1,140 @@ +/* Miscellaneous */ + +* { + overflow-wrap: break-word; +} + +a { + text-decoration: none; +} + +h2 { + font-size: 1.75em; +} + +p.rubric { + font-size: var(--font-size--small); + font-weight: 500; + margin-bottom: 0; + margin-top: 0.25rem; + text-transform: uppercase; +} + +/* Admonitions */ + +div.admonition { + box-shadow: 5px 5px 10px rgb(0 0 0 / 5%); +} + +/* Citations */ + +dl.citation { + display: grid; + grid-gap: 0.75rem; + grid-template-columns: auto auto; + margin: 0.5rem 0 0.75rem 0.75rem; +} + +dl.citation > dt { + color: inherit !important; +} + +dl.citation > dt > span.brackets:not(:last-child) { + margin-right: 0.5rem; +} + +dl.citation > dd { + margin-left: 0 !important; +} + +dl.citation > dd > :first-child { + margin-top: 0 !important; +} + +dl.citation > dd > :last-child { + margin-bottom: 0 !important; +} + +/* Code */ + +div[class*=" highlight-"], +div[class^=highlight-] { + margin-top: 0.5rem; +} + +.highlight, +.highlight span, +.literal { + background: var(--color-api-background) !important; + border: none !important; + font-style: normal !important; + font-weight: normal !important; + text-decoration: none !important; +} + +div.cell > div.cell_input { + background: var(--color-api-background); + border: unset; + border-left: medium green solid; + border-radius: 0.2rem; +} + +div.cell > div.cell_output > div.output { + background: unset; + border: unset; +} + +/* Footnotes */ + +dl.footnote.brackets > dt:after { + content: unset; +} + +/* Lists */ + +dl.field-list > dd strong { + font-family: var(--font-stack--monospace); +} + +/* Math */ + +div.math-wrapper { + overflow-x: unset; + overflow-y: auto; + margin-bottom: 0.75rem; +} + +mjx-container[display="true"] { + margin: 0.125rem 0 !important; +} + +/* Sidebar */ + +img.sidebar-logo { + max-width: 50%; +} + +div.sidebar-tree .reference.external { + color: var(--color-link); +} + +div.sidebar-tree .reference.internal, +div.sidebar-tree label .icon { + color: var(--color-sidebar-link-text) !important; +} + +/* Signatures */ + +dl.py > dt.sig > a.headerlink { + margin-right: 2em; +} + +dl.py > dt.sig > a.reference { + float: right; + text-indent: 0; + width: 0; +} + +dl.py > dt.sig > a.reference > span.viewcode-link { + width: unset; +} diff --git a/sphinx/static/logo.svg b/sphinx/static/logo.svg new file mode 100644 index 0000000..763c0af --- /dev/null +++ b/sphinx/static/logo.svg @@ -0,0 +1,7 @@ + + + + + + + diff --git a/sphinx/static/logo_dark.svg b/sphinx/static/logo_dark.svg new file mode 100644 index 0000000..dac3b98 --- /dev/null +++ b/sphinx/static/logo_dark.svg @@ -0,0 +1,7 @@ + + + + + + + diff --git a/sphinx/tutorials.rst b/sphinx/tutorials.rst new file mode 100644 index 0000000..8f842f2 --- /dev/null +++ b/sphinx/tutorials.rst @@ -0,0 +1,7 @@ +Tutorials +========= + +.. toctree:: + + 1. NPE + 2. NRE