diff --git a/captum/optim/__init__.py b/captum/optim/__init__.py index 0358aa9860..5d1b90f76a 100755 --- a/captum/optim/__init__.py +++ b/captum/optim/__init__.py @@ -6,4 +6,6 @@ from captum.optim._param.image import images # noqa: F401 from captum.optim._param.image import transform # noqa: F401 from captum.optim._param.image.images import ImageTensor # noqa: F401 -from captum.optim._utils import models # noqa: F401 +from captum.optim._utils import circuits, models, reducer # noqa: F401 +from captum.optim._utils.image.common import nchannels_to_rgb # noqa: F401 +from captum.optim._utils.image.common import weights_to_heatmap_2d # noqa: F401 diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index b0e7573086..138a6da15c 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -4,7 +4,7 @@ import torch import torch.nn as nn -from captum.optim._utils.images import get_neuron_pos +from captum.optim._utils.image.common import get_neuron_pos from captum.optim._utils.typing import ModuleOutputMapping @@ -66,18 +66,16 @@ def __init__( self.x = x self.y = y - # ensure channel_index will be valid - assert self.channel_index < self.target.out_channels - - def _call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: + def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target] assert activations is not None + assert self.channel_index < activations.shape[1] assert len(activations.shape) == 4 # assume NCHW _x, _y = get_neuron_pos( activations.size(2), activations.size(3), self.x, self.y ) - return activations[:, self.channel_index, _x, _y] + return activations[:, self.channel_index, _x : _x + 1, _y : _y + 1] class DeepDream(Loss): @@ -98,7 +96,7 @@ class TotalVariation(Loss): https://arxiv.org/abs/1412.0035 """ - def _call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: + def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target] x_diff = activations[..., 1:, :] - activations[..., :-1, :] y_diff = activations[..., :, 1:] - activations[..., :, :-1] @@ -115,7 +113,7 @@ def __init__(self, target: nn.Module, constant: float = 0.0) -> None: self.target = target self.constant = constant - def _call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: + def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target] return torch.abs(activations - self.constant).sum() @@ -132,7 +130,7 @@ def __init__( self.constant = constant self.epsilon = epsilon - def _call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: + def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target] activations = (activations - self.constant).sum() return torch.sqrt(self.epsilon + activations) @@ -145,7 +143,7 @@ class Diversity(Loss): https://distill.pub/2017/feature-visualization/#diversity """ - def _call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: + def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target] return -sum( [ @@ -260,7 +258,7 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: return torch.cosine_similarity(self.direction, activations) -class DirectionNeuron(Loss): +class NeuronDirection(Loss): """ Visualize a single (x, y) position for a direction vector. Carter, et al., "Activation Atlas", Distill, 2019. @@ -271,16 +269,16 @@ def __init__( self, target: nn.Module, vec: torch.Tensor, - channel_index: int, x: Optional[int] = None, y: Optional[int] = None, + channel_index: Optional[int] = None, ) -> None: super(Loss, self).__init__() self.target = target self.direction = vec.reshape((1, -1, 1, 1)) - self.channel_index = channel_index self.x = x self.y = y + self.channel_index = channel_index def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target] @@ -290,8 +288,10 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: _x, _y = get_neuron_pos( activations.size(2), activations.size(3), self.x, self.y ) - activations = activations[:, self.channel_index, _x, _y] - return torch.cosine_similarity(self.direction, activations[None, None, None]) + activations = activations[:, :, _x : _x + 1, _y : _y + 1] + if self.channel_index is not None: + activations = activations[:, self.channel_index, ...][:, None, ...] + return torch.cosine_similarity(self.direction, activations) class TensorDirection(Loss): @@ -361,7 +361,9 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: _x, _y = get_neuron_pos( activations.size(2), activations.size(3), self.x, self.y ) - activations = activations[..., _x, _y].squeeze() * self.weights + activations = ( + activations[..., _x : _x + 1, _y : _y + 1].squeeze() * self.weights + ) else: activations = activations[ ..., self.y : self.y + self.wy, self.x : self.x + self.wx diff --git a/captum/optim/_core/objectives.py b/captum/optim/_core/objectives.py index 1a59540556..d879f12276 100644 --- a/captum/optim/_core/objectives.py +++ b/captum/optim/_core/objectives.py @@ -10,7 +10,10 @@ try: from tqdm.auto import tqdm except (ImportError, AssertionError): - print("The tqdm package is required to use Captum's Optim library") + print( + "The tqdm package is required to use captum.optim's" + + " n_steps stop criteria with progress bar" + ) from captum.optim._core.output_hook import AbortForwardException, ModuleOutputsHook from captum.optim._param.image.images import InputParameterization, NaturalImage @@ -147,23 +150,32 @@ def optimize( return history -def n_steps(n: int) -> StopCriteria: +def n_steps(n: int, show_progress: bool = True) -> StopCriteria: """StopCriteria generator that uses number of steps as a stop criteria. Args: n (int): Number of steps to run optimization. + show_progress (bool, optional): Whether or not to show progress bar. + Default: True Returns: *StopCriteria* callable """ - pbar = tqdm(total=n, unit="step") + + if show_progress: + pbar = tqdm(total=n, unit=" step") def continue_while(step, obj, history, optim) -> bool: if len(history) > 0: - pbar.set_postfix({"Objective": f"{history[-1].mean():.1f}"}, refresh=False) + if show_progress: + pbar.set_postfix( + {"Objective": f"{history[-1].mean():.1f}"}, refresh=False + ) if step < n: - pbar.update() + if show_progress: + pbar.update() return True else: - pbar.close() + if show_progress: + pbar.close() return False return continue_while diff --git a/captum/optim/_core/output_hook.py b/captum/optim/_core/output_hook.py index 8bd365075a..9f4db55031 100755 --- a/captum/optim/_core/output_hook.py +++ b/captum/optim/_core/output_hook.py @@ -1,9 +1,10 @@ -from typing import Iterable +from contextlib import suppress +from typing import Iterable, List, Union from warnings import warn import torch.nn as nn -# from clarity.pytorch import ModuleOutputMapping +from captum.optim._utils.typing import ModelInputType, ModuleOutputMapping class AbortForwardException(Exception): @@ -88,3 +89,23 @@ def remove_hooks(self) -> None: def __del__(self) -> None: # print(f"DEL HOOKS!: {list(self.outputs.keys())}") self.remove_hooks() + + +class ActivationFetcher: + """ + Simple module for collecting activations from model targets. + """ + + def __init__(self, model, targets: Union[nn.Module, List[nn.Module]]) -> None: + super(ActivationFetcher, self).__init__() + self.model = model + self.layers = ModuleOutputsHook(targets) + + def __call__(self, input_t: ModelInputType) -> ModuleOutputMapping: + try: + with suppress(AbortForwardException): + self.model(input_t) + activations = self.layers.consume_outputs() + finally: + self.layers.remove_hooks() + return activations diff --git a/captum/optim/_models/inception_v1.py b/captum/optim/_models/inception_v1.py index 8021b77d6c..7fa6441720 100644 --- a/captum/optim/_models/inception_v1.py +++ b/captum/optim/_models/inception_v1.py @@ -67,7 +67,6 @@ def __init__( out_channels=64, kernel_size=(7, 7), stride=(2, 2), - padding=(3, 3), groups=1, bias=True, ) @@ -89,7 +88,6 @@ def __init__( out_channels=192, kernel_size=(3, 3), stride=(1, 1), - padding=(1, 1), groups=1, bias=True, ) @@ -132,6 +130,7 @@ def _transform_input(self, x: torch.Tensor) -> torch.Tensor: def forward(self, x: torch.Tensor) -> torch.Tensor: x = self._transform_input(x) + x = F.pad(x, (2, 3, 2, 3)) x = self.conv1(x) x = self.conv1_relu(x) x = F.pad(x, (0, 1, 0, 1), value=float("-inf")) @@ -140,6 +139,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: x = self.conv2(x) x = self.conv2_relu(x) + x = F.pad(x, (1, 1, 1, 1)) x = self.conv3(x) x = self.conv3_relu(x) x = self.localresponsenorm2(x) @@ -214,7 +214,6 @@ def __init__( out_channels=c3x3, kernel_size=(3, 3), stride=(1, 1), - padding=(1, 1), groups=1, bias=True, ) @@ -234,7 +233,6 @@ def __init__( out_channels=c5x5, kernel_size=(5, 5), stride=(1, 1), - padding=(2, 2), groups=1, bias=True, ) @@ -257,18 +255,20 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: c3x3 = self.conv_3x3_reduce(x) c3x3 = self.conv_3x3_reduce_relu(c3x3) + c3x3 = F.pad(c3x3, (1, 1, 1, 1)) c3x3 = self.conv_3x3(c3x3) c3x3 = self.conv_3x3_relu(c3x3) c5x5 = self.conv_5x5_reduce(x) c5x5 = self.conv_5x5_reduce_relu(c5x5) + c5x5 = F.pad(c5x5, (2, 2, 2, 2)) c5x5 = self.conv_5x5(c5x5) c5x5 = self.conv_5x5_relu(c5x5) - px = self.pool_proj(x) - px = self.pool_proj_relu(px) - px = F.pad(px, (1, 1, 1, 1), value=float("-inf")) + px = F.pad(x, (1, 1, 1, 1), value=float("-inf")) px = self.pool(px) + px = self.pool_proj(px) + px = self.pool_proj_relu(px) return torch.cat([c1x1, c3x3, c5x5, px], dim=1) diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index 694992ae53..0cb1123b45 100755 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -1,420 +1,518 @@ -from copy import deepcopy -from typing import Any, Callable, Dict, List, Optional, Tuple - -import matplotlib.pyplot as plt -import numpy as np -import torch -import torch.nn as nn -import torch.nn.functional as F - -try: - from PIL import Image -except (ImportError, AssertionError): - print("The Pillow/PIL library is required to use Captum's Optim library") - -from captum.optim._param.image.transform import ToRGB -from captum.optim._utils.typing import InitSize, SquashFunc - - -class ImageTensor(torch.Tensor): - def __init__(self, data, **kwargs) -> None: - if not isinstance(data, torch.Tensor): - data = torch.as_tensor(data, **kwargs) - self._t = data - - @classmethod - def open(cls, path: str, scale: float = 255.0): - img_np = Image.open(path).convert("RGB") - img_np = np.array(img_np).astype(np.float32) - return cls(img_np.transpose(2, 0, 1) / scale) - - @classmethod - def __torch_function__( - self, - func: Callable, - types: Tuple, - args: Tuple = (), - kwargs: Optional[Dict] = None, - ) -> Any: - if kwargs is None: - kwargs = {} - args_t = [a._t if hasattr(a, "_t") else a for a in args] - return super().__torch_function__(func, types, args_t, **kwargs) - - def __repr__(self) -> str: - return f"ImageTensor(value={self._t})" - - def show(self, scale: float = 255.0) -> None: - if len(self.shape) == 3: - numpy_thing = self.cpu().detach().numpy().transpose(1, 2, 0) * scale - elif len(self.shape) == 4: - numpy_thing = self.cpu().detach().numpy()[0].transpose(1, 2, 0) * scale - plt.imshow(numpy_thing.astype(np.uint8)) - plt.axis("off") - plt.show() - - def export(self, filename: str, scale: float = 255.0) -> None: - colorspace = "RGB" if self.size(1) == 3 else "RGBA" - if len(self.shape) == 3: - numpy_thing = self.cpu().detach().numpy().transpose(1, 2, 0) * scale - elif len(self.shape) == 4: - numpy_thing = self.cpu().detach().numpy()[0].transpose(1, 2, 0) * scale - im = Image.fromarray(numpy_thing.astype("uint8"), colorspace) - im.save(filename) - - def cpu(self) -> "ImageTensor": - return self - - def cuda(self) -> "CudaImageTensor": - return CudaImageTensor(self._t, device="cuda") - - -class CudaImageTensor(object): - def __init__(self, data, **kwargs) -> None: - self._t = torch.as_tensor(data, **kwargs) - - @classmethod - def __torch_function__( - self, - func: Callable, - types: Tuple, - args: Tuple = (), - kwargs: Optional[Dict] = None, - ) -> Any: - if kwargs is None: - kwargs = {} - args_t = [a._t if hasattr(a, "_t") else a for a in args] - return super().__torch_function__(func, types, args_t, **kwargs) - - def __repr__(self) -> str: - return f"CudaImageTensor(value={self._t})" - - @property - def shape(self) -> torch.Size: - return self._t.shape - - @property - def size(self) -> torch.Size: - return self._t.size() - - def show(self) -> None: - self.cpu().show() - - def export(self, filename: str) -> None: - self.cpu().export(filename) - - def cpu(self) -> "ImageTensor": - return ImageTensor(self._t.cpu()) - - def cuda(self) -> "CudaImageTensor": - return self - - -# mean = [0.485, 0.456, 0.406] -# std = [0.229, 0.224, 0.225] - -# normalize = transforms.Normalize(mean=mean, std=std) - -# mean = torch.Tensor(mean)[None, :, None, None] -# std = torch.Tensor(std)[None, :, None, None] - - -# def denormalize(x: torch.Tensor): -# return std * x + mean - - -def logit(p: torch.Tensor, epsilon: float = 1e-6) -> torch.Tensor: - p = torch.clamp(p, min=epsilon, max=1.0 - epsilon) - assert p.min() >= 0 and p.max() < 1 - return torch.log(p / (1 - p)) - - -# def jitter(x: torch.Tensor, pad_width=2, pad_value=0.5): -# _, _, H, W = x.shape -# y = F.pad(x, 4 * (pad_width,), value=pad_value) -# idx, idy = np.random.randint(low=0, high=2 * pad_width, size=(2,)) -# return y[:, :, idx : idx + H, idy : idy + W] - - -# def color_correction(): -# S = np.asarray( -# [[0.26, 0.09, 0.02], [0.27, 0.00, -0.05], [0.27, -0.09, 0.03]] -# ).astype("float32") -# C = S / np.max(np.linalg.norm(S, axis=0)) -# C = torch.Tensor(C) -# return C.transpose(0, 1) - - -# def upsample(): -# upsample = torch.nn.Upsample(scale_factor=1.1, mode="bilinear", -# align_corners=True) - -# def up(x): -# upsample.scale_factor = ( -# 1 + np.random.randn(1)[0] / 50, -# 1 + np.random.randn(1)[0] / 50, -# ) -# return upsample(x) - -# return up - - -class InputParameterization(torch.nn.Module): - def forward(self): - raise NotImplementedError - - -class ImageParameterization(InputParameterization): - def setup_batch( - self, x: torch.Tensor, batch: int = 1, dim: int = 3 - ) -> torch.Tensor: - assert batch > 0 - x = x.unsqueeze(0) if x.dim() == dim and batch == 1 else x - x = ( - torch.stack([x.clone() for b in range(batch)]) - if x.dim() == dim and batch > 1 - else x - ) - return x - - def set_image(self, x: torch.Tensor): - ... - - -class FFTImage(ImageParameterization): - """Parameterize an image using inverse real 2D FFT""" - - def __init__( - self, - size: InitSize = None, - channels: int = 3, - batch: int = 1, - init: Optional[torch.Tensor] = None, - ) -> None: - super().__init__() - if init is None: - assert len(size) == 2 - self.size = size - else: - assert init.dim() == 3 or init.dim() == 4 - self.size = ( - (init.size(1), init.size(2)) - if init.dim() == 3 - else (init.size(2), init.size(3)) - ) - self.torch_rfft, self.torch_irfft = self.get_fft_funcs() - - frequencies = FFTImage.rfft2d_freqs(*self.size) - scale = 1.0 / torch.max( - frequencies, - torch.full_like(frequencies, 1.0 / (max(self.size[0], self.size[1]))), - ) - scale = scale * ((self.size[0] * self.size[1]) ** (1 / 2)) - spectrum_scale = scale[None, :, :, None] - self.register_buffer("spectrum_scale", spectrum_scale) - - if init is None: - coeffs_shape = (channels, self.size[0], self.size[1] // 2 + 1, 2) - random_coeffs = torch.randn( - coeffs_shape - ) # names=["C", "H_f", "W_f", "complex"] - fourier_coeffs = random_coeffs / 50 - else: - fourier_coeffs = self.torch_rfft(init) / spectrum_scale - - fourier_coeffs = self.setup_batch(fourier_coeffs, batch, 4) - self.fourier_coeffs = nn.Parameter(fourier_coeffs) - - @staticmethod - def rfft2d_freqs(height: int, width: int) -> torch.Tensor: - """Computes 2D spectrum frequencies.""" - fy = FFTImage.pytorch_fftfreq(height)[:, None] - # on odd input dimensions we need to keep one additional frequency - wadd = 2 if width % 2 == 1 else 1 - fx = FFTImage.pytorch_fftfreq(width)[: width // 2 + wadd] - return torch.sqrt((fx * fx) + (fy * fy)) - - @staticmethod - def pytorch_fftfreq(v: int, d: float = 1.0) -> torch.Tensor: - """PyTorch version of np.fft.fftfreq""" - results = torch.empty(v) - s = (v - 1) // 2 + 1 - results[:s] = torch.arange(0, s) - results[s:] = torch.arange(-(v // 2), 0) - return results * (1.0 / (v * d)) - - def set_image(self, correlated_image: torch.Tensor) -> None: - coeffs = self.torch_rfft(correlated_image) - self.fourier_coeffs = coeffs / self.spectrum_scale - - def get_fft_funcs(self) -> Tuple[Callable, Callable]: - """Support older versions of PyTorch""" - try: - import torch.fft - - torch_rfft = lambda x: torch.view_as_real(torch.fft.rfftn(x, s=self.size)) # type: ignore # noqa: E731 E501 - - def torch_irfft(x: torch.Tensor) -> torch.Tensor: - if type(x) is not torch.complex64: - x = torch.view_as_complex(x) - return torch.fft.irfftn(x, s=self.size) # type: ignore - - except (ImportError, AssertionError): - import torch - - torch_rfft = lambda x: torch.rfft(x, signal_ndim=2) # noqa: E731 - torch_irfft = lambda x: torch.irfft(x, signal_ndim=2)[ # noqa: E731 - :, :, : self.size[0], : self.size[1] # noqa: E731 - ] # noqa: E731 - return torch_rfft, torch_irfft - - def forward(self) -> torch.Tensor: - h, w = self.size - scaled_spectrum = self.fourier_coeffs * self.spectrum_scale - output = self.torch_irfft(scaled_spectrum) - return output.refine_names("B", "C", "H", "W") - - -class PixelImage(ImageParameterization): - def __init__( - self, - size: InitSize = None, - channels: int = 3, - batch: int = 1, - init: Optional[torch.Tensor] = None, - ) -> None: - super().__init__() - if init is None: - assert size is not None and channels is not None and batch is not None - init = torch.randn([channels, size[0], size[1]]) / 10 + 0.5 - else: - assert init.shape[0] == 3 - init = self.setup_batch(init, batch) - self.image = nn.Parameter(init) - - def forward(self) -> torch.Tensor: - return self.image.refine_names("B", "C", "H", "W") - - def set_image(self, correlated_image: torch.Tensor) -> None: - self.image = nn.Parameter(correlated_image) - - -class LaplacianImage(ImageParameterization): - def __init__( - self, - size: InitSize = None, - channels: int = 3, - batch: int = 1, - init: Optional[torch.Tensor] = None, - ) -> None: - super().__init__() - power = 0.1 - - if init is None: - tensor_params, self.scaler = self.setup_input(size, channels, power, init) - - self.tensor_params = torch.nn.ModuleList( - [deepcopy(tensor_params) for b in range(batch)] - ) - else: - init = init.unsqueeze(0) if init.dim() == 3 else init - P = [] - for b in range(init.size(0)): - tensor_params, self.scaler = self.setup_input( - size, channels, power, init[b].unsqueeze(0) - ) - P.append(tensor_params) - self.tensor_params = torch.nn.ModuleList(P) - - def setup_input( - self, - size: InitSize, - channels: int, - power: float = 0.1, - init: Optional[torch.Tensor] = None, - ) -> Tuple[List[torch.Tensor], List[torch.nn.Upsample]]: - tensor_params, scaler = [], [] - scale_list = [1, 2, 4, 8, 16, 32] - for scale in scale_list: - h, w = int(size[0] // scale), int(size[1] // scale) - if init is None: - x = torch.randn([1, channels, h, w]) / 10 - else: - x = F.interpolate(init.clone(), size=(h, w), mode="bilinear") - x = x / 6 # Prevents output from being all white - upsample = torch.nn.Upsample(scale_factor=scale, mode="nearest") - x = x * (scale ** power) / (32 ** power) - x = torch.nn.Parameter(x) - tensor_params.append(x) - scaler.append(upsample) - tensor_params = torch.nn.ParameterList(tensor_params) - return tensor_params, scaler - - def create_tensor(self, params_list: torch.nn.ParameterList) -> torch.Tensor: - A = [] - for xi, upsamplei in zip(params_list, self.scaler): - A.append(upsamplei(xi)) - return torch.sum(torch.cat(A), 0) + 0.5 - - def forward(self) -> torch.Tensor: - A = [] - for params_list in self.tensor_params: - tensor = self.create_tensor(params_list) - A.append(tensor) - return torch.stack(A).refine_names("B", "C", "H", "W") - - -class NaturalImage(ImageParameterization): - r"""Outputs an optimizable input image. - - By convention, single images are CHW and float32s in [0,1]. - The underlying parameterization is decorrelated via a ToRGB transform. - When used with the (default) FFT parameterization, this results in a fully - uncorrelated image parameterization. :-) - - If a model requires a normalization step, such as normalizing imagenet RGB values, - or rescaling to [0,255], it has to perform that step inside its computation. - For example, our GoogleNet factory function has a `transform_input=True` argument. - """ - - def __init__( - self, - size: InitSize = None, - channels: int = 3, - batch: int = 1, - Parameterization=FFTImage, - init: Optional[torch.Tensor] = None, - decorrelate_init: bool = True, - squash_func: Optional[SquashFunc] = None, - ) -> None: - super().__init__() - self.decorrelate = ToRGB(transform_name="klt") - if init is not None: - assert init.dim() == 3 or init.dim() == 4 - if decorrelate_init: - init = ( - init.refine_names("B", "C", "H", "W") - if init.dim() == 4 - else init.refine_names("C", "H", "W") - ) - init = self.decorrelate(init, inverse=True).rename(None) - if squash_func is None: - squash_func: SquashFunc = lambda x: x.clamp(0, 1) - else: - if squash_func is None: - squash_func: SquashFunc = lambda x: torch.sigmoid(x) - self.squash_func = squash_func - self.parameterization = Parameterization( - size=size, channels=channels, batch=batch, init=init - ) - - def forward(self) -> torch.Tensor: - image = self.parameterization() - image = self.decorrelate(image) - image = image.rename(None) # TODO: the world is not yet ready - return CudaImageTensor(self.squash_func(image)) - - def set_image(self, image: torch.Tensor) -> None: - logits = logit(image, epsilon=1e-4) - correlated = self.decorrelate(logits, inverse=True) - self.parameterization.set_image(correlated) +from copy import deepcopy +from typing import Any, Callable, Dict, List, Optional, Tuple, Union + +import matplotlib.pyplot as plt +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F + +try: + from PIL import Image +except (ImportError, AssertionError): + print("The Pillow/PIL library is required to use Captum's Optim library") + +from captum.optim._param.image.transform import SymmetricPadding, ToRGB +from captum.optim._utils.typing import InitSize, SquashFunc + + +class ImageTensor(torch.Tensor): + def __init__(self, data, **kwargs) -> None: + if not isinstance(data, torch.Tensor): + data = torch.as_tensor(data, **kwargs) + self._t = data + + @classmethod + def open(cls, path: str, scale: float = 255.0): + img_np = Image.open(path).convert("RGB") + img_np = np.array(img_np).astype(np.float32) + return cls(img_np.transpose(2, 0, 1) / scale) + + @classmethod + def __torch_function__( + self, + func: Callable, + types: Tuple, + args: Tuple = (), + kwargs: Optional[Dict] = None, + ) -> Any: + if kwargs is None: + kwargs = {} + args_t = [a._t if hasattr(a, "_t") else a for a in args] + return super().__torch_function__(func, types, args_t, **kwargs) + + def __repr__(self) -> str: + return f"ImageTensor(value={self._t})" + + def show(self, scale: float = 255.0) -> None: + if len(self.shape) == 3: + numpy_thing = self.cpu().detach().numpy().transpose(1, 2, 0) * scale + elif len(self.shape) == 4: + numpy_thing = self.cpu().detach().numpy()[0].transpose(1, 2, 0) * scale + plt.imshow(numpy_thing.astype(np.uint8)) + plt.axis("off") + plt.show() + + def export(self, filename: str, scale: float = 255.0) -> None: + colorspace = "RGB" if self.size(1) == 3 else "RGBA" + if len(self.shape) == 3: + numpy_thing = self.cpu().detach().numpy().transpose(1, 2, 0) * scale + elif len(self.shape) == 4: + numpy_thing = self.cpu().detach().numpy()[0].transpose(1, 2, 0) * scale + im = Image.fromarray(numpy_thing.astype("uint8"), colorspace) + im.save(filename) + + def cpu(self) -> "ImageTensor": + return self + + def cuda(self) -> "CudaImageTensor": + return CudaImageTensor(self._t, device="cuda") + + +class CudaImageTensor(object): + def __init__(self, data, **kwargs) -> None: + self._t = torch.as_tensor(data, **kwargs) + + @classmethod + def __torch_function__( + self, + func: Callable, + types: Tuple, + args: Tuple = (), + kwargs: Optional[Dict] = None, + ) -> Any: + if kwargs is None: + kwargs = {} + args_t = [a._t if hasattr(a, "_t") else a for a in args] + return super().__torch_function__(func, types, args_t, **kwargs) + + def __repr__(self) -> str: + return f"CudaImageTensor(value={self._t})" + + @property + def shape(self) -> torch.Size: + return self._t.shape + + @property + def size(self) -> torch.Size: + return self._t.size() + + def show(self) -> None: + self.cpu().show() + + def export(self, filename: str) -> None: + self.cpu().export(filename) + + def cpu(self) -> "ImageTensor": + return ImageTensor(self._t.cpu()) + + def cuda(self) -> "CudaImageTensor": + return self + + +# mean = [0.485, 0.456, 0.406] +# std = [0.229, 0.224, 0.225] + +# normalize = transforms.Normalize(mean=mean, std=std) + +# mean = torch.Tensor(mean)[None, :, None, None] +# std = torch.Tensor(std)[None, :, None, None] + + +# def denormalize(x: torch.Tensor): +# return std * x + mean + + +def logit(p: torch.Tensor, epsilon: float = 1e-6) -> torch.Tensor: + p = torch.clamp(p, min=epsilon, max=1.0 - epsilon) + assert p.min() >= 0 and p.max() < 1 + return torch.log(p / (1 - p)) + + +# def jitter(x: torch.Tensor, pad_width=2, pad_value=0.5): +# _, _, H, W = x.shape +# y = F.pad(x, 4 * (pad_width,), value=pad_value) +# idx, idy = np.random.randint(low=0, high=2 * pad_width, size=(2,)) +# return y[:, :, idx : idx + H, idy : idy + W] + + +# def color_correction(): +# S = np.asarray( +# [[0.26, 0.09, 0.02], [0.27, 0.00, -0.05], [0.27, -0.09, 0.03]] +# ).astype("float32") +# C = S / np.max(np.linalg.norm(S, axis=0)) +# C = torch.Tensor(C) +# return C.transpose(0, 1) + + +# def upsample(): +# upsample = torch.nn.Upsample(scale_factor=1.1, mode="bilinear", +# align_corners=True) + +# def up(x): +# upsample.scale_factor = ( +# 1 + np.random.randn(1)[0] / 50, +# 1 + np.random.randn(1)[0] / 50, +# ) +# return upsample(x) + +# return up + + +class InputParameterization(torch.nn.Module): + def forward(self): + raise NotImplementedError + + +class ImageParameterization(InputParameterization): + def setup_batch( + self, x: torch.Tensor, batch: int = 1, dim: int = 3 + ) -> torch.Tensor: + assert batch > 0 + x = x.unsqueeze(0) if x.dim() == dim and batch == 1 else x + x = ( + torch.stack([x.clone() for b in range(batch)]) + if x.dim() == dim and batch > 1 + else x + ) + return x + + +class FFTImage(ImageParameterization): + """Parameterize an image using inverse real 2D FFT""" + + def __init__( + self, + size: InitSize = None, + channels: int = 3, + batch: int = 1, + init: Optional[torch.Tensor] = None, + ) -> None: + super().__init__() + if init is None: + assert len(size) == 2 + self.size = size + else: + assert init.dim() == 3 or init.dim() == 4 + self.size = ( + (init.size(1), init.size(2)) + if init.dim() == 3 + else (init.size(2), init.size(3)) + ) + self.torch_rfft, self.torch_irfft = self.get_fft_funcs() + + frequencies = FFTImage.rfft2d_freqs(*self.size) + scale = 1.0 / torch.max( + frequencies, + torch.full_like(frequencies, 1.0 / (max(self.size[0], self.size[1]))), + ) + scale = scale * ((self.size[0] * self.size[1]) ** (1 / 2)) + spectrum_scale = scale[None, :, :, None] + self.register_buffer("spectrum_scale", spectrum_scale) + + if init is None: + coeffs_shape = (channels, self.size[0], self.size[1] // 2 + 1, 2) + random_coeffs = torch.randn( + coeffs_shape + ) # names=["C", "H_f", "W_f", "complex"] + fourier_coeffs = random_coeffs / 50 + else: + fourier_coeffs = self.torch_rfft(init) / spectrum_scale + + fourier_coeffs = self.setup_batch(fourier_coeffs, batch, 4) + self.fourier_coeffs = nn.Parameter(fourier_coeffs) + + @staticmethod + def rfft2d_freqs(height: int, width: int) -> torch.Tensor: + """Computes 2D spectrum frequencies.""" + fy = FFTImage.pytorch_fftfreq(height)[:, None] + # on odd input dimensions we need to keep one additional frequency + wadd = 2 if width % 2 == 1 else 1 + fx = FFTImage.pytorch_fftfreq(width)[: width // 2 + wadd] + return torch.sqrt((fx * fx) + (fy * fy)) + + @staticmethod + def pytorch_fftfreq(v: int, d: float = 1.0) -> torch.Tensor: + """PyTorch version of np.fft.fftfreq""" + results = torch.empty(v) + s = (v - 1) // 2 + 1 + results[:s] = torch.arange(0, s) + results[s:] = torch.arange(-(v // 2), 0) + return results * (1.0 / (v * d)) + + def get_fft_funcs(self) -> Tuple[Callable, Callable]: + """Support older versions of PyTorch""" + try: + import torch.fft + + torch_rfft = lambda x: torch.view_as_real(torch.fft.rfftn(x, s=self.size)) # type: ignore # noqa: E731 E501 + + def torch_irfft(x: torch.Tensor) -> torch.Tensor: + if type(x) is not torch.complex64: + x = torch.view_as_complex(x) + return torch.fft.irfftn(x, s=self.size) # type: ignore + + except (ImportError, AssertionError): + import torch + + torch_rfft = lambda x: torch.rfft(x, signal_ndim=2) # noqa: E731 + torch_irfft = lambda x: torch.irfft(x, signal_ndim=2)[ # noqa: E731 + :, :, : self.size[0], : self.size[1] # noqa: E731 + ] # noqa: E731 + return torch_rfft, torch_irfft + + def forward(self) -> torch.Tensor: + h, w = self.size + scaled_spectrum = self.fourier_coeffs * self.spectrum_scale + output = self.torch_irfft(scaled_spectrum) + return output.refine_names("B", "C", "H", "W") + + +class PixelImage(ImageParameterization): + def __init__( + self, + size: InitSize = None, + channels: int = 3, + batch: int = 1, + init: Optional[torch.Tensor] = None, + ) -> None: + super().__init__() + if init is None: + assert size is not None and channels is not None and batch is not None + init = torch.randn([channels, size[0], size[1]]) / 10 + 0.5 + else: + assert init.shape[0] == 3 + init = self.setup_batch(init, batch) + self.image = nn.Parameter(init) + + def forward(self) -> torch.Tensor: + return self.image.refine_names("B", "C", "H", "W") + + +class LaplacianImage(ImageParameterization): + def __init__( + self, + size: InitSize = None, + channels: int = 3, + batch: int = 1, + init: Optional[torch.Tensor] = None, + ) -> None: + super().__init__() + power = 0.1 + + if init is None: + tensor_params, self.scaler = self.setup_input(size, channels, power, init) + + self.tensor_params = torch.nn.ModuleList( + [deepcopy(tensor_params) for b in range(batch)] + ) + else: + init = init.unsqueeze(0) if init.dim() == 3 else init + P = [] + for b in range(init.size(0)): + tensor_params, self.scaler = self.setup_input( + size, channels, power, init[b].unsqueeze(0) + ) + P.append(tensor_params) + self.tensor_params = torch.nn.ModuleList(P) + + def setup_input( + self, + size: InitSize, + channels: int, + power: float = 0.1, + init: Optional[torch.Tensor] = None, + ) -> Tuple[List[torch.Tensor], List[torch.nn.Upsample]]: + tensor_params, scaler = [], [] + scale_list = [1, 2, 4, 8, 16, 32] + for scale in scale_list: + h, w = int(size[0] // scale), int(size[1] // scale) + if init is None: + x = torch.randn([1, channels, h, w]) / 10 + else: + x = F.interpolate(init.clone(), size=(h, w), mode="bilinear") + x = x / 6 # Prevents output from being all white + upsample = torch.nn.Upsample(scale_factor=scale, mode="nearest") + x = x * (scale ** power) / (32 ** power) + x = torch.nn.Parameter(x) + tensor_params.append(x) + scaler.append(upsample) + tensor_params = torch.nn.ParameterList(tensor_params) + return tensor_params, scaler + + def create_tensor(self, params_list: torch.nn.ParameterList) -> torch.Tensor: + A = [] + for xi, upsamplei in zip(params_list, self.scaler): + A.append(upsamplei(xi)) + return torch.sum(torch.cat(A), 0) + 0.5 + + def forward(self) -> torch.Tensor: + A = [] + for params_list in self.tensor_params: + tensor = self.create_tensor(params_list) + A.append(tensor) + return torch.stack(A).refine_names("B", "C", "H", "W") + + +class SharedImage(ImageParameterization): + """ + Share some image parameters across the batch to increase spatial alignment, + by using interpolated lower resolution tensors. + This is sort of like a laplacian pyramid but more general. + + Offsets are similar to phase in Fourier transforms, and can be applied to + any dimension. + + Mordvintsev, et al., "Differentiable Image Parameterizations", Distill, 2018. + https://distill.pub/2018/differentiable-parameterizations/ + """ + + def __init__( + self, + shapes: Union[Tuple[Tuple[int]], Tuple[int]] = None, + parameterization: ImageParameterization = None, + offset: Union[int, Tuple[int], Tuple[Tuple[int]], None] = None, + ) -> None: + super().__init__() + assert shapes is not None + A = [] + shared_shapes = [shapes] if type(shapes[0]) is not tuple else shapes + for shape in shared_shapes: + assert len(shape) >= 2 and len(shape) <= 4 + shape = ([1] * (4 - len(shape))) + list(shape) + batch, channels, height, width = shape + A.append(torch.nn.Parameter(torch.randn([batch, channels, height, width]))) + self.shared_init = torch.nn.ParameterList(A) + self.parameterization = parameterization + self.offset = self.get_offset(offset, len(A)) if offset is not None else None + + def get_offset(self, offset: Union[int, Tuple[int]], n: int) -> List[List[int]]: + if type(offset) is tuple or type(offset) is list: + if type(offset[0]) is tuple or type(offset[0]) is list: + assert len(offset) == n and all(len(t) == 4 for t in offset) + else: + assert len(offset) >= 1 and len(offset) <= 4 + offset = [([0] * (4 - len(offset))) + list(offset)] * n + else: + offset = [[offset] * 4] * n + offset = [list(v) for v in offset] + assert all([all([type(o) is int for o in v]) for v in offset]) + return offset + + def apply_offset(self, x_list: List[torch.Tensor]) -> List[torch.Tensor]: + A = [] + for x, offset in zip(x_list, self.offset): + assert x.dim() == 4 + size = list(x.size()) + + offset_pad = ( + [[abs(offset[0])] * 2] + + [[abs(offset[1])] * 2] + + [[abs(offset[2])] * 2] + + [[abs(offset[3])] * 2] + ) + + x = SymmetricPadding.apply(x, offset_pad) + + for o, s in zip(offset, range(x.dim())): + x = torch.roll(x, shifts=o, dims=s) + + x = x[: size[0], : size[1], : size[2], : size[3]] + A.append(x) + return A + + def interpolate_tensor( + self, x: torch.Tensor, batch: int, channels: int, height: int, width: int + ) -> torch.Tensor: + """ + Linear interpolation for 4D, 5D, and 6D tensors. + If the batch dimension needs to be resized, + we move it's location temporarily for F.interpolate. + """ + + if x.size(1) == channels: + mode = "bilinear" + size = (height, width) + else: + mode = "trilinear" + x = x.unsqueeze(0) + size = (channels, height, width) + x = F.interpolate(x, size=size, mode=mode) + x = x.squeeze(0) if len(size) == 3 else x + if x.size(0) != batch: + x = x.permute(1, 0, 2, 3) + x = F.interpolate( + x.unsqueeze(0), + size=(batch, x.size(2), x.size(3)), + mode="trilinear", + ).squeeze(0) + x = x.permute(1, 0, 2, 3) + return x + + def forward(self) -> torch.Tensor: + image = self.parameterization() + x = [ + self.interpolate_tensor( + shared_tensor, + image.size(0), + image.size(1), + image.size(2), + image.size(3), + ) + for shared_tensor in self.shared_init + ] + if self.offset is not None: + x = self.apply_offset(x) + return (image + sum(x)).refine_names("B", "C", "H", "W") + + +class NaturalImage(ImageParameterization): + r"""Outputs an optimizable input image. + + By convention, single images are CHW and float32s in [0,1]. + The underlying parameterization is decorrelated via a ToRGB transform. + When used with the (default) FFT parameterization, this results in a fully + uncorrelated image parameterization. :-) + + If a model requires a normalization step, such as normalizing imagenet RGB values, + or rescaling to [0,255], it can perform those steps with the provided transforms or + inside its computation. + For example, our GoogleNet factory function has a `transform_input=True` argument. + """ + + def __init__( + self, + size: InitSize = None, + channels: int = 3, + batch: int = 1, + parameterization: ImageParameterization = FFTImage, + init: Optional[torch.Tensor] = None, + decorrelate_init: bool = True, + squash_func: Optional[SquashFunc] = None, + ) -> None: + super().__init__() + self.decorrelate = ToRGB(transform_name="klt") + if init is not None: + assert init.dim() == 3 or init.dim() == 4 + if decorrelate_init: + init = ( + init.refine_names("B", "C", "H", "W") + if init.dim() == 4 + else init.refine_names("C", "H", "W") + ) + init = self.decorrelate(init, inverse=True).rename(None) + if squash_func is None: + squash_func: SquashFunc = lambda x: x.clamp(0, 1) + else: + if squash_func is None: + squash_func: SquashFunc = lambda x: torch.sigmoid(x) + self.squash_func = squash_func + self.parameterization = parameterization( + size=size, channels=channels, batch=batch, init=init + ) + + def forward(self) -> torch.Tensor: + image = self.parameterization() + image = self.decorrelate(image) + image = image.rename(None) # TODO: the world is not yet ready + return CudaImageTensor(self.squash_func(image)) diff --git a/captum/optim/_param/image/transform.py b/captum/optim/_param/image/transform.py index 312a1112ed..a4b9c1d98d 100644 --- a/captum/optim/_param/image/transform.py +++ b/captum/optim/_param/image/transform.py @@ -1,11 +1,13 @@ import math import numbers -from typing import Optional, Sequence, Union +from typing import List, Optional, Sequence, Tuple, Union +import numpy as np import torch import torch.nn as nn import torch.nn.functional as F +from captum.optim._utils.image.common import nchannels_to_rgb from captum.optim._utils.typing import TransformSize, TransformVal, TransformValList device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") @@ -22,8 +24,8 @@ def __init__(self, background: Optional[torch.Tensor] = None) -> None: self.background = background def forward(self, x: torch.Tensor) -> torch.Tensor: - assert x.size(1) == 4 assert x.dim() == 4 + assert x.size(1) == 4 rgb, alpha = x[:, :3, ...], x[:, 3:4, ...] background = ( self.background if self.background is not None else torch.rand_like(rgb) @@ -36,6 +38,7 @@ class IgnoreAlpha(nn.Module): r"""Ignores a 4th channel""" def forward(self, x: torch.Tensor) -> torch.Tensor: + assert x.dim() == 4 assert x.size(1) == 4 rgb = x[:, :3, ...] return rgb @@ -145,6 +148,29 @@ def forward(self, input: torch.Tensor) -> torch.Tensor: return input[..., sh : sh + h_crop, sw : sw + w_crop] +def center_crop_shape(input: torch.Tensor, output_size: List[int]) -> torch.Tensor: + """ + Crop NCHW & CHW outputs by specifying the desired output shape. + """ + + assert input.dim() == 4 or input.dim() == 3 + output_size = [output_size] if not hasattr(output_size, "__iter__") else output_size + assert len(output_size) == 1 or len(output_size) == 2 + output_size = output_size * 2 if len(output_size) == 1 else output_size + + if input.dim() == 4: + h, w = input.size(2), input.size(3) + if input.dim() == 3: + h, w = input.size(1), input.size(2) + + h_crop = h - int(round((h - output_size[0]) / 2.0)) + w_crop = w - int(round((w - output_size[1]) / 2.0)) + + return input[ + ..., h_crop - output_size[0] : h_crop, w_crop - output_size[1] : w_crop + ] + + def rand_select(transform_values: TransformValList) -> TransformVal: """ Randomly return a value from the provided tuple or list @@ -214,6 +240,31 @@ def forward(self, input: torch.Tensor) -> torch.Tensor: return self.translate_tensor(input, insets) +class ScaleInputRange(nn.Module): + """ + Multiplies the input by a specified multiplier for models with input ranges other + than [0,1]. + """ + + def __init__(self, multiplier: float = 1.0) -> None: + super().__init__() + self.multiplier = multiplier + + def forward(self, x: torch.Tensor) -> torch.Tensor: + return x * self.multiplier + + +class RGBToBGR(nn.Module): + """ + Converts an NCHW RGB image tensor to BGR by switching the red and blue channels. + """ + + def forward(self, x: torch.Tensor) -> torch.Tensor: + assert x.dim() == 4 + assert x.size(1) == 3 + return x[:, [2, 1, 0]] + + # class TransformationRobustness(nn.Module): # def __init__(self, jitter=False, scale=False): # super().__init__() @@ -318,3 +369,45 @@ def forward(self, input: torch.Tensor) -> torch.Tensor: filtered (torch.Tensor): Filtered output. """ return self.conv(input, weight=self.weight, groups=self.groups) + + +class SymmetricPadding(torch.autograd.Function): + """ + Autograd compatible symmetric padding that uses NumPy's pad function. + """ + + @staticmethod + def forward(ctx, x: torch.Tensor, padding: List[List[int]]) -> torch.Tensor: + ctx.padding = padding + x_device = x.device + x = x.cpu() + x.data = torch.as_tensor( + np.pad(x.data.numpy(), pad_width=padding, mode="symmetric") + ) + x = x.to(x_device) + return x + + @staticmethod + def backward(ctx, grad_output: torch.Tensor) -> Tuple[torch.Tensor, None]: + grad_input = grad_output.clone() + B, C, H, W = grad_input.size() + b1, b2 = ctx.padding[0] + c1, c2 = ctx.padding[1] + h1, h2 = ctx.padding[2] + w1, w2 = ctx.padding[3] + grad_input = grad_input[b1 : B - b2, c1 : C - c2, h1 : H - h2, w1 : W - w2] + return grad_input, None + + +class NChannelsToRGB(nn.Module): + """ + Convert an NCHW image with n channels into a 3 channel RGB image. + """ + + def __init__(self, warp: bool = False) -> None: + super().__init__() + self.warp = warp + + def forward(self, x: torch.Tensor) -> torch.Tensor: + assert x.dim() == 4 + return nchannels_to_rgb(x, self.warp) diff --git a/captum/optim/_utils/circuits.py b/captum/optim/_utils/circuits.py new file mode 100644 index 0000000000..c882607570 --- /dev/null +++ b/captum/optim/_utils/circuits.py @@ -0,0 +1,63 @@ +from typing import Optional, Tuple, Union + +import torch +import torch.nn as nn + +from captum.optim._param.image.transform import center_crop_shape +from captum.optim._utils.models import collect_activations +from captum.optim._utils.typing import ModelInputType, TransformSize + + +def get_expanded_weights( + model, + target1: nn.Module, + target2: nn.Module, + crop_shape: Optional[Union[Tuple[int, int], TransformSize]] = None, + model_input: ModelInputType = torch.zeros(1, 3, 224, 224), +) -> torch.Tensor: + """ + Extract meaningful weight interactions from between neurons which aren’t + literally adjacent in a neural network, or where the weights aren’t directly + represented in a single weight tensor. + Schubert, et al., "Visualizing Weights", Distill, 2020. + See: https://distill.pub/2020/circuits/visualizing-weights/ + + Args: + model (nn.Module): The reference to PyTorch model instance. + target1 (nn.module): The starting target layer. Must be below the layer + specified for target2. + target2 (nn.Module): The end target layer. Must be above the layer + specified for target1. + crop_shape (int or tuple of ints, optional): Specify the output weight + size to enter crop away padding. + model_input (tensor or tuple of tensors, optional): The input to use + with the specified model. + Returns: + *tensor*: A tensor containing the expanded weights in the form of: + (target2 output channels, target1 output channels, y, x) + """ + + activations = collect_activations(model, [target1, target2], model_input) + activ1 = activations[target1] + activ2 = activations[target2] + + if activ2.dim() == 4: + t_offset_h, t_offset_w = (activ2.size(2) - 1) // 2, (activ2.size(3) - 1) // 2 + t_center = activ2[:, :, t_offset_h, t_offset_w] + elif activ2.dim() == 2: + t_center = activ2 + + A = [] + for i in range(activ2.size(1)): + x = torch.autograd.grad( + outputs=t_center[:, i], + inputs=[activ1], + grad_outputs=torch.ones_like(t_center[:, i]), + retain_graph=True, + )[0] + A.append(x.squeeze(0)) + exapnded_weights = torch.stack(A, 0) + + if crop_shape is not None: + exapnded_weights = center_crop_shape(exapnded_weights, crop_shape) + return exapnded_weights diff --git a/captum/optim/_utils/image/__init__.py b/captum/optim/_utils/image/__init__.py new file mode 100644 index 0000000000..902f5cb2bd --- /dev/null +++ b/captum/optim/_utils/image/__init__.py @@ -0,0 +1 @@ +# Image utils diff --git a/captum/optim/_utils/image/common.py b/captum/optim/_utils/image/common.py new file mode 100644 index 0000000000..e7939a6207 --- /dev/null +++ b/captum/optim/_utils/image/common.py @@ -0,0 +1,135 @@ +import math +from typing import List, Optional, Tuple + +import torch + +from captum.optim._utils.reducer import posneg + + +def get_neuron_pos( + H: int, W: int, x: Optional[int] = None, y: Optional[int] = None +) -> Tuple[int, int]: + if x is None: + _x = W // 2 + else: + assert x < W + _x = x + + if y is None: + _y = H // 2 + else: + assert y < H + _y = y + return _x, _y + + +def nchannels_to_rgb(x: torch.Tensor, warp: bool = True) -> torch.Tensor: + """ + Convert an NCHW image with n channels into a 3 channel RGB image. + + Args: + x (torch.Tensor): Image tensor to transform into RGB image. + warp (bool, optional): Whether or not to make colors more distinguishable. + Default: True + Returns: + *tensor* RGB image + """ + + def hue_to_rgb(angle: float) -> torch.Tensor: + """ + Create an RGB unit vector based on a hue of the input angle. + """ + + angle = angle - 360 * (angle // 360) + colors = torch.tensor( + [ + [1.0, 0.0, 0.0], + [0.7071, 0.7071, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.7071, 0.7071], + [0.0, 0.0, 1.0], + [0.7071, 0.0, 0.7071], + ] + ) + + idx = math.floor(angle / 60) + d = (angle - idx * 60) / 60 + + if warp: + + def adj(x: float) -> float: + return math.sin(x * math.pi / 2) + + d = adj(d) if idx % 2 == 0 else 1 - adj(1 - d) + + vec = (1 - d) * colors[idx] + d * colors[(idx + 1) % 6] + return vec / torch.norm(vec) + + assert x.dim() == 4 + + if (x < 0).any(): + x = posneg(x.permute(0, 2, 3, 1), -1).permute(0, 3, 1, 2) + + rgb = torch.zeros(1, 3, x.size(2), x.size(3), device=x.device) + nc = x.size(1) + for i in range(nc): + rgb = rgb + x[:, i][:, None, :, :] + rgb = rgb * hue_to_rgb(360 * i / nc).to(device=x.device)[None, :, None, None] + + rgb = rgb + torch.ones(x.size(2), x.size(3))[None, None, :, :] * ( + torch.sum(x, 1)[:, None] - torch.max(x, 1)[0][:, None] + ) + return (rgb / (1e-4 + torch.norm(rgb, dim=1, keepdim=True))) * torch.norm( + x, dim=1, keepdim=True + ) + + +def weights_to_heatmap_2d( + weight: torch.Tensor, + colors: List[str] = ["0571b0", "92c5de", "f7f7f7", "f4a582", "ca0020"], +) -> torch.Tensor: + """ + Create a color heatmap of an input weight tensor. + By default red represents excitatory values, + blue represents inhibitory values, and white represents + no excitation or inhibition. + + Args: + weight (torch.Tensor): A 2d tensor to create the heatmap from. + colors (List of strings): A list of strings containing color + hex values to use for coloring the heatmap. + Returns: + *tensor*: A weight heatmap. + """ + + assert weight.dim() == 2 + assert len(colors) == 5 + + def get_color(x: str) -> torch.Tensor: + def hex2base10(x: str) -> float: + return int(x, 16) / 255.0 + + return torch.tensor( + [hex2base10(x[0:2]), hex2base10(x[2:4]), hex2base10(x[4:6])] + ) + + def color_scale(x: torch.Tensor) -> torch.Tensor: + if x < 0: + x = -x + if x < 0.5: + x = x * 2 + return (1 - x) * get_color(colors[2]) + x * get_color(colors[1]) + else: + x = (x - 0.5) * 2 + return (1 - x) * get_color(colors[1]) + x * get_color(colors[0]) + else: + if x < 0.5: + x = x * 2 + return (1 - x) * get_color(colors[2]) + x * get_color(colors[3]) + else: + x = (x - 0.5) * 2 + return (1 - x) * get_color(colors[3]) + x * get_color(colors[4]) + + return torch.stack( + [torch.stack([color_scale(x) for x in t]) for t in weight] + ).permute(2, 0, 1) diff --git a/captum/optim/_utils/image_dataset.py b/captum/optim/_utils/image/dataset.py similarity index 100% rename from captum/optim/_utils/image_dataset.py rename to captum/optim/_utils/image/dataset.py diff --git a/captum/optim/_utils/images.py b/captum/optim/_utils/images.py deleted file mode 100644 index d785f53990..0000000000 --- a/captum/optim/_utils/images.py +++ /dev/null @@ -1,18 +0,0 @@ -from typing import Optional, Tuple - - -def get_neuron_pos( - H: int, W: int, x: Optional[int] = None, y: Optional[int] = None -) -> Tuple[int, int]: - if x is None: - _x = W // 2 - else: - assert x < W - _x = x - - if y is None: - _y = H // 2 - else: - assert y < H - _y = y - return _x, _y diff --git a/captum/optim/_utils/models.py b/captum/optim/_utils/models.py index 810edfafb1..bd5c175b75 100644 --- a/captum/optim/_utils/models.py +++ b/captum/optim/_utils/models.py @@ -5,6 +5,9 @@ import torch.nn as nn import torch.nn.functional as F +from captum.optim._core.output_hook import ActivationFetcher +from captum.optim._utils.typing import ModelInputType, ModuleOutputMapping + def get_model_layers(model) -> List[str]: """ @@ -151,3 +154,17 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: self.dilation, self.groups, ) + + +def collect_activations( + model, + targets: Union[nn.Module, List[nn.Module]], + model_input: ModelInputType = torch.zeros(1, 3, 224, 224), +) -> ModuleOutputMapping: + """ + Collect target activations for a model. + """ + + catch_activ = ActivationFetcher(model, targets) + activ_out = catch_activ(model_input) + return activ_out diff --git a/captum/optim/_utils/reducer.py b/captum/optim/_utils/reducer.py new file mode 100644 index 0000000000..ccc4079df8 --- /dev/null +++ b/captum/optim/_utils/reducer.py @@ -0,0 +1,112 @@ +from typing import Any, Callable, List, Union + +import numpy as np +import torch.nn.functional as F + +try: + import sklearn.decomposition + from sklearn.base import BaseEstimator +except (ImportError, AssertionError): + print( + "The sklearn library is required to use Captum's ChannelReducer" + + " unless you supply your own reduction algorithm." + ) +import torch + + +class ChannelReducer: + """ + Dimensionality reduction for the channel dimension of an input. + + Olah, et al., "The Building Blocks of Interpretability", Distill, 2018. + See: https://distill.pub/2018/building-blocks/ + """ + + def __init__( + self, n_components: int = 3, reduction_alg: Any = "NMF", **kwargs + ) -> None: + if isinstance(reduction_alg, str): + reduction_alg = self._get_reduction_algo_instance(reduction_alg) + if reduction_alg is None: + raise ValueError( + "Unknown sklearn dimensionality reduction method '%s'." + % reduction_alg + ) + + self.n_components = n_components + self._reducer = reduction_alg(n_components=n_components, **kwargs) + + def _get_reduction_algo_instance(self, name: str) -> Union[None, Callable]: + if hasattr(sklearn.decomposition, name): + obj = sklearn.decomposition.__getattribute__(name) + if issubclass(obj, BaseEstimator): + return obj + return None + + @classmethod + def _apply_flat(cls, func: Callable, x: torch.Tensor) -> torch.Tensor: + orig_shape = x.shape + return func(x.reshape([-1, x.shape[-1]])).reshape(list(orig_shape[:-1]) + [-1]) + + def fit_transform( + self, x: torch.Tensor, swap_2nd_and_last_dims: bool = True + ) -> torch.Tensor: + """ + Perform dimensionality reduction on an input tensor. + + If swap_2nd_and_last_dims is true, input channels are expected to be in the + second dimension unless the input tensor has a shape of CHW. + """ + + if x.dim() == 3 and swap_2nd_and_last_dims: + x = x.permute(2, 1, 0) + elif x.dim() > 3 and swap_2nd_and_last_dims: + permute_vals = [0] + list(range(x.dim()))[2:] + [1] + x = x.permute(*permute_vals) + + x_out = ChannelReducer._apply_flat(self._reducer.fit_transform, x) + + x_out = torch.as_tensor(x_out, device=x.device) + + if x.dim() == 3 and swap_2nd_and_last_dims: + x_out = x_out.permute(2, 1, 0) + elif x.dim() > 3 and swap_2nd_and_last_dims: + permute_vals = ( + [0] + + [x.dim() - 1] + + list(range(x.dim()))[1 : len(list(range(x.dim()))) - 1] + ) + x_out = x_out.permute(*permute_vals) + + return x_out + + def __getattr__(self, name: str) -> Any: + if name in self.__dict__: + out = self.__dict__[name] + elif name + "_" in self._reducer.__dict__: + out = self._reducer.__dict__[name + "_"] + if type(out) == np.ndarray: + out = torch.as_tensor(out) + return out + + def __dir__(self) -> List: + dynamic_attrs = [ + name[:-1] + for name in dir(self._reducer) + if name[-1] == "_" and name[0] != "_" + ] + + return ( + list(ChannelReducer.__dict__.keys()) + + list(self.__dict__.keys()) + + dynamic_attrs + ) + + +def posneg(x: torch.Tensor, dim: int = 0) -> torch.Tensor: + """ + Hack that makes a matrix positive by concatination in order to simulate + one-sided NMF with regular NMF + """ + + return torch.cat([F.relu(x), F.relu(-x)], dim=dim) diff --git a/captum/optim/_utils/typing.py b/captum/optim/_utils/typing.py index d577766db1..3b1fa2e390 100755 --- a/captum/optim/_utils/typing.py +++ b/captum/optim/_utils/typing.py @@ -38,3 +38,4 @@ def cleanup(self): TransformValList = Union[Sequence[int], Sequence[float], Tensor] TransformVal = Union[int, float, Tensor] TransformSize = Union[List[int], Tuple[int], int] +ModelInputType = Union[Tuple[Tensor], Tensor] diff --git a/tests/optim/core/__init__.py b/tests/optim/core/__init__.py new file mode 100644 index 0000000000..f953efcd31 --- /dev/null +++ b/tests/optim/core/__init__.py @@ -0,0 +1 @@ +# Core tests diff --git a/tests/optim/core/test_output_hook.py b/tests/optim/core/test_output_hook.py new file mode 100644 index 0000000000..ad289172fa --- /dev/null +++ b/tests/optim/core/test_output_hook.py @@ -0,0 +1,29 @@ +#!/usr/bin/env python3 +import unittest +from typing import cast + +import torch + +import captum.optim._core.output_hook as output_hook +from captum.optim._models.inception_v1 import googlenet +from tests.helpers.basic import BaseTest + + +class TestActivationFetcher(BaseTest): + def test_activation_fetcher(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping ActivationFetcher test due to insufficient Torch version." + ) + model = googlenet(pretrained=True) + + catch_activ = output_hook.ActivationFetcher(model, targets=[model.mixed4d]) + activ_out = catch_activ(torch.zeros(1, 3, 224, 224)) + + self.assertIsInstance(activ_out, dict) + m4d_activ = activ_out[model.mixed4d] + self.assertEqual(list(cast(torch.Tensor, m4d_activ).shape), [1, 528, 14, 14]) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/optim/helpers/numpy_common.py b/tests/optim/helpers/numpy_common.py new file mode 100644 index 0000000000..6013600eb7 --- /dev/null +++ b/tests/optim/helpers/numpy_common.py @@ -0,0 +1,45 @@ +from typing import List + +import numpy as np + + +def weights_to_heatmap_2d( + array: np.ndarray, + colors: List[str] = ["0571b0", "92c5de", "f7f7f7", "f4a582", "ca0020"], +) -> np.ndarray: + """ + Create a color heatmap of an input weight array. + By default red represents excitatory values, + blue represents inhibitory values, and white represents + no excitation or inhibition. + """ + + assert array.ndim == 2 + assert len(colors) == 5 + + def get_color(x: str) -> np.ndarray: + def hex2base10(x: str) -> float: + return int(x, 16) / 255.0 + + return np.array([hex2base10(x[0:2]), hex2base10(x[2:4]), hex2base10(x[4:6])]) + + def color_scale(x: np.ndarray) -> np.ndarray: + if x < 0: + x = -x + if x < 0.5: + x = x * 2 + return (1 - x) * get_color(colors[2]) + x * get_color(colors[1]) + else: + x = (x - 0.5) * 2 + return (1 - x) * get_color(colors[1]) + x * get_color(colors[0]) + else: + if x < 0.5: + x = x * 2 + return (1 - x) * get_color(colors[2]) + x * get_color(colors[3]) + else: + x = (x - 0.5) * 2 + return (1 - x) * get_color(colors[3]) + x * get_color(colors[4]) + + return np.stack([np.stack([color_scale(x) for x in a]) for a in array]).transpose( + 2, 0, 1 + ) diff --git a/tests/optim/helpers/numpy_image.py b/tests/optim/helpers/numpy_image.py index c3d55029a5..08e397446e 100644 --- a/tests/optim/helpers/numpy_image.py +++ b/tests/optim/helpers/numpy_image.py @@ -53,7 +53,6 @@ def __init__( fourier_coeffs = ( np.fft.rfftn(init, s=self.size).view("(2,)float") / spectrum_scale ) - fourier_coeffs = fourier_coeffs / spectrum_scale fourier_coeffs = setup_batch(fourier_coeffs, batch, 4) self.fourier_coeffs = fourier_coeffs @@ -74,5 +73,6 @@ def set_image(self, correlated_image: np.ndarray) -> None: def forward(self) -> np.ndarray: h, w = self.size scaled_spectrum = self.fourier_coeffs * self.spectrum_scale - output = np.fft.rfftn(scaled_spectrum, s=self.size) - return output.view(dtype=np.complex128)[..., 0] + scaled_spectrum = scaled_spectrum.astype(complex) + output = np.fft.irfftn(scaled_spectrum, s=self.size) + return output.view(dtype=np.complex128)[..., 0].real diff --git a/tests/optim/param/test_images.py b/tests/optim/param/test_images.py index 2f8c308621..15d70eb978 100644 --- a/tests/optim/param/test_images.py +++ b/tests/optim/param/test_images.py @@ -1,10 +1,12 @@ #!/usr/bin/env python3 import unittest +from typing import List import numpy as np import torch from captum.optim._param.image import images +from captum.optim._param.image.transform import SymmetricPadding from tests.helpers.basic import ( BaseTest, assertArraysAlmostEqual, @@ -77,7 +79,7 @@ def test_fftimage_forward_init_randn_batch(self) -> None: "Skipping FFTImage test due to insufficient Torch version." ) size = (224, 224) - batch = 5 + batch = 2 fftimage = images.FFTImage(size=size, batch=batch) fftimage_np = numpy_image.FFTImage(size=size, batch=batch) @@ -119,6 +121,7 @@ def test_fftimage_forward_init_chw(self) -> None: fftimage_array = fftimage_np.forward() self.assertEqual(fftimage_tensor.detach().numpy().shape, fftimage_array.shape) + assertArraysAlmostEqual(fftimage_tensor.detach().numpy(), fftimage_array, 25.0) def test_fftimage_forward_init_bchw(self) -> None: if torch.__version__ == "1.2.0": @@ -136,6 +139,7 @@ def test_fftimage_forward_init_bchw(self) -> None: fftimage_array = fftimage_np.forward() self.assertEqual(fftimage_tensor.detach().numpy().shape, fftimage_array.shape) + assertArraysAlmostEqual(fftimage_tensor.detach().numpy(), fftimage_array, 25.0) def test_fftimage_forward_init_batch(self) -> None: if torch.__version__ == "1.2.0": @@ -143,7 +147,7 @@ def test_fftimage_forward_init_batch(self) -> None: "Skipping FFTImage test due to insufficient Torch version." ) size = (224, 224) - batch = 5 + batch = 2 init_tensor = torch.randn(1, 3, 224, 224) init_array = init_tensor.numpy() @@ -154,6 +158,7 @@ def test_fftimage_forward_init_batch(self) -> None: fftimage_array = fftimage_np.forward() self.assertEqual(fftimage_tensor.detach().numpy().shape, fftimage_array.shape) + assertArraysAlmostEqual(fftimage_tensor.detach().numpy(), fftimage_array, 25.0) class TestPixelImage(BaseTest): @@ -242,5 +247,316 @@ def test_laplacianimage_random_forward(self) -> None: self.assertEqual(test_tensor.size(3), size[1]) +class TestSharedImage(BaseTest): + def test_sharedimage_get_offset_single_number(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + shared_shapes = (128 // 2, 128 // 2) + test_param = lambda: torch.ones(3, 3, 224, 224) # noqa: E731 + image_param = images.SharedImage( + shapes=shared_shapes, parameterization=test_param + ) + + offset = image_param.get_offset(4, 3) + + self.assertEqual(len(offset), 3) + self.assertEqual(offset, [[4, 4, 4, 4]] * 3) + + def test_sharedimage_get_offset_exact(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + shared_shapes = (128 // 2, 128 // 2) + test_param = lambda: torch.ones(3, 3, 224, 224) # noqa: E731 + image_param = images.SharedImage( + shapes=shared_shapes, parameterization=test_param + ) + + offset_vals = ((1, 2, 3, 4), (4, 3, 2, 1), (1, 2, 3, 4)) + offset = image_param.get_offset(offset_vals, 3) + + self.assertEqual(len(offset), 3) + self.assertEqual(offset, [[int(o) for o in v] for v in offset_vals]) + + def test_sharedimage_get_offset_single_set_four_numbers(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + shared_shapes = (128 // 2, 128 // 2) + test_param = lambda: torch.ones(3, 3, 224, 224) # noqa: E731 + image_param = images.SharedImage( + shapes=shared_shapes, parameterization=test_param + ) + + offset_vals = (1, 2, 3, 4) + offset = image_param.get_offset(offset_vals, 3) + + self.assertEqual(len(offset), 3) + self.assertEqual(offset, [list(offset_vals)] * 3) + + def test_sharedimage_get_offset_single_set_three_numbers(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + shared_shapes = (128 // 2, 128 // 2) + test_param = lambda: torch.ones(3, 3, 224, 224) # noqa: E731 + image_param = images.SharedImage( + shapes=shared_shapes, parameterization=test_param + ) + + offset_vals = (2, 3, 4) + offset = image_param.get_offset(offset_vals, 3) + + self.assertEqual(len(offset), 3) + self.assertEqual(offset, [[0] + list(offset_vals)] * 3) + + def test_sharedimage_get_offset_single_set_two_numbers(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + shared_shapes = (128 // 2, 128 // 2) + test_param = lambda: torch.ones(3, 3, 224, 224) # noqa: E731 + image_param = images.SharedImage( + shapes=shared_shapes, parameterization=test_param + ) + + offset_vals = (3, 4) + offset = image_param.get_offset(offset_vals, 3) + + self.assertEqual(len(offset), 3) + self.assertEqual(offset, [[0, 0] + list(offset_vals)] * 3) + + def apply_offset_compare( + self, x_list: List[torch.Tensor], offset_list: List[List[int]] + ) -> List[torch.Tensor]: + A = [] + for x, offset in zip(x_list, offset_list): + assert x.dim() == 4 + size = list(x.size()) + + offset_pad = ( + [[abs(offset[0])] * 2] + + [[abs(offset[1])] * 2] + + [[abs(offset[2])] * 2] + + [[abs(offset[3])] * 2] + ) + + x = SymmetricPadding.apply(x, offset_pad) + + for o, s in zip(offset, range(x.dim())): + x = torch.roll(x, shifts=o, dims=s) + + x = x[: size[0], : size[1], : size[2], : size[3]] + A.append(x) + return A + + def test_apply_offset(self): + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + size = (4, 3, 224, 224) + shared_shapes = (128 // 2, 128 // 2) + offset_vals = (2, 3, 4, 5) + test_param = lambda: torch.ones(*size) # noqa: E731 + image_param = images.SharedImage( + shapes=shared_shapes, parameterization=test_param, offset=offset_vals + ) + + test_x_list = [torch.ones(*size) for x in range(size[0])] + output_A = image_param.apply_offset(test_x_list) + + x_list = [torch.ones(*size) for x in range(size[0])] + self.assertEqual(image_param.offset, [list(offset_vals)]) + + offset_list = image_param.offset + expected_A = self.apply_offset_compare(x_list, offset_list) + + for t_expected, t_output in zip(expected_A, output_A): + assertTensorAlmostEqual(self, t_expected, t_output) + + def test_interpolate_tensor(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + shared_shapes = (128 // 2, 128 // 2) + test_param = lambda: torch.ones(3, 3, 224, 224) # noqa: E731 + image_param = images.SharedImage( + shapes=shared_shapes, parameterization=test_param + ) + + size = (224, 224) + channels = 3 + batch = 1 + + test_tensor = torch.ones(6, 4, 128, 128) + output_tensor = image_param.interpolate_tensor( + test_tensor, batch, channels, size[0], size[1] + ) + + self.assertEqual(output_tensor.dim(), 4) + self.assertEqual(output_tensor.size(0), batch) + self.assertEqual(output_tensor.size(1), channels) + self.assertEqual(output_tensor.size(2), size[0]) + self.assertEqual(output_tensor.size(3), size[1]) + + def test_sharedimage_single_shape_hw_forward(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + + shared_shapes = (128 // 2, 128 // 2) + batch = 6 + channels = 3 + size = (224, 224) + test_param = lambda: torch.ones(batch, channels, size[0], size[1]) # noqa: E731 + image_param = images.SharedImage( + shapes=shared_shapes, parameterization=test_param + ) + test_tensor = image_param.forward() + + self.assertIsNone(image_param.offset) + self.assertEqual(image_param.shared_init[0].dim(), 4) + self.assertEqual( + list(image_param.shared_init[0].shape), [1, 1] + list(shared_shapes) + ) + self.assertEqual(test_tensor.dim(), 4) + self.assertEqual(test_tensor.size(0), batch) + self.assertEqual(test_tensor.size(1), channels) + self.assertEqual(test_tensor.size(2), size[0]) + self.assertEqual(test_tensor.size(3), size[1]) + + def test_sharedimage_single_shape_chw_forward(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + + shared_shapes = (3, 128 // 2, 128 // 2) + batch = 6 + channels = 3 + size = (224, 224) + test_param = lambda: torch.ones(batch, channels, size[0], size[1]) # noqa: E731 + image_param = images.SharedImage( + shapes=shared_shapes, parameterization=test_param + ) + test_tensor = image_param.forward() + + self.assertIsNone(image_param.offset) + self.assertEqual(image_param.shared_init[0].dim(), 4) + self.assertEqual( + list(image_param.shared_init[0].shape), [1] + list(shared_shapes) + ) + self.assertEqual(test_tensor.dim(), 4) + self.assertEqual(test_tensor.size(0), batch) + self.assertEqual(test_tensor.size(1), channels) + self.assertEqual(test_tensor.size(2), size[0]) + self.assertEqual(test_tensor.size(3), size[1]) + + def test_sharedimage_single_shape_bchw_forward(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + + shared_shapes = (1, 3, 128 // 2, 128 // 2) + batch = 6 + channels = 3 + size = (224, 224) + test_param = lambda: torch.ones(batch, channels, size[0], size[1]) # noqa: E731 + image_param = images.SharedImage( + shapes=shared_shapes, parameterization=test_param + ) + test_tensor = image_param.forward() + + self.assertIsNone(image_param.offset) + self.assertEqual(image_param.shared_init[0].dim(), 4) + self.assertEqual(list(image_param.shared_init[0].shape), list(shared_shapes)) + self.assertEqual(test_tensor.dim(), 4) + self.assertEqual(test_tensor.size(0), batch) + self.assertEqual(test_tensor.size(1), channels) + self.assertEqual(test_tensor.size(2), size[0]) + self.assertEqual(test_tensor.size(3), size[1]) + + def test_sharedimage_multiple_shapes_forward(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + + shared_shapes = ( + (1, 3, 128 // 2, 128 // 2), + (1, 3, 128 // 4, 128 // 4), + (1, 3, 128 // 8, 128 // 8), + (2, 3, 128 // 8, 128 // 8), + (1, 3, 128 // 16, 128 // 16), + (2, 3, 128 // 16, 128 // 16), + ) + batch = 6 + channels = 3 + size = (224, 224) + test_param = lambda: torch.ones(batch, channels, size[0], size[1]) # noqa: E731 + image_param = images.SharedImage( + shapes=shared_shapes, parameterization=test_param + ) + test_tensor = image_param.forward() + + self.assertIsNone(image_param.offset) + for i in range(len(shared_shapes)): + self.assertEqual(image_param.shared_init[i].dim(), 4) + self.assertEqual( + list(image_param.shared_init[i].shape), list(shared_shapes[i]) + ) + self.assertEqual(test_tensor.dim(), 4) + self.assertEqual(test_tensor.size(0), batch) + self.assertEqual(test_tensor.size(1), channels) + self.assertEqual(test_tensor.size(2), size[0]) + self.assertEqual(test_tensor.size(3), size[1]) + + def test_sharedimage_multiple_shapes_diff_len_forward(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + + shared_shapes = ( + (128 // 2, 128 // 2), + (7, 3, 128 // 4, 128 // 4), + (3, 128 // 8, 128 // 8), + (2, 4, 128 // 8, 128 // 8), + (1, 3, 128 // 16, 128 // 16), + (2, 2, 128 // 16, 128 // 16), + ) + batch = 6 + channels = 3 + size = (224, 224) + test_param = lambda: torch.ones(batch, channels, size[0], size[1]) # noqa: E731 + image_param = images.SharedImage( + shapes=shared_shapes, parameterization=test_param + ) + test_tensor = image_param.forward() + + self.assertIsNone(image_param.offset) + for i in range(len(shared_shapes)): + self.assertEqual(image_param.shared_init[i].dim(), 4) + s_shape = list(shared_shapes[i]) + s_shape = ([1] * (4 - len(s_shape))) + list(s_shape) + self.assertEqual(list(image_param.shared_init[i].shape), s_shape) + + self.assertEqual(test_tensor.dim(), 4) + self.assertEqual(test_tensor.size(0), batch) + self.assertEqual(test_tensor.size(1), channels) + self.assertEqual(test_tensor.size(2), size[0]) + self.assertEqual(test_tensor.size(3), size[1]) + + if __name__ == "__main__": unittest.main() diff --git a/tests/optim/param/test_transforms.py b/tests/optim/param/test_transforms.py index d3bef26a25..b6216825ca 100644 --- a/tests/optim/param/test_transforms.py +++ b/tests/optim/param/test_transforms.py @@ -1,5 +1,6 @@ #!/usr/bin/env python3 import unittest +from typing import List import numpy as np import torch @@ -168,6 +169,22 @@ def test_center_crop_two_numbers(self) -> None: assertArraysAlmostEqual(cropped_tensor.numpy(), cropped_array, 0) +class TestCenterCropShape(BaseTest): + def test_center_crop_shape_tuple(self) -> None: + x = torch.ones(32, 16, 28, 28) + + x_out = transform.center_crop_shape(x, (5, 5)) + + self.assertEqual(list(x_out.shape), [32, 16, 5, 5]) + + def test_center_crop_shape_int(self) -> None: + x = torch.ones(32, 16, 28, 28) + + x_out = transform.center_crop_shape(x, 5) + + self.assertEqual(list(x_out.shape), [32, 16, 5, 5]) + + class TestBlendAlpha(BaseTest): def test_blend_alpha(self) -> None: rgb_tensor = torch.ones(3, 3, 3) @@ -344,5 +361,83 @@ def test_gaussian_smoothing_3d(self) -> None: self.assertGreaterEqual(t_min, 3.3377e-06) +class TestScaleInputRange(BaseTest): + def test_scale_input_range(self) -> None: + x = torch.ones(1, 3, 4, 4) + scale_input = transform.ScaleInputRange(255) + output_tensor = scale_input(x) + self.assertEqual(output_tensor.mean(), 255.0) + + +class TestRGBToBGR(BaseTest): + def test_rgb_to_bgr(self) -> None: + x = torch.randn(1, 3, 224, 224) + rgb_to_bgr = transform.RGBToBGR() + output_tensor = rgb_to_bgr(x) + expected_x = x[:, [2, 1, 0]] + assertTensorAlmostEqual(self, output_tensor, expected_x) + + +class TestSymmetricPadding(BaseTest): + def test_symmetric_padding(self) -> None: + b = 2 + c = 3 + x = torch.arange(0, b * c * 4 * 4).view(b, c, 4, 4).float() + offset_pad = [[3, 3], [4, 4], [2, 2], [5, 5]] + + x_pt = torch.nn.Parameter(x) + x_out = transform.SymmetricPadding.apply(x_pt, offset_pad) + x_out_np = torch.as_tensor( + np.pad(x.detach().numpy(), pad_width=offset_pad, mode="symmetric") + ) + assertTensorAlmostEqual(self, x_out, x_out_np) + + def test_symmetric_padding_backward(self) -> None: + b = 2 + c = 3 + x = torch.arange(0, b * c * 4 * 4).view(b, c, 4, 4).float() + offset_pad = [[3, 3], [4, 4], [2, 2], [5, 5]] + + x_pt = torch.nn.Parameter(x) * 1 + + t_grad_input, t_grad_output = [], [] + + def check_grad(self, grad_input, grad_output): + t_grad_input.append(grad_input[0].clone().detach()) + t_grad_output.append(grad_output[0].clone().detach()) + + class SymmetricPaddingLayer(torch.nn.Module): + def forward( + self, x: torch.Tensor, padding: List[List[int]] + ) -> torch.Tensor: + return transform.SymmetricPadding.apply(x_pt, padding) + + sym_pad = SymmetricPaddingLayer() + sym_pad.register_backward_hook(check_grad) + x_out = sym_pad(x_pt, offset_pad) + (x_out.sum() * 1).backward() + + self.assertEqual(x.shape, t_grad_input[0].shape) + + x_out_np = torch.as_tensor( + np.pad(x.detach().numpy(), pad_width=offset_pad, mode="symmetric") + ) + self.assertEqual(x_out_np.shape, t_grad_output[0].shape) + + +class TestNChannelsToRGB(BaseTest): + def test_nchannels_to_rgb_collapse(self) -> None: + test_input = torch.randn(1, 6, 224, 224) + nchannels_to_rgb = transform.NChannelsToRGB() + test_output = nchannels_to_rgb(test_input) + self.assertEqual(list(test_output.size()), [1, 3, 224, 224]) + + def test_nchannels_to_rgb_increase(self) -> None: + test_input = torch.randn(1, 2, 224, 224) + nchannels_to_rgb = transform.NChannelsToRGB() + test_output = nchannels_to_rgb(test_input) + self.assertEqual(list(test_output.size()), [1, 3, 224, 224]) + + if __name__ == "__main__": unittest.main() diff --git a/tests/optim/utils/image/__init__.py b/tests/optim/utils/image/__init__.py new file mode 100644 index 0000000000..0e2d9a3a8e --- /dev/null +++ b/tests/optim/utils/image/__init__.py @@ -0,0 +1 @@ +# Image utils tests diff --git a/tests/optim/utils/image/common.py b/tests/optim/utils/image/common.py new file mode 100644 index 0000000000..7bc267d616 --- /dev/null +++ b/tests/optim/utils/image/common.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +import unittest + +import torch + +import captum.optim._utils.image.common as common +from tests.helpers.basic import BaseTest, assertTensorAlmostEqual +from tests.optim.helpers import numpy_common + + +class TestGetNeuronPos(unittest.TestCase): + def test_get_neuron_pos_hw(self) -> None: + W, H = 128, 128 + x, y = common.get_neuron_pos(H, W) + + self.assertEqual(x, W // 2) + self.assertEqual(y, H // 2) + + def test_get_neuron_pos_xy(self) -> None: + W, H = 128, 128 + x, y = common.get_neuron_pos(H, W, 5, 5) + + self.assertEqual(x, 5) + self.assertEqual(y, 5) + + def test_get_neuron_pos_x_none(self) -> None: + W, H = 128, 128 + x, y = common.get_neuron_pos(H, W, 5, None) + + self.assertEqual(x, 5) + self.assertEqual(y, H // 2) + + def test_get_neuron_pos_none_y(self) -> None: + W, H = 128, 128 + x, y = common.get_neuron_pos(H, W, None, 5) + + self.assertEqual(x, W // 2) + self.assertEqual(y, 5) + + +class TestNChannelsToRGB(BaseTest): + def test_nchannels_to_rgb_collapse(self) -> None: + test_input = torch.randn(1, 6, 224, 224) + test_output = common.nchannels_to_rgb(test_input) + self.assertEqual(list(test_output.size()), [1, 3, 224, 224]) + + def test_nchannels_to_rgb_increase(self) -> None: + test_input = torch.randn(1, 2, 224, 224) + test_output = common.nchannels_to_rgb(test_input) + self.assertEqual(list(test_output.size()), [1, 3, 224, 224]) + + +class TestWeightsToHeatmap2D(BaseTest): + def test_weights_to_heatmap_2d(self) -> None: + x = torch.ones(5, 4) + x[0:1, 0:4] = x[0:1, 0:4] * 0.2 + x[1:2, 0:4] = x[1:2, 0:4] * 0.8 + x[2:3, 0:4] = x[2:3, 0:4] * 0.0 + x[3:4, 0:4] = x[3:4, 0:4] * -0.2 + x[4:5, 0:4] = x[4:5, 0:4] * -0.8 + + x_out = common.weights_to_heatmap_2d(x) + x_out_np = numpy_common.weights_to_heatmap_2d(x.numpy()) + assertTensorAlmostEqual(self, x_out, torch.as_tensor(x_out_np).float()) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/optim/utils/test_image_dataset_utils.py b/tests/optim/utils/image/dataset.py similarity index 95% rename from tests/optim/utils/test_image_dataset_utils.py rename to tests/optim/utils/image/dataset.py index 10386f2aef..d4e6f5a8ac 100644 --- a/tests/optim/utils/test_image_dataset_utils.py +++ b/tests/optim/utils/image/dataset.py @@ -3,7 +3,7 @@ import torch -import captum.optim._utils.image_dataset as dataset_utils +import captum.optim._utils.image.dataset as dataset_utils from tests.helpers.basic import ( BaseTest, assertArraysAlmostEqual, diff --git a/tests/optim/utils/test_circuits.py b/tests/optim/utils/test_circuits.py new file mode 100644 index 0000000000..5e26214ea8 --- /dev/null +++ b/tests/optim/utils/test_circuits.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +import unittest + +import torch + +import captum.optim._utils.circuits as circuits +from captum.optim._models.inception_v1 import googlenet +from tests.helpers.basic import BaseTest + + +class TestGetExpandedWeights(BaseTest): + def test_get_expanded_weights(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping get_expanded_weights test due to insufficient Torch version." + ) + model = googlenet(pretrained=True) + output_tensor = circuits.get_expanded_weights( + model, model.mixed3a, model.mixed3b + ) + self.assertTrue(torch.is_tensor(output_tensor)) + self.assertEqual(list(output_tensor.shape), [480, 256, 28, 28]) + + def test_get_expanded_weights_crop_int(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping get_expanded_weights crop test due to insufficient Torch" + + " version." + ) + model = googlenet(pretrained=True) + output_tensor = circuits.get_expanded_weights( + model, model.mixed3a, model.mixed3b, 5 + ) + self.assertEqual(list(output_tensor.shape), [480, 256, 5, 5]) + + def test_get_expanded_weights_crop_two_int(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping get_expanded_weights two int crop test due to insufficient" + + " Torch version." + ) + model = googlenet(pretrained=True) + output_tensor = circuits.get_expanded_weights( + model, model.mixed3a, model.mixed3b, (5, 5) + ) + self.assertEqual(list(output_tensor.shape), [480, 256, 5, 5]) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/optim/utils/test_images_utils.py b/tests/optim/utils/test_images_utils.py deleted file mode 100644 index cc40b7b853..0000000000 --- a/tests/optim/utils/test_images_utils.py +++ /dev/null @@ -1,38 +0,0 @@ -#!/usr/bin/env python3 -import unittest - -from captum.optim._utils.images import get_neuron_pos - - -class TestGetNeuronPos(unittest.TestCase): - def test_get_neuron_pos_hw(self) -> None: - W, H = 128, 128 - x, y = get_neuron_pos(H, W) - - self.assertEqual(x, W // 2) - self.assertEqual(y, H // 2) - - def test_get_neuron_pos_xy(self) -> None: - W, H = 128, 128 - x, y = get_neuron_pos(H, W, 5, 5) - - self.assertEqual(x, 5) - self.assertEqual(y, 5) - - def test_get_neuron_pos_x_none(self) -> None: - W, H = 128, 128 - x, y = get_neuron_pos(H, W, 5, None) - - self.assertEqual(x, 5) - self.assertEqual(y, H // 2) - - def test_get_neuron_pos_none_y(self) -> None: - W, H = 128, 128 - x, y = get_neuron_pos(H, W, None, 5) - - self.assertEqual(x, W // 2) - self.assertEqual(y, 5) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/optim/utils/test_model_utils.py b/tests/optim/utils/test_model_utils.py index e42bf19c5c..1290de9d29 100644 --- a/tests/optim/utils/test_model_utils.py +++ b/tests/optim/utils/test_model_utils.py @@ -1,5 +1,6 @@ #!/usr/bin/env python3 import unittest +from typing import cast import torch import torch.nn.functional as F @@ -71,6 +72,13 @@ def check_grad(self, grad_input, grad_output): assertTensorAlmostEqual(self, t_grad_input[0], t_grad_output[0], 0) +def check_is_not_instance(self, model, layer) -> None: + for name, child in model._modules.items(): + if child is not None: + self.assertNotIsInstance(child, layer) + check_is_not_instance(self, child, layer) + + class TestReplaceLayers(BaseTest): def test_replace_layers(self) -> None: class BasicReluModule(torch.nn.Module): @@ -97,10 +105,8 @@ def forward(self, input: torch.Tensor) -> torch.Tensor: # Unittest can't run replace_layers correctly? model_utils.replace_layers(toy_model.relu2, old_layer, new_layer) - self.assertNotIsInstance(toy_model.relu1, old_layer) + check_is_not_instance(self, toy_model, old_layer) self.assertIsInstance(toy_model.relu1, new_layer) - - self.assertNotIsInstance(toy_model.relu2.relu, old_layer) self.assertIsInstance(toy_model.relu2.relu, new_layer) @@ -294,5 +300,22 @@ def test_get_layers_torchvision_alexnet(self) -> None: self.assertEqual(collected_layers, expected_list) +class TestCollectActivations(BaseTest): + def test_collect_activations(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping collect_activations test due to insufficient Torch version." + ) + model = googlenet(pretrained=True) + + activ_out = model_utils.collect_activations( + model, [model.mixed4d], torch.zeros(1, 3, 224, 224) + ) + + self.assertIsInstance(activ_out, dict) + m4d_activ = activ_out[model.mixed4d] + self.assertEqual(list(cast(torch.Tensor, m4d_activ).shape), [1, 528, 14, 14]) + + if __name__ == "__main__": unittest.main() diff --git a/tests/optim/utils/test_reducer.py b/tests/optim/utils/test_reducer.py new file mode 100644 index 0000000000..87dcecfb02 --- /dev/null +++ b/tests/optim/utils/test_reducer.py @@ -0,0 +1,146 @@ +#!/usr/bin/env python3 +import unittest + +import numpy as np +import torch + +import captum.optim._utils.reducer as reducer +from tests.helpers.basic import BaseTest + + +class FakeReductionAlgorithm(object): + """ + Fake reduction algorithm for testing + """ + + def __init__(self, n_components=3, **kwargs) -> None: + self.n_components = n_components + self.components_ = np.ones((2, 64)) + + def fit_transform(self, x: torch.Tensor) -> np.ndarray: + x = x.numpy() if torch.is_tensor(x) else x + return x[:, 0:3, ...] + + +class TestChannelReducer(BaseTest): + def test_channelreducer_pytorch(self) -> None: + try: + import sklearn # noqa: F401 + + except (ImportError, AssertionError): + raise unittest.SkipTest( + "Module sklearn not found, skipping ChannelReducer" + + " PyTorch swap_2nd_and_last_dims test" + ) + + test_input = torch.randn(1, 32, 224, 224).abs() + c_reducer = reducer.ChannelReducer(n_components=3, max_iter=100) + test_output = c_reducer.fit_transform(test_input) + self.assertEquals(test_output.size(0), 1) + self.assertEquals(test_output.size(1), 3) + self.assertEquals(test_output.size(2), 224) + self.assertEquals(test_output.size(3), 224) + + def test_channelreducer_pytorch_dim_three(self) -> None: + try: + import sklearn # noqa: F401 + + except (ImportError, AssertionError): + raise unittest.SkipTest( + "Module sklearn not found, skipping ChannelReducer" + + " PyTorch swap_2nd_and_last_dims test" + ) + + test_input = torch.randn(32, 224, 224).abs() + c_reducer = reducer.ChannelReducer(n_components=3, max_iter=100) + test_output = c_reducer.fit_transform(test_input) + self.assertEquals(test_output.size(0), 3) + self.assertEquals(test_output.size(1), 224) + self.assertEquals(test_output.size(2), 224) + + def test_channelreducer_pytorch_pca(self) -> None: + try: + import sklearn # noqa: F401 + + except (ImportError, AssertionError): + raise unittest.SkipTest( + "Module sklearn not found, skipping ChannelReducer" + + " PyTorch swap_2nd_and_last_dims PCA test" + ) + + test_input = torch.randn(1, 32, 224, 224).abs() + c_reducer = reducer.ChannelReducer( + n_components=3, reduction_alg="PCA", max_iter=100 + ) + test_output = c_reducer.fit_transform(test_input) + self.assertEquals(test_output.size(0), 1) + self.assertEquals(test_output.size(1), 3) + self.assertEquals(test_output.size(2), 224) + self.assertEquals(test_output.size(3), 224) + + def test_channelreducer_pytorch_custom_alg(self) -> None: + test_input = torch.randn(1, 32, 224, 224).abs() + reduction_alg = FakeReductionAlgorithm + c_reducer = reducer.ChannelReducer( + n_components=3, reduction_alg=reduction_alg, max_iter=100 + ) + test_output = c_reducer.fit_transform(test_input) + self.assertEquals(test_output.size(0), 1) + self.assertEquals(test_output.size(1), 3) + self.assertEquals(test_output.size(2), 224) + self.assertEquals(test_output.size(3), 224) + + def test_channelreducer_pytorch_custom_alg_components(self) -> None: + reduction_alg = FakeReductionAlgorithm + c_reducer = reducer.ChannelReducer( + n_components=3, reduction_alg=reduction_alg, max_iter=100 + ) + components = c_reducer.components + self.assertTrue(torch.is_tensor(components)) + + def test_channelreducer_pytorch_components(self) -> None: + try: + import sklearn # noqa: F401 + + except (ImportError, AssertionError): + raise unittest.SkipTest( + "Module sklearn not found, skipping ChannelReducer" + + " PyTorch swap_2nd_and_last_dims test" + ) + + test_input = torch.randn(1, 32, 224, 224).abs() + c_reducer = reducer.ChannelReducer(n_components=3, max_iter=100) + test_output = c_reducer.fit_transform(test_input) + components = c_reducer.components + self.assertTrue(torch.is_tensor(components)) + self.assertTrue(torch.is_tensor(test_output)) + + def test_channelreducer_noreshape_pytorch(self) -> None: + try: + import sklearn # noqa: F401 + + except (ImportError, AssertionError): + raise unittest.SkipTest( + "Module sklearn not found, skipping ChannelReducer" + + " PyTorch no reshape test" + ) + + test_input = torch.randn(1, 224, 224, 32).abs() + c_reducer = reducer.ChannelReducer(n_components=3, max_iter=100) + test_output = c_reducer.fit_transform(test_input, swap_2nd_and_last_dims=False) + self.assertEquals(test_output.size(0), 1) + self.assertEquals(test_output.size(1), 224) + self.assertEquals(test_output.size(2), 224) + self.assertEquals(test_output.size(3), 3) + + +class TestPosNeg(BaseTest): + def test_posneg(self) -> None: + x = torch.ones(1, 3, 224, 224) - 2 + self.assertGreater( + torch.sum(reducer.posneg(x) >= 0).item(), torch.sum(x >= 0).item() + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tutorials/optimviz/CustomModules_OptimViz.ipynb b/tutorials/optimviz/CustomModules_OptimViz.ipynb new file mode 100644 index 0000000000..12294c18fc --- /dev/null +++ b/tutorials/optimviz/CustomModules_OptimViz.ipynb @@ -0,0 +1,541 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "CustomModules_OptimViz.ipynb", + "provenance": [], + "collapsed_sections": [], + "toc_visible": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "5c666868d62e4862a648cd0df15155ec": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_389469a07da6435eb2a1be7ea55f4f86", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_36b86b673b544cc5bdb5652eb31cabc9", + "IPY_MODEL_6d93392ab27048068aa8bb1d7ef01cf1" + ] + } + }, + "389469a07da6435eb2a1be7ea55f4f86": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "36b86b673b544cc5bdb5652eb31cabc9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_2c759e9a43754fc4963a9631cc7702c5", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 128, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 128, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_8fa32da11a2a4401a57a50f80af7be32" + } + }, + "6d93392ab27048068aa8bb1d7ef01cf1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_ba6b8e0c07074921a5faa7dbc29f3fe3", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 128/128 [00:42<00:00, 2.99 step/s, Objective=356.1]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_ea6b900b717c4e8f8051094882aeef1f" + } + }, + "2c759e9a43754fc4963a9631cc7702c5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "8fa32da11a2a4401a57a50f80af7be32": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "ba6b8e0c07074921a5faa7dbc29f3fe3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "ea6b900b717c4e8f8051094882aeef1f": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "2ylZPub2JTMH" + }, + "source": [ + "# Creating Custom Captum.optim Modules\n", + "Captum's Optim library contains an extensive list of optimization objectives, transforms, and input parameterizations. However, some cases may require adding new features to these areas of Captum's Optim library. Luckily adding them to Captum is easy!" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "GWrStkUVEbOC" + }, + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "from typing import Dict, List, Optional, Tuple, Union\n", + "\n", + "import torch\n", + "import torchvision\n", + "from captum.optim._models.inception_v1 import googlenet\n", + "\n", + "import captum.optim as optimviz\n", + "\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "model = googlenet(pretrained=True).to(device)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DffA7pFSFZY0" + }, + "source": [ + "# Custom Image Transforms\n", + "\n", + "If both Captum and Torchvision lack the transforms that you require, then you can create your own custom transforms.\n", + "\n", + "Custom image transform classes must contain a `forward()` function. The first transform in a list of transforms takes an input tensor with a shape of (B, C, W, H), and the final transform in a list of transforms will need to output a tensor with the same shape of (B, C, W, H). Captum and Torchvision's transforms normally expect and output a shape of (B, C, W, H).\n", + "\n", + "An optional `__init__()` function can be used as well.\n", + "\n", + "\n", + "Note that all custom transforms need to be autograd compatible, so that the gradient is not interrupted during the optimization process.\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "hoyneR7FFTXK" + }, + "source": [ + "class CustomTransform(torch.nn.Module):\n", + " def __init__(self, val: int = 1) -> None:\n", + " super(CustomTransform, self).__init__()\n", + " self.val = val\n", + "\n", + " def forward(self, input: torch.Tensor) -> torch.Tensor:\n", + " return input * self.val" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2kjc9istEzVz" + }, + "source": [ + "# Custom Loss Functions\n", + "Captum's loss functions are composed of classes that the optimization function uses. Custom loss classes should inherit the base loss class.\n", + "\n", + "Custom loss functions must contain the following two functions:\n", + "\n", + "\n", + "* The `__init__()` function with that must at least contain a target variable. The target variable should be an nn.module or list of nn.modules to collect activations from. Other variables can be added after the target.\n", + "\n", + "* The `__call__()` function which takes activations from the target layer and then returns a loss value. Activations sent to the call function are extracted from a dictionary with the target as the key." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "LQZECwPoEdET" + }, + "source": [ + "class CustomLoss(optimviz.loss.Loss):\n", + " def __init__(self, target: Union[torch.nn.Module, List[torch.nn.Module]]):\n", + " super(optimviz.loss.Loss, self).__init__()\n", + " self.target = target\n", + "\n", + " def __call__(\n", + " self, target_activations: Dict[torch.nn.Module, Optional[torch.Tensor]]\n", + " ) -> torch.Tensor:\n", + " activations = target_activations[self.target] # Get activations from target\n", + " return activations" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "K45Xg0HGF3VH" + }, + "source": [ + "# Custom Image Parameterization\n", + "\n", + "\n", + "The image parameters that Captum's Optim library optimizes to produce visualizations is stored in a custom image parameterization class. \n", + "\n", + "Custom parameterization must contain the following two functions:\n", + "\n", + "### Init function\n", + "\n", + "The `__init__()` function has 3 input variables:\n", + "\n", + "* size (tuple, int): dimensions in the form height, width. \n", + "\n", + "* channels (int): the number of channels for the output tensor.\n", + "\n", + "* batch (int): the desired batch size to use.\n", + "\n", + "* init (torch.Tensor): An optional input tensor with a shape of: (B, C, W, H).\n", + "\n", + "Make sure that the tensor being optimized is wrapped in `torch.nn.Parameter` and that it can be called by the `forward()` function.\n", + "\n", + "### Forward function\n", + "\n", + "The `forward()` function has zero input varibles and returns a 4 dimension tensor with a shape of (B, C, W, H):\n", + "\n", + "* The tensor being optimized should be called from where it was saved in the init function. This tensor will then be returned when the forward function is called.\n", + "\n", + "* The dimensions of the output tensor should be named: 'B', 'C', 'H', and 'W'." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Hm2HLX9VFmAT" + }, + "source": [ + "class CustomImage(optimviz.images.ImageParameterization):\n", + " def __init__(\n", + " self,\n", + " size: Tuple[int, int] = (224, 224),\n", + " channels: int = 3,\n", + " batch: int = 1,\n", + " init: torch.Tensor = None,\n", + " ) -> None:\n", + " super().__init__()\n", + " if init is None:\n", + " assert size is not None\n", + " # Create random input with a shape of: B, C, W, H\n", + " init = torch.randn([batch, channels, size[0], size[1]])\n", + " else:\n", + " assert init.dim() == 4\n", + " self.image = torch.nn.Parameter(init) # Convert input to nn.Parameter()\n", + "\n", + " def forward(self) -> torch.Tensor:\n", + " return self.image.refine_names(\"B\", \"C\", \"H\", \"W\") # rename dimensions" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "x_AK29oiH9Z3" + }, + "source": [ + "# Running Captum with custom modules\n", + "\n", + "Below is a helper function that will let us quickly and easily experiment with our custom modules from above. Random scaling and random spatial jitter transforms are also included in the helper function to improve output quality." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uQ9sEz8cG2El" + }, + "source": [ + "def visualize(model, target):\r\n", + " # Define our custom image parameterization, then add it to NaturalImage\r\n", + " image_param = CustomImage\r\n", + " image = optimviz.images.NaturalImage(size=(224, 224), parameterization=image_param)\r\n", + "\r\n", + " transforms = torch.nn.Sequential(\r\n", + " CustomTransform(), # Add our custom transform to the list of transforms\r\n", + "\r\n", + " # Additional transforms to improve output quality\r\n", + " optimviz.transform.RandomSpatialJitter(16),\r\n", + " optimviz.transform.RandomScale(scale=(1, 0.975, 1.025, 0.95, 1.05)),\r\n", + " )\r\n", + "\r\n", + " # Define our custom loss function as the loss function\r\n", + " loss_fn = CustomLoss(target)\r\n", + "\r\n", + " obj = optimviz.InputOptimization(model, image, transforms, [target], loss_fn)\r\n", + " history = obj.optimize(optimviz.objectives.n_steps(128))\r\n", + " image().show()" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 298, + "referenced_widgets": [ + "5c666868d62e4862a648cd0df15155ec", + "389469a07da6435eb2a1be7ea55f4f86", + "36b86b673b544cc5bdb5652eb31cabc9", + "6d93392ab27048068aa8bb1d7ef01cf1", + "2c759e9a43754fc4963a9631cc7702c5", + "8fa32da11a2a4401a57a50f80af7be32", + "ba6b8e0c07074921a5faa7dbc29f3fe3", + "ea6b900b717c4e8f8051094882aeef1f" + ] + }, + "id": "3m5iQ2zfqV5F", + "outputId": "40b79b81-363c-49c6-8546-9b8ada61665a" + }, + "source": [ + "visualize(model, model.mixed4a)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5c666868d62e4862a648cd0df15155ec", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + } + ] +} \ No newline at end of file diff --git a/tutorials/InceptionV1_OptimViz.ipynb b/tutorials/optimviz/InceptionV1_OptimViz.ipynb similarity index 100% rename from tutorials/InceptionV1_OptimViz.ipynb rename to tutorials/optimviz/InceptionV1_OptimViz.ipynb diff --git a/tutorials/TorchVision_OptimViz.ipynb b/tutorials/optimviz/TorchVision_OptimViz.ipynb old mode 100755 new mode 100644 similarity index 100% rename from tutorials/TorchVision_OptimViz.ipynb rename to tutorials/optimviz/TorchVision_OptimViz.ipynb diff --git a/tutorials/optimviz/WeightVisualization_OptimViz.ipynb b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb new file mode 100644 index 0000000000..a923fea790 --- /dev/null +++ b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb @@ -0,0 +1,1309 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "WeightVisualization_OptimViz.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "42fbaeeffcc940d980bd3a70d59ac759": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_6178f6a4bade4eb7a30b54b26d0f36fe", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_8a96fe98985c4a2c9305acd105c83305", + "IPY_MODEL_70895736a8674f8da04ba8659bdf6c6b" + ] + } + }, + "6178f6a4bade4eb7a30b54b26d0f36fe": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "8a96fe98985c4a2c9305acd105c83305": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_213eb42d051347e28f88699fb6a69ee5", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 128, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 128, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_2891473640954ee5b0a9249cc0611a7f" + } + }, + "70895736a8674f8da04ba8659bdf6c6b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_b042731d18cf45fdb8f2df6eae416e65", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 128/128 [02:57<00:00, 1.39s/ step, Objective=0.0]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_00bf36b045f444359f2e715363c226d4" + } + }, + "213eb42d051347e28f88699fb6a69ee5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "2891473640954ee5b0a9249cc0611a7f": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "b042731d18cf45fdb8f2df6eae416e65": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "00bf36b045f444359f2e715363c226d4": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "3894bed987e14d0f92e03bd548968877": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_c8c2196005cb4e83992ea45bab85773a", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_b5127e0bd8cf4cf2a6a7b23000a7175b", + "IPY_MODEL_9b068cc9a9484573b35868b969e6ae55" + ] + } + }, + "c8c2196005cb4e83992ea45bab85773a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "b5127e0bd8cf4cf2a6a7b23000a7175b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_abeadfeae44c498f9e22b4dcffb9d926", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 128, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 128, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_ce65fff533e24a2295fcdee9c8cb1b4d" + } + }, + "9b068cc9a9484573b35868b969e6ae55": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_0df84d7b9c9c4d65afc3e6d3a813c10a", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 128/128 [02:26<00:00, 1.14s/ step, Objective=4471.2]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_f00ac77672a64cfdafccf97581775b78" + } + }, + "abeadfeae44c498f9e22b4dcffb9d926": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "ce65fff533e24a2295fcdee9c8cb1b4d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "0df84d7b9c9c4d65afc3e6d3a813c10a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "f00ac77672a64cfdafccf97581775b78": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "b588cd0a794e42f789729de0182f1723": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_81fe4386a7ea40dda821ebf7eca095bc", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_7fd03615817f4e5b8996c1826fbc3e36", + "IPY_MODEL_924be6da1cf943c4b3010c43919f96d3" + ] + } + }, + "81fe4386a7ea40dda821ebf7eca095bc": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "7fd03615817f4e5b8996c1826fbc3e36": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_3a01f27740754bdbb68bee7bcd0f2ca5", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 128, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 128, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_be742d9de0a64f21837d019cabb1081b" + } + }, + "924be6da1cf943c4b3010c43919f96d3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_6675818472864b579393dac79d1f235d", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 128/128 [01:30<00:00, 1.41 step/s, Objective=2683.3]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_b7fc8160950d41b6a73381f6308b88d8" + } + }, + "3a01f27740754bdbb68bee7bcd0f2ca5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "be742d9de0a64f21837d019cabb1081b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "6675818472864b579393dac79d1f235d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "b7fc8160950d41b6a73381f6308b88d8": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "VWy2Woand8P0" + }, + "source": [ + "# Visualizing weights with captum.optim\r\n", + "\r\n", + "This notebook demonstrates the use of the captum.optim submodule for visualizing the weights of the InceptionV1 model imported from Caffe." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "GWrStkUVEbOC" + }, + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import torch\n", + "import torchvision\n", + "from captum.optim._models.inception_v1 import googlenet\n", + "\n", + "import captum.optim as optimviz\n", + "\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "model = googlenet(pretrained=True).to(device).eval()" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rzb9RtdUfE_H" + }, + "source": [ + "For convenience, we can create helper functions for visualizing the weights of our model.\r\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "D46o5t8a4iVk" + }, + "source": [ + "import numpy as np\r\n", + "import matplotlib.pyplot as plt\r\n", + "\r\n", + "\r\n", + "def show(x: np.ndarray, scale: float = 255.0) -> None:\r\n", + " assert x.dim() == 3 or x.dim() == 4\r\n", + " x = x[0] if x.dim() == 4 else x\r\n", + " x = x.cpu().permute(1,2,0) * scale\r\n", + " plt.imshow(x.numpy().astype(np.uint8))\r\n", + " plt.axis(\"off\")\r\n", + " plt.show()\r\n", + "\r\n", + "\r\n", + "def visualize_activations(model, target, channel: int) -> None:\r\n", + " image = optimviz.images.NaturalImage((224, 224)).to(device)\r\n", + " transforms = torch.nn.Sequential(\r\n", + " torch.nn.ReflectionPad2d(16),\r\n", + " optimviz.transform.RandomSpatialJitter(16),\r\n", + " optimviz.transform.RandomScale(scale=(1, 0.975, 1.025, 0.95, 1.05)),\r\n", + " torchvision.transforms.RandomRotation(degrees=(-5,5)),\r\n", + " optimviz.transform.RandomSpatialJitter(8),\r\n", + " optimviz.transform.CenterCrop(16),\r\n", + " )\r\n", + " loss_fn = optimviz.loss.NeuronActivation(target, channel)\r\n", + " obj = optimviz.InputOptimization(model, image, transforms, [target], loss_fn)\r\n", + " history = obj.optimize(optimviz.objectives.n_steps(128))\r\n", + " image().show()\r\n", + "\r\n", + "\r\n", + "def vis_multi(model, target, channel: int) -> None:\r\n", + " image = optimviz.images.NaturalImage((60,60)).to(device)\r\n", + " loss_fn = optimviz.loss.NeuronActivation(target, channel)\r\n", + " transforms = torch.nn.Sequential(optimviz.transform.RandomSpatialJitter(1)) \r\n", + " obj = optimviz.InputOptimization(model, image, transforms, [target], loss_fn)\r\n", + " history = obj.optimize(optimviz.objectives.n_steps(128, False))\r\n", + " return image()._t" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fMvQtKFEe9R8" + }, + "source": [ + "## Extracting expanded weights\r\n", + "\r\n", + "We can extract expanded weights with Captum.optim's `get_expanded_weights` function.\r\n", + "\r\n", + "Below we extract the 5 by 5 expanded weights from between the mixed3a and mixed3b layers. The output tensor is in the form of / has a shape of: `[target2 output channels, target1 output channels, y, x]`" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "IWbzbWvGTj0-" + }, + "source": [ + "W_3a_3b = optimviz.circuits.get_expanded_weights(model, model.mixed3a, model.mixed3b, 5)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HnNDlOiFWMf7" + }, + "source": [ + "# Visualizing expanded weights\r\n", + "\r\n", + "To make it easier to understand what we are seeing, we can create a heatmap using Captum.optim's `weights_to_heatmap_2d` function. The `weights_to_heatmap_2d` function will by default use the color red to show excitatory parts of the weights, blue for inhibitory parts of the weights, and white for no excitation or inhibition.\r\n", + "\r\n", + "By using our heatmap, we can visualize our newly collected expanded weights for channel 147 of mixed3a and channel 379 of mixed3b like so:" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 248 + }, + "id": "BiAXnE0zqyFP", + "outputId": "ac0bee4a-7bbd-423d-dd92-279a13af4b05" + }, + "source": [ + "W_3a_3b_hm = optimviz.weights_to_heatmap_2d(W_3a_3b[379, 147, ...] / W_3a_3b[379, ...].max())\r\n", + "show(W_3a_3b_hm)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAADpUlEQVR4nO3YPU5UUQCGYUeHGI2J2LkDfjpdgYVbcR822hnXYOcCNNauwMRGCzsbCog2QAThugGYcIPhvJDnKc9pvineOcldTNN0C+i5PXoAcDZxQpQ4IUqcECVOiFquuvzyc+/afMo9/Hs6esIsT27vjp4wy/RrZ/SEizs9Gb1glvtPny/OOvdyQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBC1XHX552S6qh2XtvH+9egJs3x79Wn0hFk23r0YPeHiHjwaveC/8HJClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IWq56nLz45ur2nFpP15+GD1hlu3Pb0dPmGV/69noCRe2e3A8esIsW+ecezkhSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiFquvHx476p2XNr276+jJ8yyf3QyesIsd5fX53987c712brKzfgVcAOJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROiFtM0nXt5uLdz/mXM94O10RNm2Vy/Xnt3j0YvuLj949PRE2bZfLy+OOvcywlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFC1GKaptEbgDN4OSFKnBAlTogSJ0SJE6LECVH/ACgcONUh9QcDAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mYPv8ncH1V8x" + }, + "source": [ + "By looking at the weights above, we can see how the the following two curve detector neurons are connected to each other." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 579, + "referenced_widgets": [ + "42fbaeeffcc940d980bd3a70d59ac759", + "6178f6a4bade4eb7a30b54b26d0f36fe", + "8a96fe98985c4a2c9305acd105c83305", + "70895736a8674f8da04ba8659bdf6c6b", + "213eb42d051347e28f88699fb6a69ee5", + "2891473640954ee5b0a9249cc0611a7f", + "b042731d18cf45fdb8f2df6eae416e65", + "00bf36b045f444359f2e715363c226d4", + "3894bed987e14d0f92e03bd548968877", + "c8c2196005cb4e83992ea45bab85773a", + "b5127e0bd8cf4cf2a6a7b23000a7175b", + "9b068cc9a9484573b35868b969e6ae55", + "abeadfeae44c498f9e22b4dcffb9d926", + "ce65fff533e24a2295fcdee9c8cb1b4d", + "0df84d7b9c9c4d65afc3e6d3a813c10a", + "f00ac77672a64cfdafccf97581775b78" + ] + }, + "id": "8pCOa_o4xF0w", + "outputId": "bbb5120c-886f-49d1-fea7-dc366b649271" + }, + "source": [ + "visualize_activations(model, model.mixed3a, 147)\r\n", + "visualize_activations(model, model.mixed3b, 379)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "42fbaeeffcc940d980bd3a70d59ac759", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9TZMlR46u9wBw94iTVeRopH8ryWQy0w+e28PKPBHuDkALRNXd3Ntjqo16wTBrY5PMyswTEQ7g/QIlM/n7+vv6+/rXu/T/71/g7+vv6+/rf3z9fTj/vv6+/kWvvw/n39ff17/o9ffh/Pv6+/oXvf4+nH9ff1//olf7Z//yf/8//4+E5Pz4hrszZ0IEzYL5/mLNyXh9I0UwE/baiEBXwUQJkunOnAuAYwzMhG6N43VgrZOirOXEurneX2yH3Jv3f/43tCt//vv/Rib82//y79z3RLvRm2Akvp2v++aeDtIQlN6VFHgdnTY6TRQRJUNoZqgaZo0g2Qm+g5w3JklkECixF601kqg/m0r4zVybEBBL/Osv0o2IzU6FftJ74/pxIdrwmHRJRKC9Xsx7saezM9grSBFGP7A2sK68TuFU2NvxFNyDTGgY9EY/BrkmRDDkxiOx9iIFejc+v262BGcT7r3xcKY791SIjeZCRJA2yAyu640AJgoIrR8Q4Nvx2CQgqgjJvZLXxwdkkpF8+7f/leM8uT9/8H5/0VRZHiAT809mCsuFf/vzOwZ4Kl/35vsfB20Mvq7N2Y2zNzKc67oREtTYnnz7+EBMQYSMRRKkKqqdNRfX5XgGYtCbIQF7LXw5qclQYa5FaoAogqJ9MI4PpCXzfdEbNBVGA1UjtPN5TTISQcm9UBHSneXJmhNTaF0RTdwDEpoapg1V5V4bUWX0QW+DvTbzvkkTXIQ1HVXhOBuvjw98bfy6+X/+r/9b/j8fTsyI7fzjP/6DP/74N8YxIDfiTmCINTKD0QaIsNmIGJGJtUakQzqtgwjYMI5x0hX60QgEUUVRPj9vUoy1L1690/79T9I3a03EDq7PL0IUGQqihAefXwusMc6OaCdSGaOhGnRVmhqeiQIRiw00bWQEZJCxYUd9pqb4NQGhm6EsIMmAoCPN+H403r6Z90U7XrzfjjZFI1m+sKa00YkIJKGNQcTk/f7B+z2R7FjvhAQK7HAkN+YCu+GjsxKUQGKzQ8FAU4kIfG/yfhOS3Hvyxx+N1g8EaM0YJqx7g3WaNWw0gov145OQ4Nu3PwmEwOmuxPK6NwSxv1BtiBrD6rAt33QLXkdHcRQhTTGSfX8RqkhreIB1oUk9g0MaowvDjKSeQ9NGP052Jn+cDbHG7YAniOEEmoEg7EhaAyTQ1gjfrL2hCdo6rQlEomZkBPd9oRJIU6574toBZV2T49sHGUrrHWGTOxi9IbFRaeztfPv+QUSiMRERRm+sDNZaVcTdmfeFmuLZACcT0oGh9NMQMw6egw6ET8bRaeMbpsbX+6Idg3n9RdeT+b7QCCLi9zqnh2NtoMCP9yetGySYCNaNNgyRxh3QxGm9XqL0rMqWIKFINlTgHAfHMVBJwjeBIgmxEpGg986aN6rCfS9Q4dvR6ecHeHIeDbqxl/L1NckNkYLHImNzvD5QFZpKHeztiCkbwXfQLBENMqN+jwyW3wSJiBAk6c7RB/052MtvTDemQYTQVZBhzOloMzQT7Y39vpjuqCT9aNxfF1casZLWGqoJkTQTmnXmXvie2OiM48C64ZGs5WhuDEdFQJK9F6pgbOiJpjB0sNfidRykCsd5Ig1S3hiNed20bpyt8/Hnn3x+/jckg9YahLFovN9vWmuYJmmN8XqR0ohwLDaHL46u7BCEJFPoxwtrSqZgsjlfJzIvtDXe74X1D5IEgnm/sfZBb8KyXV1+DHw6e1+YHEQ+xQEhxUiJ5+/rXfMd3PcGhT0no21EGojikcRyPGBFMAwOE9xvPIJmHQ2njUZvSu5ZhdOMJkpTQcd3ViTzujm74b6Zc7J9IYCvZN034clai8/3xegNU+hmz8SV9R6YYSrIdjKddS32FsZxYtbwOWnW8OuT1k9AiH9iM/inh1MVVAMVZwG+hdGE8ICAHQm5EBO+1kVr7RkhIe6FCpgZao3WGymG13cmpSEChBPhnN8OWMHZrA7Y6zvuk7RG7w05D7osbs8aVUSR0bGEiOoGZon7Yt9PR2pK7y9MlHUv3uuNRtBUYU+aQBsdTyc8UBMSA1U8nsopDRtGyEaBNQPEaKYsWaRKja6jsWMjEUR2jtcHGYnLJqTRG5g6ZwfVRjB437umEXjui0O+ud83kVljmEBvHc1k3m98Lf54nXycJ57CvZzwTWuNUzq3BmRirTPnF70Fn5+fpBzc7wlc2BiIKOM88BWINESMDHAccEYTtB/VcbYTaYCwwyGScAdfiBjNjG5CDoOA/nrx9fkDEUjgx9zs7djwZ7w0dBr355u5N5ELswGxSBRXp2kVCQ8nIoidJFkTwtHY2fh83+xnhDczVgRNExODNOx5jt0EQrF28tFhe+Dz5v1eHAJzViO5I1B19krwYO/JdV3PiB9EOGpS5wJBqD+bEgzrqLWabtzZ6yJbR7Txvt6gSZB4bJpafSYztP8PJ9r/+nBG7hqZRuP6ulkb7hWMdiDPjfI9yXBMnxGmDcQSgcIMuQEnom7Kft91OLRGsYxkNENN2CLsZSjBMYyvt+AkdyaHwu1J7GDdf1UHh/qwrXHYgYpx9IF0Z08BNqpSBUOVvRcyJ9udlUFrynEMEODBXtkatEYsB7X6s9K5v75Ig7U3fbxIa9AdTyO9ulwzwdvxdO3NawzaeJFm7BBG6zSBPk4iBUnFmhIS+LrgeZH666jiEBP1jh2DMQ4yBt8O4zi/IQpNOp5VmMKMazsSiaZj4+A4jPv+rJ83g6AwDwHdGrsNRAVFGF0xVXofCMFeF9MDz00ioIVBVQeiiUWynw6foWBGE+PeE7km43ihoiSBtk5eSjj42qQm7sKPr4u9Jynw55/faN2Yc9W9UaFrI2eQ7oQ7kcktAiGkOOLO9/PApfO+bvaGGV6waUiN9seBhmBWTUFFObowdxXb+56kC310ZG4wqaKjBbnA6f3gnrsmmkz2e5FmtNc3+nHwOga9daw3rkisH6DKIlBJEiOlY2yyt8KsMZlLkFy/dzglEhvQRPnz48X7Su77Zq5Ja4ruVd/cozqOaJEMJmQErTdUjHwIhvCFaI0ORBChmHUyHSWIHZgpHspQ4+OjcZwHEcF0xzJZu6ppa3WIx3ESXhV6HI3Yi4xJ6y8yjPV+gxhmnfM1yHUTkdw7WJ7sfQOCNkN6FZMpN5kUKZHBfn/yXoFvpWmjxpHN0Y15b3IMcsHRBrdDaiIRLA8OM0SVJdUbRQ1rvX5mJGZGE0hrZCZKEp50hE7QrHEcB6oNsz9g3VhvHH3gAmttcBhjcK9J6yeSicfPgnHSDyVycs2b8+N7jdWZdO0MUUQEclXBS6c3IdNYt5MbpBsqoNYYx4ujGbGCN+Dz5vj4hjWhGWQ6Any+30SCe6CjOAEP8LnR3vjrP/6T67pRHOsH6QFq9LOKrHviuUChHwfcV/EE6czrwlrjNQaqiifo+eIyZ96L4+h0C0wEQVm5sWwQDtHQ1hDrkMmwzuf7L3zeiA2GBiuT2EkEqB2/DrW1+nnWhd6UMTrH6FgfiDYMaEIRhxk0E8iAdJQEkYJ0IiQw35/03n/vcG4HndA6ZCQmSZPEjuoOSdLEaOeBo9B7HbLwwnBRo6J1Y+9NemIK43Xie+OieGoVqwBMiRyM82CYor4YZtjZ+FzJujf39X5uhBEPedFNsDGIUFYsIhUjWBHcc6HqGFEvLoKn1MsuVr8r4E6RD7HZe+HhiA7WuihuIoiEbMa9As/qcm2MwrQxQT7Y60a70kw5+ge+78J6ZmRMtirz/SYTjtHoLYsYMqGp8X7PYrd9Yb1hzfAIVAuvujemOyI34zi5PVhz4l4TTnqyM+kqZBTbiu8H774QFLNG0442x2LiXvdAVVAosmM7uddDqA3GtxdHH6Rvtu96XpF0O3gdJ56OWGcM5f31F5rJ2jemByKNJPG9CVE6ivSD+PqEUFSK7OrHgaqxfXPNhdlPhl/JcRBrsX2jCK+jY1o43fogZXMYRB6MJjQ6xzHYs4i965oc58GP9xfHOQBh04jrXbBAB41gXU7uYK1Ne4rg8s04B6MfhBdIHMNQ1WK/RaqoxsLYmBT08xCsj3rGvtkr2BlkOF2VcxgevznWHsdBk6K0ias+ThNMnG3C+6oOZp70VmRJuEMuIpPcgp4vQPBMRIuhfV8Pra+F30KN/f4qIkEa56tjBtaEPZ2IVcwrsDNoIlzXTTsGaZt7Jx9qRCwyvAiU3PSm0OCahQ3xiUmRJwdKrImvYp2Po7NweiuQj4CKE1QHFO3I3ihGepAC9/vCUcarXnpNBd+kCE0V35O1nb0mghCZNN+4T4YmyxXiABXAyEx21AM0TVI201dJM6u6mkoRS9eE97rwnbxn8BqB329cQNt35Gis6yYDVJROcH68sFZjl1KS03Vv+i+1uwrqvR2PRK3TVOjniWZDdxUlz5LOCrYs8IuM5F6L2JOdShsNGQ2/F02D9johjelFkLU2+Pj4BtuL4cwgMlBpqIJIjbHLExL2KtxaRT+5ro12xXrDZyKiNBFaJunC+Pio0XMo8/rC9AHAVkTMvRyzQTY4DqW3XoxtH+RydvwgMmsqS2iPcqGST+dV1BRVSJyZ1QAii/2PkPpeopDJnkFmFiToAwikv/jgNw+nkZwfg7U2qYbvDa09TKxwvk4iweT5pbNGt1Aj1iYLST/VWti72NAdE4max3vrTClwbT+rJJu1YM2LPg7Wnph18MXrGHx8fOfHj09I5+vtiArXnJiU7kUKPM+ij4MZN+HF0q692WxaP57DsFFVtibNOuKLjIWKls5Fx2MhqpgNAoEwPBbugu9Ft8ZaC5W7qPFdDLLEjfTBOEcx2DuqK+Yme+FZa4a2kp88NlAHs6kiaqgIns6aCzXhwyDp3Mvp3bDDaB5FqpBgjXl/EbPuiYQ+o3FV+IhgXyVb9QYiSWxH7BldKezplGQxuqJa7PTqRjzTT0bSuxDR8PRiR88P1ltI3ry+fefr/QMdSgLswHeSKFgUW/o66Vrk0lyLtRbt4Sla72QEa1encQ9SDEQ4TkP7YG3YK1nr5uM8EDW+vf4ASVK03s1WclMUx0PThFSwwQoghYyCB9YMJImYhC9oHVHh6CfW/ju3AEluZ+0g2JiW/JKqRCqJoK2RCHs5R2+oNjySITWhuS+6Nsj9m4fThLUdVSXTGOPEkzoouwRbj8RIRm+oPCA6k6SVrEICVf3W3vAQSZHFwN1+/6rC2pXMju/FjmTtEnWbNbZvJBzVwfv9VSJTQmZpkWvf9NcHrTXmXmx3EqkiYEbrhkoDbfgK5l2apouiz8/ozUqv7AcmsKYzxoHQEAmWQ2ynny8+tLHd+cdfX4g0Rj+4p7M96/dsDZWkaR2IjMlam+3FJN9E3atr4TmR3LQhDBusDNhOxfkCj+qAxzGQNC5PZDQyilya78lcm+M4GP1gZpA7EBGaaXUNKGlLhL1uQpQ9J82UbJ3twTEGmYKmYFEMpTatF5iEDGJvlgfnMFpvWDu4/YYI8CS0utnX50QNXh8Hc8M9J2slaElrrXf6eBHzjUcVbqRGeRGld0MyMQ/uu1h/6wetG00FpHRdj414kgRHawSwY7OjpLTjaKQIQnC0TiSIdIzJ6EoycIwdi+kT2fUZPZLcQRsNVEr/PA4EYe2NZ7HivbcaY9MhChOvyIeFht474bsOfQbSB12Ke6hO9ps6Z4YwTEkxWkvWujBJVBIZUudj1SjiUcxphIMq2jpiVUXqf4lpCdjKJpqyMvC1SKSAtRnX+6rG95gFrveF9Y6kVFGIYM2LYxzsFDTB3UEGjIP3fRGij55XReHoDyObSQj1+2uBdSEwSSSDXJt13/RxIr0zzs5ai+lRw0cGpgY7iK4cTWnpHKZ8vmc5lExYAe5JN0E0S4slq/sOAxdEguu+WGuRCSYBWkNOBDRT5k7u+833768iaRwuL02Q20kRPv8KxnHwjsWaTrf9VOtBXzCXsxJeZ3uKWOBzV/NoQqZifWCtxtifnXMQzL0xE6ydkBc5b1gLn5MZHY9OO/TRI50xkmsH1gb7+sLU2KuezxgvNv4QWMHHS1jXIj1ZK+j9hTSh/AU1ZTS1MqpY1pivTpLsbEhuXucJNJrKwxNQECF2Yb55Men0fpbBIqPkKZR1/6jpYRyEC+pOplWHzSSw0vMpcnNFTVY7IKVxjBprycTd8V3viAdkPk0qgvf7EzfBTBnHWe+qNXYkmkFs/73DOe83oU5rA01HwksM3rusZ1ZyQGbhgCIgFNHCJL4fpqpV9XGpapNSLh7WJsW4pyOa7M93kVtk6T+7iAprnf2QGpbJ6/WBiaEJc05ErVjgpIRshLkCX4UxP2wwzo77xtOxUWwpWV+TcbPvTZiVvbCVCwkVMgTBiayXvg9j7dJ5pxfeitXJPWmjM0MeuaFsfqodRWhN0ANCSn7qAl/vT/asERobQEd1MFqD2Mw1MRvFdGYioezkl61NElasEsQFzvMANVqvZ5SibHEkDVLJ2Pja9FEl0sZAVElqlBPqPiJWhWw7KYb1Kiaek4gNCCHCqxtIkKmM8SpcFkG3g++vD+75xaLuYR+Ng5pSwp19L657oWTBkXGS9shrCUg5lHZC63U/PBbLE0+jqdFbo4lgEoRCEuVE6u05JPm8i4V0jj7Yseo9zkVvSuvJ+30Vu20dEeU4hN6ce95FDNFRKaUCFNHGWk6uchRl6YY1iamQ+Uh8CtLriKU09irZZAd8nCdrTuSfHMF/bt8DIpJ53yigJrSzs9dkPzaoNoR1J4oU21p+G7YLPK17bi9amar2KVZj56MjBeWy2GuXdWxtPo5B6x3PzTiU99dVRgFtjKMhqRztAG2sdZXgnUIbJ/PHf0I4rRuHNdTqhdOCFEQquCMSpJQ9a+2kUTg79ibF8SnMWZjCUzlG/pRDIZz3fWEmXNcba53WR407XhKJdiNDySibnxmMfuCzqru14zE0dHrr9HFwvg4MxxfEIbTWiARNYe6FWC/h/V70x8qmWq4kpyEJr3HgzVkX5HK0ASoc5/iFbzPBbDw6q+Mh9F6i+Q5B4qD3R3z3ScSq//9IH6+Pb7RjQK4qVgrLH+NHgy5H2SwJbv/CRDhH4xgH1/tizS9iJ3YUHnssBqwwBK8iL/o4cEqK0IJ7uG9ElDUnaVoHSwUTIIp427vIRm1GPwbugTTDfLPWu1hwd9QdwXGfBHWf3CE8iiAin9/H2HMhfaAke2+CeH6uFbsvglhHte5vkyyb4l3uqPJob2iBWHEg/K5DyLVhWlT3vlfN7iL0Nh5ZRIioihWxy18bZd3DGvKAaMlkGCVa6yAjcBegE1oi+nIvbKP2NK0aZ/A6UK0pEsZy50Ug1kBL28zsZdLOwntdhYiy8Wl7qv5e+K8RIuom1YBY1VztEeidtd74LuBuuR9ButWoDZgHl0/Mqkv63mWyb42XBtfXF0LSrRjAw6wwsgsh5UayxyAd40S1WN7wIJ7O1saJSDGUEcJ9O++1OA95Cp0+L/zB2YTRT64N6YEdR2l/6qgoTeHbt29VVHaNpWt5vRfy01zQ0DEwUXyVz1V7J6Vsj11Li40eYEXIBIp7QZZIx+/F+33zGn/i4VWA8+EdJCGKx9CmyDJaD2x01Dp7LXJDhpeppStNnnFf8iFqyniS4cRauJRclFLMRtdR9rt1P5+7ivJ9TcSMa25yv4mA3pU5NzEnezsZyfYb6wdf7x8AjNYLUyrPuyO/Pq9aafpqDUSQKG27ad2LptXYEMUfj7aK8vE6IZ3bS73w3z2cW5T+tOt42Mu1AlWDnDiNn+1IWnkvEZBUnIANeHXNpLqAWSMy2OlECv180brh62bvKBmk1feJLDodSj/uCr015pwcHx0nMVN678y16LHLg6pKPvhGrIEslPJpugd7b0zLb4l2PKIsaZkQUjg4qqKWAVvAGvlY2/ZjKdueaMI5GoiTz+iIOBJSI2Tr9c9SCptcq6r4GNVd5aHSM8g9yVZWs9COtIaxWbPkFQ8Q65yvTlhZCJsNzuOgqbN9glSnLhtlcp5G14aOTibEunGc0Q3pZdie8TCPO6pTZHIMK05BhQgvMtA3os8zZ+OuhCjjfLHuL2KtstV71uRiyZzlMFoPWWatpIk+BrJrIhOp7xePccKMx/g/S1KzGr1VtIptCvOexIalRUR2lUotqaACYzR8OeKPIQBl+WLP/SSOeklvezM9WLOM8ErSx2Bds2yqJo9TTEDLC2u/+JNHGxYhTNgrywDTWpGV0kgb9CwzhDWjP/7dAkv5uJB+43CWZauVVapVXCgf8tUD9vSHaS3DOyp003LezKAZj7GgjMz9eXHKm5tAUc/aBuqBjUcjIvEUunWaCPc1yxhthWnvvVEvYT4i66B7ELLY6ZVkEcFaJQh8BymdpkruTUT+0r08HPfCJ8URRY3kgPh+Pp8Vnb/eNDVUG82E86OjuUvoz2JXPUojFKsZTBWmb9qT/0h2jTP06phU595eNjqgxuyV5Q+1huQEoFs5VSIqUjbGyVrO+97k/qwgAQ01mO9VmF8gVbnvG2tlzN4RjNeBHQcLwa8oq97eaAqnGW0cSDqRwfSnyO1F5nzue3XEMQ5II9uJqtDHwes8uN7vKspqHO2R40gsyimWXnKcZBF0oxnbqys3g9jPM7QyUujDApcEXZ+fR4JTkSr4AUfrNd5KeW7Zi94aPNLHPZ3zkLISZtIyiV1GBZUAL8ebtVZe8dZL75T+YNqka5amyU/nZ+HO0j4LHpQ0U/JOvR7F2GbWM9kZeBar+1uHU0VZe9FHR3uNjaSyvRjIjKKwSyYpJ75ZAeKfrF+9kOWm8McfmUgdbp+wN2P0JzombC+JZK1Nb6OSB1KpiEpnlLA7Z6Byo1RuNNO55yQT1nK6KXZUN0gEaUJQkaNvY9QD3uVm6mZEVnVMNm0YaycuJciLwX7fha90YMPoXXkdL9Inf/3jL6wJZkbQSh7xTevGun+w7pvUXvGuJ2b3cwwnvTBXVnpqP+NR7F2WSGrc7laspGYUm9vG4zOe7L2wHoW3mPTe8YTWWsk74oi/odeL3XpFtvIR9MksD/Iz587tfF3z6VgFXdyT3Fne6SdUkNsx6/gW9IE66pvcq55XCCpGH4P5tSviheLzxjDERhnc1yzZpMYuMuNX7lZbOchaM8SKlc0QWtdHlqImGxrNQKQiiETi+/GtbgGC+65R/uvzExsnY9TXqZZhH0nmKjyrUqTXpjo1Ct0GlgvTkj8yYBOVRDHFstJNrQ/UBpmPPb7Bio2GE1LZ1NuLw4n8TbYW5MmzFV0fTwC1q+A6WHOzVnky516PyZca98ywEESq6qkKO5UdVUHXrhCtPgmCqk5e46zXvXIMtywsMm8wpZHI4+oXKdO4quIi+BasWQVoRYp9NCX2JvasZIUqjUqSINC1dMDIB0dY2fEi69OrKZB4lEC+n3H3MAW/CXdEknEMxtGRGUQ35lrErkM675togA6wcjr5ciwCiVmjflQEKnNDGntNWj9Y7nRtDFPuuck9iwlurbRmfxM5oDXmvTAJPglkfGDSOLSjEgwFiYm2jj/wwaQ0zGaCiOE7metmL2fvKo7ymAIidhUH7SWdueN7Y16MeVKdkCxCLzJo8hyoDFIbkfqQbmUTNDVGM9YsmNBUyxkkWokYlXqPrHTPyCRF2L4rMxmBapRW+0gZksLeT0jeOr4m2qzC7tvpvZUtVYwaTJ1jnLg6PJ5wESUCQsrnnQKaYL390kChkkThARIMK4gAhU9VB2vdj37eiLAy/ROPO06e2NnvjrUSoJXnG6mojUcbrPya6U+dZxaTJlKM15MV2lFEkeZTYVEyS4xVfjKf9VcRRTPo54u9ndY6Ig1t9e+uK8tML7C93BzSCrPpk63bUWOQNUHtZyxN8CjmLXyTLrgrpoYkdDVGfw67PcFqD8boNXrJRmJjaGHVXlhVzNg7CE9a0ypeUayiqRBzsvzB59pAWiVYAuY1QQoCmCgaPC9iQ7ScLSusOpFkOaS0lVsng4zFek8knb02jAONhucNDssc85JSivAyxEB1VBqoG+H1u7am5K5OgS/Uq6jI+MmUVnFOqdR/SS3A3gi9fMN4+ZnN8GyMkdzzprdBSBaJ93GyVlaKKRvSs/ypJK03PPSxTII1o51n6ZWRv0bYvevlLmRV43lLfzp1mQskYPnzmVXJWOBlESxLbfl6i2x6pLJ8YmZPflZE2CYPUfekYCKeya86ZhFpUnBnBm6Utq/K3sVyz3siH7UtA1VSFLVETWA9CkH7TeO7KuURfb7Mo+jfInUWUJ0q0x6tp+bw1mttg6kxZ9HOO36ynoUbMUWIOphksXhy0PqB6uOjJKgJwsv5715fq4pEstdijPborOXO+HkTQp81Fxn1klqja/wECYCw74UDop1mhZuVqmaR1NjnPzHpY/+SVgcOI+JJHXiw7l0VkcLc+dP+J0rrL5o1RGGV6lAZ0FajqhF1OExJCnultud7ZM0v+ZNZbuzc7Huy9yybXcCJok/CB09iT+6Aj1HYSR+86et6Qtf9IY2qcKGNo4NlhRXOJxQ/78lyGOeoZzA6sTdqHbNdWmhWhrfSK49nWpV4HDQeQT+OkixIlhg7ix/ABZo+7095i09ThikzfppXStcExzMZoxIuGQZRTKi1ItyWB2IDUyP2XV1wb6yV+4moUICmYGhJe5rE46fmkT/YxZ5LKr5XSSZWakU+k1thXvnlVKs3uQwG+GZ7INck0hmj159/irdQCSv9n5/Nf344SwznmaEVsqxb8QjPyCKjtB5V4Z5luzt6geKMYtqQoypglK2syJfSpZq2av1mhFQuUAX88VqqCHtPIspc7z5RM7Yr0hKkFzv4iP4Rm/ZgyhBBUc5DMVpZb/RxLHkivYqLSzmXioAw7u1VmxWExrwu3Evgrq5Te5J8R2lwYngovVWSP7XTj2KSsYGiqBjz2TtzjAE8OVbJCourPC12UeIAACAASURBVLw4jzBfL/Z4dFePID14bwfqHoY2zvOPR1pJhEaq0FutjOHBl61XUFo0K7cIiA0cZV93scAZ9GYcHx/0qODwWovti7WSfh54Vghg3otOrX5Rra0EbYxi3Qn6aMztiMB6vxGUmA678pCi4NnLhkile35GrNZOPPXX95T9hBEQQuodir3AJ0OF4JmeEN73uwixJnhetVliVn502MBax+ckvJ6VJNg4ntjgY22UgTzv6t4JbDKCbu05VCXTeZY0BDVJiD3ml1kWVXvgl+8i1Rg/T5Xw/roK2zYjfpcQMmm1M8Y642zsO9i7cnXPGgOswdzlJpnbAUXNyj71xMpKt2xgyVrz+eeCasWhfAfncVbCQbxY39HgGVP3KiA6w2lorQfpte+muliibWCPlhm/1mqUHjoata/lMUOHR9kOATJqOVSWcUBUnjRJERgrSn4xlYeEmaQHqp3UZN2LQxRrjTkvnMCyPLtBYzyWQ0fgsX2VY8cfKFBsKs/+HsWeET8ZrXyZ2hr7up8Ct/DHs9kiOXqlcea9yn96DprVy6pea1z2/pn4UIYq2pQlQr0XVkSe5C8f7iHV9eYq4+XRG4cJkhtxoZd5qthOLdePNkjZNOu8Pga3b0yUef0FDK71xfakJ4QnMgbTd5nCTYu5BTKD+w6sJ9aeZVoZrDVZ864xMpNcjkRNH/XKFwFZa2s2fk8SuK4bb43Wa3ymOZntV8jC+kAkMd3M7U/GdwFRnU3KpK8VPykCKrJyys9P3qLgimUtGtvrphsPwVhj+tql5atEMfq5Oa0j+ZuYs8zrUnm3KNvSGIO9b+Kn9pfFeN6r8o72LIcqo2MRFxKVA0WFvYKHY/mloaXDdU9EClMi/dFS46mgR3WPWYl/kVEp936gD3W0d41zpo3IOsxFTwm5FrInoqNYWZT0eKpwPisowKx8nklFkNZy7lX6l7RGSqJRqZGdUR0pOrEWtWJkl0iugDYuV/BAogzPKqWDxvKHYVXOs9FVcQeeSJFnyTktauEVQo3qUuM1wLWDj9bJdVcQvRdG/nY0Yt+cx+Cejj/TR9EDwtYSGnfCvTY2BmeDw55uolpifAYcA78XKZWbDUB91zqXDJLaz7N80Qhu3+y1eZvilO0Sezr13nQbVOZcy69sQmtWppYUIvavdSB7bTKlMKbAXs6a/ou8ak1rtBUBiWK+n/UxmcEmHt29tiduDw6r1SeRVrG+cTzvbIcsi6ZZETr7IYaKwX5MNvsn+5+/WPcywT3jbSm6aG4igtEHaCuX1KoDX81KGKOyz0WN/cbh9LWYTmmK4vjaCF6yiciTdM/CdmoFvLPWVsjTCQoTlE1OH0lFrLpXayCRBLWOUc1K5H6o/e3F6qoMtH/QdZWjX+pm9wN8rlrwJSU+l25U3tDtTo8s0zKG+Mb3TaI0O/77CyEVaXPfpFVSXrNyh8iqMXrPimVpHZJ73aXPWWPuSZcozPiEjkOMPYsgKzzrJUfMi06J9KYDtbOCulmJlZDEl4M+SRxq5csClheGtdiQyn29Ob7/gY2GAHN+ofIH2o4qraa1mpF6GXaWhGWPv9eeLXmgdKs0CA8zKanoEO7R2B68vz5Jrc47FEKEftZ2iTaD//zPfyCj1qZ83TfvedN0cEdtusvIGvsjOc7Xr8OgyC9MiDas+cPE1yQztzN3cRAeWdsSrNaWxiNFSVQRt95pJtz3m53FchO7GskTlxuvj2oe/dnQd19Y+ym7N8IX4V5Oq8chV1C0JCdrVtNIFnlgWoJXeK1XKXtj7RgyK7VDKajS+yCIOviU5HcO+73DGVad7fPrk2vekGWfUgFptUpCsnCiSflMRzOwIsxNFU9nU4ZvfcTtinmVO6T3UR0sg1i1LKn/HHfnpo9BZJS74jBYdYj3mtWpemd91Qs4H4dEk6rOlSp4Fjrps+PHF7nrxovWQ1MprXF7pdnX+6JZmcK19Ur1iLGebrd3dTP3za1OVhbrCes2xF5kJGrFSqsKOSeairZWWClLwNcw1p54llZ3nC+2Ofdy7nvSLfFs7JW4b76fJzknjvGP90Xri/7xrci1FPyaT5rmLh1QS4oIknttcjof51FEUO4yOyAohRHdA0mvv1erLRZRAn+RZFnPoFkZu6V06d4MbwfusOci5oaPx+EVT3eKRTsq6B0rec/aPdy0/MgClXp6WFB9mHPWXeaPZ1NCa/asuSnp7Wi95A7f+K6NkceZxeJKPHApmR6cj+GhN63cqD05ZYSmna/3hSCF+a3cZqqdGbVGdLSSWTSrU6ZX8/EdqLUyvnjQtQLla14g8PHxqo0QagV/nu2U63+eGPsvOqfftY/zPJn3FyZao0pQWbZntEBq5QZhRczI4z8UJ1YlIXIMjn4gtnFf+FR2ANSWM/NndykdZzO6PenzzRhCO05iTWbW4WsNfN+odvrjlMmI0o96yRCSVUDmvMnc9F4srag97eHJ4EmypIRiydJpYdIT0k48NiaBCNxZe0n9fvM6BnN+0TS5bkfaibNRUXbks62tpACVkhokBc9nFSTgezKvN2md43hhVg903qtcTNqYj1uI3LhX7AtTREfFvLLWrQTCPZ2P7yc7DfXNt28vtA3e74uuwvREvFZxBMl8b3pv9F6SQm/lMtq7pCWkRrrj7EV6ZHBfwZDHxXVPwJDW63XystXNVdY9crNdoUmFu5vQRbhXseLuswLbc5cbSI3WHmYzHQ1/zAnxq3utuUuqW845ynLnvulaX6cCaYX541WbOFrv6OiET9KT9mjqIhXxM2scGvxxDt57s1eRPAhoN1rKc29qIwVPQ8mozomUqQCB2EUo8fgCxB5SVbQmOwV5Nl78Ew/Cf4E5pVwsr+Mhh7ysVqH6i7SJez4aZv2CJQ7vcu6rIM0Y8lDWsfm5/7Sdzzjnm9sT27ViU5tRaTrIZqxrsvZNG2WOxlrtcckyQ2iz+hi71kmuVZvnRovKeqYgrXN/XY8IXUmOn5Y/nnFaJWlmtY297jQoaG6+H48feE6GGdM3qllmizYq83ktbJRuqK3/EvhhsjcMK/xSniohM5/Nb5WGOMZB7537ffH1niWp7IISZQy/aaK1YrKftQ5SQdjs+2IcA2/1HGrieCFAuHPNN2m1OcCgcH4KawYra0Hyx7dXbbOQcvWE1jrTDyaj1+7iEPBIvnxx3Temjdmh6TMB7fI+416h71WLNrUp7hv9+KC3DimMUeztikojVdlUusJ8FsLxMx6XIL5orZNeJvWQxnJn//WmS9COXtG7Z5G5ofTjRNQrcofga4IF3YyMxYyogx/6LKR+A/Ir/bSzFIvlZXrPqEXkNWIDj1xW2ww2ub32K+0NalhmSUhaHEeyinXeG+Qx9fObY63KwLMcI6QBwS7DLcPK+iTPSCNJVUop616J/sk4DoZVaNhX0nttVyt/5EWK0Fsj/bHR7YV2rfwiIA1iTfa8i1XUYjDb0R+hOzha4h0MfR6oIlq7Xv35s2uuqsxW/llriRjcy/HlvJ41F9oagxqbZixeqmQu7qu29AXCt28vdnSu9yqs0l/litlwzZvXSHLVz7s+N+FOb2ftT82ofThZZJm1D0ZrHK/vuAf310Vsx1ovnHJUjCu6wbpqzWQGlp3ruvj8cWG6UDHGeSKaZGu1Iwjjvr/YabzspB8DzVmpDe0P7n26inTU6rlllt83pZGatAGJc6qwlrObsrPSJKKJWdLHwWCwInjbYqzgptagZmz66+D1+mDNm0jj49t37n88XawZrbXHeVO54TLDN0AhIHM/WmMnRJg7aCQuxkyBVSb0sxcMuefG50WK8v3PD9ZM5rrwqAP1c1v8SmGFs+8y6seq/zSEtZOEYuy3lwqwHdNqde3BohGLzJ+RyGCghHSsdc7xZHMp1xSapFrxFBGI9Icf+I3DeWjiKPeazKvwn7XG3os5S28ja3WHSLF9a00iymtbm+NK4I2kJIblhQGpqhi+azWmUPY8+385e7dlOZLj7HK5xymzam+ApKg5XMz7v9mYjdn8VDewqzLj6HPhAfBKGrO+kmhGUWCjMjPC/fvWSqxZIWTuevmxRjyWkXKm14vZFzOp09/H8AV/DGRZhPT0+g4wqq89UghU9V4ksv9hjeZekOmE+tF0l6MhmkfIEKH3QevmLyiBXis5R9DCmI1lg5QTOUfWgiMFolW+rosUAuUojFadz8oihgzmrYnjOBHx1YlsWFR5lP2/B4LtDbUIbf76mggxHQ62GpdTxMvJsvk7sJ7SiepimqJViLEgLEJY9Lb7tq37pLT4FzvIL2qF509VCkIghkXtY1foDMbg2+NJGgMLmSjmPhp1Tu1sNwMnsAuTo7gPR4nc1X/4azSuGTnLJwkPhwT1e+80x6OigWHihYI1UAnbSwILZQWwFFnJQwIxQEmROR3irbowKTuc4smkkiMhJ2JKBIVR/aMRxFdzQRwM8EjKmB66EQJZha6/EkybfLDm74CInxgFCYUYnJMl4kdlJJIC5JJ5vX96TFQFG/5MrN7+2sMpSUkWqT2STndymPC7XiXqOclrc0TDHiis6c4UDZG5jwmyp6CCF1iHCUETpSTu19fmwfpkU9PJGMvpC2Iovvi24H3NboNkk7C8T+eLaAXrRIwQjX6/abX7+gWnqgWFkh3a1KfrHqJGyrP4JNEcud/qRcwHKsrdfXr3KDtihkcJZd20+83jzL54T8X//5hhY/h6InqM63iezHpz/XhjyYjlJKa8U0f7bjcbOSXOzwc1eSbXaoUBr+ospZSK/4WnBHSSmHcZrTvYbBqrD66fX4QSCTERNBM1IWY+sAiNQyMjuj+kr4lKQiyx+kCjByRS8FhjJ1KvxaoNTAn7ZVLKwcKJg2P5j82YBOCR/E55dfM/q3n0LQUPDYQ5mFYpqZA3AcHW24++e1g25vLwvhgRr/KxnHbhMw6/A3u9T51+P/z0Nftw8t3039j146I8Ds4zs2LA+qK3yfuuPnAc3bGavdPnQNWHl+k8fr88+/tF2HVE2cER25iRjWiiVZ/spxCJUTDx1ZiIYrMTU95XocARM/W6mPoXSQgxH1xfb4jZJ2T7TN17R9Sp4X3iwwCB1n240RFSVl8vmHnx1By2a2M4pWwqIUxEI5oeHkpYDfrtOETFid8ivK8XKjek5BNOFBF/MIOkzUMN5PIgRyXo4n53xNqePOIPZimknB3haIGSEmfJztKZHTPn5dQlru0xT9SsqZzl4GrNO33LeH19sSMiCN6a+Pn1RY6JfjskzEz4dnh/77WqD1cYjNmQ7ij+DWmgJFddhOAZz/qaDDGa+S6xdj+6zg3XGsO/6JpPojWiZsQg/6bDVfL5nfDcMOc1fZUlgSNn4vkgH5l//Xix5CBoIol673P6XWz24cO0tUjxYE4QKnW0zcPxCNoy9cl7FpZOBzSrv5wixtWFI0Zsdj8tEdizJmfslhNBKOcnYy7uWR3MNpzvGo+TFANLxJtH0/lGv5JBa6NqVhBXMkRHehKdoRQIJBX66MQQqaND77Cq3w+Hw7M1GI8jU8q5I5vKFKX3mxz3glk8DRdUEPE12pq7IihCjIlcIr0214mUXSfb2VyjY1Z4nB8Ii6/X/dcezvb+ieA8UEwY27CkUdCQQP2CHvd4W5cx8vKirYBNT/uEFIFEr9ND5yi5JFhGrXssj4ce5qwby+FTu3cfSEnMPigx+HQyZN61UaKSEt40GN2zseZKuIBxTV996IJsHu+4a92ZWCcKLrz6FG0xV3A8pQg5Rm9SjAZzcHdB0pP3609yVDRsgDPeA233jS5odXBuRquhTE7OIoxqzOI1KJPoGsPN5tXgK4TRnVCARpYIoTwJarTXTViDVgfLAq3ffJyFcjppb/RBGJMQoTcjnx9IWsgSns8nX1+NmBzQtqYykjozSSI5HtTmb/21OqHfPtSJyV8+dSDV/047EAKM4XlX1UAsgV67fyl6YwL5/OQ44Y8/7feqquRAv30f081/T6/rRgN0MY6SaAOfE7TppMY5GTEQSqGakx4XTsOYo/kuPUY/4vfhYC5xVYNG1wXGmDkerh781x//4iO5SgTx9VzvRkb5+fOL89uDNszRner4l6C4RCsfv5NWhsdIRQKx+AxEQvTnIPlddQUP28RyIsFB4l70X6x6M4aRkvJx/sU75/N5kssHfQ5+vl4YRq0ePJirU3LgyMEZQGt5GiQa0l/eu5u+93HNWUQmiDlus45FjpF8FAc+rcFZCuNeXnpNhfdojN5ZOjFZFKDe1e9SwIzBjVsyEHWY1vvrImclmDhRe+JtdvAFccg7H+s53NE8X3tZ2iHrhGyrWBu3J5VSYe2i7cfpX4znUbgHnB9/o7dOb3Xfd8r2tvjbtI1OfQ+QwOfz8I3iChtvsZySF5OXmr04CSgpZnIS0gq0vhjz8lzzGugKXO32etn0IV1kccaMRmEF37vN5P1bDSASWbUjITvtwQTri+fxdBB0b5u15FP6uXbBWTNBOr3fDkjbBfEaF4+PDxbmq5t6U5dxPB+OG2VujcRktEnvnbkaSiDEQq9vUjSOqAgDs4zthkqoizh9TRFV2aM+VGDodLAaHtBfsyLAUYoHVkJgzUqfSioPr/btfueZCtfXT5YNYhD//Ua4XxdRzdsl4syopZEcA4LvoyVkQvDr3Ov1xRjuqTXP5yHROUW9NiQKJfmxu9ZGSoqmxBChDxDraMiEEpnX+689nMuEq95ISN4+YUOcUyap3w+FgAz/ZIeYOM6TazXaMMbshN5I+SAEf6DG6D7YCIE2LnQsNCTmFF7vm3K4v3P2BhLRw+l+fTjH55kPhu0OoRgziNer7Ga1urmqTjgL8SSWwDCHQGUxPPubfQLXjdYacSnX6GiInCmzZBDiSVg+nLjm4HFmxAQL0Y+V9+Vv6Vqx6fusuFdMMgf3nOSj0GtDDXJK3qbondadJC84HjIUQRLY7PQ2iDkSNHBfDVKgdU81rXFhJhzlIAJNPIBte+d2A9+P7LvQe3KvGyNQPj4IayIId238fF8cKUP4ByKRj8/AtNNzw0yPvC1zgn0qaB8QjXYvxnIdB3fnPBvKJMbD+6Qtsrrx7hfH8xvKRbDF8zz4+fUmx9OjhWEy8RpZFi8zL2VTEZQg0e8hoRNkkqLjNm0ttBs9RSQemBlFfvlQB7Z2WV8iqy+gkc/vO17ancDAJAT4+vnmfJyuCQz/rsIdKVNiJJifDtrw9NmslSCOyOnNe7w2/OsbSyanyDVuXPUIqSRaG8SYKEemjek+VDVyOkAWrVZS/otfzoH62HfaZox2nqX4vkwcWLzGXrKu5oyXdMC5MLmcbracl4ItH5mHyLDF3ZeT3vrCbrcjayqM1khH9pwDBrM60DdnZP+pfIooYJ2w37i6wJbR5mBsj4r1Qfa6CrprZS5n3TS3FPxrGv1OYuIDLJMCZES6721tMO6LxyOzNmWuthd3H0hbHI9COgrX68YY/PHqBBNoNyKHU98SXHd3DmxOXs5HqRawObyXiBLj4ZPTNXxdoIuPjw+YNy2J54bncOcsi4+PBz9/TM6Pb7TR6ebgqmiyj99KIOxic6ddNyVmrA9f6i+PpI3b+TrC5Hw+MBXe1+Um6a+bdldG8xB+DJm7vbneF+ArtDkmbVZmd2JA/fpCltMOEBh2096Neb95/vNvHEH5fhZ+vn3NlbaRO8zT14Yaab1Te+WBUE58GileZ1siuC+0MMblk9fenLFL80I58P75JyG742VNF1jl5GicMQNHVuL3754VXk5OmKMTS2ZJp9qg1kkC0IEKxCCMye4OJ8QCve1yenDCxxyN83ywdmqpvi/AdujfiGFimun23z9///OXE0/NrBVoUyix+EMUHD+iLCy6eSvgxebNN9jwKqNXx5kc6lp6ZCvBl8EMWFBvw9fGQslJee9P/RyTrBPJHpmT6O5HaYPRutebciaHwN0dnaFbLZ9SwExp16CNN/l4gCZGv/0rt6sVywJ9A4fpg6tWQil8PAKm3tj4DBG1wT0WsTxQBveIDhhTc2PVED6OsHm5niaKYTcfQqBEj27V4ZSAEh2UNRasKbTh2dOYI6aZn18vN58F4Xxkh1kNCCzutpzF2gfNGiU+nH7XJz9+XMgSSIlaOzncTigPBULm+/f/9OHEfXvGVRSdk6K4ETsV8i6uP45PZpy0y70kRz68EJ8DaKE1bwCdj8LHIzEsc79/8r7czaqm5OcD628nEYqRrWwAN7wbvo55ZAKTR3T8y62F1/vtK4d4MsVZwed5kkS3omFhQWmjczcPJuTnp/+gl/ouNyaIiWGRr9qwWTYnKjL7zeyNP1dzsxlry59g2KTNi5gDqsnz5H3SxuWIF/M6WEwZVbyNINFRL0AuBQPq/WIhXD//ZBGJ4UCTbwu8P+6rrb/2cNabJcKcRlQfENga+14Wd6IE+MXjBFeTMR2xiG5ywi6pGrS+QBNpS0gN5+YMM6g3Gg7O86D99KltScmFtwhnKbBty/p80qdf3PtohBTJYdFXRkKiD/9zhhKJ2l0nZ8tFvCxPoUwfXK3eGX3QW3ekJoF3HcSgpOzh53HdDBOyTbQclH/8jevHn6SoBHHvi6hSSiLGQslPzGD0xhwQNbtoN2dEFymKr2n65PV6o2J8PA5G7YS4KMWD2Sp+SqijI/hdfY4Xsw1EC2ElL4S/7q0ZEB6PhKrjMI/z4P3zJ59H9uTVMnI+kPP8XaGz5h3cmCOaArsO7hG1aRzHwwdMalhvHGdEl5fBf77e9Hnz8z3dxr0gB0PMLdciUM6DkpXrutB0cl2VmR68lv9IjygcR/ao35iO/IyBbl5Z1KDEI2MxMGplje526eC7bF/xeen5bousgWmJ2dYGc4NZYuJDsvM8GPdFiJH5q0ES5Tflw2kLEbMI0/Ozczqkbnbfoceg+zfmjKRfBnJftQTWaNytk1KBGehzYHGgMrnxDQY6iX8VU7J62yoEJQZxTgoKIXknUrxLaauybHpudHXPP47mlt+1GGb0PZruoyNBieWgdlfPp7NwnE/u9xfTJq+7OVy5Lu4FWQXEPFEnLt3pw5B4uPPTizhcYzJNke5B5r55pL+WyWYdcvJoXjeCOOKihMS3bx+868W7wwqB95jkadiaxEeBnElL0TWoVyPjd5+Qkx8zF4gKMT0oWf143SpLitfs1nJsiqPhPEqoid04R6xho6Hlw9M2x8l9XdRhlHxQQsdidMp4StgIWDhJOSJSqPUHJo79SFHce7JXLyEl6hjk4qbqNSfDYPQLVcgpewNjjV21E6wpKs6x/UVJ8KERW11xU6eHy1WE3gYjzK1z90qX4jvcOY1yfNKmwGh8fLoQqnvYzMvnUWn37RUtM0J4OComik9qxctVcz9Acy7ud2X0QSonFo3rbsQIKfkAZwznMGnOrPcPYligLmD69u0br7ZrYHclfrpn0xZeP4yBKZF+3yjLX1riO91fUDFVz0mP23WFMUb6Mub93ukh4evry72mKTjPKAkaT/9dqRMk/tLDaenhxePp7JYRlKMU1hwsn/gD01H45j86kc2bnf71zI+nE8kU+ugcMXtudAEhEmRDk3pnto6aks5MX4PH88m7djR0Pp5PYOP52c385miJ38CnMYjqFjSXyGTq3elj+hFF3Cw1ekfxo6GP1BeD7pNIceuxIFiKpJDRCfXqm3eT9l/KJh2sm3w8/Yt+HGhIfP1882u5ugZQMqscnhyZnb78hXLmsElum5O/OsHcruzheGejtNapXxerN86zkFX4OSs/7sk/U8TGF3EaIWfGfTPvylqffPv7J7MNcjioA6JO5HzQrBHD5HV5ZjlvEgEI/XLu6pkTA/XZwFpbVOUTb1seSJflPKJ4PphhEGRwlhOxweNwXcZQ4/0aDOukR2a83qgoR1A0npsOYXx93Xz9fJNTIrIgGDE+WDG6RW1/z49DWLPxelXu25UH8+2T7Mn0jOzojLsiYjy/fdKXO2769P9ZR6e15kC1oDyOD0SM1peny0b3RFj03uYa05GZ5tSFvL0+nrUVJEcf7s3h1wspnqHVjgVHIKj5v075kzFdF8iu8P2lh7NE4V290W4qTj7rDU2F58fBz68vn+4tH22LBEJU4hLPgtrCrPmlOQRKCqRl1O7HRQ0BAe57YSyaDdCn34NixELkWSY5HrQ5/A0cA6gT1cqRMA3cXxXW9COwCjaEXrvna3eetVeP00VNv99qzRSZfrxeW4QjuKvxeRyMdvsCOp3ApE2hj8p//Mc/+LpuUpG9e3SFnYZAxmjtIjyepPODOGTT8xb3HFzXi+fjYCx4t7HBRAWGkA7/Qs/hQ4Sv6ybFg/r+QdbJtTxLKiFS4kTqz41HgbiUKI2aJmYH4Gkhj4hNZmsMPfj6+ZNUPOb3/PjAJMEGao22iDbIWYnFvwJ9CFhwJZ8IBCcqBolElP/3dRGnBwveVyUG40gRRXi/vpD8ZM3G48wMCTQNRHGMzfX1xZLA3Sd9DUY3Rr85SiSJMduLfi/qAomZ8igeF7XI4xE4j5Ordub1xoZr4V+vGyTxKAeI8vr6898np+kl6mkJk8gjGgTxgrr5ymdiNPN0HLJod8XaJIdFzGH3fhshuBZwmnggR6HO7vQOp6ltLta/Px5hVzDFfG1lY5JS/m+fv/95WtsvRIxUsrs1l4tz4lyMTY9z2rpyv2+go8FV5MxBzCdzTWdzqrsKlS2eseZDHnE+kY2OhMhYnVOCm8HM6e96POj3zVhvbAY+nt9JqvTWmQgxZNZ802anhELKhVo77fpCpjlGEnyX2KsDmAiUIORyeI1pGUl8QZ/Kk5QjliKtVVq9EBbn8Y333fjjxw93NSYlp5MVIx/HE5s3Iyia/AEXc13EfV0+PJmT2RvXJYQSfZ20PF0VUySfBdXMqMPdLDEzV0djYkylcXP/+MEzZUoe/J/lgaaTI2f+13/9oF8NC4vXe5DCSW+NJT6kqu0m5sxSaUKQ+gAAIABJREFUYdydJYHrvjgenyxNHBr8B2nusZnXzV0rrS1iKOTgA4+ugxyF+/LUyz///ndP4ahwDcgSeL8b0idX7dj8Se+Nu17kTR74qm4NjxIIcXLfL8A8URTiVs/b7g8rjyjErKjAXb3sH5MPZOwatOpInBCUUj5382kiMfD1+iKHSEoOLLOdVuu1oyUgYlx3JeUEsTBqR6LTFEQU2es0TclFyNOHfQkn+rl2UBj17b3VGJlATMUJe3OQY0RlMC2BCGc5WGtR+wvlLzKEJPgfztaA7l/AhXIembluVjfq1K05cAN1lugiVqCN5pzYGFj7qxTUC89gqCTv+GmA+cS0MTYNfFwXfQ6en09qvRntZpOhsNb4ao1YHi7EmdPXAzE5Obx6p1J0MkYlBQ+lh3JQW6e+L3IM5PPh2dy1NYI2WGPx/fODXNKeRC/uuzNJ5AAfH5nZO0GcnSSnT+jOR6FNZU1v26dS6NPJCDZuNB4+kDkySyK2fHCmkjFdbseOB6s7q+c4E30sVyYKfFXh6x7oaGiJlNPf/kZyx0kMTAv8+HqRZXKEyffPE42FtgbNbnobPB6FFQqmmTMHFwCvSUudorL7p5O5lDnMZwz2b6mQaXaWjwlrGH28/a6Xope4Wcwx+Tlu3tU44k1XJwWMOfxlGCZ16w+5KzIbGfwebAvdk/8gvmsU9ZywEEgaGDK5rxfrEg/li7N/1lik7PRD/RVhDM78XdMlx61V5qhOIDDzq4cm+opgc0uGvTdqa5HO4/eEXcQLXqKyESi72dKaFxVy9GKBCKNVr8YFb7ZoVObX5QQR9V12X8VBkH/l4YwxM7vvwmIMu0NoHpOay0f94hS6OTqiwut9OXktOI7S1sSGuzk0uHdxLv9KyiYTJAkgiRIjMRg5+kU5RgcIBzESRojRHRa9Y1M8qK3iu7hphGVIelAOvxf3Njawq3udrTtFPYaI0Gmt8vx28vE4adftPcflf8YRPWRvwwlzicXPH394BjZlD/6XA0mRoItSlNEzIgNHxwT67QOo2xafQXg+PkGU+7pYZtQxkHlxHJHnI5Ni5qZ6QCELIZYdiTPGuHicBbUCpWDF7znrXvx4v7zZP6MfOYsPaH68LlYy6iayp+cnIRfO6AiQbtGX53WyxN0za7xp901ri9YW4XjsXR4Eg96N+zJ+vi5sVVp3XKnlRjgWI0aSBGoTP+1Yh+Bxz3JGrwzu+J3RMIW+hCgRwX0viYLEg5TSlkwllnmeOuYDmTCt7kK/EwbZJI3ed7LoKITk1zHp1R8KyT58VGPhGVu1Re99S6nUdSKjUe8b8Ow3c9DHoBwPVHzPLeCT/uGNmZSyVwGXv4Qex8l5+IbDg/zeF9aozNGY86Ic52Zg/YWHs747vTVKitR6+Qh+32HWpmKr+DFBdfNWpSDRWwUpOJXO5yxer3GHSXBa3XQWTsK5tzGqm6qaExHysQ1eUQhphxLEeN0Nm/BMgT78/qjqUarrrjyOg5AyV70cAjUW4VcgPAQsLFgZ07htWE4DYAhI9z/rdHhxOQ7a68vdGSoEPVganA44B8+UeJ6J2l2BPppRm/Fg0O+LVh2rebWGhEjQxpo304Tn47FlRAIpsmQi3lVm1u6T1OI1vJQCfSYkFDQXuiZkTe7+L/7+7SDJSV8TpHOWQL8CVTLS/GuVnk/+8X/9H9Sv2wcuw6h9ERViycRUGP1m7YhlGBVrHUuZ0QKWkrdIotDC8nvzDOSstFFZq9L6oL0bMgZLO8eZd8QdajeUyLxuJB7Icnp8zoXxevNqjZSVeyykd8rjAz1P1zDgWr4gbqZubfDVfYXWutPocwosAWxQonnZPh7U3onHk/Px4G6DIwcn3wvEOpySaAG8xUu9bzQIWZzUsbqfHmwprQ53gsaMWeDr680anaMUxmZWlaCcKfm0Wsz9MxrISSnpwRyDvuHgQdjVy7/wcAYzbKMPj/J0kSswxb0nZs5lWZt8FlSR7DTt2DuynNGCLGp1LZ4XtyGzfRRzMIcPj2Iq5BxYmpjj3w90iAXmxIbbjNtY3N0HCKaO6g+2nJVr0Hr1L+EOO6j6fcVEsbCw7m+3VjuoM2YCgZzKrkwJYfkkUyRRHs+NQ/ng44xc9w9e12C2jjwW99VY6eDHz06JvtNaKxDEOI7MNO/1LQ2oLc6SmKLEw08P1hv3NV0rMVyTeJ4PZ+yGiLZKDMq3f/4DLCKjUmtjxcLzeXqf8ngic/D9f8tIH9zti4Xx/aPw8f2TrhGzzvN5esa5Vs4yyYdPtNu70s1IIZOLEFSJD6NZ4O4VWYE6oiNIaiXp/C0KKjHw1RKxZMxe1PdNDLZTOJHHkRj97YA4VWzcPD7zHtRENGQXAOXIh5a9CvFdtcreM65AW44xfb9fnuLZHWCLyfPdYhznScT3jaNtjE3KjOFok8jaIuJKxHlV9wyurpzefVVZTE3MVlnLZVZHjGgqvka0Sa+TEMIuXQxm9xWU72hdLXJ3/82qrt90eNMdR12O/rK/isZs3dEfbhsWRnMNAjaJu03+7pU1fXmswXtrC1+dqEZEPE875/Lo2iarz+lUcBHhvivlKAR1zV2MgSDDVePi94SSvI94jYmaUIrjQUpxpXiKfgzWVJizcRxeqL3v5uHw3jelwWkMIWVetRI25V2ZtPaCkCgh09Sobbp8aDdGxhTeevOv//WHIzDKAdGPM7N61jeGziMrhqM/lhkyK+dRPEA9FcxJeLU2unlf8UxOdRNx+aqsxlpOAVD1iapo4JEyqyuLLyQIMo06jDBAjw9svultotkD4HeF1A0O6FeljpuoBatvn6bfBtWBYrcIORorQIqFIwWyKfJuaBDabN6zHIOUlZgU7R0bxrF34Ia3TvJc/PzzxffP72jMlOynl9Zuvv3tb+SSuZune4YGVlhIKN6r3GyeiXENR4l2U+Y0Vp2u/+uTibtXPZQb+fZxeiNodYIt3lfjfH7Q1vDwgPjOVdbgdb9RKe6ZDRCTeiRQ3dGDCipuBptzbVBaIpUEUijmAIDWusPodhfVgnI1jwGm6HpJxZtRx5EhJuYatOYBmLr+4pfTRInRlXNrS89UAirO+JlzwPI3kqoyhvNgYlT6Ft+I+r/PplPiS3L0xTD3GpaSqdV3Xb/eVH2aM2HMMEmYXUAGVVIQYki8vi7PN07j3PezlIW7O07Ed7OD88isCSEVeqt7onewVLDgbtG13Ifi4lVo8UnIHmQ3Akkn3z6/cffOj6+b67qR8uDzLIw1IUTetfO+3hwiPM7D+4/LG/jY4vtHoo2Bqd9Fu3ljoa+JJOW28VuF2Pgltg2U7JmJR8rcvXmIIAmf5W/EELhmpbfpwYAFzyPz4/XF3/7xH7zfjfztA1Wjvb9ogM1FPITBokQA8fSNOC1e1JCwXassjhRY2SkJ9/vClvIoDwx3oVza0JQpLCxHvuknYQglBsb7zVEKISfa3TkemZASz+QwsK/75f6UpeRYiOlwBk+7WK2hyc/4c2MxrzqYrSE7G/3L2blUCCFzHie5HPTu6oYjZPpcvN83JWfScsHQnIZZoLXOYvD5rXifWAa2bXMEY6iiOxXkBmtzYLe4ltCh07aB04kUfd3opnYH16UAvTcIwbvFooQcKfnkvm+QvzitfZwnitFN0WVYwActc3JsAHEIbkyaCBp8OKPi4pwxXPGnYS/scbqa7WWwqrtIsOHT3OJNkNoGdB9Rx+A9T03F37x1MZu7RVLaNmr8i3jXuovg2VsM6lPjvqbvUXvHRoBolJQ5HhFhODcmJZRAAnxs5M0Mt0cpf7xeXNeFqPLx/YPnt4eHta+bRdlJm8Sc3Xepa/mPaDZKPuj1ZpjfsaYoLEElksTfoG5ZiRtq3FziFBLlKPTXi9bezLmYK1G7vxAISsd4ff3k82+ZpEaKiZD9ZSrHBxICj/PA/oQ1I0HN7/A4uDuGwsITX9FLO/41mmv/vePCKLwM3pdwt46J//i//+1vvGsF9Z5tOjNPEboZgUmwSpFIKF70DkGp9Ya+aK8LSZ6NFjXW9PIEqvSrQXW0pcuWfTKKLEav+y4XSccHuRxuubNFf//gmsOnzBo9sF8vjmDUXrH13iyOyN1esGA8JlGWT3mDkNWZP2ILlUg8MzEHYnQ4uqoxtrk7xkROPrGPKXBfl/tqxNyWpupDvdlZFon7tznnIsWIHh9/7eEUmw5K2hAvzMU3NgfV65v++Uf8C5MCBbwlbp5N2HoQxz+E+FvPFrdv0ph024Q0c33D6I1aJzkl0tN9h6NNLPgap943KSjxPIFAVmWMm9bujZXAcZwC3WD6pMCrTumB5kgfjsXP2XYBGu52oZooxZfdV+3E52LN5TCt94tvn598/49/cjyf/Pzx8iX4bByPkz7aHpR4Z8/WTe+D8/ibD8hywNrbuabhQfx40McW7eA0thyEbuKQ4jV8CV8brQFMrtcXfSgWqv+I60VUJeeIqvH1/vKj9lh+BLvfhOeTGJ9c9wU2ue/AoxyUw9c2v9hEYxmvd0fXpODF5+fp9yolEdOkt8tDFlH8JXsWHjZ5350cCocYHIE/f35xqJMPP5+fNHlzNb+q1CaITtZSjiB0q76uWU6rmxw4l9QYszHamzkbDL+X383BYGRf7ZkpYaytkJw8cuTuTkuc/aZEwfq9wejzdxE+h11+aI0pTlqwNbdxTLeYynlPaWd5EfGyt00vABA2h9lbUTF6/1R0W8PvtgFmmV/w9THq1mQ45ucvPZy1+0okLI8zmTgIKhXHk9jqmHlo3QVCiSCTqMk1B+Lj6V+sUFE3P8eUWDZobTh4engHr43pD/hx0Jt7U9a6YSjl+PB7ZvNOXnkcSE6keJBVuV7T5Tt1Og6DSV+TlA9iiY6qkIjJAXPSZ6ONiohDucb0I+fU5LxelHyedJTxfjNm5fE8+PjbJ+f54Of7RW0VZfF8fnDfL4+r9cmX3USBIzp+v43hwLC5qHdFJHJk1zvY8CP42DRxT5cYrV/UcbPuzKiTkT7d1bKM1W/WCNxiFAzJiVZvbHSusYjx9ELvdRFLZC3/M8zWnLtjGZ6ZtUPfvoc2l/w0LxaUGH3dIeZXgyHU3hnj4n7/SQwRxAhncDv2bLSm3LUSZ/cK2jTy46S3xdIMam64Fl+JIZm1NtxLfR6hy4+raPTO7QRWYLTB6A4PB5fazjUJvXqwBSPsI2UJgfu63UY8O2KduzeO5wHmbSczNkfYPyAanfjR+827XYxlaEog/uepfaAjuC5CjO1h2NoO382j/u91g5uHWiaOH73rzdKTIwqzL9ovfcl//2z+/3w5Y6REP3ePPjESrd0e5J7dsREbhT9Gc/MSvo5QmaTEb1FpEA+nx5T9jbOc7Nf6AJTWqnsad0dujuURPvtlXPYzfr1eriTPT0eZzEadRp2NGAvWb/pvE9kkLB9/p5BYRPraNLktwQky6d2P6qZp5yOVHAQ1o74uH6eng+ejeK52NPr9g7CccOfZYeH58eBuF/UarIjnXUNkmFFyZPRB2ykS2TW0FALHWYgRVItDmzfJfA5PZNkQzkM5HycyfOfGWKRH4iMoUyJtKjP4v25LEenkoIScmaJ8XW+OkD3ieDz4+Ci0+gbNjKX0Nph1oL1RzifnI9KvjmrY2oq5BT+KxMRgUAJ0WVAi8z1J0Xk9C+VdKykpIRTqNaijIWH5jjlE+u13sjEa+dinrlIcBtaa53dDIKyAxIPWFn1U5oZ/rTlIEijhIOEVNREPTIw+XSF43wSg1ea/0e5IyxAclXMcyWHbSTY03BEofSwke5pn2eRu1fWKOKKTIISUXTWCKxBTELKat1zmIGffOefjoL1vwIXSLpxycW6t3eFuf+XhDFuL7bUYoTYXt/xCH861CBI2nBkMD0+PtWBVVN1eLBJ+Q6d/laQNd02YgAV/m+i2Ny1xNCLirs05O+/79qPqnNs9EtDltStVc1IAgRl38GFNcvZQA0y3ZK/hx1k8kpViBBOWj0S9KGWT/PGNov6VZnRMImfMPGLm9fOLuvGaC2VM/0KU/OHHaXzQFYJ/gc+SKI+TjDhtITrTdM3OnBUzx70k9apWbw7Msnxypg83ZrXB56OgQMzZCwMpUpISGNwVvj3+zr9+/ElR/46k9B+kVXfapyMWEC3EoyDRER93NUqBlAK1V2brnkhSCDKYNGY37iAkUZ6PwphC/fa5wVzKGobmQDkPrA5MI5oij48P+rgZ1S1fbTTiEYir7y/lXvj3hI2IxYxKAmvkfc1YCJ3s4GsV5i5MTP+cEkIkBHUzwHICfat+dDVzsLluqW15fKLi/Im1BsZETDmK72rX9HWHqqKJ3bmcjNlJKbmzVbcA2TygYeaMoRA8U454umm07iBqDXRz5+gYkzBd49jnliyZMcd/37b+n1cpre8ztO3YnSvPe+/eeIvbVzgXa07W6G6c3rNdW4JGNrZSyNkfuGXTXYhz+uMcPfk/zFyfMCo2B2KTae4o6WMw+6Kk4nnReoFG5lBiMiQcSFSiLGTev8uwc04/SlI9buXvfj+W7X9wISREfCl8lELQ6CjNtXwPuu+/r3fnqguJ3Rfm14tvj9MD0Rpp7ULCwewXiwjZOTbW6i5xZ44SiSEgq3NfL1J03ikh0+/uJ41Y0PLBcSZe7xdB3qxWCflAVXnmk4/vH8xh3K3Sf7wY60KmcC9jjJu5DuxIZBPu683370+6CeWjcLe3U+MIGEYuztNJciJr8EhCwhhrMNakN0G2anDZ5PFRHIvJ8CtEN89ed8iPyOOZGLUzrkXKkxxO1lqsKSwNvo88/OUapDhOMmbEIiFlht1+t+2Nie8RnUm1NlDu37nbHCIlFf99GI4dMa8iBpQcffVxHCe1VUpOviedjaVCKYk1KjEkJEZyWfuUKHvb4BSOmHxA1+aijb7N4E4EEVv7Zb17pSHQ1ySEfTUwlxal1pnKZjXJRmb+xWltH9sUjW42C787kiy3WK1ZCeokOcw/1zbGjmx5xQbYCjonty1zOxPL31QhZQxHMY7pY+ggUK9KeZwsU4/ezYUkmEsd9zAcbWXmCocFyH4AbS1qHaylzKUEOiF4CGLNyUo+Xdy9N5Ysb7MjpKT+n2cL5iAnoa/GWOoFZ3G2jdrAVsM4yOc3Ggt7T+zXn0ETayXurz9o7eZD8ViZ+s0p71Z8uzt6REIupONBMyHmg+cRkTGoa6LT7zoSleNRUFFihD9/DGI6eL2+PAjy/EBmpagwh2NjZE7SI3DdDZIyWmCNxTMHUphkbp7ZkFLolyfALCZydt6uuyqFr3f3kESoiCqv3omr0UbjVf1YTlK0Nn5ef4Is8uM7Ek7S3NPNw+kBZxBaDMw5aVdHxqJeE0ueWb4vfxDFBmNUJ+ib6x5yTph5sZw2IPhKw0Z3j4yYBxtUyKkg2fUXRvSjpNjv9pH60Y0xdlhFnZW/RBH1k95Rjo0s9Wtc2/Y3Pwz6YFPBo6wLRJ3uAULUwFEOFCWH4JmAra9fywHUf+nhtGVcVyNHv2y7Yd2D2N7E8v0kmLs1g0+0+jTGNlGbbLXeLj0TI2Zbh4cfXQJKycVNWyIsUabhCZFh2FIfhtB9Z5SVuMPjuWTn6aiT9lKIUBz7P4d3HIMEdN7ehhmebOkdxDzvudbGQkZHhqzh0bllyxMjwdNKWX1cPvoFc5HTgW0ci9+gDUYjl/O3wv1+N+6rEfJBa8ZaDUmBFBKpfGOOy4kTIZMfB8d5ECdI9ON/TsbswnkWepcNrw58vTwc39bkeJzoTFgVbE+mvz8KEj3iJnOxxPuQMQRKLKRoPIrTAWk3j1RYJrz6oM9BPIrjT9cbmZ6bhsjdG1yd5yOwaqO2m5/vF1oejFW5X05HbLNyxsBclaAOeBvjRpc6ZT67gbrd1fPb1riuyXUL0zqyIGtA+oU0d4wQlBiFIwU0FHqt9Ovys5AqY5vHJLrqPqhydSMfkVVvggp384RWCBHR5DzgEN3ANu7f/7cSt7ZBxP0ssq9tqyPiIOkQkkPQVRizs3+IaPTpuS33vjjtD5TBaD4jGdMox3Pb5f7Cw7mmj7JziJuAN35r4jS4nGiYT6hMBJa/EaZ56doQvz9J8uPh7DCak98lMEfH8BTMcSQ/1q6JxszX9kF6oN438Wu6/yKlyOgB1iBFHwJg2/3ptGk3SSf/yqyx3InCdL9lPHz1E9w/0lolCIzl8a16GyqLUg5XCGLE7LW2KMofPydHUta8OeMnj5z4489/kXDleowFseUaCQZBIiVmcjmASYgHfaq36Gsn4+p2Y9J75b4bAxxVYi6rlRBZ7WKMxH/98QY9+Ht4ks+ERqV8fgI3FiA8DoIY378/+F9/dDQFZrtQgxQEORK5KMzBeF/YaERtdCnUsQhJiSUwa2et6VPuNcjSeI03WSNZlclkqQum/vGfT2qblGA8Pr8RYyGaoz0+vhXmEOxPj/VFVepozPvi9XKi4ByT1qFLdIKBLlYOHDGSnpm+/EVjaxDEVxNqgiwPFEwDNKCrI6v7XGMpg0WWrZE0b5UE1f3bVhzdJa6ZXzuDrdEfXly0NW0/lMGTXypbHrxgqaGIPxPqv/sYI2bqQy1RfIbsAYfR3UCwxmTOSf8fHID/Pw/nJAWH8wbzSVXIyXebGolB3G2/8YJr9j2xdTiQedkbhzQHCG6gFlw6M0PAzEPwwC7yer40p+RHBwOL0V2T9u9mekh+3r/viyMX/4CPDWTeQ5pYnLY+e8VmdbTKElIsjrBUGMMhSxNDJ0RJ3PVNOgolq1eFNJNy5D0ro3uj4f3+IuuF1si7G60ONAU+P//B7MlB0MVBw49H3MOpwJwV/RUPW86RNQl0E2R0en3z86tCefL4/KAQWGGixycRbxmMXpkpcI2GHJk/vy7uHzdyf3GWB+148G4X5W3YavRxI2Pwx3vwz//9n9TeGOFBHka7Lur1ckfM8SSG7CHyMdzrIZGUD+p1c1D5pBJEidO1eFb8i7t23PLbt298PL9R85PVbixGzo/CHEpvT3+PLuPr62LUm+t9sVRY04+Xtir1ftMY6HFSzk9KyZS0DdHXmzUWIRfK4+G6vclGWNYts52oOIrlWQTBj7LDxKf206j3y7U5AKbEGJE59wApsMyPsO42cfq/mp/+1lqOb9knP0SJ0ae7KkJSH1CtMfw/U7yNsubmOaxJDJHVnGj4lx7OvN/YtoywunNihwd+Bba5K/gEbLOF1MZeqxq6cSXst0nYpVcR92Esc9PxNKcMJCcxoWruUOm67dbu4gjo7wxjicH5tjiOaXV/q6oWQswcBUo5nVTeb9borCneKJDNeu2LJYGlGVkDWYvVK8okqzCbYUvIT/egzD4Zzd2Opp4OuVpnrMD3ZyHlg5we/heahHY10ll4Pj95PDPrfvOqF/f9Jxg8Ph6kz+97Mb2Y/aZVQ+ODj8c3Ts201+XwraSEb0/a6+bv//mNtiKpKP/3//NfXP2L+8+Lvz+FYfDHj075/gnvN+fjyfizESWSotJq5+fXD3KbSEk+6MhPypEJEtHuEOoliyURJDPHgtaR3rzQIInRPY10oXw+nv5FCh6Mt774OD94mzN/WnUSghwf/PFffxKkM6trGiATot/TRmusfsN0BaINoXfHyJxHIJYTltCkI6lgKr5jtOW6eYmM7nHRWDIlBGJyQoGKMBYuMY4OnrNxe0ImFMBlwBoMk33Smh4qcK2lEswDKWPzLE03R0uFHPPeU3vIRq07qrQ1z6WvXfgo2Wcl6vytv1wZK9Hb+gKOcJiD1l2fp8v8DZC9jbLwL6WyYVx76Y6trZZbGJ7ekej/hdZ0MJjicb6cI1d3/YFzSdXvPb27iRpFdBGT16U0JER8EgZ4Y2ZUyvlgTG+2MAdjDO7m/0BS8HDyGgt+DauYBPMok0kk5Ei9GqqGojw/vct4poNrvMhHBP1kzU5t8FEObDb6fCBjMJeHCNgZTmMhc1JUqebB6BIzicSZTuLx8BL4y1GjQQMf5eCjnPzr/eWIjuBhCFHhH3//T2zC6+sH888fnE/j+FAe58F5PukVYjTe9Yv8+cHzP/4GFbQYrU96NV/BrMUjZz6//53/j7M3abLrytLs1mlv9zp3B0CQDAYZkZlR2SirpJnSaqwfLdNMA01kmihVJUtFWkbDDoTDm9fde0+vwX4M06RSZhzCCBpgjnffPWfv71vLew8h46rMFtaaWUNEGUHMON8RQyLkZ7QuxFSYtju81mg74VXP0gql9WTjsRic7bg8PZL6kVo0p9czLx+fGIdeSu5FAeJoqU2uTFY3Nn2PMgPkRMmBVgSsZuhQ2lEVxARaVTS3qecthJ5DuJnlNP3Uy9ok3z4ft4SOcY6pk9WaagrrncDm2u2NqBoFaLe4Ya4CKa9arnQlyxeA8R7jRIgsd32Z1uaabvdUJVe72si5yhAUcxtaajovJZJf9HBqpXHeU0oiIVM0kIfB1NvOsjaxLuWMshJKz0Ho4sZ7dIlywVZOcrVNUA9VO5wfQEecdfSdo1JYk+gFXTW3Bbpj7CUiFWOg9+OtsnPFmR1VK0LMaK3xTgDTtSJvuZrIYbnZtRumt8SYqWSsdvSd4DV9yZRSULpHuwlrK7Ei8CZVhLaQxceobaPznlojrXekuHJ3t+d0mQmpstYreW2UkPGq8WY7MDiHKpn5cqTWTN9ZdtuRfhqpKEosaCzTuGOjE6UqXCvosjJNPXZzzzgY1hBYi8K7Ad81rsdX7nylH3vOsbLZ3DNsJiY01+ORvvfkCtM4UR3sfI9YZG753dvAyxlPjhAvWb5olNAtvNbosRe1I6K7GFtlvRSu60pzsNmPaBextmfylXEccMYwz4n9Zku4fiTEK0+Pzzw9vfD6+gljHcN2BzQ2/ZZqLSVGSin4fsQaqYzFECUaWiFcI6UYShUKgTFGpFUlk8IslnMFXdeTU8R17ibudZSAaChrvQG+PcponJZZiVaa0mYZztyqXCglYQGBJiJ5AAAgAElEQVRrBRqXCyHK3thq9Rf9X8uRUhVGe9kgSPWJXAulKXLTqJbx3qFavr1CKilHvOsl1vdLHs6UK2WJQJE6kxFdmnX2Nr296bmV/JGqyQ9OSsxS0UHLt0qWPb9kCqPg/ftxoOGFfEDjfL6InDXLD9m5jpwKxhtyWHBOgvP1psQzXuJexRlqRvqXtXA8HllvjXhyRtWGdh3O+VubRqJ+2nZ4XQi1kYrFdQNTZ+Wg7B1WGUq6SjY4RqxK3B022M7z8njBq4HdYcfSLMn01LKiUqQ0RVWWkFdZL938m/3QS4k3V9zgsKNnXhqKgus0GifRBmUxLdEZhfJb3LhlHJws2OdMvK5MG4+p8O79F3S9ZywLxh+Ya6P3nqQWtod7iTeqgt/00KxE9UrjeJUon3MGbzRLCJSaiNVi8Yy+w46SaXbOwMbTcpFC9XJEVc3lNKOdRPtQlnW+sB0KNnfUotDF0W3f8fz4Z67ns8CySiW1hXTJeO1QIUHxhJhYM0z2wOAGnAbvNSUl1iVQVGPE4Hwv2MrWqClBC7Sy4g0o16GaJQShFzYa3lhSTlzjIpP9nDDOYnBy5G+3K5E2qNJoJWO6DtestF6s5G2VkrmEMgq0gAZkgt1kZ5qRrm3TOC+rmZ/DEspout5TspHPdE7ky4VlkSrhL3o4YwjUttDQWC9U7KqFwdlKuRmeZHTcqhZhrjZoCyms1JtEtCkR54g1ucmesTYWFfDeU1CslzNrSDcWUSW3giqFsl4pevrLBHheFlCNwVrWEPFWFID2dmmPSfAjKUn6ouXENExYL4MLAIzQycMcoBU2U4/uPDUG1nmlGYn5+d7j+g1T51jmJNUgYzjOiVg7dtMB2wrXuIre8CYZKinTGYO2nuvpiDlotr2j6yb8MJLRVF1ZS2XOC5037KZRQNxZCzkwN1pRHA53EhejMnUjVSvGvqMzkc2+x5kt63pl8HC+PGPdlobHDD1raMRQUJuOw9AxnxMoEfDk9UIujr46WnolrgvL+QS7A5thL6RzJfto1RqtVEpLkpqqhXC5kFQR7GRrLM4KLnLOnMKZcRhJemU+Bl4+JYzJvH/zjnkcWEomp+UWEFmYBlmlhRJYY0GZBs2h8iotH9VkxVYKKi743oNWou+r4j4xt/SZUo5Se2qTnuWaMpmM0hbfjRSz0poMZ1KQ65NCjN4asMMg16YMqSSJZ9LQRksBoIpwWRl16yrnGyJT6CClKlRMYkEwRuKtVZjOtUCz8vmfxoklRIkW/pKHs+u6m2i2wg1kZL0TQK5q1Nu6RJT0DaWKvOpbo7VKLuUvcbUbKop0AxordSuqao2tmvNFBjreG3rn5H67VJxRQm+b5/+PZqFJm1/Lldog/3jXy0ItQXRwGQxZQvpZitZ95ylVkWNB6Yh2jtKkaiZhVriGih/k7lwbDMozLxU3TqgcmJfAeYa0RGLMaD9Q23qrQmmyVmwHS69gSQIj1r0htoq1ltAKpuuEApETSiV65/DGCUhNa7JqpAYvz1dsd2azH1Ctx2mFbY2iFddFEeeKGxOegrWeWF6wW4Pd9GgqviiaM4xOYdOFaewJWQoBLTeBHHvP5XIlhyjDlKbIJdKyIq+Vuia6ocN1npAkWdV8xxITSmesq5KmKgZqJM2yv76czrj5Qjyd0FVjVU9eEuuqmNcVa+SL3Pc9/bClasPQNEU1IRz8HAKp0h6qylJyRuUMRHlQVCG0TLpJbHturCTn/xKDDKHgvKfzEjPtnJFCw7xwPc24oaeqRqmiqu9tB02RSiTVhraWWqP0iJ2hJoPV7faiuamglagH5fdYDJnOGWKp6LgSYmUuy61HeqtPqiYnlmX5ZQ+nNQp7g+eiFXYcqPqWBZS8AK0W1iYNlXTDadSmUVV2QqXKh1AeY4WyhmqMxJ+srE2UUhhtyTc+aUFLXrZUQs6gbvWcJgmOzmhaWInZUFW5qcWhpoz1Hl0Sg5VYYW5F1Ash4Z3ciZ3tmENmOb/IflVZYQaXTGcsY9eTahZZEwiwrG1YKsyXFes7djvN+bQyu8gyX8mtY9v3xHBGDSNrbGAqzTa8KZgma5vOO3lrxcpSZBfbmuJ6utC0BkQK64aBZnouT0cR/24M1iveDD1LKcwp0llI108MWjNsBtRm4Fg1OmWmmjFmy9IUo9UMBrKqrGllff0IasDaRFENN/Rs93takbVVrBWVZaFuOwVWk40mO49/2LDtPV+HLAhUJTvlmBr3b9/eFI6Fj5+e2W3kmrAgp5jjy5kEXC6Jw75nnLZM/SikBNtuMwMJn9citIySRKDVdeLV6fxArZGUA27wGOMJC1wXwYC6VvAOUonkZqhK+sMxzjgnM4xlXumco+lKKYmiFak0UtWoVKha0xSEMN+6tgWnxVtDkoktSt2+9C1dP1Bvb1elqsQNi0iwdCs4C3FZpWJnhAxpteE6X+l8/8sezkoV+h0VZT3qFrfKSZTtlEIslTUtcr+sQntHydrDKEPMjbAGGuD7Dl2bkLetQzkj+6vcboVeOdaUHECBd/LtpLWRcnEW10U1SKVoWSXb2xqahNeadY04I9Pi3ES5h1I4Z0nLlbUprF3xfsRtBnJNGA2+15Sk6Z3BdYa0Fk7LTGkj02bD5bJQabQGnTe0CteqGGum1Mg4DrRSud8dqJ2nnzqcKdiysM6vaNXTdZY2n1DKEZbEph9JrQlEbRSXaVwC6qaVM4ODODAXuD49c3jYsdlsyccLrp3AFM7NSXUqF8btjrjA8nTGD5prnLFtZXv3nu104BoDg2kc+olhHHg+PXO+fOJh98A0jGQU1Tlyydhb5jOFVcrDGppyJOPBZqat5/H7K941+u7AdLclNUcu0hxJyfB6LGz6nvPpQrKGy7zi+p5SFKZ/YL/v8SjsOGKsZV4EiEaKeOOIWpO1JccKqYKW+zxNInpNRUKqlGZw45aEGKfnWHB2Q9cypkIsMvwKIQhYvMqgxhipdIEG7bndKsk/X8GUFnrBz+uULL9DbNZVZhaDpJ9oBe8kcJCVQNIlH6PJN3ZSyhWCgONiCWgjavpf9HAWRLtQEF+mUb14M+G2n9Sy/1ECNqqqkktCaycQ3iL5QaVE+5daw5RMaxqFFkjSDU7dOc2cM+u8UGJh6GANlX7cU4uSKJ4x8latSiS6OZGDTOC0NnRao50hVlnq5wIVg6aSYqFzHZ0Fd6McZAo1rlxPM9thw8OuZ3O/pWTFaZ1pJXIqWbK/De7f3nMJV2IsPP74iLEOho7NODANjp/+/MjmN78hr1dSrzjc7RjoOR0vPM+KLlZGK/evViqDMfRaoc0gGeK00hvNuN2yLgmlAtY5fGcIrxfiJfB4/k6Oduonun5Hs3e83Xacn5/I1XE/djy3K8N+SwuN+HLm9OkZ8kAIM70f8M7Qj57d2JOXhU1XsUoclmvOTMOWqW+ivdeKec63u2lgCRnVHNVs8UOhqkD2Bn8/Uc8V3xohVDbjhoLhnDJmmljiyjDuGKeJ+91AbzVlSVSvhUyvNTlm5iXhlWYaHS5nVPZcEZ5w6xCZ1I2SvoRI+XkOMm3E3+k8tkEOM6oEKVjHIuk1FKREN3ZSrnCe1gpWScjfVFiuCxsnxPZ+muQIW4rwgVSDpFAIAd/5Dme1bCaMvRnM5MirrEbVTG0K32+xPqH0QogLORgGLwSF9ktXKa0Io7YgWcD59MrQjfhe2hG5FEKM5KwxVqBeYORbtglbSMLAgsHXWDEyFSEnWF0l7J41BoWuBZ0CqiRy0Nixp2Hph5GUKzktLMtC1vLmillwHfa26B42giUc7UTVhstacFV2Zy1GYs6sMZIoGH9zYKSKUzB4ebCvlzPWH3C+RzcZsy+XwLxGsi+4cc/L6zMlNbxJbIcewkwo0gf8+MO3TKqwDhsUBtMK+7sD91NDpcr5ckKbxP1+pBsmEUXZAe88aXnC9QKp6jrL0FnWq/RX9292jNsDP/3wR7yrlO4tXbfH6YHBRtT9O55fV7bv3sK6RWtw3nDVN7GT20JI7DYHWtbYcYv3GyiBVAxPL1dp+uBZgflSsE5JWBxLjOJajetKSxVtemx/QA3gdGE5XokZKBKjtL3h8vhKVoVLSGAN+87w6999TY4L6+sTa474fiBnkQnTYDAdKReuc6LmmRAiaIv1Mk0X2VBijTNYjbUda6jE88zYWVKp9E5aKBRPileK0hg3oFqhmZ6SEFFUWom1SG63VYw3GKXkePpztazVmxSqkmPCGY3vB8nddp4qQk5qTFIFUxVtKoPrSbHdQHdwTaKrj6niOwt+oAI5h1/2cBpnUBWxXYXEOO3w3YS73UMVwkEpab1JWDVKW0KWnGLKDarAi9XN/gRWVORhpqkmF/vWoGZUSQydozloxtOMwWhpImgr6I+8rmgMxo3sRrFmaaNvMb2bVUppoZ6pirIdnbWEqiA3nO1QZHI4E0IjrIlhdOjRsoYLRVk6dWW6P/B8PGHNgC6FmgIvLxHOr1hr2b79jBwv9Ls9H759ooRXpn6H63qq1lRn+cMPj0w3t8m7NwOdN6S2IdSGchuG/Wey0F9m2nqWutzlzHC4oxtHjFb0Q8HYgXA5kZdXnDXs3r9nLprrXPhsGpn2e2xI4Eemwx61dKRU6EeF8o2yHOkPB7CaUKHf7tg9vKWUzMvzM2tJLLqntMrGKWINnGc5Ck6bgYfD7pZgGphPV1pnmbxjcZnrObKsFa5HdmPHaV5QuuP58YXz8RGjYZ5PbLYHYgk8//QdFc1yujDsDhQzoFTFGXD9SGUllcwpC8U/pUbThn4z4XuPrjCHRGmVUjSv5xO1CORcHQ4ctj0tz4QskcC4Qj+MxLzi/E4KG9pRjSOH+Wa7NlQN3sobrTUhfFiqcJmTmO1UrbeToMRC87KgrVQPa4xoKs5JMyqukRDkTj6HSGuaoZ8wXS84nto4XS5shl+4SgmxCi3M9HR9L80PZE9prWeNP8OMxFtSU5JvOKUIqRAXac8774SHqh3OOVKKVKQHV1OmFcF6OFUxY0/OhqbED9daIaYjzvc0XRk72aeWEtjfP1BrIKRKjhXfjyIzrfIt3BlPbYrleMR3Dj92LMvC+XihpYVp3NLfDWzuDozjxPmUuK4rcy4MdPR+B6Wwtorpe8igWdFGNHrKKC6vL2CaFHXHiWNujHqgXhf0vNDv71AtcjwlumFDNBrvQXeGa4n0JWDrzPV0omkrR+HOoJXm09PCZuvY3e8ZdxO5Je6GjaA1fcedDVibaXiadvQ7w7xE1gy7aSSUhM0JH1eW8xPd0JOjQpuerDqWpvHbLX0NdG1lTurW1820VBgGz+gVJp+wteH8xO7LtyxN8CxRG1zMTHcbXh8rT6ny9PSBUWmMLTSfePf519zNO+ZWWdcL1cF+c89uf8D2Hbv9FnRmfnkhxpm5XsFV1msiZEvD0hlFWVcuy0xrSF9WN5T1kDUqBfa7LYO16FaIeUV3XnqWJhFuNrHtbiJcLmhdUFHA0t7IztR3nUyiERQmtxSZQwIPOUW8bjSvaUUA0qVWDBmasIaMEy9qU5pUICRwupLXANZTnEapJg6VnFBKyQP8Sx7OmFaMmW4RqYTT/V/emCktcrSNiRRWQog4a1FOQEZog9Y33qyVo0JthRwaJa3om4beaHDdAK0RS8P4nmk3EFNC1UoMC53piPMFzy1y1wrDOJLTTAiJQncDGCvpWQLrmtDdIM6KIt921hm2WmFVYVktyvdsD3eMvWNJgWg6cu8kvF41JUr/MIfE0yXinWPsezaDJiRQKvL4+OcbcX5LzZUvP3vHt398ZDme8dowuI7vTpE3m4GeeJtQJ/phh6uPkBaM8kyjo7Ueazd42/H8cuFlXsjdluXTJx4OO/phh9935Jh4+fgTaz7S7T8jRg8IY7i1RLssMMlbZz/ccT0LlaJqQ3IDx0vhja+Eohi6gdFY+qpQS+RlycQ1MXjLYA3X4xXjG6PTHJ9fmPbviDlJMMF2PHx1QDeH1gM1LFwvIyotpARZd6QMo59I60yrDqc6Yi6M+y2NRNWrwN66yutlZSmV2gr91BNLJaVAWSNVa4ZRdAg4i26Jmq5sxxHv3tBPo6AmtZX1R5xpWTh7Rstn6/Xxkd5bioLeWxwRtKNDY53Dup+VFLKbFzJGRLVCrVGg2Lf0VM4V552UtGsV7q7mhqUpdM5Alayx7zxNi237ZwK8Up5Sr/w7TOn/vzsnaJNBafp+wlh3E1cXSm7UEnCqgHOSlWyVogT3oVth7DuUlq6dpHUSxnmMUUS4rUCEVGCVIzWFM1LbmaaJGqNgLtZECeKvGDon9x0Hp6s0FJR30iqoDeMmSgLnAsfnF9aY8f2ArRHbekqqtOaZhh7dj8RkiSljrRiNFXA+nnhzf6B4z+US2G46dGd5eHsglwhonp+fiLNi3OzpO8/rh1fia+aHOTCfC8dw4cvf/I5sFO/vBh4Oe4ruyPMLu77n9acnzq8/8Kv3D6Tbz3s/NZRr/PmnT5yPK+H0I/f3/8Dh8DklRWI5kdsebxK7jePldcvm7p6cG9erHL+sM7x9uKNoxXJ8QXnH6/kiyEcy8zxzWTeEuvCrN+IduQaFaYrtwWFGzyZLxSvWwiUU4uVKUgl9PXNZFddmeboGQip8/dWXNK0Y+54YX/hiN9HWwusayAyYvrEGGAbPeZ25s1tKXFlOL0x3d/TDiFOFsno650UopDXoxqBguUJB0zuPcgOtZlpN5BQw1mK0otaZvGSxhNGIVSpRTSVayeRlxY8HlIFu9ORYKTnSdx7bDaS4oprwnsL1gnOS7qmIXj6WQkjgTSfakN5AlnlJbJm+7+QBbGIeqzkyrwtxXSX4Ypx8TlsBJIxAA28HljT/socTbZm2IznddpRUvPcsS4S6YOF2JPCon5EjRtwWOWZ5KxoLRvyHpRYJhDd5EKyVwZBp/na2v3lYcgYEF+GMIaZESolh8Fjt0dZwPL0Qrxec7+TbFE/fDazzijKaqhpu+JmXWiSxoT3NSOVHdwNd17POV0rTzEXj+xGDwvQDuUgYW5tCiIpx2xFCFfCYM7wbt5xSYTN9STUZvc94Dnz7xydGb/jbf/iPNAKTy5j1Edc2HO7f0fY7bHyGcKZcO3I1XK9HtBsZNwVjKkFVrusjuMy48wy9Ev1FKZi0Es5P9P2O9199KRBoFTkcNmIaizNrWMl55O7uLcvzwsvzyv3uwN2wYUfkw+XIYbNlMJaY4HRZ6WvChTM6JKbunrbZEe32Nj8YyS3T7d8xtoK/FDyep9NMWgLPlyOf7z3DeKDuDYvu8fbEmE+YXOgf9tRY+eZ+y2YaUXrgdHyhtYBW27/QFodNY60zTRdyXjHWMHVOdBYYShG4l7UjndGUGrnMZ5R2KB2YDpIaay1jlWZZBbMzjiPOSUg+hgvOOPpplBNhSxKAcJ4lLTinqG3FAsY6liiRxaYklkq7BRBunCptDKUkVBLaZCqJEFeulxNKWWpprPOK60ZB6Wih/5UYKMri9PTLHs6+H0lVS3pfadQtylRukL2qKjlVakhg5UKtVJNzdM2UYlAq0ZlGyelWWpX7WWkKpzzkBauatFM0QqYJidH05BjJOcnuKM3UKh9UUwVtqPpBIFApMXrH6Xqlc4YcChEJOm83G5zWODdSWkO7nt3djmXNfHq63uKJWSKEsaPfPzAME9ZrLudHnj8+Me4PuKS5e7eD5nk+X1jPM+n8icVtWVPh4ctv+Lc/vVCmiYc3A/PLM7o39MMDw/aOZYmY4yO2zCirmbotOXzPf/mvP/L5uy/4ct8xXxWZhsqa/fSW0mu6fotaZ9L1iX7cosrKMExMuwdOcyaois4yFWxFk6Nis7vj6bkwDRo1VO71QK8N6XKBssGGmXw583iZOa2Gsgbe33dEBq7PJ4buVVYGh4H9cMCYxuv1xMfHF1wKuBQZH/bY45WXpyO1Gn44NabNPZfFcnpZUaPnOi/0nYd4wncPbN7s2E8DrdfgKqpmwvkZlSc0opN3N/lPWAI1gVeKbugx3URFEWJijpHUOkxnGfqeUjO2m4itYZG1R209nQsobSkhsp5OqNrYvXsgZ0UKGWMM2ne0HFhaolXRTKibqycrKWujBZsp2EvpEVPAdiIUXlOl5SyY2LTQhMRNqjIE7ZUY2amVliKtRIy+iZ7Nf/sR/PePtamS20LJlVQD+lb1MkqLHLRWnK6s8VZCrvLGa6XibIMmKZsUMzEG+QvnIlUsI/1IUzPd0LGsFQf0zqNrpkaxBKsm+6PN/g0xF0rN1JTpncHYLSEK9jDOgVoKMWvpd6KkxBwS2vdUU9HWEecrcT3Jf0uLvOnNwOTBioaYPM9oLNYObB/eEy9PdJOmLZ9QZuTeKH7/6Q9s374DY+lMxSrNYfTse+ESheVIZ+9p1ZHsBtTK8fyMV6/cbXZcc+Xtbz7Hvv0MXs88fvjEZ7/6ks1oefrjBx5Xz1//wzdsNjva6Znr0yf6fosboNVetOrXmeWy0vdbQjeQy0oj0sYeh2Y9Vo4fzpxfLDudsV2P3nu6/T2PP5346bvIaBW9WWndO0LdESzUdaHGMy4P5MXwdIoU33g+QZdhO2r0EtBVkebI3Re/uZ1OBoK+0ueJ0Crb918xbXeYTqPdls12pLbKGhtaDah6xbZMDSfycmY9zqRQkXJhIeeGHzc4pYjrK81I8aGfOkJEonDO4pWlaEWJ6fbZssQ5YJSnFfHATps9OWXSGjHOEubIuN3ScsCZeoMGIENKHCHLSZAqb2xtDaoWYo7yElHyBk1ZOFVa39JqCozx9L0VPI2xdNZynSuhFLqux9LLdS1FMRD8koez5kTMsh5BSZzKmQ7toMaAxhJSJYZEqVm4o1qjncXe/v+cfxa9VJSt+N7cvCqRGFaGYaBgUaZhWialIvjHKCkhrY2Aq3SjRmmtdF0HZkAQ+D1L0jROVGMJUVPKTNf7v6x1bFeYa8DdOnlZIyxSO0hfr8HL8Ygxjs1+YrAXbOoZhx1lPrHtOxm7B8NSAx8+nbCbPS1nQvOYfsO6wsY2fvjxRNv2/ON/9w1jt2dSjcvjd6Bmcn9AP/wKux14ffnAu+0bOmcom8+odSVbQzCGr//6t7y5rmxGxfPTv2CeLmz2O8pasbs9sSYuLysxFDZ397RzxvlGjJHN23tMhc1Gsz4ndoeJb89g3h24/+ILXi6B0BasUvzH331BWk4sH8/snCOWgeAdl2WmmyzxWqnGcEyBGDQ/PC4cX1948Ct/+1e/xjAxWkN4ntkdtqzxypQupDRTW8fbN+/ZDo6CoTZDzp7X548EVvZTT1sSuQZs61BqwJYTpma0g2m/Y7mcCNcTRRmcQ3LKysgapVURR9WKrqCNgKlDrbQlYpt4Xs24IYWIbg1rMyULlqVouIQT22kHyhGWE4NxpKSFlleEZyzmcwmw15TQtrsR8DMxXNG6oo3DWifljCr0yZqiKABroVZFI0NcKQx4L5LnpWRa+cXT2iivXdXE/2E167qgs6JXwjvNLdL3Yoxe1ojx8mDSBCsiyEJZ3HrvQEmVx6BZCoQQiFGsw86KJm+dZ4wTPIYq5QZWKky97EB9N9yOEgu1ypDK2Y4ezTlmuu0dykqKaNQNXVa5X9RMikLrVuqWFx4GWJ6ZeqGcpLSSU6J6B5dMqwHnLA+bjlQVH15mHl8v7Hc912PCDJm98xhj+Nd//cASYBomnB7Zb3rW1x/Rk0a7gden7+g7S7t/y9t3dxwvgePxwvvJ8ub9O35YMt99+I63neF3X31N11meXyLFwbAd8W7i8enK4f1bUl5YssKuBZ8y4ZS5e7tBeSkTm1pRO0U3Jf7xP/8WXTxhaTz/9IpPlfyyoOoTxlq6+zfo3YH2FDlsRnTSnOeI3WqUha4FrseAmi/cD57PDx2fbXtWLHWdUflEPgfu7u/IqaO/8wTj2e4GSnG0rLgugfP8wvX4RAhXund3GJOEWRQjcb4SGhQLQ+9xqpBUJdQMXsL0LYn1zRApusnpDUMuWhwvNQoto1ahEnjNGq6YpjDaUenEmt4qfjAy0a2FUhVeW8HT+BFoOCcBeoxBVUUI682L4jBW05roBlO6WdSVxlSDafrG5tC4G+qlYlHmRlmocmxXJZHWhaJ/6ZvTeYgR23mqUtQcSLkw2k6ASFmsY61lLA0/9uQqPsWKIqYkGEwrNL31Vq9xRoK/BmmKKy2Q5oTCaRneOOUo6QZCUg3jDZvdltqElN2pRAmOZT5jbEeMmm6z4eAHlGnMBYzSxCC9zn50WG/wrhGSovM93mmIr3QmU5wlm55cpSUTlgtRZbZ+4scPz1wuE801Xj5e0M2DV2zf3DFMPS8fTnz64Q98+vaPvP36b+i7ntNx4fL6zPzd7zmGhTffbClxRvlGOJ15LStleM/wdkdm5YfrmUZhHDL3+w2jF6vbmzdf0dRIyZpiLPdfdqxzIw077ncHfCswFUpaMPuREiEsK1k3crSUoGkpY9yW64+v+E8ndm9G9l8cuLxeiFXu4k0buvuRkcZ43+GeF56enmDJ3HWK7aaxXStrrnzm7xiVp+s0yRo+/vTEcHhg7FZ2b+4ooWAUYnWzhlMK2NJQvmHcyDnMvH78QGyNWRmcUuQgBIx0faLuevphhAyOxrrMaCOVL62liuedkPNbyRjXMP1ArYZlvmC9TFjnVch6rSYyYgxQ1mGVwMR8t6UZh6FihxGFuVW/1K39pIhpJbdbsaIkqm5/KU9UOnKNAh5D7O1WWaEyrCsxV+l0qiy9ZiCGq6A4iyLmSje4X/ZwpjUxTSMGjbKWnBpTLzsmrR0pRrS2aNPfonoVUpC0zg2QpK1BI2ryetsZFGUpSB+03oLMRSnyEijaoNUAIaE7R4gr/bRDG7mk664nX+UbMmRozmHRMhJfIrt9TyRDEIOz9Q7ba/zoMYiqvswLoWRWGpSVvrd02wnvNH2uhHTlfLnQ9ZEYL6QMJItqBqEs8WUAACAASURBVN83ljiJMi9diY9X1mvgvJx499XnlDXw8U+PvNncM+or3/3r/4muit79mtPpmbQ25jDylFe+/O3MP/7V71B2oq4/EvMru8N7xnGgknC2I6wz3XbE+45WLdY4ji8faN0BXwv+MKJ6jXcblO1oqwQ8tJFU1sufV1S2hA8Xcsr050L3Zifmt3c72lHo7vNpZn83ME6W0ylBTQwW4hL48Q8fWK9XepWx80IZt9Bgd9gS5iupTrI/bJ75GOlMxjlAKZbYJDZXI6MbMA8btIu8BoMxsCmO+XxhXTOX4ycMCec9zshknJLoKZwvieu14PrEZr8B5zmdV5wp9ONICuFGudMUjPBxXYM4C8S8OYapJwSZ/JuhxzgpyBvbE5PwsJoWsVQoIn+uyI6cmlnDim4Wo6rQ94xBaaH7t9pIpVFuc5eQZHCqGlgvwDCFkCKWOVERsVX4b/O9/v2Hc78dKDVjbE/F4py0wnNRf8ExaA0ZQ8lVFrWlUmumNlBGFN3Oe2iVqiqlNnIu3BiamFGgvLUIwqEqi9YZrT2UzLg9EHORvmEpDM1CLgy9o3jPOkt9SMfINA10HayXglEN5yrWNrTTGAo1BkpKlBYJMWOVYhp6pt0B13tSabheU+rEMCVsDMQlMtqBH376nmYsu4dvWMpKiYXnj5FNtyWlE29//Q1b1Xg9w95Ylg+/x7gX/vqzd5wWxfXTM2tWPH04cVqe0LsD6+Uj/8+PlV//9j8RVs31+Im2HOnvf8PbX3/J2I/iHK2ZwVWWkPh0Cjw+XXnbGc7nj1i+QGnH3ZvdzbAm9HqlHPm64LqBVVeGbWQz3FH7Dnc3kk4ro9UcvvCEc6CfHJ03LKFxfon8+G+vfP/tt/h4pnEmZ00w5taQOXFcZv7m73+FPrylhDPH1Bh0Znvn0d1AWq7oVrAtMVcYrKG2KKJaC8unI7F1+O1IWuRo6J3DFIhz5vHyJOiaBp01eOfJuZBzIC3i91RGgcrkOGP73Y2qqMk1o7NwhGMp9OMGrcTu5ZxmSYoSAvoGxHYm0HWOditUaCVunHrjZ3VGGLaqOPn8VrG+q5IxtxVjM1oeQAUxJDkTNgU3+ZRRjaIdtTWcV1QV5bpnfuGxdgk3r0UV+BKqoJTGa0eumYrDdh0tBPSNIBeLGIqVkolWySvWSj42N6TVr72IS5tGl4obJqwyXM5yhJjGDofBollqxWhI68IaGzVE8basGWscm8Mb1vlIrw3jOHB8PRJTRamK7jS6c3SdE15Mk7RP15mbF8PTbya0N8Qwk64zSTuK6+nHidoPdDpyPb3iR8fD+98w3H1G++kH5udHXq+JuV/ItfLXX/Z8+vN3ECu7yRGfZv7rhw/YvvHum79CqQc2+kqoC84MfP3NF8zeU3Xgu49/5E9/uvI3n/+ad297DsOEsY1SA9fnn9i//RtcN/Htj08s5cj9XUcJK9NBo0phfr3w5t2O5acF5QQiVVLjp3/+E5vxjmsDrwvaNdzXe9Sg2T54as7kFdzDBrMxpJh5+bSwPM9sWdl0knFVSeOnkf4wUD8eOfxqYFk1V23QRTE5A77j8M6KWTtFjJV7m0oD3b5x/PSBa6w8LwvlfObTj48cPvsVGwfdpuP56cRhs6GmKzllalXkpHDDRDaVpsVI3nmHd5pcFrGpO4MfPM6K80am8En2oRo6P6Byw3WGrhtZ60rfCd2hpiwx0lpoQRydHVIVqyqBFuZxListR3pvUfpmZs9VqJJKCAqxSN1M1YK6mds00EpF0wghEdYkp8RSMd0gmkzzCytj3jnRrimLagmrBexrdMU0AfHGGIkxAvVGNrO3XpygA8V1iIzxvWJZV3mraovXDWMVqkJFcBOaRqcVzjpyDBijCHlG2UpJlTme0NXhrUZr6AyY0WBKRucrWktBfPAamjhWkrZUY2nVUJ106eygGb2/gcUSrQQ2255zaMzrC24YKDFhnaH4Hu1GSn/gp9MZ7RT96BlywHeNtUIXr/zu1w/8+N2J89MPnK+N/PArMoXnPz/zm1/vmQ4DL91v+S9/PPJ+esvbrzYofeX3/8f/yre//57PzN/z3fgf2O+/5DQfGfo9/f5z1mxZXwv3+y3nS8Ul+PGf/ze6v3pDchvG+5GQAng4Pc6MdyNl0SxlhGPg9//XE799r+m+SrDZ4zYe00FzleOPZ9owYFTH6acLP377SF1mtt1KzReOc2ReK3euovsdd3//OZ+/cVyXC599/QbjN4SPJ66Pr7z+9AmcYQlXDg/iQS01Qraky5XrfEUNO5bi2UwTan0lvBZUiGwR3V8xjpYjyovNLJWAsV7qeRTpnOaKVhmvLa6fbrgcR1wiLUXUzX+ZqkYZy7SdCDGhy0JKibiKk7SfRuS9Jb+Wo6eoL512tCKI1KatlLa1QlEw1hAqUKFUwdPYW7RTVXA3fImqBe89IWYaipIDTuub4kTSce2XQqVzrTinIYtez2goCtYl0JRjXWdq0MJw0UpI4SgqitzEOGaMwXU9SltarsJGrZmExjiHtwpHJYUVTxMaQBPafK3qVvBWqKqpNVFKw+hCCBFbKlaL0cw6AWDVXElrlDbCZksQewODMzcmamE3DPTOQiuksFK0pjTNerkSamO+XmgxUpJiv3/g/vMtGsWyvmJLoaRXEoHeFuL1GW08x8vA9M3ndA+OPz8HXvIjX7zNdNee/+Gf/jN5OHP/9g3qOfFPX/wdhzv44fsfSGpgOW/57//6ns+2iuc/f8+j8hzVK/3wH3i/3fIYIsvpnt/91cTeWv71j3+g++rvuMz/Qv6pot/tWI53HN5M/N//8sTu9cjhm99w/9mBaafY/Cmg3JH4/Sde45nx/R1mmBi+7tl880BbM69L5ZoVw73n6SmS6oif9pj5xNOnmWQNv945Pns3sLk/8LZ/yzSOzOvCeX4krBfqehTp0Wbg0/mF/FOgXiPb/R1ZdWy2HefSUXuFnvYs52f2B4/vJqofOZ6PuM5ztx95jYraKmF+JQNoR8qFfH1lGiZ656BU6hJYU6TFLFloIwVnpeVtVpvjeLqSY0TpSm6JqqxAy1UnMcFO7p66GtY5ihUd8KqJE7Zm4g3YlWuhNuEdl9pQSOzPW82mk0FPSeKF0bVKf7M1akhY7+m8vI2TtsRbwOaXvTnNDQeJkgtvqtSq5C8Wg1jEtAGKwKD9DWGfs6AcWqYpzbIE1pCxxmCM4O51E9swSlONph8HUIaMFF0LwnWpoTLaPaiINY7rfEEkQJYWAtZrkrbMAeI14rRiXVe2hwNKG7wScHJer7R1xWqHNV72bmvmeD6jhp6UBSJdyoLFUCIM3uGUu5W7F2pesbZymY/88MMT5fkJ3TKbt9/wOihO//wvXLPFHDa8uTtyGCrNdjzXb7n4N3x8KZw/vPI//tNv+Nv3lrs687/8z/87P377I8eHiq4rf/fN1/Rt5s1h4Onb75lD4PKj5pv/9D+hikO3hc+/GPnsq6+I53vSNTOfPnB41xGOn5h//MjrH14Y3n8phi81cb8bOV/OPHyzo37/kd32gZwKT99fWWulXwLbtxs2VvHtx5VjVSj7hqVq0vVEny8oRrGC6cY4ddzdj+gG1iTmbsVPDeffoLY9y+WVZideTjPz9YWwnpk+/5JaGn0PukHdvufDv2WMGchpZb7OlGowDIQoZPVUGxmHR0ugxTScNuLibLIjNE5hm4Ei8mZaw7bKmgI5Ni5Z9u8xLGymDmc9vbP0zpJqu63+ys3TI79upkfVjNGKlDJLXCkYaBVrZC0TbvgUrRW6WepNnJVzpcQqJPqmiDFJpbE1Sm2sKaOR1UzN8mf8oofTOQdoWhGfplKauC6kLH001cAZwWQoDSXKGV6IY+mWeZVpHaUCRXK61lILGKQfN20mrBtE69agUcil0bQlLCuoSudAUXlzf4/1hmW5SN9Ua2w/Ms//L2dvGqzpedb5/e7tWd7trH3O6X2RWt1aWrJkW0a2bMt4t7EBk8GYCcsAM0CYmhQ1SUiFQMiESlEViplAJcNMQgpMWAzYTAYBxuANIUu2bMuy1FJL3ep9OX32c97lWe4tH+5XzqdUKvrQn7r69OnT7/08131d/+v3mxAleBkxnYLWWXTwaOVwLrW726Yiyw1dIRCiQz1uEvakdeyNEgKzk3eQytDvFeQyUvYHbK9dZ3tjSNbp0DRDQFEIi9U9yswRdGRnY4fR+itMzBLzhxc4fCjHjSbEwb2sC8PtW3tQGHpFn724ydaw4ciJE7z/+1d46qt/z+2120g3oBp30CtH2DeA3p0dfNHl2j/8CcfuGRFkjfc9FpdyjJE4VTK7qJk9sEhRlLz0wjeRZoUnX71C7/4RRw/tp9poOXq6R7PbsHVjj/M3HAtHA5rIxvl1XGFY7AoQBaqjiaVisrVF5RRzvQ5vec/DZOEhpI4M5jNCoWiJ1B6MSHqMmX1LDHPH6s0JPRlpXEPYrfDBUspd2kYz3tJkWtPt9lKXMgh6nQHDvT2kdAiRrk2lhpaQ7nJKYcqZ5L2UjkjEtg7rxpTdEmP0NJqpkSZHiEhV12l90VlklGRSUY1HyExRB+gVJVp5/Gu099BlYl3S+WUpXEBwuLZh6MJ3/DtCprLXtS6x4IKfWsliggNYhRAuqeSzDCMhWosmSyVuDAm16pIHR6mMiMa83q0UnJsG0xPxDRemi9GJYyslKbzuUrDdth60Qps0K/QhJGWclEghkTG5U9y0BpdTet64bimlStZjJM5GqrpJb2OtgIDOM0SIeO8QlsR41YqJc9hhld6mWUGIDnAJXahSQkj4BBmWxiRAsQsEO8S1NVVTMdqpEVlOfzDABkW3LNHC4YRk/fYqYTREqQAKMgr2Nq7QLzRhtofzY/b29qh3r2F0zuy+/dTDyLjdTyx2Wb99luG5dfbsHAfvuZPtvYt0ikOoY6c5uH/I8qEB99u3cPHWLqfmKua0Jvqc7XWJLQYMKbj3vR9jsLyPZz//OEsr9zOzcARf1UhdIgvN2AmijQyO3odYHXLt1rOsPd9j9sQR1m5OOPWGOUQ2g39pk7K7xI2XdplfGCB3a1AerxVROjSKlZUFzMBgW9g3M8v+lQ5ZTN13WWpiBJlLAp5xYykFUA7odA0zYpfh7m2ayQY9Yxh7cAjIHb2ctOK3tYsNhph1yf2IrJdjbcQUXVxrAYdWkl5e4qKgnvYj6mqH4CNKKMoiQ8uEpkEKpPCpG49MTs08QxvD9nCMEoEsl3gDUgW0TnZrL1LfIsTkXg1hihkhTCnsKd2TSHbpOMjplQtIu5/RI2OS7gqZvDpSSdqm+U4qznuHEBFt0kzWBgcyOUchCbNe1+GMr+22iIi3cUq9bmmtmyIvNcEn3L2UIq3diJgs1zHp5oKPqZwVqR0dYkwjGKWmqX6dqOfWo1WGc5bgk60rtBXCAAjadoJwSVAUdYHUGZN2wng8whQlvg0gIzo3aKmIzmJyAahUfotkoY4BmuCYjCapZM81ZTGg6HYp8g5VlfR/e6MJbVMz3B5imwqVD1CjDWa7XZTStGNLjFvs1SNM3qXNBL6x6BjICsPLL91g/eKL1Ls7ZP0B/UOK9duXOXZyltXNDTabDQ6Pxhxst6nX4cTxYwzKDl9/+iyxvYge1hx+8AH23X0fR1d6BK148L0f4skvXmRhGIjji8wevY/heMjQGyZaMHJzFMcVp+8wmOEqT33xMnZYc/djB5jQ58qa4PjJLn5rzOUnVtnRDfP7l/CZZHjLYoRn8YCm18tRuktZFOSZRGYZUiXZT7pPtWQibWVYUTCsIzvNiLWdLYx14EDrAhE3yfuz9Mv0thDeEaLFBUGuLJmcpJmuWaQZDzHRYRHkZScxvKoqNYkEGBQi02kMEWHUBopMkquIlFP1pE3k/ogkBkG3WxKiJyqFFan3oKUjzzJanzAudpr8cT6BzdPVKvl9YgzJnhcDTHlAWmmMmUKtgwDXErxP81Ep8D4F6FNdmATRkfR1pIyokLLDSWYkca932VpOQ+xRSUSIBGcx2qRxSp6RG4W1aVDrfDrIoXUEkZ4IQkmkUiiV7gLWTQfkpkRrjQypV9a6iLWWxgpsWydKncoS0De0RARGq+k/JAXsfYLfkmeJcetswIuI9Q6pJTrL8DEg1FRSGwO2rmna/2fVJ/1AIS9LIoLJeIS3NXu1YFTVROEgF4hgqCdjpFL0ZwWD+cOsXb/JaLLK2I+J1RgvByzML7K9fZPJZI1XX90gBEvekZRlhwNvOEqRl1S3rlKzwI1Le0w21lBzQ+4/ehdFOeFrTz3J5//yadbXNT5alp/7Kv/8J36A08vvxfkUg4wHjtBkOcPtDlnrOXf+KqfuPc3aTuSl6zvcvL7Lh/7RP0Gu7vC1z9/gDY/eSTUW3F7zuJUVOitd1GKJcCUBw41XtrkRLWrHc3S5z2DYEPSIdiQw3S7z9y6gB2mdLteGLFNobVBR42pF1cDedkUVa7Lo6ecZo8EKOQ0mbDMctZR5H5lrIoa6DVRVg85zivl5ur0OO1sjogvkmcYHqK2nzAxFpyBHMqobvNdTe8BUg5kVmEKQaVIqLUScs7QOjJZJ4agkw0mNEVBoMbWKg3N2+jLxSbClZZpP2pDkujHtGpvMICBtXsWQZNDGIPU01eOSLPc1nKnzkbpJkAAZU1AhEAkhqScdEES6MxuZVITx9cb3nGsTqkEUqBApMoNQ6RuXSqG1gCinclxQOieEVF+31tFaT9Exqbvl49T6m8xi1k3rfJlwEC7EtOPmQ7oku5rgInmRYa0DbxPGUChsNUkc62mZoYSkDg0+ClRM6nkVPRKDMjod3NYymYzSm1HAYDBAaghKEnxLayXO+rSpMuXAFoVlvD1hdzhGyqQZXN+qWBh0KHt91rZuETs5oXWIos+mHbGzUzPe2cAjMdKhpEObywzcgLvv/SBbe7CxPUTeusDNl4bc+7Y7ifMzfOWFwF9/do3LZ6/gdU4hI81XL/J4u0a5/wSzS8dYnpvh0JIh6+fU9X42XeSmmGV+FBnh2fSBXqdk7OHkQ3fwAV+zdHofe9cdM7Xj4P2L7E0iz3/hYjowMpCpea7dXMWON5hfHCDCLLSBvRfPUg2HbI7uobu/h7UNKwf2cfCOZbKyJHgY3t7EIRndHJEVln63D80WPpthsnaB4XiL3VGgKDvoagPnDXnRIdM+LelHQ7XXkkem1IBUlZFnBFXgVFJ++FClvLNMD2IhPbnRCKXTPLhuEF5QZhlZnvZ7hYiMJqnh6F2brkwyJ0aPMSl+mhuNJ00BjFY0TUt0ASEEUhnstIxWOgHohExv06ZpvgMQiEhQGuscTdtOdfQhre1LidIGiQYBE+vJckW0DUIl7Kbzr7OsrcY1WZZPea1hehCSheu1Zk8UifAuErsfwdQEHH1aevYBLxzJPmymivl0uW68myJQFEaBCIEszxFGJRdnjLRtTfSOyieCfK7TD751LdaBynKInohD6yJtJ2iDDQLlIsYYvK8Zj8dY6xFSkucGJSWZzmh9Qz2Z4EPq8qIExcyAbl+zr6dYGyvaskNWzjEc1wT6qFzjc6iFoa0kvf4cG2vX8Vqzc3OVqExqPNFiqzHel1Tnn+fqEOziYWyn5f5Hj7K3VbApSz79V0/xzOfPsn7pOi7TdE8uk40sahf++twVOs99gf0zb+ZtDx3h1KED3N5b5RI9Nm+MMarHF5/d5tyVMdfPb/Lxt5YceOAkWb9k7sYucbPlW1eG3LNUsnJ3wWYOl4aCfQPJ+Nu3UOU2xeEZjtx9D40YpmzxbJ+Fo6cIt24QKoO6mXHrlauMj0SKskfZtWysbTHamBCyxOVZu1nTP7RILzO0o4bGSsp8JYVIRA/vHXMLi3TyGXw9ZDjapQ0G7w05CoegChlKWVonWNsa44Ui0x4lZHKENi0iVCjhyIIg2jIBqfMiqSFNSbebHiSttTTWYkSAaMmiQLUt0kg6RQqsp8OVlpMDEhdSpZcumUlyFIUkvShlKpljalRppYgy4Dy0HqwjlblIrHUpRaQVUhsiafyS7qkBH9Kft22au76uw+lD2uCIQiKNTOsvMfFhQ/DUrUstb+vSXqRIS9B+qmBTWqBUMpW9VoNrbaYCXU/lLPiAkVCUXSKkuapMlG7bjlMnT2oIyYfhWoezyTKMjNjp/d3ocgqfDggdcS5SWYcPU0hY206FNEktqHROXpS4sUfGGltPUMGBUYhgafZaVG+GbncO7yW7VY13iiga1tY2GI6HiMxglGE42aNqRgifUy7O42JL2ekzCJIYOtjdSKs917fXOXikT+dkyWJXcNf8Ea5ev87Zl15iY+NlXLQUBw4zf/8hhO0jVME97XXE6CyXdiQFN+jaEzTuPH927oNU57/CabZ56ZW7ef5SxZvedoDceCZk6Czj+dVrFOs9nnx1hDpxmGU35HZHsRNKxjuRtp8xH7dZvbZKK8csZo7ZxR6xPEo4fYLBiTuZySFsjlg4dorrW0OufO0aM/tzrl6+yLCK6HyWaC07mxVRa9RSTr25TZBdpDmMcgEbFdJIMr2Isy065uTZLJ28S6SDb8aEZkgIJl2josW3NTI3Uwt6TMSH2NLJUtrsNTdOiCEtNOcFURm8rXD1hOE46SWVkORFmTAbtqXszeGDpvUQfUJjZmWZeiQmm8ICquSHiekdGPCIqZBLSINSKt0XbYJLhzA1G4Qk2H3N4RmJ5CaNIwWpoVRNmhQFJH12w/97QOj/CyoNznt01EShEDKkJ0og+TKlh5DixkqI9PRSBmVypAhonfhBSfWnpqLTlHl03hGsxSiVOsDeJtpCSF+zbRt8U6PLInk6RWoEIDMgLdSqkOapGoGRmiiTdlDJ9MbFexrncS4QoyTLTZq/+hTIj5KprtwQpZ2qJ1rqrU2cNlxtG7zLEKKPtYEYBUJL1rbbtDXTjvHS046H5HPHmGxfpljaR9iq6KiK+x69j/Gk5coTLzG7f5Go9rF/AfTCMgeXTvDA4Rn+busZVLnJgUeOsnezw2SzoL5cc/yjbyY//iD9l7/GeOtJFs0WT33uZc59+W/pd9d4ee8I2bnfZW22YH37CKff1uMj75jlLY8c4eUrO7zw6k2u1+vcuv4EN7YjX75wgu+54+2UMVLuK1ltFPecOsLJbIa/fvwveeml32GhlCytLHLy3R/lzCOPkOcasWUxgz7GbTG7W7Oz6dEHFKHxrN/eYW/tLOXcPPODA2jnEDueYlwzuzTPpt1jWEVkU9DRnu2Rpzcr8M4Qy5I8K4hA1SqEMsnGJgOuaugRadr6OxT5GBwyeiBpO3RU5EqjhEImUDJtNaSajFFSJitd1gUf0dqgdY5zkSgzGps4zMLLpKBwespZfg19max4TG0CzjPtyiqI4NqksXDW4qL4jsdToiAIdF6gdLIDGCmo7VToFRwiWJQx6S0ckon9dR1OLROWJIYIKn2jMbQQE8kuQipllSYqnSy9MSazr9Qoo5PkJQriFE4dQ+C1wkFPnyAhRGxrk72ssclO7R1CG1JkPd1zlUkyG5kp7NSbYoKjyJOXEylJfImYRDwhor1DEVEq6SBikIAkz6CtRthmjPPgpEGJgPItREFrBbs39lBR0RnoRGTQjqzbgZ2C4c4GTRNBQFnOoucPEGxDMTeLkQPy8YisO4Nwt/CjmrPXKt74ri4P3FXQO3qK/uHTdKXHVoeZzQ+x/NAhrnzTcvbFZ5Gx5pGlBcbFBq9ouL5q6F74Cs9+4zKzh2apsvfyge83HLr3Y2yvHOBA9iD3vSHnjt48dAzL+zKe/vImx+65h5cvX+Gl83/K7Lv+BeP9JWeWM/p3DnjmXEOzAb0lwal7DtC5Kpn0K/7m6S+zeXiZIw8cZF9TcrsaoJtIvnWLazd3mD19AqNKZrt9en6PC6tr3Hr1RU6dfIC3nj5BbiO2WaW+vcawGtOVs+zeuMjCygnqoJmYQAiWMoPYesZt2umsAjRthQoOZx1N21DHiJcerTxGuCQKQiQaQqbSfFMarAvUtsXaOnF7QqTINZNmQiYjmcrxQiFloLUBZAJFN41IGNfa4doxPro0g5ev2c9J0l6R5ulGJUmvbRNAoHURL3SqEKXETw9qSg0pRAQFSCB4jyZJeQkOiUymvvg6s7VFmeOtJy8KfPA0PsXjgo7UdTOtq5OPMEyfEjGCc2ldzFqLVIKgElSXCM6mt5mR0MlToghpEgpCGYJrUCKSSYEwOQGFynKUS42cOgaUMolnJARRKwqjqZqa6D3OOqILBC+prSXLDN08I88NQqdwd/QRWzvapqWe1NgQKIuUCnEiUPS6VJOAKTsoXTD2UGQzzC3NsVcPKbKCmoiXGVnZwxQVOtQcOHKKRrWU3YrJyLF125IVBnN4H9nxjN7pGdZ0YO3aBZblAmrhFA+dfoQTx4+wQ8PRzSdZ/q7IkbnjNE98g5tyyB37BXu03Lp2nfe//Q28sNHy6Ad+hI+//wTjmUd5ei/wkWMd9saOr2zXbLxaIYTg6sphjsx1OfDYh2m+8ifstZs8//x1losVyqWMueOS4f6M/kqHBw69gzcOD7IrR2xnT7PeHOTiquTilU0m0XLHvMHfily+PuLovorsJiwcWObaty4z3r1JX+yxPRwx2hmydmmLyY09QmG5vXeNY8sS34xh5i7caMzOnkX3NWa0Q+N61FHgBFR7m+jYJtFstDSupZt3yLqdJDEKFmvbpN7QkJsMJTUxSqxtSIoehTYZddOm33MVqigQKNpmmv7xAi0SwtIGh4qpm+qdJUZL3ikRISbLeYwIN71/kuBiMQSC94lSHyIombi107hqEBIXUyZXCKa27ADCJy/s9I2b5xkNEZO9zn1OTzogaXU6IEI6/TKk1a/k3zQp2K4iRgkIkJmc1lla2ybjmEyyGO+Sqk1EEs5EpcZPFBJkWmgVwhClIdcKF+J0X1QSHTStTyBh36ZQgxTpjhpJZWcIFQgEPwAAIABJREFUEAWjSY2LUy2AVhSdkrzThShw7RhnLRMXqduIbSPBNmQqpg6aKoiyICs9GEtvbh6v9hEqR+U9o2GLtBDlgO5AUswUaOvI/RYUPYqdDYrhNqEzw+rL59EDhVMOUQeuXlrlW5eukkvBW+67xMyZh1hqtzmWFWzt7rJ5aJ3lmQOIq0N2r1xl/eIO73hPl/vfeSfn4hv58o3Awl1v53s/cJC7DvfZLTrkA/jcdsvo5ojzt1qef+oa29fPky3ezWz/JLdWFMPda6y6z7L7+BMc5p2svO0x/uSP/pxj7//n3FUKlu7aR9cssuQ8P909w1ee2eHltRnGtstkraazaDjxXfdx95k7kB3Dyy8/y6mlOdYE3Ni8yPFOzdx4FvdyYLy6wuXLt9jp5Gzsnme0vkmWLTBYO8fMwgpdkyWV/KiitZK82yWXgaAiUsRkKQ+OQVEgsjwp9XROJENJg5di2oRUCBI/uLURrSQqK4gxweikSIC6vNdHKOhkGa2IGNNBImmtp7ZtEmkFl5pKLqKFRJmYlCHOIkSCBwhSKRyn2zLBxQQwFyGpRGTy8ngXpqxcktgrTD0rIdI4R2MdxqTNFqX16x+lZNOyIXqP0Zo2poxjRE4TQsmDok2GUtOLu0oa+kynp497LTk0dRnqdD1AKI0wCm9bQiQ9lVyLRKWLvFIgkmEq1C1N26RLPC1lJ0cZSYjQeottW6omWaS9A4ckCoHJDN1Oh7LIiEhGk4bR2KVyQiYpjsgz+qUml5GqsaBMCkP3+hiZYTpz+JFmsneb7dYyWh/Ry0t6+5aYWVmgbVYpbY/h5hadyVXu3FciFlf4xqXrzKK5/86Hee6V23S4hNorqUSPanKNz/31F7j47LM8euYMH33XY8wtlJSruwht+NyXLnH9pTW++4MP8sj919Bqlv0nD/LtFwU/+XM/wN1HBvzOuYYrecnKHGwVmhNzPZ7948usPrPG5Pqneed/86t85jf+JfKDv8xjP/9f8NXHf51y7wAz9/9nDOY63P2mezlyUPCq86xteh5eNGRZRrc7T2Yit87vIuuGg3mXpu4jVwq+9oWv88qLz7Nx6SxHnnasrV/HjjeIlMS1Cxxe3uPoyR8i7q6xtf4CWXWBy+OWXtewvH6JI/ugPzjErVuObHY5SYx9kh+VytDaim6e47XCRUEVPNWwQnUkIstQup9wJDFBpl2URJmMYTEICpOM08YEOv0uo3GNjWmlSxqJURolk+S5qSdMJdU0riUvcqLI0wM+pB3OEFOPJfn2IlKAiyEdUpLAS085zTFM76XRommJ4bWzE6dhhIgI4Tt8XO8D2phpGul1HM4iL/DWIUVMzkhj8F5TO5cK6ekTIs8UZroN7lxLa23iBEmdrL4y/VVRpCyicynW14SQrGXTS7hA0zqHUZGxtQhlCDHNIaMQKKPwpO9Fqshkb8ikTmJdpCLLSpRJP3ypNUIXNE6im4iQgbZuGI73IEb6/ZKy0ES65CpLi7OiZTKs0XnB7Mw86C7bu5Z6b5f129fwTYVuYTyBfXceY7YPtUkdZNb2mC2X2ax3WLu+iejPIbcc33z6GzT5HEdPHGYm9+TLyzz9zFn0imK11+AOKy53BxTdt/J3X7B84S8+w9Xzqzz84BwPve1dlCf283ef/gbXNheY+8S7eeub7uIPXmlYm8uY70lEJ/KjcxnVbMbcx/bzi996mbt+6vu48Olf5PjbfpRnPr/K2//3H+LHDu/n6Us9Rv07ODPX5Wc/9i4apXh603PHjKZBUO0GtiaB5YM9Tl2P7DjJ5upTXLu4zROf3ebVl7/JeGcNGyJXL2xxqhzzhh4c7M9wYTSi14UDDyuazSG6O4G5IwxjyYXnK/zE04waJm6XtdUN2naWcvYgJgpab6lDybhpGEzHD23jqGqPyTUSj7XJVi5iBJGWLrJOgVDp0BVlhtJg2xYV07w8IlJQXqvkWA0BT5PekDqiZAJvFblBRJeuS1oiSZOJXKcdZedtqvgAnEuju0QTQE37KTEEondI1yLlNCgTItY6Wh9wTYNWgdxIEJBnaf7v3Oucc4aYBKpKgrNtuuAaTSFT3tB5j0eCUEgt8NYRoqOdxuykUGSZme6wpeS+D5bEIAwp1O4ajM7TzClLLgmHAG8TUyZIlAjkRY6Pjk6/i/QO21TUVc14OCEgycucXBtM0aEUChvStoC1jl3b4EOVspIqKdyQCkSWFnsnFUop2lCQD+aQmWFUwXi4STsJDEdjdG+WECWdXtrEWel26GaS3UYwtBN6/Xmun78MYZem9RxaPM6F3ReY7Da0wjG/UzLuGObe8Ta+92P/hNXxczx65gjHZ4dcX9vk7PNf4u/+w2d5+YVXmbtnjoXHPoE7+E5+/Xf+I08/tYB+zzs5/ua7uFAZ3ng048WOQheCD+nIrBQ0haD35jn+z//5UX7iZ3+Y3/il/5pf/b3IJ3/1NHphQO+tH8Yf9MzoFnVzj0P3LBKUpHGRz18L7G14HqJmeRYWNzyvrEqeu3yReusyovoWG3sv4tohi+UhjGp560LgzJJiMSqeW91iZ+I4f27Ege9xHLhHsl213GoEWWsJrmDGrMDgKFvrI2RTYUcFkl0igboaYXXEBs/EZ7gocSqDbIIoNJVPn5VM10RXg3Q4b3BT7UduEjFPSk1RBMaTRG4se0WaVUiFiJroW6xvEx/Ip0xt6yRlXuC9R2sDSqR7pa1xTUPTNlP4ybTiQyTCQYgIlTQjUgSihDYktFeyvacrVnSJBOiio20cWaeXmkQqLVdO31z//w9nbhRSRdoqDUq9Z0orC7iQhKpZmSOVSrt2raWxHu9TB9aYtM+J1FMNoCeGZCBLL980lCUopFI0jUVrTUCmX94jjSDTBpVnKNdgG4uWYJtA3QZaLxP1HY2Pgnz6ttZSMdzbw/tk9Q2p9YZUadnVSkXtElY/D5BKgTzp2sZbjLc8WnRoXXKMLi7tp5lZRMcxId9H0ddotUBXB7Y3byKbnHsOKS6c22DSGm7e9tRZwSTuoBrPzWsjFvcZTi1VzB89hf76Ob791Ktw50nWbjzHn//hF9m5tEEfyx13HuT5W3fw1K98nlvtcXbHisUHD/P2g4YzPcViqej6yGYLx3JJ20BHAR3FXW9a5l/9D7/Ev/21/5F//a//kLvvnSeLwEDyI6c0M0HRrHlkBFzkDinoHTJ86YLlU3/m+ch3TTgjax7MYGI09dJlNra/zdb2GiJKDonrfP9Rw3Jhue89hxg/tcrjwyGzwrB98Qbf+uQTFEsl+x/8R2w99QL3PfIgAx+Z6d2BlhlHjs4SlmbZuHmbqtlj1FZUXtCTCi0lO6MJFF200ZiySx0CVeOTUEsEhJFIrcnKDLQkqAxTCFzwyKDwIaFBlIpILakrm+5+eGKoibZFZkX6XBmDyjWutmRa4ENa6/Le0raetmmngZl0h820JopUulrhUgSVxAZKmd6YrmjWpipRpEirUprcQBMlWZYjRAICGKVw4XWujKWWsEHImvCdp0Ky/PoQkkqt9WTeImNKAxglkLJATG3ScTqB9T5QNW2CLQWIIdXrFoOLmtgm+2+QmiT6FklG5B2thA6CKASuqhi5BtdMvZ7SIIXCmAKkZjJxNHWNFIFgPVJmmNyQ5TkIm/iwwSOVx/saFz1FVpDlA6J11HaMtQ27a2tkZp7Ge5bm+xya6bM6GtObmWV3xzJqIYQ1/M42druh3b3FRRy3tydUztDWz3Fs0TNqKmoH2xnM9D13zwpOHj4FJw6yWQue+NxX+d3/9ZPsrO1CkLzrgz/M5PBjXPTH2Lz5Am5nk5Vf+TFOPDTHYwPD/jzlQB/SMJTpP7CbQ02Sje9F+MhbHuANv/E/cebBJXSMeAvKCJYLsK1id7lHDILowV/y8KU97tOa/MNdro23+ZvH/wO3v/05QnuTEevsNkOcdRzq57yp2OPtKzk6Fug1wbVJnx9YbJmVfS63y3x76xCHDx3h1L5DlCszLL/xEVTYpVqtmZ8XWDvBB4nLBGNRMHIVmTZMrKfyLVbldFUHLSPjtsZFh1SaHIkyCpkVmHzagCwygs5oXMN4NCHzliAkWaapqiaJg6wly3OUTmKi5DKx6DzpI23t0FoxGY0TZiR6EJ7YVqmzGkJanMhSptbFRP3IjCTLJWZ6qJ1LdjLrXDKIqWTJE0Im2a9QuBixbZ3GeTGDwkxP0+s4nFXdomWiWNuY/uGtc8hpZtCJVOMnHAnI6BKCQaRt9Ma77ySGYowIZLpHShIL1NrknPDN1EIWkNHjo0SpHGU8zjvGVY2QhmBbnIwYnVH2e4RxS2SEsw3OapRXKZsrZNqf05oiM8jcIDKFcxFBTkGLUQqRl4RCU48tVW2JwhCsoxqOUEKzN9piYWE/c+UsaxevsG//PHmR09u3jxuXr+BVy42LI7KtismwZmjH7DTprnG4N8vxA4ucPKn56t9/lf0dgRkLPvNbn+ct95zl0Y/ez+DUnUzUt9iLO2RzKyx89MeIH/oE289kjL86wu8dp/OLb+ZdH76bD87mrOQSLeDlesKdxtETJUYYtBCUkPCkCMZln7e88cF0RxKkdSkhkKTW/2xHcutyw//yW1uMzuzjJ7+nxx0BLj25yqf+/e+zfun3cdU6ghotJZ+Ym+F9Z2YZzDasvLVL7xacfXKPzVs7lMUy95y8n0Z3uarvZf7km1l5YIZe/xbH7zpAJ5PsXjiLzko2r9TouR5aCIruMlHmrG5X2GCpbc3CXIFZ2Ec56DAZ7+GcQ4aWTNq05hVF0j0KQ240irR4MRyNUyXXKPJSEeqKnd1tdNHBCIUPnthGssIgAuR5B49kOKoJCFT0xBhw7dQAQMBoRTu20wpRoZSeRvcMOkuIHEHEe3BeQDRpHIMkywuISQAWXGLoekBHQzUZo43GtgEXHEWRvb7DGdoG0+vigkysmNYjaVLSRyiUFOkVPQ0BB1LCx0dLsOl+GgK0rUuxJ52hVEpH+JDGJkoLnK1xraXslQilMEqjVVLVh6qmYzLaesJk0ibXZ78EDDIzqAiIKm2/aI33LinlZERHUrjbJBRnZiC6FCHMiwIbA1vbmzRVQJou7XibuhpiJ0O0DyyUPfodhfUVcwM4vDjLrT3Lqxeep5dX1HXN7o3ztHvXmbRjFhdmWcoWIFrGwNU1heiNObLY48RKwcbmLjfX93jhhYjfmPBK9gR+RvLwXQd55llH22RMTM7Bdy2ytwPm4x8ge+cBvn+uYNkIchKJ4l985IOMVm9x9IeP8Hv/1V+ypPPUMIsCLSJtYVL2OU7rHxFTgATB+kbN1/7gEvd/4E5+8qcXuHEDvvDvPLcuf5nnv/HL7K29ymzY5YyCo1Iwnw94qwi88dEOrjGsfnHM753b5ajqcHLpDEunj/H8jcusvPV9PPqetxMrzef/4hz73j3PYDCmemUdv7bGRA4YdPuMV/coFufZ2W4x8xlZfxlhRzShpjEZ2keavU1UaBlk6YGMd1ivGLctMSuZKfsEkwRHQgr6MwtU1TghOJ1lOB4TWkukgmKGaCEaQXQelRdIYXBTEoFUiqpp8NZTj2u0TvHREDwuRpRMOWkhAkWRAwKnmK7OgfVumo9NqEyl0+zethGtBGiBDY4oUxZAqWy6NyrS9xBeZ7fWC0Vrm+/o/ZSICG3SU8Z5hNTTwHCi8gXn01xHgffp9S6FSkAmJRA6I9OS2rm0YjbteAlVoE3EYiim+gVrLVqkfUuiYFJZ+oNuUqdlkigk0YbpAyPNUKOvybICFSO5SutkxuRMnKUNDcI2hBjo9ft4ERnWgQpDHSdQj2lsjfWB2bk59nYrUCWuGtMWLS7v8PzL57m9vs367ds0oy06Rcbe7hauTYq9vCzpzc9z/2KPsxdW6WQlayhO3PdGHr63y7lbNaPnv87RR05Trgyonlrn6b+5ytZonezQCqp3g5X6aS4/YRgvHqezsMCvLUjuygQLAmaB/+RnfpOzXzuLdyN+7j7HQMIPbcK7B5EfDDCTw0e3BE8upsV2n8JdNC18/Xzg21Jz5geOUgwUZiS59MXb/MbvPUXJE8xV3+Zw9KyRvDHvXS65++QjdEcW89zLXLi8wytri5hmiV73KHP3fpzw4F2cOHYBLVYorzte/cJZtv/hD/n9v9/gXe/6BOMqckveST5uuXZuQjV5hQPLS3TLQ4zXRxQi8WFnywFj69hbXSOXgTKHvJBoZVBlh0GZMR9haBUxGtrao4Si6BRkWhGahtoHaiuIIkOZQFEWmG6Obx2FVgnuHCLNaJxoHlIQYto4qetqun8c0lpaUxO8RRclRmUJUl1NUEITfUiHN0DrI60PaXNFa9AKH5gudDgykyKsvvEonRFSXmjaYkrzz9d1OMHjvZqOMiRKprCAC44gwYaU6c+0wLk0Pgmk+2SMIo1f8hyVCcCAMLTNVFgS08YI0adcLhI82Mbh/QQlk8HathXaGAb9chqXyxKfVQW8b8ixCTzW1PjgyPJIUeQIb2kbx3BvNB0+B4oiOR5VngECExtE21KNHXU9TA7LQuJkh6WjB5mdm0HmHXy7yer1Xa48/zyurpnUIwYmUI8rPC2V85xcnkET2Lhxg7+8DvVuzYPHBR8YaJ789i2+eqnDsYfv590f/RB7doO500d4bH6Wa69eIQAf+YmHOP3gm/irsx1uH7mX5TMH+IWTGavjwANdy00xZCwFl65+muWfWqH/vg4fe+efcd9d9/Ljzz3DG+QswsHhDwv+7C9ee2uCBaSH26uRk3nFvpmChaLglZccP/SDWzTtk0xGP8esdBxRkYkSPLyyyE+987uZv34DdfZpdiy4A4Gt0TKjSeD9Bw9wx8//CkxmGT33OOPyFH/7xT8g5zL3zh/hwaWa9oHv4zN/+1UOdGbYGsPdh46RG8vQLNHoLqOdhqMnDHuNoju7wur2LtEF5ooert6jbRw2pPnkwJjEk4rQKRLeI6LT5yiY9EaUikx3piKiiBMSYSC4Ok0HtKTISlrr8WQEQTJUu4irmgQb9x4bIibTNB5EANdYfDb17ngL+GRWD+Cmv1SWoxQp8keq2opuH29rgp3Q2hRPVSk+B0qkq17wUwbX6zicSZIwbQTF6Ya5J409op/SrtM+HCH1WGOK+WBMTmsdzdRNEmPA2+llmIgUelrbJ123DzGNeqNAh4D1IV3+ZYe8zIFAQaRpG1wbqP2EaB1GOGQUdLs5rnYoLE2V0kkIQV6UzM4upMlJtNgYaRoPtkb5iAgKbAJHYSSm06cwHZZXllC6i88Mm61js9pgrxmi/ZC5mYzCwsHFHi/chIOz80ThGATHzb0hk7alBdrdXf6+7RDaHtqOqPwmFy4Z7jr9AGdOGLZ6LYsnD3DX0X/Me7/v5zj37HWOHJvnR+4/yvNSUBO5Y+fbzM2tcKB/gHd+19v52G+9n/fc83H2l4eIcoavfP3riO4MAx8ZS8G3/xjK6RvTC7gR4DCgWxislKxFwQf/4w1e/c//DaPRE7yle4FfOtpgfGRUKCanH+HBe45w+QsvsXkbLlQlnxpv8qb6KO9a/AGqXmSzfIg7+yd58rc/wv52xP+2G9kvSt535jSdfUu4Wy2f/sxvspXdTzH3DnbXP8X5izcZzM+Rd3NMs8TicpfOwgKNbbn06lXyPBInY2KW6vG6qshjhlYFtgZlCmTeweQZZTdDS6jrFh8Co+GIxrZkvRxNROWGmhahQMWAKjMinnFtaSYtVmgKo6gaT9ktqCYWpWJaSRPJoVIoQWUFTQRRebyw08+1/E7SR5sCaXJCdKl3Ei0mCwgUxiiCl4nhHMFHByHNXxEK5zydThd8+zrfnCIdRIEgRg/RIqRMJWpMM0ljFK0VZFmKVcmQngjBW/Q0FO9iYqaEkBZZhVBoqdBGE7wnpAARCElT74FPiH3va0qlqSdDis4MeRYxAkZ1Sz/PaHx6OwuR9GyzvQ5V0ybHReOSjk130cEy6PYQus+eC0zqmqqJtJWjqiIxSLRIa0jz/S6lNox2Nil6lrWbm2xt7+K2r3H84EGysAPac+PaNls3hyxmAySB8cYaWkRca6lax1yvYKcZMRgUlJ0xEzVHb+8IhxZO8LVnJTcmM6ws51w6/2X04Ao311a5KfdxZv8sD81DGVo+/4Un+fH776XsLfLhn/4o7/j93+Eflg7yfZ0By1LRBb42M8cgBB6545/i9H/L1QvHiYADMuCOKfamc0DwzY3IH/3Sbc4+/hlcM8vBwy/y2Dv6vPClyI3NCVEI3rf/PEezHcZzHf792XWk2+MnD/4zHv6X/4yZ40u8+Ms/wydf+mMe/4Uj+Mkm//Tjv8jwL36bF/YuITeOM758hW59iXv6b2Y7P8yr29vEcg6rK6zOObqynyKsg+9y7fwtXt7cQuQC2dTkRc5O66htm+KdREI9ptADpPP0ZxV5acgKhfAeGxyuqojtkKbytDHS6RUMd7YoOxm4lrzXw9Y12mSEtsYojfURqSTGJNtc3imQPmfSClpnE8HPRVxIsbymTZ8pYwRtDHiR7o/OtRgtp70XCSJL4DodqZsWZ910zOiS7GvSIoJHSoPKBTFYeL30PWU6CbPgHFolgHMUEpP1qKo6YRyUweipO0KQGKKC6aqOxBiDDdMftEwZSCF1QhOFGgFYn2wqiJbaejp5nspcaagbS9M2SIaQ50Q8pUnrOMK34D1apiFP40SCdzmPzvP0tM3KpBRUAh8dKgpykxGKHpmCjokUuiHTCqPBjyuiaagngY2NIZOJo5g7TNsNRLeJk116ZpbFfQfZu32J3d09hu0ufRXIi4KdOiCyyGi8x7bLuXtunpUDS3zlpU1WOMtufQkOfYDuiZPctXiYt7858FdfeJxz536BR9/3GG8585N86oWaz67+Mf/dG97LPUtL/PmLf8rP/Ktf4Rd/9j/lk7/9ONeYZQ7oCMGbgMP3rPLGz/wW3zhRYoGJixRG0AKbzYjbn/wEy9/7f/HjPzjh+sVtwu4vMCPB3RB89jPb/FjP8MFCcOzh72PxrpOIJ38bvar52bvfTJe3s77dZe3Pb/NvLv86r94+y5iWM7Mr3LfccuuZZ3iQOzjVsTx70zOSkcN6AbHzIo89coBiY8yNyUmMvApln7pqGI4i7K5z8GDJoJMxkoLQtmgyzKCHCgbnK9pqjMpzrMroFQUuQEd6lLeMxxOqKelAKoHSASUsrp5Q5gpcQ1nk0DSURYl3DUUmQOfEKiC8o8hz2mpMEyzOK3SW44JI0dQsonAE79IOqjKpmZRltBFkaECmFUIpxHQaIUAkSqWWEmRG9CExkgnIvEMjWrRJs3+CRMnXeedMjhNPFcGRAr4xgo+CwcICrq6/E+5NPD0Q0WOkJOY5trXJGyETdFdkGUbq5L1oW1wrIMvR3jNua6SI5FpQ5poYBSEIPFDmOd1Mp7JXxqR8cyGNQ0SSEYUoGE7AdEryXokUUHbSVktUkd29EdZFho2jCZFcaTpFn8wUzM2XCC8oNKyubbC3fYtJPcE1kYWiQ7V1gTsWBww3+yz0DOO1DWyIXB9uELxlqVNyZHmWQweWkKtbPH/uRbZqD/WEF85f5MWrBcFFdqqaTnc/Zmed9Vcbzm9f4cUXtnDzj3LsH/8Q7/jQcX7z//gsj//B76LjZUa/8zDtkiAu38/W6Of5oz/8FH9H5H4CXRS3CBwSguLXF/m1NxgOSbgYYeOCpVpWfPe8Yn/WxXz/n3P4zZGwdwO3/Ub6asC7Txzhv/+oZ/z8BW5+K/CUEvzs3/wJx79U8BOH5vnuI3dybvUaf3v7BtmR/xKxWnBjK/CS0+yb/XEe/eC7ufNkl/yb/8AjW3/KjZd2ubr6PJe8IC/uZKu+RfMPT3D3nT/KQ3ceZvWa4UC/z+m3HOXKcxeJvqUzv8yZhQE3b1/n3MureDUHUdLvF/TKHqLMMEVOkXem3c2GnWYPF9K2E8FOhUUFUSvq4OkUBcE3aJklZaRSBAfVZEJWlPjG4q3DCVLWNtPIyqELgxunJlIggLUonQAC+Cw1QqXBxwQeKLKU7Y7IRN/zEm/bhMuMia4glAIhKaRDmYKJiJhgETJdt7qdLm1Tvb7DKcT/Tdp7htt1lefa9yizrbV239rSVrfkIjfZxgbXgE0L3YROQg4l5gshtCSkQCjmkJByCE5CwHDgQAIkMSSmBjA94IY7LnKRZFlWl3Zdfc452vdjLPzrS67r+NNP65KsvfeaZbzv89x3jN0VTcVgYBiammZjDOMkA+NihtZ4gnMwGtd7ZFzAQvQbhig4snVcAzidErzH1CXOepyp8EHGbxiWJNHUtiaVikYEclN5RRCRpTAoa4KLinudavpdQ5o08d6iCoX3FVnWYGxihrrfw1tLr7SULgaWddJgPC1QKsXZgDFDsiQw0UopBwO8HCCyjHVjTZSDgQjUvYpCTTD0S4RSstTp0pSS0+YmOLzQZcvMHBsyyJBMrtvJ2qWj1MdOUFtBrwo0PShV0Cxm2bFpnF/s/T7N5T3s8il90aA5uY754R6OrcyyZ+9+BgsH2fDsZ9GYdHQeu4oz1/4Bf9z8Itd6aMom1/YEvz0W6CP4CPDl52vGJNzrBZcrOGVHwscO9riilfPJt3+B3/vcs/ChzVS4iD8pJnlQSczju/jM9Ru56l2f4twPCXb/1du59ME1iI7ilsNDTG/ARe94N7+zRfOxa67hlv27OR40hoRj7c/QmtnI2itfiXrtmQzuvILmI8c5/bOf5lwv+OqB/ayGHTxs25y0cjd1qNi4diPTcxm9viGdGCDVGKUznDh8jEePH2F2fh0z4xleJ1TBIERN0cjJ8yZ53sDbml53BWd65I101FiJT54kA68hQZJIRV0pQoBBvyYZy+MQSGbUXtFvd6PMVwSKRhHjolmKqWuKosA4z6CsUCIh2BJjRuPuEOKQkzjd9daOyB46vqoSaI43kVJgqiGurkgZQRrCAAAgAElEQVSlHg1/Yiu51SwoZZSB5ammthWIJ7lKsdZEmK53pDiKsTGMFaRidJH4AETwV2Urahvi4zroODzyNTIQv6DR41sKh6krRIjZXGNDDB0IRZYXGD+KSeGiPjCTNISKUzhrKAcDJBLpFHXtkSRolSCUpt3rMzHRpNmaJM9TZMgRwyqOulWKzlM0HrBkKomiI1Vgyw6dnqPsDpmemGTdxnlEtYpt17QPH2HT+nUMjh5lTgkeXyqZbRasbSraHcnE+ATONemFir2PPcpK/RAuTZnfMo2tJ5HZDEnVZlD2OP/8eRpjgmRRsLB8J8XM6ayUNbXNuf6rd7LteJvVld0oFjhpPqel12PXf4o3XvlcHlu7kw//rz+lP9tiNZd8SsA2wCO4UMLpq/D9yXjHVkLwjrUpaT4J/BzYwRpxKd9dcwbD2SN86eETtIrAn40d5tD//j0O33s+L3vD7zP59//G/n0dlpvn8UiW87W/eR83Lh8hEQkWwVVv/jCH7a/gFjosP/4zfvq6t1P7CTpr57ngzS9BpBs4duBRZhNJ6Q8w7jV7TtzMgW7FqY0LEOsFYhUKlWPrFcyww2JnyJlbNzO1poFORAy5ZJ40S0G1MA7K2tHv93FKEtQYPk2pqgGriysUzYykVWB9oGikqOCZGtP0un2EblENA/3SMOjXCIZ4U1M0GqSNMawTmCpCtlwQCBE1fmmSE2qDxyK0iGxcHW14WotR6UOTSfkEWyvL8mgnIxIChbMkaYq1njRR1KYkDTIa4KTAGI9Qgqosn9zFmWQpeZ5S9ruItGBQRtlMmqhYfxECoRJqD5aEIC2SMDIwhRhOcBadKBKVUpUm0uCtxRIZoDpPCUKjRsl+PaLqKWoGwxIXolLcVQZfG1xZYgGDpLaK1kST2jpUnjO3pkBnKWlW0O8NML02demRSlOkgaBE5KlKyPOENEtZXlzEloZOaRgfG8cnKbasYGio2ofZ1LKIcpG8aRh0a2ZyQWPsVGamFSf693No4Rgr7ZqBg3XjDZa7A4LwTM2MMzaxjqfvPJdTnvMy7l8s2Znu4b5bbqBZZCw3FV1/hMaOM0h1hbW7WX1kL/1H9rLxoi08/9lnIU98jKs+di/VH7yfyRt/yPue+Wtc9cV/4Rs7ttFB8OVWnKY/EGDPmYGt5Sd5ZPGtbHWORqMY/RQvoSHW8t5132XTBYfYd+fZvGrHFl723nfz1j/+O+5bsly2Ms+L2o/xkhddzE++scKNG17Njw7eyAOPfActJ9i+6Tw+8rcfZOXYTdR3f449Zh2fuf07PHJwLxOioNgbWLvlAMeO3MSNpWDH1CtZLxfZmgnWjs1xwGoeeexO9u7vcMmZz6Qn2iSyjxADzjvnXIT2qFZCOtYiGwwZ9oc4PCH0qIPGBY/OHNoLvNQoBCqVFDNTWGsJIUK0ai9o6Hhx+KAY9qooRpIpKhMkweKViqjLOq7wcpXSD56yN0BLS78/iFNYlSLSlFQHmmNNtPTxsxtA6AAyRY1iqS6I6EOJmIP4mpsV0XSWxVpkluejBJEYFbQDtjLY8F8H30X4bzAJ//PDfxYaRY7pdxACTADjQvRsoqJywQfKyuM80RgmNJWJEbY8UWjpn5C1WB8DwsPBIPJV9MiJmSZIRvBpqTGmT7PRYKXTidNeJwlmgB1Gbu1gWJEpgRQJjalpxlotIAJ9W60MU1f0h4OI5fdxpF00C7JGgcoKZJoCEmWHDHurlKMbyESziRtWHD3SZmZ2kmH7MO2FDv1+m0lZMT89zZZtp3DATnLw0UfodhZ4ZO9ejJME72n3l1FKMbd+mvHJFuONdZwyVzM/t53xucvZsON0lvqOO+98iCMndvPjb38B6wRjm05h/LTLaIQdhOqHbHrNuRz4+c2sVBmv/OM38JX3f5BDP7oHjERe8gae+YUPMTc5xsNGUP6z58GPOPxExcy3mixtSlHKc3yv5Noz4P3lBqbke3iR/t/ctHaZu278Gke+9ALu/8EqX9ilMfpirlz3Ji4obic/+wx2Z30+9ePPc/vuvcjkQvKZV/Pcl5zDY3dfw/ve+wZ2bD6JP//T3+LYI4fZdaTDwnCAI1A0G2wUBW849w1ceNErsI8v8Z3brqErKp524Uv47q1fJVENTtmykyJvIYWjOTvG7NqckIJqZeRjk/QrgwgJ9dDgPXiVYGpDlkm8CNQIkkxSJBI7NFTDAVLXjM/OMBz0yBLFYNBnZaUEmSG0QsiIsAmmxKHxzjMxOYbUGimh16sYuhIz7CGIMVKnipgtz6KlzNshtq5iTjdNCK6OfFql6JWGAGipMC7WIH1dPuGVieC5iCox1RAvY5IthEjgu/rDH/7/HNn+91Dp4Cj7nVFhVMaYkhToVCNttPbWzj9Bb9fEdI+WcU0caksdDC44dJKMED+xFxc7mSISu7WDIEFrnBBoVVB7aLXGqb2j6vQRISVN45Q29wq8o9loIoLGWU+3P8AFaA+HIAO5ilaoVGmUTkmFQNUVrrYMHRRFSpoqpiam6Q6HeGHZf+gAC4/tZzxPyP04M9MztBd6ZKoJQqCM4Z577mNFtMiLDAYVJ89N8eDBwyiVUXlJqiSLJzp0uiXnv/glrFrJjpl1NPqT9H50nOUjbc48/2zO2/AUfvVZv8OP9z/IXd/8PPbef+Wi07dx5e/+Dp+4/muY+W2o01ZZl0q2fmAHR++8F9Nu4H/4OX7w8m9x8l/eyTvPn+T3v+zIPp9gnzfJxfN9/mNTwB2E2ZMbaD2GUFdhz/g1Vh58B5/KChZu+BDb3nUj695xgku6m7jvm//BJz/yD3RPOQ9dbOXnSw9y2J2JbAx482+9mC1XvJDpuTFO/p2P8+V3vYU3/uQ7GO2YHU8xAhwG4wNzWcLJsymbz51g4fDnmF+zgdmkzaa5SXbsPMTiEcHCQko1XGHdhjXY1FAUvbjzq8DqButP28TaJKdzdIGj3RMMK0eWSYSHQc9SuxKpPXnaRAtJ6fs47VFZio11jEhcFAlJFihNtIQF76OuozlFlugRLSFQNJv0K4OlpBxWmDrmvJ3UJLmI1A9jCVWFFwFUSvglkGsEqvPGxQqjMViVoJMMLyQySRFSgFDU9TDC53QCKnnC/5MmIbKY/4tf/+3FWVY9JOB87D/6AMIFysqRJBIhNM4JZIhAo6o2OOFASFIhMdZGvYIUICypjrQ0p/LRYTqiCINwpElK7QJKQKsoqEqLx+ErT5pkaCHARMERaSBPcnSaYL2n3esQRKCuK5KQRsqBUAydxPhAq5EQVEpaZCSJoj+skDK+XTg/QCrDyuIK/U7slrY7NVkmEMsDZtfOUKTTDBb30fNw+9770VlGr1ezfmwKnTq2b50n+AYn72iy2jnCnsePYzpDfnH9tSTJJIPTLuLii65k7fZ5wuIJtj9aojKYKI5x2WvOoHzr/8HW+7jjli/x0U//Eft3HWepEjz9E9fysfd8iyM/ugFWTkKoBeSWz5B/7qU016TcuhrI93suPB8+0R3wjM4ADgagQCdXcf3+d/HrZ1/Muj96HXf9/hSbPv03vP7lb+K6PQ8x8Vt/QnPtdrZffipvO+MNfOXuM3noJ5bd9yyQphOc+o5/Z27zPFekgb/92Dv43a/tYVDvQ2E4ScMLtwi+t6+CoBjolE69yvHlHl//ykdptjbw7O2bOFEtcpoOHP7FL6iTSaqGYd0aQ69hccIja0ttu0zMrcH4QGehQ1l1GXZqyjY0sgRfuejrlIKiyMnHc1QuEZlHuwRvTfRwlg6hMox14CPQMklA+DquOFAkmaLIczrdDtYZqvYqNkhqGxBBxSA9ASkkIhi8AJHksbSt4rZA4cAYTF1SOkdZmfjWKEYaTJEgsPgQAzVITdZosdxeRdfRqK6UINFxg2HUkxwIeWtiKXmU8AnBY6zHC/AhQas4rfJ1HentIx9EiMlepIz/OC8kXsRIlPeSIDxayVE425MmCTII8jQZ0c0ilLocVhCgWTSxrhwNmizTRUGSZHS7A7ztR7ylzhBSotKURpFhakemBOPNFolUKOXJZU0qEpotxWDQpbNcszyoGNZDajtEpRlicpxszGPkGLJV0AwV/fYhhsGw0F6iFkNSFFIISruCTFu4bILVE21Om3SctuNslroSEyZYPnw/STjOvrtu4Nijd3DWBc/h8p3PxoWUtNjMnv0rHL5mldWJZYZnlDS3XM5T37iVV61/Ct/46d9x1z1/QaiPkqeWcuq1bPrGO5jfvJb73x34w4/D2ZOSzz6S858hpoKOnXHS6CensOXf8ubLPsMDD3ycGw8UXDN1Eec//23sPPNSeMNfcMc3P8T8b7wC1lzEQbuTnz7ydVb33kI2t4YrLzmVS8+dZ+2k5Jp//hj4X2HHSUe57+ETjEk4o5Gye1fJtf/PJIOlHfze1+/m8vGC+5dKnnl6IGkf5IzpNbTHPYsHD3P6BVfQc0PWJBW3P34Pa8ZSDj60wjmnr2Vi89nsXoXxPKE+uERtPSYkpFqR6oRUWwhVLDk0C5yMPFPnQOcpw3ZNHWqcAU3cN5rSInUs5ydZjnN1rC9aN2o4SYL1lJXHOIeSgrzI6AVIU48XcQ1SlSUIg0oUSiqUtyTB40b9zdrE+piSKjKrgsL7aMeztkJ6R79vcEHEbG0SSJVCSGjlGbWrIyTsSV2cSLK8hTUBLyRKRNmsdwaDjn9ciigErSrSRIOOT9RgLVUkAqGVGrkkfJy6/jKqJ+O5VOmcqrQEa+I31weUTshyHVlExlGJQNpMqX2TwbAbzw8iUDuLEFFjr9MUU5fYRKPThBDUyM2i0DhCHSFgxln6qz36VUl3UNKrLM1WQZIkCFnTQpHgmQgVIcB4obB6DLW6xFQxRmkD4xMpqpHTqypcLfEmcNcD+1j32H5OmZxjod9hbnKSlq1ZLT2PHO9w6Kbbue+RNmtnruDUpmR7ukpzPscW8yz87FaO9X7Iq9/8er5x3bV0kod49XO2sz9pcMejxzn0+Bc4/qo9HFF/xdlf3cY2Jdi/Glieho0SLjqxilhqEmiTrL+RnCt45Zefwc6T38qHLnoj7/zMNh790XZ2vvi3Of25V+HHX86WW3fx/PdPc/03j7Gyv0Fx6f/ggrNP5bxNgR995zG+9q9/TUM8gq2XuEQssE3BARe4baXimpZi9V+6tM40fOm0eR5fWuCUDZOcdcpmxtOTObTwKDvPOZnv3nacu297mJIh/SwlzwV57Witm6OeWINrjTPVyOi1LYkqyBuC5WMLTOY5fnT0cQT6gwE6WJKxFj5LUVLghpa6jjQHL2u8MQgvKHSGC+CTnNoYijxnWNaoEI3kASBpYKqSyjm0iprqZkNi6xpnHaa05Gkeyx7eReemM3gt4oPKB4yJTNw0SUj8L43VkULphMDUlpoYipEh4KRCqYjvGZQGFyJ/+UldnHneZET8i6+npiaWXRTaerI80gescwShQWe4qkJSPaFI8FikkAQRlWnWRlZLI5EoHd2ZdrSCSWWkyCuRgo1YJaEzgqhI8NTDGiPju39tBkg8Qml8EKQShBuQJgmNJIlLX1NhTUWpQGiNCIJu32DqIdVgEPt7xqF9jRmU5OkY62YnqVZKht2SckVEIhw9ijxnZmYDLjQQaUJv0Ke7OkClU9TGImRNXVUsOcWgXGFcOy5aM8tkY54fPH6ISRqo6R0M/DIPPPhFHvY3sbXVQNzjMGt2cu6zzmP7Zb+K3zbOcvs77PrFCR666zh2teLLn72ed7/tak553q/S37HM207awlgqeN07PP/6ZxAyy/IFl4LbT9JIuPhPfp8L33g1n9m7iaH8ER9Z+DZXfmkDf/333+Trwx7nf/Uf+cVffY3++iY//LfAdHkSZ/7ueVyySTB39ARf+vRnuetbn0PRpu0q1kk4fVwwmUOoYbaG20oHDh695W6eOZlzR9+yfU2T3XccwqYDLnv/21FH9zB51yFm1kyyUEyw99Eltp98AemasxmutPFiG0sncqbWTeBsl5W2IfU1TZ0QvCFPUsYLTZpPsjgwlK6OrhPpMVaASBAyNqeSVOKNxFtoFmnEaBpLUujYP05SqnqknPcBEwQuJHFI4x0BE+OqCIQUpDqKgn2w1CYgnUBJ4musi13NtGiRpQoFWGOjgn4UPUxliEt6AUgdCyJJnOo6b3GmwvpYJHlSF6dARPWBTggIBsMSYR1K5YRE4eoaZIgcHgSpVKRJDBQY5zCujqYlG8mfUki0iEhp5xwieJROCCLKjeraoaSmrh3BWRKtMLVB+hopFUWWRmeoiHRwnacRpWE93kRqgpApwRmE0hQ6aglxQxIV/S5SBqzrY7xFaEnqonCpHnqsrhm6LjIE8iynImVhsU2/tkxnbXyomZ/OaExNMCjXcbzZ48jAkHYOsFivYkPOUCQ0kyaTaUoydzrTW7exobvC0sISfvE+mhMZJ58+za6H7mBP1+PVGk4r1rG4eJD19STfu73m9vsPESrN8379tzn4/Z9z/2O3Mud7NP/5PXzgCxewNrmO5YUx7GMDLvvDErp7kL3HkBqe9YqTOPCTx/nPp88xfMubCBvWIF//F1z+wiGPHl3iWDLO9rU9ui/bwe53v5+zXnk1r3vvNhpKcGDhBNff8Flu/frfR7+I8LSQrHjPqhS89QUJM2OCvbc6bjloEangWUJx+csu5oITBWZYwLZnsPH5kwRziMP3HeRnJ1Y51LFs2rCG11zxbFpTc/Q6Bc2xTTzWTslEEW+EZYeJiWm0iXVD5wW9YU1eNHBaITOFdvHI5JzFS43WmiTL0MM++OjzSfOcsjKE4FEqYK3ASUVvWJMoHWl3IZ4P0zyhlIJURslRXfUoK0uSJqhUY5yjLitsGZBZnOz+UpKUSAUh4G1cnbhIPo/7/BBwIaCSFCkEzgwidSGIGD8tmtQCXBn9t0/q4izLCiEU0gRcVVFkKWUwhBEJQSWKfr+DNVGp5kLkqMQqmMTpLPo6R/0lISS6EfeMruzgvScYF8+pXqCTjGAtzaLAGE+hY9VHkYJOqcoBQhiGA0MrTSOTFpDOQSKwQWGrmlJmI+t15BTpRCOSnLLsMhy0o/IBcERhb6YyGlnG9FiDYa8LNlIUpsZb5LLJY4cNq4MY5vdVieu0SZxlZn4dg2wRJ8bYNDnF3n2HaUpJ4QXl0NBeOkzdfYTpwjKTelpyGWcSuosZz/iVF1C6Ve49+gAHGvtwYxvZntf0brsRtXiADfOw65q/5y3veiMvueI3WPr+g7z2yvOZOeuDdMUYL/7gMoflkLV/N8/xb9+BvykSCj/03r9D1prnXPkS6oUWrfWK1c9ezT/4f6X/1dcy99EPc6i/g4Nfzdny25/l1e9scuGY5tHjy6z+8HMc+84/kOmKCdViU+5J6j77K8G/LHtOv7ni7JZgfOcYzz9fsu6czRz76REeu/UOTvrNt3D/F2/gsQfvYeNjk9y3r88vji5xVGZMbDiFV3/oz3jqjgkOP7KXvN3BLWdMaMGwMojJgpnxdTCoovKCFJU5rBasmjhcqUTASoEMHh8U3jioLVVVkhXZE8zjVOtYakZEo7lzuNJgfUTmNBsZ2HhD7g965EUj7hxNHaOgwWJdfFUOPtrdEwFOeNARrZkkmkwrpBixm/EYV8c9pwSlPFowmtVE3WRtLEYoci2pKouUmiQN9Er75C7Ouo7k7DQT5KlGhPCEok+JQAgRY2lqE8G+WkVin7OoJEUHhQsu3m2I9t8gYjslgm0kEMFONniE9/HvEGKEFXSMNxvUVUltXLQ4GUuRxN+XQmBsj1aeYmuDyiVlHdB69PQUZuRXDBhbYoYDcikikd6U1HVNkeaMTU2TZQ1W2oss9ypkaJClCd1qEG3K6TjQpwxNDq4skncWqesjHF54FJlo5qZmmJ/byIapOabMgNUjR2n3JONJoDSWQSI4//TTeeoFp+FERStbi56a4Y7DFfdZz5HH96I2L6NbCW5pL8EKXvWKl1Lefgc3fPSfmd98Ln9yzSco0yYPGTiwGphpS8T75xm6Zab+/oMsBlh/Vs7L3/Zhxu69m7OuTLhn9xyv+8aP+PoH3sb551Rsr57G7tYl3HH/A5z050/nOfOKqRQ+cXSZ7338kzz+8Y8y0cp4ypaCi9c9jec9RfLdh25m383LhCHcehzuPRY4Q5dc+Z4zEOklLJ/yHXYvrHL9/7yG5tCSzjSgrrm7U7O6/jQuferLedVbXsD8TItVbziaNVFJRpUYup0lZqcz5jbNU7Y7VMMOIRFxH46gVgVps4AEtK3JZEZAUJuSgKXb6UartQxoqWO5XsW2U1kPsMYx6JekjQlqA808pbYWZx22rtBJbIZkWSRyuBEIrN+vI49ZJwSpyTKNStLR1oH4xCQSQKQQeGfJGzl1ZdBS4J2LVnY8NsYpCEqRBB97qBFqiZQawZOU5yIYrUwsCB1jd8IjlceFOEaP8lGNRqGTJFqqXUxfFHmCd2GU0VV4wHuLx2OVxlQlSSIISYpQAWNq0iKjroY4J/HCU1dDhPdgI9rEBYGWAWstnV5JnmXY2pBlOcFJGlpT+4jlVBAzkD4gpUJ4Gc+3KJIkIwiN1wWdoaVz9DFMXZE0W3iRILI8Vt9CyWSryXK7QgRFZT1lr00za+FDjrIJ1cDywMO7mZtqsmFWIxuK+UwwKBcZ2AE9CwdPHGP3vjt54WVnsOZXTmF+eowDRx+hfODHUI8xOJHSO+oZ9mtaZ1wOJ7+Z3fdu4xfyAb53vM/51tFKAhfnggvWSZ737zN8pN3me7tvZ+c7Dd/8S8kr3j3H9iv+nA+e9Voe+26T4hWznPzoPl70no9z65vfx/2XXs4jj+Y8/ZUX85J2xTlBcOeRAY1vf4+FT/410wJmpeKKcy7imb86z8zaHq86ZwNHXY8f3Gb4zzLw0inJ868ao/tgyYOP38TtPznG2ed6biotG4XmwAlHdVOfM849i/d/9J/YNpeTyAjXWuobpiY2c8ctDxMGNWtnZlFphZKCTgVVHX0kBokUmsmJFkUjwQQzkmMF6mqIlp5uu0eiJVon1MFSe4/yAamIpQobhyWmqkF0ET5S9lSejl5ZI3lOCxvXIELgREqaeFwaMJWlyDUoidLxcx6EwI6A5wqPEB7nzBNVyLxIKAeRqCAklKbCBB/3pSES4rWOgyInFF7y/wONmUWsSJCauqzwwsUAesLIMxibIWmaYH0YYe0zrACpIp5BioRgPcY4rDMxdaEjSc07HUfUUuBqMxIhxfJ08B6RR3ERtkIKCT7uV/vdNtY5kqLAulj4lioQVI72ARUkgxF4zNWGLB29ZlvAymis8oEsLbBBU5mKbh1AJChVMGh3YpG7OYbRKd5a6gCZStg4ux5lJsgbY3RMRVkO6Hf7DKzljuMHOZELGiLhzG0bWTOjGZyw7F8ZkLUCvlTcu+sQ9YnPcV9zlkeOV2yYmmXrumex9uyLKQerHOz0EBtPZ9dBx8TaebY/I+PVF1xBIy9YrBwzQrOoAnf5wM/LQ2y9+f/wlT81PPVvcq77k8f56Xc/wJ7XFHzxxDvxj3d432+8l499+Yvs/OuruXndHHOJ5poCRFZw14plenGZL37ldtblCesbDS7dsZMztp/E+Noej959N3W9zOnPPQkzNaTz2CrIit0rkn0n5viXHzyIHhiu+46nmRc8UCvWrN/OSSc/hb/9/F/SriVdL5mQEDJF0SsJKaw/bSPHHz7MaqdmasM01gVmZ8ZZ7nexQeCtYGq6Sd5I0GnkD/eHA6wbIpwhkZIijyJcLyIEOqgYOpAykAqPczXOWopWKwZkZCDUJSIVBClxwZLp2HoiiQ5aEQw+RBKClBlBhngsCw5rq7ixUBIRaoRwI6RJQCsNMiBwaC0IAipj8CISQdSoCFIah6uqKO+yUWki1ZMEfBV5HgljYdTBlAatYvQoUQprLdbH6Jq1DpVmDMsKH8AJGXOy1sWz5cg+FtOC8Y4n0gjorcsokJEhUt5lKlHOUNkomFHBEaipqiFJoihyjbWSIFOkjFiK0gaKIsFboml6JDFVUsc846g5gNKIJKJOTO0QpqIhBWOtMUISdYPjLbAGeqtL2AB1FWgEx/zMGHkxRhIs+48exNsOwXbJcAz7PcZdjaDBxtl1TM6uY7woufHhYxxtDyjrIZu3bKbYegq3PXgXe9vHaaYF27aeyfGF3Rz52dc4dd2z2XHaU9ndD2xcV9IyHU5L+6Rqha6dZUOjYOAsLadIheBV7a1c13opqnEDzzxsuOOShHsOvZE//PB93Nj7DYIT7HrbBt71R//Bea8+lZe9Zi1H+56fHqm4/KScc9I2n7zj31jqXc+mdYqdT7sYO72N/zx4G717BVs3b6T9cMkVp5/Fsy6Axdt3sevuRb78+TZ3nLiVVAl+Zb3i2GOCRpax/YLn8qwX/DrPeMZp1Et9Wq0J+tazb3GVmekWudI0dMKWbYEjh3OscXQqwxTjNMcEct007XbFeObwpiJYF1XtIeBMxaA3QAtPkkRAm0wkSiqMc5SDAULUZErhTY0W0Co0wxEX1nmQaYZxFqUVRSaQPqCTlKB0nJ6aKpKjw4hzjMQ7gwyONG8hVRKVI94+YUIIIRAEaCFx1iAUkc8swggs7UkbLVxtRgVxhwgW4ePZWD7ZJ6dzoJR6wuarQoIQgroe4UiQiBBdhkJKvIhnSCHj3cN7hxQicjsJI6ZnDBggJFKnYB1pqlAqQSqJUgkWi1KGsiwxzlIULUxVAh6cJc1zVNKgFhlZYmKf1AqGdYV3mmpYU+QZWkVHRW3iDjVSutMosRl6TGWRQlOMtZhqaeogGHTaNBstdIBuN36Th65kXEtcPcDn45SJJtRd0rqkMZ5iyjZrxgTj2SSt5jhWpDy67xj7Bz0OLdWsVjXD2tJ+6FH2P3pgpAGQHAuGI51drFYFqlVx7HNd0rkNpGdPYk2Pp73wxcw1chBdptI0Fg18zWRK8J8AACAASURBVMClLC96PvA336b7xbfz0je9ANf7Ibf8p+R2fsb1l/4e80Jz++4Ojde/kI3f/Ude+IKnsf/OHvvuvY9Tt+5gdbrmp//+Da774Id5yqlNfu2FF3LTwTaf+Ie/4cJnruVk16Rsb6PY+BQSs0r/Z3vY9fUFFiZOZkEKNp4yzcqR49y6qJldv5FTz9zE6z/wPg64jDQvWTrsOKhzFusetTnB0yc0E60xvIk//zpkNLKa4BxlLZidzZnbvo7H9y2Q5pZhP6C1p64t3hkIAkUSvZtakSQJOpHYED+o1ppotMYipcW4AElCquORZuiiDDrJsqh+ryNBUicJ+HikEiMfCkJQFAUk0Q1kagMiIIJFhoiBRav4dieJtTFBJHC4uLnIUo0PhhSJFCES+EIMLzhbo7VAythbflIXp7c1ImgE0e8QSWUBjQSdjP7BAnw9erVMCSikAk38IpwP1N7F85+zEUeIRqUJSIkPNVKr0d+vqa1HCCKKUEN3UJNoE23CIqIQfVAkaYFK0gjKERZrSup+hfcyng0HBiktDonSAZHGO7Wx8fXa+sCwNKSJwA8NNHNcOSQVCbVVjLUa5Gm0GNe2pL3UxlpBe7mHzn7pdJQkLRhvZDQzyWxznMNHOvRCiXJNFns9xlVOH4lMCjwJQbaQocdQSDpes9oHY/r4wQMsLuwGKuwNPe5Zeya7X/FCnnPedgQ95l/0Qhrj46TKM+Mcn772OtYfvJZH59bzv/7qH9kxN4/csIHi7R/iUwck6yz4zLF1Z4NNky/i2JEh//apA/zaprt45evP5sff/jc+8fFryRgyvWYNu9pDHt7zc045W/PgrgHVYsF5WzWnX3IBU0cfxNx5P5lISWcmuezcWRDr+PnPHmR+y1k85WnP4eLnX8D4fIOTPIjBGrpNuPn+mumm55TJnNANVKIka47RzOCMrRMcO1RRdoa0Uo+vDelExvRswWDQAyUYeMNw2CNNdLTVCUmzSEkThQoxUGKNA2eQwlG66N3J8gSd5zGZ5g3BShIpoj5eeHSQWBHdPc7aGGCXEJxHBKLKvsgIyiNI0DrBeY8bGdxRkCQxR+59iJpL5/FhtC5UCiU9BI0Pjn5/EMsg1mBrj5AJAo33Av+kGUI28g9s8AQR0GqUzBARUx9ElOsKEYWmSsWLJ6LEDdYbjBc4L0lE9EpoUqRQSBkvbusElXMjpZ+kMnVUwvmI3kzynCTPsc6gRAzfqyRBpineAyrFB4XDRQShrZHEXmCaqsgOlYLSe7pVDQHG0hwsWFkRnKHslYQqQQtLU8WbybCsUTICwyabCasnLMMKsuCwtUXpcYKvqAY9rHcYkWC7XRZWO1Heqmqms4INxRiNpOKYg16dMZXNMqUGdJMGLT1PpztkpXOAengkOmfEGvCB4dGH+N4/7OOmXDOsF2l/2HD5i57LedsafPGL1/HQJ/+Ad370N7nuaRs4anPW/uabcLMDBrd9me/tHdC47G00n72B89MB9/3TA6y6nNdffBJXXfW7HNl7L1/7xNUc3n2Up2zVBLfA3fed4JVvmmTvwYqf3zBg+fgiP779Th6uJIXfz4bHOrSc4MSxR5meOpmxzHHZ+Rs4/0W/QbJmE0c7OfvqkqaumQmapV7CVCVIjh5Cn7GeO2/v8Zwr1pIJSVNLtIbGREFdOYTyyCSuI6wzdDsDetWQuupgywHjrQapTmk0NYnKqJ2nrGuqXokLAZ0ovJDovMDbCp3Fm6qxjIRDIvJotUAlEUmplMbYWPiXI5uYUrF/IVSERjsXP/dCSAIuvvZ6FVWELtrHpFLRGeRDVGaOprnOOIyLk1rjQsz8uhCVhlKDkNS1iaid/+KXuvrqq//L3/zpj398dW3jHcF7G12GIURR0UjpJ7wfAYvVCOYcqzHBRSW8Gx2afQDEqLSaJCQ6jfROqeJFLqNXxXlPXfYj4U9GqkKaFRBi7EmqDJU0CDqlLKsoR3KOgCJLcwgOZ+IrrJI6Lp6Bqqooh30SIEly3Aha5r2nrANVZcDXSOFi0BmPl4JUeur+EGniaiaxJakQoCbYMDlBqjy9vqGqE5Z6FcfLaE+eyDQbxlpsnJ0hpJJNs5MUSmDLLq00RSQZVo9R+RytpsBl+DBBpNOCwCPkDGU9h3PHeOBBy9HFiqdfeBK/+etvoNvr8aL3/RPm1Kfx7DXjLFxxKROnWTbtuYO0q1hdPERx2Tm0ji8wtX8Xp6sG73nHxZjOMt+/7u/45+t+xsAHyixFNRpMF5azTstprwZO3pwyu7lJqUuO5z0WqyELC46FlYqVYcleu4Xn/db/4LSTJ6nGt1H5gvv3LHDLQ4vMtRTz05MkWnH6qTn1kX3s2WV57GjFOU9ZQ6rAm5JgKjr9Et3KSGzJxLimsjXLKx1WV9pYMwBXoRNFUaQ085xEp1QWhnVJtz+krmqcqxFajFI+CVImpM1i1L0cuTKTOIAMRC2k0jJOTAkjEF0MrstEROOAd9GpE+IT1ToXWydVGf+biH1M7yMpPuAJIlbNwijCFwP5ntrGs+sTIZwsI1Hql2ZBBJ5nPfe5H/q/fnJWxkUFn4j/w7KsUTKSDTyMlrABKZMI5PIhvjI6G9NDo4tSSBmXuDIagKVWSC3RTuEQ+OBI0gzvbIwKItCJpshyvBdxjC4VjSyNivE6UtdMbSDY6DpMG2gEJDkyRCI3MqW2EiEDic6ZbApMXVNVFU6EuIXyBh8EwVQoqfB+glwFdNxkYYZD+qtdHJE1KoRmLGshbYapjkE1pPJR6Dt0Mb0UlKTVbDE9N4vPJplKEk47aZp+bfn2T35Bp+og6oqqXsD4GRrZyVjVw/kSLRvUdjPKT1G64whxASHsp991/Og/9vCvr6ipwgzWttltxjn89SFrroYXIFGbn8ddrzmXjDV0v/D73Dh8IQ//5AbWHd/DBz74JlJvWT26j+s+/2lEHhBe0OtbOsslO0+aY/P6nQR/kNVDB5mfD8xs38Qd3TmaS0c4fqTDwaOBauC48u0vo7vmFNa3NnN0f4+FxQX2HNzDwzfvZ1N1GVN6irXT04QEzrjsLH7+0VtprF/LgQOrMJ+SUdFdWebQwaNs2LiJxaPHkIxTO0G7V2I9NAtFUYxH83OIe0xTeYytkNZQqEDQGUNTIpOEZpZRlWHEno0xPCkCjVZGIOBqi61rwKG0InhLcAad6ije9dE8XdcWY+1okgpaxh2oMp6gAlpFcZH3REKglAglcNZRu4iPVcSzcJwJxdfePEuRIXpthfAkAoKNJL//6td/70qxBiXjrtKYMtqStCRJ08it9WZ0J0ljBUvEgLw3cTomghj5NSOZDxlI1MhdOKqZeesQ3kKI8t0sSZAUWOtAJPEbp1NEko7gYjWuGkJw+NoiZfzGCw+1iruoNEmwQoFOEUFQ5BlpkTMc9lhcWmDQX8FZj6nrOGhQgixTpDIhVRkq1LFgLj29QZdQOkSq44BBpnT7K3QGFWNNy2pnldrE6XOSJvFDYwxKCWSa0e+3QQT6pWDoAhvXzLL/+CIqbbKxlRBWLUM3wNMmU4O49xLjSAGJSvBhiRAy/OAIrfGXc8NdE/j0qYSwl13f28/DX7mRW1/0Zjp7HC963TQ33G148dPH8W/9Pfa1BdPThle/9qW0hKfz+FEev/vL7G9r1PYpsqUC2T1I1a050Q7ce8CRtDbApKXVPM7TLzgV+ZDh9rsWefxQl7ZLuPSip7Nty0aw8NDDR1k8UbPgBvQO3sbRBx/iu4vLFOveQpkE1kwIwljG2BpPFYbYlQXStdMEIh3A9dsM2g2GZZ/VRUvtU5xIKPKUPPM0G3mMvdWWqhzinEArSVAyvnlJjUglTipq40iSFC3j25zUEklKXmTYekhtbTyfBosMCSIoBFHNoROJrMNo+BRGoXYL3oEW8cmqQOVZDLdIF21mQkUztdRUdY9haVCC0QolEkEEEcauJSihCCJiNKuqBinwT9bPGYgAXekdZhR6typBh5pMRxkLeII3UdCbxqms1gohMkQQhKDinwsOxIjeZ2u8E6Q6w9Q1takwLlDkDfI8HX1hNYOyppVFTaBHUBtLXZVorXFBgYW6iskfkVl0lgBxuJSoJF50aVybuNoxrFycjjlLPazxXkR/qFCkUoHxqHIVLRzC9mk1c1q5pm0DznuEN4hE0bEDKh1oJB6TZIjaYEJCa3wW11+kZxUPL3dYsQfJ04zJNVtI/RqOHDvMks8ZqBZn7LiAddOKzo+/jwuPM5ZXdIfH6VZH0Ol5eLdInmzDmxLCZhK6NOwU5y177q+PIVDs/uoJwvL3EMOruPt7PX71FZOce2IVlic4NHEGpfek2dm89OwLGQ491fAE9sB3ufzZ46Tb13Pz/XDJJecxLRocOn4z1//7D2mqOV7w4vVMnzLJHTc9wp0/XOIXtyzAzBzbtm/g7HMvQj56gsIe51vfugvXOotNO4dkMqXZMiwduoFbvnMKK50r2CnHaKmUua2b6S7UNIqUYdeQNBStCc3WrTNY6cnnm9ihQyvJWCsnSy1ZliAEVGVNv9unqgx5XpAkElSB88SLxwmc91TlgKAqtNDIJDZDEqljeKWuYrhBxB2lFAkqT2P3V4GnxtRDvPUR9+qj0U5ohR2dWZXSuGCwCMQvW17BxTCDGx2tnMcGR1CQ6ISg4zDV+xDHMCISCoTQkQctwi/B/P/3F2e0Tce4Xpal0ZHiIrNFEQelTggUIobH69hGUToFqZFSo5Oc4C3eG4xxcTrl4+tHHYaI0SBICY3zEmM8zsaxtBDxcO5diXUQ6hIZAkKnBBNfQ4R3FFmG0hm4Cikl+HiHlUEgbKCqBvSraChTQpKojKTI8CFgnEEJQVnXUFsmEklDBnySo4Qm1TBMArY0SN8nSz1FMyVXGUFCszXG+tmCE/0BTif0OosMKehah3YF4zSZyibZc3yJY6sDFtsVE40WJ510Bpk5QOI7JG6JGvBhgMCTJl3qYFC6yVyaUQrIQ5OiuounZg2+63YzzDajh5rG5udy7y7PbQ9cy+M3/Q7q2P3cvHsTW5+WsR6Dm97KSikYl57HBzVrdp7PhWP3UG2b40b2Ep65kem5bcx2zyP71m30bvsBY+EIxewF3LfrEPcdO5v5y5/GhZdsYHzsHNJkI/d/7d85O8k5caQi26LYNruGxZ3HGAymeeSnR9l31/Wsm5vnWDLLxokx9LDPaWdvIR0XHDx8grHxnCAMeSFRKRhbIMYUwQUahaI20Uo96Pcp+z2qYU2SpDFMgqCsDN459BNmgZosL+LQxpooCwqeajiM8VGiSzNPiAV/RXT/SIG3NT7U8bPrJTqJwHNkNJoIpWIv2dVxfSgVLsTthbMR0zNyYqJHKEyZxFifQuKCxNrYZIkozZi9DUHgRrv/J3VxSjxChrjYVdGeZI1FEEfHAAIVO2xZhnc1WmqEiq8NUupoBEZEz4qK+yfvR0F3KeIXIxOEiKc8ByQiUvqCDiA8rq7QyJiXDAJvQgzlW0MqJWPN/5ezN4vVLDvP85417r3/6Yw1dnX1UNUDu5vNJpuiSImkSIuUKIl0HJmSTckBkgBxhotAgILAEIzEQBDoJslF7MRJoAiWY8QabFmKSFEiw1Gc2eLQZHezyZ6quqq6qk6d4Z/2sMZcrJ/KlSm46+Zc1Tk/Ds7ee+3ve9/nmW1Kq4qMJKXiwUjR0WfP4MMG/ptK+KEeQ8h4NxC9w2gYNZZkKqwAo6D1AxGNy47JpCbkwHw1sK/HZZktK5Z9oppMMLpjKwjW2bM13iELTycFSSqEHHHrzm1euH2NPmeaZgvRTPj+K89zcP0Z1rk85ft+XX43SIKfE5NA6z3um13iFfdJCIpTzZr4wp+yP97BbT3C+MyMRjzM17/5ChN1wGtfuoG/uuB7z3yFcw+8lfeZhrOPnSe0Hce3P0fef5hj3sfH/+VX0OvIk+/7CNeXLS8dPsPp+z7A9nsa3vfonLF/ho/+7rM886WOt37wQ7zvQz/J/vZt/uSzL3Nn71Hmjz/IHbOmu7jDzoUdDlfXOHr2a/zM+x9En6z4/jOe4cpV8liw2DphdSfwyCMXuXO0pKkzx0NgsWpheYiygd2dfcbTKa4NCDzWKOZHJyxXc2JOCKmpqkJ6R5TTnFsPZCVRVtMIW3LaKpJcRwie3g2kkElRopXYNLcsSYI1suzuyUW4NfS4kFBGl31kmaCUsIrSZTfpf7inTBttyCaKqoq9DBJKSbQxG6CdxPmIQBf7WQYfI0LXBQoWE4NP//9T+N/14tRaEZNEyoIUidFv6PGptAlEKZ6mDFVjkaYUT7MwmxdfRY4JKSWVaYpXJW7uNAK0zDjncC7RjEzJSopSVDWVJeYOKSK60sTBb9wrA6aRKJEZV5JMoTRIAUkoRAqkEOkHh4iJqqoQSZC8JCAo8D+JyhqREmNdY2RCxEhWZXelRiPoIGrIyqCILHVGT6c0++eIXWTdBvpuzs5sxmgEbpDQr4lakq1CK4VPA0dtUdf3WeBTooprjhcLvr14hdXyhCwrpKoIuXBqcg70wwmT8S/QmPvI8RgtOrYvfJD7p5K/+M6n+aWf/Qi/9dk1l2dXuXaUeOmp/5e/fdfbsXLGhUtP8DdPTVh97KMM7/sw2ybBq7/H9Pw9hMbwe1/6Fl/8wiF3t2f59V99Gync4KmTJZ/42mf4sfZVzr9jl+vXLjLs3OY//fVf4S1v//c5deoMn7lzjWf3HH3u8QLG9UXy5BUOlt/ia599mrdOVpy/sMcT736QOL/DT71jh0uPnWHtINVzbl55gV4O7D18jmENIQt0pagsVLUA1zKsHbmuyCEjQgmSYCqMllRaFJN1zGVymsrRV+pMo+wmIicYsMgcy/DIBSozQvyw3pUCtmqQMlPJTAiRLARZKFwaaCQMidI80aowg4QgJVcGRFIiZSLHgCrJ9fL0M+qvnopQVoxJlEiplhIhDa73RCEZgkduJrvFRPY6MSW2qoghFk0fmejcJrJU1GUhZXIuwWApFEjDZni92fdEtC4Rq5RzqZ9Jg5BlitX3HTEERs2YpjZIVQSvWUoEiVHV4GOgsmZDZYtYVaJ9lSoDap9KA56Y6WNGSUHfDwz9wEhXZWqmLVIXdZuIheYNAaMBnxm6vkjnrcETOeoy0o5pfWDdtkxNRlpDFJbrvWUke0YiECZTrEq4XHGweo22dbhhjTKasVQcO42QEqEg50xjRzTasO6OmffHkDykgNWg6xnEHiF6lGjYbWZMm1329gxH3RgRr/HqyRFJvJX3/PyHGD7+X/Pay8/xyDs/wOrgp9G79/B9W7O61bO9POAdv/Qk3cTxqf/x1/gP/stfJE/u5XvPf5WP/l8fR+4/wuz+x/jOP/7H7D42ZTGa8IFzggfCgnZ5hT2z4NS9W9y6/zLu7B7jasQ3b7Ycp8DF5mVW953i+KVvkWTg8Utb3LpxnfPv/ikmO4/y+KOv8Pild/HQPffQjEd85ctP8+JLN7l471l2p47uMOFDhZUVphHMakNjFcPJkjgMJCvx/QBSMp1MkVYjRTnBhSRIPiBCT20yTaPISpBiVzLTWWByIqSEC5GsFUILpJEb0ZZBpHL601oVhZ935Kyw1YhM2kyHC47HakFKES0FQutiBTMVUvgy5JQlzK60xoe8AU3nTUACQkhI6dC5vGuWKGBxqkRRlISv+1gr0qbbgoQUCCljjcJWlpwFQxeAEmlyPiCUplKlnZ7DgBEJIxWZhI8lgWGUJGz6dKshIHPGpljuJMGXwYsIQCbFhMqJ4AI5C6wy+JgwKLQ19H2HQDI4XwY60QMGIwU+wxB8sT0lj5UWrTXrzpMF+NDiQ0DEsjKxStGHQO8cWkeyk6x9Yr2OzG2CGJEmcXqUoZlS19vcvvIDFovEZDJmGBIhCYIQjLXhaLViWu0j7ZhzF87y7IsvMq2m7OuapU3MZpqD4wParmNxcoCLsuzEst007r+Hqs5zsLzGkDXr+bc4pMeMz/OFOwY3eYDZfW/m537lTfyzf3KTcHGf6lHJ7/75V/m133gz/+Rff5MPfcRSr1+hG53htU7yR5//JNf/8lXUmSnjM+/l/q3n+ZOPfZmT8Dw//QsReVYzrRM3r59wz947uXThMcLwCkdij3tOj/jp+UC9tcfWXbuorZt8+s8+yY3vr3ngjdtcfmCf0eoV9k+fRxhLM44slocs22vUO2v2L9xDg6BdHjGe7VCFgbqGcWUQMpN9SwwD3TpANnhRE1zApog1nj54YrbUQrK9VSOVxPmWYehJzuOGRDWe4kIsrGNdCAhYSSKhgcqUwr2PmTAMhBRKFtYnUi4uUHJJ8GiRy59+Kqp6UXYfJeVGZoiRmAKmrhGimPLk5p0zxtIPTbHsTJWSBJ8IUSAohr6C2cr8CDLtX9NKsRqVBc45ooBm1JByOT4qa6lS2f2FFFA5FKRJ0igtibLkWnPMCCXIqrxA5xSJ0aGUojIScoEprXvPbFSXY2xdIUSmX69xIVFVpnxYpUmmHBcqY1GZErhvNKvliiwgxIDWkno8LhT5yhSavkx0fQeDw2ZJEIkhtGVdI2XZnw6Jk3WPli3ZdAyxKmyj3jMEh5GOKieWCJKMHM8PkWaLOkaa6Q5NVXPr1i2yVDTTHS7d/wSV0TTbNS5LUhvQnefy3j0kvSQNa+bLJZ0L+FiGBEoKYmpReC6ci6xP+qInN2Pe+faf4Ga/y9d//49IDm4P99DvneH46Js89e0f8A8+8rc4uP27fPI7ljt7u/zz3/yf+If/yUW6fJHPvXaDL/7xN6nHU+798R/nzh//Ju6DDzOp3sh3v/BFXqoEzWXLq1tvZ3T5x7kxjLje9izXJ/z0fsfEJLZ+8HneufU4uxNBvhy498Nv5fz4Hm4dPc39p0bgFHZ2ltdu3CDM5zQ7F7n08Dbn7tmFwZO7BV5BcBohJLuz3VJyjoEkM16CFqV2OKTISGSc93Rdj1KF0uizYFwZpBG4mOmGgb7rSQn8OiNVw2gyQ1D4UjFlZuMKUi4ptY3Nrg+eEBNSa6wBnSFSfv/WWLRKCJXRWeFjJrpICo7eudKI0gohDTGUY7DWBRbtY2FkDf1QIOmb6B9SopRg6By2lpA9WarNlOV1XJxSW3TKyEbRdj1aAkkUkVBO2MoAmq4bSrI/QUoJFR2ZVBAmOWIoDFwkuBxIudxNxqMKmRO6soSscSEyqQ3KaIa+R+oamYt23BiJVmNqNNH5EhFUBjEEkIJmuo1SihCGkk7KYFXZv2YRCztXZkaaso9CMGkqQlL0XaJbe3oHJ71gUit0jMjsycHT+TXeR7yC275n0hiwFRlFbQTdoNidNfS6QW8rYhTsNntkOQUTODw8oNk+hRgL0vEBUQ34+SFVKnWolBVlqJ6JacBqga1qxOgU/eI1Qj5m3t7iqWcOuevykzx++SzPi7vY37vFn/6Tq+iTr/ITf+uXeObz/4KHzs64eP5R9q7+Gz71/Gc4/cZ/xcEq8Xv//W9yfPVV3vsP/j1m4VGev/oZfv9jnyeFs/zyh3+Ge+865CLf5Quf+yq3XnuMd/1HP8eLt28Qbz3NdRHR1bv44Ht/kQuTA3S6zmTvcR4+fxEXNBd27uLCqbvoV9cYkqGuR+gUWJ68QCVh//R5cucZUk297vBBk6SlD0tSG4HA0AVkjCidSEmiYo9IuazNfERqg7YVhoJDJSW0sVS2wQeIri2tEFHh+o5u6MlZ0jSlUiZqRfaAAhcyyWqMGTbRPI/Midh2BX4pFNkHqloRc6LrPcn3BOdxsdQWf/g0ZKNXEEqXUE52xAjGVGU+Yg1y01iJEkxTnq7WCGLwlPb267g4l23ZLXnXEn0magUoRPJIKTFG4pwDqYm5MFz6MGwSGqnkbYVC5gGREzHkgjQBjMhIkcu6RQkqKTbHglTSRVmVqVhKoAW+6zFkpKlRVuJdZr1aMrYNGc14MsYaTbdeEFxgcB1939GRGU1GxBAYhoLMz/qHI+7M4B2ti4RswBiqBFkIEBUjBgRD8YTaEVop4nBMLzOnT59nJGvW7ZK5y3gmWCsY6Rn33H2OWW25cnDEslvhhoCqa+iPae+8yq0U6Ze3mK9XpJyxdkZFIERPyhEEDO55bl39BPPlK+RqB58zXRzz/LNfR9m38Bv/3a9x5dPPcZgV993zFt70+Bl++zf+kJ+8dD/u5Cr7W1/lI3/vnTTj+7hzeJvh5ad54m1v5+RTB4TZX/CB/+I/4zP/z//J6ivXee0bd5AvCPy9il/6r36Jz+bHOcqWS5Ntvvwn3+W3/4ev8IG3fY3XfM89v/wfc+rym5GmouvA6J690xexlcbUj1J7zzAk5scn9E5hpWRrNkGMA+vekU1DHyLrxRy3zoRVpplOQfSli4tG1RWT2iC0RooyXBs2QPB6pItxOgvWbUcYSqWr0RZTjWhGE1yAsRnRtY627wulPUZ8TDS2IUlP8D2IXDi0oYNU3kNFFoWTawwuFIKB7xf4riOS0VahdUFl1lVRSwsxlEmsEMScSm9ZKKSp6F2isqbY4EuIr7hZkqOpKn4EGfNHZ2s/8YlP/iO0xHVtGQsbQ04Jq8sOUYryg5TOKK1ASoRUCCEJfkCmgIihMGyFwChFbSvERmGfNmLeSguidzjXk2KPUpIcI8n3xZkYygXbtX3xeKbM4DNSFHqaFAohJa7tSuhYKHrnIXmstWU9ETIpSUKEEAVkWQLzUZFzjdU1QkhGZoQUDSoGcuwReUCQmFYKQ08bM6oZM7FTFssVR+2CACydY6In3L21z5vvuUgKa0YGTu1vE3OF7+b06+sMoePGndc4XK1YDQ4XEykHJGX3JoREq4ozu2dptGLeXmfRHpHV29jdfRJjJsjmXto7grOX9/jaAt784AM8dPeUR889xgOP7PH8C/8rf+fDH+ZtP/arTO2Y5797lVPmAm948jJu4Tk4eJnLlzv8K3f4qYce5NlvPUdw8z5SqwAAIABJREFUiUFN+cbhLezOPpcv/jSf+Z0/4C/+4I95/NELTA8O+fqXXuYLn/omlx4QzPbuYohz7nzjnxIOXkKPd1l3S7ILLBbzMlvoJfun95gvl0y2z6GrCTE7cuo5vnOdWd0gVM2gRsgN6a4dSrG+qSvqUZnUSqkwlcUaQbduaXuHsZYYAhKFwqKrCc1oRgxhM2OQkCUyQlVrhmHAZeidRxoBojCvKiOLQj6kvxoIpZjKcCc4nOtYr9fkOGCtLXVFJUmpbCFyjoQYCbEA1EWGRBHmykIDIxfzEcPgaLuurHZEyeN2Xcf73ve+f/dsbUqJoe0RwjKampL8F5oUBkIIG8lQidcZo4hZ0A0ON/SILDa1mbi5+2nqupDeEZsibci0PtD6gFEJoxXOBbQYEAmE92Xq63sqrQl6RAqekBXa1vghIbCs+x7R94ytIktDNzgkhiQSyhjIoE2FTxkvNFlpRJZoEtlGpC4pENoWkiL5drM3myBoyUGjbM2p6ZjRkGmzYrXuCMkxriesvWRqKmyO7MnM0c2r9MOa6BLdEYTVCiEGjo4O6GMJQiMsSIPNmS1dNOirMLD0AyJFhtgxlkumY8uyP6Rf/xm3ru1Qmz32L/4szzz/Gl98/vsY/SD/959/mi9dPMfe7SN+5b/5AE9M70GML7F49TtsPbjF2950nlOje/ncJ36P7a37ePSNb+fJvTG1fIGPfuKLVONdzt1/D1eqE06deow3PfQhulfX1C+8yId+4hLff3XN+a2aj3xwj49/8Rb/82/8Fn//1z/H1tkztFwG0dB97aPkZpd20EzOn+bkRFLp0zjnMNWEKCrIkfnCs1h7er/F8VGmGhuMFURRoxBYHTEyI3JfMDhVjdS21K38QAgtXZ9xqSzw/dBRmbqwY41ES8O89XgXIGRk9gx9efdLaUDahhBKO8kPHTJqtJakqiLEcsFk4WnXK7QGNziKIr1BaE1tyybBu4J5TT8c6ghB9IWJHBIbK5khRPBh0+E0iioCIm/ihrn0Sf8t//4aeW5D8B4zmqBUAWVJrcrdSimsEth6TEqRGD3OR0jFQxFjoksZowQVhYYW/QauFMKmm2NRFlIuR+Pee0bWkmOA4MvXCHVV0/YeFwNGGWKUbI1H+CHQhYHeB4Rfo2gQKiJiwgiNk4reC7RIkIooqdqgS6KoyFmRg8eqhE+gJXR+gZaeqtmjshOOl5CHW4hmn2pnh90UCCdz8Jnx1gVSSPjeceHcPlp6/Fhz5c4CgsOT8e0BN48OaH3H0vUMoirrpuypRIWXGaFq9qbnuEsrDteHrN2K7CH2Au0S56f7vDY/olIB177M8TP/FNncyzKusPwlb3zovaTbx1x78Tn+0X/+Vd71jnczm5zh+OM3sX//hPb2EU2luXJL0OaX+Lt/9z9k+NYnuHzK8aZLguUDu3zXKabqHj74wY+wX0/5l//8f+elp7/AI+cEj2SNOgwcTgM//7fHfOWLA88c7FI99zJnLlXU9z1I3h2hZg+SbzzD9rkHqeUd6p3zLNdL2g5uX3uFrofrtw+pt88y2zJUpiEJyeAS63ZFGDJSW1RTlZmDChgV8LnYAoILaFux1VQMvWNwbqN/LG4N71qUiIjsiMFTCYmLPXFQSCuJzpOkREnNer3G+fJ6phQYWXCWURRVRMiJ5AIplUK+taWnHHJEisCQHCGVXX7MRbuYcsJFAEEOiSA9Q0ggyumQnGFjSKhtBZgf9cr513FriypP64IgaaqCGfHZMwx+E91LDN4XXpAsOm+TU5EZCUqfMifati2tDlWCAAKFi5ksMkpK8gYQrLTAdRGbNdpWBS9ox6jk6Y87gpU0RtP5DFlQKYkcTci5YtX25GHOtKrL8VpZ1sMaISSVkjjX0a2WZCExNuB9QAfPuK5ph4E+t4xUwlZjRjqRNIy2zlJvnWPUaFI1IgswbSIk6DrH1njE2rcsV6/hVyu60RytKrJrOVi17BjD2Z3TXD28ShczWZeKXBAWKUBJTcgZ1ISxFlSjBScis5ANXZ84WCyoVKYRgS2tOCQxLJ/lyZ3I8/MTzjeaKy/9Du9+4/s49/6HuLnKPPO9L2P+jyt87KmP8a2k+YuPfwztlmQjectPvp18cJuv/OvfZ3ZG8iv/8D1855nbzL8w8OAv/yJ/ctPgn/so3/3sH7Kde5ZLxcnKsTfW7J8IPvM7x/TLzPTcVfprJ1y4+4BU7XPzwCLWz3PmTKEC7F36MbrFdcIwsFz09IOgHk0RtWM2tsxvHZJDYr6YI01NPZkwrSQxRULqEUaQlKSPER89XTegcsRUI1IUzLYapJR065bVsmO9WG6m+o7gHFoIhHAgA1kqou+ZjBr6UEIEWmaEsdRVg8gR5zpEjPSp0BCEKntxXY+RyoAIaFPg6iGBi7qwchFkaZBao7IkeVfsaBmELHyhoqWPrAdfjGOoTRKsBBte18WpjcVWknW7RoRIZSpyKoGCymqMEgTvCkg6UeJ42pSQb8yIOCACxLzxGaqKnEpZOYlYjqyhJHNU3RQHhs9U1YzoPVJJAophPicLy2g8Y4iJLirWJyuC89R1VTTfUpGJIA0+yjL4SYLZeJ8hR/p1S2g9dTVhXGVy7OlighRJ3QnOOUJM1EpDGDhYO8aVYHv3HNFACAMIQ4ownp5hlQ7Yq7Zxwy2mMrKeH7E920JXhno65c7tmyS5YlVNGfnEGoFREis3gth6ghQ1JhuS71B5iTZbeHEKhoAMPVFospjgcialO6zWd5hVNZWIfPvqU+xbwcngubIe+MODZyEHqmaX3VNv5eoXvs03bz/P9//ZvyA0f4N+8TG2R55Lp+9nS0957OEn+ORffoPDpxJnq56/+WbNo49m7vgTvvPqTa7ujnnl1WOO7wTe8rYL1Gf2Gc8s2wc/YHZv5u7dlrvesMXWJcHLt18mtttkX9PdbNndfzetSwQ54cRd57hfE4YGoUdYYXHHHbFrQUe8k0zqjCHgU8SnvGkWaXwa8G2k9x4joWlG5cbmQtlHZotVCttUSKvJIpKdYDQZkUKg63xBVIaAnYwQRiA2O8hmXP4We+8xBKTKLNsBkiMJXUqRopQ0hIykFMBrkiid4x/2lIu0RBJ9qYNpbQkxE/sWLyXjqiaGSM65pJikAqPogsfakk56XRdnzLBc9ViliC7hY19YsX2HrQxJSaq6xhhDTJlh6Mg+lnCvLBM1HwXaWJS2RCCHcjSO3qO1pJqMiLFMzWylyIMjDB1IzWLdo4wtAQYx4CkxKbJHpQGZE2E1kEWmqitm4xqdG1atx9RjWjfgho7BRaxS1JMp3jn60KJiT3SO6AsAeHs0LhG7IeKTwFaG0WTMtFYs1wvmRzfYGp1munWaOD5DNz8kK4GRlsHdxiRPnRR3nTmFMJZ+PcN3c9zqkE4oUJrdyR6NmRJ9z531HaJ0NJQptaosud5lIqesvWZ+8Awpr6gwVGYLpcofpI6O3dkOR8s5B0Pm8tma0bpl33iGBGs/5/qVz+Grbc7sXWByasb43JQXvwJTm3jpuaf5g2dvw/HTvPfv/Qz/y299gmbd8nd+9T3sh23ita9z5Ttf5/s/WLM92eXik9vc987HePLSGe4S17j8+B63bl/jB6926Ice4yBW3Ln5Mq2fcG57m+U68cKLz1FXC6w4QeQ9lKjYmeriKUmZk1u3yNlSjSbsNQq/mfC2q5a261FGMp2NEcpR1bas5VKia9eEKBjVDQZBChHQdIMnx3KcreqamBOewLrrYFgyqSVuCOjc4IeBqhoRfAFOB+9KQTqVIrbrU3liioTWovSNlSjkxlTWgSEGYkqlVkbGJNCmGK+FllRVRVNroveI7NAiE7IvcLBcAGDEQA4SVb/OJ2ejIAqFa5clwqcsVkI1bhAygSjkvb5fQynHYOsK7wJ+KImh2siidYgD3keUNMicMBKMsaVYbRVCK9ZDgqAQKSJzZNLUhCyKELVrgVjo22FAioSdTPHdmsrakoUUgvmyRVaWKDPGVgghsGOFFNAtlgyhI+bAxFqQkSwl0qgyjPIFJhV9pjIK17V4nWi04OLZU+xuncfHzKuvXcGvTxhNTxNF4NTWhNArtrb3eeGlq0y0p3UJkcakeILUmqaeEbuOtluyM665UO+iBSjfs+47wjBn0Luc256ytXeWFJZcPXmREBcEH9g3gomE7WqbtVgxqhR378yYXn6cycnn2b1wjl4/wK7suHr1CvedP8+pey/ywqvf5Htf+hJnpxU/+/g9qNM9L718g6vP3qH748/zoV94kN/+377AH3/iDrV6gbsuH7LXV8zaJXWj4JYhvnqT7z37LKN3PML2ve9k5y13c+7oFbZ3JMdrSf3oj7G9fYqDbzzL6YefQIcBd+d5lu0xq3aL8dmHCTkX4Fq/ZOlaTF0jE4w16GrGcn5CTIksKypj0dowHo3w3lFbhZQj+rbQEomBFEprKYSIjp5+6JhOx4S8QbCGnsYaghghrcVniZQ1k1GFGY84OV6VSKWpCLFHGEP0gsrU+OhACaIUSCmLTUzkog3JohxNRcDWFiUEZEEWxczeNLpsGkgkLQtRgUT2oHIoMGtV4TZ5X5FfZ5+zJGUj2ko6F7EGrC16Nuc2/cxUHu9CFuegFiCCB21LG52E7/tNuzyVuwaljxl9ojIGH3PJQoaMkbowZXQxkxkyMWTqqqGbz6maKdVsiug6kIJ1tMQM3dASUGStiEik1lTa4nMZZGsiVaUJTpP6lm6IaFNR6cTYCJQClzR9dogN8Ld1c6ok2JrMqGqNrkH5zK6ZoycKoeboZkZltpivlyy7WPD99ZixSKxD4NR4hm5GtK7mcFhR15qqLvnR3VFm665dFi7z2o1DrHuFU2PLYCvU7YGRzfRkPJalgNlIs3RzfubND/Pp575PZy3i5Bp7p3cwdkz0rxCT4K1vvJ/Tl6Z86jOf4k3v+kXGo28zrOb8q89/m/2tH/Dhn38XlnfwjRe+wZ9+9waLJdxpr/NCepa8ktw4uM35keCNT85QowapJPe/90las83hi68yvrlAnD/Lzs4OL9/+NrN730fSe5x+YhsVO9zJFeozD2LXc9JC4Ic7GDnl6I5jCJkLF+/iaL5EJAGiYCmVzETXo73EhZ663mNoC8BZiBExQVaZetSU1RqUCzVlNI5RBTl3VHVNe9xRExg1Ej3dImdJ0k2pfUlT2EJC0nVrsgbIpQxtJFIBQWFtRd+tgLLT1LL0ip0Lhael5V95UnLOhJgwRuH7Hm1qylQlEUOZPptKE3xE6IC0xeMTfURG//ouzihK0TpLxbhWjKqKEAfCkBBZE3JZvJrKlgxijiQBtrKIPJSiahYIW5MZELFgT9wQypRt0xgX2kAoAxihNDGFMj4XGkWAJBhWc4y1NEbQ9x2EgSwNPZmUHM5FjBY0tUWYprygC0FtDCIlYufLlDg5stK4WJozRkt6YwidJ7mBTCKqkgE+uz1Gj0YY4Rg1DZNJzShLKjclXJ/TeY+oJGvf0NGgaxAtxGGJFXBhtsvpnSlGe9YxMRsH4mJBHwLTyZSdUcf21BBOEpO6xmTJ2t3mxtERy+GAmZU0doqTU1bDCV4pom04GU5z+S54+PIe1zlP/+IL7G4FXjs+4ZS+i3tFy/WnnubxC5d58Qtf4f5Htnjbz72fP//9L3F8+DLPXp3z3CvPs335LGa1xB/eZn045/qnvsXt2DM/dkSZufLSivpUw/evvgaTh/kbP//znL9/ST66gqumXHnpmIfuegc7e+foB8fh0jM/uk3ykWaSifWE3bFm2YOLitQHzEgxxBMm0y2EbuhO7rBatEQfqcZjQgwoDVFkVj6TO0/twaei8ZBGI2QiJAOptI6s0SwXC9bLJbrvqLXGZ0NFxtYT1oPHakMQsvSIVy3ODUym49ItDh4kaKtxPiGiKaECa5GADAUOJ4Use/ZccuLBR3IKhaagJEYqqroCbZEIoutKdC8UaohR4LNByIjYtFx+xIPzr3GlxIj3kVFjCvgohw22fkPd84VKNgyOmAJVVSOQ5JSJSRRmbWVRvhjFhhjxLpQOm8ikODAMGXRRqFVGI2ShlHk/MAwramPIKJTRuN7jhnkBPfkAIoHShJhIeUDkSBwSrhvY3t/BVDXBB/p1B0JSzabISuL7jqFPOO/Lu0AsEUDVzFCypRo6aqvZ3z+H8AOynlCJTByWHB0uWbcdHo1TEaFnGFUxkeXz1DrQLQe2JoppXZOtJGRJZeD02buwp/dwQy44Ryupt2bs0dOvM6vFihvzlhAjbzq7h9eWK8uOgGFvb492vWTo17x4+Cr3310T9Ii8GJju7hLiMT/29nfxvU98Gbd9htl9b0KbKY++seJk+Qrf/vwnWPVLlqLh+VXL8Tpx8J3X2JpNeffPvp83noYn7r7Jv/nCDV54tuPNl06zuzclBcuFhy4h9Hm++Ed/yJsePs2ZU1Pu3LpO5xzD8QJpZ1x79Rp3Xr1KvXeKOzcWjCYZtw5U2hFWHcmcIaxX1Nu7rBZLmpEFD/XYcjRfEEJEREk0iZwiQ9sh6DB2RB8Dk3GNqWqGrsV3a3IY0MKVqGaQNOMR9WTE0K5YhvKOKo3Ax0RVN8UPO2wmv32PEZHoI3azIVh5jzUNObZFs+DKE81lSURitWGIqbzeJY9EoOtxCR0kT9VUaLkJM0RXfp4vtPgfOmqFkKQUGTdj2nZNVVl8fJ0iI5UdprYIURTckPGk0oHLEERxHWYyRpvygSUMJFRliwIhF4yEC6JE5FQqxGvKwCgOHi0Upq6plST3HW7w9IMvmE1d1OLt2pVGey4E+iEmaq0KQrOyaFkwmDFBJTWV1UCkEgEhC+JTG4XCIH3E2IDLnkjBRYx3pqxaTyUVZ7Z3qauGqgKvChMm6ob50ZwcOnIzg1DRtyfYnDk4fg2tK3ZNTUqOyc5uwV24FS+8eIPpbMbd95xG9iturnpG0hQavrQMuWbr7D7zYHj5zjPE1Zz9SiGM5mh+wLZKtKkjhxneC9qYeOHWNTo/5eatE9Tuw2xd2OLm964yrWe84/3v4ZlvPMU03eH05B4euPh2vvPUU7znzZc5MHBur+bl52+zaFeMmxGP3/0IH/6JN/O1L/85/+2fXUVnz+lxTXfsOLSCqhY899odTl74NGKxIh+dIa4dFx59jPrC/ZzEjvnTf4ERih9872nuf/xBDq+9CI8+QGUyUvYos8K5w6J2PLnJbPscCc16FVisFpysBvCeUZOY2Qk5GyKWvu9xfYe1Fct5IIk1SkTiJnqnpcEmiTEFBj7EBFJh6gaBQeTMaGeH+fyE0Duii7T9QAoDURcxs65scfi4QOcdSmly6EEZstyY2wdHDmwM7BEhFIOPxSKgBLUtvdQQYkkixYiPisoa5A9hBKawiWorif2SSkuEX9EuX6fISIlESAO1UYQkWTtfMrI5FbdlXUMoBmCjLSkVjbbIxbwkkIQkGfqenItnxVhd2CwxoTaqeL0R2/osyKLslJqqwgePcwOu86Qk8DmiqmKtVjniSWhZeLgxlfa6NRopBbnvUAKsytg6c7xck6P+K6CYSp5aepKCLnqOVnPGxjCtLLUCqRMnywO2ds6SnKBzkSFmpDKY0Yix2uak8ziXETEjwhEHK8G9Z86irSamSMSyu3MGZS3HR2ts5Zk1kFPg5M4JAYXKina+Yt311JNt4joyDy3rteNkvWRmBS5IKivo2iWLbgVijA9bvPTaCeebOQ+pjNkZc/XZp5mjWB89z7m8RW/A+o5LD4w5ffEsoyuWg4NX6HyLlSNmZsTlMzNObv6AV565xuNnRhyuPX49IH2kPV5znYDVgdpWGKkY4hShHS7vIFYd012B0HuMSNy713Djq3/JaP8CN1++Ti0VkzMzJvWM+WpOv56T4ph6XAIauqrIRw4TO6q6QJbbdcd0ootmo5JEkckyY3TxYvZtkRRpwOVI260xMmG1RmUYUmZWWbxLTMZjXOvIoQRgVt2AEpp6NEEbTV0bhr4tzZeh6Aen4wasLTIuY7CilKmNLn4VKQqHWYRCN8hCkci4IRJSYj04MpqcAn5IjEdNMRb4gRgLbiWIgMqRde/Ynr7OhFCMEWNV+caiwjuP0Kp0IKUiZ0lGE1M5psWUGNoOmQVKGUAWlENOeO9Lm1wbEApTW1JpZCO1oK4tQllCV+4kMQSyKJCxujFlOe0jvU+E3JITNBaU0eToUGpTig2QomS97qhrix7VuAjZBzIBpQTCZFRV5EbedXgiTW0xJJrKslysiLo016sYwXuG7IhqoI2B9tZNTuYegWK61bC/dYG+OyG6gJOa45Wnyo69M+eoJjAMS27OjzFCEUmMUmBvYlkPgZP5MbGXZKmosisnCxmRIjGXmaMAO7Jh6Jc0tWLegcgFWDyaVGzZE/xKYP3A/qkJy5dfwPeWxeKE9773DUTd4tMjzN0Z9iZX4UQgYs/2uR22JrtgK06SQtqK67cXtEIy0TV5VLFShmZyCh0Si3bNbKfh6kFHXB/RxW8xHmmsctz3xPtZVbBz36O8eLVle+siMWQ6ExlevUU10sSlw1qJUJq+W9MOApKkUoHzeyNWfUQ3W0waW2YZZJwfSgFfl2molhKJw4iMMjN8yqQY8MJia0NedcQsWC46Kp0Y+p4+lH2lC4HkWsazXdKml3l01CMJ+CSoq5rgOrIv+W1jLE1tyN6XdQp5A4NOGKHQtSmvU4iyMx86cspUWpOlwki7YRCJYqsTkslsi6EvR/iQoRlPIPav7+LMERCWFAZUpRFNSTZgFUaX/xpCpDLF1JViKU2nLDCUULCPvnxAIMSMrhRaFw6uTAlpFNaWVcbgA/1QMrtWK0QUjEcjhtWiHA5UJkZPbS1SlpsFQ0uOHiVUQR8m8BGMkHTtAilSQShqWVoDKSKULKjEJDD1jMkok5NjtVzhQ8LbEWY0QQrB4WKJGBKDWyFU5NqBozaa3gVqNeLg+A6j6jzT7bPE5SGtS8zqhu3JHj4bzEiTTaZxc0LqMbZib3sbup68WoGaUu1t4X0kioDrEkZqjAp02RUbVYiklJlJh5xOEUbRtXNaI7l5YJmYHQSW0WgfFk8jhsgVDLcWMy7sVshuwWc/+Rzx4hPYrSn2+is8+cQldid7LE4Cr7z0LRyBvf0JeSgWrqWdUE1OM55O2VaSLQNL13N9kXjo/kfY2W4YDq5y6uwpTm1p7iznnPQV22dPMZlqolghZU3SDfPVCb7zjLYm9F1PCInFckXvBdujEXZri+hbjPd4lYlQsrEZGAZUdKQMcxepjKUez4r2A08aAj4MhDDC5bLOiFoyxEzo12ipScIw+ISxDYmEVRltNUokfJTEKIh+KMjXWCqNziVcjKhEuQCFxNpCdhQocoyEwdMPBZAtUkJJhTEWZX8IAMvElMm5SHNj8EihaBpDdg4hBS782y/BH93nrBqSrNCjipDChtMjSZRSqSiDKHpXsAw5bmC7uQx1nI8lxqQN2kqy3jw5VVnBhOwQIWKtRqdc3ClNTQ4OfETpzOHRErKnsQpraupmhBUZsgIZEMpgG83QOpzzJFH4L6XkqvHGYLQmRl+MwoDSiqTKaH4IjhQL07QfMj2K7dkO0ijc0NFHVcq4IXJ4smAIgtCv6IcloTkFQtL2C/pBUWnNaBQxriMlxcg4pByRlGSxKD4ZoXuOfE+dMypnzuxN2do7zc2TOQtvOX/hPirl8fNjCDCWnpdeOybkyO5kjJv3jOrM7aMFs8ndhCjZMbA0Nd/+wQH7d11GzeZc3nuYg9UNeOoKYessy2WPvPIsV6++jPQDaqS5eP8Zrr/wPXLXcN7skvZOcW5rD60N3dJx89YS1y7Ik33WrecNb3oL+fnv4xcHPPf8De6/f5969xzz49v0PpFcx/l7L5F0wuRIdpn5/BCVEqZqaI+XdH1LrGuENlS1Ro3HLIeOWhsaq0m+pW97fBCoyhZ1HyCExFpbdubekYSkj4EYBLWpMbpG1ZaT5YLkBiIRQkQxYKsRWyOL8I512xK1wMRNekgalFXIFFnN14waU4wA0RMHh5cSpUsLJYQSVNCyBHRiKlDzrH4Iiy5NLaMquhAQwmMlaFUo8TlnRs2YGANZFPVIfr19TqkqGmvofECbUfmmGdp2hcgJa+yGHDfgXYculHqULgXiRDl2iLzJEKZYQM5alXoNqUxx1y1ybPCFGk1tDUOWmFQykDEUIWptapJPyM2UazyuCYIiSCWQlKIZNdS22SyqPYIN10UBOmJkhdCS7EPJQAIpUYRHZkTMlsW6o64sYy2ptzUiB+4MGRehzh6PY2Ql47Hm5PAmR/NI3exgZ2c4c2pKOJlTjbZKfNFItLHsTbbovUcqQYgJXRkmtUFXNcfHh/TLQ0Y6oU3FqhvYqiqm0xGhnW9I4gofVOHjuIRWmio5Tk13uL0Y2N6uiNJR24yj5rtXr7F1a8Gpt7ydRbcmyZ6Lb9hj0VmmTIh1hWrg/NkZs1Fk7k5zqzfUumgL5KlzvPGuc6T2hOGoZ3Wwwrk1D7zhHkJYMd02mNOnWDeW67eO2N2e4Kod8toz2xnTLTMiDSQfiK6jW3VUjcCFDKEmBMV4KhlcR3YJsmfdr6kbg9ANVkLTNAidNsGQDdNHa6yxuJBoGBeUaowslgODawuAK/RUdeEWpwhSBKzKdEMqnV9X3Jr1pGEY4v/H2Zs0SXYsWXqf2nivu0cgAbwayObUwhaS///XcNVCNqur5dUbgIwI93ttUuVCL1C7XmAFkRRBZgxuZjqc8x0I9rvHuJ2DtNTnFiqImK9wov9cHAgmKEKsd4IKQRsh3wi4Sug8DpZ5uxZDYqlQSgDJrNUJEtHgOuCU/mh4buQKt/W4vzmml6y5XhgvR46AklIihXTFMRizN2yZ621jxAxCMGafjIslKuY3nzLRqWjcCLY4vw9UErf9Ti3B94kp+a1UCkhi2wpLB+1opBS5f/uRcrwv/cPnAAAgAElEQVTApiMgsvsA1eRyykwIAXIk191Tx55f9DYgJEooTCZrDWI39ppJQRg6ycWopfLDj5HXV+dWM4RFkhtpdm65cttvlLrx62ugUriZ0saBnJ1sxuMtUw5j6cZLjYkQw2COX/j15SaC2/sGKUF5I+fC1n7l//sYSElI3Mnbnb0r270g1U0FY54c8cbNFqEmuirH9/9CTYU//Yf/xM//6z+ynSev2JkvZbsV8uP/4Nu3/4vHz9/46/nF8evBT//0v7Fz8re//Mpf/u1vrPvke038cKuEN/hf/vQf6eODfn6xVWP7h53bP/6J//Jf/8oP75m8vxHjO3ZRD7UdtHFyDqOEgsbIa3UswPPzg5//+R/R8Ulvkff7nfPzi94Hz4+J5R+ot3e6BuiLJIFt3wklY0AiImacbbB6x5YRRbndEzFGGBBT8eHkMkpNMBqlBo4pJAyC0ZtzmEUXNjoL/4gsM27bBgS6GlOXYzbNs1Gctue62pgDttJFmjfUBAXGVIIaoYSr9buTopBzoHXHbMaQ/3iy9SSRU6HGSkpCSfD1PCkxu5PclK3e/BuaXKQ+P8Qs+70RXnOCOMnMcFaOulIWU7eEWVACnd4a5zRijiD+uiJQt4qkSyRsg7kWbU7qficG78lySaxpjHGQwubugt8CkFJEcBtcqjvWTgJGrYVc70TJMGDOTt0iILxa489/+zduj8LzORkjMHTQuse7/fRIfPvpn/mf/qf/kTES1Bs6Tz6b+IT5eFLz4LZFsi3GuShlJwSl2+DXU/mnavz8tvGlmYGvj+KCeYmk837DcufsB99HYHu/8e3tjZUKb/edLCc5POgLdClSlJoqVivy9iMad9qcNJ18//O/8s8/VP7T//m/c9ri//nP/zfPX/9CfvsHfj0nXY1nM27v/8TLMn/++ydQeJTI3758vxxDZj1f9FeBbfL+7WeCLL6GIPOLVCtHW4S6gW48fhDWeDpGxDJ9KDUXgj2d/xRvnGPxakpvJ1uKbBG2EjlbZ64XJWW6RuJcmA5yjNTyYKug7ckQ8+pnRac3NrdwzelT/sejehk8T3IWWu9ORFCIQRgLQnVRzBiGXmjXtSYxZSQExrJLqtdox+llLSDi3mIAU3UI/exI5ErSi9icnmJgRj8aa3aQgBCBP+pKidcXGALjaMQLV9hac8i0uIIixkSMgaaDuQZrLWoJqPpNZ2uhc3garymCN9XEQiwO8219YnQvBcyFxGfvSEyU24akSOunJxoHcIdoIpYE6gQBtcAyn/D2PgjBCYIx3YDIXNDPReyfJBa3fSemwL7tmGTmAGZDkrAs8Xkuvj6fjPai1B9RbQiJ1/NFLe/MKQiLOTtfr8kjOYc0FaGWGxIfjPPv/P3VSKkS337AYgY5kQWDTIsZsYWknfPZCfZBX4P9tnEYjoLMG2zGaUpS5a8fX+yPyM//+BMff//kcV8eF3AcPMfB38fi7Yc7+bbzL//yL4z1K3/7+DuPb/+Rf37/ZP76Z35ZGbslenjw8bcXpSrrdsdu3/j7X/5CKDvv7+/8+J7IHPy3//ZXSt746f3B9njjeSyeHx/s9xsaF3Yayk6RxDpOCJHZlR+/bRRJmAralHR75/j4zscvJ4+3H9hz5nh9cfz6C10D24879bYz2omuRd0SpMwKiZIyW9wcAtA7Ogc5mVMrYkISmC1aEo7zyZyNx/1Bex2oRCYJEWG/vTHOzrySp7++Tu6PO8RADl4lxQh2OnB6SEIJJFFiCEjMV0qYT80RIYnTPqZNVIx0EUEUPCYkuDagj4WYv+Zz+P/7hw7nWEqSTluTFBMxCIFFLRHlinOXK9HL5pV2beRc3S+Hr2MigkXnhDqcaRJFHTqN0v0KY0uZPhdRO9BZE0qp5HzjOD4JOgkrIpKJORLDBe6SQDsPQkykeiPkhNkkhkgI8dq1NickxMAMYMEj0Pfs4ollIEGYEomSyEmoNfF+fzB1kcR4JNd0hpR5f3PViWrgX/71z2SpFE28fXtjSUdsI2ajDeFszluNuaGmvNonj2qsmPk+FnY+0TgZ/cTGybkG/3UNnqPywZ1vPwc2e/D8/knZ72yxsFdh6eRv3/+GSUPe/oEZFkEy7//4T2xvP9ExPv7f/8x2F/75/gN//vzkr33yz/9DJEXj8/PkL38+qBIp+mJ/fKOHiG4/IevgW1XeCszXwfueaQ16m3y8fuHtp2+OQz07Uzt1wu3Hb4wR6K+na1XLjb/9/a/csu8Dt01hvGip+yCGztlhrMEPP77x2QZp35nN9c0peRoAeO7qWstJ+pcIRpbLSHMsxBxYaryGiwzm+eJ2v1OTI0GebbBIjKGI+UR4rYt8J4U+BVBuF61xzkXI10R3TILhyXjJ1WpjLfRcHh0o5ul7IsQtoxPGWITk3OKcsq8TzwOVwFiBZL7DVf2DwvfeG2M4DqLEiNpi9Cdm0fH0BE5VIsujF8RvN4ffm+95gCzJ6WRzwuiYuN10qUvoVFwiX+rds5CSR6qtCMrivt1pR8AkEXPG8Bc9hIiI/5fg+ySLCUIhx0pMLt86euc1GhZ8v1nrRpLMHIPX6UyZEEFNaLNTgiB5Z9829sc31jgpuWKnctsz6xG5//iNr+fiOAfdEm+PDaUhCOvrEysvck6U/I7ZIq4noQxGLqhVAifHefBcxqaTEgYRaDMiKfOxlE8p6P2Nx0+VOg9CNN7ef0am0MeL0z4JwXj2J+1vixrvLCK3f/gP/PXjIP7rf6Wsybb9xC6TvSv7+5/g7UfmL1+0BqMlrERMA3kYMk+SDGIpiEA/n6zWqY9v1NCRGFk2+WqHr7OobDWjajw/Prjvk4iLAo725OPXv8H7jZ++/UCJjVqEvjIxCB/PD6BQUoFS/HIeioXJ7ZaoNRFi9pWGGCkJZ/ds2K1Ecq6sAV/tiZzGuhiGYsq9FpJc5eRMbkuUQB/z8otWNBlLYcdFMaUUSqnY7Kw+ISdiFN6Sp7ATPGdzrMXZDljDs36A2/5AiH6JmMf7zTEgJkQiw9y3ZSJsW3UHjgXWHxW+h5Sx2di3TM6ZqW6QHsOj/5b6LspzgQ3FVyhiLulbZuhaCNEnueIkBQyWiXOIVFExjxYP0Eb3HafZNdF1ps+WIt2CO8vNONt04UHyb/i23enHixDczYLAlMhkEFLg8b67SD9XcszYFNqaTI/ohjlAlddxcL5OclXMjKMHdChLX9QQqPeN97cf0FKJW+Shga7CFg7O12RJ9BXU+SttZKT+SAyFmga3PaBRCLpxDmVZ5zwOBKNsxfdnITEQXmsS98KeuaSTwuPtgUbj4+PgPF/cDVSNc/p64Z/++SdievDr14uYMp8ihHkQv77z9vag3Av1vRDFuD3eKNKIPyrNhFQ22gCxyVv1pDg9nkwWsytzds42edzfWLr4y7/9SqkP/uEfdlJY3G4/EID3ojxnpN4Lf//Xv3DbKkEWx+s7divMFYgx8vn8RBXut516e2ASibPTjomua1JvQggb6fpQ9yvtLlyokYBgyUiW6K15itgFlTvmSVyBuqJD0a7hYEkR00UMnTHUd+QxeHUZ5ArD5XeXlYmv3paOa4+/HMtpy8UR5igeUad8hBAZOphjOr4kePI1GDlGhEkGTNzJYv+dI/jfj2MoiflbsMmVODZHp/VLbABXhHz0yZj4i7YubImIOB0vRlcRia8V+ujMOZ20vnlfGoIhwSnbQQQLXraFFZAcyE6GRmx6tqFGxhqkdAMCFgLbXsml/D4Vfk2PO0hiEN2bV5PAGrQ+PT8xVUwS6HIAmTkMe87JX3/94OgdzMhmrBhpBhoCabvx/rhDTBy98fo0qPB1HowJ57Px46OyJ1hRCfnGWI00G99S4IyFEu5kM25i1JwY06Pr1E6+emOpcbwOTBPrdVBi4uv7r6w+uBeHraVSPHfmsWP7nf3+J9LzIKTC27c7z//2K1/n5PHTg//5T2883itdM3MaH88nEpWcH/5z0MZeI0ky59fJ+fVB0IyIx/HFWuhr8vk8kZjIt51SHQEpCLW4gEGj8fXrr9zzYiEUgbUCfRiv1xNDiSkRNF/IFiczrinM1Xl/e/NczbmY50EMgSXQ+2S2k33fKdlfudk61k/ivhHHdENETIwZPSZwXHEYGMZkmVKTx1Ku8yQEI9fNjRimgM9MVHBywSVY8R3+8rwUPKUauMKkBdXp3swQICT3qy4HU+ckjDlY40o2yNFZukGI8gcPpw1X/Z+qBFHmctq1qXLFh/1uGHXAkeMY3Oe5kHiZU/FMCeX65ZmPq+NVj5vgZlYTgsJ5NH/9LNDPzss8QSzWwtlOZl+kKFeTLwSiM0m3jVQC6+oXsghJsmd4rquMmMYakz6Hlx9joAtisss2FC4M54s2Xldmm/Dt2zsaE7fbHYjoNFL2G1YuHqnkzOvo2Jx8HIuQF3lf3GqmaeQ1OsGMm3RCH5Sp1FJ53HbMFh/HoMYIs1O6MkJg3wr3t3e+lqHnibXOrUZ+/OnBmkr5+Z2vY2E1M88X+7fAqJX9Xl0Qnj2zdA4lhEIOmWWV1+uLv3998p4zhM4cJ++PSoqBcQ7O40kwkLXIdSO+7WxiPF8HIRRKzrz/8M77fUNwTXQbk3H+einAjLcff+Tjl++c53mF+hg6F2HLFBEWBdluDFVy6Igu3t4flLJ55KMaEgZrOZVxjkbJkVwSyvLM1+DCgGGeIpdzwqJQuGG6nKtM99yUpayVWMHQMbE5IAVS8EfFxkBzvtjBXqIKCR1uN4woGjxJN+XqEZTm7hb/3CshZFIsmKUL96nkiPNwg9AHhFg84Cv6DOcPHc61FmtOttuduTpLhZh3snXIydmcCGKGmidkYc5bcSJtciXE9Y3FmJ29Iub5mfLb0MhXGq135nlZynIkpUJrL46upJxgLbR1xIS0RbDlE10iKQhtKudaxOCDhJQcrlQkEXUxpvI8Xsw5/fUfSoyCBaX1wWyHS6rGZMzBFo1RosPCUibGxH57c8znfmP+pu08B9YbKUdaMKYoL13M84UdlR/VYdqf/UUumdfZWK+DvUTeHhs2Jq2frLGYKfJ8dfrR2d4KWxX2Isi3PxHOl2daitPOz+cXMwAhUuKOSaRmIUniXhynESTBVNaaoJO//eXFSD/wep1s+40QjXG+YJw8Hj+xFF7HRFQpt428b2z3d1ZKjHGybFDrjoTMo27sIdPbgVpHQuI4vrg9HgwNHCdMS0jeETFaFwaVYNXxqWEQd7vCsQyJxn7zv3vO68IGT5tek2CDFLNfssO3CAEXxIerjVrq4bR7jRxt0rSBTnCiCCo+DBJblBwgCGsNFyk8D9pSUrpAXsPzVoJED8fl4mSpT3lt+aENISBrISFc4OhrghsCSiTEQNDBMiFHF1EsmSwdvpf9I4dTUmJ2p5AHcXldiIl0CdaJDnM2BR2ecp1S9AxDE8by11CAMTwPRMyNzL9JsiR4tIMnTiuY51mY+i27CCRxTeO6+le1xbx+CFECrR2Emjm7G8P3mjwGXoKHHQUh4Oljr+alT+sTHZOUBiUH5uw0i5S6kXPl/iiwbRge7JtLJpbszvxSybc7/Tno5y9oP8nRiEz2CF9RkJwYYnzMAWvyfqsUHEL26+uEppSaWNo9XUuNKPB8ee/az4WEJ0s7t2z86e1n7P7g+TGZ58HHR+Pz7GhODE1YD7y9VcI60FLRdRL64p4Ei5WYMssSv3z/pIUPYk5U2wlysr0VkmVsnH5IWNzulbrfSWUj3N/9Yvt6MS1Sa2Dfd77dNmRNRu88P1+UFHm8PRgdLFbOr845FzELad/QFVkGH08l9uE2qvOkR+dRpZj4/uGDtFpupJiYV59nAWr69zZITLDRmeap48sUVbc2hotCqRKwUBjq2XcQCcGT6AjBk+PU9/HLlBjj75N+MYd9zwEhRsfyBI+bFFN0dkzdi+nkyYDhoLu19OpTr6Oa+Pc/j4mUr6Hpsmue8AcOJ0RSzrR+Om4/iNfji6vnDMjyH4QgxJQvqZOCcZEOfKu5LLgsLEDiGmWbIfgrigg1Jsot+7Rs+YplL9G/AZ3EXCAIU5XRT0SUUnx6O9eCaw/FVVovnahNbLpcaykomTHd9L2mZ7rEWK6clYhaoNaNeBEUchDEEqluqE0kCVv2HkLMZYDWv5jtRcqJEmCLwu1+Y9ryD0wplNsdbXB+PYkBRjBeOhETcsrMJazlWRslJkoIXoa1AX1w48RKZZXIn3+Bj0Ppatzrhmjhlm/M8zvHZydsO0iGcXArkbrdCdvG3385+WiQ6qLGgg2ltRePxxs6Fq/X09UveIxexmVmx3HQ+6KfE9NJzUZMSl/K0U6eXTl6oCs88h1tgzEXTKUPgzW53e7c7nfOr0ahMcxQiegQskTUOsPMw6+ufztuGxLDhQGBqcDZUKDERdwi09YVgQBtdi6fNSnWCzvpBmkke8yG+awhBKEPJeKCha+2SHmj1I3enoSUGN0tYiLq8PQA4tYPh9WZQIgMFSBcF4m3D7bUZy5qjD7xlA3BQmJdbNul/v//ocMZRDzCOySXOWHo/G0vIx5adOkcUk5XurT3l7aULJBzoq/AbBMLsPRKGZbAGMMZPykgqbDdNsYYqGRiCsTkL8tvxtY5Xaw8Ziea28V0+j7TX3AliuckrunR9kHc0iYhUEpg6vQDVxIzLFKK1Fp9KjiNuu2ksrtMcHW27DjMGIwQfQg1l6KzUdONmatLBmcjhknrHopa98QukaUTqQHLmS2/u2Qrig9GUmSkiOUdrRWmkZawS0d1p9TMxzB6D3w9Gz/sTpqYfRFFqNuDPRasDR6PxOtYPL++SKMxNVKC8tM//CMpulDj9fyVTsJW4OPjkxwGSRazv/j1lydxNLa7Q9XmEMowyIs2DlYbBG1YFBYeRNvak/NofB4nORbu73fMIocu+lRkLtbZ2d435lRmVkoQ0h4Z5cHr7Lya8oi+K3RL305OAdNOb27sl+Dom9dz8nyd5AIjTtQKMUPvndc0vxBi9H87KjUoSQaiLkwZqxNSZfZGqBli8nKfAGkjlOKvtHjkPPLvr2xOGU8Eu5LxSMTgVMWxlDb9bKgukkxP4ovRVUHD81KWCUHVL3YRxljk8gdFCL0PUi6Yue1lrOXJ1ODEPL3qbQmeeam+VzGW9wExXYMej+W2KaxrSrWucsTMfIJ6pSiGAKVsjOEmW1W7IiAG8zcKGovWJ0Xk+voWyRJzKMIkFof75nT1uOY5GCKBHAN7iayYGEEJMVHyRi07qLLf3wmpEgyO8xOJgRgTootads6vJ6+m1JDJW+Dt7Yboj5wpEnUwz4P9vnmAqgQfkhBY4q8BKbIENERWyKxQqfs7ORZ3QZyVW6nU7YGq0LtjMv5+gL0W//bryUC53QukQpaArZNUAnK4XeI8lO3h8OK4bdjIPD8/UIy3W+V5HrRzAINv98hcA1vGqaDnRNVzbFqd2GxgvspI2ZCSWBbIOTPO78wOSYR9q6RceA5fT73GwuYg4eSAr9fgqz/Za2KsScgZOz2ucdrElsc6IglVlzeO0ZGUPXEN5/c0E87jScqZFcTjHPtizIleVI4YMoGJrsVWK6/XCeIiBX/71B+eAKaBqfb7/jzgoK4+lbglUJfZidml+BEP3yrurBLxP299uaBAr0jM5OXxMhyBEyu9uxY4pkwUFyic/Q/6ObsJWexignril8RMiomUrm9OPJlpqXmI0DKfVEX/hVoImLjrwGvwiErElqNKCNfuc3YWSq3XUlobbQCxElMgjI6JkNNCI5zt+mFc8qc5hwN/p7KCYuNF2G6MMVG8xJA1kNXd43mJ9XN1sUHJGQFutXgStxpTDB0nFgIpFMQW2dQlWCF4Olo25Md3Wnthyxgjct9vvInRTQjZXw9bHRDimtRc0CVMhaaBgsDojPOFSiZtb9A7x9cnKe+spDxH5/Nr0SyRth1jwhROdWHF/sODpY0QA9o79/uVS2reC53Dd203QNsghkk/X3zXSApGMK6AKKH34duzPrDsh1HMdaQ6PKp9Tsc89uE2KA2Lj68nbQmPffNDp5m8e7X0OgeDRU532nCVmIkyZkPFcZLbfiNGQ3UwmjOSb6UiFlzqZspcfhCT+TojbJWp6/fP0+wDrKFWkFSulw9MGzG6sCKEQDTD5kIQQvSUvCDqlZaZ958xoCr+c5y+FlpqjpjhenREfM4yJ96BBobh0/wU/OewJqMvsEDeEib+KpeSWP0PTmtvt5tTBlKG1QmSPMsiRT+sobrsTYTZr9fy8nu6vdqtNUvd7bHWNZkLkIqrSuYamAWQyJjef86rh00xYzldL+Vy8XoIlGLoKuSQCBjTIoJQSkWvQN/VByV0UNeNLHHOaXRqEEghJI8b32931mpgcpHmnSuUY2GZsuXI6IP1mtCV2+3GUmNMpXH8LmYwm+QSOGbjsd2o9UFdHdYnzMFa/uHZUkXulXNMZvQSas3hsRaSOebkfH2g2tjfKlNPFP96fvhh5/j8zmpPzuOglszbLfLDLVDtztGV1xi8NPEIk3UOVi4sMRiTr/P0llwbt2yMOZjqOSIhZOpvw4rkwVXH0cg5IwRCjAQxhimv18nqi5TdSjXn8L6vTbDJFndHxkjidq90Xa76msuTAgSvYNpgTSMEYYwODHKChDjScipNDywk76NZpLyTgjFno7d/l4S6GmhdKWCgwwOPYsoEjJx8/6d9gQoh+AOj12SVAOfwHjWGQMr5kglOVlB0mSvTcJH7Wn6pRbw6AxfXxAs6l3NBAuTgL66/soItL52FRan1jx3OnAIrJARxxUTMxJSY/STGhF47zxCD60xNHT3ig10PmAmCpITkhNgiiJDi1U8Op5jrVNicC+Ra3MhYUOrm00z1qewYjYnnsNR4jbjV80Ysuo1nK4Vo5qVOH7ThwwdSYiuZfb8hFHo35uzEUMj5jqgweuPz+Z0SEzkFjj49d3QZcxq5uv9PEjyXwdNRKq05L/U4vf+NMTl9QYwgkZITsXfaGEDA5mSE4IZgi7RXo72+MBNqzcx10MfTPYBhMKaCeoDU+9uD9jzJFbI+2fbAfQvMzy9en08ONT4/P9mWELaERsGkMTmwNaB5ejOtk5Ki4onOeUv+oU/F7Xn5RsqJoANDGcN8SJRBxmQ1JZVK2TNn94V9ioski3FO7o9E642wQc6RPQtl2xA6xEjNGR2DkNyNEnJB14lJwix6jxc9KWDiwyOLmf1tc4HLeGHTl//LBF2GruECvhiveEBDwft8gqvR5iCL82ljLJdXtCHpypIVRdIG5q9xCOFKDSvYagSJjOktiw9EF2qGxMi2Z2yZDy0Naq3Y8hd5ThdH+ItrtK6kcIV4/ZHDGa49zXEcLnmT5HIjiSz1ctRUUDMyQr8EyWst+lJS9dGzmicTBwXMy4Dfbrm5HOg7xkkUIUYvQ0qqqOklgnYoNDFh5slQax2soKT6IOVAN79EkkCUCKUwljFJ9DmQNchc0ixR5JreTUcEMWfALDiczOA8BsfrieRMTC5uyPuONkdYmMBYEXDQ05onrgUENWPgIKqa7/QJYpET/4XMdtIloHOwNDCmcJ6dlCLw4l4z223jfiu088kcytkD4VTKJrzVO+e5yPfCj/eKBM/5PHrktOnzgT5hf6NsxXeu84RxElNkf7zx/v4NZfB8KedoSAhst52QKrJ8ktjOF7pOmI5ERaC/1uXx9UoEKcia3sbMkxwTGipnO11emTeOPlEEHV/c3+6s4FLQdp7YGGCujIoh+MBrGitlaqzEUj21zoTVur9EOZDKzuqJfn65JC/tHIeSL6G7WAD1C3irO2NdqzhdEH3FN5YR1Fg6sWnMNYFEyj6wDCIXV9Yn6bb85YspekS9OBxgzknOmVKLV4tmJHO53hJltJMY/LExga7TE9NSovxRP6cE/7DGVDD1vadJIOTKHMtvtwBjdHR1MC9tYwqE34dQXjKs0QnmNf3s7j5PIYI4UiQAOh0z0lojp+Av8ZoOFbuiHc6vkz6BkIkRX8WkhJhP7UzUy0cxlhhDYfRBlMmhQi6eJVqrELY7Y0B7fdL74L4FHu8PMOV8LWJqxOD6yH2rzODJ20ZnCztTxT+QKRJSpr06NhqThXbfr/Xqogvg6muCv8Y6WcuHCzUJK2YX8OslHN9u1xS6M9oXrUcfsP397+QIUTsxdPrpmuV+KBZ32vlF2t/IMaCh8GqNrooQ+DgmP2+LGhe3t3emKSE1+sfi2Rf9eFGSB1itOR2QdVEMt+SxGKowJGBL2U0Yr5Pb9s5rnsic15658Hq+yDmCBs7miqNSIIRKKTtfx4s1xu+OxhQSKXo84m+km6hGEXGyRu/eGwchR/O1nhR0ZYiR1iaG7xO3nFnjN6War//WdTgzk5QrEIgSkRwhFYcDyL8TO/zvMi+1A/QxMITIhWO9Bky69EoSS56eZ4IhpGi/N3a1FEI0n33kQljKHhIQCPEPlrVzTLq6TcaWXYvyhQWBKJdCZrDM9bciEYIbWMW8ZEoloqNfLhbFlvecohBMSSIeHJMSXY2v54FIc0mbcOUpGpNAEiEFIebNs20v0HQJfnHU4JO7bm78HsutPlGu0kOipzqlwrbfyGnjdZyMi6CQ48bqjVQShEkMniaVUFZrkBxEFtQB20t9BH+OJ5WOafeeGKH3RoiZORsWA6v1K9bcXBI41ROZ5QKP5UJXUAt+y5uRzLk1EnyI0I4XsiL1vdL6yX1LfA03GrxeH8T7N7RDDx1JQkgnfUzQxlyT/fFOiAZ6cByJGDaWBZYE+mVeH7mTpuNoFIPgmTKKr7jK+41YAp8fn2jMJDOO44uv8yTFyH4rzLV4v2+QzKVvqogKooWjKWE8XVa3DIlAzhzdSfw5F7+wMWo0xJavLiSSk3j+5pqwvEXaauTsPssIttAZoGZUJkJk2yMS/eKPMbOJWwjtYs6WfCPGiObM8fXFvnmLBMLr+aKPBjaR6zCpTnR5KPrJxE4AACAASURBVHOtFcvXzGVOdLh/2ExIe0Vt+WolBiRAjBkJhmkglELrjtP8Q4dzIB6JbnL98l7subqHsmTWcvKZqoe5SEh+KNcEM1KJlCBYykg2asTx9BIAYbRGWEay5XTsqydIdUeDOyTG7LShlHoZt6VcZIdIW0KIhVwKKQSG/hY800gXdGlId1ZuTMSYPNJh36n7To6BQGKkgo7oBtvsKAklIdGJ3jFFxnGSspPTJNxJIdHwr/toDTV3yo9+UPJGud2JKfFqje9fjbmU27bx/sOP9HLj8/MT5sTmi2MqY2W6CqdNzgU1ZnI0WMpxnpS40dukS+f4WtS6sRA6kz0XYmhudO8LKYEVPChojkGtwnEqPzwyZzs5cqK1T3LqvNR4toVIckdPSpzdNdUxJFKOlLBIIbLEmK1TLWIkTDK/fj4vg4ISH5XWB7e6efBUMHQsylbZ68aQjKq7OuacpFz8kscF4Cbzd7fJWvAcE1mX+TnEq1xdrkvdMnM1+lhOMsDB5qqBs00kREIQypZ/PyBvW0Es8Xl2igxsQutuDI9RiMHlmODOq96bbwRWx5iEtDuitZ8kc5FDTokUMyN4/s2YA1Hh0EHeKqVk1uiMOZHs5baJgwJcfPIHie+KK3x666hEjqP7ODj7bkwwx9OLXpmFk0igZs87EZ3InEQSE1i62IubtF1bLLSuPqpXn9Rq8jY+iFFK5Xi+vIYvhZQzY4Yr1CaBQYkCv+2Zpuc7lpxBh2t0DVTFY+ZjphSPZ6vF+xvZEyElLLjB1gtloW7Fs0HbSSYjxbjtFRW/XL5/flH3wFYyiTtzKUj2XxhCub3x9fEr7fVijIXGxCJzujONmgPLFkMXpRa28s7ZF0d7sfTkeDZsvxFC5u3bD0zNNOuELdPmIFsg6UC0M6ZwtEUbn6QQicFhU8frkzG7+y7PwZcdNBSk+07RFpJ8SplEkBBJJYIkB13VzJ4TeoW8jtnp58GaGz1EepsMDdhQSnLe1LYV9pz4/uVVR053vwxLhdEYfaKiTIRhkYqy5YRo4Hg1N0/nxDkWAbs4U5OtJPdj2kBUUTpjTdo5KduN2Z3saMsYRyOkQMmZdnYk5otC4CKWmqNLfFK6ZKIdSe4UwRY21wWFPt3FkpMzicxcpZR3JEYcOemDMlPzlq8U34nig9K1jLN5RZWCi2nyrfgeQxKt/8GBkOjAa1DBLl5sqT7OXmNegyGHfxFcigb4dNQFtyQiQxtrTtSMszvWXlmMOcglAy6GNIQtJbeNXXu3lCo1BSBSYoVb5WiNIIHehiv/P9rvPXAg+qon+uHrw1CDbSvctu2CUE/O56e/9CH6z1hgmO8Cn58nMRVam+y3O2bC/vjGYIIefDx/4WhKLg9a+8JWYNji8+XSu1gDTTsLYd9vjODGu5w3JLgKBd/y+gBGEvueuN8z50jo2GgvR2wMnahtHHPwFitbudGO79h0BlJcQsrep/Xlc4KfbjuaDOs+jNOmREtMC66xFVd8rRWZw1uFt9uNSaRPNwAkjJp9drDwlLmje5n9XjNmk94O5lT2krHlLp/XWKTj6Yv96ELw7X4n5sj5b78Q94e/SqqEWh1DcuFrUnT5pxrUWlCBOSfPPlmaqDW7TRHjPBqtDWxBKf5IzKvFmubyxDYmpp77GhC++knMiUe9EctGig7iYk3QC2aXhLEmaxnffv4G5vknY/i6pBTnC4V4ITNN0d4x4jUb9vDfHBLn80CDmx5KyYi5VU1mQ9J+0UD+4Mu5RZCaXYdqGZvmBAPMz9O1ShFdTFNX4Y/OnEZMTjmziEuwhCsE19cHwZz+bQbneZBTZhwH931HphLi8l9EDMSyoVNdefJ8cpyNEIwt70jwGIeUK7Ek7HLI9LXIIfC4bUxz7kvdCvvtRkoBWZ3WfQoI4qaFFHmdjWmDihCSYXp67OGW+Ph8IuI0wd6+83oqJWY0Z6y7dMySYnEwtUMpoMLb/YbgEsccAscSTnNYt6GYToJMEIji/eJ23yhFEI1MNbIpkcgcBzI9Za1uO+fnB0sKtWyY9ivmcMBc5Kw8Hu88v3+QUqbuN/8aY2DqwZiuwlkxsm8XnFAXIVxu/+cXxEAQj9WY17Dm2Q733qbE/bbDRclrAfZaaL9T2Cu3e+XVT7JFXm0S7UWIUAJuF7Tk1IDDL/tQhRDHtQeMLkjog3F2+iyUkskBsMjsJ300NyOETKqFdrwwFfpx/G7Y6PhQSWywh8AYJ6GI7yRzpKSN0Z6u/+4BCwa66K9P8v5wLIp4xSgS3NoobhWcy1m18Rr6TRPAf2fjOvAS4WgOd0vBmF1JQQlJKOkPyvdi8pAYViGsiSWYy5e8pezM7jtIxbM1ZztdQqVCIJFSZamPqB3rZa5H9AvmkjDB/f4gqhHMI8WDGCkswoVE/E3lPy/Pnq5OXAGNriHNeYcQkZjR8WLOF/t+o6YbIbhheVkglUTdfU+mXZBxMp6fLBMsQBueQPX1+UGpzhaCwO3xTrO/saYydBCsgw36XNT9jVw2pi5+eMs825Onmi/oo/fVuhY5JsIcROnM2cE8xU3EzQBBDiRkSim0ESg1UnLlnuEcB3xNtE0mk/C20Y55Tc4Te6582Ysa5QLxdl7PRqyRII2agHRj3x+IGR/PT9oamEHaKzklNAa3P4m7MLR3gixSLMwrF2SrlZcqvR+EENhLdeqFKJQbsRS2rWInvL85RWAB4/hg9siWhZf66my/PYjBaK0zjk+yABRGqNSysaaXrmv515Rq9fXHXJgsEi5WGWp8nMPB3ybM4ZDy1/Gi5uw4ymJE6RjBq5Y+3TQv8LjdmIuLoGHubsGHhhkXs/heM/mLaUZIhYsyR7hWaXMtJwCOSQji0fXB9bflms8Y7vnc9uoXHi79+0OHk1gZCl3t8m0u1lSiFOY4GXMQ3WbsEjx1SdRciyAT0eD2sUvIsPpEA4QslK1iZXP9pCj9dTKWqzrqXgllo27eD74uRMRkYRYJUxnmmM0RgtsVQibdFsGUPRUi6XcBgO2RYQope2bGhUAxm5SS6cv4PE7O4VPK++MdM2XPxtcx/DYei317UFJmL5WgcIzBKUIexu3+jp0fdIt0iiulxIg3H2DpmugYSHBhQztPjtcntWTIQuuD+y3zeDwYVOac7s4xc7na7caKgzh8tbQIfH0eWKj00dj2O0uM45ykbSN037V9//yF97vH1tcSaH0Qc3JDd/H1RRSjmGIx8vVsDnrWxW3bkFwZs7vTfw2WTvp58u3nnx3iRafWyiSjdiIjkLbA7J3xW7gsAfDdZBoHeXtz2aXBtkVS+oFaCmMoMWWnxy+PVEwxEHNwZ02IrPlCp2GSyLV66DJG64OhTuvIyc0Oa03qVum9sdWNrWys8fKE6lBgDo8elERKBVQptdJGYy4hlhus5oys6Ht/uzSx/SJkSAgEPME6JHdHpWjMfrDV6rtSG5QtuVgiBEbvxKRoSkguf+xwppBZa7DXQm8TCYtbSfTZGG0yx8DSv/NXYqnUGlmjYSz6BZi2BfFagyD+Dan5/nNY4GwNSXdSXExRsMnXeaDcsOg31eovWj/oX+clYoBt2xjLqQZbhtGUt8fN8RIhIarM6UxTEXHKuySGdo72RK+0qtfnB2ebWEjOx73EDjlBVN/B5aDkuAixMFWIJUOOPL8++fH2E3MpMwilVlabvGyQRSj3O/04UYmkGiEYcbyQqOyP7XLbNPLbj7y9/8w5Fkpzsh3rUr8MbEyO50EImXZM2nHw9fmdH1KiacBG4/3tJ1Y4ORdY3ni9nuz7O0tcjeVCh+QUcrwX1zG4FVctzaGEuajJ8SFEL9Hy7Z1zDtY42bbE/faNx+1BCDDH0+nndAILtUZYmec5YPi+MMdAG8rU4Inlc9EjBDVf8seLgBiE1ZvL3JajTUOppLxdX+8ih3R9tgykUrcM5sOryLzof42SPWV9jkmI6ULlgJkfLgBJgVdbV0zCRhIjhYJax9QPvKpR840cAwvzV7xkIn5p2uXCIniVxDqYK1w2RsGWcX/shOicqhAMm1xoHzzd+48czrmcShBj4lZd9Pvx8eExaLM5nW14yZrrRk0JWS6QnupwrhLd/zaXfzPo9J2ZiUulFFiCqU+tbtvOMU6OY7CsEVIiZKF3ZRzDLWHqh73PiYr7LxEnLcRYACd9L1FmG0wFCW5zUjpzTScuRDin8RpKH50QFT0b+/4A9YX2D3UjheAhqpfsq2x3ZCb2oUj/8MzI1ak//iPSJ63/laiL53mivMHK6Dr5bCdRjKBu1I1B6FM4D+WZOiG/mH0yx8nU5VSDUkhpMdok5chsk7nMVU9J0ZJJpbCml+Rlv3G8vsP0D+XoDQtOKDy7UWwRg5Atwv9P2rtsyZEkSZaXWR6qZg5EVFYtZv7/+7q6MgJwM1V5cS9IHNmb7jqDWeQmMgLuMFMR5QfRpZW4rosYTphjsfASPEpiUVip4K7VCmZamG/VzY8f/6Wd7gHRAmfoIDgsnM+fnxQgP07+6+9Pvn1840xGfZx8vn4weqLUxLgmnrJSBZYMFmNJyXWkDKky/SAbwoqkTDnlAErTmLOwSPRxcV+Xhn+1kFwS0LM4ZpNyPIgR5OODMRatX1xtUMqTWp3WJz/aRb2lxxYIfZBTorg8pRaC2F2vH5jL3znWrhRJqgZSYc1FPU9dPC5XUTK2QMbkqIld8vffHAgVBxCm8qiFRxEG8b4+geCvnz+JLugROTEiSMg8WuqDepz09w8tgA3C5QGNoYflfb8wHLzyOA48Fqu/qZbglIYx2STR6fdNLJluZ794fv/GDKcezx1VrtsqAsqRNy9IrNH0JSlskorl7HSg7yiGx/ngrIU5bmJJRTKWVjyPD/09zqQBQKmVd8D1GoqgW4kGPMqB9cHV50aYDPqq2BatR8qseHHfN87io2b0PArp8vc1uf7zbxh6A+WaGWGUepK88GoDrx+k1fj+MN7vvzifH5wfH9yvSc4Hbbx5/c9PyMZR4W43KZzP600uJ//5P/4TL1kl2nKsvTiPjLHN83OSfDLGoC0jUpAyrPGm90H4ga1JmkvikAx9BpgcG+82WJ+DdC68nkQsijsJ0fse3/6QXrq/tcZgkutBG8H7fUEMPBfOj2/C2MxFTYmEVnThzmJxjYFHYHsHack5zydXQAoo58n9lX79/OC+g9o6sYJ3B8xYSfMHAlZ/YfUpG1soXQxUOBjGqw1yMbIZboVYQTYHkxWyDQklHmelW2JO5OXcyNgI4+6TWg+ud5eAJZrkfvabrpQxXtTyxPaX1HqjlIznk3LCd4N+NXIRE2bOi5JlGnZCN4Ql2rxxl8KnLYjodKCWQ79CZO2W3LB8Ev2Tj+Pg5qZvjMSRjYYugGBxXTeWMyWfjNkp9SQCfrzeHCNDbAo8iaPm/VZIlKJbNdabNeEoGU8bHGaLZA4rwxr8+W9/UI9vjLloLYDOo2bGj5+c5TuHL0YWNzb6otx/826LtvSlfjsrNQtAHDjOgxd6A0w/6BjpUSneWGFcQ4qp74+T4zTO44EHhB2kMvm8uxbl7nz8+z/4/PlJt0p6Aq1TbPL33z/5x7//IR9sLQwGz2/fiXDe9+BMB+dZ9q4wsZZUVH2ozDXLjKEVw/KJN9nQvp+FPoMVchiVfHDUQirOaJ2MYjVe1+KRFzUn7mvy98+XGEc5cffg/dcPGDeZxuiTo3xjtZu+jJwLLGivn6wklm6uD+FsTPwfGZ0T73Yzp4iN831jaXIeT33vJCIyj2+F91iQioz5fVDKZlslw/KWlXrGk1Rd9xfaVdQ3VjScxBhKaS/FweC6X0rd88zj8Z1aMr0r7lKrGVUoMwarNR7Pk7mC8yy060Xyg34NyQd/63D2RU5yg0dsGVKIrBDupHLAhPf7UupvylLKJJlWR7vBC/XxHWYHX3iq9NZkQSqVNRejvRnTgEGtB54yrd2Ak5JupWSGp5MowV2yqAfpIGwJKTEXqR4kd94T5lg8smE+ua4pg6sneh9MpqRUfXK9XsTqrKm37qCSSaTieJKDP7ljOfG+F+3VqOXk+f07wU0bTv9bvVu7X6RlPEmk88nrfTFMdjYI+hwc58kahfM8GC0YMaCYBgu17ERsWENhv5wHNoM//vhObhef11sDrJ8XsQIoHHmyLGMk/t//J1Nz5p+fnyr1j0SxTOQnnm9Sds7zoV63B9dSAGyxPcyL9MtVMWeQfJE8M9piEYyrUUvdDg5JNY/zpF0DugKAjuL8/PmTNYy2lHdz5UqaN5obJgm/TXmv+nMSBSPvUKs5EqkctNaYWVVNdpckcnOLZvvKTSl4rSiZw7juTkryy6b0pGanzW12cPj586IcjrWb5/OhNDIqRzWOzR+a/WL0F2YmCHmttD65Z9+98sBrIbmygUoyLBk2A7RsxEzn4SvvE4NBMJaJRLiC1X4TKn23sW1FCh59fb73baGdjqExeq0O6cGabKaQdmDCjAxiGsslkp+9aRdkTl2dIxcYiAlqgmQt2Nkng/H+iZcHfRm1ZqwY5/GdNSY5ZdHU+kU9D/JRud5vPCWF487GUesmnClGj+TMqb5uzknygiVj5aKROpPn45TMcCd0uyfm66bg9BVMd6774vEolBw8Hg8+KbqM5mLE4GHw/Y9/4xoNlnE8H7CC3icD5yjnLsscr6Ij1IcQYL01Rf2NydmaLsfe+ce3J2u5GEat4avz/aMIVZlQn17gbsYf//Yf3NffWCnEUrUzTCGxxJQ7xoXRqJa526T1IHmHo2AuAFWE7+Qsxz2ox4FHUI+q/fZ1s8xJJO4wak0KLXq/IR2Uo2yxgFLlHo/v9KbUrvP7hxb7RZ7ftoI+QrbCmlkzaK9PvBS9lcz4+PgQrjNVvNhWWhnROndTCrV5oqS6D8aWX/ZBsoLZVJ+8Tf5XC2rZu01T3P113+RyaL0Tmpe0ny88Z0pJpJCfOPYaxF282mRwHsYcqH827UM9F6nPTIPJFSZ541rM312llHIyxuA8C++ribyWMn02pXeZXN8eSEkUHUzRe7CIKcH73OPuuYzWm8jvnvUwhLCEVoTef98qV1/XS4Lte9DbC88H0970n4Nvf3xwHic5Jfo9gUp7d0p1sgfnkThSkTbSY9u7BoxFSbrxR0z9vithReWnbfrf3SfJM5+vF8ab7AcsxRIugCFmas6Z5ymHzjs1/PEnw26OmCScYgkrhffdwQ+cQrHAXYFEItMbY5MkkieqBSVX1jJK3v/OWtx3pzxAmptKKQeHOdlu1hKj1p6V+4LqwVyN+v07P963gqbySbMXkTTun7ufelT1WVgGBLK2pCDbWAKjpaPQ51Q5e+w4x5JY07jeg1iSch6Pb3zUTJsnf/4j8+6T74+Dj7NyZKNPiQPG6BwPhWCNsUjpxFCepRwdgsX1MTQx3bmmR60445etsIVK7dE7MRo/R4dS8JSlKjPn41n5+8ff5LR4z08ymrZGOJ4P+U97V3I7LodU7yQT4bGNhezkMspHazyOQs2JdxsYi+TGfd16M3YNswKDMX9RKHHb36VM+mC0NiT0/53DyZIqp82y/XaJ9/XGXSDnYOBWaCH3AXP7FWcjSlYp6nobvt8XnYTnY+tzKyVlsoXWL0NT3TYXk6SSYAVenEd22jQGTjoOCKEshuuGfbeLvoI0Ckc99OCeJ6WfYuHcTQONACta6SyEDvFy4nRq3b3vDB7Hwbwuer/FlTlPolRmV27nam8sZeZ18dcdmFeivznSk2RT+7d+81czLE1sQWoXaw3GnJRcdYll+EhK4P68L7InigetNZIZxZP8r8eDI39wTWdaYq3FcRykcI6nSu+7d1q/yLnwb//4k1fXZ/KMg/vzE7dGrC73xgqIITIgSHZmQS4nZpPwgpUPKoNkQwiYIQfFvYJsMFvnnktytzbx40P6ZEsc5xaOnMZZZAhIOTN+fBKxuMfAVhFdcC0KTUlxq/L8+K6WKRlz7ODaTTCINZhdLp5Yk3ap5fEQjI5ycI/G88iajK7B//znC7fgeUojPAjOM9FD0SIzxLqKqeHg+/PasQtpx3dIeDDHJMbaooEqjlIqW4Qgo9uYMKcGT9eti46UsTA+vn0n+c566Ys+F04h+W8S39+vW30kNyOkcunj5nw8iLtLvZETHoVii37ftPtirIV/YU1cxmpc6InkGXMjZ42iicV1L8ZceC4s1+2SEqyl/zafT9aYnMdJn12KpNXFLopg+s5m6Z2+gmZOyeKXziUMInzlshT1DndTD512FITBn8+T+9ZD/DXC8ZwZ4835OPFYHJ7Ij5NuotPfnkjZOfIpsmDNXLPhORH3hYVE9df9ia1JSaKy9a8UtAja+0Uab6xDQ3wlL4Vwp92N1i5m0kRc52rw7ePAojDvF5hwlrGC170or87Hn3/w+rwYpTDy5GpvMLkuSk48asHLyevduFrH8yFKvyUssuQzpnZjNMn8wo3VuyxVJfg4D67XTywXHo+TlB60ubh741GqdoNj8PgQHNy9EMn4/q0yQr1XELTWOeqT8/zAt+2w3VLmyMSc+Wqkrj5JoWntnBIpHGeh3TcJeJ6ZWhwrlbjeEhi42hHLT9wWOT8Y7S2DeDdyYveSg9m6qHv5Qeuqktam8eWHLH6gQx0Re1+5mE1Gc0sJK1oTBolUKnNBSUvPT3L8+eT6fIObHF2/9eYM6UjfP2+F8ETTL8NGkJCE5zdBlINMW5uCNoJaxNWxpQQn7SBFVB99c4QwlkEPhMPvjeyiFawY1POgh1HPypg3R0pSCdVTMQ/V+bCifJMwbE7+/vtv6uEqPyzhNukhZagI/nKz55yotWIo2HfOmzm73CoJcXfGxUqZ6zbS0sPx558PrHfampy75HMTD8nrCdfk8/OTWLemdyu4l8nc61VDEjfe7VKuzHix2lu0NhNSo79ucuJXn97nzfnxQYSTz0J7vzkf38Rf8lAvfw+olb9eneE/WQue58nrx425wqJSFtKjL4g2GGPyvge+OuU4SK4HKcVNaxftekkQ4Tt0u4onlFwRCTkftLZ4X52PZ/7l/XWTd5fZ+a+/JSggghFQUhba1IwViXJWzDOpFilqxsTX5FETpCL/8BL6svUbi+Awk6Y2mYwWrtWYe6KNyeifG4mZmJY35hSC4HW9aK1z+r3h7Yq274Gkd7G4R8OQc2oMIVRFB0sK4GpvzStyoWwnivKOkyxrSHM72tg7z7aB7EoWO4thqewS9zcOZy6JPoaitWNTz3LCOyQLjEH9MhXgjJUJNMHq46a1wVET9TwoWYegt1tysLixOMn1YCEfZ+sNW41lShjusaAZVoJantyrC5XfJs/6wDzx188fRL9FAg8TDWEDqOX9kPTqPA+uNpi2d3OEvliTq2b2ydX+Bsu7nDmJ7IzRqcm47oZbcH12jud/iNQwJK6PIR7rtRZn+VBw0tC0uS/lV+r2NIKuS2+LMEaotKSepHriez8b6LCfW2zdL0Wpz9ZwnNkvyjdIf/xJv18QLyD466//kobWTiwN9cohjMb77wZ5i7ZjKYE84CMnBs5XbIdnsNlhaG+dfKNmwjiroG7v9yA85Il1fX9H+YOxGq/7DQnqdv+/3oNvHydzBETfxuWKUgvERQ53+hgcJTFCmSSlFDDFOGqGqEuw1IOjiNg3V9DuudnRibtPbN6cj5Mxdnm6OomOrYACqVQKWSs4y/TWWY7gAWP+UhyxD2tOmgwZKltH7xp6unEPuPvFWRLpOFihoCNR4OHYlI8+RHN0l+c4StJg6/9yAv+bwwnxa8WwX6aItNZmY46OpYMRi3h90ptityE4ct3JSkG3SUzdRIKxGxamVOAhvWbvXcAtE5Yw569UvsnpYmyfZ4YeHOfBcT60wmlKzTabPD7+4OP44L4u3HSzR008jkJJzrtf9DFZy2EZ6+o8T8WN447nc+d0dFpMUtG6KEUi50EuksHtuS9eXP2GS0f77//xDS+V+Z7Y48nr/iStoJwH6z2Y9hVck7RPlRSbZYs5FUhck+E2CQtSOQg3xjXpPfjxeWsE/24UT7T2ieVD00Bzmuk2vtqNlUy1YDEUcbff1gp7sx0sbFhKDJ983lOG57W478lyYE0J4WMqrDgVzJXN6jmTSmLOhrtxHpkeF2sGNTKsDuX4xYq97o7Z3gW2jqcqsFjRkK0k9p4wiTRYC2vrVrOZsi7NmUn9iqWMWVa+5ZwCRpszzMmpYpaY0cneqfmAZfR+86wf5FJJeTJvAeU8nGwaHNajkOuDx5kZvbH6wtZg7GCtCFnCUiqMJsLGUZzk5Vf8QljauJ5ETpLpkYpMI+vG0apKr+bfFCHUo0K79UDG3KBcsUMJJSh5dHIEr/tibftVhBGWmWiyt9okaqKkxNqOjOTBmFOuxtWp4k+TtnjYcGrJ1JIUzbf2xIxMsszPO2h3cM/gvoNnTqS5yJbBE/dmr7bRFWiE4toU6qNIPkuZ6UkOi4fG/n1MxjsoObHeA0/bcJ21/2ut8frxk/THdwiR41JJlIdjob6jJUi1EC39MpIfxXgPkQ1y3oE3Sc4fcVm1u+voZ6dsPJ4nyzKjw/mAGfA4DohNQojJeTyk1318cOaF10H0i1yEl7GksimFyfEyJA65rkulZU370r0ZXcORMSdeC8VMCBrXUn/5wR1F2SMJbMk59MXTiXdnzsWzFFiNu+mS/Ph48r6bzMasTcQDjyCbylWzpDjJfNLGm/F6i2CQyx7CKEPHLRit8eqd5+NJOQ7tuI8nxcVo6kNCCY8lHbfB8+M7OSZ1+4dzyuTTtX+MbZOaX/G7cuiYJZkX6sHqkzG0Uy9H3cbsISfKmrQ5cKvMJVoD7DI7BilXPO8t7v3GdweN8f9D+E7QQ7hB29kjsQJbkxmQzKkpmK2Ts8JA76vjOOXxJLNjul3BLzOk7P8qFWJIMmamP9OBeU9I5VeKV62F6hmSb9pAglIhJ7qD1QPaTbvf5Ayz79WBSwEix7n2pvX4IVvvEQAAIABJREFUYNJYiCDnyTEPnh+VXDKP86AMrX9Scux86AHfuJXRdKNHa6wmrGeuScG+C7IdOB3Lyl2BTETm8/3G0xJXdzo1F8noHG5bjHkztthd4LKKW2WE0/vkeVaiquqoR1XcBRnatdPDFKSTSgEyi0Uthxi9C4jFWgJRTVxkiS+0aSy8ZIkjkHmYBTFvFmsP1ArDEmsG3gd9Ldn9EELkap12N2qu+hlzMM3Jrt6U8F1mvnl++6DUKp21ObnI23u3rmzSpupp4DsxYKuVlgZ3eOKoApm7O3N0iiNxe5Gon/sl3tSplVQ28a4woN/4zPh5YAE5L3rfWT4bnA6FFQJCrybzgeVELUlIzFi7ZJah3F3p1V+Zm/cmKa4598RZ7NpSMjMpTDc26JwVv3c4xxwkS8yYMuiOtbW1l26EpHGzubJD5hiYfTHHguOswj10IUvy1r+uCO4m1Q5mgvTOhc0Q6r5oopvSwdVu3GSsPmvi6srU6GOwYnKUhD1OqW16yAeZC4ETruGPU4RNMeOoD1JWb297hbBGE7+1a/dkSV9CW6LKlyKCQs7CTFhXzzoD1t0ox7GzWqYE3NmpR+U4MmYPsX7GJyVpwf54KCi3XWP/nR0rmRKCcI8wbBg2gN7wQ0Lp8/kQmcGSAoR3ao8lQ4wAg+zMqHjc8igW56zObMgPG4PZJtfsxBik5dTywXIZ1SV7NFrfvsmUmJ6IZSQWhHOcBzG1553ulJrhEh5zrCFFTSm874Elp7VOJWGmwY8ClwNYQp0iCBv7vbpGF53CdeGvtailcJyHKOzj0g52LeXnYJoEBztJ3fQSYWLhpJKIcYtt7M6KRAoj+q1B1XL1tegtuObCYjBI4hy54NbJVQn2oem+qHqZDfRhjEZs+vz7fsvJaJsMuV4cR2bhm8MsaNkav4kp0ZBHjTYMCeHXIGJSc2LMwTU6rS9GBMdRcEvcTeVBxMJNITDZNMm7rqayJh/knDXBa5PeBW5ilzcKTtUbrK9Jmp1v54dSpdZk9EZN4tvaGjjy5s1doZzngVcxYiw5zN3jmXEcWezR3n+R6Ne8FS+/1U1hhteTNW/urge2UDjO7yxrQiXmAjO4W2PF0u9PImJiazFb477aXkk4o2tQMFbQ7s64uqLkIogNo66pMDkwMp701l8xKfXg+XHyfD748drL6zPovTPvlxCSz8rd4DgLP3/8k1wSszeYDTyTU+b68RbUeLshHinJUp6gDYVVBUrLGmtJGL7DZLUGc6VvJQXO9nazAooLDxrjkgJsSJ42l2DT5oWcjVoSaynB2lPWJRo7PNM1CLOU9NaPwVkyUYTKqbVoGjoafTQMrYYsZTpiQGmB4dz9ol/XdiwFxZFEtCYsJu0KmE72xRiXeLTlYCyZMr6mreodjUFWFWLq1wOpglSYbM1fQB9dU+4mTe60wdqT5bUyuRZY8s4Sagt+63D2fus2dqkjckqMfu94EkUICBWo2PRaMrGMbos1ZCXLtZCLwFfJE+XLxbAUPupJbxm3yet9EXMIKn1kwa9M4/Q+Bp+vvyASz28f1CTw2LxfMBTrFiHXC7F4f/7giKcwhTXjLCYahbu7aHLRibkI0w7XIqg57fjxga9gDCmd2hhQCqM7DGdcPynfT9aYrHeiFknF7o6gUXOp7/GlfMcmw3HKidYXbJF7J5GqSkSQmyGlvFm86nvG2HjO1vjR/wLPBIkxGte7kS2wozI21DrClKAVi3brYPrSG258PHlfjWNHFkjp0ykG01De5Zy7MwxaHxxe+VWBLVnzvDizv5QyXkRGZFMR1urSYueMGXz/eHA3gZrHWJR8kIuiHOvjIEZiRtv0/E9KOSn1wFMi2frFJ1qzERgzJiNCpLQIbC6MqTxO4teblrV7zgj6TFKBmYDYzNheWeOeRq076c4P2SFdOSklOQmHlLjWYo6hQagJYL42Flag80mLnUW2XUzmat/YzOLVNTSzKJQkGMBvHU5CPd/d7l8/KNVMWqrNPSt+3emwlG2RcqKU2LIsfVgk7X9yLiwepN643peEDStTjsJYCS9FD4CbSPGzAQmzg2XBdV08jg/a+9bbaUycJRWSduZbfK8DuuZiLMQeNYGAy/kgYaypkpA18aXexybazcWWZDXlp8Ts265kcsXMRWeReqctOGFnLTr3MMVAXBd9NDCpjiQ010DEsb1bVRTCl95q7S/ZXGVPjKUhGaLEz/tNPg/q44NcCp9bAtjGhDKw4ZSzcN+NFeI5JZzplT71eVjKpCxNsa/FWFq6y7+j3JBSiyDMfeAZyuF7XwjZoNS0WcVOzkHyEMBtlb2kD4ov5pIQJaUH56khyxiDGfe+SMUqShh4UWQBED5ll0uyW63QHrr3IMeX4N5Z7sQ0vfU2oNx2fo7toVmb2rGXX2W7oHFjTGI01o4GYedmflVAcwysOfYQyWKiVLFYk7HVZquayI3/+5AUeTrd0d+LLcF0I7uek7UGXE3Gkd8mviPu6dwMHHVawFZFrJ2T8u2P77Smw+spUTYU2Nz2G2TobRuJ8LT7vdiSQAmLyZV86FCWnDEmNVeSwfCx8ZWVPifj6pRsWwGkErrWg+vuLJSEtsx1u5qAwqCVR78uBq56H0j5Qbg4qSyTXSqCyqKk/C++qhVGH2QzVkmsOFQZlKwBT9rpxua83o2//v5JLlsYvSY+F8QUp9STrHVZuP8xhALFlefxyOrLZpZaiBjc/cJiQQLLiSNn1pQB+26TOSBFhhW0/ianB++3qopISYv8nBjvm7HxlMnEtFEkI1qXVE07zROGAoenwZodyxVLhvvE1yKdhXEHhpHPB9kVeZgrlFrwPsUnml2mCAuFGK2h9K7kQoiUE/YMM+Zi2DZtT/mIcce+Yi9WsJreXtiOnU9ZbYHLUGHIlrdCqqnRB8uGNMuhaW+43sA2Uaw94FlUvXtoh50tGH2JjGALdz1vrLX143t2IRntrga/AnfzzlbRSkzlbOBM0SXN5Xxev2m2vu9r//QsarcPAt/L4UnKSQMXT9SPg7Ux9rEGZnIxuDujb2Lf+tp1LkrJ1KLdz5jK6SxJI/NkEi2vtdgZwrgVpieZcmcnpwdtzA2phpwrxxR7JuzUlLl38u6FvqSCXz8rJScdJ6lq/D2XJpdXlyh8vZscEGuXY/2rL5IBGgr1fGLRFT2xJtlN4Cz4ZWomFrGgng9NQOdkjMCL4UVvIHdjP73yFm6D7ozN4BE6n5IlJ+xjQZMoIhg8HqcOjylFeUztqFOtvFrjKEnT9HHrf0vtiFwUzgpdCgqs0lTcPZGqcJt4JrFIySg1kbOLpJ8Lrzkk6vfCmkPVgTmjhNowk2dUfSobxGZog6MpvtWDmhNOpodWZkepOlzwa7K+QhPSCOFCItgHNymjZc1fAvPwRG+LPuX/rT7JpbLm3G0BRKgnHxMsL44MnoqsehZ4ki7b2yQfVX326DLk1yrM6s5TiTUhRHL4IrwskqLpTSOjOTp9dDCxjuZo/J/HQf8dVHpOLOkh613q/Dn7ZvRotJ6Ss8zV34wJoUHSUQpue5pompjJvT4YHnvs78I9IG5p7HJy9Ev9QygDMRVnuWC/7vpS3u9PhQ6xyLXiKVFPmYFTNqoXxtgDnh1n8HUo2Q+hJ3kGLYJ1vbViKYo3JHRwlBVsSss2WGFY1R4zuYKQxuysdpGfp5Qqrl3lnFNL9hCKY+yLxHd5Ze5aiCcwklD+JPrUMEwDNUnmHs/Hrlb08FoY3749afcNpj1ku4XXSG687k9ixe4P9Wbv74uaE3Zm+hRIuuQtJN/gszmXINzJtw1KFQGx9H2yh14EhhbtpKy8nCVBRW+NkR3zRB9CVwaLMbV2q+dBdtvfn/9Lz7qtYmZOzZkZe0CEESE3hybspudszZ1TgiI/iJ0j4wzLjGiyvoWTShWNgsUwNLDbz2tfcJaq4XfT1NnCBbSb8kFG+E6m0+ECtTfqcWNHkCRSMYiBhaa7d7tFJ0QUwbbWnqNIJ23xm6sUeTILcwWeleabxtwTPVMdPuVna70LWxhSRcQY2jQHQk6YPuBYOiRzBXN1Sil7viYoMLawPcIfu2mP3pXm1Ae1OMsSr9Z3+RtblWGU6gImDUW16cNV+rAXfekWCr41D8z1BVssaYANjlp2SrJyPvtaAlSbepuwTA+jANdom2PamatDrlhfRDRWv/CUwJOi9MywerBCe8CVsoZkKfHFpzN2GhehgYI5nguPWqm18t7umtVvbA6e50mxxD2DEaEHNOQjZMjKl7zsDjdR6hPWrbJqyPVipjd36401EZvWnIx4tcr4UL+9IvAxduZlbO/uIlYHdHGatjkSV5grb2ap7BytU4reIOU8iKE39Nz71pKTBic5/YrtMJQ+NvbFJEeSOneYEMK8zKXVFm2pfwRyzcw+pUZbytI0zyrbQwcrlZNaVM5GCDAdMVUFDM0H1pzM96W3dJKccoxB2hmfbuC50Hf75iGvqLF2pGLZAUmxyRaiBw7i/7bm/G+mtaEf3mfwrEV/meTMpWlVSXKy363RW1dpRiZYenDdd6y7a4DkIo5r5aGdnjg8ekCUhu2k1MhZ/r02F306MSb3fWGhnAn3pIfIpZyZo1FcYnxDQanCaag8yUWokvg6rK7bb/QbZhfGxJO8hF64mzyE2b7i7k6KOfeeWM69sPbkrNlYlpkmwbzF/JX9ORs8cqHmSkcrk2iLwRdMWpBixertB4TQhNVdWZlbpG+3xNWWnD4WbchTq36oAF17t7WF/Z5gKjF8jL73brZRkIqwmwtan3Jg7AOo1c++VJN+ZngRfcI10RWrVclea3VyPSDgeynEEpUuZacW6HNJJpcMz4nWFeMgaJ3mDLbT176Co46cJPgIrenmDliO0N93bcdMDOW1rjAN1WbQt57Yy0PtxRQ1ecXalHX7lRAQ7kpkmwP3RTIJ5+dce1eKxtStk3OlnjLf6/8TPcJ/RVrKuHEWqbFa79rlg1aPXW/iNbqmvlPe3d86nO82uMei1J2ANZf2RX0JOFwroBIXmxgSDWtKGlLqYCxNonG24XSvFGZTqZJ286/Yv0mfk4U0m3zZztAz2/viqIJdzwjISfgKD8L3qN52aGpOigi3tPuzrcncZa2tqSlyKswx5CPM24w9JEivJUm4vITrYMPK2H213hAFi+C+JzUJu/FLohdGJKdUpw1dULUWZuua7KG3UsQC3+nLIWGBJ+1MJ3krdRRPkI9CG+LdZJ8qj3Y8QJBwy8JALlH6aq6scSmhy0VGSC7HEO7E0sMfJoVL3oR+Mw2qUkrkcjDmorehKgNFCxByl/ne2R3lUDzFHORkzNn3rjdznpXwhCej986xkZURBnutM0Fun2SiDc5Fe98qt0PDn+TAHLy73pqxnR1aSelNtqYufQsoxQQIY2G2qHWvwFYHm6xbl81y8TK0kklECBXjbspoTYX6C7MZjN6Yo5HQTMOX3uRMSYs13ZWyyZE7qpTMaENKpNDF9VuHcwVc18UHihMvLgWIckh2InUMiE0/CJW8a2NISlZCdM2JbUwHbKda70fTtGZQV60yZETi/bpJtjgeT+bUjtBRpuIYcpok0/i/5Cx/nTuWJTNc6yum3vYXpjJpLh0ai7lJ65q6rTXQ2mYf3B0wmgxdJq5P3GfXYCEl1oRSDgYG/Q1jMaZx1MK3P/6kdU2OCbjH0AJ7y73yDJZl4TTmZI5rl/OF0dUTedaX18egpETJThuaLKrUlKztqJURtg/HYlhh3RIHrDDxc9ZUREY+eN1/05Z22MZeF36N+3OWdBG96XIp5FwVL79bl68pOq6SWm2FJpyRljJELDO6+EERASlYBI+ii2XMSap5V1s6sIr7U1keTNHXd1jQnJOxRNxLZ1WbMpStYqht8iSiYZ9dieeA26JY0p50TUg6pOXMvF9vSlrkUvQdTJhrQNoWwlgcJe1WDNYK4UZ2/0tIMIHJCJ4d/CgScMy11UADcwUaxd4SRIxfLyrpo37ncE4Zgheu5CRP3KMra8RN/yyU7PsV7ZY94alw7Oj2o2bBj8z2GJo9yVWvOtdijk5OThtTIugkOZa7vlAzZ63g+8efeDbu96Wu1yB7oiaVIr7mVhTpEsh580FXkFPS4nkMwoJhjs9JTiLurSWv5xhrEwazMjWLtH6+lOniIZdOLgd9KkbeU2Fcl6aLphSr80hgeuiv661ErjH4bqYSShMNVm+7zJEcrwf6DDxRbdvHZudCyWQpF1ZX1EObE8uVx3Hyz58XLOVdRgyISQmw6NzvJlYPmdnfzFj0bW1iLfWSG/ZdklOqetRwJ3Im1ardYgrqEZxH5v3zh954e2i0AmpKinJYjXHfv7TRklHqAW+XSAOliLAeaGGfMTGVlkrW1u9tdF+K81DEtAgIm1qfc6H3SXKnpPiV9GWhNUVJhZLVF9+t7beuccdFToc4Rasz19yqIF3YYMROr8sla6+JyvivaHvzRDkPhS/NIetzVqy8RWzVE5oML+XPhlV4/61A3wjy8yHVyu8cTmOSdthQSk4kto506Ys1U6nTZddJruTrnBJhO1dlyGRcyo5bQx45fLLiK0bQVPIlfclHOdTrFBmssua5FM+SO8VeLtGBIPlmxuyhyBoK/YmxA2x8C+Y9SGmxmLuX1e2naeMgJuDvrUZZsII19Na0KWF+PU++yjlMh32uqZH9/zawiFjKSzkO3NSjrjHoTX28xSD6TV9JAOOQpSylIivUClobrJW0f5sLxRMkmEtvmmkqFWNJRnhdlDPpwKADN8YLQJphC/A9gY6FJamlZGHSnnGa3jjZ9Hk6tt0dGfLm/kxVAWPclPNkLnDPFIcwZ4Zc4jlLV7tsUj0zp75rC8Mt7UO65XsDDYBClkLNAwbtvjUXQCu7FWxxuvzGhLAz2oOGpvOWyNnI2eijkXIStiTAxiSyE9ZJ7rSht2U5kvbW2f81RHSXuORLHLLPhKEcU3djoZnH6I1SEjF2+2MbbrcUoPvLKrmrp9YbNr+06L9xOI+sZb5l1exrTbnpVzDX5O5TAbigPeQyiCkqme0G3UVJkD9mly9mMHQDAYRnAbd6o5aDmjPFRKVbAUGC6979ovN4ftdfemgXuFbGs4JrV6xfhYIgybt5T5BzERRsNNq4dQG5FCIrnIFcBNxtm4gzhCLWxwiSJViyRaXqGpzMQZ9BOU68v6Ro2QOQNTvJT45ykElkc2pNm21qjOvH/t2MnARX7isksEh5W6WcNZ2xXTwqzzXUeD4KMwT/Sm4EgxEOXYiVsElgtNGYc9JbcH57isMTiTV1ISpsJzF22vPY4VM5GTlNaWEt9BkpHBXLH5QsUPJ93RylaChoYKmSysJLJe6LZ1FZaZbwrCCrRdL3mUT7nyHWccryjDKDOb9CfKVh/Zoj2F7vBBpWaf85YOlZ+/IEp+JMq2pzWOqLI5HTwRyN3q9NcNw9VzLC1n7rrZ2rmnQOQobvoyp5e83JfUvKKhlrl8h9aZtgbvtFMukjeL0vatGwMkKxDAKZ/eZA6DxP6Q9NJezonXt20hpEkm/TdhKxgMOC8Vbb65Q1GcAoFVlPnLDYC/8vAbvUIDkncj05j1OLd5PTvV0viaaLpplu6Vda8PTYYmfXQnmqz8LUH/nujTV2MRK7/wqonukBY2lnRirCiOBYCKM4tztf+tgiasHddDhGUats0lb2vog+sQiR6xOQqv6dGdgK+WFXULZhOOWq0b0HYwkZYtivCkGZkHtlYEGuvoXoTt7BrGN08Eo+ne98U4gwDlsC/vj2Ha43lzdR98fk8ELPCct7EBWBRaNmXTgR+026Pbsz9BbrQxVDPU/tKGMAWdVImEgZVunXS6zYa5Bz4eMo/Px802bHOEnpgFxZFkgtm1XVeOEsD0YEvV3Ezkt1l8/UsgZvc07m/SKXiiWRLdaQhLOY8l9V1Ym4LtWYwnfPemiIR9Fbln+Vo/XIstbZzmxBIbhh8sD23hlLYoy11y1a6mivHUufuaZDkF3rJG0lwBfUkpWJWg5m1xv7tw5nLInJS8kMMqs1bCn0lpXJySnl4H43Jf7G0oc3huLBdykyd3DM7I3X601fugeP5GQrOvxunLVyVjFUx5CJu9SCzS9f4gD6vuEEpU6mkfToE08FQzBkZyngl0TOhxio8ybW0PBnLSlSxtKfZYbu4kmE8W4dyOTihEnel/Iej1M1sVyJ/r6VKWM7iHc05lpkSzAm7/75r0i94pKK/eKdnqyQa6SkjBXHTdpPvPBuQ+WPBeeCNo3iDzGaMGafWqcUTWznUH/NFp1f7SZypZzxq68suTKH9o9fg7Q1OwxJbvRA6g0vG5dmCm0Ev+LZkySY6w5Gu+TiYb+Ft/vCCB6ngppWaA6RcwaclLLWOkkDq+TKLU3b56uOMUt+uVcUtuY20isRfLSFJa3ETFwXkRlNYUkLI03Tnhrn+XjwfqmyGtd7l6V5ExEHNiX4CDOyZ9IpAcSMJVljTiw5Pnb/q5mHm3JezDQInWhaH2igmlOGrNnNWBB9qOTdVkF+V4SgDzyTUtVtXU5eP/7JbG/q8wmuYc2YkmytOeVn2z1KSmX3Tg1PwfV5cd9NEXRbhzpmo3zFf8/FdV0QUFDIS06FlQxboqMf22V/HN+4LsUQqsxZkIqGAa49W2wxsMU+XMyddJaIlOVmb0MgKDU7xFK/Qcp7dyUbUjG2uXdSaiGFUBRtDooFx3kqho6b1rse+CkL0eP51KSOSpsdbxpqjCVi+pLEVf2WJ1aYEBgAOcEacpzst0ZOiTEMWwJ3X30oMyT28C27rGh9kGuhlGNPxl1i9qK4CXPDejD7UIm7QVp5XxIRi9U1I0hoAV+PRNkzh+RjE/WkwHk8HvR7cV3s3lJtxTIB2Z6OIjdSId+d4zi4b/lsU86ktGcboaxNzRgD8L1XlY1tDHk5mY1M0WFwTdnZXlTHSB6UkphT01NLlT6HpIIxt/Fc6q9wI+5Ozom2OrloVxxTk1tm2npaZb/ElnZYKGXMfKM00d7Xi8wG010XRMSeaTiEk7/KXn7zcI7Q6gLbP3xL3vJ5qNZewRyNnIO+7V+WjVoPapJowU3G17mkOTV3mPLMuWsCGGuxNvH7eQq/udYi1RNKob1eWhM8T66747mSbFLPTCBeTB99uzqSsjlT4u5rk8QHHlKaECaBss6iSiDkdP/SlSZ0i845N+NWI/9lSBywJYAlObbkK8yr82qNNkPT4BkQhuXMjITvEnfOTkMXQMwu+kEspXKbEqmiCVyV8i7f5/aTloxZ2d9npnshpURZifv6wfH4IPniam/thufALZG80DEYQ6WydXIRWqT1W+SC2WkT2bxSMFEMxVfL4VZIx4ZXb8D0Cmljj3RISGKZfl88zoP7vni3m6M+yS4KnXngVRkr7+uF2b40QthIVpJqBg3V5pQdcY4BLhXQ2tY1rTAqhJRkKxbWbhnBybrQGdz3ouyVbHajlIOrvfnjFEztphNkSt6rH0uY66J0MnKera3iWoxYaHYrLfQKOWRiSzulyZUfJRVl9qRUVa1ZVvhTX/tMQam/2XOuMFHQ08TcqCl4mxb3vXcCSeSkpJGmNLt8c/lLiGy2bxUt5tkugdm3CH2xVRs7ym5J40mS66IMvfnbXLvfcygVrwkbE5JS0L76g7mclFzSvyXRQclGCmCK6pZzlrwwghELdw0RzLVy8cjcTW/0NQZmcjdCohz1l3E5VpCyaOaEKf/k3bAkFdRo4vrWemg/O4e+sC9EmC9G6zhfsq4kaVvOPB8Hngr/vD5Zc5JzJeXKGJCOk1IzaySu6yc+NQWfq9GaSvYxJ0fWqL/NyXEcYuTMt/I7twImeyKSbafHwDjw48DQWsVDeJPwgnkhoXCf1/W5TdEGy1mrQVo8j6RovSqPZz0qpIpxq6S839LxYszeqEC2Rc0PJppMxxikcnCmxOiDYc6YCgmKMLLJmrUWrGR4qTC7Zh4p4yhr53kWcppgBYtBcQ3fUpKOFltkL5SSeF+fjB7kapzHU1reftPb9Wuj4DXvqbkBBRzW0KTepWPdOuZMKplqTrvf1FqZw7jvwX0telP147Vso97vHM69mG8jiPm5vW6Te0rWZknWptGbfpjlX3vPUirZq6LMCWrZHwLSthIqiXOpGqCEbqfXu2mpa11hOVWPcpgyNB+PD8YKPt8XZyrU48HKQb/1du1r0UM6y9hrgrU0xj4eD8xFD5wgkFbov4l9eMXX3Yqfpr3ssiZBfDEex1MZIdtW9fHtyZw3j8cHcXfqqhpgtEbvXUydkPH6l0DaE61pvxh7R9j6ZDG2aKPwfAhG/DhPeh/UemJ7oFWA992YIeFArMVi0edFLFGEwpTP4r5dIq1hlqk1sxqMcSmaMR0c+aB+oJ4MiCH107LYYyU0YGmDlSaWEsfHN6VB90a73/vyhmGi0VEPLe73Jfg1xXdbHFVL/wSKhS9V64V7bjHEHuB5loE0gjmNkgs15z1NFpZmoszWbE55nGQzPl+ftN4hhDk9S+LxfDLbRR8LD8OsknOmMZUkEvJexgpaX6x2q3LKWZgeIJbhbNE94tfG0lB0TpNE0dmyTi36phXRIvrYFjaJQSIX2oKxtwb/nw8nIUf7WpXeLtyguDGQa0HwJqRj7RfLQ9PULIas2me9xdJSU5VS2TsuMYVshaan5YCU+BKx996wWKwhQl+YprWlSCqYU+VeE2anHk+IkzY0ylcVL3Oro4O5SFpeC1ikUNpSdHvOxXV3HYICoysLJRWDJPB0a5LtvT/fHPVLfPrV4z2Y9lXiCfVfivP8+OBxnNzta/epaXbfbymNn/S7JjTdSzmJu9MnKzKpPBnrTUfZKwnj9fqknA/mWlQWPQa1JNr9iXvmbpfAVunJmMF9vyku5c89M2aDmjPhpj32VByghzhBNYXiKcxVDucKoX1gmFK/j6Mq9m5NOCo5BVe7mHbwPE6Oo/K+O2M1tqSBuTq5FMaGVJKQAAAItUlEQVQa5JBszs4nY8hEIOG7YF85uVjGc0O3XEIUX4s1A8Zk9iaTQDFhOPugt4v73ZhzkI7vJDOIzrgn3RL9uqn1yTBpdd9bgtf7lFyx34xxcV2NhPFRPzjLwRiab6S00TpzMvp+pm27tJZxTyfZgiZp5BhLzGNNcPBasDWE1zRXytxvHU7WtsrczKZlrpdDaVt9amBja5PuCqVoaGRk7X7mxnWwiKh4TlztZrWboxZqPYnexdNZN542s6p3SqpynZQC3KypeLm0VSyGPHukIr6oQbAjA/fZSZsAp32kpG4rvhwyk0XGbTM5TW/4626s0CK/Zrk0els8Hx8a9ODMVWE1PrI+Pl+L632Rdn823oNUHkKXLC2uPSfmCGIMqi/yx0MJy3mQ6qGqY3ZSmht5scUagbSxmOgSWdT4NbdAHcn4SnLOulcBJSmPJMl3+fHxhyBTs+P5f7V3JtlxJEcQ/TFnAiR1/1NKIomqGD20sAB71Vpw01yUHwAPrzJjSHezb5G3GKm1anE7WeGUURnAJ4xEnyZy4tmEYyzEuI6hXrPh5BdET7y+EcPg32uSfsXebXzSA03J4eMtmsNhDDcrcsG0QYnhDOOVtN1GZ5fA6QgRoggLYwwwcYUeu5+5qLycKWWNog65oqQs1m1UXIb+pyE5JfzlHT68JMkqAwQnG97e+JToY5xu/CYl2f36nLQuXa+L8QhSvNLqtvynszfFizhHzIXZh0z/Zrg9jjCmnAnEbyzOfH0Vpr428tsXvG360hEfkCn1E28Rk0YrMgzL6iQ6uTGH8fHjB/m69MBLYbOYswmyxVG+OE8MJsSg0yf4Z9cwpEQdk/f7ovZKDkHibhdwYwg2HCJ3fmOOh6jyJDZHAHGCknJMhOC1Yw6hLb33lJh4jCfDdO0MUY2wK2X++/M7D06MQHDk4rChJlQ4InqOITjHTEi3It7OVXyzWUvx5zFCSIU1FTfhnF7eFBPOAm53xmj67o4aayynWDkX1UBha7e+r8xVYNvFjx//4f39wvag96Bxj5dnli0WUAxelPTRmb2DD/RlSonDuO5biI1w0tSiYu3YSkYLR4P6dr9jztFbhd3IKdMW7BUI0ZjjKSVNzseSJogbaHxSu7FWo7Axl0RqYPPz8VAf9DxbtyFfRWb2Je20rshGdAufI4REzIJXr2U4k+1wb8MZ2AqYS9TayEmRCrVW7ispiS0X0fCfPyk5Hbqj1GQxQIlR4VGr48zhosYnnw0hTPENOTv6GKxtXPnGxSKca3sSvGIwFMAUWHsSCcwqieJvLU6xb7a6bWPyHHaE5JOrBNyU2t55p7wIf2IUxpMrJvkWgieZJ8WsU8Xp2gJqdzPVwre1MRZYZ0y5LZbfBEvkomTjiaM+Kzkaw7RLzVbl2+yOmC/6DvSh8UrMoruxhEyJMZBTPgzXfVru2lmJHgsXjs/upBwVtqS9nW0SShTxz22Wd9RWWS7wXINU3lkmuNOzDT6eXQE8yxQ/eOIFzUye0y1bGGGx5iCnREiOOWCe02e2SbnfubxjxaBIxv5d78QaXPkLWfmL9HLJq+kSUuJ6UoDHs5HKjdsVM0HbRhOTNqSbEBQ7GAHcZixopkYHfUOU3GwNw43OdoFnbTKQezALtEfVKGJOmjlKSYSUcNtoS93V1g6qxCvQyqNrvNmijqFV6zcYJyhZob8lZcDo1oneMedmzs32wp94IrV1CdJNizaFiHcKrc0e9hRHNiAFUCqRNgcpFMqd6bWKKTtkfTRTuDNbWDhbQotswDnBB67MXx5ThDNhmzZ/nzCM+tTf0UavU77WDi7wqI0UPGX/ZkOopEitB7qEaAbBKZVXHritCPXlsXhpoGu6zn7UqkQtL3eK4T6nzlrgQgyQ3hQXV1uVBWw7vtzlXAEr8frCXo18F1j2K4y3tirk4JZXM2WhC1sfhy8qRtGyfdQngll7r/mnbEBBNqHV8GzuGElZLhHvYPrEqgdajBHCYq9PoYJa/XUNPoFkzkda7czHB/b8ibkblzPvXMd1L1LD7BMJyk7qWnB0NnFNxRK6QL4y9SnF0w6J6/IEW5gPLBtiCLUndlCLmFG7IFgrRHZ74F0CDBvPX1kk26nD+dklTzFQciG6SHtWem/yazqJ2mPQ1dr5IMxpivpMMXWoo0EMkj1e1zs5JcYxQEtUEDQi2RJzOHPkUsRwtY0/4gi94o58FdyxeqlR1jXkDw6Iv2aaIWymZTlhRiNufQ65pMzUahubA09nb0ftDXLCBU9OalTGEFmzwl54NtOMuyRwhTYVu9EelRAi952V4aM8C1EszqRiTJka5lRvZceAc0GnKkbvXSdtyue73ZGui8sHiZl/Z3E+6wOb64QEeVod7O3weMaYgIMQD4Ze7fnR1MqXkVd5jkrvdaSSD5ZwHrzF8Tz6wP32zvcf38EF6rPCiV8fXVF9ox8OETrFg9sKGKqDZx2k5FH4qcNcIMTMo4k+7w18SkQf2WtqRBTkQhhdjSefIiXoxJwYMWSwTSjyBkag1SeuBJwZezalaMfENkd7frBzge2oU2qlz/nydgGc9Latd3rtLB+47ku6XmAPEQXUnDnfzD4wumZvrM7XqxAD7NFlwTJJ/PqJcTCfyWnw8XjQp+GisiL70mayOVQHy0S/2TYYy5FWYrtFx2MhErfmcDhtDAOH32IYj9n59q9vh8KuTJU2Kssc2wVGfdJM/Yi3r2/4eGG+yIMbAmM0YkkS2z8flBzpbcgMHwrB68XXYt1sWdRJ5SK5Qmum56qJvvoPdyHFQn08fn0ju3VOczS7/RoLzXRbm8c72seDy+zI6N6pa5FSYW0nQjubNfWbfTbxUs7cd2a7RbPBWLIsppTpBxMqa6Iwp/XRMKsyCLRGLjfT6TYafaI9n3+7/tz+P/KhV73qVf9c/b3T81WvetU/Wq/F+apX/aH1WpyvetUfWq/F+apX/aH1WpyvetUfWq/F+apX/aH1P4A4pmO2N6l+AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3894bed987e14d0f92e03bd548968877", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "e1ZoZdYdVv0G" + }, + "source": [ + "# NMF Visualizations of expanded weights\r\n", + "\r\n", + "Non-negative matrix factorization (NMF) and other dimensionality reduction algorithms can be used to reveal the spaital structure of weights. Below we use one-sided NMF dimensionality reduction to collapse the input channels down to 3 dimensions so that we can view them as an RGB image. To make the NMF dimensionality reduction be one-sided, we apply Captum.optim's `posneg` function to make all values in the input positive." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 248 + }, + "id": "rrT2Z3HiVDPt", + "outputId": "0c014f4f-bdd4-4c9a-e665-7ccbece256d8" + }, + "source": [ + "reducer = optimviz.reducer.ChannelReducer(3, \"NMF\")\r\n", + "\r\n", + "# Make the input positive for one-sided NMF\r\n", + "W_3a_3b_posneg = optimviz.reducer.posneg(W_3a_3b, dim=1)\r\n", + "\r\n", + "W_nmf = reducer.fit_transform(W_3a_3b_posneg[320, ...])\r\n", + "W_nmf = W_nmf / W_nmf.max()\r\n", + "show(W_nmf)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAADp0lEQVR4nO3YMWoVYRiG0TsmCAZUxNhoJ24gRGystbKzchUuw84luAVrGxtBRMwGtLCwsBJBRQNBxw3chDsY8j/COeV8zds8/DDTPM8roOfc6AHAeuKEKHFClDghSpwQtX3S8fale//Nr9yDw8ejJyxy8ejB6AmLfL/6fPSEje3/eDp6wiLvDl9N6757OSFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6ImuZ5PvZ4NE3HH2MOVjdGT1hkb3Vn9IRFXq6ujJ6wsa3Vs9ETFrk/z9O6715OiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0RN8zwfe7y7Px1/jPm4N3rBMpd/bo2esMjum/OjJ2xs5+jX6AmLvPg0T+u+ezkhSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiNo+6fj60ZWz2vHvrn0dvWCRzw9/j56wzJOd0Qs29+Hm6AWnwssJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihKjtE6+3vp3RjH83vR+9YJnp7egFy/zZ/TJ6wuauXxi94FR4OSFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6ImuZ5Hr0BWMPLCVHihChxQpQ4IUqcECVOiPoLNE0znAiOBdAAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xR3M4v1y367s" + }, + "source": [ + "Using the weights above, we can see how that they match the structure of the target neurons when they are visualized." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 298, + "referenced_widgets": [ + "b588cd0a794e42f789729de0182f1723", + "81fe4386a7ea40dda821ebf7eca095bc", + "7fd03615817f4e5b8996c1826fbc3e36", + "924be6da1cf943c4b3010c43919f96d3", + "3a01f27740754bdbb68bee7bcd0f2ca5", + "be742d9de0a64f21837d019cabb1081b", + "6675818472864b579393dac79d1f235d", + "b7fc8160950d41b6a73381f6308b88d8" + ] + }, + "id": "mgzEU3Iu2R5Y", + "outputId": "f1ae425b-3b71-471e-f8e2-1ecdedf2fd86" + }, + "source": [ + "visualize_activations(model, model.mixed3b, 320)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b588cd0a794e42f789729de0182f1723", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lyur-Elwddv6" + }, + "source": [ + "Seeing how different neurons & their weights compare to each other can also be interesting." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 479 + }, + "id": "SeM38ex_dcgv", + "outputId": "28ef4f8f-bda5-4604-cad1-ea3ff228b777" + }, + "source": [ + "units = list(range(320, 340))\r\n", + "\r\n", + "A = []\r\n", + "for i in range(320, 340):\r\n", + " x_out = vis_multi(model, model.mixed3b, i)\r\n", + " A.append(x_out.squeeze(0).detach())\r\n", + "\r\n", + "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", + "show(grid_img)\r\n", + "\r\n", + "A = []\r\n", + "for i in range(320, 340):\r\n", + " W_nmf = reducer.fit_transform(W_3a_3b_posneg[i, ...])\r\n", + " W_nmf = W_nmf / W_nmf.max()\r\n", + " A.append(W_nmf)\r\n", + "\r\n", + "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", + "show(grid_img)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CgumXN3krbpu" + }, + "source": [ + "One-sided NMF dimensionality reduction can also be used to describe multiple related neurons with a small number of factors. Below we demonstrate this with high-low frequency detectors. The weights have one side corrresponding to high frequency and another to low." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "GQJufN1DrYYK" + }, + "source": [ + "W_p2_3a = optimviz.circuits.get_expanded_weights(model, model.pool2, model.mixed3a, 5)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "3u0pjw04rgY6", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 455 + }, + "outputId": "0dcbfd12-50de-425f-f32c-35aa6955ece0" + }, + "source": [ + "highlow_units = [110, 180, 153, 106, 112, 186, 132, 136, 117, 113, 108, 70, 86, 88, 160]\r\n", + "\r\n", + "# Extract the units that we want to view\r\n", + "W_hl = W_p2_3a[highlow_units, ...]\r\n", + "\r\n", + "# Make the input positive for one-sided NMF\r\n", + "W_posneg = optimviz.reducer.posneg(W_hl, dim=0)\r\n", + "\r\n", + "reducer = optimviz.reducer.ChannelReducer(2, \"NMF\")\r\n", + "W_nmf = reducer.fit_transform(W_posneg)\r\n", + "\r\n", + "W_nmf = W_nmf / W_nmf.max()\r\n", + "W_nmf = W_nmf[:len(highlow_units)] - W_nmf[len(highlow_units):]\r\n", + "\r\n", + "A = []\r\n", + "for i in highlow_units:\r\n", + " x_out = vis_multi(model, model.conv3, i)\r\n", + " A.append(x_out.squeeze(0).detach())\r\n", + "\r\n", + "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", + "show(grid_img)\r\n", + "\r\n", + "A = []\r\n", + "for i in range(len(highlow_units)):\r\n", + " W_x = optimviz.weights_to_heatmap_2d(W_nmf[i, 0, ...] / W_nmf[i, 0, ...].max())\r\n", + " A.append(W_x)\r\n", + "\r\n", + "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", + "show(grid_img)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + } + ] +} \ No newline at end of file